From 8dc1e42515adbf0946a235b464b2fd41619cec04 Mon Sep 17 00:00:00 2001 From: Yashhwanth Ram Date: Thu, 2 Jul 2020 11:33:37 +0530 Subject: [PATCH 01/12] libstd/net/tcp.rs: #![deny(unsafe_op_in_unsafe_fn)] Enclose unsafe operations in unsafe blocks --- src/libstd/net/tcp.rs | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) 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")] From ec31b4e3a859c7432232dcdfb559538e0c5a0d5e Mon Sep 17 00:00:00 2001 From: Yuki Okushi Date: Thu, 2 Jul 2020 14:32:12 +0900 Subject: [PATCH 02/12] Audit uses of `span_suggestion_short` --- src/librustc_parse/parser/diagnostics.rs | 7 +- src/librustc_parse/parser/mod.rs | 2 +- .../block-expression-remove-semicolon.fixed | 12 ++ .../ui/block-expression-remove-semicolon.rs | 6 +- .../block-expression-remove-semicolon.stderr | 6 +- .../consider-removing-last-semi.fixed | 13 ++ .../consider-removing-last-semi.rs | 6 +- .../consider-removing-last-semi.stderr | 20 +-- .../coercion-missing-tail-expected-type.fixed | 16 ++ .../coercion-missing-tail-expected-type.rs | 2 + ...coercion-missing-tail-expected-type.stderr | 4 +- .../ui/const-generics/unused_braces.fixed | 15 ++ src/test/ui/const-generics/unused_braces.rs | 4 +- .../ui/const-generics/unused_braces.stderr | 15 +- ...41679-tilde-bitwise-negation-attempt.fixed | 5 + ...ue-41679-tilde-bitwise-negation-attempt.rs | 4 +- ...1679-tilde-bitwise-negation-attempt.stderr | 6 +- .../issue-54109-without-witness.fixed | 69 +++++++++ .../issue-54109-without-witness.rs | 69 +++++++++ .../issue-54109-without-witness.stderr | 130 ++++++++++++++++ src/test/ui/error-codes/E0642.fixed | 20 +++ src/test/ui/error-codes/E0642.rs | 4 + src/test/ui/error-codes/E0642.stderr | 6 +- src/test/ui/generic/generic-no-mangle.fixed | 17 ++ src/test/ui/generic/generic-no-mangle.rs | 2 + src/test/ui/generic/generic-no-mangle.stderr | 6 +- src/test/ui/impossible_range.fixed | 20 +++ src/test/ui/impossible_range.rs | 3 + src/test/ui/impossible_range.stderr | 4 +- src/test/ui/issues/issue-1962.fixed | 10 ++ src/test/ui/issues/issue-1962.rs | 12 +- src/test/ui/issues/issue-1962.stderr | 6 +- src/test/ui/issues/issue-40782.fixed | 6 + src/test/ui/issues/issue-40782.rs | 4 +- src/test/ui/issues/issue-40782.stderr | 6 +- src/test/ui/issues/issue-46186.fixed | 8 + src/test/ui/issues/issue-46186.rs | 6 +- src/test/ui/issues/issue-46186.stderr | 2 +- src/test/ui/issues/issue-50571.fixed | 8 + src/test/ui/issues/issue-50571.rs | 2 + src/test/ui/issues/issue-50571.stderr | 2 +- .../lint/issue-54538-unused-parens-lint.fixed | 107 +++++++++++++ .../ui/lint/issue-54538-unused-parens-lint.rs | 14 +- .../issue-54538-unused-parens-lint.stderr | 50 +++--- .../ui/lint/lint-unnecessary-parens.fixed | 79 ++++++++++ src/test/ui/lint/lint-unnecessary-parens.rs | 18 ++- .../ui/lint/lint-unnecessary-parens.stderr | 58 +++---- src/test/ui/lint/lint-unused-mut-self.fixed | 14 ++ src/test/ui/lint/lint-unused-mut-self.rs | 2 + src/test/ui/lint/lint-unused-mut-self.stderr | 6 +- src/test/ui/lint/lint-unused-mut-variables.rs | 13 +- .../ui/lint/lint-unused-mut-variables.stderr | 30 ++-- src/test/ui/lint/suggestions.fixed | 66 ++++++++ src/test/ui/lint/suggestions.rs | 4 + src/test/ui/lint/suggestions.stderr | 26 ++-- src/test/ui/lint/unused_braces.fixed | 53 +++++++ src/test/ui/lint/unused_braces.rs | 3 + src/test/ui/lint/unused_braces.stderr | 14 +- src/test/ui/lint/unused_braces_borrow.fixed | 26 ++++ src/test/ui/lint/unused_braces_borrow.rs | 8 +- src/test/ui/lint/unused_braces_borrow.stderr | 4 +- src/test/ui/nll/capture-mut-ref.fixed | 16 ++ src/test/ui/nll/capture-mut-ref.rs | 4 +- src/test/ui/nll/capture-mut-ref.stderr | 4 +- src/test/ui/nll/issue-61424.fixed | 9 ++ src/test/ui/nll/issue-61424.rs | 2 + src/test/ui/nll/issue-61424.stderr | 4 +- src/test/ui/nll/unused-mut-issue-50343.fixed | 9 ++ src/test/ui/nll/unused-mut-issue-50343.rs | 3 + src/test/ui/nll/unused-mut-issue-50343.stderr | 4 +- src/test/ui/parser/bad-fn-ptr-qualifier.fixed | 26 ++++ src/test/ui/parser/bad-fn-ptr-qualifier.rs | 26 ++++ .../ui/parser/bad-fn-ptr-qualifier.stderr | 146 ++++++++++++++++++ src/test/ui/parser/if-in-in.fixed | 7 + src/test/ui/parser/if-in-in.rs | 2 + src/test/ui/parser/if-in-in.stderr | 2 +- src/test/ui/parser/issue-10392-2.fixed | 9 ++ src/test/ui/parser/issue-10392-2.rs | 4 +- src/test/ui/parser/issue-10392-2.stderr | 2 +- src/test/ui/parser/issue-3036.fixed | 7 + src/test/ui/parser/issue-3036.rs | 7 +- src/test/ui/parser/issue-3036.stderr | 6 +- .../parser/issue-70388-without-witness.fixed | 9 ++ .../ui/parser/issue-70388-without-witness.rs | 9 ++ .../parser/issue-70388-without-witness.stderr | 20 +++ src/test/ui/parser/let-binop.fixed | 10 ++ src/test/ui/parser/let-binop.rs | 2 + src/test/ui/parser/let-binop.stderr | 6 +- .../ui/parser/match-refactor-to-expr.fixed | 12 ++ src/test/ui/parser/match-refactor-to-expr.rs | 4 +- .../ui/parser/match-refactor-to-expr.stderr | 6 +- src/test/ui/parser/range_inclusive.fixed | 7 + src/test/ui/parser/range_inclusive.rs | 1 + src/test/ui/parser/range_inclusive.stderr | 2 +- .../ui/parser/trait-object-lifetime-parens.rs | 1 + .../trait-object-lifetime-parens.stderr | 2 +- src/test/ui/path-lookahead.fixed | 17 ++ src/test/ui/path-lookahead.rs | 10 +- src/test/ui/path-lookahead.stderr | 8 +- src/test/ui/pub/pub-ident-fn-2.fixed | 10 ++ src/test/ui/pub/pub-ident-fn-2.rs | 6 +- src/test/ui/pub/pub-ident-fn-2.stderr | 6 +- .../ui/pub/pub-ident-fn-with-lifetime.fixed | 8 + src/test/ui/pub/pub-ident-fn-with-lifetime.rs | 4 +- .../ui/pub/pub-ident-fn-with-lifetime.stderr | 2 +- src/test/ui/pub/pub-ident-struct.fixed | 6 + src/test/ui/pub/pub-ident-struct.rs | 2 + src/test/ui/pub/pub-ident-struct.stderr | 2 +- .../range-inclusive-pattern-precedence.fixed | 20 +++ .../range-inclusive-pattern-precedence.rs | 18 +-- .../range-inclusive-pattern-precedence.stderr | 20 +-- .../range-inclusive-pattern-precedence2.rs | 19 +++ ...range-inclusive-pattern-precedence2.stderr | 20 +++ .../ui/resolve/token-error-correct-4.fixed | 10 ++ src/test/ui/resolve/token-error-correct-4.rs | 10 ++ .../ui/resolve/token-error-correct-4.stderr | 16 ++ src/test/ui/similar-tokens.fixed | 13 ++ src/test/ui/similar-tokens.rs | 6 +- src/test/ui/similar-tokens.stderr | 2 +- .../ui/structs/struct-duplicate-comma.fixed | 15 ++ src/test/ui/structs/struct-duplicate-comma.rs | 9 +- .../ui/structs/struct-duplicate-comma.stderr | 6 +- .../ui/structs/struct-missing-comma.fixed | 12 ++ src/test/ui/structs/struct-missing-comma.rs | 9 +- .../ui/structs/struct-missing-comma.stderr | 8 +- .../struct-initializer-comma.fixed | 15 ++ .../suggestions/struct-initializer-comma.rs | 10 +- .../struct-initializer-comma.stderr | 8 +- .../suggestions/suggest-remove-refs-1.fixed | 10 ++ .../ui/suggestions/suggest-remove-refs-1.rs | 4 +- .../suggestions/suggest-remove-refs-1.stderr | 4 +- .../suggestions/suggest-remove-refs-2.fixed | 10 ++ .../ui/suggestions/suggest-remove-refs-2.rs | 4 +- .../suggestions/suggest-remove-refs-2.stderr | 4 +- .../suggestions/suggest-remove-refs-3.fixed | 12 ++ .../ui/suggestions/suggest-remove-refs-3.rs | 4 +- .../suggestions/suggest-remove-refs-3.stderr | 4 +- .../try-block/try-block-unused-delims.fixed | 29 ++++ .../ui/try-block/try-block-unused-delims.rs | 1 + .../try-block/try-block-unused-delims.stderr | 14 +- ...issue-73592-borrow_mut-through-deref.fixed | 59 +++++++ .../issue-73592-borrow_mut-through-deref.rs | 1 + ...ssue-73592-borrow_mut-through-deref.stderr | 6 +- .../unused-mut-warning-captured-var.fixed | 9 ++ .../unused/unused-mut-warning-captured-var.rs | 2 + .../unused-mut-warning-captured-var.stderr | 4 +- 146 files changed, 1758 insertions(+), 300 deletions(-) create mode 100644 src/test/ui/block-expression-remove-semicolon.fixed create mode 100644 src/test/ui/block-result/consider-removing-last-semi.fixed create mode 100644 src/test/ui/coercion/coercion-missing-tail-expected-type.fixed create mode 100644 src/test/ui/const-generics/unused_braces.fixed create mode 100644 src/test/ui/did_you_mean/issue-41679-tilde-bitwise-negation-attempt.fixed create mode 100644 src/test/ui/did_you_mean/issue-54109-without-witness.fixed create mode 100644 src/test/ui/did_you_mean/issue-54109-without-witness.rs create mode 100644 src/test/ui/did_you_mean/issue-54109-without-witness.stderr create mode 100644 src/test/ui/error-codes/E0642.fixed create mode 100644 src/test/ui/generic/generic-no-mangle.fixed create mode 100644 src/test/ui/impossible_range.fixed create mode 100644 src/test/ui/issues/issue-1962.fixed create mode 100644 src/test/ui/issues/issue-40782.fixed create mode 100644 src/test/ui/issues/issue-46186.fixed create mode 100644 src/test/ui/issues/issue-50571.fixed create mode 100644 src/test/ui/lint/issue-54538-unused-parens-lint.fixed create mode 100644 src/test/ui/lint/lint-unnecessary-parens.fixed create mode 100644 src/test/ui/lint/lint-unused-mut-self.fixed create mode 100644 src/test/ui/lint/suggestions.fixed create mode 100644 src/test/ui/lint/unused_braces.fixed create mode 100644 src/test/ui/lint/unused_braces_borrow.fixed create mode 100644 src/test/ui/nll/capture-mut-ref.fixed create mode 100644 src/test/ui/nll/issue-61424.fixed create mode 100644 src/test/ui/nll/unused-mut-issue-50343.fixed create mode 100644 src/test/ui/parser/bad-fn-ptr-qualifier.fixed create mode 100644 src/test/ui/parser/bad-fn-ptr-qualifier.rs create mode 100644 src/test/ui/parser/bad-fn-ptr-qualifier.stderr create mode 100644 src/test/ui/parser/if-in-in.fixed create mode 100644 src/test/ui/parser/issue-10392-2.fixed create mode 100644 src/test/ui/parser/issue-3036.fixed create mode 100644 src/test/ui/parser/issue-70388-without-witness.fixed create mode 100644 src/test/ui/parser/issue-70388-without-witness.rs create mode 100644 src/test/ui/parser/issue-70388-without-witness.stderr create mode 100644 src/test/ui/parser/let-binop.fixed create mode 100644 src/test/ui/parser/match-refactor-to-expr.fixed create mode 100644 src/test/ui/parser/range_inclusive.fixed create mode 100644 src/test/ui/path-lookahead.fixed create mode 100644 src/test/ui/pub/pub-ident-fn-2.fixed create mode 100644 src/test/ui/pub/pub-ident-fn-with-lifetime.fixed create mode 100644 src/test/ui/pub/pub-ident-struct.fixed create mode 100644 src/test/ui/range/range-inclusive-pattern-precedence.fixed create mode 100644 src/test/ui/range/range-inclusive-pattern-precedence2.rs create mode 100644 src/test/ui/range/range-inclusive-pattern-precedence2.stderr create mode 100644 src/test/ui/resolve/token-error-correct-4.fixed create mode 100644 src/test/ui/resolve/token-error-correct-4.rs create mode 100644 src/test/ui/resolve/token-error-correct-4.stderr create mode 100644 src/test/ui/similar-tokens.fixed create mode 100644 src/test/ui/structs/struct-duplicate-comma.fixed create mode 100644 src/test/ui/structs/struct-missing-comma.fixed create mode 100644 src/test/ui/suggestions/struct-initializer-comma.fixed create mode 100644 src/test/ui/suggestions/suggest-remove-refs-1.fixed create mode 100644 src/test/ui/suggestions/suggest-remove-refs-2.fixed create mode 100644 src/test/ui/suggestions/suggest-remove-refs-3.fixed create mode 100644 src/test/ui/try-block/try-block-unused-delims.fixed create mode 100644 src/test/ui/typeck/issue-73592-borrow_mut-through-deref.fixed create mode 100644 src/test/ui/unused/unused-mut-warning-captured-var.fixed diff --git a/src/librustc_parse/parser/diagnostics.rs b/src/librustc_parse/parser/diagnostics.rs index e27bbc532cfc4..1390548480e91 100644 --- a/src/librustc_parse/parser/diagnostics.rs +++ b/src/librustc_parse/parser/diagnostics.rs @@ -1219,10 +1219,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 04074479a21a4..cf2b07228615d 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/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/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-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/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)] | ^^^^^^^^^^ From 84282fd6f17235ca52613bbfd1cb6be301897836 Mon Sep 17 00:00:00 2001 From: Yuki Okushi Date: Thu, 2 Jul 2020 15:17:39 +0900 Subject: [PATCH 03/12] Audit uses of `tool_only_span_suggestion` --- src/librustc_builtin_macros/format.rs | 2 ++ ...egative-outlives-bound-syntactic-fail.fixed | 14 ++++++++++++++ ...6-negative-outlives-bound-syntactic-fail.rs | 8 +++++--- ...gative-outlives-bound-syntactic-fail.stderr | 18 +++++++++--------- .../resolve-conflict-import-vs-import.fixed | 9 +++++++++ .../resolve-conflict-import-vs-import.rs | 3 +++ .../resolve-conflict-import-vs-import.stderr | 2 +- 7 files changed, 43 insertions(+), 13 deletions(-) create mode 100644 src/test/ui/parser/issue-67146-negative-outlives-bound-syntactic-fail.fixed create mode 100644 src/test/ui/resolve/resolve-conflict-import-vs-import.fixed diff --git a/src/librustc_builtin_macros/format.rs b/src/librustc_builtin_macros/format.rs index e574b076bf84c..e3ac4efe1a00e 100644 --- a/src/librustc_builtin_macros/format.rs +++ b/src/librustc_builtin_macros/format.rs @@ -277,6 +277,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/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/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 From 1b747a030f2dc1eba63f50f2c5f43938538e0c6a Mon Sep 17 00:00:00 2001 From: David Wood Date: Thu, 2 Jul 2020 16:20:59 +0100 Subject: [PATCH 04/12] mir: mark mir construction temporaries as internal This commit marks temporaries from MIR construction as internal such that they are skipped in `sanitize_witness` (where each MIR local is checked to have been contained within the generator interior computed during typeck). This resolves an ICE whereby the construction of checked addition introduced a `(u64, bool)` temporary which was not in the HIR and thus not in the generator interior. Signed-off-by: David Wood --- src/librustc_mir_build/build/misc.rs | 4 +++- src/test/ui/issue-73914.rs | 30 ++++++++++++++++++++++++++++ 2 files changed, 33 insertions(+), 1 deletion(-) create mode 100644 src/test/ui/issue-73914.rs 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/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(); +} From 7391bf882a040814f25f65f6b6539e2f521d17ec Mon Sep 17 00:00:00 2001 From: CAD97 Date: Thu, 2 Jul 2020 16:55:54 -0400 Subject: [PATCH 05/12] Move A|Rc::as_ptr from feature(weak_into_raw) to feature(rc_as_ptr) These were stabilized alongside the Weak versions, but having `feature = "weak_.."` on a fn definition for the non-weak pointers is potentially very confusing. --- src/liballoc/rc.rs | 2 +- src/liballoc/sync.rs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/liballoc/rc.rs b/src/liballoc/rc.rs index 4d50ae9efca95..f864852ec6324 100644 --- a/src/liballoc/rc.rs +++ b/src/liballoc/rc.rs @@ -1706,7 +1706,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 offset = data_offset_sized::(); let ptr = self.ptr.cast::().as_ptr().wrapping_offset(offset); diff --git a/src/liballoc/sync.rs b/src/liballoc/sync.rs index 826f0c8fa833f..0bead76a501c8 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); let fake_ptr = ptr as *mut T; From 2f314268b8c9ddc0ecbeeba67b036bc02e8d5f5b Mon Sep 17 00:00:00 2001 From: Kristofer Rye Date: Sun, 5 Jul 2020 11:56:41 -0500 Subject: [PATCH 06/12] rustdoc: Restore underline text decoration on hover for FQN in header This causes the components of FQN's to behave similarly to other links in the contents of rustdoc-styled pages. I (and I hope others at least in part) have found the prior design to be somewhat confusing, as it is not clear (upon hovering) that the various parts of the FQN are actually links that the user can navigate to. In short, this patch makes links in the FQN have an underline when the user hovers over them, more clearly indicating that they can be used for navigation. Signed-off-by: Kristofer Rye --- src/librustdoc/html/static/rustdoc.css | 3 +++ 1 file changed, 3 insertions(+) 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; } From 5fa19ad2bb7e6af6f05a299f2ab0120c6d2e4c54 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tomasz=20Mi=C4=85sko?= Date: Mon, 6 Jul 2020 00:00:00 +0000 Subject: [PATCH 07/12] Remove unused RUSTC_DEBUG_ASSERTIONS Since #73374 the rustc wrapper no longer configures debug assertions based on RUSTC_DEBUG_ASSERTIONS environment variable. --- src/bootstrap/test.rs | 2 -- 1 file changed, 2 deletions(-) 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")); From 7d7f167cdec82011e6f990afabc18d6e04f0abcd Mon Sep 17 00:00:00 2001 From: Andy Russell Date: Fri, 3 Jul 2020 14:13:22 -0400 Subject: [PATCH 08/12] libstd: remove some mutable statics in sys::unix --- src/libstd/sys/unix/args.rs | 19 +++++++++++-------- src/libstd/sys/unix/stack_overflow.rs | 13 +++++++------ src/libstd/sys/unix/thread.rs | 23 +++++++++++++---------- 3 files changed, 31 insertions(+), 24 deletions(-) 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")) { From f226e6bf0a97a04e57f29a3c8769c8cdc8263ebf Mon Sep 17 00:00:00 2001 From: Dan Gohman Date: Fri, 3 Jul 2020 16:20:37 -0700 Subject: [PATCH 09/12] Add `read_exact_at` and `write_all_at` to WASI's `FileExt` This adds `read_exact_at` and `write_all_at` to WASI's `FileExt`, similar to the Unix versions of the same names. --- src/libstd/sys/wasi/ext/fs.rs | 94 +++++++++++++++++++++++++++++++++++ 1 file changed, 94 insertions(+) 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 From 6196eaa0b1ca4e7857d8d62817aebf3b03216a57 Mon Sep 17 00:00:00 2001 From: Dan Gohman Date: Fri, 3 Jul 2020 12:05:59 -0700 Subject: [PATCH 10/12] Fix the return type of Windows' `OpenOptionsExt::security_qos_flags`. This adjusts the return type of Windows' `OpenOptionsExt::security_qos_flags` to be consistent with the other functions in the trait. --- src/libstd/sys/windows/ext/fs.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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")] From e46c18768e3c0f046942b907d32b3c02c100b163 Mon Sep 17 00:00:00 2001 From: Joshua Nelson Date: Sun, 5 Jul 2020 21:20:31 -0400 Subject: [PATCH 11/12] Always resolve type@primitive as a primitive, not a module Previously, if there were a module in scope with the same name as the primitive, that would take precedence. Coupled with https://github.com/rust-lang/rust/issues/58699, this made it impossible to link to the primitive when that module was in scope. This approach could be extended so that `struct@foo` would no longer resolve to any type, etc. However, it could not be used for glob imports: ```rust pub mod foo { pub struct Bar; } pub enum Bar {} use foo::*; // This is expected to link to `inner::Bar`, but instead it will link to the enum. /// Link to [struct@Bar] pub struct MyDocs; ``` The reason for this is that this change does not affect the resolution algorithm of rustc_resolve at all. The only reason we could special-case primitives is because we have a list of all possible primitives ahead of time. --- .../passes/collect_intra_doc_links.rs | 33 ++++++++++++++++--- .../rustdoc/intra-link-prim-precedence.rs | 12 +++++++ 2 files changed, 40 insertions(+), 5 deletions(-) create mode 100644 src/test/rustdoc/intra-link-prim-precedence.rs 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/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; From fdd39a343efba586227773499b366a4e8a8f8df8 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Mon, 6 Jul 2020 10:26:49 +0200 Subject: [PATCH 12/12] Add rust-analyzer to the build manifest --- src/tools/build-manifest/README.md | 2 +- src/tools/build-manifest/src/main.rs | 26 ++++++++++++++++++++++++-- 2 files changed, 25 insertions(+), 3 deletions(-) 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,