Not linting irrefutable_let_patterns on let chains

Author: Natural-selection1

compiler/rustc_mir_build/src/thir/pattern/check_match.rs

@@ -569,6 +569,11 @@ impl<'p, 'tcx> MatchVisitor<'p, 'tcx> {
     ) {
         assert!(self.let_source != LetSource::None);
 
+        // for let chains, don't emit IRREFUTABLE_LET_PATTERNS
+        if chain_refutabilities.len() > 1 {
+            return;
+        }
+
         if chain_refutabilities.iter().all(|r| matches!(*r, Some((_, Irrefutable)))) {
             // The entire chain is made up of irrefutable `let` statements
             report_irrefutable_let_patterns(

src/tools/miri/src/shims/foreign_items.rs

@@ -900,7 +900,7 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
             // Fallback to shims in submodules.
             _ => {
                 // Math shims
-                #[expect(irrefutable_let_patterns)]
+                #[allow(irrefutable_let_patterns)]
                 if let res = shims::math::EvalContextExt::emulate_foreign_item_inner(
                     this, link_name, abi, args, dest,
                 )? && !matches!(res, EmulateItemResult::NotSupported)

tests/ui/binding/irrefutable-in-let-chains.rs

@@ -0,0 +1,46 @@
+//@ run-pass
+//@ edition:2024
+
+#![allow(unused)]
+
+enum Outer {
+    Middle(Middle),
+}
+enum Middle {
+    Inner(Inner),
+    Other(bool),
+}
+struct Inner {
+    id: u32,
+}
+
+fn test_1(outer: Outer) {
+    if let Outer::Middle(middle) = outer
+        && let Middle::Inner(internal) = middle
+        && let Inner { id } = internal
+    {
+        println!("{id}");
+    }
+}
+
+fn test_2() -> usize { 42 }
+
+fn test_3() -> Outer {
+    Outer::Middle(Middle::Inner(Inner { id: 1 }))
+}
+
+fn main() {
+    if let mx = test_2() && mx < usize::MAX {
+        println!("{mx}");
+    } else if let x = test_2() && x > 0 {
+        println!("{x}");
+    }
+
+    while let Outer::Middle(middle) = test_3()
+        && let Middle::Inner(inner) = middle
+        && let Inner { id } = inner
+        && id > 5
+    {
+        println!("{id}");
+    }
+}

tests/ui/rfcs/rfc-2497-if-let-chains/irrefutable-lets.disallowed.stderr

@@ -1,40 +1,33 @@
 //@ revisions: allowed disallowed
-//@[allowed] check-pass
+//@ run-pass
 //@ edition: 2024
 
 #![feature(if_let_guard)]
 #![cfg_attr(allowed, allow(irrefutable_let_patterns))]
 #![cfg_attr(disallowed, deny(irrefutable_let_patterns))]
+#![allow(unused)]
 
 use std::ops::Range;
 
 fn main() {
     let opt = Some(None..Some(1));
 
     if let first = &opt && let Some(second) = first && let None = second.start {}
-    //[disallowed]~^ ERROR leading irrefutable pattern in let chain
 
     // No lint as the irrefutable pattern is surrounded by other stuff
     if 4 * 2 == 0 && let first = &opt && let Some(second) = first && let None = second.start {}
 
     if let first = &opt && let (a, b) = (1, 2) {}
-    //[disallowed]~^ ERROR irrefutable `if let` patterns
 
     if let first = &opt && let Some(second) = first && let None = second.start && let v = 0 {}
-    //[disallowed]~^ ERROR leading irrefutable pattern in let chain
-    //[disallowed]~^^ ERROR trailing irrefutable pattern in let chain
 
     if let Some(ref first) = opt && let second = first && let _third = second {}
-    //[disallowed]~^ ERROR trailing irrefutable patterns in let chain
 
     if let Range { start: local_start, end: _ } = (None..Some(1)) && let None = local_start {}
-    //[disallowed]~^ ERROR leading irrefutable pattern in let chain
 
     if let (a, b, c) = (Some(1), Some(1), Some(1)) && let None = Some(1) {}
-    //[disallowed]~^ ERROR leading irrefutable pattern in let chain
 
     if let first = &opt && let None = Some(1) {}
-    //[disallowed]~^ ERROR leading irrefutable pattern in let chain
 
     if let Some(ref first) = opt
         && let Range { start: local_start, end: _ } = first
@@ -43,7 +36,6 @@ fn main() {
 
     match opt {
         Some(ref first) if let second = first && let _third = second && let v = 4 + 4 => {},
-        //[disallowed]~^ ERROR irrefutable `if let` guard patterns
         _ => {}
     }
 
@@ -58,23 +50,22 @@ fn main() {
     match opt {
         Some(ref first) if let Range { start: Some(_), end: local_end } = first
             && let v = local_end && let w = v => {},
-        //[disallowed]~^ ERROR trailing irrefutable patterns in let chain
         _ => {}
     }
 
     // No error, despite the prefix being irrefutable: moving out could change the behaviour,
     // due to possible side effects of the operation.
-    while let first = &opt && let Some(second) = first && let None = second.start {}
+    while let first = &opt && let Some(second) = first && let None = second.start { break; }
 
-    while let first = &opt && let (a, b) = (1, 2) {}
-    //[disallowed]~^ ERROR irrefutable `while let` patterns
+    while let first = &opt && let (a, b) = (1, 2) { break; }
 
-    while let Some(ref first) = opt && let second = first && let _third = second {}
-    //[disallowed]~^ ERROR trailing irrefutable patterns in let chain
+    while let Some(ref first) = opt && let second = first && let _third = second { break; }
 
     while let Some(ref first) = opt
         && let Range { start: local_start, end: _ } = first
-        && let None = local_start {
+        && let None = local_start
+    {
+        break;
     }
 
     // No error. An extra nesting level would be required for the `else if`.
@@ -86,13 +77,11 @@ fn main() {
     if opt == Some(None..None) {
     } else if opt.is_some()
         && let x = &opt
-        //[disallowed]~^ ERROR trailing irrefutable pattern in let chain
     {}
 
     if opt == Some(None..None) {
     } else {
         if let x = opt.clone().map(|_| 1)
-        //[disallowed]~^ ERROR leading irrefutable pattern in let chain
             && x == Some(1)
         {}
     }