diff --git a/src/bootstrap/test.rs b/src/bootstrap/test.rs index 77bcc00d75b2b..312532558090e 100644 --- a/src/bootstrap/test.rs +++ b/src/bootstrap/test.rs @@ -397,8 +397,6 @@ impl Step for Miri { cargo.env("MIRI", &miri); // Debug things. cargo.env("RUST_BACKTRACE", "1"); - // Overwrite bootstrap's `rustc` wrapper overwriting our flags. - cargo.env("RUSTC_DEBUG_ASSERTIONS", "true"); // Let cargo-miri know where xargo ended up. cargo.env("XARGO_CHECK", builder.out.join("bin").join("xargo-check")); diff --git a/src/liballoc/rc.rs b/src/liballoc/rc.rs index fccdfa0dca92a..77ff567aa7af1 100644 --- a/src/liballoc/rc.rs +++ b/src/liballoc/rc.rs @@ -1701,7 +1701,7 @@ impl Weak { /// ``` /// /// [`null`]: ../../std/ptr/fn.null.html - #[stable(feature = "weak_into_raw", since = "1.45.0")] + #[stable(feature = "rc_as_ptr", since = "1.45.0")] pub fn as_ptr(&self) -> *const T { let ptr: *mut RcBox = NonNull::as_ptr(self.ptr); diff --git a/src/liballoc/sync.rs b/src/liballoc/sync.rs index 2d6a3917c764e..0053a54f20346 100644 --- a/src/liballoc/sync.rs +++ b/src/liballoc/sync.rs @@ -587,7 +587,7 @@ impl Arc { /// assert_eq!(x_ptr, Arc::as_ptr(&y)); /// assert_eq!(unsafe { &*x_ptr }, "hello"); /// ``` - #[stable(feature = "weak_into_raw", since = "1.45.0")] + #[stable(feature = "rc_as_ptr", since = "1.45.0")] pub fn as_ptr(this: &Self) -> *const T { let ptr: *mut ArcInner = NonNull::as_ptr(this.ptr); diff --git a/src/librustc_builtin_macros/format.rs b/src/librustc_builtin_macros/format.rs index 4cc83f8e31c20..2becbe2f6758a 100644 --- a/src/librustc_builtin_macros/format.rs +++ b/src/librustc_builtin_macros/format.rs @@ -280,6 +280,8 @@ impl<'a, 'b> Context<'a, 'b> { ("x", "LowerHex"), ("X", "UpperHex"), ] { + // FIXME: rustfix (`run-rustfix`) fails to apply suggestions. + // > "Cannot replace slice of data that was already replaced" err.tool_only_span_suggestion( sp, &format!("use the `{}` trait", name), diff --git a/src/librustc_mir_build/build/misc.rs b/src/librustc_mir_build/build/misc.rs index e8933ff8aa749..29651d9bc663a 100644 --- a/src/librustc_mir_build/build/misc.rs +++ b/src/librustc_mir_build/build/misc.rs @@ -15,7 +15,9 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { /// N.B., **No cleanup is scheduled for this temporary.** You should /// call `schedule_drop` once the temporary is initialized. crate fn temp(&mut self, ty: Ty<'tcx>, span: Span) -> Place<'tcx> { - let temp = self.local_decls.push(LocalDecl::new(ty, span)); + // Mark this local as internal to avoid temporaries with types not present in the + // user's code resulting in ICEs from the generator transform. + let temp = self.local_decls.push(LocalDecl::new(ty, span).internal()); let place = Place::from(temp); debug!("temp: created temp {:?} with type {:?}", place, self.local_decls[temp].ty); place diff --git a/src/librustc_parse/parser/diagnostics.rs b/src/librustc_parse/parser/diagnostics.rs index 16a118cb48c91..7822c09739049 100644 --- a/src/librustc_parse/parser/diagnostics.rs +++ b/src/librustc_parse/parser/diagnostics.rs @@ -1228,10 +1228,13 @@ impl<'a> Parser<'a> { if let Some(sp) = unmatched.unclosed_span { err.span_label(sp, "unclosed delimiter"); } + // Backticks should be removed to apply suggestions. + let mut delim = delim.to_string(); + delim.retain(|c| c != '`'); err.span_suggestion_short( self.prev_token.span.shrink_to_hi(), - &format!("{} may belong here", delim.to_string()), - delim.to_string(), + &format!("`{}` may belong here", delim), + delim, Applicability::MaybeIncorrect, ); if unmatched.found_delim.is_none() { diff --git a/src/librustc_parse/parser/mod.rs b/src/librustc_parse/parser/mod.rs index 7811d5fb741b2..61c680469f03c 100644 --- a/src/librustc_parse/parser/mod.rs +++ b/src/librustc_parse/parser/mod.rs @@ -699,7 +699,7 @@ impl<'a> Parser<'a> { // misses a separator. expect_err .span_suggestion_short( - sp, + self.sess.source_map().next_point(sp), &format!("missing `{}`", token_str), token_str, Applicability::MaybeIncorrect, diff --git a/src/librustdoc/html/static/rustdoc.css b/src/librustdoc/html/static/rustdoc.css index 9c6dd25394db0..a3f4dc55fe757 100644 --- a/src/librustdoc/html/static/rustdoc.css +++ b/src/librustdoc/html/static/rustdoc.css @@ -100,6 +100,9 @@ h1.fqn { border-bottom: 1px dashed; margin-top: 0; } +h1.fqn > .in-band > a:hover { + text-decoration: underline; +} h2, h3:not(.impl):not(.method):not(.type):not(.tymethod), h4:not(.method):not(.type):not(.tymethod):not(.associatedconstant) { border-bottom: 1px solid; } diff --git a/src/librustdoc/passes/collect_intra_doc_links.rs b/src/librustdoc/passes/collect_intra_doc_links.rs index 8da74f375d9ce..41a94dad0344d 100644 --- a/src/librustdoc/passes/collect_intra_doc_links.rs +++ b/src/librustdoc/passes/collect_intra_doc_links.rs @@ -164,6 +164,7 @@ impl<'a, 'tcx> LinkCollector<'a, 'tcx> { fn resolve( &self, path_str: &str, + disambiguator: Option<&str>, ns: Namespace, current_item: &Option, parent_id: Option, @@ -203,11 +204,22 @@ impl<'a, 'tcx> LinkCollector<'a, 'tcx> { } return Ok((res, Some(path_str.to_owned()))); } - other => { - debug!( - "failed to resolve {} in namespace {:?} (got {:?})", - path_str, ns, other - ); + Res::Def(DefKind::Mod, _) => { + // This resolved to a module, but if we were passed `type@`, + // we want primitive types to take precedence instead. + if disambiguator == Some("type") { + if let Some(prim) = is_primitive(path_str, ns) { + if extra_fragment.is_some() { + return Err(ErrorKind::AnchorFailure( + "primitive types cannot be followed by anchors", + )); + } + return Ok((prim, Some(path_str.to_owned()))); + } + } + return Ok((res, extra_fragment.clone())); + } + _ => { return Ok((res, extra_fragment.clone())); } }; @@ -566,11 +578,13 @@ impl<'a, 'tcx> DocFolder for LinkCollector<'a, 'tcx> { let mut path_str; let (res, fragment) = { let mut kind = None; + let mut disambiguator = None; path_str = if let Some(prefix) = ["struct@", "enum@", "type@", "trait@", "union@"] .iter() .find(|p| link.starts_with(**p)) { kind = Some(TypeNS); + disambiguator = Some(&prefix[..prefix.len() - 1]); link.trim_start_matches(prefix) } else if let Some(prefix) = [ "const@", @@ -586,18 +600,23 @@ impl<'a, 'tcx> DocFolder for LinkCollector<'a, 'tcx> { .find(|p| link.starts_with(**p)) { kind = Some(ValueNS); + disambiguator = Some(&prefix[..prefix.len() - 1]); link.trim_start_matches(prefix) } else if link.ends_with("()") { kind = Some(ValueNS); + disambiguator = Some("fn"); link.trim_end_matches("()") } else if link.starts_with("macro@") { kind = Some(MacroNS); + disambiguator = Some("macro"); link.trim_start_matches("macro@") } else if link.starts_with("derive@") { kind = Some(MacroNS); + disambiguator = Some("derive"); link.trim_start_matches("derive@") } else if link.ends_with('!') { kind = Some(MacroNS); + disambiguator = Some("macro"); link.trim_end_matches('!') } else { &link[..] @@ -634,6 +653,7 @@ impl<'a, 'tcx> DocFolder for LinkCollector<'a, 'tcx> { Some(ns @ ValueNS) => { match self.resolve( path_str, + disambiguator, ns, ¤t_item, base_node, @@ -657,6 +677,7 @@ impl<'a, 'tcx> DocFolder for LinkCollector<'a, 'tcx> { Some(ns @ TypeNS) => { match self.resolve( path_str, + disambiguator, ns, ¤t_item, base_node, @@ -683,6 +704,7 @@ impl<'a, 'tcx> DocFolder for LinkCollector<'a, 'tcx> { .map(|res| (res, extra_fragment.clone())), type_ns: match self.resolve( path_str, + disambiguator, TypeNS, ¤t_item, base_node, @@ -697,6 +719,7 @@ impl<'a, 'tcx> DocFolder for LinkCollector<'a, 'tcx> { }, value_ns: match self.resolve( path_str, + disambiguator, ValueNS, ¤t_item, base_node, diff --git a/src/libstd/net/tcp.rs b/src/libstd/net/tcp.rs index 9ac54dd5f7a65..47b8532b7a6e6 100644 --- a/src/libstd/net/tcp.rs +++ b/src/libstd/net/tcp.rs @@ -1,3 +1,4 @@ +#![deny(unsafe_op_in_unsafe_fn)] use crate::io::prelude::*; use crate::fmt; @@ -583,7 +584,8 @@ impl Read for TcpStream { #[inline] unsafe fn initializer(&self) -> Initializer { - Initializer::nop() + // SAFETY: Read is guaranteed to work on uninitialized memory + unsafe { Initializer::nop() } } } #[stable(feature = "rust1", since = "1.0.0")] @@ -622,7 +624,8 @@ impl Read for &TcpStream { #[inline] unsafe fn initializer(&self) -> Initializer { - Initializer::nop() + // SAFETY: Read is guaranteed to work on uninitialized memory + unsafe { Initializer::nop() } } } #[stable(feature = "rust1", since = "1.0.0")] diff --git a/src/libstd/sys/unix/args.rs b/src/libstd/sys/unix/args.rs index 773fab36be221..5b712e2024232 100644 --- a/src/libstd/sys/unix/args.rs +++ b/src/libstd/sys/unix/args.rs @@ -78,19 +78,20 @@ mod imp { use crate::marker::PhantomData; use crate::os::unix::prelude::*; use crate::ptr; + use crate::sync::atomic::{AtomicIsize, AtomicPtr, Ordering}; use crate::sys_common::mutex::Mutex; - static mut ARGC: isize = 0; - static mut ARGV: *const *const u8 = ptr::null(); + static ARGC: AtomicIsize = AtomicIsize::new(0); + static ARGV: AtomicPtr<*const u8> = AtomicPtr::new(ptr::null_mut()); // We never call `ENV_LOCK.init()`, so it is UB to attempt to // acquire this mutex reentrantly! static LOCK: Mutex = Mutex::new(); unsafe fn really_init(argc: isize, argv: *const *const u8) { let _guard = LOCK.lock(); - ARGC = argc; - ARGV = argv; + ARGC.store(argc, Ordering::Relaxed); + ARGV.store(argv as *mut _, Ordering::Relaxed); } #[inline(always)] @@ -126,8 +127,8 @@ mod imp { pub unsafe fn cleanup() { let _guard = LOCK.lock(); - ARGC = 0; - ARGV = ptr::null(); + ARGC.store(0, Ordering::Relaxed); + ARGV.store(ptr::null_mut(), Ordering::Relaxed); } pub fn args() -> Args { @@ -137,9 +138,11 @@ mod imp { fn clone() -> Vec { unsafe { let _guard = LOCK.lock(); - (0..ARGC) + let argc = ARGC.load(Ordering::Relaxed); + let argv = ARGV.load(Ordering::Relaxed); + (0..argc) .map(|i| { - let cstr = CStr::from_ptr(*ARGV.offset(i) as *const libc::c_char); + let cstr = CStr::from_ptr(*argv.offset(i) as *const libc::c_char); OsStringExt::from_vec(cstr.to_bytes().to_vec()) }) .collect() diff --git a/src/libstd/sys/unix/stack_overflow.rs b/src/libstd/sys/unix/stack_overflow.rs index 5e10357835056..c74fc2b590316 100644 --- a/src/libstd/sys/unix/stack_overflow.rs +++ b/src/libstd/sys/unix/stack_overflow.rs @@ -48,6 +48,7 @@ mod imp { use libc::{sigaltstack, SIGSTKSZ, SS_DISABLE}; use libc::{MAP_ANON, MAP_PRIVATE, PROT_NONE, PROT_READ, PROT_WRITE, SIGSEGV}; + use crate::sync::atomic::{AtomicBool, AtomicPtr, Ordering}; use crate::sys::unix::os::page_size; use crate::sys_common::thread_info; @@ -113,8 +114,8 @@ mod imp { } } - static mut MAIN_ALTSTACK: *mut libc::c_void = ptr::null_mut(); - static mut NEED_ALTSTACK: bool = false; + static MAIN_ALTSTACK: AtomicPtr = AtomicPtr::new(ptr::null_mut()); + static NEED_ALTSTACK: AtomicBool = AtomicBool::new(false); pub unsafe fn init() { let mut action: sigaction = mem::zeroed(); @@ -125,17 +126,17 @@ mod imp { action.sa_flags = SA_SIGINFO | SA_ONSTACK; action.sa_sigaction = signal_handler as sighandler_t; sigaction(signal, &action, ptr::null_mut()); - NEED_ALTSTACK = true; + NEED_ALTSTACK.store(true, Ordering::Relaxed); } } let handler = make_handler(); - MAIN_ALTSTACK = handler._data; + MAIN_ALTSTACK.store(handler._data, Ordering::Relaxed); mem::forget(handler); } pub unsafe fn cleanup() { - Handler { _data: MAIN_ALTSTACK }; + Handler { _data: MAIN_ALTSTACK.load(Ordering::Relaxed) }; } unsafe fn get_stackp() -> *mut libc::c_void { @@ -176,7 +177,7 @@ mod imp { } pub unsafe fn make_handler() -> Handler { - if !NEED_ALTSTACK { + if !NEED_ALTSTACK.load(Ordering::Relaxed) { return Handler::null(); } let mut stack = mem::zeroed(); diff --git a/src/libstd/sys/unix/thread.rs b/src/libstd/sys/unix/thread.rs index 7b3d69dcaa015..f5fabc01e2219 100644 --- a/src/libstd/sys/unix/thread.rs +++ b/src/libstd/sys/unix/thread.rs @@ -246,10 +246,11 @@ pub mod guard { use libc::{MAP_ANON, MAP_FAILED, MAP_FIXED, MAP_PRIVATE, PROT_NONE, PROT_READ, PROT_WRITE}; use crate::ops::Range; + use crate::sync::atomic::{AtomicUsize, Ordering}; use crate::sys::os; // This is initialized in init() and only read from after - static mut PAGE_SIZE: usize = 0; + static PAGE_SIZE: AtomicUsize = AtomicUsize::new(0); pub type Guard = Range; @@ -310,7 +311,8 @@ pub mod guard { // Precondition: PAGE_SIZE is initialized. unsafe fn get_stack_start_aligned() -> Option<*mut libc::c_void> { - assert!(PAGE_SIZE != 0); + let page_size = PAGE_SIZE.load(Ordering::Relaxed); + assert!(page_size != 0); let stackaddr = get_stack_start()?; // Ensure stackaddr is page aligned! A parent process might @@ -319,16 +321,17 @@ pub mod guard { // stackaddr < stackaddr + stacksize, so if stackaddr is not // page-aligned, calculate the fix such that stackaddr < // new_page_aligned_stackaddr < stackaddr + stacksize - let remainder = (stackaddr as usize) % PAGE_SIZE; + let remainder = (stackaddr as usize) % page_size; Some(if remainder == 0 { stackaddr } else { - ((stackaddr as usize) + PAGE_SIZE - remainder) as *mut libc::c_void + ((stackaddr as usize) + page_size - remainder) as *mut libc::c_void }) } pub unsafe fn init() -> Option { - PAGE_SIZE = os::page_size(); + let page_size = os::page_size(); + PAGE_SIZE.store(page_size, Ordering::Relaxed); let stackaddr = get_stack_start_aligned()?; @@ -344,7 +347,7 @@ pub mod guard { // faulting, so our handler can report "stack overflow", and // trust that the kernel's own stack guard will work. let stackaddr = stackaddr as usize; - Some(stackaddr - PAGE_SIZE..stackaddr) + Some(stackaddr - page_size..stackaddr) } else { // Reallocate the last page of the stack. // This ensures SIGBUS will be raised on @@ -356,7 +359,7 @@ pub mod guard { // no permissions at all. See issue #50313. let result = mmap( stackaddr, - PAGE_SIZE, + page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON | MAP_FIXED, -1, @@ -366,7 +369,7 @@ pub mod guard { panic!("failed to allocate a guard page"); } - let result = mprotect(stackaddr, PAGE_SIZE, PROT_NONE); + let result = mprotect(stackaddr, page_size, PROT_NONE); if result != 0 { panic!("failed to protect the guard page"); } @@ -374,7 +377,7 @@ pub mod guard { let guardaddr = stackaddr as usize; let offset = if cfg!(target_os = "freebsd") { 2 } else { 1 }; - Some(guardaddr..guardaddr + offset * PAGE_SIZE) + Some(guardaddr..guardaddr + offset * page_size) } } @@ -413,7 +416,7 @@ pub mod guard { ret = if cfg!(target_os = "freebsd") { // FIXME does freebsd really fault *below* the guard addr? let guardaddr = stackaddr - guardsize; - Some(guardaddr - PAGE_SIZE..guardaddr) + Some(guardaddr - PAGE_SIZE.load(Ordering::Relaxed)..guardaddr) } else if cfg!(target_os = "netbsd") { Some(stackaddr - guardsize..stackaddr) } else if cfg!(all(target_os = "linux", target_env = "gnu")) { diff --git a/src/libstd/sys/wasi/ext/fs.rs b/src/libstd/sys/wasi/ext/fs.rs index 6696efa8871c2..10ea4fd34bda3 100644 --- a/src/libstd/sys/wasi/ext/fs.rs +++ b/src/libstd/sys/wasi/ext/fs.rs @@ -27,6 +27,58 @@ pub trait FileExt { /// [`File::read`]: ../../../../std/fs/struct.File.html#method.read_vectored fn read_at(&self, bufs: &mut [IoSliceMut<'_>], offset: u64) -> io::Result; + /// Reads the exact number of byte required to fill `buf` from the given offset. + /// + /// The offset is relative to the start of the file and thus independent + /// from the current cursor. + /// + /// The current file cursor is not affected by this function. + /// + /// Similar to [`Read::read_exact`] but uses [`read_at`] instead of `read`. + /// + /// [`Read::read_exact`]: ../../../../std/io/trait.Read.html#method.read_exact + /// [`read_at`]: #tymethod.read_at + /// + /// # Errors + /// + /// If this function encounters an error of the kind + /// [`ErrorKind::Interrupted`] then the error is ignored and the operation + /// will continue. + /// + /// If this function encounters an "end of file" before completely filling + /// the buffer, it returns an error of the kind [`ErrorKind::UnexpectedEof`]. + /// The contents of `buf` are unspecified in this case. + /// + /// If any other read error is encountered then this function immediately + /// returns. The contents of `buf` are unspecified in this case. + /// + /// If this function returns an error, it is unspecified how many bytes it + /// has read, but it will never read more than would be necessary to + /// completely fill the buffer. + /// + /// [`ErrorKind::Interrupted`]: ../../../../std/io/enum.ErrorKind.html#variant.Interrupted + /// [`ErrorKind::UnexpectedEof`]: ../../../../std/io/enum.ErrorKind.html#variant.UnexpectedEof + #[stable(feature = "rw_exact_all_at", since = "1.33.0")] + fn read_exact_at(&self, mut buf: &mut [u8], mut offset: u64) -> io::Result<()> { + while !buf.is_empty() { + match self.read_at(buf, offset) { + Ok(0) => break, + Ok(n) => { + let tmp = buf; + buf = &mut tmp[n..]; + offset += n as u64; + } + Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {} + Err(e) => return Err(e), + } + } + if !buf.is_empty() { + Err(io::Error::new(io::ErrorKind::UnexpectedEof, "failed to fill whole buffer")) + } else { + Ok(()) + } + } + /// Writes a number of bytes starting from a given offset. /// /// Returns the number of bytes written. @@ -45,6 +97,48 @@ pub trait FileExt { /// [`File::write`]: ../../../../std/fs/struct.File.html#method.write_vectored fn write_at(&self, bufs: &[IoSlice<'_>], offset: u64) -> io::Result; + /// Attempts to write an entire buffer starting from a given offset. + /// + /// The offset is relative to the start of the file and thus independent + /// from the current cursor. + /// + /// The current file cursor is not affected by this function. + /// + /// This method will continuously call [`write_at`] until there is no more data + /// to be written or an error of non-[`ErrorKind::Interrupted`] kind is + /// returned. This method will not return until the entire buffer has been + /// successfully written or such an error occurs. The first error that is + /// not of [`ErrorKind::Interrupted`] kind generated from this method will be + /// returned. + /// + /// # Errors + /// + /// This function will return the first error of + /// non-[`ErrorKind::Interrupted`] kind that [`write_at`] returns. + /// + /// [`ErrorKind::Interrupted`]: ../../../../std/io/enum.ErrorKind.html#variant.Interrupted + /// [`write_at`]: #tymethod.write_at + #[stable(feature = "rw_exact_all_at", since = "1.33.0")] + fn write_all_at(&self, mut buf: &[u8], mut offset: u64) -> io::Result<()> { + while !buf.is_empty() { + match self.write_at(buf, offset) { + Ok(0) => { + return Err(io::Error::new( + io::ErrorKind::WriteZero, + "failed to write whole buffer", + )); + } + Ok(n) => { + buf = &buf[n..]; + offset += n as u64 + } + Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {} + Err(e) => return Err(e), + } + } + Ok(()) + } + /// Returns the current position within the file. /// /// This corresponds to the `fd_tell` syscall and is similar to diff --git a/src/libstd/sys/windows/ext/fs.rs b/src/libstd/sys/windows/ext/fs.rs index f85120d170f73..81b2bf9987200 100644 --- a/src/libstd/sys/windows/ext/fs.rs +++ b/src/libstd/sys/windows/ext/fs.rs @@ -259,7 +259,7 @@ pub trait OpenOptionsExt { /// [Impersonation Levels]: /// https://docs.microsoft.com/en-us/windows/win32/api/winnt/ne-winnt-security_impersonation_level #[stable(feature = "open_options_ext", since = "1.10.0")] - fn security_qos_flags(&mut self, flags: u32) -> &mut OpenOptions; + fn security_qos_flags(&mut self, flags: u32) -> &mut Self; } #[stable(feature = "open_options_ext", since = "1.10.0")] diff --git a/src/test/rustdoc/intra-link-prim-precedence.rs b/src/test/rustdoc/intra-link-prim-precedence.rs new file mode 100644 index 0000000000000..ca83d5e2281a7 --- /dev/null +++ b/src/test/rustdoc/intra-link-prim-precedence.rs @@ -0,0 +1,12 @@ +// ignore-tidy-linelength +#![deny(intra_doc_resolution_failure)] + +pub mod char {} + +/// See also [type@char] +// @has intra_link_prim_precedence/struct.MyString.html '//a/@href' 'https://doc.rust-lang.org/nightly/std/primitive.char.html' +pub struct MyString; + +/// See also [char] +// @has intra_link_prim_precedence/struct.MyString2.html '//a/@href' 'intra_link_prim_precedence/char/index.html' +pub struct MyString2; diff --git a/src/test/ui/block-expression-remove-semicolon.fixed b/src/test/ui/block-expression-remove-semicolon.fixed new file mode 100644 index 0000000000000..5629d4b6e6e5f --- /dev/null +++ b/src/test/ui/block-expression-remove-semicolon.fixed @@ -0,0 +1,12 @@ +// run-rustfix + +fn foo() -> i32 { + 0 +} + +fn main() { + let _x: i32 = { + //~^ ERROR mismatched types + foo() //~ HELP consider removing this semicolon + }; +} diff --git a/src/test/ui/block-expression-remove-semicolon.rs b/src/test/ui/block-expression-remove-semicolon.rs index afa10b38b9144..33f11b50afca2 100644 --- a/src/test/ui/block-expression-remove-semicolon.rs +++ b/src/test/ui/block-expression-remove-semicolon.rs @@ -1,9 +1,11 @@ +// run-rustfix + fn foo() -> i32 { - 0 + 0 } fn main() { - let x: i32 = { + let _x: i32 = { //~^ ERROR mismatched types foo(); //~ HELP consider removing this semicolon }; diff --git a/src/test/ui/block-expression-remove-semicolon.stderr b/src/test/ui/block-expression-remove-semicolon.stderr index e39cd04f81b3c..74dc4d595a929 100644 --- a/src/test/ui/block-expression-remove-semicolon.stderr +++ b/src/test/ui/block-expression-remove-semicolon.stderr @@ -1,8 +1,8 @@ error[E0308]: mismatched types - --> $DIR/block-expression-remove-semicolon.rs:6:18 + --> $DIR/block-expression-remove-semicolon.rs:8:19 | -LL | let x: i32 = { - | __________________^ +LL | let _x: i32 = { + | ___________________^ LL | | LL | | foo(); | | - help: consider removing this semicolon diff --git a/src/test/ui/block-result/consider-removing-last-semi.fixed b/src/test/ui/block-result/consider-removing-last-semi.fixed new file mode 100644 index 0000000000000..a2ecb73ac5b28 --- /dev/null +++ b/src/test/ui/block-result/consider-removing-last-semi.fixed @@ -0,0 +1,13 @@ +// run-rustfix + +pub fn f() -> String { //~ ERROR mismatched types + 0u8; + "bla".to_string() +} + +pub fn g() -> String { //~ ERROR mismatched types + "this won't work".to_string(); + "removeme".to_string() +} + +fn main() {} diff --git a/src/test/ui/block-result/consider-removing-last-semi.rs b/src/test/ui/block-result/consider-removing-last-semi.rs index f8cdccba27e20..4991d24b26cce 100644 --- a/src/test/ui/block-result/consider-removing-last-semi.rs +++ b/src/test/ui/block-result/consider-removing-last-semi.rs @@ -1,9 +1,11 @@ -fn f() -> String { //~ ERROR mismatched types +// run-rustfix + +pub fn f() -> String { //~ ERROR mismatched types 0u8; "bla".to_string(); } -fn g() -> String { //~ ERROR mismatched types +pub fn g() -> String { //~ ERROR mismatched types "this won't work".to_string(); "removeme".to_string(); } diff --git a/src/test/ui/block-result/consider-removing-last-semi.stderr b/src/test/ui/block-result/consider-removing-last-semi.stderr index b45f2a6282136..15ca8316708a2 100644 --- a/src/test/ui/block-result/consider-removing-last-semi.stderr +++ b/src/test/ui/block-result/consider-removing-last-semi.stderr @@ -1,21 +1,21 @@ error[E0308]: mismatched types - --> $DIR/consider-removing-last-semi.rs:1:11 + --> $DIR/consider-removing-last-semi.rs:3:15 | -LL | fn f() -> String { - | - ^^^^^^ expected struct `std::string::String`, found `()` - | | - | implicitly returns `()` as its body has no tail or `return` expression +LL | pub fn f() -> String { + | - ^^^^^^ expected struct `std::string::String`, found `()` + | | + | implicitly returns `()` as its body has no tail or `return` expression LL | 0u8; LL | "bla".to_string(); | - help: consider removing this semicolon error[E0308]: mismatched types - --> $DIR/consider-removing-last-semi.rs:6:11 + --> $DIR/consider-removing-last-semi.rs:8:15 | -LL | fn g() -> String { - | - ^^^^^^ expected struct `std::string::String`, found `()` - | | - | implicitly returns `()` as its body has no tail or `return` expression +LL | pub fn g() -> String { + | - ^^^^^^ expected struct `std::string::String`, found `()` + | | + | implicitly returns `()` as its body has no tail or `return` expression LL | "this won't work".to_string(); LL | "removeme".to_string(); | - help: consider removing this semicolon diff --git a/src/test/ui/coercion/coercion-missing-tail-expected-type.fixed b/src/test/ui/coercion/coercion-missing-tail-expected-type.fixed new file mode 100644 index 0000000000000..713e04774a0e7 --- /dev/null +++ b/src/test/ui/coercion/coercion-missing-tail-expected-type.fixed @@ -0,0 +1,16 @@ +// #41425 -- error message "mismatched types" has wrong types +// run-rustfix + +fn plus_one(x: i32) -> i32 { //~ ERROR mismatched types + x + 1 +} + +fn foo() -> Result { //~ ERROR mismatched types + Ok(1) +} + +fn main() { + let x = plus_one(5); + let _ = foo(); + println!("X = {}", x); +} diff --git a/src/test/ui/coercion/coercion-missing-tail-expected-type.rs b/src/test/ui/coercion/coercion-missing-tail-expected-type.rs index 20a4407e9a1c0..e14d79d8acae6 100644 --- a/src/test/ui/coercion/coercion-missing-tail-expected-type.rs +++ b/src/test/ui/coercion/coercion-missing-tail-expected-type.rs @@ -1,4 +1,5 @@ // #41425 -- error message "mismatched types" has wrong types +// run-rustfix fn plus_one(x: i32) -> i32 { //~ ERROR mismatched types x + 1; @@ -10,5 +11,6 @@ fn foo() -> Result { //~ ERROR mismatched types fn main() { let x = plus_one(5); + let _ = foo(); println!("X = {}", x); } diff --git a/src/test/ui/coercion/coercion-missing-tail-expected-type.stderr b/src/test/ui/coercion/coercion-missing-tail-expected-type.stderr index f1911dde981f5..da8db4331dffb 100644 --- a/src/test/ui/coercion/coercion-missing-tail-expected-type.stderr +++ b/src/test/ui/coercion/coercion-missing-tail-expected-type.stderr @@ -1,5 +1,5 @@ error[E0308]: mismatched types - --> $DIR/coercion-missing-tail-expected-type.rs:3:24 + --> $DIR/coercion-missing-tail-expected-type.rs:4:24 | LL | fn plus_one(x: i32) -> i32 { | -------- ^^^ expected `i32`, found `()` @@ -9,7 +9,7 @@ LL | x + 1; | - help: consider removing this semicolon error[E0308]: mismatched types - --> $DIR/coercion-missing-tail-expected-type.rs:7:13 + --> $DIR/coercion-missing-tail-expected-type.rs:8:13 | LL | fn foo() -> Result { | --- ^^^^^^^^^^^^^^^ expected enum `std::result::Result`, found `()` diff --git a/src/test/ui/const-generics/unused_braces.fixed b/src/test/ui/const-generics/unused_braces.fixed new file mode 100644 index 0000000000000..5c2b9267af583 --- /dev/null +++ b/src/test/ui/const-generics/unused_braces.fixed @@ -0,0 +1,15 @@ +// check-pass +// run-rustfix + +#![allow(incomplete_features)] +#![warn(unused_braces)] + +#![feature(const_generics)] + +struct A; + +fn main() { + let _: A<7>; // ok + let _: A< 7 >; //~ WARN unnecessary braces + let _: A<{ 3 + 5 }>; // ok +} diff --git a/src/test/ui/const-generics/unused_braces.rs b/src/test/ui/const-generics/unused_braces.rs index 2c3ce7c9eab4d..c3e02b45ed5a2 100644 --- a/src/test/ui/const-generics/unused_braces.rs +++ b/src/test/ui/const-generics/unused_braces.rs @@ -1,8 +1,10 @@ // check-pass +// run-rustfix + +#![allow(incomplete_features)] #![warn(unused_braces)] #![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete struct A; diff --git a/src/test/ui/const-generics/unused_braces.stderr b/src/test/ui/const-generics/unused_braces.stderr index e14958ee566ee..618698a323445 100644 --- a/src/test/ui/const-generics/unused_braces.stderr +++ b/src/test/ui/const-generics/unused_braces.stderr @@ -1,23 +1,14 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/unused_braces.rs:4:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 for more information - warning: unnecessary braces around const expression - --> $DIR/unused_braces.rs:11:14 + --> $DIR/unused_braces.rs:13:14 | LL | let _: A<{ 7 }>; | ^^^^^ help: remove these braces | note: the lint level is defined here - --> $DIR/unused_braces.rs:2:9 + --> $DIR/unused_braces.rs:5:9 | LL | #![warn(unused_braces)] | ^^^^^^^^^^^^^ -warning: 2 warnings emitted +warning: 1 warning emitted diff --git a/src/test/ui/did_you_mean/issue-41679-tilde-bitwise-negation-attempt.fixed b/src/test/ui/did_you_mean/issue-41679-tilde-bitwise-negation-attempt.fixed new file mode 100644 index 0000000000000..87debfeceaaf3 --- /dev/null +++ b/src/test/ui/did_you_mean/issue-41679-tilde-bitwise-negation-attempt.fixed @@ -0,0 +1,5 @@ +// run-rustfix + +fn main() { + let _x = !1; //~ ERROR cannot be used as a unary operator +} diff --git a/src/test/ui/did_you_mean/issue-41679-tilde-bitwise-negation-attempt.rs b/src/test/ui/did_you_mean/issue-41679-tilde-bitwise-negation-attempt.rs index b59fe423025e6..015a8edcea355 100644 --- a/src/test/ui/did_you_mean/issue-41679-tilde-bitwise-negation-attempt.rs +++ b/src/test/ui/did_you_mean/issue-41679-tilde-bitwise-negation-attempt.rs @@ -1,3 +1,5 @@ +// run-rustfix + fn main() { - let x = ~1; //~ ERROR cannot be used as a unary operator + let _x = ~1; //~ ERROR cannot be used as a unary operator } diff --git a/src/test/ui/did_you_mean/issue-41679-tilde-bitwise-negation-attempt.stderr b/src/test/ui/did_you_mean/issue-41679-tilde-bitwise-negation-attempt.stderr index 79bc7d2565be6..84b81d561e909 100644 --- a/src/test/ui/did_you_mean/issue-41679-tilde-bitwise-negation-attempt.stderr +++ b/src/test/ui/did_you_mean/issue-41679-tilde-bitwise-negation-attempt.stderr @@ -1,8 +1,8 @@ error: `~` cannot be used as a unary operator - --> $DIR/issue-41679-tilde-bitwise-negation-attempt.rs:2:13 + --> $DIR/issue-41679-tilde-bitwise-negation-attempt.rs:4:14 | -LL | let x = ~1; - | ^ help: use `!` to perform bitwise not +LL | let _x = ~1; + | ^ help: use `!` to perform bitwise not error: aborting due to previous error diff --git a/src/test/ui/did_you_mean/issue-54109-without-witness.fixed b/src/test/ui/did_you_mean/issue-54109-without-witness.fixed new file mode 100644 index 0000000000000..21471d75c8215 --- /dev/null +++ b/src/test/ui/did_you_mean/issue-54109-without-witness.fixed @@ -0,0 +1,69 @@ +// run-rustfix + +// This test is to check if suggestions can be applied automatically. + +#![allow(dead_code, unused_parens)] + +fn main() {} + +fn test_and() { + let a = true; + let b = false; + + let _ = a && b; //~ ERROR `and` is not a logical operator + //~| ERROR `and` is not a logical operator + + if a && b { //~ ERROR `and` is not a logical operator + //~| ERROR `and` is not a logical operator + println!("both"); + } +} + +fn test_or() { + let a = true; + let b = false; + + let _ = a || b; //~ ERROR `or` is not a logical operator + //~| ERROR `or` is not a logical operator + + if a || b { //~ ERROR `or` is not a logical operator + //~| ERROR `or` is not a logical operator + println!("both"); + } +} + +fn test_and_par() { + let a = true; + let b = false; + if (a && b) { //~ ERROR `and` is not a logical operator + //~| ERROR `and` is not a logical operator + println!("both"); + } +} + +fn test_or_par() { + let a = true; + let b = false; + if (a || b) { //~ ERROR `or` is not a logical operator + //~| ERROR `or` is not a logical operator + println!("both"); + } +} + +fn test_while_and() { + let a = true; + let b = false; + while a && b { //~ ERROR `and` is not a logical operator + //~| ERROR `and` is not a logical operator + println!("both"); + } +} + +fn test_while_or() { + let a = true; + let b = false; + while a || b { //~ ERROR `or` is not a logical operator + //~| ERROR `or` is not a logical operator + println!("both"); + } +} diff --git a/src/test/ui/did_you_mean/issue-54109-without-witness.rs b/src/test/ui/did_you_mean/issue-54109-without-witness.rs new file mode 100644 index 0000000000000..bb9a3a195962e --- /dev/null +++ b/src/test/ui/did_you_mean/issue-54109-without-witness.rs @@ -0,0 +1,69 @@ +// run-rustfix + +// This test is to check if suggestions can be applied automatically. + +#![allow(dead_code, unused_parens)] + +fn main() {} + +fn test_and() { + let a = true; + let b = false; + + let _ = a and b; //~ ERROR `and` is not a logical operator + //~| ERROR `and` is not a logical operator + + if a and b { //~ ERROR `and` is not a logical operator + //~| ERROR `and` is not a logical operator + println!("both"); + } +} + +fn test_or() { + let a = true; + let b = false; + + let _ = a or b; //~ ERROR `or` is not a logical operator + //~| ERROR `or` is not a logical operator + + if a or b { //~ ERROR `or` is not a logical operator + //~| ERROR `or` is not a logical operator + println!("both"); + } +} + +fn test_and_par() { + let a = true; + let b = false; + if (a and b) { //~ ERROR `and` is not a logical operator + //~| ERROR `and` is not a logical operator + println!("both"); + } +} + +fn test_or_par() { + let a = true; + let b = false; + if (a or b) { //~ ERROR `or` is not a logical operator + //~| ERROR `or` is not a logical operator + println!("both"); + } +} + +fn test_while_and() { + let a = true; + let b = false; + while a and b { //~ ERROR `and` is not a logical operator + //~| ERROR `and` is not a logical operator + println!("both"); + } +} + +fn test_while_or() { + let a = true; + let b = false; + while a or b { //~ ERROR `or` is not a logical operator + //~| ERROR `or` is not a logical operator + println!("both"); + } +} diff --git a/src/test/ui/did_you_mean/issue-54109-without-witness.stderr b/src/test/ui/did_you_mean/issue-54109-without-witness.stderr new file mode 100644 index 0000000000000..fe48af592db91 --- /dev/null +++ b/src/test/ui/did_you_mean/issue-54109-without-witness.stderr @@ -0,0 +1,130 @@ +error: `and` is not a logical operator + --> $DIR/issue-54109-without-witness.rs:13:15 + | +LL | let _ = a and b; + | ^^^ help: use `&&` to perform logical conjunction + | + = note: unlike in e.g., python and PHP, `&&` and `||` are used for logical operators + +error: `and` is not a logical operator + --> $DIR/issue-54109-without-witness.rs:13:15 + | +LL | let _ = a and b; + | ^^^ help: use `&&` to perform logical conjunction + | + = note: unlike in e.g., python and PHP, `&&` and `||` are used for logical operators + +error: `and` is not a logical operator + --> $DIR/issue-54109-without-witness.rs:16:10 + | +LL | if a and b { + | ^^^ help: use `&&` to perform logical conjunction + | + = note: unlike in e.g., python and PHP, `&&` and `||` are used for logical operators + +error: `and` is not a logical operator + --> $DIR/issue-54109-without-witness.rs:16:10 + | +LL | if a and b { + | ^^^ help: use `&&` to perform logical conjunction + | + = note: unlike in e.g., python and PHP, `&&` and `||` are used for logical operators + +error: `or` is not a logical operator + --> $DIR/issue-54109-without-witness.rs:26:15 + | +LL | let _ = a or b; + | ^^ help: use `||` to perform logical disjunction + | + = note: unlike in e.g., python and PHP, `&&` and `||` are used for logical operators + +error: `or` is not a logical operator + --> $DIR/issue-54109-without-witness.rs:26:15 + | +LL | let _ = a or b; + | ^^ help: use `||` to perform logical disjunction + | + = note: unlike in e.g., python and PHP, `&&` and `||` are used for logical operators + +error: `or` is not a logical operator + --> $DIR/issue-54109-without-witness.rs:29:10 + | +LL | if a or b { + | ^^ help: use `||` to perform logical disjunction + | + = note: unlike in e.g., python and PHP, `&&` and `||` are used for logical operators + +error: `or` is not a logical operator + --> $DIR/issue-54109-without-witness.rs:29:10 + | +LL | if a or b { + | ^^ help: use `||` to perform logical disjunction + | + = note: unlike in e.g., python and PHP, `&&` and `||` are used for logical operators + +error: `and` is not a logical operator + --> $DIR/issue-54109-without-witness.rs:38:11 + | +LL | if (a and b) { + | ^^^ help: use `&&` to perform logical conjunction + | + = note: unlike in e.g., python and PHP, `&&` and `||` are used for logical operators + +error: `and` is not a logical operator + --> $DIR/issue-54109-without-witness.rs:38:11 + | +LL | if (a and b) { + | ^^^ help: use `&&` to perform logical conjunction + | + = note: unlike in e.g., python and PHP, `&&` and `||` are used for logical operators + +error: `or` is not a logical operator + --> $DIR/issue-54109-without-witness.rs:47:11 + | +LL | if (a or b) { + | ^^ help: use `||` to perform logical disjunction + | + = note: unlike in e.g., python and PHP, `&&` and `||` are used for logical operators + +error: `or` is not a logical operator + --> $DIR/issue-54109-without-witness.rs:47:11 + | +LL | if (a or b) { + | ^^ help: use `||` to perform logical disjunction + | + = note: unlike in e.g., python and PHP, `&&` and `||` are used for logical operators + +error: `and` is not a logical operator + --> $DIR/issue-54109-without-witness.rs:56:13 + | +LL | while a and b { + | ^^^ help: use `&&` to perform logical conjunction + | + = note: unlike in e.g., python and PHP, `&&` and `||` are used for logical operators + +error: `and` is not a logical operator + --> $DIR/issue-54109-without-witness.rs:56:13 + | +LL | while a and b { + | ^^^ help: use `&&` to perform logical conjunction + | + = note: unlike in e.g., python and PHP, `&&` and `||` are used for logical operators + +error: `or` is not a logical operator + --> $DIR/issue-54109-without-witness.rs:65:13 + | +LL | while a or b { + | ^^ help: use `||` to perform logical disjunction + | + = note: unlike in e.g., python and PHP, `&&` and `||` are used for logical operators + +error: `or` is not a logical operator + --> $DIR/issue-54109-without-witness.rs:65:13 + | +LL | while a or b { + | ^^ help: use `||` to perform logical disjunction + | + = note: unlike in e.g., python and PHP, `&&` and `||` are used for logical operators + +error: aborting due to 16 previous errors + diff --git a/src/test/ui/error-codes/E0642.fixed b/src/test/ui/error-codes/E0642.fixed new file mode 100644 index 0000000000000..fc6255e027443 --- /dev/null +++ b/src/test/ui/error-codes/E0642.fixed @@ -0,0 +1,20 @@ +// run-rustfix + +#![allow(unused)] // for rustfix + +#[derive(Clone, Copy)] +struct S; + +trait T { + fn foo(_: (i32, i32)); //~ ERROR patterns aren't allowed in methods without bodies + + fn bar(_: (i32, i32)) {} //~ ERROR patterns aren't allowed in methods without bodies + + fn method(_: S) {} //~ ERROR patterns aren't allowed in methods without bodies + + fn f(&ident: &S) {} // ok + fn g(&&ident: &&S) {} // ok + fn h(mut ident: S) {} // ok +} + +fn main() {} diff --git a/src/test/ui/error-codes/E0642.rs b/src/test/ui/error-codes/E0642.rs index cfbd362c1da19..5f85f3935e1a0 100644 --- a/src/test/ui/error-codes/E0642.rs +++ b/src/test/ui/error-codes/E0642.rs @@ -1,3 +1,7 @@ +// run-rustfix + +#![allow(unused)] // for rustfix + #[derive(Clone, Copy)] struct S; diff --git a/src/test/ui/error-codes/E0642.stderr b/src/test/ui/error-codes/E0642.stderr index 45486a5d632be..83fcac042b1b4 100644 --- a/src/test/ui/error-codes/E0642.stderr +++ b/src/test/ui/error-codes/E0642.stderr @@ -1,5 +1,5 @@ error[E0642]: patterns aren't allowed in methods without bodies - --> $DIR/E0642.rs:5:12 + --> $DIR/E0642.rs:9:12 | LL | fn foo((x, y): (i32, i32)); | ^^^^^^ @@ -10,7 +10,7 @@ LL | fn foo(_: (i32, i32)); | ^ error[E0642]: patterns aren't allowed in methods without bodies - --> $DIR/E0642.rs:7:12 + --> $DIR/E0642.rs:11:12 | LL | fn bar((x, y): (i32, i32)) {} | ^^^^^^ @@ -21,7 +21,7 @@ LL | fn bar(_: (i32, i32)) {} | ^ error[E0642]: patterns aren't allowed in methods without bodies - --> $DIR/E0642.rs:9:15 + --> $DIR/E0642.rs:13:15 | LL | fn method(S { .. }: S) {} | ^^^^^^^^ diff --git a/src/test/ui/generic/generic-no-mangle.fixed b/src/test/ui/generic/generic-no-mangle.fixed new file mode 100644 index 0000000000000..72f9af0124c16 --- /dev/null +++ b/src/test/ui/generic/generic-no-mangle.fixed @@ -0,0 +1,17 @@ +// run-rustfix + +#![deny(no_mangle_generic_items)] + + +pub fn foo() {} //~ ERROR functions generic over types or consts must be mangled + + +pub extern fn bar() {} //~ ERROR functions generic over types or consts must be mangled + +#[no_mangle] +pub fn baz(x: &i32) -> &i32 { x } + +#[no_mangle] +pub fn qux<'a>(x: &'a i32) -> &i32 { x } + +fn main() {} diff --git a/src/test/ui/generic/generic-no-mangle.rs b/src/test/ui/generic/generic-no-mangle.rs index 994aebc7f6e3e..08d631e6eee1e 100644 --- a/src/test/ui/generic/generic-no-mangle.rs +++ b/src/test/ui/generic/generic-no-mangle.rs @@ -1,3 +1,5 @@ +// run-rustfix + #![deny(no_mangle_generic_items)] #[no_mangle] diff --git a/src/test/ui/generic/generic-no-mangle.stderr b/src/test/ui/generic/generic-no-mangle.stderr index ab2ad541e8640..e8e6d9d502d4b 100644 --- a/src/test/ui/generic/generic-no-mangle.stderr +++ b/src/test/ui/generic/generic-no-mangle.stderr @@ -1,5 +1,5 @@ error: functions generic over types or consts must be mangled - --> $DIR/generic-no-mangle.rs:4:1 + --> $DIR/generic-no-mangle.rs:6:1 | LL | #[no_mangle] | ------------ help: remove this attribute @@ -7,13 +7,13 @@ LL | pub fn foo() {} | ^^^^^^^^^^^^^^^^^^ | note: the lint level is defined here - --> $DIR/generic-no-mangle.rs:1:9 + --> $DIR/generic-no-mangle.rs:3:9 | LL | #![deny(no_mangle_generic_items)] | ^^^^^^^^^^^^^^^^^^^^^^^ error: functions generic over types or consts must be mangled - --> $DIR/generic-no-mangle.rs:7:1 + --> $DIR/generic-no-mangle.rs:9:1 | LL | #[no_mangle] | ------------ help: remove this attribute diff --git a/src/test/ui/impossible_range.fixed b/src/test/ui/impossible_range.fixed new file mode 100644 index 0000000000000..3fd950e0dbfc8 --- /dev/null +++ b/src/test/ui/impossible_range.fixed @@ -0,0 +1,20 @@ +// run-rustfix +// Make sure that invalid ranges generate an error during parsing, not an ICE + +#![allow(path_statements)] + +pub fn main() { + ..; + 0..; + ..1; + 0..1; + ..; //~ERROR inclusive range with no end + //~^HELP use `..` instead +} + +fn _foo1() { + ..=1; + 0..=1; + 0..; //~ERROR inclusive range with no end + //~^HELP use `..` instead +} diff --git a/src/test/ui/impossible_range.rs b/src/test/ui/impossible_range.rs index 21e5c03eb1605..0fe0e17be669a 100644 --- a/src/test/ui/impossible_range.rs +++ b/src/test/ui/impossible_range.rs @@ -1,5 +1,8 @@ +// run-rustfix // Make sure that invalid ranges generate an error during parsing, not an ICE +#![allow(path_statements)] + pub fn main() { ..; 0..; diff --git a/src/test/ui/impossible_range.stderr b/src/test/ui/impossible_range.stderr index ea2ab0f299d1b..53c56065c2a3a 100644 --- a/src/test/ui/impossible_range.stderr +++ b/src/test/ui/impossible_range.stderr @@ -1,5 +1,5 @@ error[E0586]: inclusive range with no end - --> $DIR/impossible_range.rs:8:5 + --> $DIR/impossible_range.rs:11:5 | LL | ..=; | ^^^ help: use `..` instead @@ -7,7 +7,7 @@ LL | ..=; = note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`) error[E0586]: inclusive range with no end - --> $DIR/impossible_range.rs:15:6 + --> $DIR/impossible_range.rs:18:6 | LL | 0..=; | ^^^ help: use `..` instead diff --git a/src/test/ui/issue-73914.rs b/src/test/ui/issue-73914.rs new file mode 100644 index 0000000000000..1e99faaded4ef --- /dev/null +++ b/src/test/ui/issue-73914.rs @@ -0,0 +1,30 @@ +// build-pass +// compile-flags:-Copt-level=0 +// edition:2018 + +struct S(std::marker::PhantomData); + +impl std::ops::Deref for S { + type Target = T; + + fn deref(&self) -> &Self::Target { + todo!() + } +} +impl std::ops::DerefMut for S { + fn deref_mut(&mut self) -> &mut Self::Target { + todo!() + } +} + +async fn new() -> S { + todo!() +} + +async fn crash() { + *new().await = 1 + 1; +} + +fn main() { + let _ = crash(); +} diff --git a/src/test/ui/issues/issue-1962.fixed b/src/test/ui/issues/issue-1962.fixed new file mode 100644 index 0000000000000..b810a90ef37f9 --- /dev/null +++ b/src/test/ui/issues/issue-1962.fixed @@ -0,0 +1,10 @@ +// compile-flags: -D while-true +// run-rustfix + +fn main() { + let mut i = 0; + loop { //~ ERROR denote infinite loops with `loop + i += 1; + if i == 5 { break; } + } +} diff --git a/src/test/ui/issues/issue-1962.rs b/src/test/ui/issues/issue-1962.rs index e9ab3b5f99baa..00d2bbd28506e 100644 --- a/src/test/ui/issues/issue-1962.rs +++ b/src/test/ui/issues/issue-1962.rs @@ -1,8 +1,10 @@ // compile-flags: -D while-true +// run-rustfix + fn main() { - let mut i = 0; - while true { //~ ERROR denote infinite loops with `loop - i += 1; - if i == 5 { break; } - } + let mut i = 0; + while true { //~ ERROR denote infinite loops with `loop + i += 1; + if i == 5 { break; } + } } diff --git a/src/test/ui/issues/issue-1962.stderr b/src/test/ui/issues/issue-1962.stderr index afef59c52642f..17142912696a7 100644 --- a/src/test/ui/issues/issue-1962.stderr +++ b/src/test/ui/issues/issue-1962.stderr @@ -1,8 +1,8 @@ error: denote infinite loops with `loop { ... }` - --> $DIR/issue-1962.rs:4:3 + --> $DIR/issue-1962.rs:6:5 | -LL | while true { - | ^^^^^^^^^^ help: use `loop` +LL | while true { + | ^^^^^^^^^^ help: use `loop` | = note: requested on the command line with `-D while-true` diff --git a/src/test/ui/issues/issue-40782.fixed b/src/test/ui/issues/issue-40782.fixed new file mode 100644 index 0000000000000..d61c248c6ec62 --- /dev/null +++ b/src/test/ui/issues/issue-40782.fixed @@ -0,0 +1,6 @@ +// run-rustfix + +fn main() { + for _i in 0..2 { //~ ERROR missing `in` + } +} diff --git a/src/test/ui/issues/issue-40782.rs b/src/test/ui/issues/issue-40782.rs index 60db19ef9151f..3688c69fbc613 100644 --- a/src/test/ui/issues/issue-40782.rs +++ b/src/test/ui/issues/issue-40782.rs @@ -1,4 +1,6 @@ +// run-rustfix + fn main() { - for i 0..2 { //~ ERROR missing `in` + for _i 0..2 { //~ ERROR missing `in` } } diff --git a/src/test/ui/issues/issue-40782.stderr b/src/test/ui/issues/issue-40782.stderr index fdc57466f3cac..9d7776f32b345 100644 --- a/src/test/ui/issues/issue-40782.stderr +++ b/src/test/ui/issues/issue-40782.stderr @@ -1,8 +1,8 @@ error: missing `in` in `for` loop - --> $DIR/issue-40782.rs:2:10 + --> $DIR/issue-40782.rs:4:11 | -LL | for i 0..2 { - | ^ help: try adding `in` here +LL | for _i 0..2 { + | ^ help: try adding `in` here error: aborting due to previous error diff --git a/src/test/ui/issues/issue-46186.fixed b/src/test/ui/issues/issue-46186.fixed new file mode 100644 index 0000000000000..2cb5a4996ee25 --- /dev/null +++ b/src/test/ui/issues/issue-46186.fixed @@ -0,0 +1,8 @@ +// run-rustfix + +pub struct Struct { + pub a: usize, +} +//~^ ERROR expected item, found `;` + +fn main() {} diff --git a/src/test/ui/issues/issue-46186.rs b/src/test/ui/issues/issue-46186.rs index 9dfd61fdf3f20..84cad38c5ecb9 100644 --- a/src/test/ui/issues/issue-46186.rs +++ b/src/test/ui/issues/issue-46186.rs @@ -1,5 +1,7 @@ -struct Struct { - a: usize, +// run-rustfix + +pub struct Struct { + pub a: usize, }; //~^ ERROR expected item, found `;` diff --git a/src/test/ui/issues/issue-46186.stderr b/src/test/ui/issues/issue-46186.stderr index eb0dbb8aa41b8..0766c8a33df14 100644 --- a/src/test/ui/issues/issue-46186.stderr +++ b/src/test/ui/issues/issue-46186.stderr @@ -1,5 +1,5 @@ error: expected item, found `;` - --> $DIR/issue-46186.rs:3:2 + --> $DIR/issue-46186.rs:5:2 | LL | }; | ^ help: remove this semicolon diff --git a/src/test/ui/issues/issue-50571.fixed b/src/test/ui/issues/issue-50571.fixed new file mode 100644 index 0000000000000..2f8c925b85328 --- /dev/null +++ b/src/test/ui/issues/issue-50571.fixed @@ -0,0 +1,8 @@ +// run-rustfix + +trait Foo { + fn foo(_: [i32; 2]) {} + //~^ ERROR: patterns aren't allowed in methods without bodies +} + +fn main() {} diff --git a/src/test/ui/issues/issue-50571.rs b/src/test/ui/issues/issue-50571.rs index 728c113bdc323..56f422e7d5838 100644 --- a/src/test/ui/issues/issue-50571.rs +++ b/src/test/ui/issues/issue-50571.rs @@ -1,3 +1,5 @@ +// run-rustfix + trait Foo { fn foo([a, b]: [i32; 2]) {} //~^ ERROR: patterns aren't allowed in methods without bodies diff --git a/src/test/ui/issues/issue-50571.stderr b/src/test/ui/issues/issue-50571.stderr index df9d10b39507b..ed01362758573 100644 --- a/src/test/ui/issues/issue-50571.stderr +++ b/src/test/ui/issues/issue-50571.stderr @@ -1,5 +1,5 @@ error[E0642]: patterns aren't allowed in methods without bodies - --> $DIR/issue-50571.rs:2:12 + --> $DIR/issue-50571.rs:4:12 | LL | fn foo([a, b]: [i32; 2]) {} | ^^^^^^ diff --git a/src/test/ui/lint/issue-54538-unused-parens-lint.fixed b/src/test/ui/lint/issue-54538-unused-parens-lint.fixed new file mode 100644 index 0000000000000..c70c39b5f6dc7 --- /dev/null +++ b/src/test/ui/lint/issue-54538-unused-parens-lint.fixed @@ -0,0 +1,107 @@ +// run-rustfix + +#![feature(box_patterns, stmt_expr_attributes)] +#![feature(or_patterns)] + +#![allow( + dead_code, + ellipsis_inclusive_range_patterns, + irrefutable_let_patterns, + unreachable_patterns, + unused_mut, + unused_variables +)] +#![deny(unused_parens)] + +fn lint_on_top_level() { + let a = 0; //~ ERROR unnecessary parentheses around pattern + for a in 0..1 {} //~ ERROR unnecessary parentheses around pattern + if let a = 0 {} //~ ERROR unnecessary parentheses around pattern + while let a = 0 {} //~ ERROR unnecessary parentheses around pattern + fn foo(a: u8) {} //~ ERROR unnecessary parentheses around pattern + let _ = |a: u8| 0; //~ ERROR unnecessary parentheses around pattern +} + +fn _no_lint_attr() { + let _x = #[allow(dead_code)] (1 + 2); +} + +// Don't lint in these cases (#64106). +fn or_patterns_no_lint() { + match Box::new(0) { + box (0 | 1) => {} // Should not lint as `box 0 | 1` binds as `(box 0) | 1`. + _ => {} + } + + match 0 { + x @ (0 | 1) => {} // Should not lint as `x @ 0 | 1` binds as `(x @ 0) | 1`. + _ => {} + } + + if let &(0 | 1) = &0 {} // Should also not lint. + if let &mut (0 | 1) = &mut 0 {} // Same. + + fn foo((Ok(a) | Err(a)): Result) {} // Doesn't parse if we remove parens for now. + + let _ = |(Ok(a) | Err(a)): Result| 1; // `|Ok(a) | Err(a)| 1` parses as bit-or. +} + +fn or_patterns_will_lint() { + if let 0 | 1 = 0 {} //~ ERROR unnecessary parentheses around pattern + if let (0 | 1,) = (0,) {} //~ ERROR unnecessary parentheses around pattern + if let [0 | 1] = [0] {} //~ ERROR unnecessary parentheses around pattern + if let 0 | 1 | 2 = 0 {} //~ ERROR unnecessary parentheses around pattern + struct TS(u8); + if let TS(0 | 1) = TS(0) {} //~ ERROR unnecessary parentheses around pattern + struct NS { f: u8 } + if let NS { f: 0 | 1 } = (NS { f: 0 }) {} //~ ERROR unnecessary parentheses around pattern +} + +// Don't lint on `&(mut x)` because `&mut x` means something else (#55342). +fn deref_mut_binding_no_lint() { + let &(mut x) = &0; +} + +fn main() { + match 1 { + _ => {} //~ ERROR unnecessary parentheses around pattern + y => {} //~ ERROR unnecessary parentheses around pattern + ref r => {} //~ ERROR unnecessary parentheses around pattern + e @ 1...2 => {} //~ ERROR unnecessary parentheses around pattern + (1...2) => {} // Non ambiguous range pattern should not warn + e @ (3...4) => {} // Non ambiguous range pattern should not warn + } + + match &1 { + e @ &(1...2) => {} //~ ERROR unnecessary parentheses around pattern + &_ => {} //~ ERROR unnecessary parentheses around pattern + e @ &(1...2) => {} // Ambiguous range pattern should not warn + &(1...2) => {} // Ambiguous range pattern should not warn + } + + match &1 { + e @ &(1...2) | e @ &(3...4) => {} // Complex ambiguous pattern should not warn + &_ => {} + } + + match 1 { + _ => {} //~ ERROR unnecessary parentheses around pattern + y => {} //~ ERROR unnecessary parentheses around pattern + ref r => {} //~ ERROR unnecessary parentheses around pattern + e @ 1..=2 => {} //~ ERROR unnecessary parentheses around pattern + (1..=2) => {} // Non ambiguous range pattern should not warn + e @ (3..=4) => {} // Non ambiguous range pattern should not warn + } + + match &1 { + e @ &(1..=2) => {} //~ ERROR unnecessary parentheses around pattern + &_ => {} //~ ERROR unnecessary parentheses around pattern + e @ &(1..=2) => {} // Ambiguous range pattern should not warn + &(1..=2) => {} // Ambiguous range pattern should not warn + } + + match &1 { + e @ &(1..=2) | e @ &(3..=4) => {} // Complex ambiguous pattern should not warn + &_ => {} + } +} diff --git a/src/test/ui/lint/issue-54538-unused-parens-lint.rs b/src/test/ui/lint/issue-54538-unused-parens-lint.rs index f3d2d1bb58d8f..9dd3b63c0fed7 100644 --- a/src/test/ui/lint/issue-54538-unused-parens-lint.rs +++ b/src/test/ui/lint/issue-54538-unused-parens-lint.rs @@ -1,10 +1,16 @@ -#![feature(box_patterns, stmt_expr_attributes)] +// run-rustfix +#![feature(box_patterns, stmt_expr_attributes)] #![feature(or_patterns)] -#![allow(ellipsis_inclusive_range_patterns)] -#![allow(unreachable_patterns)] -#![allow(unused_variables)] +#![allow( + dead_code, + ellipsis_inclusive_range_patterns, + irrefutable_let_patterns, + unreachable_patterns, + unused_mut, + unused_variables +)] #![deny(unused_parens)] fn lint_on_top_level() { diff --git a/src/test/ui/lint/issue-54538-unused-parens-lint.stderr b/src/test/ui/lint/issue-54538-unused-parens-lint.stderr index b31ad95b191c9..ee466857757a3 100644 --- a/src/test/ui/lint/issue-54538-unused-parens-lint.stderr +++ b/src/test/ui/lint/issue-54538-unused-parens-lint.stderr @@ -1,149 +1,149 @@ error: unnecessary parentheses around pattern - --> $DIR/issue-54538-unused-parens-lint.rs:11:9 + --> $DIR/issue-54538-unused-parens-lint.rs:17:9 | LL | let (a) = 0; | ^^^ help: remove these parentheses | note: the lint level is defined here - --> $DIR/issue-54538-unused-parens-lint.rs:8:9 + --> $DIR/issue-54538-unused-parens-lint.rs:14:9 | LL | #![deny(unused_parens)] | ^^^^^^^^^^^^^ error: unnecessary parentheses around pattern - --> $DIR/issue-54538-unused-parens-lint.rs:12:9 + --> $DIR/issue-54538-unused-parens-lint.rs:18:9 | LL | for (a) in 0..1 {} | ^^^ help: remove these parentheses error: unnecessary parentheses around pattern - --> $DIR/issue-54538-unused-parens-lint.rs:13:12 + --> $DIR/issue-54538-unused-parens-lint.rs:19:12 | LL | if let (a) = 0 {} | ^^^ help: remove these parentheses error: unnecessary parentheses around pattern - --> $DIR/issue-54538-unused-parens-lint.rs:14:15 + --> $DIR/issue-54538-unused-parens-lint.rs:20:15 | LL | while let (a) = 0 {} | ^^^ help: remove these parentheses error: unnecessary parentheses around pattern - --> $DIR/issue-54538-unused-parens-lint.rs:15:12 + --> $DIR/issue-54538-unused-parens-lint.rs:21:12 | LL | fn foo((a): u8) {} | ^^^ help: remove these parentheses error: unnecessary parentheses around pattern - --> $DIR/issue-54538-unused-parens-lint.rs:16:14 + --> $DIR/issue-54538-unused-parens-lint.rs:22:14 | LL | let _ = |(a): u8| 0; | ^^^ help: remove these parentheses error: unnecessary parentheses around pattern - --> $DIR/issue-54538-unused-parens-lint.rs:44:12 + --> $DIR/issue-54538-unused-parens-lint.rs:50:12 | LL | if let (0 | 1) = 0 {} | ^^^^^^^ help: remove these parentheses error: unnecessary parentheses around pattern - --> $DIR/issue-54538-unused-parens-lint.rs:45:13 + --> $DIR/issue-54538-unused-parens-lint.rs:51:13 | LL | if let ((0 | 1),) = (0,) {} | ^^^^^^^ help: remove these parentheses error: unnecessary parentheses around pattern - --> $DIR/issue-54538-unused-parens-lint.rs:46:13 + --> $DIR/issue-54538-unused-parens-lint.rs:52:13 | LL | if let [(0 | 1)] = [0] {} | ^^^^^^^ help: remove these parentheses error: unnecessary parentheses around pattern - --> $DIR/issue-54538-unused-parens-lint.rs:47:16 + --> $DIR/issue-54538-unused-parens-lint.rs:53:16 | LL | if let 0 | (1 | 2) = 0 {} | ^^^^^^^ help: remove these parentheses error: unnecessary parentheses around pattern - --> $DIR/issue-54538-unused-parens-lint.rs:49:15 + --> $DIR/issue-54538-unused-parens-lint.rs:55:15 | LL | if let TS((0 | 1)) = TS(0) {} | ^^^^^^^ help: remove these parentheses error: unnecessary parentheses around pattern - --> $DIR/issue-54538-unused-parens-lint.rs:51:20 + --> $DIR/issue-54538-unused-parens-lint.rs:57:20 | LL | if let NS { f: (0 | 1) } = (NS { f: 0 }) {} | ^^^^^^^ help: remove these parentheses error: unnecessary parentheses around pattern - --> $DIR/issue-54538-unused-parens-lint.rs:61:9 + --> $DIR/issue-54538-unused-parens-lint.rs:67:9 | LL | (_) => {} | ^^^ help: remove these parentheses error: unnecessary parentheses around pattern - --> $DIR/issue-54538-unused-parens-lint.rs:62:9 + --> $DIR/issue-54538-unused-parens-lint.rs:68:9 | LL | (y) => {} | ^^^ help: remove these parentheses error: unnecessary parentheses around pattern - --> $DIR/issue-54538-unused-parens-lint.rs:63:9 + --> $DIR/issue-54538-unused-parens-lint.rs:69:9 | LL | (ref r) => {} | ^^^^^^^ help: remove these parentheses error: unnecessary parentheses around pattern - --> $DIR/issue-54538-unused-parens-lint.rs:64:9 + --> $DIR/issue-54538-unused-parens-lint.rs:70:9 | LL | (e @ 1...2) => {} | ^^^^^^^^^^^ help: remove these parentheses error: unnecessary parentheses around pattern - --> $DIR/issue-54538-unused-parens-lint.rs:70:9 + --> $DIR/issue-54538-unused-parens-lint.rs:76:9 | LL | (e @ &(1...2)) => {} | ^^^^^^^^^^^^^^ help: remove these parentheses error: unnecessary parentheses around pattern - --> $DIR/issue-54538-unused-parens-lint.rs:71:10 + --> $DIR/issue-54538-unused-parens-lint.rs:77:10 | LL | &(_) => {} | ^^^ help: remove these parentheses error: unnecessary parentheses around pattern - --> $DIR/issue-54538-unused-parens-lint.rs:82:9 + --> $DIR/issue-54538-unused-parens-lint.rs:88:9 | LL | (_) => {} | ^^^ help: remove these parentheses error: unnecessary parentheses around pattern - --> $DIR/issue-54538-unused-parens-lint.rs:83:9 + --> $DIR/issue-54538-unused-parens-lint.rs:89:9 | LL | (y) => {} | ^^^ help: remove these parentheses error: unnecessary parentheses around pattern - --> $DIR/issue-54538-unused-parens-lint.rs:84:9 + --> $DIR/issue-54538-unused-parens-lint.rs:90:9 | LL | (ref r) => {} | ^^^^^^^ help: remove these parentheses error: unnecessary parentheses around pattern - --> $DIR/issue-54538-unused-parens-lint.rs:85:9 + --> $DIR/issue-54538-unused-parens-lint.rs:91:9 | LL | (e @ 1..=2) => {} | ^^^^^^^^^^^ help: remove these parentheses error: unnecessary parentheses around pattern - --> $DIR/issue-54538-unused-parens-lint.rs:91:9 + --> $DIR/issue-54538-unused-parens-lint.rs:97:9 | LL | (e @ &(1..=2)) => {} | ^^^^^^^^^^^^^^ help: remove these parentheses error: unnecessary parentheses around pattern - --> $DIR/issue-54538-unused-parens-lint.rs:92:10 + --> $DIR/issue-54538-unused-parens-lint.rs:98:10 | LL | &(_) => {} | ^^^ help: remove these parentheses diff --git a/src/test/ui/lint/lint-unnecessary-parens.fixed b/src/test/ui/lint/lint-unnecessary-parens.fixed new file mode 100644 index 0000000000000..c9dec395580f1 --- /dev/null +++ b/src/test/ui/lint/lint-unnecessary-parens.fixed @@ -0,0 +1,79 @@ +// run-rustfix + +#![deny(unused_parens)] +#![allow(while_true)] // for rustfix + +#[derive(Eq, PartialEq)] +struct X { y: bool } +impl X { + fn foo(&self, conjunct: bool) -> bool { self.y && conjunct } +} + +fn foo() -> isize { + return 1; //~ ERROR unnecessary parentheses around `return` value +} +fn bar(y: bool) -> X { + return X { y }; //~ ERROR unnecessary parentheses around `return` value +} + +pub fn unused_parens_around_return_type() -> u32 { //~ ERROR unnecessary parentheses around type + panic!() +} + +pub fn unused_parens_around_block_return() -> u32 { + let _foo = { + 5 //~ ERROR unnecessary parentheses around block return value + }; + 5 //~ ERROR unnecessary parentheses around block return value +} + +pub trait Trait { + fn test(&self); +} + +pub fn passes_unused_parens_lint() -> &'static (dyn Trait) { + panic!() +} + +macro_rules! baz { + ($($foo:expr),+) => { + ($($foo),*) + } +} + +pub const CONST_ITEM: usize = 10; //~ ERROR unnecessary parentheses around assigned value +pub static STATIC_ITEM: usize = 10; //~ ERROR unnecessary parentheses around assigned value + +fn main() { + foo(); + bar(true); //~ ERROR unnecessary parentheses around function argument + + if true {} //~ ERROR unnecessary parentheses around `if` condition + while true {} //~ ERROR unnecessary parentheses around `while` condition + match true { //~ ERROR unnecessary parentheses around `match` scrutinee expression + _ => {} + } + if let 1 = 1 {} //~ ERROR unnecessary parentheses around `let` scrutinee expression + while let 1 = 2 {} //~ ERROR unnecessary parentheses around `let` scrutinee expression + let v = X { y: false }; + // struct lits needs parens, so these shouldn't warn. + if (v == X { y: true }) {} + if (X { y: true } == v) {} + if (X { y: false }.y) {} + + while (X { y: false }.foo(true)) {} + while (true | X { y: false }.y) {} + + match (X { y: false }) { + _ => {} + } + + X { y: false }.foo(true); //~ ERROR unnecessary parentheses around method argument + + let mut _a = 0; //~ ERROR unnecessary parentheses around assigned value + _a = 0; //~ ERROR unnecessary parentheses around assigned value + _a += 1; //~ ERROR unnecessary parentheses around assigned value + + let _a = baz!(3, 4); + let _b = baz!(3); +} diff --git a/src/test/ui/lint/lint-unnecessary-parens.rs b/src/test/ui/lint/lint-unnecessary-parens.rs index 623cd04d9bce3..884bb4d2e99b6 100644 --- a/src/test/ui/lint/lint-unnecessary-parens.rs +++ b/src/test/ui/lint/lint-unnecessary-parens.rs @@ -1,4 +1,7 @@ +// run-rustfix + #![deny(unused_parens)] +#![allow(while_true)] // for rustfix #[derive(Eq, PartialEq)] struct X { y: bool } @@ -13,22 +16,22 @@ fn bar(y: bool) -> X { return (X { y }); //~ ERROR unnecessary parentheses around `return` value } -fn unused_parens_around_return_type() -> (u32) { //~ ERROR unnecessary parentheses around type +pub fn unused_parens_around_return_type() -> (u32) { //~ ERROR unnecessary parentheses around type panic!() } -fn unused_parens_around_block_return() -> u32 { - let foo = { +pub fn unused_parens_around_block_return() -> u32 { + let _foo = { (5) //~ ERROR unnecessary parentheses around block return value }; (5) //~ ERROR unnecessary parentheses around block return value } -trait Trait { +pub trait Trait { fn test(&self); } -fn passes_unused_parens_lint() -> &'static (dyn Trait) { +pub fn passes_unused_parens_lint() -> &'static (dyn Trait) { panic!() } @@ -38,8 +41,8 @@ macro_rules! baz { } } -const CONST_ITEM: usize = (10); //~ ERROR unnecessary parentheses around assigned value -static STATIC_ITEM: usize = (10); //~ ERROR unnecessary parentheses around assigned value +pub const CONST_ITEM: usize = (10); //~ ERROR unnecessary parentheses around assigned value +pub static STATIC_ITEM: usize = (10); //~ ERROR unnecessary parentheses around assigned value fn main() { foo(); @@ -47,7 +50,6 @@ fn main() { if (true) {} //~ ERROR unnecessary parentheses around `if` condition while (true) {} //~ ERROR unnecessary parentheses around `while` condition - //~^ WARN denote infinite loops with match (true) { //~ ERROR unnecessary parentheses around `match` scrutinee expression _ => {} } diff --git a/src/test/ui/lint/lint-unnecessary-parens.stderr b/src/test/ui/lint/lint-unnecessary-parens.stderr index f5a2564a5ff65..1abf47c8af521 100644 --- a/src/test/ui/lint/lint-unnecessary-parens.stderr +++ b/src/test/ui/lint/lint-unnecessary-parens.stderr @@ -1,118 +1,110 @@ error: unnecessary parentheses around `return` value - --> $DIR/lint-unnecessary-parens.rs:10:12 + --> $DIR/lint-unnecessary-parens.rs:13:12 | LL | return (1); | ^^^ help: remove these parentheses | note: the lint level is defined here - --> $DIR/lint-unnecessary-parens.rs:1:9 + --> $DIR/lint-unnecessary-parens.rs:3:9 | LL | #![deny(unused_parens)] | ^^^^^^^^^^^^^ error: unnecessary parentheses around `return` value - --> $DIR/lint-unnecessary-parens.rs:13:12 + --> $DIR/lint-unnecessary-parens.rs:16:12 | LL | return (X { y }); | ^^^^^^^^^ help: remove these parentheses error: unnecessary parentheses around type - --> $DIR/lint-unnecessary-parens.rs:16:42 + --> $DIR/lint-unnecessary-parens.rs:19:46 | -LL | fn unused_parens_around_return_type() -> (u32) { - | ^^^^^ help: remove these parentheses +LL | pub fn unused_parens_around_return_type() -> (u32) { + | ^^^^^ help: remove these parentheses error: unnecessary parentheses around block return value - --> $DIR/lint-unnecessary-parens.rs:22:9 + --> $DIR/lint-unnecessary-parens.rs:25:9 | LL | (5) | ^^^ help: remove these parentheses error: unnecessary parentheses around block return value - --> $DIR/lint-unnecessary-parens.rs:24:5 + --> $DIR/lint-unnecessary-parens.rs:27:5 | LL | (5) | ^^^ help: remove these parentheses error: unnecessary parentheses around assigned value - --> $DIR/lint-unnecessary-parens.rs:41:27 + --> $DIR/lint-unnecessary-parens.rs:44:31 | -LL | const CONST_ITEM: usize = (10); - | ^^^^ help: remove these parentheses +LL | pub const CONST_ITEM: usize = (10); + | ^^^^ help: remove these parentheses error: unnecessary parentheses around assigned value - --> $DIR/lint-unnecessary-parens.rs:42:29 + --> $DIR/lint-unnecessary-parens.rs:45:33 | -LL | static STATIC_ITEM: usize = (10); - | ^^^^ help: remove these parentheses +LL | pub static STATIC_ITEM: usize = (10); + | ^^^^ help: remove these parentheses error: unnecessary parentheses around function argument - --> $DIR/lint-unnecessary-parens.rs:46:9 + --> $DIR/lint-unnecessary-parens.rs:49:9 | LL | bar((true)); | ^^^^^^ help: remove these parentheses error: unnecessary parentheses around `if` condition - --> $DIR/lint-unnecessary-parens.rs:48:8 + --> $DIR/lint-unnecessary-parens.rs:51:8 | LL | if (true) {} | ^^^^^^ help: remove these parentheses error: unnecessary parentheses around `while` condition - --> $DIR/lint-unnecessary-parens.rs:49:11 + --> $DIR/lint-unnecessary-parens.rs:52:11 | LL | while (true) {} | ^^^^^^ help: remove these parentheses -warning: denote infinite loops with `loop { ... }` - --> $DIR/lint-unnecessary-parens.rs:49:5 - | -LL | while (true) {} - | ^^^^^^^^^^^^ help: use `loop` - | - = note: `#[warn(while_true)]` on by default - error: unnecessary parentheses around `match` scrutinee expression - --> $DIR/lint-unnecessary-parens.rs:51:11 + --> $DIR/lint-unnecessary-parens.rs:53:11 | LL | match (true) { | ^^^^^^ help: remove these parentheses error: unnecessary parentheses around `let` scrutinee expression - --> $DIR/lint-unnecessary-parens.rs:54:16 + --> $DIR/lint-unnecessary-parens.rs:56:16 | LL | if let 1 = (1) {} | ^^^ help: remove these parentheses error: unnecessary parentheses around `let` scrutinee expression - --> $DIR/lint-unnecessary-parens.rs:55:19 + --> $DIR/lint-unnecessary-parens.rs:57:19 | LL | while let 1 = (2) {} | ^^^ help: remove these parentheses error: unnecessary parentheses around method argument - --> $DIR/lint-unnecessary-parens.rs:69:24 + --> $DIR/lint-unnecessary-parens.rs:71:24 | LL | X { y: false }.foo((true)); | ^^^^^^ help: remove these parentheses error: unnecessary parentheses around assigned value - --> $DIR/lint-unnecessary-parens.rs:71:18 + --> $DIR/lint-unnecessary-parens.rs:73:18 | LL | let mut _a = (0); | ^^^ help: remove these parentheses error: unnecessary parentheses around assigned value - --> $DIR/lint-unnecessary-parens.rs:72:10 + --> $DIR/lint-unnecessary-parens.rs:74:10 | LL | _a = (0); | ^^^ help: remove these parentheses error: unnecessary parentheses around assigned value - --> $DIR/lint-unnecessary-parens.rs:73:11 + --> $DIR/lint-unnecessary-parens.rs:75:11 | LL | _a += (1); | ^^^ help: remove these parentheses -error: aborting due to 17 previous errors; 1 warning emitted +error: aborting due to 17 previous errors diff --git a/src/test/ui/lint/lint-unused-mut-self.fixed b/src/test/ui/lint/lint-unused-mut-self.fixed new file mode 100644 index 0000000000000..92ce103586c25 --- /dev/null +++ b/src/test/ui/lint/lint-unused-mut-self.fixed @@ -0,0 +1,14 @@ +// run-rustfix + +#![allow(unused_assignments)] +#![allow(unused_variables)] +#![allow(dead_code)] +#![deny(unused_mut)] + +struct Foo; +impl Foo { + fn foo(self) {} //~ ERROR: variable does not need to be mutable + fn bar(self: Box) {} //~ ERROR: variable does not need to be mutable +} + +fn main() {} diff --git a/src/test/ui/lint/lint-unused-mut-self.rs b/src/test/ui/lint/lint-unused-mut-self.rs index 3c709d0793980..70736ce216e5e 100644 --- a/src/test/ui/lint/lint-unused-mut-self.rs +++ b/src/test/ui/lint/lint-unused-mut-self.rs @@ -1,3 +1,5 @@ +// run-rustfix + #![allow(unused_assignments)] #![allow(unused_variables)] #![allow(dead_code)] diff --git a/src/test/ui/lint/lint-unused-mut-self.stderr b/src/test/ui/lint/lint-unused-mut-self.stderr index 16ad4758b92b8..01a524bd323c4 100644 --- a/src/test/ui/lint/lint-unused-mut-self.stderr +++ b/src/test/ui/lint/lint-unused-mut-self.stderr @@ -1,5 +1,5 @@ error: variable does not need to be mutable - --> $DIR/lint-unused-mut-self.rs:8:12 + --> $DIR/lint-unused-mut-self.rs:10:12 | LL | fn foo(mut self) {} | ----^^^^ @@ -7,13 +7,13 @@ LL | fn foo(mut self) {} | help: remove this `mut` | note: the lint level is defined here - --> $DIR/lint-unused-mut-self.rs:4:9 + --> $DIR/lint-unused-mut-self.rs:6:9 | LL | #![deny(unused_mut)] | ^^^^^^^^^^ error: variable does not need to be mutable - --> $DIR/lint-unused-mut-self.rs:9:12 + --> $DIR/lint-unused-mut-self.rs:11:12 | LL | fn bar(mut self: Box) {} | ----^^^^ diff --git a/src/test/ui/lint/lint-unused-mut-variables.rs b/src/test/ui/lint/lint-unused-mut-variables.rs index 5c7ed9d521940..67ec7facf1780 100644 --- a/src/test/ui/lint/lint-unused-mut-variables.rs +++ b/src/test/ui/lint/lint-unused-mut-variables.rs @@ -92,13 +92,16 @@ fn main() { mut x => {} //~ WARN: variable does not need to be mutable } + match (30, 2) { - (mut x, 1) | //~ WARN: variable does not need to be mutable + // FIXME: Here's a false positive, + // shouldn't be removed `mut` not to be bound with a different way. + (mut x, 1) | //~ WARN: variable does not need to be mutable - (mut x, 2) | - (mut x, 3) => { - } - _ => {} + (mut x, 2) | + (mut x, 3) => { + } + _ => {} } let x = |mut y: isize| 10; //~ WARN: variable does not need to be mutable diff --git a/src/test/ui/lint/lint-unused-mut-variables.stderr b/src/test/ui/lint/lint-unused-mut-variables.stderr index 42365f24274b9..805ed2b40bb7b 100644 --- a/src/test/ui/lint/lint-unused-mut-variables.stderr +++ b/src/test/ui/lint/lint-unused-mut-variables.stderr @@ -69,7 +69,7 @@ LL | mut a: i32, | help: remove this `mut` warning: variable does not need to be mutable - --> $DIR/lint-unused-mut-variables.rs:104:14 + --> $DIR/lint-unused-mut-variables.rs:107:14 | LL | let x = |mut y: isize| 10; | ----^ @@ -141,15 +141,15 @@ LL | mut x => {} | help: remove this `mut` warning: variable does not need to be mutable - --> $DIR/lint-unused-mut-variables.rs:96:8 + --> $DIR/lint-unused-mut-variables.rs:99:10 | -LL | (mut x, 1) | - | ----^ - | | - | help: remove this `mut` +LL | (mut x, 1) | + | ----^ + | | + | help: remove this `mut` warning: variable does not need to be mutable - --> $DIR/lint-unused-mut-variables.rs:109:9 + --> $DIR/lint-unused-mut-variables.rs:112:9 | LL | let mut a = &mut 5; | ----^ @@ -157,7 +157,7 @@ LL | let mut a = &mut 5; | help: remove this `mut` warning: variable does not need to be mutable - --> $DIR/lint-unused-mut-variables.rs:114:9 + --> $DIR/lint-unused-mut-variables.rs:117:9 | LL | let mut b = (&mut a,); | ----^ @@ -165,7 +165,7 @@ LL | let mut b = (&mut a,); | help: remove this `mut` warning: variable does not need to be mutable - --> $DIR/lint-unused-mut-variables.rs:117:9 + --> $DIR/lint-unused-mut-variables.rs:120:9 | LL | let mut x = &mut 1; | ----^ @@ -173,7 +173,7 @@ LL | let mut x = &mut 1; | help: remove this `mut` warning: variable does not need to be mutable - --> $DIR/lint-unused-mut-variables.rs:129:9 + --> $DIR/lint-unused-mut-variables.rs:132:9 | LL | let mut v : &mut Vec<()> = &mut vec![]; | ----^ @@ -181,7 +181,7 @@ LL | let mut v : &mut Vec<()> = &mut vec![]; | help: remove this `mut` warning: variable does not need to be mutable - --> $DIR/lint-unused-mut-variables.rs:184:9 + --> $DIR/lint-unused-mut-variables.rs:187:9 | LL | let mut raw_address_of_const = 1; | ----^^^^^^^^^^^^^^^^^^^^ @@ -189,7 +189,7 @@ LL | let mut raw_address_of_const = 1; | help: remove this `mut` warning: variable does not need to be mutable - --> $DIR/lint-unused-mut-variables.rs:106:13 + --> $DIR/lint-unused-mut-variables.rs:109:13 | LL | fn what(mut foo: isize) {} | ----^^^ @@ -197,7 +197,7 @@ LL | fn what(mut foo: isize) {} | help: remove this `mut` warning: variable does not need to be mutable - --> $DIR/lint-unused-mut-variables.rs:124:20 + --> $DIR/lint-unused-mut-variables.rs:127:20 | LL | fn mut_ref_arg(mut arg : &mut [u8]) -> &mut [u8] { | ----^^^ @@ -205,7 +205,7 @@ LL | fn mut_ref_arg(mut arg : &mut [u8]) -> &mut [u8] { | help: remove this `mut` error: variable does not need to be mutable - --> $DIR/lint-unused-mut-variables.rs:202:9 + --> $DIR/lint-unused-mut-variables.rs:205:9 | LL | let mut b = vec![2]; | ----^ @@ -213,7 +213,7 @@ LL | let mut b = vec![2]; | help: remove this `mut` | note: the lint level is defined here - --> $DIR/lint-unused-mut-variables.rs:198:8 + --> $DIR/lint-unused-mut-variables.rs:201:8 | LL | #[deny(unused_mut)] | ^^^^^^^^^^ diff --git a/src/test/ui/lint/suggestions.fixed b/src/test/ui/lint/suggestions.fixed new file mode 100644 index 0000000000000..35851690b7381 --- /dev/null +++ b/src/test/ui/lint/suggestions.fixed @@ -0,0 +1,66 @@ +// ignore-tidy-tab +// run-rustfix + +#![warn(unused_mut, unused_parens)] // UI tests pass `-A unused`—see Issue #43896 + +#[no_mangle] pub static DISCOVERY: usize = 1; +//~^ ERROR const items should never be `#[no_mangle]` +//~| HELP try a static value + + +//~^ HELP remove this attribute +pub fn defiant(_t: T) {} +//~^ WARN functions generic over types or consts must be mangled + +#[no_mangle] +fn rio_grande() {} + +mod badlands { + // The private-no-mangle lints shouldn't suggest inserting `pub` when the + // item is already `pub` (but triggered the lint because, e.g., it's in a + // private module). (Issue #47383) + #[no_mangle] pub static DAUNTLESS: bool = true; + //~^ ERROR const items should never be `#[no_mangle]` + //~| HELP try a static value + #[allow(dead_code)] // for rustfix + pub fn val_jean() {} + //~^ WARN functions generic over types or consts must be mangled + //~| HELP remove this attribute + + // ... but we can suggest just-`pub` instead of restricted + #[no_mangle] pub static VETAR: bool = true; + //~^ ERROR const items should never be `#[no_mangle]` + //~| HELP try a static value + #[allow(dead_code)] // for rustfix + pub(crate) fn crossfield() {} + //~^ WARN functions generic over types or consts must be mangled + //~| HELP remove this attribute +} + +struct Equinox { + warp_factor: f32, +} + +fn main() { + loop { + //~^ WARN denote infinite loops + //~| HELP use `loop` + let registry_no = format!("NX-{}", 74205); + //~^ WARN does not need to be mutable + //~| HELP remove this `mut` + //~| WARN unnecessary parentheses + //~| HELP remove these parentheses + // the line after `mut` has a `\t` at the beginning, this is on purpose + let b = 1; + //~^^ WARN does not need to be mutable + //~| HELP remove this `mut` + let d = Equinox { warp_factor: 9.975 }; + match d { + #[allow(unused_variables)] // for rustfix + Equinox { warp_factor } => {} + //~^ WARN this pattern is redundant + //~| HELP use shorthand field pattern + } + println!("{} {}", registry_no, b); + } +} diff --git a/src/test/ui/lint/suggestions.rs b/src/test/ui/lint/suggestions.rs index 518b5f211e5da..be6f0d6b30fed 100644 --- a/src/test/ui/lint/suggestions.rs +++ b/src/test/ui/lint/suggestions.rs @@ -1,4 +1,5 @@ // ignore-tidy-tab +// run-rustfix #![warn(unused_mut, unused_parens)] // UI tests pass `-A unused`—see Issue #43896 @@ -21,6 +22,7 @@ mod badlands { #[no_mangle] pub const DAUNTLESS: bool = true; //~^ ERROR const items should never be `#[no_mangle]` //~| HELP try a static value + #[allow(dead_code)] // for rustfix #[no_mangle] pub fn val_jean() {} //~^ WARN functions generic over types or consts must be mangled //~| HELP remove this attribute @@ -29,6 +31,7 @@ mod badlands { #[no_mangle] pub(crate) const VETAR: bool = true; //~^ ERROR const items should never be `#[no_mangle]` //~| HELP try a static value + #[allow(dead_code)] // for rustfix #[no_mangle] pub(crate) fn crossfield() {} //~^ WARN functions generic over types or consts must be mangled //~| HELP remove this attribute @@ -54,6 +57,7 @@ fn main() { //~| HELP remove this `mut` let d = Equinox { warp_factor: 9.975 }; match d { + #[allow(unused_variables)] // for rustfix Equinox { warp_factor: warp_factor } => {} //~^ WARN this pattern is redundant //~| HELP use shorthand field pattern diff --git a/src/test/ui/lint/suggestions.stderr b/src/test/ui/lint/suggestions.stderr index 0730c22417c05..cad2514625588 100644 --- a/src/test/ui/lint/suggestions.stderr +++ b/src/test/ui/lint/suggestions.stderr @@ -1,5 +1,5 @@ warning: denote infinite loops with `loop { ... }` - --> $DIR/suggestions.rs:42:5 + --> $DIR/suggestions.rs:45:5 | LL | while true { | ^^^^^^^^^^ help: use `loop` @@ -7,19 +7,19 @@ LL | while true { = note: `#[warn(while_true)]` on by default warning: unnecessary parentheses around assigned value - --> $DIR/suggestions.rs:45:31 + --> $DIR/suggestions.rs:48:31 | LL | let mut registry_no = (format!("NX-{}", 74205)); | ^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove these parentheses | note: the lint level is defined here - --> $DIR/suggestions.rs:3:21 + --> $DIR/suggestions.rs:4:21 | LL | #![warn(unused_mut, unused_parens)] // UI tests pass `-A unused`—see Issue #43896 | ^^^^^^^^^^^^^ warning: variable does not need to be mutable - --> $DIR/suggestions.rs:45:13 + --> $DIR/suggestions.rs:48:13 | LL | let mut registry_no = (format!("NX-{}", 74205)); | ----^^^^^^^^^^^ @@ -27,13 +27,13 @@ LL | let mut registry_no = (format!("NX-{}", 74205)); | help: remove this `mut` | note: the lint level is defined here - --> $DIR/suggestions.rs:3:9 + --> $DIR/suggestions.rs:4:9 | LL | #![warn(unused_mut, unused_parens)] // UI tests pass `-A unused`—see Issue #43896 | ^^^^^^^^^^ warning: variable does not need to be mutable - --> $DIR/suggestions.rs:51:13 + --> $DIR/suggestions.rs:54:13 | LL | let mut | _____________^ @@ -45,7 +45,7 @@ LL | || b = 1; | help: remove this `mut` error: const items should never be `#[no_mangle]` - --> $DIR/suggestions.rs:5:14 + --> $DIR/suggestions.rs:6:14 | LL | #[no_mangle] const DISCOVERY: usize = 1; | -----^^^^^^^^^^^^^^^^^^^^^^ @@ -55,7 +55,7 @@ LL | #[no_mangle] const DISCOVERY: usize = 1; = note: `#[deny(no_mangle_const_items)]` on by default warning: functions generic over types or consts must be mangled - --> $DIR/suggestions.rs:11:1 + --> $DIR/suggestions.rs:12:1 | LL | #[no_mangle] | ------------ help: remove this attribute @@ -66,7 +66,7 @@ LL | pub fn defiant(_t: T) {} = note: `#[warn(no_mangle_generic_items)]` on by default warning: the `warp_factor:` in this pattern is redundant - --> $DIR/suggestions.rs:57:23 + --> $DIR/suggestions.rs:61:23 | LL | Equinox { warp_factor: warp_factor } => {} | ^^^^^^^^^^^^^^^^^^^^^^^^ help: use shorthand field pattern: `warp_factor` @@ -74,7 +74,7 @@ LL | Equinox { warp_factor: warp_factor } => {} = note: `#[warn(non_shorthand_field_patterns)]` on by default error: const items should never be `#[no_mangle]` - --> $DIR/suggestions.rs:21:18 + --> $DIR/suggestions.rs:22:18 | LL | #[no_mangle] pub const DAUNTLESS: bool = true; | ---------^^^^^^^^^^^^^^^^^^^^^^^^ @@ -82,7 +82,7 @@ LL | #[no_mangle] pub const DAUNTLESS: bool = true; | help: try a static value: `pub static` warning: functions generic over types or consts must be mangled - --> $DIR/suggestions.rs:24:18 + --> $DIR/suggestions.rs:26:18 | LL | #[no_mangle] pub fn val_jean() {} | ------------ ^^^^^^^^^^^^^^^^^^^^^^^ @@ -90,7 +90,7 @@ LL | #[no_mangle] pub fn val_jean() {} | help: remove this attribute error: const items should never be `#[no_mangle]` - --> $DIR/suggestions.rs:29:18 + --> $DIR/suggestions.rs:31:18 | LL | #[no_mangle] pub(crate) const VETAR: bool = true; | ----------------^^^^^^^^^^^^^^^^^^^^ @@ -98,7 +98,7 @@ LL | #[no_mangle] pub(crate) const VETAR: bool = true; | help: try a static value: `pub static` warning: functions generic over types or consts must be mangled - --> $DIR/suggestions.rs:32:18 + --> $DIR/suggestions.rs:35:18 | LL | #[no_mangle] pub(crate) fn crossfield() {} | ------------ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ diff --git a/src/test/ui/lint/unused_braces.fixed b/src/test/ui/lint/unused_braces.fixed new file mode 100644 index 0000000000000..c0225911c6ed0 --- /dev/null +++ b/src/test/ui/lint/unused_braces.fixed @@ -0,0 +1,53 @@ +// check-pass +// run-rustfix + +#![warn(unused_braces, unused_parens)] +#![allow(unreachable_code, unused_unsafe)] // for rustfix + +fn consume(_: T) {} + +fn main() { + let _ = 7; + //~^WARN unnecessary parentheses + + // Do not emit a lint in these cases, + // as we have to be careful with + // `ref` patterns. + { + let _ = { 7 }; + + if let 7 = { 7 } { } + + match { 7 } { + _ => (), + } + } + + if true { + //~^ WARN unnecessary braces + } + + while false { + //~^ WARN unnecessary braces + } + + let _: [u8; 3 ]; + //~^ WARN unnecessary braces + + consume( 7 ); + //~^ WARN unnecessary braces + + // Do not emit lint for multiline blocks. + let _ = { + 7 + }; + + // Do not emit lint for unsafe blocks. + let _ = unsafe { 7 }; + + // Do not emit lint, as the `{` would then + // be parsed as part of the `return`. + if { return } { + + } +} diff --git a/src/test/ui/lint/unused_braces.rs b/src/test/ui/lint/unused_braces.rs index 952398ef0685b..5ca4811fc32d8 100644 --- a/src/test/ui/lint/unused_braces.rs +++ b/src/test/ui/lint/unused_braces.rs @@ -1,5 +1,8 @@ // check-pass +// run-rustfix + #![warn(unused_braces, unused_parens)] +#![allow(unreachable_code, unused_unsafe)] // for rustfix fn consume(_: T) {} diff --git a/src/test/ui/lint/unused_braces.stderr b/src/test/ui/lint/unused_braces.stderr index 541d64b3e2a5d..8fa5dfde61db0 100644 --- a/src/test/ui/lint/unused_braces.stderr +++ b/src/test/ui/lint/unused_braces.stderr @@ -1,41 +1,41 @@ warning: unnecessary parentheses around assigned value - --> $DIR/unused_braces.rs:7:13 + --> $DIR/unused_braces.rs:10:13 | LL | let _ = (7); | ^^^ help: remove these parentheses | note: the lint level is defined here - --> $DIR/unused_braces.rs:2:24 + --> $DIR/unused_braces.rs:4:24 | LL | #![warn(unused_braces, unused_parens)] | ^^^^^^^^^^^^^ warning: unnecessary braces around `if` condition - --> $DIR/unused_braces.rs:23:8 + --> $DIR/unused_braces.rs:26:8 | LL | if { true } { | ^^^^^^^^ help: remove these braces | note: the lint level is defined here - --> $DIR/unused_braces.rs:2:9 + --> $DIR/unused_braces.rs:4:9 | LL | #![warn(unused_braces, unused_parens)] | ^^^^^^^^^^^^^ warning: unnecessary braces around `while` condition - --> $DIR/unused_braces.rs:27:11 + --> $DIR/unused_braces.rs:30:11 | LL | while { false } { | ^^^^^^^^^ help: remove these braces warning: unnecessary braces around const expression - --> $DIR/unused_braces.rs:31:17 + --> $DIR/unused_braces.rs:34:17 | LL | let _: [u8; { 3 }]; | ^^^^^ help: remove these braces warning: unnecessary braces around function argument - --> $DIR/unused_braces.rs:34:13 + --> $DIR/unused_braces.rs:37:13 | LL | consume({ 7 }); | ^^^^^ help: remove these braces diff --git a/src/test/ui/lint/unused_braces_borrow.fixed b/src/test/ui/lint/unused_braces_borrow.fixed new file mode 100644 index 0000000000000..25950334549f9 --- /dev/null +++ b/src/test/ui/lint/unused_braces_borrow.fixed @@ -0,0 +1,26 @@ +// check-pass +// run-rustfix + +#![warn(unused_braces)] + +// changing `&{ expr }` to `&expr` changes the semantic of the program +// so we should not warn this case + +#[repr(packed)] +pub struct A { + pub a: u8, + pub b: u32, +} + +fn consume(_: T) {} + +fn main() { + let a = A { + a: 42, + b: 1729, + }; + + consume(&{ a.b }); + consume( a.b ); + //~^ WARN unnecessary braces +} diff --git a/src/test/ui/lint/unused_braces_borrow.rs b/src/test/ui/lint/unused_braces_borrow.rs index d0b059744e1fd..b7c529d73b94e 100644 --- a/src/test/ui/lint/unused_braces_borrow.rs +++ b/src/test/ui/lint/unused_braces_borrow.rs @@ -1,13 +1,15 @@ // check-pass +// run-rustfix + #![warn(unused_braces)] // changing `&{ expr }` to `&expr` changes the semantic of the program // so we should not warn this case #[repr(packed)] -struct A { - a: u8, - b: u32, +pub struct A { + pub a: u8, + pub b: u32, } fn consume(_: T) {} diff --git a/src/test/ui/lint/unused_braces_borrow.stderr b/src/test/ui/lint/unused_braces_borrow.stderr index 187fb9a212e0b..f018c46fcd3c6 100644 --- a/src/test/ui/lint/unused_braces_borrow.stderr +++ b/src/test/ui/lint/unused_braces_borrow.stderr @@ -1,11 +1,11 @@ warning: unnecessary braces around function argument - --> $DIR/unused_braces_borrow.rs:22:13 + --> $DIR/unused_braces_borrow.rs:24:13 | LL | consume({ a.b }); | ^^^^^^^ help: remove these braces | note: the lint level is defined here - --> $DIR/unused_braces_borrow.rs:2:9 + --> $DIR/unused_braces_borrow.rs:4:9 | LL | #![warn(unused_braces)] | ^^^^^^^^^^^^^ diff --git a/src/test/ui/nll/capture-mut-ref.fixed b/src/test/ui/nll/capture-mut-ref.fixed new file mode 100644 index 0000000000000..639de2813a90a --- /dev/null +++ b/src/test/ui/nll/capture-mut-ref.fixed @@ -0,0 +1,16 @@ +// run-rustfix + +// Check that capturing a mutable reference by move and assigning to its +// referent doesn't make the unused mut lint think that it is mutable. + +#![deny(unused_mut)] + +pub fn mutable_upvar() { + let x = &mut 0; + //~^ ERROR + move || { + *x = 1; + }; +} + +fn main() {} diff --git a/src/test/ui/nll/capture-mut-ref.rs b/src/test/ui/nll/capture-mut-ref.rs index 9d2624a9d6fa6..89f49e1ea5186 100644 --- a/src/test/ui/nll/capture-mut-ref.rs +++ b/src/test/ui/nll/capture-mut-ref.rs @@ -1,9 +1,11 @@ +// run-rustfix + // Check that capturing a mutable reference by move and assigning to its // referent doesn't make the unused mut lint think that it is mutable. #![deny(unused_mut)] -fn mutable_upvar() { +pub fn mutable_upvar() { let mut x = &mut 0; //~^ ERROR move || { diff --git a/src/test/ui/nll/capture-mut-ref.stderr b/src/test/ui/nll/capture-mut-ref.stderr index 95d8e874a68d4..4898d569235e7 100644 --- a/src/test/ui/nll/capture-mut-ref.stderr +++ b/src/test/ui/nll/capture-mut-ref.stderr @@ -1,5 +1,5 @@ error: variable does not need to be mutable - --> $DIR/capture-mut-ref.rs:7:9 + --> $DIR/capture-mut-ref.rs:9:9 | LL | let mut x = &mut 0; | ----^ @@ -7,7 +7,7 @@ LL | let mut x = &mut 0; | help: remove this `mut` | note: the lint level is defined here - --> $DIR/capture-mut-ref.rs:4:9 + --> $DIR/capture-mut-ref.rs:6:9 | LL | #![deny(unused_mut)] | ^^^^^^^^^^ diff --git a/src/test/ui/nll/issue-61424.fixed b/src/test/ui/nll/issue-61424.fixed new file mode 100644 index 0000000000000..63e00c1722e45 --- /dev/null +++ b/src/test/ui/nll/issue-61424.fixed @@ -0,0 +1,9 @@ +// run-rustfix + +#![deny(unused_mut)] + +fn main() { + let x; //~ ERROR: variable does not need to be mutable + x = String::new(); + dbg!(x); +} diff --git a/src/test/ui/nll/issue-61424.rs b/src/test/ui/nll/issue-61424.rs index 44c8e9f7256f5..3b64996c27b07 100644 --- a/src/test/ui/nll/issue-61424.rs +++ b/src/test/ui/nll/issue-61424.rs @@ -1,3 +1,5 @@ +// run-rustfix + #![deny(unused_mut)] fn main() { diff --git a/src/test/ui/nll/issue-61424.stderr b/src/test/ui/nll/issue-61424.stderr index 41dd7254d75a3..6de6b7f3abd0b 100644 --- a/src/test/ui/nll/issue-61424.stderr +++ b/src/test/ui/nll/issue-61424.stderr @@ -1,5 +1,5 @@ error: variable does not need to be mutable - --> $DIR/issue-61424.rs:4:9 + --> $DIR/issue-61424.rs:6:9 | LL | let mut x; | ----^ @@ -7,7 +7,7 @@ LL | let mut x; | help: remove this `mut` | note: the lint level is defined here - --> $DIR/issue-61424.rs:1:9 + --> $DIR/issue-61424.rs:3:9 | LL | #![deny(unused_mut)] | ^^^^^^^^^^ diff --git a/src/test/ui/nll/unused-mut-issue-50343.fixed b/src/test/ui/nll/unused-mut-issue-50343.fixed new file mode 100644 index 0000000000000..5632de1cd34de --- /dev/null +++ b/src/test/ui/nll/unused-mut-issue-50343.fixed @@ -0,0 +1,9 @@ +// run-rustfix + +#![deny(unused_mut)] +#![allow(unused_variables)] // for rustfix + +fn main() { + vec![(42, 22)].iter().map(|(x, _y)| ()).count(); + //~^ ERROR: variable does not need to be mutable +} diff --git a/src/test/ui/nll/unused-mut-issue-50343.rs b/src/test/ui/nll/unused-mut-issue-50343.rs index da0d9229c1262..c849ac8c79e43 100644 --- a/src/test/ui/nll/unused-mut-issue-50343.rs +++ b/src/test/ui/nll/unused-mut-issue-50343.rs @@ -1,4 +1,7 @@ +// run-rustfix + #![deny(unused_mut)] +#![allow(unused_variables)] // for rustfix fn main() { vec![(42, 22)].iter().map(|(mut x, _y)| ()).count(); diff --git a/src/test/ui/nll/unused-mut-issue-50343.stderr b/src/test/ui/nll/unused-mut-issue-50343.stderr index c86981a8dff15..cb02d76205c7f 100644 --- a/src/test/ui/nll/unused-mut-issue-50343.stderr +++ b/src/test/ui/nll/unused-mut-issue-50343.stderr @@ -1,5 +1,5 @@ error: variable does not need to be mutable - --> $DIR/unused-mut-issue-50343.rs:4:33 + --> $DIR/unused-mut-issue-50343.rs:7:33 | LL | vec![(42, 22)].iter().map(|(mut x, _y)| ()).count(); | ----^ @@ -7,7 +7,7 @@ LL | vec![(42, 22)].iter().map(|(mut x, _y)| ()).count(); | help: remove this `mut` | note: the lint level is defined here - --> $DIR/unused-mut-issue-50343.rs:1:9 + --> $DIR/unused-mut-issue-50343.rs:3:9 | LL | #![deny(unused_mut)] | ^^^^^^^^^^ diff --git a/src/test/ui/parser/bad-fn-ptr-qualifier.fixed b/src/test/ui/parser/bad-fn-ptr-qualifier.fixed new file mode 100644 index 0000000000000..ad8e718cf88a5 --- /dev/null +++ b/src/test/ui/parser/bad-fn-ptr-qualifier.fixed @@ -0,0 +1,26 @@ +// run-rustfix +// edition:2018 +// Most of items are taken from ./recover-const-async-fn-ptr.rs but this is able to apply rustfix. + +pub type T0 = fn(); //~ ERROR an `fn` pointer type cannot be `const` +pub type T1 = extern "C" fn(); //~ ERROR an `fn` pointer type cannot be `const` +pub type T2 = unsafe extern fn(); //~ ERROR an `fn` pointer type cannot be `const` +pub type T3 = fn(); //~ ERROR an `fn` pointer type cannot be `async` +pub type T4 = extern fn(); //~ ERROR an `fn` pointer type cannot be `async` +pub type T5 = unsafe extern "C" fn(); //~ ERROR an `fn` pointer type cannot be `async` +pub type T6 = unsafe extern "C" fn(); +//~^ ERROR an `fn` pointer type cannot be `const` +//~| ERROR an `fn` pointer type cannot be `async` + +pub type FTT0 = for<'a> fn(); //~ ERROR an `fn` pointer type cannot be `const` +pub type FTT1 = for<'a> extern "C" fn(); //~ ERROR an `fn` pointer type cannot be `const` +pub type FTT2 = for<'a> unsafe extern fn(); //~ ERROR an `fn` pointer type cannot be `const` +pub type FTT3 = for<'a> fn(); //~ ERROR an `fn` pointer type cannot be `async` +pub type FTT4 = for<'a> extern fn(); //~ ERROR an `fn` pointer type cannot be `async` +pub type FTT5 = for<'a> unsafe extern "C" fn(); +//~^ ERROR an `fn` pointer type cannot be `async` +pub type FTT6 = for<'a> unsafe extern "C" fn(); +//~^ ERROR an `fn` pointer type cannot be `const` +//~| ERROR an `fn` pointer type cannot be `async` + +fn main() {} diff --git a/src/test/ui/parser/bad-fn-ptr-qualifier.rs b/src/test/ui/parser/bad-fn-ptr-qualifier.rs new file mode 100644 index 0000000000000..c04813dadff7b --- /dev/null +++ b/src/test/ui/parser/bad-fn-ptr-qualifier.rs @@ -0,0 +1,26 @@ +// run-rustfix +// edition:2018 +// Most of items are taken from ./recover-const-async-fn-ptr.rs but this is able to apply rustfix. + +pub type T0 = const fn(); //~ ERROR an `fn` pointer type cannot be `const` +pub type T1 = const extern "C" fn(); //~ ERROR an `fn` pointer type cannot be `const` +pub type T2 = const unsafe extern fn(); //~ ERROR an `fn` pointer type cannot be `const` +pub type T3 = async fn(); //~ ERROR an `fn` pointer type cannot be `async` +pub type T4 = async extern fn(); //~ ERROR an `fn` pointer type cannot be `async` +pub type T5 = async unsafe extern "C" fn(); //~ ERROR an `fn` pointer type cannot be `async` +pub type T6 = const async unsafe extern "C" fn(); +//~^ ERROR an `fn` pointer type cannot be `const` +//~| ERROR an `fn` pointer type cannot be `async` + +pub type FTT0 = for<'a> const fn(); //~ ERROR an `fn` pointer type cannot be `const` +pub type FTT1 = for<'a> const extern "C" fn(); //~ ERROR an `fn` pointer type cannot be `const` +pub type FTT2 = for<'a> const unsafe extern fn(); //~ ERROR an `fn` pointer type cannot be `const` +pub type FTT3 = for<'a> async fn(); //~ ERROR an `fn` pointer type cannot be `async` +pub type FTT4 = for<'a> async extern fn(); //~ ERROR an `fn` pointer type cannot be `async` +pub type FTT5 = for<'a> async unsafe extern "C" fn(); +//~^ ERROR an `fn` pointer type cannot be `async` +pub type FTT6 = for<'a> const async unsafe extern "C" fn(); +//~^ ERROR an `fn` pointer type cannot be `const` +//~| ERROR an `fn` pointer type cannot be `async` + +fn main() {} diff --git a/src/test/ui/parser/bad-fn-ptr-qualifier.stderr b/src/test/ui/parser/bad-fn-ptr-qualifier.stderr new file mode 100644 index 0000000000000..265e31329ca54 --- /dev/null +++ b/src/test/ui/parser/bad-fn-ptr-qualifier.stderr @@ -0,0 +1,146 @@ +error: an `fn` pointer type cannot be `const` + --> $DIR/bad-fn-ptr-qualifier.rs:5:15 + | +LL | pub type T0 = const fn(); + | -----^^^^^ + | | + | `const` because of this + | help: remove the `const` qualifier + +error: an `fn` pointer type cannot be `const` + --> $DIR/bad-fn-ptr-qualifier.rs:6:15 + | +LL | pub type T1 = const extern "C" fn(); + | -----^^^^^^^^^^^^^^^^ + | | + | `const` because of this + | help: remove the `const` qualifier + +error: an `fn` pointer type cannot be `const` + --> $DIR/bad-fn-ptr-qualifier.rs:7:15 + | +LL | pub type T2 = const unsafe extern fn(); + | -----^^^^^^^^^^^^^^^^^^^ + | | + | `const` because of this + | help: remove the `const` qualifier + +error: an `fn` pointer type cannot be `async` + --> $DIR/bad-fn-ptr-qualifier.rs:8:15 + | +LL | pub type T3 = async fn(); + | -----^^^^^ + | | + | `async` because of this + | help: remove the `async` qualifier + +error: an `fn` pointer type cannot be `async` + --> $DIR/bad-fn-ptr-qualifier.rs:9:15 + | +LL | pub type T4 = async extern fn(); + | -----^^^^^^^^^^^^ + | | + | `async` because of this + | help: remove the `async` qualifier + +error: an `fn` pointer type cannot be `async` + --> $DIR/bad-fn-ptr-qualifier.rs:10:15 + | +LL | pub type T5 = async unsafe extern "C" fn(); + | -----^^^^^^^^^^^^^^^^^^^^^^^ + | | + | `async` because of this + | help: remove the `async` qualifier + +error: an `fn` pointer type cannot be `const` + --> $DIR/bad-fn-ptr-qualifier.rs:11:15 + | +LL | pub type T6 = const async unsafe extern "C" fn(); + | -----^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | `const` because of this + | help: remove the `const` qualifier + +error: an `fn` pointer type cannot be `async` + --> $DIR/bad-fn-ptr-qualifier.rs:11:15 + | +LL | pub type T6 = const async unsafe extern "C" fn(); + | ^^^^^^-----^^^^^^^^^^^^^^^^^^^^^^^ + | | + | `async` because of this + | help: remove the `async` qualifier + +error: an `fn` pointer type cannot be `const` + --> $DIR/bad-fn-ptr-qualifier.rs:15:17 + | +LL | pub type FTT0 = for<'a> const fn(); + | ^^^^^^^^-----^^^^^ + | | + | `const` because of this + | help: remove the `const` qualifier + +error: an `fn` pointer type cannot be `const` + --> $DIR/bad-fn-ptr-qualifier.rs:16:17 + | +LL | pub type FTT1 = for<'a> const extern "C" fn(); + | ^^^^^^^^-----^^^^^^^^^^^^^^^^ + | | + | `const` because of this + | help: remove the `const` qualifier + +error: an `fn` pointer type cannot be `const` + --> $DIR/bad-fn-ptr-qualifier.rs:17:17 + | +LL | pub type FTT2 = for<'a> const unsafe extern fn(); + | ^^^^^^^^-----^^^^^^^^^^^^^^^^^^^ + | | + | `const` because of this + | help: remove the `const` qualifier + +error: an `fn` pointer type cannot be `async` + --> $DIR/bad-fn-ptr-qualifier.rs:18:17 + | +LL | pub type FTT3 = for<'a> async fn(); + | ^^^^^^^^-----^^^^^ + | | + | `async` because of this + | help: remove the `async` qualifier + +error: an `fn` pointer type cannot be `async` + --> $DIR/bad-fn-ptr-qualifier.rs:19:17 + | +LL | pub type FTT4 = for<'a> async extern fn(); + | ^^^^^^^^-----^^^^^^^^^^^^ + | | + | `async` because of this + | help: remove the `async` qualifier + +error: an `fn` pointer type cannot be `async` + --> $DIR/bad-fn-ptr-qualifier.rs:20:17 + | +LL | pub type FTT5 = for<'a> async unsafe extern "C" fn(); + | ^^^^^^^^-----^^^^^^^^^^^^^^^^^^^^^^^ + | | + | `async` because of this + | help: remove the `async` qualifier + +error: an `fn` pointer type cannot be `const` + --> $DIR/bad-fn-ptr-qualifier.rs:22:17 + | +LL | pub type FTT6 = for<'a> const async unsafe extern "C" fn(); + | ^^^^^^^^-----^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | | + | `const` because of this + | help: remove the `const` qualifier + +error: an `fn` pointer type cannot be `async` + --> $DIR/bad-fn-ptr-qualifier.rs:22:17 + | +LL | pub type FTT6 = for<'a> const async unsafe extern "C" fn(); + | ^^^^^^^^^^^^^^-----^^^^^^^^^^^^^^^^^^^^^^^ + | | + | `async` because of this + | help: remove the `async` qualifier + +error: aborting due to 16 previous errors + diff --git a/src/test/ui/parser/if-in-in.fixed b/src/test/ui/parser/if-in-in.fixed new file mode 100644 index 0000000000000..0bb88c55936f0 --- /dev/null +++ b/src/test/ui/parser/if-in-in.fixed @@ -0,0 +1,7 @@ +// run-rustfix + +fn main() { + for i in 1..2 { //~ ERROR expected iterable, found keyword `in` + println!("{}", i); + } +} diff --git a/src/test/ui/parser/if-in-in.rs b/src/test/ui/parser/if-in-in.rs index 212378c28665b..6c0986fe1ba5f 100644 --- a/src/test/ui/parser/if-in-in.rs +++ b/src/test/ui/parser/if-in-in.rs @@ -1,3 +1,5 @@ +// run-rustfix + fn main() { for i in in 1..2 { //~ ERROR expected iterable, found keyword `in` println!("{}", i); diff --git a/src/test/ui/parser/if-in-in.stderr b/src/test/ui/parser/if-in-in.stderr index 1adb4429ec7d0..0e69bc4b2ce53 100644 --- a/src/test/ui/parser/if-in-in.stderr +++ b/src/test/ui/parser/if-in-in.stderr @@ -1,5 +1,5 @@ error: expected iterable, found keyword `in` - --> $DIR/if-in-in.rs:2:14 + --> $DIR/if-in-in.rs:4:14 | LL | for i in in 1..2 { | ---^^ diff --git a/src/test/ui/parser/issue-10392-2.fixed b/src/test/ui/parser/issue-10392-2.fixed new file mode 100644 index 0000000000000..3386fac17dfd7 --- /dev/null +++ b/src/test/ui/parser/issue-10392-2.fixed @@ -0,0 +1,9 @@ +// run-rustfix + +pub struct A { pub foo: isize } + +fn a() -> A { panic!() } + +fn main() { + let A { .. } = a(); //~ ERROR: expected `}` +} diff --git a/src/test/ui/parser/issue-10392-2.rs b/src/test/ui/parser/issue-10392-2.rs index 3b5e3199a8ab3..30628ae31c3bd 100644 --- a/src/test/ui/parser/issue-10392-2.rs +++ b/src/test/ui/parser/issue-10392-2.rs @@ -1,4 +1,6 @@ -struct A { foo: isize } +// run-rustfix + +pub struct A { pub foo: isize } fn a() -> A { panic!() } diff --git a/src/test/ui/parser/issue-10392-2.stderr b/src/test/ui/parser/issue-10392-2.stderr index ccc5dd938b5fd..4154ecfeb71c3 100644 --- a/src/test/ui/parser/issue-10392-2.stderr +++ b/src/test/ui/parser/issue-10392-2.stderr @@ -1,5 +1,5 @@ error: expected `}`, found `,` - --> $DIR/issue-10392-2.rs:6:15 + --> $DIR/issue-10392-2.rs:8:15 | LL | let A { .., } = a(); | --^ diff --git a/src/test/ui/parser/issue-3036.fixed b/src/test/ui/parser/issue-3036.fixed new file mode 100644 index 0000000000000..e5d5622e6fc00 --- /dev/null +++ b/src/test/ui/parser/issue-3036.fixed @@ -0,0 +1,7 @@ +// run-rustfix + +// Testing that semicolon tokens are printed correctly in errors + +fn main() { + let _x = 3; //~ ERROR: expected `;` +} diff --git a/src/test/ui/parser/issue-3036.rs b/src/test/ui/parser/issue-3036.rs index 6a8b67fefa780..2f76fb99b2206 100644 --- a/src/test/ui/parser/issue-3036.rs +++ b/src/test/ui/parser/issue-3036.rs @@ -1,6 +1,7 @@ +// run-rustfix + // Testing that semicolon tokens are printed correctly in errors -fn main() -{ - let x = 3 //~ ERROR: expected `;` +fn main() { + let _x = 3 //~ ERROR: expected `;` } diff --git a/src/test/ui/parser/issue-3036.stderr b/src/test/ui/parser/issue-3036.stderr index e5f5a7d8968dc..e02223931c114 100644 --- a/src/test/ui/parser/issue-3036.stderr +++ b/src/test/ui/parser/issue-3036.stderr @@ -1,8 +1,8 @@ error: expected `;`, found `}` - --> $DIR/issue-3036.rs:5:14 + --> $DIR/issue-3036.rs:6:15 | -LL | let x = 3 - | ^ help: add `;` here +LL | let _x = 3 + | ^ help: add `;` here LL | } | - unexpected token diff --git a/src/test/ui/parser/issue-67146-negative-outlives-bound-syntactic-fail.fixed b/src/test/ui/parser/issue-67146-negative-outlives-bound-syntactic-fail.fixed new file mode 100644 index 0000000000000..95019b2786925 --- /dev/null +++ b/src/test/ui/parser/issue-67146-negative-outlives-bound-syntactic-fail.fixed @@ -0,0 +1,14 @@ +// run-rustfix + +// In this regression test for #67146, we check that the +// negative outlives bound `!'a` is rejected by the parser. +// This regression was first introduced in PR #57364. + +fn main() {} + +pub fn f1() {} +//~^ ERROR negative bounds are not supported +pub fn f2<'a, T: Ord>() {} +//~^ ERROR negative bounds are not supported +pub fn f3<'a, T: Ord>() {} +//~^ ERROR negative bounds are not supported diff --git a/src/test/ui/parser/issue-67146-negative-outlives-bound-syntactic-fail.rs b/src/test/ui/parser/issue-67146-negative-outlives-bound-syntactic-fail.rs index 5a109ba7c6894..82f54f8faa98c 100644 --- a/src/test/ui/parser/issue-67146-negative-outlives-bound-syntactic-fail.rs +++ b/src/test/ui/parser/issue-67146-negative-outlives-bound-syntactic-fail.rs @@ -1,12 +1,14 @@ +// run-rustfix + // In this regression test for #67146, we check that the // negative outlives bound `!'a` is rejected by the parser. // This regression was first introduced in PR #57364. fn main() {} -fn f1() {} +pub fn f1() {} //~^ ERROR negative bounds are not supported -fn f2<'a, T: Ord + !'a>() {} +pub fn f2<'a, T: Ord + !'a>() {} //~^ ERROR negative bounds are not supported -fn f3<'a, T: !'a + Ord>() {} +pub fn f3<'a, T: !'a + Ord>() {} //~^ ERROR negative bounds are not supported diff --git a/src/test/ui/parser/issue-67146-negative-outlives-bound-syntactic-fail.stderr b/src/test/ui/parser/issue-67146-negative-outlives-bound-syntactic-fail.stderr index 4dc0634730442..a4a422948aca6 100644 --- a/src/test/ui/parser/issue-67146-negative-outlives-bound-syntactic-fail.stderr +++ b/src/test/ui/parser/issue-67146-negative-outlives-bound-syntactic-fail.stderr @@ -1,20 +1,20 @@ error: negative bounds are not supported - --> $DIR/issue-67146-negative-outlives-bound-syntactic-fail.rs:7:8 + --> $DIR/issue-67146-negative-outlives-bound-syntactic-fail.rs:9:12 | -LL | fn f1() {} - | ^^^^^^^^^^ negative bounds are not supported +LL | pub fn f1() {} + | ^^^^^^^^^^ negative bounds are not supported error: negative bounds are not supported - --> $DIR/issue-67146-negative-outlives-bound-syntactic-fail.rs:9:18 + --> $DIR/issue-67146-negative-outlives-bound-syntactic-fail.rs:11:22 | -LL | fn f2<'a, T: Ord + !'a>() {} - | ^^^^^ negative bounds are not supported +LL | pub fn f2<'a, T: Ord + !'a>() {} + | ^^^^^ negative bounds are not supported error: negative bounds are not supported - --> $DIR/issue-67146-negative-outlives-bound-syntactic-fail.rs:11:12 + --> $DIR/issue-67146-negative-outlives-bound-syntactic-fail.rs:13:16 | -LL | fn f3<'a, T: !'a + Ord>() {} - | ^^^^^ negative bounds are not supported +LL | pub fn f3<'a, T: !'a + Ord>() {} + | ^^^^^ negative bounds are not supported error: aborting due to 3 previous errors diff --git a/src/test/ui/parser/issue-70388-without-witness.fixed b/src/test/ui/parser/issue-70388-without-witness.fixed new file mode 100644 index 0000000000000..464e78fd03595 --- /dev/null +++ b/src/test/ui/parser/issue-70388-without-witness.fixed @@ -0,0 +1,9 @@ +// run-rustfix +// This is for checking if we can apply suggestions as-is. + +pub struct Foo(i32); + +fn main() { + let Foo(..) = Foo(0); //~ ERROR unexpected `...` + let [_, .., _] = [0, 1]; //~ ERROR unexpected `...` +} diff --git a/src/test/ui/parser/issue-70388-without-witness.rs b/src/test/ui/parser/issue-70388-without-witness.rs new file mode 100644 index 0000000000000..9e35e4c38aa87 --- /dev/null +++ b/src/test/ui/parser/issue-70388-without-witness.rs @@ -0,0 +1,9 @@ +// run-rustfix +// This is for checking if we can apply suggestions as-is. + +pub struct Foo(i32); + +fn main() { + let Foo(...) = Foo(0); //~ ERROR unexpected `...` + let [_, ..., _] = [0, 1]; //~ ERROR unexpected `...` +} diff --git a/src/test/ui/parser/issue-70388-without-witness.stderr b/src/test/ui/parser/issue-70388-without-witness.stderr new file mode 100644 index 0000000000000..b750ad4c626d6 --- /dev/null +++ b/src/test/ui/parser/issue-70388-without-witness.stderr @@ -0,0 +1,20 @@ +error: unexpected `...` + --> $DIR/issue-70388-without-witness.rs:7:13 + | +LL | let Foo(...) = Foo(0); + | ^^^ + | | + | not a valid pattern + | help: for a rest pattern, use `..` instead of `...` + +error: unexpected `...` + --> $DIR/issue-70388-without-witness.rs:8:13 + | +LL | let [_, ..., _] = [0, 1]; + | ^^^ + | | + | not a valid pattern + | help: for a rest pattern, use `..` instead of `...` + +error: aborting due to 2 previous errors + diff --git a/src/test/ui/parser/let-binop.fixed b/src/test/ui/parser/let-binop.fixed new file mode 100644 index 0000000000000..93f7f97b04fb7 --- /dev/null +++ b/src/test/ui/parser/let-binop.fixed @@ -0,0 +1,10 @@ +// run-rustfix + +fn main() { + let a: i8 = 1; //~ ERROR can't reassign to an uninitialized variable + let _ = a; + let b = 1; //~ ERROR can't reassign to an uninitialized variable + let _ = b; + let c = 1; //~ ERROR can't reassign to an uninitialized variable + let _ = c; +} diff --git a/src/test/ui/parser/let-binop.rs b/src/test/ui/parser/let-binop.rs index 7f58f5df2d412..2adbceae5d3c4 100644 --- a/src/test/ui/parser/let-binop.rs +++ b/src/test/ui/parser/let-binop.rs @@ -1,3 +1,5 @@ +// run-rustfix + fn main() { let a: i8 *= 1; //~ ERROR can't reassign to an uninitialized variable let _ = a; diff --git a/src/test/ui/parser/let-binop.stderr b/src/test/ui/parser/let-binop.stderr index 71431499ac70b..90295854a2d2d 100644 --- a/src/test/ui/parser/let-binop.stderr +++ b/src/test/ui/parser/let-binop.stderr @@ -1,17 +1,17 @@ error: can't reassign to an uninitialized variable - --> $DIR/let-binop.rs:2:15 + --> $DIR/let-binop.rs:4:15 | LL | let a: i8 *= 1; | ^^ help: initialize the variable error: can't reassign to an uninitialized variable - --> $DIR/let-binop.rs:4:11 + --> $DIR/let-binop.rs:6:11 | LL | let b += 1; | ^^ help: initialize the variable error: can't reassign to an uninitialized variable - --> $DIR/let-binop.rs:6:11 + --> $DIR/let-binop.rs:8:11 | LL | let c *= 1; | ^^ help: initialize the variable diff --git a/src/test/ui/parser/match-refactor-to-expr.fixed b/src/test/ui/parser/match-refactor-to-expr.fixed new file mode 100644 index 0000000000000..f21024235a591 --- /dev/null +++ b/src/test/ui/parser/match-refactor-to-expr.fixed @@ -0,0 +1,12 @@ +// run-rustfix + +fn main() { + let foo = + //~ NOTE while parsing this match expression + Some(4).unwrap_or(5) + //~^ NOTE expected one of `.`, `?`, `{`, or an operator + ; //~ NOTE unexpected token + //~^ ERROR expected one of `.`, `?`, `{`, or an operator, found `;` + + println!("{}", foo) +} diff --git a/src/test/ui/parser/match-refactor-to-expr.rs b/src/test/ui/parser/match-refactor-to-expr.rs index e10ebf2e2d60a..e02d74e2f7eac 100644 --- a/src/test/ui/parser/match-refactor-to-expr.rs +++ b/src/test/ui/parser/match-refactor-to-expr.rs @@ -1,7 +1,9 @@ +// run-rustfix + fn main() { let foo = match //~ NOTE while parsing this match expression - Some(4).unwrap_or_else(5) + Some(4).unwrap_or(5) //~^ NOTE expected one of `.`, `?`, `{`, or an operator ; //~ NOTE unexpected token //~^ ERROR expected one of `.`, `?`, `{`, or an operator, found `;` diff --git a/src/test/ui/parser/match-refactor-to-expr.stderr b/src/test/ui/parser/match-refactor-to-expr.stderr index 5cbf0232bc31e..15107ab9a258b 100644 --- a/src/test/ui/parser/match-refactor-to-expr.stderr +++ b/src/test/ui/parser/match-refactor-to-expr.stderr @@ -1,13 +1,13 @@ error: expected one of `.`, `?`, `{`, or an operator, found `;` - --> $DIR/match-refactor-to-expr.rs:6:9 + --> $DIR/match-refactor-to-expr.rs:8:9 | LL | match | ----- | | | while parsing this match expression | help: try removing this `match` -LL | Some(4).unwrap_or_else(5) - | - expected one of `.`, `?`, `{`, or an operator +LL | Some(4).unwrap_or(5) + | - expected one of `.`, `?`, `{`, or an operator LL | LL | ; | ^ unexpected token diff --git a/src/test/ui/parser/range_inclusive.fixed b/src/test/ui/parser/range_inclusive.fixed new file mode 100644 index 0000000000000..fe23880d1d48a --- /dev/null +++ b/src/test/ui/parser/range_inclusive.fixed @@ -0,0 +1,7 @@ +// run-rustfix +// Make sure that inclusive ranges with no end point don't parse. + +pub fn main() { + for _ in 1.. {} //~ERROR inclusive range with no end + //~^HELP use `..` instead +} diff --git a/src/test/ui/parser/range_inclusive.rs b/src/test/ui/parser/range_inclusive.rs index 7c3b906b47f9f..bc6d2413d2623 100644 --- a/src/test/ui/parser/range_inclusive.rs +++ b/src/test/ui/parser/range_inclusive.rs @@ -1,3 +1,4 @@ +// run-rustfix // Make sure that inclusive ranges with no end point don't parse. pub fn main() { diff --git a/src/test/ui/parser/range_inclusive.stderr b/src/test/ui/parser/range_inclusive.stderr index 1dd4799459681..8a91782639f45 100644 --- a/src/test/ui/parser/range_inclusive.stderr +++ b/src/test/ui/parser/range_inclusive.stderr @@ -1,5 +1,5 @@ error[E0586]: inclusive range with no end - --> $DIR/range_inclusive.rs:4:15 + --> $DIR/range_inclusive.rs:5:15 | LL | for _ in 1..= {} | ^^^ help: use `..` instead diff --git a/src/test/ui/parser/trait-object-lifetime-parens.rs b/src/test/ui/parser/trait-object-lifetime-parens.rs index 5a5c19f32e806..f44ebe5ba5bf2 100644 --- a/src/test/ui/parser/trait-object-lifetime-parens.rs +++ b/src/test/ui/parser/trait-object-lifetime-parens.rs @@ -6,6 +6,7 @@ fn f<'a, T: Trait + ('a)>() {} //~ ERROR parenthesized lifetime bounds are not s fn check<'a>() { let _: Box; //~ ERROR parenthesized lifetime bounds are not supported + // FIXME: It'd be great if we could add suggestion to the following case. let _: Box<('a) + Trait>; //~ ERROR lifetime in trait object type must be followed by `+` } diff --git a/src/test/ui/parser/trait-object-lifetime-parens.stderr b/src/test/ui/parser/trait-object-lifetime-parens.stderr index 1289c248275dc..9c7a9662c4024 100644 --- a/src/test/ui/parser/trait-object-lifetime-parens.stderr +++ b/src/test/ui/parser/trait-object-lifetime-parens.stderr @@ -11,7 +11,7 @@ LL | let _: Box; | ^^^^ help: remove the parentheses error: lifetime in trait object type must be followed by `+` - --> $DIR/trait-object-lifetime-parens.rs:9:17 + --> $DIR/trait-object-lifetime-parens.rs:10:17 | LL | let _: Box<('a) + Trait>; | ^^ diff --git a/src/test/ui/path-lookahead.fixed b/src/test/ui/path-lookahead.fixed new file mode 100644 index 0000000000000..928955630e9ff --- /dev/null +++ b/src/test/ui/path-lookahead.fixed @@ -0,0 +1,17 @@ +// run-pass +// run-rustfix + +#![allow(dead_code)] +#![warn(unused_parens)] + +// Parser test for #37765 + +fn with_parens(arg: T) -> String { + return ::to_string(&arg); //~WARN unnecessary parentheses around `return` value +} + +fn no_parens(arg: T) -> String { + return ::to_string(&arg); +} + +fn main() {} diff --git a/src/test/ui/path-lookahead.rs b/src/test/ui/path-lookahead.rs index 86bcb08de404e..d05c75fe8d8e0 100644 --- a/src/test/ui/path-lookahead.rs +++ b/src/test/ui/path-lookahead.rs @@ -1,17 +1,17 @@ // run-pass +// run-rustfix + #![allow(dead_code)] #![warn(unused_parens)] // Parser test for #37765 fn with_parens(arg: T) -> String { - return (::to_string(&arg)); //~WARN unnecessary parentheses around `return` value + return (::to_string(&arg)); //~WARN unnecessary parentheses around `return` value } fn no_parens(arg: T) -> String { - return ::to_string(&arg); + return ::to_string(&arg); } -fn main() { - -} +fn main() {} diff --git a/src/test/ui/path-lookahead.stderr b/src/test/ui/path-lookahead.stderr index 7a57b6100f380..dcf235a9e2774 100644 --- a/src/test/ui/path-lookahead.stderr +++ b/src/test/ui/path-lookahead.stderr @@ -1,11 +1,11 @@ warning: unnecessary parentheses around `return` value - --> $DIR/path-lookahead.rs:8:10 + --> $DIR/path-lookahead.rs:10:12 | -LL | return (::to_string(&arg)); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove these parentheses +LL | return (::to_string(&arg)); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove these parentheses | note: the lint level is defined here - --> $DIR/path-lookahead.rs:3:9 + --> $DIR/path-lookahead.rs:5:9 | LL | #![warn(unused_parens)] | ^^^^^^^^^^^^^ diff --git a/src/test/ui/pub/pub-ident-fn-2.fixed b/src/test/ui/pub/pub-ident-fn-2.fixed new file mode 100644 index 0000000000000..afd75a41f7b0f --- /dev/null +++ b/src/test/ui/pub/pub-ident-fn-2.fixed @@ -0,0 +1,10 @@ +// run-rustfix + +pub fn foo(_s: usize) { bar() } +//~^ ERROR missing `fn` for function definition + +fn bar() {} + +fn main() { + foo(2); +} diff --git a/src/test/ui/pub/pub-ident-fn-2.rs b/src/test/ui/pub/pub-ident-fn-2.rs index e1fc20c657730..e7b86a9098d16 100644 --- a/src/test/ui/pub/pub-ident-fn-2.rs +++ b/src/test/ui/pub/pub-ident-fn-2.rs @@ -1,6 +1,10 @@ -pub foo(s: usize) { bar() } +// run-rustfix + +pub foo(_s: usize) { bar() } //~^ ERROR missing `fn` for function definition +fn bar() {} + fn main() { foo(2); } diff --git a/src/test/ui/pub/pub-ident-fn-2.stderr b/src/test/ui/pub/pub-ident-fn-2.stderr index c44a5961565ab..b830b0e90098a 100644 --- a/src/test/ui/pub/pub-ident-fn-2.stderr +++ b/src/test/ui/pub/pub-ident-fn-2.stderr @@ -1,12 +1,12 @@ error: missing `fn` for function definition - --> $DIR/pub-ident-fn-2.rs:1:4 + --> $DIR/pub-ident-fn-2.rs:3:4 | -LL | pub foo(s: usize) { bar() } +LL | pub foo(_s: usize) { bar() } | ^ | help: add `fn` here to parse `foo` as a public function | -LL | pub fn foo(s: usize) { bar() } +LL | pub fn foo(_s: usize) { bar() } | ^^ error: aborting due to previous error diff --git a/src/test/ui/pub/pub-ident-fn-with-lifetime.fixed b/src/test/ui/pub/pub-ident-fn-with-lifetime.fixed new file mode 100644 index 0000000000000..e510ace5fc14c --- /dev/null +++ b/src/test/ui/pub/pub-ident-fn-with-lifetime.fixed @@ -0,0 +1,8 @@ +// run-rustfix + +pub fn foo<'a>(_s: &'a usize) -> bool { true } +//~^ ERROR missing `fn` for function definition + +fn main() { + foo(&2); +} diff --git a/src/test/ui/pub/pub-ident-fn-with-lifetime.rs b/src/test/ui/pub/pub-ident-fn-with-lifetime.rs index 84f7bdc1fb147..63e6eca151600 100644 --- a/src/test/ui/pub/pub-ident-fn-with-lifetime.rs +++ b/src/test/ui/pub/pub-ident-fn-with-lifetime.rs @@ -1,6 +1,8 @@ +// run-rustfix + pub foo<'a>(_s: &'a usize) -> bool { true } //~^ ERROR missing `fn` for function definition fn main() { - foo(2); + foo(&2); } diff --git a/src/test/ui/pub/pub-ident-fn-with-lifetime.stderr b/src/test/ui/pub/pub-ident-fn-with-lifetime.stderr index 90c78141adbf6..5b378df04b025 100644 --- a/src/test/ui/pub/pub-ident-fn-with-lifetime.stderr +++ b/src/test/ui/pub/pub-ident-fn-with-lifetime.stderr @@ -1,5 +1,5 @@ error: missing `fn` for function definition - --> $DIR/pub-ident-fn-with-lifetime.rs:1:4 + --> $DIR/pub-ident-fn-with-lifetime.rs:3:4 | LL | pub foo<'a>(_s: &'a usize) -> bool { true } | ^^^ diff --git a/src/test/ui/pub/pub-ident-struct.fixed b/src/test/ui/pub/pub-ident-struct.fixed new file mode 100644 index 0000000000000..58cde8fd6e0ca --- /dev/null +++ b/src/test/ui/pub/pub-ident-struct.fixed @@ -0,0 +1,6 @@ +// run-rustfix + +pub struct S { +//~^ ERROR missing `struct` for struct definition +} +fn main() {} diff --git a/src/test/ui/pub/pub-ident-struct.rs b/src/test/ui/pub/pub-ident-struct.rs index f2e6dfc77b6e0..3930e556e9a9c 100644 --- a/src/test/ui/pub/pub-ident-struct.rs +++ b/src/test/ui/pub/pub-ident-struct.rs @@ -1,3 +1,5 @@ +// run-rustfix + pub S { //~^ ERROR missing `struct` for struct definition } diff --git a/src/test/ui/pub/pub-ident-struct.stderr b/src/test/ui/pub/pub-ident-struct.stderr index efd7d1fe76a16..8af24904ef24c 100644 --- a/src/test/ui/pub/pub-ident-struct.stderr +++ b/src/test/ui/pub/pub-ident-struct.stderr @@ -1,5 +1,5 @@ error: missing `struct` for struct definition - --> $DIR/pub-ident-struct.rs:1:4 + --> $DIR/pub-ident-struct.rs:3:4 | LL | pub S { | ^ diff --git a/src/test/ui/range/range-inclusive-pattern-precedence.fixed b/src/test/ui/range/range-inclusive-pattern-precedence.fixed new file mode 100644 index 0000000000000..22ab6c755be2d --- /dev/null +++ b/src/test/ui/range/range-inclusive-pattern-precedence.fixed @@ -0,0 +1,20 @@ +// In expression, `&a..=b` is treated as `(&a)..=(b)` and `box a..=b` is +// `(box a)..=(b)`. In a pattern, however, `&a..=b` means `&(a..=b)`. This may +// lead to confusion. + +// run-rustfix + +#![warn(ellipsis_inclusive_range_patterns)] + +pub fn main() { + match &12 { + &(0..=9) => {} + //~^ WARN `...` range patterns are deprecated + //~| HELP use `..=` for an inclusive range + &(10 ..=15) => {} + //~^ ERROR the range pattern here has ambiguous interpretation + //~^^ HELP add parentheses to clarify the precedence + &(16..=20) => {} + _ => {} + } +} diff --git a/src/test/ui/range/range-inclusive-pattern-precedence.rs b/src/test/ui/range/range-inclusive-pattern-precedence.rs index fbafe1fe6ee12..f38a7920c94d6 100644 --- a/src/test/ui/range/range-inclusive-pattern-precedence.rs +++ b/src/test/ui/range/range-inclusive-pattern-precedence.rs @@ -1,13 +1,10 @@ // In expression, `&a..=b` is treated as `(&a)..=(b)` and `box a..=b` is // `(box a)..=(b)`. In a pattern, however, `&a..=b` means `&(a..=b)`. This may // lead to confusion. -// -// We are going to disallow `&a..=b` and `box a..=b` in a pattern. However, the -// older ... syntax is still allowed as a stability guarantee. -#![feature(box_patterns)] -#![warn(ellipsis_inclusive_range_patterns)] +// run-rustfix +#![warn(ellipsis_inclusive_range_patterns)] pub fn main() { match &12 { @@ -20,15 +17,4 @@ pub fn main() { &(16..=20) => {} _ => {} } - - match Box::new(12) { - box 0...9 => {} - //~^ WARN `...` range patterns are deprecated - //~| HELP use `..=` for an inclusive range - box 10..=15 => {} - //~^ ERROR the range pattern here has ambiguous interpretation - //~^^ HELP add parentheses to clarify the precedence - box (16..=20) => {} - _ => {} - } } diff --git a/src/test/ui/range/range-inclusive-pattern-precedence.stderr b/src/test/ui/range/range-inclusive-pattern-precedence.stderr index 3a4a514df7ade..853141969c20d 100644 --- a/src/test/ui/range/range-inclusive-pattern-precedence.stderr +++ b/src/test/ui/range/range-inclusive-pattern-precedence.stderr @@ -1,32 +1,20 @@ error: the range pattern here has ambiguous interpretation - --> $DIR/range-inclusive-pattern-precedence.rs:17:10 + --> $DIR/range-inclusive-pattern-precedence.rs:14:10 | LL | &10..=15 => {} | ^^^^^^^ help: add parentheses to clarify the precedence: `(10 ..=15)` -error: the range pattern here has ambiguous interpretation - --> $DIR/range-inclusive-pattern-precedence.rs:28:13 - | -LL | box 10..=15 => {} - | ^^^^^^^ help: add parentheses to clarify the precedence: `(10 ..=15)` - warning: `...` range patterns are deprecated - --> $DIR/range-inclusive-pattern-precedence.rs:14:9 + --> $DIR/range-inclusive-pattern-precedence.rs:11:9 | LL | &0...9 => {} | ^^^^^^ help: use `..=` for an inclusive range: `&(0..=9)` | note: the lint level is defined here - --> $DIR/range-inclusive-pattern-precedence.rs:9:9 + --> $DIR/range-inclusive-pattern-precedence.rs:7:9 | LL | #![warn(ellipsis_inclusive_range_patterns)] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -warning: `...` range patterns are deprecated - --> $DIR/range-inclusive-pattern-precedence.rs:25:14 - | -LL | box 0...9 => {} - | ^^^ help: use `..=` for an inclusive range - -error: aborting due to 2 previous errors; 2 warnings emitted +error: aborting due to previous error; 1 warning emitted diff --git a/src/test/ui/range/range-inclusive-pattern-precedence2.rs b/src/test/ui/range/range-inclusive-pattern-precedence2.rs new file mode 100644 index 0000000000000..6a3fd413e4fd7 --- /dev/null +++ b/src/test/ui/range/range-inclusive-pattern-precedence2.rs @@ -0,0 +1,19 @@ +// We are going to disallow `&a..=b` and `box a..=b` in a pattern. However, the +// older ... syntax is still allowed as a stability guarantee. + +#![feature(box_patterns)] +#![warn(ellipsis_inclusive_range_patterns)] + +fn main() { + match Box::new(12) { + // FIXME: can we add suggestions like `&(0..=9)`? + box 0...9 => {} + //~^ WARN `...` range patterns are deprecated + //~| HELP use `..=` for an inclusive range + box 10..=15 => {} + //~^ ERROR the range pattern here has ambiguous interpretation + //~^^ HELP add parentheses to clarify the precedence + box (16..=20) => {} + _ => {} + } +} diff --git a/src/test/ui/range/range-inclusive-pattern-precedence2.stderr b/src/test/ui/range/range-inclusive-pattern-precedence2.stderr new file mode 100644 index 0000000000000..7fbd972569e8d --- /dev/null +++ b/src/test/ui/range/range-inclusive-pattern-precedence2.stderr @@ -0,0 +1,20 @@ +error: the range pattern here has ambiguous interpretation + --> $DIR/range-inclusive-pattern-precedence2.rs:13:13 + | +LL | box 10..=15 => {} + | ^^^^^^^ help: add parentheses to clarify the precedence: `(10 ..=15)` + +warning: `...` range patterns are deprecated + --> $DIR/range-inclusive-pattern-precedence2.rs:10:14 + | +LL | box 0...9 => {} + | ^^^ help: use `..=` for an inclusive range + | +note: the lint level is defined here + --> $DIR/range-inclusive-pattern-precedence2.rs:5:9 + | +LL | #![warn(ellipsis_inclusive_range_patterns)] + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error: aborting due to previous error; 1 warning emitted + diff --git a/src/test/ui/resolve/resolve-conflict-import-vs-import.fixed b/src/test/ui/resolve/resolve-conflict-import-vs-import.fixed new file mode 100644 index 0000000000000..e429513b51d34 --- /dev/null +++ b/src/test/ui/resolve/resolve-conflict-import-vs-import.fixed @@ -0,0 +1,9 @@ +// run-rustfix + +#[allow(unused_imports)] +use std::mem::transmute; + +//~^ ERROR the name `transmute` is defined multiple times + +fn main() { +} diff --git a/src/test/ui/resolve/resolve-conflict-import-vs-import.rs b/src/test/ui/resolve/resolve-conflict-import-vs-import.rs index 322f000040e17..43853117af699 100644 --- a/src/test/ui/resolve/resolve-conflict-import-vs-import.rs +++ b/src/test/ui/resolve/resolve-conflict-import-vs-import.rs @@ -1,3 +1,6 @@ +// run-rustfix + +#[allow(unused_imports)] use std::mem::transmute; use std::mem::transmute; //~^ ERROR the name `transmute` is defined multiple times diff --git a/src/test/ui/resolve/resolve-conflict-import-vs-import.stderr b/src/test/ui/resolve/resolve-conflict-import-vs-import.stderr index 8df68ad3229ed..632be50f4c4bf 100644 --- a/src/test/ui/resolve/resolve-conflict-import-vs-import.stderr +++ b/src/test/ui/resolve/resolve-conflict-import-vs-import.stderr @@ -1,5 +1,5 @@ error[E0252]: the name `transmute` is defined multiple times - --> $DIR/resolve-conflict-import-vs-import.rs:2:5 + --> $DIR/resolve-conflict-import-vs-import.rs:5:5 | LL | use std::mem::transmute; | ------------------- previous import of the value `transmute` here diff --git a/src/test/ui/resolve/token-error-correct-4.fixed b/src/test/ui/resolve/token-error-correct-4.fixed new file mode 100644 index 0000000000000..064b9e74e24fd --- /dev/null +++ b/src/test/ui/resolve/token-error-correct-4.fixed @@ -0,0 +1,10 @@ +// run-rustfix +// Test that we do some basic error correction in the tokeniser and apply suggestions. + +fn setsuna(_: ()) {} + +fn kazusa() {} + +fn main() { + setsuna(kazusa()); //~ ERROR: expected one of +} //~ ERROR: expected expression diff --git a/src/test/ui/resolve/token-error-correct-4.rs b/src/test/ui/resolve/token-error-correct-4.rs new file mode 100644 index 0000000000000..5e31d71e7bf46 --- /dev/null +++ b/src/test/ui/resolve/token-error-correct-4.rs @@ -0,0 +1,10 @@ +// run-rustfix +// Test that we do some basic error correction in the tokeniser and apply suggestions. + +fn setsuna(_: ()) {} + +fn kazusa() {} + +fn main() { + setsuna(kazusa(); //~ ERROR: expected one of +} //~ ERROR: expected expression diff --git a/src/test/ui/resolve/token-error-correct-4.stderr b/src/test/ui/resolve/token-error-correct-4.stderr new file mode 100644 index 0000000000000..64aff54ba7311 --- /dev/null +++ b/src/test/ui/resolve/token-error-correct-4.stderr @@ -0,0 +1,16 @@ +error: expected one of `)`, `,`, `.`, `?`, or an operator, found `;` + --> $DIR/token-error-correct-4.rs:9:21 + | +LL | setsuna(kazusa(); + | - ^ help: `)` may belong here + | | + | unclosed delimiter + +error: expected expression, found `)` + --> $DIR/token-error-correct-4.rs:10:1 + | +LL | } + | ^ expected expression + +error: aborting due to 2 previous errors + diff --git a/src/test/ui/similar-tokens.fixed b/src/test/ui/similar-tokens.fixed new file mode 100644 index 0000000000000..addba76ae3b51 --- /dev/null +++ b/src/test/ui/similar-tokens.fixed @@ -0,0 +1,13 @@ +// run-rustfix + +#![allow(unused_imports)] + +pub mod x { + pub struct A; + pub struct B; +} + +// `.` is similar to `,` so list parsing should continue to closing `}` +use x::{A, B}; //~ ERROR expected one of `,`, `::`, `as`, or `}`, found `.` + +fn main() {} diff --git a/src/test/ui/similar-tokens.rs b/src/test/ui/similar-tokens.rs index b42f3a313e1e7..3d1bf5fe54ae1 100644 --- a/src/test/ui/similar-tokens.rs +++ b/src/test/ui/similar-tokens.rs @@ -1,4 +1,8 @@ -mod x { +// run-rustfix + +#![allow(unused_imports)] + +pub mod x { pub struct A; pub struct B; } diff --git a/src/test/ui/similar-tokens.stderr b/src/test/ui/similar-tokens.stderr index 35a2fe79d5e66..6a8d09ebae668 100644 --- a/src/test/ui/similar-tokens.stderr +++ b/src/test/ui/similar-tokens.stderr @@ -1,5 +1,5 @@ error: expected one of `,`, `::`, `as`, or `}`, found `.` - --> $DIR/similar-tokens.rs:7:10 + --> $DIR/similar-tokens.rs:11:10 | LL | use x::{A. B}; | ^ diff --git a/src/test/ui/structs/struct-duplicate-comma.fixed b/src/test/ui/structs/struct-duplicate-comma.fixed new file mode 100644 index 0000000000000..c804cf57abaaa --- /dev/null +++ b/src/test/ui/structs/struct-duplicate-comma.fixed @@ -0,0 +1,15 @@ +// run-rustfix +// Issue #50974 + +pub struct Foo { + pub a: u8, + pub b: u8 +} + +fn main() { + let _ = Foo { + a: 0, + //~^ ERROR expected identifier + b: 42 + }; +} diff --git a/src/test/ui/structs/struct-duplicate-comma.rs b/src/test/ui/structs/struct-duplicate-comma.rs index ff0d58abc3ada..db2e7cb3d05e6 100644 --- a/src/test/ui/structs/struct-duplicate-comma.rs +++ b/src/test/ui/structs/struct-duplicate-comma.rs @@ -1,12 +1,13 @@ +// run-rustfix // Issue #50974 -struct Foo { - a: u8, - b: u8 +pub struct Foo { + pub a: u8, + pub b: u8 } fn main() { - let bar = Foo { + let _ = Foo { a: 0,, //~^ ERROR expected identifier b: 42 diff --git a/src/test/ui/structs/struct-duplicate-comma.stderr b/src/test/ui/structs/struct-duplicate-comma.stderr index 2297fea635363..834b3c5c17164 100644 --- a/src/test/ui/structs/struct-duplicate-comma.stderr +++ b/src/test/ui/structs/struct-duplicate-comma.stderr @@ -1,8 +1,8 @@ error: expected identifier, found `,` - --> $DIR/struct-duplicate-comma.rs:10:14 + --> $DIR/struct-duplicate-comma.rs:11:14 | -LL | let bar = Foo { - | --- while parsing this struct +LL | let _ = Foo { + | --- while parsing this struct LL | a: 0,, | ^ | | diff --git a/src/test/ui/structs/struct-missing-comma.fixed b/src/test/ui/structs/struct-missing-comma.fixed new file mode 100644 index 0000000000000..a28179ba24168 --- /dev/null +++ b/src/test/ui/structs/struct-missing-comma.fixed @@ -0,0 +1,12 @@ +// Issue #50636 +// run-rustfix + +pub struct S { + pub foo: u32, //~ expected `,`, or `}`, found keyword `pub` + // ~^ HELP try adding a comma: ',' + pub bar: u32 +} + +fn main() { + let _ = S { foo: 5, bar: 6 }; +} diff --git a/src/test/ui/structs/struct-missing-comma.rs b/src/test/ui/structs/struct-missing-comma.rs index 4c3cac3369136..b6d6c9b8f8762 100644 --- a/src/test/ui/structs/struct-missing-comma.rs +++ b/src/test/ui/structs/struct-missing-comma.rs @@ -1,11 +1,12 @@ // Issue #50636 +// run-rustfix -struct S { - foo: u32 //~ expected `,`, or `}`, found `bar` +pub struct S { + pub foo: u32 //~ expected `,`, or `}`, found keyword `pub` // ~^ HELP try adding a comma: ',' - bar: u32 + pub bar: u32 } fn main() { - let s = S { foo: 5, bar: 6 }; + let _ = S { foo: 5, bar: 6 }; } diff --git a/src/test/ui/structs/struct-missing-comma.stderr b/src/test/ui/structs/struct-missing-comma.stderr index f5b79f54001e7..eceec65e76346 100644 --- a/src/test/ui/structs/struct-missing-comma.stderr +++ b/src/test/ui/structs/struct-missing-comma.stderr @@ -1,8 +1,8 @@ -error: expected `,`, or `}`, found `bar` - --> $DIR/struct-missing-comma.rs:4:13 +error: expected `,`, or `}`, found keyword `pub` + --> $DIR/struct-missing-comma.rs:5:17 | -LL | foo: u32 - | ^ help: try adding a comma: `,` +LL | pub foo: u32 + | ^ help: try adding a comma: `,` error: aborting due to previous error diff --git a/src/test/ui/suggestions/struct-initializer-comma.fixed b/src/test/ui/suggestions/struct-initializer-comma.fixed new file mode 100644 index 0000000000000..6a4ee39b16d86 --- /dev/null +++ b/src/test/ui/suggestions/struct-initializer-comma.fixed @@ -0,0 +1,15 @@ +// run-rustfix + +pub struct Foo { + pub first: bool, + pub second: u8, +} + +fn main() { + let _ = Foo { + //~^ ERROR missing field + first: true, + second: 25 + //~^ ERROR expected one of + }; +} diff --git a/src/test/ui/suggestions/struct-initializer-comma.rs b/src/test/ui/suggestions/struct-initializer-comma.rs index 613b976848f70..c137f0594186d 100644 --- a/src/test/ui/suggestions/struct-initializer-comma.rs +++ b/src/test/ui/suggestions/struct-initializer-comma.rs @@ -1,10 +1,12 @@ -struct Foo { - first: bool, - second: u8, +// run-rustfix + +pub struct Foo { + pub first: bool, + pub second: u8, } fn main() { - let a = Foo { + let _ = Foo { //~^ ERROR missing field first: true second: 25 diff --git a/src/test/ui/suggestions/struct-initializer-comma.stderr b/src/test/ui/suggestions/struct-initializer-comma.stderr index 731e8e10ab3ca..5eff43f32cda1 100644 --- a/src/test/ui/suggestions/struct-initializer-comma.stderr +++ b/src/test/ui/suggestions/struct-initializer-comma.stderr @@ -1,7 +1,7 @@ error: expected one of `,`, `.`, `?`, `}`, or an operator, found `second` - --> $DIR/struct-initializer-comma.rs:10:9 + --> $DIR/struct-initializer-comma.rs:12:9 | -LL | let a = Foo { +LL | let _ = Foo { | --- while parsing this struct LL | LL | first: true @@ -13,9 +13,9 @@ LL | second: 25 | ^^^^^^ unexpected token error[E0063]: missing field `second` in initializer of `Foo` - --> $DIR/struct-initializer-comma.rs:7:13 + --> $DIR/struct-initializer-comma.rs:9:13 | -LL | let a = Foo { +LL | let _ = Foo { | ^^^ missing `second` error: aborting due to 2 previous errors diff --git a/src/test/ui/suggestions/suggest-remove-refs-1.fixed b/src/test/ui/suggestions/suggest-remove-refs-1.fixed new file mode 100644 index 0000000000000..042e85b10ae21 --- /dev/null +++ b/src/test/ui/suggestions/suggest-remove-refs-1.fixed @@ -0,0 +1,10 @@ +// run-rustfix + +fn main() { + let v = vec![0, 1, 2, 3]; + + for (i, _) in v.iter().enumerate() { + //~^ ERROR `&std::iter::Enumerate>` is not an iterator + println!("{}", i); + } +} diff --git a/src/test/ui/suggestions/suggest-remove-refs-1.rs b/src/test/ui/suggestions/suggest-remove-refs-1.rs index 792cd6c5a0c3a..7bdf5dbf35884 100644 --- a/src/test/ui/suggestions/suggest-remove-refs-1.rs +++ b/src/test/ui/suggestions/suggest-remove-refs-1.rs @@ -1,7 +1,9 @@ +// run-rustfix + fn main() { let v = vec![0, 1, 2, 3]; - for (i, n) in &v.iter().enumerate() { + for (i, _) in &v.iter().enumerate() { //~^ ERROR `&std::iter::Enumerate>` is not an iterator println!("{}", i); } diff --git a/src/test/ui/suggestions/suggest-remove-refs-1.stderr b/src/test/ui/suggestions/suggest-remove-refs-1.stderr index fcaddd40d263b..5be0072fa3302 100644 --- a/src/test/ui/suggestions/suggest-remove-refs-1.stderr +++ b/src/test/ui/suggestions/suggest-remove-refs-1.stderr @@ -1,7 +1,7 @@ error[E0277]: `&std::iter::Enumerate>` is not an iterator - --> $DIR/suggest-remove-refs-1.rs:4:19 + --> $DIR/suggest-remove-refs-1.rs:6:19 | -LL | for (i, n) in &v.iter().enumerate() { +LL | for (i, _) in &v.iter().enumerate() { | -^^^^^^^^^^^^^^^^^^^^ | | | `&std::iter::Enumerate>` is not an iterator diff --git a/src/test/ui/suggestions/suggest-remove-refs-2.fixed b/src/test/ui/suggestions/suggest-remove-refs-2.fixed new file mode 100644 index 0000000000000..bdf47b0e87f13 --- /dev/null +++ b/src/test/ui/suggestions/suggest-remove-refs-2.fixed @@ -0,0 +1,10 @@ +// run-rustfix + +fn main() { + let v = vec![0, 1, 2, 3]; + + for (i, _) in v.iter().enumerate() { + //~^ ERROR `&&&&&std::iter::Enumerate>` is not an iterator + println!("{}", i); + } +} diff --git a/src/test/ui/suggestions/suggest-remove-refs-2.rs b/src/test/ui/suggestions/suggest-remove-refs-2.rs index 52d940143b327..3ed56377e146c 100644 --- a/src/test/ui/suggestions/suggest-remove-refs-2.rs +++ b/src/test/ui/suggestions/suggest-remove-refs-2.rs @@ -1,7 +1,9 @@ +// run-rustfix + fn main() { let v = vec![0, 1, 2, 3]; - for (i, n) in & & & & &v.iter().enumerate() { + for (i, _) in & & & & &v.iter().enumerate() { //~^ ERROR `&&&&&std::iter::Enumerate>` is not an iterator println!("{}", i); } diff --git a/src/test/ui/suggestions/suggest-remove-refs-2.stderr b/src/test/ui/suggestions/suggest-remove-refs-2.stderr index fe1b0f1ea22ad..ff84a2ce37705 100644 --- a/src/test/ui/suggestions/suggest-remove-refs-2.stderr +++ b/src/test/ui/suggestions/suggest-remove-refs-2.stderr @@ -1,7 +1,7 @@ error[E0277]: `&&&&&std::iter::Enumerate>` is not an iterator - --> $DIR/suggest-remove-refs-2.rs:4:19 + --> $DIR/suggest-remove-refs-2.rs:6:19 | -LL | for (i, n) in & & & & &v.iter().enumerate() { +LL | for (i, _) in & & & & &v.iter().enumerate() { | ---------^^^^^^^^^^^^^^^^^^^^ | | | `&&&&&std::iter::Enumerate>` is not an iterator diff --git a/src/test/ui/suggestions/suggest-remove-refs-3.fixed b/src/test/ui/suggestions/suggest-remove-refs-3.fixed new file mode 100644 index 0000000000000..e0ecafabf393e --- /dev/null +++ b/src/test/ui/suggestions/suggest-remove-refs-3.fixed @@ -0,0 +1,12 @@ +// run-rustfix + +fn main() { + let v = vec![0, 1, 2, 3]; + + for (i, _) in v + .iter() + .enumerate() { + //~^^^^ ERROR `&&&&&std::iter::Enumerate>` is not an + println!("{}", i); + } +} diff --git a/src/test/ui/suggestions/suggest-remove-refs-3.rs b/src/test/ui/suggestions/suggest-remove-refs-3.rs index 981924d3251df..e13099e8c3246 100644 --- a/src/test/ui/suggestions/suggest-remove-refs-3.rs +++ b/src/test/ui/suggestions/suggest-remove-refs-3.rs @@ -1,7 +1,9 @@ +// run-rustfix + fn main() { let v = vec![0, 1, 2, 3]; - for (i, n) in & & & + for (i, _) in & & & & &v .iter() .enumerate() { diff --git a/src/test/ui/suggestions/suggest-remove-refs-3.stderr b/src/test/ui/suggestions/suggest-remove-refs-3.stderr index a6c16e1817a54..d2f7c72b0e474 100644 --- a/src/test/ui/suggestions/suggest-remove-refs-3.stderr +++ b/src/test/ui/suggestions/suggest-remove-refs-3.stderr @@ -1,7 +1,7 @@ error[E0277]: `&&&&&std::iter::Enumerate>` is not an iterator - --> $DIR/suggest-remove-refs-3.rs:4:19 + --> $DIR/suggest-remove-refs-3.rs:6:19 | -LL | for (i, n) in & & & +LL | for (i, _) in & & & | ___________________^ | |___________________| | || diff --git a/src/test/ui/try-block/try-block-unused-delims.fixed b/src/test/ui/try-block/try-block-unused-delims.fixed new file mode 100644 index 0000000000000..c8b03c2006840 --- /dev/null +++ b/src/test/ui/try-block/try-block-unused-delims.fixed @@ -0,0 +1,29 @@ +// check-pass +// compile-flags: --edition 2018 +// run-rustfix + +#![feature(try_blocks)] +#![warn(unused_parens, unused_braces)] + +fn consume(_: Result) -> T { todo!() } + +fn main() { + consume(try {}); + //~^ WARN unnecessary parentheses + + consume( try {} ); + //~^ WARN unnecessary braces + + match try {} { + //~^ WARN unnecessary parentheses + Ok(()) | Err(()) => (), + } + + if let Err(()) = try {} {} + //~^ WARN unnecessary parentheses + + match try {} { + //~^ WARN unnecessary parentheses + Ok(()) | Err(()) => (), + } +} diff --git a/src/test/ui/try-block/try-block-unused-delims.rs b/src/test/ui/try-block/try-block-unused-delims.rs index 0b767eb2dad77..ce087fb351d63 100644 --- a/src/test/ui/try-block/try-block-unused-delims.rs +++ b/src/test/ui/try-block/try-block-unused-delims.rs @@ -1,5 +1,6 @@ // check-pass // compile-flags: --edition 2018 +// run-rustfix #![feature(try_blocks)] #![warn(unused_parens, unused_braces)] diff --git a/src/test/ui/try-block/try-block-unused-delims.stderr b/src/test/ui/try-block/try-block-unused-delims.stderr index 5c7602ee0ab12..c5a2405462932 100644 --- a/src/test/ui/try-block/try-block-unused-delims.stderr +++ b/src/test/ui/try-block/try-block-unused-delims.stderr @@ -1,41 +1,41 @@ warning: unnecessary parentheses around function argument - --> $DIR/try-block-unused-delims.rs:10:13 + --> $DIR/try-block-unused-delims.rs:11:13 | LL | consume((try {})); | ^^^^^^^^ help: remove these parentheses | note: the lint level is defined here - --> $DIR/try-block-unused-delims.rs:5:9 + --> $DIR/try-block-unused-delims.rs:6:9 | LL | #![warn(unused_parens, unused_braces)] | ^^^^^^^^^^^^^ warning: unnecessary braces around function argument - --> $DIR/try-block-unused-delims.rs:13:13 + --> $DIR/try-block-unused-delims.rs:14:13 | LL | consume({ try {} }); | ^^^^^^^^^^ help: remove these braces | note: the lint level is defined here - --> $DIR/try-block-unused-delims.rs:5:24 + --> $DIR/try-block-unused-delims.rs:6:24 | LL | #![warn(unused_parens, unused_braces)] | ^^^^^^^^^^^^^ warning: unnecessary parentheses around `match` scrutinee expression - --> $DIR/try-block-unused-delims.rs:16:11 + --> $DIR/try-block-unused-delims.rs:17:11 | LL | match (try {}) { | ^^^^^^^^ help: remove these parentheses warning: unnecessary parentheses around `let` scrutinee expression - --> $DIR/try-block-unused-delims.rs:21:22 + --> $DIR/try-block-unused-delims.rs:22:22 | LL | if let Err(()) = (try {}) {} | ^^^^^^^^ help: remove these parentheses warning: unnecessary parentheses around `match` scrutinee expression - --> $DIR/try-block-unused-delims.rs:24:11 + --> $DIR/try-block-unused-delims.rs:25:11 | LL | match (try {}) { | ^^^^^^^^ help: remove these parentheses diff --git a/src/test/ui/typeck/issue-73592-borrow_mut-through-deref.fixed b/src/test/ui/typeck/issue-73592-borrow_mut-through-deref.fixed new file mode 100644 index 0000000000000..7fdd618c2ecae --- /dev/null +++ b/src/test/ui/typeck/issue-73592-borrow_mut-through-deref.fixed @@ -0,0 +1,59 @@ +// check-pass +// run-rustfix +// +// rust-lang/rust#73592: borrow_mut through Deref should work. +// +// Before #72280, when we see something like `&mut *rcvr.method()`, we +// incorrectly requires `rcvr` to be type-checked as a mut place. While this +// requirement is usually correct for smart pointers, it is overly restrictive +// for types like `Mutex` or `RefCell` which can produce a guard that +// implements `DerefMut` from `&self`. +// +// Making it more confusing, because we use Deref as the fallback when DerefMut +// is implemented, we won't see an issue when the smart pointer does not +// implement `DerefMut`. It only causes an issue when `rcvr` is obtained via a +// type that implements both `Deref` or `DerefMut`. +// +// This bug is only discovered in #73592 after it is already fixed as a side-effect +// of a refactoring made in #72280. + +#![warn(unused_mut)] + +use std::pin::Pin; +use std::cell::RefCell; + +struct S(RefCell<()>); + +fn test_pin(s: Pin<&S>) { + // This works before #72280. + let _ = &mut *s.0.borrow_mut(); +} + +fn test_pin_mut(s: Pin<&mut S>) { + // This should compile but didn't before #72280. + let _ = &mut *s.0.borrow_mut(); +} + +fn test_vec(s: &Vec>) { + // This should compile but didn't before #72280. + let _ = &mut *s[0].borrow_mut(); +} + +fn test_mut_pin(s: Pin<&S>) { + //~^ WARN variable does not need to be mutable + let _ = &mut *s.0.borrow_mut(); +} + +fn test_mut_pin_mut(s: Pin<&mut S>) { + //~^ WARN variable does not need to be mutable + let _ = &mut *s.0.borrow_mut(); +} + +fn main() { + let mut s = S(RefCell::new(())); + test_pin(Pin::new(&s)); + test_pin_mut(Pin::new(&mut s)); + test_mut_pin(Pin::new(&s)); + test_mut_pin_mut(Pin::new(&mut s)); + test_vec(&vec![s.0]); +} diff --git a/src/test/ui/typeck/issue-73592-borrow_mut-through-deref.rs b/src/test/ui/typeck/issue-73592-borrow_mut-through-deref.rs index 0cf77da559470..3b399e629d341 100644 --- a/src/test/ui/typeck/issue-73592-borrow_mut-through-deref.rs +++ b/src/test/ui/typeck/issue-73592-borrow_mut-through-deref.rs @@ -1,4 +1,5 @@ // check-pass +// run-rustfix // // rust-lang/rust#73592: borrow_mut through Deref should work. // diff --git a/src/test/ui/typeck/issue-73592-borrow_mut-through-deref.stderr b/src/test/ui/typeck/issue-73592-borrow_mut-through-deref.stderr index 51303adc9e533..5f5f672c3843a 100644 --- a/src/test/ui/typeck/issue-73592-borrow_mut-through-deref.stderr +++ b/src/test/ui/typeck/issue-73592-borrow_mut-through-deref.stderr @@ -1,5 +1,5 @@ warning: variable does not need to be mutable - --> $DIR/issue-73592-borrow_mut-through-deref.rs:41:17 + --> $DIR/issue-73592-borrow_mut-through-deref.rs:42:17 | LL | fn test_mut_pin(mut s: Pin<&S>) { | ----^ @@ -7,13 +7,13 @@ LL | fn test_mut_pin(mut s: Pin<&S>) { | help: remove this `mut` | note: the lint level is defined here - --> $DIR/issue-73592-borrow_mut-through-deref.rs:19:9 + --> $DIR/issue-73592-borrow_mut-through-deref.rs:20:9 | LL | #![warn(unused_mut)] | ^^^^^^^^^^ warning: variable does not need to be mutable - --> $DIR/issue-73592-borrow_mut-through-deref.rs:46:21 + --> $DIR/issue-73592-borrow_mut-through-deref.rs:47:21 | LL | fn test_mut_pin_mut(mut s: Pin<&mut S>) { | ----^ diff --git a/src/test/ui/unused/unused-mut-warning-captured-var.fixed b/src/test/ui/unused/unused-mut-warning-captured-var.fixed new file mode 100644 index 0000000000000..b67b2a7259be0 --- /dev/null +++ b/src/test/ui/unused/unused-mut-warning-captured-var.fixed @@ -0,0 +1,9 @@ +// run-rustfix + +#![forbid(unused_mut)] + +fn main() { + let x = 1; + //~^ ERROR: variable does not need to be mutable + move|| { println!("{}", x); }; +} diff --git a/src/test/ui/unused/unused-mut-warning-captured-var.rs b/src/test/ui/unused/unused-mut-warning-captured-var.rs index c945969cf6325..8726c4f173fa3 100644 --- a/src/test/ui/unused/unused-mut-warning-captured-var.rs +++ b/src/test/ui/unused/unused-mut-warning-captured-var.rs @@ -1,3 +1,5 @@ +// run-rustfix + #![forbid(unused_mut)] fn main() { diff --git a/src/test/ui/unused/unused-mut-warning-captured-var.stderr b/src/test/ui/unused/unused-mut-warning-captured-var.stderr index 39d470e02a80f..20aeedcc24125 100644 --- a/src/test/ui/unused/unused-mut-warning-captured-var.stderr +++ b/src/test/ui/unused/unused-mut-warning-captured-var.stderr @@ -1,5 +1,5 @@ error: variable does not need to be mutable - --> $DIR/unused-mut-warning-captured-var.rs:4:9 + --> $DIR/unused-mut-warning-captured-var.rs:6:9 | LL | let mut x = 1; | ----^ @@ -7,7 +7,7 @@ LL | let mut x = 1; | help: remove this `mut` | note: the lint level is defined here - --> $DIR/unused-mut-warning-captured-var.rs:1:11 + --> $DIR/unused-mut-warning-captured-var.rs:3:11 | LL | #![forbid(unused_mut)] | ^^^^^^^^^^ diff --git a/src/tools/build-manifest/README.md b/src/tools/build-manifest/README.md index 6834f56efe7db..a80f36d496998 100644 --- a/src/tools/build-manifest/README.md +++ b/src/tools/build-manifest/README.md @@ -22,7 +22,7 @@ Then, you can generate the manifest and all the packages from `path/to/dist` to ``` $ BUILD_MANIFEST_DISABLE_SIGNING=1 cargo +nightly run \ path/to/dist path/to/output 1970-01-01 \ - nightly nightly nightly nightly nightly nightly nightly \ + nightly nightly nightly nightly nightly nightly nightly nightly \ http://example.com ``` diff --git a/src/tools/build-manifest/src/main.rs b/src/tools/build-manifest/src/main.rs index 614e25589601e..5c50587ea973d 100644 --- a/src/tools/build-manifest/src/main.rs +++ b/src/tools/build-manifest/src/main.rs @@ -158,6 +158,8 @@ static DOCS_TARGETS: &[&str] = &[ static MINGW: &[&str] = &["i686-pc-windows-gnu", "x86_64-pc-windows-gnu"]; +static NIGHTLY_ONLY_COMPONENTS: &[&str] = &["miri-preview", "rust-analyzer-preview"]; + #[derive(Serialize)] #[serde(rename_all = "kebab-case")] struct Manifest { @@ -222,6 +224,7 @@ struct Builder { rust_release: String, cargo_release: String, rls_release: String, + rust_analyzer_release: String, clippy_release: String, rustfmt_release: String, llvm_tools_release: String, @@ -237,6 +240,7 @@ struct Builder { rust_version: Option, cargo_version: Option, rls_version: Option, + rust_analyzer_version: Option, clippy_version: Option, rustfmt_version: Option, llvm_tools_version: Option, @@ -245,6 +249,7 @@ struct Builder { rust_git_commit_hash: Option, cargo_git_commit_hash: Option, rls_git_commit_hash: Option, + rust_analyzer_git_commit_hash: Option, clippy_git_commit_hash: Option, rustfmt_git_commit_hash: Option, llvm_tools_git_commit_hash: Option, @@ -274,6 +279,7 @@ fn main() { let s3_address = args.next().unwrap(); let cargo_release = args.next().unwrap(); let rls_release = args.next().unwrap(); + let rust_analyzer_release = args.next().unwrap(); let clippy_release = args.next().unwrap(); let miri_release = args.next().unwrap(); let rustfmt_release = args.next().unwrap(); @@ -290,6 +296,7 @@ fn main() { rust_release, cargo_release, rls_release, + rust_analyzer_release, clippy_release, rustfmt_release, llvm_tools_release, @@ -305,6 +312,7 @@ fn main() { rust_version: None, cargo_version: None, rls_version: None, + rust_analyzer_version: None, clippy_version: None, rustfmt_version: None, llvm_tools_version: None, @@ -313,6 +321,7 @@ fn main() { rust_git_commit_hash: None, cargo_git_commit_hash: None, rls_git_commit_hash: None, + rust_analyzer_git_commit_hash: None, clippy_git_commit_hash: None, rustfmt_git_commit_hash: None, llvm_tools_git_commit_hash: None, @@ -327,6 +336,7 @@ enum PkgType { RustSrc, Cargo, Rls, + RustAnalyzer, Clippy, Rustfmt, LlvmTools, @@ -341,6 +351,7 @@ impl PkgType { "rust-src" => RustSrc, "cargo" => Cargo, "rls" | "rls-preview" => Rls, + "rust-analyzer" | "rust-analyzer-preview" => RustAnalyzer, "clippy" | "clippy-preview" => Clippy, "rustfmt" | "rustfmt-preview" => Rustfmt, "llvm-tools" | "llvm-tools-preview" => LlvmTools, @@ -355,6 +366,7 @@ impl Builder { self.rust_version = self.version("rust", "x86_64-unknown-linux-gnu"); self.cargo_version = self.version("cargo", "x86_64-unknown-linux-gnu"); self.rls_version = self.version("rls", "x86_64-unknown-linux-gnu"); + self.rust_analyzer_version = self.version("rust-analyzer", "x86_64-unknown-linux-gnu"); self.clippy_version = self.version("clippy", "x86_64-unknown-linux-gnu"); self.rustfmt_version = self.version("rustfmt", "x86_64-unknown-linux-gnu"); self.llvm_tools_version = self.version("llvm-tools", "x86_64-unknown-linux-gnu"); @@ -363,6 +375,8 @@ impl Builder { self.rust_git_commit_hash = self.git_commit_hash("rust", "x86_64-unknown-linux-gnu"); self.cargo_git_commit_hash = self.git_commit_hash("cargo", "x86_64-unknown-linux-gnu"); self.rls_git_commit_hash = self.git_commit_hash("rls", "x86_64-unknown-linux-gnu"); + self.rust_analyzer_git_commit_hash = + self.git_commit_hash("rust-analyzer", "x86_64-unknown-linux-gnu"); self.clippy_git_commit_hash = self.git_commit_hash("clippy", "x86_64-unknown-linux-gnu"); self.rustfmt_git_commit_hash = self.git_commit_hash("rustfmt", "x86_64-unknown-linux-gnu"); self.llvm_tools_git_commit_hash = @@ -436,6 +450,7 @@ impl Builder { package("rust-docs", DOCS_TARGETS); package("rust-src", &["*"]); package("rls-preview", HOSTS); + package("rust-analyzer-preview", HOSTS); package("clippy-preview", HOSTS); package("miri-preview", HOSTS); package("rustfmt-preview", HOSTS); @@ -469,6 +484,7 @@ impl Builder { "rustfmt-preview", "clippy-preview", "rls-preview", + "rust-analyzer-preview", "rust-src", "llvm-tools-preview", "rust-analysis", @@ -543,6 +559,7 @@ impl Builder { host_component("clippy-preview"), host_component("miri-preview"), host_component("rls-preview"), + host_component("rust-analyzer-preview"), host_component("rustfmt-preview"), host_component("llvm-tools-preview"), host_component("rust-analysis"), @@ -612,8 +629,8 @@ impl Builder { .map(|version| (version, true)) .unwrap_or_default(); // `is_present` defaults to `false` here. - // Miri is nightly-only; never ship it for other trains. - if pkgname == "miri-preview" && self.rust_release != "nightly" { + // Never ship nightly-only components for other trains. + if self.rust_release != "nightly" && NIGHTLY_ONLY_COMPONENTS.contains(&pkgname) { is_present = false; // Pretend the component is entirely missing. } @@ -671,6 +688,9 @@ impl Builder { RustSrc => format!("rust-src-{}.tar.gz", self.rust_release), Cargo => format!("cargo-{}-{}.tar.gz", self.cargo_release, target), Rls => format!("rls-{}-{}.tar.gz", self.rls_release, target), + RustAnalyzer => { + format!("rust-analyzer-{}-{}.tar.gz", self.rust_analyzer_release, target) + } Clippy => format!("clippy-{}-{}.tar.gz", self.clippy_release, target), Rustfmt => format!("rustfmt-{}-{}.tar.gz", self.rustfmt_release, target), LlvmTools => format!("llvm-tools-{}-{}.tar.gz", self.llvm_tools_release, target), @@ -684,6 +704,7 @@ impl Builder { match PkgType::from_component(component) { Cargo => &self.cargo_version, Rls => &self.rls_version, + RustAnalyzer => &self.rust_analyzer_version, Clippy => &self.clippy_version, Rustfmt => &self.rustfmt_version, LlvmTools => &self.llvm_tools_version, @@ -697,6 +718,7 @@ impl Builder { match PkgType::from_component(component) { Cargo => &self.cargo_git_commit_hash, Rls => &self.rls_git_commit_hash, + RustAnalyzer => &self.rust_analyzer_git_commit_hash, Clippy => &self.clippy_git_commit_hash, Rustfmt => &self.rustfmt_git_commit_hash, LlvmTools => &self.llvm_tools_git_commit_hash,