Add more detail to irrefutable let pattern lint

estebank · estebank · commit 9fe250089fa9 · 2021-02-25T10:16:24.000-08:00
diff --git a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -366,31 +366,38 @@ fn unreachable_pattern(tcx: TyCtxt<'_>, span: Span, id: HirId, catchall: Option<
 }
 
 fn irrefutable_let_pattern(tcx: TyCtxt<'_>, span: Span, id: HirId, source: hir::MatchSource) {
-    tcx.struct_span_lint_hir(IRREFUTABLE_LET_PATTERNS, id, span, |lint| match source {
-        hir::MatchSource::IfLetDesugar { .. } => {
-            let mut diag = lint.build("irrefutable `if let` pattern");
-            diag.note("this pattern will always match, so the `if let` is useless");
-            diag.help("consider replacing the `if let` with a `let`");
-            diag.emit()
-        }
-        hir::MatchSource::WhileLetDesugar { .. } => {
-            let mut diag = lint.build("irrefutable `while let` pattern");
-            diag.note("this pattern will always match, so the loop will never exit");
-            diag.help("consider instead using a `loop { ... }` with a `let` inside it");
-            diag.emit()
-        }
-        hir::MatchSource::IfLetGuardDesugar { .. }=> {
-            let mut diag = lint.build("irrefutable `if let` guard pattern");
-            diag.note("this pattern will always match, so the guard is useless");
-            diag.help("consider removing the guard and adding a `let` inside the match arm");
-            diag.emit()
-        }
-        _ => {
-            bug!(
-                "expected `if let`, `while let`, or `if let` guard HIR match source, found {:?}",
-                source,
-            )
-        }
+    tcx.struct_span_lint_hir(IRREFUTABLE_LET_PATTERNS, id, span, |lint| {
+        let mut diag = match source {
+            hir::MatchSource::IfLetDesugar { .. } => {
+                let mut diag = lint.build("irrefutable `if let` pattern");
+                diag.span_label(span, "this pattern will always match, so the `if let` is useless");
+                diag.help("consider replacing the `if let` with a `let`");
+                diag
+            }
+            hir::MatchSource::WhileLetDesugar { .. } => {
+                let mut diag = lint.build("irrefutable `while let` pattern");
+                diag.span_label(span, "this pattern will always match, so the loop will never exit");
+                diag.help("consider instead using a `loop { ... }` with a `let` inside it");
+                diag
+            }
+            hir::MatchSource::IfLetGuardDesugar { .. }=> {
+                let mut diag = lint.build("irrefutable `if let` guard pattern");
+                diag.span_label(span, "this pattern will always match, so the guard is useless");
+                diag.help("consider removing the guard and adding a `let` inside the match arm");
+                diag
+            }
+            _ => {
+                bug!(
+                    "expected `if let`, `while let`, or `if let` guard HIR match source, found {:?}",
+                    source,
+                )
+            }
+        };
+        diag.help(
+            "for more information, visit \
+             <https://doc.rust-lang.org/book/ch18-02-refutability.html>",
+        );
+        diag.emit();
     });
 }
 
diff --git a/src/test/ui/closures/2229_closure_analysis/diagnostics/closure-origin-single-variant-diagnostics.stderr b/src/test/ui/closures/2229_closure_analysis/diagnostics/closure-origin-single-variant-diagnostics.stderr
@@ -11,11 +11,11 @@ warning: irrefutable `if let` pattern
   --> $DIR/closure-origin-single-variant-diagnostics.rs:18:12
    |
 LL |         if let SingleVariant::Point(ref mut x, _) = point {
-   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this pattern will always match, so the `if let` is useless
    |
    = note: `#[warn(irrefutable_let_patterns)]` on by default
-   = note: this pattern will always match, so the `if let` is useless
    = help: consider replacing the `if let` with a `let`
+   = help: for more information, visit <https://doc.rust-lang.org/book/ch18-02-refutability.html>
 
 error[E0382]: use of moved value: `c`
   --> $DIR/closure-origin-single-variant-diagnostics.rs:25:13
diff --git a/src/test/ui/expr/if/if-let.stderr b/src/test/ui/expr/if/if-let.stderr
@@ -2,68 +2,68 @@ warning: irrefutable `if let` pattern
   --> $DIR/if-let.rs:6:16
    |
 LL |               if let $p = $e $b
-   |                  ^^^
+   |                  ^^^ this pattern will always match, so the `if let` is useless
 ...
 LL | /     foo!(a, 1, {
 LL | |         println!("irrefutable pattern");
 LL | |     });
    | |_______- in this macro invocation
    |
    = note: `#[warn(irrefutable_let_patterns)]` on by default
-   = note: this pattern will always match, so the `if let` is useless
    = help: consider replacing the `if let` with a `let`
+   = help: for more information, visit <https://doc.rust-lang.org/book/ch18-02-refutability.html>
    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
 warning: irrefutable `if let` pattern
   --> $DIR/if-let.rs:6:16
    |
 LL |               if let $p = $e $b
-   |                  ^^^
+   |                  ^^^ this pattern will always match, so the `if let` is useless
 ...
 LL | /     bar!(a, 1, {
 LL | |         println!("irrefutable pattern");
 LL | |     });
    | |_______- in this macro invocation
    |
-   = note: this pattern will always match, so the `if let` is useless
    = help: consider replacing the `if let` with a `let`
+   = help: for more information, visit <https://doc.rust-lang.org/book/ch18-02-refutability.html>
    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
 warning: irrefutable `if let` pattern
   --> $DIR/if-let.rs:26:8
    |
 LL |     if let a = 1 {
-   |        ^^^^^^^^^
+   |        ^^^^^^^^^ this pattern will always match, so the `if let` is useless
    |
-   = note: this pattern will always match, so the `if let` is useless
    = help: consider replacing the `if let` with a `let`
+   = help: for more information, visit <https://doc.rust-lang.org/book/ch18-02-refutability.html>
 
 warning: irrefutable `if let` pattern
   --> $DIR/if-let.rs:30:8
    |
 LL |     if let a = 1 {
-   |        ^^^^^^^^^
+   |        ^^^^^^^^^ this pattern will always match, so the `if let` is useless
    |
-   = note: this pattern will always match, so the `if let` is useless
    = help: consider replacing the `if let` with a `let`
+   = help: for more information, visit <https://doc.rust-lang.org/book/ch18-02-refutability.html>
 
 warning: irrefutable `if let` pattern
   --> $DIR/if-let.rs:40:15
    |
 LL |     } else if let a = 1 {
-   |               ^^^^^^^^^
+   |               ^^^^^^^^^ this pattern will always match, so the `if let` is useless
    |
-   = note: this pattern will always match, so the `if let` is useless
    = help: consider replacing the `if let` with a `let`
+   = help: for more information, visit <https://doc.rust-lang.org/book/ch18-02-refutability.html>
 
 warning: irrefutable `if let` pattern
   --> $DIR/if-let.rs:46:15
    |
 LL |     } else if let a = 1 {
-   |               ^^^^^^^^^
+   |               ^^^^^^^^^ this pattern will always match, so the `if let` is useless
    |
-   = note: this pattern will always match, so the `if let` is useless
    = help: consider replacing the `if let` with a `let`
+   = help: for more information, visit <https://doc.rust-lang.org/book/ch18-02-refutability.html>
 
 warning: 6 warnings emitted
 
diff --git a/src/test/ui/pattern/usefulness/deny-irrefutable-let-patterns.stderr b/src/test/ui/pattern/usefulness/deny-irrefutable-let-patterns.stderr
@@ -2,33 +2,33 @@ error: irrefutable `if let` pattern
   --> $DIR/deny-irrefutable-let-patterns.rs:7:8
    |
 LL |     if let _ = 5 {}
-   |        ^^^^^^^^^
+   |        ^^^^^^^^^ this pattern will always match, so the `if let` is useless
    |
 note: the lint level is defined here
   --> $DIR/deny-irrefutable-let-patterns.rs:4:9
    |
 LL | #![deny(irrefutable_let_patterns)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
-   = note: this pattern will always match, so the `if let` is useless
    = help: consider replacing the `if let` with a `let`
+   = help: for more information, visit <https://doc.rust-lang.org/book/ch18-02-refutability.html>
 
 error: irrefutable `while let` pattern
   --> $DIR/deny-irrefutable-let-patterns.rs:9:11
    |
 LL |     while let _ = 5 {
-   |           ^^^^^^^^^
+   |           ^^^^^^^^^ this pattern will always match, so the loop will never exit
    |
-   = note: this pattern will always match, so the loop will never exit
    = help: consider instead using a `loop { ... }` with a `let` inside it
+   = help: for more information, visit <https://doc.rust-lang.org/book/ch18-02-refutability.html>
 
 error: irrefutable `if let` guard pattern
   --> $DIR/deny-irrefutable-let-patterns.rs:14:14
    |
 LL |         _ if let _ = 2 => {}
-   |              ^^^^^^^^^
+   |              ^^^^^^^^^ this pattern will always match, so the guard is useless
    |
-   = note: this pattern will always match, so the guard is useless
    = help: consider removing the guard and adding a `let` inside the match arm
+   = help: for more information, visit <https://doc.rust-lang.org/book/ch18-02-refutability.html>
 
 error: aborting due to 3 previous errors
 
diff --git a/src/test/ui/rfc-2294-if-let-guard/warns.stderr b/src/test/ui/rfc-2294-if-let-guard/warns.stderr
@@ -2,15 +2,15 @@ error: irrefutable `if let` guard pattern
   --> $DIR/warns.rs:7:20
    |
 LL |         Some(x) if let () = x => {}
-   |                    ^^^^^^^^^^
+   |                    ^^^^^^^^^^ this pattern will always match, so the guard is useless
    |
 note: the lint level is defined here
   --> $DIR/warns.rs:4:8
    |
 LL | #[deny(irrefutable_let_patterns)]
    |        ^^^^^^^^^^^^^^^^^^^^^^^^
-   = note: this pattern will always match, so the guard is useless
    = help: consider removing the guard and adding a `let` inside the match arm
+   = help: for more information, visit <https://doc.rust-lang.org/book/ch18-02-refutability.html>
 
 error: unreachable pattern
   --> $DIR/warns.rs:16:25
diff --git a/src/test/ui/while-let.stderr b/src/test/ui/while-let.stderr
@@ -2,41 +2,41 @@ warning: irrefutable `while let` pattern
   --> $DIR/while-let.rs:7:19
    |
 LL |               while let $p = $e $b
-   |                     ^^^
+   |                     ^^^ this pattern will always match, so the loop will never exit
 ...
 LL | /     foo!(_a, 1, {
 LL | |         println!("irrefutable pattern");
 LL | |     });
    | |_______- in this macro invocation
    |
    = note: `#[warn(irrefutable_let_patterns)]` on by default
-   = note: this pattern will always match, so the loop will never exit
    = help: consider instead using a `loop { ... }` with a `let` inside it
+   = help: for more information, visit <https://doc.rust-lang.org/book/ch18-02-refutability.html>
    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
 warning: irrefutable `while let` pattern
   --> $DIR/while-let.rs:7:19
    |
 LL |               while let $p = $e $b
-   |                     ^^^
+   |                     ^^^ this pattern will always match, so the loop will never exit
 ...
 LL | /     bar!(_a, 1, {
 LL | |         println!("irrefutable pattern");
 LL | |     });
    | |_______- in this macro invocation
    |
-   = note: this pattern will always match, so the loop will never exit
    = help: consider instead using a `loop { ... }` with a `let` inside it
+   = help: for more information, visit <https://doc.rust-lang.org/book/ch18-02-refutability.html>
    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
 warning: irrefutable `while let` pattern
   --> $DIR/while-let.rs:27:11
    |
 LL |     while let _a = 1 {
-   |           ^^^^^^^^^^
+   |           ^^^^^^^^^^ this pattern will always match, so the loop will never exit
    |
-   = note: this pattern will always match, so the loop will never exit
    = help: consider instead using a `loop { ... }` with a `let` inside it
+   = help: for more information, visit <https://doc.rust-lang.org/book/ch18-02-refutability.html>
 
 warning: 3 warnings emitted
 

Original file line number	Diff line number	Diff line change
@@ -11,11 +11,11 @@ warning: irrefutable `if let` pattern
`11`	`11`	`--> $DIR/closure-origin-single-variant-diagnostics.rs:18:12`
`12`	`12`	`\|`
`13`	`13`	`LL \| if let SingleVariant::Point(ref mut x, _) = point {`
`14`		`- \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
	`14`	+ \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this pattern will always match, so the `if let` is useless
`15`	`15`	`\|`
`16`	`16`	= note: `#[warn(irrefutable_let_patterns)]` on by default
`17`		- = note: this pattern will always match, so the `if let` is useless
`18`	`17`	= help: consider replacing the `if let` with a `let`
	`18`	`+ = help: for more information, visit <https://doc.rust-lang.org/book/ch18-02-refutability.html>`
`19`	`19`
`20`	`20`	error[E0382]: use of moved value: `c`
`21`	`21`	`--> $DIR/closure-origin-single-variant-diagnostics.rs:25:13`
Original file line number	Diff line number	Diff line change
@@ -2,33 +2,33 @@ error: irrefutable `if let` pattern
`2`	`2`	`--> $DIR/deny-irrefutable-let-patterns.rs:7:8`
`3`	`3`	`\|`
`4`	`4`	`LL \| if let _ = 5 {}`
`5`		`- \| ^^^^^^^^^`
	`5`	+ \| ^^^^^^^^^ this pattern will always match, so the `if let` is useless
`6`	`6`	`\|`
`7`	`7`	`note: the lint level is defined here`
`8`	`8`	`--> $DIR/deny-irrefutable-let-patterns.rs:4:9`
`9`	`9`	`\|`
`10`	`10`	`LL \| #![deny(irrefutable_let_patterns)]`
`11`	`11`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^`
`12`		- = note: this pattern will always match, so the `if let` is useless
`13`	`12`	= help: consider replacing the `if let` with a `let`
	`13`	`+ = help: for more information, visit <https://doc.rust-lang.org/book/ch18-02-refutability.html>`
`14`	`14`
`15`	`15`	error: irrefutable `while let` pattern
`16`	`16`	`--> $DIR/deny-irrefutable-let-patterns.rs:9:11`
`17`	`17`	`\|`
`18`	`18`	`LL \| while let _ = 5 {`
`19`		`- \| ^^^^^^^^^`
	`19`	`+ \| ^^^^^^^^^ this pattern will always match, so the loop will never exit`
`20`	`20`	`\|`
`21`		`- = note: this pattern will always match, so the loop will never exit`
`22`	`21`	= help: consider instead using a `loop { ... }` with a `let` inside it
	`22`	`+ = help: for more information, visit <https://doc.rust-lang.org/book/ch18-02-refutability.html>`
`23`	`23`
`24`	`24`	error: irrefutable `if let` guard pattern
`25`	`25`	`--> $DIR/deny-irrefutable-let-patterns.rs:14:14`
`26`	`26`	`\|`
`27`	`27`	`LL \| _ if let _ = 2 => {}`
`28`		`- \| ^^^^^^^^^`
	`28`	`+ \| ^^^^^^^^^ this pattern will always match, so the guard is useless`
`29`	`29`	`\|`
`30`		`- = note: this pattern will always match, so the guard is useless`
`31`	`30`	= help: consider removing the guard and adding a `let` inside the match arm
	`31`	`+ = help: for more information, visit <https://doc.rust-lang.org/book/ch18-02-refutability.html>`
`32`	`32`
`33`	`33`	`error: aborting due to 3 previous errors`
`34`	`34`
Original file line number	Diff line number	Diff line change
@@ -2,15 +2,15 @@ error: irrefutable `if let` guard pattern
`2`	`2`	`--> $DIR/warns.rs:7:20`
`3`	`3`	`\|`
`4`	`4`	`LL \| Some(x) if let () = x => {}`
`5`		`- \| ^^^^^^^^^^`
	`5`	`+ \| ^^^^^^^^^^ this pattern will always match, so the guard is useless`
`6`	`6`	`\|`
`7`	`7`	`note: the lint level is defined here`
`8`	`8`	`--> $DIR/warns.rs:4:8`
`9`	`9`	`\|`
`10`	`10`	`LL \| #[deny(irrefutable_let_patterns)]`
`11`	`11`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^`
`12`		`- = note: this pattern will always match, so the guard is useless`
`13`	`12`	= help: consider removing the guard and adding a `let` inside the match arm
	`13`	`+ = help: for more information, visit <https://doc.rust-lang.org/book/ch18-02-refutability.html>`
`14`	`14`
`15`	`15`	`error: unreachable pattern`
`16`	`16`	`--> $DIR/warns.rs:16:25`