From b4b991e66f0a1fd0e517ed7f038129350a7ad6ce Mon Sep 17 00:00:00 2001 From: surechen Date: Tue, 23 Jul 2024 10:24:45 +0800 Subject: [PATCH 01/79] Suggest adding Result return type for associated method in E0277. For following: ```rust struct A; impl A { fn test4(&self) { let mut _file = File::create("foo.txt")?; //~^ ERROR the `?` operator can only be used in a method } ``` Suggest: ```rust impl A { fn test4(&self) -> Result<(), Box> { let mut _file = File::create("foo.txt")?; //~^ ERROR the `?` operator can only be used in a method Ok(()) } } ``` For #125997 --- .../src/error_reporting/traits/suggestions.rs | 41 +++++++++++++++--- ...turn-from-residual-sugg-issue-125997.fixed | 19 ++++++++ .../return-from-residual-sugg-issue-125997.rs | 15 +++++++ ...urn-from-residual-sugg-issue-125997.stderr | 43 ++++++++++++++++++- 4 files changed, 111 insertions(+), 7 deletions(-) diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs index 885216e62165..9b949323a360 100644 --- a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs +++ b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs @@ -4612,6 +4612,9 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> { }) } + // For E0277 when use `?` operator, suggest adding + // a suitable return type in `FnSig`, and a default + // return value at the end of the function's body. pub(super) fn suggest_add_result_as_return_type( &self, obligation: &PredicateObligation<'tcx>, @@ -4622,19 +4625,47 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> { return; } + // Only suggest for local function and associated method, + // because this suggest adding both return type in + // the `FnSig` and a default return value in the body, so it + // is not suitable for foreign function without a local body, + // and neighter for trait method which may be also implemented + // in other place, so shouldn't change it's FnSig. + fn choose_suggest_items<'tcx, 'hir>( + tcx: TyCtxt<'tcx>, + node: hir::Node<'hir>, + ) -> Option<(&'hir hir::FnDecl<'hir>, hir::BodyId)> { + match node { + hir::Node::Item(item) if let hir::ItemKind::Fn(sig, _, body_id) = item.kind => { + Some((sig.decl, body_id)) + } + hir::Node::ImplItem(item) + if let hir::ImplItemKind::Fn(sig, body_id) = item.kind => + { + let parent = tcx.parent_hir_node(item.hir_id()); + if let hir::Node::Item(item) = parent + && let hir::ItemKind::Impl(imp) = item.kind + && imp.of_trait.is_none() + { + return Some((sig.decl, body_id)); + } + None + } + _ => None, + } + } + let node = self.tcx.hir_node_by_def_id(obligation.cause.body_id); - if let hir::Node::Item(item) = node - && let hir::ItemKind::Fn(sig, _, body_id) = item.kind - && let hir::FnRetTy::DefaultReturn(ret_span) = sig.decl.output + if let Some((fn_decl, body_id)) = choose_suggest_items(self.tcx, node) + && let hir::FnRetTy::DefaultReturn(ret_span) = fn_decl.output && self.tcx.is_diagnostic_item(sym::FromResidual, trait_pred.def_id()) && trait_pred.skip_binder().trait_ref.args.type_at(0).is_unit() && let ty::Adt(def, _) = trait_pred.skip_binder().trait_ref.args.type_at(1).kind() && self.tcx.is_diagnostic_item(sym::Result, def.did()) { - let body = self.tcx.hir().body(body_id); let mut sugg_spans = vec![(ret_span, " -> Result<(), Box>".to_string())]; - + let body = self.tcx.hir().body(body_id); if let hir::ExprKind::Block(b, _) = body.value.kind && b.expr.is_none() { diff --git a/tests/ui/return/return-from-residual-sugg-issue-125997.fixed b/tests/ui/return/return-from-residual-sugg-issue-125997.fixed index b2eca69aeb90..a5a133998259 100644 --- a/tests/ui/return/return-from-residual-sugg-issue-125997.fixed +++ b/tests/ui/return/return-from-residual-sugg-issue-125997.fixed @@ -33,6 +33,25 @@ macro_rules! mac { }; } +struct A; + +impl A { + fn test4(&self) -> Result<(), Box> { + let mut _file = File::create("foo.txt")?; + //~^ ERROR the `?` operator can only be used in a method + + Ok(()) +} + + fn test5(&self) -> Result<(), Box> { + let mut _file = File::create("foo.txt")?; + //~^ ERROR the `?` operator can only be used in a method + println!(); + + Ok(()) +} +} + fn main() -> Result<(), Box> { let mut _file = File::create("foo.txt")?; //~^ ERROR the `?` operator can only be used in a function diff --git a/tests/ui/return/return-from-residual-sugg-issue-125997.rs b/tests/ui/return/return-from-residual-sugg-issue-125997.rs index dd8550a388b8..30ca27eae45e 100644 --- a/tests/ui/return/return-from-residual-sugg-issue-125997.rs +++ b/tests/ui/return/return-from-residual-sugg-issue-125997.rs @@ -27,6 +27,21 @@ macro_rules! mac { }; } +struct A; + +impl A { + fn test4(&self) { + let mut _file = File::create("foo.txt")?; + //~^ ERROR the `?` operator can only be used in a method + } + + fn test5(&self) { + let mut _file = File::create("foo.txt")?; + //~^ ERROR the `?` operator can only be used in a method + println!(); + } +} + fn main() { let mut _file = File::create("foo.txt")?; //~^ ERROR the `?` operator can only be used in a function diff --git a/tests/ui/return/return-from-residual-sugg-issue-125997.stderr b/tests/ui/return/return-from-residual-sugg-issue-125997.stderr index ef938f0213df..a59f38c2ec64 100644 --- a/tests/ui/return/return-from-residual-sugg-issue-125997.stderr +++ b/tests/ui/return/return-from-residual-sugg-issue-125997.stderr @@ -37,8 +37,47 @@ LL + Ok(()) LL + } | +error[E0277]: the `?` operator can only be used in a method that returns `Result` or `Option` (or another type that implements `FromResidual`) + --> $DIR/return-from-residual-sugg-issue-125997.rs:34:48 + | +LL | fn test4(&self) { + | --------------- this function should return `Result` or `Option` to accept `?` +LL | let mut _file = File::create("foo.txt")?; + | ^ cannot use the `?` operator in a method that returns `()` + | + = help: the trait `FromResidual>` is not implemented for `()` +help: consider adding return type + | +LL ~ fn test4(&self) -> Result<(), Box> { +LL | let mut _file = File::create("foo.txt")?; +LL | +LL ~ +LL + Ok(()) +LL + } + | + +error[E0277]: the `?` operator can only be used in a method that returns `Result` or `Option` (or another type that implements `FromResidual`) + --> $DIR/return-from-residual-sugg-issue-125997.rs:39:48 + | +LL | fn test5(&self) { + | --------------- this function should return `Result` or `Option` to accept `?` +LL | let mut _file = File::create("foo.txt")?; + | ^ cannot use the `?` operator in a method that returns `()` + | + = help: the trait `FromResidual>` is not implemented for `()` +help: consider adding return type + | +LL ~ fn test5(&self) -> Result<(), Box> { +LL | let mut _file = File::create("foo.txt")?; +LL | +LL | println!(); +LL ~ +LL + Ok(()) +LL + } + | + error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`) - --> $DIR/return-from-residual-sugg-issue-125997.rs:31:44 + --> $DIR/return-from-residual-sugg-issue-125997.rs:46:44 | LL | fn main() { | --------- this function should return `Result` or `Option` to accept `?` @@ -81,6 +120,6 @@ LL + Ok(()) LL + } | -error: aborting due to 4 previous errors +error: aborting due to 6 previous errors For more information about this error, try `rustc --explain E0277`. From ec921db289ea87fd4030cb7f8a70f6ba3a31c2c7 Mon Sep 17 00:00:00 2001 From: Pavel Grigorenko Date: Sun, 23 Jun 2024 22:11:35 +0300 Subject: [PATCH 02/79] impl CloneToUninit for str and CStr --- library/core/src/clone.rs | 21 +++++++++++++++++++ library/core/tests/clone.rs | 40 +++++++++++++++++++++++++++++++++++++ 2 files changed, 61 insertions(+) diff --git a/library/core/src/clone.rs b/library/core/src/clone.rs index 76a89eaaff86..409fd2746f58 100644 --- a/library/core/src/clone.rs +++ b/library/core/src/clone.rs @@ -346,6 +346,27 @@ unsafe impl CloneToUninit for [T] { } } +#[unstable(feature = "clone_to_uninit", issue = "126799")] +unsafe impl CloneToUninit for str { + #[cfg_attr(debug_assertions, track_caller)] + unsafe fn clone_to_uninit(&self, dst: *mut Self) { + // SAFETY: str is just a [u8] with UTF-8 invariant + unsafe { self.as_bytes().clone_to_uninit(dst as *mut [u8]) } + } +} + +#[unstable(feature = "clone_to_uninit", issue = "126799")] +unsafe impl CloneToUninit for crate::ffi::CStr { + #[cfg_attr(debug_assertions, track_caller)] + unsafe fn clone_to_uninit(&self, dst: *mut Self) { + // SAFETY: For now, CStr is just a #[repr(trasnsparent)] [c_char] with some invariants. + // And we can cast [c_char] to [u8] on all supported platforms (see: to_bytes_with_nul). + // The pointer metadata properly preserves the length (NUL included). + // See: `cstr_metadata_is_length_with_nul` in tests. + unsafe { self.to_bytes_with_nul().clone_to_uninit(dst as *mut [u8]) } + } +} + /// Ownership of a collection of values stored in a non-owned `[MaybeUninit]`, some of which /// are not yet initialized. This is sort of like a `Vec` that doesn't own its allocation. /// Its responsibility is to provide cleanup on unwind by dropping the values that *are* diff --git a/library/core/tests/clone.rs b/library/core/tests/clone.rs index b7130f16f879..71a328733b7c 100644 --- a/library/core/tests/clone.rs +++ b/library/core/tests/clone.rs @@ -1,5 +1,7 @@ use core::clone::CloneToUninit; +use core::ffi::CStr; use core::mem::MaybeUninit; +use core::ptr; #[test] #[allow(suspicious_double_ref_op)] @@ -81,3 +83,41 @@ fn test_clone_to_uninit_slice_drops_on_panic() { drop(a); assert_eq!(COUNTER.load(Relaxed), 0); } + +#[test] +fn test_clone_to_uninit_str() { + let a = "hello"; + + let mut storage: MaybeUninit<[u8; 5]> = MaybeUninit::uninit(); + unsafe { a.clone_to_uninit(storage.as_mut_ptr() as *mut [u8] as *mut str) }; + assert_eq!(a.as_bytes(), unsafe { storage.assume_init() }.as_slice()); + + let mut b: Box = "world".into(); + assert_eq!(a.len(), b.len()); + assert_ne!(a, &*b); + unsafe { a.clone_to_uninit(ptr::from_mut::(&mut b)) }; + assert_eq!(a, &*b); +} + +#[test] +fn test_clone_to_uninit_cstr() { + let a = c"hello"; + + let mut storage: MaybeUninit<[u8; 6]> = MaybeUninit::uninit(); + unsafe { a.clone_to_uninit(storage.as_mut_ptr() as *mut [u8] as *mut CStr) }; + assert_eq!(a.to_bytes_with_nul(), unsafe { storage.assume_init() }.as_slice()); + + let mut b: Box = c"world".into(); + assert_eq!(a.count_bytes(), b.count_bytes()); + assert_ne!(a, &*b); + unsafe { a.clone_to_uninit(ptr::from_mut::(&mut b)) }; + assert_eq!(a, &*b); +} + +#[test] +fn cstr_metadata_is_length_with_nul() { + let s: &CStr = c"abcdef"; + let p: *const CStr = ptr::from_ref(s); + let bytes: *const [u8] = p as *const [u8]; + assert_eq!(s.to_bytes_with_nul().len(), bytes.len()); +} From afabc583f7f646d45f506263a1c331383ebdc252 Mon Sep 17 00:00:00 2001 From: Pavel Grigorenko Date: Sun, 23 Jun 2024 23:05:10 +0300 Subject: [PATCH 03/79] impl CloneToUninit for Path and OsStr --- library/std/src/ffi/os_str.rs | 12 ++++++++++++ library/std/src/ffi/os_str/tests.rs | 17 +++++++++++++++++ library/std/src/lib.rs | 1 + library/std/src/path.rs | 11 +++++++++++ library/std/src/path/tests.rs | 19 +++++++++++++++++++ library/std/src/sys/os_str/bytes.rs | 12 ++++++++++++ library/std/src/sys/os_str/wtf8.rs | 12 ++++++++++++ library/std/src/sys_common/wtf8.rs | 11 +++++++++++ 8 files changed, 95 insertions(+) diff --git a/library/std/src/ffi/os_str.rs b/library/std/src/ffi/os_str.rs index a501bcc98cf3..f68ea3c562a5 100644 --- a/library/std/src/ffi/os_str.rs +++ b/library/std/src/ffi/os_str.rs @@ -3,10 +3,13 @@ #[cfg(test)] mod tests; +use core::clone::CloneToUninit; + use crate::borrow::{Borrow, Cow}; use crate::collections::TryReserveError; use crate::hash::{Hash, Hasher}; use crate::ops::{self, Range}; +use crate::ptr::addr_of_mut; use crate::rc::Rc; use crate::str::FromStr; use crate::sync::Arc; @@ -1261,6 +1264,15 @@ impl Clone for Box { } } +#[unstable(feature = "clone_to_uninit", issue = "126799")] +unsafe impl CloneToUninit for OsStr { + #[cfg_attr(debug_assertions, track_caller)] + unsafe fn clone_to_uninit(&self, dst: *mut Self) { + // SAFETY: we're just a wrapper around a platform-specific Slice + unsafe { self.inner.clone_to_uninit(addr_of_mut!((*dst).inner)) } + } +} + #[stable(feature = "shared_from_slice2", since = "1.24.0")] impl From for Arc { /// Converts an [`OsString`] into an [Arc]<[OsStr]> by moving the [`OsString`] diff --git a/library/std/src/ffi/os_str/tests.rs b/library/std/src/ffi/os_str/tests.rs index 5b39b9e34d8c..67147934b4db 100644 --- a/library/std/src/ffi/os_str/tests.rs +++ b/library/std/src/ffi/os_str/tests.rs @@ -1,4 +1,6 @@ use super::*; +use crate::mem::MaybeUninit; +use crate::ptr; #[test] fn test_os_string_with_capacity() { @@ -286,3 +288,18 @@ fn slice_surrogate_edge() { assert_eq!(post_crab.slice_encoded_bytes(..4), "🦀"); assert_eq!(post_crab.slice_encoded_bytes(4..), surrogate); } + +#[test] +fn clone_to_uninit() { + let a = OsStr::new("hello.txt"); + + let mut storage = vec![MaybeUninit::::uninit(); size_of_val::(a)]; + unsafe { a.clone_to_uninit(ptr::from_mut::<[_]>(storage.as_mut_slice()) as *mut OsStr) }; + assert_eq!(a.as_encoded_bytes(), unsafe { MaybeUninit::slice_assume_init_ref(&storage) }); + + let mut b: Box = OsStr::new("world.exe").into(); + assert_eq!(size_of_val::(a), size_of_val::(&b)); + assert_ne!(a, &*b); + unsafe { a.clone_to_uninit(ptr::from_mut::(&mut b)) }; + assert_eq!(a, &*b); +} diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs index ee6f5a6f3c0d..5cc6376a32d7 100644 --- a/library/std/src/lib.rs +++ b/library/std/src/lib.rs @@ -323,6 +323,7 @@ // tidy-alphabetical-start #![feature(c_str_module)] #![feature(char_internals)] +#![feature(clone_to_uninit)] #![feature(core_intrinsics)] #![feature(core_io_borrowed_buf)] #![feature(duration_constants)] diff --git a/library/std/src/path.rs b/library/std/src/path.rs index 80163667636a..d6c78883f280 100644 --- a/library/std/src/path.rs +++ b/library/std/src/path.rs @@ -70,6 +70,8 @@ #[cfg(test)] mod tests; +use core::clone::CloneToUninit; + use crate::borrow::{Borrow, Cow}; use crate::collections::TryReserveError; use crate::error::Error; @@ -3109,6 +3111,15 @@ impl Path { } } +#[unstable(feature = "clone_to_uninit", issue = "126799")] +unsafe impl CloneToUninit for Path { + #[cfg_attr(debug_assertions, track_caller)] + unsafe fn clone_to_uninit(&self, dst: *mut Self) { + // SAFETY: Path is just a wrapper around OsStr + unsafe { self.inner.clone_to_uninit(core::ptr::addr_of_mut!((*dst).inner)) } + } +} + #[stable(feature = "rust1", since = "1.0.0")] impl AsRef for Path { #[inline] diff --git a/library/std/src/path/tests.rs b/library/std/src/path/tests.rs index a12e42cba0c5..6436872087d6 100644 --- a/library/std/src/path/tests.rs +++ b/library/std/src/path/tests.rs @@ -3,6 +3,8 @@ use core::hint::black_box; use super::*; use crate::collections::{BTreeSet, HashSet}; use crate::hash::DefaultHasher; +use crate::mem::MaybeUninit; +use crate::ptr; #[allow(unknown_lints, unused_macro_rules)] macro_rules! t ( @@ -2054,3 +2056,20 @@ fn bench_hash_path_long(b: &mut test::Bencher) { black_box(hasher.finish()); } + +#[test] +fn clone_to_uninit() { + let a = Path::new("hello.txt"); + + let mut storage = vec![MaybeUninit::::uninit(); size_of_val::(a)]; + unsafe { a.clone_to_uninit(ptr::from_mut::<[_]>(storage.as_mut_slice()) as *mut Path) }; + assert_eq!(a.as_os_str().as_encoded_bytes(), unsafe { + MaybeUninit::slice_assume_init_ref(&storage) + }); + + let mut b: Box = Path::new("world.exe").into(); + assert_eq!(size_of_val::(a), size_of_val::(&b)); + assert_ne!(a, &*b); + unsafe { a.clone_to_uninit(ptr::from_mut::(&mut b)) }; + assert_eq!(a, &*b); +} diff --git a/library/std/src/sys/os_str/bytes.rs b/library/std/src/sys/os_str/bytes.rs index 0f8bd6453528..8529207366e9 100644 --- a/library/std/src/sys/os_str/bytes.rs +++ b/library/std/src/sys/os_str/bytes.rs @@ -1,6 +1,9 @@ //! The underlying OsString/OsStr implementation on Unix and many other //! systems: just a `Vec`/`[u8]`. +use core::clone::CloneToUninit; +use core::ptr::addr_of_mut; + use crate::borrow::Cow; use crate::collections::TryReserveError; use crate::fmt::Write; @@ -345,3 +348,12 @@ impl Slice { self.inner.eq_ignore_ascii_case(&other.inner) } } + +#[unstable(feature = "clone_to_uninit", issue = "126799")] +unsafe impl CloneToUninit for Slice { + #[cfg_attr(debug_assertions, track_caller)] + unsafe fn clone_to_uninit(&self, dst: *mut Self) { + // SAFETY: we're just a wrapper around [u8] + unsafe { self.inner.clone_to_uninit(addr_of_mut!((*dst).inner)) } + } +} diff --git a/library/std/src/sys/os_str/wtf8.rs b/library/std/src/sys/os_str/wtf8.rs index ed975ba58b5e..e5755a4b8744 100644 --- a/library/std/src/sys/os_str/wtf8.rs +++ b/library/std/src/sys/os_str/wtf8.rs @@ -1,5 +1,8 @@ //! The underlying OsString/OsStr implementation on Windows is a //! wrapper around the "WTF-8" encoding; see the `wtf8` module for more. +use core::clone::CloneToUninit; +use core::ptr::addr_of_mut; + use crate::borrow::Cow; use crate::collections::TryReserveError; use crate::rc::Rc; @@ -268,3 +271,12 @@ impl Slice { self.inner.eq_ignore_ascii_case(&other.inner) } } + +#[unstable(feature = "clone_to_uninit", issue = "126799")] +unsafe impl CloneToUninit for Slice { + #[cfg_attr(debug_assertions, track_caller)] + unsafe fn clone_to_uninit(&self, dst: *mut Self) { + // SAFETY: we're just a wrapper around Wtf8 + unsafe { self.inner.clone_to_uninit(addr_of_mut!((*dst).inner)) } + } +} diff --git a/library/std/src/sys_common/wtf8.rs b/library/std/src/sys_common/wtf8.rs index 277c9506febb..2bdeff78ddfd 100644 --- a/library/std/src/sys_common/wtf8.rs +++ b/library/std/src/sys_common/wtf8.rs @@ -19,12 +19,14 @@ mod tests; use core::char::{encode_utf16_raw, encode_utf8_raw}; +use core::clone::CloneToUninit; use core::str::next_code_point; use crate::borrow::Cow; use crate::collections::TryReserveError; use crate::hash::{Hash, Hasher}; use crate::iter::FusedIterator; +use crate::ptr::addr_of_mut; use crate::rc::Rc; use crate::sync::Arc; use crate::sys_common::AsInner; @@ -1046,3 +1048,12 @@ impl Hash for Wtf8 { 0xfeu8.hash(state) } } + +#[unstable(feature = "clone_to_uninit", issue = "126799")] +unsafe impl CloneToUninit for Wtf8 { + #[cfg_attr(debug_assertions, track_caller)] + unsafe fn clone_to_uninit(&self, dst: *mut Self) { + // SAFETY: we're just a wrapper around [u8] + unsafe { self.bytes.clone_to_uninit(addr_of_mut!((*dst).bytes)) } + } +} From dbc13fb309f3a1539e8bb1cdeeb5fbb2e3eaaa43 Mon Sep 17 00:00:00 2001 From: Pavel Grigorenko Date: Mon, 24 Jun 2024 18:09:27 +0300 Subject: [PATCH 04/79] Sparkle some attributes over `CloneToUninit` stuff --- library/core/src/clone.rs | 7 +++++++ library/std/src/ffi/os_str.rs | 1 + library/std/src/path.rs | 1 + library/std/src/sys/os_str/bytes.rs | 1 + library/std/src/sys/os_str/wtf8.rs | 1 + library/std/src/sys_common/wtf8.rs | 1 + 6 files changed, 12 insertions(+) diff --git a/library/core/src/clone.rs b/library/core/src/clone.rs index 409fd2746f58..88f7990c017d 100644 --- a/library/core/src/clone.rs +++ b/library/core/src/clone.rs @@ -272,6 +272,7 @@ pub unsafe trait CloneToUninit { #[unstable(feature = "clone_to_uninit", issue = "126799")] unsafe impl CloneToUninit for T { + #[inline] default unsafe fn clone_to_uninit(&self, dst: *mut Self) { // SAFETY: The safety conditions of clone_to_uninit() are a superset of those of // ptr::write(). @@ -285,8 +286,10 @@ unsafe impl CloneToUninit for T { // Specialized implementation for types that are [`Copy`], not just [`Clone`], // and can therefore be copied bitwise. +#[doc(hidden)] #[unstable(feature = "clone_to_uninit", issue = "126799")] unsafe impl CloneToUninit for T { + #[inline] unsafe fn clone_to_uninit(&self, dst: *mut Self) { // SAFETY: The safety conditions of clone_to_uninit() are a superset of those of // ptr::copy_nonoverlapping(). @@ -298,6 +301,7 @@ unsafe impl CloneToUninit for T { #[unstable(feature = "clone_to_uninit", issue = "126799")] unsafe impl CloneToUninit for [T] { + #[inline] #[cfg_attr(debug_assertions, track_caller)] default unsafe fn clone_to_uninit(&self, dst: *mut Self) { let len = self.len(); @@ -326,8 +330,10 @@ unsafe impl CloneToUninit for [T] { } } +#[doc(hidden)] #[unstable(feature = "clone_to_uninit", issue = "126799")] unsafe impl CloneToUninit for [T] { + #[inline] #[cfg_attr(debug_assertions, track_caller)] unsafe fn clone_to_uninit(&self, dst: *mut Self) { let len = self.len(); @@ -348,6 +354,7 @@ unsafe impl CloneToUninit for [T] { #[unstable(feature = "clone_to_uninit", issue = "126799")] unsafe impl CloneToUninit for str { + #[inline] #[cfg_attr(debug_assertions, track_caller)] unsafe fn clone_to_uninit(&self, dst: *mut Self) { // SAFETY: str is just a [u8] with UTF-8 invariant diff --git a/library/std/src/ffi/os_str.rs b/library/std/src/ffi/os_str.rs index f68ea3c562a5..918eec2d0d8e 100644 --- a/library/std/src/ffi/os_str.rs +++ b/library/std/src/ffi/os_str.rs @@ -1266,6 +1266,7 @@ impl Clone for Box { #[unstable(feature = "clone_to_uninit", issue = "126799")] unsafe impl CloneToUninit for OsStr { + #[inline] #[cfg_attr(debug_assertions, track_caller)] unsafe fn clone_to_uninit(&self, dst: *mut Self) { // SAFETY: we're just a wrapper around a platform-specific Slice diff --git a/library/std/src/path.rs b/library/std/src/path.rs index d6c78883f280..9eaa0e01c2c0 100644 --- a/library/std/src/path.rs +++ b/library/std/src/path.rs @@ -3113,6 +3113,7 @@ impl Path { #[unstable(feature = "clone_to_uninit", issue = "126799")] unsafe impl CloneToUninit for Path { + #[inline] #[cfg_attr(debug_assertions, track_caller)] unsafe fn clone_to_uninit(&self, dst: *mut Self) { // SAFETY: Path is just a wrapper around OsStr diff --git a/library/std/src/sys/os_str/bytes.rs b/library/std/src/sys/os_str/bytes.rs index 8529207366e9..992767211d08 100644 --- a/library/std/src/sys/os_str/bytes.rs +++ b/library/std/src/sys/os_str/bytes.rs @@ -351,6 +351,7 @@ impl Slice { #[unstable(feature = "clone_to_uninit", issue = "126799")] unsafe impl CloneToUninit for Slice { + #[inline] #[cfg_attr(debug_assertions, track_caller)] unsafe fn clone_to_uninit(&self, dst: *mut Self) { // SAFETY: we're just a wrapper around [u8] diff --git a/library/std/src/sys/os_str/wtf8.rs b/library/std/src/sys/os_str/wtf8.rs index e5755a4b8744..433237aa6e7b 100644 --- a/library/std/src/sys/os_str/wtf8.rs +++ b/library/std/src/sys/os_str/wtf8.rs @@ -274,6 +274,7 @@ impl Slice { #[unstable(feature = "clone_to_uninit", issue = "126799")] unsafe impl CloneToUninit for Slice { + #[inline] #[cfg_attr(debug_assertions, track_caller)] unsafe fn clone_to_uninit(&self, dst: *mut Self) { // SAFETY: we're just a wrapper around Wtf8 diff --git a/library/std/src/sys_common/wtf8.rs b/library/std/src/sys_common/wtf8.rs index 2bdeff78ddfd..063451ad54e1 100644 --- a/library/std/src/sys_common/wtf8.rs +++ b/library/std/src/sys_common/wtf8.rs @@ -1051,6 +1051,7 @@ impl Hash for Wtf8 { #[unstable(feature = "clone_to_uninit", issue = "126799")] unsafe impl CloneToUninit for Wtf8 { + #[inline] #[cfg_attr(debug_assertions, track_caller)] unsafe fn clone_to_uninit(&self, dst: *mut Self) { // SAFETY: we're just a wrapper around [u8] From 110c273f4fb40c318be59a557ba90314fbbc42a6 Mon Sep 17 00:00:00 2001 From: Pavel Grigorenko Date: Wed, 26 Jun 2024 02:22:07 +0300 Subject: [PATCH 05/79] CloneToUninit: use a private specialization trait and move implementation details into a submodule --- library/core/src/clone.rs | 123 ++--------------------------- library/core/src/clone/uninit.rs | 128 +++++++++++++++++++++++++++++++ 2 files changed, 134 insertions(+), 117 deletions(-) create mode 100644 library/core/src/clone/uninit.rs diff --git a/library/core/src/clone.rs b/library/core/src/clone.rs index 88f7990c017d..215046306720 100644 --- a/library/core/src/clone.rs +++ b/library/core/src/clone.rs @@ -36,8 +36,7 @@ #![stable(feature = "rust1", since = "1.0.0")] -use crate::mem::{self, MaybeUninit}; -use crate::ptr; +mod uninit; /// A common trait for the ability to explicitly duplicate an object. /// @@ -248,7 +247,7 @@ pub unsafe trait CloneToUninit { /// * `dst` must be properly aligned. /// * `dst` must have the same [pointer metadata] (slice length or `dyn` vtable) as `self`. /// - /// [valid]: ptr#safety + /// [valid]: crate::ptr#safety /// [pointer metadata]: crate::ptr::metadata() /// /// # Panics @@ -272,83 +271,20 @@ pub unsafe trait CloneToUninit { #[unstable(feature = "clone_to_uninit", issue = "126799")] unsafe impl CloneToUninit for T { - #[inline] - default unsafe fn clone_to_uninit(&self, dst: *mut Self) { - // SAFETY: The safety conditions of clone_to_uninit() are a superset of those of - // ptr::write(). - unsafe { - // We hope the optimizer will figure out to create the cloned value in-place, - // skipping ever storing it on the stack and the copy to the destination. - ptr::write(dst, self.clone()); - } - } -} - -// Specialized implementation for types that are [`Copy`], not just [`Clone`], -// and can therefore be copied bitwise. -#[doc(hidden)] -#[unstable(feature = "clone_to_uninit", issue = "126799")] -unsafe impl CloneToUninit for T { #[inline] unsafe fn clone_to_uninit(&self, dst: *mut Self) { - // SAFETY: The safety conditions of clone_to_uninit() are a superset of those of - // ptr::copy_nonoverlapping(). - unsafe { - ptr::copy_nonoverlapping(self, dst, 1); - } + // SAFETY: we're calling a specialization with the same contract + unsafe { ::clone_one(self, dst) } } } #[unstable(feature = "clone_to_uninit", issue = "126799")] unsafe impl CloneToUninit for [T] { - #[inline] - #[cfg_attr(debug_assertions, track_caller)] - default unsafe fn clone_to_uninit(&self, dst: *mut Self) { - let len = self.len(); - // This is the most likely mistake to make, so check it as a debug assertion. - debug_assert_eq!( - len, - dst.len(), - "clone_to_uninit() source and destination must have equal lengths", - ); - - // SAFETY: The produced `&mut` is valid because: - // * The caller is obligated to provide a pointer which is valid for writes. - // * All bytes pointed to are in MaybeUninit, so we don't care about the memory's - // initialization status. - let uninit_ref = unsafe { &mut *(dst as *mut [MaybeUninit]) }; - - // Copy the elements - let mut initializing = InitializingSlice::from_fully_uninit(uninit_ref); - for element_ref in self.iter() { - // If the clone() panics, `initializing` will take care of the cleanup. - initializing.push(element_ref.clone()); - } - // If we reach here, then the entire slice is initialized, and we've satisfied our - // responsibilities to the caller. Disarm the cleanup guard by forgetting it. - mem::forget(initializing); - } -} - -#[doc(hidden)] -#[unstable(feature = "clone_to_uninit", issue = "126799")] -unsafe impl CloneToUninit for [T] { #[inline] #[cfg_attr(debug_assertions, track_caller)] unsafe fn clone_to_uninit(&self, dst: *mut Self) { - let len = self.len(); - // This is the most likely mistake to make, so check it as a debug assertion. - debug_assert_eq!( - len, - dst.len(), - "clone_to_uninit() source and destination must have equal lengths", - ); - - // SAFETY: The safety conditions of clone_to_uninit() are a superset of those of - // ptr::copy_nonoverlapping(). - unsafe { - ptr::copy_nonoverlapping(self.as_ptr(), dst.as_mut_ptr(), len); - } + // SAFETY: we're calling a specialization with the same contract + unsafe { ::clone_slice(self, dst) } } } @@ -374,53 +310,6 @@ unsafe impl CloneToUninit for crate::ffi::CStr { } } -/// Ownership of a collection of values stored in a non-owned `[MaybeUninit]`, some of which -/// are not yet initialized. This is sort of like a `Vec` that doesn't own its allocation. -/// Its responsibility is to provide cleanup on unwind by dropping the values that *are* -/// initialized, unless disarmed by forgetting. -/// -/// This is a helper for `impl CloneToUninit for [T]`. -struct InitializingSlice<'a, T> { - data: &'a mut [MaybeUninit], - /// Number of elements of `*self.data` that are initialized. - initialized_len: usize, -} - -impl<'a, T> InitializingSlice<'a, T> { - #[inline] - fn from_fully_uninit(data: &'a mut [MaybeUninit]) -> Self { - Self { data, initialized_len: 0 } - } - - /// Push a value onto the end of the initialized part of the slice. - /// - /// # Panics - /// - /// Panics if the slice is already fully initialized. - #[inline] - fn push(&mut self, value: T) { - MaybeUninit::write(&mut self.data[self.initialized_len], value); - self.initialized_len += 1; - } -} - -impl<'a, T> Drop for InitializingSlice<'a, T> { - #[cold] // will only be invoked on unwind - fn drop(&mut self) { - let initialized_slice = ptr::slice_from_raw_parts_mut( - MaybeUninit::slice_as_mut_ptr(self.data), - self.initialized_len, - ); - // SAFETY: - // * the pointer is valid because it was made from a mutable reference - // * `initialized_len` counts the initialized elements as an invariant of this type, - // so each of the pointed-to elements is initialized and may be dropped. - unsafe { - ptr::drop_in_place::<[T]>(initialized_slice); - } - } -} - /// Implementations of `Clone` for primitive types. /// /// Implementations that cannot be described in Rust diff --git a/library/core/src/clone/uninit.rs b/library/core/src/clone/uninit.rs new file mode 100644 index 000000000000..8b738bec796d --- /dev/null +++ b/library/core/src/clone/uninit.rs @@ -0,0 +1,128 @@ +use crate::mem::{self, MaybeUninit}; +use crate::ptr; + +/// Private specialization trait used by CloneToUninit, as per +/// [the dev guide](https://std-dev-guide.rust-lang.org/policy/specialization.html). +pub(super) unsafe trait CopySpec: Clone { + unsafe fn clone_one(src: &Self, dst: *mut Self); + unsafe fn clone_slice(src: &[Self], dst: *mut [Self]); +} + +unsafe impl CopySpec for T { + #[inline] + default unsafe fn clone_one(src: &Self, dst: *mut Self) { + // SAFETY: The safety conditions of clone_to_uninit() are a superset of those of + // ptr::write(). + unsafe { + // We hope the optimizer will figure out to create the cloned value in-place, + // skipping ever storing it on the stack and the copy to the destination. + ptr::write(dst, src.clone()); + } + } + + #[inline] + #[cfg_attr(debug_assertions, track_caller)] + default unsafe fn clone_slice(src: &[Self], dst: *mut [Self]) { + let len = src.len(); + // This is the most likely mistake to make, so check it as a debug assertion. + debug_assert_eq!( + len, + dst.len(), + "clone_to_uninit() source and destination must have equal lengths", + ); + + // SAFETY: The produced `&mut` is valid because: + // * The caller is obligated to provide a pointer which is valid for writes. + // * All bytes pointed to are in MaybeUninit, so we don't care about the memory's + // initialization status. + let uninit_ref = unsafe { &mut *(dst as *mut [MaybeUninit]) }; + + // Copy the elements + let mut initializing = InitializingSlice::from_fully_uninit(uninit_ref); + for element_ref in src { + // If the clone() panics, `initializing` will take care of the cleanup. + initializing.push(element_ref.clone()); + } + // If we reach here, then the entire slice is initialized, and we've satisfied our + // responsibilities to the caller. Disarm the cleanup guard by forgetting it. + mem::forget(initializing); + } +} + +// Specialized implementation for types that are [`Copy`], not just [`Clone`], +// and can therefore be copied bitwise. +unsafe impl CopySpec for T { + #[inline] + unsafe fn clone_one(src: &Self, dst: *mut Self) { + // SAFETY: The safety conditions of clone_to_uninit() are a superset of those of + // ptr::copy_nonoverlapping(). + unsafe { + ptr::copy_nonoverlapping(src, dst, 1); + } + } + + #[inline] + #[cfg_attr(debug_assertions, track_caller)] + unsafe fn clone_slice(src: &[Self], dst: *mut [Self]) { + let len = src.len(); + // This is the most likely mistake to make, so check it as a debug assertion. + debug_assert_eq!( + len, + dst.len(), + "clone_to_uninit() source and destination must have equal lengths", + ); + + // SAFETY: The safety conditions of clone_to_uninit() are a superset of those of + // ptr::copy_nonoverlapping(). + unsafe { + ptr::copy_nonoverlapping(src.as_ptr(), dst.as_mut_ptr(), len); + } + } +} + +/// Ownership of a collection of values stored in a non-owned `[MaybeUninit]`, some of which +/// are not yet initialized. This is sort of like a `Vec` that doesn't own its allocation. +/// Its responsibility is to provide cleanup on unwind by dropping the values that *are* +/// initialized, unless disarmed by forgetting. +/// +/// This is a helper for `impl CloneToUninit for [T]`. +struct InitializingSlice<'a, T> { + data: &'a mut [MaybeUninit], + /// Number of elements of `*self.data` that are initialized. + initialized_len: usize, +} + +impl<'a, T> InitializingSlice<'a, T> { + #[inline] + fn from_fully_uninit(data: &'a mut [MaybeUninit]) -> Self { + Self { data, initialized_len: 0 } + } + + /// Push a value onto the end of the initialized part of the slice. + /// + /// # Panics + /// + /// Panics if the slice is already fully initialized. + #[inline] + fn push(&mut self, value: T) { + MaybeUninit::write(&mut self.data[self.initialized_len], value); + self.initialized_len += 1; + } +} + +impl<'a, T> Drop for InitializingSlice<'a, T> { + #[cold] // will only be invoked on unwind + fn drop(&mut self) { + let initialized_slice = ptr::slice_from_raw_parts_mut( + MaybeUninit::slice_as_mut_ptr(self.data), + self.initialized_len, + ); + // SAFETY: + // * the pointer is valid because it was made from a mutable reference + // * `initialized_len` counts the initialized elements as an invariant of this type, + // so each of the pointed-to elements is initialized and may be dropped. + unsafe { + ptr::drop_in_place::<[T]>(initialized_slice); + } + } +} From b1493ba5194fcc5cfe4f6315db288e4e18509110 Mon Sep 17 00:00:00 2001 From: beetrees Date: Sat, 1 Jun 2024 12:25:16 +0100 Subject: [PATCH 06/79] Move ZST ABI handling to `rustc_target` --- compiler/rustc_target/src/abi/call/mod.rs | 13 +++- compiler/rustc_target/src/abi/call/powerpc.rs | 20 +++-- compiler/rustc_target/src/abi/call/s390x.rs | 18 +++-- compiler/rustc_target/src/abi/call/sparc64.rs | 12 ++- .../rustc_target/src/abi/call/x86_win64.rs | 10 ++- compiler/rustc_ty_utils/src/abi.rs | 27 +------ src/tools/compiletest/src/command-list.rs | 5 ++ tests/ui/abi/c-zst.other-linux.stderr | 67 ++++++++++++++++ tests/ui/abi/c-zst.other.stderr | 67 ++++++++++++++++ tests/ui/abi/c-zst.powerpc-linux.stderr | 78 +++++++++++++++++++ tests/ui/abi/c-zst.rs | 27 +++++++ tests/ui/abi/c-zst.s390x-linux.stderr | 78 +++++++++++++++++++ tests/ui/abi/c-zst.sparc64-linux.stderr | 78 +++++++++++++++++++ .../ui/abi/c-zst.x86_64-pc-windows-gnu.stderr | 78 +++++++++++++++++++ tests/ui/abi/sysv64-zst.rs | 8 ++ tests/ui/abi/sysv64-zst.stderr | 67 ++++++++++++++++ tests/ui/abi/win64-zst.other.stderr | 67 ++++++++++++++++ tests/ui/abi/win64-zst.rs | 11 +++ tests/ui/abi/win64-zst.windows-gnu.stderr | 78 +++++++++++++++++++ 19 files changed, 766 insertions(+), 43 deletions(-) create mode 100644 tests/ui/abi/c-zst.other-linux.stderr create mode 100644 tests/ui/abi/c-zst.other.stderr create mode 100644 tests/ui/abi/c-zst.powerpc-linux.stderr create mode 100644 tests/ui/abi/c-zst.rs create mode 100644 tests/ui/abi/c-zst.s390x-linux.stderr create mode 100644 tests/ui/abi/c-zst.sparc64-linux.stderr create mode 100644 tests/ui/abi/c-zst.x86_64-pc-windows-gnu.stderr create mode 100644 tests/ui/abi/sysv64-zst.rs create mode 100644 tests/ui/abi/sysv64-zst.stderr create mode 100644 tests/ui/abi/win64-zst.other.stderr create mode 100644 tests/ui/abi/win64-zst.rs create mode 100644 tests/ui/abi/win64-zst.windows-gnu.stderr diff --git a/compiler/rustc_target/src/abi/call/mod.rs b/compiler/rustc_target/src/abi/call/mod.rs index 5bfc528dffc8..25e4d70945b2 100644 --- a/compiler/rustc_target/src/abi/call/mod.rs +++ b/compiler/rustc_target/src/abi/call/mod.rs @@ -642,7 +642,7 @@ impl<'a, Ty> ArgAbi<'a, Ty> { pub fn make_indirect(&mut self) { match self.mode { PassMode::Direct(_) | PassMode::Pair(_, _) => { - self.mode = Self::indirect_pass_mode(&self.layout); + self.make_indirect_force(); } PassMode::Indirect { attrs: _, meta_attrs: _, on_stack: false } => { // already indirect @@ -652,6 +652,11 @@ impl<'a, Ty> ArgAbi<'a, Ty> { } } + /// Same as make_indirect, but doesn't check the current `PassMode`. + pub fn make_indirect_force(&mut self) { + self.mode = Self::indirect_pass_mode(&self.layout); + } + /// Pass this argument indirectly, by placing it at a fixed stack offset. /// This corresponds to the `byval` LLVM argument attribute. /// This is only valid for sized arguments. @@ -871,10 +876,10 @@ impl<'a, Ty> FnAbi<'a, Ty> { } "x86_64" => match abi { spec::abi::Abi::SysV64 { .. } => x86_64::compute_abi_info(cx, self), - spec::abi::Abi::Win64 { .. } => x86_win64::compute_abi_info(self), + spec::abi::Abi::Win64 { .. } => x86_win64::compute_abi_info(cx, self), _ => { if cx.target_spec().is_like_windows { - x86_win64::compute_abi_info(self) + x86_win64::compute_abi_info(cx, self) } else { x86_64::compute_abi_info(cx, self) } @@ -898,7 +903,7 @@ impl<'a, Ty> FnAbi<'a, Ty> { "csky" => csky::compute_abi_info(self), "mips" | "mips32r6" => mips::compute_abi_info(cx, self), "mips64" | "mips64r6" => mips64::compute_abi_info(cx, self), - "powerpc" => powerpc::compute_abi_info(self), + "powerpc" => powerpc::compute_abi_info(cx, self), "powerpc64" => powerpc64::compute_abi_info(cx, self), "s390x" => s390x::compute_abi_info(cx, self), "msp430" => msp430::compute_abi_info(self), diff --git a/compiler/rustc_target/src/abi/call/powerpc.rs b/compiler/rustc_target/src/abi/call/powerpc.rs index 70c32db0a871..cb80d64c9430 100644 --- a/compiler/rustc_target/src/abi/call/powerpc.rs +++ b/compiler/rustc_target/src/abi/call/powerpc.rs @@ -1,4 +1,5 @@ use crate::abi::call::{ArgAbi, FnAbi}; +use crate::spec::HasTargetSpec; fn classify_ret(ret: &mut ArgAbi<'_, Ty>) { if ret.layout.is_aggregate() { @@ -8,7 +9,17 @@ fn classify_ret(ret: &mut ArgAbi<'_, Ty>) { } } -fn classify_arg(arg: &mut ArgAbi<'_, Ty>) { +fn classify_arg(cx: &impl HasTargetSpec, arg: &mut ArgAbi<'_, Ty>) { + if arg.is_ignore() { + // powerpc-unknown-linux-{gnu,musl,uclibc} doesn't ignore ZSTs. + if cx.target_spec().os == "linux" + && matches!(&*cx.target_spec().env, "gnu" | "musl" | "uclibc") + && arg.layout.is_zst() + { + arg.make_indirect_force(); + } + return; + } if arg.layout.is_aggregate() { arg.make_indirect(); } else { @@ -16,15 +27,12 @@ fn classify_arg(arg: &mut ArgAbi<'_, Ty>) { } } -pub fn compute_abi_info(fn_abi: &mut FnAbi<'_, Ty>) { +pub fn compute_abi_info(cx: &impl HasTargetSpec, fn_abi: &mut FnAbi<'_, Ty>) { if !fn_abi.ret.is_ignore() { classify_ret(&mut fn_abi.ret); } for arg in fn_abi.args.iter_mut() { - if arg.is_ignore() { - continue; - } - classify_arg(arg); + classify_arg(cx, arg); } } diff --git a/compiler/rustc_target/src/abi/call/s390x.rs b/compiler/rustc_target/src/abi/call/s390x.rs index 1a2191082d5d..7dcbb3e4a9e9 100644 --- a/compiler/rustc_target/src/abi/call/s390x.rs +++ b/compiler/rustc_target/src/abi/call/s390x.rs @@ -3,6 +3,7 @@ use crate::abi::call::{ArgAbi, FnAbi, Reg}; use crate::abi::{HasDataLayout, TyAbiInterface}; +use crate::spec::HasTargetSpec; fn classify_ret(ret: &mut ArgAbi<'_, Ty>) { if !ret.layout.is_aggregate() && ret.layout.size.bits() <= 64 { @@ -15,12 +16,22 @@ fn classify_ret(ret: &mut ArgAbi<'_, Ty>) { fn classify_arg<'a, Ty, C>(cx: &C, arg: &mut ArgAbi<'a, Ty>) where Ty: TyAbiInterface<'a, C> + Copy, - C: HasDataLayout, + C: HasDataLayout + HasTargetSpec, { if !arg.layout.is_sized() { // Not touching this... return; } + if arg.is_ignore() { + // s390x-unknown-linux-{gnu,musl,uclibc} doesn't ignore ZSTs. + if cx.target_spec().os == "linux" + && matches!(&*cx.target_spec().env, "gnu" | "musl" | "uclibc") + && arg.layout.is_zst() + { + arg.make_indirect_force(); + } + return; + } if !arg.layout.is_aggregate() && arg.layout.size.bits() <= 64 { arg.extend_integer_width_to(64); return; @@ -46,16 +57,13 @@ where pub fn compute_abi_info<'a, Ty, C>(cx: &C, fn_abi: &mut FnAbi<'a, Ty>) where Ty: TyAbiInterface<'a, C> + Copy, - C: HasDataLayout, + C: HasDataLayout + HasTargetSpec, { if !fn_abi.ret.is_ignore() { classify_ret(&mut fn_abi.ret); } for arg in fn_abi.args.iter_mut() { - if arg.is_ignore() { - continue; - } classify_arg(cx, arg); } } diff --git a/compiler/rustc_target/src/abi/call/sparc64.rs b/compiler/rustc_target/src/abi/call/sparc64.rs index c0952130e041..3b2bf9b3187f 100644 --- a/compiler/rustc_target/src/abi/call/sparc64.rs +++ b/compiler/rustc_target/src/abi/call/sparc64.rs @@ -4,6 +4,7 @@ use crate::abi::call::{ ArgAbi, ArgAttribute, ArgAttributes, ArgExtension, CastTarget, FnAbi, Reg, Uniform, }; use crate::abi::{self, HasDataLayout, Scalar, Size, TyAbiInterface, TyAndLayout}; +use crate::spec::HasTargetSpec; #[derive(Clone, Debug)] pub struct Sdata { @@ -211,7 +212,7 @@ where pub fn compute_abi_info<'a, Ty, C>(cx: &C, fn_abi: &mut FnAbi<'a, Ty>) where Ty: TyAbiInterface<'a, C> + Copy, - C: HasDataLayout, + C: HasDataLayout + HasTargetSpec, { if !fn_abi.ret.is_ignore() { classify_arg(cx, &mut fn_abi.ret, Size::from_bytes(32)); @@ -219,7 +220,14 @@ where for arg in fn_abi.args.iter_mut() { if arg.is_ignore() { - continue; + // sparc64-unknown-linux-{gnu,musl,uclibc} doesn't ignore ZSTs. + if cx.target_spec().os == "linux" + && matches!(&*cx.target_spec().env, "gnu" | "musl" | "uclibc") + && arg.layout.is_zst() + { + arg.make_indirect_force(); + } + return; } classify_arg(cx, arg, Size::from_bytes(16)); } diff --git a/compiler/rustc_target/src/abi/call/x86_win64.rs b/compiler/rustc_target/src/abi/call/x86_win64.rs index 4e19460bd28c..6ca01cf84eaa 100644 --- a/compiler/rustc_target/src/abi/call/x86_win64.rs +++ b/compiler/rustc_target/src/abi/call/x86_win64.rs @@ -1,9 +1,10 @@ use crate::abi::call::{ArgAbi, FnAbi, Reg}; use crate::abi::{Abi, Float, Primitive}; +use crate::spec::HasTargetSpec; // Win64 ABI: https://docs.microsoft.com/en-us/cpp/build/parameter-passing -pub fn compute_abi_info(fn_abi: &mut FnAbi<'_, Ty>) { +pub fn compute_abi_info(cx: &impl HasTargetSpec, fn_abi: &mut FnAbi<'_, Ty>) { let fixup = |a: &mut ArgAbi<'_, Ty>| { match a.layout.abi { Abi::Uninhabited | Abi::Aggregate { sized: false } => {} @@ -37,6 +38,13 @@ pub fn compute_abi_info(fn_abi: &mut FnAbi<'_, Ty>) { } for arg in fn_abi.args.iter_mut() { if arg.is_ignore() { + // x86_64-pc-windows-gnu doesn't ignore ZSTs. + if cx.target_spec().os == "windows" + && cx.target_spec().env == "gnu" + && arg.layout.is_zst() + { + arg.make_indirect_force(); + } continue; } fixup(arg); diff --git a/compiler/rustc_ty_utils/src/abi.rs b/compiler/rustc_ty_utils/src/abi.rs index f1675f80717f..464d03e4b35f 100644 --- a/compiler/rustc_ty_utils/src/abi.rs +++ b/compiler/rustc_ty_utils/src/abi.rs @@ -584,7 +584,7 @@ fn fn_abi_new_uncached<'tcx>( let conv = conv_from_spec_abi(cx.tcx(), sig.abi, sig.c_variadic); let mut inputs = sig.inputs(); - let extra_args = if sig.abi == RustCall { + let extra_args = if sig.abi == SpecAbi::RustCall { assert!(!sig.c_variadic && extra_args.is_empty()); if let Some(input) = sig.inputs().last() { @@ -608,18 +608,6 @@ fn fn_abi_new_uncached<'tcx>( extra_args }; - let target = &cx.tcx.sess.target; - let target_env_gnu_like = matches!(&target.env[..], "gnu" | "musl" | "uclibc"); - let win_x64_gnu = target.os == "windows" && target.arch == "x86_64" && target.env == "gnu"; - let linux_s390x_gnu_like = - target.os == "linux" && target.arch == "s390x" && target_env_gnu_like; - let linux_sparc64_gnu_like = - target.os == "linux" && target.arch == "sparc64" && target_env_gnu_like; - let linux_powerpc_gnu_like = - target.os == "linux" && target.arch == "powerpc" && target_env_gnu_like; - use SpecAbi::*; - let rust_abi = matches!(sig.abi, RustIntrinsic | Rust | RustCall); - let is_drop_in_place = fn_def_id.is_some() && fn_def_id == cx.tcx.lang_items().drop_in_place_fn(); @@ -659,18 +647,7 @@ fn fn_abi_new_uncached<'tcx>( }); if arg.layout.is_zst() { - // For some forsaken reason, x86_64-pc-windows-gnu - // doesn't ignore zero-sized struct arguments. - // The same is true for {s390x,sparc64,powerpc}-unknown-linux-{gnu,musl,uclibc}. - if is_return - || rust_abi - || (!win_x64_gnu - && !linux_s390x_gnu_like - && !linux_sparc64_gnu_like - && !linux_powerpc_gnu_like) - { - arg.mode = PassMode::Ignore; - } + arg.mode = PassMode::Ignore; } Ok(arg) diff --git a/src/tools/compiletest/src/command-list.rs b/src/tools/compiletest/src/command-list.rs index 288f90ea1239..a405cd486c71 100644 --- a/src/tools/compiletest/src/command-list.rs +++ b/src/tools/compiletest/src/command-list.rs @@ -91,10 +91,12 @@ const KNOWN_DIRECTIVE_NAMES: &[&str] = &[ "ignore-nvptx64-nvidia-cuda", "ignore-openbsd", "ignore-pass", + "ignore-powerpc", "ignore-remote", "ignore-riscv64", "ignore-s390x", "ignore-sgx", + "ignore-sparc64", "ignore-spirv", "ignore-stable", "ignore-stage1", @@ -122,6 +124,7 @@ const KNOWN_DIRECTIVE_NAMES: &[&str] = &[ "ignore-x86", "ignore-x86_64", "ignore-x86_64-apple-darwin", + "ignore-x86_64-pc-windows-gnu", "ignore-x86_64-unknown-linux-gnu", "incremental", "known-bug", @@ -189,7 +192,9 @@ const KNOWN_DIRECTIVE_NAMES: &[&str] = &[ "only-msvc", "only-nightly", "only-nvptx64", + "only-powerpc", "only-riscv64", + "only-s390x", "only-sparc", "only-sparc64", "only-stable", diff --git a/tests/ui/abi/c-zst.other-linux.stderr b/tests/ui/abi/c-zst.other-linux.stderr new file mode 100644 index 000000000000..5a656e6ea66e --- /dev/null +++ b/tests/ui/abi/c-zst.other-linux.stderr @@ -0,0 +1,67 @@ +error: fn_abi_of(pass_zst) = FnAbi { + args: [ + ArgAbi { + layout: TyAndLayout { + ty: (), + layout: Layout { + size: Size(0 bytes), + align: AbiAndPrefAlign { + abi: $SOME_ALIGN, + pref: $SOME_ALIGN, + }, + abi: Aggregate { + sized: true, + }, + fields: Arbitrary { + offsets: [], + memory_index: [], + }, + largest_niche: None, + variants: Single { + index: 0, + }, + max_repr_align: None, + unadjusted_abi_align: $SOME_ALIGN, + }, + }, + mode: Ignore, + }, + ], + ret: ArgAbi { + layout: TyAndLayout { + ty: (), + layout: Layout { + size: Size(0 bytes), + align: AbiAndPrefAlign { + abi: $SOME_ALIGN, + pref: $SOME_ALIGN, + }, + abi: Aggregate { + sized: true, + }, + fields: Arbitrary { + offsets: [], + memory_index: [], + }, + largest_niche: None, + variants: Single { + index: 0, + }, + max_repr_align: None, + unadjusted_abi_align: $SOME_ALIGN, + }, + }, + mode: Ignore, + }, + c_variadic: false, + fixed_count: 1, + conv: C, + can_unwind: false, + } + --> $DIR/c-zst.rs:27:1 + | +LL | extern "C" fn pass_zst(_: ()) {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error: aborting due to 1 previous error + diff --git a/tests/ui/abi/c-zst.other.stderr b/tests/ui/abi/c-zst.other.stderr new file mode 100644 index 000000000000..5a656e6ea66e --- /dev/null +++ b/tests/ui/abi/c-zst.other.stderr @@ -0,0 +1,67 @@ +error: fn_abi_of(pass_zst) = FnAbi { + args: [ + ArgAbi { + layout: TyAndLayout { + ty: (), + layout: Layout { + size: Size(0 bytes), + align: AbiAndPrefAlign { + abi: $SOME_ALIGN, + pref: $SOME_ALIGN, + }, + abi: Aggregate { + sized: true, + }, + fields: Arbitrary { + offsets: [], + memory_index: [], + }, + largest_niche: None, + variants: Single { + index: 0, + }, + max_repr_align: None, + unadjusted_abi_align: $SOME_ALIGN, + }, + }, + mode: Ignore, + }, + ], + ret: ArgAbi { + layout: TyAndLayout { + ty: (), + layout: Layout { + size: Size(0 bytes), + align: AbiAndPrefAlign { + abi: $SOME_ALIGN, + pref: $SOME_ALIGN, + }, + abi: Aggregate { + sized: true, + }, + fields: Arbitrary { + offsets: [], + memory_index: [], + }, + largest_niche: None, + variants: Single { + index: 0, + }, + max_repr_align: None, + unadjusted_abi_align: $SOME_ALIGN, + }, + }, + mode: Ignore, + }, + c_variadic: false, + fixed_count: 1, + conv: C, + can_unwind: false, + } + --> $DIR/c-zst.rs:27:1 + | +LL | extern "C" fn pass_zst(_: ()) {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error: aborting due to 1 previous error + diff --git a/tests/ui/abi/c-zst.powerpc-linux.stderr b/tests/ui/abi/c-zst.powerpc-linux.stderr new file mode 100644 index 000000000000..ba9738050d87 --- /dev/null +++ b/tests/ui/abi/c-zst.powerpc-linux.stderr @@ -0,0 +1,78 @@ +error: fn_abi_of(pass_zst) = FnAbi { + args: [ + ArgAbi { + layout: TyAndLayout { + ty: (), + layout: Layout { + size: Size(0 bytes), + align: AbiAndPrefAlign { + abi: $SOME_ALIGN, + pref: $SOME_ALIGN, + }, + abi: Aggregate { + sized: true, + }, + fields: Arbitrary { + offsets: [], + memory_index: [], + }, + largest_niche: None, + variants: Single { + index: 0, + }, + max_repr_align: None, + unadjusted_abi_align: $SOME_ALIGN, + }, + }, + mode: Indirect { + attrs: ArgAttributes { + regular: NoAlias | NoCapture | NonNull | NoUndef, + arg_ext: None, + pointee_size: Size(0 bytes), + pointee_align: Some( + Align(1 bytes), + ), + }, + meta_attrs: None, + on_stack: false, + }, + }, + ], + ret: ArgAbi { + layout: TyAndLayout { + ty: (), + layout: Layout { + size: Size(0 bytes), + align: AbiAndPrefAlign { + abi: $SOME_ALIGN, + pref: $SOME_ALIGN, + }, + abi: Aggregate { + sized: true, + }, + fields: Arbitrary { + offsets: [], + memory_index: [], + }, + largest_niche: None, + variants: Single { + index: 0, + }, + max_repr_align: None, + unadjusted_abi_align: $SOME_ALIGN, + }, + }, + mode: Ignore, + }, + c_variadic: false, + fixed_count: 1, + conv: C, + can_unwind: false, + } + --> $DIR/c-zst.rs:27:1 + | +LL | extern "C" fn pass_zst(_: ()) {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error: aborting due to 1 previous error + diff --git a/tests/ui/abi/c-zst.rs b/tests/ui/abi/c-zst.rs new file mode 100644 index 000000000000..0cfd653b37e8 --- /dev/null +++ b/tests/ui/abi/c-zst.rs @@ -0,0 +1,27 @@ +//@ revisions: other other-linux x86_64-pc-windows-gnu s390x-linux sparc64-linux powerpc-linux +//@ normalize-stderr-test: "(abi|pref|unadjusted_abi_align): Align\([1-8] bytes\)" -> "$1: $$SOME_ALIGN" +// ZSTs are only not ignored when the target_env is "gnu", "musl" or "uclibc". However, Rust does +// not currently support any other target_env on these architectures. + +// Ignore the ZST revisions +//@[other] ignore-x86_64-pc-windows-gnu +//@[other] ignore-linux +//@[other-linux] only-linux +//@[other-linux] ignore-s390x +//@[other-linux] ignore-sparc64 +//@[other-linux] ignore-powerpc + +// Pass the ZST indirectly revisions +//@[x86_64-pc-windows-gnu] only-x86_64-pc-windows-gnu +//@[s390x-linux] only-s390x +//@[s390x-linux] only-linux +//@[sparc64-linux] only-sparc64 +//@[sparc64-linux] only-linux +//@[powerpc-linux] only-powerpc +//@[powerpc-linux] only-linux + +#![feature(rustc_attrs)] +#![crate_type = "lib"] + +#[rustc_abi(debug)] +extern "C" fn pass_zst(_: ()) {} //~ ERROR: fn_abi diff --git a/tests/ui/abi/c-zst.s390x-linux.stderr b/tests/ui/abi/c-zst.s390x-linux.stderr new file mode 100644 index 000000000000..ba9738050d87 --- /dev/null +++ b/tests/ui/abi/c-zst.s390x-linux.stderr @@ -0,0 +1,78 @@ +error: fn_abi_of(pass_zst) = FnAbi { + args: [ + ArgAbi { + layout: TyAndLayout { + ty: (), + layout: Layout { + size: Size(0 bytes), + align: AbiAndPrefAlign { + abi: $SOME_ALIGN, + pref: $SOME_ALIGN, + }, + abi: Aggregate { + sized: true, + }, + fields: Arbitrary { + offsets: [], + memory_index: [], + }, + largest_niche: None, + variants: Single { + index: 0, + }, + max_repr_align: None, + unadjusted_abi_align: $SOME_ALIGN, + }, + }, + mode: Indirect { + attrs: ArgAttributes { + regular: NoAlias | NoCapture | NonNull | NoUndef, + arg_ext: None, + pointee_size: Size(0 bytes), + pointee_align: Some( + Align(1 bytes), + ), + }, + meta_attrs: None, + on_stack: false, + }, + }, + ], + ret: ArgAbi { + layout: TyAndLayout { + ty: (), + layout: Layout { + size: Size(0 bytes), + align: AbiAndPrefAlign { + abi: $SOME_ALIGN, + pref: $SOME_ALIGN, + }, + abi: Aggregate { + sized: true, + }, + fields: Arbitrary { + offsets: [], + memory_index: [], + }, + largest_niche: None, + variants: Single { + index: 0, + }, + max_repr_align: None, + unadjusted_abi_align: $SOME_ALIGN, + }, + }, + mode: Ignore, + }, + c_variadic: false, + fixed_count: 1, + conv: C, + can_unwind: false, + } + --> $DIR/c-zst.rs:27:1 + | +LL | extern "C" fn pass_zst(_: ()) {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error: aborting due to 1 previous error + diff --git a/tests/ui/abi/c-zst.sparc64-linux.stderr b/tests/ui/abi/c-zst.sparc64-linux.stderr new file mode 100644 index 000000000000..ba9738050d87 --- /dev/null +++ b/tests/ui/abi/c-zst.sparc64-linux.stderr @@ -0,0 +1,78 @@ +error: fn_abi_of(pass_zst) = FnAbi { + args: [ + ArgAbi { + layout: TyAndLayout { + ty: (), + layout: Layout { + size: Size(0 bytes), + align: AbiAndPrefAlign { + abi: $SOME_ALIGN, + pref: $SOME_ALIGN, + }, + abi: Aggregate { + sized: true, + }, + fields: Arbitrary { + offsets: [], + memory_index: [], + }, + largest_niche: None, + variants: Single { + index: 0, + }, + max_repr_align: None, + unadjusted_abi_align: $SOME_ALIGN, + }, + }, + mode: Indirect { + attrs: ArgAttributes { + regular: NoAlias | NoCapture | NonNull | NoUndef, + arg_ext: None, + pointee_size: Size(0 bytes), + pointee_align: Some( + Align(1 bytes), + ), + }, + meta_attrs: None, + on_stack: false, + }, + }, + ], + ret: ArgAbi { + layout: TyAndLayout { + ty: (), + layout: Layout { + size: Size(0 bytes), + align: AbiAndPrefAlign { + abi: $SOME_ALIGN, + pref: $SOME_ALIGN, + }, + abi: Aggregate { + sized: true, + }, + fields: Arbitrary { + offsets: [], + memory_index: [], + }, + largest_niche: None, + variants: Single { + index: 0, + }, + max_repr_align: None, + unadjusted_abi_align: $SOME_ALIGN, + }, + }, + mode: Ignore, + }, + c_variadic: false, + fixed_count: 1, + conv: C, + can_unwind: false, + } + --> $DIR/c-zst.rs:27:1 + | +LL | extern "C" fn pass_zst(_: ()) {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error: aborting due to 1 previous error + diff --git a/tests/ui/abi/c-zst.x86_64-pc-windows-gnu.stderr b/tests/ui/abi/c-zst.x86_64-pc-windows-gnu.stderr new file mode 100644 index 000000000000..ba9738050d87 --- /dev/null +++ b/tests/ui/abi/c-zst.x86_64-pc-windows-gnu.stderr @@ -0,0 +1,78 @@ +error: fn_abi_of(pass_zst) = FnAbi { + args: [ + ArgAbi { + layout: TyAndLayout { + ty: (), + layout: Layout { + size: Size(0 bytes), + align: AbiAndPrefAlign { + abi: $SOME_ALIGN, + pref: $SOME_ALIGN, + }, + abi: Aggregate { + sized: true, + }, + fields: Arbitrary { + offsets: [], + memory_index: [], + }, + largest_niche: None, + variants: Single { + index: 0, + }, + max_repr_align: None, + unadjusted_abi_align: $SOME_ALIGN, + }, + }, + mode: Indirect { + attrs: ArgAttributes { + regular: NoAlias | NoCapture | NonNull | NoUndef, + arg_ext: None, + pointee_size: Size(0 bytes), + pointee_align: Some( + Align(1 bytes), + ), + }, + meta_attrs: None, + on_stack: false, + }, + }, + ], + ret: ArgAbi { + layout: TyAndLayout { + ty: (), + layout: Layout { + size: Size(0 bytes), + align: AbiAndPrefAlign { + abi: $SOME_ALIGN, + pref: $SOME_ALIGN, + }, + abi: Aggregate { + sized: true, + }, + fields: Arbitrary { + offsets: [], + memory_index: [], + }, + largest_niche: None, + variants: Single { + index: 0, + }, + max_repr_align: None, + unadjusted_abi_align: $SOME_ALIGN, + }, + }, + mode: Ignore, + }, + c_variadic: false, + fixed_count: 1, + conv: C, + can_unwind: false, + } + --> $DIR/c-zst.rs:27:1 + | +LL | extern "C" fn pass_zst(_: ()) {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error: aborting due to 1 previous error + diff --git a/tests/ui/abi/sysv64-zst.rs b/tests/ui/abi/sysv64-zst.rs new file mode 100644 index 000000000000..6f4497e77a18 --- /dev/null +++ b/tests/ui/abi/sysv64-zst.rs @@ -0,0 +1,8 @@ +//@ only-x86_64 +//@ normalize-stderr-test: "(abi|pref|unadjusted_abi_align): Align\([1-8] bytes\)" -> "$1: $$SOME_ALIGN" + +#![feature(rustc_attrs)] +#![crate_type = "lib"] + +#[rustc_abi(debug)] +extern "sysv64" fn pass_zst(_: ()) {} //~ ERROR: fn_abi diff --git a/tests/ui/abi/sysv64-zst.stderr b/tests/ui/abi/sysv64-zst.stderr new file mode 100644 index 000000000000..8b0b84dfa069 --- /dev/null +++ b/tests/ui/abi/sysv64-zst.stderr @@ -0,0 +1,67 @@ +error: fn_abi_of(pass_zst) = FnAbi { + args: [ + ArgAbi { + layout: TyAndLayout { + ty: (), + layout: Layout { + size: Size(0 bytes), + align: AbiAndPrefAlign { + abi: $SOME_ALIGN, + pref: $SOME_ALIGN, + }, + abi: Aggregate { + sized: true, + }, + fields: Arbitrary { + offsets: [], + memory_index: [], + }, + largest_niche: None, + variants: Single { + index: 0, + }, + max_repr_align: None, + unadjusted_abi_align: $SOME_ALIGN, + }, + }, + mode: Ignore, + }, + ], + ret: ArgAbi { + layout: TyAndLayout { + ty: (), + layout: Layout { + size: Size(0 bytes), + align: AbiAndPrefAlign { + abi: $SOME_ALIGN, + pref: $SOME_ALIGN, + }, + abi: Aggregate { + sized: true, + }, + fields: Arbitrary { + offsets: [], + memory_index: [], + }, + largest_niche: None, + variants: Single { + index: 0, + }, + max_repr_align: None, + unadjusted_abi_align: $SOME_ALIGN, + }, + }, + mode: Ignore, + }, + c_variadic: false, + fixed_count: 1, + conv: X86_64SysV, + can_unwind: false, + } + --> $DIR/sysv64-zst.rs:8:1 + | +LL | extern "sysv64" fn pass_zst(_: ()) {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error: aborting due to 1 previous error + diff --git a/tests/ui/abi/win64-zst.other.stderr b/tests/ui/abi/win64-zst.other.stderr new file mode 100644 index 000000000000..15db141cb574 --- /dev/null +++ b/tests/ui/abi/win64-zst.other.stderr @@ -0,0 +1,67 @@ +error: fn_abi_of(pass_zst) = FnAbi { + args: [ + ArgAbi { + layout: TyAndLayout { + ty: (), + layout: Layout { + size: Size(0 bytes), + align: AbiAndPrefAlign { + abi: $SOME_ALIGN, + pref: $SOME_ALIGN, + }, + abi: Aggregate { + sized: true, + }, + fields: Arbitrary { + offsets: [], + memory_index: [], + }, + largest_niche: None, + variants: Single { + index: 0, + }, + max_repr_align: None, + unadjusted_abi_align: $SOME_ALIGN, + }, + }, + mode: Ignore, + }, + ], + ret: ArgAbi { + layout: TyAndLayout { + ty: (), + layout: Layout { + size: Size(0 bytes), + align: AbiAndPrefAlign { + abi: $SOME_ALIGN, + pref: $SOME_ALIGN, + }, + abi: Aggregate { + sized: true, + }, + fields: Arbitrary { + offsets: [], + memory_index: [], + }, + largest_niche: None, + variants: Single { + index: 0, + }, + max_repr_align: None, + unadjusted_abi_align: $SOME_ALIGN, + }, + }, + mode: Ignore, + }, + c_variadic: false, + fixed_count: 1, + conv: X86_64Win64, + can_unwind: false, + } + --> $DIR/win64-zst.rs:11:1 + | +LL | extern "win64" fn pass_zst(_: ()) {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error: aborting due to 1 previous error + diff --git a/tests/ui/abi/win64-zst.rs b/tests/ui/abi/win64-zst.rs new file mode 100644 index 000000000000..cae32795e16e --- /dev/null +++ b/tests/ui/abi/win64-zst.rs @@ -0,0 +1,11 @@ +//@ only-x86_64 +//@ revisions: other windows-gnu +//@ normalize-stderr-test: "(abi|pref|unadjusted_abi_align): Align\([1-8] bytes\)" -> "$1: $$SOME_ALIGN" +//@[other] ignore-windows-gnu +//@[windows-gnu] only-windows-gnu + +#![feature(rustc_attrs)] +#![crate_type = "lib"] + +#[rustc_abi(debug)] +extern "win64" fn pass_zst(_: ()) {} //~ ERROR: fn_abi diff --git a/tests/ui/abi/win64-zst.windows-gnu.stderr b/tests/ui/abi/win64-zst.windows-gnu.stderr new file mode 100644 index 000000000000..7773e0aa2b57 --- /dev/null +++ b/tests/ui/abi/win64-zst.windows-gnu.stderr @@ -0,0 +1,78 @@ +error: fn_abi_of(pass_zst) = FnAbi { + args: [ + ArgAbi { + layout: TyAndLayout { + ty: (), + layout: Layout { + size: Size(0 bytes), + align: AbiAndPrefAlign { + abi: $SOME_ALIGN, + pref: $SOME_ALIGN, + }, + abi: Aggregate { + sized: true, + }, + fields: Arbitrary { + offsets: [], + memory_index: [], + }, + largest_niche: None, + variants: Single { + index: 0, + }, + max_repr_align: None, + unadjusted_abi_align: $SOME_ALIGN, + }, + }, + mode: Indirect { + attrs: ArgAttributes { + regular: NoAlias | NoCapture | NonNull | NoUndef, + arg_ext: None, + pointee_size: Size(0 bytes), + pointee_align: Some( + Align(1 bytes), + ), + }, + meta_attrs: None, + on_stack: false, + }, + }, + ], + ret: ArgAbi { + layout: TyAndLayout { + ty: (), + layout: Layout { + size: Size(0 bytes), + align: AbiAndPrefAlign { + abi: $SOME_ALIGN, + pref: $SOME_ALIGN, + }, + abi: Aggregate { + sized: true, + }, + fields: Arbitrary { + offsets: [], + memory_index: [], + }, + largest_niche: None, + variants: Single { + index: 0, + }, + max_repr_align: None, + unadjusted_abi_align: $SOME_ALIGN, + }, + }, + mode: Ignore, + }, + c_variadic: false, + fixed_count: 1, + conv: X86_64Win64, + can_unwind: false, + } + --> $DIR/win64-zst.rs:11:1 + | +LL | extern "win64" fn pass_zst(_: ()) {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error: aborting due to 1 previous error + From 709406fc6c792bd5dd0d07fbc59c4437b3d47f95 Mon Sep 17 00:00:00 2001 From: Kyle Huey Date: Sat, 3 Aug 2024 21:23:35 -0700 Subject: [PATCH 07/79] When deduplicating unreachable blocks, erase the source information. After deduplication the block conceptually belongs to multiple locations in the source. Although these blocks are unreachable, in #123341 we did come across a real side effect, an unreachable block that survives into the compiled code can cause a debugger to set a breakpoint on the wrong instruction. Erasing the source information ensures that a debugger will never be misled into thinking that the unreachable block is worth setting a breakpoint on, especially after #128627. Technically we don't need to erase the source information if all the deduplicated blocks have identical source information, but tracking that seems like more effort than it's worth. --- compiler/rustc_mir_transform/src/simplify.rs | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/compiler/rustc_mir_transform/src/simplify.rs b/compiler/rustc_mir_transform/src/simplify.rs index 5bbe3bb747fd..4fe8cf6213f8 100644 --- a/compiler/rustc_mir_transform/src/simplify.rs +++ b/compiler/rustc_mir_transform/src/simplify.rs @@ -31,6 +31,7 @@ use rustc_index::{Idx, IndexSlice, IndexVec}; use rustc_middle::mir::visit::{MutVisitor, MutatingUseContext, PlaceContext, Visitor}; use rustc_middle::mir::*; use rustc_middle::ty::TyCtxt; +use rustc_span::DUMMY_SP; use smallvec::SmallVec; pub enum SimplifyCfg { @@ -318,6 +319,7 @@ pub(crate) fn remove_dead_blocks(body: &mut Body<'_>) { let mut orig_index = 0; let mut used_index = 0; let mut kept_unreachable = None; + let mut deduplicated_unreachable = false; basic_blocks.raw.retain(|bbdata| { let orig_bb = BasicBlock::new(orig_index); if !reachable.contains(orig_bb) { @@ -330,6 +332,7 @@ pub(crate) fn remove_dead_blocks(body: &mut Body<'_>) { let kept_unreachable = *kept_unreachable.get_or_insert(used_bb); if kept_unreachable != used_bb { replacements[orig_index] = kept_unreachable; + deduplicated_unreachable = true; orig_index += 1; return false; } @@ -341,6 +344,14 @@ pub(crate) fn remove_dead_blocks(body: &mut Body<'_>) { true }); + // If we deduplicated unreachable blocks we erase their source_info as we + // can no longer attribute their code to a particular location in the + // source. + if deduplicated_unreachable { + basic_blocks[kept_unreachable.unwrap()].terminator_mut().source_info = + SourceInfo { span: DUMMY_SP, scope: OUTERMOST_SOURCE_SCOPE }; + } + for block in basic_blocks { for target in block.terminator_mut().successors_mut() { *target = replacements[target.index()]; From 37984bbde11e6bcd0a009d2bbdbe7a73f9605b05 Mon Sep 17 00:00:00 2001 From: onur-ozkan Date: Sat, 3 Aug 2024 08:58:53 +0300 Subject: [PATCH 08/79] unify path syncing logic for vendor and dist Signed-off-by: onur-ozkan --- src/bootstrap/src/core/build_steps/dist.rs | 34 ++++++-------------- src/bootstrap/src/core/build_steps/vendor.rs | 32 ++++++++++++------ 2 files changed, 31 insertions(+), 35 deletions(-) diff --git a/src/bootstrap/src/core/build_steps/dist.rs b/src/bootstrap/src/core/build_steps/dist.rs index c14709ffb632..cd7d602e859f 100644 --- a/src/bootstrap/src/core/build_steps/dist.rs +++ b/src/bootstrap/src/core/build_steps/dist.rs @@ -19,6 +19,7 @@ use object::BinaryFormat; use crate::core::build_steps::doc::DocumentationFormat; use crate::core::build_steps::tool::{self, Tool}; +use crate::core::build_steps::vendor::default_paths_to_vendor; use crate::core::build_steps::{compile, llvm}; use crate::core::builder::{Builder, Kind, RunConfig, ShouldRun, Step}; use crate::core::config::TargetSelection; @@ -1016,35 +1017,18 @@ impl Step for PlainSourceTarball { if builder.rust_info().is_managed_git_subrepository() || builder.rust_info().is_from_tarball() { - // FIXME: This code looks _very_ similar to what we have in `src/core/build_steps/vendor.rs` - // perhaps it should be removed in favor of making `dist` perform the `vendor` step? - builder.require_and_update_all_submodules(); // Vendor all Cargo dependencies let mut cmd = command(&builder.initial_cargo); - cmd.arg("vendor") - .arg("--versioned-dirs") - .arg("--sync") - .arg(builder.src.join("./src/tools/cargo/Cargo.toml")) - .arg("--sync") - .arg(builder.src.join("./src/tools/rust-analyzer/Cargo.toml")) - .arg("--sync") - .arg(builder.src.join("./compiler/rustc_codegen_cranelift/Cargo.toml")) - .arg("--sync") - .arg(builder.src.join("./compiler/rustc_codegen_gcc/Cargo.toml")) - .arg("--sync") - .arg(builder.src.join("./library/Cargo.toml")) - .arg("--sync") - .arg(builder.src.join("./src/bootstrap/Cargo.toml")) - .arg("--sync") - .arg(builder.src.join("./src/tools/opt-dist/Cargo.toml")) - .arg("--sync") - .arg(builder.src.join("./src/tools/rustc-perf/Cargo.toml")) - .arg("--sync") - .arg(builder.src.join("./src/tools/rustbook/Cargo.toml")) - // Will read the libstd Cargo.toml - // which uses the unstable `public-dependency` feature. + cmd.arg("vendor").arg("--versioned-dirs"); + + for p in default_paths_to_vendor(builder) { + cmd.arg("--sync").arg(p); + } + + cmd + // Will read the libstd Cargo.toml which uses the unstable `public-dependency` feature. .env("RUSTC_BOOTSTRAP", "1") .current_dir(plain_dst_src); diff --git a/src/bootstrap/src/core/build_steps/vendor.rs b/src/bootstrap/src/core/build_steps/vendor.rs index 33768465225f..82a6b4d4f28c 100644 --- a/src/bootstrap/src/core/build_steps/vendor.rs +++ b/src/bootstrap/src/core/build_steps/vendor.rs @@ -4,6 +4,26 @@ use crate::core::build_steps::tool::SUBMODULES_FOR_RUSTBOOK; use crate::core::builder::{Builder, RunConfig, ShouldRun, Step}; use crate::utils::exec::command; +/// List of default paths used for vendoring for `x vendor` and dist tarballs. +pub fn default_paths_to_vendor(builder: &Builder<'_>) -> Vec { + let mut paths = vec![]; + for p in [ + "src/tools/cargo/Cargo.toml", + "src/tools/rust-analyzer/Cargo.toml", + "compiler/rustc_codegen_cranelift/Cargo.toml", + "compiler/rustc_codegen_gcc/Cargo.toml", + "library/Cargo.toml", + "src/bootstrap/Cargo.toml", + "src/tools/rustbook/Cargo.toml", + "src/tools/rustc-perf/Cargo.toml", + "src/tools/opt-dist/Cargo.toml", + ] { + paths.push(builder.src.join(p)); + } + + paths +} + #[derive(Debug, Clone, Hash, PartialEq, Eq)] pub(crate) struct Vendor { sync_args: Vec, @@ -42,16 +62,8 @@ impl Step for Vendor { } // Sync these paths by default. - for p in [ - "src/tools/cargo/Cargo.toml", - "src/tools/rust-analyzer/Cargo.toml", - "compiler/rustc_codegen_cranelift/Cargo.toml", - "compiler/rustc_codegen_gcc/Cargo.toml", - "library/Cargo.toml", - "src/bootstrap/Cargo.toml", - "src/tools/rustbook/Cargo.toml", - ] { - cmd.arg("--sync").arg(builder.src.join(p)); + for p in default_paths_to_vendor(builder) { + cmd.arg("--sync").arg(p); } // Also sync explicitly requested paths. From bc0bc91e109fb21243f6bf15747c6fe2158d6a4b Mon Sep 17 00:00:00 2001 From: onur-ozkan Date: Sat, 3 Aug 2024 09:00:16 +0300 Subject: [PATCH 09/79] remove redundant FIXMEs Signed-off-by: onur-ozkan --- src/bootstrap/src/core/build_steps/tool.rs | 7 +------ src/bootstrap/src/core/builder.rs | 14 +++++--------- src/bootstrap/src/core/download.rs | 2 -- 3 files changed, 6 insertions(+), 17 deletions(-) diff --git a/src/bootstrap/src/core/build_steps/tool.rs b/src/bootstrap/src/core/build_steps/tool.rs index 4d573b107b58..ff8ca2ad74aa 100644 --- a/src/bootstrap/src/core/build_steps/tool.rs +++ b/src/bootstrap/src/core/build_steps/tool.rs @@ -1091,18 +1091,13 @@ macro_rules! tool_extended { } } -// NOTE: tools need to be also added to `Builder::get_step_descriptions` in `builder.rs` -// to make `./x.py build ` work. tool_extended!((self, builder), Cargofmt, "src/tools/rustfmt", "cargo-fmt", stable=true; CargoClippy, "src/tools/clippy", "cargo-clippy", stable=true; Clippy, "src/tools/clippy", "clippy-driver", stable=true, add_bins_to_sysroot = ["clippy-driver", "cargo-clippy"]; Miri, "src/tools/miri", "miri", stable=false, add_bins_to_sysroot = ["miri"]; CargoMiri, "src/tools/miri/cargo-miri", "cargo-miri", stable=true, add_bins_to_sysroot = ["cargo-miri"]; - // FIXME: tool_std is not quite right, we shouldn't allow nightly features. - // But `builder.cargo` doesn't know how to handle ToolBootstrap in stages other than 0, - // and this is close enough for now. - Rls, "src/tools/rls", "rls", stable=true, tool_std=true; + Rls, "src/tools/rls", "rls", stable=true; Rustfmt, "src/tools/rustfmt", "rustfmt", stable=true, add_bins_to_sysroot = ["rustfmt", "cargo-fmt"]; ); diff --git a/src/bootstrap/src/core/builder.rs b/src/bootstrap/src/core/builder.rs index 84c23c059e97..d6c6de8f80df 100644 --- a/src/bootstrap/src/core/builder.rs +++ b/src/bootstrap/src/core/builder.rs @@ -1449,15 +1449,11 @@ impl<'a> Builder<'a> { assert_eq!(target, compiler.host); } - if self.config.rust_optimize.is_release() { - // FIXME: cargo bench/install do not accept `--release` - // and miri doesn't want it - match cmd_kind { - Kind::Bench | Kind::Install | Kind::Miri | Kind::MiriSetup | Kind::MiriTest => {} - _ => { - cargo.arg("--release"); - } - } + if self.config.rust_optimize.is_release() && + // cargo bench/install do not accept `--release` and miri doesn't want it + !matches!(cmd_kind, Kind::Bench | Kind::Install | Kind::Miri | Kind::MiriSetup | Kind::MiriTest) + { + cargo.arg("--release"); } // Remove make-related flags to ensure Cargo can correctly set things up diff --git a/src/bootstrap/src/core/download.rs b/src/bootstrap/src/core/download.rs index 4d1aea3cd956..25daeeb721ee 100644 --- a/src/bootstrap/src/core/download.rs +++ b/src/bootstrap/src/core/download.rs @@ -616,8 +616,6 @@ impl Config { }; // For the beta compiler, put special effort into ensuring the checksums are valid. - // FIXME: maybe we should do this for download-rustc as well? but it would be a pain to update - // this on each and every nightly ... let checksum = if should_verify { let error = format!( "src/stage0 doesn't contain a checksum for {url}. \ From 8d7c374b2ec4f6cfd99f9c8e7cd5b2624909fa21 Mon Sep 17 00:00:00 2001 From: onur-ozkan Date: Sat, 3 Aug 2024 09:10:00 +0300 Subject: [PATCH 10/79] improve rustup check in `x setup` Signed-off-by: onur-ozkan --- src/bootstrap/src/core/build_steps/setup.rs | 19 +++++++++++++++---- 1 file changed, 15 insertions(+), 4 deletions(-) diff --git a/src/bootstrap/src/core/build_steps/setup.rs b/src/bootstrap/src/core/build_steps/setup.rs index 8cd9ba5fd146..f7b26712cabd 100644 --- a/src/bootstrap/src/core/build_steps/setup.rs +++ b/src/bootstrap/src/core/build_steps/setup.rs @@ -247,9 +247,11 @@ pub struct Link; impl Step for Link { type Output = (); const DEFAULT: bool = true; + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.alias("link") } + fn make_run(run: RunConfig<'_>) { if run.builder.config.dry_run() { return; @@ -262,21 +264,30 @@ impl Step for Link { } fn run(self, builder: &Builder<'_>) -> Self::Output { let config = &builder.config; + if config.dry_run() { return; } + + if !rustup_installed(builder) { + println!("WARNING: `rustup` is not installed; Skipping `stage1` toolchain linking."); + return; + } + let stage_path = ["build", config.build.rustc_target_arg(), "stage1"].join(MAIN_SEPARATOR_STR); - if !rustup_installed(builder) { - eprintln!("`rustup` is not installed; cannot link `stage1` toolchain"); - } else if stage_dir_exists(&stage_path[..]) && !config.dry_run() { + + if stage_dir_exists(&stage_path[..]) && !config.dry_run() { attempt_toolchain_link(builder, &stage_path[..]); } } } fn rustup_installed(builder: &Builder<'_>) -> bool { - command("rustup").arg("--version").run_capture_stdout(builder).is_success() + let mut rustup = command("rustup"); + rustup.arg("--version"); + + rustup.allow_failure().run_always().run_capture_stdout(builder).is_success() } fn stage_dir_exists(stage_path: &str) -> bool { From de9b5c3ea280112169887065354706e102e6290d Mon Sep 17 00:00:00 2001 From: carbotaniuman <41451839+carbotaniuman@users.noreply.github.com> Date: Wed, 7 Aug 2024 01:36:28 -0500 Subject: [PATCH 11/79] Stabilize `unsafe_attributes` --- .../rustc_ast_passes/src/ast_validation.rs | 2 +- compiler/rustc_ast_passes/src/feature_gate.rs | 1 - .../src/cfg_accessible.rs | 1 - compiler/rustc_builtin_macros/src/derive.rs | 1 - compiler/rustc_builtin_macros/src/util.rs | 1 - compiler/rustc_expand/src/config.rs | 13 +----- compiler/rustc_expand/src/expand.rs | 2 +- compiler/rustc_feature/src/accepted.rs | 2 + compiler/rustc_feature/src/unstable.rs | 2 - compiler/rustc_lint_defs/src/builtin.rs | 1 - compiler/rustc_parse/src/parser/attr.rs | 4 +- compiler/rustc_parse/src/validate_attr.rs | 40 ++++++------------- .../rustfmt/tests/target/unsafe_attributes.rs | 1 - .../unsafe/cfg-unsafe-attributes.rs | 1 - .../unsafe/derive-unsafe-attributes.rs | 2 - .../unsafe/derive-unsafe-attributes.stderr | 14 +++---- .../unsafe/double-unsafe-attributes.rs | 2 - .../unsafe/double-unsafe-attributes.stderr | 6 +-- .../unsafe/extraneous-unsafe-attributes.rs | 1 - .../extraneous-unsafe-attributes.stderr | 16 ++++---- .../unsafe/proc-unsafe-attributes.rs | 2 - .../unsafe/proc-unsafe-attributes.stderr | 30 +++++++------- .../ui/attributes/unsafe/unsafe-attributes.rs | 1 - .../unsafe/unsafe-safe-attribute.rs | 2 - .../unsafe/unsafe-safe-attribute.stderr | 2 +- .../unsafe-safe-attribute_diagnostic.rs | 2 - .../unsafe-safe-attribute_diagnostic.stderr | 2 +- .../feature-gate-unsafe-attributes.rs | 8 ---- .../feature-gate-unsafe-attributes.stderr | 13 ------ .../in_2024_compatibility.rs | 1 - .../in_2024_compatibility.stderr | 2 +- .../unsafe-attribute-marked.rs | 1 - .../unsafe-attributes-fix.fixed | 1 - .../unsafe-attributes-fix.rs | 1 - .../unsafe-attributes-fix.stderr | 14 +++---- .../unsafe-attributes.edition2024.stderr | 2 +- .../unsafe-attributes/unsafe-attributes.rs | 1 - 37 files changed, 64 insertions(+), 134 deletions(-) delete mode 100644 tests/ui/feature-gates/feature-gate-unsafe-attributes.rs delete mode 100644 tests/ui/feature-gates/feature-gate-unsafe-attributes.stderr diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs index a353c79f12d4..837cb805700d 100644 --- a/compiler/rustc_ast_passes/src/ast_validation.rs +++ b/compiler/rustc_ast_passes/src/ast_validation.rs @@ -887,7 +887,7 @@ fn validate_generic_param_order(dcx: DiagCtxtHandle<'_>, generics: &[GenericPara impl<'a> Visitor<'a> for AstValidator<'a> { fn visit_attribute(&mut self, attr: &Attribute) { - validate_attr::check_attr(&self.features, &self.session.psess, attr); + validate_attr::check_attr(&self.session.psess, attr); } fn visit_ty(&mut self, ty: &'a Ty) { diff --git a/compiler/rustc_ast_passes/src/feature_gate.rs b/compiler/rustc_ast_passes/src/feature_gate.rs index 3ceb8e0711a2..214a37bca03e 100644 --- a/compiler/rustc_ast_passes/src/feature_gate.rs +++ b/compiler/rustc_ast_passes/src/feature_gate.rs @@ -559,7 +559,6 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session, features: &Features) { gate_all!(mut_ref, "mutable by-reference bindings are experimental"); gate_all!(precise_capturing, "precise captures on `impl Trait` are experimental"); gate_all!(global_registration, "global registration is experimental"); - gate_all!(unsafe_attributes, "`#[unsafe()]` markers for attributes are experimental"); gate_all!(return_type_notation, "return type notation is experimental"); if !visitor.features.never_patterns { diff --git a/compiler/rustc_builtin_macros/src/cfg_accessible.rs b/compiler/rustc_builtin_macros/src/cfg_accessible.rs index 006b6aa823fb..3d3bd3aea059 100644 --- a/compiler/rustc_builtin_macros/src/cfg_accessible.rs +++ b/compiler/rustc_builtin_macros/src/cfg_accessible.rs @@ -47,7 +47,6 @@ impl MultiItemModifier for Expander { ) -> ExpandResult, Annotatable> { let template = AttributeTemplate { list: Some("path"), ..Default::default() }; validate_attr::check_builtin_meta_item( - &ecx.ecfg.features, &ecx.sess.psess, meta_item, ast::AttrStyle::Outer, diff --git a/compiler/rustc_builtin_macros/src/derive.rs b/compiler/rustc_builtin_macros/src/derive.rs index 57bddf0ab60a..e8704bc2f639 100644 --- a/compiler/rustc_builtin_macros/src/derive.rs +++ b/compiler/rustc_builtin_macros/src/derive.rs @@ -38,7 +38,6 @@ impl MultiItemModifier for Expander { let template = AttributeTemplate { list: Some("Trait1, Trait2, ..."), ..Default::default() }; validate_attr::check_builtin_meta_item( - features, &sess.psess, meta_item, ast::AttrStyle::Outer, diff --git a/compiler/rustc_builtin_macros/src/util.rs b/compiler/rustc_builtin_macros/src/util.rs index 73cc8ff547d5..0bcd5aef28ba 100644 --- a/compiler/rustc_builtin_macros/src/util.rs +++ b/compiler/rustc_builtin_macros/src/util.rs @@ -17,7 +17,6 @@ pub(crate) fn check_builtin_macro_attribute(ecx: &ExtCtxt<'_>, meta_item: &MetaI // All the built-in macro attributes are "words" at the moment. let template = AttributeTemplate { word: true, ..Default::default() }; validate_attr::check_builtin_meta_item( - &ecx.ecfg.features, &ecx.sess.psess, meta_item, AttrStyle::Outer, diff --git a/compiler/rustc_expand/src/config.rs b/compiler/rustc_expand/src/config.rs index f6bf9f5e89f2..b0d3fecbb479 100644 --- a/compiler/rustc_expand/src/config.rs +++ b/compiler/rustc_expand/src/config.rs @@ -265,12 +265,7 @@ impl<'a> StripUnconfigured<'a> { /// is in the original source file. Gives a compiler error if the syntax of /// the attribute is incorrect. pub(crate) fn expand_cfg_attr(&self, cfg_attr: &Attribute, recursive: bool) -> Vec { - validate_attr::check_attribute_safety( - self.features.unwrap_or(&Features::default()), - &self.sess.psess, - AttributeSafety::Normal, - &cfg_attr, - ); + validate_attr::check_attribute_safety(&self.sess.psess, AttributeSafety::Normal, &cfg_attr); let Some((cfg_predicate, expanded_attrs)) = rustc_parse::parse_cfg_attr(cfg_attr, &self.sess.psess) @@ -395,11 +390,7 @@ impl<'a> StripUnconfigured<'a> { } }; - validate_attr::deny_builtin_meta_unsafety( - self.features.unwrap_or(&Features::default()), - &self.sess.psess, - &meta_item, - ); + validate_attr::deny_builtin_meta_unsafety(&self.sess.psess, &meta_item); ( parse_cfg(&meta_item, self.sess).map_or(true, |meta_item| { diff --git a/compiler/rustc_expand/src/expand.rs b/compiler/rustc_expand/src/expand.rs index d8cb367e3fac..61b36e15487e 100644 --- a/compiler/rustc_expand/src/expand.rs +++ b/compiler/rustc_expand/src/expand.rs @@ -1883,7 +1883,7 @@ impl<'a, 'b> InvocationCollector<'a, 'b> { let mut span: Option = None; while let Some(attr) = attrs.next() { rustc_ast_passes::feature_gate::check_attribute(attr, self.cx.sess, features); - validate_attr::check_attr(features, &self.cx.sess.psess, attr); + validate_attr::check_attr(&self.cx.sess.psess, attr); let current_span = if let Some(sp) = span { sp.to(attr.span) } else { attr.span }; span = Some(current_span); diff --git a/compiler/rustc_feature/src/accepted.rs b/compiler/rustc_feature/src/accepted.rs index e42a655531b5..689e2d2771e6 100644 --- a/compiler/rustc_feature/src/accepted.rs +++ b/compiler/rustc_feature/src/accepted.rs @@ -388,6 +388,8 @@ declare_features! ( (accepted, universal_impl_trait, "1.26.0", Some(34511)), /// Allows arbitrary delimited token streams in non-macro attributes. (accepted, unrestricted_attribute_tokens, "1.34.0", Some(55208)), + /// Allows unsafe attributes. + (accepted, unsafe_attributes, "CURRENT_RUSTC_VERSION", Some(123757)), /// The `unsafe_op_in_unsafe_fn` lint (allowed by default): no longer treat an unsafe function as an unsafe block. (accepted, unsafe_block_in_unsafe_fn, "1.52.0", Some(71668)), /// Allows unsafe on extern declarations and safety qualifiers over internal items. diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs index 88a4b5a83824..a9e9bdd6a419 100644 --- a/compiler/rustc_feature/src/unstable.rs +++ b/compiler/rustc_feature/src/unstable.rs @@ -627,8 +627,6 @@ declare_features! ( (unstable, type_changing_struct_update, "1.58.0", Some(86555)), /// Allows unnamed fields of struct and union type (incomplete, unnamed_fields, "1.74.0", Some(49804)), - /// Allows unsafe attributes. - (unstable, unsafe_attributes, "1.80.0", Some(123757)), /// Allows const generic parameters to be defined with types that /// are not `Sized`, e.g. `fn foo() {`. (incomplete, unsized_const_params, "CURRENT_RUSTC_VERSION", Some(95174)), diff --git a/compiler/rustc_lint_defs/src/builtin.rs b/compiler/rustc_lint_defs/src/builtin.rs index ff0bdfcc9d26..aa281a6f67b4 100644 --- a/compiler/rustc_lint_defs/src/builtin.rs +++ b/compiler/rustc_lint_defs/src/builtin.rs @@ -4937,7 +4937,6 @@ declare_lint! { /// ### Example /// /// ```rust - /// #![feature(unsafe_attributes)] /// #![warn(unsafe_attr_outside_unsafe)] /// /// #[no_mangle] diff --git a/compiler/rustc_parse/src/parser/attr.rs b/compiler/rustc_parse/src/parser/attr.rs index 8fdfbcee3854..4fea00edebc6 100644 --- a/compiler/rustc_parse/src/parser/attr.rs +++ b/compiler/rustc_parse/src/parser/attr.rs @@ -4,7 +4,7 @@ use rustc_ast::token::{self, Delimiter}; use rustc_errors::codes::*; use rustc_errors::{Diag, PResult}; use rustc_span::symbol::kw; -use rustc_span::{sym, BytePos, Span}; +use rustc_span::{BytePos, Span}; use thin_vec::ThinVec; use tracing::debug; @@ -261,7 +261,6 @@ impl<'a> Parser<'a> { let is_unsafe = this.eat_keyword(kw::Unsafe); let unsafety = if is_unsafe { let unsafe_span = this.prev_token.span; - this.psess.gated_spans.gate(sym::unsafe_attributes, unsafe_span); this.expect(&token::OpenDelim(Delimiter::Parenthesis))?; ast::Safety::Unsafe(unsafe_span) } else { @@ -400,7 +399,6 @@ impl<'a> Parser<'a> { }; let unsafety = if is_unsafe { let unsafe_span = self.prev_token.span; - self.psess.gated_spans.gate(sym::unsafe_attributes, unsafe_span); self.expect(&token::OpenDelim(Delimiter::Parenthesis))?; ast::Safety::Unsafe(unsafe_span) diff --git a/compiler/rustc_parse/src/validate_attr.rs b/compiler/rustc_parse/src/validate_attr.rs index a64c00f3b6cb..fce41bd90be7 100644 --- a/compiler/rustc_parse/src/validate_attr.rs +++ b/compiler/rustc_parse/src/validate_attr.rs @@ -7,9 +7,7 @@ use rustc_ast::{ NestedMetaItem, Safety, }; use rustc_errors::{Applicability, FatalError, PResult}; -use rustc_feature::{ - AttributeSafety, AttributeTemplate, BuiltinAttribute, Features, BUILTIN_ATTRIBUTE_MAP, -}; +use rustc_feature::{AttributeSafety, AttributeTemplate, BuiltinAttribute, BUILTIN_ATTRIBUTE_MAP}; use rustc_session::errors::report_lit_error; use rustc_session::lint::builtin::{ILL_FORMED_ATTRIBUTE_INPUT, UNSAFE_ATTR_OUTSIDE_UNSAFE}; use rustc_session::lint::BuiltinLintDiag; @@ -18,7 +16,7 @@ use rustc_span::{sym, BytePos, Span, Symbol}; use crate::{errors, parse_in}; -pub fn check_attr(features: &Features, psess: &ParseSess, attr: &Attribute) { +pub fn check_attr(psess: &ParseSess, attr: &Attribute) { if attr.is_doc_comment() { return; } @@ -28,7 +26,7 @@ pub fn check_attr(features: &Features, psess: &ParseSess, attr: &Attribute) { // All non-builtin attributes are considered safe let safety = attr_info.map(|x| x.safety).unwrap_or(AttributeSafety::Normal); - check_attribute_safety(features, psess, safety, attr); + check_attribute_safety(psess, safety, attr); // Check input tokens for built-in and key-value attributes. match attr_info { @@ -36,9 +34,9 @@ pub fn check_attr(features: &Features, psess: &ParseSess, attr: &Attribute) { Some(BuiltinAttribute { name, template, .. }) if *name != sym::rustc_dummy => { match parse_meta(psess, attr) { // Don't check safety again, we just did that - Ok(meta) => check_builtin_meta_item( - features, psess, &meta, attr.style, *name, *template, false, - ), + Ok(meta) => { + check_builtin_meta_item(psess, &meta, attr.style, *name, *template, false) + } Err(err) => { err.emit(); } @@ -157,16 +155,7 @@ fn is_attr_template_compatible(template: &AttributeTemplate, meta: &ast::MetaIte } } -pub fn check_attribute_safety( - features: &Features, - psess: &ParseSess, - safety: AttributeSafety, - attr: &Attribute, -) { - if !features.unsafe_attributes { - return; - } - +pub fn check_attribute_safety(psess: &ParseSess, safety: AttributeSafety, attr: &Attribute) { let attr_item = attr.get_normal_item(); if safety == AttributeSafety::Unsafe { @@ -215,21 +204,18 @@ pub fn check_attribute_safety( // Called by `check_builtin_meta_item` and code that manually denies // `unsafe(...)` in `cfg` -pub fn deny_builtin_meta_unsafety(features: &Features, psess: &ParseSess, meta: &MetaItem) { +pub fn deny_builtin_meta_unsafety(psess: &ParseSess, meta: &MetaItem) { // This only supports denying unsafety right now - making builtin attributes // support unsafety will requite us to thread the actual `Attribute` through // for the nice diagnostics. - if features.unsafe_attributes { - if let Safety::Unsafe(unsafe_span) = meta.unsafety { - psess - .dcx() - .emit_err(errors::InvalidAttrUnsafe { span: unsafe_span, name: meta.path.clone() }); - } + if let Safety::Unsafe(unsafe_span) = meta.unsafety { + psess + .dcx() + .emit_err(errors::InvalidAttrUnsafe { span: unsafe_span, name: meta.path.clone() }); } } pub fn check_builtin_meta_item( - features: &Features, psess: &ParseSess, meta: &MetaItem, style: ast::AttrStyle, @@ -246,7 +232,7 @@ pub fn check_builtin_meta_item( } if deny_unsafety { - deny_builtin_meta_unsafety(features, psess, meta); + deny_builtin_meta_unsafety(psess, meta); } } diff --git a/src/tools/rustfmt/tests/target/unsafe_attributes.rs b/src/tools/rustfmt/tests/target/unsafe_attributes.rs index a05bedc751ae..d79c56f21479 100644 --- a/src/tools/rustfmt/tests/target/unsafe_attributes.rs +++ b/src/tools/rustfmt/tests/target/unsafe_attributes.rs @@ -1,4 +1,3 @@ -#![feature(unsafe_attributes)] // https://github.com/rust-lang/rust/issues/123757 // #![simple_ident] diff --git a/tests/ui/attributes/unsafe/cfg-unsafe-attributes.rs b/tests/ui/attributes/unsafe/cfg-unsafe-attributes.rs index ce365d1a8b1c..6a9853b2f6fc 100644 --- a/tests/ui/attributes/unsafe/cfg-unsafe-attributes.rs +++ b/tests/ui/attributes/unsafe/cfg-unsafe-attributes.rs @@ -1,5 +1,4 @@ //@ build-pass -#![feature(unsafe_attributes)] #[cfg_attr(all(), unsafe(no_mangle))] fn a() {} diff --git a/tests/ui/attributes/unsafe/derive-unsafe-attributes.rs b/tests/ui/attributes/unsafe/derive-unsafe-attributes.rs index b8edb4aab907..95fc19f506b2 100644 --- a/tests/ui/attributes/unsafe/derive-unsafe-attributes.rs +++ b/tests/ui/attributes/unsafe/derive-unsafe-attributes.rs @@ -1,5 +1,3 @@ -#![feature(unsafe_attributes)] - #[derive(unsafe(Debug))] //~^ ERROR: expected identifier, found keyword `unsafe` //~| ERROR: traits in `#[derive(...)]` don't accept arguments diff --git a/tests/ui/attributes/unsafe/derive-unsafe-attributes.stderr b/tests/ui/attributes/unsafe/derive-unsafe-attributes.stderr index c40a5512fd5c..4002c930b63e 100644 --- a/tests/ui/attributes/unsafe/derive-unsafe-attributes.stderr +++ b/tests/ui/attributes/unsafe/derive-unsafe-attributes.stderr @@ -1,5 +1,5 @@ error: expected identifier, found keyword `unsafe` - --> $DIR/derive-unsafe-attributes.rs:3:10 + --> $DIR/derive-unsafe-attributes.rs:1:10 | LL | #[derive(unsafe(Debug))] | ^^^^^^ expected identifier, found keyword @@ -10,13 +10,13 @@ LL | #[derive(r#unsafe(Debug))] | ++ error: traits in `#[derive(...)]` don't accept arguments - --> $DIR/derive-unsafe-attributes.rs:3:16 + --> $DIR/derive-unsafe-attributes.rs:1:16 | LL | #[derive(unsafe(Debug))] | ^^^^^^^ help: remove the arguments error: `derive` is not an unsafe attribute - --> $DIR/derive-unsafe-attributes.rs:12:3 + --> $DIR/derive-unsafe-attributes.rs:10:3 | LL | #[unsafe(derive(Debug))] | ^^^^^^ this is not an unsafe attribute @@ -24,7 +24,7 @@ LL | #[unsafe(derive(Debug))] = note: extraneous unsafe is not allowed in attributes error: expected identifier, found keyword `unsafe` - --> $DIR/derive-unsafe-attributes.rs:3:10 + --> $DIR/derive-unsafe-attributes.rs:1:10 | LL | #[derive(unsafe(Debug))] | ^^^^^^ expected identifier, found keyword @@ -36,7 +36,7 @@ LL | #[derive(r#unsafe(Debug))] | ++ error: expected identifier, found keyword `unsafe` - --> $DIR/derive-unsafe-attributes.rs:3:10 + --> $DIR/derive-unsafe-attributes.rs:1:10 | LL | #[derive(unsafe(Debug))] | ^^^^^^ expected identifier, found keyword @@ -48,13 +48,13 @@ LL | #[derive(r#unsafe(Debug))] | ++ error: cannot find derive macro `r#unsafe` in this scope - --> $DIR/derive-unsafe-attributes.rs:3:10 + --> $DIR/derive-unsafe-attributes.rs:1:10 | LL | #[derive(unsafe(Debug))] | ^^^^^^ error: cannot find derive macro `r#unsafe` in this scope - --> $DIR/derive-unsafe-attributes.rs:3:10 + --> $DIR/derive-unsafe-attributes.rs:1:10 | LL | #[derive(unsafe(Debug))] | ^^^^^^ diff --git a/tests/ui/attributes/unsafe/double-unsafe-attributes.rs b/tests/ui/attributes/unsafe/double-unsafe-attributes.rs index a6c0ea578f25..894d1327da79 100644 --- a/tests/ui/attributes/unsafe/double-unsafe-attributes.rs +++ b/tests/ui/attributes/unsafe/double-unsafe-attributes.rs @@ -1,5 +1,3 @@ -#![feature(unsafe_attributes)] - #[unsafe(unsafe(no_mangle))] //~^ ERROR expected identifier, found keyword `unsafe` //~| ERROR cannot find attribute `r#unsafe` in this scope diff --git a/tests/ui/attributes/unsafe/double-unsafe-attributes.stderr b/tests/ui/attributes/unsafe/double-unsafe-attributes.stderr index 950b2636993c..0825cf794083 100644 --- a/tests/ui/attributes/unsafe/double-unsafe-attributes.stderr +++ b/tests/ui/attributes/unsafe/double-unsafe-attributes.stderr @@ -1,5 +1,5 @@ error: expected identifier, found keyword `unsafe` - --> $DIR/double-unsafe-attributes.rs:3:10 + --> $DIR/double-unsafe-attributes.rs:1:10 | LL | #[unsafe(unsafe(no_mangle))] | ^^^^^^ expected identifier, found keyword @@ -10,7 +10,7 @@ LL | #[unsafe(r#unsafe(no_mangle))] | ++ error: `r#unsafe` is not an unsafe attribute - --> $DIR/double-unsafe-attributes.rs:3:3 + --> $DIR/double-unsafe-attributes.rs:1:3 | LL | #[unsafe(unsafe(no_mangle))] | ^^^^^^ this is not an unsafe attribute @@ -18,7 +18,7 @@ LL | #[unsafe(unsafe(no_mangle))] = note: extraneous unsafe is not allowed in attributes error: cannot find attribute `r#unsafe` in this scope - --> $DIR/double-unsafe-attributes.rs:3:10 + --> $DIR/double-unsafe-attributes.rs:1:10 | LL | #[unsafe(unsafe(no_mangle))] | ^^^^^^ diff --git a/tests/ui/attributes/unsafe/extraneous-unsafe-attributes.rs b/tests/ui/attributes/unsafe/extraneous-unsafe-attributes.rs index 0181add843bc..b561550c1984 100644 --- a/tests/ui/attributes/unsafe/extraneous-unsafe-attributes.rs +++ b/tests/ui/attributes/unsafe/extraneous-unsafe-attributes.rs @@ -1,6 +1,5 @@ //@ edition: 2024 //@ compile-flags: -Zunstable-options -#![feature(unsafe_attributes)] #[unsafe(cfg(any()))] //~ ERROR: is not an unsafe attribute fn a() {} diff --git a/tests/ui/attributes/unsafe/extraneous-unsafe-attributes.stderr b/tests/ui/attributes/unsafe/extraneous-unsafe-attributes.stderr index f39074b613d4..9fb7f062b912 100644 --- a/tests/ui/attributes/unsafe/extraneous-unsafe-attributes.stderr +++ b/tests/ui/attributes/unsafe/extraneous-unsafe-attributes.stderr @@ -1,5 +1,5 @@ error: `cfg` is not an unsafe attribute - --> $DIR/extraneous-unsafe-attributes.rs:5:3 + --> $DIR/extraneous-unsafe-attributes.rs:4:3 | LL | #[unsafe(cfg(any()))] | ^^^^^^ this is not an unsafe attribute @@ -7,7 +7,7 @@ LL | #[unsafe(cfg(any()))] = note: extraneous unsafe is not allowed in attributes error: `cfg_attr` is not an unsafe attribute - --> $DIR/extraneous-unsafe-attributes.rs:8:3 + --> $DIR/extraneous-unsafe-attributes.rs:7:3 | LL | #[unsafe(cfg_attr(any(), allow(dead_code)))] | ^^^^^^ this is not an unsafe attribute @@ -15,7 +15,7 @@ LL | #[unsafe(cfg_attr(any(), allow(dead_code)))] = note: extraneous unsafe is not allowed in attributes error: `test` is not an unsafe attribute - --> $DIR/extraneous-unsafe-attributes.rs:11:3 + --> $DIR/extraneous-unsafe-attributes.rs:10:3 | LL | #[unsafe(test)] | ^^^^^^ this is not an unsafe attribute @@ -23,7 +23,7 @@ LL | #[unsafe(test)] = note: extraneous unsafe is not allowed in attributes error: `ignore` is not an unsafe attribute - --> $DIR/extraneous-unsafe-attributes.rs:14:3 + --> $DIR/extraneous-unsafe-attributes.rs:13:3 | LL | #[unsafe(ignore = "test")] | ^^^^^^ this is not an unsafe attribute @@ -31,7 +31,7 @@ LL | #[unsafe(ignore = "test")] = note: extraneous unsafe is not allowed in attributes error: `should_panic` is not an unsafe attribute - --> $DIR/extraneous-unsafe-attributes.rs:17:3 + --> $DIR/extraneous-unsafe-attributes.rs:16:3 | LL | #[unsafe(should_panic(expected = "test"))] | ^^^^^^ this is not an unsafe attribute @@ -39,7 +39,7 @@ LL | #[unsafe(should_panic(expected = "test"))] = note: extraneous unsafe is not allowed in attributes error: `macro_use` is not an unsafe attribute - --> $DIR/extraneous-unsafe-attributes.rs:20:3 + --> $DIR/extraneous-unsafe-attributes.rs:19:3 | LL | #[unsafe(macro_use)] | ^^^^^^ this is not an unsafe attribute @@ -47,7 +47,7 @@ LL | #[unsafe(macro_use)] = note: extraneous unsafe is not allowed in attributes error: `macro_export` is not an unsafe attribute - --> $DIR/extraneous-unsafe-attributes.rs:22:7 + --> $DIR/extraneous-unsafe-attributes.rs:21:7 | LL | #[unsafe(macro_export)] | ^^^^^^ this is not an unsafe attribute @@ -55,7 +55,7 @@ LL | #[unsafe(macro_export)] = note: extraneous unsafe is not allowed in attributes error: `used` is not an unsafe attribute - --> $DIR/extraneous-unsafe-attributes.rs:28:3 + --> $DIR/extraneous-unsafe-attributes.rs:27:3 | LL | #[unsafe(used)] | ^^^^^^ this is not an unsafe attribute diff --git a/tests/ui/attributes/unsafe/proc-unsafe-attributes.rs b/tests/ui/attributes/unsafe/proc-unsafe-attributes.rs index f29a5b3252b0..eaf8706369a5 100644 --- a/tests/ui/attributes/unsafe/proc-unsafe-attributes.rs +++ b/tests/ui/attributes/unsafe/proc-unsafe-attributes.rs @@ -1,5 +1,3 @@ -#![feature(unsafe_attributes)] - #[unsafe(proc_macro)] //~^ ERROR: is not an unsafe attribute //~| ERROR attribute is only usable with crates of the `proc-macro` crate type diff --git a/tests/ui/attributes/unsafe/proc-unsafe-attributes.stderr b/tests/ui/attributes/unsafe/proc-unsafe-attributes.stderr index 79d34d458bd6..9c5751c82e4c 100644 --- a/tests/ui/attributes/unsafe/proc-unsafe-attributes.stderr +++ b/tests/ui/attributes/unsafe/proc-unsafe-attributes.stderr @@ -1,11 +1,11 @@ error[E0452]: malformed lint attribute input - --> $DIR/proc-unsafe-attributes.rs:28:16 + --> $DIR/proc-unsafe-attributes.rs:26:16 | LL | #[unsafe(allow(unsafe(dead_code)))] | ^^^^^^^^^^^^^^^^^ bad attribute argument error[E0452]: malformed lint attribute input - --> $DIR/proc-unsafe-attributes.rs:28:16 + --> $DIR/proc-unsafe-attributes.rs:26:16 | LL | #[unsafe(allow(unsafe(dead_code)))] | ^^^^^^^^^^^^^^^^^ bad attribute argument @@ -13,7 +13,7 @@ LL | #[unsafe(allow(unsafe(dead_code)))] = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no` error: `proc_macro` is not an unsafe attribute - --> $DIR/proc-unsafe-attributes.rs:3:3 + --> $DIR/proc-unsafe-attributes.rs:1:3 | LL | #[unsafe(proc_macro)] | ^^^^^^ this is not an unsafe attribute @@ -21,7 +21,7 @@ LL | #[unsafe(proc_macro)] = note: extraneous unsafe is not allowed in attributes error: `proc_macro_derive` is not an unsafe attribute - --> $DIR/proc-unsafe-attributes.rs:9:3 + --> $DIR/proc-unsafe-attributes.rs:7:3 | LL | #[unsafe(proc_macro_derive(Foo))] | ^^^^^^ this is not an unsafe attribute @@ -29,7 +29,7 @@ LL | #[unsafe(proc_macro_derive(Foo))] = note: extraneous unsafe is not allowed in attributes error: expected identifier, found keyword `unsafe` - --> $DIR/proc-unsafe-attributes.rs:14:21 + --> $DIR/proc-unsafe-attributes.rs:12:21 | LL | #[proc_macro_derive(unsafe(Foo))] | ^^^^^^ expected identifier, found keyword @@ -40,7 +40,7 @@ LL | #[proc_macro_derive(r#unsafe(Foo))] | ++ error: `proc_macro_attribute` is not an unsafe attribute - --> $DIR/proc-unsafe-attributes.rs:19:3 + --> $DIR/proc-unsafe-attributes.rs:17:3 | LL | #[unsafe(proc_macro_attribute)] | ^^^^^^ this is not an unsafe attribute @@ -48,7 +48,7 @@ LL | #[unsafe(proc_macro_attribute)] = note: extraneous unsafe is not allowed in attributes error: `allow` is not an unsafe attribute - --> $DIR/proc-unsafe-attributes.rs:24:3 + --> $DIR/proc-unsafe-attributes.rs:22:3 | LL | #[unsafe(allow(dead_code))] | ^^^^^^ this is not an unsafe attribute @@ -56,7 +56,7 @@ LL | #[unsafe(allow(dead_code))] = note: extraneous unsafe is not allowed in attributes error: `allow` is not an unsafe attribute - --> $DIR/proc-unsafe-attributes.rs:28:3 + --> $DIR/proc-unsafe-attributes.rs:26:3 | LL | #[unsafe(allow(unsafe(dead_code)))] | ^^^^^^ this is not an unsafe attribute @@ -64,7 +64,7 @@ LL | #[unsafe(allow(unsafe(dead_code)))] = note: extraneous unsafe is not allowed in attributes error: expected identifier, found keyword `unsafe` - --> $DIR/proc-unsafe-attributes.rs:28:16 + --> $DIR/proc-unsafe-attributes.rs:26:16 | LL | #[unsafe(allow(unsafe(dead_code)))] | ^^^^^^ expected identifier, found keyword @@ -75,31 +75,31 @@ LL | #[unsafe(allow(r#unsafe(dead_code)))] | ++ error: the `#[proc_macro]` attribute is only usable with crates of the `proc-macro` crate type - --> $DIR/proc-unsafe-attributes.rs:3:1 + --> $DIR/proc-unsafe-attributes.rs:1:1 | LL | #[unsafe(proc_macro)] | ^^^^^^^^^^^^^^^^^^^^^ error: the `#[proc_macro_derive]` attribute is only usable with crates of the `proc-macro` crate type - --> $DIR/proc-unsafe-attributes.rs:9:1 + --> $DIR/proc-unsafe-attributes.rs:7:1 | LL | #[unsafe(proc_macro_derive(Foo))] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: the `#[proc_macro_derive]` attribute is only usable with crates of the `proc-macro` crate type - --> $DIR/proc-unsafe-attributes.rs:14:1 + --> $DIR/proc-unsafe-attributes.rs:12:1 | LL | #[proc_macro_derive(unsafe(Foo))] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: the `#[proc_macro_attribute]` attribute is only usable with crates of the `proc-macro` crate type - --> $DIR/proc-unsafe-attributes.rs:19:1 + --> $DIR/proc-unsafe-attributes.rs:17:1 | LL | #[unsafe(proc_macro_attribute)] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error[E0452]: malformed lint attribute input - --> $DIR/proc-unsafe-attributes.rs:28:16 + --> $DIR/proc-unsafe-attributes.rs:26:16 | LL | #[unsafe(allow(unsafe(dead_code)))] | ^^^^^^^^^^^^^^^^^ bad attribute argument @@ -107,7 +107,7 @@ LL | #[unsafe(allow(unsafe(dead_code)))] = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no` error[E0452]: malformed lint attribute input - --> $DIR/proc-unsafe-attributes.rs:28:16 + --> $DIR/proc-unsafe-attributes.rs:26:16 | LL | #[unsafe(allow(unsafe(dead_code)))] | ^^^^^^^^^^^^^^^^^ bad attribute argument diff --git a/tests/ui/attributes/unsafe/unsafe-attributes.rs b/tests/ui/attributes/unsafe/unsafe-attributes.rs index 33a412add500..5c57767b3b96 100644 --- a/tests/ui/attributes/unsafe/unsafe-attributes.rs +++ b/tests/ui/attributes/unsafe/unsafe-attributes.rs @@ -1,5 +1,4 @@ //@ build-pass -#![feature(unsafe_attributes)] #[unsafe(no_mangle)] fn a() {} diff --git a/tests/ui/attributes/unsafe/unsafe-safe-attribute.rs b/tests/ui/attributes/unsafe/unsafe-safe-attribute.rs index 67db36afd2e6..5af03a2b8d13 100644 --- a/tests/ui/attributes/unsafe/unsafe-safe-attribute.rs +++ b/tests/ui/attributes/unsafe/unsafe-safe-attribute.rs @@ -1,5 +1,3 @@ -#![feature(unsafe_attributes)] - #[unsafe(repr(C))] //~ ERROR: is not an unsafe attribute struct Foo {} diff --git a/tests/ui/attributes/unsafe/unsafe-safe-attribute.stderr b/tests/ui/attributes/unsafe/unsafe-safe-attribute.stderr index 584b0ea797d0..55172c91aaee 100644 --- a/tests/ui/attributes/unsafe/unsafe-safe-attribute.stderr +++ b/tests/ui/attributes/unsafe/unsafe-safe-attribute.stderr @@ -1,5 +1,5 @@ error: `repr` is not an unsafe attribute - --> $DIR/unsafe-safe-attribute.rs:3:3 + --> $DIR/unsafe-safe-attribute.rs:1:3 | LL | #[unsafe(repr(C))] | ^^^^^^ this is not an unsafe attribute diff --git a/tests/ui/attributes/unsafe/unsafe-safe-attribute_diagnostic.rs b/tests/ui/attributes/unsafe/unsafe-safe-attribute_diagnostic.rs index ff2eb61b4053..0f241cc439f3 100644 --- a/tests/ui/attributes/unsafe/unsafe-safe-attribute_diagnostic.rs +++ b/tests/ui/attributes/unsafe/unsafe-safe-attribute_diagnostic.rs @@ -1,5 +1,3 @@ -#![feature(unsafe_attributes)] - #[unsafe(diagnostic::on_unimplemented( //~ ERROR: is not an unsafe attribute message = "testing", ))] diff --git a/tests/ui/attributes/unsafe/unsafe-safe-attribute_diagnostic.stderr b/tests/ui/attributes/unsafe/unsafe-safe-attribute_diagnostic.stderr index 26b5e4e37b93..3bc291db5acf 100644 --- a/tests/ui/attributes/unsafe/unsafe-safe-attribute_diagnostic.stderr +++ b/tests/ui/attributes/unsafe/unsafe-safe-attribute_diagnostic.stderr @@ -1,5 +1,5 @@ error: `diagnostic::on_unimplemented` is not an unsafe attribute - --> $DIR/unsafe-safe-attribute_diagnostic.rs:3:3 + --> $DIR/unsafe-safe-attribute_diagnostic.rs:1:3 | LL | #[unsafe(diagnostic::on_unimplemented( | ^^^^^^ this is not an unsafe attribute diff --git a/tests/ui/feature-gates/feature-gate-unsafe-attributes.rs b/tests/ui/feature-gates/feature-gate-unsafe-attributes.rs deleted file mode 100644 index 9eba415dda0e..000000000000 --- a/tests/ui/feature-gates/feature-gate-unsafe-attributes.rs +++ /dev/null @@ -1,8 +0,0 @@ -#[unsafe(no_mangle)] //~ ERROR [E0658] -extern "C" fn foo() { - -} - -fn main() { - foo(); -} diff --git a/tests/ui/feature-gates/feature-gate-unsafe-attributes.stderr b/tests/ui/feature-gates/feature-gate-unsafe-attributes.stderr deleted file mode 100644 index dfcea756b02b..000000000000 --- a/tests/ui/feature-gates/feature-gate-unsafe-attributes.stderr +++ /dev/null @@ -1,13 +0,0 @@ -error[E0658]: `#[unsafe()]` markers for attributes are experimental - --> $DIR/feature-gate-unsafe-attributes.rs:1:3 - | -LL | #[unsafe(no_mangle)] - | ^^^^^^ - | - = note: see issue #123757 for more information - = help: add `#![feature(unsafe_attributes)]` to the crate attributes to enable - = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date - -error: aborting due to 1 previous error - -For more information about this error, try `rustc --explain E0658`. diff --git a/tests/ui/rust-2024/unsafe-attributes/in_2024_compatibility.rs b/tests/ui/rust-2024/unsafe-attributes/in_2024_compatibility.rs index c6f9115cde75..f3b8645abaf8 100644 --- a/tests/ui/rust-2024/unsafe-attributes/in_2024_compatibility.rs +++ b/tests/ui/rust-2024/unsafe-attributes/in_2024_compatibility.rs @@ -1,5 +1,4 @@ #![deny(rust_2024_compatibility)] -#![feature(unsafe_attributes)] #[no_mangle] //~^ ERROR: unsafe attribute used without unsafe diff --git a/tests/ui/rust-2024/unsafe-attributes/in_2024_compatibility.stderr b/tests/ui/rust-2024/unsafe-attributes/in_2024_compatibility.stderr index f0689d9883c9..4629a154ac3c 100644 --- a/tests/ui/rust-2024/unsafe-attributes/in_2024_compatibility.stderr +++ b/tests/ui/rust-2024/unsafe-attributes/in_2024_compatibility.stderr @@ -1,5 +1,5 @@ error: unsafe attribute used without unsafe - --> $DIR/in_2024_compatibility.rs:4:3 + --> $DIR/in_2024_compatibility.rs:3:3 | LL | #[no_mangle] | ^^^^^^^^^ usage of unsafe attribute diff --git a/tests/ui/rust-2024/unsafe-attributes/unsafe-attribute-marked.rs b/tests/ui/rust-2024/unsafe-attributes/unsafe-attribute-marked.rs index 279ced2525a2..7c919fed976f 100644 --- a/tests/ui/rust-2024/unsafe-attributes/unsafe-attribute-marked.rs +++ b/tests/ui/rust-2024/unsafe-attributes/unsafe-attribute-marked.rs @@ -4,7 +4,6 @@ //@[edition2024] compile-flags: -Zunstable-options //@ check-pass -#![feature(unsafe_attributes)] #[unsafe(no_mangle)] extern "C" fn foo() {} diff --git a/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes-fix.fixed b/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes-fix.fixed index 6ebdff0334c8..586881d18076 100644 --- a/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes-fix.fixed +++ b/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes-fix.fixed @@ -1,5 +1,4 @@ //@ run-rustfix -#![feature(unsafe_attributes)] #![deny(unsafe_attr_outside_unsafe)] macro_rules! tt { diff --git a/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes-fix.rs b/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes-fix.rs index c78ff45ea4cd..03e122c7d57e 100644 --- a/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes-fix.rs +++ b/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes-fix.rs @@ -1,5 +1,4 @@ //@ run-rustfix -#![feature(unsafe_attributes)] #![deny(unsafe_attr_outside_unsafe)] macro_rules! tt { diff --git a/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes-fix.stderr b/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes-fix.stderr index c95984f58ecf..64debc58905c 100644 --- a/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes-fix.stderr +++ b/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes-fix.stderr @@ -1,5 +1,5 @@ error: unsafe attribute used without unsafe - --> $DIR/unsafe-attributes-fix.rs:44:6 + --> $DIR/unsafe-attributes-fix.rs:43:6 | LL | tt!([no_mangle]); | ^^^^^^^^^ usage of unsafe attribute @@ -7,7 +7,7 @@ LL | tt!([no_mangle]); = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2024! = note: for more information, see issue #123757 note: the lint level is defined here - --> $DIR/unsafe-attributes-fix.rs:3:9 + --> $DIR/unsafe-attributes-fix.rs:2:9 | LL | #![deny(unsafe_attr_outside_unsafe)] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -17,7 +17,7 @@ LL | tt!([unsafe(no_mangle)]); | +++++++ + error: unsafe attribute used without unsafe - --> $DIR/unsafe-attributes-fix.rs:14:11 + --> $DIR/unsafe-attributes-fix.rs:13:11 | LL | #[$e] | ^^ usage of unsafe attribute @@ -34,7 +34,7 @@ LL | #[unsafe($e)] | +++++++ + error: unsafe attribute used without unsafe - --> $DIR/unsafe-attributes-fix.rs:48:7 + --> $DIR/unsafe-attributes-fix.rs:47:7 | LL | meta!(no_mangle); | ^^^^^^^^^ usage of unsafe attribute @@ -47,7 +47,7 @@ LL | meta!(unsafe(no_mangle)); | +++++++ + error: unsafe attribute used without unsafe - --> $DIR/unsafe-attributes-fix.rs:51:8 + --> $DIR/unsafe-attributes-fix.rs:50:8 | LL | meta2!(export_name = "baw"); | ^^^^^^^^^^^ usage of unsafe attribute @@ -60,7 +60,7 @@ LL | meta2!(unsafe(export_name = "baw")); | +++++++ + error: unsafe attribute used without unsafe - --> $DIR/unsafe-attributes-fix.rs:23:11 + --> $DIR/unsafe-attributes-fix.rs:22:11 | LL | #[$e = $l] | ^^ usage of unsafe attribute @@ -77,7 +77,7 @@ LL | #[unsafe($e = $l)] | +++++++ + error: unsafe attribute used without unsafe - --> $DIR/unsafe-attributes-fix.rs:56:3 + --> $DIR/unsafe-attributes-fix.rs:55:3 | LL | #[no_mangle] | ^^^^^^^^^ usage of unsafe attribute diff --git a/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes.edition2024.stderr b/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes.edition2024.stderr index 35475d667162..fb697e14ef1c 100644 --- a/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes.edition2024.stderr +++ b/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes.edition2024.stderr @@ -1,5 +1,5 @@ error: unsafe attribute used without unsafe - --> $DIR/unsafe-attributes.rs:9:3 + --> $DIR/unsafe-attributes.rs:8:3 | LL | #[no_mangle] | ^^^^^^^^^ usage of unsafe attribute diff --git a/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes.rs b/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes.rs index 3a6af9dfb2b0..f6f2994bb6de 100644 --- a/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes.rs +++ b/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes.rs @@ -4,7 +4,6 @@ //@[edition2024] edition:2024 //@[edition2024] compile-flags: -Zunstable-options -#![feature(unsafe_attributes)] #[no_mangle] //[edition2024]~ ERROR: unsafe attribute used without unsafe extern "C" fn foo() {} From d5a7c459662a4868f4a38cbafb72dce7885e027d Mon Sep 17 00:00:00 2001 From: Evan Jones Date: Fri, 9 Aug 2024 14:26:18 -0400 Subject: [PATCH 12/79] doc: std::env::var: Returns None for names with '=' or NUL byte The documentation incorrectly stated that std::env::var could return an error for variable names containing '=' or the NUL byte. Copy the correct documentation from var_os. var_os was fixed in Commit 8a7a665, Pull Request #109894, which closed Issue #109893. This documentation was incorrectly added in commit f2c0f292, which replaced a panic in var_os by returning None, but documented the change as "May error if ...". Reference the specific error values and link to them. --- library/std/src/env.rs | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/library/std/src/env.rs b/library/std/src/env.rs index 50ae83090c7e..215b7b03f04c 100644 --- a/library/std/src/env.rs +++ b/library/std/src/env.rs @@ -198,13 +198,16 @@ impl fmt::Debug for VarsOs { /// /// # Errors /// -/// This function will return an error if the environment variable isn't set. +/// This function returns [`VarError::NotPresent`] if the environment variable +/// isn't set. /// -/// This function may return an error if the environment variable's name contains -/// the equal sign character (`=`) or the NUL character. +/// This function may return [`VarError::NotPresent`] if the +/// environment variable's name contains the equal sign character (`=`) or the +/// NUL character. /// -/// This function will return an error if the environment variable's value is -/// not valid Unicode. If this is not desired, consider using [`var_os`]. +/// This function will return [`VarError::NotUnicode`] if the environment +/// variable's value is not valid Unicode. If this is not desired, consider +/// using [`var_os`]. /// /// # Examples /// From b2e7ae1f65fd5e1579692a9a7a8c95fb95aa1b04 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Esteban=20K=C3=BCber?= Date: Wed, 7 Aug 2024 15:08:43 +0000 Subject: [PATCH 13/79] Detect multiple crate versions on method not found When a type comes indirectly from one crate version but the imported trait comes from a separate crate version, the called method won't be found. We now show additional context: ``` error[E0599]: no method named `foo` found for struct `dep_2_reexport::Type` in the current scope --> multiple-dep-versions.rs:8:10 | 8 | Type.foo(); | ^^^ method not found in `Type` | note: you have multiple different versions of crate `dependency` in your dependency graph --> multiple-dep-versions.rs:4:32 | 4 | use dependency::{do_something, Trait}; | ^^^^^ `dependency` imported here doesn't correspond to the right crate version | ::: ~/rust/build/x86_64-unknown-linux-gnu/test/run-make/crate-loading/rmake_out/multiple-dep-versions-1.rs:4:1 | 4 | pub trait Trait { | --------------- this is the trait that was imported | ::: ~/rust/build/x86_64-unknown-linux-gnu/test/run-make/crate-loading/rmake_out/multiple-dep-versions-2.rs:4:1 | 4 | pub trait Trait { | --------------- this is the trait that is needed 5 | fn foo(&self); | --- the method is available for `dep_2_reexport::Type` here ``` --- .../rustc_hir_typeck/src/method/suggest.rs | 69 +++++++++++++++++-- .../crate-loading/multiple-dep-versions-1.rs | 10 ++- .../crate-loading/multiple-dep-versions-2.rs | 10 ++- .../crate-loading/multiple-dep-versions-3.rs | 5 ++ .../crate-loading/multiple-dep-versions.rs | 5 +- tests/run-make/crate-loading/rmake.rs | 14 +++- 6 files changed, 99 insertions(+), 14 deletions(-) create mode 100644 tests/run-make/crate-loading/multiple-dep-versions-3.rs diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs index 61287d98676b..d4fcbcad7ae0 100644 --- a/compiler/rustc_hir_typeck/src/method/suggest.rs +++ b/compiler/rustc_hir_typeck/src/method/suggest.rs @@ -3448,6 +3448,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { trait_missing_method: bool, ) { let mut alt_rcvr_sugg = false; + let mut suggest = true; if let (SelfSource::MethodCall(rcvr), false) = (source, unsatisfied_bounds) { debug!( "suggest_traits_to_import: span={:?}, item_name={:?}, rcvr_ty={:?}, rcvr={:?}", @@ -3491,10 +3492,18 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { let did = Some(pick.item.container_id(self.tcx)); let skip = skippable.contains(&did); if pick.autoderefs == 0 && !skip { - err.span_label( - pick.item.ident(self.tcx).span, - format!("the method is available for `{rcvr_ty}` here"), + suggest = self.detect_and_explain_multiple_crate_versions( + err, + &pick.item, + rcvr.hir_id.owner, + *rcvr_ty, ); + if suggest { + err.span_label( + pick.item.ident(self.tcx).span, + format!("the method is available for `{rcvr_ty}` here"), + ); + } } break; } @@ -3675,7 +3684,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { } } } - if self.suggest_valid_traits(err, item_name, valid_out_of_scope_traits, true) { + if suggest && self.suggest_valid_traits(err, item_name, valid_out_of_scope_traits, true) { return; } @@ -4040,6 +4049,58 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { } } + fn detect_and_explain_multiple_crate_versions( + &self, + err: &mut Diag<'_>, + item: &ty::AssocItem, + owner: hir::OwnerId, + rcvr_ty: Ty<'_>, + ) -> bool { + let pick_name = self.tcx.crate_name(item.def_id.krate); + if let Some(map) = self.tcx.in_scope_traits_map(owner) { + for trait_candidate in map.to_sorted_stable_ord().into_iter().flat_map(|v| v.1.iter()) { + let name = self.tcx.crate_name(trait_candidate.def_id.krate); + if trait_candidate.def_id.krate != item.def_id.krate && name == pick_name { + let msg = format!( + "you have multiple different versions of crate `{name}` in your \ + dependency graph", + ); + let tdid = self.tcx.parent(item.def_id); + if self.tcx.item_name(trait_candidate.def_id) == self.tcx.item_name(tdid) + && let Some(def_id) = trait_candidate.import_ids.get(0) + { + let span = self.tcx.def_span(*def_id); + let mut multi_span: MultiSpan = span.into(); + multi_span.push_span_label( + span, + format!( + "`{name}` imported here doesn't correspond to the right crate \ + version", + ), + ); + multi_span.push_span_label( + self.tcx.def_span(trait_candidate.def_id), + format!("this is the trait that was imported"), + ); + multi_span.push_span_label( + self.tcx.def_span(tdid), + format!("this is the trait that is needed"), + ); + multi_span.push_span_label( + item.ident(self.tcx).span, + format!("the method is available for `{rcvr_ty}` here"), + ); + err.span_note(multi_span, msg); + return false; + } else { + err.note(msg); + } + } + } + } + true + } + /// issue #102320, for `unwrap_or` with closure as argument, suggest `unwrap_or_else` /// FIXME: currently not working for suggesting `map_or_else`, see #102408 pub(crate) fn suggest_else_fn_with_closure( diff --git a/tests/run-make/crate-loading/multiple-dep-versions-1.rs b/tests/run-make/crate-loading/multiple-dep-versions-1.rs index 2d3516338291..94f30ca326fd 100644 --- a/tests/run-make/crate-loading/multiple-dep-versions-1.rs +++ b/tests/run-make/crate-loading/multiple-dep-versions-1.rs @@ -1,6 +1,10 @@ #![crate_name = "dependency"] #![crate_type = "rlib"] -pub struct Type; -pub trait Trait {} -impl Trait for Type {} +pub struct Type(pub i32); +pub trait Trait { + fn foo(&self); +} +impl Trait for Type { + fn foo(&self) {} +} pub fn do_something(_: X) {} diff --git a/tests/run-make/crate-loading/multiple-dep-versions-2.rs b/tests/run-make/crate-loading/multiple-dep-versions-2.rs index a5df3dc61eda..0a4626be5605 100644 --- a/tests/run-make/crate-loading/multiple-dep-versions-2.rs +++ b/tests/run-make/crate-loading/multiple-dep-versions-2.rs @@ -1,6 +1,10 @@ #![crate_name = "dependency"] #![crate_type = "rlib"] -pub struct Type(pub i32); -pub trait Trait {} -impl Trait for Type {} +pub struct Type; +pub trait Trait { + fn foo(&self); +} +impl Trait for Type { + fn foo(&self) {} +} pub fn do_something(_: X) {} diff --git a/tests/run-make/crate-loading/multiple-dep-versions-3.rs b/tests/run-make/crate-loading/multiple-dep-versions-3.rs new file mode 100644 index 000000000000..07d888e9f103 --- /dev/null +++ b/tests/run-make/crate-loading/multiple-dep-versions-3.rs @@ -0,0 +1,5 @@ +#![crate_name = "foo"] +#![crate_type = "rlib"] + +extern crate dependency; +pub use dependency::Type; diff --git a/tests/run-make/crate-loading/multiple-dep-versions.rs b/tests/run-make/crate-loading/multiple-dep-versions.rs index 5a6cb03aaa4a..113a6b76d7d8 100644 --- a/tests/run-make/crate-loading/multiple-dep-versions.rs +++ b/tests/run-make/crate-loading/multiple-dep-versions.rs @@ -1,8 +1,9 @@ extern crate dep_2_reexport; extern crate dependency; -use dep_2_reexport::do_something; -use dependency::Type; +use dep_2_reexport::Type; +use dependency::{do_something, Trait}; fn main() { do_something(Type); + Type.foo(); } diff --git a/tests/run-make/crate-loading/rmake.rs b/tests/run-make/crate-loading/rmake.rs index d7abd5872c94..5da706624aef 100644 --- a/tests/run-make/crate-loading/rmake.rs +++ b/tests/run-make/crate-loading/rmake.rs @@ -7,11 +7,15 @@ use run_make_support::{rust_lib_name, rustc}; fn main() { rustc().input("multiple-dep-versions-1.rs").run(); rustc().input("multiple-dep-versions-2.rs").extra_filename("2").metadata("2").run(); + rustc() + .input("multiple-dep-versions-3.rs") + .extern_("dependency", rust_lib_name("dependency2")) + .run(); rustc() .input("multiple-dep-versions.rs") .extern_("dependency", rust_lib_name("dependency")) - .extern_("dep_2_reexport", rust_lib_name("dependency2")) + .extern_("dep_2_reexport", rust_lib_name("foo")) .run_fail() .assert_stderr_contains( "you have multiple different versions of crate `dependency` in your dependency graph", @@ -22,5 +26,11 @@ fn main() { ) .assert_stderr_contains("this type doesn't implement the required trait") .assert_stderr_contains("this type implements the required trait") - .assert_stderr_contains("this is the required trait"); + .assert_stderr_contains("this is the required trait") + .assert_stderr_contains( + "`dependency` imported here doesn't correspond to the right crate version", + ) + .assert_stderr_contains("this is the trait that was imported") + .assert_stderr_contains("this is the trait that is needed") + .assert_stderr_contains("the method is available for `dep_2_reexport::Type` here"); } From 5c427b4600708dce24066ade292f8d8b592b1cc5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Esteban=20K=C3=BCber?= Date: Wed, 7 Aug 2024 16:18:06 +0000 Subject: [PATCH 14/79] reword message --- compiler/rustc_hir_typeck/src/method/suggest.rs | 2 +- .../src/error_reporting/traits/fulfillment_errors.rs | 4 ++-- tests/run-make/crate-loading/rmake.rs | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs index d4fcbcad7ae0..6afbde867398 100644 --- a/compiler/rustc_hir_typeck/src/method/suggest.rs +++ b/compiler/rustc_hir_typeck/src/method/suggest.rs @@ -4062,7 +4062,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { let name = self.tcx.crate_name(trait_candidate.def_id.krate); if trait_candidate.def_id.krate != item.def_id.krate && name == pick_name { let msg = format!( - "you have multiple different versions of crate `{name}` in your \ + "there are multiple different versions of crate `{name}` in the \ dependency graph", ); let tdid = self.tcx.parent(item.def_id); diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs index 95d4509c100a..5b879cf67ce0 100644 --- a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs +++ b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs @@ -1697,11 +1697,11 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> { err.highlighted_span_help( span, vec![ - StringPart::normal("you have ".to_string()), + StringPart::normal("there are ".to_string()), StringPart::highlighted("multiple different versions".to_string()), StringPart::normal(" of crate `".to_string()), StringPart::highlighted(format!("{name}")), - StringPart::normal("` in your dependency graph".to_string()), + StringPart::normal("` the your dependency graph".to_string()), ], ); let candidates = if impl_candidates.is_empty() { diff --git a/tests/run-make/crate-loading/rmake.rs b/tests/run-make/crate-loading/rmake.rs index 5da706624aef..1b9c13c1f6a1 100644 --- a/tests/run-make/crate-loading/rmake.rs +++ b/tests/run-make/crate-loading/rmake.rs @@ -18,7 +18,7 @@ fn main() { .extern_("dep_2_reexport", rust_lib_name("foo")) .run_fail() .assert_stderr_contains( - "you have multiple different versions of crate `dependency` in your dependency graph", + "there are multiple different versions of crate `dependency` in the dependency graph", ) .assert_stderr_contains( "two types coming from two different versions of the same crate are different types \ From eeb72835d291a9e5fc08731ed0e26cc707ced720 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Esteban=20K=C3=BCber?= Date: Wed, 7 Aug 2024 21:09:17 +0000 Subject: [PATCH 15/79] Account for fully-qualified path case of conflicting crate versions When encountering the following, mention the precense of conflicting crates: ``` error[E0599]: no function or associated item named `get_decoded` found for struct `HpkeConfig` in the current scope --> src/main.rs:7:17 | 7 | HpkeConfig::get_decoded(&foo); | ^^^^^^^^^^^ function or associated item not found in `HpkeConfig` | note: if you're trying to build a new `HpkeConfig`, consider using `HpkeConfig::new` which returns `HpkeConfig` --> ~/.cargo/registry/src/index.crates.io-6f17d22bba15001f/janus_messages-0.3.1/src/lib.rs:908:5 | 908 | / pub fn new( 909 | | id: HpkeConfigId, 910 | | kem_id: HpkeKemId, 911 | | kdf_id: HpkeKdfId, 912 | | aead_id: HpkeAeadId, 913 | | public_key: HpkePublicKey, 914 | | ) -> HpkeConfig { | |___________________^ note: there are multiple different versions of crate `prio` in the dependency graph --> src/main.rs:1:5 | 1 | use prio::codec::Decode; | ^^^^^^^^^^^^^^^^^^^ `prio` imported here doesn't correspond to the right crate version | ::: ~/.cargo/registry/src/index.crates.io-6f17d22bba15001f/prio-0.9.1/src/codec.rs:35:1 | 35 | pub trait Decode: Sized { | ----------------------- this is the trait that was imported | ::: ~/.cargo/registry/src/index.crates.io-6f17d22bba15001f/prio-0.10.3/src/codec.rs:35:1 | 35 | pub trait Decode: Sized { | ----------------------- this is the trait that is needed ... 43 | fn get_decoded(bytes: &[u8]) -> Result { | -------------------------------------------------------- the method is available for `HpkeConfig` here help: there is an associated function `decode` with a similar name | 7 | HpkeConfig::decode(&foo); | ~~~~~~ ``` --- .../rustc_hir_typeck/src/method/suggest.rs | 52 ++++++++++++++----- 1 file changed, 40 insertions(+), 12 deletions(-) diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs index 6afbde867398..4ab7e2ee1777 100644 --- a/compiler/rustc_hir_typeck/src/method/suggest.rs +++ b/compiler/rustc_hir_typeck/src/method/suggest.rs @@ -3494,7 +3494,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { if pick.autoderefs == 0 && !skip { suggest = self.detect_and_explain_multiple_crate_versions( err, - &pick.item, + pick.item.def_id, + pick.item.ident(self.tcx).span, rcvr.hir_id.owner, *rcvr_ty, ); @@ -3684,6 +3685,30 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { } } } + + if let SelfSource::QPath(ty) = source + && !valid_out_of_scope_traits.is_empty() + && let hir::TyKind::Path(path) = ty.kind + && let hir::QPath::Resolved(_, path) = path + && let Some(def_id) = path.res.opt_def_id() + && let Some(assoc) = self + .tcx + .associated_items(valid_out_of_scope_traits[0]) + .filter_by_name_unhygienic(item_name.name) + .next() + { + // See if the `Type::function(val)` where `function` wasn't found corresponds to a + // `Trait` that is imported directly, but `Type` came from a different version of the + // same crate. + let rcvr_ty = self.tcx.type_of(def_id).instantiate_identity(); + suggest = self.detect_and_explain_multiple_crate_versions( + err, + assoc.def_id, + self.tcx.def_span(assoc.def_id), + ty.hir_id.owner, + rcvr_ty, + ); + } if suggest && self.suggest_valid_traits(err, item_name, valid_out_of_scope_traits, true) { return; } @@ -4052,21 +4077,24 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { fn detect_and_explain_multiple_crate_versions( &self, err: &mut Diag<'_>, - item: &ty::AssocItem, + item_def_id: DefId, + item_span: Span, owner: hir::OwnerId, rcvr_ty: Ty<'_>, ) -> bool { - let pick_name = self.tcx.crate_name(item.def_id.krate); + let pick_name = self.tcx.crate_name(item_def_id.krate); + let trait_did = self.tcx.parent(item_def_id); + let trait_name = self.tcx.item_name(trait_did); if let Some(map) = self.tcx.in_scope_traits_map(owner) { for trait_candidate in map.to_sorted_stable_ord().into_iter().flat_map(|v| v.1.iter()) { - let name = self.tcx.crate_name(trait_candidate.def_id.krate); - if trait_candidate.def_id.krate != item.def_id.krate && name == pick_name { + let crate_name = self.tcx.crate_name(trait_candidate.def_id.krate); + if trait_candidate.def_id.krate != item_def_id.krate && crate_name == pick_name { let msg = format!( - "there are multiple different versions of crate `{name}` in the \ + "there are multiple different versions of crate `{crate_name}` in the \ dependency graph", ); - let tdid = self.tcx.parent(item.def_id); - if self.tcx.item_name(trait_candidate.def_id) == self.tcx.item_name(tdid) + let candidate_name = self.tcx.item_name(trait_candidate.def_id); + if candidate_name == trait_name && let Some(def_id) = trait_candidate.import_ids.get(0) { let span = self.tcx.def_span(*def_id); @@ -4074,8 +4102,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { multi_span.push_span_label( span, format!( - "`{name}` imported here doesn't correspond to the right crate \ - version", + "`{crate_name}` imported here doesn't correspond to the right \ + crate version", ), ); multi_span.push_span_label( @@ -4083,11 +4111,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { format!("this is the trait that was imported"), ); multi_span.push_span_label( - self.tcx.def_span(tdid), + self.tcx.def_span(trait_did), format!("this is the trait that is needed"), ); multi_span.push_span_label( - item.ident(self.tcx).span, + item_span, format!("the method is available for `{rcvr_ty}` here"), ); err.span_note(multi_span, msg); From 4e985534e850822c6e1069b6bb2459b31ea5a886 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Esteban=20K=C3=BCber?= Date: Wed, 7 Aug 2024 21:24:49 +0000 Subject: [PATCH 16/79] Ignore auto-deref for multiple crate version note As per the case presented in #128569, we should be showing the extra info even if auto-deref is involved. --- .../rustc_hir_typeck/src/method/suggest.rs | 31 ++++++++++--------- 1 file changed, 17 insertions(+), 14 deletions(-) diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs index 4ab7e2ee1777..cf9f496ed56f 100644 --- a/compiler/rustc_hir_typeck/src/method/suggest.rs +++ b/compiler/rustc_hir_typeck/src/method/suggest.rs @@ -3448,7 +3448,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { trait_missing_method: bool, ) { let mut alt_rcvr_sugg = false; - let mut suggest = true; + let mut trait_in_other_version_found = false; if let (SelfSource::MethodCall(rcvr), false) = (source, unsatisfied_bounds) { debug!( "suggest_traits_to_import: span={:?}, item_name={:?}, rcvr_ty={:?}, rcvr={:?}", @@ -3490,21 +3490,22 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { // self types and rely on the suggestion to `use` the trait from // `suggest_valid_traits`. let did = Some(pick.item.container_id(self.tcx)); - let skip = skippable.contains(&did); - if pick.autoderefs == 0 && !skip { - suggest = self.detect_and_explain_multiple_crate_versions( + if skippable.contains(&did) { + continue; + } + trait_in_other_version_found = self + .detect_and_explain_multiple_crate_versions( err, pick.item.def_id, pick.item.ident(self.tcx).span, rcvr.hir_id.owner, *rcvr_ty, ); - if suggest { - err.span_label( - pick.item.ident(self.tcx).span, - format!("the method is available for `{rcvr_ty}` here"), - ); - } + if pick.autoderefs == 0 && !trait_in_other_version_found { + err.span_label( + pick.item.ident(self.tcx).span, + format!("the method is available for `{rcvr_ty}` here"), + ); } break; } @@ -3701,7 +3702,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { // `Trait` that is imported directly, but `Type` came from a different version of the // same crate. let rcvr_ty = self.tcx.type_of(def_id).instantiate_identity(); - suggest = self.detect_and_explain_multiple_crate_versions( + trait_in_other_version_found = self.detect_and_explain_multiple_crate_versions( err, assoc.def_id, self.tcx.def_span(assoc.def_id), @@ -3709,7 +3710,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { rcvr_ty, ); } - if suggest && self.suggest_valid_traits(err, item_name, valid_out_of_scope_traits, true) { + if !trait_in_other_version_found + && self.suggest_valid_traits(err, item_name, valid_out_of_scope_traits, true) + { return; } @@ -4119,14 +4122,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { format!("the method is available for `{rcvr_ty}` here"), ); err.span_note(multi_span, msg); - return false; } else { err.note(msg); } + return true; } } } - true + false } /// issue #102320, for `unwrap_or` with closure as argument, suggest `unwrap_or_else` From 61058937e5a9d58ce1f9c5e0ac6beef22c54cadf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Esteban=20K=C3=BCber?= Date: Sat, 10 Aug 2024 00:32:10 +0000 Subject: [PATCH 17/79] Rework suggestion method Make checking slightly cheaper (by restricting to the right item only). Add tests. --- .../rustc_hir_typeck/src/method/suggest.rs | 98 +++++++++---------- .../crate-loading/multiple-dep-versions-1.rs | 2 + .../crate-loading/multiple-dep-versions-2.rs | 2 + .../crate-loading/multiple-dep-versions.rs | 1 + tests/run-make/crate-loading/rmake.rs | 84 ++++++++++++++-- 5 files changed, 127 insertions(+), 60 deletions(-) diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs index cf9f496ed56f..31366a307605 100644 --- a/compiler/rustc_hir_typeck/src/method/suggest.rs +++ b/compiler/rustc_hir_typeck/src/method/suggest.rs @@ -3497,8 +3497,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { .detect_and_explain_multiple_crate_versions( err, pick.item.def_id, - pick.item.ident(self.tcx).span, - rcvr.hir_id.owner, + rcvr.hir_id, *rcvr_ty, ); if pick.autoderefs == 0 && !trait_in_other_version_found { @@ -3705,8 +3704,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { trait_in_other_version_found = self.detect_and_explain_multiple_crate_versions( err, assoc.def_id, - self.tcx.def_span(assoc.def_id), - ty.hir_id.owner, + ty.hir_id, rcvr_ty, ); } @@ -4081,55 +4079,55 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { &self, err: &mut Diag<'_>, item_def_id: DefId, - item_span: Span, - owner: hir::OwnerId, + hir_id: hir::HirId, rcvr_ty: Ty<'_>, ) -> bool { - let pick_name = self.tcx.crate_name(item_def_id.krate); - let trait_did = self.tcx.parent(item_def_id); - let trait_name = self.tcx.item_name(trait_did); - if let Some(map) = self.tcx.in_scope_traits_map(owner) { - for trait_candidate in map.to_sorted_stable_ord().into_iter().flat_map(|v| v.1.iter()) { - let crate_name = self.tcx.crate_name(trait_candidate.def_id.krate); - if trait_candidate.def_id.krate != item_def_id.krate && crate_name == pick_name { - let msg = format!( - "there are multiple different versions of crate `{crate_name}` in the \ - dependency graph", - ); - let candidate_name = self.tcx.item_name(trait_candidate.def_id); - if candidate_name == trait_name - && let Some(def_id) = trait_candidate.import_ids.get(0) - { - let span = self.tcx.def_span(*def_id); - let mut multi_span: MultiSpan = span.into(); - multi_span.push_span_label( - span, - format!( - "`{crate_name}` imported here doesn't correspond to the right \ - crate version", - ), - ); - multi_span.push_span_label( - self.tcx.def_span(trait_candidate.def_id), - format!("this is the trait that was imported"), - ); - multi_span.push_span_label( - self.tcx.def_span(trait_did), - format!("this is the trait that is needed"), - ); - multi_span.push_span_label( - item_span, - format!("the method is available for `{rcvr_ty}` here"), - ); - err.span_note(multi_span, msg); - } else { - err.note(msg); - } - return true; - } - } + let hir_id = self.tcx.parent_hir_id(hir_id); + let Some(traits) = self.tcx.in_scope_traits(hir_id) else { return false }; + if traits.is_empty() { + return false; } - false + let trait_def_id = self.tcx.parent(item_def_id); + let krate = self.tcx.crate_name(trait_def_id.krate); + let name = self.tcx.item_name(trait_def_id); + let candidates: Vec<_> = traits + .iter() + .filter(|c| { + c.def_id.krate != trait_def_id.krate + && self.tcx.crate_name(c.def_id.krate) == krate + && self.tcx.item_name(c.def_id) == name + }) + .map(|c| (c.def_id, c.import_ids.get(0).cloned())) + .collect(); + if candidates.is_empty() { + return false; + } + let item_span = self.tcx.def_span(item_def_id); + let msg = format!( + "there are multiple different versions of crate `{krate}` in the dependency graph", + ); + let trait_span = self.tcx.def_span(trait_def_id); + let mut multi_span: MultiSpan = trait_span.into(); + multi_span.push_span_label(trait_span, format!("this is the trait that is needed")); + multi_span + .push_span_label(item_span, format!("the method is available for `{rcvr_ty}` here")); + for (def_id, import_def_id) in candidates { + if let Some(import_def_id) = import_def_id { + multi_span.push_span_label( + self.tcx.def_span(import_def_id), + format!( + "`{name}` imported here doesn't correspond to the right version of crate \ + `{krate}`", + ), + ); + } + multi_span.push_span_label( + self.tcx.def_span(def_id), + format!("this is the trait that was imported"), + ); + } + err.span_note(multi_span, msg); + true } /// issue #102320, for `unwrap_or` with closure as argument, suggest `unwrap_or_else` diff --git a/tests/run-make/crate-loading/multiple-dep-versions-1.rs b/tests/run-make/crate-loading/multiple-dep-versions-1.rs index 94f30ca326fd..d81462504dd5 100644 --- a/tests/run-make/crate-loading/multiple-dep-versions-1.rs +++ b/tests/run-make/crate-loading/multiple-dep-versions-1.rs @@ -3,8 +3,10 @@ pub struct Type(pub i32); pub trait Trait { fn foo(&self); + fn bar(); } impl Trait for Type { fn foo(&self) {} + fn bar() {} } pub fn do_something(_: X) {} diff --git a/tests/run-make/crate-loading/multiple-dep-versions-2.rs b/tests/run-make/crate-loading/multiple-dep-versions-2.rs index 0a4626be5605..0a566fe2c605 100644 --- a/tests/run-make/crate-loading/multiple-dep-versions-2.rs +++ b/tests/run-make/crate-loading/multiple-dep-versions-2.rs @@ -3,8 +3,10 @@ pub struct Type; pub trait Trait { fn foo(&self); + fn bar(); } impl Trait for Type { fn foo(&self) {} + fn bar() {} } pub fn do_something(_: X) {} diff --git a/tests/run-make/crate-loading/multiple-dep-versions.rs b/tests/run-make/crate-loading/multiple-dep-versions.rs index 113a6b76d7d8..8ef042bf4184 100644 --- a/tests/run-make/crate-loading/multiple-dep-versions.rs +++ b/tests/run-make/crate-loading/multiple-dep-versions.rs @@ -6,4 +6,5 @@ use dependency::{do_something, Trait}; fn main() { do_something(Type); Type.foo(); + Type::bar(); } diff --git a/tests/run-make/crate-loading/rmake.rs b/tests/run-make/crate-loading/rmake.rs index 1b9c13c1f6a1..65cbc8b0b1b9 100644 --- a/tests/run-make/crate-loading/rmake.rs +++ b/tests/run-make/crate-loading/rmake.rs @@ -1,6 +1,7 @@ //@ only-linux //@ ignore-wasm32 //@ ignore-wasm64 +// ignore-tidy-linelength use run_make_support::{rust_lib_name, rustc}; @@ -18,19 +19,82 @@ fn main() { .extern_("dep_2_reexport", rust_lib_name("foo")) .run_fail() .assert_stderr_contains( - "there are multiple different versions of crate `dependency` in the dependency graph", + r#"error[E0277]: the trait bound `dep_2_reexport::Type: Trait` is not satisfied + --> multiple-dep-versions.rs:7:18 + | +7 | do_something(Type); + | ------------ ^^^^ the trait `Trait` is not implemented for `dep_2_reexport::Type` + | | + | required by a bound introduced by this call + | +help: there are multiple different versions of crate `dependency` the your dependency graph + --> multiple-dep-versions.rs:1:1 + | +1 | extern crate dep_2_reexport; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one version of crate `dependency` is used here, as a dependency of crate `foo` +2 | extern crate dependency; + | ^^^^^^^^^^^^^^^^^^^^^^^^ one version of crate `dependency` is used here, as a direct dependency of the current crate"#, ) .assert_stderr_contains( - "two types coming from two different versions of the same crate are different types \ - even if they look the same", + r#" +3 | pub struct Type(pub i32); + | ^^^^^^^^^^^^^^^ this type implements the required trait +4 | pub trait Trait { + | --------------- this is the required trait"#, ) - .assert_stderr_contains("this type doesn't implement the required trait") - .assert_stderr_contains("this type implements the required trait") - .assert_stderr_contains("this is the required trait") .assert_stderr_contains( - "`dependency` imported here doesn't correspond to the right crate version", + r#" +3 | pub struct Type; + | ^^^^^^^^^^^^^^^ this type doesn't implement the required trait"#, ) - .assert_stderr_contains("this is the trait that was imported") - .assert_stderr_contains("this is the trait that is needed") - .assert_stderr_contains("the method is available for `dep_2_reexport::Type` here"); + .assert_stderr_contains( + r#" +error[E0599]: no method named `foo` found for struct `dep_2_reexport::Type` in the current scope + --> multiple-dep-versions.rs:8:10 + | +8 | Type.foo(); + | ^^^ method not found in `Type` + | +note: there are multiple different versions of crate `dependency` in the dependency graph"#, + ) + .assert_stderr_contains( + r#" +4 | pub trait Trait { + | ^^^^^^^^^^^^^^^ this is the trait that is needed +5 | fn foo(&self); + | -------------- the method is available for `dep_2_reexport::Type` here + | + ::: multiple-dep-versions.rs:4:32 + | +4 | use dependency::{do_something, Trait}; + | ----- `Trait` imported here doesn't correspond to the right version of crate `dependency`"#, + ) + .assert_stderr_contains( + r#" +4 | pub trait Trait { + | --------------- this is the trait that was imported"#, + ) + .assert_stderr_contains( + r#" +error[E0599]: no function or associated item named `bar` found for struct `dep_2_reexport::Type` in the current scope + --> multiple-dep-versions.rs:9:11 + | +9 | Type::bar(); + | ^^^ function or associated item not found in `Type` + | +note: there are multiple different versions of crate `dependency` in the dependency graph"#, + ) + .assert_stderr_contains( + r#" +4 | pub trait Trait { + | ^^^^^^^^^^^^^^^ this is the trait that is needed +5 | fn foo(&self); +6 | fn bar(); + | --------- the method is available for `dep_2_reexport::Type` here + | + ::: multiple-dep-versions.rs:4:32 + | +4 | use dependency::{do_something, Trait}; + | ----- `Trait` imported here doesn't correspond to the right version of crate `dependency`"#, + ); } From 110b19b2b6a9896d4d73b8bd8b735fa9c2503d1e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Esteban=20K=C3=BCber?= Date: Mon, 12 Aug 2024 19:45:20 +0000 Subject: [PATCH 18/79] Properly differentiate between methods and assoc fns --- compiler/rustc_hir_typeck/src/method/suggest.rs | 3 ++- tests/run-make/crate-loading/rmake.rs | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs index 31366a307605..ab13b31439c0 100644 --- a/compiler/rustc_hir_typeck/src/method/suggest.rs +++ b/compiler/rustc_hir_typeck/src/method/suggest.rs @@ -4109,8 +4109,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { let trait_span = self.tcx.def_span(trait_def_id); let mut multi_span: MultiSpan = trait_span.into(); multi_span.push_span_label(trait_span, format!("this is the trait that is needed")); + let descr = self.tcx.associated_item(item_def_id).descr(); multi_span - .push_span_label(item_span, format!("the method is available for `{rcvr_ty}` here")); + .push_span_label(item_span, format!("the {descr} is available for `{rcvr_ty}` here")); for (def_id, import_def_id) in candidates { if let Some(import_def_id) = import_def_id { multi_span.push_span_label( diff --git a/tests/run-make/crate-loading/rmake.rs b/tests/run-make/crate-loading/rmake.rs index 65cbc8b0b1b9..13585edf6ccb 100644 --- a/tests/run-make/crate-loading/rmake.rs +++ b/tests/run-make/crate-loading/rmake.rs @@ -90,7 +90,7 @@ note: there are multiple different versions of crate `dependency` in the depende | ^^^^^^^^^^^^^^^ this is the trait that is needed 5 | fn foo(&self); 6 | fn bar(); - | --------- the method is available for `dep_2_reexport::Type` here + | --------- the associated function is available for `dep_2_reexport::Type` here | ::: multiple-dep-versions.rs:4:32 | From cebae30f7229007ecad8dfa47222d889541d7902 Mon Sep 17 00:00:00 2001 From: WANG Rui Date: Tue, 13 Aug 2024 11:41:37 +0800 Subject: [PATCH 19/79] Update `crosstool-ng` for loongarch64 The current cross-compilation toolchain for the LoongArch64 target consists of GCC 13.2.0, Binutils 2.40, and Glibc 2.36. However, Binutils 2.40 has known issues that in broken binaries without any error reports: - https://github.com/rust-lang/rust/issues/121289 - https://github.com/cross-rs/cross/issues/1538 This patch upgrades the cross-compilation toolchain for the LoongArch64 target to resolve these issues. - GCC: 13.2.0 -> 14.2.0 - Binutils: 2.40 -> 2.42 The new binaries remain compatible with the existing GCC 13.2.0/Glibc 2.36 distribution, and no issues have been identified. --- src/ci/docker/README.md | 8 ++++---- .../docker/host-x86_64/dist-loongarch64-linux/Dockerfile | 4 ++-- src/ci/docker/scripts/crosstool-ng-git.sh | 2 +- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/src/ci/docker/README.md b/src/ci/docker/README.md index 985e3b37422d..876787c30e53 100644 --- a/src/ci/docker/README.md +++ b/src/ci/docker/README.md @@ -266,9 +266,9 @@ For targets: `loongarch64-unknown-linux-gnu` - Target options > Bitness = 64-bit - Operating System > Target OS = linux - Operating System > Linux kernel version = 5.19.16 -- Binary utilities > Version of binutils = 2.40 +- Binary utilities > Version of binutils = 2.42 - C-library > glibc version = 2.36 -- C compiler > gcc version = 13.2.0 +- C compiler > gcc version = 14.2.0 - C compiler > C++ = ENABLE -- to cross compile LLVM ### `loongarch64-linux-musl.defconfig` @@ -282,9 +282,9 @@ For targets: `loongarch64-unknown-linux-musl` - Target options > Bitness = 64-bit - Operating System > Target OS = linux - Operating System > Linux kernel version = 5.19.16 -- Binary utilities > Version of binutils = 2.41 +- Binary utilities > Version of binutils = 2.42 - C-library > musl version = 1.2.5 -- C compiler > gcc version = 13.2.0 +- C compiler > gcc version = 14.2.0 - C compiler > C++ = ENABLE -- to cross compile LLVM ### `mips-linux-gnu.defconfig` diff --git a/src/ci/docker/host-x86_64/dist-loongarch64-linux/Dockerfile b/src/ci/docker/host-x86_64/dist-loongarch64-linux/Dockerfile index d39566516636..865a9e32fa92 100644 --- a/src/ci/docker/host-x86_64/dist-loongarch64-linux/Dockerfile +++ b/src/ci/docker/host-x86_64/dist-loongarch64-linux/Dockerfile @@ -3,8 +3,8 @@ FROM ubuntu:22.04 COPY scripts/cross-apt-packages.sh /scripts/ RUN sh /scripts/cross-apt-packages.sh -COPY scripts/crosstool-ng.sh /scripts/ -RUN sh /scripts/crosstool-ng.sh +COPY scripts/crosstool-ng-git.sh /scripts/ +RUN sh /scripts/crosstool-ng-git.sh COPY scripts/rustbuild-setup.sh /scripts/ RUN sh /scripts/rustbuild-setup.sh diff --git a/src/ci/docker/scripts/crosstool-ng-git.sh b/src/ci/docker/scripts/crosstool-ng-git.sh index 2a10e262df8c..e86810ae6133 100644 --- a/src/ci/docker/scripts/crosstool-ng-git.sh +++ b/src/ci/docker/scripts/crosstool-ng-git.sh @@ -2,7 +2,7 @@ set -ex URL=https://github.com/crosstool-ng/crosstool-ng -REV=c64500d94be92ed1bcdfdef911048a14e216a5e1 +REV=ed12fa68402f58e171a6f79500f73f4781fdc9e5 mkdir crosstool-ng cd crosstool-ng From 3ed63dd8435bf14c958f2d500010eb14bd7c11d8 Mon Sep 17 00:00:00 2001 From: Mads Marquart Date: Wed, 14 Aug 2024 02:12:14 +0200 Subject: [PATCH 20/79] Promote Mac Catalyst targets to tier 2, and ship with rustup - aarch64-apple-ios-macabi - x86_64-apple-ios-macabi --- .../spec/targets/aarch64_apple_ios_macabi.rs | 2 +- .../spec/targets/x86_64_apple_ios_macabi.rs | 2 +- src/ci/github-actions/jobs.yml | 6 ++++-- src/doc/rustc/src/platform-support.md | 4 ++-- .../src/platform-support/apple-ios-macabi.md | 20 +++++++++++-------- src/tools/build-manifest/src/main.rs | 2 ++ 6 files changed, 22 insertions(+), 14 deletions(-) diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_macabi.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_macabi.rs index 85c40ec60c41..32c2367d5bfd 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_macabi.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_macabi.rs @@ -10,7 +10,7 @@ pub fn target() -> Target { llvm_target: mac_catalyst_llvm_target(arch).into(), metadata: crate::spec::TargetMetadata { description: Some("Apple Catalyst on ARM64".into()), - tier: Some(3), + tier: Some(2), host_tools: Some(false), std: Some(true), }, diff --git a/compiler/rustc_target/src/spec/targets/x86_64_apple_ios_macabi.rs b/compiler/rustc_target/src/spec/targets/x86_64_apple_ios_macabi.rs index d3ba17cf0271..c23a20ff0848 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_apple_ios_macabi.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_apple_ios_macabi.rs @@ -10,7 +10,7 @@ pub fn target() -> Target { llvm_target: mac_catalyst_llvm_target(arch).into(), metadata: crate::spec::TargetMetadata { description: Some("Apple Catalyst on x86_64".into()), - tier: Some(3), + tier: Some(2), host_tools: Some(false), std: Some(true), }, diff --git a/src/ci/github-actions/jobs.yml b/src/ci/github-actions/jobs.yml index 638f14ad53fe..4de44c6dd39d 100644 --- a/src/ci/github-actions/jobs.yml +++ b/src/ci/github-actions/jobs.yml @@ -285,8 +285,10 @@ auto: - image: dist-apple-various env: - SCRIPT: ./x.py dist bootstrap --include-default-paths --host='' --target=aarch64-apple-ios,x86_64-apple-ios,aarch64-apple-ios-sim - RUST_CONFIGURE_ARGS: --enable-sanitizers --enable-profiler --set rust.jemalloc + SCRIPT: ./x.py dist bootstrap --include-default-paths --host='' --target=aarch64-apple-ios,x86_64-apple-ios,aarch64-apple-ios-sim,aarch64-apple-ios-macabi,x86_64-apple-ios-macabi + # Mac Catalyst cannot currently compile the sanitizer: + # https://github.com/rust-lang/rust/issues/129069 + RUST_CONFIGURE_ARGS: --enable-sanitizers --enable-profiler --set rust.jemalloc --set target.aarch64-apple-ios-macabi.sanitizers=false --set target.x86_64-apple-ios-macabi.sanitizers=false RUSTC_RETRY_LINKER_ON_SEGFAULT: 1 MACOSX_DEPLOYMENT_TARGET: 10.12 SELECT_XCODE: /Applications/Xcode_14.3.1.app diff --git a/src/doc/rustc/src/platform-support.md b/src/doc/rustc/src/platform-support.md index bd12172ecbb4..91d92e23055a 100644 --- a/src/doc/rustc/src/platform-support.md +++ b/src/doc/rustc/src/platform-support.md @@ -136,6 +136,7 @@ so Rustup may install the documentation for a similar tier 1 target instead. target | std | notes -------|:---:|------- [`aarch64-apple-ios`](platform-support/apple-ios.md) | ✓ | ARM64 iOS +[`aarch64-apple-ios-macabi`](platform-support/apple-ios-macabi.md) | ✓ | Mac Catalyst on ARM64 [`aarch64-apple-ios-sim`](platform-support/apple-ios.md) | ✓ | Apple iOS Simulator on ARM64 `aarch64-fuchsia` | ✓ | Alias for `aarch64-unknown-fuchsia` [`aarch64-unknown-fuchsia`](platform-support/fuchsia.md) | ✓ | ARM64 Fuchsia @@ -196,6 +197,7 @@ target | std | notes [`wasm32-wasip1`](platform-support/wasm32-wasip1.md) | ✓ | WebAssembly with WASI [`wasm32-wasip1-threads`](platform-support/wasm32-wasip1-threads.md) | ✓ | WebAssembly with WASI Preview 1 and threads [`x86_64-apple-ios`](platform-support/apple-ios.md) | ✓ | 64-bit x86 iOS +[`x86_64-apple-ios-macabi`](platform-support/apple-ios-macabi.md) | ✓ | Mac Catalyst on x86_64 [`x86_64-fortanix-unknown-sgx`](platform-support/x86_64-fortanix-unknown-sgx.md) | ✓ | [Fortanix ABI] for 64-bit Intel SGX `x86_64-fuchsia` | ✓ | Alias for `x86_64-unknown-fuchsia` [`x86_64-unknown-fuchsia`](platform-support/fuchsia.md) | ✓ | 64-bit x86 Fuchsia @@ -245,7 +247,6 @@ target | std | host | notes -------|:---:|:----:|------- [`arm64e-apple-ios`](platform-support/arm64e-apple-ios.md) | ✓ | | ARM64e Apple iOS [`arm64e-apple-darwin`](platform-support/arm64e-apple-darwin.md) | ✓ | ✓ | ARM64e Apple Darwin -[`aarch64-apple-ios-macabi`](platform-support/apple-ios-macabi.md) | ✓ | | Apple Catalyst on ARM64 [`aarch64-apple-tvos`](platform-support/apple-tvos.md) | ✓ | | ARM64 tvOS [`aarch64-apple-tvos-sim`](platform-support/apple-tvos.md) | ✓ | | ARM64 tvOS Simulator [`aarch64-apple-watchos`](platform-support/apple-watchos.md) | ✓ | | ARM64 Apple WatchOS @@ -370,7 +371,6 @@ target | std | host | notes `thumbv7neon-unknown-linux-musleabihf` | ? | | Thumb2-mode Armv7-A Linux with NEON, musl 1.2.3 [`wasm32-wasip2`](platform-support/wasm32-wasip2.md) | ✓ | | WebAssembly [`wasm64-unknown-unknown`](platform-support/wasm64-unknown-unknown.md) | ? | | WebAssembly -[`x86_64-apple-ios-macabi`](platform-support/apple-ios-macabi.md) | ✓ | | Apple Catalyst on x86_64 [`x86_64-apple-tvos`](platform-support/apple-tvos.md) | ✓ | | x86 64-bit tvOS [`x86_64-apple-watchos-sim`](platform-support/apple-watchos.md) | ✓ | | x86 64-bit Apple WatchOS simulator [`x86_64-pc-nto-qnx710`](platform-support/nto-qnx.md) | ✓ | | x86 64-bit QNX Neutrino 7.1 RTOS | diff --git a/src/doc/rustc/src/platform-support/apple-ios-macabi.md b/src/doc/rustc/src/platform-support/apple-ios-macabi.md index 15ba31e0f064..678630873b13 100644 --- a/src/doc/rustc/src/platform-support/apple-ios-macabi.md +++ b/src/doc/rustc/src/platform-support/apple-ios-macabi.md @@ -2,7 +2,7 @@ Apple Mac Catalyst targets. -**Tier: 3** +**Tier: 2 (without Host Tools)** - `aarch64-apple-ios-macabi`: Mac Catalyst on ARM64. - `x86_64-apple-ios-macabi`: Mac Catalyst on 64-bit x86. @@ -32,15 +32,19 @@ case `IPHONEOS_DEPLOYMENT_TARGET`. ## Building the target -The targets can be built by enabling them for a `rustc` build in -`config.toml`, by adding, for example: - -```toml -[build] -target = ["aarch64-apple-ios-macabi", "x86_64-apple-ios-macabi"] +The targets are distributed through `rustup`, and can be installed using one +of: +```console +$ rustup target add aarch64-apple-ios-macabi +$ rustup target add x86_64-apple-ios-macabi ``` -Using the unstable `-Zbuild-std` with a nightly Cargo may also work. +### Sanitizers + +Due to CMake having poor support for Mac Catalyst, sanitizer runtimes are not +currently available, see [#129069]. + +[#129069]: https://github.com/rust-lang/rust/issues/129069 ## Building Rust programs diff --git a/src/tools/build-manifest/src/main.rs b/src/tools/build-manifest/src/main.rs index 2b263f848e89..92b21f7dbaa6 100644 --- a/src/tools/build-manifest/src/main.rs +++ b/src/tools/build-manifest/src/main.rs @@ -54,6 +54,7 @@ static TARGETS: &[&str] = &[ "arm64e-apple-darwin", "aarch64-apple-ios", "arm64e-apple-ios", + "aarch64-apple-ios-macabi", "aarch64-apple-ios-sim", "aarch64-unknown-fuchsia", "aarch64-linux-android", @@ -161,6 +162,7 @@ static TARGETS: &[&str] = &[ "wasm32-wasip2", "x86_64-apple-darwin", "x86_64-apple-ios", + "x86_64-apple-ios-macabi", "x86_64-fortanix-unknown-sgx", "x86_64-unknown-fuchsia", "x86_64-linux-android", From 35785ef39fa01250f6c4db6bb08e239f55c308ee Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E6=9D=B0=E5=8F=8B=20Jieyou=20Xu=20=28Joe=29?= Date: Thu, 15 Aug 2024 05:13:05 +0000 Subject: [PATCH 21/79] tests: re-enable `dump-ice-to-disk` for Windows This test was previously flakey on `i686-mingw`, but since some modifications I could no longer make it fail on `i686-mingw`. See for multiple try job runs. --- tests/run-make/dump-ice-to-disk/rmake.rs | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/tests/run-make/dump-ice-to-disk/rmake.rs b/tests/run-make/dump-ice-to-disk/rmake.rs index 48b4071e0654..08767246b90d 100644 --- a/tests/run-make/dump-ice-to-disk/rmake.rs +++ b/tests/run-make/dump-ice-to-disk/rmake.rs @@ -14,11 +14,14 @@ //! that `RUSTC_ICE_PATH` takes precedence and no ICE dump is emitted under `METRICS_PATH`. //! //! See . - -//@ ignore-windows -// FIXME(#128911): @jieyouxu: This test is sometimes for whatever forsaken reason flakey in -// `i686-mingw`, and I cannot reproduce it locally. The error messages upon assertion failure in -// this test is intentionally extremely verbose to aid debugging that issue. +//! +//! # Test history +//! +//! - The previous rmake.rs iteration of this test was flakey for unknown reason on `i686-mingw` +//! *specifically*, so assertion failures in this test was made extremely verbose to help +//! diagnose why the ICE messages was different *specifically* on `i686-mingw`. +//! - An attempt is made to re-enable this test on `i686-mingw` (by removing `ignore-windows`). If +//! this test is still flakey, please restore the `ignore-windows` directive. use std::cell::OnceCell; use std::path::{Path, PathBuf}; From 320be47410e2a826c47097790b790b3a1826d073 Mon Sep 17 00:00:00 2001 From: Zalathar Date: Thu, 15 Aug 2024 14:55:40 +1000 Subject: [PATCH 22/79] Include a copy of `compiler-rt` source in the `download-ci-llvm` tarball --- src/bootstrap/download-ci-llvm-stamp | 2 +- src/bootstrap/src/core/build_steps/dist.rs | 13 +++++++++++++ 2 files changed, 14 insertions(+), 1 deletion(-) diff --git a/src/bootstrap/download-ci-llvm-stamp b/src/bootstrap/download-ci-llvm-stamp index 11316004412e..909015305015 100644 --- a/src/bootstrap/download-ci-llvm-stamp +++ b/src/bootstrap/download-ci-llvm-stamp @@ -1,4 +1,4 @@ Change this file to make users of the `download-ci-llvm` configuration download a new version of LLVM from CI, even if the LLVM submodule hasn’t changed. -Last change is for: https://github.com/rust-lang/rust/pull/125642 +Last change is for: https://github.com/rust-lang/rust/pull/129116 diff --git a/src/bootstrap/src/core/build_steps/dist.rs b/src/bootstrap/src/core/build_steps/dist.rs index 530eb9b446a4..24894251017a 100644 --- a/src/bootstrap/src/core/build_steps/dist.rs +++ b/src/bootstrap/src/core/build_steps/dist.rs @@ -2322,6 +2322,19 @@ impl Step for RustDev { let link_type = if builder.llvm_link_shared() { "dynamic" } else { "static" }; t!(std::fs::write(tarball.image_dir().join("link-type.txt"), link_type), dst_libdir); + // Copy the `compiler-rt` source, so that `library/profiler_builtins` + // can potentially use it to build the profiler runtime without needing + // to check out the LLVM submodule. + copy_src_dirs( + builder, + &builder.src.join("src").join("llvm-project"), + &["compiler-rt"], + // The test subdirectory is much larger than the rest of the source, + // and we currently don't use these test files anyway. + &["compiler-rt/test"], + tarball.image_dir(), + ); + Some(tarball.generate()) } } From 368a4c6808c49baf5e03f9debeff3d53a013e968 Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Sat, 3 Aug 2024 11:51:16 +0200 Subject: [PATCH 23/79] float to/from bits and classify: update comments regarding non-conformant hardware --- library/core/src/num/f128.rs | 110 +----------- library/core/src/num/f16.rs | 163 +++-------------- library/core/src/num/f32.rs | 169 +++--------------- library/core/src/num/f64.rs | 143 +++------------ tests/ui/consts/const-float-bits-conv.rs | 22 +++ .../ui/consts/const-float-bits-reject-conv.rs | 68 ------- .../const-float-bits-reject-conv.stderr | 115 ------------ 7 files changed, 107 insertions(+), 683 deletions(-) delete mode 100644 tests/ui/consts/const-float-bits-reject-conv.rs delete mode 100644 tests/ui/consts/const-float-bits-reject-conv.stderr diff --git a/library/core/src/num/f128.rs b/library/core/src/num/f128.rs index 0c04f47fe7df..38e69e7641ab 100644 --- a/library/core/src/num/f128.rs +++ b/library/core/src/num/f128.rs @@ -290,7 +290,7 @@ impl f128 { #[inline] #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")] pub(crate) const fn abs_private(self) -> f128 { - // SAFETY: This transmutation is fine. Probably. For the reasons std is using it. + // SAFETY: This transmutation is fine just like in `to_bits`/`from_bits`. unsafe { mem::transmute::(mem::transmute::(self) & !Self::SIGN_MASK) } @@ -439,22 +439,12 @@ impl f128 { #[unstable(feature = "f128", issue = "116909")] #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")] pub const fn classify(self) -> FpCategory { - // Other float types cannot use a bitwise classify because they may suffer a variety - // of errors if the backend chooses to cast to different float types (x87). `f128` cannot - // fit into any other float types so this is not a concern, and we rely on bit patterns. + // Other float types suffer from various platform bugs that violate the usual IEEE semantics + // and also make bitwise classification not always work reliably. However, `f128` cannot fit + // into any other float types so this is not a concern, and we can rely on bit patterns. - // SAFETY: POD bitcast, same as in `to_bits`. - let bits = unsafe { mem::transmute::(self) }; - Self::classify_bits(bits) - } - - /// This operates on bits, and only bits, so it can ignore concerns about weird FPUs. - /// FIXME(jubilee): In a just world, this would be the entire impl for classify, - /// plus a transmute. We do not live in a just world, but we can make it more so. - #[inline] - #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")] - const fn classify_bits(b: u128) -> FpCategory { - match (b & Self::MAN_MASK, b & Self::EXP_MASK) { + let bits = self.to_bits(); + match (bits & Self::MAN_MASK, bits & Self::EXP_MASK) { (0, Self::EXP_MASK) => FpCategory::Infinite, (_, Self::EXP_MASK) => FpCategory::Nan, (0, 0) => FpCategory::Zero, @@ -922,48 +912,7 @@ impl f128 { #[must_use = "this returns the result of the operation, without modifying the original"] pub const fn to_bits(self) -> u128 { // SAFETY: `u128` is a plain old datatype so we can always transmute to it. - // ...sorta. - // - // It turns out that at runtime, it is possible for a floating point number - // to be subject to a floating point mode that alters nonzero subnormal numbers - // to zero on reads and writes, aka "denormals are zero" and "flush to zero". - // - // And, of course evaluating to a NaN value is fairly nondeterministic. - // More precisely: when NaN should be returned is knowable, but which NaN? - // So far that's defined by a combination of LLVM and the CPU, not Rust. - // This function, however, allows observing the bitstring of a NaN, - // thus introspection on CTFE. - // - // In order to preserve, at least for the moment, const-to-runtime equivalence, - // we reject any of these possible situations from happening. - #[inline] - #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] - const fn ct_f128_to_u128(ct: f128) -> u128 { - // FIXME(f16_f128): we should use `.classify()` like `f32` and `f64`, but that - // is not available on all platforms (needs `netf2` and `unordtf2`). So classify - // the bits instead. - - // SAFETY: this is a POD transmutation - let bits = unsafe { mem::transmute::(ct) }; - match f128::classify_bits(bits) { - FpCategory::Nan => { - panic!("const-eval error: cannot use f128::to_bits on a NaN") - } - FpCategory::Subnormal => { - panic!("const-eval error: cannot use f128::to_bits on a subnormal number") - } - FpCategory::Infinite | FpCategory::Normal | FpCategory::Zero => bits, - } - } - - #[inline(always)] // See https://github.com/rust-lang/compiler-builtins/issues/491 - fn rt_f128_to_u128(x: f128) -> u128 { - // SAFETY: `u128` is a plain old datatype so we can always... uh... - // ...look, just pretend you forgot what you just read. - // Stability concerns. - unsafe { mem::transmute(x) } - } - intrinsics::const_eval_select((self,), ct_f128_to_u128, rt_f128_to_u128) + unsafe { mem::transmute(self) } } /// Raw transmutation from `u128`. @@ -1011,49 +960,8 @@ impl f128 { #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] pub const fn from_bits(v: u128) -> Self { // It turns out the safety issues with sNaN were overblown! Hooray! - // SAFETY: `u128` is a plain old datatype so we can always transmute from it - // ...sorta. - // - // It turns out that at runtime, it is possible for a floating point number - // to be subject to floating point modes that alter nonzero subnormal numbers - // to zero on reads and writes, aka "denormals are zero" and "flush to zero". - // This is not a problem usually, but at least one tier2 platform for Rust - // actually exhibits this behavior by default: thumbv7neon - // aka "the Neon FPU in AArch32 state" - // - // And, of course evaluating to a NaN value is fairly nondeterministic. - // More precisely: when NaN should be returned is knowable, but which NaN? - // So far that's defined by a combination of LLVM and the CPU, not Rust. - // This function, however, allows observing the bitstring of a NaN, - // thus introspection on CTFE. - // - // In order to preserve, at least for the moment, const-to-runtime equivalence, - // reject any of these possible situations from happening. - #[inline] - #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] - const fn ct_u128_to_f128(ct: u128) -> f128 { - match f128::classify_bits(ct) { - FpCategory::Subnormal => { - panic!("const-eval error: cannot use f128::from_bits on a subnormal number") - } - FpCategory::Nan => { - panic!("const-eval error: cannot use f128::from_bits on NaN") - } - FpCategory::Infinite | FpCategory::Normal | FpCategory::Zero => { - // SAFETY: It's not a frumious number - unsafe { mem::transmute::(ct) } - } - } - } - - #[inline(always)] // See https://github.com/rust-lang/compiler-builtins/issues/491 - fn rt_u128_to_f128(x: u128) -> f128 { - // SAFETY: `u128` is a plain old datatype so we can always... uh... - // ...look, just pretend you forgot what you just read. - // Stability concerns. - unsafe { mem::transmute(x) } - } - intrinsics::const_eval_select((v,), ct_u128_to_f128, rt_u128_to_f128) + // SAFETY: `u128` is a plain old datatype so we can always transmute from it. + unsafe { mem::transmute(v) } } /// Returns the memory representation of this floating point number as a byte array in diff --git a/library/core/src/num/f16.rs b/library/core/src/num/f16.rs index e5b1148e1921..41bd34a27023 100644 --- a/library/core/src/num/f16.rs +++ b/library/core/src/num/f16.rs @@ -284,7 +284,7 @@ impl f16 { #[inline] #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")] pub(crate) const fn abs_private(self) -> f16 { - // SAFETY: This transmutation is fine. Probably. For the reasons std is using it. + // SAFETY: This transmutation is fine just like in `to_bits`/`from_bits`. unsafe { mem::transmute::(mem::transmute::(self) & !Self::SIGN_MASK) } } @@ -426,15 +426,15 @@ impl f16 { pub const fn classify(self) -> FpCategory { // A previous implementation for f32/f64 tried to only use bitmask-based checks, // using `to_bits` to transmute the float to its bit repr and match on that. - // Unfortunately, floating point numbers can be much worse than that. - // This also needs to not result in recursive evaluations of `to_bits`. + // If we only cared about being "technically" correct, that's an entirely legit + // implementation. // - - // Platforms without native support generally convert to `f32` to perform operations, - // and most of these platforms correctly round back to `f16` after each operation. - // However, some platforms have bugs where they keep the excess `f32` precision (e.g. - // WASM, see llvm/llvm-project#96437). This implementation makes a best-effort attempt - // to account for that excess precision. + // Unfortunately, there are platforms out there that do not correctly implement the IEEE + // float semantics Rust relies on: some hardware flushes denormals to zero, and some + // platforms convert to `f32` to perform operations without properly rounding back (e.g. + // WASM, see llvm/llvm-project#96437). These are platforms bugs, and Rust will misbehave on + // such platforms, but we can at least try to make things seem as sane as possible by being + // careful here. if self.is_infinite() { // Thus, a value may compare unequal to infinity, despite having a "full" exponent mask. FpCategory::Infinite @@ -446,49 +446,20 @@ impl f16 { // as correctness requires avoiding equality tests that may be Subnormal == -0.0 // because it may be wrong under "denormals are zero" and "flush to zero" modes. // Most of std's targets don't use those, but they are used for thumbv7neon. - // So, this does use bitpattern matching for the rest. - - // SAFETY: f16 to u16 is fine. Usually. - // If classify has gotten this far, the value is definitely in one of these categories. - unsafe { f16::partial_classify(self) } - } - } - - /// This doesn't actually return a right answer for NaN on purpose, - /// seeing as how it cannot correctly discern between a floating point NaN, - /// and some normal floating point numbers truncated from an x87 FPU. - /// - /// # Safety - /// - /// This requires making sure you call this function for values it answers correctly on, - /// otherwise it returns a wrong answer. This is not important for memory safety per se, - /// but getting floats correct is important for not accidentally leaking const eval - /// runtime-deviating logic which may or may not be acceptable. - #[inline] - #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")] - const unsafe fn partial_classify(self) -> FpCategory { - // SAFETY: The caller is not asking questions for which this will tell lies. - let b = unsafe { mem::transmute::(self) }; - match (b & Self::MAN_MASK, b & Self::EXP_MASK) { - (0, Self::EXP_MASK) => FpCategory::Infinite, - (0, 0) => FpCategory::Zero, - (_, 0) => FpCategory::Subnormal, - _ => FpCategory::Normal, - } - } - - /// This operates on bits, and only bits, so it can ignore concerns about weird FPUs. - /// FIXME(jubilee): In a just world, this would be the entire impl for classify, - /// plus a transmute. We do not live in a just world, but we can make it more so. - #[inline] - #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")] - const fn classify_bits(b: u16) -> FpCategory { - match (b & Self::MAN_MASK, b & Self::EXP_MASK) { - (0, Self::EXP_MASK) => FpCategory::Infinite, - (_, Self::EXP_MASK) => FpCategory::Nan, - (0, 0) => FpCategory::Zero, - (_, 0) => FpCategory::Subnormal, - _ => FpCategory::Normal, + // So, this does use bitpattern matching for the rest. On x87, due to the incorrect + // float codegen on this hardware, this doesn't actually return a right answer for NaN + // because it cannot correctly discern between a floating point NaN, and some normal + // floating point numbers truncated from an x87 FPU -- but we took care of NaN above, so + // we are fine. + // FIXME(jubilee): This probably could at least answer things correctly for Infinity, + // like the f64 version does, but I need to run more checks on how things go on x86. + // I fear losing mantissa data that would have answered that differently. + let b = self.to_bits(); + match (b & Self::MAN_MASK, b & Self::EXP_MASK) { + (0, 0) => FpCategory::Zero, + (_, 0) => FpCategory::Subnormal, + _ => FpCategory::Normal, + } } } @@ -952,48 +923,7 @@ impl f16 { #[must_use = "this returns the result of the operation, without modifying the original"] pub const fn to_bits(self) -> u16 { // SAFETY: `u16` is a plain old datatype so we can always transmute to it. - // ...sorta. - // - // It turns out that at runtime, it is possible for a floating point number - // to be subject to a floating point mode that alters nonzero subnormal numbers - // to zero on reads and writes, aka "denormals are zero" and "flush to zero". - // - // And, of course evaluating to a NaN value is fairly nondeterministic. - // More precisely: when NaN should be returned is knowable, but which NaN? - // So far that's defined by a combination of LLVM and the CPU, not Rust. - // This function, however, allows observing the bitstring of a NaN, - // thus introspection on CTFE. - // - // In order to preserve, at least for the moment, const-to-runtime equivalence, - // we reject any of these possible situations from happening. - #[inline] - #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] - const fn ct_f16_to_u16(ct: f16) -> u16 { - // FIXME(f16_f128): we should use `.classify()` like `f32` and `f64`, but we don't yet - // want to rely on that on all platforms because it is nondeterministic (e.g. x86 has - // convention discrepancies calling intrinsics). So just classify the bits instead. - - // SAFETY: this is a POD transmutation - let bits = unsafe { mem::transmute::(ct) }; - match f16::classify_bits(bits) { - FpCategory::Nan => { - panic!("const-eval error: cannot use f16::to_bits on a NaN") - } - FpCategory::Subnormal => { - panic!("const-eval error: cannot use f16::to_bits on a subnormal number") - } - FpCategory::Infinite | FpCategory::Normal | FpCategory::Zero => bits, - } - } - - #[inline(always)] // See https://github.com/rust-lang/compiler-builtins/issues/491 - fn rt_f16_to_u16(x: f16) -> u16 { - // SAFETY: `u16` is a plain old datatype so we can always... uh... - // ...look, just pretend you forgot what you just read. - // Stability concerns. - unsafe { mem::transmute(x) } - } - intrinsics::const_eval_select((self,), ct_f16_to_u16, rt_f16_to_u16) + unsafe { mem::transmute(self) } } /// Raw transmutation from `u16`. @@ -1040,49 +970,8 @@ impl f16 { #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] pub const fn from_bits(v: u16) -> Self { // It turns out the safety issues with sNaN were overblown! Hooray! - // SAFETY: `u16` is a plain old datatype so we can always transmute from it - // ...sorta. - // - // It turns out that at runtime, it is possible for a floating point number - // to be subject to floating point modes that alter nonzero subnormal numbers - // to zero on reads and writes, aka "denormals are zero" and "flush to zero". - // This is not a problem usually, but at least one tier2 platform for Rust - // actually exhibits this behavior by default: thumbv7neon - // aka "the Neon FPU in AArch32 state" - // - // And, of course evaluating to a NaN value is fairly nondeterministic. - // More precisely: when NaN should be returned is knowable, but which NaN? - // So far that's defined by a combination of LLVM and the CPU, not Rust. - // This function, however, allows observing the bitstring of a NaN, - // thus introspection on CTFE. - // - // In order to preserve, at least for the moment, const-to-runtime equivalence, - // reject any of these possible situations from happening. - #[inline] - #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] - const fn ct_u16_to_f16(ct: u16) -> f16 { - match f16::classify_bits(ct) { - FpCategory::Subnormal => { - panic!("const-eval error: cannot use f16::from_bits on a subnormal number") - } - FpCategory::Nan => { - panic!("const-eval error: cannot use f16::from_bits on NaN") - } - FpCategory::Infinite | FpCategory::Normal | FpCategory::Zero => { - // SAFETY: It's not a frumious number - unsafe { mem::transmute::(ct) } - } - } - } - - #[inline(always)] // See https://github.com/rust-lang/compiler-builtins/issues/491 - fn rt_u16_to_f16(x: u16) -> f16 { - // SAFETY: `u16` is a plain old datatype so we can always... uh... - // ...look, just pretend you forgot what you just read. - // Stability concerns. - unsafe { mem::transmute(x) } - } - intrinsics::const_eval_select((v,), ct_u16_to_f16, rt_u16_to_f16) + // SAFETY: `u16` is a plain old datatype so we can always transmute from it. + unsafe { mem::transmute(v) } } /// Returns the memory representation of this floating point number as a byte array in diff --git a/library/core/src/num/f32.rs b/library/core/src/num/f32.rs index 7710e23edf0b..719727e2f1e0 100644 --- a/library/core/src/num/f32.rs +++ b/library/core/src/num/f32.rs @@ -529,7 +529,7 @@ impl f32 { #[inline] #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")] pub(crate) const fn abs_private(self) -> f32 { - // SAFETY: This transmutation is fine. Probably. For the reasons std is using it. + // SAFETY: This transmutation is fine just like in `to_bits`/`from_bits`. unsafe { mem::transmute::(mem::transmute::(self) & !Self::SIGN_MASK) } } @@ -654,18 +654,20 @@ impl f32 { pub const fn classify(self) -> FpCategory { // A previous implementation tried to only use bitmask-based checks, // using f32::to_bits to transmute the float to its bit repr and match on that. - // Unfortunately, floating point numbers can be much worse than that. - // This also needs to not result in recursive evaluations of f64::to_bits. + // If we only cared about being "technically" correct, that's an entirely legit + // implementation. + // + // Unfortunately, there is hardware out there that does not correctly implement the IEEE + // float semantics Rust relies on: x87 uses a too-large mantissa and exponent, and some + // hardware flushes subnormals to zero. These are platforms bugs, and Rust will misbehave on + // such hardware, but we can at least try to make things seem as sane as possible by being + // careful here. // - // On some processors, in some cases, LLVM will "helpfully" lower floating point ops, - // in spite of a request for them using f32 and f64, to things like x87 operations. - // These have an f64's mantissa, but can have a larger than normal exponent. // FIXME(jubilee): Using x87 operations is never necessary in order to function // on x86 processors for Rust-to-Rust calls, so this issue should not happen. // Code generation should be adjusted to use non-C calling conventions, avoiding this. - // if self.is_infinite() { - // Thus, a value may compare unequal to infinity, despite having a "full" exponent mask. + // A value may compare unequal to infinity, despite having a "full" exponent mask. FpCategory::Infinite } else if self.is_nan() { // And it may not be NaN, as it can simply be an "overextended" finite value. @@ -675,48 +677,20 @@ impl f32 { // as correctness requires avoiding equality tests that may be Subnormal == -0.0 // because it may be wrong under "denormals are zero" and "flush to zero" modes. // Most of std's targets don't use those, but they are used for thumbv7neon. - // So, this does use bitpattern matching for the rest. - - // SAFETY: f32 to u32 is fine. Usually. - // If classify has gotten this far, the value is definitely in one of these categories. - unsafe { f32::partial_classify(self) } - } - } - - // This doesn't actually return a right answer for NaN on purpose, - // seeing as how it cannot correctly discern between a floating point NaN, - // and some normal floating point numbers truncated from an x87 FPU. - // FIXME(jubilee): This probably could at least answer things correctly for Infinity, - // like the f64 version does, but I need to run more checks on how things go on x86. - // I fear losing mantissa data that would have answered that differently. - // - // # Safety - // This requires making sure you call this function for values it answers correctly on, - // otherwise it returns a wrong answer. This is not important for memory safety per se, - // but getting floats correct is important for not accidentally leaking const eval - // runtime-deviating logic which may or may not be acceptable. - #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")] - const unsafe fn partial_classify(self) -> FpCategory { - // SAFETY: The caller is not asking questions for which this will tell lies. - let b = unsafe { mem::transmute::(self) }; - match (b & Self::MAN_MASK, b & Self::EXP_MASK) { - (0, 0) => FpCategory::Zero, - (_, 0) => FpCategory::Subnormal, - _ => FpCategory::Normal, - } - } - - // This operates on bits, and only bits, so it can ignore concerns about weird FPUs. - // FIXME(jubilee): In a just world, this would be the entire impl for classify, - // plus a transmute. We do not live in a just world, but we can make it more so. - #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")] - const fn classify_bits(b: u32) -> FpCategory { - match (b & Self::MAN_MASK, b & Self::EXP_MASK) { - (0, Self::EXP_MASK) => FpCategory::Infinite, - (_, Self::EXP_MASK) => FpCategory::Nan, - (0, 0) => FpCategory::Zero, - (_, 0) => FpCategory::Subnormal, - _ => FpCategory::Normal, + // So, this does use bitpattern matching for the rest. On x87, due to the incorrect + // float codegen on this hardware, this doesn't actually return a right answer for NaN + // because it cannot correctly discern between a floating point NaN, and some normal + // floating point numbers truncated from an x87 FPU -- but we took care of NaN above, so + // we are fine. + // FIXME(jubilee): This probably could at least answer things correctly for Infinity, + // like the f64 version does, but I need to run more checks on how things go on x86. + // I fear losing mantissa data that would have answered that differently. + let b = self.to_bits(); + match (b & Self::MAN_MASK, b & Self::EXP_MASK) { + (0, 0) => FpCategory::Zero, + (_, 0) => FpCategory::Subnormal, + _ => FpCategory::Normal, + } } } @@ -1143,51 +1117,7 @@ impl f32 { #[inline] pub const fn to_bits(self) -> u32 { // SAFETY: `u32` is a plain old datatype so we can always transmute to it. - // ...sorta. - // - // It turns out that at runtime, it is possible for a floating point number - // to be subject to a floating point mode that alters nonzero subnormal numbers - // to zero on reads and writes, aka "denormals are zero" and "flush to zero". - // This is not a problem per se, but at least one tier2 platform for Rust - // actually exhibits this behavior by default. - // - // In addition, on x86 targets with SSE or SSE2 disabled and the x87 FPU enabled, - // i.e. not soft-float, the way Rust does parameter passing can actually alter - // a number that is "not infinity" to have the same exponent as infinity, - // in a slightly unpredictable manner. - // - // And, of course evaluating to a NaN value is fairly nondeterministic. - // More precisely: when NaN should be returned is knowable, but which NaN? - // So far that's defined by a combination of LLVM and the CPU, not Rust. - // This function, however, allows observing the bitstring of a NaN, - // thus introspection on CTFE. - // - // In order to preserve, at least for the moment, const-to-runtime equivalence, - // we reject any of these possible situations from happening. - #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] - const fn ct_f32_to_u32(ct: f32) -> u32 { - match ct.classify() { - FpCategory::Nan => { - panic!("const-eval error: cannot use f32::to_bits on a NaN") - } - FpCategory::Subnormal => { - panic!("const-eval error: cannot use f32::to_bits on a subnormal number") - } - FpCategory::Infinite | FpCategory::Normal | FpCategory::Zero => { - // SAFETY: We have a normal floating point number. Now we transmute, i.e. do a bitcopy. - unsafe { mem::transmute::(ct) } - } - } - } - - #[inline(always)] // See https://github.com/rust-lang/compiler-builtins/issues/491 - fn rt_f32_to_u32(x: f32) -> u32 { - // SAFETY: `u32` is a plain old datatype so we can always... uh... - // ...look, just pretend you forgot what you just read. - // Stability concerns. - unsafe { mem::transmute(x) } - } - intrinsics::const_eval_select((self,), ct_f32_to_u32, rt_f32_to_u32) + unsafe { mem::transmute(self) } } /// Raw transmutation from `u32`. @@ -1232,53 +1162,8 @@ impl f32 { #[inline] pub const fn from_bits(v: u32) -> Self { // It turns out the safety issues with sNaN were overblown! Hooray! - // SAFETY: `u32` is a plain old datatype so we can always transmute from it - // ...sorta. - // - // It turns out that at runtime, it is possible for a floating point number - // to be subject to floating point modes that alter nonzero subnormal numbers - // to zero on reads and writes, aka "denormals are zero" and "flush to zero". - // This is not a problem usually, but at least one tier2 platform for Rust - // actually exhibits this behavior by default: thumbv7neon - // aka "the Neon FPU in AArch32 state" - // - // In addition, on x86 targets with SSE or SSE2 disabled and the x87 FPU enabled, - // i.e. not soft-float, the way Rust does parameter passing can actually alter - // a number that is "not infinity" to have the same exponent as infinity, - // in a slightly unpredictable manner. - // - // And, of course evaluating to a NaN value is fairly nondeterministic. - // More precisely: when NaN should be returned is knowable, but which NaN? - // So far that's defined by a combination of LLVM and the CPU, not Rust. - // This function, however, allows observing the bitstring of a NaN, - // thus introspection on CTFE. - // - // In order to preserve, at least for the moment, const-to-runtime equivalence, - // reject any of these possible situations from happening. - #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] - const fn ct_u32_to_f32(ct: u32) -> f32 { - match f32::classify_bits(ct) { - FpCategory::Subnormal => { - panic!("const-eval error: cannot use f32::from_bits on a subnormal number") - } - FpCategory::Nan => { - panic!("const-eval error: cannot use f32::from_bits on NaN") - } - FpCategory::Infinite | FpCategory::Normal | FpCategory::Zero => { - // SAFETY: It's not a frumious number - unsafe { mem::transmute::(ct) } - } - } - } - - #[inline(always)] // See https://github.com/rust-lang/compiler-builtins/issues/491 - fn rt_u32_to_f32(x: u32) -> f32 { - // SAFETY: `u32` is a plain old datatype so we can always... uh... - // ...look, just pretend you forgot what you just read. - // Stability concerns. - unsafe { mem::transmute(x) } - } - intrinsics::const_eval_select((v,), ct_u32_to_f32, rt_u32_to_f32) + // SAFETY: `u32` is a plain old datatype so we can always transmute from it. + unsafe { mem::transmute(v) } } /// Returns the memory representation of this floating point number as a byte array in diff --git a/library/core/src/num/f64.rs b/library/core/src/num/f64.rs index a89859be7efe..85eb152ad1f1 100644 --- a/library/core/src/num/f64.rs +++ b/library/core/src/num/f64.rs @@ -528,7 +528,7 @@ impl f64 { #[inline] #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")] pub(crate) const fn abs_private(self) -> f64 { - // SAFETY: This transmutation is fine. Probably. For the reasons std is using it. + // SAFETY: This transmutation is fine just like in `to_bits`/`from_bits`. unsafe { mem::transmute::(mem::transmute::(self) & !Self::SIGN_MASK) } } @@ -653,12 +653,14 @@ impl f64 { pub const fn classify(self) -> FpCategory { // A previous implementation tried to only use bitmask-based checks, // using f64::to_bits to transmute the float to its bit repr and match on that. - // Unfortunately, floating point numbers can be much worse than that. - // This also needs to not result in recursive evaluations of f64::to_bits. + // If we only cared about being "technically" correct, that's an entirely legit + // implementation. + // + // Unfortunately, there is hardware out there that does not correctly implement the IEEE + // float semantics Rust relies on: x87 uses a too-large exponent, and some hardware flushes + // subnormals to zero. These are platforms bugs, and Rust will misbehave on such hardware, + // but we can at least try to make things seem as sane as possible by being careful here. // - // On some processors, in some cases, LLVM will "helpfully" lower floating point ops, - // in spite of a request for them using f32 and f64, to things like x87 operations. - // These have an f64's mantissa, but can have a larger than normal exponent. // FIXME(jubilee): Using x87 operations is never necessary in order to function // on x86 processors for Rust-to-Rust calls, so this issue should not happen. // Code generation should be adjusted to use non-C calling conventions, avoiding this. @@ -672,41 +674,18 @@ impl f64 { // as correctness requires avoiding equality tests that may be Subnormal == -0.0 // because it may be wrong under "denormals are zero" and "flush to zero" modes. // Most of std's targets don't use those, but they are used for thumbv7neon. - // So, this does use bitpattern matching for the rest. - - // SAFETY: f64 to u64 is fine. Usually. - // If control flow has gotten this far, the value is definitely in one of the categories - // that f64::partial_classify can correctly analyze. - unsafe { f64::partial_classify(self) } - } - } - - // This doesn't actually return a right answer for NaN on purpose, - // seeing as how it cannot correctly discern between a floating point NaN, - // and some normal floating point numbers truncated from an x87 FPU. - #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")] - const unsafe fn partial_classify(self) -> FpCategory { - // SAFETY: The caller is not asking questions for which this will tell lies. - let b = unsafe { mem::transmute::(self) }; - match (b & Self::MAN_MASK, b & Self::EXP_MASK) { - (0, Self::EXP_MASK) => FpCategory::Infinite, - (0, 0) => FpCategory::Zero, - (_, 0) => FpCategory::Subnormal, - _ => FpCategory::Normal, - } - } - - // This operates on bits, and only bits, so it can ignore concerns about weird FPUs. - // FIXME(jubilee): In a just world, this would be the entire impl for classify, - // plus a transmute. We do not live in a just world, but we can make it more so. - #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")] - const fn classify_bits(b: u64) -> FpCategory { - match (b & Self::MAN_MASK, b & Self::EXP_MASK) { - (0, Self::EXP_MASK) => FpCategory::Infinite, - (_, Self::EXP_MASK) => FpCategory::Nan, - (0, 0) => FpCategory::Zero, - (_, 0) => FpCategory::Subnormal, - _ => FpCategory::Normal, + // So, this does use bitpattern matching for the rest. On x87, due to the incorrect + // float codegen on this hardware, this doesn't actually return a right answer for NaN + // because it cannot correctly discern between a floating point NaN, and some normal + // floating point numbers truncated from an x87 FPU -- but we took care of NaN above, so + // we are fine. + let b = self.to_bits(); + match (b & Self::MAN_MASK, b & Self::EXP_MASK) { + (0, Self::EXP_MASK) => FpCategory::Infinite, + (0, 0) => FpCategory::Zero, + (_, 0) => FpCategory::Subnormal, + _ => FpCategory::Normal, + } } } @@ -1134,33 +1113,7 @@ impl f64 { #[inline] pub const fn to_bits(self) -> u64 { // SAFETY: `u64` is a plain old datatype so we can always transmute to it. - // ...sorta. - // - // See the SAFETY comment in f64::from_bits for more. - #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] - const fn ct_f64_to_u64(ct: f64) -> u64 { - match ct.classify() { - FpCategory::Nan => { - panic!("const-eval error: cannot use f64::to_bits on a NaN") - } - FpCategory::Subnormal => { - panic!("const-eval error: cannot use f64::to_bits on a subnormal number") - } - FpCategory::Infinite | FpCategory::Normal | FpCategory::Zero => { - // SAFETY: We have a normal floating point number. Now we transmute, i.e. do a bitcopy. - unsafe { mem::transmute::(ct) } - } - } - } - - #[inline(always)] // See https://github.com/rust-lang/compiler-builtins/issues/491 - fn rt_f64_to_u64(rt: f64) -> u64 { - // SAFETY: `u64` is a plain old datatype so we can always... uh... - // ...look, just pretend you forgot what you just read. - // Stability concerns. - unsafe { mem::transmute::(rt) } - } - intrinsics::const_eval_select((self,), ct_f64_to_u64, rt_f64_to_u64) + unsafe { mem::transmute(self) } } /// Raw transmutation from `u64`. @@ -1205,58 +1158,8 @@ impl f64 { #[inline] pub const fn from_bits(v: u64) -> Self { // It turns out the safety issues with sNaN were overblown! Hooray! - // SAFETY: `u64` is a plain old datatype so we can always transmute from it - // ...sorta. - // - // It turns out that at runtime, it is possible for a floating point number - // to be subject to floating point modes that alter nonzero subnormal numbers - // to zero on reads and writes, aka "denormals are zero" and "flush to zero". - // This is not a problem usually, but at least one tier2 platform for Rust - // actually exhibits an FTZ behavior by default: thumbv7neon - // aka "the Neon FPU in AArch32 state" - // - // Even with this, not all instructions exhibit the FTZ behaviors on thumbv7neon, - // so this should load the same bits if LLVM emits the "correct" instructions, - // but LLVM sometimes makes interesting choices about float optimization, - // and other FPUs may do similar. Thus, it is wise to indulge luxuriously in caution. - // - // In addition, on x86 targets with SSE or SSE2 disabled and the x87 FPU enabled, - // i.e. not soft-float, the way Rust does parameter passing can actually alter - // a number that is "not infinity" to have the same exponent as infinity, - // in a slightly unpredictable manner. - // - // And, of course evaluating to a NaN value is fairly nondeterministic. - // More precisely: when NaN should be returned is knowable, but which NaN? - // So far that's defined by a combination of LLVM and the CPU, not Rust. - // This function, however, allows observing the bitstring of a NaN, - // thus introspection on CTFE. - // - // In order to preserve, at least for the moment, const-to-runtime equivalence, - // reject any of these possible situations from happening. - #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")] - const fn ct_u64_to_f64(ct: u64) -> f64 { - match f64::classify_bits(ct) { - FpCategory::Subnormal => { - panic!("const-eval error: cannot use f64::from_bits on a subnormal number") - } - FpCategory::Nan => { - panic!("const-eval error: cannot use f64::from_bits on NaN") - } - FpCategory::Infinite | FpCategory::Normal | FpCategory::Zero => { - // SAFETY: It's not a frumious number - unsafe { mem::transmute::(ct) } - } - } - } - - #[inline(always)] // See https://github.com/rust-lang/compiler-builtins/issues/491 - fn rt_u64_to_f64(rt: u64) -> f64 { - // SAFETY: `u64` is a plain old datatype so we can always... uh... - // ...look, just pretend you forgot what you just read. - // Stability concerns. - unsafe { mem::transmute::(rt) } - } - intrinsics::const_eval_select((v,), ct_u64_to_f64, rt_u64_to_f64) + // SAFETY: `u64` is a plain old datatype so we can always transmute from it. + unsafe { mem::transmute(v) } } /// Returns the memory representation of this floating point number as a byte array in diff --git a/tests/ui/consts/const-float-bits-conv.rs b/tests/ui/consts/const-float-bits-conv.rs index ba8db4c23dc9..74df90139478 100644 --- a/tests/ui/consts/const-float-bits-conv.rs +++ b/tests/ui/consts/const-float-bits-conv.rs @@ -38,6 +38,17 @@ fn f32() { const_assert!(f32::from_bits(0x44a72000), 1337.0); const_assert!(f32::from_ne_bytes(0x44a72000u32.to_ne_bytes()), 1337.0); const_assert!(f32::from_bits(0xc1640000), -14.25); + + // Check that NaNs roundtrip their bits regardless of signalingness + // 0xA is 0b1010; 0x5 is 0b0101 -- so these two together clobbers all the mantissa bits + // ...actually, let's just check that these break. :D + const MASKED_NAN1: u32 = f32::NAN.to_bits() ^ 0x002A_AAAA; + const MASKED_NAN2: u32 = f32::NAN.to_bits() ^ 0x0055_5555; + + const_assert!(f32::from_bits(MASKED_NAN1).is_nan()); + const_assert!(f32::from_bits(MASKED_NAN1).is_nan()); + const_assert!(f32::from_bits(MASKED_NAN1).to_bits(), MASKED_NAN1); + const_assert!(f32::from_bits(MASKED_NAN2).to_bits(), MASKED_NAN2); } fn f64() { @@ -55,6 +66,17 @@ fn f64() { const_assert!(f64::from_bits(0x4094e40000000000), 1337.0); const_assert!(f64::from_ne_bytes(0x4094e40000000000u64.to_ne_bytes()), 1337.0); const_assert!(f64::from_bits(0xc02c800000000000), -14.25); + + // Check that NaNs roundtrip their bits regardless of signalingness + // 0xA is 0b1010; 0x5 is 0b0101 -- so these two together clobbers all the mantissa bits + // ...actually, let's just check that these break. :D + const MASKED_NAN1: u64 = f64::NAN.to_bits() ^ 0x000A_AAAA_AAAA_AAAA; + const MASKED_NAN2: u64 = f64::NAN.to_bits() ^ 0x0005_5555_5555_5555; + + const_assert!(f64::from_bits(MASKED_NAN1).is_nan()); + const_assert!(f64::from_bits(MASKED_NAN1).is_nan()); + const_assert!(f64::from_bits(MASKED_NAN1).to_bits(), MASKED_NAN1); + const_assert!(f64::from_bits(MASKED_NAN2).to_bits(), MASKED_NAN2); } fn main() { diff --git a/tests/ui/consts/const-float-bits-reject-conv.rs b/tests/ui/consts/const-float-bits-reject-conv.rs deleted file mode 100644 index febb272869a3..000000000000 --- a/tests/ui/consts/const-float-bits-reject-conv.rs +++ /dev/null @@ -1,68 +0,0 @@ -//@ compile-flags: -Zmir-opt-level=0 -//@ error-pattern: cannot use f32::to_bits on a NaN -#![feature(const_float_bits_conv)] -#![feature(const_float_classify)] - -// Don't promote -const fn nop(x: T) -> T { x } - -macro_rules! const_assert { - ($a:expr) => { - { - const _: () = assert!($a); - assert!(nop($a)); - } - }; - ($a:expr, $b:expr) => { - { - const _: () = assert!($a == $b); - assert_eq!(nop($a), nop($b)); - } - }; -} - -fn f32() { - // Check that NaNs roundtrip their bits regardless of signalingness - // 0xA is 0b1010; 0x5 is 0b0101 -- so these two together clobbers all the mantissa bits - // ...actually, let's just check that these break. :D - const MASKED_NAN1: u32 = f32::NAN.to_bits() ^ 0x002A_AAAA; - //~^ inside - const MASKED_NAN2: u32 = f32::NAN.to_bits() ^ 0x0055_5555; - //~^ inside - - // The rest of the code is dead because the constants already fail to evaluate. - - const_assert!(f32::from_bits(MASKED_NAN1).is_nan()); - const_assert!(f32::from_bits(MASKED_NAN1).is_nan()); - - // LLVM does not guarantee that loads and stores of NaNs preserve their exact bit pattern. - // In practice, this seems to only cause a problem on x86, since the most widely used calling - // convention mandates that floating point values are returned on the x87 FPU stack. See #73328. - // However, during CTFE we still preserve bit patterns (though that is not a guarantee). - const_assert!(f32::from_bits(MASKED_NAN1).to_bits(), MASKED_NAN1); - const_assert!(f32::from_bits(MASKED_NAN2).to_bits(), MASKED_NAN2); -} - -fn f64() { - // Check that NaNs roundtrip their bits regardless of signalingness - // 0xA is 0b1010; 0x5 is 0b0101 -- so these two together clobbers all the mantissa bits - // ...actually, let's just check that these break. :D - const MASKED_NAN1: u64 = f64::NAN.to_bits() ^ 0x000A_AAAA_AAAA_AAAA; - //~^ inside - const MASKED_NAN2: u64 = f64::NAN.to_bits() ^ 0x0005_5555_5555_5555; - //~^ inside - - // The rest of the code is dead because the constants already fail to evaluate. - - const_assert!(f64::from_bits(MASKED_NAN1).is_nan()); - const_assert!(f64::from_bits(MASKED_NAN1).is_nan()); - - // See comment above. - const_assert!(f64::from_bits(MASKED_NAN1).to_bits(), MASKED_NAN1); - const_assert!(f64::from_bits(MASKED_NAN2).to_bits(), MASKED_NAN2); -} - -fn main() { - f32(); - f64(); -} diff --git a/tests/ui/consts/const-float-bits-reject-conv.stderr b/tests/ui/consts/const-float-bits-reject-conv.stderr deleted file mode 100644 index 1511dab12b0e..000000000000 --- a/tests/ui/consts/const-float-bits-reject-conv.stderr +++ /dev/null @@ -1,115 +0,0 @@ -error[E0080]: evaluation of constant value failed - --> $SRC_DIR/core/src/num/f32.rs:LL:COL - | - = note: the evaluated program panicked at 'const-eval error: cannot use f32::to_bits on a NaN', $SRC_DIR/core/src/num/f32.rs:LL:COL - | -note: inside `core::f32::::to_bits::ct_f32_to_u32` - --> $SRC_DIR/core/src/num/f32.rs:LL:COL -note: inside `core::f32::::to_bits` - --> $SRC_DIR/core/src/num/f32.rs:LL:COL -note: inside `f32::MASKED_NAN1` - --> $DIR/const-float-bits-reject-conv.rs:28:30 - | -LL | const MASKED_NAN1: u32 = f32::NAN.to_bits() ^ 0x002A_AAAA; - | ^^^^^^^^^^^^^^^^^^ - = note: this error originates in the macro `$crate::panic::panic_2021` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info) - -error[E0080]: evaluation of constant value failed - --> $SRC_DIR/core/src/num/f32.rs:LL:COL - | - = note: the evaluated program panicked at 'const-eval error: cannot use f32::to_bits on a NaN', $SRC_DIR/core/src/num/f32.rs:LL:COL - | -note: inside `core::f32::::to_bits::ct_f32_to_u32` - --> $SRC_DIR/core/src/num/f32.rs:LL:COL -note: inside `core::f32::::to_bits` - --> $SRC_DIR/core/src/num/f32.rs:LL:COL -note: inside `f32::MASKED_NAN2` - --> $DIR/const-float-bits-reject-conv.rs:30:30 - | -LL | const MASKED_NAN2: u32 = f32::NAN.to_bits() ^ 0x0055_5555; - | ^^^^^^^^^^^^^^^^^^ - = note: this error originates in the macro `$crate::panic::panic_2021` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info) - -note: erroneous constant encountered - --> $DIR/const-float-bits-reject-conv.rs:35:34 - | -LL | const_assert!(f32::from_bits(MASKED_NAN1).is_nan()); - | ^^^^^^^^^^^ - -note: erroneous constant encountered - --> $DIR/const-float-bits-reject-conv.rs:36:34 - | -LL | const_assert!(f32::from_bits(MASKED_NAN1).is_nan()); - | ^^^^^^^^^^^ - -note: erroneous constant encountered - --> $DIR/const-float-bits-reject-conv.rs:42:34 - | -LL | const_assert!(f32::from_bits(MASKED_NAN1).to_bits(), MASKED_NAN1); - | ^^^^^^^^^^^ - -note: erroneous constant encountered - --> $DIR/const-float-bits-reject-conv.rs:43:34 - | -LL | const_assert!(f32::from_bits(MASKED_NAN2).to_bits(), MASKED_NAN2); - | ^^^^^^^^^^^ - -error[E0080]: evaluation of constant value failed - --> $SRC_DIR/core/src/num/f64.rs:LL:COL - | - = note: the evaluated program panicked at 'const-eval error: cannot use f64::to_bits on a NaN', $SRC_DIR/core/src/num/f64.rs:LL:COL - | -note: inside `core::f64::::to_bits::ct_f64_to_u64` - --> $SRC_DIR/core/src/num/f64.rs:LL:COL -note: inside `core::f64::::to_bits` - --> $SRC_DIR/core/src/num/f64.rs:LL:COL -note: inside `f64::MASKED_NAN1` - --> $DIR/const-float-bits-reject-conv.rs:50:30 - | -LL | const MASKED_NAN1: u64 = f64::NAN.to_bits() ^ 0x000A_AAAA_AAAA_AAAA; - | ^^^^^^^^^^^^^^^^^^ - = note: this error originates in the macro `$crate::panic::panic_2021` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info) - -error[E0080]: evaluation of constant value failed - --> $SRC_DIR/core/src/num/f64.rs:LL:COL - | - = note: the evaluated program panicked at 'const-eval error: cannot use f64::to_bits on a NaN', $SRC_DIR/core/src/num/f64.rs:LL:COL - | -note: inside `core::f64::::to_bits::ct_f64_to_u64` - --> $SRC_DIR/core/src/num/f64.rs:LL:COL -note: inside `core::f64::::to_bits` - --> $SRC_DIR/core/src/num/f64.rs:LL:COL -note: inside `f64::MASKED_NAN2` - --> $DIR/const-float-bits-reject-conv.rs:52:30 - | -LL | const MASKED_NAN2: u64 = f64::NAN.to_bits() ^ 0x0005_5555_5555_5555; - | ^^^^^^^^^^^^^^^^^^ - = note: this error originates in the macro `$crate::panic::panic_2021` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info) - -note: erroneous constant encountered - --> $DIR/const-float-bits-reject-conv.rs:57:34 - | -LL | const_assert!(f64::from_bits(MASKED_NAN1).is_nan()); - | ^^^^^^^^^^^ - -note: erroneous constant encountered - --> $DIR/const-float-bits-reject-conv.rs:58:34 - | -LL | const_assert!(f64::from_bits(MASKED_NAN1).is_nan()); - | ^^^^^^^^^^^ - -note: erroneous constant encountered - --> $DIR/const-float-bits-reject-conv.rs:61:34 - | -LL | const_assert!(f64::from_bits(MASKED_NAN1).to_bits(), MASKED_NAN1); - | ^^^^^^^^^^^ - -note: erroneous constant encountered - --> $DIR/const-float-bits-reject-conv.rs:62:34 - | -LL | const_assert!(f64::from_bits(MASKED_NAN2).to_bits(), MASKED_NAN2); - | ^^^^^^^^^^^ - -error: aborting due to 4 previous errors - -For more information about this error, try `rustc --explain E0080`. From 833af65f38c4674e3ae6d886174e65f0fcabab3d Mon Sep 17 00:00:00 2001 From: Michael Goulet Date: Wed, 7 Aug 2024 13:01:34 -0400 Subject: [PATCH 24/79] Use FnSig instead of raw FnDecl for ForeignItemKind::Fn --- compiler/rustc_ast_lowering/src/delegation.rs | 2 +- compiler/rustc_ast_lowering/src/item.rs | 24 +++++--- compiler/rustc_hir/src/hir.rs | 39 +++++++----- compiler/rustc_hir/src/intravisit.rs | 4 +- .../rustc_hir_analysis/src/check/check.rs | 4 +- .../rustc_hir_analysis/src/check/intrinsic.rs | 2 +- .../rustc_hir_analysis/src/check/wfcheck.rs | 4 +- compiler/rustc_hir_analysis/src/collect.rs | 6 +- .../src/collect/resolve_bound_vars.rs | 2 +- compiler/rustc_hir_pretty/src/lib.rs | 11 +--- compiler/rustc_lint/src/types.rs | 9 ++- compiler/rustc_middle/src/hir/map/mod.rs | 10 ++-- compiler/rustc_middle/src/hir/mod.rs | 2 +- .../ui/extern/extern-main-issue-86110.stderr | 2 +- .../safe-intrinsic-mismatch.effects.stderr | 4 +- .../safe-intrinsic-mismatch.stock.stderr | 4 +- tests/ui/issues/issue-16725.stderr | 2 +- tests/ui/lint/clashing-extern-fn.stderr | 60 +++++++++---------- tests/ui/lint/issue-1866.stderr | 4 +- .../ui/lint/lint-attr-everywhere-late.stderr | 8 +-- tests/ui/lint/lint-missing-doc.stderr | 2 +- tests/ui/lint/unreachable_pub.stderr | 2 +- .../ui/privacy/private-in-public-warn.stderr | 4 +- 23 files changed, 113 insertions(+), 98 deletions(-) diff --git a/compiler/rustc_ast_lowering/src/delegation.rs b/compiler/rustc_ast_lowering/src/delegation.rs index 300bfa101c6b..9c073130827c 100644 --- a/compiler/rustc_ast_lowering/src/delegation.rs +++ b/compiler/rustc_ast_lowering/src/delegation.rs @@ -189,7 +189,7 @@ impl<'hir> LoweringContext<'_, 'hir> { ) -> hir::FnSig<'hir> { let header = if let Some(local_sig_id) = sig_id.as_local() { match self.resolver.delegation_fn_sigs.get(&local_sig_id) { - Some(sig) => self.lower_fn_header(sig.header), + Some(sig) => self.lower_fn_header(sig.header, hir::Safety::Safe), None => self.generate_header_error(), } } else { diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs index 7af3945d3f99..f6065259d8d2 100644 --- a/compiler/rustc_ast_lowering/src/item.rs +++ b/compiler/rustc_ast_lowering/src/item.rs @@ -237,7 +237,7 @@ impl<'hir> LoweringContext<'_, 'hir> { }); let sig = hir::FnSig { decl, - header: this.lower_fn_header(*header), + header: this.lower_fn_header(*header, hir::Safety::Safe), span: this.lower_span(*fn_sig_span), }; hir::ItemKind::Fn(sig, generics, body_id) @@ -668,7 +668,7 @@ impl<'hir> LoweringContext<'_, 'hir> { ForeignItemKind::Fn(box Fn { sig, generics, .. }) => { let fdec = &sig.decl; let itctx = ImplTraitContext::Universal; - let (generics, (fn_dec, fn_args)) = + let (generics, (decl, fn_args)) = self.lower_generics(generics, Const::No, false, i.id, itctx, |this| { ( // Disallow `impl Trait` in foreign items. @@ -682,9 +682,15 @@ impl<'hir> LoweringContext<'_, 'hir> { this.lower_fn_params_to_names(fdec), ) }); - let safety = self.lower_safety(sig.header.safety, hir::Safety::Unsafe); - hir::ForeignItemKind::Fn(fn_dec, fn_args, generics, safety) + // Unmarked safety in unsafe block defaults to unsafe. + let header = self.lower_fn_header(sig.header, hir::Safety::Unsafe); + + hir::ForeignItemKind::Fn( + hir::FnSig { header, decl, span: self.lower_span(sig.span) }, + fn_args, + generics, + ) } ForeignItemKind::Static(box StaticItem { ty, mutability, expr: _, safety }) => { let ty = self @@ -1390,7 +1396,7 @@ impl<'hir> LoweringContext<'_, 'hir> { coroutine_kind: Option, parent_constness: Const, ) -> (&'hir hir::Generics<'hir>, hir::FnSig<'hir>) { - let header = self.lower_fn_header(sig.header); + let header = self.lower_fn_header(sig.header, hir::Safety::Safe); // Don't pass along the user-provided constness of trait associated functions; we don't want to // synthesize a host effect param for them. We reject `const` on them during AST validation. let constness = @@ -1403,14 +1409,18 @@ impl<'hir> LoweringContext<'_, 'hir> { (generics, hir::FnSig { header, decl, span: self.lower_span(sig.span) }) } - pub(super) fn lower_fn_header(&mut self, h: FnHeader) -> hir::FnHeader { + pub(super) fn lower_fn_header( + &mut self, + h: FnHeader, + default_safety: hir::Safety, + ) -> hir::FnHeader { let asyncness = if let Some(CoroutineKind::Async { span, .. }) = h.coroutine_kind { hir::IsAsync::Async(span) } else { hir::IsAsync::NotAsync }; hir::FnHeader { - safety: self.lower_safety(h.safety, hir::Safety::Safe), + safety: self.lower_safety(h.safety, default_safety), asyncness: asyncness, constness: self.lower_constness(h.constness), abi: self.lower_extern(h.ext), diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs index 33e8432596be..6599e7034611 100644 --- a/compiler/rustc_hir/src/hir.rs +++ b/compiler/rustc_hir/src/hir.rs @@ -3586,7 +3586,7 @@ impl ForeignItem<'_> { #[derive(Debug, Clone, Copy, HashStable_Generic)] pub enum ForeignItemKind<'hir> { /// A foreign function. - Fn(&'hir FnDecl<'hir>, &'hir [Ident], &'hir Generics<'hir>, Safety), + Fn(FnSig<'hir>, &'hir [Ident], &'hir Generics<'hir>), /// A foreign static item (`static ext: u8`). Static(&'hir Ty<'hir>, Mutability, Safety), /// A foreign type. @@ -3645,7 +3645,10 @@ impl<'hir> OwnerNode<'hir> { match self { OwnerNode::TraitItem(TraitItem { kind: TraitItemKind::Fn(fn_sig, _), .. }) | OwnerNode::ImplItem(ImplItem { kind: ImplItemKind::Fn(fn_sig, _), .. }) - | OwnerNode::Item(Item { kind: ItemKind::Fn(fn_sig, _, _), .. }) => Some(fn_sig), + | OwnerNode::Item(Item { kind: ItemKind::Fn(fn_sig, _, _), .. }) + | OwnerNode::ForeignItem(ForeignItem { + kind: ForeignItemKind::Fn(fn_sig, _, _), .. + }) => Some(fn_sig), _ => None, } } @@ -3654,11 +3657,10 @@ impl<'hir> OwnerNode<'hir> { match self { OwnerNode::TraitItem(TraitItem { kind: TraitItemKind::Fn(fn_sig, _), .. }) | OwnerNode::ImplItem(ImplItem { kind: ImplItemKind::Fn(fn_sig, _), .. }) - | OwnerNode::Item(Item { kind: ItemKind::Fn(fn_sig, _, _), .. }) => Some(fn_sig.decl), - OwnerNode::ForeignItem(ForeignItem { - kind: ForeignItemKind::Fn(fn_decl, _, _, _), - .. - }) => Some(fn_decl), + | OwnerNode::Item(Item { kind: ItemKind::Fn(fn_sig, _, _), .. }) + | OwnerNode::ForeignItem(ForeignItem { + kind: ForeignItemKind::Fn(fn_sig, _, _), .. + }) => Some(fn_sig.decl), _ => None, } } @@ -3846,11 +3848,13 @@ impl<'hir> Node<'hir> { match self { Node::TraitItem(TraitItem { kind: TraitItemKind::Fn(fn_sig, _), .. }) | Node::ImplItem(ImplItem { kind: ImplItemKind::Fn(fn_sig, _), .. }) - | Node::Item(Item { kind: ItemKind::Fn(fn_sig, _, _), .. }) => Some(fn_sig.decl), - Node::Expr(Expr { kind: ExprKind::Closure(Closure { fn_decl, .. }), .. }) - | Node::ForeignItem(ForeignItem { - kind: ForeignItemKind::Fn(fn_decl, _, _, _), .. - }) => Some(fn_decl), + | Node::Item(Item { kind: ItemKind::Fn(fn_sig, _, _), .. }) + | Node::ForeignItem(ForeignItem { kind: ForeignItemKind::Fn(fn_sig, _, _), .. }) => { + Some(fn_sig.decl) + } + Node::Expr(Expr { kind: ExprKind::Closure(Closure { fn_decl, .. }), .. }) => { + Some(fn_decl) + } _ => None, } } @@ -3874,7 +3878,10 @@ impl<'hir> Node<'hir> { match self { Node::TraitItem(TraitItem { kind: TraitItemKind::Fn(fn_sig, _), .. }) | Node::ImplItem(ImplItem { kind: ImplItemKind::Fn(fn_sig, _), .. }) - | Node::Item(Item { kind: ItemKind::Fn(fn_sig, _, _), .. }) => Some(fn_sig), + | Node::Item(Item { kind: ItemKind::Fn(fn_sig, _, _), .. }) + | Node::ForeignItem(ForeignItem { kind: ForeignItemKind::Fn(fn_sig, _, _), .. }) => { + Some(fn_sig) + } _ => None, } } @@ -3949,7 +3956,7 @@ impl<'hir> Node<'hir> { pub fn generics(self) -> Option<&'hir Generics<'hir>> { match self { Node::ForeignItem(ForeignItem { - kind: ForeignItemKind::Fn(_, _, generics, _), .. + kind: ForeignItemKind::Fn(_, _, generics), .. }) | Node::TraitItem(TraitItem { generics, .. }) | Node::ImplItem(ImplItem { generics, .. }) => Some(generics), @@ -4039,8 +4046,8 @@ mod size_asserts { static_assert_size!(Expr<'_>, 64); static_assert_size!(ExprKind<'_>, 48); static_assert_size!(FnDecl<'_>, 40); - static_assert_size!(ForeignItem<'_>, 72); - static_assert_size!(ForeignItemKind<'_>, 40); + static_assert_size!(ForeignItem<'_>, 88); + static_assert_size!(ForeignItemKind<'_>, 56); static_assert_size!(GenericArg<'_>, 16); static_assert_size!(GenericBound<'_>, 48); static_assert_size!(Generics<'_>, 56); diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs index dd501f8417e6..a54596e3088d 100644 --- a/compiler/rustc_hir/src/intravisit.rs +++ b/compiler/rustc_hir/src/intravisit.rs @@ -611,9 +611,9 @@ pub fn walk_foreign_item<'v, V: Visitor<'v>>( try_visit!(visitor.visit_ident(foreign_item.ident)); match foreign_item.kind { - ForeignItemKind::Fn(ref function_declaration, param_names, ref generics, _) => { + ForeignItemKind::Fn(ref sig, param_names, ref generics) => { try_visit!(visitor.visit_generics(generics)); - try_visit!(visitor.visit_fn_decl(function_declaration)); + try_visit!(visitor.visit_fn_decl(sig.decl)); walk_list!(visitor, visit_ident, param_names.iter().copied()); } ForeignItemKind::Static(ref typ, _, _) => { diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs index 2e778fd37596..0135cdf1e900 100644 --- a/compiler/rustc_hir_analysis/src/check/check.rs +++ b/compiler/rustc_hir_analysis/src/check/check.rs @@ -804,8 +804,8 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) { let item = tcx.hir().foreign_item(item.id); match &item.kind { - hir::ForeignItemKind::Fn(fn_decl, _, _, _) => { - require_c_abi_if_c_variadic(tcx, fn_decl, abi, item.span); + hir::ForeignItemKind::Fn(sig, _, _) => { + require_c_abi_if_c_variadic(tcx, sig.decl, abi, item.span); } hir::ForeignItemKind::Static(..) => { check_static_inhabited(tcx, def_id); diff --git a/compiler/rustc_hir_analysis/src/check/intrinsic.rs b/compiler/rustc_hir_analysis/src/check/intrinsic.rs index 4b45ced30c57..c2b2f08132ed 100644 --- a/compiler/rustc_hir_analysis/src/check/intrinsic.rs +++ b/compiler/rustc_hir_analysis/src/check/intrinsic.rs @@ -30,7 +30,7 @@ fn equate_intrinsic_type<'tcx>( let (generics, span) = match tcx.hir_node_by_def_id(def_id) { hir::Node::Item(hir::Item { kind: hir::ItemKind::Fn(_, generics, _), .. }) | hir::Node::ForeignItem(hir::ForeignItem { - kind: hir::ForeignItemKind::Fn(.., generics, _), + kind: hir::ForeignItemKind::Fn(_, _, generics), .. }) => (tcx.generics_of(def_id), generics.span), _ => { diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs index d3b928fc17c5..bdf2914fc50c 100644 --- a/compiler/rustc_hir_analysis/src/check/wfcheck.rs +++ b/compiler/rustc_hir_analysis/src/check/wfcheck.rs @@ -350,8 +350,8 @@ fn check_foreign_item<'tcx>( ); match item.kind { - hir::ForeignItemKind::Fn(decl, ..) => { - check_item_fn(tcx, def_id, item.ident, item.span, decl) + hir::ForeignItemKind::Fn(sig, ..) => { + check_item_fn(tcx, def_id, item.ident, item.span, sig.decl) } hir::ForeignItemKind::Static(ty, ..) => { check_item_type(tcx, def_id, ty.span, UnsizedHandling::AllowIfForeignTail) diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs index 91fa066ec6a1..f75954c9edfb 100644 --- a/compiler/rustc_hir_analysis/src/collect.rs +++ b/compiler/rustc_hir_analysis/src/collect.rs @@ -1440,11 +1440,9 @@ fn fn_sig(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::EarlyBinder<'_, ty::PolyFn icx.lowerer().lower_fn_ty(hir_id, header.safety, header.abi, decl, Some(generics), None) } - ForeignItem(&hir::ForeignItem { - kind: ForeignItemKind::Fn(fn_decl, _, _, safety), .. - }) => { + ForeignItem(&hir::ForeignItem { kind: ForeignItemKind::Fn(sig, _, _), .. }) => { let abi = tcx.hir().get_foreign_abi(hir_id); - compute_sig_of_foreign_fn_decl(tcx, def_id, fn_decl, abi, safety) + compute_sig_of_foreign_fn_decl(tcx, def_id, sig.decl, abi, sig.header.safety) } Ctor(data) | Variant(hir::Variant { data, .. }) if data.ctor().is_some() => { diff --git a/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs b/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs index e11d3c9c48b4..ae0c70d23268 100644 --- a/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs +++ b/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs @@ -604,7 +604,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> { fn visit_foreign_item(&mut self, item: &'tcx hir::ForeignItem<'tcx>) { match item.kind { - hir::ForeignItemKind::Fn(_, _, generics, _) => { + hir::ForeignItemKind::Fn(_, _, generics) => { self.visit_early_late(item.hir_id(), generics, |this| { intravisit::walk_foreign_item(this, item); }) diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs index 089cee2fa0de..cff21173f798 100644 --- a/compiler/rustc_hir_pretty/src/lib.rs +++ b/compiler/rustc_hir_pretty/src/lib.rs @@ -352,16 +352,11 @@ impl<'a> State<'a> { self.maybe_print_comment(item.span.lo()); self.print_outer_attributes(self.attrs(item.hir_id())); match item.kind { - hir::ForeignItemKind::Fn(decl, arg_names, generics, safety) => { + hir::ForeignItemKind::Fn(sig, arg_names, generics) => { self.head(""); self.print_fn( - decl, - hir::FnHeader { - safety, - constness: hir::Constness::NotConst, - abi: Abi::Rust, - asyncness: hir::IsAsync::NotAsync, - }, + sig.decl, + sig.header, Some(item.ident.name), generics, arg_names, diff --git a/compiler/rustc_lint/src/types.rs b/compiler/rustc_lint/src/types.rs index 54bf73a40dd5..cb7a07116ced 100644 --- a/compiler/rustc_lint/src/types.rs +++ b/compiler/rustc_lint/src/types.rs @@ -1734,13 +1734,16 @@ impl<'tcx> LateLintPass<'tcx> for ImproperCTypesDeclarations { let abi = cx.tcx.hir().get_foreign_abi(it.hir_id()); match it.kind { - hir::ForeignItemKind::Fn(decl, _, _, _) if !vis.is_internal_abi(abi) => { - vis.check_foreign_fn(it.owner_id.def_id, decl); + hir::ForeignItemKind::Fn(sig, _, _) => { + if vis.is_internal_abi(abi) { + vis.check_fn(it.owner_id.def_id, sig.decl) + } else { + vis.check_foreign_fn(it.owner_id.def_id, sig.decl); + } } hir::ForeignItemKind::Static(ty, _, _) if !vis.is_internal_abi(abi) => { vis.check_foreign_static(it.owner_id, ty.span); } - hir::ForeignItemKind::Fn(decl, _, _, _) => vis.check_fn(it.owner_id.def_id, decl), hir::ForeignItemKind::Static(..) | hir::ForeignItemKind::Type => (), } } diff --git a/compiler/rustc_middle/src/hir/map/mod.rs b/compiler/rustc_middle/src/hir/map/mod.rs index edab6b5ebde8..ce489099ed2a 100644 --- a/compiler/rustc_middle/src/hir/map/mod.rs +++ b/compiler/rustc_middle/src/hir/map/mod.rs @@ -826,6 +826,11 @@ impl<'hir> Map<'hir> { }) | Node::ImplItem(ImplItem { kind: ImplItemKind::Fn(sig, ..), span: outer_span, .. + }) + | Node::ForeignItem(ForeignItem { + kind: ForeignItemKind::Fn(sig, ..), + span: outer_span, + .. }) => { // Ensure that the returned span has the item's SyntaxContext, and not the // SyntaxContext of the visibility. @@ -884,10 +889,7 @@ impl<'hir> Map<'hir> { }, Node::Variant(variant) => named_span(variant.span, variant.ident, None), Node::ImplItem(item) => named_span(item.span, item.ident, Some(item.generics)), - Node::ForeignItem(item) => match item.kind { - ForeignItemKind::Fn(decl, _, _, _) => until_within(item.span, decl.output.span()), - _ => named_span(item.span, item.ident, None), - }, + Node::ForeignItem(item) => named_span(item.span, item.ident, None), Node::Ctor(_) => return self.span(self.tcx.parent_hir_id(hir_id)), Node::Expr(Expr { kind: ExprKind::Closure(Closure { fn_decl_span, .. }), diff --git a/compiler/rustc_middle/src/hir/mod.rs b/compiler/rustc_middle/src/hir/mod.rs index fa521ab9f2fa..596d9f077372 100644 --- a/compiler/rustc_middle/src/hir/mod.rs +++ b/compiler/rustc_middle/src/hir/mod.rs @@ -202,7 +202,7 @@ pub fn provide(providers: &mut Providers) { .. }) | Node::ForeignItem(&ForeignItem { - kind: ForeignItemKind::Fn(_, idents, _, _), + kind: ForeignItemKind::Fn(_, idents, _), .. }) = tcx.hir_node(tcx.local_def_id_to_hir_id(def_id)) { diff --git a/tests/ui/extern/extern-main-issue-86110.stderr b/tests/ui/extern/extern-main-issue-86110.stderr index 8a3262fbcc7b..d69f4e617680 100644 --- a/tests/ui/extern/extern-main-issue-86110.stderr +++ b/tests/ui/extern/extern-main-issue-86110.stderr @@ -2,7 +2,7 @@ error: the `main` function cannot be declared in an `extern` block --> $DIR/extern-main-issue-86110.rs:4:5 | LL | fn main(); - | ^^^^^^^^^ + | ^^^^^^^^^^ error: aborting due to 1 previous error diff --git a/tests/ui/intrinsics/safe-intrinsic-mismatch.effects.stderr b/tests/ui/intrinsics/safe-intrinsic-mismatch.effects.stderr index d9a4960feec4..55983a445a4c 100644 --- a/tests/ui/intrinsics/safe-intrinsic-mismatch.effects.stderr +++ b/tests/ui/intrinsics/safe-intrinsic-mismatch.effects.stderr @@ -7,13 +7,13 @@ error: intrinsic safety mismatch between list of intrinsics within the compiler --> $DIR/safe-intrinsic-mismatch.rs:11:5 | LL | fn size_of() -> usize; - | ^^^^^^^^^^^^^^^^^^^^^^^^ + | ^^^^^^^^^^^^^^^^^^^^^^^^^ error: intrinsic safety mismatch between list of intrinsics within the compiler and core library intrinsics for intrinsic `size_of` --> $DIR/safe-intrinsic-mismatch.rs:11:5 | LL | fn size_of() -> usize; - | ^^^^^^^^^^^^^^^^^^^^^^^^ + | ^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no` diff --git a/tests/ui/intrinsics/safe-intrinsic-mismatch.stock.stderr b/tests/ui/intrinsics/safe-intrinsic-mismatch.stock.stderr index 6864c0f36ded..c59e357b2752 100644 --- a/tests/ui/intrinsics/safe-intrinsic-mismatch.stock.stderr +++ b/tests/ui/intrinsics/safe-intrinsic-mismatch.stock.stderr @@ -2,13 +2,13 @@ error: intrinsic safety mismatch between list of intrinsics within the compiler --> $DIR/safe-intrinsic-mismatch.rs:11:5 | LL | fn size_of() -> usize; - | ^^^^^^^^^^^^^^^^^^^^^^^^ + | ^^^^^^^^^^^^^^^^^^^^^^^^^ error: intrinsic safety mismatch between list of intrinsics within the compiler and core library intrinsics for intrinsic `size_of` --> $DIR/safe-intrinsic-mismatch.rs:11:5 | LL | fn size_of() -> usize; - | ^^^^^^^^^^^^^^^^^^^^^^^^ + | ^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no` diff --git a/tests/ui/issues/issue-16725.stderr b/tests/ui/issues/issue-16725.stderr index a4a406b3d4ba..dcb7d58b0f96 100644 --- a/tests/ui/issues/issue-16725.stderr +++ b/tests/ui/issues/issue-16725.stderr @@ -8,7 +8,7 @@ note: the function `bar` is defined here --> $DIR/auxiliary/issue-16725.rs:2:5 | LL | fn bar(); - | ^^^^^^^^ + | ^^^^^^^^^ error: aborting due to 1 previous error diff --git a/tests/ui/lint/clashing-extern-fn.stderr b/tests/ui/lint/clashing-extern-fn.stderr index 43c8cdead9f4..f75ff6d05a15 100644 --- a/tests/ui/lint/clashing-extern-fn.stderr +++ b/tests/ui/lint/clashing-extern-fn.stderr @@ -21,10 +21,10 @@ warning: `clash` redeclared with a different signature --> $DIR/clashing-extern-fn.rs:14:13 | LL | fn clash(x: u8); - | --------------- `clash` previously declared here + | ---------------- `clash` previously declared here ... LL | fn clash(x: u64); - | ^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration + | ^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration | = note: expected `unsafe extern "C" fn(u8)` found `unsafe extern "C" fn(u64)` @@ -41,7 +41,7 @@ LL | #[link_name = "extern_link_name"] | --------------------------------- `extern_link_name` previously declared here ... LL | fn extern_link_name(x: u32); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration | = note: expected `unsafe extern "C" fn(i16)` found `unsafe extern "C" fn(u32)` @@ -50,7 +50,7 @@ warning: `some_other_extern_link_name` redeclares `some_other_new_name` with a d --> $DIR/clashing-extern-fn.rs:55:9 | LL | fn some_other_new_name(x: i16); - | ------------------------------ `some_other_new_name` previously declared here + | ------------------------------- `some_other_new_name` previously declared here ... LL | #[link_name = "some_other_new_name"] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration @@ -74,10 +74,10 @@ warning: `different_mod` redeclared with a different signature --> $DIR/clashing-extern-fn.rs:72:9 | LL | fn different_mod(x: u8); - | ----------------------- `different_mod` previously declared here + | ------------------------ `different_mod` previously declared here ... LL | fn different_mod(x: u64); - | ^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration + | ^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration | = note: expected `unsafe extern "C" fn(u8)` found `unsafe extern "C" fn(u64)` @@ -86,10 +86,10 @@ warning: `variadic_decl` redeclared with a different signature --> $DIR/clashing-extern-fn.rs:82:9 | LL | fn variadic_decl(x: u8, ...); - | ---------------------------- `variadic_decl` previously declared here + | ----------------------------- `variadic_decl` previously declared here ... LL | fn variadic_decl(x: u8); - | ^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration + | ^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration | = note: expected `unsafe extern "C" fn(u8, ...)` found `unsafe extern "C" fn(u8)` @@ -98,10 +98,10 @@ warning: `weigh_banana` redeclared with a different signature --> $DIR/clashing-extern-fn.rs:142:13 | LL | fn weigh_banana(count: *const Banana) -> u64; - | -------------------------------------------- `weigh_banana` previously declared here + | --------------------------------------------- `weigh_banana` previously declared here ... LL | fn weigh_banana(count: *const Banana) -> u64; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration | = note: expected `unsafe extern "C" fn(*const one::Banana) -> u64` found `unsafe extern "C" fn(*const three::Banana) -> u64` @@ -110,10 +110,10 @@ warning: `draw_point` redeclared with a different signature --> $DIR/clashing-extern-fn.rs:171:13 | LL | fn draw_point(p: Point); - | ----------------------- `draw_point` previously declared here + | ------------------------ `draw_point` previously declared here ... LL | fn draw_point(p: Point); - | ^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration + | ^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration | = note: expected `unsafe extern "C" fn(sameish_members::a::Point)` found `unsafe extern "C" fn(sameish_members::b::Point)` @@ -122,10 +122,10 @@ warning: `origin` redeclared with a different signature --> $DIR/clashing-extern-fn.rs:197:13 | LL | fn origin() -> Point3; - | --------------------- `origin` previously declared here + | ---------------------- `origin` previously declared here ... LL | fn origin() -> Point3; - | ^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration + | ^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration | = note: expected `unsafe extern "C" fn() -> same_sized_members_clash::a::Point3` found `unsafe extern "C" fn() -> same_sized_members_clash::b::Point3` @@ -134,10 +134,10 @@ warning: `transparent_incorrect` redeclared with a different signature --> $DIR/clashing-extern-fn.rs:220:13 | LL | fn transparent_incorrect() -> T; - | ------------------------------- `transparent_incorrect` previously declared here + | -------------------------------- `transparent_incorrect` previously declared here ... LL | fn transparent_incorrect() -> isize; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration | = note: expected `unsafe extern "C" fn() -> T` found `unsafe extern "C" fn() -> isize` @@ -146,10 +146,10 @@ warning: `missing_return_type` redeclared with a different signature --> $DIR/clashing-extern-fn.rs:259:13 | LL | fn missing_return_type() -> usize; - | --------------------------------- `missing_return_type` previously declared here + | ---------------------------------- `missing_return_type` previously declared here ... LL | fn missing_return_type(); - | ^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration + | ^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration | = note: expected `unsafe extern "C" fn() -> usize` found `unsafe extern "C" fn()` @@ -158,10 +158,10 @@ warning: `non_zero_usize` redeclared with a different signature --> $DIR/clashing-extern-fn.rs:277:13 | LL | fn non_zero_usize() -> core::num::NonZero; - | ------------------------------------------------ `non_zero_usize` previously declared here + | ------------------------------------------------- `non_zero_usize` previously declared here ... LL | fn non_zero_usize() -> usize; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration | = note: expected `unsafe extern "C" fn() -> NonZero` found `unsafe extern "C" fn() -> usize` @@ -170,10 +170,10 @@ warning: `non_null_ptr` redeclared with a different signature --> $DIR/clashing-extern-fn.rs:279:13 | LL | fn non_null_ptr() -> core::ptr::NonNull; - | ---------------------------------------------- `non_null_ptr` previously declared here + | ----------------------------------------------- `non_null_ptr` previously declared here ... LL | fn non_null_ptr() -> *const usize; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration | = note: expected `unsafe extern "C" fn() -> NonNull` found `unsafe extern "C" fn() -> *const usize` @@ -182,10 +182,10 @@ warning: `option_non_zero_usize_incorrect` redeclared with a different signature --> $DIR/clashing-extern-fn.rs:373:13 | LL | fn option_non_zero_usize_incorrect() -> usize; - | --------------------------------------------- `option_non_zero_usize_incorrect` previously declared here + | ---------------------------------------------- `option_non_zero_usize_incorrect` previously declared here ... LL | fn option_non_zero_usize_incorrect() -> isize; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration | = note: expected `unsafe extern "C" fn() -> usize` found `unsafe extern "C" fn() -> isize` @@ -194,10 +194,10 @@ warning: `option_non_null_ptr_incorrect` redeclared with a different signature --> $DIR/clashing-extern-fn.rs:375:13 | LL | fn option_non_null_ptr_incorrect() -> *const usize; - | -------------------------------------------------- `option_non_null_ptr_incorrect` previously declared here + | --------------------------------------------------- `option_non_null_ptr_incorrect` previously declared here ... LL | fn option_non_null_ptr_incorrect() -> *const isize; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration | = note: expected `unsafe extern "C" fn() -> *const usize` found `unsafe extern "C" fn() -> *const isize` @@ -206,10 +206,10 @@ warning: `hidden_niche_transparent_no_niche` redeclared with a different signatu --> $DIR/clashing-extern-fn.rs:429:13 | LL | fn hidden_niche_transparent_no_niche() -> usize; - | ----------------------------------------------- `hidden_niche_transparent_no_niche` previously declared here + | ------------------------------------------------ `hidden_niche_transparent_no_niche` previously declared here ... LL | fn hidden_niche_transparent_no_niche() -> Option; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration | = note: expected `unsafe extern "C" fn() -> usize` found `unsafe extern "C" fn() -> Option` @@ -218,10 +218,10 @@ warning: `hidden_niche_unsafe_cell` redeclared with a different signature --> $DIR/clashing-extern-fn.rs:433:13 | LL | fn hidden_niche_unsafe_cell() -> usize; - | -------------------------------------- `hidden_niche_unsafe_cell` previously declared here + | --------------------------------------- `hidden_niche_unsafe_cell` previously declared here ... LL | fn hidden_niche_unsafe_cell() -> Option>>; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration | = note: expected `unsafe extern "C" fn() -> usize` found `unsafe extern "C" fn() -> Option>>` diff --git a/tests/ui/lint/issue-1866.stderr b/tests/ui/lint/issue-1866.stderr index 36d323825a4d..d19a13496683 100644 --- a/tests/ui/lint/issue-1866.stderr +++ b/tests/ui/lint/issue-1866.stderr @@ -2,10 +2,10 @@ warning: `rust_task_is_unwinding` redeclared with a different signature --> $DIR/issue-1866.rs:23:13 | LL | pub fn rust_task_is_unwinding(rt: *const rust_task) -> bool; - | ----------------------------------------------------------- `rust_task_is_unwinding` previously declared here + | ------------------------------------------------------------ `rust_task_is_unwinding` previously declared here ... LL | pub fn rust_task_is_unwinding(rt: *const rust_task) -> bool; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration | = note: expected `unsafe extern "C" fn(*const usize) -> bool` found `unsafe extern "C" fn(*const bool) -> bool` diff --git a/tests/ui/lint/lint-attr-everywhere-late.stderr b/tests/ui/lint/lint-attr-everywhere-late.stderr index ddc31905afbc..1937b618236b 100644 --- a/tests/ui/lint/lint-attr-everywhere-late.stderr +++ b/tests/ui/lint/lint-attr-everywhere-late.stderr @@ -406,10 +406,10 @@ error: `clashing1` redeclared with a different signature --> $DIR/lint-attr-everywhere-late.rs:123:5 | LL | fn clashing1(); - | -------------- `clashing1` previously declared here + | --------------- `clashing1` previously declared here ... LL | fn clashing1(_: i32); - | ^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration + | ^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration | = note: expected `unsafe extern "C" fn()` found `unsafe extern "C" fn(i32)` @@ -423,10 +423,10 @@ error: `clashing2` redeclared with a different signature --> $DIR/lint-attr-everywhere-late.rs:128:5 | LL | fn clashing2(); - | -------------- `clashing2` previously declared here + | --------------- `clashing2` previously declared here ... LL | fn clashing2(_: i32); - | ^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration + | ^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration | = note: expected `unsafe extern "C" fn()` found `unsafe extern "C" fn(i32)` diff --git a/tests/ui/lint/lint-missing-doc.stderr b/tests/ui/lint/lint-missing-doc.stderr index 4e9ee4f27696..5165ccc3fd06 100644 --- a/tests/ui/lint/lint-missing-doc.stderr +++ b/tests/ui/lint/lint-missing-doc.stderr @@ -116,7 +116,7 @@ error: missing documentation for a function --> $DIR/lint-missing-doc.rs:196:5 | LL | pub fn extern_fn_undocumented(f: f32) -> f32; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: missing documentation for a static --> $DIR/lint-missing-doc.rs:201:5 diff --git a/tests/ui/lint/unreachable_pub.stderr b/tests/ui/lint/unreachable_pub.stderr index 705a537a3f1c..65f45fbd8168 100644 --- a/tests/ui/lint/unreachable_pub.stderr +++ b/tests/ui/lint/unreachable_pub.stderr @@ -130,7 +130,7 @@ warning: unreachable `pub` item --> $DIR/unreachable_pub.rs:48:9 | LL | pub fn catalyze() -> bool; - | ---^^^^^^^^^^^^^^^^^^^^^^ + | ---^^^^^^^^^^^^^^^^^^^^^^^ | | | help: consider restricting its visibility: `pub(crate)` | diff --git a/tests/ui/privacy/private-in-public-warn.stderr b/tests/ui/privacy/private-in-public-warn.stderr index 3f7b8c281e70..3743879ffa61 100644 --- a/tests/ui/privacy/private-in-public-warn.stderr +++ b/tests/ui/privacy/private-in-public-warn.stderr @@ -100,7 +100,7 @@ error: type `types::Priv` is more private than the item `types::ef1` --> $DIR/private-in-public-warn.rs:28:9 | LL | pub fn ef1(arg: Priv); - | ^^^^^^^^^^^^^^^^^^^^^ function `types::ef1` is reachable at visibility `pub(crate)` + | ^^^^^^^^^^^^^^^^^^^^^^ function `types::ef1` is reachable at visibility `pub(crate)` | note: but type `types::Priv` is only usable at visibility `pub(self)` --> $DIR/private-in-public-warn.rs:9:5 @@ -112,7 +112,7 @@ error: type `types::Priv` is more private than the item `types::ef2` --> $DIR/private-in-public-warn.rs:29:9 | LL | pub fn ef2() -> Priv; - | ^^^^^^^^^^^^^^^^^^^^ function `types::ef2` is reachable at visibility `pub(crate)` + | ^^^^^^^^^^^^^^^^^^^^^ function `types::ef2` is reachable at visibility `pub(crate)` | note: but type `types::Priv` is only usable at visibility `pub(self)` --> $DIR/private-in-public-warn.rs:9:5 From d850f85055b1d46278e29be39d9b4b938e90f199 Mon Sep 17 00:00:00 2001 From: Michael Goulet Date: Wed, 7 Aug 2024 13:08:24 -0400 Subject: [PATCH 25/79] Don't ICE on Fn trait error for foreign fn --- .../traits/fulfillment_errors.rs | 4 ++ .../foreign/foreign-safe-fn-arg-mismatch.rs | 13 ++++++ .../foreign-safe-fn-arg-mismatch.stderr | 44 +++++++++++++++++++ 3 files changed, 61 insertions(+) create mode 100644 tests/ui/foreign/foreign-safe-fn-arg-mismatch.rs create mode 100644 tests/ui/foreign/foreign-safe-fn-arg-mismatch.stderr diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs index 326a0e4e35ce..79ba9840130e 100644 --- a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs +++ b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs @@ -2729,6 +2729,10 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> { | Node::ImplItem(&hir::ImplItem { kind: hir::ImplItemKind::Fn(ref sig, _), .. }) | Node::TraitItem(&hir::TraitItem { kind: hir::TraitItemKind::Fn(ref sig, _), .. + }) + | Node::ForeignItem(&hir::ForeignItem { + kind: hir::ForeignItemKind::Fn(ref sig, _, _), + .. }) => ( sig.span, None, diff --git a/tests/ui/foreign/foreign-safe-fn-arg-mismatch.rs b/tests/ui/foreign/foreign-safe-fn-arg-mismatch.rs new file mode 100644 index 000000000000..bb1052b15e9d --- /dev/null +++ b/tests/ui/foreign/foreign-safe-fn-arg-mismatch.rs @@ -0,0 +1,13 @@ +// Make sure we don't ICE when a foreign fn doesn't implement `Fn` due to arg mismatch. + +unsafe extern "Rust" { + pub safe fn foo(); + pub safe fn bar(x: u32); +} + +fn test(_: impl Fn(i32)) {} + +fn main() { + test(foo); //~ ERROR function is expected to take 1 argument, but it takes 0 arguments + test(bar); //~ ERROR type mismatch in function arguments +} diff --git a/tests/ui/foreign/foreign-safe-fn-arg-mismatch.stderr b/tests/ui/foreign/foreign-safe-fn-arg-mismatch.stderr new file mode 100644 index 000000000000..73ccecff5ab8 --- /dev/null +++ b/tests/ui/foreign/foreign-safe-fn-arg-mismatch.stderr @@ -0,0 +1,44 @@ +error[E0593]: function is expected to take 1 argument, but it takes 0 arguments + --> $DIR/foreign-safe-fn-arg-mismatch.rs:11:10 + | +LL | pub safe fn foo(); + | ------------------ takes 0 arguments +... +LL | test(foo); + | ---- ^^^ expected function that takes 1 argument + | | + | required by a bound introduced by this call + | +note: required by a bound in `test` + --> $DIR/foreign-safe-fn-arg-mismatch.rs:8:17 + | +LL | fn test(_: impl Fn(i32)) {} + | ^^^^^^^ required by this bound in `test` + +error[E0631]: type mismatch in function arguments + --> $DIR/foreign-safe-fn-arg-mismatch.rs:12:10 + | +LL | pub safe fn bar(x: u32); + | ------------------------ found signature defined here +... +LL | test(bar); + | ---- ^^^ expected due to this + | | + | required by a bound introduced by this call + | + = note: expected function signature `fn(i32) -> _` + found function signature `fn(u32) -> _` +note: required by a bound in `test` + --> $DIR/foreign-safe-fn-arg-mismatch.rs:8:17 + | +LL | fn test(_: impl Fn(i32)) {} + | ^^^^^^^ required by this bound in `test` +help: consider wrapping the function in a closure + | +LL | test(|arg0: i32| bar(/* u32 */)); + | +++++++++++ +++++++++++ + +error: aborting due to 2 previous errors + +Some errors have detailed explanations: E0593, E0631. +For more information about an error, try `rustc --explain E0593`. From 84633f47f671f6c084d83070c6dc97d812de1758 Mon Sep 17 00:00:00 2001 From: Michael Goulet Date: Wed, 7 Aug 2024 13:35:21 -0400 Subject: [PATCH 26/79] Simplify cleaning foreign fns in rustdoc --- src/librustdoc/clean/mod.rs | 14 ++++---------- .../multiple-declarations.stderr | 2 +- .../rfcs/rfc-2627-raw-dylib/unsupported-abi.stderr | 2 +- 3 files changed, 6 insertions(+), 12 deletions(-) diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 53757349a9b2..db81b4c4282a 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -3094,16 +3094,10 @@ fn clean_maybe_renamed_foreign_item<'tcx>( let def_id = item.owner_id.to_def_id(); cx.with_param_env(def_id, |cx| { let kind = match item.kind { - hir::ForeignItemKind::Fn(decl, names, generics, safety) => { - let (generics, decl) = enter_impl_trait(cx, |cx| { - // NOTE: generics must be cleaned before args - let generics = clean_generics(generics, cx); - let args = clean_args_from_types_and_names(cx, decl.inputs, names); - let decl = clean_fn_decl_with_args(cx, decl, None, args); - (generics, decl) - }); - ForeignFunctionItem(Box::new(Function { decl, generics }), safety) - } + hir::ForeignItemKind::Fn(sig, names, generics) => ForeignFunctionItem( + clean_function(cx, &sig, generics, FunctionArgs::Names(names)), + sig.header.safety, + ), hir::ForeignItemKind::Static(ty, mutability, safety) => ForeignStaticItem( Static { type_: Box::new(clean_ty(ty, cx)), mutability, expr: None }, safety, diff --git a/tests/ui/rfcs/rfc-2627-raw-dylib/multiple-declarations.stderr b/tests/ui/rfcs/rfc-2627-raw-dylib/multiple-declarations.stderr index 7866af594449..b766b5c8dd83 100644 --- a/tests/ui/rfcs/rfc-2627-raw-dylib/multiple-declarations.stderr +++ b/tests/ui/rfcs/rfc-2627-raw-dylib/multiple-declarations.stderr @@ -2,7 +2,7 @@ error: multiple declarations of external function `f` from library `foo.dll` hav --> $DIR/multiple-declarations.rs:13:9 | LL | fn f(x: i32); - | ^^^^^^^^^^^^ + | ^^^^^^^^^^^^^ error: aborting due to 1 previous error diff --git a/tests/ui/rfcs/rfc-2627-raw-dylib/unsupported-abi.stderr b/tests/ui/rfcs/rfc-2627-raw-dylib/unsupported-abi.stderr index d7c7344b596d..ef022404e7f6 100644 --- a/tests/ui/rfcs/rfc-2627-raw-dylib/unsupported-abi.stderr +++ b/tests/ui/rfcs/rfc-2627-raw-dylib/unsupported-abi.stderr @@ -2,7 +2,7 @@ error: ABI not supported by `#[link(kind = "raw-dylib")]` on this architecture --> $DIR/unsupported-abi.rs:6:5 | LL | fn f(x: i32); - | ^^^^^^^^^^^^ + | ^^^^^^^^^^^^^ error: aborting due to 1 previous error From 29017e45a1c85afe457765a5d4c77e4fcdebb4f6 Mon Sep 17 00:00:00 2001 From: Josh Stone Date: Fri, 16 Aug 2024 12:42:02 -0700 Subject: [PATCH 27/79] mir/pretty: use `Option` instead of `Either` `Either` is wasteful for a one-or-none iterator, especially since `Once` is already an `option::IntoIter` internally. We don't really need any of the iterator mechanisms in this case, just a single conditional insert. --- compiler/rustc_middle/src/mir/pretty.rs | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/compiler/rustc_middle/src/mir/pretty.rs b/compiler/rustc_middle/src/mir/pretty.rs index f2d878141309..5dd0e69cf1fe 100644 --- a/compiler/rustc_middle/src/mir/pretty.rs +++ b/compiler/rustc_middle/src/mir/pretty.rs @@ -1418,21 +1418,19 @@ pub fn write_allocations<'tcx>( alloc.inner().provenance().ptrs().values().map(|p| p.alloc_id()) } - fn alloc_ids_from_const_val(val: ConstValue<'_>) -> impl Iterator + '_ { + fn alloc_id_from_const_val(val: ConstValue<'_>) -> Option { match val { - ConstValue::Scalar(interpret::Scalar::Ptr(ptr, _)) => { - Either::Left(std::iter::once(ptr.provenance.alloc_id())) - } - ConstValue::Scalar(interpret::Scalar::Int { .. }) => Either::Right(std::iter::empty()), - ConstValue::ZeroSized => Either::Right(std::iter::empty()), + ConstValue::Scalar(interpret::Scalar::Ptr(ptr, _)) => Some(ptr.provenance.alloc_id()), + ConstValue::Scalar(interpret::Scalar::Int { .. }) => None, + ConstValue::ZeroSized => None, ConstValue::Slice { .. } => { // `u8`/`str` slices, shouldn't contain pointers that we want to print. - Either::Right(std::iter::empty()) + None } ConstValue::Indirect { alloc_id, .. } => { // FIXME: we don't actually want to print all of these, since some are printed nicely directly as values inline in MIR. // Really we'd want `pretty_print_const_value` to decide which allocations to print, instead of having a separate visitor. - Either::Left(std::iter::once(alloc_id)) + Some(alloc_id) } } } @@ -1443,7 +1441,9 @@ pub fn write_allocations<'tcx>( match c.const_ { Const::Ty(_, _) | Const::Unevaluated(..) => {} Const::Val(val, _) => { - self.0.extend(alloc_ids_from_const_val(val)); + if let Some(id) = alloc_id_from_const_val(val) { + self.0.insert(id); + } } } } From ed6315b3fef4ebd9aee053d407eb746c3b1d58bf Mon Sep 17 00:00:00 2001 From: Boxy Date: Fri, 16 Aug 2024 20:53:02 +0100 Subject: [PATCH 28/79] Rewrite `get_fn_id_for_return_block` --- compiler/rustc_middle/src/hir/map/mod.rs | 64 +++++----- tests/crashes/128810.rs | 25 ---- ..._body_owner_parent_found_in_diagnostics.rs | 34 ++++++ ...y_owner_parent_found_in_diagnostics.stderr | 113 ++++++++++++++++++ tests/ui/typeck/const-in-fn-call-generics.rs | 16 +++ .../typeck/const-in-fn-call-generics.stderr | 9 ++ 6 files changed, 199 insertions(+), 62 deletions(-) delete mode 100644 tests/crashes/128810.rs create mode 100644 tests/ui/delegation/correct_body_owner_parent_found_in_diagnostics.rs create mode 100644 tests/ui/delegation/correct_body_owner_parent_found_in_diagnostics.stderr create mode 100644 tests/ui/typeck/const-in-fn-call-generics.rs create mode 100644 tests/ui/typeck/const-in-fn-call-generics.stderr diff --git a/compiler/rustc_middle/src/hir/map/mod.rs b/compiler/rustc_middle/src/hir/map/mod.rs index edab6b5ebde8..da08027d66b1 100644 --- a/compiler/rustc_middle/src/hir/map/mod.rs +++ b/compiler/rustc_middle/src/hir/map/mod.rs @@ -554,53 +554,43 @@ impl<'hir> Map<'hir> { /// } /// ``` pub fn get_fn_id_for_return_block(self, id: HirId) -> Option { - let mut iter = self.parent_iter(id).peekable(); - let mut ignore_tail = false; - if let Node::Expr(Expr { kind: ExprKind::Ret(_), .. }) = self.tcx.hir_node(id) { - // When dealing with `return` statements, we don't care about climbing only tail - // expressions. - ignore_tail = true; - } + let enclosing_body_owner = self.tcx.local_def_id_to_hir_id(self.enclosing_body_owner(id)); - let mut prev_hir_id = None; - while let Some((hir_id, node)) = iter.next() { - if let (Some((_, next_node)), false) = (iter.peek(), ignore_tail) { - match next_node { - Node::Block(Block { expr: None, .. }) => return None, - // The current node is not the tail expression of its parent. - Node::Block(Block { expr: Some(e), .. }) if hir_id != e.hir_id => return None, + // Return `None` if the `id` expression is not the returned value of the enclosing body + let mut iter = [id].into_iter().chain(self.parent_id_iter(id)).peekable(); + while let Some(cur_id) = iter.next() { + if enclosing_body_owner == cur_id { + break; + } + + // A return statement is always the value returned from the enclosing body regardless of + // what the parent expressions are. + if let Node::Expr(Expr { kind: ExprKind::Ret(_), .. }) = self.tcx.hir_node(cur_id) { + break; + } + + // If the current expression's value doesnt get used as the parent expressions value then return `None` + if let Some(&parent_id) = iter.peek() { + match self.tcx.hir_node(parent_id) { + // The current node is not the tail expression of the block expression parent expr. + Node::Block(Block { expr: Some(e), .. }) if cur_id != e.hir_id => return None, Node::Block(Block { expr: Some(e), .. }) if matches!(e.kind, ExprKind::If(_, _, None)) => { return None; } + + // The current expression's value does not pass up through these parent expressions + Node::Block(Block { expr: None, .. }) + | Node::Expr(Expr { kind: ExprKind::Loop(..), .. }) + | Node::LetStmt(..) => return None, + _ => {} } } - match node { - Node::Item(_) - | Node::ForeignItem(_) - | Node::TraitItem(_) - | Node::Expr(Expr { kind: ExprKind::Closure(_), .. }) - | Node::ImplItem(_) - // The input node `id` must be enclosed in the method's body as opposed - // to some other place such as its return type (fixes #114918). - // We verify that indirectly by checking that the previous node is the - // current node's body - if node.body_id().map(|b| b.hir_id) == prev_hir_id => { - return Some(hir_id) - } - // Ignore `return`s on the first iteration - Node::Expr(Expr { kind: ExprKind::Loop(..) | ExprKind::Ret(..), .. }) - | Node::LetStmt(_) => { - return None; - } - _ => {} - } - - prev_hir_id = Some(hir_id); } - None + + Some(enclosing_body_owner) } /// Retrieves the `OwnerId` for `id`'s parent item, or `id` itself if no diff --git a/tests/crashes/128810.rs b/tests/crashes/128810.rs deleted file mode 100644 index 68214ff010c9..000000000000 --- a/tests/crashes/128810.rs +++ /dev/null @@ -1,25 +0,0 @@ -//@ known-bug: rust-lang/rust#128810 - -#![feature(fn_delegation)] - -use std::marker::PhantomData; - -pub struct InvariantRef<'a, T: ?Sized>(&'a T, PhantomData<&'a mut &'a T>); - -impl<'a> InvariantRef<'a, ()> { - pub const NEW: Self = InvariantRef::new(&()); -} - -trait Trait { - fn foo(&self) -> u8 { 0 } - fn bar(&self) -> u8 { 1 } - fn meh(&self) -> u8 { 2 } -} - -struct Z(u8); - -impl Trait for Z { - reuse ::{foo, bar, meh} { &const { InvariantRef::<'a>::NEW } } -} - -fn main() { } diff --git a/tests/ui/delegation/correct_body_owner_parent_found_in_diagnostics.rs b/tests/ui/delegation/correct_body_owner_parent_found_in_diagnostics.rs new file mode 100644 index 000000000000..0a7ec5ab5c1b --- /dev/null +++ b/tests/ui/delegation/correct_body_owner_parent_found_in_diagnostics.rs @@ -0,0 +1,34 @@ +#![feature(fn_delegation)] +#![allow(incomplete_features)] + +use std::marker::PhantomData; + +pub struct InvariantRef<'a, T: ?Sized>(&'a T, PhantomData<&'a mut &'a T>); + +impl<'a> InvariantRef<'a, ()> { + pub const NEW: Self = InvariantRef::new(&()); + //~^ ERROR: no function or associated item named `new` found +} + +trait Trait { + fn foo(&self) -> u8 { 0 } + fn bar(&self) -> u8 { 1 } + fn meh(&self) -> u8 { 2 } +} + +struct Z(u8); + +impl Trait for Z { + reuse ::{foo, bar, meh} { &const { InvariantRef::<'a>::NEW } } + //~^ ERROR: use of undeclared lifetime name `'a` + //~| ERROR: use of undeclared lifetime name `'a` + //~| ERROR: use of undeclared lifetime name `'a` + //~| ERROR: the trait bound `u8: Trait` is not satisfied + //~| ERROR: the trait bound `u8: Trait` is not satisfied + //~| ERROR: the trait bound `u8: Trait` is not satisfied + //~| ERROR: mismatched types + //~| ERROR: mismatched types + //~| ERROR: mismatched types +} + +fn main() { } diff --git a/tests/ui/delegation/correct_body_owner_parent_found_in_diagnostics.stderr b/tests/ui/delegation/correct_body_owner_parent_found_in_diagnostics.stderr new file mode 100644 index 000000000000..2ce3b388073c --- /dev/null +++ b/tests/ui/delegation/correct_body_owner_parent_found_in_diagnostics.stderr @@ -0,0 +1,113 @@ +error[E0261]: use of undeclared lifetime name `'a` + --> $DIR/correct_body_owner_parent_found_in_diagnostics.rs:22:68 + | +LL | reuse ::{foo, bar, meh} { &const { InvariantRef::<'a>::NEW } } + | ^^ undeclared lifetime + | +help: consider introducing lifetime `'a` here + | +LL | reuse ::{foo'a, , bar, meh} { &const { InvariantRef::<'a>::NEW } } + | +++ +help: consider introducing lifetime `'a` here + | +LL | impl<'a> Trait for Z { + | ++++ + +error[E0261]: use of undeclared lifetime name `'a` + --> $DIR/correct_body_owner_parent_found_in_diagnostics.rs:22:68 + | +LL | reuse ::{foo, bar, meh} { &const { InvariantRef::<'a>::NEW } } + | ^^ undeclared lifetime + | +help: consider introducing lifetime `'a` here + | +LL | reuse ::{foo, bar'a, , meh} { &const { InvariantRef::<'a>::NEW } } + | +++ +help: consider introducing lifetime `'a` here + | +LL | impl<'a> Trait for Z { + | ++++ + +error[E0261]: use of undeclared lifetime name `'a` + --> $DIR/correct_body_owner_parent_found_in_diagnostics.rs:22:68 + | +LL | reuse ::{foo, bar, meh} { &const { InvariantRef::<'a>::NEW } } + | ^^ undeclared lifetime + | +help: consider introducing lifetime `'a` here + | +LL | reuse ::{foo, bar, meh'a, } { &const { InvariantRef::<'a>::NEW } } + | +++ +help: consider introducing lifetime `'a` here + | +LL | impl<'a> Trait for Z { + | ++++ + +error[E0599]: no function or associated item named `new` found for struct `InvariantRef` in the current scope + --> $DIR/correct_body_owner_parent_found_in_diagnostics.rs:9:41 + | +LL | pub struct InvariantRef<'a, T: ?Sized>(&'a T, PhantomData<&'a mut &'a T>); + | -------------------------------------- function or associated item `new` not found for this struct +... +LL | pub const NEW: Self = InvariantRef::new(&()); + | ^^^ function or associated item not found in `InvariantRef<'_, _>` + +error[E0308]: mismatched types + --> $DIR/correct_body_owner_parent_found_in_diagnostics.rs:22:53 + | +LL | reuse ::{foo, bar, meh} { &const { InvariantRef::<'a>::NEW } } + | ^^^^^^^^^^^^^^^^^^^^^^^ expected `u8`, found `InvariantRef<'_, ()>` + | + = note: expected type `u8` + found struct `InvariantRef<'_, ()>` + +error[E0277]: the trait bound `u8: Trait` is not satisfied + --> $DIR/correct_body_owner_parent_found_in_diagnostics.rs:22:12 + | +LL | reuse ::{foo, bar, meh} { &const { InvariantRef::<'a>::NEW } } + | ^^ the trait `Trait` is not implemented for `u8` + | + = help: the trait `Trait` is implemented for `Z` + +error[E0308]: mismatched types + --> $DIR/correct_body_owner_parent_found_in_diagnostics.rs:22:53 + | +LL | reuse ::{foo, bar, meh} { &const { InvariantRef::<'a>::NEW } } + | ^^^^^^^^^^^^^^^^^^^^^^^ expected `u8`, found `InvariantRef<'_, ()>` + | + = note: expected type `u8` + found struct `InvariantRef<'_, ()>` + = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no` + +error[E0277]: the trait bound `u8: Trait` is not satisfied + --> $DIR/correct_body_owner_parent_found_in_diagnostics.rs:22:12 + | +LL | reuse ::{foo, bar, meh} { &const { InvariantRef::<'a>::NEW } } + | ^^ the trait `Trait` is not implemented for `u8` + | + = help: the trait `Trait` is implemented for `Z` + = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no` + +error[E0308]: mismatched types + --> $DIR/correct_body_owner_parent_found_in_diagnostics.rs:22:53 + | +LL | reuse ::{foo, bar, meh} { &const { InvariantRef::<'a>::NEW } } + | ^^^^^^^^^^^^^^^^^^^^^^^ expected `u8`, found `InvariantRef<'_, ()>` + | + = note: expected type `u8` + found struct `InvariantRef<'_, ()>` + = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no` + +error[E0277]: the trait bound `u8: Trait` is not satisfied + --> $DIR/correct_body_owner_parent_found_in_diagnostics.rs:22:12 + | +LL | reuse ::{foo, bar, meh} { &const { InvariantRef::<'a>::NEW } } + | ^^ the trait `Trait` is not implemented for `u8` + | + = help: the trait `Trait` is implemented for `Z` + = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no` + +error: aborting due to 10 previous errors + +Some errors have detailed explanations: E0261, E0277, E0308, E0599. +For more information about an error, try `rustc --explain E0261`. diff --git a/tests/ui/typeck/const-in-fn-call-generics.rs b/tests/ui/typeck/const-in-fn-call-generics.rs new file mode 100644 index 000000000000..675dbcc30547 --- /dev/null +++ b/tests/ui/typeck/const-in-fn-call-generics.rs @@ -0,0 +1,16 @@ +fn generic() {} + +trait Collate { + type Pass; + fn collate(self) -> Self::Pass; +} + +impl Collate for i32 { + type Pass = (); + fn collate(self) -> Self::Pass { + generic::<{ true }>() + //~^ ERROR: mismatched types + } +} + +fn main() {} diff --git a/tests/ui/typeck/const-in-fn-call-generics.stderr b/tests/ui/typeck/const-in-fn-call-generics.stderr new file mode 100644 index 000000000000..12dd454188ca --- /dev/null +++ b/tests/ui/typeck/const-in-fn-call-generics.stderr @@ -0,0 +1,9 @@ +error[E0308]: mismatched types + --> $DIR/const-in-fn-call-generics.rs:11:21 + | +LL | generic::<{ true }>() + | ^^^^ expected `u32`, found `bool` + +error: aborting due to 1 previous error + +For more information about this error, try `rustc --explain E0308`. From 9bc7cea412b31be0faf1fc1e65f39b9b952a43e6 Mon Sep 17 00:00:00 2001 From: beetrees Date: Fri, 16 Aug 2024 23:42:10 +0100 Subject: [PATCH 29/79] Fix `is_val_statically_known` for floats --- compiler/rustc_codegen_llvm/src/context.rs | 2 + compiler/rustc_codegen_llvm/src/intrinsic.rs | 22 ++++-- tests/codegen/is_val_statically_known.rs | 81 +++++++++++++++++++- 3 files changed, 96 insertions(+), 9 deletions(-) diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs index dd3f39eceadb..1fd9f9e81167 100644 --- a/compiler/rustc_codegen_llvm/src/context.rs +++ b/compiler/rustc_codegen_llvm/src/context.rs @@ -1000,8 +1000,10 @@ impl<'ll> CodegenCx<'ll, '_> { ifn!("llvm.is.constant.i64", fn(t_i64) -> i1); ifn!("llvm.is.constant.i128", fn(t_i128) -> i1); ifn!("llvm.is.constant.isize", fn(t_isize) -> i1); + ifn!("llvm.is.constant.f16", fn(t_f16) -> i1); ifn!("llvm.is.constant.f32", fn(t_f32) -> i1); ifn!("llvm.is.constant.f64", fn(t_f64) -> i1); + ifn!("llvm.is.constant.f128", fn(t_f128) -> i1); ifn!("llvm.is.constant.ptr", fn(ptr) -> i1); ifn!("llvm.expect.i1", fn(i1, i1) -> i1); diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs index f5558723d11b..abfe38d4c0cc 100644 --- a/compiler/rustc_codegen_llvm/src/intrinsic.rs +++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs @@ -192,14 +192,22 @@ impl<'ll, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'_, 'll, 'tcx> { } sym::is_val_statically_known => { let intrinsic_type = args[0].layout.immediate_llvm_type(self.cx); - match self.type_kind(intrinsic_type) { - TypeKind::Pointer | TypeKind::Integer | TypeKind::Float | TypeKind::Double => { - self.call_intrinsic( - &format!("llvm.is.constant.{:?}", intrinsic_type), - &[args[0].immediate()], - ) + let kind = self.type_kind(intrinsic_type); + let intrinsic_name = match kind { + TypeKind::Pointer | TypeKind::Integer => { + Some(format!("llvm.is.constant.{intrinsic_type:?}")) } - _ => self.const_bool(false), + // LLVM float types' intrinsic names differ from their type names. + TypeKind::Half => Some(format!("llvm.is.constant.f16")), + TypeKind::Float => Some(format!("llvm.is.constant.f32")), + TypeKind::Double => Some(format!("llvm.is.constant.f64")), + TypeKind::FP128 => Some(format!("llvm.is.constant.f128")), + _ => None, + }; + if let Some(intrinsic_name) = intrinsic_name { + self.call_intrinsic(&intrinsic_name, &[args[0].immediate()]) + } else { + self.const_bool(false) } } sym::unlikely => self diff --git a/tests/codegen/is_val_statically_known.rs b/tests/codegen/is_val_statically_known.rs index 6af4f353a481..fe432d3bcc4d 100644 --- a/tests/codegen/is_val_statically_known.rs +++ b/tests/codegen/is_val_statically_known.rs @@ -1,6 +1,7 @@ //@ compile-flags: --crate-type=lib -Zmerge-functions=disabled -O #![feature(core_intrinsics)] +#![feature(f16, f128)] use std::intrinsics::is_val_statically_known; @@ -49,7 +50,7 @@ pub fn _bool_false(b: bool) -> i32 { #[inline] pub fn _iref(a: &u8) -> i32 { - if unsafe { is_val_statically_known(a) } { 5 } else { 4 } + if is_val_statically_known(a) { 5 } else { 4 } } // CHECK-LABEL: @_iref_borrow( @@ -68,7 +69,7 @@ pub fn _iref_arg(a: &u8) -> i32 { #[inline] pub fn _slice_ref(a: &[u8]) -> i32 { - if unsafe { is_val_statically_known(a) } { 7 } else { 6 } + if is_val_statically_known(a) { 7 } else { 6 } } // CHECK-LABEL: @_slice_ref_borrow( @@ -84,3 +85,79 @@ pub fn _slice_ref_arg(a: &[u8]) -> i32 { // CHECK: ret i32 6 _slice_ref(a) } + +#[inline] +pub fn _f16(a: f16) -> i32 { + if is_val_statically_known(a) { 1 } else { 0 } +} + +// CHECK-LABEL: @_f16_true( +#[no_mangle] +pub fn _f16_true() -> i32 { + // CHECK: ret i32 1 + _f16(1.0) +} + +// CHECK-LABEL: @_f16_false( +#[no_mangle] +pub fn _f16_false(a: f16) -> i32 { + // CHECK: ret i32 0 + _f16(a) +} + +#[inline] +pub fn _f32(a: f32) -> i32 { + if is_val_statically_known(a) { 1 } else { 0 } +} + +// CHECK-LABEL: @_f32_true( +#[no_mangle] +pub fn _f32_true() -> i32 { + // CHECK: ret i32 1 + _f32(1.0) +} + +// CHECK-LABEL: @_f32_false( +#[no_mangle] +pub fn _f32_false(a: f32) -> i32 { + // CHECK: ret i32 0 + _f32(a) +} + +#[inline] +pub fn _f64(a: f64) -> i32 { + if is_val_statically_known(a) { 1 } else { 0 } +} + +// CHECK-LABEL: @_f64_true( +#[no_mangle] +pub fn _f64_true() -> i32 { + // CHECK: ret i32 1 + _f64(1.0) +} + +// CHECK-LABEL: @_f64_false( +#[no_mangle] +pub fn _f64_false(a: f64) -> i32 { + // CHECK: ret i32 0 + _f64(a) +} + +#[inline] +pub fn _f128(a: f128) -> i32 { + if is_val_statically_known(a) { 1 } else { 0 } +} + +// CHECK-LABEL: @_f128_true( +#[no_mangle] +pub fn _f128_true() -> i32 { + // CHECK: ret i32 1 + _f128(1.0) +} + +// CHECK-LABEL: @_f128_false( +#[no_mangle] +pub fn _f128_false(a: f128) -> i32 { + // CHECK: ret i32 0 + _f128(a) +} From 70320c1936e2cdf0dd4f79c6539b32dd928d4cc2 Mon Sep 17 00:00:00 2001 From: Ben Kimock Date: Sun, 11 Aug 2024 14:25:00 -0400 Subject: [PATCH 30/79] Enable more debuginfo tests on Windows --- tests/debuginfo/drop-locations.rs | 1 - tests/debuginfo/embedded-visualizer.rs | 2 +- tests/debuginfo/empty-string.rs | 2 +- tests/debuginfo/issue-12886.rs | 3 +-- tests/debuginfo/macro-stepping.rs | 1 - tests/debuginfo/numeric-types.rs | 2 +- tests/debuginfo/pretty-huge-vec.rs | 2 +- tests/debuginfo/pretty-slices.rs | 2 +- tests/debuginfo/pretty-std-collections.rs | 1 - tests/debuginfo/pretty-uninitialized-vec.rs | 2 +- tests/debuginfo/thread-names.rs | 2 +- 11 files changed, 8 insertions(+), 12 deletions(-) diff --git a/tests/debuginfo/drop-locations.rs b/tests/debuginfo/drop-locations.rs index 0777313d1980..2db087dda796 100644 --- a/tests/debuginfo/drop-locations.rs +++ b/tests/debuginfo/drop-locations.rs @@ -1,4 +1,3 @@ -//@ ignore-windows //@ ignore-android //@ min-lldb-version: 310 //@ ignore-test: #128971 diff --git a/tests/debuginfo/embedded-visualizer.rs b/tests/debuginfo/embedded-visualizer.rs index 69afd273f773..959dbba7fd73 100644 --- a/tests/debuginfo/embedded-visualizer.rs +++ b/tests/debuginfo/embedded-visualizer.rs @@ -1,7 +1,7 @@ //@ compile-flags:-g //@ min-gdb-version: 8.1 //@ ignore-lldb -//@ ignore-windows-gnu // emit_debug_gdb_scripts is disabled on Windows +//@ ignore-windows-gnu: #128981 // === CDB TESTS ================================================================================== diff --git a/tests/debuginfo/empty-string.rs b/tests/debuginfo/empty-string.rs index 35b68ed91c0f..eac3448bfd51 100644 --- a/tests/debuginfo/empty-string.rs +++ b/tests/debuginfo/empty-string.rs @@ -1,4 +1,4 @@ -//@ ignore-windows failing on win32 bot +//@ ignore-windows-gnu: #128981 //@ ignore-android: FIXME(#10381) //@ compile-flags:-g //@ min-gdb-version: 8.1 diff --git a/tests/debuginfo/issue-12886.rs b/tests/debuginfo/issue-12886.rs index c6cf0dd4e05e..48250e885374 100644 --- a/tests/debuginfo/issue-12886.rs +++ b/tests/debuginfo/issue-12886.rs @@ -1,4 +1,3 @@ -//@ ignore-windows failing on 64-bit bots FIXME #17638 //@ ignore-lldb //@ ignore-aarch64 @@ -6,7 +5,7 @@ // gdb-command:run // gdb-command:next -// gdb-check:[...]24[...]let s = Some(5).unwrap(); // #break +// gdb-check:[...]23[...]let s = Some(5).unwrap(); // #break // gdb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/macro-stepping.rs b/tests/debuginfo/macro-stepping.rs index 3edac3c7832f..35bb6de4fef3 100644 --- a/tests/debuginfo/macro-stepping.rs +++ b/tests/debuginfo/macro-stepping.rs @@ -1,4 +1,3 @@ -//@ ignore-windows //@ ignore-android //@ ignore-aarch64 //@ min-lldb-version: 1800 diff --git a/tests/debuginfo/numeric-types.rs b/tests/debuginfo/numeric-types.rs index 98bc31e88557..6f45b69e5e34 100644 --- a/tests/debuginfo/numeric-types.rs +++ b/tests/debuginfo/numeric-types.rs @@ -1,7 +1,7 @@ //@ compile-flags:-g //@ min-gdb-version: 8.1 -//@ ignore-windows-gnu // emit_debug_gdb_scripts is disabled on Windows +//@ ignore-windows-gnu: #128981 // Tests the visualizations for `NonZero`, `Wrapping` and // `Atomic{Bool,I8,I16,I32,I64,Isize,U8,U16,U32,U64,Usize}` located in `libcore.natvis`. diff --git a/tests/debuginfo/pretty-huge-vec.rs b/tests/debuginfo/pretty-huge-vec.rs index dcf3521175d4..b88e5db1acb8 100644 --- a/tests/debuginfo/pretty-huge-vec.rs +++ b/tests/debuginfo/pretty-huge-vec.rs @@ -1,4 +1,4 @@ -//@ ignore-windows failing on win32 bot +//@ ignore-windows-gnu: #128981 //@ ignore-android: FIXME(#10381) //@ compile-flags:-g //@ min-gdb-version: 8.1 diff --git a/tests/debuginfo/pretty-slices.rs b/tests/debuginfo/pretty-slices.rs index 9defa344be03..44335f5c83b3 100644 --- a/tests/debuginfo/pretty-slices.rs +++ b/tests/debuginfo/pretty-slices.rs @@ -1,5 +1,5 @@ //@ ignore-android: FIXME(#10381) -//@ ignore-windows +//@ ignore-windows-gnu: #128981 //@ compile-flags:-g // gdb-command: run diff --git a/tests/debuginfo/pretty-std-collections.rs b/tests/debuginfo/pretty-std-collections.rs index 3d5a30d19a9c..3ec00886e2f4 100644 --- a/tests/debuginfo/pretty-std-collections.rs +++ b/tests/debuginfo/pretty-std-collections.rs @@ -1,4 +1,3 @@ -//@ ignore-windows failing on win32 bot //@ ignore-android: FIXME(#10381) //@ ignore-windows-gnu: #128981 //@ compile-flags:-g diff --git a/tests/debuginfo/pretty-uninitialized-vec.rs b/tests/debuginfo/pretty-uninitialized-vec.rs index 5206ff23fd5b..ddb751161d8c 100644 --- a/tests/debuginfo/pretty-uninitialized-vec.rs +++ b/tests/debuginfo/pretty-uninitialized-vec.rs @@ -1,4 +1,4 @@ -//@ ignore-windows failing on win32 bot +//@ ignore-windows-gnu: #128981 //@ ignore-android: FIXME(#10381) //@ compile-flags:-g //@ min-gdb-version: 8.1 diff --git a/tests/debuginfo/thread-names.rs b/tests/debuginfo/thread-names.rs index 6b3b0c7f4b23..265b9271cf30 100644 --- a/tests/debuginfo/thread-names.rs +++ b/tests/debuginfo/thread-names.rs @@ -4,7 +4,7 @@ //@[macos] only-macos //@[win] only-windows //@ ignore-sgx -//@ ignore-windows-gnu +//@ ignore-windows-gnu: gdb on windows-gnu does not print thread names // === GDB TESTS ================================================================================== // From 6c201561acd30972e850fc069341bd84ee3d26ae Mon Sep 17 00:00:00 2001 From: Weihang Lo Date: Fri, 16 Aug 2024 21:18:24 -0400 Subject: [PATCH 31/79] Update cargo --- src/tools/cargo | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/tools/cargo b/src/tools/cargo index 2f738d617c6e..ba8b39413c74 160000 --- a/src/tools/cargo +++ b/src/tools/cargo @@ -1 +1 @@ -Subproject commit 2f738d617c6ead388f899802dd1a7fd66858a691 +Subproject commit ba8b39413c74d08494f94a7542fe79aa636e1661 From 3c8dad152bc1e3baca25e5b7b6b7ea6eccef060a Mon Sep 17 00:00:00 2001 From: Shina <53410646+s7tya@users.noreply.github.com> Date: Sat, 17 Aug 2024 15:03:20 +0900 Subject: [PATCH 32/79] Emit an error for invalid use of the linkage attribute --- compiler/rustc_passes/messages.ftl | 4 ++ compiler/rustc_passes/src/check_attr.rs | 15 ++++++- compiler/rustc_passes/src/errors.rs | 9 ++++ tests/ui/attributes/linkage.rs | 42 +++++++++++++++++++ tests/ui/attributes/linkage.stderr | 55 +++++++++++++++++++++++++ 5 files changed, 124 insertions(+), 1 deletion(-) create mode 100644 tests/ui/attributes/linkage.rs create mode 100644 tests/ui/attributes/linkage.stderr diff --git a/compiler/rustc_passes/messages.ftl b/compiler/rustc_passes/messages.ftl index 59c9d1e49f5b..86ce552ad16d 100644 --- a/compiler/rustc_passes/messages.ftl +++ b/compiler/rustc_passes/messages.ftl @@ -427,6 +427,10 @@ passes_link_section = .warn = {-passes_previously_accepted} .label = not a function or static +passes_linkage = + attribute should be applied to a function or static + .label = not a function definition or static + passes_macro_export = `#[macro_export]` only has an effect on macro definitions diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs index c8d4c190113b..e16509261404 100644 --- a/compiler/rustc_passes/src/check_attr.rs +++ b/compiler/rustc_passes/src/check_attr.rs @@ -243,6 +243,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> { [sym::coroutine, ..] => { self.check_coroutine(attr, target); } + [sym::linkage, ..] => self.check_linkage(attr, span, target), [ // ok sym::allow @@ -256,7 +257,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> { | sym::cfi_encoding // FIXME(cfi_encoding) | sym::may_dangle // FIXME(dropck_eyepatch) | sym::pointee // FIXME(derive_smart_pointer) - | sym::linkage // FIXME(linkage) | sym::omit_gdb_pretty_printer_section // FIXME(omit_gdb_pretty_printer_section) | sym::used // handled elsewhere to restrict to static items | sym::repr // handled elsewhere to restrict to type decls items @@ -2349,6 +2349,19 @@ impl<'tcx> CheckAttrVisitor<'tcx> { } } } + + fn check_linkage(&self, attr: &Attribute, span: Span, target: Target) { + match target { + Target::Fn + | Target::Method(..) + | Target::Static + | Target::ForeignStatic + | Target::ForeignFn => {} + _ => { + self.dcx().emit_err(errors::Linkage { attr_span: attr.span, span }); + } + } + } } impl<'tcx> Visitor<'tcx> for CheckAttrVisitor<'tcx> { diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs index 36dfc40e7628..3a043e0e3c19 100644 --- a/compiler/rustc_passes/src/errors.rs +++ b/compiler/rustc_passes/src/errors.rs @@ -643,6 +643,15 @@ pub struct CoroutineOnNonClosure { pub span: Span, } +#[derive(Diagnostic)] +#[diag(passes_linkage)] +pub struct Linkage { + #[primary_span] + pub attr_span: Span, + #[label] + pub span: Span, +} + #[derive(Diagnostic)] #[diag(passes_empty_confusables)] pub(crate) struct EmptyConfusables { diff --git a/tests/ui/attributes/linkage.rs b/tests/ui/attributes/linkage.rs new file mode 100644 index 000000000000..0d5ce699fa80 --- /dev/null +++ b/tests/ui/attributes/linkage.rs @@ -0,0 +1,42 @@ +#![feature(linkage)] +#![feature(stmt_expr_attributes)] +#![deny(unused_attributes)] +#![allow(dead_code)] + +#[linkage = "weak"] //~ ERROR attribute should be applied to a function or static +type InvalidTy = (); + +#[linkage = "weak"] //~ ERROR attribute should be applied to a function or static +mod invalid_module {} + +#[linkage = "weak"] //~ ERROR attribute should be applied to a function or static +struct F; + +#[linkage = "weak"] //~ ERROR attribute should be applied to a function or static +impl F { + #[linkage = "weak"] + fn valid(&self) {} +} + +#[linkage = "weak"] +fn f() { + #[linkage = "weak"] + { + 1 + }; + //~^^^^ ERROR attribute should be applied to a function or static +} + +extern "C" { + #[linkage = "weak"] + static A: *const (); + + #[linkage = "weak"] + fn bar(); +} + +fn main() { + let _ = #[linkage = "weak"] + (|| 1); + //~^^ ERROR attribute should be applied to a function or static +} diff --git a/tests/ui/attributes/linkage.stderr b/tests/ui/attributes/linkage.stderr new file mode 100644 index 000000000000..d5595529f400 --- /dev/null +++ b/tests/ui/attributes/linkage.stderr @@ -0,0 +1,55 @@ +error: attribute should be applied to a function or static + --> $DIR/linkage.rs:6:1 + | +LL | #[linkage = "weak"] + | ^^^^^^^^^^^^^^^^^^^ +LL | type InvalidTy = (); + | -------------------- not a function definition or static + +error: attribute should be applied to a function or static + --> $DIR/linkage.rs:9:1 + | +LL | #[linkage = "weak"] + | ^^^^^^^^^^^^^^^^^^^ +LL | mod invalid_module {} + | --------------------- not a function definition or static + +error: attribute should be applied to a function or static + --> $DIR/linkage.rs:12:1 + | +LL | #[linkage = "weak"] + | ^^^^^^^^^^^^^^^^^^^ +LL | struct F; + | --------- not a function definition or static + +error: attribute should be applied to a function or static + --> $DIR/linkage.rs:15:1 + | +LL | #[linkage = "weak"] + | ^^^^^^^^^^^^^^^^^^^ +LL | / impl F { +LL | | #[linkage = "weak"] +LL | | fn valid(&self) {} +LL | | } + | |_- not a function definition or static + +error: attribute should be applied to a function or static + --> $DIR/linkage.rs:23:5 + | +LL | #[linkage = "weak"] + | ^^^^^^^^^^^^^^^^^^^ +LL | / { +LL | | 1 +LL | | }; + | |_____- not a function definition or static + +error: attribute should be applied to a function or static + --> $DIR/linkage.rs:39:13 + | +LL | let _ = #[linkage = "weak"] + | ^^^^^^^^^^^^^^^^^^^ +LL | (|| 1); + | ------ not a function definition or static + +error: aborting due to 6 previous errors + From 3116db669c4e80ffdae5a34a8dd9bcfba4b1a9be Mon Sep 17 00:00:00 2001 From: Zalathar Date: Sat, 17 Aug 2024 17:56:00 +1000 Subject: [PATCH 33/79] Port `run-make/libtest-json/validate_json.py` to Rust This is a trivial Python script that simply tries to parse each line of stdin (i.e. the test process output) as JSON, to verify that the overall output is JSON Lines. We can perform the same check directly in `rmake.rs` using `serde_json`. --- tests/run-make/libtest-json/rmake.rs | 15 +++++++++++++-- tests/run-make/libtest-json/validate_json.py | 8 -------- 2 files changed, 13 insertions(+), 10 deletions(-) delete mode 100755 tests/run-make/libtest-json/validate_json.py diff --git a/tests/run-make/libtest-json/rmake.rs b/tests/run-make/libtest-json/rmake.rs index acbd88dc46cb..c31f4a79b641 100644 --- a/tests/run-make/libtest-json/rmake.rs +++ b/tests/run-make/libtest-json/rmake.rs @@ -3,7 +3,7 @@ //@ ignore-cross-compile //@ needs-unwind (test file contains #[should_panic] test) -use run_make_support::{cmd, diff, python_command, rustc}; +use run_make_support::{cmd, diff, rustc, serde_json}; fn main() { rustc().arg("--test").input("f.rs").run(); @@ -21,7 +21,18 @@ fn run_tests(extra_args: &[&str], expected_file: &str) { .run_fail(); let test_stdout = &cmd_out.stdout_utf8(); - python_command().arg("validate_json.py").stdin(test_stdout).run(); + // Verify that the test process output is JSON Lines, i.e. each line is valid JSON. + for (line, n) in test_stdout.lines().zip(1..) { + if let Err(e) = serde_json::from_str::(line) { + panic!( + "could not parse JSON on line {n}: {e}\n\ + \n\ + === STDOUT ===\n\ + {test_stdout}\ + ==============" + ); + } + } diff() .expected_file(expected_file) diff --git a/tests/run-make/libtest-json/validate_json.py b/tests/run-make/libtest-json/validate_json.py deleted file mode 100755 index 657f732f2bff..000000000000 --- a/tests/run-make/libtest-json/validate_json.py +++ /dev/null @@ -1,8 +0,0 @@ -#!/usr/bin/env python - -import sys -import json - -# Try to decode line in order to ensure it is a valid JSON document -for line in sys.stdin: - json.loads(line) From 53e1a2ee46cbcf84a61464bf62d9543be2c1ce8b Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Fri, 16 Aug 2024 23:08:29 +0200 Subject: [PATCH 34/79] disable problematic float-conv tests in i586 targets also fix typo in const-float-bits-conv --- tests/ui/consts/const-float-bits-conv.rs | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/tests/ui/consts/const-float-bits-conv.rs b/tests/ui/consts/const-float-bits-conv.rs index 74df90139478..aad750c4c975 100644 --- a/tests/ui/consts/const-float-bits-conv.rs +++ b/tests/ui/consts/const-float-bits-conv.rs @@ -23,6 +23,11 @@ macro_rules! const_assert { }; } +fn has_broken_floats() -> bool { + // i586 targets are broken due to . + std::env::var("TARGET").is_ok_and(|v| v.contains("i586")) +} + fn f32() { const_assert!((1f32).to_bits(), 0x3f800000); const_assert!(u32::from_be_bytes(1f32.to_be_bytes()), 0x3f800000); @@ -41,14 +46,15 @@ fn f32() { // Check that NaNs roundtrip their bits regardless of signalingness // 0xA is 0b1010; 0x5 is 0b0101 -- so these two together clobbers all the mantissa bits - // ...actually, let's just check that these break. :D const MASKED_NAN1: u32 = f32::NAN.to_bits() ^ 0x002A_AAAA; const MASKED_NAN2: u32 = f32::NAN.to_bits() ^ 0x0055_5555; const_assert!(f32::from_bits(MASKED_NAN1).is_nan()); - const_assert!(f32::from_bits(MASKED_NAN1).is_nan()); + const_assert!(f32::from_bits(MASKED_NAN2).is_nan()); const_assert!(f32::from_bits(MASKED_NAN1).to_bits(), MASKED_NAN1); - const_assert!(f32::from_bits(MASKED_NAN2).to_bits(), MASKED_NAN2); + if !has_broken_floats() { + const_assert!(f32::from_bits(MASKED_NAN2).to_bits(), MASKED_NAN2); + } } fn f64() { @@ -69,14 +75,15 @@ fn f64() { // Check that NaNs roundtrip their bits regardless of signalingness // 0xA is 0b1010; 0x5 is 0b0101 -- so these two together clobbers all the mantissa bits - // ...actually, let's just check that these break. :D const MASKED_NAN1: u64 = f64::NAN.to_bits() ^ 0x000A_AAAA_AAAA_AAAA; const MASKED_NAN2: u64 = f64::NAN.to_bits() ^ 0x0005_5555_5555_5555; const_assert!(f64::from_bits(MASKED_NAN1).is_nan()); - const_assert!(f64::from_bits(MASKED_NAN1).is_nan()); + const_assert!(f64::from_bits(MASKED_NAN2).is_nan()); const_assert!(f64::from_bits(MASKED_NAN1).to_bits(), MASKED_NAN1); - const_assert!(f64::from_bits(MASKED_NAN2).to_bits(), MASKED_NAN2); + if !has_broken_floats() { + const_assert!(f64::from_bits(MASKED_NAN2).to_bits(), MASKED_NAN2); + } } fn main() { From 5f33085a7f574b95609da59b2d4164238d7782f0 Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Sat, 17 Aug 2024 10:25:58 +0200 Subject: [PATCH 35/79] more clear NAN names and fix broken_floats logic Co-authored-by: Jubilee <46493976+workingjubilee@users.noreply.github.com> --- tests/ui/consts/const-float-bits-conv.rs | 26 +++++++++++++----------- 1 file changed, 14 insertions(+), 12 deletions(-) diff --git a/tests/ui/consts/const-float-bits-conv.rs b/tests/ui/consts/const-float-bits-conv.rs index aad750c4c975..45e8ea570ed7 100644 --- a/tests/ui/consts/const-float-bits-conv.rs +++ b/tests/ui/consts/const-float-bits-conv.rs @@ -46,14 +46,15 @@ fn f32() { // Check that NaNs roundtrip their bits regardless of signalingness // 0xA is 0b1010; 0x5 is 0b0101 -- so these two together clobbers all the mantissa bits - const MASKED_NAN1: u32 = f32::NAN.to_bits() ^ 0x002A_AAAA; - const MASKED_NAN2: u32 = f32::NAN.to_bits() ^ 0x0055_5555; + // NOTE: These names assume `f{BITS}::NAN` is a quiet NAN and IEEE754-2008's NaN rules apply! + const QUIET_NAN: u32 = f32::NAN.to_bits() ^ 0x002A_AAAA; + const SIGNALING_NAN: u32 = f32::NAN.to_bits() ^ 0x0055_5555; - const_assert!(f32::from_bits(MASKED_NAN1).is_nan()); - const_assert!(f32::from_bits(MASKED_NAN2).is_nan()); - const_assert!(f32::from_bits(MASKED_NAN1).to_bits(), MASKED_NAN1); + const_assert!(f32::from_bits(QUIET_NAN).is_nan()); + const_assert!(f32::from_bits(SIGNALING_NAN).is_nan()); + const_assert!(f32::from_bits(QUIET_NAN).to_bits(), QUIET_NAN); if !has_broken_floats() { - const_assert!(f32::from_bits(MASKED_NAN2).to_bits(), MASKED_NAN2); + const_assert!(f32::from_bits(SIGNALING_NAN).to_bits(), SIGNALING_NAN); } } @@ -75,14 +76,15 @@ fn f64() { // Check that NaNs roundtrip their bits regardless of signalingness // 0xA is 0b1010; 0x5 is 0b0101 -- so these two together clobbers all the mantissa bits - const MASKED_NAN1: u64 = f64::NAN.to_bits() ^ 0x000A_AAAA_AAAA_AAAA; - const MASKED_NAN2: u64 = f64::NAN.to_bits() ^ 0x0005_5555_5555_5555; + // NOTE: These names assume `f{BITS}::NAN` is a quiet NAN and IEEE754-2008's NaN rules apply! + const QUIET_NAN: u64 = f64::NAN.to_bits() ^ 0x0005_5555_5555_5555; + const SIGNALING_NAN: u64 = f64::NAN.to_bits() ^ 0x000A_AAAA_AAAA_AAAA; - const_assert!(f64::from_bits(MASKED_NAN1).is_nan()); - const_assert!(f64::from_bits(MASKED_NAN2).is_nan()); - const_assert!(f64::from_bits(MASKED_NAN1).to_bits(), MASKED_NAN1); + const_assert!(f64::from_bits(QUIET_NAN).is_nan()); + const_assert!(f64::from_bits(SIGNALING_NAN).is_nan()); + const_assert!(f64::from_bits(QUIET_NAN).to_bits(), QUIET_NAN); if !has_broken_floats() { - const_assert!(f64::from_bits(MASKED_NAN2).to_bits(), MASKED_NAN2); + const_assert!(f64::from_bits(SIGNALING_NAN).to_bits(), SIGNALING_NAN); } } From 321d40f060bccd79ea6878abc67bda5d10b65e5f Mon Sep 17 00:00:00 2001 From: Alona Enraght-Moony Date: Sat, 17 Aug 2024 10:44:23 +0000 Subject: [PATCH 36/79] rustdoc-json: Clean up serialization and printing. --- src/librustdoc/json/mod.rs | 42 +++++++++++++++++++++----------------- 1 file changed, 23 insertions(+), 19 deletions(-) diff --git a/src/librustdoc/json/mod.rs b/src/librustdoc/json/mod.rs index a424faaf9998..e2860292aa3b 100644 --- a/src/librustdoc/json/mod.rs +++ b/src/librustdoc/json/mod.rs @@ -39,8 +39,10 @@ pub(crate) struct JsonRenderer<'tcx> { /// A mapping of IDs that contains all local items for this crate which gets output as a top /// level field of the JSON blob. index: Rc>>, - /// The directory where the blob will be written to. - out_path: Option, + /// The directory where the JSON blob should be written to. + /// + /// If this is `None`, the blob will be printed to `stdout` instead. + out_dir: Option, cache: Rc, imported_items: DefIdSet, } @@ -101,18 +103,20 @@ impl<'tcx> JsonRenderer<'tcx> { .unwrap_or_default() } - fn write( + fn serialize_and_write( &self, - output: types::Crate, + output_crate: types::Crate, mut writer: BufWriter, path: &str, ) -> Result<(), Error> { - self.tcx - .sess - .time("rustdoc_json_serialization", || serde_json::ser::to_writer(&mut writer, &output)) - .unwrap(); - try_err!(writer.flush(), path); - Ok(()) + self.sess().time("rustdoc_json_serialize_and_write", || { + try_err!( + serde_json::ser::to_writer(&mut writer, &output_crate).map_err(|e| e.to_string()), + path + ); + try_err!(writer.flush(), path); + Ok(()) + }) } } @@ -137,7 +141,7 @@ impl<'tcx> FormatRenderer<'tcx> for JsonRenderer<'tcx> { JsonRenderer { tcx, index: Rc::new(RefCell::new(FxHashMap::default())), - out_path: if options.output_to_stdout { None } else { Some(options.output) }, + out_dir: if options.output_to_stdout { None } else { Some(options.output) }, cache: Rc::new(cache), imported_items, }, @@ -237,7 +241,7 @@ impl<'tcx> FormatRenderer<'tcx> for JsonRenderer<'tcx> { let index = (*self.index).clone().into_inner(); debug!("Constructing Output"); - let output = types::Crate { + let output_crate = types::Crate { root: types::Id(format!("0:0:{}", e.name(self.tcx).as_u32())), crate_version: self.cache.crate_version.clone(), includes_private: self.cache.document_private, @@ -278,20 +282,20 @@ impl<'tcx> FormatRenderer<'tcx> for JsonRenderer<'tcx> { .collect(), format_version: types::FORMAT_VERSION, }; - if let Some(ref out_path) = self.out_path { - let out_dir = out_path.clone(); + if let Some(ref out_dir) = self.out_dir { try_err!(create_dir_all(&out_dir), out_dir); - let mut p = out_dir; - p.push(output.index.get(&output.root).unwrap().name.clone().unwrap()); + let mut p = out_dir.clone(); + p.push(output_crate.index.get(&output_crate.root).unwrap().name.clone().unwrap()); p.set_extension("json"); - self.write( - output, + + self.serialize_and_write( + output_crate, BufWriter::new(try_err!(File::create(&p), p)), &p.display().to_string(), ) } else { - self.write(output, BufWriter::new(stdout()), "") + self.serialize_and_write(output_crate, BufWriter::new(stdout().lock()), "") } } From 7bde314de8cef42a1848b48cd5084f5d6c26549f Mon Sep 17 00:00:00 2001 From: Guillaume Gomez Date: Sat, 17 Aug 2024 13:24:38 +0200 Subject: [PATCH 37/79] Remove useless attributes in merged doctest generated code --- src/librustdoc/doctest/runner.rs | 4 ---- 1 file changed, 4 deletions(-) diff --git a/src/librustdoc/doctest/runner.rs b/src/librustdoc/doctest/runner.rs index b91333e5f813..d49fa3ac5ac5 100644 --- a/src/librustdoc/doctest/runner.rs +++ b/src/librustdoc/doctest/runner.rs @@ -75,7 +75,6 @@ impl DocTestRunner { #![allow(internal_features)] #![feature(test)] #![feature(rustc_attrs)] -#![feature(coverage_attribute)] " .to_string(); @@ -135,7 +134,6 @@ mod __doctest_mod {{ }} #[rustc_main] -#[coverage(off)] fn main() -> std::process::ExitCode {{ const TESTS: [test::TestDescAndFn; {nb_tests}] = [{ids}]; let bin_marker = std::ffi::OsStr::new(__doctest_mod::BIN_OPTION); @@ -235,11 +233,9 @@ fn main() {returns_result} {{ writeln!( output, " -#[rustc_test_marker = {test_name:?}] pub const TEST: test::TestDescAndFn = test::TestDescAndFn::new_doctest( {test_name:?}, {ignore}, {file:?}, {line}, {no_run}, {should_panic}, test::StaticTestFn( - #[coverage(off)] || {{{runner}}}, )); }}", From 194ade1267f2bb66cb53626679944e195850bdcf Mon Sep 17 00:00:00 2001 From: Zalathar Date: Sat, 17 Aug 2024 22:18:37 +1000 Subject: [PATCH 38/79] Remove a useless ref/id/ref round-trip from `pattern_from_hir` This re-lookup of `&hir::Pat` by its ID appears to be an artifact of earlier complexity that has since been removed from the compiler. --- compiler/rustc_mir_build/src/thir/cx/mod.rs | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/compiler/rustc_mir_build/src/thir/cx/mod.rs b/compiler/rustc_mir_build/src/thir/cx/mod.rs index 6120b1453cfa..5b5f97cb5141 100644 --- a/compiler/rustc_mir_build/src/thir/cx/mod.rs +++ b/compiler/rustc_mir_build/src/thir/cx/mod.rs @@ -8,7 +8,7 @@ use rustc_hir as hir; use rustc_hir::def::DefKind; use rustc_hir::def_id::{DefId, LocalDefId}; use rustc_hir::lang_items::LangItem; -use rustc_hir::{HirId, Node}; +use rustc_hir::HirId; use rustc_middle::bug; use rustc_middle::middle::region; use rustc_middle::thir::*; @@ -110,11 +110,7 @@ impl<'tcx> Cx<'tcx> { } #[instrument(level = "debug", skip(self))] - fn pattern_from_hir(&mut self, p: &hir::Pat<'_>) -> Box> { - let p = match self.tcx.hir_node(p.hir_id) { - Node::Pat(p) => p, - node => bug!("pattern became {:?}", node), - }; + fn pattern_from_hir(&mut self, p: &'tcx hir::Pat<'tcx>) -> Box> { pat_from_hir(self.tcx, self.param_env, self.typeck_results(), p) } From 9a9cf2fd4ce7adee14a90c3af2623902f29486fb Mon Sep 17 00:00:00 2001 From: Chris Denton Date: Sat, 17 Aug 2024 12:29:28 +0000 Subject: [PATCH 39/79] Fix bootstrap test `detect_src_and_out` on Windows --- src/bootstrap/src/core/config/tests.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/bootstrap/src/core/config/tests.rs b/src/bootstrap/src/core/config/tests.rs index 378d069672f5..219c5a6ec914 100644 --- a/src/bootstrap/src/core/config/tests.rs +++ b/src/bootstrap/src/core/config/tests.rs @@ -96,8 +96,8 @@ fn detect_src_and_out() { test(parse(""), None); { - let build_dir = if cfg!(windows) { Some("C:\\tmp") } else { Some("/tmp") }; - test(parse("build.build-dir = \"/tmp\""), build_dir); + let build_dir = if cfg!(windows) { "C:\\tmp" } else { "/tmp" }; + test(parse(&format!("build.build-dir = '{build_dir}'")), Some(build_dir)); } } From b2dd943d4be2f7f9f923146e2ff7b7bd46c59a3b Mon Sep 17 00:00:00 2001 From: Michael Goulet Date: Sat, 17 Aug 2024 12:50:12 -0400 Subject: [PATCH 40/79] Use cnum for extern crate data --- compiler/rustc_middle/src/query/mod.rs | 2 +- compiler/rustc_middle/src/ty/print/pretty.rs | 8 +++----- compiler/rustc_middle/src/ty/util.rs | 2 +- compiler/rustc_passes/src/lang_items.rs | 4 ++-- .../src/error_reporting/traits/fulfillment_errors.rs | 2 +- 5 files changed, 8 insertions(+), 10 deletions(-) diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs index 92c8d265c09e..75166624f95a 100644 --- a/compiler/rustc_middle/src/query/mod.rs +++ b/compiler/rustc_middle/src/query/mod.rs @@ -1520,7 +1520,7 @@ rustc_queries! { separate_provide_extern } - query extern_crate(def_id: DefId) -> Option<&'tcx ExternCrate> { + query extern_crate(def_id: CrateNum) -> Option<&'tcx ExternCrate> { eval_always desc { "getting crate's ExternCrateData" } separate_provide_extern diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs index 56ddf146636c..319fb7ef03bb 100644 --- a/compiler/rustc_middle/src/ty/print/pretty.rs +++ b/compiler/rustc_middle/src/ty/print/pretty.rs @@ -451,7 +451,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write { // 2. For an extern inferred from a path or an indirect crate, // where there is no explicit `extern crate`, we just prepend // the crate name. - match self.tcx().extern_crate(def_id) { + match self.tcx().extern_crate(cnum) { Some(&ExternCrate { src, dependency_of, span, .. }) => match (src, dependency_of) { (ExternCrateSource::Extern(def_id), LOCAL_CRATE) => { // NOTE(eddyb) the only reason `span` might be dummy, @@ -3247,10 +3247,8 @@ fn for_each_def(tcx: TyCtxt<'_>, mut collect_fn: impl for<'b> FnMut(&'b Ident, N let mut seen_defs: DefIdSet = Default::default(); for &cnum in tcx.crates(()).iter() { - let def_id = cnum.as_def_id(); - // Ignore crates that are not direct dependencies. - match tcx.extern_crate(def_id) { + match tcx.extern_crate(cnum) { None => continue, Some(extern_crate) => { if !extern_crate.is_direct() { @@ -3259,7 +3257,7 @@ fn for_each_def(tcx: TyCtxt<'_>, mut collect_fn: impl for<'b> FnMut(&'b Ident, N } } - queue.push(def_id); + queue.push(cnum.as_def_id()); } // Iterate external crate defs but be mindful about visibility diff --git a/compiler/rustc_middle/src/ty/util.rs b/compiler/rustc_middle/src/ty/util.rs index b9bf17cbb5ce..045c8ad39bee 100644 --- a/compiler/rustc_middle/src/ty/util.rs +++ b/compiler/rustc_middle/src/ty/util.rs @@ -859,7 +859,7 @@ impl<'tcx> TyCtxt<'tcx> { // If `extern_crate` is `None`, then the crate was injected (e.g., by the allocator). // Treat that kind of crate as "indirect", since it's an implementation detail of // the language. - || self.extern_crate(key.as_def_id()).is_some_and(|e| e.is_direct()) + || self.extern_crate(key).is_some_and(|e| e.is_direct()) } /// Whether the item has a host effect param. This is different from `TyCtxt::is_const`, diff --git a/compiler/rustc_passes/src/lang_items.rs b/compiler/rustc_passes/src/lang_items.rs index 3f1be87a73f7..71b0ebb0e217 100644 --- a/compiler/rustc_passes/src/lang_items.rs +++ b/compiler/rustc_passes/src/lang_items.rs @@ -130,7 +130,7 @@ impl<'ast, 'tcx> LanguageItemCollector<'ast, 'tcx> { if first_defined_span.is_none() { orig_crate_name = self.tcx.crate_name(original_def_id.krate); if let Some(ExternCrate { dependency_of: inner_dependency_of, .. }) = - self.tcx.extern_crate(original_def_id) + self.tcx.extern_crate(original_def_id.krate) { orig_dependency_of = self.tcx.crate_name(*inner_dependency_of); } @@ -139,7 +139,7 @@ impl<'ast, 'tcx> LanguageItemCollector<'ast, 'tcx> { let duplicate = if item_span.is_some() { Duplicate::Plain } else { - match self.tcx.extern_crate(item_def_id) { + match self.tcx.extern_crate(item_def_id.krate) { Some(ExternCrate { dependency_of: inner_dependency_of, .. }) => { dependency_of = self.tcx.crate_name(*inner_dependency_of); Duplicate::CrateDepends diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs index 326a0e4e35ce..347f5b9f93f7 100644 --- a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs +++ b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs @@ -1668,7 +1668,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> { let name = self.tcx.crate_name(trait_def_id.krate); let spans: Vec<_> = [trait_def_id, found_type] .into_iter() - .filter_map(|def_id| self.tcx.extern_crate(def_id)) + .filter_map(|def_id| self.tcx.extern_crate(def_id.krate)) .map(|data| { let dependency = if data.dependency_of == LOCAL_CRATE { "direct dependency of the current crate".to_string() From 0156eb57a152003c0c82552229747b3d04e1fddc Mon Sep 17 00:00:00 2001 From: Chris Denton Date: Fri, 16 Aug 2024 19:32:22 +0000 Subject: [PATCH 41/79] Always use ar_archive_writer for import libs --- Cargo.lock | 4 +- .../rustc_codegen_cranelift/src/archive.rs | 83 +--------------- compiler/rustc_codegen_cranelift/src/lib.rs | 1 - compiler/rustc_codegen_llvm/messages.ftl | 3 - .../rustc_codegen_llvm/src/back/archive.rs | 94 +------------------ compiler/rustc_codegen_llvm/src/errors.rs | 7 -- compiler/rustc_codegen_ssa/Cargo.toml | 2 +- compiler/rustc_codegen_ssa/messages.ftl | 3 + .../rustc_codegen_ssa/src/back/archive.rs | 86 ++++++++++++++++- compiler/rustc_codegen_ssa/src/errors.rs | 7 ++ 10 files changed, 100 insertions(+), 190 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 1aa0b2ea4a39..ae5d3e12e3af 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -205,9 +205,9 @@ dependencies = [ [[package]] name = "ar_archive_writer" -version = "0.3.3" +version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3f2bcb7cf51decfbbfc7ef476e28b0775b13e5eb1190f8b7df145cd53d4f4374" +checksum = "de11a9d32db3327f981143bdf699ade4d637c6887b13b97e6e91a9154666963c" dependencies = [ "object 0.36.2", ] diff --git a/compiler/rustc_codegen_cranelift/src/archive.rs b/compiler/rustc_codegen_cranelift/src/archive.rs index 5eedab4f2cba..c7725e49c944 100644 --- a/compiler/rustc_codegen_cranelift/src/archive.rs +++ b/compiler/rustc_codegen_cranelift/src/archive.rs @@ -1,13 +1,6 @@ -use std::borrow::Borrow; -use std::fs; -use std::path::Path; - -use ar_archive_writer::{COFFShortExport, MachineTypes}; use rustc_codegen_ssa::back::archive::{ - create_mingw_dll_import_lib, ArArchiveBuilder, ArchiveBuilder, ArchiveBuilderBuilder, - DEFAULT_OBJECT_READER, + ArArchiveBuilder, ArchiveBuilder, ArchiveBuilderBuilder, DEFAULT_OBJECT_READER, }; -use rustc_codegen_ssa::common::is_mingw_gnu_toolchain; use rustc_session::Session; pub(crate) struct ArArchiveBuilderBuilder; @@ -16,78 +9,4 @@ impl ArchiveBuilderBuilder for ArArchiveBuilderBuilder { fn new_archive_builder<'a>(&self, sess: &'a Session) -> Box { Box::new(ArArchiveBuilder::new(sess, &DEFAULT_OBJECT_READER)) } - - fn create_dll_import_lib( - &self, - sess: &Session, - lib_name: &str, - import_name_and_ordinal_vector: Vec<(String, Option)>, - output_path: &Path, - ) { - if is_mingw_gnu_toolchain(&sess.target) { - // The binutils linker used on -windows-gnu targets cannot read the import - // libraries generated by LLVM: in our attempts, the linker produced an .EXE - // that loaded but crashed with an AV upon calling one of the imported - // functions. Therefore, use binutils to create the import library instead, - // by writing a .DEF file to the temp dir and calling binutils's dlltool. - create_mingw_dll_import_lib( - sess, - lib_name, - import_name_and_ordinal_vector, - output_path, - ); - } else { - let mut file = - match fs::OpenOptions::new().write(true).create_new(true).open(&output_path) { - Ok(file) => file, - Err(error) => { - sess.dcx().fatal(format!( - "failed to create import library file `{path}`: {error}", - path = output_path.display(), - )); - } - }; - - let machine = match sess.target.arch.borrow() { - "x86" => MachineTypes::I386, - "x86_64" => MachineTypes::AMD64, - "arm" => MachineTypes::ARMNT, - "aarch64" => MachineTypes::ARM64, - _ => { - sess.dcx().fatal(format!( - "unsupported target architecture `{arch}`", - arch = sess.target.arch, - )); - } - }; - - let exports = import_name_and_ordinal_vector - .iter() - .map(|(name, ordinal)| COFFShortExport { - name: name.to_string(), - ext_name: None, - symbol_name: None, - alias_target: None, - ordinal: ordinal.unwrap_or(0), - noname: ordinal.is_some(), - data: false, - private: false, - constant: false, - }) - .collect::>(); - - if let Err(error) = ar_archive_writer::write_import_library( - &mut file, - lib_name, - &exports, - machine, - !sess.target.is_like_msvc, - ) { - sess.dcx().fatal(format!( - "failed to create import library `{path}`: `{error}`", - path = output_path.display(), - )); - } - } - } } diff --git a/compiler/rustc_codegen_cranelift/src/lib.rs b/compiler/rustc_codegen_cranelift/src/lib.rs index 21930fa2ddb4..f737af25b62e 100644 --- a/compiler/rustc_codegen_cranelift/src/lib.rs +++ b/compiler/rustc_codegen_cranelift/src/lib.rs @@ -12,7 +12,6 @@ #![warn(unused_lifetimes)] // tidy-alphabetical-end -extern crate ar_archive_writer; extern crate jobserver; #[macro_use] extern crate rustc_middle; diff --git a/compiler/rustc_codegen_llvm/messages.ftl b/compiler/rustc_codegen_llvm/messages.ftl index 267da9325c38..df2198df14b6 100644 --- a/compiler/rustc_codegen_llvm/messages.ftl +++ b/compiler/rustc_codegen_llvm/messages.ftl @@ -5,9 +5,6 @@ codegen_llvm_dynamic_linking_with_lto = .note = only 'staticlib', 'bin', and 'cdylib' outputs are supported with LTO -codegen_llvm_error_creating_import_library = - Error creating import library for {$lib_name}: {$error} - codegen_llvm_fixed_x18_invalid_arch = the `-Zfixed-x18` flag is not supported on the `{$arch}` architecture codegen_llvm_from_llvm_diag = {$message} diff --git a/compiler/rustc_codegen_llvm/src/back/archive.rs b/compiler/rustc_codegen_llvm/src/back/archive.rs index 2120fc1815cd..c0ec4f86b4db 100644 --- a/compiler/rustc_codegen_llvm/src/back/archive.rs +++ b/compiler/rustc_codegen_llvm/src/back/archive.rs @@ -5,17 +5,13 @@ use std::path::{Path, PathBuf}; use std::{io, mem, ptr, str}; use rustc_codegen_ssa::back::archive::{ - create_mingw_dll_import_lib, try_extract_macho_fat_archive, ArArchiveBuilder, - ArchiveBuildFailure, ArchiveBuilder, ArchiveBuilderBuilder, ObjectReader, UnknownArchiveKind, - DEFAULT_OBJECT_READER, + try_extract_macho_fat_archive, ArArchiveBuilder, ArchiveBuildFailure, ArchiveBuilder, + ArchiveBuilderBuilder, ObjectReader, UnknownArchiveKind, DEFAULT_OBJECT_READER, }; -use rustc_codegen_ssa::common; use rustc_session::Session; -use tracing::trace; -use crate::errors::ErrorCreatingImportLibrary; use crate::llvm::archive_ro::{ArchiveRO, Child}; -use crate::llvm::{self, ArchiveKind, LLVMMachineType, LLVMRustCOFFShortExport}; +use crate::llvm::{self, ArchiveKind}; /// Helper for adding many files to an archive. #[must_use = "must call build() to finish building the archive"] @@ -44,18 +40,6 @@ fn is_relevant_child(c: &Child<'_>) -> bool { } } -/// Map machine type strings to values of LLVM's MachineTypes enum. -fn llvm_machine_type(cpu: &str) -> LLVMMachineType { - match cpu { - "x86_64" => LLVMMachineType::AMD64, - "x86" => LLVMMachineType::I386, - "aarch64" => LLVMMachineType::ARM64, - "arm64ec" => LLVMMachineType::ARM64EC, - "arm" => LLVMMachineType::ARM, - _ => panic!("unsupported cpu type {cpu}"), - } -} - impl<'a> ArchiveBuilder for LlvmArchiveBuilder<'a> { fn add_archive( &mut self, @@ -116,78 +100,6 @@ impl ArchiveBuilderBuilder for LlvmArchiveBuilderBuilder { Box::new(ArArchiveBuilder::new(sess, &LLVM_OBJECT_READER)) } } - - fn create_dll_import_lib( - &self, - sess: &Session, - lib_name: &str, - import_name_and_ordinal_vector: Vec<(String, Option)>, - output_path: &Path, - ) { - if common::is_mingw_gnu_toolchain(&sess.target) { - // The binutils linker used on -windows-gnu targets cannot read the import - // libraries generated by LLVM: in our attempts, the linker produced an .EXE - // that loaded but crashed with an AV upon calling one of the imported - // functions. Therefore, use binutils to create the import library instead, - // by writing a .DEF file to the temp dir and calling binutils's dlltool. - create_mingw_dll_import_lib( - sess, - lib_name, - import_name_and_ordinal_vector, - output_path, - ); - } else { - // we've checked for \0 characters in the library name already - let dll_name_z = CString::new(lib_name).unwrap(); - - let output_path_z = rustc_fs_util::path_to_c_string(&output_path); - - trace!("invoking LLVMRustWriteImportLibrary"); - trace!(" dll_name {:#?}", dll_name_z); - trace!(" output_path {}", output_path.display()); - trace!( - " import names: {}", - import_name_and_ordinal_vector - .iter() - .map(|(name, _ordinal)| name.clone()) - .collect::>() - .join(", "), - ); - - // All import names are Rust identifiers and therefore cannot contain \0 characters. - // FIXME: when support for #[link_name] is implemented, ensure that the import names - // still don't contain any \0 characters. Also need to check that the names don't - // contain substrings like " @" or "NONAME" that are keywords or otherwise reserved - // in definition files. - let cstring_import_name_and_ordinal_vector: Vec<(CString, Option)> = - import_name_and_ordinal_vector - .into_iter() - .map(|(name, ordinal)| (CString::new(name).unwrap(), ordinal)) - .collect(); - - let ffi_exports: Vec = cstring_import_name_and_ordinal_vector - .iter() - .map(|(name_z, ordinal)| LLVMRustCOFFShortExport::new(name_z.as_ptr(), *ordinal)) - .collect(); - let result = unsafe { - crate::llvm::LLVMRustWriteImportLibrary( - dll_name_z.as_ptr(), - output_path_z.as_ptr(), - ffi_exports.as_ptr(), - ffi_exports.len(), - llvm_machine_type(&sess.target.arch) as u16, - !sess.target.is_like_msvc, - ) - }; - - if result == crate::llvm::LLVMRustResult::Failure { - sess.dcx().emit_fatal(ErrorCreatingImportLibrary { - lib_name, - error: llvm::last_error().unwrap_or("unknown LLVM error".to_string()), - }); - } - } - } } // The object crate doesn't know how to get symbols for LLVM bitcode and COFF bigobj files. diff --git a/compiler/rustc_codegen_llvm/src/errors.rs b/compiler/rustc_codegen_llvm/src/errors.rs index 7e53d32ce8cd..e0ec9cdca560 100644 --- a/compiler/rustc_codegen_llvm/src/errors.rs +++ b/compiler/rustc_codegen_llvm/src/errors.rs @@ -39,13 +39,6 @@ pub(crate) enum PossibleFeature<'a> { None, } -#[derive(Diagnostic)] -#[diag(codegen_llvm_error_creating_import_library)] -pub(crate) struct ErrorCreatingImportLibrary<'a> { - pub lib_name: &'a str, - pub error: String, -} - #[derive(Diagnostic)] #[diag(codegen_llvm_symbol_already_defined)] pub(crate) struct SymbolAlreadyDefined<'a> { diff --git a/compiler/rustc_codegen_ssa/Cargo.toml b/compiler/rustc_codegen_ssa/Cargo.toml index 6e1c323cbd06..0af34a1b9fa6 100644 --- a/compiler/rustc_codegen_ssa/Cargo.toml +++ b/compiler/rustc_codegen_ssa/Cargo.toml @@ -5,7 +5,7 @@ edition = "2021" [dependencies] # tidy-alphabetical-start -ar_archive_writer = "0.3.3" +ar_archive_writer = "0.4.0" arrayvec = { version = "0.7", default-features = false } bitflags = "2.4.1" cc = "1.0.90" diff --git a/compiler/rustc_codegen_ssa/messages.ftl b/compiler/rustc_codegen_ssa/messages.ftl index 80f25d42a085..8a6a2acd87d4 100644 --- a/compiler/rustc_codegen_ssa/messages.ftl +++ b/compiler/rustc_codegen_ssa/messages.ftl @@ -32,6 +32,9 @@ codegen_ssa_dlltool_fail_import_library = codegen_ssa_error_calling_dlltool = Error calling dlltool '{$dlltool_path}': {$error} +codegen_ssa_error_creating_import_library = + Error creating import library for {$lib_name}: {$error} + codegen_ssa_error_creating_remark_dir = failed to create remark directory: {$error} codegen_ssa_error_writing_def_file = diff --git a/compiler/rustc_codegen_ssa/src/back/archive.rs b/compiler/rustc_codegen_ssa/src/back/archive.rs index 8eb44d120164..38a440a707a2 100644 --- a/compiler/rustc_codegen_ssa/src/back/archive.rs +++ b/compiler/rustc_codegen_ssa/src/back/archive.rs @@ -5,7 +5,9 @@ use std::fs::{self, File}; use std::io::{self, Write}; use std::path::{Path, PathBuf}; -use ar_archive_writer::{write_archive_to_stream, ArchiveKind, NewArchiveMember}; +use ar_archive_writer::{ + write_archive_to_stream, ArchiveKind, COFFShortExport, MachineTypes, NewArchiveMember, +}; pub use ar_archive_writer::{ObjectReader, DEFAULT_OBJECT_READER}; use object::read::archive::ArchiveFile; use object::read::macho::FatArch; @@ -14,11 +16,15 @@ use rustc_data_structures::memmap::Mmap; use rustc_session::Session; use rustc_span::symbol::Symbol; use tempfile::Builder as TempFileBuilder; +use tracing::trace; use super::metadata::search_for_section; +use crate::common; // Re-exporting for rustc_codegen_llvm::back::archive pub use crate::errors::{ArchiveBuildFailure, ExtractBundledLibsError, UnknownArchiveKind}; -use crate::errors::{DlltoolFailImportLibrary, ErrorCallingDllTool, ErrorWritingDEFFile}; +use crate::errors::{ + DlltoolFailImportLibrary, ErrorCallingDllTool, ErrorCreatingImportLibrary, ErrorWritingDEFFile, +}; pub trait ArchiveBuilderBuilder { fn new_archive_builder<'a>(&self, sess: &'a Session) -> Box; @@ -34,7 +40,81 @@ pub trait ArchiveBuilderBuilder { lib_name: &str, import_name_and_ordinal_vector: Vec<(String, Option)>, output_path: &Path, - ); + ) { + if common::is_mingw_gnu_toolchain(&sess.target) { + // The binutils linker used on -windows-gnu targets cannot read the import + // libraries generated by LLVM: in our attempts, the linker produced an .EXE + // that loaded but crashed with an AV upon calling one of the imported + // functions. Therefore, use binutils to create the import library instead, + // by writing a .DEF file to the temp dir and calling binutils's dlltool. + create_mingw_dll_import_lib( + sess, + lib_name, + import_name_and_ordinal_vector, + output_path, + ); + } else { + trace!("creating import library"); + trace!(" dll_name {:#?}", lib_name); + trace!(" output_path {}", output_path.display()); + trace!( + " import names: {}", + import_name_and_ordinal_vector + .iter() + .map(|(name, _ordinal)| name.clone()) + .collect::>() + .join(", "), + ); + + // All import names are Rust identifiers and therefore cannot contain \0 characters. + // FIXME: when support for #[link_name] is implemented, ensure that the import names + // still don't contain any \0 characters. Also need to check that the names don't + // contain substrings like " @" or "NONAME" that are keywords or otherwise reserved + // in definition files. + + let mut file = match fs::File::create_new(&output_path) { + Ok(file) => file, + Err(error) => sess + .dcx() + .emit_fatal(ErrorCreatingImportLibrary { lib_name, error: error.to_string() }), + }; + + let exports = import_name_and_ordinal_vector + .iter() + .map(|(name, ordinal)| COFFShortExport { + name: name.to_string(), + ext_name: None, + symbol_name: None, + alias_target: None, + ordinal: ordinal.unwrap_or(0), + noname: ordinal.is_some(), + data: false, + private: false, + constant: false, + }) + .collect::>(); + let machine = match &*sess.target.arch { + "x86_64" => MachineTypes::AMD64, + "x86" => MachineTypes::I386, + "aarch64" => MachineTypes::ARM64, + "arm64ec" => MachineTypes::ARM64EC, + "arm" => MachineTypes::ARMNT, + cpu => panic!("unsupported cpu type {cpu}"), + }; + + if let Err(error) = ar_archive_writer::write_import_library( + &mut file, + lib_name, + &exports, + machine, + !sess.target.is_like_msvc, + /*comdat=*/ false, + ) { + sess.dcx() + .emit_fatal(ErrorCreatingImportLibrary { lib_name, error: error.to_string() }); + } + } + } fn extract_bundled_libs<'a>( &'a self, diff --git a/compiler/rustc_codegen_ssa/src/errors.rs b/compiler/rustc_codegen_ssa/src/errors.rs index 94bf0ab34e21..573a8cf7cbe4 100644 --- a/compiler/rustc_codegen_ssa/src/errors.rs +++ b/compiler/rustc_codegen_ssa/src/errors.rs @@ -1060,3 +1060,10 @@ pub struct CompilerBuiltinsCannotCall { pub caller: String, pub callee: String, } + +#[derive(Diagnostic)] +#[diag(codegen_ssa_error_creating_import_library)] +pub(crate) struct ErrorCreatingImportLibrary<'a> { + pub lib_name: &'a str, + pub error: String, +} From 7fd62320feddcb3fa85a3ab25bc4c0ac55ddac7c Mon Sep 17 00:00:00 2001 From: Luca Versari Date: Sat, 17 Aug 2024 20:45:45 +0200 Subject: [PATCH 42/79] Fix order of normalization and recursion in const folding. Fixes #126831. Without this patch, type normalization is not always idempotent, which leads to all sorts of bugs in places that assume that normalizing a normalized type does nothing. --- .../src/traits/query/normalize.rs | 8 +++--- .../const-generics/const-ty-is-normalized.rs | 25 +++++++++++++++++++ 2 files changed, 29 insertions(+), 4 deletions(-) create mode 100644 tests/ui/const-generics/const-ty-is-normalized.rs diff --git a/compiler/rustc_trait_selection/src/traits/query/normalize.rs b/compiler/rustc_trait_selection/src/traits/query/normalize.rs index 247b6e4823c4..cb96db5f7a22 100644 --- a/compiler/rustc_trait_selection/src/traits/query/normalize.rs +++ b/compiler/rustc_trait_selection/src/traits/query/normalize.rs @@ -333,14 +333,14 @@ impl<'cx, 'tcx> FallibleTypeFolder> for QueryNormalizer<'cx, 'tcx> return Ok(constant); } - let constant = constant.try_super_fold_with(self)?; - debug!(?constant, ?self.param_env); - Ok(crate::traits::with_replaced_escaping_bound_vars( + let constant = crate::traits::with_replaced_escaping_bound_vars( self.infcx, &mut self.universes, constant, |constant| constant.normalize(self.infcx.tcx, self.param_env), - )) + ); + debug!(?constant, ?self.param_env); + constant.try_super_fold_with(self) } #[inline] diff --git a/tests/ui/const-generics/const-ty-is-normalized.rs b/tests/ui/const-generics/const-ty-is-normalized.rs new file mode 100644 index 000000000000..784145f735ed --- /dev/null +++ b/tests/ui/const-generics/const-ty-is-normalized.rs @@ -0,0 +1,25 @@ +//@ compile-flags: -Cdebuginfo=2 --crate-type=lib +//@ build-pass +#![feature(adt_const_params)] + +const N_ISLANDS: usize = 4; + +pub type Matrix = [[usize; N_ISLANDS]; N_ISLANDS]; + +const EMPTY_MATRIX: Matrix = [[0; N_ISLANDS]; N_ISLANDS]; + +const fn to_matrix() -> Matrix { + EMPTY_MATRIX +} + +const BRIDGE_MATRIX: [[usize; N_ISLANDS]; N_ISLANDS] = to_matrix(); + +pub struct Walk { + _p: (), +} + +impl Walk<0, BRIDGE_MATRIX> { + pub const fn new() -> Self { + Self { _p: () } + } +} From f458886a405553294aca62defe7a90446f2a8a27 Mon Sep 17 00:00:00 2001 From: Eric Huss Date: Sat, 17 Aug 2024 17:34:52 -0700 Subject: [PATCH 43/79] Remove JohnTitor from review rotation --- triagebot.toml | 1 - 1 file changed, 1 deletion(-) diff --git a/triagebot.toml b/triagebot.toml index a98d5f6a7c21..161fe98fca94 100644 --- a/triagebot.toml +++ b/triagebot.toml @@ -970,7 +970,6 @@ rustdoc = [ docs = [ "@ehuss", "@GuillaumeGomez", - "@JohnTitor", ] query-system = [ "@cjgillot", From ce7a70ade8c73cf8622fb4eb051ccb3599ba75c7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=AE=B8=E6=9D=B0=E5=8F=8B=20Jieyou=20Xu=20=28Joe=29?= Date: Sun, 18 Aug 2024 09:13:44 +0000 Subject: [PATCH 44/79] tests: disable `dump-ice-to-disk` for i686-mingw To avoid blocking full CI. --- tests/run-make/dump-ice-to-disk/rmake.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tests/run-make/dump-ice-to-disk/rmake.rs b/tests/run-make/dump-ice-to-disk/rmake.rs index 08767246b90d..15f35eb2d3d8 100644 --- a/tests/run-make/dump-ice-to-disk/rmake.rs +++ b/tests/run-make/dump-ice-to-disk/rmake.rs @@ -23,6 +23,9 @@ //! - An attempt is made to re-enable this test on `i686-mingw` (by removing `ignore-windows`). If //! this test is still flakey, please restore the `ignore-windows` directive. +//@ ignore-windows +//FIXME(#128911): still flakey on i686-mingw. + use std::cell::OnceCell; use std::path::{Path, PathBuf}; From 0708b289b72fc3328c0244be6c1b267bba18fabd Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Sun, 18 Aug 2024 13:36:11 +0200 Subject: [PATCH 45/79] fix build with bootstrap compiler --- src/tools/miri/src/eval.rs | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/tools/miri/src/eval.rs b/src/tools/miri/src/eval.rs index 0850a8f24d96..bb623c66892a 100644 --- a/src/tools/miri/src/eval.rs +++ b/src/tools/miri/src/eval.rs @@ -458,7 +458,14 @@ pub fn eval_entry<'tcx>( panic::resume_unwind(panic_payload) }); // `Ok` can never happen. + #[cfg(not(bootstrap))] let Err(res) = res; + #[cfg(bootstrap)] + let res = match res { + Err(res) => res, + // `Ok` can never happen + Ok(never) => match never {}, + }; // Machine cleanup. Only do this if all threads have terminated; threads that are still running // might cause Stacked Borrows errors (https://github.com/rust-lang/miri/issues/2396). From b0023f5a417374aad980422b3f437f133676d4ef Mon Sep 17 00:00:00 2001 From: Evan Jones Date: Sun, 18 Aug 2024 10:43:36 -0400 Subject: [PATCH 46/79] code review improvements --- library/std/src/env.rs | 14 +++++--------- 1 file changed, 5 insertions(+), 9 deletions(-) diff --git a/library/std/src/env.rs b/library/std/src/env.rs index 215b7b03f04c..bbe191181c5a 100644 --- a/library/std/src/env.rs +++ b/library/std/src/env.rs @@ -198,16 +198,12 @@ impl fmt::Debug for VarsOs { /// /// # Errors /// -/// This function returns [`VarError::NotPresent`] if the environment variable -/// isn't set. +/// Returns [`VarError::NotPresent`] if: +/// - The variable is not set. +/// - The variable's name contains an equal sign or NUL (`'='` or `'\0'`). /// -/// This function may return [`VarError::NotPresent`] if the -/// environment variable's name contains the equal sign character (`=`) or the -/// NUL character. -/// -/// This function will return [`VarError::NotUnicode`] if the environment -/// variable's value is not valid Unicode. If this is not desired, consider -/// using [`var_os`]. +/// Returns [`VarError::NotUnicode`] if the variable's value is not valid +/// Unicode. If this is not desired, consider using [`var_os`]. /// /// # Examples /// From 43146616710b6ea7017aed22a978f942d6eb7ca3 Mon Sep 17 00:00:00 2001 From: Ben Kimock Date: Sat, 17 Aug 2024 17:31:13 -0400 Subject: [PATCH 47/79] Delete gdbg commands --- tests/debuginfo/associated-types.rs | 2 -- .../debuginfo/basic-types-globals-metadata.rs | 15 -------- tests/debuginfo/basic-types-globals.rs | 16 --------- tests/debuginfo/basic-types-metadata.rs | 11 ------ tests/debuginfo/basic-types-mut-globals.rs | 32 ----------------- tests/debuginfo/basic-types.rs | 2 -- tests/debuginfo/borrowed-basic.rs | 2 -- tests/debuginfo/borrowed-c-style-enum.rs | 3 -- tests/debuginfo/borrowed-struct.rs | 3 -- tests/debuginfo/borrowed-tuple.rs | 3 -- tests/debuginfo/box.rs | 1 - tests/debuginfo/boxed-struct.rs | 2 -- .../by-value-non-immediate-argument.rs | 5 --- .../by-value-self-argument-in-trait-impl.rs | 2 -- tests/debuginfo/c-style-enum-in-composite.rs | 7 ---- tests/debuginfo/c-style-enum.rs | 29 --------------- tests/debuginfo/cross-crate-spans.rs | 2 -- tests/debuginfo/destructured-fn-argument.rs | 8 ----- .../destructured-for-loop-variable.rs | 2 -- tests/debuginfo/destructured-local.rs | 8 ----- tests/debuginfo/evec-in-struct.rs | 5 --- .../debuginfo/function-arg-initialization.rs | 2 -- .../debuginfo/gdb-pretty-struct-and-enums.rs | 5 --- tests/debuginfo/generic-function.rs | 1 - .../generic-method-on-generic-struct.rs | 5 --- tests/debuginfo/generic-struct.rs | 4 --- .../lexical-scopes-in-block-expression.rs | 9 ----- tests/debuginfo/limited-debuginfo.rs | 4 --- tests/debuginfo/method-on-enum.rs | 5 --- tests/debuginfo/method-on-generic-struct.rs | 5 --- tests/debuginfo/method-on-struct.rs | 5 --- tests/debuginfo/method-on-trait.rs | 5 --- tests/debuginfo/method-on-tuple-struct.rs | 5 --- tests/debuginfo/option-like-enum.rs | 8 ----- .../packed-struct-with-destructor.rs | 8 ----- tests/debuginfo/packed-struct.rs | 4 --- tests/debuginfo/pretty-slices.rs | 2 -- tests/debuginfo/pretty-std.rs | 1 - tests/debuginfo/reference-debuginfo.rs | 2 -- tests/debuginfo/self-in-default-method.rs | 5 --- .../self-in-generic-default-method.rs | 5 --- tests/debuginfo/simd.rs | 18 ---------- tests/debuginfo/simple-struct.rs | 30 ---------------- tests/debuginfo/simple-tuple.rs | 36 ------------------- tests/debuginfo/struct-in-enum.rs | 3 -- tests/debuginfo/struct-in-struct.rs | 3 -- tests/debuginfo/struct-with-destructor.rs | 4 --- tests/debuginfo/tuple-in-struct.rs | 10 ------ tests/debuginfo/tuple-in-tuple.rs | 7 ---- tests/debuginfo/tuple-struct.rs | 6 ---- tests/debuginfo/union-smoke.rs | 2 -- tests/debuginfo/unsized.rs | 6 ---- .../var-captured-in-nested-closure.rs | 4 --- .../var-captured-in-sendable-closure.rs | 1 - .../var-captured-in-stack-closure.rs | 4 --- tests/debuginfo/vec-slices.rs | 12 ------- tests/debuginfo/vec.rs | 2 -- 57 files changed, 398 deletions(-) diff --git a/tests/debuginfo/associated-types.rs b/tests/debuginfo/associated-types.rs index d1d4e320b05d..8dd9853efe72 100644 --- a/tests/debuginfo/associated-types.rs +++ b/tests/debuginfo/associated-types.rs @@ -8,7 +8,6 @@ // gdb-command:run // gdb-command:print arg -// gdbg-check:$1 = {b = -1, b1 = 0} // gdbr-check:$1 = associated_types::Struct {b: -1, b1: 0} // gdb-command:continue @@ -23,7 +22,6 @@ // gdb-command:continue // gdb-command:print arg -// gdbg-check:$5 = {__0 = 4, __1 = 5} // gdbr-check:$5 = (4, 5) // gdb-command:continue diff --git a/tests/debuginfo/basic-types-globals-metadata.rs b/tests/debuginfo/basic-types-globals-metadata.rs index 13678c31e765..5276d6f4a5dc 100644 --- a/tests/debuginfo/basic-types-globals-metadata.rs +++ b/tests/debuginfo/basic-types-globals-metadata.rs @@ -2,49 +2,34 @@ //@ compile-flags:-g // gdb-command:run -// gdbg-command:whatis 'basic_types_globals_metadata::B' // gdbr-command:whatis basic_types_globals_metadata::B // gdb-check:type = bool -// gdbg-command:whatis 'basic_types_globals_metadata::I' // gdbr-command:whatis basic_types_globals_metadata::I // gdb-check:type = isize -// gdbg-command:whatis 'basic_types_globals_metadata::C' // gdbr-command:whatis basic_types_globals_metadata::C // gdb-check:type = char -// gdbg-command:whatis 'basic_types_globals_metadata::I8' // gdbr-command:whatis basic_types_globals_metadata::I8 // gdb-check:type = i8 -// gdbg-command:whatis 'basic_types_globals_metadata::I16' // gdbr-command:whatis basic_types_globals_metadata::I16 // gdb-check:type = i16 -// gdbg-command:whatis 'basic_types_globals_metadata::I32' // gdbr-command:whatis basic_types_globals_metadata::I32 // gdb-check:type = i32 -// gdbg-command:whatis 'basic_types_globals_metadata::I64' // gdbr-command:whatis basic_types_globals_metadata::I64 // gdb-check:type = i64 -// gdbg-command:whatis 'basic_types_globals_metadata::U' // gdbr-command:whatis basic_types_globals_metadata::U // gdb-check:type = usize -// gdbg-command:whatis 'basic_types_globals_metadata::U8' // gdbr-command:whatis basic_types_globals_metadata::U8 // gdb-check:type = u8 -// gdbg-command:whatis 'basic_types_globals_metadata::U16' // gdbr-command:whatis basic_types_globals_metadata::U16 // gdb-check:type = u16 -// gdbg-command:whatis 'basic_types_globals_metadata::U32' // gdbr-command:whatis basic_types_globals_metadata::U32 // gdb-check:type = u32 -// gdbg-command:whatis 'basic_types_globals_metadata::U64' // gdbr-command:whatis basic_types_globals_metadata::U64 // gdb-check:type = u64 -// gdbg-command:whatis 'basic_types_globals_metadata::F16' // gdbr-command:whatis basic_types_globals_metadata::F16 // gdb-check:type = f16 -// gdbg-command:whatis 'basic_types_globals_metadata::F32' // gdbr-command:whatis basic_types_globals_metadata::F32 // gdb-check:type = f32 -// gdbg-command:whatis 'basic_types_globals_metadata::F64' // gdbr-command:whatis basic_types_globals_metadata::F64 // gdb-check:type = f64 // gdb-command:continue diff --git a/tests/debuginfo/basic-types-globals.rs b/tests/debuginfo/basic-types-globals.rs index 0425d14fa5a3..7f86dce41779 100644 --- a/tests/debuginfo/basic-types-globals.rs +++ b/tests/debuginfo/basic-types-globals.rs @@ -12,50 +12,34 @@ //@ [lto] no-prefer-dynamic // gdb-command:run -// gdbg-command:print 'basic_types_globals::B' // gdbr-command:print B // gdb-check:$1 = false -// gdbg-command:print 'basic_types_globals::I' // gdbr-command:print I // gdb-check:$2 = -1 -// gdbg-command:print 'basic_types_globals::C' // gdbr-command:print/d C -// gdbg-check:$3 = 97 // gdbr-check:$3 = 97 -// gdbg-command:print/d 'basic_types_globals::I8' // gdbr-command:print I8 // gdb-check:$4 = 68 -// gdbg-command:print 'basic_types_globals::I16' // gdbr-command:print I16 // gdb-check:$5 = -16 -// gdbg-command:print 'basic_types_globals::I32' // gdbr-command:print I32 // gdb-check:$6 = -32 -// gdbg-command:print 'basic_types_globals::I64' // gdbr-command:print I64 // gdb-check:$7 = -64 -// gdbg-command:print 'basic_types_globals::U' // gdbr-command:print U // gdb-check:$8 = 1 -// gdbg-command:print/d 'basic_types_globals::U8' // gdbr-command:print U8 // gdb-check:$9 = 100 -// gdbg-command:print 'basic_types_globals::U16' // gdbr-command:print U16 // gdb-check:$10 = 16 -// gdbg-command:print 'basic_types_globals::U32' // gdbr-command:print U32 // gdb-check:$11 = 32 -// gdbg-command:print 'basic_types_globals::U64' // gdbr-command:print U64 // gdb-check:$12 = 64 -// gdbg-command:print 'basic_types_globals::F16' // gdbr-command:print F16 // gdb-check:$13 = 1.5 -// gdbg-command:print 'basic_types_globals::F32' // gdbr-command:print F32 // gdb-check:$14 = 2.5 -// gdbg-command:print 'basic_types_globals::F64' // gdbr-command:print F64 // gdb-check:$15 = 3.5 // gdb-command:continue diff --git a/tests/debuginfo/basic-types-metadata.rs b/tests/debuginfo/basic-types-metadata.rs index 3aebf2577b6b..a2662068fa4c 100644 --- a/tests/debuginfo/basic-types-metadata.rs +++ b/tests/debuginfo/basic-types-metadata.rs @@ -37,25 +37,14 @@ // gdb-command:whatis fnptr // gdb-check:type = *mut fn () // gdb-command:info functions _yyy -// gdbg-check:[...]![...]_yyy([...]); // gdbr-check:static fn basic_types_metadata::_yyy(); // gdb-command:ptype closure_0 // gdbr-check: type = struct basic_types_metadata::main::{closure_env#0} -// gdbg-check: type = struct closure { -// gdbg-check: -// gdbg-check: } // gdb-command:ptype closure_1 -// gdbg-check: type = struct closure { -// gdbg-check: bool *__0; -// gdbg-check: } // gdbr-check: type = struct basic_types_metadata::main::{closure_env#1} { // gdbr-check: *mut bool, // gdbr-check: } // gdb-command:ptype closure_2 -// gdbg-check: type = struct closure { -// gdbg-check: bool *__0; -// gdbg-check: isize *__1; -// gdbg-check: } // gdbr-check: type = struct basic_types_metadata::main::{closure_env#2} { // gdbr-check: *mut bool, // gdbr-check: *mut isize, diff --git a/tests/debuginfo/basic-types-mut-globals.rs b/tests/debuginfo/basic-types-mut-globals.rs index c676fd737714..fab2dc8507b5 100644 --- a/tests/debuginfo/basic-types-mut-globals.rs +++ b/tests/debuginfo/basic-types-mut-globals.rs @@ -11,99 +11,67 @@ // gdb-command:run // Check initializers -// gdbg-command:print 'basic_types_mut_globals::B' // gdbr-command:print B // gdb-check:$1 = false -// gdbg-command:print 'basic_types_mut_globals::I' // gdbr-command:print I // gdb-check:$2 = -1 -// gdbg-command:print/d 'basic_types_mut_globals::C' // gdbr-command:print C -// gdbg-check:$3 = 97 // gdbr-check:$3 = 97 'a' -// gdbg-command:print/d 'basic_types_mut_globals::I8' // gdbr-command:print I8 // gdb-check:$4 = 68 -// gdbg-command:print 'basic_types_mut_globals::I16' // gdbr-command:print I16 // gdb-check:$5 = -16 -// gdbg-command:print 'basic_types_mut_globals::I32' // gdbr-command:print I32 // gdb-check:$6 = -32 -// gdbg-command:print 'basic_types_mut_globals::I64' // gdbr-command:print I64 // gdb-check:$7 = -64 -// gdbg-command:print 'basic_types_mut_globals::U' // gdbr-command:print U // gdb-check:$8 = 1 -// gdbg-command:print/d 'basic_types_mut_globals::U8' // gdbr-command:print U8 // gdb-check:$9 = 100 -// gdbg-command:print 'basic_types_mut_globals::U16' // gdbr-command:print U16 // gdb-check:$10 = 16 -// gdbg-command:print 'basic_types_mut_globals::U32' // gdbr-command:print U32 // gdb-check:$11 = 32 -// gdbg-command:print 'basic_types_mut_globals::U64' // gdbr-command:print U64 // gdb-check:$12 = 64 -// gdbg-command:print 'basic_types_mut_globals::F16' // gdbr-command:print F16 // gdb-check:$13 = 1.5 -// gdbg-command:print 'basic_types_mut_globals::F32' // gdbr-command:print F32 // gdb-check:$14 = 2.5 -// gdbg-command:print 'basic_types_mut_globals::F64' // gdbr-command:print F64 // gdb-check:$15 = 3.5 // gdb-command:continue // Check new values -// gdbg-command:print 'basic_types_mut_globals'::B // gdbr-command:print B // gdb-check:$16 = true -// gdbg-command:print 'basic_types_mut_globals'::I // gdbr-command:print I // gdb-check:$17 = 2 -// gdbg-command:print/d 'basic_types_mut_globals'::C // gdbr-command:print C -// gdbg-check:$18 = 102 // gdbr-check:$18 = 102 'f' -// gdbg-command:print/d 'basic_types_mut_globals'::I8 // gdbr-command:print/d I8 // gdb-check:$19 = 78 -// gdbg-command:print 'basic_types_mut_globals'::I16 // gdbr-command:print I16 // gdb-check:$20 = -26 -// gdbg-command:print 'basic_types_mut_globals'::I32 // gdbr-command:print I32 // gdb-check:$21 = -12 -// gdbg-command:print 'basic_types_mut_globals'::I64 // gdbr-command:print I64 // gdb-check:$22 = -54 -// gdbg-command:print 'basic_types_mut_globals'::U // gdbr-command:print U // gdb-check:$23 = 5 -// gdbg-command:print/d 'basic_types_mut_globals'::U8 // gdbr-command:print/d U8 // gdb-check:$24 = 20 -// gdbg-command:print 'basic_types_mut_globals'::U16 // gdbr-command:print U16 // gdb-check:$25 = 32 -// gdbg-command:print 'basic_types_mut_globals'::U32 // gdbr-command:print U32 // gdb-check:$26 = 16 -// gdbg-command:print 'basic_types_mut_globals'::U64 // gdbr-command:print U64 // gdb-check:$27 = 128 -// gdbg-command:print 'basic_types_mut_globals'::F16 // gdbr-command:print F16 // gdb-check:$28 = 2.25 -// gdbg-command:print 'basic_types_mut_globals'::F32 // gdbr-command:print F32 // gdb-check:$29 = 5.75 -// gdbg-command:print 'basic_types_mut_globals'::F64 // gdbr-command:print F64 // gdb-check:$30 = 9.25 diff --git a/tests/debuginfo/basic-types.rs b/tests/debuginfo/basic-types.rs index d836525240ae..215599e6f0ef 100644 --- a/tests/debuginfo/basic-types.rs +++ b/tests/debuginfo/basic-types.rs @@ -16,7 +16,6 @@ // gdb-command:print i // gdb-check:$2 = -1 // gdb-command:print c -// gdbg-check:$3 = 97 // gdbr-check:$3 = 97 'a' // gdb-command:print/d i8 // gdb-check:$4 = 68 @@ -43,7 +42,6 @@ // gdb-command:print f64 // gdb-check:$15 = 3.5 // gdb-command:print s -// gdbg-check:$16 = {data_ptr = [...] "Hello, World!", length = 13} // gdbr-check:$16 = "Hello, World!" // === LLDB TESTS ================================================================================== diff --git a/tests/debuginfo/borrowed-basic.rs b/tests/debuginfo/borrowed-basic.rs index e3cf74dab1e7..68fcc3169919 100644 --- a/tests/debuginfo/borrowed-basic.rs +++ b/tests/debuginfo/borrowed-basic.rs @@ -14,7 +14,6 @@ // gdb-check:$3 = 97 // gdb-command:print *i8_ref -// gdbg-check:$4 = 68 'D' // gdbr-check:$4 = 68 // gdb-command:print *i16_ref @@ -30,7 +29,6 @@ // gdb-check:$8 = 1 // gdb-command:print *u8_ref -// gdbg-check:$9 = 100 'd' // gdbr-check:$9 = 100 // gdb-command:print *u16_ref diff --git a/tests/debuginfo/borrowed-c-style-enum.rs b/tests/debuginfo/borrowed-c-style-enum.rs index 1a582e8a6d9a..7ca19217a794 100644 --- a/tests/debuginfo/borrowed-c-style-enum.rs +++ b/tests/debuginfo/borrowed-c-style-enum.rs @@ -6,15 +6,12 @@ // gdb-command:run // gdb-command:print *the_a_ref -// gdbg-check:$1 = TheA // gdbr-check:$1 = borrowed_c_style_enum::ABC::TheA // gdb-command:print *the_b_ref -// gdbg-check:$2 = TheB // gdbr-check:$2 = borrowed_c_style_enum::ABC::TheB // gdb-command:print *the_c_ref -// gdbg-check:$3 = TheC // gdbr-check:$3 = borrowed_c_style_enum::ABC::TheC diff --git a/tests/debuginfo/borrowed-struct.rs b/tests/debuginfo/borrowed-struct.rs index d108a29592bc..84e63d9cf634 100644 --- a/tests/debuginfo/borrowed-struct.rs +++ b/tests/debuginfo/borrowed-struct.rs @@ -6,7 +6,6 @@ // gdb-command:run // gdb-command:print *stack_val_ref -// gdbg-check:$1 = {x = 10, y = 23.5} // gdbr-check:$1 = borrowed_struct::SomeStruct {x: 10, y: 23.5} // gdb-command:print *stack_val_interior_ref_1 @@ -16,11 +15,9 @@ // gdb-check:$3 = 23.5 // gdb-command:print *ref_to_unnamed -// gdbg-check:$4 = {x = 11, y = 24.5} // gdbr-check:$4 = borrowed_struct::SomeStruct {x: 11, y: 24.5} // gdb-command:print *unique_val_ref -// gdbg-check:$5 = {x = 13, y = 26.5} // gdbr-check:$5 = borrowed_struct::SomeStruct {x: 13, y: 26.5} // gdb-command:print *unique_val_interior_ref_1 diff --git a/tests/debuginfo/borrowed-tuple.rs b/tests/debuginfo/borrowed-tuple.rs index 4c5643deb9d0..c7253410f95b 100644 --- a/tests/debuginfo/borrowed-tuple.rs +++ b/tests/debuginfo/borrowed-tuple.rs @@ -7,15 +7,12 @@ // gdb-command:run // gdb-command:print *stack_val_ref -// gdbg-check:$1 = {__0 = -14, __1 = -19} // gdbr-check:$1 = (-14, -19) // gdb-command:print *ref_to_unnamed -// gdbg-check:$2 = {__0 = -15, __1 = -20} // gdbr-check:$2 = (-15, -20) // gdb-command:print *unique_val_ref -// gdbg-check:$3 = {__0 = -17, __1 = -22} // gdbr-check:$3 = (-17, -22) diff --git a/tests/debuginfo/box.rs b/tests/debuginfo/box.rs index 46019bcb1a76..f27e7cbafbf2 100644 --- a/tests/debuginfo/box.rs +++ b/tests/debuginfo/box.rs @@ -9,7 +9,6 @@ // gdb-command:print *a // gdb-check:$1 = 1 // gdb-command:print *b -// gdbg-check:$2 = {__0 = 2, __1 = 3.5} // gdbr-check:$2 = (2, 3.5) diff --git a/tests/debuginfo/boxed-struct.rs b/tests/debuginfo/boxed-struct.rs index 1ee639690eab..078af68c84df 100644 --- a/tests/debuginfo/boxed-struct.rs +++ b/tests/debuginfo/boxed-struct.rs @@ -7,11 +7,9 @@ // gdb-command:run // gdb-command:print *boxed_with_padding -// gdbg-check:$1 = {x = 99, y = 999, z = 9999, w = 99999} // gdbr-check:$1 = boxed_struct::StructWithSomePadding {x: 99, y: 999, z: 9999, w: 99999} // gdb-command:print *boxed_with_dtor -// gdbg-check:$2 = {x = 77, y = 777, z = 7777, w = 77777} // gdbr-check:$2 = boxed_struct::StructWithDestructor {x: 77, y: 777, z: 7777, w: 77777} diff --git a/tests/debuginfo/by-value-non-immediate-argument.rs b/tests/debuginfo/by-value-non-immediate-argument.rs index 68717b795337..623c939ee143 100644 --- a/tests/debuginfo/by-value-non-immediate-argument.rs +++ b/tests/debuginfo/by-value-non-immediate-argument.rs @@ -7,12 +7,10 @@ // gdb-command:run // gdb-command:print s -// gdbg-check:$1 = {a = 1, b = 2.5} // gdbr-check:$1 = by_value_non_immediate_argument::Struct {a: 1, b: 2.5} // gdb-command:continue // gdb-command:print x -// gdbg-check:$2 = {a = 3, b = 4.5} // gdbr-check:$2 = by_value_non_immediate_argument::Struct {a: 3, b: 4.5} // gdb-command:print y // gdb-check:$3 = 5 @@ -21,17 +19,14 @@ // gdb-command:continue // gdb-command:print a -// gdbg-check:$5 = {__0 = 7, __1 = 8, __2 = 9.5, __3 = 10.5} // gdbr-check:$5 = (7, 8, 9.5, 10.5) // gdb-command:continue // gdb-command:print a -// gdbg-check:$6 = {__0 = 11.5, __1 = 12.5, __2 = 13, __3 = 14} // gdbr-check:$6 = by_value_non_immediate_argument::Newtype (11.5, 12.5, 13, 14) // gdb-command:continue // gdb-command:print x -// gdbg-check:$7 = {{RUST$ENUM$DISR = Case1, x = 0, y = 8970181431921507452}, {RUST$ENUM$DISR = Case1, [...]}} // gdbr-check:$7 = by_value_non_immediate_argument::Enum::Case1{x: 0, y: 8970181431921507452} // gdb-command:continue diff --git a/tests/debuginfo/by-value-self-argument-in-trait-impl.rs b/tests/debuginfo/by-value-self-argument-in-trait-impl.rs index 5276ec827333..91a8792a69f9 100644 --- a/tests/debuginfo/by-value-self-argument-in-trait-impl.rs +++ b/tests/debuginfo/by-value-self-argument-in-trait-impl.rs @@ -11,12 +11,10 @@ // gdb-command:continue // gdb-command:print self -// gdbg-check:$2 = {x = 2222, y = 3333} // gdbr-check:$2 = by_value_self_argument_in_trait_impl::Struct {x: 2222, y: 3333} // gdb-command:continue // gdb-command:print self -// gdbg-check:$3 = {__0 = 4444.5, __1 = 5555, __2 = 6666, __3 = 7777.5} // gdbr-check:$3 = (4444.5, 5555, 6666, 7777.5) // gdb-command:continue diff --git a/tests/debuginfo/c-style-enum-in-composite.rs b/tests/debuginfo/c-style-enum-in-composite.rs index ec11d5f46555..112631e874eb 100644 --- a/tests/debuginfo/c-style-enum-in-composite.rs +++ b/tests/debuginfo/c-style-enum-in-composite.rs @@ -7,31 +7,24 @@ // gdb-command:run // gdb-command:print tuple_interior_padding -// gdbg-check:$1 = {__0 = 0, __1 = OneHundred} // gdbr-check:$1 = (0, c_style_enum_in_composite::AnEnum::OneHundred) // gdb-command:print tuple_padding_at_end -// gdbg-check:$2 = {__0 = {__0 = 1, __1 = OneThousand}, __1 = 2} // gdbr-check:$2 = ((1, c_style_enum_in_composite::AnEnum::OneThousand), 2) // gdb-command:print tuple_different_enums -// gdbg-check:$3 = {__0 = OneThousand, __1 = MountainView, __2 = OneMillion, __3 = Vienna} // gdbr-check:$3 = (c_style_enum_in_composite::AnEnum::OneThousand, c_style_enum_in_composite::AnotherEnum::MountainView, c_style_enum_in_composite::AnEnum::OneMillion, c_style_enum_in_composite::AnotherEnum::Vienna) // gdb-command:print padded_struct -// gdbg-check:$4 = {a = 3, b = OneMillion, c = 4, d = Toronto, e = 5} // gdbr-check:$4 = c_style_enum_in_composite::PaddedStruct {a: 3, b: c_style_enum_in_composite::AnEnum::OneMillion, c: 4, d: c_style_enum_in_composite::AnotherEnum::Toronto, e: 5} // gdb-command:print packed_struct -// gdbg-check:$5 = {a = 6, b = OneHundred, c = 7, d = Vienna, e = 8} // gdbr-check:$5 = c_style_enum_in_composite::PackedStruct {a: 6, b: c_style_enum_in_composite::AnEnum::OneHundred, c: 7, d: c_style_enum_in_composite::AnotherEnum::Vienna, e: 8} // gdb-command:print non_padded_struct -// gdbg-check:$6 = {a = OneMillion, b = MountainView, c = OneThousand, d = Toronto} // gdbr-check:$6 = c_style_enum_in_composite::NonPaddedStruct {a: c_style_enum_in_composite::AnEnum::OneMillion, b: c_style_enum_in_composite::AnotherEnum::MountainView, c: c_style_enum_in_composite::AnEnum::OneThousand, d: c_style_enum_in_composite::AnotherEnum::Toronto} // gdb-command:print struct_with_drop -// gdbg-check:$7 = {__0 = {a = OneHundred, b = Vienna}, __1 = 9} // gdbr-check:$7 = (c_style_enum_in_composite::StructWithDrop {a: c_style_enum_in_composite::AnEnum::OneHundred, b: c_style_enum_in_composite::AnotherEnum::Vienna}, 9) // === LLDB TESTS ================================================================================== diff --git a/tests/debuginfo/c-style-enum.rs b/tests/debuginfo/c-style-enum.rs index 2ab5d5ccf2cb..6f14f41f0600 100644 --- a/tests/debuginfo/c-style-enum.rs +++ b/tests/debuginfo/c-style-enum.rs @@ -5,89 +5,60 @@ // === GDB TESTS =================================================================================== -// gdbg-command:print 'c_style_enum::SINGLE_VARIANT' // gdbr-command:print c_style_enum::SINGLE_VARIANT -// gdbg-check:$1 = TheOnlyVariant // gdbr-check:$1 = c_style_enum::SingleVariant::TheOnlyVariant -// gdbg-command:print 'c_style_enum::AUTO_ONE' // gdbr-command:print c_style_enum::AUTO_ONE -// gdbg-check:$2 = One // gdbr-check:$2 = c_style_enum::AutoDiscriminant::One -// gdbg-command:print 'c_style_enum::AUTO_TWO' // gdbr-command:print c_style_enum::AUTO_TWO -// gdbg-check:$3 = One // gdbr-check:$3 = c_style_enum::AutoDiscriminant::One -// gdbg-command:print 'c_style_enum::AUTO_THREE' // gdbr-command:print c_style_enum::AUTO_THREE -// gdbg-check:$4 = One // gdbr-check:$4 = c_style_enum::AutoDiscriminant::One -// gdbg-command:print 'c_style_enum::MANUAL_ONE' // gdbr-command:print c_style_enum::MANUAL_ONE -// gdbg-check:$5 = OneHundred // gdbr-check:$5 = c_style_enum::ManualDiscriminant::OneHundred -// gdbg-command:print 'c_style_enum::MANUAL_TWO' // gdbr-command:print c_style_enum::MANUAL_TWO -// gdbg-check:$6 = OneHundred // gdbr-check:$6 = c_style_enum::ManualDiscriminant::OneHundred -// gdbg-command:print 'c_style_enum::MANUAL_THREE' // gdbr-command:print c_style_enum::MANUAL_THREE -// gdbg-check:$7 = OneHundred // gdbr-check:$7 = c_style_enum::ManualDiscriminant::OneHundred // gdb-command:run // gdb-command:print auto_one -// gdbg-check:$8 = One // gdbr-check:$8 = c_style_enum::AutoDiscriminant::One // gdb-command:print auto_two -// gdbg-check:$9 = Two // gdbr-check:$9 = c_style_enum::AutoDiscriminant::Two // gdb-command:print auto_three -// gdbg-check:$10 = Three // gdbr-check:$10 = c_style_enum::AutoDiscriminant::Three // gdb-command:print manual_one_hundred -// gdbg-check:$11 = OneHundred // gdbr-check:$11 = c_style_enum::ManualDiscriminant::OneHundred // gdb-command:print manual_one_thousand -// gdbg-check:$12 = OneThousand // gdbr-check:$12 = c_style_enum::ManualDiscriminant::OneThousand // gdb-command:print manual_one_million -// gdbg-check:$13 = OneMillion // gdbr-check:$13 = c_style_enum::ManualDiscriminant::OneMillion // gdb-command:print single_variant -// gdbg-check:$14 = TheOnlyVariant // gdbr-check:$14 = c_style_enum::SingleVariant::TheOnlyVariant -// gdbg-command:print 'c_style_enum::AUTO_TWO' // gdbr-command:print AUTO_TWO -// gdbg-check:$15 = Two // gdbr-check:$15 = c_style_enum::AutoDiscriminant::Two -// gdbg-command:print 'c_style_enum::AUTO_THREE' // gdbr-command:print AUTO_THREE -// gdbg-check:$16 = Three // gdbr-check:$16 = c_style_enum::AutoDiscriminant::Three -// gdbg-command:print 'c_style_enum::MANUAL_TWO' // gdbr-command:print MANUAL_TWO -// gdbg-check:$17 = OneThousand // gdbr-check:$17 = c_style_enum::ManualDiscriminant::OneThousand -// gdbg-command:print 'c_style_enum::MANUAL_THREE' // gdbr-command:print MANUAL_THREE -// gdbg-check:$18 = OneMillion // gdbr-check:$18 = c_style_enum::ManualDiscriminant::OneMillion diff --git a/tests/debuginfo/cross-crate-spans.rs b/tests/debuginfo/cross-crate-spans.rs index a93c8f46930e..57e1e63bb8fb 100644 --- a/tests/debuginfo/cross-crate-spans.rs +++ b/tests/debuginfo/cross-crate-spans.rs @@ -15,7 +15,6 @@ extern crate cross_crate_spans; // gdb-command:run // gdb-command:print result -// gdbg-check:$1 = {__0 = 17, __1 = 17} // gdbr-check:$1 = (17, 17) // gdb-command:print a_variable // gdb-check:$2 = 123456789 @@ -24,7 +23,6 @@ extern crate cross_crate_spans; // gdb-command:continue // gdb-command:print result -// gdbg-check:$4 = {__0 = 1212, __1 = 1212} // gdbr-check:$4 = (1212, 1212) // gdb-command:print a_variable // gdb-check:$5 = 123456789 diff --git a/tests/debuginfo/destructured-fn-argument.rs b/tests/debuginfo/destructured-fn-argument.rs index 74e18a594d78..2ebf49ca881e 100644 --- a/tests/debuginfo/destructured-fn-argument.rs +++ b/tests/debuginfo/destructured-fn-argument.rs @@ -23,14 +23,12 @@ // gdb-command:print a // gdb-check:$6 = 5 // gdb-command:print b -// gdbg-check:$7 = {__0 = 6, __1 = 7} // gdbr-check:$7 = (6, 7) // gdb-command:continue // gdb-command:print h // gdb-check:$8 = 8 // gdb-command:print i -// gdbg-check:$9 = {a = 9, b = 10} // gdbr-check:$9 = destructured_fn_argument::Struct {a: 9, b: 10} // gdb-command:print j // gdb-check:$10 = 11 @@ -57,7 +55,6 @@ // gdb-command:print q // gdb-check:$17 = 20 // gdb-command:print r -// gdbg-check:$18 = {a = 21, b = 22} // gdbr-check:$18 = destructured_fn_argument::Struct {a: 21, b: 22} // gdb-command:continue @@ -88,12 +85,10 @@ // gdb-command:continue // gdb-command:print aa -// gdbg-check:$30 = {__0 = 34, __1 = 35} // gdbr-check:$30 = (34, 35) // gdb-command:continue // gdb-command:print bb -// gdbg-check:$31 = {__0 = 36, __1 = 37} // gdbr-check:$31 = (36, 37) // gdb-command:continue @@ -102,19 +97,16 @@ // gdb-command:continue // gdb-command:print dd -// gdbg-check:$33 = {__0 = 40, __1 = 41, __2 = 42} // gdbr-check:$33 = (40, 41, 42) // gdb-command:continue // gdb-command:print *ee -// gdbg-check:$34 = {__0 = 43, __1 = 44, __2 = 45} // gdbr-check:$34 = (43, 44, 45) // gdb-command:continue // gdb-command:print *ff // gdb-check:$35 = 46 // gdb-command:print gg -// gdbg-check:$36 = {__0 = 47, __1 = 48} // gdbr-check:$36 = (47, 48) // gdb-command:continue diff --git a/tests/debuginfo/destructured-for-loop-variable.rs b/tests/debuginfo/destructured-for-loop-variable.rs index a8c7cc1489f6..f6b10f998902 100644 --- a/tests/debuginfo/destructured-for-loop-variable.rs +++ b/tests/debuginfo/destructured-for-loop-variable.rs @@ -63,12 +63,10 @@ // gdb-command:continue // gdb-command:print simple_struct_ident -// gdbg-check:$23 = {x = 3537, y = 35437.5, z = true} // gdbr-check:$23 = destructured_for_loop_variable::Struct {x: 3537, y: 35437.5, z: true} // gdb-command:continue // gdb-command:print simple_tuple_ident -// gdbg-check:$24 = {__0 = 34903493, __1 = 232323} // gdbr-check:$24 = (34903493, 232323) // gdb-command:continue diff --git a/tests/debuginfo/destructured-local.rs b/tests/debuginfo/destructured-local.rs index 8d62fe5db031..d65b352e695f 100644 --- a/tests/debuginfo/destructured-local.rs +++ b/tests/debuginfo/destructured-local.rs @@ -21,13 +21,11 @@ // gdb-command:print f // gdb-check:$6 = 5 // gdb-command:print g -// gdbg-check:$7 = {__0 = 6, __1 = 7} // gdbr-check:$7 = (6, 7) // gdb-command:print h // gdb-check:$8 = 8 // gdb-command:print i -// gdbg-check:$9 = {a = 9, b = 10} // gdbr-check:$9 = destructured_local::Struct {a: 9, b: 10} // gdb-command:print j // gdb-check:$10 = 11 @@ -50,7 +48,6 @@ // gdb-command:print q // gdb-check:$17 = 20 // gdb-command:print r -// gdbg-check:$18 = {a = 21, b = 22} // gdbr-check:$18 = destructured_local::Struct {a: 21, b: 22} // gdb-command:print s @@ -78,29 +75,24 @@ // gdb-check:$29 = 33 // gdb-command:print aa -// gdbg-check:$30 = {__0 = 34, __1 = 35} // gdbr-check:$30 = (34, 35) // gdb-command:print bb -// gdbg-check:$31 = {__0 = 36, __1 = 37} // gdbr-check:$31 = (36, 37) // gdb-command:print cc // gdb-check:$32 = 38 // gdb-command:print dd -// gdbg-check:$33 = {__0 = 40, __1 = 41, __2 = 42} // gdbr-check:$33 = (40, 41, 42) // gdb-command:print *ee -// gdbg-check:$34 = {__0 = 43, __1 = 44, __2 = 45} // gdbr-check:$34 = (43, 44, 45) // gdb-command:print *ff // gdb-check:$35 = 46 // gdb-command:print gg -// gdbg-check:$36 = {__0 = 47, __1 = 48} // gdbr-check:$36 = (47, 48) // gdb-command:print *hh diff --git a/tests/debuginfo/evec-in-struct.rs b/tests/debuginfo/evec-in-struct.rs index 2283e96c0ad6..7e0dea0680bc 100644 --- a/tests/debuginfo/evec-in-struct.rs +++ b/tests/debuginfo/evec-in-struct.rs @@ -7,22 +7,17 @@ // gdb-command:run // gdb-command:print no_padding1 -// gdbg-check:$1 = {x = {0, 1, 2}, y = -3, z = {4.5, 5.5}} // gdbr-check:$1 = evec_in_struct::NoPadding1 {x: [0, 1, 2], y: -3, z: [4.5, 5.5]} // gdb-command:print no_padding2 -// gdbg-check:$2 = {x = {6, 7, 8}, y = {{9, 10}, {11, 12}}} // gdbr-check:$2 = evec_in_struct::NoPadding2 {x: [6, 7, 8], y: [[9, 10], [11, 12]]} // gdb-command:print struct_internal_padding -// gdbg-check:$3 = {x = {13, 14}, y = {15, 16}} // gdbr-check:$3 = evec_in_struct::StructInternalPadding {x: [13, 14], y: [15, 16]} // gdb-command:print single_vec -// gdbg-check:$4 = {x = {17, 18, 19, 20, 21}} // gdbr-check:$4 = evec_in_struct::SingleVec {x: [17, 18, 19, 20, 21]} // gdb-command:print struct_padded_at_end -// gdbg-check:$5 = {x = {22, 23}, y = {24, 25}} // gdbr-check:$5 = evec_in_struct::StructPaddedAtEnd {x: [22, 23], y: [24, 25]} diff --git a/tests/debuginfo/function-arg-initialization.rs b/tests/debuginfo/function-arg-initialization.rs index c641a35c9a58..ae54d56623c6 100644 --- a/tests/debuginfo/function-arg-initialization.rs +++ b/tests/debuginfo/function-arg-initialization.rs @@ -24,10 +24,8 @@ // NON IMMEDIATE ARGS // gdb-command:print a -// gdbg-check:$4 = {a = 3, b = 4, c = 5, d = 6, e = 7, f = 8, g = 9, h = 10} // gdbt-check:$4 = function_arg_initialization::BigStruct {a: 3, b: 4, c: 5, d: 6, e: 7, f: 8, g: 9, h: 10} // gdb-command:print b -// gdbg-check:$5 = {a = 11, b = 12, c = 13, d = 14, e = 15, f = 16, g = 17, h = 18} // gdbt-check:$5 = function_arg_initialization::BigStruct {a: 11, b: 12, c: 13, d: 14, e: 15, f: 16, g: 17, h: 18} // gdb-command:continue diff --git a/tests/debuginfo/gdb-pretty-struct-and-enums.rs b/tests/debuginfo/gdb-pretty-struct-and-enums.rs index 235295e887c2..5b6977fdd5bc 100644 --- a/tests/debuginfo/gdb-pretty-struct-and-enums.rs +++ b/tests/debuginfo/gdb-pretty-struct-and-enums.rs @@ -7,23 +7,18 @@ // gdb-command: run // gdb-command: print regular_struct -// gdbg-check:$1 = {the_first_field = 101, the_second_field = 102.5, the_third_field = false} // gdbr-check:$1 = gdb_pretty_struct_and_enums::RegularStruct {the_first_field: 101, the_second_field: 102.5, the_third_field: false} // gdb-command: print empty_struct -// gdbg-check:$2 = EmptyStruct // gdbr-check:$2 = gdb_pretty_struct_and_enums::EmptyStruct // gdb-command: print c_style_enum1 -// gdbg-check:$3 = CStyleEnumVar1 // gdbr-check:$3 = gdb_pretty_struct_and_enums::CStyleEnum::CStyleEnumVar1 // gdb-command: print c_style_enum2 -// gdbg-check:$4 = CStyleEnumVar2 // gdbr-check:$4 = gdb_pretty_struct_and_enums::CStyleEnum::CStyleEnumVar2 // gdb-command: print c_style_enum3 -// gdbg-check:$5 = CStyleEnumVar3 // gdbr-check:$5 = gdb_pretty_struct_and_enums::CStyleEnum::CStyleEnumVar3 #![allow(dead_code, unused_variables)] diff --git a/tests/debuginfo/generic-function.rs b/tests/debuginfo/generic-function.rs index e131ebfa306e..7378a5960f30 100644 --- a/tests/debuginfo/generic-function.rs +++ b/tests/debuginfo/generic-function.rs @@ -21,7 +21,6 @@ // gdb-command:print *t0 // gdb-check:$5 = 5 // gdb-command:print *t1 -// gdbg-check:$6 = {a = 6, b = 7.5} // gdbr-check:$6 = generic_function::Struct {a: 6, b: 7.5} // gdb-command:continue diff --git a/tests/debuginfo/generic-method-on-generic-struct.rs b/tests/debuginfo/generic-method-on-generic-struct.rs index 0f7067404103..0b7bee53daba 100644 --- a/tests/debuginfo/generic-method-on-generic-struct.rs +++ b/tests/debuginfo/generic-method-on-generic-struct.rs @@ -10,7 +10,6 @@ // STACK BY REF // gdb-command:print *self -// gdbg-check:$1 = {x = {__0 = 8888, __1 = -8888}} // gdbr-check:$1 = generic_method_on_generic_struct::Struct<(u32, i32)> {x: (8888, -8888)} // gdb-command:print arg1 // gdb-check:$2 = -1 @@ -20,7 +19,6 @@ // STACK BY VAL // gdb-command:print self -// gdbg-check:$4 = {x = {__0 = 8888, __1 = -8888}} // gdbr-check:$4 = generic_method_on_generic_struct::Struct<(u32, i32)> {x: (8888, -8888)} // gdb-command:print arg1 // gdb-check:$5 = -3 @@ -30,7 +28,6 @@ // OWNED BY REF // gdb-command:print *self -// gdbg-check:$7 = {x = 1234.5} // gdbr-check:$7 = generic_method_on_generic_struct::Struct {x: 1234.5} // gdb-command:print arg1 // gdb-check:$8 = -5 @@ -40,7 +37,6 @@ // OWNED BY VAL // gdb-command:print self -// gdbg-check:$10 = {x = 1234.5} // gdbr-check:$10 = generic_method_on_generic_struct::Struct {x: 1234.5} // gdb-command:print arg1 // gdb-check:$11 = -7 @@ -50,7 +46,6 @@ // OWNED MOVED // gdb-command:print *self -// gdbg-check:$13 = {x = 1234.5} // gdbr-check:$13 = generic_method_on_generic_struct::Struct {x: 1234.5} // gdb-command:print arg1 // gdb-check:$14 = -9 diff --git a/tests/debuginfo/generic-struct.rs b/tests/debuginfo/generic-struct.rs index 8c74aa42d2ca..7a0caf280a4b 100644 --- a/tests/debuginfo/generic-struct.rs +++ b/tests/debuginfo/generic-struct.rs @@ -9,16 +9,12 @@ // gdb-command:run // gdb-command:print int_int -// gdbg-check:$1 = {key = 0, value = 1} // gdbr-check:$1 = generic_struct::AGenericStruct {key: 0, value: 1} // gdb-command:print int_float -// gdbg-check:$2 = {key = 2, value = 3.5} // gdbr-check:$2 = generic_struct::AGenericStruct {key: 2, value: 3.5} // gdb-command:print float_int -// gdbg-check:$3 = {key = 4.5, value = 5} // gdbr-check:$3 = generic_struct::AGenericStruct {key: 4.5, value: 5} // gdb-command:print float_int_float -// gdbg-check:$4 = {key = 6.5, value = {key = 7, value = 8.5}} // gdbr-check:$4 = generic_struct::AGenericStruct> {key: 6.5, value: generic_struct::AGenericStruct {key: 7, value: 8.5}} // === LLDB TESTS ================================================================================== diff --git a/tests/debuginfo/lexical-scopes-in-block-expression.rs b/tests/debuginfo/lexical-scopes-in-block-expression.rs index bd5a607586dc..62a9ec0d19d1 100644 --- a/tests/debuginfo/lexical-scopes-in-block-expression.rs +++ b/tests/debuginfo/lexical-scopes-in-block-expression.rs @@ -6,7 +6,6 @@ // gdb-command:run -// gdbg-command:print 'lexical_scopes_in_block_expression::MUT_INT' // gdbr-command:print lexical_scopes_in_block_expression::MUT_INT // gdb-check:$1 = 0 @@ -19,7 +18,6 @@ // gdb-command:print val // gdb-check:$4 = 11 -// gdbg-command:print 'lexical_scopes_in_block_expression::MUT_INT' // gdbr-command:print lexical_scopes_in_block_expression::MUT_INT // gdb-check:$5 = 1 // gdb-command:print ten @@ -41,7 +39,6 @@ // gdb-command:print val // gdb-check:$11 = 12 -// gdbg-command:print 'lexical_scopes_in_block_expression::MUT_INT' // gdbr-command:print lexical_scopes_in_block_expression::MUT_INT // gdb-check:$12 = 2 // gdb-command:print ten @@ -63,7 +60,6 @@ // gdb-command:print val // gdb-check:$18 = 13 -// gdbg-command:print 'lexical_scopes_in_block_expression::MUT_INT' // gdbr-command:print lexical_scopes_in_block_expression::MUT_INT // gdb-check:$19 = 3 // gdb-command:print ten @@ -85,7 +81,6 @@ // gdb-command:print val // gdb-check:$25 = 14 -// gdbg-command:print 'lexical_scopes_in_block_expression::MUT_INT' // gdbr-command:print lexical_scopes_in_block_expression::MUT_INT // gdb-check:$26 = 4 // gdb-command:print ten @@ -107,7 +102,6 @@ // gdb-command:print val // gdb-check:$32 = 15 -// gdbg-command:print 'lexical_scopes_in_block_expression::MUT_INT' // gdbr-command:print lexical_scopes_in_block_expression::MUT_INT // gdb-check:$33 = 5 // gdb-command:print ten @@ -129,7 +123,6 @@ // gdb-command:print val // gdb-check:$39 = 16 -// gdbg-command:print 'lexical_scopes_in_block_expression::MUT_INT' // gdbr-command:print lexical_scopes_in_block_expression::MUT_INT // gdb-check:$40 = 6 // gdb-command:print ten @@ -152,7 +145,6 @@ // gdb-command:print val // gdb-check:$46 = 17 -// gdbg-command:print 'lexical_scopes_in_block_expression::MUT_INT' // gdbr-command:print lexical_scopes_in_block_expression::MUT_INT // gdb-check:$47 = 7 // gdb-command:print ten @@ -174,7 +166,6 @@ // gdb-command:print val // gdb-check:$53 = 18 -// gdbg-command:print 'lexical_scopes_in_block_expression::MUT_INT' // gdbr-command:print lexical_scopes_in_block_expression::MUT_INT // gdb-check:$54 = 8 // gdb-command:print ten diff --git a/tests/debuginfo/limited-debuginfo.rs b/tests/debuginfo/limited-debuginfo.rs index 2e49acd24017..e82e8e26aca7 100644 --- a/tests/debuginfo/limited-debuginfo.rs +++ b/tests/debuginfo/limited-debuginfo.rs @@ -4,13 +4,9 @@ // Make sure functions have proper names // gdb-command:info functions -// gdbg-check:[...]void[...]main([...]); // gdbr-check:fn limited_debuginfo::main(); -// gdbg-check:[...]void[...]some_function([...]); // gdbr-check:fn limited_debuginfo::some_function(); -// gdbg-check:[...]void[...]some_other_function([...]); // gdbr-check:fn limited_debuginfo::some_other_function(); -// gdbg-check:[...]void[...]zzz([...]); // gdbr-check:fn limited_debuginfo::zzz(); // gdb-command:run diff --git a/tests/debuginfo/method-on-enum.rs b/tests/debuginfo/method-on-enum.rs index 7bee54451aa9..1d447686b000 100644 --- a/tests/debuginfo/method-on-enum.rs +++ b/tests/debuginfo/method-on-enum.rs @@ -9,7 +9,6 @@ // STACK BY REF // gdb-command:print *self -// gdbg-check:$1 = {{RUST$ENUM$DISR = Variant2, [...]}, {RUST$ENUM$DISR = Variant2, __0 = 117901063}} // gdbr-check:$1 = method_on_enum::Enum::Variant2(117901063) // gdb-command:print arg1 // gdb-check:$2 = -1 @@ -19,7 +18,6 @@ // STACK BY VAL // gdb-command:print self -// gdbg-check:$4 = {{RUST$ENUM$DISR = Variant2, [...]}, {RUST$ENUM$DISR = Variant2, __0 = 117901063}} // gdbr-check:$4 = method_on_enum::Enum::Variant2(117901063) // gdb-command:print arg1 // gdb-check:$5 = -3 @@ -29,7 +27,6 @@ // OWNED BY REF // gdb-command:print *self -// gdbg-check:$7 = {{RUST$ENUM$DISR = Variant1, x = 1799, y = 1799}, {RUST$ENUM$DISR = Variant1, [...]}} // gdbr-check:$7 = method_on_enum::Enum::Variant1{x: 1799, y: 1799} // gdb-command:print arg1 // gdb-check:$8 = -5 @@ -39,7 +36,6 @@ // OWNED BY VAL // gdb-command:print self -// gdbg-check:$10 = {{RUST$ENUM$DISR = Variant1, x = 1799, y = 1799}, {RUST$ENUM$DISR = Variant1, [...]}} // gdbr-check:$10 = method_on_enum::Enum::Variant1{x: 1799, y: 1799} // gdb-command:print arg1 // gdb-check:$11 = -7 @@ -49,7 +45,6 @@ // OWNED MOVED // gdb-command:print *self -// gdbg-check:$13 = {{RUST$ENUM$DISR = Variant1, x = 1799, y = 1799}, {RUST$ENUM$DISR = Variant1, [...]}} // gdbr-check:$13 = method_on_enum::Enum::Variant1{x: 1799, y: 1799} // gdb-command:print arg1 // gdb-check:$14 = -9 diff --git a/tests/debuginfo/method-on-generic-struct.rs b/tests/debuginfo/method-on-generic-struct.rs index 64ef0e6bb0c3..d8f5508090d5 100644 --- a/tests/debuginfo/method-on-generic-struct.rs +++ b/tests/debuginfo/method-on-generic-struct.rs @@ -10,7 +10,6 @@ // STACK BY REF // gdb-command:print *self -// gdbg-check:$1 = {x = {__0 = 8888, __1 = -8888}} // gdbr-check:$1 = method_on_generic_struct::Struct<(u32, i32)> {x: (8888, -8888)} // gdb-command:print arg1 // gdb-check:$2 = -1 @@ -20,7 +19,6 @@ // STACK BY VAL // gdb-command:print self -// gdbg-check:$4 = {x = {__0 = 8888, __1 = -8888}} // gdbr-check:$4 = method_on_generic_struct::Struct<(u32, i32)> {x: (8888, -8888)} // gdb-command:print arg1 // gdb-check:$5 = -3 @@ -30,7 +28,6 @@ // OWNED BY REF // gdb-command:print *self -// gdbg-check:$7 = {x = 1234.5} // gdbr-check:$7 = method_on_generic_struct::Struct {x: 1234.5} // gdb-command:print arg1 // gdb-check:$8 = -5 @@ -40,7 +37,6 @@ // OWNED BY VAL // gdb-command:print self -// gdbg-check:$10 = {x = 1234.5} // gdbr-check:$10 = method_on_generic_struct::Struct {x: 1234.5} // gdb-command:print arg1 // gdb-check:$11 = -7 @@ -50,7 +46,6 @@ // OWNED MOVED // gdb-command:print *self -// gdbg-check:$13 = {x = 1234.5} // gdbr-check:$13 = method_on_generic_struct::Struct {x: 1234.5} // gdb-command:print arg1 // gdb-check:$14 = -9 diff --git a/tests/debuginfo/method-on-struct.rs b/tests/debuginfo/method-on-struct.rs index a4129af54290..c2632dafc394 100644 --- a/tests/debuginfo/method-on-struct.rs +++ b/tests/debuginfo/method-on-struct.rs @@ -8,7 +8,6 @@ // STACK BY REF // gdb-command:print *self -// gdbg-check:$1 = {x = 100} // gdbr-check:$1 = method_on_struct::Struct {x: 100} // gdb-command:print arg1 // gdb-check:$2 = -1 @@ -18,7 +17,6 @@ // STACK BY VAL // gdb-command:print self -// gdbg-check:$4 = {x = 100} // gdbr-check:$4 = method_on_struct::Struct {x: 100} // gdb-command:print arg1 // gdb-check:$5 = -3 @@ -28,7 +26,6 @@ // OWNED BY REF // gdb-command:print *self -// gdbg-check:$7 = {x = 200} // gdbr-check:$7 = method_on_struct::Struct {x: 200} // gdb-command:print arg1 // gdb-check:$8 = -5 @@ -38,7 +35,6 @@ // OWNED BY VAL // gdb-command:print self -// gdbg-check:$10 = {x = 200} // gdbr-check:$10 = method_on_struct::Struct {x: 200} // gdb-command:print arg1 // gdb-check:$11 = -7 @@ -48,7 +44,6 @@ // OWNED MOVED // gdb-command:print *self -// gdbg-check:$13 = {x = 200} // gdbr-check:$13 = method_on_struct::Struct {x: 200} // gdb-command:print arg1 // gdb-check:$14 = -9 diff --git a/tests/debuginfo/method-on-trait.rs b/tests/debuginfo/method-on-trait.rs index 0934c267ab13..9172c6976a1a 100644 --- a/tests/debuginfo/method-on-trait.rs +++ b/tests/debuginfo/method-on-trait.rs @@ -8,7 +8,6 @@ // STACK BY REF // gdb-command:print *self -// gdbg-check:$1 = {x = 100} // gdbr-check:$1 = method_on_trait::Struct {x: 100} // gdb-command:print arg1 // gdb-check:$2 = -1 @@ -18,7 +17,6 @@ // STACK BY VAL // gdb-command:print self -// gdbg-check:$4 = {x = 100} // gdbr-check:$4 = method_on_trait::Struct {x: 100} // gdb-command:print arg1 // gdb-check:$5 = -3 @@ -28,7 +26,6 @@ // OWNED BY REF // gdb-command:print *self -// gdbg-check:$7 = {x = 200} // gdbr-check:$7 = method_on_trait::Struct {x: 200} // gdb-command:print arg1 // gdb-check:$8 = -5 @@ -38,7 +35,6 @@ // OWNED BY VAL // gdb-command:print self -// gdbg-check:$10 = {x = 200} // gdbr-check:$10 = method_on_trait::Struct {x: 200} // gdb-command:print arg1 // gdb-check:$11 = -7 @@ -48,7 +44,6 @@ // OWNED MOVED // gdb-command:print *self -// gdbg-check:$13 = {x = 200} // gdbr-check:$13 = method_on_trait::Struct {x: 200} // gdb-command:print arg1 // gdb-check:$14 = -9 diff --git a/tests/debuginfo/method-on-tuple-struct.rs b/tests/debuginfo/method-on-tuple-struct.rs index 9cf9c6d7fbae..71a11093f7d3 100644 --- a/tests/debuginfo/method-on-tuple-struct.rs +++ b/tests/debuginfo/method-on-tuple-struct.rs @@ -8,7 +8,6 @@ // STACK BY REF // gdb-command:print *self -// gdbg-check:$1 = {__0 = 100, __1 = -100.5} // gdbr-check:$1 = method_on_tuple_struct::TupleStruct (100, -100.5) // gdb-command:print arg1 // gdb-check:$2 = -1 @@ -18,7 +17,6 @@ // STACK BY VAL // gdb-command:print self -// gdbg-check:$4 = {__0 = 100, __1 = -100.5} // gdbr-check:$4 = method_on_tuple_struct::TupleStruct (100, -100.5) // gdb-command:print arg1 // gdb-check:$5 = -3 @@ -28,7 +26,6 @@ // OWNED BY REF // gdb-command:print *self -// gdbg-check:$7 = {__0 = 200, __1 = -200.5} // gdbr-check:$7 = method_on_tuple_struct::TupleStruct (200, -200.5) // gdb-command:print arg1 // gdb-check:$8 = -5 @@ -38,7 +35,6 @@ // OWNED BY VAL // gdb-command:print self -// gdbg-check:$10 = {__0 = 200, __1 = -200.5} // gdbr-check:$10 = method_on_tuple_struct::TupleStruct (200, -200.5) // gdb-command:print arg1 // gdb-check:$11 = -7 @@ -48,7 +44,6 @@ // OWNED MOVED // gdb-command:print *self -// gdbg-check:$13 = {__0 = 200, __1 = -200.5} // gdbr-check:$13 = method_on_tuple_struct::TupleStruct (200, -200.5) // gdb-command:print arg1 // gdb-check:$14 = -9 diff --git a/tests/debuginfo/option-like-enum.rs b/tests/debuginfo/option-like-enum.rs index da556d613d08..159d8e976c7c 100644 --- a/tests/debuginfo/option-like-enum.rs +++ b/tests/debuginfo/option-like-enum.rs @@ -8,35 +8,27 @@ // gdb-command:run // gdb-command:print some -// gdbg-check:$1 = {RUST$ENCODED$ENUM$0$None = {__0 = 0x12345678}} // gdbr-check:$1 = core::option::Option<&u32>::Some(0x12345678) // gdb-command:print none -// gdbg-check:$2 = {RUST$ENCODED$ENUM$0$None = {__0 = 0x0}} // gdbr-check:$2 = core::option::Option<&u32>::None // gdb-command:print full -// gdbg-check:$3 = {RUST$ENCODED$ENUM$1$Empty = {__0 = 454545, __1 = 0x87654321, __2 = 9988}} // gdbr-check:$3 = option_like_enum::MoreFields::Full(454545, 0x87654321, 9988) -// gdbg-command:print empty_gdb->discr // gdbr-command:print empty_gdb.discr // gdb-check:$4 = (*mut isize) 0x1 // gdb-command:print droid -// gdbg-check:$5 = {RUST$ENCODED$ENUM$2$Void = {id = 675675, range = 10000001, internals = 0x43218765}} // gdbr-check:$5 = option_like_enum::NamedFields::Droid{id: 675675, range: 10000001, internals: 0x43218765} -// gdbg-command:print void_droid_gdb->internals // gdbr-command:print void_droid_gdb.internals // gdb-check:$6 = (*mut isize) 0x1 // gdb-command:print nested_non_zero_yep -// gdbg-check:$7 = {RUST$ENCODED$ENUM$1$2$Nope = {__0 = 10.5, __1 = {a = 10, b = 20, c = [...]}}} // gdbr-check:$7 = option_like_enum::NestedNonZero::Yep(10.5, option_like_enum::NestedNonZeroField {a: 10, b: 20, c: 0x[...]}) // gdb-command:print nested_non_zero_nope -// gdbg-check:$8 = {RUST$ENCODED$ENUM$1$2$Nope = {__0 = [...], __1 = {a = [...], b = [...], c = 0x0}}} // gdbr-check:$8 = option_like_enum::NestedNonZero::Nope // gdb-command:continue diff --git a/tests/debuginfo/packed-struct-with-destructor.rs b/tests/debuginfo/packed-struct-with-destructor.rs index f9bac8443762..afd0d570b0b3 100644 --- a/tests/debuginfo/packed-struct-with-destructor.rs +++ b/tests/debuginfo/packed-struct-with-destructor.rs @@ -7,36 +7,28 @@ // gdb-command:run // gdb-command:print packed -// gdbg-check:$1 = {x = 123, y = 234, z = 345} // gdbr-check:$1 = packed_struct_with_destructor::Packed {x: 123, y: 234, z: 345} // gdb-command:print packedInPacked -// gdbg-check:$2 = {a = 1111, b = {x = 2222, y = 3333, z = 4444}, c = 5555, d = {x = 6666, y = 7777, z = 8888}} // gdbr-check:$2 = packed_struct_with_destructor::PackedInPacked {a: 1111, b: packed_struct_with_destructor::Packed {x: 2222, y: 3333, z: 4444}, c: 5555, d: packed_struct_with_destructor::Packed {x: 6666, y: 7777, z: 8888}} // gdb-command:print packedInUnpacked -// gdbg-check:$3 = {a = -1111, b = {x = -2222, y = -3333, z = -4444}, c = -5555, d = {x = -6666, y = -7777, z = -8888}} // gdbr-check:$3 = packed_struct_with_destructor::PackedInUnpacked {a: -1111, b: packed_struct_with_destructor::Packed {x: -2222, y: -3333, z: -4444}, c: -5555, d: packed_struct_with_destructor::Packed {x: -6666, y: -7777, z: -8888}} // gdb-command:print unpackedInPacked -// gdbg-check:$4 = {a = 987, b = {x = 876, y = 765, z = 654}, c = {x = 543, y = 432, z = 321}, d = 210} // gdbr-check:$4 = packed_struct_with_destructor::UnpackedInPacked {a: 987, b: packed_struct_with_destructor::Unpacked {x: 876, y: 765, z: 654}, c: packed_struct_with_destructor::Unpacked {x: 543, y: 432, z: 321}, d: 210} // gdb-command:print packedInPackedWithDrop -// gdbg-check:$5 = {a = 11, b = {x = 22, y = 33, z = 44}, c = 55, d = {x = 66, y = 77, z = 88}} // gdbr-check:$5 = packed_struct_with_destructor::PackedInPackedWithDrop {a: 11, b: packed_struct_with_destructor::Packed {x: 22, y: 33, z: 44}, c: 55, d: packed_struct_with_destructor::Packed {x: 66, y: 77, z: 88}} // gdb-command:print packedInUnpackedWithDrop -// gdbg-check:$6 = {a = -11, b = {x = -22, y = -33, z = -44}, c = -55, d = {x = -66, y = -77, z = -88}} // gdbr-check:$6 = packed_struct_with_destructor::PackedInUnpackedWithDrop {a: -11, b: packed_struct_with_destructor::Packed {x: -22, y: -33, z: -44}, c: -55, d: packed_struct_with_destructor::Packed {x: -66, y: -77, z: -88}} // gdb-command:print unpackedInPackedWithDrop -// gdbg-check:$7 = {a = 98, b = {x = 87, y = 76, z = 65}, c = {x = 54, y = 43, z = 32}, d = 21} // gdbr-check:$7 = packed_struct_with_destructor::UnpackedInPackedWithDrop {a: 98, b: packed_struct_with_destructor::Unpacked {x: 87, y: 76, z: 65}, c: packed_struct_with_destructor::Unpacked {x: 54, y: 43, z: 32}, d: 21} // gdb-command:print deeplyNested -// gdbg-check:$8 = {a = {a = 1, b = {x = 2, y = 3, z = 4}, c = 5, d = {x = 6, y = 7, z = 8}}, b = {a = 9, b = {x = 10, y = 11, z = 12}, c = {x = 13, y = 14, z = 15}, d = 16}, c = {a = 17, b = {x = 18, y = 19, z = 20}, c = 21, d = {x = 22, y = 23, z = 24}}, d = {a = 25, b = {x = 26, y = 27, z = 28}, c = 29, d = {x = 30, y = 31, z = 32}}, e = {a = 33, b = {x = 34, y = 35, z = 36}, c = {x = 37, y = 38, z = 39}, d = 40}, f = {a = 41, b = {x = 42, y = 43, z = 44}, c = 45, d = {x = 46, y = 47, z = 48}}} // gdbr-check:$8 = packed_struct_with_destructor::DeeplyNested {a: packed_struct_with_destructor::PackedInPacked {a: 1, b: packed_struct_with_destructor::Packed {x: 2, y: 3, z: 4}, c: 5, d: packed_struct_with_destructor::Packed {x: 6, y: 7, z: 8}}, b: packed_struct_with_destructor::UnpackedInPackedWithDrop {a: 9, b: packed_struct_with_destructor::Unpacked {x: 10, y: 11, z: 12}, c: packed_struct_with_destructor::Unpacked {x: 13, y: 14, z: 15}, d: 16}, c: packed_struct_with_destructor::PackedInUnpacked {a: 17, b: packed_struct_with_destructor::Packed {x: 18, y: 19, z: 20}, c: 21, d: packed_struct_with_destructor::Packed {x: 22, y: 23, z: 24}}, d: packed_struct_with_destructor::PackedInUnpackedWithDrop {a: 25, b: packed_struct_with_destructor::Packed {x: 26, y: 27, z: 28}, c: 29, d: packed_struct_with_destructor::Packed {x: 30, y: 31, z: 32}}, e: packed_struct_with_destructor::UnpackedInPacked {a: 33, b: packed_struct_with_destructor::Unpacked {x: 34, y: 35, z: 36}, c: packed_struct_with_destructor::Unpacked {x: 37, y: 38, z: 39}, d: 40}, f: packed_struct_with_destructor::PackedInPackedWithDrop {a: 41, b: packed_struct_with_destructor::Packed {x: 42, y: 43, z: 44}, c: 45, d: packed_struct_with_destructor::Packed {x: 46, y: 47, z: 48}}} diff --git a/tests/debuginfo/packed-struct.rs b/tests/debuginfo/packed-struct.rs index ea9aa22ba550..6ef4995bc16d 100644 --- a/tests/debuginfo/packed-struct.rs +++ b/tests/debuginfo/packed-struct.rs @@ -8,19 +8,15 @@ // gdb-command:run // gdb-command:print packed -// gdbg-check:$1 = {x = 123, y = 234, z = 345} // gdbr-check:$1 = packed_struct::Packed {x: 123, y: 234, z: 345} // gdb-command:print packedInPacked -// gdbg-check:$2 = {a = 1111, b = {x = 2222, y = 3333, z = 4444}, c = 5555, d = {x = 6666, y = 7777, z = 8888}} // gdbr-check:$2 = packed_struct::PackedInPacked {a: 1111, b: packed_struct::Packed {x: 2222, y: 3333, z: 4444}, c: 5555, d: packed_struct::Packed {x: 6666, y: 7777, z: 8888}} // gdb-command:print packedInUnpacked -// gdbg-check:$3 = {a = -1111, b = {x = -2222, y = -3333, z = -4444}, c = -5555, d = {x = -6666, y = -7777, z = -8888}} // gdbr-check:$3 = packed_struct::PackedInUnpacked {a: -1111, b: packed_struct::Packed {x: -2222, y: -3333, z: -4444}, c: -5555, d: packed_struct::Packed {x: -6666, y: -7777, z: -8888}} // gdb-command:print unpackedInPacked -// gdbg-check:$4 = {a = 987, b = {x = 876, y = 765, z = 654, w = 543}, c = {x = 432, y = 321, z = 210, w = 109}, d = -98} // gdbr-check:$4 = packed_struct::UnpackedInPacked {a: 987, b: packed_struct::Unpacked {x: 876, y: 765, z: 654, w: 543}, c: packed_struct::Unpacked {x: 432, y: 321, z: 210, w: 109}, d: -98} // gdb-command:print sizeof(packed) diff --git a/tests/debuginfo/pretty-slices.rs b/tests/debuginfo/pretty-slices.rs index 44335f5c83b3..90cad4e6639e 100644 --- a/tests/debuginfo/pretty-slices.rs +++ b/tests/debuginfo/pretty-slices.rs @@ -5,11 +5,9 @@ // gdb-command: run // gdb-command: print slice -// gdbg-check: $1 = struct &[i32](size=3) = {0, 1, 2} // gdbr-check: $1 = &[i32](size=3) = {0, 1, 2} // gdb-command: print mut_slice -// gdbg-check: $2 = struct &mut [i32](size=4) = {2, 3, 5, 7} // gdbr-check: $2 = &mut [i32](size=4) = {2, 3, 5, 7} // gdb-command: print str_slice diff --git a/tests/debuginfo/pretty-std.rs b/tests/debuginfo/pretty-std.rs index 933be9772343..c42bdc5ee3fc 100644 --- a/tests/debuginfo/pretty-std.rs +++ b/tests/debuginfo/pretty-std.rs @@ -26,7 +26,6 @@ // gdb-check:$5 = core::option::Option::Some(8) // gdb-command: print none -// gdbg-check:$6 = None // gdbr-check:$6 = core::option::Option::None // gdb-command: print os_string diff --git a/tests/debuginfo/reference-debuginfo.rs b/tests/debuginfo/reference-debuginfo.rs index e2fb964ace52..d59cf61420f2 100644 --- a/tests/debuginfo/reference-debuginfo.rs +++ b/tests/debuginfo/reference-debuginfo.rs @@ -18,7 +18,6 @@ // gdb-check:$3 = 97 // gdb-command:print *i8_ref -// gdbg-check:$4 = 68 'D' // gdbr-check:$4 = 68 // gdb-command:print *i16_ref @@ -34,7 +33,6 @@ // gdb-check:$8 = 1 // gdb-command:print *u8_ref -// gdbg-check:$9 = 100 'd' // gdbr-check:$9 = 100 // gdb-command:print *u16_ref diff --git a/tests/debuginfo/self-in-default-method.rs b/tests/debuginfo/self-in-default-method.rs index 374951475fc0..89e1a8fab2b9 100644 --- a/tests/debuginfo/self-in-default-method.rs +++ b/tests/debuginfo/self-in-default-method.rs @@ -8,7 +8,6 @@ // STACK BY REF // gdb-command:print *self -// gdbg-check:$1 = {x = 100} // gdbr-check:$1 = self_in_default_method::Struct {x: 100} // gdb-command:print arg1 // gdb-check:$2 = -1 @@ -18,7 +17,6 @@ // STACK BY VAL // gdb-command:print self -// gdbg-check:$4 = {x = 100} // gdbr-check:$4 = self_in_default_method::Struct {x: 100} // gdb-command:print arg1 // gdb-check:$5 = -3 @@ -28,7 +26,6 @@ // OWNED BY REF // gdb-command:print *self -// gdbg-check:$7 = {x = 200} // gdbr-check:$7 = self_in_default_method::Struct {x: 200} // gdb-command:print arg1 // gdb-check:$8 = -5 @@ -38,7 +35,6 @@ // OWNED BY VAL // gdb-command:print self -// gdbg-check:$10 = {x = 200} // gdbr-check:$10 = self_in_default_method::Struct {x: 200} // gdb-command:print arg1 // gdb-check:$11 = -7 @@ -48,7 +44,6 @@ // OWNED MOVED // gdb-command:print *self -// gdbg-check:$13 = {x = 200} // gdbr-check:$13 = self_in_default_method::Struct {x: 200} // gdb-command:print arg1 // gdb-check:$14 = -9 diff --git a/tests/debuginfo/self-in-generic-default-method.rs b/tests/debuginfo/self-in-generic-default-method.rs index 4759ca3ecdc0..b4908486cdf8 100644 --- a/tests/debuginfo/self-in-generic-default-method.rs +++ b/tests/debuginfo/self-in-generic-default-method.rs @@ -8,7 +8,6 @@ // STACK BY REF // gdb-command:print *self -// gdbg-check:$1 = {x = 987} // gdbr-check:$1 = self_in_generic_default_method::Struct {x: 987} // gdb-command:print arg1 // gdb-check:$2 = -1 @@ -18,7 +17,6 @@ // STACK BY VAL // gdb-command:print self -// gdbg-check:$4 = {x = 987} // gdbr-check:$4 = self_in_generic_default_method::Struct {x: 987} // gdb-command:print arg1 // gdb-check:$5 = -3 @@ -28,7 +26,6 @@ // OWNED BY REF // gdb-command:print *self -// gdbg-check:$7 = {x = 879} // gdbr-check:$7 = self_in_generic_default_method::Struct {x: 879} // gdb-command:print arg1 // gdb-check:$8 = -5 @@ -38,7 +35,6 @@ // OWNED BY VAL // gdb-command:print self -// gdbg-check:$10 = {x = 879} // gdbr-check:$10 = self_in_generic_default_method::Struct {x: 879} // gdb-command:print arg1 // gdb-check:$11 = -7 @@ -48,7 +44,6 @@ // OWNED MOVED // gdb-command:print *self -// gdbg-check:$13 = {x = 879} // gdbr-check:$13 = self_in_generic_default_method::Struct {x: 879} // gdb-command:print arg1 // gdb-check:$14 = -9 diff --git a/tests/debuginfo/simd.rs b/tests/debuginfo/simd.rs index a5dd2e61a8de..44a3efee3913 100644 --- a/tests/debuginfo/simd.rs +++ b/tests/debuginfo/simd.rs @@ -9,45 +9,27 @@ //@ compile-flags:-g // gdb-command:run -// gdbg-command:print/d vi8x16 // gdbr-command:print vi8x16 -// gdbg-check:$1 = {__0 = 0, __1 = 1, __2 = 2, __3 = 3, __4 = 4, __5 = 5, __6 = 6, __7 = 7, __8 = 8, __9 = 9, __10 = 10, __11 = 11, __12 = 12, __13 = 13, __14 = 14, __15 = 15} // gdbr-check:$1 = simd::i8x16 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15) -// gdbg-command:print/d vi16x8 // gdbr-command:print vi16x8 -// gdbg-check:$2 = {__0 = 16, __1 = 17, __2 = 18, __3 = 19, __4 = 20, __5 = 21, __6 = 22, __7 = 23} // gdbr-check:$2 = simd::i16x8 (16, 17, 18, 19, 20, 21, 22, 23) -// gdbg-command:print/d vi32x4 // gdbr-command:print vi32x4 -// gdbg-check:$3 = {__0 = 24, __1 = 25, __2 = 26, __3 = 27} // gdbr-check:$3 = simd::i32x4 (24, 25, 26, 27) -// gdbg-command:print/d vi64x2 // gdbr-command:print vi64x2 -// gdbg-check:$4 = {__0 = 28, __1 = 29} // gdbr-check:$4 = simd::i64x2 (28, 29) -// gdbg-command:print/d vu8x16 // gdbr-command:print vu8x16 -// gdbg-check:$5 = {__0 = 30, __1 = 31, __2 = 32, __3 = 33, __4 = 34, __5 = 35, __6 = 36, __7 = 37, __8 = 38, __9 = 39, __10 = 40, __11 = 41, __12 = 42, __13 = 43, __14 = 44, __15 = 45} // gdbr-check:$5 = simd::u8x16 (30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45) -// gdbg-command:print/d vu16x8 // gdbr-command:print vu16x8 -// gdbg-check:$6 = {__0 = 46, __1 = 47, __2 = 48, __3 = 49, __4 = 50, __5 = 51, __6 = 52, __7 = 53} // gdbr-check:$6 = simd::u16x8 (46, 47, 48, 49, 50, 51, 52, 53) -// gdbg-command:print/d vu32x4 // gdbr-command:print vu32x4 -// gdbg-check:$7 = {__0 = 54, __1 = 55, __2 = 56, __3 = 57} // gdbr-check:$7 = simd::u32x4 (54, 55, 56, 57) -// gdbg-command:print/d vu64x2 // gdbr-command:print vu64x2 -// gdbg-check:$8 = {__0 = 58, __1 = 59} // gdbr-check:$8 = simd::u64x2 (58, 59) // gdb-command:print vf32x4 -// gdbg-check:$9 = {__0 = 60.5, __1 = 61.5, __2 = 62.5, __3 = 63.5} // gdbr-check:$9 = simd::f32x4 (60.5, 61.5, 62.5, 63.5) // gdb-command:print vf64x2 -// gdbg-check:$10 = {__0 = 64.5, __1 = 65.5} // gdbr-check:$10 = simd::f64x2 (64.5, 65.5) // gdb-command:continue diff --git a/tests/debuginfo/simple-struct.rs b/tests/debuginfo/simple-struct.rs index aaa654aeb7a6..54d543d90a4c 100644 --- a/tests/debuginfo/simple-struct.rs +++ b/tests/debuginfo/simple-struct.rs @@ -4,90 +4,60 @@ // === GDB TESTS =================================================================================== -// gdbg-command:print 'simple_struct::NO_PADDING_16' // gdbr-command:print simple_struct::NO_PADDING_16 -// gdbg-check:$1 = {x = 1000, y = -1001} // gdbr-check:$1 = simple_struct::NoPadding16 {x: 1000, y: -1001} -// gdbg-command:print 'simple_struct::NO_PADDING_32' // gdbr-command:print simple_struct::NO_PADDING_32 -// gdbg-check:$2 = {x = 1, y = 2, z = 3} // gdbr-check:$2 = simple_struct::NoPadding32 {x: 1, y: 2, z: 3} -// gdbg-command:print 'simple_struct::NO_PADDING_64' // gdbr-command:print simple_struct::NO_PADDING_64 -// gdbg-check:$3 = {x = 4, y = 5, z = 6} // gdbr-check:$3 = simple_struct::NoPadding64 {x: 4, y: 5, z: 6} -// gdbg-command:print 'simple_struct::NO_PADDING_163264' // gdbr-command:print simple_struct::NO_PADDING_163264 -// gdbg-check:$4 = {a = 7, b = 8, c = 9, d = 10} // gdbr-check:$4 = simple_struct::NoPadding163264 {a: 7, b: 8, c: 9, d: 10} -// gdbg-command:print 'simple_struct::INTERNAL_PADDING' // gdbr-command:print simple_struct::INTERNAL_PADDING -// gdbg-check:$5 = {x = 11, y = 12} // gdbr-check:$5 = simple_struct::InternalPadding {x: 11, y: 12} -// gdbg-command:print 'simple_struct::PADDING_AT_END' // gdbr-command:print simple_struct::PADDING_AT_END -// gdbg-check:$6 = {x = 13, y = 14} // gdbr-check:$6 = simple_struct::PaddingAtEnd {x: 13, y: 14} // gdb-command:run // gdb-command:print no_padding16 -// gdbg-check:$7 = {x = 10000, y = -10001} // gdbr-check:$7 = simple_struct::NoPadding16 {x: 10000, y: -10001} // gdb-command:print no_padding32 -// gdbg-check:$8 = {x = -10002, y = -10003.5, z = 10004} // gdbr-check:$8 = simple_struct::NoPadding32 {x: -10002, y: -10003.5, z: 10004} // gdb-command:print no_padding64 -// gdbg-check:$9 = {x = -10005.5, y = 10006, z = 10007} // gdbr-check:$9 = simple_struct::NoPadding64 {x: -10005.5, y: 10006, z: 10007} // gdb-command:print no_padding163264 -// gdbg-check:$10 = {a = -10008, b = 10009, c = 10010, d = 10011} // gdbr-check:$10 = simple_struct::NoPadding163264 {a: -10008, b: 10009, c: 10010, d: 10011} // gdb-command:print internal_padding -// gdbg-check:$11 = {x = 10012, y = -10013} // gdbr-check:$11 = simple_struct::InternalPadding {x: 10012, y: -10013} // gdb-command:print padding_at_end -// gdbg-check:$12 = {x = -10014, y = 10015} // gdbr-check:$12 = simple_struct::PaddingAtEnd {x: -10014, y: 10015} -// gdbg-command:print 'simple_struct::NO_PADDING_16' // gdbr-command:print simple_struct::NO_PADDING_16 -// gdbg-check:$13 = {x = 100, y = -101} // gdbr-check:$13 = simple_struct::NoPadding16 {x: 100, y: -101} -// gdbg-command:print 'simple_struct::NO_PADDING_32' // gdbr-command:print simple_struct::NO_PADDING_32 -// gdbg-check:$14 = {x = -15, y = -16, z = 17} // gdbr-check:$14 = simple_struct::NoPadding32 {x: -15, y: -16, z: 17} -// gdbg-command:print 'simple_struct::NO_PADDING_64' // gdbr-command:print simple_struct::NO_PADDING_64 -// gdbg-check:$15 = {x = -18, y = 19, z = 20} // gdbr-check:$15 = simple_struct::NoPadding64 {x: -18, y: 19, z: 20} -// gdbg-command:print 'simple_struct::NO_PADDING_163264' // gdbr-command:print simple_struct::NO_PADDING_163264 -// gdbg-check:$16 = {a = -21, b = 22, c = 23, d = 24} // gdbr-check:$16 = simple_struct::NoPadding163264 {a: -21, b: 22, c: 23, d: 24} -// gdbg-command:print 'simple_struct::INTERNAL_PADDING' // gdbr-command:print simple_struct::INTERNAL_PADDING -// gdbg-check:$17 = {x = 25, y = -26} // gdbr-check:$17 = simple_struct::InternalPadding {x: 25, y: -26} -// gdbg-command:print 'simple_struct::PADDING_AT_END' // gdbr-command:print simple_struct::PADDING_AT_END -// gdbg-check:$18 = {x = -27, y = 28} // gdbr-check:$18 = simple_struct::PaddingAtEnd {x: -27, y: 28} // gdb-command:continue diff --git a/tests/debuginfo/simple-tuple.rs b/tests/debuginfo/simple-tuple.rs index 9d809a11cac5..e19fb59cdc5c 100644 --- a/tests/debuginfo/simple-tuple.rs +++ b/tests/debuginfo/simple-tuple.rs @@ -4,93 +4,57 @@ // === GDB TESTS =================================================================================== -// gdbg-command:print/d 'simple_tuple::NO_PADDING_8' // gdbr-command:print simple_tuple::NO_PADDING_8 -// gdbg-check:$1 = {__0 = -50, __1 = 50} // gdbr-check:$1 = (-50, 50) -// gdbg-command:print 'simple_tuple::NO_PADDING_16' // gdbr-command:print simple_tuple::NO_PADDING_16 -// gdbg-check:$2 = {__0 = -1, __1 = 2, __2 = 3} // gdbr-check:$2 = (-1, 2, 3) -// gdbg-command:print 'simple_tuple::NO_PADDING_32' // gdbr-command:print simple_tuple::NO_PADDING_32 -// gdbg-check:$3 = {__0 = 4, __1 = 5, __2 = 6} // gdbr-check:$3 = (4, 5, 6) -// gdbg-command:print 'simple_tuple::NO_PADDING_64' // gdbr-command:print simple_tuple::NO_PADDING_64 -// gdbg-check:$4 = {__0 = 7, __1 = 8, __2 = 9} // gdbr-check:$4 = (7, 8, 9) -// gdbg-command:print 'simple_tuple::INTERNAL_PADDING_1' // gdbr-command:print simple_tuple::INTERNAL_PADDING_1 -// gdbg-check:$5 = {__0 = 10, __1 = 11} // gdbr-check:$5 = (10, 11) -// gdbg-command:print 'simple_tuple::INTERNAL_PADDING_2' // gdbr-command:print simple_tuple::INTERNAL_PADDING_2 -// gdbg-check:$6 = {__0 = 12, __1 = 13, __2 = 14, __3 = 15} // gdbr-check:$6 = (12, 13, 14, 15) -// gdbg-command:print 'simple_tuple::PADDING_AT_END' // gdbr-command:print simple_tuple::PADDING_AT_END -// gdbg-check:$7 = {__0 = 16, __1 = 17} // gdbr-check:$7 = (16, 17) // gdb-command:run -// gdbg-command:print/d noPadding8 // gdbr-command:print noPadding8 -// gdbg-check:$8 = {__0 = -100, __1 = 100} // gdbr-check:$8 = (-100, 100) // gdb-command:print noPadding16 -// gdbg-check:$9 = {__0 = 0, __1 = 1, __2 = 2} // gdbr-check:$9 = (0, 1, 2) // gdb-command:print noPadding32 -// gdbg-check:$10 = {__0 = 3, __1 = 4.5, __2 = 5} // gdbr-check:$10 = (3, 4.5, 5) // gdb-command:print noPadding64 -// gdbg-check:$11 = {__0 = 6, __1 = 7.5, __2 = 8} // gdbr-check:$11 = (6, 7.5, 8) // gdb-command:print internalPadding1 -// gdbg-check:$12 = {__0 = 9, __1 = 10} // gdbr-check:$12 = (9, 10) // gdb-command:print internalPadding2 -// gdbg-check:$13 = {__0 = 11, __1 = 12, __2 = 13, __3 = 14} // gdbr-check:$13 = (11, 12, 13, 14) // gdb-command:print paddingAtEnd -// gdbg-check:$14 = {__0 = 15, __1 = 16} // gdbr-check:$14 = (15, 16) -// gdbg-command:print/d 'simple_tuple::NO_PADDING_8' // gdbr-command:print simple_tuple::NO_PADDING_8 -// gdbg-check:$15 = {__0 = -127, __1 = 127} // gdbr-check:$15 = (-127, 127) -// gdbg-command:print 'simple_tuple::NO_PADDING_16' // gdbr-command:print simple_tuple::NO_PADDING_16 -// gdbg-check:$16 = {__0 = -10, __1 = 10, __2 = 9} // gdbr-check:$16 = (-10, 10, 9) -// gdbg-command:print 'simple_tuple::NO_PADDING_32' // gdbr-command:print simple_tuple::NO_PADDING_32 -// gdbg-check:$17 = {__0 = 14, __1 = 15, __2 = 16} // gdbr-check:$17 = (14, 15, 16) -// gdbg-command:print 'simple_tuple::NO_PADDING_64' // gdbr-command:print simple_tuple::NO_PADDING_64 -// gdbg-check:$18 = {__0 = 17, __1 = 18, __2 = 19} // gdbr-check:$18 = (17, 18, 19) -// gdbg-command:print 'simple_tuple::INTERNAL_PADDING_1' // gdbr-command:print simple_tuple::INTERNAL_PADDING_1 -// gdbg-check:$19 = {__0 = 110, __1 = 111} // gdbr-check:$19 = (110, 111) -// gdbg-command:print 'simple_tuple::INTERNAL_PADDING_2' // gdbr-command:print simple_tuple::INTERNAL_PADDING_2 -// gdbg-check:$20 = {__0 = 112, __1 = 113, __2 = 114, __3 = 115} // gdbr-check:$20 = (112, 113, 114, 115) -// gdbg-command:print 'simple_tuple::PADDING_AT_END' // gdbr-command:print simple_tuple::PADDING_AT_END -// gdbg-check:$21 = {__0 = 116, __1 = 117} // gdbr-check:$21 = (116, 117) diff --git a/tests/debuginfo/struct-in-enum.rs b/tests/debuginfo/struct-in-enum.rs index e4b647a4ac16..9e97741444e8 100644 --- a/tests/debuginfo/struct-in-enum.rs +++ b/tests/debuginfo/struct-in-enum.rs @@ -9,15 +9,12 @@ // gdb-command:run // gdb-command:print case1 -// gdbg-check:$1 = {{RUST$ENUM$DISR = Case1, __0 = 0, __1 = {x = 2088533116, y = 2088533116, z = 31868}}, {RUST$ENUM$DISR = Case1, [...]}} // gdbr-check:$1 = struct_in_enum::Regular::Case1(0, struct_in_enum::Struct {x: 2088533116, y: 2088533116, z: 31868}) // gdb-command:print case2 -// gdbg-check:$2 = {{RUST$ENUM$DISR = Case2, [...]}, {RUST$ENUM$DISR = Case2, __0 = 0, __1 = 1229782938247303441, __2 = 4369}} // gdbr-check:$2 = struct_in_enum::Regular::Case2(0, 1229782938247303441, 4369) // gdb-command:print univariant -// gdbg-check:$3 = {{__0 = {x = 123, y = 456, z = 789}}} // gdbr-check:$3 = struct_in_enum::Univariant::TheOnlyCase(struct_in_enum::Struct {x: 123, y: 456, z: 789}) diff --git a/tests/debuginfo/struct-in-struct.rs b/tests/debuginfo/struct-in-struct.rs index 7ca0e3a5ef63..0025f571aa78 100644 --- a/tests/debuginfo/struct-in-struct.rs +++ b/tests/debuginfo/struct-in-struct.rs @@ -7,15 +7,12 @@ // gdb-command:run // gdb-command:print three_simple_structs -// gdbg-check:$1 = {x = {x = 1}, y = {x = 2}, z = {x = 3}} // gdbr-check:$1 = struct_in_struct::ThreeSimpleStructs {x: struct_in_struct::Simple {x: 1}, y: struct_in_struct::Simple {x: 2}, z: struct_in_struct::Simple {x: 3}} // gdb-command:print internal_padding_parent -// gdbg-check:$2 = {x = {x = 4, y = 5}, y = {x = 6, y = 7}, z = {x = 8, y = 9}} // gdbr-check:$2 = struct_in_struct::InternalPaddingParent {x: struct_in_struct::InternalPadding {x: 4, y: 5}, y: struct_in_struct::InternalPadding {x: 6, y: 7}, z: struct_in_struct::InternalPadding {x: 8, y: 9}} // gdb-command:print padding_at_end_parent -// gdbg-check:$3 = {x = {x = 10, y = 11}, y = {x = 12, y = 13}, z = {x = 14, y = 15}} // gdbr-check:$3 = struct_in_struct::PaddingAtEndParent {x: struct_in_struct::PaddingAtEnd {x: 10, y: 11}, y: struct_in_struct::PaddingAtEnd {x: 12, y: 13}, z: struct_in_struct::PaddingAtEnd {x: 14, y: 15}} diff --git a/tests/debuginfo/struct-with-destructor.rs b/tests/debuginfo/struct-with-destructor.rs index 12e2ac4225c0..8d854369d686 100644 --- a/tests/debuginfo/struct-with-destructor.rs +++ b/tests/debuginfo/struct-with-destructor.rs @@ -6,19 +6,15 @@ // gdb-command:run // gdb-command:print simple -// gdbg-check:$1 = {x = 10, y = 20} // gdbr-check:$1 = struct_with_destructor::WithDestructor {x: 10, y: 20} // gdb-command:print noDestructor -// gdbg-check:$2 = {a = {x = 10, y = 20}, guard = -1} // gdbr-check:$2 = struct_with_destructor::NoDestructorGuarded {a: struct_with_destructor::NoDestructor {x: 10, y: 20}, guard: -1} // gdb-command:print withDestructor -// gdbg-check:$3 = {a = {x = 10, y = 20}, guard = -1} // gdbr-check:$3 = struct_with_destructor::WithDestructorGuarded {a: struct_with_destructor::WithDestructor {x: 10, y: 20}, guard: -1} // gdb-command:print nested -// gdbg-check:$4 = {a = {a = {x = 7890, y = 9870}}} // gdbr-check:$4 = struct_with_destructor::NestedOuter {a: struct_with_destructor::NestedInner {a: struct_with_destructor::WithDestructor {x: 7890, y: 9870}}} diff --git a/tests/debuginfo/tuple-in-struct.rs b/tests/debuginfo/tuple-in-struct.rs index e36d924e9259..11175c73f55b 100644 --- a/tests/debuginfo/tuple-in-struct.rs +++ b/tests/debuginfo/tuple-in-struct.rs @@ -5,38 +5,28 @@ // gdb-command:run // gdb-command:print no_padding1 -// gdbg-check:$1 = {x = {__0 = 0, __1 = 1}, y = 2, z = {__0 = 3, __1 = 4, __2 = 5}} // gdbr-check:$1 = tuple_in_struct::NoPadding1 {x: (0, 1), y: 2, z: (3, 4, 5)} // gdb-command:print no_padding2 -// gdbg-check:$2 = {x = {__0 = 6, __1 = 7}, y = {__0 = {__0 = 8, __1 = 9}, __1 = 10}} // gdbr-check:$2 = tuple_in_struct::NoPadding2 {x: (6, 7), y: ((8, 9), 10)} // gdb-command:print tuple_internal_padding -// gdbg-check:$3 = {x = {__0 = 11, __1 = 12}, y = {__0 = 13, __1 = 14}} // gdbr-check:$3 = tuple_in_struct::TupleInternalPadding {x: (11, 12), y: (13, 14)} // gdb-command:print struct_internal_padding -// gdbg-check:$4 = {x = {__0 = 15, __1 = 16}, y = {__0 = 17, __1 = 18}} // gdbr-check:$4 = tuple_in_struct::StructInternalPadding {x: (15, 16), y: (17, 18)} // gdb-command:print both_internally_padded -// gdbg-check:$5 = {x = {__0 = 19, __1 = 20, __2 = 21}, y = {__0 = 22, __1 = 23}} // gdbr-check:$5 = tuple_in_struct::BothInternallyPadded {x: (19, 20, 21), y: (22, 23)} // gdb-command:print single_tuple -// gdbg-check:$6 = {x = {__0 = 24, __1 = 25, __2 = 26}} // gdbr-check:$6 = tuple_in_struct::SingleTuple {x: (24, 25, 26)} // gdb-command:print tuple_padded_at_end -// gdbg-check:$7 = {x = {__0 = 27, __1 = 28}, y = {__0 = 29, __1 = 30}} // gdbr-check:$7 = tuple_in_struct::TuplePaddedAtEnd {x: (27, 28), y: (29, 30)} // gdb-command:print struct_padded_at_end -// gdbg-check:$8 = {x = {__0 = 31, __1 = 32}, y = {__0 = 33, __1 = 34}} // gdbr-check:$8 = tuple_in_struct::StructPaddedAtEnd {x: (31, 32), y: (33, 34)} // gdb-command:print both_padded_at_end -// gdbg-check:$9 = {x = {__0 = 35, __1 = 36, __2 = 37}, y = {__0 = 38, __1 = 39}} // gdbr-check:$9 = tuple_in_struct::BothPaddedAtEnd {x: (35, 36, 37), y: (38, 39)} // gdb-command:print mixed_padding -// gdbg-check:$10 = {x = {__0 = {__0 = 40, __1 = 41, __2 = 42}, __1 = {__0 = 43, __1 = 44}}, y = {__0 = 45, __1 = 46, __2 = 47, __3 = 48}} // gdbr-check:$10 = tuple_in_struct::MixedPadding {x: ((40, 41, 42), (43, 44)), y: (45, 46, 47, 48)} #![allow(unused_variables)] diff --git a/tests/debuginfo/tuple-in-tuple.rs b/tests/debuginfo/tuple-in-tuple.rs index 8ed0e1f9c13b..98bded68b14e 100644 --- a/tests/debuginfo/tuple-in-tuple.rs +++ b/tests/debuginfo/tuple-in-tuple.rs @@ -7,27 +7,20 @@ // gdb-command:run // gdb-command:print no_padding1 -// gdbg-check:$1 = {__0 = {__0 = 0, __1 = 1}, __1 = 2, __2 = 3} // gdbr-check:$1 = ((0, 1), 2, 3) // gdb-command:print no_padding2 -// gdbg-check:$2 = {__0 = 4, __1 = {__0 = 5, __1 = 6}, __2 = 7} // gdbr-check:$2 = (4, (5, 6), 7) // gdb-command:print no_padding3 -// gdbg-check:$3 = {__0 = 8, __1 = 9, __2 = {__0 = 10, __1 = 11}} // gdbr-check:$3 = (8, 9, (10, 11)) // gdb-command:print internal_padding1 -// gdbg-check:$4 = {__0 = 12, __1 = {__0 = 13, __1 = 14}} // gdbr-check:$4 = (12, (13, 14)) // gdb-command:print internal_padding2 -// gdbg-check:$5 = {__0 = 15, __1 = {__0 = 16, __1 = 17}} // gdbr-check:$5 = (15, (16, 17)) // gdb-command:print padding_at_end1 -// gdbg-check:$6 = {__0 = 18, __1 = {__0 = 19, __1 = 20}} // gdbr-check:$6 = (18, (19, 20)) // gdb-command:print padding_at_end2 -// gdbg-check:$7 = {__0 = {__0 = 21, __1 = 22}, __1 = 23} // gdbr-check:$7 = ((21, 22), 23) diff --git a/tests/debuginfo/tuple-struct.rs b/tests/debuginfo/tuple-struct.rs index 88b1ae19e295..a3e88c0f9266 100644 --- a/tests/debuginfo/tuple-struct.rs +++ b/tests/debuginfo/tuple-struct.rs @@ -7,27 +7,21 @@ // gdb-command:run // gdb-command:print no_padding16 -// gdbg-check:$1 = {__0 = 10000, __1 = -10001} // gdbr-check:$1 = tuple_struct::NoPadding16 (10000, -10001) // gdb-command:print no_padding32 -// gdbg-check:$2 = {__0 = -10002, __1 = -10003.5, __2 = 10004} // gdbr-check:$2 = tuple_struct::NoPadding32 (-10002, -10003.5, 10004) // gdb-command:print no_padding64 -// gdbg-check:$3 = {__0 = -10005.5, __1 = 10006, __2 = 10007} // gdbr-check:$3 = tuple_struct::NoPadding64 (-10005.5, 10006, 10007) // gdb-command:print no_padding163264 -// gdbg-check:$4 = {__0 = -10008, __1 = 10009, __2 = 10010, __3 = 10011} // gdbr-check:$4 = tuple_struct::NoPadding163264 (-10008, 10009, 10010, 10011) // gdb-command:print internal_padding -// gdbg-check:$5 = {__0 = 10012, __1 = -10013} // gdbr-check:$5 = tuple_struct::InternalPadding (10012, -10013) // gdb-command:print padding_at_end -// gdbg-check:$6 = {__0 = -10014, __1 = 10015} // gdbr-check:$6 = tuple_struct::PaddingAtEnd (-10014, 10015) diff --git a/tests/debuginfo/union-smoke.rs b/tests/debuginfo/union-smoke.rs index d786ba612714..cd2c9a139730 100644 --- a/tests/debuginfo/union-smoke.rs +++ b/tests/debuginfo/union-smoke.rs @@ -8,10 +8,8 @@ // gdb-command:run // gdb-command:print u -// gdbg-check:$1 = {a = {__0 = 2 '\002', __1 = 2 '\002'}, b = 514} // gdbr-check:$1 = union_smoke::U {a: (2, 2), b: 514} // gdb-command:print union_smoke::SU -// gdbg-check:$2 = {a = {__0 = 1 '\001', __1 = 1 '\001'}, b = 257} // gdbr-check:$2 = union_smoke::U {a: (1, 1), b: 257} // === LLDB TESTS ================================================================================== diff --git a/tests/debuginfo/unsized.rs b/tests/debuginfo/unsized.rs index 982ab003a2a1..ee6fe22c6b8d 100644 --- a/tests/debuginfo/unsized.rs +++ b/tests/debuginfo/unsized.rs @@ -7,27 +7,21 @@ // gdb-command:run // gdb-command:print a -// gdbg-check:$1 = {data_ptr = [...], length = 4} // gdbr-check:$1 = &unsized::Foo<[u8]> {data_ptr: [...], length: 4} // gdb-command:print b -// gdbg-check:$2 = {data_ptr = [...], length = 4} // gdbr-check:$2 = &unsized::Foo> {data_ptr: [...], length: 4} // gdb-command:print c -// gdbg-check:$3 = {pointer = [...], vtable = [...]} // gdbr-check:$3 = &unsized::Foo {pointer: [...], vtable: [...]} // gdb-command:print _box -// gdbg-check:$4 = {pointer = [...], vtable = [...]} // gdbr-check:$4 = alloc::boxed::Box, alloc::alloc::Global> {pointer: [...], vtable: [...]} // gdb-command:print tuple_slice -// gdbg-check:$5 = {data_ptr = [...], length = 2} // gdbr-check:$5 = &(i32, i32, [i32]) {data_ptr: [...], length: 2} // gdb-command:print tuple_dyn -// gdbg-check:$6 = {pointer = [...], vtable = [...]} // gdbr-check:$6 = &(i32, i32, dyn core::fmt::Debug) {pointer: [...], vtable: [...]} // === CDB TESTS =================================================================================== diff --git a/tests/debuginfo/var-captured-in-nested-closure.rs b/tests/debuginfo/var-captured-in-nested-closure.rs index 7772ec003378..e2974f418ae9 100644 --- a/tests/debuginfo/var-captured-in-nested-closure.rs +++ b/tests/debuginfo/var-captured-in-nested-closure.rs @@ -11,10 +11,8 @@ // gdb-command:print constant // gdb-check:$2 = 2 // gdb-command:print a_struct -// gdbg-check:$3 = {a = -3, b = 4.5, c = 5} // gdbr-check:$3 = var_captured_in_nested_closure::Struct {a: -3, b: 4.5, c: 5} // gdb-command:print *struct_ref -// gdbg-check:$4 = {a = -3, b = 4.5, c = 5} // gdbr-check:$4 = var_captured_in_nested_closure::Struct {a: -3, b: 4.5, c: 5} // gdb-command:print *owned // gdb-check:$5 = 6 @@ -27,10 +25,8 @@ // gdb-command:print constant // gdb-check:$8 = 2 // gdb-command:print a_struct -// gdbg-check:$9 = {a = -3, b = 4.5, c = 5} // gdbr-check:$9 = var_captured_in_nested_closure::Struct {a: -3, b: 4.5, c: 5} // gdb-command:print *struct_ref -// gdbg-check:$10 = {a = -3, b = 4.5, c = 5} // gdbr-check:$10 = var_captured_in_nested_closure::Struct {a: -3, b: 4.5, c: 5} // gdb-command:print *owned // gdb-check:$11 = 6 diff --git a/tests/debuginfo/var-captured-in-sendable-closure.rs b/tests/debuginfo/var-captured-in-sendable-closure.rs index 782a7d113738..1029ab6b788b 100644 --- a/tests/debuginfo/var-captured-in-sendable-closure.rs +++ b/tests/debuginfo/var-captured-in-sendable-closure.rs @@ -9,7 +9,6 @@ // gdb-command:print constant // gdb-check:$1 = 1 // gdb-command:print a_struct -// gdbg-check:$2 = {a = -2, b = 3.5, c = 4} // gdbr-check:$2 = var_captured_in_sendable_closure::Struct {a: -2, b: 3.5, c: 4} // gdb-command:print *owned // gdb-check:$3 = 5 diff --git a/tests/debuginfo/var-captured-in-stack-closure.rs b/tests/debuginfo/var-captured-in-stack-closure.rs index c9a93cd7b7f9..baa784e5c459 100644 --- a/tests/debuginfo/var-captured-in-stack-closure.rs +++ b/tests/debuginfo/var-captured-in-stack-closure.rs @@ -11,10 +11,8 @@ // gdb-command:print constant // gdb-check:$2 = 2 // gdb-command:print a_struct -// gdbg-check:$3 = {a = -3, b = 4.5, c = 5} // gdbr-check:$3 = var_captured_in_stack_closure::Struct {a: -3, b: 4.5, c: 5} // gdb-command:print *struct_ref -// gdbg-check:$4 = {a = -3, b = 4.5, c = 5} // gdbr-check:$4 = var_captured_in_stack_closure::Struct {a: -3, b: 4.5, c: 5} // gdb-command:print *owned // gdb-check:$5 = 6 @@ -26,10 +24,8 @@ // gdb-command:print constant // gdb-check:$7 = 2 // gdb-command:print a_struct -// gdbg-check:$8 = {a = -3, b = 4.5, c = 5} // gdbr-check:$8 = var_captured_in_stack_closure::Struct {a: -3, b: 4.5, c: 5} // gdb-command:print *struct_ref -// gdbg-check:$9 = {a = -3, b = 4.5, c = 5} // gdbr-check:$9 = var_captured_in_stack_closure::Struct {a: -3, b: 4.5, c: 5} // gdb-command:print *owned // gdb-check:$10 = 6 diff --git a/tests/debuginfo/vec-slices.rs b/tests/debuginfo/vec-slices.rs index a8235dba40c0..9d7e3eef8045 100644 --- a/tests/debuginfo/vec-slices.rs +++ b/tests/debuginfo/vec-slices.rs @@ -12,48 +12,36 @@ // gdb-command:print singleton.length // gdb-check:$2 = 1 -// gdbg-command:print *((i64[1]*)(singleton.data_ptr)) // gdbr-command:print *(singleton.data_ptr as *const [i64; 1]) -// gdbg-check:$3 = {1} // gdbr-check:$3 = [1] // gdb-command:print multiple.length // gdb-check:$4 = 4 -// gdbg-command:print *((i64[4]*)(multiple.data_ptr)) // gdbr-command:print *(multiple.data_ptr as *const [i64; 4]) -// gdbg-check:$5 = {2, 3, 4, 5} // gdbr-check:$5 = [2, 3, 4, 5] // gdb-command:print slice_of_slice.length // gdb-check:$6 = 2 -// gdbg-command:print *((i64[2]*)(slice_of_slice.data_ptr)) // gdbr-command:print *(slice_of_slice.data_ptr as *const [i64; 2]) -// gdbg-check:$7 = {3, 4} // gdbr-check:$7 = [3, 4] // gdb-command:print padded_tuple.length // gdb-check:$8 = 2 // gdb-command:print padded_tuple.data_ptr[0] -// gdbg-check:$9 = {__0 = 6, __1 = 7} // gdbr-check:$9 = (6, 7) // gdb-command:print padded_tuple.data_ptr[1] -// gdbg-check:$10 = {__0 = 8, __1 = 9} // gdbr-check:$10 = (8, 9) // gdb-command:print padded_struct.length // gdb-check:$11 = 2 // gdb-command:print padded_struct.data_ptr[0] -// gdbg-check:$12 = {x = 10, y = 11, z = 12} // gdbr-check:$12 = vec_slices::AStruct {x: 10, y: 11, z: 12} // gdb-command:print padded_struct.data_ptr[1] -// gdbg-check:$13 = {x = 13, y = 14, z = 15} // gdbr-check:$13 = vec_slices::AStruct {x: 13, y: 14, z: 15} // gdb-command:print mut_slice.length // gdb-check:$14 = 5 -// gdbg-command:print *((i64[5]*)(mut_slice.data_ptr)) // gdbr-command:print *(mut_slice.data_ptr as *const [i64; 5]) -// gdbg-check:$15 = {1, 2, 3, 4, 5} // gdbr-check:$15 = [1, 2, 3, 4, 5] // Some lines below are marked with [ignored] because old GDB versions seem to have trouble diff --git a/tests/debuginfo/vec.rs b/tests/debuginfo/vec.rs index 20cfd785ca7f..bc1f995ce0e1 100644 --- a/tests/debuginfo/vec.rs +++ b/tests/debuginfo/vec.rs @@ -6,10 +6,8 @@ // gdb-command:run // gdb-command:print a -// gdbg-check:$1 = {1, 2, 3} // gdbr-check:$1 = [1, 2, 3] // gdb-command:print vec::VECT -// gdbg-check:$2 = {4, 5, 6} // gdbr-check:$2 = [4, 5, 6] From fa0e8585d4c3484c344e84ed3e639a8fd63616b8 Mon Sep 17 00:00:00 2001 From: Ben Kimock Date: Sat, 17 Aug 2024 17:31:49 -0400 Subject: [PATCH 48/79] Replace gdbr with gdbg --- tests/debuginfo/associated-types.rs | 4 +- .../debuginfo/basic-types-globals-metadata.rs | 30 ++++---- tests/debuginfo/basic-types-globals.rs | 32 ++++----- tests/debuginfo/basic-types-metadata.rs | 18 ++--- tests/debuginfo/basic-types-mut-globals.rs | 64 ++++++++--------- tests/debuginfo/basic-types.rs | 4 +- tests/debuginfo/borrowed-basic.rs | 4 +- tests/debuginfo/borrowed-c-style-enum.rs | 6 +- tests/debuginfo/borrowed-enum.rs | 6 +- tests/debuginfo/borrowed-struct.rs | 6 +- tests/debuginfo/borrowed-tuple.rs | 6 +- tests/debuginfo/box.rs | 2 +- tests/debuginfo/boxed-struct.rs | 4 +- .../by-value-non-immediate-argument.rs | 10 +-- .../by-value-self-argument-in-trait-impl.rs | 4 +- tests/debuginfo/c-style-enum-in-composite.rs | 14 ++-- tests/debuginfo/c-style-enum.rs | 58 +++++++-------- tests/debuginfo/captured-fields-1.rs | 12 ++-- tests/debuginfo/captured-fields-2.rs | 4 +- tests/debuginfo/cross-crate-spans.rs | 4 +- tests/debuginfo/destructured-fn-argument.rs | 16 ++--- .../destructured-for-loop-variable.rs | 4 +- tests/debuginfo/destructured-local.rs | 16 ++--- tests/debuginfo/enum-thinlto.rs | 2 +- tests/debuginfo/evec-in-struct.rs | 10 +-- .../debuginfo/gdb-pretty-struct-and-enums.rs | 10 +-- .../generic-enum-with-different-disr-sizes.rs | 16 ++--- tests/debuginfo/generic-function.rs | 2 +- .../generic-method-on-generic-struct.rs | 10 +-- tests/debuginfo/generic-struct-style-enum.rs | 8 +-- tests/debuginfo/generic-struct.rs | 8 +-- tests/debuginfo/generic-tuple-style-enum.rs | 8 +-- .../lexical-scopes-in-block-expression.rs | 18 ++--- tests/debuginfo/limited-debuginfo.rs | 8 +-- tests/debuginfo/method-on-enum.rs | 10 +-- tests/debuginfo/method-on-generic-struct.rs | 10 +-- tests/debuginfo/method-on-struct.rs | 10 +-- tests/debuginfo/method-on-trait.rs | 10 +-- tests/debuginfo/method-on-tuple-struct.rs | 10 +-- tests/debuginfo/option-like-enum.rs | 16 ++--- .../packed-struct-with-destructor.rs | 16 ++--- tests/debuginfo/packed-struct.rs | 8 +-- tests/debuginfo/pretty-slices.rs | 4 +- tests/debuginfo/pretty-std.rs | 2 +- tests/debuginfo/recursive-struct.rs | 28 ++++---- tests/debuginfo/reference-debuginfo.rs | 4 +- tests/debuginfo/self-in-default-method.rs | 10 +-- .../self-in-generic-default-method.rs | 10 +-- tests/debuginfo/simd.rs | 36 +++++----- tests/debuginfo/simple-struct.rs | 60 ++++++++-------- tests/debuginfo/simple-tuple.rs | 72 +++++++++---------- tests/debuginfo/strings-and-strs.rs | 10 +-- tests/debuginfo/struct-in-enum.rs | 6 +- tests/debuginfo/struct-in-struct.rs | 6 +- tests/debuginfo/struct-style-enum.rs | 8 +-- tests/debuginfo/struct-with-destructor.rs | 8 +-- tests/debuginfo/tuple-in-struct.rs | 20 +++--- tests/debuginfo/tuple-in-tuple.rs | 14 ++-- tests/debuginfo/tuple-struct.rs | 12 ++-- tests/debuginfo/tuple-style-enum.rs | 8 +-- tests/debuginfo/union-smoke.rs | 4 +- tests/debuginfo/unique-enum.rs | 6 +- tests/debuginfo/unsized.rs | 12 ++-- .../var-captured-in-nested-closure.rs | 8 +-- .../var-captured-in-sendable-closure.rs | 2 +- .../var-captured-in-stack-closure.rs | 8 +-- tests/debuginfo/vec-slices.rs | 32 ++++----- tests/debuginfo/vec.rs | 4 +- 68 files changed, 456 insertions(+), 456 deletions(-) diff --git a/tests/debuginfo/associated-types.rs b/tests/debuginfo/associated-types.rs index 8dd9853efe72..bc7a62082b76 100644 --- a/tests/debuginfo/associated-types.rs +++ b/tests/debuginfo/associated-types.rs @@ -8,7 +8,7 @@ // gdb-command:run // gdb-command:print arg -// gdbr-check:$1 = associated_types::Struct {b: -1, b1: 0} +// gdb-check:$1 = associated_types::Struct {b: -1, b1: 0} // gdb-command:continue // gdb-command:print inferred @@ -22,7 +22,7 @@ // gdb-command:continue // gdb-command:print arg -// gdbr-check:$5 = (4, 5) +// gdb-check:$5 = (4, 5) // gdb-command:continue // gdb-command:print a diff --git a/tests/debuginfo/basic-types-globals-metadata.rs b/tests/debuginfo/basic-types-globals-metadata.rs index 5276d6f4a5dc..8819db86cede 100644 --- a/tests/debuginfo/basic-types-globals-metadata.rs +++ b/tests/debuginfo/basic-types-globals-metadata.rs @@ -2,35 +2,35 @@ //@ compile-flags:-g // gdb-command:run -// gdbr-command:whatis basic_types_globals_metadata::B +// gdb-command:whatis basic_types_globals_metadata::B // gdb-check:type = bool -// gdbr-command:whatis basic_types_globals_metadata::I +// gdb-command:whatis basic_types_globals_metadata::I // gdb-check:type = isize -// gdbr-command:whatis basic_types_globals_metadata::C +// gdb-command:whatis basic_types_globals_metadata::C // gdb-check:type = char -// gdbr-command:whatis basic_types_globals_metadata::I8 +// gdb-command:whatis basic_types_globals_metadata::I8 // gdb-check:type = i8 -// gdbr-command:whatis basic_types_globals_metadata::I16 +// gdb-command:whatis basic_types_globals_metadata::I16 // gdb-check:type = i16 -// gdbr-command:whatis basic_types_globals_metadata::I32 +// gdb-command:whatis basic_types_globals_metadata::I32 // gdb-check:type = i32 -// gdbr-command:whatis basic_types_globals_metadata::I64 +// gdb-command:whatis basic_types_globals_metadata::I64 // gdb-check:type = i64 -// gdbr-command:whatis basic_types_globals_metadata::U +// gdb-command:whatis basic_types_globals_metadata::U // gdb-check:type = usize -// gdbr-command:whatis basic_types_globals_metadata::U8 +// gdb-command:whatis basic_types_globals_metadata::U8 // gdb-check:type = u8 -// gdbr-command:whatis basic_types_globals_metadata::U16 +// gdb-command:whatis basic_types_globals_metadata::U16 // gdb-check:type = u16 -// gdbr-command:whatis basic_types_globals_metadata::U32 +// gdb-command:whatis basic_types_globals_metadata::U32 // gdb-check:type = u32 -// gdbr-command:whatis basic_types_globals_metadata::U64 +// gdb-command:whatis basic_types_globals_metadata::U64 // gdb-check:type = u64 -// gdbr-command:whatis basic_types_globals_metadata::F16 +// gdb-command:whatis basic_types_globals_metadata::F16 // gdb-check:type = f16 -// gdbr-command:whatis basic_types_globals_metadata::F32 +// gdb-command:whatis basic_types_globals_metadata::F32 // gdb-check:type = f32 -// gdbr-command:whatis basic_types_globals_metadata::F64 +// gdb-command:whatis basic_types_globals_metadata::F64 // gdb-check:type = f64 // gdb-command:continue diff --git a/tests/debuginfo/basic-types-globals.rs b/tests/debuginfo/basic-types-globals.rs index 7f86dce41779..515d70e19353 100644 --- a/tests/debuginfo/basic-types-globals.rs +++ b/tests/debuginfo/basic-types-globals.rs @@ -12,35 +12,35 @@ //@ [lto] no-prefer-dynamic // gdb-command:run -// gdbr-command:print B +// gdb-command:print B // gdb-check:$1 = false -// gdbr-command:print I +// gdb-command:print I // gdb-check:$2 = -1 -// gdbr-command:print/d C -// gdbr-check:$3 = 97 -// gdbr-command:print I8 +// gdb-command:print/d C +// gdb-check:$3 = 97 +// gdb-command:print I8 // gdb-check:$4 = 68 -// gdbr-command:print I16 +// gdb-command:print I16 // gdb-check:$5 = -16 -// gdbr-command:print I32 +// gdb-command:print I32 // gdb-check:$6 = -32 -// gdbr-command:print I64 +// gdb-command:print I64 // gdb-check:$7 = -64 -// gdbr-command:print U +// gdb-command:print U // gdb-check:$8 = 1 -// gdbr-command:print U8 +// gdb-command:print U8 // gdb-check:$9 = 100 -// gdbr-command:print U16 +// gdb-command:print U16 // gdb-check:$10 = 16 -// gdbr-command:print U32 +// gdb-command:print U32 // gdb-check:$11 = 32 -// gdbr-command:print U64 +// gdb-command:print U64 // gdb-check:$12 = 64 -// gdbr-command:print F16 +// gdb-command:print F16 // gdb-check:$13 = 1.5 -// gdbr-command:print F32 +// gdb-command:print F32 // gdb-check:$14 = 2.5 -// gdbr-command:print F64 +// gdb-command:print F64 // gdb-check:$15 = 3.5 // gdb-command:continue diff --git a/tests/debuginfo/basic-types-metadata.rs b/tests/debuginfo/basic-types-metadata.rs index a2662068fa4c..9bfbdc867011 100644 --- a/tests/debuginfo/basic-types-metadata.rs +++ b/tests/debuginfo/basic-types-metadata.rs @@ -37,18 +37,18 @@ // gdb-command:whatis fnptr // gdb-check:type = *mut fn () // gdb-command:info functions _yyy -// gdbr-check:static fn basic_types_metadata::_yyy(); +// gdb-check:static fn basic_types_metadata::_yyy(); // gdb-command:ptype closure_0 -// gdbr-check: type = struct basic_types_metadata::main::{closure_env#0} +// gdb-check: type = struct basic_types_metadata::main::{closure_env#0} // gdb-command:ptype closure_1 -// gdbr-check: type = struct basic_types_metadata::main::{closure_env#1} { -// gdbr-check: *mut bool, -// gdbr-check: } +// gdb-check: type = struct basic_types_metadata::main::{closure_env#1} { +// gdb-check: *mut bool, +// gdb-check: } // gdb-command:ptype closure_2 -// gdbr-check: type = struct basic_types_metadata::main::{closure_env#2} { -// gdbr-check: *mut bool, -// gdbr-check: *mut isize, -// gdbr-check: } +// gdb-check: type = struct basic_types_metadata::main::{closure_env#2} { +// gdb-check: *mut bool, +// gdb-check: *mut isize, +// gdb-check: } // // gdb-command:continue diff --git a/tests/debuginfo/basic-types-mut-globals.rs b/tests/debuginfo/basic-types-mut-globals.rs index fab2dc8507b5..af0963177f54 100644 --- a/tests/debuginfo/basic-types-mut-globals.rs +++ b/tests/debuginfo/basic-types-mut-globals.rs @@ -11,68 +11,68 @@ // gdb-command:run // Check initializers -// gdbr-command:print B +// gdb-command:print B // gdb-check:$1 = false -// gdbr-command:print I +// gdb-command:print I // gdb-check:$2 = -1 -// gdbr-command:print C -// gdbr-check:$3 = 97 'a' -// gdbr-command:print I8 +// gdb-command:print C +// gdb-check:$3 = 97 'a' +// gdb-command:print I8 // gdb-check:$4 = 68 -// gdbr-command:print I16 +// gdb-command:print I16 // gdb-check:$5 = -16 -// gdbr-command:print I32 +// gdb-command:print I32 // gdb-check:$6 = -32 -// gdbr-command:print I64 +// gdb-command:print I64 // gdb-check:$7 = -64 -// gdbr-command:print U +// gdb-command:print U // gdb-check:$8 = 1 -// gdbr-command:print U8 +// gdb-command:print U8 // gdb-check:$9 = 100 -// gdbr-command:print U16 +// gdb-command:print U16 // gdb-check:$10 = 16 -// gdbr-command:print U32 +// gdb-command:print U32 // gdb-check:$11 = 32 -// gdbr-command:print U64 +// gdb-command:print U64 // gdb-check:$12 = 64 -// gdbr-command:print F16 +// gdb-command:print F16 // gdb-check:$13 = 1.5 -// gdbr-command:print F32 +// gdb-command:print F32 // gdb-check:$14 = 2.5 -// gdbr-command:print F64 +// gdb-command:print F64 // gdb-check:$15 = 3.5 // gdb-command:continue // Check new values -// gdbr-command:print B +// gdb-command:print B // gdb-check:$16 = true -// gdbr-command:print I +// gdb-command:print I // gdb-check:$17 = 2 -// gdbr-command:print C -// gdbr-check:$18 = 102 'f' -// gdbr-command:print/d I8 +// gdb-command:print C +// gdb-check:$18 = 102 'f' +// gdb-command:print/d I8 // gdb-check:$19 = 78 -// gdbr-command:print I16 +// gdb-command:print I16 // gdb-check:$20 = -26 -// gdbr-command:print I32 +// gdb-command:print I32 // gdb-check:$21 = -12 -// gdbr-command:print I64 +// gdb-command:print I64 // gdb-check:$22 = -54 -// gdbr-command:print U +// gdb-command:print U // gdb-check:$23 = 5 -// gdbr-command:print/d U8 +// gdb-command:print/d U8 // gdb-check:$24 = 20 -// gdbr-command:print U16 +// gdb-command:print U16 // gdb-check:$25 = 32 -// gdbr-command:print U32 +// gdb-command:print U32 // gdb-check:$26 = 16 -// gdbr-command:print U64 +// gdb-command:print U64 // gdb-check:$27 = 128 -// gdbr-command:print F16 +// gdb-command:print F16 // gdb-check:$28 = 2.25 -// gdbr-command:print F32 +// gdb-command:print F32 // gdb-check:$29 = 5.75 -// gdbr-command:print F64 +// gdb-command:print F64 // gdb-check:$30 = 9.25 #![allow(unused_variables)] diff --git a/tests/debuginfo/basic-types.rs b/tests/debuginfo/basic-types.rs index 215599e6f0ef..e78c2746fec8 100644 --- a/tests/debuginfo/basic-types.rs +++ b/tests/debuginfo/basic-types.rs @@ -16,7 +16,7 @@ // gdb-command:print i // gdb-check:$2 = -1 // gdb-command:print c -// gdbr-check:$3 = 97 'a' +// gdb-check:$3 = 97 'a' // gdb-command:print/d i8 // gdb-check:$4 = 68 // gdb-command:print i16 @@ -42,7 +42,7 @@ // gdb-command:print f64 // gdb-check:$15 = 3.5 // gdb-command:print s -// gdbr-check:$16 = "Hello, World!" +// gdb-check:$16 = "Hello, World!" // === LLDB TESTS ================================================================================== diff --git a/tests/debuginfo/borrowed-basic.rs b/tests/debuginfo/borrowed-basic.rs index 68fcc3169919..397097cc19b0 100644 --- a/tests/debuginfo/borrowed-basic.rs +++ b/tests/debuginfo/borrowed-basic.rs @@ -14,7 +14,7 @@ // gdb-check:$3 = 97 // gdb-command:print *i8_ref -// gdbr-check:$4 = 68 +// gdb-check:$4 = 68 // gdb-command:print *i16_ref // gdb-check:$5 = -16 @@ -29,7 +29,7 @@ // gdb-check:$8 = 1 // gdb-command:print *u8_ref -// gdbr-check:$9 = 100 +// gdb-check:$9 = 100 // gdb-command:print *u16_ref // gdb-check:$10 = 16 diff --git a/tests/debuginfo/borrowed-c-style-enum.rs b/tests/debuginfo/borrowed-c-style-enum.rs index 7ca19217a794..95554211522a 100644 --- a/tests/debuginfo/borrowed-c-style-enum.rs +++ b/tests/debuginfo/borrowed-c-style-enum.rs @@ -6,13 +6,13 @@ // gdb-command:run // gdb-command:print *the_a_ref -// gdbr-check:$1 = borrowed_c_style_enum::ABC::TheA +// gdb-check:$1 = borrowed_c_style_enum::ABC::TheA // gdb-command:print *the_b_ref -// gdbr-check:$2 = borrowed_c_style_enum::ABC::TheB +// gdb-check:$2 = borrowed_c_style_enum::ABC::TheB // gdb-command:print *the_c_ref -// gdbr-check:$3 = borrowed_c_style_enum::ABC::TheC +// gdb-check:$3 = borrowed_c_style_enum::ABC::TheC // === LLDB TESTS ================================================================================== diff --git a/tests/debuginfo/borrowed-enum.rs b/tests/debuginfo/borrowed-enum.rs index fc2ab62a21c4..444adac8b0aa 100644 --- a/tests/debuginfo/borrowed-enum.rs +++ b/tests/debuginfo/borrowed-enum.rs @@ -9,13 +9,13 @@ // gdb-command:run // gdb-command:print *the_a_ref -// gdbr-check:$1 = borrowed_enum::ABC::TheA{x: 0, y: 8970181431921507452} +// gdb-check:$1 = borrowed_enum::ABC::TheA{x: 0, y: 8970181431921507452} // gdb-command:print *the_b_ref -// gdbr-check:$2 = borrowed_enum::ABC::TheB(0, 286331153, 286331153) +// gdb-check:$2 = borrowed_enum::ABC::TheB(0, 286331153, 286331153) // gdb-command:print *univariant_ref -// gdbr-check:$3 = borrowed_enum::Univariant::TheOnlyCase(4820353753753434) +// gdb-check:$3 = borrowed_enum::Univariant::TheOnlyCase(4820353753753434) // === LLDB TESTS ================================================================================== diff --git a/tests/debuginfo/borrowed-struct.rs b/tests/debuginfo/borrowed-struct.rs index 84e63d9cf634..f74a6b5796f5 100644 --- a/tests/debuginfo/borrowed-struct.rs +++ b/tests/debuginfo/borrowed-struct.rs @@ -6,7 +6,7 @@ // gdb-command:run // gdb-command:print *stack_val_ref -// gdbr-check:$1 = borrowed_struct::SomeStruct {x: 10, y: 23.5} +// gdb-check:$1 = borrowed_struct::SomeStruct {x: 10, y: 23.5} // gdb-command:print *stack_val_interior_ref_1 // gdb-check:$2 = 10 @@ -15,10 +15,10 @@ // gdb-check:$3 = 23.5 // gdb-command:print *ref_to_unnamed -// gdbr-check:$4 = borrowed_struct::SomeStruct {x: 11, y: 24.5} +// gdb-check:$4 = borrowed_struct::SomeStruct {x: 11, y: 24.5} // gdb-command:print *unique_val_ref -// gdbr-check:$5 = borrowed_struct::SomeStruct {x: 13, y: 26.5} +// gdb-check:$5 = borrowed_struct::SomeStruct {x: 13, y: 26.5} // gdb-command:print *unique_val_interior_ref_1 // gdb-check:$6 = 13 diff --git a/tests/debuginfo/borrowed-tuple.rs b/tests/debuginfo/borrowed-tuple.rs index c7253410f95b..8f11f545ca79 100644 --- a/tests/debuginfo/borrowed-tuple.rs +++ b/tests/debuginfo/borrowed-tuple.rs @@ -7,13 +7,13 @@ // gdb-command:run // gdb-command:print *stack_val_ref -// gdbr-check:$1 = (-14, -19) +// gdb-check:$1 = (-14, -19) // gdb-command:print *ref_to_unnamed -// gdbr-check:$2 = (-15, -20) +// gdb-check:$2 = (-15, -20) // gdb-command:print *unique_val_ref -// gdbr-check:$3 = (-17, -22) +// gdb-check:$3 = (-17, -22) // === LLDB TESTS ================================================================================== diff --git a/tests/debuginfo/box.rs b/tests/debuginfo/box.rs index f27e7cbafbf2..bc6928ada3a5 100644 --- a/tests/debuginfo/box.rs +++ b/tests/debuginfo/box.rs @@ -9,7 +9,7 @@ // gdb-command:print *a // gdb-check:$1 = 1 // gdb-command:print *b -// gdbr-check:$2 = (2, 3.5) +// gdb-check:$2 = (2, 3.5) // === LLDB TESTS ================================================================================== diff --git a/tests/debuginfo/boxed-struct.rs b/tests/debuginfo/boxed-struct.rs index 078af68c84df..d31b912ab8c6 100644 --- a/tests/debuginfo/boxed-struct.rs +++ b/tests/debuginfo/boxed-struct.rs @@ -7,10 +7,10 @@ // gdb-command:run // gdb-command:print *boxed_with_padding -// gdbr-check:$1 = boxed_struct::StructWithSomePadding {x: 99, y: 999, z: 9999, w: 99999} +// gdb-check:$1 = boxed_struct::StructWithSomePadding {x: 99, y: 999, z: 9999, w: 99999} // gdb-command:print *boxed_with_dtor -// gdbr-check:$2 = boxed_struct::StructWithDestructor {x: 77, y: 777, z: 7777, w: 77777} +// gdb-check:$2 = boxed_struct::StructWithDestructor {x: 77, y: 777, z: 7777, w: 77777} // === LLDB TESTS ================================================================================== diff --git a/tests/debuginfo/by-value-non-immediate-argument.rs b/tests/debuginfo/by-value-non-immediate-argument.rs index 623c939ee143..f0a39a45195a 100644 --- a/tests/debuginfo/by-value-non-immediate-argument.rs +++ b/tests/debuginfo/by-value-non-immediate-argument.rs @@ -7,11 +7,11 @@ // gdb-command:run // gdb-command:print s -// gdbr-check:$1 = by_value_non_immediate_argument::Struct {a: 1, b: 2.5} +// gdb-check:$1 = by_value_non_immediate_argument::Struct {a: 1, b: 2.5} // gdb-command:continue // gdb-command:print x -// gdbr-check:$2 = by_value_non_immediate_argument::Struct {a: 3, b: 4.5} +// gdb-check:$2 = by_value_non_immediate_argument::Struct {a: 3, b: 4.5} // gdb-command:print y // gdb-check:$3 = 5 // gdb-command:print z @@ -19,15 +19,15 @@ // gdb-command:continue // gdb-command:print a -// gdbr-check:$5 = (7, 8, 9.5, 10.5) +// gdb-check:$5 = (7, 8, 9.5, 10.5) // gdb-command:continue // gdb-command:print a -// gdbr-check:$6 = by_value_non_immediate_argument::Newtype (11.5, 12.5, 13, 14) +// gdb-check:$6 = by_value_non_immediate_argument::Newtype (11.5, 12.5, 13, 14) // gdb-command:continue // gdb-command:print x -// gdbr-check:$7 = by_value_non_immediate_argument::Enum::Case1{x: 0, y: 8970181431921507452} +// gdb-check:$7 = by_value_non_immediate_argument::Enum::Case1{x: 0, y: 8970181431921507452} // gdb-command:continue diff --git a/tests/debuginfo/by-value-self-argument-in-trait-impl.rs b/tests/debuginfo/by-value-self-argument-in-trait-impl.rs index 91a8792a69f9..985f84881c72 100644 --- a/tests/debuginfo/by-value-self-argument-in-trait-impl.rs +++ b/tests/debuginfo/by-value-self-argument-in-trait-impl.rs @@ -11,11 +11,11 @@ // gdb-command:continue // gdb-command:print self -// gdbr-check:$2 = by_value_self_argument_in_trait_impl::Struct {x: 2222, y: 3333} +// gdb-check:$2 = by_value_self_argument_in_trait_impl::Struct {x: 2222, y: 3333} // gdb-command:continue // gdb-command:print self -// gdbr-check:$3 = (4444.5, 5555, 6666, 7777.5) +// gdb-check:$3 = (4444.5, 5555, 6666, 7777.5) // gdb-command:continue diff --git a/tests/debuginfo/c-style-enum-in-composite.rs b/tests/debuginfo/c-style-enum-in-composite.rs index 112631e874eb..bd025c2ae8c1 100644 --- a/tests/debuginfo/c-style-enum-in-composite.rs +++ b/tests/debuginfo/c-style-enum-in-composite.rs @@ -7,25 +7,25 @@ // gdb-command:run // gdb-command:print tuple_interior_padding -// gdbr-check:$1 = (0, c_style_enum_in_composite::AnEnum::OneHundred) +// gdb-check:$1 = (0, c_style_enum_in_composite::AnEnum::OneHundred) // gdb-command:print tuple_padding_at_end -// gdbr-check:$2 = ((1, c_style_enum_in_composite::AnEnum::OneThousand), 2) +// gdb-check:$2 = ((1, c_style_enum_in_composite::AnEnum::OneThousand), 2) // gdb-command:print tuple_different_enums -// gdbr-check:$3 = (c_style_enum_in_composite::AnEnum::OneThousand, c_style_enum_in_composite::AnotherEnum::MountainView, c_style_enum_in_composite::AnEnum::OneMillion, c_style_enum_in_composite::AnotherEnum::Vienna) +// gdb-check:$3 = (c_style_enum_in_composite::AnEnum::OneThousand, c_style_enum_in_composite::AnotherEnum::MountainView, c_style_enum_in_composite::AnEnum::OneMillion, c_style_enum_in_composite::AnotherEnum::Vienna) // gdb-command:print padded_struct -// gdbr-check:$4 = c_style_enum_in_composite::PaddedStruct {a: 3, b: c_style_enum_in_composite::AnEnum::OneMillion, c: 4, d: c_style_enum_in_composite::AnotherEnum::Toronto, e: 5} +// gdb-check:$4 = c_style_enum_in_composite::PaddedStruct {a: 3, b: c_style_enum_in_composite::AnEnum::OneMillion, c: 4, d: c_style_enum_in_composite::AnotherEnum::Toronto, e: 5} // gdb-command:print packed_struct -// gdbr-check:$5 = c_style_enum_in_composite::PackedStruct {a: 6, b: c_style_enum_in_composite::AnEnum::OneHundred, c: 7, d: c_style_enum_in_composite::AnotherEnum::Vienna, e: 8} +// gdb-check:$5 = c_style_enum_in_composite::PackedStruct {a: 6, b: c_style_enum_in_composite::AnEnum::OneHundred, c: 7, d: c_style_enum_in_composite::AnotherEnum::Vienna, e: 8} // gdb-command:print non_padded_struct -// gdbr-check:$6 = c_style_enum_in_composite::NonPaddedStruct {a: c_style_enum_in_composite::AnEnum::OneMillion, b: c_style_enum_in_composite::AnotherEnum::MountainView, c: c_style_enum_in_composite::AnEnum::OneThousand, d: c_style_enum_in_composite::AnotherEnum::Toronto} +// gdb-check:$6 = c_style_enum_in_composite::NonPaddedStruct {a: c_style_enum_in_composite::AnEnum::OneMillion, b: c_style_enum_in_composite::AnotherEnum::MountainView, c: c_style_enum_in_composite::AnEnum::OneThousand, d: c_style_enum_in_composite::AnotherEnum::Toronto} // gdb-command:print struct_with_drop -// gdbr-check:$7 = (c_style_enum_in_composite::StructWithDrop {a: c_style_enum_in_composite::AnEnum::OneHundred, b: c_style_enum_in_composite::AnotherEnum::Vienna}, 9) +// gdb-check:$7 = (c_style_enum_in_composite::StructWithDrop {a: c_style_enum_in_composite::AnEnum::OneHundred, b: c_style_enum_in_composite::AnotherEnum::Vienna}, 9) // === LLDB TESTS ================================================================================== diff --git a/tests/debuginfo/c-style-enum.rs b/tests/debuginfo/c-style-enum.rs index 6f14f41f0600..d39576bd3878 100644 --- a/tests/debuginfo/c-style-enum.rs +++ b/tests/debuginfo/c-style-enum.rs @@ -5,61 +5,61 @@ // === GDB TESTS =================================================================================== -// gdbr-command:print c_style_enum::SINGLE_VARIANT -// gdbr-check:$1 = c_style_enum::SingleVariant::TheOnlyVariant +// gdb-command:print c_style_enum::SINGLE_VARIANT +// gdb-check:$1 = c_style_enum::SingleVariant::TheOnlyVariant -// gdbr-command:print c_style_enum::AUTO_ONE -// gdbr-check:$2 = c_style_enum::AutoDiscriminant::One +// gdb-command:print c_style_enum::AUTO_ONE +// gdb-check:$2 = c_style_enum::AutoDiscriminant::One -// gdbr-command:print c_style_enum::AUTO_TWO -// gdbr-check:$3 = c_style_enum::AutoDiscriminant::One +// gdb-command:print c_style_enum::AUTO_TWO +// gdb-check:$3 = c_style_enum::AutoDiscriminant::One -// gdbr-command:print c_style_enum::AUTO_THREE -// gdbr-check:$4 = c_style_enum::AutoDiscriminant::One +// gdb-command:print c_style_enum::AUTO_THREE +// gdb-check:$4 = c_style_enum::AutoDiscriminant::One -// gdbr-command:print c_style_enum::MANUAL_ONE -// gdbr-check:$5 = c_style_enum::ManualDiscriminant::OneHundred +// gdb-command:print c_style_enum::MANUAL_ONE +// gdb-check:$5 = c_style_enum::ManualDiscriminant::OneHundred -// gdbr-command:print c_style_enum::MANUAL_TWO -// gdbr-check:$6 = c_style_enum::ManualDiscriminant::OneHundred +// gdb-command:print c_style_enum::MANUAL_TWO +// gdb-check:$6 = c_style_enum::ManualDiscriminant::OneHundred -// gdbr-command:print c_style_enum::MANUAL_THREE -// gdbr-check:$7 = c_style_enum::ManualDiscriminant::OneHundred +// gdb-command:print c_style_enum::MANUAL_THREE +// gdb-check:$7 = c_style_enum::ManualDiscriminant::OneHundred // gdb-command:run // gdb-command:print auto_one -// gdbr-check:$8 = c_style_enum::AutoDiscriminant::One +// gdb-check:$8 = c_style_enum::AutoDiscriminant::One // gdb-command:print auto_two -// gdbr-check:$9 = c_style_enum::AutoDiscriminant::Two +// gdb-check:$9 = c_style_enum::AutoDiscriminant::Two // gdb-command:print auto_three -// gdbr-check:$10 = c_style_enum::AutoDiscriminant::Three +// gdb-check:$10 = c_style_enum::AutoDiscriminant::Three // gdb-command:print manual_one_hundred -// gdbr-check:$11 = c_style_enum::ManualDiscriminant::OneHundred +// gdb-check:$11 = c_style_enum::ManualDiscriminant::OneHundred // gdb-command:print manual_one_thousand -// gdbr-check:$12 = c_style_enum::ManualDiscriminant::OneThousand +// gdb-check:$12 = c_style_enum::ManualDiscriminant::OneThousand // gdb-command:print manual_one_million -// gdbr-check:$13 = c_style_enum::ManualDiscriminant::OneMillion +// gdb-check:$13 = c_style_enum::ManualDiscriminant::OneMillion // gdb-command:print single_variant -// gdbr-check:$14 = c_style_enum::SingleVariant::TheOnlyVariant +// gdb-check:$14 = c_style_enum::SingleVariant::TheOnlyVariant -// gdbr-command:print AUTO_TWO -// gdbr-check:$15 = c_style_enum::AutoDiscriminant::Two +// gdb-command:print AUTO_TWO +// gdb-check:$15 = c_style_enum::AutoDiscriminant::Two -// gdbr-command:print AUTO_THREE -// gdbr-check:$16 = c_style_enum::AutoDiscriminant::Three +// gdb-command:print AUTO_THREE +// gdb-check:$16 = c_style_enum::AutoDiscriminant::Three -// gdbr-command:print MANUAL_TWO -// gdbr-check:$17 = c_style_enum::ManualDiscriminant::OneThousand +// gdb-command:print MANUAL_TWO +// gdb-check:$17 = c_style_enum::ManualDiscriminant::OneThousand -// gdbr-command:print MANUAL_THREE -// gdbr-check:$18 = c_style_enum::ManualDiscriminant::OneMillion +// gdb-command:print MANUAL_THREE +// gdb-check:$18 = c_style_enum::ManualDiscriminant::OneMillion // === LLDB TESTS ================================================================================== diff --git a/tests/debuginfo/captured-fields-1.rs b/tests/debuginfo/captured-fields-1.rs index d96f2590570b..217a1f27b678 100644 --- a/tests/debuginfo/captured-fields-1.rs +++ b/tests/debuginfo/captured-fields-1.rs @@ -4,22 +4,22 @@ // gdb-command:run // gdb-command:print test -// gdbr-check:$1 = captured_fields_1::main::{closure_env#0} {_ref__my_ref__my_field1: 0x[...]} +// gdb-check:$1 = captured_fields_1::main::{closure_env#0} {_ref__my_ref__my_field1: 0x[...]} // gdb-command:continue // gdb-command:print test -// gdbr-check:$2 = captured_fields_1::main::{closure_env#1} {_ref__my_ref__my_field2: 0x[...]} +// gdb-check:$2 = captured_fields_1::main::{closure_env#1} {_ref__my_ref__my_field2: 0x[...]} // gdb-command:continue // gdb-command:print test -// gdbr-check:$3 = captured_fields_1::main::{closure_env#2} {_ref__my_ref: 0x[...]} +// gdb-check:$3 = captured_fields_1::main::{closure_env#2} {_ref__my_ref: 0x[...]} // gdb-command:continue // gdb-command:print test -// gdbr-check:$4 = captured_fields_1::main::{closure_env#3} {my_ref: 0x[...]} +// gdb-check:$4 = captured_fields_1::main::{closure_env#3} {my_ref: 0x[...]} // gdb-command:continue // gdb-command:print test -// gdbr-check:$5 = captured_fields_1::main::{closure_env#4} {my_var__my_field2: 22} +// gdb-check:$5 = captured_fields_1::main::{closure_env#4} {my_var__my_field2: 22} // gdb-command:continue // gdb-command:print test -// gdbr-check:$6 = captured_fields_1::main::{closure_env#5} {my_var: captured_fields_1::MyStruct {my_field1: 11, my_field2: 22}} +// gdb-check:$6 = captured_fields_1::main::{closure_env#5} {my_var: captured_fields_1::MyStruct {my_field1: 11, my_field2: 22}} // gdb-command:continue // === LLDB TESTS ================================================================================== diff --git a/tests/debuginfo/captured-fields-2.rs b/tests/debuginfo/captured-fields-2.rs index 446c5c70fefb..940f07ecacbb 100644 --- a/tests/debuginfo/captured-fields-2.rs +++ b/tests/debuginfo/captured-fields-2.rs @@ -4,10 +4,10 @@ // gdb-command:run // gdb-command:print my_ref__my_field1 -// gdbr-check:$1 = 11 +// gdb-check:$1 = 11 // gdb-command:continue // gdb-command:print my_var__my_field2 -// gdbr-check:$2 = 22 +// gdb-check:$2 = 22 // gdb-command:continue // === LLDB TESTS ================================================================================== diff --git a/tests/debuginfo/cross-crate-spans.rs b/tests/debuginfo/cross-crate-spans.rs index 57e1e63bb8fb..7344901ec31c 100644 --- a/tests/debuginfo/cross-crate-spans.rs +++ b/tests/debuginfo/cross-crate-spans.rs @@ -15,7 +15,7 @@ extern crate cross_crate_spans; // gdb-command:run // gdb-command:print result -// gdbr-check:$1 = (17, 17) +// gdb-check:$1 = (17, 17) // gdb-command:print a_variable // gdb-check:$2 = 123456789 // gdb-command:print another_variable @@ -23,7 +23,7 @@ extern crate cross_crate_spans; // gdb-command:continue // gdb-command:print result -// gdbr-check:$4 = (1212, 1212) +// gdb-check:$4 = (1212, 1212) // gdb-command:print a_variable // gdb-check:$5 = 123456789 // gdb-command:print another_variable diff --git a/tests/debuginfo/destructured-fn-argument.rs b/tests/debuginfo/destructured-fn-argument.rs index 2ebf49ca881e..783cafb43b35 100644 --- a/tests/debuginfo/destructured-fn-argument.rs +++ b/tests/debuginfo/destructured-fn-argument.rs @@ -23,13 +23,13 @@ // gdb-command:print a // gdb-check:$6 = 5 // gdb-command:print b -// gdbr-check:$7 = (6, 7) +// gdb-check:$7 = (6, 7) // gdb-command:continue // gdb-command:print h // gdb-check:$8 = 8 // gdb-command:print i -// gdbr-check:$9 = destructured_fn_argument::Struct {a: 9, b: 10} +// gdb-check:$9 = destructured_fn_argument::Struct {a: 9, b: 10} // gdb-command:print j // gdb-check:$10 = 11 // gdb-command:continue @@ -55,7 +55,7 @@ // gdb-command:print q // gdb-check:$17 = 20 // gdb-command:print r -// gdbr-check:$18 = destructured_fn_argument::Struct {a: 21, b: 22} +// gdb-check:$18 = destructured_fn_argument::Struct {a: 21, b: 22} // gdb-command:continue // gdb-command:print s @@ -85,11 +85,11 @@ // gdb-command:continue // gdb-command:print aa -// gdbr-check:$30 = (34, 35) +// gdb-check:$30 = (34, 35) // gdb-command:continue // gdb-command:print bb -// gdbr-check:$31 = (36, 37) +// gdb-check:$31 = (36, 37) // gdb-command:continue // gdb-command:print cc @@ -97,17 +97,17 @@ // gdb-command:continue // gdb-command:print dd -// gdbr-check:$33 = (40, 41, 42) +// gdb-check:$33 = (40, 41, 42) // gdb-command:continue // gdb-command:print *ee -// gdbr-check:$34 = (43, 44, 45) +// gdb-check:$34 = (43, 44, 45) // gdb-command:continue // gdb-command:print *ff // gdb-check:$35 = 46 // gdb-command:print gg -// gdbr-check:$36 = (47, 48) +// gdb-check:$36 = (47, 48) // gdb-command:continue // gdb-command:print *hh diff --git a/tests/debuginfo/destructured-for-loop-variable.rs b/tests/debuginfo/destructured-for-loop-variable.rs index f6b10f998902..7636a8d0ad52 100644 --- a/tests/debuginfo/destructured-for-loop-variable.rs +++ b/tests/debuginfo/destructured-for-loop-variable.rs @@ -63,11 +63,11 @@ // gdb-command:continue // gdb-command:print simple_struct_ident -// gdbr-check:$23 = destructured_for_loop_variable::Struct {x: 3537, y: 35437.5, z: true} +// gdb-check:$23 = destructured_for_loop_variable::Struct {x: 3537, y: 35437.5, z: true} // gdb-command:continue // gdb-command:print simple_tuple_ident -// gdbr-check:$24 = (34903493, 232323) +// gdb-check:$24 = (34903493, 232323) // gdb-command:continue // === LLDB TESTS ================================================================================== diff --git a/tests/debuginfo/destructured-local.rs b/tests/debuginfo/destructured-local.rs index d65b352e695f..06f1355dcfe6 100644 --- a/tests/debuginfo/destructured-local.rs +++ b/tests/debuginfo/destructured-local.rs @@ -21,12 +21,12 @@ // gdb-command:print f // gdb-check:$6 = 5 // gdb-command:print g -// gdbr-check:$7 = (6, 7) +// gdb-check:$7 = (6, 7) // gdb-command:print h // gdb-check:$8 = 8 // gdb-command:print i -// gdbr-check:$9 = destructured_local::Struct {a: 9, b: 10} +// gdb-check:$9 = destructured_local::Struct {a: 9, b: 10} // gdb-command:print j // gdb-check:$10 = 11 @@ -48,7 +48,7 @@ // gdb-command:print q // gdb-check:$17 = 20 // gdb-command:print r -// gdbr-check:$18 = destructured_local::Struct {a: 21, b: 22} +// gdb-check:$18 = destructured_local::Struct {a: 21, b: 22} // gdb-command:print s // gdb-check:$19 = 24 @@ -75,25 +75,25 @@ // gdb-check:$29 = 33 // gdb-command:print aa -// gdbr-check:$30 = (34, 35) +// gdb-check:$30 = (34, 35) // gdb-command:print bb -// gdbr-check:$31 = (36, 37) +// gdb-check:$31 = (36, 37) // gdb-command:print cc // gdb-check:$32 = 38 // gdb-command:print dd -// gdbr-check:$33 = (40, 41, 42) +// gdb-check:$33 = (40, 41, 42) // gdb-command:print *ee -// gdbr-check:$34 = (43, 44, 45) +// gdb-check:$34 = (43, 44, 45) // gdb-command:print *ff // gdb-check:$35 = 46 // gdb-command:print gg -// gdbr-check:$36 = (47, 48) +// gdb-check:$36 = (47, 48) // gdb-command:print *hh // gdb-check:$37 = 50 diff --git a/tests/debuginfo/enum-thinlto.rs b/tests/debuginfo/enum-thinlto.rs index 42a0d1e28f8e..ff39c09e2a5d 100644 --- a/tests/debuginfo/enum-thinlto.rs +++ b/tests/debuginfo/enum-thinlto.rs @@ -8,7 +8,7 @@ // gdb-command:run // gdb-command:print *abc -// gdbr-check:$1 = enum_thinlto::ABC::TheA{x: 0, y: 8970181431921507452} +// gdb-check:$1 = enum_thinlto::ABC::TheA{x: 0, y: 8970181431921507452} // === LLDB TESTS ================================================================================== diff --git a/tests/debuginfo/evec-in-struct.rs b/tests/debuginfo/evec-in-struct.rs index 7e0dea0680bc..9552dba17f6f 100644 --- a/tests/debuginfo/evec-in-struct.rs +++ b/tests/debuginfo/evec-in-struct.rs @@ -7,18 +7,18 @@ // gdb-command:run // gdb-command:print no_padding1 -// gdbr-check:$1 = evec_in_struct::NoPadding1 {x: [0, 1, 2], y: -3, z: [4.5, 5.5]} +// gdb-check:$1 = evec_in_struct::NoPadding1 {x: [0, 1, 2], y: -3, z: [4.5, 5.5]} // gdb-command:print no_padding2 -// gdbr-check:$2 = evec_in_struct::NoPadding2 {x: [6, 7, 8], y: [[9, 10], [11, 12]]} +// gdb-check:$2 = evec_in_struct::NoPadding2 {x: [6, 7, 8], y: [[9, 10], [11, 12]]} // gdb-command:print struct_internal_padding -// gdbr-check:$3 = evec_in_struct::StructInternalPadding {x: [13, 14], y: [15, 16]} +// gdb-check:$3 = evec_in_struct::StructInternalPadding {x: [13, 14], y: [15, 16]} // gdb-command:print single_vec -// gdbr-check:$4 = evec_in_struct::SingleVec {x: [17, 18, 19, 20, 21]} +// gdb-check:$4 = evec_in_struct::SingleVec {x: [17, 18, 19, 20, 21]} // gdb-command:print struct_padded_at_end -// gdbr-check:$5 = evec_in_struct::StructPaddedAtEnd {x: [22, 23], y: [24, 25]} +// gdb-check:$5 = evec_in_struct::StructPaddedAtEnd {x: [22, 23], y: [24, 25]} // === LLDB TESTS ================================================================================== diff --git a/tests/debuginfo/gdb-pretty-struct-and-enums.rs b/tests/debuginfo/gdb-pretty-struct-and-enums.rs index 5b6977fdd5bc..15f0fe8e261f 100644 --- a/tests/debuginfo/gdb-pretty-struct-and-enums.rs +++ b/tests/debuginfo/gdb-pretty-struct-and-enums.rs @@ -7,19 +7,19 @@ // gdb-command: run // gdb-command: print regular_struct -// gdbr-check:$1 = gdb_pretty_struct_and_enums::RegularStruct {the_first_field: 101, the_second_field: 102.5, the_third_field: false} +// gdb-check:$1 = gdb_pretty_struct_and_enums::RegularStruct {the_first_field: 101, the_second_field: 102.5, the_third_field: false} // gdb-command: print empty_struct -// gdbr-check:$2 = gdb_pretty_struct_and_enums::EmptyStruct +// gdb-check:$2 = gdb_pretty_struct_and_enums::EmptyStruct // gdb-command: print c_style_enum1 -// gdbr-check:$3 = gdb_pretty_struct_and_enums::CStyleEnum::CStyleEnumVar1 +// gdb-check:$3 = gdb_pretty_struct_and_enums::CStyleEnum::CStyleEnumVar1 // gdb-command: print c_style_enum2 -// gdbr-check:$4 = gdb_pretty_struct_and_enums::CStyleEnum::CStyleEnumVar2 +// gdb-check:$4 = gdb_pretty_struct_and_enums::CStyleEnum::CStyleEnumVar2 // gdb-command: print c_style_enum3 -// gdbr-check:$5 = gdb_pretty_struct_and_enums::CStyleEnum::CStyleEnumVar3 +// gdb-check:$5 = gdb_pretty_struct_and_enums::CStyleEnum::CStyleEnumVar3 #![allow(dead_code, unused_variables)] diff --git a/tests/debuginfo/generic-enum-with-different-disr-sizes.rs b/tests/debuginfo/generic-enum-with-different-disr-sizes.rs index 7b23221213a5..03118a11aadd 100644 --- a/tests/debuginfo/generic-enum-with-different-disr-sizes.rs +++ b/tests/debuginfo/generic-enum-with-different-disr-sizes.rs @@ -10,29 +10,29 @@ // gdb-command:run // gdb-command:print eight_bytes1 -// gdbr-check:$1 = generic_enum_with_different_disr_sizes::Enum::Variant1(100) +// gdb-check:$1 = generic_enum_with_different_disr_sizes::Enum::Variant1(100) // gdb-command:print four_bytes1 -// gdbr-check:$2 = generic_enum_with_different_disr_sizes::Enum::Variant1(101) +// gdb-check:$2 = generic_enum_with_different_disr_sizes::Enum::Variant1(101) // gdb-command:print two_bytes1 -// gdbr-check:$3 = generic_enum_with_different_disr_sizes::Enum::Variant1(102) +// gdb-check:$3 = generic_enum_with_different_disr_sizes::Enum::Variant1(102) // gdb-command:print one_byte1 -// gdbr-check:$4 = generic_enum_with_different_disr_sizes::Enum::Variant1(65) +// gdb-check:$4 = generic_enum_with_different_disr_sizes::Enum::Variant1(65) // gdb-command:print eight_bytes2 -// gdbr-check:$5 = generic_enum_with_different_disr_sizes::Enum::Variant2(100) +// gdb-check:$5 = generic_enum_with_different_disr_sizes::Enum::Variant2(100) // gdb-command:print four_bytes2 -// gdbr-check:$6 = generic_enum_with_different_disr_sizes::Enum::Variant2(101) +// gdb-check:$6 = generic_enum_with_different_disr_sizes::Enum::Variant2(101) // gdb-command:print two_bytes2 -// gdbr-check:$7 = generic_enum_with_different_disr_sizes::Enum::Variant2(102) +// gdb-check:$7 = generic_enum_with_different_disr_sizes::Enum::Variant2(102) // gdb-command:print one_byte2 -// gdbr-check:$8 = generic_enum_with_different_disr_sizes::Enum::Variant2(65) +// gdb-check:$8 = generic_enum_with_different_disr_sizes::Enum::Variant2(65) // gdb-command:continue diff --git a/tests/debuginfo/generic-function.rs b/tests/debuginfo/generic-function.rs index 7378a5960f30..fce1a3f3ec52 100644 --- a/tests/debuginfo/generic-function.rs +++ b/tests/debuginfo/generic-function.rs @@ -21,7 +21,7 @@ // gdb-command:print *t0 // gdb-check:$5 = 5 // gdb-command:print *t1 -// gdbr-check:$6 = generic_function::Struct {a: 6, b: 7.5} +// gdb-check:$6 = generic_function::Struct {a: 6, b: 7.5} // gdb-command:continue // === LLDB TESTS ================================================================================== diff --git a/tests/debuginfo/generic-method-on-generic-struct.rs b/tests/debuginfo/generic-method-on-generic-struct.rs index 0b7bee53daba..0f72e2b092be 100644 --- a/tests/debuginfo/generic-method-on-generic-struct.rs +++ b/tests/debuginfo/generic-method-on-generic-struct.rs @@ -10,7 +10,7 @@ // STACK BY REF // gdb-command:print *self -// gdbr-check:$1 = generic_method_on_generic_struct::Struct<(u32, i32)> {x: (8888, -8888)} +// gdb-check:$1 = generic_method_on_generic_struct::Struct<(u32, i32)> {x: (8888, -8888)} // gdb-command:print arg1 // gdb-check:$2 = -1 // gdb-command:print arg2 @@ -19,7 +19,7 @@ // STACK BY VAL // gdb-command:print self -// gdbr-check:$4 = generic_method_on_generic_struct::Struct<(u32, i32)> {x: (8888, -8888)} +// gdb-check:$4 = generic_method_on_generic_struct::Struct<(u32, i32)> {x: (8888, -8888)} // gdb-command:print arg1 // gdb-check:$5 = -3 // gdb-command:print arg2 @@ -28,7 +28,7 @@ // OWNED BY REF // gdb-command:print *self -// gdbr-check:$7 = generic_method_on_generic_struct::Struct {x: 1234.5} +// gdb-check:$7 = generic_method_on_generic_struct::Struct {x: 1234.5} // gdb-command:print arg1 // gdb-check:$8 = -5 // gdb-command:print arg2 @@ -37,7 +37,7 @@ // OWNED BY VAL // gdb-command:print self -// gdbr-check:$10 = generic_method_on_generic_struct::Struct {x: 1234.5} +// gdb-check:$10 = generic_method_on_generic_struct::Struct {x: 1234.5} // gdb-command:print arg1 // gdb-check:$11 = -7 // gdb-command:print arg2 @@ -46,7 +46,7 @@ // OWNED MOVED // gdb-command:print *self -// gdbr-check:$13 = generic_method_on_generic_struct::Struct {x: 1234.5} +// gdb-check:$13 = generic_method_on_generic_struct::Struct {x: 1234.5} // gdb-command:print arg1 // gdb-check:$14 = -9 // gdb-command:print arg2 diff --git a/tests/debuginfo/generic-struct-style-enum.rs b/tests/debuginfo/generic-struct-style-enum.rs index 7d929b91064c..7be1922d2671 100644 --- a/tests/debuginfo/generic-struct-style-enum.rs +++ b/tests/debuginfo/generic-struct-style-enum.rs @@ -9,16 +9,16 @@ // gdb-command:run // gdb-command:print case1 -// gdbr-check:$1 = generic_struct_style_enum::Regular::Case1{a: 0, b: 31868, c: 31868, d: 31868, e: 31868} +// gdb-check:$1 = generic_struct_style_enum::Regular::Case1{a: 0, b: 31868, c: 31868, d: 31868, e: 31868} // gdb-command:print case2 -// gdbr-check:$2 = generic_struct_style_enum::Regular::Case2{a: 0, b: 286331153, c: 286331153} +// gdb-check:$2 = generic_struct_style_enum::Regular::Case2{a: 0, b: 286331153, c: 286331153} // gdb-command:print case3 -// gdbr-check:$3 = generic_struct_style_enum::Regular::Case3{a: 0, b: 6438275382588823897} +// gdb-check:$3 = generic_struct_style_enum::Regular::Case3{a: 0, b: 6438275382588823897} // gdb-command:print univariant -// gdbr-check:$4 = generic_struct_style_enum::Univariant::TheOnlyCase{a: -1} +// gdb-check:$4 = generic_struct_style_enum::Univariant::TheOnlyCase{a: -1} #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/generic-struct.rs b/tests/debuginfo/generic-struct.rs index 7a0caf280a4b..df01d33a0dc5 100644 --- a/tests/debuginfo/generic-struct.rs +++ b/tests/debuginfo/generic-struct.rs @@ -9,13 +9,13 @@ // gdb-command:run // gdb-command:print int_int -// gdbr-check:$1 = generic_struct::AGenericStruct {key: 0, value: 1} +// gdb-check:$1 = generic_struct::AGenericStruct {key: 0, value: 1} // gdb-command:print int_float -// gdbr-check:$2 = generic_struct::AGenericStruct {key: 2, value: 3.5} +// gdb-check:$2 = generic_struct::AGenericStruct {key: 2, value: 3.5} // gdb-command:print float_int -// gdbr-check:$3 = generic_struct::AGenericStruct {key: 4.5, value: 5} +// gdb-check:$3 = generic_struct::AGenericStruct {key: 4.5, value: 5} // gdb-command:print float_int_float -// gdbr-check:$4 = generic_struct::AGenericStruct> {key: 6.5, value: generic_struct::AGenericStruct {key: 7, value: 8.5}} +// gdb-check:$4 = generic_struct::AGenericStruct> {key: 6.5, value: generic_struct::AGenericStruct {key: 7, value: 8.5}} // === LLDB TESTS ================================================================================== diff --git a/tests/debuginfo/generic-tuple-style-enum.rs b/tests/debuginfo/generic-tuple-style-enum.rs index af90c6ce30ea..feb62a1f5d1f 100644 --- a/tests/debuginfo/generic-tuple-style-enum.rs +++ b/tests/debuginfo/generic-tuple-style-enum.rs @@ -10,16 +10,16 @@ // gdb-command:run // gdb-command:print case1 -// gdbr-check:$1 = generic_tuple_style_enum::Regular::Case1(0, 31868, 31868, 31868, 31868) +// gdb-check:$1 = generic_tuple_style_enum::Regular::Case1(0, 31868, 31868, 31868, 31868) // gdb-command:print case2 -// gdbr-check:$2 = generic_tuple_style_enum::Regular::Case2(0, 286331153, 286331153) +// gdb-check:$2 = generic_tuple_style_enum::Regular::Case2(0, 286331153, 286331153) // gdb-command:print case3 -// gdbr-check:$3 = generic_tuple_style_enum::Regular::Case3(0, 6438275382588823897) +// gdb-check:$3 = generic_tuple_style_enum::Regular::Case3(0, 6438275382588823897) // gdb-command:print univariant -// gdbr-check:$4 = generic_tuple_style_enum::Univariant::TheOnlyCase(-1) +// gdb-check:$4 = generic_tuple_style_enum::Univariant::TheOnlyCase(-1) // === LLDB TESTS ================================================================================== diff --git a/tests/debuginfo/lexical-scopes-in-block-expression.rs b/tests/debuginfo/lexical-scopes-in-block-expression.rs index 62a9ec0d19d1..46af09f09343 100644 --- a/tests/debuginfo/lexical-scopes-in-block-expression.rs +++ b/tests/debuginfo/lexical-scopes-in-block-expression.rs @@ -6,7 +6,7 @@ // gdb-command:run -// gdbr-command:print lexical_scopes_in_block_expression::MUT_INT +// gdb-command:print lexical_scopes_in_block_expression::MUT_INT // gdb-check:$1 = 0 // STRUCT EXPRESSION @@ -18,7 +18,7 @@ // gdb-command:print val // gdb-check:$4 = 11 -// gdbr-command:print lexical_scopes_in_block_expression::MUT_INT +// gdb-command:print lexical_scopes_in_block_expression::MUT_INT // gdb-check:$5 = 1 // gdb-command:print ten // gdb-check:$6 = 10 @@ -39,7 +39,7 @@ // gdb-command:print val // gdb-check:$11 = 12 -// gdbr-command:print lexical_scopes_in_block_expression::MUT_INT +// gdb-command:print lexical_scopes_in_block_expression::MUT_INT // gdb-check:$12 = 2 // gdb-command:print ten // gdb-check:$13 = 10 @@ -60,7 +60,7 @@ // gdb-command:print val // gdb-check:$18 = 13 -// gdbr-command:print lexical_scopes_in_block_expression::MUT_INT +// gdb-command:print lexical_scopes_in_block_expression::MUT_INT // gdb-check:$19 = 3 // gdb-command:print ten // gdb-check:$20 = 10 @@ -81,7 +81,7 @@ // gdb-command:print val // gdb-check:$25 = 14 -// gdbr-command:print lexical_scopes_in_block_expression::MUT_INT +// gdb-command:print lexical_scopes_in_block_expression::MUT_INT // gdb-check:$26 = 4 // gdb-command:print ten // gdb-check:$27 = 10 @@ -102,7 +102,7 @@ // gdb-command:print val // gdb-check:$32 = 15 -// gdbr-command:print lexical_scopes_in_block_expression::MUT_INT +// gdb-command:print lexical_scopes_in_block_expression::MUT_INT // gdb-check:$33 = 5 // gdb-command:print ten // gdb-check:$34 = 10 @@ -123,7 +123,7 @@ // gdb-command:print val // gdb-check:$39 = 16 -// gdbr-command:print lexical_scopes_in_block_expression::MUT_INT +// gdb-command:print lexical_scopes_in_block_expression::MUT_INT // gdb-check:$40 = 6 // gdb-command:print ten // gdb-check:$41 = 10 @@ -145,7 +145,7 @@ // gdb-command:print val // gdb-check:$46 = 17 -// gdbr-command:print lexical_scopes_in_block_expression::MUT_INT +// gdb-command:print lexical_scopes_in_block_expression::MUT_INT // gdb-check:$47 = 7 // gdb-command:print ten // gdb-check:$48 = 10 @@ -166,7 +166,7 @@ // gdb-command:print val // gdb-check:$53 = 18 -// gdbr-command:print lexical_scopes_in_block_expression::MUT_INT +// gdb-command:print lexical_scopes_in_block_expression::MUT_INT // gdb-check:$54 = 8 // gdb-command:print ten // gdb-check:$55 = 10 diff --git a/tests/debuginfo/limited-debuginfo.rs b/tests/debuginfo/limited-debuginfo.rs index e82e8e26aca7..fb453d8078ce 100644 --- a/tests/debuginfo/limited-debuginfo.rs +++ b/tests/debuginfo/limited-debuginfo.rs @@ -4,10 +4,10 @@ // Make sure functions have proper names // gdb-command:info functions -// gdbr-check:fn limited_debuginfo::main(); -// gdbr-check:fn limited_debuginfo::some_function(); -// gdbr-check:fn limited_debuginfo::some_other_function(); -// gdbr-check:fn limited_debuginfo::zzz(); +// gdb-check:fn limited_debuginfo::main(); +// gdb-check:fn limited_debuginfo::some_function(); +// gdb-check:fn limited_debuginfo::some_other_function(); +// gdb-check:fn limited_debuginfo::zzz(); // gdb-command:run diff --git a/tests/debuginfo/method-on-enum.rs b/tests/debuginfo/method-on-enum.rs index 1d447686b000..a570144450d7 100644 --- a/tests/debuginfo/method-on-enum.rs +++ b/tests/debuginfo/method-on-enum.rs @@ -9,7 +9,7 @@ // STACK BY REF // gdb-command:print *self -// gdbr-check:$1 = method_on_enum::Enum::Variant2(117901063) +// gdb-check:$1 = method_on_enum::Enum::Variant2(117901063) // gdb-command:print arg1 // gdb-check:$2 = -1 // gdb-command:print arg2 @@ -18,7 +18,7 @@ // STACK BY VAL // gdb-command:print self -// gdbr-check:$4 = method_on_enum::Enum::Variant2(117901063) +// gdb-check:$4 = method_on_enum::Enum::Variant2(117901063) // gdb-command:print arg1 // gdb-check:$5 = -3 // gdb-command:print arg2 @@ -27,7 +27,7 @@ // OWNED BY REF // gdb-command:print *self -// gdbr-check:$7 = method_on_enum::Enum::Variant1{x: 1799, y: 1799} +// gdb-check:$7 = method_on_enum::Enum::Variant1{x: 1799, y: 1799} // gdb-command:print arg1 // gdb-check:$8 = -5 // gdb-command:print arg2 @@ -36,7 +36,7 @@ // OWNED BY VAL // gdb-command:print self -// gdbr-check:$10 = method_on_enum::Enum::Variant1{x: 1799, y: 1799} +// gdb-check:$10 = method_on_enum::Enum::Variant1{x: 1799, y: 1799} // gdb-command:print arg1 // gdb-check:$11 = -7 // gdb-command:print arg2 @@ -45,7 +45,7 @@ // OWNED MOVED // gdb-command:print *self -// gdbr-check:$13 = method_on_enum::Enum::Variant1{x: 1799, y: 1799} +// gdb-check:$13 = method_on_enum::Enum::Variant1{x: 1799, y: 1799} // gdb-command:print arg1 // gdb-check:$14 = -9 // gdb-command:print arg2 diff --git a/tests/debuginfo/method-on-generic-struct.rs b/tests/debuginfo/method-on-generic-struct.rs index d8f5508090d5..c20c1cec9db7 100644 --- a/tests/debuginfo/method-on-generic-struct.rs +++ b/tests/debuginfo/method-on-generic-struct.rs @@ -10,7 +10,7 @@ // STACK BY REF // gdb-command:print *self -// gdbr-check:$1 = method_on_generic_struct::Struct<(u32, i32)> {x: (8888, -8888)} +// gdb-check:$1 = method_on_generic_struct::Struct<(u32, i32)> {x: (8888, -8888)} // gdb-command:print arg1 // gdb-check:$2 = -1 // gdb-command:print arg2 @@ -19,7 +19,7 @@ // STACK BY VAL // gdb-command:print self -// gdbr-check:$4 = method_on_generic_struct::Struct<(u32, i32)> {x: (8888, -8888)} +// gdb-check:$4 = method_on_generic_struct::Struct<(u32, i32)> {x: (8888, -8888)} // gdb-command:print arg1 // gdb-check:$5 = -3 // gdb-command:print arg2 @@ -28,7 +28,7 @@ // OWNED BY REF // gdb-command:print *self -// gdbr-check:$7 = method_on_generic_struct::Struct {x: 1234.5} +// gdb-check:$7 = method_on_generic_struct::Struct {x: 1234.5} // gdb-command:print arg1 // gdb-check:$8 = -5 // gdb-command:print arg2 @@ -37,7 +37,7 @@ // OWNED BY VAL // gdb-command:print self -// gdbr-check:$10 = method_on_generic_struct::Struct {x: 1234.5} +// gdb-check:$10 = method_on_generic_struct::Struct {x: 1234.5} // gdb-command:print arg1 // gdb-check:$11 = -7 // gdb-command:print arg2 @@ -46,7 +46,7 @@ // OWNED MOVED // gdb-command:print *self -// gdbr-check:$13 = method_on_generic_struct::Struct {x: 1234.5} +// gdb-check:$13 = method_on_generic_struct::Struct {x: 1234.5} // gdb-command:print arg1 // gdb-check:$14 = -9 // gdb-command:print arg2 diff --git a/tests/debuginfo/method-on-struct.rs b/tests/debuginfo/method-on-struct.rs index c2632dafc394..eef1b1043b81 100644 --- a/tests/debuginfo/method-on-struct.rs +++ b/tests/debuginfo/method-on-struct.rs @@ -8,7 +8,7 @@ // STACK BY REF // gdb-command:print *self -// gdbr-check:$1 = method_on_struct::Struct {x: 100} +// gdb-check:$1 = method_on_struct::Struct {x: 100} // gdb-command:print arg1 // gdb-check:$2 = -1 // gdb-command:print arg2 @@ -17,7 +17,7 @@ // STACK BY VAL // gdb-command:print self -// gdbr-check:$4 = method_on_struct::Struct {x: 100} +// gdb-check:$4 = method_on_struct::Struct {x: 100} // gdb-command:print arg1 // gdb-check:$5 = -3 // gdb-command:print arg2 @@ -26,7 +26,7 @@ // OWNED BY REF // gdb-command:print *self -// gdbr-check:$7 = method_on_struct::Struct {x: 200} +// gdb-check:$7 = method_on_struct::Struct {x: 200} // gdb-command:print arg1 // gdb-check:$8 = -5 // gdb-command:print arg2 @@ -35,7 +35,7 @@ // OWNED BY VAL // gdb-command:print self -// gdbr-check:$10 = method_on_struct::Struct {x: 200} +// gdb-check:$10 = method_on_struct::Struct {x: 200} // gdb-command:print arg1 // gdb-check:$11 = -7 // gdb-command:print arg2 @@ -44,7 +44,7 @@ // OWNED MOVED // gdb-command:print *self -// gdbr-check:$13 = method_on_struct::Struct {x: 200} +// gdb-check:$13 = method_on_struct::Struct {x: 200} // gdb-command:print arg1 // gdb-check:$14 = -9 // gdb-command:print arg2 diff --git a/tests/debuginfo/method-on-trait.rs b/tests/debuginfo/method-on-trait.rs index 9172c6976a1a..ff4f6c5e131e 100644 --- a/tests/debuginfo/method-on-trait.rs +++ b/tests/debuginfo/method-on-trait.rs @@ -8,7 +8,7 @@ // STACK BY REF // gdb-command:print *self -// gdbr-check:$1 = method_on_trait::Struct {x: 100} +// gdb-check:$1 = method_on_trait::Struct {x: 100} // gdb-command:print arg1 // gdb-check:$2 = -1 // gdb-command:print arg2 @@ -17,7 +17,7 @@ // STACK BY VAL // gdb-command:print self -// gdbr-check:$4 = method_on_trait::Struct {x: 100} +// gdb-check:$4 = method_on_trait::Struct {x: 100} // gdb-command:print arg1 // gdb-check:$5 = -3 // gdb-command:print arg2 @@ -26,7 +26,7 @@ // OWNED BY REF // gdb-command:print *self -// gdbr-check:$7 = method_on_trait::Struct {x: 200} +// gdb-check:$7 = method_on_trait::Struct {x: 200} // gdb-command:print arg1 // gdb-check:$8 = -5 // gdb-command:print arg2 @@ -35,7 +35,7 @@ // OWNED BY VAL // gdb-command:print self -// gdbr-check:$10 = method_on_trait::Struct {x: 200} +// gdb-check:$10 = method_on_trait::Struct {x: 200} // gdb-command:print arg1 // gdb-check:$11 = -7 // gdb-command:print arg2 @@ -44,7 +44,7 @@ // OWNED MOVED // gdb-command:print *self -// gdbr-check:$13 = method_on_trait::Struct {x: 200} +// gdb-check:$13 = method_on_trait::Struct {x: 200} // gdb-command:print arg1 // gdb-check:$14 = -9 // gdb-command:print arg2 diff --git a/tests/debuginfo/method-on-tuple-struct.rs b/tests/debuginfo/method-on-tuple-struct.rs index 71a11093f7d3..cb8014cace5d 100644 --- a/tests/debuginfo/method-on-tuple-struct.rs +++ b/tests/debuginfo/method-on-tuple-struct.rs @@ -8,7 +8,7 @@ // STACK BY REF // gdb-command:print *self -// gdbr-check:$1 = method_on_tuple_struct::TupleStruct (100, -100.5) +// gdb-check:$1 = method_on_tuple_struct::TupleStruct (100, -100.5) // gdb-command:print arg1 // gdb-check:$2 = -1 // gdb-command:print arg2 @@ -17,7 +17,7 @@ // STACK BY VAL // gdb-command:print self -// gdbr-check:$4 = method_on_tuple_struct::TupleStruct (100, -100.5) +// gdb-check:$4 = method_on_tuple_struct::TupleStruct (100, -100.5) // gdb-command:print arg1 // gdb-check:$5 = -3 // gdb-command:print arg2 @@ -26,7 +26,7 @@ // OWNED BY REF // gdb-command:print *self -// gdbr-check:$7 = method_on_tuple_struct::TupleStruct (200, -200.5) +// gdb-check:$7 = method_on_tuple_struct::TupleStruct (200, -200.5) // gdb-command:print arg1 // gdb-check:$8 = -5 // gdb-command:print arg2 @@ -35,7 +35,7 @@ // OWNED BY VAL // gdb-command:print self -// gdbr-check:$10 = method_on_tuple_struct::TupleStruct (200, -200.5) +// gdb-check:$10 = method_on_tuple_struct::TupleStruct (200, -200.5) // gdb-command:print arg1 // gdb-check:$11 = -7 // gdb-command:print arg2 @@ -44,7 +44,7 @@ // OWNED MOVED // gdb-command:print *self -// gdbr-check:$13 = method_on_tuple_struct::TupleStruct (200, -200.5) +// gdb-check:$13 = method_on_tuple_struct::TupleStruct (200, -200.5) // gdb-command:print arg1 // gdb-check:$14 = -9 // gdb-command:print arg2 diff --git a/tests/debuginfo/option-like-enum.rs b/tests/debuginfo/option-like-enum.rs index 159d8e976c7c..d370796efa9d 100644 --- a/tests/debuginfo/option-like-enum.rs +++ b/tests/debuginfo/option-like-enum.rs @@ -8,28 +8,28 @@ // gdb-command:run // gdb-command:print some -// gdbr-check:$1 = core::option::Option<&u32>::Some(0x12345678) +// gdb-check:$1 = core::option::Option<&u32>::Some(0x12345678) // gdb-command:print none -// gdbr-check:$2 = core::option::Option<&u32>::None +// gdb-check:$2 = core::option::Option<&u32>::None // gdb-command:print full -// gdbr-check:$3 = option_like_enum::MoreFields::Full(454545, 0x87654321, 9988) +// gdb-check:$3 = option_like_enum::MoreFields::Full(454545, 0x87654321, 9988) -// gdbr-command:print empty_gdb.discr +// gdb-command:print empty_gdb.discr // gdb-check:$4 = (*mut isize) 0x1 // gdb-command:print droid -// gdbr-check:$5 = option_like_enum::NamedFields::Droid{id: 675675, range: 10000001, internals: 0x43218765} +// gdb-check:$5 = option_like_enum::NamedFields::Droid{id: 675675, range: 10000001, internals: 0x43218765} -// gdbr-command:print void_droid_gdb.internals +// gdb-command:print void_droid_gdb.internals // gdb-check:$6 = (*mut isize) 0x1 // gdb-command:print nested_non_zero_yep -// gdbr-check:$7 = option_like_enum::NestedNonZero::Yep(10.5, option_like_enum::NestedNonZeroField {a: 10, b: 20, c: 0x[...]}) +// gdb-check:$7 = option_like_enum::NestedNonZero::Yep(10.5, option_like_enum::NestedNonZeroField {a: 10, b: 20, c: 0x[...]}) // gdb-command:print nested_non_zero_nope -// gdbr-check:$8 = option_like_enum::NestedNonZero::Nope +// gdb-check:$8 = option_like_enum::NestedNonZero::Nope // gdb-command:continue diff --git a/tests/debuginfo/packed-struct-with-destructor.rs b/tests/debuginfo/packed-struct-with-destructor.rs index afd0d570b0b3..e3138b1185fa 100644 --- a/tests/debuginfo/packed-struct-with-destructor.rs +++ b/tests/debuginfo/packed-struct-with-destructor.rs @@ -7,29 +7,29 @@ // gdb-command:run // gdb-command:print packed -// gdbr-check:$1 = packed_struct_with_destructor::Packed {x: 123, y: 234, z: 345} +// gdb-check:$1 = packed_struct_with_destructor::Packed {x: 123, y: 234, z: 345} // gdb-command:print packedInPacked -// gdbr-check:$2 = packed_struct_with_destructor::PackedInPacked {a: 1111, b: packed_struct_with_destructor::Packed {x: 2222, y: 3333, z: 4444}, c: 5555, d: packed_struct_with_destructor::Packed {x: 6666, y: 7777, z: 8888}} +// gdb-check:$2 = packed_struct_with_destructor::PackedInPacked {a: 1111, b: packed_struct_with_destructor::Packed {x: 2222, y: 3333, z: 4444}, c: 5555, d: packed_struct_with_destructor::Packed {x: 6666, y: 7777, z: 8888}} // gdb-command:print packedInUnpacked -// gdbr-check:$3 = packed_struct_with_destructor::PackedInUnpacked {a: -1111, b: packed_struct_with_destructor::Packed {x: -2222, y: -3333, z: -4444}, c: -5555, d: packed_struct_with_destructor::Packed {x: -6666, y: -7777, z: -8888}} +// gdb-check:$3 = packed_struct_with_destructor::PackedInUnpacked {a: -1111, b: packed_struct_with_destructor::Packed {x: -2222, y: -3333, z: -4444}, c: -5555, d: packed_struct_with_destructor::Packed {x: -6666, y: -7777, z: -8888}} // gdb-command:print unpackedInPacked -// gdbr-check:$4 = packed_struct_with_destructor::UnpackedInPacked {a: 987, b: packed_struct_with_destructor::Unpacked {x: 876, y: 765, z: 654}, c: packed_struct_with_destructor::Unpacked {x: 543, y: 432, z: 321}, d: 210} +// gdb-check:$4 = packed_struct_with_destructor::UnpackedInPacked {a: 987, b: packed_struct_with_destructor::Unpacked {x: 876, y: 765, z: 654}, c: packed_struct_with_destructor::Unpacked {x: 543, y: 432, z: 321}, d: 210} // gdb-command:print packedInPackedWithDrop -// gdbr-check:$5 = packed_struct_with_destructor::PackedInPackedWithDrop {a: 11, b: packed_struct_with_destructor::Packed {x: 22, y: 33, z: 44}, c: 55, d: packed_struct_with_destructor::Packed {x: 66, y: 77, z: 88}} +// gdb-check:$5 = packed_struct_with_destructor::PackedInPackedWithDrop {a: 11, b: packed_struct_with_destructor::Packed {x: 22, y: 33, z: 44}, c: 55, d: packed_struct_with_destructor::Packed {x: 66, y: 77, z: 88}} // gdb-command:print packedInUnpackedWithDrop -// gdbr-check:$6 = packed_struct_with_destructor::PackedInUnpackedWithDrop {a: -11, b: packed_struct_with_destructor::Packed {x: -22, y: -33, z: -44}, c: -55, d: packed_struct_with_destructor::Packed {x: -66, y: -77, z: -88}} +// gdb-check:$6 = packed_struct_with_destructor::PackedInUnpackedWithDrop {a: -11, b: packed_struct_with_destructor::Packed {x: -22, y: -33, z: -44}, c: -55, d: packed_struct_with_destructor::Packed {x: -66, y: -77, z: -88}} // gdb-command:print unpackedInPackedWithDrop -// gdbr-check:$7 = packed_struct_with_destructor::UnpackedInPackedWithDrop {a: 98, b: packed_struct_with_destructor::Unpacked {x: 87, y: 76, z: 65}, c: packed_struct_with_destructor::Unpacked {x: 54, y: 43, z: 32}, d: 21} +// gdb-check:$7 = packed_struct_with_destructor::UnpackedInPackedWithDrop {a: 98, b: packed_struct_with_destructor::Unpacked {x: 87, y: 76, z: 65}, c: packed_struct_with_destructor::Unpacked {x: 54, y: 43, z: 32}, d: 21} // gdb-command:print deeplyNested -// gdbr-check:$8 = packed_struct_with_destructor::DeeplyNested {a: packed_struct_with_destructor::PackedInPacked {a: 1, b: packed_struct_with_destructor::Packed {x: 2, y: 3, z: 4}, c: 5, d: packed_struct_with_destructor::Packed {x: 6, y: 7, z: 8}}, b: packed_struct_with_destructor::UnpackedInPackedWithDrop {a: 9, b: packed_struct_with_destructor::Unpacked {x: 10, y: 11, z: 12}, c: packed_struct_with_destructor::Unpacked {x: 13, y: 14, z: 15}, d: 16}, c: packed_struct_with_destructor::PackedInUnpacked {a: 17, b: packed_struct_with_destructor::Packed {x: 18, y: 19, z: 20}, c: 21, d: packed_struct_with_destructor::Packed {x: 22, y: 23, z: 24}}, d: packed_struct_with_destructor::PackedInUnpackedWithDrop {a: 25, b: packed_struct_with_destructor::Packed {x: 26, y: 27, z: 28}, c: 29, d: packed_struct_with_destructor::Packed {x: 30, y: 31, z: 32}}, e: packed_struct_with_destructor::UnpackedInPacked {a: 33, b: packed_struct_with_destructor::Unpacked {x: 34, y: 35, z: 36}, c: packed_struct_with_destructor::Unpacked {x: 37, y: 38, z: 39}, d: 40}, f: packed_struct_with_destructor::PackedInPackedWithDrop {a: 41, b: packed_struct_with_destructor::Packed {x: 42, y: 43, z: 44}, c: 45, d: packed_struct_with_destructor::Packed {x: 46, y: 47, z: 48}}} +// gdb-check:$8 = packed_struct_with_destructor::DeeplyNested {a: packed_struct_with_destructor::PackedInPacked {a: 1, b: packed_struct_with_destructor::Packed {x: 2, y: 3, z: 4}, c: 5, d: packed_struct_with_destructor::Packed {x: 6, y: 7, z: 8}}, b: packed_struct_with_destructor::UnpackedInPackedWithDrop {a: 9, b: packed_struct_with_destructor::Unpacked {x: 10, y: 11, z: 12}, c: packed_struct_with_destructor::Unpacked {x: 13, y: 14, z: 15}, d: 16}, c: packed_struct_with_destructor::PackedInUnpacked {a: 17, b: packed_struct_with_destructor::Packed {x: 18, y: 19, z: 20}, c: 21, d: packed_struct_with_destructor::Packed {x: 22, y: 23, z: 24}}, d: packed_struct_with_destructor::PackedInUnpackedWithDrop {a: 25, b: packed_struct_with_destructor::Packed {x: 26, y: 27, z: 28}, c: 29, d: packed_struct_with_destructor::Packed {x: 30, y: 31, z: 32}}, e: packed_struct_with_destructor::UnpackedInPacked {a: 33, b: packed_struct_with_destructor::Unpacked {x: 34, y: 35, z: 36}, c: packed_struct_with_destructor::Unpacked {x: 37, y: 38, z: 39}, d: 40}, f: packed_struct_with_destructor::PackedInPackedWithDrop {a: 41, b: packed_struct_with_destructor::Packed {x: 42, y: 43, z: 44}, c: 45, d: packed_struct_with_destructor::Packed {x: 46, y: 47, z: 48}}} // === LLDB TESTS ================================================================================== diff --git a/tests/debuginfo/packed-struct.rs b/tests/debuginfo/packed-struct.rs index 6ef4995bc16d..cfff4c27d705 100644 --- a/tests/debuginfo/packed-struct.rs +++ b/tests/debuginfo/packed-struct.rs @@ -8,16 +8,16 @@ // gdb-command:run // gdb-command:print packed -// gdbr-check:$1 = packed_struct::Packed {x: 123, y: 234, z: 345} +// gdb-check:$1 = packed_struct::Packed {x: 123, y: 234, z: 345} // gdb-command:print packedInPacked -// gdbr-check:$2 = packed_struct::PackedInPacked {a: 1111, b: packed_struct::Packed {x: 2222, y: 3333, z: 4444}, c: 5555, d: packed_struct::Packed {x: 6666, y: 7777, z: 8888}} +// gdb-check:$2 = packed_struct::PackedInPacked {a: 1111, b: packed_struct::Packed {x: 2222, y: 3333, z: 4444}, c: 5555, d: packed_struct::Packed {x: 6666, y: 7777, z: 8888}} // gdb-command:print packedInUnpacked -// gdbr-check:$3 = packed_struct::PackedInUnpacked {a: -1111, b: packed_struct::Packed {x: -2222, y: -3333, z: -4444}, c: -5555, d: packed_struct::Packed {x: -6666, y: -7777, z: -8888}} +// gdb-check:$3 = packed_struct::PackedInUnpacked {a: -1111, b: packed_struct::Packed {x: -2222, y: -3333, z: -4444}, c: -5555, d: packed_struct::Packed {x: -6666, y: -7777, z: -8888}} // gdb-command:print unpackedInPacked -// gdbr-check:$4 = packed_struct::UnpackedInPacked {a: 987, b: packed_struct::Unpacked {x: 876, y: 765, z: 654, w: 543}, c: packed_struct::Unpacked {x: 432, y: 321, z: 210, w: 109}, d: -98} +// gdb-check:$4 = packed_struct::UnpackedInPacked {a: 987, b: packed_struct::Unpacked {x: 876, y: 765, z: 654, w: 543}, c: packed_struct::Unpacked {x: 432, y: 321, z: 210, w: 109}, d: -98} // gdb-command:print sizeof(packed) // gdb-check:$5 = 14 diff --git a/tests/debuginfo/pretty-slices.rs b/tests/debuginfo/pretty-slices.rs index 90cad4e6639e..f1aad836434e 100644 --- a/tests/debuginfo/pretty-slices.rs +++ b/tests/debuginfo/pretty-slices.rs @@ -5,10 +5,10 @@ // gdb-command: run // gdb-command: print slice -// gdbr-check: $1 = &[i32](size=3) = {0, 1, 2} +// gdb-check: $1 = &[i32](size=3) = {0, 1, 2} // gdb-command: print mut_slice -// gdbr-check: $2 = &mut [i32](size=4) = {2, 3, 5, 7} +// gdb-check: $2 = &mut [i32](size=4) = {2, 3, 5, 7} // gdb-command: print str_slice // gdb-check: $3 = "string slice" diff --git a/tests/debuginfo/pretty-std.rs b/tests/debuginfo/pretty-std.rs index c42bdc5ee3fc..e33d0b237be0 100644 --- a/tests/debuginfo/pretty-std.rs +++ b/tests/debuginfo/pretty-std.rs @@ -26,7 +26,7 @@ // gdb-check:$5 = core::option::Option::Some(8) // gdb-command: print none -// gdbr-check:$6 = core::option::Option::None +// gdb-check:$6 = core::option::Option::None // gdb-command: print os_string // gdb-check:$7 = "IAMA OS string 😃" diff --git a/tests/debuginfo/recursive-struct.rs b/tests/debuginfo/recursive-struct.rs index 1d039527d1ab..d6f5b9f2868d 100644 --- a/tests/debuginfo/recursive-struct.rs +++ b/tests/debuginfo/recursive-struct.rs @@ -9,53 +9,53 @@ // gdb-command:print stack_unique.value // gdb-check:$1 = 0 -// gdbr-command:print stack_unique.next.val.value +// gdb-command:print stack_unique.next.val.value // gdb-check:$2 = 1 -// gdbr-command:print unique_unique.value +// gdb-command:print unique_unique.value // gdb-check:$3 = 2 -// gdbr-command:print unique_unique.next.val.value +// gdb-command:print unique_unique.next.val.value // gdb-check:$4 = 3 // gdb-command:print vec_unique[0].value // gdb-check:$5 = 6.5 -// gdbr-command:print vec_unique[0].next.val.value +// gdb-command:print vec_unique[0].next.val.value // gdb-check:$6 = 7.5 -// gdbr-command:print borrowed_unique.value +// gdb-command:print borrowed_unique.value // gdb-check:$7 = 8.5 -// gdbr-command:print borrowed_unique.next.val.value +// gdb-command:print borrowed_unique.next.val.value // gdb-check:$8 = 9.5 // LONG CYCLE // gdb-command:print long_cycle1.value // gdb-check:$9 = 20 -// gdbr-command:print long_cycle1.next.value +// gdb-command:print long_cycle1.next.value // gdb-check:$10 = 21 -// gdbr-command:print long_cycle1.next.next.value +// gdb-command:print long_cycle1.next.next.value // gdb-check:$11 = 22 -// gdbr-command:print long_cycle1.next.next.next.value +// gdb-command:print long_cycle1.next.next.next.value // gdb-check:$12 = 23 // gdb-command:print long_cycle2.value // gdb-check:$13 = 24 -// gdbr-command:print long_cycle2.next.value +// gdb-command:print long_cycle2.next.value // gdb-check:$14 = 25 -// gdbr-command:print long_cycle2.next.next.value +// gdb-command:print long_cycle2.next.next.value // gdb-check:$15 = 26 // gdb-command:print long_cycle3.value // gdb-check:$16 = 27 -// gdbr-command:print long_cycle3.next.value +// gdb-command:print long_cycle3.next.value // gdb-check:$17 = 28 // gdb-command:print long_cycle4.value // gdb-check:$18 = 29.5 -// gdbr-command:print long_cycle_w_anon_types.value +// gdb-command:print long_cycle_w_anon_types.value // gdb-check:$19 = 30 -// gdbr-command:print long_cycle_w_anon_types.next.val.value +// gdb-command:print long_cycle_w_anon_types.next.val.value // gdb-check:$20 = 31 // gdb-command:continue diff --git a/tests/debuginfo/reference-debuginfo.rs b/tests/debuginfo/reference-debuginfo.rs index d59cf61420f2..c21a2f01f2f9 100644 --- a/tests/debuginfo/reference-debuginfo.rs +++ b/tests/debuginfo/reference-debuginfo.rs @@ -18,7 +18,7 @@ // gdb-check:$3 = 97 // gdb-command:print *i8_ref -// gdbr-check:$4 = 68 +// gdb-check:$4 = 68 // gdb-command:print *i16_ref // gdb-check:$5 = -16 @@ -33,7 +33,7 @@ // gdb-check:$8 = 1 // gdb-command:print *u8_ref -// gdbr-check:$9 = 100 +// gdb-check:$9 = 100 // gdb-command:print *u16_ref // gdb-check:$10 = 16 diff --git a/tests/debuginfo/self-in-default-method.rs b/tests/debuginfo/self-in-default-method.rs index 89e1a8fab2b9..e5a53bb618db 100644 --- a/tests/debuginfo/self-in-default-method.rs +++ b/tests/debuginfo/self-in-default-method.rs @@ -8,7 +8,7 @@ // STACK BY REF // gdb-command:print *self -// gdbr-check:$1 = self_in_default_method::Struct {x: 100} +// gdb-check:$1 = self_in_default_method::Struct {x: 100} // gdb-command:print arg1 // gdb-check:$2 = -1 // gdb-command:print arg2 @@ -17,7 +17,7 @@ // STACK BY VAL // gdb-command:print self -// gdbr-check:$4 = self_in_default_method::Struct {x: 100} +// gdb-check:$4 = self_in_default_method::Struct {x: 100} // gdb-command:print arg1 // gdb-check:$5 = -3 // gdb-command:print arg2 @@ -26,7 +26,7 @@ // OWNED BY REF // gdb-command:print *self -// gdbr-check:$7 = self_in_default_method::Struct {x: 200} +// gdb-check:$7 = self_in_default_method::Struct {x: 200} // gdb-command:print arg1 // gdb-check:$8 = -5 // gdb-command:print arg2 @@ -35,7 +35,7 @@ // OWNED BY VAL // gdb-command:print self -// gdbr-check:$10 = self_in_default_method::Struct {x: 200} +// gdb-check:$10 = self_in_default_method::Struct {x: 200} // gdb-command:print arg1 // gdb-check:$11 = -7 // gdb-command:print arg2 @@ -44,7 +44,7 @@ // OWNED MOVED // gdb-command:print *self -// gdbr-check:$13 = self_in_default_method::Struct {x: 200} +// gdb-check:$13 = self_in_default_method::Struct {x: 200} // gdb-command:print arg1 // gdb-check:$14 = -9 // gdb-command:print arg2 diff --git a/tests/debuginfo/self-in-generic-default-method.rs b/tests/debuginfo/self-in-generic-default-method.rs index b4908486cdf8..8c6abad83771 100644 --- a/tests/debuginfo/self-in-generic-default-method.rs +++ b/tests/debuginfo/self-in-generic-default-method.rs @@ -8,7 +8,7 @@ // STACK BY REF // gdb-command:print *self -// gdbr-check:$1 = self_in_generic_default_method::Struct {x: 987} +// gdb-check:$1 = self_in_generic_default_method::Struct {x: 987} // gdb-command:print arg1 // gdb-check:$2 = -1 // gdb-command:print arg2 @@ -17,7 +17,7 @@ // STACK BY VAL // gdb-command:print self -// gdbr-check:$4 = self_in_generic_default_method::Struct {x: 987} +// gdb-check:$4 = self_in_generic_default_method::Struct {x: 987} // gdb-command:print arg1 // gdb-check:$5 = -3 // gdb-command:print arg2 @@ -26,7 +26,7 @@ // OWNED BY REF // gdb-command:print *self -// gdbr-check:$7 = self_in_generic_default_method::Struct {x: 879} +// gdb-check:$7 = self_in_generic_default_method::Struct {x: 879} // gdb-command:print arg1 // gdb-check:$8 = -5 // gdb-command:print arg2 @@ -35,7 +35,7 @@ // OWNED BY VAL // gdb-command:print self -// gdbr-check:$10 = self_in_generic_default_method::Struct {x: 879} +// gdb-check:$10 = self_in_generic_default_method::Struct {x: 879} // gdb-command:print arg1 // gdb-check:$11 = -7 // gdb-command:print arg2 @@ -44,7 +44,7 @@ // OWNED MOVED // gdb-command:print *self -// gdbr-check:$13 = self_in_generic_default_method::Struct {x: 879} +// gdb-check:$13 = self_in_generic_default_method::Struct {x: 879} // gdb-command:print arg1 // gdb-check:$14 = -9 // gdb-command:print arg2 diff --git a/tests/debuginfo/simd.rs b/tests/debuginfo/simd.rs index 44a3efee3913..e4fe262235ba 100644 --- a/tests/debuginfo/simd.rs +++ b/tests/debuginfo/simd.rs @@ -9,28 +9,28 @@ //@ compile-flags:-g // gdb-command:run -// gdbr-command:print vi8x16 -// gdbr-check:$1 = simd::i8x16 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15) -// gdbr-command:print vi16x8 -// gdbr-check:$2 = simd::i16x8 (16, 17, 18, 19, 20, 21, 22, 23) -// gdbr-command:print vi32x4 -// gdbr-check:$3 = simd::i32x4 (24, 25, 26, 27) -// gdbr-command:print vi64x2 -// gdbr-check:$4 = simd::i64x2 (28, 29) +// gdb-command:print vi8x16 +// gdb-check:$1 = simd::i8x16 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15) +// gdb-command:print vi16x8 +// gdb-check:$2 = simd::i16x8 (16, 17, 18, 19, 20, 21, 22, 23) +// gdb-command:print vi32x4 +// gdb-check:$3 = simd::i32x4 (24, 25, 26, 27) +// gdb-command:print vi64x2 +// gdb-check:$4 = simd::i64x2 (28, 29) -// gdbr-command:print vu8x16 -// gdbr-check:$5 = simd::u8x16 (30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45) -// gdbr-command:print vu16x8 -// gdbr-check:$6 = simd::u16x8 (46, 47, 48, 49, 50, 51, 52, 53) -// gdbr-command:print vu32x4 -// gdbr-check:$7 = simd::u32x4 (54, 55, 56, 57) -// gdbr-command:print vu64x2 -// gdbr-check:$8 = simd::u64x2 (58, 59) +// gdb-command:print vu8x16 +// gdb-check:$5 = simd::u8x16 (30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45) +// gdb-command:print vu16x8 +// gdb-check:$6 = simd::u16x8 (46, 47, 48, 49, 50, 51, 52, 53) +// gdb-command:print vu32x4 +// gdb-check:$7 = simd::u32x4 (54, 55, 56, 57) +// gdb-command:print vu64x2 +// gdb-check:$8 = simd::u64x2 (58, 59) // gdb-command:print vf32x4 -// gdbr-check:$9 = simd::f32x4 (60.5, 61.5, 62.5, 63.5) +// gdb-check:$9 = simd::f32x4 (60.5, 61.5, 62.5, 63.5) // gdb-command:print vf64x2 -// gdbr-check:$10 = simd::f64x2 (64.5, 65.5) +// gdb-check:$10 = simd::f64x2 (64.5, 65.5) // gdb-command:continue diff --git a/tests/debuginfo/simple-struct.rs b/tests/debuginfo/simple-struct.rs index 54d543d90a4c..77bfb8a0676b 100644 --- a/tests/debuginfo/simple-struct.rs +++ b/tests/debuginfo/simple-struct.rs @@ -4,61 +4,61 @@ // === GDB TESTS =================================================================================== -// gdbr-command:print simple_struct::NO_PADDING_16 -// gdbr-check:$1 = simple_struct::NoPadding16 {x: 1000, y: -1001} +// gdb-command:print simple_struct::NO_PADDING_16 +// gdb-check:$1 = simple_struct::NoPadding16 {x: 1000, y: -1001} -// gdbr-command:print simple_struct::NO_PADDING_32 -// gdbr-check:$2 = simple_struct::NoPadding32 {x: 1, y: 2, z: 3} +// gdb-command:print simple_struct::NO_PADDING_32 +// gdb-check:$2 = simple_struct::NoPadding32 {x: 1, y: 2, z: 3} -// gdbr-command:print simple_struct::NO_PADDING_64 -// gdbr-check:$3 = simple_struct::NoPadding64 {x: 4, y: 5, z: 6} +// gdb-command:print simple_struct::NO_PADDING_64 +// gdb-check:$3 = simple_struct::NoPadding64 {x: 4, y: 5, z: 6} -// gdbr-command:print simple_struct::NO_PADDING_163264 -// gdbr-check:$4 = simple_struct::NoPadding163264 {a: 7, b: 8, c: 9, d: 10} +// gdb-command:print simple_struct::NO_PADDING_163264 +// gdb-check:$4 = simple_struct::NoPadding163264 {a: 7, b: 8, c: 9, d: 10} -// gdbr-command:print simple_struct::INTERNAL_PADDING -// gdbr-check:$5 = simple_struct::InternalPadding {x: 11, y: 12} +// gdb-command:print simple_struct::INTERNAL_PADDING +// gdb-check:$5 = simple_struct::InternalPadding {x: 11, y: 12} -// gdbr-command:print simple_struct::PADDING_AT_END -// gdbr-check:$6 = simple_struct::PaddingAtEnd {x: 13, y: 14} +// gdb-command:print simple_struct::PADDING_AT_END +// gdb-check:$6 = simple_struct::PaddingAtEnd {x: 13, y: 14} // gdb-command:run // gdb-command:print no_padding16 -// gdbr-check:$7 = simple_struct::NoPadding16 {x: 10000, y: -10001} +// gdb-check:$7 = simple_struct::NoPadding16 {x: 10000, y: -10001} // gdb-command:print no_padding32 -// gdbr-check:$8 = simple_struct::NoPadding32 {x: -10002, y: -10003.5, z: 10004} +// gdb-check:$8 = simple_struct::NoPadding32 {x: -10002, y: -10003.5, z: 10004} // gdb-command:print no_padding64 -// gdbr-check:$9 = simple_struct::NoPadding64 {x: -10005.5, y: 10006, z: 10007} +// gdb-check:$9 = simple_struct::NoPadding64 {x: -10005.5, y: 10006, z: 10007} // gdb-command:print no_padding163264 -// gdbr-check:$10 = simple_struct::NoPadding163264 {a: -10008, b: 10009, c: 10010, d: 10011} +// gdb-check:$10 = simple_struct::NoPadding163264 {a: -10008, b: 10009, c: 10010, d: 10011} // gdb-command:print internal_padding -// gdbr-check:$11 = simple_struct::InternalPadding {x: 10012, y: -10013} +// gdb-check:$11 = simple_struct::InternalPadding {x: 10012, y: -10013} // gdb-command:print padding_at_end -// gdbr-check:$12 = simple_struct::PaddingAtEnd {x: -10014, y: 10015} +// gdb-check:$12 = simple_struct::PaddingAtEnd {x: -10014, y: 10015} -// gdbr-command:print simple_struct::NO_PADDING_16 -// gdbr-check:$13 = simple_struct::NoPadding16 {x: 100, y: -101} +// gdb-command:print simple_struct::NO_PADDING_16 +// gdb-check:$13 = simple_struct::NoPadding16 {x: 100, y: -101} -// gdbr-command:print simple_struct::NO_PADDING_32 -// gdbr-check:$14 = simple_struct::NoPadding32 {x: -15, y: -16, z: 17} +// gdb-command:print simple_struct::NO_PADDING_32 +// gdb-check:$14 = simple_struct::NoPadding32 {x: -15, y: -16, z: 17} -// gdbr-command:print simple_struct::NO_PADDING_64 -// gdbr-check:$15 = simple_struct::NoPadding64 {x: -18, y: 19, z: 20} +// gdb-command:print simple_struct::NO_PADDING_64 +// gdb-check:$15 = simple_struct::NoPadding64 {x: -18, y: 19, z: 20} -// gdbr-command:print simple_struct::NO_PADDING_163264 -// gdbr-check:$16 = simple_struct::NoPadding163264 {a: -21, b: 22, c: 23, d: 24} +// gdb-command:print simple_struct::NO_PADDING_163264 +// gdb-check:$16 = simple_struct::NoPadding163264 {a: -21, b: 22, c: 23, d: 24} -// gdbr-command:print simple_struct::INTERNAL_PADDING -// gdbr-check:$17 = simple_struct::InternalPadding {x: 25, y: -26} +// gdb-command:print simple_struct::INTERNAL_PADDING +// gdb-check:$17 = simple_struct::InternalPadding {x: 25, y: -26} -// gdbr-command:print simple_struct::PADDING_AT_END -// gdbr-check:$18 = simple_struct::PaddingAtEnd {x: -27, y: 28} +// gdb-command:print simple_struct::PADDING_AT_END +// gdb-check:$18 = simple_struct::PaddingAtEnd {x: -27, y: 28} // gdb-command:continue diff --git a/tests/debuginfo/simple-tuple.rs b/tests/debuginfo/simple-tuple.rs index e19fb59cdc5c..eb1d5ab3c3d3 100644 --- a/tests/debuginfo/simple-tuple.rs +++ b/tests/debuginfo/simple-tuple.rs @@ -4,58 +4,58 @@ // === GDB TESTS =================================================================================== -// gdbr-command:print simple_tuple::NO_PADDING_8 -// gdbr-check:$1 = (-50, 50) -// gdbr-command:print simple_tuple::NO_PADDING_16 -// gdbr-check:$2 = (-1, 2, 3) -// gdbr-command:print simple_tuple::NO_PADDING_32 -// gdbr-check:$3 = (4, 5, 6) -// gdbr-command:print simple_tuple::NO_PADDING_64 -// gdbr-check:$4 = (7, 8, 9) +// gdb-command:print simple_tuple::NO_PADDING_8 +// gdb-check:$1 = (-50, 50) +// gdb-command:print simple_tuple::NO_PADDING_16 +// gdb-check:$2 = (-1, 2, 3) +// gdb-command:print simple_tuple::NO_PADDING_32 +// gdb-check:$3 = (4, 5, 6) +// gdb-command:print simple_tuple::NO_PADDING_64 +// gdb-check:$4 = (7, 8, 9) -// gdbr-command:print simple_tuple::INTERNAL_PADDING_1 -// gdbr-check:$5 = (10, 11) -// gdbr-command:print simple_tuple::INTERNAL_PADDING_2 -// gdbr-check:$6 = (12, 13, 14, 15) +// gdb-command:print simple_tuple::INTERNAL_PADDING_1 +// gdb-check:$5 = (10, 11) +// gdb-command:print simple_tuple::INTERNAL_PADDING_2 +// gdb-check:$6 = (12, 13, 14, 15) -// gdbr-command:print simple_tuple::PADDING_AT_END -// gdbr-check:$7 = (16, 17) +// gdb-command:print simple_tuple::PADDING_AT_END +// gdb-check:$7 = (16, 17) // gdb-command:run -// gdbr-command:print noPadding8 -// gdbr-check:$8 = (-100, 100) +// gdb-command:print noPadding8 +// gdb-check:$8 = (-100, 100) // gdb-command:print noPadding16 -// gdbr-check:$9 = (0, 1, 2) +// gdb-check:$9 = (0, 1, 2) // gdb-command:print noPadding32 -// gdbr-check:$10 = (3, 4.5, 5) +// gdb-check:$10 = (3, 4.5, 5) // gdb-command:print noPadding64 -// gdbr-check:$11 = (6, 7.5, 8) +// gdb-check:$11 = (6, 7.5, 8) // gdb-command:print internalPadding1 -// gdbr-check:$12 = (9, 10) +// gdb-check:$12 = (9, 10) // gdb-command:print internalPadding2 -// gdbr-check:$13 = (11, 12, 13, 14) +// gdb-check:$13 = (11, 12, 13, 14) // gdb-command:print paddingAtEnd -// gdbr-check:$14 = (15, 16) +// gdb-check:$14 = (15, 16) -// gdbr-command:print simple_tuple::NO_PADDING_8 -// gdbr-check:$15 = (-127, 127) -// gdbr-command:print simple_tuple::NO_PADDING_16 -// gdbr-check:$16 = (-10, 10, 9) -// gdbr-command:print simple_tuple::NO_PADDING_32 -// gdbr-check:$17 = (14, 15, 16) -// gdbr-command:print simple_tuple::NO_PADDING_64 -// gdbr-check:$18 = (17, 18, 19) +// gdb-command:print simple_tuple::NO_PADDING_8 +// gdb-check:$15 = (-127, 127) +// gdb-command:print simple_tuple::NO_PADDING_16 +// gdb-check:$16 = (-10, 10, 9) +// gdb-command:print simple_tuple::NO_PADDING_32 +// gdb-check:$17 = (14, 15, 16) +// gdb-command:print simple_tuple::NO_PADDING_64 +// gdb-check:$18 = (17, 18, 19) -// gdbr-command:print simple_tuple::INTERNAL_PADDING_1 -// gdbr-check:$19 = (110, 111) -// gdbr-command:print simple_tuple::INTERNAL_PADDING_2 -// gdbr-check:$20 = (112, 113, 114, 115) +// gdb-command:print simple_tuple::INTERNAL_PADDING_1 +// gdb-check:$19 = (110, 111) +// gdb-command:print simple_tuple::INTERNAL_PADDING_2 +// gdb-check:$20 = (112, 113, 114, 115) -// gdbr-command:print simple_tuple::PADDING_AT_END -// gdbr-check:$21 = (116, 117) +// gdb-command:print simple_tuple::PADDING_AT_END +// gdb-check:$21 = (116, 117) // === LLDB TESTS ================================================================================== diff --git a/tests/debuginfo/strings-and-strs.rs b/tests/debuginfo/strings-and-strs.rs index 2d29ac12bd8a..c109b4023009 100644 --- a/tests/debuginfo/strings-and-strs.rs +++ b/tests/debuginfo/strings-and-strs.rs @@ -7,19 +7,19 @@ // gdb-command:run // gdb-command:print plain_string -// gdbr-check:$1 = alloc::string::String {vec: alloc::vec::Vec {buf: alloc::raw_vec::RawVec {inner: alloc::raw_vec::RawVecInner {ptr: core::ptr::unique::Unique {pointer: core::ptr::non_null::NonNull {pointer: 0x[...]}, _marker: core::marker::PhantomData}, cap: alloc::raw_vec::Cap (5), alloc: alloc::alloc::Global}, _marker: core::marker::PhantomData}, len: 5}} +// gdb-check:$1 = alloc::string::String {vec: alloc::vec::Vec {buf: alloc::raw_vec::RawVec {inner: alloc::raw_vec::RawVecInner {ptr: core::ptr::unique::Unique {pointer: core::ptr::non_null::NonNull {pointer: 0x[...]}, _marker: core::marker::PhantomData}, cap: alloc::raw_vec::Cap (5), alloc: alloc::alloc::Global}, _marker: core::marker::PhantomData}, len: 5}} // gdb-command:print plain_str -// gdbr-check:$2 = "Hello" +// gdb-check:$2 = "Hello" // gdb-command:print str_in_struct -// gdbr-check:$3 = strings_and_strs::Foo {inner: "Hello"} +// gdb-check:$3 = strings_and_strs::Foo {inner: "Hello"} // gdb-command:print str_in_tuple -// gdbr-check:$4 = ("Hello", "World") +// gdb-check:$4 = ("Hello", "World") // gdb-command:print str_in_rc -// gdbr-check:$5 = alloc::rc::Rc<&str, alloc::alloc::Global> {ptr: core::ptr::non_null::NonNull> {pointer: 0x[...]}, phantom: core::marker::PhantomData>, alloc: alloc::alloc::Global} +// gdb-check:$5 = alloc::rc::Rc<&str, alloc::alloc::Global> {ptr: core::ptr::non_null::NonNull> {pointer: 0x[...]}, phantom: core::marker::PhantomData>, alloc: alloc::alloc::Global} // === LLDB TESTS ================================================================================== diff --git a/tests/debuginfo/struct-in-enum.rs b/tests/debuginfo/struct-in-enum.rs index 9e97741444e8..8d7ad93e0a21 100644 --- a/tests/debuginfo/struct-in-enum.rs +++ b/tests/debuginfo/struct-in-enum.rs @@ -9,13 +9,13 @@ // gdb-command:run // gdb-command:print case1 -// gdbr-check:$1 = struct_in_enum::Regular::Case1(0, struct_in_enum::Struct {x: 2088533116, y: 2088533116, z: 31868}) +// gdb-check:$1 = struct_in_enum::Regular::Case1(0, struct_in_enum::Struct {x: 2088533116, y: 2088533116, z: 31868}) // gdb-command:print case2 -// gdbr-check:$2 = struct_in_enum::Regular::Case2(0, 1229782938247303441, 4369) +// gdb-check:$2 = struct_in_enum::Regular::Case2(0, 1229782938247303441, 4369) // gdb-command:print univariant -// gdbr-check:$3 = struct_in_enum::Univariant::TheOnlyCase(struct_in_enum::Struct {x: 123, y: 456, z: 789}) +// gdb-check:$3 = struct_in_enum::Univariant::TheOnlyCase(struct_in_enum::Struct {x: 123, y: 456, z: 789}) // === LLDB TESTS ================================================================================== diff --git a/tests/debuginfo/struct-in-struct.rs b/tests/debuginfo/struct-in-struct.rs index 0025f571aa78..75141e28e498 100644 --- a/tests/debuginfo/struct-in-struct.rs +++ b/tests/debuginfo/struct-in-struct.rs @@ -7,13 +7,13 @@ // gdb-command:run // gdb-command:print three_simple_structs -// gdbr-check:$1 = struct_in_struct::ThreeSimpleStructs {x: struct_in_struct::Simple {x: 1}, y: struct_in_struct::Simple {x: 2}, z: struct_in_struct::Simple {x: 3}} +// gdb-check:$1 = struct_in_struct::ThreeSimpleStructs {x: struct_in_struct::Simple {x: 1}, y: struct_in_struct::Simple {x: 2}, z: struct_in_struct::Simple {x: 3}} // gdb-command:print internal_padding_parent -// gdbr-check:$2 = struct_in_struct::InternalPaddingParent {x: struct_in_struct::InternalPadding {x: 4, y: 5}, y: struct_in_struct::InternalPadding {x: 6, y: 7}, z: struct_in_struct::InternalPadding {x: 8, y: 9}} +// gdb-check:$2 = struct_in_struct::InternalPaddingParent {x: struct_in_struct::InternalPadding {x: 4, y: 5}, y: struct_in_struct::InternalPadding {x: 6, y: 7}, z: struct_in_struct::InternalPadding {x: 8, y: 9}} // gdb-command:print padding_at_end_parent -// gdbr-check:$3 = struct_in_struct::PaddingAtEndParent {x: struct_in_struct::PaddingAtEnd {x: 10, y: 11}, y: struct_in_struct::PaddingAtEnd {x: 12, y: 13}, z: struct_in_struct::PaddingAtEnd {x: 14, y: 15}} +// gdb-check:$3 = struct_in_struct::PaddingAtEndParent {x: struct_in_struct::PaddingAtEnd {x: 10, y: 11}, y: struct_in_struct::PaddingAtEnd {x: 12, y: 13}, z: struct_in_struct::PaddingAtEnd {x: 14, y: 15}} // === LLDB TESTS ================================================================================== diff --git a/tests/debuginfo/struct-style-enum.rs b/tests/debuginfo/struct-style-enum.rs index 42368017cae6..7c5846ea350f 100644 --- a/tests/debuginfo/struct-style-enum.rs +++ b/tests/debuginfo/struct-style-enum.rs @@ -9,16 +9,16 @@ // gdb-command:run // gdb-command:print case1 -// gdbr-check:$1 = struct_style_enum::Regular::Case1{a: 0, b: 31868, c: 31868, d: 31868, e: 31868} +// gdb-check:$1 = struct_style_enum::Regular::Case1{a: 0, b: 31868, c: 31868, d: 31868, e: 31868} // gdb-command:print case2 -// gdbr-check:$2 = struct_style_enum::Regular::Case2{a: 0, b: 286331153, c: 286331153} +// gdb-check:$2 = struct_style_enum::Regular::Case2{a: 0, b: 286331153, c: 286331153} // gdb-command:print case3 -// gdbr-check:$3 = struct_style_enum::Regular::Case3{a: 0, b: 6438275382588823897} +// gdb-check:$3 = struct_style_enum::Regular::Case3{a: 0, b: 6438275382588823897} // gdb-command:print univariant -// gdbr-check:$4 = struct_style_enum::Univariant::TheOnlyCase{a: -1} +// gdb-check:$4 = struct_style_enum::Univariant::TheOnlyCase{a: -1} // === LLDB TESTS ================================================================================== diff --git a/tests/debuginfo/struct-with-destructor.rs b/tests/debuginfo/struct-with-destructor.rs index 8d854369d686..17dc6edd3657 100644 --- a/tests/debuginfo/struct-with-destructor.rs +++ b/tests/debuginfo/struct-with-destructor.rs @@ -6,16 +6,16 @@ // gdb-command:run // gdb-command:print simple -// gdbr-check:$1 = struct_with_destructor::WithDestructor {x: 10, y: 20} +// gdb-check:$1 = struct_with_destructor::WithDestructor {x: 10, y: 20} // gdb-command:print noDestructor -// gdbr-check:$2 = struct_with_destructor::NoDestructorGuarded {a: struct_with_destructor::NoDestructor {x: 10, y: 20}, guard: -1} +// gdb-check:$2 = struct_with_destructor::NoDestructorGuarded {a: struct_with_destructor::NoDestructor {x: 10, y: 20}, guard: -1} // gdb-command:print withDestructor -// gdbr-check:$3 = struct_with_destructor::WithDestructorGuarded {a: struct_with_destructor::WithDestructor {x: 10, y: 20}, guard: -1} +// gdb-check:$3 = struct_with_destructor::WithDestructorGuarded {a: struct_with_destructor::WithDestructor {x: 10, y: 20}, guard: -1} // gdb-command:print nested -// gdbr-check:$4 = struct_with_destructor::NestedOuter {a: struct_with_destructor::NestedInner {a: struct_with_destructor::WithDestructor {x: 7890, y: 9870}}} +// gdb-check:$4 = struct_with_destructor::NestedOuter {a: struct_with_destructor::NestedInner {a: struct_with_destructor::WithDestructor {x: 7890, y: 9870}}} // === LLDB TESTS ================================================================================== diff --git a/tests/debuginfo/tuple-in-struct.rs b/tests/debuginfo/tuple-in-struct.rs index 11175c73f55b..afda586c1544 100644 --- a/tests/debuginfo/tuple-in-struct.rs +++ b/tests/debuginfo/tuple-in-struct.rs @@ -5,29 +5,29 @@ // gdb-command:run // gdb-command:print no_padding1 -// gdbr-check:$1 = tuple_in_struct::NoPadding1 {x: (0, 1), y: 2, z: (3, 4, 5)} +// gdb-check:$1 = tuple_in_struct::NoPadding1 {x: (0, 1), y: 2, z: (3, 4, 5)} // gdb-command:print no_padding2 -// gdbr-check:$2 = tuple_in_struct::NoPadding2 {x: (6, 7), y: ((8, 9), 10)} +// gdb-check:$2 = tuple_in_struct::NoPadding2 {x: (6, 7), y: ((8, 9), 10)} // gdb-command:print tuple_internal_padding -// gdbr-check:$3 = tuple_in_struct::TupleInternalPadding {x: (11, 12), y: (13, 14)} +// gdb-check:$3 = tuple_in_struct::TupleInternalPadding {x: (11, 12), y: (13, 14)} // gdb-command:print struct_internal_padding -// gdbr-check:$4 = tuple_in_struct::StructInternalPadding {x: (15, 16), y: (17, 18)} +// gdb-check:$4 = tuple_in_struct::StructInternalPadding {x: (15, 16), y: (17, 18)} // gdb-command:print both_internally_padded -// gdbr-check:$5 = tuple_in_struct::BothInternallyPadded {x: (19, 20, 21), y: (22, 23)} +// gdb-check:$5 = tuple_in_struct::BothInternallyPadded {x: (19, 20, 21), y: (22, 23)} // gdb-command:print single_tuple -// gdbr-check:$6 = tuple_in_struct::SingleTuple {x: (24, 25, 26)} +// gdb-check:$6 = tuple_in_struct::SingleTuple {x: (24, 25, 26)} // gdb-command:print tuple_padded_at_end -// gdbr-check:$7 = tuple_in_struct::TuplePaddedAtEnd {x: (27, 28), y: (29, 30)} +// gdb-check:$7 = tuple_in_struct::TuplePaddedAtEnd {x: (27, 28), y: (29, 30)} // gdb-command:print struct_padded_at_end -// gdbr-check:$8 = tuple_in_struct::StructPaddedAtEnd {x: (31, 32), y: (33, 34)} +// gdb-check:$8 = tuple_in_struct::StructPaddedAtEnd {x: (31, 32), y: (33, 34)} // gdb-command:print both_padded_at_end -// gdbr-check:$9 = tuple_in_struct::BothPaddedAtEnd {x: (35, 36, 37), y: (38, 39)} +// gdb-check:$9 = tuple_in_struct::BothPaddedAtEnd {x: (35, 36, 37), y: (38, 39)} // gdb-command:print mixed_padding -// gdbr-check:$10 = tuple_in_struct::MixedPadding {x: ((40, 41, 42), (43, 44)), y: (45, 46, 47, 48)} +// gdb-check:$10 = tuple_in_struct::MixedPadding {x: ((40, 41, 42), (43, 44)), y: (45, 46, 47, 48)} #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/tuple-in-tuple.rs b/tests/debuginfo/tuple-in-tuple.rs index 98bded68b14e..24147e6ce0e4 100644 --- a/tests/debuginfo/tuple-in-tuple.rs +++ b/tests/debuginfo/tuple-in-tuple.rs @@ -7,21 +7,21 @@ // gdb-command:run // gdb-command:print no_padding1 -// gdbr-check:$1 = ((0, 1), 2, 3) +// gdb-check:$1 = ((0, 1), 2, 3) // gdb-command:print no_padding2 -// gdbr-check:$2 = (4, (5, 6), 7) +// gdb-check:$2 = (4, (5, 6), 7) // gdb-command:print no_padding3 -// gdbr-check:$3 = (8, 9, (10, 11)) +// gdb-check:$3 = (8, 9, (10, 11)) // gdb-command:print internal_padding1 -// gdbr-check:$4 = (12, (13, 14)) +// gdb-check:$4 = (12, (13, 14)) // gdb-command:print internal_padding2 -// gdbr-check:$5 = (15, (16, 17)) +// gdb-check:$5 = (15, (16, 17)) // gdb-command:print padding_at_end1 -// gdbr-check:$6 = (18, (19, 20)) +// gdb-check:$6 = (18, (19, 20)) // gdb-command:print padding_at_end2 -// gdbr-check:$7 = ((21, 22), 23) +// gdb-check:$7 = ((21, 22), 23) // === LLDB TESTS ================================================================================== diff --git a/tests/debuginfo/tuple-struct.rs b/tests/debuginfo/tuple-struct.rs index a3e88c0f9266..8c546be07c37 100644 --- a/tests/debuginfo/tuple-struct.rs +++ b/tests/debuginfo/tuple-struct.rs @@ -7,22 +7,22 @@ // gdb-command:run // gdb-command:print no_padding16 -// gdbr-check:$1 = tuple_struct::NoPadding16 (10000, -10001) +// gdb-check:$1 = tuple_struct::NoPadding16 (10000, -10001) // gdb-command:print no_padding32 -// gdbr-check:$2 = tuple_struct::NoPadding32 (-10002, -10003.5, 10004) +// gdb-check:$2 = tuple_struct::NoPadding32 (-10002, -10003.5, 10004) // gdb-command:print no_padding64 -// gdbr-check:$3 = tuple_struct::NoPadding64 (-10005.5, 10006, 10007) +// gdb-check:$3 = tuple_struct::NoPadding64 (-10005.5, 10006, 10007) // gdb-command:print no_padding163264 -// gdbr-check:$4 = tuple_struct::NoPadding163264 (-10008, 10009, 10010, 10011) +// gdb-check:$4 = tuple_struct::NoPadding163264 (-10008, 10009, 10010, 10011) // gdb-command:print internal_padding -// gdbr-check:$5 = tuple_struct::InternalPadding (10012, -10013) +// gdb-check:$5 = tuple_struct::InternalPadding (10012, -10013) // gdb-command:print padding_at_end -// gdbr-check:$6 = tuple_struct::PaddingAtEnd (-10014, 10015) +// gdb-check:$6 = tuple_struct::PaddingAtEnd (-10014, 10015) // === LLDB TESTS ================================================================================== diff --git a/tests/debuginfo/tuple-style-enum.rs b/tests/debuginfo/tuple-style-enum.rs index 3de4ecb12849..f231f3e05987 100644 --- a/tests/debuginfo/tuple-style-enum.rs +++ b/tests/debuginfo/tuple-style-enum.rs @@ -10,16 +10,16 @@ // gdb-command:run // gdb-command:print case1 -// gdbr-check:$1 = tuple_style_enum::Regular::Case1(0, 31868, 31868, 31868, 31868) +// gdb-check:$1 = tuple_style_enum::Regular::Case1(0, 31868, 31868, 31868, 31868) // gdb-command:print case2 -// gdbr-check:$2 = tuple_style_enum::Regular::Case2(0, 286331153, 286331153) +// gdb-check:$2 = tuple_style_enum::Regular::Case2(0, 286331153, 286331153) // gdb-command:print case3 -// gdbr-check:$3 = tuple_style_enum::Regular::Case3(0, 6438275382588823897) +// gdb-check:$3 = tuple_style_enum::Regular::Case3(0, 6438275382588823897) // gdb-command:print univariant -// gdbr-check:$4 = tuple_style_enum::Univariant::TheOnlyCase(-1) +// gdb-check:$4 = tuple_style_enum::Univariant::TheOnlyCase(-1) // === LLDB TESTS ================================================================================== diff --git a/tests/debuginfo/union-smoke.rs b/tests/debuginfo/union-smoke.rs index cd2c9a139730..f14437b1c3fb 100644 --- a/tests/debuginfo/union-smoke.rs +++ b/tests/debuginfo/union-smoke.rs @@ -8,9 +8,9 @@ // gdb-command:run // gdb-command:print u -// gdbr-check:$1 = union_smoke::U {a: (2, 2), b: 514} +// gdb-check:$1 = union_smoke::U {a: (2, 2), b: 514} // gdb-command:print union_smoke::SU -// gdbr-check:$2 = union_smoke::U {a: (1, 1), b: 257} +// gdb-check:$2 = union_smoke::U {a: (1, 1), b: 257} // === LLDB TESTS ================================================================================== diff --git a/tests/debuginfo/unique-enum.rs b/tests/debuginfo/unique-enum.rs index 514c7c50812c..fcfbe856123e 100644 --- a/tests/debuginfo/unique-enum.rs +++ b/tests/debuginfo/unique-enum.rs @@ -9,13 +9,13 @@ // gdb-command:run // gdb-command:print *the_a -// gdbr-check:$1 = unique_enum::ABC::TheA{x: 0, y: 8970181431921507452} +// gdb-check:$1 = unique_enum::ABC::TheA{x: 0, y: 8970181431921507452} // gdb-command:print *the_b -// gdbr-check:$2 = unique_enum::ABC::TheB(0, 286331153, 286331153) +// gdb-check:$2 = unique_enum::ABC::TheB(0, 286331153, 286331153) // gdb-command:print *univariant -// gdbr-check:$3 = unique_enum::Univariant::TheOnlyCase(123234) +// gdb-check:$3 = unique_enum::Univariant::TheOnlyCase(123234) // === LLDB TESTS ================================================================================== diff --git a/tests/debuginfo/unsized.rs b/tests/debuginfo/unsized.rs index ee6fe22c6b8d..acfe511be7c0 100644 --- a/tests/debuginfo/unsized.rs +++ b/tests/debuginfo/unsized.rs @@ -7,22 +7,22 @@ // gdb-command:run // gdb-command:print a -// gdbr-check:$1 = &unsized::Foo<[u8]> {data_ptr: [...], length: 4} +// gdb-check:$1 = &unsized::Foo<[u8]> {data_ptr: [...], length: 4} // gdb-command:print b -// gdbr-check:$2 = &unsized::Foo> {data_ptr: [...], length: 4} +// gdb-check:$2 = &unsized::Foo> {data_ptr: [...], length: 4} // gdb-command:print c -// gdbr-check:$3 = &unsized::Foo {pointer: [...], vtable: [...]} +// gdb-check:$3 = &unsized::Foo {pointer: [...], vtable: [...]} // gdb-command:print _box -// gdbr-check:$4 = alloc::boxed::Box, alloc::alloc::Global> {pointer: [...], vtable: [...]} +// gdb-check:$4 = alloc::boxed::Box, alloc::alloc::Global> {pointer: [...], vtable: [...]} // gdb-command:print tuple_slice -// gdbr-check:$5 = &(i32, i32, [i32]) {data_ptr: [...], length: 2} +// gdb-check:$5 = &(i32, i32, [i32]) {data_ptr: [...], length: 2} // gdb-command:print tuple_dyn -// gdbr-check:$6 = &(i32, i32, dyn core::fmt::Debug) {pointer: [...], vtable: [...]} +// gdb-check:$6 = &(i32, i32, dyn core::fmt::Debug) {pointer: [...], vtable: [...]} // === CDB TESTS =================================================================================== diff --git a/tests/debuginfo/var-captured-in-nested-closure.rs b/tests/debuginfo/var-captured-in-nested-closure.rs index e2974f418ae9..5183245ad5dc 100644 --- a/tests/debuginfo/var-captured-in-nested-closure.rs +++ b/tests/debuginfo/var-captured-in-nested-closure.rs @@ -11,9 +11,9 @@ // gdb-command:print constant // gdb-check:$2 = 2 // gdb-command:print a_struct -// gdbr-check:$3 = var_captured_in_nested_closure::Struct {a: -3, b: 4.5, c: 5} +// gdb-check:$3 = var_captured_in_nested_closure::Struct {a: -3, b: 4.5, c: 5} // gdb-command:print *struct_ref -// gdbr-check:$4 = var_captured_in_nested_closure::Struct {a: -3, b: 4.5, c: 5} +// gdb-check:$4 = var_captured_in_nested_closure::Struct {a: -3, b: 4.5, c: 5} // gdb-command:print *owned // gdb-check:$5 = 6 // gdb-command:print closure_local @@ -25,9 +25,9 @@ // gdb-command:print constant // gdb-check:$8 = 2 // gdb-command:print a_struct -// gdbr-check:$9 = var_captured_in_nested_closure::Struct {a: -3, b: 4.5, c: 5} +// gdb-check:$9 = var_captured_in_nested_closure::Struct {a: -3, b: 4.5, c: 5} // gdb-command:print *struct_ref -// gdbr-check:$10 = var_captured_in_nested_closure::Struct {a: -3, b: 4.5, c: 5} +// gdb-check:$10 = var_captured_in_nested_closure::Struct {a: -3, b: 4.5, c: 5} // gdb-command:print *owned // gdb-check:$11 = 6 // gdb-command:print closure_local diff --git a/tests/debuginfo/var-captured-in-sendable-closure.rs b/tests/debuginfo/var-captured-in-sendable-closure.rs index 1029ab6b788b..094639ebf20c 100644 --- a/tests/debuginfo/var-captured-in-sendable-closure.rs +++ b/tests/debuginfo/var-captured-in-sendable-closure.rs @@ -9,7 +9,7 @@ // gdb-command:print constant // gdb-check:$1 = 1 // gdb-command:print a_struct -// gdbr-check:$2 = var_captured_in_sendable_closure::Struct {a: -2, b: 3.5, c: 4} +// gdb-check:$2 = var_captured_in_sendable_closure::Struct {a: -2, b: 3.5, c: 4} // gdb-command:print *owned // gdb-check:$3 = 5 // gdb-command:continue diff --git a/tests/debuginfo/var-captured-in-stack-closure.rs b/tests/debuginfo/var-captured-in-stack-closure.rs index baa784e5c459..ca10cdcb518e 100644 --- a/tests/debuginfo/var-captured-in-stack-closure.rs +++ b/tests/debuginfo/var-captured-in-stack-closure.rs @@ -11,9 +11,9 @@ // gdb-command:print constant // gdb-check:$2 = 2 // gdb-command:print a_struct -// gdbr-check:$3 = var_captured_in_stack_closure::Struct {a: -3, b: 4.5, c: 5} +// gdb-check:$3 = var_captured_in_stack_closure::Struct {a: -3, b: 4.5, c: 5} // gdb-command:print *struct_ref -// gdbr-check:$4 = var_captured_in_stack_closure::Struct {a: -3, b: 4.5, c: 5} +// gdb-check:$4 = var_captured_in_stack_closure::Struct {a: -3, b: 4.5, c: 5} // gdb-command:print *owned // gdb-check:$5 = 6 @@ -24,9 +24,9 @@ // gdb-command:print constant // gdb-check:$7 = 2 // gdb-command:print a_struct -// gdbr-check:$8 = var_captured_in_stack_closure::Struct {a: -3, b: 4.5, c: 5} +// gdb-check:$8 = var_captured_in_stack_closure::Struct {a: -3, b: 4.5, c: 5} // gdb-command:print *struct_ref -// gdbr-check:$9 = var_captured_in_stack_closure::Struct {a: -3, b: 4.5, c: 5} +// gdb-check:$9 = var_captured_in_stack_closure::Struct {a: -3, b: 4.5, c: 5} // gdb-command:print *owned // gdb-check:$10 = 6 diff --git a/tests/debuginfo/vec-slices.rs b/tests/debuginfo/vec-slices.rs index 9d7e3eef8045..13342abf5d0e 100644 --- a/tests/debuginfo/vec-slices.rs +++ b/tests/debuginfo/vec-slices.rs @@ -12,49 +12,49 @@ // gdb-command:print singleton.length // gdb-check:$2 = 1 -// gdbr-command:print *(singleton.data_ptr as *const [i64; 1]) -// gdbr-check:$3 = [1] +// gdb-command:print *(singleton.data_ptr as *const [i64; 1]) +// gdb-check:$3 = [1] // gdb-command:print multiple.length // gdb-check:$4 = 4 -// gdbr-command:print *(multiple.data_ptr as *const [i64; 4]) -// gdbr-check:$5 = [2, 3, 4, 5] +// gdb-command:print *(multiple.data_ptr as *const [i64; 4]) +// gdb-check:$5 = [2, 3, 4, 5] // gdb-command:print slice_of_slice.length // gdb-check:$6 = 2 -// gdbr-command:print *(slice_of_slice.data_ptr as *const [i64; 2]) -// gdbr-check:$7 = [3, 4] +// gdb-command:print *(slice_of_slice.data_ptr as *const [i64; 2]) +// gdb-check:$7 = [3, 4] // gdb-command:print padded_tuple.length // gdb-check:$8 = 2 // gdb-command:print padded_tuple.data_ptr[0] -// gdbr-check:$9 = (6, 7) +// gdb-check:$9 = (6, 7) // gdb-command:print padded_tuple.data_ptr[1] -// gdbr-check:$10 = (8, 9) +// gdb-check:$10 = (8, 9) // gdb-command:print padded_struct.length // gdb-check:$11 = 2 // gdb-command:print padded_struct.data_ptr[0] -// gdbr-check:$12 = vec_slices::AStruct {x: 10, y: 11, z: 12} +// gdb-check:$12 = vec_slices::AStruct {x: 10, y: 11, z: 12} // gdb-command:print padded_struct.data_ptr[1] -// gdbr-check:$13 = vec_slices::AStruct {x: 13, y: 14, z: 15} +// gdb-check:$13 = vec_slices::AStruct {x: 13, y: 14, z: 15} // gdb-command:print mut_slice.length // gdb-check:$14 = 5 -// gdbr-command:print *(mut_slice.data_ptr as *const [i64; 5]) -// gdbr-check:$15 = [1, 2, 3, 4, 5] +// gdb-command:print *(mut_slice.data_ptr as *const [i64; 5]) +// gdb-check:$15 = [1, 2, 3, 4, 5] // Some lines below are marked with [ignored] because old GDB versions seem to have trouble // accessing globals. // [ignored] gdbg-command:print 'vec_slices::MUT_VECT_SLICE'.length -// gdbr-command:print MUT_VECT_SLICE.length +// gdb-command:print MUT_VECT_SLICE.length // [ignored] gdbg-check:$16 = 2 -// gdbr-check:$16 = 2 +// gdb-check:$16 = 2 // [ignored] gdbg-command:print *((i64[2]*)('vec_slices::MUT_VECT_SLICE'.data_ptr)) -// gdbr-command:print *(MUT_VECT_SLICE.data_ptr as *const [i64; 2]) +// gdb-command:print *(MUT_VECT_SLICE.data_ptr as *const [i64; 2]) // [ignored] gdbg-check:$17 = {64, 65} -// gdbr-check:$17 = [64, 65] +// gdb-check:$17 = [64, 65] // === LLDB TESTS ================================================================================== diff --git a/tests/debuginfo/vec.rs b/tests/debuginfo/vec.rs index bc1f995ce0e1..7b9054639a8d 100644 --- a/tests/debuginfo/vec.rs +++ b/tests/debuginfo/vec.rs @@ -6,9 +6,9 @@ // gdb-command:run // gdb-command:print a -// gdbr-check:$1 = [1, 2, 3] +// gdb-check:$1 = [1, 2, 3] // gdb-command:print vec::VECT -// gdbr-check:$2 = [4, 5, 6] +// gdb-check:$2 = [4, 5, 6] // === LLDB TESTS ================================================================================== From 95ae9b8c841947adcd0a530f9fb94c70cc325f7e Mon Sep 17 00:00:00 2001 From: Ben Kimock Date: Sat, 17 Aug 2024 17:34:11 -0400 Subject: [PATCH 49/79] Fix up a special case --- tests/debuginfo/vec-slices.rs | 7 ------- 1 file changed, 7 deletions(-) diff --git a/tests/debuginfo/vec-slices.rs b/tests/debuginfo/vec-slices.rs index 13342abf5d0e..18ff6c743228 100644 --- a/tests/debuginfo/vec-slices.rs +++ b/tests/debuginfo/vec-slices.rs @@ -44,16 +44,9 @@ // gdb-command:print *(mut_slice.data_ptr as *const [i64; 5]) // gdb-check:$15 = [1, 2, 3, 4, 5] -// Some lines below are marked with [ignored] because old GDB versions seem to have trouble -// accessing globals. - -// [ignored] gdbg-command:print 'vec_slices::MUT_VECT_SLICE'.length // gdb-command:print MUT_VECT_SLICE.length -// [ignored] gdbg-check:$16 = 2 // gdb-check:$16 = 2 -// [ignored] gdbg-command:print *((i64[2]*)('vec_slices::MUT_VECT_SLICE'.data_ptr)) // gdb-command:print *(MUT_VECT_SLICE.data_ptr as *const [i64; 2]) -// [ignored] gdbg-check:$17 = {64, 65} // gdb-check:$17 = [64, 65] // === LLDB TESTS ================================================================================== From e1a82c96341747e486c72139748d3bc3d538f669 Mon Sep 17 00:00:00 2001 From: Ben Kimock Date: Sat, 17 Aug 2024 17:37:09 -0400 Subject: [PATCH 50/79] Delete compiletest support for gdbg --- src/tools/compiletest/src/runtest.rs | 12 +----------- 1 file changed, 1 insertion(+), 11 deletions(-) diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs index 59fce44d1c72..394f24e6f359 100644 --- a/src/tools/compiletest/src/runtest.rs +++ b/src/tools/compiletest/src/runtest.rs @@ -856,17 +856,7 @@ impl<'test> TestCx<'test> { } fn run_debuginfo_gdb_test_no_opt(&self) { - let prefixes = if self.config.gdb_native_rust { - // GDB with Rust - static PREFIXES: &[&str] = &["gdb", "gdbr"]; - println!("NOTE: compiletest thinks it is using GDB with native rust support"); - PREFIXES - } else { - // Generic GDB - static PREFIXES: &[&str] = &["gdb", "gdbg"]; - println!("NOTE: compiletest thinks it is using GDB without native rust support"); - PREFIXES - }; + let prefixes = &["gdb"]; let dbg_cmds = DebuggerCommands::parse_from( &self.testpaths.file, From dc4766536b892e91d8d499e9da7facc3006bf922 Mon Sep 17 00:00:00 2001 From: Samuel Moelius <35515885+smoelius@users.noreply.github.com> Date: Sun, 18 Aug 2024 13:14:09 -0400 Subject: [PATCH 51/79] Typo --- compiler/rustc_hir/src/hir.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs index 6599e7034611..6c7125b75dba 100644 --- a/compiler/rustc_hir/src/hir.rs +++ b/compiler/rustc_hir/src/hir.rs @@ -1395,7 +1395,7 @@ pub struct LetExpr<'hir> { pub pat: &'hir Pat<'hir>, pub ty: Option<&'hir Ty<'hir>>, pub init: &'hir Expr<'hir>, - /// `Recovered::Yes` when this let expressions is not in a syntanctically valid location. + /// `Recovered::Yes` when this let expressions is not in a syntactically valid location. /// Used to prevent building MIR in such situations. pub recovered: ast::Recovered, } From 3a9bf4551374893fdc522572ee569028186e22cc Mon Sep 17 00:00:00 2001 From: Goldstein Date: Sun, 18 Aug 2024 17:11:47 +0300 Subject: [PATCH 52/79] Check that `#[may_dangle]` is properly applied It's only valid when applied to a type or lifetime parameter in `Drop` trait implementation. --- compiler/rustc_passes/messages.ftl | 3 ++ compiler/rustc_passes/src/check_attr.rs | 23 ++++++++++- compiler/rustc_passes/src/errors.rs | 7 ++++ tests/ui/attributes/may_dangle.rs | 53 +++++++++++++++++++++++++ tests/ui/attributes/may_dangle.stderr | 50 +++++++++++++++++++++++ 5 files changed, 135 insertions(+), 1 deletion(-) create mode 100644 tests/ui/attributes/may_dangle.rs create mode 100644 tests/ui/attributes/may_dangle.stderr diff --git a/compiler/rustc_passes/messages.ftl b/compiler/rustc_passes/messages.ftl index 1ea4ca375f15..7d4f351560b0 100644 --- a/compiler/rustc_passes/messages.ftl +++ b/compiler/rustc_passes/messages.ftl @@ -444,6 +444,9 @@ passes_macro_export_on_decl_macro = passes_macro_use = `#[{$name}]` only has an effect on `extern crate` and modules +passes_may_dangle = + `#[may_dangle]` must be applied to a lifetime or type generic parameter in `Drop` impl + passes_maybe_string_interpolation = you might have meant to use string interpolation in this string literal passes_missing_const_err = attributes `#[rustc_const_unstable]` and `#[rustc_const_stable]` require the function or method to be `const` diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs index a47add929eba..60c8c1e7a001 100644 --- a/compiler/rustc_passes/src/check_attr.rs +++ b/compiler/rustc_passes/src/check_attr.rs @@ -189,6 +189,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> { [sym::collapse_debuginfo, ..] => self.check_collapse_debuginfo(attr, span, target), [sym::must_not_suspend, ..] => self.check_must_not_suspend(attr, span, target), [sym::must_use, ..] => self.check_must_use(hir_id, attr, target), + [sym::may_dangle, ..] => self.check_may_dangle(hir_id, attr), [sym::rustc_pass_by_value, ..] => self.check_pass_by_value(attr, span, target), [sym::rustc_allow_incoherent_impl, ..] => { self.check_allow_incoherent_impl(attr, span, target) @@ -255,7 +256,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> { | sym::cfg_attr // need to be fixed | sym::cfi_encoding // FIXME(cfi_encoding) - | sym::may_dangle // FIXME(dropck_eyepatch) | sym::pointee // FIXME(derive_smart_pointer) | sym::omit_gdb_pretty_printer_section // FIXME(omit_gdb_pretty_printer_section) | sym::used // handled elsewhere to restrict to static items @@ -1373,6 +1373,27 @@ impl<'tcx> CheckAttrVisitor<'tcx> { } } + /// Checks if `#[may_dangle]` is applied to a lifetime or type generic parameter in `Drop` impl. + fn check_may_dangle(&self, hir_id: HirId, attr: &Attribute) { + if let hir::Node::GenericParam(param) = self.tcx.hir_node(hir_id) + && matches!( + param.kind, + hir::GenericParamKind::Lifetime { .. } | hir::GenericParamKind::Type { .. } + ) + && matches!(param.source, hir::GenericParamSource::Generics) + && let parent_hir_id = self.tcx.parent_hir_id(hir_id) + && let hir::Node::Item(item) = self.tcx.hir_node(parent_hir_id) + && let hir::ItemKind::Impl(impl_) = item.kind + && let Some(trait_) = impl_.of_trait + && let Some(def_id) = trait_.trait_def_id() + && self.tcx.is_lang_item(def_id, hir::LangItem::Drop) + { + return; + } + + self.dcx().emit_err(errors::InvalidMayDangle { attr_span: attr.span }); + } + /// Checks if `#[cold]` is applied to a non-function. fn check_cold(&self, hir_id: HirId, attr: &Attribute, span: Span, target: Target) { match target { diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs index 3a043e0e3c19..ee7d097e5d38 100644 --- a/compiler/rustc_passes/src/errors.rs +++ b/compiler/rustc_passes/src/errors.rs @@ -737,6 +737,13 @@ pub struct NonExportedMacroInvalidAttrs { pub attr_span: Span, } +#[derive(Diagnostic)] +#[diag(passes_may_dangle)] +pub struct InvalidMayDangle { + #[primary_span] + pub attr_span: Span, +} + #[derive(LintDiagnostic)] #[diag(passes_unused_duplicate)] pub struct UnusedDuplicate { diff --git a/tests/ui/attributes/may_dangle.rs b/tests/ui/attributes/may_dangle.rs new file mode 100644 index 000000000000..209ba0e88ad1 --- /dev/null +++ b/tests/ui/attributes/may_dangle.rs @@ -0,0 +1,53 @@ +#![feature(dropck_eyepatch)] + +struct Implee1<'a, T, const N: usize>(&'a T); +struct Implee2<'a, T, const N: usize>(&'a T); +struct Implee3<'a, T, const N: usize>(&'a T); +trait NotDrop {} + +unsafe impl<#[may_dangle] 'a, T, const N: usize> NotDrop for Implee1<'a, T, N> {} +//~^ ERROR must be applied to a lifetime or type generic parameter in `Drop` impl + +unsafe impl<'a, #[may_dangle] T, const N: usize> NotDrop for Implee2<'a, T, N> {} +//~^ ERROR must be applied to a lifetime or type generic parameter in `Drop` impl + +unsafe impl<'a, T, #[may_dangle] const N: usize> Drop for Implee1<'a, T, N> { + //~^ ERROR must be applied to a lifetime or type generic parameter in `Drop` impl + fn drop(&mut self) {} +} + +// Ok, lifetime param in a `Drop` impl. +unsafe impl<#[may_dangle] 'a, T, const N: usize> Drop for Implee2<'a, T, N> { + fn drop(&mut self) {} +} + +// Ok, type param in a `Drop` impl. +unsafe impl<'a, #[may_dangle] T, const N: usize> Drop for Implee3<'a, T, N> { + fn drop(&mut self) {} +} + +// Check that this check is not textual. +mod fake { + trait Drop { + fn drop(&mut self); + } + struct Implee(T); + + unsafe impl<#[may_dangle] T> Drop for Implee { + //~^ ERROR must be applied to a lifetime or type generic parameter in `Drop` impl + fn drop(&mut self) {} + } +} + +#[may_dangle] //~ ERROR must be applied to a lifetime or type generic parameter in `Drop` impl +struct Dangling; + +#[may_dangle] //~ ERROR must be applied to a lifetime or type generic parameter in `Drop` impl +impl NotDrop for () { +} + +#[may_dangle] //~ ERROR must be applied to a lifetime or type generic parameter in `Drop` impl +fn main() { + #[may_dangle] //~ ERROR must be applied to a lifetime or type generic parameter in `Drop` impl + let () = (); +} diff --git a/tests/ui/attributes/may_dangle.stderr b/tests/ui/attributes/may_dangle.stderr new file mode 100644 index 000000000000..dc24f847f712 --- /dev/null +++ b/tests/ui/attributes/may_dangle.stderr @@ -0,0 +1,50 @@ +error: `#[may_dangle]` must be applied to a lifetime or type generic parameter in `Drop` impl + --> $DIR/may_dangle.rs:8:13 + | +LL | unsafe impl<#[may_dangle] 'a, T, const N: usize> NotDrop for Implee1<'a, T, N> {} + | ^^^^^^^^^^^^^ + +error: `#[may_dangle]` must be applied to a lifetime or type generic parameter in `Drop` impl + --> $DIR/may_dangle.rs:11:17 + | +LL | unsafe impl<'a, #[may_dangle] T, const N: usize> NotDrop for Implee2<'a, T, N> {} + | ^^^^^^^^^^^^^ + +error: `#[may_dangle]` must be applied to a lifetime or type generic parameter in `Drop` impl + --> $DIR/may_dangle.rs:14:20 + | +LL | unsafe impl<'a, T, #[may_dangle] const N: usize> Drop for Implee1<'a, T, N> { + | ^^^^^^^^^^^^^ + +error: `#[may_dangle]` must be applied to a lifetime or type generic parameter in `Drop` impl + --> $DIR/may_dangle.rs:42:1 + | +LL | #[may_dangle] + | ^^^^^^^^^^^^^ + +error: `#[may_dangle]` must be applied to a lifetime or type generic parameter in `Drop` impl + --> $DIR/may_dangle.rs:45:1 + | +LL | #[may_dangle] + | ^^^^^^^^^^^^^ + +error: `#[may_dangle]` must be applied to a lifetime or type generic parameter in `Drop` impl + --> $DIR/may_dangle.rs:49:1 + | +LL | #[may_dangle] + | ^^^^^^^^^^^^^ + +error: `#[may_dangle]` must be applied to a lifetime or type generic parameter in `Drop` impl + --> $DIR/may_dangle.rs:51:5 + | +LL | #[may_dangle] + | ^^^^^^^^^^^^^ + +error: `#[may_dangle]` must be applied to a lifetime or type generic parameter in `Drop` impl + --> $DIR/may_dangle.rs:36:17 + | +LL | unsafe impl<#[may_dangle] T> Drop for Implee { + | ^^^^^^^^^^^^^ + +error: aborting due to 8 previous errors + From df6cb954bb50fa8567f7198c02db90edda3cd3e4 Mon Sep 17 00:00:00 2001 From: Goldstein Date: Sun, 18 Aug 2024 17:15:29 +0300 Subject: [PATCH 53/79] Fix wording of misapplied `must_not_suspend` error --- compiler/rustc_passes/messages.ftl | 4 ++-- compiler/rustc_passes/src/check_attr.rs | 2 +- tests/ui/lint/must_not_suspend/other_items.stderr | 4 ++-- tests/ui/lint/must_not_suspend/return.stderr | 4 ++-- 4 files changed, 7 insertions(+), 7 deletions(-) diff --git a/compiler/rustc_passes/messages.ftl b/compiler/rustc_passes/messages.ftl index 7d4f351560b0..dfc726efeb99 100644 --- a/compiler/rustc_passes/messages.ftl +++ b/compiler/rustc_passes/messages.ftl @@ -478,8 +478,8 @@ passes_multiple_start_functions = .previous = previous `#[start]` function here passes_must_not_suspend = - `must_not_suspend` attribute should be applied to a struct, enum, or trait - .label = is not a struct, enum, or trait + `must_not_suspend` attribute should be applied to a struct, enum, union, or trait + .label = is not a struct, enum, union, or trait passes_must_use_async = `must_use` attribute on `async` functions applies to the anonymous `Future` returned by the function, not the value within diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs index 60c8c1e7a001..e3c2999142f3 100644 --- a/compiler/rustc_passes/src/check_attr.rs +++ b/compiler/rustc_passes/src/check_attr.rs @@ -1363,7 +1363,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> { } } - /// Checks if `#[must_not_suspend]` is applied to a function. + /// Checks if `#[must_not_suspend]` is applied to a struct, enum, union, or trait. fn check_must_not_suspend(&self, attr: &Attribute, span: Span, target: Target) { match target { Target::Struct | Target::Enum | Target::Union | Target::Trait => {} diff --git a/tests/ui/lint/must_not_suspend/other_items.stderr b/tests/ui/lint/must_not_suspend/other_items.stderr index e6c36b789510..dff5210b7e47 100644 --- a/tests/ui/lint/must_not_suspend/other_items.stderr +++ b/tests/ui/lint/must_not_suspend/other_items.stderr @@ -1,10 +1,10 @@ -error: `must_not_suspend` attribute should be applied to a struct, enum, or trait +error: `must_not_suspend` attribute should be applied to a struct, enum, union, or trait --> $DIR/other_items.rs:5:1 | LL | #[must_not_suspend] | ^^^^^^^^^^^^^^^^^^^ LL | mod inner {} - | ------------ is not a struct, enum, or trait + | ------------ is not a struct, enum, union, or trait error: aborting due to 1 previous error diff --git a/tests/ui/lint/must_not_suspend/return.stderr b/tests/ui/lint/must_not_suspend/return.stderr index 5a73064c7877..440f81656862 100644 --- a/tests/ui/lint/must_not_suspend/return.stderr +++ b/tests/ui/lint/must_not_suspend/return.stderr @@ -1,4 +1,4 @@ -error: `must_not_suspend` attribute should be applied to a struct, enum, or trait +error: `must_not_suspend` attribute should be applied to a struct, enum, union, or trait --> $DIR/return.rs:5:1 | LL | #[must_not_suspend] @@ -6,7 +6,7 @@ LL | #[must_not_suspend] LL | / fn foo() -> i32 { LL | | 0 LL | | } - | |_- is not a struct, enum, or trait + | |_- is not a struct, enum, union, or trait error: aborting due to 1 previous error From 79503dd742253cdca54f10aec9052ff477ccaf38 Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Sat, 13 Jul 2024 13:53:56 +0200 Subject: [PATCH 54/79] stabilize raw_ref_op --- compiler/rustc_ast_passes/src/feature_gate.rs | 1 - .../example/mini_core_hello_world.rs | 3 +- .../example/mini_core_hello_world.rs | 2 +- .../src/error_codes/E0745.md | 2 - compiler/rustc_feature/src/accepted.rs | 2 + compiler/rustc_feature/src/unstable.rs | 2 - compiler/rustc_parse/src/parser/expr.rs | 5 +- .../dangling_pointer_to_raw_pointer.rs | 1 - .../return_pointer_aliasing_read.rs | 1 - .../return_pointer_aliasing_write.rs | 1 - ...return_pointer_aliasing_write_tail_call.rs | 1 - .../return_pointer_on_unwind.rs | 1 - .../function_calls/return_place_on_heap.rs | 1 - tests/mir-opt/const_prop/indirect_mutation.rs | 1 - tests/mir-opt/copy-prop/reborrow.rs | 2 - .../gvn.fn_pointers.GVN.panic-abort.diff | 18 ++--- .../gvn.fn_pointers.GVN.panic-unwind.diff | 18 ++--- tests/mir-opt/gvn.rs | 1 - tests/mir-opt/instsimplify/ref_of_deref.rs | 1 - tests/mir-opt/reference_prop.rs | 1 - tests/pretty/raw-address-of.rs | 1 - .../borrow-raw-address-of-borrowed.rs | 2 - .../borrow-raw-address-of-borrowed.stderr | 6 +- ...rrow-raw-address-of-deref-mutability-ok.rs | 2 - .../borrow-raw-address-of-deref-mutability.rs | 2 - ...row-raw-address-of-deref-mutability.stderr | 4 +- .../borrow-raw-address-of-mutability-ok.rs | 2 - .../borrow-raw-address-of-mutability.rs | 2 - .../borrow-raw-address-of-mutability.stderr | 10 +-- .../consts/const-address-of-interior-mut.rs | 2 - .../const-address-of-interior-mut.stderr | 8 +-- tests/ui/consts/const-address-of-mut.rs | 2 - tests/ui/consts/const-address-of-mut.stderr | 6 +- tests/ui/consts/const-address-of.rs | 2 - .../const-mut-refs/const_mut_address_of.rs | 1 - .../consts/const-mut-refs/mut_ref_in_final.rs | 1 - .../const-mut-refs/mut_ref_in_final.stderr | 20 +++--- .../mut_ref_in_final_dynamic_check.rs | 1 - .../mut_ref_in_final_dynamic_check.stderr | 10 +-- tests/ui/consts/min_const_fn/address_of.rs | 2 - .../ui/consts/min_const_fn/address_of.stderr | 4 +- .../consts/min_const_fn/address_of_const.rs | 2 - .../consts/qualif-indirect-mutation-fail.rs | 1 - .../qualif-indirect-mutation-fail.stderr | 22 +++---- tests/ui/lint/lint-unnecessary-parens.fixed | 1 - tests/ui/lint/lint-unnecessary-parens.rs | 1 - tests/ui/lint/lint-unnecessary-parens.stderr | 66 +++++++++---------- .../lint/unused/lint-unused-mut-variables.rs | 2 +- tests/ui/macros/stringify.rs | 1 - tests/ui/mir/mir_raw_fat_ptr.rs | 1 - tests/ui/mir/mir_raw_fat_ptr.stderr | 2 +- .../packed-struct-address-of-element.rs | 1 - tests/ui/raw-ref-op/feature-raw-ref-op.rs | 21 ------ tests/ui/raw-ref-op/feature-raw-ref-op.stderr | 63 ------------------ tests/ui/raw-ref-op/raw-ref-op.rs | 2 - tests/ui/raw-ref-op/raw-ref-temp-deref.rs | 2 +- tests/ui/raw-ref-op/raw-ref-temp.rs | 2 +- tests/ui/raw-ref-op/unusual_locations.rs | 2 - tests/ui/sanitizer/thread.rs | 1 - tests/ui/static/raw-ref-extern-static.rs | 1 - tests/ui/static/raw-ref-static-mut.rs | 1 - tests/ui/unpretty/expanded-exhaustive.rs | 1 - tests/ui/unpretty/expanded-exhaustive.stdout | 1 - 63 files changed, 106 insertions(+), 246 deletions(-) delete mode 100644 tests/ui/raw-ref-op/feature-raw-ref-op.rs delete mode 100644 tests/ui/raw-ref-op/feature-raw-ref-op.stderr diff --git a/compiler/rustc_ast_passes/src/feature_gate.rs b/compiler/rustc_ast_passes/src/feature_gate.rs index 214a37bca03e..5ab99fbac866 100644 --- a/compiler/rustc_ast_passes/src/feature_gate.rs +++ b/compiler/rustc_ast_passes/src/feature_gate.rs @@ -539,7 +539,6 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session, features: &Features) { } } gate_all!(gen_blocks, "gen blocks are experimental"); - gate_all!(raw_ref_op, "raw address of syntax is experimental"); gate_all!(const_trait_impl, "const trait impls are experimental"); gate_all!( half_open_range_patterns_in_slices, diff --git a/compiler/rustc_codegen_cranelift/example/mini_core_hello_world.rs b/compiler/rustc_codegen_cranelift/example/mini_core_hello_world.rs index e603ac566f4e..ccbd5a78485d 100644 --- a/compiler/rustc_codegen_cranelift/example/mini_core_hello_world.rs +++ b/compiler/rustc_codegen_cranelift/example/mini_core_hello_world.rs @@ -6,8 +6,7 @@ extern_types, naked_functions, thread_local, - repr_simd, - raw_ref_op + repr_simd )] #![no_core] #![allow(dead_code, non_camel_case_types, internal_features)] diff --git a/compiler/rustc_codegen_gcc/example/mini_core_hello_world.rs b/compiler/rustc_codegen_gcc/example/mini_core_hello_world.rs index 9f096e902201..dcfa34cb729d 100644 --- a/compiler/rustc_codegen_gcc/example/mini_core_hello_world.rs +++ b/compiler/rustc_codegen_gcc/example/mini_core_hello_world.rs @@ -2,7 +2,7 @@ #![feature( no_core, unboxed_closures, start, lang_items, never_type, linkage, - extern_types, thread_local, raw_ref_op + extern_types, thread_local )] #![no_core] #![allow(dead_code, internal_features, non_camel_case_types)] diff --git a/compiler/rustc_error_codes/src/error_codes/E0745.md b/compiler/rustc_error_codes/src/error_codes/E0745.md index 23ee7af30f41..32b28f3de949 100644 --- a/compiler/rustc_error_codes/src/error_codes/E0745.md +++ b/compiler/rustc_error_codes/src/error_codes/E0745.md @@ -3,7 +3,6 @@ The address of temporary value was taken. Erroneous code example: ```compile_fail,E0745 -# #![feature(raw_ref_op)] fn temp_address() { let ptr = &raw const 2; // error! } @@ -15,7 +14,6 @@ In this example, `2` is destroyed right after the assignment, which means that To avoid this error, first bind the temporary to a named local variable: ``` -# #![feature(raw_ref_op)] fn temp_address() { let val = 2; let ptr = &raw const val; // ok! diff --git a/compiler/rustc_feature/src/accepted.rs b/compiler/rustc_feature/src/accepted.rs index 3d5ecbaae32a..7838abca9b89 100644 --- a/compiler/rustc_feature/src/accepted.rs +++ b/compiler/rustc_feature/src/accepted.rs @@ -321,6 +321,8 @@ declare_features! ( (accepted, raw_dylib, "1.71.0", Some(58713)), /// Allows keywords to be escaped for use as identifiers. (accepted, raw_identifiers, "1.30.0", Some(48589)), + /// Allows `&raw const $place_expr` and `&raw mut $place_expr` expressions. + (accepted, raw_ref_op, "CURRENT_RUSTC_VERSION", Some(64490)), /// Allows relaxing the coherence rules such that /// `impl ForeignTrait for ForeignType` is permitted. (accepted, re_rebalance_coherence, "1.41.0", Some(55437)), diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs index 459df9ea1b85..14e353f13ca4 100644 --- a/compiler/rustc_feature/src/unstable.rs +++ b/compiler/rustc_feature/src/unstable.rs @@ -565,8 +565,6 @@ declare_features! ( (unstable, precise_capturing, "1.79.0", Some(123432)), /// Allows macro attributes on expressions, statements and non-inline modules. (unstable, proc_macro_hygiene, "1.30.0", Some(54727)), - /// Allows `&raw const $place_expr` and `&raw mut $place_expr` expressions. - (unstable, raw_ref_op, "1.41.0", Some(64490)), /// Makes `&` and `&mut` patterns eat only one layer of references in Rust 2024. (incomplete, ref_pat_eat_one_layer_2024, "1.79.0", Some(123076)), /// Makes `&` and `&mut` patterns eat only one layer of references in Rust 2024—structural variant diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs index e0917ba43e41..422206ebbce0 100644 --- a/compiler/rustc_parse/src/parser/expr.rs +++ b/compiler/rustc_parse/src/parser/expr.rs @@ -851,7 +851,7 @@ impl<'a> Parser<'a> { self.expect_and()?; let has_lifetime = self.token.is_lifetime() && self.look_ahead(1, |t| t != &token::Colon); let lifetime = has_lifetime.then(|| self.expect_lifetime()); // For recovery, see below. - let (borrow_kind, mutbl) = self.parse_borrow_modifiers(lo); + let (borrow_kind, mutbl) = self.parse_borrow_modifiers(); let attrs = self.parse_outer_attributes()?; let expr = if self.token.is_range_separator() { self.parse_expr_prefix_range(attrs) @@ -871,13 +871,12 @@ impl<'a> Parser<'a> { } /// Parse `mut?` or `raw [ const | mut ]`. - fn parse_borrow_modifiers(&mut self, lo: Span) -> (ast::BorrowKind, ast::Mutability) { + fn parse_borrow_modifiers(&mut self) -> (ast::BorrowKind, ast::Mutability) { if self.check_keyword(kw::Raw) && self.look_ahead(1, Token::is_mutability) { // `raw [ const | mut ]`. let found_raw = self.eat_keyword(kw::Raw); assert!(found_raw); let mutability = self.parse_const_or_mut().unwrap(); - self.psess.gated_spans.gate(sym::raw_ref_op, lo.to(self.prev_token.span)); (ast::BorrowKind::Raw, mutability) } else { // `mut?` diff --git a/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_to_raw_pointer.rs b/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_to_raw_pointer.rs index 023bce1616b8..3e20b8da6223 100644 --- a/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_to_raw_pointer.rs +++ b/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_to_raw_pointer.rs @@ -1,4 +1,3 @@ -#![feature(raw_ref_op)] #![feature(strict_provenance)] use std::ptr; diff --git a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_read.rs b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_read.rs index c8e0782eff2f..a6e0134bd173 100644 --- a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_read.rs +++ b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_read.rs @@ -1,7 +1,6 @@ //@revisions: stack tree none //@[tree]compile-flags: -Zmiri-tree-borrows //@[none]compile-flags: -Zmiri-disable-stacked-borrows -#![feature(raw_ref_op)] #![feature(core_intrinsics)] #![feature(custom_mir)] diff --git a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write.rs b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write.rs index 8de0b12b8b04..6155e925c4b9 100644 --- a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write.rs +++ b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write.rs @@ -1,7 +1,6 @@ // This does need an aliasing model and protectors. //@revisions: stack tree //@[tree]compile-flags: -Zmiri-tree-borrows -#![feature(raw_ref_op)] #![feature(core_intrinsics)] #![feature(custom_mir)] diff --git a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write_tail_call.rs b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write_tail_call.rs index facc323bbc51..37ee7ae1b0dc 100644 --- a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write_tail_call.rs +++ b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write_tail_call.rs @@ -1,7 +1,6 @@ // This does need an aliasing model and protectors. //@revisions: stack tree //@[tree]compile-flags: -Zmiri-tree-borrows -#![feature(raw_ref_op)] #![feature(core_intrinsics)] #![feature(custom_mir)] #![feature(explicit_tail_calls)] diff --git a/src/tools/miri/tests/fail/function_calls/return_pointer_on_unwind.rs b/src/tools/miri/tests/fail/function_calls/return_pointer_on_unwind.rs index 244acd8f2be5..698a893f897f 100644 --- a/src/tools/miri/tests/fail/function_calls/return_pointer_on_unwind.rs +++ b/src/tools/miri/tests/fail/function_calls/return_pointer_on_unwind.rs @@ -1,6 +1,5 @@ // Doesn't need an aliasing model. //@compile-flags: -Zmiri-disable-stacked-borrows -#![feature(raw_ref_op)] #![feature(core_intrinsics)] #![feature(custom_mir)] diff --git a/src/tools/miri/tests/pass/function_calls/return_place_on_heap.rs b/src/tools/miri/tests/pass/function_calls/return_place_on_heap.rs index a5cbe2a0d1d9..04a55d7007ce 100644 --- a/src/tools/miri/tests/pass/function_calls/return_place_on_heap.rs +++ b/src/tools/miri/tests/pass/function_calls/return_place_on_heap.rs @@ -1,4 +1,3 @@ -#![feature(raw_ref_op)] #![feature(core_intrinsics)] #![feature(custom_mir)] diff --git a/tests/mir-opt/const_prop/indirect_mutation.rs b/tests/mir-opt/const_prop/indirect_mutation.rs index 32ff8f142b1e..f001b631acb5 100644 --- a/tests/mir-opt/const_prop/indirect_mutation.rs +++ b/tests/mir-opt/const_prop/indirect_mutation.rs @@ -1,6 +1,5 @@ //@ test-mir-pass: GVN // Check that we do not propagate past an indirect mutation. -#![feature(raw_ref_op)] // EMIT_MIR indirect_mutation.foo.GVN.diff fn foo() { diff --git a/tests/mir-opt/copy-prop/reborrow.rs b/tests/mir-opt/copy-prop/reborrow.rs index 2f1720556cde..51a1f92cde2f 100644 --- a/tests/mir-opt/copy-prop/reborrow.rs +++ b/tests/mir-opt/copy-prop/reborrow.rs @@ -3,8 +3,6 @@ // Check that CopyProp considers reborrows as not mutating the pointer. //@ test-mir-pass: CopyProp -#![feature(raw_ref_op)] - #[inline(never)] fn opaque(_: impl Sized) {} diff --git a/tests/mir-opt/gvn.fn_pointers.GVN.panic-abort.diff b/tests/mir-opt/gvn.fn_pointers.GVN.panic-abort.diff index b5c0cee78468..0c49e706c9ec 100644 --- a/tests/mir-opt/gvn.fn_pointers.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.fn_pointers.GVN.panic-abort.diff @@ -8,10 +8,10 @@ let mut _3: fn(u8) -> u8; let _5: (); let mut _6: fn(u8) -> u8; - let mut _9: {closure@$DIR/gvn.rs:615:19: 615:21}; + let mut _9: {closure@$DIR/gvn.rs:614:19: 614:21}; let _10: (); let mut _11: fn(); - let mut _13: {closure@$DIR/gvn.rs:615:19: 615:21}; + let mut _13: {closure@$DIR/gvn.rs:614:19: 614:21}; let _14: (); let mut _15: fn(); scope 1 { @@ -19,7 +19,7 @@ let _4: fn(u8) -> u8; scope 2 { debug g => _4; - let _7: {closure@$DIR/gvn.rs:615:19: 615:21}; + let _7: {closure@$DIR/gvn.rs:614:19: 614:21}; scope 3 { debug closure => _7; let _8: fn(); @@ -62,16 +62,16 @@ StorageDead(_6); StorageDead(_5); - StorageLive(_7); -- _7 = {closure@$DIR/gvn.rs:615:19: 615:21}; +- _7 = {closure@$DIR/gvn.rs:614:19: 614:21}; - StorageLive(_8); + nop; -+ _7 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21}; ++ _7 = const ZeroSized: {closure@$DIR/gvn.rs:614:19: 614:21}; + nop; StorageLive(_9); - _9 = _7; - _8 = move _9 as fn() (PointerCoercion(ClosureFnPointer(Safe))); -+ _9 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21}; -+ _8 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21} as fn() (PointerCoercion(ClosureFnPointer(Safe))); ++ _9 = const ZeroSized: {closure@$DIR/gvn.rs:614:19: 614:21}; ++ _8 = const ZeroSized: {closure@$DIR/gvn.rs:614:19: 614:21} as fn() (PointerCoercion(ClosureFnPointer(Safe))); StorageDead(_9); StorageLive(_10); StorageLive(_11); @@ -88,8 +88,8 @@ StorageLive(_13); - _13 = _7; - _12 = move _13 as fn() (PointerCoercion(ClosureFnPointer(Safe))); -+ _13 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21}; -+ _12 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21} as fn() (PointerCoercion(ClosureFnPointer(Safe))); ++ _13 = const ZeroSized: {closure@$DIR/gvn.rs:614:19: 614:21}; ++ _12 = const ZeroSized: {closure@$DIR/gvn.rs:614:19: 614:21} as fn() (PointerCoercion(ClosureFnPointer(Safe))); StorageDead(_13); StorageLive(_14); StorageLive(_15); diff --git a/tests/mir-opt/gvn.fn_pointers.GVN.panic-unwind.diff b/tests/mir-opt/gvn.fn_pointers.GVN.panic-unwind.diff index 7bc6573c13d4..e5f865b74b9f 100644 --- a/tests/mir-opt/gvn.fn_pointers.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.fn_pointers.GVN.panic-unwind.diff @@ -8,10 +8,10 @@ let mut _3: fn(u8) -> u8; let _5: (); let mut _6: fn(u8) -> u8; - let mut _9: {closure@$DIR/gvn.rs:615:19: 615:21}; + let mut _9: {closure@$DIR/gvn.rs:614:19: 614:21}; let _10: (); let mut _11: fn(); - let mut _13: {closure@$DIR/gvn.rs:615:19: 615:21}; + let mut _13: {closure@$DIR/gvn.rs:614:19: 614:21}; let _14: (); let mut _15: fn(); scope 1 { @@ -19,7 +19,7 @@ let _4: fn(u8) -> u8; scope 2 { debug g => _4; - let _7: {closure@$DIR/gvn.rs:615:19: 615:21}; + let _7: {closure@$DIR/gvn.rs:614:19: 614:21}; scope 3 { debug closure => _7; let _8: fn(); @@ -62,16 +62,16 @@ StorageDead(_6); StorageDead(_5); - StorageLive(_7); -- _7 = {closure@$DIR/gvn.rs:615:19: 615:21}; +- _7 = {closure@$DIR/gvn.rs:614:19: 614:21}; - StorageLive(_8); + nop; -+ _7 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21}; ++ _7 = const ZeroSized: {closure@$DIR/gvn.rs:614:19: 614:21}; + nop; StorageLive(_9); - _9 = _7; - _8 = move _9 as fn() (PointerCoercion(ClosureFnPointer(Safe))); -+ _9 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21}; -+ _8 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21} as fn() (PointerCoercion(ClosureFnPointer(Safe))); ++ _9 = const ZeroSized: {closure@$DIR/gvn.rs:614:19: 614:21}; ++ _8 = const ZeroSized: {closure@$DIR/gvn.rs:614:19: 614:21} as fn() (PointerCoercion(ClosureFnPointer(Safe))); StorageDead(_9); StorageLive(_10); StorageLive(_11); @@ -88,8 +88,8 @@ StorageLive(_13); - _13 = _7; - _12 = move _13 as fn() (PointerCoercion(ClosureFnPointer(Safe))); -+ _13 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21}; -+ _12 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21} as fn() (PointerCoercion(ClosureFnPointer(Safe))); ++ _13 = const ZeroSized: {closure@$DIR/gvn.rs:614:19: 614:21}; ++ _12 = const ZeroSized: {closure@$DIR/gvn.rs:614:19: 614:21} as fn() (PointerCoercion(ClosureFnPointer(Safe))); StorageDead(_13); StorageLive(_14); StorageLive(_15); diff --git a/tests/mir-opt/gvn.rs b/tests/mir-opt/gvn.rs index 430f979fec71..4bbef9920ff1 100644 --- a/tests/mir-opt/gvn.rs +++ b/tests/mir-opt/gvn.rs @@ -3,7 +3,6 @@ // EMIT_MIR_FOR_EACH_PANIC_STRATEGY //@ only-64bit -#![feature(raw_ref_op)] #![feature(rustc_attrs)] #![feature(custom_mir)] #![feature(core_intrinsics)] diff --git a/tests/mir-opt/instsimplify/ref_of_deref.rs b/tests/mir-opt/instsimplify/ref_of_deref.rs index dc0f5f8198bc..72481f5579ac 100644 --- a/tests/mir-opt/instsimplify/ref_of_deref.rs +++ b/tests/mir-opt/instsimplify/ref_of_deref.rs @@ -1,6 +1,5 @@ //@ test-mir-pass: InstSimplify-after-simplifycfg #![crate_type = "lib"] -#![feature(raw_ref_op)] // For each of these, only 2 of the 6 should simplify, // as the others have the wrong types. diff --git a/tests/mir-opt/reference_prop.rs b/tests/mir-opt/reference_prop.rs index 58d8b524ad64..7c5c02ee7ef6 100644 --- a/tests/mir-opt/reference_prop.rs +++ b/tests/mir-opt/reference_prop.rs @@ -2,7 +2,6 @@ //@ test-mir-pass: ReferencePropagation //@ needs-unwind -#![feature(raw_ref_op)] #![feature(core_intrinsics, custom_mir)] #[inline(never)] diff --git a/tests/pretty/raw-address-of.rs b/tests/pretty/raw-address-of.rs index 6e97ab99407f..c00a16e238a6 100644 --- a/tests/pretty/raw-address-of.rs +++ b/tests/pretty/raw-address-of.rs @@ -1,5 +1,4 @@ //@ pp-exact -#![feature(raw_ref_op)] const C_PTR: () = { let a = 1; &raw const a; }; static S_PTR: () = { let b = false; &raw const b; }; diff --git a/tests/ui/borrowck/borrow-raw-address-of-borrowed.rs b/tests/ui/borrowck/borrow-raw-address-of-borrowed.rs index f25fd7f66b3c..3ed42d072891 100644 --- a/tests/ui/borrowck/borrow-raw-address-of-borrowed.rs +++ b/tests/ui/borrowck/borrow-raw-address-of-borrowed.rs @@ -1,5 +1,3 @@ -#![feature(raw_ref_op)] - fn address_of_shared() { let mut x = 0; let y = &x; diff --git a/tests/ui/borrowck/borrow-raw-address-of-borrowed.stderr b/tests/ui/borrowck/borrow-raw-address-of-borrowed.stderr index 6f7b7e08070b..1a38f8c780e7 100644 --- a/tests/ui/borrowck/borrow-raw-address-of-borrowed.stderr +++ b/tests/ui/borrowck/borrow-raw-address-of-borrowed.stderr @@ -1,5 +1,5 @@ error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable - --> $DIR/borrow-raw-address-of-borrowed.rs:7:13 + --> $DIR/borrow-raw-address-of-borrowed.rs:5:13 | LL | let y = &x; | -- immutable borrow occurs here @@ -11,7 +11,7 @@ LL | drop(y); | - immutable borrow later used here error[E0502]: cannot borrow `x` as immutable because it is also borrowed as mutable - --> $DIR/borrow-raw-address-of-borrowed.rs:16:13 + --> $DIR/borrow-raw-address-of-borrowed.rs:14:13 | LL | let y = &mut x; | ------ mutable borrow occurs here @@ -23,7 +23,7 @@ LL | drop(y); | - mutable borrow later used here error[E0499]: cannot borrow `x` as mutable more than once at a time - --> $DIR/borrow-raw-address-of-borrowed.rs:17:13 + --> $DIR/borrow-raw-address-of-borrowed.rs:15:13 | LL | let y = &mut x; | ------ first mutable borrow occurs here diff --git a/tests/ui/borrowck/borrow-raw-address-of-deref-mutability-ok.rs b/tests/ui/borrowck/borrow-raw-address-of-deref-mutability-ok.rs index 0dfced34c7e2..234097952274 100644 --- a/tests/ui/borrowck/borrow-raw-address-of-deref-mutability-ok.rs +++ b/tests/ui/borrowck/borrow-raw-address-of-deref-mutability-ok.rs @@ -1,7 +1,5 @@ //@ check-pass -#![feature(raw_ref_op)] - fn raw_reborrow() { let x = &0; let y = &mut 0; diff --git a/tests/ui/borrowck/borrow-raw-address-of-deref-mutability.rs b/tests/ui/borrowck/borrow-raw-address-of-deref-mutability.rs index 712873528b5f..5b3936ef5a3f 100644 --- a/tests/ui/borrowck/borrow-raw-address-of-deref-mutability.rs +++ b/tests/ui/borrowck/borrow-raw-address-of-deref-mutability.rs @@ -1,7 +1,5 @@ // Check that `&raw mut` cannot be used to turn a `&T` into a `*mut T`. -#![feature(raw_ref_op)] - fn raw_reborrow() { let x = &0; diff --git a/tests/ui/borrowck/borrow-raw-address-of-deref-mutability.stderr b/tests/ui/borrowck/borrow-raw-address-of-deref-mutability.stderr index cfc86ff0dc12..ac0241cf9a76 100644 --- a/tests/ui/borrowck/borrow-raw-address-of-deref-mutability.stderr +++ b/tests/ui/borrowck/borrow-raw-address-of-deref-mutability.stderr @@ -1,5 +1,5 @@ error[E0596]: cannot borrow `*x` as mutable, as it is behind a `&` reference - --> $DIR/borrow-raw-address-of-deref-mutability.rs:8:13 + --> $DIR/borrow-raw-address-of-deref-mutability.rs:6:13 | LL | let q = &raw mut *x; | ^^^^^^^^^^^ `x` is a `&` reference, so the data it refers to cannot be borrowed as mutable @@ -10,7 +10,7 @@ LL | let x = &mut 0; | +++ error[E0596]: cannot borrow `*x` as mutable, as it is behind a `*const` pointer - --> $DIR/borrow-raw-address-of-deref-mutability.rs:14:13 + --> $DIR/borrow-raw-address-of-deref-mutability.rs:12:13 | LL | let q = &raw mut *x; | ^^^^^^^^^^^ `x` is a `*const` pointer, so the data it refers to cannot be borrowed as mutable diff --git a/tests/ui/borrowck/borrow-raw-address-of-mutability-ok.rs b/tests/ui/borrowck/borrow-raw-address-of-mutability-ok.rs index 7b0232a9d455..ed8c5502a75b 100644 --- a/tests/ui/borrowck/borrow-raw-address-of-mutability-ok.rs +++ b/tests/ui/borrowck/borrow-raw-address-of-mutability-ok.rs @@ -1,7 +1,5 @@ //@ check-pass -#![feature(raw_ref_op)] - fn mutable_address_of() { let mut x = 0; let y = &raw mut x; diff --git a/tests/ui/borrowck/borrow-raw-address-of-mutability.rs b/tests/ui/borrowck/borrow-raw-address-of-mutability.rs index 320c54b806a7..2c5d636d096d 100644 --- a/tests/ui/borrowck/borrow-raw-address-of-mutability.rs +++ b/tests/ui/borrowck/borrow-raw-address-of-mutability.rs @@ -1,5 +1,3 @@ -#![feature(raw_ref_op)] - fn mutable_address_of() { let x = 0; let y = &raw mut x; //~ ERROR cannot borrow diff --git a/tests/ui/borrowck/borrow-raw-address-of-mutability.stderr b/tests/ui/borrowck/borrow-raw-address-of-mutability.stderr index 4b5b368287e1..f81a8c99376f 100644 --- a/tests/ui/borrowck/borrow-raw-address-of-mutability.stderr +++ b/tests/ui/borrowck/borrow-raw-address-of-mutability.stderr @@ -1,5 +1,5 @@ error[E0596]: cannot borrow `x` as mutable, as it is not declared as mutable - --> $DIR/borrow-raw-address-of-mutability.rs:5:13 + --> $DIR/borrow-raw-address-of-mutability.rs:3:13 | LL | let y = &raw mut x; | ^^^^^^^^^^ cannot borrow as mutable @@ -10,7 +10,7 @@ LL | let mut x = 0; | +++ error[E0596]: cannot borrow `x` as mutable, as it is not declared as mutable - --> $DIR/borrow-raw-address-of-mutability.rs:11:17 + --> $DIR/borrow-raw-address-of-mutability.rs:9:17 | LL | let y = &raw mut x; | ^^^^^^^^^^ cannot borrow as mutable @@ -21,7 +21,7 @@ LL | let mut x = 0; | +++ error[E0596]: cannot borrow `f` as mutable, as it is not declared as mutable - --> $DIR/borrow-raw-address-of-mutability.rs:21:5 + --> $DIR/borrow-raw-address-of-mutability.rs:19:5 | LL | let y = &raw mut x; | - calling `f` requires mutable binding due to mutable borrow of `x` @@ -35,7 +35,7 @@ LL | let mut f = || { | +++ error[E0596]: cannot borrow `x` as mutable, as it is a captured variable in a `Fn` closure - --> $DIR/borrow-raw-address-of-mutability.rs:29:17 + --> $DIR/borrow-raw-address-of-mutability.rs:27:17 | LL | fn make_fn(f: F) -> F { f } | - change this to accept `FnMut` instead of `Fn` @@ -48,7 +48,7 @@ LL | let y = &raw mut x; | ^^^^^^^^^^ cannot borrow as mutable error[E0596]: cannot borrow `x` as mutable, as it is a captured variable in a `Fn` closure - --> $DIR/borrow-raw-address-of-mutability.rs:37:17 + --> $DIR/borrow-raw-address-of-mutability.rs:35:17 | LL | fn make_fn(f: F) -> F { f } | - change this to accept `FnMut` instead of `Fn` diff --git a/tests/ui/consts/const-address-of-interior-mut.rs b/tests/ui/consts/const-address-of-interior-mut.rs index 60c7c31daca7..930fa0c492f3 100644 --- a/tests/ui/consts/const-address-of-interior-mut.rs +++ b/tests/ui/consts/const-address-of-interior-mut.rs @@ -1,5 +1,3 @@ -#![feature(raw_ref_op)] - use std::cell::Cell; const A: () = { let x = Cell::new(2); &raw const x; }; //~ ERROR interior mutability diff --git a/tests/ui/consts/const-address-of-interior-mut.stderr b/tests/ui/consts/const-address-of-interior-mut.stderr index 12c8917d740f..203745f0b019 100644 --- a/tests/ui/consts/const-address-of-interior-mut.stderr +++ b/tests/ui/consts/const-address-of-interior-mut.stderr @@ -1,5 +1,5 @@ error[E0658]: cannot borrow here, since the borrowed element may contain interior mutability - --> $DIR/const-address-of-interior-mut.rs:5:39 + --> $DIR/const-address-of-interior-mut.rs:3:39 | LL | const A: () = { let x = Cell::new(2); &raw const x; }; | ^^^^^^^^^^^^ @@ -9,7 +9,7 @@ LL | const A: () = { let x = Cell::new(2); &raw const x; }; = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date error[E0658]: cannot borrow here, since the borrowed element may contain interior mutability - --> $DIR/const-address-of-interior-mut.rs:7:40 + --> $DIR/const-address-of-interior-mut.rs:5:40 | LL | static B: () = { let x = Cell::new(2); &raw const x; }; | ^^^^^^^^^^^^ @@ -19,7 +19,7 @@ LL | static B: () = { let x = Cell::new(2); &raw const x; }; = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date error[E0658]: cannot borrow here, since the borrowed element may contain interior mutability - --> $DIR/const-address-of-interior-mut.rs:9:44 + --> $DIR/const-address-of-interior-mut.rs:7:44 | LL | static mut C: () = { let x = Cell::new(2); &raw const x; }; | ^^^^^^^^^^^^ @@ -29,7 +29,7 @@ LL | static mut C: () = { let x = Cell::new(2); &raw const x; }; = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date error[E0658]: cannot borrow here, since the borrowed element may contain interior mutability - --> $DIR/const-address-of-interior-mut.rs:13:13 + --> $DIR/const-address-of-interior-mut.rs:11:13 | LL | let y = &raw const x; | ^^^^^^^^^^^^ diff --git a/tests/ui/consts/const-address-of-mut.rs b/tests/ui/consts/const-address-of-mut.rs index 0018bf18e419..c3f37843d3c1 100644 --- a/tests/ui/consts/const-address-of-mut.rs +++ b/tests/ui/consts/const-address-of-mut.rs @@ -1,5 +1,3 @@ -#![feature(raw_ref_op)] - const A: () = { let mut x = 2; &raw mut x; }; //~ mutable pointer static B: () = { let mut x = 2; &raw mut x; }; //~ mutable pointer diff --git a/tests/ui/consts/const-address-of-mut.stderr b/tests/ui/consts/const-address-of-mut.stderr index 95a91ff463f6..d4243485de15 100644 --- a/tests/ui/consts/const-address-of-mut.stderr +++ b/tests/ui/consts/const-address-of-mut.stderr @@ -1,5 +1,5 @@ error[E0658]: raw mutable pointers are not allowed in constants - --> $DIR/const-address-of-mut.rs:3:32 + --> $DIR/const-address-of-mut.rs:1:32 | LL | const A: () = { let mut x = 2; &raw mut x; }; | ^^^^^^^^^^ @@ -9,7 +9,7 @@ LL | const A: () = { let mut x = 2; &raw mut x; }; = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date error[E0658]: raw mutable pointers are not allowed in statics - --> $DIR/const-address-of-mut.rs:5:33 + --> $DIR/const-address-of-mut.rs:3:33 | LL | static B: () = { let mut x = 2; &raw mut x; }; | ^^^^^^^^^^ @@ -19,7 +19,7 @@ LL | static B: () = { let mut x = 2; &raw mut x; }; = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date error[E0658]: raw mutable pointers are not allowed in constant functions - --> $DIR/const-address-of-mut.rs:9:13 + --> $DIR/const-address-of-mut.rs:7:13 | LL | let y = &raw mut x; | ^^^^^^^^^^ diff --git a/tests/ui/consts/const-address-of.rs b/tests/ui/consts/const-address-of.rs index 4eb3c3840ba4..39ed430e17ea 100644 --- a/tests/ui/consts/const-address-of.rs +++ b/tests/ui/consts/const-address-of.rs @@ -1,7 +1,5 @@ //@ check-pass -#![feature(raw_ref_op)] - const A: *const i32 = &raw const *&2; static B: () = { &raw const *&2; }; static mut C: *const i32 = &raw const *&2; diff --git a/tests/ui/consts/const-mut-refs/const_mut_address_of.rs b/tests/ui/consts/const-mut-refs/const_mut_address_of.rs index 66a4ec50c11d..437bdc88722c 100644 --- a/tests/ui/consts/const-mut-refs/const_mut_address_of.rs +++ b/tests/ui/consts/const-mut-refs/const_mut_address_of.rs @@ -1,6 +1,5 @@ //@ check-pass #![feature(const_mut_refs)] -#![feature(raw_ref_op)] struct Foo { x: usize diff --git a/tests/ui/consts/const-mut-refs/mut_ref_in_final.rs b/tests/ui/consts/const-mut-refs/mut_ref_in_final.rs index 93197d5bce49..10339ee6798e 100644 --- a/tests/ui/consts/const-mut-refs/mut_ref_in_final.rs +++ b/tests/ui/consts/const-mut-refs/mut_ref_in_final.rs @@ -1,5 +1,4 @@ #![feature(const_mut_refs)] -#![feature(raw_ref_op)] const NULL: *mut i32 = std::ptr::null_mut(); const A: *const i32 = &4; diff --git a/tests/ui/consts/const-mut-refs/mut_ref_in_final.stderr b/tests/ui/consts/const-mut-refs/mut_ref_in_final.stderr index 59e6aa4011c2..00a8421076b8 100644 --- a/tests/ui/consts/const-mut-refs/mut_ref_in_final.stderr +++ b/tests/ui/consts/const-mut-refs/mut_ref_in_final.stderr @@ -1,11 +1,11 @@ error[E0764]: mutable references are not allowed in the final value of constants - --> $DIR/mut_ref_in_final.rs:10:21 + --> $DIR/mut_ref_in_final.rs:9:21 | LL | const B: *mut i32 = &mut 4; | ^^^^^^ error[E0716]: temporary value dropped while borrowed - --> $DIR/mut_ref_in_final.rs:16:40 + --> $DIR/mut_ref_in_final.rs:15:40 | LL | const B3: Option<&mut i32> = Some(&mut 42); | ----------^^- @@ -15,7 +15,7 @@ LL | const B3: Option<&mut i32> = Some(&mut 42); | using this value as a constant requires that borrow lasts for `'static` error[E0716]: temporary value dropped while borrowed - --> $DIR/mut_ref_in_final.rs:19:42 + --> $DIR/mut_ref_in_final.rs:18:42 | LL | const B4: Option<&mut i32> = helper(&mut 42); | ------------^^- @@ -25,7 +25,7 @@ LL | const B4: Option<&mut i32> = helper(&mut 42); | using this value as a constant requires that borrow lasts for `'static` error[E0716]: temporary value dropped while borrowed - --> $DIR/mut_ref_in_final.rs:34:65 + --> $DIR/mut_ref_in_final.rs:33:65 | LL | const FOO: NotAMutex<&mut i32> = NotAMutex(UnsafeCell::new(&mut 42)); | -------------------------------^^-- @@ -35,7 +35,7 @@ LL | const FOO: NotAMutex<&mut i32> = NotAMutex(UnsafeCell::new(&mut 42)); | using this value as a constant requires that borrow lasts for `'static` error[E0716]: temporary value dropped while borrowed - --> $DIR/mut_ref_in_final.rs:37:67 + --> $DIR/mut_ref_in_final.rs:36:67 | LL | static FOO2: NotAMutex<&mut i32> = NotAMutex(UnsafeCell::new(&mut 42)); | -------------------------------^^-- @@ -45,7 +45,7 @@ LL | static FOO2: NotAMutex<&mut i32> = NotAMutex(UnsafeCell::new(&mut 42)); | using this value as a static requires that borrow lasts for `'static` error[E0716]: temporary value dropped while borrowed - --> $DIR/mut_ref_in_final.rs:40:71 + --> $DIR/mut_ref_in_final.rs:39:71 | LL | static mut FOO3: NotAMutex<&mut i32> = NotAMutex(UnsafeCell::new(&mut 42)); | -------------------------------^^-- @@ -55,25 +55,25 @@ LL | static mut FOO3: NotAMutex<&mut i32> = NotAMutex(UnsafeCell::new(&mut 42)); | using this value as a static requires that borrow lasts for `'static` error[E0764]: mutable references are not allowed in the final value of statics - --> $DIR/mut_ref_in_final.rs:53:53 + --> $DIR/mut_ref_in_final.rs:52:53 | LL | static RAW_MUT_CAST_S: SyncPtr = SyncPtr { x : &mut 42 as *mut _ as *const _ }; | ^^^^^^^ error[E0764]: mutable references are not allowed in the final value of statics - --> $DIR/mut_ref_in_final.rs:55:54 + --> $DIR/mut_ref_in_final.rs:54:54 | LL | static RAW_MUT_COERCE_S: SyncPtr = SyncPtr { x: &mut 0 }; | ^^^^^^ error[E0764]: mutable references are not allowed in the final value of constants - --> $DIR/mut_ref_in_final.rs:57:52 + --> $DIR/mut_ref_in_final.rs:56:52 | LL | const RAW_MUT_CAST_C: SyncPtr = SyncPtr { x : &mut 42 as *mut _ as *const _ }; | ^^^^^^^ error[E0764]: mutable references are not allowed in the final value of constants - --> $DIR/mut_ref_in_final.rs:59:53 + --> $DIR/mut_ref_in_final.rs:58:53 | LL | const RAW_MUT_COERCE_C: SyncPtr = SyncPtr { x: &mut 0 }; | ^^^^^^ diff --git a/tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.rs b/tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.rs index c12c22447b59..e208845e7470 100644 --- a/tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.rs +++ b/tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.rs @@ -2,7 +2,6 @@ //@ normalize-stderr-test: "( 0x[0-9a-f][0-9a-f] │)? ([0-9a-f][0-9a-f] |__ |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?()?─*╼ )+ *│.*" -> " HEX_DUMP" //@ normalize-stderr-test: "HEX_DUMP\s*\n\s*HEX_DUMP" -> "HEX_DUMP" #![feature(const_mut_refs, const_refs_to_static)] -#![feature(raw_ref_op)] use std::sync::Mutex; diff --git a/tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.stderr b/tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.stderr index ea9dccf0173c..4ea6fa62475e 100644 --- a/tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.stderr +++ b/tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.stderr @@ -1,5 +1,5 @@ error[E0080]: it is undefined behavior to use this value - --> $DIR/mut_ref_in_final_dynamic_check.rs:20:1 + --> $DIR/mut_ref_in_final_dynamic_check.rs:19:1 | LL | const MUT: Option<&mut i32> = helper(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at ..0: encountered reference to mutable memory in `const` @@ -10,7 +10,7 @@ LL | const MUT: Option<&mut i32> = helper(); } error[E0080]: it is undefined behavior to use this value - --> $DIR/mut_ref_in_final_dynamic_check.rs:27:1 + --> $DIR/mut_ref_in_final_dynamic_check.rs:26:1 | LL | const INT2PTR: Option<&mut i32> = helper_int2ptr(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at ..0: encountered a dangling reference (0x2a[noalloc] has no provenance) @@ -21,7 +21,7 @@ LL | const INT2PTR: Option<&mut i32> = helper_int2ptr(); } error[E0080]: it is undefined behavior to use this value - --> $DIR/mut_ref_in_final_dynamic_check.rs:29:1 + --> $DIR/mut_ref_in_final_dynamic_check.rs:28:1 | LL | static INT2PTR_STATIC: Option<&mut i32> = helper_int2ptr(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at ..0: encountered a dangling reference (0x2a[noalloc] has no provenance) @@ -32,7 +32,7 @@ LL | static INT2PTR_STATIC: Option<&mut i32> = helper_int2ptr(); } error[E0080]: it is undefined behavior to use this value - --> $DIR/mut_ref_in_final_dynamic_check.rs:36:1 + --> $DIR/mut_ref_in_final_dynamic_check.rs:35:1 | LL | const DANGLING: Option<&mut i32> = helper_dangling(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at ..0: encountered a dangling reference (use-after-free) @@ -43,7 +43,7 @@ LL | const DANGLING: Option<&mut i32> = helper_dangling(); } error[E0080]: it is undefined behavior to use this value - --> $DIR/mut_ref_in_final_dynamic_check.rs:37:1 + --> $DIR/mut_ref_in_final_dynamic_check.rs:36:1 | LL | static DANGLING_STATIC: Option<&mut i32> = helper_dangling(); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at ..0: encountered a dangling reference (use-after-free) diff --git a/tests/ui/consts/min_const_fn/address_of.rs b/tests/ui/consts/min_const_fn/address_of.rs index aa75423ca4d6..dc481e17ba38 100644 --- a/tests/ui/consts/min_const_fn/address_of.rs +++ b/tests/ui/consts/min_const_fn/address_of.rs @@ -1,5 +1,3 @@ -#![feature(raw_ref_op)] - const fn mutable_address_of_in_const() { let mut a = 0; let b = &raw mut a; //~ ERROR mutable pointer diff --git a/tests/ui/consts/min_const_fn/address_of.stderr b/tests/ui/consts/min_const_fn/address_of.stderr index 143760c0943d..dd6fe6486d49 100644 --- a/tests/ui/consts/min_const_fn/address_of.stderr +++ b/tests/ui/consts/min_const_fn/address_of.stderr @@ -1,5 +1,5 @@ error[E0658]: raw mutable pointers are not allowed in constant functions - --> $DIR/address_of.rs:5:13 + --> $DIR/address_of.rs:3:13 | LL | let b = &raw mut a; | ^^^^^^^^^^ @@ -9,7 +9,7 @@ LL | let b = &raw mut a; = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date error[E0658]: raw mutable pointers are not allowed in constant functions - --> $DIR/address_of.rs:13:17 + --> $DIR/address_of.rs:11:17 | LL | let b = &raw mut a; | ^^^^^^^^^^ diff --git a/tests/ui/consts/min_const_fn/address_of_const.rs b/tests/ui/consts/min_const_fn/address_of_const.rs index 4280d0745c1a..1520622679fb 100644 --- a/tests/ui/consts/min_const_fn/address_of_const.rs +++ b/tests/ui/consts/min_const_fn/address_of_const.rs @@ -1,7 +1,5 @@ //@ check-pass -#![feature(raw_ref_op)] - const fn const_address_of_in_const() { let mut a = 0; let b = &raw const a; diff --git a/tests/ui/consts/qualif-indirect-mutation-fail.rs b/tests/ui/consts/qualif-indirect-mutation-fail.rs index 420e32128a4b..a99d0633ba13 100644 --- a/tests/ui/consts/qualif-indirect-mutation-fail.rs +++ b/tests/ui/consts/qualif-indirect-mutation-fail.rs @@ -2,7 +2,6 @@ #![feature(const_mut_refs)] #![feature(const_precise_live_drops)] #![feature(const_swap)] -#![feature(raw_ref_op)] // Mutable borrow of a field with drop impl. pub const fn f() { diff --git a/tests/ui/consts/qualif-indirect-mutation-fail.stderr b/tests/ui/consts/qualif-indirect-mutation-fail.stderr index 458dc2071c48..21c872ed13f2 100644 --- a/tests/ui/consts/qualif-indirect-mutation-fail.stderr +++ b/tests/ui/consts/qualif-indirect-mutation-fail.stderr @@ -1,5 +1,5 @@ error[E0493]: destructor of `Option` cannot be evaluated at compile-time - --> $DIR/qualif-indirect-mutation-fail.rs:15:9 + --> $DIR/qualif-indirect-mutation-fail.rs:14:9 | LL | let mut x = None; | ^^^^^ the destructor for this type cannot be evaluated in constants @@ -16,13 +16,13 @@ note: inside `std::ptr::drop_in_place:: - shim(Some(String))` note: inside `std::ptr::drop_in_place::> - shim(Some(Option))` --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL note: inside `A1` - --> $DIR/qualif-indirect-mutation-fail.rs:21:1 + --> $DIR/qualif-indirect-mutation-fail.rs:20:1 | LL | }; | ^ error[E0493]: destructor of `Option` cannot be evaluated at compile-time - --> $DIR/qualif-indirect-mutation-fail.rs:31:9 + --> $DIR/qualif-indirect-mutation-fail.rs:30:9 | LL | let _z = x; | ^^ the destructor for this type cannot be evaluated in constants @@ -39,49 +39,49 @@ note: inside `std::ptr::drop_in_place:: - shim(Some(String))` note: inside `std::ptr::drop_in_place::> - shim(Some(Option))` --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL note: inside `A2` - --> $DIR/qualif-indirect-mutation-fail.rs:32:1 + --> $DIR/qualif-indirect-mutation-fail.rs:31:1 | LL | }; | ^ error[E0493]: destructor of `(u32, Option)` cannot be evaluated at compile-time - --> $DIR/qualif-indirect-mutation-fail.rs:9:9 + --> $DIR/qualif-indirect-mutation-fail.rs:8:9 | LL | let mut a: (u32, Option) = (0, None); | ^^^^^ the destructor for this type cannot be evaluated in constant functions error[E0493]: destructor of `Option` cannot be evaluated at compile-time - --> $DIR/qualif-indirect-mutation-fail.rs:36:9 + --> $DIR/qualif-indirect-mutation-fail.rs:35:9 | LL | let x: Option = None; | ^ the destructor for this type cannot be evaluated in constant functions error[E0493]: destructor of `Option` cannot be evaluated at compile-time - --> $DIR/qualif-indirect-mutation-fail.rs:44:9 + --> $DIR/qualif-indirect-mutation-fail.rs:43:9 | LL | let _y = x; | ^^ the destructor for this type cannot be evaluated in constant functions error[E0493]: destructor of `Option` cannot be evaluated at compile-time - --> $DIR/qualif-indirect-mutation-fail.rs:52:9 + --> $DIR/qualif-indirect-mutation-fail.rs:51:9 | LL | let mut y: Option = None; | ^^^^^ the destructor for this type cannot be evaluated in constant functions error[E0493]: destructor of `Option` cannot be evaluated at compile-time - --> $DIR/qualif-indirect-mutation-fail.rs:49:9 + --> $DIR/qualif-indirect-mutation-fail.rs:48:9 | LL | let mut x: Option = None; | ^^^^^ the destructor for this type cannot be evaluated in constant functions error[E0493]: destructor of `Option` cannot be evaluated at compile-time - --> $DIR/qualif-indirect-mutation-fail.rs:62:9 + --> $DIR/qualif-indirect-mutation-fail.rs:61:9 | LL | let y: Option = None; | ^ the destructor for this type cannot be evaluated in constant functions error[E0493]: destructor of `Option` cannot be evaluated at compile-time - --> $DIR/qualif-indirect-mutation-fail.rs:59:9 + --> $DIR/qualif-indirect-mutation-fail.rs:58:9 | LL | let x: Option = None; | ^ the destructor for this type cannot be evaluated in constant functions diff --git a/tests/ui/lint/lint-unnecessary-parens.fixed b/tests/ui/lint/lint-unnecessary-parens.fixed index 089aa1b7ab7d..a8c8dd1d512f 100644 --- a/tests/ui/lint/lint-unnecessary-parens.fixed +++ b/tests/ui/lint/lint-unnecessary-parens.fixed @@ -1,7 +1,6 @@ //@ run-rustfix #![deny(unused_parens)] -#![feature(raw_ref_op)] #![allow(while_true)] // for rustfix #[derive(Eq, PartialEq)] diff --git a/tests/ui/lint/lint-unnecessary-parens.rs b/tests/ui/lint/lint-unnecessary-parens.rs index dc77ee003523..02aa78283c78 100644 --- a/tests/ui/lint/lint-unnecessary-parens.rs +++ b/tests/ui/lint/lint-unnecessary-parens.rs @@ -1,7 +1,6 @@ //@ run-rustfix #![deny(unused_parens)] -#![feature(raw_ref_op)] #![allow(while_true)] // for rustfix #[derive(Eq, PartialEq)] diff --git a/tests/ui/lint/lint-unnecessary-parens.stderr b/tests/ui/lint/lint-unnecessary-parens.stderr index c9422437a9fc..f2e5debd6e08 100644 --- a/tests/ui/lint/lint-unnecessary-parens.stderr +++ b/tests/ui/lint/lint-unnecessary-parens.stderr @@ -1,5 +1,5 @@ error: unnecessary parentheses around `return` value - --> $DIR/lint-unnecessary-parens.rs:14:12 + --> $DIR/lint-unnecessary-parens.rs:13:12 | LL | return (1); | ^ ^ @@ -16,7 +16,7 @@ LL + return 1; | error: unnecessary parentheses around `return` value - --> $DIR/lint-unnecessary-parens.rs:17:12 + --> $DIR/lint-unnecessary-parens.rs:16:12 | LL | return (X { y }); | ^ ^ @@ -28,7 +28,7 @@ LL + return X { y }; | error: unnecessary parentheses around type - --> $DIR/lint-unnecessary-parens.rs:20:46 + --> $DIR/lint-unnecessary-parens.rs:19:46 | LL | pub fn unused_parens_around_return_type() -> (u32) { | ^ ^ @@ -40,7 +40,7 @@ LL + pub fn unused_parens_around_return_type() -> u32 { | error: unnecessary parentheses around block return value - --> $DIR/lint-unnecessary-parens.rs:26:9 + --> $DIR/lint-unnecessary-parens.rs:25:9 | LL | (5) | ^ ^ @@ -52,7 +52,7 @@ LL + 5 | error: unnecessary parentheses around block return value - --> $DIR/lint-unnecessary-parens.rs:28:5 + --> $DIR/lint-unnecessary-parens.rs:27:5 | LL | (5) | ^ ^ @@ -64,7 +64,7 @@ LL + 5 | error: unnecessary parentheses around `if` condition - --> $DIR/lint-unnecessary-parens.rs:40:7 + --> $DIR/lint-unnecessary-parens.rs:39:7 | LL | if(true) {} | ^ ^ @@ -76,7 +76,7 @@ LL + if true {} | error: unnecessary parentheses around `while` condition - --> $DIR/lint-unnecessary-parens.rs:41:10 + --> $DIR/lint-unnecessary-parens.rs:40:10 | LL | while(true) {} | ^ ^ @@ -88,7 +88,7 @@ LL + while true {} | error: unnecessary parentheses around `for` iterator expression - --> $DIR/lint-unnecessary-parens.rs:42:13 + --> $DIR/lint-unnecessary-parens.rs:41:13 | LL | for _ in(e) {} | ^ ^ @@ -100,7 +100,7 @@ LL + for _ in e {} | error: unnecessary parentheses around `match` scrutinee expression - --> $DIR/lint-unnecessary-parens.rs:43:10 + --> $DIR/lint-unnecessary-parens.rs:42:10 | LL | match(1) { _ => ()} | ^ ^ @@ -112,7 +112,7 @@ LL + match 1 { _ => ()} | error: unnecessary parentheses around `return` value - --> $DIR/lint-unnecessary-parens.rs:44:11 + --> $DIR/lint-unnecessary-parens.rs:43:11 | LL | return(1); | ^ ^ @@ -124,7 +124,7 @@ LL + return 1; | error: unnecessary parentheses around assigned value - --> $DIR/lint-unnecessary-parens.rs:75:31 + --> $DIR/lint-unnecessary-parens.rs:74:31 | LL | pub const CONST_ITEM: usize = (10); | ^ ^ @@ -136,7 +136,7 @@ LL + pub const CONST_ITEM: usize = 10; | error: unnecessary parentheses around assigned value - --> $DIR/lint-unnecessary-parens.rs:76:33 + --> $DIR/lint-unnecessary-parens.rs:75:33 | LL | pub static STATIC_ITEM: usize = (10); | ^ ^ @@ -148,7 +148,7 @@ LL + pub static STATIC_ITEM: usize = 10; | error: unnecessary parentheses around function argument - --> $DIR/lint-unnecessary-parens.rs:80:9 + --> $DIR/lint-unnecessary-parens.rs:79:9 | LL | bar((true)); | ^ ^ @@ -160,7 +160,7 @@ LL + bar(true); | error: unnecessary parentheses around `if` condition - --> $DIR/lint-unnecessary-parens.rs:82:8 + --> $DIR/lint-unnecessary-parens.rs:81:8 | LL | if (true) {} | ^ ^ @@ -172,7 +172,7 @@ LL + if true {} | error: unnecessary parentheses around `while` condition - --> $DIR/lint-unnecessary-parens.rs:83:11 + --> $DIR/lint-unnecessary-parens.rs:82:11 | LL | while (true) {} | ^ ^ @@ -184,7 +184,7 @@ LL + while true {} | error: unnecessary parentheses around `match` scrutinee expression - --> $DIR/lint-unnecessary-parens.rs:84:11 + --> $DIR/lint-unnecessary-parens.rs:83:11 | LL | match (true) { | ^ ^ @@ -196,7 +196,7 @@ LL + match true { | error: unnecessary parentheses around `let` scrutinee expression - --> $DIR/lint-unnecessary-parens.rs:87:16 + --> $DIR/lint-unnecessary-parens.rs:86:16 | LL | if let 1 = (1) {} | ^ ^ @@ -208,7 +208,7 @@ LL + if let 1 = 1 {} | error: unnecessary parentheses around `let` scrutinee expression - --> $DIR/lint-unnecessary-parens.rs:88:19 + --> $DIR/lint-unnecessary-parens.rs:87:19 | LL | while let 1 = (2) {} | ^ ^ @@ -220,7 +220,7 @@ LL + while let 1 = 2 {} | error: unnecessary parentheses around method argument - --> $DIR/lint-unnecessary-parens.rs:104:24 + --> $DIR/lint-unnecessary-parens.rs:103:24 | LL | X { y: false }.foo((true)); | ^ ^ @@ -232,7 +232,7 @@ LL + X { y: false }.foo(true); | error: unnecessary parentheses around assigned value - --> $DIR/lint-unnecessary-parens.rs:106:18 + --> $DIR/lint-unnecessary-parens.rs:105:18 | LL | let mut _a = (0); | ^ ^ @@ -244,7 +244,7 @@ LL + let mut _a = 0; | error: unnecessary parentheses around assigned value - --> $DIR/lint-unnecessary-parens.rs:107:10 + --> $DIR/lint-unnecessary-parens.rs:106:10 | LL | _a = (0); | ^ ^ @@ -256,7 +256,7 @@ LL + _a = 0; | error: unnecessary parentheses around assigned value - --> $DIR/lint-unnecessary-parens.rs:108:11 + --> $DIR/lint-unnecessary-parens.rs:107:11 | LL | _a += (1); | ^ ^ @@ -268,7 +268,7 @@ LL + _a += 1; | error: unnecessary parentheses around pattern - --> $DIR/lint-unnecessary-parens.rs:110:8 + --> $DIR/lint-unnecessary-parens.rs:109:8 | LL | let(mut _a) = 3; | ^ ^ @@ -280,7 +280,7 @@ LL + let mut _a = 3; | error: unnecessary parentheses around pattern - --> $DIR/lint-unnecessary-parens.rs:111:9 + --> $DIR/lint-unnecessary-parens.rs:110:9 | LL | let (mut _a) = 3; | ^ ^ @@ -292,7 +292,7 @@ LL + let mut _a = 3; | error: unnecessary parentheses around pattern - --> $DIR/lint-unnecessary-parens.rs:112:8 + --> $DIR/lint-unnecessary-parens.rs:111:8 | LL | let( mut _a) = 3; | ^^ ^ @@ -304,7 +304,7 @@ LL + let mut _a = 3; | error: unnecessary parentheses around pattern - --> $DIR/lint-unnecessary-parens.rs:114:8 + --> $DIR/lint-unnecessary-parens.rs:113:8 | LL | let(_a) = 3; | ^ ^ @@ -316,7 +316,7 @@ LL + let _a = 3; | error: unnecessary parentheses around pattern - --> $DIR/lint-unnecessary-parens.rs:115:9 + --> $DIR/lint-unnecessary-parens.rs:114:9 | LL | let (_a) = 3; | ^ ^ @@ -328,7 +328,7 @@ LL + let _a = 3; | error: unnecessary parentheses around pattern - --> $DIR/lint-unnecessary-parens.rs:116:8 + --> $DIR/lint-unnecessary-parens.rs:115:8 | LL | let( _a) = 3; | ^^ ^ @@ -340,7 +340,7 @@ LL + let _a = 3; | error: unnecessary parentheses around block return value - --> $DIR/lint-unnecessary-parens.rs:122:9 + --> $DIR/lint-unnecessary-parens.rs:121:9 | LL | (unit!() - One) | ^ ^ @@ -352,7 +352,7 @@ LL + unit!() - One | error: unnecessary parentheses around block return value - --> $DIR/lint-unnecessary-parens.rs:124:9 + --> $DIR/lint-unnecessary-parens.rs:123:9 | LL | (unit![] - One) | ^ ^ @@ -364,7 +364,7 @@ LL + unit![] - One | error: unnecessary parentheses around block return value - --> $DIR/lint-unnecessary-parens.rs:127:9 + --> $DIR/lint-unnecessary-parens.rs:126:9 | LL | (unit! {} - One) | ^ ^ @@ -376,7 +376,7 @@ LL + unit! {} - One | error: unnecessary parentheses around assigned value - --> $DIR/lint-unnecessary-parens.rs:132:14 + --> $DIR/lint-unnecessary-parens.rs:131:14 | LL | let _r = (&x); | ^ ^ @@ -388,7 +388,7 @@ LL + let _r = &x; | error: unnecessary parentheses around assigned value - --> $DIR/lint-unnecessary-parens.rs:133:14 + --> $DIR/lint-unnecessary-parens.rs:132:14 | LL | let _r = (&mut x); | ^ ^ diff --git a/tests/ui/lint/unused/lint-unused-mut-variables.rs b/tests/ui/lint/unused/lint-unused-mut-variables.rs index f0c7dff666e2..bc38af9867cd 100644 --- a/tests/ui/lint/unused/lint-unused-mut-variables.rs +++ b/tests/ui/lint/unused/lint-unused-mut-variables.rs @@ -3,7 +3,7 @@ // Exercise the unused_mut attribute in some positive and negative cases #![warn(unused_mut)] -#![feature(async_closure, raw_ref_op)] +#![feature(async_closure)] async fn baz_async( mut a: i32, diff --git a/tests/ui/macros/stringify.rs b/tests/ui/macros/stringify.rs index 37409dd066d5..f405cd253deb 100644 --- a/tests/ui/macros/stringify.rs +++ b/tests/ui/macros/stringify.rs @@ -14,7 +14,6 @@ #![feature(let_chains)] #![feature(more_qualified_paths)] #![feature(never_patterns)] -#![feature(raw_ref_op)] #![feature(trait_alias)] #![feature(try_blocks)] #![feature(type_ascription)] diff --git a/tests/ui/mir/mir_raw_fat_ptr.rs b/tests/ui/mir/mir_raw_fat_ptr.rs index a5a48587e3bb..96c030b70e50 100644 --- a/tests/ui/mir/mir_raw_fat_ptr.rs +++ b/tests/ui/mir/mir_raw_fat_ptr.rs @@ -2,7 +2,6 @@ // check raw fat pointer ops in mir // FIXME: please improve this when we get monomorphization support -#![feature(raw_ref_op)] #![allow(ambiguous_wide_pointer_comparisons)] use std::mem; diff --git a/tests/ui/mir/mir_raw_fat_ptr.stderr b/tests/ui/mir/mir_raw_fat_ptr.stderr index a9e9dd66ebdf..cd99d566654f 100644 --- a/tests/ui/mir/mir_raw_fat_ptr.stderr +++ b/tests/ui/mir/mir_raw_fat_ptr.stderr @@ -1,5 +1,5 @@ warning: method `foo` is never used - --> $DIR/mir_raw_fat_ptr.rs:101:16 + --> $DIR/mir_raw_fat_ptr.rs:100:16 | LL | trait Foo { fn foo(&self) -> usize; } | --- ^^^ diff --git a/tests/ui/packed/packed-struct-address-of-element.rs b/tests/ui/packed/packed-struct-address-of-element.rs index 3fc27d4a96a7..5d7c0b3d8b1b 100644 --- a/tests/ui/packed/packed-struct-address-of-element.rs +++ b/tests/ui/packed/packed-struct-address-of-element.rs @@ -1,6 +1,5 @@ //@ run-pass #![allow(dead_code)] -#![feature(raw_ref_op)] //@ ignore-emscripten weird assertion? #[repr(packed)] diff --git a/tests/ui/raw-ref-op/feature-raw-ref-op.rs b/tests/ui/raw-ref-op/feature-raw-ref-op.rs deleted file mode 100644 index 0a44b1cde40b..000000000000 --- a/tests/ui/raw-ref-op/feature-raw-ref-op.rs +++ /dev/null @@ -1,21 +0,0 @@ -// gate-test-raw_ref_op - -macro_rules! is_expr { - ($e:expr) => {} -} - -is_expr!(&raw const a); //~ ERROR raw address of syntax is experimental -is_expr!(&raw mut a); //~ ERROR raw address of syntax is experimental - -#[cfg(FALSE)] -fn cfgd_out() { - let mut a = 0; - &raw const a; //~ ERROR raw address of syntax is experimental - &raw mut a; //~ ERROR raw address of syntax is experimental -} - -fn main() { - let mut y = 123; - let x = &raw const y; //~ ERROR raw address of syntax is experimental - let x = &raw mut y; //~ ERROR raw address of syntax is experimental -} diff --git a/tests/ui/raw-ref-op/feature-raw-ref-op.stderr b/tests/ui/raw-ref-op/feature-raw-ref-op.stderr deleted file mode 100644 index 4ffd0c90e48b..000000000000 --- a/tests/ui/raw-ref-op/feature-raw-ref-op.stderr +++ /dev/null @@ -1,63 +0,0 @@ -error[E0658]: raw address of syntax is experimental - --> $DIR/feature-raw-ref-op.rs:13:5 - | -LL | &raw const a; - | ^^^^^^^^^^ - | - = note: see issue #64490 for more information - = help: add `#![feature(raw_ref_op)]` to the crate attributes to enable - = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date - -error[E0658]: raw address of syntax is experimental - --> $DIR/feature-raw-ref-op.rs:14:5 - | -LL | &raw mut a; - | ^^^^^^^^ - | - = note: see issue #64490 for more information - = help: add `#![feature(raw_ref_op)]` to the crate attributes to enable - = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date - -error[E0658]: raw address of syntax is experimental - --> $DIR/feature-raw-ref-op.rs:19:13 - | -LL | let x = &raw const y; - | ^^^^^^^^^^ - | - = note: see issue #64490 for more information - = help: add `#![feature(raw_ref_op)]` to the crate attributes to enable - = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date - -error[E0658]: raw address of syntax is experimental - --> $DIR/feature-raw-ref-op.rs:20:13 - | -LL | let x = &raw mut y; - | ^^^^^^^^ - | - = note: see issue #64490 for more information - = help: add `#![feature(raw_ref_op)]` to the crate attributes to enable - = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date - -error[E0658]: raw address of syntax is experimental - --> $DIR/feature-raw-ref-op.rs:7:10 - | -LL | is_expr!(&raw const a); - | ^^^^^^^^^^ - | - = note: see issue #64490 for more information - = help: add `#![feature(raw_ref_op)]` to the crate attributes to enable - = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date - -error[E0658]: raw address of syntax is experimental - --> $DIR/feature-raw-ref-op.rs:8:10 - | -LL | is_expr!(&raw mut a); - | ^^^^^^^^ - | - = note: see issue #64490 for more information - = help: add `#![feature(raw_ref_op)]` to the crate attributes to enable - = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date - -error: aborting due to 6 previous errors - -For more information about this error, try `rustc --explain E0658`. diff --git a/tests/ui/raw-ref-op/raw-ref-op.rs b/tests/ui/raw-ref-op/raw-ref-op.rs index 70b7a5a48067..0989a6005dc5 100644 --- a/tests/ui/raw-ref-op/raw-ref-op.rs +++ b/tests/ui/raw-ref-op/raw-ref-op.rs @@ -1,7 +1,5 @@ //@ run-pass -#![feature(raw_ref_op)] - fn main() { let mut x = 123; let c_p = &raw const x; diff --git a/tests/ui/raw-ref-op/raw-ref-temp-deref.rs b/tests/ui/raw-ref-op/raw-ref-temp-deref.rs index 5270bdb7a2b5..a0078bbc1cdf 100644 --- a/tests/ui/raw-ref-op/raw-ref-temp-deref.rs +++ b/tests/ui/raw-ref-op/raw-ref-temp-deref.rs @@ -1,7 +1,7 @@ //@ check-pass // Check that taking the address of a place that contains a dereference is // allowed. -#![feature(raw_ref_op, type_ascription)] +#![feature(type_ascription)] const PAIR_REF: &(i32, i64) = &(1, 2); diff --git a/tests/ui/raw-ref-op/raw-ref-temp.rs b/tests/ui/raw-ref-op/raw-ref-temp.rs index 10e47cb34c58..70f67602af2f 100644 --- a/tests/ui/raw-ref-op/raw-ref-temp.rs +++ b/tests/ui/raw-ref-op/raw-ref-temp.rs @@ -1,5 +1,5 @@ // Ensure that we don't allow taking the address of temporary values -#![feature(raw_ref_op, type_ascription)] +#![feature(type_ascription)] const FOUR: u64 = 4; diff --git a/tests/ui/raw-ref-op/unusual_locations.rs b/tests/ui/raw-ref-op/unusual_locations.rs index badf529cb45a..eb40fa8a7ee8 100644 --- a/tests/ui/raw-ref-op/unusual_locations.rs +++ b/tests/ui/raw-ref-op/unusual_locations.rs @@ -1,7 +1,5 @@ //@ check-pass -#![feature(raw_ref_op)] - const USES_PTR: () = { let u = (); &raw const u; }; static ALSO_USES_PTR: () = { let u = (); &raw const u; }; diff --git a/tests/ui/sanitizer/thread.rs b/tests/ui/sanitizer/thread.rs index 9d9ad6ee5186..566774d6b1d6 100644 --- a/tests/ui/sanitizer/thread.rs +++ b/tests/ui/sanitizer/thread.rs @@ -20,7 +20,6 @@ //@ error-pattern: Location is heap block of size 4 //@ error-pattern: allocated by main thread -#![feature(raw_ref_op)] #![feature(rustc_private)] extern crate libc; diff --git a/tests/ui/static/raw-ref-extern-static.rs b/tests/ui/static/raw-ref-extern-static.rs index 95a53a8640d3..81bc5990efe1 100644 --- a/tests/ui/static/raw-ref-extern-static.rs +++ b/tests/ui/static/raw-ref-extern-static.rs @@ -1,5 +1,4 @@ //@ check-pass -#![feature(raw_ref_op)] use std::ptr; // see https://github.com/rust-lang/rust/issues/125833 diff --git a/tests/ui/static/raw-ref-static-mut.rs b/tests/ui/static/raw-ref-static-mut.rs index 6855cc7b050b..d4159fc65caa 100644 --- a/tests/ui/static/raw-ref-static-mut.rs +++ b/tests/ui/static/raw-ref-static-mut.rs @@ -1,5 +1,4 @@ //@ check-pass -#![feature(raw_ref_op)] use std::ptr; // see https://github.com/rust-lang/rust/issues/125833 diff --git a/tests/ui/unpretty/expanded-exhaustive.rs b/tests/ui/unpretty/expanded-exhaustive.rs index 29472df897a1..279d723a26c5 100644 --- a/tests/ui/unpretty/expanded-exhaustive.rs +++ b/tests/ui/unpretty/expanded-exhaustive.rs @@ -19,7 +19,6 @@ #![feature(never_type)] #![feature(pattern_types)] #![feature(prelude_import)] -#![feature(raw_ref_op)] #![feature(specialization)] #![feature(trace_macros)] #![feature(trait_alias)] diff --git a/tests/ui/unpretty/expanded-exhaustive.stdout b/tests/ui/unpretty/expanded-exhaustive.stdout index cf2f6f8cbaa9..149659693ae6 100644 --- a/tests/ui/unpretty/expanded-exhaustive.stdout +++ b/tests/ui/unpretty/expanded-exhaustive.stdout @@ -20,7 +20,6 @@ #![feature(never_type)] #![feature(pattern_types)] #![feature(prelude_import)] -#![feature(raw_ref_op)] #![feature(specialization)] #![feature(trace_macros)] #![feature(trait_alias)] From b8464961a2681585a6231b93cd7e85e50022c2b3 Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Sat, 13 Jul 2024 13:56:05 +0200 Subject: [PATCH 55/79] soft-deprecate the addr_of macros --- library/core/src/ptr/mod.rs | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/library/core/src/ptr/mod.rs b/library/core/src/ptr/mod.rs index 25d8f4a0adbd..3fe5212cea77 100644 --- a/library/core/src/ptr/mod.rs +++ b/library/core/src/ptr/mod.rs @@ -2209,6 +2209,9 @@ impl fmt::Debug for F { /// Creates a `const` raw pointer to a place, without creating an intermediate reference. /// +/// `addr_of!(expr)` is equivalent to `&raw const expr`. The macro is *soft-deprecated*; +/// use `&raw const` instead. +/// /// Creating a reference with `&`/`&mut` is only allowed if the pointer is properly aligned /// and points to initialized data. For cases where those requirements do not hold, /// raw pointers should be used instead. However, `&expr as *const _` creates a reference @@ -2283,6 +2286,9 @@ pub macro addr_of($place:expr) { /// Creates a `mut` raw pointer to a place, without creating an intermediate reference. /// +/// `addr_of_mut!(expr)` is equivalent to `&raw mut expr`. The macro is *soft-deprecated*; +/// use `&raw mut` instead. +/// /// Creating a reference with `&`/`&mut` is only allowed if the pointer is properly aligned /// and points to initialized data. For cases where those requirements do not hold, /// raw pointers should be used instead. However, `&mut expr as *mut _` creates a reference From 35709be02d43b40e7f720408f8a88bf6e9d5501d Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Mon, 12 Aug 2024 10:57:57 +0200 Subject: [PATCH 56/79] rename AddressOf -> RawBorrow inside the compiler --- compiler/rustc_borrowck/src/def_use.rs | 4 ++-- compiler/rustc_borrowck/src/lib.rs | 2 +- .../src/polonius/loan_invalidations.rs | 2 +- compiler/rustc_borrowck/src/type_check/mod.rs | 6 +++--- .../rustc_codegen_cranelift/src/analyze.rs | 2 +- compiler/rustc_codegen_cranelift/src/base.rs | 2 +- compiler/rustc_codegen_ssa/src/mir/analyze.rs | 4 ++-- compiler/rustc_codegen_ssa/src/mir/rvalue.rs | 6 +++--- .../rustc_const_eval/src/check_consts/check.rs | 10 +++++----- .../src/check_consts/qualifs.rs | 2 +- .../src/check_consts/resolver.rs | 4 ++-- .../rustc_const_eval/src/interpret/step.rs | 2 +- compiler/rustc_hir_typeck/src/cast.rs | 2 +- compiler/rustc_middle/src/mir/pretty.rs | 2 +- compiler/rustc_middle/src/mir/statement.rs | 2 +- compiler/rustc_middle/src/mir/syntax.rs | 8 ++++---- compiler/rustc_middle/src/mir/tcx.rs | 2 +- compiler/rustc_middle/src/mir/visit.rs | 18 +++++++++--------- compiler/rustc_middle/src/thir.rs | 2 +- compiler/rustc_middle/src/thir/visit.rs | 2 +- .../src/build/custom/parse/instruction.rs | 4 ++-- .../rustc_mir_build/src/build/expr/as_place.rs | 2 +- .../src/build/expr/as_rvalue.rs | 2 +- .../rustc_mir_build/src/build/expr/category.rs | 2 +- .../rustc_mir_build/src/build/expr/into.rs | 4 ++-- compiler/rustc_mir_build/src/check_unsafety.rs | 4 ++-- compiler/rustc_mir_build/src/thir/cx/expr.rs | 4 ++-- .../src/thir/pattern/check_match.rs | 2 +- compiler/rustc_mir_build/src/thir/print.rs | 4 ++-- .../rustc_mir_dataflow/src/elaborate_drops.rs | 2 +- .../src/impls/borrowed_locals.rs | 2 +- .../src/impls/initialized.rs | 2 +- .../rustc_mir_dataflow/src/impls/liveness.rs | 4 ++-- .../src/move_paths/builder.rs | 2 +- .../rustc_mir_dataflow/src/value_analysis.rs | 2 +- compiler/rustc_mir_transform/src/add_retag.rs | 4 ++-- .../rustc_mir_transform/src/check_alignment.rs | 2 +- .../src/deduce_param_attrs.rs | 2 +- compiler/rustc_mir_transform/src/dest_prop.rs | 2 +- compiler/rustc_mir_transform/src/gvn.rs | 4 ++-- .../rustc_mir_transform/src/instsimplify.rs | 2 +- .../src/known_panics_lint.rs | 10 +++++----- .../rustc_mir_transform/src/large_enums.rs | 4 ++-- .../rustc_mir_transform/src/promote_consts.rs | 2 +- compiler/rustc_mir_transform/src/ref_prop.rs | 2 +- .../src/shim/async_destructor_ctor.rs | 4 ++-- compiler/rustc_mir_transform/src/ssa.rs | 8 ++++---- compiler/rustc_mir_transform/src/validate.rs | 2 +- .../rustc_smir/src/rustc_smir/convert/mir.rs | 2 +- compiler/rustc_ty_utils/src/consts.rs | 6 +++--- .../clippy_utils/src/qualify_min_const_fn.rs | 2 +- 51 files changed, 92 insertions(+), 92 deletions(-) diff --git a/compiler/rustc_borrowck/src/def_use.rs b/compiler/rustc_borrowck/src/def_use.rs index 1f0b0981c8f2..e07d7dd309ae 100644 --- a/compiler/rustc_borrowck/src/def_use.rs +++ b/compiler/rustc_borrowck/src/def_use.rs @@ -55,8 +55,8 @@ pub fn categorize(context: PlaceContext) -> Option { PlaceContext::NonMutatingUse(NonMutatingUseContext::PlaceMention) | PlaceContext::NonUse(NonUseContext::AscribeUserTy(_)) | - PlaceContext::MutatingUse(MutatingUseContext::AddressOf) | - PlaceContext::NonMutatingUse(NonMutatingUseContext::AddressOf) | + PlaceContext::MutatingUse(MutatingUseContext::RawBorrow) | + PlaceContext::NonMutatingUse(NonMutatingUseContext::RawBorrow) | PlaceContext::NonMutatingUse(NonMutatingUseContext::Inspect) | PlaceContext::NonMutatingUse(NonMutatingUseContext::Copy) | PlaceContext::NonMutatingUse(NonMutatingUseContext::Move) | diff --git a/compiler/rustc_borrowck/src/lib.rs b/compiler/rustc_borrowck/src/lib.rs index 30dd45d847c9..a529df76bcbc 100644 --- a/compiler/rustc_borrowck/src/lib.rs +++ b/compiler/rustc_borrowck/src/lib.rs @@ -1242,7 +1242,7 @@ impl<'mir, 'tcx> MirBorrowckCtxt<'_, 'mir, '_, 'tcx> { ); } - &Rvalue::AddressOf(mutability, place) => { + &Rvalue::RawPtr(mutability, place) => { let access_kind = match mutability { Mutability::Mut => ( Deep, diff --git a/compiler/rustc_borrowck/src/polonius/loan_invalidations.rs b/compiler/rustc_borrowck/src/polonius/loan_invalidations.rs index f090da031a04..a57041cd04c5 100644 --- a/compiler/rustc_borrowck/src/polonius/loan_invalidations.rs +++ b/compiler/rustc_borrowck/src/polonius/loan_invalidations.rs @@ -269,7 +269,7 @@ impl<'cx, 'tcx> LoanInvalidationsGenerator<'cx, 'tcx> { self.access_place(location, place, access_kind, LocalMutationIsAllowed::No); } - &Rvalue::AddressOf(mutability, place) => { + &Rvalue::RawPtr(mutability, place) => { let access_kind = match mutability { Mutability::Mut => ( Deep, diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs index a2669da1b04e..6983cda6ddf3 100644 --- a/compiler/rustc_borrowck/src/type_check/mod.rs +++ b/compiler/rustc_borrowck/src/type_check/mod.rs @@ -756,7 +756,7 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> { PlaceContext::MutatingUse(_) => ty::Invariant, PlaceContext::NonUse(StorageDead | StorageLive | VarDebugInfo) => ty::Invariant, PlaceContext::NonMutatingUse( - Inspect | Copy | Move | PlaceMention | SharedBorrow | FakeBorrow | AddressOf + Inspect | Copy | Move | PlaceMention | SharedBorrow | FakeBorrow | RawBorrow | Projection, ) => ty::Covariant, PlaceContext::NonUse(AscribeUserTy(variance)) => variance, @@ -2468,7 +2468,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> { self.check_operand(right, location); } - Rvalue::AddressOf(..) + Rvalue::RawPtr(..) | Rvalue::ThreadLocalRef(..) | Rvalue::Len(..) | Rvalue::Discriminant(..) @@ -2485,7 +2485,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> { | Rvalue::ThreadLocalRef(_) | Rvalue::Repeat(..) | Rvalue::Ref(..) - | Rvalue::AddressOf(..) + | Rvalue::RawPtr(..) | Rvalue::Len(..) | Rvalue::Cast(..) | Rvalue::ShallowInitBox(..) diff --git a/compiler/rustc_codegen_cranelift/src/analyze.rs b/compiler/rustc_codegen_cranelift/src/analyze.rs index c5762638a6b1..72380f50385a 100644 --- a/compiler/rustc_codegen_cranelift/src/analyze.rs +++ b/compiler/rustc_codegen_cranelift/src/analyze.rs @@ -25,7 +25,7 @@ pub(crate) fn analyze(fx: &FunctionCx<'_, '_, '_>) -> IndexVec { for stmt in bb.statements.iter() { match &stmt.kind { Assign(place_and_rval) => match &place_and_rval.1 { - Rvalue::Ref(_, _, place) | Rvalue::AddressOf(_, place) => { + Rvalue::Ref(_, _, place) | Rvalue::RawPtr(_, place) => { flag_map[place.local] = SsaKind::NotSsa; } _ => {} diff --git a/compiler/rustc_codegen_cranelift/src/base.rs b/compiler/rustc_codegen_cranelift/src/base.rs index 9bc7b57c5374..f1d885bf1bce 100644 --- a/compiler/rustc_codegen_cranelift/src/base.rs +++ b/compiler/rustc_codegen_cranelift/src/base.rs @@ -595,7 +595,7 @@ fn codegen_stmt<'tcx>( let val = cplace.to_cvalue(fx); lval.write_cvalue(fx, val) } - Rvalue::Ref(_, _, place) | Rvalue::AddressOf(_, place) => { + Rvalue::Ref(_, _, place) | Rvalue::RawPtr(_, place) => { let place = codegen_place(fx, place); let ref_ = place.place_ref(fx, lval.layout()); lval.write_cvalue(fx, ref_); diff --git a/compiler/rustc_codegen_ssa/src/mir/analyze.rs b/compiler/rustc_codegen_ssa/src/mir/analyze.rs index 6794365c9bee..c8cf341628c3 100644 --- a/compiler/rustc_codegen_ssa/src/mir/analyze.rs +++ b/compiler/rustc_codegen_ssa/src/mir/analyze.rs @@ -220,14 +220,14 @@ impl<'mir, 'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> Visitor<'tcx> | MutatingUseContext::SetDiscriminant | MutatingUseContext::AsmOutput | MutatingUseContext::Borrow - | MutatingUseContext::AddressOf + | MutatingUseContext::RawBorrow | MutatingUseContext::Projection, ) | PlaceContext::NonMutatingUse( NonMutatingUseContext::Inspect | NonMutatingUseContext::SharedBorrow | NonMutatingUseContext::FakeBorrow - | NonMutatingUseContext::AddressOf + | NonMutatingUseContext::RawBorrow | NonMutatingUseContext::Projection, ) => { self.locals[local] = LocalKind::Memory; diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs index 3c2c29ac7f7d..d94c6f8ddcec 100644 --- a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs +++ b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs @@ -584,7 +584,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> { mir::Rvalue::CopyForDeref(place) => { self.codegen_operand(bx, &mir::Operand::Copy(place)) } - mir::Rvalue::AddressOf(mutability, place) => { + mir::Rvalue::RawPtr(mutability, place) => { let mk_ptr = move |tcx: TyCtxt<'tcx>, ty: Ty<'tcx>| Ty::new_ptr(tcx, ty, mutability); self.codegen_place_to_pointer(bx, place, mk_ptr) @@ -813,7 +813,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> { cg_value.len(bx.cx()) } - /// Codegen an `Rvalue::AddressOf` or `Rvalue::Ref` + /// Codegen an `Rvalue::RawPtr` or `Rvalue::Ref` fn codegen_place_to_pointer( &mut self, bx: &mut Bx, @@ -1085,7 +1085,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> { } mir::Rvalue::Ref(..) | mir::Rvalue::CopyForDeref(..) | - mir::Rvalue::AddressOf(..) | + mir::Rvalue::RawPtr(..) | mir::Rvalue::Len(..) | mir::Rvalue::Cast(..) | // (*) mir::Rvalue::ShallowInitBox(..) | // (*) diff --git a/compiler/rustc_const_eval/src/check_consts/check.rs b/compiler/rustc_const_eval/src/check_consts/check.rs index 32a9247bcc70..86a5afa65ba8 100644 --- a/compiler/rustc_const_eval/src/check_consts/check.rs +++ b/compiler/rustc_const_eval/src/check_consts/check.rs @@ -431,13 +431,13 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> { return; } } - Rvalue::AddressOf(mutbl, place) => { + Rvalue::RawPtr(mutbl, place) => { if let Some(reborrowed_place_ref) = place_as_reborrow(self.tcx, self.body, place) { let ctx = match mutbl { Mutability::Not => { - PlaceContext::NonMutatingUse(NonMutatingUseContext::AddressOf) + PlaceContext::NonMutatingUse(NonMutatingUseContext::RawBorrow) } - Mutability::Mut => PlaceContext::MutatingUse(MutatingUseContext::AddressOf), + Mutability::Mut => PlaceContext::MutatingUse(MutatingUseContext::RawBorrow), }; self.visit_local(reborrowed_place_ref.local, ctx, location); self.visit_projection(reborrowed_place_ref, ctx, location); @@ -472,7 +472,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> { } Rvalue::Ref(_, BorrowKind::Mut { .. }, place) - | Rvalue::AddressOf(Mutability::Mut, place) => { + | Rvalue::RawPtr(Mutability::Mut, place) => { // Inside mutable statics, we allow arbitrary mutable references. // We've allowed `static mut FOO = &mut [elements];` for a long time (the exact // reasons why are lost to history), and there is no reason to restrict that to @@ -493,7 +493,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> { } Rvalue::Ref(_, BorrowKind::Shared | BorrowKind::Fake(_), place) - | Rvalue::AddressOf(Mutability::Not, place) => { + | Rvalue::RawPtr(Mutability::Not, place) => { let borrowed_place_has_mut_interior = qualifs::in_place::( self.ccx, &mut |local| self.qualifs.has_mut_interior(self.ccx, local, location), diff --git a/compiler/rustc_const_eval/src/check_consts/qualifs.rs b/compiler/rustc_const_eval/src/check_consts/qualifs.rs index c0f2d113c7e3..c566dc7fa844 100644 --- a/compiler/rustc_const_eval/src/check_consts/qualifs.rs +++ b/compiler/rustc_const_eval/src/check_consts/qualifs.rs @@ -291,7 +291,7 @@ where in_operand::(cx, in_local, lhs) || in_operand::(cx, in_local, rhs) } - Rvalue::Ref(_, _, place) | Rvalue::AddressOf(_, place) => { + Rvalue::Ref(_, _, place) | Rvalue::RawPtr(_, place) => { // Special-case reborrows to be more like a copy of the reference. if let Some((place_base, ProjectionElem::Deref)) = place.as_ref().last_projection() { let base_ty = place_base.ty(cx.body, cx.tcx).ty; diff --git a/compiler/rustc_const_eval/src/check_consts/resolver.rs b/compiler/rustc_const_eval/src/check_consts/resolver.rs index ea3a5264357c..681184f7fbcd 100644 --- a/compiler/rustc_const_eval/src/check_consts/resolver.rs +++ b/compiler/rustc_const_eval/src/check_consts/resolver.rs @@ -96,7 +96,7 @@ where } fn address_of_allows_mutation(&self) -> bool { - // Exact set of permissions granted by AddressOf is undecided. Conservatively assume that + // Exact set of permissions granted by RawPtr is undecided. Conservatively assume that // it might allow mutation until resolution of #56604. true } @@ -170,7 +170,7 @@ where self.super_rvalue(rvalue, location); match rvalue { - mir::Rvalue::AddressOf(_mt, borrowed_place) => { + mir::Rvalue::RawPtr(_mt, borrowed_place) => { if !borrowed_place.is_indirect() && self.address_of_allows_mutation() { let place_ty = borrowed_place.ty(self.ccx.body, self.ccx.tcx).ty; if Q::in_any_value_of_ty(self.ccx, place_ty) { diff --git a/compiler/rustc_const_eval/src/interpret/step.rs b/compiler/rustc_const_eval/src/interpret/step.rs index aaee6f6d247f..70cfba1922c6 100644 --- a/compiler/rustc_const_eval/src/interpret/step.rs +++ b/compiler/rustc_const_eval/src/interpret/step.rs @@ -234,7 +234,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> { self.write_immediate(*val, &dest)?; } - AddressOf(_, place) => { + RawPtr(_, place) => { // Figure out whether this is an addr_of of an already raw place. let place_base_raw = if place.is_indirect_first_projection() { let ty = self.frame().body.local_decls[place.local].ty; diff --git a/compiler/rustc_hir_typeck/src/cast.rs b/compiler/rustc_hir_typeck/src/cast.rs index 7cd97166ed1e..03a76d44cc98 100644 --- a/compiler/rustc_hir_typeck/src/cast.rs +++ b/compiler/rustc_hir_typeck/src/cast.rs @@ -967,7 +967,7 @@ impl<'a, 'tcx> CastCheck<'tcx> { // need to special-case obtaining a raw pointer // from a region pointer to a vector. - // Coerce to a raw pointer so that we generate AddressOf in MIR. + // Coerce to a raw pointer so that we generate RawPtr in MIR. let array_ptr_type = Ty::new_ptr(fcx.tcx, m_expr.ty, m_expr.mutbl); fcx.coerce(self.expr, self.expr_ty, array_ptr_type, AllowTwoPhase::No, None) .unwrap_or_else(|_| { diff --git a/compiler/rustc_middle/src/mir/pretty.rs b/compiler/rustc_middle/src/mir/pretty.rs index 5dd0e69cf1fe..212eda666ca0 100644 --- a/compiler/rustc_middle/src/mir/pretty.rs +++ b/compiler/rustc_middle/src/mir/pretty.rs @@ -1038,7 +1038,7 @@ impl<'tcx> Debug for Rvalue<'tcx> { CopyForDeref(ref place) => write!(fmt, "deref_copy {place:#?}"), - AddressOf(mutability, ref place) => { + RawPtr(mutability, ref place) => { write!(fmt, "&raw {mut_str} {place:?}", mut_str = mutability.ptr_str()) } diff --git a/compiler/rustc_middle/src/mir/statement.rs b/compiler/rustc_middle/src/mir/statement.rs index 3009ca8d8097..bc7dfa6205e7 100644 --- a/compiler/rustc_middle/src/mir/statement.rs +++ b/compiler/rustc_middle/src/mir/statement.rs @@ -423,7 +423,7 @@ impl<'tcx> Rvalue<'tcx> { | Rvalue::Repeat(_, _) | Rvalue::Ref(_, _, _) | Rvalue::ThreadLocalRef(_) - | Rvalue::AddressOf(_, _) + | Rvalue::RawPtr(_, _) | Rvalue::Len(_) | Rvalue::Cast( CastKind::IntToInt diff --git a/compiler/rustc_middle/src/mir/syntax.rs b/compiler/rustc_middle/src/mir/syntax.rs index 1119ff6ff3d6..51b4154ddab7 100644 --- a/compiler/rustc_middle/src/mir/syntax.rs +++ b/compiler/rustc_middle/src/mir/syntax.rs @@ -1293,14 +1293,14 @@ pub enum Rvalue<'tcx> { /// nature of this operation? ThreadLocalRef(DefId), - /// Creates a pointer with the indicated mutability to the place. + /// Creates a raw pointer with the indicated mutability to the place. /// - /// This is generated by pointer casts like `&v as *const _` or raw address of expressions like - /// `&raw v` or `addr_of!(v)`. + /// This is generated by pointer casts like `&v as *const _` or raw borrow expressions like + /// `&raw const v`. /// /// Like with references, the semantics of this operation are heavily dependent on the aliasing /// model. - AddressOf(Mutability, Place<'tcx>), + RawPtr(Mutability, Place<'tcx>), /// Yields the length of the place, as a `usize`. /// diff --git a/compiler/rustc_middle/src/mir/tcx.rs b/compiler/rustc_middle/src/mir/tcx.rs index 1075344dc00f..8d57d0d86546 100644 --- a/compiler/rustc_middle/src/mir/tcx.rs +++ b/compiler/rustc_middle/src/mir/tcx.rs @@ -170,7 +170,7 @@ impl<'tcx> Rvalue<'tcx> { let place_ty = place.ty(local_decls, tcx).ty; Ty::new_ref(tcx, reg, place_ty, bk.to_mutbl_lossy()) } - Rvalue::AddressOf(mutability, ref place) => { + Rvalue::RawPtr(mutability, ref place) => { let place_ty = place.ty(local_decls, tcx).ty; Ty::new_ptr(tcx, place_ty, mutability) } diff --git a/compiler/rustc_middle/src/mir/visit.rs b/compiler/rustc_middle/src/mir/visit.rs index 3921176873c8..bfb129495ce8 100644 --- a/compiler/rustc_middle/src/mir/visit.rs +++ b/compiler/rustc_middle/src/mir/visit.rs @@ -682,13 +682,13 @@ macro_rules! make_mir_visitor { ); } - Rvalue::AddressOf(m, path) => { + Rvalue::RawPtr(m, path) => { let ctx = match m { Mutability::Mut => PlaceContext::MutatingUse( - MutatingUseContext::AddressOf + MutatingUseContext::RawBorrow ), Mutability::Not => PlaceContext::NonMutatingUse( - NonMutatingUseContext::AddressOf + NonMutatingUseContext::RawBorrow ), }; self.visit_place(path, ctx, location); @@ -1299,8 +1299,8 @@ pub enum NonMutatingUseContext { /// FIXME: do we need to distinguish shallow and deep fake borrows? In fact, do we need to /// distinguish fake and normal deep borrows? FakeBorrow, - /// AddressOf for *const pointer. - AddressOf, + /// `&raw const`. + RawBorrow, /// PlaceMention statement. /// /// This statement is executed as a check that the `Place` is live without reading from it, @@ -1333,8 +1333,8 @@ pub enum MutatingUseContext { Drop, /// Mutable borrow. Borrow, - /// AddressOf for *mut pointer. - AddressOf, + /// `&raw mut`. + RawBorrow, /// Used as base for another place, e.g., `x` in `x.y`. Could potentially mutate the place. /// For example, the projection `x.y` is marked as a mutation in these cases: /// ```ignore (illustrative) @@ -1386,8 +1386,8 @@ impl PlaceContext { pub fn is_address_of(&self) -> bool { matches!( self, - PlaceContext::NonMutatingUse(NonMutatingUseContext::AddressOf) - | PlaceContext::MutatingUse(MutatingUseContext::AddressOf) + PlaceContext::NonMutatingUse(NonMutatingUseContext::RawBorrow) + | PlaceContext::MutatingUse(MutatingUseContext::RawBorrow) ) } diff --git a/compiler/rustc_middle/src/thir.rs b/compiler/rustc_middle/src/thir.rs index f2ea32275f9b..aca1390935ef 100644 --- a/compiler/rustc_middle/src/thir.rs +++ b/compiler/rustc_middle/src/thir.rs @@ -407,7 +407,7 @@ pub enum ExprKind<'tcx> { arg: ExprId, }, /// A `&raw [const|mut] $place_expr` raw borrow resulting in type `*[const|mut] T`. - AddressOf { + RawBorrow { mutability: hir::Mutability, arg: ExprId, }, diff --git a/compiler/rustc_middle/src/thir/visit.rs b/compiler/rustc_middle/src/thir/visit.rs index f19888104373..e246ecebbec0 100644 --- a/compiler/rustc_middle/src/thir/visit.rs +++ b/compiler/rustc_middle/src/thir/visit.rs @@ -92,7 +92,7 @@ pub fn walk_expr<'thir, 'tcx: 'thir, V: Visitor<'thir, 'tcx>>( } VarRef { id: _ } | UpvarRef { closure_def_id: _, var_hir_id: _ } => {} Borrow { arg, borrow_kind: _ } => visitor.visit_expr(&visitor.thir()[arg]), - AddressOf { arg, mutability: _ } => visitor.visit_expr(&visitor.thir()[arg]), + RawBorrow { arg, mutability: _ } => visitor.visit_expr(&visitor.thir()[arg]), Break { value, label: _ } => { if let Some(value) = value { visitor.visit_expr(&visitor.thir()[value]) diff --git a/compiler/rustc_mir_build/src/build/custom/parse/instruction.rs b/compiler/rustc_mir_build/src/build/custom/parse/instruction.rs index 56896d945e5f..0b13ceb574d0 100644 --- a/compiler/rustc_mir_build/src/build/custom/parse/instruction.rs +++ b/compiler/rustc_mir_build/src/build/custom/parse/instruction.rs @@ -244,8 +244,8 @@ impl<'tcx, 'body> ParseCtxt<'tcx, 'body> { ExprKind::Borrow { borrow_kind, arg } => Ok( Rvalue::Ref(self.tcx.lifetimes.re_erased, *borrow_kind, self.parse_place(*arg)?) ), - ExprKind::AddressOf { mutability, arg } => Ok( - Rvalue::AddressOf(*mutability, self.parse_place(*arg)?) + ExprKind::RawBorrow { mutability, arg } => Ok( + Rvalue::RawPtr(*mutability, self.parse_place(*arg)?) ), ExprKind::Binary { op, lhs, rhs } => Ok( Rvalue::BinaryOp(*op, Box::new((self.parse_operand(*lhs)?, self.parse_operand(*rhs)?))) diff --git a/compiler/rustc_mir_build/src/build/expr/as_place.rs b/compiler/rustc_mir_build/src/build/expr/as_place.rs index b80d9de70c8d..07784982631f 100644 --- a/compiler/rustc_mir_build/src/build/expr/as_place.rs +++ b/compiler/rustc_mir_build/src/build/expr/as_place.rs @@ -542,7 +542,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { | ExprKind::PointerCoercion { .. } | ExprKind::Repeat { .. } | ExprKind::Borrow { .. } - | ExprKind::AddressOf { .. } + | ExprKind::RawBorrow { .. } | ExprKind::Match { .. } | ExprKind::If { .. } | ExprKind::Loop { .. } diff --git a/compiler/rustc_mir_build/src/build/expr/as_rvalue.rs b/compiler/rustc_mir_build/src/build/expr/as_rvalue.rs index 379d2140c09c..0c9571da3cf7 100644 --- a/compiler/rustc_mir_build/src/build/expr/as_rvalue.rs +++ b/compiler/rustc_mir_build/src/build/expr/as_rvalue.rs @@ -512,7 +512,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { | ExprKind::NeverToAny { .. } | ExprKind::Use { .. } | ExprKind::Borrow { .. } - | ExprKind::AddressOf { .. } + | ExprKind::RawBorrow { .. } | ExprKind::Adt { .. } | ExprKind::Loop { .. } | ExprKind::LogicalOp { .. } diff --git a/compiler/rustc_mir_build/src/build/expr/category.rs b/compiler/rustc_mir_build/src/build/expr/category.rs index e07ba6b6e938..e0349e3e3f66 100644 --- a/compiler/rustc_mir_build/src/build/expr/category.rs +++ b/compiler/rustc_mir_build/src/build/expr/category.rs @@ -51,7 +51,7 @@ impl Category { | ExprKind::Use { .. } | ExprKind::Adt { .. } | ExprKind::Borrow { .. } - | ExprKind::AddressOf { .. } + | ExprKind::RawBorrow { .. } | ExprKind::Yield { .. } | ExprKind::Call { .. } | ExprKind::InlineAsm { .. } => Some(Category::Rvalue(RvalueFunc::Into)), diff --git a/compiler/rustc_mir_build/src/build/expr/into.rs b/compiler/rustc_mir_build/src/build/expr/into.rs index 01b32b8e05e4..1c805ed20cc3 100644 --- a/compiler/rustc_mir_build/src/build/expr/into.rs +++ b/compiler/rustc_mir_build/src/build/expr/into.rs @@ -303,12 +303,12 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { this.cfg.push_assign(block, source_info, destination, borrow); block.unit() } - ExprKind::AddressOf { mutability, arg } => { + ExprKind::RawBorrow { mutability, arg } => { let place = match mutability { hir::Mutability::Not => this.as_read_only_place(block, arg), hir::Mutability::Mut => this.as_place(block, arg), }; - let address_of = Rvalue::AddressOf(mutability, unpack!(block = place)); + let address_of = Rvalue::RawPtr(mutability, unpack!(block = place)); this.cfg.push_assign(block, source_info, destination, address_of); block.unit() } diff --git a/compiler/rustc_mir_build/src/check_unsafety.rs b/compiler/rustc_mir_build/src/check_unsafety.rs index 9b85ad0ad089..e4e5844d2ef8 100644 --- a/compiler/rustc_mir_build/src/check_unsafety.rs +++ b/compiler/rustc_mir_build/src/check_unsafety.rs @@ -397,7 +397,7 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> { | ExprKind::Scope { .. } | ExprKind::Cast { .. } => {} - ExprKind::AddressOf { .. } + ExprKind::RawBorrow { .. } | ExprKind::Adt { .. } | ExprKind::Array { .. } | ExprKind::Binary { .. } @@ -498,7 +498,7 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> { } } } - ExprKind::AddressOf { arg, .. } => { + ExprKind::RawBorrow { arg, .. } => { if let ExprKind::Scope { value: arg, .. } = self.thir[arg].kind // THIR desugars UNSAFE_STATIC into *UNSAFE_STATIC_REF, where // UNSAFE_STATIC_REF holds the addr of the UNSAFE_STATIC, so: take two steps diff --git a/compiler/rustc_mir_build/src/thir/cx/expr.rs b/compiler/rustc_mir_build/src/thir/cx/expr.rs index d4de5fac96eb..2cbaed2cc625 100644 --- a/compiler/rustc_mir_build/src/thir/cx/expr.rs +++ b/compiler/rustc_mir_build/src/thir/cx/expr.rs @@ -143,7 +143,7 @@ impl<'tcx> Cx<'tcx> { arg: self.thir.exprs.push(expr), }, Adjust::Borrow(AutoBorrow::RawPtr(mutability)) => { - ExprKind::AddressOf { mutability, arg: self.thir.exprs.push(expr) } + ExprKind::RawBorrow { mutability, arg: self.thir.exprs.push(expr) } } Adjust::DynStar => ExprKind::Cast { source: self.thir.exprs.push(expr) }, }; @@ -396,7 +396,7 @@ impl<'tcx> Cx<'tcx> { } hir::ExprKind::AddrOf(hir::BorrowKind::Raw, mutability, arg) => { - ExprKind::AddressOf { mutability, arg: self.mirror_expr(arg) } + ExprKind::RawBorrow { mutability, arg: self.mirror_expr(arg) } } hir::ExprKind::Block(blk, _) => ExprKind::Block { block: self.mirror_block(blk) }, diff --git a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs index 85b9dacb1293..bc1acd51c691 100644 --- a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs +++ b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs @@ -325,7 +325,7 @@ impl<'p, 'tcx> MatchVisitor<'p, 'tcx> { Assign { .. } | AssignOp { .. } | InlineAsm { .. } | Let { .. } => true, // These evaluate to a value. - AddressOf { .. } + RawBorrow { .. } | Adt { .. } | Array { .. } | Binary { .. } diff --git a/compiler/rustc_mir_build/src/thir/print.rs b/compiler/rustc_mir_build/src/thir/print.rs index 2d4b39e7b08f..ce7774f59488 100644 --- a/compiler/rustc_mir_build/src/thir/print.rs +++ b/compiler/rustc_mir_build/src/thir/print.rs @@ -379,8 +379,8 @@ impl<'a, 'tcx> ThirPrinter<'a, 'tcx> { self.print_expr(*arg, depth_lvl + 2); print_indented!(self, ")", depth_lvl); } - AddressOf { mutability, arg } => { - print_indented!(self, "AddressOf {", depth_lvl); + RawBorrow { mutability, arg } => { + print_indented!(self, "RawBorrow {", depth_lvl); print_indented!(self, format!("mutability: {:?}", mutability), depth_lvl + 1); print_indented!(self, "arg:", depth_lvl + 1); self.print_expr(*arg, depth_lvl + 2); diff --git a/compiler/rustc_mir_dataflow/src/elaborate_drops.rs b/compiler/rustc_mir_dataflow/src/elaborate_drops.rs index 2ec3b53bc981..d7e738b8829e 100644 --- a/compiler/rustc_mir_dataflow/src/elaborate_drops.rs +++ b/compiler/rustc_mir_dataflow/src/elaborate_drops.rs @@ -703,7 +703,7 @@ where statements: vec![ self.assign( ptr, - Rvalue::AddressOf(Mutability::Mut, tcx.mk_place_index(self.place, cur)), + Rvalue::RawPtr(Mutability::Mut, tcx.mk_place_index(self.place, cur)), ), self.assign( cur.into(), diff --git a/compiler/rustc_mir_dataflow/src/impls/borrowed_locals.rs b/compiler/rustc_mir_dataflow/src/impls/borrowed_locals.rs index 885fdd0d58be..e8e78fb8a89e 100644 --- a/compiler/rustc_mir_dataflow/src/impls/borrowed_locals.rs +++ b/compiler/rustc_mir_dataflow/src/impls/borrowed_locals.rs @@ -94,7 +94,7 @@ where match rvalue { // We ignore fake borrows as these get removed after analysis and shouldn't effect // the layout of generators. - Rvalue::AddressOf(_, borrowed_place) + Rvalue::RawPtr(_, borrowed_place) | Rvalue::Ref(_, BorrowKind::Mut { .. } | BorrowKind::Shared, borrowed_place) => { if !borrowed_place.is_indirect() { self.trans.gen_(borrowed_place.local); diff --git a/compiler/rustc_mir_dataflow/src/impls/initialized.rs b/compiler/rustc_mir_dataflow/src/impls/initialized.rs index 7822fb17f729..ddfd0739358d 100644 --- a/compiler/rustc_mir_dataflow/src/impls/initialized.rs +++ b/compiler/rustc_mir_dataflow/src/impls/initialized.rs @@ -351,7 +351,7 @@ impl<'tcx> GenKillAnalysis<'tcx> for MaybeInitializedPlaces<'_, '_, 'tcx> { && let Some((_, rvalue)) = statement.kind.as_assign() && let mir::Rvalue::Ref(_, mir::BorrowKind::Mut { .. }, place) // FIXME: Does `&raw const foo` allow mutation? See #90413. - | mir::Rvalue::AddressOf(_, place) = rvalue + | mir::Rvalue::RawPtr(_, place) = rvalue && let LookupResult::Exact(mpi) = self.move_data().rev_lookup.find(place.as_ref()) { on_all_children_bits(self.move_data(), mpi, |child| { diff --git a/compiler/rustc_mir_dataflow/src/impls/liveness.rs b/compiler/rustc_mir_dataflow/src/impls/liveness.rs index 48bdb1316012..24a4b32ceb7c 100644 --- a/compiler/rustc_mir_dataflow/src/impls/liveness.rs +++ b/compiler/rustc_mir_dataflow/src/impls/liveness.rs @@ -189,13 +189,13 @@ impl DefUse { // All other contexts are uses... PlaceContext::MutatingUse( - MutatingUseContext::AddressOf + MutatingUseContext::RawBorrow | MutatingUseContext::Borrow | MutatingUseContext::Drop | MutatingUseContext::Retag, ) | PlaceContext::NonMutatingUse( - NonMutatingUseContext::AddressOf + NonMutatingUseContext::RawBorrow | NonMutatingUseContext::Copy | NonMutatingUseContext::Inspect | NonMutatingUseContext::Move diff --git a/compiler/rustc_mir_dataflow/src/move_paths/builder.rs b/compiler/rustc_mir_dataflow/src/move_paths/builder.rs index 86091379f5a9..14390723ba4b 100644 --- a/compiler/rustc_mir_dataflow/src/move_paths/builder.rs +++ b/compiler/rustc_mir_dataflow/src/move_paths/builder.rs @@ -432,7 +432,7 @@ impl<'b, 'a, 'tcx, F: Fn(Ty<'tcx>) -> bool> Gatherer<'b, 'a, 'tcx, F> { } Rvalue::CopyForDeref(..) => unreachable!(), Rvalue::Ref(..) - | Rvalue::AddressOf(..) + | Rvalue::RawPtr(..) | Rvalue::Discriminant(..) | Rvalue::Len(..) | Rvalue::NullaryOp( diff --git a/compiler/rustc_mir_dataflow/src/value_analysis.rs b/compiler/rustc_mir_dataflow/src/value_analysis.rs index 139fd592f69a..2b20a35b61e2 100644 --- a/compiler/rustc_mir_dataflow/src/value_analysis.rs +++ b/compiler/rustc_mir_dataflow/src/value_analysis.rs @@ -177,7 +177,7 @@ pub trait ValueAnalysis<'tcx> { match rvalue { Rvalue::Use(operand) => self.handle_operand(operand, state), Rvalue::CopyForDeref(place) => self.handle_operand(&Operand::Copy(*place), state), - Rvalue::Ref(..) | Rvalue::AddressOf(..) => { + Rvalue::Ref(..) | Rvalue::RawPtr(..) => { // We don't track such places. ValueOrPlace::TOP } diff --git a/compiler/rustc_mir_transform/src/add_retag.rs b/compiler/rustc_mir_transform/src/add_retag.rs index 16977a63c598..12a68790374e 100644 --- a/compiler/rustc_mir_transform/src/add_retag.rs +++ b/compiler/rustc_mir_transform/src/add_retag.rs @@ -131,9 +131,9 @@ impl<'tcx> MirPass<'tcx> for AddRetag { // Ptr-creating operations already do their own internal retagging, no // need to also add a retag statement. // *Except* if we are deref'ing a Box, because those get desugared to directly working - // with the inner raw pointer! That's relevant for `AddressOf` as Miri otherwise makes it + // with the inner raw pointer! That's relevant for `RawPtr` as Miri otherwise makes it // a NOP when the original pointer is already raw. - Rvalue::AddressOf(_mutbl, place) => { + Rvalue::RawPtr(_mutbl, place) => { // Using `is_box_global` here is a bit sketchy: if this code is // generic over the allocator, we'll not add a retag! This is a hack // to make Stacked Borrows compatible with custom allocator code. diff --git a/compiler/rustc_mir_transform/src/check_alignment.rs b/compiler/rustc_mir_transform/src/check_alignment.rs index a1dbd7dc50ec..5dfdcfc8b944 100644 --- a/compiler/rustc_mir_transform/src/check_alignment.rs +++ b/compiler/rustc_mir_transform/src/check_alignment.rs @@ -71,7 +71,7 @@ struct PointerFinder<'tcx, 'a> { impl<'tcx, 'a> Visitor<'tcx> for PointerFinder<'tcx, 'a> { fn visit_place(&mut self, place: &Place<'tcx>, context: PlaceContext, location: Location) { // We want to only check reads and writes to Places, so we specifically exclude - // Borrows and AddressOf. + // Borrow and RawBorrow. match context { PlaceContext::MutatingUse( MutatingUseContext::Store diff --git a/compiler/rustc_mir_transform/src/deduce_param_attrs.rs b/compiler/rustc_mir_transform/src/deduce_param_attrs.rs index 370e930b7409..71af099199ea 100644 --- a/compiler/rustc_mir_transform/src/deduce_param_attrs.rs +++ b/compiler/rustc_mir_transform/src/deduce_param_attrs.rs @@ -40,7 +40,7 @@ impl<'tcx> Visitor<'tcx> for DeduceReadOnly { // This is a mutation, so mark it as such. true } - PlaceContext::NonMutatingUse(NonMutatingUseContext::AddressOf) => { + PlaceContext::NonMutatingUse(NonMutatingUseContext::RawBorrow) => { // Whether mutating though a `&raw const` is allowed is still undecided, so we // disable any sketchy `readonly` optimizations for now. // But we only need to do this if the pointer would point into the argument. diff --git a/compiler/rustc_mir_transform/src/dest_prop.rs b/compiler/rustc_mir_transform/src/dest_prop.rs index 054cdbc6bad9..ed924761892c 100644 --- a/compiler/rustc_mir_transform/src/dest_prop.rs +++ b/compiler/rustc_mir_transform/src/dest_prop.rs @@ -576,7 +576,7 @@ impl WriteInfo { Rvalue::ThreadLocalRef(_) | Rvalue::NullaryOp(_, _) | Rvalue::Ref(_, _, _) - | Rvalue::AddressOf(_, _) + | Rvalue::RawPtr(_, _) | Rvalue::Len(_) | Rvalue::Discriminant(_) | Rvalue::CopyForDeref(_) => (), diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs index e16911d79c37..90e3ba26a438 100644 --- a/compiler/rustc_mir_transform/src/gvn.rs +++ b/compiler/rustc_mir_transform/src/gvn.rs @@ -45,7 +45,7 @@ //! //! # Handling of references //! -//! We handle references by assigning a different "provenance" index to each Ref/AddressOf rvalue. +//! We handle references by assigning a different "provenance" index to each Ref/RawPtr rvalue. //! This ensure that we do not spuriously merge borrows that should not be merged. Meanwhile, we //! consider all the derefs of an immutable reference to a freeze type to give the same value: //! ```ignore (MIR) @@ -832,7 +832,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> { self.simplify_place_projection(place, location); return self.new_pointer(*place, AddressKind::Ref(borrow_kind)); } - Rvalue::AddressOf(mutbl, ref mut place) => { + Rvalue::RawPtr(mutbl, ref mut place) => { self.simplify_place_projection(place, location); return self.new_pointer(*place, AddressKind::Address(mutbl)); } diff --git a/compiler/rustc_mir_transform/src/instsimplify.rs b/compiler/rustc_mir_transform/src/instsimplify.rs index 1589653968c2..3ec553d0ba0c 100644 --- a/compiler/rustc_mir_transform/src/instsimplify.rs +++ b/compiler/rustc_mir_transform/src/instsimplify.rs @@ -141,7 +141,7 @@ impl<'tcx> InstSimplifyContext<'tcx, '_> { /// Transform `&(*a)` ==> `a`. fn simplify_ref_deref(&self, source_info: &SourceInfo, rvalue: &mut Rvalue<'tcx>) { - if let Rvalue::Ref(_, _, place) | Rvalue::AddressOf(_, place) = rvalue { + if let Rvalue::Ref(_, _, place) | Rvalue::RawPtr(_, place) = rvalue { if let Some((base, ProjectionElem::Deref)) = place.as_ref().last_projection() { if rvalue.ty(self.local_decls, self.tcx) != base.ty(self.local_decls, self.tcx).ty { return; diff --git a/compiler/rustc_mir_transform/src/known_panics_lint.rs b/compiler/rustc_mir_transform/src/known_panics_lint.rs index 7202cc2d0427..7eed47cf2398 100644 --- a/compiler/rustc_mir_transform/src/known_panics_lint.rs +++ b/compiler/rustc_mir_transform/src/known_panics_lint.rs @@ -419,8 +419,8 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> { } // Do not try creating references (#67862) - Rvalue::AddressOf(_, place) | Rvalue::Ref(_, _, place) => { - trace!("skipping AddressOf | Ref for {:?}", place); + Rvalue::RawPtr(_, place) | Rvalue::Ref(_, _, place) => { + trace!("skipping RawPtr | Ref for {:?}", place); // This may be creating mutable references or immutable references to cells. // If that happens, the pointed to value could be mutated via that reference. @@ -616,7 +616,7 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> { ImmTy::from_scalar(Scalar::from_target_usize(len, self), layout).into() } - Ref(..) | AddressOf(..) => return None, + Ref(..) | RawPtr(..) => return None, NullaryOp(ref null_op, ty) => { let op_layout = self.use_ecx(|this| this.ecx.layout_of(ty))?; @@ -969,9 +969,9 @@ impl<'tcx> Visitor<'tcx> for CanConstProp { // mutation. | NonMutatingUse(NonMutatingUseContext::SharedBorrow) | NonMutatingUse(NonMutatingUseContext::FakeBorrow) - | NonMutatingUse(NonMutatingUseContext::AddressOf) + | NonMutatingUse(NonMutatingUseContext::RawBorrow) | MutatingUse(MutatingUseContext::Borrow) - | MutatingUse(MutatingUseContext::AddressOf) => { + | MutatingUse(MutatingUseContext::RawBorrow) => { trace!("local {:?} can't be propagated because it's used: {:?}", local, context); self.can_const_prop[local] = ConstPropMode::NoPropagation; } diff --git a/compiler/rustc_mir_transform/src/large_enums.rs b/compiler/rustc_mir_transform/src/large_enums.rs index e407929c9a7f..cbc3169f2f10 100644 --- a/compiler/rustc_mir_transform/src/large_enums.rs +++ b/compiler/rustc_mir_transform/src/large_enums.rs @@ -214,7 +214,7 @@ impl EnumSizeOpt { source_info, kind: StatementKind::Assign(Box::new(( dst, - Rvalue::AddressOf(Mutability::Mut, *lhs), + Rvalue::RawPtr(Mutability::Mut, *lhs), ))), }; @@ -238,7 +238,7 @@ impl EnumSizeOpt { source_info, kind: StatementKind::Assign(Box::new(( src, - Rvalue::AddressOf(Mutability::Not, *rhs), + Rvalue::RawPtr(Mutability::Not, *rhs), ))), }; diff --git a/compiler/rustc_mir_transform/src/promote_consts.rs b/compiler/rustc_mir_transform/src/promote_consts.rs index 48a3266ae6f0..6e84914ef972 100644 --- a/compiler/rustc_mir_transform/src/promote_consts.rs +++ b/compiler/rustc_mir_transform/src/promote_consts.rs @@ -551,7 +551,7 @@ impl<'tcx> Validator<'_, 'tcx> { self.validate_operand(rhs)?; } - Rvalue::AddressOf(_, place) => { + Rvalue::RawPtr(_, place) => { // We accept `&raw *`, i.e., raw reborrows -- creating a raw pointer is // no problem, only using it is. if let Some((place_base, ProjectionElem::Deref)) = place.as_ref().last_projection() diff --git a/compiler/rustc_mir_transform/src/ref_prop.rs b/compiler/rustc_mir_transform/src/ref_prop.rs index 76e65099e902..973a191d786e 100644 --- a/compiler/rustc_mir_transform/src/ref_prop.rs +++ b/compiler/rustc_mir_transform/src/ref_prop.rs @@ -227,7 +227,7 @@ fn compute_replacement<'tcx>( } } } - Rvalue::Ref(_, _, place) | Rvalue::AddressOf(_, place) => { + Rvalue::Ref(_, _, place) | Rvalue::RawPtr(_, place) => { let mut place = *place; // Try to see through `place` in order to collapse reborrow chains. if place.projection.first() == Some(&PlaceElem::Deref) diff --git a/compiler/rustc_mir_transform/src/shim/async_destructor_ctor.rs b/compiler/rustc_mir_transform/src/shim/async_destructor_ctor.rs index ea4f5fca59e6..9c3f903e0eab 100644 --- a/compiler/rustc_mir_transform/src/shim/async_destructor_ctor.rs +++ b/compiler/rustc_mir_transform/src/shim/async_destructor_ctor.rs @@ -343,7 +343,7 @@ impl<'tcx> AsyncDestructorCtorShimBuilder<'tcx> { .tcx .mk_place_elems(&[PlaceElem::Deref, PlaceElem::Field(field, field_ty)]), }; - self.put_temp_rvalue(Rvalue::AddressOf(Mutability::Mut, place)) + self.put_temp_rvalue(Rvalue::RawPtr(Mutability::Mut, place)) } /// If given Self is an enum puts `to_drop: *mut FieldTy` on top of @@ -363,7 +363,7 @@ impl<'tcx> AsyncDestructorCtorShimBuilder<'tcx> { PlaceElem::Field(field, field_ty), ]), }; - self.put_temp_rvalue(Rvalue::AddressOf(Mutability::Mut, place)) + self.put_temp_rvalue(Rvalue::RawPtr(Mutability::Mut, place)) } /// If given Self is an enum puts `to_drop: *mut FieldTy` on top of diff --git a/compiler/rustc_mir_transform/src/ssa.rs b/compiler/rustc_mir_transform/src/ssa.rs index fb870425f6ef..76591f526250 100644 --- a/compiler/rustc_mir_transform/src/ssa.rs +++ b/compiler/rustc_mir_transform/src/ssa.rs @@ -2,9 +2,9 @@ //! 1/ They are only assigned-to once, either as a function parameter, or in an assign statement; //! 2/ This single assignment dominates all uses; //! -//! As we do not track indirect assignments, a local that has its address taken (either by -//! AddressOf or by borrowing) is considered non-SSA. However, it is UB to modify through an -//! immutable borrow of a `Freeze` local. Those can still be considered to be SSA. +//! As we do not track indirect assignments, a local that has its address taken (via a borrow or raw +//! borrow operator) is considered non-SSA. However, it is UB to modify through an immutable borrow +//! of a `Freeze` local. Those can still be considered to be SSA. use rustc_data_structures::graph::dominators::Dominators; use rustc_index::bit_set::BitSet; @@ -262,7 +262,7 @@ impl<'tcx> Visitor<'tcx> for SsaVisitor<'tcx, '_> { PlaceContext::MutatingUse(MutatingUseContext::Projection) | PlaceContext::NonMutatingUse(NonMutatingUseContext::Projection) => bug!(), // Anything can happen with raw pointers, so remove them. - PlaceContext::NonMutatingUse(NonMutatingUseContext::AddressOf) + PlaceContext::NonMutatingUse(NonMutatingUseContext::RawBorrow) | PlaceContext::MutatingUse(_) => { self.assignments[local] = Set1::Many; } diff --git a/compiler/rustc_mir_transform/src/validate.rs b/compiler/rustc_mir_transform/src/validate.rs index 491ae1c0d083..36908036796c 100644 --- a/compiler/rustc_mir_transform/src/validate.rs +++ b/compiler/rustc_mir_transform/src/validate.rs @@ -1345,7 +1345,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> { } Rvalue::Repeat(_, _) | Rvalue::ThreadLocalRef(_) - | Rvalue::AddressOf(_, _) + | Rvalue::RawPtr(_, _) | Rvalue::NullaryOp(NullOp::SizeOf | NullOp::AlignOf | NullOp::UbChecks, _) | Rvalue::Discriminant(_) => {} } diff --git a/compiler/rustc_smir/src/rustc_smir/convert/mir.rs b/compiler/rustc_smir/src/rustc_smir/convert/mir.rs index da705e6f9598..c442ca861d35 100644 --- a/compiler/rustc_smir/src/rustc_smir/convert/mir.rs +++ b/compiler/rustc_smir/src/rustc_smir/convert/mir.rs @@ -174,7 +174,7 @@ impl<'tcx> Stable<'tcx> for mir::Rvalue<'tcx> { ThreadLocalRef(def_id) => { stable_mir::mir::Rvalue::ThreadLocalRef(tables.crate_item(*def_id)) } - AddressOf(mutability, place) => { + RawPtr(mutability, place) => { stable_mir::mir::Rvalue::AddressOf(mutability.stable(tables), place.stable(tables)) } Len(place) => stable_mir::mir::Rvalue::Len(place.stable(tables)), diff --git a/compiler/rustc_ty_utils/src/consts.rs b/compiler/rustc_ty_utils/src/consts.rs index 249268835234..4ded935b801d 100644 --- a/compiler/rustc_ty_utils/src/consts.rs +++ b/compiler/rustc_ty_utils/src/consts.rs @@ -192,7 +192,7 @@ fn recurse_build<'tcx>( ExprKind::Borrow { arg, .. } => { let arg_node = &body.exprs[*arg]; - // Skip reborrows for now until we allow Deref/Borrow/AddressOf + // Skip reborrows for now until we allow Deref/Borrow/RawBorrow // expressions. // FIXME(generic_const_exprs): Verify/explain why this is sound if let ExprKind::Deref { arg } = arg_node.kind { @@ -202,7 +202,7 @@ fn recurse_build<'tcx>( } } // FIXME(generic_const_exprs): We may want to support these. - ExprKind::AddressOf { .. } | ExprKind::Deref { .. } => maybe_supported_error( + ExprKind::RawBorrow { .. } | ExprKind::Deref { .. } => maybe_supported_error( GenericConstantTooComplexSub::AddressAndDerefNotSupported(node.span), )?, ExprKind::Repeat { .. } | ExprKind::Array { .. } => { @@ -343,7 +343,7 @@ impl<'a, 'tcx> IsThirPolymorphic<'a, 'tcx> { | thir::ExprKind::VarRef { .. } | thir::ExprKind::UpvarRef { .. } | thir::ExprKind::Borrow { .. } - | thir::ExprKind::AddressOf { .. } + | thir::ExprKind::RawBorrow { .. } | thir::ExprKind::Break { .. } | thir::ExprKind::Continue { .. } | thir::ExprKind::Return { .. } diff --git a/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs b/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs index 553af913ef9d..95fbf0b2ea20 100644 --- a/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs +++ b/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs @@ -110,7 +110,7 @@ fn check_rvalue<'tcx>( ) -> McfResult { match rvalue { Rvalue::ThreadLocalRef(_) => Err((span, "cannot access thread local storage in const fn".into())), - Rvalue::Len(place) | Rvalue::Discriminant(place) | Rvalue::Ref(_, _, place) | Rvalue::AddressOf(_, place) => { + Rvalue::Len(place) | Rvalue::Discriminant(place) | Rvalue::Ref(_, _, place) | Rvalue::RawPtr(_, place) => { check_place(tcx, *place, span, body, msrv) }, Rvalue::CopyForDeref(place) => check_place(tcx, *place, span, body, msrv), From 17995d5cc2e75b65b8bd6b77ad30b0c764500c0c Mon Sep 17 00:00:00 2001 From: Jack Wrenn Date: Wed, 14 Aug 2024 20:10:28 +0000 Subject: [PATCH 57/79] safe transmute: forbid reference lifetime extension Modifies `BikeshedIntrinsicFrom` to forbid lifetime extensions on references. This static check can be opted out of with the `Assume::lifetimes` flag. Fixes #129097 --- .../src/traits/select/confirmation.rs | 176 ++++++++++-------- compiler/rustc_transmute/src/layout/mod.rs | 13 +- compiler/rustc_transmute/src/layout/tree.rs | 141 ++++++++------ compiler/rustc_transmute/src/lib.rs | 2 +- .../src/maybe_transmutable/mod.rs | 7 +- .../accept_assume_lifetime_extension.rs | 91 +++++++++ .../accept_unexercised_lifetime_extension.rs | 68 +++++++ .../references/reject_lifetime_extension.rs | 91 +++++++++ .../reject_lifetime_extension.stderr | 78 ++++++++ 9 files changed, 535 insertions(+), 132 deletions(-) create mode 100644 tests/ui/transmutability/references/accept_assume_lifetime_extension.rs create mode 100644 tests/ui/transmutability/references/accept_unexercised_lifetime_extension.rs create mode 100644 tests/ui/transmutability/references/reject_lifetime_extension.rs create mode 100644 tests/ui/transmutability/references/reject_lifetime_extension.stderr diff --git a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs index 0d7ceca43017..f19cd19c99a8 100644 --- a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs +++ b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs @@ -17,8 +17,7 @@ use rustc_infer::infer::{DefineOpaqueTypes, HigherRankedType, InferOk}; use rustc_infer::traits::ObligationCauseCode; use rustc_middle::traits::{BuiltinImplSource, SignatureMismatchData}; use rustc_middle::ty::{ - self, GenericArgs, GenericArgsRef, GenericParamDefKind, ToPolyTraitRef, TraitPredicate, Ty, - TyCtxt, Upcast, + self, GenericArgs, GenericArgsRef, GenericParamDefKind, ToPolyTraitRef, Ty, TyCtxt, Upcast, }; use rustc_middle::{bug, span_bug}; use rustc_span::def_id::DefId; @@ -292,90 +291,120 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { &mut self, obligation: &PolyTraitObligation<'tcx>, ) -> Result>, SelectionError<'tcx>> { - use rustc_transmute::{Answer, Condition}; - #[instrument(level = "debug", skip(tcx, obligation, predicate))] + use rustc_transmute::{Answer, Assume, Condition}; + + /// Generate sub-obligations for reference-to-reference transmutations. + fn reference_obligations<'tcx>( + tcx: TyCtxt<'tcx>, + obligation: &PolyTraitObligation<'tcx>, + (src_lifetime, src_ty, src_mut): (ty::Region<'tcx>, Ty<'tcx>, Mutability), + (dst_lifetime, dst_ty, dst_mut): (ty::Region<'tcx>, Ty<'tcx>, Mutability), + assume: Assume, + ) -> Vec> { + let make_transmute_obl = |src, dst| { + let transmute_trait = obligation.predicate.def_id(); + let assume = obligation.predicate.skip_binder().trait_ref.args.const_at(2); + let trait_ref = ty::TraitRef::new( + tcx, + transmute_trait, + [ + ty::GenericArg::from(dst), + ty::GenericArg::from(src), + ty::GenericArg::from(assume), + ], + ); + Obligation::with_depth( + tcx, + obligation.cause.clone(), + obligation.recursion_depth + 1, + obligation.param_env, + obligation.predicate.rebind(trait_ref), + ) + }; + + let make_freeze_obl = |ty| { + let trait_ref = ty::TraitRef::new( + tcx, + tcx.require_lang_item(LangItem::Freeze, None), + [ty::GenericArg::from(ty)], + ); + Obligation::with_depth( + tcx, + obligation.cause.clone(), + obligation.recursion_depth + 1, + obligation.param_env, + trait_ref, + ) + }; + + let make_outlives_obl = |target, region| { + let outlives = ty::OutlivesPredicate(target, region); + Obligation::with_depth( + tcx, + obligation.cause.clone(), + obligation.recursion_depth + 1, + obligation.param_env, + obligation.predicate.rebind(outlives), + ) + }; + + // Given a transmutation from `&'a (mut) Src` and `&'dst (mut) Dst`, + // it is always the case that `Src` must be transmutable into `Dst`, + // and that that `'src` must outlive `'dst`. + let mut obls = vec![make_transmute_obl(src_ty, dst_ty)]; + if !assume.lifetimes { + obls.push(make_outlives_obl(src_lifetime, dst_lifetime)); + } + + // Given a transmutation from `&Src`, both `Src` and `Dst` must be + // `Freeze`, otherwise, using the transmuted value could lead to + // data races. + if src_mut == Mutability::Not { + obls.extend([make_freeze_obl(src_ty), make_freeze_obl(dst_ty)]) + } + + // Given a transmutation into `&'dst mut Dst`, it also must be the + // case that `Dst` is transmutable into `Src`. For example, + // transmuting bool -> u8 is OK as long as you can't update that u8 + // to be > 1, because you could later transmute the u8 back to a + // bool and get undefined behavior. It also must be the case that + // `'dst` lives exactly as long as `'src`. + if dst_mut == Mutability::Mut { + obls.push(make_transmute_obl(dst_ty, src_ty)); + if !assume.lifetimes { + obls.push(make_outlives_obl(dst_lifetime, src_lifetime)); + } + } + + obls + } + + /// Flatten the `Condition` tree into a conjunction of obligations. + #[instrument(level = "debug", skip(tcx, obligation))] fn flatten_answer_tree<'tcx>( tcx: TyCtxt<'tcx>, obligation: &PolyTraitObligation<'tcx>, - predicate: TraitPredicate<'tcx>, cond: Condition>, + assume: Assume, ) -> Vec> { match cond { // FIXME(bryangarza): Add separate `IfAny` case, instead of treating as `IfAll` // Not possible until the trait solver supports disjunctions of obligations Condition::IfAll(conds) | Condition::IfAny(conds) => conds .into_iter() - .flat_map(|cond| flatten_answer_tree(tcx, obligation, predicate, cond)) + .flat_map(|cond| flatten_answer_tree(tcx, obligation, cond, assume)) .collect(), - Condition::IfTransmutable { src, dst } => { - let transmute_trait = obligation.predicate.def_id(); - let assume_const = predicate.trait_ref.args.const_at(2); - let make_transmute_obl = |from_ty, to_ty| { - let trait_ref = ty::TraitRef::new( - tcx, - transmute_trait, - [ - ty::GenericArg::from(to_ty), - ty::GenericArg::from(from_ty), - ty::GenericArg::from(assume_const), - ], - ); - Obligation::with_depth( - tcx, - obligation.cause.clone(), - obligation.recursion_depth + 1, - obligation.param_env, - trait_ref, - ) - }; - - let make_freeze_obl = |ty| { - let trait_ref = ty::TraitRef::new( - tcx, - tcx.require_lang_item(LangItem::Freeze, None), - [ty::GenericArg::from(ty)], - ); - Obligation::with_depth( - tcx, - obligation.cause.clone(), - obligation.recursion_depth + 1, - obligation.param_env, - trait_ref, - ) - }; - - let mut obls = vec![]; - - // If the source is a shared reference, it must be `Freeze`; - // otherwise, transmuting could lead to data races. - if src.mutability == Mutability::Not { - obls.extend([make_freeze_obl(src.ty), make_freeze_obl(dst.ty)]) - } - - // If Dst is mutable, check bidirectionally. - // For example, transmuting bool -> u8 is OK as long as you can't update that u8 - // to be > 1, because you could later transmute the u8 back to a bool and get UB. - match dst.mutability { - Mutability::Not => obls.push(make_transmute_obl(src.ty, dst.ty)), - Mutability::Mut => obls.extend([ - make_transmute_obl(src.ty, dst.ty), - make_transmute_obl(dst.ty, src.ty), - ]), - } - - obls - } + Condition::IfTransmutable { src, dst } => reference_obligations( + tcx, + obligation, + (src.lifetime, src.ty, src.mutability), + (dst.lifetime, dst.ty, dst.mutability), + assume, + ), } } - // We erase regions here because transmutability calls layout queries, - // which does not handle inference regions and doesn't particularly - // care about other regions. Erasing late-bound regions is equivalent - // to instantiating the binder with placeholders then erasing those - // placeholder regions. - let predicate = self - .tcx() - .erase_regions(self.tcx().instantiate_bound_regions_with_erased(obligation.predicate)); + let predicate = obligation.predicate.skip_binder(); let Some(assume) = rustc_transmute::Assume::from_const( self.infcx.tcx, @@ -387,6 +416,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { let dst = predicate.trait_ref.args.type_at(0); let src = predicate.trait_ref.args.type_at(1); + debug!(?src, ?dst); let mut transmute_env = rustc_transmute::TransmuteTypeEnv::new(self.infcx); let maybe_transmutable = transmute_env.is_transmutable( @@ -397,7 +427,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { let fully_flattened = match maybe_transmutable { Answer::No(_) => Err(Unimplemented)?, - Answer::If(cond) => flatten_answer_tree(self.tcx(), obligation, predicate, cond), + Answer::If(cond) => flatten_answer_tree(self.tcx(), obligation, cond, assume), Answer::Yes => vec![], }; diff --git a/compiler/rustc_transmute/src/layout/mod.rs b/compiler/rustc_transmute/src/layout/mod.rs index bbf155581f98..1cf9e0b9b70e 100644 --- a/compiler/rustc_transmute/src/layout/mod.rs +++ b/compiler/rustc_transmute/src/layout/mod.rs @@ -63,7 +63,9 @@ pub mod rustc { use std::fmt::{self, Write}; use rustc_middle::mir::Mutability; - use rustc_middle::ty::{self, Ty}; + use rustc_middle::ty::layout::{LayoutCx, LayoutError}; + use rustc_middle::ty::{self, Ty, TyCtxt}; + use rustc_target::abi::Layout; /// A reference in the layout. #[derive(Debug, Hash, Eq, PartialEq, Clone, Copy)] @@ -120,4 +122,13 @@ pub mod rustc { self != &Self::Primitive } } + + pub(crate) fn layout_of<'tcx>( + cx: LayoutCx<'tcx, TyCtxt<'tcx>>, + ty: Ty<'tcx>, + ) -> Result, &'tcx LayoutError<'tcx>> { + use rustc_middle::ty::layout::LayoutOf; + let ty = cx.tcx.erase_regions(ty); + cx.layout_of(ty).map(|tl| tl.layout) + } } diff --git a/compiler/rustc_transmute/src/layout/tree.rs b/compiler/rustc_transmute/src/layout/tree.rs index 5c25f913ffe3..7c73f74e6290 100644 --- a/compiler/rustc_transmute/src/layout/tree.rs +++ b/compiler/rustc_transmute/src/layout/tree.rs @@ -171,10 +171,12 @@ where #[cfg(feature = "rustc")] pub(crate) mod rustc { - use rustc_middle::ty::layout::{HasTyCtxt, LayoutCx, LayoutError, LayoutOf}; + use rustc_middle::ty::layout::{HasTyCtxt, LayoutCx, LayoutError}; use rustc_middle::ty::{self, AdtDef, AdtKind, List, ScalarInt, Ty, TyCtxt, TypeVisitableExt}; use rustc_span::ErrorGuaranteed; - use rustc_target::abi::{FieldsShape, Size, TyAndLayout, Variants}; + use rustc_target::abi::{ + FieldIdx, FieldsShape, Layout, Size, TyAndLayout, VariantIdx, Variants, + }; use super::Tree; use crate::layout::rustc::{Def, Ref}; @@ -202,20 +204,18 @@ pub(crate) mod rustc { } impl<'tcx> Tree, Ref<'tcx>> { - pub fn from_ty( - ty_and_layout: TyAndLayout<'tcx, Ty<'tcx>>, - cx: LayoutCx<'tcx, TyCtxt<'tcx>>, - ) -> Result { + pub fn from_ty(ty: Ty<'tcx>, cx: LayoutCx<'tcx, TyCtxt<'tcx>>) -> Result { use rustc_target::abi::HasDataLayout; + let layout = ty_layout(cx, ty); - if let Err(e) = ty_and_layout.ty.error_reported() { + if let Err(e) = ty.error_reported() { return Err(Err::TypeError(e)); } let target = cx.tcx.data_layout(); let pointer_size = target.pointer_size; - match ty_and_layout.ty.kind() { + match ty.kind() { ty::Bool => Ok(Self::bool()), ty::Float(nty) => { @@ -233,32 +233,30 @@ pub(crate) mod rustc { Ok(Self::number(width as _)) } - ty::Tuple(members) => Self::from_tuple(ty_and_layout, members, cx), + ty::Tuple(members) => Self::from_tuple((ty, layout), members, cx), ty::Array(inner_ty, len) => { - let FieldsShape::Array { stride, count } = &ty_and_layout.fields else { + let FieldsShape::Array { stride, count } = &layout.fields else { return Err(Err::NotYetSupported); }; - let inner_ty_and_layout = cx.layout_of(*inner_ty)?; - assert_eq!(*stride, inner_ty_and_layout.size); - let elt = Tree::from_ty(inner_ty_and_layout, cx)?; + let inner_layout = ty_layout(cx, *inner_ty); + assert_eq!(*stride, inner_layout.size); + let elt = Tree::from_ty(*inner_ty, cx)?; Ok(std::iter::repeat(elt) .take(*count as usize) .fold(Tree::unit(), |tree, elt| tree.then(elt))) } - ty::Adt(adt_def, _args_ref) if !ty_and_layout.ty.is_box() => { - match adt_def.adt_kind() { - AdtKind::Struct => Self::from_struct(ty_and_layout, *adt_def, cx), - AdtKind::Enum => Self::from_enum(ty_and_layout, *adt_def, cx), - AdtKind::Union => Self::from_union(ty_and_layout, *adt_def, cx), - } - } + ty::Adt(adt_def, _args_ref) if !ty.is_box() => match adt_def.adt_kind() { + AdtKind::Struct => Self::from_struct((ty, layout), *adt_def, cx), + AdtKind::Enum => Self::from_enum((ty, layout), *adt_def, cx), + AdtKind::Union => Self::from_union((ty, layout), *adt_def, cx), + }, ty::Ref(lifetime, ty, mutability) => { - let ty_and_layout = cx.layout_of(*ty)?; - let align = ty_and_layout.align.abi.bytes_usize(); - let size = ty_and_layout.size.bytes_usize(); + let layout = ty_layout(cx, *ty); + let align = layout.align.abi.bytes_usize(); + let size = layout.size.bytes_usize(); Ok(Tree::Ref(Ref { lifetime: *lifetime, ty: *ty, @@ -274,21 +272,20 @@ pub(crate) mod rustc { /// Constructs a `Tree` from a tuple. fn from_tuple( - ty_and_layout: TyAndLayout<'tcx, Ty<'tcx>>, + (ty, layout): (Ty<'tcx>, Layout<'tcx>), members: &'tcx List>, cx: LayoutCx<'tcx, TyCtxt<'tcx>>, ) -> Result { - match &ty_and_layout.fields { + match &layout.fields { FieldsShape::Primitive => { assert_eq!(members.len(), 1); let inner_ty = members[0]; - let inner_ty_and_layout = cx.layout_of(inner_ty)?; - assert_eq!(ty_and_layout.layout, inner_ty_and_layout.layout); - Self::from_ty(inner_ty_and_layout, cx) + let inner_layout = ty_layout(cx, inner_ty); + Self::from_ty(inner_ty, cx) } FieldsShape::Arbitrary { offsets, .. } => { assert_eq!(offsets.len(), members.len()); - Self::from_variant(Def::Primitive, None, ty_and_layout, ty_and_layout.size, cx) + Self::from_variant(Def::Primitive, None, (ty, layout), layout.size, cx) } FieldsShape::Array { .. } | FieldsShape::Union(_) => Err(Err::NotYetSupported), } @@ -300,13 +297,13 @@ pub(crate) mod rustc { /// /// Panics if `def` is not a struct definition. fn from_struct( - ty_and_layout: TyAndLayout<'tcx, Ty<'tcx>>, + (ty, layout): (Ty<'tcx>, Layout<'tcx>), def: AdtDef<'tcx>, cx: LayoutCx<'tcx, TyCtxt<'tcx>>, ) -> Result { assert!(def.is_struct()); let def = Def::Adt(def); - Self::from_variant(def, None, ty_and_layout, ty_and_layout.size, cx) + Self::from_variant(def, None, (ty, layout), layout.size, cx) } /// Constructs a `Tree` from an enum. @@ -315,19 +312,18 @@ pub(crate) mod rustc { /// /// Panics if `def` is not an enum definition. fn from_enum( - ty_and_layout: TyAndLayout<'tcx, Ty<'tcx>>, + (ty, layout): (Ty<'tcx>, Layout<'tcx>), def: AdtDef<'tcx>, cx: LayoutCx<'tcx, TyCtxt<'tcx>>, ) -> Result { assert!(def.is_enum()); - let layout = ty_and_layout.layout; // Computes the variant of a given index. let layout_of_variant = |index| { - let tag = cx.tcx.tag_for_variant((ty_and_layout.ty, index)); + let tag = cx.tcx.tag_for_variant((cx.tcx.erase_regions(ty), index)); let variant_def = Def::Variant(def.variant(index)); - let variant_ty_and_layout = ty_and_layout.for_variant(&cx, index); - Self::from_variant(variant_def, tag, variant_ty_and_layout, layout.size, cx) + let variant_layout = ty_variant(cx, (ty, layout), index); + Self::from_variant(variant_def, tag, (ty, variant_layout), layout.size, cx) }; // We consider three kinds of enums, each demanding a different @@ -385,21 +381,20 @@ pub(crate) mod rustc { fn from_variant( def: Def<'tcx>, tag: Option, - ty_and_layout: TyAndLayout<'tcx, Ty<'tcx>>, + (ty, layout): (Ty<'tcx>, Layout<'tcx>), total_size: Size, cx: LayoutCx<'tcx, TyCtxt<'tcx>>, ) -> Result { // This constructor does not support non-`FieldsShape::Arbitrary` // layouts. - let FieldsShape::Arbitrary { offsets, memory_index } = ty_and_layout.layout.fields() - else { + let FieldsShape::Arbitrary { offsets, memory_index } = layout.fields() else { return Err(Err::NotYetSupported); }; // When this function is invoked with enum variants, // `ty_and_layout.size` does not encompass the entire size of the // enum. We rely on `total_size` for this. - assert!(ty_and_layout.size <= total_size); + assert!(layout.size <= total_size); let mut size = Size::ZERO; let mut struct_tree = Self::def(def); @@ -412,17 +407,18 @@ pub(crate) mod rustc { // Append the fields, in memory order, to the layout. let inverse_memory_index = memory_index.invert_bijective_mapping(); - for (memory_idx, field_idx) in inverse_memory_index.iter_enumerated() { + for (memory_idx, &field_idx) in inverse_memory_index.iter_enumerated() { // Add interfield padding. - let padding_needed = offsets[*field_idx] - size; + let padding_needed = offsets[field_idx] - size; let padding = Self::padding(padding_needed.bytes_usize()); - let field_ty_and_layout = ty_and_layout.field(&cx, field_idx.as_usize()); - let field_tree = Self::from_ty(field_ty_and_layout, cx)?; + let field_ty = ty_field(cx, (ty, layout), field_idx); + let field_layout = ty_layout(cx, field_ty); + let field_tree = Self::from_ty(field_ty, cx)?; struct_tree = struct_tree.then(padding).then(field_tree); - size += padding_needed + field_ty_and_layout.size; + size += padding_needed + field_layout.size; } // Add trailing padding. @@ -457,28 +453,27 @@ pub(crate) mod rustc { /// /// Panics if `def` is not a union definition. fn from_union( - ty_and_layout: TyAndLayout<'tcx, Ty<'tcx>>, + (ty, layout): (Ty<'tcx>, Layout<'tcx>), def: AdtDef<'tcx>, cx: LayoutCx<'tcx, TyCtxt<'tcx>>, ) -> Result { assert!(def.is_union()); - let union_layout = ty_and_layout.layout; - // This constructor does not support non-`FieldsShape::Union` // layouts. Fields of this shape are all placed at offset 0. - let FieldsShape::Union(fields) = union_layout.fields() else { + let FieldsShape::Union(fields) = layout.fields() else { return Err(Err::NotYetSupported); }; let fields = &def.non_enum_variant().fields; let fields = fields.iter_enumerated().try_fold( Self::uninhabited(), - |fields, (idx, ref field_def)| { + |fields, (idx, field_def)| { let field_def = Def::Field(field_def); - let field_ty_and_layout = ty_and_layout.field(&cx, idx.as_usize()); - let field = Self::from_ty(field_ty_and_layout, cx)?; - let trailing_padding_needed = union_layout.size - field_ty_and_layout.size; + let field_ty = ty_field(cx, (ty, layout), idx); + let field_layout = ty_layout(cx, field_ty); + let field = Self::from_ty(field_ty, cx)?; + let trailing_padding_needed = layout.size - field_layout.size; let trailing_padding = Self::padding(trailing_padding_needed.bytes_usize()); let field_and_padding = field.then(trailing_padding); Result::::Ok(fields.or(field_and_padding)) @@ -488,4 +483,44 @@ pub(crate) mod rustc { Ok(Self::def(Def::Adt(def)).then(fields)) } } + + pub(crate) fn ty_layout<'tcx>(cx: LayoutCx<'tcx, TyCtxt<'tcx>>, ty: Ty<'tcx>) -> Layout<'tcx> { + crate::layout::rustc::layout_of(cx, ty).unwrap() + } + + fn ty_field<'tcx>( + cx: LayoutCx<'tcx, TyCtxt<'tcx>>, + (ty, layout): (Ty<'tcx>, Layout<'tcx>), + i: FieldIdx, + ) -> Ty<'tcx> { + match ty.kind() { + ty::Adt(def, args) => { + match layout.variants { + Variants::Single { index } => { + let field = &def.variant(index).fields[i]; + field.ty(cx.tcx, args) + } + // Discriminant field for enums (where applicable). + Variants::Multiple { tag, .. } => { + assert_eq!(i.as_usize(), 0); + ty::layout::PrimitiveExt::to_ty(&tag.primitive(), cx.tcx) + } + } + } + ty::Tuple(fields) => fields[i.as_usize()], + kind @ _ => unimplemented!( + "only a subset of `Ty::ty_and_layout_field`'s functionality is implemented. implementation needed for {:?}", + kind + ), + } + } + + fn ty_variant<'tcx>( + cx: LayoutCx<'tcx, TyCtxt<'tcx>>, + (ty, layout): (Ty<'tcx>, Layout<'tcx>), + i: VariantIdx, + ) -> Layout<'tcx> { + let ty = cx.tcx.erase_regions(ty); + TyAndLayout { ty, layout }.for_variant(&cx, i).layout + } } diff --git a/compiler/rustc_transmute/src/lib.rs b/compiler/rustc_transmute/src/lib.rs index 31664ee6c4f7..bdc98bcea5eb 100644 --- a/compiler/rustc_transmute/src/lib.rs +++ b/compiler/rustc_transmute/src/lib.rs @@ -9,7 +9,7 @@ pub(crate) use rustc_data_structures::fx::{FxIndexMap as Map, FxIndexSet as Set} pub mod layout; mod maybe_transmutable; -#[derive(Default)] +#[derive(Copy, Clone, Debug, Default)] pub struct Assume { pub alignment: bool, pub lifetimes: bool, diff --git a/compiler/rustc_transmute/src/maybe_transmutable/mod.rs b/compiler/rustc_transmute/src/maybe_transmutable/mod.rs index 7c66a827db9a..1f3c4e3c817d 100644 --- a/compiler/rustc_transmute/src/maybe_transmutable/mod.rs +++ b/compiler/rustc_transmute/src/maybe_transmutable/mod.rs @@ -30,7 +30,7 @@ where // FIXME: Nix this cfg, so we can write unit tests independently of rustc #[cfg(feature = "rustc")] mod rustc { - use rustc_middle::ty::layout::{LayoutCx, LayoutOf}; + use rustc_middle::ty::layout::LayoutCx; use rustc_middle::ty::{ParamEnv, Ty, TyCtxt}; use super::*; @@ -45,10 +45,9 @@ mod rustc { let layout_cx = LayoutCx { tcx: context, param_env: ParamEnv::reveal_all() }; let layout_of = |ty| { - layout_cx - .layout_of(ty) + crate::layout::rustc::layout_of(layout_cx, ty) .map_err(|_| Err::NotYetSupported) - .and_then(|tl| Tree::from_ty(tl, layout_cx)) + .and_then(|_| Tree::from_ty(ty, layout_cx)) }; // Convert `src` and `dst` from their rustc representations, to `Tree`-based diff --git a/tests/ui/transmutability/references/accept_assume_lifetime_extension.rs b/tests/ui/transmutability/references/accept_assume_lifetime_extension.rs new file mode 100644 index 000000000000..3bdd7256791e --- /dev/null +++ b/tests/ui/transmutability/references/accept_assume_lifetime_extension.rs @@ -0,0 +1,91 @@ +//@ check-pass + +//! Accept lifetime extensions with `Assume::LIFETIMES`. + +#![feature(transmutability, core_intrinsics)] + +use std::mem::{Assume, BikeshedIntrinsicFrom}; + +unsafe fn transmute(src: Src) -> Dst +where + Dst: BikeshedIntrinsicFrom, +{ + core::intrinsics::transmute_unchecked(src) +} + +mod bare { + use super::*; + + fn extend_bare<'a>(src: &'a u8) -> &'static u8 { + unsafe { transmute(src) } + } +} + +mod nested { + use super::*; + + fn extend_nested<'a>(src: &'a &'a u8) -> &'a &'static u8 { + unsafe { transmute(src) } + } +} + +mod tuple { + use super::*; + + fn extend_unit<'a>(src: (&'a u8,)) -> (&'static u8,) { + unsafe { transmute(src) } + } + + fn extend_pair<'a>(src: (&'a u8, u8)) -> (&'static u8, u8) { + unsafe { transmute(src) } + } +} + +mod r#struct { + use super::*; + + struct Struct<'a>(&'a u8); + + fn extend_struct<'a>(src: Struct<'a>) -> Struct<'static> { + unsafe { transmute(src) } + } +} + +mod r#enum { + use super::*; + + enum Single<'a> { + A(&'a u8), + } + + fn extend_single<'a>(src: Single<'a>) -> Single<'static> { + unsafe { transmute(src) } + } + + enum Multi<'a> { + A(&'a u8), + B, + C, + } + + fn extend_multi<'a>(src: Multi<'a>) -> Multi<'static> { + unsafe { transmute(src) } + } +} + +mod hrtb { + use super::*; + + fn call_extend_hrtb<'a>(src: &'a u8) -> &'static u8 { + unsafe { extend_hrtb(src) } + } + + unsafe fn extend_hrtb<'a>(src: &'a u8) -> &'static u8 + where + for<'b> &'b u8: BikeshedIntrinsicFrom<&'a u8, { Assume::LIFETIMES }>, + { + core::intrinsics::transmute_unchecked(src) + } +} + +fn main() {} diff --git a/tests/ui/transmutability/references/accept_unexercised_lifetime_extension.rs b/tests/ui/transmutability/references/accept_unexercised_lifetime_extension.rs new file mode 100644 index 000000000000..559ee23a4460 --- /dev/null +++ b/tests/ui/transmutability/references/accept_unexercised_lifetime_extension.rs @@ -0,0 +1,68 @@ +//@ check-pass + +//! Accept lifetime extensions of un-exercised lifetimes. + +#![feature(transmutability, core_intrinsics)] + +use std::mem::{Assume, BikeshedIntrinsicFrom}; + +unsafe fn transmute(src: Src) -> Dst +where + Dst: BikeshedIntrinsicFrom, +{ + core::intrinsics::transmute_unchecked(src) +} + +enum Void {} + +mod phantom { + use super::*; + use std::marker::PhantomData; + + fn extend_bare<'a>(src: PhantomData<&'a u8>) -> PhantomData<&'static u8> { + unsafe { transmute(src) } + } +} + + +mod tuple { + use super::*; + + fn extend_pair<'a>(src: (&'a u8, Void)) -> (&'static u8, Void) { + unsafe { transmute(src) } + } +} + +mod r#struct { + use super::*; + + struct Struct<'a>(&'a u8, Void); + + fn extend_struct<'a>(src: Struct<'a>) -> Struct<'static> { + unsafe { transmute(src) } + } +} + +mod r#enum { + use super::*; + + enum Single<'a> { + A(&'a u8, Void), + } + + fn extend_single<'a>(src: Single<'a>) -> Single<'static> { + unsafe { transmute(src) } + } + + enum Multi<'a> { + A(&'a u8, Void), + B, + C, + } + + fn extend_multi<'a>(src: Multi<'a>) -> Multi<'static> { + unsafe { transmute(src) } + } +} + +fn main() {} diff --git a/tests/ui/transmutability/references/reject_lifetime_extension.rs b/tests/ui/transmutability/references/reject_lifetime_extension.rs new file mode 100644 index 000000000000..79bb4e1e5569 --- /dev/null +++ b/tests/ui/transmutability/references/reject_lifetime_extension.rs @@ -0,0 +1,91 @@ +//@ check-fail + +//! Reject lifetime extensions. + +#![feature(transmutability, core_intrinsics)] + +use std::mem::{Assume, BikeshedIntrinsicFrom}; + +unsafe fn transmute(src: Src) -> Dst +where + Dst: BikeshedIntrinsicFrom, +{ + core::intrinsics::transmute_unchecked(src) +} + +mod bare { + use super::*; + + fn extend_bare<'a>(src: &'a u8) -> &'static u8 { + unsafe { transmute(src) } //~ ERROR lifetime may not live long enough + } +} + +mod nested { + use super::*; + + fn extend_nested<'a>(src: &'a &'a u8) -> &'a &'static u8 { + unsafe { transmute(src) } //~ ERROR lifetime may not live long enough + } +} + +mod tuple { + use super::*; + + fn extend_unit<'a>(src: (&'a u8,)) -> (&'static u8,) { + unsafe { transmute(src) } //~ ERROR lifetime may not live long enough + } + + fn extend_pair<'a>(src: (&'a u8, u8)) -> (&'static u8, u8) { + unsafe { transmute(src) } //~ ERROR lifetime may not live long enough + } +} + +mod r#struct { + use super::*; + + struct Struct<'a>(&'a u8); + + fn extend_struct<'a>(src: Struct<'a>) -> Struct<'static> { + unsafe { transmute(src) } //~ ERROR lifetime may not live long enough + } +} + +mod r#enum { + use super::*; + + enum Single<'a> { + A(&'a u8), + } + + fn extend_single<'a>(src: Single<'a>) -> Single<'static> { + unsafe { transmute(src) } //~ ERROR lifetime may not live long enough + } + + enum Multi<'a> { + A(&'a u8), + B, + C, + } + + fn extend_multi<'a>(src: Multi<'a>) -> Multi<'static> { + unsafe { transmute(src) } //~ ERROR lifetime may not live long enough + } +} + +mod hrtb { + use super::*; + + fn call_extend_hrtb<'a>(src: &'a u8) -> &'static u8 { + unsafe { extend_hrtb(src) } //~ ERROR borrowed data escapes outside of function + } + + unsafe fn extend_hrtb<'a>(src: &'a u8) -> &'static u8 + where + for<'b> &'b u8: BikeshedIntrinsicFrom<&'a u8>, + { + core::intrinsics::transmute_unchecked(src) + } +} + +fn main() {} diff --git a/tests/ui/transmutability/references/reject_lifetime_extension.stderr b/tests/ui/transmutability/references/reject_lifetime_extension.stderr new file mode 100644 index 000000000000..df1b81f26d2b --- /dev/null +++ b/tests/ui/transmutability/references/reject_lifetime_extension.stderr @@ -0,0 +1,78 @@ +error: lifetime may not live long enough + --> $DIR/reject_lifetime_extension.rs:20:18 + | +LL | fn extend_bare<'a>(src: &'a u8) -> &'static u8 { + | -- lifetime `'a` defined here +LL | unsafe { transmute(src) } + | ^^^^^^^^^^^^^^ returning this value requires that `'a` must outlive `'static` + +error: lifetime may not live long enough + --> $DIR/reject_lifetime_extension.rs:28:18 + | +LL | fn extend_nested<'a>(src: &'a &'a u8) -> &'a &'static u8 { + | -- lifetime `'a` defined here +LL | unsafe { transmute(src) } + | ^^^^^^^^^^^^^^ returning this value requires that `'a` must outlive `'static` + +error: lifetime may not live long enough + --> $DIR/reject_lifetime_extension.rs:36:18 + | +LL | fn extend_unit<'a>(src: (&'a u8,)) -> (&'static u8,) { + | -- lifetime `'a` defined here +LL | unsafe { transmute(src) } + | ^^^^^^^^^^^^^^ returning this value requires that `'a` must outlive `'static` + +error: lifetime may not live long enough + --> $DIR/reject_lifetime_extension.rs:40:18 + | +LL | fn extend_pair<'a>(src: (&'a u8, u8)) -> (&'static u8, u8) { + | -- lifetime `'a` defined here +LL | unsafe { transmute(src) } + | ^^^^^^^^^^^^^^ returning this value requires that `'a` must outlive `'static` + +error: lifetime may not live long enough + --> $DIR/reject_lifetime_extension.rs:50:18 + | +LL | fn extend_struct<'a>(src: Struct<'a>) -> Struct<'static> { + | -- lifetime `'a` defined here +LL | unsafe { transmute(src) } + | ^^^^^^^^^^^^^^ returning this value requires that `'a` must outlive `'static` + +error: lifetime may not live long enough + --> $DIR/reject_lifetime_extension.rs:62:18 + | +LL | fn extend_single<'a>(src: Single<'a>) -> Single<'static> { + | -- lifetime `'a` defined here +LL | unsafe { transmute(src) } + | ^^^^^^^^^^^^^^ returning this value requires that `'a` must outlive `'static` + +error: lifetime may not live long enough + --> $DIR/reject_lifetime_extension.rs:72:18 + | +LL | fn extend_multi<'a>(src: Multi<'a>) -> Multi<'static> { + | -- lifetime `'a` defined here +LL | unsafe { transmute(src) } + | ^^^^^^^^^^^^^^ returning this value requires that `'a` must outlive `'static` + +error[E0521]: borrowed data escapes outside of function + --> $DIR/reject_lifetime_extension.rs:80:18 + | +LL | fn call_extend_hrtb<'a>(src: &'a u8) -> &'static u8 { + | -- --- `src` is a reference that is only valid in the function body + | | + | lifetime `'a` defined here +LL | unsafe { extend_hrtb(src) } + | ^^^^^^^^^^^^^^^^ + | | + | `src` escapes the function body here + | argument requires that `'a` must outlive `'static` + | +note: due to current limitations in the borrow checker, this implies a `'static` lifetime + --> $DIR/reject_lifetime_extension.rs:85:25 + | +LL | for<'b> &'b u8: BikeshedIntrinsicFrom<&'a u8>, + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error: aborting due to 8 previous errors + +For more information about this error, try `rustc --explain E0521`. From 42b9cb1cb508045541a62178835e5884a14dac7b Mon Sep 17 00:00:00 2001 From: Trevor Gross Date: Wed, 7 Aug 2024 02:02:57 -0500 Subject: [PATCH 58/79] Switch to using the v2 resolver in most workspaces Pinning the resolver to v1 was done in 5abff3753a7c ("Explicit set workspace.resolver ...") in order to suppress warnings. Since there is no specific reason not to use the new resolver and since it fixes issues, change to `resolver = "2"` everywhere except library and submodules. --- Cargo.toml | 2 +- .../docker/host-x86_64/test-various/uefi_qemu_test/Cargo.toml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 131feec70abc..d4b84250fc46 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,5 +1,5 @@ [workspace] -resolver = "1" +resolver = "2" members = [ "compiler/rustc", "src/etc/test-float-parse", diff --git a/src/ci/docker/host-x86_64/test-various/uefi_qemu_test/Cargo.toml b/src/ci/docker/host-x86_64/test-various/uefi_qemu_test/Cargo.toml index 2d17cf7d47a8..976245f5bdd0 100644 --- a/src/ci/docker/host-x86_64/test-various/uefi_qemu_test/Cargo.toml +++ b/src/ci/docker/host-x86_64/test-various/uefi_qemu_test/Cargo.toml @@ -4,7 +4,7 @@ version = "0.0.0" edition = "2021" [workspace] -resolver = "1" +resolver = "2" [dependencies] r-efi = "4.1.0" From f69e74e2f50f1a6bf9aa5acb5b91d5da5311ba5c Mon Sep 17 00:00:00 2001 From: Trevor Gross Date: Wed, 7 Aug 2024 02:03:57 -0500 Subject: [PATCH 59/79] Update some dependency versions that allow better licensing With the new resolver, a few dependencies get brought in twice with different licenses. For example, all dependencies from `wasm-tools` gained Apache-2.0 and MIT options, and with the v2 resolver we were using one version from before and one version from after this change. This made tidy's license check difficult. Update some minimum versions to remove duplicate dependencies and smooth out license checking. --- compiler/rustc_codegen_llvm/Cargo.toml | 2 +- compiler/rustc_codegen_ssa/Cargo.toml | 2 +- src/bootstrap/Cargo.toml | 2 +- src/tools/run-make-support/Cargo.toml | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/compiler/rustc_codegen_llvm/Cargo.toml b/compiler/rustc_codegen_llvm/Cargo.toml index dad4722d620f..a93baf88413a 100644 --- a/compiler/rustc_codegen_llvm/Cargo.toml +++ b/compiler/rustc_codegen_llvm/Cargo.toml @@ -12,7 +12,7 @@ bitflags = "2.4.1" itertools = "0.12" libc = "0.2" measureme = "11" -object = { version = "0.36.2", default-features = false, features = ["std", "read"] } +object = { version = "0.36.3", default-features = false, features = ["std", "read"] } rustc-demangle = "0.1.21" rustc_ast = { path = "../rustc_ast" } rustc_attr = { path = "../rustc_attr" } diff --git a/compiler/rustc_codegen_ssa/Cargo.toml b/compiler/rustc_codegen_ssa/Cargo.toml index 0af34a1b9fa6..e3033b332cae 100644 --- a/compiler/rustc_codegen_ssa/Cargo.toml +++ b/compiler/rustc_codegen_ssa/Cargo.toml @@ -41,7 +41,7 @@ tempfile = "3.2" thin-vec = "0.2.12" thorin-dwp = "0.7" tracing = "0.1" -wasm-encoder = "0.210.0" +wasm-encoder = "0.215.0" # tidy-alphabetical-end [target.'cfg(unix)'.dependencies] diff --git a/src/bootstrap/Cargo.toml b/src/bootstrap/Cargo.toml index 84262c115b12..07f7444aaff6 100644 --- a/src/bootstrap/Cargo.toml +++ b/src/bootstrap/Cargo.toml @@ -47,7 +47,7 @@ fd-lock = "4.0" home = "0.5" ignore = "0.4" libc = "0.2" -object = { version = "0.32", default-features = false, features = ["archive", "coff", "read_core", "unaligned"] } +object = { version = "0.36.3", default-features = false, features = ["archive", "coff", "read_core", "unaligned"] } opener = "0.5" semver = "1.0" serde = "1.0" diff --git a/src/tools/run-make-support/Cargo.toml b/src/tools/run-make-support/Cargo.toml index eae6022b803f..1a13d56b0e42 100644 --- a/src/tools/run-make-support/Cargo.toml +++ b/src/tools/run-make-support/Cargo.toml @@ -7,7 +7,7 @@ edition = "2021" bstr = "1.6.0" object = "0.36.2" similar = "2.5.0" -wasmparser = { version = "0.214", default-features = false, features = ["std"] } +wasmparser = { version = "0.215", default-features = false, features = ["std"] } regex = "1.8" # 1.8 to avoid memchr 2.6.0, as 2.5.0 is pinned in the workspace gimli = "0.31.0" build_helper = { path = "../build_helper" } From 7240da01ee4fdc33308e9f869b63449af776040e Mon Sep 17 00:00:00 2001 From: Trevor Gross Date: Wed, 7 Aug 2024 02:09:12 -0500 Subject: [PATCH 60/79] Run `cargo update` with the new v2 resolver v2 resolves some dependencies differently, and we adjusted some dependency versions. Run `cargo update` to make sure everything is in sync. --- Cargo.lock | 659 +++++++++++++++++++-------------------- src/bootstrap/Cargo.lock | 207 ++++++------ 2 files changed, 438 insertions(+), 428 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 3ad21b0abf92..ac347d02af70 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -125,9 +125,9 @@ dependencies = [ [[package]] name = "anstream" -version = "0.6.14" +version = "0.6.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "418c75fa768af9c03be99d17643f93f79bbba589895012a80e3452a19ddda15b" +checksum = "64e15c1ab1f89faffbf04a634d5e1962e9074f2741eef6d97f3c4e322426d526" dependencies = [ "anstyle", "anstyle-parse", @@ -140,42 +140,42 @@ dependencies = [ [[package]] name = "anstyle" -version = "1.0.7" +version = "1.0.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "038dfcf04a5feb68e9c60b21c9625a54c2c0616e79b72b0fd87075a056ae1d1b" +checksum = "1bec1de6f59aedf83baf9ff929c98f2ad654b97c9510f4e70cf6f661d49fd5b1" [[package]] name = "anstyle-lossy" -version = "1.1.1" +version = "1.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6fcff6599f06e21b0165c85052ccd6e67dc388ddd1c516a9dc5f55dc8cacf004" +checksum = "f45c79b3b9413932fc255f2c19ca0d48eaab72c4ea1913bafaebf289cbc099f2" dependencies = [ "anstyle", ] [[package]] name = "anstyle-parse" -version = "0.2.4" +version = "0.2.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c03a11a9034d92058ceb6ee011ce58af4a9bf61491aa7e1e59ecd24bd40d22d4" +checksum = "eb47de1e80c2b463c735db5b217a0ddc39d612e7ac9e2e96a5aed1f57616c1cb" dependencies = [ "utf8parse", ] [[package]] name = "anstyle-query" -version = "1.1.0" +version = "1.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ad186efb764318d35165f1758e7dcef3b10628e26d41a44bc5550652e6804391" +checksum = "6d36fc52c7f6c869915e99412912f22093507da8d9e942ceaf66fe4b7c14422a" dependencies = [ "windows-sys 0.52.0", ] [[package]] name = "anstyle-svg" -version = "0.1.4" +version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bbbf0bf947d663010f0b4132f28ca08da9151f3b9035fa7578a38de521c1d1aa" +checksum = "962f6d5681926dbe5503b71057202d6723a33abe464c983b1d160bca3095a3bb" dependencies = [ "anstream", "anstyle", @@ -186,9 +186,9 @@ dependencies = [ [[package]] name = "anstyle-wincon" -version = "3.0.3" +version = "3.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "61a38449feb7068f52bb06c12759005cf459ee52bb4adc1d5a7c4322d716fb19" +checksum = "5bf74e1b6e971609db8ca7a9ce79fd5768ab6ae46441c572e46cf596f59e57f8" dependencies = [ "anstyle", "windows-sys 0.52.0", @@ -209,14 +209,14 @@ version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "de11a9d32db3327f981143bdf699ade4d637c6887b13b97e6e91a9154666963c" dependencies = [ - "object 0.36.2", + "object 0.36.3", ] [[package]] name = "arrayvec" -version = "0.7.4" +version = "0.7.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711" +checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50" [[package]] name = "autocfg" @@ -271,9 +271,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" [[package]] name = "bitflags" -version = "2.5.0" +version = "2.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1" +checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de" [[package]] name = "block-buffer" @@ -291,7 +291,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6798148dccfbff0fae41c7574d2fa8f1ef3492fba0face179de5d8d447d67b05" dependencies = [ "memchr", - "regex-automata 0.3.7", + "regex-automata 0.3.9", "serde", ] @@ -351,15 +351,15 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" [[package]] name = "bytes" -version = "1.6.0" +version = "1.7.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "514de17de45fdb8dc022b1a7975556c53c86f9f0aa5f534b98977b171857c2c9" +checksum = "8318a53db07bb3f8dca91a600466bdb3f2eaadeedfdbcf02e1accbad9271ba50" [[package]] name = "camino" -version = "1.1.7" +version = "1.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e0ec6b951b160caa93cc0c7b209e5a3bff7aae9062213451ac99493cd844c239" +checksum = "8b96ec4966b5813e2c0507c1f86115c8c5abaadc3980879c3424042a02fd1ad3" dependencies = [ "serde", ] @@ -420,9 +420,12 @@ version = "0.1.0" [[package]] name = "cc" -version = "1.0.99" +version = "1.1.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "96c51067fd44124faa7f870b4b1c969379ad32b2ba805aa959430ceaa384f695" +checksum = "72db2f7947ecee9b03b510377e8bb9077afa27176fdbff55c51027e976fdcc48" +dependencies = [ + "shlex", +] [[package]] name = "cfg-if" @@ -432,9 +435,9 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" [[package]] name = "cfg_aliases" -version = "0.1.1" +version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fd16c4719339c4530435d38e511904438d07cce7950afa3718a84ac36c10e89e" +checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724" [[package]] name = "chrono" @@ -446,7 +449,7 @@ dependencies = [ "iana-time-zone", "num-traits", "serde", - "windows-targets 0.52.5", + "windows-targets 0.52.6", ] [[package]] @@ -483,9 +486,9 @@ dependencies = [ [[package]] name = "clap" -version = "4.5.7" +version = "4.5.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5db83dced34638ad474f39f250d7fea9598bdd239eaced1bdf45d597da0f433f" +checksum = "ed6719fffa43d0d87e5fd8caeab59be1554fb028cd30edc88fc4369b17971019" dependencies = [ "clap_builder", "clap_derive", @@ -503,9 +506,9 @@ dependencies = [ [[package]] name = "clap_builder" -version = "4.5.7" +version = "4.5.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f7e204572485eb3fbf28f871612191521df159bc3e15a9f5064c66dba3a8c05f" +checksum = "216aec2b177652e3846684cbfe25c9964d18ec45234f0f5da5157b207ed1aab6" dependencies = [ "anstream", "anstyle", @@ -516,30 +519,30 @@ dependencies = [ [[package]] name = "clap_complete" -version = "4.5.6" +version = "4.5.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fbca90c87c2a04da41e95d1856e8bcd22f159bdbfa147314d2ce5218057b0e58" +checksum = "1ee158892bd7ce77aa15c208abbdb73e155d191c287a659b57abd5adb92feb03" dependencies = [ "clap", ] [[package]] name = "clap_derive" -version = "4.5.5" +version = "4.5.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c780290ccf4fb26629baa7a1081e68ced113f1d3ec302fa5948f1c381ebf06c6" +checksum = "501d359d5f3dcaf6ecdeee48833ae73ec6e42723a1e52419c79abf9507eec0a0" dependencies = [ "heck 0.5.0", "proc-macro2", "quote", - "syn 2.0.67", + "syn 2.0.75", ] [[package]] name = "clap_lex" -version = "0.7.1" +version = "0.7.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4b82cf0babdbd58558212896d1a4272303a57bdb245c2bf1147185fb45640e70" +checksum = "1462739cb27611015575c0c11df5df7601141071f07518d56fcc1be504cbec97" [[package]] name = "clippy" @@ -559,7 +562,7 @@ dependencies = [ "regex", "rustc_tools_util", "serde", - "syn 2.0.67", + "syn 2.0.75", "tempfile", "termize", "tokio", @@ -671,7 +674,7 @@ dependencies = [ "nom", "proc-macro2", "quote", - "syn 2.0.67", + "syn 2.0.75", ] [[package]] @@ -688,9 +691,9 @@ dependencies = [ [[package]] name = "colorchoice" -version = "1.0.1" +version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0b6a852b24ab71dffc585bcb46eaf7959d175cb865a7152e35b348d1b2960422" +checksum = "d3fd119d74b830634cea2a0f58bbd0d54540518a14397557951e79340abc28c0" [[package]] name = "colored" @@ -750,9 +753,9 @@ dependencies = [ [[package]] name = "core-foundation-sys" -version = "0.8.6" +version = "0.8.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f" +checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" [[package]] name = "coverage-dump" @@ -768,9 +771,9 @@ dependencies = [ [[package]] name = "cpufeatures" -version = "0.2.12" +version = "0.2.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "53fe5e26ff1b7aef8bca9c6080520cfb8d9333c7568e1829cef191a9723e5504" +checksum = "51e852e6dc9a5bed1fae92dd2375037bf2b768725bf3be87811edee3249d09ad" dependencies = [ "libc", ] @@ -830,12 +833,12 @@ dependencies = [ [[package]] name = "ctrlc" -version = "3.4.4" +version = "3.4.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "672465ae37dc1bc6380a6547a8883d5dd397b0f1faaad4f265726cc7042a5345" +checksum = "90eeab0aa92f3f9b4e87f258c72b139c207d251f9cbc1080a0086b86a8870dd3" dependencies = [ "nix", - "windows-sys 0.52.0", + "windows-sys 0.59.0", ] [[package]] @@ -855,9 +858,9 @@ dependencies = [ [[package]] name = "curl-sys" -version = "0.4.72+curl-8.6.0" +version = "0.4.74+curl-8.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "29cbdc8314c447d11e8fd156dcdd031d9e02a7a976163e396b548c03153bc9ea" +checksum = "8af10b986114528fcdc4b63b6f5f021b7057618411046a4de2ba0f0149a097bf" dependencies = [ "cc", "libc", @@ -870,9 +873,9 @@ dependencies = [ [[package]] name = "darling" -version = "0.20.9" +version = "0.20.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "83b2eb4d90d12bdda5ed17de686c2acb4c57914f8f921b8da7e112b5a36f3fe1" +checksum = "6f63b86c8a8826a49b8c21f08a2d07338eec8d900540f8630dc76284be802989" dependencies = [ "darling_core", "darling_macro", @@ -880,27 +883,27 @@ dependencies = [ [[package]] name = "darling_core" -version = "0.20.9" +version = "0.20.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "622687fe0bac72a04e5599029151f5796111b90f1baaa9b544d807a5e31cd120" +checksum = "95133861a8032aaea082871032f5815eb9e98cef03fa916ab4500513994df9e5" dependencies = [ "fnv", "ident_case", "proc-macro2", "quote", "strsim", - "syn 2.0.67", + "syn 2.0.75", ] [[package]] name = "darling_macro" -version = "0.20.9" +version = "0.20.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "733cabb43482b1a1b53eee8583c2b9e8684d592215ea83efd305dd31bc2f0178" +checksum = "d336a2a514f6ccccaa3e09b02d41d35330c07ddf03a62165fcec10bb561c7806" dependencies = [ "darling_core", "quote", - "syn 2.0.67", + "syn 2.0.75", ] [[package]] @@ -926,7 +929,7 @@ version = "0.1.82" dependencies = [ "itertools", "quote", - "syn 2.0.67", + "syn 2.0.75", ] [[package]] @@ -946,7 +949,7 @@ checksum = "62d671cc41a825ebabc75757b62d3d168c577f9149b2d49ece1dad1f72119d25" dependencies = [ "proc-macro2", "quote", - "syn 2.0.67", + "syn 2.0.75", ] [[package]] @@ -967,7 +970,7 @@ dependencies = [ "darling", "proc-macro2", "quote", - "syn 2.0.67", + "syn 2.0.75", ] [[package]] @@ -977,7 +980,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "206868b8242f27cecce124c19fd88157fbd0dd334df2587f36417bafbc85097b" dependencies = [ "derive_builder_core", - "syn 2.0.67", + "syn 2.0.75", ] [[package]] @@ -988,7 +991,7 @@ checksum = "5f33878137e4dafd7fa914ad4e259e18a4e8e532b9617a2d0150262bf53abfce" dependencies = [ "proc-macro2", "quote", - "syn 2.0.67", + "syn 2.0.75", ] [[package]] @@ -1000,7 +1003,7 @@ dependencies = [ "darling", "proc-macro2", "quote", - "syn 2.0.67", + "syn 2.0.75", ] [[package]] @@ -1078,7 +1081,7 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0" dependencies = [ "proc-macro2", "quote", - "syn 2.0.67", + "syn 2.0.75", ] [[package]] @@ -1089,9 +1092,9 @@ checksum = "59f8e79d1fbf76bdfbde321e902714bf6c49df88a7dda6fc682fc2979226962d" [[package]] name = "either" -version = "1.12.0" +version = "1.13.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3dca9240753cf90908d7e4aac30f630662b02aebaa1b58a3cadabdb23385b58b" +checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0" [[package]] name = "elasticlunr-rs" @@ -1131,9 +1134,9 @@ checksum = "a357d28ed41a50f9c765dbfe56cbc04a64e53e5fc58ba79fbc34c10ef3df831f" [[package]] name = "env_filter" -version = "0.1.0" +version = "0.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a009aa4810eb158359dda09d0c87378e4bbb89b5a801f016885a4707ba24f7ea" +checksum = "4f2c92ceda6ceec50f43169f9ee8424fe2db276791afde7b2cd8bc084cb376ab" dependencies = [ "log", "regex", @@ -1141,9 +1144,9 @@ dependencies = [ [[package]] name = "env_logger" -version = "0.11.3" +version = "0.11.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "38b35839ba51819680ba087cd351788c9a3c476841207e0b8cee0b04722343b9" +checksum = "e13fa619b91fb2381732789fc5de83b45675e882f66623b7d8cb4f643017018d" dependencies = [ "anstream", "anstyle", @@ -1219,21 +1222,21 @@ dependencies = [ [[package]] name = "filetime" -version = "0.2.23" +version = "0.2.24" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1ee447700ac8aa0b2f2bd7bc4462ad686ba06baa6727ac149a2d6277f0d240fd" +checksum = "bf401df4a4e3872c4fe8151134cf483738e74b67fc934d6532c882b3d24a4550" dependencies = [ "cfg-if", "libc", - "redox_syscall 0.4.1", - "windows-sys 0.52.0", + "libredox", + "windows-sys 0.59.0", ] [[package]] name = "flate2" -version = "1.0.30" +version = "1.0.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5f54427cfd1c7829e2a139fcefea601bf088ebca651d2bf53ebc600eac295dae" +checksum = "7f211bbe8e69bbd0cfdea405084f128ae8b4aaa6b0b522fc8f2b009084797920" dependencies = [ "crc32fast", "miniz_oxide", @@ -1369,7 +1372,7 @@ checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac" dependencies = [ "proc-macro2", "quote", - "syn 2.0.67", + "syn 2.0.75", ] [[package]] @@ -1587,7 +1590,7 @@ dependencies = [ "markup5ever", "proc-macro2", "quote", - "syn 2.0.67", + "syn 2.0.75", ] [[package]] @@ -1719,7 +1722,7 @@ checksum = "1ec89e9337638ecdc08744df490b221a7399bf8d164eb52a665454e60e075ad6" dependencies = [ "proc-macro2", "quote", - "syn 2.0.67", + "syn 2.0.75", ] [[package]] @@ -1856,9 +1859,9 @@ dependencies = [ [[package]] name = "is_terminal_polyfill" -version = "1.70.0" +version = "1.70.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8478577c03552c21db0e2724ffb8986a5ce7af88107e6be5d2ee6e158c12800" +checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf" [[package]] name = "itertools" @@ -1887,18 +1890,18 @@ dependencies = [ [[package]] name = "jobserver" -version = "0.1.31" +version = "0.1.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d2b099aaa34a9751c5bf0878add70444e1ed2dd73f347be99003d4577277de6e" +checksum = "48d1dbcbbeb6a7fec7e059840aa538bd62aaccf972c7346c4d9d2059312853d0" dependencies = [ "libc", ] [[package]] name = "js-sys" -version = "0.3.69" +version = "0.3.70" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "29c15563dc2726973df627357ce0c9ddddbea194836909d655df6a75d2cf296d" +checksum = "1868808506b929d7b0cfa8f75951347aa71bb21144b7791bae35d9bccfcfe37a" dependencies = [ "wasm-bindgen", ] @@ -1965,9 +1968,9 @@ checksum = "baff4b617f7df3d896f97fe922b64817f6cd9a756bb81d40f8883f2f66dcb401" [[package]] name = "libc" -version = "0.2.155" +version = "0.2.157" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c" +checksum = "374af5f94e54fa97cf75e945cce8a6b201e88a1a07e688b47dfd2a59c66dbd86" [[package]] name = "libdbus-sys" @@ -2000,12 +2003,12 @@ dependencies = [ [[package]] name = "libloading" -version = "0.8.3" +version = "0.8.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c2a198fb6b0eada2a8df47933734e6d35d350665a33a3593d7164fa52c75c19" +checksum = "4979f22fdb869068da03c9f7528f8297c6fd2606bc3a4affe42e6a823fdb8da4" dependencies = [ "cfg-if", - "windows-targets 0.52.5", + "windows-targets 0.52.6", ] [[package]] @@ -2020,15 +2023,16 @@ version = "0.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.6.0", "libc", + "redox_syscall", ] [[package]] name = "libz-sys" -version = "1.1.18" +version = "1.1.19" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c15da26e5af7e25c90b37a2d75cdbf940cf4a55316de9d84c679c9b8bfabf82e" +checksum = "fdc53a7799a7496ebc9fd29f31f7df80e83c9bda5299768af5f9e59eeea74647" dependencies = [ "cc", "libc", @@ -2092,9 +2096,9 @@ dependencies = [ [[package]] name = "log" -version = "0.4.21" +version = "0.4.22" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c" +checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24" [[package]] name = "lzma-sys" @@ -2169,7 +2173,7 @@ dependencies = [ "log", "memchr", "once_cell", - "opener 0.7.1", + "opener 0.7.2", "pulldown-cmark 0.10.3", "regex", "serde", @@ -2226,9 +2230,9 @@ checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a" [[package]] name = "mime_guess" -version = "2.0.4" +version = "2.0.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4192263c238a5f0d0c6bfd21f336a313a4ce1c450542449ca191bb657b4642ef" +checksum = "f7c44f8e672c00fe5308fa235f821cb4198414e1c77935c1ab6948d3fd78550e" dependencies = [ "mime", "unicase", @@ -2301,11 +2305,11 @@ checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086" [[package]] name = "nix" -version = "0.28.0" +version = "0.29.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ab2156c4fce2f8df6c499cc1c763e4394b7482525bf2a9701c9d79d215f519e4" +checksum = "71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.6.0", "cfg-if", "cfg_aliases", "libc", @@ -2323,11 +2327,11 @@ dependencies = [ [[package]] name = "normpath" -version = "1.2.0" +version = "1.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5831952a9476f2fed74b77d74182fa5ddc4d21c72ec45a333b250e3ed0272804" +checksum = "c8911957c4b1549ac0dc74e30db9c8b0e66ddcd6d7acc33098f4c63a64a6d7ed" dependencies = [ - "windows-sys 0.52.0", + "windows-sys 0.59.0", ] [[package]] @@ -2342,11 +2346,11 @@ dependencies = [ [[package]] name = "nu-ansi-term" -version = "0.50.0" +version = "0.50.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dd2800e1520bdc966782168a627aa5d1ad92e33b984bf7c7615d31280c83ff14" +checksum = "d4a28e057d01f97e61255210fcff094d74ed0466038633e95017f5beb68e4399" dependencies = [ - "windows-sys 0.48.0", + "windows-sys 0.52.0", ] [[package]] @@ -2460,9 +2464,9 @@ dependencies = [ [[package]] name = "object" -version = "0.36.2" +version = "0.36.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3f203fa8daa7bb185f760ae12bd8e097f63d17041dcdcaf675ac54cdf863170e" +checksum = "27b64972346851a39438c60b341ebc01bba47464ae329e55cf343eb93964efd9" dependencies = [ "crc32fast", "flate2", @@ -2470,7 +2474,7 @@ dependencies = [ "indexmap", "memchr", "ruzstd 0.7.0", - "wasmparser 0.214.0", + "wasmparser", ] [[package]] @@ -2513,14 +2517,14 @@ dependencies = [ [[package]] name = "opener" -version = "0.7.1" +version = "0.7.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8df34be653210fbe9ffaff41d3b92721c56ce82dfee58ee684f9afb5e3a90c0" +checksum = "d0812e5e4df08da354c851a3376fead46db31c2214f849d3de356d774d057681" dependencies = [ "bstr", "dbus", "normpath", - "windows-sys 0.52.0", + "windows-sys 0.59.0", ] [[package]] @@ -2531,9 +2535,9 @@ checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf" [[package]] name = "openssl-sys" -version = "0.9.102" +version = "0.9.103" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c597637d56fbc83893a35eb0dd04b2b8e7a50c91e64e9493e398b5df4fb45fa2" +checksum = "7f9e8deee91df40a943c71b917e5874b951d32a802526c85721ce3b776c929d6" dependencies = [ "cc", "libc", @@ -2621,9 +2625,9 @@ checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8" dependencies = [ "cfg-if", "libc", - "redox_syscall 0.5.2", + "redox_syscall", "smallvec", - "windows-targets 0.52.5", + "windows-targets 0.52.6", ] [[package]] @@ -2658,9 +2662,9 @@ dependencies = [ [[package]] name = "pest" -version = "2.7.10" +version = "2.7.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "560131c633294438da9f7c4b08189194b20946c8274c6b9e38881a7874dc8ee8" +checksum = "cd53dff83f26735fdc1ca837098ccf133605d794cdae66acfc2bfac3ec809d95" dependencies = [ "memchr", "thiserror", @@ -2669,9 +2673,9 @@ dependencies = [ [[package]] name = "pest_derive" -version = "2.7.10" +version = "2.7.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "26293c9193fbca7b1a3bf9b79dc1e388e927e6cacaa78b4a3ab705a1d3d41459" +checksum = "2a548d2beca6773b1c244554d36fcf8548a8a58e74156968211567250e48e49a" dependencies = [ "pest", "pest_generator", @@ -2679,22 +2683,22 @@ dependencies = [ [[package]] name = "pest_generator" -version = "2.7.10" +version = "2.7.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3ec22af7d3fb470a85dd2ca96b7c577a1eb4ef6f1683a9fe9a8c16e136c04687" +checksum = "3c93a82e8d145725dcbaf44e5ea887c8a869efdcc28706df2d08c69e17077183" dependencies = [ "pest", "pest_meta", "proc-macro2", "quote", - "syn 2.0.67", + "syn 2.0.75", ] [[package]] name = "pest_meta" -version = "2.7.10" +version = "2.7.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d7a240022f37c361ec1878d646fc5b7d7c4d28d5946e1a80ad5a7a4f4ca0bdcd" +checksum = "a941429fea7e08bedec25e4f6785b6ffaacc6b755da98df5ef3e7dcf4a124c4f" dependencies = [ "once_cell", "pest", @@ -2789,9 +2793,9 @@ dependencies = [ [[package]] name = "portable-atomic" -version = "1.6.0" +version = "1.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7170ef9988bc169ba16dd36a7fa041e5c4cbeb6a35b76d4c03daded371eae7c0" +checksum = "da544ee218f0d287a911e9c99a39a8c9bc8fcad3cb8db5959940044ecfc67265" [[package]] name = "powerfmt" @@ -2801,9 +2805,12 @@ checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391" [[package]] name = "ppv-lite86" -version = "0.2.17" +version = "0.2.20" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de" +checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04" +dependencies = [ + "zerocopy", +] [[package]] name = "precomputed-hash" @@ -2861,7 +2868,7 @@ version = "0.9.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "57206b407293d2bcd3af849ce869d52068623f19e1b5ff8e8778e3309439682b" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.6.0", "memchr", "unicase", ] @@ -2872,7 +2879,7 @@ version = "0.10.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "76979bea66e7875e7509c4ec5300112b316af87fa7a252ca91c448b32dfe3993" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.6.0", "memchr", "pulldown-cmark-escape 0.10.1", "unicase", @@ -2880,11 +2887,11 @@ dependencies = [ [[package]] name = "pulldown-cmark" -version = "0.11.0" +version = "0.11.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8746739f11d39ce5ad5c2520a9b75285310dbfe78c541ccf832d38615765aec0" +checksum = "cb4e75767fbc9d92b90e4d0c011f61358cde9513b31ef07ea3631b15ffc3b4fd" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.6.0", "memchr", "pulldown-cmark-escape 0.11.0", "unicase", @@ -2984,20 +2991,11 @@ dependencies = [ [[package]] name = "redox_syscall" -version = "0.4.1" +version = "0.5.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa" +checksum = "2a908a6e00f1fdd0dfd9c0eb08ce85126f6d8bbda50017e74bc4a4b7d4a926a4" dependencies = [ - "bitflags 1.3.2", -] - -[[package]] -name = "redox_syscall" -version = "0.5.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c82cf8cff14456045f55ec4241383baeff27af886adb72ffb2162f99911de0fd" -dependencies = [ - "bitflags 2.5.0", + "bitflags 2.6.0", ] [[package]] @@ -3013,13 +3011,12 @@ dependencies = [ [[package]] name = "regex" -version = "1.9.4" +version = "1.8.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "12de2eff854e5fa4b1295edd650e227e9d8fb0c9e90b12e7f36d6a6811791a29" +checksum = "d0ab3ca65655bb1e41f2a8c8cd662eb4fb035e67c3f78da1d61dffe89d07300f" dependencies = [ "aho-corasick", "memchr", - "regex-automata 0.3.7", "regex-syntax 0.7.5", ] @@ -3043,14 +3040,9 @@ dependencies = [ [[package]] name = "regex-automata" -version = "0.3.7" +version = "0.3.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "49530408a136e16e5b486e883fbb6ba058e8e4e8ae6621a77b048b314336e629" -dependencies = [ - "aho-corasick", - "memchr", - "regex-syntax 0.7.5", -] +checksum = "59b23e92ee4318893fa3fe3e6fb365258efbfe6ac6ab30f090cdcbb7aa37efa9" [[package]] name = "regex-lite" @@ -3120,7 +3112,7 @@ dependencies = [ "quote", "rinja_parser", "serde", - "syn 2.0.67", + "syn 2.0.75", ] [[package]] @@ -3147,11 +3139,11 @@ dependencies = [ "bstr", "build_helper", "gimli 0.31.0", - "object 0.36.2", + "object 0.36.3", "regex", "serde_json", "similar", - "wasmparser 0.214.0", + "wasmparser", ] [[package]] @@ -3235,7 +3227,7 @@ checksum = "e5c9f15eec8235d7cb775ee6f81891db79b98fd54ba1ad8fae565b88ef1ae4e2" name = "rustc_abi" version = "0.0.0" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.6.0", "rand", "rand_xoshiro", "rustc_data_structures", @@ -3247,9 +3239,9 @@ dependencies = [ [[package]] name = "rustc_apfloat" -version = "0.2.0+llvm-462a31f5a5ab" +version = "0.2.1+llvm-462a31f5a5ab" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "465187772033a5ee566f69fe008df03628fce549a0899aae76f0a0c2e34696be" +checksum = "886d94c63c812a8037c4faca2607453a0fa4cf82f734665266876b022244543f" dependencies = [ "bitflags 1.3.2", "smallvec", @@ -3266,7 +3258,7 @@ dependencies = [ name = "rustc_ast" version = "0.0.0" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.6.0", "memchr", "rustc_ast_ir", "rustc_data_structures", @@ -3428,11 +3420,11 @@ dependencies = [ name = "rustc_codegen_llvm" version = "0.0.0" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.6.0", "itertools", "libc", "measureme", - "object 0.36.2", + "object 0.36.3", "rustc-demangle", "rustc_ast", "rustc_attr", @@ -3465,13 +3457,13 @@ version = "0.0.0" dependencies = [ "ar_archive_writer", "arrayvec", - "bitflags 2.5.0", + "bitflags 2.6.0", "cc", "either", "itertools", "jobserver", "libc", - "object 0.36.2", + "object 0.36.3", "pathdiff", "regex", "rustc_arena", @@ -3501,7 +3493,7 @@ dependencies = [ "thin-vec", "thorin-dwp", "tracing", - "wasm-encoder 0.210.0", + "wasm-encoder", "windows 0.52.0", ] @@ -3535,7 +3527,7 @@ name = "rustc_data_structures" version = "0.0.0" dependencies = [ "arrayvec", - "bitflags 2.5.0", + "bitflags 2.6.0", "either", "elsa", "ena", @@ -3715,7 +3707,7 @@ dependencies = [ "fluent-syntax", "proc-macro2", "quote", - "syn 2.0.67", + "syn 2.0.75", "unic-langid", ] @@ -3849,7 +3841,7 @@ version = "0.0.0" dependencies = [ "proc-macro2", "quote", - "syn 2.0.67", + "syn 2.0.75", ] [[package]] @@ -3998,7 +3990,7 @@ version = "0.0.0" dependencies = [ "proc-macro2", "quote", - "syn 2.0.67", + "syn 2.0.75", "synstructure", ] @@ -4006,7 +3998,7 @@ dependencies = [ name = "rustc_metadata" version = "0.0.0" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.6.0", "libloading", "odht", "rustc_ast", @@ -4036,7 +4028,7 @@ dependencies = [ name = "rustc_middle" version = "0.0.0" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.6.0", "derive-where", "either", "field-offset", @@ -4167,7 +4159,7 @@ dependencies = [ name = "rustc_next_trait_solver" version = "0.0.0" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.6.0", "derive-where", "rustc_ast_ir", "rustc_data_structures", @@ -4183,7 +4175,7 @@ dependencies = [ name = "rustc_parse" version = "0.0.0" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.6.0", "rustc_ast", "rustc_ast_pretty", "rustc_data_structures", @@ -4321,8 +4313,8 @@ dependencies = [ name = "rustc_resolve" version = "0.0.0" dependencies = [ - "bitflags 2.5.0", - "pulldown-cmark 0.11.0", + "bitflags 2.6.0", + "pulldown-cmark 0.11.2", "rustc_arena", "rustc_ast", "rustc_ast_pretty", @@ -4349,7 +4341,7 @@ dependencies = [ name = "rustc_sanitizers" version = "0.0.0" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.6.0", "rustc_data_structures", "rustc_hir", "rustc_middle", @@ -4375,7 +4367,7 @@ dependencies = [ name = "rustc_session" version = "0.0.0" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.6.0", "getopts", "libc", "rustc_ast", @@ -4454,8 +4446,8 @@ dependencies = [ name = "rustc_target" version = "0.0.0" dependencies = [ - "bitflags 2.5.0", - "object 0.36.2", + "bitflags 2.6.0", + "object 0.36.3", "rustc_abi", "rustc_data_structures", "rustc_feature", @@ -4557,7 +4549,7 @@ dependencies = [ name = "rustc_type_ir" version = "0.0.0" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.6.0", "derive-where", "indexmap", "rustc_ast_ir", @@ -4577,7 +4569,7 @@ version = "0.0.0" dependencies = [ "proc-macro2", "quote", - "syn 2.0.67", + "syn 2.0.75", "synstructure", ] @@ -4677,7 +4669,7 @@ dependencies = [ "proc-macro2", "quote", "serde", - "syn 2.0.67", + "syn 2.0.75", ] [[package]] @@ -4715,7 +4707,7 @@ version = "0.38.34" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "70dc5ec042f7a43c4a73241207cecc9873a06d45debb38b329f8541d85c2730f" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.6.0", "errno", "libc", "linux-raw-sys", @@ -4811,41 +4803,42 @@ dependencies = [ [[package]] name = "serde" -version = "1.0.203" +version = "1.0.208" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7253ab4de971e72fb7be983802300c30b5a7f0c2e56fab8abfc6a214307c0094" +checksum = "cff085d2cb684faa248efb494c39b68e522822ac0de72ccf08109abde717cfb2" dependencies = [ "serde_derive", ] [[package]] name = "serde_derive" -version = "1.0.203" +version = "1.0.208" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "500cbc0ebeb6f46627f50f3f5811ccf6bf00643be300b4c3eabc0ef55dc5b5ba" +checksum = "24008e81ff7613ed8e5ba0cfaf24e2c2f1e5b8a0495711e44fcd4882fca62bcf" dependencies = [ "proc-macro2", "quote", - "syn 2.0.67", + "syn 2.0.75", ] [[package]] name = "serde_json" -version = "1.0.117" +version = "1.0.125" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "455182ea6142b14f93f4bc5320a2b31c1f266b66a4a5c858b013302a5d8cbfc3" +checksum = "83c8e735a073ccf5be70aa8066aa984eaf2fa000db6c8d0100ae605b366d31ed" dependencies = [ "indexmap", "itoa", + "memchr", "ryu", "serde", ] [[package]] name = "serde_spanned" -version = "0.6.6" +version = "0.6.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "79e674e01f999af37c49f70a6ede167a8a60b2503e56c5599532a65baa5969a0" +checksum = "eb5b1b31579f3811bf615c144393417496f152e12ac8b7663bf664f4a815306d" dependencies = [ "serde", ] @@ -4895,9 +4888,9 @@ checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" [[package]] name = "similar" -version = "2.5.0" +version = "2.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fa42c91313f1d05da9b26f267f931cf178d4aba455b4c4622dd7355eb80c6640" +checksum = "1de1d4f81173b03af4c0cbed3c898f6bff5b870e4a7f5d6f4057d62a7a4b686e" [[package]] name = "siphasher" @@ -5089,9 +5082,9 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.67" +version = "2.0.75" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ff8655ed1d86f3af4ee3fd3263786bc14245ad17c4c7e85ba7187fb3ae028c90" +checksum = "f6af063034fc1935ede7be0122941bafa9bacb949334d090b77ca98b5817c7d9" dependencies = [ "proc-macro2", "quote", @@ -5106,7 +5099,7 @@ checksum = "c8af7666ab7b6390ab78131fb5b0fce11d6b7a6951602017c35fa82800708971" dependencies = [ "proc-macro2", "quote", - "syn 2.0.67", + "syn 2.0.75", ] [[package]] @@ -5143,14 +5136,15 @@ dependencies = [ [[package]] name = "tempfile" -version = "3.10.1" +version = "3.12.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "85b77fafb263dd9d05cbeac119526425676db3784113aa9295c88498cbf8bff1" +checksum = "04cbcdd0c794ebb0d4cf35e88edd2f7d2c4c3e9a5a6dab322839b321c6a87a64" dependencies = [ "cfg-if", "fastrand", + "once_cell", "rustix", - "windows-sys 0.52.0", + "windows-sys 0.59.0", ] [[package]] @@ -5223,22 +5217,22 @@ checksum = "a38c90d48152c236a3ab59271da4f4ae63d678c5d7ad6b7714d7cb9760be5e4b" [[package]] name = "thiserror" -version = "1.0.61" +version = "1.0.63" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c546c80d6be4bc6a00c0f01730c08df82eaa7a7a61f11d656526506112cc1709" +checksum = "c0342370b38b6a11b6cc11d6a805569958d54cfa061a29969c3b5ce2ea405724" dependencies = [ "thiserror-impl", ] [[package]] name = "thiserror-impl" -version = "1.0.61" +version = "1.0.63" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "46c3384250002a6d5af4d114f2845d37b57521033f30d5c3f46c4d70e1197533" +checksum = "a4558b58466b9ad7ca0f102865eccc95938dca1a74a856f2b57b6629050da261" dependencies = [ "proc-macro2", "quote", - "syn 2.0.67", + "syn 2.0.75", ] [[package]] @@ -5336,9 +5330,9 @@ dependencies = [ [[package]] name = "tinyvec" -version = "1.6.0" +version = "1.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50" +checksum = "445e881f4f6d382d5f27c034e25eb92edd7c784ceab92a0937db7f2e9471b938" dependencies = [ "tinyvec_macros", ] @@ -5351,9 +5345,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" [[package]] name = "tokio" -version = "1.38.0" +version = "1.39.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ba4f4a02a7a80d6f274636f0aa95c7e383b912d41fe721a31f29e29698585a4a" +checksum = "9babc99b9923bfa4804bd74722ff02c0381021eafa4db9949217e3be8e84fff5" dependencies = [ "backtrace", "bytes", @@ -5383,9 +5377,9 @@ dependencies = [ [[package]] name = "toml_datetime" -version = "0.6.6" +version = "0.6.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4badfd56924ae69bcc9039335b2e017639ce3f9b001c393c1b2d1ef846ce2cbf" +checksum = "0dd7358ecb8fc2f8d014bf86f6f638ce72ba252a2c3a2572f2a795f1d23efb41" dependencies = [ "serde", ] @@ -5429,7 +5423,7 @@ checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7" dependencies = [ "proc-macro2", "quote", - "syn 2.0.67", + "syn 2.0.75", ] [[package]] @@ -5488,7 +5482,7 @@ version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b56c62d2c80033cb36fae448730a2f2ef99410fe3ecbffc916681a32f6807dbe" dependencies = [ - "nu-ansi-term 0.50.0", + "nu-ansi-term 0.50.1", "tracing-core", "tracing-log", "tracing-subscriber", @@ -5628,7 +5622,7 @@ checksum = "1ed7f4237ba393424195053097c1516bd4590dc82b84f2f97c5c69e12704555b" dependencies = [ "proc-macro-hack", "quote", - "syn 2.0.67", + "syn 2.0.75", "unic-langid-impl", ] @@ -5757,9 +5751,9 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821" [[package]] name = "uuid" -version = "1.8.0" +version = "1.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a183cf7feeba97b4dd1c0d46788634f6221d87fa961b305bed08c851829efcc0" +checksum = "81dfa00651efa65069b0b6b651f4aaa31ba9e3c3ce0137aaad053604ee7e0314" dependencies = [ "getrandom", ] @@ -5778,9 +5772,9 @@ checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426" [[package]] name = "version_check" -version = "0.9.4" +version = "0.9.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f" +checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" [[package]] name = "walkdir" @@ -5799,35 +5793,42 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" [[package]] -name = "wasm-bindgen" -version = "0.2.92" +name = "wasi-preview1-component-adapter-provider" +version = "23.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8" +checksum = "f91d3d13afef569b9fc80cfbb807c87c16ef49bd3ac1a93285ea6a264b600d2d" + +[[package]] +name = "wasm-bindgen" +version = "0.2.93" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a82edfc16a6c469f5f44dc7b571814045d60404b55a0ee849f9bcfa2e63dd9b5" dependencies = [ "cfg-if", + "once_cell", "wasm-bindgen-macro", ] [[package]] name = "wasm-bindgen-backend" -version = "0.2.92" +version = "0.2.93" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da" +checksum = "9de396da306523044d3302746f1208fa71d7532227f15e347e2d93e4145dd77b" dependencies = [ "bumpalo", "log", "once_cell", "proc-macro2", "quote", - "syn 2.0.67", + "syn 2.0.75", "wasm-bindgen-shared", ] [[package]] name = "wasm-bindgen-macro" -version = "0.2.92" +version = "0.2.93" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726" +checksum = "585c4c91a46b072c92e908d99cb1dcdf95c5218eeb6f3bf1efa991ee7a68cccf" dependencies = [ "quote", "wasm-bindgen-macro-support", @@ -5835,36 +5836,38 @@ dependencies = [ [[package]] name = "wasm-bindgen-macro-support" -version = "0.2.92" +version = "0.2.93" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7" +checksum = "afc340c74d9005395cf9dd098506f7f44e38f2b4a21c6aaacf9a105ea5e1e836" dependencies = [ "proc-macro2", "quote", - "syn 2.0.67", + "syn 2.0.75", "wasm-bindgen-backend", "wasm-bindgen-shared", ] [[package]] name = "wasm-bindgen-shared" -version = "0.2.92" +version = "0.2.93" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96" +checksum = "c62a0a307cb4a311d3a07867860911ca130c3494e8c2719593806c08bc5d0484" [[package]] name = "wasm-component-ld" -version = "0.5.4" +version = "0.5.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "314d932d5e84c9678751b85498b1482b2f32f185744e449d3ce0b1d400376dad" +checksum = "51449c63d1ce69f92b8465a084ed5b91f1a7eb583fa95796650a6bfcffc4f9cb" dependencies = [ "anyhow", "clap", "lexopt", "tempfile", - "wasmparser 0.210.0", + "wasi-preview1-component-adapter-provider", + "wasmparser", "wat", "wit-component", + "wit-parser", ] [[package]] @@ -5876,27 +5879,19 @@ dependencies = [ [[package]] name = "wasm-encoder" -version = "0.210.0" +version = "0.215.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e7e3764d9d6edabd8c9e16195e177be0d20f6ab942ad18af52860f12f82bc59a" -dependencies = [ - "leb128", -] - -[[package]] -name = "wasm-encoder" -version = "0.211.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5e7d931a1120ef357f32b74547646b6fa68ea25e377772b72874b131a9ed70d4" +checksum = "4fb56df3e06b8e6b77e37d2969a50ba51281029a9aeb3855e76b7f49b6418847" dependencies = [ "leb128", + "wasmparser", ] [[package]] name = "wasm-metadata" -version = "0.210.0" +version = "0.215.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "012729d1294907fcb0866f08460ab95426a6d0b176a599619b84cac7653452b4" +checksum = "0c6bb07c5576b608f7a2a9baa2294c1a3584a249965d695a9814a496cb6d232f" dependencies = [ "anyhow", "indexmap", @@ -5904,52 +5899,42 @@ dependencies = [ "serde_derive", "serde_json", "spdx", - "wasm-encoder 0.210.0", - "wasmparser 0.210.0", + "wasm-encoder", + "wasmparser", ] [[package]] name = "wasmparser" -version = "0.210.0" +version = "0.215.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a7bbcd21e7581619d9f6ca00f8c4f08f1cacfe58bf63f83af57cd0476f1026f5" +checksum = "53fbde0881f24199b81cf49b6ff8f9c145ac8eb1b7fc439adb5c099734f7d90e" dependencies = [ "ahash", - "bitflags 2.5.0", + "bitflags 2.6.0", "hashbrown", "indexmap", "semver", "serde", ] -[[package]] -name = "wasmparser" -version = "0.214.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5309c1090e3e84dad0d382f42064e9933fdaedb87e468cc239f0eabea73ddcb6" -dependencies = [ - "bitflags 2.5.0", - "indexmap", -] - [[package]] name = "wast" -version = "211.0.1" +version = "215.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b25506dd82d00da6b14a87436b3d52b1d264083fa79cdb72a0d1b04a8595ccaa" +checksum = "1ff1d00d893593249e60720be04a7c1f42f1c4dc3806a2869f4e66ab61eb54cb" dependencies = [ "bumpalo", "leb128", "memchr", "unicode-width", - "wasm-encoder 0.211.1", + "wasm-encoder", ] [[package]] name = "wat" -version = "1.211.1" +version = "1.215.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eb716ca6c86eecac2d82541ffc39860118fc0af9309c4f2670637bea2e1bdd7d" +checksum = "670bf4d9c8cf76ae242d70ded47c546525b6dafaa6871f9bcb065344bf2b4e3d" dependencies = [ "wast", ] @@ -5972,11 +5957,11 @@ checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" [[package]] name = "winapi-util" -version = "0.1.8" +version = "0.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4d4cc384e1e73b93bafa6fb4f1df8c41695c8a91cf9c4c64358067d15a7b6c6b" +checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb" dependencies = [ - "windows-sys 0.52.0", + "windows-sys 0.59.0", ] [[package]] @@ -5992,7 +5977,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e48a53791691ab099e5e2ad123536d0fff50652600abaf43bbf952894110d0be" dependencies = [ "windows-core 0.52.0", - "windows-targets 0.52.5", + "windows-targets 0.52.6", ] [[package]] @@ -6002,7 +5987,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "12342cb4d8e3b046f3d80effd474a7a02447231330ef77d71daa6fbc40681143" dependencies = [ "windows-core 0.57.0", - "windows-targets 0.52.5", + "windows-targets 0.52.6", ] [[package]] @@ -6015,7 +6000,7 @@ dependencies = [ "rayon", "serde", "serde_json", - "syn 2.0.67", + "syn 2.0.75", "windows-metadata", ] @@ -6025,7 +6010,7 @@ version = "0.52.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9" dependencies = [ - "windows-targets 0.52.5", + "windows-targets 0.52.6", ] [[package]] @@ -6037,7 +6022,7 @@ dependencies = [ "windows-implement", "windows-interface", "windows-result", - "windows-targets 0.52.5", + "windows-targets 0.52.6", ] [[package]] @@ -6048,7 +6033,7 @@ checksum = "9107ddc059d5b6fbfbffdfa7a7fe3e22a226def0b2608f72e9d552763d3e1ad7" dependencies = [ "proc-macro2", "quote", - "syn 2.0.67", + "syn 2.0.75", ] [[package]] @@ -6059,7 +6044,7 @@ checksum = "29bee4b38ea3cde66011baa44dba677c432a78593e202392d1e9070cf2a7fca7" dependencies = [ "proc-macro2", "quote", - "syn 2.0.67", + "syn 2.0.75", ] [[package]] @@ -6074,7 +6059,7 @@ version = "0.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5e383302e8ec8515204254685643de10811af0ed97ea37210dc26fb0032647f8" dependencies = [ - "windows-targets 0.52.5", + "windows-targets 0.52.6", ] [[package]] @@ -6092,7 +6077,16 @@ version = "0.52.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" dependencies = [ - "windows-targets 0.52.5", + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-sys" +version = "0.59.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" +dependencies = [ + "windows-targets 0.52.6", ] [[package]] @@ -6112,18 +6106,18 @@ dependencies = [ [[package]] name = "windows-targets" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6f0713a46559409d202e70e28227288446bf7841d3211583a4b53e3f6d96e7eb" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" dependencies = [ - "windows_aarch64_gnullvm 0.52.5", - "windows_aarch64_msvc 0.52.5", - "windows_i686_gnu 0.52.5", + "windows_aarch64_gnullvm 0.52.6", + "windows_aarch64_msvc 0.52.6", + "windows_i686_gnu 0.52.6", "windows_i686_gnullvm", - "windows_i686_msvc 0.52.5", - "windows_x86_64_gnu 0.52.5", - "windows_x86_64_gnullvm 0.52.5", - "windows_x86_64_msvc 0.52.5", + "windows_i686_msvc 0.52.6", + "windows_x86_64_gnu 0.52.6", + "windows_x86_64_gnullvm 0.52.6", + "windows_x86_64_msvc 0.52.6", ] [[package]] @@ -6134,9 +6128,9 @@ checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8" [[package]] name = "windows_aarch64_gnullvm" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7088eed71e8b8dda258ecc8bac5fb1153c5cffaf2578fc8ff5d61e23578d3263" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" [[package]] name = "windows_aarch64_msvc" @@ -6146,9 +6140,9 @@ checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc" [[package]] name = "windows_aarch64_msvc" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9985fd1504e250c615ca5f281c3f7a6da76213ebd5ccc9561496568a2752afb6" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" [[package]] name = "windows_i686_gnu" @@ -6158,15 +6152,15 @@ checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e" [[package]] name = "windows_i686_gnu" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "88ba073cf16d5372720ec942a8ccbf61626074c6d4dd2e745299726ce8b89670" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" [[package]] name = "windows_i686_gnullvm" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "87f4261229030a858f36b459e748ae97545d6f1ec60e5e0d6a3d32e0dc232ee9" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" [[package]] name = "windows_i686_msvc" @@ -6176,9 +6170,9 @@ checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406" [[package]] name = "windows_i686_msvc" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "db3c2bf3d13d5b658be73463284eaf12830ac9a26a90c717b7f771dfe97487bf" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" [[package]] name = "windows_x86_64_gnu" @@ -6188,9 +6182,9 @@ checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e" [[package]] name = "windows_x86_64_gnu" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4e4246f76bdeff09eb48875a0fd3e2af6aada79d409d33011886d3e1581517d9" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" [[package]] name = "windows_x86_64_gnullvm" @@ -6200,9 +6194,9 @@ checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc" [[package]] name = "windows_x86_64_gnullvm" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "852298e482cd67c356ddd9570386e2862b5673c85bd5f88df9ab6802b334c596" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" [[package]] name = "windows_x86_64_msvc" @@ -6212,9 +6206,9 @@ checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538" [[package]] name = "windows_x86_64_msvc" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bec47e5bfd1bff0eeaf6d8b485cc1074891a197ab4225d504cb7a1ab88b02bf0" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" [[package]] name = "winnow" @@ -6227,28 +6221,28 @@ dependencies = [ [[package]] name = "wit-component" -version = "0.210.0" +version = "0.215.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a450bdb5d032acf1fa0865451fa0c6f50e62f2d31eaa8dba967c2e2d068694a4" +checksum = "f725e3885fc5890648be5c5cbc1353b755dc932aa5f1aa7de968b912a3280743" dependencies = [ "anyhow", - "bitflags 2.5.0", + "bitflags 2.6.0", "indexmap", "log", "serde", "serde_derive", "serde_json", - "wasm-encoder 0.210.0", + "wasm-encoder", "wasm-metadata", - "wasmparser 0.210.0", + "wasmparser", "wit-parser", ] [[package]] name = "wit-parser" -version = "0.210.0" +version = "0.215.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "60a965cbd439af19a4b44a54a97ab8957d86f02d01320efc9e31c1d3605c6710" +checksum = "935a97eaffd57c3b413aa510f8f0b550a4a9fe7d59e79cd8b89a83dcb860321f" dependencies = [ "anyhow", "id-arena", @@ -6259,7 +6253,7 @@ dependencies = [ "serde_derive", "serde_json", "unicode-xid", - "wasmparser 0.210.0", + "wasmparser", ] [[package]] @@ -6317,28 +6311,29 @@ checksum = "28cc31741b18cb6f1d5ff12f5b7523e3d6eb0852bbbad19d73905511d9849b95" dependencies = [ "proc-macro2", "quote", - "syn 2.0.67", + "syn 2.0.75", "synstructure", ] [[package]] name = "zerocopy" -version = "0.7.34" +version = "0.7.35" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ae87e3fcd617500e5d106f0380cf7b77f3c6092aae37191433159dda23cfb087" +checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0" dependencies = [ + "byteorder", "zerocopy-derive", ] [[package]] name = "zerocopy-derive" -version = "0.7.34" +version = "0.7.35" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "15e934569e47891f7d9411f1a451d947a60e000ab3bd24fbb970f000387d1b3b" +checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e" dependencies = [ "proc-macro2", "quote", - "syn 2.0.67", + "syn 2.0.75", ] [[package]] @@ -6358,15 +6353,15 @@ checksum = "0ea7b4a3637ea8669cedf0f1fd5c286a17f3de97b8dd5a70a6c167a1730e63a5" dependencies = [ "proc-macro2", "quote", - "syn 2.0.67", + "syn 2.0.75", "synstructure", ] [[package]] name = "zerovec" -version = "0.10.2" +version = "0.10.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bb2cc8827d6c0994478a15c53f374f46fbd41bea663d809b14744bc42e6b109c" +checksum = "aa2b893d79df23bfb12d5461018d408ea19dfafe76c2c7ef6d4eba614f8ff079" dependencies = [ "yoke", "zerofrom", @@ -6375,11 +6370,11 @@ dependencies = [ [[package]] name = "zerovec-derive" -version = "0.10.2" +version = "0.10.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "97cf56601ee5052b4417d90c8755c6683473c926039908196cf35d99f893ebe7" +checksum = "6eafa6dfb17584ea3e2bd6e76e0cc15ad7af12b09abdd1ca55961bed9b1063c6" dependencies = [ "proc-macro2", "quote", - "syn 2.0.67", + "syn 2.0.75", ] diff --git a/src/bootstrap/Cargo.lock b/src/bootstrap/Cargo.lock index 60453764d82d..357c6175152d 100644 --- a/src/bootstrap/Cargo.lock +++ b/src/bootstrap/Cargo.lock @@ -4,30 +4,24 @@ version = 3 [[package]] name = "aho-corasick" -version = "1.1.2" +version = "1.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b2969dcb958b36655471fc61f7e416fa76033bdd4bfed0678d8fee1e2d07a1f0" +checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916" dependencies = [ "memchr", ] [[package]] name = "anstyle" -version = "1.0.4" +version = "1.0.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7079075b41f533b8c61d2a4d073c4676e1f8b249ff94a393b0595db304e0dd87" +checksum = "1bec1de6f59aedf83baf9ff929c98f2ad654b97c9510f4e70cf6f661d49fd5b1" [[package]] name = "bitflags" -version = "1.3.2" +version = "2.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" - -[[package]] -name = "bitflags" -version = "2.4.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "327762f6e5a765692301e5bb513e0d9fef63be86bbc14528052b1cd3e6f03e07" +checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de" [[package]] name = "block-buffer" @@ -71,9 +65,9 @@ dependencies = [ [[package]] name = "bstr" -version = "1.9.0" +version = "1.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c48f0051a4b4c5e0b6d365cd04af53aeaa209e3cc15ec2cdb69e73cc87fbd0dc" +checksum = "40723b8fb387abc38f4f4a37c09073622e41dd12327033091ef8950659e6dc0c" dependencies = [ "memchr", "regex-automata", @@ -102,9 +96,9 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" [[package]] name = "clap" -version = "4.4.13" +version = "4.5.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "52bdc885e4cacc7f7c9eedc1ef6da641603180c783c41a15c264944deeaab642" +checksum = "ed6719fffa43d0d87e5fd8caeab59be1554fb028cd30edc88fc4369b17971019" dependencies = [ "clap_builder", "clap_derive", @@ -112,9 +106,9 @@ dependencies = [ [[package]] name = "clap_builder" -version = "4.4.12" +version = "4.5.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fb7fb5e4e979aec3be7791562fcba452f94ad85e954da024396433e0e25a79e9" +checksum = "216aec2b177652e3846684cbfe25c9964d18ec45234f0f5da5157b207ed1aab6" dependencies = [ "anstyle", "clap_lex", @@ -122,18 +116,18 @@ dependencies = [ [[package]] name = "clap_complete" -version = "4.4.6" +version = "4.5.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "97aeaa95557bd02f23fbb662f981670c3d20c5a26e69f7354b28f57092437fcd" +checksum = "1ee158892bd7ce77aa15c208abbdb73e155d191c287a659b57abd5adb92feb03" dependencies = [ "clap", ] [[package]] name = "clap_derive" -version = "4.4.7" +version = "4.5.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cf9804afaaf59a91e75b022a30fb7229a7901f60c755489cc61c9b423b836442" +checksum = "501d359d5f3dcaf6ecdeee48833ae73ec6e42723a1e52419c79abf9507eec0a0" dependencies = [ "heck", "proc-macro2", @@ -143,9 +137,9 @@ dependencies = [ [[package]] name = "clap_lex" -version = "0.6.0" +version = "0.7.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "702fc72eb24e5a1e48ce58027a675bc24edd52096d5397d4aea7c6dd9eca0bd1" +checksum = "1462739cb27611015575c0c11df5df7601141071f07518d56fcc1be504cbec97" [[package]] name = "cmake" @@ -158,15 +152,15 @@ dependencies = [ [[package]] name = "core-foundation-sys" -version = "0.8.6" +version = "0.8.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f" +checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" [[package]] name = "cpufeatures" -version = "0.2.12" +version = "0.2.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "53fe5e26ff1b7aef8bca9c6080520cfb8d9333c7568e1829cef191a9723e5504" +checksum = "51e852e6dc9a5bed1fae92dd2375037bf2b768725bf3be87811edee3249d09ad" dependencies = [ "libc", ] @@ -224,12 +218,12 @@ dependencies = [ [[package]] name = "errno" -version = "0.3.8" +version = "0.3.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a258e46cdc063eb8519c00b9fc845fc47bcfca4130e2f08e88665ceda8474245" +checksum = "534c5cf6194dfab3db3242765c03bbe257cf92f22b38f6bc0c58d59108a820ba" dependencies = [ "libc", - "windows-sys", + "windows-sys 0.52.0", ] [[package]] @@ -240,19 +234,19 @@ checksum = "7e5768da2206272c81ef0b5e951a41862938a6070da63bcea197899942d3b947" dependencies = [ "cfg-if", "rustix", - "windows-sys", + "windows-sys 0.52.0", ] [[package]] name = "filetime" -version = "0.2.23" +version = "0.2.24" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1ee447700ac8aa0b2f2bd7bc4462ad686ba06baa6727ac149a2d6277f0d240fd" +checksum = "bf401df4a4e3872c4fe8151134cf483738e74b67fc934d6532c882b3d24a4550" dependencies = [ "cfg-if", "libc", - "redox_syscall", - "windows-sys", + "libredox", + "windows-sys 0.59.0", ] [[package]] @@ -280,9 +274,9 @@ dependencies = [ [[package]] name = "heck" -version = "0.4.1" +version = "0.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" [[package]] name = "home" @@ -290,14 +284,14 @@ version = "0.5.9" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e3d1354bf6b7235cb4a0576c2619fd4ed18183f689b12b006a0ee7329eeff9a5" dependencies = [ - "windows-sys", + "windows-sys 0.52.0", ] [[package]] name = "ignore" -version = "0.4.21" +version = "0.4.22" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "747ad1b4ae841a78e8aba0d63adbfbeaea26b517b63705d47856b73015d27060" +checksum = "b46810df39e66e925525d6e38ce1e7f6e1d208f72dc39757880fcb66e2c58af1" dependencies = [ "crossbeam-deque", "globset", @@ -311,9 +305,9 @@ dependencies = [ [[package]] name = "itoa" -version = "1.0.10" +version = "1.0.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b1a46d1a171d865aa5f83f92695765caa047a9b4cbae2cbf37dbd613a793fd4c" +checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b" [[package]] name = "junction" @@ -322,26 +316,37 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1c9c415a9b7b1e86cd5738f39d34c9e78c765da7fb1756dbd7d31b3b0d2e7afa" dependencies = [ "scopeguard", - "windows-sys", + "windows-sys 0.52.0", ] [[package]] name = "libc" -version = "0.2.155" +version = "0.2.157" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c" +checksum = "374af5f94e54fa97cf75e945cce8a6b201e88a1a07e688b47dfd2a59c66dbd86" + +[[package]] +name = "libredox" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d" +dependencies = [ + "bitflags", + "libc", + "redox_syscall", +] [[package]] name = "linux-raw-sys" -version = "0.4.12" +version = "0.4.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c4cd1a83af159aa67994778be9070f0ae1bd732942279cabb14f86f986a21456" +checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89" [[package]] name = "log" -version = "0.4.20" +version = "0.4.22" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f" +checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24" [[package]] name = "lzma-sys" @@ -356,9 +361,9 @@ dependencies = [ [[package]] name = "memchr" -version = "2.7.1" +version = "2.7.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "523dc4f511e55ab87b694dc30d0f820d60906ef06413f93d4d7a1385599cc149" +checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" [[package]] name = "ntapi" @@ -371,9 +376,9 @@ dependencies = [ [[package]] name = "object" -version = "0.32.2" +version = "0.36.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441" +checksum = "27b64972346851a39438c60b341ebc01bba47464ae329e55cf343eb93964efd9" dependencies = [ "memchr", ] @@ -390,9 +395,9 @@ dependencies = [ [[package]] name = "pkg-config" -version = "0.3.28" +version = "0.3.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "69d3587f8a9e599cc7ec2c00e331f71c4e69a5f9a4b8a6efd5b07466b9736f9a" +checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec" [[package]] name = "pretty_assertions" @@ -406,36 +411,36 @@ dependencies = [ [[package]] name = "proc-macro2" -version = "1.0.76" +version = "1.0.86" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "95fc56cda0b5c3325f5fbbd7ff9fda9e02bb00bb3dac51252d2f1bfa1cb8cc8c" +checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77" dependencies = [ "unicode-ident", ] [[package]] name = "quote" -version = "1.0.35" +version = "1.0.36" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef" +checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7" dependencies = [ "proc-macro2", ] [[package]] name = "redox_syscall" -version = "0.4.1" +version = "0.5.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa" +checksum = "2a908a6e00f1fdd0dfd9c0eb08ce85126f6d8bbda50017e74bc4a4b7d4a926a4" dependencies = [ - "bitflags 1.3.2", + "bitflags", ] [[package]] name = "regex-automata" -version = "0.4.3" +version = "0.4.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5f804c7828047e88b2d32e2d7fe5a105da8ee3264f01902f796c8e067dc2483f" +checksum = "38caf58cc5ef2fed281f89292ef23f6365465ed9a41b7a7754eb4e26496c92df" dependencies = [ "aho-corasick", "memchr", @@ -444,28 +449,28 @@ dependencies = [ [[package]] name = "regex-syntax" -version = "0.8.2" +version = "0.8.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f" +checksum = "7a66a03ae7c801facd77a29370b4faec201768915ac14a721ba36f20bc9c209b" [[package]] name = "rustix" -version = "0.38.28" +version = "0.38.34" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "72e572a5e8ca657d7366229cdde4bd14c4eb5499a9573d4d366fe1b599daa316" +checksum = "70dc5ec042f7a43c4a73241207cecc9873a06d45debb38b329f8541d85c2730f" dependencies = [ - "bitflags 2.4.1", + "bitflags", "errno", "libc", "linux-raw-sys", - "windows-sys", + "windows-sys 0.52.0", ] [[package]] name = "ryu" -version = "1.0.16" +version = "1.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f98d2aa92eebf49b69786be48e4477826b256916e84a57ff2a4f21923b48eb4c" +checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f" [[package]] name = "same-file" @@ -484,24 +489,24 @@ checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" [[package]] name = "semver" -version = "1.0.21" +version = "1.0.23" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b97ed7a9823b74f99c7742f5336af7be5ecd3eeafcb1507d1fa93347b1d589b0" +checksum = "61697e0a1c7e512e84a621326239844a24d8207b4669b41bc18b32ea5cbf988b" [[package]] name = "serde" -version = "1.0.195" +version = "1.0.208" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "63261df402c67811e9ac6def069e4786148c4563f4b50fd4bf30aa370d626b02" +checksum = "cff085d2cb684faa248efb494c39b68e522822ac0de72ccf08109abde717cfb2" dependencies = [ "serde_derive", ] [[package]] name = "serde_derive" -version = "1.0.195" +version = "1.0.208" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "46fe8f8603d81ba86327b23a2e9cdf49e1255fb94a4c5f297f6ee0547178ea2c" +checksum = "24008e81ff7613ed8e5ba0cfaf24e2c2f1e5b8a0495711e44fcd4882fca62bcf" dependencies = [ "proc-macro2", "quote", @@ -510,11 +515,12 @@ dependencies = [ [[package]] name = "serde_json" -version = "1.0.111" +version = "1.0.125" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "176e46fa42316f18edd598015a5166857fc835ec732f5215eac6b7bdbf0a84f4" +checksum = "83c8e735a073ccf5be70aa8066aa984eaf2fa000db6c8d0100ae605b366d31ed" dependencies = [ "itoa", + "memchr", "ryu", "serde", ] @@ -532,9 +538,9 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.48" +version = "2.0.75" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0f3531638e407dfc0814761abb7c00a5b54992b849452a0646b7f65c9f770f3f" +checksum = "f6af063034fc1935ede7be0122941bafa9bacb949334d090b77ca98b5817c7d9" dependencies = [ "proc-macro2", "quote", @@ -556,9 +562,9 @@ dependencies = [ [[package]] name = "tar" -version = "0.4.40" +version = "0.4.41" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b16afcea1f22891c49a00c751c7b63b2233284064f11a200fc624137c51e2ddb" +checksum = "cb797dad5fb5b76fcf519e702f4a589483b5ef06567f160c392832c1f5e44909" dependencies = [ "filetime", "libc", @@ -567,9 +573,9 @@ dependencies = [ [[package]] name = "termcolor" -version = "1.4.0" +version = "1.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ff1bc3d3f05aff0403e8ac0d92ced918ec05b666a43f83297ccef5bea8a3d449" +checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755" dependencies = [ "winapi-util", ] @@ -597,15 +603,15 @@ checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b" [[package]] name = "version_check" -version = "0.9.4" +version = "0.9.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f" +checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" [[package]] name = "walkdir" -version = "2.4.0" +version = "2.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d71d857dc86794ca4c280d616f7da00d2dbfd8cd788846559a6813e6aa4b54ee" +checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b" dependencies = [ "same-file", "winapi-util", @@ -629,11 +635,11 @@ checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" [[package]] name = "winapi-util" -version = "0.1.6" +version = "0.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f29e6f9198ba0d26b4c9f07dbe6f9ed633e1f3d5b8b414090084349e46a52596" +checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb" dependencies = [ - "winapi", + "windows-sys 0.59.0", ] [[package]] @@ -723,6 +729,15 @@ dependencies = [ "windows-targets", ] +[[package]] +name = "windows-sys" +version = "0.59.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" +dependencies = [ + "windows-targets", +] + [[package]] name = "windows-targets" version = "0.52.6" @@ -789,9 +804,9 @@ checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" [[package]] name = "xattr" -version = "1.2.0" +version = "1.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "914566e6413e7fa959cc394fb30e563ba80f3541fbd40816d4c05a0fc3f2a0f1" +checksum = "8da84f1a25939b27f6820d92aed108f83ff920fdf11a7b19366c27c4cda81d4f" dependencies = [ "libc", "linux-raw-sys", From b1b1dd17d30c04faed44a7983fbde14f4dbb481b Mon Sep 17 00:00:00 2001 From: Trevor Gross Date: Wed, 7 Aug 2024 02:10:06 -0500 Subject: [PATCH 61/79] Adjust licensing exceptions for WASM components Recent versions of wasm-tools are now Apache-2.0 or MIT or Apache-2.0 with the LLVM exception, rather than strictly Apache-2.0 with the LLVM exception. The only component with the exception has moved to a new dependency `wasi-preview1-component-adapter-provider`. --- src/tools/tidy/src/deps.rs | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/src/tools/tidy/src/deps.rs b/src/tools/tidy/src/deps.rs index 89011bbb48f5..28367f25267f 100644 --- a/src/tools/tidy/src/deps.rs +++ b/src/tools/tidy/src/deps.rs @@ -98,13 +98,7 @@ const EXCEPTIONS: ExceptionList = &[ ("ryu", "Apache-2.0 OR BSL-1.0"), // BSL is not acceptble, but we use it under Apache-2.0 // cargo/... (because of serde) ("self_cell", "Apache-2.0"), // rustc (fluent translations) ("snap", "BSD-3-Clause"), // rustc - ("wasm-encoder", "Apache-2.0 WITH LLVM-exception"), // rustc - ("wasm-metadata", "Apache-2.0 WITH LLVM-exception"), // rustc - ("wasmparser", "Apache-2.0 WITH LLVM-exception"), // rustc - ("wast", "Apache-2.0 WITH LLVM-exception"), // rustc - ("wat", "Apache-2.0 WITH LLVM-exception"), // rustc - ("wit-component", "Apache-2.0 WITH LLVM-exception"), // rustc - ("wit-parser", "Apache-2.0 WITH LLVM-exception"), // rustc + ("wasi-preview1-component-adapter-provider", "Apache-2.0 WITH LLVM-exception"), // rustc // tidy-alphabetical-end ]; From e93e61032962b80747ed869a21e887090ac63c90 Mon Sep 17 00:00:00 2001 From: Ben Kimock Date: Sat, 17 Aug 2024 17:42:20 -0400 Subject: [PATCH 62/79] Grep for enabled and clean up those hits --- tests/debuginfo/associated-types.rs | 4 ---- tests/debuginfo/borrowed-basic.rs | 1 - tests/debuginfo/borrowed-unique-basic.rs | 1 - tests/debuginfo/generic-struct.rs | 4 ---- tests/debuginfo/lexical-scope-with-macro.rs | 3 --- tests/debuginfo/method-on-generic-struct.rs | 4 ---- tests/debuginfo/reference-debuginfo.rs | 1 - tests/debuginfo/union-smoke.rs | 4 ---- 8 files changed, 22 deletions(-) diff --git a/tests/debuginfo/associated-types.rs b/tests/debuginfo/associated-types.rs index bc7a62082b76..f85aa2aca96f 100644 --- a/tests/debuginfo/associated-types.rs +++ b/tests/debuginfo/associated-types.rs @@ -1,7 +1,3 @@ -// Some versions of the non-rust-enabled LLDB print the wrong generic -// parameter type names in this test. -//@ needs-rust-lldb - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/borrowed-basic.rs b/tests/debuginfo/borrowed-basic.rs index 397097cc19b0..a68473030538 100644 --- a/tests/debuginfo/borrowed-basic.rs +++ b/tests/debuginfo/borrowed-basic.rs @@ -61,7 +61,6 @@ // lldbg-check:[...] -1 // lldbr-check:(isize) *int_ref = -1 -// NOTE: only rust-enabled lldb supports 32bit chars // lldbr-command:print *char_ref // lldbr-check:(char) *char_ref = 'a' diff --git a/tests/debuginfo/borrowed-unique-basic.rs b/tests/debuginfo/borrowed-unique-basic.rs index e952ec8cebb5..8059af7dcbbf 100644 --- a/tests/debuginfo/borrowed-unique-basic.rs +++ b/tests/debuginfo/borrowed-unique-basic.rs @@ -66,7 +66,6 @@ // lldbg-check:[...] -1 // lldbr-check:(isize) *int_ref = -1 -// NOTE: only rust-enabled lldb supports 32bit chars // lldbr-command:print *char_ref // lldbr-check:(char) *char_ref = 97 diff --git a/tests/debuginfo/generic-struct.rs b/tests/debuginfo/generic-struct.rs index df01d33a0dc5..2817f8edc150 100644 --- a/tests/debuginfo/generic-struct.rs +++ b/tests/debuginfo/generic-struct.rs @@ -1,7 +1,3 @@ -// Some versions of the non-rust-enabled LLDB print the wrong generic -// parameter type names in this test. -//@ needs-rust-lldb - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/lexical-scope-with-macro.rs b/tests/debuginfo/lexical-scope-with-macro.rs index 7ea3dc62e450..ad70da9e4938 100644 --- a/tests/debuginfo/lexical-scope-with-macro.rs +++ b/tests/debuginfo/lexical-scope-with-macro.rs @@ -1,5 +1,4 @@ //@ min-lldb-version: 310 -//@ ignore-lldb FIXME #48807 //@ compile-flags:-g @@ -88,7 +87,6 @@ // lldbr-check:(i32) b = 34 // lldb-command:continue -// Don't test this with rust-enabled lldb for now; see issue #48807 // lldbg-command:print a // lldbg-check:[...] 110 // lldbg-command:print b @@ -109,7 +107,6 @@ // lldbg-check:[...] 400 // lldbg-command:continue - #![feature(omit_gdb_pretty_printer_section)] #![omit_gdb_pretty_printer_section] diff --git a/tests/debuginfo/method-on-generic-struct.rs b/tests/debuginfo/method-on-generic-struct.rs index c20c1cec9db7..8c2c6a38c269 100644 --- a/tests/debuginfo/method-on-generic-struct.rs +++ b/tests/debuginfo/method-on-generic-struct.rs @@ -1,7 +1,3 @@ -// Some versions of the non-rust-enabled LLDB print the wrong generic -// parameter type names in this test. -//@ needs-rust-lldb - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/reference-debuginfo.rs b/tests/debuginfo/reference-debuginfo.rs index c21a2f01f2f9..b33b148f2232 100644 --- a/tests/debuginfo/reference-debuginfo.rs +++ b/tests/debuginfo/reference-debuginfo.rs @@ -68,7 +68,6 @@ // lldbg-check:[...] -1 // lldbr-check:(isize) *int_ref = -1 -// NOTE: only rust-enabled lldb supports 32bit chars // lldbr-command:print *char_ref // lldbr-check:(char) *char_ref = 'a' diff --git a/tests/debuginfo/union-smoke.rs b/tests/debuginfo/union-smoke.rs index f14437b1c3fb..4a9a91164a3b 100644 --- a/tests/debuginfo/union-smoke.rs +++ b/tests/debuginfo/union-smoke.rs @@ -1,7 +1,5 @@ //@ min-lldb-version: 310 -//@ ignore-gdb-version: 7.11.90 - 7.12.9 - //@ compile-flags:-g // === GDB TESTS =================================================================================== @@ -19,8 +17,6 @@ // lldbg-check:[...] { a = { 0 = '\x02' 1 = '\x02' } b = 514 } // lldbr-check:(union_smoke::U) u = { a = { 0 = '\x02' 1 = '\x02' } b = 514 } -// Don't test this with rust-enabled lldb for now; see -// https://github.com/rust-lang-nursery/lldb/issues/18 // lldbg-command:print union_smoke::SU // lldbg-check:[...] { a = { 0 = '\x01' 1 = '\x01' } b = 257 } From 156088f8a86679ec5a342d5e7ebf17f468c805c1 Mon Sep 17 00:00:00 2001 From: Ben Kimock Date: Sat, 17 Aug 2024 18:00:49 -0400 Subject: [PATCH 63/79] Delete redundant gdb-version requirements and related comments --- tests/debuginfo/basic-types-globals.rs | 4 ---- tests/debuginfo/borrowed-enum.rs | 2 -- tests/debuginfo/coroutine-objects.rs | 2 -- tests/debuginfo/embedded-visualizer.rs | 1 - tests/debuginfo/empty-string.rs | 2 -- tests/debuginfo/gdb-pretty-struct-and-enums.rs | 1 - tests/debuginfo/generic-enum-with-different-disr-sizes.rs | 3 --- tests/debuginfo/generic-struct-style-enum.rs | 3 --- tests/debuginfo/generic-tuple-style-enum.rs | 4 ---- tests/debuginfo/issue-57822.rs | 2 -- tests/debuginfo/numeric-types.rs | 1 - tests/debuginfo/packed-struct.rs | 1 - tests/debuginfo/pretty-huge-vec.rs | 1 - tests/debuginfo/pretty-std-collections.rs | 4 ---- tests/debuginfo/pretty-std.rs | 1 - tests/debuginfo/pretty-uninitialized-vec.rs | 1 - tests/debuginfo/rc_arc.rs | 1 - tests/debuginfo/recursive-struct.rs | 3 --- tests/debuginfo/struct-in-enum.rs | 1 - tests/debuginfo/struct-style-enum.rs | 2 -- tests/debuginfo/tuple-style-enum.rs | 2 -- tests/debuginfo/unique-enum.rs | 2 -- tests/debuginfo/unit-type.rs | 3 --- 23 files changed, 47 deletions(-) diff --git a/tests/debuginfo/basic-types-globals.rs b/tests/debuginfo/basic-types-globals.rs index 515d70e19353..3440dd68ab4f 100644 --- a/tests/debuginfo/basic-types-globals.rs +++ b/tests/debuginfo/basic-types-globals.rs @@ -1,8 +1,4 @@ -// Caveat - gdb doesn't know about UTF-32 character encoding and will print a -// rust char as only its numerical value. - //@ min-lldb-version: 310 -//@ min-gdb-version: 8.0 //@ revisions: lto no-lto diff --git a/tests/debuginfo/borrowed-enum.rs b/tests/debuginfo/borrowed-enum.rs index 444adac8b0aa..2f69742f0d4f 100644 --- a/tests/debuginfo/borrowed-enum.rs +++ b/tests/debuginfo/borrowed-enum.rs @@ -1,5 +1,3 @@ -// Require a gdb or lldb that can read DW_TAG_variant_part. -//@ min-gdb-version: 8.2 //@ min-lldb-version: 1800 //@ compile-flags:-g diff --git a/tests/debuginfo/coroutine-objects.rs b/tests/debuginfo/coroutine-objects.rs index 746b7e40eda5..242c76c2989e 100644 --- a/tests/debuginfo/coroutine-objects.rs +++ b/tests/debuginfo/coroutine-objects.rs @@ -1,5 +1,3 @@ -// Require a gdb that can read DW_TAG_variant_part. -//@ min-gdb-version: 8.2 //@ min-lldb-version: 1800 // LLDB (18.1+) now supports DW_TAG_variant_part, but there is some bug in either compiler or LLDB diff --git a/tests/debuginfo/embedded-visualizer.rs b/tests/debuginfo/embedded-visualizer.rs index 959dbba7fd73..cbd8691394d5 100644 --- a/tests/debuginfo/embedded-visualizer.rs +++ b/tests/debuginfo/embedded-visualizer.rs @@ -1,5 +1,4 @@ //@ compile-flags:-g -//@ min-gdb-version: 8.1 //@ ignore-lldb //@ ignore-windows-gnu: #128981 diff --git a/tests/debuginfo/empty-string.rs b/tests/debuginfo/empty-string.rs index eac3448bfd51..41f7fa941b77 100644 --- a/tests/debuginfo/empty-string.rs +++ b/tests/debuginfo/empty-string.rs @@ -1,8 +1,6 @@ //@ ignore-windows-gnu: #128981 //@ ignore-android: FIXME(#10381) //@ compile-flags:-g -//@ min-gdb-version: 8.1 -//@ ignore-gdb-version: 7.11.90 - 8.0.9 //@ min-lldb-version: 310 // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/gdb-pretty-struct-and-enums.rs b/tests/debuginfo/gdb-pretty-struct-and-enums.rs index 15f0fe8e261f..08e01333a376 100644 --- a/tests/debuginfo/gdb-pretty-struct-and-enums.rs +++ b/tests/debuginfo/gdb-pretty-struct-and-enums.rs @@ -1,6 +1,5 @@ //@ ignore-lldb //@ ignore-android: FIXME(#10381) -//@ min-gdb-version: 8.1 //@ compile-flags:-g diff --git a/tests/debuginfo/generic-enum-with-different-disr-sizes.rs b/tests/debuginfo/generic-enum-with-different-disr-sizes.rs index 03118a11aadd..1f973e10141f 100644 --- a/tests/debuginfo/generic-enum-with-different-disr-sizes.rs +++ b/tests/debuginfo/generic-enum-with-different-disr-sizes.rs @@ -1,9 +1,6 @@ //@ ignore-lldb: FIXME(#27089) //@ min-lldb-version: 310 -// Require a gdb that can read DW_TAG_variant_part. -//@ min-gdb-version: 8.2 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/generic-struct-style-enum.rs b/tests/debuginfo/generic-struct-style-enum.rs index 7be1922d2671..68d44b858090 100644 --- a/tests/debuginfo/generic-struct-style-enum.rs +++ b/tests/debuginfo/generic-struct-style-enum.rs @@ -1,8 +1,5 @@ //@ min-lldb-version: 310 -// Require a gdb that can read DW_TAG_variant_part. -//@ min-gdb-version: 8.2 - //@ compile-flags:-g // gdb-command:set print union on diff --git a/tests/debuginfo/generic-tuple-style-enum.rs b/tests/debuginfo/generic-tuple-style-enum.rs index feb62a1f5d1f..15b9cec071a7 100644 --- a/tests/debuginfo/generic-tuple-style-enum.rs +++ b/tests/debuginfo/generic-tuple-style-enum.rs @@ -1,7 +1,3 @@ -// Require a gdb or lldb that can read DW_TAG_variant_part. -//@ min-gdb-version: 8.2 -//@ needs-rust-lldb - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/issue-57822.rs b/tests/debuginfo/issue-57822.rs index cadd9b542e9c..8a8cf41ab1fb 100644 --- a/tests/debuginfo/issue-57822.rs +++ b/tests/debuginfo/issue-57822.rs @@ -1,8 +1,6 @@ // This test makes sure that the LLDB pretty printer does not throw an exception // for nested closures and coroutines. -// Require a gdb that can read DW_TAG_variant_part. -//@ min-gdb-version: 8.2 //@ min-lldb-version: 1800 //@ compile-flags:-g diff --git a/tests/debuginfo/numeric-types.rs b/tests/debuginfo/numeric-types.rs index 6f45b69e5e34..9d232578979f 100644 --- a/tests/debuginfo/numeric-types.rs +++ b/tests/debuginfo/numeric-types.rs @@ -1,6 +1,5 @@ //@ compile-flags:-g -//@ min-gdb-version: 8.1 //@ ignore-windows-gnu: #128981 // Tests the visualizations for `NonZero`, `Wrapping` and diff --git a/tests/debuginfo/packed-struct.rs b/tests/debuginfo/packed-struct.rs index cfff4c27d705..5b804fa6c1de 100644 --- a/tests/debuginfo/packed-struct.rs +++ b/tests/debuginfo/packed-struct.rs @@ -1,5 +1,4 @@ //@ min-lldb-version: 310 -//@ ignore-gdb-version: 7.11.90 - 7.12.9 //@ compile-flags:-g diff --git a/tests/debuginfo/pretty-huge-vec.rs b/tests/debuginfo/pretty-huge-vec.rs index b88e5db1acb8..874670e58b17 100644 --- a/tests/debuginfo/pretty-huge-vec.rs +++ b/tests/debuginfo/pretty-huge-vec.rs @@ -1,7 +1,6 @@ //@ ignore-windows-gnu: #128981 //@ ignore-android: FIXME(#10381) //@ compile-flags:-g -//@ min-gdb-version: 8.1 //@ min-lldb-version: 310 // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/pretty-std-collections.rs b/tests/debuginfo/pretty-std-collections.rs index 3ec00886e2f4..87b631946f35 100644 --- a/tests/debuginfo/pretty-std-collections.rs +++ b/tests/debuginfo/pretty-std-collections.rs @@ -2,10 +2,6 @@ //@ ignore-windows-gnu: #128981 //@ compile-flags:-g -// The pretty printers being tested here require the patch from -// https://sourceware.org/bugzilla/show_bug.cgi?id=21763 -//@ min-gdb-version: 8.1 - //@ min-lldb-version: 310 // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/pretty-std.rs b/tests/debuginfo/pretty-std.rs index e33d0b237be0..d7c640a5bea3 100644 --- a/tests/debuginfo/pretty-std.rs +++ b/tests/debuginfo/pretty-std.rs @@ -2,7 +2,6 @@ //@ ignore-windows-gnu: #128981 //@ ignore-android: FIXME(#10381) //@ compile-flags:-g -//@ min-gdb-version: 7.7 //@ min-lldb-version: 1800 //@ min-cdb-version: 10.0.18317.1001 diff --git a/tests/debuginfo/pretty-uninitialized-vec.rs b/tests/debuginfo/pretty-uninitialized-vec.rs index ddb751161d8c..0f72f2a5dd26 100644 --- a/tests/debuginfo/pretty-uninitialized-vec.rs +++ b/tests/debuginfo/pretty-uninitialized-vec.rs @@ -1,7 +1,6 @@ //@ ignore-windows-gnu: #128981 //@ ignore-android: FIXME(#10381) //@ compile-flags:-g -//@ min-gdb-version: 8.1 //@ min-lldb-version: 310 // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/rc_arc.rs b/tests/debuginfo/rc_arc.rs index 688dc625ce44..f636c60702cd 100644 --- a/tests/debuginfo/rc_arc.rs +++ b/tests/debuginfo/rc_arc.rs @@ -1,7 +1,6 @@ //@ ignore-windows-gnu: #128981 //@ compile-flags:-g -//@ min-gdb-version: 8.1 //@ min-cdb-version: 10.0.18317.1001 // === GDB TESTS ================================================================================== diff --git a/tests/debuginfo/recursive-struct.rs b/tests/debuginfo/recursive-struct.rs index d6f5b9f2868d..a97eb295eb43 100644 --- a/tests/debuginfo/recursive-struct.rs +++ b/tests/debuginfo/recursive-struct.rs @@ -1,8 +1,5 @@ //@ ignore-lldb -// Require a gdb that can read DW_TAG_variant_part. -//@ min-gdb-version: 8.2 - //@ compile-flags:-g // gdb-command:run diff --git a/tests/debuginfo/struct-in-enum.rs b/tests/debuginfo/struct-in-enum.rs index 8d7ad93e0a21..bc2c59fe4aa9 100644 --- a/tests/debuginfo/struct-in-enum.rs +++ b/tests/debuginfo/struct-in-enum.rs @@ -1,5 +1,4 @@ //@ min-lldb-version: 1800 -//@ ignore-gdb-version: 7.11.90 - 7.12.9 //@ compile-flags:-g diff --git a/tests/debuginfo/struct-style-enum.rs b/tests/debuginfo/struct-style-enum.rs index 7c5846ea350f..c3cfb29994e7 100644 --- a/tests/debuginfo/struct-style-enum.rs +++ b/tests/debuginfo/struct-style-enum.rs @@ -1,5 +1,3 @@ -// Require a gdb or lldb that can read DW_TAG_variant_part. -//@ min-gdb-version: 8.2 //@ min-lldb-version: 1800 //@ compile-flags:-g diff --git a/tests/debuginfo/tuple-style-enum.rs b/tests/debuginfo/tuple-style-enum.rs index f231f3e05987..2a11bfe70656 100644 --- a/tests/debuginfo/tuple-style-enum.rs +++ b/tests/debuginfo/tuple-style-enum.rs @@ -1,5 +1,3 @@ -// Require a gdb or lldb that can read DW_TAG_variant_part. -//@ min-gdb-version: 8.2 //@ min-lldb-version: 1800 //@ compile-flags:-g diff --git a/tests/debuginfo/unique-enum.rs b/tests/debuginfo/unique-enum.rs index fcfbe856123e..6990f18788c7 100644 --- a/tests/debuginfo/unique-enum.rs +++ b/tests/debuginfo/unique-enum.rs @@ -1,5 +1,3 @@ -// Require a gdb or lldb that can read DW_TAG_variant_part. -//@ min-gdb-version: 8.2 //@ min-lldb-version: 1800 //@ compile-flags:-g diff --git a/tests/debuginfo/unit-type.rs b/tests/debuginfo/unit-type.rs index 60b105fc53d0..42c0ff11f711 100644 --- a/tests/debuginfo/unit-type.rs +++ b/tests/debuginfo/unit-type.rs @@ -1,8 +1,5 @@ //@ compile-flags:-g -// We only test Rust-aware versions of GDB: -//@ min-gdb-version: 8.2 - // === GDB TESTS =================================================================================== // gdb-command: run From e2523c18427db0a6b28b7dc8c12a5a65011bef49 Mon Sep 17 00:00:00 2001 From: Ben Kimock Date: Sat, 17 Aug 2024 18:09:27 -0400 Subject: [PATCH 64/79] Clean up compiletest --- src/tools/compiletest/src/command-list.rs | 1 - src/tools/compiletest/src/common.rs | 6 ---- src/tools/compiletest/src/header/needs.rs | 7 +---- src/tools/compiletest/src/lib.rs | 36 +++++++---------------- src/tools/compiletest/src/runtest.rs | 20 ++----------- src/tools/compiletest/src/tests.rs | 8 ++--- 6 files changed, 19 insertions(+), 59 deletions(-) diff --git a/src/tools/compiletest/src/command-list.rs b/src/tools/compiletest/src/command-list.rs index 50c909793f5e..e4e6ddcd22cb 100644 --- a/src/tools/compiletest/src/command-list.rs +++ b/src/tools/compiletest/src/command-list.rs @@ -142,7 +142,6 @@ const KNOWN_DIRECTIVE_NAMES: &[&str] = &[ "needs-relocation-model-pic", "needs-run-enabled", "needs-rust-lld", - "needs-rust-lldb", "needs-sanitizer-address", "needs-sanitizer-cfi", "needs-sanitizer-dataflow", diff --git a/src/tools/compiletest/src/common.rs b/src/tools/compiletest/src/common.rs index 70ebefe3f417..5831f7c3cf28 100644 --- a/src/tools/compiletest/src/common.rs +++ b/src/tools/compiletest/src/common.rs @@ -296,15 +296,9 @@ pub struct Config { /// Version of GDB, encoded as ((major * 1000) + minor) * 1000 + patch pub gdb_version: Option, - /// Whether GDB has native rust support - pub gdb_native_rust: bool, - /// Version of LLDB pub lldb_version: Option, - /// Whether LLDB has native rust support - pub lldb_native_rust: bool, - /// Version of LLVM pub llvm_version: Option, diff --git a/src/tools/compiletest/src/header/needs.rs b/src/tools/compiletest/src/header/needs.rs index 5b2665f7d0ba..8f935d5b7444 100644 --- a/src/tools/compiletest/src/header/needs.rs +++ b/src/tools/compiletest/src/header/needs.rs @@ -1,4 +1,4 @@ -use crate::common::{Config, Debugger, Sanitizer}; +use crate::common::{Config, Sanitizer}; use crate::header::IgnoreDecision; pub(super) fn handle_needs( @@ -114,11 +114,6 @@ pub(super) fn handle_needs( condition: cache.rust_lld, ignore_reason: "ignored on targets without Rust's LLD", }, - Need { - name: "needs-rust-lldb", - condition: config.debugger != Some(Debugger::Lldb) || config.lldb_native_rust, - ignore_reason: "ignored on targets without Rust's LLDB", - }, Need { name: "needs-dlltool", condition: cache.dlltool, diff --git a/src/tools/compiletest/src/lib.rs b/src/tools/compiletest/src/lib.rs index 6acf46f91962..7018362af541 100644 --- a/src/tools/compiletest/src/lib.rs +++ b/src/tools/compiletest/src/lib.rs @@ -194,14 +194,8 @@ pub fn parse_config(args: Vec) -> Config { let target = opt_str2(matches.opt_str("target")); let android_cross_path = opt_path(matches, "android-cross-path"); let (cdb, cdb_version) = analyze_cdb(matches.opt_str("cdb"), &target); - let (gdb, gdb_version, gdb_native_rust) = - analyze_gdb(matches.opt_str("gdb"), &target, &android_cross_path); - let (lldb_version, lldb_native_rust) = matches - .opt_str("lldb-version") - .as_deref() - .and_then(extract_lldb_version) - .map(|(v, b)| (Some(v), b)) - .unwrap_or((None, false)); + let (gdb, gdb_version) = analyze_gdb(matches.opt_str("gdb"), &target, &android_cross_path); + let lldb_version = matches.opt_str("lldb-version").as_deref().and_then(extract_lldb_version); let color = match matches.opt_str("color").as_deref() { Some("auto") | None => ColorConfig::AutoColor, Some("always") => ColorConfig::AlwaysColor, @@ -298,9 +292,7 @@ pub fn parse_config(args: Vec) -> Config { cdb_version, gdb, gdb_version, - gdb_native_rust, lldb_version, - lldb_native_rust, llvm_version, system_llvm: matches.opt_present("system-llvm"), android_cross_path, @@ -1035,19 +1027,17 @@ fn extract_cdb_version(full_version_line: &str) -> Option<[u16; 4]> { Some([major, minor, patch, build]) } -/// Returns (Path to GDB, GDB Version, GDB has Rust Support) +/// Returns (Path to GDB, GDB Version) fn analyze_gdb( gdb: Option, target: &str, android_cross_path: &PathBuf, -) -> (Option, Option, bool) { +) -> (Option, Option) { #[cfg(not(windows))] const GDB_FALLBACK: &str = "gdb"; #[cfg(windows)] const GDB_FALLBACK: &str = "gdb.exe"; - const MIN_GDB_WITH_RUST: u32 = 7011010; - let fallback_gdb = || { if is_android_gdb_target(target) { let mut gdb_path = match android_cross_path.to_str() { @@ -1076,12 +1066,10 @@ fn analyze_gdb( let version = match version_line { Some(line) => extract_gdb_version(&line), - None => return (None, None, false), + None => return (None, None), }; - let gdb_native_rust = version.map_or(false, |v| v >= MIN_GDB_WITH_RUST); - - (Some(gdb), version, gdb_native_rust) + (Some(gdb), version) } fn extract_gdb_version(full_version_line: &str) -> Option { @@ -1131,8 +1119,8 @@ fn extract_gdb_version(full_version_line: &str) -> Option { Some(((major * 1000) + minor) * 1000 + patch) } -/// Returns (LLDB version, LLDB is rust-enabled) -fn extract_lldb_version(full_version_line: &str) -> Option<(u32, bool)> { +/// Returns LLDB version +fn extract_lldb_version(full_version_line: &str) -> Option { // Extract the major LLDB version from the given version string. // LLDB version strings are different for Apple and non-Apple platforms. // The Apple variant looks like this: @@ -1149,9 +1137,7 @@ fn extract_lldb_version(full_version_line: &str) -> Option<(u32, bool)> { // There doesn't seem to be a way to correlate the Apple version // with the upstream version, and since the tests were originally // written against Apple versions, we make a fake Apple version by - // multiplying the first number by 100. This is a hack, but - // normally fine because the only non-Apple version we test is - // rust-enabled. + // multiplying the first number by 100. This is a hack. let full_version_line = full_version_line.trim(); @@ -1160,12 +1146,12 @@ fn extract_lldb_version(full_version_line: &str) -> Option<(u32, bool)> { { if let Some(idx) = apple_ver.find(not_a_digit) { let version: u32 = apple_ver[..idx].parse().unwrap(); - return Some((version, full_version_line.contains("rust-enabled"))); + return Some(version); } } else if let Some(lldb_ver) = full_version_line.strip_prefix("lldb version ") { if let Some(idx) = lldb_ver.find(not_a_digit) { let version: u32 = lldb_ver[..idx].parse().ok()?; - return Some((version * 100, full_version_line.contains("rust-enabled"))); + return Some(version * 100); } } None diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs index 394f24e6f359..eca21e559896 100644 --- a/src/tools/compiletest/src/runtest.rs +++ b/src/tools/compiletest/src/runtest.rs @@ -856,12 +856,10 @@ impl<'test> TestCx<'test> { } fn run_debuginfo_gdb_test_no_opt(&self) { - let prefixes = &["gdb"]; - let dbg_cmds = DebuggerCommands::parse_from( &self.testpaths.file, self.config, - prefixes, + &["gdb"], self.revision, ) .unwrap_or_else(|e| self.fatal(&e)); @@ -1043,9 +1041,7 @@ impl<'test> TestCx<'test> { .push_str(&format!("file {}\n", exe_file.to_str().unwrap().replace(r"\", r"\\"))); // Force GDB to print values in the Rust format. - if self.config.gdb_native_rust { - script_str.push_str("set language rust\n"); - } + script_str.push_str("set language rust\n"); // Add line breakpoints for line in &dbg_cmds.breakpoint_lines { @@ -1130,21 +1126,11 @@ impl<'test> TestCx<'test> { } } - let prefixes = if self.config.lldb_native_rust { - static PREFIXES: &[&str] = &["lldb", "lldbr"]; - println!("NOTE: compiletest thinks it is using LLDB with native rust support"); - PREFIXES - } else { - static PREFIXES: &[&str] = &["lldb", "lldbg"]; - println!("NOTE: compiletest thinks it is using LLDB without native rust support"); - PREFIXES - }; - // Parse debugger commands etc from test files let dbg_cmds = DebuggerCommands::parse_from( &self.testpaths.file, self.config, - prefixes, + &["lldb"], self.revision, ) .unwrap_or_else(|e| self.fatal(&e)); diff --git a/src/tools/compiletest/src/tests.rs b/src/tools/compiletest/src/tests.rs index 4292f234adc7..7c2e7b0f023c 100644 --- a/src/tools/compiletest/src/tests.rs +++ b/src/tools/compiletest/src/tests.rs @@ -48,12 +48,12 @@ fn test_extract_gdb_version() { #[test] fn test_extract_lldb_version() { // Apple variants - assert_eq!(extract_lldb_version("LLDB-179.5"), Some((179, false))); - assert_eq!(extract_lldb_version("lldb-300.2.51"), Some((300, false))); + assert_eq!(extract_lldb_version("LLDB-179.5"), Some(179)); + assert_eq!(extract_lldb_version("lldb-300.2.51"), Some(300)); // Upstream versions - assert_eq!(extract_lldb_version("lldb version 6.0.1"), Some((600, false))); - assert_eq!(extract_lldb_version("lldb version 9.0.0"), Some((900, false))); + assert_eq!(extract_lldb_version("lldb version 6.0.1"), Some(600)); + assert_eq!(extract_lldb_version("lldb version 9.0.0"), Some(900)); } #[test] From c5fdc90a733187564c3a5dc2567cdb232738b7f7 Mon Sep 17 00:00:00 2001 From: Ben Kimock Date: Sat, 17 Aug 2024 18:55:13 -0400 Subject: [PATCH 65/79] Delete min-lldb-version: 310 --- tests/debuginfo/basic-types-globals-metadata.rs | 3 +-- tests/debuginfo/basic-types-globals.rs | 2 -- tests/debuginfo/basic-types-metadata.rs | 3 +-- tests/debuginfo/basic-types-mut-globals.rs | 2 -- tests/debuginfo/basic-types.rs | 2 -- tests/debuginfo/borrowed-basic.rs | 1 - tests/debuginfo/borrowed-c-style-enum.rs | 1 - tests/debuginfo/borrowed-struct.rs | 1 - tests/debuginfo/borrowed-tuple.rs | 2 -- tests/debuginfo/borrowed-unique-basic.rs | 2 -- tests/debuginfo/box.rs | 2 -- tests/debuginfo/boxed-struct.rs | 2 -- tests/debuginfo/by-value-self-argument-in-trait-impl.rs | 2 -- tests/debuginfo/c-style-enum-in-composite.rs | 2 -- tests/debuginfo/c-style-enum.rs | 1 - tests/debuginfo/closure-in-generic-function.rs | 2 -- tests/debuginfo/constant-debug-locs.rs | 2 -- tests/debuginfo/constant-in-match-pattern.rs | 2 -- tests/debuginfo/coroutine-locals.rs | 2 -- tests/debuginfo/cross-crate-spans.rs | 2 -- tests/debuginfo/cross-crate-type-uniquing.rs | 2 -- tests/debuginfo/destructured-fn-argument.rs | 2 -- tests/debuginfo/destructured-for-loop-variable.rs | 2 -- tests/debuginfo/destructured-local.rs | 2 -- tests/debuginfo/drop-locations.rs | 1 - tests/debuginfo/empty-string.rs | 1 - tests/debuginfo/enum-thinlto.rs | 2 -- tests/debuginfo/evec-in-struct.rs | 2 -- tests/debuginfo/extern-c-fn.rs | 2 -- tests/debuginfo/function-arguments.rs | 2 -- tests/debuginfo/generic-enum-with-different-disr-sizes.rs | 1 - tests/debuginfo/generic-function.rs | 2 -- tests/debuginfo/generic-functions-nested.rs | 2 -- tests/debuginfo/generic-static-method-on-struct-and-enum.rs | 2 -- tests/debuginfo/generic-struct-style-enum.rs | 2 -- tests/debuginfo/include_string.rs | 1 - tests/debuginfo/issue-13213.rs | 1 - tests/debuginfo/issue-14411.rs | 2 -- tests/debuginfo/issue-22656.rs | 1 - tests/debuginfo/issue-7712.rs | 1 - tests/debuginfo/lexical-scope-in-for-loop.rs | 2 -- tests/debuginfo/lexical-scope-in-if.rs | 2 -- tests/debuginfo/lexical-scope-in-match.rs | 2 -- tests/debuginfo/lexical-scope-in-parameterless-closure.rs | 2 -- tests/debuginfo/lexical-scope-in-stack-closure.rs | 2 -- tests/debuginfo/lexical-scope-in-unconditional-loop.rs | 2 -- tests/debuginfo/lexical-scope-in-unique-closure.rs | 2 -- tests/debuginfo/lexical-scope-in-while.rs | 2 -- tests/debuginfo/lexical-scope-with-macro.rs | 2 -- tests/debuginfo/lexical-scopes-in-block-expression.rs | 2 -- tests/debuginfo/method-on-struct.rs | 2 -- tests/debuginfo/method-on-trait.rs | 2 -- tests/debuginfo/method-on-tuple-struct.rs | 2 -- tests/debuginfo/multi-byte-chars.rs | 2 -- tests/debuginfo/multi-cgu.rs | 3 --- tests/debuginfo/multiple-functions-equal-var-names.rs | 2 -- tests/debuginfo/multiple-functions.rs | 2 -- tests/debuginfo/name-shadowing-and-scope-nesting.rs | 2 -- tests/debuginfo/packed-struct-with-destructor.rs | 2 -- tests/debuginfo/packed-struct.rs | 2 -- tests/debuginfo/pretty-huge-vec.rs | 1 - tests/debuginfo/pretty-std-collections.rs | 2 -- tests/debuginfo/pretty-uninitialized-vec.rs | 1 - tests/debuginfo/reference-debuginfo.rs | 1 - tests/debuginfo/self-in-default-method.rs | 2 -- tests/debuginfo/self-in-generic-default-method.rs | 2 -- tests/debuginfo/shadowed-argument.rs | 2 -- tests/debuginfo/shadowed-variable.rs | 1 - tests/debuginfo/should-fail.rs | 2 -- tests/debuginfo/simple-lexical-scope.rs | 2 -- tests/debuginfo/simple-struct.rs | 2 -- tests/debuginfo/simple-tuple.rs | 2 -- tests/debuginfo/static-method-on-struct-and-enum.rs | 2 -- tests/debuginfo/struct-in-struct.rs | 2 -- tests/debuginfo/struct-namespace.rs | 1 - tests/debuginfo/struct-with-destructor.rs | 2 -- tests/debuginfo/trait-pointers.rs | 2 -- tests/debuginfo/tuple-in-struct.rs | 2 -- tests/debuginfo/tuple-in-tuple.rs | 2 -- tests/debuginfo/tuple-struct.rs | 2 -- tests/debuginfo/union-smoke.rs | 2 -- tests/debuginfo/unreachable-locals.rs | 2 -- tests/debuginfo/var-captured-in-nested-closure.rs | 2 -- tests/debuginfo/var-captured-in-sendable-closure.rs | 2 -- tests/debuginfo/var-captured-in-stack-closure.rs | 2 -- tests/debuginfo/vec-slices.rs | 1 - tests/debuginfo/vec.rs | 2 -- 87 files changed, 2 insertions(+), 158 deletions(-) diff --git a/tests/debuginfo/basic-types-globals-metadata.rs b/tests/debuginfo/basic-types-globals-metadata.rs index 8819db86cede..53fc550a2dc8 100644 --- a/tests/debuginfo/basic-types-globals-metadata.rs +++ b/tests/debuginfo/basic-types-globals-metadata.rs @@ -1,6 +1,5 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g + // gdb-command:run // gdb-command:whatis basic_types_globals_metadata::B // gdb-check:type = bool diff --git a/tests/debuginfo/basic-types-globals.rs b/tests/debuginfo/basic-types-globals.rs index 3440dd68ab4f..41b69939650d 100644 --- a/tests/debuginfo/basic-types-globals.rs +++ b/tests/debuginfo/basic-types-globals.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ revisions: lto no-lto //@ compile-flags:-g diff --git a/tests/debuginfo/basic-types-metadata.rs b/tests/debuginfo/basic-types-metadata.rs index 9bfbdc867011..6b7cfbdebca9 100644 --- a/tests/debuginfo/basic-types-metadata.rs +++ b/tests/debuginfo/basic-types-metadata.rs @@ -1,6 +1,5 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g + // gdb-command:run // gdb-command:whatis unit // gdb-check:type = () diff --git a/tests/debuginfo/basic-types-mut-globals.rs b/tests/debuginfo/basic-types-mut-globals.rs index af0963177f54..f6a2399d230a 100644 --- a/tests/debuginfo/basic-types-mut-globals.rs +++ b/tests/debuginfo/basic-types-mut-globals.rs @@ -4,8 +4,6 @@ // about UTF-32 character encoding and will print a rust char as only // its numerical value. -//@ min-lldb-version: 310 - //@ compile-flags:-g // gdb-command:run diff --git a/tests/debuginfo/basic-types.rs b/tests/debuginfo/basic-types.rs index e78c2746fec8..b032186cf29f 100644 --- a/tests/debuginfo/basic-types.rs +++ b/tests/debuginfo/basic-types.rs @@ -4,8 +4,6 @@ // about UTF-32 character encoding and will print a rust char as only // its numerical value. -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/borrowed-basic.rs b/tests/debuginfo/borrowed-basic.rs index a68473030538..9a1c5472c2e9 100644 --- a/tests/debuginfo/borrowed-basic.rs +++ b/tests/debuginfo/borrowed-basic.rs @@ -1,5 +1,4 @@ //@ compile-flags:-g -//@ min-lldb-version: 310 // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/borrowed-c-style-enum.rs b/tests/debuginfo/borrowed-c-style-enum.rs index 95554211522a..af932fad16a0 100644 --- a/tests/debuginfo/borrowed-c-style-enum.rs +++ b/tests/debuginfo/borrowed-c-style-enum.rs @@ -1,5 +1,4 @@ //@ compile-flags:-g -//@ min-lldb-version: 310 // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/borrowed-struct.rs b/tests/debuginfo/borrowed-struct.rs index f74a6b5796f5..6868290963c9 100644 --- a/tests/debuginfo/borrowed-struct.rs +++ b/tests/debuginfo/borrowed-struct.rs @@ -1,5 +1,4 @@ //@ compile-flags:-g -//@ min-lldb-version: 310 // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/borrowed-tuple.rs b/tests/debuginfo/borrowed-tuple.rs index 8f11f545ca79..ec81e5b607ba 100644 --- a/tests/debuginfo/borrowed-tuple.rs +++ b/tests/debuginfo/borrowed-tuple.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/borrowed-unique-basic.rs b/tests/debuginfo/borrowed-unique-basic.rs index 8059af7dcbbf..2c4492e8eb21 100644 --- a/tests/debuginfo/borrowed-unique-basic.rs +++ b/tests/debuginfo/borrowed-unique-basic.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/box.rs b/tests/debuginfo/box.rs index bc6928ada3a5..248d00687e89 100644 --- a/tests/debuginfo/box.rs +++ b/tests/debuginfo/box.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/boxed-struct.rs b/tests/debuginfo/boxed-struct.rs index d31b912ab8c6..c7a8a4bd3d14 100644 --- a/tests/debuginfo/boxed-struct.rs +++ b/tests/debuginfo/boxed-struct.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/by-value-self-argument-in-trait-impl.rs b/tests/debuginfo/by-value-self-argument-in-trait-impl.rs index 985f84881c72..e23b459a5725 100644 --- a/tests/debuginfo/by-value-self-argument-in-trait-impl.rs +++ b/tests/debuginfo/by-value-self-argument-in-trait-impl.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/c-style-enum-in-composite.rs b/tests/debuginfo/c-style-enum-in-composite.rs index bd025c2ae8c1..5aaa8b8853a7 100644 --- a/tests/debuginfo/c-style-enum-in-composite.rs +++ b/tests/debuginfo/c-style-enum-in-composite.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/c-style-enum.rs b/tests/debuginfo/c-style-enum.rs index d39576bd3878..471449af3dd0 100644 --- a/tests/debuginfo/c-style-enum.rs +++ b/tests/debuginfo/c-style-enum.rs @@ -1,5 +1,4 @@ //@ ignore-aarch64 -//@ min-lldb-version: 310 //@ compile-flags:-g diff --git a/tests/debuginfo/closure-in-generic-function.rs b/tests/debuginfo/closure-in-generic-function.rs index ef0f2b0b464b..d4608dc284a1 100644 --- a/tests/debuginfo/closure-in-generic-function.rs +++ b/tests/debuginfo/closure-in-generic-function.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/constant-debug-locs.rs b/tests/debuginfo/constant-debug-locs.rs index d834d9909859..81115fc3c384 100644 --- a/tests/debuginfo/constant-debug-locs.rs +++ b/tests/debuginfo/constant-debug-locs.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g #![allow(dead_code, unused_variables)] diff --git a/tests/debuginfo/constant-in-match-pattern.rs b/tests/debuginfo/constant-in-match-pattern.rs index f34284be1640..952db216debf 100644 --- a/tests/debuginfo/constant-in-match-pattern.rs +++ b/tests/debuginfo/constant-in-match-pattern.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g #![allow(dead_code, unused_variables)] diff --git a/tests/debuginfo/coroutine-locals.rs b/tests/debuginfo/coroutine-locals.rs index c019998040b9..f3593adc9453 100644 --- a/tests/debuginfo/coroutine-locals.rs +++ b/tests/debuginfo/coroutine-locals.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/cross-crate-spans.rs b/tests/debuginfo/cross-crate-spans.rs index 7344901ec31c..34e3daebb80d 100644 --- a/tests/debuginfo/cross-crate-spans.rs +++ b/tests/debuginfo/cross-crate-spans.rs @@ -1,8 +1,6 @@ #![feature(omit_gdb_pretty_printer_section)] #![omit_gdb_pretty_printer_section] -//@ min-lldb-version: 310 - //@ aux-build:cross_crate_spans.rs extern crate cross_crate_spans; diff --git a/tests/debuginfo/cross-crate-type-uniquing.rs b/tests/debuginfo/cross-crate-type-uniquing.rs index 88f8bac5d6f4..28ebc3438846 100644 --- a/tests/debuginfo/cross-crate-type-uniquing.rs +++ b/tests/debuginfo/cross-crate-type-uniquing.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ aux-build:cross_crate_debuginfo_type_uniquing.rs extern crate cross_crate_debuginfo_type_uniquing; diff --git a/tests/debuginfo/destructured-fn-argument.rs b/tests/debuginfo/destructured-fn-argument.rs index 783cafb43b35..db86fe5b9233 100644 --- a/tests/debuginfo/destructured-fn-argument.rs +++ b/tests/debuginfo/destructured-fn-argument.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/destructured-for-loop-variable.rs b/tests/debuginfo/destructured-for-loop-variable.rs index 7636a8d0ad52..73f03ec40b63 100644 --- a/tests/debuginfo/destructured-for-loop-variable.rs +++ b/tests/debuginfo/destructured-for-loop-variable.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/destructured-local.rs b/tests/debuginfo/destructured-local.rs index 06f1355dcfe6..f4d960f78812 100644 --- a/tests/debuginfo/destructured-local.rs +++ b/tests/debuginfo/destructured-local.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/drop-locations.rs b/tests/debuginfo/drop-locations.rs index 2db087dda796..a55cf7b50a81 100644 --- a/tests/debuginfo/drop-locations.rs +++ b/tests/debuginfo/drop-locations.rs @@ -1,5 +1,4 @@ //@ ignore-android -//@ min-lldb-version: 310 //@ ignore-test: #128971 #![allow(unused)] diff --git a/tests/debuginfo/empty-string.rs b/tests/debuginfo/empty-string.rs index 41f7fa941b77..014465c27cab 100644 --- a/tests/debuginfo/empty-string.rs +++ b/tests/debuginfo/empty-string.rs @@ -1,7 +1,6 @@ //@ ignore-windows-gnu: #128981 //@ ignore-android: FIXME(#10381) //@ compile-flags:-g -//@ min-lldb-version: 310 // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/enum-thinlto.rs b/tests/debuginfo/enum-thinlto.rs index ff39c09e2a5d..d30ff7dde389 100644 --- a/tests/debuginfo/enum-thinlto.rs +++ b/tests/debuginfo/enum-thinlto.rs @@ -1,5 +1,3 @@ -// Require a gdb that can read DW_TAG_variant_part. -//@ min-gdb-version: 8.2 //@ min-lldb-version: 1800 //@ compile-flags:-g -Z thinlto diff --git a/tests/debuginfo/evec-in-struct.rs b/tests/debuginfo/evec-in-struct.rs index 9552dba17f6f..f09471e75305 100644 --- a/tests/debuginfo/evec-in-struct.rs +++ b/tests/debuginfo/evec-in-struct.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/extern-c-fn.rs b/tests/debuginfo/extern-c-fn.rs index b45a073ed050..0531d7461885 100644 --- a/tests/debuginfo/extern-c-fn.rs +++ b/tests/debuginfo/extern-c-fn.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/function-arguments.rs b/tests/debuginfo/function-arguments.rs index b0afa1d07720..bbf397caacd5 100644 --- a/tests/debuginfo/function-arguments.rs +++ b/tests/debuginfo/function-arguments.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/generic-enum-with-different-disr-sizes.rs b/tests/debuginfo/generic-enum-with-different-disr-sizes.rs index 1f973e10141f..e723543a37b2 100644 --- a/tests/debuginfo/generic-enum-with-different-disr-sizes.rs +++ b/tests/debuginfo/generic-enum-with-different-disr-sizes.rs @@ -1,5 +1,4 @@ //@ ignore-lldb: FIXME(#27089) -//@ min-lldb-version: 310 //@ compile-flags:-g diff --git a/tests/debuginfo/generic-function.rs b/tests/debuginfo/generic-function.rs index fce1a3f3ec52..6c1d0d5d7dbd 100644 --- a/tests/debuginfo/generic-function.rs +++ b/tests/debuginfo/generic-function.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/generic-functions-nested.rs b/tests/debuginfo/generic-functions-nested.rs index eee0c1511822..1aac6591738b 100644 --- a/tests/debuginfo/generic-functions-nested.rs +++ b/tests/debuginfo/generic-functions-nested.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/generic-static-method-on-struct-and-enum.rs b/tests/debuginfo/generic-static-method-on-struct-and-enum.rs index 98608e329148..79fe2144cf4b 100644 --- a/tests/debuginfo/generic-static-method-on-struct-and-enum.rs +++ b/tests/debuginfo/generic-static-method-on-struct-and-enum.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // gdb-command:run diff --git a/tests/debuginfo/generic-struct-style-enum.rs b/tests/debuginfo/generic-struct-style-enum.rs index 68d44b858090..a5529ab8027d 100644 --- a/tests/debuginfo/generic-struct-style-enum.rs +++ b/tests/debuginfo/generic-struct-style-enum.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // gdb-command:set print union on diff --git a/tests/debuginfo/include_string.rs b/tests/debuginfo/include_string.rs index 628ac92fe341..3ee02c554cbd 100644 --- a/tests/debuginfo/include_string.rs +++ b/tests/debuginfo/include_string.rs @@ -1,4 +1,3 @@ -//@ min-lldb-version: 310 //@ ignore-gdb-version: 15.0 - 99.0 // ^ test temporarily disabled as it fails under gdb 15 diff --git a/tests/debuginfo/issue-13213.rs b/tests/debuginfo/issue-13213.rs index 7ef9178ce9d9..b43a6f90ffc0 100644 --- a/tests/debuginfo/issue-13213.rs +++ b/tests/debuginfo/issue-13213.rs @@ -1,4 +1,3 @@ -//@ min-lldb-version: 310 //@ ignore-cdb: Fails with exit code 0xc0000135 ("the application failed to initialize properly") //@ aux-build:issue-13213-aux.rs diff --git a/tests/debuginfo/issue-14411.rs b/tests/debuginfo/issue-14411.rs index 3258fec1e870..7da5fb16d44a 100644 --- a/tests/debuginfo/issue-14411.rs +++ b/tests/debuginfo/issue-14411.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // No debugger interaction required: just make sure it compiles without diff --git a/tests/debuginfo/issue-22656.rs b/tests/debuginfo/issue-22656.rs index 5a5442acd95f..199de531d0b4 100644 --- a/tests/debuginfo/issue-22656.rs +++ b/tests/debuginfo/issue-22656.rs @@ -2,7 +2,6 @@ // when trying to handle a Vec<> or anything else that contains zero-sized // fields. -//@ min-lldb-version: 310 //@ ignore-gdb //@ compile-flags:-g diff --git a/tests/debuginfo/issue-7712.rs b/tests/debuginfo/issue-7712.rs index 35e6b10c4e58..11143f79161a 100644 --- a/tests/debuginfo/issue-7712.rs +++ b/tests/debuginfo/issue-7712.rs @@ -1,5 +1,4 @@ //@ compile-flags:-C debuginfo=1 -//@ min-lldb-version: 310 pub trait TraitWithDefaultMethod : Sized { fn method(self) { diff --git a/tests/debuginfo/lexical-scope-in-for-loop.rs b/tests/debuginfo/lexical-scope-in-for-loop.rs index 1b1f106fecec..d5594b6bc62f 100644 --- a/tests/debuginfo/lexical-scope-in-for-loop.rs +++ b/tests/debuginfo/lexical-scope-in-for-loop.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/lexical-scope-in-if.rs b/tests/debuginfo/lexical-scope-in-if.rs index d472a50f6977..e35eb3715a9b 100644 --- a/tests/debuginfo/lexical-scope-in-if.rs +++ b/tests/debuginfo/lexical-scope-in-if.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/lexical-scope-in-match.rs b/tests/debuginfo/lexical-scope-in-match.rs index d5f0fcbe8927..cffda426aefa 100644 --- a/tests/debuginfo/lexical-scope-in-match.rs +++ b/tests/debuginfo/lexical-scope-in-match.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/lexical-scope-in-parameterless-closure.rs b/tests/debuginfo/lexical-scope-in-parameterless-closure.rs index fa2cd281c807..dd6da95d388c 100644 --- a/tests/debuginfo/lexical-scope-in-parameterless-closure.rs +++ b/tests/debuginfo/lexical-scope-in-parameterless-closure.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-C debuginfo=1 // gdb-command:run diff --git a/tests/debuginfo/lexical-scope-in-stack-closure.rs b/tests/debuginfo/lexical-scope-in-stack-closure.rs index 92582e10c42d..51fb16c594fa 100644 --- a/tests/debuginfo/lexical-scope-in-stack-closure.rs +++ b/tests/debuginfo/lexical-scope-in-stack-closure.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/lexical-scope-in-unconditional-loop.rs b/tests/debuginfo/lexical-scope-in-unconditional-loop.rs index b1af018f3eb0..344e1893c865 100644 --- a/tests/debuginfo/lexical-scope-in-unconditional-loop.rs +++ b/tests/debuginfo/lexical-scope-in-unconditional-loop.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/lexical-scope-in-unique-closure.rs b/tests/debuginfo/lexical-scope-in-unique-closure.rs index a08c2af05ccb..443c4209b75b 100644 --- a/tests/debuginfo/lexical-scope-in-unique-closure.rs +++ b/tests/debuginfo/lexical-scope-in-unique-closure.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/lexical-scope-in-while.rs b/tests/debuginfo/lexical-scope-in-while.rs index bd885b5b10c1..864900711a9f 100644 --- a/tests/debuginfo/lexical-scope-in-while.rs +++ b/tests/debuginfo/lexical-scope-in-while.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/lexical-scope-with-macro.rs b/tests/debuginfo/lexical-scope-with-macro.rs index ad70da9e4938..6e8f87cc2d7f 100644 --- a/tests/debuginfo/lexical-scope-with-macro.rs +++ b/tests/debuginfo/lexical-scope-with-macro.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/lexical-scopes-in-block-expression.rs b/tests/debuginfo/lexical-scopes-in-block-expression.rs index 46af09f09343..310e9ae2a93e 100644 --- a/tests/debuginfo/lexical-scopes-in-block-expression.rs +++ b/tests/debuginfo/lexical-scopes-in-block-expression.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/method-on-struct.rs b/tests/debuginfo/method-on-struct.rs index eef1b1043b81..d92259b7ab11 100644 --- a/tests/debuginfo/method-on-struct.rs +++ b/tests/debuginfo/method-on-struct.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/method-on-trait.rs b/tests/debuginfo/method-on-trait.rs index ff4f6c5e131e..b4ff61b38b05 100644 --- a/tests/debuginfo/method-on-trait.rs +++ b/tests/debuginfo/method-on-trait.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/method-on-tuple-struct.rs b/tests/debuginfo/method-on-tuple-struct.rs index cb8014cace5d..0a4beecb0679 100644 --- a/tests/debuginfo/method-on-tuple-struct.rs +++ b/tests/debuginfo/method-on-tuple-struct.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/multi-byte-chars.rs b/tests/debuginfo/multi-byte-chars.rs index 8fb066c71857..2ab98d265b84 100644 --- a/tests/debuginfo/multi-byte-chars.rs +++ b/tests/debuginfo/multi-byte-chars.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // This test checks whether debuginfo generation can handle multi-byte UTF-8 diff --git a/tests/debuginfo/multi-cgu.rs b/tests/debuginfo/multi-cgu.rs index 32fd68958773..69460c40e622 100644 --- a/tests/debuginfo/multi-cgu.rs +++ b/tests/debuginfo/multi-cgu.rs @@ -1,9 +1,6 @@ // This test case makes sure that we get proper break points for binaries // compiled with multiple codegen units. (see #39160) - -//@ min-lldb-version: 310 - //@ compile-flags:-g -Ccodegen-units=2 // === GDB TESTS =============================================================== diff --git a/tests/debuginfo/multiple-functions-equal-var-names.rs b/tests/debuginfo/multiple-functions-equal-var-names.rs index 2d9caf75290a..8ea3d5df2b04 100644 --- a/tests/debuginfo/multiple-functions-equal-var-names.rs +++ b/tests/debuginfo/multiple-functions-equal-var-names.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/multiple-functions.rs b/tests/debuginfo/multiple-functions.rs index 5c01a4270511..c1a357499f0f 100644 --- a/tests/debuginfo/multiple-functions.rs +++ b/tests/debuginfo/multiple-functions.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/name-shadowing-and-scope-nesting.rs b/tests/debuginfo/name-shadowing-and-scope-nesting.rs index 8813793e59e4..1a46a2d3890d 100644 --- a/tests/debuginfo/name-shadowing-and-scope-nesting.rs +++ b/tests/debuginfo/name-shadowing-and-scope-nesting.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/packed-struct-with-destructor.rs b/tests/debuginfo/packed-struct-with-destructor.rs index e3138b1185fa..a7683781b704 100644 --- a/tests/debuginfo/packed-struct-with-destructor.rs +++ b/tests/debuginfo/packed-struct-with-destructor.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/packed-struct.rs b/tests/debuginfo/packed-struct.rs index 5b804fa6c1de..670482ef41e6 100644 --- a/tests/debuginfo/packed-struct.rs +++ b/tests/debuginfo/packed-struct.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/pretty-huge-vec.rs b/tests/debuginfo/pretty-huge-vec.rs index 874670e58b17..093fbc5b12d2 100644 --- a/tests/debuginfo/pretty-huge-vec.rs +++ b/tests/debuginfo/pretty-huge-vec.rs @@ -1,7 +1,6 @@ //@ ignore-windows-gnu: #128981 //@ ignore-android: FIXME(#10381) //@ compile-flags:-g -//@ min-lldb-version: 310 // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/pretty-std-collections.rs b/tests/debuginfo/pretty-std-collections.rs index 87b631946f35..14f64e83cffc 100644 --- a/tests/debuginfo/pretty-std-collections.rs +++ b/tests/debuginfo/pretty-std-collections.rs @@ -2,8 +2,6 @@ //@ ignore-windows-gnu: #128981 //@ compile-flags:-g -//@ min-lldb-version: 310 - // === GDB TESTS =================================================================================== // gdb-command: run diff --git a/tests/debuginfo/pretty-uninitialized-vec.rs b/tests/debuginfo/pretty-uninitialized-vec.rs index 0f72f2a5dd26..cea2f26ef58f 100644 --- a/tests/debuginfo/pretty-uninitialized-vec.rs +++ b/tests/debuginfo/pretty-uninitialized-vec.rs @@ -1,7 +1,6 @@ //@ ignore-windows-gnu: #128981 //@ ignore-android: FIXME(#10381) //@ compile-flags:-g -//@ min-lldb-version: 310 // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/reference-debuginfo.rs b/tests/debuginfo/reference-debuginfo.rs index b33b148f2232..514228c69981 100644 --- a/tests/debuginfo/reference-debuginfo.rs +++ b/tests/debuginfo/reference-debuginfo.rs @@ -3,7 +3,6 @@ // and leaves codegen to create a ladder of allocations so as `*a == b`. // //@ compile-flags:-g -Zmir-enable-passes=+ReferencePropagation,-ConstDebugInfo -//@ min-lldb-version: 310 // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/self-in-default-method.rs b/tests/debuginfo/self-in-default-method.rs index e5a53bb618db..9507e2c04a25 100644 --- a/tests/debuginfo/self-in-default-method.rs +++ b/tests/debuginfo/self-in-default-method.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/self-in-generic-default-method.rs b/tests/debuginfo/self-in-generic-default-method.rs index 8c6abad83771..4cb68f6fed8d 100644 --- a/tests/debuginfo/self-in-generic-default-method.rs +++ b/tests/debuginfo/self-in-generic-default-method.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/shadowed-argument.rs b/tests/debuginfo/shadowed-argument.rs index e7bc731336e5..f85910652c8a 100644 --- a/tests/debuginfo/shadowed-argument.rs +++ b/tests/debuginfo/shadowed-argument.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/shadowed-variable.rs b/tests/debuginfo/shadowed-variable.rs index 3cc5fe14cb2b..87c85a9e1e26 100644 --- a/tests/debuginfo/shadowed-variable.rs +++ b/tests/debuginfo/shadowed-variable.rs @@ -1,4 +1,3 @@ -//@ min-lldb-version: 310 //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/should-fail.rs b/tests/debuginfo/should-fail.rs index 0f153394a442..bc9b83fc2427 100644 --- a/tests/debuginfo/should-fail.rs +++ b/tests/debuginfo/should-fail.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - // == Test [gdb|lldb]-[command|check] are parsed correctly === //@ should-fail //@ needs-run-enabled diff --git a/tests/debuginfo/simple-lexical-scope.rs b/tests/debuginfo/simple-lexical-scope.rs index 4156e68f8b13..148ad589deca 100644 --- a/tests/debuginfo/simple-lexical-scope.rs +++ b/tests/debuginfo/simple-lexical-scope.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/simple-struct.rs b/tests/debuginfo/simple-struct.rs index 77bfb8a0676b..65bfb84cdcd4 100644 --- a/tests/debuginfo/simple-struct.rs +++ b/tests/debuginfo/simple-struct.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags: -g -Zmir-enable-passes=-CheckAlignment // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/simple-tuple.rs b/tests/debuginfo/simple-tuple.rs index eb1d5ab3c3d3..6dadf9236556 100644 --- a/tests/debuginfo/simple-tuple.rs +++ b/tests/debuginfo/simple-tuple.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/static-method-on-struct-and-enum.rs b/tests/debuginfo/static-method-on-struct-and-enum.rs index b4ec45435726..defced1441ca 100644 --- a/tests/debuginfo/static-method-on-struct-and-enum.rs +++ b/tests/debuginfo/static-method-on-struct-and-enum.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/struct-in-struct.rs b/tests/debuginfo/struct-in-struct.rs index 75141e28e498..2e32633fa87e 100644 --- a/tests/debuginfo/struct-in-struct.rs +++ b/tests/debuginfo/struct-in-struct.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/struct-namespace.rs b/tests/debuginfo/struct-namespace.rs index 3cae51e83ddb..83f2962140aa 100644 --- a/tests/debuginfo/struct-namespace.rs +++ b/tests/debuginfo/struct-namespace.rs @@ -1,6 +1,5 @@ //@ ignore-gdb //@ compile-flags:-g -//@ min-lldb-version: 310 // Check that structs get placed in the correct namespace diff --git a/tests/debuginfo/struct-with-destructor.rs b/tests/debuginfo/struct-with-destructor.rs index 17dc6edd3657..05a4b7572831 100644 --- a/tests/debuginfo/struct-with-destructor.rs +++ b/tests/debuginfo/struct-with-destructor.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/trait-pointers.rs b/tests/debuginfo/trait-pointers.rs index 2b4dde4d3a0c..71da71b897ad 100644 --- a/tests/debuginfo/trait-pointers.rs +++ b/tests/debuginfo/trait-pointers.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // gdb-command:run // lldb-command:run diff --git a/tests/debuginfo/tuple-in-struct.rs b/tests/debuginfo/tuple-in-struct.rs index afda586c1544..a74d6203f5f5 100644 --- a/tests/debuginfo/tuple-in-struct.rs +++ b/tests/debuginfo/tuple-in-struct.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // gdb-command:run diff --git a/tests/debuginfo/tuple-in-tuple.rs b/tests/debuginfo/tuple-in-tuple.rs index 24147e6ce0e4..0d7ffc634701 100644 --- a/tests/debuginfo/tuple-in-tuple.rs +++ b/tests/debuginfo/tuple-in-tuple.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/tuple-struct.rs b/tests/debuginfo/tuple-struct.rs index 8c546be07c37..abfbfac22eb8 100644 --- a/tests/debuginfo/tuple-struct.rs +++ b/tests/debuginfo/tuple-struct.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/union-smoke.rs b/tests/debuginfo/union-smoke.rs index 4a9a91164a3b..41bd81c9e8ae 100644 --- a/tests/debuginfo/union-smoke.rs +++ b/tests/debuginfo/union-smoke.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/unreachable-locals.rs b/tests/debuginfo/unreachable-locals.rs index 72effc103913..d4416387e0b9 100644 --- a/tests/debuginfo/unreachable-locals.rs +++ b/tests/debuginfo/unreachable-locals.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g #![allow(unused_variables)] diff --git a/tests/debuginfo/var-captured-in-nested-closure.rs b/tests/debuginfo/var-captured-in-nested-closure.rs index 5183245ad5dc..bed2a57e1f9e 100644 --- a/tests/debuginfo/var-captured-in-nested-closure.rs +++ b/tests/debuginfo/var-captured-in-nested-closure.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/var-captured-in-sendable-closure.rs b/tests/debuginfo/var-captured-in-sendable-closure.rs index 094639ebf20c..59909b758266 100644 --- a/tests/debuginfo/var-captured-in-sendable-closure.rs +++ b/tests/debuginfo/var-captured-in-sendable-closure.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/var-captured-in-stack-closure.rs b/tests/debuginfo/var-captured-in-stack-closure.rs index ca10cdcb518e..5ac804464333 100644 --- a/tests/debuginfo/var-captured-in-stack-closure.rs +++ b/tests/debuginfo/var-captured-in-stack-closure.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== diff --git a/tests/debuginfo/vec-slices.rs b/tests/debuginfo/vec-slices.rs index 18ff6c743228..a84631685280 100644 --- a/tests/debuginfo/vec-slices.rs +++ b/tests/debuginfo/vec-slices.rs @@ -1,4 +1,3 @@ -//@ min-lldb-version: 310 //@ ignore-gdb-version: 15.0 - 99.0 // ^ test temporarily disabled as it fails under gdb 15 diff --git a/tests/debuginfo/vec.rs b/tests/debuginfo/vec.rs index 7b9054639a8d..24b7ae9c3942 100644 --- a/tests/debuginfo/vec.rs +++ b/tests/debuginfo/vec.rs @@ -1,5 +1,3 @@ -//@ min-lldb-version: 310 - //@ compile-flags:-g // === GDB TESTS =================================================================================== From 41d06f41158b9efaaaeed141bd9a8315527410ec Mon Sep 17 00:00:00 2001 From: Ben Kimock Date: Sun, 18 Aug 2024 16:59:58 -0400 Subject: [PATCH 66/79] Delete lldbr annotations --- tests/debuginfo/associated-types.rs | 9 ---- tests/debuginfo/basic-types.rs | 17 ------- tests/debuginfo/borrowed-basic.rs | 16 ------ tests/debuginfo/borrowed-c-style-enum.rs | 3 -- tests/debuginfo/borrowed-enum.rs | 3 -- tests/debuginfo/borrowed-struct.rs | 7 --- tests/debuginfo/borrowed-tuple.rs | 3 -- tests/debuginfo/borrowed-unique-basic.rs | 16 ------ tests/debuginfo/box.rs | 2 - tests/debuginfo/boxed-struct.rs | 2 - .../by-value-self-argument-in-trait-impl.rs | 3 -- tests/debuginfo/c-style-enum-in-composite.rs | 7 --- tests/debuginfo/c-style-enum.rs | 7 --- .../debuginfo/closure-in-generic-function.rs | 4 -- tests/debuginfo/cross-crate-spans.rs | 6 --- tests/debuginfo/destructured-fn-argument.rs | 49 ------------------- .../destructured-for-loop-variable.rs | 24 --------- tests/debuginfo/destructured-local.rs | 43 ---------------- tests/debuginfo/enum-thinlto.rs | 1 - tests/debuginfo/evec-in-struct.rs | 5 -- tests/debuginfo/extern-c-fn.rs | 4 -- tests/debuginfo/function-arguments.rs | 4 -- tests/debuginfo/generic-function.rs | 6 --- tests/debuginfo/generic-functions-nested.rs | 8 --- .../generic-method-on-generic-struct.rs | 19 ------- tests/debuginfo/generic-struct.rs | 4 -- tests/debuginfo/generic-tuple-style-enum.rs | 4 -- tests/debuginfo/include_string.rs | 3 -- tests/debuginfo/issue-22656.rs | 3 -- tests/debuginfo/lexical-scope-in-for-loop.rs | 7 --- tests/debuginfo/lexical-scope-in-if.rs | 16 ------ tests/debuginfo/lexical-scope-in-match.rs | 18 ------- .../lexical-scope-in-stack-closure.rs | 6 --- .../lexical-scope-in-unconditional-loop.rs | 13 ----- .../lexical-scope-in-unique-closure.rs | 6 --- tests/debuginfo/lexical-scope-in-while.rs | 13 ----- tests/debuginfo/lexical-scope-with-macro.rs | 8 --- .../lexical-scopes-in-block-expression.rs | 48 ------------------ tests/debuginfo/method-on-generic-struct.rs | 15 ------ tests/debuginfo/method-on-struct.rs | 15 ------ tests/debuginfo/method-on-trait.rs | 15 ------ tests/debuginfo/method-on-tuple-struct.rs | 15 ------ tests/debuginfo/multi-cgu.rs | 2 - .../multiple-functions-equal-var-names.rs | 3 -- tests/debuginfo/multiple-functions.rs | 3 -- .../name-shadowing-and-scope-nesting.rs | 12 ----- .../packed-struct-with-destructor.rs | 8 --- tests/debuginfo/packed-struct.rs | 6 --- tests/debuginfo/pretty-std-collections.rs | 4 -- tests/debuginfo/reference-debuginfo.rs | 17 ------- .../regression-bad-location-list-67992.rs | 1 - tests/debuginfo/self-in-default-method.rs | 15 ------ .../self-in-generic-default-method.rs | 15 ------ tests/debuginfo/shadowed-argument.rs | 6 --- tests/debuginfo/shadowed-variable.rs | 10 ---- tests/debuginfo/simple-lexical-scope.rs | 7 --- tests/debuginfo/simple-struct.rs | 6 --- tests/debuginfo/simple-tuple.rs | 7 --- .../static-method-on-struct-and-enum.rs | 5 -- tests/debuginfo/struct-in-struct.rs | 8 --- tests/debuginfo/struct-namespace.rs | 4 -- tests/debuginfo/struct-style-enum.rs | 4 -- tests/debuginfo/struct-with-destructor.rs | 4 -- tests/debuginfo/tuple-in-tuple.rs | 7 --- tests/debuginfo/tuple-struct.rs | 6 --- tests/debuginfo/tuple-style-enum.rs | 4 -- tests/debuginfo/union-smoke.rs | 1 - tests/debuginfo/unique-enum.rs | 3 -- .../var-captured-in-nested-closure.rs | 12 ----- .../var-captured-in-sendable-closure.rs | 3 -- .../var-captured-in-stack-closure.rs | 10 ---- tests/debuginfo/vec-slices.rs | 6 --- tests/debuginfo/vec.rs | 1 - 73 files changed, 677 deletions(-) diff --git a/tests/debuginfo/associated-types.rs b/tests/debuginfo/associated-types.rs index f85aa2aca96f..54ea047d36c4 100644 --- a/tests/debuginfo/associated-types.rs +++ b/tests/debuginfo/associated-types.rs @@ -38,41 +38,32 @@ // lldb-command:v arg // lldbg-check:[...] { b = -1, b1 = 0 } -// lldbr-check:(associated_types::Struct) arg = { b = -1, b1 = 0 } // lldb-command:continue // lldb-command:v inferred // lldbg-check:[...] 1 -// lldbr-check:(i64) inferred = 1 // lldb-command:v explicitly // lldbg-check:[...] 1 -// lldbr-check:(i64) explicitly = 1 // lldb-command:continue // lldb-command:v arg // lldbg-check:[...] 2 -// lldbr-check:(i64) arg = 2 // lldb-command:continue // lldb-command:v arg // lldbg-check:[...] (4, 5) -// lldbr-check:((i32, i64)) arg = { = 4 = 5 } // lldb-command:continue // lldb-command:v a // lldbg-check:[...] 6 -// lldbr-check:(i32) a = 6 // lldb-command:v b // lldbg-check:[...] 7 -// lldbr-check:(i64) b = 7 // lldb-command:continue // lldb-command:v a // lldbg-check:[...] 8 -// lldbr-check:(i64) a = 8 // lldb-command:v b // lldbg-check:[...] 9 -// lldbr-check:(i32) b = 9 // lldb-command:continue #![allow(unused_variables)] diff --git a/tests/debuginfo/basic-types.rs b/tests/debuginfo/basic-types.rs index b032186cf29f..656c49ee001b 100644 --- a/tests/debuginfo/basic-types.rs +++ b/tests/debuginfo/basic-types.rs @@ -47,48 +47,31 @@ // lldb-command:run // lldb-command:v b // lldbg-check:[...] false -// lldbr-check:(bool) b = false // lldb-command:v i // lldbg-check:[...] -1 -// lldbr-check:(isize) i = -1 - -// NOTE: only rust-enabled lldb supports 32bit chars -// lldbr-command:print c -// lldbr-check:(char) c = 'a' // lldb-command:v i8 // lldbg-check:[...] 'D' -// lldbr-check:(i8) i8 = 68 // lldb-command:v i16 // lldbg-check:[...] -16 -// lldbr-check:(i16) i16 = -16 // lldb-command:v i32 // lldbg-check:[...] -32 -// lldbr-check:(i32) i32 = -32 // lldb-command:v i64 // lldbg-check:[...] -64 -// lldbr-check:(i64) i64 = -64 // lldb-command:v u // lldbg-check:[...] 1 -// lldbr-check:(usize) u = 1 // lldb-command:v u8 // lldbg-check:[...] 'd' -// lldbr-check:(u8) u8 = 100 // lldb-command:v u16 // lldbg-check:[...] 16 -// lldbr-check:(u16) u16 = 16 // lldb-command:v u32 // lldbg-check:[...] 32 -// lldbr-check:(u32) u32 = 32 // lldb-command:v u64 // lldbg-check:[...] 64 -// lldbr-check:(u64) u64 = 64 // lldb-command:v f32 // lldbg-check:[...] 2.5 -// lldbr-check:(f32) f32 = 2.5 // lldb-command:v f64 // lldbg-check:[...] 3.5 -// lldbr-check:(f64) f64 = 3.5 // === CDB TESTS =================================================================================== diff --git a/tests/debuginfo/borrowed-basic.rs b/tests/debuginfo/borrowed-basic.rs index 9a1c5472c2e9..e51f5912fc21 100644 --- a/tests/debuginfo/borrowed-basic.rs +++ b/tests/debuginfo/borrowed-basic.rs @@ -54,62 +54,46 @@ // lldb-command:run // lldb-command:v *bool_ref // lldbg-check:[...] true -// lldbr-check:(bool) *bool_ref = true // lldb-command:v *int_ref // lldbg-check:[...] -1 -// lldbr-check:(isize) *int_ref = -1 -// lldbr-command:print *char_ref -// lldbr-check:(char) *char_ref = 'a' // lldb-command:v *i8_ref // lldbg-check:[...] 'D' -// lldbr-check:(i8) *i8_ref = 68 // lldb-command:v *i16_ref // lldbg-check:[...] -16 -// lldbr-check:(i16) *i16_ref = -16 // lldb-command:v *i32_ref // lldbg-check:[...] -32 -// lldbr-check:(i32) *i32_ref = -32 // lldb-command:v *i64_ref // lldbg-check:[...] -64 -// lldbr-check:(i64) *i64_ref = -64 // lldb-command:v *uint_ref // lldbg-check:[...] 1 -// lldbr-check:(usize) *uint_ref = 1 // lldb-command:v *u8_ref // lldbg-check:[...] 'd' -// lldbr-check:(u8) *u8_ref = 100 // lldb-command:v *u16_ref // lldbg-check:[...] 16 -// lldbr-check:(u16) *u16_ref = 16 // lldb-command:v *u32_ref // lldbg-check:[...] 32 -// lldbr-check:(u32) *u32_ref = 32 // lldb-command:v *u64_ref // lldbg-check:[...] 64 -// lldbr-check:(u64) *u64_ref = 64 // lldb-command:v *f16_ref // lldbg-check:[...] 1.5 -// lldbr-check:(f16) *f16_ref = 1.5 // lldb-command:v *f32_ref // lldbg-check:[...] 2.5 -// lldbr-check:(f32) *f32_ref = 2.5 // lldb-command:v *f64_ref // lldbg-check:[...] 3.5 -// lldbr-check:(f64) *f64_ref = 3.5 #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/borrowed-c-style-enum.rs b/tests/debuginfo/borrowed-c-style-enum.rs index af932fad16a0..6d771cf67927 100644 --- a/tests/debuginfo/borrowed-c-style-enum.rs +++ b/tests/debuginfo/borrowed-c-style-enum.rs @@ -20,15 +20,12 @@ // lldb-command:v *the_a_ref // lldbg-check:[...] TheA -// lldbr-check:(borrowed_c_style_enum::ABC) *the_a_ref = borrowed_c_style_enum::ABC::TheA // lldb-command:v *the_b_ref // lldbg-check:[...] TheB -// lldbr-check:(borrowed_c_style_enum::ABC) *the_b_ref = borrowed_c_style_enum::ABC::TheB // lldb-command:v *the_c_ref // lldbg-check:[...] TheC -// lldbr-check:(borrowed_c_style_enum::ABC) *the_c_ref = borrowed_c_style_enum::ABC::TheC #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/borrowed-enum.rs b/tests/debuginfo/borrowed-enum.rs index 2f69742f0d4f..8782e28e4ec1 100644 --- a/tests/debuginfo/borrowed-enum.rs +++ b/tests/debuginfo/borrowed-enum.rs @@ -22,13 +22,10 @@ // lldb-command:v *the_a_ref // lldbg-check:(borrowed_enum::ABC) *the_a_ref = { value = { x = 0 y = 8970181431921507452 } $discr$ = 0 } -// lldbr-check:(borrowed_enum::ABC::TheA) *the_a_ref = TheA { TheA: 0, TheB: 8970181431921507452 } // lldb-command:v *the_b_ref // lldbg-check:(borrowed_enum::ABC) *the_b_ref = { value = { 0 = 0 1 = 286331153 2 = 286331153 } $discr$ = 1 } -// lldbr-check:(borrowed_enum::ABC::TheB) *the_b_ref = { = 0 = 286331153 = 286331153 } // lldb-command:v *univariant_ref // lldbg-check:(borrowed_enum::Univariant) *univariant_ref = { value = { 0 = 4820353753753434 } } -// lldbr-check:(borrowed_enum::Univariant) *univariant_ref = { TheOnlyCase = { = 4820353753753434 } } #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/borrowed-struct.rs b/tests/debuginfo/borrowed-struct.rs index 6868290963c9..e9b751465629 100644 --- a/tests/debuginfo/borrowed-struct.rs +++ b/tests/debuginfo/borrowed-struct.rs @@ -32,31 +32,24 @@ // lldb-command:v *stack_val_ref // lldbg-check:[...] { x = 10 y = 23.5 } -// lldbr-check:(borrowed_struct::SomeStruct) *stack_val_ref = (x = 10, y = 23.5) // lldb-command:v *stack_val_interior_ref_1 // lldbg-check:[...] 10 -// lldbr-check:(isize) *stack_val_interior_ref_1 = 10 // lldb-command:v *stack_val_interior_ref_2 // lldbg-check:[...] 23.5 -// lldbr-check:(f64) *stack_val_interior_ref_2 = 23.5 // lldb-command:v *ref_to_unnamed // lldbg-check:[...] { x = 11 y = 24.5 } -// lldbr-check:(borrowed_struct::SomeStruct) *ref_to_unnamed = (x = 11, y = 24.5) // lldb-command:v *unique_val_ref // lldbg-check:[...] { x = 13 y = 26.5 } -// lldbr-check:(borrowed_struct::SomeStruct) *unique_val_ref = (x = 13, y = 26.5) // lldb-command:v *unique_val_interior_ref_1 // lldbg-check:[...] 13 -// lldbr-check:(isize) *unique_val_interior_ref_1 = 13 // lldb-command:v *unique_val_interior_ref_2 // lldbg-check:[...] 26.5 -// lldbr-check:(f64) *unique_val_interior_ref_2 = 26.5 #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/borrowed-tuple.rs b/tests/debuginfo/borrowed-tuple.rs index ec81e5b607ba..720d6048f833 100644 --- a/tests/debuginfo/borrowed-tuple.rs +++ b/tests/debuginfo/borrowed-tuple.rs @@ -20,15 +20,12 @@ // lldb-command:v *stack_val_ref // lldbg-check:[...] { 0 = -14 1 = -19 } -// lldbr-check:((i16, f32)) *stack_val_ref = { 0 = -14 1 = -19 } // lldb-command:v *ref_to_unnamed // lldbg-check:[...] { 0 = -15 1 = -20 } -// lldbr-check:((i16, f32)) *ref_to_unnamed = { 0 = -15 1 = -20 } // lldb-command:v *unique_val_ref // lldbg-check:[...] { 0 = -17 1 = -22 } -// lldbr-check:((i16, f32)) *unique_val_ref = { 0 = -17 1 = -22 } #![allow(unused_variables)] diff --git a/tests/debuginfo/borrowed-unique-basic.rs b/tests/debuginfo/borrowed-unique-basic.rs index 2c4492e8eb21..8b2690e025b0 100644 --- a/tests/debuginfo/borrowed-unique-basic.rs +++ b/tests/debuginfo/borrowed-unique-basic.rs @@ -58,62 +58,46 @@ // lldb-command:v *bool_ref // lldbg-check:[...] true -// lldbr-check:(bool) *bool_ref = true // lldb-command:v *int_ref // lldbg-check:[...] -1 -// lldbr-check:(isize) *int_ref = -1 -// lldbr-command:print *char_ref -// lldbr-check:(char) *char_ref = 97 // lldb-command:v *i8_ref // lldbg-check:[...] 68 -// lldbr-check:(i8) *i8_ref = 68 // lldb-command:v *i16_ref // lldbg-check:[...] -16 -// lldbr-check:(i16) *i16_ref = -16 // lldb-command:v *i32_ref // lldbg-check:[...] -32 -// lldbr-check:(i32) *i32_ref = -32 // lldb-command:v *i64_ref // lldbg-check:[...] -64 -// lldbr-check:(i64) *i64_ref = -64 // lldb-command:v *uint_ref // lldbg-check:[...] 1 -// lldbr-check:(usize) *uint_ref = 1 // lldb-command:v *u8_ref // lldbg-check:[...] 100 -// lldbr-check:(u8) *u8_ref = 100 // lldb-command:v *u16_ref // lldbg-check:[...] 16 -// lldbr-check:(u16) *u16_ref = 16 // lldb-command:v *u32_ref // lldbg-check:[...] 32 -// lldbr-check:(u32) *u32_ref = 32 // lldb-command:v *u64_ref // lldbg-check:[...] 64 -// lldbr-check:(u64) *u64_ref = 64 // lldb-command:v *f16_ref // lldbg-check:[...] 1.5 -// lldbr-check:(f16) *f16_ref = 1.5 // lldb-command:v *f32_ref // lldbg-check:[...] 2.5 -// lldbr-check:(f32) *f32_ref = 2.5 // lldb-command:v *f64_ref // lldbg-check:[...] 3.5 -// lldbr-check:(f64) *f64_ref = 3.5 #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/box.rs b/tests/debuginfo/box.rs index 248d00687e89..40f0cd524448 100644 --- a/tests/debuginfo/box.rs +++ b/tests/debuginfo/box.rs @@ -15,10 +15,8 @@ // lldb-command:run // lldb-command:v *a // lldbg-check:[...] 1 -// lldbr-check:(i32) *a = 1 // lldb-command:v *b // lldbg-check:[...] { 0 = 2 1 = 3.5 } -// lldbr-check:((i32, f64)) *b = { 0 = 2 1 = 3.5 } #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/boxed-struct.rs b/tests/debuginfo/boxed-struct.rs index c7a8a4bd3d14..b4349122a3a8 100644 --- a/tests/debuginfo/boxed-struct.rs +++ b/tests/debuginfo/boxed-struct.rs @@ -17,11 +17,9 @@ // lldb-command:v *boxed_with_padding // lldbg-check:[...] { x = 99 y = 999 z = 9999 w = 99999 } -// lldbr-check:(boxed_struct::StructWithSomePadding) *boxed_with_padding = { x = 99 y = 999 z = 9999 w = 99999 } // lldb-command:v *boxed_with_dtor // lldbg-check:[...] { x = 77 y = 777 z = 7777 w = 77777 } -// lldbr-check:(boxed_struct::StructWithDestructor) *boxed_with_dtor = { x = 77 y = 777 z = 7777 w = 77777 } #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/by-value-self-argument-in-trait-impl.rs b/tests/debuginfo/by-value-self-argument-in-trait-impl.rs index e23b459a5725..69a051b444df 100644 --- a/tests/debuginfo/by-value-self-argument-in-trait-impl.rs +++ b/tests/debuginfo/by-value-self-argument-in-trait-impl.rs @@ -23,17 +23,14 @@ // lldb-command:v self // lldbg-check:[...] 1111 -// lldbr-check:(isize) self = 1111 // lldb-command:continue // lldb-command:v self // lldbg-check:[...] { x = 2222 y = 3333 } -// lldbr-check:(by_value_self_argument_in_trait_impl::Struct) self = { x = 2222 y = 3333 } // lldb-command:continue // lldb-command:v self // lldbg-check:[...] { 0 = 4444.5 1 = 5555 2 = 6666 3 = 7777.5 } -// lldbr-check:((f64, isize, isize, f64)) self = { 0 = 4444.5 1 = 5555 2 = 6666 3 = 7777.5 } // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/c-style-enum-in-composite.rs b/tests/debuginfo/c-style-enum-in-composite.rs index 5aaa8b8853a7..4cd40c20cebd 100644 --- a/tests/debuginfo/c-style-enum-in-composite.rs +++ b/tests/debuginfo/c-style-enum-in-composite.rs @@ -31,31 +31,24 @@ // lldb-command:v tuple_interior_padding // lldbg-check:[...] { 0 = 0 1 = OneHundred } -// lldbr-check:((i16, c_style_enum_in_composite::AnEnum)) tuple_interior_padding = { 0 = 0 1 = OneHundred } // lldb-command:v tuple_padding_at_end // lldbg-check:[...] { 0 = { 0 = 1 1 = OneThousand } 1 = 2 } -// lldbr-check:(((u64, c_style_enum_in_composite::AnEnum), u64)) tuple_padding_at_end = { 0 = { 0 = 1 1 = OneThousand } 1 = 2 } // lldb-command:v tuple_different_enums // lldbg-check:[...] { 0 = OneThousand 1 = MountainView 2 = OneMillion 3 = Vienna } -// lldbr-check:((c_style_enum_in_composite::AnEnum, c_style_enum_in_composite::AnotherEnum, c_style_enum_in_composite::AnEnum, c_style_enum_in_composite::AnotherEnum)) tuple_different_enums = { 0 = c_style_enum_in_composite::AnEnum::OneThousand 1 = c_style_enum_in_composite::AnotherEnum::MountainView 2 = c_style_enum_in_composite::AnEnum::OneMillion 3 = c_style_enum_in_composite::AnotherEnum::Vienna } // lldb-command:v padded_struct // lldbg-check:[...] { a = 3 b = OneMillion c = 4 d = Toronto e = 5 } -// lldbr-check:(c_style_enum_in_composite::PaddedStruct) padded_struct = { a = 3 b = c_style_enum_in_composite::AnEnum::OneMillion c = 4 d = Toronto e = 5 } // lldb-command:v packed_struct // lldbg-check:[...] { a = 6 b = OneHundred c = 7 d = Vienna e = 8 } -// lldbr-check:(c_style_enum_in_composite::PackedStruct) packed_struct = { a = 6 b = c_style_enum_in_composite::AnEnum::OneHundred c = 7 d = Vienna e = 8 } // lldb-command:v non_padded_struct // lldbg-check:[...] { a = OneMillion b = MountainView c = OneThousand d = Toronto } -// lldbr-check:(c_style_enum_in_composite::NonPaddedStruct) non_padded_struct = { a = c_style_enum_in_composite::AnEnum::OneMillion, b = c_style_enum_in_composite::AnotherEnum::MountainView, c = c_style_enum_in_composite::AnEnum::OneThousand, d = c_style_enum_in_composite::AnotherEnum::Toronto } // lldb-command:v struct_with_drop // lldbg-check:[...] { 0 = { a = OneHundred b = Vienna } 1 = 9 } -// lldbr-check:((c_style_enum_in_composite::StructWithDrop, i64)) struct_with_drop = { 0 = { a = c_style_enum_in_composite::AnEnum::OneHundred b = c_style_enum_in_composite::AnotherEnum::Vienna } 1 = 9 } #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/c-style-enum.rs b/tests/debuginfo/c-style-enum.rs index 471449af3dd0..a148c8d38453 100644 --- a/tests/debuginfo/c-style-enum.rs +++ b/tests/debuginfo/c-style-enum.rs @@ -67,31 +67,24 @@ // lldb-command:v auto_one // lldbg-check:[...] One -// lldbr-check:(c_style_enum::AutoDiscriminant) auto_one = c_style_enum::AutoDiscriminant::One // lldb-command:v auto_two // lldbg-check:[...] Two -// lldbr-check:(c_style_enum::AutoDiscriminant) auto_two = c_style_enum::AutoDiscriminant::Two // lldb-command:v auto_three // lldbg-check:[...] Three -// lldbr-check:(c_style_enum::AutoDiscriminant) auto_three = c_style_enum::AutoDiscriminant::Three // lldb-command:v manual_one_hundred // lldbg-check:[...] OneHundred -// lldbr-check:(c_style_enum::ManualDiscriminant) manual_one_hundred = c_style_enum::ManualDiscriminant::OneHundred // lldb-command:v manual_one_thousand // lldbg-check:[...] OneThousand -// lldbr-check:(c_style_enum::ManualDiscriminant) manual_one_thousand = c_style_enum::ManualDiscriminant::OneThousand // lldb-command:v manual_one_million // lldbg-check:[...] OneMillion -// lldbr-check:(c_style_enum::ManualDiscriminant) manual_one_million = c_style_enum::ManualDiscriminant::OneMillion // lldb-command:v single_variant // lldbg-check:[...] TheOnlyVariant -// lldbr-check:(c_style_enum::SingleVariant) single_variant = c_style_enum::SingleVariant::TheOnlyVariant #![allow(unused_variables)] #![allow(dead_code)] diff --git a/tests/debuginfo/closure-in-generic-function.rs b/tests/debuginfo/closure-in-generic-function.rs index d4608dc284a1..2baaf1b79e9d 100644 --- a/tests/debuginfo/closure-in-generic-function.rs +++ b/tests/debuginfo/closure-in-generic-function.rs @@ -23,18 +23,14 @@ // lldb-command:v x // lldbg-check:[...] 0.5 -// lldbr-check:(f64) x = 0.5 // lldb-command:v y // lldbg-check:[...] 10 -// lldbr-check:(i32) y = 10 // lldb-command:continue // lldb-command:v *x // lldbg-check:[...] 29 -// lldbr-check:(i32) *x = 29 // lldb-command:v *y // lldbg-check:[...] 110 -// lldbr-check:(i32) *y = 110 // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/cross-crate-spans.rs b/tests/debuginfo/cross-crate-spans.rs index 34e3daebb80d..5e8b27d4d55e 100644 --- a/tests/debuginfo/cross-crate-spans.rs +++ b/tests/debuginfo/cross-crate-spans.rs @@ -37,24 +37,18 @@ extern crate cross_crate_spans; // lldb-command:v result // lldbg-check:[...] { 0 = 17 1 = 17 } -// lldbr-check:((u32, u32)) result = { 0 = 17 1 = 17 } // lldb-command:v a_variable // lldbg-check:[...] 123456789 -// lldbr-check:(u32) a_variable = 123456789 // lldb-command:v another_variable // lldbg-check:[...] 123456789.5 -// lldbr-check:(f64) another_variable = 123456789.5 // lldb-command:continue // lldb-command:v result // lldbg-check:[...] { 0 = 1212 1 = 1212 } -// lldbr-check:((i16, i16)) result = { 0 = 1212 1 = 1212 } // lldb-command:v a_variable // lldbg-check:[...] 123456789 -// lldbr-check:(u32) a_variable = 123456789 // lldb-command:v another_variable // lldbg-check:[...] 123456789.5 -// lldbr-check:(f64) another_variable = 123456789.5 // lldb-command:continue diff --git a/tests/debuginfo/destructured-fn-argument.rs b/tests/debuginfo/destructured-fn-argument.rs index db86fe5b9233..aef4e4baae1e 100644 --- a/tests/debuginfo/destructured-fn-argument.rs +++ b/tests/debuginfo/destructured-fn-argument.rs @@ -155,195 +155,146 @@ // lldb-command:v a // lldbg-check:[...] 1 -// lldbr-check:(isize) a = 1 // lldb-command:v b // lldbg-check:[...] false -// lldbr-check:(bool) b = false // lldb-command:continue // lldb-command:v a // lldbg-check:[...] 2 -// lldbr-check:(isize) a = 2 // lldb-command:v b // lldbg-check:[...] 3 -// lldbr-check:(u16) b = 3 // lldb-command:v c // lldbg-check:[...] 4 -// lldbr-check:(u16) c = 4 // lldb-command:continue // lldb-command:v a // lldbg-check:[...] 5 -// lldbr-check:(isize) a = 5 // lldb-command:v b // lldbg-check:[...] { 0 = 6 1 = 7 } -// lldbr-check:((u32, u32)) b = { 0 = 6 1 = 7 } // lldb-command:continue // lldb-command:v h // lldbg-check:[...] 8 -// lldbr-check:(i16) h = 8 // lldb-command:v i // lldbg-check:[...] { a = 9 b = 10 } -// lldbr-check:(destructured_fn_argument::Struct) i = { a = 9 b = 10 } // lldb-command:v j // lldbg-check:[...] 11 -// lldbr-check:(i16) j = 11 // lldb-command:continue // lldb-command:v k // lldbg-check:[...] 12 -// lldbr-check:(i64) k = 12 // lldb-command:v l // lldbg-check:[...] 13 -// lldbr-check:(i32) l = 13 // lldb-command:continue // lldb-command:v m // lldbg-check:[...] 14 -// lldbr-check:(isize) m = 14 // lldb-command:v n // lldbg-check:[...] 16 -// lldbr-check:(i32) n = 16 // lldb-command:continue // lldb-command:v o // lldbg-check:[...] 18 -// lldbr-check:(i32) o = 18 // lldb-command:continue // lldb-command:v p // lldbg-check:[...] 19 -// lldbr-check:(i64) p = 19 // lldb-command:v q // lldbg-check:[...] 20 -// lldbr-check:(i32) q = 20 // lldb-command:v r // lldbg-check:[...] { a = 21 b = 22 } -// lldbr-check:(destructured_fn_argument::Struct) r = { a = 21, b = 22 } // lldb-command:continue // lldb-command:v s // lldbg-check:[...] 24 -// lldbr-check:(i32) s = 24 // lldb-command:v t // lldbg-check:[...] 23 -// lldbr-check:(i64) t = 23 // lldb-command:continue // lldb-command:v u // lldbg-check:[...] 25 -// lldbr-check:(i16) u = 25 // lldb-command:v v // lldbg-check:[...] 26 -// lldbr-check:(i32) v = 26 // lldb-command:v w // lldbg-check:[...] 27 -// lldbr-check:(i64) w = 27 // lldb-command:v x // lldbg-check:[...] 28 -// lldbr-check:(i32) x = 28 // lldb-command:v y // lldbg-check:[...] 29 -// lldbr-check:(i64) y = 29 // lldb-command:v z // lldbg-check:[...] 30 -// lldbr-check:(i32) z = 30 // lldb-command:v ae // lldbg-check:[...] 31 -// lldbr-check:(i64) ae = 31 // lldb-command:v oe // lldbg-check:[...] 32 -// lldbr-check:(i32) oe = 32 // lldb-command:v ue // lldbg-check:[...] 33 -// lldbr-check:(u16) ue = 33 // lldb-command:continue // lldb-command:v aa // lldbg-check:[...] { 0 = 34 1 = 35 } -// lldbr-check:((isize, isize)) aa = { 0 = 34 1 = 35 } // lldb-command:continue // lldb-command:v bb // lldbg-check:[...] { 0 = 36 1 = 37 } -// lldbr-check:((isize, isize)) bb = { 0 = 36 1 = 37 } // lldb-command:continue // lldb-command:v cc // lldbg-check:[...] 38 -// lldbr-check:(isize) cc = 38 // lldb-command:continue // lldb-command:v dd // lldbg-check:[...] { 0 = 40 1 = 41 2 = 42 } -// lldbr-check:((isize, isize, isize)) dd = { 0 = 40 1 = 41 2 = 42 } // lldb-command:continue // lldb-command:v *ee // lldbg-check:[...] { 0 = 43 1 = 44 2 = 45 } -// lldbr-check:((isize, isize, isize)) *ee = { 0 = 43 1 = 44 2 = 45 } // lldb-command:continue // lldb-command:v *ff // lldbg-check:[...] 46 -// lldbr-check:(isize) *ff = 46 // lldb-command:v gg // lldbg-check:[...] { 0 = 47 1 = 48 } -// lldbr-check:((isize, isize)) gg = { 0 = 47 1 = 48 } // lldb-command:continue // lldb-command:v *hh // lldbg-check:[...] 50 -// lldbr-check:(i32) *hh = 50 // lldb-command:continue // lldb-command:v ii // lldbg-check:[...] 51 -// lldbr-check:(i32) ii = 51 // lldb-command:continue // lldb-command:v *jj // lldbg-check:[...] 52 -// lldbr-check:(i32) *jj = 52 // lldb-command:continue // lldb-command:v kk // lldbg-check:[...] 53 -// lldbr-check:(f64) kk = 53 // lldb-command:v ll // lldbg-check:[...] 54 -// lldbr-check:(isize) ll = 54 // lldb-command:continue // lldb-command:v mm // lldbg-check:[...] 55 -// lldbr-check:(f64) mm = 55 // lldb-command:v *nn // lldbg-check:[...] 56 -// lldbr-check:(isize) *nn = 56 // lldb-command:continue // lldb-command:v oo // lldbg-check:[...] 57 -// lldbr-check:(isize) oo = 57 // lldb-command:v pp // lldbg-check:[...] 58 -// lldbr-check:(isize) pp = 58 // lldb-command:v qq // lldbg-check:[...] 59 -// lldbr-check:(isize) qq = 59 // lldb-command:continue // lldb-command:v rr // lldbg-check:[...] 60 -// lldbr-check:(isize) rr = 60 // lldb-command:v ss // lldbg-check:[...] 61 -// lldbr-check:(isize) ss = 61 // lldb-command:v tt // lldbg-check:[...] 62 -// lldbr-check:(isize) tt = 62 // lldb-command:continue #![allow(unused_variables)] diff --git a/tests/debuginfo/destructured-for-loop-variable.rs b/tests/debuginfo/destructured-for-loop-variable.rs index 73f03ec40b63..6a43f8ca1999 100644 --- a/tests/debuginfo/destructured-for-loop-variable.rs +++ b/tests/debuginfo/destructured-for-loop-variable.rs @@ -78,89 +78,65 @@ // DESTRUCTURED STRUCT // lldb-command:v x // lldbg-check:[...] 400 -// lldbr-check:(i16) x = 400 // lldb-command:v y // lldbg-check:[...] 401.5 -// lldbr-check:(f32) y = 401.5 // lldb-command:v z // lldbg-check:[...] true -// lldbr-check:(bool) z = true // lldb-command:continue // DESTRUCTURED TUPLE // lldb-command:v _i8 // lldbg-check:[...] 0x6f -// lldbr-check:(i8) _i8 = 111 // lldb-command:v _u8 // lldbg-check:[...] 0x70 -// lldbr-check:(u8) _u8 = 112 // lldb-command:v _i16 // lldbg-check:[...] -113 -// lldbr-check:(i16) _i16 = -113 // lldb-command:v _u16 // lldbg-check:[...] 114 -// lldbr-check:(u16) _u16 = 114 // lldb-command:v _i32 // lldbg-check:[...] -115 -// lldbr-check:(i32) _i32 = -115 // lldb-command:v _u32 // lldbg-check:[...] 116 -// lldbr-check:(u32) _u32 = 116 // lldb-command:v _i64 // lldbg-check:[...] -117 -// lldbr-check:(i64) _i64 = -117 // lldb-command:v _u64 // lldbg-check:[...] 118 -// lldbr-check:(u64) _u64 = 118 // lldb-command:v _f32 // lldbg-check:[...] 119.5 -// lldbr-check:(f32) _f32 = 119.5 // lldb-command:v _f64 // lldbg-check:[...] 120.5 -// lldbr-check:(f64) _f64 = 120.5 // lldb-command:continue // MORE COMPLEX CASE // lldb-command:v v1 // lldbg-check:[...] 80000 -// lldbr-check:(i32) v1 = 80000 // lldb-command:v x1 // lldbg-check:[...] 8000 -// lldbr-check:(i16) x1 = 8000 // lldb-command:v *y1 // lldbg-check:[...] 80001.5 -// lldbr-check:(f32) *y1 = 80001.5 // lldb-command:v z1 // lldbg-check:[...] false -// lldbr-check:(bool) z1 = false // lldb-command:v *x2 // lldbg-check:[...] -30000 -// lldbr-check:(i16) *x2 = -30000 // lldb-command:v y2 // lldbg-check:[...] -300001.5 -// lldbr-check:(f32) y2 = -300001.5 // lldb-command:v *z2 // lldbg-check:[...] true -// lldbr-check:(bool) *z2 = true // lldb-command:v v2 // lldbg-check:[...] 854237.5 -// lldbr-check:(f64) v2 = 854237.5 // lldb-command:continue // SIMPLE IDENTIFIER // lldb-command:v i // lldbg-check:[...] 1234 -// lldbr-check:(i32) i = 1234 // lldb-command:continue // lldb-command:v simple_struct_ident // lldbg-check:[...] { x = 3537 y = 35437.5 z = true } -// lldbr-check:(destructured_for_loop_variable::Struct) simple_struct_ident = { x = 3537 y = 35437.5 z = true } // lldb-command:continue // lldb-command:v simple_tuple_ident // lldbg-check:[...] { 0 = 34903493 1 = 232323 } -// lldbr-check:((u32, i64)) simple_tuple_ident = { 0 = 34903493 1 = 232323 } // lldb-command:continue #![allow(unused_variables)] diff --git a/tests/debuginfo/destructured-local.rs b/tests/debuginfo/destructured-local.rs index f4d960f78812..b74bf8745eaa 100644 --- a/tests/debuginfo/destructured-local.rs +++ b/tests/debuginfo/destructured-local.rs @@ -121,156 +121,113 @@ // lldb-command:v a // lldbg-check:[...] 1 -// lldbr-check:(isize) a = 1 // lldb-command:v b // lldbg-check:[...] false -// lldbr-check:(bool) b = false // lldb-command:v c // lldbg-check:[...] 2 -// lldbr-check:(isize) c = 2 // lldb-command:v d // lldbg-check:[...] 3 -// lldbr-check:(u16) d = 3 // lldb-command:v e // lldbg-check:[...] 4 -// lldbr-check:(u16) e = 4 // lldb-command:v f // lldbg-check:[...] 5 -// lldbr-check:(isize) f = 5 // lldb-command:v g // lldbg-check:[...] { 0 = 6 1 = 7 } -// lldbr-check:((u32, u32)) g = { 0 = 6 1 = 7 } // lldb-command:v h // lldbg-check:[...] 8 -// lldbr-check:(i16) h = 8 // lldb-command:v i // lldbg-check:[...] { a = 9 b = 10 } -// lldbr-check:(destructured_local::Struct) i = { a = 9 b = 10 } // lldb-command:v j // lldbg-check:[...] 11 -// lldbr-check:(i16) j = 11 // lldb-command:v k // lldbg-check:[...] 12 -// lldbr-check:(i64) k = 12 // lldb-command:v l // lldbg-check:[...] 13 -// lldbr-check:(i32) l = 13 // lldb-command:v m // lldbg-check:[...] 14 -// lldbr-check:(i32) m = 14 // lldb-command:v n // lldbg-check:[...] 16 -// lldbr-check:(i32) n = 16 // lldb-command:v o // lldbg-check:[...] 18 -// lldbr-check:(i32) o = 18 // lldb-command:v p // lldbg-check:[...] 19 -// lldbr-check:(i64) p = 19 // lldb-command:v q // lldbg-check:[...] 20 -// lldbr-check:(i32) q = 20 // lldb-command:v r // lldbg-check:[...] { a = 21 b = 22 } -// lldbr-check:(destructured_local::Struct) r = { a = 21 b = 22 } // lldb-command:v s // lldbg-check:[...] 24 -// lldbr-check:(i32) s = 24 // lldb-command:v t // lldbg-check:[...] 23 -// lldbr-check:(i64) t = 23 // lldb-command:v u // lldbg-check:[...] 25 -// lldbr-check:(i32) u = 25 // lldb-command:v v // lldbg-check:[...] 26 -// lldbr-check:(i32) v = 26 // lldb-command:v w // lldbg-check:[...] 27 -// lldbr-check:(i32) w = 27 // lldb-command:v x // lldbg-check:[...] 28 -// lldbr-check:(i32) x = 28 // lldb-command:v y // lldbg-check:[...] 29 -// lldbr-check:(i64) y = 29 // lldb-command:v z // lldbg-check:[...] 30 -// lldbr-check:(i32) z = 30 // lldb-command:v ae // lldbg-check:[...] 31 -// lldbr-check:(i64) ae = 31 // lldb-command:v oe // lldbg-check:[...] 32 -// lldbr-check:(i32) oe = 32 // lldb-command:v ue // lldbg-check:[...] 33 -// lldbr-check:(i32) ue = 33 // lldb-command:v aa // lldbg-check:[...] { 0 = 34 1 = 35 } -// lldbr-check:((i32, i32)) aa = { 0 = 34 1 = 35 } // lldb-command:v bb // lldbg-check:[...] { 0 = 36 1 = 37 } -// lldbr-check:((i32, i32)) bb = { 0 = 36 1 = 37 } // lldb-command:v cc // lldbg-check:[...] 38 -// lldbr-check:(i32) cc = 38 // lldb-command:v dd // lldbg-check:[...] { 0 = 40 1 = 41 2 = 42 } -// lldbr-check:((i32, i32, i32)) dd = { 0 = 40 1 = 41 2 = 42} // lldb-command:v *ee // lldbg-check:[...] { 0 = 43 1 = 44 2 = 45 } -// lldbr-check:((i32, i32, i32)) *ee = { 0 = 43 1 = 44 2 = 45} // lldb-command:v *ff // lldbg-check:[...] 46 -// lldbr-check:(i32) *ff = 46 // lldb-command:v gg // lldbg-check:[...] { 0 = 47 1 = 48 } -// lldbr-check:((i32, i32)) gg = { 0 = 47 1 = 48 } // lldb-command:v *hh // lldbg-check:[...] 50 -// lldbr-check:(i32) *hh = 50 // lldb-command:v ii // lldbg-check:[...] 51 -// lldbr-check:(i32) ii = 51 // lldb-command:v *jj // lldbg-check:[...] 52 -// lldbr-check:(i32) *jj = 52 // lldb-command:v kk // lldbg-check:[...] 53 -// lldbr-check:(f64) kk = 53 // lldb-command:v ll // lldbg-check:[...] 54 -// lldbr-check:(isize) ll = 54 // lldb-command:v mm // lldbg-check:[...] 55 -// lldbr-check:(f64) mm = 55 // lldb-command:v *nn // lldbg-check:[...] 56 -// lldbr-check:(isize) *nn = 56 #![allow(unused_variables)] diff --git a/tests/debuginfo/enum-thinlto.rs b/tests/debuginfo/enum-thinlto.rs index d30ff7dde389..8c3a20a2da4c 100644 --- a/tests/debuginfo/enum-thinlto.rs +++ b/tests/debuginfo/enum-thinlto.rs @@ -14,7 +14,6 @@ // lldb-command:v *abc // lldbg-check:(enum_thinlto::ABC) *abc = { value = { x = 0 y = 8970181431921507452 } $discr$ = 0 } -// lldbr-check:(enum_thinlto::ABC) *abc = (x = 0, y = 8970181431921507452) #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/evec-in-struct.rs b/tests/debuginfo/evec-in-struct.rs index f09471e75305..020c6e7d1542 100644 --- a/tests/debuginfo/evec-in-struct.rs +++ b/tests/debuginfo/evec-in-struct.rs @@ -25,22 +25,17 @@ // lldb-command:v no_padding1 // lldbg-check:[...] { x = { [0] = 0 [1] = 1 [2] = 2 } y = -3 z = { [0] = 4.5 [1] = 5.5 } } -// lldbr-check:(evec_in_struct::NoPadding1) no_padding1 = { x = { [0] = 0 [1] = 1 [2] = 2 } y = -3 z = { [0] = 4.5 [1] = 5.5 } } // lldb-command:v no_padding2 // lldbg-check:[...] { x = { [0] = 6 [1] = 7 [2] = 8 } y = { [0] = { [0] = 9 [1] = 10 } [1] = { [0] = 11 [1] = 12 } } } -// lldbr-check:(evec_in_struct::NoPadding2) no_padding2 = { x = { [0] = 6 [1] = 7 [2] = 8 } y = { [0] = { [0] = 9 [1] = 10 } [1] = { [0] = 11 [1] = 12 } } } // lldb-command:v struct_internal_padding // lldbg-check:[...] { x = { [0] = 13 [1] = 14 } y = { [0] = 15 [1] = 16 } } -// lldbr-check:(evec_in_struct::StructInternalPadding) struct_internal_padding = { x = { [0] = 13 [1] = 14 } y = { [0] = 15 [1] = 16 } } // lldb-command:v single_vec // lldbg-check:[...] { x = { [0] = 17 [1] = 18 [2] = 19 [3] = 20 [4] = 21 } } -// lldbr-check:(evec_in_struct::SingleVec) single_vec = { x = { [0] = 17 [1] = 18 [2] = 19 [3] = 20 [4] = 21 } } // lldb-command:v struct_padded_at_end // lldbg-check:[...] { x = { [0] = 22 [1] = 23 } y = { [0] = 24 [1] = 25 } } -// lldbr-check:(evec_in_struct::StructPaddedAtEnd) struct_padded_at_end = { x = { [0] = 22 [1] = 23 } y = { [0] = 24 [1] = 25 } } #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/extern-c-fn.rs b/tests/debuginfo/extern-c-fn.rs index 0531d7461885..d81ab356c1e9 100644 --- a/tests/debuginfo/extern-c-fn.rs +++ b/tests/debuginfo/extern-c-fn.rs @@ -21,16 +21,12 @@ // lldb-command:v len // lldbg-check:[...] 20 -// lldbr-check:(i32) len = 20 // lldb-command:v local0 // lldbg-check:[...] 19 -// lldbr-check:(i32) local0 = 19 // lldb-command:v local1 // lldbg-check:[...] true -// lldbr-check:(bool) local1 = true // lldb-command:v local2 // lldbg-check:[...] 20.5 -// lldbr-check:(f64) local2 = 20.5 // lldb-command:continue diff --git a/tests/debuginfo/function-arguments.rs b/tests/debuginfo/function-arguments.rs index bbf397caacd5..9befadf5dc15 100644 --- a/tests/debuginfo/function-arguments.rs +++ b/tests/debuginfo/function-arguments.rs @@ -22,18 +22,14 @@ // lldb-command:v x // lldbg-check:[...] 111102 -// lldbr-check:(isize) x = 111102 // lldb-command:v y // lldbg-check:[...] true -// lldbr-check:(bool) y = true // lldb-command:continue // lldb-command:v a // lldbg-check:[...] 2000 -// lldbr-check:(i32) a = 2000 // lldb-command:v b // lldbg-check:[...] 3000 -// lldbr-check:(i64) b = 3000 // lldb-command:continue diff --git a/tests/debuginfo/generic-function.rs b/tests/debuginfo/generic-function.rs index 6c1d0d5d7dbd..47f695b8fbe9 100644 --- a/tests/debuginfo/generic-function.rs +++ b/tests/debuginfo/generic-function.rs @@ -28,26 +28,20 @@ // lldb-command:v *t0 // lldbg-check:[...] 1 -// lldbr-check:(i32) *t0 = 1 // lldb-command:v *t1 // lldbg-check:[...] 2.5 -// lldbr-check:(f64) *t1 = 2.5 // lldb-command:continue // lldb-command:v *t0 // lldbg-check:[...] 3.5 -// lldbr-check:(f64) *t0 = 3.5 // lldb-command:v *t1 // lldbg-check:[...] 4 -// lldbr-check:(u16) *t1 = 4 // lldb-command:continue // lldb-command:v *t0 // lldbg-check:[...] 5 -// lldbr-check:(i32) *t0 = 5 // lldb-command:v *t1 // lldbg-check:[...] { a = 6 b = 7.5 } -// lldbr-check:(generic_function::Struct) *t1 = { a = 6 b = 7.5 } // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/generic-functions-nested.rs b/tests/debuginfo/generic-functions-nested.rs index 1aac6591738b..500a42f3dc8c 100644 --- a/tests/debuginfo/generic-functions-nested.rs +++ b/tests/debuginfo/generic-functions-nested.rs @@ -35,34 +35,26 @@ // lldb-command:v x // lldbg-check:[...] -1 -// lldbr-check:(i32) x = -1 // lldb-command:v y // lldbg-check:[...] 1 -// lldbr-check:(i32) y = 1 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] -1 -// lldbr-check:(i32) x = -1 // lldb-command:v y // lldbg-check:[...] 2.5 -// lldbr-check:(f64) y = 2.5 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] -2.5 -// lldbr-check:(f64) x = -2.5 // lldb-command:v y // lldbg-check:[...] 1 -// lldbr-check:(i32) y = 1 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] -2.5 -// lldbr-check:(f64) x = -2.5 // lldb-command:v y // lldbg-check:[...] 2.5 -// lldbr-check:(f64) y = 2.5 // lldb-command:continue diff --git a/tests/debuginfo/generic-method-on-generic-struct.rs b/tests/debuginfo/generic-method-on-generic-struct.rs index 0f72e2b092be..071d436b0895 100644 --- a/tests/debuginfo/generic-method-on-generic-struct.rs +++ b/tests/debuginfo/generic-method-on-generic-struct.rs @@ -1,9 +1,5 @@ //@ compile-flags:-g -// Some versions of the non-rust-enabled LLDB print the wrong generic -// parameter type names in this test. -//@ needs-rust-lldb - // === GDB TESTS =================================================================================== // gdb-command:run @@ -61,61 +57,46 @@ // STACK BY REF // lldb-command:v *self // lldbg-check:[...] { x = { 0 = 8888, 1 = -8888 } } -// lldbr-check:(generic_method_on_generic_struct::Struct<(u32, i32)>) *self = { x = { 0 = 8888 1 = -8888 } } // lldb-command:v arg1 // lldbg-check:[...] -1 -// lldbr-check:(isize) arg1 = -1 // lldb-command:v arg2 // lldbg-check:[...] 2 -// lldbr-check:(u16) arg2 = 2 // lldb-command:continue // STACK BY VAL // lldb-command:v self // lldbg-check:[...] { x = { 0 = 8888, 1 = -8888 } } -// lldbr-check:(generic_method_on_generic_struct::Struct<(u32, i32)>) self = { x = { 0 = 8888, 1 = -8888 } } // lldb-command:v arg1 // lldbg-check:[...] -3 -// lldbr-check:(isize) arg1 = -3 // lldb-command:v arg2 // lldbg-check:[...] -4 -// lldbr-check:(i16) arg2 = -4 // lldb-command:continue // OWNED BY REF // lldb-command:v *self // lldbg-check:[...] { x = 1234.5 } -// lldbr-check:(generic_method_on_generic_struct::Struct) *self = { x = 1234.5 } // lldb-command:v arg1 // lldbg-check:[...] -5 -// lldbr-check:(isize) arg1 = -5 // lldb-command:v arg2 // lldbg-check:[...] -6 -// lldbr-check:(i32) arg2 = -6 // lldb-command:continue // OWNED BY VAL // lldb-command:v self // lldbg-check:[...] { x = 1234.5 } -// lldbr-check:(generic_method_on_generic_struct::Struct) self = { x = 1234.5 } // lldb-command:v arg1 // lldbg-check:[...] -7 -// lldbr-check:(isize) arg1 = -7 // lldb-command:v arg2 // lldbg-check:[...] -8 -// lldbr-check:(i64) arg2 = -8 // lldb-command:continue // OWNED MOVED // lldb-command:v *self // lldbg-check:[...] { x = 1234.5 } -// lldbr-check:(generic_method_on_generic_struct::Struct) *self = { x = 1234.5 } // lldb-command:v arg1 // lldbg-check:[...] -9 -// lldbr-check:(isize) arg1 = -9 // lldb-command:v arg2 // lldbg-check:[...] -10.5 -// lldbr-check:(f32) arg2 = -10.5 // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/generic-struct.rs b/tests/debuginfo/generic-struct.rs index 2817f8edc150..49ec4ac1c177 100644 --- a/tests/debuginfo/generic-struct.rs +++ b/tests/debuginfo/generic-struct.rs @@ -19,17 +19,13 @@ // lldb-command:v int_int // lldbg-check:[...] AGenericStruct { key: 0, value: 1 } -// lldbr-check:(generic_struct::AGenericStruct) int_int = AGenericStruct { key: 0, value: 1 } // lldb-command:v int_float // lldbg-check:[...] AGenericStruct { key: 2, value: 3.5 } -// lldbr-check:(generic_struct::AGenericStruct) int_float = AGenericStruct { key: 2, value: 3.5 } // lldb-command:v float_int // lldbg-check:[...] AGenericStruct { key: 4.5, value: 5 } -// lldbr-check:(generic_struct::AGenericStruct) float_int = AGenericStruct { key: 4.5, value: 5 } // lldb-command:v float_int_float // lldbg-check:[...] AGenericStruct> { key: 6.5, value: AGenericStruct { key: 7, value: 8.5 } } -// lldbr-check:(generic_struct::AGenericStruct>) float_int_float = AGenericStruct> { key: 6.5, value: AGenericStruct { key: 7, value: 8.5 } } // === CDB TESTS =================================================================================== diff --git a/tests/debuginfo/generic-tuple-style-enum.rs b/tests/debuginfo/generic-tuple-style-enum.rs index 15b9cec071a7..4a5996645cb4 100644 --- a/tests/debuginfo/generic-tuple-style-enum.rs +++ b/tests/debuginfo/generic-tuple-style-enum.rs @@ -23,16 +23,12 @@ // lldb-command:run // lldb-command:v case1 -// lldbr-check:(generic_tuple_style_enum::Regular::Case1) case1 = { __0 = 0 __1 = 31868 __2 = 31868 __3 = 31868 __4 = 31868 } // lldb-command:v case2 -// lldbr-check:(generic_tuple_style_enum::Regular::Case2) case2 = Regular::Case2 { Case1: 0, Case2: 286331153, Case3: 286331153 } // lldb-command:v case3 -// lldbr-check:(generic_tuple_style_enum::Regular::Case3) case3 = Regular::Case3 { Case1: 0, Case2: 6438275382588823897 } // lldb-command:v univariant -// lldbr-check:(generic_tuple_style_enum::Univariant) univariant = Univariant { TheOnlyCase: Univariant::TheOnlyCase(-1) } #![feature(omit_gdb_pretty_printer_section)] #![omit_gdb_pretty_printer_section] diff --git a/tests/debuginfo/include_string.rs b/tests/debuginfo/include_string.rs index 3ee02c554cbd..5bf7cb69cc12 100644 --- a/tests/debuginfo/include_string.rs +++ b/tests/debuginfo/include_string.rs @@ -18,13 +18,10 @@ // lldb-command:v string1.length // lldbg-check:[...] 48 -// lldbr-check:(usize) length = 48 // lldb-command:v string2.length // lldbg-check:[...] 49 -// lldbr-check:(usize) length = 49 // lldb-command:v string3.length // lldbg-check:[...] 50 -// lldbr-check:(usize) length = 50 // lldb-command:continue diff --git a/tests/debuginfo/issue-22656.rs b/tests/debuginfo/issue-22656.rs index 199de531d0b4..5198d34c7b8b 100644 --- a/tests/debuginfo/issue-22656.rs +++ b/tests/debuginfo/issue-22656.rs @@ -11,11 +11,8 @@ // lldb-command:v v // lldbg-check:[...] size=3 { [0] = 1 [1] = 2 [2] = 3 } -// lldbr-check:(alloc::vec::Vec) v = size=3 { [0] = 1 [1] = 2 [2] = 3 } // lldb-command:v zs // lldbg-check:[...] { x = y = 123 z = w = 456 } -// lldbr-check:(issue_22656::StructWithZeroSizedField) zs = { x = y = 123 z = w = 456 } -// lldbr-command:continue #![allow(unused_variables)] #![allow(dead_code)] diff --git a/tests/debuginfo/lexical-scope-in-for-loop.rs b/tests/debuginfo/lexical-scope-in-for-loop.rs index d5594b6bc62f..acfddaab89c7 100644 --- a/tests/debuginfo/lexical-scope-in-for-loop.rs +++ b/tests/debuginfo/lexical-scope-in-for-loop.rs @@ -44,40 +44,33 @@ // FIRST ITERATION // lldb-command:v x // lldbg-check:[...] 1 -// lldbr-check:(i32) x = 1 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] -1 -// lldbr-check:(i32) x = -1 // lldb-command:continue // SECOND ITERATION // lldb-command:v x // lldbg-check:[...] 2 -// lldbr-check:(i32) x = 2 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] -2 -// lldbr-check:(i32) x = -2 // lldb-command:continue // THIRD ITERATION // lldb-command:v x // lldbg-check:[...] 3 -// lldbr-check:(i32) x = 3 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] -3 -// lldbr-check:(i32) x = -3 // lldb-command:continue // AFTER LOOP // lldb-command:v x // lldbg-check:[...] 1000000 -// lldbr-check:(i32) x = 1000000 // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/lexical-scope-in-if.rs b/tests/debuginfo/lexical-scope-in-if.rs index e35eb3715a9b..d1c5884843c4 100644 --- a/tests/debuginfo/lexical-scope-in-if.rs +++ b/tests/debuginfo/lexical-scope-in-if.rs @@ -68,73 +68,57 @@ // BEFORE if // lldb-command:v x // lldbg-check:[...] 999 -// lldbr-check:(i32) x = 999 // lldb-command:v y // lldbg-check:[...] -1 -// lldbr-check:(i32) y = -1 // lldb-command:continue // AT BEGINNING of 'then' block // lldb-command:v x // lldbg-check:[...] 999 -// lldbr-check:(i32) x = 999 // lldb-command:v y // lldbg-check:[...] -1 -// lldbr-check:(i32) y = -1 // lldb-command:continue // AFTER 1st redeclaration of 'x' // lldb-command:v x // lldbg-check:[...] 1001 -// lldbr-check:(i32) x = 1001 // lldb-command:v y // lldbg-check:[...] -1 -// lldbr-check:(i32) y = -1 // lldb-command:continue // AFTER 2st redeclaration of 'x' // lldb-command:v x // lldbg-check:[...] 1002 -// lldbr-check:(i32) x = 1002 // lldb-command:v y // lldbg-check:[...] 1003 -// lldbr-check:(i32) y = 1003 // lldb-command:continue // AFTER 1st if expression // lldb-command:v x // lldbg-check:[...] 999 -// lldbr-check:(i32) x = 999 // lldb-command:v y // lldbg-check:[...] -1 -// lldbr-check:(i32) y = -1 // lldb-command:continue // BEGINNING of else branch // lldb-command:v x // lldbg-check:[...] 999 -// lldbr-check:(i32) x = 999 // lldb-command:v y // lldbg-check:[...] -1 -// lldbr-check:(i32) y = -1 // lldb-command:continue // BEGINNING of else branch // lldb-command:v x // lldbg-check:[...] 1004 -// lldbr-check:(i32) x = 1004 // lldb-command:v y // lldbg-check:[...] 1005 -// lldbr-check:(i32) y = 1005 // lldb-command:continue // BEGINNING of else branch // lldb-command:v x // lldbg-check:[...] 999 -// lldbr-check:(i32) x = 999 // lldb-command:v y // lldbg-check:[...] -1 -// lldbr-check:(i32) y = -1 // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/lexical-scope-in-match.rs b/tests/debuginfo/lexical-scope-in-match.rs index cffda426aefa..754616b1a54b 100644 --- a/tests/debuginfo/lexical-scope-in-match.rs +++ b/tests/debuginfo/lexical-scope-in-match.rs @@ -63,72 +63,54 @@ // lldb-command:v shadowed // lldbg-check:[...] 231 -// lldbr-check:(i32) shadowed = 231 // lldb-command:v not_shadowed // lldbg-check:[...] 232 -// lldbr-check:(i32) not_shadowed = 232 // lldb-command:continue // lldb-command:v shadowed // lldbg-check:[...] 233 -// lldbr-check:(i32) shadowed = 233 // lldb-command:v not_shadowed // lldbg-check:[...] 232 -// lldbr-check:(i32) not_shadowed = 232 // lldb-command:v local_to_arm // lldbg-check:[...] 234 -// lldbr-check:(i32) local_to_arm = 234 // lldb-command:continue // lldb-command:v shadowed // lldbg-check:[...] 236 -// lldbr-check:(i32) shadowed = 236 // lldb-command:v not_shadowed // lldbg-check:[...] 232 -// lldbr-check:(i32) not_shadowed = 232 // lldb-command:continue // lldb-command:v shadowed // lldbg-check:[...] 237 -// lldbr-check:(isize) shadowed = 237 // lldb-command:v not_shadowed // lldbg-check:[...] 232 -// lldbr-check:(i32) not_shadowed = 232 // lldb-command:v local_to_arm // lldbg-check:[...] 238 -// lldbr-check:(isize) local_to_arm = 238 // lldb-command:continue // lldb-command:v shadowed // lldbg-check:[...] 239 -// lldbr-check:(isize) shadowed = 239 // lldb-command:v not_shadowed // lldbg-check:[...] 232 -// lldbr-check:(i32) not_shadowed = 232 // lldb-command:continue // lldb-command:v shadowed // lldbg-check:[...] 241 -// lldbr-check:(isize) shadowed = 241 // lldb-command:v not_shadowed // lldbg-check:[...] 232 -// lldbr-check:(i32) not_shadowed = 232 // lldb-command:continue // lldb-command:v shadowed // lldbg-check:[...] 243 -// lldbr-check:(i32) shadowed = 243 // lldb-command:v *local_to_arm // lldbg-check:[...] 244 -// lldbr-check:(i32) *local_to_arm = 244 // lldb-command:continue // lldb-command:v shadowed // lldbg-check:[...] 231 -// lldbr-check:(i32) shadowed = 231 // lldb-command:v not_shadowed // lldbg-check:[...] 232 -// lldbr-check:(i32) not_shadowed = 232 // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/lexical-scope-in-stack-closure.rs b/tests/debuginfo/lexical-scope-in-stack-closure.rs index 51fb16c594fa..301423080e68 100644 --- a/tests/debuginfo/lexical-scope-in-stack-closure.rs +++ b/tests/debuginfo/lexical-scope-in-stack-closure.rs @@ -35,32 +35,26 @@ // lldb-command:v x // lldbg-check:[...] false -// lldbr-check:(bool) x = false // lldb-command:continue // lldb-command:v x // lldbg-check:[...] false -// lldbr-check:(bool) x = false // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 1000 -// lldbr-check:(isize) x = 1000 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 2.5 -// lldbr-check:(f64) x = 2.5 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] true -// lldbr-check:(bool) x = true // lldb-command:continue // lldb-command:v x // lldbg-check:[...] false -// lldbr-check:(bool) x = false // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/lexical-scope-in-unconditional-loop.rs b/tests/debuginfo/lexical-scope-in-unconditional-loop.rs index 344e1893c865..1d111dab5c94 100644 --- a/tests/debuginfo/lexical-scope-in-unconditional-loop.rs +++ b/tests/debuginfo/lexical-scope-in-unconditional-loop.rs @@ -67,69 +67,56 @@ // FIRST ITERATION // lldb-command:v x // lldbg-check:[...] 0 -// lldbr-check:(i32) x = 0 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 1 -// lldbr-check:(i32) x = 1 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 101 -// lldbr-check:(i32) x = 101 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 101 -// lldbr-check:(i32) x = 101 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] -987 -// lldbr-check:(i32) x = -987 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 101 -// lldbr-check:(i32) x = 101 // lldb-command:continue // SECOND ITERATION // lldb-command:v x // lldbg-check:[...] 1 -// lldbr-check:(i32) x = 1 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 2 -// lldbr-check:(i32) x = 2 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 102 -// lldbr-check:(i32) x = 102 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 102 -// lldbr-check:(i32) x = 102 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] -987 -// lldbr-check:(i32) x = -987 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 102 -// lldbr-check:(i32) x = 102 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 2 -// lldbr-check:(i32) x = 2 // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/lexical-scope-in-unique-closure.rs b/tests/debuginfo/lexical-scope-in-unique-closure.rs index 443c4209b75b..d6cf39c77ae1 100644 --- a/tests/debuginfo/lexical-scope-in-unique-closure.rs +++ b/tests/debuginfo/lexical-scope-in-unique-closure.rs @@ -35,32 +35,26 @@ // lldb-command:v x // lldbg-check:[...] false -// lldbr-check:(bool) x = false // lldb-command:continue // lldb-command:v x // lldbg-check:[...] false -// lldbr-check:(bool) x = false // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 1000 -// lldbr-check:(isize) x = 1000 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 2.5 -// lldbr-check:(f64) x = 2.5 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] true -// lldbr-check:(bool) x = true // lldb-command:continue // lldb-command:v x // lldbg-check:[...] false -// lldbr-check:(bool) x = false // lldb-command:continue diff --git a/tests/debuginfo/lexical-scope-in-while.rs b/tests/debuginfo/lexical-scope-in-while.rs index 864900711a9f..faef8b44a297 100644 --- a/tests/debuginfo/lexical-scope-in-while.rs +++ b/tests/debuginfo/lexical-scope-in-while.rs @@ -67,69 +67,56 @@ // FIRST ITERATION // lldb-command:v x // lldbg-check:[...] 0 -// lldbr-check:(i32) x = 0 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 1 -// lldbr-check:(i32) x = 1 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 101 -// lldbr-check:(i32) x = 101 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 101 -// lldbr-check:(i32) x = 101 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] -987 -// lldbr-check:(i32) x = -987 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 101 -// lldbr-check:(i32) x = 101 // lldb-command:continue // SECOND ITERATION // lldb-command:v x // lldbg-check:[...] 1 -// lldbr-check:(i32) x = 1 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 2 -// lldbr-check:(i32) x = 2 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 102 -// lldbr-check:(i32) x = 102 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 102 -// lldbr-check:(i32) x = 102 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] -987 -// lldbr-check:(i32) x = -987 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 102 -// lldbr-check:(i32) x = 102 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 2 -// lldbr-check:(i32) x = 2 // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/lexical-scope-with-macro.rs b/tests/debuginfo/lexical-scope-with-macro.rs index 6e8f87cc2d7f..5f8838c782bb 100644 --- a/tests/debuginfo/lexical-scope-with-macro.rs +++ b/tests/debuginfo/lexical-scope-with-macro.rs @@ -55,34 +55,26 @@ // lldb-command:v a // lldbg-check:[...] 10 -// lldbr-check:(i32) a = 10 // lldb-command:v b // lldbg-check:[...] 34 -// lldbr-check:(i32) b = 34 // lldb-command:continue // lldb-command:v a // lldbg-check:[...] 890242 -// lldbr-check:(i32) a = 10 // lldb-command:v b // lldbg-check:[...] 34 -// lldbr-check:(i32) b = 34 // lldb-command:continue // lldb-command:v a // lldbg-check:[...] 10 -// lldbr-check:(i32) a = 10 // lldb-command:v b // lldbg-check:[...] 34 -// lldbr-check:(i32) b = 34 // lldb-command:continue // lldb-command:v a // lldbg-check:[...] 102 -// lldbr-check:(i32) a = 10 // lldb-command:v b // lldbg-check:[...] 34 -// lldbr-check:(i32) b = 34 // lldb-command:continue // lldbg-command:print a diff --git a/tests/debuginfo/lexical-scopes-in-block-expression.rs b/tests/debuginfo/lexical-scopes-in-block-expression.rs index 310e9ae2a93e..f90c3dd327bc 100644 --- a/tests/debuginfo/lexical-scopes-in-block-expression.rs +++ b/tests/debuginfo/lexical-scopes-in-block-expression.rs @@ -184,202 +184,154 @@ // STRUCT EXPRESSION // lldb-command:v val // lldbg-check:[...] -1 -// lldbr-check:(i32) val = -1 // lldb-command:v ten // lldbg-check:[...] 10 -// lldbr-check:(isize) ten = 10 // lldb-command:continue // lldb-command:v val // lldbg-check:[...] 11 -// lldbr-check:(isize) val = 11 // lldb-command:v ten // lldbg-check:[...] 10 -// lldbr-check:(isize) ten = 10 // lldb-command:continue // lldb-command:v val // lldbg-check:[...] -1 -// lldbr-check:(i32) val = -1 // lldb-command:v ten // lldbg-check:[...] 10 -// lldbr-check:(isize) ten = 10 // lldb-command:continue // FUNCTION CALL // lldb-command:v val // lldbg-check:[...] -1 -// lldbr-check:(i32) val = -1 // lldb-command:v ten // lldbg-check:[...] 10 -// lldbr-check:(isize) ten = 10 // lldb-command:continue // lldb-command:v val // lldbg-check:[...] 12 -// lldbr-check:(isize) val = 12 // lldb-command:v ten // lldbg-check:[...] 10 -// lldbr-check:(isize) ten = 10 // lldb-command:continue // lldb-command:v val // lldbg-check:[...] -1 -// lldbr-check:(i32) val = -1 // lldb-command:v ten // lldbg-check:[...] 10 -// lldbr-check:(isize) ten = 10 // lldb-command:continue // TUPLE EXPRESSION // lldb-command:v val // lldbg-check:[...] -1 -// lldbr-check:(i32) val = -1 // lldb-command:v ten // lldbg-check:[...] 10 -// lldbr-check:(isize) ten = 10 // lldb-command:continue // lldb-command:v val // lldbg-check:[...] 13 -// lldbr-check:(isize) val = 13 // lldb-command:v ten // lldbg-check:[...] 10 -// lldbr-check:(isize) ten = 10 // lldb-command:continue // lldb-command:v val // lldbg-check:[...] -1 -// lldbr-check:(i32) val = -1 // lldb-command:v ten // lldbg-check:[...] 10 -// lldbr-check:(isize) ten = 10 // lldb-command:continue // VEC EXPRESSION // lldb-command:v val // lldbg-check:[...] -1 -// lldbr-check:(i32) val = -1 // lldb-command:v ten // lldbg-check:[...] 10 -// lldbr-check:(isize) ten = 10 // lldb-command:continue // lldb-command:v val // lldbg-check:[...] 14 -// lldbr-check:(isize) val = 14 // lldb-command:v ten // lldbg-check:[...] 10 -// lldbr-check:(isize) ten = 10 // lldb-command:continue // lldb-command:v val // lldbg-check:[...] -1 -// lldbr-check:(i32) val = -1 // lldb-command:v ten // lldbg-check:[...] 10 -// lldbr-check:(isize) ten = 10 // lldb-command:continue // REPEAT VEC EXPRESSION // lldb-command:v val // lldbg-check:[...] -1 -// lldbr-check:(i32) val = -1 // lldb-command:v ten // lldbg-check:[...] 10 -// lldbr-check:(isize) ten = 10 // lldb-command:continue // lldb-command:v val // lldbg-check:[...] 15 -// lldbr-check:(isize) val = 15 // lldb-command:v ten // lldbg-check:[...] 10 -// lldbr-check:(isize) ten = 10 // lldb-command:continue // lldb-command:v val // lldbg-check:[...] -1 -// lldbr-check:(i32) val = -1 // lldb-command:v ten // lldbg-check:[...] 10 -// lldbr-check:(isize) ten = 10 // lldb-command:continue // ASSIGNMENT EXPRESSION // lldb-command:v val // lldbg-check:[...] -1 -// lldbr-check:(i32) val = -1 // lldb-command:v ten // lldbg-check:[...] 10 -// lldbr-check:(isize) ten = 10 // lldb-command:continue // lldb-command:v val // lldbg-check:[...] 16 -// lldbr-check:(isize) val = 16 // lldb-command:v ten // lldbg-check:[...] 10 -// lldbr-check:(isize) ten = 10 // lldb-command:continue // lldb-command:v val // lldbg-check:[...] -1 -// lldbr-check:(i32) val = -1 // lldb-command:v ten // lldbg-check:[...] 10 -// lldbr-check:(isize) ten = 10 // lldb-command:continue // ARITHMETIC EXPRESSION // lldb-command:v val // lldbg-check:[...] -1 -// lldbr-check:(i32) val = -1 // lldb-command:v ten // lldbg-check:[...] 10 -// lldbr-check:(isize) ten = 10 // lldb-command:continue // lldb-command:v val // lldbg-check:[...] 17 -// lldbr-check:(isize) val = 17 // lldb-command:v ten // lldbg-check:[...] 10 -// lldbr-check:(isize) ten = 10 // lldb-command:continue // lldb-command:v val // lldbg-check:[...] -1 -// lldbr-check:(i32) val = -1 // lldb-command:v ten // lldbg-check:[...] 10 -// lldbr-check:(isize) ten = 10 // lldb-command:continue // INDEX EXPRESSION // lldb-command:v val // lldbg-check:[...] -1 -// lldbr-check:(i32) val = -1 // lldb-command:v ten // lldbg-check:[...] 10 -// lldbr-check:(isize) ten = 10 // lldb-command:continue // lldb-command:v val // lldbg-check:[...] 18 -// lldbr-check:(isize) val = 18 // lldb-command:v ten // lldbg-check:[...] 10 -// lldbr-check:(isize) ten = 10 // lldb-command:continue // lldb-command:v val // lldbg-check:[...] -1 -// lldbr-check:(i32) val = -1 // lldb-command:v ten // lldbg-check:[...] 10 -// lldbr-check:(isize) ten = 10 // lldb-command:continue #![allow(unused_variables)] diff --git a/tests/debuginfo/method-on-generic-struct.rs b/tests/debuginfo/method-on-generic-struct.rs index 8c2c6a38c269..27e83cbbe223 100644 --- a/tests/debuginfo/method-on-generic-struct.rs +++ b/tests/debuginfo/method-on-generic-struct.rs @@ -57,61 +57,46 @@ // STACK BY REF // lldb-command:v *self // lldbg-check:[...] Struct<(u32, i32)> { x: (8888, -8888) } -// lldbr-check:(method_on_generic_struct::Struct<(u32, i32)>) *self = { x = { = 8888 = -8888 } } // lldb-command:v arg1 // lldbg-check:[...] -1 -// lldbr-check:(isize) arg1 = -1 // lldb-command:v arg2 // lldbg-check:[...] -2 -// lldbr-check:(isize) arg2 = -2 // lldb-command:continue // STACK BY VAL // lldb-command:v self // lldbg-check:[...] Struct<(u32, i32)> { x: (8888, -8888) } -// lldbr-check:(method_on_generic_struct::Struct<(u32, i32)>) self = { x = { = 8888 = -8888 } } // lldb-command:v arg1 // lldbg-check:[...] -3 -// lldbr-check:(isize) arg1 = -3 // lldb-command:v arg2 // lldbg-check:[...] -4 -// lldbr-check:(isize) arg2 = -4 // lldb-command:continue // OWNED BY REF // lldb-command:v *self // lldbg-check:[...] Struct { x: 1234.5 } -// lldbr-check:(method_on_generic_struct::Struct) *self = Struct { x: 1234.5 } // lldb-command:v arg1 // lldbg-check:[...] -5 -// lldbr-check:(isize) arg1 = -5 // lldb-command:v arg2 // lldbg-check:[...] -6 -// lldbr-check:(isize) arg2 = -6 // lldb-command:continue // OWNED BY VAL // lldb-command:v self // lldbg-check:[...] Struct { x: 1234.5 } -// lldbr-check:(method_on_generic_struct::Struct) self = Struct { x: 1234.5 } // lldb-command:v arg1 // lldbg-check:[...] -7 -// lldbr-check:(isize) arg1 = -7 // lldb-command:v arg2 // lldbg-check:[...] -8 -// lldbr-check:(isize) arg2 = -8 // lldb-command:continue // OWNED MOVED // lldb-command:v *self // lldbg-check:[...] Struct { x: 1234.5 } -// lldbr-check:(method_on_generic_struct::Struct) *self = Struct { x: 1234.5 } // lldb-command:v arg1 // lldbg-check:[...] -9 -// lldbr-check:(isize) arg1 = -9 // lldb-command:v arg2 // lldbg-check:[...] -10 -// lldbr-check:(isize) arg2 = -10 // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/method-on-struct.rs b/tests/debuginfo/method-on-struct.rs index d92259b7ab11..307c6d92d489 100644 --- a/tests/debuginfo/method-on-struct.rs +++ b/tests/debuginfo/method-on-struct.rs @@ -57,61 +57,46 @@ // STACK BY REF // lldb-command:v *self // lldbg-check:[...] { x = 100 } -// lldbr-check:(method_on_struct::Struct) *self = Struct { x: 100 } // lldb-command:v arg1 // lldbg-check:[...] -1 -// lldbr-check:(isize) arg1 = -1 // lldb-command:v arg2 // lldbg-check:[...] -2 -// lldbr-check:(isize) arg2 = -2 // lldb-command:continue // STACK BY VAL // lldb-command:v self // lldbg-check:[...] { x = 100 } -// lldbr-check:(method_on_struct::Struct) self = Struct { x: 100 } // lldb-command:v arg1 // lldbg-check:[...] -3 -// lldbr-check:(isize) arg1 = -3 // lldb-command:v arg2 // lldbg-check:[...] -4 -// lldbr-check:(isize) arg2 = -4 // lldb-command:continue // OWNED BY REF // lldb-command:v *self // lldbg-check:[...] { x = 200 } -// lldbr-check:(method_on_struct::Struct) *self = Struct { x: 200 } // lldb-command:v arg1 // lldbg-check:[...] -5 -// lldbr-check:(isize) arg1 = -5 // lldb-command:v arg2 // lldbg-check:[...] -6 -// lldbr-check:(isize) arg2 = -6 // lldb-command:continue // OWNED BY VAL // lldb-command:v self // lldbg-check:[...] { x = 200 } -// lldbr-check:(method_on_struct::Struct) self = Struct { x: 200 } // lldb-command:v arg1 // lldbg-check:[...] -7 -// lldbr-check:(isize) arg1 = -7 // lldb-command:v arg2 // lldbg-check:[...] -8 -// lldbr-check:(isize) arg2 = -8 // lldb-command:continue // OWNED MOVED // lldb-command:v *self // lldbg-check:[...] { x = 200 } -// lldbr-check:(method_on_struct::Struct) *self = Struct { x: 200 } // lldb-command:v arg1 // lldbg-check:[...] -9 -// lldbr-check:(isize) arg1 = -9 // lldb-command:v arg2 // lldbg-check:[...] -10 -// lldbr-check:(isize) arg2 = -10 // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/method-on-trait.rs b/tests/debuginfo/method-on-trait.rs index b4ff61b38b05..29087da0e6a6 100644 --- a/tests/debuginfo/method-on-trait.rs +++ b/tests/debuginfo/method-on-trait.rs @@ -57,61 +57,46 @@ // STACK BY REF // lldb-command:v *self // lldbg-check:[...] { x = 100 } -// lldbr-check:(method_on_trait::Struct) *self = { x = 100 } // lldb-command:v arg1 // lldbg-check:[...] -1 -// lldbr-check:(isize) arg1 = -1 // lldb-command:v arg2 // lldbg-check:[...] -2 -// lldbr-check:(isize) arg2 = -2 // lldb-command:continue // STACK BY VAL // lldb-command:v self // lldbg-check:[...] { x = 100 } -// lldbr-check:(method_on_trait::Struct) self = { x = 100 } // lldb-command:v arg1 // lldbg-check:[...] -3 -// lldbr-check:(isize) arg1 = -3 // lldb-command:v arg2 // lldbg-check:[...] -4 -// lldbr-check:(isize) arg2 = -4 // lldb-command:continue // OWNED BY REF // lldb-command:v *self // lldbg-check:[...] { x = 200 } -// lldbr-check:(method_on_trait::Struct) *self = { x = 200 } // lldb-command:v arg1 // lldbg-check:[...] -5 -// lldbr-check:(isize) arg1 = -5 // lldb-command:v arg2 // lldbg-check:[...] -6 -// lldbr-check:(isize) arg2 = -6 // lldb-command:continue // OWNED BY VAL // lldb-command:v self // lldbg-check:[...] { x = 200 } -// lldbr-check:(method_on_trait::Struct) self = { x = 200 } // lldb-command:v arg1 // lldbg-check:[...] -7 -// lldbr-check:(isize) arg1 = -7 // lldb-command:v arg2 // lldbg-check:[...] -8 -// lldbr-check:(isize) arg2 = -8 // lldb-command:continue // OWNED MOVED // lldb-command:v *self // lldbg-check:[...] { x = 200 } -// lldbr-check:(method_on_trait::Struct) *self = { x = 200 } // lldb-command:v arg1 // lldbg-check:[...] -9 -// lldbr-check:(isize) arg1 = -9 // lldb-command:v arg2 // lldbg-check:[...] -10 -// lldbr-check:(isize) arg2 = -10 // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/method-on-tuple-struct.rs b/tests/debuginfo/method-on-tuple-struct.rs index 0a4beecb0679..7b8d30abf63c 100644 --- a/tests/debuginfo/method-on-tuple-struct.rs +++ b/tests/debuginfo/method-on-tuple-struct.rs @@ -57,61 +57,46 @@ // STACK BY REF // lldb-command:v *self // lldbg-check:[...] { 0 = 100 1 = -100.5 } -// lldbr-check:(method_on_tuple_struct::TupleStruct) *self = { 0 = 100 1 = -100.5 } // lldb-command:v arg1 // lldbg-check:[...] -1 -// lldbr-check:(isize) arg1 = -1 // lldb-command:v arg2 // lldbg-check:[...] -2 -// lldbr-check:(isize) arg2 = -2 // lldb-command:continue // STACK BY VAL // lldb-command:v self // lldbg-check:[...] { 0 = 100 1 = -100.5 } -// lldbr-check:(method_on_tuple_struct::TupleStruct) self = { 0 = 100 1 = -100.5 } // lldb-command:v arg1 // lldbg-check:[...] -3 -// lldbr-check:(isize) arg1 = -3 // lldb-command:v arg2 // lldbg-check:[...] -4 -// lldbr-check:(isize) arg2 = -4 // lldb-command:continue // OWNED BY REF // lldb-command:v *self // lldbg-check:[...] { 0 = 200 1 = -200.5 } -// lldbr-check:(method_on_tuple_struct::TupleStruct) *self = { 0 = 200 1 = -200.5 } // lldb-command:v arg1 // lldbg-check:[...] -5 -// lldbr-check:(isize) arg1 = -5 // lldb-command:v arg2 // lldbg-check:[...] -6 -// lldbr-check:(isize) arg2 = -6 // lldb-command:continue // OWNED BY VAL // lldb-command:v self // lldbg-check:[...] { 0 = 200 1 = -200.5 } -// lldbr-check:(method_on_tuple_struct::TupleStruct) self = { 0 = 200 1 = -200.5 } // lldb-command:v arg1 // lldbg-check:[...] -7 -// lldbr-check:(isize) arg1 = -7 // lldb-command:v arg2 // lldbg-check:[...] -8 -// lldbr-check:(isize) arg2 = -8 // lldb-command:continue // OWNED MOVED // lldb-command:v *self // lldbg-check:[...] { 0 = 200 1 = -200.5 } -// lldbr-check:(method_on_tuple_struct::TupleStruct) *self = { 0 = 200 1 = -200.5 } // lldb-command:v arg1 // lldbg-check:[...] -9 -// lldbr-check:(isize) arg1 = -9 // lldb-command:v arg2 // lldbg-check:[...] -10 -// lldbr-check:(isize) arg2 = -10 // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/multi-cgu.rs b/tests/debuginfo/multi-cgu.rs index 69460c40e622..81735f2bc09a 100644 --- a/tests/debuginfo/multi-cgu.rs +++ b/tests/debuginfo/multi-cgu.rs @@ -22,12 +22,10 @@ // lldb-command:v xxx // lldbg-check:[...] 12345 -// lldbr-check:(u32) xxx = 12345 // lldb-command:continue // lldb-command:v yyy // lldbg-check:[...] 67890 -// lldbr-check:(u64) yyy = 67890 // lldb-command:continue diff --git a/tests/debuginfo/multiple-functions-equal-var-names.rs b/tests/debuginfo/multiple-functions-equal-var-names.rs index 8ea3d5df2b04..cbf513ad0f71 100644 --- a/tests/debuginfo/multiple-functions-equal-var-names.rs +++ b/tests/debuginfo/multiple-functions-equal-var-names.rs @@ -22,17 +22,14 @@ // lldb-command:v abc // lldbg-check:[...] 10101 -// lldbr-check:(i32) abc = 10101 // lldb-command:continue // lldb-command:v abc // lldbg-check:[...] 20202 -// lldbr-check:(i32) abc = 20202 // lldb-command:continue // lldb-command:v abc // lldbg-check:[...] 30303 -// lldbr-check:(i32) abc = 30303 #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/multiple-functions.rs b/tests/debuginfo/multiple-functions.rs index c1a357499f0f..a113ce17855c 100644 --- a/tests/debuginfo/multiple-functions.rs +++ b/tests/debuginfo/multiple-functions.rs @@ -22,17 +22,14 @@ // lldb-command:v a // lldbg-check:[...] 10101 -// lldbr-check:(i32) a = 10101 // lldb-command:continue // lldb-command:v b // lldbg-check:[...] 20202 -// lldbr-check:(i32) b = 20202 // lldb-command:continue // lldb-command:v c // lldbg-check:[...] 30303 -// lldbr-check:(i32) c = 30303 #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/name-shadowing-and-scope-nesting.rs b/tests/debuginfo/name-shadowing-and-scope-nesting.rs index 1a46a2d3890d..9d1accd963be 100644 --- a/tests/debuginfo/name-shadowing-and-scope-nesting.rs +++ b/tests/debuginfo/name-shadowing-and-scope-nesting.rs @@ -47,50 +47,38 @@ // lldb-command:v x // lldbg-check:[...] false -// lldbr-check:(bool) x = false // lldb-command:v y // lldbg-check:[...] true -// lldbr-check:(bool) y = true // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 10 -// lldbr-check:(i32) x = 10 // lldb-command:v y // lldbg-check:[...] true -// lldbr-check:(bool) y = true // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 10.5 -// lldbr-check:(f64) x = 10.5 // lldb-command:v y // lldbg-check:[...] 20 -// lldbr-check:(i32) y = 20 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] true -// lldbr-check:(bool) x = true // lldb-command:v y // lldbg-check:[...] 2220 -// lldbr-check:(i32) y = 2220 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 203203.5 -// lldbr-check:(f64) x = 203203.5 // lldb-command:v y // lldbg-check:[...] 2220 -// lldbr-check:(i32) y = 2220 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 10.5 -// lldbr-check:(f64) x = 10.5 // lldb-command:v y // lldbg-check:[...] 20 -// lldbr-check:(i32) y = 20 // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/packed-struct-with-destructor.rs b/tests/debuginfo/packed-struct-with-destructor.rs index a7683781b704..f715fdaea6fe 100644 --- a/tests/debuginfo/packed-struct-with-destructor.rs +++ b/tests/debuginfo/packed-struct-with-destructor.rs @@ -36,35 +36,27 @@ // lldb-command:v packed // lldbg-check:[...] { x = 123 y = 234 z = 345 } -// lldbr-check:(packed_struct_with_destructor::Packed) packed = { x = 123 y = 234 z = 345 } // lldb-command:v packedInPacked // lldbg-check:[...] { a = 1111 b = { x = 2222 y = 3333 z = 4444 } c = 5555 d = { x = 6666 y = 7777 z = 8888 } } -// lldbr-check:(packed_struct_with_destructor::PackedInPacked) packedInPacked = { a = 1111 b = { x = 2222 y = 3333 z = 4444 } c = 5555 d = { x = 6666 y = 7777 z = 8888 } } // lldb-command:v packedInUnpacked // lldbg-check:[...] { a = -1111 b = { x = -2222 y = -3333 z = -4444 } c = -5555 d = { x = -6666 y = -7777 z = -8888 } } -// lldbr-check:(packed_struct_with_destructor::PackedInUnpacked) packedInUnpacked = { a = -1111 b = { x = -2222 y = -3333 z = -4444 } c = -5555 d = { x = -6666 y = -7777 z = -8888 } } // lldb-command:v unpackedInPacked // lldbg-check:[...] { a = 987 b = { x = 876 y = 765 z = 654 } c = { x = 543 y = 432 z = 321 } d = 210 } -// lldbr-check:(packed_struct_with_destructor::UnpackedInPacked) unpackedInPacked = { a = 987 b = { x = 876 y = 765 z = 654 } c = { x = 543 y = 432 z = 321 } d = 210 } // lldb-command:v packedInPackedWithDrop // lldbg-check:[...] { a = 11 b = { x = 22 y = 33 z = 44 } c = 55 d = { x = 66 y = 77 z = 88 } } -// lldbr-check:(packed_struct_with_destructor::PackedInPackedWithDrop) packedInPackedWithDrop = { a = 11 b = { x = 22 y = 33 z = 44 } c = 55 d = { x = 66 y = 77 z = 88 } } // lldb-command:v packedInUnpackedWithDrop // lldbg-check:[...] { a = -11 b = { x = -22 y = -33 z = -44 } c = -55 d = { x = -66 y = -77 z = -88 } } -// lldbr-check:(packed_struct_with_destructor::PackedInUnpackedWithDrop) packedInUnpackedWithDrop = { a = -11 b = { x = -22 y = -33 z = -44 } c = -55 d = { x = -66 y = -77 z = -88 } } // lldb-command:v unpackedInPackedWithDrop // lldbg-check:[...] { a = 98 b = { x = 87 y = 76 z = 65 } c = { x = 54 y = 43 z = 32 } d = 21 } -// lldbr-check:(packed_struct_with_destructor::UnpackedInPackedWithDrop) unpackedInPackedWithDrop = { a = 98 b = { x = 87 y = 76 z = 65 } c = { x = 54 y = 43 z = 32 } d = 21 } // lldb-command:v deeplyNested // lldbg-check:[...] { a = { a = 1 b = { x = 2 y = 3 z = 4 } c = 5 d = { x = 6 y = 7 z = 8 } } b = { a = 9 b = { x = 10 y = 11 z = 12 } c = { x = 13 y = 14 z = 15 } d = 16 } c = { a = 17 b = { x = 18 y = 19 z = 20 } c = 21 d = { x = 22 y = 23 z = 24 } } d = { a = 25 b = { x = 26 y = 27 z = 28 } c = 29 d = { x = 30 y = 31 z = 32 } } e = { a = 33 b = { x = 34 y = 35 z = 36 } c = { x = 37 y = 38 z = 39 } d = 40 } f = { a = 41 b = { x = 42 y = 43 z = 44 } c = 45 d = { x = 46 y = 47 z = 48 } } } -// lldbr-check:(packed_struct_with_destructor::DeeplyNested) deeplyNested = { a = { a = 1 b = { x = 2 y = 3 z = 4 } c = 5 d = { x = 6 y = 7 z = 8 } } b = { a = 9 b = { x = 10 y = 11 z = 12 } c = { x = 13 y = 14 z = 15 } d = 16 } c = { a = 17 b = { x = 18 y = 19 z = 20 } c = 21 d = { x = 22 y = 23 z = 24 } } d = { a = 25 b = { x = 26 y = 27 z = 28 } c = 29 d = { x = 30 y = 31 z = 32 } } e = { a = 33 b = { x = 34 y = 35 z = 36 } c = { x = 37 y = 38 z = 39 } d = 40 } f = { a = 41 b = { x = 42 y = 43 z = 44 } c = 45 d = { x = 46 y = 47 z = 48 } } } #![allow(unused_variables)] diff --git a/tests/debuginfo/packed-struct.rs b/tests/debuginfo/packed-struct.rs index 670482ef41e6..5f5233e3732d 100644 --- a/tests/debuginfo/packed-struct.rs +++ b/tests/debuginfo/packed-struct.rs @@ -29,27 +29,21 @@ // lldb-command:v packed // lldbg-check:[...] { x = 123 y = 234 z = 345 } -// lldbr-check:(packed_struct::Packed) packed = { x = 123 y = 234 z = 345 } // lldb-command:v packedInPacked // lldbg-check:[...] { a = 1111 b = { x = 2222 y = 3333 z = 4444 } c = 5555 d = { x = 6666 y = 7777 z = 8888 } } -// lldbr-check:(packed_struct::PackedInPacked) packedInPacked = { a = 1111 b = { x = 2222 y = 3333 z = 4444 } c = 5555 d = { x = 6666 y = 7777 z = 8888 } } // lldb-command:v packedInUnpacked // lldbg-check:[...] { a = -1111 b = { x = -2222 y = -3333 z = -4444 } c = -5555 d = { x = -6666 y = -7777 z = -8888 } } -// lldbr-check:(packed_struct::PackedInUnpacked) packedInUnpacked = { a = -1111 b = { x = -2222 y = -3333 z = -4444 } c = -5555 d = { x = -6666 y = -7777 z = -8888 } } // lldb-command:v unpackedInPacked // lldbg-check:[...] { a = 987 b = { x = 876 y = 765 z = 654 w = 543 } c = { x = 432 y = 321 z = 210 w = 109 } d = -98 } -// lldbr-check:(packed_struct::UnpackedInPacked) unpackedInPacked = { a = 987 b = { x = 876 y = 765 z = 654 w = 543 } c = { x = 432 y = 321 z = 210 w = 109 } d = -98 } // lldb-command:expr sizeof(packed) // lldbg-check:[...] 14 -// lldbr-check:(usize) [...] 14 // lldb-command:expr sizeof(packedInPacked) // lldbg-check:[...] 40 -// lldbr-check:(usize) [...] 40 #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/pretty-std-collections.rs b/tests/debuginfo/pretty-std-collections.rs index 14f64e83cffc..2489d6d41362 100644 --- a/tests/debuginfo/pretty-std-collections.rs +++ b/tests/debuginfo/pretty-std-collections.rs @@ -53,19 +53,15 @@ // lldb-command:v vec_deque // lldbg-check:[...] size=3 { [0] = 5 [1] = 3 [2] = 7 } -// lldbr-check:(alloc::collections::vec_deque::VecDeque) vec_deque = size=3 = { [0] = 5 [1] = 3 [2] = 7 } // lldb-command:v vec_deque2 // lldbg-check:[...] size=7 { [0] = 2 [1] = 3 [2] = 4 [3] = 5 [4] = 6 [5] = 7 [6] = 8 } -// lldbr-check:(alloc::collections::vec_deque::VecDeque) vec_deque2 = size=7 = { [0] = 2 [1] = 3 [2] = 4 [3] = 5 [4] = 6 [5] = 7 [6] = 8 } // lldb-command:v hash_map // lldbg-check:[...] size=4 { [0] = { 0 = 1 1 = 10 } [1] = { 0 = 2 1 = 20 } [2] = { 0 = 3 1 = 30 } [3] = { 0 = 4 1 = 40 } } -// lldbr-check:(std::collections::hash::map::HashMap) hash_map = size=4 size=4 { [0] = { 0 = 1 1 = 10 } [1] = { 0 = 2 1 = 20 } [2] = { 0 = 3 1 = 30 } [3] = { 0 = 4 1 = 40 } } // lldb-command:v hash_set // lldbg-check:[...] size=4 { [0] = 1 [1] = 2 [2] = 3 [3] = 4 } -// lldbr-check:(std::collections::hash::set::HashSet) hash_set = size=4 { [0] = 1 [1] = 2 [2] = 3 [3] = 4 } #![allow(unused_variables)] use std::collections::BTreeMap; diff --git a/tests/debuginfo/reference-debuginfo.rs b/tests/debuginfo/reference-debuginfo.rs index 514228c69981..3889c1f5ba8f 100644 --- a/tests/debuginfo/reference-debuginfo.rs +++ b/tests/debuginfo/reference-debuginfo.rs @@ -61,66 +61,49 @@ // lldb-command:run // lldb-command:v *bool_ref // lldbg-check:[...] true -// lldbr-check:(bool) *bool_ref = true // lldb-command:v *int_ref // lldbg-check:[...] -1 -// lldbr-check:(isize) *int_ref = -1 -// lldbr-command:print *char_ref -// lldbr-check:(char) *char_ref = 'a' // lldb-command:v *i8_ref // lldbg-check:[...] 'D' -// lldbr-check:(i8) *i8_ref = 68 // lldb-command:v *i16_ref // lldbg-check:[...] -16 -// lldbr-check:(i16) *i16_ref = -16 // lldb-command:v *i32_ref // lldbg-check:[...] -32 -// lldbr-check:(i32) *i32_ref = -32 // lldb-command:v *i64_ref // lldbg-check:[...] -64 -// lldbr-check:(i64) *i64_ref = -64 // lldb-command:v *uint_ref // lldbg-check:[...] 1 -// lldbr-check:(usize) *uint_ref = 1 // lldb-command:v *u8_ref // lldbg-check:[...] 'd' -// lldbr-check:(u8) *u8_ref = 100 // lldb-command:v *u16_ref // lldbg-check:[...] 16 -// lldbr-check:(u16) *u16_ref = 16 // lldb-command:v *u32_ref // lldbg-check:[...] 32 -// lldbr-check:(u32) *u32_ref = 32 // lldb-command:v *u64_ref // lldbg-check:[...] 64 -// lldbr-check:(u64) *u64_ref = 64 // lldb-command:v *f16_ref // lldbg-check:[...] 1.5 -// lldbr-check:(f16) *f16_ref = 1.5 // lldb-command:v *f32_ref // lldbg-check:[...] 2.5 -// lldbr-check:(f32) *f32_ref = 2.5 // lldb-command:v *f64_ref // lldbg-check:[...] 3.5 -// lldbr-check:(f64) *f64_ref = 3.5 // lldb-command:v *f64_double_ref // lldbg-check:[...] 3.5 -// lldbr-check:(f64) **f64_double_ref = 3.5 #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/regression-bad-location-list-67992.rs b/tests/debuginfo/regression-bad-location-list-67992.rs index fe410942d51e..6502cce3700f 100644 --- a/tests/debuginfo/regression-bad-location-list-67992.rs +++ b/tests/debuginfo/regression-bad-location-list-67992.rs @@ -12,7 +12,6 @@ // lldb-command:run // lldb-command:v a // lldbg-check:(regression_bad_location_list_67992::Foo) [...] -// lldbr-check:(regression_bad_location_list_67992::Foo) a = [...] const ARRAY_SIZE: usize = 1024; diff --git a/tests/debuginfo/self-in-default-method.rs b/tests/debuginfo/self-in-default-method.rs index 9507e2c04a25..8c607d012105 100644 --- a/tests/debuginfo/self-in-default-method.rs +++ b/tests/debuginfo/self-in-default-method.rs @@ -57,61 +57,46 @@ // STACK BY REF // lldb-command:v *self // lldbg-check:[...] { x = 100 } -// lldbr-check:(self_in_default_method::Struct) *self = Struct { x: 100 } // lldb-command:v arg1 // lldbg-check:[...] -1 -// lldbr-check:(isize) arg1 = -1 // lldb-command:v arg2 // lldbg-check:[...] -2 -// lldbr-check:(isize) arg2 = -2 // lldb-command:continue // STACK BY VAL // lldb-command:v self // lldbg-check:[...] { x = 100 } -// lldbr-check:(self_in_default_method::Struct) self = Struct { x: 100 } // lldb-command:v arg1 // lldbg-check:[...] -3 -// lldbr-check:(isize) arg1 = -3 // lldb-command:v arg2 // lldbg-check:[...] -4 -// lldbr-check:(isize) arg2 = -4 // lldb-command:continue // OWNED BY REF // lldb-command:v *self // lldbg-check:[...] { x = 200 } -// lldbr-check:(self_in_default_method::Struct) *self = Struct { x: 200 } // lldb-command:v arg1 // lldbg-check:[...] -5 -// lldbr-check:(isize) arg1 = -5 // lldb-command:v arg2 // lldbg-check:[...] -6 -// lldbr-check:(isize) arg2 = -6 // lldb-command:continue // OWNED BY VAL // lldb-command:v self // lldbg-check:[...] { x = 200 } -// lldbr-check:(self_in_default_method::Struct) self = Struct { x: 200 } // lldb-command:v arg1 // lldbg-check:[...] -7 -// lldbr-check:(isize) arg1 = -7 // lldb-command:v arg2 // lldbg-check:[...] -8 -// lldbr-check:(isize) arg2 = -8 // lldb-command:continue // OWNED MOVED // lldb-command:v *self // lldbg-check:[...] { x = 200 } -// lldbr-check:(self_in_default_method::Struct) *self = Struct { x: 200 } // lldb-command:v arg1 // lldbg-check:[...] -9 -// lldbr-check:(isize) arg1 = -9 // lldb-command:v arg2 // lldbg-check:[...] -10 -// lldbr-check:(isize) arg2 = -10 // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/self-in-generic-default-method.rs b/tests/debuginfo/self-in-generic-default-method.rs index 4cb68f6fed8d..71d1f2d52d26 100644 --- a/tests/debuginfo/self-in-generic-default-method.rs +++ b/tests/debuginfo/self-in-generic-default-method.rs @@ -57,61 +57,46 @@ // STACK BY REF // lldb-command:v *self // lldbg-check:[...] { x = 987 } -// lldbr-check:(self_in_generic_default_method::Struct) *self = Struct { x: 987 } // lldb-command:v arg1 // lldbg-check:[...] -1 -// lldbr-check:(isize) arg1 = -1 // lldb-command:v arg2 // lldbg-check:[...] 2 -// lldbr-check:(u16) arg2 = 2 // lldb-command:continue // STACK BY VAL // lldb-command:v self // lldbg-check:[...] { x = 987 } -// lldbr-check:(self_in_generic_default_method::Struct) self = Struct { x: 987 } // lldb-command:v arg1 // lldbg-check:[...] -3 -// lldbr-check:(isize) arg1 = -3 // lldb-command:v arg2 // lldbg-check:[...] -4 -// lldbr-check:(i16) arg2 = -4 // lldb-command:continue // OWNED BY REF // lldb-command:v *self // lldbg-check:[...] { x = 879 } -// lldbr-check:(self_in_generic_default_method::Struct) *self = Struct { x: 879 } // lldb-command:v arg1 // lldbg-check:[...] -5 -// lldbr-check:(isize) arg1 = -5 // lldb-command:v arg2 // lldbg-check:[...] -6 -// lldbr-check:(i32) arg2 = -6 // lldb-command:continue // OWNED BY VAL // lldb-command:v self // lldbg-check:[...] { x = 879 } -// lldbr-check:(self_in_generic_default_method::Struct) self = Struct { x: 879 } // lldb-command:v arg1 // lldbg-check:[...] -7 -// lldbr-check:(isize) arg1 = -7 // lldb-command:v arg2 // lldbg-check:[...] -8 -// lldbr-check:(i64) arg2 = -8 // lldb-command:continue // OWNED MOVED // lldb-command:v *self // lldbg-check:[...] { x = 879 } -// lldbr-check:(self_in_generic_default_method::Struct) *self = Struct { x: 879 } // lldb-command:v arg1 // lldbg-check:[...] -9 -// lldbr-check:(isize) arg1 = -9 // lldb-command:v arg2 // lldbg-check:[...] -10.5 -// lldbr-check:(f32) arg2 = -10.5 // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/shadowed-argument.rs b/tests/debuginfo/shadowed-argument.rs index f85910652c8a..b4da794ef955 100644 --- a/tests/debuginfo/shadowed-argument.rs +++ b/tests/debuginfo/shadowed-argument.rs @@ -29,26 +29,20 @@ // lldb-command:v x // lldbg-check:[...] false -// lldbr-check:(bool) x = false // lldb-command:v y // lldbg-check:[...] true -// lldbr-check:(bool) y = true // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 10 -// lldbr-check:(i32) x = 10 // lldb-command:v y // lldbg-check:[...] true -// lldbr-check:(bool) y = true // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 10.5 -// lldbr-check:(f64) x = 10.5 // lldb-command:v y // lldbg-check:[...] 20 -// lldbr-check:(i32) y = 20 // lldb-command:continue diff --git a/tests/debuginfo/shadowed-variable.rs b/tests/debuginfo/shadowed-variable.rs index 87c85a9e1e26..cbbad4c2b7cb 100644 --- a/tests/debuginfo/shadowed-variable.rs +++ b/tests/debuginfo/shadowed-variable.rs @@ -40,42 +40,32 @@ // lldb-command:v x // lldbg-check:[...] false -// lldbr-check:(bool) x = false // lldb-command:v y // lldbg-check:[...] true -// lldbr-check:(bool) y = true // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 10 -// lldbr-check:(i32) x = 10 // lldb-command:v y // lldbg-check:[...] true -// lldbr-check:(bool) y = true // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 10.5 -// lldbr-check:(f64) x = 10.5 // lldb-command:v y // lldbg-check:[...] 20 -// lldbr-check:(i32) y = 20 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 10.5 -// lldbr-check:(f64) x = 10.5 // lldb-command:v y // lldbg-check:[...] 20 -// lldbr-check:(i32) y = 20 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 11.5 -// lldbr-check:(f64) x = 11.5 // lldb-command:v y // lldbg-check:[...] 20 -// lldbr-check:(i32) y = 20 // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/simple-lexical-scope.rs b/tests/debuginfo/simple-lexical-scope.rs index 148ad589deca..82737b04b644 100644 --- a/tests/debuginfo/simple-lexical-scope.rs +++ b/tests/debuginfo/simple-lexical-scope.rs @@ -39,37 +39,30 @@ // lldb-command:v x // lldbg-check:[...] false -// lldbr-check:(bool) x = false // lldb-command:continue // lldb-command:v x // lldbg-check:[...] false -// lldbr-check:(bool) x = false // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 10 -// lldbr-check:(i32) x = 10 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 10 -// lldbr-check:(i32) x = 10 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 10.5 -// lldbr-check:(f64) x = 10.5 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] 10 -// lldbr-check:(i32) x = 10 // lldb-command:continue // lldb-command:v x // lldbg-check:[...] false -// lldbr-check:(bool) x = false // lldb-command:continue diff --git a/tests/debuginfo/simple-struct.rs b/tests/debuginfo/simple-struct.rs index 65bfb84cdcd4..9fe4d3c8d3fa 100644 --- a/tests/debuginfo/simple-struct.rs +++ b/tests/debuginfo/simple-struct.rs @@ -66,27 +66,21 @@ // lldb-command:v no_padding16 // lldbg-check:[...] { x = 10000 y = -10001 } -// lldbr-check:(simple_struct::NoPadding16) no_padding16 = { x = 10000 y = -10001 } // lldb-command:v no_padding32 // lldbg-check:[...] { x = -10002 y = -10003.5 z = 10004 } -// lldbr-check:(simple_struct::NoPadding32) no_padding32 = { x = -10002 y = -10003.5 z = 10004 } // lldb-command:v no_padding64 // lldbg-check:[...] { x = -10005.5 y = 10006 z = 10007 } -// lldbr-check:(simple_struct::NoPadding64) no_padding64 = { x = -10005.5 y = 10006 z = 10007 } // lldb-command:v no_padding163264 // lldbg-check:[...] { a = -10008 b = 10009 c = 10010 d = 10011 } -// lldbr-check:(simple_struct::NoPadding163264) no_padding163264 = { a = -10008 b = 10009 c = 10010 d = 10011 } // lldb-command:v internal_padding // lldbg-check:[...] { x = 10012 y = -10013 } -// lldbr-check:(simple_struct::InternalPadding) internal_padding = { x = 10012 y = -10013 } // lldb-command:v padding_at_end // lldbg-check:[...] { x = -10014 y = 10015 } -// lldbr-check:(simple_struct::PaddingAtEnd) padding_at_end = { x = -10014 y = 10015 } #![allow(unused_variables)] #![allow(dead_code)] diff --git a/tests/debuginfo/simple-tuple.rs b/tests/debuginfo/simple-tuple.rs index 6dadf9236556..f267fc7d8d94 100644 --- a/tests/debuginfo/simple-tuple.rs +++ b/tests/debuginfo/simple-tuple.rs @@ -62,27 +62,20 @@ // lldb-command:v/d noPadding8 // lldbg-check:[...] { 0 = -100 1 = 100 } -// lldbr-check:((i8, u8)) noPadding8 = { 0 = -100 1 = 100 } // lldb-command:v noPadding16 // lldbg-check:[...] { 0 = 0 1 = 1 2 = 2 } -// lldbr-check:((i16, i16, u16)) noPadding16 = { 0 = 0 1 = 1 2 = 2 } // lldb-command:v noPadding32 // lldbg-check:[...] { 0 = 3 1 = 4.5 2 = 5 } -// lldbr-check:((i32, f32, u32)) noPadding32 = { 0 = 3 1 = 4.5 2 = 5 } // lldb-command:v noPadding64 // lldbg-check:[...] { 0 = 6 1 = 7.5 2 = 8 } -// lldbr-check:((i64, f64, u64)) noPadding64 = { 0 = 6 1 = 7.5 2 = 8 } // lldb-command:v internalPadding1 // lldbg-check:[...] { 0 = 9 1 = 10 } -// lldbr-check:((i16, i32)) internalPadding1 = { 0 = 9 1 = 10 } // lldb-command:v internalPadding2 // lldbg-check:[...] { 0 = 11 1 = 12 2 = 13 3 = 14 } -// lldbr-check:((i16, i32, u32, u64)) internalPadding2 = { 0 = 11 1 = 12 2 = 13 3 = 14 } // lldb-command:v paddingAtEnd // lldbg-check:[...] { 0 = 15 1 = 16 } -// lldbr-check:((i32, i16)) paddingAtEnd = { 0 = 15 1 = 16 } // === CDB TESTS ================================================================================== diff --git a/tests/debuginfo/static-method-on-struct-and-enum.rs b/tests/debuginfo/static-method-on-struct-and-enum.rs index defced1441ca..5d2932e378df 100644 --- a/tests/debuginfo/static-method-on-struct-and-enum.rs +++ b/tests/debuginfo/static-method-on-struct-and-enum.rs @@ -28,22 +28,17 @@ // STRUCT // lldb-command:v arg1 // lldbg-check:[...] 1 -// lldbr-check:(isize) arg1 = 1 // lldb-command:v arg2 // lldbg-check:[...] 2 -// lldbr-check:(isize) arg2 = 2 // lldb-command:continue // ENUM // lldb-command:v arg1 // lldbg-check:[...] -3 -// lldbr-check:(isize) arg1 = -3 // lldb-command:v arg2 // lldbg-check:[...] 4.5 -// lldbr-check:(f64) arg2 = 4.5 // lldb-command:v arg3 // lldbg-check:[...] 5 -// lldbr-check:(usize) arg3 = 5 // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/struct-in-struct.rs b/tests/debuginfo/struct-in-struct.rs index 2e32633fa87e..5dde8079f9aa 100644 --- a/tests/debuginfo/struct-in-struct.rs +++ b/tests/debuginfo/struct-in-struct.rs @@ -20,35 +20,27 @@ // lldb-command:v three_simple_structs // lldbg-check:[...] { x = { x = 1 } y = { x = 2 } z = { x = 3 } } -// lldbr-check:(struct_in_struct::ThreeSimpleStructs) three_simple_structs = { x = { x = 1 } y = { x = 2 } z = { x = 3 } } // lldb-command:v internal_padding_parent // lldbg-check:[...] { x = { x = 4 y = 5 } y = { x = 6 y = 7 } z = { x = 8 y = 9 } } -// lldbr-check:(struct_in_struct::InternalPaddingParent) internal_padding_parent = { x = { x = 4 y = 5 } y = { x = 6 y = 7 } z = { x = 8 y = 9 } } // lldb-command:v padding_at_end_parent // lldbg-check:[...] { x = { x = 10 y = 11 } y = { x = 12 y = 13 } z = { x = 14 y = 15 } } -// lldbr-check:(struct_in_struct::PaddingAtEndParent) padding_at_end_parent = { x = { x = 10 y = 11 } y = { x = 12 y = 13 } z = { x = 14 y = 15 } } // lldb-command:v mixed // lldbg-check:[...] { x = { x = 16 y = 17 } y = { x = 18 y = 19 } z = { x = 20 } w = 21 } -// lldbr-check:(struct_in_struct::Mixed) mixed = { x = { x = 16 y = 17 } y = { x = 18 y = 19 } z = { x = 20 } w = 21 } // lldb-command:v bag // lldbg-check:[...] { x = { x = 22 } } -// lldbr-check:(struct_in_struct::Bag) bag = { x = { x = 22 } } // lldb-command:v bag_in_bag // lldbg-check:[...] { x = { x = { x = 23 } } } -// lldbr-check:(struct_in_struct::BagInBag) bag_in_bag = { x = { x = { x = 23 } } } // lldb-command:v tjo // lldbg-check:[...] { x = { x = { x = { x = 24 } } } } -// lldbr-check:(struct_in_struct::ThatsJustOverkill) tjo = { x = { x = { x = { x = 24 } } } } // lldb-command:v tree // lldbg-check:[...] { x = { x = 25 } y = { x = { x = 26 y = 27 } y = { x = 28 y = 29 } z = { x = 30 y = 31 } } z = { x = { x = { x = 32 } } } } -// lldbr-check:(struct_in_struct::Tree) tree = { x = { x = 25 } y = { x = { x = 26 y = 27 } y = { x = 28 y = 29 } z = { x = 30 y = 31 } } z = { x = { x = { x = 32 } } } } #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/struct-namespace.rs b/tests/debuginfo/struct-namespace.rs index 83f2962140aa..aacc1d3825d7 100644 --- a/tests/debuginfo/struct-namespace.rs +++ b/tests/debuginfo/struct-namespace.rs @@ -6,17 +6,13 @@ // lldb-command:run // lldb-command:v struct1 // lldbg-check:(struct_namespace::Struct1)[...] -// lldbr-check:(struct_namespace::Struct1) struct1 = Struct1 { a: 0, b: 1 } // lldb-command:v struct2 // lldbg-check:(struct_namespace::Struct2)[...] -// lldbr-check:(struct_namespace::Struct2) struct2 = { = 2 } // lldb-command:v mod1_struct1 // lldbg-check:(struct_namespace::mod1::Struct1)[...] -// lldbr-check:(struct_namespace::mod1::Struct1) mod1_struct1 = Struct1 { a: 3, b: 4 } // lldb-command:v mod1_struct2 // lldbg-check:(struct_namespace::mod1::Struct2)[...] -// lldbr-check:(struct_namespace::mod1::Struct2) mod1_struct2 = { = 5 } #![allow(unused_variables)] #![allow(dead_code)] diff --git a/tests/debuginfo/struct-style-enum.rs b/tests/debuginfo/struct-style-enum.rs index c3cfb29994e7..c2f7fb688ed2 100644 --- a/tests/debuginfo/struct-style-enum.rs +++ b/tests/debuginfo/struct-style-enum.rs @@ -25,19 +25,15 @@ // lldb-command:v case1 // lldbg-check:(struct_style_enum::Regular) case1 = { value = { a = 0 b = 31868 c = 31868 d = 31868 e = 31868 } $discr$ = 0 } -// lldbr-check:(struct_style_enum::Regular::Case1) case1 = { a = 0 b = 31868 c = 31868 d = 31868 e = 31868 } // lldb-command:v case2 // lldbg-check:(struct_style_enum::Regular) case2 = { value = { a = 0 b = 286331153 c = 286331153 } $discr$ = 1 } -// lldbr-check:(struct_style_enum::Regular::Case2) case2 = Case2 { Case1: 0, Case2: 286331153, Case3: 286331153 } // lldb-command:v case3 // lldbg-check:(struct_style_enum::Regular) case3 = { value = { a = 0 b = 6438275382588823897 } $discr$ = 2 } -// lldbr-check:(struct_style_enum::Regular::Case3) case3 = Case3 { Case1: 0, Case2: 6438275382588823897 } // lldb-command:v univariant // lldbg-check:(struct_style_enum::Univariant) univariant = { value = { a = -1 } } -// lldbr-check:(struct_style_enum::Univariant) univariant = Univariant { TheOnlyCase: TheOnlyCase { a: -1 } } #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/struct-with-destructor.rs b/tests/debuginfo/struct-with-destructor.rs index 05a4b7572831..654a574ebb5e 100644 --- a/tests/debuginfo/struct-with-destructor.rs +++ b/tests/debuginfo/struct-with-destructor.rs @@ -21,19 +21,15 @@ // lldb-command:run // lldb-command:v simple // lldbg-check:[...] { x = 10 y = 20 } -// lldbr-check:(struct_with_destructor::WithDestructor) simple = { x = 10 y = 20 } // lldb-command:v noDestructor // lldbg-check:[...] { a = { x = 10 y = 20 } guard = -1 } -// lldbr-check:(struct_with_destructor::NoDestructorGuarded) noDestructor = { a = { x = 10 y = 20 } guard = -1 } // lldb-command:v withDestructor // lldbg-check:[...] { a = { x = 10 y = 20 } guard = -1 } -// lldbr-check:(struct_with_destructor::WithDestructorGuarded) withDestructor = { a = { x = 10 y = 20 } guard = -1 } // lldb-command:v nested // lldbg-check:[...] { a = { a = { x = 7890 y = 9870 } } } -// lldbr-check:(struct_with_destructor::NestedOuter) nested = { a = { a = { x = 7890 y = 9870 } } } #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/tuple-in-tuple.rs b/tests/debuginfo/tuple-in-tuple.rs index 0d7ffc634701..74ccaf14d00b 100644 --- a/tests/debuginfo/tuple-in-tuple.rs +++ b/tests/debuginfo/tuple-in-tuple.rs @@ -28,27 +28,20 @@ // lldb-command:v no_padding1 // lldbg-check:[...] { 0 = { 0 = 0 1 = 1 } 1 = 2 2 = 3 } -// lldbr-check:(((u32, u32), u32, u32)) no_padding1 = { 0 = { 0 = 0 1 = 1 } 1 = 2 2 = 3 } // lldb-command:v no_padding2 // lldbg-check:[...] { 0 = 4 1 = { 0 = 5 1 = 6 } 2 = 7 } -// lldbr-check:((u32, (u32, u32), u32)) no_padding2 = { 0 = 4 1 = { 0 = 5 1 = 6 } 2 = 7 } // lldb-command:v no_padding3 // lldbg-check:[...] { 0 = 8 1 = 9 2 = { 0 = 10 1 = 11 } } -// lldbr-check:((u32, u32, (u32, u32))) no_padding3 = { 0 = 8 1 = 9 2 = { 0 = 10 1 = 11 } } // lldb-command:v internal_padding1 // lldbg-check:[...] { 0 = 12 1 = { 0 = 13 1 = 14 } } -// lldbr-check:((i16, (i32, i32))) internal_padding1 = { 0 = 12 1 = { 0 = 13 1 = 14 } } // lldb-command:v internal_padding2 // lldbg-check:[...] { 0 = 15 1 = { 0 = 16 1 = 17 } } -// lldbr-check:((i16, (i16, i32))) internal_padding2 = { 0 = 15 1 = { 0 = 16 1 = 17 } } // lldb-command:v padding_at_end1 // lldbg-check:[...] { 0 = 18 1 = { 0 = 19 1 = 20 } } -// lldbr-check:((i32, (i32, i16))) padding_at_end1 = { 0 = 18 1 = { 0 = 19 1 = 20 } } // lldb-command:v padding_at_end2 // lldbg-check:[...] { 0 = { 0 = 21 1 = 22 } 1 = 23 } -// lldbr-check:(((i32, i16), i32)) padding_at_end2 = { 0 = { 0 = 21 1 = 22 } 1 = 23 } // === CDB TESTS ================================================================================== diff --git a/tests/debuginfo/tuple-struct.rs b/tests/debuginfo/tuple-struct.rs index abfbfac22eb8..f9755a8a0d5b 100644 --- a/tests/debuginfo/tuple-struct.rs +++ b/tests/debuginfo/tuple-struct.rs @@ -29,27 +29,21 @@ // lldb-command:v no_padding16 // lldbg-check:[...] { 0 = 10000 1 = -10001 } -// lldbr-check:(tuple_struct::NoPadding16) no_padding16 = { 0 = 10000 1 = -10001 } // lldb-command:v no_padding32 // lldbg-check:[...] { 0 = -10002 1 = -10003.5 2 = 10004 } -// lldbr-check:(tuple_struct::NoPadding32) no_padding32 = { 0 = -10002 1 = -10003.5 2 = 10004 } // lldb-command:v no_padding64 // lldbg-check:[...] { 0 = -10005.5 1 = 10006 2 = 10007 } -// lldbr-check:(tuple_struct::NoPadding64) no_padding64 = { 0 = -10005.5 1 = 10006 2 = 10007 } // lldb-command:v no_padding163264 // lldbg-check:[...] { 0 = -10008 1 = 10009 2 = 10010 3 = 10011 } -// lldbr-check:(tuple_struct::NoPadding163264) no_padding163264 = { 0 = -10008 1 = 10009 2 = 10010 3 = 10011 } // lldb-command:v internal_padding // lldbg-check:[...] { 0 = 10012 1 = -10013 } -// lldbr-check:(tuple_struct::InternalPadding) internal_padding = { 0 = 10012 1 = -10013 } // lldb-command:v padding_at_end // lldbg-check:[...] { 0 = -10014 1 = 10015 } -// lldbr-check:(tuple_struct::PaddingAtEnd) padding_at_end = { 0 = -10014 1 = 10015 } // This test case mainly makes sure that no field names are generated for tuple structs (as opposed // to all fields having the name ""). Otherwise they are handled the same a normal diff --git a/tests/debuginfo/tuple-style-enum.rs b/tests/debuginfo/tuple-style-enum.rs index 2a11bfe70656..efdf8c6970e2 100644 --- a/tests/debuginfo/tuple-style-enum.rs +++ b/tests/debuginfo/tuple-style-enum.rs @@ -26,19 +26,15 @@ // lldb-command:v case1 // lldbg-check:(tuple_style_enum::Regular) case1 = { value = { 0 = 0 1 = 31868 2 = 31868 3 = 31868 4 = 31868 } $discr$ = 0 } -// lldbr-check:(tuple_style_enum::Regular::Case1) case1 = { = 0 = 31868 = 31868 = 31868 = 31868 } // lldb-command:v case2 // lldbg-check:(tuple_style_enum::Regular) case2 = { value = { 0 = 0 1 = 286331153 2 = 286331153 } $discr$ = 1 } -// lldbr-check:(tuple_style_enum::Regular::Case2) case2 = Case2 { Case1: 0, Case2: 286331153, Case3: 286331153 } // lldb-command:v case3 // lldbg-check:(tuple_style_enum::Regular) case3 = { value = { 0 = 0 1 = 6438275382588823897 } $discr$ = 2 } -// lldbr-check:(tuple_style_enum::Regular::Case3) case3 = Case3 { Case1: 0, Case2: 6438275382588823897 } // lldb-command:v univariant // lldbg-check:(tuple_style_enum::Univariant) univariant = { value = { 0 = -1 } } -// lldbr-check:(tuple_style_enum::Univariant) univariant = { TheOnlyCase = { = -1 } } #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/union-smoke.rs b/tests/debuginfo/union-smoke.rs index 41bd81c9e8ae..73617df10b13 100644 --- a/tests/debuginfo/union-smoke.rs +++ b/tests/debuginfo/union-smoke.rs @@ -13,7 +13,6 @@ // lldb-command:run // lldb-command:v u // lldbg-check:[...] { a = { 0 = '\x02' 1 = '\x02' } b = 514 } -// lldbr-check:(union_smoke::U) u = { a = { 0 = '\x02' 1 = '\x02' } b = 514 } // lldbg-command:print union_smoke::SU // lldbg-check:[...] { a = { 0 = '\x01' 1 = '\x01' } b = 257 } diff --git a/tests/debuginfo/unique-enum.rs b/tests/debuginfo/unique-enum.rs index 6990f18788c7..b9ee480c851a 100644 --- a/tests/debuginfo/unique-enum.rs +++ b/tests/debuginfo/unique-enum.rs @@ -22,15 +22,12 @@ // lldb-command:v *the_a // lldbg-check:(unique_enum::ABC) *the_a = { value = { x = 0 y = 8970181431921507452 } $discr$ = 0 } -// lldbr-check:(unique_enum::ABC::TheA) *the_a = TheA { TheA: 0, TheB: 8970181431921507452 } // lldb-command:v *the_b // lldbg-check:(unique_enum::ABC) *the_b = { value = { 0 = 0 1 = 286331153 2 = 286331153 } $discr$ = 1 } -// lldbr-check:(unique_enum::ABC::TheB) *the_b = { = 0 = 286331153 = 286331153 } // lldb-command:v *univariant // lldbg-check:(unique_enum::Univariant) *univariant = { value = { 0 = 123234 } } -// lldbr-check:(unique_enum::Univariant) *univariant = { TheOnlyCase = { = 123234 } } #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/var-captured-in-nested-closure.rs b/tests/debuginfo/var-captured-in-nested-closure.rs index bed2a57e1f9e..0f544c24b5bc 100644 --- a/tests/debuginfo/var-captured-in-nested-closure.rs +++ b/tests/debuginfo/var-captured-in-nested-closure.rs @@ -39,42 +39,30 @@ // lldb-command:v variable // lldbg-check:[...] 1 -// lldbr-check:(isize) variable = 1 // lldb-command:v constant // lldbg-check:[...] 2 -// lldbr-check:(isize) constant = 2 // lldb-command:v a_struct // lldbg-check:[...] { a = -3 b = 4.5 c = 5 } -// lldbr-check:(var_captured_in_nested_closure::Struct) a_struct = { a = -3 b = 4.5 c = 5 } // lldb-command:v *struct_ref // lldbg-check:[...] { a = -3 b = 4.5 c = 5 } -// lldbr-check:(var_captured_in_nested_closure::Struct) *struct_ref = { a = -3 b = 4.5 c = 5 } // lldb-command:v *owned // lldbg-check:[...] 6 -// lldbr-check:(isize) *owned = 6 // lldb-command:v closure_local // lldbg-check:[...] 8 -// lldbr-check:(isize) closure_local = 8 // lldb-command:continue // lldb-command:v variable // lldbg-check:[...] 1 -// lldbr-check:(isize) variable = 1 // lldb-command:v constant // lldbg-check:[...] 2 -// lldbr-check:(isize) constant = 2 // lldb-command:v a_struct // lldbg-check:[...] { a = -3 b = 4.5 c = 5 } -// lldbr-check:(var_captured_in_nested_closure::Struct) a_struct = { a = -3 b = 4.5 c = 5 } // lldb-command:v *struct_ref // lldbg-check:[...] { a = -3 b = 4.5 c = 5 } -// lldbr-check:(var_captured_in_nested_closure::Struct) *struct_ref = { a = -3 b = 4.5 c = 5 } // lldb-command:v *owned // lldbg-check:[...] 6 -// lldbr-check:(isize) *owned = 6 // lldb-command:v closure_local // lldbg-check:[...] 8 -// lldbr-check:(isize) closure_local = 8 // lldb-command:continue diff --git a/tests/debuginfo/var-captured-in-sendable-closure.rs b/tests/debuginfo/var-captured-in-sendable-closure.rs index 59909b758266..2d9e60744739 100644 --- a/tests/debuginfo/var-captured-in-sendable-closure.rs +++ b/tests/debuginfo/var-captured-in-sendable-closure.rs @@ -22,13 +22,10 @@ // lldb-command:v constant // lldbg-check:[...] 1 -// lldbr-check:(isize) constant = 1 // lldb-command:v a_struct // lldbg-check:[...] { a = -2 b = 3.5 c = 4 } -// lldbr-check:(var_captured_in_sendable_closure::Struct) a_struct = { a = -2 b = 3.5 c = 4 } // lldb-command:v *owned // lldbg-check:[...] 5 -// lldbr-check:(isize) *owned = 5 #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/var-captured-in-stack-closure.rs b/tests/debuginfo/var-captured-in-stack-closure.rs index 5ac804464333..d6c4b11b5f2c 100644 --- a/tests/debuginfo/var-captured-in-stack-closure.rs +++ b/tests/debuginfo/var-captured-in-stack-closure.rs @@ -35,37 +35,27 @@ // lldb-command:v variable // lldbg-check:[...] 1 -// lldbr-check:(isize) variable = 1 // lldb-command:v constant // lldbg-check:[...] 2 -// lldbr-check:(isize) constant = 2 // lldb-command:v a_struct // lldbg-check:[...] { a = -3 b = 4.5 c = 5 } -// lldbr-check:(var_captured_in_stack_closure::Struct) a_struct = { a = -3 b = 4.5 c = 5 } // lldb-command:v *struct_ref // lldbg-check:[...] { a = -3 b = 4.5 c = 5 } -// lldbr-check:(var_captured_in_stack_closure::Struct) *struct_ref = { a = -3 b = 4.5 c = 5 } // lldb-command:v *owned // lldbg-check:[...] 6 -// lldbr-check:(isize) *owned = 6 // lldb-command:continue // lldb-command:v variable // lldbg-check:[...] 2 -// lldbr-check:(isize) variable = 2 // lldb-command:v constant // lldbg-check:[...] 2 -// lldbr-check:(isize) constant = 2 // lldb-command:v a_struct // lldbg-check:[...] { a = -3 b = 4.5 c = 5 } -// lldbr-check:(var_captured_in_stack_closure::Struct) a_struct = { a = -3 b = 4.5 c = 5 } // lldb-command:v *struct_ref // lldbg-check:[...] { a = -3 b = 4.5 c = 5 } -// lldbr-check:(var_captured_in_stack_closure::Struct) *struct_ref = { a = -3 b = 4.5 c = 5 } // lldb-command:v *owned // lldbg-check:[...] 6 -// lldbr-check:(isize) *owned = 6 // === CDB TESTS =================================================================================== diff --git a/tests/debuginfo/vec-slices.rs b/tests/debuginfo/vec-slices.rs index a84631685280..77d7b90ca0b5 100644 --- a/tests/debuginfo/vec-slices.rs +++ b/tests/debuginfo/vec-slices.rs @@ -54,27 +54,21 @@ // lldb-command:v empty // lldbg-check:[...] size=0 -// lldbr-check:(&[i64]) empty = size=0 // lldb-command:v singleton // lldbg-check:[...] size=1 { [0] = 1 } -// lldbr-check:(&[i64]) singleton = &[1] // lldb-command:v multiple // lldbg-check:[...] size=4 { [0] = 2 [1] = 3 [2] = 4 [3] = 5 } -// lldbr-check:(&[i64]) multiple = size=4 { [0] = 2 [1] = 3 [2] = 4 [3] = 5 } // lldb-command:v slice_of_slice // lldbg-check:[...] size=2 { [0] = 3 [1] = 4 } -// lldbr-check:(&[i64]) slice_of_slice = size=2 { [0] = 3 [1] = 4 } // lldb-command:v padded_tuple // lldbg-check:[...] size=2 { [0] = { 0 = 6 1 = 7 } [1] = { 0 = 8 1 = 9 } } -// lldbr-check:(&[(i32, i16)]) padded_tuple = size=2 { [0] = { 0 = 6 1 = 7 } [1] = { 0 = 8 1 = 9 } } // lldb-command:v padded_struct // lldbg-check:[...] size=2 { [0] = { x = 10 y = 11 z = 12 } [1] = { x = 13 y = 14 z = 15 } } -// lldbr-check:(&[vec_slices::AStruct]) padded_struct = size=2 { [0] = { x = 10 y = 11 z = 12 } [1] = { x = 13 y = 14 z = 15 } } #![allow(dead_code, unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/vec.rs b/tests/debuginfo/vec.rs index 24b7ae9c3942..3bb84d485730 100644 --- a/tests/debuginfo/vec.rs +++ b/tests/debuginfo/vec.rs @@ -14,7 +14,6 @@ // lldb-command:run // lldb-command:v a // lldbg-check:[...] { [0] = 1 [1] = 2 [2] = 3 } -// lldbr-check:([i32; 3]) a = { [0] = 1 [1] = 2 [2] = 3 } #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] From 22ed23d680fbb50c90992b03e50968e7bce6f373 Mon Sep 17 00:00:00 2001 From: Ben Kimock Date: Sun, 18 Aug 2024 17:00:33 -0400 Subject: [PATCH 67/79] Convert lldbg- to lldb- --- tests/debuginfo/associated-types.rs | 18 ++-- tests/debuginfo/basic-types.rs | 26 ++--- tests/debuginfo/borrowed-basic.rs | 28 +++--- tests/debuginfo/borrowed-c-style-enum.rs | 6 +- tests/debuginfo/borrowed-enum.rs | 6 +- tests/debuginfo/borrowed-struct.rs | 14 +-- tests/debuginfo/borrowed-tuple.rs | 6 +- tests/debuginfo/borrowed-unique-basic.rs | 28 +++--- tests/debuginfo/box.rs | 4 +- tests/debuginfo/boxed-struct.rs | 4 +- .../by-value-self-argument-in-trait-impl.rs | 6 +- tests/debuginfo/c-style-enum-in-composite.rs | 14 +-- tests/debuginfo/c-style-enum.rs | 14 +-- tests/debuginfo/captured-fields-1.rs | 12 +-- tests/debuginfo/captured-fields-2.rs | 4 +- .../debuginfo/closure-in-generic-function.rs | 8 +- tests/debuginfo/cross-crate-spans.rs | 12 +-- tests/debuginfo/destructured-fn-argument.rs | 98 +++++++++---------- .../destructured-for-loop-variable.rs | 48 ++++----- tests/debuginfo/destructured-local.rs | 86 ++++++++-------- tests/debuginfo/enum-thinlto.rs | 2 +- tests/debuginfo/evec-in-struct.rs | 10 +- tests/debuginfo/extern-c-fn.rs | 8 +- tests/debuginfo/function-arguments.rs | 8 +- tests/debuginfo/generic-function.rs | 12 +-- tests/debuginfo/generic-functions-nested.rs | 16 +-- .../generic-method-on-generic-struct.rs | 30 +++--- tests/debuginfo/generic-struct.rs | 8 +- tests/debuginfo/include_string.rs | 6 +- tests/debuginfo/issue-22656.rs | 4 +- tests/debuginfo/issue-57822.rs | 4 +- tests/debuginfo/lexical-scope-in-for-loop.rs | 14 +-- tests/debuginfo/lexical-scope-in-if.rs | 32 +++--- tests/debuginfo/lexical-scope-in-match.rs | 36 +++---- .../lexical-scope-in-stack-closure.rs | 12 +-- .../lexical-scope-in-unconditional-loop.rs | 26 ++--- .../lexical-scope-in-unique-closure.rs | 12 +-- tests/debuginfo/lexical-scope-in-while.rs | 26 ++--- tests/debuginfo/lexical-scope-with-macro.rs | 50 +++++----- .../lexical-scopes-in-block-expression.rs | 96 +++++++++--------- tests/debuginfo/method-on-generic-struct.rs | 30 +++--- tests/debuginfo/method-on-struct.rs | 30 +++--- tests/debuginfo/method-on-trait.rs | 30 +++--- tests/debuginfo/method-on-tuple-struct.rs | 30 +++--- tests/debuginfo/msvc-pretty-enums.rs | 44 ++++----- tests/debuginfo/multi-cgu.rs | 4 +- .../multiple-functions-equal-var-names.rs | 6 +- tests/debuginfo/multiple-functions.rs | 6 +- .../name-shadowing-and-scope-nesting.rs | 24 ++--- .../packed-struct-with-destructor.rs | 16 +-- tests/debuginfo/packed-struct.rs | 12 +-- tests/debuginfo/pretty-std-collections.rs | 8 +- tests/debuginfo/reference-debuginfo.rs | 30 +++--- .../regression-bad-location-list-67992.rs | 2 +- tests/debuginfo/self-in-default-method.rs | 30 +++--- .../self-in-generic-default-method.rs | 30 +++--- tests/debuginfo/shadowed-argument.rs | 12 +-- tests/debuginfo/shadowed-variable.rs | 20 ++-- tests/debuginfo/simple-lexical-scope.rs | 14 +-- tests/debuginfo/simple-struct.rs | 12 +-- tests/debuginfo/simple-tuple.rs | 14 +-- .../static-method-on-struct-and-enum.rs | 10 +- tests/debuginfo/strings-and-strs.rs | 10 +- tests/debuginfo/struct-in-struct.rs | 16 +-- tests/debuginfo/struct-namespace.rs | 8 +- tests/debuginfo/struct-style-enum.rs | 8 +- tests/debuginfo/struct-with-destructor.rs | 8 +- tests/debuginfo/tuple-in-tuple.rs | 14 +-- tests/debuginfo/tuple-struct.rs | 12 +-- tests/debuginfo/tuple-style-enum.rs | 8 +- tests/debuginfo/union-smoke.rs | 6 +- tests/debuginfo/unique-enum.rs | 6 +- .../var-captured-in-nested-closure.rs | 24 ++--- .../var-captured-in-sendable-closure.rs | 6 +- .../var-captured-in-stack-closure.rs | 20 ++-- tests/debuginfo/vec-slices.rs | 12 +-- tests/debuginfo/vec.rs | 2 +- 77 files changed, 714 insertions(+), 714 deletions(-) diff --git a/tests/debuginfo/associated-types.rs b/tests/debuginfo/associated-types.rs index 54ea047d36c4..95e742104729 100644 --- a/tests/debuginfo/associated-types.rs +++ b/tests/debuginfo/associated-types.rs @@ -37,33 +37,33 @@ // lldb-command:run // lldb-command:v arg -// lldbg-check:[...] { b = -1, b1 = 0 } +// lldb-check:[...] { b = -1, b1 = 0 } // lldb-command:continue // lldb-command:v inferred -// lldbg-check:[...] 1 +// lldb-check:[...] 1 // lldb-command:v explicitly -// lldbg-check:[...] 1 +// lldb-check:[...] 1 // lldb-command:continue // lldb-command:v arg -// lldbg-check:[...] 2 +// lldb-check:[...] 2 // lldb-command:continue // lldb-command:v arg -// lldbg-check:[...] (4, 5) +// lldb-check:[...] (4, 5) // lldb-command:continue // lldb-command:v a -// lldbg-check:[...] 6 +// lldb-check:[...] 6 // lldb-command:v b -// lldbg-check:[...] 7 +// lldb-check:[...] 7 // lldb-command:continue // lldb-command:v a -// lldbg-check:[...] 8 +// lldb-check:[...] 8 // lldb-command:v b -// lldbg-check:[...] 9 +// lldb-check:[...] 9 // lldb-command:continue #![allow(unused_variables)] diff --git a/tests/debuginfo/basic-types.rs b/tests/debuginfo/basic-types.rs index 656c49ee001b..fea5262bc41d 100644 --- a/tests/debuginfo/basic-types.rs +++ b/tests/debuginfo/basic-types.rs @@ -46,32 +46,32 @@ // lldb-command:run // lldb-command:v b -// lldbg-check:[...] false +// lldb-check:[...] false // lldb-command:v i -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:v i8 -// lldbg-check:[...] 'D' +// lldb-check:[...] 'D' // lldb-command:v i16 -// lldbg-check:[...] -16 +// lldb-check:[...] -16 // lldb-command:v i32 -// lldbg-check:[...] -32 +// lldb-check:[...] -32 // lldb-command:v i64 -// lldbg-check:[...] -64 +// lldb-check:[...] -64 // lldb-command:v u -// lldbg-check:[...] 1 +// lldb-check:[...] 1 // lldb-command:v u8 -// lldbg-check:[...] 'd' +// lldb-check:[...] 'd' // lldb-command:v u16 -// lldbg-check:[...] 16 +// lldb-check:[...] 16 // lldb-command:v u32 -// lldbg-check:[...] 32 +// lldb-check:[...] 32 // lldb-command:v u64 -// lldbg-check:[...] 64 +// lldb-check:[...] 64 // lldb-command:v f32 -// lldbg-check:[...] 2.5 +// lldb-check:[...] 2.5 // lldb-command:v f64 -// lldbg-check:[...] 3.5 +// lldb-check:[...] 3.5 // === CDB TESTS =================================================================================== diff --git a/tests/debuginfo/borrowed-basic.rs b/tests/debuginfo/borrowed-basic.rs index e51f5912fc21..91de691e78e1 100644 --- a/tests/debuginfo/borrowed-basic.rs +++ b/tests/debuginfo/borrowed-basic.rs @@ -53,47 +53,47 @@ // lldb-command:run // lldb-command:v *bool_ref -// lldbg-check:[...] true +// lldb-check:[...] true // lldb-command:v *int_ref -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:v *i8_ref -// lldbg-check:[...] 'D' +// lldb-check:[...] 'D' // lldb-command:v *i16_ref -// lldbg-check:[...] -16 +// lldb-check:[...] -16 // lldb-command:v *i32_ref -// lldbg-check:[...] -32 +// lldb-check:[...] -32 // lldb-command:v *i64_ref -// lldbg-check:[...] -64 +// lldb-check:[...] -64 // lldb-command:v *uint_ref -// lldbg-check:[...] 1 +// lldb-check:[...] 1 // lldb-command:v *u8_ref -// lldbg-check:[...] 'd' +// lldb-check:[...] 'd' // lldb-command:v *u16_ref -// lldbg-check:[...] 16 +// lldb-check:[...] 16 // lldb-command:v *u32_ref -// lldbg-check:[...] 32 +// lldb-check:[...] 32 // lldb-command:v *u64_ref -// lldbg-check:[...] 64 +// lldb-check:[...] 64 // lldb-command:v *f16_ref -// lldbg-check:[...] 1.5 +// lldb-check:[...] 1.5 // lldb-command:v *f32_ref -// lldbg-check:[...] 2.5 +// lldb-check:[...] 2.5 // lldb-command:v *f64_ref -// lldbg-check:[...] 3.5 +// lldb-check:[...] 3.5 #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/borrowed-c-style-enum.rs b/tests/debuginfo/borrowed-c-style-enum.rs index 6d771cf67927..6a91d4f96504 100644 --- a/tests/debuginfo/borrowed-c-style-enum.rs +++ b/tests/debuginfo/borrowed-c-style-enum.rs @@ -19,13 +19,13 @@ // lldb-command:run // lldb-command:v *the_a_ref -// lldbg-check:[...] TheA +// lldb-check:[...] TheA // lldb-command:v *the_b_ref -// lldbg-check:[...] TheB +// lldb-check:[...] TheB // lldb-command:v *the_c_ref -// lldbg-check:[...] TheC +// lldb-check:[...] TheC #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/borrowed-enum.rs b/tests/debuginfo/borrowed-enum.rs index 8782e28e4ec1..c5a795fdede6 100644 --- a/tests/debuginfo/borrowed-enum.rs +++ b/tests/debuginfo/borrowed-enum.rs @@ -21,11 +21,11 @@ // lldb-command:run // lldb-command:v *the_a_ref -// lldbg-check:(borrowed_enum::ABC) *the_a_ref = { value = { x = 0 y = 8970181431921507452 } $discr$ = 0 } +// lldb-check:(borrowed_enum::ABC) *the_a_ref = { value = { x = 0 y = 8970181431921507452 } $discr$ = 0 } // lldb-command:v *the_b_ref -// lldbg-check:(borrowed_enum::ABC) *the_b_ref = { value = { 0 = 0 1 = 286331153 2 = 286331153 } $discr$ = 1 } +// lldb-check:(borrowed_enum::ABC) *the_b_ref = { value = { 0 = 0 1 = 286331153 2 = 286331153 } $discr$ = 1 } // lldb-command:v *univariant_ref -// lldbg-check:(borrowed_enum::Univariant) *univariant_ref = { value = { 0 = 4820353753753434 } } +// lldb-check:(borrowed_enum::Univariant) *univariant_ref = { value = { 0 = 4820353753753434 } } #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/borrowed-struct.rs b/tests/debuginfo/borrowed-struct.rs index e9b751465629..245af35f5055 100644 --- a/tests/debuginfo/borrowed-struct.rs +++ b/tests/debuginfo/borrowed-struct.rs @@ -31,25 +31,25 @@ // lldb-command:run // lldb-command:v *stack_val_ref -// lldbg-check:[...] { x = 10 y = 23.5 } +// lldb-check:[...] { x = 10 y = 23.5 } // lldb-command:v *stack_val_interior_ref_1 -// lldbg-check:[...] 10 +// lldb-check:[...] 10 // lldb-command:v *stack_val_interior_ref_2 -// lldbg-check:[...] 23.5 +// lldb-check:[...] 23.5 // lldb-command:v *ref_to_unnamed -// lldbg-check:[...] { x = 11 y = 24.5 } +// lldb-check:[...] { x = 11 y = 24.5 } // lldb-command:v *unique_val_ref -// lldbg-check:[...] { x = 13 y = 26.5 } +// lldb-check:[...] { x = 13 y = 26.5 } // lldb-command:v *unique_val_interior_ref_1 -// lldbg-check:[...] 13 +// lldb-check:[...] 13 // lldb-command:v *unique_val_interior_ref_2 -// lldbg-check:[...] 26.5 +// lldb-check:[...] 26.5 #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/borrowed-tuple.rs b/tests/debuginfo/borrowed-tuple.rs index 720d6048f833..9e4ceec033ec 100644 --- a/tests/debuginfo/borrowed-tuple.rs +++ b/tests/debuginfo/borrowed-tuple.rs @@ -19,13 +19,13 @@ // lldb-command:run // lldb-command:v *stack_val_ref -// lldbg-check:[...] { 0 = -14 1 = -19 } +// lldb-check:[...] { 0 = -14 1 = -19 } // lldb-command:v *ref_to_unnamed -// lldbg-check:[...] { 0 = -15 1 = -20 } +// lldb-check:[...] { 0 = -15 1 = -20 } // lldb-command:v *unique_val_ref -// lldbg-check:[...] { 0 = -17 1 = -22 } +// lldb-check:[...] { 0 = -17 1 = -22 } #![allow(unused_variables)] diff --git a/tests/debuginfo/borrowed-unique-basic.rs b/tests/debuginfo/borrowed-unique-basic.rs index 8b2690e025b0..7a9b4d1df825 100644 --- a/tests/debuginfo/borrowed-unique-basic.rs +++ b/tests/debuginfo/borrowed-unique-basic.rs @@ -57,47 +57,47 @@ // lldb-command:run // lldb-command:v *bool_ref -// lldbg-check:[...] true +// lldb-check:[...] true // lldb-command:v *int_ref -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:v *i8_ref -// lldbg-check:[...] 68 +// lldb-check:[...] 68 // lldb-command:v *i16_ref -// lldbg-check:[...] -16 +// lldb-check:[...] -16 // lldb-command:v *i32_ref -// lldbg-check:[...] -32 +// lldb-check:[...] -32 // lldb-command:v *i64_ref -// lldbg-check:[...] -64 +// lldb-check:[...] -64 // lldb-command:v *uint_ref -// lldbg-check:[...] 1 +// lldb-check:[...] 1 // lldb-command:v *u8_ref -// lldbg-check:[...] 100 +// lldb-check:[...] 100 // lldb-command:v *u16_ref -// lldbg-check:[...] 16 +// lldb-check:[...] 16 // lldb-command:v *u32_ref -// lldbg-check:[...] 32 +// lldb-check:[...] 32 // lldb-command:v *u64_ref -// lldbg-check:[...] 64 +// lldb-check:[...] 64 // lldb-command:v *f16_ref -// lldbg-check:[...] 1.5 +// lldb-check:[...] 1.5 // lldb-command:v *f32_ref -// lldbg-check:[...] 2.5 +// lldb-check:[...] 2.5 // lldb-command:v *f64_ref -// lldbg-check:[...] 3.5 +// lldb-check:[...] 3.5 #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/box.rs b/tests/debuginfo/box.rs index 40f0cd524448..d22566c0b179 100644 --- a/tests/debuginfo/box.rs +++ b/tests/debuginfo/box.rs @@ -14,9 +14,9 @@ // lldb-command:run // lldb-command:v *a -// lldbg-check:[...] 1 +// lldb-check:[...] 1 // lldb-command:v *b -// lldbg-check:[...] { 0 = 2 1 = 3.5 } +// lldb-check:[...] { 0 = 2 1 = 3.5 } #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/boxed-struct.rs b/tests/debuginfo/boxed-struct.rs index b4349122a3a8..158609fb2ed7 100644 --- a/tests/debuginfo/boxed-struct.rs +++ b/tests/debuginfo/boxed-struct.rs @@ -16,10 +16,10 @@ // lldb-command:run // lldb-command:v *boxed_with_padding -// lldbg-check:[...] { x = 99 y = 999 z = 9999 w = 99999 } +// lldb-check:[...] { x = 99 y = 999 z = 9999 w = 99999 } // lldb-command:v *boxed_with_dtor -// lldbg-check:[...] { x = 77 y = 777 z = 7777 w = 77777 } +// lldb-check:[...] { x = 77 y = 777 z = 7777 w = 77777 } #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/by-value-self-argument-in-trait-impl.rs b/tests/debuginfo/by-value-self-argument-in-trait-impl.rs index 69a051b444df..6981fdfc9e11 100644 --- a/tests/debuginfo/by-value-self-argument-in-trait-impl.rs +++ b/tests/debuginfo/by-value-self-argument-in-trait-impl.rs @@ -22,15 +22,15 @@ // lldb-command:run // lldb-command:v self -// lldbg-check:[...] 1111 +// lldb-check:[...] 1111 // lldb-command:continue // lldb-command:v self -// lldbg-check:[...] { x = 2222 y = 3333 } +// lldb-check:[...] { x = 2222 y = 3333 } // lldb-command:continue // lldb-command:v self -// lldbg-check:[...] { 0 = 4444.5 1 = 5555 2 = 6666 3 = 7777.5 } +// lldb-check:[...] { 0 = 4444.5 1 = 5555 2 = 6666 3 = 7777.5 } // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/c-style-enum-in-composite.rs b/tests/debuginfo/c-style-enum-in-composite.rs index 4cd40c20cebd..642879cf3b67 100644 --- a/tests/debuginfo/c-style-enum-in-composite.rs +++ b/tests/debuginfo/c-style-enum-in-composite.rs @@ -30,25 +30,25 @@ // lldb-command:run // lldb-command:v tuple_interior_padding -// lldbg-check:[...] { 0 = 0 1 = OneHundred } +// lldb-check:[...] { 0 = 0 1 = OneHundred } // lldb-command:v tuple_padding_at_end -// lldbg-check:[...] { 0 = { 0 = 1 1 = OneThousand } 1 = 2 } +// lldb-check:[...] { 0 = { 0 = 1 1 = OneThousand } 1 = 2 } // lldb-command:v tuple_different_enums -// lldbg-check:[...] { 0 = OneThousand 1 = MountainView 2 = OneMillion 3 = Vienna } +// lldb-check:[...] { 0 = OneThousand 1 = MountainView 2 = OneMillion 3 = Vienna } // lldb-command:v padded_struct -// lldbg-check:[...] { a = 3 b = OneMillion c = 4 d = Toronto e = 5 } +// lldb-check:[...] { a = 3 b = OneMillion c = 4 d = Toronto e = 5 } // lldb-command:v packed_struct -// lldbg-check:[...] { a = 6 b = OneHundred c = 7 d = Vienna e = 8 } +// lldb-check:[...] { a = 6 b = OneHundred c = 7 d = Vienna e = 8 } // lldb-command:v non_padded_struct -// lldbg-check:[...] { a = OneMillion b = MountainView c = OneThousand d = Toronto } +// lldb-check:[...] { a = OneMillion b = MountainView c = OneThousand d = Toronto } // lldb-command:v struct_with_drop -// lldbg-check:[...] { 0 = { a = OneHundred b = Vienna } 1 = 9 } +// lldb-check:[...] { 0 = { a = OneHundred b = Vienna } 1 = 9 } #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/c-style-enum.rs b/tests/debuginfo/c-style-enum.rs index a148c8d38453..08378f7af181 100644 --- a/tests/debuginfo/c-style-enum.rs +++ b/tests/debuginfo/c-style-enum.rs @@ -66,25 +66,25 @@ // lldb-command:run // lldb-command:v auto_one -// lldbg-check:[...] One +// lldb-check:[...] One // lldb-command:v auto_two -// lldbg-check:[...] Two +// lldb-check:[...] Two // lldb-command:v auto_three -// lldbg-check:[...] Three +// lldb-check:[...] Three // lldb-command:v manual_one_hundred -// lldbg-check:[...] OneHundred +// lldb-check:[...] OneHundred // lldb-command:v manual_one_thousand -// lldbg-check:[...] OneThousand +// lldb-check:[...] OneThousand // lldb-command:v manual_one_million -// lldbg-check:[...] OneMillion +// lldb-check:[...] OneMillion // lldb-command:v single_variant -// lldbg-check:[...] TheOnlyVariant +// lldb-check:[...] TheOnlyVariant #![allow(unused_variables)] #![allow(dead_code)] diff --git a/tests/debuginfo/captured-fields-1.rs b/tests/debuginfo/captured-fields-1.rs index 217a1f27b678..69ca3ecd812d 100644 --- a/tests/debuginfo/captured-fields-1.rs +++ b/tests/debuginfo/captured-fields-1.rs @@ -26,22 +26,22 @@ // lldb-command:run // lldb-command:v test -// lldbg-check:(captured_fields_1::main::{closure_env#0}) test = { _ref__my_ref__my_field1 = 0x[...] } +// lldb-check:(captured_fields_1::main::{closure_env#0}) test = { _ref__my_ref__my_field1 = 0x[...] } // lldb-command:continue // lldb-command:v test -// lldbg-check:(captured_fields_1::main::{closure_env#1}) test = { _ref__my_ref__my_field2 = 0x[...] } +// lldb-check:(captured_fields_1::main::{closure_env#1}) test = { _ref__my_ref__my_field2 = 0x[...] } // lldb-command:continue // lldb-command:v test -// lldbg-check:(captured_fields_1::main::{closure_env#2}) test = { _ref__my_ref = 0x[...] } +// lldb-check:(captured_fields_1::main::{closure_env#2}) test = { _ref__my_ref = 0x[...] } // lldb-command:continue // lldb-command:v test -// lldbg-check:(captured_fields_1::main::{closure_env#3}) test = { my_ref = 0x[...] } +// lldb-check:(captured_fields_1::main::{closure_env#3}) test = { my_ref = 0x[...] } // lldb-command:continue // lldb-command:v test -// lldbg-check:(captured_fields_1::main::{closure_env#4}) test = { my_var__my_field2 = 22 } +// lldb-check:(captured_fields_1::main::{closure_env#4}) test = { my_var__my_field2 = 22 } // lldb-command:continue // lldb-command:v test -// lldbg-check:(captured_fields_1::main::{closure_env#5}) test = { my_var = { my_field1 = 11 my_field2 = 22 } } +// lldb-check:(captured_fields_1::main::{closure_env#5}) test = { my_var = { my_field1 = 11 my_field2 = 22 } } // lldb-command:continue #![allow(unused)] diff --git a/tests/debuginfo/captured-fields-2.rs b/tests/debuginfo/captured-fields-2.rs index 940f07ecacbb..24bff1d3f35d 100644 --- a/tests/debuginfo/captured-fields-2.rs +++ b/tests/debuginfo/captured-fields-2.rs @@ -14,10 +14,10 @@ // lldb-command:run // lldb-command:v my_ref__my_field1 -// lldbg-check:(unsigned int) my_ref__my_field1 = 11 +// lldb-check:(unsigned int) my_ref__my_field1 = 11 // lldb-command:continue // lldb-command:v my_var__my_field2 -// lldbg-check:(unsigned int) my_var__my_field2 = 22 +// lldb-check:(unsigned int) my_var__my_field2 = 22 // lldb-command:continue #![allow(unused)] diff --git a/tests/debuginfo/closure-in-generic-function.rs b/tests/debuginfo/closure-in-generic-function.rs index 2baaf1b79e9d..0c6a6fdfca1b 100644 --- a/tests/debuginfo/closure-in-generic-function.rs +++ b/tests/debuginfo/closure-in-generic-function.rs @@ -22,15 +22,15 @@ // lldb-command:run // lldb-command:v x -// lldbg-check:[...] 0.5 +// lldb-check:[...] 0.5 // lldb-command:v y -// lldbg-check:[...] 10 +// lldb-check:[...] 10 // lldb-command:continue // lldb-command:v *x -// lldbg-check:[...] 29 +// lldb-check:[...] 29 // lldb-command:v *y -// lldbg-check:[...] 110 +// lldb-check:[...] 110 // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/cross-crate-spans.rs b/tests/debuginfo/cross-crate-spans.rs index 5e8b27d4d55e..e337aaf5a6c9 100644 --- a/tests/debuginfo/cross-crate-spans.rs +++ b/tests/debuginfo/cross-crate-spans.rs @@ -36,19 +36,19 @@ extern crate cross_crate_spans; // lldb-command:run // lldb-command:v result -// lldbg-check:[...] { 0 = 17 1 = 17 } +// lldb-check:[...] { 0 = 17 1 = 17 } // lldb-command:v a_variable -// lldbg-check:[...] 123456789 +// lldb-check:[...] 123456789 // lldb-command:v another_variable -// lldbg-check:[...] 123456789.5 +// lldb-check:[...] 123456789.5 // lldb-command:continue // lldb-command:v result -// lldbg-check:[...] { 0 = 1212 1 = 1212 } +// lldb-check:[...] { 0 = 1212 1 = 1212 } // lldb-command:v a_variable -// lldbg-check:[...] 123456789 +// lldb-check:[...] 123456789 // lldb-command:v another_variable -// lldbg-check:[...] 123456789.5 +// lldb-check:[...] 123456789.5 // lldb-command:continue diff --git a/tests/debuginfo/destructured-fn-argument.rs b/tests/debuginfo/destructured-fn-argument.rs index aef4e4baae1e..37a7bb2b7786 100644 --- a/tests/debuginfo/destructured-fn-argument.rs +++ b/tests/debuginfo/destructured-fn-argument.rs @@ -154,147 +154,147 @@ // lldb-command:run // lldb-command:v a -// lldbg-check:[...] 1 +// lldb-check:[...] 1 // lldb-command:v b -// lldbg-check:[...] false +// lldb-check:[...] false // lldb-command:continue // lldb-command:v a -// lldbg-check:[...] 2 +// lldb-check:[...] 2 // lldb-command:v b -// lldbg-check:[...] 3 +// lldb-check:[...] 3 // lldb-command:v c -// lldbg-check:[...] 4 +// lldb-check:[...] 4 // lldb-command:continue // lldb-command:v a -// lldbg-check:[...] 5 +// lldb-check:[...] 5 // lldb-command:v b -// lldbg-check:[...] { 0 = 6 1 = 7 } +// lldb-check:[...] { 0 = 6 1 = 7 } // lldb-command:continue // lldb-command:v h -// lldbg-check:[...] 8 +// lldb-check:[...] 8 // lldb-command:v i -// lldbg-check:[...] { a = 9 b = 10 } +// lldb-check:[...] { a = 9 b = 10 } // lldb-command:v j -// lldbg-check:[...] 11 +// lldb-check:[...] 11 // lldb-command:continue // lldb-command:v k -// lldbg-check:[...] 12 +// lldb-check:[...] 12 // lldb-command:v l -// lldbg-check:[...] 13 +// lldb-check:[...] 13 // lldb-command:continue // lldb-command:v m -// lldbg-check:[...] 14 +// lldb-check:[...] 14 // lldb-command:v n -// lldbg-check:[...] 16 +// lldb-check:[...] 16 // lldb-command:continue // lldb-command:v o -// lldbg-check:[...] 18 +// lldb-check:[...] 18 // lldb-command:continue // lldb-command:v p -// lldbg-check:[...] 19 +// lldb-check:[...] 19 // lldb-command:v q -// lldbg-check:[...] 20 +// lldb-check:[...] 20 // lldb-command:v r -// lldbg-check:[...] { a = 21 b = 22 } +// lldb-check:[...] { a = 21 b = 22 } // lldb-command:continue // lldb-command:v s -// lldbg-check:[...] 24 +// lldb-check:[...] 24 // lldb-command:v t -// lldbg-check:[...] 23 +// lldb-check:[...] 23 // lldb-command:continue // lldb-command:v u -// lldbg-check:[...] 25 +// lldb-check:[...] 25 // lldb-command:v v -// lldbg-check:[...] 26 +// lldb-check:[...] 26 // lldb-command:v w -// lldbg-check:[...] 27 +// lldb-check:[...] 27 // lldb-command:v x -// lldbg-check:[...] 28 +// lldb-check:[...] 28 // lldb-command:v y -// lldbg-check:[...] 29 +// lldb-check:[...] 29 // lldb-command:v z -// lldbg-check:[...] 30 +// lldb-check:[...] 30 // lldb-command:v ae -// lldbg-check:[...] 31 +// lldb-check:[...] 31 // lldb-command:v oe -// lldbg-check:[...] 32 +// lldb-check:[...] 32 // lldb-command:v ue -// lldbg-check:[...] 33 +// lldb-check:[...] 33 // lldb-command:continue // lldb-command:v aa -// lldbg-check:[...] { 0 = 34 1 = 35 } +// lldb-check:[...] { 0 = 34 1 = 35 } // lldb-command:continue // lldb-command:v bb -// lldbg-check:[...] { 0 = 36 1 = 37 } +// lldb-check:[...] { 0 = 36 1 = 37 } // lldb-command:continue // lldb-command:v cc -// lldbg-check:[...] 38 +// lldb-check:[...] 38 // lldb-command:continue // lldb-command:v dd -// lldbg-check:[...] { 0 = 40 1 = 41 2 = 42 } +// lldb-check:[...] { 0 = 40 1 = 41 2 = 42 } // lldb-command:continue // lldb-command:v *ee -// lldbg-check:[...] { 0 = 43 1 = 44 2 = 45 } +// lldb-check:[...] { 0 = 43 1 = 44 2 = 45 } // lldb-command:continue // lldb-command:v *ff -// lldbg-check:[...] 46 +// lldb-check:[...] 46 // lldb-command:v gg -// lldbg-check:[...] { 0 = 47 1 = 48 } +// lldb-check:[...] { 0 = 47 1 = 48 } // lldb-command:continue // lldb-command:v *hh -// lldbg-check:[...] 50 +// lldb-check:[...] 50 // lldb-command:continue // lldb-command:v ii -// lldbg-check:[...] 51 +// lldb-check:[...] 51 // lldb-command:continue // lldb-command:v *jj -// lldbg-check:[...] 52 +// lldb-check:[...] 52 // lldb-command:continue // lldb-command:v kk -// lldbg-check:[...] 53 +// lldb-check:[...] 53 // lldb-command:v ll -// lldbg-check:[...] 54 +// lldb-check:[...] 54 // lldb-command:continue // lldb-command:v mm -// lldbg-check:[...] 55 +// lldb-check:[...] 55 // lldb-command:v *nn -// lldbg-check:[...] 56 +// lldb-check:[...] 56 // lldb-command:continue // lldb-command:v oo -// lldbg-check:[...] 57 +// lldb-check:[...] 57 // lldb-command:v pp -// lldbg-check:[...] 58 +// lldb-check:[...] 58 // lldb-command:v qq -// lldbg-check:[...] 59 +// lldb-check:[...] 59 // lldb-command:continue // lldb-command:v rr -// lldbg-check:[...] 60 +// lldb-check:[...] 60 // lldb-command:v ss -// lldbg-check:[...] 61 +// lldb-check:[...] 61 // lldb-command:v tt -// lldbg-check:[...] 62 +// lldb-check:[...] 62 // lldb-command:continue #![allow(unused_variables)] diff --git a/tests/debuginfo/destructured-for-loop-variable.rs b/tests/debuginfo/destructured-for-loop-variable.rs index 6a43f8ca1999..cc16be1268ae 100644 --- a/tests/debuginfo/destructured-for-loop-variable.rs +++ b/tests/debuginfo/destructured-for-loop-variable.rs @@ -77,66 +77,66 @@ // DESTRUCTURED STRUCT // lldb-command:v x -// lldbg-check:[...] 400 +// lldb-check:[...] 400 // lldb-command:v y -// lldbg-check:[...] 401.5 +// lldb-check:[...] 401.5 // lldb-command:v z -// lldbg-check:[...] true +// lldb-check:[...] true // lldb-command:continue // DESTRUCTURED TUPLE // lldb-command:v _i8 -// lldbg-check:[...] 0x6f +// lldb-check:[...] 0x6f // lldb-command:v _u8 -// lldbg-check:[...] 0x70 +// lldb-check:[...] 0x70 // lldb-command:v _i16 -// lldbg-check:[...] -113 +// lldb-check:[...] -113 // lldb-command:v _u16 -// lldbg-check:[...] 114 +// lldb-check:[...] 114 // lldb-command:v _i32 -// lldbg-check:[...] -115 +// lldb-check:[...] -115 // lldb-command:v _u32 -// lldbg-check:[...] 116 +// lldb-check:[...] 116 // lldb-command:v _i64 -// lldbg-check:[...] -117 +// lldb-check:[...] -117 // lldb-command:v _u64 -// lldbg-check:[...] 118 +// lldb-check:[...] 118 // lldb-command:v _f32 -// lldbg-check:[...] 119.5 +// lldb-check:[...] 119.5 // lldb-command:v _f64 -// lldbg-check:[...] 120.5 +// lldb-check:[...] 120.5 // lldb-command:continue // MORE COMPLEX CASE // lldb-command:v v1 -// lldbg-check:[...] 80000 +// lldb-check:[...] 80000 // lldb-command:v x1 -// lldbg-check:[...] 8000 +// lldb-check:[...] 8000 // lldb-command:v *y1 -// lldbg-check:[...] 80001.5 +// lldb-check:[...] 80001.5 // lldb-command:v z1 -// lldbg-check:[...] false +// lldb-check:[...] false // lldb-command:v *x2 -// lldbg-check:[...] -30000 +// lldb-check:[...] -30000 // lldb-command:v y2 -// lldbg-check:[...] -300001.5 +// lldb-check:[...] -300001.5 // lldb-command:v *z2 -// lldbg-check:[...] true +// lldb-check:[...] true // lldb-command:v v2 -// lldbg-check:[...] 854237.5 +// lldb-check:[...] 854237.5 // lldb-command:continue // SIMPLE IDENTIFIER // lldb-command:v i -// lldbg-check:[...] 1234 +// lldb-check:[...] 1234 // lldb-command:continue // lldb-command:v simple_struct_ident -// lldbg-check:[...] { x = 3537 y = 35437.5 z = true } +// lldb-check:[...] { x = 3537 y = 35437.5 z = true } // lldb-command:continue // lldb-command:v simple_tuple_ident -// lldbg-check:[...] { 0 = 34903493 1 = 232323 } +// lldb-check:[...] { 0 = 34903493 1 = 232323 } // lldb-command:continue #![allow(unused_variables)] diff --git a/tests/debuginfo/destructured-local.rs b/tests/debuginfo/destructured-local.rs index b74bf8745eaa..fad96ca7d4b6 100644 --- a/tests/debuginfo/destructured-local.rs +++ b/tests/debuginfo/destructured-local.rs @@ -120,114 +120,114 @@ // lldb-command:run // lldb-command:v a -// lldbg-check:[...] 1 +// lldb-check:[...] 1 // lldb-command:v b -// lldbg-check:[...] false +// lldb-check:[...] false // lldb-command:v c -// lldbg-check:[...] 2 +// lldb-check:[...] 2 // lldb-command:v d -// lldbg-check:[...] 3 +// lldb-check:[...] 3 // lldb-command:v e -// lldbg-check:[...] 4 +// lldb-check:[...] 4 // lldb-command:v f -// lldbg-check:[...] 5 +// lldb-check:[...] 5 // lldb-command:v g -// lldbg-check:[...] { 0 = 6 1 = 7 } +// lldb-check:[...] { 0 = 6 1 = 7 } // lldb-command:v h -// lldbg-check:[...] 8 +// lldb-check:[...] 8 // lldb-command:v i -// lldbg-check:[...] { a = 9 b = 10 } +// lldb-check:[...] { a = 9 b = 10 } // lldb-command:v j -// lldbg-check:[...] 11 +// lldb-check:[...] 11 // lldb-command:v k -// lldbg-check:[...] 12 +// lldb-check:[...] 12 // lldb-command:v l -// lldbg-check:[...] 13 +// lldb-check:[...] 13 // lldb-command:v m -// lldbg-check:[...] 14 +// lldb-check:[...] 14 // lldb-command:v n -// lldbg-check:[...] 16 +// lldb-check:[...] 16 // lldb-command:v o -// lldbg-check:[...] 18 +// lldb-check:[...] 18 // lldb-command:v p -// lldbg-check:[...] 19 +// lldb-check:[...] 19 // lldb-command:v q -// lldbg-check:[...] 20 +// lldb-check:[...] 20 // lldb-command:v r -// lldbg-check:[...] { a = 21 b = 22 } +// lldb-check:[...] { a = 21 b = 22 } // lldb-command:v s -// lldbg-check:[...] 24 +// lldb-check:[...] 24 // lldb-command:v t -// lldbg-check:[...] 23 +// lldb-check:[...] 23 // lldb-command:v u -// lldbg-check:[...] 25 +// lldb-check:[...] 25 // lldb-command:v v -// lldbg-check:[...] 26 +// lldb-check:[...] 26 // lldb-command:v w -// lldbg-check:[...] 27 +// lldb-check:[...] 27 // lldb-command:v x -// lldbg-check:[...] 28 +// lldb-check:[...] 28 // lldb-command:v y -// lldbg-check:[...] 29 +// lldb-check:[...] 29 // lldb-command:v z -// lldbg-check:[...] 30 +// lldb-check:[...] 30 // lldb-command:v ae -// lldbg-check:[...] 31 +// lldb-check:[...] 31 // lldb-command:v oe -// lldbg-check:[...] 32 +// lldb-check:[...] 32 // lldb-command:v ue -// lldbg-check:[...] 33 +// lldb-check:[...] 33 // lldb-command:v aa -// lldbg-check:[...] { 0 = 34 1 = 35 } +// lldb-check:[...] { 0 = 34 1 = 35 } // lldb-command:v bb -// lldbg-check:[...] { 0 = 36 1 = 37 } +// lldb-check:[...] { 0 = 36 1 = 37 } // lldb-command:v cc -// lldbg-check:[...] 38 +// lldb-check:[...] 38 // lldb-command:v dd -// lldbg-check:[...] { 0 = 40 1 = 41 2 = 42 } +// lldb-check:[...] { 0 = 40 1 = 41 2 = 42 } // lldb-command:v *ee -// lldbg-check:[...] { 0 = 43 1 = 44 2 = 45 } +// lldb-check:[...] { 0 = 43 1 = 44 2 = 45 } // lldb-command:v *ff -// lldbg-check:[...] 46 +// lldb-check:[...] 46 // lldb-command:v gg -// lldbg-check:[...] { 0 = 47 1 = 48 } +// lldb-check:[...] { 0 = 47 1 = 48 } // lldb-command:v *hh -// lldbg-check:[...] 50 +// lldb-check:[...] 50 // lldb-command:v ii -// lldbg-check:[...] 51 +// lldb-check:[...] 51 // lldb-command:v *jj -// lldbg-check:[...] 52 +// lldb-check:[...] 52 // lldb-command:v kk -// lldbg-check:[...] 53 +// lldb-check:[...] 53 // lldb-command:v ll -// lldbg-check:[...] 54 +// lldb-check:[...] 54 // lldb-command:v mm -// lldbg-check:[...] 55 +// lldb-check:[...] 55 // lldb-command:v *nn -// lldbg-check:[...] 56 +// lldb-check:[...] 56 #![allow(unused_variables)] diff --git a/tests/debuginfo/enum-thinlto.rs b/tests/debuginfo/enum-thinlto.rs index 8c3a20a2da4c..af77145c312d 100644 --- a/tests/debuginfo/enum-thinlto.rs +++ b/tests/debuginfo/enum-thinlto.rs @@ -13,7 +13,7 @@ // lldb-command:run // lldb-command:v *abc -// lldbg-check:(enum_thinlto::ABC) *abc = { value = { x = 0 y = 8970181431921507452 } $discr$ = 0 } +// lldb-check:(enum_thinlto::ABC) *abc = { value = { x = 0 y = 8970181431921507452 } $discr$ = 0 } #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/evec-in-struct.rs b/tests/debuginfo/evec-in-struct.rs index 020c6e7d1542..303669cf06cd 100644 --- a/tests/debuginfo/evec-in-struct.rs +++ b/tests/debuginfo/evec-in-struct.rs @@ -24,18 +24,18 @@ // lldb-command:run // lldb-command:v no_padding1 -// lldbg-check:[...] { x = { [0] = 0 [1] = 1 [2] = 2 } y = -3 z = { [0] = 4.5 [1] = 5.5 } } +// lldb-check:[...] { x = { [0] = 0 [1] = 1 [2] = 2 } y = -3 z = { [0] = 4.5 [1] = 5.5 } } // lldb-command:v no_padding2 -// lldbg-check:[...] { x = { [0] = 6 [1] = 7 [2] = 8 } y = { [0] = { [0] = 9 [1] = 10 } [1] = { [0] = 11 [1] = 12 } } } +// lldb-check:[...] { x = { [0] = 6 [1] = 7 [2] = 8 } y = { [0] = { [0] = 9 [1] = 10 } [1] = { [0] = 11 [1] = 12 } } } // lldb-command:v struct_internal_padding -// lldbg-check:[...] { x = { [0] = 13 [1] = 14 } y = { [0] = 15 [1] = 16 } } +// lldb-check:[...] { x = { [0] = 13 [1] = 14 } y = { [0] = 15 [1] = 16 } } // lldb-command:v single_vec -// lldbg-check:[...] { x = { [0] = 17 [1] = 18 [2] = 19 [3] = 20 [4] = 21 } } +// lldb-check:[...] { x = { [0] = 17 [1] = 18 [2] = 19 [3] = 20 [4] = 21 } } // lldb-command:v struct_padded_at_end -// lldbg-check:[...] { x = { [0] = 22 [1] = 23 } y = { [0] = 24 [1] = 25 } } +// lldb-check:[...] { x = { [0] = 22 [1] = 23 } y = { [0] = 24 [1] = 25 } } #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/extern-c-fn.rs b/tests/debuginfo/extern-c-fn.rs index d81ab356c1e9..4642073faabc 100644 --- a/tests/debuginfo/extern-c-fn.rs +++ b/tests/debuginfo/extern-c-fn.rs @@ -20,13 +20,13 @@ // lldb-command:run // lldb-command:v len -// lldbg-check:[...] 20 +// lldb-check:[...] 20 // lldb-command:v local0 -// lldbg-check:[...] 19 +// lldb-check:[...] 19 // lldb-command:v local1 -// lldbg-check:[...] true +// lldb-check:[...] true // lldb-command:v local2 -// lldbg-check:[...] 20.5 +// lldb-check:[...] 20.5 // lldb-command:continue diff --git a/tests/debuginfo/function-arguments.rs b/tests/debuginfo/function-arguments.rs index 9befadf5dc15..21c0c7d859cc 100644 --- a/tests/debuginfo/function-arguments.rs +++ b/tests/debuginfo/function-arguments.rs @@ -21,15 +21,15 @@ // lldb-command:run // lldb-command:v x -// lldbg-check:[...] 111102 +// lldb-check:[...] 111102 // lldb-command:v y -// lldbg-check:[...] true +// lldb-check:[...] true // lldb-command:continue // lldb-command:v a -// lldbg-check:[...] 2000 +// lldb-check:[...] 2000 // lldb-command:v b -// lldbg-check:[...] 3000 +// lldb-check:[...] 3000 // lldb-command:continue diff --git a/tests/debuginfo/generic-function.rs b/tests/debuginfo/generic-function.rs index 47f695b8fbe9..4be8d5ad45aa 100644 --- a/tests/debuginfo/generic-function.rs +++ b/tests/debuginfo/generic-function.rs @@ -27,21 +27,21 @@ // lldb-command:run // lldb-command:v *t0 -// lldbg-check:[...] 1 +// lldb-check:[...] 1 // lldb-command:v *t1 -// lldbg-check:[...] 2.5 +// lldb-check:[...] 2.5 // lldb-command:continue // lldb-command:v *t0 -// lldbg-check:[...] 3.5 +// lldb-check:[...] 3.5 // lldb-command:v *t1 -// lldbg-check:[...] 4 +// lldb-check:[...] 4 // lldb-command:continue // lldb-command:v *t0 -// lldbg-check:[...] 5 +// lldb-check:[...] 5 // lldb-command:v *t1 -// lldbg-check:[...] { a = 6 b = 7.5 } +// lldb-check:[...] { a = 6 b = 7.5 } // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/generic-functions-nested.rs b/tests/debuginfo/generic-functions-nested.rs index 500a42f3dc8c..7e0c20f89038 100644 --- a/tests/debuginfo/generic-functions-nested.rs +++ b/tests/debuginfo/generic-functions-nested.rs @@ -34,27 +34,27 @@ // lldb-command:run // lldb-command:v x -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:v y -// lldbg-check:[...] 1 +// lldb-check:[...] 1 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:v y -// lldbg-check:[...] 2.5 +// lldb-check:[...] 2.5 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] -2.5 +// lldb-check:[...] -2.5 // lldb-command:v y -// lldbg-check:[...] 1 +// lldb-check:[...] 1 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] -2.5 +// lldb-check:[...] -2.5 // lldb-command:v y -// lldbg-check:[...] 2.5 +// lldb-check:[...] 2.5 // lldb-command:continue diff --git a/tests/debuginfo/generic-method-on-generic-struct.rs b/tests/debuginfo/generic-method-on-generic-struct.rs index 071d436b0895..a391fbf08265 100644 --- a/tests/debuginfo/generic-method-on-generic-struct.rs +++ b/tests/debuginfo/generic-method-on-generic-struct.rs @@ -56,47 +56,47 @@ // STACK BY REF // lldb-command:v *self -// lldbg-check:[...] { x = { 0 = 8888, 1 = -8888 } } +// lldb-check:[...] { x = { 0 = 8888, 1 = -8888 } } // lldb-command:v arg1 -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:v arg2 -// lldbg-check:[...] 2 +// lldb-check:[...] 2 // lldb-command:continue // STACK BY VAL // lldb-command:v self -// lldbg-check:[...] { x = { 0 = 8888, 1 = -8888 } } +// lldb-check:[...] { x = { 0 = 8888, 1 = -8888 } } // lldb-command:v arg1 -// lldbg-check:[...] -3 +// lldb-check:[...] -3 // lldb-command:v arg2 -// lldbg-check:[...] -4 +// lldb-check:[...] -4 // lldb-command:continue // OWNED BY REF // lldb-command:v *self -// lldbg-check:[...] { x = 1234.5 } +// lldb-check:[...] { x = 1234.5 } // lldb-command:v arg1 -// lldbg-check:[...] -5 +// lldb-check:[...] -5 // lldb-command:v arg2 -// lldbg-check:[...] -6 +// lldb-check:[...] -6 // lldb-command:continue // OWNED BY VAL // lldb-command:v self -// lldbg-check:[...] { x = 1234.5 } +// lldb-check:[...] { x = 1234.5 } // lldb-command:v arg1 -// lldbg-check:[...] -7 +// lldb-check:[...] -7 // lldb-command:v arg2 -// lldbg-check:[...] -8 +// lldb-check:[...] -8 // lldb-command:continue // OWNED MOVED // lldb-command:v *self -// lldbg-check:[...] { x = 1234.5 } +// lldb-check:[...] { x = 1234.5 } // lldb-command:v arg1 -// lldbg-check:[...] -9 +// lldb-check:[...] -9 // lldb-command:v arg2 -// lldbg-check:[...] -10.5 +// lldb-check:[...] -10.5 // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/generic-struct.rs b/tests/debuginfo/generic-struct.rs index 49ec4ac1c177..09160bc3ba03 100644 --- a/tests/debuginfo/generic-struct.rs +++ b/tests/debuginfo/generic-struct.rs @@ -18,14 +18,14 @@ // lldb-command:run // lldb-command:v int_int -// lldbg-check:[...] AGenericStruct { key: 0, value: 1 } +// lldb-check:[...] AGenericStruct { key: 0, value: 1 } // lldb-command:v int_float -// lldbg-check:[...] AGenericStruct { key: 2, value: 3.5 } +// lldb-check:[...] AGenericStruct { key: 2, value: 3.5 } // lldb-command:v float_int -// lldbg-check:[...] AGenericStruct { key: 4.5, value: 5 } +// lldb-check:[...] AGenericStruct { key: 4.5, value: 5 } // lldb-command:v float_int_float -// lldbg-check:[...] AGenericStruct> { key: 6.5, value: AGenericStruct { key: 7, value: 8.5 } } +// lldb-check:[...] AGenericStruct> { key: 6.5, value: AGenericStruct { key: 7, value: 8.5 } } // === CDB TESTS =================================================================================== diff --git a/tests/debuginfo/include_string.rs b/tests/debuginfo/include_string.rs index 5bf7cb69cc12..704b85e1ac2d 100644 --- a/tests/debuginfo/include_string.rs +++ b/tests/debuginfo/include_string.rs @@ -17,11 +17,11 @@ // lldb-command:run // lldb-command:v string1.length -// lldbg-check:[...] 48 +// lldb-check:[...] 48 // lldb-command:v string2.length -// lldbg-check:[...] 49 +// lldb-check:[...] 49 // lldb-command:v string3.length -// lldbg-check:[...] 50 +// lldb-check:[...] 50 // lldb-command:continue diff --git a/tests/debuginfo/issue-22656.rs b/tests/debuginfo/issue-22656.rs index 5198d34c7b8b..eb0b38cfa4d6 100644 --- a/tests/debuginfo/issue-22656.rs +++ b/tests/debuginfo/issue-22656.rs @@ -10,9 +10,9 @@ // lldb-command:run // lldb-command:v v -// lldbg-check:[...] size=3 { [0] = 1 [1] = 2 [2] = 3 } +// lldb-check:[...] size=3 { [0] = 1 [1] = 2 [2] = 3 } // lldb-command:v zs -// lldbg-check:[...] { x = y = 123 z = w = 456 } +// lldb-check:[...] { x = y = 123 z = w = 456 } #![allow(unused_variables)] #![allow(dead_code)] diff --git a/tests/debuginfo/issue-57822.rs b/tests/debuginfo/issue-57822.rs index 8a8cf41ab1fb..7abac1c14d32 100644 --- a/tests/debuginfo/issue-57822.rs +++ b/tests/debuginfo/issue-57822.rs @@ -19,10 +19,10 @@ // lldb-command:run // lldb-command:v g -// lldbg-check:(issue_57822::main::{closure_env#1}) g = { f = { x = 1 } } +// lldb-check:(issue_57822::main::{closure_env#1}) g = { f = { x = 1 } } // lldb-command:v b -// lldbg-check:(issue_57822::main::{coroutine_env#3}) b = { value = { a = { value = { y = 2 } $discr$ = '\x02' } } $discr$ = '\x02' } +// lldb-check:(issue_57822::main::{coroutine_env#3}) b = { value = { a = { value = { y = 2 } $discr$ = '\x02' } } $discr$ = '\x02' } #![feature(omit_gdb_pretty_printer_section, coroutines, coroutine_trait, stmt_expr_attributes)] #![omit_gdb_pretty_printer_section] diff --git a/tests/debuginfo/lexical-scope-in-for-loop.rs b/tests/debuginfo/lexical-scope-in-for-loop.rs index acfddaab89c7..08f244f89a02 100644 --- a/tests/debuginfo/lexical-scope-in-for-loop.rs +++ b/tests/debuginfo/lexical-scope-in-for-loop.rs @@ -43,34 +43,34 @@ // FIRST ITERATION // lldb-command:v x -// lldbg-check:[...] 1 +// lldb-check:[...] 1 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:continue // SECOND ITERATION // lldb-command:v x -// lldbg-check:[...] 2 +// lldb-check:[...] 2 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] -2 +// lldb-check:[...] -2 // lldb-command:continue // THIRD ITERATION // lldb-command:v x -// lldbg-check:[...] 3 +// lldb-check:[...] 3 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] -3 +// lldb-check:[...] -3 // lldb-command:continue // AFTER LOOP // lldb-command:v x -// lldbg-check:[...] 1000000 +// lldb-check:[...] 1000000 // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/lexical-scope-in-if.rs b/tests/debuginfo/lexical-scope-in-if.rs index d1c5884843c4..c0e1f2f3e05c 100644 --- a/tests/debuginfo/lexical-scope-in-if.rs +++ b/tests/debuginfo/lexical-scope-in-if.rs @@ -67,58 +67,58 @@ // BEFORE if // lldb-command:v x -// lldbg-check:[...] 999 +// lldb-check:[...] 999 // lldb-command:v y -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:continue // AT BEGINNING of 'then' block // lldb-command:v x -// lldbg-check:[...] 999 +// lldb-check:[...] 999 // lldb-command:v y -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:continue // AFTER 1st redeclaration of 'x' // lldb-command:v x -// lldbg-check:[...] 1001 +// lldb-check:[...] 1001 // lldb-command:v y -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:continue // AFTER 2st redeclaration of 'x' // lldb-command:v x -// lldbg-check:[...] 1002 +// lldb-check:[...] 1002 // lldb-command:v y -// lldbg-check:[...] 1003 +// lldb-check:[...] 1003 // lldb-command:continue // AFTER 1st if expression // lldb-command:v x -// lldbg-check:[...] 999 +// lldb-check:[...] 999 // lldb-command:v y -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:continue // BEGINNING of else branch // lldb-command:v x -// lldbg-check:[...] 999 +// lldb-check:[...] 999 // lldb-command:v y -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:continue // BEGINNING of else branch // lldb-command:v x -// lldbg-check:[...] 1004 +// lldb-check:[...] 1004 // lldb-command:v y -// lldbg-check:[...] 1005 +// lldb-check:[...] 1005 // lldb-command:continue // BEGINNING of else branch // lldb-command:v x -// lldbg-check:[...] 999 +// lldb-check:[...] 999 // lldb-command:v y -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/lexical-scope-in-match.rs b/tests/debuginfo/lexical-scope-in-match.rs index 754616b1a54b..9169c19c6a33 100644 --- a/tests/debuginfo/lexical-scope-in-match.rs +++ b/tests/debuginfo/lexical-scope-in-match.rs @@ -62,55 +62,55 @@ // lldb-command:run // lldb-command:v shadowed -// lldbg-check:[...] 231 +// lldb-check:[...] 231 // lldb-command:v not_shadowed -// lldbg-check:[...] 232 +// lldb-check:[...] 232 // lldb-command:continue // lldb-command:v shadowed -// lldbg-check:[...] 233 +// lldb-check:[...] 233 // lldb-command:v not_shadowed -// lldbg-check:[...] 232 +// lldb-check:[...] 232 // lldb-command:v local_to_arm -// lldbg-check:[...] 234 +// lldb-check:[...] 234 // lldb-command:continue // lldb-command:v shadowed -// lldbg-check:[...] 236 +// lldb-check:[...] 236 // lldb-command:v not_shadowed -// lldbg-check:[...] 232 +// lldb-check:[...] 232 // lldb-command:continue // lldb-command:v shadowed -// lldbg-check:[...] 237 +// lldb-check:[...] 237 // lldb-command:v not_shadowed -// lldbg-check:[...] 232 +// lldb-check:[...] 232 // lldb-command:v local_to_arm -// lldbg-check:[...] 238 +// lldb-check:[...] 238 // lldb-command:continue // lldb-command:v shadowed -// lldbg-check:[...] 239 +// lldb-check:[...] 239 // lldb-command:v not_shadowed -// lldbg-check:[...] 232 +// lldb-check:[...] 232 // lldb-command:continue // lldb-command:v shadowed -// lldbg-check:[...] 241 +// lldb-check:[...] 241 // lldb-command:v not_shadowed -// lldbg-check:[...] 232 +// lldb-check:[...] 232 // lldb-command:continue // lldb-command:v shadowed -// lldbg-check:[...] 243 +// lldb-check:[...] 243 // lldb-command:v *local_to_arm -// lldbg-check:[...] 244 +// lldb-check:[...] 244 // lldb-command:continue // lldb-command:v shadowed -// lldbg-check:[...] 231 +// lldb-check:[...] 231 // lldb-command:v not_shadowed -// lldbg-check:[...] 232 +// lldb-check:[...] 232 // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/lexical-scope-in-stack-closure.rs b/tests/debuginfo/lexical-scope-in-stack-closure.rs index 301423080e68..d01162c39d69 100644 --- a/tests/debuginfo/lexical-scope-in-stack-closure.rs +++ b/tests/debuginfo/lexical-scope-in-stack-closure.rs @@ -34,27 +34,27 @@ // lldb-command:run // lldb-command:v x -// lldbg-check:[...] false +// lldb-check:[...] false // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] false +// lldb-check:[...] false // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 1000 +// lldb-check:[...] 1000 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 2.5 +// lldb-check:[...] 2.5 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] true +// lldb-check:[...] true // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] false +// lldb-check:[...] false // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/lexical-scope-in-unconditional-loop.rs b/tests/debuginfo/lexical-scope-in-unconditional-loop.rs index 1d111dab5c94..dfec570218f3 100644 --- a/tests/debuginfo/lexical-scope-in-unconditional-loop.rs +++ b/tests/debuginfo/lexical-scope-in-unconditional-loop.rs @@ -66,57 +66,57 @@ // FIRST ITERATION // lldb-command:v x -// lldbg-check:[...] 0 +// lldb-check:[...] 0 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 1 +// lldb-check:[...] 1 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 101 +// lldb-check:[...] 101 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 101 +// lldb-check:[...] 101 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] -987 +// lldb-check:[...] -987 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 101 +// lldb-check:[...] 101 // lldb-command:continue // SECOND ITERATION // lldb-command:v x -// lldbg-check:[...] 1 +// lldb-check:[...] 1 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 2 +// lldb-check:[...] 2 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 102 +// lldb-check:[...] 102 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 102 +// lldb-check:[...] 102 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] -987 +// lldb-check:[...] -987 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 102 +// lldb-check:[...] 102 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 2 +// lldb-check:[...] 2 // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/lexical-scope-in-unique-closure.rs b/tests/debuginfo/lexical-scope-in-unique-closure.rs index d6cf39c77ae1..db84005121af 100644 --- a/tests/debuginfo/lexical-scope-in-unique-closure.rs +++ b/tests/debuginfo/lexical-scope-in-unique-closure.rs @@ -34,27 +34,27 @@ // lldb-command:run // lldb-command:v x -// lldbg-check:[...] false +// lldb-check:[...] false // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] false +// lldb-check:[...] false // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 1000 +// lldb-check:[...] 1000 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 2.5 +// lldb-check:[...] 2.5 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] true +// lldb-check:[...] true // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] false +// lldb-check:[...] false // lldb-command:continue diff --git a/tests/debuginfo/lexical-scope-in-while.rs b/tests/debuginfo/lexical-scope-in-while.rs index faef8b44a297..d6536d77545b 100644 --- a/tests/debuginfo/lexical-scope-in-while.rs +++ b/tests/debuginfo/lexical-scope-in-while.rs @@ -66,57 +66,57 @@ // FIRST ITERATION // lldb-command:v x -// lldbg-check:[...] 0 +// lldb-check:[...] 0 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 1 +// lldb-check:[...] 1 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 101 +// lldb-check:[...] 101 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 101 +// lldb-check:[...] 101 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] -987 +// lldb-check:[...] -987 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 101 +// lldb-check:[...] 101 // lldb-command:continue // SECOND ITERATION // lldb-command:v x -// lldbg-check:[...] 1 +// lldb-check:[...] 1 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 2 +// lldb-check:[...] 2 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 102 +// lldb-check:[...] 102 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 102 +// lldb-check:[...] 102 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] -987 +// lldb-check:[...] -987 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 102 +// lldb-check:[...] 102 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 2 +// lldb-check:[...] 2 // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/lexical-scope-with-macro.rs b/tests/debuginfo/lexical-scope-with-macro.rs index 5f8838c782bb..6e8fef201ead 100644 --- a/tests/debuginfo/lexical-scope-with-macro.rs +++ b/tests/debuginfo/lexical-scope-with-macro.rs @@ -54,48 +54,48 @@ // lldb-command:run // lldb-command:v a -// lldbg-check:[...] 10 +// lldb-check:[...] 10 // lldb-command:v b -// lldbg-check:[...] 34 +// lldb-check:[...] 34 // lldb-command:continue // lldb-command:v a -// lldbg-check:[...] 890242 +// lldb-check:[...] 890242 // lldb-command:v b -// lldbg-check:[...] 34 +// lldb-check:[...] 34 // lldb-command:continue // lldb-command:v a -// lldbg-check:[...] 10 +// lldb-check:[...] 10 // lldb-command:v b -// lldbg-check:[...] 34 +// lldb-check:[...] 34 // lldb-command:continue // lldb-command:v a -// lldbg-check:[...] 102 +// lldb-check:[...] 102 // lldb-command:v b -// lldbg-check:[...] 34 +// lldb-check:[...] 34 // lldb-command:continue -// lldbg-command:print a -// lldbg-check:[...] 110 -// lldbg-command:print b -// lldbg-check:[...] 34 -// lldbg-command:continue +// lldb-command:print a +// lldb-check:[...] 110 +// lldb-command:print b +// lldb-check:[...] 34 +// lldb-command:continue -// lldbg-command:print a -// lldbg-check:[...] 10 -// lldbg-command:print b -// lldbg-check:[...] 34 -// lldbg-command:continue +// lldb-command:print a +// lldb-check:[...] 10 +// lldb-command:print b +// lldb-check:[...] 34 +// lldb-command:continue -// lldbg-command:print a -// lldbg-check:[...] 10 -// lldbg-command:print b -// lldbg-check:[...] 34 -// lldbg-command:print c -// lldbg-check:[...] 400 -// lldbg-command:continue +// lldb-command:print a +// lldb-check:[...] 10 +// lldb-command:print b +// lldb-check:[...] 34 +// lldb-command:print c +// lldb-check:[...] 400 +// lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] #![omit_gdb_pretty_printer_section] diff --git a/tests/debuginfo/lexical-scopes-in-block-expression.rs b/tests/debuginfo/lexical-scopes-in-block-expression.rs index f90c3dd327bc..cd27c88db58e 100644 --- a/tests/debuginfo/lexical-scopes-in-block-expression.rs +++ b/tests/debuginfo/lexical-scopes-in-block-expression.rs @@ -183,155 +183,155 @@ // STRUCT EXPRESSION // lldb-command:v val -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:v ten -// lldbg-check:[...] 10 +// lldb-check:[...] 10 // lldb-command:continue // lldb-command:v val -// lldbg-check:[...] 11 +// lldb-check:[...] 11 // lldb-command:v ten -// lldbg-check:[...] 10 +// lldb-check:[...] 10 // lldb-command:continue // lldb-command:v val -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:v ten -// lldbg-check:[...] 10 +// lldb-check:[...] 10 // lldb-command:continue // FUNCTION CALL // lldb-command:v val -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:v ten -// lldbg-check:[...] 10 +// lldb-check:[...] 10 // lldb-command:continue // lldb-command:v val -// lldbg-check:[...] 12 +// lldb-check:[...] 12 // lldb-command:v ten -// lldbg-check:[...] 10 +// lldb-check:[...] 10 // lldb-command:continue // lldb-command:v val -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:v ten -// lldbg-check:[...] 10 +// lldb-check:[...] 10 // lldb-command:continue // TUPLE EXPRESSION // lldb-command:v val -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:v ten -// lldbg-check:[...] 10 +// lldb-check:[...] 10 // lldb-command:continue // lldb-command:v val -// lldbg-check:[...] 13 +// lldb-check:[...] 13 // lldb-command:v ten -// lldbg-check:[...] 10 +// lldb-check:[...] 10 // lldb-command:continue // lldb-command:v val -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:v ten -// lldbg-check:[...] 10 +// lldb-check:[...] 10 // lldb-command:continue // VEC EXPRESSION // lldb-command:v val -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:v ten -// lldbg-check:[...] 10 +// lldb-check:[...] 10 // lldb-command:continue // lldb-command:v val -// lldbg-check:[...] 14 +// lldb-check:[...] 14 // lldb-command:v ten -// lldbg-check:[...] 10 +// lldb-check:[...] 10 // lldb-command:continue // lldb-command:v val -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:v ten -// lldbg-check:[...] 10 +// lldb-check:[...] 10 // lldb-command:continue // REPEAT VEC EXPRESSION // lldb-command:v val -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:v ten -// lldbg-check:[...] 10 +// lldb-check:[...] 10 // lldb-command:continue // lldb-command:v val -// lldbg-check:[...] 15 +// lldb-check:[...] 15 // lldb-command:v ten -// lldbg-check:[...] 10 +// lldb-check:[...] 10 // lldb-command:continue // lldb-command:v val -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:v ten -// lldbg-check:[...] 10 +// lldb-check:[...] 10 // lldb-command:continue // ASSIGNMENT EXPRESSION // lldb-command:v val -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:v ten -// lldbg-check:[...] 10 +// lldb-check:[...] 10 // lldb-command:continue // lldb-command:v val -// lldbg-check:[...] 16 +// lldb-check:[...] 16 // lldb-command:v ten -// lldbg-check:[...] 10 +// lldb-check:[...] 10 // lldb-command:continue // lldb-command:v val -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:v ten -// lldbg-check:[...] 10 +// lldb-check:[...] 10 // lldb-command:continue // ARITHMETIC EXPRESSION // lldb-command:v val -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:v ten -// lldbg-check:[...] 10 +// lldb-check:[...] 10 // lldb-command:continue // lldb-command:v val -// lldbg-check:[...] 17 +// lldb-check:[...] 17 // lldb-command:v ten -// lldbg-check:[...] 10 +// lldb-check:[...] 10 // lldb-command:continue // lldb-command:v val -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:v ten -// lldbg-check:[...] 10 +// lldb-check:[...] 10 // lldb-command:continue // INDEX EXPRESSION // lldb-command:v val -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:v ten -// lldbg-check:[...] 10 +// lldb-check:[...] 10 // lldb-command:continue // lldb-command:v val -// lldbg-check:[...] 18 +// lldb-check:[...] 18 // lldb-command:v ten -// lldbg-check:[...] 10 +// lldb-check:[...] 10 // lldb-command:continue // lldb-command:v val -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:v ten -// lldbg-check:[...] 10 +// lldb-check:[...] 10 // lldb-command:continue #![allow(unused_variables)] diff --git a/tests/debuginfo/method-on-generic-struct.rs b/tests/debuginfo/method-on-generic-struct.rs index 27e83cbbe223..23617d46e831 100644 --- a/tests/debuginfo/method-on-generic-struct.rs +++ b/tests/debuginfo/method-on-generic-struct.rs @@ -56,47 +56,47 @@ // STACK BY REF // lldb-command:v *self -// lldbg-check:[...] Struct<(u32, i32)> { x: (8888, -8888) } +// lldb-check:[...] Struct<(u32, i32)> { x: (8888, -8888) } // lldb-command:v arg1 -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:v arg2 -// lldbg-check:[...] -2 +// lldb-check:[...] -2 // lldb-command:continue // STACK BY VAL // lldb-command:v self -// lldbg-check:[...] Struct<(u32, i32)> { x: (8888, -8888) } +// lldb-check:[...] Struct<(u32, i32)> { x: (8888, -8888) } // lldb-command:v arg1 -// lldbg-check:[...] -3 +// lldb-check:[...] -3 // lldb-command:v arg2 -// lldbg-check:[...] -4 +// lldb-check:[...] -4 // lldb-command:continue // OWNED BY REF // lldb-command:v *self -// lldbg-check:[...] Struct { x: 1234.5 } +// lldb-check:[...] Struct { x: 1234.5 } // lldb-command:v arg1 -// lldbg-check:[...] -5 +// lldb-check:[...] -5 // lldb-command:v arg2 -// lldbg-check:[...] -6 +// lldb-check:[...] -6 // lldb-command:continue // OWNED BY VAL // lldb-command:v self -// lldbg-check:[...] Struct { x: 1234.5 } +// lldb-check:[...] Struct { x: 1234.5 } // lldb-command:v arg1 -// lldbg-check:[...] -7 +// lldb-check:[...] -7 // lldb-command:v arg2 -// lldbg-check:[...] -8 +// lldb-check:[...] -8 // lldb-command:continue // OWNED MOVED // lldb-command:v *self -// lldbg-check:[...] Struct { x: 1234.5 } +// lldb-check:[...] Struct { x: 1234.5 } // lldb-command:v arg1 -// lldbg-check:[...] -9 +// lldb-check:[...] -9 // lldb-command:v arg2 -// lldbg-check:[...] -10 +// lldb-check:[...] -10 // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/method-on-struct.rs b/tests/debuginfo/method-on-struct.rs index 307c6d92d489..91f609365e9a 100644 --- a/tests/debuginfo/method-on-struct.rs +++ b/tests/debuginfo/method-on-struct.rs @@ -56,47 +56,47 @@ // STACK BY REF // lldb-command:v *self -// lldbg-check:[...] { x = 100 } +// lldb-check:[...] { x = 100 } // lldb-command:v arg1 -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:v arg2 -// lldbg-check:[...] -2 +// lldb-check:[...] -2 // lldb-command:continue // STACK BY VAL // lldb-command:v self -// lldbg-check:[...] { x = 100 } +// lldb-check:[...] { x = 100 } // lldb-command:v arg1 -// lldbg-check:[...] -3 +// lldb-check:[...] -3 // lldb-command:v arg2 -// lldbg-check:[...] -4 +// lldb-check:[...] -4 // lldb-command:continue // OWNED BY REF // lldb-command:v *self -// lldbg-check:[...] { x = 200 } +// lldb-check:[...] { x = 200 } // lldb-command:v arg1 -// lldbg-check:[...] -5 +// lldb-check:[...] -5 // lldb-command:v arg2 -// lldbg-check:[...] -6 +// lldb-check:[...] -6 // lldb-command:continue // OWNED BY VAL // lldb-command:v self -// lldbg-check:[...] { x = 200 } +// lldb-check:[...] { x = 200 } // lldb-command:v arg1 -// lldbg-check:[...] -7 +// lldb-check:[...] -7 // lldb-command:v arg2 -// lldbg-check:[...] -8 +// lldb-check:[...] -8 // lldb-command:continue // OWNED MOVED // lldb-command:v *self -// lldbg-check:[...] { x = 200 } +// lldb-check:[...] { x = 200 } // lldb-command:v arg1 -// lldbg-check:[...] -9 +// lldb-check:[...] -9 // lldb-command:v arg2 -// lldbg-check:[...] -10 +// lldb-check:[...] -10 // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/method-on-trait.rs b/tests/debuginfo/method-on-trait.rs index 29087da0e6a6..7b95e1f81c70 100644 --- a/tests/debuginfo/method-on-trait.rs +++ b/tests/debuginfo/method-on-trait.rs @@ -56,47 +56,47 @@ // STACK BY REF // lldb-command:v *self -// lldbg-check:[...] { x = 100 } +// lldb-check:[...] { x = 100 } // lldb-command:v arg1 -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:v arg2 -// lldbg-check:[...] -2 +// lldb-check:[...] -2 // lldb-command:continue // STACK BY VAL // lldb-command:v self -// lldbg-check:[...] { x = 100 } +// lldb-check:[...] { x = 100 } // lldb-command:v arg1 -// lldbg-check:[...] -3 +// lldb-check:[...] -3 // lldb-command:v arg2 -// lldbg-check:[...] -4 +// lldb-check:[...] -4 // lldb-command:continue // OWNED BY REF // lldb-command:v *self -// lldbg-check:[...] { x = 200 } +// lldb-check:[...] { x = 200 } // lldb-command:v arg1 -// lldbg-check:[...] -5 +// lldb-check:[...] -5 // lldb-command:v arg2 -// lldbg-check:[...] -6 +// lldb-check:[...] -6 // lldb-command:continue // OWNED BY VAL // lldb-command:v self -// lldbg-check:[...] { x = 200 } +// lldb-check:[...] { x = 200 } // lldb-command:v arg1 -// lldbg-check:[...] -7 +// lldb-check:[...] -7 // lldb-command:v arg2 -// lldbg-check:[...] -8 +// lldb-check:[...] -8 // lldb-command:continue // OWNED MOVED // lldb-command:v *self -// lldbg-check:[...] { x = 200 } +// lldb-check:[...] { x = 200 } // lldb-command:v arg1 -// lldbg-check:[...] -9 +// lldb-check:[...] -9 // lldb-command:v arg2 -// lldbg-check:[...] -10 +// lldb-check:[...] -10 // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/method-on-tuple-struct.rs b/tests/debuginfo/method-on-tuple-struct.rs index 7b8d30abf63c..04c00d883025 100644 --- a/tests/debuginfo/method-on-tuple-struct.rs +++ b/tests/debuginfo/method-on-tuple-struct.rs @@ -56,47 +56,47 @@ // STACK BY REF // lldb-command:v *self -// lldbg-check:[...] { 0 = 100 1 = -100.5 } +// lldb-check:[...] { 0 = 100 1 = -100.5 } // lldb-command:v arg1 -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:v arg2 -// lldbg-check:[...] -2 +// lldb-check:[...] -2 // lldb-command:continue // STACK BY VAL // lldb-command:v self -// lldbg-check:[...] { 0 = 100 1 = -100.5 } +// lldb-check:[...] { 0 = 100 1 = -100.5 } // lldb-command:v arg1 -// lldbg-check:[...] -3 +// lldb-check:[...] -3 // lldb-command:v arg2 -// lldbg-check:[...] -4 +// lldb-check:[...] -4 // lldb-command:continue // OWNED BY REF // lldb-command:v *self -// lldbg-check:[...] { 0 = 200 1 = -200.5 } +// lldb-check:[...] { 0 = 200 1 = -200.5 } // lldb-command:v arg1 -// lldbg-check:[...] -5 +// lldb-check:[...] -5 // lldb-command:v arg2 -// lldbg-check:[...] -6 +// lldb-check:[...] -6 // lldb-command:continue // OWNED BY VAL // lldb-command:v self -// lldbg-check:[...] { 0 = 200 1 = -200.5 } +// lldb-check:[...] { 0 = 200 1 = -200.5 } // lldb-command:v arg1 -// lldbg-check:[...] -7 +// lldb-check:[...] -7 // lldb-command:v arg2 -// lldbg-check:[...] -8 +// lldb-check:[...] -8 // lldb-command:continue // OWNED MOVED // lldb-command:v *self -// lldbg-check:[...] { 0 = 200 1 = -200.5 } +// lldb-check:[...] { 0 = 200 1 = -200.5 } // lldb-command:v arg1 -// lldbg-check:[...] -9 +// lldb-check:[...] -9 // lldb-command:v arg2 -// lldbg-check:[...] -10 +// lldb-check:[...] -10 // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/msvc-pretty-enums.rs b/tests/debuginfo/msvc-pretty-enums.rs index a2e2b32cfd11..d60a7b81944e 100644 --- a/tests/debuginfo/msvc-pretty-enums.rs +++ b/tests/debuginfo/msvc-pretty-enums.rs @@ -6,72 +6,72 @@ // lldb-command:run // lldb-command:v a -// lldbg-check:(core::option::Option) a = { value = { 0 = Low } } +// lldb-check:(core::option::Option) a = { value = { 0 = Low } } // lldb-command:v b -// lldbg-check:(core::option::Option) b = { value = $discr$ = '\x01' } +// lldb-check:(core::option::Option) b = { value = $discr$ = '\x01' } // lldb-command:v c -// lldbg-check:(msvc_pretty_enums::NicheLayoutEnum) c = { value = $discr$ = '\x11' } +// lldb-check:(msvc_pretty_enums::NicheLayoutEnum) c = { value = $discr$ = '\x11' } // lldb-command:v d -// lldbg-check:(msvc_pretty_enums::NicheLayoutEnum) d = { value = { my_data = High } } +// lldb-check:(msvc_pretty_enums::NicheLayoutEnum) d = { value = { my_data = High } } // lldb-command:v e -// lldbg-check:(msvc_pretty_enums::NicheLayoutEnum) e = { value = $discr$ = '\x13' } +// lldb-check:(msvc_pretty_enums::NicheLayoutEnum) e = { value = $discr$ = '\x13' } // lldb-command:v h -// lldbg-check:(core::option::Option) h = { value = { 0 = 12 } $discr$ = 1 } +// lldb-check:(core::option::Option) h = { value = { 0 = 12 } $discr$ = 1 } // lldb-command:v i -// lldbg-check:(core::option::Option) i = { value = $discr$ = 0 } +// lldb-check:(core::option::Option) i = { value = $discr$ = 0 } // lldb-command:v j -// lldbg-check:(msvc_pretty_enums::CStyleEnum) j = High +// lldb-check:(msvc_pretty_enums::CStyleEnum) j = High // lldb-command:v k -// lldbg-check:(core::option::Option) k = { value = { 0 = "IAMA optional string!" { vec = size=21 { [0] = 'I' [1] = 'A' [2] = 'M' [3] = 'A' [4] = ' ' [5] = 'o' [6] = 'p' [7] = 't' [8] = 'i' [9] = 'o' [10] = 'n' [11] = 'a' [12] = 'l' [13] = ' ' [14] = 's' [15] = 't' [16] = 'r' [17] = 'i' [18] = 'n' [19] = 'g' [20] = '!' } } } } +// lldb-check:(core::option::Option) k = { value = { 0 = "IAMA optional string!" { vec = size=21 { [0] = 'I' [1] = 'A' [2] = 'M' [3] = 'A' [4] = ' ' [5] = 'o' [6] = 'p' [7] = 't' [8] = 'i' [9] = 'o' [10] = 'n' [11] = 'a' [12] = 'l' [13] = ' ' [14] = 's' [15] = 't' [16] = 'r' [17] = 'i' [18] = 'n' [19] = 'g' [20] = '!' } } } } // lldb-command:v l -// lldbg-check:(core::result::Result) l = { value = { 0 = {} } } +// lldb-check:(core::result::Result) l = { value = { 0 = {} } } // lldb-command:v niche128_some -// lldbg-check:(core::option::Option>) niche128_some = { value = $discr$ = 123456 } +// lldb-check:(core::option::Option>) niche128_some = { value = $discr$ = 123456 } // lldb-command:v niche128_none -// lldbg-check:(core::option::Option>) niche128_none = { value = $discr$ = 0 } +// lldb-check:(core::option::Option>) niche128_none = { value = $discr$ = 0 } // lldb-command:v wrapping_niche128_untagged -// lldbg-check:(msvc_pretty_enums::Wrapping128Niche) wrapping_niche128_untagged = { value = { 0 = { 0 = 340282366920938463463374607431768211454 } } } +// lldb-check:(msvc_pretty_enums::Wrapping128Niche) wrapping_niche128_untagged = { value = { 0 = { 0 = 340282366920938463463374607431768211454 } } } // lldb-command:v wrapping_niche128_none1 -// lldbg-check:(msvc_pretty_enums::Wrapping128Niche) wrapping_niche128_none1 = { value = { 0 = { 0 = 2 } } } +// lldb-check:(msvc_pretty_enums::Wrapping128Niche) wrapping_niche128_none1 = { value = { 0 = { 0 = 2 } } } // lldb-command:v direct_tag_128_a -// lldbg-check:(msvc_pretty_enums::DirectTag128) direct_tag_128_a = { value = { 0 = 42 } $discr$ = 0 } +// lldb-check:(msvc_pretty_enums::DirectTag128) direct_tag_128_a = { value = { 0 = 42 } $discr$ = 0 } // lldb-command:v direct_tag_128_b -// lldbg-check:(msvc_pretty_enums::DirectTag128) direct_tag_128_b = { value = { 0 = 137 } $discr$ = 1 } +// lldb-check:(msvc_pretty_enums::DirectTag128) direct_tag_128_b = { value = { 0 = 137 } $discr$ = 1 } // &u32 is incorrectly formatted and LLDB thinks it's a char* so skipping niche_w_fields_1_some // lldb-command:v niche_w_fields_1_none -// lldbg-check:(msvc_pretty_enums::NicheLayoutWithFields1) niche_w_fields_1_none = { value = { 0 = 99 } $discr$ = 1 } +// lldb-check:(msvc_pretty_enums::NicheLayoutWithFields1) niche_w_fields_1_none = { value = { 0 = 99 } $discr$ = 1 } // lldb-command:v niche_w_fields_2_some -// lldbg-check:(msvc_pretty_enums::NicheLayoutWithFields2) niche_w_fields_2_some = { value = { 0 = 800 { __0 = { 0 = 800 } } 1 = 900 } $discr$ = 0 } +// lldb-check:(msvc_pretty_enums::NicheLayoutWithFields2) niche_w_fields_2_some = { value = { 0 = 800 { __0 = { 0 = 800 } } 1 = 900 } $discr$ = 0 } // lldb-command:v niche_w_fields_3_some -// lldbg-check:(msvc_pretty_enums::NicheLayoutWithFields3) niche_w_fields_3_some = { value = { 0 = '\x89' 1 = true } } +// lldb-check:(msvc_pretty_enums::NicheLayoutWithFields3) niche_w_fields_3_some = { value = { 0 = '\x89' 1 = true } } // lldb-command:v niche_w_fields_3_niche3 -// lldbg-check:(msvc_pretty_enums::NicheLayoutWithFields3) niche_w_fields_3_niche3 = { value = { 0 = '"' } $discr$ = '\x04' } +// lldb-check:(msvc_pretty_enums::NicheLayoutWithFields3) niche_w_fields_3_niche3 = { value = { 0 = '"' } $discr$ = '\x04' } // lldb-command:v arbitrary_discr1 -// lldbg-check:(msvc_pretty_enums::ArbitraryDiscr) arbitrary_discr1 = { value = { 0 = 1234 } $discr$ = 1000 } +// lldb-check:(msvc_pretty_enums::ArbitraryDiscr) arbitrary_discr1 = { value = { 0 = 1234 } $discr$ = 1000 } // lldb-command:v arbitrary_discr2 -// lldbg-check:(msvc_pretty_enums::ArbitraryDiscr) arbitrary_discr2 = { value = { 0 = 5678 } $discr$ = 5000000 } +// lldb-check:(msvc_pretty_enums::ArbitraryDiscr) arbitrary_discr2 = { value = { 0 = 5678 } $discr$ = 5000000 } // === CDB TESTS ================================================================================== diff --git a/tests/debuginfo/multi-cgu.rs b/tests/debuginfo/multi-cgu.rs index 81735f2bc09a..3bb5269adead 100644 --- a/tests/debuginfo/multi-cgu.rs +++ b/tests/debuginfo/multi-cgu.rs @@ -21,11 +21,11 @@ // lldb-command:run // lldb-command:v xxx -// lldbg-check:[...] 12345 +// lldb-check:[...] 12345 // lldb-command:continue // lldb-command:v yyy -// lldbg-check:[...] 67890 +// lldb-check:[...] 67890 // lldb-command:continue diff --git a/tests/debuginfo/multiple-functions-equal-var-names.rs b/tests/debuginfo/multiple-functions-equal-var-names.rs index cbf513ad0f71..6ae9225d55c3 100644 --- a/tests/debuginfo/multiple-functions-equal-var-names.rs +++ b/tests/debuginfo/multiple-functions-equal-var-names.rs @@ -21,15 +21,15 @@ // lldb-command:run // lldb-command:v abc -// lldbg-check:[...] 10101 +// lldb-check:[...] 10101 // lldb-command:continue // lldb-command:v abc -// lldbg-check:[...] 20202 +// lldb-check:[...] 20202 // lldb-command:continue // lldb-command:v abc -// lldbg-check:[...] 30303 +// lldb-check:[...] 30303 #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/multiple-functions.rs b/tests/debuginfo/multiple-functions.rs index a113ce17855c..3f7a0ded91b0 100644 --- a/tests/debuginfo/multiple-functions.rs +++ b/tests/debuginfo/multiple-functions.rs @@ -21,15 +21,15 @@ // lldb-command:run // lldb-command:v a -// lldbg-check:[...] 10101 +// lldb-check:[...] 10101 // lldb-command:continue // lldb-command:v b -// lldbg-check:[...] 20202 +// lldb-check:[...] 20202 // lldb-command:continue // lldb-command:v c -// lldbg-check:[...] 30303 +// lldb-check:[...] 30303 #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/name-shadowing-and-scope-nesting.rs b/tests/debuginfo/name-shadowing-and-scope-nesting.rs index 9d1accd963be..d3829b60713d 100644 --- a/tests/debuginfo/name-shadowing-and-scope-nesting.rs +++ b/tests/debuginfo/name-shadowing-and-scope-nesting.rs @@ -46,39 +46,39 @@ // lldb-command:run // lldb-command:v x -// lldbg-check:[...] false +// lldb-check:[...] false // lldb-command:v y -// lldbg-check:[...] true +// lldb-check:[...] true // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 10 +// lldb-check:[...] 10 // lldb-command:v y -// lldbg-check:[...] true +// lldb-check:[...] true // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 10.5 +// lldb-check:[...] 10.5 // lldb-command:v y -// lldbg-check:[...] 20 +// lldb-check:[...] 20 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] true +// lldb-check:[...] true // lldb-command:v y -// lldbg-check:[...] 2220 +// lldb-check:[...] 2220 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 203203.5 +// lldb-check:[...] 203203.5 // lldb-command:v y -// lldbg-check:[...] 2220 +// lldb-check:[...] 2220 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 10.5 +// lldb-check:[...] 10.5 // lldb-command:v y -// lldbg-check:[...] 20 +// lldb-check:[...] 20 // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/packed-struct-with-destructor.rs b/tests/debuginfo/packed-struct-with-destructor.rs index f715fdaea6fe..f923d36953c7 100644 --- a/tests/debuginfo/packed-struct-with-destructor.rs +++ b/tests/debuginfo/packed-struct-with-destructor.rs @@ -35,28 +35,28 @@ // lldb-command:run // lldb-command:v packed -// lldbg-check:[...] { x = 123 y = 234 z = 345 } +// lldb-check:[...] { x = 123 y = 234 z = 345 } // lldb-command:v packedInPacked -// lldbg-check:[...] { a = 1111 b = { x = 2222 y = 3333 z = 4444 } c = 5555 d = { x = 6666 y = 7777 z = 8888 } } +// lldb-check:[...] { a = 1111 b = { x = 2222 y = 3333 z = 4444 } c = 5555 d = { x = 6666 y = 7777 z = 8888 } } // lldb-command:v packedInUnpacked -// lldbg-check:[...] { a = -1111 b = { x = -2222 y = -3333 z = -4444 } c = -5555 d = { x = -6666 y = -7777 z = -8888 } } +// lldb-check:[...] { a = -1111 b = { x = -2222 y = -3333 z = -4444 } c = -5555 d = { x = -6666 y = -7777 z = -8888 } } // lldb-command:v unpackedInPacked -// lldbg-check:[...] { a = 987 b = { x = 876 y = 765 z = 654 } c = { x = 543 y = 432 z = 321 } d = 210 } +// lldb-check:[...] { a = 987 b = { x = 876 y = 765 z = 654 } c = { x = 543 y = 432 z = 321 } d = 210 } // lldb-command:v packedInPackedWithDrop -// lldbg-check:[...] { a = 11 b = { x = 22 y = 33 z = 44 } c = 55 d = { x = 66 y = 77 z = 88 } } +// lldb-check:[...] { a = 11 b = { x = 22 y = 33 z = 44 } c = 55 d = { x = 66 y = 77 z = 88 } } // lldb-command:v packedInUnpackedWithDrop -// lldbg-check:[...] { a = -11 b = { x = -22 y = -33 z = -44 } c = -55 d = { x = -66 y = -77 z = -88 } } +// lldb-check:[...] { a = -11 b = { x = -22 y = -33 z = -44 } c = -55 d = { x = -66 y = -77 z = -88 } } // lldb-command:v unpackedInPackedWithDrop -// lldbg-check:[...] { a = 98 b = { x = 87 y = 76 z = 65 } c = { x = 54 y = 43 z = 32 } d = 21 } +// lldb-check:[...] { a = 98 b = { x = 87 y = 76 z = 65 } c = { x = 54 y = 43 z = 32 } d = 21 } // lldb-command:v deeplyNested -// lldbg-check:[...] { a = { a = 1 b = { x = 2 y = 3 z = 4 } c = 5 d = { x = 6 y = 7 z = 8 } } b = { a = 9 b = { x = 10 y = 11 z = 12 } c = { x = 13 y = 14 z = 15 } d = 16 } c = { a = 17 b = { x = 18 y = 19 z = 20 } c = 21 d = { x = 22 y = 23 z = 24 } } d = { a = 25 b = { x = 26 y = 27 z = 28 } c = 29 d = { x = 30 y = 31 z = 32 } } e = { a = 33 b = { x = 34 y = 35 z = 36 } c = { x = 37 y = 38 z = 39 } d = 40 } f = { a = 41 b = { x = 42 y = 43 z = 44 } c = 45 d = { x = 46 y = 47 z = 48 } } } +// lldb-check:[...] { a = { a = 1 b = { x = 2 y = 3 z = 4 } c = 5 d = { x = 6 y = 7 z = 8 } } b = { a = 9 b = { x = 10 y = 11 z = 12 } c = { x = 13 y = 14 z = 15 } d = 16 } c = { a = 17 b = { x = 18 y = 19 z = 20 } c = 21 d = { x = 22 y = 23 z = 24 } } d = { a = 25 b = { x = 26 y = 27 z = 28 } c = 29 d = { x = 30 y = 31 z = 32 } } e = { a = 33 b = { x = 34 y = 35 z = 36 } c = { x = 37 y = 38 z = 39 } d = 40 } f = { a = 41 b = { x = 42 y = 43 z = 44 } c = 45 d = { x = 46 y = 47 z = 48 } } } #![allow(unused_variables)] diff --git a/tests/debuginfo/packed-struct.rs b/tests/debuginfo/packed-struct.rs index 5f5233e3732d..2b3652fe8611 100644 --- a/tests/debuginfo/packed-struct.rs +++ b/tests/debuginfo/packed-struct.rs @@ -28,22 +28,22 @@ // lldb-command:run // lldb-command:v packed -// lldbg-check:[...] { x = 123 y = 234 z = 345 } +// lldb-check:[...] { x = 123 y = 234 z = 345 } // lldb-command:v packedInPacked -// lldbg-check:[...] { a = 1111 b = { x = 2222 y = 3333 z = 4444 } c = 5555 d = { x = 6666 y = 7777 z = 8888 } } +// lldb-check:[...] { a = 1111 b = { x = 2222 y = 3333 z = 4444 } c = 5555 d = { x = 6666 y = 7777 z = 8888 } } // lldb-command:v packedInUnpacked -// lldbg-check:[...] { a = -1111 b = { x = -2222 y = -3333 z = -4444 } c = -5555 d = { x = -6666 y = -7777 z = -8888 } } +// lldb-check:[...] { a = -1111 b = { x = -2222 y = -3333 z = -4444 } c = -5555 d = { x = -6666 y = -7777 z = -8888 } } // lldb-command:v unpackedInPacked -// lldbg-check:[...] { a = 987 b = { x = 876 y = 765 z = 654 w = 543 } c = { x = 432 y = 321 z = 210 w = 109 } d = -98 } +// lldb-check:[...] { a = 987 b = { x = 876 y = 765 z = 654 w = 543 } c = { x = 432 y = 321 z = 210 w = 109 } d = -98 } // lldb-command:expr sizeof(packed) -// lldbg-check:[...] 14 +// lldb-check:[...] 14 // lldb-command:expr sizeof(packedInPacked) -// lldbg-check:[...] 40 +// lldb-check:[...] 40 #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/pretty-std-collections.rs b/tests/debuginfo/pretty-std-collections.rs index 2489d6d41362..5e133ee718e2 100644 --- a/tests/debuginfo/pretty-std-collections.rs +++ b/tests/debuginfo/pretty-std-collections.rs @@ -52,16 +52,16 @@ // lldb-command:run // lldb-command:v vec_deque -// lldbg-check:[...] size=3 { [0] = 5 [1] = 3 [2] = 7 } +// lldb-check:[...] size=3 { [0] = 5 [1] = 3 [2] = 7 } // lldb-command:v vec_deque2 -// lldbg-check:[...] size=7 { [0] = 2 [1] = 3 [2] = 4 [3] = 5 [4] = 6 [5] = 7 [6] = 8 } +// lldb-check:[...] size=7 { [0] = 2 [1] = 3 [2] = 4 [3] = 5 [4] = 6 [5] = 7 [6] = 8 } // lldb-command:v hash_map -// lldbg-check:[...] size=4 { [0] = { 0 = 1 1 = 10 } [1] = { 0 = 2 1 = 20 } [2] = { 0 = 3 1 = 30 } [3] = { 0 = 4 1 = 40 } } +// lldb-check:[...] size=4 { [0] = { 0 = 1 1 = 10 } [1] = { 0 = 2 1 = 20 } [2] = { 0 = 3 1 = 30 } [3] = { 0 = 4 1 = 40 } } // lldb-command:v hash_set -// lldbg-check:[...] size=4 { [0] = 1 [1] = 2 [2] = 3 [3] = 4 } +// lldb-check:[...] size=4 { [0] = 1 [1] = 2 [2] = 3 [3] = 4 } #![allow(unused_variables)] use std::collections::BTreeMap; diff --git a/tests/debuginfo/reference-debuginfo.rs b/tests/debuginfo/reference-debuginfo.rs index 3889c1f5ba8f..773c3ae4bc36 100644 --- a/tests/debuginfo/reference-debuginfo.rs +++ b/tests/debuginfo/reference-debuginfo.rs @@ -60,50 +60,50 @@ // lldb-command:run // lldb-command:v *bool_ref -// lldbg-check:[...] true +// lldb-check:[...] true // lldb-command:v *int_ref -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:v *i8_ref -// lldbg-check:[...] 'D' +// lldb-check:[...] 'D' // lldb-command:v *i16_ref -// lldbg-check:[...] -16 +// lldb-check:[...] -16 // lldb-command:v *i32_ref -// lldbg-check:[...] -32 +// lldb-check:[...] -32 // lldb-command:v *i64_ref -// lldbg-check:[...] -64 +// lldb-check:[...] -64 // lldb-command:v *uint_ref -// lldbg-check:[...] 1 +// lldb-check:[...] 1 // lldb-command:v *u8_ref -// lldbg-check:[...] 'd' +// lldb-check:[...] 'd' // lldb-command:v *u16_ref -// lldbg-check:[...] 16 +// lldb-check:[...] 16 // lldb-command:v *u32_ref -// lldbg-check:[...] 32 +// lldb-check:[...] 32 // lldb-command:v *u64_ref -// lldbg-check:[...] 64 +// lldb-check:[...] 64 // lldb-command:v *f16_ref -// lldbg-check:[...] 1.5 +// lldb-check:[...] 1.5 // lldb-command:v *f32_ref -// lldbg-check:[...] 2.5 +// lldb-check:[...] 2.5 // lldb-command:v *f64_ref -// lldbg-check:[...] 3.5 +// lldb-check:[...] 3.5 // lldb-command:v *f64_double_ref -// lldbg-check:[...] 3.5 +// lldb-check:[...] 3.5 #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/regression-bad-location-list-67992.rs b/tests/debuginfo/regression-bad-location-list-67992.rs index 6502cce3700f..0ec474b5b5af 100644 --- a/tests/debuginfo/regression-bad-location-list-67992.rs +++ b/tests/debuginfo/regression-bad-location-list-67992.rs @@ -11,7 +11,7 @@ // lldb-command:run // lldb-command:v a -// lldbg-check:(regression_bad_location_list_67992::Foo) [...] +// lldb-check:(regression_bad_location_list_67992::Foo) [...] const ARRAY_SIZE: usize = 1024; diff --git a/tests/debuginfo/self-in-default-method.rs b/tests/debuginfo/self-in-default-method.rs index 8c607d012105..02fc01d96eb3 100644 --- a/tests/debuginfo/self-in-default-method.rs +++ b/tests/debuginfo/self-in-default-method.rs @@ -56,47 +56,47 @@ // STACK BY REF // lldb-command:v *self -// lldbg-check:[...] { x = 100 } +// lldb-check:[...] { x = 100 } // lldb-command:v arg1 -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:v arg2 -// lldbg-check:[...] -2 +// lldb-check:[...] -2 // lldb-command:continue // STACK BY VAL // lldb-command:v self -// lldbg-check:[...] { x = 100 } +// lldb-check:[...] { x = 100 } // lldb-command:v arg1 -// lldbg-check:[...] -3 +// lldb-check:[...] -3 // lldb-command:v arg2 -// lldbg-check:[...] -4 +// lldb-check:[...] -4 // lldb-command:continue // OWNED BY REF // lldb-command:v *self -// lldbg-check:[...] { x = 200 } +// lldb-check:[...] { x = 200 } // lldb-command:v arg1 -// lldbg-check:[...] -5 +// lldb-check:[...] -5 // lldb-command:v arg2 -// lldbg-check:[...] -6 +// lldb-check:[...] -6 // lldb-command:continue // OWNED BY VAL // lldb-command:v self -// lldbg-check:[...] { x = 200 } +// lldb-check:[...] { x = 200 } // lldb-command:v arg1 -// lldbg-check:[...] -7 +// lldb-check:[...] -7 // lldb-command:v arg2 -// lldbg-check:[...] -8 +// lldb-check:[...] -8 // lldb-command:continue // OWNED MOVED // lldb-command:v *self -// lldbg-check:[...] { x = 200 } +// lldb-check:[...] { x = 200 } // lldb-command:v arg1 -// lldbg-check:[...] -9 +// lldb-check:[...] -9 // lldb-command:v arg2 -// lldbg-check:[...] -10 +// lldb-check:[...] -10 // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/self-in-generic-default-method.rs b/tests/debuginfo/self-in-generic-default-method.rs index 71d1f2d52d26..65018e549ee0 100644 --- a/tests/debuginfo/self-in-generic-default-method.rs +++ b/tests/debuginfo/self-in-generic-default-method.rs @@ -56,47 +56,47 @@ // STACK BY REF // lldb-command:v *self -// lldbg-check:[...] { x = 987 } +// lldb-check:[...] { x = 987 } // lldb-command:v arg1 -// lldbg-check:[...] -1 +// lldb-check:[...] -1 // lldb-command:v arg2 -// lldbg-check:[...] 2 +// lldb-check:[...] 2 // lldb-command:continue // STACK BY VAL // lldb-command:v self -// lldbg-check:[...] { x = 987 } +// lldb-check:[...] { x = 987 } // lldb-command:v arg1 -// lldbg-check:[...] -3 +// lldb-check:[...] -3 // lldb-command:v arg2 -// lldbg-check:[...] -4 +// lldb-check:[...] -4 // lldb-command:continue // OWNED BY REF // lldb-command:v *self -// lldbg-check:[...] { x = 879 } +// lldb-check:[...] { x = 879 } // lldb-command:v arg1 -// lldbg-check:[...] -5 +// lldb-check:[...] -5 // lldb-command:v arg2 -// lldbg-check:[...] -6 +// lldb-check:[...] -6 // lldb-command:continue // OWNED BY VAL // lldb-command:v self -// lldbg-check:[...] { x = 879 } +// lldb-check:[...] { x = 879 } // lldb-command:v arg1 -// lldbg-check:[...] -7 +// lldb-check:[...] -7 // lldb-command:v arg2 -// lldbg-check:[...] -8 +// lldb-check:[...] -8 // lldb-command:continue // OWNED MOVED // lldb-command:v *self -// lldbg-check:[...] { x = 879 } +// lldb-check:[...] { x = 879 } // lldb-command:v arg1 -// lldbg-check:[...] -9 +// lldb-check:[...] -9 // lldb-command:v arg2 -// lldbg-check:[...] -10.5 +// lldb-check:[...] -10.5 // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/shadowed-argument.rs b/tests/debuginfo/shadowed-argument.rs index b4da794ef955..3a575b4addfd 100644 --- a/tests/debuginfo/shadowed-argument.rs +++ b/tests/debuginfo/shadowed-argument.rs @@ -28,21 +28,21 @@ // lldb-command:run // lldb-command:v x -// lldbg-check:[...] false +// lldb-check:[...] false // lldb-command:v y -// lldbg-check:[...] true +// lldb-check:[...] true // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 10 +// lldb-check:[...] 10 // lldb-command:v y -// lldbg-check:[...] true +// lldb-check:[...] true // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 10.5 +// lldb-check:[...] 10.5 // lldb-command:v y -// lldbg-check:[...] 20 +// lldb-check:[...] 20 // lldb-command:continue diff --git a/tests/debuginfo/shadowed-variable.rs b/tests/debuginfo/shadowed-variable.rs index cbbad4c2b7cb..752e4c233f12 100644 --- a/tests/debuginfo/shadowed-variable.rs +++ b/tests/debuginfo/shadowed-variable.rs @@ -39,33 +39,33 @@ // lldb-command:run // lldb-command:v x -// lldbg-check:[...] false +// lldb-check:[...] false // lldb-command:v y -// lldbg-check:[...] true +// lldb-check:[...] true // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 10 +// lldb-check:[...] 10 // lldb-command:v y -// lldbg-check:[...] true +// lldb-check:[...] true // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 10.5 +// lldb-check:[...] 10.5 // lldb-command:v y -// lldbg-check:[...] 20 +// lldb-check:[...] 20 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 10.5 +// lldb-check:[...] 10.5 // lldb-command:v y -// lldbg-check:[...] 20 +// lldb-check:[...] 20 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 11.5 +// lldb-check:[...] 11.5 // lldb-command:v y -// lldbg-check:[...] 20 +// lldb-check:[...] 20 // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/simple-lexical-scope.rs b/tests/debuginfo/simple-lexical-scope.rs index 82737b04b644..6008489bd65d 100644 --- a/tests/debuginfo/simple-lexical-scope.rs +++ b/tests/debuginfo/simple-lexical-scope.rs @@ -38,31 +38,31 @@ // lldb-command:run // lldb-command:v x -// lldbg-check:[...] false +// lldb-check:[...] false // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] false +// lldb-check:[...] false // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 10 +// lldb-check:[...] 10 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 10 +// lldb-check:[...] 10 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 10.5 +// lldb-check:[...] 10.5 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] 10 +// lldb-check:[...] 10 // lldb-command:continue // lldb-command:v x -// lldbg-check:[...] false +// lldb-check:[...] false // lldb-command:continue diff --git a/tests/debuginfo/simple-struct.rs b/tests/debuginfo/simple-struct.rs index 9fe4d3c8d3fa..bb6b2b798102 100644 --- a/tests/debuginfo/simple-struct.rs +++ b/tests/debuginfo/simple-struct.rs @@ -65,22 +65,22 @@ // lldb-command:run // lldb-command:v no_padding16 -// lldbg-check:[...] { x = 10000 y = -10001 } +// lldb-check:[...] { x = 10000 y = -10001 } // lldb-command:v no_padding32 -// lldbg-check:[...] { x = -10002 y = -10003.5 z = 10004 } +// lldb-check:[...] { x = -10002 y = -10003.5 z = 10004 } // lldb-command:v no_padding64 -// lldbg-check:[...] { x = -10005.5 y = 10006 z = 10007 } +// lldb-check:[...] { x = -10005.5 y = 10006 z = 10007 } // lldb-command:v no_padding163264 -// lldbg-check:[...] { a = -10008 b = 10009 c = 10010 d = 10011 } +// lldb-check:[...] { a = -10008 b = 10009 c = 10010 d = 10011 } // lldb-command:v internal_padding -// lldbg-check:[...] { x = 10012 y = -10013 } +// lldb-check:[...] { x = 10012 y = -10013 } // lldb-command:v padding_at_end -// lldbg-check:[...] { x = -10014 y = 10015 } +// lldb-check:[...] { x = -10014 y = 10015 } #![allow(unused_variables)] #![allow(dead_code)] diff --git a/tests/debuginfo/simple-tuple.rs b/tests/debuginfo/simple-tuple.rs index f267fc7d8d94..82467ef3bcf2 100644 --- a/tests/debuginfo/simple-tuple.rs +++ b/tests/debuginfo/simple-tuple.rs @@ -61,21 +61,21 @@ // lldb-command:run // lldb-command:v/d noPadding8 -// lldbg-check:[...] { 0 = -100 1 = 100 } +// lldb-check:[...] { 0 = -100 1 = 100 } // lldb-command:v noPadding16 -// lldbg-check:[...] { 0 = 0 1 = 1 2 = 2 } +// lldb-check:[...] { 0 = 0 1 = 1 2 = 2 } // lldb-command:v noPadding32 -// lldbg-check:[...] { 0 = 3 1 = 4.5 2 = 5 } +// lldb-check:[...] { 0 = 3 1 = 4.5 2 = 5 } // lldb-command:v noPadding64 -// lldbg-check:[...] { 0 = 6 1 = 7.5 2 = 8 } +// lldb-check:[...] { 0 = 6 1 = 7.5 2 = 8 } // lldb-command:v internalPadding1 -// lldbg-check:[...] { 0 = 9 1 = 10 } +// lldb-check:[...] { 0 = 9 1 = 10 } // lldb-command:v internalPadding2 -// lldbg-check:[...] { 0 = 11 1 = 12 2 = 13 3 = 14 } +// lldb-check:[...] { 0 = 11 1 = 12 2 = 13 3 = 14 } // lldb-command:v paddingAtEnd -// lldbg-check:[...] { 0 = 15 1 = 16 } +// lldb-check:[...] { 0 = 15 1 = 16 } // === CDB TESTS ================================================================================== diff --git a/tests/debuginfo/static-method-on-struct-and-enum.rs b/tests/debuginfo/static-method-on-struct-and-enum.rs index 5d2932e378df..b487512a52f1 100644 --- a/tests/debuginfo/static-method-on-struct-and-enum.rs +++ b/tests/debuginfo/static-method-on-struct-and-enum.rs @@ -27,18 +27,18 @@ // STRUCT // lldb-command:v arg1 -// lldbg-check:[...] 1 +// lldb-check:[...] 1 // lldb-command:v arg2 -// lldbg-check:[...] 2 +// lldb-check:[...] 2 // lldb-command:continue // ENUM // lldb-command:v arg1 -// lldbg-check:[...] -3 +// lldb-check:[...] -3 // lldb-command:v arg2 -// lldbg-check:[...] 4.5 +// lldb-check:[...] 4.5 // lldb-command:v arg3 -// lldbg-check:[...] 5 +// lldb-check:[...] 5 // lldb-command:continue #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/strings-and-strs.rs b/tests/debuginfo/strings-and-strs.rs index c109b4023009..b7ee3312d131 100644 --- a/tests/debuginfo/strings-and-strs.rs +++ b/tests/debuginfo/strings-and-strs.rs @@ -25,19 +25,19 @@ // === LLDB TESTS ================================================================================== // lldb-command:run // lldb-command:v plain_string -// lldbg-check:(alloc::string::String) plain_string = "Hello" { vec = size=5 { [0] = 'H' [1] = 'e' [2] = 'l' [3] = 'l' [4] = 'o' } } +// lldb-check:(alloc::string::String) plain_string = "Hello" { vec = size=5 { [0] = 'H' [1] = 'e' [2] = 'l' [3] = 'l' [4] = 'o' } } // lldb-command:v plain_str -// lldbg-check:(&str) plain_str = "Hello" { [0] = 'H' [1] = 'e' [2] = 'l' [3] = 'l' [4] = 'o' } +// lldb-check:(&str) plain_str = "Hello" { [0] = 'H' [1] = 'e' [2] = 'l' [3] = 'l' [4] = 'o' } // lldb-command:v str_in_struct -// lldbg-check:((&str, &str)) str_in_tuple = { 0 = "Hello" { [0] = 'H' [1] = 'e' [2] = 'l' [3] = 'l' [4] = 'o' } 1 = "World" { [0] = 'W' [1] = 'o' [2] = 'r' [3] = 'l' [4] = 'd' } } +// lldb-check:((&str, &str)) str_in_tuple = { 0 = "Hello" { [0] = 'H' [1] = 'e' [2] = 'l' [3] = 'l' [4] = 'o' } 1 = "World" { [0] = 'W' [1] = 'o' [2] = 'r' [3] = 'l' [4] = 'd' } } // lldb-command:v str_in_tuple -// lldbg-check:((&str, &str)) str_in_tuple = { 0 = "Hello" { [0] = 'H' [1] = 'e' [2] = 'l' [3] = 'l' [4] = 'o' } 1 = "World" { [0] = 'W' [1] = 'o' [2] = 'r' [3] = 'l' [4] = 'd' } } +// lldb-check:((&str, &str)) str_in_tuple = { 0 = "Hello" { [0] = 'H' [1] = 'e' [2] = 'l' [3] = 'l' [4] = 'o' } 1 = "World" { [0] = 'W' [1] = 'o' [2] = 'r' [3] = 'l' [4] = 'd' } } // lldb-command:v str_in_rc -// lldbg-check:(alloc::rc::Rc<&str, alloc::alloc::Global>) str_in_rc = strong=1, weak=0 { value = "Hello" { [0] = 'H' [1] = 'e' [2] = 'l' [3] = 'l' [4] = 'o' } } +// lldb-check:(alloc::rc::Rc<&str, alloc::alloc::Global>) str_in_rc = strong=1, weak=0 { value = "Hello" { [0] = 'H' [1] = 'e' [2] = 'l' [3] = 'l' [4] = 'o' } } #![allow(unused_variables)] diff --git a/tests/debuginfo/struct-in-struct.rs b/tests/debuginfo/struct-in-struct.rs index 5dde8079f9aa..3cf48470391b 100644 --- a/tests/debuginfo/struct-in-struct.rs +++ b/tests/debuginfo/struct-in-struct.rs @@ -19,28 +19,28 @@ // lldb-command:run // lldb-command:v three_simple_structs -// lldbg-check:[...] { x = { x = 1 } y = { x = 2 } z = { x = 3 } } +// lldb-check:[...] { x = { x = 1 } y = { x = 2 } z = { x = 3 } } // lldb-command:v internal_padding_parent -// lldbg-check:[...] { x = { x = 4 y = 5 } y = { x = 6 y = 7 } z = { x = 8 y = 9 } } +// lldb-check:[...] { x = { x = 4 y = 5 } y = { x = 6 y = 7 } z = { x = 8 y = 9 } } // lldb-command:v padding_at_end_parent -// lldbg-check:[...] { x = { x = 10 y = 11 } y = { x = 12 y = 13 } z = { x = 14 y = 15 } } +// lldb-check:[...] { x = { x = 10 y = 11 } y = { x = 12 y = 13 } z = { x = 14 y = 15 } } // lldb-command:v mixed -// lldbg-check:[...] { x = { x = 16 y = 17 } y = { x = 18 y = 19 } z = { x = 20 } w = 21 } +// lldb-check:[...] { x = { x = 16 y = 17 } y = { x = 18 y = 19 } z = { x = 20 } w = 21 } // lldb-command:v bag -// lldbg-check:[...] { x = { x = 22 } } +// lldb-check:[...] { x = { x = 22 } } // lldb-command:v bag_in_bag -// lldbg-check:[...] { x = { x = { x = 23 } } } +// lldb-check:[...] { x = { x = { x = 23 } } } // lldb-command:v tjo -// lldbg-check:[...] { x = { x = { x = { x = 24 } } } } +// lldb-check:[...] { x = { x = { x = { x = 24 } } } } // lldb-command:v tree -// lldbg-check:[...] { x = { x = 25 } y = { x = { x = 26 y = 27 } y = { x = 28 y = 29 } z = { x = 30 y = 31 } } z = { x = { x = { x = 32 } } } } +// lldb-check:[...] { x = { x = 25 } y = { x = { x = 26 y = 27 } y = { x = 28 y = 29 } z = { x = 30 y = 31 } } z = { x = { x = { x = 32 } } } } #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/struct-namespace.rs b/tests/debuginfo/struct-namespace.rs index aacc1d3825d7..957884191003 100644 --- a/tests/debuginfo/struct-namespace.rs +++ b/tests/debuginfo/struct-namespace.rs @@ -5,14 +5,14 @@ // lldb-command:run // lldb-command:v struct1 -// lldbg-check:(struct_namespace::Struct1)[...] +// lldb-check:(struct_namespace::Struct1)[...] // lldb-command:v struct2 -// lldbg-check:(struct_namespace::Struct2)[...] +// lldb-check:(struct_namespace::Struct2)[...] // lldb-command:v mod1_struct1 -// lldbg-check:(struct_namespace::mod1::Struct1)[...] +// lldb-check:(struct_namespace::mod1::Struct1)[...] // lldb-command:v mod1_struct2 -// lldbg-check:(struct_namespace::mod1::Struct2)[...] +// lldb-check:(struct_namespace::mod1::Struct2)[...] #![allow(unused_variables)] #![allow(dead_code)] diff --git a/tests/debuginfo/struct-style-enum.rs b/tests/debuginfo/struct-style-enum.rs index c2f7fb688ed2..cea9f3def8bc 100644 --- a/tests/debuginfo/struct-style-enum.rs +++ b/tests/debuginfo/struct-style-enum.rs @@ -24,16 +24,16 @@ // lldb-command:run // lldb-command:v case1 -// lldbg-check:(struct_style_enum::Regular) case1 = { value = { a = 0 b = 31868 c = 31868 d = 31868 e = 31868 } $discr$ = 0 } +// lldb-check:(struct_style_enum::Regular) case1 = { value = { a = 0 b = 31868 c = 31868 d = 31868 e = 31868 } $discr$ = 0 } // lldb-command:v case2 -// lldbg-check:(struct_style_enum::Regular) case2 = { value = { a = 0 b = 286331153 c = 286331153 } $discr$ = 1 } +// lldb-check:(struct_style_enum::Regular) case2 = { value = { a = 0 b = 286331153 c = 286331153 } $discr$ = 1 } // lldb-command:v case3 -// lldbg-check:(struct_style_enum::Regular) case3 = { value = { a = 0 b = 6438275382588823897 } $discr$ = 2 } +// lldb-check:(struct_style_enum::Regular) case3 = { value = { a = 0 b = 6438275382588823897 } $discr$ = 2 } // lldb-command:v univariant -// lldbg-check:(struct_style_enum::Univariant) univariant = { value = { a = -1 } } +// lldb-check:(struct_style_enum::Univariant) univariant = { value = { a = -1 } } #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/struct-with-destructor.rs b/tests/debuginfo/struct-with-destructor.rs index 654a574ebb5e..c159824980a2 100644 --- a/tests/debuginfo/struct-with-destructor.rs +++ b/tests/debuginfo/struct-with-destructor.rs @@ -20,16 +20,16 @@ // lldb-command:run // lldb-command:v simple -// lldbg-check:[...] { x = 10 y = 20 } +// lldb-check:[...] { x = 10 y = 20 } // lldb-command:v noDestructor -// lldbg-check:[...] { a = { x = 10 y = 20 } guard = -1 } +// lldb-check:[...] { a = { x = 10 y = 20 } guard = -1 } // lldb-command:v withDestructor -// lldbg-check:[...] { a = { x = 10 y = 20 } guard = -1 } +// lldb-check:[...] { a = { x = 10 y = 20 } guard = -1 } // lldb-command:v nested -// lldbg-check:[...] { a = { a = { x = 7890 y = 9870 } } } +// lldb-check:[...] { a = { a = { x = 7890 y = 9870 } } } #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/tuple-in-tuple.rs b/tests/debuginfo/tuple-in-tuple.rs index 74ccaf14d00b..d4388095ad72 100644 --- a/tests/debuginfo/tuple-in-tuple.rs +++ b/tests/debuginfo/tuple-in-tuple.rs @@ -27,21 +27,21 @@ // lldb-command:run // lldb-command:v no_padding1 -// lldbg-check:[...] { 0 = { 0 = 0 1 = 1 } 1 = 2 2 = 3 } +// lldb-check:[...] { 0 = { 0 = 0 1 = 1 } 1 = 2 2 = 3 } // lldb-command:v no_padding2 -// lldbg-check:[...] { 0 = 4 1 = { 0 = 5 1 = 6 } 2 = 7 } +// lldb-check:[...] { 0 = 4 1 = { 0 = 5 1 = 6 } 2 = 7 } // lldb-command:v no_padding3 -// lldbg-check:[...] { 0 = 8 1 = 9 2 = { 0 = 10 1 = 11 } } +// lldb-check:[...] { 0 = 8 1 = 9 2 = { 0 = 10 1 = 11 } } // lldb-command:v internal_padding1 -// lldbg-check:[...] { 0 = 12 1 = { 0 = 13 1 = 14 } } +// lldb-check:[...] { 0 = 12 1 = { 0 = 13 1 = 14 } } // lldb-command:v internal_padding2 -// lldbg-check:[...] { 0 = 15 1 = { 0 = 16 1 = 17 } } +// lldb-check:[...] { 0 = 15 1 = { 0 = 16 1 = 17 } } // lldb-command:v padding_at_end1 -// lldbg-check:[...] { 0 = 18 1 = { 0 = 19 1 = 20 } } +// lldb-check:[...] { 0 = 18 1 = { 0 = 19 1 = 20 } } // lldb-command:v padding_at_end2 -// lldbg-check:[...] { 0 = { 0 = 21 1 = 22 } 1 = 23 } +// lldb-check:[...] { 0 = { 0 = 21 1 = 22 } 1 = 23 } // === CDB TESTS ================================================================================== diff --git a/tests/debuginfo/tuple-struct.rs b/tests/debuginfo/tuple-struct.rs index f9755a8a0d5b..0110203a7c79 100644 --- a/tests/debuginfo/tuple-struct.rs +++ b/tests/debuginfo/tuple-struct.rs @@ -28,22 +28,22 @@ // lldb-command:run // lldb-command:v no_padding16 -// lldbg-check:[...] { 0 = 10000 1 = -10001 } +// lldb-check:[...] { 0 = 10000 1 = -10001 } // lldb-command:v no_padding32 -// lldbg-check:[...] { 0 = -10002 1 = -10003.5 2 = 10004 } +// lldb-check:[...] { 0 = -10002 1 = -10003.5 2 = 10004 } // lldb-command:v no_padding64 -// lldbg-check:[...] { 0 = -10005.5 1 = 10006 2 = 10007 } +// lldb-check:[...] { 0 = -10005.5 1 = 10006 2 = 10007 } // lldb-command:v no_padding163264 -// lldbg-check:[...] { 0 = -10008 1 = 10009 2 = 10010 3 = 10011 } +// lldb-check:[...] { 0 = -10008 1 = 10009 2 = 10010 3 = 10011 } // lldb-command:v internal_padding -// lldbg-check:[...] { 0 = 10012 1 = -10013 } +// lldb-check:[...] { 0 = 10012 1 = -10013 } // lldb-command:v padding_at_end -// lldbg-check:[...] { 0 = -10014 1 = 10015 } +// lldb-check:[...] { 0 = -10014 1 = 10015 } // This test case mainly makes sure that no field names are generated for tuple structs (as opposed // to all fields having the name ""). Otherwise they are handled the same a normal diff --git a/tests/debuginfo/tuple-style-enum.rs b/tests/debuginfo/tuple-style-enum.rs index efdf8c6970e2..a759ad61c056 100644 --- a/tests/debuginfo/tuple-style-enum.rs +++ b/tests/debuginfo/tuple-style-enum.rs @@ -25,16 +25,16 @@ // lldb-command:run // lldb-command:v case1 -// lldbg-check:(tuple_style_enum::Regular) case1 = { value = { 0 = 0 1 = 31868 2 = 31868 3 = 31868 4 = 31868 } $discr$ = 0 } +// lldb-check:(tuple_style_enum::Regular) case1 = { value = { 0 = 0 1 = 31868 2 = 31868 3 = 31868 4 = 31868 } $discr$ = 0 } // lldb-command:v case2 -// lldbg-check:(tuple_style_enum::Regular) case2 = { value = { 0 = 0 1 = 286331153 2 = 286331153 } $discr$ = 1 } +// lldb-check:(tuple_style_enum::Regular) case2 = { value = { 0 = 0 1 = 286331153 2 = 286331153 } $discr$ = 1 } // lldb-command:v case3 -// lldbg-check:(tuple_style_enum::Regular) case3 = { value = { 0 = 0 1 = 6438275382588823897 } $discr$ = 2 } +// lldb-check:(tuple_style_enum::Regular) case3 = { value = { 0 = 0 1 = 6438275382588823897 } $discr$ = 2 } // lldb-command:v univariant -// lldbg-check:(tuple_style_enum::Univariant) univariant = { value = { 0 = -1 } } +// lldb-check:(tuple_style_enum::Univariant) univariant = { value = { 0 = -1 } } #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/union-smoke.rs b/tests/debuginfo/union-smoke.rs index 73617df10b13..6043240069e3 100644 --- a/tests/debuginfo/union-smoke.rs +++ b/tests/debuginfo/union-smoke.rs @@ -12,10 +12,10 @@ // lldb-command:run // lldb-command:v u -// lldbg-check:[...] { a = { 0 = '\x02' 1 = '\x02' } b = 514 } +// lldb-check:[...] { a = { 0 = '\x02' 1 = '\x02' } b = 514 } -// lldbg-command:print union_smoke::SU -// lldbg-check:[...] { a = { 0 = '\x01' 1 = '\x01' } b = 257 } +// lldb-command:print union_smoke::SU +// lldb-check:[...] { a = { 0 = '\x01' 1 = '\x01' } b = 257 } #![allow(unused)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/unique-enum.rs b/tests/debuginfo/unique-enum.rs index b9ee480c851a..230429278aa5 100644 --- a/tests/debuginfo/unique-enum.rs +++ b/tests/debuginfo/unique-enum.rs @@ -21,13 +21,13 @@ // lldb-command:run // lldb-command:v *the_a -// lldbg-check:(unique_enum::ABC) *the_a = { value = { x = 0 y = 8970181431921507452 } $discr$ = 0 } +// lldb-check:(unique_enum::ABC) *the_a = { value = { x = 0 y = 8970181431921507452 } $discr$ = 0 } // lldb-command:v *the_b -// lldbg-check:(unique_enum::ABC) *the_b = { value = { 0 = 0 1 = 286331153 2 = 286331153 } $discr$ = 1 } +// lldb-check:(unique_enum::ABC) *the_b = { value = { 0 = 0 1 = 286331153 2 = 286331153 } $discr$ = 1 } // lldb-command:v *univariant -// lldbg-check:(unique_enum::Univariant) *univariant = { value = { 0 = 123234 } } +// lldb-check:(unique_enum::Univariant) *univariant = { value = { 0 = 123234 } } #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/var-captured-in-nested-closure.rs b/tests/debuginfo/var-captured-in-nested-closure.rs index 0f544c24b5bc..4e8700015ba6 100644 --- a/tests/debuginfo/var-captured-in-nested-closure.rs +++ b/tests/debuginfo/var-captured-in-nested-closure.rs @@ -38,31 +38,31 @@ // lldb-command:run // lldb-command:v variable -// lldbg-check:[...] 1 +// lldb-check:[...] 1 // lldb-command:v constant -// lldbg-check:[...] 2 +// lldb-check:[...] 2 // lldb-command:v a_struct -// lldbg-check:[...] { a = -3 b = 4.5 c = 5 } +// lldb-check:[...] { a = -3 b = 4.5 c = 5 } // lldb-command:v *struct_ref -// lldbg-check:[...] { a = -3 b = 4.5 c = 5 } +// lldb-check:[...] { a = -3 b = 4.5 c = 5 } // lldb-command:v *owned -// lldbg-check:[...] 6 +// lldb-check:[...] 6 // lldb-command:v closure_local -// lldbg-check:[...] 8 +// lldb-check:[...] 8 // lldb-command:continue // lldb-command:v variable -// lldbg-check:[...] 1 +// lldb-check:[...] 1 // lldb-command:v constant -// lldbg-check:[...] 2 +// lldb-check:[...] 2 // lldb-command:v a_struct -// lldbg-check:[...] { a = -3 b = 4.5 c = 5 } +// lldb-check:[...] { a = -3 b = 4.5 c = 5 } // lldb-command:v *struct_ref -// lldbg-check:[...] { a = -3 b = 4.5 c = 5 } +// lldb-check:[...] { a = -3 b = 4.5 c = 5 } // lldb-command:v *owned -// lldbg-check:[...] 6 +// lldb-check:[...] 6 // lldb-command:v closure_local -// lldbg-check:[...] 8 +// lldb-check:[...] 8 // lldb-command:continue diff --git a/tests/debuginfo/var-captured-in-sendable-closure.rs b/tests/debuginfo/var-captured-in-sendable-closure.rs index 2d9e60744739..cbb09daeb5f7 100644 --- a/tests/debuginfo/var-captured-in-sendable-closure.rs +++ b/tests/debuginfo/var-captured-in-sendable-closure.rs @@ -21,11 +21,11 @@ // lldb-command:run // lldb-command:v constant -// lldbg-check:[...] 1 +// lldb-check:[...] 1 // lldb-command:v a_struct -// lldbg-check:[...] { a = -2 b = 3.5 c = 4 } +// lldb-check:[...] { a = -2 b = 3.5 c = 4 } // lldb-command:v *owned -// lldbg-check:[...] 5 +// lldb-check:[...] 5 #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/var-captured-in-stack-closure.rs b/tests/debuginfo/var-captured-in-stack-closure.rs index d6c4b11b5f2c..0f84ea57b007 100644 --- a/tests/debuginfo/var-captured-in-stack-closure.rs +++ b/tests/debuginfo/var-captured-in-stack-closure.rs @@ -34,28 +34,28 @@ // lldb-command:run // lldb-command:v variable -// lldbg-check:[...] 1 +// lldb-check:[...] 1 // lldb-command:v constant -// lldbg-check:[...] 2 +// lldb-check:[...] 2 // lldb-command:v a_struct -// lldbg-check:[...] { a = -3 b = 4.5 c = 5 } +// lldb-check:[...] { a = -3 b = 4.5 c = 5 } // lldb-command:v *struct_ref -// lldbg-check:[...] { a = -3 b = 4.5 c = 5 } +// lldb-check:[...] { a = -3 b = 4.5 c = 5 } // lldb-command:v *owned -// lldbg-check:[...] 6 +// lldb-check:[...] 6 // lldb-command:continue // lldb-command:v variable -// lldbg-check:[...] 2 +// lldb-check:[...] 2 // lldb-command:v constant -// lldbg-check:[...] 2 +// lldb-check:[...] 2 // lldb-command:v a_struct -// lldbg-check:[...] { a = -3 b = 4.5 c = 5 } +// lldb-check:[...] { a = -3 b = 4.5 c = 5 } // lldb-command:v *struct_ref -// lldbg-check:[...] { a = -3 b = 4.5 c = 5 } +// lldb-check:[...] { a = -3 b = 4.5 c = 5 } // lldb-command:v *owned -// lldbg-check:[...] 6 +// lldb-check:[...] 6 // === CDB TESTS =================================================================================== diff --git a/tests/debuginfo/vec-slices.rs b/tests/debuginfo/vec-slices.rs index 77d7b90ca0b5..2b4d624976ab 100644 --- a/tests/debuginfo/vec-slices.rs +++ b/tests/debuginfo/vec-slices.rs @@ -53,22 +53,22 @@ // lldb-command:run // lldb-command:v empty -// lldbg-check:[...] size=0 +// lldb-check:[...] size=0 // lldb-command:v singleton -// lldbg-check:[...] size=1 { [0] = 1 } +// lldb-check:[...] size=1 { [0] = 1 } // lldb-command:v multiple -// lldbg-check:[...] size=4 { [0] = 2 [1] = 3 [2] = 4 [3] = 5 } +// lldb-check:[...] size=4 { [0] = 2 [1] = 3 [2] = 4 [3] = 5 } // lldb-command:v slice_of_slice -// lldbg-check:[...] size=2 { [0] = 3 [1] = 4 } +// lldb-check:[...] size=2 { [0] = 3 [1] = 4 } // lldb-command:v padded_tuple -// lldbg-check:[...] size=2 { [0] = { 0 = 6 1 = 7 } [1] = { 0 = 8 1 = 9 } } +// lldb-check:[...] size=2 { [0] = { 0 = 6 1 = 7 } [1] = { 0 = 8 1 = 9 } } // lldb-command:v padded_struct -// lldbg-check:[...] size=2 { [0] = { x = 10 y = 11 z = 12 } [1] = { x = 13 y = 14 z = 15 } } +// lldb-check:[...] size=2 { [0] = { x = 10 y = 11 z = 12 } [1] = { x = 13 y = 14 z = 15 } } #![allow(dead_code, unused_variables)] #![feature(omit_gdb_pretty_printer_section)] diff --git a/tests/debuginfo/vec.rs b/tests/debuginfo/vec.rs index 3bb84d485730..1093e38d8780 100644 --- a/tests/debuginfo/vec.rs +++ b/tests/debuginfo/vec.rs @@ -13,7 +13,7 @@ // lldb-command:run // lldb-command:v a -// lldbg-check:[...] { [0] = 1 [1] = 2 [2] = 3 } +// lldb-check:[...] { [0] = 1 [1] = 2 [2] = 3 } #![allow(unused_variables)] #![feature(omit_gdb_pretty_printer_section)] From 32185decd6875d5a86374043c7cfa77682b98ba3 Mon Sep 17 00:00:00 2001 From: RayMuir Date: Fri, 15 Mar 2024 14:21:29 +0000 Subject: [PATCH 68/79] Added "copy" to Debug fmt for copy operands --- compiler/rustc_middle/src/mir/pretty.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/rustc_middle/src/mir/pretty.rs b/compiler/rustc_middle/src/mir/pretty.rs index 5dd0e69cf1fe..76a25e45cded 100644 --- a/compiler/rustc_middle/src/mir/pretty.rs +++ b/compiler/rustc_middle/src/mir/pretty.rs @@ -1159,7 +1159,7 @@ impl<'tcx> Debug for Operand<'tcx> { use self::Operand::*; match *self { Constant(ref a) => write!(fmt, "{a:?}"), - Copy(ref place) => write!(fmt, "{place:?}"), + Copy(ref place) => write!(fmt, "copy {place:?}"), Move(ref place) => write!(fmt, "move {place:?}"), } } From b2dae987f8d0118be944434f0504f5fefd8737c4 Mon Sep 17 00:00:00 2001 From: Ben Kimock Date: Sun, 18 Aug 2024 17:41:01 -0400 Subject: [PATCH 69/79] Fixup tests --- tests/debuginfo/associated-types.rs | 4 ++-- tests/debuginfo/generic-method-on-generic-struct.rs | 4 ++-- tests/debuginfo/generic-struct.rs | 8 ++++---- tests/debuginfo/method-on-generic-struct.rs | 10 +++++----- 4 files changed, 13 insertions(+), 13 deletions(-) diff --git a/tests/debuginfo/associated-types.rs b/tests/debuginfo/associated-types.rs index 95e742104729..b20bd5209368 100644 --- a/tests/debuginfo/associated-types.rs +++ b/tests/debuginfo/associated-types.rs @@ -37,7 +37,7 @@ // lldb-command:run // lldb-command:v arg -// lldb-check:[...] { b = -1, b1 = 0 } +// lldb-check:[...] { b = -1 b1 = 0 } // lldb-command:continue // lldb-command:v inferred @@ -51,7 +51,7 @@ // lldb-command:continue // lldb-command:v arg -// lldb-check:[...] (4, 5) +// lldb-check:[...] { 0 = 4 1 = 5 } // lldb-command:continue // lldb-command:v a diff --git a/tests/debuginfo/generic-method-on-generic-struct.rs b/tests/debuginfo/generic-method-on-generic-struct.rs index a391fbf08265..9c587ca2839b 100644 --- a/tests/debuginfo/generic-method-on-generic-struct.rs +++ b/tests/debuginfo/generic-method-on-generic-struct.rs @@ -56,7 +56,7 @@ // STACK BY REF // lldb-command:v *self -// lldb-check:[...] { x = { 0 = 8888, 1 = -8888 } } +// lldb-check:[...] { x = { 0 = 8888 1 = -8888 } } // lldb-command:v arg1 // lldb-check:[...] -1 // lldb-command:v arg2 @@ -65,7 +65,7 @@ // STACK BY VAL // lldb-command:v self -// lldb-check:[...] { x = { 0 = 8888, 1 = -8888 } } +// lldb-check:[...] { x = { 0 = 8888 1 = -8888 } } // lldb-command:v arg1 // lldb-check:[...] -3 // lldb-command:v arg2 diff --git a/tests/debuginfo/generic-struct.rs b/tests/debuginfo/generic-struct.rs index 09160bc3ba03..f26d823d4f2e 100644 --- a/tests/debuginfo/generic-struct.rs +++ b/tests/debuginfo/generic-struct.rs @@ -18,14 +18,14 @@ // lldb-command:run // lldb-command:v int_int -// lldb-check:[...] AGenericStruct { key: 0, value: 1 } +// lldb-check:[...]AGenericStruct) int_int = { key = 0 value = 1 } // lldb-command:v int_float -// lldb-check:[...] AGenericStruct { key: 2, value: 3.5 } +// lldb-check:[...]AGenericStruct) int_float = { key = 2 value = 3.5 } // lldb-command:v float_int -// lldb-check:[...] AGenericStruct { key: 4.5, value: 5 } +// lldb-check:[...]AGenericStruct) float_int = { key = 4.5 value = 5 } // lldb-command:v float_int_float -// lldb-check:[...] AGenericStruct> { key: 6.5, value: AGenericStruct { key: 7, value: 8.5 } } +// lldb-check:[...]AGenericStruct >) float_int_float = { key = 6.5 value = { key = 7 value = 8.5 } } // === CDB TESTS =================================================================================== diff --git a/tests/debuginfo/method-on-generic-struct.rs b/tests/debuginfo/method-on-generic-struct.rs index 23617d46e831..1e6c9d66178a 100644 --- a/tests/debuginfo/method-on-generic-struct.rs +++ b/tests/debuginfo/method-on-generic-struct.rs @@ -56,7 +56,7 @@ // STACK BY REF // lldb-command:v *self -// lldb-check:[...] Struct<(u32, i32)> { x: (8888, -8888) } +// lldb-check:[...]Struct<(u32, i32)>) *self = { x = { 0 = 8888 1 = -8888 } } // lldb-command:v arg1 // lldb-check:[...] -1 // lldb-command:v arg2 @@ -65,7 +65,7 @@ // STACK BY VAL // lldb-command:v self -// lldb-check:[...] Struct<(u32, i32)> { x: (8888, -8888) } +// lldb-check:[...]Struct<(u32, i32)>) self = { x = { 0 = 8888 1 = -8888 } } // lldb-command:v arg1 // lldb-check:[...] -3 // lldb-command:v arg2 @@ -74,7 +74,7 @@ // OWNED BY REF // lldb-command:v *self -// lldb-check:[...] Struct { x: 1234.5 } +// lldb-check:[...]Struct) *self = { x = 1234.5 } // lldb-command:v arg1 // lldb-check:[...] -5 // lldb-command:v arg2 @@ -83,7 +83,7 @@ // OWNED BY VAL // lldb-command:v self -// lldb-check:[...] Struct { x: 1234.5 } +// lldb-check:[...]Struct) self = { x = 1234.5 } // lldb-command:v arg1 // lldb-check:[...] -7 // lldb-command:v arg2 @@ -92,7 +92,7 @@ // OWNED MOVED // lldb-command:v *self -// lldb-check:[...] Struct { x: 1234.5 } +// lldb-check:[...]Struct) *self = { x = 1234.5 } // lldb-command:v arg1 // lldb-check:[...] -9 // lldb-command:v arg2 From 5fe70afc8c6372018da586f3a9068ac593eb80b4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= Date: Sun, 18 Aug 2024 12:50:01 +0200 Subject: [PATCH 70/79] crashes: more tests --- tests/crashes/129150.rs | 7 +++++++ tests/crashes/129166.rs | 7 +++++++ tests/crashes/129205.rs | 5 +++++ tests/crashes/129209.rs | 11 +++++++++++ tests/crashes/129214.rs | 30 ++++++++++++++++++++++++++++++ tests/crashes/129216.rs | 12 ++++++++++++ tests/crashes/129219.rs | 26 ++++++++++++++++++++++++++ 7 files changed, 98 insertions(+) create mode 100644 tests/crashes/129150.rs create mode 100644 tests/crashes/129166.rs create mode 100644 tests/crashes/129205.rs create mode 100644 tests/crashes/129209.rs create mode 100644 tests/crashes/129214.rs create mode 100644 tests/crashes/129216.rs create mode 100644 tests/crashes/129219.rs diff --git a/tests/crashes/129150.rs b/tests/crashes/129150.rs new file mode 100644 index 000000000000..9f8c2ba17393 --- /dev/null +++ b/tests/crashes/129150.rs @@ -0,0 +1,7 @@ +//@ known-bug: rust-lang/rust#129150 +//@ only-x86_64 +use std::arch::x86_64::_mm_blend_ps; + +pub fn main() { + _mm_blend_ps(1, 2, &const {} ); +} diff --git a/tests/crashes/129166.rs b/tests/crashes/129166.rs new file mode 100644 index 000000000000..d3635d410db5 --- /dev/null +++ b/tests/crashes/129166.rs @@ -0,0 +1,7 @@ +//@ known-bug: rust-lang/rust#129166 + +fn main() { + #[cfg_eval] + #[cfg] + 0 +} diff --git a/tests/crashes/129205.rs b/tests/crashes/129205.rs new file mode 100644 index 000000000000..f328fca247ac --- /dev/null +++ b/tests/crashes/129205.rs @@ -0,0 +1,5 @@ +//@ known-bug: rust-lang/rust#129205 + +fn x() { + T::try_from(); +} diff --git a/tests/crashes/129209.rs b/tests/crashes/129209.rs new file mode 100644 index 000000000000..249fa41552eb --- /dev/null +++ b/tests/crashes/129209.rs @@ -0,0 +1,11 @@ +//@ known-bug: rust-lang/rust#129209 + +impl< + const N: usize = { + static || { + Foo([0; X]); + } + }, + > PartialEq for True +{ +} diff --git a/tests/crashes/129214.rs b/tests/crashes/129214.rs new file mode 100644 index 000000000000..e14b9f379d62 --- /dev/null +++ b/tests/crashes/129214.rs @@ -0,0 +1,30 @@ +//@ known-bug: rust-lang/rust#129214 +//@ compile-flags: -Zvalidate-mir -Copt-level=3 --crate-type=lib + +trait to_str {} + +trait map { + fn map(&self, f: F) -> Vec + where + F: FnMut(&Box) -> U; +} +impl map for Vec { + fn map(&self, mut f: F) -> Vec + where + F: FnMut(&T) -> U, + { + let mut r = Vec::new(); + for i in self { + r.push(f(i)); + } + r + } +} + +fn foo>(x: T) -> Vec { + x.map(|_e| "hi".to_string()) +} + +pub fn main() { + assert_eq!(foo(vec![1]), ["hi".to_string()]); +} diff --git a/tests/crashes/129216.rs b/tests/crashes/129216.rs new file mode 100644 index 000000000000..0ad6bc5c71ba --- /dev/null +++ b/tests/crashes/129216.rs @@ -0,0 +1,12 @@ +//@ known-bug: rust-lang/rust#129216 +//@ only-linux + +trait Mirror { + type Assoc; +} + +struct Foo; + +fn main() { + ::Assoc::new(); +} diff --git a/tests/crashes/129219.rs b/tests/crashes/129219.rs new file mode 100644 index 000000000000..effbfcd8b8e4 --- /dev/null +++ b/tests/crashes/129219.rs @@ -0,0 +1,26 @@ +//@ known-bug: rust-lang/rust#129219 +//@ compile-flags: -Zmir-opt-level=5 -Zvalidate-mir --edition=2018 + +use core::marker::Unsize; + +pub trait CastTo: Unsize {} + +impl CastTo for U {} + +impl Cast for T {} +pub trait Cast { + fn cast(&self) -> &T + where + Self: CastTo, + { + self + } +} + +pub trait Foo {} +impl Foo for [i32; 0] {} + +fn main() { + let x: &dyn Foo = &[]; + let x = x.cast::<[i32]>(); +} From 249a36ffbd577fc76153b7ad4cafd33607ee4ddc Mon Sep 17 00:00:00 2001 From: Scott McMurray Date: Sun, 18 Aug 2024 15:51:53 -0700 Subject: [PATCH 71/79] Update mir-opt filechecks --- tests/mir-opt/array_index_is_temporary.rs | 2 +- tests/mir-opt/box_expr.rs | 2 +- .../mir-opt/building/match/sort_candidates.rs | 2 +- tests/mir-opt/building/while_storage.rs | 4 +- tests/mir-opt/const_prop/address_of_pair.rs | 4 +- .../bad_op_unsafe_oob_for_slices.rs | 2 +- tests/mir-opt/const_prop/boxes.rs | 4 +- tests/mir-opt/const_prop/indirect_mutation.rs | 4 +- tests/mir-opt/const_prop/mutable_variable.rs | 2 +- .../const_prop/mutable_variable_aggregate.rs | 2 +- .../mutable_variable_aggregate_mut_ref.rs | 2 +- ...mutable_variable_aggregate_partial_read.rs | 2 +- .../const_prop/mutable_variable_no_prop.rs | 4 +- .../mutable_variable_unprop_assign.rs | 6 +- .../overwrite_with_const_with_params.rs | 2 +- .../const_prop/pointer_expose_provenance.rs | 2 +- tests/mir-opt/const_prop/slice_len.rs | 2 +- tests/mir-opt/copy-prop/borrowed_local.rs | 16 +- .../dataflow-const-prop/array_index.rs | 2 +- tests/mir-opt/dataflow-const-prop/enum.rs | 10 +- .../dataflow-const-prop/large_array_index.rs | 2 +- .../dataflow-const-prop/ref_without_sb.rs | 2 +- tests/mir-opt/dataflow-const-prop/repeat.rs | 4 +- .../dataflow-const-prop/sibling_ptr.rs | 2 +- .../mir-opt/dataflow-const-prop/slice_len.rs | 6 +- tests/mir-opt/dataflow-const-prop/struct.rs | 16 +- .../dead-store-elimination/call_arg_copy.rs | 4 +- .../mir-opt/dest-prop/copy_propagation_arg.rs | 4 +- tests/mir-opt/dest-prop/dead_stores_79191.rs | 2 +- tests/mir-opt/dest-prop/dead_stores_better.rs | 2 +- tests/mir-opt/dest-prop/simple.rs | 4 +- tests/mir-opt/early_otherwise_branch.rs | 4 +- .../early_otherwise_branch_3_element_tuple.rs | 2 +- tests/mir-opt/gvn.rs | 366 +++++++++--------- tests/mir-opt/gvn_copy_moves.rs | 6 +- tests/mir-opt/instsimplify/casts.rs | 4 +- tests/mir-opt/instsimplify/ref_of_deref.rs | 8 +- tests/mir-opt/instsimplify/ub_check.rs | 2 +- tests/mir-opt/jump_threading.rs | 24 +- tests/mir-opt/lower_array_len.rs | 4 +- tests/mir-opt/lower_intrinsics.rs | 4 +- tests/mir-opt/pre-codegen/slice_index.rs | 20 +- tests/mir-opt/reference_prop.rs | 114 +++--- tests/mir-opt/simplify_dead_blocks.rs | 4 +- tests/mir-opt/sroa/structs.rs | 26 +- 45 files changed, 356 insertions(+), 356 deletions(-) diff --git a/tests/mir-opt/array_index_is_temporary.rs b/tests/mir-opt/array_index_is_temporary.rs index 771fb3771b5c..cda9e86b3e66 100644 --- a/tests/mir-opt/array_index_is_temporary.rs +++ b/tests/mir-opt/array_index_is_temporary.rs @@ -15,7 +15,7 @@ fn main() { // CHECK: debug x => [[x:_.*]]; // CHECK: debug y => [[y:_.*]]; // CHECK: [[y]] = const 1_usize; - // CHECK: [[tmp:_.*]] = [[y]]; + // CHECK: [[tmp:_.*]] = copy [[y]]; // CHECK: [[x]][[[tmp]]] = let mut x = [42, 43, 44]; let mut y = 1; diff --git a/tests/mir-opt/box_expr.rs b/tests/mir-opt/box_expr.rs index a2d3ab94db65..41cd4ca57bfe 100644 --- a/tests/mir-opt/box_expr.rs +++ b/tests/mir-opt/box_expr.rs @@ -7,7 +7,7 @@ fn main() { // CHECK-LABEL: fn main( // CHECK: [[box:_.*]] = ShallowInitBox( - // CHECK: [[ptr:_.*]] = ((([[box]].0: std::ptr::Unique).0: std::ptr::NonNull).0: *const S); + // CHECK: [[ptr:_.*]] = copy ((([[box]].0: std::ptr::Unique).0: std::ptr::NonNull).0: *const S); // CHECK: (*[[ptr]]) = S::new() -> [return: [[ret:bb.*]], unwind: [[unwind:bb.*]]]; // CHECK: [[ret]]: { // CHECK: [[box2:_.*]] = move [[box]]; diff --git a/tests/mir-opt/building/match/sort_candidates.rs b/tests/mir-opt/building/match/sort_candidates.rs index 593a975a7a47..d7dd82791ffa 100644 --- a/tests/mir-opt/building/match/sort_candidates.rs +++ b/tests/mir-opt/building/match/sort_candidates.rs @@ -25,7 +25,7 @@ fn disjoint_ranges(x: i32, b: bool) -> u32 { // CHECK-LABEL: fn disjoint_ranges( // CHECK: debug b => _2; // CHECK: bb0: { - // CHECK: switchInt(_2) -> [0: [[jump:bb.*]], otherwise: {{bb.*}}]; + // CHECK: switchInt(copy _2) -> [0: [[jump:bb.*]], otherwise: {{bb.*}}]; // CHECK: [[jump]]: { // CHECK-NEXT: _0 = const 3_u32; // CHECK-NEXT: return; diff --git a/tests/mir-opt/building/while_storage.rs b/tests/mir-opt/building/while_storage.rs index 83095316f005..cd226eb0c1e2 100644 --- a/tests/mir-opt/building/while_storage.rs +++ b/tests/mir-opt/building/while_storage.rs @@ -15,7 +15,7 @@ fn while_loop(c: bool) { // CHECK: bb1: { // CHECK-NEXT: StorageLive(_3); // CHECK-NEXT: StorageLive(_2); - // CHECK-NEXT: _2 = _1; + // CHECK-NEXT: _2 = copy _1; // CHECK-NEXT: _3 = get_bool(move _2) -> [return: bb2, unwind // CHECK: bb2: { // CHECK-NEXT: switchInt(move _3) -> [0: bb3, otherwise: bb4]; @@ -29,7 +29,7 @@ fn while_loop(c: bool) { // CHECK-NEXT: StorageDead(_2); // CHECK-NEXT: StorageLive(_5); // CHECK-NEXT: StorageLive(_4); - // CHECK-NEXT: _4 = _1; + // CHECK-NEXT: _4 = copy _1; // CHECK-NEXT: _5 = get_bool(move _4) -> [return: bb5, unwind // CHECK: bb5: { // CHECK-NEXT: switchInt(move _5) -> [0: bb6, otherwise: bb7]; diff --git a/tests/mir-opt/const_prop/address_of_pair.rs b/tests/mir-opt/const_prop/address_of_pair.rs index 9acaaa0ccaf9..df1ab229d6e3 100644 --- a/tests/mir-opt/const_prop/address_of_pair.rs +++ b/tests/mir-opt/const_prop/address_of_pair.rs @@ -10,13 +10,13 @@ pub fn fn0() -> bool { // CHECK: (*[[ptr]]) = const true; // CHECK-NOT: = const false; // CHECK-NOT: = const true; - // CHECK: [[tmp:_.*]] = ([[pair]].1: bool); + // CHECK: [[tmp:_.*]] = copy ([[pair]].1: bool); // CHECK-NOT: = const false; // CHECK-NOT: = const true; // CHECK: [[ret]] = Not(move [[tmp]]); // CHECK-NOT: = const false; // CHECK-NOT: = const true; - // CHECK: _0 = [[ret]]; + // CHECK: _0 = copy [[ret]]; let mut pair = (1, false); let ptr = core::ptr::addr_of_mut!(pair.1); pair = (1, false); diff --git a/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.rs b/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.rs index 0f8d278535dc..139d0fa2e0f1 100644 --- a/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.rs +++ b/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.rs @@ -8,7 +8,7 @@ fn main() { // CHECK-LABEL: fn main( // CHECK: debug a => [[a:_.*]]; // CHECK: debug _b => [[b:_.*]]; - // CHECK: [[b]] = (*[[a]])[3 of 4]; + // CHECK: [[b]] = copy (*[[a]])[3 of 4]; let a: *const [_] = &[1, 2, 3]; unsafe { let _b = (*a)[3]; diff --git a/tests/mir-opt/const_prop/boxes.rs b/tests/mir-opt/const_prop/boxes.rs index 7813352261e5..f04db260e27f 100644 --- a/tests/mir-opt/const_prop/boxes.rs +++ b/tests/mir-opt/const_prop/boxes.rs @@ -11,8 +11,8 @@ fn main() { // CHECK-LABEL: fn main( // CHECK: debug x => [[x:_.*]]; // CHECK: (*{{_.*}}) = const 42_i32; - // CHECK: [[tmp:_.*]] = (*{{_.*}}); - // CHECK: [[x]] = [[tmp]]; + // CHECK: [[tmp:_.*]] = copy (*{{_.*}}); + // CHECK: [[x]] = copy [[tmp]]; let x = *(#[rustc_box] Box::new(42)) + 0; diff --git a/tests/mir-opt/const_prop/indirect_mutation.rs b/tests/mir-opt/const_prop/indirect_mutation.rs index 32ff8f142b1e..0a4c455c76ef 100644 --- a/tests/mir-opt/const_prop/indirect_mutation.rs +++ b/tests/mir-opt/const_prop/indirect_mutation.rs @@ -10,7 +10,7 @@ fn foo() { // CHECK: _1 = const (1_i32,); // CHECK: _2 = &mut (_1.0: i32); // CHECK: (*_2) = const 5_i32; - // CHECK: _4 = (_1.0: i32); + // CHECK: _4 = copy (_1.0: i32); // CHECK: _3 = Eq(move _4, const 5_i32); let mut u = (1,); @@ -25,7 +25,7 @@ fn bar() { // CHECK: debug y => _4; // CHECK: _3 = &raw mut (_1.0: i32); // CHECK: (*_3) = const 5_i32; - // CHECK: _5 = (_1.0: i32); + // CHECK: _5 = copy (_1.0: i32); // CHECK: _4 = Eq(move _5, const 5_i32); let mut v = (1,); diff --git a/tests/mir-opt/const_prop/mutable_variable.rs b/tests/mir-opt/const_prop/mutable_variable.rs index 9698fba6a11a..3aa1b1bcd218 100644 --- a/tests/mir-opt/const_prop/mutable_variable.rs +++ b/tests/mir-opt/const_prop/mutable_variable.rs @@ -7,7 +7,7 @@ fn main() { // CHECK: debug y => [[y:_.*]]; // CHECK: [[x]] = const 42_i32; // CHECK: [[x]] = const 99_i32; - // CHECK: [[y]] = [[x]]; + // CHECK: [[y]] = copy [[x]]; let mut x = 42; x = 99; let y = x; diff --git a/tests/mir-opt/const_prop/mutable_variable_aggregate.rs b/tests/mir-opt/const_prop/mutable_variable_aggregate.rs index 80cd75215c1b..bb8bf7f71646 100644 --- a/tests/mir-opt/const_prop/mutable_variable_aggregate.rs +++ b/tests/mir-opt/const_prop/mutable_variable_aggregate.rs @@ -8,7 +8,7 @@ fn main() { // CHECK: debug y => [[y:_.*]]; // CHECK: [[x]] = const (42_i32, 43_i32); // CHECK: ([[x]].1: i32) = const 99_i32; - // CHECK: [[y]] = [[x]]; + // CHECK: [[y]] = copy [[x]]; let mut x = (42, 43); x.1 = 99; let y = x; diff --git a/tests/mir-opt/const_prop/mutable_variable_aggregate_mut_ref.rs b/tests/mir-opt/const_prop/mutable_variable_aggregate_mut_ref.rs index 856afd53ab46..332cac96f75d 100644 --- a/tests/mir-opt/const_prop/mutable_variable_aggregate_mut_ref.rs +++ b/tests/mir-opt/const_prop/mutable_variable_aggregate_mut_ref.rs @@ -10,7 +10,7 @@ fn main() { // CHECK: [[x]] = const (42_i32, 43_i32); // CHECK: [[z]] = &mut [[x]]; // CHECK: ((*[[z]]).1: i32) = const 99_i32; - // CHECK: [[y]] = [[x]]; + // CHECK: [[y]] = copy [[x]]; let mut x = (42, 43); let z = &mut x; z.1 = 99; diff --git a/tests/mir-opt/const_prop/mutable_variable_aggregate_partial_read.rs b/tests/mir-opt/const_prop/mutable_variable_aggregate_partial_read.rs index 6f99e6be246f..e27437a1c754 100644 --- a/tests/mir-opt/const_prop/mutable_variable_aggregate_partial_read.rs +++ b/tests/mir-opt/const_prop/mutable_variable_aggregate_partial_read.rs @@ -9,7 +9,7 @@ fn main() { // CHECK: [[x]] = foo() // CHECK: ([[x]].1: i32) = const 99_i32; // CHECK: ([[x]].0: i32) = const 42_i32; - // CHECK: [[y]] = ([[x]].1: i32); + // CHECK: [[y]] = copy ([[x]].1: i32); let mut x: (i32, i32) = foo(); x.1 = 99; x.0 = 42; diff --git a/tests/mir-opt/const_prop/mutable_variable_no_prop.rs b/tests/mir-opt/const_prop/mutable_variable_no_prop.rs index 8289832f81ea..66af5bf1d5d4 100644 --- a/tests/mir-opt/const_prop/mutable_variable_no_prop.rs +++ b/tests/mir-opt/const_prop/mutable_variable_no_prop.rs @@ -9,9 +9,9 @@ fn main() { // CHECK: debug x => [[x:_.*]]; // CHECK: debug y => [[y:_.*]]; // CHECK: [[x]] = const 42_u32; - // CHECK: [[tmp:_.*]] = (*{{_.*}}); + // CHECK: [[tmp:_.*]] = copy (*{{_.*}}); // CHECK: [[x]] = move [[tmp]]; - // CHECK: [[y]] = [[x]]; + // CHECK: [[y]] = copy [[x]]; let mut x = 42; unsafe { x = STATIC; diff --git a/tests/mir-opt/const_prop/mutable_variable_unprop_assign.rs b/tests/mir-opt/const_prop/mutable_variable_unprop_assign.rs index 2c6cc0db6b21..1f4421331bcc 100644 --- a/tests/mir-opt/const_prop/mutable_variable_unprop_assign.rs +++ b/tests/mir-opt/const_prop/mutable_variable_unprop_assign.rs @@ -11,9 +11,9 @@ fn main() { // CHECK: debug z => [[z:_.*]]; // CHECK: [[a]] = foo() // CHECK: [[x]] = const (1_i32, 2_i32); - // CHECK: ([[x]].1: i32) = [[a]]; - // CHECK: [[y]] = ([[x]].1: i32); - // CHECK: [[z]] = ([[x]].0: i32); + // CHECK: ([[x]].1: i32) = copy [[a]]; + // CHECK: [[y]] = copy ([[x]].1: i32); + // CHECK: [[z]] = copy ([[x]].0: i32); let a = foo(); let mut x: (i32, i32) = (1, 2); x.1 = a; diff --git a/tests/mir-opt/const_prop/overwrite_with_const_with_params.rs b/tests/mir-opt/const_prop/overwrite_with_const_with_params.rs index a43558223fe1..1d8890bf3692 100644 --- a/tests/mir-opt/const_prop/overwrite_with_const_with_params.rs +++ b/tests/mir-opt/const_prop/overwrite_with_const_with_params.rs @@ -15,7 +15,7 @@ fn size_of() -> usize { // CHECK-LABEL: fn size_of( // CHECK: _1 = const 0_usize; // CHECK-NEXT: _1 = const SizeOfConst::::SIZE; - // CHECK-NEXT: _0 = _1; + // CHECK-NEXT: _0 = copy _1; let mut a = 0; a = SizeOfConst::::SIZE; a diff --git a/tests/mir-opt/const_prop/pointer_expose_provenance.rs b/tests/mir-opt/const_prop/pointer_expose_provenance.rs index a76fead98594..bee8a985f8f9 100644 --- a/tests/mir-opt/const_prop/pointer_expose_provenance.rs +++ b/tests/mir-opt/const_prop/pointer_expose_provenance.rs @@ -10,7 +10,7 @@ fn main() { // CHECK: [[ptr:_.*]] = const main::FOO; // CHECK: [[ref:_.*]] = &raw const (*[[ptr]]); // CHECK: [[x:_.*]] = move [[ref]] as usize (PointerExposeProvenance); - // CHECK: = read([[x]]) + // CHECK: = read(copy [[x]]) const FOO: &i32 = &1; let x = FOO as *const i32 as usize; read(x); diff --git a/tests/mir-opt/const_prop/slice_len.rs b/tests/mir-opt/const_prop/slice_len.rs index 3d1b58965ac4..46604cfe1e09 100644 --- a/tests/mir-opt/const_prop/slice_len.rs +++ b/tests/mir-opt/const_prop/slice_len.rs @@ -7,7 +7,7 @@ fn main() { // CHECK-LABEL: fn main( // CHECK: debug a => [[a:_.*]]; - // CHECK: [[slice:_.*]] = {{.*}} as &[u32] (PointerCoercion(Unsize)); + // CHECK: [[slice:_.*]] = copy {{.*}} as &[u32] (PointerCoercion(Unsize)); // CHECK: assert(const true, // CHECK: [[a]] = const 2_u32; let a = (&[1u32, 2, 3] as &[u32])[1]; diff --git a/tests/mir-opt/copy-prop/borrowed_local.rs b/tests/mir-opt/copy-prop/borrowed_local.rs index dd1679513f6c..8db19fbd3775 100644 --- a/tests/mir-opt/copy-prop/borrowed_local.rs +++ b/tests/mir-opt/copy-prop/borrowed_local.rs @@ -21,11 +21,11 @@ fn compare_address() -> bool { // CHECK: bb0: { // CHECK-NEXT: _1 = const 5_u8; // CHECK-NEXT: _2 = &_1; - // CHECK-NEXT: _3 = _1; + // CHECK-NEXT: _3 = copy _1; // CHECK-NEXT: _4 = &_3; - // CHECK-NEXT: _0 = cmp_ref(_2, _4) + // CHECK-NEXT: _0 = cmp_ref(copy _2, copy _4) // CHECK: bb1: { - // CHECK-NEXT: _0 = opaque::(_3) + // CHECK-NEXT: _0 = opaque::(copy _3) mir! { { let a = 5_u8; @@ -51,9 +51,9 @@ fn borrowed(x: T) -> bool { // CHECK-LABEL: fn borrowed( // CHECK: bb0: { // CHECK-NEXT: _3 = &_1; - // CHECK-NEXT: _0 = opaque::<&T>(_3) + // CHECK-NEXT: _0 = opaque::<&T>(copy _3) // CHECK: bb1: { - // CHECK-NEXT: _0 = opaque::(_1) + // CHECK-NEXT: _0 = opaque::(copy _1) mir! { { let a = x; @@ -74,11 +74,11 @@ fn borrowed(x: T) -> bool { fn non_freeze(x: T) -> bool { // CHECK-LABEL: fn non_freeze( // CHECK: bb0: { - // CHECK-NEXT: _2 = _1; + // CHECK-NEXT: _2 = copy _1; // CHECK-NEXT: _3 = &_1; - // CHECK-NEXT: _0 = opaque::<&T>(_3) + // CHECK-NEXT: _0 = opaque::<&T>(copy _3) // CHECK: bb1: { - // CHECK-NEXT: _0 = opaque::(_2) + // CHECK-NEXT: _0 = opaque::(copy _2) mir! { { let a = x; diff --git a/tests/mir-opt/dataflow-const-prop/array_index.rs b/tests/mir-opt/dataflow-const-prop/array_index.rs index daf9c7729c60..e442ef99f79e 100644 --- a/tests/mir-opt/dataflow-const-prop/array_index.rs +++ b/tests/mir-opt/dataflow-const-prop/array_index.rs @@ -16,6 +16,6 @@ fn main() { // CHECK: {{_.*}} = const 4_usize; // CHECK: {{_.*}} = const true; // CHECK: assert(const true - // CHECK: [[x]] = [[array_lit]][2 of 3]; + // CHECK: [[x]] = copy [[array_lit]][2 of 3]; let x: u32 = [0, 1, 2, 3][2]; } diff --git a/tests/mir-opt/dataflow-const-prop/enum.rs b/tests/mir-opt/dataflow-const-prop/enum.rs index 37304e3a270e..207e29e63df9 100644 --- a/tests/mir-opt/dataflow-const-prop/enum.rs +++ b/tests/mir-opt/dataflow-const-prop/enum.rs @@ -73,7 +73,7 @@ fn statics() { static RC: &E = &E::V2(4); // CHECK: [[t:_.*]] = const {alloc5: &&E}; - // CHECK: [[e2]] = (*[[t]]); + // CHECK: [[e2]] = copy (*[[t]]); let e2 = RC; // CHECK: switchInt({{move _.*}}) -> {{.*}} @@ -108,7 +108,7 @@ fn mutate_discriminant() -> u8 { // CHECK: [[a:_.*]] = discriminant({{_.*}}); let a = Discriminant(x); - // CHECK: switchInt([[a]]) -> [0: {{bb.*}}, otherwise: {{bb.*}}]; + // CHECK: switchInt(copy [[a]]) -> [0: {{bb.*}}, otherwise: {{bb.*}}]; match a { 0 => bb1, _ => bad, @@ -143,8 +143,8 @@ fn multiple(x: bool, i: u8) { // discriminant(e) => Top // (e as Some).0 => Top // CHECK: [[x2]] = const 0_u8; - // CHECK: [[some:_.*]] = (({{_.*}} as Some).0: u8) - // CHECK: [[x2]] = [[some]]; + // CHECK: [[some:_.*]] = copy (({{_.*}} as Some).0: u8) + // CHECK: [[x2]] = copy [[some]]; let x2 = match e { Some(i) => i, None => 0, @@ -153,7 +153,7 @@ fn multiple(x: bool, i: u8) { // Therefore, `x2` should be `Top` here, and no replacement shall happen. // CHECK-NOT: [[y]] = const - // CHECK: [[y]] = [[x2]]; + // CHECK: [[y]] = copy [[x2]]; // CHECK-NOT: [[y]] = const let y = x2; } diff --git a/tests/mir-opt/dataflow-const-prop/large_array_index.rs b/tests/mir-opt/dataflow-const-prop/large_array_index.rs index e74fd88d002c..e9f2fa2badf9 100644 --- a/tests/mir-opt/dataflow-const-prop/large_array_index.rs +++ b/tests/mir-opt/dataflow-const-prop/large_array_index.rs @@ -13,6 +13,6 @@ fn main() { // CHECK: {{_.*}} = const 5000_usize; // CHECK: {{_.*}} = const true; // CHECK: assert(const true - // CHECK: [[x]] = [[array_lit]][2 of 3]; + // CHECK: [[x]] = copy [[array_lit]][2 of 3]; let x: u8 = [0_u8; 5000][2]; } diff --git a/tests/mir-opt/dataflow-const-prop/ref_without_sb.rs b/tests/mir-opt/dataflow-const-prop/ref_without_sb.rs index 399de921a590..1c4eb41f35ec 100644 --- a/tests/mir-opt/dataflow-const-prop/ref_without_sb.rs +++ b/tests/mir-opt/dataflow-const-prop/ref_without_sb.rs @@ -24,7 +24,7 @@ fn main() { // This should currently not be propagated. // CHECK-NOT: [[b]] = const - // CHECK: [[b]] = [[a]]; + // CHECK: [[b]] = copy [[a]]; // CHECK-NOT: [[b]] = const let b = a; } diff --git a/tests/mir-opt/dataflow-const-prop/repeat.rs b/tests/mir-opt/dataflow-const-prop/repeat.rs index e32c0d0877de..2067aa3d709e 100644 --- a/tests/mir-opt/dataflow-const-prop/repeat.rs +++ b/tests/mir-opt/dataflow-const-prop/repeat.rs @@ -14,8 +14,8 @@ fn main() { // CHECK: {{_.*}} = const true; // CHECK: assert(const true - // CHECK-NOT: [[t:_.*]] = [[array_lit]][_ - // CHECK: [[t:_.*]] = [[array_lit]][2 of 3]; + // CHECK-NOT: [[t:_.*]] = {{copy|move}} [[array_lit]][_ + // CHECK: [[t:_.*]] = copy [[array_lit]][2 of 3]; // CHECK: [[x]] = Add(move [[t]], const 0_u32); let x: u32 = [42; 8][2] + 0; } diff --git a/tests/mir-opt/dataflow-const-prop/sibling_ptr.rs b/tests/mir-opt/dataflow-const-prop/sibling_ptr.rs index be7f311cdc10..b123f06807d6 100644 --- a/tests/mir-opt/dataflow-const-prop/sibling_ptr.rs +++ b/tests/mir-opt/dataflow-const-prop/sibling_ptr.rs @@ -20,6 +20,6 @@ fn main() { *p.add(1) = 1; } - // CHECK: [[x1]] = ({{_.*}}.1: u8); + // CHECK: [[x1]] = copy ({{_.*}}.1: u8); let x1 = x.1; // should not be propagated } diff --git a/tests/mir-opt/dataflow-const-prop/slice_len.rs b/tests/mir-opt/dataflow-const-prop/slice_len.rs index 64c043cca795..e0e68f9fde54 100644 --- a/tests/mir-opt/dataflow-const-prop/slice_len.rs +++ b/tests/mir-opt/dataflow-const-prop/slice_len.rs @@ -17,7 +17,7 @@ fn main() { // CHECK: {{_.*}} = const true; // CHECK: assert(const true, - // CHECK: [[local]] = (*{{_.*}})[1 of 2]; + // CHECK: [[local]] = copy (*{{_.*}})[1 of 2]; let local = (&[1u32, 2, 3] as &[u32])[1]; // CHECK-NOT: {{_.*}} = Len( @@ -28,7 +28,7 @@ fn main() { // CHECK: {{_.*}} = const true; // CHECK: assert(const true, - // CHECK-NOT: [[constant]] = (*{{_.*}})[_ - // CHECK: [[constant]] = (*{{_.*}})[1 of 2]; + // CHECK-NOT: [[constant]] = {{copy|move}} (*{{_.*}})[_ + // CHECK: [[constant]] = copy (*{{_.*}})[1 of 2]; let constant = SLICE[1]; } diff --git a/tests/mir-opt/dataflow-const-prop/struct.rs b/tests/mir-opt/dataflow-const-prop/struct.rs index 89ad1b870294..44591ffb6de2 100644 --- a/tests/mir-opt/dataflow-const-prop/struct.rs +++ b/tests/mir-opt/dataflow-const-prop/struct.rs @@ -46,15 +46,15 @@ fn main() { const SMALL_VAL: SmallStruct = SmallStruct(4., Some(S(1)), &[]); // CHECK: [[a1]] = const 4f32; - // CHECK: [[b1]] = ({{_.*}}.1: std::option::Option); - // CHECK: [[c1]] = ({{_.*}}.2: &[f32]); + // CHECK: [[b1]] = copy ({{_.*}}.1: std::option::Option); + // CHECK: [[c1]] = copy ({{_.*}}.2: &[f32]); let SmallStruct(a1, b1, c1) = SMALL_VAL; static SMALL_STAT: &SmallStruct = &SmallStruct(9., None, &[13.]); // CHECK: [[a2]] = const 9f32; - // CHECK: [[b2]] = ((*{{_.*}}).1: std::option::Option); - // CHECK: [[c2]] = ((*{{_.*}}).2: &[f32]); + // CHECK: [[b2]] = copy ((*{{_.*}}).1: std::option::Option); + // CHECK: [[c2]] = copy ((*{{_.*}}).2: &[f32]); let SmallStruct(a2, b2, c2) = *SMALL_STAT; // CHECK: [[ss]] = SmallStruct(const 9f32, move {{_.*}}, move {{_.*}}); @@ -63,14 +63,14 @@ fn main() { const BIG_VAL: BigStruct = BigStruct(25., None, &[]); // CHECK: [[a3]] = const 25f32; - // CHECK: [[b3]] = ({{_.*}}.1: std::option::Option); - // CHECK: [[c3]] = ({{_.*}}.2: &[f32]); + // CHECK: [[b3]] = copy ({{_.*}}.1: std::option::Option); + // CHECK: [[c3]] = copy ({{_.*}}.2: &[f32]); let BigStruct(a3, b3, c3) = BIG_VAL; static BIG_STAT: &BigStruct = &BigStruct(82., Some(S(35)), &[45., 72.]); // CHECK: [[a4]] = const 82f32; - // CHECK: [[b4]] = ((*{{_.*}}).1: std::option::Option); - // CHECK: [[c4]] = ((*{{_.*}}).2: &[f32]); + // CHECK: [[b4]] = copy ((*{{_.*}}).1: std::option::Option); + // CHECK: [[c4]] = copy ((*{{_.*}}).2: &[f32]); let BigStruct(a4, b4, c4) = *BIG_STAT; // We arbitrarily limit the size of synthetized values to 4 pointers. diff --git a/tests/mir-opt/dead-store-elimination/call_arg_copy.rs b/tests/mir-opt/dead-store-elimination/call_arg_copy.rs index 2556848ec462..27b5ccdb936d 100644 --- a/tests/mir-opt/dead-store-elimination/call_arg_copy.rs +++ b/tests/mir-opt/dead-store-elimination/call_arg_copy.rs @@ -14,7 +14,7 @@ fn use_both(_: i32, _: i32) {} // EMIT_MIR call_arg_copy.move_simple.DeadStoreElimination-final.diff fn move_simple(x: i32) { // CHECK-LABEL: fn move_simple( - // CHECK: = use_both(_1, move _1) + // CHECK: = use_both(copy _1, move _1) use_both(x, x); } @@ -28,7 +28,7 @@ struct Packed { #[custom_mir(dialect = "analysis")] fn move_packed(packed: Packed) { // CHECK-LABEL: fn move_packed( - // CHECK: = use_both(const 0_i32, (_1.1: i32)) + // CHECK: = use_both(const 0_i32, copy (_1.1: i32)) mir! { { // We have a packed struct, verify that the copy is not turned into a move. diff --git a/tests/mir-opt/dest-prop/copy_propagation_arg.rs b/tests/mir-opt/dest-prop/copy_propagation_arg.rs index 084bd0544c17..ef531f4afa2b 100644 --- a/tests/mir-opt/dest-prop/copy_propagation_arg.rs +++ b/tests/mir-opt/dest-prop/copy_propagation_arg.rs @@ -41,9 +41,9 @@ fn arg_src(mut x: i32) -> i32 { // CHECK-LABEL: fn arg_src( // CHECK: debug x => [[x:_.*]]; // CHECK: debug y => [[y:_.*]]; - // CHECK: [[y]] = [[x]] + // CHECK: [[y]] = copy [[x]] // CHECK: [[x]] = const 123_i32; - // CHECK-NOT: {{_.*}} = [[y]]; + // CHECK-NOT: {{_.*}} = copy [[y]]; let y = x; x = 123; // Don't propagate this assignment to `y` y diff --git a/tests/mir-opt/dest-prop/dead_stores_79191.rs b/tests/mir-opt/dest-prop/dead_stores_79191.rs index 61060e4f8506..d035de5ce076 100644 --- a/tests/mir-opt/dest-prop/dead_stores_79191.rs +++ b/tests/mir-opt/dest-prop/dead_stores_79191.rs @@ -10,7 +10,7 @@ fn f(mut a: usize) -> usize { // CHECK-LABEL: fn f( // CHECK: debug a => [[a:_.*]]; // CHECK: debug b => [[b:_.*]]; - // CHECK: [[b]] = [[a]]; + // CHECK: [[b]] = copy [[a]]; // CHECK: [[a]] = const 5_usize; // CHECK: [[a]] = move [[b]]; // CHECK: id::(move [[a]]) diff --git a/tests/mir-opt/dest-prop/dead_stores_better.rs b/tests/mir-opt/dest-prop/dead_stores_better.rs index d2b9fe057123..d4c297fd97a3 100644 --- a/tests/mir-opt/dest-prop/dead_stores_better.rs +++ b/tests/mir-opt/dest-prop/dead_stores_better.rs @@ -14,7 +14,7 @@ pub fn f(mut a: usize) -> usize { // CHECK-LABEL: fn f( // CHECK: debug a => [[a:_.*]]; // CHECK: debug b => [[b:_.*]]; - // CHECK: [[b]] = [[a]]; + // CHECK: [[b]] = copy [[a]]; // CHECK: [[a]] = const 5_usize; // CHECK: [[a]] = move [[b]]; // CHECK: id::(move [[a]]) diff --git a/tests/mir-opt/dest-prop/simple.rs b/tests/mir-opt/dest-prop/simple.rs index 833d49b8c466..927a9c5b24cd 100644 --- a/tests/mir-opt/dest-prop/simple.rs +++ b/tests/mir-opt/dest-prop/simple.rs @@ -7,9 +7,9 @@ fn nrvo(init: fn(&mut [u8; 1024])) -> [u8; 1024] { // CHECK: debug init => [[init:_.*]]; // CHECK: debug buf => [[buf:_.*]]; // CHECK: [[buf]] = [const 0_u8; 1024]; - // CHECK-NOT: {{_.*}} = [[init]]; + // CHECK-NOT: {{_.*}} = copy [[init]]; // CHECK: move [[init]](move {{_.*}}) - // CHECK: {{_.*}} = [[buf]] + // CHECK: {{_.*}} = copy [[buf]] let mut buf = [0; 1024]; init(&mut buf); buf diff --git a/tests/mir-opt/early_otherwise_branch.rs b/tests/mir-opt/early_otherwise_branch.rs index b047c50df97f..47bd4be295b0 100644 --- a/tests/mir-opt/early_otherwise_branch.rs +++ b/tests/mir-opt/early_otherwise_branch.rs @@ -49,7 +49,7 @@ fn opt3(x: Option2, y: Option2) -> u32 { // CHECK: bb0: { // CHECK: [[LOCAL1:_.*]] = discriminant({{.*}}); // CHECK: [[LOCAL2:_.*]] = discriminant({{.*}}); - // CHECK: [[CMP_LOCAL]] = Ne([[LOCAL1]], move [[LOCAL2]]); + // CHECK: [[CMP_LOCAL]] = Ne(copy [[LOCAL1]], move [[LOCAL2]]); // CHECK: switchInt(move [[CMP_LOCAL]]) -> [ // CHECK-NEXT: } match (x, y) { @@ -67,7 +67,7 @@ fn opt4(x: Option2, y: Option2) -> u32 { // CHECK: bb0: { // CHECK: [[LOCAL1:_.*]] = discriminant({{.*}}); // CHECK: [[LOCAL2:_.*]] = discriminant({{.*}}); - // CHECK: [[CMP_LOCAL]] = Ne([[LOCAL1]], move [[LOCAL2]]); + // CHECK: [[CMP_LOCAL]] = Ne(copy [[LOCAL1]], move [[LOCAL2]]); // CHECK: switchInt(move [[CMP_LOCAL]]) -> [ // CHECK-NEXT: } match (x, y) { diff --git a/tests/mir-opt/early_otherwise_branch_3_element_tuple.rs b/tests/mir-opt/early_otherwise_branch_3_element_tuple.rs index d2a3e1f59ff6..d6b27fbce484 100644 --- a/tests/mir-opt/early_otherwise_branch_3_element_tuple.rs +++ b/tests/mir-opt/early_otherwise_branch_3_element_tuple.rs @@ -32,7 +32,7 @@ fn opt2(x: Option2, y: Option2, z: Option2) -> u32 { // CHECK: bb0: { // CHECK: [[LOCAL1:_.*]] = discriminant({{.*}}); // CHECK: [[LOCAL2:_.*]] = discriminant({{.*}}); - // CHECK: [[CMP_LOCAL]] = Ne([[LOCAL1]], move [[LOCAL2]]); + // CHECK: [[CMP_LOCAL]] = Ne(copy [[LOCAL1]], move [[LOCAL2]]); // CHECK: switchInt(move [[CMP_LOCAL]]) -> [ // CHECK-NEXT: } match (x, y, z) { diff --git a/tests/mir-opt/gvn.rs b/tests/mir-opt/gvn.rs index 430f979fec71..ab1253eadeec 100644 --- a/tests/mir-opt/gvn.rs +++ b/tests/mir-opt/gvn.rs @@ -21,91 +21,91 @@ struct S(T); fn subexpression_elimination(x: u64, y: u64, mut z: u64) { // CHECK-LABEL: fn subexpression_elimination( - // CHECK: [[add:_.*]] = Add(_1, _2); - // CHECK: opaque::([[add]]) + // CHECK: [[add:_.*]] = Add(copy _1, copy _2); + // CHECK: opaque::(copy [[add]]) opaque(x + y); - // CHECK: [[mul:_.*]] = Mul(_1, _2); - // CHECK: opaque::([[mul]]) + // CHECK: [[mul:_.*]] = Mul(copy _1, copy _2); + // CHECK: opaque::(copy [[mul]]) opaque(x * y); - // CHECK: [[sub:_.*]] = Sub(_1, _2); - // CHECK: opaque::([[sub]]) + // CHECK: [[sub:_.*]] = Sub(copy _1, copy _2); + // CHECK: opaque::(copy [[sub]]) opaque(x - y); - // CHECK: [[div:_.*]] = Div(_1, _2); - // CHECK: opaque::([[div]]) + // CHECK: [[div:_.*]] = Div(copy _1, copy _2); + // CHECK: opaque::(copy [[div]]) opaque(x / y); - // CHECK: [[rem:_.*]] = Rem(_1, _2); - // CHECK: opaque::([[rem]]) + // CHECK: [[rem:_.*]] = Rem(copy _1, copy _2); + // CHECK: opaque::(copy [[rem]]) opaque(x % y); - // CHECK: [[and:_.*]] = BitAnd(_1, _2); - // CHECK: opaque::([[and]]) + // CHECK: [[and:_.*]] = BitAnd(copy _1, copy _2); + // CHECK: opaque::(copy [[and]]) opaque(x & y); - // CHECK: [[or:_.*]] = BitOr(_1, _2); - // CHECK: opaque::([[or]]) + // CHECK: [[or:_.*]] = BitOr(copy _1, copy _2); + // CHECK: opaque::(copy [[or]]) opaque(x | y); - // CHECK: [[xor:_.*]] = BitXor(_1, _2); - // CHECK: opaque::([[xor]]) + // CHECK: [[xor:_.*]] = BitXor(copy _1, copy _2); + // CHECK: opaque::(copy [[xor]]) opaque(x ^ y); - // CHECK: [[shl:_.*]] = Shl(_1, _2); - // CHECK: opaque::([[shl]]) + // CHECK: [[shl:_.*]] = Shl(copy _1, copy _2); + // CHECK: opaque::(copy [[shl]]) opaque(x << y); - // CHECK: [[shr:_.*]] = Shr(_1, _2); - // CHECK: opaque::([[shr]]) + // CHECK: [[shr:_.*]] = Shr(copy _1, copy _2); + // CHECK: opaque::(copy [[shr]]) opaque(x >> y); - // CHECK: [[int:_.*]] = _1 as u32 (IntToInt); - // CHECK: opaque::([[int]]) + // CHECK: [[int:_.*]] = copy _1 as u32 (IntToInt); + // CHECK: opaque::(copy [[int]]) opaque(x as u32); - // CHECK: [[float:_.*]] = _1 as f32 (IntToFloat); - // CHECK: opaque::([[float]]) + // CHECK: [[float:_.*]] = copy _1 as f32 (IntToFloat); + // CHECK: opaque::(copy [[float]]) opaque(x as f32); - // CHECK: [[wrap:_.*]] = S::(_1); - // CHECK: opaque::>([[wrap]]) + // CHECK: [[wrap:_.*]] = S::(copy _1); + // CHECK: opaque::>(copy [[wrap]]) opaque(S(x)); - // CHECK: opaque::(_1) + // CHECK: opaque::(copy _1) opaque(S(x).0); // Those are duplicates to substitute somehow. - // CHECK: opaque::([[add]]) + // CHECK: opaque::(copy [[add]]) opaque(x + y); - // CHECK: opaque::([[mul]]) + // CHECK: opaque::(copy [[mul]]) opaque(x * y); - // CHECK: opaque::([[sub]]) + // CHECK: opaque::(copy [[sub]]) opaque(x - y); - // CHECK: opaque::([[div]]) + // CHECK: opaque::(copy [[div]]) opaque(x / y); - // CHECK: opaque::([[rem]]) + // CHECK: opaque::(copy [[rem]]) opaque(x % y); - // CHECK: opaque::([[and]]) + // CHECK: opaque::(copy [[and]]) opaque(x & y); - // CHECK: opaque::([[or]]) + // CHECK: opaque::(copy [[or]]) opaque(x | y); - // CHECK: opaque::([[xor]]) + // CHECK: opaque::(copy [[xor]]) opaque(x ^ y); - // CHECK: opaque::([[shl]]) + // CHECK: opaque::(copy [[shl]]) opaque(x << y); - // CHECK: opaque::([[shr]]) + // CHECK: opaque::(copy [[shr]]) opaque(x >> y); - // CHECK: opaque::([[int]]) + // CHECK: opaque::(copy [[int]]) opaque(x as u32); - // CHECK: opaque::([[float]]) + // CHECK: opaque::(copy [[float]]) opaque(x as f32); - // CHECK: opaque::>([[wrap]]) + // CHECK: opaque::>(copy [[wrap]]) opaque(S(x)); - // CHECK: opaque::(_1) + // CHECK: opaque::(copy _1) opaque(S(x).0); // We can substitute through a complex expression. - // CHECK: [[compound:_.*]] = Sub([[mul]], _2); - // CHECK: opaque::([[compound]]) - // CHECK: opaque::([[compound]]) + // CHECK: [[compound:_.*]] = Sub(copy [[mul]], copy _2); + // CHECK: opaque::(copy [[compound]]) + // CHECK: opaque::(copy [[compound]]) opaque((x * y) - y); opaque((x * y) - y); // We can substitute through an immutable reference too. // CHECK: [[ref:_.*]] = &_3; - // CHECK: [[deref:_.*]] = (*[[ref]]); - // CHECK: [[addref:_.*]] = Add([[deref]], _1); - // CHECK: opaque::([[addref]]) - // CHECK: opaque::([[addref]]) + // CHECK: [[deref:_.*]] = copy (*[[ref]]); + // CHECK: [[addref:_.*]] = Add(copy [[deref]], copy _1); + // CHECK: opaque::(copy [[addref]]) + // CHECK: opaque::(copy [[addref]]) let a = &z; opaque(*a + x); opaque(*a + x); @@ -141,10 +141,10 @@ fn subexpression_elimination(x: u64, y: u64, mut z: u64) { // We can substitute again, but not with the earlier computations. // Important: `e` is not `a`! // CHECK: [[ref2:_.*]] = &_3; - // CHECK: [[deref2:_.*]] = (*[[ref2]]); - // CHECK: [[addref2:_.*]] = Add([[deref2]], _1); - // CHECK: opaque::([[addref2]]) - // CHECK: opaque::([[addref2]]) + // CHECK: [[deref2:_.*]] = copy (*[[ref2]]); + // CHECK: [[addref2:_.*]] = Add(copy [[deref2]], copy _1); + // CHECK: opaque::(copy [[addref2]]) + // CHECK: opaque::(copy [[addref2]]) let e = &z; opaque(*e + x); opaque(*e + x); @@ -152,9 +152,9 @@ fn subexpression_elimination(x: u64, y: u64, mut z: u64) { fn wrap_unwrap(x: T) -> T { // CHECK-LABEL: fn wrap_unwrap( - // CHECK: [[some:_.*]] = Option::::Some(_1); + // CHECK: [[some:_.*]] = Option::::Some(copy _1); // CHECK: switchInt(const 1_isize) - // CHECK: _0 = _1; + // CHECK: _0 = copy _1; match Some(x) { Some(y) => y, None => panic!(), @@ -163,35 +163,35 @@ fn wrap_unwrap(x: T) -> T { fn repeated_index(x: T, idx: usize) { // CHECK-LABEL: fn repeated_index( - // CHECK: [[a:_.*]] = [_1; N]; + // CHECK: [[a:_.*]] = [copy _1; N]; let a = [x; N]; - // CHECK: opaque::(_1) + // CHECK: opaque::(copy _1) opaque(a[0]); - // CHECK: opaque::(_1) + // CHECK: opaque::(copy _1) opaque(a[idx]); } fn unary(x: i64) { // CHECK-LABEL: fn unary( - // CHECK: opaque::(_1) + // CHECK: opaque::(copy _1) opaque(--x); // This is `x`. - // CHECK: [[b:_.*]] = Lt(_1, const 13_i64); - // CHECK: opaque::([[b]]) + // CHECK: [[b:_.*]] = Lt(copy _1, const 13_i64); + // CHECK: opaque::(copy [[b]]) let b = x < 13; opaque(!!b); // This is `b`. // Both lines should test the same thing. - // CHECK: [[c:_.*]] = Ne(_1, const 15_i64); - // CHECK: opaque::([[c]]) - // CHECK: opaque::([[c]]) + // CHECK: [[c:_.*]] = Ne(copy _1, const 15_i64); + // CHECK: opaque::(copy [[c]]) + // CHECK: opaque::(copy [[c]]) opaque(x != 15); opaque(!(x == 15)); // Both lines should test the same thing. - // CHECK: [[d:_.*]] = Eq(_1, const 35_i64); - // CHECK: opaque::([[d]]) - // CHECK: opaque::([[d]]) + // CHECK: [[d:_.*]] = Eq(copy _1, const 35_i64); + // CHECK: opaque::(copy [[d]]) + // CHECK: opaque::(copy [[d]]) opaque(x == 35); opaque(!(x != 35)); } @@ -199,53 +199,53 @@ fn unary(x: i64) { /// Verify symbolic integer arithmetic simplifications. fn arithmetic(x: u64) { // CHECK-LABEL: fn arithmetic( - // CHECK: opaque::(_1) + // CHECK: opaque::(copy _1) opaque(x + 0); - // CHECK: opaque::(_1) + // CHECK: opaque::(copy _1) opaque(x - 0); // CHECK: opaque::(const 0_u64) opaque(x - x); // CHECK: opaque::(const 0_u64) opaque(x * 0); - // CHECK: opaque::(_1) + // CHECK: opaque::(copy _1) opaque(x * 1); // CHECK: assert(!const true, "attempt to divide `{}` by zero", - // CHECK: [[div0:_.*]] = Div(_1, const 0_u64); + // CHECK: [[div0:_.*]] = Div(copy _1, const 0_u64); // CHECK: opaque::(move [[div0]]) opaque(x / 0); - // CHECK: opaque::(_1) + // CHECK: opaque::(copy _1) opaque(x / 1); // CHECK: opaque::(const 0_u64) opaque(0 / x); - // CHECK: [[odiv:_.*]] = Div(const 1_u64, _1); + // CHECK: [[odiv:_.*]] = Div(const 1_u64, copy _1); // CHECK: opaque::(move [[odiv]]) opaque(1 / x); // CHECK: assert(!const true, "attempt to calculate the remainder of `{}` with a divisor of zero" - // CHECK: [[rem0:_.*]] = Rem(_1, const 0_u64); + // CHECK: [[rem0:_.*]] = Rem(copy _1, const 0_u64); // CHECK: opaque::(move [[rem0]]) opaque(x % 0); // CHECK: opaque::(const 0_u64) opaque(x % 1); // CHECK: opaque::(const 0_u64) opaque(0 % x); - // CHECK: [[orem:_.*]] = Rem(const 1_u64, _1); + // CHECK: [[orem:_.*]] = Rem(const 1_u64, copy _1); // CHECK: opaque::(move [[orem]]) opaque(1 % x); // CHECK: opaque::(const 0_u64) opaque(x & 0); - // CHECK: opaque::(_1) + // CHECK: opaque::(copy _1) opaque(x & u64::MAX); - // CHECK: opaque::(_1) + // CHECK: opaque::(copy _1) opaque(x | 0); // CHECK: opaque::(const u64::MAX) opaque(x | u64::MAX); - // CHECK: opaque::(_1) + // CHECK: opaque::(copy _1) opaque(x ^ 0); // CHECK: opaque::(const 0_u64) opaque(x ^ x); - // CHECK: opaque::(_1) + // CHECK: opaque::(copy _1) opaque(x >> 0); - // CHECK: opaque::(_1) + // CHECK: opaque::(copy _1) opaque(x << 0); } @@ -255,10 +255,10 @@ fn comparison(x: u64, y: u64) { opaque(x == x); // CHECK: opaque::(const false) opaque(x != x); - // CHECK: [[eqxy:_.*]] = Eq(_1, _2); + // CHECK: [[eqxy:_.*]] = Eq(copy _1, copy _2); // CHECK: opaque::(move [[eqxy]]) opaque(x == y); - // CHECK: [[nexy:_.*]] = Ne(_1, _2); + // CHECK: [[nexy:_.*]] = Ne(copy _1, copy _2); // CHECK: opaque::(move [[nexy]]) opaque(x != y); } @@ -268,10 +268,10 @@ fn comparison(x: u64, y: u64) { fn arithmetic_checked(x: u64) { // CHECK-LABEL: fn arithmetic_checked( // CHECK: assert(!const false, - // CHECK: opaque::(_1) + // CHECK: opaque::(copy _1) opaque(x + 0); // CHECK: assert(!const false, - // CHECK: opaque::(_1) + // CHECK: opaque::(copy _1) opaque(x - 0); // CHECK: assert(!const false, // CHECK: opaque::(const 0_u64) @@ -280,39 +280,39 @@ fn arithmetic_checked(x: u64) { // CHECK: opaque::(const 0_u64) opaque(x * 0); // CHECK: assert(!const false, - // CHECK: opaque::(_1) + // CHECK: opaque::(copy _1) opaque(x * 1); } /// Verify that we do not apply arithmetic simplifications on floats. fn arithmetic_float(x: f64) { // CHECK-LABEL: fn arithmetic_float( - // CHECK: [[add:_.*]] = Add(_1, const 0f64); + // CHECK: [[add:_.*]] = Add(copy _1, const 0f64); // CHECK: opaque::(move [[add]]) opaque(x + 0.); - // CHECK: [[sub:_.*]] = Sub(_1, const 0f64); + // CHECK: [[sub:_.*]] = Sub(copy _1, const 0f64); // CHECK: opaque::(move [[sub]]) opaque(x - 0.); - // CHECK: [[mul:_.*]] = Mul(_1, const 0f64); + // CHECK: [[mul:_.*]] = Mul(copy _1, const 0f64); // CHECK: opaque::(move [[mul]]) opaque(x * 0.); - // CHECK: [[div0:_.*]] = Div(_1, const 0f64); + // CHECK: [[div0:_.*]] = Div(copy _1, const 0f64); // CHECK: opaque::(move [[div0]]) opaque(x / 0.); - // CHECK: [[zdiv:_.*]] = Div(const 0f64, _1); + // CHECK: [[zdiv:_.*]] = Div(const 0f64, copy _1); // CHECK: opaque::(move [[zdiv]]) opaque(0. / x); - // CHECK: [[rem0:_.*]] = Rem(_1, const 0f64); + // CHECK: [[rem0:_.*]] = Rem(copy _1, const 0f64); // CHECK: opaque::(move [[rem0]]) opaque(x % 0.); - // CHECK: [[zrem:_.*]] = Rem(const 0f64, _1); + // CHECK: [[zrem:_.*]] = Rem(const 0f64, copy _1); // CHECK: opaque::(move [[zrem]]) opaque(0. % x); // Those are not simplifiable to `true`/`false`, thanks to NaNs. - // CHECK: [[eq:_.*]] = Eq(_1, _1); + // CHECK: [[eq:_.*]] = Eq(copy _1, copy _1); // CHECK: opaque::(move [[eq]]) opaque(x == x); - // CHECK: [[ne:_.*]] = Ne(_1, _1); + // CHECK: [[ne:_.*]] = Ne(copy _1, copy _1); // CHECK: opaque::(move [[ne]]) opaque(x != x); } @@ -386,36 +386,36 @@ fn cast() { fn multiple_branches(t: bool, x: u8, y: u8) { // CHECK-LABEL: fn multiple_branches( - // CHECK: switchInt(_1) -> [0: [[bbf:bb.*]], otherwise: [[bbt:bb.*]]]; + // CHECK: switchInt(copy _1) -> [0: [[bbf:bb.*]], otherwise: [[bbt:bb.*]]]; if t { // CHECK: [[bbt]]: { - // CHECK: [[a:_.*]] = Add(_2, _3); - // CHECK: opaque::([[a]]) - // CHECK: opaque::([[a]]) + // CHECK: [[a:_.*]] = Add(copy _2, copy _3); + // CHECK: opaque::(copy [[a]]) + // CHECK: opaque::(copy [[a]]) // CHECK: goto -> [[bbc:bb.*]]; opaque(x + y); opaque(x + y); } else { // CHECK: [[bbf]]: { - // CHECK: [[b:_.*]] = Add(_2, _3); - // CHECK: opaque::([[b]]) - // CHECK: opaque::([[b]]) + // CHECK: [[b:_.*]] = Add(copy _2, copy _3); + // CHECK: opaque::(copy [[b]]) + // CHECK: opaque::(copy [[b]]) // CHECK: goto -> [[bbc:bb.*]]; opaque(x + y); opaque(x + y); } // Neither `a` nor `b` dominate `c`, so we cannot reuse any of them. // CHECK: [[bbc]]: { - // CHECK: [[c:_.*]] = Add(_2, _3); - // CHECK: opaque::([[c]]) + // CHECK: [[c:_.*]] = Add(copy _2, copy _3); + // CHECK: opaque::(copy [[c]]) opaque(x + y); // `c` dominates both calls, so we can reuse it. if t { - // CHECK: opaque::([[c]]) + // CHECK: opaque::(copy [[c]]) opaque(x + y); } else { - // CHECK: opaque::([[c]]) + // CHECK: opaque::(copy [[c]]) opaque(x + y); } } @@ -469,18 +469,18 @@ fn dereferences(t: &mut u32, u: &impl Copy, s: &S) { // CHECK-LABEL: fn dereferences( // Do not reuse dereferences of `&mut`. - // CHECK: [[st1:_.*]] = (*_1); + // CHECK: [[st1:_.*]] = copy (*_1); // CHECK: opaque::(move [[st1]]) - // CHECK: [[st2:_.*]] = (*_1); + // CHECK: [[st2:_.*]] = copy (*_1); // CHECK: opaque::(move [[st2]]) opaque(*t); opaque(*t); // Do not reuse dereferences of `*const`. // CHECK: [[raw:_.*]] = &raw const (*_1); - // CHECK: [[st3:_.*]] = (*[[raw]]); + // CHECK: [[st3:_.*]] = copy (*[[raw]]); // CHECK: opaque::(move [[st3]]) - // CHECK: [[st4:_.*]] = (*[[raw]]); + // CHECK: [[st4:_.*]] = copy (*[[raw]]); // CHECK: opaque::(move [[st4]]) let z = &raw const *t; unsafe { opaque(*z) }; @@ -488,9 +488,9 @@ fn dereferences(t: &mut u32, u: &impl Copy, s: &S) { // Do not reuse dereferences of `*mut`. // CHECK: [[ptr:_.*]] = &raw mut (*_1); - // CHECK: [[st5:_.*]] = (*[[ptr]]); + // CHECK: [[st5:_.*]] = copy (*[[ptr]]); // CHECK: opaque::(move [[st5]]) - // CHECK: [[st6:_.*]] = (*[[ptr]]); + // CHECK: [[st6:_.*]] = copy (*[[ptr]]); // CHECK: opaque::(move [[st6]]) let z = &raw mut *t; unsafe { opaque(*z) }; @@ -498,9 +498,9 @@ fn dereferences(t: &mut u32, u: &impl Copy, s: &S) { // We can reuse dereferences of `&Freeze`. // CHECK: [[ref:_.*]] = &(*_1); - // CHECK: [[st7:_.*]] = (*[[ref]]); - // CHECK: opaque::([[st7]]) - // CHECK: opaque::([[st7]]) + // CHECK: [[st7:_.*]] = copy (*[[ref]]); + // CHECK: opaque::(copy [[st7]]) + // CHECK: opaque::(copy [[st7]]) let z = &*t; opaque(*z); opaque(*z); @@ -510,17 +510,17 @@ fn dereferences(t: &mut u32, u: &impl Copy, s: &S) { opaque(&*z); // `*u` is not Freeze, so we cannot reuse. - // CHECK: [[st8:_.*]] = (*_2); + // CHECK: [[st8:_.*]] = copy (*_2); // CHECK: opaque::(move [[st8]]) - // CHECK: [[st9:_.*]] = (*_2); + // CHECK: [[st9:_.*]] = copy (*_2); // CHECK: opaque::(move [[st9]]) opaque(*u); opaque(*u); - // `*s` is not Copy, by `(*s).0` is, so we can reuse. - // CHECK: [[st10:_.*]] = ((*_3).0: u32); - // CHECK: opaque::([[st10]]) - // CHECK: opaque::([[st10]]) + // `*s` is not Copy, but `(*s).0` is, so we can reuse. + // CHECK: [[st10:_.*]] = copy ((*_3).0: u32); + // CHECK: opaque::(copy [[st10]]) + // CHECK: opaque::(copy [[st10]]) opaque(s.0); opaque(s.0); } @@ -551,38 +551,38 @@ fn duplicate_slice() -> (bool, bool) { let d: &str; { // CHECK: [[a:_.*]] = (const "a",); - // CHECK: [[au:_.*]] = ([[a]].0: &str) as u128 (Transmute); + // CHECK: [[au:_.*]] = copy ([[a]].0: &str) as u128 (Transmute); let a = ("a",); Call(au = transmute::<_, u128>(a.0), ReturnTo(bb1), UnwindContinue()) } bb1 = { - // CHECK: [[c:_.*]] = identity::<&str>(([[a]].0: &str)) + // CHECK: [[c:_.*]] = identity::<&str>(copy ([[a]].0: &str)) Call(c = identity(a.0), ReturnTo(bb2), UnwindContinue()) } bb2 = { - // CHECK: [[cu:_.*]] = [[c]] as u128 (Transmute); + // CHECK: [[cu:_.*]] = copy [[c]] as u128 (Transmute); Call(cu = transmute::<_, u128>(c), ReturnTo(bb3), UnwindContinue()) } bb3 = { // This slice is different from `a.0`. Hence `bu` is not `au`. // CHECK: [[b:_.*]] = const "a"; - // CHECK: [[bu:_.*]] = [[b]] as u128 (Transmute); + // CHECK: [[bu:_.*]] = copy [[b]] as u128 (Transmute); let b = "a"; Call(bu = transmute::<_, u128>(b), ReturnTo(bb4), UnwindContinue()) } bb4 = { // This returns a copy of `b`, which is not `a`. - // CHECK: [[d:_.*]] = identity::<&str>([[b]]) + // CHECK: [[d:_.*]] = identity::<&str>(copy [[b]]) Call(d = identity(b), ReturnTo(bb5), UnwindContinue()) } bb5 = { - // CHECK: [[du:_.*]] = [[d]] as u128 (Transmute); + // CHECK: [[du:_.*]] = copy [[d]] as u128 (Transmute); Call(du = transmute::<_, u128>(d), ReturnTo(bb6), UnwindContinue()) } bb6 = { // `direct` must not fold to `true`, as `indirect` will not. - // CHECK: = Eq([[au]], [[bu]]); - // CHECK: = Eq([[cu]], [[du]]); + // CHECK: = Eq(copy [[au]], copy [[bu]]); + // CHECK: = Eq(copy [[cu]], copy [[du]]); let direct = au == bu; let indirect = cu == du; RET = (direct, indirect); @@ -602,21 +602,21 @@ fn repeat() { fn fn_pointers() { // CHECK-LABEL: fn fn_pointers( // CHECK: [[f:_.*]] = identity:: as fn(u8) -> u8 (PointerCoercion(ReifyFnPointer - // CHECK: opaque:: u8>([[f]]) + // CHECK: opaque:: u8>(copy [[f]]) let f = identity as fn(u8) -> u8; opaque(f); // CHECK: [[g:_.*]] = identity:: as fn(u8) -> u8 (PointerCoercion(ReifyFnPointer - // CHECK: opaque:: u8>([[g]]) + // CHECK: opaque:: u8>(copy [[g]]) let g = identity as fn(u8) -> u8; opaque(g); // CHECK: [[cf:_.*]] = const {{.*}} as fn() (PointerCoercion(ClosureFnPointer - // CHECK: opaque::([[cf]]) + // CHECK: opaque::(copy [[cf]]) let closure = || {}; let cf = closure as fn(); opaque(cf); // CHECK: [[cg:_.*]] = const {{.*}} as fn() (PointerCoercion(ClosureFnPointer - // CHECK: opaque::([[cg]]) + // CHECK: opaque::(copy [[cg]]) let cg = closure as fn(); opaque(cg); } @@ -642,9 +642,9 @@ fn constant_index_overflow(x: &[T]) { // CHECK: debug b => [[b:_.*]]; // CHECK: [[a]] = const usize::MAX; // CHECK-NOT: = (*_1)[{{.*}} of 0]; - // CHECK: [[b]] = (*_1)[[[a]]]; + // CHECK: [[b]] = copy (*_1)[[[a]]]; // CHECK-NOT: = (*_1)[{{.*}} of 0]; - // CHECK: [[b]] = (*_1)[0 of 1]; + // CHECK: [[b]] = copy (*_1)[0 of 1]; // CHECK-NOT: = (*_1)[{{.*}} of 0]; let a = u64::MAX as usize; let b = if a < x.len() { x[a] } else { x[0] }; @@ -657,22 +657,22 @@ fn wide_ptr_provenance() { let a: *const dyn Send = &1 as &dyn Send; let b: *const dyn Send = &1 as &dyn Send; - // CHECK: [[eqp:_.*]] = Eq([[a:_.*]], [[b:_.*]]); + // CHECK: [[eqp:_.*]] = Eq(copy [[a:_.*]], copy [[b:_.*]]); // CHECK: opaque::(move [[eqp]]) opaque(a == b); - // CHECK: [[nep:_.*]] = Ne([[a]], [[b]]); + // CHECK: [[nep:_.*]] = Ne(copy [[a]], copy [[b]]); // CHECK: opaque::(move [[nep]]) opaque(a != b); - // CHECK: [[ltp:_.*]] = Lt([[a]], [[b]]); + // CHECK: [[ltp:_.*]] = Lt(copy [[a]], copy [[b]]); // CHECK: opaque::(move [[ltp]]) opaque(a < b); - // CHECK: [[lep:_.*]] = Le([[a]], [[b]]); + // CHECK: [[lep:_.*]] = Le(copy [[a]], copy [[b]]); // CHECK: opaque::(move [[lep]]) opaque(a <= b); - // CHECK: [[gtp:_.*]] = Gt([[a]], [[b]]); + // CHECK: [[gtp:_.*]] = Gt(copy [[a]], copy [[b]]); // CHECK: opaque::(move [[gtp]]) opaque(a > b); - // CHECK: [[gep:_.*]] = Ge([[a]], [[b]]); + // CHECK: [[gep:_.*]] = Ge(copy [[a]], copy [[b]]); // CHECK: opaque::(move [[gep]]) opaque(a >= b); } @@ -684,22 +684,22 @@ fn wide_ptr_same_provenance() { let a: *const dyn Send = &slice[0] as &dyn Send; let b: *const dyn Send = &slice[1] as &dyn Send; - // CHECK: [[eqp:_.*]] = Eq([[a:_.*]], [[b:_.*]]); + // CHECK: [[eqp:_.*]] = Eq(copy [[a:_.*]], copy [[b:_.*]]); // CHECK: opaque::(move [[eqp]]) opaque(a == b); - // CHECK: [[nep:_.*]] = Ne([[a]], [[b]]); + // CHECK: [[nep:_.*]] = Ne(copy [[a]], copy [[b]]); // CHECK: opaque::(move [[nep]]) opaque(a != b); - // CHECK: [[ltp:_.*]] = Lt([[a]], [[b]]); + // CHECK: [[ltp:_.*]] = Lt(copy [[a]], copy [[b]]); // CHECK: opaque::(move [[ltp]]) opaque(a < b); - // CHECK: [[lep:_.*]] = Le([[a]], [[b]]); + // CHECK: [[lep:_.*]] = Le(copy [[a]], copy [[b]]); // CHECK: opaque::(move [[lep]]) opaque(a <= b); - // CHECK: [[gtp:_.*]] = Gt([[a]], [[b]]); + // CHECK: [[gtp:_.*]] = Gt(copy [[a]], copy [[b]]); // CHECK: opaque::(move [[gtp]]) opaque(a > b); - // CHECK: [[gep:_.*]] = Ge([[a]], [[b]]); + // CHECK: [[gep:_.*]] = Ge(copy [[a]], copy [[b]]); // CHECK: opaque::(move [[gep]]) opaque(a >= b); } @@ -731,13 +731,13 @@ fn wide_ptr_integer() { fn borrowed(x: T) { // CHECK-LABEL: fn borrowed( // CHECK: bb0: { - // CHECK-NEXT: _2 = _1; + // CHECK-NEXT: _2 = copy _1; // CHECK-NEXT: _3 = &_1; - // CHECK-NEXT: _0 = opaque::<&T>(_3) + // CHECK-NEXT: _0 = opaque::<&T>(copy _3) // CHECK: bb1: { - // CHECK-NEXT: _0 = opaque::(_1) + // CHECK-NEXT: _0 = opaque::(copy _1) // CHECK: bb2: { - // CHECK-NEXT: _0 = opaque::(_1) + // CHECK-NEXT: _0 = opaque::(copy _1) mir! { { let a = x; @@ -761,13 +761,13 @@ fn borrowed(x: T) { fn non_freeze(x: T) { // CHECK-LABEL: fn non_freeze( // CHECK: bb0: { - // CHECK-NEXT: _2 = _1; + // CHECK-NEXT: _2 = copy _1; // CHECK-NEXT: _3 = &_1; - // CHECK-NEXT: _0 = opaque::<&T>(_3) + // CHECK-NEXT: _0 = opaque::<&T>(copy _3) // CHECK: bb1: { - // CHECK-NEXT: _0 = opaque::(_2) + // CHECK-NEXT: _0 = opaque::(copy _2) // CHECK: bb2: { - // CHECK-NEXT: _0 = opaque::((*_3)) + // CHECK-NEXT: _0 = opaque::(copy (*_3)) mir! { { let a = x; @@ -789,7 +789,7 @@ fn non_freeze(x: T) { // Check that we can const-prop into `from_raw_parts` fn slice_const_length(x: &[i32]) -> *const [i32] { // CHECK-LABEL: fn slice_const_length( - // CHECK: _0 = *const [i32] from ({{_[0-9]+}}, const 123_usize); + // CHECK: _0 = *const [i32] from (copy {{_[0-9]+}}, const 123_usize); let ptr = x.as_ptr(); let len = 123; std::intrinsics::aggregate_raw_ptr(ptr, len) @@ -804,15 +804,15 @@ fn meta_of_ref_to_slice(x: *const i32) -> usize { fn slice_from_raw_parts_as_ptr(x: *const u16, n: usize) -> (*const u16, *const f32) { // CHECK-LABEL: fn slice_from_raw_parts_as_ptr - // CHECK: _8 = _1 as *const f32 (PtrToPtr); - // CHECK: _0 = (_1, move _8); + // CHECK: _8 = copy _1 as *const f32 (PtrToPtr); + // CHECK: _0 = (copy _1, move _8); let ptr: *const [u16] = std::intrinsics::aggregate_raw_ptr(x, n); (ptr as *const u16, ptr as *const f32) } fn casts_before_aggregate_raw_ptr(x: *const u32) -> *const [u8] { // CHECK-LABEL: fn casts_before_aggregate_raw_ptr - // CHECK: _0 = *const [u8] from (_1, const 4_usize); + // CHECK: _0 = *const [u8] from (copy _1, const 4_usize); let x = x as *const [u8; 4]; let x = x as *const u8; let x = x as *const (); @@ -821,7 +821,7 @@ fn casts_before_aggregate_raw_ptr(x: *const u32) -> *const [u8] { fn manual_slice_mut_len(x: &mut [i32]) -> usize { // CHECK-LABEL: fn manual_slice_mut_len - // CHECK: _0 = PtrMetadata(_1); + // CHECK: _0 = PtrMetadata(copy _1); let x: *mut [i32] = x; let x: *const [i32] = x; std::intrinsics::ptr_metadata(x) @@ -844,38 +844,38 @@ fn generic_cast_metadata(ps: *const [T], pa: *const A, // when the pointee metadata do or don't match, respectively. // Metadata usize -> (), do not optimize. - // CHECK: [[T:_.+]] = _1 as - // CHECK-NEXT: PtrMetadata([[T]]) + // CHECK: [[T:_.+]] = copy _1 as + // CHECK-NEXT: PtrMetadata(copy [[T]]) let t1 = CastPtrToPtr::<_, *const T>(ps); let m1 = PtrMetadata(t1); // `(&A, [T])` has `usize` metadata, same as `[T]`, yes optimize. - // CHECK: [[T:_.+]] = _1 as - // CHECK-NEXT: PtrMetadata(_1) + // CHECK: [[T:_.+]] = copy _1 as + // CHECK-NEXT: PtrMetadata(copy _1) let t2 = CastPtrToPtr::<_, *const (&A, [T])>(ps); let m2 = PtrMetadata(t2); // Tail `A` and tail `B`, do not optimize. - // CHECK: [[T:_.+]] = _2 as - // CHECK-NEXT: PtrMetadata([[T]]) + // CHECK: [[T:_.+]] = copy _2 as + // CHECK-NEXT: PtrMetadata(copy [[T]]) let t3 = CastPtrToPtr::<_, *const (T, B)>(pa); let m3 = PtrMetadata(t3); // Both have tail `A`, yes optimize. - // CHECK: [[T:_.+]] = _2 as - // CHECK-NEXT: PtrMetadata(_2) + // CHECK: [[T:_.+]] = copy _2 as + // CHECK-NEXT: PtrMetadata(copy _2) let t4 = CastPtrToPtr::<_, *const (T, A)>(pa); let m4 = PtrMetadata(t4); // Tail `B` and tail `A`, do not optimize. - // CHECK: [[T:_.+]] = _3 as - // CHECK-NEXT: PtrMetadata([[T]]) + // CHECK: [[T:_.+]] = copy _3 as + // CHECK-NEXT: PtrMetadata(copy [[T]]) let t5 = CastPtrToPtr::<_, *mut A>(pb); let m5 = PtrMetadata(t5); // Both have tail `B`, yes optimize. - // CHECK: [[T:_.+]] = _3 as - // CHECK-NEXT: PtrMetadata(_3) + // CHECK: [[T:_.+]] = copy _3 as + // CHECK-NEXT: PtrMetadata(copy _3) let t6 = CastPtrToPtr::<_, *mut B>(pb); let m6 = PtrMetadata(t6); @@ -891,21 +891,21 @@ fn cast_pointer_eq(p1: *mut u8, p2: *mut u32, p3: *mut u32, p4: *mut [u32]) { // CHECK: debug p3 => [[P3:_3]]; // CHECK: debug p4 => [[P4:_4]]; - // CHECK: [[M1:_.+]] = [[P1]] as *const u32 (PtrToPtr); - // CHECK: [[M2:_.+]] = [[P2]] as *const u32 (PtrToPtr); - // CHECK: [[M3:_.+]] = [[P3]] as *const u32 (PtrToPtr); - // CHECK: [[M4:_.+]] = [[P4]] as *const u32 (PtrToPtr); + // CHECK: [[M1:_.+]] = copy [[P1]] as *const u32 (PtrToPtr); + // CHECK: [[M2:_.+]] = copy [[P2]] as *const u32 (PtrToPtr); + // CHECK: [[M3:_.+]] = copy [[P3]] as *const u32 (PtrToPtr); + // CHECK: [[M4:_.+]] = copy [[P4]] as *const u32 (PtrToPtr); let m1 = p1 as *const u32; let m2 = p2 as *const u32; let m3 = p3 as *const u32; let m4 = p4 as *const u32; // CHECK-NOT: Eq - // CHECK: Eq([[M1]], [[M2]]) + // CHECK: Eq(copy [[M1]], copy [[M2]]) // CHECK-NOT: Eq - // CHECK: Eq([[P2]], [[P3]]) + // CHECK: Eq(copy [[P2]], copy [[P3]]) // CHECK-NOT: Eq - // CHECK: Eq([[M3]], [[M4]]) + // CHECK: Eq(copy [[M3]], copy [[M4]]) // CHECK-NOT: Eq let eq_different_thing = m1 == m2; let eq_optimize = m2 == m3; @@ -918,11 +918,11 @@ fn cast_pointer_eq(p1: *mut u8, p2: *mut u32, p3: *mut u32, p4: *mut [u32]) { unsafe fn cast_pointer_then_transmute(thin: *mut u32, fat: *mut [u8]) { // CHECK-LABEL: fn cast_pointer_then_transmute - // CHECK: [[UNUSED:_.+]] = _1 as *const () (PtrToPtr); - // CHECK: = _1 as usize (Transmute); + // CHECK: [[UNUSED:_.+]] = copy _1 as *const () (PtrToPtr); + // CHECK: = copy _1 as usize (Transmute); let thin_addr: usize = std::intrinsics::transmute(thin as *const ()); - // CHECK: [[TEMP2:_.+]] = _2 as *const () (PtrToPtr); + // CHECK: [[TEMP2:_.+]] = copy _2 as *const () (PtrToPtr); // CHECK: = move [[TEMP2]] as usize (Transmute); let fat_addr: usize = std::intrinsics::transmute(fat as *const ()); } @@ -935,11 +935,11 @@ fn remove_casts_must_change_both_sides(mut_a: &*mut u8, mut_b: *mut u8) -> bool // to be locals, so make sure we don't change one without the other, as // that would be a type error. { - // CHECK: [[A:_.+]] = (*_1) as *const u8 (PtrToPtr); + // CHECK: [[A:_.+]] = copy (*_1) as *const u8 (PtrToPtr); let a = *mut_a as *const u8; - // CHECK: [[B:_.+]] = _2 as *const u8 (PtrToPtr); + // CHECK: [[B:_.+]] = copy _2 as *const u8 (PtrToPtr); let b = mut_b as *const u8; - // CHECK: _0 = Eq([[A]], [[B]]); + // CHECK: _0 = Eq(copy [[A]], copy [[B]]); RET = a == b; Return() } diff --git a/tests/mir-opt/gvn_copy_moves.rs b/tests/mir-opt/gvn_copy_moves.rs index 1812de16d69f..b1fe2caf3a14 100644 --- a/tests/mir-opt/gvn_copy_moves.rs +++ b/tests/mir-opt/gvn_copy_moves.rs @@ -18,9 +18,9 @@ fn fn0() { // CHECK-NEXT: _1 = const 1_usize; // CHECK-NEXT: _2 = [const 42_u128; 6]; // CHECK-NEXT: _2[1 of 2] = const 1_u128; - // CHECK-NEXT: _3 = (_2,); - // CHECK-NEXT: _4 = _3; - // CHECK-NEXT: _5 = fn1((_3.0: [u128; 6]), _3) + // CHECK-NEXT: _3 = (copy _2,); + // CHECK-NEXT: _4 = copy _3; + // CHECK-NEXT: _5 = fn1(copy (_3.0: [u128; 6]), copy _3) a = 1_usize; b = [42; 6]; b[a] = 1; diff --git a/tests/mir-opt/instsimplify/casts.rs b/tests/mir-opt/instsimplify/casts.rs index 24dbb67b42d1..27308ee52bc2 100644 --- a/tests/mir-opt/instsimplify/casts.rs +++ b/tests/mir-opt/instsimplify/casts.rs @@ -19,7 +19,7 @@ pub fn redundant<'a, 'b: 'a>(x: *const &'a u8) -> *const &'a u8 { // EMIT_MIR casts.roundtrip.InstSimplify-after-simplifycfg.diff pub fn roundtrip(x: *const u8) -> *const u8 { // CHECK-LABEL: fn roundtrip( - // CHECK: _4 = _1; + // CHECK: _4 = copy _1; // CHECK: _3 = move _4 as *mut u8 (PtrToPtr); // CHECK: _2 = move _3 as *const u8 (PtrToPtr); x as *mut u8 as *const u8 @@ -28,7 +28,7 @@ pub fn roundtrip(x: *const u8) -> *const u8 { // EMIT_MIR casts.roundtrip.InstSimplify-after-simplifycfg.diff pub fn cast_thin_via_aggregate(x: *const u8) -> *const () { // CHECK-LABEL: fn cast_thin_via_aggregate( - // CHECK: _2 = _1; + // CHECK: _2 = copy _1; // CHECK: _0 = move _2 as *const () (PtrToPtr); std::intrinsics::aggregate_raw_ptr(x, ()) } diff --git a/tests/mir-opt/instsimplify/ref_of_deref.rs b/tests/mir-opt/instsimplify/ref_of_deref.rs index dc0f5f8198bc..5ba9bafaea2a 100644 --- a/tests/mir-opt/instsimplify/ref_of_deref.rs +++ b/tests/mir-opt/instsimplify/ref_of_deref.rs @@ -8,11 +8,11 @@ // EMIT_MIR ref_of_deref.references.InstSimplify-after-simplifycfg.diff // CHECK-LABEL: references pub fn references(const_ref: &i32, mut_ref: &mut [i32]) { - // CHECK: _3 = _1; + // CHECK: _3 = copy _1; let _a = &*const_ref; // CHECK: _4 = &(*_2); let _b = &*mut_ref; - // CHECK: _5 = _2; + // CHECK: _5 = copy _2; let _c = &mut *mut_ref; // CHECK: _6 = &raw const (*_1); let _d = &raw const *const_ref; @@ -31,10 +31,10 @@ pub unsafe fn pointers(const_ptr: *const [i32], mut_ptr: *mut i32) { let _b = &*mut_ptr; // CHECK: _5 = &mut (*_2); let _c = &mut *mut_ptr; - // CHECK: _6 = _1; + // CHECK: _6 = copy _1; let _d = &raw const *const_ptr; // CHECK: _7 = &raw const (*_2); let _e = &raw const *mut_ptr; - // CHECK: _8 = _2; + // CHECK: _8 = copy _2; let _f = &raw mut *mut_ptr; } diff --git a/tests/mir-opt/instsimplify/ub_check.rs b/tests/mir-opt/instsimplify/ub_check.rs index ee72511c132d..b513f60dc7b9 100644 --- a/tests/mir-opt/instsimplify/ub_check.rs +++ b/tests/mir-opt/instsimplify/ub_check.rs @@ -6,7 +6,7 @@ pub fn unwrap_unchecked(x: Option) -> i32 { // CHECK-LABEL: fn unwrap_unchecked( // CHECK-NOT: UbChecks() // CHECK: [[assume:_.*]] = const false; - // CHECK-NEXT: assume([[assume]]); + // CHECK-NEXT: assume(copy [[assume]]); // CHECK-NEXT: unreachable_unchecked::precondition_check unsafe { x.unwrap_unchecked() } } diff --git a/tests/mir-opt/jump_threading.rs b/tests/mir-opt/jump_threading.rs index 6486a321e693..9487a4e7e5ff 100644 --- a/tests/mir-opt/jump_threading.rs +++ b/tests/mir-opt/jump_threading.rs @@ -24,11 +24,11 @@ fn too_complex(x: Result) -> Option { // CHECK: bb4: { // CHECK: goto -> bb6; // CHECK: bb5: { - // CHECK: {{_.*}} = (([[controlflow]] as Break).0: usize); + // CHECK: {{_.*}} = copy (([[controlflow]] as Break).0: usize); // CHECK: _0 = Option::::None; // CHECK: goto -> bb7; // CHECK: bb6: { - // CHECK: {{_.*}} = (([[controlflow]] as Continue).0: i32); + // CHECK: {{_.*}} = copy (([[controlflow]] as Continue).0: i32); // CHECK: _0 = Option::::Some( // CHECK: goto -> bb7; // CHECK: bb7: { @@ -49,16 +49,16 @@ fn too_complex(x: Result) -> Option { fn identity(x: Result) -> Result { // CHECK-LABEL: fn identity( // CHECK: bb0: { - // CHECK: [[x:_.*]] = _1; + // CHECK: [[x:_.*]] = copy _1; // CHECK: switchInt(move {{_.*}}) -> [0: bb7, 1: bb6, otherwise: bb1]; // CHECK: bb1: { // CHECK: unreachable; // CHECK: bb2: { - // CHECK: {{_.*}} = (([[controlflow:_.*]] as Continue).0: i32); + // CHECK: {{_.*}} = copy (([[controlflow:_.*]] as Continue).0: i32); // CHECK: _0 = Result::::Ok( // CHECK: goto -> bb4; // CHECK: bb3: { - // CHECK: {{_.*}} = (([[controlflow]] as Break).0: std::result::Result); + // CHECK: {{_.*}} = copy (([[controlflow]] as Break).0: std::result::Result); // CHECK: _0 = Result::::Err( // CHECK: goto -> bb4; // CHECK: bb4: { @@ -160,13 +160,13 @@ fn multiple_match(x: u8) -> u8 { mir! { { // CHECK: bb0: { - // CHECK: switchInt([[x:_.*]]) -> [3: bb1, otherwise: bb2]; + // CHECK: switchInt(copy [[x:_.*]]) -> [3: bb1, otherwise: bb2]; match x { 3 => bb1, _ => bb2 } } bb1 = { // We know `x == 3`, so we can take `bb3`. // CHECK: bb1: { - // CHECK: {{_.*}} = [[x]]; + // CHECK: {{_.*}} = copy [[x]]; // CHECK: goto -> bb3; let y = x; match y { 3 => bb3, _ => bb4 } @@ -174,7 +174,7 @@ fn multiple_match(x: u8) -> u8 { bb2 = { // We know `x != 3`, so we can take `bb6`. // CHECK: bb2: { - // CHECK: [[z:_.*]] = [[x]]; + // CHECK: [[z:_.*]] = copy [[x]]; // CHECK: goto -> bb6; let z = x; match z { 3 => bb5, _ => bb6 } @@ -203,7 +203,7 @@ fn multiple_match(x: u8) -> u8 { bb6 = { // We know `z != 3`, so we CANNOT take `bb7`. // CHECK: bb6: { - // CHECK: switchInt([[z]]) -> [1: bb7, otherwise: bb8]; + // CHECK: switchInt(copy [[z]]) -> [1: bb7, otherwise: bb8]; match z { 1 => bb7, _ => bb8 } } bb7 = { @@ -467,12 +467,12 @@ fn assume(a: u8, b: bool) -> u8 { mir! { { // CHECK: bb0: { - // CHECK-NEXT: switchInt(_1) -> [7: bb1, otherwise: bb2] + // CHECK-NEXT: switchInt(copy _1) -> [7: bb1, otherwise: bb2] match a { 7 => bb1, _ => bb2 } } bb1 = { // CHECK: bb1: { - // CHECK-NEXT: assume(_2); + // CHECK-NEXT: assume(copy _2); // CHECK-NEXT: goto -> bb6; Assume(b); Goto(bb3) @@ -484,7 +484,7 @@ fn assume(a: u8, b: bool) -> u8 { } bb3 = { // CHECK: bb3: { - // CHECK-NEXT: switchInt(_2) -> [0: bb4, otherwise: bb5]; + // CHECK-NEXT: switchInt(copy _2) -> [0: bb4, otherwise: bb5]; match b { false => bb4, _ => bb5 } } bb4 = { diff --git a/tests/mir-opt/lower_array_len.rs b/tests/mir-opt/lower_array_len.rs index f7ed376726c8..6553343cbf03 100644 --- a/tests/mir-opt/lower_array_len.rs +++ b/tests/mir-opt/lower_array_len.rs @@ -6,7 +6,7 @@ pub fn array_bound(index: usize, slice: &[u8; N]) -> u8 { // CHECK-LABEL: fn array_bound( // CHECK-NOT: Lt - // CHECK: Lt(_1, const N); + // CHECK: Lt(copy _1, const N); // CHECK-NOT: Lt if index < slice.len() { slice[index] } else { 42 } } @@ -15,7 +15,7 @@ pub fn array_bound(index: usize, slice: &[u8; N]) -> u8 { pub fn array_bound_mut(index: usize, slice: &mut [u8; N]) -> u8 { // CHECK-LABEL: fn array_bound_mut( // CHECK-NOT: Lt - // CHECK: Lt(_1, const N); + // CHECK: Lt(copy _1, const N); // CHECK-NOT: Lt // CHECK: Lt(const 0_usize, const N) // CHECK-NOT: Lt diff --git a/tests/mir-opt/lower_intrinsics.rs b/tests/mir-opt/lower_intrinsics.rs index 2569f4f4de5d..4859d9354619 100644 --- a/tests/mir-opt/lower_intrinsics.rs +++ b/tests/mir-opt/lower_intrinsics.rs @@ -197,7 +197,7 @@ pub fn with_overflow(a: i32, b: i32) { pub fn read_via_copy_primitive(r: &i32) -> i32 { // CHECK-LABEL: fn read_via_copy_primitive( // CHECK: [[tmp:_.*]] = &raw const (*_1); - // CHECK: _0 = (*[[tmp]]); + // CHECK: _0 = copy (*[[tmp]]); // CHECK: return; unsafe { core::intrinsics::read_via_copy(r) } @@ -207,7 +207,7 @@ pub fn read_via_copy_primitive(r: &i32) -> i32 { pub fn read_via_copy_uninhabited(r: &Never) -> Never { // CHECK-LABEL: fn read_via_copy_uninhabited( // CHECK: [[tmp:_.*]] = &raw const (*_1); - // CHECK: _0 = (*[[tmp]]); + // CHECK: _0 = copy (*[[tmp]]); // CHECK: unreachable; unsafe { core::intrinsics::read_via_copy(r) } diff --git a/tests/mir-opt/pre-codegen/slice_index.rs b/tests/mir-opt/pre-codegen/slice_index.rs index 6ddc4ad02207..574062d6c356 100644 --- a/tests/mir-opt/pre-codegen/slice_index.rs +++ b/tests/mir-opt/pre-codegen/slice_index.rs @@ -10,17 +10,17 @@ use std::ops::Range; pub fn slice_index_usize(slice: &[u32], index: usize) -> u32 { // CHECK-LABEL: slice_index_usize // CHECK: [[LEN:_[0-9]+]] = Len((*_1)) - // CHECK: Lt(_2, [[LEN]]) + // CHECK: Lt(copy _2, copy [[LEN]]) // CHECK-NOT: precondition_check - // CHECK: _0 = (*_1)[_2]; + // CHECK: _0 = copy (*_1)[_2]; slice[index] } // EMIT_MIR slice_index.slice_get_mut_usize.PreCodegen.after.mir pub fn slice_get_mut_usize(slice: &mut [u32], index: usize) -> Option<&mut u32> { // CHECK-LABEL: slice_get_mut_usize - // CHECK: [[LEN:_[0-9]+]] = PtrMetadata(_1) - // CHECK: Lt(_2, move [[LEN]]) + // CHECK: [[LEN:_[0-9]+]] = PtrMetadata(copy _1) + // CHECK: Lt(copy _2, move [[LEN]]) // CHECK-NOT: precondition_check slice.get_mut(index) } @@ -37,9 +37,9 @@ pub unsafe fn slice_get_unchecked_mut_range(slice: &mut [u32], index: Range(single: &'a T, mut multiple: &'a T) { // CHECK: bb0: { // CHECK: [[a:_.*]] = const 5_usize; // CHECK: [[b:_.*]] = &[[a]]; - // CHECK: [[c:_.*]] = [[a]]; + // CHECK: [[c:_.*]] = copy [[a]]; let a = 5_usize; let b = &a; // This borrow is only used once. @@ -32,7 +32,7 @@ fn reference_propagation<'a, T: Copy>(single: &'a T, mut multiple: &'a T) { // CHECK: [[b:_.*]] = &[[a]]; // CHECK: [[btmp:_.*]] = &[[a2]]; // CHECK: [[b]] = move [[btmp]]; - // CHECK: [[c:_.*]] = (*[[b]]); + // CHECK: [[c:_.*]] = copy (*[[b]]); let a = 5_usize; let a2 = 7_usize; @@ -49,7 +49,7 @@ fn reference_propagation<'a, T: Copy>(single: &'a T, mut multiple: &'a T) { // CHECK: [[a:_.*]] = const 5_usize; // CHECK: [[b:_.*]] = &[[a]]; // CHECK: [[d:_.*]] = &[[b]]; - // CHECK: [[c:_.*]] = [[a]]; + // CHECK: [[c:_.*]] = copy [[a]]; let a = 5_usize; let b = &a; @@ -64,7 +64,7 @@ fn reference_propagation<'a, T: Copy>(single: &'a T, mut multiple: &'a T) { // CHECK: [[a:_.*]] = const 5_usize; // CHECK: [[b:_.*]] = &[[a]]; // CHECK: [[d:_.*]] = &raw mut [[b]]; - // CHECK: [[c:_.*]] = (*[[b]]); + // CHECK: [[c:_.*]] = copy (*[[b]]); let a = 5_usize; let mut b = &a; @@ -78,7 +78,7 @@ fn reference_propagation<'a, T: Copy>(single: &'a T, mut multiple: &'a T) { // CHECK: bb4: { // CHECK: [[a:_.*]] = const 7_usize; // CHECK: [[b:_.*]] = &[[a]]; - // CHECK: [[c:_.*]] = [[a]]; + // CHECK: [[c:_.*]] = copy [[a]]; let a = 7_usize; let b = &a; @@ -91,10 +91,10 @@ fn reference_propagation<'a, T: Copy>(single: &'a T, mut multiple: &'a T) { // CHECK: bb5: { // CHECK: [[a:_.*]] = const 7_usize; // CHECK: [[b1:_.*]] = &[[a]]; - // CHECK: [[c:_.*]] = [[a]]; - // CHECK: [[b2:_.*]] = [[b1]]; - // CHECK: [[c2:_.*]] = [[a]]; - // CHECK: [[b3:_.*]] = [[b2]]; + // CHECK: [[c:_.*]] = copy [[a]]; + // CHECK: [[b2:_.*]] = copy [[b1]]; + // CHECK: [[c2:_.*]] = copy [[a]]; + // CHECK: [[b3:_.*]] = copy [[b2]]; let a = 7_usize; let b1 = &a; @@ -111,7 +111,7 @@ fn reference_propagation<'a, T: Copy>(single: &'a T, mut multiple: &'a T) { { // CHECK: bb6: { // CHECK-NOT: {{_.*}} = &(*_1); - // CHECK: [[b:_.*]] = (*_1); + // CHECK: [[b:_.*]] = copy (*_1); let a = &*single; let b = *a; // This should be optimized as `*single`. @@ -124,7 +124,7 @@ fn reference_propagation<'a, T: Copy>(single: &'a T, mut multiple: &'a T) { // CHECK: [[a:_.*]] = &(*_2); // CHECK: [[tmp:_.*]] = &(*_1); // CHECK: _2 = move [[tmp]]; - // CHECK: [[b:_.*]] = (*[[a]]); + // CHECK: [[b:_.*]] = copy (*[[a]]); let a = &*multiple; multiple = &*single; @@ -138,7 +138,7 @@ fn reference_propagation<'a, T: Copy>(single: &'a T, mut multiple: &'a T) { // CHECK: [[a:_.*]] = const 5_usize; // CHECK: [[b:_.*]] = &[[a]]; // CHECK: [[d:_.*]] = &[[b]]; - // CHECK: [[c:_.*]] = [[a]]; + // CHECK: [[c:_.*]] = copy [[a]]; let a = 5_usize; let b = &a; @@ -154,7 +154,7 @@ fn reference_propagation<'a, T: Copy>(single: &'a T, mut multiple: &'a T) { // CHECK: [[b:_.*]] = &[[a]]; // CHECK: [[d:_.*]] = &mut [[b]]; // FIXME this could be [[a]] - // CHECK: [[c:_.*]] = (*[[b]]); + // CHECK: [[c:_.*]] = copy (*[[b]]); let a = 5_usize; let mut b = &a; @@ -172,7 +172,7 @@ fn reference_propagation_mut<'a, T: Copy>(single: &'a mut T, mut multiple: &'a m // CHECK: bb0: { // CHECK: [[a:_.*]] = const 5_usize; // CHECK: [[b:_.*]] = &mut [[a]]; - // CHECK: [[c:_.*]] = [[a]]; + // CHECK: [[c:_.*]] = copy [[a]]; let mut a = 5_usize; let b = &mut a; // This borrow is only used once. @@ -188,7 +188,7 @@ fn reference_propagation_mut<'a, T: Copy>(single: &'a mut T, mut multiple: &'a m // CHECK: [[b:_.*]] = &mut [[a]]; // CHECK: [[btmp:_.*]] = &mut [[a2]]; // CHECK: [[b]] = move [[btmp]]; - // CHECK: [[c:_.*]] = (*[[b]]); + // CHECK: [[c:_.*]] = copy (*[[b]]); let mut a = 5_usize; let mut a2 = 7_usize; @@ -205,7 +205,7 @@ fn reference_propagation_mut<'a, T: Copy>(single: &'a mut T, mut multiple: &'a m // CHECK: [[a:_.*]] = const 5_usize; // CHECK: [[b:_.*]] = &mut [[a]]; // CHECK: [[d:_.*]] = &[[b]]; - // CHECK: [[c:_.*]] = (*[[b]]); + // CHECK: [[c:_.*]] = copy (*[[b]]); let mut a = 5_usize; let b = &mut a; @@ -220,7 +220,7 @@ fn reference_propagation_mut<'a, T: Copy>(single: &'a mut T, mut multiple: &'a m // CHECK: [[a:_.*]] = const 5_usize; // CHECK: [[b:_.*]] = &mut [[a]]; // CHECK: [[d:_.*]] = &raw mut [[b]]; - // CHECK: [[c:_.*]] = (*[[b]]); + // CHECK: [[c:_.*]] = copy (*[[b]]); let mut a = 5_usize; let mut b = &mut a; @@ -234,7 +234,7 @@ fn reference_propagation_mut<'a, T: Copy>(single: &'a mut T, mut multiple: &'a m // CHECK: bb4: { // CHECK: [[a:_.*]] = const 7_usize; // CHECK: [[b:_.*]] = &mut [[a]]; - // CHECK: [[c:_.*]] = (*[[b]]); + // CHECK: [[c:_.*]] = copy (*[[b]]); let mut a = 7_usize; let b = &mut a; @@ -247,9 +247,9 @@ fn reference_propagation_mut<'a, T: Copy>(single: &'a mut T, mut multiple: &'a m // CHECK: bb5: { // CHECK: [[a:_.*]] = const 7_usize; // CHECK: [[b1:_.*]] = &mut [[a]]; - // CHECK: [[c:_.*]] = (*[[b1]]); + // CHECK: [[c:_.*]] = copy (*[[b1]]); // CHECK: [[b2:_.*]] = move [[b1]]; - // CHECK: [[c2:_.*]] = (*[[b2]]); + // CHECK: [[c2:_.*]] = copy (*[[b2]]); // CHECK: [[b3:_.*]] = move [[b2]]; let mut a = 7_usize; @@ -267,7 +267,7 @@ fn reference_propagation_mut<'a, T: Copy>(single: &'a mut T, mut multiple: &'a m { // CHECK: bb6: { // CHECK-NOT: {{_.*}} = &(*_1); - // CHECK: [[b:_.*]] = (*_1); + // CHECK: [[b:_.*]] = copy (*_1); let a = &mut *single; let b = *a; // This should be optimized as `*single`. @@ -280,7 +280,7 @@ fn reference_propagation_mut<'a, T: Copy>(single: &'a mut T, mut multiple: &'a m // CHECK: [[a:_.*]] = &mut (*_2); // CHECK: [[tmp:_.*]] = &mut (*_1); // CHECK: _2 = move [[tmp]]; - // CHECK: [[b:_.*]] = (*[[a]]); + // CHECK: [[b:_.*]] = copy (*[[a]]); let a = &mut *multiple; multiple = &mut *single; @@ -295,7 +295,7 @@ fn reference_propagation_mut<'a, T: Copy>(single: &'a mut T, mut multiple: &'a m // CHECK: [[b:_.*]] = &mut [[a]]; // CHECK: [[d:_.*]] = &[[b]]; // FIXME this could be [[a]] - // CHECK: [[c:_.*]] = (*[[b]]); + // CHECK: [[c:_.*]] = copy (*[[b]]); let mut a = 5_usize; let b = &mut a; @@ -311,7 +311,7 @@ fn reference_propagation_mut<'a, T: Copy>(single: &'a mut T, mut multiple: &'a m // CHECK: [[b:_.*]] = &mut [[a]]; // CHECK: [[d:_.*]] = &mut [[b]]; // FIXME this could be [[a]] - // CHECK: [[c:_.*]] = (*[[b]]); + // CHECK: [[c:_.*]] = copy (*[[b]]); let mut a = 5_usize; let mut b = &mut a; @@ -329,7 +329,7 @@ fn reference_propagation_const_ptr(single: *const T, mut multiple: *con // CHECK: bb0: { // CHECK: [[a:_.*]] = const 5_usize; // CHECK: [[b:_.*]] = &raw const [[a]]; - // CHECK: [[c:_.*]] = [[a]]; + // CHECK: [[c:_.*]] = copy [[a]]; let a = 5_usize; let b = &raw const a; // This borrow is only used once. @@ -345,7 +345,7 @@ fn reference_propagation_const_ptr(single: *const T, mut multiple: *con // CHECK: [[b:_.*]] = &raw const [[a]]; // CHECK: [[btmp:_.*]] = &raw const [[a2]]; // CHECK: [[b]] = move [[btmp]]; - // CHECK: [[c:_.*]] = (*[[b]]); + // CHECK: [[c:_.*]] = copy (*[[b]]); let a = 5_usize; let a2 = 7_usize; @@ -362,7 +362,7 @@ fn reference_propagation_const_ptr(single: *const T, mut multiple: *con // CHECK: [[a:_.*]] = const 5_usize; // CHECK: [[b:_.*]] = &raw const [[a]]; // CHECK: [[d:_.*]] = &[[b]]; - // CHECK: [[c:_.*]] = [[a]]; + // CHECK: [[c:_.*]] = copy [[a]]; let a = 5_usize; let b = &raw const a; @@ -377,7 +377,7 @@ fn reference_propagation_const_ptr(single: *const T, mut multiple: *con // CHECK: [[a:_.*]] = const 5_usize; // CHECK: [[b:_.*]] = &raw const [[a]]; // CHECK: [[d:_.*]] = &raw mut [[b]]; - // CHECK: [[c:_.*]] = (*[[b]]); + // CHECK: [[c:_.*]] = copy (*[[b]]); let a = 5_usize; let mut b = &raw const a; @@ -391,7 +391,7 @@ fn reference_propagation_const_ptr(single: *const T, mut multiple: *con // CHECK: bb4: { // CHECK: [[a:_.*]] = const 7_usize; // CHECK: [[b:_.*]] = &raw const [[a]]; - // CHECK: [[c:_.*]] = [[a]]; + // CHECK: [[c:_.*]] = copy [[a]]; let a = 7_usize; let b = &raw const a; @@ -404,10 +404,10 @@ fn reference_propagation_const_ptr(single: *const T, mut multiple: *con // CHECK: bb5: { // CHECK: [[a:_.*]] = const 7_usize; // CHECK: [[b1:_.*]] = &raw const [[a]]; - // CHECK: [[c:_.*]] = [[a]]; - // CHECK: [[b2:_.*]] = [[b1]]; - // CHECK: [[c2:_.*]] = [[a]]; - // CHECK: [[b3:_.*]] = [[b2]]; + // CHECK: [[c:_.*]] = copy [[a]]; + // CHECK: [[b2:_.*]] = copy [[b1]]; + // CHECK: [[c2:_.*]] = copy [[a]]; + // CHECK: [[b3:_.*]] = copy [[b2]]; let a = 7_usize; let b1 = &raw const a; @@ -424,7 +424,7 @@ fn reference_propagation_const_ptr(single: *const T, mut multiple: *con unsafe { // CHECK: bb6: { // CHECK-NOT: {{_.*}} = &(*_1); - // CHECK: [[b:_.*]] = (*_1); + // CHECK: [[b:_.*]] = copy (*_1); let a = &raw const *single; let b = *a; // This should be optimized as `*single`. @@ -437,7 +437,7 @@ fn reference_propagation_const_ptr(single: *const T, mut multiple: *con // CHECK: [[a:_.*]] = &raw const (*_2); // CHECK: [[tmp:_.*]] = &raw const (*_1); // CHECK: _2 = move [[tmp]]; - // CHECK: [[b:_.*]] = (*[[a]]); + // CHECK: [[b:_.*]] = copy (*[[a]]); let a = &raw const *multiple; multiple = &raw const *single; @@ -451,7 +451,7 @@ fn reference_propagation_const_ptr(single: *const T, mut multiple: *con // CHECK: [[a:_.*]] = const 13_usize; // CHECK: [[b:_.*]] = &raw const [[a]]; // CHECK: [[d:_.*]] = &raw const [[a]]; - // CHECK: [[c:_.*]] = [[a]]; + // CHECK: [[c:_.*]] = copy [[a]]; let a = 13_usize; let b = &raw const a; @@ -466,7 +466,7 @@ fn reference_propagation_const_ptr(single: *const T, mut multiple: *con // CHECK: [[a:_.*]] = const 5_usize; // CHECK: [[b:_.*]] = &raw const [[a]]; // CHECK: [[d:_.*]] = &[[b]]; - // CHECK: [[c:_.*]] = [[a]]; + // CHECK: [[c:_.*]] = copy [[a]]; let a = 5_usize; let b = &raw const a; @@ -482,7 +482,7 @@ fn reference_propagation_const_ptr(single: *const T, mut multiple: *con // CHECK: [[b:_.*]] = &raw const [[a]]; // CHECK: [[d:_.*]] = &mut [[b]]; // FIXME this could be [[a]] - // CHECK: [[c:_.*]] = (*[[b]]); + // CHECK: [[c:_.*]] = copy (*[[b]]); let a = 5_usize; let mut b = &raw const a; @@ -500,7 +500,7 @@ fn reference_propagation_mut_ptr(single: *mut T, mut multiple: *mut T) // CHECK: bb0: { // CHECK: [[a:_.*]] = const 5_usize; // CHECK: [[b:_.*]] = &raw mut [[a]]; - // CHECK: [[c:_.*]] = [[a]]; + // CHECK: [[c:_.*]] = copy [[a]]; let mut a = 5_usize; let b = &raw mut a; // This borrow is only used once. @@ -516,7 +516,7 @@ fn reference_propagation_mut_ptr(single: *mut T, mut multiple: *mut T) // CHECK: [[b:_.*]] = &raw mut [[a]]; // CHECK: [[btmp:_.*]] = &raw mut [[a2]]; // CHECK: [[b]] = move [[btmp]]; - // CHECK: [[c:_.*]] = (*[[b]]); + // CHECK: [[c:_.*]] = copy (*[[b]]); let mut a = 5_usize; let mut a2 = 7_usize; @@ -533,7 +533,7 @@ fn reference_propagation_mut_ptr(single: *mut T, mut multiple: *mut T) // CHECK: [[a:_.*]] = const 5_usize; // CHECK: [[b:_.*]] = &raw mut [[a]]; // CHECK: [[d:_.*]] = &[[b]]; - // CHECK: [[c:_.*]] = (*[[b]]); + // CHECK: [[c:_.*]] = copy (*[[b]]); let mut a = 5_usize; let b = &raw mut a; @@ -548,7 +548,7 @@ fn reference_propagation_mut_ptr(single: *mut T, mut multiple: *mut T) // CHECK: [[a:_.*]] = const 5_usize; // CHECK: [[b:_.*]] = &raw mut [[a]]; // CHECK: [[d:_.*]] = &raw mut [[b]]; - // CHECK: [[c:_.*]] = (*[[b]]); + // CHECK: [[c:_.*]] = copy (*[[b]]); let mut a = 5_usize; let mut b = &raw mut a; @@ -562,7 +562,7 @@ fn reference_propagation_mut_ptr(single: *mut T, mut multiple: *mut T) // CHECK: bb4: { // CHECK: [[a:_.*]] = const 7_usize; // CHECK: [[b:_.*]] = &raw mut [[a]]; - // CHECK: [[c:_.*]] = (*[[b]]); + // CHECK: [[c:_.*]] = copy (*[[b]]); let mut a = 7_usize; let b = &raw mut a; @@ -575,10 +575,10 @@ fn reference_propagation_mut_ptr(single: *mut T, mut multiple: *mut T) // CHECK: bb5: { // CHECK: [[a:_.*]] = const 7_usize; // CHECK: [[b1:_.*]] = &raw mut [[a]]; - // CHECK: [[c:_.*]] = (*[[b1]]); - // CHECK: [[b2:_.*]] = [[b1]]; - // CHECK: [[c2:_.*]] = (*[[b2]]); - // CHECK: [[b3:_.*]] = [[b2]]; + // CHECK: [[c:_.*]] = copy (*[[b1]]); + // CHECK: [[b2:_.*]] = copy [[b1]]; + // CHECK: [[c2:_.*]] = copy (*[[b2]]); + // CHECK: [[b3:_.*]] = copy [[b2]]; let mut a = 7_usize; let b1 = &raw mut a; @@ -595,7 +595,7 @@ fn reference_propagation_mut_ptr(single: *mut T, mut multiple: *mut T) unsafe { // CHECK: bb6: { // CHECK-NOT: {{_.*}} = &(*_1); - // CHECK: [[b:_.*]] = (*_1); + // CHECK: [[b:_.*]] = copy (*_1); let a = &raw mut *single; let b = *a; // This should be optimized as `*single`. @@ -608,7 +608,7 @@ fn reference_propagation_mut_ptr(single: *mut T, mut multiple: *mut T) // CHECK: [[a:_.*]] = &raw mut (*_2); // CHECK: [[tmp:_.*]] = &raw mut (*_1); // CHECK: _2 = move [[tmp]]; - // CHECK: [[b:_.*]] = (*[[a]]); + // CHECK: [[b:_.*]] = copy (*[[a]]); let a = &raw mut *multiple; multiple = &raw mut *single; @@ -623,7 +623,7 @@ fn reference_propagation_mut_ptr(single: *mut T, mut multiple: *mut T) // CHECK: [[b:_.*]] = &raw mut [[a]]; // CHECK: [[d:_.*]] = &[[b]]; // FIXME this could be [[a]] - // CHECK: [[c:_.*]] = (*[[b]]); + // CHECK: [[c:_.*]] = copy (*[[b]]); let mut a = 5_usize; let b = &raw mut a; @@ -639,7 +639,7 @@ fn reference_propagation_mut_ptr(single: *mut T, mut multiple: *mut T) // CHECK: [[b:_.*]] = &raw mut [[a]]; // CHECK: [[d:_.*]] = &mut [[b]]; // FIXME this could be [[a]] - // CHECK: [[c:_.*]] = (*[[b]]); + // CHECK: [[c:_.*]] = copy (*[[b]]); let mut a = 5_usize; let mut b = &raw mut a; @@ -653,8 +653,8 @@ fn reference_propagation_mut_ptr(single: *mut T, mut multiple: *mut T) fn read_through_raw(x: &mut usize) -> usize { // CHECK-LABEL: read_through_raw // CHECK: bb0: { - // CHECK-NEXT: _0 = (*_1); - // CHECK-NEXT: _0 = (*_1); + // CHECK-NEXT: _0 = copy (*_1); + // CHECK-NEXT: _0 = copy (*_1); // CHECK-NEXT: return; use std::intrinsics::mir::*; @@ -680,7 +680,7 @@ fn read_through_raw(x: &mut usize) -> usize { #[custom_mir(dialect = "runtime", phase = "post-cleanup")] fn multiple_storage() { // CHECK-LABEL: multiple_storage - // CHECK: _3 = (*_2); + // CHECK: _3 = copy (*_2); use std::intrinsics::mir::*; mir! { @@ -706,7 +706,7 @@ fn multiple_storage() { #[custom_mir(dialect = "runtime", phase = "post-cleanup")] fn dominate_storage() { // CHECK-LABEL: dominate_storage - // CHECK: _5 = (*_2); + // CHECK: _5 = copy (*_2); use std::intrinsics::mir::*; mir! { @@ -798,12 +798,12 @@ fn unique_with_copies() { // CHECK: [[a:_.*]] = const 0_i32; // CHECK: [[x:_.*]] = &raw mut [[a]]; // CHECK-NOT: [[a]] - // CHECK: [[tmp:_.*]] = (*[[x]]); + // CHECK: [[tmp:_.*]] = copy (*[[x]]); // CHECK-NEXT: opaque::(move [[tmp]]) // CHECK-NOT: [[a]] // CHECK: StorageDead([[a]]); // CHECK-NOT: [[a]] - // CHECK: [[tmp:_.*]] = (*[[x]]); + // CHECK: [[tmp:_.*]] = copy (*[[x]]); // CHECK-NEXT: opaque::(move [[tmp]]) let y = { diff --git a/tests/mir-opt/simplify_dead_blocks.rs b/tests/mir-opt/simplify_dead_blocks.rs index b9a404fd35c8..7f2134c61218 100644 --- a/tests/mir-opt/simplify_dead_blocks.rs +++ b/tests/mir-opt/simplify_dead_blocks.rs @@ -10,7 +10,7 @@ use std::intrinsics::mir::*; pub unsafe fn assert_nonzero_nonmax(x: u8) -> u8 { // CHECK-LABEL: fn assert_nonzero_nonmax( // CHECK: bb0: { - // CHECK-NEXT: switchInt({{.*}}) -> [0: [[unreachable:bb.*]], 1: [[retblock2:bb.*]], 255: [[unreachable:bb.*]], otherwise: [[retblock:bb.*]]]; + // CHECK-NEXT: switchInt(copy {{_[0-9]+}}) -> [0: [[unreachable:bb.*]], 1: [[retblock2:bb.*]], 255: [[unreachable:bb.*]], otherwise: [[retblock:bb.*]]]; // CHECK-NEXT: } // CHECK-NOT: _0 = const 1_u8; // CHECK: [[retblock2]]: { @@ -21,7 +21,7 @@ pub unsafe fn assert_nonzero_nonmax(x: u8) -> u8 { // CHECK-NEXT: unreachable; // CHECK-NEXT: } // CHECK: [[retblock]]: { - // CHECK-NEXT: _0 = _1; + // CHECK-NEXT: _0 = copy _1; // CHECK-NEXT: return; // CHECK-NEXT: } mir! { diff --git a/tests/mir-opt/sroa/structs.rs b/tests/mir-opt/sroa/structs.rs index a177dbf71cf1..d5f13f8b0090 100644 --- a/tests/mir-opt/sroa/structs.rs +++ b/tests/mir-opt/sroa/structs.rs @@ -31,8 +31,8 @@ pub fn enums(a: usize) -> usize { // CHECK: bb0: { // CHECK: [[enum]] = Option::::Some - // CHECK: _5 = (([[enum]] as Some).0: usize) - // CHECK: _0 = _5 + // CHECK: _5 = copy (([[enum]] as Some).0: usize) + // CHECK: _0 = copy _5 if let Some(a) = Some(a) { a } else { 0 } } @@ -51,13 +51,13 @@ pub fn structs(a: f32) -> f32 { // CHECK: bb0: { // CHECK-NOT: [[struct]] - // CHECK: [[a_tmp]] = _1; + // CHECK: [[a_tmp]] = copy _1; // CHECK-NOT: [[struct]] // CHECK: [[foo]] = const 0_usize; // CHECK-NOT: [[struct]] // CHECK: [[a_ret]] = move [[a_tmp]]; // CHECK-NOT: [[struct]] - // CHECK: _0 = [[a_ret]]; + // CHECK: _0 = copy [[a_ret]]; // CHECK-NOT: [[struct]] U { _foo: 0, a }.a } @@ -73,7 +73,7 @@ pub fn unions(a: f32) -> u32 { // CHECK: bb0: { // CHECK: [[union]] = Repr { - // CHECK: _0 = ([[union]].1: u32) + // CHECK: _0 = copy ([[union]].1: u32) unsafe { Repr { f: a }.u } } @@ -156,10 +156,10 @@ fn copies(x: Foo) { // CHECK: [[opt_isize:_[0-9]+]]: std::option::Option; // CHECK: bb0: { - // CHECK: [[byte]] = ([[external]].0 - // CHECK: [[unit]] = ([[external]].1 - // CHECK: [[str]] = ([[external]].2 - // CHECK: [[opt_isize]] = ([[external]].3 + // CHECK: [[byte]] = copy ([[external]].0 + // CHECK: [[unit]] = copy ([[external]].1 + // CHECK: [[str]] = copy ([[external]].2 + // CHECK: [[opt_isize]] = copy ([[external]].3 let y = x; let t = y.a; @@ -181,10 +181,10 @@ fn ref_copies(x: &Foo) { // CHECK: [[opt_isize:_[0-9]+]]: std::option::Option; // CHECK: bb0: { - // CHECK: [[byte]] = ((*[[external]]).0 - // CHECK: [[unit]] = ((*[[external]]).1 - // CHECK: [[str]] = ((*[[external]]).2 - // CHECK: [[opt_isize]] = ((*[[external]]).3 + // CHECK: [[byte]] = copy ((*[[external]]).0 + // CHECK: [[unit]] = copy ((*[[external]]).1 + // CHECK: [[str]] = copy ((*[[external]]).2 + // CHECK: [[opt_isize]] = copy ((*[[external]]).3 let y = *x; let t = y.a; From 99cb0c6bc399fb94a0ddde7e9b38e9c00d523bad Mon Sep 17 00:00:00 2001 From: Scott McMurray Date: Sun, 18 Aug 2024 14:26:34 -0700 Subject: [PATCH 72/79] Bless *all* the mir-opt tests --- ..._of_reborrow.SimplifyCfg-initial.after.mir | 12 +- ...fg-pre-optimizations.after.panic-abort.mir | 8 +- ...g-pre-optimizations.after.panic-unwind.mir | 8 +- ...ure#0}.coroutine_by_move.0.panic-abort.mir | 2 +- ...re#0}.coroutine_by_move.0.panic-unwind.mir | 2 +- ...ure#0}.coroutine_by_move.0.panic-abort.mir | 2 +- ...re#0}.coroutine_by_move.0.panic-unwind.mir | 2 +- ...coroutine_closure_by_ref.0.panic-abort.mir | 2 +- ...oroutine_closure_by_ref.0.panic-unwind.mir | 2 +- .../basic_assignment.main.ElaborateDrops.diff | 2 +- ...ignment.main.SimplifyCfg-initial.after.mir | 2 +- ...await.b-{closure#0}.coroutine_resume.0.mir | 12 +- .../aggregate_exprs.adt.built.after.mir | 4 +- .../aggregate_exprs.array.built.after.mir | 2 +- ...rbitrary_let.arbitrary_let.built.after.mir | 6 +- .../custom/arrays.arrays.built.after.mir | 2 +- .../as_cast.float_to_int.built.after.mir | 2 +- .../custom/as_cast.int_to_int.built.after.mir | 2 +- .../custom/as_cast.int_to_ptr.built.after.mir | 2 +- .../assume.assume_local.built.after.mir | 2 +- .../assume.assume_place.built.after.mir | 2 +- .../custom/enums.switch_bool.built.after.mir | 2 +- .../enums.switch_option.built.after.mir | 2 +- .../enums.switch_option_repr.built.after.mir | 2 +- .../custom/operators.f.built.after.mir | 40 +- .../custom/operators.g.runtime.after.mir | 4 +- ...projections.copy_for_deref.built.after.mir | 2 +- .../projections.simple_index.built.after.mir | 4 +- .../custom/projections.tuples.built.after.mir | 4 +- .../custom/projections.unions.built.after.mir | 2 +- .../custom/projections.unwrap.built.after.mir | 2 +- .../projections.unwrap_deref.built.after.mir | 2 +- ...erences.raw_pointer_offset.built.after.mir | 2 +- .../simple_assign.simple.built.after.mir | 4 +- ...terminators.assert_nonzero.built.after.mir | 2 +- .../terminators.direct_call.built.after.mir | 2 +- .../terminators.indirect_call.built.after.mir | 2 +- .../terminators.tail_call.built.after.mir | 4 +- .../building/enum_cast.bar.built.after.mir | 4 +- .../building/enum_cast.boo.built.after.mir | 4 +- .../building/enum_cast.droppy.built.after.mir | 4 +- .../building/enum_cast.far.built.after.mir | 4 +- .../enum_cast.offsetty.built.after.mir | 6 +- .../building/enum_cast.signy.built.after.mir | 6 +- .../building/eq_never_type._f.built.after.mir | 4 +- .../issue_101867.main.built.after.mir | 2 +- .../building/issue_49232.main.built.after.mir | 2 +- ...n_conditional.test_complex.built.after.mir | 4 +- ..._or_in_conditional.test_or.built.after.mir | 4 +- .../string.foo.PreCodegen.after.mir | 4 +- ....match_tuple.SimplifyCfg-initial.after.mir | 20 +- ...se_edges.full_tested_match.built.after.mir | 8 +- ...e_edges.full_tested_match2.built.after.mir | 8 +- .../match_false_edges.main.built.after.mir | 10 +- .../simple_match.match_bool.built.after.mir | 2 +- ....constant_eq.SimplifyCfg-initial.after.mir | 14 +- ...joint_ranges.SimplifyCfg-initial.after.mir | 12 +- ...ceiver_ptr_mutability.main.built.after.mir | 4 +- .../shifts.shift_signed.built.after.mir | 48 +-- .../shifts.shift_unsigned.built.after.mir | 48 +-- ...hile_loop.PreCodegen.after.panic-abort.mir | 4 +- ...ile_loop.PreCodegen.after.panic-unwind.mir | 4 +- .../const_allocation.main.GVN.after.32bit.mir | 2 +- .../const_allocation.main.GVN.after.64bit.mir | 2 +- ...const_allocation2.main.GVN.after.32bit.mir | 2 +- ...const_allocation2.main.GVN.after.64bit.mir | 2 +- ...const_allocation3.main.GVN.after.32bit.mir | 2 +- ...const_allocation3.main.GVN.after.64bit.mir | 2 +- ..._goto_const_eval_fail.f.JumpThreading.diff | 2 +- .../const_prop/address_of_pair.fn0.GVN.diff | 4 +- .../aggregate.foo.GVN.panic-abort.diff | 12 +- .../aggregate.foo.GVN.panic-unwind.diff | 12 +- .../aggregate.main.GVN.panic-abort.diff | 4 +- .../aggregate.main.GVN.panic-unwind.diff | 4 +- ...rray_index.main.GVN.32bit.panic-abort.diff | 6 +- ...ray_index.main.GVN.32bit.panic-unwind.diff | 6 +- ...rray_index.main.GVN.64bit.panic-abort.diff | 6 +- ...ray_index.main.GVN.64bit.panic-unwind.diff | 6 +- ...d_op_div_by_zero.main.GVN.panic-abort.diff | 8 +- ..._op_div_by_zero.main.GVN.panic-unwind.diff | 8 +- ...d_op_mod_by_zero.main.GVN.panic-abort.diff | 8 +- ..._op_mod_by_zero.main.GVN.panic-unwind.diff | 8 +- ...for_slices.main.GVN.32bit.panic-abort.diff | 10 +- ...or_slices.main.GVN.32bit.panic-unwind.diff | 10 +- ...for_slices.main.GVN.64bit.panic-abort.diff | 10 +- ...or_slices.main.GVN.64bit.panic-unwind.diff | 10 +- .../boolean_identities.test.GVN.diff | 8 +- .../boxes.main.GVN.panic-abort.diff | 8 +- .../boxes.main.GVN.panic-unwind.diff | 8 +- .../discriminant.main.GVN.32bit.diff | 2 +- .../discriminant.main.GVN.64bit.diff | 2 +- .../indirect.main.GVN.panic-abort.diff | 2 +- .../indirect.main.GVN.panic-unwind.diff | 2 +- .../const_prop/indirect_mutation.bar.GVN.diff | 2 +- .../const_prop/indirect_mutation.foo.GVN.diff | 2 +- ...inherit_overflow.main.GVN.panic-abort.diff | 4 +- ...nherit_overflow.main.GVN.panic-unwind.diff | 4 +- .../const_prop/invalid_constant.main.GVN.diff | 4 +- .../invalid_constant.main.RemoveZsts.diff | 6 +- ...rray_index.main.GVN.32bit.panic-abort.diff | 6 +- ...ray_index.main.GVN.32bit.panic-unwind.diff | 6 +- ...rray_index.main.GVN.64bit.panic-abort.diff | 6 +- ...ray_index.main.GVN.64bit.panic-unwind.diff | 6 +- .../const_prop/mult_by_zero.test.GVN.diff | 2 +- .../const_prop/mutable_variable.main.GVN.diff | 2 +- .../mutable_variable_aggregate.main.GVN.diff | 2 +- ...e_variable_aggregate_mut_ref.main.GVN.diff | 2 +- ...ate_partial_read.main.GVN.panic-abort.diff | 2 +- ...te_partial_read.main.GVN.panic-unwind.diff | 2 +- .../mutable_variable_no_prop.main.GVN.diff | 4 +- ...le_unprop_assign.main.GVN.panic-abort.diff | 8 +- ...e_unprop_assign.main.GVN.panic-unwind.diff | 8 +- ...te_with_const_with_params.size_of.GVN.diff | 2 +- ...xpose_provenance.main.GVN.panic-abort.diff | 4 +- ...pose_provenance.main.GVN.panic-unwind.diff | 4 +- .../read_immutable_static.main.GVN.diff | 4 +- .../const_prop/ref_deref.main.GVN.diff | 2 +- .../ref_deref_project.main.GVN.diff | 2 +- .../repeat.main.GVN.32bit.panic-abort.diff | 6 +- .../repeat.main.GVN.32bit.panic-unwind.diff | 6 +- .../repeat.main.GVN.64bit.panic-abort.diff | 6 +- .../repeat.main.GVN.64bit.panic-unwind.diff | 6 +- ...eral_propagation.main.GVN.panic-abort.diff | 2 +- ...ral_propagation.main.GVN.panic-unwind.diff | 2 +- .../slice_len.main.GVN.32bit.panic-abort.diff | 14 +- ...slice_len.main.GVN.32bit.panic-unwind.diff | 14 +- .../slice_len.main.GVN.64bit.panic-abort.diff | 14 +- ...slice_len.main.GVN.64bit.panic-unwind.diff | 14 +- .../switch_int.main.GVN.panic-abort.diff | 2 +- .../switch_int.main.GVN.panic-unwind.diff | 2 +- .../transmute.unreachable_box.GVN.32bit.diff | 2 +- .../transmute.unreachable_box.GVN.64bit.diff | 2 +- ...eral_propagation.main.GVN.panic-abort.diff | 2 +- ...ral_propagation.main.GVN.panic-unwind.diff | 2 +- .../while_let_loops.change_loop_body.GVN.diff | 2 +- ...d_local.borrowed.CopyProp.panic-abort.diff | 8 +- ..._local.borrowed.CopyProp.panic-unwind.diff | 8 +- ....compare_address.CopyProp.panic-abort.diff | 6 +- ...compare_address.CopyProp.panic-unwind.diff | 6 +- ...local.non_freeze.CopyProp.panic-abort.diff | 6 +- ...ocal.non_freeze.CopyProp.panic-unwind.diff | 6 +- .../branch.foo.CopyProp.panic-abort.diff | 6 +- .../branch.foo.CopyProp.panic-unwind.diff | 6 +- .../calls.multiple_edges.CopyProp.diff | 4 +- .../copy-prop/calls.nrvo.CopyProp.diff | 2 +- ...tion_arg.arg_src.CopyProp.panic-abort.diff | 6 +- ...ion_arg.arg_src.CopyProp.panic-unwind.diff | 6 +- ...pagation_arg.bar.CopyProp.panic-abort.diff | 2 +- ...agation_arg.bar.CopyProp.panic-unwind.diff | 2 +- ...pagation_arg.baz.CopyProp.panic-abort.diff | 4 +- ...agation_arg.baz.CopyProp.panic-unwind.diff | 4 +- ...pagation_arg.foo.CopyProp.panic-abort.diff | 2 +- ...agation_arg.foo.CopyProp.panic-unwind.diff | 2 +- ...ustom_move_arg.f.CopyProp.panic-abort.diff | 8 +- ...stom_move_arg.f.CopyProp.panic-unwind.diff | 8 +- .../cycle.main.CopyProp.panic-abort.diff | 10 +- .../cycle.main.CopyProp.panic-unwind.diff | 10 +- ...res_79191.f.CopyProp.after.panic-abort.mir | 6 +- ...es_79191.f.CopyProp.after.panic-unwind.mir | 6 +- ...es_better.f.CopyProp.after.panic-abort.mir | 6 +- ...s_better.f.CopyProp.after.panic-unwind.mir | 6 +- ...ssue_107511.main.CopyProp.panic-abort.diff | 18 +- ...sue_107511.main.CopyProp.panic-unwind.diff | 18 +- .../move_arg.f.CopyProp.panic-abort.diff | 8 +- .../move_arg.f.CopyProp.panic-unwind.diff | 8 +- ...ove_projection.f.CopyProp.panic-abort.diff | 6 +- ...ve_projection.f.CopyProp.panic-unwind.diff | 6 +- .../mutate_through_pointer.f.CopyProp.diff | 4 +- .../copy-prop/non_dominate.f.CopyProp.diff | 8 +- ...reborrow.demiraw.CopyProp.panic-abort.diff | 6 +- ...eborrow.demiraw.CopyProp.panic-unwind.diff | 6 +- .../reborrow.miraw.CopyProp.panic-abort.diff | 6 +- .../reborrow.miraw.CopyProp.panic-unwind.diff | 6 +- ...ch_match_arms.main.InstrumentCoverage.diff | 16 +- .../aggregate_copy.foo.DataflowConstProp.diff | 8 +- ...n.DataflowConstProp.32bit.panic-abort.diff | 8 +- ....DataflowConstProp.32bit.panic-unwind.diff | 8 +- ...n.DataflowConstProp.64bit.panic-abort.diff | 8 +- ....DataflowConstProp.64bit.panic-unwind.diff | 8 +- ...ean_identities.test.DataflowConstProp.diff | 4 +- .../cast.main.DataflowConstProp.diff | 2 +- ...ed.main.DataflowConstProp.panic-abort.diff | 10 +- ...d.main.DataflowConstProp.panic-unwind.diff | 10 +- ...oxed_slice.main.GVN.32bit.panic-abort.diff | 10 +- ...xed_slice.main.GVN.32bit.panic-unwind.diff | 10 +- ...oxed_slice.main.GVN.64bit.panic-abort.diff | 10 +- ...xed_slice.main.GVN.64bit.panic-unwind.diff | 10 +- ...enum.constant.DataflowConstProp.32bit.diff | 8 +- ...enum.constant.DataflowConstProp.64bit.diff | 8 +- ...enum.multiple.DataflowConstProp.32bit.diff | 10 +- ...enum.multiple.DataflowConstProp.64bit.diff | 10 +- ..._discriminant.DataflowConstProp.32bit.diff | 2 +- ..._discriminant.DataflowConstProp.64bit.diff | 2 +- .../enum.simple.DataflowConstProp.32bit.diff | 8 +- .../enum.simple.DataflowConstProp.64bit.diff | 8 +- .../enum.statics.DataflowConstProp.32bit.diff | 14 +- .../enum.statics.DataflowConstProp.64bit.diff | 14 +- .../if.main.DataflowConstProp.diff | 12 +- ...ow.main.DataflowConstProp.panic-abort.diff | 4 +- ...w.main.DataflowConstProp.panic-unwind.diff | 4 +- ...n.DataflowConstProp.32bit.panic-abort.diff | 8 +- ....DataflowConstProp.32bit.panic-unwind.diff | 8 +- ...n.DataflowConstProp.64bit.panic-abort.diff | 8 +- ....DataflowConstProp.64bit.panic-unwind.diff | 8 +- .../mult_by_zero.test.DataflowConstProp.diff | 2 +- ...sb.main.DataflowConstProp.panic-abort.diff | 2 +- ...b.main.DataflowConstProp.panic-unwind.diff | 2 +- ...n.DataflowConstProp.32bit.panic-abort.diff | 8 +- ....DataflowConstProp.32bit.panic-unwind.diff | 8 +- ...n.DataflowConstProp.64bit.panic-abort.diff | 8 +- ....DataflowConstProp.64bit.panic-unwind.diff | 8 +- ...pr_transparent.main.DataflowConstProp.diff | 4 +- .../self_assign.main.DataflowConstProp.diff | 8 +- ...elf_assign_add.main.DataflowConstProp.diff | 4 +- ...tr.main.DataflowConstProp.panic-abort.diff | 4 +- ...r.main.DataflowConstProp.panic-unwind.diff | 4 +- ...n.DataflowConstProp.32bit.panic-abort.diff | 20 +- ....DataflowConstProp.32bit.panic-unwind.diff | 20 +- ...n.DataflowConstProp.64bit.panic-abort.diff | 20 +- ....DataflowConstProp.64bit.panic-unwind.diff | 20 +- .../struct.main.DataflowConstProp.32bit.diff | 42 +-- .../struct.main.DataflowConstProp.64bit.diff | 42 +-- ...or.main.DataflowConstProp.panic-abort.diff | 2 +- ...r.main.DataflowConstProp.panic-unwind.diff | 2 +- ...reachable_box.DataflowConstProp.32bit.diff | 2 +- ...reachable_box.DataflowConstProp.64bit.diff | 2 +- .../tuple.main.DataflowConstProp.32bit.diff | 16 +- .../tuple.main.DataflowConstProp.64bit.diff | 16 +- ...eadStoreElimination-final.panic-abort.diff | 2 +- ...adStoreElimination-final.panic-unwind.diff | 2 +- ...eadStoreElimination-final.panic-abort.diff | 4 +- ...adStoreElimination-final.panic-unwind.diff | 4 +- ...le.cycle.DeadStoreElimination-initial.diff | 10 +- ...r_to_int.DeadStoreElimination-initial.diff | 4 +- ...mment_2.DeduplicateBlocks.panic-abort.diff | 22 +- ...ment_2.DeduplicateBlocks.panic-unwind.diff | 22 +- ...complex_case.main.Derefer.panic-abort.diff | 6 +- ...omplex_case.main.Derefer.panic-unwind.diff | 6 +- ...minator_test.main.Derefer.panic-abort.diff | 4 +- ...inator_test.main.Derefer.panic-unwind.diff | 4 +- ...oo.DestinationPropagation.panic-abort.diff | 6 +- ...o.DestinationPropagation.panic-unwind.diff | 6 +- ...rc.DestinationPropagation.panic-abort.diff | 6 +- ...c.DestinationPropagation.panic-unwind.diff | 6 +- ...ar.DestinationPropagation.panic-abort.diff | 2 +- ...r.DestinationPropagation.panic-unwind.diff | 2 +- ...az.DestinationPropagation.panic-abort.diff | 4 +- ...z.DestinationPropagation.panic-unwind.diff | 4 +- ...oo.DestinationPropagation.panic-abort.diff | 2 +- ...o.DestinationPropagation.panic-unwind.diff | 2 +- ...in.DestinationPropagation.panic-abort.diff | 8 +- ...n.DestinationPropagation.panic-unwind.diff | 8 +- ...stinationPropagation.after.panic-abort.mir | 2 +- ...tinationPropagation.after.panic-unwind.mir | 2 +- ...stinationPropagation.after.panic-abort.mir | 2 +- ...tinationPropagation.after.panic-unwind.mir | 2 +- ...vo.DestinationPropagation.panic-abort.diff | 4 +- ...o.DestinationPropagation.panic-unwind.diff | 4 +- ...in.DestinationPropagation.panic-abort.diff | 2 +- ...n.DestinationPropagation.panic-unwind.diff | 2 +- ...wise_branch.opt1.EarlyOtherwiseBranch.diff | 8 +- ...wise_branch.opt2.EarlyOtherwiseBranch.diff | 8 +- ...wise_branch.opt3.EarlyOtherwiseBranch.diff | 8 +- ...wise_branch.opt4.EarlyOtherwiseBranch.diff | 8 +- ...ement_tuple.opt1.EarlyOtherwiseBranch.diff | 12 +- ...ement_tuple.opt2.EarlyOtherwiseBranch.diff | 10 +- ...ch_68867.try_sum.EarlyOtherwiseBranch.diff | 36 +- ...nch_noopt.noopt1.EarlyOtherwiseBranch.diff | 12 +- ...ess.no_deref_ptr.EarlyOtherwiseBranch.diff | 4 +- .../enum_opt.cand.EnumSizeOpt.32bit.diff | 20 +- .../enum_opt.cand.EnumSizeOpt.64bit.diff | 20 +- .../enum_opt.unin.EnumSizeOpt.32bit.diff | 20 +- .../enum_opt.unin.EnumSizeOpt.64bit.diff | 20 +- ...to_exponential_common.GVN.panic-abort.diff | 32 +- ...o_exponential_common.GVN.panic-unwind.diff | 32 +- .../gvn.arithmetic.GVN.panic-abort.diff | 130 +++---- .../gvn.arithmetic.GVN.panic-unwind.diff | 130 +++---- ...vn.arithmetic_checked.GVN.panic-abort.diff | 50 +-- ...n.arithmetic_checked.GVN.panic-unwind.diff | 50 +-- .../gvn.arithmetic_float.GVN.panic-abort.diff | 40 +- ...gvn.arithmetic_float.GVN.panic-unwind.diff | 40 +- .../mir-opt/gvn.borrowed.GVN.panic-abort.diff | 12 +- .../gvn.borrowed.GVN.panic-unwind.diff | 12 +- tests/mir-opt/gvn.cast.GVN.panic-abort.diff | 60 +-- tests/mir-opt/gvn.cast.GVN.panic-unwind.diff | 60 +-- .../gvn.cast_pointer_eq.GVN.panic-abort.diff | 46 +-- .../gvn.cast_pointer_eq.GVN.panic-unwind.diff | 46 +-- ...ointer_then_transmute.GVN.panic-abort.diff | 10 +- ...inter_then_transmute.GVN.panic-unwind.diff | 10 +- ...ore_aggregate_raw_ptr.GVN.panic-abort.diff | 16 +- ...re_aggregate_raw_ptr.GVN.panic-unwind.diff | 16 +- .../gvn.comparison.GVN.panic-abort.diff | 20 +- .../gvn.comparison.GVN.panic-unwind.diff | 20 +- ...nstant_index_overflow.GVN.panic-abort.diff | 26 +- ...stant_index_overflow.GVN.panic-unwind.diff | 26 +- .../gvn.dereferences.GVN.panic-abort.diff | 36 +- .../gvn.dereferences.GVN.panic-unwind.diff | 36 +- .../gvn.duplicate_slice.GVN.panic-abort.diff | 18 +- .../gvn.duplicate_slice.GVN.panic-unwind.diff | 18 +- .../gvn.fn_pointers.GVN.panic-abort.diff | 20 +- .../gvn.fn_pointers.GVN.panic-unwind.diff | 20 +- ...generic_cast_metadata.GVN.panic-abort.diff | 30 +- ...eneric_cast_metadata.GVN.panic-unwind.diff | 30 +- .../gvn.indirect_static.GVN.panic-abort.diff | 2 +- .../gvn.indirect_static.GVN.panic-unwind.diff | 2 +- ....manual_slice_mut_len.GVN.panic-abort.diff | 8 +- ...manual_slice_mut_len.GVN.panic-unwind.diff | 8 +- ....meta_of_ref_to_slice.GVN.panic-abort.diff | 6 +- ...meta_of_ref_to_slice.GVN.panic-unwind.diff | 6 +- ...gvn.multiple_branches.GVN.panic-abort.diff | 64 ++-- ...vn.multiple_branches.GVN.panic-unwind.diff | 64 ++-- .../gvn.non_freeze.GVN.panic-abort.diff | 8 +- .../gvn.non_freeze.GVN.panic-unwind.diff | 8 +- .../gvn.references.GVN.panic-abort.diff | 6 +- .../gvn.references.GVN.panic-unwind.diff | 6 +- ...ust_change_both_sides.GVN.panic-abort.diff | 6 +- ...st_change_both_sides.GVN.panic-unwind.diff | 6 +- tests/mir-opt/gvn.repeat.GVN.panic-abort.diff | 20 +- .../mir-opt/gvn.repeat.GVN.panic-unwind.diff | 20 +- .../gvn.repeated_index.GVN.panic-abort.diff | 30 +- .../gvn.repeated_index.GVN.panic-unwind.diff | 30 +- ...vn.slice_const_length.GVN.panic-abort.diff | 6 +- ...n.slice_const_length.GVN.panic-unwind.diff | 6 +- ...from_raw_parts_as_ptr.GVN.panic-abort.diff | 16 +- ...rom_raw_parts_as_ptr.GVN.panic-unwind.diff | 16 +- tests/mir-opt/gvn.slices.GVN.panic-abort.diff | 56 +-- .../mir-opt/gvn.slices.GVN.panic-unwind.diff | 56 +-- ...xpression_elimination.GVN.panic-abort.diff | 344 +++++++++--------- ...pression_elimination.GVN.panic-unwind.diff | 344 +++++++++--------- tests/mir-opt/gvn.unary.GVN.panic-abort.diff | 48 +-- tests/mir-opt/gvn.unary.GVN.panic-unwind.diff | 48 +-- .../gvn.wide_ptr_integer.GVN.panic-abort.diff | 24 +- ...gvn.wide_ptr_integer.GVN.panic-unwind.diff | 24 +- ...n.wide_ptr_provenance.GVN.panic-abort.diff | 76 ++-- ....wide_ptr_provenance.GVN.panic-unwind.diff | 76 ++-- ...e_ptr_same_provenance.GVN.panic-abort.diff | 84 ++--- ..._ptr_same_provenance.GVN.panic-unwind.diff | 84 ++--- .../gvn.wrap_unwrap.GVN.panic-abort.diff | 12 +- .../gvn.wrap_unwrap.GVN.panic-unwind.diff | 12 +- tests/mir-opt/gvn_copy_moves.fn0.GVN.diff | 8 +- .../gvn_ptr_eq_with_constant.main.GVN.diff | 8 +- .../gvn_uninhabited.f.GVN.panic-abort.diff | 8 +- .../gvn_uninhabited.f.GVN.panic-unwind.diff | 8 +- ...t_opt_bool.SimplifyComparisonIntegral.diff | 2 +- ...opt_floats.SimplifyComparisonIntegral.diff | 2 +- ...comparison.SimplifyComparisonIntegral.diff | 10 +- ...t.opt_char.SimplifyComparisonIntegral.diff | 2 +- ...int.opt_i8.SimplifyComparisonIntegral.diff | 2 +- ...ltiple_ifs.SimplifyComparisonIntegral.diff | 4 +- ...t_negative.SimplifyComparisonIntegral.diff | 2 +- ...nt.opt_u32.SimplifyComparisonIntegral.diff | 2 +- ...yn_trait.get_query.Inline.panic-abort.diff | 6 +- ...n_trait.get_query.Inline.panic-unwind.diff | 6 +- ...dyn_trait.mk_cycle.Inline.panic-abort.diff | 2 +- ...yn_trait.mk_cycle.Inline.panic-unwind.diff | 2 +- ....try_execute_query.Inline.panic-abort.diff | 2 +- ...try_execute_query.Inline.panic-unwind.diff | 2 +- .../inline_any_operand.bar.Inline.after.mir | 4 +- .../inline_closure.foo.Inline.after.mir | 6 +- ...e_closure_borrows_arg.foo.Inline.after.mir | 6 +- ...line_closure_captures.foo.Inline.after.mir | 10 +- ...ine_coroutine.main.Inline.panic-abort.diff | 8 +- ...ne_coroutine.main.Inline.panic-unwind.diff | 8 +- ...inline_diverging.g.Inline.panic-abort.diff | 4 +- ...nline_diverging.g.Inline.panic-unwind.diff | 4 +- ...inline_diverging.h.Inline.panic-abort.diff | 2 +- ...nline_diverging.h.Inline.panic-unwind.diff | 2 +- ...inline_direct.Inline.after.panic-abort.mir | 2 +- ...nline_direct.Inline.after.panic-unwind.mir | 2 +- ...line_indirect.Inline.after.panic-abort.mir | 2 +- ...ine_indirect.Inline.after.panic-unwind.mir | 2 +- ...ic_not_inline.Inline.after.panic-abort.mir | 4 +- ...c_not_inline.Inline.after.panic-unwind.mir | 4 +- .../inline/inline_retag.bar.Inline.after.mir | 14 +- ...inline_shims.clone.Inline.panic-abort.diff | 2 +- ...nline_shims.clone.Inline.panic-unwind.diff | 2 +- .../inline_shims.drop.Inline.panic-abort.diff | 4 +- ...inline_shims.drop.Inline.panic-unwind.diff | 4 +- ...t_method.test.Inline.after.panic-abort.mir | 2 +- ..._method.test.Inline.after.panic-unwind.mir | 2 +- ...ethod_2.test2.Inline.after.panic-abort.mir | 2 +- ...thod_2.test2.Inline.after.panic-unwind.mir | 2 +- ...issue_106141.outer.Inline.panic-abort.diff | 6 +- ...ssue_106141.outer.Inline.panic-unwind.diff | 6 +- ...67_inline_as_ref_as_mut.a.Inline.after.mir | 8 +- ...67_inline_as_ref_as_mut.b.Inline.after.mir | 10 +- ...67_inline_as_ref_as_mut.c.Inline.after.mir | 6 +- ...67_inline_as_ref_as_mut.d.Inline.after.mir | 8 +- ...l_unsigned_smaller.Inline.panic-abort.diff | 8 +- ..._unsigned_smaller.Inline.panic-unwind.diff | 8 +- ...d_smaller.PreCodegen.after.panic-abort.mir | 2 +- ..._smaller.PreCodegen.after.panic-unwind.mir | 2 +- ..._shr_signed_bigger.Inline.panic-abort.diff | 8 +- ...shr_signed_bigger.Inline.panic-unwind.diff | 8 +- ...ed_bigger.PreCodegen.after.panic-abort.mir | 2 +- ...d_bigger.PreCodegen.after.panic-unwind.mir | 2 +- .../unsized_argument.caller.Inline.diff | 2 +- ...d.unwrap_unchecked.Inline.panic-abort.diff | 2 +- ....unwrap_unchecked.Inline.panic-unwind.diff | 2 +- ...unchecked.PreCodegen.after.panic-abort.mir | 2 +- ...nchecked.PreCodegen.after.panic-unwind.mir | 2 +- ...y.run2-{closure#0}.Inline.panic-abort.diff | 10 +- ....run2-{closure#0}.Inline.panic-unwind.diff | 10 +- ..._false.InstSimplify-after-simplifycfg.diff | 2 +- ...q_true.InstSimplify-after-simplifycfg.diff | 2 +- ...lse_eq.InstSimplify-after-simplifycfg.diff | 2 +- ...lse_ne.InstSimplify-after-simplifycfg.diff | 2 +- ..._false.InstSimplify-after-simplifycfg.diff | 2 +- ...e_true.InstSimplify-after-simplifycfg.diff | 2 +- ...rue_eq.InstSimplify-after-simplifycfg.diff | 2 +- ...rue_ne.InstSimplify-after-simplifycfg.diff | 2 +- ...undant.InstSimplify-after-simplifycfg.diff | 6 +- ...ndtrip.InstSimplify-after-simplifycfg.diff | 2 +- ...implify-after-simplifycfg.panic-abort.diff | 20 +- ...mplify-after-simplifycfg.panic-unwind.diff | 20 +- ...implify-after-simplifycfg.panic-abort.diff | 10 +- ...mplify-after-simplifycfg.panic-unwind.diff | 10 +- ...t_zero.InstSimplify-after-simplifycfg.diff | 6 +- ...inters.InstSimplify-after-simplifycfg.diff | 4 +- ...rences.InstSimplify-after-simplifycfg.diff | 4 +- ...hecked.InstSimplify-after-simplifycfg.diff | 4 +- .../issue_101973.inner.GVN.panic-abort.diff | 14 +- .../issue_101973.inner.GVN.panic-unwind.diff | 14 +- ...e_38669.main.SimplifyCfg-initial.after.mir | 2 +- ...41110.main.ElaborateDrops.panic-abort.diff | 2 +- ...1110.main.ElaborateDrops.panic-unwind.diff | 2 +- ...41110.test.ElaborateDrops.panic-abort.diff | 2 +- ...1110.test.ElaborateDrops.panic-unwind.diff | 2 +- ...41888.main.ElaborateDrops.panic-abort.diff | 6 +- ...1888.main.ElaborateDrops.panic-unwind.diff | 6 +- ...test.ElaborateDrops.before.panic-abort.mir | 8 +- ...est.ElaborateDrops.before.panic-unwind.mir | 8 +- tests/mir-opt/issue_72181.bar.built.after.mir | 4 +- tests/mir-opt/issue_72181.foo.built.after.mir | 6 +- .../mir-opt/issue_72181.main.built.after.mir | 6 +- ...implifyComparisonIntegral.panic-abort.diff | 4 +- ...mplifyComparisonIntegral.panic-unwind.diff | 4 +- ...8192.f.InstSimplify-after-simplifycfg.diff | 4 +- tests/mir-opt/issue_91633.foo.built.after.mir | 4 +- tests/mir-opt/issue_91633.fun.built.after.mir | 4 +- .../issue_99325.main.built.after.32bit.mir | 8 +- .../issue_99325.main.built.after.64bit.mir | 8 +- ..._to_digit.PreCodegen.after.panic-abort.mir | 2 +- ...to_digit.PreCodegen.after.panic-unwind.mir | 2 +- ...e_75439.foo.MatchBranchSimplification.diff | 12 +- ...g.aggregate.JumpThreading.panic-abort.diff | 10 +- ....aggregate.JumpThreading.panic-unwind.diff | 10 +- ...regate_copy.JumpThreading.panic-abort.diff | 8 +- ...egate_copy.JumpThreading.panic-unwind.diff | 8 +- ...ding.assume.JumpThreading.panic-abort.diff | 6 +- ...ing.assume.JumpThreading.panic-unwind.diff | 6 +- ...ustom_discr.JumpThreading.panic-abort.diff | 2 +- ...stom_discr.JumpThreading.panic-unwind.diff | 2 +- ...ppearing_bb.JumpThreading.panic-abort.diff | 6 +- ...pearing_bb.JumpThreading.panic-unwind.diff | 6 +- ...icate_chain.JumpThreading.panic-abort.diff | 4 +- ...cate_chain.JumpThreading.panic-unwind.diff | 4 +- ...ding.floats.JumpThreading.panic-abort.diff | 2 +- ...ing.floats.JumpThreading.panic-unwind.diff | 2 +- ...ng.identity.JumpThreading.panic-abort.diff | 14 +- ...g.identity.JumpThreading.panic-unwind.diff | 14 +- ...tiple_match.JumpThreading.panic-abort.diff | 12 +- ...iple_match.JumpThreading.panic-unwind.diff | 12 +- ...mutable_ref.JumpThreading.panic-abort.diff | 2 +- ...utable_ref.JumpThreading.panic-unwind.diff | 2 +- ...iscriminant.JumpThreading.panic-abort.diff | 2 +- ...scriminant.JumpThreading.panic-unwind.diff | 2 +- ...numbered_bb.JumpThreading.panic-abort.diff | 10 +- ...umbered_bb.JumpThreading.panic-unwind.diff | 10 +- ...too_complex.JumpThreading.panic-abort.diff | 14 +- ...oo_complex.JumpThreading.panic-unwind.diff | 14 +- ...array_len.array_bound.GVN.panic-abort.diff | 20 +- ...rray_len.array_bound.GVN.panic-unwind.diff | 20 +- ...y_len.array_bound_mut.GVN.panic-abort.diff | 24 +- ..._len.array_bound_mut.GVN.panic-unwind.diff | 24 +- ...erlapping.LowerIntrinsics.panic-abort.diff | 4 +- ...rlapping.LowerIntrinsics.panic-unwind.diff | 4 +- ..._metadata.LowerIntrinsics.panic-abort.diff | 6 +- ...metadata.LowerIntrinsics.panic-unwind.diff | 6 +- ..._pointers.LowerIntrinsics.panic-abort.diff | 12 +- ...pointers.LowerIntrinsics.panic-unwind.diff | 12 +- ...non_const.LowerIntrinsics.panic-abort.diff | 2 +- ...on_const.LowerIntrinsics.panic-unwind.diff | 2 +- ...tr_offset.LowerIntrinsics.panic-abort.diff | 4 +- ...r_offset.LowerIntrinsics.panic-unwind.diff | 4 +- ...primitive.LowerIntrinsics.panic-abort.diff | 2 +- ...rimitive.LowerIntrinsics.panic-unwind.diff | 2 +- ...inhabited.LowerIntrinsics.panic-abort.diff | 2 +- ...nhabited.LowerIntrinsics.panic-unwind.diff | 2 +- ...pare_char.LowerIntrinsics.panic-abort.diff | 4 +- ...are_char.LowerIntrinsics.panic-unwind.diff | 4 +- ...re_signed.LowerIntrinsics.panic-abort.diff | 4 +- ...e_signed.LowerIntrinsics.panic-unwind.diff | 4 +- ..._unsigned.LowerIntrinsics.panic-abort.diff | 4 +- ...unsigned.LowerIntrinsics.panic-unwind.diff | 4 +- ...inhabited.LowerIntrinsics.panic-abort.diff | 2 +- ...nhabited.LowerIntrinsics.panic-unwind.diff | 2 +- ...e_ref_dst.LowerIntrinsics.panic-abort.diff | 2 +- ..._ref_dst.LowerIntrinsics.panic-unwind.diff | 2 +- ...inhabited.LowerIntrinsics.panic-abort.diff | 2 +- ...nhabited.LowerIntrinsics.panic-unwind.diff | 2 +- ...inhabited.LowerIntrinsics.panic-abort.diff | 2 +- ...nhabited.LowerIntrinsics.panic-unwind.diff | 2 +- ...unchecked.LowerIntrinsics.panic-abort.diff | 36 +- ...nchecked.LowerIntrinsics.panic-unwind.diff | 36 +- ..._overflow.LowerIntrinsics.panic-abort.diff | 12 +- ...overflow.LowerIntrinsics.panic-unwind.diff | 12 +- ....wrapping.LowerIntrinsics.panic-abort.diff | 12 +- ...wrapping.LowerIntrinsics.panic-unwind.diff | 12 +- ....bound.LowerSliceLenCalls.panic-abort.diff | 10 +- ...bound.LowerSliceLenCalls.panic-unwind.diff | 10 +- ...fg-initial.after-ElaborateDrops.after.diff | 28 +- ...fg-initial.after-ElaborateDrops.after.diff | 28 +- ...ranches.bar.MatchBranchSimplification.diff | 16 +- ...ranches.foo.MatchBranchSimplification.diff | 2 +- ...h_i128_u128.MatchBranchSimplification.diff | 2 +- ...h_nested_if.MatchBranchSimplification.diff | 10 +- ...sext_i8_i16.MatchBranchSimplification.diff | 2 +- ...sext_i8_u16.MatchBranchSimplification.diff | 2 +- ...runc_i16_i8.MatchBranchSimplification.diff | 2 +- ...runc_i16_u8.MatchBranchSimplification.diff | 2 +- ...runc_u16_i8.MatchBranchSimplification.diff | 2 +- ...runc_u16_u8.MatchBranchSimplification.diff | 2 +- ...match_u8_i8.MatchBranchSimplification.diff | 2 +- ...tch_u8_i8_2.MatchBranchSimplification.diff | 8 +- ...i8_2_failed.MatchBranchSimplification.diff | 4 +- ...ailed_len_1.MatchBranchSimplification.diff | 2 +- ...ailed_len_2.MatchBranchSimplification.diff | 2 +- ...zext_u8_i16.MatchBranchSimplification.diff | 2 +- ...zext_u8_u16.MatchBranchSimplification.diff | 2 +- ...stive_match.MatchBranchSimplification.diff | 2 +- ...ve_match_i8.MatchBranchSimplification.diff | 2 +- ...egion_subtyping_basic.main.nll.0.32bit.mir | 8 +- ...egion_subtyping_basic.main.nll.0.64bit.mir | 8 +- ...ompile_111005.wrong.RenameReturnPlace.diff | 6 +- ...le.nrvo.RenameReturnPlace.panic-abort.diff | 4 +- ...e.nrvo.RenameReturnPlace.panic-unwind.diff | 4 +- ...ut_second_or.SimplifyCfg-initial.after.mir | 24 +- ...le_switchint.SimplifyCfg-initial.after.mir | 8 +- ...ned_comparison.bitand.PreCodegen.after.mir | 20 +- ...ined_comparison.naive.PreCodegen.after.mir | 20 +- ..._comparison.returning.PreCodegen.after.mir | 20 +- ...ecked_shl.PreCodegen.after.panic-abort.mir | 4 +- ...cked_shl.PreCodegen.after.panic-unwind.mir | 4 +- ...p_forward.PreCodegen.after.panic-abort.mir | 12 +- ..._forward.PreCodegen.after.panic-unwind.mir | 12 +- ....{impl#0}-partial_cmp.PreCodegen.after.mir | 12 +- ...d_constant.main.GVN.32bit.panic-abort.diff | 14 +- ..._constant.main.GVN.32bit.panic-unwind.diff | 12 +- ...d_constant.main.GVN.64bit.panic-abort.diff | 14 +- ..._constant.main.GVN.64bit.panic-unwind.diff | 12 +- .../loops.filter_mapped.PreCodegen.after.mir | 2 +- .../loops.int_range.PreCodegen.after.mir | 16 +- .../loops.mapped.PreCodegen.after.mir | 4 +- ...l_replace.PreCodegen.after.panic-abort.mir | 4 +- ..._replace.PreCodegen.after.panic-unwind.mir | 4 +- ...m_replace.PreCodegen.after.panic-abort.mir | 4 +- ..._replace.PreCodegen.after.panic-unwind.mir | 4 +- ..._clone.{impl#0}-clone.PreCodegen.after.mir | 2 +- ...o_variable.main.GVN.32bit.panic-abort.diff | 8 +- ..._variable.main.GVN.32bit.panic-unwind.diff | 8 +- ...o_variable.main.GVN.64bit.panic-abort.diff | 8 +- ..._variable.main.GVN.64bit.panic-unwind.diff | 8 +- ...acementOfAggregates.32bit.panic-abort.diff | 10 +- ...cementOfAggregates.32bit.panic-unwind.diff | 10 +- ...acementOfAggregates.64bit.panic-abort.diff | 10 +- ...cementOfAggregates.64bit.panic-unwind.diff | 10 +- ...e_add_fat.PreCodegen.after.panic-abort.mir | 8 +- ..._add_fat.PreCodegen.after.panic-unwind.mir | 8 +- ..._add_thin.PreCodegen.after.panic-abort.mir | 6 +- ...add_thin.PreCodegen.after.panic-unwind.mir | 6 +- ...ward_loop.PreCodegen.after.panic-abort.mir | 16 +- ...ard_loop.PreCodegen.after.panic-unwind.mir | 16 +- ...sive_loop.PreCodegen.after.panic-abort.mir | 8 +- ...ive_loop.PreCodegen.after.panic-unwind.mir | 8 +- ...iter_next.PreCodegen.after.panic-abort.mir | 10 +- ...ter_next.PreCodegen.after.panic-unwind.mir | 10 +- ...mple_option_map.ezmap.PreCodegen.after.mir | 4 +- ...variant_a-{closure#0}.PreCodegen.after.mir | 26 +- ...variant_b-{closure#0}.PreCodegen.after.mir | 18 +- ...mut_usize.PreCodegen.after.panic-abort.mir | 10 +- ...ut_usize.PreCodegen.after.panic-unwind.mir | 10 +- ...mut_range.PreCodegen.after.panic-abort.mir | 12 +- ...ut_range.PreCodegen.after.panic-unwind.mir | 12 +- ...dex_usize.PreCodegen.after.panic-abort.mir | 6 +- ...ex_usize.PreCodegen.after.panic-unwind.mir | 6 +- ...ked_range.PreCodegen.after.panic-abort.mir | 12 +- ...ed_range.PreCodegen.after.panic-unwind.mir | 12 +- ...ated_loop.PreCodegen.after.panic-abort.mir | 36 +- ...ted_loop.PreCodegen.after.panic-unwind.mir | 26 +- ...ward_loop.PreCodegen.after.panic-abort.mir | 22 +- ...ard_loop.PreCodegen.after.panic-unwind.mir | 22 +- ...ange_loop.PreCodegen.after.panic-abort.mir | 20 +- ...nge_loop.PreCodegen.after.panic-unwind.mir | 20 +- ...erse_loop.PreCodegen.after.panic-abort.mir | 24 +- ...rse_loop.PreCodegen.after.panic-unwind.mir | 24 +- ..._is_empty.PreCodegen.after.panic-abort.mir | 18 +- ...is_empty.PreCodegen.after.panic-unwind.mir | 18 +- ...ans.outer.PreCodegen.after.panic-abort.mir | 2 +- ...ns.outer.PreCodegen.after.panic-unwind.mir | 2 +- .../try_identity.new.PreCodegen.after.mir | 8 +- .../try_identity.old.PreCodegen.after.mir | 4 +- ..._to_slice.PreCodegen.after.panic-abort.mir | 10 +- ...to_slice.PreCodegen.after.panic-unwind.mir | 10 +- ...dominate_storage.ReferencePropagation.diff | 6 +- ..._prop.maybe_dead.ReferencePropagation.diff | 16 +- ...multiple_storage.ReferencePropagation.diff | 4 +- ...raw_then_mut_shr.ReferencePropagation.diff | 10 +- ...read_through_raw.ReferencePropagation.diff | 8 +- ...ence_propagation.ReferencePropagation.diff | 48 +-- ...gation_const_ptr.ReferencePropagation.diff | 52 +-- ..._propagation_mut.ReferencePropagation.diff | 30 +- ...pagation_mut_ptr.ReferencePropagation.diff | 38 +- ...ique_with_copies.ReferencePropagation.diff | 8 +- ...guard.CleanupPostBorrowck.panic-abort.diff | 4 +- ...uard.CleanupPostBorrowck.panic-unwind.diff | 4 +- ...main.RemoveStorageMarkers.panic-abort.diff | 6 +- ...ain.RemoveStorageMarkers.panic-unwind.diff | 6 +- ...s.opt.RemoveUnneededDrops.panic-abort.diff | 2 +- ....opt.RemoveUnneededDrops.panic-unwind.diff | 2 +- ..._copy.RemoveUnneededDrops.panic-abort.diff | 2 +- ...copy.RemoveUnneededDrops.panic-unwind.diff | 2 +- ...fg-pre-optimizations.after.panic-abort.mir | 14 +- ...g-pre-optimizations.after.panic-unwind.mir | 14 +- ...fg-pre-optimizations.after.panic-abort.mir | 2 +- ...g-pre-optimizations.after.panic-unwind.mir | 2 +- ...fg-pre-optimizations.after.panic-abort.mir | 2 +- ...g-pre-optimizations.after.panic-unwind.mir | 2 +- ...fg-pre-optimizations.after.panic-abort.mir | 6 +- ...g-pre-optimizations.after.panic-unwind.mir | 6 +- ...fg-pre-optimizations.after.panic-abort.mir | 2 +- ...g-pre-optimizations.after.panic-unwind.mir | 2 +- ...e_const_switch.identity.JumpThreading.diff | 18 +- ...onst_switch.too_complex.JumpThreading.diff | 14 +- .../set_no_discriminant.f.JumpThreading.diff | 2 +- ...no_discriminant.generic.JumpThreading.diff | 2 +- ...yCfg-after-unreachable-enum-branching.diff | 6 +- ...ance.SimplifyLocals-before-const-prop.diff | 2 +- ...s.t1.SimplifyLocals-before-const-prop.diff | 2 +- ...s.t3.SimplifyLocals-before-const-prop.diff | 2 +- ...s.t4.SimplifyLocals-before-const-prop.diff | 2 +- ....foo.SimplifyLocals-final.panic-abort.diff | 2 +- ...foo.SimplifyLocals-final.panic-unwind.diff | 2 +- ...yLocals-before-const-prop.panic-abort.diff | 4 +- ...Locals-before-const-prop.panic-unwind.diff | 4 +- .../simplify_match.main.GVN.panic-abort.diff | 4 +- .../simplify_match.main.GVN.panic-unwind.diff | 4 +- ...nst_debug.SingleUseConsts.panic-abort.diff | 2 +- ...st_debug.SingleUseConsts.panic-unwind.diff | 2 +- ...tch_const.SingleUseConsts.panic-abort.diff | 2 +- ...ch_const.SingleUseConsts.panic-unwind.diff | 2 +- ...nst_debug.SingleUseConsts.panic-abort.diff | 2 +- ...st_debug.SingleUseConsts.panic-unwind.diff | 2 +- ...[String].AddMovesForPackedDrops.before.mir | 4 +- ...mes.foo.ScalarReplacementOfAggregates.diff | 6 +- ...onstant.ScalarReplacementOfAggregates.diff | 8 +- ....copies.ScalarReplacementOfAggregates.diff | 32 +- ...s.enums.ScalarReplacementOfAggregates.diff | 6 +- ...ts.flat.ScalarReplacementOfAggregates.diff | 16 +- ..._copies.ScalarReplacementOfAggregates.diff | 18 +- ...structs.ScalarReplacementOfAggregates.diff | 6 +- ....unions.ScalarReplacementOfAggregates.diff | 4 +- tests/mir-opt/storage_ranges.main.nll.0.mir | 2 +- ...o_self.test.MatchBranchSimplification.diff | 4 +- ...ll_drops.f.ElaborateDrops.panic-abort.diff | 2 +- ...l_drops.f.ElaborateDrops.panic-unwind.diff | 2 +- ...f_with_arg.ElaborateDrops.panic-abort.diff | 2 +- ..._with_arg.ElaborateDrops.panic-unwind.diff | 2 +- ...d_access.bar.SimplifyCfg-initial.after.mir | 8 +- ...d_access.foo.SimplifyCfg-initial.after.mir | 8 +- ...ch.UnreachablePropagation.panic-abort.diff | 2 +- ...h.UnreachablePropagation.panic-unwind.diff | 2 +- ...et.UnreachablePropagation.panic-abort.diff | 2 +- ...t.UnreachablePropagation.panic-unwind.diff | 2 +- ...in.UnreachablePropagation.panic-abort.diff | 4 +- ...n.UnreachablePropagation.panic-unwind.diff | 4 +- ....UnreachableEnumBranching.panic-abort.diff | 2 +- ...UnreachableEnumBranching.panic-unwind.diff | 2 +- 678 files changed, 3567 insertions(+), 3567 deletions(-) diff --git a/tests/mir-opt/address_of.address_of_reborrow.SimplifyCfg-initial.after.mir b/tests/mir-opt/address_of.address_of_reborrow.SimplifyCfg-initial.after.mir index cb72ad3d2531..be636da4517c 100644 --- a/tests/mir-opt/address_of.address_of_reborrow.SimplifyCfg-initial.after.mir +++ b/tests/mir-opt/address_of.address_of_reborrow.SimplifyCfg-initial.after.mir @@ -140,7 +140,7 @@ fn address_of_reborrow() -> () { StorageLive(_6); _6 = &raw const (*_1); AscribeUserType(_6, o, UserTypeProjection { base: UserType(0), projs: [] }); - _5 = _6; + _5 = copy _6; StorageDead(_6); StorageDead(_5); StorageLive(_7); @@ -153,7 +153,7 @@ fn address_of_reborrow() -> () { _9 = move _10 as *const dyn std::marker::Send (PointerCoercion(Unsize)); StorageDead(_10); AscribeUserType(_9, o, UserTypeProjection { base: UserType(1), projs: [] }); - _8 = _9; + _8 = copy _9; StorageDead(_9); StorageDead(_8); StorageLive(_11); @@ -194,7 +194,7 @@ fn address_of_reborrow() -> () { StorageLive(_22); _22 = &raw const (*_3); AscribeUserType(_22, o, UserTypeProjection { base: UserType(10), projs: [] }); - _21 = _22; + _21 = copy _22; StorageDead(_22); StorageDead(_21); StorageLive(_23); @@ -207,7 +207,7 @@ fn address_of_reborrow() -> () { _25 = move _26 as *const dyn std::marker::Send (PointerCoercion(Unsize)); StorageDead(_26); AscribeUserType(_25, o, UserTypeProjection { base: UserType(11), projs: [] }); - _24 = _25; + _24 = copy _25; StorageDead(_25); StorageDead(_24); StorageLive(_27); @@ -242,7 +242,7 @@ fn address_of_reborrow() -> () { StorageLive(_36); _36 = &raw mut (*_3); AscribeUserType(_36, o, UserTypeProjection { base: UserType(20), projs: [] }); - _35 = _36; + _35 = copy _36; StorageDead(_36); StorageDead(_35); StorageLive(_37); @@ -255,7 +255,7 @@ fn address_of_reborrow() -> () { _39 = move _40 as *mut dyn std::marker::Send (PointerCoercion(Unsize)); StorageDead(_40); AscribeUserType(_39, o, UserTypeProjection { base: UserType(21), projs: [] }); - _38 = _39; + _38 = copy _39; StorageDead(_39); StorageDead(_38); StorageLive(_41); diff --git a/tests/mir-opt/array_index_is_temporary.main.SimplifyCfg-pre-optimizations.after.panic-abort.mir b/tests/mir-opt/array_index_is_temporary.main.SimplifyCfg-pre-optimizations.after.panic-abort.mir index ef51b07827fb..a467987e8861 100644 --- a/tests/mir-opt/array_index_is_temporary.main.SimplifyCfg-pre-optimizations.after.panic-abort.mir +++ b/tests/mir-opt/array_index_is_temporary.main.SimplifyCfg-pre-optimizations.after.panic-abort.mir @@ -33,17 +33,17 @@ fn main() -> () { StorageDead(_4); StorageLive(_5); StorageLive(_6); - _6 = _3; + _6 = copy _3; _5 = foo(move _6) -> [return: bb1, unwind unreachable]; } bb1: { StorageDead(_6); StorageLive(_7); - _7 = _2; + _7 = copy _2; _8 = Len(_1); - _9 = Lt(_7, _8); - assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, _7) -> [success: bb2, unwind unreachable]; + _9 = Lt(copy _7, copy _8); + assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, copy _7) -> [success: bb2, unwind unreachable]; } bb2: { diff --git a/tests/mir-opt/array_index_is_temporary.main.SimplifyCfg-pre-optimizations.after.panic-unwind.mir b/tests/mir-opt/array_index_is_temporary.main.SimplifyCfg-pre-optimizations.after.panic-unwind.mir index d1aa9382a2c5..bd7365543bdc 100644 --- a/tests/mir-opt/array_index_is_temporary.main.SimplifyCfg-pre-optimizations.after.panic-unwind.mir +++ b/tests/mir-opt/array_index_is_temporary.main.SimplifyCfg-pre-optimizations.after.panic-unwind.mir @@ -33,17 +33,17 @@ fn main() -> () { StorageDead(_4); StorageLive(_5); StorageLive(_6); - _6 = _3; + _6 = copy _3; _5 = foo(move _6) -> [return: bb1, unwind continue]; } bb1: { StorageDead(_6); StorageLive(_7); - _7 = _2; + _7 = copy _2; _8 = Len(_1); - _9 = Lt(_7, _8); - assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, _7) -> [success: bb2, unwind continue]; + _9 = Lt(copy _7, copy _8); + assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, copy _7) -> [success: bb2, unwind continue]; } bb2: { diff --git a/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#0}-{closure#0}.coroutine_by_move.0.panic-abort.mir b/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#0}-{closure#0}.coroutine_by_move.0.panic-abort.mir index 1c34955a8d9d..1f5bb551b8e0 100644 --- a/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#0}-{closure#0}.coroutine_by_move.0.panic-abort.mir +++ b/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#0}-{closure#0}.coroutine_by_move.0.panic-abort.mir @@ -22,7 +22,7 @@ yields () bb0: { StorageLive(_3); - _3 = (_1.0: i32); + _3 = copy (_1.0: i32); FakeRead(ForLet(None), _3); StorageLive(_4); _4 = &_3; diff --git a/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#0}-{closure#0}.coroutine_by_move.0.panic-unwind.mir b/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#0}-{closure#0}.coroutine_by_move.0.panic-unwind.mir index 1c34955a8d9d..1f5bb551b8e0 100644 --- a/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#0}-{closure#0}.coroutine_by_move.0.panic-unwind.mir +++ b/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#0}-{closure#0}.coroutine_by_move.0.panic-unwind.mir @@ -22,7 +22,7 @@ yields () bb0: { StorageLive(_3); - _3 = (_1.0: i32); + _3 = copy (_1.0: i32); FakeRead(ForLet(None), _3); StorageLive(_4); _4 = &_3; diff --git a/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}-{closure#0}.coroutine_by_move.0.panic-abort.mir b/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}-{closure#0}.coroutine_by_move.0.panic-abort.mir index 516908144a64..17fa93148064 100644 --- a/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}-{closure#0}.coroutine_by_move.0.panic-abort.mir +++ b/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}-{closure#0}.coroutine_by_move.0.panic-abort.mir @@ -22,7 +22,7 @@ yields () bb0: { StorageLive(_3); - _3 = (_1.0: i32); + _3 = copy (_1.0: i32); FakeRead(ForLet(None), _3); StorageLive(_4); _4 = &_3; diff --git a/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}-{closure#0}.coroutine_by_move.0.panic-unwind.mir b/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}-{closure#0}.coroutine_by_move.0.panic-unwind.mir index 516908144a64..17fa93148064 100644 --- a/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}-{closure#0}.coroutine_by_move.0.panic-unwind.mir +++ b/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}-{closure#0}.coroutine_by_move.0.panic-unwind.mir @@ -22,7 +22,7 @@ yields () bb0: { StorageLive(_3); - _3 = (_1.0: i32); + _3 = copy (_1.0: i32); FakeRead(ForLet(None), _3); StorageLive(_4); _4 = &_3; diff --git a/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}.coroutine_closure_by_ref.0.panic-abort.mir b/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}.coroutine_closure_by_ref.0.panic-abort.mir index ba20c28cd014..3fdc81791dee 100644 --- a/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}.coroutine_closure_by_ref.0.panic-abort.mir +++ b/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}.coroutine_closure_by_ref.0.panic-abort.mir @@ -4,7 +4,7 @@ fn main::{closure#0}::{closure#1}(_1: &{async closure@$DIR/async_closure_shims.r let mut _0: {async closure body@$DIR/async_closure_shims.rs:62:48: 65:10}; bb0: { - _0 = {coroutine@$DIR/async_closure_shims.rs:62:48: 65:10 (#0)} { a: move _2, b: ((*_1).0: &i32) }; + _0 = {coroutine@$DIR/async_closure_shims.rs:62:48: 65:10 (#0)} { a: move _2, b: copy ((*_1).0: &i32) }; return; } } diff --git a/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}.coroutine_closure_by_ref.0.panic-unwind.mir b/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}.coroutine_closure_by_ref.0.panic-unwind.mir index ba20c28cd014..3fdc81791dee 100644 --- a/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}.coroutine_closure_by_ref.0.panic-unwind.mir +++ b/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}.coroutine_closure_by_ref.0.panic-unwind.mir @@ -4,7 +4,7 @@ fn main::{closure#0}::{closure#1}(_1: &{async closure@$DIR/async_closure_shims.r let mut _0: {async closure body@$DIR/async_closure_shims.rs:62:48: 65:10}; bb0: { - _0 = {coroutine@$DIR/async_closure_shims.rs:62:48: 65:10 (#0)} { a: move _2, b: ((*_1).0: &i32) }; + _0 = {coroutine@$DIR/async_closure_shims.rs:62:48: 65:10 (#0)} { a: move _2, b: copy ((*_1).0: &i32) }; return; } } diff --git a/tests/mir-opt/basic_assignment.main.ElaborateDrops.diff b/tests/mir-opt/basic_assignment.main.ElaborateDrops.diff index f187f9597279..2d6adaca19e6 100644 --- a/tests/mir-opt/basic_assignment.main.ElaborateDrops.diff +++ b/tests/mir-opt/basic_assignment.main.ElaborateDrops.diff @@ -27,7 +27,7 @@ _1 = const false; StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; _2 = move _3; StorageDead(_3); StorageLive(_4); diff --git a/tests/mir-opt/basic_assignment.main.SimplifyCfg-initial.after.mir b/tests/mir-opt/basic_assignment.main.SimplifyCfg-initial.after.mir index 5c0d1e9b93ff..d4f0363e4431 100644 --- a/tests/mir-opt/basic_assignment.main.SimplifyCfg-initial.after.mir +++ b/tests/mir-opt/basic_assignment.main.SimplifyCfg-initial.after.mir @@ -31,7 +31,7 @@ fn main() -> () { FakeRead(ForLet(None), _1); StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; _2 = move _3; StorageDead(_3); StorageLive(_4); diff --git a/tests/mir-opt/building/async_await.b-{closure#0}.coroutine_resume.0.mir b/tests/mir-opt/building/async_await.b-{closure#0}.coroutine_resume.0.mir index c0f16ee7ec0b..c1c2fdcfa949 100644 --- a/tests/mir-opt/building/async_await.b-{closure#0}.coroutine_resume.0.mir +++ b/tests/mir-opt/building/async_await.b-{closure#0}.coroutine_resume.0.mir @@ -151,7 +151,7 @@ fn b::{closure#0}(_1: Pin<&mut {async fn body of b()}>, _2: &mut Context<'_>) -> StorageLive(_13); StorageLive(_14); StorageLive(_15); - _15 = _38; + _15 = copy _38; _14 = move _15; goto -> bb6; } @@ -194,8 +194,8 @@ fn b::{closure#0}(_1: Pin<&mut {async fn body of b()}>, _2: &mut Context<'_>) -> bb10: { StorageLive(_17); - _17 = ((_9 as Ready).0: ()); - _3 = _17; + _17 = copy ((_9 as Ready).0: ()); + _3 = copy _17; StorageDead(_17); StorageDead(_14); StorageDead(_12); @@ -253,7 +253,7 @@ fn b::{closure#0}(_1: Pin<&mut {async fn body of b()}>, _2: &mut Context<'_>) -> StorageLive(_29); StorageLive(_30); StorageLive(_31); - _31 = _38; + _31 = copy _38; _30 = move _31; goto -> bb18; } @@ -291,8 +291,8 @@ fn b::{closure#0}(_1: Pin<&mut {async fn body of b()}>, _2: &mut Context<'_>) -> bb21: { StorageLive(_33); - _33 = ((_25 as Ready).0: ()); - _37 = _33; + _33 = copy ((_25 as Ready).0: ()); + _37 = copy _33; StorageDead(_33); StorageDead(_30); StorageDead(_28); diff --git a/tests/mir-opt/building/custom/aggregate_exprs.adt.built.after.mir b/tests/mir-opt/building/custom/aggregate_exprs.adt.built.after.mir index c14882142f56..6d4d261b895a 100644 --- a/tests/mir-opt/building/custom/aggregate_exprs.adt.built.after.mir +++ b/tests/mir-opt/building/custom/aggregate_exprs.adt.built.after.mir @@ -9,8 +9,8 @@ fn adt() -> Onion { bb0: { _1 = const 1_i32; _2 = Foo { a: const 1_i32, b: const 2_i32 }; - _3 = Bar::Foo(move _2, _1); - _0 = Onion { neon: ((_3 as variant#0).1: i32) }; + _3 = Bar::Foo(move _2, copy _1); + _0 = Onion { neon: copy ((_3 as variant#0).1: i32) }; return; } } diff --git a/tests/mir-opt/building/custom/aggregate_exprs.array.built.after.mir b/tests/mir-opt/building/custom/aggregate_exprs.array.built.after.mir index fde007abab0a..2c14258956a9 100644 --- a/tests/mir-opt/building/custom/aggregate_exprs.array.built.after.mir +++ b/tests/mir-opt/building/custom/aggregate_exprs.array.built.after.mir @@ -8,7 +8,7 @@ fn array() -> [i32; 2] { bb0: { _1 = [const 42_i32, const 43_i32]; _2 = const 1_i32; - _1 = [_2, const 2_i32]; + _1 = [copy _2, const 2_i32]; _0 = move _1; return; } diff --git a/tests/mir-opt/building/custom/arbitrary_let.arbitrary_let.built.after.mir b/tests/mir-opt/building/custom/arbitrary_let.arbitrary_let.built.after.mir index 189996f11798..72a16b358852 100644 --- a/tests/mir-opt/building/custom/arbitrary_let.arbitrary_let.built.after.mir +++ b/tests/mir-opt/building/custom/arbitrary_let.arbitrary_let.built.after.mir @@ -6,17 +6,17 @@ fn arbitrary_let(_1: i32) -> i32 { let mut _3: i32; bb0: { - _2 = _1; + _2 = copy _1; goto -> bb2; } bb1: { - _0 = _3; + _0 = copy _3; return; } bb2: { - _3 = _2; + _3 = copy _2; goto -> bb1; } } diff --git a/tests/mir-opt/building/custom/arrays.arrays.built.after.mir b/tests/mir-opt/building/custom/arrays.arrays.built.after.mir index eaeba302f151..30d11e31e4d4 100644 --- a/tests/mir-opt/building/custom/arrays.arrays.built.after.mir +++ b/tests/mir-opt/building/custom/arrays.arrays.built.after.mir @@ -8,7 +8,7 @@ fn arrays() -> usize { bb0: { _1 = [const 5_i32; C]; _2 = Len(_1); - _0 = _2; + _0 = copy _2; return; } } diff --git a/tests/mir-opt/building/custom/as_cast.float_to_int.built.after.mir b/tests/mir-opt/building/custom/as_cast.float_to_int.built.after.mir index e3334bc7dbee..93750719d270 100644 --- a/tests/mir-opt/building/custom/as_cast.float_to_int.built.after.mir +++ b/tests/mir-opt/building/custom/as_cast.float_to_int.built.after.mir @@ -4,7 +4,7 @@ fn float_to_int(_1: f32) -> i32 { let mut _0: i32; bb0: { - _0 = _1 as i32 (FloatToInt); + _0 = copy _1 as i32 (FloatToInt); return; } } diff --git a/tests/mir-opt/building/custom/as_cast.int_to_int.built.after.mir b/tests/mir-opt/building/custom/as_cast.int_to_int.built.after.mir index d71cb9d78d33..9adec45d64b1 100644 --- a/tests/mir-opt/building/custom/as_cast.int_to_int.built.after.mir +++ b/tests/mir-opt/building/custom/as_cast.int_to_int.built.after.mir @@ -4,7 +4,7 @@ fn int_to_int(_1: u32) -> i32 { let mut _0: i32; bb0: { - _0 = _1 as i32 (IntToInt); + _0 = copy _1 as i32 (IntToInt); return; } } diff --git a/tests/mir-opt/building/custom/as_cast.int_to_ptr.built.after.mir b/tests/mir-opt/building/custom/as_cast.int_to_ptr.built.after.mir index faff79e8c578..aa6422580956 100644 --- a/tests/mir-opt/building/custom/as_cast.int_to_ptr.built.after.mir +++ b/tests/mir-opt/building/custom/as_cast.int_to_ptr.built.after.mir @@ -4,7 +4,7 @@ fn int_to_ptr(_1: usize) -> *const i32 { let mut _0: *const i32; bb0: { - _0 = _1 as *const i32 (PointerWithExposedProvenance); + _0 = copy _1 as *const i32 (PointerWithExposedProvenance); return; } } diff --git a/tests/mir-opt/building/custom/assume.assume_local.built.after.mir b/tests/mir-opt/building/custom/assume.assume_local.built.after.mir index 7ea1fcd30c2e..36e2859ce16d 100644 --- a/tests/mir-opt/building/custom/assume.assume_local.built.after.mir +++ b/tests/mir-opt/building/custom/assume.assume_local.built.after.mir @@ -4,7 +4,7 @@ fn assume_local(_1: bool) -> () { let mut _0: (); bb0: { - assume(_1); + assume(copy _1); return; } } diff --git a/tests/mir-opt/building/custom/assume.assume_place.built.after.mir b/tests/mir-opt/building/custom/assume.assume_place.built.after.mir index ce914618d3dc..074af333d63a 100644 --- a/tests/mir-opt/building/custom/assume.assume_place.built.after.mir +++ b/tests/mir-opt/building/custom/assume.assume_place.built.after.mir @@ -4,7 +4,7 @@ fn assume_place(_1: (bool, u8)) -> () { let mut _0: (); bb0: { - assume((_1.0: bool)); + assume(copy (_1.0: bool)); return; } } diff --git a/tests/mir-opt/building/custom/enums.switch_bool.built.after.mir b/tests/mir-opt/building/custom/enums.switch_bool.built.after.mir index f82e5f1c6fd0..beefef331df8 100644 --- a/tests/mir-opt/building/custom/enums.switch_bool.built.after.mir +++ b/tests/mir-opt/building/custom/enums.switch_bool.built.after.mir @@ -4,7 +4,7 @@ fn switch_bool(_1: bool) -> u32 { let mut _0: u32; bb0: { - switchInt(_1) -> [1: bb1, 0: bb2, otherwise: bb2]; + switchInt(copy _1) -> [1: bb1, 0: bb2, otherwise: bb2]; } bb1: { diff --git a/tests/mir-opt/building/custom/enums.switch_option.built.after.mir b/tests/mir-opt/building/custom/enums.switch_option.built.after.mir index fa03f274be34..a854df878668 100644 --- a/tests/mir-opt/building/custom/enums.switch_option.built.after.mir +++ b/tests/mir-opt/building/custom/enums.switch_option.built.after.mir @@ -6,7 +6,7 @@ fn switch_option(_1: Option<()>) -> bool { bb0: { _2 = discriminant(_1); - switchInt(_2) -> [0: bb1, 1: bb2, otherwise: bb2]; + switchInt(copy _2) -> [0: bb1, 1: bb2, otherwise: bb2]; } bb1: { diff --git a/tests/mir-opt/building/custom/enums.switch_option_repr.built.after.mir b/tests/mir-opt/building/custom/enums.switch_option_repr.built.after.mir index eec2197a8bd3..4ffc08772a84 100644 --- a/tests/mir-opt/building/custom/enums.switch_option_repr.built.after.mir +++ b/tests/mir-opt/building/custom/enums.switch_option_repr.built.after.mir @@ -6,7 +6,7 @@ fn switch_option_repr(_1: Bool) -> bool { bb0: { _2 = discriminant(_1); - switchInt(_2) -> [0: bb2, otherwise: bb1]; + switchInt(copy _2) -> [0: bb2, otherwise: bb1]; } bb1: { diff --git a/tests/mir-opt/building/custom/operators.f.built.after.mir b/tests/mir-opt/building/custom/operators.f.built.after.mir index cac82f7b3ea3..ed6cddd548fb 100644 --- a/tests/mir-opt/building/custom/operators.f.built.after.mir +++ b/tests/mir-opt/building/custom/operators.f.built.after.mir @@ -5,26 +5,26 @@ fn f(_1: i32, _2: bool) -> i32 { let mut _3: (i32, bool); bb0: { - _1 = Neg(_1); - _2 = Not(_2); - _1 = Add(_1, _1); - _1 = Sub(_1, _1); - _1 = Mul(_1, _1); - _1 = Div(_1, _1); - _1 = Rem(_1, _1); - _1 = BitXor(_1, _1); - _1 = BitAnd(_1, _1); - _1 = Shl(_1, _1); - _1 = Shr(_1, _1); - _2 = Eq(_1, _1); - _2 = Lt(_1, _1); - _2 = Le(_1, _1); - _2 = Ge(_1, _1); - _2 = Gt(_1, _1); - _3 = AddWithOverflow(_1, _1); - _2 = (_3.1: bool); - _1 = (_3.0: i32); - _0 = _1; + _1 = Neg(copy _1); + _2 = Not(copy _2); + _1 = Add(copy _1, copy _1); + _1 = Sub(copy _1, copy _1); + _1 = Mul(copy _1, copy _1); + _1 = Div(copy _1, copy _1); + _1 = Rem(copy _1, copy _1); + _1 = BitXor(copy _1, copy _1); + _1 = BitAnd(copy _1, copy _1); + _1 = Shl(copy _1, copy _1); + _1 = Shr(copy _1, copy _1); + _2 = Eq(copy _1, copy _1); + _2 = Lt(copy _1, copy _1); + _2 = Le(copy _1, copy _1); + _2 = Ge(copy _1, copy _1); + _2 = Gt(copy _1, copy _1); + _3 = AddWithOverflow(copy _1, copy _1); + _2 = copy (_3.1: bool); + _1 = copy (_3.0: i32); + _0 = copy _1; return; } } diff --git a/tests/mir-opt/building/custom/operators.g.runtime.after.mir b/tests/mir-opt/building/custom/operators.g.runtime.after.mir index a0ad7d0f93f4..7d87fd932783 100644 --- a/tests/mir-opt/building/custom/operators.g.runtime.after.mir +++ b/tests/mir-opt/building/custom/operators.g.runtime.after.mir @@ -6,8 +6,8 @@ fn g(_1: *const i32, _2: *const [i32]) -> () { let mut _4: usize; bb0: { - _3 = PtrMetadata(_1); - _4 = PtrMetadata(_2); + _3 = PtrMetadata(copy _1); + _4 = PtrMetadata(copy _2); return; } } diff --git a/tests/mir-opt/building/custom/projections.copy_for_deref.built.after.mir b/tests/mir-opt/building/custom/projections.copy_for_deref.built.after.mir index b1ba5f9314d5..b28e96f10eae 100644 --- a/tests/mir-opt/building/custom/projections.copy_for_deref.built.after.mir +++ b/tests/mir-opt/building/custom/projections.copy_for_deref.built.after.mir @@ -6,7 +6,7 @@ fn copy_for_deref(_1: (&i32, i32)) -> i32 { bb0: { _2 = deref_copy (_1.0: &i32); - _0 = (*_2); + _0 = copy (*_2); return; } } diff --git a/tests/mir-opt/building/custom/projections.simple_index.built.after.mir b/tests/mir-opt/building/custom/projections.simple_index.built.after.mir index f74c61009d34..2cd781696da7 100644 --- a/tests/mir-opt/building/custom/projections.simple_index.built.after.mir +++ b/tests/mir-opt/building/custom/projections.simple_index.built.after.mir @@ -6,8 +6,8 @@ fn simple_index(_1: [i32; 10], _2: &[i32]) -> i32 { bb0: { _3 = const 3_usize; - _0 = _1[_3]; - _0 = (*_2)[_3]; + _0 = copy _1[_3]; + _0 = copy (*_2)[_3]; return; } } diff --git a/tests/mir-opt/building/custom/projections.tuples.built.after.mir b/tests/mir-opt/building/custom/projections.tuples.built.after.mir index a370de2ed843..d07269cd0d30 100644 --- a/tests/mir-opt/building/custom/projections.tuples.built.after.mir +++ b/tests/mir-opt/building/custom/projections.tuples.built.after.mir @@ -4,8 +4,8 @@ fn tuples(_1: (u32, i32)) -> (u32, i32) { let mut _0: (u32, i32); bb0: { - (_0.0: u32) = (_1.0: u32); - (_0.1: i32) = (_1.1: i32); + (_0.0: u32) = copy (_1.0: u32); + (_0.1: i32) = copy (_1.1: i32); return; } } diff --git a/tests/mir-opt/building/custom/projections.unions.built.after.mir b/tests/mir-opt/building/custom/projections.unions.built.after.mir index 4189b329e8cc..fe4f7acebb52 100644 --- a/tests/mir-opt/building/custom/projections.unions.built.after.mir +++ b/tests/mir-opt/building/custom/projections.unions.built.after.mir @@ -4,7 +4,7 @@ fn unions(_1: U) -> i32 { let mut _0: i32; bb0: { - _0 = (_1.0: i32); + _0 = copy (_1.0: i32); return; } } diff --git a/tests/mir-opt/building/custom/projections.unwrap.built.after.mir b/tests/mir-opt/building/custom/projections.unwrap.built.after.mir index 0c43bdc9d24d..ea706e0a97d2 100644 --- a/tests/mir-opt/building/custom/projections.unwrap.built.after.mir +++ b/tests/mir-opt/building/custom/projections.unwrap.built.after.mir @@ -4,7 +4,7 @@ fn unwrap(_1: Option) -> i32 { let mut _0: i32; bb0: { - _0 = ((_1 as variant#1).0: i32); + _0 = copy ((_1 as variant#1).0: i32); return; } } diff --git a/tests/mir-opt/building/custom/projections.unwrap_deref.built.after.mir b/tests/mir-opt/building/custom/projections.unwrap_deref.built.after.mir index 39e978513438..eb83dcece3e8 100644 --- a/tests/mir-opt/building/custom/projections.unwrap_deref.built.after.mir +++ b/tests/mir-opt/building/custom/projections.unwrap_deref.built.after.mir @@ -4,7 +4,7 @@ fn unwrap_deref(_1: Option<&i32>) -> i32 { let mut _0: i32; bb0: { - _0 = (*((_1 as variant#1).0: &i32)); + _0 = copy (*((_1 as variant#1).0: &i32)); return; } } diff --git a/tests/mir-opt/building/custom/references.raw_pointer_offset.built.after.mir b/tests/mir-opt/building/custom/references.raw_pointer_offset.built.after.mir index 8046b543eefc..3893613bff9f 100644 --- a/tests/mir-opt/building/custom/references.raw_pointer_offset.built.after.mir +++ b/tests/mir-opt/building/custom/references.raw_pointer_offset.built.after.mir @@ -4,7 +4,7 @@ fn raw_pointer_offset(_1: *const i32) -> *const i32 { let mut _0: *const i32; bb0: { - _0 = Offset(_1, const 1_isize); + _0 = Offset(copy _1, const 1_isize); return; } } diff --git a/tests/mir-opt/building/custom/simple_assign.simple.built.after.mir b/tests/mir-opt/building/custom/simple_assign.simple.built.after.mir index 6f7aaeed9799..10ad840f98c5 100644 --- a/tests/mir-opt/building/custom/simple_assign.simple.built.after.mir +++ b/tests/mir-opt/building/custom/simple_assign.simple.built.after.mir @@ -7,14 +7,14 @@ fn simple(_1: i32) -> i32 { bb0: { StorageLive(_2); - _2 = _1; + _2 = copy _1; goto -> bb1; } bb1: { _3 = move _2; StorageDead(_2); - _0 = _3; + _0 = copy _3; return; } } diff --git a/tests/mir-opt/building/custom/terminators.assert_nonzero.built.after.mir b/tests/mir-opt/building/custom/terminators.assert_nonzero.built.after.mir index 9cf26dff3503..44030abc7974 100644 --- a/tests/mir-opt/building/custom/terminators.assert_nonzero.built.after.mir +++ b/tests/mir-opt/building/custom/terminators.assert_nonzero.built.after.mir @@ -4,7 +4,7 @@ fn assert_nonzero(_1: i32) -> () { let mut _0: (); bb0: { - switchInt(_1) -> [0: bb1, otherwise: bb2]; + switchInt(copy _1) -> [0: bb1, otherwise: bb2]; } bb1: { diff --git a/tests/mir-opt/building/custom/terminators.direct_call.built.after.mir b/tests/mir-opt/building/custom/terminators.direct_call.built.after.mir index 07044ceaef44..b29d4ec70957 100644 --- a/tests/mir-opt/building/custom/terminators.direct_call.built.after.mir +++ b/tests/mir-opt/building/custom/terminators.direct_call.built.after.mir @@ -4,7 +4,7 @@ fn direct_call(_1: i32) -> i32 { let mut _0: i32; bb0: { - _0 = ident::(_1) -> [return: bb1, unwind continue]; + _0 = ident::(copy _1) -> [return: bb1, unwind continue]; } bb1: { diff --git a/tests/mir-opt/building/custom/terminators.indirect_call.built.after.mir b/tests/mir-opt/building/custom/terminators.indirect_call.built.after.mir index 3b849354dcd8..b88f66030269 100644 --- a/tests/mir-opt/building/custom/terminators.indirect_call.built.after.mir +++ b/tests/mir-opt/building/custom/terminators.indirect_call.built.after.mir @@ -4,7 +4,7 @@ fn indirect_call(_1: i32, _2: fn(i32) -> i32) -> i32 { let mut _0: i32; bb0: { - _0 = _2(_1) -> [return: bb1, unwind continue]; + _0 = copy _2(copy _1) -> [return: bb1, unwind continue]; } bb1: { diff --git a/tests/mir-opt/building/custom/terminators.tail_call.built.after.mir b/tests/mir-opt/building/custom/terminators.tail_call.built.after.mir index 4cf6e459aa82..ab3925dae1c3 100644 --- a/tests/mir-opt/building/custom/terminators.tail_call.built.after.mir +++ b/tests/mir-opt/building/custom/terminators.tail_call.built.after.mir @@ -5,7 +5,7 @@ fn tail_call(_1: i32) -> i32 { let mut _2: i32; bb0: { - _2 = Add(_1, const 42_i32); - tailcall ident::(Spanned { node: _2, span: $DIR/terminators.rs:32:28: 32:29 (#0) }); + _2 = Add(copy _1, const 42_i32); + tailcall ident::(Spanned { node: copy _2, span: $DIR/terminators.rs:32:28: 32:29 (#0) }); } } diff --git a/tests/mir-opt/building/enum_cast.bar.built.after.mir b/tests/mir-opt/building/enum_cast.bar.built.after.mir index 512c73216198..72d0cf5d1e82 100644 --- a/tests/mir-opt/building/enum_cast.bar.built.after.mir +++ b/tests/mir-opt/building/enum_cast.bar.built.after.mir @@ -12,8 +12,8 @@ fn bar(_1: Bar) -> usize { StorageLive(_2); _2 = move _1; _3 = discriminant(_2); - _4 = _3 as u8 (IntToInt); - _5 = Le(_4, const 1_u8); + _4 = copy _3 as u8 (IntToInt); + _5 = Le(copy _4, const 1_u8); assume(move _5); _0 = move _3 as usize (IntToInt); StorageDead(_2); diff --git a/tests/mir-opt/building/enum_cast.boo.built.after.mir b/tests/mir-opt/building/enum_cast.boo.built.after.mir index ad0adf14e4ac..91e06dc88629 100644 --- a/tests/mir-opt/building/enum_cast.boo.built.after.mir +++ b/tests/mir-opt/building/enum_cast.boo.built.after.mir @@ -12,8 +12,8 @@ fn boo(_1: Boo) -> usize { StorageLive(_2); _2 = move _1; _3 = discriminant(_2); - _4 = _3 as u8 (IntToInt); - _5 = Le(_4, const 1_u8); + _4 = copy _3 as u8 (IntToInt); + _5 = Le(copy _4, const 1_u8); assume(move _5); _0 = move _3 as usize (IntToInt); StorageDead(_2); diff --git a/tests/mir-opt/building/enum_cast.droppy.built.after.mir b/tests/mir-opt/building/enum_cast.droppy.built.after.mir index ea0edb610f5c..f53c9199a494 100644 --- a/tests/mir-opt/building/enum_cast.droppy.built.after.mir +++ b/tests/mir-opt/building/enum_cast.droppy.built.after.mir @@ -31,8 +31,8 @@ fn droppy() -> () { StorageLive(_4); _4 = move _2; _5 = discriminant(_4); - _6 = _5 as u8 (IntToInt); - _7 = Le(_6, const 2_u8); + _6 = copy _5 as u8 (IntToInt); + _7 = Le(copy _6, const 2_u8); assume(move _7); _3 = move _5 as usize (IntToInt); drop(_4) -> [return: bb1, unwind: bb4]; diff --git a/tests/mir-opt/building/enum_cast.far.built.after.mir b/tests/mir-opt/building/enum_cast.far.built.after.mir index e75803c706da..14eaf3441903 100644 --- a/tests/mir-opt/building/enum_cast.far.built.after.mir +++ b/tests/mir-opt/building/enum_cast.far.built.after.mir @@ -12,8 +12,8 @@ fn far(_1: Far) -> isize { StorageLive(_2); _2 = move _1; _3 = discriminant(_2); - _4 = _3 as u16 (IntToInt); - _5 = Le(_4, const 1_u16); + _4 = copy _3 as u16 (IntToInt); + _5 = Le(copy _4, const 1_u16); assume(move _5); _0 = move _3 as isize (IntToInt); StorageDead(_2); diff --git a/tests/mir-opt/building/enum_cast.offsetty.built.after.mir b/tests/mir-opt/building/enum_cast.offsetty.built.after.mir index 282859d7cd01..1c2acbe3023f 100644 --- a/tests/mir-opt/building/enum_cast.offsetty.built.after.mir +++ b/tests/mir-opt/building/enum_cast.offsetty.built.after.mir @@ -14,9 +14,9 @@ fn offsetty(_1: NotStartingAtZero) -> u32 { StorageLive(_2); _2 = move _1; _3 = discriminant(_2); - _4 = _3 as u8 (IntToInt); - _5 = Ge(_4, const 4_u8); - _6 = Le(_4, const 8_u8); + _4 = copy _3 as u8 (IntToInt); + _5 = Ge(copy _4, const 4_u8); + _6 = Le(copy _4, const 8_u8); _7 = BitAnd(move _5, move _6); assume(move _7); _0 = move _3 as u32 (IntToInt); diff --git a/tests/mir-opt/building/enum_cast.signy.built.after.mir b/tests/mir-opt/building/enum_cast.signy.built.after.mir index a9f7d6c78007..39b6dfaf005e 100644 --- a/tests/mir-opt/building/enum_cast.signy.built.after.mir +++ b/tests/mir-opt/building/enum_cast.signy.built.after.mir @@ -14,9 +14,9 @@ fn signy(_1: SignedAroundZero) -> i16 { StorageLive(_2); _2 = move _1; _3 = discriminant(_2); - _4 = _3 as u16 (IntToInt); - _5 = Ge(_4, const 65534_u16); - _6 = Le(_4, const 2_u16); + _4 = copy _3 as u16 (IntToInt); + _5 = Ge(copy _4, const 65534_u16); + _6 = Le(copy _4, const 2_u16); _7 = BitOr(move _5, move _6); assume(move _7); _0 = move _3 as i16 (IntToInt); diff --git a/tests/mir-opt/building/eq_never_type._f.built.after.mir b/tests/mir-opt/building/eq_never_type._f.built.after.mir index 39438258c2eb..4711af46f1c8 100644 --- a/tests/mir-opt/building/eq_never_type._f.built.after.mir +++ b/tests/mir-opt/building/eq_never_type._f.built.after.mir @@ -16,7 +16,7 @@ fn _f(_1: !, _2: !) -> () { StorageLive(_4); StorageLive(_5); StorageLive(_6); - _6 = _1; + _6 = copy _1; unreachable; } @@ -25,7 +25,7 @@ fn _f(_1: !, _2: !) -> () { StorageLive(_7); StorageLive(_8); StorageLive(_9); - _9 = _2; + _9 = copy _2; unreachable; } diff --git a/tests/mir-opt/building/issue_101867.main.built.after.mir b/tests/mir-opt/building/issue_101867.main.built.after.mir index 5c50b3db5cad..34e5bedf4ce9 100644 --- a/tests/mir-opt/building/issue_101867.main.built.after.mir +++ b/tests/mir-opt/building/issue_101867.main.built.after.mir @@ -55,7 +55,7 @@ fn main() -> () { } bb6: { - _5 = ((_1 as Some).0: u8); + _5 = copy ((_1 as Some).0: u8); _0 = const (); StorageDead(_5); StorageDead(_1); diff --git a/tests/mir-opt/building/issue_49232.main.built.after.mir b/tests/mir-opt/building/issue_49232.main.built.after.mir index d09a1748a8b3..b78f6691d54c 100644 --- a/tests/mir-opt/building/issue_49232.main.built.after.mir +++ b/tests/mir-opt/building/issue_49232.main.built.after.mir @@ -25,7 +25,7 @@ fn main() -> () { StorageLive(_3); _3 = const true; PlaceMention(_3); - switchInt(_3) -> [0: bb4, otherwise: bb6]; + switchInt(copy _3) -> [0: bb4, otherwise: bb6]; } bb3: { diff --git a/tests/mir-opt/building/logical_or_in_conditional.test_complex.built.after.mir b/tests/mir-opt/building/logical_or_in_conditional.test_complex.built.after.mir index 3e16efe6980d..72bd4605b264 100644 --- a/tests/mir-opt/building/logical_or_in_conditional.test_complex.built.after.mir +++ b/tests/mir-opt/building/logical_or_in_conditional.test_complex.built.after.mir @@ -54,7 +54,7 @@ fn test_complex() -> () { StorageLive(_6); StorageLive(_7); _7 = Droppy(const 0_u8); - _6 = (_7.0: u8); + _6 = copy (_7.0: u8); _5 = Gt(move _6, const 0_u8); switchInt(move _5) -> [0: bb10, otherwise: bb9]; } @@ -92,7 +92,7 @@ fn test_complex() -> () { StorageLive(_9); StorageLive(_10); _10 = Droppy(const 1_u8); - _9 = (_10.0: u8); + _9 = copy (_10.0: u8); _8 = Gt(move _9, const 1_u8); switchInt(move _8) -> [0: bb16, otherwise: bb15]; } diff --git a/tests/mir-opt/building/logical_or_in_conditional.test_or.built.after.mir b/tests/mir-opt/building/logical_or_in_conditional.test_or.built.after.mir index 3e7c116016cc..2fc19e7e0fdc 100644 --- a/tests/mir-opt/building/logical_or_in_conditional.test_or.built.after.mir +++ b/tests/mir-opt/building/logical_or_in_conditional.test_or.built.after.mir @@ -14,7 +14,7 @@ fn test_or() -> () { StorageLive(_2); StorageLive(_3); _3 = Droppy(const 0_u8); - _2 = (_3.0: u8); + _2 = copy (_3.0: u8); _1 = Gt(move _2, const 0_u8); switchInt(move _1) -> [0: bb2, otherwise: bb1]; } @@ -44,7 +44,7 @@ fn test_or() -> () { StorageLive(_5); StorageLive(_6); _6 = Droppy(const 1_u8); - _5 = (_6.0: u8); + _5 = copy (_6.0: u8); _4 = Gt(move _5, const 1_u8); switchInt(move _4) -> [0: bb7, otherwise: bb6]; } diff --git a/tests/mir-opt/building/match/deref-patterns/string.foo.PreCodegen.after.mir b/tests/mir-opt/building/match/deref-patterns/string.foo.PreCodegen.after.mir index 1e4f7485089e..9f52a8cd1e55 100644 --- a/tests/mir-opt/building/match/deref-patterns/string.foo.PreCodegen.after.mir +++ b/tests/mir-opt/building/match/deref-patterns/string.foo.PreCodegen.after.mir @@ -26,7 +26,7 @@ fn foo(_1: Option) -> i32 { } bb2: { - _6 = ::eq(_5, const "a") -> [return: bb3, unwind unreachable]; + _6 = ::eq(copy _5, const "a") -> [return: bb3, unwind unreachable]; } bb3: { @@ -52,7 +52,7 @@ fn foo(_1: Option) -> i32 { } bb7: { - switchInt(_2) -> [0: bb9, otherwise: bb8]; + switchInt(copy _2) -> [0: bb9, otherwise: bb8]; } bb8: { diff --git a/tests/mir-opt/building/match/exponential_or.match_tuple.SimplifyCfg-initial.after.mir b/tests/mir-opt/building/match/exponential_or.match_tuple.SimplifyCfg-initial.after.mir index 596dcef85fd2..d52241b459eb 100644 --- a/tests/mir-opt/building/match/exponential_or.match_tuple.SimplifyCfg-initial.after.mir +++ b/tests/mir-opt/building/match/exponential_or.match_tuple.SimplifyCfg-initial.after.mir @@ -19,7 +19,7 @@ fn match_tuple(_1: (u32, bool, Option, u32)) -> u32 { bb0: { PlaceMention(_1); - switchInt((_1.0: u32)) -> [1: bb2, 4: bb2, otherwise: bb1]; + switchInt(copy (_1.0: u32)) -> [1: bb2, 4: bb2, otherwise: bb1]; } bb1: { @@ -33,26 +33,26 @@ fn match_tuple(_1: (u32, bool, Option, u32)) -> u32 { } bb3: { - switchInt((((_1.2: std::option::Option) as Some).0: i32)) -> [1: bb4, 8: bb4, otherwise: bb1]; + switchInt(copy (((_1.2: std::option::Option) as Some).0: i32)) -> [1: bb4, 8: bb4, otherwise: bb1]; } bb4: { - _5 = Le(const 6_u32, (_1.3: u32)); + _5 = Le(const 6_u32, copy (_1.3: u32)); switchInt(move _5) -> [0: bb5, otherwise: bb7]; } bb5: { - _3 = Le(const 13_u32, (_1.3: u32)); + _3 = Le(const 13_u32, copy (_1.3: u32)); switchInt(move _3) -> [0: bb1, otherwise: bb6]; } bb6: { - _4 = Le((_1.3: u32), const 16_u32); + _4 = Le(copy (_1.3: u32), const 16_u32); switchInt(move _4) -> [0: bb1, otherwise: bb8]; } bb7: { - _6 = Le((_1.3: u32), const 9_u32); + _6 = Le(copy (_1.3: u32), const 9_u32); switchInt(move _6) -> [0: bb5, otherwise: bb8]; } @@ -62,13 +62,13 @@ fn match_tuple(_1: (u32, bool, Option, u32)) -> u32 { bb9: { StorageLive(_7); - _7 = (_1.0: u32); + _7 = copy (_1.0: u32); StorageLive(_8); - _8 = (_1.3: u32); + _8 = copy (_1.3: u32); StorageLive(_9); - _9 = _7; + _9 = copy _7; StorageLive(_10); - _10 = _8; + _10 = copy _8; _0 = BitXor(move _9, move _10); StorageDead(_10); StorageDead(_9); diff --git a/tests/mir-opt/building/match/match_false_edges.full_tested_match.built.after.mir b/tests/mir-opt/building/match/match_false_edges.full_tested_match.built.after.mir index a93743edfac7..4b0cdcfbb866 100644 --- a/tests/mir-opt/building/match/match_false_edges.full_tested_match.built.after.mir +++ b/tests/mir-opt/building/match/match_false_edges.full_tested_match.built.after.mir @@ -59,9 +59,9 @@ fn full_tested_match() -> () { bb7: { StorageLive(_9); - _9 = ((_2 as Some).0: i32); + _9 = copy ((_2 as Some).0: i32); StorageLive(_10); - _10 = _9; + _10 = copy _9; _1 = (const 2_i32, move _10); StorageDead(_10); StorageDead(_9); @@ -89,9 +89,9 @@ fn full_tested_match() -> () { FakeRead(ForMatchGuard, _3); FakeRead(ForGuardBinding, _6); StorageLive(_5); - _5 = ((_2 as Some).0: i32); + _5 = copy ((_2 as Some).0: i32); StorageLive(_8); - _8 = _5; + _8 = copy _5; _1 = (const 1_i32, move _8); StorageDead(_8); StorageDead(_5); diff --git a/tests/mir-opt/building/match/match_false_edges.full_tested_match2.built.after.mir b/tests/mir-opt/building/match/match_false_edges.full_tested_match2.built.after.mir index 0d0ea2be1b00..63ec71fdf513 100644 --- a/tests/mir-opt/building/match/match_false_edges.full_tested_match2.built.after.mir +++ b/tests/mir-opt/building/match/match_false_edges.full_tested_match2.built.after.mir @@ -42,9 +42,9 @@ fn full_tested_match2() -> () { bb3: { StorageLive(_9); - _9 = ((_2 as Some).0: i32); + _9 = copy ((_2 as Some).0: i32); StorageLive(_10); - _10 = _9; + _10 = copy _9; _1 = (const 2_i32, move _10); StorageDead(_10); StorageDead(_9); @@ -89,9 +89,9 @@ fn full_tested_match2() -> () { FakeRead(ForMatchGuard, _3); FakeRead(ForGuardBinding, _6); StorageLive(_5); - _5 = ((_2 as Some).0: i32); + _5 = copy ((_2 as Some).0: i32); StorageLive(_8); - _8 = _5; + _8 = copy _5; _1 = (const 1_i32, move _8); StorageDead(_8); StorageDead(_5); diff --git a/tests/mir-opt/building/match/match_false_edges.main.built.after.mir b/tests/mir-opt/building/match/match_false_edges.main.built.after.mir index 87b7e29848f7..3b10adb499cd 100644 --- a/tests/mir-opt/building/match/match_false_edges.main.built.after.mir +++ b/tests/mir-opt/building/match/match_false_edges.main.built.after.mir @@ -61,7 +61,7 @@ fn main() -> () { bb5: { StorageLive(_14); - _14 = _2; + _14 = copy _2; _1 = const 4_i32; StorageDead(_14); goto -> bb22; @@ -86,7 +86,7 @@ fn main() -> () { _3 = &fake shallow _2; StorageLive(_12); StorageLive(_13); - _13 = (*_11); + _13 = copy (*_11); _12 = guard2(move _13) -> [return: bb18, unwind: bb24]; } @@ -96,7 +96,7 @@ fn main() -> () { bb11: { StorageLive(_9); - _9 = _2; + _9 = copy _2; _1 = const 2_i32; StorageDead(_9); goto -> bb22; @@ -123,7 +123,7 @@ fn main() -> () { FakeRead(ForMatchGuard, _3); FakeRead(ForGuardBinding, _7); StorageLive(_6); - _6 = ((_2 as Some).0: i32); + _6 = copy ((_2 as Some).0: i32); _1 = const 1_i32; StorageDead(_6); StorageDead(_7); @@ -150,7 +150,7 @@ fn main() -> () { FakeRead(ForMatchGuard, _3); FakeRead(ForGuardBinding, _11); StorageLive(_10); - _10 = ((_2 as Some).0: i32); + _10 = copy ((_2 as Some).0: i32); _1 = const 3_i32; StorageDead(_10); StorageDead(_11); diff --git a/tests/mir-opt/building/match/simple_match.match_bool.built.after.mir b/tests/mir-opt/building/match/simple_match.match_bool.built.after.mir index b0ebdc37b067..0e82d9591a69 100644 --- a/tests/mir-opt/building/match/simple_match.match_bool.built.after.mir +++ b/tests/mir-opt/building/match/simple_match.match_bool.built.after.mir @@ -6,7 +6,7 @@ fn match_bool(_1: bool) -> usize { bb0: { PlaceMention(_1); - switchInt(_1) -> [0: bb1, otherwise: bb2]; + switchInt(copy _1) -> [0: bb1, otherwise: bb2]; } bb1: { diff --git a/tests/mir-opt/building/match/sort_candidates.constant_eq.SimplifyCfg-initial.after.mir b/tests/mir-opt/building/match/sort_candidates.constant_eq.SimplifyCfg-initial.after.mir index 2bce79a3ae79..b8f54fef0faf 100644 --- a/tests/mir-opt/building/match/sort_candidates.constant_eq.SimplifyCfg-initial.after.mir +++ b/tests/mir-opt/building/match/sort_candidates.constant_eq.SimplifyCfg-initial.after.mir @@ -16,18 +16,18 @@ fn constant_eq(_1: &str, _2: bool) -> u32 { bb0: { StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; StorageLive(_5); - _5 = _2; + _5 = copy _2; _3 = (move _4, move _5); StorageDead(_5); StorageDead(_4); PlaceMention(_3); - _9 = ::eq((_3.0: &str), const "a") -> [return: bb9, unwind: bb19]; + _9 = ::eq(copy (_3.0: &str), const "a") -> [return: bb9, unwind: bb19]; } bb1: { - switchInt((_3.1: bool)) -> [0: bb10, otherwise: bb11]; + switchInt(copy (_3.1: bool)) -> [0: bb10, otherwise: bb11]; } bb2: { @@ -35,7 +35,7 @@ fn constant_eq(_1: &str, _2: bool) -> u32 { } bb3: { - switchInt((_3.1: bool)) -> [0: bb1, otherwise: bb4]; + switchInt(copy (_3.1: bool)) -> [0: bb1, otherwise: bb4]; } bb4: { @@ -43,11 +43,11 @@ fn constant_eq(_1: &str, _2: bool) -> u32 { } bb5: { - _8 = ::eq((_3.0: &str), const "b") -> [return: bb8, unwind: bb19]; + _8 = ::eq(copy (_3.0: &str), const "b") -> [return: bb8, unwind: bb19]; } bb6: { - switchInt((_3.1: bool)) -> [0: bb1, otherwise: bb7]; + switchInt(copy (_3.1: bool)) -> [0: bb1, otherwise: bb7]; } bb7: { diff --git a/tests/mir-opt/building/match/sort_candidates.disjoint_ranges.SimplifyCfg-initial.after.mir b/tests/mir-opt/building/match/sort_candidates.disjoint_ranges.SimplifyCfg-initial.after.mir index e521fb4509aa..d62516808143 100644 --- a/tests/mir-opt/building/match/sort_candidates.disjoint_ranges.SimplifyCfg-initial.after.mir +++ b/tests/mir-opt/building/match/sort_candidates.disjoint_ranges.SimplifyCfg-initial.after.mir @@ -13,7 +13,7 @@ fn disjoint_ranges(_1: i32, _2: bool) -> u32 { bb0: { PlaceMention(_1); - _6 = Le(const 0_i32, _1); + _6 = Le(const 0_i32, copy _1); switchInt(move _6) -> [0: bb3, otherwise: bb8]; } @@ -27,7 +27,7 @@ fn disjoint_ranges(_1: i32, _2: bool) -> u32 { } bb3: { - _4 = Le(const 10_i32, _1); + _4 = Le(const 10_i32, copy _1); switchInt(move _4) -> [0: bb5, otherwise: bb7]; } @@ -36,7 +36,7 @@ fn disjoint_ranges(_1: i32, _2: bool) -> u32 { } bb5: { - switchInt(_1) -> [4294967295: bb6, otherwise: bb1]; + switchInt(copy _1) -> [4294967295: bb6, otherwise: bb1]; } bb6: { @@ -44,12 +44,12 @@ fn disjoint_ranges(_1: i32, _2: bool) -> u32 { } bb7: { - _5 = Le(_1, const 20_i32); + _5 = Le(copy _1, const 20_i32); switchInt(move _5) -> [0: bb5, otherwise: bb4]; } bb8: { - _7 = Lt(_1, const 10_i32); + _7 = Lt(copy _1, const 10_i32); switchInt(move _7) -> [0: bb3, otherwise: bb2]; } @@ -66,7 +66,7 @@ fn disjoint_ranges(_1: i32, _2: bool) -> u32 { bb11: { _3 = &fake shallow _1; StorageLive(_8); - _8 = _2; + _8 = copy _2; switchInt(move _8) -> [0: bb13, otherwise: bb12]; } diff --git a/tests/mir-opt/building/receiver_ptr_mutability.main.built.after.mir b/tests/mir-opt/building/receiver_ptr_mutability.main.built.after.mir index 1855bb0787d2..296d71a319d1 100644 --- a/tests/mir-opt/building/receiver_ptr_mutability.main.built.after.mir +++ b/tests/mir-opt/building/receiver_ptr_mutability.main.built.after.mir @@ -38,7 +38,7 @@ fn main() -> () { StorageLive(_2); StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; _3 = move _4 as *const Test (PointerCoercion(MutToConstPointer)); StorageDead(_4); _2 = Test::x(move _3) -> [return: bb2, unwind: bb4]; @@ -63,7 +63,7 @@ fn main() -> () { StorageLive(_10); StorageLive(_11); StorageLive(_12); - _12 = (*(*(*(*_5)))); + _12 = copy (*(*(*(*_5)))); _11 = move _12 as *const Test (PointerCoercion(MutToConstPointer)); StorageDead(_12); _10 = Test::x(move _11) -> [return: bb3, unwind: bb4]; diff --git a/tests/mir-opt/building/shifts.shift_signed.built.after.mir b/tests/mir-opt/building/shifts.shift_signed.built.after.mir index 8706ee9d4463..65e2db300cde 100644 --- a/tests/mir-opt/building/shifts.shift_signed.built.after.mir +++ b/tests/mir-opt/building/shifts.shift_signed.built.after.mir @@ -44,12 +44,12 @@ fn shift_signed(_1: i8, _2: u128, _3: i8, _4: i32, _5: i128) -> ([i8; 3], [u128; StorageLive(_6); StorageLive(_7); StorageLive(_8); - _8 = _1; + _8 = copy _1; StorageLive(_9); - _9 = _3; - _10 = _9 as u8 (IntToInt); + _9 = copy _3; + _10 = copy _9 as u8 (IntToInt); _11 = Lt(move _10, const 8_u8); - assert(move _11, "attempt to shift right by `{}`, which would overflow", _9) -> [success: bb1, unwind: bb7]; + assert(move _11, "attempt to shift right by `{}`, which would overflow", copy _9) -> [success: bb1, unwind: bb7]; } bb1: { @@ -58,12 +58,12 @@ fn shift_signed(_1: i8, _2: u128, _3: i8, _4: i32, _5: i128) -> ([i8; 3], [u128; StorageDead(_8); StorageLive(_12); StorageLive(_13); - _13 = _1; + _13 = copy _1; StorageLive(_14); - _14 = _4; - _15 = _14 as u32 (IntToInt); + _14 = copy _4; + _15 = copy _14 as u32 (IntToInt); _16 = Lt(move _15, const 8_u32); - assert(move _16, "attempt to shift right by `{}`, which would overflow", _14) -> [success: bb2, unwind: bb7]; + assert(move _16, "attempt to shift right by `{}`, which would overflow", copy _14) -> [success: bb2, unwind: bb7]; } bb2: { @@ -72,12 +72,12 @@ fn shift_signed(_1: i8, _2: u128, _3: i8, _4: i32, _5: i128) -> ([i8; 3], [u128; StorageDead(_13); StorageLive(_17); StorageLive(_18); - _18 = _1; + _18 = copy _1; StorageLive(_19); - _19 = _5; - _20 = _19 as u128 (IntToInt); + _19 = copy _5; + _20 = copy _19 as u128 (IntToInt); _21 = Lt(move _20, const 8_u128); - assert(move _21, "attempt to shift right by `{}`, which would overflow", _19) -> [success: bb3, unwind: bb7]; + assert(move _21, "attempt to shift right by `{}`, which would overflow", copy _19) -> [success: bb3, unwind: bb7]; } bb3: { @@ -91,12 +91,12 @@ fn shift_signed(_1: i8, _2: u128, _3: i8, _4: i32, _5: i128) -> ([i8; 3], [u128; StorageLive(_22); StorageLive(_23); StorageLive(_24); - _24 = _2; + _24 = copy _2; StorageLive(_25); - _25 = _3; - _26 = _25 as u8 (IntToInt); + _25 = copy _3; + _26 = copy _25 as u8 (IntToInt); _27 = Lt(move _26, const 128_u8); - assert(move _27, "attempt to shift left by `{}`, which would overflow", _25) -> [success: bb4, unwind: bb7]; + assert(move _27, "attempt to shift left by `{}`, which would overflow", copy _25) -> [success: bb4, unwind: bb7]; } bb4: { @@ -105,12 +105,12 @@ fn shift_signed(_1: i8, _2: u128, _3: i8, _4: i32, _5: i128) -> ([i8; 3], [u128; StorageDead(_24); StorageLive(_28); StorageLive(_29); - _29 = _2; + _29 = copy _2; StorageLive(_30); - _30 = _4; - _31 = _30 as u32 (IntToInt); + _30 = copy _4; + _31 = copy _30 as u32 (IntToInt); _32 = Lt(move _31, const 128_u32); - assert(move _32, "attempt to shift left by `{}`, which would overflow", _30) -> [success: bb5, unwind: bb7]; + assert(move _32, "attempt to shift left by `{}`, which would overflow", copy _30) -> [success: bb5, unwind: bb7]; } bb5: { @@ -119,12 +119,12 @@ fn shift_signed(_1: i8, _2: u128, _3: i8, _4: i32, _5: i128) -> ([i8; 3], [u128; StorageDead(_29); StorageLive(_33); StorageLive(_34); - _34 = _2; + _34 = copy _2; StorageLive(_35); - _35 = _5; - _36 = _35 as u128 (IntToInt); + _35 = copy _5; + _36 = copy _35 as u128 (IntToInt); _37 = Lt(move _36, const 128_u128); - assert(move _37, "attempt to shift left by `{}`, which would overflow", _35) -> [success: bb6, unwind: bb7]; + assert(move _37, "attempt to shift left by `{}`, which would overflow", copy _35) -> [success: bb6, unwind: bb7]; } bb6: { diff --git a/tests/mir-opt/building/shifts.shift_unsigned.built.after.mir b/tests/mir-opt/building/shifts.shift_unsigned.built.after.mir index dfd3b5b35ad5..62536833e491 100644 --- a/tests/mir-opt/building/shifts.shift_unsigned.built.after.mir +++ b/tests/mir-opt/building/shifts.shift_unsigned.built.after.mir @@ -38,11 +38,11 @@ fn shift_unsigned(_1: u8, _2: i128, _3: u8, _4: u32, _5: u128) -> ([u8; 3], [i12 StorageLive(_6); StorageLive(_7); StorageLive(_8); - _8 = _1; + _8 = copy _1; StorageLive(_9); - _9 = _3; - _10 = Lt(_9, const 8_u8); - assert(move _10, "attempt to shift right by `{}`, which would overflow", _9) -> [success: bb1, unwind: bb7]; + _9 = copy _3; + _10 = Lt(copy _9, const 8_u8); + assert(move _10, "attempt to shift right by `{}`, which would overflow", copy _9) -> [success: bb1, unwind: bb7]; } bb1: { @@ -51,11 +51,11 @@ fn shift_unsigned(_1: u8, _2: i128, _3: u8, _4: u32, _5: u128) -> ([u8; 3], [i12 StorageDead(_8); StorageLive(_11); StorageLive(_12); - _12 = _1; + _12 = copy _1; StorageLive(_13); - _13 = _4; - _14 = Lt(_13, const 8_u32); - assert(move _14, "attempt to shift right by `{}`, which would overflow", _13) -> [success: bb2, unwind: bb7]; + _13 = copy _4; + _14 = Lt(copy _13, const 8_u32); + assert(move _14, "attempt to shift right by `{}`, which would overflow", copy _13) -> [success: bb2, unwind: bb7]; } bb2: { @@ -64,11 +64,11 @@ fn shift_unsigned(_1: u8, _2: i128, _3: u8, _4: u32, _5: u128) -> ([u8; 3], [i12 StorageDead(_12); StorageLive(_15); StorageLive(_16); - _16 = _1; + _16 = copy _1; StorageLive(_17); - _17 = _5; - _18 = Lt(_17, const 8_u128); - assert(move _18, "attempt to shift right by `{}`, which would overflow", _17) -> [success: bb3, unwind: bb7]; + _17 = copy _5; + _18 = Lt(copy _17, const 8_u128); + assert(move _18, "attempt to shift right by `{}`, which would overflow", copy _17) -> [success: bb3, unwind: bb7]; } bb3: { @@ -82,11 +82,11 @@ fn shift_unsigned(_1: u8, _2: i128, _3: u8, _4: u32, _5: u128) -> ([u8; 3], [i12 StorageLive(_19); StorageLive(_20); StorageLive(_21); - _21 = _2; + _21 = copy _2; StorageLive(_22); - _22 = _3; - _23 = Lt(_22, const 128_u8); - assert(move _23, "attempt to shift left by `{}`, which would overflow", _22) -> [success: bb4, unwind: bb7]; + _22 = copy _3; + _23 = Lt(copy _22, const 128_u8); + assert(move _23, "attempt to shift left by `{}`, which would overflow", copy _22) -> [success: bb4, unwind: bb7]; } bb4: { @@ -95,11 +95,11 @@ fn shift_unsigned(_1: u8, _2: i128, _3: u8, _4: u32, _5: u128) -> ([u8; 3], [i12 StorageDead(_21); StorageLive(_24); StorageLive(_25); - _25 = _2; + _25 = copy _2; StorageLive(_26); - _26 = _4; - _27 = Lt(_26, const 128_u32); - assert(move _27, "attempt to shift left by `{}`, which would overflow", _26) -> [success: bb5, unwind: bb7]; + _26 = copy _4; + _27 = Lt(copy _26, const 128_u32); + assert(move _27, "attempt to shift left by `{}`, which would overflow", copy _26) -> [success: bb5, unwind: bb7]; } bb5: { @@ -108,11 +108,11 @@ fn shift_unsigned(_1: u8, _2: i128, _3: u8, _4: u32, _5: u128) -> ([u8; 3], [i12 StorageDead(_25); StorageLive(_28); StorageLive(_29); - _29 = _2; + _29 = copy _2; StorageLive(_30); - _30 = _5; - _31 = Lt(_30, const 128_u128); - assert(move _31, "attempt to shift left by `{}`, which would overflow", _30) -> [success: bb6, unwind: bb7]; + _30 = copy _5; + _31 = Lt(copy _30, const 128_u128); + assert(move _31, "attempt to shift left by `{}`, which would overflow", copy _30) -> [success: bb6, unwind: bb7]; } bb6: { diff --git a/tests/mir-opt/building/while_storage.while_loop.PreCodegen.after.panic-abort.mir b/tests/mir-opt/building/while_storage.while_loop.PreCodegen.after.panic-abort.mir index 26c82edf2d5f..44a8b7342b2e 100644 --- a/tests/mir-opt/building/while_storage.while_loop.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/building/while_storage.while_loop.PreCodegen.after.panic-abort.mir @@ -20,7 +20,7 @@ fn while_loop(_1: bool) -> () { bb1: { StorageLive(_3); StorageLive(_2); - _2 = _1; + _2 = copy _1; _3 = get_bool(move _2) -> [return: bb2, unwind unreachable]; } @@ -40,7 +40,7 @@ fn while_loop(_1: bool) -> () { StorageDead(_2); StorageLive(_5); StorageLive(_4); - _4 = _1; + _4 = copy _1; _5 = get_bool(move _4) -> [return: bb5, unwind unreachable]; } diff --git a/tests/mir-opt/building/while_storage.while_loop.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/building/while_storage.while_loop.PreCodegen.after.panic-unwind.mir index 1bb72074846e..9a6403006744 100644 --- a/tests/mir-opt/building/while_storage.while_loop.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/building/while_storage.while_loop.PreCodegen.after.panic-unwind.mir @@ -20,7 +20,7 @@ fn while_loop(_1: bool) -> () { bb1: { StorageLive(_3); StorageLive(_2); - _2 = _1; + _2 = copy _1; _3 = get_bool(move _2) -> [return: bb2, unwind continue]; } @@ -40,7 +40,7 @@ fn while_loop(_1: bool) -> () { StorageDead(_2); StorageLive(_5); StorageLive(_4); - _4 = _1; + _4 = copy _1; _5 = get_bool(move _4) -> [return: bb5, unwind continue]; } diff --git a/tests/mir-opt/const_allocation.main.GVN.after.32bit.mir b/tests/mir-opt/const_allocation.main.GVN.after.32bit.mir index 10d99a134633..a2bd2bc0d92a 100644 --- a/tests/mir-opt/const_allocation.main.GVN.after.32bit.mir +++ b/tests/mir-opt/const_allocation.main.GVN.after.32bit.mir @@ -9,7 +9,7 @@ fn main() -> () { StorageLive(_1); StorageLive(_2); _2 = const {ALLOC9: &&[(Option, &[&str])]}; - _1 = (*_2); + _1 = copy (*_2); StorageDead(_2); StorageDead(_1); _0 = const (); diff --git a/tests/mir-opt/const_allocation.main.GVN.after.64bit.mir b/tests/mir-opt/const_allocation.main.GVN.after.64bit.mir index 2f23dbe9ee4f..a431104d08be 100644 --- a/tests/mir-opt/const_allocation.main.GVN.after.64bit.mir +++ b/tests/mir-opt/const_allocation.main.GVN.after.64bit.mir @@ -9,7 +9,7 @@ fn main() -> () { StorageLive(_1); StorageLive(_2); _2 = const {ALLOC9: &&[(Option, &[&str])]}; - _1 = (*_2); + _1 = copy (*_2); StorageDead(_2); StorageDead(_1); _0 = const (); diff --git a/tests/mir-opt/const_allocation2.main.GVN.after.32bit.mir b/tests/mir-opt/const_allocation2.main.GVN.after.32bit.mir index 6499e3676aaa..6fae163f1079 100644 --- a/tests/mir-opt/const_allocation2.main.GVN.after.32bit.mir +++ b/tests/mir-opt/const_allocation2.main.GVN.after.32bit.mir @@ -9,7 +9,7 @@ fn main() -> () { StorageLive(_1); StorageLive(_2); _2 = const {ALLOC9: &&[(Option, &[&u8])]}; - _1 = (*_2); + _1 = copy (*_2); StorageDead(_2); StorageDead(_1); _0 = const (); diff --git a/tests/mir-opt/const_allocation2.main.GVN.after.64bit.mir b/tests/mir-opt/const_allocation2.main.GVN.after.64bit.mir index 02f5ebab8477..f2bb5f46b16e 100644 --- a/tests/mir-opt/const_allocation2.main.GVN.after.64bit.mir +++ b/tests/mir-opt/const_allocation2.main.GVN.after.64bit.mir @@ -9,7 +9,7 @@ fn main() -> () { StorageLive(_1); StorageLive(_2); _2 = const {ALLOC9: &&[(Option, &[&u8])]}; - _1 = (*_2); + _1 = copy (*_2); StorageDead(_2); StorageDead(_1); _0 = const (); diff --git a/tests/mir-opt/const_allocation3.main.GVN.after.32bit.mir b/tests/mir-opt/const_allocation3.main.GVN.after.32bit.mir index c95e696946a6..58776b446fa7 100644 --- a/tests/mir-opt/const_allocation3.main.GVN.after.32bit.mir +++ b/tests/mir-opt/const_allocation3.main.GVN.after.32bit.mir @@ -9,7 +9,7 @@ fn main() -> () { StorageLive(_1); StorageLive(_2); _2 = const {ALLOC4: &&Packed}; - _1 = (*_2); + _1 = copy (*_2); StorageDead(_2); StorageDead(_1); _0 = const (); diff --git a/tests/mir-opt/const_allocation3.main.GVN.after.64bit.mir b/tests/mir-opt/const_allocation3.main.GVN.after.64bit.mir index 198bc8bd07ef..3ccf4211971c 100644 --- a/tests/mir-opt/const_allocation3.main.GVN.after.64bit.mir +++ b/tests/mir-opt/const_allocation3.main.GVN.after.64bit.mir @@ -9,7 +9,7 @@ fn main() -> () { StorageLive(_1); StorageLive(_2); _2 = const {ALLOC2: &&Packed}; - _1 = (*_2); + _1 = copy (*_2); StorageDead(_2); StorageDead(_1); _0 = const (); diff --git a/tests/mir-opt/const_goto_const_eval_fail.f.JumpThreading.diff b/tests/mir-opt/const_goto_const_eval_fail.f.JumpThreading.diff index 4fc9254b7bae..086abeba0f84 100644 --- a/tests/mir-opt/const_goto_const_eval_fail.f.JumpThreading.diff +++ b/tests/mir-opt/const_goto_const_eval_fail.f.JumpThreading.diff @@ -22,7 +22,7 @@ } bb3: { - switchInt(_1) -> [0: bb5, otherwise: bb4]; + switchInt(copy _1) -> [0: bb5, otherwise: bb4]; } bb4: { diff --git a/tests/mir-opt/const_prop/address_of_pair.fn0.GVN.diff b/tests/mir-opt/const_prop/address_of_pair.fn0.GVN.diff index ac372f837268..e33185f17bcf 100644 --- a/tests/mir-opt/const_prop/address_of_pair.fn0.GVN.diff +++ b/tests/mir-opt/const_prop/address_of_pair.fn0.GVN.diff @@ -34,10 +34,10 @@ - StorageLive(_5); + nop; StorageLive(_6); - _6 = (_2.1: bool); + _6 = copy (_2.1: bool); _5 = Not(move _6); StorageDead(_6); - _0 = _5; + _0 = copy _5; - StorageDead(_5); + nop; StorageDead(_3); diff --git a/tests/mir-opt/const_prop/aggregate.foo.GVN.panic-abort.diff b/tests/mir-opt/const_prop/aggregate.foo.GVN.panic-abort.diff index 4f0f7fa8fa27..c6d3bad0790c 100644 --- a/tests/mir-opt/const_prop/aggregate.foo.GVN.panic-abort.diff +++ b/tests/mir-opt/const_prop/aggregate.foo.GVN.panic-abort.diff @@ -24,11 +24,11 @@ StorageLive(_3); StorageLive(_4); StorageLive(_5); - _5 = _1; + _5 = copy _1; - _4 = (const 0_i32, move _5); -+ _4 = (const 0_i32, _1); ++ _4 = (const 0_i32, copy _1); StorageDead(_5); -- _3 = (_4.0: i32); +- _3 = copy (_4.0: i32); - _2 = Add(move _3, const 1_i32); + _3 = const 0_i32; + _2 = const 1_i32; @@ -38,11 +38,11 @@ StorageLive(_7); StorageLive(_8); StorageLive(_9); - _9 = _1; + _9 = copy _1; - _8 = (move _9, const 1_i32); -+ _8 = (_1, const 1_i32); ++ _8 = (copy _1, const 1_i32); StorageDead(_9); -- _7 = (_8.1: i32); +- _7 = copy (_8.1: i32); - _6 = Add(move _7, const 2_i32); + _7 = const 1_i32; + _6 = const 3_i32; diff --git a/tests/mir-opt/const_prop/aggregate.foo.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/aggregate.foo.GVN.panic-unwind.diff index 4f0f7fa8fa27..c6d3bad0790c 100644 --- a/tests/mir-opt/const_prop/aggregate.foo.GVN.panic-unwind.diff +++ b/tests/mir-opt/const_prop/aggregate.foo.GVN.panic-unwind.diff @@ -24,11 +24,11 @@ StorageLive(_3); StorageLive(_4); StorageLive(_5); - _5 = _1; + _5 = copy _1; - _4 = (const 0_i32, move _5); -+ _4 = (const 0_i32, _1); ++ _4 = (const 0_i32, copy _1); StorageDead(_5); -- _3 = (_4.0: i32); +- _3 = copy (_4.0: i32); - _2 = Add(move _3, const 1_i32); + _3 = const 0_i32; + _2 = const 1_i32; @@ -38,11 +38,11 @@ StorageLive(_7); StorageLive(_8); StorageLive(_9); - _9 = _1; + _9 = copy _1; - _8 = (move _9, const 1_i32); -+ _8 = (_1, const 1_i32); ++ _8 = (copy _1, const 1_i32); StorageDead(_9); -- _7 = (_8.1: i32); +- _7 = copy (_8.1: i32); - _6 = Add(move _7, const 2_i32); + _7 = const 1_i32; + _6 = const 3_i32; diff --git a/tests/mir-opt/const_prop/aggregate.main.GVN.panic-abort.diff b/tests/mir-opt/const_prop/aggregate.main.GVN.panic-abort.diff index 854e27445afb..0a59c59c2ed2 100644 --- a/tests/mir-opt/const_prop/aggregate.main.GVN.panic-abort.diff +++ b/tests/mir-opt/const_prop/aggregate.main.GVN.panic-abort.diff @@ -18,7 +18,7 @@ StorageLive(_2); StorageLive(_3); _3 = (const 0_i32, const 1_u8, const 2_i32); -- _2 = (_3.1: u8); +- _2 = copy (_3.1: u8); - _1 = Add(move _2, const 0_u8); + _2 = const 1_u8; + _1 = const 1_u8; @@ -26,7 +26,7 @@ StorageDead(_3); StorageLive(_4); StorageLive(_5); -- _5 = _1; +- _5 = copy _1; - _4 = foo(move _5) -> [return: bb1, unwind unreachable]; + _5 = const 1_u8; + _4 = foo(const 1_u8) -> [return: bb1, unwind unreachable]; diff --git a/tests/mir-opt/const_prop/aggregate.main.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/aggregate.main.GVN.panic-unwind.diff index f6c4b2c92409..100369a2eee3 100644 --- a/tests/mir-opt/const_prop/aggregate.main.GVN.panic-unwind.diff +++ b/tests/mir-opt/const_prop/aggregate.main.GVN.panic-unwind.diff @@ -18,7 +18,7 @@ StorageLive(_2); StorageLive(_3); _3 = (const 0_i32, const 1_u8, const 2_i32); -- _2 = (_3.1: u8); +- _2 = copy (_3.1: u8); - _1 = Add(move _2, const 0_u8); + _2 = const 1_u8; + _1 = const 1_u8; @@ -26,7 +26,7 @@ StorageDead(_3); StorageLive(_4); StorageLive(_5); -- _5 = _1; +- _5 = copy _1; - _4 = foo(move _5) -> [return: bb1, unwind continue]; + _5 = const 1_u8; + _4 = foo(const 1_u8) -> [return: bb1, unwind continue]; diff --git a/tests/mir-opt/const_prop/array_index.main.GVN.32bit.panic-abort.diff b/tests/mir-opt/const_prop/array_index.main.GVN.32bit.panic-abort.diff index 6d00dd5b2126..e754af95ce39 100644 --- a/tests/mir-opt/const_prop/array_index.main.GVN.32bit.panic-abort.diff +++ b/tests/mir-opt/const_prop/array_index.main.GVN.32bit.panic-abort.diff @@ -19,15 +19,15 @@ StorageLive(_3); _3 = const 2_usize; - _4 = Len(_2); -- _5 = Lt(_3, _4); -- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind unreachable]; +- _5 = Lt(copy _3, copy _4); +- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind unreachable]; + _4 = const 4_usize; + _5 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 4_usize, const 2_usize) -> [success: bb1, unwind unreachable]; } bb1: { -- _1 = _2[_3]; +- _1 = copy _2[_3]; + _1 = const 2_u32; StorageDead(_3); StorageDead(_2); diff --git a/tests/mir-opt/const_prop/array_index.main.GVN.32bit.panic-unwind.diff b/tests/mir-opt/const_prop/array_index.main.GVN.32bit.panic-unwind.diff index 7e2f72ab31bc..e15a35c7fe94 100644 --- a/tests/mir-opt/const_prop/array_index.main.GVN.32bit.panic-unwind.diff +++ b/tests/mir-opt/const_prop/array_index.main.GVN.32bit.panic-unwind.diff @@ -19,15 +19,15 @@ StorageLive(_3); _3 = const 2_usize; - _4 = Len(_2); -- _5 = Lt(_3, _4); -- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind continue]; +- _5 = Lt(copy _3, copy _4); +- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind continue]; + _4 = const 4_usize; + _5 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 4_usize, const 2_usize) -> [success: bb1, unwind continue]; } bb1: { -- _1 = _2[_3]; +- _1 = copy _2[_3]; + _1 = const 2_u32; StorageDead(_3); StorageDead(_2); diff --git a/tests/mir-opt/const_prop/array_index.main.GVN.64bit.panic-abort.diff b/tests/mir-opt/const_prop/array_index.main.GVN.64bit.panic-abort.diff index 6d00dd5b2126..e754af95ce39 100644 --- a/tests/mir-opt/const_prop/array_index.main.GVN.64bit.panic-abort.diff +++ b/tests/mir-opt/const_prop/array_index.main.GVN.64bit.panic-abort.diff @@ -19,15 +19,15 @@ StorageLive(_3); _3 = const 2_usize; - _4 = Len(_2); -- _5 = Lt(_3, _4); -- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind unreachable]; +- _5 = Lt(copy _3, copy _4); +- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind unreachable]; + _4 = const 4_usize; + _5 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 4_usize, const 2_usize) -> [success: bb1, unwind unreachable]; } bb1: { -- _1 = _2[_3]; +- _1 = copy _2[_3]; + _1 = const 2_u32; StorageDead(_3); StorageDead(_2); diff --git a/tests/mir-opt/const_prop/array_index.main.GVN.64bit.panic-unwind.diff b/tests/mir-opt/const_prop/array_index.main.GVN.64bit.panic-unwind.diff index 7e2f72ab31bc..e15a35c7fe94 100644 --- a/tests/mir-opt/const_prop/array_index.main.GVN.64bit.panic-unwind.diff +++ b/tests/mir-opt/const_prop/array_index.main.GVN.64bit.panic-unwind.diff @@ -19,15 +19,15 @@ StorageLive(_3); _3 = const 2_usize; - _4 = Len(_2); -- _5 = Lt(_3, _4); -- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind continue]; +- _5 = Lt(copy _3, copy _4); +- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind continue]; + _4 = const 4_usize; + _5 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 4_usize, const 2_usize) -> [success: bb1, unwind continue]; } bb1: { -- _1 = _2[_3]; +- _1 = copy _2[_3]; + _1 = const 2_u32; StorageDead(_3); StorageDead(_2); diff --git a/tests/mir-opt/const_prop/bad_op_div_by_zero.main.GVN.panic-abort.diff b/tests/mir-opt/const_prop/bad_op_div_by_zero.main.GVN.panic-abort.diff index 4838efba6f9d..8c535b567c32 100644 --- a/tests/mir-opt/const_prop/bad_op_div_by_zero.main.GVN.panic-abort.diff +++ b/tests/mir-opt/const_prop/bad_op_div_by_zero.main.GVN.panic-abort.diff @@ -23,8 +23,8 @@ _1 = const 0_i32; StorageLive(_2); StorageLive(_3); -- _3 = _1; -- _4 = Eq(_3, const 0_i32); +- _3 = copy _1; +- _4 = Eq(copy _3, const 0_i32); - assert(!move _4, "attempt to divide `{}` by zero", const 1_i32) -> [success: bb1, unwind unreachable]; + _3 = const 0_i32; + _4 = const true; @@ -32,10 +32,10 @@ } bb1: { -- _5 = Eq(_3, const -1_i32); +- _5 = Eq(copy _3, const -1_i32); - _6 = Eq(const 1_i32, const i32::MIN); - _7 = BitAnd(move _5, move _6); -- assert(!move _7, "attempt to compute `{} / {}`, which would overflow", const 1_i32, _3) -> [success: bb2, unwind unreachable]; +- assert(!move _7, "attempt to compute `{} / {}`, which would overflow", const 1_i32, copy _3) -> [success: bb2, unwind unreachable]; + _5 = const false; + _6 = const false; + _7 = const false; diff --git a/tests/mir-opt/const_prop/bad_op_div_by_zero.main.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/bad_op_div_by_zero.main.GVN.panic-unwind.diff index 7f403d6efc10..045f4d81db62 100644 --- a/tests/mir-opt/const_prop/bad_op_div_by_zero.main.GVN.panic-unwind.diff +++ b/tests/mir-opt/const_prop/bad_op_div_by_zero.main.GVN.panic-unwind.diff @@ -23,8 +23,8 @@ _1 = const 0_i32; StorageLive(_2); StorageLive(_3); -- _3 = _1; -- _4 = Eq(_3, const 0_i32); +- _3 = copy _1; +- _4 = Eq(copy _3, const 0_i32); - assert(!move _4, "attempt to divide `{}` by zero", const 1_i32) -> [success: bb1, unwind continue]; + _3 = const 0_i32; + _4 = const true; @@ -32,10 +32,10 @@ } bb1: { -- _5 = Eq(_3, const -1_i32); +- _5 = Eq(copy _3, const -1_i32); - _6 = Eq(const 1_i32, const i32::MIN); - _7 = BitAnd(move _5, move _6); -- assert(!move _7, "attempt to compute `{} / {}`, which would overflow", const 1_i32, _3) -> [success: bb2, unwind continue]; +- assert(!move _7, "attempt to compute `{} / {}`, which would overflow", const 1_i32, copy _3) -> [success: bb2, unwind continue]; + _5 = const false; + _6 = const false; + _7 = const false; diff --git a/tests/mir-opt/const_prop/bad_op_mod_by_zero.main.GVN.panic-abort.diff b/tests/mir-opt/const_prop/bad_op_mod_by_zero.main.GVN.panic-abort.diff index 59f2eb86f509..e5a8726b855c 100644 --- a/tests/mir-opt/const_prop/bad_op_mod_by_zero.main.GVN.panic-abort.diff +++ b/tests/mir-opt/const_prop/bad_op_mod_by_zero.main.GVN.panic-abort.diff @@ -23,8 +23,8 @@ _1 = const 0_i32; StorageLive(_2); StorageLive(_3); -- _3 = _1; -- _4 = Eq(_3, const 0_i32); +- _3 = copy _1; +- _4 = Eq(copy _3, const 0_i32); - assert(!move _4, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_i32) -> [success: bb1, unwind unreachable]; + _3 = const 0_i32; + _4 = const true; @@ -32,10 +32,10 @@ } bb1: { -- _5 = Eq(_3, const -1_i32); +- _5 = Eq(copy _3, const -1_i32); - _6 = Eq(const 1_i32, const i32::MIN); - _7 = BitAnd(move _5, move _6); -- assert(!move _7, "attempt to compute the remainder of `{} % {}`, which would overflow", const 1_i32, _3) -> [success: bb2, unwind unreachable]; +- assert(!move _7, "attempt to compute the remainder of `{} % {}`, which would overflow", const 1_i32, copy _3) -> [success: bb2, unwind unreachable]; + _5 = const false; + _6 = const false; + _7 = const false; diff --git a/tests/mir-opt/const_prop/bad_op_mod_by_zero.main.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/bad_op_mod_by_zero.main.GVN.panic-unwind.diff index 9b866082788c..1110ff186dc6 100644 --- a/tests/mir-opt/const_prop/bad_op_mod_by_zero.main.GVN.panic-unwind.diff +++ b/tests/mir-opt/const_prop/bad_op_mod_by_zero.main.GVN.panic-unwind.diff @@ -23,8 +23,8 @@ _1 = const 0_i32; StorageLive(_2); StorageLive(_3); -- _3 = _1; -- _4 = Eq(_3, const 0_i32); +- _3 = copy _1; +- _4 = Eq(copy _3, const 0_i32); - assert(!move _4, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_i32) -> [success: bb1, unwind continue]; + _3 = const 0_i32; + _4 = const true; @@ -32,10 +32,10 @@ } bb1: { -- _5 = Eq(_3, const -1_i32); +- _5 = Eq(copy _3, const -1_i32); - _6 = Eq(const 1_i32, const i32::MIN); - _7 = BitAnd(move _5, move _6); -- assert(!move _7, "attempt to compute the remainder of `{} % {}`, which would overflow", const 1_i32, _3) -> [success: bb2, unwind continue]; +- assert(!move _7, "attempt to compute the remainder of `{} % {}`, which would overflow", const 1_i32, copy _3) -> [success: bb2, unwind continue]; + _5 = const false; + _6 = const false; + _7 = const false; diff --git a/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.main.GVN.32bit.panic-abort.diff b/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.main.GVN.32bit.panic-abort.diff index 826f4c342777..52aa4da49efa 100644 --- a/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.main.GVN.32bit.panic-abort.diff +++ b/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.main.GVN.32bit.panic-abort.diff @@ -33,15 +33,15 @@ StorageLive(_6); _6 = const 3_usize; _7 = Len((*_1)); -- _8 = Lt(_6, _7); -- assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, _6) -> [success: bb1, unwind unreachable]; -+ _8 = Lt(const 3_usize, _7); +- _8 = Lt(copy _6, copy _7); +- assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, copy _6) -> [success: bb1, unwind unreachable]; ++ _8 = Lt(const 3_usize, copy _7); + assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, const 3_usize) -> [success: bb1, unwind unreachable]; } bb1: { -- _5 = (*_1)[_6]; -+ _5 = (*_1)[3 of 4]; +- _5 = copy (*_1)[_6]; ++ _5 = copy (*_1)[3 of 4]; StorageDead(_6); _0 = const (); StorageDead(_5); diff --git a/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.main.GVN.32bit.panic-unwind.diff b/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.main.GVN.32bit.panic-unwind.diff index 0e2ec65652f5..242ff0e664f1 100644 --- a/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.main.GVN.32bit.panic-unwind.diff +++ b/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.main.GVN.32bit.panic-unwind.diff @@ -33,15 +33,15 @@ StorageLive(_6); _6 = const 3_usize; _7 = Len((*_1)); -- _8 = Lt(_6, _7); -- assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, _6) -> [success: bb1, unwind continue]; -+ _8 = Lt(const 3_usize, _7); +- _8 = Lt(copy _6, copy _7); +- assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, copy _6) -> [success: bb1, unwind continue]; ++ _8 = Lt(const 3_usize, copy _7); + assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, const 3_usize) -> [success: bb1, unwind continue]; } bb1: { -- _5 = (*_1)[_6]; -+ _5 = (*_1)[3 of 4]; +- _5 = copy (*_1)[_6]; ++ _5 = copy (*_1)[3 of 4]; StorageDead(_6); _0 = const (); StorageDead(_5); diff --git a/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.main.GVN.64bit.panic-abort.diff b/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.main.GVN.64bit.panic-abort.diff index 826f4c342777..52aa4da49efa 100644 --- a/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.main.GVN.64bit.panic-abort.diff +++ b/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.main.GVN.64bit.panic-abort.diff @@ -33,15 +33,15 @@ StorageLive(_6); _6 = const 3_usize; _7 = Len((*_1)); -- _8 = Lt(_6, _7); -- assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, _6) -> [success: bb1, unwind unreachable]; -+ _8 = Lt(const 3_usize, _7); +- _8 = Lt(copy _6, copy _7); +- assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, copy _6) -> [success: bb1, unwind unreachable]; ++ _8 = Lt(const 3_usize, copy _7); + assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, const 3_usize) -> [success: bb1, unwind unreachable]; } bb1: { -- _5 = (*_1)[_6]; -+ _5 = (*_1)[3 of 4]; +- _5 = copy (*_1)[_6]; ++ _5 = copy (*_1)[3 of 4]; StorageDead(_6); _0 = const (); StorageDead(_5); diff --git a/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.main.GVN.64bit.panic-unwind.diff b/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.main.GVN.64bit.panic-unwind.diff index 0e2ec65652f5..242ff0e664f1 100644 --- a/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.main.GVN.64bit.panic-unwind.diff +++ b/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.main.GVN.64bit.panic-unwind.diff @@ -33,15 +33,15 @@ StorageLive(_6); _6 = const 3_usize; _7 = Len((*_1)); -- _8 = Lt(_6, _7); -- assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, _6) -> [success: bb1, unwind continue]; -+ _8 = Lt(const 3_usize, _7); +- _8 = Lt(copy _6, copy _7); +- assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, copy _6) -> [success: bb1, unwind continue]; ++ _8 = Lt(const 3_usize, copy _7); + assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, const 3_usize) -> [success: bb1, unwind continue]; } bb1: { -- _5 = (*_1)[_6]; -+ _5 = (*_1)[3 of 4]; +- _5 = copy (*_1)[_6]; ++ _5 = copy (*_1)[3 of 4]; StorageDead(_6); _0 = const (); StorageDead(_5); diff --git a/tests/mir-opt/const_prop/boolean_identities.test.GVN.diff b/tests/mir-opt/const_prop/boolean_identities.test.GVN.diff index 0bd8413289e6..3fe70302b21c 100644 --- a/tests/mir-opt/const_prop/boolean_identities.test.GVN.diff +++ b/tests/mir-opt/const_prop/boolean_identities.test.GVN.diff @@ -22,22 +22,22 @@ - StorageLive(_3); + nop; StorageLive(_4); - _4 = _2; + _4 = copy _2; - _3 = BitOr(move _4, const true); + _3 = const true; StorageDead(_4); - StorageLive(_5); + nop; StorageLive(_6); - _6 = _1; + _6 = copy _1; - _5 = BitAnd(move _6, const false); + _5 = const false; StorageDead(_6); StorageLive(_7); -- _7 = _3; +- _7 = copy _3; + _7 = const true; StorageLive(_8); -- _8 = _5; +- _8 = copy _5; - _0 = BitAnd(move _7, move _8); + _8 = const false; + _0 = const false; diff --git a/tests/mir-opt/const_prop/boxes.main.GVN.panic-abort.diff b/tests/mir-opt/const_prop/boxes.main.GVN.panic-abort.diff index a408c197fd14..d5f15b750d4b 100644 --- a/tests/mir-opt/const_prop/boxes.main.GVN.panic-abort.diff +++ b/tests/mir-opt/const_prop/boxes.main.GVN.panic-abort.diff @@ -32,15 +32,15 @@ bb1: { StorageLive(_7); _7 = ShallowInitBox(move _6, i32); - _8 = (((_7.0: std::ptr::Unique).0: std::ptr::NonNull).0: *const i32); + _8 = copy (((_7.0: std::ptr::Unique).0: std::ptr::NonNull).0: *const i32); (*_8) = const 42_i32; _3 = move _7; StorageDead(_7); - _9 = (((_3.0: std::ptr::Unique).0: std::ptr::NonNull).0: *const i32); - _2 = (*_9); + _9 = copy (((_3.0: std::ptr::Unique).0: std::ptr::NonNull).0: *const i32); + _2 = copy (*_9); - _1 = Add(move _2, const 0_i32); - StorageDead(_2); -+ _1 = _2; ++ _1 = copy _2; + nop; drop(_3) -> [return: bb2, unwind unreachable]; } diff --git a/tests/mir-opt/const_prop/boxes.main.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/boxes.main.GVN.panic-unwind.diff index 5706a739602e..d4d4f21be6e0 100644 --- a/tests/mir-opt/const_prop/boxes.main.GVN.panic-unwind.diff +++ b/tests/mir-opt/const_prop/boxes.main.GVN.panic-unwind.diff @@ -32,15 +32,15 @@ bb1: { StorageLive(_7); _7 = ShallowInitBox(move _6, i32); - _8 = (((_7.0: std::ptr::Unique).0: std::ptr::NonNull).0: *const i32); + _8 = copy (((_7.0: std::ptr::Unique).0: std::ptr::NonNull).0: *const i32); (*_8) = const 42_i32; _3 = move _7; StorageDead(_7); - _9 = (((_3.0: std::ptr::Unique).0: std::ptr::NonNull).0: *const i32); - _2 = (*_9); + _9 = copy (((_3.0: std::ptr::Unique).0: std::ptr::NonNull).0: *const i32); + _2 = copy (*_9); - _1 = Add(move _2, const 0_i32); - StorageDead(_2); -+ _1 = _2; ++ _1 = copy _2; + nop; drop(_3) -> [return: bb2, unwind: bb3]; } diff --git a/tests/mir-opt/const_prop/discriminant.main.GVN.32bit.diff b/tests/mir-opt/const_prop/discriminant.main.GVN.32bit.diff index 70c3c3fe7e49..2543cf6257d4 100644 --- a/tests/mir-opt/const_prop/discriminant.main.GVN.32bit.diff +++ b/tests/mir-opt/const_prop/discriminant.main.GVN.32bit.diff @@ -26,7 +26,7 @@ } bb1: { -- switchInt(((_3 as Some).0: bool)) -> [0: bb3, otherwise: bb2]; +- switchInt(copy ((_3 as Some).0: bool)) -> [0: bb3, otherwise: bb2]; + switchInt(const true) -> [0: bb3, otherwise: bb2]; } diff --git a/tests/mir-opt/const_prop/discriminant.main.GVN.64bit.diff b/tests/mir-opt/const_prop/discriminant.main.GVN.64bit.diff index 70c3c3fe7e49..2543cf6257d4 100644 --- a/tests/mir-opt/const_prop/discriminant.main.GVN.64bit.diff +++ b/tests/mir-opt/const_prop/discriminant.main.GVN.64bit.diff @@ -26,7 +26,7 @@ } bb1: { -- switchInt(((_3 as Some).0: bool)) -> [0: bb3, otherwise: bb2]; +- switchInt(copy ((_3 as Some).0: bool)) -> [0: bb3, otherwise: bb2]; + switchInt(const true) -> [0: bb3, otherwise: bb2]; } diff --git a/tests/mir-opt/const_prop/indirect.main.GVN.panic-abort.diff b/tests/mir-opt/const_prop/indirect.main.GVN.panic-abort.diff index f24b9755eaea..208845942c76 100644 --- a/tests/mir-opt/const_prop/indirect.main.GVN.panic-abort.diff +++ b/tests/mir-opt/const_prop/indirect.main.GVN.panic-abort.diff @@ -14,7 +14,7 @@ StorageLive(_1); StorageLive(_2); - _2 = const 2_u32 as u8 (IntToInt); -- _3 = AddWithOverflow(_2, const 1_u8); +- _3 = AddWithOverflow(copy _2, const 1_u8); - assert(!move (_3.1: bool), "attempt to compute `{} + {}`, which would overflow", move _2, const 1_u8) -> [success: bb1, unwind unreachable]; + _2 = const 2_u8; + _3 = const (3_u8, false); diff --git a/tests/mir-opt/const_prop/indirect.main.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/indirect.main.GVN.panic-unwind.diff index 44ff313b5328..4a7c69bae3ca 100644 --- a/tests/mir-opt/const_prop/indirect.main.GVN.panic-unwind.diff +++ b/tests/mir-opt/const_prop/indirect.main.GVN.panic-unwind.diff @@ -14,7 +14,7 @@ StorageLive(_1); StorageLive(_2); - _2 = const 2_u32 as u8 (IntToInt); -- _3 = AddWithOverflow(_2, const 1_u8); +- _3 = AddWithOverflow(copy _2, const 1_u8); - assert(!move (_3.1: bool), "attempt to compute `{} + {}`, which would overflow", move _2, const 1_u8) -> [success: bb1, unwind continue]; + _2 = const 2_u8; + _3 = const (3_u8, false); diff --git a/tests/mir-opt/const_prop/indirect_mutation.bar.GVN.diff b/tests/mir-opt/const_prop/indirect_mutation.bar.GVN.diff index 99a6ba7d08ab..849a57e20306 100644 --- a/tests/mir-opt/const_prop/indirect_mutation.bar.GVN.diff +++ b/tests/mir-opt/const_prop/indirect_mutation.bar.GVN.diff @@ -28,7 +28,7 @@ StorageDead(_2); StorageLive(_4); StorageLive(_5); - _5 = (_1.0: i32); + _5 = copy (_1.0: i32); _4 = Eq(move _5, const 5_i32); StorageDead(_5); _0 = const (); diff --git a/tests/mir-opt/const_prop/indirect_mutation.foo.GVN.diff b/tests/mir-opt/const_prop/indirect_mutation.foo.GVN.diff index c21869dece65..2435f81206bd 100644 --- a/tests/mir-opt/const_prop/indirect_mutation.foo.GVN.diff +++ b/tests/mir-opt/const_prop/indirect_mutation.foo.GVN.diff @@ -24,7 +24,7 @@ StorageDead(_2); StorageLive(_3); StorageLive(_4); - _4 = (_1.0: i32); + _4 = copy (_1.0: i32); _3 = Eq(move _4, const 5_i32); StorageDead(_4); _0 = const (); diff --git a/tests/mir-opt/const_prop/inherit_overflow.main.GVN.panic-abort.diff b/tests/mir-opt/const_prop/inherit_overflow.main.GVN.panic-abort.diff index de9cb7a47a2b..ab39c5be4e37 100644 --- a/tests/mir-opt/const_prop/inherit_overflow.main.GVN.panic-abort.diff +++ b/tests/mir-opt/const_prop/inherit_overflow.main.GVN.panic-abort.diff @@ -19,8 +19,8 @@ StorageLive(_3); _3 = const 1_u8; StorageLive(_4); -- _4 = AddWithOverflow(_2, _3); -- assert(!move (_4.1: bool), "attempt to compute `{} + {}`, which would overflow", _2, _3) -> [success: bb1, unwind unreachable]; +- _4 = AddWithOverflow(copy _2, copy _3); +- assert(!move (_4.1: bool), "attempt to compute `{} + {}`, which would overflow", copy _2, copy _3) -> [success: bb1, unwind unreachable]; + _4 = const (0_u8, true); + assert(!const true, "attempt to compute `{} + {}`, which would overflow", const u8::MAX, const 1_u8) -> [success: bb1, unwind unreachable]; } diff --git a/tests/mir-opt/const_prop/inherit_overflow.main.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/inherit_overflow.main.GVN.panic-unwind.diff index 1f19a13c1e8c..1aea0dbb5d53 100644 --- a/tests/mir-opt/const_prop/inherit_overflow.main.GVN.panic-unwind.diff +++ b/tests/mir-opt/const_prop/inherit_overflow.main.GVN.panic-unwind.diff @@ -19,8 +19,8 @@ StorageLive(_3); _3 = const 1_u8; StorageLive(_4); -- _4 = AddWithOverflow(_2, _3); -- assert(!move (_4.1: bool), "attempt to compute `{} + {}`, which would overflow", _2, _3) -> [success: bb1, unwind continue]; +- _4 = AddWithOverflow(copy _2, copy _3); +- assert(!move (_4.1: bool), "attempt to compute `{} + {}`, which would overflow", copy _2, copy _3) -> [success: bb1, unwind continue]; + _4 = const (0_u8, true); + assert(!const true, "attempt to compute `{} + {}`, which would overflow", const u8::MAX, const 1_u8) -> [success: bb1, unwind continue]; } diff --git a/tests/mir-opt/const_prop/invalid_constant.main.GVN.diff b/tests/mir-opt/const_prop/invalid_constant.main.GVN.diff index f50413656049..5e843da86792 100644 --- a/tests/mir-opt/const_prop/invalid_constant.main.GVN.diff +++ b/tests/mir-opt/const_prop/invalid_constant.main.GVN.diff @@ -29,13 +29,13 @@ StorageLive(_1); StorageLive(_2); _2 = InvalidChar { int: const 1114113_u32 }; - _1 = (_2.1: char); + _1 = copy (_2.1: char); StorageDead(_2); StorageLive(_3); StorageLive(_4); StorageLive(_5); _5 = InvalidTag { int: const 4_u32 }; - _4 = (_5.1: E); + _4 = copy (_5.1: E); _3 = [move _4]; StorageDead(_4); StorageDead(_5); diff --git a/tests/mir-opt/const_prop/invalid_constant.main.RemoveZsts.diff b/tests/mir-opt/const_prop/invalid_constant.main.RemoveZsts.diff index 6e5ad8d6b81a..6593b329756c 100644 --- a/tests/mir-opt/const_prop/invalid_constant.main.RemoveZsts.diff +++ b/tests/mir-opt/const_prop/invalid_constant.main.RemoveZsts.diff @@ -31,13 +31,13 @@ StorageLive(_1); StorageLive(_2); _2 = InvalidChar { int: const 1114113_u32 }; - _1 = (_2.1: char); + _1 = copy (_2.1: char); StorageDead(_2); StorageLive(_3); StorageLive(_4); StorageLive(_5); _5 = InvalidTag { int: const 4_u32 }; - _4 = (_5.1: E); + _4 = copy (_5.1: E); _3 = [move _4]; StorageDead(_4); StorageDead(_5); @@ -47,7 +47,7 @@ + nop; StorageLive(_8); _8 = NoVariants { int: const 0_u32 }; -- _7 = (_8.1: Empty); +- _7 = copy (_8.1: Empty); - _6 = [move _7]; - StorageDead(_7); + nop; diff --git a/tests/mir-opt/const_prop/large_array_index.main.GVN.32bit.panic-abort.diff b/tests/mir-opt/const_prop/large_array_index.main.GVN.32bit.panic-abort.diff index bd987c01ab16..49ea51deed69 100644 --- a/tests/mir-opt/const_prop/large_array_index.main.GVN.32bit.panic-abort.diff +++ b/tests/mir-opt/const_prop/large_array_index.main.GVN.32bit.panic-abort.diff @@ -19,15 +19,15 @@ StorageLive(_3); _3 = const 2_usize; - _4 = Len(_2); -- _5 = Lt(_3, _4); -- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind unreachable]; +- _5 = Lt(copy _3, copy _4); +- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind unreachable]; + _4 = const 5000_usize; + _5 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 5000_usize, const 2_usize) -> [success: bb1, unwind unreachable]; } bb1: { -- _1 = _2[_3]; +- _1 = copy _2[_3]; + _1 = const 0_u8; StorageDead(_3); StorageDead(_2); diff --git a/tests/mir-opt/const_prop/large_array_index.main.GVN.32bit.panic-unwind.diff b/tests/mir-opt/const_prop/large_array_index.main.GVN.32bit.panic-unwind.diff index e9ebef84ae04..103bfbcaf642 100644 --- a/tests/mir-opt/const_prop/large_array_index.main.GVN.32bit.panic-unwind.diff +++ b/tests/mir-opt/const_prop/large_array_index.main.GVN.32bit.panic-unwind.diff @@ -19,15 +19,15 @@ StorageLive(_3); _3 = const 2_usize; - _4 = Len(_2); -- _5 = Lt(_3, _4); -- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind continue]; +- _5 = Lt(copy _3, copy _4); +- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind continue]; + _4 = const 5000_usize; + _5 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 5000_usize, const 2_usize) -> [success: bb1, unwind continue]; } bb1: { -- _1 = _2[_3]; +- _1 = copy _2[_3]; + _1 = const 0_u8; StorageDead(_3); StorageDead(_2); diff --git a/tests/mir-opt/const_prop/large_array_index.main.GVN.64bit.panic-abort.diff b/tests/mir-opt/const_prop/large_array_index.main.GVN.64bit.panic-abort.diff index bd987c01ab16..49ea51deed69 100644 --- a/tests/mir-opt/const_prop/large_array_index.main.GVN.64bit.panic-abort.diff +++ b/tests/mir-opt/const_prop/large_array_index.main.GVN.64bit.panic-abort.diff @@ -19,15 +19,15 @@ StorageLive(_3); _3 = const 2_usize; - _4 = Len(_2); -- _5 = Lt(_3, _4); -- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind unreachable]; +- _5 = Lt(copy _3, copy _4); +- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind unreachable]; + _4 = const 5000_usize; + _5 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 5000_usize, const 2_usize) -> [success: bb1, unwind unreachable]; } bb1: { -- _1 = _2[_3]; +- _1 = copy _2[_3]; + _1 = const 0_u8; StorageDead(_3); StorageDead(_2); diff --git a/tests/mir-opt/const_prop/large_array_index.main.GVN.64bit.panic-unwind.diff b/tests/mir-opt/const_prop/large_array_index.main.GVN.64bit.panic-unwind.diff index e9ebef84ae04..103bfbcaf642 100644 --- a/tests/mir-opt/const_prop/large_array_index.main.GVN.64bit.panic-unwind.diff +++ b/tests/mir-opt/const_prop/large_array_index.main.GVN.64bit.panic-unwind.diff @@ -19,15 +19,15 @@ StorageLive(_3); _3 = const 2_usize; - _4 = Len(_2); -- _5 = Lt(_3, _4); -- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind continue]; +- _5 = Lt(copy _3, copy _4); +- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind continue]; + _4 = const 5000_usize; + _5 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 5000_usize, const 2_usize) -> [success: bb1, unwind continue]; } bb1: { -- _1 = _2[_3]; +- _1 = copy _2[_3]; + _1 = const 0_u8; StorageDead(_3); StorageDead(_2); diff --git a/tests/mir-opt/const_prop/mult_by_zero.test.GVN.diff b/tests/mir-opt/const_prop/mult_by_zero.test.GVN.diff index 6c2aab45d48b..290d9d62ce02 100644 --- a/tests/mir-opt/const_prop/mult_by_zero.test.GVN.diff +++ b/tests/mir-opt/const_prop/mult_by_zero.test.GVN.diff @@ -8,7 +8,7 @@ bb0: { StorageLive(_2); - _2 = _1; + _2 = copy _1; - _0 = Mul(move _2, const 0_i32); + _0 = const 0_i32; StorageDead(_2); diff --git a/tests/mir-opt/const_prop/mutable_variable.main.GVN.diff b/tests/mir-opt/const_prop/mutable_variable.main.GVN.diff index 11464e324002..cc25b6caf90d 100644 --- a/tests/mir-opt/const_prop/mutable_variable.main.GVN.diff +++ b/tests/mir-opt/const_prop/mutable_variable.main.GVN.diff @@ -17,7 +17,7 @@ _1 = const 42_i32; _1 = const 99_i32; StorageLive(_2); - _2 = _1; + _2 = copy _1; _0 = const (); StorageDead(_2); StorageDead(_1); diff --git a/tests/mir-opt/const_prop/mutable_variable_aggregate.main.GVN.diff b/tests/mir-opt/const_prop/mutable_variable_aggregate.main.GVN.diff index 7584353620ec..3cc71eee710b 100644 --- a/tests/mir-opt/const_prop/mutable_variable_aggregate.main.GVN.diff +++ b/tests/mir-opt/const_prop/mutable_variable_aggregate.main.GVN.diff @@ -18,7 +18,7 @@ + _1 = const (42_i32, 43_i32); (_1.1: i32) = const 99_i32; StorageLive(_2); - _2 = _1; + _2 = copy _1; _0 = const (); StorageDead(_2); StorageDead(_1); diff --git a/tests/mir-opt/const_prop/mutable_variable_aggregate_mut_ref.main.GVN.diff b/tests/mir-opt/const_prop/mutable_variable_aggregate_mut_ref.main.GVN.diff index e16e2969eb89..569ad62b5cc5 100644 --- a/tests/mir-opt/const_prop/mutable_variable_aggregate_mut_ref.main.GVN.diff +++ b/tests/mir-opt/const_prop/mutable_variable_aggregate_mut_ref.main.GVN.diff @@ -24,7 +24,7 @@ _2 = &mut _1; ((*_2).1: i32) = const 99_i32; StorageLive(_3); - _3 = _1; + _3 = copy _1; _0 = const (); StorageDead(_3); StorageDead(_2); diff --git a/tests/mir-opt/const_prop/mutable_variable_aggregate_partial_read.main.GVN.panic-abort.diff b/tests/mir-opt/const_prop/mutable_variable_aggregate_partial_read.main.GVN.panic-abort.diff index 6480e480f8c5..5b4d18a3c070 100644 --- a/tests/mir-opt/const_prop/mutable_variable_aggregate_partial_read.main.GVN.panic-abort.diff +++ b/tests/mir-opt/const_prop/mutable_variable_aggregate_partial_read.main.GVN.panic-abort.diff @@ -21,7 +21,7 @@ (_1.1: i32) = const 99_i32; (_1.0: i32) = const 42_i32; StorageLive(_2); - _2 = (_1.1: i32); + _2 = copy (_1.1: i32); _0 = const (); StorageDead(_2); StorageDead(_1); diff --git a/tests/mir-opt/const_prop/mutable_variable_aggregate_partial_read.main.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/mutable_variable_aggregate_partial_read.main.GVN.panic-unwind.diff index fb757801082e..d58febe368d1 100644 --- a/tests/mir-opt/const_prop/mutable_variable_aggregate_partial_read.main.GVN.panic-unwind.diff +++ b/tests/mir-opt/const_prop/mutable_variable_aggregate_partial_read.main.GVN.panic-unwind.diff @@ -21,7 +21,7 @@ (_1.1: i32) = const 99_i32; (_1.0: i32) = const 42_i32; StorageLive(_2); - _2 = (_1.1: i32); + _2 = copy (_1.1: i32); _0 = const (); StorageDead(_2); StorageDead(_1); diff --git a/tests/mir-opt/const_prop/mutable_variable_no_prop.main.GVN.diff b/tests/mir-opt/const_prop/mutable_variable_no_prop.main.GVN.diff index 31c839f67490..3f8dc12f4ae5 100644 --- a/tests/mir-opt/const_prop/mutable_variable_no_prop.main.GVN.diff +++ b/tests/mir-opt/const_prop/mutable_variable_no_prop.main.GVN.diff @@ -22,14 +22,14 @@ StorageLive(_3); StorageLive(_4); _4 = const {ALLOC0: *mut u32}; - _3 = (*_4); + _3 = copy (*_4); _1 = move _3; StorageDead(_3); StorageDead(_4); _2 = const (); StorageDead(_2); StorageLive(_5); - _5 = _1; + _5 = copy _1; _0 = const (); StorageDead(_5); StorageDead(_1); diff --git a/tests/mir-opt/const_prop/mutable_variable_unprop_assign.main.GVN.panic-abort.diff b/tests/mir-opt/const_prop/mutable_variable_unprop_assign.main.GVN.panic-abort.diff index 19d79694666f..7ca1b39d7711 100644 --- a/tests/mir-opt/const_prop/mutable_variable_unprop_assign.main.GVN.panic-abort.diff +++ b/tests/mir-opt/const_prop/mutable_variable_unprop_assign.main.GVN.panic-abort.diff @@ -32,14 +32,14 @@ - _2 = (const 1_i32, const 2_i32); + _2 = const (1_i32, 2_i32); StorageLive(_3); - _3 = _1; + _3 = copy _1; - (_2.1: i32) = move _3; -+ (_2.1: i32) = _1; ++ (_2.1: i32) = copy _1; StorageDead(_3); StorageLive(_4); - _4 = (_2.1: i32); + _4 = copy (_2.1: i32); StorageLive(_5); - _5 = (_2.0: i32); + _5 = copy (_2.0: i32); _0 = const (); StorageDead(_5); StorageDead(_4); diff --git a/tests/mir-opt/const_prop/mutable_variable_unprop_assign.main.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/mutable_variable_unprop_assign.main.GVN.panic-unwind.diff index 2bb277bf27f7..f63795138066 100644 --- a/tests/mir-opt/const_prop/mutable_variable_unprop_assign.main.GVN.panic-unwind.diff +++ b/tests/mir-opt/const_prop/mutable_variable_unprop_assign.main.GVN.panic-unwind.diff @@ -32,14 +32,14 @@ - _2 = (const 1_i32, const 2_i32); + _2 = const (1_i32, 2_i32); StorageLive(_3); - _3 = _1; + _3 = copy _1; - (_2.1: i32) = move _3; -+ (_2.1: i32) = _1; ++ (_2.1: i32) = copy _1; StorageDead(_3); StorageLive(_4); - _4 = (_2.1: i32); + _4 = copy (_2.1: i32); StorageLive(_5); - _5 = (_2.0: i32); + _5 = copy (_2.0: i32); _0 = const (); StorageDead(_5); StorageDead(_4); diff --git a/tests/mir-opt/const_prop/overwrite_with_const_with_params.size_of.GVN.diff b/tests/mir-opt/const_prop/overwrite_with_const_with_params.size_of.GVN.diff index 1eadffa4f365..da6ef0a978b4 100644 --- a/tests/mir-opt/const_prop/overwrite_with_const_with_params.size_of.GVN.diff +++ b/tests/mir-opt/const_prop/overwrite_with_const_with_params.size_of.GVN.diff @@ -12,7 +12,7 @@ StorageLive(_1); _1 = const 0_usize; _1 = const SizeOfConst::::SIZE; - _0 = _1; + _0 = copy _1; StorageDead(_1); return; } diff --git a/tests/mir-opt/const_prop/pointer_expose_provenance.main.GVN.panic-abort.diff b/tests/mir-opt/const_prop/pointer_expose_provenance.main.GVN.panic-abort.diff index 79a95b618d17..657fa7a5fea1 100644 --- a/tests/mir-opt/const_prop/pointer_expose_provenance.main.GVN.panic-abort.diff +++ b/tests/mir-opt/const_prop/pointer_expose_provenance.main.GVN.panic-abort.diff @@ -24,9 +24,9 @@ StorageDead(_3); StorageLive(_4); StorageLive(_5); - _5 = _1; + _5 = copy _1; - _4 = read(move _5) -> [return: bb1, unwind unreachable]; -+ _4 = read(_1) -> [return: bb1, unwind unreachable]; ++ _4 = read(copy _1) -> [return: bb1, unwind unreachable]; } bb1: { diff --git a/tests/mir-opt/const_prop/pointer_expose_provenance.main.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/pointer_expose_provenance.main.GVN.panic-unwind.diff index 9d1bcd92fef2..8fef6591d41d 100644 --- a/tests/mir-opt/const_prop/pointer_expose_provenance.main.GVN.panic-unwind.diff +++ b/tests/mir-opt/const_prop/pointer_expose_provenance.main.GVN.panic-unwind.diff @@ -24,9 +24,9 @@ StorageDead(_3); StorageLive(_4); StorageLive(_5); - _5 = _1; + _5 = copy _1; - _4 = read(move _5) -> [return: bb1, unwind continue]; -+ _4 = read(_1) -> [return: bb1, unwind continue]; ++ _4 = read(copy _1) -> [return: bb1, unwind continue]; } bb1: { diff --git a/tests/mir-opt/const_prop/read_immutable_static.main.GVN.diff b/tests/mir-opt/const_prop/read_immutable_static.main.GVN.diff index 38f235052303..8df262b351f1 100644 --- a/tests/mir-opt/const_prop/read_immutable_static.main.GVN.diff +++ b/tests/mir-opt/const_prop/read_immutable_static.main.GVN.diff @@ -19,12 +19,12 @@ + nop; + nop; _3 = const {ALLOC0: &u8}; -- _2 = (*_3); +- _2 = copy (*_3); + _2 = const 2_u8; StorageLive(_4); StorageLive(_5); _5 = const {ALLOC0: &u8}; -- _4 = (*_5); +- _4 = copy (*_5); - _1 = Add(move _2, move _4); + _4 = const 2_u8; + _1 = const 4_u8; diff --git a/tests/mir-opt/const_prop/ref_deref.main.GVN.diff b/tests/mir-opt/const_prop/ref_deref.main.GVN.diff index 509924a91c51..b9e269266b0b 100644 --- a/tests/mir-opt/const_prop/ref_deref.main.GVN.diff +++ b/tests/mir-opt/const_prop/ref_deref.main.GVN.diff @@ -16,7 +16,7 @@ StorageLive(_2); _4 = const main::promoted[0]; _2 = &(*_4); -- _1 = (*_2); +- _1 = copy (*_2); + _1 = const 4_i32; StorageDead(_2); _0 = const (); diff --git a/tests/mir-opt/const_prop/ref_deref_project.main.GVN.diff b/tests/mir-opt/const_prop/ref_deref_project.main.GVN.diff index 820c6cc06806..dcc13c9251c4 100644 --- a/tests/mir-opt/const_prop/ref_deref_project.main.GVN.diff +++ b/tests/mir-opt/const_prop/ref_deref_project.main.GVN.diff @@ -16,7 +16,7 @@ StorageLive(_2); _4 = const main::promoted[0]; _2 = &((*_4).1: i32); -- _1 = (*_2); +- _1 = copy (*_2); + _1 = const 5_i32; StorageDead(_2); _0 = const (); diff --git a/tests/mir-opt/const_prop/repeat.main.GVN.32bit.panic-abort.diff b/tests/mir-opt/const_prop/repeat.main.GVN.32bit.panic-abort.diff index 71635b8e9c3e..f7c1c2da01fc 100644 --- a/tests/mir-opt/const_prop/repeat.main.GVN.32bit.panic-abort.diff +++ b/tests/mir-opt/const_prop/repeat.main.GVN.32bit.panic-abort.diff @@ -21,15 +21,15 @@ StorageLive(_4); _4 = const 2_usize; - _5 = Len(_3); -- _6 = Lt(_4, _5); -- assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, _4) -> [success: bb1, unwind unreachable]; +- _6 = Lt(copy _4, copy _5); +- assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, copy _4) -> [success: bb1, unwind unreachable]; + _5 = const 8_usize; + _6 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 8_usize, const 2_usize) -> [success: bb1, unwind unreachable]; } bb1: { -- _2 = _3[_4]; +- _2 = copy _3[_4]; - _1 = Add(move _2, const 0_u32); + _2 = const 42_u32; + _1 = const 42_u32; diff --git a/tests/mir-opt/const_prop/repeat.main.GVN.32bit.panic-unwind.diff b/tests/mir-opt/const_prop/repeat.main.GVN.32bit.panic-unwind.diff index 84205028d6d2..436773c85563 100644 --- a/tests/mir-opt/const_prop/repeat.main.GVN.32bit.panic-unwind.diff +++ b/tests/mir-opt/const_prop/repeat.main.GVN.32bit.panic-unwind.diff @@ -21,15 +21,15 @@ StorageLive(_4); _4 = const 2_usize; - _5 = Len(_3); -- _6 = Lt(_4, _5); -- assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, _4) -> [success: bb1, unwind continue]; +- _6 = Lt(copy _4, copy _5); +- assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, copy _4) -> [success: bb1, unwind continue]; + _5 = const 8_usize; + _6 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 8_usize, const 2_usize) -> [success: bb1, unwind continue]; } bb1: { -- _2 = _3[_4]; +- _2 = copy _3[_4]; - _1 = Add(move _2, const 0_u32); + _2 = const 42_u32; + _1 = const 42_u32; diff --git a/tests/mir-opt/const_prop/repeat.main.GVN.64bit.panic-abort.diff b/tests/mir-opt/const_prop/repeat.main.GVN.64bit.panic-abort.diff index 71635b8e9c3e..f7c1c2da01fc 100644 --- a/tests/mir-opt/const_prop/repeat.main.GVN.64bit.panic-abort.diff +++ b/tests/mir-opt/const_prop/repeat.main.GVN.64bit.panic-abort.diff @@ -21,15 +21,15 @@ StorageLive(_4); _4 = const 2_usize; - _5 = Len(_3); -- _6 = Lt(_4, _5); -- assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, _4) -> [success: bb1, unwind unreachable]; +- _6 = Lt(copy _4, copy _5); +- assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, copy _4) -> [success: bb1, unwind unreachable]; + _5 = const 8_usize; + _6 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 8_usize, const 2_usize) -> [success: bb1, unwind unreachable]; } bb1: { -- _2 = _3[_4]; +- _2 = copy _3[_4]; - _1 = Add(move _2, const 0_u32); + _2 = const 42_u32; + _1 = const 42_u32; diff --git a/tests/mir-opt/const_prop/repeat.main.GVN.64bit.panic-unwind.diff b/tests/mir-opt/const_prop/repeat.main.GVN.64bit.panic-unwind.diff index 84205028d6d2..436773c85563 100644 --- a/tests/mir-opt/const_prop/repeat.main.GVN.64bit.panic-unwind.diff +++ b/tests/mir-opt/const_prop/repeat.main.GVN.64bit.panic-unwind.diff @@ -21,15 +21,15 @@ StorageLive(_4); _4 = const 2_usize; - _5 = Len(_3); -- _6 = Lt(_4, _5); -- assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, _4) -> [success: bb1, unwind continue]; +- _6 = Lt(copy _4, copy _5); +- assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, copy _4) -> [success: bb1, unwind continue]; + _5 = const 8_usize; + _6 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 8_usize, const 2_usize) -> [success: bb1, unwind continue]; } bb1: { -- _2 = _3[_4]; +- _2 = copy _3[_4]; - _1 = Add(move _2, const 0_u32); + _2 = const 42_u32; + _1 = const 42_u32; diff --git a/tests/mir-opt/const_prop/scalar_literal_propagation.main.GVN.panic-abort.diff b/tests/mir-opt/const_prop/scalar_literal_propagation.main.GVN.panic-abort.diff index 0a20fb0e59ef..3c73d34474c1 100644 --- a/tests/mir-opt/const_prop/scalar_literal_propagation.main.GVN.panic-abort.diff +++ b/tests/mir-opt/const_prop/scalar_literal_propagation.main.GVN.panic-abort.diff @@ -16,7 +16,7 @@ _1 = const 1_u32; StorageLive(_2); StorageLive(_3); -- _3 = _1; +- _3 = copy _1; - _2 = consume(move _3) -> [return: bb1, unwind unreachable]; + _3 = const 1_u32; + _2 = consume(const 1_u32) -> [return: bb1, unwind unreachable]; diff --git a/tests/mir-opt/const_prop/scalar_literal_propagation.main.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/scalar_literal_propagation.main.GVN.panic-unwind.diff index 8b9519d3adc4..0a7fddee39b6 100644 --- a/tests/mir-opt/const_prop/scalar_literal_propagation.main.GVN.panic-unwind.diff +++ b/tests/mir-opt/const_prop/scalar_literal_propagation.main.GVN.panic-unwind.diff @@ -16,7 +16,7 @@ _1 = const 1_u32; StorageLive(_2); StorageLive(_3); -- _3 = _1; +- _3 = copy _1; - _2 = consume(move _3) -> [return: bb1, unwind continue]; + _3 = const 1_u32; + _2 = consume(const 1_u32) -> [return: bb1, unwind continue]; diff --git a/tests/mir-opt/const_prop/slice_len.main.GVN.32bit.panic-abort.diff b/tests/mir-opt/const_prop/slice_len.main.GVN.32bit.panic-abort.diff index 21d91d0320ae..e834a5802c33 100644 --- a/tests/mir-opt/const_prop/slice_len.main.GVN.32bit.panic-abort.diff +++ b/tests/mir-opt/const_prop/slice_len.main.GVN.32bit.panic-abort.diff @@ -22,24 +22,24 @@ StorageLive(_3); StorageLive(_4); _9 = const main::promoted[0]; - _4 = _9; -- _3 = _4; + _4 = copy _9; +- _3 = copy _4; - _2 = move _3 as &[u32] (PointerCoercion(Unsize)); -+ _3 = _9; -+ _2 = _9 as &[u32] (PointerCoercion(Unsize)); ++ _3 = copy _9; ++ _2 = copy _9 as &[u32] (PointerCoercion(Unsize)); StorageDead(_3); StorageLive(_6); _6 = const 1_usize; - _7 = Len((*_2)); -- _8 = Lt(_6, _7); -- assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, _6) -> [success: bb1, unwind unreachable]; +- _8 = Lt(copy _6, copy _7); +- assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, copy _6) -> [success: bb1, unwind unreachable]; + _7 = const 3_usize; + _8 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 1_usize) -> [success: bb1, unwind unreachable]; } bb1: { -- _1 = (*_2)[_6]; +- _1 = copy (*_2)[_6]; + _1 = const 2_u32; StorageDead(_6); StorageDead(_4); diff --git a/tests/mir-opt/const_prop/slice_len.main.GVN.32bit.panic-unwind.diff b/tests/mir-opt/const_prop/slice_len.main.GVN.32bit.panic-unwind.diff index 889114c98623..55ffc5018056 100644 --- a/tests/mir-opt/const_prop/slice_len.main.GVN.32bit.panic-unwind.diff +++ b/tests/mir-opt/const_prop/slice_len.main.GVN.32bit.panic-unwind.diff @@ -22,24 +22,24 @@ StorageLive(_3); StorageLive(_4); _9 = const main::promoted[0]; - _4 = _9; -- _3 = _4; + _4 = copy _9; +- _3 = copy _4; - _2 = move _3 as &[u32] (PointerCoercion(Unsize)); -+ _3 = _9; -+ _2 = _9 as &[u32] (PointerCoercion(Unsize)); ++ _3 = copy _9; ++ _2 = copy _9 as &[u32] (PointerCoercion(Unsize)); StorageDead(_3); StorageLive(_6); _6 = const 1_usize; - _7 = Len((*_2)); -- _8 = Lt(_6, _7); -- assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, _6) -> [success: bb1, unwind continue]; +- _8 = Lt(copy _6, copy _7); +- assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, copy _6) -> [success: bb1, unwind continue]; + _7 = const 3_usize; + _8 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 1_usize) -> [success: bb1, unwind continue]; } bb1: { -- _1 = (*_2)[_6]; +- _1 = copy (*_2)[_6]; + _1 = const 2_u32; StorageDead(_6); StorageDead(_4); diff --git a/tests/mir-opt/const_prop/slice_len.main.GVN.64bit.panic-abort.diff b/tests/mir-opt/const_prop/slice_len.main.GVN.64bit.panic-abort.diff index 21d91d0320ae..e834a5802c33 100644 --- a/tests/mir-opt/const_prop/slice_len.main.GVN.64bit.panic-abort.diff +++ b/tests/mir-opt/const_prop/slice_len.main.GVN.64bit.panic-abort.diff @@ -22,24 +22,24 @@ StorageLive(_3); StorageLive(_4); _9 = const main::promoted[0]; - _4 = _9; -- _3 = _4; + _4 = copy _9; +- _3 = copy _4; - _2 = move _3 as &[u32] (PointerCoercion(Unsize)); -+ _3 = _9; -+ _2 = _9 as &[u32] (PointerCoercion(Unsize)); ++ _3 = copy _9; ++ _2 = copy _9 as &[u32] (PointerCoercion(Unsize)); StorageDead(_3); StorageLive(_6); _6 = const 1_usize; - _7 = Len((*_2)); -- _8 = Lt(_6, _7); -- assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, _6) -> [success: bb1, unwind unreachable]; +- _8 = Lt(copy _6, copy _7); +- assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, copy _6) -> [success: bb1, unwind unreachable]; + _7 = const 3_usize; + _8 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 1_usize) -> [success: bb1, unwind unreachable]; } bb1: { -- _1 = (*_2)[_6]; +- _1 = copy (*_2)[_6]; + _1 = const 2_u32; StorageDead(_6); StorageDead(_4); diff --git a/tests/mir-opt/const_prop/slice_len.main.GVN.64bit.panic-unwind.diff b/tests/mir-opt/const_prop/slice_len.main.GVN.64bit.panic-unwind.diff index 889114c98623..55ffc5018056 100644 --- a/tests/mir-opt/const_prop/slice_len.main.GVN.64bit.panic-unwind.diff +++ b/tests/mir-opt/const_prop/slice_len.main.GVN.64bit.panic-unwind.diff @@ -22,24 +22,24 @@ StorageLive(_3); StorageLive(_4); _9 = const main::promoted[0]; - _4 = _9; -- _3 = _4; + _4 = copy _9; +- _3 = copy _4; - _2 = move _3 as &[u32] (PointerCoercion(Unsize)); -+ _3 = _9; -+ _2 = _9 as &[u32] (PointerCoercion(Unsize)); ++ _3 = copy _9; ++ _2 = copy _9 as &[u32] (PointerCoercion(Unsize)); StorageDead(_3); StorageLive(_6); _6 = const 1_usize; - _7 = Len((*_2)); -- _8 = Lt(_6, _7); -- assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, _6) -> [success: bb1, unwind continue]; +- _8 = Lt(copy _6, copy _7); +- assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, copy _6) -> [success: bb1, unwind continue]; + _7 = const 3_usize; + _8 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 1_usize) -> [success: bb1, unwind continue]; } bb1: { -- _1 = (*_2)[_6]; +- _1 = copy (*_2)[_6]; + _1 = const 2_u32; StorageDead(_6); StorageDead(_4); diff --git a/tests/mir-opt/const_prop/switch_int.main.GVN.panic-abort.diff b/tests/mir-opt/const_prop/switch_int.main.GVN.panic-abort.diff index ee9f2d5c7f5b..2339f110f5a1 100644 --- a/tests/mir-opt/const_prop/switch_int.main.GVN.panic-abort.diff +++ b/tests/mir-opt/const_prop/switch_int.main.GVN.panic-abort.diff @@ -8,7 +8,7 @@ bb0: { StorageLive(_1); _1 = const 1_i32; -- switchInt(_1) -> [1: bb2, otherwise: bb1]; +- switchInt(copy _1) -> [1: bb2, otherwise: bb1]; + switchInt(const 1_i32) -> [1: bb2, otherwise: bb1]; } diff --git a/tests/mir-opt/const_prop/switch_int.main.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/switch_int.main.GVN.panic-unwind.diff index 143d04ac984b..49082e6ba526 100644 --- a/tests/mir-opt/const_prop/switch_int.main.GVN.panic-unwind.diff +++ b/tests/mir-opt/const_prop/switch_int.main.GVN.panic-unwind.diff @@ -8,7 +8,7 @@ bb0: { StorageLive(_1); _1 = const 1_i32; -- switchInt(_1) -> [1: bb2, otherwise: bb1]; +- switchInt(copy _1) -> [1: bb2, otherwise: bb1]; + switchInt(const 1_i32) -> [1: bb2, otherwise: bb1]; } diff --git a/tests/mir-opt/const_prop/transmute.unreachable_box.GVN.32bit.diff b/tests/mir-opt/const_prop/transmute.unreachable_box.GVN.32bit.diff index 7a289563c506..de0b1a57f808 100644 --- a/tests/mir-opt/const_prop/transmute.unreachable_box.GVN.32bit.diff +++ b/tests/mir-opt/const_prop/transmute.unreachable_box.GVN.32bit.diff @@ -12,7 +12,7 @@ bb0: { StorageLive(_1); - _1 = const 1_usize as std::boxed::Box (Transmute); -- _2 = (((_1.0: std::ptr::Unique).0: std::ptr::NonNull).0: *const Never); +- _2 = copy (((_1.0: std::ptr::Unique).0: std::ptr::NonNull).0: *const Never); + _1 = const Box::(Unique:: {{ pointer: NonNull:: {{ pointer: {0x1 as *const Never} }}, _marker: PhantomData:: }}, std::alloc::Global); + _2 = const {0x1 as *const Never}; unreachable; diff --git a/tests/mir-opt/const_prop/transmute.unreachable_box.GVN.64bit.diff b/tests/mir-opt/const_prop/transmute.unreachable_box.GVN.64bit.diff index 7a289563c506..de0b1a57f808 100644 --- a/tests/mir-opt/const_prop/transmute.unreachable_box.GVN.64bit.diff +++ b/tests/mir-opt/const_prop/transmute.unreachable_box.GVN.64bit.diff @@ -12,7 +12,7 @@ bb0: { StorageLive(_1); - _1 = const 1_usize as std::boxed::Box (Transmute); -- _2 = (((_1.0: std::ptr::Unique).0: std::ptr::NonNull).0: *const Never); +- _2 = copy (((_1.0: std::ptr::Unique).0: std::ptr::NonNull).0: *const Never); + _1 = const Box::(Unique:: {{ pointer: NonNull:: {{ pointer: {0x1 as *const Never} }}, _marker: PhantomData:: }}, std::alloc::Global); + _2 = const {0x1 as *const Never}; unreachable; diff --git a/tests/mir-opt/const_prop/tuple_literal_propagation.main.GVN.panic-abort.diff b/tests/mir-opt/const_prop/tuple_literal_propagation.main.GVN.panic-abort.diff index bf8fece3d37b..01d86ce8717d 100644 --- a/tests/mir-opt/const_prop/tuple_literal_propagation.main.GVN.panic-abort.diff +++ b/tests/mir-opt/const_prop/tuple_literal_propagation.main.GVN.panic-abort.diff @@ -17,7 +17,7 @@ + _1 = const (1_u32, 2_u32); StorageLive(_2); StorageLive(_3); -- _3 = _1; +- _3 = copy _1; - _2 = consume(move _3) -> [return: bb1, unwind unreachable]; + _3 = const (1_u32, 2_u32); + _2 = consume(const (1_u32, 2_u32)) -> [return: bb1, unwind unreachable]; diff --git a/tests/mir-opt/const_prop/tuple_literal_propagation.main.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/tuple_literal_propagation.main.GVN.panic-unwind.diff index 02a75849d887..bd7d494212ce 100644 --- a/tests/mir-opt/const_prop/tuple_literal_propagation.main.GVN.panic-unwind.diff +++ b/tests/mir-opt/const_prop/tuple_literal_propagation.main.GVN.panic-unwind.diff @@ -17,7 +17,7 @@ + _1 = const (1_u32, 2_u32); StorageLive(_2); StorageLive(_3); -- _3 = _1; +- _3 = copy _1; - _2 = consume(move _3) -> [return: bb1, unwind continue]; + _3 = const (1_u32, 2_u32); + _2 = consume(const (1_u32, 2_u32)) -> [return: bb1, unwind continue]; diff --git a/tests/mir-opt/const_prop/while_let_loops.change_loop_body.GVN.diff b/tests/mir-opt/const_prop/while_let_loops.change_loop_body.GVN.diff index 9548afc9d402..f830624cae76 100644 --- a/tests/mir-opt/const_prop/while_let_loops.change_loop_body.GVN.diff +++ b/tests/mir-opt/const_prop/while_let_loops.change_loop_body.GVN.diff @@ -30,7 +30,7 @@ } bb1: { -- switchInt(((_3 as Some).0: u32)) -> [0: bb2, otherwise: bb3]; +- switchInt(copy ((_3 as Some).0: u32)) -> [0: bb2, otherwise: bb3]; + switchInt(const Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: u32) -> [0: bb2, otherwise: bb3]; } diff --git a/tests/mir-opt/copy-prop/borrowed_local.borrowed.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/borrowed_local.borrowed.CopyProp.panic-abort.diff index 897592a0e2fd..40e8c06f357e 100644 --- a/tests/mir-opt/copy-prop/borrowed_local.borrowed.CopyProp.panic-abort.diff +++ b/tests/mir-opt/copy-prop/borrowed_local.borrowed.CopyProp.panic-abort.diff @@ -7,14 +7,14 @@ let mut _3: &T; bb0: { -- _2 = _1; +- _2 = copy _1; _3 = &_1; - _0 = opaque::<&T>(_3) -> [return: bb1, unwind unreachable]; + _0 = opaque::<&T>(copy _3) -> [return: bb1, unwind unreachable]; } bb1: { -- _0 = opaque::(_2) -> [return: bb2, unwind unreachable]; -+ _0 = opaque::(_1) -> [return: bb2, unwind unreachable]; +- _0 = opaque::(copy _2) -> [return: bb2, unwind unreachable]; ++ _0 = opaque::(copy _1) -> [return: bb2, unwind unreachable]; } bb2: { diff --git a/tests/mir-opt/copy-prop/borrowed_local.borrowed.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/borrowed_local.borrowed.CopyProp.panic-unwind.diff index 33c05af91a10..d09c96c0f2ba 100644 --- a/tests/mir-opt/copy-prop/borrowed_local.borrowed.CopyProp.panic-unwind.diff +++ b/tests/mir-opt/copy-prop/borrowed_local.borrowed.CopyProp.panic-unwind.diff @@ -7,14 +7,14 @@ let mut _3: &T; bb0: { -- _2 = _1; +- _2 = copy _1; _3 = &_1; - _0 = opaque::<&T>(_3) -> [return: bb1, unwind continue]; + _0 = opaque::<&T>(copy _3) -> [return: bb1, unwind continue]; } bb1: { -- _0 = opaque::(_2) -> [return: bb2, unwind continue]; -+ _0 = opaque::(_1) -> [return: bb2, unwind continue]; +- _0 = opaque::(copy _2) -> [return: bb2, unwind continue]; ++ _0 = opaque::(copy _1) -> [return: bb2, unwind continue]; } bb2: { diff --git a/tests/mir-opt/copy-prop/borrowed_local.compare_address.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/borrowed_local.compare_address.CopyProp.panic-abort.diff index 3d6b5dffba45..7e63911d8434 100644 --- a/tests/mir-opt/copy-prop/borrowed_local.compare_address.CopyProp.panic-abort.diff +++ b/tests/mir-opt/copy-prop/borrowed_local.compare_address.CopyProp.panic-abort.diff @@ -11,13 +11,13 @@ bb0: { _1 = const 5_u8; _2 = &_1; - _3 = _1; + _3 = copy _1; _4 = &_3; - _0 = cmp_ref(_2, _4) -> [return: bb1, unwind unreachable]; + _0 = cmp_ref(copy _2, copy _4) -> [return: bb1, unwind unreachable]; } bb1: { - _0 = opaque::(_3) -> [return: bb2, unwind unreachable]; + _0 = opaque::(copy _3) -> [return: bb2, unwind unreachable]; } bb2: { diff --git a/tests/mir-opt/copy-prop/borrowed_local.compare_address.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/borrowed_local.compare_address.CopyProp.panic-unwind.diff index 0f29d2681de8..8e5f8b21fe70 100644 --- a/tests/mir-opt/copy-prop/borrowed_local.compare_address.CopyProp.panic-unwind.diff +++ b/tests/mir-opt/copy-prop/borrowed_local.compare_address.CopyProp.panic-unwind.diff @@ -11,13 +11,13 @@ bb0: { _1 = const 5_u8; _2 = &_1; - _3 = _1; + _3 = copy _1; _4 = &_3; - _0 = cmp_ref(_2, _4) -> [return: bb1, unwind continue]; + _0 = cmp_ref(copy _2, copy _4) -> [return: bb1, unwind continue]; } bb1: { - _0 = opaque::(_3) -> [return: bb2, unwind continue]; + _0 = opaque::(copy _3) -> [return: bb2, unwind continue]; } bb2: { diff --git a/tests/mir-opt/copy-prop/borrowed_local.non_freeze.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/borrowed_local.non_freeze.CopyProp.panic-abort.diff index af2aeb0dcab2..99dda2a95ffa 100644 --- a/tests/mir-opt/copy-prop/borrowed_local.non_freeze.CopyProp.panic-abort.diff +++ b/tests/mir-opt/copy-prop/borrowed_local.non_freeze.CopyProp.panic-abort.diff @@ -7,13 +7,13 @@ let mut _3: &T; bb0: { - _2 = _1; + _2 = copy _1; _3 = &_1; - _0 = opaque::<&T>(_3) -> [return: bb1, unwind unreachable]; + _0 = opaque::<&T>(copy _3) -> [return: bb1, unwind unreachable]; } bb1: { - _0 = opaque::(_2) -> [return: bb2, unwind unreachable]; + _0 = opaque::(copy _2) -> [return: bb2, unwind unreachable]; } bb2: { diff --git a/tests/mir-opt/copy-prop/borrowed_local.non_freeze.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/borrowed_local.non_freeze.CopyProp.panic-unwind.diff index 040ed0aec166..6eb48cd8dbcf 100644 --- a/tests/mir-opt/copy-prop/borrowed_local.non_freeze.CopyProp.panic-unwind.diff +++ b/tests/mir-opt/copy-prop/borrowed_local.non_freeze.CopyProp.panic-unwind.diff @@ -7,13 +7,13 @@ let mut _3: &T; bb0: { - _2 = _1; + _2 = copy _1; _3 = &_1; - _0 = opaque::<&T>(_3) -> [return: bb1, unwind continue]; + _0 = opaque::<&T>(copy _3) -> [return: bb1, unwind continue]; } bb1: { - _0 = opaque::(_2) -> [return: bb2, unwind continue]; + _0 = opaque::(copy _2) -> [return: bb2, unwind continue]; } bb2: { diff --git a/tests/mir-opt/copy-prop/branch.foo.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/branch.foo.CopyProp.panic-abort.diff index 3334cdf92e7d..c8889ee716ff 100644 --- a/tests/mir-opt/copy-prop/branch.foo.CopyProp.panic-abort.diff +++ b/tests/mir-opt/copy-prop/branch.foo.CopyProp.panic-abort.diff @@ -30,7 +30,7 @@ } bb3: { - _2 = _1; + _2 = copy _1; goto -> bb6; } @@ -41,13 +41,13 @@ bb5: { StorageDead(_4); - _2 = _1; + _2 = copy _1; goto -> bb6; } bb6: { StorageDead(_3); - _0 = _2; + _0 = copy _2; StorageDead(_2); StorageDead(_1); return; diff --git a/tests/mir-opt/copy-prop/branch.foo.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/branch.foo.CopyProp.panic-unwind.diff index 2f92d8818cff..a41c28cb8c8a 100644 --- a/tests/mir-opt/copy-prop/branch.foo.CopyProp.panic-unwind.diff +++ b/tests/mir-opt/copy-prop/branch.foo.CopyProp.panic-unwind.diff @@ -30,7 +30,7 @@ } bb3: { - _2 = _1; + _2 = copy _1; goto -> bb6; } @@ -41,13 +41,13 @@ bb5: { StorageDead(_4); - _2 = _1; + _2 = copy _1; goto -> bb6; } bb6: { StorageDead(_3); - _0 = _2; + _0 = copy _2; StorageDead(_2); StorageDead(_1); return; diff --git a/tests/mir-opt/copy-prop/calls.multiple_edges.CopyProp.diff b/tests/mir-opt/copy-prop/calls.multiple_edges.CopyProp.diff index 4d56a8b25d36..9d0a1644ae4f 100644 --- a/tests/mir-opt/copy-prop/calls.multiple_edges.CopyProp.diff +++ b/tests/mir-opt/copy-prop/calls.multiple_edges.CopyProp.diff @@ -6,7 +6,7 @@ let mut _2: u8; bb0: { - switchInt(_1) -> [1: bb1, otherwise: bb2]; + switchInt(copy _1) -> [1: bb1, otherwise: bb2]; } bb1: { @@ -14,7 +14,7 @@ } bb2: { - _0 = _2; + _0 = copy _2; return; } } diff --git a/tests/mir-opt/copy-prop/calls.nrvo.CopyProp.diff b/tests/mir-opt/copy-prop/calls.nrvo.CopyProp.diff index b5d56909b0dd..29d9ec3f2fcb 100644 --- a/tests/mir-opt/copy-prop/calls.nrvo.CopyProp.diff +++ b/tests/mir-opt/copy-prop/calls.nrvo.CopyProp.diff @@ -16,7 +16,7 @@ } bb1: { -- _0 = _1; +- _0 = copy _1; - StorageDead(_1); return; } diff --git a/tests/mir-opt/copy-prop/copy_propagation_arg.arg_src.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/copy_propagation_arg.arg_src.CopyProp.panic-abort.diff index 70674a912edd..280908ac63a6 100644 --- a/tests/mir-opt/copy-prop/copy_propagation_arg.arg_src.CopyProp.panic-abort.diff +++ b/tests/mir-opt/copy-prop/copy_propagation_arg.arg_src.CopyProp.panic-abort.diff @@ -12,10 +12,10 @@ bb0: { - StorageLive(_2); -- _2 = _1; -+ _0 = _1; +- _2 = copy _1; ++ _0 = copy _1; _1 = const 123_i32; -- _0 = _2; +- _0 = copy _2; - StorageDead(_2); return; } diff --git a/tests/mir-opt/copy-prop/copy_propagation_arg.arg_src.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/copy_propagation_arg.arg_src.CopyProp.panic-unwind.diff index 70674a912edd..280908ac63a6 100644 --- a/tests/mir-opt/copy-prop/copy_propagation_arg.arg_src.CopyProp.panic-unwind.diff +++ b/tests/mir-opt/copy-prop/copy_propagation_arg.arg_src.CopyProp.panic-unwind.diff @@ -12,10 +12,10 @@ bb0: { - StorageLive(_2); -- _2 = _1; -+ _0 = _1; +- _2 = copy _1; ++ _0 = copy _1; _1 = const 123_i32; -- _0 = _2; +- _0 = copy _2; - StorageDead(_2); return; } diff --git a/tests/mir-opt/copy-prop/copy_propagation_arg.bar.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/copy_propagation_arg.bar.CopyProp.panic-abort.diff index 9ec014e2b256..eea07d5839d4 100644 --- a/tests/mir-opt/copy-prop/copy_propagation_arg.bar.CopyProp.panic-abort.diff +++ b/tests/mir-opt/copy-prop/copy_propagation_arg.bar.CopyProp.panic-abort.diff @@ -10,7 +10,7 @@ bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; _2 = dummy(move _3) -> [return: bb1, unwind unreachable]; } diff --git a/tests/mir-opt/copy-prop/copy_propagation_arg.bar.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/copy_propagation_arg.bar.CopyProp.panic-unwind.diff index ef9c343a264d..b0e5219913a5 100644 --- a/tests/mir-opt/copy-prop/copy_propagation_arg.bar.CopyProp.panic-unwind.diff +++ b/tests/mir-opt/copy-prop/copy_propagation_arg.bar.CopyProp.panic-unwind.diff @@ -10,7 +10,7 @@ bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; _2 = dummy(move _3) -> [return: bb1, unwind continue]; } diff --git a/tests/mir-opt/copy-prop/copy_propagation_arg.baz.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/copy_propagation_arg.baz.CopyProp.panic-abort.diff index 71facf91df78..5fb14902fefd 100644 --- a/tests/mir-opt/copy-prop/copy_propagation_arg.baz.CopyProp.panic-abort.diff +++ b/tests/mir-opt/copy-prop/copy_propagation_arg.baz.CopyProp.panic-abort.diff @@ -8,10 +8,10 @@ bb0: { StorageLive(_2); - _2 = _1; + _2 = copy _1; _1 = move _2; StorageDead(_2); - _0 = _1; + _0 = copy _1; return; } } diff --git a/tests/mir-opt/copy-prop/copy_propagation_arg.baz.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/copy_propagation_arg.baz.CopyProp.panic-unwind.diff index 71facf91df78..5fb14902fefd 100644 --- a/tests/mir-opt/copy-prop/copy_propagation_arg.baz.CopyProp.panic-unwind.diff +++ b/tests/mir-opt/copy-prop/copy_propagation_arg.baz.CopyProp.panic-unwind.diff @@ -8,10 +8,10 @@ bb0: { StorageLive(_2); - _2 = _1; + _2 = copy _1; _1 = move _2; StorageDead(_2); - _0 = _1; + _0 = copy _1; return; } } diff --git a/tests/mir-opt/copy-prop/copy_propagation_arg.foo.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/copy_propagation_arg.foo.CopyProp.panic-abort.diff index 81b73e18763f..685a290492e2 100644 --- a/tests/mir-opt/copy-prop/copy_propagation_arg.foo.CopyProp.panic-abort.diff +++ b/tests/mir-opt/copy-prop/copy_propagation_arg.foo.CopyProp.panic-abort.diff @@ -10,7 +10,7 @@ bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; _2 = dummy(move _3) -> [return: bb1, unwind unreachable]; } diff --git a/tests/mir-opt/copy-prop/copy_propagation_arg.foo.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/copy_propagation_arg.foo.CopyProp.panic-unwind.diff index 769089e16f34..4a0601431abc 100644 --- a/tests/mir-opt/copy-prop/copy_propagation_arg.foo.CopyProp.panic-unwind.diff +++ b/tests/mir-opt/copy-prop/copy_propagation_arg.foo.CopyProp.panic-unwind.diff @@ -10,7 +10,7 @@ bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; _2 = dummy(move _3) -> [return: bb1, unwind continue]; } diff --git a/tests/mir-opt/copy-prop/custom_move_arg.f.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/custom_move_arg.f.CopyProp.panic-abort.diff index 7ba853010517..1445b899dee2 100644 --- a/tests/mir-opt/copy-prop/custom_move_arg.f.CopyProp.panic-abort.diff +++ b/tests/mir-opt/copy-prop/custom_move_arg.f.CopyProp.panic-abort.diff @@ -7,15 +7,15 @@ let mut _3: NotCopy; bb0: { -- _2 = _1; +- _2 = copy _1; - _0 = opaque::(move _1) -> [return: bb1, unwind unreachable]; -+ _0 = opaque::(_1) -> [return: bb1, unwind unreachable]; ++ _0 = opaque::(copy _1) -> [return: bb1, unwind unreachable]; } bb1: { - _3 = move _2; -- _0 = opaque::(_3) -> [return: bb2, unwind unreachable]; -+ _0 = opaque::(_1) -> [return: bb2, unwind unreachable]; +- _0 = opaque::(copy _3) -> [return: bb2, unwind unreachable]; ++ _0 = opaque::(copy _1) -> [return: bb2, unwind unreachable]; } bb2: { diff --git a/tests/mir-opt/copy-prop/custom_move_arg.f.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/custom_move_arg.f.CopyProp.panic-unwind.diff index 7ba853010517..1445b899dee2 100644 --- a/tests/mir-opt/copy-prop/custom_move_arg.f.CopyProp.panic-unwind.diff +++ b/tests/mir-opt/copy-prop/custom_move_arg.f.CopyProp.panic-unwind.diff @@ -7,15 +7,15 @@ let mut _3: NotCopy; bb0: { -- _2 = _1; +- _2 = copy _1; - _0 = opaque::(move _1) -> [return: bb1, unwind unreachable]; -+ _0 = opaque::(_1) -> [return: bb1, unwind unreachable]; ++ _0 = opaque::(copy _1) -> [return: bb1, unwind unreachable]; } bb1: { - _3 = move _2; -- _0 = opaque::(_3) -> [return: bb2, unwind unreachable]; -+ _0 = opaque::(_1) -> [return: bb2, unwind unreachable]; +- _0 = opaque::(copy _3) -> [return: bb2, unwind unreachable]; ++ _0 = opaque::(copy _1) -> [return: bb2, unwind unreachable]; } bb2: { diff --git a/tests/mir-opt/copy-prop/cycle.main.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/cycle.main.CopyProp.panic-abort.diff index 8f97c4e439e9..d133091e6a43 100644 --- a/tests/mir-opt/copy-prop/cycle.main.CopyProp.panic-abort.diff +++ b/tests/mir-opt/copy-prop/cycle.main.CopyProp.panic-abort.diff @@ -27,17 +27,17 @@ bb1: { - StorageLive(_2); - _2 = _1; + _2 = copy _1; - StorageLive(_3); -- _3 = _2; +- _3 = copy _2; - StorageLive(_4); -- _4 = _3; +- _4 = copy _3; - _1 = move _4; - StorageDead(_4); -+ _1 = _2; ++ _1 = copy _2; StorageLive(_5); StorageLive(_6); - _6 = _1; + _6 = copy _1; _5 = std::mem::drop::(move _6) -> [return: bb2, unwind unreachable]; } diff --git a/tests/mir-opt/copy-prop/cycle.main.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/cycle.main.CopyProp.panic-unwind.diff index e343b78924ab..bd4ad737cec1 100644 --- a/tests/mir-opt/copy-prop/cycle.main.CopyProp.panic-unwind.diff +++ b/tests/mir-opt/copy-prop/cycle.main.CopyProp.panic-unwind.diff @@ -27,17 +27,17 @@ bb1: { - StorageLive(_2); - _2 = _1; + _2 = copy _1; - StorageLive(_3); -- _3 = _2; +- _3 = copy _2; - StorageLive(_4); -- _4 = _3; +- _4 = copy _3; - _1 = move _4; - StorageDead(_4); -+ _1 = _2; ++ _1 = copy _2; StorageLive(_5); StorageLive(_6); - _6 = _1; + _6 = copy _1; _5 = std::mem::drop::(move _6) -> [return: bb2, unwind continue]; } diff --git a/tests/mir-opt/copy-prop/dead_stores_79191.f.CopyProp.after.panic-abort.mir b/tests/mir-opt/copy-prop/dead_stores_79191.f.CopyProp.after.panic-abort.mir index 02b88d140035..4781fdfd902a 100644 --- a/tests/mir-opt/copy-prop/dead_stores_79191.f.CopyProp.after.panic-abort.mir +++ b/tests/mir-opt/copy-prop/dead_stores_79191.f.CopyProp.after.panic-abort.mir @@ -11,11 +11,11 @@ fn f(_1: usize) -> usize { } bb0: { - _2 = _1; + _2 = copy _1; _1 = const 5_usize; - _1 = _2; + _1 = copy _2; StorageLive(_4); - _4 = _1; + _4 = copy _1; _0 = id::(move _4) -> [return: bb1, unwind unreachable]; } diff --git a/tests/mir-opt/copy-prop/dead_stores_79191.f.CopyProp.after.panic-unwind.mir b/tests/mir-opt/copy-prop/dead_stores_79191.f.CopyProp.after.panic-unwind.mir index f8c285ff3843..f5fded45c13b 100644 --- a/tests/mir-opt/copy-prop/dead_stores_79191.f.CopyProp.after.panic-unwind.mir +++ b/tests/mir-opt/copy-prop/dead_stores_79191.f.CopyProp.after.panic-unwind.mir @@ -11,11 +11,11 @@ fn f(_1: usize) -> usize { } bb0: { - _2 = _1; + _2 = copy _1; _1 = const 5_usize; - _1 = _2; + _1 = copy _2; StorageLive(_4); - _4 = _1; + _4 = copy _1; _0 = id::(move _4) -> [return: bb1, unwind continue]; } diff --git a/tests/mir-opt/copy-prop/dead_stores_better.f.CopyProp.after.panic-abort.mir b/tests/mir-opt/copy-prop/dead_stores_better.f.CopyProp.after.panic-abort.mir index 02b88d140035..4781fdfd902a 100644 --- a/tests/mir-opt/copy-prop/dead_stores_better.f.CopyProp.after.panic-abort.mir +++ b/tests/mir-opt/copy-prop/dead_stores_better.f.CopyProp.after.panic-abort.mir @@ -11,11 +11,11 @@ fn f(_1: usize) -> usize { } bb0: { - _2 = _1; + _2 = copy _1; _1 = const 5_usize; - _1 = _2; + _1 = copy _2; StorageLive(_4); - _4 = _1; + _4 = copy _1; _0 = id::(move _4) -> [return: bb1, unwind unreachable]; } diff --git a/tests/mir-opt/copy-prop/dead_stores_better.f.CopyProp.after.panic-unwind.mir b/tests/mir-opt/copy-prop/dead_stores_better.f.CopyProp.after.panic-unwind.mir index f8c285ff3843..f5fded45c13b 100644 --- a/tests/mir-opt/copy-prop/dead_stores_better.f.CopyProp.after.panic-unwind.mir +++ b/tests/mir-opt/copy-prop/dead_stores_better.f.CopyProp.after.panic-unwind.mir @@ -11,11 +11,11 @@ fn f(_1: usize) -> usize { } bb0: { - _2 = _1; + _2 = copy _1; _1 = const 5_usize; - _1 = _2; + _1 = copy _2; StorageLive(_4); - _4 = _1; + _4 = copy _1; _0 = id::(move _4) -> [return: bb1, unwind continue]; } diff --git a/tests/mir-opt/copy-prop/issue_107511.main.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/issue_107511.main.CopyProp.panic-abort.diff index 51390e2abbe9..f4411886f9a7 100644 --- a/tests/mir-opt/copy-prop/issue_107511.main.CopyProp.panic-abort.diff +++ b/tests/mir-opt/copy-prop/issue_107511.main.CopyProp.panic-abort.diff @@ -88,15 +88,15 @@ bb6: { - StorageLive(_16); - _16 = ((_11 as Some).0: usize); + _16 = copy ((_11 as Some).0: usize); StorageLive(_17); - StorageLive(_18); -- _18 = _16; +- _18 = copy _16; _19 = Len(_2); -- _20 = Lt(_18, _19); -- assert(move _20, "index out of bounds: the length is {} but the index is {}", move _19, _18) -> [success: bb8, unwind unreachable]; -+ _20 = Lt(_16, _19); -+ assert(move _20, "index out of bounds: the length is {} but the index is {}", move _19, _16) -> [success: bb8, unwind unreachable]; +- _20 = Lt(copy _18, copy _19); +- assert(move _20, "index out of bounds: the length is {} but the index is {}", move _19, copy _18) -> [success: bb8, unwind unreachable]; ++ _20 = Lt(copy _16, copy _19); ++ assert(move _20, "index out of bounds: the length is {} but the index is {}", move _19, copy _16) -> [success: bb8, unwind unreachable]; } bb7: { @@ -112,9 +112,9 @@ } bb8: { -- _17 = _2[_18]; -+ _17 = _2[_16]; - _1 = Add(_1, move _17); +- _17 = copy _2[_18]; ++ _17 = copy _2[_16]; + _1 = Add(copy _1, move _17); StorageDead(_17); - StorageDead(_18); - _10 = const (); diff --git a/tests/mir-opt/copy-prop/issue_107511.main.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/issue_107511.main.CopyProp.panic-unwind.diff index 8a2cbb68824c..833588aa4e92 100644 --- a/tests/mir-opt/copy-prop/issue_107511.main.CopyProp.panic-unwind.diff +++ b/tests/mir-opt/copy-prop/issue_107511.main.CopyProp.panic-unwind.diff @@ -88,15 +88,15 @@ bb6: { - StorageLive(_16); - _16 = ((_11 as Some).0: usize); + _16 = copy ((_11 as Some).0: usize); StorageLive(_17); - StorageLive(_18); -- _18 = _16; +- _18 = copy _16; _19 = Len(_2); -- _20 = Lt(_18, _19); -- assert(move _20, "index out of bounds: the length is {} but the index is {}", move _19, _18) -> [success: bb8, unwind continue]; -+ _20 = Lt(_16, _19); -+ assert(move _20, "index out of bounds: the length is {} but the index is {}", move _19, _16) -> [success: bb8, unwind continue]; +- _20 = Lt(copy _18, copy _19); +- assert(move _20, "index out of bounds: the length is {} but the index is {}", move _19, copy _18) -> [success: bb8, unwind continue]; ++ _20 = Lt(copy _16, copy _19); ++ assert(move _20, "index out of bounds: the length is {} but the index is {}", move _19, copy _16) -> [success: bb8, unwind continue]; } bb7: { @@ -112,9 +112,9 @@ } bb8: { -- _17 = _2[_18]; -+ _17 = _2[_16]; - _1 = Add(_1, move _17); +- _17 = copy _2[_18]; ++ _17 = copy _2[_16]; + _1 = Add(copy _1, move _17); StorageDead(_17); - StorageDead(_18); - _10 = const (); diff --git a/tests/mir-opt/copy-prop/move_arg.f.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/move_arg.f.CopyProp.panic-abort.diff index cf04f213efb9..da9904bfa01f 100644 --- a/tests/mir-opt/copy-prop/move_arg.f.CopyProp.panic-abort.diff +++ b/tests/mir-opt/copy-prop/move_arg.f.CopyProp.panic-abort.diff @@ -15,14 +15,14 @@ bb0: { - StorageLive(_2); -- _2 = _1; +- _2 = copy _1; StorageLive(_3); - StorageLive(_4); -- _4 = _1; +- _4 = copy _1; - StorageLive(_5); -- _5 = _2; +- _5 = copy _2; - _3 = g::(move _4, move _5) -> [return: bb1, unwind unreachable]; -+ _3 = g::(_1, _1) -> [return: bb1, unwind unreachable]; ++ _3 = g::(copy _1, copy _1) -> [return: bb1, unwind unreachable]; } bb1: { diff --git a/tests/mir-opt/copy-prop/move_arg.f.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/move_arg.f.CopyProp.panic-unwind.diff index 0c6a3c6d5c95..9b0de655bd26 100644 --- a/tests/mir-opt/copy-prop/move_arg.f.CopyProp.panic-unwind.diff +++ b/tests/mir-opt/copy-prop/move_arg.f.CopyProp.panic-unwind.diff @@ -15,14 +15,14 @@ bb0: { - StorageLive(_2); -- _2 = _1; +- _2 = copy _1; StorageLive(_3); - StorageLive(_4); -- _4 = _1; +- _4 = copy _1; - StorageLive(_5); -- _5 = _2; +- _5 = copy _2; - _3 = g::(move _4, move _5) -> [return: bb1, unwind continue]; -+ _3 = g::(_1, _1) -> [return: bb1, unwind continue]; ++ _3 = g::(copy _1, copy _1) -> [return: bb1, unwind continue]; } bb1: { diff --git a/tests/mir-opt/copy-prop/move_projection.f.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/move_projection.f.CopyProp.panic-abort.diff index b2b89968d70b..973bcd6de839 100644 --- a/tests/mir-opt/copy-prop/move_projection.f.CopyProp.panic-abort.diff +++ b/tests/mir-opt/copy-prop/move_projection.f.CopyProp.panic-abort.diff @@ -7,11 +7,11 @@ let mut _3: u8; bb0: { -- _2 = _1; +- _2 = copy _1; - _3 = move (_2.0: u8); - _0 = opaque::(move _1) -> [return: bb1, unwind unreachable]; -+ _3 = (_1.0: u8); -+ _0 = opaque::(_1) -> [return: bb1, unwind unreachable]; ++ _3 = copy (_1.0: u8); ++ _0 = opaque::(copy _1) -> [return: bb1, unwind unreachable]; } bb1: { diff --git a/tests/mir-opt/copy-prop/move_projection.f.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/move_projection.f.CopyProp.panic-unwind.diff index b2b89968d70b..973bcd6de839 100644 --- a/tests/mir-opt/copy-prop/move_projection.f.CopyProp.panic-unwind.diff +++ b/tests/mir-opt/copy-prop/move_projection.f.CopyProp.panic-unwind.diff @@ -7,11 +7,11 @@ let mut _3: u8; bb0: { -- _2 = _1; +- _2 = copy _1; - _3 = move (_2.0: u8); - _0 = opaque::(move _1) -> [return: bb1, unwind unreachable]; -+ _3 = (_1.0: u8); -+ _0 = opaque::(_1) -> [return: bb1, unwind unreachable]; ++ _3 = copy (_1.0: u8); ++ _0 = opaque::(copy _1) -> [return: bb1, unwind unreachable]; } bb1: { diff --git a/tests/mir-opt/copy-prop/mutate_through_pointer.f.CopyProp.diff b/tests/mir-opt/copy-prop/mutate_through_pointer.f.CopyProp.diff index 7f6802beeae2..f96be6271294 100644 --- a/tests/mir-opt/copy-prop/mutate_through_pointer.f.CopyProp.diff +++ b/tests/mir-opt/copy-prop/mutate_through_pointer.f.CopyProp.diff @@ -8,11 +8,11 @@ let mut _4: *mut bool; bb0: { - _2 = _1; + _2 = copy _1; _3 = &raw const _2; _4 = &raw mut (*_3); (*_4) = const false; - _0 = _1; + _0 = copy _1; return; } } diff --git a/tests/mir-opt/copy-prop/non_dominate.f.CopyProp.diff b/tests/mir-opt/copy-prop/non_dominate.f.CopyProp.diff index 5bf2335943cf..6955d694e5ab 100644 --- a/tests/mir-opt/copy-prop/non_dominate.f.CopyProp.diff +++ b/tests/mir-opt/copy-prop/non_dominate.f.CopyProp.diff @@ -11,18 +11,18 @@ } bb1: { - _3 = _1; - switchInt(_3) -> [0: bb3, otherwise: bb2]; + _3 = copy _1; + switchInt(copy _3) -> [0: bb3, otherwise: bb2]; } bb2: { - _2 = _3; + _2 = copy _3; _1 = const false; goto -> bb1; } bb3: { - _0 = _2; + _0 = copy _2; return; } } diff --git a/tests/mir-opt/copy-prop/reborrow.demiraw.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/reborrow.demiraw.CopyProp.panic-abort.diff index ef30ac2fc8c0..676c5cee3438 100644 --- a/tests/mir-opt/copy-prop/reborrow.demiraw.CopyProp.panic-abort.diff +++ b/tests/mir-opt/copy-prop/reborrow.demiraw.CopyProp.panic-abort.diff @@ -30,12 +30,12 @@ _3 = &mut (*_4); StorageDead(_4); - StorageLive(_5); -- _5 = _2; +- _5 = copy _2; StorageLive(_6); - StorageLive(_7); -- _7 = _5; +- _7 = copy _5; - _6 = opaque::<*mut u8>(move _7) -> [return: bb1, unwind unreachable]; -+ _6 = opaque::<*mut u8>(_2) -> [return: bb1, unwind unreachable]; ++ _6 = opaque::<*mut u8>(copy _2) -> [return: bb1, unwind unreachable]; } bb1: { diff --git a/tests/mir-opt/copy-prop/reborrow.demiraw.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/reborrow.demiraw.CopyProp.panic-unwind.diff index a743a3e829a7..ca2232ce54a1 100644 --- a/tests/mir-opt/copy-prop/reborrow.demiraw.CopyProp.panic-unwind.diff +++ b/tests/mir-opt/copy-prop/reborrow.demiraw.CopyProp.panic-unwind.diff @@ -30,12 +30,12 @@ _3 = &mut (*_4); StorageDead(_4); - StorageLive(_5); -- _5 = _2; +- _5 = copy _2; StorageLive(_6); - StorageLive(_7); -- _7 = _5; +- _7 = copy _5; - _6 = opaque::<*mut u8>(move _7) -> [return: bb1, unwind continue]; -+ _6 = opaque::<*mut u8>(_2) -> [return: bb1, unwind continue]; ++ _6 = opaque::<*mut u8>(copy _2) -> [return: bb1, unwind continue]; } bb1: { diff --git a/tests/mir-opt/copy-prop/reborrow.miraw.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/reborrow.miraw.CopyProp.panic-abort.diff index 2de6f85ce64b..1968696905fc 100644 --- a/tests/mir-opt/copy-prop/reborrow.miraw.CopyProp.panic-abort.diff +++ b/tests/mir-opt/copy-prop/reborrow.miraw.CopyProp.panic-abort.diff @@ -26,12 +26,12 @@ StorageLive(_3); _3 = &raw mut (*_2); - StorageLive(_4); -- _4 = _2; +- _4 = copy _2; StorageLive(_5); - StorageLive(_6); -- _6 = _4; +- _6 = copy _4; - _5 = opaque::<*mut u8>(move _6) -> [return: bb1, unwind unreachable]; -+ _5 = opaque::<*mut u8>(_2) -> [return: bb1, unwind unreachable]; ++ _5 = opaque::<*mut u8>(copy _2) -> [return: bb1, unwind unreachable]; } bb1: { diff --git a/tests/mir-opt/copy-prop/reborrow.miraw.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/reborrow.miraw.CopyProp.panic-unwind.diff index 2afec4898bc8..9a3c9665bc8f 100644 --- a/tests/mir-opt/copy-prop/reborrow.miraw.CopyProp.panic-unwind.diff +++ b/tests/mir-opt/copy-prop/reborrow.miraw.CopyProp.panic-unwind.diff @@ -26,12 +26,12 @@ StorageLive(_3); _3 = &raw mut (*_2); - StorageLive(_4); -- _4 = _2; +- _4 = copy _2; StorageLive(_5); - StorageLive(_6); -- _6 = _4; +- _6 = copy _4; - _5 = opaque::<*mut u8>(move _6) -> [return: bb1, unwind continue]; -+ _5 = opaque::<*mut u8>(_2) -> [return: bb1, unwind continue]; ++ _5 = opaque::<*mut u8>(copy _2) -> [return: bb1, unwind continue]; } bb1: { diff --git a/tests/mir-opt/coverage/branch_match_arms.main.InstrumentCoverage.diff b/tests/mir-opt/coverage/branch_match_arms.main.InstrumentCoverage.diff index 3d791734f462..eeeac70b5b8e 100644 --- a/tests/mir-opt/coverage/branch_match_arms.main.InstrumentCoverage.diff +++ b/tests/mir-opt/coverage/branch_match_arms.main.InstrumentCoverage.diff @@ -71,33 +71,33 @@ bb5: { + Coverage::ExpressionUsed(2); StorageLive(_9); - _9 = ((_1 as A).0: u32); + _9 = copy ((_1 as A).0: u32); StorageLive(_10); - _10 = _9; + _10 = copy _9; _0 = consume(move _10) -> [return: bb12, unwind: bb14]; } bb6: { StorageLive(_7); - _7 = ((_1 as B).0: u32); + _7 = copy ((_1 as B).0: u32); StorageLive(_8); - _8 = _7; + _8 = copy _7; _0 = consume(move _8) -> [return: bb11, unwind: bb14]; } bb7: { StorageLive(_5); - _5 = ((_1 as C).0: u32); + _5 = copy ((_1 as C).0: u32); StorageLive(_6); - _6 = _5; + _6 = copy _5; _0 = consume(move _6) -> [return: bb10, unwind: bb14]; } bb8: { StorageLive(_3); - _3 = ((_1 as D).0: u32); + _3 = copy ((_1 as D).0: u32); StorageLive(_4); - _4 = _3; + _4 = copy _3; _0 = consume(move _4) -> [return: bb9, unwind: bb14]; } diff --git a/tests/mir-opt/dataflow-const-prop/aggregate_copy.foo.DataflowConstProp.diff b/tests/mir-opt/dataflow-const-prop/aggregate_copy.foo.DataflowConstProp.diff index 3b739a25cb86..8dd34d845801 100644 --- a/tests/mir-opt/dataflow-const-prop/aggregate_copy.foo.DataflowConstProp.diff +++ b/tests/mir-opt/dataflow-const-prop/aggregate_copy.foo.DataflowConstProp.diff @@ -22,14 +22,14 @@ StorageLive(_1); _1 = const Foo; StorageLive(_2); -- _2 = _1; +- _2 = copy _1; + _2 = const (5_u32, 3_u32); StorageLive(_3); -- _3 = (_2.1: u32); +- _3 = copy (_2.1: u32); + _3 = const 3_u32; StorageLive(_4); StorageLive(_5); -- _5 = _3; +- _5 = copy _3; - _4 = Ge(move _5, const 2_u32); - switchInt(move _4) -> [0: bb2, otherwise: bb1]; + _5 = const 3_u32; @@ -39,7 +39,7 @@ bb1: { StorageDead(_5); -- _0 = (_2.0: u32); +- _0 = copy (_2.0: u32); + _0 = const 5_u32; goto -> bb3; } diff --git a/tests/mir-opt/dataflow-const-prop/array_index.main.DataflowConstProp.32bit.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/array_index.main.DataflowConstProp.32bit.panic-abort.diff index 212ddc5b1541..a46daef435f3 100644 --- a/tests/mir-opt/dataflow-const-prop/array_index.main.DataflowConstProp.32bit.panic-abort.diff +++ b/tests/mir-opt/dataflow-const-prop/array_index.main.DataflowConstProp.32bit.panic-abort.diff @@ -19,16 +19,16 @@ StorageLive(_3); _3 = const 2_usize; - _4 = Len(_2); -- _5 = Lt(_3, _4); -- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind unreachable]; +- _5 = Lt(copy _3, copy _4); +- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind unreachable]; + _4 = const 4_usize; + _5 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 4_usize, const 2_usize) -> [success: bb1, unwind unreachable]; } bb1: { -- _1 = _2[_3]; -+ _1 = _2[2 of 3]; +- _1 = copy _2[_3]; ++ _1 = copy _2[2 of 3]; StorageDead(_3); StorageDead(_2); _0 = const (); diff --git a/tests/mir-opt/dataflow-const-prop/array_index.main.DataflowConstProp.32bit.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/array_index.main.DataflowConstProp.32bit.panic-unwind.diff index 5c53d4f44613..1a4e15b45faa 100644 --- a/tests/mir-opt/dataflow-const-prop/array_index.main.DataflowConstProp.32bit.panic-unwind.diff +++ b/tests/mir-opt/dataflow-const-prop/array_index.main.DataflowConstProp.32bit.panic-unwind.diff @@ -19,16 +19,16 @@ StorageLive(_3); _3 = const 2_usize; - _4 = Len(_2); -- _5 = Lt(_3, _4); -- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind continue]; +- _5 = Lt(copy _3, copy _4); +- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind continue]; + _4 = const 4_usize; + _5 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 4_usize, const 2_usize) -> [success: bb1, unwind continue]; } bb1: { -- _1 = _2[_3]; -+ _1 = _2[2 of 3]; +- _1 = copy _2[_3]; ++ _1 = copy _2[2 of 3]; StorageDead(_3); StorageDead(_2); _0 = const (); diff --git a/tests/mir-opt/dataflow-const-prop/array_index.main.DataflowConstProp.64bit.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/array_index.main.DataflowConstProp.64bit.panic-abort.diff index 212ddc5b1541..a46daef435f3 100644 --- a/tests/mir-opt/dataflow-const-prop/array_index.main.DataflowConstProp.64bit.panic-abort.diff +++ b/tests/mir-opt/dataflow-const-prop/array_index.main.DataflowConstProp.64bit.panic-abort.diff @@ -19,16 +19,16 @@ StorageLive(_3); _3 = const 2_usize; - _4 = Len(_2); -- _5 = Lt(_3, _4); -- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind unreachable]; +- _5 = Lt(copy _3, copy _4); +- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind unreachable]; + _4 = const 4_usize; + _5 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 4_usize, const 2_usize) -> [success: bb1, unwind unreachable]; } bb1: { -- _1 = _2[_3]; -+ _1 = _2[2 of 3]; +- _1 = copy _2[_3]; ++ _1 = copy _2[2 of 3]; StorageDead(_3); StorageDead(_2); _0 = const (); diff --git a/tests/mir-opt/dataflow-const-prop/array_index.main.DataflowConstProp.64bit.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/array_index.main.DataflowConstProp.64bit.panic-unwind.diff index 5c53d4f44613..1a4e15b45faa 100644 --- a/tests/mir-opt/dataflow-const-prop/array_index.main.DataflowConstProp.64bit.panic-unwind.diff +++ b/tests/mir-opt/dataflow-const-prop/array_index.main.DataflowConstProp.64bit.panic-unwind.diff @@ -19,16 +19,16 @@ StorageLive(_3); _3 = const 2_usize; - _4 = Len(_2); -- _5 = Lt(_3, _4); -- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind continue]; +- _5 = Lt(copy _3, copy _4); +- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind continue]; + _4 = const 4_usize; + _5 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 4_usize, const 2_usize) -> [success: bb1, unwind continue]; } bb1: { -- _1 = _2[_3]; -+ _1 = _2[2 of 3]; +- _1 = copy _2[_3]; ++ _1 = copy _2[2 of 3]; StorageDead(_3); StorageDead(_2); _0 = const (); diff --git a/tests/mir-opt/dataflow-const-prop/boolean_identities.test.DataflowConstProp.diff b/tests/mir-opt/dataflow-const-prop/boolean_identities.test.DataflowConstProp.diff index 5440c38ce4bc..89175fbad5c7 100644 --- a/tests/mir-opt/dataflow-const-prop/boolean_identities.test.DataflowConstProp.diff +++ b/tests/mir-opt/dataflow-const-prop/boolean_identities.test.DataflowConstProp.diff @@ -13,13 +13,13 @@ bb0: { StorageLive(_3); StorageLive(_4); - _4 = _2; + _4 = copy _2; - _3 = BitOr(move _4, const true); + _3 = const true; StorageDead(_4); StorageLive(_5); StorageLive(_6); - _6 = _1; + _6 = copy _1; - _5 = BitAnd(move _6, const false); + _5 = const false; StorageDead(_6); diff --git a/tests/mir-opt/dataflow-const-prop/cast.main.DataflowConstProp.diff b/tests/mir-opt/dataflow-const-prop/cast.main.DataflowConstProp.diff index 0ca446c89f2e..f2c262f9fe2c 100644 --- a/tests/mir-opt/dataflow-const-prop/cast.main.DataflowConstProp.diff +++ b/tests/mir-opt/dataflow-const-prop/cast.main.DataflowConstProp.diff @@ -20,7 +20,7 @@ StorageLive(_2); StorageLive(_3); StorageLive(_4); -- _4 = _1; +- _4 = copy _1; - _3 = move _4 as u8 (IntToInt); + _4 = const 257_i32; + _3 = const 1_u8; diff --git a/tests/mir-opt/dataflow-const-prop/checked.main.DataflowConstProp.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/checked.main.DataflowConstProp.panic-abort.diff index 79ea55617481..867e768790f6 100644 --- a/tests/mir-opt/dataflow-const-prop/checked.main.DataflowConstProp.panic-abort.diff +++ b/tests/mir-opt/dataflow-const-prop/checked.main.DataflowConstProp.panic-abort.diff @@ -36,11 +36,11 @@ _2 = const 2_i32; StorageLive(_3); StorageLive(_4); -- _4 = _1; +- _4 = copy _1; + _4 = const 1_i32; StorageLive(_5); -- _5 = _2; -- _6 = AddWithOverflow(_4, _5); +- _5 = copy _2; +- _6 = AddWithOverflow(copy _4, copy _5); - assert(!move (_6.1: bool), "attempt to compute `{} + {}`, which would overflow", move _4, move _5) -> [success: bb1, unwind unreachable]; + _5 = const 2_i32; + _6 = const (3_i32, false); @@ -56,8 +56,8 @@ _7 = const core::num::::MAX; StorageLive(_8); StorageLive(_9); -- _9 = _7; -- _10 = AddWithOverflow(_9, const 1_i32); +- _9 = copy _7; +- _10 = AddWithOverflow(copy _9, const 1_i32); - assert(!move (_10.1: bool), "attempt to compute `{} + {}`, which would overflow", move _9, const 1_i32) -> [success: bb2, unwind unreachable]; + _9 = const i32::MAX; + _10 = const (i32::MIN, true); diff --git a/tests/mir-opt/dataflow-const-prop/checked.main.DataflowConstProp.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/checked.main.DataflowConstProp.panic-unwind.diff index bd22c50dd8fc..c22edaaec409 100644 --- a/tests/mir-opt/dataflow-const-prop/checked.main.DataflowConstProp.panic-unwind.diff +++ b/tests/mir-opt/dataflow-const-prop/checked.main.DataflowConstProp.panic-unwind.diff @@ -36,11 +36,11 @@ _2 = const 2_i32; StorageLive(_3); StorageLive(_4); -- _4 = _1; +- _4 = copy _1; + _4 = const 1_i32; StorageLive(_5); -- _5 = _2; -- _6 = AddWithOverflow(_4, _5); +- _5 = copy _2; +- _6 = AddWithOverflow(copy _4, copy _5); - assert(!move (_6.1: bool), "attempt to compute `{} + {}`, which would overflow", move _4, move _5) -> [success: bb1, unwind continue]; + _5 = const 2_i32; + _6 = const (3_i32, false); @@ -56,8 +56,8 @@ _7 = const core::num::::MAX; StorageLive(_8); StorageLive(_9); -- _9 = _7; -- _10 = AddWithOverflow(_9, const 1_i32); +- _9 = copy _7; +- _10 = AddWithOverflow(copy _9, const 1_i32); - assert(!move (_10.1: bool), "attempt to compute `{} + {}`, which would overflow", move _9, const 1_i32) -> [success: bb2, unwind continue]; + _9 = const i32::MAX; + _10 = const (i32::MIN, true); diff --git a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-abort.diff index 9d96e895c8aa..c7870a7902b9 100644 --- a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-abort.diff +++ b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-abort.diff @@ -50,7 +50,7 @@ StorageLive(_6); StorageLive(_7); - _7 = AlignOf([bool; 0]); -- _6 = _7 as *mut [bool; 0] (Transmute); +- _6 = copy _7 as *mut [bool; 0] (Transmute); + _7 = const 1_usize; + _6 = const {0x1 as *mut [bool; 0]}; StorageDead(_7); @@ -67,7 +67,7 @@ bb2: { StorageLive(_10); -- _10 = _6 as *mut () (PtrToPtr); +- _10 = copy _6 as *mut () (PtrToPtr); - _9 = NonNull::::new_unchecked::precondition_check(move _10) -> [return: bb3, unwind unreachable]; + _10 = const {0x1 as *mut ()}; + _9 = NonNull::::new_unchecked::precondition_check(const {0x1 as *mut ()}) -> [return: bb3, unwind unreachable]; @@ -80,8 +80,8 @@ bb4: { StorageDead(_8); -- _11 = _6 as *const [bool; 0] (PtrToPtr); -- _5 = NonNull::<[bool; 0]> { pointer: _11 }; +- _11 = copy _6 as *const [bool; 0] (PtrToPtr); +- _5 = NonNull::<[bool; 0]> { pointer: copy _11 }; + _11 = const {0x1 as *const [bool; 0]}; + _5 = const NonNull::<[bool; 0]> {{ pointer: {0x1 as *const [bool; 0]} }}; StorageDead(_11); @@ -92,7 +92,7 @@ - _3 = move _4 as std::ptr::Unique<[bool]> (PointerCoercion(Unsize)); + _3 = const Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}; StorageDead(_4); -- _2 = Box::<[bool]>(_3, const std::alloc::Global); +- _2 = Box::<[bool]>(copy _3, const std::alloc::Global); + _2 = const Box::<[bool]>(Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}, std::alloc::Global); StorageDead(_9); StorageDead(_3); diff --git a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-unwind.diff index 0bdff584b01e..f5de7a361bc1 100644 --- a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-unwind.diff +++ b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-unwind.diff @@ -50,7 +50,7 @@ StorageLive(_6); StorageLive(_7); - _7 = AlignOf([bool; 0]); -- _6 = _7 as *mut [bool; 0] (Transmute); +- _6 = copy _7 as *mut [bool; 0] (Transmute); + _7 = const 1_usize; + _6 = const {0x1 as *mut [bool; 0]}; StorageDead(_7); @@ -71,7 +71,7 @@ bb3: { StorageLive(_10); -- _10 = _6 as *mut () (PtrToPtr); +- _10 = copy _6 as *mut () (PtrToPtr); - _9 = NonNull::::new_unchecked::precondition_check(move _10) -> [return: bb4, unwind unreachable]; + _10 = const {0x1 as *mut ()}; + _9 = NonNull::::new_unchecked::precondition_check(const {0x1 as *mut ()}) -> [return: bb4, unwind unreachable]; @@ -84,8 +84,8 @@ bb5: { StorageDead(_8); -- _11 = _6 as *const [bool; 0] (PtrToPtr); -- _5 = NonNull::<[bool; 0]> { pointer: _11 }; +- _11 = copy _6 as *const [bool; 0] (PtrToPtr); +- _5 = NonNull::<[bool; 0]> { pointer: copy _11 }; + _11 = const {0x1 as *const [bool; 0]}; + _5 = const NonNull::<[bool; 0]> {{ pointer: {0x1 as *const [bool; 0]} }}; StorageDead(_11); @@ -96,7 +96,7 @@ - _3 = move _4 as std::ptr::Unique<[bool]> (PointerCoercion(Unsize)); + _3 = const Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}; StorageDead(_4); -- _2 = Box::<[bool]>(_3, const std::alloc::Global); +- _2 = Box::<[bool]>(copy _3, const std::alloc::Global); + _2 = const Box::<[bool]>(Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}, std::alloc::Global); StorageDead(_9); StorageDead(_3); diff --git a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.64bit.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.64bit.panic-abort.diff index 99e96fe5d70f..3b0bc6377da6 100644 --- a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.64bit.panic-abort.diff +++ b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.64bit.panic-abort.diff @@ -50,7 +50,7 @@ StorageLive(_6); StorageLive(_7); - _7 = AlignOf([bool; 0]); -- _6 = _7 as *mut [bool; 0] (Transmute); +- _6 = copy _7 as *mut [bool; 0] (Transmute); + _7 = const 1_usize; + _6 = const {0x1 as *mut [bool; 0]}; StorageDead(_7); @@ -67,7 +67,7 @@ bb2: { StorageLive(_10); -- _10 = _6 as *mut () (PtrToPtr); +- _10 = copy _6 as *mut () (PtrToPtr); - _9 = NonNull::::new_unchecked::precondition_check(move _10) -> [return: bb3, unwind unreachable]; + _10 = const {0x1 as *mut ()}; + _9 = NonNull::::new_unchecked::precondition_check(const {0x1 as *mut ()}) -> [return: bb3, unwind unreachable]; @@ -80,8 +80,8 @@ bb4: { StorageDead(_8); -- _11 = _6 as *const [bool; 0] (PtrToPtr); -- _5 = NonNull::<[bool; 0]> { pointer: _11 }; +- _11 = copy _6 as *const [bool; 0] (PtrToPtr); +- _5 = NonNull::<[bool; 0]> { pointer: copy _11 }; + _11 = const {0x1 as *const [bool; 0]}; + _5 = const NonNull::<[bool; 0]> {{ pointer: {0x1 as *const [bool; 0]} }}; StorageDead(_11); @@ -92,7 +92,7 @@ - _3 = move _4 as std::ptr::Unique<[bool]> (PointerCoercion(Unsize)); + _3 = const Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}; StorageDead(_4); -- _2 = Box::<[bool]>(_3, const std::alloc::Global); +- _2 = Box::<[bool]>(copy _3, const std::alloc::Global); + _2 = const Box::<[bool]>(Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}, std::alloc::Global); StorageDead(_9); StorageDead(_3); diff --git a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.64bit.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.64bit.panic-unwind.diff index 5eefabeac386..5dd7ad9a1177 100644 --- a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.64bit.panic-unwind.diff +++ b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.64bit.panic-unwind.diff @@ -50,7 +50,7 @@ StorageLive(_6); StorageLive(_7); - _7 = AlignOf([bool; 0]); -- _6 = _7 as *mut [bool; 0] (Transmute); +- _6 = copy _7 as *mut [bool; 0] (Transmute); + _7 = const 1_usize; + _6 = const {0x1 as *mut [bool; 0]}; StorageDead(_7); @@ -71,7 +71,7 @@ bb3: { StorageLive(_10); -- _10 = _6 as *mut () (PtrToPtr); +- _10 = copy _6 as *mut () (PtrToPtr); - _9 = NonNull::::new_unchecked::precondition_check(move _10) -> [return: bb4, unwind unreachable]; + _10 = const {0x1 as *mut ()}; + _9 = NonNull::::new_unchecked::precondition_check(const {0x1 as *mut ()}) -> [return: bb4, unwind unreachable]; @@ -84,8 +84,8 @@ bb5: { StorageDead(_8); -- _11 = _6 as *const [bool; 0] (PtrToPtr); -- _5 = NonNull::<[bool; 0]> { pointer: _11 }; +- _11 = copy _6 as *const [bool; 0] (PtrToPtr); +- _5 = NonNull::<[bool; 0]> { pointer: copy _11 }; + _11 = const {0x1 as *const [bool; 0]}; + _5 = const NonNull::<[bool; 0]> {{ pointer: {0x1 as *const [bool; 0]} }}; StorageDead(_11); @@ -96,7 +96,7 @@ - _3 = move _4 as std::ptr::Unique<[bool]> (PointerCoercion(Unsize)); + _3 = const Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}; StorageDead(_4); -- _2 = Box::<[bool]>(_3, const std::alloc::Global); +- _2 = Box::<[bool]>(copy _3, const std::alloc::Global); + _2 = const Box::<[bool]>(Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}, std::alloc::Global); StorageDead(_9); StorageDead(_3); diff --git a/tests/mir-opt/dataflow-const-prop/enum.constant.DataflowConstProp.32bit.diff b/tests/mir-opt/dataflow-const-prop/enum.constant.DataflowConstProp.32bit.diff index 9da1caf9004e..ef3b24cd4400 100644 --- a/tests/mir-opt/dataflow-const-prop/enum.constant.DataflowConstProp.32bit.diff +++ b/tests/mir-opt/dataflow-const-prop/enum.constant.DataflowConstProp.32bit.diff @@ -37,16 +37,16 @@ bb2: { StorageLive(_5); - _5 = ((_1 as V2).0: i32); - _2 = _5; + _5 = copy ((_1 as V2).0: i32); + _2 = copy _5; StorageDead(_5); goto -> bb4; } bb3: { StorageLive(_4); -- _4 = ((_1 as V1).0: i32); -- _2 = _4; +- _4 = copy ((_1 as V1).0: i32); +- _2 = copy _4; + _4 = const 0_i32; + _2 = const 0_i32; StorageDead(_4); diff --git a/tests/mir-opt/dataflow-const-prop/enum.constant.DataflowConstProp.64bit.diff b/tests/mir-opt/dataflow-const-prop/enum.constant.DataflowConstProp.64bit.diff index 9da1caf9004e..ef3b24cd4400 100644 --- a/tests/mir-opt/dataflow-const-prop/enum.constant.DataflowConstProp.64bit.diff +++ b/tests/mir-opt/dataflow-const-prop/enum.constant.DataflowConstProp.64bit.diff @@ -37,16 +37,16 @@ bb2: { StorageLive(_5); - _5 = ((_1 as V2).0: i32); - _2 = _5; + _5 = copy ((_1 as V2).0: i32); + _2 = copy _5; StorageDead(_5); goto -> bb4; } bb3: { StorageLive(_4); -- _4 = ((_1 as V1).0: i32); -- _2 = _4; +- _4 = copy ((_1 as V1).0: i32); +- _2 = copy _4; + _4 = const 0_i32; + _2 = const 0_i32; StorageDead(_4); diff --git a/tests/mir-opt/dataflow-const-prop/enum.multiple.DataflowConstProp.32bit.diff b/tests/mir-opt/dataflow-const-prop/enum.multiple.DataflowConstProp.32bit.diff index 10d33767c90d..db8352bcbcf9 100644 --- a/tests/mir-opt/dataflow-const-prop/enum.multiple.DataflowConstProp.32bit.diff +++ b/tests/mir-opt/dataflow-const-prop/enum.multiple.DataflowConstProp.32bit.diff @@ -28,13 +28,13 @@ bb0: { StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; switchInt(move _4) -> [0: bb2, otherwise: bb1]; } bb1: { StorageLive(_5); - _5 = _2; + _5 = copy _2; _3 = Option::::Some(move _5); StorageDead(_5); goto -> bb3; @@ -63,15 +63,15 @@ bb6: { StorageLive(_8); - _8 = ((_3 as Some).0: u8); - _6 = _8; + _8 = copy ((_3 as Some).0: u8); + _6 = copy _8; StorageDead(_8); goto -> bb7; } bb7: { StorageLive(_9); - _9 = _6; + _9 = copy _6; _0 = const (); StorageDead(_9); StorageDead(_6); diff --git a/tests/mir-opt/dataflow-const-prop/enum.multiple.DataflowConstProp.64bit.diff b/tests/mir-opt/dataflow-const-prop/enum.multiple.DataflowConstProp.64bit.diff index 10d33767c90d..db8352bcbcf9 100644 --- a/tests/mir-opt/dataflow-const-prop/enum.multiple.DataflowConstProp.64bit.diff +++ b/tests/mir-opt/dataflow-const-prop/enum.multiple.DataflowConstProp.64bit.diff @@ -28,13 +28,13 @@ bb0: { StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; switchInt(move _4) -> [0: bb2, otherwise: bb1]; } bb1: { StorageLive(_5); - _5 = _2; + _5 = copy _2; _3 = Option::::Some(move _5); StorageDead(_5); goto -> bb3; @@ -63,15 +63,15 @@ bb6: { StorageLive(_8); - _8 = ((_3 as Some).0: u8); - _6 = _8; + _8 = copy ((_3 as Some).0: u8); + _6 = copy _8; StorageDead(_8); goto -> bb7; } bb7: { StorageLive(_9); - _9 = _6; + _9 = copy _6; _0 = const (); StorageDead(_9); StorageDead(_6); diff --git a/tests/mir-opt/dataflow-const-prop/enum.mutate_discriminant.DataflowConstProp.32bit.diff b/tests/mir-opt/dataflow-const-prop/enum.mutate_discriminant.DataflowConstProp.32bit.diff index 960e69ee9165..e2cd73404bec 100644 --- a/tests/mir-opt/dataflow-const-prop/enum.mutate_discriminant.DataflowConstProp.32bit.diff +++ b/tests/mir-opt/dataflow-const-prop/enum.mutate_discriminant.DataflowConstProp.32bit.diff @@ -10,7 +10,7 @@ discriminant(_1) = 1; (((_1 as variant#1).0: NonZeroUsize).0: usize) = const 0_usize; _2 = discriminant(_1); - switchInt(_2) -> [0: bb1, otherwise: bb2]; + switchInt(copy _2) -> [0: bb1, otherwise: bb2]; } bb1: { diff --git a/tests/mir-opt/dataflow-const-prop/enum.mutate_discriminant.DataflowConstProp.64bit.diff b/tests/mir-opt/dataflow-const-prop/enum.mutate_discriminant.DataflowConstProp.64bit.diff index 960e69ee9165..e2cd73404bec 100644 --- a/tests/mir-opt/dataflow-const-prop/enum.mutate_discriminant.DataflowConstProp.64bit.diff +++ b/tests/mir-opt/dataflow-const-prop/enum.mutate_discriminant.DataflowConstProp.64bit.diff @@ -10,7 +10,7 @@ discriminant(_1) = 1; (((_1 as variant#1).0: NonZeroUsize).0: usize) = const 0_usize; _2 = discriminant(_1); - switchInt(_2) -> [0: bb1, otherwise: bb2]; + switchInt(copy _2) -> [0: bb1, otherwise: bb2]; } bb1: { diff --git a/tests/mir-opt/dataflow-const-prop/enum.simple.DataflowConstProp.32bit.diff b/tests/mir-opt/dataflow-const-prop/enum.simple.DataflowConstProp.32bit.diff index a64dda0d06c4..d79c163effc1 100644 --- a/tests/mir-opt/dataflow-const-prop/enum.simple.DataflowConstProp.32bit.diff +++ b/tests/mir-opt/dataflow-const-prop/enum.simple.DataflowConstProp.32bit.diff @@ -38,16 +38,16 @@ bb2: { StorageLive(_5); - _5 = ((_1 as V2).0: i32); - _2 = _5; + _5 = copy ((_1 as V2).0: i32); + _2 = copy _5; StorageDead(_5); goto -> bb4; } bb3: { StorageLive(_4); -- _4 = ((_1 as V1).0: i32); -- _2 = _4; +- _4 = copy ((_1 as V1).0: i32); +- _2 = copy _4; + _4 = const 0_i32; + _2 = const 0_i32; StorageDead(_4); diff --git a/tests/mir-opt/dataflow-const-prop/enum.simple.DataflowConstProp.64bit.diff b/tests/mir-opt/dataflow-const-prop/enum.simple.DataflowConstProp.64bit.diff index a64dda0d06c4..d79c163effc1 100644 --- a/tests/mir-opt/dataflow-const-prop/enum.simple.DataflowConstProp.64bit.diff +++ b/tests/mir-opt/dataflow-const-prop/enum.simple.DataflowConstProp.64bit.diff @@ -38,16 +38,16 @@ bb2: { StorageLive(_5); - _5 = ((_1 as V2).0: i32); - _2 = _5; + _5 = copy ((_1 as V2).0: i32); + _2 = copy _5; StorageDead(_5); goto -> bb4; } bb3: { StorageLive(_4); -- _4 = ((_1 as V1).0: i32); -- _2 = _4; +- _4 = copy ((_1 as V1).0: i32); +- _2 = copy _4; + _4 = const 0_i32; + _2 = const 0_i32; StorageDead(_4); diff --git a/tests/mir-opt/dataflow-const-prop/enum.statics.DataflowConstProp.32bit.diff b/tests/mir-opt/dataflow-const-prop/enum.statics.DataflowConstProp.32bit.diff index b4d14f25fe2a..9823a48785a5 100644 --- a/tests/mir-opt/dataflow-const-prop/enum.statics.DataflowConstProp.32bit.diff +++ b/tests/mir-opt/dataflow-const-prop/enum.statics.DataflowConstProp.32bit.diff @@ -44,7 +44,7 @@ StorageLive(_1); StorageLive(_2); _2 = const {ALLOC0: &E}; -- _1 = (*_2); +- _1 = copy (*_2); + _1 = const E::V1(0_i32); StorageDead(_2); StorageLive(_3); @@ -60,16 +60,16 @@ bb2: { StorageLive(_6); - _6 = ((_1 as V2).0: i32); - _3 = _6; + _6 = copy ((_1 as V2).0: i32); + _3 = copy _6; StorageDead(_6); goto -> bb4; } bb3: { StorageLive(_5); -- _5 = ((_1 as V1).0: i32); -- _3 = _5; +- _5 = copy ((_1 as V1).0: i32); +- _3 = copy _5; + _5 = const 0_i32; + _3 = const 0_i32; StorageDead(_5); @@ -80,7 +80,7 @@ StorageLive(_7); StorageLive(_8); _8 = const {ALLOC1: &&E}; - _7 = (*_8); + _7 = copy (*_8); StorageDead(_8); StorageLive(_9); _10 = discriminant((*_7)); @@ -98,7 +98,7 @@ bb6: { StorageLive(_11); _11 = &(((*_7) as V1).0: i32); - _9 = _11; + _9 = copy _11; StorageDead(_11); goto -> bb7; } diff --git a/tests/mir-opt/dataflow-const-prop/enum.statics.DataflowConstProp.64bit.diff b/tests/mir-opt/dataflow-const-prop/enum.statics.DataflowConstProp.64bit.diff index 57d02b87d136..e4e68483f255 100644 --- a/tests/mir-opt/dataflow-const-prop/enum.statics.DataflowConstProp.64bit.diff +++ b/tests/mir-opt/dataflow-const-prop/enum.statics.DataflowConstProp.64bit.diff @@ -44,7 +44,7 @@ StorageLive(_1); StorageLive(_2); _2 = const {ALLOC0: &E}; -- _1 = (*_2); +- _1 = copy (*_2); + _1 = const E::V1(0_i32); StorageDead(_2); StorageLive(_3); @@ -60,16 +60,16 @@ bb2: { StorageLive(_6); - _6 = ((_1 as V2).0: i32); - _3 = _6; + _6 = copy ((_1 as V2).0: i32); + _3 = copy _6; StorageDead(_6); goto -> bb4; } bb3: { StorageLive(_5); -- _5 = ((_1 as V1).0: i32); -- _3 = _5; +- _5 = copy ((_1 as V1).0: i32); +- _3 = copy _5; + _5 = const 0_i32; + _3 = const 0_i32; StorageDead(_5); @@ -80,7 +80,7 @@ StorageLive(_7); StorageLive(_8); _8 = const {ALLOC1: &&E}; - _7 = (*_8); + _7 = copy (*_8); StorageDead(_8); StorageLive(_9); _10 = discriminant((*_7)); @@ -98,7 +98,7 @@ bb6: { StorageLive(_11); _11 = &(((*_7) as V1).0: i32); - _9 = _11; + _9 = copy _11; StorageDead(_11); goto -> bb7; } diff --git a/tests/mir-opt/dataflow-const-prop/if.main.DataflowConstProp.diff b/tests/mir-opt/dataflow-const-prop/if.main.DataflowConstProp.diff index 355f28b03db5..5f013b1d134d 100644 --- a/tests/mir-opt/dataflow-const-prop/if.main.DataflowConstProp.diff +++ b/tests/mir-opt/dataflow-const-prop/if.main.DataflowConstProp.diff @@ -37,7 +37,7 @@ StorageLive(_2); StorageLive(_3); StorageLive(_4); -- _4 = _1; +- _4 = copy _1; - _3 = Eq(move _4, const 1_i32); - switchInt(move _3) -> [0: bb2, otherwise: bb1]; + _4 = const 1_i32; @@ -61,7 +61,7 @@ StorageDead(_3); StorageLive(_5); StorageLive(_6); -- _6 = _2; +- _6 = copy _2; - _5 = Add(move _6, const 1_i32); + _6 = const 2_i32; + _5 = const 3_i32; @@ -69,7 +69,7 @@ StorageLive(_7); StorageLive(_8); StorageLive(_9); -- _9 = _1; +- _9 = copy _1; - _8 = Eq(move _9, const 1_i32); - switchInt(move _8) -> [0: bb5, otherwise: bb4]; + _9 = const 1_i32; @@ -79,7 +79,7 @@ bb4: { StorageDead(_9); -- _7 = _1; +- _7 = copy _1; + _7 = const 1_i32; goto -> bb6; } @@ -87,7 +87,7 @@ bb5: { StorageDead(_9); StorageLive(_10); - _10 = _1; + _10 = copy _1; _7 = Add(move _10, const 1_i32); StorageDead(_10); goto -> bb6; @@ -97,7 +97,7 @@ StorageDead(_8); StorageLive(_11); StorageLive(_12); -- _12 = _7; +- _12 = copy _7; - _11 = Add(move _12, const 1_i32); + _12 = const 1_i32; + _11 = const 2_i32; diff --git a/tests/mir-opt/dataflow-const-prop/inherit_overflow.main.DataflowConstProp.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/inherit_overflow.main.DataflowConstProp.panic-abort.diff index 8d62de0c8215..1b695e4b53c3 100644 --- a/tests/mir-opt/dataflow-const-prop/inherit_overflow.main.DataflowConstProp.panic-abort.diff +++ b/tests/mir-opt/dataflow-const-prop/inherit_overflow.main.DataflowConstProp.panic-abort.diff @@ -19,8 +19,8 @@ StorageLive(_3); _3 = const 1_u8; StorageLive(_4); -- _4 = AddWithOverflow(_2, _3); -- assert(!move (_4.1: bool), "attempt to compute `{} + {}`, which would overflow", _2, _3) -> [success: bb1, unwind unreachable]; +- _4 = AddWithOverflow(copy _2, copy _3); +- assert(!move (_4.1: bool), "attempt to compute `{} + {}`, which would overflow", copy _2, copy _3) -> [success: bb1, unwind unreachable]; + _4 = const (0_u8, true); + assert(!const true, "attempt to compute `{} + {}`, which would overflow", const u8::MAX, const 1_u8) -> [success: bb1, unwind unreachable]; } diff --git a/tests/mir-opt/dataflow-const-prop/inherit_overflow.main.DataflowConstProp.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/inherit_overflow.main.DataflowConstProp.panic-unwind.diff index 25624851cb34..a0bd8e17d8c4 100644 --- a/tests/mir-opt/dataflow-const-prop/inherit_overflow.main.DataflowConstProp.panic-unwind.diff +++ b/tests/mir-opt/dataflow-const-prop/inherit_overflow.main.DataflowConstProp.panic-unwind.diff @@ -19,8 +19,8 @@ StorageLive(_3); _3 = const 1_u8; StorageLive(_4); -- _4 = AddWithOverflow(_2, _3); -- assert(!move (_4.1: bool), "attempt to compute `{} + {}`, which would overflow", _2, _3) -> [success: bb1, unwind continue]; +- _4 = AddWithOverflow(copy _2, copy _3); +- assert(!move (_4.1: bool), "attempt to compute `{} + {}`, which would overflow", copy _2, copy _3) -> [success: bb1, unwind continue]; + _4 = const (0_u8, true); + assert(!const true, "attempt to compute `{} + {}`, which would overflow", const u8::MAX, const 1_u8) -> [success: bb1, unwind continue]; } diff --git a/tests/mir-opt/dataflow-const-prop/large_array_index.main.DataflowConstProp.32bit.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/large_array_index.main.DataflowConstProp.32bit.panic-abort.diff index 6c612d467250..b7ff0b671f7b 100644 --- a/tests/mir-opt/dataflow-const-prop/large_array_index.main.DataflowConstProp.32bit.panic-abort.diff +++ b/tests/mir-opt/dataflow-const-prop/large_array_index.main.DataflowConstProp.32bit.panic-abort.diff @@ -19,16 +19,16 @@ StorageLive(_3); _3 = const 2_usize; - _4 = Len(_2); -- _5 = Lt(_3, _4); -- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind unreachable]; +- _5 = Lt(copy _3, copy _4); +- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind unreachable]; + _4 = const 5000_usize; + _5 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 5000_usize, const 2_usize) -> [success: bb1, unwind unreachable]; } bb1: { -- _1 = _2[_3]; -+ _1 = _2[2 of 3]; +- _1 = copy _2[_3]; ++ _1 = copy _2[2 of 3]; StorageDead(_3); StorageDead(_2); _0 = const (); diff --git a/tests/mir-opt/dataflow-const-prop/large_array_index.main.DataflowConstProp.32bit.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/large_array_index.main.DataflowConstProp.32bit.panic-unwind.diff index 87024da2628b..af6e3626142f 100644 --- a/tests/mir-opt/dataflow-const-prop/large_array_index.main.DataflowConstProp.32bit.panic-unwind.diff +++ b/tests/mir-opt/dataflow-const-prop/large_array_index.main.DataflowConstProp.32bit.panic-unwind.diff @@ -19,16 +19,16 @@ StorageLive(_3); _3 = const 2_usize; - _4 = Len(_2); -- _5 = Lt(_3, _4); -- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind continue]; +- _5 = Lt(copy _3, copy _4); +- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind continue]; + _4 = const 5000_usize; + _5 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 5000_usize, const 2_usize) -> [success: bb1, unwind continue]; } bb1: { -- _1 = _2[_3]; -+ _1 = _2[2 of 3]; +- _1 = copy _2[_3]; ++ _1 = copy _2[2 of 3]; StorageDead(_3); StorageDead(_2); _0 = const (); diff --git a/tests/mir-opt/dataflow-const-prop/large_array_index.main.DataflowConstProp.64bit.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/large_array_index.main.DataflowConstProp.64bit.panic-abort.diff index 6c612d467250..b7ff0b671f7b 100644 --- a/tests/mir-opt/dataflow-const-prop/large_array_index.main.DataflowConstProp.64bit.panic-abort.diff +++ b/tests/mir-opt/dataflow-const-prop/large_array_index.main.DataflowConstProp.64bit.panic-abort.diff @@ -19,16 +19,16 @@ StorageLive(_3); _3 = const 2_usize; - _4 = Len(_2); -- _5 = Lt(_3, _4); -- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind unreachable]; +- _5 = Lt(copy _3, copy _4); +- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind unreachable]; + _4 = const 5000_usize; + _5 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 5000_usize, const 2_usize) -> [success: bb1, unwind unreachable]; } bb1: { -- _1 = _2[_3]; -+ _1 = _2[2 of 3]; +- _1 = copy _2[_3]; ++ _1 = copy _2[2 of 3]; StorageDead(_3); StorageDead(_2); _0 = const (); diff --git a/tests/mir-opt/dataflow-const-prop/large_array_index.main.DataflowConstProp.64bit.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/large_array_index.main.DataflowConstProp.64bit.panic-unwind.diff index 87024da2628b..af6e3626142f 100644 --- a/tests/mir-opt/dataflow-const-prop/large_array_index.main.DataflowConstProp.64bit.panic-unwind.diff +++ b/tests/mir-opt/dataflow-const-prop/large_array_index.main.DataflowConstProp.64bit.panic-unwind.diff @@ -19,16 +19,16 @@ StorageLive(_3); _3 = const 2_usize; - _4 = Len(_2); -- _5 = Lt(_3, _4); -- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind continue]; +- _5 = Lt(copy _3, copy _4); +- assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind continue]; + _4 = const 5000_usize; + _5 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 5000_usize, const 2_usize) -> [success: bb1, unwind continue]; } bb1: { -- _1 = _2[_3]; -+ _1 = _2[2 of 3]; +- _1 = copy _2[_3]; ++ _1 = copy _2[2 of 3]; StorageDead(_3); StorageDead(_2); _0 = const (); diff --git a/tests/mir-opt/dataflow-const-prop/mult_by_zero.test.DataflowConstProp.diff b/tests/mir-opt/dataflow-const-prop/mult_by_zero.test.DataflowConstProp.diff index 91bc10a562f7..8b05386b38ae 100644 --- a/tests/mir-opt/dataflow-const-prop/mult_by_zero.test.DataflowConstProp.diff +++ b/tests/mir-opt/dataflow-const-prop/mult_by_zero.test.DataflowConstProp.diff @@ -8,7 +8,7 @@ bb0: { StorageLive(_2); - _2 = _1; + _2 = copy _1; - _0 = Mul(move _2, const 0_i32); + _0 = const 0_i32; StorageDead(_2); diff --git a/tests/mir-opt/dataflow-const-prop/ref_without_sb.main.DataflowConstProp.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/ref_without_sb.main.DataflowConstProp.panic-abort.diff index fbbfd61bbedc..a0e83265d31c 100644 --- a/tests/mir-opt/dataflow-const-prop/ref_without_sb.main.DataflowConstProp.panic-abort.diff +++ b/tests/mir-opt/dataflow-const-prop/ref_without_sb.main.DataflowConstProp.panic-abort.diff @@ -39,7 +39,7 @@ bb2: { StorageDead(_5); StorageLive(_6); - _6 = _1; + _6 = copy _1; _0 = const (); StorageDead(_6); StorageDead(_1); diff --git a/tests/mir-opt/dataflow-const-prop/ref_without_sb.main.DataflowConstProp.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/ref_without_sb.main.DataflowConstProp.panic-unwind.diff index 4e1d26acfa3f..6dead031a9f6 100644 --- a/tests/mir-opt/dataflow-const-prop/ref_without_sb.main.DataflowConstProp.panic-unwind.diff +++ b/tests/mir-opt/dataflow-const-prop/ref_without_sb.main.DataflowConstProp.panic-unwind.diff @@ -39,7 +39,7 @@ bb2: { StorageDead(_5); StorageLive(_6); - _6 = _1; + _6 = copy _1; _0 = const (); StorageDead(_6); StorageDead(_1); diff --git a/tests/mir-opt/dataflow-const-prop/repeat.main.DataflowConstProp.32bit.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/repeat.main.DataflowConstProp.32bit.panic-abort.diff index a18ef6c9db76..dfa541b1200d 100644 --- a/tests/mir-opt/dataflow-const-prop/repeat.main.DataflowConstProp.32bit.panic-abort.diff +++ b/tests/mir-opt/dataflow-const-prop/repeat.main.DataflowConstProp.32bit.panic-abort.diff @@ -21,16 +21,16 @@ StorageLive(_4); _4 = const 2_usize; - _5 = Len(_3); -- _6 = Lt(_4, _5); -- assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, _4) -> [success: bb1, unwind unreachable]; +- _6 = Lt(copy _4, copy _5); +- assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, copy _4) -> [success: bb1, unwind unreachable]; + _5 = const 8_usize; + _6 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 8_usize, const 2_usize) -> [success: bb1, unwind unreachable]; } bb1: { -- _2 = _3[_4]; -+ _2 = _3[2 of 3]; +- _2 = copy _3[_4]; ++ _2 = copy _3[2 of 3]; _1 = Add(move _2, const 0_u32); StorageDead(_2); StorageDead(_4); diff --git a/tests/mir-opt/dataflow-const-prop/repeat.main.DataflowConstProp.32bit.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/repeat.main.DataflowConstProp.32bit.panic-unwind.diff index 3356ef98b14a..9ede3c5f7ac2 100644 --- a/tests/mir-opt/dataflow-const-prop/repeat.main.DataflowConstProp.32bit.panic-unwind.diff +++ b/tests/mir-opt/dataflow-const-prop/repeat.main.DataflowConstProp.32bit.panic-unwind.diff @@ -21,16 +21,16 @@ StorageLive(_4); _4 = const 2_usize; - _5 = Len(_3); -- _6 = Lt(_4, _5); -- assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, _4) -> [success: bb1, unwind continue]; +- _6 = Lt(copy _4, copy _5); +- assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, copy _4) -> [success: bb1, unwind continue]; + _5 = const 8_usize; + _6 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 8_usize, const 2_usize) -> [success: bb1, unwind continue]; } bb1: { -- _2 = _3[_4]; -+ _2 = _3[2 of 3]; +- _2 = copy _3[_4]; ++ _2 = copy _3[2 of 3]; _1 = Add(move _2, const 0_u32); StorageDead(_2); StorageDead(_4); diff --git a/tests/mir-opt/dataflow-const-prop/repeat.main.DataflowConstProp.64bit.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/repeat.main.DataflowConstProp.64bit.panic-abort.diff index a18ef6c9db76..dfa541b1200d 100644 --- a/tests/mir-opt/dataflow-const-prop/repeat.main.DataflowConstProp.64bit.panic-abort.diff +++ b/tests/mir-opt/dataflow-const-prop/repeat.main.DataflowConstProp.64bit.panic-abort.diff @@ -21,16 +21,16 @@ StorageLive(_4); _4 = const 2_usize; - _5 = Len(_3); -- _6 = Lt(_4, _5); -- assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, _4) -> [success: bb1, unwind unreachable]; +- _6 = Lt(copy _4, copy _5); +- assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, copy _4) -> [success: bb1, unwind unreachable]; + _5 = const 8_usize; + _6 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 8_usize, const 2_usize) -> [success: bb1, unwind unreachable]; } bb1: { -- _2 = _3[_4]; -+ _2 = _3[2 of 3]; +- _2 = copy _3[_4]; ++ _2 = copy _3[2 of 3]; _1 = Add(move _2, const 0_u32); StorageDead(_2); StorageDead(_4); diff --git a/tests/mir-opt/dataflow-const-prop/repeat.main.DataflowConstProp.64bit.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/repeat.main.DataflowConstProp.64bit.panic-unwind.diff index 3356ef98b14a..9ede3c5f7ac2 100644 --- a/tests/mir-opt/dataflow-const-prop/repeat.main.DataflowConstProp.64bit.panic-unwind.diff +++ b/tests/mir-opt/dataflow-const-prop/repeat.main.DataflowConstProp.64bit.panic-unwind.diff @@ -21,16 +21,16 @@ StorageLive(_4); _4 = const 2_usize; - _5 = Len(_3); -- _6 = Lt(_4, _5); -- assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, _4) -> [success: bb1, unwind continue]; +- _6 = Lt(copy _4, copy _5); +- assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, copy _4) -> [success: bb1, unwind continue]; + _5 = const 8_usize; + _6 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 8_usize, const 2_usize) -> [success: bb1, unwind continue]; } bb1: { -- _2 = _3[_4]; -+ _2 = _3[2 of 3]; +- _2 = copy _3[_4]; ++ _2 = copy _3[2 of 3]; _1 = Add(move _2, const 0_u32); StorageDead(_2); StorageDead(_4); diff --git a/tests/mir-opt/dataflow-const-prop/repr_transparent.main.DataflowConstProp.diff b/tests/mir-opt/dataflow-const-prop/repr_transparent.main.DataflowConstProp.diff index 98bd40ab2c3d..d0915432aaa6 100644 --- a/tests/mir-opt/dataflow-const-prop/repr_transparent.main.DataflowConstProp.diff +++ b/tests/mir-opt/dataflow-const-prop/repr_transparent.main.DataflowConstProp.diff @@ -22,10 +22,10 @@ StorageLive(_2); StorageLive(_3); StorageLive(_4); -- _4 = (_1.0: i32); +- _4 = copy (_1.0: i32); + _4 = const 0_i32; StorageLive(_5); -- _5 = (_1.0: i32); +- _5 = copy (_1.0: i32); - _3 = Add(move _4, move _5); + _5 = const 0_i32; + _3 = const 0_i32; diff --git a/tests/mir-opt/dataflow-const-prop/self_assign.main.DataflowConstProp.diff b/tests/mir-opt/dataflow-const-prop/self_assign.main.DataflowConstProp.diff index fbdbb3fa35ca..e54a0d64b166 100644 --- a/tests/mir-opt/dataflow-const-prop/self_assign.main.DataflowConstProp.diff +++ b/tests/mir-opt/dataflow-const-prop/self_assign.main.DataflowConstProp.diff @@ -20,21 +20,21 @@ StorageLive(_1); _1 = const 0_i32; StorageLive(_2); - _2 = _1; + _2 = copy _1; _1 = Add(move _2, const 1_i32); StorageDead(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; _1 = move _3; StorageDead(_3); StorageLive(_4); _4 = &_1; StorageLive(_5); - _5 = _4; + _5 = copy _4; _4 = move _5; StorageDead(_5); StorageLive(_6); - _6 = (*_4); + _6 = copy (*_4); _1 = move _6; StorageDead(_6); _0 = const (); diff --git a/tests/mir-opt/dataflow-const-prop/self_assign_add.main.DataflowConstProp.diff b/tests/mir-opt/dataflow-const-prop/self_assign_add.main.DataflowConstProp.diff index e2468a9645d6..77762ed90413 100644 --- a/tests/mir-opt/dataflow-const-prop/self_assign_add.main.DataflowConstProp.diff +++ b/tests/mir-opt/dataflow-const-prop/self_assign_add.main.DataflowConstProp.diff @@ -11,8 +11,8 @@ bb0: { StorageLive(_1); _1 = const 0_i32; -- _1 = Add(_1, const 1_i32); -- _1 = Add(_1, const 1_i32); +- _1 = Add(copy _1, const 1_i32); +- _1 = Add(copy _1, const 1_i32); + _1 = const 1_i32; + _1 = const 2_i32; _0 = const (); diff --git a/tests/mir-opt/dataflow-const-prop/sibling_ptr.main.DataflowConstProp.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/sibling_ptr.main.DataflowConstProp.panic-abort.diff index a5e409907510..178ebad6105a 100644 --- a/tests/mir-opt/dataflow-const-prop/sibling_ptr.main.DataflowConstProp.panic-abort.diff +++ b/tests/mir-opt/dataflow-const-prop/sibling_ptr.main.DataflowConstProp.panic-abort.diff @@ -27,7 +27,7 @@ _3 = &raw mut (_1.0: u8); StorageLive(_4); StorageLive(_5); - _5 = _3; + _5 = copy _3; _4 = std::ptr::mut_ptr::::add(move _5, const 1_usize) -> [return: bb1, unwind unreachable]; } @@ -39,7 +39,7 @@ StorageDead(_3); StorageDead(_2); StorageLive(_6); - _6 = (_1.1: u8); + _6 = copy (_1.1: u8); _0 = const (); StorageDead(_6); StorageDead(_1); diff --git a/tests/mir-opt/dataflow-const-prop/sibling_ptr.main.DataflowConstProp.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/sibling_ptr.main.DataflowConstProp.panic-unwind.diff index ce2178ddbee6..ce2545589f18 100644 --- a/tests/mir-opt/dataflow-const-prop/sibling_ptr.main.DataflowConstProp.panic-unwind.diff +++ b/tests/mir-opt/dataflow-const-prop/sibling_ptr.main.DataflowConstProp.panic-unwind.diff @@ -27,7 +27,7 @@ _3 = &raw mut (_1.0: u8); StorageLive(_4); StorageLive(_5); - _5 = _3; + _5 = copy _3; _4 = std::ptr::mut_ptr::::add(move _5, const 1_usize) -> [return: bb1, unwind continue]; } @@ -39,7 +39,7 @@ StorageDead(_3); StorageDead(_2); StorageLive(_6); - _6 = (_1.1: u8); + _6 = copy (_1.1: u8); _0 = const (); StorageDead(_6); StorageDead(_1); diff --git a/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.32bit.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.32bit.panic-abort.diff index efba4a4646cd..40632db667a8 100644 --- a/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.32bit.panic-abort.diff +++ b/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.32bit.panic-abort.diff @@ -30,23 +30,23 @@ StorageLive(_3); StorageLive(_4); _14 = const main::promoted[0]; - _4 = _14; - _3 = _4; + _4 = copy _14; + _3 = copy _4; _2 = move _3 as &[u32] (PointerCoercion(Unsize)); StorageDead(_3); StorageLive(_6); _6 = const 1_usize; - _7 = Len((*_2)); -- _8 = Lt(_6, _7); -- assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, _6) -> [success: bb1, unwind unreachable]; +- _8 = Lt(copy _6, copy _7); +- assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, copy _6) -> [success: bb1, unwind unreachable]; + _7 = const 3_usize; + _8 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 1_usize) -> [success: bb1, unwind unreachable]; } bb1: { -- _1 = (*_2)[_6]; -+ _1 = (*_2)[1 of 2]; +- _1 = copy (*_2)[_6]; ++ _1 = copy (*_2)[1 of 2]; StorageDead(_6); StorageDead(_4); StorageDead(_2); @@ -56,16 +56,16 @@ StorageLive(_11); _11 = const 1_usize; - _12 = Len((*_10)); -- _13 = Lt(_11, _12); -- assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, _11) -> [success: bb2, unwind unreachable]; +- _13 = Lt(copy _11, copy _12); +- assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, copy _11) -> [success: bb2, unwind unreachable]; + _12 = const 3_usize; + _13 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 1_usize) -> [success: bb2, unwind unreachable]; } bb2: { -- _9 = (*_10)[_11]; -+ _9 = (*_10)[1 of 2]; +- _9 = copy (*_10)[_11]; ++ _9 = copy (*_10)[1 of 2]; StorageDead(_11); StorageDead(_10); _0 = const (); diff --git a/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.32bit.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.32bit.panic-unwind.diff index bf477d7e041e..596b4ac9b1e5 100644 --- a/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.32bit.panic-unwind.diff +++ b/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.32bit.panic-unwind.diff @@ -30,23 +30,23 @@ StorageLive(_3); StorageLive(_4); _14 = const main::promoted[0]; - _4 = _14; - _3 = _4; + _4 = copy _14; + _3 = copy _4; _2 = move _3 as &[u32] (PointerCoercion(Unsize)); StorageDead(_3); StorageLive(_6); _6 = const 1_usize; - _7 = Len((*_2)); -- _8 = Lt(_6, _7); -- assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, _6) -> [success: bb1, unwind continue]; +- _8 = Lt(copy _6, copy _7); +- assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, copy _6) -> [success: bb1, unwind continue]; + _7 = const 3_usize; + _8 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 1_usize) -> [success: bb1, unwind continue]; } bb1: { -- _1 = (*_2)[_6]; -+ _1 = (*_2)[1 of 2]; +- _1 = copy (*_2)[_6]; ++ _1 = copy (*_2)[1 of 2]; StorageDead(_6); StorageDead(_4); StorageDead(_2); @@ -56,16 +56,16 @@ StorageLive(_11); _11 = const 1_usize; - _12 = Len((*_10)); -- _13 = Lt(_11, _12); -- assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, _11) -> [success: bb2, unwind continue]; +- _13 = Lt(copy _11, copy _12); +- assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, copy _11) -> [success: bb2, unwind continue]; + _12 = const 3_usize; + _13 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 1_usize) -> [success: bb2, unwind continue]; } bb2: { -- _9 = (*_10)[_11]; -+ _9 = (*_10)[1 of 2]; +- _9 = copy (*_10)[_11]; ++ _9 = copy (*_10)[1 of 2]; StorageDead(_11); StorageDead(_10); _0 = const (); diff --git a/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.64bit.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.64bit.panic-abort.diff index efba4a4646cd..40632db667a8 100644 --- a/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.64bit.panic-abort.diff +++ b/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.64bit.panic-abort.diff @@ -30,23 +30,23 @@ StorageLive(_3); StorageLive(_4); _14 = const main::promoted[0]; - _4 = _14; - _3 = _4; + _4 = copy _14; + _3 = copy _4; _2 = move _3 as &[u32] (PointerCoercion(Unsize)); StorageDead(_3); StorageLive(_6); _6 = const 1_usize; - _7 = Len((*_2)); -- _8 = Lt(_6, _7); -- assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, _6) -> [success: bb1, unwind unreachable]; +- _8 = Lt(copy _6, copy _7); +- assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, copy _6) -> [success: bb1, unwind unreachable]; + _7 = const 3_usize; + _8 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 1_usize) -> [success: bb1, unwind unreachable]; } bb1: { -- _1 = (*_2)[_6]; -+ _1 = (*_2)[1 of 2]; +- _1 = copy (*_2)[_6]; ++ _1 = copy (*_2)[1 of 2]; StorageDead(_6); StorageDead(_4); StorageDead(_2); @@ -56,16 +56,16 @@ StorageLive(_11); _11 = const 1_usize; - _12 = Len((*_10)); -- _13 = Lt(_11, _12); -- assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, _11) -> [success: bb2, unwind unreachable]; +- _13 = Lt(copy _11, copy _12); +- assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, copy _11) -> [success: bb2, unwind unreachable]; + _12 = const 3_usize; + _13 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 1_usize) -> [success: bb2, unwind unreachable]; } bb2: { -- _9 = (*_10)[_11]; -+ _9 = (*_10)[1 of 2]; +- _9 = copy (*_10)[_11]; ++ _9 = copy (*_10)[1 of 2]; StorageDead(_11); StorageDead(_10); _0 = const (); diff --git a/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.64bit.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.64bit.panic-unwind.diff index bf477d7e041e..596b4ac9b1e5 100644 --- a/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.64bit.panic-unwind.diff +++ b/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.64bit.panic-unwind.diff @@ -30,23 +30,23 @@ StorageLive(_3); StorageLive(_4); _14 = const main::promoted[0]; - _4 = _14; - _3 = _4; + _4 = copy _14; + _3 = copy _4; _2 = move _3 as &[u32] (PointerCoercion(Unsize)); StorageDead(_3); StorageLive(_6); _6 = const 1_usize; - _7 = Len((*_2)); -- _8 = Lt(_6, _7); -- assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, _6) -> [success: bb1, unwind continue]; +- _8 = Lt(copy _6, copy _7); +- assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, copy _6) -> [success: bb1, unwind continue]; + _7 = const 3_usize; + _8 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 1_usize) -> [success: bb1, unwind continue]; } bb1: { -- _1 = (*_2)[_6]; -+ _1 = (*_2)[1 of 2]; +- _1 = copy (*_2)[_6]; ++ _1 = copy (*_2)[1 of 2]; StorageDead(_6); StorageDead(_4); StorageDead(_2); @@ -56,16 +56,16 @@ StorageLive(_11); _11 = const 1_usize; - _12 = Len((*_10)); -- _13 = Lt(_11, _12); -- assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, _11) -> [success: bb2, unwind continue]; +- _13 = Lt(copy _11, copy _12); +- assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, copy _11) -> [success: bb2, unwind continue]; + _12 = const 3_usize; + _13 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 1_usize) -> [success: bb2, unwind continue]; } bb2: { -- _9 = (*_10)[_11]; -+ _9 = (*_10)[1 of 2]; +- _9 = copy (*_10)[_11]; ++ _9 = copy (*_10)[1 of 2]; StorageDead(_11); StorageDead(_10); _0 = const (); diff --git a/tests/mir-opt/dataflow-const-prop/struct.main.DataflowConstProp.32bit.diff b/tests/mir-opt/dataflow-const-prop/struct.main.DataflowConstProp.32bit.diff index 5e89382ea8f4..3ea49265cee3 100644 --- a/tests/mir-opt/dataflow-const-prop/struct.main.DataflowConstProp.32bit.diff +++ b/tests/mir-opt/dataflow-const-prop/struct.main.DataflowConstProp.32bit.diff @@ -83,7 +83,7 @@ + _1 = const S(1_i32); StorageLive(_2); StorageLive(_3); -- _3 = (_1.0: i32); +- _3 = copy (_1.0: i32); - _2 = Add(move _3, const 2_i32); + _3 = const 1_i32; + _2 = const 3_i32; @@ -91,10 +91,10 @@ (_1.0: i32) = const 3_i32; StorageLive(_4); StorageLive(_5); -- _5 = _2; +- _5 = copy _2; + _5 = const 3_i32; StorageLive(_6); -- _6 = (_1.0: i32); +- _6 = copy (_1.0: i32); - _4 = Add(move _5, move _6); + _6 = const 3_i32; + _4 = const 6_i32; @@ -103,35 +103,35 @@ StorageLive(_10); _10 = const main::SMALL_VAL; StorageLive(_7); -- _7 = (_10.0: f32); +- _7 = copy (_10.0: f32); + _7 = const 4f32; StorageLive(_8); - _8 = (_10.1: std::option::Option); + _8 = copy (_10.1: std::option::Option); StorageLive(_9); - _9 = (_10.2: &[f32]); + _9 = copy (_10.2: &[f32]); StorageDead(_10); StorageLive(_14); _14 = const {ALLOC0: &&SmallStruct}; _31 = deref_copy (*_14); StorageLive(_11); _32 = deref_copy (*_14); -- _11 = ((*_32).0: f32); +- _11 = copy ((*_32).0: f32); + _11 = const 9f32; StorageLive(_12); _33 = deref_copy (*_14); - _12 = ((*_33).1: std::option::Option); + _12 = copy ((*_33).1: std::option::Option); StorageLive(_13); _34 = deref_copy (*_14); - _13 = ((*_34).2: &[f32]); + _13 = copy ((*_34).2: &[f32]); StorageDead(_14); StorageLive(_15); StorageLive(_16); -- _16 = _11; +- _16 = copy _11; + _16 = const 9f32; StorageLive(_17); - _17 = _12; + _17 = copy _12; StorageLive(_18); - _18 = _13; + _18 = copy _13; - _15 = SmallStruct(move _16, move _17, move _18); + _15 = SmallStruct(const 9f32, move _17, move _18); StorageDead(_18); @@ -140,35 +140,35 @@ StorageLive(_22); _22 = const main::BIG_VAL; StorageLive(_19); -- _19 = (_22.0: f32); +- _19 = copy (_22.0: f32); + _19 = const 25f32; StorageLive(_20); - _20 = (_22.1: std::option::Option); + _20 = copy (_22.1: std::option::Option); StorageLive(_21); - _21 = (_22.2: &[f32]); + _21 = copy (_22.2: &[f32]); StorageDead(_22); StorageLive(_26); _26 = const {ALLOC1: &&BigStruct}; _35 = deref_copy (*_26); StorageLive(_23); _36 = deref_copy (*_26); -- _23 = ((*_36).0: f32); +- _23 = copy ((*_36).0: f32); + _23 = const 82f32; StorageLive(_24); _37 = deref_copy (*_26); - _24 = ((*_37).1: std::option::Option); + _24 = copy ((*_37).1: std::option::Option); StorageLive(_25); _38 = deref_copy (*_26); - _25 = ((*_38).2: &[f32]); + _25 = copy ((*_38).2: &[f32]); StorageDead(_26); StorageLive(_27); StorageLive(_28); -- _28 = _23; +- _28 = copy _23; + _28 = const 82f32; StorageLive(_29); - _29 = _24; + _29 = copy _24; StorageLive(_30); - _30 = _25; + _30 = copy _25; - _27 = BigStruct(move _28, move _29, move _30); + _27 = BigStruct(const 82f32, move _29, move _30); StorageDead(_30); diff --git a/tests/mir-opt/dataflow-const-prop/struct.main.DataflowConstProp.64bit.diff b/tests/mir-opt/dataflow-const-prop/struct.main.DataflowConstProp.64bit.diff index a707d7e5e76e..78a0944975c8 100644 --- a/tests/mir-opt/dataflow-const-prop/struct.main.DataflowConstProp.64bit.diff +++ b/tests/mir-opt/dataflow-const-prop/struct.main.DataflowConstProp.64bit.diff @@ -83,7 +83,7 @@ + _1 = const S(1_i32); StorageLive(_2); StorageLive(_3); -- _3 = (_1.0: i32); +- _3 = copy (_1.0: i32); - _2 = Add(move _3, const 2_i32); + _3 = const 1_i32; + _2 = const 3_i32; @@ -91,10 +91,10 @@ (_1.0: i32) = const 3_i32; StorageLive(_4); StorageLive(_5); -- _5 = _2; +- _5 = copy _2; + _5 = const 3_i32; StorageLive(_6); -- _6 = (_1.0: i32); +- _6 = copy (_1.0: i32); - _4 = Add(move _5, move _6); + _6 = const 3_i32; + _4 = const 6_i32; @@ -103,35 +103,35 @@ StorageLive(_10); _10 = const main::SMALL_VAL; StorageLive(_7); -- _7 = (_10.0: f32); +- _7 = copy (_10.0: f32); + _7 = const 4f32; StorageLive(_8); - _8 = (_10.1: std::option::Option); + _8 = copy (_10.1: std::option::Option); StorageLive(_9); - _9 = (_10.2: &[f32]); + _9 = copy (_10.2: &[f32]); StorageDead(_10); StorageLive(_14); _14 = const {ALLOC0: &&SmallStruct}; _31 = deref_copy (*_14); StorageLive(_11); _32 = deref_copy (*_14); -- _11 = ((*_32).0: f32); +- _11 = copy ((*_32).0: f32); + _11 = const 9f32; StorageLive(_12); _33 = deref_copy (*_14); - _12 = ((*_33).1: std::option::Option); + _12 = copy ((*_33).1: std::option::Option); StorageLive(_13); _34 = deref_copy (*_14); - _13 = ((*_34).2: &[f32]); + _13 = copy ((*_34).2: &[f32]); StorageDead(_14); StorageLive(_15); StorageLive(_16); -- _16 = _11; +- _16 = copy _11; + _16 = const 9f32; StorageLive(_17); - _17 = _12; + _17 = copy _12; StorageLive(_18); - _18 = _13; + _18 = copy _13; - _15 = SmallStruct(move _16, move _17, move _18); + _15 = SmallStruct(const 9f32, move _17, move _18); StorageDead(_18); @@ -140,35 +140,35 @@ StorageLive(_22); _22 = const main::BIG_VAL; StorageLive(_19); -- _19 = (_22.0: f32); +- _19 = copy (_22.0: f32); + _19 = const 25f32; StorageLive(_20); - _20 = (_22.1: std::option::Option); + _20 = copy (_22.1: std::option::Option); StorageLive(_21); - _21 = (_22.2: &[f32]); + _21 = copy (_22.2: &[f32]); StorageDead(_22); StorageLive(_26); _26 = const {ALLOC1: &&BigStruct}; _35 = deref_copy (*_26); StorageLive(_23); _36 = deref_copy (*_26); -- _23 = ((*_36).0: f32); +- _23 = copy ((*_36).0: f32); + _23 = const 82f32; StorageLive(_24); _37 = deref_copy (*_26); - _24 = ((*_37).1: std::option::Option); + _24 = copy ((*_37).1: std::option::Option); StorageLive(_25); _38 = deref_copy (*_26); - _25 = ((*_38).2: &[f32]); + _25 = copy ((*_38).2: &[f32]); StorageDead(_26); StorageLive(_27); StorageLive(_28); -- _28 = _23; +- _28 = copy _23; + _28 = const 82f32; StorageLive(_29); - _29 = _24; + _29 = copy _24; StorageLive(_30); - _30 = _25; + _30 = copy _25; - _27 = BigStruct(move _28, move _29, move _30); + _27 = BigStruct(const 82f32, move _29, move _30); StorageDead(_30); diff --git a/tests/mir-opt/dataflow-const-prop/terminator.main.DataflowConstProp.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/terminator.main.DataflowConstProp.panic-abort.diff index c0f378cc21f8..e13b2aa9f7e3 100644 --- a/tests/mir-opt/dataflow-const-prop/terminator.main.DataflowConstProp.panic-abort.diff +++ b/tests/mir-opt/dataflow-const-prop/terminator.main.DataflowConstProp.panic-abort.diff @@ -17,7 +17,7 @@ StorageLive(_2); StorageLive(_3); StorageLive(_4); -- _4 = _1; +- _4 = copy _1; - _3 = Add(move _4, const 1_i32); + _4 = const 1_i32; + _3 = const 2_i32; diff --git a/tests/mir-opt/dataflow-const-prop/terminator.main.DataflowConstProp.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/terminator.main.DataflowConstProp.panic-unwind.diff index 395620fec524..4be25fdcc38d 100644 --- a/tests/mir-opt/dataflow-const-prop/terminator.main.DataflowConstProp.panic-unwind.diff +++ b/tests/mir-opt/dataflow-const-prop/terminator.main.DataflowConstProp.panic-unwind.diff @@ -17,7 +17,7 @@ StorageLive(_2); StorageLive(_3); StorageLive(_4); -- _4 = _1; +- _4 = copy _1; - _3 = Add(move _4, const 1_i32); + _4 = const 1_i32; + _3 = const 2_i32; diff --git a/tests/mir-opt/dataflow-const-prop/transmute.unreachable_box.DataflowConstProp.32bit.diff b/tests/mir-opt/dataflow-const-prop/transmute.unreachable_box.DataflowConstProp.32bit.diff index 258e2b454ebe..2d67ac92209b 100644 --- a/tests/mir-opt/dataflow-const-prop/transmute.unreachable_box.DataflowConstProp.32bit.diff +++ b/tests/mir-opt/dataflow-const-prop/transmute.unreachable_box.DataflowConstProp.32bit.diff @@ -13,7 +13,7 @@ StorageLive(_1); - _1 = const 1_usize as std::boxed::Box (Transmute); + _1 = const Box::(Unique:: {{ pointer: NonNull:: {{ pointer: {0x1 as *const Never} }}, _marker: PhantomData:: }}, std::alloc::Global); - _2 = (((_1.0: std::ptr::Unique).0: std::ptr::NonNull).0: *const Never); + _2 = copy (((_1.0: std::ptr::Unique).0: std::ptr::NonNull).0: *const Never); unreachable; } } diff --git a/tests/mir-opt/dataflow-const-prop/transmute.unreachable_box.DataflowConstProp.64bit.diff b/tests/mir-opt/dataflow-const-prop/transmute.unreachable_box.DataflowConstProp.64bit.diff index 258e2b454ebe..2d67ac92209b 100644 --- a/tests/mir-opt/dataflow-const-prop/transmute.unreachable_box.DataflowConstProp.64bit.diff +++ b/tests/mir-opt/dataflow-const-prop/transmute.unreachable_box.DataflowConstProp.64bit.diff @@ -13,7 +13,7 @@ StorageLive(_1); - _1 = const 1_usize as std::boxed::Box (Transmute); + _1 = const Box::(Unique:: {{ pointer: NonNull:: {{ pointer: {0x1 as *const Never} }}, _marker: PhantomData:: }}, std::alloc::Global); - _2 = (((_1.0: std::ptr::Unique).0: std::ptr::NonNull).0: *const Never); + _2 = copy (((_1.0: std::ptr::Unique).0: std::ptr::NonNull).0: *const Never); unreachable; } } diff --git a/tests/mir-opt/dataflow-const-prop/tuple.main.DataflowConstProp.32bit.diff b/tests/mir-opt/dataflow-const-prop/tuple.main.DataflowConstProp.32bit.diff index e4031b65caaf..f7846823e196 100644 --- a/tests/mir-opt/dataflow-const-prop/tuple.main.DataflowConstProp.32bit.diff +++ b/tests/mir-opt/dataflow-const-prop/tuple.main.DataflowConstProp.32bit.diff @@ -37,10 +37,10 @@ StorageLive(_2); StorageLive(_3); StorageLive(_4); -- _4 = (_1.0: i32); +- _4 = copy (_1.0: i32); + _4 = const 1_i32; StorageLive(_5); -- _5 = (_1.1: i32); +- _5 = copy (_1.1: i32); - _3 = Add(move _4, move _5); + _5 = const 2_i32; + _3 = const 3_i32; @@ -54,17 +54,17 @@ StorageLive(_6); StorageLive(_7); StorageLive(_8); -- _8 = (_1.0: i32); +- _8 = copy (_1.0: i32); + _8 = const 2_i32; StorageLive(_9); -- _9 = (_1.1: i32); +- _9 = copy (_1.1: i32); - _7 = Add(move _8, move _9); + _9 = const 3_i32; + _7 = const 5_i32; StorageDead(_9); StorageDead(_8); StorageLive(_10); -- _10 = _2; +- _10 = copy _2; - _6 = Add(move _7, move _10); + _10 = const 6_i32; + _6 = const 11_i32; @@ -72,13 +72,13 @@ StorageDead(_7); StorageLive(_11); StorageLive(_12); -- _12 = _2; +- _12 = copy _2; + _12 = const 6_i32; StorageLive(_13); -- _13 = _1; +- _13 = copy _1; + _13 = const (2_i32, 3_i32); StorageLive(_14); -- _14 = _6; +- _14 = copy _6; - _11 = (move _12, move _13, move _14); + _14 = const 11_i32; + _11 = (const 6_i32, const (2_i32, 3_i32), const 11_i32); diff --git a/tests/mir-opt/dataflow-const-prop/tuple.main.DataflowConstProp.64bit.diff b/tests/mir-opt/dataflow-const-prop/tuple.main.DataflowConstProp.64bit.diff index e4031b65caaf..f7846823e196 100644 --- a/tests/mir-opt/dataflow-const-prop/tuple.main.DataflowConstProp.64bit.diff +++ b/tests/mir-opt/dataflow-const-prop/tuple.main.DataflowConstProp.64bit.diff @@ -37,10 +37,10 @@ StorageLive(_2); StorageLive(_3); StorageLive(_4); -- _4 = (_1.0: i32); +- _4 = copy (_1.0: i32); + _4 = const 1_i32; StorageLive(_5); -- _5 = (_1.1: i32); +- _5 = copy (_1.1: i32); - _3 = Add(move _4, move _5); + _5 = const 2_i32; + _3 = const 3_i32; @@ -54,17 +54,17 @@ StorageLive(_6); StorageLive(_7); StorageLive(_8); -- _8 = (_1.0: i32); +- _8 = copy (_1.0: i32); + _8 = const 2_i32; StorageLive(_9); -- _9 = (_1.1: i32); +- _9 = copy (_1.1: i32); - _7 = Add(move _8, move _9); + _9 = const 3_i32; + _7 = const 5_i32; StorageDead(_9); StorageDead(_8); StorageLive(_10); -- _10 = _2; +- _10 = copy _2; - _6 = Add(move _7, move _10); + _10 = const 6_i32; + _6 = const 11_i32; @@ -72,13 +72,13 @@ StorageDead(_7); StorageLive(_11); StorageLive(_12); -- _12 = _2; +- _12 = copy _2; + _12 = const 6_i32; StorageLive(_13); -- _13 = _1; +- _13 = copy _1; + _13 = const (2_i32, 3_i32); StorageLive(_14); -- _14 = _6; +- _14 = copy _6; - _11 = (move _12, move _13, move _14); + _14 = const 11_i32; + _11 = (const 6_i32, const (2_i32, 3_i32), const 11_i32); diff --git a/tests/mir-opt/dead-store-elimination/call_arg_copy.move_packed.DeadStoreElimination-final.panic-abort.diff b/tests/mir-opt/dead-store-elimination/call_arg_copy.move_packed.DeadStoreElimination-final.panic-abort.diff index 07fb8301b9a9..80b727dd1a45 100644 --- a/tests/mir-opt/dead-store-elimination/call_arg_copy.move_packed.DeadStoreElimination-final.panic-abort.diff +++ b/tests/mir-opt/dead-store-elimination/call_arg_copy.move_packed.DeadStoreElimination-final.panic-abort.diff @@ -5,7 +5,7 @@ let mut _0: (); bb0: { - _0 = use_both(const 0_i32, (_1.1: i32)) -> [return: bb1, unwind unreachable]; + _0 = use_both(const 0_i32, copy (_1.1: i32)) -> [return: bb1, unwind unreachable]; } bb1: { diff --git a/tests/mir-opt/dead-store-elimination/call_arg_copy.move_packed.DeadStoreElimination-final.panic-unwind.diff b/tests/mir-opt/dead-store-elimination/call_arg_copy.move_packed.DeadStoreElimination-final.panic-unwind.diff index cac3badfa673..c7aff795bd8c 100644 --- a/tests/mir-opt/dead-store-elimination/call_arg_copy.move_packed.DeadStoreElimination-final.panic-unwind.diff +++ b/tests/mir-opt/dead-store-elimination/call_arg_copy.move_packed.DeadStoreElimination-final.panic-unwind.diff @@ -5,7 +5,7 @@ let mut _0: (); bb0: { - _0 = use_both(const 0_i32, (_1.1: i32)) -> [return: bb1, unwind continue]; + _0 = use_both(const 0_i32, copy (_1.1: i32)) -> [return: bb1, unwind continue]; } bb1: { diff --git a/tests/mir-opt/dead-store-elimination/call_arg_copy.move_simple.DeadStoreElimination-final.panic-abort.diff b/tests/mir-opt/dead-store-elimination/call_arg_copy.move_simple.DeadStoreElimination-final.panic-abort.diff index f9bc9405d6a4..a09ef3e4f34a 100644 --- a/tests/mir-opt/dead-store-elimination/call_arg_copy.move_simple.DeadStoreElimination-final.panic-abort.diff +++ b/tests/mir-opt/dead-store-elimination/call_arg_copy.move_simple.DeadStoreElimination-final.panic-abort.diff @@ -10,8 +10,8 @@ bb0: { StorageLive(_2); -- _2 = use_both(_1, _1) -> [return: bb1, unwind unreachable]; -+ _2 = use_both(_1, move _1) -> [return: bb1, unwind unreachable]; +- _2 = use_both(copy _1, copy _1) -> [return: bb1, unwind unreachable]; ++ _2 = use_both(copy _1, move _1) -> [return: bb1, unwind unreachable]; } bb1: { diff --git a/tests/mir-opt/dead-store-elimination/call_arg_copy.move_simple.DeadStoreElimination-final.panic-unwind.diff b/tests/mir-opt/dead-store-elimination/call_arg_copy.move_simple.DeadStoreElimination-final.panic-unwind.diff index efe165422d94..09413c99fefb 100644 --- a/tests/mir-opt/dead-store-elimination/call_arg_copy.move_simple.DeadStoreElimination-final.panic-unwind.diff +++ b/tests/mir-opt/dead-store-elimination/call_arg_copy.move_simple.DeadStoreElimination-final.panic-unwind.diff @@ -10,8 +10,8 @@ bb0: { StorageLive(_2); -- _2 = use_both(_1, _1) -> [return: bb1, unwind continue]; -+ _2 = use_both(_1, move _1) -> [return: bb1, unwind continue]; +- _2 = use_both(copy _1, copy _1) -> [return: bb1, unwind continue]; ++ _2 = use_both(copy _1, move _1) -> [return: bb1, unwind continue]; } bb1: { diff --git a/tests/mir-opt/dead-store-elimination/cycle.cycle.DeadStoreElimination-initial.diff b/tests/mir-opt/dead-store-elimination/cycle.cycle.DeadStoreElimination-initial.diff index 2766b6ce6a9f..ff18df1efcfc 100644 --- a/tests/mir-opt/dead-store-elimination/cycle.cycle.DeadStoreElimination-initial.diff +++ b/tests/mir-opt/dead-store-elimination/cycle.cycle.DeadStoreElimination-initial.diff @@ -11,14 +11,14 @@ } bb1: { - switchInt(_4) -> [1: bb2, otherwise: bb3]; + switchInt(copy _4) -> [1: bb2, otherwise: bb3]; } bb2: { -- _5 = _3; -- _3 = _2; -- _2 = _1; -- _1 = _5; +- _5 = copy _3; +- _3 = copy _2; +- _2 = copy _1; +- _1 = copy _5; + nop; + nop; + nop; diff --git a/tests/mir-opt/dead-store-elimination/provenance_soundness.pointer_to_int.DeadStoreElimination-initial.diff b/tests/mir-opt/dead-store-elimination/provenance_soundness.pointer_to_int.DeadStoreElimination-initial.diff index 56d5c24ae1dc..5d054e2ea16f 100644 --- a/tests/mir-opt/dead-store-elimination/provenance_soundness.pointer_to_int.DeadStoreElimination-initial.diff +++ b/tests/mir-opt/dead-store-elimination/provenance_soundness.pointer_to_int.DeadStoreElimination-initial.diff @@ -18,12 +18,12 @@ bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; _2 = move _3 as usize (PointerExposeProvenance); StorageDead(_3); StorageLive(_4); StorageLive(_5); - _5 = _1; + _5 = copy _1; _4 = move _5 as isize (PointerExposeProvenance); StorageDead(_5); _0 = const (); diff --git a/tests/mir-opt/deduplicate_blocks.is_line_doc_comment_2.DeduplicateBlocks.panic-abort.diff b/tests/mir-opt/deduplicate_blocks.is_line_doc_comment_2.DeduplicateBlocks.panic-abort.diff index efb28ba344b2..60742ef0e9a9 100644 --- a/tests/mir-opt/deduplicate_blocks.is_line_doc_comment_2.DeduplicateBlocks.panic-abort.diff +++ b/tests/mir-opt/deduplicate_blocks.is_line_doc_comment_2.DeduplicateBlocks.panic-abort.diff @@ -37,40 +37,40 @@ } bb3: { - switchInt((*_2)[0 of 4]) -> [47: bb4, otherwise: bb2]; + switchInt(copy (*_2)[0 of 4]) -> [47: bb4, otherwise: bb2]; } bb4: { - switchInt((*_2)[1 of 4]) -> [47: bb5, otherwise: bb2]; + switchInt(copy (*_2)[1 of 4]) -> [47: bb5, otherwise: bb2]; } bb5: { - switchInt((*_2)[2 of 4]) -> [47: bb6, otherwise: bb2]; + switchInt(copy (*_2)[2 of 4]) -> [47: bb6, otherwise: bb2]; } bb6: { -- switchInt((*_2)[3 of 4]) -> [47: bb13, otherwise: bb2]; -+ switchInt((*_2)[3 of 4]) -> [47: bb11, otherwise: bb2]; +- switchInt(copy (*_2)[3 of 4]) -> [47: bb13, otherwise: bb2]; ++ switchInt(copy (*_2)[3 of 4]) -> [47: bb11, otherwise: bb2]; } bb7: { - _0 = const false; - goto -> bb14; -+ switchInt((*_2)[0 of 3]) -> [47: bb8, otherwise: bb11]; ++ switchInt(copy (*_2)[0 of 3]) -> [47: bb8, otherwise: bb11]; } bb8: { -- switchInt((*_2)[0 of 3]) -> [47: bb9, otherwise: bb7]; -+ switchInt((*_2)[1 of 3]) -> [47: bb9, otherwise: bb11]; +- switchInt(copy (*_2)[0 of 3]) -> [47: bb9, otherwise: bb7]; ++ switchInt(copy (*_2)[1 of 3]) -> [47: bb9, otherwise: bb11]; } bb9: { -- switchInt((*_2)[1 of 3]) -> [47: bb10, otherwise: bb7]; -+ switchInt((*_2)[2 of 3]) -> [47: bb10, 33: bb10, otherwise: bb11]; +- switchInt(copy (*_2)[1 of 3]) -> [47: bb10, otherwise: bb7]; ++ switchInt(copy (*_2)[2 of 3]) -> [47: bb10, 33: bb10, otherwise: bb11]; } bb10: { -- switchInt((*_2)[2 of 3]) -> [47: bb12, 33: bb11, otherwise: bb7]; +- switchInt(copy (*_2)[2 of 3]) -> [47: bb12, 33: bb11, otherwise: bb7]; - } - - bb11: { diff --git a/tests/mir-opt/deduplicate_blocks.is_line_doc_comment_2.DeduplicateBlocks.panic-unwind.diff b/tests/mir-opt/deduplicate_blocks.is_line_doc_comment_2.DeduplicateBlocks.panic-unwind.diff index c6e2d3a55125..7337a32f525f 100644 --- a/tests/mir-opt/deduplicate_blocks.is_line_doc_comment_2.DeduplicateBlocks.panic-unwind.diff +++ b/tests/mir-opt/deduplicate_blocks.is_line_doc_comment_2.DeduplicateBlocks.panic-unwind.diff @@ -37,40 +37,40 @@ } bb3: { - switchInt((*_2)[0 of 4]) -> [47: bb4, otherwise: bb2]; + switchInt(copy (*_2)[0 of 4]) -> [47: bb4, otherwise: bb2]; } bb4: { - switchInt((*_2)[1 of 4]) -> [47: bb5, otherwise: bb2]; + switchInt(copy (*_2)[1 of 4]) -> [47: bb5, otherwise: bb2]; } bb5: { - switchInt((*_2)[2 of 4]) -> [47: bb6, otherwise: bb2]; + switchInt(copy (*_2)[2 of 4]) -> [47: bb6, otherwise: bb2]; } bb6: { -- switchInt((*_2)[3 of 4]) -> [47: bb13, otherwise: bb2]; -+ switchInt((*_2)[3 of 4]) -> [47: bb11, otherwise: bb2]; +- switchInt(copy (*_2)[3 of 4]) -> [47: bb13, otherwise: bb2]; ++ switchInt(copy (*_2)[3 of 4]) -> [47: bb11, otherwise: bb2]; } bb7: { - _0 = const false; - goto -> bb14; -+ switchInt((*_2)[0 of 3]) -> [47: bb8, otherwise: bb11]; ++ switchInt(copy (*_2)[0 of 3]) -> [47: bb8, otherwise: bb11]; } bb8: { -- switchInt((*_2)[0 of 3]) -> [47: bb9, otherwise: bb7]; -+ switchInt((*_2)[1 of 3]) -> [47: bb9, otherwise: bb11]; +- switchInt(copy (*_2)[0 of 3]) -> [47: bb9, otherwise: bb7]; ++ switchInt(copy (*_2)[1 of 3]) -> [47: bb9, otherwise: bb11]; } bb9: { -- switchInt((*_2)[1 of 3]) -> [47: bb10, otherwise: bb7]; -+ switchInt((*_2)[2 of 3]) -> [47: bb10, 33: bb10, otherwise: bb11]; +- switchInt(copy (*_2)[1 of 3]) -> [47: bb10, otherwise: bb7]; ++ switchInt(copy (*_2)[2 of 3]) -> [47: bb10, 33: bb10, otherwise: bb11]; } bb10: { -- switchInt((*_2)[2 of 3]) -> [47: bb12, 33: bb11, otherwise: bb7]; +- switchInt(copy (*_2)[2 of 3]) -> [47: bb12, 33: bb11, otherwise: bb7]; - } - - bb11: { diff --git a/tests/mir-opt/derefer_complex_case.main.Derefer.panic-abort.diff b/tests/mir-opt/derefer_complex_case.main.Derefer.panic-abort.diff index 4ead50e96d8b..bac62c886688 100644 --- a/tests/mir-opt/derefer_complex_case.main.Derefer.panic-abort.diff +++ b/tests/mir-opt/derefer_complex_case.main.Derefer.panic-abort.diff @@ -64,11 +64,11 @@ bb5: { StorageLive(_12); -- _12 = (*((_7 as Some).0: &i32)); +- _12 = copy (*((_7 as Some).0: &i32)); + _15 = deref_copy ((_7 as Some).0: &i32); -+ _12 = (*_15); ++ _12 = copy (*_15); StorageLive(_13); - _13 = _12; + _13 = copy _12; _6 = std::mem::drop::(move _13) -> [return: bb7, unwind: bb8]; } diff --git a/tests/mir-opt/derefer_complex_case.main.Derefer.panic-unwind.diff b/tests/mir-opt/derefer_complex_case.main.Derefer.panic-unwind.diff index c7cf5f02e0ea..55cd2e427eea 100644 --- a/tests/mir-opt/derefer_complex_case.main.Derefer.panic-unwind.diff +++ b/tests/mir-opt/derefer_complex_case.main.Derefer.panic-unwind.diff @@ -64,11 +64,11 @@ bb5: { StorageLive(_12); -- _12 = (*((_7 as Some).0: &i32)); +- _12 = copy (*((_7 as Some).0: &i32)); + _15 = deref_copy ((_7 as Some).0: &i32); -+ _12 = (*_15); ++ _12 = copy (*_15); StorageLive(_13); - _13 = _12; + _13 = copy _12; _6 = std::mem::drop::(move _13) -> [return: bb7, unwind continue]; } diff --git a/tests/mir-opt/derefer_terminator_test.main.Derefer.panic-abort.diff b/tests/mir-opt/derefer_terminator_test.main.Derefer.panic-abort.diff index f4c034517f7e..012d2eb8b72c 100644 --- a/tests/mir-opt/derefer_terminator_test.main.Derefer.panic-abort.diff +++ b/tests/mir-opt/derefer_terminator_test.main.Derefer.panic-abort.diff @@ -52,7 +52,7 @@ _5 = &_6; _4 = &_5; - PlaceMention((*(*(*(*_4))))); -- switchInt((*(*(*(*_4))))) -> [0: bb3, otherwise: bb4]; +- switchInt(copy (*(*(*(*_4))))) -> [0: bb3, otherwise: bb4]; + _10 = deref_copy (*_4); + _11 = deref_copy (*_10); + _12 = deref_copy (*_11); @@ -60,7 +60,7 @@ + _13 = deref_copy (*_4); + _14 = deref_copy (*_13); + _15 = deref_copy (*_14); -+ switchInt((*_15)) -> [0: bb3, otherwise: bb4]; ++ switchInt(copy (*_15)) -> [0: bb3, otherwise: bb4]; } bb3: { diff --git a/tests/mir-opt/derefer_terminator_test.main.Derefer.panic-unwind.diff b/tests/mir-opt/derefer_terminator_test.main.Derefer.panic-unwind.diff index e3c0c6b7dd27..43cee2923352 100644 --- a/tests/mir-opt/derefer_terminator_test.main.Derefer.panic-unwind.diff +++ b/tests/mir-opt/derefer_terminator_test.main.Derefer.panic-unwind.diff @@ -52,7 +52,7 @@ _5 = &_6; _4 = &_5; - PlaceMention((*(*(*(*_4))))); -- switchInt((*(*(*(*_4))))) -> [0: bb3, otherwise: bb4]; +- switchInt(copy (*(*(*(*_4))))) -> [0: bb3, otherwise: bb4]; + _10 = deref_copy (*_4); + _11 = deref_copy (*_10); + _12 = deref_copy (*_11); @@ -60,7 +60,7 @@ + _13 = deref_copy (*_4); + _14 = deref_copy (*_13); + _15 = deref_copy (*_14); -+ switchInt((*_15)) -> [0: bb3, otherwise: bb4]; ++ switchInt(copy (*_15)) -> [0: bb3, otherwise: bb4]; } bb3: { diff --git a/tests/mir-opt/dest-prop/branch.foo.DestinationPropagation.panic-abort.diff b/tests/mir-opt/dest-prop/branch.foo.DestinationPropagation.panic-abort.diff index 10ec3aa555ee..775d51ea49f3 100644 --- a/tests/mir-opt/dest-prop/branch.foo.DestinationPropagation.panic-abort.diff +++ b/tests/mir-opt/dest-prop/branch.foo.DestinationPropagation.panic-abort.diff @@ -35,7 +35,7 @@ } bb3: { -- _2 = _1; +- _2 = copy _1; + nop; goto -> bb6; } @@ -47,14 +47,14 @@ bb5: { StorageDead(_4); -- _2 = _1; +- _2 = copy _1; + nop; goto -> bb6; } bb6: { StorageDead(_3); -- _0 = _2; +- _0 = copy _2; - StorageDead(_2); - StorageDead(_1); + nop; diff --git a/tests/mir-opt/dest-prop/branch.foo.DestinationPropagation.panic-unwind.diff b/tests/mir-opt/dest-prop/branch.foo.DestinationPropagation.panic-unwind.diff index 759c1cabf45e..875ef8829d08 100644 --- a/tests/mir-opt/dest-prop/branch.foo.DestinationPropagation.panic-unwind.diff +++ b/tests/mir-opt/dest-prop/branch.foo.DestinationPropagation.panic-unwind.diff @@ -35,7 +35,7 @@ } bb3: { -- _2 = _1; +- _2 = copy _1; + nop; goto -> bb6; } @@ -47,14 +47,14 @@ bb5: { StorageDead(_4); -- _2 = _1; +- _2 = copy _1; + nop; goto -> bb6; } bb6: { StorageDead(_3); -- _0 = _2; +- _0 = copy _2; - StorageDead(_2); - StorageDead(_1); + nop; diff --git a/tests/mir-opt/dest-prop/copy_propagation_arg.arg_src.DestinationPropagation.panic-abort.diff b/tests/mir-opt/dest-prop/copy_propagation_arg.arg_src.DestinationPropagation.panic-abort.diff index 1aed07f9e6ab..a4908c05e2e1 100644 --- a/tests/mir-opt/dest-prop/copy_propagation_arg.arg_src.DestinationPropagation.panic-abort.diff +++ b/tests/mir-opt/dest-prop/copy_propagation_arg.arg_src.DestinationPropagation.panic-abort.diff @@ -12,11 +12,11 @@ bb0: { - StorageLive(_2); -- _2 = _1; +- _2 = copy _1; + nop; -+ _0 = _1; ++ _0 = copy _1; _1 = const 123_i32; -- _0 = _2; +- _0 = copy _2; - StorageDead(_2); + nop; + nop; diff --git a/tests/mir-opt/dest-prop/copy_propagation_arg.arg_src.DestinationPropagation.panic-unwind.diff b/tests/mir-opt/dest-prop/copy_propagation_arg.arg_src.DestinationPropagation.panic-unwind.diff index 1aed07f9e6ab..a4908c05e2e1 100644 --- a/tests/mir-opt/dest-prop/copy_propagation_arg.arg_src.DestinationPropagation.panic-unwind.diff +++ b/tests/mir-opt/dest-prop/copy_propagation_arg.arg_src.DestinationPropagation.panic-unwind.diff @@ -12,11 +12,11 @@ bb0: { - StorageLive(_2); -- _2 = _1; +- _2 = copy _1; + nop; -+ _0 = _1; ++ _0 = copy _1; _1 = const 123_i32; -- _0 = _2; +- _0 = copy _2; - StorageDead(_2); + nop; + nop; diff --git a/tests/mir-opt/dest-prop/copy_propagation_arg.bar.DestinationPropagation.panic-abort.diff b/tests/mir-opt/dest-prop/copy_propagation_arg.bar.DestinationPropagation.panic-abort.diff index 641dea594e11..24f2b464e2cb 100644 --- a/tests/mir-opt/dest-prop/copy_propagation_arg.bar.DestinationPropagation.panic-abort.diff +++ b/tests/mir-opt/dest-prop/copy_propagation_arg.bar.DestinationPropagation.panic-abort.diff @@ -10,7 +10,7 @@ bb0: { StorageLive(_2); - StorageLive(_3); -- _3 = _1; +- _3 = copy _1; - _2 = dummy(move _3) -> [return: bb1, unwind unreachable]; + nop; + nop; diff --git a/tests/mir-opt/dest-prop/copy_propagation_arg.bar.DestinationPropagation.panic-unwind.diff b/tests/mir-opt/dest-prop/copy_propagation_arg.bar.DestinationPropagation.panic-unwind.diff index 8b2835c8ced2..d42ac52b6319 100644 --- a/tests/mir-opt/dest-prop/copy_propagation_arg.bar.DestinationPropagation.panic-unwind.diff +++ b/tests/mir-opt/dest-prop/copy_propagation_arg.bar.DestinationPropagation.panic-unwind.diff @@ -10,7 +10,7 @@ bb0: { StorageLive(_2); - StorageLive(_3); -- _3 = _1; +- _3 = copy _1; - _2 = dummy(move _3) -> [return: bb1, unwind continue]; + nop; + nop; diff --git a/tests/mir-opt/dest-prop/copy_propagation_arg.baz.DestinationPropagation.panic-abort.diff b/tests/mir-opt/dest-prop/copy_propagation_arg.baz.DestinationPropagation.panic-abort.diff index 4cddaec01d2d..f1f1714b472e 100644 --- a/tests/mir-opt/dest-prop/copy_propagation_arg.baz.DestinationPropagation.panic-abort.diff +++ b/tests/mir-opt/dest-prop/copy_propagation_arg.baz.DestinationPropagation.panic-abort.diff @@ -8,14 +8,14 @@ bb0: { - StorageLive(_2); -- _2 = _1; +- _2 = copy _1; - _1 = move _2; - StorageDead(_2); + nop; + nop; + nop; + nop; - _0 = _1; + _0 = copy _1; return; } } diff --git a/tests/mir-opt/dest-prop/copy_propagation_arg.baz.DestinationPropagation.panic-unwind.diff b/tests/mir-opt/dest-prop/copy_propagation_arg.baz.DestinationPropagation.panic-unwind.diff index 4cddaec01d2d..f1f1714b472e 100644 --- a/tests/mir-opt/dest-prop/copy_propagation_arg.baz.DestinationPropagation.panic-unwind.diff +++ b/tests/mir-opt/dest-prop/copy_propagation_arg.baz.DestinationPropagation.panic-unwind.diff @@ -8,14 +8,14 @@ bb0: { - StorageLive(_2); -- _2 = _1; +- _2 = copy _1; - _1 = move _2; - StorageDead(_2); + nop; + nop; + nop; + nop; - _0 = _1; + _0 = copy _1; return; } } diff --git a/tests/mir-opt/dest-prop/copy_propagation_arg.foo.DestinationPropagation.panic-abort.diff b/tests/mir-opt/dest-prop/copy_propagation_arg.foo.DestinationPropagation.panic-abort.diff index b461869be318..0328fc6b745b 100644 --- a/tests/mir-opt/dest-prop/copy_propagation_arg.foo.DestinationPropagation.panic-abort.diff +++ b/tests/mir-opt/dest-prop/copy_propagation_arg.foo.DestinationPropagation.panic-abort.diff @@ -10,7 +10,7 @@ bb0: { StorageLive(_2); - StorageLive(_3); -- _3 = _1; +- _3 = copy _1; - _2 = dummy(move _3) -> [return: bb1, unwind unreachable]; + nop; + nop; diff --git a/tests/mir-opt/dest-prop/copy_propagation_arg.foo.DestinationPropagation.panic-unwind.diff b/tests/mir-opt/dest-prop/copy_propagation_arg.foo.DestinationPropagation.panic-unwind.diff index d5c2e07c6c23..30e2248db820 100644 --- a/tests/mir-opt/dest-prop/copy_propagation_arg.foo.DestinationPropagation.panic-unwind.diff +++ b/tests/mir-opt/dest-prop/copy_propagation_arg.foo.DestinationPropagation.panic-unwind.diff @@ -10,7 +10,7 @@ bb0: { StorageLive(_2); - StorageLive(_3); -- _3 = _1; +- _3 = copy _1; - _2 = dummy(move _3) -> [return: bb1, unwind continue]; + nop; + nop; diff --git a/tests/mir-opt/dest-prop/cycle.main.DestinationPropagation.panic-abort.diff b/tests/mir-opt/dest-prop/cycle.main.DestinationPropagation.panic-abort.diff index 98b4ee866d2b..5d8aaedae374 100644 --- a/tests/mir-opt/dest-prop/cycle.main.DestinationPropagation.panic-abort.diff +++ b/tests/mir-opt/dest-prop/cycle.main.DestinationPropagation.panic-abort.diff @@ -31,11 +31,11 @@ bb1: { - StorageLive(_2); -- _2 = _1; +- _2 = copy _1; - StorageLive(_3); -- _3 = _2; +- _3 = copy _2; - StorageLive(_4); -- _4 = _3; +- _4 = copy _3; - _1 = move _4; - StorageDead(_4); + nop; @@ -48,7 +48,7 @@ + nop; StorageLive(_5); - StorageLive(_6); -- _6 = _1; +- _6 = copy _1; + nop; + nop; _5 = std::mem::drop::(move _6) -> [return: bb2, unwind unreachable]; diff --git a/tests/mir-opt/dest-prop/cycle.main.DestinationPropagation.panic-unwind.diff b/tests/mir-opt/dest-prop/cycle.main.DestinationPropagation.panic-unwind.diff index 6f6e01d37b1a..05c9bcc1d737 100644 --- a/tests/mir-opt/dest-prop/cycle.main.DestinationPropagation.panic-unwind.diff +++ b/tests/mir-opt/dest-prop/cycle.main.DestinationPropagation.panic-unwind.diff @@ -31,11 +31,11 @@ bb1: { - StorageLive(_2); -- _2 = _1; +- _2 = copy _1; - StorageLive(_3); -- _3 = _2; +- _3 = copy _2; - StorageLive(_4); -- _4 = _3; +- _4 = copy _3; - _1 = move _4; - StorageDead(_4); + nop; @@ -48,7 +48,7 @@ + nop; StorageLive(_5); - StorageLive(_6); -- _6 = _1; +- _6 = copy _1; + nop; + nop; _5 = std::mem::drop::(move _6) -> [return: bb2, unwind continue]; diff --git a/tests/mir-opt/dest-prop/dead_stores_79191.f.DestinationPropagation.after.panic-abort.mir b/tests/mir-opt/dest-prop/dead_stores_79191.f.DestinationPropagation.after.panic-abort.mir index eb160fc194a8..eb4209731c62 100644 --- a/tests/mir-opt/dest-prop/dead_stores_79191.f.DestinationPropagation.after.panic-abort.mir +++ b/tests/mir-opt/dest-prop/dead_stores_79191.f.DestinationPropagation.after.panic-abort.mir @@ -12,7 +12,7 @@ fn f(_1: usize) -> usize { bb0: { nop; - _3 = _1; + _3 = copy _1; _1 = const 5_usize; nop; nop; diff --git a/tests/mir-opt/dest-prop/dead_stores_79191.f.DestinationPropagation.after.panic-unwind.mir b/tests/mir-opt/dest-prop/dead_stores_79191.f.DestinationPropagation.after.panic-unwind.mir index 9147de2ec473..fe9a7376a585 100644 --- a/tests/mir-opt/dest-prop/dead_stores_79191.f.DestinationPropagation.after.panic-unwind.mir +++ b/tests/mir-opt/dest-prop/dead_stores_79191.f.DestinationPropagation.after.panic-unwind.mir @@ -12,7 +12,7 @@ fn f(_1: usize) -> usize { bb0: { nop; - _3 = _1; + _3 = copy _1; _1 = const 5_usize; nop; nop; diff --git a/tests/mir-opt/dest-prop/dead_stores_better.f.DestinationPropagation.after.panic-abort.mir b/tests/mir-opt/dest-prop/dead_stores_better.f.DestinationPropagation.after.panic-abort.mir index eb160fc194a8..eb4209731c62 100644 --- a/tests/mir-opt/dest-prop/dead_stores_better.f.DestinationPropagation.after.panic-abort.mir +++ b/tests/mir-opt/dest-prop/dead_stores_better.f.DestinationPropagation.after.panic-abort.mir @@ -12,7 +12,7 @@ fn f(_1: usize) -> usize { bb0: { nop; - _3 = _1; + _3 = copy _1; _1 = const 5_usize; nop; nop; diff --git a/tests/mir-opt/dest-prop/dead_stores_better.f.DestinationPropagation.after.panic-unwind.mir b/tests/mir-opt/dest-prop/dead_stores_better.f.DestinationPropagation.after.panic-unwind.mir index 9147de2ec473..fe9a7376a585 100644 --- a/tests/mir-opt/dest-prop/dead_stores_better.f.DestinationPropagation.after.panic-unwind.mir +++ b/tests/mir-opt/dest-prop/dead_stores_better.f.DestinationPropagation.after.panic-unwind.mir @@ -12,7 +12,7 @@ fn f(_1: usize) -> usize { bb0: { nop; - _3 = _1; + _3 = copy _1; _1 = const 5_usize; nop; nop; diff --git a/tests/mir-opt/dest-prop/simple.nrvo.DestinationPropagation.panic-abort.diff b/tests/mir-opt/dest-prop/simple.nrvo.DestinationPropagation.panic-abort.diff index 4d34f43fd5ce..e9fbcf20a722 100644 --- a/tests/mir-opt/dest-prop/simple.nrvo.DestinationPropagation.panic-abort.diff +++ b/tests/mir-opt/dest-prop/simple.nrvo.DestinationPropagation.panic-abort.diff @@ -18,7 +18,7 @@ _2 = [const 0_u8; 1024]; StorageLive(_3); - StorageLive(_4); -- _4 = _1; +- _4 = copy _1; + nop; + nop; StorageLive(_5); @@ -35,7 +35,7 @@ + nop; StorageDead(_6); StorageDead(_3); - _0 = _2; + _0 = copy _2; StorageDead(_2); return; } diff --git a/tests/mir-opt/dest-prop/simple.nrvo.DestinationPropagation.panic-unwind.diff b/tests/mir-opt/dest-prop/simple.nrvo.DestinationPropagation.panic-unwind.diff index 9c3cbef38d69..95d5fe1b9304 100644 --- a/tests/mir-opt/dest-prop/simple.nrvo.DestinationPropagation.panic-unwind.diff +++ b/tests/mir-opt/dest-prop/simple.nrvo.DestinationPropagation.panic-unwind.diff @@ -18,7 +18,7 @@ _2 = [const 0_u8; 1024]; StorageLive(_3); - StorageLive(_4); -- _4 = _1; +- _4 = copy _1; + nop; + nop; StorageLive(_5); @@ -35,7 +35,7 @@ + nop; StorageDead(_6); StorageDead(_3); - _0 = _2; + _0 = copy _2; StorageDead(_2); return; } diff --git a/tests/mir-opt/dest-prop/union.main.DestinationPropagation.panic-abort.diff b/tests/mir-opt/dest-prop/union.main.DestinationPropagation.panic-abort.diff index b596e25ddfdf..557320f01798 100644 --- a/tests/mir-opt/dest-prop/union.main.DestinationPropagation.panic-abort.diff +++ b/tests/mir-opt/dest-prop/union.main.DestinationPropagation.panic-abort.diff @@ -22,7 +22,7 @@ _1 = Un { us: const 1_u32 }; StorageDead(_2); StorageLive(_3); - _3 = (_1.0: u32); + _3 = copy (_1.0: u32); StorageDead(_3); StorageDead(_1); return; diff --git a/tests/mir-opt/dest-prop/union.main.DestinationPropagation.panic-unwind.diff b/tests/mir-opt/dest-prop/union.main.DestinationPropagation.panic-unwind.diff index b596e25ddfdf..557320f01798 100644 --- a/tests/mir-opt/dest-prop/union.main.DestinationPropagation.panic-unwind.diff +++ b/tests/mir-opt/dest-prop/union.main.DestinationPropagation.panic-unwind.diff @@ -22,7 +22,7 @@ _1 = Un { us: const 1_u32 }; StorageDead(_2); StorageLive(_3); - _3 = (_1.0: u32); + _3 = copy (_1.0: u32); StorageDead(_3); StorageDead(_1); return; diff --git a/tests/mir-opt/early_otherwise_branch.opt1.EarlyOtherwiseBranch.diff b/tests/mir-opt/early_otherwise_branch.opt1.EarlyOtherwiseBranch.diff index 4af3ed3e1d1b..51c41996678c 100644 --- a/tests/mir-opt/early_otherwise_branch.opt1.EarlyOtherwiseBranch.diff +++ b/tests/mir-opt/early_otherwise_branch.opt1.EarlyOtherwiseBranch.diff @@ -20,9 +20,9 @@ bb0: { StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; StorageLive(_5); - _5 = _2; + _5 = copy _2; _3 = (move _4, move _5); StorageDead(_5); StorageDead(_4); @@ -42,9 +42,9 @@ bb3: { StorageLive(_8); - _8 = (((_3.0: std::option::Option) as Some).0: u32); + _8 = copy (((_3.0: std::option::Option) as Some).0: u32); StorageLive(_9); - _9 = (((_3.1: std::option::Option) as Some).0: u32); + _9 = copy (((_3.1: std::option::Option) as Some).0: u32); _0 = const 0_u32; StorageDead(_9); StorageDead(_8); diff --git a/tests/mir-opt/early_otherwise_branch.opt2.EarlyOtherwiseBranch.diff b/tests/mir-opt/early_otherwise_branch.opt2.EarlyOtherwiseBranch.diff index 41ae2fd3af3f..f17ebee9416f 100644 --- a/tests/mir-opt/early_otherwise_branch.opt2.EarlyOtherwiseBranch.diff +++ b/tests/mir-opt/early_otherwise_branch.opt2.EarlyOtherwiseBranch.diff @@ -21,9 +21,9 @@ bb0: { StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; StorageLive(_5); - _5 = _2; + _5 = copy _2; _3 = (move _4, move _5); StorageDead(_5); StorageDead(_4); @@ -53,9 +53,9 @@ bb5: { StorageLive(_9); - _9 = (((_3.0: std::option::Option) as Some).0: u32); + _9 = copy (((_3.0: std::option::Option) as Some).0: u32); StorageLive(_10); - _10 = (((_3.1: std::option::Option) as Some).0: u32); + _10 = copy (((_3.1: std::option::Option) as Some).0: u32); _0 = const 0_u32; StorageDead(_10); StorageDead(_9); diff --git a/tests/mir-opt/early_otherwise_branch.opt3.EarlyOtherwiseBranch.diff b/tests/mir-opt/early_otherwise_branch.opt3.EarlyOtherwiseBranch.diff index 302fd0bfded4..7b94a4c2bf73 100644 --- a/tests/mir-opt/early_otherwise_branch.opt3.EarlyOtherwiseBranch.diff +++ b/tests/mir-opt/early_otherwise_branch.opt3.EarlyOtherwiseBranch.diff @@ -35,7 +35,7 @@ + StorageLive(_12); + _12 = discriminant((_3.1: Option2)); + StorageLive(_13); -+ _13 = Ne(_9, move _12); ++ _13 = Ne(copy _9, move _12); + StorageDead(_12); + switchInt(move _13) -> [0: bb7, otherwise: bb1]; } @@ -78,9 +78,9 @@ - bb7: { + bb4: { StorageLive(_10); - _10 = (((_3.0: Option2) as Some).0: u32); + _10 = copy (((_3.0: Option2) as Some).0: u32); StorageLive(_11); - _11 = (((_3.1: Option2) as Some).0: bool); + _11 = copy (((_3.1: Option2) as Some).0: bool); _0 = const 0_u32; StorageDead(_11); StorageDead(_10); @@ -101,7 +101,7 @@ + + bb7: { + StorageDead(_13); -+ switchInt(_9) -> [0: bb4, 1: bb3, 2: bb2, otherwise: bb6]; ++ switchInt(copy _9) -> [0: bb4, 1: bb3, 2: bb2, otherwise: bb6]; } } diff --git a/tests/mir-opt/early_otherwise_branch.opt4.EarlyOtherwiseBranch.diff b/tests/mir-opt/early_otherwise_branch.opt4.EarlyOtherwiseBranch.diff index eef4fb3278c1..f52795baef81 100644 --- a/tests/mir-opt/early_otherwise_branch.opt4.EarlyOtherwiseBranch.diff +++ b/tests/mir-opt/early_otherwise_branch.opt4.EarlyOtherwiseBranch.diff @@ -35,7 +35,7 @@ + StorageLive(_12); + _12 = discriminant((_3.1: Option2)); + StorageLive(_13); -+ _13 = Ne(_9, move _12); ++ _13 = Ne(copy _9, move _12); + StorageDead(_12); + switchInt(move _13) -> [0: bb7, otherwise: bb1]; } @@ -78,9 +78,9 @@ - bb7: { + bb4: { StorageLive(_10); - _10 = (((_3.0: Option2) as Some).0: u32); + _10 = copy (((_3.0: Option2) as Some).0: u32); StorageLive(_11); - _11 = (((_3.1: Option2) as Some).0: u32); + _11 = copy (((_3.1: Option2) as Some).0: u32); _0 = const 0_u32; StorageDead(_11); StorageDead(_10); @@ -101,7 +101,7 @@ + + bb7: { + StorageDead(_13); -+ switchInt(_9) -> [0: bb4, 1: bb3, 2: bb2, otherwise: bb6]; ++ switchInt(copy _9) -> [0: bb4, 1: bb3, 2: bb2, otherwise: bb6]; } } diff --git a/tests/mir-opt/early_otherwise_branch_3_element_tuple.opt1.EarlyOtherwiseBranch.diff b/tests/mir-opt/early_otherwise_branch_3_element_tuple.opt1.EarlyOtherwiseBranch.diff index cb03e2697ccd..98df9934af05 100644 --- a/tests/mir-opt/early_otherwise_branch_3_element_tuple.opt1.EarlyOtherwiseBranch.diff +++ b/tests/mir-opt/early_otherwise_branch_3_element_tuple.opt1.EarlyOtherwiseBranch.diff @@ -27,11 +27,11 @@ bb0: { StorageLive(_4); StorageLive(_5); - _5 = _1; + _5 = copy _1; StorageLive(_6); - _6 = _2; + _6 = copy _2; StorageLive(_7); - _7 = _3; + _7 = copy _3; _4 = (move _5, move _6, move _7); StorageDead(_7); StorageDead(_6); @@ -72,11 +72,11 @@ bb7: { StorageLive(_13); - _13 = (((_4.0: std::option::Option) as Some).0: u32); + _13 = copy (((_4.0: std::option::Option) as Some).0: u32); StorageLive(_14); - _14 = (((_4.1: std::option::Option) as Some).0: u32); + _14 = copy (((_4.1: std::option::Option) as Some).0: u32); StorageLive(_15); - _15 = (((_4.2: std::option::Option) as Some).0: u32); + _15 = copy (((_4.2: std::option::Option) as Some).0: u32); _0 = const 0_u32; StorageDead(_15); StorageDead(_14); diff --git a/tests/mir-opt/early_otherwise_branch_3_element_tuple.opt2.EarlyOtherwiseBranch.diff b/tests/mir-opt/early_otherwise_branch_3_element_tuple.opt2.EarlyOtherwiseBranch.diff index 5634df253a5d..831d8cbb4d60 100644 --- a/tests/mir-opt/early_otherwise_branch_3_element_tuple.opt2.EarlyOtherwiseBranch.diff +++ b/tests/mir-opt/early_otherwise_branch_3_element_tuple.opt2.EarlyOtherwiseBranch.diff @@ -45,7 +45,7 @@ + StorageLive(_18); + _18 = discriminant((_4.1: Option2)); + StorageLive(_19); -+ _19 = Ne(_14, move _18); ++ _19 = Ne(copy _14, move _18); + StorageDead(_18); + switchInt(move _19) -> [0: bb10, otherwise: bb1]; } @@ -109,11 +109,11 @@ - bb10: { + bb7: { StorageLive(_15); - _15 = (((_4.0: Option2) as Some).0: u32); + _15 = copy (((_4.0: Option2) as Some).0: u32); StorageLive(_16); - _16 = (((_4.1: Option2) as Some).0: u32); + _16 = copy (((_4.1: Option2) as Some).0: u32); StorageLive(_17); - _17 = (((_4.2: Option2) as Some).0: u32); + _17 = copy (((_4.2: Option2) as Some).0: u32); _0 = const 0_u32; StorageDead(_17); StorageDead(_16); @@ -135,7 +135,7 @@ + + bb10: { + StorageDead(_19); -+ switchInt(_14) -> [0: bb2, 1: bb3, 2: bb4, otherwise: bb9]; ++ switchInt(copy _14) -> [0: bb2, 1: bb3, 2: bb4, otherwise: bb9]; } } diff --git a/tests/mir-opt/early_otherwise_branch_68867.try_sum.EarlyOtherwiseBranch.diff b/tests/mir-opt/early_otherwise_branch_68867.try_sum.EarlyOtherwiseBranch.diff index 8179d9dd1150..fec318c1ab49 100644 --- a/tests/mir-opt/early_otherwise_branch_68867.try_sum.EarlyOtherwiseBranch.diff +++ b/tests/mir-opt/early_otherwise_branch_68867.try_sum.EarlyOtherwiseBranch.diff @@ -70,9 +70,9 @@ StorageLive(_3); StorageLive(_4); StorageLive(_5); - _5 = _1; + _5 = copy _1; StorageLive(_6); - _6 = _2; + _6 = copy _2; _4 = (move _5, move _6); StorageDead(_6); StorageDead(_5); @@ -118,15 +118,15 @@ bb6: { StorageLive(_27); _39 = deref_copy (_4.0: &ViewportPercentageLength); - _27 = (((*_39) as Vmax).0: f32); + _27 = copy (((*_39) as Vmax).0: f32); StorageLive(_28); _40 = deref_copy (_4.1: &ViewportPercentageLength); - _28 = (((*_40) as Vmax).0: f32); + _28 = copy (((*_40) as Vmax).0: f32); StorageLive(_29); StorageLive(_30); - _30 = _27; + _30 = copy _27; StorageLive(_31); - _31 = _28; + _31 = copy _28; _29 = Add(move _30, move _31); StorageDead(_31); StorageDead(_30); @@ -140,15 +140,15 @@ bb7: { StorageLive(_22); _41 = deref_copy (_4.0: &ViewportPercentageLength); - _22 = (((*_41) as Vmin).0: f32); + _22 = copy (((*_41) as Vmin).0: f32); StorageLive(_23); _42 = deref_copy (_4.1: &ViewportPercentageLength); - _23 = (((*_42) as Vmin).0: f32); + _23 = copy (((*_42) as Vmin).0: f32); StorageLive(_24); StorageLive(_25); - _25 = _22; + _25 = copy _22; StorageLive(_26); - _26 = _23; + _26 = copy _23; _24 = Add(move _25, move _26); StorageDead(_26); StorageDead(_25); @@ -162,15 +162,15 @@ bb8: { StorageLive(_17); _43 = deref_copy (_4.0: &ViewportPercentageLength); - _17 = (((*_43) as Vh).0: f32); + _17 = copy (((*_43) as Vh).0: f32); StorageLive(_18); _44 = deref_copy (_4.1: &ViewportPercentageLength); - _18 = (((*_44) as Vh).0: f32); + _18 = copy (((*_44) as Vh).0: f32); StorageLive(_19); StorageLive(_20); - _20 = _17; + _20 = copy _17; StorageLive(_21); - _21 = _18; + _21 = copy _18; _19 = Add(move _20, move _21); StorageDead(_21); StorageDead(_20); @@ -184,15 +184,15 @@ bb9: { StorageLive(_12); _45 = deref_copy (_4.0: &ViewportPercentageLength); - _12 = (((*_45) as Vw).0: f32); + _12 = copy (((*_45) as Vw).0: f32); StorageLive(_13); _46 = deref_copy (_4.1: &ViewportPercentageLength); - _13 = (((*_46) as Vw).0: f32); + _13 = copy (((*_46) as Vw).0: f32); StorageLive(_14); StorageLive(_15); - _15 = _12; + _15 = copy _12; StorageLive(_16); - _16 = _13; + _16 = copy _13; _14 = Add(move _15, move _16); StorageDead(_16); StorageDead(_15); diff --git a/tests/mir-opt/early_otherwise_branch_noopt.noopt1.EarlyOtherwiseBranch.diff b/tests/mir-opt/early_otherwise_branch_noopt.noopt1.EarlyOtherwiseBranch.diff index 651b1de4ddd3..8ed2274a72be 100644 --- a/tests/mir-opt/early_otherwise_branch_noopt.noopt1.EarlyOtherwiseBranch.diff +++ b/tests/mir-opt/early_otherwise_branch_noopt.noopt1.EarlyOtherwiseBranch.diff @@ -29,9 +29,9 @@ bb0: { StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; StorageLive(_5); - _5 = _2; + _5 = copy _2; _3 = (move _4, move _5); StorageDead(_5); StorageDead(_4); @@ -60,7 +60,7 @@ bb5: { StorageLive(_12); - _12 = (((_3.1: std::option::Option) as Some).0: u32); + _12 = copy (((_3.1: std::option::Option) as Some).0: u32); _0 = const 2_u32; StorageDead(_12); goto -> bb8; @@ -68,7 +68,7 @@ bb6: { StorageLive(_11); - _11 = (((_3.0: std::option::Option) as Some).0: u32); + _11 = copy (((_3.0: std::option::Option) as Some).0: u32); _0 = const 1_u32; StorageDead(_11); goto -> bb8; @@ -76,9 +76,9 @@ bb7: { StorageLive(_9); - _9 = (((_3.0: std::option::Option) as Some).0: u32); + _9 = copy (((_3.0: std::option::Option) as Some).0: u32); StorageLive(_10); - _10 = (((_3.1: std::option::Option) as Some).0: u32); + _10 = copy (((_3.1: std::option::Option) as Some).0: u32); _0 = const 0_u32; StorageDead(_10); StorageDead(_9); diff --git a/tests/mir-opt/early_otherwise_branch_soundness.no_deref_ptr.EarlyOtherwiseBranch.diff b/tests/mir-opt/early_otherwise_branch_soundness.no_deref_ptr.EarlyOtherwiseBranch.diff index 8eab59823f4b..eeb8b766b5d1 100644 --- a/tests/mir-opt/early_otherwise_branch_soundness.no_deref_ptr.EarlyOtherwiseBranch.diff +++ b/tests/mir-opt/early_otherwise_branch_soundness.no_deref_ptr.EarlyOtherwiseBranch.diff @@ -34,8 +34,8 @@ bb4: { StorageLive(_5); - _5 = (((*_2) as Some).0: i32); - _0 = _5; + _5 = copy (((*_2) as Some).0: i32); + _0 = copy _5; StorageDead(_5); goto -> bb5; } diff --git a/tests/mir-opt/enum_opt.cand.EnumSizeOpt.32bit.diff b/tests/mir-opt/enum_opt.cand.EnumSizeOpt.32bit.diff index 085c55caaa03..727efe4b0d95 100644 --- a/tests/mir-opt/enum_opt.cand.EnumSizeOpt.32bit.diff +++ b/tests/mir-opt/enum_opt.cand.EnumSizeOpt.32bit.diff @@ -38,28 +38,28 @@ + StorageLive(_4); + _4 = const [2_usize, 8197_usize]; + _5 = discriminant(_2); -+ _6 = _5 as usize (IntToInt); -+ _7 = _4[_6]; ++ _6 = copy _5 as usize (IntToInt); ++ _7 = copy _4[_6]; + _8 = &raw mut _1; -+ _9 = _8 as *mut u8 (PtrToPtr); ++ _9 = copy _8 as *mut u8 (PtrToPtr); + _10 = &raw const _2; -+ _11 = _10 as *const u8 (PtrToPtr); ++ _11 = copy _10 as *const u8 (PtrToPtr); + Deinit(_8); -+ copy_nonoverlapping(dst = _9, src = _11, count = _7); ++ copy_nonoverlapping(dst = copy _9, src = copy _11, count = copy _7); + StorageDead(_4); StorageDead(_2); - _0 = move _1; + StorageLive(_12); + _12 = const [2_usize, 8197_usize]; + _13 = discriminant(_1); -+ _14 = _13 as usize (IntToInt); -+ _15 = _12[_14]; ++ _14 = copy _13 as usize (IntToInt); ++ _15 = copy _12[_14]; + _16 = &raw mut _0; -+ _17 = _16 as *mut u8 (PtrToPtr); ++ _17 = copy _16 as *mut u8 (PtrToPtr); + _18 = &raw const _1; -+ _19 = _18 as *const u8 (PtrToPtr); ++ _19 = copy _18 as *const u8 (PtrToPtr); + Deinit(_16); -+ copy_nonoverlapping(dst = _17, src = _19, count = _15); ++ copy_nonoverlapping(dst = copy _17, src = copy _19, count = copy _15); + StorageDead(_12); StorageDead(_1); return; diff --git a/tests/mir-opt/enum_opt.cand.EnumSizeOpt.64bit.diff b/tests/mir-opt/enum_opt.cand.EnumSizeOpt.64bit.diff index 798b7c10fe8d..8d0cd97f7866 100644 --- a/tests/mir-opt/enum_opt.cand.EnumSizeOpt.64bit.diff +++ b/tests/mir-opt/enum_opt.cand.EnumSizeOpt.64bit.diff @@ -38,28 +38,28 @@ + StorageLive(_4); + _4 = const [2_usize, 8197_usize]; + _5 = discriminant(_2); -+ _6 = _5 as usize (IntToInt); -+ _7 = _4[_6]; ++ _6 = copy _5 as usize (IntToInt); ++ _7 = copy _4[_6]; + _8 = &raw mut _1; -+ _9 = _8 as *mut u8 (PtrToPtr); ++ _9 = copy _8 as *mut u8 (PtrToPtr); + _10 = &raw const _2; -+ _11 = _10 as *const u8 (PtrToPtr); ++ _11 = copy _10 as *const u8 (PtrToPtr); + Deinit(_8); -+ copy_nonoverlapping(dst = _9, src = _11, count = _7); ++ copy_nonoverlapping(dst = copy _9, src = copy _11, count = copy _7); + StorageDead(_4); StorageDead(_2); - _0 = move _1; + StorageLive(_12); + _12 = const [2_usize, 8197_usize]; + _13 = discriminant(_1); -+ _14 = _13 as usize (IntToInt); -+ _15 = _12[_14]; ++ _14 = copy _13 as usize (IntToInt); ++ _15 = copy _12[_14]; + _16 = &raw mut _0; -+ _17 = _16 as *mut u8 (PtrToPtr); ++ _17 = copy _16 as *mut u8 (PtrToPtr); + _18 = &raw const _1; -+ _19 = _18 as *const u8 (PtrToPtr); ++ _19 = copy _18 as *const u8 (PtrToPtr); + Deinit(_16); -+ copy_nonoverlapping(dst = _17, src = _19, count = _15); ++ copy_nonoverlapping(dst = copy _17, src = copy _19, count = copy _15); + StorageDead(_12); StorageDead(_1); return; diff --git a/tests/mir-opt/enum_opt.unin.EnumSizeOpt.32bit.diff b/tests/mir-opt/enum_opt.unin.EnumSizeOpt.32bit.diff index a04829af4b53..6d1e2a72fdb7 100644 --- a/tests/mir-opt/enum_opt.unin.EnumSizeOpt.32bit.diff +++ b/tests/mir-opt/enum_opt.unin.EnumSizeOpt.32bit.diff @@ -38,28 +38,28 @@ + StorageLive(_4); + _4 = const [8197_usize, 1_usize]; + _5 = discriminant(_2); -+ _6 = _5 as usize (IntToInt); -+ _7 = _4[_6]; ++ _6 = copy _5 as usize (IntToInt); ++ _7 = copy _4[_6]; + _8 = &raw mut _1; -+ _9 = _8 as *mut u8 (PtrToPtr); ++ _9 = copy _8 as *mut u8 (PtrToPtr); + _10 = &raw const _2; -+ _11 = _10 as *const u8 (PtrToPtr); ++ _11 = copy _10 as *const u8 (PtrToPtr); + Deinit(_8); -+ copy_nonoverlapping(dst = _9, src = _11, count = _7); ++ copy_nonoverlapping(dst = copy _9, src = copy _11, count = copy _7); + StorageDead(_4); StorageDead(_2); - _0 = move _1; + StorageLive(_12); + _12 = const [8197_usize, 1_usize]; + _13 = discriminant(_1); -+ _14 = _13 as usize (IntToInt); -+ _15 = _12[_14]; ++ _14 = copy _13 as usize (IntToInt); ++ _15 = copy _12[_14]; + _16 = &raw mut _0; -+ _17 = _16 as *mut u8 (PtrToPtr); ++ _17 = copy _16 as *mut u8 (PtrToPtr); + _18 = &raw const _1; -+ _19 = _18 as *const u8 (PtrToPtr); ++ _19 = copy _18 as *const u8 (PtrToPtr); + Deinit(_16); -+ copy_nonoverlapping(dst = _17, src = _19, count = _15); ++ copy_nonoverlapping(dst = copy _17, src = copy _19, count = copy _15); + StorageDead(_12); StorageDead(_1); return; diff --git a/tests/mir-opt/enum_opt.unin.EnumSizeOpt.64bit.diff b/tests/mir-opt/enum_opt.unin.EnumSizeOpt.64bit.diff index f5521a1e22a4..4b1406d0d623 100644 --- a/tests/mir-opt/enum_opt.unin.EnumSizeOpt.64bit.diff +++ b/tests/mir-opt/enum_opt.unin.EnumSizeOpt.64bit.diff @@ -38,28 +38,28 @@ + StorageLive(_4); + _4 = const [8197_usize, 1_usize]; + _5 = discriminant(_2); -+ _6 = _5 as usize (IntToInt); -+ _7 = _4[_6]; ++ _6 = copy _5 as usize (IntToInt); ++ _7 = copy _4[_6]; + _8 = &raw mut _1; -+ _9 = _8 as *mut u8 (PtrToPtr); ++ _9 = copy _8 as *mut u8 (PtrToPtr); + _10 = &raw const _2; -+ _11 = _10 as *const u8 (PtrToPtr); ++ _11 = copy _10 as *const u8 (PtrToPtr); + Deinit(_8); -+ copy_nonoverlapping(dst = _9, src = _11, count = _7); ++ copy_nonoverlapping(dst = copy _9, src = copy _11, count = copy _7); + StorageDead(_4); StorageDead(_2); - _0 = move _1; + StorageLive(_12); + _12 = const [8197_usize, 1_usize]; + _13 = discriminant(_1); -+ _14 = _13 as usize (IntToInt); -+ _15 = _12[_14]; ++ _14 = copy _13 as usize (IntToInt); ++ _15 = copy _12[_14]; + _16 = &raw mut _0; -+ _17 = _16 as *mut u8 (PtrToPtr); ++ _17 = copy _16 as *mut u8 (PtrToPtr); + _18 = &raw const _1; -+ _19 = _18 as *const u8 (PtrToPtr); ++ _19 = copy _18 as *const u8 (PtrToPtr); + Deinit(_16); -+ copy_nonoverlapping(dst = _17, src = _19, count = _15); ++ copy_nonoverlapping(dst = copy _17, src = copy _19, count = copy _15); + StorageDead(_12); StorageDead(_1); return; diff --git a/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.panic-abort.diff b/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.panic-abort.diff index 8a701641ff9a..ed72ca726295 100644 --- a/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.panic-abort.diff +++ b/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.panic-abort.diff @@ -42,13 +42,13 @@ StorageLive(_4); StorageLive(_20); StorageLive(_21); - _21 = ((*_1).0: u32); + _21 = copy ((*_1).0: u32); _20 = BitAnd(move _21, const 1_u32); StorageDead(_21); _4 = Ne(move _20, const 0_u32); StorageDead(_20); StorageLive(_5); - switchInt(_4) -> [0: bb2, otherwise: bb1]; + switchInt(copy _4) -> [0: bb2, otherwise: bb1]; } bb1: { @@ -65,7 +65,7 @@ bb3: { StorageLive(_6); - _6 = ((*_1).4: std::option::Option); + _6 = copy ((*_1).4: std::option::Option); _7 = discriminant(_6); switchInt(move _7) -> [1: bb4, 0: bb6, otherwise: bb9]; } @@ -73,26 +73,26 @@ bb4: { - StorageLive(_8); + nop; - _8 = ((_6 as Some).0: usize); + _8 = copy ((_6 as Some).0: usize); StorageLive(_9); - _9 = _1; + _9 = copy _1; StorageLive(_10); - _10 = _2; + _10 = copy _2; StorageLive(_11); - _11 = _5; + _11 = copy _5; StorageLive(_12); StorageLive(_13); StorageLive(_14); - _14 = _8; + _14 = copy _8; - _13 = move _14 as u32 (IntToInt); -+ _13 = _8 as u32 (IntToInt); ++ _13 = copy _8 as u32 (IntToInt); StorageDead(_14); _12 = Add(move _13, const 1_u32); StorageDead(_13); StorageLive(_15); - _15 = _3; + _15 = copy _3; - _0 = float_to_exponential_common_exact::(move _9, move _10, move _11, move _12, move _15) -> [return: bb5, unwind unreachable]; -+ _0 = float_to_exponential_common_exact::(_1, _2, move _11, move _12, _3) -> [return: bb5, unwind unreachable]; ++ _0 = float_to_exponential_common_exact::(copy _1, copy _2, move _11, move _12, copy _3) -> [return: bb5, unwind unreachable]; } bb5: { @@ -108,15 +108,15 @@ bb6: { StorageLive(_16); - _16 = _1; + _16 = copy _1; StorageLive(_17); - _17 = _2; + _17 = copy _2; StorageLive(_18); - _18 = _5; + _18 = copy _5; StorageLive(_19); - _19 = _3; + _19 = copy _3; - _0 = float_to_exponential_common_shortest::(move _16, move _17, move _18, move _19) -> [return: bb7, unwind unreachable]; -+ _0 = float_to_exponential_common_shortest::(_1, _2, move _18, _3) -> [return: bb7, unwind unreachable]; ++ _0 = float_to_exponential_common_shortest::(copy _1, copy _2, move _18, copy _3) -> [return: bb7, unwind unreachable]; } bb7: { diff --git a/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.panic-unwind.diff b/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.panic-unwind.diff index 5e65700ee4aa..42d998837495 100644 --- a/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.panic-unwind.diff +++ b/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.panic-unwind.diff @@ -42,13 +42,13 @@ StorageLive(_4); StorageLive(_20); StorageLive(_21); - _21 = ((*_1).0: u32); + _21 = copy ((*_1).0: u32); _20 = BitAnd(move _21, const 1_u32); StorageDead(_21); _4 = Ne(move _20, const 0_u32); StorageDead(_20); StorageLive(_5); - switchInt(_4) -> [0: bb2, otherwise: bb1]; + switchInt(copy _4) -> [0: bb2, otherwise: bb1]; } bb1: { @@ -65,7 +65,7 @@ bb3: { StorageLive(_6); - _6 = ((*_1).4: std::option::Option); + _6 = copy ((*_1).4: std::option::Option); _7 = discriminant(_6); switchInt(move _7) -> [1: bb4, 0: bb6, otherwise: bb9]; } @@ -73,26 +73,26 @@ bb4: { - StorageLive(_8); + nop; - _8 = ((_6 as Some).0: usize); + _8 = copy ((_6 as Some).0: usize); StorageLive(_9); - _9 = _1; + _9 = copy _1; StorageLive(_10); - _10 = _2; + _10 = copy _2; StorageLive(_11); - _11 = _5; + _11 = copy _5; StorageLive(_12); StorageLive(_13); StorageLive(_14); - _14 = _8; + _14 = copy _8; - _13 = move _14 as u32 (IntToInt); -+ _13 = _8 as u32 (IntToInt); ++ _13 = copy _8 as u32 (IntToInt); StorageDead(_14); _12 = Add(move _13, const 1_u32); StorageDead(_13); StorageLive(_15); - _15 = _3; + _15 = copy _3; - _0 = float_to_exponential_common_exact::(move _9, move _10, move _11, move _12, move _15) -> [return: bb5, unwind continue]; -+ _0 = float_to_exponential_common_exact::(_1, _2, move _11, move _12, _3) -> [return: bb5, unwind continue]; ++ _0 = float_to_exponential_common_exact::(copy _1, copy _2, move _11, move _12, copy _3) -> [return: bb5, unwind continue]; } bb5: { @@ -108,15 +108,15 @@ bb6: { StorageLive(_16); - _16 = _1; + _16 = copy _1; StorageLive(_17); - _17 = _2; + _17 = copy _2; StorageLive(_18); - _18 = _5; + _18 = copy _5; StorageLive(_19); - _19 = _3; + _19 = copy _3; - _0 = float_to_exponential_common_shortest::(move _16, move _17, move _18, move _19) -> [return: bb7, unwind continue]; -+ _0 = float_to_exponential_common_shortest::(_1, _2, move _18, _3) -> [return: bb7, unwind continue]; ++ _0 = float_to_exponential_common_shortest::(copy _1, copy _2, move _18, copy _3) -> [return: bb7, unwind continue]; } bb7: { diff --git a/tests/mir-opt/gvn.arithmetic.GVN.panic-abort.diff b/tests/mir-opt/gvn.arithmetic.GVN.panic-abort.diff index cb87d9020150..f980645b1d09 100644 --- a/tests/mir-opt/gvn.arithmetic.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.arithmetic.GVN.panic-abort.diff @@ -82,12 +82,12 @@ StorageLive(_2); StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; - _3 = Add(move _4, const 0_u64); -+ _3 = _1; ++ _3 = copy _1; StorageDead(_4); - _2 = opaque::(move _3) -> [return: bb1, unwind unreachable]; -+ _2 = opaque::(_1) -> [return: bb1, unwind unreachable]; ++ _2 = opaque::(copy _1) -> [return: bb1, unwind unreachable]; } bb1: { @@ -96,12 +96,12 @@ StorageLive(_5); StorageLive(_6); StorageLive(_7); - _7 = _1; + _7 = copy _1; - _6 = Sub(move _7, const 0_u64); -+ _6 = _1; ++ _6 = copy _1; StorageDead(_7); - _5 = opaque::(move _6) -> [return: bb2, unwind unreachable]; -+ _5 = opaque::(_1) -> [return: bb2, unwind unreachable]; ++ _5 = opaque::(copy _1) -> [return: bb2, unwind unreachable]; } bb2: { @@ -111,9 +111,9 @@ - StorageLive(_9); + nop; StorageLive(_10); - _10 = _1; + _10 = copy _1; StorageLive(_11); - _11 = _1; + _11 = copy _1; - _9 = Sub(move _10, move _11); + _9 = const 0_u64; StorageDead(_11); @@ -129,7 +129,7 @@ StorageLive(_12); StorageLive(_13); StorageLive(_14); - _14 = _1; + _14 = copy _1; - _13 = Mul(move _14, const 0_u64); + _13 = const 0_u64; StorageDead(_14); @@ -143,12 +143,12 @@ StorageLive(_15); StorageLive(_16); StorageLive(_17); - _17 = _1; + _17 = copy _1; - _16 = Mul(move _17, const 1_u64); -+ _16 = _1; ++ _16 = copy _1; StorageDead(_17); - _15 = opaque::(move _16) -> [return: bb5, unwind unreachable]; -+ _15 = opaque::(_1) -> [return: bb5, unwind unreachable]; ++ _15 = opaque::(copy _1) -> [return: bb5, unwind unreachable]; } bb5: { @@ -157,16 +157,16 @@ StorageLive(_18); StorageLive(_19); StorageLive(_20); - _20 = _1; + _20 = copy _1; - _21 = Eq(const 0_u64, const 0_u64); -- assert(!move _21, "attempt to divide `{}` by zero", _20) -> [success: bb6, unwind unreachable]; +- assert(!move _21, "attempt to divide `{}` by zero", copy _20) -> [success: bb6, unwind unreachable]; + _21 = const true; -+ assert(!const true, "attempt to divide `{}` by zero", _1) -> [success: bb6, unwind unreachable]; ++ assert(!const true, "attempt to divide `{}` by zero", copy _1) -> [success: bb6, unwind unreachable]; } bb6: { - _19 = Div(move _20, const 0_u64); -+ _19 = Div(_1, const 0_u64); ++ _19 = Div(copy _1, const 0_u64); StorageDead(_20); _18 = opaque::(move _19) -> [return: bb7, unwind unreachable]; } @@ -177,19 +177,19 @@ StorageLive(_22); StorageLive(_23); StorageLive(_24); - _24 = _1; + _24 = copy _1; - _25 = Eq(const 1_u64, const 0_u64); -- assert(!move _25, "attempt to divide `{}` by zero", _24) -> [success: bb8, unwind unreachable]; +- assert(!move _25, "attempt to divide `{}` by zero", copy _24) -> [success: bb8, unwind unreachable]; + _25 = const false; -+ assert(!const false, "attempt to divide `{}` by zero", _1) -> [success: bb8, unwind unreachable]; ++ assert(!const false, "attempt to divide `{}` by zero", copy _1) -> [success: bb8, unwind unreachable]; } bb8: { - _23 = Div(move _24, const 1_u64); -+ _23 = _1; ++ _23 = copy _1; StorageDead(_24); - _22 = opaque::(move _23) -> [return: bb9, unwind unreachable]; -+ _22 = opaque::(_1) -> [return: bb9, unwind unreachable]; ++ _22 = opaque::(copy _1) -> [return: bb9, unwind unreachable]; } bb9: { @@ -198,11 +198,11 @@ StorageLive(_26); StorageLive(_27); StorageLive(_28); - _28 = _1; -- _29 = Eq(_28, const 0_u64); + _28 = copy _1; +- _29 = Eq(copy _28, const 0_u64); - assert(!move _29, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb10, unwind unreachable]; -+ _29 = Eq(_1, const 0_u64); -+ assert(!_29, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb10, unwind unreachable]; ++ _29 = Eq(copy _1, const 0_u64); ++ assert(!copy _29, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb10, unwind unreachable]; } bb10: { @@ -219,16 +219,16 @@ StorageLive(_30); StorageLive(_31); StorageLive(_32); - _32 = _1; -- _33 = Eq(_32, const 0_u64); + _32 = copy _1; +- _33 = Eq(copy _32, const 0_u64); - assert(!move _33, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb12, unwind unreachable]; -+ _33 = _29; -+ assert(!_29, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb12, unwind unreachable]; ++ _33 = copy _29; ++ assert(!copy _29, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb12, unwind unreachable]; } bb12: { - _31 = Div(const 1_u64, move _32); -+ _31 = Div(const 1_u64, _1); ++ _31 = Div(const 1_u64, copy _1); StorageDead(_32); _30 = opaque::(move _31) -> [return: bb13, unwind unreachable]; } @@ -239,16 +239,16 @@ StorageLive(_34); StorageLive(_35); StorageLive(_36); - _36 = _1; + _36 = copy _1; - _37 = Eq(const 0_u64, const 0_u64); -- assert(!move _37, "attempt to calculate the remainder of `{}` with a divisor of zero", _36) -> [success: bb14, unwind unreachable]; +- assert(!move _37, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _36) -> [success: bb14, unwind unreachable]; + _37 = const true; -+ assert(!const true, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb14, unwind unreachable]; ++ assert(!const true, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _1) -> [success: bb14, unwind unreachable]; } bb14: { - _35 = Rem(move _36, const 0_u64); -+ _35 = Rem(_1, const 0_u64); ++ _35 = Rem(copy _1, const 0_u64); StorageDead(_36); _34 = opaque::(move _35) -> [return: bb15, unwind unreachable]; } @@ -259,11 +259,11 @@ StorageLive(_38); StorageLive(_39); StorageLive(_40); - _40 = _1; + _40 = copy _1; - _41 = Eq(const 1_u64, const 0_u64); -- assert(!move _41, "attempt to calculate the remainder of `{}` with a divisor of zero", _40) -> [success: bb16, unwind unreachable]; +- assert(!move _41, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _40) -> [success: bb16, unwind unreachable]; + _41 = const false; -+ assert(!const false, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb16, unwind unreachable]; ++ assert(!const false, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _1) -> [success: bb16, unwind unreachable]; } bb16: { @@ -280,11 +280,11 @@ StorageLive(_42); StorageLive(_43); StorageLive(_44); - _44 = _1; -- _45 = Eq(_44, const 0_u64); + _44 = copy _1; +- _45 = Eq(copy _44, const 0_u64); - assert(!move _45, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb18, unwind unreachable]; -+ _45 = _29; -+ assert(!_29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb18, unwind unreachable]; ++ _45 = copy _29; ++ assert(!copy _29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb18, unwind unreachable]; } bb18: { @@ -301,16 +301,16 @@ StorageLive(_46); StorageLive(_47); StorageLive(_48); - _48 = _1; -- _49 = Eq(_48, const 0_u64); + _48 = copy _1; +- _49 = Eq(copy _48, const 0_u64); - assert(!move _49, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb20, unwind unreachable]; -+ _49 = _29; -+ assert(!_29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb20, unwind unreachable]; ++ _49 = copy _29; ++ assert(!copy _29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb20, unwind unreachable]; } bb20: { - _47 = Rem(const 1_u64, move _48); -+ _47 = Rem(const 1_u64, _1); ++ _47 = Rem(const 1_u64, copy _1); StorageDead(_48); _46 = opaque::(move _47) -> [return: bb21, unwind unreachable]; } @@ -321,7 +321,7 @@ StorageLive(_50); StorageLive(_51); StorageLive(_52); - _52 = _1; + _52 = copy _1; - _51 = BitAnd(move _52, const 0_u64); + _51 = const 0_u64; StorageDead(_52); @@ -335,12 +335,12 @@ StorageLive(_53); StorageLive(_54); StorageLive(_55); - _55 = _1; + _55 = copy _1; - _54 = BitAnd(move _55, const core::num::::MAX); -+ _54 = _1; ++ _54 = copy _1; StorageDead(_55); - _53 = opaque::(move _54) -> [return: bb23, unwind unreachable]; -+ _53 = opaque::(_1) -> [return: bb23, unwind unreachable]; ++ _53 = opaque::(copy _1) -> [return: bb23, unwind unreachable]; } bb23: { @@ -349,12 +349,12 @@ StorageLive(_56); StorageLive(_57); StorageLive(_58); - _58 = _1; + _58 = copy _1; - _57 = BitOr(move _58, const 0_u64); -+ _57 = _1; ++ _57 = copy _1; StorageDead(_58); - _56 = opaque::(move _57) -> [return: bb24, unwind unreachable]; -+ _56 = opaque::(_1) -> [return: bb24, unwind unreachable]; ++ _56 = opaque::(copy _1) -> [return: bb24, unwind unreachable]; } bb24: { @@ -363,7 +363,7 @@ StorageLive(_59); StorageLive(_60); StorageLive(_61); - _61 = _1; + _61 = copy _1; - _60 = BitOr(move _61, const core::num::::MAX); + _60 = const u64::MAX; StorageDead(_61); @@ -377,12 +377,12 @@ StorageLive(_62); StorageLive(_63); StorageLive(_64); - _64 = _1; + _64 = copy _1; - _63 = BitXor(move _64, const 0_u64); -+ _63 = _1; ++ _63 = copy _1; StorageDead(_64); - _62 = opaque::(move _63) -> [return: bb26, unwind unreachable]; -+ _62 = opaque::(_1) -> [return: bb26, unwind unreachable]; ++ _62 = opaque::(copy _1) -> [return: bb26, unwind unreachable]; } bb26: { @@ -391,9 +391,9 @@ StorageLive(_65); StorageLive(_66); StorageLive(_67); - _67 = _1; + _67 = copy _1; StorageLive(_68); - _68 = _1; + _68 = copy _1; - _66 = BitXor(move _67, move _68); + _66 = const 0_u64; StorageDead(_68); @@ -408,12 +408,12 @@ StorageLive(_69); StorageLive(_70); StorageLive(_71); - _71 = _1; + _71 = copy _1; - _70 = Shr(move _71, const 0_i32); -+ _70 = _1; ++ _70 = copy _1; StorageDead(_71); - _69 = opaque::(move _70) -> [return: bb28, unwind unreachable]; -+ _69 = opaque::(_1) -> [return: bb28, unwind unreachable]; ++ _69 = opaque::(copy _1) -> [return: bb28, unwind unreachable]; } bb28: { @@ -422,12 +422,12 @@ StorageLive(_72); StorageLive(_73); StorageLive(_74); - _74 = _1; + _74 = copy _1; - _73 = Shl(move _74, const 0_i32); -+ _73 = _1; ++ _73 = copy _1; StorageDead(_74); - _72 = opaque::(move _73) -> [return: bb29, unwind unreachable]; -+ _72 = opaque::(_1) -> [return: bb29, unwind unreachable]; ++ _72 = opaque::(copy _1) -> [return: bb29, unwind unreachable]; } bb29: { diff --git a/tests/mir-opt/gvn.arithmetic.GVN.panic-unwind.diff b/tests/mir-opt/gvn.arithmetic.GVN.panic-unwind.diff index fa7536efc8e6..b8e4967fe8b1 100644 --- a/tests/mir-opt/gvn.arithmetic.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.arithmetic.GVN.panic-unwind.diff @@ -82,12 +82,12 @@ StorageLive(_2); StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; - _3 = Add(move _4, const 0_u64); -+ _3 = _1; ++ _3 = copy _1; StorageDead(_4); - _2 = opaque::(move _3) -> [return: bb1, unwind continue]; -+ _2 = opaque::(_1) -> [return: bb1, unwind continue]; ++ _2 = opaque::(copy _1) -> [return: bb1, unwind continue]; } bb1: { @@ -96,12 +96,12 @@ StorageLive(_5); StorageLive(_6); StorageLive(_7); - _7 = _1; + _7 = copy _1; - _6 = Sub(move _7, const 0_u64); -+ _6 = _1; ++ _6 = copy _1; StorageDead(_7); - _5 = opaque::(move _6) -> [return: bb2, unwind continue]; -+ _5 = opaque::(_1) -> [return: bb2, unwind continue]; ++ _5 = opaque::(copy _1) -> [return: bb2, unwind continue]; } bb2: { @@ -111,9 +111,9 @@ - StorageLive(_9); + nop; StorageLive(_10); - _10 = _1; + _10 = copy _1; StorageLive(_11); - _11 = _1; + _11 = copy _1; - _9 = Sub(move _10, move _11); + _9 = const 0_u64; StorageDead(_11); @@ -129,7 +129,7 @@ StorageLive(_12); StorageLive(_13); StorageLive(_14); - _14 = _1; + _14 = copy _1; - _13 = Mul(move _14, const 0_u64); + _13 = const 0_u64; StorageDead(_14); @@ -143,12 +143,12 @@ StorageLive(_15); StorageLive(_16); StorageLive(_17); - _17 = _1; + _17 = copy _1; - _16 = Mul(move _17, const 1_u64); -+ _16 = _1; ++ _16 = copy _1; StorageDead(_17); - _15 = opaque::(move _16) -> [return: bb5, unwind continue]; -+ _15 = opaque::(_1) -> [return: bb5, unwind continue]; ++ _15 = opaque::(copy _1) -> [return: bb5, unwind continue]; } bb5: { @@ -157,16 +157,16 @@ StorageLive(_18); StorageLive(_19); StorageLive(_20); - _20 = _1; + _20 = copy _1; - _21 = Eq(const 0_u64, const 0_u64); -- assert(!move _21, "attempt to divide `{}` by zero", _20) -> [success: bb6, unwind continue]; +- assert(!move _21, "attempt to divide `{}` by zero", copy _20) -> [success: bb6, unwind continue]; + _21 = const true; -+ assert(!const true, "attempt to divide `{}` by zero", _1) -> [success: bb6, unwind continue]; ++ assert(!const true, "attempt to divide `{}` by zero", copy _1) -> [success: bb6, unwind continue]; } bb6: { - _19 = Div(move _20, const 0_u64); -+ _19 = Div(_1, const 0_u64); ++ _19 = Div(copy _1, const 0_u64); StorageDead(_20); _18 = opaque::(move _19) -> [return: bb7, unwind continue]; } @@ -177,19 +177,19 @@ StorageLive(_22); StorageLive(_23); StorageLive(_24); - _24 = _1; + _24 = copy _1; - _25 = Eq(const 1_u64, const 0_u64); -- assert(!move _25, "attempt to divide `{}` by zero", _24) -> [success: bb8, unwind continue]; +- assert(!move _25, "attempt to divide `{}` by zero", copy _24) -> [success: bb8, unwind continue]; + _25 = const false; -+ assert(!const false, "attempt to divide `{}` by zero", _1) -> [success: bb8, unwind continue]; ++ assert(!const false, "attempt to divide `{}` by zero", copy _1) -> [success: bb8, unwind continue]; } bb8: { - _23 = Div(move _24, const 1_u64); -+ _23 = _1; ++ _23 = copy _1; StorageDead(_24); - _22 = opaque::(move _23) -> [return: bb9, unwind continue]; -+ _22 = opaque::(_1) -> [return: bb9, unwind continue]; ++ _22 = opaque::(copy _1) -> [return: bb9, unwind continue]; } bb9: { @@ -198,11 +198,11 @@ StorageLive(_26); StorageLive(_27); StorageLive(_28); - _28 = _1; -- _29 = Eq(_28, const 0_u64); + _28 = copy _1; +- _29 = Eq(copy _28, const 0_u64); - assert(!move _29, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb10, unwind continue]; -+ _29 = Eq(_1, const 0_u64); -+ assert(!_29, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb10, unwind continue]; ++ _29 = Eq(copy _1, const 0_u64); ++ assert(!copy _29, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb10, unwind continue]; } bb10: { @@ -219,16 +219,16 @@ StorageLive(_30); StorageLive(_31); StorageLive(_32); - _32 = _1; -- _33 = Eq(_32, const 0_u64); + _32 = copy _1; +- _33 = Eq(copy _32, const 0_u64); - assert(!move _33, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb12, unwind continue]; -+ _33 = _29; -+ assert(!_29, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb12, unwind continue]; ++ _33 = copy _29; ++ assert(!copy _29, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb12, unwind continue]; } bb12: { - _31 = Div(const 1_u64, move _32); -+ _31 = Div(const 1_u64, _1); ++ _31 = Div(const 1_u64, copy _1); StorageDead(_32); _30 = opaque::(move _31) -> [return: bb13, unwind continue]; } @@ -239,16 +239,16 @@ StorageLive(_34); StorageLive(_35); StorageLive(_36); - _36 = _1; + _36 = copy _1; - _37 = Eq(const 0_u64, const 0_u64); -- assert(!move _37, "attempt to calculate the remainder of `{}` with a divisor of zero", _36) -> [success: bb14, unwind continue]; +- assert(!move _37, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _36) -> [success: bb14, unwind continue]; + _37 = const true; -+ assert(!const true, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb14, unwind continue]; ++ assert(!const true, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _1) -> [success: bb14, unwind continue]; } bb14: { - _35 = Rem(move _36, const 0_u64); -+ _35 = Rem(_1, const 0_u64); ++ _35 = Rem(copy _1, const 0_u64); StorageDead(_36); _34 = opaque::(move _35) -> [return: bb15, unwind continue]; } @@ -259,11 +259,11 @@ StorageLive(_38); StorageLive(_39); StorageLive(_40); - _40 = _1; + _40 = copy _1; - _41 = Eq(const 1_u64, const 0_u64); -- assert(!move _41, "attempt to calculate the remainder of `{}` with a divisor of zero", _40) -> [success: bb16, unwind continue]; +- assert(!move _41, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _40) -> [success: bb16, unwind continue]; + _41 = const false; -+ assert(!const false, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb16, unwind continue]; ++ assert(!const false, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _1) -> [success: bb16, unwind continue]; } bb16: { @@ -280,11 +280,11 @@ StorageLive(_42); StorageLive(_43); StorageLive(_44); - _44 = _1; -- _45 = Eq(_44, const 0_u64); + _44 = copy _1; +- _45 = Eq(copy _44, const 0_u64); - assert(!move _45, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb18, unwind continue]; -+ _45 = _29; -+ assert(!_29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb18, unwind continue]; ++ _45 = copy _29; ++ assert(!copy _29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb18, unwind continue]; } bb18: { @@ -301,16 +301,16 @@ StorageLive(_46); StorageLive(_47); StorageLive(_48); - _48 = _1; -- _49 = Eq(_48, const 0_u64); + _48 = copy _1; +- _49 = Eq(copy _48, const 0_u64); - assert(!move _49, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb20, unwind continue]; -+ _49 = _29; -+ assert(!_29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb20, unwind continue]; ++ _49 = copy _29; ++ assert(!copy _29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb20, unwind continue]; } bb20: { - _47 = Rem(const 1_u64, move _48); -+ _47 = Rem(const 1_u64, _1); ++ _47 = Rem(const 1_u64, copy _1); StorageDead(_48); _46 = opaque::(move _47) -> [return: bb21, unwind continue]; } @@ -321,7 +321,7 @@ StorageLive(_50); StorageLive(_51); StorageLive(_52); - _52 = _1; + _52 = copy _1; - _51 = BitAnd(move _52, const 0_u64); + _51 = const 0_u64; StorageDead(_52); @@ -335,12 +335,12 @@ StorageLive(_53); StorageLive(_54); StorageLive(_55); - _55 = _1; + _55 = copy _1; - _54 = BitAnd(move _55, const core::num::::MAX); -+ _54 = _1; ++ _54 = copy _1; StorageDead(_55); - _53 = opaque::(move _54) -> [return: bb23, unwind continue]; -+ _53 = opaque::(_1) -> [return: bb23, unwind continue]; ++ _53 = opaque::(copy _1) -> [return: bb23, unwind continue]; } bb23: { @@ -349,12 +349,12 @@ StorageLive(_56); StorageLive(_57); StorageLive(_58); - _58 = _1; + _58 = copy _1; - _57 = BitOr(move _58, const 0_u64); -+ _57 = _1; ++ _57 = copy _1; StorageDead(_58); - _56 = opaque::(move _57) -> [return: bb24, unwind continue]; -+ _56 = opaque::(_1) -> [return: bb24, unwind continue]; ++ _56 = opaque::(copy _1) -> [return: bb24, unwind continue]; } bb24: { @@ -363,7 +363,7 @@ StorageLive(_59); StorageLive(_60); StorageLive(_61); - _61 = _1; + _61 = copy _1; - _60 = BitOr(move _61, const core::num::::MAX); + _60 = const u64::MAX; StorageDead(_61); @@ -377,12 +377,12 @@ StorageLive(_62); StorageLive(_63); StorageLive(_64); - _64 = _1; + _64 = copy _1; - _63 = BitXor(move _64, const 0_u64); -+ _63 = _1; ++ _63 = copy _1; StorageDead(_64); - _62 = opaque::(move _63) -> [return: bb26, unwind continue]; -+ _62 = opaque::(_1) -> [return: bb26, unwind continue]; ++ _62 = opaque::(copy _1) -> [return: bb26, unwind continue]; } bb26: { @@ -391,9 +391,9 @@ StorageLive(_65); StorageLive(_66); StorageLive(_67); - _67 = _1; + _67 = copy _1; StorageLive(_68); - _68 = _1; + _68 = copy _1; - _66 = BitXor(move _67, move _68); + _66 = const 0_u64; StorageDead(_68); @@ -408,12 +408,12 @@ StorageLive(_69); StorageLive(_70); StorageLive(_71); - _71 = _1; + _71 = copy _1; - _70 = Shr(move _71, const 0_i32); -+ _70 = _1; ++ _70 = copy _1; StorageDead(_71); - _69 = opaque::(move _70) -> [return: bb28, unwind continue]; -+ _69 = opaque::(_1) -> [return: bb28, unwind continue]; ++ _69 = opaque::(copy _1) -> [return: bb28, unwind continue]; } bb28: { @@ -422,12 +422,12 @@ StorageLive(_72); StorageLive(_73); StorageLive(_74); - _74 = _1; + _74 = copy _1; - _73 = Shl(move _74, const 0_i32); -+ _73 = _1; ++ _73 = copy _1; StorageDead(_74); - _72 = opaque::(move _73) -> [return: bb29, unwind continue]; -+ _72 = opaque::(_1) -> [return: bb29, unwind continue]; ++ _72 = opaque::(copy _1) -> [return: bb29, unwind continue]; } bb29: { diff --git a/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-abort.diff b/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-abort.diff index 0e3f2459fae3..acf8bfc71bed 100644 --- a/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-abort.diff @@ -30,19 +30,19 @@ StorageLive(_2); StorageLive(_3); StorageLive(_4); - _4 = _1; -- _5 = AddWithOverflow(_4, const 0_u64); + _4 = copy _1; +- _5 = AddWithOverflow(copy _4, const 0_u64); - assert(!move (_5.1: bool), "attempt to compute `{} + {}`, which would overflow", move _4, const 0_u64) -> [success: bb1, unwind unreachable]; -+ _5 = AddWithOverflow(_1, const 0_u64); -+ assert(!const false, "attempt to compute `{} + {}`, which would overflow", _1, const 0_u64) -> [success: bb1, unwind unreachable]; ++ _5 = AddWithOverflow(copy _1, const 0_u64); ++ assert(!const false, "attempt to compute `{} + {}`, which would overflow", copy _1, const 0_u64) -> [success: bb1, unwind unreachable]; } bb1: { - _3 = move (_5.0: u64); -+ _3 = _1; ++ _3 = copy _1; StorageDead(_4); - _2 = opaque::(move _3) -> [return: bb2, unwind unreachable]; -+ _2 = opaque::(_1) -> [return: bb2, unwind unreachable]; ++ _2 = opaque::(copy _1) -> [return: bb2, unwind unreachable]; } bb2: { @@ -51,19 +51,19 @@ StorageLive(_6); StorageLive(_7); StorageLive(_8); - _8 = _1; -- _9 = SubWithOverflow(_8, const 0_u64); + _8 = copy _1; +- _9 = SubWithOverflow(copy _8, const 0_u64); - assert(!move (_9.1: bool), "attempt to compute `{} - {}`, which would overflow", move _8, const 0_u64) -> [success: bb3, unwind unreachable]; -+ _9 = _5; -+ assert(!const false, "attempt to compute `{} - {}`, which would overflow", _1, const 0_u64) -> [success: bb3, unwind unreachable]; ++ _9 = copy _5; ++ assert(!const false, "attempt to compute `{} - {}`, which would overflow", copy _1, const 0_u64) -> [success: bb3, unwind unreachable]; } bb3: { - _7 = move (_9.0: u64); -+ _7 = _1; ++ _7 = copy _1; StorageDead(_8); - _6 = opaque::(move _7) -> [return: bb4, unwind unreachable]; -+ _6 = opaque::(_1) -> [return: bb4, unwind unreachable]; ++ _6 = opaque::(copy _1) -> [return: bb4, unwind unreachable]; } bb4: { @@ -73,13 +73,13 @@ - StorageLive(_11); + nop; StorageLive(_12); - _12 = _1; + _12 = copy _1; StorageLive(_13); - _13 = _1; -- _14 = SubWithOverflow(_12, _13); + _13 = copy _1; +- _14 = SubWithOverflow(copy _12, copy _13); - assert(!move (_14.1: bool), "attempt to compute `{} - {}`, which would overflow", move _12, move _13) -> [success: bb5, unwind unreachable]; + _14 = const (0_u64, false); -+ assert(!const false, "attempt to compute `{} - {}`, which would overflow", _1, _1) -> [success: bb5, unwind unreachable]; ++ assert(!const false, "attempt to compute `{} - {}`, which would overflow", copy _1, copy _1) -> [success: bb5, unwind unreachable]; } bb5: { @@ -98,11 +98,11 @@ StorageLive(_15); StorageLive(_16); StorageLive(_17); - _17 = _1; -- _18 = MulWithOverflow(_17, const 0_u64); + _17 = copy _1; +- _18 = MulWithOverflow(copy _17, const 0_u64); - assert(!move (_18.1: bool), "attempt to compute `{} * {}`, which would overflow", move _17, const 0_u64) -> [success: bb7, unwind unreachable]; + _18 = const (0_u64, false); -+ assert(!const false, "attempt to compute `{} * {}`, which would overflow", _1, const 0_u64) -> [success: bb7, unwind unreachable]; ++ assert(!const false, "attempt to compute `{} * {}`, which would overflow", copy _1, const 0_u64) -> [success: bb7, unwind unreachable]; } bb7: { @@ -119,19 +119,19 @@ StorageLive(_19); StorageLive(_20); StorageLive(_21); - _21 = _1; -- _22 = MulWithOverflow(_21, const 1_u64); + _21 = copy _1; +- _22 = MulWithOverflow(copy _21, const 1_u64); - assert(!move (_22.1: bool), "attempt to compute `{} * {}`, which would overflow", move _21, const 1_u64) -> [success: bb9, unwind unreachable]; -+ _22 = _5; -+ assert(!const false, "attempt to compute `{} * {}`, which would overflow", _1, const 1_u64) -> [success: bb9, unwind unreachable]; ++ _22 = copy _5; ++ assert(!const false, "attempt to compute `{} * {}`, which would overflow", copy _1, const 1_u64) -> [success: bb9, unwind unreachable]; } bb9: { - _20 = move (_22.0: u64); -+ _20 = _1; ++ _20 = copy _1; StorageDead(_21); - _19 = opaque::(move _20) -> [return: bb10, unwind unreachable]; -+ _19 = opaque::(_1) -> [return: bb10, unwind unreachable]; ++ _19 = opaque::(copy _1) -> [return: bb10, unwind unreachable]; } bb10: { diff --git a/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-unwind.diff b/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-unwind.diff index 2873d7ef0ab1..f3f6b381a81c 100644 --- a/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-unwind.diff @@ -30,19 +30,19 @@ StorageLive(_2); StorageLive(_3); StorageLive(_4); - _4 = _1; -- _5 = AddWithOverflow(_4, const 0_u64); + _4 = copy _1; +- _5 = AddWithOverflow(copy _4, const 0_u64); - assert(!move (_5.1: bool), "attempt to compute `{} + {}`, which would overflow", move _4, const 0_u64) -> [success: bb1, unwind continue]; -+ _5 = AddWithOverflow(_1, const 0_u64); -+ assert(!const false, "attempt to compute `{} + {}`, which would overflow", _1, const 0_u64) -> [success: bb1, unwind continue]; ++ _5 = AddWithOverflow(copy _1, const 0_u64); ++ assert(!const false, "attempt to compute `{} + {}`, which would overflow", copy _1, const 0_u64) -> [success: bb1, unwind continue]; } bb1: { - _3 = move (_5.0: u64); -+ _3 = _1; ++ _3 = copy _1; StorageDead(_4); - _2 = opaque::(move _3) -> [return: bb2, unwind continue]; -+ _2 = opaque::(_1) -> [return: bb2, unwind continue]; ++ _2 = opaque::(copy _1) -> [return: bb2, unwind continue]; } bb2: { @@ -51,19 +51,19 @@ StorageLive(_6); StorageLive(_7); StorageLive(_8); - _8 = _1; -- _9 = SubWithOverflow(_8, const 0_u64); + _8 = copy _1; +- _9 = SubWithOverflow(copy _8, const 0_u64); - assert(!move (_9.1: bool), "attempt to compute `{} - {}`, which would overflow", move _8, const 0_u64) -> [success: bb3, unwind continue]; -+ _9 = _5; -+ assert(!const false, "attempt to compute `{} - {}`, which would overflow", _1, const 0_u64) -> [success: bb3, unwind continue]; ++ _9 = copy _5; ++ assert(!const false, "attempt to compute `{} - {}`, which would overflow", copy _1, const 0_u64) -> [success: bb3, unwind continue]; } bb3: { - _7 = move (_9.0: u64); -+ _7 = _1; ++ _7 = copy _1; StorageDead(_8); - _6 = opaque::(move _7) -> [return: bb4, unwind continue]; -+ _6 = opaque::(_1) -> [return: bb4, unwind continue]; ++ _6 = opaque::(copy _1) -> [return: bb4, unwind continue]; } bb4: { @@ -73,13 +73,13 @@ - StorageLive(_11); + nop; StorageLive(_12); - _12 = _1; + _12 = copy _1; StorageLive(_13); - _13 = _1; -- _14 = SubWithOverflow(_12, _13); + _13 = copy _1; +- _14 = SubWithOverflow(copy _12, copy _13); - assert(!move (_14.1: bool), "attempt to compute `{} - {}`, which would overflow", move _12, move _13) -> [success: bb5, unwind continue]; + _14 = const (0_u64, false); -+ assert(!const false, "attempt to compute `{} - {}`, which would overflow", _1, _1) -> [success: bb5, unwind continue]; ++ assert(!const false, "attempt to compute `{} - {}`, which would overflow", copy _1, copy _1) -> [success: bb5, unwind continue]; } bb5: { @@ -98,11 +98,11 @@ StorageLive(_15); StorageLive(_16); StorageLive(_17); - _17 = _1; -- _18 = MulWithOverflow(_17, const 0_u64); + _17 = copy _1; +- _18 = MulWithOverflow(copy _17, const 0_u64); - assert(!move (_18.1: bool), "attempt to compute `{} * {}`, which would overflow", move _17, const 0_u64) -> [success: bb7, unwind continue]; + _18 = const (0_u64, false); -+ assert(!const false, "attempt to compute `{} * {}`, which would overflow", _1, const 0_u64) -> [success: bb7, unwind continue]; ++ assert(!const false, "attempt to compute `{} * {}`, which would overflow", copy _1, const 0_u64) -> [success: bb7, unwind continue]; } bb7: { @@ -119,19 +119,19 @@ StorageLive(_19); StorageLive(_20); StorageLive(_21); - _21 = _1; -- _22 = MulWithOverflow(_21, const 1_u64); + _21 = copy _1; +- _22 = MulWithOverflow(copy _21, const 1_u64); - assert(!move (_22.1: bool), "attempt to compute `{} * {}`, which would overflow", move _21, const 1_u64) -> [success: bb9, unwind continue]; -+ _22 = _5; -+ assert(!const false, "attempt to compute `{} * {}`, which would overflow", _1, const 1_u64) -> [success: bb9, unwind continue]; ++ _22 = copy _5; ++ assert(!const false, "attempt to compute `{} * {}`, which would overflow", copy _1, const 1_u64) -> [success: bb9, unwind continue]; } bb9: { - _20 = move (_22.0: u64); -+ _20 = _1; ++ _20 = copy _1; StorageDead(_21); - _19 = opaque::(move _20) -> [return: bb10, unwind continue]; -+ _19 = opaque::(_1) -> [return: bb10, unwind continue]; ++ _19 = opaque::(copy _1) -> [return: bb10, unwind continue]; } bb10: { diff --git a/tests/mir-opt/gvn.arithmetic_float.GVN.panic-abort.diff b/tests/mir-opt/gvn.arithmetic_float.GVN.panic-abort.diff index b332100eaf03..31a854681267 100644 --- a/tests/mir-opt/gvn.arithmetic_float.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.arithmetic_float.GVN.panic-abort.diff @@ -38,9 +38,9 @@ StorageLive(_2); StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; - _3 = Add(move _4, const 0f64); -+ _3 = Add(_1, const 0f64); ++ _3 = Add(copy _1, const 0f64); StorageDead(_4); _2 = opaque::(move _3) -> [return: bb1, unwind unreachable]; } @@ -51,9 +51,9 @@ StorageLive(_5); StorageLive(_6); StorageLive(_7); - _7 = _1; + _7 = copy _1; - _6 = Sub(move _7, const 0f64); -+ _6 = Sub(_1, const 0f64); ++ _6 = Sub(copy _1, const 0f64); StorageDead(_7); _5 = opaque::(move _6) -> [return: bb2, unwind unreachable]; } @@ -64,9 +64,9 @@ StorageLive(_8); StorageLive(_9); StorageLive(_10); - _10 = _1; + _10 = copy _1; - _9 = Mul(move _10, const 0f64); -+ _9 = Mul(_1, const 0f64); ++ _9 = Mul(copy _1, const 0f64); StorageDead(_10); _8 = opaque::(move _9) -> [return: bb3, unwind unreachable]; } @@ -77,9 +77,9 @@ StorageLive(_11); StorageLive(_12); StorageLive(_13); - _13 = _1; + _13 = copy _1; - _12 = Div(move _13, const 0f64); -+ _12 = Div(_1, const 0f64); ++ _12 = Div(copy _1, const 0f64); StorageDead(_13); _11 = opaque::(move _12) -> [return: bb4, unwind unreachable]; } @@ -90,9 +90,9 @@ StorageLive(_14); StorageLive(_15); StorageLive(_16); - _16 = _1; + _16 = copy _1; - _15 = Div(const 0f64, move _16); -+ _15 = Div(const 0f64, _1); ++ _15 = Div(const 0f64, copy _1); StorageDead(_16); _14 = opaque::(move _15) -> [return: bb5, unwind unreachable]; } @@ -103,9 +103,9 @@ StorageLive(_17); StorageLive(_18); StorageLive(_19); - _19 = _1; + _19 = copy _1; - _18 = Rem(move _19, const 0f64); -+ _18 = Rem(_1, const 0f64); ++ _18 = Rem(copy _1, const 0f64); StorageDead(_19); _17 = opaque::(move _18) -> [return: bb6, unwind unreachable]; } @@ -116,9 +116,9 @@ StorageLive(_20); StorageLive(_21); StorageLive(_22); - _22 = _1; + _22 = copy _1; - _21 = Rem(const 0f64, move _22); -+ _21 = Rem(const 0f64, _1); ++ _21 = Rem(const 0f64, copy _1); StorageDead(_22); _20 = opaque::(move _21) -> [return: bb7, unwind unreachable]; } @@ -129,11 +129,11 @@ StorageLive(_23); StorageLive(_24); StorageLive(_25); - _25 = _1; + _25 = copy _1; StorageLive(_26); - _26 = _1; + _26 = copy _1; - _24 = Eq(move _25, move _26); -+ _24 = Eq(_1, _1); ++ _24 = Eq(copy _1, copy _1); StorageDead(_26); StorageDead(_25); _23 = opaque::(move _24) -> [return: bb8, unwind unreachable]; @@ -145,11 +145,11 @@ StorageLive(_27); StorageLive(_28); StorageLive(_29); - _29 = _1; + _29 = copy _1; StorageLive(_30); - _30 = _1; + _30 = copy _1; - _28 = Ne(move _29, move _30); -+ _28 = Ne(_1, _1); ++ _28 = Ne(copy _1, copy _1); StorageDead(_30); StorageDead(_29); _27 = opaque::(move _28) -> [return: bb9, unwind unreachable]; diff --git a/tests/mir-opt/gvn.arithmetic_float.GVN.panic-unwind.diff b/tests/mir-opt/gvn.arithmetic_float.GVN.panic-unwind.diff index 28664cb0ac8c..4e42b1af4fc9 100644 --- a/tests/mir-opt/gvn.arithmetic_float.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.arithmetic_float.GVN.panic-unwind.diff @@ -38,9 +38,9 @@ StorageLive(_2); StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; - _3 = Add(move _4, const 0f64); -+ _3 = Add(_1, const 0f64); ++ _3 = Add(copy _1, const 0f64); StorageDead(_4); _2 = opaque::(move _3) -> [return: bb1, unwind continue]; } @@ -51,9 +51,9 @@ StorageLive(_5); StorageLive(_6); StorageLive(_7); - _7 = _1; + _7 = copy _1; - _6 = Sub(move _7, const 0f64); -+ _6 = Sub(_1, const 0f64); ++ _6 = Sub(copy _1, const 0f64); StorageDead(_7); _5 = opaque::(move _6) -> [return: bb2, unwind continue]; } @@ -64,9 +64,9 @@ StorageLive(_8); StorageLive(_9); StorageLive(_10); - _10 = _1; + _10 = copy _1; - _9 = Mul(move _10, const 0f64); -+ _9 = Mul(_1, const 0f64); ++ _9 = Mul(copy _1, const 0f64); StorageDead(_10); _8 = opaque::(move _9) -> [return: bb3, unwind continue]; } @@ -77,9 +77,9 @@ StorageLive(_11); StorageLive(_12); StorageLive(_13); - _13 = _1; + _13 = copy _1; - _12 = Div(move _13, const 0f64); -+ _12 = Div(_1, const 0f64); ++ _12 = Div(copy _1, const 0f64); StorageDead(_13); _11 = opaque::(move _12) -> [return: bb4, unwind continue]; } @@ -90,9 +90,9 @@ StorageLive(_14); StorageLive(_15); StorageLive(_16); - _16 = _1; + _16 = copy _1; - _15 = Div(const 0f64, move _16); -+ _15 = Div(const 0f64, _1); ++ _15 = Div(const 0f64, copy _1); StorageDead(_16); _14 = opaque::(move _15) -> [return: bb5, unwind continue]; } @@ -103,9 +103,9 @@ StorageLive(_17); StorageLive(_18); StorageLive(_19); - _19 = _1; + _19 = copy _1; - _18 = Rem(move _19, const 0f64); -+ _18 = Rem(_1, const 0f64); ++ _18 = Rem(copy _1, const 0f64); StorageDead(_19); _17 = opaque::(move _18) -> [return: bb6, unwind continue]; } @@ -116,9 +116,9 @@ StorageLive(_20); StorageLive(_21); StorageLive(_22); - _22 = _1; + _22 = copy _1; - _21 = Rem(const 0f64, move _22); -+ _21 = Rem(const 0f64, _1); ++ _21 = Rem(const 0f64, copy _1); StorageDead(_22); _20 = opaque::(move _21) -> [return: bb7, unwind continue]; } @@ -129,11 +129,11 @@ StorageLive(_23); StorageLive(_24); StorageLive(_25); - _25 = _1; + _25 = copy _1; StorageLive(_26); - _26 = _1; + _26 = copy _1; - _24 = Eq(move _25, move _26); -+ _24 = Eq(_1, _1); ++ _24 = Eq(copy _1, copy _1); StorageDead(_26); StorageDead(_25); _23 = opaque::(move _24) -> [return: bb8, unwind continue]; @@ -145,11 +145,11 @@ StorageLive(_27); StorageLive(_28); StorageLive(_29); - _29 = _1; + _29 = copy _1; StorageLive(_30); - _30 = _1; + _30 = copy _1; - _28 = Ne(move _29, move _30); -+ _28 = Ne(_1, _1); ++ _28 = Ne(copy _1, copy _1); StorageDead(_30); StorageDead(_29); _27 = opaque::(move _28) -> [return: bb9, unwind continue]; diff --git a/tests/mir-opt/gvn.borrowed.GVN.panic-abort.diff b/tests/mir-opt/gvn.borrowed.GVN.panic-abort.diff index 9520bd382eeb..b0702696e187 100644 --- a/tests/mir-opt/gvn.borrowed.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.borrowed.GVN.panic-abort.diff @@ -7,19 +7,19 @@ let mut _3: &T; bb0: { - _2 = _1; + _2 = copy _1; _3 = &_1; - _0 = opaque::<&T>(_3) -> [return: bb1, unwind unreachable]; + _0 = opaque::<&T>(copy _3) -> [return: bb1, unwind unreachable]; } bb1: { -- _0 = opaque::(_2) -> [return: bb2, unwind unreachable]; -+ _0 = opaque::(_1) -> [return: bb2, unwind unreachable]; +- _0 = opaque::(copy _2) -> [return: bb2, unwind unreachable]; ++ _0 = opaque::(copy _1) -> [return: bb2, unwind unreachable]; } bb2: { -- _0 = opaque::((*_3)) -> [return: bb3, unwind unreachable]; -+ _0 = opaque::(_1) -> [return: bb3, unwind unreachable]; +- _0 = opaque::(copy (*_3)) -> [return: bb3, unwind unreachable]; ++ _0 = opaque::(copy _1) -> [return: bb3, unwind unreachable]; } bb3: { diff --git a/tests/mir-opt/gvn.borrowed.GVN.panic-unwind.diff b/tests/mir-opt/gvn.borrowed.GVN.panic-unwind.diff index 4f5d76d56440..fe05d4deeede 100644 --- a/tests/mir-opt/gvn.borrowed.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.borrowed.GVN.panic-unwind.diff @@ -7,19 +7,19 @@ let mut _3: &T; bb0: { - _2 = _1; + _2 = copy _1; _3 = &_1; - _0 = opaque::<&T>(_3) -> [return: bb1, unwind continue]; + _0 = opaque::<&T>(copy _3) -> [return: bb1, unwind continue]; } bb1: { -- _0 = opaque::(_2) -> [return: bb2, unwind continue]; -+ _0 = opaque::(_1) -> [return: bb2, unwind continue]; +- _0 = opaque::(copy _2) -> [return: bb2, unwind continue]; ++ _0 = opaque::(copy _1) -> [return: bb2, unwind continue]; } bb2: { -- _0 = opaque::((*_3)) -> [return: bb3, unwind continue]; -+ _0 = opaque::(_1) -> [return: bb3, unwind continue]; +- _0 = opaque::(copy (*_3)) -> [return: bb3, unwind continue]; ++ _0 = opaque::(copy _1) -> [return: bb3, unwind continue]; } bb3: { diff --git a/tests/mir-opt/gvn.cast.GVN.panic-abort.diff b/tests/mir-opt/gvn.cast.GVN.panic-abort.diff index d43198c99110..1d523d22ca64 100644 --- a/tests/mir-opt/gvn.cast.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.cast.GVN.panic-abort.diff @@ -116,7 +116,7 @@ StorageLive(_4); StorageLive(_5); StorageLive(_6); -- _6 = _1; +- _6 = copy _1; - _5 = move _6 as u8 (IntToInt); + _6 = const 1_i64; + _5 = const 1_u8; @@ -131,7 +131,7 @@ StorageLive(_7); StorageLive(_8); StorageLive(_9); -- _9 = _1; +- _9 = copy _1; - _8 = move _9 as u16 (IntToInt); + _9 = const 1_i64; + _8 = const 1_u16; @@ -146,7 +146,7 @@ StorageLive(_10); StorageLive(_11); StorageLive(_12); -- _12 = _1; +- _12 = copy _1; - _11 = move _12 as u32 (IntToInt); + _12 = const 1_i64; + _11 = const 1_u32; @@ -161,7 +161,7 @@ StorageLive(_13); StorageLive(_14); StorageLive(_15); -- _15 = _1; +- _15 = copy _1; - _14 = move _15 as u64 (IntToInt); + _15 = const 1_i64; + _14 = const 1_u64; @@ -176,7 +176,7 @@ StorageLive(_16); StorageLive(_17); StorageLive(_18); -- _18 = _1; +- _18 = copy _1; - _17 = move _18 as i8 (IntToInt); + _18 = const 1_i64; + _17 = const 1_i8; @@ -191,7 +191,7 @@ StorageLive(_19); StorageLive(_20); StorageLive(_21); -- _21 = _1; +- _21 = copy _1; - _20 = move _21 as i16 (IntToInt); + _21 = const 1_i64; + _20 = const 1_i16; @@ -206,7 +206,7 @@ StorageLive(_22); StorageLive(_23); StorageLive(_24); -- _24 = _1; +- _24 = copy _1; - _23 = move _24 as i32 (IntToInt); + _24 = const 1_i64; + _23 = const 1_i32; @@ -220,7 +220,7 @@ StorageDead(_22); StorageLive(_25); StorageLive(_26); -- _26 = _1; +- _26 = copy _1; - _25 = opaque::(move _26) -> [return: bb8, unwind unreachable]; + _26 = const 1_i64; + _25 = opaque::(const 1_i64) -> [return: bb8, unwind unreachable]; @@ -232,7 +232,7 @@ StorageLive(_27); StorageLive(_28); StorageLive(_29); -- _29 = _1; +- _29 = copy _1; - _28 = move _29 as f32 (IntToFloat); + _29 = const 1_i64; + _28 = const 1f32; @@ -247,7 +247,7 @@ StorageLive(_30); StorageLive(_31); StorageLive(_32); -- _32 = _1; +- _32 = copy _1; - _31 = move _32 as f64 (IntToFloat); + _32 = const 1_i64; + _31 = const 1f64; @@ -262,7 +262,7 @@ StorageLive(_33); StorageLive(_34); StorageLive(_35); -- _35 = _2; +- _35 = copy _2; - _34 = move _35 as u8 (IntToInt); + _35 = const 1_u64; + _34 = const 1_u8; @@ -277,7 +277,7 @@ StorageLive(_36); StorageLive(_37); StorageLive(_38); -- _38 = _2; +- _38 = copy _2; - _37 = move _38 as u16 (IntToInt); + _38 = const 1_u64; + _37 = const 1_u16; @@ -292,7 +292,7 @@ StorageLive(_39); StorageLive(_40); StorageLive(_41); -- _41 = _2; +- _41 = copy _2; - _40 = move _41 as u32 (IntToInt); + _41 = const 1_u64; + _40 = const 1_u32; @@ -306,7 +306,7 @@ StorageDead(_39); StorageLive(_42); StorageLive(_43); -- _43 = _2; +- _43 = copy _2; - _42 = opaque::(move _43) -> [return: bb14, unwind unreachable]; + _43 = const 1_u64; + _42 = opaque::(const 1_u64) -> [return: bb14, unwind unreachable]; @@ -318,7 +318,7 @@ StorageLive(_44); StorageLive(_45); StorageLive(_46); -- _46 = _2; +- _46 = copy _2; - _45 = move _46 as i8 (IntToInt); + _46 = const 1_u64; + _45 = const 1_i8; @@ -333,7 +333,7 @@ StorageLive(_47); StorageLive(_48); StorageLive(_49); -- _49 = _2; +- _49 = copy _2; - _48 = move _49 as i16 (IntToInt); + _49 = const 1_u64; + _48 = const 1_i16; @@ -348,7 +348,7 @@ StorageLive(_50); StorageLive(_51); StorageLive(_52); -- _52 = _2; +- _52 = copy _2; - _51 = move _52 as i32 (IntToInt); + _52 = const 1_u64; + _51 = const 1_i32; @@ -363,7 +363,7 @@ StorageLive(_53); StorageLive(_54); StorageLive(_55); -- _55 = _2; +- _55 = copy _2; - _54 = move _55 as i64 (IntToInt); + _55 = const 1_u64; + _54 = const 1_i64; @@ -378,7 +378,7 @@ StorageLive(_56); StorageLive(_57); StorageLive(_58); -- _58 = _2; +- _58 = copy _2; - _57 = move _58 as f32 (IntToFloat); + _58 = const 1_u64; + _57 = const 1f32; @@ -393,7 +393,7 @@ StorageLive(_59); StorageLive(_60); StorageLive(_61); -- _61 = _2; +- _61 = copy _2; - _60 = move _61 as f64 (IntToFloat); + _61 = const 1_u64; + _60 = const 1f64; @@ -408,7 +408,7 @@ StorageLive(_62); StorageLive(_63); StorageLive(_64); -- _64 = _3; +- _64 = copy _3; - _63 = move _64 as u8 (FloatToInt); + _64 = const 1f64; + _63 = const 1_u8; @@ -423,7 +423,7 @@ StorageLive(_65); StorageLive(_66); StorageLive(_67); -- _67 = _3; +- _67 = copy _3; - _66 = move _67 as u16 (FloatToInt); + _67 = const 1f64; + _66 = const 1_u16; @@ -438,7 +438,7 @@ StorageLive(_68); StorageLive(_69); StorageLive(_70); -- _70 = _3; +- _70 = copy _3; - _69 = move _70 as u32 (FloatToInt); + _70 = const 1f64; + _69 = const 1_u32; @@ -453,7 +453,7 @@ StorageLive(_71); StorageLive(_72); StorageLive(_73); -- _73 = _3; +- _73 = copy _3; - _72 = move _73 as u64 (FloatToInt); + _73 = const 1f64; + _72 = const 1_u64; @@ -468,7 +468,7 @@ StorageLive(_74); StorageLive(_75); StorageLive(_76); -- _76 = _3; +- _76 = copy _3; - _75 = move _76 as i8 (FloatToInt); + _76 = const 1f64; + _75 = const 1_i8; @@ -483,7 +483,7 @@ StorageLive(_77); StorageLive(_78); StorageLive(_79); -- _79 = _3; +- _79 = copy _3; - _78 = move _79 as i16 (FloatToInt); + _79 = const 1f64; + _78 = const 1_i16; @@ -498,7 +498,7 @@ StorageLive(_80); StorageLive(_81); StorageLive(_82); -- _82 = _3; +- _82 = copy _3; - _81 = move _82 as i32 (FloatToInt); + _82 = const 1f64; + _81 = const 1_i32; @@ -513,7 +513,7 @@ StorageLive(_83); StorageLive(_84); StorageLive(_85); -- _85 = _3; +- _85 = copy _3; - _84 = move _85 as i64 (FloatToInt); + _85 = const 1f64; + _84 = const 1_i64; @@ -528,7 +528,7 @@ StorageLive(_86); StorageLive(_87); StorageLive(_88); -- _88 = _3; +- _88 = copy _3; - _87 = move _88 as f32 (FloatToFloat); + _88 = const 1f64; + _87 = const 1f32; @@ -542,7 +542,7 @@ StorageDead(_86); StorageLive(_89); StorageLive(_90); -- _90 = _3; +- _90 = copy _3; - _89 = opaque::(move _90) -> [return: bb30, unwind unreachable]; + _90 = const 1f64; + _89 = opaque::(const 1f64) -> [return: bb30, unwind unreachable]; diff --git a/tests/mir-opt/gvn.cast.GVN.panic-unwind.diff b/tests/mir-opt/gvn.cast.GVN.panic-unwind.diff index 08b97e13aa0b..3541c10da643 100644 --- a/tests/mir-opt/gvn.cast.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.cast.GVN.panic-unwind.diff @@ -116,7 +116,7 @@ StorageLive(_4); StorageLive(_5); StorageLive(_6); -- _6 = _1; +- _6 = copy _1; - _5 = move _6 as u8 (IntToInt); + _6 = const 1_i64; + _5 = const 1_u8; @@ -131,7 +131,7 @@ StorageLive(_7); StorageLive(_8); StorageLive(_9); -- _9 = _1; +- _9 = copy _1; - _8 = move _9 as u16 (IntToInt); + _9 = const 1_i64; + _8 = const 1_u16; @@ -146,7 +146,7 @@ StorageLive(_10); StorageLive(_11); StorageLive(_12); -- _12 = _1; +- _12 = copy _1; - _11 = move _12 as u32 (IntToInt); + _12 = const 1_i64; + _11 = const 1_u32; @@ -161,7 +161,7 @@ StorageLive(_13); StorageLive(_14); StorageLive(_15); -- _15 = _1; +- _15 = copy _1; - _14 = move _15 as u64 (IntToInt); + _15 = const 1_i64; + _14 = const 1_u64; @@ -176,7 +176,7 @@ StorageLive(_16); StorageLive(_17); StorageLive(_18); -- _18 = _1; +- _18 = copy _1; - _17 = move _18 as i8 (IntToInt); + _18 = const 1_i64; + _17 = const 1_i8; @@ -191,7 +191,7 @@ StorageLive(_19); StorageLive(_20); StorageLive(_21); -- _21 = _1; +- _21 = copy _1; - _20 = move _21 as i16 (IntToInt); + _21 = const 1_i64; + _20 = const 1_i16; @@ -206,7 +206,7 @@ StorageLive(_22); StorageLive(_23); StorageLive(_24); -- _24 = _1; +- _24 = copy _1; - _23 = move _24 as i32 (IntToInt); + _24 = const 1_i64; + _23 = const 1_i32; @@ -220,7 +220,7 @@ StorageDead(_22); StorageLive(_25); StorageLive(_26); -- _26 = _1; +- _26 = copy _1; - _25 = opaque::(move _26) -> [return: bb8, unwind continue]; + _26 = const 1_i64; + _25 = opaque::(const 1_i64) -> [return: bb8, unwind continue]; @@ -232,7 +232,7 @@ StorageLive(_27); StorageLive(_28); StorageLive(_29); -- _29 = _1; +- _29 = copy _1; - _28 = move _29 as f32 (IntToFloat); + _29 = const 1_i64; + _28 = const 1f32; @@ -247,7 +247,7 @@ StorageLive(_30); StorageLive(_31); StorageLive(_32); -- _32 = _1; +- _32 = copy _1; - _31 = move _32 as f64 (IntToFloat); + _32 = const 1_i64; + _31 = const 1f64; @@ -262,7 +262,7 @@ StorageLive(_33); StorageLive(_34); StorageLive(_35); -- _35 = _2; +- _35 = copy _2; - _34 = move _35 as u8 (IntToInt); + _35 = const 1_u64; + _34 = const 1_u8; @@ -277,7 +277,7 @@ StorageLive(_36); StorageLive(_37); StorageLive(_38); -- _38 = _2; +- _38 = copy _2; - _37 = move _38 as u16 (IntToInt); + _38 = const 1_u64; + _37 = const 1_u16; @@ -292,7 +292,7 @@ StorageLive(_39); StorageLive(_40); StorageLive(_41); -- _41 = _2; +- _41 = copy _2; - _40 = move _41 as u32 (IntToInt); + _41 = const 1_u64; + _40 = const 1_u32; @@ -306,7 +306,7 @@ StorageDead(_39); StorageLive(_42); StorageLive(_43); -- _43 = _2; +- _43 = copy _2; - _42 = opaque::(move _43) -> [return: bb14, unwind continue]; + _43 = const 1_u64; + _42 = opaque::(const 1_u64) -> [return: bb14, unwind continue]; @@ -318,7 +318,7 @@ StorageLive(_44); StorageLive(_45); StorageLive(_46); -- _46 = _2; +- _46 = copy _2; - _45 = move _46 as i8 (IntToInt); + _46 = const 1_u64; + _45 = const 1_i8; @@ -333,7 +333,7 @@ StorageLive(_47); StorageLive(_48); StorageLive(_49); -- _49 = _2; +- _49 = copy _2; - _48 = move _49 as i16 (IntToInt); + _49 = const 1_u64; + _48 = const 1_i16; @@ -348,7 +348,7 @@ StorageLive(_50); StorageLive(_51); StorageLive(_52); -- _52 = _2; +- _52 = copy _2; - _51 = move _52 as i32 (IntToInt); + _52 = const 1_u64; + _51 = const 1_i32; @@ -363,7 +363,7 @@ StorageLive(_53); StorageLive(_54); StorageLive(_55); -- _55 = _2; +- _55 = copy _2; - _54 = move _55 as i64 (IntToInt); + _55 = const 1_u64; + _54 = const 1_i64; @@ -378,7 +378,7 @@ StorageLive(_56); StorageLive(_57); StorageLive(_58); -- _58 = _2; +- _58 = copy _2; - _57 = move _58 as f32 (IntToFloat); + _58 = const 1_u64; + _57 = const 1f32; @@ -393,7 +393,7 @@ StorageLive(_59); StorageLive(_60); StorageLive(_61); -- _61 = _2; +- _61 = copy _2; - _60 = move _61 as f64 (IntToFloat); + _61 = const 1_u64; + _60 = const 1f64; @@ -408,7 +408,7 @@ StorageLive(_62); StorageLive(_63); StorageLive(_64); -- _64 = _3; +- _64 = copy _3; - _63 = move _64 as u8 (FloatToInt); + _64 = const 1f64; + _63 = const 1_u8; @@ -423,7 +423,7 @@ StorageLive(_65); StorageLive(_66); StorageLive(_67); -- _67 = _3; +- _67 = copy _3; - _66 = move _67 as u16 (FloatToInt); + _67 = const 1f64; + _66 = const 1_u16; @@ -438,7 +438,7 @@ StorageLive(_68); StorageLive(_69); StorageLive(_70); -- _70 = _3; +- _70 = copy _3; - _69 = move _70 as u32 (FloatToInt); + _70 = const 1f64; + _69 = const 1_u32; @@ -453,7 +453,7 @@ StorageLive(_71); StorageLive(_72); StorageLive(_73); -- _73 = _3; +- _73 = copy _3; - _72 = move _73 as u64 (FloatToInt); + _73 = const 1f64; + _72 = const 1_u64; @@ -468,7 +468,7 @@ StorageLive(_74); StorageLive(_75); StorageLive(_76); -- _76 = _3; +- _76 = copy _3; - _75 = move _76 as i8 (FloatToInt); + _76 = const 1f64; + _75 = const 1_i8; @@ -483,7 +483,7 @@ StorageLive(_77); StorageLive(_78); StorageLive(_79); -- _79 = _3; +- _79 = copy _3; - _78 = move _79 as i16 (FloatToInt); + _79 = const 1f64; + _78 = const 1_i16; @@ -498,7 +498,7 @@ StorageLive(_80); StorageLive(_81); StorageLive(_82); -- _82 = _3; +- _82 = copy _3; - _81 = move _82 as i32 (FloatToInt); + _82 = const 1f64; + _81 = const 1_i32; @@ -513,7 +513,7 @@ StorageLive(_83); StorageLive(_84); StorageLive(_85); -- _85 = _3; +- _85 = copy _3; - _84 = move _85 as i64 (FloatToInt); + _85 = const 1f64; + _84 = const 1_i64; @@ -528,7 +528,7 @@ StorageLive(_86); StorageLive(_87); StorageLive(_88); -- _88 = _3; +- _88 = copy _3; - _87 = move _88 as f32 (FloatToFloat); + _88 = const 1f64; + _87 = const 1f32; @@ -542,7 +542,7 @@ StorageDead(_86); StorageLive(_89); StorageLive(_90); -- _90 = _3; +- _90 = copy _3; - _89 = opaque::(move _90) -> [return: bb30, unwind continue]; + _90 = const 1f64; + _89 = opaque::(const 1f64) -> [return: bb30, unwind continue]; diff --git a/tests/mir-opt/gvn.cast_pointer_eq.GVN.panic-abort.diff b/tests/mir-opt/gvn.cast_pointer_eq.GVN.panic-abort.diff index 757ab959813a..f66aed0f4415 100644 --- a/tests/mir-opt/gvn.cast_pointer_eq.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.cast_pointer_eq.GVN.panic-abort.diff @@ -52,70 +52,70 @@ - StorageLive(_5); + nop; StorageLive(_6); - _6 = _1; + _6 = copy _1; - _5 = move _6 as *const u32 (PtrToPtr); -+ _5 = _1 as *const u32 (PtrToPtr); ++ _5 = copy _1 as *const u32 (PtrToPtr); StorageDead(_6); StorageLive(_7); - StorageLive(_8); + nop; StorageLive(_9); - _9 = _2; + _9 = copy _2; - _8 = move _9 as *const u32 (PtrToPtr); -+ _8 = _2 as *const u32 (PtrToPtr); ++ _8 = copy _2 as *const u32 (PtrToPtr); StorageDead(_9); - _7 = move _8 as *const u32 (PtrToPtr); - StorageDead(_8); -+ _7 = _8; ++ _7 = copy _8; + nop; StorageLive(_10); - StorageLive(_11); + nop; StorageLive(_12); - _12 = _3; + _12 = copy _3; - _11 = move _12 as *const u32 (PtrToPtr); -+ _11 = _3 as *const u32 (PtrToPtr); ++ _11 = copy _3 as *const u32 (PtrToPtr); StorageDead(_12); - _10 = move _11 as *const u32 (PtrToPtr); - StorageDead(_11); - StorageLive(_13); -+ _10 = _11; ++ _10 = copy _11; + nop; + nop; StorageLive(_14); - _14 = _4; + _14 = copy _4; - _13 = move _14 as *const u32 (PtrToPtr); -+ _13 = _4 as *const u32 (PtrToPtr); ++ _13 = copy _4 as *const u32 (PtrToPtr); StorageDead(_14); StorageLive(_15); StorageLive(_16); - _16 = _5; + _16 = copy _5; StorageLive(_17); -- _17 = _7; +- _17 = copy _7; - _15 = Eq(move _16, move _17); -+ _17 = _8; -+ _15 = Eq(_5, _8); ++ _17 = copy _8; ++ _15 = Eq(copy _5, copy _8); StorageDead(_17); StorageDead(_16); StorageLive(_18); StorageLive(_19); -- _19 = _7; -+ _19 = _8; +- _19 = copy _7; ++ _19 = copy _8; StorageLive(_20); -- _20 = _10; +- _20 = copy _10; - _18 = Eq(move _19, move _20); -+ _20 = _11; -+ _18 = Eq(_2, _3); ++ _20 = copy _11; ++ _18 = Eq(copy _2, copy _3); StorageDead(_20); StorageDead(_19); StorageLive(_21); StorageLive(_22); -- _22 = _10; -+ _22 = _11; +- _22 = copy _10; ++ _22 = copy _11; StorageLive(_23); - _23 = _13; + _23 = copy _13; - _21 = Eq(move _22, move _23); -+ _21 = Eq(_11, _13); ++ _21 = Eq(copy _11, copy _13); StorageDead(_23); StorageDead(_22); _0 = const (); diff --git a/tests/mir-opt/gvn.cast_pointer_eq.GVN.panic-unwind.diff b/tests/mir-opt/gvn.cast_pointer_eq.GVN.panic-unwind.diff index 757ab959813a..f66aed0f4415 100644 --- a/tests/mir-opt/gvn.cast_pointer_eq.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.cast_pointer_eq.GVN.panic-unwind.diff @@ -52,70 +52,70 @@ - StorageLive(_5); + nop; StorageLive(_6); - _6 = _1; + _6 = copy _1; - _5 = move _6 as *const u32 (PtrToPtr); -+ _5 = _1 as *const u32 (PtrToPtr); ++ _5 = copy _1 as *const u32 (PtrToPtr); StorageDead(_6); StorageLive(_7); - StorageLive(_8); + nop; StorageLive(_9); - _9 = _2; + _9 = copy _2; - _8 = move _9 as *const u32 (PtrToPtr); -+ _8 = _2 as *const u32 (PtrToPtr); ++ _8 = copy _2 as *const u32 (PtrToPtr); StorageDead(_9); - _7 = move _8 as *const u32 (PtrToPtr); - StorageDead(_8); -+ _7 = _8; ++ _7 = copy _8; + nop; StorageLive(_10); - StorageLive(_11); + nop; StorageLive(_12); - _12 = _3; + _12 = copy _3; - _11 = move _12 as *const u32 (PtrToPtr); -+ _11 = _3 as *const u32 (PtrToPtr); ++ _11 = copy _3 as *const u32 (PtrToPtr); StorageDead(_12); - _10 = move _11 as *const u32 (PtrToPtr); - StorageDead(_11); - StorageLive(_13); -+ _10 = _11; ++ _10 = copy _11; + nop; + nop; StorageLive(_14); - _14 = _4; + _14 = copy _4; - _13 = move _14 as *const u32 (PtrToPtr); -+ _13 = _4 as *const u32 (PtrToPtr); ++ _13 = copy _4 as *const u32 (PtrToPtr); StorageDead(_14); StorageLive(_15); StorageLive(_16); - _16 = _5; + _16 = copy _5; StorageLive(_17); -- _17 = _7; +- _17 = copy _7; - _15 = Eq(move _16, move _17); -+ _17 = _8; -+ _15 = Eq(_5, _8); ++ _17 = copy _8; ++ _15 = Eq(copy _5, copy _8); StorageDead(_17); StorageDead(_16); StorageLive(_18); StorageLive(_19); -- _19 = _7; -+ _19 = _8; +- _19 = copy _7; ++ _19 = copy _8; StorageLive(_20); -- _20 = _10; +- _20 = copy _10; - _18 = Eq(move _19, move _20); -+ _20 = _11; -+ _18 = Eq(_2, _3); ++ _20 = copy _11; ++ _18 = Eq(copy _2, copy _3); StorageDead(_20); StorageDead(_19); StorageLive(_21); StorageLive(_22); -- _22 = _10; -+ _22 = _11; +- _22 = copy _10; ++ _22 = copy _11; StorageLive(_23); - _23 = _13; + _23 = copy _13; - _21 = Eq(move _22, move _23); -+ _21 = Eq(_11, _13); ++ _21 = Eq(copy _11, copy _13); StorageDead(_23); StorageDead(_22); _0 = const (); diff --git a/tests/mir-opt/gvn.cast_pointer_then_transmute.GVN.panic-abort.diff b/tests/mir-opt/gvn.cast_pointer_then_transmute.GVN.panic-abort.diff index 8133f6e0b007..d9f945d2c41e 100644 --- a/tests/mir-opt/gvn.cast_pointer_then_transmute.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.cast_pointer_then_transmute.GVN.panic-abort.diff @@ -22,19 +22,19 @@ StorageLive(_3); StorageLive(_4); StorageLive(_5); - _5 = _1; + _5 = copy _1; - _4 = move _5 as *const () (PtrToPtr); -+ _4 = _1 as *const () (PtrToPtr); ++ _4 = copy _1 as *const () (PtrToPtr); StorageDead(_5); - _3 = move _4 as usize (Transmute); -+ _3 = _1 as usize (Transmute); ++ _3 = copy _1 as usize (Transmute); StorageDead(_4); StorageLive(_6); StorageLive(_7); StorageLive(_8); - _8 = _2; + _8 = copy _2; - _7 = move _8 as *const () (PtrToPtr); -+ _7 = _2 as *const () (PtrToPtr); ++ _7 = copy _2 as *const () (PtrToPtr); StorageDead(_8); _6 = move _7 as usize (Transmute); StorageDead(_7); diff --git a/tests/mir-opt/gvn.cast_pointer_then_transmute.GVN.panic-unwind.diff b/tests/mir-opt/gvn.cast_pointer_then_transmute.GVN.panic-unwind.diff index 8133f6e0b007..d9f945d2c41e 100644 --- a/tests/mir-opt/gvn.cast_pointer_then_transmute.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.cast_pointer_then_transmute.GVN.panic-unwind.diff @@ -22,19 +22,19 @@ StorageLive(_3); StorageLive(_4); StorageLive(_5); - _5 = _1; + _5 = copy _1; - _4 = move _5 as *const () (PtrToPtr); -+ _4 = _1 as *const () (PtrToPtr); ++ _4 = copy _1 as *const () (PtrToPtr); StorageDead(_5); - _3 = move _4 as usize (Transmute); -+ _3 = _1 as usize (Transmute); ++ _3 = copy _1 as usize (Transmute); StorageDead(_4); StorageLive(_6); StorageLive(_7); StorageLive(_8); - _8 = _2; + _8 = copy _2; - _7 = move _8 as *const () (PtrToPtr); -+ _7 = _2 as *const () (PtrToPtr); ++ _7 = copy _2 as *const () (PtrToPtr); StorageDead(_8); _6 = move _7 as usize (Transmute); StorageDead(_7); diff --git a/tests/mir-opt/gvn.casts_before_aggregate_raw_ptr.GVN.panic-abort.diff b/tests/mir-opt/gvn.casts_before_aggregate_raw_ptr.GVN.panic-abort.diff index 6e5bdb16595b..fd09310fabde 100644 --- a/tests/mir-opt/gvn.casts_before_aggregate_raw_ptr.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.casts_before_aggregate_raw_ptr.GVN.panic-abort.diff @@ -25,28 +25,28 @@ - StorageLive(_2); + nop; StorageLive(_3); - _3 = _1; + _3 = copy _1; - _2 = move _3 as *const [u8; 4] (PtrToPtr); -+ _2 = _1 as *const [u8; 4] (PtrToPtr); ++ _2 = copy _1 as *const [u8; 4] (PtrToPtr); StorageDead(_3); - StorageLive(_4); + nop; StorageLive(_5); - _5 = _2; + _5 = copy _2; - _4 = move _5 as *const u8 (PtrToPtr); -+ _4 = _1 as *const u8 (PtrToPtr); ++ _4 = copy _1 as *const u8 (PtrToPtr); StorageDead(_5); - StorageLive(_6); + nop; StorageLive(_7); - _7 = _4; + _7 = copy _4; - _6 = move _7 as *const () (PtrToPtr); -+ _6 = _1 as *const () (PtrToPtr); ++ _6 = copy _1 as *const () (PtrToPtr); StorageDead(_7); StorageLive(_8); - _8 = _6; + _8 = copy _6; - _0 = *const [u8] from (move _8, const 4_usize); -+ _0 = *const [u8] from (_1, const 4_usize); ++ _0 = *const [u8] from (copy _1, const 4_usize); StorageDead(_8); - StorageDead(_6); - StorageDead(_4); diff --git a/tests/mir-opt/gvn.casts_before_aggregate_raw_ptr.GVN.panic-unwind.diff b/tests/mir-opt/gvn.casts_before_aggregate_raw_ptr.GVN.panic-unwind.diff index 6e5bdb16595b..fd09310fabde 100644 --- a/tests/mir-opt/gvn.casts_before_aggregate_raw_ptr.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.casts_before_aggregate_raw_ptr.GVN.panic-unwind.diff @@ -25,28 +25,28 @@ - StorageLive(_2); + nop; StorageLive(_3); - _3 = _1; + _3 = copy _1; - _2 = move _3 as *const [u8; 4] (PtrToPtr); -+ _2 = _1 as *const [u8; 4] (PtrToPtr); ++ _2 = copy _1 as *const [u8; 4] (PtrToPtr); StorageDead(_3); - StorageLive(_4); + nop; StorageLive(_5); - _5 = _2; + _5 = copy _2; - _4 = move _5 as *const u8 (PtrToPtr); -+ _4 = _1 as *const u8 (PtrToPtr); ++ _4 = copy _1 as *const u8 (PtrToPtr); StorageDead(_5); - StorageLive(_6); + nop; StorageLive(_7); - _7 = _4; + _7 = copy _4; - _6 = move _7 as *const () (PtrToPtr); -+ _6 = _1 as *const () (PtrToPtr); ++ _6 = copy _1 as *const () (PtrToPtr); StorageDead(_7); StorageLive(_8); - _8 = _6; + _8 = copy _6; - _0 = *const [u8] from (move _8, const 4_usize); -+ _0 = *const [u8] from (_1, const 4_usize); ++ _0 = *const [u8] from (copy _1, const 4_usize); StorageDead(_8); - StorageDead(_6); - StorageDead(_4); diff --git a/tests/mir-opt/gvn.comparison.GVN.panic-abort.diff b/tests/mir-opt/gvn.comparison.GVN.panic-abort.diff index fefdf14bddcd..7b25dedbb887 100644 --- a/tests/mir-opt/gvn.comparison.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.comparison.GVN.panic-abort.diff @@ -26,9 +26,9 @@ StorageLive(_3); StorageLive(_4); StorageLive(_5); - _5 = _1; + _5 = copy _1; StorageLive(_6); - _6 = _1; + _6 = copy _1; - _4 = Eq(move _5, move _6); + _4 = const true; StorageDead(_6); @@ -43,9 +43,9 @@ StorageLive(_7); StorageLive(_8); StorageLive(_9); - _9 = _1; + _9 = copy _1; StorageLive(_10); - _10 = _1; + _10 = copy _1; - _8 = Ne(move _9, move _10); + _8 = const false; StorageDead(_10); @@ -60,11 +60,11 @@ StorageLive(_11); StorageLive(_12); StorageLive(_13); - _13 = _1; + _13 = copy _1; StorageLive(_14); - _14 = _2; + _14 = copy _2; - _12 = Eq(move _13, move _14); -+ _12 = Eq(_1, _2); ++ _12 = Eq(copy _1, copy _2); StorageDead(_14); StorageDead(_13); _11 = opaque::(move _12) -> [return: bb3, unwind unreachable]; @@ -76,11 +76,11 @@ StorageLive(_15); StorageLive(_16); StorageLive(_17); - _17 = _1; + _17 = copy _1; StorageLive(_18); - _18 = _2; + _18 = copy _2; - _16 = Ne(move _17, move _18); -+ _16 = Ne(_1, _2); ++ _16 = Ne(copy _1, copy _2); StorageDead(_18); StorageDead(_17); _15 = opaque::(move _16) -> [return: bb4, unwind unreachable]; diff --git a/tests/mir-opt/gvn.comparison.GVN.panic-unwind.diff b/tests/mir-opt/gvn.comparison.GVN.panic-unwind.diff index 9f19b2b59fa5..416ae1ee5595 100644 --- a/tests/mir-opt/gvn.comparison.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.comparison.GVN.panic-unwind.diff @@ -26,9 +26,9 @@ StorageLive(_3); StorageLive(_4); StorageLive(_5); - _5 = _1; + _5 = copy _1; StorageLive(_6); - _6 = _1; + _6 = copy _1; - _4 = Eq(move _5, move _6); + _4 = const true; StorageDead(_6); @@ -43,9 +43,9 @@ StorageLive(_7); StorageLive(_8); StorageLive(_9); - _9 = _1; + _9 = copy _1; StorageLive(_10); - _10 = _1; + _10 = copy _1; - _8 = Ne(move _9, move _10); + _8 = const false; StorageDead(_10); @@ -60,11 +60,11 @@ StorageLive(_11); StorageLive(_12); StorageLive(_13); - _13 = _1; + _13 = copy _1; StorageLive(_14); - _14 = _2; + _14 = copy _2; - _12 = Eq(move _13, move _14); -+ _12 = Eq(_1, _2); ++ _12 = Eq(copy _1, copy _2); StorageDead(_14); StorageDead(_13); _11 = opaque::(move _12) -> [return: bb3, unwind continue]; @@ -76,11 +76,11 @@ StorageLive(_15); StorageLive(_16); StorageLive(_17); - _17 = _1; + _17 = copy _1; StorageLive(_18); - _18 = _2; + _18 = copy _2; - _16 = Ne(move _17, move _18); -+ _16 = Ne(_1, _2); ++ _16 = Ne(copy _1, copy _2); StorageDead(_18); StorageDead(_17); _15 = opaque::(move _16) -> [return: bb4, unwind continue]; diff --git a/tests/mir-opt/gvn.constant_index_overflow.GVN.panic-abort.diff b/tests/mir-opt/gvn.constant_index_overflow.GVN.panic-abort.diff index c417c51f9b7d..3f052ee19fdf 100644 --- a/tests/mir-opt/gvn.constant_index_overflow.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.constant_index_overflow.GVN.panic-abort.diff @@ -32,7 +32,7 @@ StorageLive(_3); StorageLive(_4); StorageLive(_5); -- _5 = _2; +- _5 = copy _2; + _5 = const usize::MAX; StorageLive(_6); StorageLive(_7); @@ -51,18 +51,18 @@ StorageDead(_6); StorageDead(_5); StorageLive(_8); -- _8 = _2; +- _8 = copy _2; + _8 = const usize::MAX; _9 = Len((*_1)); -- _10 = Lt(_8, _9); -- assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, _8) -> [success: bb3, unwind unreachable]; -+ _10 = Lt(const usize::MAX, _9); +- _10 = Lt(copy _8, copy _9); +- assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, copy _8) -> [success: bb3, unwind unreachable]; ++ _10 = Lt(const usize::MAX, copy _9); + assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, const usize::MAX) -> [success: bb3, unwind unreachable]; } bb3: { -- _3 = (*_1)[_8]; -+ _3 = (*_1)[_2]; +- _3 = copy (*_1)[_8]; ++ _3 = copy (*_1)[_2]; StorageDead(_8); goto -> bb6; } @@ -73,15 +73,15 @@ StorageLive(_11); _11 = const 0_usize; _12 = Len((*_1)); -- _13 = Lt(_11, _12); -- assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, _11) -> [success: bb5, unwind unreachable]; -+ _13 = Lt(const 0_usize, _12); +- _13 = Lt(copy _11, copy _12); +- assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, copy _11) -> [success: bb5, unwind unreachable]; ++ _13 = Lt(const 0_usize, copy _12); + assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, const 0_usize) -> [success: bb5, unwind unreachable]; } bb5: { -- _3 = (*_1)[_11]; -+ _3 = (*_1)[0 of 1]; +- _3 = copy (*_1)[_11]; ++ _3 = copy (*_1)[0 of 1]; StorageDead(_11); goto -> bb6; } @@ -89,7 +89,7 @@ bb6: { StorageDead(_4); StorageLive(_14); - _14 = _3; + _14 = copy _3; _0 = opaque::(move _14) -> [return: bb7, unwind unreachable]; } diff --git a/tests/mir-opt/gvn.constant_index_overflow.GVN.panic-unwind.diff b/tests/mir-opt/gvn.constant_index_overflow.GVN.panic-unwind.diff index 7a23fbe7cc00..84b738c7804e 100644 --- a/tests/mir-opt/gvn.constant_index_overflow.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.constant_index_overflow.GVN.panic-unwind.diff @@ -32,7 +32,7 @@ StorageLive(_3); StorageLive(_4); StorageLive(_5); -- _5 = _2; +- _5 = copy _2; + _5 = const usize::MAX; StorageLive(_6); StorageLive(_7); @@ -51,18 +51,18 @@ StorageDead(_6); StorageDead(_5); StorageLive(_8); -- _8 = _2; +- _8 = copy _2; + _8 = const usize::MAX; _9 = Len((*_1)); -- _10 = Lt(_8, _9); -- assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, _8) -> [success: bb3, unwind continue]; -+ _10 = Lt(const usize::MAX, _9); +- _10 = Lt(copy _8, copy _9); +- assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, copy _8) -> [success: bb3, unwind continue]; ++ _10 = Lt(const usize::MAX, copy _9); + assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, const usize::MAX) -> [success: bb3, unwind continue]; } bb3: { -- _3 = (*_1)[_8]; -+ _3 = (*_1)[_2]; +- _3 = copy (*_1)[_8]; ++ _3 = copy (*_1)[_2]; StorageDead(_8); goto -> bb6; } @@ -73,15 +73,15 @@ StorageLive(_11); _11 = const 0_usize; _12 = Len((*_1)); -- _13 = Lt(_11, _12); -- assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, _11) -> [success: bb5, unwind continue]; -+ _13 = Lt(const 0_usize, _12); +- _13 = Lt(copy _11, copy _12); +- assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, copy _11) -> [success: bb5, unwind continue]; ++ _13 = Lt(const 0_usize, copy _12); + assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, const 0_usize) -> [success: bb5, unwind continue]; } bb5: { -- _3 = (*_1)[_11]; -+ _3 = (*_1)[0 of 1]; +- _3 = copy (*_1)[_11]; ++ _3 = copy (*_1)[0 of 1]; StorageDead(_11); goto -> bb6; } @@ -89,7 +89,7 @@ bb6: { StorageDead(_4); StorageLive(_14); - _14 = _3; + _14 = copy _3; _0 = opaque::(move _14) -> [return: bb7, unwind continue]; } diff --git a/tests/mir-opt/gvn.dereferences.GVN.panic-abort.diff b/tests/mir-opt/gvn.dereferences.GVN.panic-abort.diff index 906835530d86..a763614dc644 100644 --- a/tests/mir-opt/gvn.dereferences.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.dereferences.GVN.panic-abort.diff @@ -48,7 +48,7 @@ bb0: { StorageLive(_4); StorageLive(_5); - _5 = (*_1); + _5 = copy (*_1); _4 = opaque::(move _5) -> [return: bb1, unwind unreachable]; } @@ -57,7 +57,7 @@ StorageDead(_4); StorageLive(_6); StorageLive(_7); - _7 = (*_1); + _7 = copy (*_1); _6 = opaque::(move _7) -> [return: bb2, unwind unreachable]; } @@ -68,7 +68,7 @@ _8 = &raw const (*_1); StorageLive(_9); StorageLive(_10); - _10 = (*_8); + _10 = copy (*_8); _9 = opaque::(move _10) -> [return: bb3, unwind unreachable]; } @@ -77,7 +77,7 @@ StorageDead(_9); StorageLive(_11); StorageLive(_12); - _12 = (*_8); + _12 = copy (*_8); _11 = opaque::(move _12) -> [return: bb4, unwind unreachable]; } @@ -88,7 +88,7 @@ _13 = &raw mut (*_1); StorageLive(_14); StorageLive(_15); - _15 = (*_13); + _15 = copy (*_13); _14 = opaque::(move _15) -> [return: bb5, unwind unreachable]; } @@ -97,7 +97,7 @@ StorageDead(_14); StorageLive(_16); StorageLive(_17); - _17 = (*_13); + _17 = copy (*_13); _16 = opaque::(move _17) -> [return: bb6, unwind unreachable]; } @@ -109,9 +109,9 @@ StorageLive(_19); - StorageLive(_20); + nop; - _20 = (*_18); + _20 = copy (*_18); - _19 = opaque::(move _20) -> [return: bb7, unwind unreachable]; -+ _19 = opaque::(_20) -> [return: bb7, unwind unreachable]; ++ _19 = opaque::(copy _20) -> [return: bb7, unwind unreachable]; } bb7: { @@ -120,10 +120,10 @@ StorageDead(_19); StorageLive(_21); StorageLive(_22); -- _22 = (*_18); +- _22 = copy (*_18); - _21 = opaque::(move _22) -> [return: bb8, unwind unreachable]; -+ _22 = _20; -+ _21 = opaque::(_20) -> [return: bb8, unwind unreachable]; ++ _22 = copy _20; ++ _21 = opaque::(copy _20) -> [return: bb8, unwind unreachable]; } bb8: { @@ -140,7 +140,7 @@ StorageDead(_23); StorageLive(_25); StorageLive(_26); - _26 = (*_2); + _26 = copy (*_2); _25 = opaque::(move _26) -> [return: bb10, unwind unreachable]; } @@ -149,7 +149,7 @@ StorageDead(_25); StorageLive(_27); StorageLive(_28); - _28 = (*_2); + _28 = copy (*_2); _27 = opaque::(move _28) -> [return: bb11, unwind unreachable]; } @@ -159,9 +159,9 @@ StorageLive(_29); - StorageLive(_30); + nop; - _30 = ((*_3).0: u32); + _30 = copy ((*_3).0: u32); - _29 = opaque::(move _30) -> [return: bb12, unwind unreachable]; -+ _29 = opaque::(_30) -> [return: bb12, unwind unreachable]; ++ _29 = opaque::(copy _30) -> [return: bb12, unwind unreachable]; } bb12: { @@ -170,10 +170,10 @@ StorageDead(_29); StorageLive(_31); StorageLive(_32); -- _32 = ((*_3).0: u32); +- _32 = copy ((*_3).0: u32); - _31 = opaque::(move _32) -> [return: bb13, unwind unreachable]; -+ _32 = _30; -+ _31 = opaque::(_30) -> [return: bb13, unwind unreachable]; ++ _32 = copy _30; ++ _31 = opaque::(copy _30) -> [return: bb13, unwind unreachable]; } bb13: { diff --git a/tests/mir-opt/gvn.dereferences.GVN.panic-unwind.diff b/tests/mir-opt/gvn.dereferences.GVN.panic-unwind.diff index 006b5da646c1..ca6fda483642 100644 --- a/tests/mir-opt/gvn.dereferences.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.dereferences.GVN.panic-unwind.diff @@ -48,7 +48,7 @@ bb0: { StorageLive(_4); StorageLive(_5); - _5 = (*_1); + _5 = copy (*_1); _4 = opaque::(move _5) -> [return: bb1, unwind continue]; } @@ -57,7 +57,7 @@ StorageDead(_4); StorageLive(_6); StorageLive(_7); - _7 = (*_1); + _7 = copy (*_1); _6 = opaque::(move _7) -> [return: bb2, unwind continue]; } @@ -68,7 +68,7 @@ _8 = &raw const (*_1); StorageLive(_9); StorageLive(_10); - _10 = (*_8); + _10 = copy (*_8); _9 = opaque::(move _10) -> [return: bb3, unwind continue]; } @@ -77,7 +77,7 @@ StorageDead(_9); StorageLive(_11); StorageLive(_12); - _12 = (*_8); + _12 = copy (*_8); _11 = opaque::(move _12) -> [return: bb4, unwind continue]; } @@ -88,7 +88,7 @@ _13 = &raw mut (*_1); StorageLive(_14); StorageLive(_15); - _15 = (*_13); + _15 = copy (*_13); _14 = opaque::(move _15) -> [return: bb5, unwind continue]; } @@ -97,7 +97,7 @@ StorageDead(_14); StorageLive(_16); StorageLive(_17); - _17 = (*_13); + _17 = copy (*_13); _16 = opaque::(move _17) -> [return: bb6, unwind continue]; } @@ -109,9 +109,9 @@ StorageLive(_19); - StorageLive(_20); + nop; - _20 = (*_18); + _20 = copy (*_18); - _19 = opaque::(move _20) -> [return: bb7, unwind continue]; -+ _19 = opaque::(_20) -> [return: bb7, unwind continue]; ++ _19 = opaque::(copy _20) -> [return: bb7, unwind continue]; } bb7: { @@ -120,10 +120,10 @@ StorageDead(_19); StorageLive(_21); StorageLive(_22); -- _22 = (*_18); +- _22 = copy (*_18); - _21 = opaque::(move _22) -> [return: bb8, unwind continue]; -+ _22 = _20; -+ _21 = opaque::(_20) -> [return: bb8, unwind continue]; ++ _22 = copy _20; ++ _21 = opaque::(copy _20) -> [return: bb8, unwind continue]; } bb8: { @@ -140,7 +140,7 @@ StorageDead(_23); StorageLive(_25); StorageLive(_26); - _26 = (*_2); + _26 = copy (*_2); _25 = opaque::(move _26) -> [return: bb10, unwind continue]; } @@ -149,7 +149,7 @@ StorageDead(_25); StorageLive(_27); StorageLive(_28); - _28 = (*_2); + _28 = copy (*_2); _27 = opaque::(move _28) -> [return: bb11, unwind continue]; } @@ -159,9 +159,9 @@ StorageLive(_29); - StorageLive(_30); + nop; - _30 = ((*_3).0: u32); + _30 = copy ((*_3).0: u32); - _29 = opaque::(move _30) -> [return: bb12, unwind continue]; -+ _29 = opaque::(_30) -> [return: bb12, unwind continue]; ++ _29 = opaque::(copy _30) -> [return: bb12, unwind continue]; } bb12: { @@ -170,10 +170,10 @@ StorageDead(_29); StorageLive(_31); StorageLive(_32); -- _32 = ((*_3).0: u32); +- _32 = copy ((*_3).0: u32); - _31 = opaque::(move _32) -> [return: bb13, unwind continue]; -+ _32 = _30; -+ _31 = opaque::(_30) -> [return: bb13, unwind continue]; ++ _32 = copy _30; ++ _31 = opaque::(copy _30) -> [return: bb13, unwind continue]; } bb13: { diff --git a/tests/mir-opt/gvn.duplicate_slice.GVN.panic-abort.diff b/tests/mir-opt/gvn.duplicate_slice.GVN.panic-abort.diff index 7ae1fae68e88..18c2897d5287 100644 --- a/tests/mir-opt/gvn.duplicate_slice.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.duplicate_slice.GVN.panic-abort.diff @@ -16,22 +16,22 @@ bb0: { _7 = (const "a",); - _1 = (_7.0: &str) as u128 (Transmute); - _5 = identity::<&str>((_7.0: &str)) -> [return: bb1, unwind unreachable]; + _1 = copy (_7.0: &str) as u128 (Transmute); + _5 = identity::<&str>(copy (_7.0: &str)) -> [return: bb1, unwind unreachable]; } bb1: { - _3 = _5 as u128 (Transmute); + _3 = copy _5 as u128 (Transmute); _8 = const "a"; - _2 = _8 as u128 (Transmute); - _6 = identity::<&str>(_8) -> [return: bb2, unwind unreachable]; + _2 = copy _8 as u128 (Transmute); + _6 = identity::<&str>(copy _8) -> [return: bb2, unwind unreachable]; } bb2: { - _4 = _6 as u128 (Transmute); - _9 = Eq(_1, _2); - _10 = Eq(_3, _4); - _0 = (_9, _10); + _4 = copy _6 as u128 (Transmute); + _9 = Eq(copy _1, copy _2); + _10 = Eq(copy _3, copy _4); + _0 = (copy _9, copy _10); return; } } diff --git a/tests/mir-opt/gvn.duplicate_slice.GVN.panic-unwind.diff b/tests/mir-opt/gvn.duplicate_slice.GVN.panic-unwind.diff index 8c96edaa280e..55f382e926e7 100644 --- a/tests/mir-opt/gvn.duplicate_slice.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.duplicate_slice.GVN.panic-unwind.diff @@ -16,22 +16,22 @@ bb0: { _7 = (const "a",); - _1 = (_7.0: &str) as u128 (Transmute); - _5 = identity::<&str>((_7.0: &str)) -> [return: bb1, unwind continue]; + _1 = copy (_7.0: &str) as u128 (Transmute); + _5 = identity::<&str>(copy (_7.0: &str)) -> [return: bb1, unwind continue]; } bb1: { - _3 = _5 as u128 (Transmute); + _3 = copy _5 as u128 (Transmute); _8 = const "a"; - _2 = _8 as u128 (Transmute); - _6 = identity::<&str>(_8) -> [return: bb2, unwind continue]; + _2 = copy _8 as u128 (Transmute); + _6 = identity::<&str>(copy _8) -> [return: bb2, unwind continue]; } bb2: { - _4 = _6 as u128 (Transmute); - _9 = Eq(_1, _2); - _10 = Eq(_3, _4); - _0 = (_9, _10); + _4 = copy _6 as u128 (Transmute); + _9 = Eq(copy _1, copy _2); + _10 = Eq(copy _3, copy _4); + _0 = (copy _9, copy _10); return; } } diff --git a/tests/mir-opt/gvn.fn_pointers.GVN.panic-abort.diff b/tests/mir-opt/gvn.fn_pointers.GVN.panic-abort.diff index b5c0cee78468..42075d11b6cd 100644 --- a/tests/mir-opt/gvn.fn_pointers.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.fn_pointers.GVN.panic-abort.diff @@ -40,9 +40,9 @@ _1 = identity:: as fn(u8) -> u8 (PointerCoercion(ReifyFnPointer)); StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; - _2 = opaque:: u8>(move _3) -> [return: bb1, unwind unreachable]; -+ _2 = opaque:: u8>(_1) -> [return: bb1, unwind unreachable]; ++ _2 = opaque:: u8>(copy _1) -> [return: bb1, unwind unreachable]; } bb1: { @@ -53,9 +53,9 @@ _4 = identity:: as fn(u8) -> u8 (PointerCoercion(ReifyFnPointer)); StorageLive(_5); StorageLive(_6); - _6 = _4; + _6 = copy _4; - _5 = opaque:: u8>(move _6) -> [return: bb2, unwind unreachable]; -+ _5 = opaque:: u8>(_4) -> [return: bb2, unwind unreachable]; ++ _5 = opaque:: u8>(copy _4) -> [return: bb2, unwind unreachable]; } bb2: { @@ -68,16 +68,16 @@ + _7 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21}; + nop; StorageLive(_9); -- _9 = _7; +- _9 = copy _7; - _8 = move _9 as fn() (PointerCoercion(ClosureFnPointer(Safe))); + _9 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21}; + _8 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21} as fn() (PointerCoercion(ClosureFnPointer(Safe))); StorageDead(_9); StorageLive(_10); StorageLive(_11); - _11 = _8; + _11 = copy _8; - _10 = opaque::(move _11) -> [return: bb3, unwind unreachable]; -+ _10 = opaque::(_8) -> [return: bb3, unwind unreachable]; ++ _10 = opaque::(copy _8) -> [return: bb3, unwind unreachable]; } bb3: { @@ -86,16 +86,16 @@ - StorageLive(_12); + nop; StorageLive(_13); -- _13 = _7; +- _13 = copy _7; - _12 = move _13 as fn() (PointerCoercion(ClosureFnPointer(Safe))); + _13 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21}; + _12 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21} as fn() (PointerCoercion(ClosureFnPointer(Safe))); StorageDead(_13); StorageLive(_14); StorageLive(_15); - _15 = _12; + _15 = copy _12; - _14 = opaque::(move _15) -> [return: bb4, unwind unreachable]; -+ _14 = opaque::(_12) -> [return: bb4, unwind unreachable]; ++ _14 = opaque::(copy _12) -> [return: bb4, unwind unreachable]; } bb4: { diff --git a/tests/mir-opt/gvn.fn_pointers.GVN.panic-unwind.diff b/tests/mir-opt/gvn.fn_pointers.GVN.panic-unwind.diff index 7bc6573c13d4..f6ad045bbfa0 100644 --- a/tests/mir-opt/gvn.fn_pointers.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.fn_pointers.GVN.panic-unwind.diff @@ -40,9 +40,9 @@ _1 = identity:: as fn(u8) -> u8 (PointerCoercion(ReifyFnPointer)); StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; - _2 = opaque:: u8>(move _3) -> [return: bb1, unwind continue]; -+ _2 = opaque:: u8>(_1) -> [return: bb1, unwind continue]; ++ _2 = opaque:: u8>(copy _1) -> [return: bb1, unwind continue]; } bb1: { @@ -53,9 +53,9 @@ _4 = identity:: as fn(u8) -> u8 (PointerCoercion(ReifyFnPointer)); StorageLive(_5); StorageLive(_6); - _6 = _4; + _6 = copy _4; - _5 = opaque:: u8>(move _6) -> [return: bb2, unwind continue]; -+ _5 = opaque:: u8>(_4) -> [return: bb2, unwind continue]; ++ _5 = opaque:: u8>(copy _4) -> [return: bb2, unwind continue]; } bb2: { @@ -68,16 +68,16 @@ + _7 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21}; + nop; StorageLive(_9); -- _9 = _7; +- _9 = copy _7; - _8 = move _9 as fn() (PointerCoercion(ClosureFnPointer(Safe))); + _9 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21}; + _8 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21} as fn() (PointerCoercion(ClosureFnPointer(Safe))); StorageDead(_9); StorageLive(_10); StorageLive(_11); - _11 = _8; + _11 = copy _8; - _10 = opaque::(move _11) -> [return: bb3, unwind continue]; -+ _10 = opaque::(_8) -> [return: bb3, unwind continue]; ++ _10 = opaque::(copy _8) -> [return: bb3, unwind continue]; } bb3: { @@ -86,16 +86,16 @@ - StorageLive(_12); + nop; StorageLive(_13); -- _13 = _7; +- _13 = copy _7; - _12 = move _13 as fn() (PointerCoercion(ClosureFnPointer(Safe))); + _13 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21}; + _12 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21} as fn() (PointerCoercion(ClosureFnPointer(Safe))); StorageDead(_13); StorageLive(_14); StorageLive(_15); - _15 = _12; + _15 = copy _12; - _14 = opaque::(move _15) -> [return: bb4, unwind continue]; -+ _14 = opaque::(_12) -> [return: bb4, unwind continue]; ++ _14 = opaque::(copy _12) -> [return: bb4, unwind continue]; } bb4: { diff --git a/tests/mir-opt/gvn.generic_cast_metadata.GVN.panic-abort.diff b/tests/mir-opt/gvn.generic_cast_metadata.GVN.panic-abort.diff index 1d462a8a23c2..770c67307753 100644 --- a/tests/mir-opt/gvn.generic_cast_metadata.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.generic_cast_metadata.GVN.panic-abort.diff @@ -17,21 +17,21 @@ let mut _15: ::Metadata; bb0: { - _4 = _1 as *const T (PtrToPtr); - _5 = PtrMetadata(_4); - _6 = _1 as *const (&A, [T]) (PtrToPtr); -- _7 = PtrMetadata(_6); -+ _7 = PtrMetadata(_1); - _8 = _2 as *const (T, B) (PtrToPtr); - _9 = PtrMetadata(_8); - _10 = _2 as *const (T, A) (PtrToPtr); -- _11 = PtrMetadata(_10); -+ _11 = PtrMetadata(_2); - _12 = _3 as *mut A (PtrToPtr); - _13 = PtrMetadata(_12); - _14 = _3 as *mut B (PtrToPtr); -- _15 = PtrMetadata(_14); -+ _15 = PtrMetadata(_3); + _4 = copy _1 as *const T (PtrToPtr); + _5 = PtrMetadata(copy _4); + _6 = copy _1 as *const (&A, [T]) (PtrToPtr); +- _7 = PtrMetadata(copy _6); ++ _7 = PtrMetadata(copy _1); + _8 = copy _2 as *const (T, B) (PtrToPtr); + _9 = PtrMetadata(copy _8); + _10 = copy _2 as *const (T, A) (PtrToPtr); +- _11 = PtrMetadata(copy _10); ++ _11 = PtrMetadata(copy _2); + _12 = copy _3 as *mut A (PtrToPtr); + _13 = PtrMetadata(copy _12); + _14 = copy _3 as *mut B (PtrToPtr); +- _15 = PtrMetadata(copy _14); ++ _15 = PtrMetadata(copy _3); return; } } diff --git a/tests/mir-opt/gvn.generic_cast_metadata.GVN.panic-unwind.diff b/tests/mir-opt/gvn.generic_cast_metadata.GVN.panic-unwind.diff index 1d462a8a23c2..770c67307753 100644 --- a/tests/mir-opt/gvn.generic_cast_metadata.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.generic_cast_metadata.GVN.panic-unwind.diff @@ -17,21 +17,21 @@ let mut _15: ::Metadata; bb0: { - _4 = _1 as *const T (PtrToPtr); - _5 = PtrMetadata(_4); - _6 = _1 as *const (&A, [T]) (PtrToPtr); -- _7 = PtrMetadata(_6); -+ _7 = PtrMetadata(_1); - _8 = _2 as *const (T, B) (PtrToPtr); - _9 = PtrMetadata(_8); - _10 = _2 as *const (T, A) (PtrToPtr); -- _11 = PtrMetadata(_10); -+ _11 = PtrMetadata(_2); - _12 = _3 as *mut A (PtrToPtr); - _13 = PtrMetadata(_12); - _14 = _3 as *mut B (PtrToPtr); -- _15 = PtrMetadata(_14); -+ _15 = PtrMetadata(_3); + _4 = copy _1 as *const T (PtrToPtr); + _5 = PtrMetadata(copy _4); + _6 = copy _1 as *const (&A, [T]) (PtrToPtr); +- _7 = PtrMetadata(copy _6); ++ _7 = PtrMetadata(copy _1); + _8 = copy _2 as *const (T, B) (PtrToPtr); + _9 = PtrMetadata(copy _8); + _10 = copy _2 as *const (T, A) (PtrToPtr); +- _11 = PtrMetadata(copy _10); ++ _11 = PtrMetadata(copy _2); + _12 = copy _3 as *mut A (PtrToPtr); + _13 = PtrMetadata(copy _12); + _14 = copy _3 as *mut B (PtrToPtr); +- _15 = PtrMetadata(copy _14); ++ _15 = PtrMetadata(copy _3); return; } } diff --git a/tests/mir-opt/gvn.indirect_static.GVN.panic-abort.diff b/tests/mir-opt/gvn.indirect_static.GVN.panic-abort.diff index e84f91e495d9..97f41f89fb24 100644 --- a/tests/mir-opt/gvn.indirect_static.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.indirect_static.GVN.panic-abort.diff @@ -8,7 +8,7 @@ bb0: { _1 = const {ALLOC0: &Option}; - _2 = (((*_1) as variant#1).0: u8); + _2 = copy (((*_1) as variant#1).0: u8); return; } } diff --git a/tests/mir-opt/gvn.indirect_static.GVN.panic-unwind.diff b/tests/mir-opt/gvn.indirect_static.GVN.panic-unwind.diff index e84f91e495d9..97f41f89fb24 100644 --- a/tests/mir-opt/gvn.indirect_static.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.indirect_static.GVN.panic-unwind.diff @@ -8,7 +8,7 @@ bb0: { _1 = const {ALLOC0: &Option}; - _2 = (((*_1) as variant#1).0: u8); + _2 = copy (((*_1) as variant#1).0: u8); return; } } diff --git a/tests/mir-opt/gvn.manual_slice_mut_len.GVN.panic-abort.diff b/tests/mir-opt/gvn.manual_slice_mut_len.GVN.panic-abort.diff index c877d8a3c0e5..936fa3db82a7 100644 --- a/tests/mir-opt/gvn.manual_slice_mut_len.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.manual_slice_mut_len.GVN.panic-abort.diff @@ -22,14 +22,14 @@ - StorageLive(_3); + nop; StorageLive(_4); - _4 = _2; + _4 = copy _2; - _3 = move _4 as *const [i32] (PtrToPtr); -+ _3 = _2 as *const [i32] (PtrToPtr); ++ _3 = copy _2 as *const [i32] (PtrToPtr); StorageDead(_4); StorageLive(_5); - _5 = _3; + _5 = copy _3; - _0 = PtrMetadata(move _5); -+ _0 = PtrMetadata(_1); ++ _0 = PtrMetadata(copy _1); StorageDead(_5); - StorageDead(_3); - StorageDead(_2); diff --git a/tests/mir-opt/gvn.manual_slice_mut_len.GVN.panic-unwind.diff b/tests/mir-opt/gvn.manual_slice_mut_len.GVN.panic-unwind.diff index c877d8a3c0e5..936fa3db82a7 100644 --- a/tests/mir-opt/gvn.manual_slice_mut_len.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.manual_slice_mut_len.GVN.panic-unwind.diff @@ -22,14 +22,14 @@ - StorageLive(_3); + nop; StorageLive(_4); - _4 = _2; + _4 = copy _2; - _3 = move _4 as *const [i32] (PtrToPtr); -+ _3 = _2 as *const [i32] (PtrToPtr); ++ _3 = copy _2 as *const [i32] (PtrToPtr); StorageDead(_4); StorageLive(_5); - _5 = _3; + _5 = copy _3; - _0 = PtrMetadata(move _5); -+ _0 = PtrMetadata(_1); ++ _0 = PtrMetadata(copy _1); StorageDead(_5); - StorageDead(_3); - StorageDead(_2); diff --git a/tests/mir-opt/gvn.meta_of_ref_to_slice.GVN.panic-abort.diff b/tests/mir-opt/gvn.meta_of_ref_to_slice.GVN.panic-abort.diff index 73dbabb56b35..3ed6c2b5308f 100644 --- a/tests/mir-opt/gvn.meta_of_ref_to_slice.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.meta_of_ref_to_slice.GVN.panic-abort.diff @@ -15,12 +15,12 @@ - StorageLive(_2); + nop; StorageLive(_3); - _3 = _1; + _3 = copy _1; - _2 = *const [i32] from (move _3, const 1_usize); -+ _2 = *const [i32] from (_1, const 1_usize); ++ _2 = *const [i32] from (copy _1, const 1_usize); StorageDead(_3); StorageLive(_4); - _4 = _2; + _4 = copy _2; - _0 = PtrMetadata(move _4); + _0 = const 1_usize; StorageDead(_4); diff --git a/tests/mir-opt/gvn.meta_of_ref_to_slice.GVN.panic-unwind.diff b/tests/mir-opt/gvn.meta_of_ref_to_slice.GVN.panic-unwind.diff index 73dbabb56b35..3ed6c2b5308f 100644 --- a/tests/mir-opt/gvn.meta_of_ref_to_slice.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.meta_of_ref_to_slice.GVN.panic-unwind.diff @@ -15,12 +15,12 @@ - StorageLive(_2); + nop; StorageLive(_3); - _3 = _1; + _3 = copy _1; - _2 = *const [i32] from (move _3, const 1_usize); -+ _2 = *const [i32] from (_1, const 1_usize); ++ _2 = *const [i32] from (copy _1, const 1_usize); StorageDead(_3); StorageLive(_4); - _4 = _2; + _4 = copy _2; - _0 = PtrMetadata(move _4); + _0 = const 1_usize; StorageDead(_4); diff --git a/tests/mir-opt/gvn.multiple_branches.GVN.panic-abort.diff b/tests/mir-opt/gvn.multiple_branches.GVN.panic-abort.diff index 29ca1ba5902e..f300ce7e8846 100644 --- a/tests/mir-opt/gvn.multiple_branches.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.multiple_branches.GVN.panic-abort.diff @@ -41,9 +41,9 @@ bb0: { StorageLive(_4); StorageLive(_5); - _5 = _1; + _5 = copy _1; - switchInt(move _5) -> [0: bb4, otherwise: bb1]; -+ switchInt(_1) -> [0: bb4, otherwise: bb1]; ++ switchInt(copy _1) -> [0: bb4, otherwise: bb1]; } bb1: { @@ -51,15 +51,15 @@ - StorageLive(_7); + nop; StorageLive(_8); - _8 = _2; + _8 = copy _2; StorageLive(_9); - _9 = _3; + _9 = copy _3; - _7 = Add(move _8, move _9); -+ _7 = Add(_2, _3); ++ _7 = Add(copy _2, copy _3); StorageDead(_9); StorageDead(_8); - _6 = opaque::(move _7) -> [return: bb2, unwind unreachable]; -+ _6 = opaque::(_7) -> [return: bb2, unwind unreachable]; ++ _6 = opaque::(copy _7) -> [return: bb2, unwind unreachable]; } bb2: { @@ -69,15 +69,15 @@ StorageLive(_10); StorageLive(_11); StorageLive(_12); - _12 = _2; + _12 = copy _2; StorageLive(_13); - _13 = _3; + _13 = copy _3; - _11 = Add(move _12, move _13); -+ _11 = _7; ++ _11 = copy _7; StorageDead(_13); StorageDead(_12); - _10 = opaque::(move _11) -> [return: bb3, unwind unreachable]; -+ _10 = opaque::(_7) -> [return: bb3, unwind unreachable]; ++ _10 = opaque::(copy _7) -> [return: bb3, unwind unreachable]; } bb3: { @@ -92,15 +92,15 @@ - StorageLive(_15); + nop; StorageLive(_16); - _16 = _2; + _16 = copy _2; StorageLive(_17); - _17 = _3; + _17 = copy _3; - _15 = Add(move _16, move _17); -+ _15 = Add(_2, _3); ++ _15 = Add(copy _2, copy _3); StorageDead(_17); StorageDead(_16); - _14 = opaque::(move _15) -> [return: bb5, unwind unreachable]; -+ _14 = opaque::(_15) -> [return: bb5, unwind unreachable]; ++ _14 = opaque::(copy _15) -> [return: bb5, unwind unreachable]; } bb5: { @@ -110,15 +110,15 @@ StorageLive(_18); StorageLive(_19); StorageLive(_20); - _20 = _2; + _20 = copy _2; StorageLive(_21); - _21 = _3; + _21 = copy _3; - _19 = Add(move _20, move _21); -+ _19 = _15; ++ _19 = copy _15; StorageDead(_21); StorageDead(_20); - _18 = opaque::(move _19) -> [return: bb6, unwind unreachable]; -+ _18 = opaque::(_15) -> [return: bb6, unwind unreachable]; ++ _18 = opaque::(copy _15) -> [return: bb6, unwind unreachable]; } bb6: { @@ -135,15 +135,15 @@ - StorageLive(_23); + nop; StorageLive(_24); - _24 = _2; + _24 = copy _2; StorageLive(_25); - _25 = _3; + _25 = copy _3; - _23 = Add(move _24, move _25); -+ _23 = Add(_2, _3); ++ _23 = Add(copy _2, copy _3); StorageDead(_25); StorageDead(_24); - _22 = opaque::(move _23) -> [return: bb8, unwind unreachable]; -+ _22 = opaque::(_23) -> [return: bb8, unwind unreachable]; ++ _22 = opaque::(copy _23) -> [return: bb8, unwind unreachable]; } bb8: { @@ -151,24 +151,24 @@ + nop; StorageDead(_22); StorageLive(_26); - _26 = _1; + _26 = copy _1; - switchInt(move _26) -> [0: bb11, otherwise: bb9]; -+ switchInt(_1) -> [0: bb11, otherwise: bb9]; ++ switchInt(copy _1) -> [0: bb11, otherwise: bb9]; } bb9: { StorageLive(_27); StorageLive(_28); StorageLive(_29); - _29 = _2; + _29 = copy _2; StorageLive(_30); - _30 = _3; + _30 = copy _3; - _28 = Add(move _29, move _30); -+ _28 = _23; ++ _28 = copy _23; StorageDead(_30); StorageDead(_29); - _27 = opaque::(move _28) -> [return: bb10, unwind unreachable]; -+ _27 = opaque::(_23) -> [return: bb10, unwind unreachable]; ++ _27 = opaque::(copy _23) -> [return: bb10, unwind unreachable]; } bb10: { @@ -182,15 +182,15 @@ StorageLive(_31); StorageLive(_32); StorageLive(_33); - _33 = _2; + _33 = copy _2; StorageLive(_34); - _34 = _3; + _34 = copy _3; - _32 = Add(move _33, move _34); -+ _32 = _23; ++ _32 = copy _23; StorageDead(_34); StorageDead(_33); - _31 = opaque::(move _32) -> [return: bb12, unwind unreachable]; -+ _31 = opaque::(_23) -> [return: bb12, unwind unreachable]; ++ _31 = opaque::(copy _23) -> [return: bb12, unwind unreachable]; } bb12: { diff --git a/tests/mir-opt/gvn.multiple_branches.GVN.panic-unwind.diff b/tests/mir-opt/gvn.multiple_branches.GVN.panic-unwind.diff index 5394dc8be8a0..f34765534cc8 100644 --- a/tests/mir-opt/gvn.multiple_branches.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.multiple_branches.GVN.panic-unwind.diff @@ -41,9 +41,9 @@ bb0: { StorageLive(_4); StorageLive(_5); - _5 = _1; + _5 = copy _1; - switchInt(move _5) -> [0: bb4, otherwise: bb1]; -+ switchInt(_1) -> [0: bb4, otherwise: bb1]; ++ switchInt(copy _1) -> [0: bb4, otherwise: bb1]; } bb1: { @@ -51,15 +51,15 @@ - StorageLive(_7); + nop; StorageLive(_8); - _8 = _2; + _8 = copy _2; StorageLive(_9); - _9 = _3; + _9 = copy _3; - _7 = Add(move _8, move _9); -+ _7 = Add(_2, _3); ++ _7 = Add(copy _2, copy _3); StorageDead(_9); StorageDead(_8); - _6 = opaque::(move _7) -> [return: bb2, unwind continue]; -+ _6 = opaque::(_7) -> [return: bb2, unwind continue]; ++ _6 = opaque::(copy _7) -> [return: bb2, unwind continue]; } bb2: { @@ -69,15 +69,15 @@ StorageLive(_10); StorageLive(_11); StorageLive(_12); - _12 = _2; + _12 = copy _2; StorageLive(_13); - _13 = _3; + _13 = copy _3; - _11 = Add(move _12, move _13); -+ _11 = _7; ++ _11 = copy _7; StorageDead(_13); StorageDead(_12); - _10 = opaque::(move _11) -> [return: bb3, unwind continue]; -+ _10 = opaque::(_7) -> [return: bb3, unwind continue]; ++ _10 = opaque::(copy _7) -> [return: bb3, unwind continue]; } bb3: { @@ -92,15 +92,15 @@ - StorageLive(_15); + nop; StorageLive(_16); - _16 = _2; + _16 = copy _2; StorageLive(_17); - _17 = _3; + _17 = copy _3; - _15 = Add(move _16, move _17); -+ _15 = Add(_2, _3); ++ _15 = Add(copy _2, copy _3); StorageDead(_17); StorageDead(_16); - _14 = opaque::(move _15) -> [return: bb5, unwind continue]; -+ _14 = opaque::(_15) -> [return: bb5, unwind continue]; ++ _14 = opaque::(copy _15) -> [return: bb5, unwind continue]; } bb5: { @@ -110,15 +110,15 @@ StorageLive(_18); StorageLive(_19); StorageLive(_20); - _20 = _2; + _20 = copy _2; StorageLive(_21); - _21 = _3; + _21 = copy _3; - _19 = Add(move _20, move _21); -+ _19 = _15; ++ _19 = copy _15; StorageDead(_21); StorageDead(_20); - _18 = opaque::(move _19) -> [return: bb6, unwind continue]; -+ _18 = opaque::(_15) -> [return: bb6, unwind continue]; ++ _18 = opaque::(copy _15) -> [return: bb6, unwind continue]; } bb6: { @@ -135,15 +135,15 @@ - StorageLive(_23); + nop; StorageLive(_24); - _24 = _2; + _24 = copy _2; StorageLive(_25); - _25 = _3; + _25 = copy _3; - _23 = Add(move _24, move _25); -+ _23 = Add(_2, _3); ++ _23 = Add(copy _2, copy _3); StorageDead(_25); StorageDead(_24); - _22 = opaque::(move _23) -> [return: bb8, unwind continue]; -+ _22 = opaque::(_23) -> [return: bb8, unwind continue]; ++ _22 = opaque::(copy _23) -> [return: bb8, unwind continue]; } bb8: { @@ -151,24 +151,24 @@ + nop; StorageDead(_22); StorageLive(_26); - _26 = _1; + _26 = copy _1; - switchInt(move _26) -> [0: bb11, otherwise: bb9]; -+ switchInt(_1) -> [0: bb11, otherwise: bb9]; ++ switchInt(copy _1) -> [0: bb11, otherwise: bb9]; } bb9: { StorageLive(_27); StorageLive(_28); StorageLive(_29); - _29 = _2; + _29 = copy _2; StorageLive(_30); - _30 = _3; + _30 = copy _3; - _28 = Add(move _29, move _30); -+ _28 = _23; ++ _28 = copy _23; StorageDead(_30); StorageDead(_29); - _27 = opaque::(move _28) -> [return: bb10, unwind continue]; -+ _27 = opaque::(_23) -> [return: bb10, unwind continue]; ++ _27 = opaque::(copy _23) -> [return: bb10, unwind continue]; } bb10: { @@ -182,15 +182,15 @@ StorageLive(_31); StorageLive(_32); StorageLive(_33); - _33 = _2; + _33 = copy _2; StorageLive(_34); - _34 = _3; + _34 = copy _3; - _32 = Add(move _33, move _34); -+ _32 = _23; ++ _32 = copy _23; StorageDead(_34); StorageDead(_33); - _31 = opaque::(move _32) -> [return: bb12, unwind continue]; -+ _31 = opaque::(_23) -> [return: bb12, unwind continue]; ++ _31 = opaque::(copy _23) -> [return: bb12, unwind continue]; } bb12: { diff --git a/tests/mir-opt/gvn.non_freeze.GVN.panic-abort.diff b/tests/mir-opt/gvn.non_freeze.GVN.panic-abort.diff index 7b6ed0961184..377b4d7670cd 100644 --- a/tests/mir-opt/gvn.non_freeze.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.non_freeze.GVN.panic-abort.diff @@ -7,17 +7,17 @@ let mut _3: &T; bb0: { - _2 = _1; + _2 = copy _1; _3 = &_1; - _0 = opaque::<&T>(_3) -> [return: bb1, unwind unreachable]; + _0 = opaque::<&T>(copy _3) -> [return: bb1, unwind unreachable]; } bb1: { - _0 = opaque::(_2) -> [return: bb2, unwind unreachable]; + _0 = opaque::(copy _2) -> [return: bb2, unwind unreachable]; } bb2: { - _0 = opaque::((*_3)) -> [return: bb3, unwind unreachable]; + _0 = opaque::(copy (*_3)) -> [return: bb3, unwind unreachable]; } bb3: { diff --git a/tests/mir-opt/gvn.non_freeze.GVN.panic-unwind.diff b/tests/mir-opt/gvn.non_freeze.GVN.panic-unwind.diff index 641a2f4609ac..988eee07cc98 100644 --- a/tests/mir-opt/gvn.non_freeze.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.non_freeze.GVN.panic-unwind.diff @@ -7,17 +7,17 @@ let mut _3: &T; bb0: { - _2 = _1; + _2 = copy _1; _3 = &_1; - _0 = opaque::<&T>(_3) -> [return: bb1, unwind continue]; + _0 = opaque::<&T>(copy _3) -> [return: bb1, unwind continue]; } bb1: { - _0 = opaque::(_2) -> [return: bb2, unwind continue]; + _0 = opaque::(copy _2) -> [return: bb2, unwind continue]; } bb2: { - _0 = opaque::((*_3)) -> [return: bb3, unwind continue]; + _0 = opaque::(copy (*_3)) -> [return: bb3, unwind continue]; } bb3: { diff --git a/tests/mir-opt/gvn.references.GVN.panic-abort.diff b/tests/mir-opt/gvn.references.GVN.panic-abort.diff index 7799c6114452..62a487dee821 100644 --- a/tests/mir-opt/gvn.references.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.references.GVN.panic-abort.diff @@ -120,11 +120,11 @@ StorageLive(_21); - _21 = move _18; - _20 = S::<&mut impl Sized>(move _21); -+ _21 = _18; -+ _20 = S::<&mut impl Sized>(_18); ++ _21 = copy _18; ++ _20 = S::<&mut impl Sized>(copy _18); StorageDead(_21); - _19 = move (_20.0: &mut impl Sized); -+ _19 = _18; ++ _19 = copy _18; StorageDead(_20); StorageLive(_22); StorageLive(_23); diff --git a/tests/mir-opt/gvn.references.GVN.panic-unwind.diff b/tests/mir-opt/gvn.references.GVN.panic-unwind.diff index 880e7913fa94..6dd986907fcc 100644 --- a/tests/mir-opt/gvn.references.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.references.GVN.panic-unwind.diff @@ -120,11 +120,11 @@ StorageLive(_21); - _21 = move _18; - _20 = S::<&mut impl Sized>(move _21); -+ _21 = _18; -+ _20 = S::<&mut impl Sized>(_18); ++ _21 = copy _18; ++ _20 = S::<&mut impl Sized>(copy _18); StorageDead(_21); - _19 = move (_20.0: &mut impl Sized); -+ _19 = _18; ++ _19 = copy _18; StorageDead(_20); StorageLive(_22); StorageLive(_23); diff --git a/tests/mir-opt/gvn.remove_casts_must_change_both_sides.GVN.panic-abort.diff b/tests/mir-opt/gvn.remove_casts_must_change_both_sides.GVN.panic-abort.diff index 8b4bfb70401b..98cb34810bc0 100644 --- a/tests/mir-opt/gvn.remove_casts_must_change_both_sides.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.remove_casts_must_change_both_sides.GVN.panic-abort.diff @@ -7,9 +7,9 @@ let mut _4: *const u8; bb0: { - _3 = (*_1) as *const u8 (PtrToPtr); - _4 = _2 as *const u8 (PtrToPtr); - _0 = Eq(_3, _4); + _3 = copy (*_1) as *const u8 (PtrToPtr); + _4 = copy _2 as *const u8 (PtrToPtr); + _0 = Eq(copy _3, copy _4); return; } } diff --git a/tests/mir-opt/gvn.remove_casts_must_change_both_sides.GVN.panic-unwind.diff b/tests/mir-opt/gvn.remove_casts_must_change_both_sides.GVN.panic-unwind.diff index 8b4bfb70401b..98cb34810bc0 100644 --- a/tests/mir-opt/gvn.remove_casts_must_change_both_sides.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.remove_casts_must_change_both_sides.GVN.panic-unwind.diff @@ -7,9 +7,9 @@ let mut _4: *const u8; bb0: { - _3 = (*_1) as *const u8 (PtrToPtr); - _4 = _2 as *const u8 (PtrToPtr); - _0 = Eq(_3, _4); + _3 = copy (*_1) as *const u8 (PtrToPtr); + _4 = copy _2 as *const u8 (PtrToPtr); + _0 = Eq(copy _3, copy _4); return; } } diff --git a/tests/mir-opt/gvn.repeat.GVN.panic-abort.diff b/tests/mir-opt/gvn.repeat.GVN.panic-abort.diff index 37915f8578d2..ef2eb1a66779 100644 --- a/tests/mir-opt/gvn.repeat.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.repeat.GVN.panic-abort.diff @@ -28,34 +28,34 @@ _1 = const 5_i32; StorageLive(_2); StorageLive(_3); -- _3 = _1; +- _3 = copy _1; + _3 = const 5_i32; StorageLive(_4); -- _4 = _1; +- _4 = copy _1; + _4 = const 5_i32; StorageLive(_5); -- _5 = _1; +- _5 = copy _1; + _5 = const 5_i32; StorageLive(_6); -- _6 = _1; +- _6 = copy _1; + _6 = const 5_i32; StorageLive(_7); -- _7 = _1; +- _7 = copy _1; + _7 = const 5_i32; StorageLive(_8); -- _8 = _1; +- _8 = copy _1; + _8 = const 5_i32; StorageLive(_9); -- _9 = _1; +- _9 = copy _1; + _9 = const 5_i32; StorageLive(_10); -- _10 = _1; +- _10 = copy _1; + _10 = const 5_i32; StorageLive(_11); -- _11 = _1; +- _11 = copy _1; + _11 = const 5_i32; StorageLive(_12); -- _12 = _1; +- _12 = copy _1; - _2 = [move _3, move _4, move _5, move _6, move _7, move _8, move _9, move _10, move _11, move _12]; + _12 = const 5_i32; + _2 = [const 5_i32; 10]; diff --git a/tests/mir-opt/gvn.repeat.GVN.panic-unwind.diff b/tests/mir-opt/gvn.repeat.GVN.panic-unwind.diff index 37915f8578d2..ef2eb1a66779 100644 --- a/tests/mir-opt/gvn.repeat.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.repeat.GVN.panic-unwind.diff @@ -28,34 +28,34 @@ _1 = const 5_i32; StorageLive(_2); StorageLive(_3); -- _3 = _1; +- _3 = copy _1; + _3 = const 5_i32; StorageLive(_4); -- _4 = _1; +- _4 = copy _1; + _4 = const 5_i32; StorageLive(_5); -- _5 = _1; +- _5 = copy _1; + _5 = const 5_i32; StorageLive(_6); -- _6 = _1; +- _6 = copy _1; + _6 = const 5_i32; StorageLive(_7); -- _7 = _1; +- _7 = copy _1; + _7 = const 5_i32; StorageLive(_8); -- _8 = _1; +- _8 = copy _1; + _8 = const 5_i32; StorageLive(_9); -- _9 = _1; +- _9 = copy _1; + _9 = const 5_i32; StorageLive(_10); -- _10 = _1; +- _10 = copy _1; + _10 = const 5_i32; StorageLive(_11); -- _11 = _1; +- _11 = copy _1; + _11 = const 5_i32; StorageLive(_12); -- _12 = _1; +- _12 = copy _1; - _2 = [move _3, move _4, move _5, move _6, move _7, move _8, move _9, move _10, move _11, move _12]; + _12 = const 5_i32; + _2 = [const 5_i32; 10]; diff --git a/tests/mir-opt/gvn.repeated_index.GVN.panic-abort.diff b/tests/mir-opt/gvn.repeated_index.GVN.panic-abort.diff index 8ce05c9b340f..d4b22d05f6c7 100644 --- a/tests/mir-opt/gvn.repeated_index.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.repeated_index.GVN.panic-abort.diff @@ -24,27 +24,27 @@ bb0: { StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; - _3 = [move _4; N]; -+ _3 = [_1; N]; ++ _3 = [copy _1; N]; StorageDead(_4); StorageLive(_5); StorageLive(_6); StorageLive(_7); _7 = const 0_usize; - _8 = Len(_3); -- _9 = Lt(_7, _8); -- assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, _7) -> [success: bb1, unwind unreachable]; +- _9 = Lt(copy _7, copy _8); +- assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, copy _7) -> [success: bb1, unwind unreachable]; + _8 = const N; + _9 = Lt(const 0_usize, const N); + assert(move _9, "index out of bounds: the length is {} but the index is {}", const N, const 0_usize) -> [success: bb1, unwind unreachable]; } bb1: { -- _6 = _3[_7]; +- _6 = copy _3[_7]; - _5 = opaque::(move _6) -> [return: bb2, unwind unreachable]; -+ _6 = _1; -+ _5 = opaque::(_1) -> [return: bb2, unwind unreachable]; ++ _6 = copy _1; ++ _5 = opaque::(copy _1) -> [return: bb2, unwind unreachable]; } bb2: { @@ -54,20 +54,20 @@ StorageLive(_10); StorageLive(_11); StorageLive(_12); - _12 = _2; + _12 = copy _2; - _13 = Len(_3); -- _14 = Lt(_12, _13); -- assert(move _14, "index out of bounds: the length is {} but the index is {}", move _13, _12) -> [success: bb3, unwind unreachable]; +- _14 = Lt(copy _12, copy _13); +- assert(move _14, "index out of bounds: the length is {} but the index is {}", move _13, copy _12) -> [success: bb3, unwind unreachable]; + _13 = const N; -+ _14 = Lt(_2, const N); -+ assert(move _14, "index out of bounds: the length is {} but the index is {}", const N, _2) -> [success: bb3, unwind unreachable]; ++ _14 = Lt(copy _2, const N); ++ assert(move _14, "index out of bounds: the length is {} but the index is {}", const N, copy _2) -> [success: bb3, unwind unreachable]; } bb3: { -- _11 = _3[_12]; +- _11 = copy _3[_12]; - _10 = opaque::(move _11) -> [return: bb4, unwind unreachable]; -+ _11 = _1; -+ _10 = opaque::(_1) -> [return: bb4, unwind unreachable]; ++ _11 = copy _1; ++ _10 = opaque::(copy _1) -> [return: bb4, unwind unreachable]; } bb4: { diff --git a/tests/mir-opt/gvn.repeated_index.GVN.panic-unwind.diff b/tests/mir-opt/gvn.repeated_index.GVN.panic-unwind.diff index 7ed547eeb4ad..708c0f92e542 100644 --- a/tests/mir-opt/gvn.repeated_index.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.repeated_index.GVN.panic-unwind.diff @@ -24,27 +24,27 @@ bb0: { StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; - _3 = [move _4; N]; -+ _3 = [_1; N]; ++ _3 = [copy _1; N]; StorageDead(_4); StorageLive(_5); StorageLive(_6); StorageLive(_7); _7 = const 0_usize; - _8 = Len(_3); -- _9 = Lt(_7, _8); -- assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, _7) -> [success: bb1, unwind continue]; +- _9 = Lt(copy _7, copy _8); +- assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, copy _7) -> [success: bb1, unwind continue]; + _8 = const N; + _9 = Lt(const 0_usize, const N); + assert(move _9, "index out of bounds: the length is {} but the index is {}", const N, const 0_usize) -> [success: bb1, unwind continue]; } bb1: { -- _6 = _3[_7]; +- _6 = copy _3[_7]; - _5 = opaque::(move _6) -> [return: bb2, unwind continue]; -+ _6 = _1; -+ _5 = opaque::(_1) -> [return: bb2, unwind continue]; ++ _6 = copy _1; ++ _5 = opaque::(copy _1) -> [return: bb2, unwind continue]; } bb2: { @@ -54,20 +54,20 @@ StorageLive(_10); StorageLive(_11); StorageLive(_12); - _12 = _2; + _12 = copy _2; - _13 = Len(_3); -- _14 = Lt(_12, _13); -- assert(move _14, "index out of bounds: the length is {} but the index is {}", move _13, _12) -> [success: bb3, unwind continue]; +- _14 = Lt(copy _12, copy _13); +- assert(move _14, "index out of bounds: the length is {} but the index is {}", move _13, copy _12) -> [success: bb3, unwind continue]; + _13 = const N; -+ _14 = Lt(_2, const N); -+ assert(move _14, "index out of bounds: the length is {} but the index is {}", const N, _2) -> [success: bb3, unwind continue]; ++ _14 = Lt(copy _2, const N); ++ assert(move _14, "index out of bounds: the length is {} but the index is {}", const N, copy _2) -> [success: bb3, unwind continue]; } bb3: { -- _11 = _3[_12]; +- _11 = copy _3[_12]; - _10 = opaque::(move _11) -> [return: bb4, unwind continue]; -+ _11 = _1; -+ _10 = opaque::(_1) -> [return: bb4, unwind continue]; ++ _11 = copy _1; ++ _10 = opaque::(copy _1) -> [return: bb4, unwind continue]; } bb4: { diff --git a/tests/mir-opt/gvn.slice_const_length.GVN.panic-abort.diff b/tests/mir-opt/gvn.slice_const_length.GVN.panic-abort.diff index fd5fa035d816..1a6204e4ac8a 100644 --- a/tests/mir-opt/gvn.slice_const_length.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.slice_const_length.GVN.panic-abort.diff @@ -30,12 +30,12 @@ + nop; _4 = const 123_usize; StorageLive(_5); - _5 = _2; + _5 = copy _2; StorageLive(_6); -- _6 = _4; +- _6 = copy _4; - _0 = *const [i32] from (move _5, move _6); + _6 = const 123_usize; -+ _0 = *const [i32] from (_2, const 123_usize); ++ _0 = *const [i32] from (copy _2, const 123_usize); StorageDead(_6); StorageDead(_5); - StorageDead(_4); diff --git a/tests/mir-opt/gvn.slice_const_length.GVN.panic-unwind.diff b/tests/mir-opt/gvn.slice_const_length.GVN.panic-unwind.diff index 98945cf9724d..62d57b0fe283 100644 --- a/tests/mir-opt/gvn.slice_const_length.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.slice_const_length.GVN.panic-unwind.diff @@ -30,12 +30,12 @@ + nop; _4 = const 123_usize; StorageLive(_5); - _5 = _2; + _5 = copy _2; StorageLive(_6); -- _6 = _4; +- _6 = copy _4; - _0 = *const [i32] from (move _5, move _6); + _6 = const 123_usize; -+ _0 = *const [i32] from (_2, const 123_usize); ++ _0 = *const [i32] from (copy _2, const 123_usize); StorageDead(_6); StorageDead(_5); - StorageDead(_4); diff --git a/tests/mir-opt/gvn.slice_from_raw_parts_as_ptr.GVN.panic-abort.diff b/tests/mir-opt/gvn.slice_from_raw_parts_as_ptr.GVN.panic-abort.diff index 75bcd2a8d72c..4a2cc2518919 100644 --- a/tests/mir-opt/gvn.slice_from_raw_parts_as_ptr.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.slice_from_raw_parts_as_ptr.GVN.panic-abort.diff @@ -20,27 +20,27 @@ - StorageLive(_3); + nop; StorageLive(_4); - _4 = _1; + _4 = copy _1; StorageLive(_5); - _5 = _2; + _5 = copy _2; - _3 = *const [u16] from (move _4, move _5); -+ _3 = *const [u16] from (_1, _2); ++ _3 = *const [u16] from (copy _1, copy _2); StorageDead(_5); StorageDead(_4); StorageLive(_6); StorageLive(_7); - _7 = _3; + _7 = copy _3; - _6 = move _7 as *const u16 (PtrToPtr); -+ _6 = _1; ++ _6 = copy _1; StorageDead(_7); StorageLive(_8); StorageLive(_9); - _9 = _3; + _9 = copy _3; - _8 = move _9 as *const f32 (PtrToPtr); -+ _8 = _1 as *const f32 (PtrToPtr); ++ _8 = copy _1 as *const f32 (PtrToPtr); StorageDead(_9); - _0 = (move _6, move _8); -+ _0 = (_1, move _8); ++ _0 = (copy _1, move _8); StorageDead(_8); StorageDead(_6); - StorageDead(_3); diff --git a/tests/mir-opt/gvn.slice_from_raw_parts_as_ptr.GVN.panic-unwind.diff b/tests/mir-opt/gvn.slice_from_raw_parts_as_ptr.GVN.panic-unwind.diff index 75bcd2a8d72c..4a2cc2518919 100644 --- a/tests/mir-opt/gvn.slice_from_raw_parts_as_ptr.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.slice_from_raw_parts_as_ptr.GVN.panic-unwind.diff @@ -20,27 +20,27 @@ - StorageLive(_3); + nop; StorageLive(_4); - _4 = _1; + _4 = copy _1; StorageLive(_5); - _5 = _2; + _5 = copy _2; - _3 = *const [u16] from (move _4, move _5); -+ _3 = *const [u16] from (_1, _2); ++ _3 = *const [u16] from (copy _1, copy _2); StorageDead(_5); StorageDead(_4); StorageLive(_6); StorageLive(_7); - _7 = _3; + _7 = copy _3; - _6 = move _7 as *const u16 (PtrToPtr); -+ _6 = _1; ++ _6 = copy _1; StorageDead(_7); StorageLive(_8); StorageLive(_9); - _9 = _3; + _9 = copy _3; - _8 = move _9 as *const f32 (PtrToPtr); -+ _8 = _1 as *const f32 (PtrToPtr); ++ _8 = copy _1 as *const f32 (PtrToPtr); StorageDead(_9); - _0 = (move _6, move _8); -+ _0 = (_1, move _8); ++ _0 = (copy _1, move _8); StorageDead(_8); StorageDead(_6); - StorageDead(_3); diff --git a/tests/mir-opt/gvn.slices.GVN.panic-abort.diff b/tests/mir-opt/gvn.slices.GVN.panic-abort.diff index fb67e3d59940..e8e99b44e721 100644 --- a/tests/mir-opt/gvn.slices.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.slices.GVN.panic-abort.diff @@ -87,22 +87,22 @@ _1 = const "my favourite slice"; StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; - _2 = opaque::<&str>(move _3) -> [return: bb1, unwind unreachable]; -+ _2 = opaque::<&str>(_1) -> [return: bb1, unwind unreachable]; ++ _2 = opaque::<&str>(copy _1) -> [return: bb1, unwind unreachable]; } bb1: { StorageDead(_3); StorageDead(_2); StorageLive(_4); - _4 = _1; + _4 = copy _1; StorageLive(_5); StorageLive(_6); -- _6 = _4; +- _6 = copy _4; - _5 = opaque::<&str>(move _6) -> [return: bb2, unwind unreachable]; -+ _6 = _1; -+ _5 = opaque::<&str>(_1) -> [return: bb2, unwind unreachable]; ++ _6 = copy _1; ++ _5 = opaque::<&str>(copy _1) -> [return: bb2, unwind unreachable]; } bb2: { @@ -138,24 +138,24 @@ - _8 = (move _9, move _12); - StorageDead(_12); - StorageDead(_9); -+ _8 = (_9, _12); ++ _8 = (copy _9, copy _12); + nop; + nop; StorageLive(_15); -- _15 = (_8.0: &*const u8); -+ _15 = _9; +- _15 = copy (_8.0: &*const u8); ++ _15 = copy _9; StorageLive(_16); -- _16 = (_8.1: &*const u8); -+ _16 = _12; +- _16 = copy (_8.1: &*const u8); ++ _16 = copy _12; StorageLive(_17); StorageLive(_18); -- _18 = (*_15); -+ _18 = _10; +- _18 = copy (*_15); ++ _18 = copy _10; StorageLive(_19); -- _19 = (*_16); +- _19 = copy (*_16); - _17 = Eq(move _18, move _19); -+ _19 = _13; -+ _17 = Eq(_10, _13); ++ _19 = copy _13; ++ _17 = Eq(copy _10, copy _13); switchInt(move _17) -> [0: bb6, otherwise: bb5]; } @@ -180,9 +180,9 @@ StorageDead(_30); StorageLive(_31); StorageLive(_32); - _32 = _29; + _32 = copy _29; - _31 = opaque::<&[u8]>(move _32) -> [return: bb7, unwind unreachable]; -+ _31 = opaque::<&[u8]>(_29) -> [return: bb7, unwind unreachable]; ++ _31 = opaque::<&[u8]>(copy _29) -> [return: bb7, unwind unreachable]; } bb6: { @@ -244,24 +244,24 @@ - _34 = (move _35, move _38); - StorageDead(_38); - StorageDead(_35); -+ _34 = (_35, _38); ++ _34 = (copy _35, copy _38); + nop; + nop; StorageLive(_41); -- _41 = (_34.0: &*const u8); -+ _41 = _35; +- _41 = copy (_34.0: &*const u8); ++ _41 = copy _35; StorageLive(_42); -- _42 = (_34.1: &*const u8); -+ _42 = _38; +- _42 = copy (_34.1: &*const u8); ++ _42 = copy _38; StorageLive(_43); StorageLive(_44); -- _44 = (*_41); -+ _44 = _36; +- _44 = copy (*_41); ++ _44 = copy _36; StorageLive(_45); -- _45 = (*_42); +- _45 = copy (*_42); - _43 = Eq(move _44, move _45); -+ _45 = _39; -+ _43 = Eq(_36, _39); ++ _45 = copy _39; ++ _43 = Eq(copy _36, copy _39); switchInt(move _43) -> [0: bb11, otherwise: bb10]; } diff --git a/tests/mir-opt/gvn.slices.GVN.panic-unwind.diff b/tests/mir-opt/gvn.slices.GVN.panic-unwind.diff index ae3013b011e9..4296d4d4a594 100644 --- a/tests/mir-opt/gvn.slices.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.slices.GVN.panic-unwind.diff @@ -87,22 +87,22 @@ _1 = const "my favourite slice"; StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; - _2 = opaque::<&str>(move _3) -> [return: bb1, unwind continue]; -+ _2 = opaque::<&str>(_1) -> [return: bb1, unwind continue]; ++ _2 = opaque::<&str>(copy _1) -> [return: bb1, unwind continue]; } bb1: { StorageDead(_3); StorageDead(_2); StorageLive(_4); - _4 = _1; + _4 = copy _1; StorageLive(_5); StorageLive(_6); -- _6 = _4; +- _6 = copy _4; - _5 = opaque::<&str>(move _6) -> [return: bb2, unwind continue]; -+ _6 = _1; -+ _5 = opaque::<&str>(_1) -> [return: bb2, unwind continue]; ++ _6 = copy _1; ++ _5 = opaque::<&str>(copy _1) -> [return: bb2, unwind continue]; } bb2: { @@ -138,24 +138,24 @@ - _8 = (move _9, move _12); - StorageDead(_12); - StorageDead(_9); -+ _8 = (_9, _12); ++ _8 = (copy _9, copy _12); + nop; + nop; StorageLive(_15); -- _15 = (_8.0: &*const u8); -+ _15 = _9; +- _15 = copy (_8.0: &*const u8); ++ _15 = copy _9; StorageLive(_16); -- _16 = (_8.1: &*const u8); -+ _16 = _12; +- _16 = copy (_8.1: &*const u8); ++ _16 = copy _12; StorageLive(_17); StorageLive(_18); -- _18 = (*_15); -+ _18 = _10; +- _18 = copy (*_15); ++ _18 = copy _10; StorageLive(_19); -- _19 = (*_16); +- _19 = copy (*_16); - _17 = Eq(move _18, move _19); -+ _19 = _13; -+ _17 = Eq(_10, _13); ++ _19 = copy _13; ++ _17 = Eq(copy _10, copy _13); switchInt(move _17) -> [0: bb6, otherwise: bb5]; } @@ -180,9 +180,9 @@ StorageDead(_30); StorageLive(_31); StorageLive(_32); - _32 = _29; + _32 = copy _29; - _31 = opaque::<&[u8]>(move _32) -> [return: bb7, unwind continue]; -+ _31 = opaque::<&[u8]>(_29) -> [return: bb7, unwind continue]; ++ _31 = opaque::<&[u8]>(copy _29) -> [return: bb7, unwind continue]; } bb6: { @@ -244,24 +244,24 @@ - _34 = (move _35, move _38); - StorageDead(_38); - StorageDead(_35); -+ _34 = (_35, _38); ++ _34 = (copy _35, copy _38); + nop; + nop; StorageLive(_41); -- _41 = (_34.0: &*const u8); -+ _41 = _35; +- _41 = copy (_34.0: &*const u8); ++ _41 = copy _35; StorageLive(_42); -- _42 = (_34.1: &*const u8); -+ _42 = _38; +- _42 = copy (_34.1: &*const u8); ++ _42 = copy _38; StorageLive(_43); StorageLive(_44); -- _44 = (*_41); -+ _44 = _36; +- _44 = copy (*_41); ++ _44 = copy _36; StorageLive(_45); -- _45 = (*_42); +- _45 = copy (*_42); - _43 = Eq(move _44, move _45); -+ _45 = _39; -+ _43 = Eq(_36, _39); ++ _45 = copy _39; ++ _43 = Eq(copy _36, copy _39); switchInt(move _43) -> [0: bb11, otherwise: bb10]; } diff --git a/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-abort.diff b/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-abort.diff index ba9e507560d6..7a479bc55da7 100644 --- a/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-abort.diff @@ -195,15 +195,15 @@ - StorageLive(_5); + nop; StorageLive(_6); - _6 = _1; + _6 = copy _1; StorageLive(_7); - _7 = _2; + _7 = copy _2; - _5 = Add(move _6, move _7); -+ _5 = Add(_1, _2); ++ _5 = Add(copy _1, copy _2); StorageDead(_7); StorageDead(_6); - _4 = opaque::(move _5) -> [return: bb1, unwind unreachable]; -+ _4 = opaque::(_5) -> [return: bb1, unwind unreachable]; ++ _4 = opaque::(copy _5) -> [return: bb1, unwind unreachable]; } bb1: { @@ -214,15 +214,15 @@ - StorageLive(_9); + nop; StorageLive(_10); - _10 = _1; + _10 = copy _1; StorageLive(_11); - _11 = _2; + _11 = copy _2; - _9 = Mul(move _10, move _11); -+ _9 = Mul(_1, _2); ++ _9 = Mul(copy _1, copy _2); StorageDead(_11); StorageDead(_10); - _8 = opaque::(move _9) -> [return: bb2, unwind unreachable]; -+ _8 = opaque::(_9) -> [return: bb2, unwind unreachable]; ++ _8 = opaque::(copy _9) -> [return: bb2, unwind unreachable]; } bb2: { @@ -233,15 +233,15 @@ - StorageLive(_13); + nop; StorageLive(_14); - _14 = _1; + _14 = copy _1; StorageLive(_15); - _15 = _2; + _15 = copy _2; - _13 = Sub(move _14, move _15); -+ _13 = Sub(_1, _2); ++ _13 = Sub(copy _1, copy _2); StorageDead(_15); StorageDead(_14); - _12 = opaque::(move _13) -> [return: bb3, unwind unreachable]; -+ _12 = opaque::(_13) -> [return: bb3, unwind unreachable]; ++ _12 = opaque::(copy _13) -> [return: bb3, unwind unreachable]; } bb3: { @@ -252,22 +252,22 @@ - StorageLive(_17); + nop; StorageLive(_18); - _18 = _1; + _18 = copy _1; StorageLive(_19); - _19 = _2; -- _20 = Eq(_19, const 0_u64); -- assert(!move _20, "attempt to divide `{}` by zero", _18) -> [success: bb4, unwind unreachable]; -+ _20 = Eq(_2, const 0_u64); -+ assert(!_20, "attempt to divide `{}` by zero", _1) -> [success: bb4, unwind unreachable]; + _19 = copy _2; +- _20 = Eq(copy _19, const 0_u64); +- assert(!move _20, "attempt to divide `{}` by zero", copy _18) -> [success: bb4, unwind unreachable]; ++ _20 = Eq(copy _2, const 0_u64); ++ assert(!copy _20, "attempt to divide `{}` by zero", copy _1) -> [success: bb4, unwind unreachable]; } bb4: { - _17 = Div(move _18, move _19); -+ _17 = Div(_1, _2); ++ _17 = Div(copy _1, copy _2); StorageDead(_19); StorageDead(_18); - _16 = opaque::(move _17) -> [return: bb5, unwind unreachable]; -+ _16 = opaque::(_17) -> [return: bb5, unwind unreachable]; ++ _16 = opaque::(copy _17) -> [return: bb5, unwind unreachable]; } bb5: { @@ -278,22 +278,22 @@ - StorageLive(_22); + nop; StorageLive(_23); - _23 = _1; + _23 = copy _1; StorageLive(_24); - _24 = _2; -- _25 = Eq(_24, const 0_u64); -- assert(!move _25, "attempt to calculate the remainder of `{}` with a divisor of zero", _23) -> [success: bb6, unwind unreachable]; -+ _25 = _20; -+ assert(!_20, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb6, unwind unreachable]; + _24 = copy _2; +- _25 = Eq(copy _24, const 0_u64); +- assert(!move _25, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _23) -> [success: bb6, unwind unreachable]; ++ _25 = copy _20; ++ assert(!copy _20, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _1) -> [success: bb6, unwind unreachable]; } bb6: { - _22 = Rem(move _23, move _24); -+ _22 = Rem(_1, _2); ++ _22 = Rem(copy _1, copy _2); StorageDead(_24); StorageDead(_23); - _21 = opaque::(move _22) -> [return: bb7, unwind unreachable]; -+ _21 = opaque::(_22) -> [return: bb7, unwind unreachable]; ++ _21 = opaque::(copy _22) -> [return: bb7, unwind unreachable]; } bb7: { @@ -304,15 +304,15 @@ - StorageLive(_27); + nop; StorageLive(_28); - _28 = _1; + _28 = copy _1; StorageLive(_29); - _29 = _2; + _29 = copy _2; - _27 = BitAnd(move _28, move _29); -+ _27 = BitAnd(_1, _2); ++ _27 = BitAnd(copy _1, copy _2); StorageDead(_29); StorageDead(_28); - _26 = opaque::(move _27) -> [return: bb8, unwind unreachable]; -+ _26 = opaque::(_27) -> [return: bb8, unwind unreachable]; ++ _26 = opaque::(copy _27) -> [return: bb8, unwind unreachable]; } bb8: { @@ -323,15 +323,15 @@ - StorageLive(_31); + nop; StorageLive(_32); - _32 = _1; + _32 = copy _1; StorageLive(_33); - _33 = _2; + _33 = copy _2; - _31 = BitOr(move _32, move _33); -+ _31 = BitOr(_1, _2); ++ _31 = BitOr(copy _1, copy _2); StorageDead(_33); StorageDead(_32); - _30 = opaque::(move _31) -> [return: bb9, unwind unreachable]; -+ _30 = opaque::(_31) -> [return: bb9, unwind unreachable]; ++ _30 = opaque::(copy _31) -> [return: bb9, unwind unreachable]; } bb9: { @@ -342,15 +342,15 @@ - StorageLive(_35); + nop; StorageLive(_36); - _36 = _1; + _36 = copy _1; StorageLive(_37); - _37 = _2; + _37 = copy _2; - _35 = BitXor(move _36, move _37); -+ _35 = BitXor(_1, _2); ++ _35 = BitXor(copy _1, copy _2); StorageDead(_37); StorageDead(_36); - _34 = opaque::(move _35) -> [return: bb10, unwind unreachable]; -+ _34 = opaque::(_35) -> [return: bb10, unwind unreachable]; ++ _34 = opaque::(copy _35) -> [return: bb10, unwind unreachable]; } bb10: { @@ -361,15 +361,15 @@ - StorageLive(_39); + nop; StorageLive(_40); - _40 = _1; + _40 = copy _1; StorageLive(_41); - _41 = _2; + _41 = copy _2; - _39 = Shl(move _40, move _41); -+ _39 = Shl(_1, _2); ++ _39 = Shl(copy _1, copy _2); StorageDead(_41); StorageDead(_40); - _38 = opaque::(move _39) -> [return: bb11, unwind unreachable]; -+ _38 = opaque::(_39) -> [return: bb11, unwind unreachable]; ++ _38 = opaque::(copy _39) -> [return: bb11, unwind unreachable]; } bb11: { @@ -380,15 +380,15 @@ - StorageLive(_43); + nop; StorageLive(_44); - _44 = _1; + _44 = copy _1; StorageLive(_45); - _45 = _2; + _45 = copy _2; - _43 = Shr(move _44, move _45); -+ _43 = Shr(_1, _2); ++ _43 = Shr(copy _1, copy _2); StorageDead(_45); StorageDead(_44); - _42 = opaque::(move _43) -> [return: bb12, unwind unreachable]; -+ _42 = opaque::(_43) -> [return: bb12, unwind unreachable]; ++ _42 = opaque::(copy _43) -> [return: bb12, unwind unreachable]; } bb12: { @@ -399,12 +399,12 @@ - StorageLive(_47); + nop; StorageLive(_48); - _48 = _1; + _48 = copy _1; - _47 = move _48 as u32 (IntToInt); -+ _47 = _1 as u32 (IntToInt); ++ _47 = copy _1 as u32 (IntToInt); StorageDead(_48); - _46 = opaque::(move _47) -> [return: bb13, unwind unreachable]; -+ _46 = opaque::(_47) -> [return: bb13, unwind unreachable]; ++ _46 = opaque::(copy _47) -> [return: bb13, unwind unreachable]; } bb13: { @@ -415,12 +415,12 @@ - StorageLive(_50); + nop; StorageLive(_51); - _51 = _1; + _51 = copy _1; - _50 = move _51 as f32 (IntToFloat); -+ _50 = _1 as f32 (IntToFloat); ++ _50 = copy _1 as f32 (IntToFloat); StorageDead(_51); - _49 = opaque::(move _50) -> [return: bb14, unwind unreachable]; -+ _49 = opaque::(_50) -> [return: bb14, unwind unreachable]; ++ _49 = opaque::(copy _50) -> [return: bb14, unwind unreachable]; } bb14: { @@ -431,12 +431,12 @@ - StorageLive(_53); + nop; StorageLive(_54); - _54 = _1; + _54 = copy _1; - _53 = S::(move _54); -+ _53 = S::(_1); ++ _53 = S::(copy _1); StorageDead(_54); - _52 = opaque::>(move _53) -> [return: bb15, unwind unreachable]; -+ _52 = opaque::>(_53) -> [return: bb15, unwind unreachable]; ++ _52 = opaque::>(copy _53) -> [return: bb15, unwind unreachable]; } bb15: { @@ -447,14 +447,14 @@ StorageLive(_56); StorageLive(_57); StorageLive(_58); - _58 = _1; + _58 = copy _1; - _57 = S::(move _58); -+ _57 = _53; ++ _57 = copy _53; StorageDead(_58); -- _56 = (_57.0: u64); +- _56 = copy (_57.0: u64); - _55 = opaque::(move _56) -> [return: bb16, unwind unreachable]; -+ _56 = _1; -+ _55 = opaque::(_1) -> [return: bb16, unwind unreachable]; ++ _56 = copy _1; ++ _55 = opaque::(copy _1) -> [return: bb16, unwind unreachable]; } bb16: { @@ -464,15 +464,15 @@ StorageLive(_59); StorageLive(_60); StorageLive(_61); - _61 = _1; + _61 = copy _1; StorageLive(_62); - _62 = _2; + _62 = copy _2; - _60 = Add(move _61, move _62); -+ _60 = _5; ++ _60 = copy _5; StorageDead(_62); StorageDead(_61); - _59 = opaque::(move _60) -> [return: bb17, unwind unreachable]; -+ _59 = opaque::(_5) -> [return: bb17, unwind unreachable]; ++ _59 = opaque::(copy _5) -> [return: bb17, unwind unreachable]; } bb17: { @@ -481,15 +481,15 @@ StorageLive(_63); StorageLive(_64); StorageLive(_65); - _65 = _1; + _65 = copy _1; StorageLive(_66); - _66 = _2; + _66 = copy _2; - _64 = Mul(move _65, move _66); -+ _64 = _9; ++ _64 = copy _9; StorageDead(_66); StorageDead(_65); - _63 = opaque::(move _64) -> [return: bb18, unwind unreachable]; -+ _63 = opaque::(_9) -> [return: bb18, unwind unreachable]; ++ _63 = opaque::(copy _9) -> [return: bb18, unwind unreachable]; } bb18: { @@ -498,15 +498,15 @@ StorageLive(_67); StorageLive(_68); StorageLive(_69); - _69 = _1; + _69 = copy _1; StorageLive(_70); - _70 = _2; + _70 = copy _2; - _68 = Sub(move _69, move _70); -+ _68 = _13; ++ _68 = copy _13; StorageDead(_70); StorageDead(_69); - _67 = opaque::(move _68) -> [return: bb19, unwind unreachable]; -+ _67 = opaque::(_13) -> [return: bb19, unwind unreachable]; ++ _67 = opaque::(copy _13) -> [return: bb19, unwind unreachable]; } bb19: { @@ -515,22 +515,22 @@ StorageLive(_71); StorageLive(_72); StorageLive(_73); - _73 = _1; + _73 = copy _1; StorageLive(_74); - _74 = _2; -- _75 = Eq(_74, const 0_u64); -- assert(!move _75, "attempt to divide `{}` by zero", _73) -> [success: bb20, unwind unreachable]; -+ _75 = _20; -+ assert(!_20, "attempt to divide `{}` by zero", _1) -> [success: bb20, unwind unreachable]; + _74 = copy _2; +- _75 = Eq(copy _74, const 0_u64); +- assert(!move _75, "attempt to divide `{}` by zero", copy _73) -> [success: bb20, unwind unreachable]; ++ _75 = copy _20; ++ assert(!copy _20, "attempt to divide `{}` by zero", copy _1) -> [success: bb20, unwind unreachable]; } bb20: { - _72 = Div(move _73, move _74); -+ _72 = _17; ++ _72 = copy _17; StorageDead(_74); StorageDead(_73); - _71 = opaque::(move _72) -> [return: bb21, unwind unreachable]; -+ _71 = opaque::(_17) -> [return: bb21, unwind unreachable]; ++ _71 = opaque::(copy _17) -> [return: bb21, unwind unreachable]; } bb21: { @@ -539,22 +539,22 @@ StorageLive(_76); StorageLive(_77); StorageLive(_78); - _78 = _1; + _78 = copy _1; StorageLive(_79); - _79 = _2; -- _80 = Eq(_79, const 0_u64); -- assert(!move _80, "attempt to calculate the remainder of `{}` with a divisor of zero", _78) -> [success: bb22, unwind unreachable]; -+ _80 = _20; -+ assert(!_20, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb22, unwind unreachable]; + _79 = copy _2; +- _80 = Eq(copy _79, const 0_u64); +- assert(!move _80, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _78) -> [success: bb22, unwind unreachable]; ++ _80 = copy _20; ++ assert(!copy _20, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _1) -> [success: bb22, unwind unreachable]; } bb22: { - _77 = Rem(move _78, move _79); -+ _77 = _22; ++ _77 = copy _22; StorageDead(_79); StorageDead(_78); - _76 = opaque::(move _77) -> [return: bb23, unwind unreachable]; -+ _76 = opaque::(_22) -> [return: bb23, unwind unreachable]; ++ _76 = opaque::(copy _22) -> [return: bb23, unwind unreachable]; } bb23: { @@ -563,15 +563,15 @@ StorageLive(_81); StorageLive(_82); StorageLive(_83); - _83 = _1; + _83 = copy _1; StorageLive(_84); - _84 = _2; + _84 = copy _2; - _82 = BitAnd(move _83, move _84); -+ _82 = _27; ++ _82 = copy _27; StorageDead(_84); StorageDead(_83); - _81 = opaque::(move _82) -> [return: bb24, unwind unreachable]; -+ _81 = opaque::(_27) -> [return: bb24, unwind unreachable]; ++ _81 = opaque::(copy _27) -> [return: bb24, unwind unreachable]; } bb24: { @@ -580,15 +580,15 @@ StorageLive(_85); StorageLive(_86); StorageLive(_87); - _87 = _1; + _87 = copy _1; StorageLive(_88); - _88 = _2; + _88 = copy _2; - _86 = BitOr(move _87, move _88); -+ _86 = _31; ++ _86 = copy _31; StorageDead(_88); StorageDead(_87); - _85 = opaque::(move _86) -> [return: bb25, unwind unreachable]; -+ _85 = opaque::(_31) -> [return: bb25, unwind unreachable]; ++ _85 = opaque::(copy _31) -> [return: bb25, unwind unreachable]; } bb25: { @@ -597,15 +597,15 @@ StorageLive(_89); StorageLive(_90); StorageLive(_91); - _91 = _1; + _91 = copy _1; StorageLive(_92); - _92 = _2; + _92 = copy _2; - _90 = BitXor(move _91, move _92); -+ _90 = _35; ++ _90 = copy _35; StorageDead(_92); StorageDead(_91); - _89 = opaque::(move _90) -> [return: bb26, unwind unreachable]; -+ _89 = opaque::(_35) -> [return: bb26, unwind unreachable]; ++ _89 = opaque::(copy _35) -> [return: bb26, unwind unreachable]; } bb26: { @@ -614,15 +614,15 @@ StorageLive(_93); StorageLive(_94); StorageLive(_95); - _95 = _1; + _95 = copy _1; StorageLive(_96); - _96 = _2; + _96 = copy _2; - _94 = Shl(move _95, move _96); -+ _94 = _39; ++ _94 = copy _39; StorageDead(_96); StorageDead(_95); - _93 = opaque::(move _94) -> [return: bb27, unwind unreachable]; -+ _93 = opaque::(_39) -> [return: bb27, unwind unreachable]; ++ _93 = opaque::(copy _39) -> [return: bb27, unwind unreachable]; } bb27: { @@ -631,15 +631,15 @@ StorageLive(_97); StorageLive(_98); StorageLive(_99); - _99 = _1; + _99 = copy _1; StorageLive(_100); - _100 = _2; + _100 = copy _2; - _98 = Shr(move _99, move _100); -+ _98 = _43; ++ _98 = copy _43; StorageDead(_100); StorageDead(_99); - _97 = opaque::(move _98) -> [return: bb28, unwind unreachable]; -+ _97 = opaque::(_43) -> [return: bb28, unwind unreachable]; ++ _97 = opaque::(copy _43) -> [return: bb28, unwind unreachable]; } bb28: { @@ -648,12 +648,12 @@ StorageLive(_101); StorageLive(_102); StorageLive(_103); - _103 = _1; + _103 = copy _1; - _102 = move _103 as u32 (IntToInt); -+ _102 = _47; ++ _102 = copy _47; StorageDead(_103); - _101 = opaque::(move _102) -> [return: bb29, unwind unreachable]; -+ _101 = opaque::(_47) -> [return: bb29, unwind unreachable]; ++ _101 = opaque::(copy _47) -> [return: bb29, unwind unreachable]; } bb29: { @@ -662,12 +662,12 @@ StorageLive(_104); StorageLive(_105); StorageLive(_106); - _106 = _1; + _106 = copy _1; - _105 = move _106 as f32 (IntToFloat); -+ _105 = _50; ++ _105 = copy _50; StorageDead(_106); - _104 = opaque::(move _105) -> [return: bb30, unwind unreachable]; -+ _104 = opaque::(_50) -> [return: bb30, unwind unreachable]; ++ _104 = opaque::(copy _50) -> [return: bb30, unwind unreachable]; } bb30: { @@ -676,12 +676,12 @@ StorageLive(_107); StorageLive(_108); StorageLive(_109); - _109 = _1; + _109 = copy _1; - _108 = S::(move _109); -+ _108 = _53; ++ _108 = copy _53; StorageDead(_109); - _107 = opaque::>(move _108) -> [return: bb31, unwind unreachable]; -+ _107 = opaque::>(_53) -> [return: bb31, unwind unreachable]; ++ _107 = opaque::>(copy _53) -> [return: bb31, unwind unreachable]; } bb31: { @@ -691,14 +691,14 @@ StorageLive(_111); StorageLive(_112); StorageLive(_113); - _113 = _1; + _113 = copy _1; - _112 = S::(move _113); -+ _112 = _53; ++ _112 = copy _53; StorageDead(_113); -- _111 = (_112.0: u64); +- _111 = copy (_112.0: u64); - _110 = opaque::(move _111) -> [return: bb32, unwind unreachable]; -+ _111 = _1; -+ _110 = opaque::(_1) -> [return: bb32, unwind unreachable]; ++ _111 = copy _1; ++ _110 = opaque::(copy _1) -> [return: bb32, unwind unreachable]; } bb32: { @@ -710,21 +710,21 @@ + nop; StorageLive(_116); StorageLive(_117); - _117 = _1; + _117 = copy _1; StorageLive(_118); - _118 = _2; + _118 = copy _2; - _116 = Mul(move _117, move _118); -+ _116 = _9; ++ _116 = copy _9; StorageDead(_118); StorageDead(_117); StorageLive(_119); - _119 = _2; + _119 = copy _2; - _115 = Sub(move _116, move _119); -+ _115 = Sub(_9, _2); ++ _115 = Sub(copy _9, copy _2); StorageDead(_119); StorageDead(_116); - _114 = opaque::(move _115) -> [return: bb33, unwind unreachable]; -+ _114 = opaque::(_115) -> [return: bb33, unwind unreachable]; ++ _114 = opaque::(copy _115) -> [return: bb33, unwind unreachable]; } bb33: { @@ -735,21 +735,21 @@ StorageLive(_121); StorageLive(_122); StorageLive(_123); - _123 = _1; + _123 = copy _1; StorageLive(_124); - _124 = _2; + _124 = copy _2; - _122 = Mul(move _123, move _124); -+ _122 = _9; ++ _122 = copy _9; StorageDead(_124); StorageDead(_123); StorageLive(_125); - _125 = _2; + _125 = copy _2; - _121 = Sub(move _122, move _125); -+ _121 = _115; ++ _121 = copy _115; StorageDead(_125); StorageDead(_122); - _120 = opaque::(move _121) -> [return: bb34, unwind unreachable]; -+ _120 = opaque::(_115) -> [return: bb34, unwind unreachable]; ++ _120 = opaque::(copy _115) -> [return: bb34, unwind unreachable]; } bb34: { @@ -762,16 +762,16 @@ - StorageLive(_129); + nop; + nop; - _129 = (*_126); + _129 = copy (*_126); StorageLive(_130); - _130 = _1; + _130 = copy _1; - _128 = Add(move _129, move _130); -+ _128 = Add(_129, _1); ++ _128 = Add(copy _129, copy _1); StorageDead(_130); - StorageDead(_129); - _127 = opaque::(move _128) -> [return: bb35, unwind unreachable]; + nop; -+ _127 = opaque::(_128) -> [return: bb35, unwind unreachable]; ++ _127 = opaque::(copy _128) -> [return: bb35, unwind unreachable]; } bb35: { @@ -781,16 +781,16 @@ StorageLive(_131); StorageLive(_132); StorageLive(_133); -- _133 = (*_126); -+ _133 = _129; +- _133 = copy (*_126); ++ _133 = copy _129; StorageLive(_134); - _134 = _1; + _134 = copy _1; - _132 = Add(move _133, move _134); -+ _132 = _128; ++ _132 = copy _128; StorageDead(_134); StorageDead(_133); - _131 = opaque::(move _132) -> [return: bb36, unwind unreachable]; -+ _131 = opaque::(_128) -> [return: bb36, unwind unreachable]; ++ _131 = opaque::(copy _128) -> [return: bb36, unwind unreachable]; } bb36: { @@ -801,11 +801,11 @@ StorageLive(_136); StorageLive(_137); StorageLive(_138); - _138 = (*_135); + _138 = copy (*_135); StorageLive(_139); - _139 = _1; + _139 = copy _1; - _137 = Add(move _138, move _139); -+ _137 = Add(move _138, _1); ++ _137 = Add(move _138, copy _1); StorageDead(_139); StorageDead(_138); _136 = opaque::(move _137) -> [return: bb37, unwind unreachable]; @@ -817,11 +817,11 @@ StorageLive(_140); StorageLive(_141); StorageLive(_142); - _142 = (*_135); + _142 = copy (*_135); StorageLive(_143); - _143 = _1; + _143 = copy _1; - _141 = Add(move _142, move _143); -+ _141 = Add(move _142, _1); ++ _141 = Add(move _142, copy _1); StorageDead(_143); StorageDead(_142); _140 = opaque::(move _141) -> [return: bb38, unwind unreachable]; @@ -836,11 +836,11 @@ StorageLive(_146); StorageLive(_147); StorageLive(_148); - _148 = (*_145); + _148 = copy (*_145); StorageLive(_149); - _149 = _1; + _149 = copy _1; - _147 = Add(move _148, move _149); -+ _147 = Add(move _148, _1); ++ _147 = Add(move _148, copy _1); StorageDead(_149); StorageDead(_148); _146 = opaque::(move _147) -> [return: bb39, unwind unreachable]; @@ -852,11 +852,11 @@ StorageLive(_150); StorageLive(_151); StorageLive(_152); - _152 = (*_145); + _152 = copy (*_145); StorageLive(_153); - _153 = _1; + _153 = copy _1; - _151 = Add(move _152, move _153); -+ _151 = Add(move _152, _1); ++ _151 = Add(move _152, copy _1); StorageDead(_153); StorageDead(_152); _150 = opaque::(move _151) -> [return: bb40, unwind unreachable]; @@ -870,11 +870,11 @@ StorageLive(_155); StorageLive(_156); StorageLive(_157); - _157 = (*_154); + _157 = copy (*_154); StorageLive(_158); - _158 = _1; + _158 = copy _1; - _156 = Add(move _157, move _158); -+ _156 = Add(move _157, _1); ++ _156 = Add(move _157, copy _1); StorageDead(_158); StorageDead(_157); _155 = opaque::(move _156) -> [return: bb41, unwind unreachable]; @@ -886,11 +886,11 @@ StorageLive(_159); StorageLive(_160); StorageLive(_161); - _161 = (*_154); + _161 = copy (*_154); StorageLive(_162); - _162 = _1; + _162 = copy _1; - _160 = Add(move _161, move _162); -+ _160 = Add(move _161, _1); ++ _160 = Add(move _161, copy _1); StorageDead(_162); StorageDead(_161); _159 = opaque::(move _160) -> [return: bb42, unwind unreachable]; @@ -910,16 +910,16 @@ - StorageLive(_166); + nop; + nop; - _166 = (*_163); + _166 = copy (*_163); StorageLive(_167); - _167 = _1; + _167 = copy _1; - _165 = Add(move _166, move _167); -+ _165 = Add(_166, _1); ++ _165 = Add(copy _166, copy _1); StorageDead(_167); - StorageDead(_166); - _164 = opaque::(move _165) -> [return: bb43, unwind unreachable]; + nop; -+ _164 = opaque::(_165) -> [return: bb43, unwind unreachable]; ++ _164 = opaque::(copy _165) -> [return: bb43, unwind unreachable]; } bb43: { @@ -929,16 +929,16 @@ StorageLive(_168); StorageLive(_169); StorageLive(_170); -- _170 = (*_163); -+ _170 = _166; +- _170 = copy (*_163); ++ _170 = copy _166; StorageLive(_171); - _171 = _1; + _171 = copy _1; - _169 = Add(move _170, move _171); -+ _169 = _165; ++ _169 = copy _165; StorageDead(_171); StorageDead(_170); - _168 = opaque::(move _169) -> [return: bb44, unwind unreachable]; -+ _168 = opaque::(_165) -> [return: bb44, unwind unreachable]; ++ _168 = opaque::(copy _165) -> [return: bb44, unwind unreachable]; } bb44: { diff --git a/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-unwind.diff b/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-unwind.diff index 41c015361301..3ca5238663c2 100644 --- a/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-unwind.diff @@ -195,15 +195,15 @@ - StorageLive(_5); + nop; StorageLive(_6); - _6 = _1; + _6 = copy _1; StorageLive(_7); - _7 = _2; + _7 = copy _2; - _5 = Add(move _6, move _7); -+ _5 = Add(_1, _2); ++ _5 = Add(copy _1, copy _2); StorageDead(_7); StorageDead(_6); - _4 = opaque::(move _5) -> [return: bb1, unwind continue]; -+ _4 = opaque::(_5) -> [return: bb1, unwind continue]; ++ _4 = opaque::(copy _5) -> [return: bb1, unwind continue]; } bb1: { @@ -214,15 +214,15 @@ - StorageLive(_9); + nop; StorageLive(_10); - _10 = _1; + _10 = copy _1; StorageLive(_11); - _11 = _2; + _11 = copy _2; - _9 = Mul(move _10, move _11); -+ _9 = Mul(_1, _2); ++ _9 = Mul(copy _1, copy _2); StorageDead(_11); StorageDead(_10); - _8 = opaque::(move _9) -> [return: bb2, unwind continue]; -+ _8 = opaque::(_9) -> [return: bb2, unwind continue]; ++ _8 = opaque::(copy _9) -> [return: bb2, unwind continue]; } bb2: { @@ -233,15 +233,15 @@ - StorageLive(_13); + nop; StorageLive(_14); - _14 = _1; + _14 = copy _1; StorageLive(_15); - _15 = _2; + _15 = copy _2; - _13 = Sub(move _14, move _15); -+ _13 = Sub(_1, _2); ++ _13 = Sub(copy _1, copy _2); StorageDead(_15); StorageDead(_14); - _12 = opaque::(move _13) -> [return: bb3, unwind continue]; -+ _12 = opaque::(_13) -> [return: bb3, unwind continue]; ++ _12 = opaque::(copy _13) -> [return: bb3, unwind continue]; } bb3: { @@ -252,22 +252,22 @@ - StorageLive(_17); + nop; StorageLive(_18); - _18 = _1; + _18 = copy _1; StorageLive(_19); - _19 = _2; -- _20 = Eq(_19, const 0_u64); -- assert(!move _20, "attempt to divide `{}` by zero", _18) -> [success: bb4, unwind continue]; -+ _20 = Eq(_2, const 0_u64); -+ assert(!_20, "attempt to divide `{}` by zero", _1) -> [success: bb4, unwind continue]; + _19 = copy _2; +- _20 = Eq(copy _19, const 0_u64); +- assert(!move _20, "attempt to divide `{}` by zero", copy _18) -> [success: bb4, unwind continue]; ++ _20 = Eq(copy _2, const 0_u64); ++ assert(!copy _20, "attempt to divide `{}` by zero", copy _1) -> [success: bb4, unwind continue]; } bb4: { - _17 = Div(move _18, move _19); -+ _17 = Div(_1, _2); ++ _17 = Div(copy _1, copy _2); StorageDead(_19); StorageDead(_18); - _16 = opaque::(move _17) -> [return: bb5, unwind continue]; -+ _16 = opaque::(_17) -> [return: bb5, unwind continue]; ++ _16 = opaque::(copy _17) -> [return: bb5, unwind continue]; } bb5: { @@ -278,22 +278,22 @@ - StorageLive(_22); + nop; StorageLive(_23); - _23 = _1; + _23 = copy _1; StorageLive(_24); - _24 = _2; -- _25 = Eq(_24, const 0_u64); -- assert(!move _25, "attempt to calculate the remainder of `{}` with a divisor of zero", _23) -> [success: bb6, unwind continue]; -+ _25 = _20; -+ assert(!_20, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb6, unwind continue]; + _24 = copy _2; +- _25 = Eq(copy _24, const 0_u64); +- assert(!move _25, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _23) -> [success: bb6, unwind continue]; ++ _25 = copy _20; ++ assert(!copy _20, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _1) -> [success: bb6, unwind continue]; } bb6: { - _22 = Rem(move _23, move _24); -+ _22 = Rem(_1, _2); ++ _22 = Rem(copy _1, copy _2); StorageDead(_24); StorageDead(_23); - _21 = opaque::(move _22) -> [return: bb7, unwind continue]; -+ _21 = opaque::(_22) -> [return: bb7, unwind continue]; ++ _21 = opaque::(copy _22) -> [return: bb7, unwind continue]; } bb7: { @@ -304,15 +304,15 @@ - StorageLive(_27); + nop; StorageLive(_28); - _28 = _1; + _28 = copy _1; StorageLive(_29); - _29 = _2; + _29 = copy _2; - _27 = BitAnd(move _28, move _29); -+ _27 = BitAnd(_1, _2); ++ _27 = BitAnd(copy _1, copy _2); StorageDead(_29); StorageDead(_28); - _26 = opaque::(move _27) -> [return: bb8, unwind continue]; -+ _26 = opaque::(_27) -> [return: bb8, unwind continue]; ++ _26 = opaque::(copy _27) -> [return: bb8, unwind continue]; } bb8: { @@ -323,15 +323,15 @@ - StorageLive(_31); + nop; StorageLive(_32); - _32 = _1; + _32 = copy _1; StorageLive(_33); - _33 = _2; + _33 = copy _2; - _31 = BitOr(move _32, move _33); -+ _31 = BitOr(_1, _2); ++ _31 = BitOr(copy _1, copy _2); StorageDead(_33); StorageDead(_32); - _30 = opaque::(move _31) -> [return: bb9, unwind continue]; -+ _30 = opaque::(_31) -> [return: bb9, unwind continue]; ++ _30 = opaque::(copy _31) -> [return: bb9, unwind continue]; } bb9: { @@ -342,15 +342,15 @@ - StorageLive(_35); + nop; StorageLive(_36); - _36 = _1; + _36 = copy _1; StorageLive(_37); - _37 = _2; + _37 = copy _2; - _35 = BitXor(move _36, move _37); -+ _35 = BitXor(_1, _2); ++ _35 = BitXor(copy _1, copy _2); StorageDead(_37); StorageDead(_36); - _34 = opaque::(move _35) -> [return: bb10, unwind continue]; -+ _34 = opaque::(_35) -> [return: bb10, unwind continue]; ++ _34 = opaque::(copy _35) -> [return: bb10, unwind continue]; } bb10: { @@ -361,15 +361,15 @@ - StorageLive(_39); + nop; StorageLive(_40); - _40 = _1; + _40 = copy _1; StorageLive(_41); - _41 = _2; + _41 = copy _2; - _39 = Shl(move _40, move _41); -+ _39 = Shl(_1, _2); ++ _39 = Shl(copy _1, copy _2); StorageDead(_41); StorageDead(_40); - _38 = opaque::(move _39) -> [return: bb11, unwind continue]; -+ _38 = opaque::(_39) -> [return: bb11, unwind continue]; ++ _38 = opaque::(copy _39) -> [return: bb11, unwind continue]; } bb11: { @@ -380,15 +380,15 @@ - StorageLive(_43); + nop; StorageLive(_44); - _44 = _1; + _44 = copy _1; StorageLive(_45); - _45 = _2; + _45 = copy _2; - _43 = Shr(move _44, move _45); -+ _43 = Shr(_1, _2); ++ _43 = Shr(copy _1, copy _2); StorageDead(_45); StorageDead(_44); - _42 = opaque::(move _43) -> [return: bb12, unwind continue]; -+ _42 = opaque::(_43) -> [return: bb12, unwind continue]; ++ _42 = opaque::(copy _43) -> [return: bb12, unwind continue]; } bb12: { @@ -399,12 +399,12 @@ - StorageLive(_47); + nop; StorageLive(_48); - _48 = _1; + _48 = copy _1; - _47 = move _48 as u32 (IntToInt); -+ _47 = _1 as u32 (IntToInt); ++ _47 = copy _1 as u32 (IntToInt); StorageDead(_48); - _46 = opaque::(move _47) -> [return: bb13, unwind continue]; -+ _46 = opaque::(_47) -> [return: bb13, unwind continue]; ++ _46 = opaque::(copy _47) -> [return: bb13, unwind continue]; } bb13: { @@ -415,12 +415,12 @@ - StorageLive(_50); + nop; StorageLive(_51); - _51 = _1; + _51 = copy _1; - _50 = move _51 as f32 (IntToFloat); -+ _50 = _1 as f32 (IntToFloat); ++ _50 = copy _1 as f32 (IntToFloat); StorageDead(_51); - _49 = opaque::(move _50) -> [return: bb14, unwind continue]; -+ _49 = opaque::(_50) -> [return: bb14, unwind continue]; ++ _49 = opaque::(copy _50) -> [return: bb14, unwind continue]; } bb14: { @@ -431,12 +431,12 @@ - StorageLive(_53); + nop; StorageLive(_54); - _54 = _1; + _54 = copy _1; - _53 = S::(move _54); -+ _53 = S::(_1); ++ _53 = S::(copy _1); StorageDead(_54); - _52 = opaque::>(move _53) -> [return: bb15, unwind continue]; -+ _52 = opaque::>(_53) -> [return: bb15, unwind continue]; ++ _52 = opaque::>(copy _53) -> [return: bb15, unwind continue]; } bb15: { @@ -447,14 +447,14 @@ StorageLive(_56); StorageLive(_57); StorageLive(_58); - _58 = _1; + _58 = copy _1; - _57 = S::(move _58); -+ _57 = _53; ++ _57 = copy _53; StorageDead(_58); -- _56 = (_57.0: u64); +- _56 = copy (_57.0: u64); - _55 = opaque::(move _56) -> [return: bb16, unwind continue]; -+ _56 = _1; -+ _55 = opaque::(_1) -> [return: bb16, unwind continue]; ++ _56 = copy _1; ++ _55 = opaque::(copy _1) -> [return: bb16, unwind continue]; } bb16: { @@ -464,15 +464,15 @@ StorageLive(_59); StorageLive(_60); StorageLive(_61); - _61 = _1; + _61 = copy _1; StorageLive(_62); - _62 = _2; + _62 = copy _2; - _60 = Add(move _61, move _62); -+ _60 = _5; ++ _60 = copy _5; StorageDead(_62); StorageDead(_61); - _59 = opaque::(move _60) -> [return: bb17, unwind continue]; -+ _59 = opaque::(_5) -> [return: bb17, unwind continue]; ++ _59 = opaque::(copy _5) -> [return: bb17, unwind continue]; } bb17: { @@ -481,15 +481,15 @@ StorageLive(_63); StorageLive(_64); StorageLive(_65); - _65 = _1; + _65 = copy _1; StorageLive(_66); - _66 = _2; + _66 = copy _2; - _64 = Mul(move _65, move _66); -+ _64 = _9; ++ _64 = copy _9; StorageDead(_66); StorageDead(_65); - _63 = opaque::(move _64) -> [return: bb18, unwind continue]; -+ _63 = opaque::(_9) -> [return: bb18, unwind continue]; ++ _63 = opaque::(copy _9) -> [return: bb18, unwind continue]; } bb18: { @@ -498,15 +498,15 @@ StorageLive(_67); StorageLive(_68); StorageLive(_69); - _69 = _1; + _69 = copy _1; StorageLive(_70); - _70 = _2; + _70 = copy _2; - _68 = Sub(move _69, move _70); -+ _68 = _13; ++ _68 = copy _13; StorageDead(_70); StorageDead(_69); - _67 = opaque::(move _68) -> [return: bb19, unwind continue]; -+ _67 = opaque::(_13) -> [return: bb19, unwind continue]; ++ _67 = opaque::(copy _13) -> [return: bb19, unwind continue]; } bb19: { @@ -515,22 +515,22 @@ StorageLive(_71); StorageLive(_72); StorageLive(_73); - _73 = _1; + _73 = copy _1; StorageLive(_74); - _74 = _2; -- _75 = Eq(_74, const 0_u64); -- assert(!move _75, "attempt to divide `{}` by zero", _73) -> [success: bb20, unwind continue]; -+ _75 = _20; -+ assert(!_20, "attempt to divide `{}` by zero", _1) -> [success: bb20, unwind continue]; + _74 = copy _2; +- _75 = Eq(copy _74, const 0_u64); +- assert(!move _75, "attempt to divide `{}` by zero", copy _73) -> [success: bb20, unwind continue]; ++ _75 = copy _20; ++ assert(!copy _20, "attempt to divide `{}` by zero", copy _1) -> [success: bb20, unwind continue]; } bb20: { - _72 = Div(move _73, move _74); -+ _72 = _17; ++ _72 = copy _17; StorageDead(_74); StorageDead(_73); - _71 = opaque::(move _72) -> [return: bb21, unwind continue]; -+ _71 = opaque::(_17) -> [return: bb21, unwind continue]; ++ _71 = opaque::(copy _17) -> [return: bb21, unwind continue]; } bb21: { @@ -539,22 +539,22 @@ StorageLive(_76); StorageLive(_77); StorageLive(_78); - _78 = _1; + _78 = copy _1; StorageLive(_79); - _79 = _2; -- _80 = Eq(_79, const 0_u64); -- assert(!move _80, "attempt to calculate the remainder of `{}` with a divisor of zero", _78) -> [success: bb22, unwind continue]; -+ _80 = _20; -+ assert(!_20, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb22, unwind continue]; + _79 = copy _2; +- _80 = Eq(copy _79, const 0_u64); +- assert(!move _80, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _78) -> [success: bb22, unwind continue]; ++ _80 = copy _20; ++ assert(!copy _20, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _1) -> [success: bb22, unwind continue]; } bb22: { - _77 = Rem(move _78, move _79); -+ _77 = _22; ++ _77 = copy _22; StorageDead(_79); StorageDead(_78); - _76 = opaque::(move _77) -> [return: bb23, unwind continue]; -+ _76 = opaque::(_22) -> [return: bb23, unwind continue]; ++ _76 = opaque::(copy _22) -> [return: bb23, unwind continue]; } bb23: { @@ -563,15 +563,15 @@ StorageLive(_81); StorageLive(_82); StorageLive(_83); - _83 = _1; + _83 = copy _1; StorageLive(_84); - _84 = _2; + _84 = copy _2; - _82 = BitAnd(move _83, move _84); -+ _82 = _27; ++ _82 = copy _27; StorageDead(_84); StorageDead(_83); - _81 = opaque::(move _82) -> [return: bb24, unwind continue]; -+ _81 = opaque::(_27) -> [return: bb24, unwind continue]; ++ _81 = opaque::(copy _27) -> [return: bb24, unwind continue]; } bb24: { @@ -580,15 +580,15 @@ StorageLive(_85); StorageLive(_86); StorageLive(_87); - _87 = _1; + _87 = copy _1; StorageLive(_88); - _88 = _2; + _88 = copy _2; - _86 = BitOr(move _87, move _88); -+ _86 = _31; ++ _86 = copy _31; StorageDead(_88); StorageDead(_87); - _85 = opaque::(move _86) -> [return: bb25, unwind continue]; -+ _85 = opaque::(_31) -> [return: bb25, unwind continue]; ++ _85 = opaque::(copy _31) -> [return: bb25, unwind continue]; } bb25: { @@ -597,15 +597,15 @@ StorageLive(_89); StorageLive(_90); StorageLive(_91); - _91 = _1; + _91 = copy _1; StorageLive(_92); - _92 = _2; + _92 = copy _2; - _90 = BitXor(move _91, move _92); -+ _90 = _35; ++ _90 = copy _35; StorageDead(_92); StorageDead(_91); - _89 = opaque::(move _90) -> [return: bb26, unwind continue]; -+ _89 = opaque::(_35) -> [return: bb26, unwind continue]; ++ _89 = opaque::(copy _35) -> [return: bb26, unwind continue]; } bb26: { @@ -614,15 +614,15 @@ StorageLive(_93); StorageLive(_94); StorageLive(_95); - _95 = _1; + _95 = copy _1; StorageLive(_96); - _96 = _2; + _96 = copy _2; - _94 = Shl(move _95, move _96); -+ _94 = _39; ++ _94 = copy _39; StorageDead(_96); StorageDead(_95); - _93 = opaque::(move _94) -> [return: bb27, unwind continue]; -+ _93 = opaque::(_39) -> [return: bb27, unwind continue]; ++ _93 = opaque::(copy _39) -> [return: bb27, unwind continue]; } bb27: { @@ -631,15 +631,15 @@ StorageLive(_97); StorageLive(_98); StorageLive(_99); - _99 = _1; + _99 = copy _1; StorageLive(_100); - _100 = _2; + _100 = copy _2; - _98 = Shr(move _99, move _100); -+ _98 = _43; ++ _98 = copy _43; StorageDead(_100); StorageDead(_99); - _97 = opaque::(move _98) -> [return: bb28, unwind continue]; -+ _97 = opaque::(_43) -> [return: bb28, unwind continue]; ++ _97 = opaque::(copy _43) -> [return: bb28, unwind continue]; } bb28: { @@ -648,12 +648,12 @@ StorageLive(_101); StorageLive(_102); StorageLive(_103); - _103 = _1; + _103 = copy _1; - _102 = move _103 as u32 (IntToInt); -+ _102 = _47; ++ _102 = copy _47; StorageDead(_103); - _101 = opaque::(move _102) -> [return: bb29, unwind continue]; -+ _101 = opaque::(_47) -> [return: bb29, unwind continue]; ++ _101 = opaque::(copy _47) -> [return: bb29, unwind continue]; } bb29: { @@ -662,12 +662,12 @@ StorageLive(_104); StorageLive(_105); StorageLive(_106); - _106 = _1; + _106 = copy _1; - _105 = move _106 as f32 (IntToFloat); -+ _105 = _50; ++ _105 = copy _50; StorageDead(_106); - _104 = opaque::(move _105) -> [return: bb30, unwind continue]; -+ _104 = opaque::(_50) -> [return: bb30, unwind continue]; ++ _104 = opaque::(copy _50) -> [return: bb30, unwind continue]; } bb30: { @@ -676,12 +676,12 @@ StorageLive(_107); StorageLive(_108); StorageLive(_109); - _109 = _1; + _109 = copy _1; - _108 = S::(move _109); -+ _108 = _53; ++ _108 = copy _53; StorageDead(_109); - _107 = opaque::>(move _108) -> [return: bb31, unwind continue]; -+ _107 = opaque::>(_53) -> [return: bb31, unwind continue]; ++ _107 = opaque::>(copy _53) -> [return: bb31, unwind continue]; } bb31: { @@ -691,14 +691,14 @@ StorageLive(_111); StorageLive(_112); StorageLive(_113); - _113 = _1; + _113 = copy _1; - _112 = S::(move _113); -+ _112 = _53; ++ _112 = copy _53; StorageDead(_113); -- _111 = (_112.0: u64); +- _111 = copy (_112.0: u64); - _110 = opaque::(move _111) -> [return: bb32, unwind continue]; -+ _111 = _1; -+ _110 = opaque::(_1) -> [return: bb32, unwind continue]; ++ _111 = copy _1; ++ _110 = opaque::(copy _1) -> [return: bb32, unwind continue]; } bb32: { @@ -710,21 +710,21 @@ + nop; StorageLive(_116); StorageLive(_117); - _117 = _1; + _117 = copy _1; StorageLive(_118); - _118 = _2; + _118 = copy _2; - _116 = Mul(move _117, move _118); -+ _116 = _9; ++ _116 = copy _9; StorageDead(_118); StorageDead(_117); StorageLive(_119); - _119 = _2; + _119 = copy _2; - _115 = Sub(move _116, move _119); -+ _115 = Sub(_9, _2); ++ _115 = Sub(copy _9, copy _2); StorageDead(_119); StorageDead(_116); - _114 = opaque::(move _115) -> [return: bb33, unwind continue]; -+ _114 = opaque::(_115) -> [return: bb33, unwind continue]; ++ _114 = opaque::(copy _115) -> [return: bb33, unwind continue]; } bb33: { @@ -735,21 +735,21 @@ StorageLive(_121); StorageLive(_122); StorageLive(_123); - _123 = _1; + _123 = copy _1; StorageLive(_124); - _124 = _2; + _124 = copy _2; - _122 = Mul(move _123, move _124); -+ _122 = _9; ++ _122 = copy _9; StorageDead(_124); StorageDead(_123); StorageLive(_125); - _125 = _2; + _125 = copy _2; - _121 = Sub(move _122, move _125); -+ _121 = _115; ++ _121 = copy _115; StorageDead(_125); StorageDead(_122); - _120 = opaque::(move _121) -> [return: bb34, unwind continue]; -+ _120 = opaque::(_115) -> [return: bb34, unwind continue]; ++ _120 = opaque::(copy _115) -> [return: bb34, unwind continue]; } bb34: { @@ -762,16 +762,16 @@ - StorageLive(_129); + nop; + nop; - _129 = (*_126); + _129 = copy (*_126); StorageLive(_130); - _130 = _1; + _130 = copy _1; - _128 = Add(move _129, move _130); -+ _128 = Add(_129, _1); ++ _128 = Add(copy _129, copy _1); StorageDead(_130); - StorageDead(_129); - _127 = opaque::(move _128) -> [return: bb35, unwind continue]; + nop; -+ _127 = opaque::(_128) -> [return: bb35, unwind continue]; ++ _127 = opaque::(copy _128) -> [return: bb35, unwind continue]; } bb35: { @@ -781,16 +781,16 @@ StorageLive(_131); StorageLive(_132); StorageLive(_133); -- _133 = (*_126); -+ _133 = _129; +- _133 = copy (*_126); ++ _133 = copy _129; StorageLive(_134); - _134 = _1; + _134 = copy _1; - _132 = Add(move _133, move _134); -+ _132 = _128; ++ _132 = copy _128; StorageDead(_134); StorageDead(_133); - _131 = opaque::(move _132) -> [return: bb36, unwind continue]; -+ _131 = opaque::(_128) -> [return: bb36, unwind continue]; ++ _131 = opaque::(copy _128) -> [return: bb36, unwind continue]; } bb36: { @@ -801,11 +801,11 @@ StorageLive(_136); StorageLive(_137); StorageLive(_138); - _138 = (*_135); + _138 = copy (*_135); StorageLive(_139); - _139 = _1; + _139 = copy _1; - _137 = Add(move _138, move _139); -+ _137 = Add(move _138, _1); ++ _137 = Add(move _138, copy _1); StorageDead(_139); StorageDead(_138); _136 = opaque::(move _137) -> [return: bb37, unwind continue]; @@ -817,11 +817,11 @@ StorageLive(_140); StorageLive(_141); StorageLive(_142); - _142 = (*_135); + _142 = copy (*_135); StorageLive(_143); - _143 = _1; + _143 = copy _1; - _141 = Add(move _142, move _143); -+ _141 = Add(move _142, _1); ++ _141 = Add(move _142, copy _1); StorageDead(_143); StorageDead(_142); _140 = opaque::(move _141) -> [return: bb38, unwind continue]; @@ -836,11 +836,11 @@ StorageLive(_146); StorageLive(_147); StorageLive(_148); - _148 = (*_145); + _148 = copy (*_145); StorageLive(_149); - _149 = _1; + _149 = copy _1; - _147 = Add(move _148, move _149); -+ _147 = Add(move _148, _1); ++ _147 = Add(move _148, copy _1); StorageDead(_149); StorageDead(_148); _146 = opaque::(move _147) -> [return: bb39, unwind continue]; @@ -852,11 +852,11 @@ StorageLive(_150); StorageLive(_151); StorageLive(_152); - _152 = (*_145); + _152 = copy (*_145); StorageLive(_153); - _153 = _1; + _153 = copy _1; - _151 = Add(move _152, move _153); -+ _151 = Add(move _152, _1); ++ _151 = Add(move _152, copy _1); StorageDead(_153); StorageDead(_152); _150 = opaque::(move _151) -> [return: bb40, unwind continue]; @@ -870,11 +870,11 @@ StorageLive(_155); StorageLive(_156); StorageLive(_157); - _157 = (*_154); + _157 = copy (*_154); StorageLive(_158); - _158 = _1; + _158 = copy _1; - _156 = Add(move _157, move _158); -+ _156 = Add(move _157, _1); ++ _156 = Add(move _157, copy _1); StorageDead(_158); StorageDead(_157); _155 = opaque::(move _156) -> [return: bb41, unwind continue]; @@ -886,11 +886,11 @@ StorageLive(_159); StorageLive(_160); StorageLive(_161); - _161 = (*_154); + _161 = copy (*_154); StorageLive(_162); - _162 = _1; + _162 = copy _1; - _160 = Add(move _161, move _162); -+ _160 = Add(move _161, _1); ++ _160 = Add(move _161, copy _1); StorageDead(_162); StorageDead(_161); _159 = opaque::(move _160) -> [return: bb42, unwind continue]; @@ -910,16 +910,16 @@ - StorageLive(_166); + nop; + nop; - _166 = (*_163); + _166 = copy (*_163); StorageLive(_167); - _167 = _1; + _167 = copy _1; - _165 = Add(move _166, move _167); -+ _165 = Add(_166, _1); ++ _165 = Add(copy _166, copy _1); StorageDead(_167); - StorageDead(_166); - _164 = opaque::(move _165) -> [return: bb43, unwind continue]; + nop; -+ _164 = opaque::(_165) -> [return: bb43, unwind continue]; ++ _164 = opaque::(copy _165) -> [return: bb43, unwind continue]; } bb43: { @@ -929,16 +929,16 @@ StorageLive(_168); StorageLive(_169); StorageLive(_170); -- _170 = (*_163); -+ _170 = _166; +- _170 = copy (*_163); ++ _170 = copy _166; StorageLive(_171); - _171 = _1; + _171 = copy _1; - _169 = Add(move _170, move _171); -+ _169 = _165; ++ _169 = copy _165; StorageDead(_171); StorageDead(_170); - _168 = opaque::(move _169) -> [return: bb44, unwind continue]; -+ _168 = opaque::(_165) -> [return: bb44, unwind continue]; ++ _168 = opaque::(copy _165) -> [return: bb44, unwind continue]; } bb44: { diff --git a/tests/mir-opt/gvn.unary.GVN.panic-abort.diff b/tests/mir-opt/gvn.unary.GVN.panic-abort.diff index 9469032f294e..d14aec6df5fa 100644 --- a/tests/mir-opt/gvn.unary.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.unary.GVN.panic-abort.diff @@ -37,15 +37,15 @@ StorageLive(_3); StorageLive(_4); StorageLive(_5); - _5 = _1; + _5 = copy _1; - _4 = Neg(move _5); -+ _4 = Neg(_1); ++ _4 = Neg(copy _1); StorageDead(_5); - _3 = Neg(move _4); -+ _3 = _1; ++ _3 = copy _1; StorageDead(_4); - _2 = opaque::(move _3) -> [return: bb1, unwind unreachable]; -+ _2 = opaque::(_1) -> [return: bb1, unwind unreachable]; ++ _2 = opaque::(copy _1) -> [return: bb1, unwind unreachable]; } bb1: { @@ -54,23 +54,23 @@ - StorageLive(_6); + nop; StorageLive(_7); - _7 = _1; + _7 = copy _1; - _6 = Lt(move _7, const 13_i64); -+ _6 = Lt(_1, const 13_i64); ++ _6 = Lt(copy _1, const 13_i64); StorageDead(_7); StorageLive(_8); StorageLive(_9); StorageLive(_10); StorageLive(_11); - _11 = _6; + _11 = copy _6; - _10 = Not(move _11); -+ _10 = Not(_6); ++ _10 = Not(copy _6); StorageDead(_11); - _9 = Not(move _10); -+ _9 = _6; ++ _9 = copy _6; StorageDead(_10); - _8 = opaque::(move _9) -> [return: bb2, unwind unreachable]; -+ _8 = opaque::(_6) -> [return: bb2, unwind unreachable]; ++ _8 = opaque::(copy _6) -> [return: bb2, unwind unreachable]; } bb2: { @@ -80,12 +80,12 @@ - StorageLive(_13); + nop; StorageLive(_14); - _14 = _1; + _14 = copy _1; - _13 = Ne(move _14, const 15_i64); -+ _13 = Ne(_1, const 15_i64); ++ _13 = Ne(copy _1, const 15_i64); StorageDead(_14); - _12 = opaque::(move _13) -> [return: bb3, unwind unreachable]; -+ _12 = opaque::(_13) -> [return: bb3, unwind unreachable]; ++ _12 = opaque::(copy _13) -> [return: bb3, unwind unreachable]; } bb3: { @@ -96,15 +96,15 @@ StorageLive(_16); StorageLive(_17); StorageLive(_18); - _18 = _1; + _18 = copy _1; - _17 = Eq(move _18, const 15_i64); -+ _17 = Eq(_1, const 15_i64); ++ _17 = Eq(copy _1, const 15_i64); StorageDead(_18); - _16 = Not(move _17); -+ _16 = _13; ++ _16 = copy _13; StorageDead(_17); - _15 = opaque::(move _16) -> [return: bb4, unwind unreachable]; -+ _15 = opaque::(_13) -> [return: bb4, unwind unreachable]; ++ _15 = opaque::(copy _13) -> [return: bb4, unwind unreachable]; } bb4: { @@ -114,12 +114,12 @@ - StorageLive(_20); + nop; StorageLive(_21); - _21 = _1; + _21 = copy _1; - _20 = Eq(move _21, const 35_i64); -+ _20 = Eq(_1, const 35_i64); ++ _20 = Eq(copy _1, const 35_i64); StorageDead(_21); - _19 = opaque::(move _20) -> [return: bb5, unwind unreachable]; -+ _19 = opaque::(_20) -> [return: bb5, unwind unreachable]; ++ _19 = opaque::(copy _20) -> [return: bb5, unwind unreachable]; } bb5: { @@ -130,15 +130,15 @@ StorageLive(_23); StorageLive(_24); StorageLive(_25); - _25 = _1; + _25 = copy _1; - _24 = Ne(move _25, const 35_i64); -+ _24 = Ne(_1, const 35_i64); ++ _24 = Ne(copy _1, const 35_i64); StorageDead(_25); - _23 = Not(move _24); -+ _23 = _20; ++ _23 = copy _20; StorageDead(_24); - _22 = opaque::(move _23) -> [return: bb6, unwind unreachable]; -+ _22 = opaque::(_20) -> [return: bb6, unwind unreachable]; ++ _22 = opaque::(copy _20) -> [return: bb6, unwind unreachable]; } bb6: { diff --git a/tests/mir-opt/gvn.unary.GVN.panic-unwind.diff b/tests/mir-opt/gvn.unary.GVN.panic-unwind.diff index e672f6fb6ba7..5978f1faa1f6 100644 --- a/tests/mir-opt/gvn.unary.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.unary.GVN.panic-unwind.diff @@ -37,15 +37,15 @@ StorageLive(_3); StorageLive(_4); StorageLive(_5); - _5 = _1; + _5 = copy _1; - _4 = Neg(move _5); -+ _4 = Neg(_1); ++ _4 = Neg(copy _1); StorageDead(_5); - _3 = Neg(move _4); -+ _3 = _1; ++ _3 = copy _1; StorageDead(_4); - _2 = opaque::(move _3) -> [return: bb1, unwind continue]; -+ _2 = opaque::(_1) -> [return: bb1, unwind continue]; ++ _2 = opaque::(copy _1) -> [return: bb1, unwind continue]; } bb1: { @@ -54,23 +54,23 @@ - StorageLive(_6); + nop; StorageLive(_7); - _7 = _1; + _7 = copy _1; - _6 = Lt(move _7, const 13_i64); -+ _6 = Lt(_1, const 13_i64); ++ _6 = Lt(copy _1, const 13_i64); StorageDead(_7); StorageLive(_8); StorageLive(_9); StorageLive(_10); StorageLive(_11); - _11 = _6; + _11 = copy _6; - _10 = Not(move _11); -+ _10 = Not(_6); ++ _10 = Not(copy _6); StorageDead(_11); - _9 = Not(move _10); -+ _9 = _6; ++ _9 = copy _6; StorageDead(_10); - _8 = opaque::(move _9) -> [return: bb2, unwind continue]; -+ _8 = opaque::(_6) -> [return: bb2, unwind continue]; ++ _8 = opaque::(copy _6) -> [return: bb2, unwind continue]; } bb2: { @@ -80,12 +80,12 @@ - StorageLive(_13); + nop; StorageLive(_14); - _14 = _1; + _14 = copy _1; - _13 = Ne(move _14, const 15_i64); -+ _13 = Ne(_1, const 15_i64); ++ _13 = Ne(copy _1, const 15_i64); StorageDead(_14); - _12 = opaque::(move _13) -> [return: bb3, unwind continue]; -+ _12 = opaque::(_13) -> [return: bb3, unwind continue]; ++ _12 = opaque::(copy _13) -> [return: bb3, unwind continue]; } bb3: { @@ -96,15 +96,15 @@ StorageLive(_16); StorageLive(_17); StorageLive(_18); - _18 = _1; + _18 = copy _1; - _17 = Eq(move _18, const 15_i64); -+ _17 = Eq(_1, const 15_i64); ++ _17 = Eq(copy _1, const 15_i64); StorageDead(_18); - _16 = Not(move _17); -+ _16 = _13; ++ _16 = copy _13; StorageDead(_17); - _15 = opaque::(move _16) -> [return: bb4, unwind continue]; -+ _15 = opaque::(_13) -> [return: bb4, unwind continue]; ++ _15 = opaque::(copy _13) -> [return: bb4, unwind continue]; } bb4: { @@ -114,12 +114,12 @@ - StorageLive(_20); + nop; StorageLive(_21); - _21 = _1; + _21 = copy _1; - _20 = Eq(move _21, const 35_i64); -+ _20 = Eq(_1, const 35_i64); ++ _20 = Eq(copy _1, const 35_i64); StorageDead(_21); - _19 = opaque::(move _20) -> [return: bb5, unwind continue]; -+ _19 = opaque::(_20) -> [return: bb5, unwind continue]; ++ _19 = opaque::(copy _20) -> [return: bb5, unwind continue]; } bb5: { @@ -130,15 +130,15 @@ StorageLive(_23); StorageLive(_24); StorageLive(_25); - _25 = _1; + _25 = copy _1; - _24 = Ne(move _25, const 35_i64); -+ _24 = Ne(_1, const 35_i64); ++ _24 = Ne(copy _1, const 35_i64); StorageDead(_25); - _23 = Not(move _24); -+ _23 = _20; ++ _23 = copy _20; StorageDead(_24); - _22 = opaque::(move _23) -> [return: bb6, unwind continue]; -+ _22 = opaque::(_20) -> [return: bb6, unwind continue]; ++ _22 = opaque::(copy _20) -> [return: bb6, unwind continue]; } bb6: { diff --git a/tests/mir-opt/gvn.wide_ptr_integer.GVN.panic-abort.diff b/tests/mir-opt/gvn.wide_ptr_integer.GVN.panic-abort.diff index 3eed0473f7fc..bb938f3ba6a9 100644 --- a/tests/mir-opt/gvn.wide_ptr_integer.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.wide_ptr_integer.GVN.panic-abort.diff @@ -58,10 +58,10 @@ StorageLive(_5); StorageLive(_6); StorageLive(_7); -- _7 = _1; +- _7 = copy _1; + _7 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8]; StorageLive(_8); -- _8 = _3; +- _8 = copy _3; - _6 = Eq(move _7, move _8); + _8 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]; + _6 = const false; @@ -77,10 +77,10 @@ StorageLive(_9); StorageLive(_10); StorageLive(_11); -- _11 = _1; +- _11 = copy _1; + _11 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8]; StorageLive(_12); -- _12 = _3; +- _12 = copy _3; - _10 = Ne(move _11, move _12); + _12 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]; + _10 = const true; @@ -96,10 +96,10 @@ StorageLive(_13); StorageLive(_14); StorageLive(_15); -- _15 = _1; +- _15 = copy _1; + _15 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8]; StorageLive(_16); -- _16 = _3; +- _16 = copy _3; - _14 = Lt(move _15, move _16); + _16 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]; + _14 = const true; @@ -115,10 +115,10 @@ StorageLive(_17); StorageLive(_18); StorageLive(_19); -- _19 = _1; +- _19 = copy _1; + _19 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8]; StorageLive(_20); -- _20 = _3; +- _20 = copy _3; - _18 = Le(move _19, move _20); + _20 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]; + _18 = const true; @@ -134,10 +134,10 @@ StorageLive(_21); StorageLive(_22); StorageLive(_23); -- _23 = _1; +- _23 = copy _1; + _23 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8]; StorageLive(_24); -- _24 = _3; +- _24 = copy _3; - _22 = Gt(move _23, move _24); + _24 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]; + _22 = const false; @@ -153,10 +153,10 @@ StorageLive(_25); StorageLive(_26); StorageLive(_27); -- _27 = _1; +- _27 = copy _1; + _27 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8]; StorageLive(_28); -- _28 = _3; +- _28 = copy _3; - _26 = Ge(move _27, move _28); + _28 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]; + _26 = const false; diff --git a/tests/mir-opt/gvn.wide_ptr_integer.GVN.panic-unwind.diff b/tests/mir-opt/gvn.wide_ptr_integer.GVN.panic-unwind.diff index 9a6e255a872e..81432d687eb3 100644 --- a/tests/mir-opt/gvn.wide_ptr_integer.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.wide_ptr_integer.GVN.panic-unwind.diff @@ -58,10 +58,10 @@ StorageLive(_5); StorageLive(_6); StorageLive(_7); -- _7 = _1; +- _7 = copy _1; + _7 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8]; StorageLive(_8); -- _8 = _3; +- _8 = copy _3; - _6 = Eq(move _7, move _8); + _8 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]; + _6 = const false; @@ -77,10 +77,10 @@ StorageLive(_9); StorageLive(_10); StorageLive(_11); -- _11 = _1; +- _11 = copy _1; + _11 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8]; StorageLive(_12); -- _12 = _3; +- _12 = copy _3; - _10 = Ne(move _11, move _12); + _12 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]; + _10 = const true; @@ -96,10 +96,10 @@ StorageLive(_13); StorageLive(_14); StorageLive(_15); -- _15 = _1; +- _15 = copy _1; + _15 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8]; StorageLive(_16); -- _16 = _3; +- _16 = copy _3; - _14 = Lt(move _15, move _16); + _16 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]; + _14 = const true; @@ -115,10 +115,10 @@ StorageLive(_17); StorageLive(_18); StorageLive(_19); -- _19 = _1; +- _19 = copy _1; + _19 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8]; StorageLive(_20); -- _20 = _3; +- _20 = copy _3; - _18 = Le(move _19, move _20); + _20 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]; + _18 = const true; @@ -134,10 +134,10 @@ StorageLive(_21); StorageLive(_22); StorageLive(_23); -- _23 = _1; +- _23 = copy _1; + _23 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8]; StorageLive(_24); -- _24 = _3; +- _24 = copy _3; - _22 = Gt(move _23, move _24); + _24 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]; + _22 = const false; @@ -153,10 +153,10 @@ StorageLive(_25); StorageLive(_26); StorageLive(_27); -- _27 = _1; +- _27 = copy _1; + _27 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8]; StorageLive(_28); -- _28 = _3; +- _28 = copy _3; - _26 = Ge(move _27, move _28); + _28 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]; + _26 = const false; diff --git a/tests/mir-opt/gvn.wide_ptr_provenance.GVN.panic-abort.diff b/tests/mir-opt/gvn.wide_ptr_provenance.GVN.panic-abort.diff index 629c22256820..c58362e391c4 100644 --- a/tests/mir-opt/gvn.wide_ptr_provenance.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.wide_ptr_provenance.GVN.panic-abort.diff @@ -69,7 +69,7 @@ _2 = &raw const (*_3); - _1 = move _2 as *const dyn std::marker::Send (PointerCoercion(Unsize)); - StorageDead(_2); -+ _1 = _2; ++ _1 = copy _2; + nop; StorageDead(_5); StorageDead(_3); @@ -87,24 +87,24 @@ _8 = &raw const (*_9); - _7 = move _8 as *const dyn std::marker::Send (PointerCoercion(Unsize)); - StorageDead(_8); -+ _7 = _8; ++ _7 = copy _8; + nop; StorageDead(_11); StorageDead(_9); StorageLive(_13); StorageLive(_14); StorageLive(_15); -- _15 = _1; -+ _15 = _2; +- _15 = copy _1; ++ _15 = copy _2; StorageLive(_16); StorageLive(_17); -- _17 = _7; +- _17 = copy _7; - _16 = move _17 as *const dyn std::marker::Send (PointerCoercion(Unsize)); -+ _17 = _8; -+ _16 = _8; ++ _17 = copy _8; ++ _16 = copy _8; StorageDead(_17); - _14 = Eq(move _15, move _16); -+ _14 = Eq(_2, _8); ++ _14 = Eq(copy _2, copy _8); StorageDead(_16); StorageDead(_15); _13 = opaque::(move _14) -> [return: bb1, unwind unreachable]; @@ -116,17 +116,17 @@ StorageLive(_18); StorageLive(_19); StorageLive(_20); -- _20 = _1; -+ _20 = _2; +- _20 = copy _1; ++ _20 = copy _2; StorageLive(_21); StorageLive(_22); -- _22 = _7; +- _22 = copy _7; - _21 = move _22 as *const dyn std::marker::Send (PointerCoercion(Unsize)); -+ _22 = _8; -+ _21 = _8; ++ _22 = copy _8; ++ _21 = copy _8; StorageDead(_22); - _19 = Ne(move _20, move _21); -+ _19 = Ne(_2, _8); ++ _19 = Ne(copy _2, copy _8); StorageDead(_21); StorageDead(_20); _18 = opaque::(move _19) -> [return: bb2, unwind unreachable]; @@ -138,17 +138,17 @@ StorageLive(_23); StorageLive(_24); StorageLive(_25); -- _25 = _1; -+ _25 = _2; +- _25 = copy _1; ++ _25 = copy _2; StorageLive(_26); StorageLive(_27); -- _27 = _7; +- _27 = copy _7; - _26 = move _27 as *const dyn std::marker::Send (PointerCoercion(Unsize)); -+ _27 = _8; -+ _26 = _8; ++ _27 = copy _8; ++ _26 = copy _8; StorageDead(_27); - _24 = Lt(move _25, move _26); -+ _24 = Lt(_2, _8); ++ _24 = Lt(copy _2, copy _8); StorageDead(_26); StorageDead(_25); _23 = opaque::(move _24) -> [return: bb3, unwind unreachable]; @@ -160,17 +160,17 @@ StorageLive(_28); StorageLive(_29); StorageLive(_30); -- _30 = _1; -+ _30 = _2; +- _30 = copy _1; ++ _30 = copy _2; StorageLive(_31); StorageLive(_32); -- _32 = _7; +- _32 = copy _7; - _31 = move _32 as *const dyn std::marker::Send (PointerCoercion(Unsize)); -+ _32 = _8; -+ _31 = _8; ++ _32 = copy _8; ++ _31 = copy _8; StorageDead(_32); - _29 = Le(move _30, move _31); -+ _29 = Le(_2, _8); ++ _29 = Le(copy _2, copy _8); StorageDead(_31); StorageDead(_30); _28 = opaque::(move _29) -> [return: bb4, unwind unreachable]; @@ -182,17 +182,17 @@ StorageLive(_33); StorageLive(_34); StorageLive(_35); -- _35 = _1; -+ _35 = _2; +- _35 = copy _1; ++ _35 = copy _2; StorageLive(_36); StorageLive(_37); -- _37 = _7; +- _37 = copy _7; - _36 = move _37 as *const dyn std::marker::Send (PointerCoercion(Unsize)); -+ _37 = _8; -+ _36 = _8; ++ _37 = copy _8; ++ _36 = copy _8; StorageDead(_37); - _34 = Gt(move _35, move _36); -+ _34 = Gt(_2, _8); ++ _34 = Gt(copy _2, copy _8); StorageDead(_36); StorageDead(_35); _33 = opaque::(move _34) -> [return: bb5, unwind unreachable]; @@ -204,17 +204,17 @@ StorageLive(_38); StorageLive(_39); StorageLive(_40); -- _40 = _1; -+ _40 = _2; +- _40 = copy _1; ++ _40 = copy _2; StorageLive(_41); StorageLive(_42); -- _42 = _7; +- _42 = copy _7; - _41 = move _42 as *const dyn std::marker::Send (PointerCoercion(Unsize)); -+ _42 = _8; -+ _41 = _8; ++ _42 = copy _8; ++ _41 = copy _8; StorageDead(_42); - _39 = Ge(move _40, move _41); -+ _39 = Ge(_2, _8); ++ _39 = Ge(copy _2, copy _8); StorageDead(_41); StorageDead(_40); _38 = opaque::(move _39) -> [return: bb6, unwind unreachable]; diff --git a/tests/mir-opt/gvn.wide_ptr_provenance.GVN.panic-unwind.diff b/tests/mir-opt/gvn.wide_ptr_provenance.GVN.panic-unwind.diff index 3380bc84cb80..b29ee862c81a 100644 --- a/tests/mir-opt/gvn.wide_ptr_provenance.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.wide_ptr_provenance.GVN.panic-unwind.diff @@ -69,7 +69,7 @@ _2 = &raw const (*_3); - _1 = move _2 as *const dyn std::marker::Send (PointerCoercion(Unsize)); - StorageDead(_2); -+ _1 = _2; ++ _1 = copy _2; + nop; StorageDead(_5); StorageDead(_3); @@ -87,24 +87,24 @@ _8 = &raw const (*_9); - _7 = move _8 as *const dyn std::marker::Send (PointerCoercion(Unsize)); - StorageDead(_8); -+ _7 = _8; ++ _7 = copy _8; + nop; StorageDead(_11); StorageDead(_9); StorageLive(_13); StorageLive(_14); StorageLive(_15); -- _15 = _1; -+ _15 = _2; +- _15 = copy _1; ++ _15 = copy _2; StorageLive(_16); StorageLive(_17); -- _17 = _7; +- _17 = copy _7; - _16 = move _17 as *const dyn std::marker::Send (PointerCoercion(Unsize)); -+ _17 = _8; -+ _16 = _8; ++ _17 = copy _8; ++ _16 = copy _8; StorageDead(_17); - _14 = Eq(move _15, move _16); -+ _14 = Eq(_2, _8); ++ _14 = Eq(copy _2, copy _8); StorageDead(_16); StorageDead(_15); _13 = opaque::(move _14) -> [return: bb1, unwind continue]; @@ -116,17 +116,17 @@ StorageLive(_18); StorageLive(_19); StorageLive(_20); -- _20 = _1; -+ _20 = _2; +- _20 = copy _1; ++ _20 = copy _2; StorageLive(_21); StorageLive(_22); -- _22 = _7; +- _22 = copy _7; - _21 = move _22 as *const dyn std::marker::Send (PointerCoercion(Unsize)); -+ _22 = _8; -+ _21 = _8; ++ _22 = copy _8; ++ _21 = copy _8; StorageDead(_22); - _19 = Ne(move _20, move _21); -+ _19 = Ne(_2, _8); ++ _19 = Ne(copy _2, copy _8); StorageDead(_21); StorageDead(_20); _18 = opaque::(move _19) -> [return: bb2, unwind continue]; @@ -138,17 +138,17 @@ StorageLive(_23); StorageLive(_24); StorageLive(_25); -- _25 = _1; -+ _25 = _2; +- _25 = copy _1; ++ _25 = copy _2; StorageLive(_26); StorageLive(_27); -- _27 = _7; +- _27 = copy _7; - _26 = move _27 as *const dyn std::marker::Send (PointerCoercion(Unsize)); -+ _27 = _8; -+ _26 = _8; ++ _27 = copy _8; ++ _26 = copy _8; StorageDead(_27); - _24 = Lt(move _25, move _26); -+ _24 = Lt(_2, _8); ++ _24 = Lt(copy _2, copy _8); StorageDead(_26); StorageDead(_25); _23 = opaque::(move _24) -> [return: bb3, unwind continue]; @@ -160,17 +160,17 @@ StorageLive(_28); StorageLive(_29); StorageLive(_30); -- _30 = _1; -+ _30 = _2; +- _30 = copy _1; ++ _30 = copy _2; StorageLive(_31); StorageLive(_32); -- _32 = _7; +- _32 = copy _7; - _31 = move _32 as *const dyn std::marker::Send (PointerCoercion(Unsize)); -+ _32 = _8; -+ _31 = _8; ++ _32 = copy _8; ++ _31 = copy _8; StorageDead(_32); - _29 = Le(move _30, move _31); -+ _29 = Le(_2, _8); ++ _29 = Le(copy _2, copy _8); StorageDead(_31); StorageDead(_30); _28 = opaque::(move _29) -> [return: bb4, unwind continue]; @@ -182,17 +182,17 @@ StorageLive(_33); StorageLive(_34); StorageLive(_35); -- _35 = _1; -+ _35 = _2; +- _35 = copy _1; ++ _35 = copy _2; StorageLive(_36); StorageLive(_37); -- _37 = _7; +- _37 = copy _7; - _36 = move _37 as *const dyn std::marker::Send (PointerCoercion(Unsize)); -+ _37 = _8; -+ _36 = _8; ++ _37 = copy _8; ++ _36 = copy _8; StorageDead(_37); - _34 = Gt(move _35, move _36); -+ _34 = Gt(_2, _8); ++ _34 = Gt(copy _2, copy _8); StorageDead(_36); StorageDead(_35); _33 = opaque::(move _34) -> [return: bb5, unwind continue]; @@ -204,17 +204,17 @@ StorageLive(_38); StorageLive(_39); StorageLive(_40); -- _40 = _1; -+ _40 = _2; +- _40 = copy _1; ++ _40 = copy _2; StorageLive(_41); StorageLive(_42); -- _42 = _7; +- _42 = copy _7; - _41 = move _42 as *const dyn std::marker::Send (PointerCoercion(Unsize)); -+ _42 = _8; -+ _41 = _8; ++ _42 = copy _8; ++ _41 = copy _8; StorageDead(_42); - _39 = Ge(move _40, move _41); -+ _39 = Ge(_2, _8); ++ _39 = Ge(copy _2, copy _8); StorageDead(_41); StorageDead(_40); _38 = opaque::(move _39) -> [return: bb6, unwind continue]; diff --git a/tests/mir-opt/gvn.wide_ptr_same_provenance.GVN.panic-abort.diff b/tests/mir-opt/gvn.wide_ptr_same_provenance.GVN.panic-abort.diff index da1662615d24..f4c38b7ab071 100644 --- a/tests/mir-opt/gvn.wide_ptr_same_provenance.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.wide_ptr_same_provenance.GVN.panic-abort.diff @@ -75,8 +75,8 @@ StorageLive(_8); _8 = const 0_usize; - _9 = Len((*_1)); -- _10 = Lt(_8, _9); -- assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, _8) -> [success: bb1, unwind unreachable]; +- _10 = Lt(copy _8, copy _9); +- assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, copy _8) -> [success: bb1, unwind unreachable]; + _9 = const 2_usize; + _10 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 2_usize, const 0_usize) -> [success: bb1, unwind unreachable]; @@ -91,7 +91,7 @@ _4 = &raw const (*_5); - _3 = move _4 as *const dyn std::marker::Send (PointerCoercion(Unsize)); - StorageDead(_4); -+ _3 = _4; ++ _3 = copy _4; + nop; StorageDead(_7); StorageDead(_5); @@ -104,8 +104,8 @@ StorageLive(_16); _16 = const 1_usize; - _17 = Len((*_1)); -- _18 = Lt(_16, _17); -- assert(move _18, "index out of bounds: the length is {} but the index is {}", move _17, _16) -> [success: bb2, unwind unreachable]; +- _18 = Lt(copy _16, copy _17); +- assert(move _18, "index out of bounds: the length is {} but the index is {}", move _17, copy _16) -> [success: bb2, unwind unreachable]; + _17 = const 2_usize; + _18 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 2_usize, const 1_usize) -> [success: bb2, unwind unreachable]; @@ -120,24 +120,24 @@ _12 = &raw const (*_13); - _11 = move _12 as *const dyn std::marker::Send (PointerCoercion(Unsize)); - StorageDead(_12); -+ _11 = _12; ++ _11 = copy _12; + nop; StorageDead(_15); StorageDead(_13); StorageLive(_19); StorageLive(_20); StorageLive(_21); -- _21 = _3; -+ _21 = _4; +- _21 = copy _3; ++ _21 = copy _4; StorageLive(_22); StorageLive(_23); -- _23 = _11; +- _23 = copy _11; - _22 = move _23 as *const dyn std::marker::Send (PointerCoercion(Unsize)); -+ _23 = _12; -+ _22 = _12; ++ _23 = copy _12; ++ _22 = copy _12; StorageDead(_23); - _20 = Eq(move _21, move _22); -+ _20 = Eq(_4, _12); ++ _20 = Eq(copy _4, copy _12); StorageDead(_22); StorageDead(_21); _19 = opaque::(move _20) -> [return: bb3, unwind unreachable]; @@ -149,17 +149,17 @@ StorageLive(_24); StorageLive(_25); StorageLive(_26); -- _26 = _3; -+ _26 = _4; +- _26 = copy _3; ++ _26 = copy _4; StorageLive(_27); StorageLive(_28); -- _28 = _11; +- _28 = copy _11; - _27 = move _28 as *const dyn std::marker::Send (PointerCoercion(Unsize)); -+ _28 = _12; -+ _27 = _12; ++ _28 = copy _12; ++ _27 = copy _12; StorageDead(_28); - _25 = Ne(move _26, move _27); -+ _25 = Ne(_4, _12); ++ _25 = Ne(copy _4, copy _12); StorageDead(_27); StorageDead(_26); _24 = opaque::(move _25) -> [return: bb4, unwind unreachable]; @@ -171,17 +171,17 @@ StorageLive(_29); StorageLive(_30); StorageLive(_31); -- _31 = _3; -+ _31 = _4; +- _31 = copy _3; ++ _31 = copy _4; StorageLive(_32); StorageLive(_33); -- _33 = _11; +- _33 = copy _11; - _32 = move _33 as *const dyn std::marker::Send (PointerCoercion(Unsize)); -+ _33 = _12; -+ _32 = _12; ++ _33 = copy _12; ++ _32 = copy _12; StorageDead(_33); - _30 = Lt(move _31, move _32); -+ _30 = Lt(_4, _12); ++ _30 = Lt(copy _4, copy _12); StorageDead(_32); StorageDead(_31); _29 = opaque::(move _30) -> [return: bb5, unwind unreachable]; @@ -193,17 +193,17 @@ StorageLive(_34); StorageLive(_35); StorageLive(_36); -- _36 = _3; -+ _36 = _4; +- _36 = copy _3; ++ _36 = copy _4; StorageLive(_37); StorageLive(_38); -- _38 = _11; +- _38 = copy _11; - _37 = move _38 as *const dyn std::marker::Send (PointerCoercion(Unsize)); -+ _38 = _12; -+ _37 = _12; ++ _38 = copy _12; ++ _37 = copy _12; StorageDead(_38); - _35 = Le(move _36, move _37); -+ _35 = Le(_4, _12); ++ _35 = Le(copy _4, copy _12); StorageDead(_37); StorageDead(_36); _34 = opaque::(move _35) -> [return: bb6, unwind unreachable]; @@ -215,17 +215,17 @@ StorageLive(_39); StorageLive(_40); StorageLive(_41); -- _41 = _3; -+ _41 = _4; +- _41 = copy _3; ++ _41 = copy _4; StorageLive(_42); StorageLive(_43); -- _43 = _11; +- _43 = copy _11; - _42 = move _43 as *const dyn std::marker::Send (PointerCoercion(Unsize)); -+ _43 = _12; -+ _42 = _12; ++ _43 = copy _12; ++ _42 = copy _12; StorageDead(_43); - _40 = Gt(move _41, move _42); -+ _40 = Gt(_4, _12); ++ _40 = Gt(copy _4, copy _12); StorageDead(_42); StorageDead(_41); _39 = opaque::(move _40) -> [return: bb7, unwind unreachable]; @@ -237,17 +237,17 @@ StorageLive(_44); StorageLive(_45); StorageLive(_46); -- _46 = _3; -+ _46 = _4; +- _46 = copy _3; ++ _46 = copy _4; StorageLive(_47); StorageLive(_48); -- _48 = _11; +- _48 = copy _11; - _47 = move _48 as *const dyn std::marker::Send (PointerCoercion(Unsize)); -+ _48 = _12; -+ _47 = _12; ++ _48 = copy _12; ++ _47 = copy _12; StorageDead(_48); - _45 = Ge(move _46, move _47); -+ _45 = Ge(_4, _12); ++ _45 = Ge(copy _4, copy _12); StorageDead(_47); StorageDead(_46); _44 = opaque::(move _45) -> [return: bb8, unwind unreachable]; diff --git a/tests/mir-opt/gvn.wide_ptr_same_provenance.GVN.panic-unwind.diff b/tests/mir-opt/gvn.wide_ptr_same_provenance.GVN.panic-unwind.diff index 6c4f3a91264b..03f2d129a9b6 100644 --- a/tests/mir-opt/gvn.wide_ptr_same_provenance.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.wide_ptr_same_provenance.GVN.panic-unwind.diff @@ -75,8 +75,8 @@ StorageLive(_8); _8 = const 0_usize; - _9 = Len((*_1)); -- _10 = Lt(_8, _9); -- assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, _8) -> [success: bb1, unwind continue]; +- _10 = Lt(copy _8, copy _9); +- assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, copy _8) -> [success: bb1, unwind continue]; + _9 = const 2_usize; + _10 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 2_usize, const 0_usize) -> [success: bb1, unwind continue]; @@ -91,7 +91,7 @@ _4 = &raw const (*_5); - _3 = move _4 as *const dyn std::marker::Send (PointerCoercion(Unsize)); - StorageDead(_4); -+ _3 = _4; ++ _3 = copy _4; + nop; StorageDead(_7); StorageDead(_5); @@ -104,8 +104,8 @@ StorageLive(_16); _16 = const 1_usize; - _17 = Len((*_1)); -- _18 = Lt(_16, _17); -- assert(move _18, "index out of bounds: the length is {} but the index is {}", move _17, _16) -> [success: bb2, unwind continue]; +- _18 = Lt(copy _16, copy _17); +- assert(move _18, "index out of bounds: the length is {} but the index is {}", move _17, copy _16) -> [success: bb2, unwind continue]; + _17 = const 2_usize; + _18 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 2_usize, const 1_usize) -> [success: bb2, unwind continue]; @@ -120,24 +120,24 @@ _12 = &raw const (*_13); - _11 = move _12 as *const dyn std::marker::Send (PointerCoercion(Unsize)); - StorageDead(_12); -+ _11 = _12; ++ _11 = copy _12; + nop; StorageDead(_15); StorageDead(_13); StorageLive(_19); StorageLive(_20); StorageLive(_21); -- _21 = _3; -+ _21 = _4; +- _21 = copy _3; ++ _21 = copy _4; StorageLive(_22); StorageLive(_23); -- _23 = _11; +- _23 = copy _11; - _22 = move _23 as *const dyn std::marker::Send (PointerCoercion(Unsize)); -+ _23 = _12; -+ _22 = _12; ++ _23 = copy _12; ++ _22 = copy _12; StorageDead(_23); - _20 = Eq(move _21, move _22); -+ _20 = Eq(_4, _12); ++ _20 = Eq(copy _4, copy _12); StorageDead(_22); StorageDead(_21); _19 = opaque::(move _20) -> [return: bb3, unwind continue]; @@ -149,17 +149,17 @@ StorageLive(_24); StorageLive(_25); StorageLive(_26); -- _26 = _3; -+ _26 = _4; +- _26 = copy _3; ++ _26 = copy _4; StorageLive(_27); StorageLive(_28); -- _28 = _11; +- _28 = copy _11; - _27 = move _28 as *const dyn std::marker::Send (PointerCoercion(Unsize)); -+ _28 = _12; -+ _27 = _12; ++ _28 = copy _12; ++ _27 = copy _12; StorageDead(_28); - _25 = Ne(move _26, move _27); -+ _25 = Ne(_4, _12); ++ _25 = Ne(copy _4, copy _12); StorageDead(_27); StorageDead(_26); _24 = opaque::(move _25) -> [return: bb4, unwind continue]; @@ -171,17 +171,17 @@ StorageLive(_29); StorageLive(_30); StorageLive(_31); -- _31 = _3; -+ _31 = _4; +- _31 = copy _3; ++ _31 = copy _4; StorageLive(_32); StorageLive(_33); -- _33 = _11; +- _33 = copy _11; - _32 = move _33 as *const dyn std::marker::Send (PointerCoercion(Unsize)); -+ _33 = _12; -+ _32 = _12; ++ _33 = copy _12; ++ _32 = copy _12; StorageDead(_33); - _30 = Lt(move _31, move _32); -+ _30 = Lt(_4, _12); ++ _30 = Lt(copy _4, copy _12); StorageDead(_32); StorageDead(_31); _29 = opaque::(move _30) -> [return: bb5, unwind continue]; @@ -193,17 +193,17 @@ StorageLive(_34); StorageLive(_35); StorageLive(_36); -- _36 = _3; -+ _36 = _4; +- _36 = copy _3; ++ _36 = copy _4; StorageLive(_37); StorageLive(_38); -- _38 = _11; +- _38 = copy _11; - _37 = move _38 as *const dyn std::marker::Send (PointerCoercion(Unsize)); -+ _38 = _12; -+ _37 = _12; ++ _38 = copy _12; ++ _37 = copy _12; StorageDead(_38); - _35 = Le(move _36, move _37); -+ _35 = Le(_4, _12); ++ _35 = Le(copy _4, copy _12); StorageDead(_37); StorageDead(_36); _34 = opaque::(move _35) -> [return: bb6, unwind continue]; @@ -215,17 +215,17 @@ StorageLive(_39); StorageLive(_40); StorageLive(_41); -- _41 = _3; -+ _41 = _4; +- _41 = copy _3; ++ _41 = copy _4; StorageLive(_42); StorageLive(_43); -- _43 = _11; +- _43 = copy _11; - _42 = move _43 as *const dyn std::marker::Send (PointerCoercion(Unsize)); -+ _43 = _12; -+ _42 = _12; ++ _43 = copy _12; ++ _42 = copy _12; StorageDead(_43); - _40 = Gt(move _41, move _42); -+ _40 = Gt(_4, _12); ++ _40 = Gt(copy _4, copy _12); StorageDead(_42); StorageDead(_41); _39 = opaque::(move _40) -> [return: bb7, unwind continue]; @@ -237,17 +237,17 @@ StorageLive(_44); StorageLive(_45); StorageLive(_46); -- _46 = _3; -+ _46 = _4; +- _46 = copy _3; ++ _46 = copy _4; StorageLive(_47); StorageLive(_48); -- _48 = _11; +- _48 = copy _11; - _47 = move _48 as *const dyn std::marker::Send (PointerCoercion(Unsize)); -+ _48 = _12; -+ _47 = _12; ++ _48 = copy _12; ++ _47 = copy _12; StorageDead(_48); - _45 = Ge(move _46, move _47); -+ _45 = Ge(_4, _12); ++ _45 = Ge(copy _4, copy _12); StorageDead(_47); StorageDead(_46); _44 = opaque::(move _45) -> [return: bb8, unwind continue]; diff --git a/tests/mir-opt/gvn.wrap_unwrap.GVN.panic-abort.diff b/tests/mir-opt/gvn.wrap_unwrap.GVN.panic-abort.diff index a5c29c191ad5..0433152bb4f2 100644 --- a/tests/mir-opt/gvn.wrap_unwrap.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.wrap_unwrap.GVN.panic-abort.diff @@ -16,9 +16,9 @@ bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; - _2 = Option::::Some(move _3); -+ _2 = Option::::Some(_1); ++ _2 = Option::::Some(copy _1); StorageDead(_3); - _4 = discriminant(_2); - switchInt(move _4) -> [0: bb2, 1: bb3, otherwise: bb1]; @@ -37,10 +37,10 @@ bb3: { StorageLive(_5); -- _5 = ((_2 as Some).0: T); -- _0 = _5; -+ _5 = _1; -+ _0 = _1; +- _5 = copy ((_2 as Some).0: T); +- _0 = copy _5; ++ _5 = copy _1; ++ _0 = copy _1; StorageDead(_5); StorageDead(_2); return; diff --git a/tests/mir-opt/gvn.wrap_unwrap.GVN.panic-unwind.diff b/tests/mir-opt/gvn.wrap_unwrap.GVN.panic-unwind.diff index 6f2e52482716..5722c865c2f9 100644 --- a/tests/mir-opt/gvn.wrap_unwrap.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.wrap_unwrap.GVN.panic-unwind.diff @@ -16,9 +16,9 @@ bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; - _2 = Option::::Some(move _3); -+ _2 = Option::::Some(_1); ++ _2 = Option::::Some(copy _1); StorageDead(_3); - _4 = discriminant(_2); - switchInt(move _4) -> [0: bb2, 1: bb3, otherwise: bb1]; @@ -37,10 +37,10 @@ bb3: { StorageLive(_5); -- _5 = ((_2 as Some).0: T); -- _0 = _5; -+ _5 = _1; -+ _0 = _1; +- _5 = copy ((_2 as Some).0: T); +- _0 = copy _5; ++ _5 = copy _1; ++ _0 = copy _1; StorageDead(_5); StorageDead(_2); return; diff --git a/tests/mir-opt/gvn_copy_moves.fn0.GVN.diff b/tests/mir-opt/gvn_copy_moves.fn0.GVN.diff index b12de636f58b..c364da7a3cc6 100644 --- a/tests/mir-opt/gvn_copy_moves.fn0.GVN.diff +++ b/tests/mir-opt/gvn_copy_moves.fn0.GVN.diff @@ -14,10 +14,10 @@ _2 = [const 42_u128; 6]; - _2[_1] = const 1_u128; + _2[1 of 2] = const 1_u128; - _3 = (_2,); - _4 = _3; -- _5 = fn1(move (_3.0: [u128; 6]), _4) -> [return: bb1, unwind unreachable]; -+ _5 = fn1((_3.0: [u128; 6]), _3) -> [return: bb1, unwind unreachable]; + _3 = (copy _2,); + _4 = copy _3; +- _5 = fn1(move (_3.0: [u128; 6]), copy _4) -> [return: bb1, unwind unreachable]; ++ _5 = fn1(copy (_3.0: [u128; 6]), copy _3) -> [return: bb1, unwind unreachable]; } bb1: { diff --git a/tests/mir-opt/gvn_ptr_eq_with_constant.main.GVN.diff b/tests/mir-opt/gvn_ptr_eq_with_constant.main.GVN.diff index 3af78d9b6ce9..1e378d30a3e9 100644 --- a/tests/mir-opt/gvn_ptr_eq_with_constant.main.GVN.diff +++ b/tests/mir-opt/gvn_ptr_eq_with_constant.main.GVN.diff @@ -25,20 +25,20 @@ StorageLive(_2); StorageLive(_3); - _3 = AlignOf(u8); -- _2 = _3 as *mut u8 (Transmute); +- _2 = copy _3 as *mut u8 (Transmute); + _3 = const 1_usize; + _2 = const {0x1 as *mut u8}; StorageDead(_3); StorageLive(_4); StorageLive(_5); -- _5 = _2; -- _4 = _2 as *const u8 (PtrToPtr); +- _5 = copy _2; +- _4 = copy _2 as *const u8 (PtrToPtr); + _5 = const {0x1 as *mut u8}; + _4 = const {0x1 as *const u8}; StorageDead(_5); StorageLive(_6); - _6 = const Foo::::SENTINEL as *const u8 (PtrToPtr); -- _1 = Eq(_4, _6); +- _1 = Eq(copy _4, copy _6); + _6 = const {0x1 as *const u8}; + _1 = const true; StorageDead(_6); diff --git a/tests/mir-opt/gvn_uninhabited.f.GVN.panic-abort.diff b/tests/mir-opt/gvn_uninhabited.f.GVN.panic-abort.diff index 626367766d76..37b7b0d2c9db 100644 --- a/tests/mir-opt/gvn_uninhabited.f.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn_uninhabited.f.GVN.panic-abort.diff @@ -17,14 +17,14 @@ StorageLive(_3); _5 = const f::promoted[0]; _3 = &(*_5); -- _2 = ((*_3).1: E); -+ _2 = ((*_5).1: E); +- _2 = copy ((*_3).1: E); ++ _2 = copy ((*_5).1: E); StorageLive(_1); -- _1 = ((_2 as A).1: u32); +- _1 = copy ((_2 as A).1: u32); + _1 = const 0_u32; StorageDead(_3); StorageDead(_2); -- _0 = _1; +- _0 = copy _1; + _0 = const 0_u32; StorageDead(_1); return; diff --git a/tests/mir-opt/gvn_uninhabited.f.GVN.panic-unwind.diff b/tests/mir-opt/gvn_uninhabited.f.GVN.panic-unwind.diff index 626367766d76..37b7b0d2c9db 100644 --- a/tests/mir-opt/gvn_uninhabited.f.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn_uninhabited.f.GVN.panic-unwind.diff @@ -17,14 +17,14 @@ StorageLive(_3); _5 = const f::promoted[0]; _3 = &(*_5); -- _2 = ((*_3).1: E); -+ _2 = ((*_5).1: E); +- _2 = copy ((*_3).1: E); ++ _2 = copy ((*_5).1: E); StorageLive(_1); -- _1 = ((_2 as A).1: u32); +- _1 = copy ((_2 as A).1: u32); + _1 = const 0_u32; StorageDead(_3); StorageDead(_2); -- _0 = _1; +- _0 = copy _1; + _0 = const 0_u32; StorageDead(_1); return; diff --git a/tests/mir-opt/if_condition_int.dont_opt_bool.SimplifyComparisonIntegral.diff b/tests/mir-opt/if_condition_int.dont_opt_bool.SimplifyComparisonIntegral.diff index 083515aebc69..2350faa05d3f 100644 --- a/tests/mir-opt/if_condition_int.dont_opt_bool.SimplifyComparisonIntegral.diff +++ b/tests/mir-opt/if_condition_int.dont_opt_bool.SimplifyComparisonIntegral.diff @@ -8,7 +8,7 @@ bb0: { StorageLive(_2); - _2 = _1; + _2 = copy _1; switchInt(move _2) -> [0: bb2, otherwise: bb1]; } diff --git a/tests/mir-opt/if_condition_int.dont_opt_floats.SimplifyComparisonIntegral.diff b/tests/mir-opt/if_condition_int.dont_opt_floats.SimplifyComparisonIntegral.diff index 15319586062b..94570017730d 100644 --- a/tests/mir-opt/if_condition_int.dont_opt_floats.SimplifyComparisonIntegral.diff +++ b/tests/mir-opt/if_condition_int.dont_opt_floats.SimplifyComparisonIntegral.diff @@ -10,7 +10,7 @@ bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; _2 = Eq(move _3, const -42f32); switchInt(move _2) -> [0: bb2, otherwise: bb1]; } diff --git a/tests/mir-opt/if_condition_int.dont_remove_comparison.SimplifyComparisonIntegral.diff b/tests/mir-opt/if_condition_int.dont_remove_comparison.SimplifyComparisonIntegral.diff index 218d7fd59b73..d19b4148405e 100644 --- a/tests/mir-opt/if_condition_int.dont_remove_comparison.SimplifyComparisonIntegral.diff +++ b/tests/mir-opt/if_condition_int.dont_remove_comparison.SimplifyComparisonIntegral.diff @@ -17,11 +17,11 @@ bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; - _2 = Eq(move _3, const 17_i8); - StorageDead(_3); -- switchInt(_2) -> [0: bb2, otherwise: bb1]; -+ _2 = Eq(_3, const 17_i8); +- switchInt(copy _2) -> [0: bb2, otherwise: bb1]; ++ _2 = Eq(copy _3, const 17_i8); + nop; + switchInt(move _3) -> [17: bb1, otherwise: bb2]; } @@ -30,7 +30,7 @@ + StorageDead(_3); StorageLive(_6); StorageLive(_7); - _7 = _2; + _7 = copy _2; _6 = move _7 as i32 (IntToInt); StorageDead(_7); _0 = Add(const 100_i32, move _6); @@ -42,7 +42,7 @@ + StorageDead(_3); StorageLive(_4); StorageLive(_5); - _5 = _2; + _5 = copy _2; _4 = move _5 as i32 (IntToInt); StorageDead(_5); _0 = Add(const 10_i32, move _4); diff --git a/tests/mir-opt/if_condition_int.opt_char.SimplifyComparisonIntegral.diff b/tests/mir-opt/if_condition_int.opt_char.SimplifyComparisonIntegral.diff index fedbd6cdd24a..e47b7e522598 100644 --- a/tests/mir-opt/if_condition_int.opt_char.SimplifyComparisonIntegral.diff +++ b/tests/mir-opt/if_condition_int.opt_char.SimplifyComparisonIntegral.diff @@ -10,7 +10,7 @@ bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; - _2 = Eq(move _3, const 'x'); - switchInt(move _2) -> [0: bb2, otherwise: bb1]; + nop; diff --git a/tests/mir-opt/if_condition_int.opt_i8.SimplifyComparisonIntegral.diff b/tests/mir-opt/if_condition_int.opt_i8.SimplifyComparisonIntegral.diff index 9c38d8fe0657..b6cdc6af8bf4 100644 --- a/tests/mir-opt/if_condition_int.opt_i8.SimplifyComparisonIntegral.diff +++ b/tests/mir-opt/if_condition_int.opt_i8.SimplifyComparisonIntegral.diff @@ -10,7 +10,7 @@ bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; - _2 = Eq(move _3, const 42_i8); - switchInt(move _2) -> [0: bb2, otherwise: bb1]; + nop; diff --git a/tests/mir-opt/if_condition_int.opt_multiple_ifs.SimplifyComparisonIntegral.diff b/tests/mir-opt/if_condition_int.opt_multiple_ifs.SimplifyComparisonIntegral.diff index 8c85ce78565c..31745ac732a2 100644 --- a/tests/mir-opt/if_condition_int.opt_multiple_ifs.SimplifyComparisonIntegral.diff +++ b/tests/mir-opt/if_condition_int.opt_multiple_ifs.SimplifyComparisonIntegral.diff @@ -12,7 +12,7 @@ bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; - _2 = Eq(move _3, const 42_u32); - switchInt(move _2) -> [0: bb2, otherwise: bb1]; + nop; @@ -29,7 +29,7 @@ StorageDead(_3); StorageLive(_4); StorageLive(_5); - _5 = _1; + _5 = copy _1; - _4 = Ne(move _5, const 21_u32); - switchInt(move _4) -> [0: bb4, otherwise: bb3]; + nop; diff --git a/tests/mir-opt/if_condition_int.opt_negative.SimplifyComparisonIntegral.diff b/tests/mir-opt/if_condition_int.opt_negative.SimplifyComparisonIntegral.diff index 876ed61e9fa3..d747985f6e13 100644 --- a/tests/mir-opt/if_condition_int.opt_negative.SimplifyComparisonIntegral.diff +++ b/tests/mir-opt/if_condition_int.opt_negative.SimplifyComparisonIntegral.diff @@ -10,7 +10,7 @@ bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; - _2 = Eq(move _3, const -42_i32); - switchInt(move _2) -> [0: bb2, otherwise: bb1]; + nop; diff --git a/tests/mir-opt/if_condition_int.opt_u32.SimplifyComparisonIntegral.diff b/tests/mir-opt/if_condition_int.opt_u32.SimplifyComparisonIntegral.diff index ed3eb47dd3d9..1d6809a9438a 100644 --- a/tests/mir-opt/if_condition_int.opt_u32.SimplifyComparisonIntegral.diff +++ b/tests/mir-opt/if_condition_int.opt_u32.SimplifyComparisonIntegral.diff @@ -10,7 +10,7 @@ bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; - _2 = Eq(move _3, const 42_u32); - switchInt(move _2) -> [0: bb2, otherwise: bb1]; + nop; diff --git a/tests/mir-opt/inline/dyn_trait.get_query.Inline.panic-abort.diff b/tests/mir-opt/inline/dyn_trait.get_query.Inline.panic-abort.diff index 4e495c37fbc9..2d64d49ce5c1 100644 --- a/tests/mir-opt/inline/dyn_trait.get_query.Inline.panic-abort.diff +++ b/tests/mir-opt/inline/dyn_trait.get_query.Inline.panic-abort.diff @@ -21,17 +21,17 @@ bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; _2 = ::cache::(move _3) -> [return: bb1, unwind unreachable]; } bb1: { StorageDead(_3); StorageLive(_4); - _4 = _2; + _4 = copy _2; - _0 = try_execute_query::<::C>(move _4) -> [return: bb2, unwind unreachable]; + StorageLive(_5); -+ _5 = _4 as &dyn Cache::V> (PointerCoercion(Unsize)); ++ _5 = copy _4 as &dyn Cache::V> (PointerCoercion(Unsize)); + _0 = ::V> as Cache>::store_nocache(move _5) -> [return: bb2, unwind unreachable]; } diff --git a/tests/mir-opt/inline/dyn_trait.get_query.Inline.panic-unwind.diff b/tests/mir-opt/inline/dyn_trait.get_query.Inline.panic-unwind.diff index 7fdb7618212a..c5e9654e19cf 100644 --- a/tests/mir-opt/inline/dyn_trait.get_query.Inline.panic-unwind.diff +++ b/tests/mir-opt/inline/dyn_trait.get_query.Inline.panic-unwind.diff @@ -21,17 +21,17 @@ bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; _2 = ::cache::(move _3) -> [return: bb1, unwind continue]; } bb1: { StorageDead(_3); StorageLive(_4); - _4 = _2; + _4 = copy _2; - _0 = try_execute_query::<::C>(move _4) -> [return: bb2, unwind continue]; + StorageLive(_5); -+ _5 = _4 as &dyn Cache::V> (PointerCoercion(Unsize)); ++ _5 = copy _4 as &dyn Cache::V> (PointerCoercion(Unsize)); + _0 = ::V> as Cache>::store_nocache(move _5) -> [return: bb2, unwind continue]; } diff --git a/tests/mir-opt/inline/dyn_trait.mk_cycle.Inline.panic-abort.diff b/tests/mir-opt/inline/dyn_trait.mk_cycle.Inline.panic-abort.diff index 8df4408690b7..13bc54424d1d 100644 --- a/tests/mir-opt/inline/dyn_trait.mk_cycle.Inline.panic-abort.diff +++ b/tests/mir-opt/inline/dyn_trait.mk_cycle.Inline.panic-abort.diff @@ -8,7 +8,7 @@ bb0: { StorageLive(_2); - _2 = _1; + _2 = copy _1; _0 = as Cache>::store_nocache(move _2) -> [return: bb1, unwind unreachable]; } diff --git a/tests/mir-opt/inline/dyn_trait.mk_cycle.Inline.panic-unwind.diff b/tests/mir-opt/inline/dyn_trait.mk_cycle.Inline.panic-unwind.diff index 43a0621f766d..35d4db378027 100644 --- a/tests/mir-opt/inline/dyn_trait.mk_cycle.Inline.panic-unwind.diff +++ b/tests/mir-opt/inline/dyn_trait.mk_cycle.Inline.panic-unwind.diff @@ -8,7 +8,7 @@ bb0: { StorageLive(_2); - _2 = _1; + _2 = copy _1; _0 = as Cache>::store_nocache(move _2) -> [return: bb1, unwind continue]; } diff --git a/tests/mir-opt/inline/dyn_trait.try_execute_query.Inline.panic-abort.diff b/tests/mir-opt/inline/dyn_trait.try_execute_query.Inline.panic-abort.diff index e72c312f5496..f02ca6233173 100644 --- a/tests/mir-opt/inline/dyn_trait.try_execute_query.Inline.panic-abort.diff +++ b/tests/mir-opt/inline/dyn_trait.try_execute_query.Inline.panic-abort.diff @@ -13,7 +13,7 @@ bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; _2 = move _3 as &dyn Cache::V> (PointerCoercion(Unsize)); StorageDead(_3); - _0 = mk_cycle::<::V>(move _2) -> [return: bb1, unwind unreachable]; diff --git a/tests/mir-opt/inline/dyn_trait.try_execute_query.Inline.panic-unwind.diff b/tests/mir-opt/inline/dyn_trait.try_execute_query.Inline.panic-unwind.diff index 46728f9e2e65..31080dff4ded 100644 --- a/tests/mir-opt/inline/dyn_trait.try_execute_query.Inline.panic-unwind.diff +++ b/tests/mir-opt/inline/dyn_trait.try_execute_query.Inline.panic-unwind.diff @@ -13,7 +13,7 @@ bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; _2 = move _3 as &dyn Cache::V> (PointerCoercion(Unsize)); StorageDead(_3); - _0 = mk_cycle::<::V>(move _2) -> [return: bb1, unwind continue]; diff --git a/tests/mir-opt/inline/inline_any_operand.bar.Inline.after.mir b/tests/mir-opt/inline/inline_any_operand.bar.Inline.after.mir index 2d0b71e0a645..0ee5968419a0 100644 --- a/tests/mir-opt/inline/inline_any_operand.bar.Inline.after.mir +++ b/tests/mir-opt/inline/inline_any_operand.bar.Inline.after.mir @@ -18,12 +18,12 @@ fn bar() -> bool { StorageLive(_1); _1 = foo; StorageLive(_2); - _2 = _1; + _2 = copy _1; StorageLive(_3); _3 = const 1_i32; StorageLive(_4); _4 = const -1_i32; - _0 = Eq(_3, _4); + _0 = Eq(copy _3, copy _4); StorageDead(_4); StorageDead(_3); StorageDead(_2); diff --git a/tests/mir-opt/inline/inline_closure.foo.Inline.after.mir b/tests/mir-opt/inline/inline_closure.foo.Inline.after.mir index 8a60f4b1bdc6..5bc227c87df1 100644 --- a/tests/mir-opt/inline/inline_closure.foo.Inline.after.mir +++ b/tests/mir-opt/inline/inline_closure.foo.Inline.after.mir @@ -26,15 +26,15 @@ fn foo(_1: T, _2: i32) -> i32 { _4 = &_3; StorageLive(_5); StorageLive(_6); - _6 = _2; + _6 = copy _2; StorageLive(_7); - _7 = _2; + _7 = copy _2; _5 = (move _6, move _7); StorageLive(_8); _8 = move (_5.0: i32); StorageLive(_9); _9 = move (_5.1: i32); - _0 = _8; + _0 = copy _8; StorageDead(_9); StorageDead(_8); StorageDead(_7); diff --git a/tests/mir-opt/inline/inline_closure_borrows_arg.foo.Inline.after.mir b/tests/mir-opt/inline/inline_closure_borrows_arg.foo.Inline.after.mir index f524b054b61b..7930111cf229 100644 --- a/tests/mir-opt/inline/inline_closure_borrows_arg.foo.Inline.after.mir +++ b/tests/mir-opt/inline/inline_closure_borrows_arg.foo.Inline.after.mir @@ -26,15 +26,15 @@ fn foo(_1: T, _2: &i32) -> i32 { _4 = &_3; StorageLive(_5); StorageLive(_6); - _6 = _2; + _6 = copy _2; StorageLive(_7); - _7 = _2; + _7 = copy _2; _5 = (move _6, move _7); StorageLive(_8); _8 = move (_5.0: &i32); StorageLive(_9); _9 = move (_5.1: &i32); - _0 = (*_8); + _0 = copy (*_8); StorageDead(_9); StorageDead(_8); StorageDead(_7); diff --git a/tests/mir-opt/inline/inline_closure_captures.foo.Inline.after.mir b/tests/mir-opt/inline/inline_closure_captures.foo.Inline.after.mir index 2f9d28ea0937..17e6e39a86bc 100644 --- a/tests/mir-opt/inline/inline_closure_captures.foo.Inline.after.mir +++ b/tests/mir-opt/inline/inline_closure_captures.foo.Inline.after.mir @@ -34,18 +34,18 @@ fn foo(_1: T, _2: i32) -> (i32, T) { _6 = &_3; StorageLive(_7); StorageLive(_8); - _8 = _2; + _8 = copy _2; _7 = (move _8,); StorageLive(_9); _9 = move (_7.0: i32); StorageLive(_10); StorageLive(_12); StorageLive(_11); - _10 = ((*_6).0: &i32); - _11 = (*_10); + _10 = copy ((*_6).0: &i32); + _11 = copy (*_10); StorageLive(_13); - _12 = ((*_6).1: &T); - _13 = (*_12); + _12 = copy ((*_6).1: &T); + _13 = copy (*_12); _0 = (move _11, move _13); StorageDead(_13); StorageDead(_11); diff --git a/tests/mir-opt/inline/inline_coroutine.main.Inline.panic-abort.diff b/tests/mir-opt/inline/inline_coroutine.main.Inline.panic-abort.diff index 07031a298bc3..94017f028ccc 100644 --- a/tests/mir-opt/inline/inline_coroutine.main.Inline.panic-abort.diff +++ b/tests/mir-opt/inline/inline_coroutine.main.Inline.panic-abort.diff @@ -34,13 +34,13 @@ - _4 = g() -> [return: bb1, unwind unreachable]; + _4 = {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8 (#0)}; + _3 = &mut _4; -+ _2 = Pin::<&mut {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8}> { __pointer: _3 }; ++ _2 = Pin::<&mut {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8}> { __pointer: copy _3 }; + StorageDead(_3); + StorageLive(_5); + _5 = const false; + StorageLive(_6); + StorageLive(_7); -+ _6 = (_2.0: &mut {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8}); ++ _6 = copy (_2.0: &mut {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8}); + _7 = discriminant((*_6)); + switchInt(move _7) -> [0: bb3, 1: bb7, 3: bb8, otherwise: bb9]; } @@ -68,7 +68,7 @@ - StorageDead(_2); - drop(_4) -> [return: bb4, unwind unreachable]; + StorageLive(_8); -+ switchInt(_5) -> [0: bb4, otherwise: bb5]; ++ switchInt(copy _5) -> [0: bb4, otherwise: bb5]; } bb4: { @@ -99,7 +99,7 @@ + bb8: { + StorageLive(_8); + StorageDead(_8); -+ _1 = CoroutineState::::Complete(_5); ++ _1 = CoroutineState::::Complete(copy _5); + discriminant((*_6)) = 1; + goto -> bb2; + } diff --git a/tests/mir-opt/inline/inline_coroutine.main.Inline.panic-unwind.diff b/tests/mir-opt/inline/inline_coroutine.main.Inline.panic-unwind.diff index ab6c62b0baf5..858f9ace9b40 100644 --- a/tests/mir-opt/inline/inline_coroutine.main.Inline.panic-unwind.diff +++ b/tests/mir-opt/inline/inline_coroutine.main.Inline.panic-unwind.diff @@ -34,13 +34,13 @@ - _4 = g() -> [return: bb1, unwind continue]; + _4 = {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8 (#0)}; + _3 = &mut _4; -+ _2 = Pin::<&mut {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8}> { __pointer: _3 }; ++ _2 = Pin::<&mut {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8}> { __pointer: copy _3 }; + StorageDead(_3); + StorageLive(_5); + _5 = const false; + StorageLive(_6); + StorageLive(_7); -+ _6 = (_2.0: &mut {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8}); ++ _6 = copy (_2.0: &mut {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8}); + _7 = discriminant((*_6)); + switchInt(move _7) -> [0: bb5, 1: bb9, 3: bb10, otherwise: bb11]; } @@ -84,7 +84,7 @@ - drop(_4) -> [return: bb6, unwind terminate(cleanup)]; + bb5: { + StorageLive(_8); -+ switchInt(_5) -> [0: bb6, otherwise: bb7]; ++ switchInt(copy _5) -> [0: bb6, otherwise: bb7]; } - bb6 (cleanup): { @@ -113,7 +113,7 @@ + bb10: { + StorageLive(_8); + StorageDead(_8); -+ _1 = CoroutineState::::Complete(_5); ++ _1 = CoroutineState::::Complete(copy _5); + discriminant((*_6)) = 1; + goto -> bb4; + } diff --git a/tests/mir-opt/inline/inline_diverging.g.Inline.panic-abort.diff b/tests/mir-opt/inline/inline_diverging.g.Inline.panic-abort.diff index d675695eb104..bda855865153 100644 --- a/tests/mir-opt/inline/inline_diverging.g.Inline.panic-abort.diff +++ b/tests/mir-opt/inline/inline_diverging.g.Inline.panic-abort.diff @@ -16,7 +16,7 @@ bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; _2 = Gt(move _3, const 0_i32); switchInt(move _2) -> [0: bb2, otherwise: bb1]; } @@ -24,7 +24,7 @@ bb1: { StorageDead(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; _0 = move _4 as u32 (IntToInt); StorageDead(_4); StorageDead(_2); diff --git a/tests/mir-opt/inline/inline_diverging.g.Inline.panic-unwind.diff b/tests/mir-opt/inline/inline_diverging.g.Inline.panic-unwind.diff index 1142616115fb..ecd72d2b37fa 100644 --- a/tests/mir-opt/inline/inline_diverging.g.Inline.panic-unwind.diff +++ b/tests/mir-opt/inline/inline_diverging.g.Inline.panic-unwind.diff @@ -16,7 +16,7 @@ bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; _2 = Gt(move _3, const 0_i32); switchInt(move _2) -> [0: bb2, otherwise: bb1]; } @@ -24,7 +24,7 @@ bb1: { StorageDead(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; _0 = move _4 as u32 (IntToInt); StorageDead(_4); StorageDead(_2); diff --git a/tests/mir-opt/inline/inline_diverging.h.Inline.panic-abort.diff b/tests/mir-opt/inline/inline_diverging.h.Inline.panic-abort.diff index 2bbb830fc779..338dca85e5c9 100644 --- a/tests/mir-opt/inline/inline_diverging.h.Inline.panic-abort.diff +++ b/tests/mir-opt/inline/inline_diverging.h.Inline.panic-abort.diff @@ -40,7 +40,7 @@ + + bb2: { + StorageDead(_5); -+ _1 = (_4, _6); ++ _1 = (copy _4, copy _6); + drop(_2) -> [return: bb3, unwind unreachable]; + } + diff --git a/tests/mir-opt/inline/inline_diverging.h.Inline.panic-unwind.diff b/tests/mir-opt/inline/inline_diverging.h.Inline.panic-unwind.diff index bc4f2d24df0b..a77cb913bfd0 100644 --- a/tests/mir-opt/inline/inline_diverging.h.Inline.panic-unwind.diff +++ b/tests/mir-opt/inline/inline_diverging.h.Inline.panic-unwind.diff @@ -43,7 +43,7 @@ + StorageDead(_5); + StorageLive(_7); + _7 = move _4; -+ _1 = (move _7, _6); ++ _1 = (move _7, copy _6); + StorageDead(_7); + StorageDead(_4); + drop(_2) -> [return: bb3, unwind continue]; diff --git a/tests/mir-opt/inline/inline_more_in_non_inline.marked_inline_direct.Inline.after.panic-abort.mir b/tests/mir-opt/inline/inline_more_in_non_inline.marked_inline_direct.Inline.after.panic-abort.mir index 522f772c6f48..9b28aeb271df 100644 --- a/tests/mir-opt/inline/inline_more_in_non_inline.marked_inline_direct.Inline.after.panic-abort.mir +++ b/tests/mir-opt/inline/inline_more_in_non_inline.marked_inline_direct.Inline.after.panic-abort.mir @@ -9,7 +9,7 @@ fn marked_inline_direct(_1: i32) -> () { bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; _2 = call_twice(move _3) -> [return: bb1, unwind unreachable]; } diff --git a/tests/mir-opt/inline/inline_more_in_non_inline.marked_inline_direct.Inline.after.panic-unwind.mir b/tests/mir-opt/inline/inline_more_in_non_inline.marked_inline_direct.Inline.after.panic-unwind.mir index 722b02eeba80..929c89940dcb 100644 --- a/tests/mir-opt/inline/inline_more_in_non_inline.marked_inline_direct.Inline.after.panic-unwind.mir +++ b/tests/mir-opt/inline/inline_more_in_non_inline.marked_inline_direct.Inline.after.panic-unwind.mir @@ -9,7 +9,7 @@ fn marked_inline_direct(_1: i32) -> () { bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; _2 = call_twice(move _3) -> [return: bb1, unwind continue]; } diff --git a/tests/mir-opt/inline/inline_more_in_non_inline.marked_inline_indirect.Inline.after.panic-abort.mir b/tests/mir-opt/inline/inline_more_in_non_inline.marked_inline_indirect.Inline.after.panic-abort.mir index 63b91cbce2d6..374ed294d8b2 100644 --- a/tests/mir-opt/inline/inline_more_in_non_inline.marked_inline_indirect.Inline.after.panic-abort.mir +++ b/tests/mir-opt/inline/inline_more_in_non_inline.marked_inline_indirect.Inline.after.panic-abort.mir @@ -12,7 +12,7 @@ fn marked_inline_indirect(_1: i32) -> () { bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; StorageLive(_4); _4 = call_twice(move _3) -> [return: bb1, unwind unreachable]; } diff --git a/tests/mir-opt/inline/inline_more_in_non_inline.marked_inline_indirect.Inline.after.panic-unwind.mir b/tests/mir-opt/inline/inline_more_in_non_inline.marked_inline_indirect.Inline.after.panic-unwind.mir index 7c84e98dd516..97bed8020bad 100644 --- a/tests/mir-opt/inline/inline_more_in_non_inline.marked_inline_indirect.Inline.after.panic-unwind.mir +++ b/tests/mir-opt/inline/inline_more_in_non_inline.marked_inline_indirect.Inline.after.panic-unwind.mir @@ -12,7 +12,7 @@ fn marked_inline_indirect(_1: i32) -> () { bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; StorageLive(_4); _4 = call_twice(move _3) -> [return: bb1, unwind continue]; } diff --git a/tests/mir-opt/inline/inline_more_in_non_inline.monomorphic_not_inline.Inline.after.panic-abort.mir b/tests/mir-opt/inline/inline_more_in_non_inline.monomorphic_not_inline.Inline.after.panic-abort.mir index 989014b8b476..cffe0e96f5c9 100644 --- a/tests/mir-opt/inline/inline_more_in_non_inline.monomorphic_not_inline.Inline.after.panic-abort.mir +++ b/tests/mir-opt/inline/inline_more_in_non_inline.monomorphic_not_inline.Inline.after.panic-abort.mir @@ -13,10 +13,10 @@ fn monomorphic_not_inline(_1: i32) -> () { bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; StorageLive(_4); StorageLive(_5); - _4 = other_thing(_3) -> [return: bb2, unwind unreachable]; + _4 = other_thing(copy _3) -> [return: bb2, unwind unreachable]; } bb1: { diff --git a/tests/mir-opt/inline/inline_more_in_non_inline.monomorphic_not_inline.Inline.after.panic-unwind.mir b/tests/mir-opt/inline/inline_more_in_non_inline.monomorphic_not_inline.Inline.after.panic-unwind.mir index bd200719bbbe..7f3a093012bc 100644 --- a/tests/mir-opt/inline/inline_more_in_non_inline.monomorphic_not_inline.Inline.after.panic-unwind.mir +++ b/tests/mir-opt/inline/inline_more_in_non_inline.monomorphic_not_inline.Inline.after.panic-unwind.mir @@ -13,10 +13,10 @@ fn monomorphic_not_inline(_1: i32) -> () { bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; StorageLive(_4); StorageLive(_5); - _4 = other_thing(_3) -> [return: bb2, unwind continue]; + _4 = other_thing(copy _3) -> [return: bb2, unwind continue]; } bb1: { diff --git a/tests/mir-opt/inline/inline_retag.bar.Inline.after.mir b/tests/mir-opt/inline/inline_retag.bar.Inline.after.mir index ec3c79e2a374..9a256ea19496 100644 --- a/tests/mir-opt/inline/inline_retag.bar.Inline.after.mir +++ b/tests/mir-opt/inline/inline_retag.bar.Inline.after.mir @@ -26,25 +26,25 @@ fn bar() -> bool { StorageLive(_1); _1 = foo; StorageLive(_2); - _2 = _1; + _2 = copy _1; StorageLive(_3); StorageLive(_4); _10 = const bar::promoted[1]; Retag(_10); - _4 = _10; - _3 = _4; + _4 = copy _10; + _3 = copy _4; StorageLive(_6); StorageLive(_7); _9 = const bar::promoted[0]; Retag(_9); - _7 = _9; - _6 = _7; + _7 = copy _9; + _6 = copy _7; Retag(_3); Retag(_6); StorageLive(_11); - _11 = (*_3); + _11 = copy (*_3); StorageLive(_12); - _12 = (*_6); + _12 = copy (*_6); _0 = Eq(move _11, move _12); StorageDead(_12); StorageDead(_11); diff --git a/tests/mir-opt/inline/inline_shims.clone.Inline.panic-abort.diff b/tests/mir-opt/inline/inline_shims.clone.Inline.panic-abort.diff index 8117e58fa51a..26b4dc357f33 100644 --- a/tests/mir-opt/inline/inline_shims.clone.Inline.panic-abort.diff +++ b/tests/mir-opt/inline/inline_shims.clone.Inline.panic-abort.diff @@ -15,7 +15,7 @@ - } - - bb1: { -+ _0 = (*_2); ++ _0 = copy (*_2); StorageDead(_2); return; } diff --git a/tests/mir-opt/inline/inline_shims.clone.Inline.panic-unwind.diff b/tests/mir-opt/inline/inline_shims.clone.Inline.panic-unwind.diff index 00e92a0f5e5a..faa12d5c7360 100644 --- a/tests/mir-opt/inline/inline_shims.clone.Inline.panic-unwind.diff +++ b/tests/mir-opt/inline/inline_shims.clone.Inline.panic-unwind.diff @@ -15,7 +15,7 @@ - } - - bb1: { -+ _0 = (*_2); ++ _0 = copy (*_2); StorageDead(_2); return; } diff --git a/tests/mir-opt/inline/inline_shims.drop.Inline.panic-abort.diff b/tests/mir-opt/inline/inline_shims.drop.Inline.panic-abort.diff index 2a36ccaab110..581244074b36 100644 --- a/tests/mir-opt/inline/inline_shims.drop.Inline.panic-abort.diff +++ b/tests/mir-opt/inline/inline_shims.drop.Inline.panic-abort.diff @@ -20,7 +20,7 @@ bb0: { StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; - _3 = std::ptr::drop_in_place::>(move _4) -> [return: bb1, unwind unreachable]; + StorageLive(_6); + StorageLive(_7); @@ -34,7 +34,7 @@ StorageDead(_4); StorageDead(_3); StorageLive(_5); - _5 = _2; + _5 = copy _2; - _0 = std::ptr::drop_in_place::>(move _5) -> [return: bb2, unwind unreachable]; + StorageLive(_8); + StorageLive(_9); diff --git a/tests/mir-opt/inline/inline_shims.drop.Inline.panic-unwind.diff b/tests/mir-opt/inline/inline_shims.drop.Inline.panic-unwind.diff index e11561076e64..d89ca003d77b 100644 --- a/tests/mir-opt/inline/inline_shims.drop.Inline.panic-unwind.diff +++ b/tests/mir-opt/inline/inline_shims.drop.Inline.panic-unwind.diff @@ -16,7 +16,7 @@ bb0: { StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; _3 = std::ptr::drop_in_place::>(move _4) -> [return: bb1, unwind continue]; } @@ -24,7 +24,7 @@ StorageDead(_4); StorageDead(_3); StorageLive(_5); - _5 = _2; + _5 = copy _2; - _0 = std::ptr::drop_in_place::>(move _5) -> [return: bb2, unwind continue]; + StorageLive(_6); + StorageLive(_7); diff --git a/tests/mir-opt/inline/inline_trait_method.test.Inline.after.panic-abort.mir b/tests/mir-opt/inline/inline_trait_method.test.Inline.after.panic-abort.mir index d7b4302b06d9..8355cd0070de 100644 --- a/tests/mir-opt/inline/inline_trait_method.test.Inline.after.panic-abort.mir +++ b/tests/mir-opt/inline/inline_trait_method.test.Inline.after.panic-abort.mir @@ -7,7 +7,7 @@ fn test(_1: &dyn X) -> u32 { bb0: { StorageLive(_2); - _2 = _1; + _2 = copy _1; _0 = ::y(move _2) -> [return: bb1, unwind unreachable]; } diff --git a/tests/mir-opt/inline/inline_trait_method.test.Inline.after.panic-unwind.mir b/tests/mir-opt/inline/inline_trait_method.test.Inline.after.panic-unwind.mir index 0d6f3e61f71f..ebfbfeb0b13e 100644 --- a/tests/mir-opt/inline/inline_trait_method.test.Inline.after.panic-unwind.mir +++ b/tests/mir-opt/inline/inline_trait_method.test.Inline.after.panic-unwind.mir @@ -7,7 +7,7 @@ fn test(_1: &dyn X) -> u32 { bb0: { StorageLive(_2); - _2 = _1; + _2 = copy _1; _0 = ::y(move _2) -> [return: bb1, unwind continue]; } diff --git a/tests/mir-opt/inline/inline_trait_method_2.test2.Inline.after.panic-abort.mir b/tests/mir-opt/inline/inline_trait_method_2.test2.Inline.after.panic-abort.mir index af79c7ce1968..1105dba06ac4 100644 --- a/tests/mir-opt/inline/inline_trait_method_2.test2.Inline.after.panic-abort.mir +++ b/tests/mir-opt/inline/inline_trait_method_2.test2.Inline.after.panic-abort.mir @@ -12,7 +12,7 @@ fn test2(_1: &dyn X) -> bool { bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; _2 = move _3; StorageDead(_3); _0 = ::y(move _2) -> [return: bb1, unwind unreachable]; diff --git a/tests/mir-opt/inline/inline_trait_method_2.test2.Inline.after.panic-unwind.mir b/tests/mir-opt/inline/inline_trait_method_2.test2.Inline.after.panic-unwind.mir index bf5a56b8e624..faa6ef47b18a 100644 --- a/tests/mir-opt/inline/inline_trait_method_2.test2.Inline.after.panic-unwind.mir +++ b/tests/mir-opt/inline/inline_trait_method_2.test2.Inline.after.panic-unwind.mir @@ -12,7 +12,7 @@ fn test2(_1: &dyn X) -> bool { bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; _2 = move _3; StorageDead(_3); _0 = ::y(move _2) -> [return: bb1, unwind continue]; diff --git a/tests/mir-opt/inline/issue_106141.outer.Inline.panic-abort.diff b/tests/mir-opt/inline/issue_106141.outer.Inline.panic-abort.diff index 2ab79cc2a509..e87a565f0fc9 100644 --- a/tests/mir-opt/inline/issue_106141.outer.Inline.panic-abort.diff +++ b/tests/mir-opt/inline/issue_106141.outer.Inline.panic-abort.diff @@ -25,12 +25,12 @@ bb1: { + StorageLive(_3); -+ _2 = Lt(_0, const 1_usize); -+ assert(move _2, "index out of bounds: the length is {} but the index is {}", const 1_usize, _0) -> [success: bb2, unwind unreachable]; ++ _2 = Lt(copy _0, const 1_usize); ++ assert(move _2, "index out of bounds: the length is {} but the index is {}", const 1_usize, copy _0) -> [success: bb2, unwind unreachable]; + } + + bb2: { -+ _3 = (*_1)[_0]; ++ _3 = copy (*_1)[_0]; + switchInt(move _3) -> [0: bb3, otherwise: bb4]; + } + diff --git a/tests/mir-opt/inline/issue_106141.outer.Inline.panic-unwind.diff b/tests/mir-opt/inline/issue_106141.outer.Inline.panic-unwind.diff index 4d96a8628859..834851b75adf 100644 --- a/tests/mir-opt/inline/issue_106141.outer.Inline.panic-unwind.diff +++ b/tests/mir-opt/inline/issue_106141.outer.Inline.panic-unwind.diff @@ -25,12 +25,12 @@ bb1: { + StorageLive(_3); -+ _2 = Lt(_0, const 1_usize); -+ assert(move _2, "index out of bounds: the length is {} but the index is {}", const 1_usize, _0) -> [success: bb2, unwind continue]; ++ _2 = Lt(copy _0, const 1_usize); ++ assert(move _2, "index out of bounds: the length is {} but the index is {}", const 1_usize, copy _0) -> [success: bb2, unwind continue]; + } + + bb2: { -+ _3 = (*_1)[_0]; ++ _3 = copy (*_1)[_0]; + switchInt(move _3) -> [0: bb3, otherwise: bb4]; + } + diff --git a/tests/mir-opt/inline/issue_58867_inline_as_ref_as_mut.a.Inline.after.mir b/tests/mir-opt/inline/issue_58867_inline_as_ref_as_mut.a.Inline.after.mir index 8c457037ec97..a48a9a0bb0c4 100644 --- a/tests/mir-opt/inline/issue_58867_inline_as_ref_as_mut.a.Inline.after.mir +++ b/tests/mir-opt/inline/issue_58867_inline_as_ref_as_mut.a.Inline.after.mir @@ -14,11 +14,11 @@ fn a(_1: &mut [T]) -> &mut [T] { StorageLive(_2); StorageLive(_3); StorageLive(_4); - _4 = _1; - _3 = _4; - _2 = _3; + _4 = copy _1; + _3 = copy _4; + _2 = copy _3; StorageDead(_4); - _0 = _2; + _0 = copy _2; StorageDead(_3); StorageDead(_2); return; diff --git a/tests/mir-opt/inline/issue_58867_inline_as_ref_as_mut.b.Inline.after.mir b/tests/mir-opt/inline/issue_58867_inline_as_ref_as_mut.b.Inline.after.mir index e27d9fe38c7e..02aadfc1de06 100644 --- a/tests/mir-opt/inline/issue_58867_inline_as_ref_as_mut.b.Inline.after.mir +++ b/tests/mir-opt/inline/issue_58867_inline_as_ref_as_mut.b.Inline.after.mir @@ -16,17 +16,17 @@ fn b(_1: &mut Box) -> &mut T { StorageLive(_2); StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; StorageLive(_5); StorageLive(_6); - _5 = (*_4); - _6 = (((_5.0: std::ptr::Unique).0: std::ptr::NonNull).0: *const T); + _5 = copy (*_4); + _6 = copy (((_5.0: std::ptr::Unique).0: std::ptr::NonNull).0: *const T); _3 = &mut (*_6); StorageDead(_6); StorageDead(_5); - _2 = _3; + _2 = copy _3; StorageDead(_4); - _0 = _2; + _0 = copy _2; StorageDead(_3); StorageDead(_2); return; diff --git a/tests/mir-opt/inline/issue_58867_inline_as_ref_as_mut.c.Inline.after.mir b/tests/mir-opt/inline/issue_58867_inline_as_ref_as_mut.c.Inline.after.mir index da0464c64d69..2d88f9e55249 100644 --- a/tests/mir-opt/inline/issue_58867_inline_as_ref_as_mut.c.Inline.after.mir +++ b/tests/mir-opt/inline/issue_58867_inline_as_ref_as_mut.c.Inline.after.mir @@ -12,9 +12,9 @@ fn c(_1: &[T]) -> &[T] { bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; - _2 = _3; - _0 = _2; + _3 = copy _1; + _2 = copy _3; + _0 = copy _2; StorageDead(_3); StorageDead(_2); return; diff --git a/tests/mir-opt/inline/issue_58867_inline_as_ref_as_mut.d.Inline.after.mir b/tests/mir-opt/inline/issue_58867_inline_as_ref_as_mut.d.Inline.after.mir index 25eaedfc842d..1ea347510fdb 100644 --- a/tests/mir-opt/inline/issue_58867_inline_as_ref_as_mut.d.Inline.after.mir +++ b/tests/mir-opt/inline/issue_58867_inline_as_ref_as_mut.d.Inline.after.mir @@ -14,15 +14,15 @@ fn d(_1: &Box) -> &T { bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; StorageLive(_4); StorageLive(_5); - _4 = (*_3); - _5 = (((_4.0: std::ptr::Unique).0: std::ptr::NonNull).0: *const T); + _4 = copy (*_3); + _5 = copy (((_4.0: std::ptr::Unique).0: std::ptr::NonNull).0: *const T); _2 = &(*_5); StorageDead(_5); StorageDead(_4); - _0 = _2; + _0 = copy _2; StorageDead(_3); StorageDead(_2); return; diff --git a/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.Inline.panic-abort.diff b/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.Inline.panic-abort.diff index 0d9d58316ea1..f36157a762c2 100644 --- a/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.Inline.panic-abort.diff +++ b/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.Inline.panic-abort.diff @@ -18,9 +18,9 @@ bb0: { StorageLive(_3); - _3 = _1; + _3 = copy _1; StorageLive(_4); - _4 = _2; + _4 = copy _2; - _0 = core::num::::unchecked_shl(move _3, move _4) -> [return: bb1, unwind unreachable]; + StorageLive(_6); + StorageLive(_5); @@ -29,12 +29,12 @@ } bb1: { -+ _6 = core::num::::unchecked_shl::precondition_check(_4) -> [return: bb2, unwind unreachable]; ++ _6 = core::num::::unchecked_shl::precondition_check(copy _4) -> [return: bb2, unwind unreachable]; + } + + bb2: { + StorageDead(_5); -+ _0 = ShlUnchecked(_3, _4); ++ _0 = ShlUnchecked(copy _3, copy _4); + StorageDead(_6); StorageDead(_4); StorageDead(_3); diff --git a/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.Inline.panic-unwind.diff b/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.Inline.panic-unwind.diff index 82f7eceaa180..be1b066c6c1b 100644 --- a/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.Inline.panic-unwind.diff +++ b/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.Inline.panic-unwind.diff @@ -18,9 +18,9 @@ bb0: { StorageLive(_3); - _3 = _1; + _3 = copy _1; StorageLive(_4); - _4 = _2; + _4 = copy _2; - _0 = core::num::::unchecked_shl(move _3, move _4) -> [return: bb1, unwind continue]; + StorageLive(_6); + StorageLive(_5); @@ -29,12 +29,12 @@ } bb1: { -+ _6 = core::num::::unchecked_shl::precondition_check(_4) -> [return: bb2, unwind unreachable]; ++ _6 = core::num::::unchecked_shl::precondition_check(copy _4) -> [return: bb2, unwind unreachable]; + } + + bb2: { + StorageDead(_5); -+ _0 = ShlUnchecked(_3, _4); ++ _0 = ShlUnchecked(copy _3, copy _4); + StorageDead(_6); StorageDead(_4); StorageDead(_3); diff --git a/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.PreCodegen.after.panic-abort.mir b/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.PreCodegen.after.panic-abort.mir index dc27685ee79b..611273ab08d7 100644 --- a/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.PreCodegen.after.panic-abort.mir @@ -12,7 +12,7 @@ fn unchecked_shl_unsigned_smaller(_1: u16, _2: u32) -> u16 { } bb0: { - _0 = ShlUnchecked(_1, _2); + _0 = ShlUnchecked(copy _1, copy _2); return; } } diff --git a/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.PreCodegen.after.panic-unwind.mir index dc27685ee79b..611273ab08d7 100644 --- a/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.PreCodegen.after.panic-unwind.mir @@ -12,7 +12,7 @@ fn unchecked_shl_unsigned_smaller(_1: u16, _2: u32) -> u16 { } bb0: { - _0 = ShlUnchecked(_1, _2); + _0 = ShlUnchecked(copy _1, copy _2); return; } } diff --git a/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_bigger.Inline.panic-abort.diff b/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_bigger.Inline.panic-abort.diff index 6894b2466990..360687f3c4e7 100644 --- a/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_bigger.Inline.panic-abort.diff +++ b/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_bigger.Inline.panic-abort.diff @@ -18,9 +18,9 @@ bb0: { StorageLive(_3); - _3 = _1; + _3 = copy _1; StorageLive(_4); - _4 = _2; + _4 = copy _2; - _0 = core::num::::unchecked_shr(move _3, move _4) -> [return: bb1, unwind unreachable]; + StorageLive(_6); + StorageLive(_5); @@ -29,12 +29,12 @@ } bb1: { -+ _6 = core::num::::unchecked_shr::precondition_check(_4) -> [return: bb2, unwind unreachable]; ++ _6 = core::num::::unchecked_shr::precondition_check(copy _4) -> [return: bb2, unwind unreachable]; + } + + bb2: { + StorageDead(_5); -+ _0 = ShrUnchecked(_3, _4); ++ _0 = ShrUnchecked(copy _3, copy _4); + StorageDead(_6); StorageDead(_4); StorageDead(_3); diff --git a/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_bigger.Inline.panic-unwind.diff b/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_bigger.Inline.panic-unwind.diff index 070f4a1c5c83..986df55df037 100644 --- a/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_bigger.Inline.panic-unwind.diff +++ b/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_bigger.Inline.panic-unwind.diff @@ -18,9 +18,9 @@ bb0: { StorageLive(_3); - _3 = _1; + _3 = copy _1; StorageLive(_4); - _4 = _2; + _4 = copy _2; - _0 = core::num::::unchecked_shr(move _3, move _4) -> [return: bb1, unwind continue]; + StorageLive(_6); + StorageLive(_5); @@ -29,12 +29,12 @@ } bb1: { -+ _6 = core::num::::unchecked_shr::precondition_check(_4) -> [return: bb2, unwind unreachable]; ++ _6 = core::num::::unchecked_shr::precondition_check(copy _4) -> [return: bb2, unwind unreachable]; + } + + bb2: { + StorageDead(_5); -+ _0 = ShrUnchecked(_3, _4); ++ _0 = ShrUnchecked(copy _3, copy _4); + StorageDead(_6); StorageDead(_4); StorageDead(_3); diff --git a/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_bigger.PreCodegen.after.panic-abort.mir b/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_bigger.PreCodegen.after.panic-abort.mir index 54f093b87d19..f4ddd0bca04d 100644 --- a/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_bigger.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_bigger.PreCodegen.after.panic-abort.mir @@ -12,7 +12,7 @@ fn unchecked_shr_signed_bigger(_1: i64, _2: u32) -> i64 { } bb0: { - _0 = ShrUnchecked(_1, _2); + _0 = ShrUnchecked(copy _1, copy _2); return; } } diff --git a/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_bigger.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_bigger.PreCodegen.after.panic-unwind.mir index 54f093b87d19..f4ddd0bca04d 100644 --- a/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_bigger.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_bigger.PreCodegen.after.panic-unwind.mir @@ -12,7 +12,7 @@ fn unchecked_shr_signed_bigger(_1: i64, _2: u32) -> i64 { } bb0: { - _0 = ShrUnchecked(_1, _2); + _0 = ShrUnchecked(copy _1, copy _2); return; } } diff --git a/tests/mir-opt/inline/unsized_argument.caller.Inline.diff b/tests/mir-opt/inline/unsized_argument.caller.Inline.diff index 37083973fd15..70671e2089a0 100644 --- a/tests/mir-opt/inline/unsized_argument.caller.Inline.diff +++ b/tests/mir-opt/inline/unsized_argument.caller.Inline.diff @@ -12,7 +12,7 @@ StorageLive(_2); StorageLive(_3); _3 = move _1; - _4 = (((_3.0: std::ptr::Unique<[i32]>).0: std::ptr::NonNull<[i32]>).0: *const [i32]); + _4 = copy (((_3.0: std::ptr::Unique<[i32]>).0: std::ptr::NonNull<[i32]>).0: *const [i32]); _2 = callee(move (*_4)) -> [return: bb1, unwind: bb3]; } diff --git a/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.Inline.panic-abort.diff b/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.Inline.panic-abort.diff index c1f7879cf0e8..28878736ed7c 100644 --- a/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.Inline.panic-abort.diff +++ b/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.Inline.panic-abort.diff @@ -36,7 +36,7 @@ + bb2: { + StorageLive(_4); + _4 = UbChecks(); -+ assume(_4); ++ assume(copy _4); + _5 = unreachable_unchecked::precondition_check() -> [return: bb1, unwind unreachable]; + } + diff --git a/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.Inline.panic-unwind.diff b/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.Inline.panic-unwind.diff index 5271e538dafe..27b6bb6a5bb2 100644 --- a/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.Inline.panic-unwind.diff +++ b/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.Inline.panic-unwind.diff @@ -40,7 +40,7 @@ + bb2: { + StorageLive(_4); + _4 = UbChecks(); -+ assume(_4); ++ assume(copy _4); + _5 = unreachable_unchecked::precondition_check() -> [return: bb1, unwind unreachable]; + } + diff --git a/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.PreCodegen.after.panic-abort.mir b/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.PreCodegen.after.panic-abort.mir index dcab8a679a87..66ab5e1b9622 100644 --- a/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.PreCodegen.after.panic-abort.mir @@ -22,7 +22,7 @@ fn unwrap_unchecked(_1: Option) -> T { } bb1: { - _0 = ((_1 as Some).0: T); + _0 = copy ((_1 as Some).0: T); StorageDead(_2); return; } diff --git a/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.PreCodegen.after.panic-unwind.mir index dcab8a679a87..66ab5e1b9622 100644 --- a/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.PreCodegen.after.panic-unwind.mir @@ -22,7 +22,7 @@ fn unwrap_unchecked(_1: Option) -> T { } bb1: { - _0 = ((_1 as Some).0: T); + _0 = copy ((_1 as Some).0: T); StorageDead(_2); return; } diff --git a/tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-abort.diff b/tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-abort.diff index f8715789cec1..1e33e222b27f 100644 --- a/tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-abort.diff +++ b/tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-abort.diff @@ -85,7 +85,7 @@ - } - - bb2: { -+ _4 = Pin::<&mut {async fn body of ActionPermit<'_, T>::perform()}> { __pointer: _5 }; ++ _4 = Pin::<&mut {async fn body of ActionPermit<'_, T>::perform()}> { __pointer: copy _5 }; StorageDead(_5); StorageLive(_6); StorageLive(_7); @@ -160,7 +160,7 @@ + StorageLive(_14); + _14 = (); + StorageLive(_41); -+ _41 = Option::<()>::Some(_14); ++ _41 = Option::<()>::Some(copy _14); + _13 = std::future::Ready::<()>(move _41); + StorageDead(_41); + StorageDead(_14); @@ -193,7 +193,7 @@ + StorageLive(_22); + StorageLive(_23); + StorageLive(_24); -+ _24 = _31; ++ _24 = copy _31; + _23 = move _24; + _22 = &mut (*_23); + StorageDead(_24); @@ -231,8 +231,8 @@ + + bb10: { + StorageLive(_26); -+ _26 = ((_18 as Ready).0: ()); -+ _30 = _26; ++ _26 = copy ((_18 as Ready).0: ()); ++ _30 = copy _26; + StorageDead(_26); + StorageDead(_23); + StorageDead(_21); diff --git a/tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-unwind.diff b/tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-unwind.diff index 494f5591e325..b1840beb3efc 100644 --- a/tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-unwind.diff +++ b/tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-unwind.diff @@ -87,7 +87,7 @@ - } - - bb2: { -+ _4 = Pin::<&mut {async fn body of ActionPermit<'_, T>::perform()}> { __pointer: _5 }; ++ _4 = Pin::<&mut {async fn body of ActionPermit<'_, T>::perform()}> { __pointer: copy _5 }; StorageDead(_5); StorageLive(_6); StorageLive(_7); @@ -177,7 +177,7 @@ + StorageLive(_14); + _14 = (); + StorageLive(_43); -+ _43 = Option::<()>::Some(_14); ++ _43 = Option::<()>::Some(copy _14); + _13 = std::future::Ready::<()>(move _43); + StorageDead(_43); + StorageDead(_14); @@ -212,7 +212,7 @@ + StorageLive(_22); + StorageLive(_23); + StorageLive(_24); -+ _24 = _31; ++ _24 = copy _31; + _23 = move _24; + _22 = &mut (*_23); + StorageDead(_24); @@ -250,8 +250,8 @@ + + bb12: { + StorageLive(_26); -+ _26 = ((_18 as Ready).0: ()); -+ _30 = _26; ++ _26 = copy ((_18 as Ready).0: ()); ++ _30 = copy _26; + StorageDead(_26); + StorageDead(_23); + StorageDead(_21); diff --git a/tests/mir-opt/instsimplify/bool_compare.eq_false.InstSimplify-after-simplifycfg.diff b/tests/mir-opt/instsimplify/bool_compare.eq_false.InstSimplify-after-simplifycfg.diff index fea5f4f02ceb..4762123184b6 100644 --- a/tests/mir-opt/instsimplify/bool_compare.eq_false.InstSimplify-after-simplifycfg.diff +++ b/tests/mir-opt/instsimplify/bool_compare.eq_false.InstSimplify-after-simplifycfg.diff @@ -10,7 +10,7 @@ bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; - _2 = Eq(move _3, const false); + _2 = Not(move _3); switchInt(move _2) -> [0: bb2, otherwise: bb1]; diff --git a/tests/mir-opt/instsimplify/bool_compare.eq_true.InstSimplify-after-simplifycfg.diff b/tests/mir-opt/instsimplify/bool_compare.eq_true.InstSimplify-after-simplifycfg.diff index 9a509ccfa67b..6fae0acf439d 100644 --- a/tests/mir-opt/instsimplify/bool_compare.eq_true.InstSimplify-after-simplifycfg.diff +++ b/tests/mir-opt/instsimplify/bool_compare.eq_true.InstSimplify-after-simplifycfg.diff @@ -10,7 +10,7 @@ bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; - _2 = Eq(move _3, const true); + _2 = move _3; switchInt(move _2) -> [0: bb2, otherwise: bb1]; diff --git a/tests/mir-opt/instsimplify/bool_compare.false_eq.InstSimplify-after-simplifycfg.diff b/tests/mir-opt/instsimplify/bool_compare.false_eq.InstSimplify-after-simplifycfg.diff index e4ec4c80579e..7975a808d4f2 100644 --- a/tests/mir-opt/instsimplify/bool_compare.false_eq.InstSimplify-after-simplifycfg.diff +++ b/tests/mir-opt/instsimplify/bool_compare.false_eq.InstSimplify-after-simplifycfg.diff @@ -10,7 +10,7 @@ bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; - _2 = Eq(const false, move _3); + _2 = Not(move _3); switchInt(move _2) -> [0: bb2, otherwise: bb1]; diff --git a/tests/mir-opt/instsimplify/bool_compare.false_ne.InstSimplify-after-simplifycfg.diff b/tests/mir-opt/instsimplify/bool_compare.false_ne.InstSimplify-after-simplifycfg.diff index 3aea55f4db4f..80d0cd62007b 100644 --- a/tests/mir-opt/instsimplify/bool_compare.false_ne.InstSimplify-after-simplifycfg.diff +++ b/tests/mir-opt/instsimplify/bool_compare.false_ne.InstSimplify-after-simplifycfg.diff @@ -10,7 +10,7 @@ bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; - _2 = Ne(const false, move _3); + _2 = move _3; switchInt(move _2) -> [0: bb2, otherwise: bb1]; diff --git a/tests/mir-opt/instsimplify/bool_compare.ne_false.InstSimplify-after-simplifycfg.diff b/tests/mir-opt/instsimplify/bool_compare.ne_false.InstSimplify-after-simplifycfg.diff index b6e891088a1d..c0f8b5261c27 100644 --- a/tests/mir-opt/instsimplify/bool_compare.ne_false.InstSimplify-after-simplifycfg.diff +++ b/tests/mir-opt/instsimplify/bool_compare.ne_false.InstSimplify-after-simplifycfg.diff @@ -10,7 +10,7 @@ bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; - _2 = Ne(move _3, const false); + _2 = move _3; switchInt(move _2) -> [0: bb2, otherwise: bb1]; diff --git a/tests/mir-opt/instsimplify/bool_compare.ne_true.InstSimplify-after-simplifycfg.diff b/tests/mir-opt/instsimplify/bool_compare.ne_true.InstSimplify-after-simplifycfg.diff index 974738bb3a9e..4627b3144088 100644 --- a/tests/mir-opt/instsimplify/bool_compare.ne_true.InstSimplify-after-simplifycfg.diff +++ b/tests/mir-opt/instsimplify/bool_compare.ne_true.InstSimplify-after-simplifycfg.diff @@ -10,7 +10,7 @@ bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; - _2 = Ne(move _3, const true); + _2 = Not(move _3); switchInt(move _2) -> [0: bb2, otherwise: bb1]; diff --git a/tests/mir-opt/instsimplify/bool_compare.true_eq.InstSimplify-after-simplifycfg.diff b/tests/mir-opt/instsimplify/bool_compare.true_eq.InstSimplify-after-simplifycfg.diff index 240835bf7f22..91ca1ba553e0 100644 --- a/tests/mir-opt/instsimplify/bool_compare.true_eq.InstSimplify-after-simplifycfg.diff +++ b/tests/mir-opt/instsimplify/bool_compare.true_eq.InstSimplify-after-simplifycfg.diff @@ -10,7 +10,7 @@ bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; - _2 = Eq(const true, move _3); + _2 = move _3; switchInt(move _2) -> [0: bb2, otherwise: bb1]; diff --git a/tests/mir-opt/instsimplify/bool_compare.true_ne.InstSimplify-after-simplifycfg.diff b/tests/mir-opt/instsimplify/bool_compare.true_ne.InstSimplify-after-simplifycfg.diff index 1e2b2c27f570..744c61b987d1 100644 --- a/tests/mir-opt/instsimplify/bool_compare.true_ne.InstSimplify-after-simplifycfg.diff +++ b/tests/mir-opt/instsimplify/bool_compare.true_ne.InstSimplify-after-simplifycfg.diff @@ -10,7 +10,7 @@ bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; - _2 = Ne(const true, move _3); + _2 = Not(move _3); switchInt(move _2) -> [0: bb2, otherwise: bb1]; diff --git a/tests/mir-opt/instsimplify/casts.redundant.InstSimplify-after-simplifycfg.diff b/tests/mir-opt/instsimplify/casts.redundant.InstSimplify-after-simplifycfg.diff index 7001589d9e3c..afa25ecdbfba 100644 --- a/tests/mir-opt/instsimplify/casts.redundant.InstSimplify-after-simplifycfg.diff +++ b/tests/mir-opt/instsimplify/casts.redundant.InstSimplify-after-simplifycfg.diff @@ -15,16 +15,16 @@ StorageLive(_2); StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; StorageLive(_5); - _5 = _4; + _5 = copy _4; - _3 = move _5 as *const &u8 (PtrToPtr); + _3 = move _5; StorageDead(_5); StorageDead(_4); - _2 = move _3 as *const &u8 (PtrToPtr); + _2 = move _3; - _0 = _2; + _0 = copy _2; StorageDead(_3); StorageDead(_2); return; diff --git a/tests/mir-opt/instsimplify/casts.roundtrip.InstSimplify-after-simplifycfg.diff b/tests/mir-opt/instsimplify/casts.roundtrip.InstSimplify-after-simplifycfg.diff index e1045db97307..12e2913a8ca8 100644 --- a/tests/mir-opt/instsimplify/casts.roundtrip.InstSimplify-after-simplifycfg.diff +++ b/tests/mir-opt/instsimplify/casts.roundtrip.InstSimplify-after-simplifycfg.diff @@ -12,7 +12,7 @@ StorageLive(_2); StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; _3 = move _4 as *mut u8 (PtrToPtr); _2 = move _3 as *const u8 (PtrToPtr); StorageDead(_4); diff --git a/tests/mir-opt/instsimplify/combine_array_len.norm2.InstSimplify-after-simplifycfg.panic-abort.diff b/tests/mir-opt/instsimplify/combine_array_len.norm2.InstSimplify-after-simplifycfg.panic-abort.diff index a7de09ca3868..f39df7ffca0f 100644 --- a/tests/mir-opt/instsimplify/combine_array_len.norm2.InstSimplify-after-simplifycfg.panic-abort.diff +++ b/tests/mir-opt/instsimplify/combine_array_len.norm2.InstSimplify-after-simplifycfg.panic-abort.diff @@ -31,38 +31,38 @@ _3 = const 0_usize; - _4 = Len(_1); + _4 = const 2_usize; - _5 = Lt(_3, _4); - assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind unreachable]; + _5 = Lt(copy _3, copy _4); + assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind unreachable]; } bb1: { - _2 = _1[_3]; + _2 = copy _1[_3]; StorageDead(_3); StorageLive(_6); StorageLive(_7); _7 = const 1_usize; - _8 = Len(_1); + _8 = const 2_usize; - _9 = Lt(_7, _8); - assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, _7) -> [success: bb2, unwind unreachable]; + _9 = Lt(copy _7, copy _8); + assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, copy _7) -> [success: bb2, unwind unreachable]; } bb2: { - _6 = _1[_7]; + _6 = copy _1[_7]; StorageDead(_7); StorageLive(_10); StorageLive(_11); - _11 = _2; + _11 = copy _2; StorageLive(_12); - _12 = _2; + _12 = copy _2; _10 = Mul(move _11, move _12); StorageDead(_12); StorageDead(_11); StorageLive(_13); StorageLive(_14); - _14 = _6; + _14 = copy _6; StorageLive(_15); - _15 = _6; + _15 = copy _6; _13 = Mul(move _14, move _15); StorageDead(_15); StorageDead(_14); diff --git a/tests/mir-opt/instsimplify/combine_array_len.norm2.InstSimplify-after-simplifycfg.panic-unwind.diff b/tests/mir-opt/instsimplify/combine_array_len.norm2.InstSimplify-after-simplifycfg.panic-unwind.diff index c15f7e47fe36..0e7d5653c682 100644 --- a/tests/mir-opt/instsimplify/combine_array_len.norm2.InstSimplify-after-simplifycfg.panic-unwind.diff +++ b/tests/mir-opt/instsimplify/combine_array_len.norm2.InstSimplify-after-simplifycfg.panic-unwind.diff @@ -31,38 +31,38 @@ _3 = const 0_usize; - _4 = Len(_1); + _4 = const 2_usize; - _5 = Lt(_3, _4); - assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind continue]; + _5 = Lt(copy _3, copy _4); + assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind continue]; } bb1: { - _2 = _1[_3]; + _2 = copy _1[_3]; StorageDead(_3); StorageLive(_6); StorageLive(_7); _7 = const 1_usize; - _8 = Len(_1); + _8 = const 2_usize; - _9 = Lt(_7, _8); - assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, _7) -> [success: bb2, unwind continue]; + _9 = Lt(copy _7, copy _8); + assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, copy _7) -> [success: bb2, unwind continue]; } bb2: { - _6 = _1[_7]; + _6 = copy _1[_7]; StorageDead(_7); StorageLive(_10); StorageLive(_11); - _11 = _2; + _11 = copy _2; StorageLive(_12); - _12 = _2; + _12 = copy _2; _10 = Mul(move _11, move _12); StorageDead(_12); StorageDead(_11); StorageLive(_13); StorageLive(_14); - _14 = _6; + _14 = copy _6; StorageLive(_15); - _15 = _6; + _15 = copy _6; _13 = Mul(move _14, move _15); StorageDead(_15); StorageDead(_14); diff --git a/tests/mir-opt/instsimplify/combine_clone_of_primitives.{impl#0}-clone.InstSimplify-after-simplifycfg.panic-abort.diff b/tests/mir-opt/instsimplify/combine_clone_of_primitives.{impl#0}-clone.InstSimplify-after-simplifycfg.panic-abort.diff index c6f858d89eb2..d0b50c597c4f 100644 --- a/tests/mir-opt/instsimplify/combine_clone_of_primitives.{impl#0}-clone.InstSimplify-after-simplifycfg.panic-abort.diff +++ b/tests/mir-opt/instsimplify/combine_clone_of_primitives.{impl#0}-clone.InstSimplify-after-simplifycfg.panic-abort.diff @@ -20,7 +20,7 @@ StorageLive(_4); _4 = &((*_1).0: T); - _3 = &(*_4); -+ _3 = _4; ++ _3 = copy _4; _2 = ::clone(move _3) -> [return: bb1, unwind unreachable]; } @@ -32,8 +32,8 @@ _7 = &((*_1).1: u64); - _6 = &(*_7); - _5 = ::clone(move _6) -> [return: bb2, unwind unreachable]; -+ _6 = _7; -+ _5 = (*_6); ++ _6 = copy _7; ++ _5 = copy (*_6); + goto -> bb2; } @@ -45,8 +45,8 @@ _10 = &((*_1).2: [f32; 3]); - _9 = &(*_10); - _8 = <[f32; 3] as Clone>::clone(move _9) -> [return: bb3, unwind unreachable]; -+ _9 = _10; -+ _8 = (*_9); ++ _9 = copy _10; ++ _8 = copy (*_9); + goto -> bb3; } diff --git a/tests/mir-opt/instsimplify/combine_clone_of_primitives.{impl#0}-clone.InstSimplify-after-simplifycfg.panic-unwind.diff b/tests/mir-opt/instsimplify/combine_clone_of_primitives.{impl#0}-clone.InstSimplify-after-simplifycfg.panic-unwind.diff index 691ab1f0e7fb..b8f4f348530a 100644 --- a/tests/mir-opt/instsimplify/combine_clone_of_primitives.{impl#0}-clone.InstSimplify-after-simplifycfg.panic-unwind.diff +++ b/tests/mir-opt/instsimplify/combine_clone_of_primitives.{impl#0}-clone.InstSimplify-after-simplifycfg.panic-unwind.diff @@ -20,7 +20,7 @@ StorageLive(_4); _4 = &((*_1).0: T); - _3 = &(*_4); -+ _3 = _4; ++ _3 = copy _4; _2 = ::clone(move _3) -> [return: bb1, unwind continue]; } @@ -32,8 +32,8 @@ _7 = &((*_1).1: u64); - _6 = &(*_7); - _5 = ::clone(move _6) -> [return: bb2, unwind: bb4]; -+ _6 = _7; -+ _5 = (*_6); ++ _6 = copy _7; ++ _5 = copy (*_6); + goto -> bb2; } @@ -45,8 +45,8 @@ _10 = &((*_1).2: [f32; 3]); - _9 = &(*_10); - _8 = <[f32; 3] as Clone>::clone(move _9) -> [return: bb3, unwind: bb4]; -+ _9 = _10; -+ _8 = (*_9); ++ _9 = copy _10; ++ _8 = copy (*_9); + goto -> bb3; } diff --git a/tests/mir-opt/instsimplify/duplicate_switch_targets.assert_zero.InstSimplify-after-simplifycfg.diff b/tests/mir-opt/instsimplify/duplicate_switch_targets.assert_zero.InstSimplify-after-simplifycfg.diff index 7596aa203086..5d74f0f75db9 100644 --- a/tests/mir-opt/instsimplify/duplicate_switch_targets.assert_zero.InstSimplify-after-simplifycfg.diff +++ b/tests/mir-opt/instsimplify/duplicate_switch_targets.assert_zero.InstSimplify-after-simplifycfg.diff @@ -5,8 +5,8 @@ let mut _0: u8; bb0: { -- switchInt(_1) -> [0: bb2, 1: bb1, otherwise: bb1]; -+ switchInt(_1) -> [0: bb2, otherwise: bb1]; +- switchInt(copy _1) -> [0: bb2, 1: bb1, otherwise: bb1]; ++ switchInt(copy _1) -> [0: bb2, otherwise: bb1]; } bb1: { @@ -14,7 +14,7 @@ } bb2: { - _0 = _1; + _0 = copy _1; return; } } diff --git a/tests/mir-opt/instsimplify/ref_of_deref.pointers.InstSimplify-after-simplifycfg.diff b/tests/mir-opt/instsimplify/ref_of_deref.pointers.InstSimplify-after-simplifycfg.diff index ca26f0240f9d..b2f720be9e16 100644 --- a/tests/mir-opt/instsimplify/ref_of_deref.pointers.InstSimplify-after-simplifycfg.diff +++ b/tests/mir-opt/instsimplify/ref_of_deref.pointers.InstSimplify-after-simplifycfg.diff @@ -39,12 +39,12 @@ _5 = &mut (*_2); StorageLive(_6); - _6 = &raw const (*_1); -+ _6 = _1; ++ _6 = copy _1; StorageLive(_7); _7 = &raw const (*_2); StorageLive(_8); - _8 = &raw mut (*_2); -+ _8 = _2; ++ _8 = copy _2; _0 = const (); StorageDead(_8); StorageDead(_7); diff --git a/tests/mir-opt/instsimplify/ref_of_deref.references.InstSimplify-after-simplifycfg.diff b/tests/mir-opt/instsimplify/ref_of_deref.references.InstSimplify-after-simplifycfg.diff index 928ee3acaa02..4ea9da46c55d 100644 --- a/tests/mir-opt/instsimplify/ref_of_deref.references.InstSimplify-after-simplifycfg.diff +++ b/tests/mir-opt/instsimplify/ref_of_deref.references.InstSimplify-after-simplifycfg.diff @@ -33,12 +33,12 @@ bb0: { StorageLive(_3); - _3 = &(*_1); -+ _3 = _1; ++ _3 = copy _1; StorageLive(_4); _4 = &(*_2); StorageLive(_5); - _5 = &mut (*_2); -+ _5 = _2; ++ _5 = copy _2; StorageLive(_6); _6 = &raw const (*_1); StorageLive(_7); diff --git a/tests/mir-opt/instsimplify/ub_check.unwrap_unchecked.InstSimplify-after-simplifycfg.diff b/tests/mir-opt/instsimplify/ub_check.unwrap_unchecked.InstSimplify-after-simplifycfg.diff index 7ef77e76d129..5fee9a6733dd 100644 --- a/tests/mir-opt/instsimplify/ub_check.unwrap_unchecked.InstSimplify-after-simplifycfg.diff +++ b/tests/mir-opt/instsimplify/ub_check.unwrap_unchecked.InstSimplify-after-simplifycfg.diff @@ -21,7 +21,7 @@ bb0: { StorageLive(_2); - _2 = _1; + _2 = copy _1; StorageLive(_3); StorageLive(_5); _3 = discriminant(_2); @@ -36,7 +36,7 @@ StorageLive(_4); - _4 = UbChecks(); + _4 = const false; - assume(_4); + assume(copy _4); _5 = unreachable_unchecked::precondition_check() -> [return: bb1, unwind unreachable]; } diff --git a/tests/mir-opt/issue_101973.inner.GVN.panic-abort.diff b/tests/mir-opt/issue_101973.inner.GVN.panic-abort.diff index 311de9e1c93f..ac88fe67bb86 100644 --- a/tests/mir-opt/issue_101973.inner.GVN.panic-abort.diff +++ b/tests/mir-opt/issue_101973.inner.GVN.panic-abort.diff @@ -29,22 +29,22 @@ StorageLive(_3); StorageLive(_4); StorageLive(_5); - _5 = _1; + _5 = copy _1; nop; - StorageLive(_14); -- _14 = BitAnd(_5, const 255_u32); +- _14 = BitAnd(copy _5, const 255_u32); - _4 = BitOr(const 0_u32, move _14); - StorageDead(_14); + nop; -+ _14 = BitAnd(_1, const 255_u32); -+ _4 = _14; ++ _14 = BitAnd(copy _1, const 255_u32); ++ _4 = copy _14; + nop; StorageDead(_5); StorageLive(_6); StorageLive(_7); StorageLive(_8); StorageLive(_9); - _9 = _1; + _9 = copy _1; - _10 = const 8_i32 as u32 (IntToInt); - _11 = Lt(move _10, const 32_u32); - assert(move _11, "attempt to shift right by `{}`, which would overflow", const 8_i32) -> [success: bb1, unwind unreachable]; @@ -55,7 +55,7 @@ bb1: { - _8 = Shr(move _9, const 8_i32); -+ _8 = Shr(_1, const 8_i32); ++ _8 = Shr(copy _1, const 8_i32); StorageDead(_9); _7 = BitAnd(move _8, const 15_u32); StorageDead(_8); @@ -71,7 +71,7 @@ _6 = Shl(move _7, const 1_i32); StorageDead(_7); - _3 = rotate_right::(move _4, move _6) -> [return: bb3, unwind unreachable]; -+ _3 = rotate_right::(_14, move _6) -> [return: bb3, unwind unreachable]; ++ _3 = rotate_right::(copy _14, move _6) -> [return: bb3, unwind unreachable]; } bb3: { diff --git a/tests/mir-opt/issue_101973.inner.GVN.panic-unwind.diff b/tests/mir-opt/issue_101973.inner.GVN.panic-unwind.diff index c5fd042161d2..96c3cae2d334 100644 --- a/tests/mir-opt/issue_101973.inner.GVN.panic-unwind.diff +++ b/tests/mir-opt/issue_101973.inner.GVN.panic-unwind.diff @@ -29,22 +29,22 @@ StorageLive(_3); StorageLive(_4); StorageLive(_5); - _5 = _1; + _5 = copy _1; nop; - StorageLive(_14); -- _14 = BitAnd(_5, const 255_u32); +- _14 = BitAnd(copy _5, const 255_u32); - _4 = BitOr(const 0_u32, move _14); - StorageDead(_14); + nop; -+ _14 = BitAnd(_1, const 255_u32); -+ _4 = _14; ++ _14 = BitAnd(copy _1, const 255_u32); ++ _4 = copy _14; + nop; StorageDead(_5); StorageLive(_6); StorageLive(_7); StorageLive(_8); StorageLive(_9); - _9 = _1; + _9 = copy _1; - _10 = const 8_i32 as u32 (IntToInt); - _11 = Lt(move _10, const 32_u32); - assert(move _11, "attempt to shift right by `{}`, which would overflow", const 8_i32) -> [success: bb1, unwind continue]; @@ -55,7 +55,7 @@ bb1: { - _8 = Shr(move _9, const 8_i32); -+ _8 = Shr(_1, const 8_i32); ++ _8 = Shr(copy _1, const 8_i32); StorageDead(_9); _7 = BitAnd(move _8, const 15_u32); StorageDead(_8); @@ -71,7 +71,7 @@ _6 = Shl(move _7, const 1_i32); StorageDead(_7); - _3 = rotate_right::(move _4, move _6) -> [return: bb3, unwind unreachable]; -+ _3 = rotate_right::(_14, move _6) -> [return: bb3, unwind unreachable]; ++ _3 = rotate_right::(copy _14, move _6) -> [return: bb3, unwind unreachable]; } bb3: { diff --git a/tests/mir-opt/issue_38669.main.SimplifyCfg-initial.after.mir b/tests/mir-opt/issue_38669.main.SimplifyCfg-initial.after.mir index 632b5580656d..66dbbc0c044b 100644 --- a/tests/mir-opt/issue_38669.main.SimplifyCfg-initial.after.mir +++ b/tests/mir-opt/issue_38669.main.SimplifyCfg-initial.after.mir @@ -25,7 +25,7 @@ fn main() -> () { bb2: { StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; switchInt(move _4) -> [0: bb4, otherwise: bb3]; } diff --git a/tests/mir-opt/issue_41110.main.ElaborateDrops.panic-abort.diff b/tests/mir-opt/issue_41110.main.ElaborateDrops.panic-abort.diff index 4469270a9b23..cf9522301281 100644 --- a/tests/mir-opt/issue_41110.main.ElaborateDrops.panic-abort.diff +++ b/tests/mir-opt/issue_41110.main.ElaborateDrops.panic-abort.diff @@ -63,7 +63,7 @@ + } + + bb8 (cleanup): { -+ switchInt(_5) -> [0: bb6, otherwise: bb7]; ++ switchInt(copy _5) -> [0: bb6, otherwise: bb7]; } } diff --git a/tests/mir-opt/issue_41110.main.ElaborateDrops.panic-unwind.diff b/tests/mir-opt/issue_41110.main.ElaborateDrops.panic-unwind.diff index 4469270a9b23..cf9522301281 100644 --- a/tests/mir-opt/issue_41110.main.ElaborateDrops.panic-unwind.diff +++ b/tests/mir-opt/issue_41110.main.ElaborateDrops.panic-unwind.diff @@ -63,7 +63,7 @@ + } + + bb8 (cleanup): { -+ switchInt(_5) -> [0: bb6, otherwise: bb7]; ++ switchInt(copy _5) -> [0: bb6, otherwise: bb7]; } } diff --git a/tests/mir-opt/issue_41110.test.ElaborateDrops.panic-abort.diff b/tests/mir-opt/issue_41110.test.ElaborateDrops.panic-abort.diff index 78184f6aeeb1..15fd95a63fff 100644 --- a/tests/mir-opt/issue_41110.test.ElaborateDrops.panic-abort.diff +++ b/tests/mir-opt/issue_41110.test.ElaborateDrops.panic-abort.diff @@ -93,7 +93,7 @@ + } + + bb12 (cleanup): { -+ switchInt(_6) -> [0: bb10, otherwise: bb11]; ++ switchInt(copy _6) -> [0: bb10, otherwise: bb11]; } } diff --git a/tests/mir-opt/issue_41110.test.ElaborateDrops.panic-unwind.diff b/tests/mir-opt/issue_41110.test.ElaborateDrops.panic-unwind.diff index 688887c3c1f5..4a0067981cb7 100644 --- a/tests/mir-opt/issue_41110.test.ElaborateDrops.panic-unwind.diff +++ b/tests/mir-opt/issue_41110.test.ElaborateDrops.panic-unwind.diff @@ -93,7 +93,7 @@ + } + + bb12 (cleanup): { -+ switchInt(_6) -> [0: bb10, otherwise: bb11]; ++ switchInt(copy _6) -> [0: bb10, otherwise: bb11]; } } diff --git a/tests/mir-opt/issue_41888.main.ElaborateDrops.panic-abort.diff b/tests/mir-opt/issue_41888.main.ElaborateDrops.panic-abort.diff index 55d2629a5519..e2726464ef3a 100644 --- a/tests/mir-opt/issue_41888.main.ElaborateDrops.panic-abort.diff +++ b/tests/mir-opt/issue_41888.main.ElaborateDrops.panic-abort.diff @@ -115,7 +115,7 @@ + } + + bb15 (cleanup): { -+ switchInt(_7) -> [0: bb12, otherwise: bb14]; ++ switchInt(copy _7) -> [0: bb12, otherwise: bb14]; + } + + bb16: { @@ -132,7 +132,7 @@ + } + + bb19: { -+ switchInt(_7) -> [0: bb13, otherwise: bb18]; ++ switchInt(copy _7) -> [0: bb13, otherwise: bb18]; + } + + bb20 (cleanup): { @@ -141,7 +141,7 @@ + } + + bb21 (cleanup): { -+ switchInt(_7) -> [0: bb12, otherwise: bb20]; ++ switchInt(copy _7) -> [0: bb12, otherwise: bb20]; } } diff --git a/tests/mir-opt/issue_41888.main.ElaborateDrops.panic-unwind.diff b/tests/mir-opt/issue_41888.main.ElaborateDrops.panic-unwind.diff index c731b5646f68..7efa3330e66a 100644 --- a/tests/mir-opt/issue_41888.main.ElaborateDrops.panic-unwind.diff +++ b/tests/mir-opt/issue_41888.main.ElaborateDrops.panic-unwind.diff @@ -115,7 +115,7 @@ + } + + bb15 (cleanup): { -+ switchInt(_7) -> [0: bb12, otherwise: bb14]; ++ switchInt(copy _7) -> [0: bb12, otherwise: bb14]; + } + + bb16: { @@ -132,7 +132,7 @@ + } + + bb19: { -+ switchInt(_7) -> [0: bb13, otherwise: bb18]; ++ switchInt(copy _7) -> [0: bb13, otherwise: bb18]; + } + + bb20 (cleanup): { @@ -141,7 +141,7 @@ + } + + bb21 (cleanup): { -+ switchInt(_7) -> [0: bb12, otherwise: bb20]; ++ switchInt(copy _7) -> [0: bb12, otherwise: bb20]; } } diff --git a/tests/mir-opt/issue_62289.test.ElaborateDrops.before.panic-abort.mir b/tests/mir-opt/issue_62289.test.ElaborateDrops.before.panic-abort.mir index 3104baa5fdbd..736a8bbca49c 100644 --- a/tests/mir-opt/issue_62289.test.ElaborateDrops.before.panic-abort.mir +++ b/tests/mir-opt/issue_62289.test.ElaborateDrops.before.panic-abort.mir @@ -54,8 +54,8 @@ fn test() -> Option> { bb4: { StorageLive(_12); - _12 = ((_6 as Continue).0: u32); - (*_5) = _12; + _12 = copy ((_6 as Continue).0: u32); + (*_5) = copy _12; StorageDead(_12); _1 = move _5; drop(_5) -> [return: bb7, unwind: bb11]; @@ -63,9 +63,9 @@ fn test() -> Option> { bb5: { StorageLive(_9); - _9 = ((_6 as Break).0: std::option::Option); + _9 = copy ((_6 as Break).0: std::option::Option); StorageLive(_11); - _11 = _9; + _11 = copy _9; _0 = > as FromResidual>>::from_residual(move _11) -> [return: bb6, unwind: bb12]; } diff --git a/tests/mir-opt/issue_62289.test.ElaborateDrops.before.panic-unwind.mir b/tests/mir-opt/issue_62289.test.ElaborateDrops.before.panic-unwind.mir index da33c8301151..1acb1ae20b69 100644 --- a/tests/mir-opt/issue_62289.test.ElaborateDrops.before.panic-unwind.mir +++ b/tests/mir-opt/issue_62289.test.ElaborateDrops.before.panic-unwind.mir @@ -54,8 +54,8 @@ fn test() -> Option> { bb4: { StorageLive(_12); - _12 = ((_6 as Continue).0: u32); - (*_5) = _12; + _12 = copy ((_6 as Continue).0: u32); + (*_5) = copy _12; StorageDead(_12); _1 = move _5; drop(_5) -> [return: bb7, unwind: bb11]; @@ -63,9 +63,9 @@ fn test() -> Option> { bb5: { StorageLive(_9); - _9 = ((_6 as Break).0: std::option::Option); + _9 = copy ((_6 as Break).0: std::option::Option); StorageLive(_11); - _11 = _9; + _11 = copy _9; _0 = > as FromResidual>>::from_residual(move _11) -> [return: bb6, unwind: bb12]; } diff --git a/tests/mir-opt/issue_72181.bar.built.after.mir b/tests/mir-opt/issue_72181.bar.built.after.mir index b6cc7d221956..569c4a006282 100644 --- a/tests/mir-opt/issue_72181.bar.built.after.mir +++ b/tests/mir-opt/issue_72181.bar.built.after.mir @@ -9,8 +9,8 @@ fn bar(_1: [(Never, u32); 1]) -> u32 { bb0: { StorageLive(_2); - _2 = (_1[0 of 1].1: u32); - _0 = _2; + _2 = copy (_1[0 of 1].1: u32); + _0 = copy _2; StorageDead(_2); return; } diff --git a/tests/mir-opt/issue_72181.foo.built.after.mir b/tests/mir-opt/issue_72181.foo.built.after.mir index f78942cc56fd..314cf8b367f5 100644 --- a/tests/mir-opt/issue_72181.foo.built.after.mir +++ b/tests/mir-opt/issue_72181.foo.built.after.mir @@ -11,12 +11,12 @@ fn foo(_1: [(Never, u32); 1]) -> u32 { StorageLive(_2); _2 = const 0_usize; _3 = Len(_1); - _4 = Lt(_2, _3); - assert(move _4, "index out of bounds: the length is {} but the index is {}", move _3, _2) -> [success: bb1, unwind: bb2]; + _4 = Lt(copy _2, copy _3); + assert(move _4, "index out of bounds: the length is {} but the index is {}", move _3, copy _2) -> [success: bb1, unwind: bb2]; } bb1: { - _0 = (_1[_2].1: u32); + _0 = copy (_1[_2].1: u32); StorageDead(_2); return; } diff --git a/tests/mir-opt/issue_72181.main.built.after.mir b/tests/mir-opt/issue_72181.main.built.after.mir index 89d351d5172c..aade84a6dd2e 100644 --- a/tests/mir-opt/issue_72181.main.built.after.mir +++ b/tests/mir-opt/issue_72181.main.built.after.mir @@ -39,8 +39,8 @@ fn main() -> () { StorageLive(_6); _6 = const 0_usize; _7 = Len(_2); - _8 = Lt(_6, _7); - assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, _6) -> [success: bb3, unwind: bb5]; + _8 = Lt(copy _6, copy _7); + assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, copy _6) -> [success: bb3, unwind: bb5]; } bb2: { @@ -49,7 +49,7 @@ fn main() -> () { } bb3: { - _5 = (_2[_6].0: u64); + _5 = copy (_2[_6].0: u64); PlaceMention(_5); StorageDead(_6); StorageDead(_5); diff --git a/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-abort.diff b/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-abort.diff index 861ee1d3d3d4..f03691ad6731 100644 --- a/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-abort.diff +++ b/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-abort.diff @@ -24,9 +24,9 @@ bb0: { StorageLive(_4); - _4 = [_1, _1, _1]; + _4 = [copy _1, copy _1, copy _1]; _3 = &_4; - _2 = _3 as &[T] (PointerCoercion(Unsize)); + _2 = copy _3 as &[T] (PointerCoercion(Unsize)); nop; nop; goto -> bb2; diff --git a/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-unwind.diff b/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-unwind.diff index f27be9533847..633e5c740a1a 100644 --- a/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-unwind.diff +++ b/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-unwind.diff @@ -24,9 +24,9 @@ bb0: { StorageLive(_4); - _4 = [_1, _1, _1]; + _4 = [copy _1, copy _1, copy _1]; _3 = &_4; - _2 = _3 as &[T] (PointerCoercion(Unsize)); + _2 = copy _3 as &[T] (PointerCoercion(Unsize)); nop; nop; goto -> bb2; diff --git a/tests/mir-opt/issue_78192.f.InstSimplify-after-simplifycfg.diff b/tests/mir-opt/issue_78192.f.InstSimplify-after-simplifycfg.diff index 53957bb3cb19..aae0570973df 100644 --- a/tests/mir-opt/issue_78192.f.InstSimplify-after-simplifycfg.diff +++ b/tests/mir-opt/issue_78192.f.InstSimplify-after-simplifycfg.diff @@ -17,9 +17,9 @@ StorageLive(_4); _4 = &raw const (*_1); _3 = &_4; - _2 = _3; + _2 = copy _3; StorageDead(_3); - _0 = (*_2); + _0 = copy (*_2); StorageDead(_4); StorageDead(_2); return; diff --git a/tests/mir-opt/issue_91633.foo.built.after.mir b/tests/mir-opt/issue_91633.foo.built.after.mir index a66769f0d112..50fdf08375a0 100644 --- a/tests/mir-opt/issue_91633.foo.built.after.mir +++ b/tests/mir-opt/issue_91633.foo.built.after.mir @@ -18,8 +18,8 @@ fn foo(_1: Box<[T]>) -> T { StorageLive(_4); _4 = const 0_usize; _5 = Len((*_1)); - _6 = Lt(_4, _5); - assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, _4) -> [success: bb1, unwind: bb5]; + _6 = Lt(copy _4, copy _5); + assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, copy _4) -> [success: bb1, unwind: bb5]; } bb1: { diff --git a/tests/mir-opt/issue_91633.fun.built.after.mir b/tests/mir-opt/issue_91633.fun.built.after.mir index 7175c9e80066..5b41b376719b 100644 --- a/tests/mir-opt/issue_91633.fun.built.after.mir +++ b/tests/mir-opt/issue_91633.fun.built.after.mir @@ -16,8 +16,8 @@ fn fun(_1: &[T]) -> &T { StorageLive(_3); _3 = const 0_usize; _4 = Len((*_1)); - _5 = Lt(_3, _4); - assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind: bb2]; + _5 = Lt(copy _3, copy _4); + assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind: bb2]; } bb1: { diff --git a/tests/mir-opt/issue_99325.main.built.after.32bit.mir b/tests/mir-opt/issue_99325.main.built.after.32bit.mir index 72e7f4794f98..161c73529f53 100644 --- a/tests/mir-opt/issue_99325.main.built.after.32bit.mir +++ b/tests/mir-opt/issue_99325.main.built.after.32bit.mir @@ -83,9 +83,9 @@ fn main() -> () { StorageDead(_3); PlaceMention(_2); StorageLive(_8); - _8 = (_2.0: &&[u8]); + _8 = copy (_2.0: &&[u8]); StorageLive(_9); - _9 = (_2.1: &&[u8; 4]); + _9 = copy (_2.1: &&[u8; 4]); StorageLive(_10); StorageLive(_11); _11 = &(*_8); @@ -187,9 +187,9 @@ fn main() -> () { StorageDead(_24); PlaceMention(_23); StorageLive(_28); - _28 = (_23.0: &&[u8]); + _28 = copy (_23.0: &&[u8]); StorageLive(_29); - _29 = (_23.1: &&[u8; 4]); + _29 = copy (_23.1: &&[u8; 4]); StorageLive(_30); StorageLive(_31); _31 = &(*_28); diff --git a/tests/mir-opt/issue_99325.main.built.after.64bit.mir b/tests/mir-opt/issue_99325.main.built.after.64bit.mir index 72e7f4794f98..161c73529f53 100644 --- a/tests/mir-opt/issue_99325.main.built.after.64bit.mir +++ b/tests/mir-opt/issue_99325.main.built.after.64bit.mir @@ -83,9 +83,9 @@ fn main() -> () { StorageDead(_3); PlaceMention(_2); StorageLive(_8); - _8 = (_2.0: &&[u8]); + _8 = copy (_2.0: &&[u8]); StorageLive(_9); - _9 = (_2.1: &&[u8; 4]); + _9 = copy (_2.1: &&[u8; 4]); StorageLive(_10); StorageLive(_11); _11 = &(*_8); @@ -187,9 +187,9 @@ fn main() -> () { StorageDead(_24); PlaceMention(_23); StorageLive(_28); - _28 = (_23.0: &&[u8]); + _28 = copy (_23.0: &&[u8]); StorageLive(_29); - _29 = (_23.1: &&[u8; 4]); + _29 = copy (_23.1: &&[u8; 4]); StorageLive(_30); StorageLive(_31); _31 = &(*_28); diff --git a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.panic-abort.mir b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.panic-abort.mir index 8da56d59aaa6..573c0a12bc1a 100644 --- a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.panic-abort.mir @@ -19,7 +19,7 @@ fn num_to_digit(_1: char) -> u32 { bb0: { StorageLive(_2); - _2 = char::methods::::to_digit(_1, const 8_u32) -> [return: bb1, unwind unreachable]; + _2 = char::methods::::to_digit(copy _1, const 8_u32) -> [return: bb1, unwind unreachable]; } bb1: { diff --git a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.panic-unwind.mir index 61bc09d901cb..049803041d4e 100644 --- a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.panic-unwind.mir @@ -19,7 +19,7 @@ fn num_to_digit(_1: char) -> u32 { bb0: { StorageLive(_2); - _2 = char::methods::::to_digit(_1, const 8_u32) -> [return: bb1, unwind continue]; + _2 = char::methods::::to_digit(copy _1, const 8_u32) -> [return: bb1, unwind continue]; } bb1: { diff --git a/tests/mir-opt/issues/issue_75439.foo.MatchBranchSimplification.diff b/tests/mir-opt/issues/issue_75439.foo.MatchBranchSimplification.diff index 25ed1b4d0c76..1ab9be966522 100644 --- a/tests/mir-opt/issues/issue_75439.foo.MatchBranchSimplification.diff +++ b/tests/mir-opt/issues/issue_75439.foo.MatchBranchSimplification.diff @@ -19,26 +19,26 @@ bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; _2 = move _3 as [u32; 4] (Transmute); StorageDead(_3); - switchInt(_2[0 of 4]) -> [0: bb1, otherwise: bb4]; + switchInt(copy _2[0 of 4]) -> [0: bb1, otherwise: bb4]; } bb1: { - switchInt(_2[1 of 4]) -> [0: bb2, otherwise: bb4]; + switchInt(copy _2[1 of 4]) -> [0: bb2, otherwise: bb4]; } bb2: { - switchInt(_2[2 of 4]) -> [0: bb3, 4294901760: bb3, otherwise: bb4]; + switchInt(copy _2[2 of 4]) -> [0: bb3, 4294901760: bb3, otherwise: bb4]; } bb3: { StorageLive(_4); - _4 = _2[3 of 4]; + _4 = copy _2[3 of 4]; StorageLive(_5); StorageLive(_6); - _6 = _4; + _6 = copy _4; _5 = move _6 as [u8; 4] (Transmute); StorageDead(_6); _0 = Option::<[u8; 4]>::Some(move _5); diff --git a/tests/mir-opt/jump_threading.aggregate.JumpThreading.panic-abort.diff b/tests/mir-opt/jump_threading.aggregate.JumpThreading.panic-abort.diff index e955e6690143..a7551c3fb5b7 100644 --- a/tests/mir-opt/jump_threading.aggregate.JumpThreading.panic-abort.diff +++ b/tests/mir-opt/jump_threading.aggregate.JumpThreading.panic-abort.diff @@ -18,13 +18,13 @@ StorageLive(_4); _4 = const aggregate::FOO; StorageLive(_2); - _2 = (_4.0: u8); + _2 = copy (_4.0: u8); StorageLive(_3); - _3 = (_4.1: u8); + _3 = copy (_4.1: u8); StorageDead(_4); StorageLive(_5); StorageLive(_6); - _6 = _2; + _6 = copy _2; _5 = Eq(move _6, const 7_u8); - switchInt(move _5) -> [0: bb2, otherwise: bb1]; + goto -> bb2; @@ -32,13 +32,13 @@ bb1: { StorageDead(_6); - _0 = _3; + _0 = copy _3; goto -> bb3; } bb2: { StorageDead(_6); - _0 = _2; + _0 = copy _2; goto -> bb3; } diff --git a/tests/mir-opt/jump_threading.aggregate.JumpThreading.panic-unwind.diff b/tests/mir-opt/jump_threading.aggregate.JumpThreading.panic-unwind.diff index e955e6690143..a7551c3fb5b7 100644 --- a/tests/mir-opt/jump_threading.aggregate.JumpThreading.panic-unwind.diff +++ b/tests/mir-opt/jump_threading.aggregate.JumpThreading.panic-unwind.diff @@ -18,13 +18,13 @@ StorageLive(_4); _4 = const aggregate::FOO; StorageLive(_2); - _2 = (_4.0: u8); + _2 = copy (_4.0: u8); StorageLive(_3); - _3 = (_4.1: u8); + _3 = copy (_4.1: u8); StorageDead(_4); StorageLive(_5); StorageLive(_6); - _6 = _2; + _6 = copy _2; _5 = Eq(move _6, const 7_u8); - switchInt(move _5) -> [0: bb2, otherwise: bb1]; + goto -> bb2; @@ -32,13 +32,13 @@ bb1: { StorageDead(_6); - _0 = _3; + _0 = copy _3; goto -> bb3; } bb2: { StorageDead(_6); - _0 = _2; + _0 = copy _2; goto -> bb3; } diff --git a/tests/mir-opt/jump_threading.aggregate_copy.JumpThreading.panic-abort.diff b/tests/mir-opt/jump_threading.aggregate_copy.JumpThreading.panic-abort.diff index 0c8e04a1e74d..4d639d89f0d1 100644 --- a/tests/mir-opt/jump_threading.aggregate_copy.JumpThreading.panic-abort.diff +++ b/tests/mir-opt/jump_threading.aggregate_copy.JumpThreading.panic-abort.diff @@ -22,12 +22,12 @@ StorageLive(_1); _1 = const aggregate_copy::Foo; StorageLive(_2); - _2 = _1; + _2 = copy _1; StorageLive(_3); - _3 = (_2.1: u32); + _3 = copy (_2.1: u32); StorageLive(_4); StorageLive(_5); - _5 = _3; + _5 = copy _3; _4 = Eq(move _5, const 2_u32); - switchInt(move _4) -> [0: bb2, otherwise: bb1]; + goto -> bb2; @@ -35,7 +35,7 @@ bb1: { StorageDead(_5); - _0 = (_2.0: u32); + _0 = copy (_2.0: u32); goto -> bb3; } diff --git a/tests/mir-opt/jump_threading.aggregate_copy.JumpThreading.panic-unwind.diff b/tests/mir-opt/jump_threading.aggregate_copy.JumpThreading.panic-unwind.diff index 0c8e04a1e74d..4d639d89f0d1 100644 --- a/tests/mir-opt/jump_threading.aggregate_copy.JumpThreading.panic-unwind.diff +++ b/tests/mir-opt/jump_threading.aggregate_copy.JumpThreading.panic-unwind.diff @@ -22,12 +22,12 @@ StorageLive(_1); _1 = const aggregate_copy::Foo; StorageLive(_2); - _2 = _1; + _2 = copy _1; StorageLive(_3); - _3 = (_2.1: u32); + _3 = copy (_2.1: u32); StorageLive(_4); StorageLive(_5); - _5 = _3; + _5 = copy _3; _4 = Eq(move _5, const 2_u32); - switchInt(move _4) -> [0: bb2, otherwise: bb1]; + goto -> bb2; @@ -35,7 +35,7 @@ bb1: { StorageDead(_5); - _0 = (_2.0: u32); + _0 = copy (_2.0: u32); goto -> bb3; } diff --git a/tests/mir-opt/jump_threading.assume.JumpThreading.panic-abort.diff b/tests/mir-opt/jump_threading.assume.JumpThreading.panic-abort.diff index f1f0106fdbce..519cb0f0ab1d 100644 --- a/tests/mir-opt/jump_threading.assume.JumpThreading.panic-abort.diff +++ b/tests/mir-opt/jump_threading.assume.JumpThreading.panic-abort.diff @@ -5,11 +5,11 @@ let mut _0: u8; bb0: { - switchInt(_1) -> [7: bb1, otherwise: bb2]; + switchInt(copy _1) -> [7: bb1, otherwise: bb2]; } bb1: { - assume(_2); + assume(copy _2); - goto -> bb3; + goto -> bb6; } @@ -19,7 +19,7 @@ } bb3: { - switchInt(_2) -> [0: bb4, otherwise: bb5]; + switchInt(copy _2) -> [0: bb4, otherwise: bb5]; } bb4: { diff --git a/tests/mir-opt/jump_threading.assume.JumpThreading.panic-unwind.diff b/tests/mir-opt/jump_threading.assume.JumpThreading.panic-unwind.diff index f1f0106fdbce..519cb0f0ab1d 100644 --- a/tests/mir-opt/jump_threading.assume.JumpThreading.panic-unwind.diff +++ b/tests/mir-opt/jump_threading.assume.JumpThreading.panic-unwind.diff @@ -5,11 +5,11 @@ let mut _0: u8; bb0: { - switchInt(_1) -> [7: bb1, otherwise: bb2]; + switchInt(copy _1) -> [7: bb1, otherwise: bb2]; } bb1: { - assume(_2); + assume(copy _2); - goto -> bb3; + goto -> bb6; } @@ -19,7 +19,7 @@ } bb3: { - switchInt(_2) -> [0: bb4, otherwise: bb5]; + switchInt(copy _2) -> [0: bb4, otherwise: bb5]; } bb4: { diff --git a/tests/mir-opt/jump_threading.custom_discr.JumpThreading.panic-abort.diff b/tests/mir-opt/jump_threading.custom_discr.JumpThreading.panic-abort.diff index 462cc2077858..a86371794ebe 100644 --- a/tests/mir-opt/jump_threading.custom_discr.JumpThreading.panic-abort.diff +++ b/tests/mir-opt/jump_threading.custom_discr.JumpThreading.panic-abort.diff @@ -11,7 +11,7 @@ bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; switchInt(move _3) -> [0: bb2, otherwise: bb1]; } diff --git a/tests/mir-opt/jump_threading.custom_discr.JumpThreading.panic-unwind.diff b/tests/mir-opt/jump_threading.custom_discr.JumpThreading.panic-unwind.diff index 462cc2077858..a86371794ebe 100644 --- a/tests/mir-opt/jump_threading.custom_discr.JumpThreading.panic-unwind.diff +++ b/tests/mir-opt/jump_threading.custom_discr.JumpThreading.panic-unwind.diff @@ -11,7 +11,7 @@ bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; switchInt(move _3) -> [0: bb2, otherwise: bb1]; } diff --git a/tests/mir-opt/jump_threading.disappearing_bb.JumpThreading.panic-abort.diff b/tests/mir-opt/jump_threading.disappearing_bb.JumpThreading.panic-abort.diff index f290da84e5d8..d17f2752f58e 100644 --- a/tests/mir-opt/jump_threading.disappearing_bb.JumpThreading.panic-abort.diff +++ b/tests/mir-opt/jump_threading.disappearing_bb.JumpThreading.panic-abort.diff @@ -9,7 +9,7 @@ bb0: { _2 = const true; _3 = const true; - switchInt(_1) -> [0: bb3, 1: bb3, 2: bb1, otherwise: bb2]; + switchInt(copy _1) -> [0: bb3, 1: bb3, 2: bb1, otherwise: bb2]; } bb1: { @@ -28,11 +28,11 @@ } bb4: { - switchInt(_3) -> [0: bb5, otherwise: bb7]; + switchInt(copy _3) -> [0: bb5, otherwise: bb7]; } bb5: { - switchInt(_2) -> [0: bb6, otherwise: bb8]; + switchInt(copy _2) -> [0: bb6, otherwise: bb8]; } bb6: { diff --git a/tests/mir-opt/jump_threading.disappearing_bb.JumpThreading.panic-unwind.diff b/tests/mir-opt/jump_threading.disappearing_bb.JumpThreading.panic-unwind.diff index f290da84e5d8..d17f2752f58e 100644 --- a/tests/mir-opt/jump_threading.disappearing_bb.JumpThreading.panic-unwind.diff +++ b/tests/mir-opt/jump_threading.disappearing_bb.JumpThreading.panic-unwind.diff @@ -9,7 +9,7 @@ bb0: { _2 = const true; _3 = const true; - switchInt(_1) -> [0: bb3, 1: bb3, 2: bb1, otherwise: bb2]; + switchInt(copy _1) -> [0: bb3, 1: bb3, 2: bb1, otherwise: bb2]; } bb1: { @@ -28,11 +28,11 @@ } bb4: { - switchInt(_3) -> [0: bb5, otherwise: bb7]; + switchInt(copy _3) -> [0: bb5, otherwise: bb7]; } bb5: { - switchInt(_2) -> [0: bb6, otherwise: bb8]; + switchInt(copy _2) -> [0: bb6, otherwise: bb8]; } bb6: { diff --git a/tests/mir-opt/jump_threading.duplicate_chain.JumpThreading.panic-abort.diff b/tests/mir-opt/jump_threading.duplicate_chain.JumpThreading.panic-abort.diff index adcedfb36670..083a6e7487a0 100644 --- a/tests/mir-opt/jump_threading.duplicate_chain.JumpThreading.panic-abort.diff +++ b/tests/mir-opt/jump_threading.duplicate_chain.JumpThreading.panic-abort.diff @@ -8,7 +8,7 @@ let mut _4: i32; bb0: { - switchInt(_1) -> [1: bb1, otherwise: bb2]; + switchInt(copy _1) -> [1: bb1, otherwise: bb2]; } bb1: { @@ -28,7 +28,7 @@ bb4: { _4 = const 15_i32; -- switchInt(_2) -> [5: bb5, otherwise: bb6]; +- switchInt(copy _2) -> [5: bb5, otherwise: bb6]; + goto -> bb5; } diff --git a/tests/mir-opt/jump_threading.duplicate_chain.JumpThreading.panic-unwind.diff b/tests/mir-opt/jump_threading.duplicate_chain.JumpThreading.panic-unwind.diff index adcedfb36670..083a6e7487a0 100644 --- a/tests/mir-opt/jump_threading.duplicate_chain.JumpThreading.panic-unwind.diff +++ b/tests/mir-opt/jump_threading.duplicate_chain.JumpThreading.panic-unwind.diff @@ -8,7 +8,7 @@ let mut _4: i32; bb0: { - switchInt(_1) -> [1: bb1, otherwise: bb2]; + switchInt(copy _1) -> [1: bb1, otherwise: bb2]; } bb1: { @@ -28,7 +28,7 @@ bb4: { _4 = const 15_i32; -- switchInt(_2) -> [5: bb5, otherwise: bb6]; +- switchInt(copy _2) -> [5: bb5, otherwise: bb6]; + goto -> bb5; } diff --git a/tests/mir-opt/jump_threading.floats.JumpThreading.panic-abort.diff b/tests/mir-opt/jump_threading.floats.JumpThreading.panic-abort.diff index 6ca37e96d297..1192f7c23e15 100644 --- a/tests/mir-opt/jump_threading.floats.JumpThreading.panic-abort.diff +++ b/tests/mir-opt/jump_threading.floats.JumpThreading.panic-abort.diff @@ -33,7 +33,7 @@ StorageDead(_2); StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; _3 = Eq(move _4, const 0f64); switchInt(move _3) -> [0: bb5, otherwise: bb4]; } diff --git a/tests/mir-opt/jump_threading.floats.JumpThreading.panic-unwind.diff b/tests/mir-opt/jump_threading.floats.JumpThreading.panic-unwind.diff index 6ca37e96d297..1192f7c23e15 100644 --- a/tests/mir-opt/jump_threading.floats.JumpThreading.panic-unwind.diff +++ b/tests/mir-opt/jump_threading.floats.JumpThreading.panic-unwind.diff @@ -33,7 +33,7 @@ StorageDead(_2); StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; _3 = Eq(move _4, const 0f64); switchInt(move _3) -> [0: bb5, otherwise: bb4]; } diff --git a/tests/mir-opt/jump_threading.identity.JumpThreading.panic-abort.diff b/tests/mir-opt/jump_threading.identity.JumpThreading.panic-abort.diff index 65379ae8b890..79599f856115 100644 --- a/tests/mir-opt/jump_threading.identity.JumpThreading.panic-abort.diff +++ b/tests/mir-opt/jump_threading.identity.JumpThreading.panic-abort.diff @@ -45,7 +45,7 @@ StorageLive(_2); StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; StorageLive(_10); StorageLive(_11); StorageLive(_12); @@ -59,8 +59,8 @@ bb2: { StorageLive(_9); - _9 = ((_3 as Continue).0: i32); - _2 = _9; + _9 = copy ((_3 as Continue).0: i32); + _2 = copy _9; StorageDead(_9); _0 = Result::::Ok(move _2); StorageDead(_2); @@ -70,9 +70,9 @@ bb3: { StorageLive(_6); - _6 = ((_3 as Break).0: std::result::Result); + _6 = copy ((_3 as Break).0: std::result::Result); StorageLive(_8); - _8 = _6; + _8 = copy _6; StorageLive(_14); _14 = move ((_8 as Err).0: i32); StorageLive(_15); @@ -104,7 +104,7 @@ bb6: { _12 = move ((_4 as Err).0: i32); StorageLive(_13); - _13 = Result::::Err(_12); + _13 = Result::::Err(copy _12); _3 = ControlFlow::, i32>::Break(move _13); StorageDead(_13); - goto -> bb5; @@ -113,7 +113,7 @@ bb7: { _11 = move ((_4 as Ok).0: i32); - _3 = ControlFlow::, i32>::Continue(_11); + _3 = ControlFlow::, i32>::Continue(copy _11); goto -> bb5; + } + diff --git a/tests/mir-opt/jump_threading.identity.JumpThreading.panic-unwind.diff b/tests/mir-opt/jump_threading.identity.JumpThreading.panic-unwind.diff index 65379ae8b890..79599f856115 100644 --- a/tests/mir-opt/jump_threading.identity.JumpThreading.panic-unwind.diff +++ b/tests/mir-opt/jump_threading.identity.JumpThreading.panic-unwind.diff @@ -45,7 +45,7 @@ StorageLive(_2); StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; StorageLive(_10); StorageLive(_11); StorageLive(_12); @@ -59,8 +59,8 @@ bb2: { StorageLive(_9); - _9 = ((_3 as Continue).0: i32); - _2 = _9; + _9 = copy ((_3 as Continue).0: i32); + _2 = copy _9; StorageDead(_9); _0 = Result::::Ok(move _2); StorageDead(_2); @@ -70,9 +70,9 @@ bb3: { StorageLive(_6); - _6 = ((_3 as Break).0: std::result::Result); + _6 = copy ((_3 as Break).0: std::result::Result); StorageLive(_8); - _8 = _6; + _8 = copy _6; StorageLive(_14); _14 = move ((_8 as Err).0: i32); StorageLive(_15); @@ -104,7 +104,7 @@ bb6: { _12 = move ((_4 as Err).0: i32); StorageLive(_13); - _13 = Result::::Err(_12); + _13 = Result::::Err(copy _12); _3 = ControlFlow::, i32>::Break(move _13); StorageDead(_13); - goto -> bb5; @@ -113,7 +113,7 @@ bb7: { _11 = move ((_4 as Ok).0: i32); - _3 = ControlFlow::, i32>::Continue(_11); + _3 = ControlFlow::, i32>::Continue(copy _11); goto -> bb5; + } + diff --git a/tests/mir-opt/jump_threading.multiple_match.JumpThreading.panic-abort.diff b/tests/mir-opt/jump_threading.multiple_match.JumpThreading.panic-abort.diff index 2ca03e439a0b..09c0ad6d4856 100644 --- a/tests/mir-opt/jump_threading.multiple_match.JumpThreading.panic-abort.diff +++ b/tests/mir-opt/jump_threading.multiple_match.JumpThreading.panic-abort.diff @@ -7,18 +7,18 @@ let mut _3: u8; bb0: { - switchInt(_1) -> [3: bb1, otherwise: bb2]; + switchInt(copy _1) -> [3: bb1, otherwise: bb2]; } bb1: { - _2 = _1; -- switchInt(_2) -> [3: bb3, otherwise: bb4]; + _2 = copy _1; +- switchInt(copy _2) -> [3: bb3, otherwise: bb4]; + goto -> bb3; } bb2: { - _3 = _1; -- switchInt(_3) -> [3: bb5, otherwise: bb6]; + _3 = copy _1; +- switchInt(copy _3) -> [3: bb5, otherwise: bb6]; + goto -> bb6; } @@ -38,7 +38,7 @@ } bb6: { - switchInt(_3) -> [1: bb7, otherwise: bb8]; + switchInt(copy _3) -> [1: bb7, otherwise: bb8]; } bb7: { diff --git a/tests/mir-opt/jump_threading.multiple_match.JumpThreading.panic-unwind.diff b/tests/mir-opt/jump_threading.multiple_match.JumpThreading.panic-unwind.diff index 2ca03e439a0b..09c0ad6d4856 100644 --- a/tests/mir-opt/jump_threading.multiple_match.JumpThreading.panic-unwind.diff +++ b/tests/mir-opt/jump_threading.multiple_match.JumpThreading.panic-unwind.diff @@ -7,18 +7,18 @@ let mut _3: u8; bb0: { - switchInt(_1) -> [3: bb1, otherwise: bb2]; + switchInt(copy _1) -> [3: bb1, otherwise: bb2]; } bb1: { - _2 = _1; -- switchInt(_2) -> [3: bb3, otherwise: bb4]; + _2 = copy _1; +- switchInt(copy _2) -> [3: bb3, otherwise: bb4]; + goto -> bb3; } bb2: { - _3 = _1; -- switchInt(_3) -> [3: bb5, otherwise: bb6]; + _3 = copy _1; +- switchInt(copy _3) -> [3: bb5, otherwise: bb6]; + goto -> bb6; } @@ -38,7 +38,7 @@ } bb6: { - switchInt(_3) -> [1: bb7, otherwise: bb8]; + switchInt(copy _3) -> [1: bb7, otherwise: bb8]; } bb7: { diff --git a/tests/mir-opt/jump_threading.mutable_ref.JumpThreading.panic-abort.diff b/tests/mir-opt/jump_threading.mutable_ref.JumpThreading.panic-abort.diff index e9d4352014f7..bb47f57b542a 100644 --- a/tests/mir-opt/jump_threading.mutable_ref.JumpThreading.panic-abort.diff +++ b/tests/mir-opt/jump_threading.mutable_ref.JumpThreading.panic-abort.diff @@ -27,7 +27,7 @@ StorageDead(_3); StorageLive(_4); StorageLive(_5); - _5 = _1; + _5 = copy _1; _4 = Eq(move _5, const 7_i32); switchInt(move _4) -> [0: bb2, otherwise: bb1]; } diff --git a/tests/mir-opt/jump_threading.mutable_ref.JumpThreading.panic-unwind.diff b/tests/mir-opt/jump_threading.mutable_ref.JumpThreading.panic-unwind.diff index e9d4352014f7..bb47f57b542a 100644 --- a/tests/mir-opt/jump_threading.mutable_ref.JumpThreading.panic-unwind.diff +++ b/tests/mir-opt/jump_threading.mutable_ref.JumpThreading.panic-unwind.diff @@ -27,7 +27,7 @@ StorageDead(_3); StorageLive(_4); StorageLive(_5); - _5 = _1; + _5 = copy _1; _4 = Eq(move _5, const 7_i32); switchInt(move _4) -> [0: bb2, otherwise: bb1]; } diff --git a/tests/mir-opt/jump_threading.mutate_discriminant.JumpThreading.panic-abort.diff b/tests/mir-opt/jump_threading.mutate_discriminant.JumpThreading.panic-abort.diff index 8821b47c3457..7014146cb862 100644 --- a/tests/mir-opt/jump_threading.mutate_discriminant.JumpThreading.panic-abort.diff +++ b/tests/mir-opt/jump_threading.mutate_discriminant.JumpThreading.panic-abort.diff @@ -10,7 +10,7 @@ discriminant(_1) = 1; (((_1 as variant#1).0: NonZeroUsize).0: usize) = const 0_usize; _2 = discriminant(_1); - switchInt(_2) -> [0: bb1, otherwise: bb2]; + switchInt(copy _2) -> [0: bb1, otherwise: bb2]; } bb1: { diff --git a/tests/mir-opt/jump_threading.mutate_discriminant.JumpThreading.panic-unwind.diff b/tests/mir-opt/jump_threading.mutate_discriminant.JumpThreading.panic-unwind.diff index 8821b47c3457..7014146cb862 100644 --- a/tests/mir-opt/jump_threading.mutate_discriminant.JumpThreading.panic-unwind.diff +++ b/tests/mir-opt/jump_threading.mutate_discriminant.JumpThreading.panic-unwind.diff @@ -10,7 +10,7 @@ discriminant(_1) = 1; (((_1 as variant#1).0: NonZeroUsize).0: usize) = const 0_usize; _2 = discriminant(_1); - switchInt(_2) -> [0: bb1, otherwise: bb2]; + switchInt(copy _2) -> [0: bb1, otherwise: bb2]; } bb1: { diff --git a/tests/mir-opt/jump_threading.renumbered_bb.JumpThreading.panic-abort.diff b/tests/mir-opt/jump_threading.renumbered_bb.JumpThreading.panic-abort.diff index 2d943a4bee21..9a8bdc8f4d95 100644 --- a/tests/mir-opt/jump_threading.renumbered_bb.JumpThreading.panic-abort.diff +++ b/tests/mir-opt/jump_threading.renumbered_bb.JumpThreading.panic-abort.diff @@ -8,7 +8,7 @@ bb0: { _3 = const false; - switchInt(_1) -> [1: bb1, otherwise: bb2]; + switchInt(copy _1) -> [1: bb1, otherwise: bb2]; } bb1: { @@ -18,17 +18,17 @@ } bb2: { - _2 = _1; - _3 = _1; + _2 = copy _1; + _3 = copy _1; goto -> bb3; } bb3: { - switchInt(_2) -> [0: bb4, otherwise: bb5]; + switchInt(copy _2) -> [0: bb4, otherwise: bb5]; } bb4: { - switchInt(_3) -> [0: bb6, otherwise: bb7]; + switchInt(copy _3) -> [0: bb6, otherwise: bb7]; } bb5: { diff --git a/tests/mir-opt/jump_threading.renumbered_bb.JumpThreading.panic-unwind.diff b/tests/mir-opt/jump_threading.renumbered_bb.JumpThreading.panic-unwind.diff index 2d943a4bee21..9a8bdc8f4d95 100644 --- a/tests/mir-opt/jump_threading.renumbered_bb.JumpThreading.panic-unwind.diff +++ b/tests/mir-opt/jump_threading.renumbered_bb.JumpThreading.panic-unwind.diff @@ -8,7 +8,7 @@ bb0: { _3 = const false; - switchInt(_1) -> [1: bb1, otherwise: bb2]; + switchInt(copy _1) -> [1: bb1, otherwise: bb2]; } bb1: { @@ -18,17 +18,17 @@ } bb2: { - _2 = _1; - _3 = _1; + _2 = copy _1; + _3 = copy _1; goto -> bb3; } bb3: { - switchInt(_2) -> [0: bb4, otherwise: bb5]; + switchInt(copy _2) -> [0: bb4, otherwise: bb5]; } bb4: { - switchInt(_3) -> [0: bb6, otherwise: bb7]; + switchInt(copy _3) -> [0: bb6, otherwise: bb7]; } bb5: { diff --git a/tests/mir-opt/jump_threading.too_complex.JumpThreading.panic-abort.diff b/tests/mir-opt/jump_threading.too_complex.JumpThreading.panic-abort.diff index 365d9d6b32bd..7de359298922 100644 --- a/tests/mir-opt/jump_threading.too_complex.JumpThreading.panic-abort.diff +++ b/tests/mir-opt/jump_threading.too_complex.JumpThreading.panic-abort.diff @@ -39,9 +39,9 @@ bb2: { StorageLive(_6); - _6 = ((_1 as Err).0: usize); + _6 = copy ((_1 as Err).0: usize); StorageLive(_7); - _7 = _6; + _7 = copy _6; _2 = ControlFlow::::Break(move _7); StorageDead(_7); StorageDead(_6); @@ -51,9 +51,9 @@ bb3: { StorageLive(_4); - _4 = ((_1 as Ok).0: i32); + _4 = copy ((_1 as Ok).0: i32); StorageLive(_5); - _5 = _4; + _5 = copy _4; _2 = ControlFlow::::Continue(move _5); StorageDead(_5); StorageDead(_4); @@ -68,7 +68,7 @@ bb5: { StorageLive(_11); - _11 = ((_2 as Break).0: usize); + _11 = copy ((_2 as Break).0: usize); _0 = Option::::None; StorageDead(_11); goto -> bb7; @@ -76,9 +76,9 @@ bb6: { StorageLive(_9); - _9 = ((_2 as Continue).0: i32); + _9 = copy ((_2 as Continue).0: i32); StorageLive(_10); - _10 = _9; + _10 = copy _9; _0 = Option::::Some(move _10); StorageDead(_10); StorageDead(_9); diff --git a/tests/mir-opt/jump_threading.too_complex.JumpThreading.panic-unwind.diff b/tests/mir-opt/jump_threading.too_complex.JumpThreading.panic-unwind.diff index 365d9d6b32bd..7de359298922 100644 --- a/tests/mir-opt/jump_threading.too_complex.JumpThreading.panic-unwind.diff +++ b/tests/mir-opt/jump_threading.too_complex.JumpThreading.panic-unwind.diff @@ -39,9 +39,9 @@ bb2: { StorageLive(_6); - _6 = ((_1 as Err).0: usize); + _6 = copy ((_1 as Err).0: usize); StorageLive(_7); - _7 = _6; + _7 = copy _6; _2 = ControlFlow::::Break(move _7); StorageDead(_7); StorageDead(_6); @@ -51,9 +51,9 @@ bb3: { StorageLive(_4); - _4 = ((_1 as Ok).0: i32); + _4 = copy ((_1 as Ok).0: i32); StorageLive(_5); - _5 = _4; + _5 = copy _4; _2 = ControlFlow::::Continue(move _5); StorageDead(_5); StorageDead(_4); @@ -68,7 +68,7 @@ bb5: { StorageLive(_11); - _11 = ((_2 as Break).0: usize); + _11 = copy ((_2 as Break).0: usize); _0 = Option::::None; StorageDead(_11); goto -> bb7; @@ -76,9 +76,9 @@ bb6: { StorageLive(_9); - _9 = ((_2 as Continue).0: i32); + _9 = copy ((_2 as Continue).0: i32); StorageLive(_10); - _10 = _9; + _10 = copy _9; _0 = Option::::Some(move _10); StorageDead(_10); StorageDead(_9); diff --git a/tests/mir-opt/lower_array_len.array_bound.GVN.panic-abort.diff b/tests/mir-opt/lower_array_len.array_bound.GVN.panic-abort.diff index 7aca2cb00070..8223cbbb4121 100644 --- a/tests/mir-opt/lower_array_len.array_bound.GVN.panic-abort.diff +++ b/tests/mir-opt/lower_array_len.array_bound.GVN.panic-abort.diff @@ -18,7 +18,7 @@ - StorageLive(_3); + nop; StorageLive(_4); - _4 = _1; + _4 = copy _1; - StorageLive(_5); + nop; StorageLive(_6); @@ -35,8 +35,8 @@ StorageDead(_6); - _3 = Lt(move _4, move _5); - switchInt(move _3) -> [0: bb4, otherwise: bb2]; -+ _3 = Lt(_1, const N); -+ switchInt(_3) -> [0: bb4, otherwise: bb2]; ++ _3 = Lt(copy _1, const N); ++ switchInt(copy _3) -> [0: bb4, otherwise: bb2]; } bb2: { @@ -44,18 +44,18 @@ + nop; StorageDead(_4); StorageLive(_8); - _8 = _1; + _8 = copy _1; - _9 = Len((*_2)); -- _10 = Lt(_8, _9); -- assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, _8) -> [success: bb3, unwind unreachable]; +- _10 = Lt(copy _8, copy _9); +- assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, copy _8) -> [success: bb3, unwind unreachable]; + _9 = const N; -+ _10 = _3; -+ assert(_3, "index out of bounds: the length is {} but the index is {}", const N, _1) -> [success: bb3, unwind unreachable]; ++ _10 = copy _3; ++ assert(copy _3, "index out of bounds: the length is {} but the index is {}", const N, copy _1) -> [success: bb3, unwind unreachable]; } bb3: { -- _0 = (*_2)[_8]; -+ _0 = (*_2)[_1]; +- _0 = copy (*_2)[_8]; ++ _0 = copy (*_2)[_1]; StorageDead(_8); goto -> bb5; } diff --git a/tests/mir-opt/lower_array_len.array_bound.GVN.panic-unwind.diff b/tests/mir-opt/lower_array_len.array_bound.GVN.panic-unwind.diff index ed39c11319af..d8f33accbc00 100644 --- a/tests/mir-opt/lower_array_len.array_bound.GVN.panic-unwind.diff +++ b/tests/mir-opt/lower_array_len.array_bound.GVN.panic-unwind.diff @@ -18,7 +18,7 @@ - StorageLive(_3); + nop; StorageLive(_4); - _4 = _1; + _4 = copy _1; - StorageLive(_5); + nop; StorageLive(_6); @@ -35,8 +35,8 @@ StorageDead(_6); - _3 = Lt(move _4, move _5); - switchInt(move _3) -> [0: bb4, otherwise: bb2]; -+ _3 = Lt(_1, const N); -+ switchInt(_3) -> [0: bb4, otherwise: bb2]; ++ _3 = Lt(copy _1, const N); ++ switchInt(copy _3) -> [0: bb4, otherwise: bb2]; } bb2: { @@ -44,18 +44,18 @@ + nop; StorageDead(_4); StorageLive(_8); - _8 = _1; + _8 = copy _1; - _9 = Len((*_2)); -- _10 = Lt(_8, _9); -- assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, _8) -> [success: bb3, unwind continue]; +- _10 = Lt(copy _8, copy _9); +- assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, copy _8) -> [success: bb3, unwind continue]; + _9 = const N; -+ _10 = _3; -+ assert(_3, "index out of bounds: the length is {} but the index is {}", const N, _1) -> [success: bb3, unwind continue]; ++ _10 = copy _3; ++ assert(copy _3, "index out of bounds: the length is {} but the index is {}", const N, copy _1) -> [success: bb3, unwind continue]; } bb3: { -- _0 = (*_2)[_8]; -+ _0 = (*_2)[_1]; +- _0 = copy (*_2)[_8]; ++ _0 = copy (*_2)[_1]; StorageDead(_8); goto -> bb5; } diff --git a/tests/mir-opt/lower_array_len.array_bound_mut.GVN.panic-abort.diff b/tests/mir-opt/lower_array_len.array_bound_mut.GVN.panic-abort.diff index 734d28e9546c..1cb9963c00e9 100644 --- a/tests/mir-opt/lower_array_len.array_bound_mut.GVN.panic-abort.diff +++ b/tests/mir-opt/lower_array_len.array_bound_mut.GVN.panic-abort.diff @@ -21,7 +21,7 @@ - StorageLive(_3); + nop; StorageLive(_4); - _4 = _1; + _4 = copy _1; - StorageLive(_5); + nop; StorageLive(_6); @@ -38,8 +38,8 @@ StorageDead(_6); - _3 = Lt(move _4, move _5); - switchInt(move _3) -> [0: bb4, otherwise: bb2]; -+ _3 = Lt(_1, const N); -+ switchInt(_3) -> [0: bb4, otherwise: bb2]; ++ _3 = Lt(copy _1, const N); ++ switchInt(copy _3) -> [0: bb4, otherwise: bb2]; } bb2: { @@ -47,18 +47,18 @@ + nop; StorageDead(_4); StorageLive(_8); - _8 = _1; + _8 = copy _1; - _9 = Len((*_2)); -- _10 = Lt(_8, _9); -- assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, _8) -> [success: bb3, unwind unreachable]; +- _10 = Lt(copy _8, copy _9); +- assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, copy _8) -> [success: bb3, unwind unreachable]; + _9 = const N; -+ _10 = _3; -+ assert(_3, "index out of bounds: the length is {} but the index is {}", const N, _1) -> [success: bb3, unwind unreachable]; ++ _10 = copy _3; ++ assert(copy _3, "index out of bounds: the length is {} but the index is {}", const N, copy _1) -> [success: bb3, unwind unreachable]; } bb3: { -- _0 = (*_2)[_8]; -+ _0 = (*_2)[_1]; +- _0 = copy (*_2)[_8]; ++ _0 = copy (*_2)[_1]; StorageDead(_8); goto -> bb6; } @@ -70,8 +70,8 @@ StorageLive(_11); _11 = const 0_usize; - _12 = Len((*_2)); -- _13 = Lt(_11, _12); -- assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, _11) -> [success: bb5, unwind unreachable]; +- _13 = Lt(copy _11, copy _12); +- assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, copy _11) -> [success: bb5, unwind unreachable]; + _12 = const N; + _13 = Lt(const 0_usize, const N); + assert(move _13, "index out of bounds: the length is {} but the index is {}", const N, const 0_usize) -> [success: bb5, unwind unreachable]; diff --git a/tests/mir-opt/lower_array_len.array_bound_mut.GVN.panic-unwind.diff b/tests/mir-opt/lower_array_len.array_bound_mut.GVN.panic-unwind.diff index ec569ab50423..fa4e11ed2019 100644 --- a/tests/mir-opt/lower_array_len.array_bound_mut.GVN.panic-unwind.diff +++ b/tests/mir-opt/lower_array_len.array_bound_mut.GVN.panic-unwind.diff @@ -21,7 +21,7 @@ - StorageLive(_3); + nop; StorageLive(_4); - _4 = _1; + _4 = copy _1; - StorageLive(_5); + nop; StorageLive(_6); @@ -38,8 +38,8 @@ StorageDead(_6); - _3 = Lt(move _4, move _5); - switchInt(move _3) -> [0: bb4, otherwise: bb2]; -+ _3 = Lt(_1, const N); -+ switchInt(_3) -> [0: bb4, otherwise: bb2]; ++ _3 = Lt(copy _1, const N); ++ switchInt(copy _3) -> [0: bb4, otherwise: bb2]; } bb2: { @@ -47,18 +47,18 @@ + nop; StorageDead(_4); StorageLive(_8); - _8 = _1; + _8 = copy _1; - _9 = Len((*_2)); -- _10 = Lt(_8, _9); -- assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, _8) -> [success: bb3, unwind continue]; +- _10 = Lt(copy _8, copy _9); +- assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, copy _8) -> [success: bb3, unwind continue]; + _9 = const N; -+ _10 = _3; -+ assert(_3, "index out of bounds: the length is {} but the index is {}", const N, _1) -> [success: bb3, unwind continue]; ++ _10 = copy _3; ++ assert(copy _3, "index out of bounds: the length is {} but the index is {}", const N, copy _1) -> [success: bb3, unwind continue]; } bb3: { -- _0 = (*_2)[_8]; -+ _0 = (*_2)[_1]; +- _0 = copy (*_2)[_8]; ++ _0 = copy (*_2)[_1]; StorageDead(_8); goto -> bb6; } @@ -70,8 +70,8 @@ StorageLive(_11); _11 = const 0_usize; - _12 = Len((*_2)); -- _13 = Lt(_11, _12); -- assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, _11) -> [success: bb5, unwind continue]; +- _13 = Lt(copy _11, copy _12); +- assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, copy _11) -> [success: bb5, unwind continue]; + _12 = const N; + _13 = Lt(const 0_usize, const N); + assert(move _13, "index out of bounds: the length is {} but the index is {}", const N, const 0_usize) -> [success: bb5, unwind continue]; diff --git a/tests/mir-opt/lower_intrinsics.f_copy_nonoverlapping.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.f_copy_nonoverlapping.LowerIntrinsics.panic-abort.diff index 96b66af66a2d..7f325245bce6 100644 --- a/tests/mir-opt/lower_intrinsics.f_copy_nonoverlapping.LowerIntrinsics.panic-abort.diff +++ b/tests/mir-opt/lower_intrinsics.f_copy_nonoverlapping.LowerIntrinsics.panic-abort.diff @@ -33,7 +33,7 @@ StorageLive(_7); _7 = &_1; _6 = &raw const (*_7); - _5 = _6; + _5 = copy _6; _4 = move _5 as *const i32 (PtrToPtr); StorageDead(_5); StorageLive(_8); @@ -42,7 +42,7 @@ StorageLive(_11); _11 = &mut _2; _10 = &raw mut (*_11); - _9 = _10; + _9 = copy _10; _8 = move _9 as *mut i32 (PtrToPtr); StorageDead(_9); - _3 = copy_nonoverlapping::(move _4, move _8, const 0_usize) -> [return: bb1, unwind unreachable]; diff --git a/tests/mir-opt/lower_intrinsics.f_copy_nonoverlapping.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.f_copy_nonoverlapping.LowerIntrinsics.panic-unwind.diff index 96b66af66a2d..7f325245bce6 100644 --- a/tests/mir-opt/lower_intrinsics.f_copy_nonoverlapping.LowerIntrinsics.panic-unwind.diff +++ b/tests/mir-opt/lower_intrinsics.f_copy_nonoverlapping.LowerIntrinsics.panic-unwind.diff @@ -33,7 +33,7 @@ StorageLive(_7); _7 = &_1; _6 = &raw const (*_7); - _5 = _6; + _5 = copy _6; _4 = move _5 as *const i32 (PtrToPtr); StorageDead(_5); StorageLive(_8); @@ -42,7 +42,7 @@ StorageLive(_11); _11 = &mut _2; _10 = &raw mut (*_11); - _9 = _10; + _9 = copy _10; _8 = move _9 as *mut i32 (PtrToPtr); StorageDead(_9); - _3 = copy_nonoverlapping::(move _4, move _8, const 0_usize) -> [return: bb1, unwind unreachable]; diff --git a/tests/mir-opt/lower_intrinsics.get_metadata.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.get_metadata.LowerIntrinsics.panic-abort.diff index d256058c05ee..f2cfce1b6e3f 100644 --- a/tests/mir-opt/lower_intrinsics.get_metadata.LowerIntrinsics.panic-abort.diff +++ b/tests/mir-opt/lower_intrinsics.get_metadata.LowerIntrinsics.panic-abort.diff @@ -25,7 +25,7 @@ bb0: { StorageLive(_4); StorageLive(_5); - _5 = _1; + _5 = copy _1; - _4 = ptr_metadata::(move _5) -> [return: bb1, unwind unreachable]; + _4 = PtrMetadata(move _5); + goto -> bb1; @@ -35,7 +35,7 @@ StorageDead(_5); StorageLive(_6); StorageLive(_7); - _7 = _2; + _7 = copy _2; - _6 = ptr_metadata::<[u8], usize>(move _7) -> [return: bb2, unwind unreachable]; + _6 = PtrMetadata(move _7); + goto -> bb2; @@ -45,7 +45,7 @@ StorageDead(_7); StorageLive(_8); StorageLive(_9); - _9 = _3; + _9 = copy _3; - _8 = ptr_metadata::>(move _9) -> [return: bb3, unwind unreachable]; + _8 = PtrMetadata(move _9); + goto -> bb3; diff --git a/tests/mir-opt/lower_intrinsics.get_metadata.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.get_metadata.LowerIntrinsics.panic-unwind.diff index d256058c05ee..f2cfce1b6e3f 100644 --- a/tests/mir-opt/lower_intrinsics.get_metadata.LowerIntrinsics.panic-unwind.diff +++ b/tests/mir-opt/lower_intrinsics.get_metadata.LowerIntrinsics.panic-unwind.diff @@ -25,7 +25,7 @@ bb0: { StorageLive(_4); StorageLive(_5); - _5 = _1; + _5 = copy _1; - _4 = ptr_metadata::(move _5) -> [return: bb1, unwind unreachable]; + _4 = PtrMetadata(move _5); + goto -> bb1; @@ -35,7 +35,7 @@ StorageDead(_5); StorageLive(_6); StorageLive(_7); - _7 = _2; + _7 = copy _2; - _6 = ptr_metadata::<[u8], usize>(move _7) -> [return: bb2, unwind unreachable]; + _6 = PtrMetadata(move _7); + goto -> bb2; @@ -45,7 +45,7 @@ StorageDead(_7); StorageLive(_8); StorageLive(_9); - _9 = _3; + _9 = copy _3; - _8 = ptr_metadata::>(move _9) -> [return: bb3, unwind unreachable]; + _8 = PtrMetadata(move _9); + goto -> bb3; diff --git a/tests/mir-opt/lower_intrinsics.make_pointers.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.make_pointers.LowerIntrinsics.panic-abort.diff index 02934d4c01e6..b282509c0686 100644 --- a/tests/mir-opt/lower_intrinsics.make_pointers.LowerIntrinsics.panic-abort.diff +++ b/tests/mir-opt/lower_intrinsics.make_pointers.LowerIntrinsics.panic-abort.diff @@ -34,7 +34,7 @@ bb0: { StorageLive(_4); StorageLive(_5); - _5 = _1; + _5 = copy _1; StorageLive(_6); _6 = (); - _4 = aggregate_raw_ptr::<*const i32, *const u8, ()>(move _5, move _6) -> [return: bb1, unwind unreachable]; @@ -47,7 +47,7 @@ StorageDead(_5); StorageLive(_7); StorageLive(_8); - _8 = _2; + _8 = copy _2; StorageLive(_9); _9 = (); - _7 = aggregate_raw_ptr::<*mut u8, *mut (), ()>(move _8, move _9) -> [return: bb2, unwind unreachable]; @@ -60,9 +60,9 @@ StorageDead(_8); StorageLive(_10); StorageLive(_11); - _11 = _1; + _11 = copy _1; StorageLive(_12); - _12 = _3; + _12 = copy _3; - _10 = aggregate_raw_ptr::<*const [u16], *const u8, usize>(move _11, move _12) -> [return: bb3, unwind unreachable]; + _10 = *const [u16] from (move _11, move _12); + goto -> bb3; @@ -73,9 +73,9 @@ StorageDead(_11); StorageLive(_13); StorageLive(_14); - _14 = _2; + _14 = copy _2; StorageLive(_15); - _15 = _3; + _15 = copy _3; - _13 = aggregate_raw_ptr::<*mut [u64], *mut (), usize>(move _14, move _15) -> [return: bb4, unwind unreachable]; + _13 = *mut [u64] from (move _14, move _15); + goto -> bb4; diff --git a/tests/mir-opt/lower_intrinsics.make_pointers.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.make_pointers.LowerIntrinsics.panic-unwind.diff index 02934d4c01e6..b282509c0686 100644 --- a/tests/mir-opt/lower_intrinsics.make_pointers.LowerIntrinsics.panic-unwind.diff +++ b/tests/mir-opt/lower_intrinsics.make_pointers.LowerIntrinsics.panic-unwind.diff @@ -34,7 +34,7 @@ bb0: { StorageLive(_4); StorageLive(_5); - _5 = _1; + _5 = copy _1; StorageLive(_6); _6 = (); - _4 = aggregate_raw_ptr::<*const i32, *const u8, ()>(move _5, move _6) -> [return: bb1, unwind unreachable]; @@ -47,7 +47,7 @@ StorageDead(_5); StorageLive(_7); StorageLive(_8); - _8 = _2; + _8 = copy _2; StorageLive(_9); _9 = (); - _7 = aggregate_raw_ptr::<*mut u8, *mut (), ()>(move _8, move _9) -> [return: bb2, unwind unreachable]; @@ -60,9 +60,9 @@ StorageDead(_8); StorageLive(_10); StorageLive(_11); - _11 = _1; + _11 = copy _1; StorageLive(_12); - _12 = _3; + _12 = copy _3; - _10 = aggregate_raw_ptr::<*const [u16], *const u8, usize>(move _11, move _12) -> [return: bb3, unwind unreachable]; + _10 = *const [u16] from (move _11, move _12); + goto -> bb3; @@ -73,9 +73,9 @@ StorageDead(_11); StorageLive(_13); StorageLive(_14); - _14 = _2; + _14 = copy _2; StorageLive(_15); - _15 = _3; + _15 = copy _3; - _13 = aggregate_raw_ptr::<*mut [u64], *mut (), usize>(move _14, move _15) -> [return: bb4, unwind unreachable]; + _13 = *mut [u64] from (move _14, move _15); + goto -> bb4; diff --git a/tests/mir-opt/lower_intrinsics.non_const.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.non_const.LowerIntrinsics.panic-abort.diff index 069a82b95215..5aa986984768 100644 --- a/tests/mir-opt/lower_intrinsics.non_const.LowerIntrinsics.panic-abort.diff +++ b/tests/mir-opt/lower_intrinsics.non_const.LowerIntrinsics.panic-abort.diff @@ -13,7 +13,7 @@ StorageLive(_1); _1 = std::intrinsics::size_of::; StorageLive(_2); - _2 = _1; + _2 = copy _1; - _0 = move _2() -> [return: bb1, unwind unreachable]; + _0 = SizeOf(T); + goto -> bb1; diff --git a/tests/mir-opt/lower_intrinsics.non_const.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.non_const.LowerIntrinsics.panic-unwind.diff index 069a82b95215..5aa986984768 100644 --- a/tests/mir-opt/lower_intrinsics.non_const.LowerIntrinsics.panic-unwind.diff +++ b/tests/mir-opt/lower_intrinsics.non_const.LowerIntrinsics.panic-unwind.diff @@ -13,7 +13,7 @@ StorageLive(_1); _1 = std::intrinsics::size_of::; StorageLive(_2); - _2 = _1; + _2 = copy _1; - _0 = move _2() -> [return: bb1, unwind unreachable]; + _0 = SizeOf(T); + goto -> bb1; diff --git a/tests/mir-opt/lower_intrinsics.ptr_offset.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.ptr_offset.LowerIntrinsics.panic-abort.diff index 4f7ad0b6094f..62cce84f6956 100644 --- a/tests/mir-opt/lower_intrinsics.ptr_offset.LowerIntrinsics.panic-abort.diff +++ b/tests/mir-opt/lower_intrinsics.ptr_offset.LowerIntrinsics.panic-abort.diff @@ -10,9 +10,9 @@ bb0: { StorageLive(_3); - _3 = _1; + _3 = copy _1; StorageLive(_4); - _4 = _2; + _4 = copy _2; - _0 = offset::<*const i32, isize>(move _3, move _4) -> [return: bb1, unwind unreachable]; + _0 = Offset(move _3, move _4); + goto -> bb1; diff --git a/tests/mir-opt/lower_intrinsics.ptr_offset.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.ptr_offset.LowerIntrinsics.panic-unwind.diff index 4f7ad0b6094f..62cce84f6956 100644 --- a/tests/mir-opt/lower_intrinsics.ptr_offset.LowerIntrinsics.panic-unwind.diff +++ b/tests/mir-opt/lower_intrinsics.ptr_offset.LowerIntrinsics.panic-unwind.diff @@ -10,9 +10,9 @@ bb0: { StorageLive(_3); - _3 = _1; + _3 = copy _1; StorageLive(_4); - _4 = _2; + _4 = copy _2; - _0 = offset::<*const i32, isize>(move _3, move _4) -> [return: bb1, unwind unreachable]; + _0 = Offset(move _3, move _4); + goto -> bb1; diff --git a/tests/mir-opt/lower_intrinsics.read_via_copy_primitive.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.read_via_copy_primitive.LowerIntrinsics.panic-abort.diff index 781104be290a..95717d03b61f 100644 --- a/tests/mir-opt/lower_intrinsics.read_via_copy_primitive.LowerIntrinsics.panic-abort.diff +++ b/tests/mir-opt/lower_intrinsics.read_via_copy_primitive.LowerIntrinsics.panic-abort.diff @@ -10,7 +10,7 @@ StorageLive(_2); _2 = &raw const (*_1); - _0 = read_via_copy::(move _2) -> [return: bb1, unwind unreachable]; -+ _0 = (*_2); ++ _0 = copy (*_2); + goto -> bb1; } diff --git a/tests/mir-opt/lower_intrinsics.read_via_copy_primitive.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.read_via_copy_primitive.LowerIntrinsics.panic-unwind.diff index 781104be290a..95717d03b61f 100644 --- a/tests/mir-opt/lower_intrinsics.read_via_copy_primitive.LowerIntrinsics.panic-unwind.diff +++ b/tests/mir-opt/lower_intrinsics.read_via_copy_primitive.LowerIntrinsics.panic-unwind.diff @@ -10,7 +10,7 @@ StorageLive(_2); _2 = &raw const (*_1); - _0 = read_via_copy::(move _2) -> [return: bb1, unwind unreachable]; -+ _0 = (*_2); ++ _0 = copy (*_2); + goto -> bb1; } diff --git a/tests/mir-opt/lower_intrinsics.read_via_copy_uninhabited.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.read_via_copy_uninhabited.LowerIntrinsics.panic-abort.diff index 56c357b3776d..8828549249e5 100644 --- a/tests/mir-opt/lower_intrinsics.read_via_copy_uninhabited.LowerIntrinsics.panic-abort.diff +++ b/tests/mir-opt/lower_intrinsics.read_via_copy_uninhabited.LowerIntrinsics.panic-abort.diff @@ -10,7 +10,7 @@ StorageLive(_2); _2 = &raw const (*_1); - _0 = read_via_copy::(move _2) -> unwind unreachable; -+ _0 = (*_2); ++ _0 = copy (*_2); + unreachable; } } diff --git a/tests/mir-opt/lower_intrinsics.read_via_copy_uninhabited.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.read_via_copy_uninhabited.LowerIntrinsics.panic-unwind.diff index 56c357b3776d..8828549249e5 100644 --- a/tests/mir-opt/lower_intrinsics.read_via_copy_uninhabited.LowerIntrinsics.panic-unwind.diff +++ b/tests/mir-opt/lower_intrinsics.read_via_copy_uninhabited.LowerIntrinsics.panic-unwind.diff @@ -10,7 +10,7 @@ StorageLive(_2); _2 = &raw const (*_1); - _0 = read_via_copy::(move _2) -> unwind unreachable; -+ _0 = (*_2); ++ _0 = copy (*_2); + unreachable; } } diff --git a/tests/mir-opt/lower_intrinsics.three_way_compare_char.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.three_way_compare_char.LowerIntrinsics.panic-abort.diff index 816d62097158..f29bc5dfc6e4 100644 --- a/tests/mir-opt/lower_intrinsics.three_way_compare_char.LowerIntrinsics.panic-abort.diff +++ b/tests/mir-opt/lower_intrinsics.three_way_compare_char.LowerIntrinsics.panic-abort.diff @@ -15,9 +15,9 @@ bb0: { StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; StorageLive(_5); - _5 = _2; + _5 = copy _2; - _3 = three_way_compare::(move _4, move _5) -> [return: bb1, unwind unreachable]; + _3 = Cmp(move _4, move _5); + goto -> bb1; diff --git a/tests/mir-opt/lower_intrinsics.three_way_compare_char.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.three_way_compare_char.LowerIntrinsics.panic-unwind.diff index 80b4bd7a2be7..596ad70b3bfa 100644 --- a/tests/mir-opt/lower_intrinsics.three_way_compare_char.LowerIntrinsics.panic-unwind.diff +++ b/tests/mir-opt/lower_intrinsics.three_way_compare_char.LowerIntrinsics.panic-unwind.diff @@ -15,9 +15,9 @@ bb0: { StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; StorageLive(_5); - _5 = _2; + _5 = copy _2; - _3 = three_way_compare::(move _4, move _5) -> [return: bb1, unwind continue]; + _3 = Cmp(move _4, move _5); + goto -> bb1; diff --git a/tests/mir-opt/lower_intrinsics.three_way_compare_signed.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.three_way_compare_signed.LowerIntrinsics.panic-abort.diff index 05c20aaa09a2..654cb2503df5 100644 --- a/tests/mir-opt/lower_intrinsics.three_way_compare_signed.LowerIntrinsics.panic-abort.diff +++ b/tests/mir-opt/lower_intrinsics.three_way_compare_signed.LowerIntrinsics.panic-abort.diff @@ -12,9 +12,9 @@ bb0: { StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; StorageLive(_5); - _5 = _2; + _5 = copy _2; - _3 = three_way_compare::(move _4, move _5) -> [return: bb1, unwind unreachable]; + _3 = Cmp(move _4, move _5); + goto -> bb1; diff --git a/tests/mir-opt/lower_intrinsics.three_way_compare_signed.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.three_way_compare_signed.LowerIntrinsics.panic-unwind.diff index 8a254d02a47b..987c21666927 100644 --- a/tests/mir-opt/lower_intrinsics.three_way_compare_signed.LowerIntrinsics.panic-unwind.diff +++ b/tests/mir-opt/lower_intrinsics.three_way_compare_signed.LowerIntrinsics.panic-unwind.diff @@ -12,9 +12,9 @@ bb0: { StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; StorageLive(_5); - _5 = _2; + _5 = copy _2; - _3 = three_way_compare::(move _4, move _5) -> [return: bb1, unwind continue]; + _3 = Cmp(move _4, move _5); + goto -> bb1; diff --git a/tests/mir-opt/lower_intrinsics.three_way_compare_unsigned.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.three_way_compare_unsigned.LowerIntrinsics.panic-abort.diff index 437614ec6738..82c89b7ce549 100644 --- a/tests/mir-opt/lower_intrinsics.three_way_compare_unsigned.LowerIntrinsics.panic-abort.diff +++ b/tests/mir-opt/lower_intrinsics.three_way_compare_unsigned.LowerIntrinsics.panic-abort.diff @@ -15,9 +15,9 @@ bb0: { StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; StorageLive(_5); - _5 = _2; + _5 = copy _2; - _3 = three_way_compare::(move _4, move _5) -> [return: bb1, unwind unreachable]; + _3 = Cmp(move _4, move _5); + goto -> bb1; diff --git a/tests/mir-opt/lower_intrinsics.three_way_compare_unsigned.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.three_way_compare_unsigned.LowerIntrinsics.panic-unwind.diff index 7d6137979c81..d7ec6dcfa2c3 100644 --- a/tests/mir-opt/lower_intrinsics.three_way_compare_unsigned.LowerIntrinsics.panic-unwind.diff +++ b/tests/mir-opt/lower_intrinsics.three_way_compare_unsigned.LowerIntrinsics.panic-unwind.diff @@ -15,9 +15,9 @@ bb0: { StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; StorageLive(_5); - _5 = _2; + _5 = copy _2; - _3 = three_way_compare::(move _4, move _5) -> [return: bb1, unwind continue]; + _3 = Cmp(move _4, move _5); + goto -> bb1; diff --git a/tests/mir-opt/lower_intrinsics.transmute_inhabited.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.transmute_inhabited.LowerIntrinsics.panic-abort.diff index 6e542c4b5a7b..71e84fdd8816 100644 --- a/tests/mir-opt/lower_intrinsics.transmute_inhabited.LowerIntrinsics.panic-abort.diff +++ b/tests/mir-opt/lower_intrinsics.transmute_inhabited.LowerIntrinsics.panic-abort.diff @@ -8,7 +8,7 @@ bb0: { StorageLive(_2); - _2 = _1; + _2 = copy _1; - _0 = transmute::(move _2) -> [return: bb1, unwind unreachable]; + _0 = move _2 as i8 (Transmute); + goto -> bb1; diff --git a/tests/mir-opt/lower_intrinsics.transmute_inhabited.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.transmute_inhabited.LowerIntrinsics.panic-unwind.diff index 6e542c4b5a7b..71e84fdd8816 100644 --- a/tests/mir-opt/lower_intrinsics.transmute_inhabited.LowerIntrinsics.panic-unwind.diff +++ b/tests/mir-opt/lower_intrinsics.transmute_inhabited.LowerIntrinsics.panic-unwind.diff @@ -8,7 +8,7 @@ bb0: { StorageLive(_2); - _2 = _1; + _2 = copy _1; - _0 = transmute::(move _2) -> [return: bb1, unwind unreachable]; + _0 = move _2 as i8 (Transmute); + goto -> bb1; diff --git a/tests/mir-opt/lower_intrinsics.transmute_ref_dst.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.transmute_ref_dst.LowerIntrinsics.panic-abort.diff index ab4646370f16..37232b826c12 100644 --- a/tests/mir-opt/lower_intrinsics.transmute_ref_dst.LowerIntrinsics.panic-abort.diff +++ b/tests/mir-opt/lower_intrinsics.transmute_ref_dst.LowerIntrinsics.panic-abort.diff @@ -8,7 +8,7 @@ bb0: { StorageLive(_2); - _2 = _1; + _2 = copy _1; - _0 = transmute::<&T, *const T>(move _2) -> [return: bb1, unwind unreachable]; + _0 = move _2 as *const T (Transmute); + goto -> bb1; diff --git a/tests/mir-opt/lower_intrinsics.transmute_ref_dst.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.transmute_ref_dst.LowerIntrinsics.panic-unwind.diff index ab4646370f16..37232b826c12 100644 --- a/tests/mir-opt/lower_intrinsics.transmute_ref_dst.LowerIntrinsics.panic-unwind.diff +++ b/tests/mir-opt/lower_intrinsics.transmute_ref_dst.LowerIntrinsics.panic-unwind.diff @@ -8,7 +8,7 @@ bb0: { StorageLive(_2); - _2 = _1; + _2 = copy _1; - _0 = transmute::<&T, *const T>(move _2) -> [return: bb1, unwind unreachable]; + _0 = move _2 as *const T (Transmute); + goto -> bb1; diff --git a/tests/mir-opt/lower_intrinsics.transmute_to_box_uninhabited.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.transmute_to_box_uninhabited.LowerIntrinsics.panic-abort.diff index c4a3358ffa3a..8ac70f99ad2f 100644 --- a/tests/mir-opt/lower_intrinsics.transmute_to_box_uninhabited.LowerIntrinsics.panic-abort.diff +++ b/tests/mir-opt/lower_intrinsics.transmute_to_box_uninhabited.LowerIntrinsics.panic-abort.diff @@ -17,7 +17,7 @@ } bb1: { - _2 = (((_1.0: std::ptr::Unique).0: std::ptr::NonNull).0: *const Never); + _2 = copy (((_1.0: std::ptr::Unique).0: std::ptr::NonNull).0: *const Never); PlaceMention((*_2)); unreachable; } diff --git a/tests/mir-opt/lower_intrinsics.transmute_to_box_uninhabited.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.transmute_to_box_uninhabited.LowerIntrinsics.panic-unwind.diff index c4a3358ffa3a..8ac70f99ad2f 100644 --- a/tests/mir-opt/lower_intrinsics.transmute_to_box_uninhabited.LowerIntrinsics.panic-unwind.diff +++ b/tests/mir-opt/lower_intrinsics.transmute_to_box_uninhabited.LowerIntrinsics.panic-unwind.diff @@ -17,7 +17,7 @@ } bb1: { - _2 = (((_1.0: std::ptr::Unique).0: std::ptr::NonNull).0: *const Never); + _2 = copy (((_1.0: std::ptr::Unique).0: std::ptr::NonNull).0: *const Never); PlaceMention((*_2)); unreachable; } diff --git a/tests/mir-opt/lower_intrinsics.transmute_uninhabited.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.transmute_uninhabited.LowerIntrinsics.panic-abort.diff index 6d3ad348988b..eab969e9fe5b 100644 --- a/tests/mir-opt/lower_intrinsics.transmute_uninhabited.LowerIntrinsics.panic-abort.diff +++ b/tests/mir-opt/lower_intrinsics.transmute_uninhabited.LowerIntrinsics.panic-abort.diff @@ -8,7 +8,7 @@ bb0: { StorageLive(_2); - _2 = _1; + _2 = copy _1; - _0 = transmute::<(), Never>(move _2) -> unwind unreachable; + _0 = move _2 as Never (Transmute); + unreachable; diff --git a/tests/mir-opt/lower_intrinsics.transmute_uninhabited.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.transmute_uninhabited.LowerIntrinsics.panic-unwind.diff index 6d3ad348988b..eab969e9fe5b 100644 --- a/tests/mir-opt/lower_intrinsics.transmute_uninhabited.LowerIntrinsics.panic-unwind.diff +++ b/tests/mir-opt/lower_intrinsics.transmute_uninhabited.LowerIntrinsics.panic-unwind.diff @@ -8,7 +8,7 @@ bb0: { StorageLive(_2); - _2 = _1; + _2 = copy _1; - _0 = transmute::<(), Never>(move _2) -> unwind unreachable; + _0 = move _2 as Never (Transmute); + unreachable; diff --git a/tests/mir-opt/lower_intrinsics.unchecked.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.unchecked.LowerIntrinsics.panic-abort.diff index 3c9694d0370d..d0d38462f8dd 100644 --- a/tests/mir-opt/lower_intrinsics.unchecked.LowerIntrinsics.panic-abort.diff +++ b/tests/mir-opt/lower_intrinsics.unchecked.LowerIntrinsics.panic-abort.diff @@ -64,9 +64,9 @@ bb0: { StorageLive(_4); StorageLive(_5); - _5 = _1; + _5 = copy _1; StorageLive(_6); - _6 = _2; + _6 = copy _2; - _4 = unchecked_add::(move _5, move _6) -> [return: bb1, unwind unreachable]; + _4 = AddUnchecked(move _5, move _6); + goto -> bb1; @@ -77,9 +77,9 @@ StorageDead(_5); StorageLive(_7); StorageLive(_8); - _8 = _1; + _8 = copy _1; StorageLive(_9); - _9 = _2; + _9 = copy _2; - _7 = unchecked_sub::(move _8, move _9) -> [return: bb2, unwind unreachable]; + _7 = SubUnchecked(move _8, move _9); + goto -> bb2; @@ -90,9 +90,9 @@ StorageDead(_8); StorageLive(_10); StorageLive(_11); - _11 = _1; + _11 = copy _1; StorageLive(_12); - _12 = _2; + _12 = copy _2; - _10 = unchecked_mul::(move _11, move _12) -> [return: bb3, unwind unreachable]; + _10 = MulUnchecked(move _11, move _12); + goto -> bb3; @@ -103,9 +103,9 @@ StorageDead(_11); StorageLive(_13); StorageLive(_14); - _14 = _1; + _14 = copy _1; StorageLive(_15); - _15 = _2; + _15 = copy _2; - _13 = unchecked_div::(move _14, move _15) -> [return: bb4, unwind unreachable]; + _13 = Div(move _14, move _15); + goto -> bb4; @@ -116,9 +116,9 @@ StorageDead(_14); StorageLive(_16); StorageLive(_17); - _17 = _1; + _17 = copy _1; StorageLive(_18); - _18 = _2; + _18 = copy _2; - _16 = unchecked_rem::(move _17, move _18) -> [return: bb5, unwind unreachable]; + _16 = Rem(move _17, move _18); + goto -> bb5; @@ -129,9 +129,9 @@ StorageDead(_17); StorageLive(_19); StorageLive(_20); - _20 = _1; + _20 = copy _1; StorageLive(_21); - _21 = _2; + _21 = copy _2; - _19 = unchecked_shl::(move _20, move _21) -> [return: bb6, unwind unreachable]; + _19 = ShlUnchecked(move _20, move _21); + goto -> bb6; @@ -142,9 +142,9 @@ StorageDead(_20); StorageLive(_22); StorageLive(_23); - _23 = _1; + _23 = copy _1; StorageLive(_24); - _24 = _2; + _24 = copy _2; - _22 = unchecked_shr::(move _23, move _24) -> [return: bb7, unwind unreachable]; + _22 = ShrUnchecked(move _23, move _24); + goto -> bb7; @@ -155,9 +155,9 @@ StorageDead(_23); StorageLive(_25); StorageLive(_26); - _26 = _1; + _26 = copy _1; StorageLive(_27); - _27 = _3; + _27 = copy _3; - _25 = unchecked_shl::(move _26, move _27) -> [return: bb8, unwind unreachable]; + _25 = ShlUnchecked(move _26, move _27); + goto -> bb8; @@ -168,9 +168,9 @@ StorageDead(_26); StorageLive(_28); StorageLive(_29); - _29 = _1; + _29 = copy _1; StorageLive(_30); - _30 = _3; + _30 = copy _3; - _28 = unchecked_shr::(move _29, move _30) -> [return: bb9, unwind unreachable]; + _28 = ShrUnchecked(move _29, move _30); + goto -> bb9; diff --git a/tests/mir-opt/lower_intrinsics.unchecked.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.unchecked.LowerIntrinsics.panic-unwind.diff index 3c9694d0370d..d0d38462f8dd 100644 --- a/tests/mir-opt/lower_intrinsics.unchecked.LowerIntrinsics.panic-unwind.diff +++ b/tests/mir-opt/lower_intrinsics.unchecked.LowerIntrinsics.panic-unwind.diff @@ -64,9 +64,9 @@ bb0: { StorageLive(_4); StorageLive(_5); - _5 = _1; + _5 = copy _1; StorageLive(_6); - _6 = _2; + _6 = copy _2; - _4 = unchecked_add::(move _5, move _6) -> [return: bb1, unwind unreachable]; + _4 = AddUnchecked(move _5, move _6); + goto -> bb1; @@ -77,9 +77,9 @@ StorageDead(_5); StorageLive(_7); StorageLive(_8); - _8 = _1; + _8 = copy _1; StorageLive(_9); - _9 = _2; + _9 = copy _2; - _7 = unchecked_sub::(move _8, move _9) -> [return: bb2, unwind unreachable]; + _7 = SubUnchecked(move _8, move _9); + goto -> bb2; @@ -90,9 +90,9 @@ StorageDead(_8); StorageLive(_10); StorageLive(_11); - _11 = _1; + _11 = copy _1; StorageLive(_12); - _12 = _2; + _12 = copy _2; - _10 = unchecked_mul::(move _11, move _12) -> [return: bb3, unwind unreachable]; + _10 = MulUnchecked(move _11, move _12); + goto -> bb3; @@ -103,9 +103,9 @@ StorageDead(_11); StorageLive(_13); StorageLive(_14); - _14 = _1; + _14 = copy _1; StorageLive(_15); - _15 = _2; + _15 = copy _2; - _13 = unchecked_div::(move _14, move _15) -> [return: bb4, unwind unreachable]; + _13 = Div(move _14, move _15); + goto -> bb4; @@ -116,9 +116,9 @@ StorageDead(_14); StorageLive(_16); StorageLive(_17); - _17 = _1; + _17 = copy _1; StorageLive(_18); - _18 = _2; + _18 = copy _2; - _16 = unchecked_rem::(move _17, move _18) -> [return: bb5, unwind unreachable]; + _16 = Rem(move _17, move _18); + goto -> bb5; @@ -129,9 +129,9 @@ StorageDead(_17); StorageLive(_19); StorageLive(_20); - _20 = _1; + _20 = copy _1; StorageLive(_21); - _21 = _2; + _21 = copy _2; - _19 = unchecked_shl::(move _20, move _21) -> [return: bb6, unwind unreachable]; + _19 = ShlUnchecked(move _20, move _21); + goto -> bb6; @@ -142,9 +142,9 @@ StorageDead(_20); StorageLive(_22); StorageLive(_23); - _23 = _1; + _23 = copy _1; StorageLive(_24); - _24 = _2; + _24 = copy _2; - _22 = unchecked_shr::(move _23, move _24) -> [return: bb7, unwind unreachable]; + _22 = ShrUnchecked(move _23, move _24); + goto -> bb7; @@ -155,9 +155,9 @@ StorageDead(_23); StorageLive(_25); StorageLive(_26); - _26 = _1; + _26 = copy _1; StorageLive(_27); - _27 = _3; + _27 = copy _3; - _25 = unchecked_shl::(move _26, move _27) -> [return: bb8, unwind unreachable]; + _25 = ShlUnchecked(move _26, move _27); + goto -> bb8; @@ -168,9 +168,9 @@ StorageDead(_26); StorageLive(_28); StorageLive(_29); - _29 = _1; + _29 = copy _1; StorageLive(_30); - _30 = _3; + _30 = copy _3; - _28 = unchecked_shr::(move _29, move _30) -> [return: bb9, unwind unreachable]; + _28 = ShrUnchecked(move _29, move _30); + goto -> bb9; diff --git a/tests/mir-opt/lower_intrinsics.with_overflow.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.with_overflow.LowerIntrinsics.panic-abort.diff index efbbeeeac73d..a9bb5e7e3a44 100644 --- a/tests/mir-opt/lower_intrinsics.with_overflow.LowerIntrinsics.panic-abort.diff +++ b/tests/mir-opt/lower_intrinsics.with_overflow.LowerIntrinsics.panic-abort.diff @@ -27,9 +27,9 @@ bb0: { StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; StorageLive(_5); - _5 = _2; + _5 = copy _2; - _3 = add_with_overflow::(move _4, move _5) -> [return: bb1, unwind unreachable]; + _3 = AddWithOverflow(move _4, move _5); + goto -> bb1; @@ -40,9 +40,9 @@ StorageDead(_4); StorageLive(_6); StorageLive(_7); - _7 = _1; + _7 = copy _1; StorageLive(_8); - _8 = _2; + _8 = copy _2; - _6 = sub_with_overflow::(move _7, move _8) -> [return: bb2, unwind unreachable]; + _6 = SubWithOverflow(move _7, move _8); + goto -> bb2; @@ -53,9 +53,9 @@ StorageDead(_7); StorageLive(_9); StorageLive(_10); - _10 = _1; + _10 = copy _1; StorageLive(_11); - _11 = _2; + _11 = copy _2; - _9 = mul_with_overflow::(move _10, move _11) -> [return: bb3, unwind unreachable]; + _9 = MulWithOverflow(move _10, move _11); + goto -> bb3; diff --git a/tests/mir-opt/lower_intrinsics.with_overflow.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.with_overflow.LowerIntrinsics.panic-unwind.diff index efbbeeeac73d..a9bb5e7e3a44 100644 --- a/tests/mir-opt/lower_intrinsics.with_overflow.LowerIntrinsics.panic-unwind.diff +++ b/tests/mir-opt/lower_intrinsics.with_overflow.LowerIntrinsics.panic-unwind.diff @@ -27,9 +27,9 @@ bb0: { StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; StorageLive(_5); - _5 = _2; + _5 = copy _2; - _3 = add_with_overflow::(move _4, move _5) -> [return: bb1, unwind unreachable]; + _3 = AddWithOverflow(move _4, move _5); + goto -> bb1; @@ -40,9 +40,9 @@ StorageDead(_4); StorageLive(_6); StorageLive(_7); - _7 = _1; + _7 = copy _1; StorageLive(_8); - _8 = _2; + _8 = copy _2; - _6 = sub_with_overflow::(move _7, move _8) -> [return: bb2, unwind unreachable]; + _6 = SubWithOverflow(move _7, move _8); + goto -> bb2; @@ -53,9 +53,9 @@ StorageDead(_7); StorageLive(_9); StorageLive(_10); - _10 = _1; + _10 = copy _1; StorageLive(_11); - _11 = _2; + _11 = copy _2; - _9 = mul_with_overflow::(move _10, move _11) -> [return: bb3, unwind unreachable]; + _9 = MulWithOverflow(move _10, move _11); + goto -> bb3; diff --git a/tests/mir-opt/lower_intrinsics.wrapping.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.wrapping.LowerIntrinsics.panic-abort.diff index 2acb193e054d..552b1a9a32b4 100644 --- a/tests/mir-opt/lower_intrinsics.wrapping.LowerIntrinsics.panic-abort.diff +++ b/tests/mir-opt/lower_intrinsics.wrapping.LowerIntrinsics.panic-abort.diff @@ -27,9 +27,9 @@ bb0: { StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; StorageLive(_5); - _5 = _2; + _5 = copy _2; - _3 = std::intrinsics::wrapping_add::(move _4, move _5) -> [return: bb1, unwind unreachable]; + _3 = Add(move _4, move _5); + goto -> bb1; @@ -40,9 +40,9 @@ StorageDead(_4); StorageLive(_6); StorageLive(_7); - _7 = _1; + _7 = copy _1; StorageLive(_8); - _8 = _2; + _8 = copy _2; - _6 = std::intrinsics::wrapping_sub::(move _7, move _8) -> [return: bb2, unwind unreachable]; + _6 = Sub(move _7, move _8); + goto -> bb2; @@ -53,9 +53,9 @@ StorageDead(_7); StorageLive(_9); StorageLive(_10); - _10 = _1; + _10 = copy _1; StorageLive(_11); - _11 = _2; + _11 = copy _2; - _9 = wrapping_mul::(move _10, move _11) -> [return: bb3, unwind unreachable]; + _9 = Mul(move _10, move _11); + goto -> bb3; diff --git a/tests/mir-opt/lower_intrinsics.wrapping.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.wrapping.LowerIntrinsics.panic-unwind.diff index 2acb193e054d..552b1a9a32b4 100644 --- a/tests/mir-opt/lower_intrinsics.wrapping.LowerIntrinsics.panic-unwind.diff +++ b/tests/mir-opt/lower_intrinsics.wrapping.LowerIntrinsics.panic-unwind.diff @@ -27,9 +27,9 @@ bb0: { StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; StorageLive(_5); - _5 = _2; + _5 = copy _2; - _3 = std::intrinsics::wrapping_add::(move _4, move _5) -> [return: bb1, unwind unreachable]; + _3 = Add(move _4, move _5); + goto -> bb1; @@ -40,9 +40,9 @@ StorageDead(_4); StorageLive(_6); StorageLive(_7); - _7 = _1; + _7 = copy _1; StorageLive(_8); - _8 = _2; + _8 = copy _2; - _6 = std::intrinsics::wrapping_sub::(move _7, move _8) -> [return: bb2, unwind unreachable]; + _6 = Sub(move _7, move _8); + goto -> bb2; @@ -53,9 +53,9 @@ StorageDead(_7); StorageLive(_9); StorageLive(_10); - _10 = _1; + _10 = copy _1; StorageLive(_11); - _11 = _2; + _11 = copy _2; - _9 = wrapping_mul::(move _10, move _11) -> [return: bb3, unwind unreachable]; + _9 = Mul(move _10, move _11); + goto -> bb3; diff --git a/tests/mir-opt/lower_slice_len.bound.LowerSliceLenCalls.panic-abort.diff b/tests/mir-opt/lower_slice_len.bound.LowerSliceLenCalls.panic-abort.diff index a212ee678811..20001f1248ef 100644 --- a/tests/mir-opt/lower_slice_len.bound.LowerSliceLenCalls.panic-abort.diff +++ b/tests/mir-opt/lower_slice_len.bound.LowerSliceLenCalls.panic-abort.diff @@ -16,7 +16,7 @@ bb0: { StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; StorageLive(_5); StorageLive(_6); _6 = &(*_2); @@ -35,14 +35,14 @@ StorageDead(_5); StorageDead(_4); StorageLive(_7); - _7 = _1; + _7 = copy _1; _8 = Len((*_2)); - _9 = Lt(_7, _8); - assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, _7) -> [success: bb3, unwind unreachable]; + _9 = Lt(copy _7, copy _8); + assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, copy _7) -> [success: bb3, unwind unreachable]; } bb3: { - _0 = (*_2)[_7]; + _0 = copy (*_2)[_7]; StorageDead(_7); goto -> bb5; } diff --git a/tests/mir-opt/lower_slice_len.bound.LowerSliceLenCalls.panic-unwind.diff b/tests/mir-opt/lower_slice_len.bound.LowerSliceLenCalls.panic-unwind.diff index 38ec8a5b0c72..ca8f92df5de0 100644 --- a/tests/mir-opt/lower_slice_len.bound.LowerSliceLenCalls.panic-unwind.diff +++ b/tests/mir-opt/lower_slice_len.bound.LowerSliceLenCalls.panic-unwind.diff @@ -16,7 +16,7 @@ bb0: { StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; StorageLive(_5); StorageLive(_6); _6 = &(*_2); @@ -35,14 +35,14 @@ StorageDead(_5); StorageDead(_4); StorageLive(_7); - _7 = _1; + _7 = copy _1; _8 = Len((*_2)); - _9 = Lt(_7, _8); - assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, _7) -> [success: bb3, unwind continue]; + _9 = Lt(copy _7, copy _8); + assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, copy _7) -> [success: bb3, unwind continue]; } bb3: { - _0 = (*_2)[_7]; + _0 = copy (*_2)[_7]; StorageDead(_7); goto -> bb5; } diff --git a/tests/mir-opt/match_arm_scopes.complicated_match.panic-abort.SimplifyCfg-initial.after-ElaborateDrops.after.diff b/tests/mir-opt/match_arm_scopes.complicated_match.panic-abort.SimplifyCfg-initial.after-ElaborateDrops.after.diff index 3c4a84bc2436..b3eb3e1f8b9d 100644 --- a/tests/mir-opt/match_arm_scopes.complicated_match.panic-abort.SimplifyCfg-initial.after-ElaborateDrops.after.diff +++ b/tests/mir-opt/match_arm_scopes.complicated_match.panic-abort.SimplifyCfg-initial.after-ElaborateDrops.after.diff @@ -32,22 +32,22 @@ bb0: { PlaceMention(_2); -- switchInt((_2.0: bool)) -> [0: bb2, otherwise: bb1]; -+ switchInt((_2.0: bool)) -> [0: bb6, otherwise: bb1]; +- switchInt(copy (_2.0: bool)) -> [0: bb2, otherwise: bb1]; ++ switchInt(copy (_2.0: bool)) -> [0: bb6, otherwise: bb1]; } bb1: { -- switchInt((_2.1: bool)) -> [0: bb4, otherwise: bb3]; -+ switchInt((_2.1: bool)) -> [0: bb5, otherwise: bb2]; +- switchInt(copy (_2.1: bool)) -> [0: bb4, otherwise: bb3]; ++ switchInt(copy (_2.1: bool)) -> [0: bb5, otherwise: bb2]; } bb2: { - falseEdge -> [real: bb9, imaginary: bb1]; -+ switchInt((_2.0: bool)) -> [0: bb3, otherwise: bb4]; ++ switchInt(copy (_2.0: bool)) -> [0: bb3, otherwise: bb4]; } bb3: { -- switchInt((_2.0: bool)) -> [0: bb6, otherwise: bb5]; +- switchInt(copy (_2.0: bool)) -> [0: bb6, otherwise: bb5]; - } - - bb4: { @@ -60,7 +60,7 @@ - - bb6: { StorageLive(_15); - _15 = (_2.1: bool); + _15 = copy (_2.1: bool); StorageLive(_16); _16 = move (_2.2: std::string::String); - goto -> bb20; @@ -70,7 +70,7 @@ - bb7: { + bb4: { StorageLive(_15); - _15 = (_2.1: bool); + _15 = copy (_2.1: bool); StorageLive(_16); _16 = move (_2.2: std::string::String); - goto -> bb20; @@ -87,7 +87,7 @@ - _4 = &fake shallow (_2.1: bool); StorageLive(_12); StorageLive(_13); - _13 = _1; + _13 = copy _1; - switchInt(move _13) -> [0: bb16, otherwise: bb15]; + switchInt(move _13) -> [0: bb13, otherwise: bb12]; } @@ -102,7 +102,7 @@ - _4 = &fake shallow (_2.1: bool); StorageLive(_9); StorageLive(_10); - _10 = _1; + _10 = copy _1; - switchInt(move _10) -> [0: bb12, otherwise: bb11]; + switchInt(move _10) -> [0: bb9, otherwise: bb8]; } @@ -125,7 +125,7 @@ - bb12: { + bb9: { - _9 = (*_6); + _9 = copy (*_6); - switchInt(move _9) -> [0: bb14, otherwise: bb13]; + switchInt(move _9) -> [0: bb11, otherwise: bb10]; } @@ -139,7 +139,7 @@ - FakeRead(ForGuardBinding, _6); - FakeRead(ForGuardBinding, _8); StorageLive(_5); - _5 = (_2.1: bool); + _5 = copy (_2.1: bool); StorageLive(_7); _7 = move (_2.2: std::string::String); - goto -> bb10; @@ -167,7 +167,7 @@ - bb16: { + bb13: { - _12 = (*_6); + _12 = copy (*_6); - switchInt(move _12) -> [0: bb18, otherwise: bb17]; + switchInt(move _12) -> [0: bb15, otherwise: bb14]; } @@ -181,7 +181,7 @@ - FakeRead(ForGuardBinding, _6); - FakeRead(ForGuardBinding, _8); StorageLive(_5); - _5 = (_2.0: bool); + _5 = copy (_2.0: bool); StorageLive(_7); _7 = move (_2.2: std::string::String); - goto -> bb10; diff --git a/tests/mir-opt/match_arm_scopes.complicated_match.panic-unwind.SimplifyCfg-initial.after-ElaborateDrops.after.diff b/tests/mir-opt/match_arm_scopes.complicated_match.panic-unwind.SimplifyCfg-initial.after-ElaborateDrops.after.diff index 3c4a84bc2436..b3eb3e1f8b9d 100644 --- a/tests/mir-opt/match_arm_scopes.complicated_match.panic-unwind.SimplifyCfg-initial.after-ElaborateDrops.after.diff +++ b/tests/mir-opt/match_arm_scopes.complicated_match.panic-unwind.SimplifyCfg-initial.after-ElaborateDrops.after.diff @@ -32,22 +32,22 @@ bb0: { PlaceMention(_2); -- switchInt((_2.0: bool)) -> [0: bb2, otherwise: bb1]; -+ switchInt((_2.0: bool)) -> [0: bb6, otherwise: bb1]; +- switchInt(copy (_2.0: bool)) -> [0: bb2, otherwise: bb1]; ++ switchInt(copy (_2.0: bool)) -> [0: bb6, otherwise: bb1]; } bb1: { -- switchInt((_2.1: bool)) -> [0: bb4, otherwise: bb3]; -+ switchInt((_2.1: bool)) -> [0: bb5, otherwise: bb2]; +- switchInt(copy (_2.1: bool)) -> [0: bb4, otherwise: bb3]; ++ switchInt(copy (_2.1: bool)) -> [0: bb5, otherwise: bb2]; } bb2: { - falseEdge -> [real: bb9, imaginary: bb1]; -+ switchInt((_2.0: bool)) -> [0: bb3, otherwise: bb4]; ++ switchInt(copy (_2.0: bool)) -> [0: bb3, otherwise: bb4]; } bb3: { -- switchInt((_2.0: bool)) -> [0: bb6, otherwise: bb5]; +- switchInt(copy (_2.0: bool)) -> [0: bb6, otherwise: bb5]; - } - - bb4: { @@ -60,7 +60,7 @@ - - bb6: { StorageLive(_15); - _15 = (_2.1: bool); + _15 = copy (_2.1: bool); StorageLive(_16); _16 = move (_2.2: std::string::String); - goto -> bb20; @@ -70,7 +70,7 @@ - bb7: { + bb4: { StorageLive(_15); - _15 = (_2.1: bool); + _15 = copy (_2.1: bool); StorageLive(_16); _16 = move (_2.2: std::string::String); - goto -> bb20; @@ -87,7 +87,7 @@ - _4 = &fake shallow (_2.1: bool); StorageLive(_12); StorageLive(_13); - _13 = _1; + _13 = copy _1; - switchInt(move _13) -> [0: bb16, otherwise: bb15]; + switchInt(move _13) -> [0: bb13, otherwise: bb12]; } @@ -102,7 +102,7 @@ - _4 = &fake shallow (_2.1: bool); StorageLive(_9); StorageLive(_10); - _10 = _1; + _10 = copy _1; - switchInt(move _10) -> [0: bb12, otherwise: bb11]; + switchInt(move _10) -> [0: bb9, otherwise: bb8]; } @@ -125,7 +125,7 @@ - bb12: { + bb9: { - _9 = (*_6); + _9 = copy (*_6); - switchInt(move _9) -> [0: bb14, otherwise: bb13]; + switchInt(move _9) -> [0: bb11, otherwise: bb10]; } @@ -139,7 +139,7 @@ - FakeRead(ForGuardBinding, _6); - FakeRead(ForGuardBinding, _8); StorageLive(_5); - _5 = (_2.1: bool); + _5 = copy (_2.1: bool); StorageLive(_7); _7 = move (_2.2: std::string::String); - goto -> bb10; @@ -167,7 +167,7 @@ - bb16: { + bb13: { - _12 = (*_6); + _12 = copy (*_6); - switchInt(move _12) -> [0: bb18, otherwise: bb17]; + switchInt(move _12) -> [0: bb15, otherwise: bb14]; } @@ -181,7 +181,7 @@ - FakeRead(ForGuardBinding, _6); - FakeRead(ForGuardBinding, _8); StorageLive(_5); - _5 = (_2.0: bool); + _5 = copy (_2.0: bool); StorageLive(_7); _7 = move (_2.2: std::string::String); - goto -> bb10; diff --git a/tests/mir-opt/matches_reduce_branches.bar.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.bar.MatchBranchSimplification.diff index 65da13eec50e..597d93926f16 100644 --- a/tests/mir-opt/matches_reduce_branches.bar.MatchBranchSimplification.diff +++ b/tests/mir-opt/matches_reduce_branches.bar.MatchBranchSimplification.diff @@ -33,16 +33,16 @@ StorageLive(_4); StorageLive(_5); StorageLive(_6); -- switchInt(_1) -> [7: bb2, otherwise: bb1]; +- switchInt(copy _1) -> [7: bb2, otherwise: bb1]; - } - - bb1: { - _2 = const true; - _3 = const false; + StorageLive(_11); -+ _11 = _1; -+ _2 = Ne(_11, const 7_i32); -+ _3 = Eq(_11, const 7_i32); ++ _11 = copy _1; ++ _2 = Ne(copy _11, const 7_i32); ++ _3 = Eq(copy _11, const 7_i32); _4 = const false; _5 = const true; _6 = (); @@ -62,13 +62,13 @@ + StorageDead(_11); StorageDead(_6); StorageLive(_7); - _7 = _2; + _7 = copy _2; StorageLive(_8); - _8 = _3; + _8 = copy _3; StorageLive(_9); - _9 = _4; + _9 = copy _4; StorageLive(_10); - _10 = _5; + _10 = copy _5; _0 = (move _7, move _8, move _9, move _10); StorageDead(_10); StorageDead(_9); diff --git a/tests/mir-opt/matches_reduce_branches.foo.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.foo.MatchBranchSimplification.diff index 052e2e126643..281f43b355dc 100644 --- a/tests/mir-opt/matches_reduce_branches.foo.MatchBranchSimplification.diff +++ b/tests/mir-opt/matches_reduce_branches.foo.MatchBranchSimplification.diff @@ -14,7 +14,7 @@ - switchInt(move _3) -> [0: bb2, otherwise: bb1]; + StorageLive(_4); + _4 = move _3; -+ _2 = Eq(_4, const 0_isize); ++ _2 = Eq(copy _4, const 0_isize); + StorageDead(_4); + switchInt(move _2) -> [0: bb2, otherwise: bb1]; } diff --git a/tests/mir-opt/matches_reduce_branches.match_i128_u128.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_i128_u128.MatchBranchSimplification.diff index fc34ce7125ec..cc7e863d1354 100644 --- a/tests/mir-opt/matches_reduce_branches.match_i128_u128.MatchBranchSimplification.diff +++ b/tests/mir-opt/matches_reduce_branches.match_i128_u128.MatchBranchSimplification.diff @@ -39,7 +39,7 @@ - bb6: { + StorageLive(_3); + _3 = move _2; -+ _0 = _3 as u128 (IntToInt); ++ _0 = copy _3 as u128 (IntToInt); + StorageDead(_3); return; } diff --git a/tests/mir-opt/matches_reduce_branches.match_nested_if.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_nested_if.MatchBranchSimplification.diff index 5a71bef93416..e9143ef1636e 100644 --- a/tests/mir-opt/matches_reduce_branches.match_nested_if.MatchBranchSimplification.diff +++ b/tests/mir-opt/matches_reduce_branches.match_nested_if.MatchBranchSimplification.diff @@ -46,7 +46,7 @@ - bb4: { + StorageLive(_7); + _7 = move _6; -+ _5 = Ne(_7, const false); ++ _5 = Ne(copy _7, const false); + StorageDead(_7); + StorageLive(_8); + _8 = move _5; @@ -66,7 +66,7 @@ - } - - bb7: { -+ _4 = Ne(_8, const false); ++ _4 = Ne(copy _8, const false); + StorageDead(_8); + StorageLive(_9); + _9 = move _4; @@ -86,7 +86,7 @@ - } - - bb10: { -+ _3 = Ne(_9, const false); ++ _3 = Ne(copy _9, const false); + StorageDead(_9); + StorageLive(_10); + _10 = move _3; @@ -104,10 +104,10 @@ - } - - bb12: { -+ _1 = Ne(_10, const false); ++ _1 = Ne(copy _10, const false); + StorageDead(_10); StorageDead(_2); - _0 = _1; + _0 = copy _1; StorageDead(_1); return; } diff --git a/tests/mir-opt/matches_reduce_branches.match_sext_i8_i16.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_sext_i8_i16.MatchBranchSimplification.diff index 7f8c2ab8d374..dbd26adc20f9 100644 --- a/tests/mir-opt/matches_reduce_branches.match_sext_i8_i16.MatchBranchSimplification.diff +++ b/tests/mir-opt/matches_reduce_branches.match_sext_i8_i16.MatchBranchSimplification.diff @@ -44,7 +44,7 @@ - bb7: { + StorageLive(_3); + _3 = move _2; -+ _0 = _3 as i16 (IntToInt); ++ _0 = copy _3 as i16 (IntToInt); + StorageDead(_3); return; } diff --git a/tests/mir-opt/matches_reduce_branches.match_sext_i8_u16.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_sext_i8_u16.MatchBranchSimplification.diff index 86d0d0ba6cf5..f273d5388350 100644 --- a/tests/mir-opt/matches_reduce_branches.match_sext_i8_u16.MatchBranchSimplification.diff +++ b/tests/mir-opt/matches_reduce_branches.match_sext_i8_u16.MatchBranchSimplification.diff @@ -44,7 +44,7 @@ - bb7: { + StorageLive(_3); + _3 = move _2; -+ _0 = _3 as u16 (IntToInt); ++ _0 = copy _3 as u16 (IntToInt); + StorageDead(_3); return; } diff --git a/tests/mir-opt/matches_reduce_branches.match_trunc_i16_i8.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_trunc_i16_i8.MatchBranchSimplification.diff index d3d27be20701..6170cf13c002 100644 --- a/tests/mir-opt/matches_reduce_branches.match_trunc_i16_i8.MatchBranchSimplification.diff +++ b/tests/mir-opt/matches_reduce_branches.match_trunc_i16_i8.MatchBranchSimplification.diff @@ -69,7 +69,7 @@ - bb12: { + StorageLive(_3); + _3 = move _2; -+ _0 = _3 as i8 (IntToInt); ++ _0 = copy _3 as i8 (IntToInt); + StorageDead(_3); return; } diff --git a/tests/mir-opt/matches_reduce_branches.match_trunc_i16_u8.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_trunc_i16_u8.MatchBranchSimplification.diff index 5fe899148ebc..c18719ebb55e 100644 --- a/tests/mir-opt/matches_reduce_branches.match_trunc_i16_u8.MatchBranchSimplification.diff +++ b/tests/mir-opt/matches_reduce_branches.match_trunc_i16_u8.MatchBranchSimplification.diff @@ -69,7 +69,7 @@ - bb12: { + StorageLive(_3); + _3 = move _2; -+ _0 = _3 as u8 (IntToInt); ++ _0 = copy _3 as u8 (IntToInt); + StorageDead(_3); return; } diff --git a/tests/mir-opt/matches_reduce_branches.match_trunc_u16_i8.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_trunc_u16_i8.MatchBranchSimplification.diff index 85f97a13cac9..401049026f27 100644 --- a/tests/mir-opt/matches_reduce_branches.match_trunc_u16_i8.MatchBranchSimplification.diff +++ b/tests/mir-opt/matches_reduce_branches.match_trunc_u16_i8.MatchBranchSimplification.diff @@ -59,7 +59,7 @@ - bb10: { + StorageLive(_3); + _3 = move _2; -+ _0 = _3 as i8 (IntToInt); ++ _0 = copy _3 as i8 (IntToInt); + StorageDead(_3); return; } diff --git a/tests/mir-opt/matches_reduce_branches.match_trunc_u16_u8.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_trunc_u16_u8.MatchBranchSimplification.diff index 768d838eaa6f..d4dafbd886fc 100644 --- a/tests/mir-opt/matches_reduce_branches.match_trunc_u16_u8.MatchBranchSimplification.diff +++ b/tests/mir-opt/matches_reduce_branches.match_trunc_u16_u8.MatchBranchSimplification.diff @@ -59,7 +59,7 @@ - bb10: { + StorageLive(_3); + _3 = move _2; -+ _0 = _3 as u8 (IntToInt); ++ _0 = copy _3 as u8 (IntToInt); + StorageDead(_3); return; } diff --git a/tests/mir-opt/matches_reduce_branches.match_u8_i8.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_u8_i8.MatchBranchSimplification.diff index d63eed7c019a..5ab6f5eac84a 100644 --- a/tests/mir-opt/matches_reduce_branches.match_u8_i8.MatchBranchSimplification.diff +++ b/tests/mir-opt/matches_reduce_branches.match_u8_i8.MatchBranchSimplification.diff @@ -39,7 +39,7 @@ - bb6: { + StorageLive(_3); + _3 = move _2; -+ _0 = _3 as i8 (IntToInt); ++ _0 = copy _3 as i8 (IntToInt); + StorageDead(_3); return; } diff --git a/tests/mir-opt/matches_reduce_branches.match_u8_i8_2.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_u8_i8_2.MatchBranchSimplification.diff index 98dee1835a82..f14b3af9660a 100644 --- a/tests/mir-opt/matches_reduce_branches.match_u8_i8_2.MatchBranchSimplification.diff +++ b/tests/mir-opt/matches_reduce_branches.match_u8_i8_2.MatchBranchSimplification.diff @@ -35,8 +35,8 @@ - _3 = const -1_i8; + StorageLive(_8); + _8 = move _5; -+ _2 = _8 as i8 (IntToInt); -+ _3 = _8 as i8 (IntToInt); ++ _2 = copy _8 as i8 (IntToInt); ++ _3 = copy _8 as i8 (IntToInt); _4 = (); - goto -> bb6; - } @@ -66,9 +66,9 @@ + StorageDead(_8); StorageDead(_4); StorageLive(_6); - _6 = _2; + _6 = copy _2; StorageLive(_7); - _7 = _3; + _7 = copy _3; _0 = (move _6, move _7); StorageDead(_7); StorageDead(_6); diff --git a/tests/mir-opt/matches_reduce_branches.match_u8_i8_2_failed.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_u8_i8_2_failed.MatchBranchSimplification.diff index 901dda586177..92e1a7dbc7d6 100644 --- a/tests/mir-opt/matches_reduce_branches.match_u8_i8_2_failed.MatchBranchSimplification.diff +++ b/tests/mir-opt/matches_reduce_branches.match_u8_i8_2_failed.MatchBranchSimplification.diff @@ -60,9 +60,9 @@ bb6: { StorageDead(_4); StorageLive(_6); - _6 = _2; + _6 = copy _2; StorageLive(_7); - _7 = _3; + _7 = copy _3; _0 = (move _6, move _7); StorageDead(_7); StorageDead(_6); diff --git a/tests/mir-opt/matches_reduce_branches.match_u8_i8_failed_len_1.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_u8_i8_failed_len_1.MatchBranchSimplification.diff index 9ebf2cf27cbf..a1d58424ecd1 100644 --- a/tests/mir-opt/matches_reduce_branches.match_u8_i8_failed_len_1.MatchBranchSimplification.diff +++ b/tests/mir-opt/matches_reduce_branches.match_u8_i8_failed_len_1.MatchBranchSimplification.diff @@ -7,7 +7,7 @@ bb0: { _2 = discriminant(_1); - switchInt(_2) -> [0: bb1, 127: bb2, 128: bb3, 255: bb4, otherwise: bb5]; + switchInt(copy _2) -> [0: bb1, 127: bb2, 128: bb3, 255: bb4, otherwise: bb5]; } bb1: { diff --git a/tests/mir-opt/matches_reduce_branches.match_u8_i8_failed_len_2.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_u8_i8_failed_len_2.MatchBranchSimplification.diff index 554856777eb6..6c4ade1b6ca9 100644 --- a/tests/mir-opt/matches_reduce_branches.match_u8_i8_failed_len_2.MatchBranchSimplification.diff +++ b/tests/mir-opt/matches_reduce_branches.match_u8_i8_failed_len_2.MatchBranchSimplification.diff @@ -7,7 +7,7 @@ bb0: { _2 = discriminant(_1); - switchInt(_2) -> [0: bb1, 127: bb2, 128: bb3, 255: bb4, otherwise: bb5]; + switchInt(copy _2) -> [0: bb1, 127: bb2, 128: bb3, 255: bb4, otherwise: bb5]; } bb1: { diff --git a/tests/mir-opt/matches_reduce_branches.match_zext_u8_i16.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_zext_u8_i16.MatchBranchSimplification.diff index e00a604fe25d..fdf83d91bbd3 100644 --- a/tests/mir-opt/matches_reduce_branches.match_zext_u8_i16.MatchBranchSimplification.diff +++ b/tests/mir-opt/matches_reduce_branches.match_zext_u8_i16.MatchBranchSimplification.diff @@ -39,7 +39,7 @@ - bb6: { + StorageLive(_3); + _3 = move _2; -+ _0 = _3 as i16 (IntToInt); ++ _0 = copy _3 as i16 (IntToInt); + StorageDead(_3); return; } diff --git a/tests/mir-opt/matches_reduce_branches.match_zext_u8_u16.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_zext_u8_u16.MatchBranchSimplification.diff index befb9118907b..a888d247275f 100644 --- a/tests/mir-opt/matches_reduce_branches.match_zext_u8_u16.MatchBranchSimplification.diff +++ b/tests/mir-opt/matches_reduce_branches.match_zext_u8_u16.MatchBranchSimplification.diff @@ -39,7 +39,7 @@ - bb6: { + StorageLive(_3); + _3 = move _2; -+ _0 = _3 as u16 (IntToInt); ++ _0 = copy _3 as u16 (IntToInt); + StorageDead(_3); return; } diff --git a/tests/mir-opt/matches_u8.exhaustive_match.MatchBranchSimplification.diff b/tests/mir-opt/matches_u8.exhaustive_match.MatchBranchSimplification.diff index 11a18f58e3a1..99985b28382f 100644 --- a/tests/mir-opt/matches_u8.exhaustive_match.MatchBranchSimplification.diff +++ b/tests/mir-opt/matches_u8.exhaustive_match.MatchBranchSimplification.diff @@ -29,7 +29,7 @@ - bb4: { + StorageLive(_3); + _3 = move _2; -+ _0 = _3 as u8 (IntToInt); ++ _0 = copy _3 as u8 (IntToInt); + StorageDead(_3); return; } diff --git a/tests/mir-opt/matches_u8.exhaustive_match_i8.MatchBranchSimplification.diff b/tests/mir-opt/matches_u8.exhaustive_match_i8.MatchBranchSimplification.diff index 809badc41ba7..0fc5032691fe 100644 --- a/tests/mir-opt/matches_u8.exhaustive_match_i8.MatchBranchSimplification.diff +++ b/tests/mir-opt/matches_u8.exhaustive_match_i8.MatchBranchSimplification.diff @@ -29,7 +29,7 @@ - bb4: { + StorageLive(_3); + _3 = move _2; -+ _0 = _3 as i8 (IntToInt); ++ _0 = copy _3 as i8 (IntToInt); + StorageDead(_3); return; } diff --git a/tests/mir-opt/nll/region_subtyping_basic.main.nll.0.32bit.mir b/tests/mir-opt/nll/region_subtyping_basic.main.nll.0.32bit.mir index ad456600b0ab..d09a422d4080 100644 --- a/tests/mir-opt/nll/region_subtyping_basic.main.nll.0.32bit.mir +++ b/tests/mir-opt/nll/region_subtyping_basic.main.nll.0.32bit.mir @@ -50,15 +50,15 @@ fn main() -> () { StorageLive(_3); _3 = const ConstValue(Scalar(0x00000000): usize); _4 = Len(_1); - _5 = Lt(_3, _4); - assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind: bb7]; + _5 = Lt(copy _3, copy _4); + assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind: bb7]; } bb1: { _2 = &'?2 _1[_3]; FakeRead(ForLet(None), _2); StorageLive(_6); - _6 = _2; + _6 = copy _2; FakeRead(ForLet(None), _6); StorageLive(_7); _7 = const ConstValue(Scalar(0x01): bool); @@ -68,7 +68,7 @@ fn main() -> () { bb2: { StorageLive(_8); StorageLive(_9); - _9 = (*_6); + _9 = copy (*_6); _8 = ConstValue(ZeroSized: fn(usize) -> bool {use_x})(move _9) -> [return: bb3, unwind: bb7]; } diff --git a/tests/mir-opt/nll/region_subtyping_basic.main.nll.0.64bit.mir b/tests/mir-opt/nll/region_subtyping_basic.main.nll.0.64bit.mir index a15d47cd66fe..4abb5b0b93b1 100644 --- a/tests/mir-opt/nll/region_subtyping_basic.main.nll.0.64bit.mir +++ b/tests/mir-opt/nll/region_subtyping_basic.main.nll.0.64bit.mir @@ -50,15 +50,15 @@ fn main() -> () { StorageLive(_3); _3 = const ConstValue(Scalar(0x0000000000000000): usize); _4 = Len(_1); - _5 = Lt(_3, _4); - assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind: bb7]; + _5 = Lt(copy _3, copy _4); + assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind: bb7]; } bb1: { _2 = &'?2 _1[_3]; FakeRead(ForLet(None), _2); StorageLive(_6); - _6 = _2; + _6 = copy _2; FakeRead(ForLet(None), _6); StorageLive(_7); _7 = const ConstValue(Scalar(0x01): bool); @@ -68,7 +68,7 @@ fn main() -> () { bb2: { StorageLive(_8); StorageLive(_9); - _9 = (*_6); + _9 = copy (*_6); _8 = ConstValue(ZeroSized: fn(usize) -> bool {use_x})(move _9) -> [return: bb3, unwind: bb7]; } diff --git a/tests/mir-opt/nrvo_miscompile_111005.wrong.RenameReturnPlace.diff b/tests/mir-opt/nrvo_miscompile_111005.wrong.RenameReturnPlace.diff index 260b472daa92..d248c76f261b 100644 --- a/tests/mir-opt/nrvo_miscompile_111005.wrong.RenameReturnPlace.diff +++ b/tests/mir-opt/nrvo_miscompile_111005.wrong.RenameReturnPlace.diff @@ -6,10 +6,10 @@ let mut _2: char; bb0: { -- _2 = _1; -- _0 = _2; +- _2 = copy _1; +- _0 = copy _2; - _2 = const 'b'; -+ _0 = _1; ++ _0 = copy _1; + _0 = const 'b'; return; } diff --git a/tests/mir-opt/nrvo_simple.nrvo.RenameReturnPlace.panic-abort.diff b/tests/mir-opt/nrvo_simple.nrvo.RenameReturnPlace.panic-abort.diff index f7bc5559ab7b..6dce3ec5303d 100644 --- a/tests/mir-opt/nrvo_simple.nrvo.RenameReturnPlace.panic-abort.diff +++ b/tests/mir-opt/nrvo_simple.nrvo.RenameReturnPlace.panic-abort.diff @@ -20,7 +20,7 @@ + _0 = [const 0_u8; 1024]; StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; StorageLive(_5); StorageLive(_6); - _6 = &mut _2; @@ -34,7 +34,7 @@ StorageDead(_4); StorageDead(_6); StorageDead(_3); -- _0 = _2; +- _0 = copy _2; - StorageDead(_2); return; } diff --git a/tests/mir-opt/nrvo_simple.nrvo.RenameReturnPlace.panic-unwind.diff b/tests/mir-opt/nrvo_simple.nrvo.RenameReturnPlace.panic-unwind.diff index 3df8e567f1fe..54cbe2871f15 100644 --- a/tests/mir-opt/nrvo_simple.nrvo.RenameReturnPlace.panic-unwind.diff +++ b/tests/mir-opt/nrvo_simple.nrvo.RenameReturnPlace.panic-unwind.diff @@ -20,7 +20,7 @@ + _0 = [const 0_u8; 1024]; StorageLive(_3); StorageLive(_4); - _4 = _1; + _4 = copy _1; StorageLive(_5); StorageLive(_6); - _6 = &mut _2; @@ -34,7 +34,7 @@ StorageDead(_4); StorageDead(_6); StorageDead(_3); -- _0 = _2; +- _0 = copy _2; - StorageDead(_2); return; } diff --git a/tests/mir-opt/or_pattern.shortcut_second_or.SimplifyCfg-initial.after.mir b/tests/mir-opt/or_pattern.shortcut_second_or.SimplifyCfg-initial.after.mir index 6c76a72b7757..c5d7a6a1d996 100644 --- a/tests/mir-opt/or_pattern.shortcut_second_or.SimplifyCfg-initial.after.mir +++ b/tests/mir-opt/or_pattern.shortcut_second_or.SimplifyCfg-initial.after.mir @@ -18,15 +18,15 @@ fn shortcut_second_or() -> () { _1 = (move _2, const 0_i32); StorageDead(_2); PlaceMention(_1); - switchInt(((_1.0: (i32, i32)).0: i32)) -> [0: bb2, otherwise: bb1]; + switchInt(copy ((_1.0: (i32, i32)).0: i32)) -> [0: bb2, otherwise: bb1]; } bb1: { - switchInt(((_1.0: (i32, i32)).1: i32)) -> [1: bb4, otherwise: bb3]; + switchInt(copy ((_1.0: (i32, i32)).1: i32)) -> [1: bb4, otherwise: bb3]; } bb2: { - switchInt((_1.1: i32)) -> [2: bb5, 3: bb6, otherwise: bb3]; + switchInt(copy (_1.1: i32)) -> [2: bb5, 3: bb6, otherwise: bb3]; } bb3: { @@ -35,7 +35,7 @@ fn shortcut_second_or() -> () { } bb4: { - switchInt((_1.1: i32)) -> [2: bb7, 3: bb8, otherwise: bb3]; + switchInt(copy (_1.1: i32)) -> [2: bb7, 3: bb8, otherwise: bb3]; } bb5: { @@ -56,33 +56,33 @@ fn shortcut_second_or() -> () { bb9: { StorageLive(_3); - _3 = (_1.0: (i32, i32)); + _3 = copy (_1.0: (i32, i32)); StorageLive(_4); - _4 = (_1.1: i32); + _4 = copy (_1.1: i32); goto -> bb13; } bb10: { StorageLive(_3); - _3 = (_1.0: (i32, i32)); + _3 = copy (_1.0: (i32, i32)); StorageLive(_4); - _4 = (_1.1: i32); + _4 = copy (_1.1: i32); goto -> bb13; } bb11: { StorageLive(_3); - _3 = (_1.0: (i32, i32)); + _3 = copy (_1.0: (i32, i32)); StorageLive(_4); - _4 = (_1.1: i32); + _4 = copy (_1.1: i32); goto -> bb13; } bb12: { StorageLive(_3); - _3 = (_1.0: (i32, i32)); + _3 = copy (_1.0: (i32, i32)); StorageLive(_4); - _4 = (_1.1: i32); + _4 = copy (_1.1: i32); goto -> bb13; } diff --git a/tests/mir-opt/or_pattern.single_switchint.SimplifyCfg-initial.after.mir b/tests/mir-opt/or_pattern.single_switchint.SimplifyCfg-initial.after.mir index 8b0ef7b29d7b..889ff6f9f5e2 100644 --- a/tests/mir-opt/or_pattern.single_switchint.SimplifyCfg-initial.after.mir +++ b/tests/mir-opt/or_pattern.single_switchint.SimplifyCfg-initial.after.mir @@ -10,15 +10,15 @@ fn single_switchint() -> () { StorageLive(_2); _2 = (const 1_i32, const true); PlaceMention(_2); - switchInt((_2.0: i32)) -> [1: bb2, 2: bb4, otherwise: bb1]; + switchInt(copy (_2.0: i32)) -> [1: bb2, 2: bb4, otherwise: bb1]; } bb1: { - switchInt((_2.0: i32)) -> [3: bb8, 4: bb8, otherwise: bb7]; + switchInt(copy (_2.0: i32)) -> [3: bb8, 4: bb8, otherwise: bb7]; } bb2: { - switchInt((_2.1: bool)) -> [0: bb6, otherwise: bb3]; + switchInt(copy (_2.1: bool)) -> [0: bb6, otherwise: bb3]; } bb3: { @@ -26,7 +26,7 @@ fn single_switchint() -> () { } bb4: { - switchInt((_2.1: bool)) -> [0: bb5, otherwise: bb6]; + switchInt(copy (_2.1: bool)) -> [0: bb5, otherwise: bb6]; } bb5: { diff --git a/tests/mir-opt/pre-codegen/chained_comparison.bitand.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/chained_comparison.bitand.PreCodegen.after.mir index 99ca659c637b..9b77bdb7cf61 100644 --- a/tests/mir-opt/pre-codegen/chained_comparison.bitand.PreCodegen.after.mir +++ b/tests/mir-opt/pre-codegen/chained_comparison.bitand.PreCodegen.after.mir @@ -29,17 +29,17 @@ fn bitand(_1: &Blueprint, _2: &Blueprint) -> bool { StorageLive(_9); StorageLive(_5); StorageLive(_3); - _3 = ((*_1).0: u32); + _3 = copy ((*_1).0: u32); StorageLive(_4); - _4 = ((*_2).0: u32); + _4 = copy ((*_2).0: u32); _5 = Eq(move _3, move _4); StorageDead(_4); StorageDead(_3); StorageLive(_8); StorageLive(_6); - _6 = ((*_1).1: u32); + _6 = copy ((*_1).1: u32); StorageLive(_7); - _7 = ((*_2).1: u32); + _7 = copy ((*_2).1: u32); _8 = Eq(move _6, move _7); StorageDead(_7); StorageDead(_6); @@ -48,9 +48,9 @@ fn bitand(_1: &Blueprint, _2: &Blueprint) -> bool { StorageDead(_5); StorageLive(_12); StorageLive(_10); - _10 = ((*_1).2: u32); + _10 = copy ((*_1).2: u32); StorageLive(_11); - _11 = ((*_2).2: u32); + _11 = copy ((*_2).2: u32); _12 = Eq(move _10, move _11); StorageDead(_11); StorageDead(_10); @@ -59,9 +59,9 @@ fn bitand(_1: &Blueprint, _2: &Blueprint) -> bool { StorageDead(_9); StorageLive(_16); StorageLive(_14); - _14 = ((*_1).3: u32); + _14 = copy ((*_1).3: u32); StorageLive(_15); - _15 = ((*_2).3: u32); + _15 = copy ((*_2).3: u32); _16 = Eq(move _14, move _15); StorageDead(_15); StorageDead(_14); @@ -70,9 +70,9 @@ fn bitand(_1: &Blueprint, _2: &Blueprint) -> bool { StorageDead(_13); StorageLive(_20); StorageLive(_18); - _18 = ((*_1).4: u32); + _18 = copy ((*_1).4: u32); StorageLive(_19); - _19 = ((*_2).4: u32); + _19 = copy ((*_2).4: u32); _20 = Eq(move _18, move _19); StorageDead(_19); StorageDead(_18); diff --git a/tests/mir-opt/pre-codegen/chained_comparison.naive.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/chained_comparison.naive.PreCodegen.after.mir index 838e30fa35eb..9b3e28ab5b8e 100644 --- a/tests/mir-opt/pre-codegen/chained_comparison.naive.PreCodegen.after.mir +++ b/tests/mir-opt/pre-codegen/chained_comparison.naive.PreCodegen.after.mir @@ -22,9 +22,9 @@ fn naive(_1: &Blueprint, _2: &Blueprint) -> bool { bb0: { StorageLive(_5); StorageLive(_3); - _3 = ((*_1).0: u32); + _3 = copy ((*_1).0: u32); StorageLive(_4); - _4 = ((*_2).0: u32); + _4 = copy ((*_2).0: u32); _5 = Eq(move _3, move _4); switchInt(move _5) -> [0: bb1, otherwise: bb2]; } @@ -40,9 +40,9 @@ fn naive(_1: &Blueprint, _2: &Blueprint) -> bool { StorageDead(_3); StorageLive(_8); StorageLive(_6); - _6 = ((*_1).1: u32); + _6 = copy ((*_1).1: u32); StorageLive(_7); - _7 = ((*_2).1: u32); + _7 = copy ((*_2).1: u32); _8 = Eq(move _6, move _7); switchInt(move _8) -> [0: bb3, otherwise: bb4]; } @@ -58,9 +58,9 @@ fn naive(_1: &Blueprint, _2: &Blueprint) -> bool { StorageDead(_6); StorageLive(_11); StorageLive(_9); - _9 = ((*_1).2: u32); + _9 = copy ((*_1).2: u32); StorageLive(_10); - _10 = ((*_2).2: u32); + _10 = copy ((*_2).2: u32); _11 = Eq(move _9, move _10); switchInt(move _11) -> [0: bb5, otherwise: bb6]; } @@ -76,9 +76,9 @@ fn naive(_1: &Blueprint, _2: &Blueprint) -> bool { StorageDead(_9); StorageLive(_14); StorageLive(_12); - _12 = ((*_1).3: u32); + _12 = copy ((*_1).3: u32); StorageLive(_13); - _13 = ((*_2).3: u32); + _13 = copy ((*_2).3: u32); _14 = Eq(move _12, move _13); switchInt(move _14) -> [0: bb7, otherwise: bb9]; } @@ -98,9 +98,9 @@ fn naive(_1: &Blueprint, _2: &Blueprint) -> bool { StorageDead(_13); StorageDead(_12); StorageLive(_15); - _15 = ((*_1).4: u32); + _15 = copy ((*_1).4: u32); StorageLive(_16); - _16 = ((*_2).4: u32); + _16 = copy ((*_2).4: u32); _0 = Eq(move _15, move _16); StorageDead(_16); StorageDead(_15); diff --git a/tests/mir-opt/pre-codegen/chained_comparison.returning.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/chained_comparison.returning.PreCodegen.after.mir index 8452fa12f31d..72d52701d112 100644 --- a/tests/mir-opt/pre-codegen/chained_comparison.returning.PreCodegen.after.mir +++ b/tests/mir-opt/pre-codegen/chained_comparison.returning.PreCodegen.after.mir @@ -23,9 +23,9 @@ fn returning(_1: &Blueprint, _2: &Blueprint) -> bool { bb0: { StorageLive(_5); StorageLive(_3); - _3 = ((*_1).0: u32); + _3 = copy ((*_1).0: u32); StorageLive(_4); - _4 = ((*_2).0: u32); + _4 = copy ((*_2).0: u32); _5 = Ne(move _3, move _4); switchInt(move _5) -> [0: bb1, otherwise: bb10]; } @@ -36,9 +36,9 @@ fn returning(_1: &Blueprint, _2: &Blueprint) -> bool { StorageDead(_5); StorageLive(_8); StorageLive(_6); - _6 = ((*_1).1: u32); + _6 = copy ((*_1).1: u32); StorageLive(_7); - _7 = ((*_2).1: u32); + _7 = copy ((*_2).1: u32); _8 = Ne(move _6, move _7); switchInt(move _8) -> [0: bb2, otherwise: bb9]; } @@ -49,9 +49,9 @@ fn returning(_1: &Blueprint, _2: &Blueprint) -> bool { StorageDead(_8); StorageLive(_11); StorageLive(_9); - _9 = ((*_1).2: u32); + _9 = copy ((*_1).2: u32); StorageLive(_10); - _10 = ((*_2).2: u32); + _10 = copy ((*_2).2: u32); _11 = Ne(move _9, move _10); switchInt(move _11) -> [0: bb3, otherwise: bb8]; } @@ -62,9 +62,9 @@ fn returning(_1: &Blueprint, _2: &Blueprint) -> bool { StorageDead(_11); StorageLive(_14); StorageLive(_12); - _12 = ((*_1).3: u32); + _12 = copy ((*_1).3: u32); StorageLive(_13); - _13 = ((*_2).3: u32); + _13 = copy ((*_2).3: u32); _14 = Ne(move _12, move _13); switchInt(move _14) -> [0: bb4, otherwise: bb7]; } @@ -75,9 +75,9 @@ fn returning(_1: &Blueprint, _2: &Blueprint) -> bool { StorageDead(_14); StorageLive(_17); StorageLive(_15); - _15 = ((*_1).4: u32); + _15 = copy ((*_1).4: u32); StorageLive(_16); - _16 = ((*_2).4: u32); + _16 = copy ((*_2).4: u32); _17 = Ne(move _15, move _16); switchInt(move _17) -> [0: bb5, otherwise: bb6]; } diff --git a/tests/mir-opt/pre-codegen/checked_ops.checked_shl.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/checked_ops.checked_shl.PreCodegen.after.panic-abort.mir index 4edf0d2c47c0..a9dd8886577d 100644 --- a/tests/mir-opt/pre-codegen/checked_ops.checked_shl.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/checked_ops.checked_shl.PreCodegen.after.panic-abort.mir @@ -17,7 +17,7 @@ fn checked_shl(_1: u32, _2: u32) -> Option { bb0: { StorageLive(_3); - _3 = Lt(_2, const core::num::::BITS); + _3 = Lt(copy _2, const core::num::::BITS); switchInt(move _3) -> [0: bb1, otherwise: bb2]; } @@ -28,7 +28,7 @@ fn checked_shl(_1: u32, _2: u32) -> Option { bb2: { StorageLive(_4); - _4 = ShlUnchecked(_1, _2); + _4 = ShlUnchecked(copy _1, copy _2); _0 = Option::::Some(move _4); StorageDead(_4); goto -> bb3; diff --git a/tests/mir-opt/pre-codegen/checked_ops.checked_shl.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/checked_ops.checked_shl.PreCodegen.after.panic-unwind.mir index 4edf0d2c47c0..a9dd8886577d 100644 --- a/tests/mir-opt/pre-codegen/checked_ops.checked_shl.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/checked_ops.checked_shl.PreCodegen.after.panic-unwind.mir @@ -17,7 +17,7 @@ fn checked_shl(_1: u32, _2: u32) -> Option { bb0: { StorageLive(_3); - _3 = Lt(_2, const core::num::::BITS); + _3 = Lt(copy _2, const core::num::::BITS); switchInt(move _3) -> [0: bb1, otherwise: bb2]; } @@ -28,7 +28,7 @@ fn checked_shl(_1: u32, _2: u32) -> Option { bb2: { StorageLive(_4); - _4 = ShlUnchecked(_1, _2); + _4 = ShlUnchecked(copy _1, copy _2); _0 = Option::::Some(move _4); StorageDead(_4); goto -> bb3; diff --git a/tests/mir-opt/pre-codegen/checked_ops.step_forward.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/checked_ops.step_forward.PreCodegen.after.panic-abort.mir index 69c11ebcacce..935e67fc3c0a 100644 --- a/tests/mir-opt/pre-codegen/checked_ops.step_forward.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/checked_ops.step_forward.PreCodegen.after.panic-abort.mir @@ -32,18 +32,18 @@ fn step_forward(_1: u16, _2: usize) -> u16 { bb0: { StorageLive(_4); StorageLive(_3); - _3 = Gt(_2, const 65535_usize); + _3 = Gt(copy _2, const 65535_usize); switchInt(move _3) -> [0: bb1, otherwise: bb5]; } bb1: { - _4 = _2 as u16 (IntToInt); + _4 = copy _2 as u16 (IntToInt); StorageDead(_3); StorageLive(_7); StorageLive(_6); StorageLive(_5); - _5 = AddWithOverflow(_1, _4); - _6 = (_5.1: bool); + _5 = AddWithOverflow(copy _1, copy _4); + _6 = copy (_5.1: bool); _7 = unlikely(move _6) -> [return: bb2, unwind unreachable]; } @@ -76,8 +76,8 @@ fn step_forward(_1: u16, _2: usize) -> u16 { bb7: { StorageLive(_8); - _8 = _2 as u16 (IntToInt); - _0 = Add(_1, _8); + _8 = copy _2 as u16 (IntToInt); + _0 = Add(copy _1, copy _8); StorageDead(_8); StorageDead(_4); return; diff --git a/tests/mir-opt/pre-codegen/checked_ops.step_forward.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/checked_ops.step_forward.PreCodegen.after.panic-unwind.mir index e6ea6c510019..bf1ffd1ef328 100644 --- a/tests/mir-opt/pre-codegen/checked_ops.step_forward.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/checked_ops.step_forward.PreCodegen.after.panic-unwind.mir @@ -32,18 +32,18 @@ fn step_forward(_1: u16, _2: usize) -> u16 { bb0: { StorageLive(_4); StorageLive(_3); - _3 = Gt(_2, const 65535_usize); + _3 = Gt(copy _2, const 65535_usize); switchInt(move _3) -> [0: bb1, otherwise: bb5]; } bb1: { - _4 = _2 as u16 (IntToInt); + _4 = copy _2 as u16 (IntToInt); StorageDead(_3); StorageLive(_7); StorageLive(_6); StorageLive(_5); - _5 = AddWithOverflow(_1, _4); - _6 = (_5.1: bool); + _5 = AddWithOverflow(copy _1, copy _4); + _6 = copy (_5.1: bool); _7 = unlikely(move _6) -> [return: bb2, unwind unreachable]; } @@ -76,8 +76,8 @@ fn step_forward(_1: u16, _2: usize) -> u16 { bb7: { StorageLive(_8); - _8 = _2 as u16 (IntToInt); - _0 = Add(_1, _8); + _8 = copy _2 as u16 (IntToInt); + _0 = Add(copy _1, copy _8); StorageDead(_8); StorageDead(_4); return; diff --git a/tests/mir-opt/pre-codegen/derived_ord.{impl#0}-partial_cmp.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/derived_ord.{impl#0}-partial_cmp.PreCodegen.after.mir index 47f10451b057..5f4ec1de2701 100644 --- a/tests/mir-opt/pre-codegen/derived_ord.{impl#0}-partial_cmp.PreCodegen.after.mir +++ b/tests/mir-opt/pre-codegen/derived_ord.{impl#0}-partial_cmp.PreCodegen.after.mir @@ -22,13 +22,13 @@ fn ::partial_cmp(_1: &MultiField, _2: &M bb0: { StorageLive(_3); - _3 = ((*_1).0: char); + _3 = copy ((*_1).0: char); StorageLive(_4); - _4 = ((*_2).0: char); + _4 = copy ((*_2).0: char); _5 = Cmp(move _3, move _4); StorageDead(_4); StorageDead(_3); - _6 = Option::::Some(_5); + _6 = Option::::Some(copy _5); _7 = discriminant(_5); switchInt(move _7) -> [0: bb1, otherwise: bb2]; } @@ -36,9 +36,9 @@ fn ::partial_cmp(_1: &MultiField, _2: &M bb1: { StorageLive(_10); StorageLive(_8); - _8 = ((*_1).1: i16); + _8 = copy ((*_1).1: i16); StorageLive(_9); - _9 = ((*_2).1: i16); + _9 = copy ((*_2).1: i16); _10 = Cmp(move _8, move _9); StorageDead(_9); StorageDead(_8); @@ -48,7 +48,7 @@ fn ::partial_cmp(_1: &MultiField, _2: &M } bb2: { - _0 = _6; + _0 = copy _6; goto -> bb3; } diff --git a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-abort.diff b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-abort.diff index 30c122ddea03..6cac8b109eea 100644 --- a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-abort.diff +++ b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-abort.diff @@ -73,12 +73,12 @@ StorageLive(_6); StorageLive(_7); _9 = const main::promoted[0]; - _7 = _9; + _7 = copy _9; StorageLive(_8); -- _8 = _1; +- _8 = copy _1; - _6 = std::alloc::Global::alloc_impl(move _7, move _8, const false) -> [return: bb4, unwind unreachable]; + _8 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x00000000): std::ptr::alignment::AlignmentEnum) }}; -+ _6 = std::alloc::Global::alloc_impl(_9, const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x00000000): std::ptr::alignment::AlignmentEnum) }}, const false) -> [return: bb4, unwind unreachable]; ++ _6 = std::alloc::Global::alloc_impl(copy _9, const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x00000000): std::ptr::alignment::AlignmentEnum) }}, const false) -> [return: bb4, unwind unreachable]; } bb4: { @@ -93,7 +93,7 @@ bb5: { StorageLive(_15); _16 = &_13; - _15 = _16 as &dyn std::fmt::Debug (PointerCoercion(Unsize)); + _15 = copy _16 as &dyn std::fmt::Debug (PointerCoercion(Unsize)); _14 = result::unwrap_failed(const "called `Result::unwrap()` on an `Err` value", move _15) -> unwind unreachable; } @@ -104,14 +104,14 @@ StorageDead(_6); - StorageLive(_17); + nop; - _17 = (_5.0: *const [u8]); + _17 = copy (_5.0: *const [u8]); - _4 = move _17 as *mut [u8] (PtrToPtr); - StorageDead(_17); -+ _4 = _17 as *mut [u8] (PtrToPtr); ++ _4 = copy _17 as *mut [u8] (PtrToPtr); + nop; StorageDead(_5); - _3 = move _4 as *mut u8 (PtrToPtr); -+ _3 = _17 as *mut u8 (PtrToPtr); ++ _3 = copy _17 as *mut u8 (PtrToPtr); StorageDead(_4); StorageDead(_3); - StorageDead(_1); diff --git a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-unwind.diff b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-unwind.diff index 93449462c3d0..5fcece2280d4 100644 --- a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-unwind.diff +++ b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-unwind.diff @@ -47,14 +47,14 @@ StorageDead(_6); - StorageLive(_12); + nop; - _12 = (_5.0: *const [u8]); + _12 = copy (_5.0: *const [u8]); - _4 = move _12 as *mut [u8] (PtrToPtr); - StorageDead(_12); -+ _4 = _12 as *mut [u8] (PtrToPtr); ++ _4 = copy _12 as *mut [u8] (PtrToPtr); + nop; StorageDead(_5); - _3 = move _4 as *mut u8 (PtrToPtr); -+ _3 = _12 as *mut u8 (PtrToPtr); ++ _3 = copy _12 as *mut u8 (PtrToPtr); StorageDead(_4); StorageDead(_3); - StorageDead(_1); @@ -81,12 +81,12 @@ StorageLive(_6); StorageLive(_7); _9 = const main::promoted[0]; - _7 = _9; + _7 = copy _9; StorageLive(_8); -- _8 = _1; +- _8 = copy _1; - _6 = std::alloc::Global::alloc_impl(move _7, move _8, const false) -> [return: bb5, unwind continue]; + _8 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x00000000): std::ptr::alignment::AlignmentEnum) }}; -+ _6 = std::alloc::Global::alloc_impl(_9, const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x00000000): std::ptr::alignment::AlignmentEnum) }}, const false) -> [return: bb5, unwind continue]; ++ _6 = std::alloc::Global::alloc_impl(copy _9, const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x00000000): std::ptr::alignment::AlignmentEnum) }}, const false) -> [return: bb5, unwind continue]; } bb5: { diff --git a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff index 44435956ec41..10fde25e3178 100644 --- a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff +++ b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff @@ -73,12 +73,12 @@ StorageLive(_6); StorageLive(_7); _9 = const main::promoted[0]; - _7 = _9; + _7 = copy _9; StorageLive(_8); -- _8 = _1; +- _8 = copy _1; - _6 = std::alloc::Global::alloc_impl(move _7, move _8, const false) -> [return: bb4, unwind unreachable]; + _8 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x0000000000000000): std::ptr::alignment::AlignmentEnum) }}; -+ _6 = std::alloc::Global::alloc_impl(_9, const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x0000000000000000): std::ptr::alignment::AlignmentEnum) }}, const false) -> [return: bb4, unwind unreachable]; ++ _6 = std::alloc::Global::alloc_impl(copy _9, const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x0000000000000000): std::ptr::alignment::AlignmentEnum) }}, const false) -> [return: bb4, unwind unreachable]; } bb4: { @@ -93,7 +93,7 @@ bb5: { StorageLive(_15); _16 = &_13; - _15 = _16 as &dyn std::fmt::Debug (PointerCoercion(Unsize)); + _15 = copy _16 as &dyn std::fmt::Debug (PointerCoercion(Unsize)); _14 = result::unwrap_failed(const "called `Result::unwrap()` on an `Err` value", move _15) -> unwind unreachable; } @@ -104,14 +104,14 @@ StorageDead(_6); - StorageLive(_17); + nop; - _17 = (_5.0: *const [u8]); + _17 = copy (_5.0: *const [u8]); - _4 = move _17 as *mut [u8] (PtrToPtr); - StorageDead(_17); -+ _4 = _17 as *mut [u8] (PtrToPtr); ++ _4 = copy _17 as *mut [u8] (PtrToPtr); + nop; StorageDead(_5); - _3 = move _4 as *mut u8 (PtrToPtr); -+ _3 = _17 as *mut u8 (PtrToPtr); ++ _3 = copy _17 as *mut u8 (PtrToPtr); StorageDead(_4); StorageDead(_3); - StorageDead(_1); diff --git a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-unwind.diff b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-unwind.diff index c958480a9c71..0821ea272bf5 100644 --- a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-unwind.diff +++ b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-unwind.diff @@ -47,14 +47,14 @@ StorageDead(_6); - StorageLive(_12); + nop; - _12 = (_5.0: *const [u8]); + _12 = copy (_5.0: *const [u8]); - _4 = move _12 as *mut [u8] (PtrToPtr); - StorageDead(_12); -+ _4 = _12 as *mut [u8] (PtrToPtr); ++ _4 = copy _12 as *mut [u8] (PtrToPtr); + nop; StorageDead(_5); - _3 = move _4 as *mut u8 (PtrToPtr); -+ _3 = _12 as *mut u8 (PtrToPtr); ++ _3 = copy _12 as *mut u8 (PtrToPtr); StorageDead(_4); StorageDead(_3); - StorageDead(_1); @@ -81,12 +81,12 @@ StorageLive(_6); StorageLive(_7); _9 = const main::promoted[0]; - _7 = _9; + _7 = copy _9; StorageLive(_8); -- _8 = _1; +- _8 = copy _1; - _6 = std::alloc::Global::alloc_impl(move _7, move _8, const false) -> [return: bb5, unwind continue]; + _8 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x0000000000000000): std::ptr::alignment::AlignmentEnum) }}; -+ _6 = std::alloc::Global::alloc_impl(_9, const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x0000000000000000): std::ptr::alignment::AlignmentEnum) }}, const false) -> [return: bb5, unwind continue]; ++ _6 = std::alloc::Global::alloc_impl(copy _9, const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x0000000000000000): std::ptr::alignment::AlignmentEnum) }}, const false) -> [return: bb5, unwind continue]; } bb5: { diff --git a/tests/mir-opt/pre-codegen/loops.filter_mapped.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/loops.filter_mapped.PreCodegen.after.mir index 8d182069adc9..75e8cb1d8618 100644 --- a/tests/mir-opt/pre-codegen/loops.filter_mapped.PreCodegen.after.mir +++ b/tests/mir-opt/pre-codegen/loops.filter_mapped.PreCodegen.after.mir @@ -32,7 +32,7 @@ fn filter_mapped(_1: impl Iterator, _2: impl Fn(T) -> Option) -> () bb1: { StorageLive(_4); - _4 = _3; + _4 = copy _3; goto -> bb2; } diff --git a/tests/mir-opt/pre-codegen/loops.int_range.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/loops.int_range.PreCodegen.after.mir index cdb7eea74fba..be69bbf10e77 100644 --- a/tests/mir-opt/pre-codegen/loops.int_range.PreCodegen.after.mir +++ b/tests/mir-opt/pre-codegen/loops.int_range.PreCodegen.after.mir @@ -41,9 +41,9 @@ fn int_range(_1: usize, _2: usize) -> () { } bb0: { - _3 = std::ops::Range:: { start: _1, end: _2 }; + _3 = std::ops::Range:: { start: copy _1, end: copy _2 }; StorageLive(_4); - _4 = _3; + _4 = copy _3; goto -> bb1; } @@ -57,9 +57,9 @@ fn int_range(_1: usize, _2: usize) -> () { StorageLive(_7); _7 = &(_4.1: usize); StorageLive(_8); - _8 = (_4.0: usize); + _8 = copy (_4.0: usize); StorageLive(_9); - _9 = (_4.1: usize); + _9 = copy (_4.1: usize); _10 = Lt(move _8, move _9); StorageDead(_9); StorageDead(_8); @@ -79,18 +79,18 @@ fn int_range(_1: usize, _2: usize) -> () { bb3: { StorageDead(_7); StorageDead(_6); - _11 = (_4.0: usize); + _11 = copy (_4.0: usize); StorageLive(_12); - _12 = ::forward_unchecked(_11, const 1_usize) -> [return: bb4, unwind continue]; + _12 = ::forward_unchecked(copy _11, const 1_usize) -> [return: bb4, unwind continue]; } bb4: { (_4.0: usize) = move _12; StorageDead(_12); - _13 = Option::::Some(_11); + _13 = Option::::Some(copy _11); StorageDead(_10); StorageDead(_11); - _14 = ((_13 as Some).0: usize); + _14 = copy ((_13 as Some).0: usize); _15 = opaque::(move _14) -> [return: bb5, unwind continue]; } diff --git a/tests/mir-opt/pre-codegen/loops.mapped.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/loops.mapped.PreCodegen.after.mir index 51d41e9ff051..4977f39ccefe 100644 --- a/tests/mir-opt/pre-codegen/loops.mapped.PreCodegen.after.mir +++ b/tests/mir-opt/pre-codegen/loops.mapped.PreCodegen.after.mir @@ -43,7 +43,7 @@ fn mapped(_1: impl Iterator, _2: impl Fn(T) -> U) -> () { bb1: { StorageLive(_4); - _4 = _3; + _4 = copy _3; goto -> bb2; } @@ -84,7 +84,7 @@ fn mapped(_1: impl Iterator, _2: impl Fn(T) -> U) -> () { _10 = move ((_7 as Some).0: T); StorageLive(_12); StorageLive(_11); - _11 = (_10,); + _11 = (copy _10,); _12 = <&mut impl Fn(T) -> U as FnOnce<(T,)>>::call_once(move _8, move _11) -> [return: bb7, unwind: bb10]; } diff --git a/tests/mir-opt/pre-codegen/mem_replace.manual_replace.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/mem_replace.manual_replace.PreCodegen.after.panic-abort.mir index 3ca24e152a4e..c10f3c429627 100644 --- a/tests/mir-opt/pre-codegen/mem_replace.manual_replace.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/mem_replace.manual_replace.PreCodegen.after.panic-abort.mir @@ -9,8 +9,8 @@ fn manual_replace(_1: &mut u32, _2: u32) -> u32 { } bb0: { - _0 = (*_1); - (*_1) = _2; + _0 = copy (*_1); + (*_1) = copy _2; return; } } diff --git a/tests/mir-opt/pre-codegen/mem_replace.manual_replace.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/mem_replace.manual_replace.PreCodegen.after.panic-unwind.mir index 3ca24e152a4e..c10f3c429627 100644 --- a/tests/mir-opt/pre-codegen/mem_replace.manual_replace.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/mem_replace.manual_replace.PreCodegen.after.panic-unwind.mir @@ -9,8 +9,8 @@ fn manual_replace(_1: &mut u32, _2: u32) -> u32 { } bb0: { - _0 = (*_1); - (*_1) = _2; + _0 = copy (*_1); + (*_1) = copy _2; return; } } diff --git a/tests/mir-opt/pre-codegen/mem_replace.mem_replace.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/mem_replace.mem_replace.PreCodegen.after.panic-abort.mir index a3dc54f73c8d..ed494f6e74cf 100644 --- a/tests/mir-opt/pre-codegen/mem_replace.mem_replace.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/mem_replace.mem_replace.PreCodegen.after.panic-abort.mir @@ -14,8 +14,8 @@ fn mem_replace(_1: &mut u32, _2: u32) -> u32 { } bb0: { - _0 = (*_1); - (*_1) = _2; + _0 = copy (*_1); + (*_1) = copy _2; return; } } diff --git a/tests/mir-opt/pre-codegen/mem_replace.mem_replace.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/mem_replace.mem_replace.PreCodegen.after.panic-unwind.mir index a3dc54f73c8d..ed494f6e74cf 100644 --- a/tests/mir-opt/pre-codegen/mem_replace.mem_replace.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/mem_replace.mem_replace.PreCodegen.after.panic-unwind.mir @@ -14,8 +14,8 @@ fn mem_replace(_1: &mut u32, _2: u32) -> u32 { } bb0: { - _0 = (*_1); - (*_1) = _2; + _0 = copy (*_1); + (*_1) = copy _2; return; } } diff --git a/tests/mir-opt/pre-codegen/no_inlined_clone.{impl#0}-clone.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/no_inlined_clone.{impl#0}-clone.PreCodegen.after.mir index 71898daa1bfa..62a9cd9131f0 100644 --- a/tests/mir-opt/pre-codegen/no_inlined_clone.{impl#0}-clone.PreCodegen.after.mir +++ b/tests/mir-opt/pre-codegen/no_inlined_clone.{impl#0}-clone.PreCodegen.after.mir @@ -7,7 +7,7 @@ fn ::clone(_1: &Foo) -> Foo { bb0: { StorageLive(_2); - _2 = ((*_1).0: i32); + _2 = copy ((*_1).0: i32); _0 = Foo { a: move _2 }; StorageDead(_2); return; diff --git a/tests/mir-opt/pre-codegen/optimizes_into_variable.main.GVN.32bit.panic-abort.diff b/tests/mir-opt/pre-codegen/optimizes_into_variable.main.GVN.32bit.panic-abort.diff index 45b8d89c0f4f..6575610727b9 100644 --- a/tests/mir-opt/pre-codegen/optimizes_into_variable.main.GVN.32bit.panic-abort.diff +++ b/tests/mir-opt/pre-codegen/optimizes_into_variable.main.GVN.32bit.panic-abort.diff @@ -39,21 +39,21 @@ StorageLive(_5); _5 = const 3_usize; _6 = const 6_usize; -- _7 = Lt(_5, _6); -- assert(move _7, "index out of bounds: the length is {} but the index is {}", move _6, _5) -> [success: bb2, unwind unreachable]; +- _7 = Lt(copy _5, copy _6); +- assert(move _7, "index out of bounds: the length is {} but the index is {}", move _6, copy _5) -> [success: bb2, unwind unreachable]; + _7 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 6_usize, const 3_usize) -> [success: bb2, unwind unreachable]; } bb2: { -- _3 = _4[_5]; +- _3 = copy _4[_5]; + _3 = const 3_i32; StorageDead(_5); StorageDead(_4); StorageLive(_8); StorageLive(_9); _9 = const 42_u32; -- _8 = _9; +- _8 = copy _9; + _8 = const 42_u32; StorageDead(_9); StorageDead(_8); diff --git a/tests/mir-opt/pre-codegen/optimizes_into_variable.main.GVN.32bit.panic-unwind.diff b/tests/mir-opt/pre-codegen/optimizes_into_variable.main.GVN.32bit.panic-unwind.diff index e6ee1e6f9a34..1a4ed5767fec 100644 --- a/tests/mir-opt/pre-codegen/optimizes_into_variable.main.GVN.32bit.panic-unwind.diff +++ b/tests/mir-opt/pre-codegen/optimizes_into_variable.main.GVN.32bit.panic-unwind.diff @@ -39,21 +39,21 @@ StorageLive(_5); _5 = const 3_usize; _6 = const 6_usize; -- _7 = Lt(_5, _6); -- assert(move _7, "index out of bounds: the length is {} but the index is {}", move _6, _5) -> [success: bb2, unwind continue]; +- _7 = Lt(copy _5, copy _6); +- assert(move _7, "index out of bounds: the length is {} but the index is {}", move _6, copy _5) -> [success: bb2, unwind continue]; + _7 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 6_usize, const 3_usize) -> [success: bb2, unwind continue]; } bb2: { -- _3 = _4[_5]; +- _3 = copy _4[_5]; + _3 = const 3_i32; StorageDead(_5); StorageDead(_4); StorageLive(_8); StorageLive(_9); _9 = const 42_u32; -- _8 = _9; +- _8 = copy _9; + _8 = const 42_u32; StorageDead(_9); StorageDead(_8); diff --git a/tests/mir-opt/pre-codegen/optimizes_into_variable.main.GVN.64bit.panic-abort.diff b/tests/mir-opt/pre-codegen/optimizes_into_variable.main.GVN.64bit.panic-abort.diff index 45b8d89c0f4f..6575610727b9 100644 --- a/tests/mir-opt/pre-codegen/optimizes_into_variable.main.GVN.64bit.panic-abort.diff +++ b/tests/mir-opt/pre-codegen/optimizes_into_variable.main.GVN.64bit.panic-abort.diff @@ -39,21 +39,21 @@ StorageLive(_5); _5 = const 3_usize; _6 = const 6_usize; -- _7 = Lt(_5, _6); -- assert(move _7, "index out of bounds: the length is {} but the index is {}", move _6, _5) -> [success: bb2, unwind unreachable]; +- _7 = Lt(copy _5, copy _6); +- assert(move _7, "index out of bounds: the length is {} but the index is {}", move _6, copy _5) -> [success: bb2, unwind unreachable]; + _7 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 6_usize, const 3_usize) -> [success: bb2, unwind unreachable]; } bb2: { -- _3 = _4[_5]; +- _3 = copy _4[_5]; + _3 = const 3_i32; StorageDead(_5); StorageDead(_4); StorageLive(_8); StorageLive(_9); _9 = const 42_u32; -- _8 = _9; +- _8 = copy _9; + _8 = const 42_u32; StorageDead(_9); StorageDead(_8); diff --git a/tests/mir-opt/pre-codegen/optimizes_into_variable.main.GVN.64bit.panic-unwind.diff b/tests/mir-opt/pre-codegen/optimizes_into_variable.main.GVN.64bit.panic-unwind.diff index e6ee1e6f9a34..1a4ed5767fec 100644 --- a/tests/mir-opt/pre-codegen/optimizes_into_variable.main.GVN.64bit.panic-unwind.diff +++ b/tests/mir-opt/pre-codegen/optimizes_into_variable.main.GVN.64bit.panic-unwind.diff @@ -39,21 +39,21 @@ StorageLive(_5); _5 = const 3_usize; _6 = const 6_usize; -- _7 = Lt(_5, _6); -- assert(move _7, "index out of bounds: the length is {} but the index is {}", move _6, _5) -> [success: bb2, unwind continue]; +- _7 = Lt(copy _5, copy _6); +- assert(move _7, "index out of bounds: the length is {} but the index is {}", move _6, copy _5) -> [success: bb2, unwind continue]; + _7 = const true; + assert(const true, "index out of bounds: the length is {} but the index is {}", const 6_usize, const 3_usize) -> [success: bb2, unwind continue]; } bb2: { -- _3 = _4[_5]; +- _3 = copy _4[_5]; + _3 = const 3_i32; StorageDead(_5); StorageDead(_4); StorageLive(_8); StorageLive(_9); _9 = const 42_u32; -- _8 = _9; +- _8 = copy _9; + _8 = const 42_u32; StorageDead(_9); StorageDead(_8); diff --git a/tests/mir-opt/pre-codegen/optimizes_into_variable.main.ScalarReplacementOfAggregates.32bit.panic-abort.diff b/tests/mir-opt/pre-codegen/optimizes_into_variable.main.ScalarReplacementOfAggregates.32bit.panic-abort.diff index c01a12eaa4f2..e2420a341e0a 100644 --- a/tests/mir-opt/pre-codegen/optimizes_into_variable.main.ScalarReplacementOfAggregates.32bit.panic-abort.diff +++ b/tests/mir-opt/pre-codegen/optimizes_into_variable.main.ScalarReplacementOfAggregates.32bit.panic-abort.diff @@ -38,18 +38,18 @@ StorageLive(_5); _5 = const 3_usize; _6 = const 6_usize; - _7 = Lt(_5, _6); - assert(move _7, "index out of bounds: the length is {} but the index is {}", move _6, _5) -> [success: bb2, unwind unreachable]; + _7 = Lt(copy _5, copy _6); + assert(move _7, "index out of bounds: the length is {} but the index is {}", move _6, copy _5) -> [success: bb2, unwind unreachable]; } bb2: { - _3 = _4[_5]; + _3 = copy _4[_5]; StorageDead(_5); StorageDead(_4); StorageLive(_8); - StorageLive(_9); - _9 = Point { x: const 12_u32, y: const 42_u32 }; -- _8 = (_9.1: u32); +- _8 = copy (_9.1: u32); - StorageDead(_9); + StorageLive(_10); + StorageLive(_11); @@ -57,7 +57,7 @@ + _10 = const 12_u32; + _11 = const 42_u32; + nop; -+ _8 = _11; ++ _8 = copy _11; + StorageDead(_10); + StorageDead(_11); + nop; diff --git a/tests/mir-opt/pre-codegen/optimizes_into_variable.main.ScalarReplacementOfAggregates.32bit.panic-unwind.diff b/tests/mir-opt/pre-codegen/optimizes_into_variable.main.ScalarReplacementOfAggregates.32bit.panic-unwind.diff index 64028e4437be..a2fb3b979e62 100644 --- a/tests/mir-opt/pre-codegen/optimizes_into_variable.main.ScalarReplacementOfAggregates.32bit.panic-unwind.diff +++ b/tests/mir-opt/pre-codegen/optimizes_into_variable.main.ScalarReplacementOfAggregates.32bit.panic-unwind.diff @@ -38,18 +38,18 @@ StorageLive(_5); _5 = const 3_usize; _6 = const 6_usize; - _7 = Lt(_5, _6); - assert(move _7, "index out of bounds: the length is {} but the index is {}", move _6, _5) -> [success: bb2, unwind continue]; + _7 = Lt(copy _5, copy _6); + assert(move _7, "index out of bounds: the length is {} but the index is {}", move _6, copy _5) -> [success: bb2, unwind continue]; } bb2: { - _3 = _4[_5]; + _3 = copy _4[_5]; StorageDead(_5); StorageDead(_4); StorageLive(_8); - StorageLive(_9); - _9 = Point { x: const 12_u32, y: const 42_u32 }; -- _8 = (_9.1: u32); +- _8 = copy (_9.1: u32); - StorageDead(_9); + StorageLive(_10); + StorageLive(_11); @@ -57,7 +57,7 @@ + _10 = const 12_u32; + _11 = const 42_u32; + nop; -+ _8 = _11; ++ _8 = copy _11; + StorageDead(_10); + StorageDead(_11); + nop; diff --git a/tests/mir-opt/pre-codegen/optimizes_into_variable.main.ScalarReplacementOfAggregates.64bit.panic-abort.diff b/tests/mir-opt/pre-codegen/optimizes_into_variable.main.ScalarReplacementOfAggregates.64bit.panic-abort.diff index c01a12eaa4f2..e2420a341e0a 100644 --- a/tests/mir-opt/pre-codegen/optimizes_into_variable.main.ScalarReplacementOfAggregates.64bit.panic-abort.diff +++ b/tests/mir-opt/pre-codegen/optimizes_into_variable.main.ScalarReplacementOfAggregates.64bit.panic-abort.diff @@ -38,18 +38,18 @@ StorageLive(_5); _5 = const 3_usize; _6 = const 6_usize; - _7 = Lt(_5, _6); - assert(move _7, "index out of bounds: the length is {} but the index is {}", move _6, _5) -> [success: bb2, unwind unreachable]; + _7 = Lt(copy _5, copy _6); + assert(move _7, "index out of bounds: the length is {} but the index is {}", move _6, copy _5) -> [success: bb2, unwind unreachable]; } bb2: { - _3 = _4[_5]; + _3 = copy _4[_5]; StorageDead(_5); StorageDead(_4); StorageLive(_8); - StorageLive(_9); - _9 = Point { x: const 12_u32, y: const 42_u32 }; -- _8 = (_9.1: u32); +- _8 = copy (_9.1: u32); - StorageDead(_9); + StorageLive(_10); + StorageLive(_11); @@ -57,7 +57,7 @@ + _10 = const 12_u32; + _11 = const 42_u32; + nop; -+ _8 = _11; ++ _8 = copy _11; + StorageDead(_10); + StorageDead(_11); + nop; diff --git a/tests/mir-opt/pre-codegen/optimizes_into_variable.main.ScalarReplacementOfAggregates.64bit.panic-unwind.diff b/tests/mir-opt/pre-codegen/optimizes_into_variable.main.ScalarReplacementOfAggregates.64bit.panic-unwind.diff index 64028e4437be..a2fb3b979e62 100644 --- a/tests/mir-opt/pre-codegen/optimizes_into_variable.main.ScalarReplacementOfAggregates.64bit.panic-unwind.diff +++ b/tests/mir-opt/pre-codegen/optimizes_into_variable.main.ScalarReplacementOfAggregates.64bit.panic-unwind.diff @@ -38,18 +38,18 @@ StorageLive(_5); _5 = const 3_usize; _6 = const 6_usize; - _7 = Lt(_5, _6); - assert(move _7, "index out of bounds: the length is {} but the index is {}", move _6, _5) -> [success: bb2, unwind continue]; + _7 = Lt(copy _5, copy _6); + assert(move _7, "index out of bounds: the length is {} but the index is {}", move _6, copy _5) -> [success: bb2, unwind continue]; } bb2: { - _3 = _4[_5]; + _3 = copy _4[_5]; StorageDead(_5); StorageDead(_4); StorageLive(_8); - StorageLive(_9); - _9 = Point { x: const 12_u32, y: const 42_u32 }; -- _8 = (_9.1: u32); +- _8 = copy (_9.1: u32); - StorageDead(_9); + StorageLive(_10); + StorageLive(_11); @@ -57,7 +57,7 @@ + _10 = const 12_u32; + _11 = const 42_u32; + nop; -+ _8 = _11; ++ _8 = copy _11; + StorageDead(_10); + StorageDead(_11); + nop; diff --git a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-abort.mir index 2f6139712ffc..5faa1e210cf4 100644 --- a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-abort.mir @@ -23,12 +23,12 @@ fn demo_byte_add_fat(_1: *const [u32], _2: usize) -> *const [u32] { bb0: { StorageLive(_4); StorageLive(_3); - _3 = _1 as *const u8 (PtrToPtr); - _4 = Offset(_3, _2); + _3 = copy _1 as *const u8 (PtrToPtr); + _4 = Offset(copy _3, copy _2); StorageDead(_3); StorageLive(_5); - _5 = PtrMetadata(_1); - _0 = *const [u32] from (_4, _5); + _5 = PtrMetadata(copy _1); + _0 = *const [u32] from (copy _4, copy _5); StorageDead(_5); StorageDead(_4); return; diff --git a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-unwind.mir index 2f6139712ffc..5faa1e210cf4 100644 --- a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-unwind.mir @@ -23,12 +23,12 @@ fn demo_byte_add_fat(_1: *const [u32], _2: usize) -> *const [u32] { bb0: { StorageLive(_4); StorageLive(_3); - _3 = _1 as *const u8 (PtrToPtr); - _4 = Offset(_3, _2); + _3 = copy _1 as *const u8 (PtrToPtr); + _4 = Offset(copy _3, copy _2); StorageDead(_3); StorageLive(_5); - _5 = PtrMetadata(_1); - _0 = *const [u32] from (_4, _5); + _5 = PtrMetadata(copy _1); + _0 = *const [u32] from (copy _4, copy _5); StorageDead(_5); StorageDead(_4); return; diff --git a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-abort.mir index 8d47e63eff2a..9429785045a2 100644 --- a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-abort.mir @@ -22,10 +22,10 @@ fn demo_byte_add_thin(_1: *const u32, _2: usize) -> *const u32 { bb0: { StorageLive(_4); StorageLive(_3); - _3 = _1 as *const u8 (PtrToPtr); - _4 = Offset(_3, _2); + _3 = copy _1 as *const u8 (PtrToPtr); + _4 = Offset(copy _3, copy _2); StorageDead(_3); - _0 = _4 as *const u32 (PtrToPtr); + _0 = copy _4 as *const u32 (PtrToPtr); StorageDead(_4); return; } diff --git a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-unwind.mir index 8d47e63eff2a..9429785045a2 100644 --- a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-unwind.mir @@ -22,10 +22,10 @@ fn demo_byte_add_thin(_1: *const u32, _2: usize) -> *const u32 { bb0: { StorageLive(_4); StorageLive(_3); - _3 = _1 as *const u8 (PtrToPtr); - _4 = Offset(_3, _2); + _3 = copy _1 as *const u8 (PtrToPtr); + _4 = Offset(copy _3, copy _2); StorageDead(_3); - _0 = _4 as *const u32 (PtrToPtr); + _0 = copy _4 as *const u32 (PtrToPtr); StorageDead(_4); return; } diff --git a/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-abort.mir index 96b4962854de..5d33c33d73fe 100644 --- a/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-abort.mir @@ -35,7 +35,7 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { bb0: { StorageLive(_4); - _4 = _1; + _4 = copy _1; goto -> bb1; } @@ -44,8 +44,8 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { StorageLive(_7); StorageLive(_6); StorageLive(_5); - _5 = _4; - _6 = Lt(move _5, _2); + _5 = copy _4; + _6 = Lt(move _5, copy _2); StorageDead(_5); switchInt(move _6) -> [0: bb2, otherwise: bb4]; } @@ -63,22 +63,22 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { } bb4: { - _7 = _4; + _7 = copy _4; StorageLive(_8); - _8 = ::forward_unchecked(_7, const 1_usize) -> [return: bb5, unwind unreachable]; + _8 = ::forward_unchecked(copy _7, const 1_usize) -> [return: bb5, unwind unreachable]; } bb5: { _4 = move _8; StorageDead(_8); - _9 = Option::::Some(_7); + _9 = Option::::Some(copy _7); StorageDead(_6); StorageDead(_7); - _10 = ((_9 as Some).0: u32); + _10 = copy ((_9 as Some).0: u32); StorageLive(_11); _11 = &_3; StorageLive(_12); - _12 = (_10,); + _12 = (copy _10,); _13 = >::call(move _11, move _12) -> [return: bb6, unwind unreachable]; } diff --git a/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-unwind.mir index ce8e2bd083ed..ded30a155203 100644 --- a/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-unwind.mir @@ -35,7 +35,7 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { bb0: { StorageLive(_4); - _4 = _1; + _4 = copy _1; goto -> bb1; } @@ -44,8 +44,8 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { StorageLive(_7); StorageLive(_6); StorageLive(_5); - _5 = _4; - _6 = Lt(move _5, _2); + _5 = copy _4; + _6 = Lt(move _5, copy _2); StorageDead(_5); switchInt(move _6) -> [0: bb2, otherwise: bb4]; } @@ -63,22 +63,22 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { } bb4: { - _7 = _4; + _7 = copy _4; StorageLive(_8); - _8 = ::forward_unchecked(_7, const 1_usize) -> [return: bb5, unwind: bb7]; + _8 = ::forward_unchecked(copy _7, const 1_usize) -> [return: bb5, unwind: bb7]; } bb5: { _4 = move _8; StorageDead(_8); - _9 = Option::::Some(_7); + _9 = Option::::Some(copy _7); StorageDead(_6); StorageDead(_7); - _10 = ((_9 as Some).0: u32); + _10 = copy ((_9 as Some).0: u32); StorageLive(_11); _11 = &_3; StorageLive(_12); - _12 = (_10,); + _12 = (copy _10,); _13 = >::call(move _11, move _12) -> [return: bb6, unwind: bb7]; } diff --git a/tests/mir-opt/pre-codegen/range_iter.inclusive_loop.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/range_iter.inclusive_loop.PreCodegen.after.panic-abort.mir index a7fe52d8390e..60c0b8afa534 100644 --- a/tests/mir-opt/pre-codegen/range_iter.inclusive_loop.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/range_iter.inclusive_loop.PreCodegen.after.panic-abort.mir @@ -28,9 +28,9 @@ fn inclusive_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { } bb0: { - _4 = RangeInclusive:: { start: _1, end: _2, exhausted: const false }; + _4 = RangeInclusive:: { start: copy _1, end: copy _2, exhausted: const false }; StorageLive(_5); - _5 = _4; + _5 = copy _4; goto -> bb1; } @@ -56,11 +56,11 @@ fn inclusive_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { } bb5: { - _9 = ((_7 as Some).0: u32); + _9 = copy ((_7 as Some).0: u32); StorageLive(_10); _10 = &_3; StorageLive(_11); - _11 = (_9,); + _11 = (copy _9,); _12 = >::call(move _10, move _11) -> [return: bb6, unwind unreachable]; } diff --git a/tests/mir-opt/pre-codegen/range_iter.inclusive_loop.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/range_iter.inclusive_loop.PreCodegen.after.panic-unwind.mir index 3e2bbcd3c916..7145da58ce18 100644 --- a/tests/mir-opt/pre-codegen/range_iter.inclusive_loop.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/range_iter.inclusive_loop.PreCodegen.after.panic-unwind.mir @@ -28,9 +28,9 @@ fn inclusive_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { } bb0: { - _4 = RangeInclusive:: { start: _1, end: _2, exhausted: const false }; + _4 = RangeInclusive:: { start: copy _1, end: copy _2, exhausted: const false }; StorageLive(_5); - _5 = _4; + _5 = copy _4; goto -> bb1; } @@ -56,11 +56,11 @@ fn inclusive_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { } bb5: { - _9 = ((_7 as Some).0: u32); + _9 = copy ((_7 as Some).0: u32); StorageLive(_10); _10 = &_3; StorageLive(_11); - _11 = (_9,); + _11 = (copy _9,); _12 = >::call(move _10, move _11) -> [return: bb6, unwind: bb8]; } diff --git a/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-abort.mir index 2ac7e880ccb5..2621ec675318 100644 --- a/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-abort.mir @@ -21,9 +21,9 @@ fn range_iter_next(_1: &mut std::ops::Range) -> Option { StorageLive(_5); StorageLive(_4); StorageLive(_2); - _2 = ((*_1).0: u32); + _2 = copy ((*_1).0: u32); StorageLive(_3); - _3 = ((*_1).1: u32); + _3 = copy ((*_1).1: u32); _4 = Lt(move _2, move _3); StorageDead(_3); StorageDead(_2); @@ -36,15 +36,15 @@ fn range_iter_next(_1: &mut std::ops::Range) -> Option { } bb2: { - _5 = ((*_1).0: u32); + _5 = copy ((*_1).0: u32); StorageLive(_6); - _6 = ::forward_unchecked(_5, const 1_usize) -> [return: bb3, unwind unreachable]; + _6 = ::forward_unchecked(copy _5, const 1_usize) -> [return: bb3, unwind unreachable]; } bb3: { ((*_1).0: u32) = move _6; StorageDead(_6); - _0 = Option::::Some(_5); + _0 = Option::::Some(copy _5); goto -> bb4; } diff --git a/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-unwind.mir index 60bf644fce6b..338fb4b95232 100644 --- a/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-unwind.mir @@ -21,9 +21,9 @@ fn range_iter_next(_1: &mut std::ops::Range) -> Option { StorageLive(_5); StorageLive(_4); StorageLive(_2); - _2 = ((*_1).0: u32); + _2 = copy ((*_1).0: u32); StorageLive(_3); - _3 = ((*_1).1: u32); + _3 = copy ((*_1).1: u32); _4 = Lt(move _2, move _3); StorageDead(_3); StorageDead(_2); @@ -36,15 +36,15 @@ fn range_iter_next(_1: &mut std::ops::Range) -> Option { } bb2: { - _5 = ((*_1).0: u32); + _5 = copy ((*_1).0: u32); StorageLive(_6); - _6 = ::forward_unchecked(_5, const 1_usize) -> [return: bb3, unwind continue]; + _6 = ::forward_unchecked(copy _5, const 1_usize) -> [return: bb3, unwind continue]; } bb3: { ((*_1).0: u32) = move _6; StorageDead(_6); - _0 = Option::::Some(_5); + _0 = Option::::Some(copy _5); goto -> bb4; } diff --git a/tests/mir-opt/pre-codegen/simple_option_map.ezmap.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/simple_option_map.ezmap.PreCodegen.after.mir index 030f9c3b93e0..cbfc58194cc1 100644 --- a/tests/mir-opt/pre-codegen/simple_option_map.ezmap.PreCodegen.after.mir +++ b/tests/mir-opt/pre-codegen/simple_option_map.ezmap.PreCodegen.after.mir @@ -25,9 +25,9 @@ fn ezmap(_1: Option) -> Option { } bb2: { - _3 = ((_1 as Some).0: i32); + _3 = copy ((_1 as Some).0: i32); StorageLive(_4); - _4 = Add(_3, const 1_i32); + _4 = Add(copy _3, const 1_i32); _0 = Option::::Some(move _4); StorageDead(_4); goto -> bb3; diff --git a/tests/mir-opt/pre-codegen/slice_filter.variant_a-{closure#0}.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/slice_filter.variant_a-{closure#0}.PreCodegen.after.mir index e382f744723e..cbdd194afd3a 100644 --- a/tests/mir-opt/pre-codegen/slice_filter.variant_a-{closure#0}.PreCodegen.after.mir +++ b/tests/mir-opt/pre-codegen/slice_filter.variant_a-{closure#0}.PreCodegen.after.mir @@ -68,7 +68,7 @@ fn variant_a::{closure#0}(_1: &mut {closure@$DIR/slice_filter.rs:7:25: 7:39}, _2 } bb0: { - _3 = (*_2); + _3 = copy (*_2); _4 = &((*_3).0: usize); _5 = &((*_3).1: usize); _6 = &((*_3).2: usize); @@ -78,11 +78,11 @@ fn variant_a::{closure#0}(_1: &mut {closure@$DIR/slice_filter.rs:7:25: 7:39}, _2 _8 = &_4; StorageLive(_10); StorageLive(_9); - _9 = _6; + _9 = copy _6; _10 = &_9; - _11 = ((*_3).0: usize); - _12 = ((*_3).2: usize); - _13 = Le(_11, _12); + _11 = copy ((*_3).0: usize); + _12 = copy ((*_3).2: usize); + _13 = Le(copy _11, copy _12); switchInt(move _13) -> [0: bb1, otherwise: bb2]; } @@ -102,12 +102,12 @@ fn variant_a::{closure#0}(_1: &mut {closure@$DIR/slice_filter.rs:7:25: 7:39}, _2 _14 = &_7; StorageLive(_16); StorageLive(_15); - _15 = _5; + _15 = copy _5; _16 = &_15; StorageLive(_17); - _17 = ((*_3).3: usize); + _17 = copy ((*_3).3: usize); StorageLive(_18); - _18 = ((*_3).1: usize); + _18 = copy ((*_3).1: usize); _19 = Le(move _17, move _18); StorageDead(_18); StorageDead(_17); @@ -127,9 +127,9 @@ fn variant_a::{closure#0}(_1: &mut {closure@$DIR/slice_filter.rs:7:25: 7:39}, _2 _20 = &_6; StorageLive(_22); StorageLive(_21); - _21 = _4; + _21 = copy _4; _22 = &_21; - _23 = Le(_12, _11); + _23 = Le(copy _12, copy _11); switchInt(move _23) -> [0: bb5, otherwise: bb6]; } @@ -149,12 +149,12 @@ fn variant_a::{closure#0}(_1: &mut {closure@$DIR/slice_filter.rs:7:25: 7:39}, _2 _24 = &_5; StorageLive(_26); StorageLive(_25); - _25 = _7; + _25 = copy _7; _26 = &_25; StorageLive(_27); - _27 = ((*_3).1: usize); + _27 = copy ((*_3).1: usize); StorageLive(_28); - _28 = ((*_3).3: usize); + _28 = copy ((*_3).3: usize); _0 = Le(move _27, move _28); StorageDead(_28); StorageDead(_27); diff --git a/tests/mir-opt/pre-codegen/slice_filter.variant_b-{closure#0}.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/slice_filter.variant_b-{closure#0}.PreCodegen.after.mir index d9e118d879a6..bc7a31d52199 100644 --- a/tests/mir-opt/pre-codegen/slice_filter.variant_b-{closure#0}.PreCodegen.after.mir +++ b/tests/mir-opt/pre-codegen/slice_filter.variant_b-{closure#0}.PreCodegen.after.mir @@ -18,25 +18,25 @@ fn variant_b::{closure#0}(_1: &mut {closure@$DIR/slice_filter.rs:11:25: 11:41}, } bb0: { - _3 = (*_2); - _4 = ((*_3).0: usize); - _5 = ((*_3).1: usize); - _6 = ((*_3).2: usize); - _7 = ((*_3).3: usize); + _3 = copy (*_2); + _4 = copy ((*_3).0: usize); + _5 = copy ((*_3).1: usize); + _6 = copy ((*_3).2: usize); + _7 = copy ((*_3).3: usize); StorageLive(_8); - _8 = Le(_4, _6); + _8 = Le(copy _4, copy _6); switchInt(move _8) -> [0: bb2, otherwise: bb1]; } bb1: { StorageLive(_9); - _9 = Le(_7, _5); + _9 = Le(copy _7, copy _5); switchInt(move _9) -> [0: bb2, otherwise: bb6]; } bb2: { StorageLive(_10); - _10 = Le(_6, _4); + _10 = Le(copy _6, copy _4); switchInt(move _10) -> [0: bb3, otherwise: bb4]; } @@ -46,7 +46,7 @@ fn variant_b::{closure#0}(_1: &mut {closure@$DIR/slice_filter.rs:11:25: 11:41}, } bb4: { - _0 = Le(_5, _7); + _0 = Le(copy _5, copy _7); goto -> bb5; } diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_get_mut_usize.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_index.slice_get_mut_usize.PreCodegen.after.panic-abort.mir index 58e9b45a4a0f..ec67193bc794 100644 --- a/tests/mir-opt/pre-codegen/slice_index.slice_get_mut_usize.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/slice_index.slice_get_mut_usize.PreCodegen.after.panic-abort.mir @@ -23,8 +23,8 @@ fn slice_get_mut_usize(_1: &mut [u32], _2: usize) -> Option<&mut u32> { StorageLive(_8); StorageLive(_4); StorageLive(_3); - _3 = PtrMetadata(_1); - _4 = Lt(_2, move _3); + _3 = PtrMetadata(copy _1); + _4 = Lt(copy _2, move _3); switchInt(move _4) -> [0: bb1, otherwise: bb2]; } @@ -40,12 +40,12 @@ fn slice_get_mut_usize(_1: &mut [u32], _2: usize) -> Option<&mut u32> { StorageLive(_5); _5 = &raw mut (*_1); StorageLive(_6); - _6 = _5 as *mut u32 (PtrToPtr); - _7 = Offset(_6, _2); + _6 = copy _5 as *mut u32 (PtrToPtr); + _7 = Offset(copy _6, copy _2); StorageDead(_6); StorageDead(_5); _8 = &mut (*_7); - _0 = Option::<&mut u32>::Some(_8); + _0 = Option::<&mut u32>::Some(copy _8); StorageDead(_7); goto -> bb3; } diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_get_mut_usize.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_index.slice_get_mut_usize.PreCodegen.after.panic-unwind.mir index 58e9b45a4a0f..ec67193bc794 100644 --- a/tests/mir-opt/pre-codegen/slice_index.slice_get_mut_usize.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/slice_index.slice_get_mut_usize.PreCodegen.after.panic-unwind.mir @@ -23,8 +23,8 @@ fn slice_get_mut_usize(_1: &mut [u32], _2: usize) -> Option<&mut u32> { StorageLive(_8); StorageLive(_4); StorageLive(_3); - _3 = PtrMetadata(_1); - _4 = Lt(_2, move _3); + _3 = PtrMetadata(copy _1); + _4 = Lt(copy _2, move _3); switchInt(move _4) -> [0: bb1, otherwise: bb2]; } @@ -40,12 +40,12 @@ fn slice_get_mut_usize(_1: &mut [u32], _2: usize) -> Option<&mut u32> { StorageLive(_5); _5 = &raw mut (*_1); StorageLive(_6); - _6 = _5 as *mut u32 (PtrToPtr); - _7 = Offset(_6, _2); + _6 = copy _5 as *mut u32 (PtrToPtr); + _7 = Offset(copy _6, copy _2); StorageDead(_6); StorageDead(_5); _8 = &mut (*_7); - _0 = Option::<&mut u32>::Some(_8); + _0 = Option::<&mut u32>::Some(copy _8); StorageDead(_7); goto -> bb3; } diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-abort.mir index ee80726a675c..220e881f8664 100644 --- a/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-abort.mir @@ -40,19 +40,19 @@ fn slice_get_unchecked_mut_range(_1: &mut [u32], _2: std::ops::Range) -> _5 = &raw mut (*_1); StorageLive(_8); StorageLive(_6); - _6 = PtrMetadata(_1); - _7 = as SliceIndex<[T]>>::get_unchecked_mut::precondition_check(_3, _4, move _6) -> [return: bb1, unwind unreachable]; + _6 = PtrMetadata(copy _1); + _7 = as SliceIndex<[T]>>::get_unchecked_mut::precondition_check(copy _3, copy _4, move _6) -> [return: bb1, unwind unreachable]; } bb1: { StorageDead(_6); - _8 = SubUnchecked(_4, _3); + _8 = SubUnchecked(copy _4, copy _3); StorageLive(_10); StorageLive(_9); - _9 = _5 as *mut u32 (PtrToPtr); - _10 = Offset(_9, _3); + _9 = copy _5 as *mut u32 (PtrToPtr); + _10 = Offset(copy _9, copy _3); StorageDead(_9); - _11 = *mut [u32] from (_10, _8); + _11 = *mut [u32] from (copy _10, copy _8); StorageDead(_10); StorageDead(_8); StorageDead(_5); diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-unwind.mir index ee80726a675c..220e881f8664 100644 --- a/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-unwind.mir @@ -40,19 +40,19 @@ fn slice_get_unchecked_mut_range(_1: &mut [u32], _2: std::ops::Range) -> _5 = &raw mut (*_1); StorageLive(_8); StorageLive(_6); - _6 = PtrMetadata(_1); - _7 = as SliceIndex<[T]>>::get_unchecked_mut::precondition_check(_3, _4, move _6) -> [return: bb1, unwind unreachable]; + _6 = PtrMetadata(copy _1); + _7 = as SliceIndex<[T]>>::get_unchecked_mut::precondition_check(copy _3, copy _4, move _6) -> [return: bb1, unwind unreachable]; } bb1: { StorageDead(_6); - _8 = SubUnchecked(_4, _3); + _8 = SubUnchecked(copy _4, copy _3); StorageLive(_10); StorageLive(_9); - _9 = _5 as *mut u32 (PtrToPtr); - _10 = Offset(_9, _3); + _9 = copy _5 as *mut u32 (PtrToPtr); + _10 = Offset(copy _9, copy _3); StorageDead(_9); - _11 = *mut [u32] from (_10, _8); + _11 = *mut [u32] from (copy _10, copy _8); StorageDead(_10); StorageDead(_8); StorageDead(_5); diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_index_usize.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_index.slice_index_usize.PreCodegen.after.panic-abort.mir index 210f9d6a1240..cc1034229fc3 100644 --- a/tests/mir-opt/pre-codegen/slice_index.slice_index_usize.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/slice_index.slice_index_usize.PreCodegen.after.panic-abort.mir @@ -9,12 +9,12 @@ fn slice_index_usize(_1: &[u32], _2: usize) -> u32 { bb0: { _3 = Len((*_1)); - _4 = Lt(_2, _3); - assert(move _4, "index out of bounds: the length is {} but the index is {}", move _3, _2) -> [success: bb1, unwind unreachable]; + _4 = Lt(copy _2, copy _3); + assert(move _4, "index out of bounds: the length is {} but the index is {}", move _3, copy _2) -> [success: bb1, unwind unreachable]; } bb1: { - _0 = (*_1)[_2]; + _0 = copy (*_1)[_2]; return; } } diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_index_usize.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_index.slice_index_usize.PreCodegen.after.panic-unwind.mir index d576520a8d56..358226fb5294 100644 --- a/tests/mir-opt/pre-codegen/slice_index.slice_index_usize.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/slice_index.slice_index_usize.PreCodegen.after.panic-unwind.mir @@ -9,12 +9,12 @@ fn slice_index_usize(_1: &[u32], _2: usize) -> u32 { bb0: { _3 = Len((*_1)); - _4 = Lt(_2, _3); - assert(move _4, "index out of bounds: the length is {} but the index is {}", move _3, _2) -> [success: bb1, unwind continue]; + _4 = Lt(copy _2, copy _3); + assert(move _4, "index out of bounds: the length is {} but the index is {}", move _3, copy _2) -> [success: bb1, unwind continue]; } bb1: { - _0 = (*_1)[_2]; + _0 = copy (*_1)[_2]; return; } } diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-abort.mir index c61bebe6cc3c..1e0df94b67fb 100644 --- a/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-abort.mir @@ -35,19 +35,19 @@ fn slice_ptr_get_unchecked_range(_1: *const [u32], _2: std::ops::Range) - _4 = move (_2.1: usize); StorageLive(_7); StorageLive(_5); - _5 = PtrMetadata(_1); - _6 = as SliceIndex<[T]>>::get_unchecked::precondition_check(_3, _4, move _5) -> [return: bb1, unwind unreachable]; + _5 = PtrMetadata(copy _1); + _6 = as SliceIndex<[T]>>::get_unchecked::precondition_check(copy _3, copy _4, move _5) -> [return: bb1, unwind unreachable]; } bb1: { StorageDead(_5); - _7 = SubUnchecked(_4, _3); + _7 = SubUnchecked(copy _4, copy _3); StorageLive(_9); StorageLive(_8); - _8 = _1 as *const u32 (PtrToPtr); - _9 = Offset(_8, _3); + _8 = copy _1 as *const u32 (PtrToPtr); + _9 = Offset(copy _8, copy _3); StorageDead(_8); - _0 = *const [u32] from (_9, _7); + _0 = *const [u32] from (copy _9, copy _7); StorageDead(_9); StorageDead(_7); return; diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-unwind.mir index c61bebe6cc3c..1e0df94b67fb 100644 --- a/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-unwind.mir @@ -35,19 +35,19 @@ fn slice_ptr_get_unchecked_range(_1: *const [u32], _2: std::ops::Range) - _4 = move (_2.1: usize); StorageLive(_7); StorageLive(_5); - _5 = PtrMetadata(_1); - _6 = as SliceIndex<[T]>>::get_unchecked::precondition_check(_3, _4, move _5) -> [return: bb1, unwind unreachable]; + _5 = PtrMetadata(copy _1); + _6 = as SliceIndex<[T]>>::get_unchecked::precondition_check(copy _3, copy _4, move _5) -> [return: bb1, unwind unreachable]; } bb1: { StorageDead(_5); - _7 = SubUnchecked(_4, _3); + _7 = SubUnchecked(copy _4, copy _3); StorageLive(_9); StorageLive(_8); - _8 = _1 as *const u32 (PtrToPtr); - _9 = Offset(_8, _3); + _8 = copy _1 as *const u32 (PtrToPtr); + _9 = Offset(copy _8, copy _3); StorageDead(_8); - _0 = *const [u32] from (_9, _7); + _0 = *const [u32] from (copy _9, copy _7); StorageDead(_9); StorageDead(_7); return; diff --git a/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-abort.mir index 953e7550479d..3aa483ed1aef 100644 --- a/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-abort.mir @@ -31,7 +31,7 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { } scope 19 { scope 20 { - scope 26 (inlined as FromResidual>::from_residual) { + scope 26 (inlined as FromResidual>>::from_residual) { } } } @@ -90,10 +90,10 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { StorageLive(_6); StorageLive(_4); StorageLive(_5); - _3 = PtrMetadata(_1); + _3 = PtrMetadata(copy _1); _4 = &raw const (*_1); - _5 = _4 as *const T (PtrToPtr); - _6 = NonNull:: { pointer: _5 }; + _5 = copy _4 as *const T (PtrToPtr); + _6 = NonNull:: { pointer: copy _5 }; StorageLive(_9); switchInt(const ::IS_ZST) -> [0: bb1, otherwise: bb2]; } @@ -101,8 +101,8 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { bb1: { StorageLive(_8); StorageLive(_7); - _7 = _4 as *mut T (PtrToPtr); - _8 = Offset(_7, _3); + _7 = copy _4 as *mut T (PtrToPtr); + _8 = Offset(copy _7, copy _3); StorageDead(_7); _9 = move _8 as *const T (PtrToPtr); StorageDead(_8); @@ -110,24 +110,24 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { } bb2: { - _9 = _3 as *const T (Transmute); + _9 = copy _3 as *const T (Transmute); goto -> bb3; } bb3: { StorageLive(_10); - _10 = _9; - _11 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> }; + _10 = copy _9; + _11 = std::slice::Iter::<'_, T> { ptr: copy _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> }; StorageDead(_10); StorageDead(_9); StorageDead(_5); StorageDead(_4); StorageDead(_6); StorageDead(_3); - _12 = Enumerate::> { iter: _11, count: const 0_usize }; + _12 = Enumerate::> { iter: copy _11, count: const 0_usize }; StorageDead(_11); StorageLive(_13); - _13 = _12; + _13 = copy _12; goto -> bb4; } @@ -166,25 +166,25 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { _17 = move ((_15 as Some).0: &T); StorageDead(_16); StorageDead(_15); - _18 = (_13.1: usize); - _19 = AddWithOverflow((_13.1: usize), const 1_usize); - assert(!move (_19.1: bool), "attempt to compute `{} + {}`, which would overflow", (_13.1: usize), const 1_usize) -> [success: bb9, unwind unreachable]; + _18 = copy (_13.1: usize); + _19 = AddWithOverflow(copy (_13.1: usize), const 1_usize); + assert(!move (_19.1: bool), "attempt to compute `{} + {}`, which would overflow", copy (_13.1: usize), const 1_usize) -> [success: bb9, unwind unreachable]; } bb9: { (_13.1: usize) = move (_19.0: usize); StorageLive(_20); - _20 = (_18, _17); + _20 = (copy _18, copy _17); _21 = Option::<(usize, &T)>::Some(move _20); StorageDead(_20); StorageDead(_19); StorageDead(_18); - _22 = (((_21 as Some).0: (usize, &T)).0: usize); - _23 = (((_21 as Some).0: (usize, &T)).1: &T); + _22 = copy (((_21 as Some).0: (usize, &T)).0: usize); + _23 = copy (((_21 as Some).0: (usize, &T)).1: &T); StorageLive(_24); _24 = &_2; StorageLive(_25); - _25 = (_22, _23); + _25 = (copy _22, copy _23); _26 = >::call(move _24, move _25) -> [return: bb10, unwind unreachable]; } diff --git a/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-unwind.mir index 4c766c6497a2..4cc0aa0ed788 100644 --- a/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-unwind.mir @@ -65,10 +65,10 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { StorageLive(_6); StorageLive(_4); StorageLive(_5); - _3 = PtrMetadata(_1); + _3 = PtrMetadata(copy _1); _4 = &raw const (*_1); - _5 = _4 as *const T (PtrToPtr); - _6 = NonNull:: { pointer: _5 }; + _5 = copy _4 as *const T (PtrToPtr); + _6 = NonNull:: { pointer: copy _5 }; StorageLive(_9); switchInt(const ::IS_ZST) -> [0: bb1, otherwise: bb2]; } @@ -76,8 +76,8 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { bb1: { StorageLive(_8); StorageLive(_7); - _7 = _4 as *mut T (PtrToPtr); - _8 = Offset(_7, _3); + _7 = copy _4 as *mut T (PtrToPtr); + _8 = Offset(copy _7, copy _3); StorageDead(_7); _9 = move _8 as *const T (PtrToPtr); StorageDead(_8); @@ -85,24 +85,24 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { } bb2: { - _9 = _3 as *const T (Transmute); + _9 = copy _3 as *const T (Transmute); goto -> bb3; } bb3: { StorageLive(_10); - _10 = _9; - _11 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> }; + _10 = copy _9; + _11 = std::slice::Iter::<'_, T> { ptr: copy _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> }; StorageDead(_10); StorageDead(_9); StorageDead(_5); StorageDead(_4); StorageDead(_6); StorageDead(_3); - _12 = Enumerate::> { iter: _11, count: const 0_usize }; + _12 = Enumerate::> { iter: copy _11, count: const 0_usize }; StorageDead(_11); StorageLive(_13); - _13 = _12; + _13 = copy _12; goto -> bb4; } @@ -128,12 +128,12 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { } bb8: { - _17 = (((_15 as Some).0: (usize, &T)).0: usize); - _18 = (((_15 as Some).0: (usize, &T)).1: &T); + _17 = copy (((_15 as Some).0: (usize, &T)).0: usize); + _18 = copy (((_15 as Some).0: (usize, &T)).1: &T); StorageLive(_19); _19 = &_2; StorageLive(_20); - _20 = (_17, _18); + _20 = (copy _17, copy _18); _21 = >::call(move _19, move _20) -> [return: bb9, unwind: bb11]; } diff --git a/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-abort.mir index 03de9fd938ec..507afa63c688 100644 --- a/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-abort.mir @@ -57,10 +57,10 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () { StorageLive(_6); StorageLive(_4); StorageLive(_5); - _3 = PtrMetadata(_1); + _3 = PtrMetadata(copy _1); _4 = &raw const (*_1); - _5 = _4 as *const T (PtrToPtr); - _6 = NonNull:: { pointer: _5 }; + _5 = copy _4 as *const T (PtrToPtr); + _6 = NonNull:: { pointer: copy _5 }; StorageLive(_9); switchInt(const ::IS_ZST) -> [0: bb1, otherwise: bb2]; } @@ -68,8 +68,8 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () { bb1: { StorageLive(_8); StorageLive(_7); - _7 = _4 as *mut T (PtrToPtr); - _8 = Offset(_7, _3); + _7 = copy _4 as *mut T (PtrToPtr); + _8 = Offset(copy _7, copy _3); StorageDead(_7); _9 = move _8 as *const T (PtrToPtr); StorageDead(_8); @@ -77,14 +77,14 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () { } bb2: { - _9 = _3 as *const T (Transmute); + _9 = copy _3 as *const T (Transmute); goto -> bb3; } bb3: { StorageLive(_10); - _10 = _9; - _11 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> }; + _10 = copy _9; + _11 = std::slice::Iter::<'_, T> { ptr: copy _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> }; StorageDead(_10); StorageDead(_9); StorageDead(_5); @@ -92,7 +92,7 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () { StorageDead(_6); StorageDead(_3); StorageLive(_12); - _12 = _11; + _12 = copy _11; goto -> bb4; } @@ -118,11 +118,11 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () { } bb8: { - _16 = ((_14 as Some).0: &T); + _16 = copy ((_14 as Some).0: &T); StorageLive(_17); _17 = &_2; StorageLive(_18); - _18 = (_16,); + _18 = (copy _16,); _19 = >::call(move _17, move _18) -> [return: bb9, unwind unreachable]; } diff --git a/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-unwind.mir index c7c722274f24..a25f12edc28e 100644 --- a/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-unwind.mir @@ -57,10 +57,10 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () { StorageLive(_6); StorageLive(_4); StorageLive(_5); - _3 = PtrMetadata(_1); + _3 = PtrMetadata(copy _1); _4 = &raw const (*_1); - _5 = _4 as *const T (PtrToPtr); - _6 = NonNull:: { pointer: _5 }; + _5 = copy _4 as *const T (PtrToPtr); + _6 = NonNull:: { pointer: copy _5 }; StorageLive(_9); switchInt(const ::IS_ZST) -> [0: bb1, otherwise: bb2]; } @@ -68,8 +68,8 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () { bb1: { StorageLive(_8); StorageLive(_7); - _7 = _4 as *mut T (PtrToPtr); - _8 = Offset(_7, _3); + _7 = copy _4 as *mut T (PtrToPtr); + _8 = Offset(copy _7, copy _3); StorageDead(_7); _9 = move _8 as *const T (PtrToPtr); StorageDead(_8); @@ -77,14 +77,14 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () { } bb2: { - _9 = _3 as *const T (Transmute); + _9 = copy _3 as *const T (Transmute); goto -> bb3; } bb3: { StorageLive(_10); - _10 = _9; - _11 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> }; + _10 = copy _9; + _11 = std::slice::Iter::<'_, T> { ptr: copy _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> }; StorageDead(_10); StorageDead(_9); StorageDead(_5); @@ -92,7 +92,7 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () { StorageDead(_6); StorageDead(_3); StorageLive(_12); - _12 = _11; + _12 = copy _11; goto -> bb4; } @@ -118,11 +118,11 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () { } bb8: { - _16 = ((_14 as Some).0: &T); + _16 = copy ((_14 as Some).0: &T); StorageLive(_17); _17 = &_2; StorageLive(_18); - _18 = (_16,); + _18 = (copy _16,); _19 = >::call(move _17, move _18) -> [return: bb9, unwind: bb11]; } diff --git a/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-abort.mir index cea2fcbcdc0b..ecac03ad0f9d 100644 --- a/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-abort.mir @@ -40,7 +40,7 @@ fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { } bb0: { - _3 = PtrMetadata(_1); + _3 = PtrMetadata(copy _1); StorageLive(_4); _4 = const 0_usize; goto -> bb1; @@ -51,8 +51,8 @@ fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { StorageLive(_7); StorageLive(_6); StorageLive(_5); - _5 = _4; - _6 = Lt(move _5, _3); + _5 = copy _4; + _6 = Lt(move _5, copy _3); StorageDead(_5); switchInt(move _6) -> [0: bb2, otherwise: bb4]; } @@ -70,21 +70,21 @@ fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { } bb4: { - _7 = _4; + _7 = copy _4; StorageLive(_8); - _8 = ::forward_unchecked(_7, const 1_usize) -> [return: bb5, unwind unreachable]; + _8 = ::forward_unchecked(copy _7, const 1_usize) -> [return: bb5, unwind unreachable]; } bb5: { _4 = move _8; StorageDead(_8); - _9 = Option::::Some(_7); + _9 = Option::::Some(copy _7); StorageDead(_6); StorageDead(_7); - _10 = ((_9 as Some).0: usize); + _10 = copy ((_9 as Some).0: usize); _11 = Len((*_1)); - _12 = Lt(_10, _11); - assert(move _12, "index out of bounds: the length is {} but the index is {}", move _11, _10) -> [success: bb6, unwind unreachable]; + _12 = Lt(copy _10, copy _11); + assert(move _12, "index out of bounds: the length is {} but the index is {}", move _11, copy _10) -> [success: bb6, unwind unreachable]; } bb6: { @@ -92,7 +92,7 @@ fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { StorageLive(_14); _14 = &_2; StorageLive(_15); - _15 = (_10, _13); + _15 = (copy _10, copy _13); _16 = >::call(move _14, move _15) -> [return: bb7, unwind unreachable]; } diff --git a/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-unwind.mir index bd658a770ea9..1032473b9b2a 100644 --- a/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-unwind.mir @@ -40,7 +40,7 @@ fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { } bb0: { - _3 = PtrMetadata(_1); + _3 = PtrMetadata(copy _1); StorageLive(_4); _4 = const 0_usize; goto -> bb1; @@ -51,8 +51,8 @@ fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { StorageLive(_7); StorageLive(_6); StorageLive(_5); - _5 = _4; - _6 = Lt(move _5, _3); + _5 = copy _4; + _6 = Lt(move _5, copy _3); StorageDead(_5); switchInt(move _6) -> [0: bb2, otherwise: bb4]; } @@ -70,21 +70,21 @@ fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { } bb4: { - _7 = _4; + _7 = copy _4; StorageLive(_8); - _8 = ::forward_unchecked(_7, const 1_usize) -> [return: bb5, unwind: bb8]; + _8 = ::forward_unchecked(copy _7, const 1_usize) -> [return: bb5, unwind: bb8]; } bb5: { _4 = move _8; StorageDead(_8); - _9 = Option::::Some(_7); + _9 = Option::::Some(copy _7); StorageDead(_6); StorageDead(_7); - _10 = ((_9 as Some).0: usize); + _10 = copy ((_9 as Some).0: usize); _11 = Len((*_1)); - _12 = Lt(_10, _11); - assert(move _12, "index out of bounds: the length is {} but the index is {}", move _11, _10) -> [success: bb6, unwind: bb8]; + _12 = Lt(copy _10, copy _11); + assert(move _12, "index out of bounds: the length is {} but the index is {}", move _11, copy _10) -> [success: bb6, unwind: bb8]; } bb6: { @@ -92,7 +92,7 @@ fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { StorageLive(_14); _14 = &_2; StorageLive(_15); - _15 = (_10, _13); + _15 = (copy _10, copy _13); _16 = >::call(move _14, move _15) -> [return: bb7, unwind: bb8]; } diff --git a/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-abort.mir index fbb887fe76a5..1b397a4e4cdd 100644 --- a/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-abort.mir @@ -65,10 +65,10 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () { StorageLive(_6); StorageLive(_4); StorageLive(_5); - _3 = PtrMetadata(_1); + _3 = PtrMetadata(copy _1); _4 = &raw const (*_1); - _5 = _4 as *const T (PtrToPtr); - _6 = NonNull:: { pointer: _5 }; + _5 = copy _4 as *const T (PtrToPtr); + _6 = NonNull:: { pointer: copy _5 }; StorageLive(_9); switchInt(const ::IS_ZST) -> [0: bb1, otherwise: bb2]; } @@ -76,8 +76,8 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () { bb1: { StorageLive(_8); StorageLive(_7); - _7 = _4 as *mut T (PtrToPtr); - _8 = Offset(_7, _3); + _7 = copy _4 as *mut T (PtrToPtr); + _8 = Offset(copy _7, copy _3); StorageDead(_7); _9 = move _8 as *const T (PtrToPtr); StorageDead(_8); @@ -85,24 +85,24 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () { } bb2: { - _9 = _3 as *const T (Transmute); + _9 = copy _3 as *const T (Transmute); goto -> bb3; } bb3: { StorageLive(_10); - _10 = _9; - _11 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> }; + _10 = copy _9; + _11 = std::slice::Iter::<'_, T> { ptr: copy _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> }; StorageDead(_10); StorageDead(_9); StorageDead(_5); StorageDead(_4); StorageDead(_6); StorageDead(_3); - _12 = Rev::> { iter: _11 }; + _12 = Rev::> { iter: copy _11 }; StorageDead(_11); StorageLive(_13); - _13 = _12; + _13 = copy _12; goto -> bb4; } @@ -130,11 +130,11 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () { } bb8: { - _17 = ((_15 as Some).0: &T); + _17 = copy ((_15 as Some).0: &T); StorageLive(_18); _18 = &_2; StorageLive(_19); - _19 = (_17,); + _19 = (copy _17,); _20 = >::call(move _18, move _19) -> [return: bb9, unwind unreachable]; } diff --git a/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-unwind.mir index db9409f72ab1..77689dd9b513 100644 --- a/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-unwind.mir @@ -65,10 +65,10 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () { StorageLive(_6); StorageLive(_4); StorageLive(_5); - _3 = PtrMetadata(_1); + _3 = PtrMetadata(copy _1); _4 = &raw const (*_1); - _5 = _4 as *const T (PtrToPtr); - _6 = NonNull:: { pointer: _5 }; + _5 = copy _4 as *const T (PtrToPtr); + _6 = NonNull:: { pointer: copy _5 }; StorageLive(_9); switchInt(const ::IS_ZST) -> [0: bb1, otherwise: bb2]; } @@ -76,8 +76,8 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () { bb1: { StorageLive(_8); StorageLive(_7); - _7 = _4 as *mut T (PtrToPtr); - _8 = Offset(_7, _3); + _7 = copy _4 as *mut T (PtrToPtr); + _8 = Offset(copy _7, copy _3); StorageDead(_7); _9 = move _8 as *const T (PtrToPtr); StorageDead(_8); @@ -85,24 +85,24 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () { } bb2: { - _9 = _3 as *const T (Transmute); + _9 = copy _3 as *const T (Transmute); goto -> bb3; } bb3: { StorageLive(_10); - _10 = _9; - _11 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> }; + _10 = copy _9; + _11 = std::slice::Iter::<'_, T> { ptr: copy _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> }; StorageDead(_10); StorageDead(_9); StorageDead(_5); StorageDead(_4); StorageDead(_6); StorageDead(_3); - _12 = Rev::> { iter: _11 }; + _12 = Rev::> { iter: copy _11 }; StorageDead(_11); StorageLive(_13); - _13 = _12; + _13 = copy _12; goto -> bb4; } @@ -130,11 +130,11 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () { } bb8: { - _17 = ((_15 as Some).0: &T); + _17 = copy ((_15 as Some).0: &T); StorageLive(_18); _18 = &_2; StorageLive(_19); - _19 = (_17,); + _19 = (copy _17,); _20 = >::call(move _18, move _19) -> [return: bb9, unwind: bb11]; } diff --git a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_generic_is_empty.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_generic_is_empty.PreCodegen.after.panic-abort.mir index 96e71c298e00..f8b0e749bfc0 100644 --- a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_generic_is_empty.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_generic_is_empty.PreCodegen.after.panic-abort.mir @@ -43,27 +43,27 @@ fn slice_iter_generic_is_empty(_1: &std::slice::Iter<'_, T>) -> bool { StorageLive(_3); StorageLive(_2); _2 = &raw const ((*_1).1: *const T); - _3 = _2 as *const std::ptr::NonNull (PtrToPtr); + _3 = copy _2 as *const std::ptr::NonNull (PtrToPtr); StorageDead(_2); - _4 = (*_3); + _4 = copy (*_3); StorageDead(_3); StorageLive(_6); StorageLive(_7); StorageLive(_5); - _5 = ((*_1).0: std::ptr::NonNull); - _6 = (_5.0: *const T); + _5 = copy ((*_1).0: std::ptr::NonNull); + _6 = copy (_5.0: *const T); StorageDead(_5); - _7 = (_4.0: *const T); - _0 = Eq(_6, _7); + _7 = copy (_4.0: *const T); + _0 = Eq(copy _6, copy _7); StorageDead(_7); StorageDead(_6); goto -> bb3; } bb2: { - _8 = ((*_1).1: *const T); - _9 = _8 as usize (Transmute); - _0 = Eq(_9, const 0_usize); + _8 = copy ((*_1).1: *const T); + _9 = copy _8 as usize (Transmute); + _0 = Eq(copy _9, const 0_usize); goto -> bb3; } diff --git a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_generic_is_empty.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_generic_is_empty.PreCodegen.after.panic-unwind.mir index 96e71c298e00..f8b0e749bfc0 100644 --- a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_generic_is_empty.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_generic_is_empty.PreCodegen.after.panic-unwind.mir @@ -43,27 +43,27 @@ fn slice_iter_generic_is_empty(_1: &std::slice::Iter<'_, T>) -> bool { StorageLive(_3); StorageLive(_2); _2 = &raw const ((*_1).1: *const T); - _3 = _2 as *const std::ptr::NonNull (PtrToPtr); + _3 = copy _2 as *const std::ptr::NonNull (PtrToPtr); StorageDead(_2); - _4 = (*_3); + _4 = copy (*_3); StorageDead(_3); StorageLive(_6); StorageLive(_7); StorageLive(_5); - _5 = ((*_1).0: std::ptr::NonNull); - _6 = (_5.0: *const T); + _5 = copy ((*_1).0: std::ptr::NonNull); + _6 = copy (_5.0: *const T); StorageDead(_5); - _7 = (_4.0: *const T); - _0 = Eq(_6, _7); + _7 = copy (_4.0: *const T); + _0 = Eq(copy _6, copy _7); StorageDead(_7); StorageDead(_6); goto -> bb3; } bb2: { - _8 = ((*_1).1: *const T); - _9 = _8 as usize (Transmute); - _0 = Eq(_9, const 0_usize); + _8 = copy ((*_1).1: *const T); + _9 = copy _8 as usize (Transmute); + _0 = Eq(copy _9, const 0_usize); goto -> bb3; } diff --git a/tests/mir-opt/pre-codegen/spans.outer.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/spans.outer.PreCodegen.after.panic-abort.mir index c76e5315db9f..fe4e2deab870 100644 --- a/tests/mir-opt/pre-codegen/spans.outer.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/spans.outer.PreCodegen.after.panic-abort.mir @@ -10,7 +10,7 @@ fn outer(_1: u8) -> u8 { bb0: { _2 = &_1; // scope 0 at $DIR/spans.rs:11:11: 11:13 - _0 = _1; // scope 1 at $DIR/spans.rs:15:5: 15:7 + _0 = copy _1; // scope 1 at $DIR/spans.rs:15:5: 15:7 return; // scope 0 at $DIR/spans.rs:12:2: 12:2 } } diff --git a/tests/mir-opt/pre-codegen/spans.outer.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/spans.outer.PreCodegen.after.panic-unwind.mir index c76e5315db9f..fe4e2deab870 100644 --- a/tests/mir-opt/pre-codegen/spans.outer.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/spans.outer.PreCodegen.after.panic-unwind.mir @@ -10,7 +10,7 @@ fn outer(_1: u8) -> u8 { bb0: { _2 = &_1; // scope 0 at $DIR/spans.rs:11:11: 11:13 - _0 = _1; // scope 1 at $DIR/spans.rs:15:5: 15:7 + _0 = copy _1; // scope 1 at $DIR/spans.rs:15:5: 15:7 return; // scope 0 at $DIR/spans.rs:12:2: 12:2 } } diff --git a/tests/mir-opt/pre-codegen/try_identity.new.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/try_identity.new.PreCodegen.after.mir index 16d6d9719b64..baa01e28a941 100644 --- a/tests/mir-opt/pre-codegen/try_identity.new.PreCodegen.after.mir +++ b/tests/mir-opt/pre-codegen/try_identity.new.PreCodegen.after.mir @@ -30,18 +30,18 @@ fn new(_1: Result) -> Result { bb1: { _3 = move ((_1 as Ok).0: T); - _4 = ControlFlow::::Continue(_3); + _4 = ControlFlow::::Continue(copy _3); _5 = move ((_4 as Continue).0: T); - _0 = Result::::Ok(_5); + _0 = Result::::Ok(copy _5); StorageDead(_4); goto -> bb3; } bb2: { _6 = move ((_1 as Err).0: E); - _4 = ControlFlow::::Break(_6); + _4 = ControlFlow::::Break(copy _6); _7 = move ((_4 as Break).0: E); - _0 = Result::::Err(_7); + _0 = Result::::Err(copy _7); StorageDead(_4); goto -> bb3; } diff --git a/tests/mir-opt/pre-codegen/try_identity.old.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/try_identity.old.PreCodegen.after.mir index d6883ac9fda0..ac485f485b1c 100644 --- a/tests/mir-opt/pre-codegen/try_identity.old.PreCodegen.after.mir +++ b/tests/mir-opt/pre-codegen/try_identity.old.PreCodegen.after.mir @@ -20,13 +20,13 @@ fn old(_1: Result) -> Result { bb1: { _3 = move ((_1 as Ok).0: T); - _0 = Result::::Ok(_3); + _0 = Result::::Ok(copy _3); goto -> bb3; } bb2: { _4 = move ((_1 as Err).0: E); - _0 = Result::::Err(_4); + _0 = Result::::Err(copy _4); goto -> bb3; } diff --git a/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-abort.mir index 0fe4fd370722..ce1e4a0abd61 100644 --- a/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-abort.mir @@ -78,17 +78,17 @@ fn vec_deref_to_slice(_1: &Vec) -> &[u8] { _3 = &(((*_1).0: alloc::raw_vec::RawVec).0: alloc::raw_vec::RawVecInner); StorageLive(_6); StorageLive(_4); - _4 = (((((*_1).0: alloc::raw_vec::RawVec).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique).0: std::ptr::NonNull); - _5 = (_4.0: *const u8); - _6 = NonNull:: { pointer: _5 }; + _4 = copy (((((*_1).0: alloc::raw_vec::RawVec).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique).0: std::ptr::NonNull); + _5 = copy (_4.0: *const u8); + _6 = NonNull:: { pointer: copy _5 }; StorageDead(_4); StorageDead(_6); StorageDead(_3); StorageDead(_2); StorageLive(_7); - _7 = ((*_1).1: usize); + _7 = copy ((*_1).1: usize); StorageLive(_8); - _8 = *const [u8] from (_5, _7); + _8 = *const [u8] from (copy _5, copy _7); _0 = &(*_8); StorageDead(_8); StorageDead(_7); diff --git a/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-unwind.mir index 0fe4fd370722..ce1e4a0abd61 100644 --- a/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-unwind.mir @@ -78,17 +78,17 @@ fn vec_deref_to_slice(_1: &Vec) -> &[u8] { _3 = &(((*_1).0: alloc::raw_vec::RawVec).0: alloc::raw_vec::RawVecInner); StorageLive(_6); StorageLive(_4); - _4 = (((((*_1).0: alloc::raw_vec::RawVec).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique).0: std::ptr::NonNull); - _5 = (_4.0: *const u8); - _6 = NonNull:: { pointer: _5 }; + _4 = copy (((((*_1).0: alloc::raw_vec::RawVec).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique).0: std::ptr::NonNull); + _5 = copy (_4.0: *const u8); + _6 = NonNull:: { pointer: copy _5 }; StorageDead(_4); StorageDead(_6); StorageDead(_3); StorageDead(_2); StorageLive(_7); - _7 = ((*_1).1: usize); + _7 = copy ((*_1).1: usize); StorageLive(_8); - _8 = *const [u8] from (_5, _7); + _8 = *const [u8] from (copy _5, copy _7); _0 = &(*_8); StorageDead(_8); StorageDead(_7); diff --git a/tests/mir-opt/reference_prop.dominate_storage.ReferencePropagation.diff b/tests/mir-opt/reference_prop.dominate_storage.ReferencePropagation.diff index 012efa9693ec..4715f5110ebb 100644 --- a/tests/mir-opt/reference_prop.dominate_storage.ReferencePropagation.diff +++ b/tests/mir-opt/reference_prop.dominate_storage.ReferencePropagation.diff @@ -21,15 +21,15 @@ } bb2: { - _5 = (*_2); - _0 = opaque::(_5) -> [return: bb3, unwind continue]; + _5 = copy (*_2); + _0 = opaque::(copy _5) -> [return: bb3, unwind continue]; } bb3: { StorageDead(_1); StorageLive(_1); _6 = const true; - switchInt(_6) -> [0: bb3, otherwise: bb1]; + switchInt(copy _6) -> [0: bb3, otherwise: bb1]; } } diff --git a/tests/mir-opt/reference_prop.maybe_dead.ReferencePropagation.diff b/tests/mir-opt/reference_prop.maybe_dead.ReferencePropagation.diff index c6bd6c212109..b1de380d84d4 100644 --- a/tests/mir-opt/reference_prop.maybe_dead.ReferencePropagation.diff +++ b/tests/mir-opt/reference_prop.maybe_dead.ReferencePropagation.diff @@ -19,25 +19,25 @@ _4 = &_2; _5 = &mut _3; (*_5) = const 7_i32; -- _6 = (*_4); -+ _6 = _2; - switchInt(_1) -> [1: bb1, otherwise: bb2]; +- _6 = copy (*_4); ++ _6 = copy _2; + switchInt(copy _1) -> [1: bb1, otherwise: bb2]; } bb1: { StorageDead(_2); StorageDead(_3); - _0 = opaque::(_6) -> [return: bb2, unwind continue]; + _0 = opaque::(copy _6) -> [return: bb2, unwind continue]; } bb2: { - _7 = (*_4); - _0 = opaque::(_7) -> [return: bb3, unwind continue]; + _7 = copy (*_4); + _0 = opaque::(copy _7) -> [return: bb3, unwind continue]; } bb3: { - _8 = (*_5); - _0 = opaque::(_8) -> [return: bb4, unwind continue]; + _8 = copy (*_5); + _0 = opaque::(copy _8) -> [return: bb4, unwind continue]; } bb4: { diff --git a/tests/mir-opt/reference_prop.multiple_storage.ReferencePropagation.diff b/tests/mir-opt/reference_prop.multiple_storage.ReferencePropagation.diff index 0fd74155aa30..2368edea5bac 100644 --- a/tests/mir-opt/reference_prop.multiple_storage.ReferencePropagation.diff +++ b/tests/mir-opt/reference_prop.multiple_storage.ReferencePropagation.diff @@ -13,8 +13,8 @@ _2 = &_1; StorageDead(_1); StorageLive(_1); - _3 = (*_2); - _0 = opaque::(_3) -> [return: bb1, unwind continue]; + _3 = copy (*_2); + _0 = opaque::(copy _3) -> [return: bb1, unwind continue]; } bb1: { diff --git a/tests/mir-opt/reference_prop.mut_raw_then_mut_shr.ReferencePropagation.diff b/tests/mir-opt/reference_prop.mut_raw_then_mut_shr.ReferencePropagation.diff index 859097d3966a..90fd91764cb9 100644 --- a/tests/mir-opt/reference_prop.mut_raw_then_mut_shr.ReferencePropagation.diff +++ b/tests/mir-opt/reference_prop.mut_raw_then_mut_shr.ReferencePropagation.diff @@ -41,23 +41,23 @@ - StorageLive(_5); - _5 = &mut (*_2); - _4 = &raw mut (*_5); -- _3 = _4; +- _3 = copy _4; - StorageDead(_5); - StorageDead(_4); - StorageLive(_6); - _6 = &(*_2); StorageLive(_7); -- _7 = (*_6); +- _7 = copy (*_6); - StorageLive(_8); - (*_3) = const 4_i32; - _8 = const (); - StorageDead(_8); -+ _7 = _1; ++ _7 = copy _1; + _1 = const 4_i32; StorageLive(_9); - _9 = _7; + _9 = copy _7; StorageLive(_10); - _10 = _1; + _10 = copy _1; _0 = (move _9, move _10); StorageDead(_10); StorageDead(_9); diff --git a/tests/mir-opt/reference_prop.read_through_raw.ReferencePropagation.diff b/tests/mir-opt/reference_prop.read_through_raw.ReferencePropagation.diff index 371b0e468b1d..064711925e02 100644 --- a/tests/mir-opt/reference_prop.read_through_raw.ReferencePropagation.diff +++ b/tests/mir-opt/reference_prop.read_through_raw.ReferencePropagation.diff @@ -13,10 +13,10 @@ - _3 = &mut (*_2); - _4 = &raw mut (*_2); - _5 = &raw mut (*_3); -- _0 = (*_4); -- _0 = (*_5); -+ _0 = (*_1); -+ _0 = (*_1); +- _0 = copy (*_4); +- _0 = copy (*_5); ++ _0 = copy (*_1); ++ _0 = copy (*_1); return; } } diff --git a/tests/mir-opt/reference_prop.reference_propagation.ReferencePropagation.diff b/tests/mir-opt/reference_prop.reference_propagation.ReferencePropagation.diff index 0dfe8781c186..3c6a9a9614c3 100644 --- a/tests/mir-opt/reference_prop.reference_propagation.ReferencePropagation.diff +++ b/tests/mir-opt/reference_prop.reference_propagation.ReferencePropagation.diff @@ -191,8 +191,8 @@ StorageLive(_5); _5 = &_4; StorageLive(_6); -- _6 = (*_5); -+ _6 = _4; +- _6 = copy (*_5); ++ _6 = copy _4; StorageLive(_7); StorageLive(_8); _8 = (); @@ -223,7 +223,7 @@ StorageDead(_13); - StorageDead(_14); StorageLive(_15); - _15 = (*_12); + _15 = copy (*_12); StorageLive(_16); StorageLive(_17); _17 = (); @@ -247,11 +247,11 @@ StorageLive(_21); _21 = &_20; StorageLive(_22); -- _22 = (*_20); -+ _22 = _19; +- _22 = copy (*_20); ++ _22 = copy _19; StorageLive(_23); StorageLive(_24); - _24 = _21; + _24 = copy _21; _23 = opaque::<&&usize>(move _24) -> [return: bb3, unwind continue]; } @@ -272,10 +272,10 @@ StorageLive(_28); _28 = &raw mut _27; StorageLive(_29); - _29 = (*_27); + _29 = copy (*_27); StorageLive(_30); StorageLive(_31); - _31 = _28; + _31 = copy _28; _30 = opaque::<*mut &usize>(move _31) -> [return: bb4, unwind continue]; } @@ -294,11 +294,11 @@ StorageLive(_34); _34 = &_33; StorageLive(_35); -- _35 = (*_34); -+ _35 = _33; +- _35 = copy (*_34); ++ _35 = copy _33; StorageLive(_36); StorageLive(_37); - _37 = _34; + _37 = copy _34; _36 = opaque::<&usize>(move _37) -> [return: bb5, unwind continue]; } @@ -316,18 +316,18 @@ StorageLive(_40); _40 = &_39; StorageLive(_41); -- _41 = (*_40); -+ _41 = _39; +- _41 = copy (*_40); ++ _41 = copy _39; StorageLive(_42); - _42 = _40; + _42 = copy _40; StorageLive(_43); -- _43 = (*_42); -+ _43 = _39; +- _43 = copy (*_42); ++ _43 = copy _39; StorageLive(_44); - _44 = _42; + _44 = copy _42; StorageLive(_45); StorageLive(_46); - _46 = _44; + _46 = copy _44; _45 = opaque::<&usize>(move _46) -> [return: bb6, unwind continue]; } @@ -346,8 +346,8 @@ - StorageLive(_48); - _48 = &(*_1); StorageLive(_49); -- _49 = (*_48); -+ _49 = (*_1); +- _49 = copy (*_48); ++ _49 = copy (*_1); StorageLive(_50); StorageLive(_51); _51 = (); @@ -373,7 +373,7 @@ StorageDead(_54); - StorageDead(_55); StorageLive(_56); - _56 = (*_53); + _56 = copy (*_53); StorageLive(_57); StorageLive(_58); _58 = (); @@ -395,8 +395,8 @@ StorageLive(_62); _62 = &_61; StorageLive(_63); -- _63 = (*_61); -+ _63 = _60; +- _63 = copy (*_61); ++ _63 = copy _60; StorageLive(_64); StorageLive(_65); _65 = (); @@ -419,7 +419,7 @@ StorageLive(_68); _68 = &mut _67; StorageLive(_69); - _69 = (*_67); + _69 = copy (*_67); StorageLive(_70); StorageLive(_71); _71 = (); diff --git a/tests/mir-opt/reference_prop.reference_propagation_const_ptr.ReferencePropagation.diff b/tests/mir-opt/reference_prop.reference_propagation_const_ptr.ReferencePropagation.diff index 21486a8616aa..75fe99de9381 100644 --- a/tests/mir-opt/reference_prop.reference_propagation_const_ptr.ReferencePropagation.diff +++ b/tests/mir-opt/reference_prop.reference_propagation_const_ptr.ReferencePropagation.diff @@ -208,8 +208,8 @@ StorageLive(_5); _5 = &raw const _4; StorageLive(_6); -- _6 = (*_5); -+ _6 = _4; +- _6 = copy (*_5); ++ _6 = copy _4; StorageLive(_7); StorageLive(_8); _8 = (); @@ -236,7 +236,7 @@ _12 = move _13; StorageDead(_13); StorageLive(_14); - _14 = (*_12); + _14 = copy (*_12); StorageLive(_15); StorageLive(_16); _16 = (); @@ -260,11 +260,11 @@ StorageLive(_20); _20 = &_19; StorageLive(_21); -- _21 = (*_19); -+ _21 = _18; +- _21 = copy (*_19); ++ _21 = copy _18; StorageLive(_22); StorageLive(_23); - _23 = _20; + _23 = copy _20; _22 = opaque::<&*const usize>(move _23) -> [return: bb3, unwind continue]; } @@ -285,10 +285,10 @@ StorageLive(_27); _27 = &raw mut _26; StorageLive(_28); - _28 = (*_26); + _28 = copy (*_26); StorageLive(_29); StorageLive(_30); - _30 = _27; + _30 = copy _27; _29 = opaque::<*mut *const usize>(move _30) -> [return: bb4, unwind continue]; } @@ -307,11 +307,11 @@ StorageLive(_33); _33 = &raw const _32; StorageLive(_34); -- _34 = (*_33); -+ _34 = _32; +- _34 = copy (*_33); ++ _34 = copy _32; StorageLive(_35); StorageLive(_36); - _36 = _33; + _36 = copy _33; _35 = opaque::<*const usize>(move _36) -> [return: bb5, unwind continue]; } @@ -329,18 +329,18 @@ StorageLive(_39); _39 = &raw const _38; StorageLive(_40); -- _40 = (*_39); -+ _40 = _38; +- _40 = copy (*_39); ++ _40 = copy _38; StorageLive(_41); - _41 = _39; + _41 = copy _39; StorageLive(_42); -- _42 = (*_41); -+ _42 = _38; +- _42 = copy (*_41); ++ _42 = copy _38; StorageLive(_43); - _43 = _41; + _43 = copy _41; StorageLive(_44); StorageLive(_45); - _45 = _43; + _45 = copy _43; _44 = opaque::<*const usize>(move _45) -> [return: bb6, unwind continue]; } @@ -359,8 +359,8 @@ - StorageLive(_47); - _47 = &raw const (*_1); StorageLive(_48); -- _48 = (*_47); -+ _48 = (*_1); +- _48 = copy (*_47); ++ _48 = copy (*_1); StorageLive(_49); StorageLive(_50); _50 = (); @@ -382,7 +382,7 @@ _2 = move _53; StorageDead(_53); StorageLive(_54); - _54 = (*_52); + _54 = copy (*_52); StorageLive(_55); StorageLive(_56); _56 = (); @@ -405,8 +405,8 @@ - _60 = &raw const (*_59); + _60 = &raw const _58; StorageLive(_61); -- _61 = (*_60); -+ _61 = _58; +- _61 = copy (*_60); ++ _61 = copy _58; StorageLive(_62); StorageLive(_63); _63 = (); @@ -430,8 +430,8 @@ StorageLive(_67); _67 = &_66; StorageLive(_68); -- _68 = (*_66); -+ _68 = _65; +- _68 = copy (*_66); ++ _68 = copy _65; StorageLive(_69); StorageLive(_70); _70 = (); @@ -454,7 +454,7 @@ StorageLive(_73); _73 = &mut _72; StorageLive(_74); - _74 = (*_72); + _74 = copy (*_72); StorageLive(_75); StorageLive(_76); _76 = (); diff --git a/tests/mir-opt/reference_prop.reference_propagation_mut.ReferencePropagation.diff b/tests/mir-opt/reference_prop.reference_propagation_mut.ReferencePropagation.diff index 7c7f424bba2b..f35b4974d6eb 100644 --- a/tests/mir-opt/reference_prop.reference_propagation_mut.ReferencePropagation.diff +++ b/tests/mir-opt/reference_prop.reference_propagation_mut.ReferencePropagation.diff @@ -191,8 +191,8 @@ StorageLive(_5); _5 = &mut _4; StorageLive(_6); -- _6 = (*_5); -+ _6 = _4; +- _6 = copy (*_5); ++ _6 = copy _4; StorageLive(_7); StorageLive(_8); _8 = (); @@ -223,7 +223,7 @@ StorageDead(_13); - StorageDead(_14); StorageLive(_15); - _15 = (*_12); + _15 = copy (*_12); StorageLive(_16); StorageLive(_17); _17 = (); @@ -247,10 +247,10 @@ StorageLive(_21); _21 = &_20; StorageLive(_22); - _22 = (*_20); + _22 = copy (*_20); StorageLive(_23); StorageLive(_24); - _24 = _21; + _24 = copy _21; _23 = opaque::<&&mut usize>(move _24) -> [return: bb3, unwind continue]; } @@ -271,10 +271,10 @@ StorageLive(_28); _28 = &raw mut _27; StorageLive(_29); - _29 = (*_27); + _29 = copy (*_27); StorageLive(_30); StorageLive(_31); - _31 = _28; + _31 = copy _28; _30 = opaque::<*mut &mut usize>(move _31) -> [return: bb4, unwind continue]; } @@ -293,7 +293,7 @@ StorageLive(_34); _34 = &mut _33; StorageLive(_35); - _35 = (*_34); + _35 = copy (*_34); StorageLive(_36); StorageLive(_37); _37 = move _34; @@ -314,11 +314,11 @@ StorageLive(_40); _40 = &mut _39; StorageLive(_41); - _41 = (*_40); + _41 = copy (*_40); StorageLive(_42); _42 = move _40; StorageLive(_43); - _43 = (*_42); + _43 = copy (*_42); StorageLive(_44); _44 = move _42; StorageLive(_45); @@ -342,8 +342,8 @@ - StorageLive(_48); - _48 = &mut (*_1); StorageLive(_49); -- _49 = (*_48); -+ _49 = (*_1); +- _49 = copy (*_48); ++ _49 = copy (*_1); StorageLive(_50); StorageLive(_51); _51 = (); @@ -369,7 +369,7 @@ StorageDead(_54); - StorageDead(_55); StorageLive(_56); - _56 = (*_53); + _56 = copy (*_53); StorageLive(_57); StorageLive(_58); _58 = (); @@ -391,7 +391,7 @@ StorageLive(_62); _62 = &_61; StorageLive(_63); - _63 = (*_61); + _63 = copy (*_61); StorageLive(_64); StorageLive(_65); _65 = (); @@ -414,7 +414,7 @@ StorageLive(_68); _68 = &mut _67; StorageLive(_69); - _69 = (*_67); + _69 = copy (*_67); StorageLive(_70); StorageLive(_71); _71 = (); diff --git a/tests/mir-opt/reference_prop.reference_propagation_mut_ptr.ReferencePropagation.diff b/tests/mir-opt/reference_prop.reference_propagation_mut_ptr.ReferencePropagation.diff index 5629d04f1b19..21b322b72187 100644 --- a/tests/mir-opt/reference_prop.reference_propagation_mut_ptr.ReferencePropagation.diff +++ b/tests/mir-opt/reference_prop.reference_propagation_mut_ptr.ReferencePropagation.diff @@ -189,8 +189,8 @@ StorageLive(_5); _5 = &raw mut _4; StorageLive(_6); -- _6 = (*_5); -+ _6 = _4; +- _6 = copy (*_5); ++ _6 = copy _4; StorageLive(_7); StorageLive(_8); _8 = (); @@ -217,7 +217,7 @@ _12 = move _13; StorageDead(_13); StorageLive(_14); - _14 = (*_12); + _14 = copy (*_12); StorageLive(_15); StorageLive(_16); _16 = (); @@ -241,10 +241,10 @@ StorageLive(_20); _20 = &_19; StorageLive(_21); - _21 = (*_19); + _21 = copy (*_19); StorageLive(_22); StorageLive(_23); - _23 = _20; + _23 = copy _20; _22 = opaque::<&*mut usize>(move _23) -> [return: bb3, unwind continue]; } @@ -265,10 +265,10 @@ StorageLive(_27); _27 = &raw mut _26; StorageLive(_28); - _28 = (*_26); + _28 = copy (*_26); StorageLive(_29); StorageLive(_30); - _30 = _27; + _30 = copy _27; _29 = opaque::<*mut *mut usize>(move _30) -> [return: bb4, unwind continue]; } @@ -287,10 +287,10 @@ StorageLive(_33); _33 = &raw mut _32; StorageLive(_34); - _34 = (*_33); + _34 = copy (*_33); StorageLive(_35); StorageLive(_36); - _36 = _33; + _36 = copy _33; _35 = opaque::<*mut usize>(move _36) -> [return: bb5, unwind continue]; } @@ -308,16 +308,16 @@ StorageLive(_39); _39 = &raw mut _38; StorageLive(_40); - _40 = (*_39); + _40 = copy (*_39); StorageLive(_41); - _41 = _39; + _41 = copy _39; StorageLive(_42); - _42 = (*_41); + _42 = copy (*_41); StorageLive(_43); - _43 = _41; + _43 = copy _41; StorageLive(_44); StorageLive(_45); - _45 = _43; + _45 = copy _43; _44 = opaque::<*mut usize>(move _45) -> [return: bb6, unwind continue]; } @@ -336,8 +336,8 @@ - StorageLive(_47); - _47 = &raw mut (*_1); StorageLive(_48); -- _48 = (*_47); -+ _48 = (*_1); +- _48 = copy (*_47); ++ _48 = copy (*_1); StorageLive(_49); StorageLive(_50); _50 = (); @@ -359,7 +359,7 @@ _2 = move _53; StorageDead(_53); StorageLive(_54); - _54 = (*_52); + _54 = copy (*_52); StorageLive(_55); StorageLive(_56); _56 = (); @@ -381,7 +381,7 @@ StorageLive(_60); _60 = &_59; StorageLive(_61); - _61 = (*_59); + _61 = copy (*_59); StorageLive(_62); StorageLive(_63); _63 = (); @@ -404,7 +404,7 @@ StorageLive(_66); _66 = &mut _65; StorageLive(_67); - _67 = (*_65); + _67 = copy (*_65); StorageLive(_68); StorageLive(_69); _69 = (); diff --git a/tests/mir-opt/reference_prop.unique_with_copies.ReferencePropagation.diff b/tests/mir-opt/reference_prop.unique_with_copies.ReferencePropagation.diff index a5427cea1f8e..d2ba9db2b897 100644 --- a/tests/mir-opt/reference_prop.unique_with_copies.ReferencePropagation.diff +++ b/tests/mir-opt/reference_prop.unique_with_copies.ReferencePropagation.diff @@ -29,20 +29,20 @@ _3 = &raw mut _2; StorageLive(_4); StorageLive(_5); - _5 = (*_3); + _5 = copy (*_3); _4 = opaque::(move _5) -> [return: bb1, unwind continue]; } bb1: { StorageDead(_5); StorageDead(_4); -- _1 = _3; +- _1 = copy _3; - StorageDead(_3); StorageDead(_2); StorageLive(_6); StorageLive(_7); -- _7 = (*_1); -+ _7 = (*_3); +- _7 = copy (*_1); ++ _7 = copy (*_3); _6 = opaque::(move _7) -> [return: bb2, unwind continue]; } diff --git a/tests/mir-opt/remove_fake_borrows.match_guard.CleanupPostBorrowck.panic-abort.diff b/tests/mir-opt/remove_fake_borrows.match_guard.CleanupPostBorrowck.panic-abort.diff index d76d65a18a7b..8c6c5e0d9934 100644 --- a/tests/mir-opt/remove_fake_borrows.match_guard.CleanupPostBorrowck.panic-abort.diff +++ b/tests/mir-opt/remove_fake_borrows.match_guard.CleanupPostBorrowck.panic-abort.diff @@ -24,7 +24,7 @@ } bb2: { - switchInt((*(*((_1 as Some).0: &&i32)))) -> [0: bb3, otherwise: bb1]; + switchInt(copy (*(*((_1 as Some).0: &&i32)))) -> [0: bb3, otherwise: bb1]; } bb3: { @@ -42,7 +42,7 @@ + nop; + nop; StorageLive(_8); - _8 = _2; + _8 = copy _2; switchInt(move _8) -> [0: bb6, otherwise: bb5]; } diff --git a/tests/mir-opt/remove_fake_borrows.match_guard.CleanupPostBorrowck.panic-unwind.diff b/tests/mir-opt/remove_fake_borrows.match_guard.CleanupPostBorrowck.panic-unwind.diff index d76d65a18a7b..8c6c5e0d9934 100644 --- a/tests/mir-opt/remove_fake_borrows.match_guard.CleanupPostBorrowck.panic-unwind.diff +++ b/tests/mir-opt/remove_fake_borrows.match_guard.CleanupPostBorrowck.panic-unwind.diff @@ -24,7 +24,7 @@ } bb2: { - switchInt((*(*((_1 as Some).0: &&i32)))) -> [0: bb3, otherwise: bb1]; + switchInt(copy (*(*((_1 as Some).0: &&i32)))) -> [0: bb3, otherwise: bb1]; } bb3: { @@ -42,7 +42,7 @@ + nop; + nop; StorageLive(_8); - _8 = _2; + _8 = copy _2; switchInt(move _8) -> [0: bb6, otherwise: bb5]; } diff --git a/tests/mir-opt/remove_storage_markers.main.RemoveStorageMarkers.panic-abort.diff b/tests/mir-opt/remove_storage_markers.main.RemoveStorageMarkers.panic-abort.diff index 14762b9c40f4..38cdbf5684bf 100644 --- a/tests/mir-opt/remove_storage_markers.main.RemoveStorageMarkers.panic-abort.diff +++ b/tests/mir-opt/remove_storage_markers.main.RemoveStorageMarkers.panic-abort.diff @@ -64,10 +64,10 @@ bb5: { - StorageLive(_12); - _12 = ((_7 as Some).0: i32); + _12 = copy ((_7 as Some).0: i32); - StorageLive(_13); - _13 = _12; - _1 = Add(_1, move _13); + _13 = copy _12; + _1 = Add(copy _1, move _13); - StorageDead(_13); _6 = const (); - StorageDead(_12); diff --git a/tests/mir-opt/remove_storage_markers.main.RemoveStorageMarkers.panic-unwind.diff b/tests/mir-opt/remove_storage_markers.main.RemoveStorageMarkers.panic-unwind.diff index 24797424b5c8..2b5aaa95fe1a 100644 --- a/tests/mir-opt/remove_storage_markers.main.RemoveStorageMarkers.panic-unwind.diff +++ b/tests/mir-opt/remove_storage_markers.main.RemoveStorageMarkers.panic-unwind.diff @@ -64,10 +64,10 @@ bb5: { - StorageLive(_12); - _12 = ((_7 as Some).0: i32); + _12 = copy ((_7 as Some).0: i32); - StorageLive(_13); - _13 = _12; - _1 = Add(_1, move _13); + _13 = copy _12; + _1 = Add(copy _1, move _13); - StorageDead(_13); _6 = const (); - StorageDead(_12); diff --git a/tests/mir-opt/remove_unneeded_drops.opt.RemoveUnneededDrops.panic-abort.diff b/tests/mir-opt/remove_unneeded_drops.opt.RemoveUnneededDrops.panic-abort.diff index 5afeb8620a17..01eb6d4901f7 100644 --- a/tests/mir-opt/remove_unneeded_drops.opt.RemoveUnneededDrops.panic-abort.diff +++ b/tests/mir-opt/remove_unneeded_drops.opt.RemoveUnneededDrops.panic-abort.diff @@ -12,7 +12,7 @@ bb0: { - nop; StorageLive(_3); - _3 = _1; + _3 = copy _1; - drop(_3) -> [return: bb1, unwind unreachable]; - } - diff --git a/tests/mir-opt/remove_unneeded_drops.opt.RemoveUnneededDrops.panic-unwind.diff b/tests/mir-opt/remove_unneeded_drops.opt.RemoveUnneededDrops.panic-unwind.diff index b9919ddea568..c2c3cb76e832 100644 --- a/tests/mir-opt/remove_unneeded_drops.opt.RemoveUnneededDrops.panic-unwind.diff +++ b/tests/mir-opt/remove_unneeded_drops.opt.RemoveUnneededDrops.panic-unwind.diff @@ -12,7 +12,7 @@ bb0: { - nop; StorageLive(_3); - _3 = _1; + _3 = copy _1; - drop(_3) -> [return: bb1, unwind continue]; - } - diff --git a/tests/mir-opt/remove_unneeded_drops.opt_generic_copy.RemoveUnneededDrops.panic-abort.diff b/tests/mir-opt/remove_unneeded_drops.opt_generic_copy.RemoveUnneededDrops.panic-abort.diff index b89432dd6d62..a82ede6196ed 100644 --- a/tests/mir-opt/remove_unneeded_drops.opt_generic_copy.RemoveUnneededDrops.panic-abort.diff +++ b/tests/mir-opt/remove_unneeded_drops.opt_generic_copy.RemoveUnneededDrops.panic-abort.diff @@ -12,7 +12,7 @@ bb0: { - nop; StorageLive(_3); - _3 = _1; + _3 = copy _1; - drop(_3) -> [return: bb1, unwind unreachable]; - } - diff --git a/tests/mir-opt/remove_unneeded_drops.opt_generic_copy.RemoveUnneededDrops.panic-unwind.diff b/tests/mir-opt/remove_unneeded_drops.opt_generic_copy.RemoveUnneededDrops.panic-unwind.diff index 48d026053322..6e7c9ead740f 100644 --- a/tests/mir-opt/remove_unneeded_drops.opt_generic_copy.RemoveUnneededDrops.panic-unwind.diff +++ b/tests/mir-opt/remove_unneeded_drops.opt_generic_copy.RemoveUnneededDrops.panic-unwind.diff @@ -12,7 +12,7 @@ bb0: { - nop; StorageLive(_3); - _3 = _1; + _3 = copy _1; - drop(_3) -> [return: bb1, unwind continue]; - } - diff --git a/tests/mir-opt/retag.array_casts.SimplifyCfg-pre-optimizations.after.panic-abort.mir b/tests/mir-opt/retag.array_casts.SimplifyCfg-pre-optimizations.after.panic-abort.mir index 6dba667dd155..ae7b2cc0b6fc 100644 --- a/tests/mir-opt/retag.array_casts.SimplifyCfg-pre-optimizations.after.panic-abort.mir +++ b/tests/mir-opt/retag.array_casts.SimplifyCfg-pre-optimizations.after.panic-abort.mir @@ -70,7 +70,7 @@ fn array_casts() -> () { StorageLive(_5); StorageLive(_6); StorageLive(_7); - _7 = _2; + _7 = copy _2; _6 = std::ptr::mut_ptr::::add(move _7, const 1_usize) -> [return: bb1, unwind unreachable]; } @@ -96,13 +96,13 @@ fn array_casts() -> () { StorageLive(_15); StorageLive(_16); StorageLive(_17); - _17 = _9; + _17 = copy _9; _16 = std::ptr::const_ptr::::add(move _17, const 1_usize) -> [return: bb2, unwind unreachable]; } bb2: { StorageDead(_17); - _15 = (*_16); + _15 = copy (*_16); _14 = &_15; StorageLive(_18); _34 = const array_casts::promoted[0]; @@ -113,16 +113,16 @@ fn array_casts() -> () { StorageDead(_18); StorageDead(_14); StorageLive(_20); - _20 = (_13.0: &usize); + _20 = copy (_13.0: &usize); Retag(_20); StorageLive(_21); - _21 = (_13.1: &usize); + _21 = copy (_13.1: &usize); Retag(_21); StorageLive(_22); StorageLive(_23); - _23 = (*_20); + _23 = copy (*_20); StorageLive(_24); - _24 = (*_21); + _24 = copy (*_21); _22 = Eq(move _23, move _24); switchInt(move _22) -> [0: bb4, otherwise: bb3]; } diff --git a/tests/mir-opt/retag.array_casts.SimplifyCfg-pre-optimizations.after.panic-unwind.mir b/tests/mir-opt/retag.array_casts.SimplifyCfg-pre-optimizations.after.panic-unwind.mir index fa812002e26c..789bc3426384 100644 --- a/tests/mir-opt/retag.array_casts.SimplifyCfg-pre-optimizations.after.panic-unwind.mir +++ b/tests/mir-opt/retag.array_casts.SimplifyCfg-pre-optimizations.after.panic-unwind.mir @@ -70,7 +70,7 @@ fn array_casts() -> () { StorageLive(_5); StorageLive(_6); StorageLive(_7); - _7 = _2; + _7 = copy _2; _6 = std::ptr::mut_ptr::::add(move _7, const 1_usize) -> [return: bb1, unwind continue]; } @@ -96,13 +96,13 @@ fn array_casts() -> () { StorageLive(_15); StorageLive(_16); StorageLive(_17); - _17 = _9; + _17 = copy _9; _16 = std::ptr::const_ptr::::add(move _17, const 1_usize) -> [return: bb2, unwind continue]; } bb2: { StorageDead(_17); - _15 = (*_16); + _15 = copy (*_16); _14 = &_15; StorageLive(_18); _34 = const array_casts::promoted[0]; @@ -113,16 +113,16 @@ fn array_casts() -> () { StorageDead(_18); StorageDead(_14); StorageLive(_20); - _20 = (_13.0: &usize); + _20 = copy (_13.0: &usize); Retag(_20); StorageLive(_21); - _21 = (_13.1: &usize); + _21 = copy (_13.1: &usize); Retag(_21); StorageLive(_22); StorageLive(_23); - _23 = (*_20); + _23 = copy (*_20); StorageLive(_24); - _24 = (*_21); + _24 = copy (*_21); _22 = Eq(move _23, move _24); switchInt(move _22) -> [0: bb4, otherwise: bb3]; } diff --git a/tests/mir-opt/retag.box_to_raw_mut.SimplifyCfg-pre-optimizations.after.panic-abort.mir b/tests/mir-opt/retag.box_to_raw_mut.SimplifyCfg-pre-optimizations.after.panic-abort.mir index 0e568f6a5685..ca02e7b49ccc 100644 --- a/tests/mir-opt/retag.box_to_raw_mut.SimplifyCfg-pre-optimizations.after.panic-abort.mir +++ b/tests/mir-opt/retag.box_to_raw_mut.SimplifyCfg-pre-optimizations.after.panic-abort.mir @@ -9,7 +9,7 @@ fn box_to_raw_mut(_1: &mut Box) -> *mut i32 { bb0: { Retag([fn entry] _1); _2 = deref_copy (*_1); - _3 = (((_2.0: std::ptr::Unique).0: std::ptr::NonNull).0: *const i32); + _3 = copy (((_2.0: std::ptr::Unique).0: std::ptr::NonNull).0: *const i32); _0 = &raw mut (*_3); Retag([raw] _0); return; diff --git a/tests/mir-opt/retag.box_to_raw_mut.SimplifyCfg-pre-optimizations.after.panic-unwind.mir b/tests/mir-opt/retag.box_to_raw_mut.SimplifyCfg-pre-optimizations.after.panic-unwind.mir index 0e568f6a5685..ca02e7b49ccc 100644 --- a/tests/mir-opt/retag.box_to_raw_mut.SimplifyCfg-pre-optimizations.after.panic-unwind.mir +++ b/tests/mir-opt/retag.box_to_raw_mut.SimplifyCfg-pre-optimizations.after.panic-unwind.mir @@ -9,7 +9,7 @@ fn box_to_raw_mut(_1: &mut Box) -> *mut i32 { bb0: { Retag([fn entry] _1); _2 = deref_copy (*_1); - _3 = (((_2.0: std::ptr::Unique).0: std::ptr::NonNull).0: *const i32); + _3 = copy (((_2.0: std::ptr::Unique).0: std::ptr::NonNull).0: *const i32); _0 = &raw mut (*_3); Retag([raw] _0); return; diff --git a/tests/mir-opt/retag.main-{closure#0}.SimplifyCfg-pre-optimizations.after.panic-abort.mir b/tests/mir-opt/retag.main-{closure#0}.SimplifyCfg-pre-optimizations.after.panic-abort.mir index 2620929e896b..63b32ceb5c05 100644 --- a/tests/mir-opt/retag.main-{closure#0}.SimplifyCfg-pre-optimizations.after.panic-abort.mir +++ b/tests/mir-opt/retag.main-{closure#0}.SimplifyCfg-pre-optimizations.after.panic-abort.mir @@ -12,7 +12,7 @@ fn main::{closure#0}(_1: &{closure@main::{closure#0}}, _2: &i32) -> &i32 { Retag([fn entry] _1); Retag([fn entry] _2); StorageLive(_3); - _3 = _2; + _3 = copy _2; Retag(_3); _0 = &(*_2); StorageDead(_3); diff --git a/tests/mir-opt/retag.main-{closure#0}.SimplifyCfg-pre-optimizations.after.panic-unwind.mir b/tests/mir-opt/retag.main-{closure#0}.SimplifyCfg-pre-optimizations.after.panic-unwind.mir index 2620929e896b..63b32ceb5c05 100644 --- a/tests/mir-opt/retag.main-{closure#0}.SimplifyCfg-pre-optimizations.after.panic-unwind.mir +++ b/tests/mir-opt/retag.main-{closure#0}.SimplifyCfg-pre-optimizations.after.panic-unwind.mir @@ -12,7 +12,7 @@ fn main::{closure#0}(_1: &{closure@main::{closure#0}}, _2: &i32) -> &i32 { Retag([fn entry] _1); Retag([fn entry] _2); StorageLive(_3); - _3 = _2; + _3 = copy _2; Retag(_3); _0 = &(*_2); StorageDead(_3); diff --git a/tests/mir-opt/retag.main.SimplifyCfg-pre-optimizations.after.panic-abort.mir b/tests/mir-opt/retag.main.SimplifyCfg-pre-optimizations.after.panic-abort.mir index a35af43cefd6..d0f454e45693 100644 --- a/tests/mir-opt/retag.main.SimplifyCfg-pre-optimizations.after.panic-abort.mir +++ b/tests/mir-opt/retag.main.SimplifyCfg-pre-optimizations.after.panic-abort.mir @@ -93,7 +93,7 @@ fn main() -> () { StorageLive(_11); StorageLive(_12); _12 = &raw mut (*_10); - _11 = _12; + _11 = copy _12; StorageDead(_12); _2 = const (); StorageDead(_11); @@ -109,7 +109,7 @@ fn main() -> () { StorageDead(_14); StorageLive(_15); StorageLive(_16); - _16 = _13; + _16 = copy _13; StorageLive(_17); StorageLive(_18); _18 = &_1; @@ -150,7 +150,7 @@ fn main() -> () { StorageLive(_25); StorageLive(_26); _26 = &raw const (*_15); - _25 = _26; + _25 = copy _26; StorageDead(_26); StorageLive(_27); _27 = array_casts() -> [return: bb6, unwind unreachable]; diff --git a/tests/mir-opt/retag.main.SimplifyCfg-pre-optimizations.after.panic-unwind.mir b/tests/mir-opt/retag.main.SimplifyCfg-pre-optimizations.after.panic-unwind.mir index 2495719ec1c6..685277d7a532 100644 --- a/tests/mir-opt/retag.main.SimplifyCfg-pre-optimizations.after.panic-unwind.mir +++ b/tests/mir-opt/retag.main.SimplifyCfg-pre-optimizations.after.panic-unwind.mir @@ -93,7 +93,7 @@ fn main() -> () { StorageLive(_11); StorageLive(_12); _12 = &raw mut (*_10); - _11 = _12; + _11 = copy _12; StorageDead(_12); _2 = const (); StorageDead(_11); @@ -109,7 +109,7 @@ fn main() -> () { StorageDead(_14); StorageLive(_15); StorageLive(_16); - _16 = _13; + _16 = copy _13; StorageLive(_17); StorageLive(_18); _18 = &_1; @@ -150,7 +150,7 @@ fn main() -> () { StorageLive(_25); StorageLive(_26); _26 = &raw const (*_15); - _25 = _26; + _25 = copy _26; StorageDead(_26); StorageLive(_27); _27 = array_casts() -> [return: bb6, unwind continue]; diff --git a/tests/mir-opt/retag.{impl#0}-foo_shr.SimplifyCfg-pre-optimizations.after.panic-abort.mir b/tests/mir-opt/retag.{impl#0}-foo_shr.SimplifyCfg-pre-optimizations.after.panic-abort.mir index 4f90413e38bf..b873c5aabbfc 100644 --- a/tests/mir-opt/retag.{impl#0}-foo_shr.SimplifyCfg-pre-optimizations.after.panic-abort.mir +++ b/tests/mir-opt/retag.{impl#0}-foo_shr.SimplifyCfg-pre-optimizations.after.panic-abort.mir @@ -8,7 +8,7 @@ fn ::foo_shr(_1: &Test, _2: &i32) -> &i32 { bb0: { Retag([fn entry] _1); Retag([fn entry] _2); - _0 = _2; + _0 = copy _2; Retag(_0); return; } diff --git a/tests/mir-opt/retag.{impl#0}-foo_shr.SimplifyCfg-pre-optimizations.after.panic-unwind.mir b/tests/mir-opt/retag.{impl#0}-foo_shr.SimplifyCfg-pre-optimizations.after.panic-unwind.mir index 4f90413e38bf..b873c5aabbfc 100644 --- a/tests/mir-opt/retag.{impl#0}-foo_shr.SimplifyCfg-pre-optimizations.after.panic-unwind.mir +++ b/tests/mir-opt/retag.{impl#0}-foo_shr.SimplifyCfg-pre-optimizations.after.panic-unwind.mir @@ -8,7 +8,7 @@ fn ::foo_shr(_1: &Test, _2: &i32) -> &i32 { bb0: { Retag([fn entry] _1); Retag([fn entry] _2); - _0 = _2; + _0 = copy _2; Retag(_0); return; } diff --git a/tests/mir-opt/separate_const_switch.identity.JumpThreading.diff b/tests/mir-opt/separate_const_switch.identity.JumpThreading.diff index 8dd904c7d7b9..ce9d812701a8 100644 --- a/tests/mir-opt/separate_const_switch.identity.JumpThreading.diff +++ b/tests/mir-opt/separate_const_switch.identity.JumpThreading.diff @@ -50,16 +50,16 @@ } bb2: { - _5 = ((_2 as Continue).0: i32); - _0 = Result::::Ok(_5); + _5 = copy ((_2 as Continue).0: i32); + _0 = Result::::Ok(copy _5); StorageDead(_2); return; } bb3: { - _4 = ((_2 as Break).0: std::result::Result); - _10 = ((_4 as Err).0: i32); - _0 = Result::::Err(_10); + _4 = copy ((_2 as Break).0: std::result::Result); + _10 = copy ((_4 as Err).0: i32); + _0 = Result::::Err(copy _10); StorageDead(_2); return; } @@ -74,9 +74,9 @@ } bb5: { - _8 = ((_1 as Err).0: i32); + _8 = copy ((_1 as Err).0: i32); StorageLive(_9); - _9 = Result::::Err(_8); + _9 = Result::::Err(copy _8); _2 = ControlFlow::, i32>::Break(move _9); StorageDead(_9); - goto -> bb4; @@ -84,8 +84,8 @@ } bb6: { - _7 = ((_1 as Ok).0: i32); - _2 = ControlFlow::, i32>::Continue(_7); + _7 = copy ((_1 as Ok).0: i32); + _2 = ControlFlow::, i32>::Continue(copy _7); goto -> bb4; + } + diff --git a/tests/mir-opt/separate_const_switch.too_complex.JumpThreading.diff b/tests/mir-opt/separate_const_switch.too_complex.JumpThreading.diff index f74958629922..c88c63e0c133 100644 --- a/tests/mir-opt/separate_const_switch.too_complex.JumpThreading.diff +++ b/tests/mir-opt/separate_const_switch.too_complex.JumpThreading.diff @@ -35,15 +35,15 @@ } bb2: { - _5 = ((_1 as Err).0: usize); - _2 = ControlFlow::::Break(_5); + _5 = copy ((_1 as Err).0: usize); + _2 = ControlFlow::::Break(copy _5); - goto -> bb4; + goto -> bb8; } bb3: { - _4 = ((_1 as Ok).0: i32); - _2 = ControlFlow::::Continue(_4); + _4 = copy ((_1 as Ok).0: i32); + _2 = ControlFlow::::Continue(copy _4); goto -> bb4; } @@ -55,15 +55,15 @@ bb5: { StorageLive(_8); - _8 = ((_2 as Break).0: usize); + _8 = copy ((_2 as Break).0: usize); _0 = const Option::::None; StorageDead(_8); goto -> bb7; } bb6: { - _7 = ((_2 as Continue).0: i32); - _0 = Option::::Some(_7); + _7 = copy ((_2 as Continue).0: i32); + _0 = Option::::Some(copy _7); goto -> bb7; } diff --git a/tests/mir-opt/set_no_discriminant.f.JumpThreading.diff b/tests/mir-opt/set_no_discriminant.f.JumpThreading.diff index bc28e81c9a88..3d9852aef657 100644 --- a/tests/mir-opt/set_no_discriminant.f.JumpThreading.diff +++ b/tests/mir-opt/set_no_discriminant.f.JumpThreading.diff @@ -10,7 +10,7 @@ _2 = E::::A; discriminant(_2) = 1; _1 = discriminant(_2); - switchInt(_1) -> [0: bb1, otherwise: bb2]; + switchInt(copy _1) -> [0: bb1, otherwise: bb2]; } bb1: { diff --git a/tests/mir-opt/set_no_discriminant.generic.JumpThreading.diff b/tests/mir-opt/set_no_discriminant.generic.JumpThreading.diff index 78bfeef3c649..c7af16383161 100644 --- a/tests/mir-opt/set_no_discriminant.generic.JumpThreading.diff +++ b/tests/mir-opt/set_no_discriminant.generic.JumpThreading.diff @@ -10,7 +10,7 @@ _2 = E::::A; discriminant(_2) = 1; _1 = discriminant(_2); - switchInt(_1) -> [0: bb1, otherwise: bb2]; + switchInt(copy _1) -> [0: bb1, otherwise: bb2]; } bb1: { diff --git a/tests/mir-opt/simplify_dead_blocks.assert_nonzero_nonmax.SimplifyCfg-after-unreachable-enum-branching.diff b/tests/mir-opt/simplify_dead_blocks.assert_nonzero_nonmax.SimplifyCfg-after-unreachable-enum-branching.diff index 4400cfaef810..9c8efab5c843 100644 --- a/tests/mir-opt/simplify_dead_blocks.assert_nonzero_nonmax.SimplifyCfg-after-unreachable-enum-branching.diff +++ b/tests/mir-opt/simplify_dead_blocks.assert_nonzero_nonmax.SimplifyCfg-after-unreachable-enum-branching.diff @@ -5,8 +5,8 @@ let mut _0: u8; bb0: { -- switchInt(_1) -> [0: bb3, 1: bb2, 255: bb3, otherwise: bb4]; -+ switchInt(_1) -> [0: bb2, 1: bb1, 255: bb2, otherwise: bb3]; +- switchInt(copy _1) -> [0: bb3, 1: bb2, 255: bb3, otherwise: bb4]; ++ switchInt(copy _1) -> [0: bb2, 1: bb1, 255: bb2, otherwise: bb3]; } bb1: { @@ -26,7 +26,7 @@ - bb4: { + bb3: { - _0 = _1; + _0 = copy _1; return; } } diff --git a/tests/mir-opt/simplify_locals.expose_provenance.SimplifyLocals-before-const-prop.diff b/tests/mir-opt/simplify_locals.expose_provenance.SimplifyLocals-before-const-prop.diff index cc5c642407e9..420fb4270b2b 100644 --- a/tests/mir-opt/simplify_locals.expose_provenance.SimplifyLocals-before-const-prop.diff +++ b/tests/mir-opt/simplify_locals.expose_provenance.SimplifyLocals-before-const-prop.diff @@ -10,7 +10,7 @@ bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; _2 = move _3 as usize (PointerExposeProvenance); StorageDead(_3); StorageDead(_2); diff --git a/tests/mir-opt/simplify_locals.t1.SimplifyLocals-before-const-prop.diff b/tests/mir-opt/simplify_locals.t1.SimplifyLocals-before-const-prop.diff index 526ff2f25cfc..f05a3935d658 100644 --- a/tests/mir-opt/simplify_locals.t1.SimplifyLocals-before-const-prop.diff +++ b/tests/mir-opt/simplify_locals.t1.SimplifyLocals-before-const-prop.diff @@ -10,7 +10,7 @@ - StorageLive(_1); - StorageLive(_2); - _2 = &/*tls*/ mut X; -- _1 = (*_2); +- _1 = copy (*_2); - StorageDead(_2); - StorageDead(_1); _0 = const (); diff --git a/tests/mir-opt/simplify_locals.t3.SimplifyLocals-before-const-prop.diff b/tests/mir-opt/simplify_locals.t3.SimplifyLocals-before-const-prop.diff index 5d45d7ac7815..a57c136e64d3 100644 --- a/tests/mir-opt/simplify_locals.t3.SimplifyLocals-before-const-prop.diff +++ b/tests/mir-opt/simplify_locals.t3.SimplifyLocals-before-const-prop.diff @@ -13,7 +13,7 @@ - StorageLive(_3); - _3 = &/*tls*/ mut X; - _2 = &mut (*_3); -- _1 = (*_2); +- _1 = copy (*_2); - StorageDead(_3); - StorageDead(_2); - StorageDead(_1); diff --git a/tests/mir-opt/simplify_locals.t4.SimplifyLocals-before-const-prop.diff b/tests/mir-opt/simplify_locals.t4.SimplifyLocals-before-const-prop.diff index 4f4855dbaaf8..118193fd4fde 100644 --- a/tests/mir-opt/simplify_locals.t4.SimplifyLocals-before-const-prop.diff +++ b/tests/mir-opt/simplify_locals.t4.SimplifyLocals-before-const-prop.diff @@ -10,7 +10,7 @@ StorageLive(_1); StorageLive(_2); _2 = &/*tls*/ mut X; - _1 = (*_2); + _1 = copy (*_2); _0 = Add(move _1, const 1_u32); StorageDead(_1); StorageDead(_2); diff --git a/tests/mir-opt/simplify_locals_fixedpoint.foo.SimplifyLocals-final.panic-abort.diff b/tests/mir-opt/simplify_locals_fixedpoint.foo.SimplifyLocals-final.panic-abort.diff index c520a159f47b..c363dfcbf70b 100644 --- a/tests/mir-opt/simplify_locals_fixedpoint.foo.SimplifyLocals-final.panic-abort.diff +++ b/tests/mir-opt/simplify_locals_fixedpoint.foo.SimplifyLocals-final.panic-abort.diff @@ -33,7 +33,7 @@ bb2: { StorageLive(_6); - _6 = (((_1.0: std::option::Option) as Some).0: u8); + _6 = copy (((_1.0: std::option::Option) as Some).0: u8); StorageDead(_6); goto -> bb3; } diff --git a/tests/mir-opt/simplify_locals_fixedpoint.foo.SimplifyLocals-final.panic-unwind.diff b/tests/mir-opt/simplify_locals_fixedpoint.foo.SimplifyLocals-final.panic-unwind.diff index 686581591fc4..895b0067d2e6 100644 --- a/tests/mir-opt/simplify_locals_fixedpoint.foo.SimplifyLocals-final.panic-unwind.diff +++ b/tests/mir-opt/simplify_locals_fixedpoint.foo.SimplifyLocals-final.panic-unwind.diff @@ -33,7 +33,7 @@ bb2: { StorageLive(_6); - _6 = (((_1.0: std::option::Option) as Some).0: u8); + _6 = copy (((_1.0: std::option::Option) as Some).0: u8); StorageDead(_6); goto -> bb3; } diff --git a/tests/mir-opt/simplify_locals_removes_unused_consts.main.SimplifyLocals-before-const-prop.panic-abort.diff b/tests/mir-opt/simplify_locals_removes_unused_consts.main.SimplifyLocals-before-const-prop.panic-abort.diff index 54d254ee3746..58c265c5e605 100644 --- a/tests/mir-opt/simplify_locals_removes_unused_consts.main.SimplifyLocals-before-const-prop.panic-abort.diff +++ b/tests/mir-opt/simplify_locals_removes_unused_consts.main.SimplifyLocals-before-const-prop.panic-abort.diff @@ -51,7 +51,7 @@ - _5 = (move _6, move _7); + StorageLive(_8); + _8 = Temp { x: const 40_u8 }; -+ _7 = (_8.0: u8); ++ _7 = copy (_8.0: u8); + _6 = Add(move _7, const 2_u8); StorageDead(_7); - StorageDead(_6); @@ -67,7 +67,7 @@ - StorageLive(_10); - StorageLive(_11); - _11 = Temp { x: const 40_u8 }; -- _10 = (_11.0: u8); +- _10 = copy (_11.0: u8); - _9 = Add(move _10, const 2_u8); - StorageDead(_10); - _8 = use_u8(move _9) -> [return: bb2, unwind unreachable]; diff --git a/tests/mir-opt/simplify_locals_removes_unused_consts.main.SimplifyLocals-before-const-prop.panic-unwind.diff b/tests/mir-opt/simplify_locals_removes_unused_consts.main.SimplifyLocals-before-const-prop.panic-unwind.diff index a5d9bbc49af0..748e1661c987 100644 --- a/tests/mir-opt/simplify_locals_removes_unused_consts.main.SimplifyLocals-before-const-prop.panic-unwind.diff +++ b/tests/mir-opt/simplify_locals_removes_unused_consts.main.SimplifyLocals-before-const-prop.panic-unwind.diff @@ -51,7 +51,7 @@ - _5 = (move _6, move _7); + StorageLive(_8); + _8 = Temp { x: const 40_u8 }; -+ _7 = (_8.0: u8); ++ _7 = copy (_8.0: u8); + _6 = Add(move _7, const 2_u8); StorageDead(_7); - StorageDead(_6); @@ -67,7 +67,7 @@ - StorageLive(_10); - StorageLive(_11); - _11 = Temp { x: const 40_u8 }; -- _10 = (_11.0: u8); +- _10 = copy (_11.0: u8); - _9 = Add(move _10, const 2_u8); - StorageDead(_10); - _8 = use_u8(move _9) -> [return: bb2, unwind continue]; diff --git a/tests/mir-opt/simplify_match.main.GVN.panic-abort.diff b/tests/mir-opt/simplify_match.main.GVN.panic-abort.diff index 33b36f660cb3..9e798cbcac0c 100644 --- a/tests/mir-opt/simplify_match.main.GVN.panic-abort.diff +++ b/tests/mir-opt/simplify_match.main.GVN.panic-abort.diff @@ -14,9 +14,9 @@ - StorageLive(_2); + nop; _2 = const false; -- _1 = _2; +- _1 = copy _2; - StorageDead(_2); -- switchInt(_1) -> [0: bb2, otherwise: bb1]; +- switchInt(copy _1) -> [0: bb2, otherwise: bb1]; + _1 = const false; + nop; + switchInt(const false) -> [0: bb2, otherwise: bb1]; diff --git a/tests/mir-opt/simplify_match.main.GVN.panic-unwind.diff b/tests/mir-opt/simplify_match.main.GVN.panic-unwind.diff index e5c3adff6236..e243ff45ab0b 100644 --- a/tests/mir-opt/simplify_match.main.GVN.panic-unwind.diff +++ b/tests/mir-opt/simplify_match.main.GVN.panic-unwind.diff @@ -14,9 +14,9 @@ - StorageLive(_2); + nop; _2 = const false; -- _1 = _2; +- _1 = copy _2; - StorageDead(_2); -- switchInt(_1) -> [0: bb2, otherwise: bb1]; +- switchInt(copy _1) -> [0: bb2, otherwise: bb1]; + _1 = const false; + nop; + switchInt(const false) -> [0: bb2, otherwise: bb1]; diff --git a/tests/mir-opt/single_use_consts.if_const_debug.SingleUseConsts.panic-abort.diff b/tests/mir-opt/single_use_consts.if_const_debug.SingleUseConsts.panic-abort.diff index ad1a2b300f2a..0269c2cba202 100644 --- a/tests/mir-opt/single_use_consts.if_const_debug.SingleUseConsts.panic-abort.diff +++ b/tests/mir-opt/single_use_consts.if_const_debug.SingleUseConsts.panic-abort.diff @@ -22,7 +22,7 @@ bb1: { StorageDead(_2); StorageLive(_3); -- _3 = _1; +- _3 = copy _1; + _3 = const ::ASSOC_BOOL; switchInt(move _3) -> [0: bb3, otherwise: bb2]; } diff --git a/tests/mir-opt/single_use_consts.if_const_debug.SingleUseConsts.panic-unwind.diff b/tests/mir-opt/single_use_consts.if_const_debug.SingleUseConsts.panic-unwind.diff index 827a292e5d02..1285b8b33ba2 100644 --- a/tests/mir-opt/single_use_consts.if_const_debug.SingleUseConsts.panic-unwind.diff +++ b/tests/mir-opt/single_use_consts.if_const_debug.SingleUseConsts.panic-unwind.diff @@ -22,7 +22,7 @@ bb1: { StorageDead(_2); StorageLive(_3); -- _3 = _1; +- _3 = copy _1; + _3 = const ::ASSOC_BOOL; switchInt(move _3) -> [0: bb3, otherwise: bb2]; } diff --git a/tests/mir-opt/single_use_consts.match_const.SingleUseConsts.panic-abort.diff b/tests/mir-opt/single_use_consts.match_const.SingleUseConsts.panic-abort.diff index 998b89919d1b..354e0988a006 100644 --- a/tests/mir-opt/single_use_consts.match_const.SingleUseConsts.panic-abort.diff +++ b/tests/mir-opt/single_use_consts.match_const.SingleUseConsts.panic-abort.diff @@ -8,7 +8,7 @@ bb0: { StorageLive(_1); - _1 = const ::ASSOC_INT; -- switchInt(_1) -> [7: bb3, 42: bb2, otherwise: bb1]; +- switchInt(copy _1) -> [7: bb3, 42: bb2, otherwise: bb1]; + nop; + switchInt(const ::ASSOC_INT) -> [7: bb3, 42: bb2, otherwise: bb1]; } diff --git a/tests/mir-opt/single_use_consts.match_const.SingleUseConsts.panic-unwind.diff b/tests/mir-opt/single_use_consts.match_const.SingleUseConsts.panic-unwind.diff index 998b89919d1b..354e0988a006 100644 --- a/tests/mir-opt/single_use_consts.match_const.SingleUseConsts.panic-unwind.diff +++ b/tests/mir-opt/single_use_consts.match_const.SingleUseConsts.panic-unwind.diff @@ -8,7 +8,7 @@ bb0: { StorageLive(_1); - _1 = const ::ASSOC_INT; -- switchInt(_1) -> [7: bb3, 42: bb2, otherwise: bb1]; +- switchInt(copy _1) -> [7: bb3, 42: bb2, otherwise: bb1]; + nop; + switchInt(const ::ASSOC_INT) -> [7: bb3, 42: bb2, otherwise: bb1]; } diff --git a/tests/mir-opt/single_use_consts.match_const_debug.SingleUseConsts.panic-abort.diff b/tests/mir-opt/single_use_consts.match_const_debug.SingleUseConsts.panic-abort.diff index 30f66ef6b823..5cf37dc97cbf 100644 --- a/tests/mir-opt/single_use_consts.match_const_debug.SingleUseConsts.panic-abort.diff +++ b/tests/mir-opt/single_use_consts.match_const_debug.SingleUseConsts.panic-abort.diff @@ -20,7 +20,7 @@ bb1: { StorageDead(_2); -- switchInt(_1) -> [7: bb4, 42: bb3, otherwise: bb2]; +- switchInt(copy _1) -> [7: bb4, 42: bb3, otherwise: bb2]; + switchInt(const ::ASSOC_INT) -> [7: bb4, 42: bb3, otherwise: bb2]; } diff --git a/tests/mir-opt/single_use_consts.match_const_debug.SingleUseConsts.panic-unwind.diff b/tests/mir-opt/single_use_consts.match_const_debug.SingleUseConsts.panic-unwind.diff index ed12ad4b93e8..bdcf086e8d96 100644 --- a/tests/mir-opt/single_use_consts.match_const_debug.SingleUseConsts.panic-unwind.diff +++ b/tests/mir-opt/single_use_consts.match_const_debug.SingleUseConsts.panic-unwind.diff @@ -20,7 +20,7 @@ bb1: { StorageDead(_2); -- switchInt(_1) -> [7: bb4, 42: bb3, otherwise: bb2]; +- switchInt(copy _1) -> [7: bb4, 42: bb3, otherwise: bb2]; + switchInt(const ::ASSOC_INT) -> [7: bb4, 42: bb3, otherwise: bb2]; } diff --git a/tests/mir-opt/slice_drop_shim.core.ptr-drop_in_place.[String].AddMovesForPackedDrops.before.mir b/tests/mir-opt/slice_drop_shim.core.ptr-drop_in_place.[String].AddMovesForPackedDrops.before.mir index 3a8b457a7a10..4d1eaa6ffe32 100644 --- a/tests/mir-opt/slice_drop_shim.core.ptr-drop_in_place.[String].AddMovesForPackedDrops.before.mir +++ b/tests/mir-opt/slice_drop_shim.core.ptr-drop_in_place.[String].AddMovesForPackedDrops.before.mir @@ -28,7 +28,7 @@ fn std::ptr::drop_in_place(_1: *mut [String]) -> () { } bb4 (cleanup): { - _5 = Eq(_3, _2); + _5 = Eq(copy _3, copy _2); switchInt(move _5) -> [0: bb3, otherwise: bb2]; } @@ -39,7 +39,7 @@ fn std::ptr::drop_in_place(_1: *mut [String]) -> () { } bb6: { - _7 = Eq(_3, _2); + _7 = Eq(copy _3, copy _2); switchInt(move _7) -> [0: bb5, otherwise: bb1]; } diff --git a/tests/mir-opt/sroa/lifetimes.foo.ScalarReplacementOfAggregates.diff b/tests/mir-opt/sroa/lifetimes.foo.ScalarReplacementOfAggregates.diff index 819f3f86d145..478dacc32766 100644 --- a/tests/mir-opt/sroa/lifetimes.foo.ScalarReplacementOfAggregates.diff +++ b/tests/mir-opt/sroa/lifetimes.foo.ScalarReplacementOfAggregates.diff @@ -75,8 +75,8 @@ - _5 = move (_1.0: std::result::Result, ::Err>); + _5 = move _29; StorageLive(_6); -- _6 = (_1.1: u32); -+ _6 = _30; +- _6 = copy (_1.1: u32); ++ _6 = copy _30; _7 = discriminant(_5); switchInt(move _7) -> [0: bb2, otherwise: bb7]; } @@ -171,7 +171,7 @@ } bb11: { - switchInt(_25) -> [0: bb10, otherwise: bb12]; + switchInt(copy _25) -> [0: bb10, otherwise: bb12]; } bb12: { diff --git a/tests/mir-opt/sroa/structs.constant.ScalarReplacementOfAggregates.diff b/tests/mir-opt/sroa/structs.constant.ScalarReplacementOfAggregates.diff index 5d21e7939823..4da3eb0ed761 100644 --- a/tests/mir-opt/sroa/structs.constant.ScalarReplacementOfAggregates.diff +++ b/tests/mir-opt/sroa/structs.constant.ScalarReplacementOfAggregates.diff @@ -29,11 +29,11 @@ + _4 = move (_1.0: usize); + _5 = move (_1.1: u8); StorageLive(_2); -- _2 = (_1.0: usize); -+ _2 = _4; +- _2 = copy (_1.0: usize); ++ _2 = copy _4; StorageLive(_3); -- _3 = (_1.1: u8); -+ _3 = _5; +- _3 = copy (_1.1: u8); ++ _3 = copy _5; _0 = const (); StorageDead(_3); StorageDead(_2); diff --git a/tests/mir-opt/sroa/structs.copies.ScalarReplacementOfAggregates.diff b/tests/mir-opt/sroa/structs.copies.ScalarReplacementOfAggregates.diff index 3621338635ed..cfc086d65963 100644 --- a/tests/mir-opt/sroa/structs.copies.ScalarReplacementOfAggregates.diff +++ b/tests/mir-opt/sroa/structs.copies.ScalarReplacementOfAggregates.diff @@ -43,38 +43,38 @@ bb0: { - StorageLive(_2); -- _2 = _1; +- _2 = copy _1; + StorageLive(_11); + StorageLive(_12); + StorageLive(_13); + StorageLive(_14); + nop; -+ _11 = (_1.0: u8); -+ _12 = (_1.1: ()); -+ _13 = (_1.2: &str); -+ _14 = (_1.3: std::option::Option); ++ _11 = copy (_1.0: u8); ++ _12 = copy (_1.1: ()); ++ _13 = copy (_1.2: &str); ++ _14 = copy (_1.3: std::option::Option); + nop; StorageLive(_3); -- _3 = (_2.0: u8); -+ _3 = _11; +- _3 = copy (_2.0: u8); ++ _3 = copy _11; StorageLive(_4); -- _4 = (_2.2: &str); +- _4 = copy (_2.2: &str); - StorageLive(_5); -- _5 = _2; -+ _4 = _13; +- _5 = copy _2; ++ _4 = copy _13; + StorageLive(_7); + StorageLive(_8); + StorageLive(_9); + StorageLive(_10); + nop; -+ _7 = _11; -+ _8 = _12; -+ _9 = _13; -+ _10 = _14; ++ _7 = copy _11; ++ _8 = copy _12; ++ _9 = copy _13; ++ _10 = copy _14; + nop; StorageLive(_6); -- _6 = (_5.1: ()); -+ _6 = _8; +- _6 = copy (_5.1: ()); ++ _6 = copy _8; _0 = const (); StorageDead(_6); - StorageDead(_5); diff --git a/tests/mir-opt/sroa/structs.enums.ScalarReplacementOfAggregates.diff b/tests/mir-opt/sroa/structs.enums.ScalarReplacementOfAggregates.diff index b5e39e632476..eda884de822a 100644 --- a/tests/mir-opt/sroa/structs.enums.ScalarReplacementOfAggregates.diff +++ b/tests/mir-opt/sroa/structs.enums.ScalarReplacementOfAggregates.diff @@ -15,7 +15,7 @@ bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; _2 = Option::::Some(move _3); StorageDead(_3); _4 = discriminant(_2); @@ -24,8 +24,8 @@ bb1: { StorageLive(_5); - _5 = ((_2 as Some).0: usize); - _0 = _5; + _5 = copy ((_2 as Some).0: usize); + _0 = copy _5; StorageDead(_5); goto -> bb3; } diff --git a/tests/mir-opt/sroa/structs.flat.ScalarReplacementOfAggregates.diff b/tests/mir-opt/sroa/structs.flat.ScalarReplacementOfAggregates.diff index a84048365a4b..77c7c1a90123 100644 --- a/tests/mir-opt/sroa/structs.flat.ScalarReplacementOfAggregates.diff +++ b/tests/mir-opt/sroa/structs.flat.ScalarReplacementOfAggregates.diff @@ -49,18 +49,18 @@ StorageDead(_7); StorageDead(_6); StorageLive(_1); -- _1 = (_5.0: u8); -+ _1 = _8; +- _1 = copy (_5.0: u8); ++ _1 = copy _8; StorageLive(_2); -- _2 = (_5.1: ()); -+ _2 = _9; +- _2 = copy (_5.1: ()); ++ _2 = copy _9; StorageLive(_3); -- _3 = (_5.2: &str); -+ _3 = _10; +- _3 = copy (_5.2: &str); ++ _3 = copy _10; StorageLive(_4); -- _4 = (_5.3: std::option::Option); +- _4 = copy (_5.3: std::option::Option); - StorageDead(_5); -+ _4 = _11; ++ _4 = copy _11; + StorageDead(_8); + StorageDead(_9); + StorageDead(_10); diff --git a/tests/mir-opt/sroa/structs.ref_copies.ScalarReplacementOfAggregates.diff b/tests/mir-opt/sroa/structs.ref_copies.ScalarReplacementOfAggregates.diff index 304bf2fb1a76..abe7cd78878f 100644 --- a/tests/mir-opt/sroa/structs.ref_copies.ScalarReplacementOfAggregates.diff +++ b/tests/mir-opt/sroa/structs.ref_copies.ScalarReplacementOfAggregates.diff @@ -27,23 +27,23 @@ bb0: { - StorageLive(_2); -- _2 = (*_1); +- _2 = copy (*_1); + StorageLive(_5); + StorageLive(_6); + StorageLive(_7); + StorageLive(_8); + nop; -+ _5 = ((*_1).0: u8); -+ _6 = ((*_1).1: ()); -+ _7 = ((*_1).2: &str); -+ _8 = ((*_1).3: std::option::Option); ++ _5 = copy ((*_1).0: u8); ++ _6 = copy ((*_1).1: ()); ++ _7 = copy ((*_1).2: &str); ++ _8 = copy ((*_1).3: std::option::Option); + nop; StorageLive(_3); -- _3 = (_2.0: u8); -+ _3 = _5; +- _3 = copy (_2.0: u8); ++ _3 = copy _5; StorageLive(_4); -- _4 = (_2.2: &str); -+ _4 = _7; +- _4 = copy (_2.2: &str); ++ _4 = copy _7; _0 = const (); StorageDead(_4); StorageDead(_3); diff --git a/tests/mir-opt/sroa/structs.structs.ScalarReplacementOfAggregates.diff b/tests/mir-opt/sroa/structs.structs.ScalarReplacementOfAggregates.diff index bf5c3e3bd030..fe9deabe9407 100644 --- a/tests/mir-opt/sroa/structs.structs.ScalarReplacementOfAggregates.diff +++ b/tests/mir-opt/sroa/structs.structs.ScalarReplacementOfAggregates.diff @@ -15,15 +15,15 @@ + StorageLive(_5); + nop; StorageLive(_3); - _3 = _1; + _3 = copy _1; - _2 = U { _foo: const 0_usize, a: move _3 }; + _4 = const 0_usize; + _5 = move _3; + nop; StorageDead(_3); -- _0 = (_2.1: f32); +- _0 = copy (_2.1: f32); - StorageDead(_2); -+ _0 = _5; ++ _0 = copy _5; + StorageDead(_4); + StorageDead(_5); + nop; diff --git a/tests/mir-opt/sroa/structs.unions.ScalarReplacementOfAggregates.diff b/tests/mir-opt/sroa/structs.unions.ScalarReplacementOfAggregates.diff index 2f8dfcc5d634..115f163cda9b 100644 --- a/tests/mir-opt/sroa/structs.unions.ScalarReplacementOfAggregates.diff +++ b/tests/mir-opt/sroa/structs.unions.ScalarReplacementOfAggregates.diff @@ -10,10 +10,10 @@ bb0: { StorageLive(_2); StorageLive(_3); - _3 = _1; + _3 = copy _1; _2 = Repr { f: move _3 }; StorageDead(_3); - _0 = (_2.1: u32); + _0 = copy (_2.1: u32); StorageDead(_2); return; } diff --git a/tests/mir-opt/storage_ranges.main.nll.0.mir b/tests/mir-opt/storage_ranges.main.nll.0.mir index 782efd5acc62..bc2dcfe0a645 100644 --- a/tests/mir-opt/storage_ranges.main.nll.0.mir +++ b/tests/mir-opt/storage_ranges.main.nll.0.mir @@ -43,7 +43,7 @@ fn main() -> () { StorageLive(_3); StorageLive(_4); StorageLive(_5); - _5 = _1; + _5 = copy _1; _4 = Option::::Some(move _5); StorageDead(_5); _3 = &_4; diff --git a/tests/mir-opt/switch_to_self.test.MatchBranchSimplification.diff b/tests/mir-opt/switch_to_self.test.MatchBranchSimplification.diff index c0b599e060b2..fef708d9962e 100644 --- a/tests/mir-opt/switch_to_self.test.MatchBranchSimplification.diff +++ b/tests/mir-opt/switch_to_self.test.MatchBranchSimplification.diff @@ -9,11 +9,11 @@ } bb1: { - switchInt(_1) -> [0: bb1, otherwise: bb2]; + switchInt(copy _1) -> [0: bb1, otherwise: bb2]; } bb2: { - switchInt(_1) -> [0: bb1, otherwise: bb2]; + switchInt(copy _1) -> [0: bb1, otherwise: bb2]; } } diff --git a/tests/mir-opt/tail_call_drops.f.ElaborateDrops.panic-abort.diff b/tests/mir-opt/tail_call_drops.f.ElaborateDrops.panic-abort.diff index 44673ea00a96..17c64d4baf0e 100644 --- a/tests/mir-opt/tail_call_drops.f.ElaborateDrops.panic-abort.diff +++ b/tests/mir-opt/tail_call_drops.f.ElaborateDrops.panic-abort.diff @@ -102,7 +102,7 @@ + } + + bb14 (cleanup): { -+ switchInt(_8) -> [0: bb11, otherwise: bb13]; ++ switchInt(copy _8) -> [0: bb11, otherwise: bb13]; } } diff --git a/tests/mir-opt/tail_call_drops.f.ElaborateDrops.panic-unwind.diff b/tests/mir-opt/tail_call_drops.f.ElaborateDrops.panic-unwind.diff index a6d33a245954..58d8a87986d6 100644 --- a/tests/mir-opt/tail_call_drops.f.ElaborateDrops.panic-unwind.diff +++ b/tests/mir-opt/tail_call_drops.f.ElaborateDrops.panic-unwind.diff @@ -103,7 +103,7 @@ + } + + bb14 (cleanup): { -+ switchInt(_8) -> [0: bb11, otherwise: bb13]; ++ switchInt(copy _8) -> [0: bb11, otherwise: bb13]; } } diff --git a/tests/mir-opt/tail_call_drops.f_with_arg.ElaborateDrops.panic-abort.diff b/tests/mir-opt/tail_call_drops.f_with_arg.ElaborateDrops.panic-abort.diff index c7df2bb2207f..1a51601bc56f 100644 --- a/tests/mir-opt/tail_call_drops.f_with_arg.ElaborateDrops.panic-abort.diff +++ b/tests/mir-opt/tail_call_drops.f_with_arg.ElaborateDrops.panic-abort.diff @@ -178,7 +178,7 @@ + } + + bb31 (cleanup): { -+ switchInt(_12) -> [0: bb26, otherwise: bb30]; ++ switchInt(copy _12) -> [0: bb26, otherwise: bb30]; } } diff --git a/tests/mir-opt/tail_call_drops.f_with_arg.ElaborateDrops.panic-unwind.diff b/tests/mir-opt/tail_call_drops.f_with_arg.ElaborateDrops.panic-unwind.diff index c7df2bb2207f..1a51601bc56f 100644 --- a/tests/mir-opt/tail_call_drops.f_with_arg.ElaborateDrops.panic-unwind.diff +++ b/tests/mir-opt/tail_call_drops.f_with_arg.ElaborateDrops.panic-unwind.diff @@ -178,7 +178,7 @@ + } + + bb31 (cleanup): { -+ switchInt(_12) -> [0: bb26, otherwise: bb30]; ++ switchInt(copy _12) -> [0: bb26, otherwise: bb30]; } } diff --git a/tests/mir-opt/unnamed-fields/field_access.bar.SimplifyCfg-initial.after.mir b/tests/mir-opt/unnamed-fields/field_access.bar.SimplifyCfg-initial.after.mir index f0311422c17b..f1904e5d0f44 100644 --- a/tests/mir-opt/unnamed-fields/field_access.bar.SimplifyCfg-initial.after.mir +++ b/tests/mir-opt/unnamed-fields/field_access.bar.SimplifyCfg-initial.after.mir @@ -15,7 +15,7 @@ fn bar(_1: Bar) -> () { bb0: { StorageLive(_2); StorageLive(_3); - _3 = (_1.0: u8); + _3 = copy (_1.0: u8); _2 = access::(move _3) -> [return: bb1, unwind: bb5]; } @@ -24,7 +24,7 @@ fn bar(_1: Bar) -> () { StorageDead(_2); StorageLive(_4); StorageLive(_5); - _5 = ((_1.1: Bar::{anon_adt#0}).0: i8); + _5 = copy ((_1.1: Bar::{anon_adt#0}).0: i8); _4 = access::(move _5) -> [return: bb2, unwind: bb5]; } @@ -33,7 +33,7 @@ fn bar(_1: Bar) -> () { StorageDead(_4); StorageLive(_6); StorageLive(_7); - _7 = ((_1.1: Bar::{anon_adt#0}).1: bool); + _7 = copy ((_1.1: Bar::{anon_adt#0}).1: bool); _6 = access::(move _7) -> [return: bb3, unwind: bb5]; } @@ -42,7 +42,7 @@ fn bar(_1: Bar) -> () { StorageDead(_6); StorageLive(_8); StorageLive(_9); - _9 = (((_1.2: Bar::{anon_adt#1}).0: Bar::{anon_adt#1}::{anon_adt#0}).0: [u8; 1]); + _9 = copy (((_1.2: Bar::{anon_adt#1}).0: Bar::{anon_adt#1}::{anon_adt#0}).0: [u8; 1]); _8 = access::<[u8; 1]>(move _9) -> [return: bb4, unwind: bb5]; } diff --git a/tests/mir-opt/unnamed-fields/field_access.foo.SimplifyCfg-initial.after.mir b/tests/mir-opt/unnamed-fields/field_access.foo.SimplifyCfg-initial.after.mir index d48a969f06eb..c279f5900121 100644 --- a/tests/mir-opt/unnamed-fields/field_access.foo.SimplifyCfg-initial.after.mir +++ b/tests/mir-opt/unnamed-fields/field_access.foo.SimplifyCfg-initial.after.mir @@ -15,7 +15,7 @@ fn foo(_1: Foo) -> () { bb0: { StorageLive(_2); StorageLive(_3); - _3 = (_1.0: u8); + _3 = copy (_1.0: u8); _2 = access::(move _3) -> [return: bb1, unwind: bb5]; } @@ -24,7 +24,7 @@ fn foo(_1: Foo) -> () { StorageDead(_2); StorageLive(_4); StorageLive(_5); - _5 = ((_1.1: Foo::{anon_adt#0}).0: i8); + _5 = copy ((_1.1: Foo::{anon_adt#0}).0: i8); _4 = access::(move _5) -> [return: bb2, unwind: bb5]; } @@ -33,7 +33,7 @@ fn foo(_1: Foo) -> () { StorageDead(_4); StorageLive(_6); StorageLive(_7); - _7 = ((_1.1: Foo::{anon_adt#0}).1: bool); + _7 = copy ((_1.1: Foo::{anon_adt#0}).1: bool); _6 = access::(move _7) -> [return: bb3, unwind: bb5]; } @@ -42,7 +42,7 @@ fn foo(_1: Foo) -> () { StorageDead(_6); StorageLive(_8); StorageLive(_9); - _9 = (((_1.2: Foo::{anon_adt#1}).0: Foo::{anon_adt#1}::{anon_adt#0}).0: [u8; 1]); + _9 = copy (((_1.2: Foo::{anon_adt#1}).0: Foo::{anon_adt#1}::{anon_adt#0}).0: [u8; 1]); _8 = access::<[u8; 1]>(move _9) -> [return: bb4, unwind: bb5]; } diff --git a/tests/mir-opt/unreachable.as_match.UnreachablePropagation.panic-abort.diff b/tests/mir-opt/unreachable.as_match.UnreachablePropagation.panic-abort.diff index 1e1ddfae0eb9..17ddce0cdf8d 100644 --- a/tests/mir-opt/unreachable.as_match.UnreachablePropagation.panic-abort.diff +++ b/tests/mir-opt/unreachable.as_match.UnreachablePropagation.panic-abort.diff @@ -20,7 +20,7 @@ bb1: { _2 = discriminant(_1); - switchInt(move _2) -> [1: bb3, otherwise: bb2]; -+ _5 = Ne(_2, const 1_isize); ++ _5 = Ne(copy _2, const 1_isize); + assume(move _5); + goto -> bb2; } diff --git a/tests/mir-opt/unreachable.as_match.UnreachablePropagation.panic-unwind.diff b/tests/mir-opt/unreachable.as_match.UnreachablePropagation.panic-unwind.diff index 809d24aa15a1..2f78092f5bd2 100644 --- a/tests/mir-opt/unreachable.as_match.UnreachablePropagation.panic-unwind.diff +++ b/tests/mir-opt/unreachable.as_match.UnreachablePropagation.panic-unwind.diff @@ -20,7 +20,7 @@ bb1: { _2 = discriminant(_1); - switchInt(move _2) -> [1: bb3, otherwise: bb2]; -+ _5 = Ne(_2, const 1_isize); ++ _5 = Ne(copy _2, const 1_isize); + assume(move _5); + goto -> bb2; } diff --git a/tests/mir-opt/unreachable.if_let.UnreachablePropagation.panic-abort.diff b/tests/mir-opt/unreachable.if_let.UnreachablePropagation.panic-abort.diff index 61959732720e..2ce37c4422b9 100644 --- a/tests/mir-opt/unreachable.if_let.UnreachablePropagation.panic-abort.diff +++ b/tests/mir-opt/unreachable.if_let.UnreachablePropagation.panic-abort.diff @@ -26,7 +26,7 @@ bb1: { _2 = discriminant(_1); - switchInt(move _2) -> [1: bb2, otherwise: bb6]; -+ _8 = Ne(_2, const 1_isize); ++ _8 = Ne(copy _2, const 1_isize); + assume(move _8); + goto -> bb6; } diff --git a/tests/mir-opt/unreachable.if_let.UnreachablePropagation.panic-unwind.diff b/tests/mir-opt/unreachable.if_let.UnreachablePropagation.panic-unwind.diff index 476e2f559944..2dfba10c37df 100644 --- a/tests/mir-opt/unreachable.if_let.UnreachablePropagation.panic-unwind.diff +++ b/tests/mir-opt/unreachable.if_let.UnreachablePropagation.panic-unwind.diff @@ -26,7 +26,7 @@ bb1: { _2 = discriminant(_1); - switchInt(move _2) -> [1: bb2, otherwise: bb6]; -+ _8 = Ne(_2, const 1_isize); ++ _8 = Ne(copy _2, const 1_isize); + assume(move _8); + goto -> bb6; } diff --git a/tests/mir-opt/unreachable_diverging.main.UnreachablePropagation.panic-abort.diff b/tests/mir-opt/unreachable_diverging.main.UnreachablePropagation.panic-abort.diff index 11d7924e7360..ba268832ca3c 100644 --- a/tests/mir-opt/unreachable_diverging.main.UnreachablePropagation.panic-abort.diff +++ b/tests/mir-opt/unreachable_diverging.main.UnreachablePropagation.panic-abort.diff @@ -35,9 +35,9 @@ _4 = move ((_2 as Some).0: Empty); StorageLive(_5); StorageLive(_6); - _6 = _1; + _6 = copy _1; - switchInt(move _6) -> [0: bb4, otherwise: bb3]; -+ _8 = Ne(_6, const false); ++ _8 = Ne(copy _6, const false); + assume(move _8); + goto -> bb3; } diff --git a/tests/mir-opt/unreachable_diverging.main.UnreachablePropagation.panic-unwind.diff b/tests/mir-opt/unreachable_diverging.main.UnreachablePropagation.panic-unwind.diff index df6f5609fbfa..f057f7764704 100644 --- a/tests/mir-opt/unreachable_diverging.main.UnreachablePropagation.panic-unwind.diff +++ b/tests/mir-opt/unreachable_diverging.main.UnreachablePropagation.panic-unwind.diff @@ -35,9 +35,9 @@ _4 = move ((_2 as Some).0: Empty); StorageLive(_5); StorageLive(_6); - _6 = _1; + _6 = copy _1; - switchInt(move _6) -> [0: bb4, otherwise: bb3]; -+ _8 = Ne(_6, const false); ++ _8 = Ne(copy _6, const false); + assume(move _8); + goto -> bb3; } diff --git a/tests/mir-opt/unreachable_enum_branching.otherwise_t4_unreachable_default_2.UnreachableEnumBranching.panic-abort.diff b/tests/mir-opt/unreachable_enum_branching.otherwise_t4_unreachable_default_2.UnreachableEnumBranching.panic-abort.diff index 4cd6d3f56833..17e01f38f4eb 100644 --- a/tests/mir-opt/unreachable_enum_branching.otherwise_t4_unreachable_default_2.UnreachableEnumBranching.panic-abort.diff +++ b/tests/mir-opt/unreachable_enum_branching.otherwise_t4_unreachable_default_2.UnreachableEnumBranching.panic-abort.diff @@ -29,7 +29,7 @@ } bb2: { - switchInt(((_2 as A).0: i32)) -> [1: bb6, 2: bb5, otherwise: bb1]; + switchInt(copy ((_2 as A).0: i32)) -> [1: bb6, 2: bb5, otherwise: bb1]; } bb3: { diff --git a/tests/mir-opt/unreachable_enum_branching.otherwise_t4_unreachable_default_2.UnreachableEnumBranching.panic-unwind.diff b/tests/mir-opt/unreachable_enum_branching.otherwise_t4_unreachable_default_2.UnreachableEnumBranching.panic-unwind.diff index 4cd6d3f56833..17e01f38f4eb 100644 --- a/tests/mir-opt/unreachable_enum_branching.otherwise_t4_unreachable_default_2.UnreachableEnumBranching.panic-unwind.diff +++ b/tests/mir-opt/unreachable_enum_branching.otherwise_t4_unreachable_default_2.UnreachableEnumBranching.panic-unwind.diff @@ -29,7 +29,7 @@ } bb2: { - switchInt(((_2 as A).0: i32)) -> [1: bb6, 2: bb5, otherwise: bb1]; + switchInt(copy ((_2 as A).0: i32)) -> [1: bb6, 2: bb5, otherwise: bb1]; } bb3: { From b9cffa7de071e8deae2b0c6b4780bba25f8ec875 Mon Sep 17 00:00:00 2001 From: Scott McMurray Date: Sun, 18 Aug 2024 16:09:03 -0700 Subject: [PATCH 73/79] Exclude the copy blessing from git blame --- .git-blame-ignore-revs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs index 9fd8054a12e4..ec76a1a42ef0 100644 --- a/.git-blame-ignore-revs +++ b/.git-blame-ignore-revs @@ -25,3 +25,5 @@ b2d2184edea578109a48ec3d8decbee5948e8f35 ec2cc761bc7067712ecc7734502f703fe3b024c8 # format use declarations 84ac80f1921afc243d71fd0caaa4f2838c294102 +# bless mir-opt tests to add `copy` +99cb0c6bc399fb94a0ddde7e9b38e9c00d523bad From da7dd434c8086378a44ed2c379050dbe5c01a5d7 Mon Sep 17 00:00:00 2001 From: Wafarm Date: Sun, 18 Aug 2024 10:44:17 +0800 Subject: [PATCH 74/79] Fix wrong argument for `get_fn_decl` --- compiler/rustc_hir_typeck/src/coercion.rs | 2 +- .../async-fn/recurse-ice-129215.rs | 9 +++++ .../async-fn/recurse-ice-129215.stderr | 34 +++++++++++++++++++ .../add_semicolon_non_block_closure.rs | 1 + .../add_semicolon_non_block_closure.stderr | 6 ++-- 5 files changed, 49 insertions(+), 3 deletions(-) create mode 100644 tests/ui/async-await/async-fn/recurse-ice-129215.rs create mode 100644 tests/ui/async-await/async-fn/recurse-ice-129215.stderr diff --git a/compiler/rustc_hir_typeck/src/coercion.rs b/compiler/rustc_hir_typeck/src/coercion.rs index d53df251a153..9b34c59f1f1b 100644 --- a/compiler/rustc_hir_typeck/src/coercion.rs +++ b/compiler/rustc_hir_typeck/src/coercion.rs @@ -1859,7 +1859,7 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> { }; // If this is due to an explicit `return`, suggest adding a return type. - if let Some((fn_id, fn_decl, can_suggest)) = fcx.get_fn_decl(parent_id) + if let Some((fn_id, fn_decl, can_suggest)) = fcx.get_fn_decl(block_or_return_id) && !due_to_block { fcx.suggest_missing_return_type(&mut err, fn_decl, expected, found, can_suggest, fn_id); diff --git a/tests/ui/async-await/async-fn/recurse-ice-129215.rs b/tests/ui/async-await/async-fn/recurse-ice-129215.rs new file mode 100644 index 000000000000..06a2d7be9efb --- /dev/null +++ b/tests/ui/async-await/async-fn/recurse-ice-129215.rs @@ -0,0 +1,9 @@ +//@ edition: 2021 + +async fn a() { + //~^ ERROR `()` is not a future + //~| ERROR mismatched types + a() //~ ERROR `()` is not a future +} + +fn main() {} diff --git a/tests/ui/async-await/async-fn/recurse-ice-129215.stderr b/tests/ui/async-await/async-fn/recurse-ice-129215.stderr new file mode 100644 index 000000000000..98c7be2a5a3f --- /dev/null +++ b/tests/ui/async-await/async-fn/recurse-ice-129215.stderr @@ -0,0 +1,34 @@ +error[E0277]: `()` is not a future + --> $DIR/recurse-ice-129215.rs:6:5 + | +LL | a() + | ^^^ `()` is not a future + | + = help: the trait `Future` is not implemented for `()` + +error[E0277]: `()` is not a future + --> $DIR/recurse-ice-129215.rs:3:1 + | +LL | async fn a() { + | ^^^^^^^^^^^^ `()` is not a future + | + = help: the trait `Future` is not implemented for `()` + +error[E0308]: mismatched types + --> $DIR/recurse-ice-129215.rs:3:14 + | +LL | async fn a() { + | ______________^ +LL | | +LL | | +LL | | a() +LL | | } + | |_^ expected `()`, found `async` fn body + | + = note: expected unit type `()` + found `async` fn body `{async fn body of a()}` + +error: aborting due to 3 previous errors + +Some errors have detailed explanations: E0277, E0308. +For more information about an error, try `rustc --explain E0277`. diff --git a/tests/ui/closures/add_semicolon_non_block_closure.rs b/tests/ui/closures/add_semicolon_non_block_closure.rs index 3ae91be60c5a..62c5e343cd34 100644 --- a/tests/ui/closures/add_semicolon_non_block_closure.rs +++ b/tests/ui/closures/add_semicolon_non_block_closure.rs @@ -8,4 +8,5 @@ fn main() { foo(|| bar()) //~^ ERROR mismatched types [E0308] //~| HELP consider using a semicolon here + //~| HELP try adding a return type } diff --git a/tests/ui/closures/add_semicolon_non_block_closure.stderr b/tests/ui/closures/add_semicolon_non_block_closure.stderr index d095e59c7ebb..7883db8f98ec 100644 --- a/tests/ui/closures/add_semicolon_non_block_closure.stderr +++ b/tests/ui/closures/add_semicolon_non_block_closure.stderr @@ -1,8 +1,6 @@ error[E0308]: mismatched types --> $DIR/add_semicolon_non_block_closure.rs:8:12 | -LL | fn main() { - | - expected `()` because of default return type LL | foo(|| bar()) | ^^^^^ expected `()`, found `i32` | @@ -10,6 +8,10 @@ help: consider using a semicolon here | LL | foo(|| { bar(); }) | + +++ +help: try adding a return type + | +LL | foo(|| -> i32 bar()) + | ++++++ error: aborting due to 1 previous error From 1eb1e1816d3e42f3f31be75aae3c147302ae02a6 Mon Sep 17 00:00:00 2001 From: Trevor Gross Date: Sun, 18 Aug 2024 22:51:04 -0500 Subject: [PATCH 75/79] Adjust expected errors for a `rustdoc` test `pulldown-cmark` has slightly different behavior between 0.11.0 and 0.11.2, causing one of the `unportable-markdown` tests to no longer emit an error. Per [1], remove the error annotation and bless the output. [1]: https://github.com/rust-lang/rust/pull/128722#issuecomment-2295522292 --- tests/rustdoc-ui/unportable-markdown.rs | 1 - tests/rustdoc-ui/unportable-markdown.stderr | 30 +++++---------------- 2 files changed, 7 insertions(+), 24 deletions(-) diff --git a/tests/rustdoc-ui/unportable-markdown.rs b/tests/rustdoc-ui/unportable-markdown.rs index 8035e680f3cf..105fc1e59d53 100644 --- a/tests/rustdoc-ui/unportable-markdown.rs +++ b/tests/rustdoc-ui/unportable-markdown.rs @@ -19,7 +19,6 @@ pub struct GfmFootnotes; /// /// /// test [^foo][^bar] -//~^ ERROR unportable markdown /// /// [^foo]: test /// [^bar]: test2 diff --git a/tests/rustdoc-ui/unportable-markdown.stderr b/tests/rustdoc-ui/unportable-markdown.stderr index b524aca25aef..952ae4bb6eec 100644 --- a/tests/rustdoc-ui/unportable-markdown.stderr +++ b/tests/rustdoc-ui/unportable-markdown.stderr @@ -1,31 +1,15 @@ error: unportable markdown - --> $DIR/unportable-markdown.rs:21:10 - | -LL | /// test [^foo][^bar] - | ^^^^^^ - | - = help: confusing footnote reference and link -note: the lint level is defined here - --> $DIR/unportable-markdown.rs:8:9 - | -LL | #![deny(rustdoc::unportable_markdown)] - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -help: if it should not be a footnote, escape it - | -LL | /// test \[^foo][^bar] - | + -help: if the footnote is intended, add a space - | -LL | /// test [^foo] [^bar] - | + - -error: unportable markdown - --> $DIR/unportable-markdown.rs:49:5 + --> $DIR/unportable-markdown.rs:48:5 | LL | /// >bar | ^ | = help: confusing block quote with no space after the `>` marker +note: the lint level is defined here + --> $DIR/unportable-markdown.rs:8:9 + | +LL | #![deny(rustdoc::unportable_markdown)] + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if the quote is intended, add a space | LL | /// > bar @@ -35,5 +19,5 @@ help: if it should not be a quote, escape it LL | /// \>bar | + -error: aborting due to 2 previous errors +error: aborting due to 1 previous error From 370168787bd6f2ed26788a51af97166d868e0609 Mon Sep 17 00:00:00 2001 From: Trevor Gross Date: Wed, 7 Aug 2024 02:11:05 -0500 Subject: [PATCH 76/79] Generate completions after version updates Running `cargo update` changed completion output. Regenerate them here. --- src/etc/completions/x.py.fish | 1354 +++++++++++++-------------- src/etc/completions/x.py.ps1 | 1438 ++++++++++++++--------------- src/etc/completions/x.py.sh | 1631 +++++++++++++++++++++++++++++++-- src/etc/completions/x.py.zsh | 36 +- 4 files changed, 2988 insertions(+), 1471 deletions(-) diff --git a/src/etc/completions/x.py.fish b/src/etc/completions/x.py.fish index 297dc11cd614..3a83c89280f9 100644 --- a/src/etc/completions/x.py.fish +++ b/src/etc/completions/x.py.fish @@ -1,664 +1,690 @@ -complete -c x.py -n "__fish_use_subcommand" -l config -d 'TOML configuration file for build' -r -F -complete -c x.py -n "__fish_use_subcommand" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_use_subcommand" -l build -d 'build target of the stage0 compiler' -r -f -complete -c x.py -n "__fish_use_subcommand" -l host -d 'host targets to build' -r -f -complete -c x.py -n "__fish_use_subcommand" -l target -d 'target targets to build' -r -f -complete -c x.py -n "__fish_use_subcommand" -l exclude -d 'build paths to exclude' -r -F -complete -c x.py -n "__fish_use_subcommand" -l skip -d 'build paths to skip' -r -F -complete -c x.py -n "__fish_use_subcommand" -l rustc-error-format -r -f -complete -c x.py -n "__fish_use_subcommand" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" -complete -c x.py -n "__fish_use_subcommand" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f -complete -c x.py -n "__fish_use_subcommand" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_use_subcommand" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_use_subcommand" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_use_subcommand" -s j -l jobs -d 'number of jobs to run in parallel' -r -f -complete -c x.py -n "__fish_use_subcommand" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny '',warn '',default ''}" -complete -c x.py -n "__fish_use_subcommand" -l error-format -d 'rustc error format' -r -f -complete -c x.py -n "__fish_use_subcommand" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always '',never '',auto ''}" -complete -c x.py -n "__fish_use_subcommand" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true '',false ''}" -complete -c x.py -n "__fish_use_subcommand" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F -complete -c x.py -n "__fish_use_subcommand" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F -complete -c x.py -n "__fish_use_subcommand" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F -complete -c x.py -n "__fish_use_subcommand" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r -complete -c x.py -n "__fish_use_subcommand" -l set -d 'override options in config.toml' -r -f -complete -c x.py -n "__fish_use_subcommand" -s v -l verbose -d 'use verbose output (-vv for very verbose)' -complete -c x.py -n "__fish_use_subcommand" -s i -l incremental -d 'use incremental compilation' -complete -c x.py -n "__fish_use_subcommand" -l include-default-paths -d 'include default paths in addition to the provided ones' -complete -c x.py -n "__fish_use_subcommand" -l dry-run -d 'dry run; don\'t build anything' -complete -c x.py -n "__fish_use_subcommand" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' -complete -c x.py -n "__fish_use_subcommand" -l json-output -d 'use message-format=json' -complete -c x.py -n "__fish_use_subcommand" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' -complete -c x.py -n "__fish_use_subcommand" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' -complete -c x.py -n "__fish_use_subcommand" -l enable-bolt-settings -d 'Enable BOLT link flags' -complete -c x.py -n "__fish_use_subcommand" -l skip-stage0-validation -d 'Skip stage0 compiler validation' -complete -c x.py -n "__fish_use_subcommand" -s h -l help -d 'Print help (see more with \'--help\')' -complete -c x.py -n "__fish_use_subcommand" -f -a "build" -d 'Compile either the compiler or libraries' -complete -c x.py -n "__fish_use_subcommand" -f -a "check" -d 'Compile either the compiler or libraries, using cargo check' -complete -c x.py -n "__fish_use_subcommand" -f -a "clippy" -d 'Run Clippy (uses rustup/cargo-installed clippy binary)' -complete -c x.py -n "__fish_use_subcommand" -f -a "fix" -d 'Run cargo fix' -complete -c x.py -n "__fish_use_subcommand" -f -a "fmt" -d 'Run rustfmt' -complete -c x.py -n "__fish_use_subcommand" -f -a "doc" -d 'Build documentation' -complete -c x.py -n "__fish_use_subcommand" -f -a "test" -d 'Build and run some test suites' -complete -c x.py -n "__fish_use_subcommand" -f -a "miri" -d 'Build and run some test suites *in Miri*' -complete -c x.py -n "__fish_use_subcommand" -f -a "bench" -d 'Build and run some benchmarks' -complete -c x.py -n "__fish_use_subcommand" -f -a "clean" -d 'Clean out build directories' -complete -c x.py -n "__fish_use_subcommand" -f -a "dist" -d 'Build distribution artifacts' -complete -c x.py -n "__fish_use_subcommand" -f -a "install" -d 'Install distribution artifacts' -complete -c x.py -n "__fish_use_subcommand" -f -a "run" -d 'Run tools contained in this repository' -complete -c x.py -n "__fish_use_subcommand" -f -a "setup" -d 'Set up the environment for development' -complete -c x.py -n "__fish_use_subcommand" -f -a "suggest" -d 'Suggest a subset of tests to run, based on modified files' -complete -c x.py -n "__fish_use_subcommand" -f -a "vendor" -d 'Vendor dependencies' -complete -c x.py -n "__fish_use_subcommand" -f -a "perf" -d 'Perform profiling and benchmarking of the compiler using the `rustc-perf-wrapper` tool' -complete -c x.py -n "__fish_seen_subcommand_from build" -l config -d 'TOML configuration file for build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from build" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_seen_subcommand_from build" -l build -d 'build target of the stage0 compiler' -r -f -complete -c x.py -n "__fish_seen_subcommand_from build" -l host -d 'host targets to build' -r -f -complete -c x.py -n "__fish_seen_subcommand_from build" -l target -d 'target targets to build' -r -f -complete -c x.py -n "__fish_seen_subcommand_from build" -l exclude -d 'build paths to exclude' -r -F -complete -c x.py -n "__fish_seen_subcommand_from build" -l skip -d 'build paths to skip' -r -F -complete -c x.py -n "__fish_seen_subcommand_from build" -l rustc-error-format -r -f -complete -c x.py -n "__fish_seen_subcommand_from build" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" -complete -c x.py -n "__fish_seen_subcommand_from build" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from build" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from build" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from build" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_seen_subcommand_from build" -s j -l jobs -d 'number of jobs to run in parallel' -r -f -complete -c x.py -n "__fish_seen_subcommand_from build" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny '',warn '',default ''}" -complete -c x.py -n "__fish_seen_subcommand_from build" -l error-format -d 'rustc error format' -r -f -complete -c x.py -n "__fish_seen_subcommand_from build" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always '',never '',auto ''}" -complete -c x.py -n "__fish_seen_subcommand_from build" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true '',false ''}" -complete -c x.py -n "__fish_seen_subcommand_from build" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from build" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from build" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from build" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r -complete -c x.py -n "__fish_seen_subcommand_from build" -l set -d 'override options in config.toml' -r -f -complete -c x.py -n "__fish_seen_subcommand_from build" -s v -l verbose -d 'use verbose output (-vv for very verbose)' -complete -c x.py -n "__fish_seen_subcommand_from build" -s i -l incremental -d 'use incremental compilation' -complete -c x.py -n "__fish_seen_subcommand_from build" -l include-default-paths -d 'include default paths in addition to the provided ones' -complete -c x.py -n "__fish_seen_subcommand_from build" -l dry-run -d 'dry run; don\'t build anything' -complete -c x.py -n "__fish_seen_subcommand_from build" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' -complete -c x.py -n "__fish_seen_subcommand_from build" -l json-output -d 'use message-format=json' -complete -c x.py -n "__fish_seen_subcommand_from build" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' -complete -c x.py -n "__fish_seen_subcommand_from build" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' -complete -c x.py -n "__fish_seen_subcommand_from build" -l enable-bolt-settings -d 'Enable BOLT link flags' -complete -c x.py -n "__fish_seen_subcommand_from build" -l skip-stage0-validation -d 'Skip stage0 compiler validation' -complete -c x.py -n "__fish_seen_subcommand_from build" -s h -l help -d 'Print help (see more with \'--help\')' -complete -c x.py -n "__fish_seen_subcommand_from check" -l config -d 'TOML configuration file for build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from check" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_seen_subcommand_from check" -l build -d 'build target of the stage0 compiler' -r -f -complete -c x.py -n "__fish_seen_subcommand_from check" -l host -d 'host targets to build' -r -f -complete -c x.py -n "__fish_seen_subcommand_from check" -l target -d 'target targets to build' -r -f -complete -c x.py -n "__fish_seen_subcommand_from check" -l exclude -d 'build paths to exclude' -r -F -complete -c x.py -n "__fish_seen_subcommand_from check" -l skip -d 'build paths to skip' -r -F -complete -c x.py -n "__fish_seen_subcommand_from check" -l rustc-error-format -r -f -complete -c x.py -n "__fish_seen_subcommand_from check" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" -complete -c x.py -n "__fish_seen_subcommand_from check" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from check" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from check" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from check" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_seen_subcommand_from check" -s j -l jobs -d 'number of jobs to run in parallel' -r -f -complete -c x.py -n "__fish_seen_subcommand_from check" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny '',warn '',default ''}" -complete -c x.py -n "__fish_seen_subcommand_from check" -l error-format -d 'rustc error format' -r -f -complete -c x.py -n "__fish_seen_subcommand_from check" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always '',never '',auto ''}" -complete -c x.py -n "__fish_seen_subcommand_from check" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true '',false ''}" -complete -c x.py -n "__fish_seen_subcommand_from check" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from check" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from check" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from check" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r -complete -c x.py -n "__fish_seen_subcommand_from check" -l set -d 'override options in config.toml' -r -f -complete -c x.py -n "__fish_seen_subcommand_from check" -l all-targets -d 'Check all targets' -complete -c x.py -n "__fish_seen_subcommand_from check" -s v -l verbose -d 'use verbose output (-vv for very verbose)' -complete -c x.py -n "__fish_seen_subcommand_from check" -s i -l incremental -d 'use incremental compilation' -complete -c x.py -n "__fish_seen_subcommand_from check" -l include-default-paths -d 'include default paths in addition to the provided ones' -complete -c x.py -n "__fish_seen_subcommand_from check" -l dry-run -d 'dry run; don\'t build anything' -complete -c x.py -n "__fish_seen_subcommand_from check" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' -complete -c x.py -n "__fish_seen_subcommand_from check" -l json-output -d 'use message-format=json' -complete -c x.py -n "__fish_seen_subcommand_from check" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' -complete -c x.py -n "__fish_seen_subcommand_from check" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' -complete -c x.py -n "__fish_seen_subcommand_from check" -l enable-bolt-settings -d 'Enable BOLT link flags' -complete -c x.py -n "__fish_seen_subcommand_from check" -l skip-stage0-validation -d 'Skip stage0 compiler validation' -complete -c x.py -n "__fish_seen_subcommand_from check" -s h -l help -d 'Print help (see more with \'--help\')' -complete -c x.py -n "__fish_seen_subcommand_from clippy" -s A -d 'clippy lints to allow' -r -complete -c x.py -n "__fish_seen_subcommand_from clippy" -s D -d 'clippy lints to deny' -r -complete -c x.py -n "__fish_seen_subcommand_from clippy" -s W -d 'clippy lints to warn on' -r -complete -c x.py -n "__fish_seen_subcommand_from clippy" -s F -d 'clippy lints to forbid' -r -complete -c x.py -n "__fish_seen_subcommand_from clippy" -l config -d 'TOML configuration file for build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from clippy" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_seen_subcommand_from clippy" -l build -d 'build target of the stage0 compiler' -r -f -complete -c x.py -n "__fish_seen_subcommand_from clippy" -l host -d 'host targets to build' -r -f -complete -c x.py -n "__fish_seen_subcommand_from clippy" -l target -d 'target targets to build' -r -f -complete -c x.py -n "__fish_seen_subcommand_from clippy" -l exclude -d 'build paths to exclude' -r -F -complete -c x.py -n "__fish_seen_subcommand_from clippy" -l skip -d 'build paths to skip' -r -F -complete -c x.py -n "__fish_seen_subcommand_from clippy" -l rustc-error-format -r -f -complete -c x.py -n "__fish_seen_subcommand_from clippy" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" -complete -c x.py -n "__fish_seen_subcommand_from clippy" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from clippy" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from clippy" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from clippy" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_seen_subcommand_from clippy" -s j -l jobs -d 'number of jobs to run in parallel' -r -f -complete -c x.py -n "__fish_seen_subcommand_from clippy" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny '',warn '',default ''}" -complete -c x.py -n "__fish_seen_subcommand_from clippy" -l error-format -d 'rustc error format' -r -f -complete -c x.py -n "__fish_seen_subcommand_from clippy" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always '',never '',auto ''}" -complete -c x.py -n "__fish_seen_subcommand_from clippy" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true '',false ''}" -complete -c x.py -n "__fish_seen_subcommand_from clippy" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from clippy" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from clippy" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from clippy" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r -complete -c x.py -n "__fish_seen_subcommand_from clippy" -l set -d 'override options in config.toml' -r -f -complete -c x.py -n "__fish_seen_subcommand_from clippy" -l fix -complete -c x.py -n "__fish_seen_subcommand_from clippy" -l allow-dirty -complete -c x.py -n "__fish_seen_subcommand_from clippy" -l allow-staged -complete -c x.py -n "__fish_seen_subcommand_from clippy" -s v -l verbose -d 'use verbose output (-vv for very verbose)' -complete -c x.py -n "__fish_seen_subcommand_from clippy" -s i -l incremental -d 'use incremental compilation' -complete -c x.py -n "__fish_seen_subcommand_from clippy" -l include-default-paths -d 'include default paths in addition to the provided ones' -complete -c x.py -n "__fish_seen_subcommand_from clippy" -l dry-run -d 'dry run; don\'t build anything' -complete -c x.py -n "__fish_seen_subcommand_from clippy" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' -complete -c x.py -n "__fish_seen_subcommand_from clippy" -l json-output -d 'use message-format=json' -complete -c x.py -n "__fish_seen_subcommand_from clippy" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' -complete -c x.py -n "__fish_seen_subcommand_from clippy" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' -complete -c x.py -n "__fish_seen_subcommand_from clippy" -l enable-bolt-settings -d 'Enable BOLT link flags' -complete -c x.py -n "__fish_seen_subcommand_from clippy" -l skip-stage0-validation -d 'Skip stage0 compiler validation' -complete -c x.py -n "__fish_seen_subcommand_from clippy" -s h -l help -d 'Print help (see more with \'--help\')' -complete -c x.py -n "__fish_seen_subcommand_from fix" -l config -d 'TOML configuration file for build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from fix" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_seen_subcommand_from fix" -l build -d 'build target of the stage0 compiler' -r -f -complete -c x.py -n "__fish_seen_subcommand_from fix" -l host -d 'host targets to build' -r -f -complete -c x.py -n "__fish_seen_subcommand_from fix" -l target -d 'target targets to build' -r -f -complete -c x.py -n "__fish_seen_subcommand_from fix" -l exclude -d 'build paths to exclude' -r -F -complete -c x.py -n "__fish_seen_subcommand_from fix" -l skip -d 'build paths to skip' -r -F -complete -c x.py -n "__fish_seen_subcommand_from fix" -l rustc-error-format -r -f -complete -c x.py -n "__fish_seen_subcommand_from fix" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" -complete -c x.py -n "__fish_seen_subcommand_from fix" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from fix" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from fix" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from fix" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_seen_subcommand_from fix" -s j -l jobs -d 'number of jobs to run in parallel' -r -f -complete -c x.py -n "__fish_seen_subcommand_from fix" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny '',warn '',default ''}" -complete -c x.py -n "__fish_seen_subcommand_from fix" -l error-format -d 'rustc error format' -r -f -complete -c x.py -n "__fish_seen_subcommand_from fix" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always '',never '',auto ''}" -complete -c x.py -n "__fish_seen_subcommand_from fix" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true '',false ''}" -complete -c x.py -n "__fish_seen_subcommand_from fix" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from fix" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from fix" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from fix" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r -complete -c x.py -n "__fish_seen_subcommand_from fix" -l set -d 'override options in config.toml' -r -f -complete -c x.py -n "__fish_seen_subcommand_from fix" -s v -l verbose -d 'use verbose output (-vv for very verbose)' -complete -c x.py -n "__fish_seen_subcommand_from fix" -s i -l incremental -d 'use incremental compilation' -complete -c x.py -n "__fish_seen_subcommand_from fix" -l include-default-paths -d 'include default paths in addition to the provided ones' -complete -c x.py -n "__fish_seen_subcommand_from fix" -l dry-run -d 'dry run; don\'t build anything' -complete -c x.py -n "__fish_seen_subcommand_from fix" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' -complete -c x.py -n "__fish_seen_subcommand_from fix" -l json-output -d 'use message-format=json' -complete -c x.py -n "__fish_seen_subcommand_from fix" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' -complete -c x.py -n "__fish_seen_subcommand_from fix" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' -complete -c x.py -n "__fish_seen_subcommand_from fix" -l enable-bolt-settings -d 'Enable BOLT link flags' -complete -c x.py -n "__fish_seen_subcommand_from fix" -l skip-stage0-validation -d 'Skip stage0 compiler validation' -complete -c x.py -n "__fish_seen_subcommand_from fix" -s h -l help -d 'Print help (see more with \'--help\')' -complete -c x.py -n "__fish_seen_subcommand_from fmt" -l config -d 'TOML configuration file for build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from fmt" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_seen_subcommand_from fmt" -l build -d 'build target of the stage0 compiler' -r -f -complete -c x.py -n "__fish_seen_subcommand_from fmt" -l host -d 'host targets to build' -r -f -complete -c x.py -n "__fish_seen_subcommand_from fmt" -l target -d 'target targets to build' -r -f -complete -c x.py -n "__fish_seen_subcommand_from fmt" -l exclude -d 'build paths to exclude' -r -F -complete -c x.py -n "__fish_seen_subcommand_from fmt" -l skip -d 'build paths to skip' -r -F -complete -c x.py -n "__fish_seen_subcommand_from fmt" -l rustc-error-format -r -f -complete -c x.py -n "__fish_seen_subcommand_from fmt" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" -complete -c x.py -n "__fish_seen_subcommand_from fmt" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from fmt" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from fmt" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from fmt" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_seen_subcommand_from fmt" -s j -l jobs -d 'number of jobs to run in parallel' -r -f -complete -c x.py -n "__fish_seen_subcommand_from fmt" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny '',warn '',default ''}" -complete -c x.py -n "__fish_seen_subcommand_from fmt" -l error-format -d 'rustc error format' -r -f -complete -c x.py -n "__fish_seen_subcommand_from fmt" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always '',never '',auto ''}" -complete -c x.py -n "__fish_seen_subcommand_from fmt" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true '',false ''}" -complete -c x.py -n "__fish_seen_subcommand_from fmt" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from fmt" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from fmt" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from fmt" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r -complete -c x.py -n "__fish_seen_subcommand_from fmt" -l set -d 'override options in config.toml' -r -f -complete -c x.py -n "__fish_seen_subcommand_from fmt" -l check -d 'check formatting instead of applying' -complete -c x.py -n "__fish_seen_subcommand_from fmt" -l all -d 'apply to all appropriate files, not just those that have been modified' -complete -c x.py -n "__fish_seen_subcommand_from fmt" -s v -l verbose -d 'use verbose output (-vv for very verbose)' -complete -c x.py -n "__fish_seen_subcommand_from fmt" -s i -l incremental -d 'use incremental compilation' -complete -c x.py -n "__fish_seen_subcommand_from fmt" -l include-default-paths -d 'include default paths in addition to the provided ones' -complete -c x.py -n "__fish_seen_subcommand_from fmt" -l dry-run -d 'dry run; don\'t build anything' -complete -c x.py -n "__fish_seen_subcommand_from fmt" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' -complete -c x.py -n "__fish_seen_subcommand_from fmt" -l json-output -d 'use message-format=json' -complete -c x.py -n "__fish_seen_subcommand_from fmt" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' -complete -c x.py -n "__fish_seen_subcommand_from fmt" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' -complete -c x.py -n "__fish_seen_subcommand_from fmt" -l enable-bolt-settings -d 'Enable BOLT link flags' -complete -c x.py -n "__fish_seen_subcommand_from fmt" -l skip-stage0-validation -d 'Skip stage0 compiler validation' -complete -c x.py -n "__fish_seen_subcommand_from fmt" -s h -l help -d 'Print help (see more with \'--help\')' -complete -c x.py -n "__fish_seen_subcommand_from doc" -l config -d 'TOML configuration file for build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from doc" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_seen_subcommand_from doc" -l build -d 'build target of the stage0 compiler' -r -f -complete -c x.py -n "__fish_seen_subcommand_from doc" -l host -d 'host targets to build' -r -f -complete -c x.py -n "__fish_seen_subcommand_from doc" -l target -d 'target targets to build' -r -f -complete -c x.py -n "__fish_seen_subcommand_from doc" -l exclude -d 'build paths to exclude' -r -F -complete -c x.py -n "__fish_seen_subcommand_from doc" -l skip -d 'build paths to skip' -r -F -complete -c x.py -n "__fish_seen_subcommand_from doc" -l rustc-error-format -r -f -complete -c x.py -n "__fish_seen_subcommand_from doc" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" -complete -c x.py -n "__fish_seen_subcommand_from doc" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from doc" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from doc" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from doc" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_seen_subcommand_from doc" -s j -l jobs -d 'number of jobs to run in parallel' -r -f -complete -c x.py -n "__fish_seen_subcommand_from doc" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny '',warn '',default ''}" -complete -c x.py -n "__fish_seen_subcommand_from doc" -l error-format -d 'rustc error format' -r -f -complete -c x.py -n "__fish_seen_subcommand_from doc" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always '',never '',auto ''}" -complete -c x.py -n "__fish_seen_subcommand_from doc" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true '',false ''}" -complete -c x.py -n "__fish_seen_subcommand_from doc" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from doc" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from doc" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from doc" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r -complete -c x.py -n "__fish_seen_subcommand_from doc" -l set -d 'override options in config.toml' -r -f -complete -c x.py -n "__fish_seen_subcommand_from doc" -l open -d 'open the docs in a browser' -complete -c x.py -n "__fish_seen_subcommand_from doc" -l json -d 'render the documentation in JSON format in addition to the usual HTML format' -complete -c x.py -n "__fish_seen_subcommand_from doc" -s v -l verbose -d 'use verbose output (-vv for very verbose)' -complete -c x.py -n "__fish_seen_subcommand_from doc" -s i -l incremental -d 'use incremental compilation' -complete -c x.py -n "__fish_seen_subcommand_from doc" -l include-default-paths -d 'include default paths in addition to the provided ones' -complete -c x.py -n "__fish_seen_subcommand_from doc" -l dry-run -d 'dry run; don\'t build anything' -complete -c x.py -n "__fish_seen_subcommand_from doc" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' -complete -c x.py -n "__fish_seen_subcommand_from doc" -l json-output -d 'use message-format=json' -complete -c x.py -n "__fish_seen_subcommand_from doc" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' -complete -c x.py -n "__fish_seen_subcommand_from doc" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' -complete -c x.py -n "__fish_seen_subcommand_from doc" -l enable-bolt-settings -d 'Enable BOLT link flags' -complete -c x.py -n "__fish_seen_subcommand_from doc" -l skip-stage0-validation -d 'Skip stage0 compiler validation' -complete -c x.py -n "__fish_seen_subcommand_from doc" -s h -l help -d 'Print help (see more with \'--help\')' -complete -c x.py -n "__fish_seen_subcommand_from test" -l test-args -d 'extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)' -r -complete -c x.py -n "__fish_seen_subcommand_from test" -l compiletest-rustc-args -d 'extra options to pass the compiler when running compiletest tests' -r -complete -c x.py -n "__fish_seen_subcommand_from test" -l extra-checks -d 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell)' -r -complete -c x.py -n "__fish_seen_subcommand_from test" -l compare-mode -d 'mode describing what file the actual ui output will be compared to' -r -complete -c x.py -n "__fish_seen_subcommand_from test" -l pass -d 'force {check,build,run}-pass tests to this mode' -r -complete -c x.py -n "__fish_seen_subcommand_from test" -l run -d 'whether to execute run-* tests' -r -complete -c x.py -n "__fish_seen_subcommand_from test" -l config -d 'TOML configuration file for build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from test" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_seen_subcommand_from test" -l build -d 'build target of the stage0 compiler' -r -f -complete -c x.py -n "__fish_seen_subcommand_from test" -l host -d 'host targets to build' -r -f -complete -c x.py -n "__fish_seen_subcommand_from test" -l target -d 'target targets to build' -r -f -complete -c x.py -n "__fish_seen_subcommand_from test" -l exclude -d 'build paths to exclude' -r -F -complete -c x.py -n "__fish_seen_subcommand_from test" -l skip -d 'build paths to skip' -r -F -complete -c x.py -n "__fish_seen_subcommand_from test" -l rustc-error-format -r -f -complete -c x.py -n "__fish_seen_subcommand_from test" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" -complete -c x.py -n "__fish_seen_subcommand_from test" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from test" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from test" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from test" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_seen_subcommand_from test" -s j -l jobs -d 'number of jobs to run in parallel' -r -f -complete -c x.py -n "__fish_seen_subcommand_from test" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny '',warn '',default ''}" -complete -c x.py -n "__fish_seen_subcommand_from test" -l error-format -d 'rustc error format' -r -f -complete -c x.py -n "__fish_seen_subcommand_from test" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always '',never '',auto ''}" -complete -c x.py -n "__fish_seen_subcommand_from test" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true '',false ''}" -complete -c x.py -n "__fish_seen_subcommand_from test" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from test" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from test" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from test" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r -complete -c x.py -n "__fish_seen_subcommand_from test" -l set -d 'override options in config.toml' -r -f -complete -c x.py -n "__fish_seen_subcommand_from test" -l no-fail-fast -d 'run all tests regardless of failure' -complete -c x.py -n "__fish_seen_subcommand_from test" -l no-doc -d 'do not run doc tests' -complete -c x.py -n "__fish_seen_subcommand_from test" -l doc -d 'only run doc tests' -complete -c x.py -n "__fish_seen_subcommand_from test" -l bless -d 'whether to automatically update stderr/stdout files' -complete -c x.py -n "__fish_seen_subcommand_from test" -l force-rerun -d 'rerun tests even if the inputs are unchanged' -complete -c x.py -n "__fish_seen_subcommand_from test" -l only-modified -d 'only run tests that result has been changed' -complete -c x.py -n "__fish_seen_subcommand_from test" -l rustfix-coverage -d 'enable this to generate a Rustfix coverage file, which is saved in `//rustfix_missing_coverage.txt`' -complete -c x.py -n "__fish_seen_subcommand_from test" -s v -l verbose -d 'use verbose output (-vv for very verbose)' -complete -c x.py -n "__fish_seen_subcommand_from test" -s i -l incremental -d 'use incremental compilation' -complete -c x.py -n "__fish_seen_subcommand_from test" -l include-default-paths -d 'include default paths in addition to the provided ones' -complete -c x.py -n "__fish_seen_subcommand_from test" -l dry-run -d 'dry run; don\'t build anything' -complete -c x.py -n "__fish_seen_subcommand_from test" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' -complete -c x.py -n "__fish_seen_subcommand_from test" -l json-output -d 'use message-format=json' -complete -c x.py -n "__fish_seen_subcommand_from test" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' -complete -c x.py -n "__fish_seen_subcommand_from test" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' -complete -c x.py -n "__fish_seen_subcommand_from test" -l enable-bolt-settings -d 'Enable BOLT link flags' -complete -c x.py -n "__fish_seen_subcommand_from test" -l skip-stage0-validation -d 'Skip stage0 compiler validation' -complete -c x.py -n "__fish_seen_subcommand_from test" -s h -l help -d 'Print help (see more with \'--help\')' -complete -c x.py -n "__fish_seen_subcommand_from miri" -l test-args -d 'extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)' -r -complete -c x.py -n "__fish_seen_subcommand_from miri" -l config -d 'TOML configuration file for build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from miri" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_seen_subcommand_from miri" -l build -d 'build target of the stage0 compiler' -r -f -complete -c x.py -n "__fish_seen_subcommand_from miri" -l host -d 'host targets to build' -r -f -complete -c x.py -n "__fish_seen_subcommand_from miri" -l target -d 'target targets to build' -r -f -complete -c x.py -n "__fish_seen_subcommand_from miri" -l exclude -d 'build paths to exclude' -r -F -complete -c x.py -n "__fish_seen_subcommand_from miri" -l skip -d 'build paths to skip' -r -F -complete -c x.py -n "__fish_seen_subcommand_from miri" -l rustc-error-format -r -f -complete -c x.py -n "__fish_seen_subcommand_from miri" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" -complete -c x.py -n "__fish_seen_subcommand_from miri" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from miri" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from miri" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from miri" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_seen_subcommand_from miri" -s j -l jobs -d 'number of jobs to run in parallel' -r -f -complete -c x.py -n "__fish_seen_subcommand_from miri" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny '',warn '',default ''}" -complete -c x.py -n "__fish_seen_subcommand_from miri" -l error-format -d 'rustc error format' -r -f -complete -c x.py -n "__fish_seen_subcommand_from miri" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always '',never '',auto ''}" -complete -c x.py -n "__fish_seen_subcommand_from miri" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true '',false ''}" -complete -c x.py -n "__fish_seen_subcommand_from miri" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from miri" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from miri" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from miri" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r -complete -c x.py -n "__fish_seen_subcommand_from miri" -l set -d 'override options in config.toml' -r -f -complete -c x.py -n "__fish_seen_subcommand_from miri" -l no-fail-fast -d 'run all tests regardless of failure' -complete -c x.py -n "__fish_seen_subcommand_from miri" -l no-doc -d 'do not run doc tests' -complete -c x.py -n "__fish_seen_subcommand_from miri" -l doc -d 'only run doc tests' -complete -c x.py -n "__fish_seen_subcommand_from miri" -s v -l verbose -d 'use verbose output (-vv for very verbose)' -complete -c x.py -n "__fish_seen_subcommand_from miri" -s i -l incremental -d 'use incremental compilation' -complete -c x.py -n "__fish_seen_subcommand_from miri" -l include-default-paths -d 'include default paths in addition to the provided ones' -complete -c x.py -n "__fish_seen_subcommand_from miri" -l dry-run -d 'dry run; don\'t build anything' -complete -c x.py -n "__fish_seen_subcommand_from miri" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' -complete -c x.py -n "__fish_seen_subcommand_from miri" -l json-output -d 'use message-format=json' -complete -c x.py -n "__fish_seen_subcommand_from miri" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' -complete -c x.py -n "__fish_seen_subcommand_from miri" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' -complete -c x.py -n "__fish_seen_subcommand_from miri" -l enable-bolt-settings -d 'Enable BOLT link flags' -complete -c x.py -n "__fish_seen_subcommand_from miri" -l skip-stage0-validation -d 'Skip stage0 compiler validation' -complete -c x.py -n "__fish_seen_subcommand_from miri" -s h -l help -d 'Print help (see more with \'--help\')' -complete -c x.py -n "__fish_seen_subcommand_from bench" -l test-args -r -complete -c x.py -n "__fish_seen_subcommand_from bench" -l config -d 'TOML configuration file for build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from bench" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_seen_subcommand_from bench" -l build -d 'build target of the stage0 compiler' -r -f -complete -c x.py -n "__fish_seen_subcommand_from bench" -l host -d 'host targets to build' -r -f -complete -c x.py -n "__fish_seen_subcommand_from bench" -l target -d 'target targets to build' -r -f -complete -c x.py -n "__fish_seen_subcommand_from bench" -l exclude -d 'build paths to exclude' -r -F -complete -c x.py -n "__fish_seen_subcommand_from bench" -l skip -d 'build paths to skip' -r -F -complete -c x.py -n "__fish_seen_subcommand_from bench" -l rustc-error-format -r -f -complete -c x.py -n "__fish_seen_subcommand_from bench" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" -complete -c x.py -n "__fish_seen_subcommand_from bench" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from bench" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from bench" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from bench" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_seen_subcommand_from bench" -s j -l jobs -d 'number of jobs to run in parallel' -r -f -complete -c x.py -n "__fish_seen_subcommand_from bench" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny '',warn '',default ''}" -complete -c x.py -n "__fish_seen_subcommand_from bench" -l error-format -d 'rustc error format' -r -f -complete -c x.py -n "__fish_seen_subcommand_from bench" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always '',never '',auto ''}" -complete -c x.py -n "__fish_seen_subcommand_from bench" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true '',false ''}" -complete -c x.py -n "__fish_seen_subcommand_from bench" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from bench" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from bench" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from bench" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r -complete -c x.py -n "__fish_seen_subcommand_from bench" -l set -d 'override options in config.toml' -r -f -complete -c x.py -n "__fish_seen_subcommand_from bench" -s v -l verbose -d 'use verbose output (-vv for very verbose)' -complete -c x.py -n "__fish_seen_subcommand_from bench" -s i -l incremental -d 'use incremental compilation' -complete -c x.py -n "__fish_seen_subcommand_from bench" -l include-default-paths -d 'include default paths in addition to the provided ones' -complete -c x.py -n "__fish_seen_subcommand_from bench" -l dry-run -d 'dry run; don\'t build anything' -complete -c x.py -n "__fish_seen_subcommand_from bench" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' -complete -c x.py -n "__fish_seen_subcommand_from bench" -l json-output -d 'use message-format=json' -complete -c x.py -n "__fish_seen_subcommand_from bench" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' -complete -c x.py -n "__fish_seen_subcommand_from bench" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' -complete -c x.py -n "__fish_seen_subcommand_from bench" -l enable-bolt-settings -d 'Enable BOLT link flags' -complete -c x.py -n "__fish_seen_subcommand_from bench" -l skip-stage0-validation -d 'Skip stage0 compiler validation' -complete -c x.py -n "__fish_seen_subcommand_from bench" -s h -l help -d 'Print help (see more with \'--help\')' -complete -c x.py -n "__fish_seen_subcommand_from clean" -l stage -d 'Clean a specific stage without touching other artifacts. By default, every stage is cleaned if this option is not used' -r -complete -c x.py -n "__fish_seen_subcommand_from clean" -l config -d 'TOML configuration file for build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from clean" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_seen_subcommand_from clean" -l build -d 'build target of the stage0 compiler' -r -f -complete -c x.py -n "__fish_seen_subcommand_from clean" -l host -d 'host targets to build' -r -f -complete -c x.py -n "__fish_seen_subcommand_from clean" -l target -d 'target targets to build' -r -f -complete -c x.py -n "__fish_seen_subcommand_from clean" -l exclude -d 'build paths to exclude' -r -F -complete -c x.py -n "__fish_seen_subcommand_from clean" -l skip -d 'build paths to skip' -r -F -complete -c x.py -n "__fish_seen_subcommand_from clean" -l rustc-error-format -r -f -complete -c x.py -n "__fish_seen_subcommand_from clean" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" -complete -c x.py -n "__fish_seen_subcommand_from clean" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from clean" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from clean" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_seen_subcommand_from clean" -s j -l jobs -d 'number of jobs to run in parallel' -r -f -complete -c x.py -n "__fish_seen_subcommand_from clean" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny '',warn '',default ''}" -complete -c x.py -n "__fish_seen_subcommand_from clean" -l error-format -d 'rustc error format' -r -f -complete -c x.py -n "__fish_seen_subcommand_from clean" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always '',never '',auto ''}" -complete -c x.py -n "__fish_seen_subcommand_from clean" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true '',false ''}" -complete -c x.py -n "__fish_seen_subcommand_from clean" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from clean" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from clean" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from clean" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r -complete -c x.py -n "__fish_seen_subcommand_from clean" -l set -d 'override options in config.toml' -r -f -complete -c x.py -n "__fish_seen_subcommand_from clean" -l all -d 'Clean the entire build directory (not used by default)' -complete -c x.py -n "__fish_seen_subcommand_from clean" -s v -l verbose -d 'use verbose output (-vv for very verbose)' -complete -c x.py -n "__fish_seen_subcommand_from clean" -s i -l incremental -d 'use incremental compilation' -complete -c x.py -n "__fish_seen_subcommand_from clean" -l include-default-paths -d 'include default paths in addition to the provided ones' -complete -c x.py -n "__fish_seen_subcommand_from clean" -l dry-run -d 'dry run; don\'t build anything' -complete -c x.py -n "__fish_seen_subcommand_from clean" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' -complete -c x.py -n "__fish_seen_subcommand_from clean" -l json-output -d 'use message-format=json' -complete -c x.py -n "__fish_seen_subcommand_from clean" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' -complete -c x.py -n "__fish_seen_subcommand_from clean" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' -complete -c x.py -n "__fish_seen_subcommand_from clean" -l enable-bolt-settings -d 'Enable BOLT link flags' -complete -c x.py -n "__fish_seen_subcommand_from clean" -l skip-stage0-validation -d 'Skip stage0 compiler validation' -complete -c x.py -n "__fish_seen_subcommand_from clean" -s h -l help -d 'Print help (see more with \'--help\')' -complete -c x.py -n "__fish_seen_subcommand_from dist" -l config -d 'TOML configuration file for build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from dist" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_seen_subcommand_from dist" -l build -d 'build target of the stage0 compiler' -r -f -complete -c x.py -n "__fish_seen_subcommand_from dist" -l host -d 'host targets to build' -r -f -complete -c x.py -n "__fish_seen_subcommand_from dist" -l target -d 'target targets to build' -r -f -complete -c x.py -n "__fish_seen_subcommand_from dist" -l exclude -d 'build paths to exclude' -r -F -complete -c x.py -n "__fish_seen_subcommand_from dist" -l skip -d 'build paths to skip' -r -F -complete -c x.py -n "__fish_seen_subcommand_from dist" -l rustc-error-format -r -f -complete -c x.py -n "__fish_seen_subcommand_from dist" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" -complete -c x.py -n "__fish_seen_subcommand_from dist" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from dist" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from dist" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from dist" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_seen_subcommand_from dist" -s j -l jobs -d 'number of jobs to run in parallel' -r -f -complete -c x.py -n "__fish_seen_subcommand_from dist" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny '',warn '',default ''}" -complete -c x.py -n "__fish_seen_subcommand_from dist" -l error-format -d 'rustc error format' -r -f -complete -c x.py -n "__fish_seen_subcommand_from dist" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always '',never '',auto ''}" -complete -c x.py -n "__fish_seen_subcommand_from dist" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true '',false ''}" -complete -c x.py -n "__fish_seen_subcommand_from dist" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from dist" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from dist" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from dist" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r -complete -c x.py -n "__fish_seen_subcommand_from dist" -l set -d 'override options in config.toml' -r -f -complete -c x.py -n "__fish_seen_subcommand_from dist" -s v -l verbose -d 'use verbose output (-vv for very verbose)' -complete -c x.py -n "__fish_seen_subcommand_from dist" -s i -l incremental -d 'use incremental compilation' -complete -c x.py -n "__fish_seen_subcommand_from dist" -l include-default-paths -d 'include default paths in addition to the provided ones' -complete -c x.py -n "__fish_seen_subcommand_from dist" -l dry-run -d 'dry run; don\'t build anything' -complete -c x.py -n "__fish_seen_subcommand_from dist" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' -complete -c x.py -n "__fish_seen_subcommand_from dist" -l json-output -d 'use message-format=json' -complete -c x.py -n "__fish_seen_subcommand_from dist" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' -complete -c x.py -n "__fish_seen_subcommand_from dist" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' -complete -c x.py -n "__fish_seen_subcommand_from dist" -l enable-bolt-settings -d 'Enable BOLT link flags' -complete -c x.py -n "__fish_seen_subcommand_from dist" -l skip-stage0-validation -d 'Skip stage0 compiler validation' -complete -c x.py -n "__fish_seen_subcommand_from dist" -s h -l help -d 'Print help (see more with \'--help\')' -complete -c x.py -n "__fish_seen_subcommand_from install" -l config -d 'TOML configuration file for build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from install" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_seen_subcommand_from install" -l build -d 'build target of the stage0 compiler' -r -f -complete -c x.py -n "__fish_seen_subcommand_from install" -l host -d 'host targets to build' -r -f -complete -c x.py -n "__fish_seen_subcommand_from install" -l target -d 'target targets to build' -r -f -complete -c x.py -n "__fish_seen_subcommand_from install" -l exclude -d 'build paths to exclude' -r -F -complete -c x.py -n "__fish_seen_subcommand_from install" -l skip -d 'build paths to skip' -r -F -complete -c x.py -n "__fish_seen_subcommand_from install" -l rustc-error-format -r -f -complete -c x.py -n "__fish_seen_subcommand_from install" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" -complete -c x.py -n "__fish_seen_subcommand_from install" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from install" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from install" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from install" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_seen_subcommand_from install" -s j -l jobs -d 'number of jobs to run in parallel' -r -f -complete -c x.py -n "__fish_seen_subcommand_from install" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny '',warn '',default ''}" -complete -c x.py -n "__fish_seen_subcommand_from install" -l error-format -d 'rustc error format' -r -f -complete -c x.py -n "__fish_seen_subcommand_from install" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always '',never '',auto ''}" -complete -c x.py -n "__fish_seen_subcommand_from install" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true '',false ''}" -complete -c x.py -n "__fish_seen_subcommand_from install" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from install" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from install" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from install" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r -complete -c x.py -n "__fish_seen_subcommand_from install" -l set -d 'override options in config.toml' -r -f -complete -c x.py -n "__fish_seen_subcommand_from install" -s v -l verbose -d 'use verbose output (-vv for very verbose)' -complete -c x.py -n "__fish_seen_subcommand_from install" -s i -l incremental -d 'use incremental compilation' -complete -c x.py -n "__fish_seen_subcommand_from install" -l include-default-paths -d 'include default paths in addition to the provided ones' -complete -c x.py -n "__fish_seen_subcommand_from install" -l dry-run -d 'dry run; don\'t build anything' -complete -c x.py -n "__fish_seen_subcommand_from install" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' -complete -c x.py -n "__fish_seen_subcommand_from install" -l json-output -d 'use message-format=json' -complete -c x.py -n "__fish_seen_subcommand_from install" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' -complete -c x.py -n "__fish_seen_subcommand_from install" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' -complete -c x.py -n "__fish_seen_subcommand_from install" -l enable-bolt-settings -d 'Enable BOLT link flags' -complete -c x.py -n "__fish_seen_subcommand_from install" -l skip-stage0-validation -d 'Skip stage0 compiler validation' -complete -c x.py -n "__fish_seen_subcommand_from install" -s h -l help -d 'Print help (see more with \'--help\')' -complete -c x.py -n "__fish_seen_subcommand_from run" -l args -d 'arguments for the tool' -r -complete -c x.py -n "__fish_seen_subcommand_from run" -l config -d 'TOML configuration file for build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from run" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_seen_subcommand_from run" -l build -d 'build target of the stage0 compiler' -r -f -complete -c x.py -n "__fish_seen_subcommand_from run" -l host -d 'host targets to build' -r -f -complete -c x.py -n "__fish_seen_subcommand_from run" -l target -d 'target targets to build' -r -f -complete -c x.py -n "__fish_seen_subcommand_from run" -l exclude -d 'build paths to exclude' -r -F -complete -c x.py -n "__fish_seen_subcommand_from run" -l skip -d 'build paths to skip' -r -F -complete -c x.py -n "__fish_seen_subcommand_from run" -l rustc-error-format -r -f -complete -c x.py -n "__fish_seen_subcommand_from run" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" -complete -c x.py -n "__fish_seen_subcommand_from run" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from run" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from run" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from run" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_seen_subcommand_from run" -s j -l jobs -d 'number of jobs to run in parallel' -r -f -complete -c x.py -n "__fish_seen_subcommand_from run" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny '',warn '',default ''}" -complete -c x.py -n "__fish_seen_subcommand_from run" -l error-format -d 'rustc error format' -r -f -complete -c x.py -n "__fish_seen_subcommand_from run" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always '',never '',auto ''}" -complete -c x.py -n "__fish_seen_subcommand_from run" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true '',false ''}" -complete -c x.py -n "__fish_seen_subcommand_from run" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from run" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from run" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from run" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r -complete -c x.py -n "__fish_seen_subcommand_from run" -l set -d 'override options in config.toml' -r -f -complete -c x.py -n "__fish_seen_subcommand_from run" -s v -l verbose -d 'use verbose output (-vv for very verbose)' -complete -c x.py -n "__fish_seen_subcommand_from run" -s i -l incremental -d 'use incremental compilation' -complete -c x.py -n "__fish_seen_subcommand_from run" -l include-default-paths -d 'include default paths in addition to the provided ones' -complete -c x.py -n "__fish_seen_subcommand_from run" -l dry-run -d 'dry run; don\'t build anything' -complete -c x.py -n "__fish_seen_subcommand_from run" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' -complete -c x.py -n "__fish_seen_subcommand_from run" -l json-output -d 'use message-format=json' -complete -c x.py -n "__fish_seen_subcommand_from run" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' -complete -c x.py -n "__fish_seen_subcommand_from run" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' -complete -c x.py -n "__fish_seen_subcommand_from run" -l enable-bolt-settings -d 'Enable BOLT link flags' -complete -c x.py -n "__fish_seen_subcommand_from run" -l skip-stage0-validation -d 'Skip stage0 compiler validation' -complete -c x.py -n "__fish_seen_subcommand_from run" -s h -l help -d 'Print help (see more with \'--help\')' -complete -c x.py -n "__fish_seen_subcommand_from setup" -l config -d 'TOML configuration file for build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from setup" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_seen_subcommand_from setup" -l build -d 'build target of the stage0 compiler' -r -f -complete -c x.py -n "__fish_seen_subcommand_from setup" -l host -d 'host targets to build' -r -f -complete -c x.py -n "__fish_seen_subcommand_from setup" -l target -d 'target targets to build' -r -f -complete -c x.py -n "__fish_seen_subcommand_from setup" -l exclude -d 'build paths to exclude' -r -F -complete -c x.py -n "__fish_seen_subcommand_from setup" -l skip -d 'build paths to skip' -r -F -complete -c x.py -n "__fish_seen_subcommand_from setup" -l rustc-error-format -r -f -complete -c x.py -n "__fish_seen_subcommand_from setup" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" -complete -c x.py -n "__fish_seen_subcommand_from setup" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from setup" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from setup" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from setup" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_seen_subcommand_from setup" -s j -l jobs -d 'number of jobs to run in parallel' -r -f -complete -c x.py -n "__fish_seen_subcommand_from setup" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny '',warn '',default ''}" -complete -c x.py -n "__fish_seen_subcommand_from setup" -l error-format -d 'rustc error format' -r -f -complete -c x.py -n "__fish_seen_subcommand_from setup" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always '',never '',auto ''}" -complete -c x.py -n "__fish_seen_subcommand_from setup" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true '',false ''}" -complete -c x.py -n "__fish_seen_subcommand_from setup" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from setup" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from setup" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from setup" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r -complete -c x.py -n "__fish_seen_subcommand_from setup" -l set -d 'override options in config.toml' -r -f -complete -c x.py -n "__fish_seen_subcommand_from setup" -s v -l verbose -d 'use verbose output (-vv for very verbose)' -complete -c x.py -n "__fish_seen_subcommand_from setup" -s i -l incremental -d 'use incremental compilation' -complete -c x.py -n "__fish_seen_subcommand_from setup" -l include-default-paths -d 'include default paths in addition to the provided ones' -complete -c x.py -n "__fish_seen_subcommand_from setup" -l dry-run -d 'dry run; don\'t build anything' -complete -c x.py -n "__fish_seen_subcommand_from setup" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' -complete -c x.py -n "__fish_seen_subcommand_from setup" -l json-output -d 'use message-format=json' -complete -c x.py -n "__fish_seen_subcommand_from setup" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' -complete -c x.py -n "__fish_seen_subcommand_from setup" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' -complete -c x.py -n "__fish_seen_subcommand_from setup" -l enable-bolt-settings -d 'Enable BOLT link flags' -complete -c x.py -n "__fish_seen_subcommand_from setup" -l skip-stage0-validation -d 'Skip stage0 compiler validation' -complete -c x.py -n "__fish_seen_subcommand_from setup" -s h -l help -d 'Print help (see more with \'--help\')' -complete -c x.py -n "__fish_seen_subcommand_from suggest" -l config -d 'TOML configuration file for build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from suggest" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_seen_subcommand_from suggest" -l build -d 'build target of the stage0 compiler' -r -f -complete -c x.py -n "__fish_seen_subcommand_from suggest" -l host -d 'host targets to build' -r -f -complete -c x.py -n "__fish_seen_subcommand_from suggest" -l target -d 'target targets to build' -r -f -complete -c x.py -n "__fish_seen_subcommand_from suggest" -l exclude -d 'build paths to exclude' -r -F -complete -c x.py -n "__fish_seen_subcommand_from suggest" -l skip -d 'build paths to skip' -r -F -complete -c x.py -n "__fish_seen_subcommand_from suggest" -l rustc-error-format -r -f -complete -c x.py -n "__fish_seen_subcommand_from suggest" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" -complete -c x.py -n "__fish_seen_subcommand_from suggest" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from suggest" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from suggest" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from suggest" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_seen_subcommand_from suggest" -s j -l jobs -d 'number of jobs to run in parallel' -r -f -complete -c x.py -n "__fish_seen_subcommand_from suggest" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny '',warn '',default ''}" -complete -c x.py -n "__fish_seen_subcommand_from suggest" -l error-format -d 'rustc error format' -r -f -complete -c x.py -n "__fish_seen_subcommand_from suggest" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always '',never '',auto ''}" -complete -c x.py -n "__fish_seen_subcommand_from suggest" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true '',false ''}" -complete -c x.py -n "__fish_seen_subcommand_from suggest" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from suggest" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from suggest" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from suggest" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r -complete -c x.py -n "__fish_seen_subcommand_from suggest" -l set -d 'override options in config.toml' -r -f -complete -c x.py -n "__fish_seen_subcommand_from suggest" -l run -d 'run suggested tests' -complete -c x.py -n "__fish_seen_subcommand_from suggest" -s v -l verbose -d 'use verbose output (-vv for very verbose)' -complete -c x.py -n "__fish_seen_subcommand_from suggest" -s i -l incremental -d 'use incremental compilation' -complete -c x.py -n "__fish_seen_subcommand_from suggest" -l include-default-paths -d 'include default paths in addition to the provided ones' -complete -c x.py -n "__fish_seen_subcommand_from suggest" -l dry-run -d 'dry run; don\'t build anything' -complete -c x.py -n "__fish_seen_subcommand_from suggest" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' -complete -c x.py -n "__fish_seen_subcommand_from suggest" -l json-output -d 'use message-format=json' -complete -c x.py -n "__fish_seen_subcommand_from suggest" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' -complete -c x.py -n "__fish_seen_subcommand_from suggest" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' -complete -c x.py -n "__fish_seen_subcommand_from suggest" -l enable-bolt-settings -d 'Enable BOLT link flags' -complete -c x.py -n "__fish_seen_subcommand_from suggest" -l skip-stage0-validation -d 'Skip stage0 compiler validation' -complete -c x.py -n "__fish_seen_subcommand_from suggest" -s h -l help -d 'Print help (see more with \'--help\')' -complete -c x.py -n "__fish_seen_subcommand_from vendor" -l sync -d 'Additional `Cargo.toml` to sync and vendor' -r -F -complete -c x.py -n "__fish_seen_subcommand_from vendor" -l config -d 'TOML configuration file for build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from vendor" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_seen_subcommand_from vendor" -l build -d 'build target of the stage0 compiler' -r -f -complete -c x.py -n "__fish_seen_subcommand_from vendor" -l host -d 'host targets to build' -r -f -complete -c x.py -n "__fish_seen_subcommand_from vendor" -l target -d 'target targets to build' -r -f -complete -c x.py -n "__fish_seen_subcommand_from vendor" -l exclude -d 'build paths to exclude' -r -F -complete -c x.py -n "__fish_seen_subcommand_from vendor" -l skip -d 'build paths to skip' -r -F -complete -c x.py -n "__fish_seen_subcommand_from vendor" -l rustc-error-format -r -f -complete -c x.py -n "__fish_seen_subcommand_from vendor" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" -complete -c x.py -n "__fish_seen_subcommand_from vendor" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from vendor" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from vendor" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from vendor" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_seen_subcommand_from vendor" -s j -l jobs -d 'number of jobs to run in parallel' -r -f -complete -c x.py -n "__fish_seen_subcommand_from vendor" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny '',warn '',default ''}" -complete -c x.py -n "__fish_seen_subcommand_from vendor" -l error-format -d 'rustc error format' -r -f -complete -c x.py -n "__fish_seen_subcommand_from vendor" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always '',never '',auto ''}" -complete -c x.py -n "__fish_seen_subcommand_from vendor" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true '',false ''}" -complete -c x.py -n "__fish_seen_subcommand_from vendor" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from vendor" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from vendor" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from vendor" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r -complete -c x.py -n "__fish_seen_subcommand_from vendor" -l set -d 'override options in config.toml' -r -f -complete -c x.py -n "__fish_seen_subcommand_from vendor" -l versioned-dirs -d 'Always include version in subdir name' -complete -c x.py -n "__fish_seen_subcommand_from vendor" -s v -l verbose -d 'use verbose output (-vv for very verbose)' -complete -c x.py -n "__fish_seen_subcommand_from vendor" -s i -l incremental -d 'use incremental compilation' -complete -c x.py -n "__fish_seen_subcommand_from vendor" -l include-default-paths -d 'include default paths in addition to the provided ones' -complete -c x.py -n "__fish_seen_subcommand_from vendor" -l dry-run -d 'dry run; don\'t build anything' -complete -c x.py -n "__fish_seen_subcommand_from vendor" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' -complete -c x.py -n "__fish_seen_subcommand_from vendor" -l json-output -d 'use message-format=json' -complete -c x.py -n "__fish_seen_subcommand_from vendor" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' -complete -c x.py -n "__fish_seen_subcommand_from vendor" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' -complete -c x.py -n "__fish_seen_subcommand_from vendor" -l enable-bolt-settings -d 'Enable BOLT link flags' -complete -c x.py -n "__fish_seen_subcommand_from vendor" -l skip-stage0-validation -d 'Skip stage0 compiler validation' -complete -c x.py -n "__fish_seen_subcommand_from vendor" -s h -l help -d 'Print help (see more with \'--help\')' -complete -c x.py -n "__fish_seen_subcommand_from perf" -l config -d 'TOML configuration file for build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from perf" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_seen_subcommand_from perf" -l build -d 'build target of the stage0 compiler' -r -f -complete -c x.py -n "__fish_seen_subcommand_from perf" -l host -d 'host targets to build' -r -f -complete -c x.py -n "__fish_seen_subcommand_from perf" -l target -d 'target targets to build' -r -f -complete -c x.py -n "__fish_seen_subcommand_from perf" -l exclude -d 'build paths to exclude' -r -F -complete -c x.py -n "__fish_seen_subcommand_from perf" -l skip -d 'build paths to skip' -r -F -complete -c x.py -n "__fish_seen_subcommand_from perf" -l rustc-error-format -r -f -complete -c x.py -n "__fish_seen_subcommand_from perf" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" -complete -c x.py -n "__fish_seen_subcommand_from perf" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from perf" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from perf" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f -complete -c x.py -n "__fish_seen_subcommand_from perf" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" -complete -c x.py -n "__fish_seen_subcommand_from perf" -s j -l jobs -d 'number of jobs to run in parallel' -r -f -complete -c x.py -n "__fish_seen_subcommand_from perf" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny '',warn '',default ''}" -complete -c x.py -n "__fish_seen_subcommand_from perf" -l error-format -d 'rustc error format' -r -f -complete -c x.py -n "__fish_seen_subcommand_from perf" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always '',never '',auto ''}" -complete -c x.py -n "__fish_seen_subcommand_from perf" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true '',false ''}" -complete -c x.py -n "__fish_seen_subcommand_from perf" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from perf" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from perf" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F -complete -c x.py -n "__fish_seen_subcommand_from perf" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r -complete -c x.py -n "__fish_seen_subcommand_from perf" -l set -d 'override options in config.toml' -r -f -complete -c x.py -n "__fish_seen_subcommand_from perf" -s v -l verbose -d 'use verbose output (-vv for very verbose)' -complete -c x.py -n "__fish_seen_subcommand_from perf" -s i -l incremental -d 'use incremental compilation' -complete -c x.py -n "__fish_seen_subcommand_from perf" -l include-default-paths -d 'include default paths in addition to the provided ones' -complete -c x.py -n "__fish_seen_subcommand_from perf" -l dry-run -d 'dry run; don\'t build anything' -complete -c x.py -n "__fish_seen_subcommand_from perf" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' -complete -c x.py -n "__fish_seen_subcommand_from perf" -l json-output -d 'use message-format=json' -complete -c x.py -n "__fish_seen_subcommand_from perf" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' -complete -c x.py -n "__fish_seen_subcommand_from perf" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' -complete -c x.py -n "__fish_seen_subcommand_from perf" -l enable-bolt-settings -d 'Enable BOLT link flags' -complete -c x.py -n "__fish_seen_subcommand_from perf" -l skip-stage0-validation -d 'Skip stage0 compiler validation' -complete -c x.py -n "__fish_seen_subcommand_from perf" -s h -l help -d 'Print help (see more with \'--help\')' +# Print an optspec for argparse to handle cmd's options that are independent of any subcommand. +function __fish_x.py_global_optspecs + string join \n v/verbose i/incremental config= build-dir= build= host= target= exclude= skip= include-default-paths rustc-error-format= on-fail= dry-run dump-bootstrap-shims stage= keep-stage= keep-stage-std= src= j/jobs= warnings= error-format= json-output color= bypass-bootstrap-lock llvm-skip-rebuild= rust-profile-generate= rust-profile-use= llvm-profile-use= llvm-profile-generate enable-bolt-settings skip-stage0-validation reproducible-artifact= set= h/help +end + +function __fish_x.py_needs_command + # Figure out if the current invocation already has a command. + set -l cmd (commandline -opc) + set -e cmd[1] + argparse -s (__fish_x.py_global_optspecs) -- $cmd 2>/dev/null + or return + if set -q argv[1] + # Also print the command, so this can be used to figure out what it is. + echo $argv[1] + return 1 + end + return 0 +end + +function __fish_x.py_using_subcommand + set -l cmd (__fish_x.py_needs_command) + test -z "$cmd" + and return 1 + contains -- $cmd[1] $argv +end + +complete -c x.py -n "__fish_x.py_needs_command" -l config -d 'TOML configuration file for build' -r -F +complete -c x.py -n "__fish_x.py_needs_command" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_needs_command" -l build -d 'build target of the stage0 compiler' -r -f +complete -c x.py -n "__fish_x.py_needs_command" -l host -d 'host targets to build' -r -f +complete -c x.py -n "__fish_x.py_needs_command" -l target -d 'target targets to build' -r -f +complete -c x.py -n "__fish_x.py_needs_command" -l exclude -d 'build paths to exclude' -r -F +complete -c x.py -n "__fish_x.py_needs_command" -l skip -d 'build paths to skip' -r -F +complete -c x.py -n "__fish_x.py_needs_command" -l rustc-error-format -r -f +complete -c x.py -n "__fish_x.py_needs_command" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" +complete -c x.py -n "__fish_x.py_needs_command" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f +complete -c x.py -n "__fish_x.py_needs_command" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_needs_command" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_needs_command" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_needs_command" -s j -l jobs -d 'number of jobs to run in parallel' -r -f +complete -c x.py -n "__fish_x.py_needs_command" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}" +complete -c x.py -n "__fish_x.py_needs_command" -l error-format -d 'rustc error format' -r -f +complete -c x.py -n "__fish_x.py_needs_command" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}" +complete -c x.py -n "__fish_x.py_needs_command" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}" +complete -c x.py -n "__fish_x.py_needs_command" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F +complete -c x.py -n "__fish_x.py_needs_command" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F +complete -c x.py -n "__fish_x.py_needs_command" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F +complete -c x.py -n "__fish_x.py_needs_command" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r +complete -c x.py -n "__fish_x.py_needs_command" -l set -d 'override options in config.toml' -r -f +complete -c x.py -n "__fish_x.py_needs_command" -s v -l verbose -d 'use verbose output (-vv for very verbose)' +complete -c x.py -n "__fish_x.py_needs_command" -s i -l incremental -d 'use incremental compilation' +complete -c x.py -n "__fish_x.py_needs_command" -l include-default-paths -d 'include default paths in addition to the provided ones' +complete -c x.py -n "__fish_x.py_needs_command" -l dry-run -d 'dry run; don\'t build anything' +complete -c x.py -n "__fish_x.py_needs_command" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' +complete -c x.py -n "__fish_x.py_needs_command" -l json-output -d 'use message-format=json' +complete -c x.py -n "__fish_x.py_needs_command" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' +complete -c x.py -n "__fish_x.py_needs_command" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' +complete -c x.py -n "__fish_x.py_needs_command" -l enable-bolt-settings -d 'Enable BOLT link flags' +complete -c x.py -n "__fish_x.py_needs_command" -l skip-stage0-validation -d 'Skip stage0 compiler validation' +complete -c x.py -n "__fish_x.py_needs_command" -s h -l help -d 'Print help (see more with \'--help\')' +complete -c x.py -n "__fish_x.py_needs_command" -a "build" -d 'Compile either the compiler or libraries' +complete -c x.py -n "__fish_x.py_needs_command" -a "check" -d 'Compile either the compiler or libraries, using cargo check' +complete -c x.py -n "__fish_x.py_needs_command" -a "clippy" -d 'Run Clippy (uses rustup/cargo-installed clippy binary)' +complete -c x.py -n "__fish_x.py_needs_command" -a "fix" -d 'Run cargo fix' +complete -c x.py -n "__fish_x.py_needs_command" -a "fmt" -d 'Run rustfmt' +complete -c x.py -n "__fish_x.py_needs_command" -a "doc" -d 'Build documentation' +complete -c x.py -n "__fish_x.py_needs_command" -a "test" -d 'Build and run some test suites' +complete -c x.py -n "__fish_x.py_needs_command" -a "miri" -d 'Build and run some test suites *in Miri*' +complete -c x.py -n "__fish_x.py_needs_command" -a "bench" -d 'Build and run some benchmarks' +complete -c x.py -n "__fish_x.py_needs_command" -a "clean" -d 'Clean out build directories' +complete -c x.py -n "__fish_x.py_needs_command" -a "dist" -d 'Build distribution artifacts' +complete -c x.py -n "__fish_x.py_needs_command" -a "install" -d 'Install distribution artifacts' +complete -c x.py -n "__fish_x.py_needs_command" -a "run" -d 'Run tools contained in this repository' +complete -c x.py -n "__fish_x.py_needs_command" -a "setup" -d 'Set up the environment for development' +complete -c x.py -n "__fish_x.py_needs_command" -a "suggest" -d 'Suggest a subset of tests to run, based on modified files' +complete -c x.py -n "__fish_x.py_needs_command" -a "vendor" -d 'Vendor dependencies' +complete -c x.py -n "__fish_x.py_needs_command" -a "perf" -d 'Perform profiling and benchmarking of the compiler using the `rustc-perf-wrapper` tool' +complete -c x.py -n "__fish_x.py_using_subcommand build" -l config -d 'TOML configuration file for build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand build" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_using_subcommand build" -l build -d 'build target of the stage0 compiler' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand build" -l host -d 'host targets to build' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand build" -l target -d 'target targets to build' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand build" -l exclude -d 'build paths to exclude' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand build" -l skip -d 'build paths to skip' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand build" -l rustc-error-format -r -f +complete -c x.py -n "__fish_x.py_using_subcommand build" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" +complete -c x.py -n "__fish_x.py_using_subcommand build" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand build" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand build" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand build" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_using_subcommand build" -s j -l jobs -d 'number of jobs to run in parallel' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand build" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand build" -l error-format -d 'rustc error format' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand build" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand build" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand build" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand build" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand build" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand build" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r +complete -c x.py -n "__fish_x.py_using_subcommand build" -l set -d 'override options in config.toml' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand build" -s v -l verbose -d 'use verbose output (-vv for very verbose)' +complete -c x.py -n "__fish_x.py_using_subcommand build" -s i -l incremental -d 'use incremental compilation' +complete -c x.py -n "__fish_x.py_using_subcommand build" -l include-default-paths -d 'include default paths in addition to the provided ones' +complete -c x.py -n "__fish_x.py_using_subcommand build" -l dry-run -d 'dry run; don\'t build anything' +complete -c x.py -n "__fish_x.py_using_subcommand build" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' +complete -c x.py -n "__fish_x.py_using_subcommand build" -l json-output -d 'use message-format=json' +complete -c x.py -n "__fish_x.py_using_subcommand build" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' +complete -c x.py -n "__fish_x.py_using_subcommand build" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' +complete -c x.py -n "__fish_x.py_using_subcommand build" -l enable-bolt-settings -d 'Enable BOLT link flags' +complete -c x.py -n "__fish_x.py_using_subcommand build" -l skip-stage0-validation -d 'Skip stage0 compiler validation' +complete -c x.py -n "__fish_x.py_using_subcommand build" -s h -l help -d 'Print help (see more with \'--help\')' +complete -c x.py -n "__fish_x.py_using_subcommand check" -l config -d 'TOML configuration file for build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand check" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_using_subcommand check" -l build -d 'build target of the stage0 compiler' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand check" -l host -d 'host targets to build' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand check" -l target -d 'target targets to build' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand check" -l exclude -d 'build paths to exclude' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand check" -l skip -d 'build paths to skip' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand check" -l rustc-error-format -r -f +complete -c x.py -n "__fish_x.py_using_subcommand check" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" +complete -c x.py -n "__fish_x.py_using_subcommand check" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand check" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand check" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand check" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_using_subcommand check" -s j -l jobs -d 'number of jobs to run in parallel' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand check" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand check" -l error-format -d 'rustc error format' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand check" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand check" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand check" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand check" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand check" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand check" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r +complete -c x.py -n "__fish_x.py_using_subcommand check" -l set -d 'override options in config.toml' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand check" -l all-targets -d 'Check all targets' +complete -c x.py -n "__fish_x.py_using_subcommand check" -s v -l verbose -d 'use verbose output (-vv for very verbose)' +complete -c x.py -n "__fish_x.py_using_subcommand check" -s i -l incremental -d 'use incremental compilation' +complete -c x.py -n "__fish_x.py_using_subcommand check" -l include-default-paths -d 'include default paths in addition to the provided ones' +complete -c x.py -n "__fish_x.py_using_subcommand check" -l dry-run -d 'dry run; don\'t build anything' +complete -c x.py -n "__fish_x.py_using_subcommand check" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' +complete -c x.py -n "__fish_x.py_using_subcommand check" -l json-output -d 'use message-format=json' +complete -c x.py -n "__fish_x.py_using_subcommand check" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' +complete -c x.py -n "__fish_x.py_using_subcommand check" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' +complete -c x.py -n "__fish_x.py_using_subcommand check" -l enable-bolt-settings -d 'Enable BOLT link flags' +complete -c x.py -n "__fish_x.py_using_subcommand check" -l skip-stage0-validation -d 'Skip stage0 compiler validation' +complete -c x.py -n "__fish_x.py_using_subcommand check" -s h -l help -d 'Print help (see more with \'--help\')' +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -s A -d 'clippy lints to allow' -r +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -s D -d 'clippy lints to deny' -r +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -s W -d 'clippy lints to warn on' -r +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -s F -d 'clippy lints to forbid' -r +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l config -d 'TOML configuration file for build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l build -d 'build target of the stage0 compiler' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l host -d 'host targets to build' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l target -d 'target targets to build' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l exclude -d 'build paths to exclude' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l skip -d 'build paths to skip' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l rustc-error-format -r -f +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -s j -l jobs -d 'number of jobs to run in parallel' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l error-format -d 'rustc error format' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l set -d 'override options in config.toml' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l fix +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l allow-dirty +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l allow-staged +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -s v -l verbose -d 'use verbose output (-vv for very verbose)' +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -s i -l incremental -d 'use incremental compilation' +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l include-default-paths -d 'include default paths in addition to the provided ones' +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l dry-run -d 'dry run; don\'t build anything' +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l json-output -d 'use message-format=json' +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l enable-bolt-settings -d 'Enable BOLT link flags' +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l skip-stage0-validation -d 'Skip stage0 compiler validation' +complete -c x.py -n "__fish_x.py_using_subcommand clippy" -s h -l help -d 'Print help (see more with \'--help\')' +complete -c x.py -n "__fish_x.py_using_subcommand fix" -l config -d 'TOML configuration file for build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand fix" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_using_subcommand fix" -l build -d 'build target of the stage0 compiler' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand fix" -l host -d 'host targets to build' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand fix" -l target -d 'target targets to build' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand fix" -l exclude -d 'build paths to exclude' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand fix" -l skip -d 'build paths to skip' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand fix" -l rustc-error-format -r -f +complete -c x.py -n "__fish_x.py_using_subcommand fix" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" +complete -c x.py -n "__fish_x.py_using_subcommand fix" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand fix" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand fix" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand fix" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_using_subcommand fix" -s j -l jobs -d 'number of jobs to run in parallel' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand fix" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand fix" -l error-format -d 'rustc error format' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand fix" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand fix" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand fix" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand fix" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand fix" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand fix" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r +complete -c x.py -n "__fish_x.py_using_subcommand fix" -l set -d 'override options in config.toml' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand fix" -s v -l verbose -d 'use verbose output (-vv for very verbose)' +complete -c x.py -n "__fish_x.py_using_subcommand fix" -s i -l incremental -d 'use incremental compilation' +complete -c x.py -n "__fish_x.py_using_subcommand fix" -l include-default-paths -d 'include default paths in addition to the provided ones' +complete -c x.py -n "__fish_x.py_using_subcommand fix" -l dry-run -d 'dry run; don\'t build anything' +complete -c x.py -n "__fish_x.py_using_subcommand fix" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' +complete -c x.py -n "__fish_x.py_using_subcommand fix" -l json-output -d 'use message-format=json' +complete -c x.py -n "__fish_x.py_using_subcommand fix" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' +complete -c x.py -n "__fish_x.py_using_subcommand fix" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' +complete -c x.py -n "__fish_x.py_using_subcommand fix" -l enable-bolt-settings -d 'Enable BOLT link flags' +complete -c x.py -n "__fish_x.py_using_subcommand fix" -l skip-stage0-validation -d 'Skip stage0 compiler validation' +complete -c x.py -n "__fish_x.py_using_subcommand fix" -s h -l help -d 'Print help (see more with \'--help\')' +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l config -d 'TOML configuration file for build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l build -d 'build target of the stage0 compiler' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l host -d 'host targets to build' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l target -d 'target targets to build' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l exclude -d 'build paths to exclude' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l skip -d 'build paths to skip' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l rustc-error-format -r -f +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -s j -l jobs -d 'number of jobs to run in parallel' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l error-format -d 'rustc error format' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l set -d 'override options in config.toml' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l check -d 'check formatting instead of applying' +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l all -d 'apply to all appropriate files, not just those that have been modified' +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -s v -l verbose -d 'use verbose output (-vv for very verbose)' +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -s i -l incremental -d 'use incremental compilation' +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l include-default-paths -d 'include default paths in addition to the provided ones' +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l dry-run -d 'dry run; don\'t build anything' +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l json-output -d 'use message-format=json' +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l enable-bolt-settings -d 'Enable BOLT link flags' +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l skip-stage0-validation -d 'Skip stage0 compiler validation' +complete -c x.py -n "__fish_x.py_using_subcommand fmt" -s h -l help -d 'Print help (see more with \'--help\')' +complete -c x.py -n "__fish_x.py_using_subcommand doc" -l config -d 'TOML configuration file for build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand doc" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_using_subcommand doc" -l build -d 'build target of the stage0 compiler' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand doc" -l host -d 'host targets to build' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand doc" -l target -d 'target targets to build' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand doc" -l exclude -d 'build paths to exclude' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand doc" -l skip -d 'build paths to skip' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand doc" -l rustc-error-format -r -f +complete -c x.py -n "__fish_x.py_using_subcommand doc" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" +complete -c x.py -n "__fish_x.py_using_subcommand doc" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand doc" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand doc" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand doc" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_using_subcommand doc" -s j -l jobs -d 'number of jobs to run in parallel' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand doc" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand doc" -l error-format -d 'rustc error format' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand doc" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand doc" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand doc" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand doc" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand doc" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand doc" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r +complete -c x.py -n "__fish_x.py_using_subcommand doc" -l set -d 'override options in config.toml' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand doc" -l open -d 'open the docs in a browser' +complete -c x.py -n "__fish_x.py_using_subcommand doc" -l json -d 'render the documentation in JSON format in addition to the usual HTML format' +complete -c x.py -n "__fish_x.py_using_subcommand doc" -s v -l verbose -d 'use verbose output (-vv for very verbose)' +complete -c x.py -n "__fish_x.py_using_subcommand doc" -s i -l incremental -d 'use incremental compilation' +complete -c x.py -n "__fish_x.py_using_subcommand doc" -l include-default-paths -d 'include default paths in addition to the provided ones' +complete -c x.py -n "__fish_x.py_using_subcommand doc" -l dry-run -d 'dry run; don\'t build anything' +complete -c x.py -n "__fish_x.py_using_subcommand doc" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' +complete -c x.py -n "__fish_x.py_using_subcommand doc" -l json-output -d 'use message-format=json' +complete -c x.py -n "__fish_x.py_using_subcommand doc" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' +complete -c x.py -n "__fish_x.py_using_subcommand doc" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' +complete -c x.py -n "__fish_x.py_using_subcommand doc" -l enable-bolt-settings -d 'Enable BOLT link flags' +complete -c x.py -n "__fish_x.py_using_subcommand doc" -l skip-stage0-validation -d 'Skip stage0 compiler validation' +complete -c x.py -n "__fish_x.py_using_subcommand doc" -s h -l help -d 'Print help (see more with \'--help\')' +complete -c x.py -n "__fish_x.py_using_subcommand test" -l test-args -d 'extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)' -r +complete -c x.py -n "__fish_x.py_using_subcommand test" -l compiletest-rustc-args -d 'extra options to pass the compiler when running compiletest tests' -r +complete -c x.py -n "__fish_x.py_using_subcommand test" -l extra-checks -d 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell)' -r +complete -c x.py -n "__fish_x.py_using_subcommand test" -l compare-mode -d 'mode describing what file the actual ui output will be compared to' -r +complete -c x.py -n "__fish_x.py_using_subcommand test" -l pass -d 'force {check,build,run}-pass tests to this mode' -r +complete -c x.py -n "__fish_x.py_using_subcommand test" -l run -d 'whether to execute run-* tests' -r +complete -c x.py -n "__fish_x.py_using_subcommand test" -l config -d 'TOML configuration file for build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand test" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_using_subcommand test" -l build -d 'build target of the stage0 compiler' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand test" -l host -d 'host targets to build' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand test" -l target -d 'target targets to build' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand test" -l exclude -d 'build paths to exclude' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand test" -l skip -d 'build paths to skip' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand test" -l rustc-error-format -r -f +complete -c x.py -n "__fish_x.py_using_subcommand test" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" +complete -c x.py -n "__fish_x.py_using_subcommand test" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand test" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand test" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand test" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_using_subcommand test" -s j -l jobs -d 'number of jobs to run in parallel' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand test" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand test" -l error-format -d 'rustc error format' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand test" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand test" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand test" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand test" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand test" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand test" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r +complete -c x.py -n "__fish_x.py_using_subcommand test" -l set -d 'override options in config.toml' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand test" -l no-fail-fast -d 'run all tests regardless of failure' +complete -c x.py -n "__fish_x.py_using_subcommand test" -l no-doc -d 'do not run doc tests' +complete -c x.py -n "__fish_x.py_using_subcommand test" -l doc -d 'only run doc tests' +complete -c x.py -n "__fish_x.py_using_subcommand test" -l bless -d 'whether to automatically update stderr/stdout files' +complete -c x.py -n "__fish_x.py_using_subcommand test" -l force-rerun -d 'rerun tests even if the inputs are unchanged' +complete -c x.py -n "__fish_x.py_using_subcommand test" -l only-modified -d 'only run tests that result has been changed' +complete -c x.py -n "__fish_x.py_using_subcommand test" -l rustfix-coverage -d 'enable this to generate a Rustfix coverage file, which is saved in `//rustfix_missing_coverage.txt`' +complete -c x.py -n "__fish_x.py_using_subcommand test" -s v -l verbose -d 'use verbose output (-vv for very verbose)' +complete -c x.py -n "__fish_x.py_using_subcommand test" -s i -l incremental -d 'use incremental compilation' +complete -c x.py -n "__fish_x.py_using_subcommand test" -l include-default-paths -d 'include default paths in addition to the provided ones' +complete -c x.py -n "__fish_x.py_using_subcommand test" -l dry-run -d 'dry run; don\'t build anything' +complete -c x.py -n "__fish_x.py_using_subcommand test" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' +complete -c x.py -n "__fish_x.py_using_subcommand test" -l json-output -d 'use message-format=json' +complete -c x.py -n "__fish_x.py_using_subcommand test" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' +complete -c x.py -n "__fish_x.py_using_subcommand test" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' +complete -c x.py -n "__fish_x.py_using_subcommand test" -l enable-bolt-settings -d 'Enable BOLT link flags' +complete -c x.py -n "__fish_x.py_using_subcommand test" -l skip-stage0-validation -d 'Skip stage0 compiler validation' +complete -c x.py -n "__fish_x.py_using_subcommand test" -s h -l help -d 'Print help (see more with \'--help\')' +complete -c x.py -n "__fish_x.py_using_subcommand miri" -l test-args -d 'extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)' -r +complete -c x.py -n "__fish_x.py_using_subcommand miri" -l config -d 'TOML configuration file for build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand miri" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_using_subcommand miri" -l build -d 'build target of the stage0 compiler' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand miri" -l host -d 'host targets to build' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand miri" -l target -d 'target targets to build' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand miri" -l exclude -d 'build paths to exclude' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand miri" -l skip -d 'build paths to skip' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand miri" -l rustc-error-format -r -f +complete -c x.py -n "__fish_x.py_using_subcommand miri" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" +complete -c x.py -n "__fish_x.py_using_subcommand miri" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand miri" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand miri" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand miri" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_using_subcommand miri" -s j -l jobs -d 'number of jobs to run in parallel' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand miri" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand miri" -l error-format -d 'rustc error format' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand miri" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand miri" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand miri" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand miri" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand miri" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand miri" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r +complete -c x.py -n "__fish_x.py_using_subcommand miri" -l set -d 'override options in config.toml' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand miri" -l no-fail-fast -d 'run all tests regardless of failure' +complete -c x.py -n "__fish_x.py_using_subcommand miri" -l no-doc -d 'do not run doc tests' +complete -c x.py -n "__fish_x.py_using_subcommand miri" -l doc -d 'only run doc tests' +complete -c x.py -n "__fish_x.py_using_subcommand miri" -s v -l verbose -d 'use verbose output (-vv for very verbose)' +complete -c x.py -n "__fish_x.py_using_subcommand miri" -s i -l incremental -d 'use incremental compilation' +complete -c x.py -n "__fish_x.py_using_subcommand miri" -l include-default-paths -d 'include default paths in addition to the provided ones' +complete -c x.py -n "__fish_x.py_using_subcommand miri" -l dry-run -d 'dry run; don\'t build anything' +complete -c x.py -n "__fish_x.py_using_subcommand miri" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' +complete -c x.py -n "__fish_x.py_using_subcommand miri" -l json-output -d 'use message-format=json' +complete -c x.py -n "__fish_x.py_using_subcommand miri" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' +complete -c x.py -n "__fish_x.py_using_subcommand miri" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' +complete -c x.py -n "__fish_x.py_using_subcommand miri" -l enable-bolt-settings -d 'Enable BOLT link flags' +complete -c x.py -n "__fish_x.py_using_subcommand miri" -l skip-stage0-validation -d 'Skip stage0 compiler validation' +complete -c x.py -n "__fish_x.py_using_subcommand miri" -s h -l help -d 'Print help (see more with \'--help\')' +complete -c x.py -n "__fish_x.py_using_subcommand bench" -l test-args -r +complete -c x.py -n "__fish_x.py_using_subcommand bench" -l config -d 'TOML configuration file for build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand bench" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_using_subcommand bench" -l build -d 'build target of the stage0 compiler' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand bench" -l host -d 'host targets to build' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand bench" -l target -d 'target targets to build' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand bench" -l exclude -d 'build paths to exclude' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand bench" -l skip -d 'build paths to skip' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand bench" -l rustc-error-format -r -f +complete -c x.py -n "__fish_x.py_using_subcommand bench" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" +complete -c x.py -n "__fish_x.py_using_subcommand bench" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand bench" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand bench" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand bench" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_using_subcommand bench" -s j -l jobs -d 'number of jobs to run in parallel' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand bench" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand bench" -l error-format -d 'rustc error format' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand bench" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand bench" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand bench" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand bench" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand bench" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand bench" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r +complete -c x.py -n "__fish_x.py_using_subcommand bench" -l set -d 'override options in config.toml' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand bench" -s v -l verbose -d 'use verbose output (-vv for very verbose)' +complete -c x.py -n "__fish_x.py_using_subcommand bench" -s i -l incremental -d 'use incremental compilation' +complete -c x.py -n "__fish_x.py_using_subcommand bench" -l include-default-paths -d 'include default paths in addition to the provided ones' +complete -c x.py -n "__fish_x.py_using_subcommand bench" -l dry-run -d 'dry run; don\'t build anything' +complete -c x.py -n "__fish_x.py_using_subcommand bench" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' +complete -c x.py -n "__fish_x.py_using_subcommand bench" -l json-output -d 'use message-format=json' +complete -c x.py -n "__fish_x.py_using_subcommand bench" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' +complete -c x.py -n "__fish_x.py_using_subcommand bench" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' +complete -c x.py -n "__fish_x.py_using_subcommand bench" -l enable-bolt-settings -d 'Enable BOLT link flags' +complete -c x.py -n "__fish_x.py_using_subcommand bench" -l skip-stage0-validation -d 'Skip stage0 compiler validation' +complete -c x.py -n "__fish_x.py_using_subcommand bench" -s h -l help -d 'Print help (see more with \'--help\')' +complete -c x.py -n "__fish_x.py_using_subcommand clean" -l stage -d 'Clean a specific stage without touching other artifacts. By default, every stage is cleaned if this option is not used' -r +complete -c x.py -n "__fish_x.py_using_subcommand clean" -l config -d 'TOML configuration file for build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand clean" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_using_subcommand clean" -l build -d 'build target of the stage0 compiler' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand clean" -l host -d 'host targets to build' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand clean" -l target -d 'target targets to build' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand clean" -l exclude -d 'build paths to exclude' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand clean" -l skip -d 'build paths to skip' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand clean" -l rustc-error-format -r -f +complete -c x.py -n "__fish_x.py_using_subcommand clean" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" +complete -c x.py -n "__fish_x.py_using_subcommand clean" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand clean" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand clean" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_using_subcommand clean" -s j -l jobs -d 'number of jobs to run in parallel' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand clean" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand clean" -l error-format -d 'rustc error format' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand clean" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand clean" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand clean" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand clean" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand clean" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand clean" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r +complete -c x.py -n "__fish_x.py_using_subcommand clean" -l set -d 'override options in config.toml' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand clean" -l all -d 'Clean the entire build directory (not used by default)' +complete -c x.py -n "__fish_x.py_using_subcommand clean" -s v -l verbose -d 'use verbose output (-vv for very verbose)' +complete -c x.py -n "__fish_x.py_using_subcommand clean" -s i -l incremental -d 'use incremental compilation' +complete -c x.py -n "__fish_x.py_using_subcommand clean" -l include-default-paths -d 'include default paths in addition to the provided ones' +complete -c x.py -n "__fish_x.py_using_subcommand clean" -l dry-run -d 'dry run; don\'t build anything' +complete -c x.py -n "__fish_x.py_using_subcommand clean" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' +complete -c x.py -n "__fish_x.py_using_subcommand clean" -l json-output -d 'use message-format=json' +complete -c x.py -n "__fish_x.py_using_subcommand clean" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' +complete -c x.py -n "__fish_x.py_using_subcommand clean" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' +complete -c x.py -n "__fish_x.py_using_subcommand clean" -l enable-bolt-settings -d 'Enable BOLT link flags' +complete -c x.py -n "__fish_x.py_using_subcommand clean" -l skip-stage0-validation -d 'Skip stage0 compiler validation' +complete -c x.py -n "__fish_x.py_using_subcommand clean" -s h -l help -d 'Print help (see more with \'--help\')' +complete -c x.py -n "__fish_x.py_using_subcommand dist" -l config -d 'TOML configuration file for build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand dist" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_using_subcommand dist" -l build -d 'build target of the stage0 compiler' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand dist" -l host -d 'host targets to build' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand dist" -l target -d 'target targets to build' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand dist" -l exclude -d 'build paths to exclude' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand dist" -l skip -d 'build paths to skip' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand dist" -l rustc-error-format -r -f +complete -c x.py -n "__fish_x.py_using_subcommand dist" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" +complete -c x.py -n "__fish_x.py_using_subcommand dist" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand dist" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand dist" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand dist" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_using_subcommand dist" -s j -l jobs -d 'number of jobs to run in parallel' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand dist" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand dist" -l error-format -d 'rustc error format' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand dist" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand dist" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand dist" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand dist" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand dist" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand dist" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r +complete -c x.py -n "__fish_x.py_using_subcommand dist" -l set -d 'override options in config.toml' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand dist" -s v -l verbose -d 'use verbose output (-vv for very verbose)' +complete -c x.py -n "__fish_x.py_using_subcommand dist" -s i -l incremental -d 'use incremental compilation' +complete -c x.py -n "__fish_x.py_using_subcommand dist" -l include-default-paths -d 'include default paths in addition to the provided ones' +complete -c x.py -n "__fish_x.py_using_subcommand dist" -l dry-run -d 'dry run; don\'t build anything' +complete -c x.py -n "__fish_x.py_using_subcommand dist" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' +complete -c x.py -n "__fish_x.py_using_subcommand dist" -l json-output -d 'use message-format=json' +complete -c x.py -n "__fish_x.py_using_subcommand dist" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' +complete -c x.py -n "__fish_x.py_using_subcommand dist" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' +complete -c x.py -n "__fish_x.py_using_subcommand dist" -l enable-bolt-settings -d 'Enable BOLT link flags' +complete -c x.py -n "__fish_x.py_using_subcommand dist" -l skip-stage0-validation -d 'Skip stage0 compiler validation' +complete -c x.py -n "__fish_x.py_using_subcommand dist" -s h -l help -d 'Print help (see more with \'--help\')' +complete -c x.py -n "__fish_x.py_using_subcommand install" -l config -d 'TOML configuration file for build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand install" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_using_subcommand install" -l build -d 'build target of the stage0 compiler' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand install" -l host -d 'host targets to build' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand install" -l target -d 'target targets to build' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand install" -l exclude -d 'build paths to exclude' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand install" -l skip -d 'build paths to skip' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand install" -l rustc-error-format -r -f +complete -c x.py -n "__fish_x.py_using_subcommand install" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" +complete -c x.py -n "__fish_x.py_using_subcommand install" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand install" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand install" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand install" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_using_subcommand install" -s j -l jobs -d 'number of jobs to run in parallel' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand install" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand install" -l error-format -d 'rustc error format' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand install" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand install" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand install" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand install" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand install" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand install" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r +complete -c x.py -n "__fish_x.py_using_subcommand install" -l set -d 'override options in config.toml' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand install" -s v -l verbose -d 'use verbose output (-vv for very verbose)' +complete -c x.py -n "__fish_x.py_using_subcommand install" -s i -l incremental -d 'use incremental compilation' +complete -c x.py -n "__fish_x.py_using_subcommand install" -l include-default-paths -d 'include default paths in addition to the provided ones' +complete -c x.py -n "__fish_x.py_using_subcommand install" -l dry-run -d 'dry run; don\'t build anything' +complete -c x.py -n "__fish_x.py_using_subcommand install" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' +complete -c x.py -n "__fish_x.py_using_subcommand install" -l json-output -d 'use message-format=json' +complete -c x.py -n "__fish_x.py_using_subcommand install" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' +complete -c x.py -n "__fish_x.py_using_subcommand install" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' +complete -c x.py -n "__fish_x.py_using_subcommand install" -l enable-bolt-settings -d 'Enable BOLT link flags' +complete -c x.py -n "__fish_x.py_using_subcommand install" -l skip-stage0-validation -d 'Skip stage0 compiler validation' +complete -c x.py -n "__fish_x.py_using_subcommand install" -s h -l help -d 'Print help (see more with \'--help\')' +complete -c x.py -n "__fish_x.py_using_subcommand run" -l args -d 'arguments for the tool' -r +complete -c x.py -n "__fish_x.py_using_subcommand run" -l config -d 'TOML configuration file for build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand run" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_using_subcommand run" -l build -d 'build target of the stage0 compiler' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand run" -l host -d 'host targets to build' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand run" -l target -d 'target targets to build' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand run" -l exclude -d 'build paths to exclude' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand run" -l skip -d 'build paths to skip' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand run" -l rustc-error-format -r -f +complete -c x.py -n "__fish_x.py_using_subcommand run" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" +complete -c x.py -n "__fish_x.py_using_subcommand run" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand run" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand run" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand run" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_using_subcommand run" -s j -l jobs -d 'number of jobs to run in parallel' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand run" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand run" -l error-format -d 'rustc error format' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand run" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand run" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand run" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand run" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand run" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand run" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r +complete -c x.py -n "__fish_x.py_using_subcommand run" -l set -d 'override options in config.toml' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand run" -s v -l verbose -d 'use verbose output (-vv for very verbose)' +complete -c x.py -n "__fish_x.py_using_subcommand run" -s i -l incremental -d 'use incremental compilation' +complete -c x.py -n "__fish_x.py_using_subcommand run" -l include-default-paths -d 'include default paths in addition to the provided ones' +complete -c x.py -n "__fish_x.py_using_subcommand run" -l dry-run -d 'dry run; don\'t build anything' +complete -c x.py -n "__fish_x.py_using_subcommand run" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' +complete -c x.py -n "__fish_x.py_using_subcommand run" -l json-output -d 'use message-format=json' +complete -c x.py -n "__fish_x.py_using_subcommand run" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' +complete -c x.py -n "__fish_x.py_using_subcommand run" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' +complete -c x.py -n "__fish_x.py_using_subcommand run" -l enable-bolt-settings -d 'Enable BOLT link flags' +complete -c x.py -n "__fish_x.py_using_subcommand run" -l skip-stage0-validation -d 'Skip stage0 compiler validation' +complete -c x.py -n "__fish_x.py_using_subcommand run" -s h -l help -d 'Print help (see more with \'--help\')' +complete -c x.py -n "__fish_x.py_using_subcommand setup" -l config -d 'TOML configuration file for build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand setup" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_using_subcommand setup" -l build -d 'build target of the stage0 compiler' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand setup" -l host -d 'host targets to build' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand setup" -l target -d 'target targets to build' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand setup" -l exclude -d 'build paths to exclude' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand setup" -l skip -d 'build paths to skip' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand setup" -l rustc-error-format -r -f +complete -c x.py -n "__fish_x.py_using_subcommand setup" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" +complete -c x.py -n "__fish_x.py_using_subcommand setup" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand setup" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand setup" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand setup" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_using_subcommand setup" -s j -l jobs -d 'number of jobs to run in parallel' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand setup" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand setup" -l error-format -d 'rustc error format' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand setup" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand setup" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand setup" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand setup" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand setup" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand setup" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r +complete -c x.py -n "__fish_x.py_using_subcommand setup" -l set -d 'override options in config.toml' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand setup" -s v -l verbose -d 'use verbose output (-vv for very verbose)' +complete -c x.py -n "__fish_x.py_using_subcommand setup" -s i -l incremental -d 'use incremental compilation' +complete -c x.py -n "__fish_x.py_using_subcommand setup" -l include-default-paths -d 'include default paths in addition to the provided ones' +complete -c x.py -n "__fish_x.py_using_subcommand setup" -l dry-run -d 'dry run; don\'t build anything' +complete -c x.py -n "__fish_x.py_using_subcommand setup" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' +complete -c x.py -n "__fish_x.py_using_subcommand setup" -l json-output -d 'use message-format=json' +complete -c x.py -n "__fish_x.py_using_subcommand setup" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' +complete -c x.py -n "__fish_x.py_using_subcommand setup" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' +complete -c x.py -n "__fish_x.py_using_subcommand setup" -l enable-bolt-settings -d 'Enable BOLT link flags' +complete -c x.py -n "__fish_x.py_using_subcommand setup" -l skip-stage0-validation -d 'Skip stage0 compiler validation' +complete -c x.py -n "__fish_x.py_using_subcommand setup" -s h -l help -d 'Print help (see more with \'--help\')' +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l config -d 'TOML configuration file for build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l build -d 'build target of the stage0 compiler' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l host -d 'host targets to build' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l target -d 'target targets to build' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l exclude -d 'build paths to exclude' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l skip -d 'build paths to skip' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l rustc-error-format -r -f +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -s j -l jobs -d 'number of jobs to run in parallel' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l error-format -d 'rustc error format' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l set -d 'override options in config.toml' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l run -d 'run suggested tests' +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -s v -l verbose -d 'use verbose output (-vv for very verbose)' +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -s i -l incremental -d 'use incremental compilation' +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l include-default-paths -d 'include default paths in addition to the provided ones' +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l dry-run -d 'dry run; don\'t build anything' +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l json-output -d 'use message-format=json' +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l enable-bolt-settings -d 'Enable BOLT link flags' +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l skip-stage0-validation -d 'Skip stage0 compiler validation' +complete -c x.py -n "__fish_x.py_using_subcommand suggest" -s h -l help -d 'Print help (see more with \'--help\')' +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l sync -d 'Additional `Cargo.toml` to sync and vendor' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l config -d 'TOML configuration file for build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l build -d 'build target of the stage0 compiler' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l host -d 'host targets to build' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l target -d 'target targets to build' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l exclude -d 'build paths to exclude' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l skip -d 'build paths to skip' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l rustc-error-format -r -f +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -s j -l jobs -d 'number of jobs to run in parallel' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l error-format -d 'rustc error format' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l set -d 'override options in config.toml' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l versioned-dirs -d 'Always include version in subdir name' +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -s v -l verbose -d 'use verbose output (-vv for very verbose)' +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -s i -l incremental -d 'use incremental compilation' +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l include-default-paths -d 'include default paths in addition to the provided ones' +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l dry-run -d 'dry run; don\'t build anything' +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l json-output -d 'use message-format=json' +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l enable-bolt-settings -d 'Enable BOLT link flags' +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l skip-stage0-validation -d 'Skip stage0 compiler validation' +complete -c x.py -n "__fish_x.py_using_subcommand vendor" -s h -l help -d 'Print help (see more with \'--help\')' +complete -c x.py -n "__fish_x.py_using_subcommand perf" -l config -d 'TOML configuration file for build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand perf" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_using_subcommand perf" -l build -d 'build target of the stage0 compiler' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand perf" -l host -d 'host targets to build' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand perf" -l target -d 'target targets to build' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand perf" -l exclude -d 'build paths to exclude' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand perf" -l skip -d 'build paths to skip' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand perf" -l rustc-error-format -r -f +complete -c x.py -n "__fish_x.py_using_subcommand perf" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)" +complete -c x.py -n "__fish_x.py_using_subcommand perf" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand perf" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand perf" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand perf" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)" +complete -c x.py -n "__fish_x.py_using_subcommand perf" -s j -l jobs -d 'number of jobs to run in parallel' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand perf" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand perf" -l error-format -d 'rustc error format' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand perf" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand perf" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}" +complete -c x.py -n "__fish_x.py_using_subcommand perf" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand perf" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand perf" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F +complete -c x.py -n "__fish_x.py_using_subcommand perf" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r +complete -c x.py -n "__fish_x.py_using_subcommand perf" -l set -d 'override options in config.toml' -r -f +complete -c x.py -n "__fish_x.py_using_subcommand perf" -s v -l verbose -d 'use verbose output (-vv for very verbose)' +complete -c x.py -n "__fish_x.py_using_subcommand perf" -s i -l incremental -d 'use incremental compilation' +complete -c x.py -n "__fish_x.py_using_subcommand perf" -l include-default-paths -d 'include default paths in addition to the provided ones' +complete -c x.py -n "__fish_x.py_using_subcommand perf" -l dry-run -d 'dry run; don\'t build anything' +complete -c x.py -n "__fish_x.py_using_subcommand perf" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims' +complete -c x.py -n "__fish_x.py_using_subcommand perf" -l json-output -d 'use message-format=json' +complete -c x.py -n "__fish_x.py_using_subcommand perf" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)' +complete -c x.py -n "__fish_x.py_using_subcommand perf" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc' +complete -c x.py -n "__fish_x.py_using_subcommand perf" -l enable-bolt-settings -d 'Enable BOLT link flags' +complete -c x.py -n "__fish_x.py_using_subcommand perf" -l skip-stage0-validation -d 'Skip stage0 compiler validation' +complete -c x.py -n "__fish_x.py_using_subcommand perf" -s h -l help -d 'Print help (see more with \'--help\')' diff --git a/src/etc/completions/x.py.ps1 b/src/etc/completions/x.py.ps1 index 4b424471a267..240de32451de 100644 --- a/src/etc/completions/x.py.ps1 +++ b/src/etc/completions/x.py.ps1 @@ -21,44 +21,44 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock { $completions = @(switch ($command) { 'x.py' { - [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') - [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') - [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') - [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build') - [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build') - [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') - [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip') - [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') - [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') - [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)') - [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') - [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') - [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format') - [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') - [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') - [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') - [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') - [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') - [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') - [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml') - [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') - [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') - [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') - [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json') - [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') - [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') - [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') - [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') - [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') - [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') + [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') + [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') + [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build') + [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build') + [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') + [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip') + [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') + [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') + [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)') + [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') + [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') + [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format') + [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') + [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') + [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') + [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') + [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') + [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') + [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml') + [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') + [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') + [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') + [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json') + [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') + [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') + [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') + [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') + [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') [CompletionResult]::new('build', 'build', [CompletionResultType]::ParameterValue, 'Compile either the compiler or libraries') [CompletionResult]::new('check', 'check', [CompletionResultType]::ParameterValue, 'Compile either the compiler or libraries, using cargo check') [CompletionResult]::new('clippy', 'clippy', [CompletionResultType]::ParameterValue, 'Run Clippy (uses rustup/cargo-installed clippy binary)') @@ -79,735 +79,735 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock { break } 'x.py;build' { - [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') - [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') - [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') - [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build') - [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build') - [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') - [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip') - [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') - [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') - [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)') - [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') - [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') - [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format') - [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') - [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') - [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') - [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') - [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') - [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') - [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml') - [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') - [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') - [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') - [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json') - [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') - [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') - [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') - [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') - [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') - [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') + [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') + [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') + [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build') + [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build') + [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') + [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip') + [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') + [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') + [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)') + [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') + [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') + [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format') + [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') + [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') + [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') + [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') + [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') + [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') + [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml') + [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') + [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') + [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') + [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json') + [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') + [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') + [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') + [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') + [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') break } 'x.py;check' { - [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') - [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') - [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') - [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build') - [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build') - [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') - [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip') - [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') - [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') - [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)') - [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') - [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') - [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format') - [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') - [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') - [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') - [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') - [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') - [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') - [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml') - [CompletionResult]::new('--all-targets', 'all-targets', [CompletionResultType]::ParameterName, 'Check all targets') - [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') - [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') - [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') - [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json') - [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') - [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') - [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') - [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') - [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') - [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') + [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') + [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') + [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build') + [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build') + [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') + [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip') + [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') + [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') + [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)') + [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') + [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') + [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format') + [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') + [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') + [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') + [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') + [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') + [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') + [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml') + [CompletionResult]::new('--all-targets', '--all-targets', [CompletionResultType]::ParameterName, 'Check all targets') + [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') + [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') + [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') + [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json') + [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') + [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') + [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') + [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') + [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') break } 'x.py;clippy' { - [CompletionResult]::new('-A', 'A ', [CompletionResultType]::ParameterName, 'clippy lints to allow') - [CompletionResult]::new('-D', 'D ', [CompletionResultType]::ParameterName, 'clippy lints to deny') - [CompletionResult]::new('-W', 'W ', [CompletionResultType]::ParameterName, 'clippy lints to warn on') - [CompletionResult]::new('-F', 'F ', [CompletionResultType]::ParameterName, 'clippy lints to forbid') - [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') - [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') - [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') - [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build') - [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build') - [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') - [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip') - [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') - [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') - [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)') - [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') - [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') - [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format') - [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') - [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') - [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') - [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') - [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') - [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') - [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml') - [CompletionResult]::new('--fix', 'fix', [CompletionResultType]::ParameterName, 'fix') - [CompletionResult]::new('--allow-dirty', 'allow-dirty', [CompletionResultType]::ParameterName, 'allow-dirty') - [CompletionResult]::new('--allow-staged', 'allow-staged', [CompletionResultType]::ParameterName, 'allow-staged') - [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') - [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') - [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') - [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json') - [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') - [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') - [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') - [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') - [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') - [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('-A', '-A ', [CompletionResultType]::ParameterName, 'clippy lints to allow') + [CompletionResult]::new('-D', '-D ', [CompletionResultType]::ParameterName, 'clippy lints to deny') + [CompletionResult]::new('-W', '-W ', [CompletionResultType]::ParameterName, 'clippy lints to warn on') + [CompletionResult]::new('-F', '-F ', [CompletionResultType]::ParameterName, 'clippy lints to forbid') + [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') + [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') + [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') + [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build') + [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build') + [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') + [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip') + [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') + [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') + [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)') + [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') + [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') + [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format') + [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') + [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') + [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') + [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') + [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') + [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') + [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml') + [CompletionResult]::new('--fix', '--fix', [CompletionResultType]::ParameterName, 'fix') + [CompletionResult]::new('--allow-dirty', '--allow-dirty', [CompletionResultType]::ParameterName, 'allow-dirty') + [CompletionResult]::new('--allow-staged', '--allow-staged', [CompletionResultType]::ParameterName, 'allow-staged') + [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') + [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') + [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') + [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json') + [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') + [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') + [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') + [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') + [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') break } 'x.py;fix' { - [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') - [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') - [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') - [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build') - [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build') - [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') - [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip') - [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') - [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') - [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)') - [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') - [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') - [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format') - [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') - [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') - [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') - [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') - [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') - [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') - [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml') - [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') - [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') - [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') - [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json') - [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') - [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') - [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') - [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') - [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') - [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') + [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') + [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') + [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build') + [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build') + [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') + [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip') + [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') + [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') + [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)') + [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') + [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') + [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format') + [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') + [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') + [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') + [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') + [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') + [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') + [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml') + [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') + [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') + [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') + [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json') + [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') + [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') + [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') + [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') + [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') break } 'x.py;fmt' { - [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') - [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') - [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') - [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build') - [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build') - [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') - [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip') - [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') - [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') - [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)') - [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') - [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') - [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format') - [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') - [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') - [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') - [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') - [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') - [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') - [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml') - [CompletionResult]::new('--check', 'check', [CompletionResultType]::ParameterName, 'check formatting instead of applying') - [CompletionResult]::new('--all', 'all', [CompletionResultType]::ParameterName, 'apply to all appropriate files, not just those that have been modified') - [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') - [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') - [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') - [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json') - [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') - [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') - [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') - [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') - [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') - [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') + [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') + [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') + [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build') + [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build') + [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') + [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip') + [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') + [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') + [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)') + [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') + [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') + [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format') + [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') + [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') + [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') + [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') + [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') + [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') + [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml') + [CompletionResult]::new('--check', '--check', [CompletionResultType]::ParameterName, 'check formatting instead of applying') + [CompletionResult]::new('--all', '--all', [CompletionResultType]::ParameterName, 'apply to all appropriate files, not just those that have been modified') + [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') + [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') + [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') + [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json') + [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') + [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') + [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') + [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') + [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') break } 'x.py;doc' { - [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') - [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') - [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') - [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build') - [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build') - [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') - [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip') - [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') - [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') - [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)') - [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') - [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') - [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format') - [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') - [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') - [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') - [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') - [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') - [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') - [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml') - [CompletionResult]::new('--open', 'open', [CompletionResultType]::ParameterName, 'open the docs in a browser') - [CompletionResult]::new('--json', 'json', [CompletionResultType]::ParameterName, 'render the documentation in JSON format in addition to the usual HTML format') - [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') - [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') - [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') - [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json') - [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') - [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') - [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') - [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') - [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') - [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') + [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') + [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') + [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build') + [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build') + [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') + [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip') + [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') + [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') + [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)') + [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') + [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') + [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format') + [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') + [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') + [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') + [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') + [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') + [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') + [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml') + [CompletionResult]::new('--open', '--open', [CompletionResultType]::ParameterName, 'open the docs in a browser') + [CompletionResult]::new('--json', '--json', [CompletionResultType]::ParameterName, 'render the documentation in JSON format in addition to the usual HTML format') + [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') + [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') + [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') + [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json') + [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') + [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') + [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') + [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') + [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') break } 'x.py;test' { - [CompletionResult]::new('--test-args', 'test-args', [CompletionResultType]::ParameterName, 'extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)') - [CompletionResult]::new('--compiletest-rustc-args', 'compiletest-rustc-args', [CompletionResultType]::ParameterName, 'extra options to pass the compiler when running compiletest tests') - [CompletionResult]::new('--extra-checks', 'extra-checks', [CompletionResultType]::ParameterName, 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell)') - [CompletionResult]::new('--compare-mode', 'compare-mode', [CompletionResultType]::ParameterName, 'mode describing what file the actual ui output will be compared to') - [CompletionResult]::new('--pass', 'pass', [CompletionResultType]::ParameterName, 'force {check,build,run}-pass tests to this mode') - [CompletionResult]::new('--run', 'run', [CompletionResultType]::ParameterName, 'whether to execute run-* tests') - [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') - [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') - [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') - [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build') - [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build') - [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') - [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip') - [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') - [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') - [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)') - [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') - [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') - [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format') - [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') - [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') - [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') - [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') - [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') - [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') - [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml') - [CompletionResult]::new('--no-fail-fast', 'no-fail-fast', [CompletionResultType]::ParameterName, 'run all tests regardless of failure') - [CompletionResult]::new('--no-doc', 'no-doc', [CompletionResultType]::ParameterName, 'do not run doc tests') - [CompletionResult]::new('--doc', 'doc', [CompletionResultType]::ParameterName, 'only run doc tests') - [CompletionResult]::new('--bless', 'bless', [CompletionResultType]::ParameterName, 'whether to automatically update stderr/stdout files') - [CompletionResult]::new('--force-rerun', 'force-rerun', [CompletionResultType]::ParameterName, 'rerun tests even if the inputs are unchanged') - [CompletionResult]::new('--only-modified', 'only-modified', [CompletionResultType]::ParameterName, 'only run tests that result has been changed') - [CompletionResult]::new('--rustfix-coverage', 'rustfix-coverage', [CompletionResultType]::ParameterName, 'enable this to generate a Rustfix coverage file, which is saved in `//rustfix_missing_coverage.txt`') - [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') - [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') - [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') - [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json') - [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') - [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') - [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') - [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') - [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') - [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--test-args', '--test-args', [CompletionResultType]::ParameterName, 'extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)') + [CompletionResult]::new('--compiletest-rustc-args', '--compiletest-rustc-args', [CompletionResultType]::ParameterName, 'extra options to pass the compiler when running compiletest tests') + [CompletionResult]::new('--extra-checks', '--extra-checks', [CompletionResultType]::ParameterName, 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell)') + [CompletionResult]::new('--compare-mode', '--compare-mode', [CompletionResultType]::ParameterName, 'mode describing what file the actual ui output will be compared to') + [CompletionResult]::new('--pass', '--pass', [CompletionResultType]::ParameterName, 'force {check,build,run}-pass tests to this mode') + [CompletionResult]::new('--run', '--run', [CompletionResultType]::ParameterName, 'whether to execute run-* tests') + [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') + [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') + [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') + [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build') + [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build') + [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') + [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip') + [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') + [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') + [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)') + [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') + [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') + [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format') + [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') + [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') + [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') + [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') + [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') + [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') + [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml') + [CompletionResult]::new('--no-fail-fast', '--no-fail-fast', [CompletionResultType]::ParameterName, 'run all tests regardless of failure') + [CompletionResult]::new('--no-doc', '--no-doc', [CompletionResultType]::ParameterName, 'do not run doc tests') + [CompletionResult]::new('--doc', '--doc', [CompletionResultType]::ParameterName, 'only run doc tests') + [CompletionResult]::new('--bless', '--bless', [CompletionResultType]::ParameterName, 'whether to automatically update stderr/stdout files') + [CompletionResult]::new('--force-rerun', '--force-rerun', [CompletionResultType]::ParameterName, 'rerun tests even if the inputs are unchanged') + [CompletionResult]::new('--only-modified', '--only-modified', [CompletionResultType]::ParameterName, 'only run tests that result has been changed') + [CompletionResult]::new('--rustfix-coverage', '--rustfix-coverage', [CompletionResultType]::ParameterName, 'enable this to generate a Rustfix coverage file, which is saved in `//rustfix_missing_coverage.txt`') + [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') + [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') + [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') + [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json') + [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') + [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') + [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') + [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') + [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') break } 'x.py;miri' { - [CompletionResult]::new('--test-args', 'test-args', [CompletionResultType]::ParameterName, 'extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)') - [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') - [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') - [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') - [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build') - [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build') - [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') - [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip') - [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') - [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') - [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)') - [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') - [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') - [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format') - [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') - [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') - [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') - [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') - [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') - [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') - [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml') - [CompletionResult]::new('--no-fail-fast', 'no-fail-fast', [CompletionResultType]::ParameterName, 'run all tests regardless of failure') - [CompletionResult]::new('--no-doc', 'no-doc', [CompletionResultType]::ParameterName, 'do not run doc tests') - [CompletionResult]::new('--doc', 'doc', [CompletionResultType]::ParameterName, 'only run doc tests') - [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') - [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') - [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') - [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json') - [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') - [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') - [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') - [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') - [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') - [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--test-args', '--test-args', [CompletionResultType]::ParameterName, 'extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)') + [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') + [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') + [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') + [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build') + [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build') + [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') + [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip') + [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') + [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') + [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)') + [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') + [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') + [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format') + [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') + [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') + [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') + [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') + [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') + [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') + [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml') + [CompletionResult]::new('--no-fail-fast', '--no-fail-fast', [CompletionResultType]::ParameterName, 'run all tests regardless of failure') + [CompletionResult]::new('--no-doc', '--no-doc', [CompletionResultType]::ParameterName, 'do not run doc tests') + [CompletionResult]::new('--doc', '--doc', [CompletionResultType]::ParameterName, 'only run doc tests') + [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') + [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') + [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') + [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json') + [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') + [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') + [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') + [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') + [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') break } 'x.py;bench' { - [CompletionResult]::new('--test-args', 'test-args', [CompletionResultType]::ParameterName, 'test-args') - [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') - [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') - [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') - [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build') - [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build') - [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') - [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip') - [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') - [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') - [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)') - [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') - [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') - [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format') - [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') - [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') - [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') - [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') - [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') - [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') - [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml') - [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') - [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') - [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') - [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json') - [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') - [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') - [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') - [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') - [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') - [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--test-args', '--test-args', [CompletionResultType]::ParameterName, 'test-args') + [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') + [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') + [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') + [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build') + [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build') + [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') + [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip') + [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') + [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') + [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)') + [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') + [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') + [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format') + [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') + [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') + [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') + [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') + [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') + [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') + [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml') + [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') + [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') + [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') + [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json') + [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') + [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') + [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') + [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') + [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') break } 'x.py;clean' { - [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'Clean a specific stage without touching other artifacts. By default, every stage is cleaned if this option is not used') - [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') - [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') - [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') - [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build') - [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build') - [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') - [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip') - [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') - [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') - [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') - [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') - [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format') - [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') - [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') - [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') - [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') - [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') - [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') - [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml') - [CompletionResult]::new('--all', 'all', [CompletionResultType]::ParameterName, 'Clean the entire build directory (not used by default)') - [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') - [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') - [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') - [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json') - [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') - [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') - [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') - [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') - [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') - [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'Clean a specific stage without touching other artifacts. By default, every stage is cleaned if this option is not used') + [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') + [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') + [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') + [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build') + [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build') + [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') + [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip') + [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') + [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') + [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') + [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') + [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format') + [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') + [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') + [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') + [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') + [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') + [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') + [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml') + [CompletionResult]::new('--all', '--all', [CompletionResultType]::ParameterName, 'Clean the entire build directory (not used by default)') + [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') + [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') + [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') + [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json') + [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') + [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') + [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') + [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') + [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') break } 'x.py;dist' { - [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') - [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') - [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') - [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build') - [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build') - [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') - [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip') - [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') - [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') - [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)') - [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') - [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') - [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format') - [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') - [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') - [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') - [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') - [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') - [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') - [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml') - [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') - [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') - [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') - [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json') - [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') - [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') - [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') - [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') - [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') - [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') + [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') + [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') + [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build') + [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build') + [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') + [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip') + [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') + [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') + [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)') + [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') + [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') + [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format') + [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') + [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') + [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') + [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') + [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') + [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') + [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml') + [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') + [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') + [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') + [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json') + [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') + [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') + [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') + [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') + [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') break } 'x.py;install' { - [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') - [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') - [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') - [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build') - [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build') - [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') - [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip') - [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') - [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') - [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)') - [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') - [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') - [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format') - [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') - [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') - [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') - [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') - [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') - [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') - [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml') - [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') - [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') - [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') - [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json') - [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') - [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') - [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') - [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') - [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') - [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') + [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') + [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') + [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build') + [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build') + [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') + [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip') + [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') + [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') + [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)') + [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') + [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') + [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format') + [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') + [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') + [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') + [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') + [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') + [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') + [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml') + [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') + [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') + [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') + [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json') + [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') + [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') + [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') + [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') + [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') break } 'x.py;run' { - [CompletionResult]::new('--args', 'args', [CompletionResultType]::ParameterName, 'arguments for the tool') - [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') - [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') - [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') - [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build') - [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build') - [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') - [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip') - [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') - [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') - [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)') - [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') - [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') - [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format') - [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') - [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') - [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') - [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') - [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') - [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') - [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml') - [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') - [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') - [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') - [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json') - [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') - [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') - [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') - [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') - [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') - [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--args', '--args', [CompletionResultType]::ParameterName, 'arguments for the tool') + [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') + [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') + [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') + [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build') + [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build') + [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') + [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip') + [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') + [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') + [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)') + [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') + [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') + [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format') + [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') + [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') + [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') + [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') + [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') + [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') + [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml') + [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') + [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') + [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') + [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json') + [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') + [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') + [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') + [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') + [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') break } 'x.py;setup' { - [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') - [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') - [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') - [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build') - [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build') - [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') - [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip') - [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') - [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') - [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)') - [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') - [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') - [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format') - [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') - [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') - [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') - [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') - [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') - [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') - [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml') - [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') - [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') - [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') - [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json') - [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') - [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') - [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') - [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') - [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') - [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') + [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') + [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') + [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build') + [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build') + [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') + [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip') + [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') + [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') + [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)') + [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') + [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') + [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format') + [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') + [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') + [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') + [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') + [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') + [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') + [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml') + [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') + [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') + [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') + [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json') + [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') + [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') + [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') + [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') + [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') break } 'x.py;suggest' { - [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') - [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') - [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') - [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build') - [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build') - [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') - [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip') - [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') - [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') - [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)') - [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') - [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') - [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format') - [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') - [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') - [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') - [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') - [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') - [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') - [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml') - [CompletionResult]::new('--run', 'run', [CompletionResultType]::ParameterName, 'run suggested tests') - [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') - [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') - [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') - [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json') - [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') - [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') - [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') - [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') - [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') - [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') + [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') + [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') + [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build') + [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build') + [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') + [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip') + [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') + [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') + [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)') + [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') + [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') + [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format') + [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') + [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') + [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') + [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') + [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') + [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') + [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml') + [CompletionResult]::new('--run', '--run', [CompletionResultType]::ParameterName, 'run suggested tests') + [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') + [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') + [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') + [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json') + [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') + [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') + [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') + [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') + [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') break } 'x.py;vendor' { - [CompletionResult]::new('--sync', 'sync', [CompletionResultType]::ParameterName, 'Additional `Cargo.toml` to sync and vendor') - [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') - [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') - [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') - [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build') - [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build') - [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') - [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip') - [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') - [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') - [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)') - [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') - [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') - [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format') - [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') - [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') - [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') - [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') - [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') - [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') - [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml') - [CompletionResult]::new('--versioned-dirs', 'versioned-dirs', [CompletionResultType]::ParameterName, 'Always include version in subdir name') - [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') - [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') - [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') - [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json') - [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') - [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') - [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') - [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') - [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') - [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--sync', '--sync', [CompletionResultType]::ParameterName, 'Additional `Cargo.toml` to sync and vendor') + [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') + [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') + [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') + [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build') + [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build') + [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') + [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip') + [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') + [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') + [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)') + [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') + [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') + [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format') + [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') + [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') + [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') + [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') + [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') + [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') + [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml') + [CompletionResult]::new('--versioned-dirs', '--versioned-dirs', [CompletionResultType]::ParameterName, 'Always include version in subdir name') + [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') + [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') + [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') + [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json') + [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') + [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') + [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') + [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') + [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') break } 'x.py;perf' { - [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') - [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') - [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') - [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build') - [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build') - [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') - [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip') - [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') - [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') - [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)') - [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') - [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') - [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') - [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') - [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format') - [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') - [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') - [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') - [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') - [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') - [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') - [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml') - [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') - [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') - [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') - [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') - [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') - [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json') - [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') - [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') - [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') - [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') - [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') - [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build') + [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`') + [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler') + [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build') + [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build') + [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude') + [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip') + [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format') + [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure') + [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)') + [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)') + [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout') + [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel') + [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour') + [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format') + [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output') + [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml') + [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build') + [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build') + [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build') + [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive') + [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml') + [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)') + [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation') + [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones') + [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything') + [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims') + [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json') + [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)') + [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc') + [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags') + [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation') + [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') + [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')') break } }) diff --git a/src/etc/completions/x.py.sh b/src/etc/completions/x.py.sh index 60ba8d3ba703..b1730e5c6d8e 100644 --- a/src/etc/completions/x.py.sh +++ b/src/etc/completions/x.py.sh @@ -12,56 +12,56 @@ _x.py() { ",$1") cmd="x.py" ;; - bootstrap,bench) - cmd="bootstrap__bench" + x.py,bench) + cmd="x.py__bench" ;; - bootstrap,build) - cmd="bootstrap__build" + x.py,build) + cmd="x.py__build" ;; - bootstrap,check) - cmd="bootstrap__check" + x.py,check) + cmd="x.py__check" ;; - bootstrap,clean) - cmd="bootstrap__clean" + x.py,clean) + cmd="x.py__clean" ;; - bootstrap,clippy) - cmd="bootstrap__clippy" + x.py,clippy) + cmd="x.py__clippy" ;; - bootstrap,dist) - cmd="bootstrap__dist" + x.py,dist) + cmd="x.py__dist" ;; - bootstrap,doc) - cmd="bootstrap__doc" + x.py,doc) + cmd="x.py__doc" ;; - bootstrap,fix) - cmd="bootstrap__fix" + x.py,fix) + cmd="x.py__fix" ;; - bootstrap,fmt) - cmd="bootstrap__fmt" + x.py,fmt) + cmd="x.py__fmt" ;; - bootstrap,install) - cmd="bootstrap__install" + x.py,install) + cmd="x.py__install" ;; - bootstrap,miri) - cmd="bootstrap__miri" + x.py,miri) + cmd="x.py__miri" ;; - bootstrap,perf) - cmd="bootstrap__perf" + x.py,perf) + cmd="x.py__perf" ;; - bootstrap,run) - cmd="bootstrap__run" + x.py,run) + cmd="x.py__run" ;; - bootstrap,setup) - cmd="bootstrap__setup" + x.py,setup) + cmd="x.py__setup" ;; - bootstrap,suggest) - cmd="bootstrap__suggest" + x.py,suggest) + cmd="x.py__suggest" ;; - bootstrap,test) - cmd="bootstrap__test" + x.py,test) + cmd="x.py__test" ;; - bootstrap,vendor) - cmd="bootstrap__vendor" + x.py,vendor) + cmd="x.py__vendor" ;; *) ;; @@ -77,23 +77,46 @@ _x.py() { fi case "${prev}" in --config) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --build-dir) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --build) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --host) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --target) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --exclude) @@ -106,6 +129,9 @@ _x.py() { ;; --rustc-error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --on-fail) @@ -114,26 +140,44 @@ _x.py() { ;; --stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage-std) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --src) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --jobs) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; -j) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --warnings) @@ -142,6 +186,9 @@ _x.py() { ;; --error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --color) @@ -153,15 +200,48 @@ _x.py() { return 0 ;; --rust-profile-generate) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --rust-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --llvm-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --reproducible-artifact) @@ -170,6 +250,9 @@ _x.py() { ;; --set) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; *) @@ -191,23 +274,46 @@ _x.py() { return 0 ;; --config) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --build-dir) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --build) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --host) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --target) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --exclude) @@ -220,6 +326,9 @@ _x.py() { ;; --rustc-error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --on-fail) @@ -228,26 +337,44 @@ _x.py() { ;; --stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage-std) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --src) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --jobs) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; -j) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --warnings) @@ -256,6 +383,9 @@ _x.py() { ;; --error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --color) @@ -267,15 +397,48 @@ _x.py() { return 0 ;; --rust-profile-generate) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --rust-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --llvm-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --reproducible-artifact) @@ -284,6 +447,9 @@ _x.py() { ;; --set) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; *) @@ -301,23 +467,46 @@ _x.py() { fi case "${prev}" in --config) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --build-dir) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --build) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --host) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --target) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --exclude) @@ -330,6 +519,9 @@ _x.py() { ;; --rustc-error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --on-fail) @@ -338,26 +530,44 @@ _x.py() { ;; --stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage-std) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --src) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --jobs) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; -j) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --warnings) @@ -366,6 +576,9 @@ _x.py() { ;; --error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --color) @@ -377,15 +590,48 @@ _x.py() { return 0 ;; --rust-profile-generate) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --rust-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --llvm-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --reproducible-artifact) @@ -394,6 +640,9 @@ _x.py() { ;; --set) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; *) @@ -411,23 +660,46 @@ _x.py() { fi case "${prev}" in --config) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --build-dir) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --build) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --host) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --target) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --exclude) @@ -440,6 +712,9 @@ _x.py() { ;; --rustc-error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --on-fail) @@ -448,26 +723,44 @@ _x.py() { ;; --stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage-std) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --src) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --jobs) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; -j) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --warnings) @@ -476,6 +769,9 @@ _x.py() { ;; --error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --color) @@ -487,15 +783,48 @@ _x.py() { return 0 ;; --rust-profile-generate) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --rust-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --llvm-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --reproducible-artifact) @@ -504,6 +833,9 @@ _x.py() { ;; --set) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; *) @@ -525,23 +857,46 @@ _x.py() { return 0 ;; --config) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --build-dir) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --build) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --host) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --target) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --exclude) @@ -554,6 +909,9 @@ _x.py() { ;; --rustc-error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --on-fail) @@ -562,22 +920,37 @@ _x.py() { ;; --keep-stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage-std) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --src) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --jobs) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; -j) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --warnings) @@ -586,6 +959,9 @@ _x.py() { ;; --error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --color) @@ -597,15 +973,48 @@ _x.py() { return 0 ;; --rust-profile-generate) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --rust-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --llvm-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --reproducible-artifact) @@ -614,6 +1023,9 @@ _x.py() { ;; --set) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; *) @@ -647,23 +1059,46 @@ _x.py() { return 0 ;; --config) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --build-dir) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --build) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --host) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --target) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --exclude) @@ -676,6 +1111,9 @@ _x.py() { ;; --rustc-error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --on-fail) @@ -684,26 +1122,44 @@ _x.py() { ;; --stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage-std) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --src) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --jobs) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; -j) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --warnings) @@ -712,6 +1168,9 @@ _x.py() { ;; --error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --color) @@ -723,15 +1182,48 @@ _x.py() { return 0 ;; --rust-profile-generate) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --rust-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --llvm-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --reproducible-artifact) @@ -740,6 +1232,9 @@ _x.py() { ;; --set) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; *) @@ -757,23 +1252,46 @@ _x.py() { fi case "${prev}" in --config) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --build-dir) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --build) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --host) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --target) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --exclude) @@ -786,6 +1304,9 @@ _x.py() { ;; --rustc-error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --on-fail) @@ -794,26 +1315,44 @@ _x.py() { ;; --stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage-std) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --src) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --jobs) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; -j) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --warnings) @@ -822,6 +1361,9 @@ _x.py() { ;; --error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --color) @@ -833,15 +1375,48 @@ _x.py() { return 0 ;; --rust-profile-generate) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --rust-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --llvm-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --reproducible-artifact) @@ -850,6 +1425,9 @@ _x.py() { ;; --set) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; *) @@ -867,23 +1445,46 @@ _x.py() { fi case "${prev}" in --config) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --build-dir) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --build) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --host) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --target) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --exclude) @@ -896,6 +1497,9 @@ _x.py() { ;; --rustc-error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --on-fail) @@ -904,26 +1508,44 @@ _x.py() { ;; --stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage-std) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --src) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --jobs) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; -j) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --warnings) @@ -932,6 +1554,9 @@ _x.py() { ;; --error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --color) @@ -943,15 +1568,48 @@ _x.py() { return 0 ;; --rust-profile-generate) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --rust-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --llvm-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --reproducible-artifact) @@ -960,6 +1618,9 @@ _x.py() { ;; --set) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; *) @@ -977,23 +1638,46 @@ _x.py() { fi case "${prev}" in --config) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --build-dir) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --build) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --host) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --target) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --exclude) @@ -1006,6 +1690,9 @@ _x.py() { ;; --rustc-error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --on-fail) @@ -1014,26 +1701,44 @@ _x.py() { ;; --stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage-std) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --src) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --jobs) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; -j) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --warnings) @@ -1042,6 +1747,9 @@ _x.py() { ;; --error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --color) @@ -1053,15 +1761,48 @@ _x.py() { return 0 ;; --rust-profile-generate) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --rust-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --llvm-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --reproducible-artifact) @@ -1070,6 +1811,9 @@ _x.py() { ;; --set) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; *) @@ -1087,23 +1831,46 @@ _x.py() { fi case "${prev}" in --config) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --build-dir) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --build) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --host) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --target) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --exclude) @@ -1116,6 +1883,9 @@ _x.py() { ;; --rustc-error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --on-fail) @@ -1124,26 +1894,44 @@ _x.py() { ;; --stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage-std) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --src) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --jobs) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; -j) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --warnings) @@ -1152,6 +1940,9 @@ _x.py() { ;; --error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --color) @@ -1163,15 +1954,48 @@ _x.py() { return 0 ;; --rust-profile-generate) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --rust-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --llvm-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --reproducible-artifact) @@ -1180,6 +2004,9 @@ _x.py() { ;; --set) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; *) @@ -1197,23 +2024,46 @@ _x.py() { fi case "${prev}" in --config) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --build-dir) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --build) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --host) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --target) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --exclude) @@ -1226,6 +2076,9 @@ _x.py() { ;; --rustc-error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --on-fail) @@ -1234,26 +2087,44 @@ _x.py() { ;; --stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage-std) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --src) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --jobs) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; -j) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --warnings) @@ -1262,6 +2133,9 @@ _x.py() { ;; --error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --color) @@ -1273,15 +2147,48 @@ _x.py() { return 0 ;; --rust-profile-generate) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --rust-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --llvm-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --reproducible-artifact) @@ -1290,6 +2197,9 @@ _x.py() { ;; --set) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; *) @@ -1311,23 +2221,46 @@ _x.py() { return 0 ;; --config) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --build-dir) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --build) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --host) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --target) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --exclude) @@ -1340,6 +2273,9 @@ _x.py() { ;; --rustc-error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --on-fail) @@ -1348,26 +2284,44 @@ _x.py() { ;; --stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage-std) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --src) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --jobs) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; -j) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --warnings) @@ -1376,6 +2330,9 @@ _x.py() { ;; --error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --color) @@ -1387,15 +2344,48 @@ _x.py() { return 0 ;; --rust-profile-generate) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --rust-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --llvm-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --reproducible-artifact) @@ -1404,6 +2394,9 @@ _x.py() { ;; --set) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; *) @@ -1421,23 +2414,46 @@ _x.py() { fi case "${prev}" in --config) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --build-dir) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --build) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --host) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --target) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --exclude) @@ -1450,6 +2466,9 @@ _x.py() { ;; --rustc-error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --on-fail) @@ -1458,26 +2477,44 @@ _x.py() { ;; --stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage-std) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --src) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --jobs) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; -j) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --warnings) @@ -1486,6 +2523,9 @@ _x.py() { ;; --error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --color) @@ -1497,15 +2537,48 @@ _x.py() { return 0 ;; --rust-profile-generate) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --rust-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --llvm-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --reproducible-artifact) @@ -1514,6 +2587,9 @@ _x.py() { ;; --set) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; *) @@ -1535,23 +2611,46 @@ _x.py() { return 0 ;; --config) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --build-dir) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --build) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --host) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --target) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --exclude) @@ -1564,6 +2663,9 @@ _x.py() { ;; --rustc-error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --on-fail) @@ -1572,26 +2674,44 @@ _x.py() { ;; --stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage-std) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --src) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --jobs) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; -j) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --warnings) @@ -1600,6 +2720,9 @@ _x.py() { ;; --error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --color) @@ -1611,15 +2734,48 @@ _x.py() { return 0 ;; --rust-profile-generate) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --rust-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --llvm-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --reproducible-artifact) @@ -1628,6 +2784,9 @@ _x.py() { ;; --set) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; *) @@ -1645,23 +2804,46 @@ _x.py() { fi case "${prev}" in --config) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --build-dir) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --build) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --host) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --target) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --exclude) @@ -1674,6 +2856,9 @@ _x.py() { ;; --rustc-error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --on-fail) @@ -1682,26 +2867,44 @@ _x.py() { ;; --stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage-std) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --src) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --jobs) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; -j) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --warnings) @@ -1710,6 +2913,9 @@ _x.py() { ;; --error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --color) @@ -1721,15 +2927,48 @@ _x.py() { return 0 ;; --rust-profile-generate) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --rust-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --llvm-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --reproducible-artifact) @@ -1738,6 +2977,9 @@ _x.py() { ;; --set) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; *) @@ -1755,23 +2997,46 @@ _x.py() { fi case "${prev}" in --config) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --build-dir) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --build) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --host) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --target) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --exclude) @@ -1784,6 +3049,9 @@ _x.py() { ;; --rustc-error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --on-fail) @@ -1792,26 +3060,44 @@ _x.py() { ;; --stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage-std) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --src) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --jobs) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; -j) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --warnings) @@ -1820,6 +3106,9 @@ _x.py() { ;; --error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --color) @@ -1831,15 +3120,48 @@ _x.py() { return 0 ;; --rust-profile-generate) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --rust-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --llvm-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --reproducible-artifact) @@ -1848,6 +3170,9 @@ _x.py() { ;; --set) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; *) @@ -1889,23 +3214,46 @@ _x.py() { return 0 ;; --config) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --build-dir) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --build) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --host) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --target) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --exclude) @@ -1918,6 +3266,9 @@ _x.py() { ;; --rustc-error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --on-fail) @@ -1926,26 +3277,44 @@ _x.py() { ;; --stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage-std) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --src) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --jobs) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; -j) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --warnings) @@ -1954,6 +3323,9 @@ _x.py() { ;; --error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --color) @@ -1965,15 +3337,48 @@ _x.py() { return 0 ;; --rust-profile-generate) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --rust-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --llvm-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --reproducible-artifact) @@ -1982,6 +3387,9 @@ _x.py() { ;; --set) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; *) @@ -2003,23 +3411,46 @@ _x.py() { return 0 ;; --config) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --build-dir) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --build) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --host) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --target) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --exclude) @@ -2032,6 +3463,9 @@ _x.py() { ;; --rustc-error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --on-fail) @@ -2040,26 +3474,44 @@ _x.py() { ;; --stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --keep-stage-std) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --src) - COMPREPLY=($(compgen -f "${cur}")) + COMPREPLY=() + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o plusdirs + fi return 0 ;; --jobs) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; -j) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --warnings) @@ -2068,6 +3520,9 @@ _x.py() { ;; --error-format) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; --color) @@ -2079,15 +3534,48 @@ _x.py() { return 0 ;; --rust-profile-generate) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --rust-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --llvm-profile-use) + local oldifs + if [ -n "${IFS+x}" ]; then + oldifs="$IFS" + fi + IFS=$'\n' COMPREPLY=($(compgen -f "${cur}")) + if [ -n "${oldifs+x}" ]; then + IFS="$oldifs" + fi + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o filenames + fi return 0 ;; --reproducible-artifact) @@ -2096,6 +3584,9 @@ _x.py() { ;; --set) COMPREPLY=("${cur}") + if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then + compopt -o nospace + fi return 0 ;; *) diff --git a/src/etc/completions/x.py.zsh b/src/etc/completions/x.py.zsh index 688f692da241..ae076b883450 100644 --- a/src/etc/completions/x.py.zsh +++ b/src/etc/completions/x.py.zsh @@ -14,7 +14,7 @@ _x.py() { fi local context curcontext="$curcontext" state line - _arguments "${_arguments_options[@]}" \ + _arguments "${_arguments_options[@]}" : \ '--config=[TOML configuration file for build]:FILE:_files' \ '--build-dir=[Build directory, overrides \`build.build-dir\` in \`config.toml\`]:DIR:_files -/' \ '--build=[build target of the stage0 compiler]:BUILD:( )' \ @@ -65,7 +65,7 @@ _x.py() { curcontext="${curcontext%:*:*}:x.py-command-$line[3]:" case $line[3] in (build) -_arguments "${_arguments_options[@]}" \ +_arguments "${_arguments_options[@]}" : \ '--config=[TOML configuration file for build]:FILE:_files' \ '--build-dir=[Build directory, overrides \`build.build-dir\` in \`config.toml\`]:DIR:_files -/' \ '--build=[build target of the stage0 compiler]:BUILD:( )' \ @@ -108,7 +108,7 @@ _arguments "${_arguments_options[@]}" \ && ret=0 ;; (check) -_arguments "${_arguments_options[@]}" \ +_arguments "${_arguments_options[@]}" : \ '--config=[TOML configuration file for build]:FILE:_files' \ '--build-dir=[Build directory, overrides \`build.build-dir\` in \`config.toml\`]:DIR:_files -/' \ '--build=[build target of the stage0 compiler]:BUILD:( )' \ @@ -152,7 +152,7 @@ _arguments "${_arguments_options[@]}" \ && ret=0 ;; (clippy) -_arguments "${_arguments_options[@]}" \ +_arguments "${_arguments_options[@]}" : \ '*-A+[clippy lints to allow]:LINT: ' \ '*-D+[clippy lints to deny]:LINT: ' \ '*-W+[clippy lints to warn on]:LINT: ' \ @@ -202,7 +202,7 @@ _arguments "${_arguments_options[@]}" \ && ret=0 ;; (fix) -_arguments "${_arguments_options[@]}" \ +_arguments "${_arguments_options[@]}" : \ '--config=[TOML configuration file for build]:FILE:_files' \ '--build-dir=[Build directory, overrides \`build.build-dir\` in \`config.toml\`]:DIR:_files -/' \ '--build=[build target of the stage0 compiler]:BUILD:( )' \ @@ -245,7 +245,7 @@ _arguments "${_arguments_options[@]}" \ && ret=0 ;; (fmt) -_arguments "${_arguments_options[@]}" \ +_arguments "${_arguments_options[@]}" : \ '--config=[TOML configuration file for build]:FILE:_files' \ '--build-dir=[Build directory, overrides \`build.build-dir\` in \`config.toml\`]:DIR:_files -/' \ '--build=[build target of the stage0 compiler]:BUILD:( )' \ @@ -290,7 +290,7 @@ _arguments "${_arguments_options[@]}" \ && ret=0 ;; (doc) -_arguments "${_arguments_options[@]}" \ +_arguments "${_arguments_options[@]}" : \ '--config=[TOML configuration file for build]:FILE:_files' \ '--build-dir=[Build directory, overrides \`build.build-dir\` in \`config.toml\`]:DIR:_files -/' \ '--build=[build target of the stage0 compiler]:BUILD:( )' \ @@ -335,7 +335,7 @@ _arguments "${_arguments_options[@]}" \ && ret=0 ;; (test) -_arguments "${_arguments_options[@]}" \ +_arguments "${_arguments_options[@]}" : \ '*--test-args=[extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)]:ARGS: ' \ '*--compiletest-rustc-args=[extra options to pass the compiler when running compiletest tests]:ARGS: ' \ '--extra-checks=[comma-separated list of other files types to check (accepts py, py\:lint, py\:fmt, shell)]:EXTRA_CHECKS: ' \ @@ -391,7 +391,7 @@ _arguments "${_arguments_options[@]}" \ && ret=0 ;; (miri) -_arguments "${_arguments_options[@]}" \ +_arguments "${_arguments_options[@]}" : \ '*--test-args=[extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)]:ARGS: ' \ '--config=[TOML configuration file for build]:FILE:_files' \ '--build-dir=[Build directory, overrides \`build.build-dir\` in \`config.toml\`]:DIR:_files -/' \ @@ -438,7 +438,7 @@ _arguments "${_arguments_options[@]}" \ && ret=0 ;; (bench) -_arguments "${_arguments_options[@]}" \ +_arguments "${_arguments_options[@]}" : \ '*--test-args=[]:TEST_ARGS: ' \ '--config=[TOML configuration file for build]:FILE:_files' \ '--build-dir=[Build directory, overrides \`build.build-dir\` in \`config.toml\`]:DIR:_files -/' \ @@ -482,7 +482,7 @@ _arguments "${_arguments_options[@]}" \ && ret=0 ;; (clean) -_arguments "${_arguments_options[@]}" \ +_arguments "${_arguments_options[@]}" : \ '--stage=[Clean a specific stage without touching other artifacts. By default, every stage is cleaned if this option is not used]:N: ' \ '--config=[TOML configuration file for build]:FILE:_files' \ '--build-dir=[Build directory, overrides \`build.build-dir\` in \`config.toml\`]:DIR:_files -/' \ @@ -526,7 +526,7 @@ _arguments "${_arguments_options[@]}" \ && ret=0 ;; (dist) -_arguments "${_arguments_options[@]}" \ +_arguments "${_arguments_options[@]}" : \ '--config=[TOML configuration file for build]:FILE:_files' \ '--build-dir=[Build directory, overrides \`build.build-dir\` in \`config.toml\`]:DIR:_files -/' \ '--build=[build target of the stage0 compiler]:BUILD:( )' \ @@ -569,7 +569,7 @@ _arguments "${_arguments_options[@]}" \ && ret=0 ;; (install) -_arguments "${_arguments_options[@]}" \ +_arguments "${_arguments_options[@]}" : \ '--config=[TOML configuration file for build]:FILE:_files' \ '--build-dir=[Build directory, overrides \`build.build-dir\` in \`config.toml\`]:DIR:_files -/' \ '--build=[build target of the stage0 compiler]:BUILD:( )' \ @@ -612,7 +612,7 @@ _arguments "${_arguments_options[@]}" \ && ret=0 ;; (run) -_arguments "${_arguments_options[@]}" \ +_arguments "${_arguments_options[@]}" : \ '*--args=[arguments for the tool]:ARGS: ' \ '--config=[TOML configuration file for build]:FILE:_files' \ '--build-dir=[Build directory, overrides \`build.build-dir\` in \`config.toml\`]:DIR:_files -/' \ @@ -656,7 +656,7 @@ _arguments "${_arguments_options[@]}" \ && ret=0 ;; (setup) -_arguments "${_arguments_options[@]}" \ +_arguments "${_arguments_options[@]}" : \ '--config=[TOML configuration file for build]:FILE:_files' \ '--build-dir=[Build directory, overrides \`build.build-dir\` in \`config.toml\`]:DIR:_files -/' \ '--build=[build target of the stage0 compiler]:BUILD:( )' \ @@ -700,7 +700,7 @@ _arguments "${_arguments_options[@]}" \ && ret=0 ;; (suggest) -_arguments "${_arguments_options[@]}" \ +_arguments "${_arguments_options[@]}" : \ '--config=[TOML configuration file for build]:FILE:_files' \ '--build-dir=[Build directory, overrides \`build.build-dir\` in \`config.toml\`]:DIR:_files -/' \ '--build=[build target of the stage0 compiler]:BUILD:( )' \ @@ -744,7 +744,7 @@ _arguments "${_arguments_options[@]}" \ && ret=0 ;; (vendor) -_arguments "${_arguments_options[@]}" \ +_arguments "${_arguments_options[@]}" : \ '*--sync=[Additional \`Cargo.toml\` to sync and vendor]:SYNC:_files' \ '--config=[TOML configuration file for build]:FILE:_files' \ '--build-dir=[Build directory, overrides \`build.build-dir\` in \`config.toml\`]:DIR:_files -/' \ @@ -789,7 +789,7 @@ _arguments "${_arguments_options[@]}" \ && ret=0 ;; (perf) -_arguments "${_arguments_options[@]}" \ +_arguments "${_arguments_options[@]}" : \ '--config=[TOML configuration file for build]:FILE:_files' \ '--build-dir=[Build directory, overrides \`build.build-dir\` in \`config.toml\`]:DIR:_files -/' \ '--build=[build target of the stage0 compiler]:BUILD:( )' \ From 5365b05fc9160f55c2729c2bf32030bbe92adc3b Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Mon, 19 Aug 2024 09:26:25 +0200 Subject: [PATCH 77/79] library: bump libc dependency --- library/Cargo.lock | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/library/Cargo.lock b/library/Cargo.lock index 815f5bb1385b..30f5076e1e22 100644 --- a/library/Cargo.lock +++ b/library/Cargo.lock @@ -155,9 +155,9 @@ dependencies = [ [[package]] name = "libc" -version = "0.2.155" +version = "0.2.158" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c" +checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439" dependencies = [ "rustc-std-workspace-core", ] From 2bf24559252f9e4a186ea6227827c0c7c417471a Mon Sep 17 00:00:00 2001 From: Felix Rath Date: Mon, 12 Aug 2024 03:16:39 +0200 Subject: [PATCH 78/79] Prevent double panic in query system, improve diagnostics --- compiler/rustc_query_impl/src/plumbing.rs | 10 ++++++++-- compiler/rustc_query_system/src/query/plumbing.rs | 11 +++++++++-- 2 files changed, 17 insertions(+), 4 deletions(-) diff --git a/compiler/rustc_query_impl/src/plumbing.rs b/compiler/rustc_query_impl/src/plumbing.rs index b9e700c1938f..c064b2bd6c16 100644 --- a/compiler/rustc_query_impl/src/plumbing.rs +++ b/compiler/rustc_query_impl/src/plumbing.rs @@ -702,11 +702,17 @@ macro_rules! define_queries { let name = stringify!($name); $crate::plumbing::create_query_frame(tcx, rustc_middle::query::descs::$name, key, kind, name) }; - tcx.query_system.states.$name.try_collect_active_jobs( + let res = tcx.query_system.states.$name.try_collect_active_jobs( tcx, make_query, qmap, - ).unwrap(); + ); + // this can be called during unwinding, and the function has a `try_`-prefix, so + // don't `unwrap()` here, just manually check for `None` and do best-effort error + // reporting. + if res.is_none() { + tracing::warn!("Failed to collect active jobs for query with name `{}`!", stringify!($name)); + } } pub fn alloc_self_profile_query_strings<'tcx>(tcx: TyCtxt<'tcx>, string_cache: &mut QueryKeyStringCache) { diff --git a/compiler/rustc_query_system/src/query/plumbing.rs b/compiler/rustc_query_system/src/query/plumbing.rs index 8ef680cdb6c8..6dbd6e89fe98 100644 --- a/compiler/rustc_query_system/src/query/plumbing.rs +++ b/compiler/rustc_query_system/src/query/plumbing.rs @@ -181,8 +181,15 @@ where cache.complete(key, result, dep_node_index); let job = { - let mut lock = state.active.lock_shard_by_value(&key); - lock.remove(&key).unwrap().expect_job() + let val = { + // don't keep the lock during the `unwrap()` of the retrieved value, or we taint the + // underlying shard. + // since unwinding also wants to look at this map, this can also prevent a double + // panic. + let mut lock = state.active.lock_shard_by_value(&key); + lock.remove(&key) + }; + val.unwrap().expect_job() }; job.signal_complete(); From e5072f0e51fc9dcaf59e9902fdc11ef3cb1f6c67 Mon Sep 17 00:00:00 2001 From: The Miri Cronjob Bot Date: Tue, 20 Aug 2024 05:00:55 +0000 Subject: [PATCH 79/79] Preparing for merge from rustc --- src/tools/miri/rust-version | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/tools/miri/rust-version b/src/tools/miri/rust-version index c3f4f4b5d822..1eca86baeaa2 100644 --- a/src/tools/miri/rust-version +++ b/src/tools/miri/rust-version @@ -1 +1 @@ -f24a6ba06f4190d8ec4f22d1baa800e64b1900cb +fdf61d499c8a8421ecf98e7924bb87caf43a9938