Not linting irrefutable_let_patterns on let chains

Author: Natural-selection1

compiler/rustc_mir_build/src/errors.rs

@@ -765,22 +765,6 @@ pub(crate) struct LowerRangeBoundMustBeLessThanUpper {
     pub(crate) span: Span,
 }
 
-#[derive(LintDiagnostic)]
-#[diag(mir_build_leading_irrefutable_let_patterns)]
-#[note]
-#[help]
-pub(crate) struct LeadingIrrefutableLetPatterns {
-    pub(crate) count: usize,
-}
-
-#[derive(LintDiagnostic)]
-#[diag(mir_build_trailing_irrefutable_let_patterns)]
-#[note]
-#[help]
-pub(crate) struct TrailingIrrefutableLetPatterns {
-    pub(crate) count: usize,
-}
-
 #[derive(LintDiagnostic)]
 #[diag(mir_build_bindings_with_variant_name, code = E0170)]
 pub(crate) struct BindingsWithVariantName {

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

@@ -168,9 +168,9 @@ impl<'p, 'tcx> Visitor<'p, 'tcx> for MatchVisitor<'p, 'tcx> {
             {
                 let mut chain_refutabilities = Vec::new();
                 let Ok(()) = self.visit_land(ex, &mut chain_refutabilities) else { return };
-                // If at least one of the operands is a `let ... = ...`.
-                if chain_refutabilities.iter().any(|x| x.is_some()) {
-                    self.check_let_chain(chain_refutabilities, ex.span);
+                // For let chains, don't lint.
+                if let [Some((_, refutability))] = chain_refutabilities[..] {
+                    self.check_single_let(refutability, ex.span);
                 }
                 return;
             }
@@ -562,73 +562,16 @@ impl<'p, 'tcx> MatchVisitor<'p, 'tcx> {
     }
 
     #[instrument(level = "trace", skip(self))]
-    fn check_let_chain(
-        &mut self,
-        chain_refutabilities: Vec<Option<(Span, RefutableFlag)>>,
-        whole_chain_span: Span,
-    ) {
+    fn check_single_let(&mut self, refutability: RefutableFlag, whole_chain_span: Span) {
         assert!(self.let_source != LetSource::None);
-
-        if chain_refutabilities.iter().all(|r| matches!(*r, Some((_, Irrefutable)))) {
-            // The entire chain is made up of irrefutable `let` statements
+        if matches!(refutability, Irrefutable) {
             report_irrefutable_let_patterns(
                 self.tcx,
                 self.lint_level,
                 self.let_source,
-                chain_refutabilities.len(),
+                1,
                 whole_chain_span,
             );
-            return;
-        }
-
-        if let Some(until) =
-            chain_refutabilities.iter().position(|r| !matches!(*r, Some((_, Irrefutable))))
-            && until > 0
-        {
-            // The chain has a non-zero prefix of irrefutable `let` statements.
-
-            // Check if the let source is while, for there is no alternative place to put a prefix,
-            // and we shouldn't lint.
-            // For let guards inside a match, prefixes might use bindings of the match pattern,
-            // so can't always be moved out.
-            // For `else if let`, an extra indentation level would be required to move the bindings.
-            // FIXME: Add checking whether the bindings are actually used in the prefix,
-            // and lint if they are not.
-            if !matches!(
-                self.let_source,
-                LetSource::WhileLet | LetSource::IfLetGuard | LetSource::ElseIfLet
-            ) {
-                // Emit the lint
-                let prefix = &chain_refutabilities[..until];
-                let span_start = prefix[0].unwrap().0;
-                let span_end = prefix.last().unwrap().unwrap().0;
-                let span = span_start.to(span_end);
-                let count = prefix.len();
-                self.tcx.emit_node_span_lint(
-                    IRREFUTABLE_LET_PATTERNS,
-                    self.lint_level,
-                    span,
-                    LeadingIrrefutableLetPatterns { count },
-                );
-            }
-        }
-
-        if let Some(from) =
-            chain_refutabilities.iter().rposition(|r| !matches!(*r, Some((_, Irrefutable))))
-            && from != (chain_refutabilities.len() - 1)
-        {
-            // The chain has a non-empty suffix of irrefutable `let` statements
-            let suffix = &chain_refutabilities[from + 1..];
-            let span_start = suffix[0].unwrap().0;
-            let span_end = suffix.last().unwrap().unwrap().0;
-            let span = span_start.to(span_end);
-            let count = suffix.len();
-            self.tcx.emit_node_span_lint(
-                IRREFUTABLE_LET_PATTERNS,
-                self.lint_level,
-                span,
-                TrailingIrrefutableLetPatterns { count },
-            );
         }
     }
 

compiler/rustc_mir_transform/src/check_alignment.rs

@@ -82,7 +82,7 @@ fn insert_alignment_check<'tcx>(
 
     // If this target does not have reliable alignment, further limit the mask by anding it with
     // the mask for the highest reliable alignment.
-    #[allow(irrefutable_let_patterns)]
+    #[expect(irrefutable_let_patterns)]
     if let max_align = tcx.sess.target.max_reliable_alignment()
         && max_align < Align::MAX
     {

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

@@ -0,0 +1,46 @@
+//@ check-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,29 @@
-//@ revisions: allowed disallowed
-//@[allowed] check-pass
+//@ check-pass
 //@ edition: 2024
 
 #![feature(if_let_guard)]
-#![cfg_attr(allowed, allow(irrefutable_let_patterns))]
-#![cfg_attr(disallowed, deny(irrefutable_let_patterns))]
 
 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 +32,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,7 +46,6 @@ 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
         _ => {}
     }
 
@@ -67,15 +54,13 @@ fn main() {
     while let first = &opt && let Some(second) = first && let None = second.start {}
 
     while let first = &opt && let (a, b) = (1, 2) {}
-    //[disallowed]~^ ERROR irrefutable `while let` patterns
 
     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 Range { start: local_start, end: _ } = first
-        && let None = local_start {
-    }
+        && let None = local_start
+    {}
 
     // No error. An extra nesting level would be required for the `else if`.
     if opt == Some(None..None) {
@@ -86,13 +71,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)
         {}
     }