rust-lang-ci
diff --git a/Diff for: ‎compiler/rustc_parse/src/parser/expr.rs
+54-29 b/Diff for: ‎compiler/rustc_parse/src/parser/expr.rs
+54-29
diff --git a/Diff for: ‎tests/mir-opt/building/logical_or_in_conditional.rs
+1-1 b/Diff for: ‎tests/mir-opt/building/logical_or_in_conditional.rs
+1-1
diff --git a/Diff for: ‎tests/mir-opt/building/logical_or_in_conditional.test_complex.built.after.mir
+20-14 b/Diff for: ‎tests/mir-opt/building/logical_or_in_conditional.test_complex.built.after.mir
+20-14
diff --git a/Diff for: ‎tests/ui/deriving/auxiliary/malicious-macro.rs
+1-1 b/Diff for: ‎tests/ui/deriving/auxiliary/malicious-macro.rs
+1-1
diff --git a/Diff for: ‎tests/ui/drop/drop-order-comparisons.e2021.fixed
+1-1 b/Diff for: ‎tests/ui/drop/drop-order-comparisons.e2021.fixed
+1-1
diff --git a/Diff for: ‎tests/ui/drop/drop-order-comparisons.rs
+1-1 b/Diff for: ‎tests/ui/drop/drop-order-comparisons.rs
+1-1
diff --git a/Diff for: ‎tests/ui/drop/drop_order.rs
+2-1 b/Diff for: ‎tests/ui/drop/drop_order.rs
+2-1
diff --git a/Diff for: ‎tests/ui/drop/drop_order_if_let_rescope.rs
+1-3 b/Diff for: ‎tests/ui/drop/drop_order_if_let_rescope.rs
+1-3
diff --git a/Diff for: ‎tests/ui/drop/issue-100276.rs
+6-1 b/Diff for: ‎tests/ui/drop/issue-100276.rs
+6-1
diff --git a/Diff for: ‎tests/ui/expr/if/attrs/let-chains-attr.rs
+1-2 b/Diff for: ‎tests/ui/expr/if/attrs/let-chains-attr.rs
+1-2
diff --git a/Diff for: ‎tests/ui/lint/issue-121070-let-range.rs
+1-1 b/Diff for: ‎tests/ui/lint/issue-121070-let-range.rs
+1-1
diff --git a/Diff for: ‎tests/ui/mir/issue-99852.rs
+1-1 b/Diff for: ‎tests/ui/mir/issue-99852.rs
+1-1
@@ -26,6 +26,7 @@ use rustc_macros::Subdiagnostic;
 use rustc_session::errors::{ExprParenthesesNeeded, report_lit_error};
 use rustc_session::lint::BuiltinLintDiag;
 use rustc_session::lint::builtin::BREAK_WITH_LABEL_AND_LOOP;
+use rustc_span::edition::Edition;
 use rustc_span::source_map::{self, Spanned};
 use rustc_span::{BytePos, ErrorGuaranteed, Ident, Pos, Span, Symbol, kw, sym};
 use thin_vec::{ThinVec, thin_vec};
@@ -2602,7 +2603,10 @@ impl<'a> Parser<'a> {
     /// Parses an `if` expression (`if` token already eaten).
     fn parse_expr_if(&mut self) -> PResult<'a, P<Expr>> {
         let lo = self.prev_token.span;
-        let cond = self.parse_expr_cond()?;
+        // Scoping code checks the top level edition of the `if`; let's match it here.
+        // The `CondChecker` also checks the edition of the `let` itself, just to make sure.
+        let let_chains_policy = LetChainsPolicy::EditionDependent { current_edition: lo.edition() };
+        let cond = self.parse_expr_cond(let_chains_policy)?;
         self.parse_if_after_cond(lo, cond)
     }
 
@@ -2711,18 +2715,17 @@ impl<'a> Parser<'a> {
     }
 
     /// Parses the condition of a `if` or `while` expression.
+    ///
+    /// The specified `edition` in `let_chains_policy` should be that of the whole `if` construct,
+    /// i.e. the same span we use to later decide whether the drop behaviour should be that of
+    /// edition `..=2021` or that of `2024..`.
     // Public because it is used in rustfmt forks such as https://github.com/tucant/rustfmt/blob/30c83df9e1db10007bdd16dafce8a86b404329b2/src/parse/macros/html.rs#L57 for custom if expressions.
-    pub fn parse_expr_cond(&mut self) -> PResult<'a, P<Expr>> {
+    pub fn parse_expr_cond(&mut self, let_chains_policy: LetChainsPolicy) -> PResult<'a, P<Expr>> {
         let attrs = self.parse_outer_attributes()?;
         let (mut cond, _) =
             self.parse_expr_res(Restrictions::NO_STRUCT_LITERAL | Restrictions::ALLOW_LET, attrs)?;
 
-        CondChecker::new(self).visit_expr(&mut cond);
-
-        if let ExprKind::Let(_, _, _, Recovered::No) = cond.kind {
-            // Remove the last feature gating of a `let` expression since it's stable.
-            self.psess.gated_spans.ungate_last(sym::let_chains, cond.span);
-        }
+        CondChecker::new(self, let_chains_policy).visit_expr(&mut cond);
 
         Ok(cond)
     }
@@ -3017,7 +3020,8 @@ impl<'a> Parser<'a> {
 
     /// Parses a `while` or `while let` expression (`while` token already eaten).
     fn parse_expr_while(&mut self, opt_label: Option<Label>, lo: Span) -> PResult<'a, P<Expr>> {
-        let cond = self.parse_expr_cond().map_err(|mut err| {
+        let policy = LetChainsPolicy::EditionDependent { current_edition: lo.edition() };
+        let cond = self.parse_expr_cond(policy).map_err(|mut err| {
             err.span_label(lo, "while parsing the condition of this `while` expression");
             err
         })?;
@@ -3401,17 +3405,17 @@ impl<'a> Parser<'a> {
     }
 
     fn parse_match_arm_guard(&mut self) -> PResult<'a, Option<P<Expr>>> {
-        // Used to check the `let_chains` and `if_let_guard` features mostly by scanning
+        // Used to check the `if_let_guard` feature mostly by scanning
         // `&&` tokens.
-        fn check_let_expr(expr: &Expr) -> (bool, bool) {
+        fn has_let_expr(expr: &Expr) -> bool {
             match &expr.kind {
                 ExprKind::Binary(BinOp { node: BinOpKind::And, .. }, lhs, rhs) => {
-                    let lhs_rslt = check_let_expr(lhs);
-                    let rhs_rslt = check_let_expr(rhs);
-                    (lhs_rslt.0 || rhs_rslt.0, false)
+                    let lhs_rslt = has_let_expr(lhs);
+                    let rhs_rslt = has_let_expr(rhs);
+                    lhs_rslt || rhs_rslt
                 }
-                ExprKind::Let(..) => (true, true),
-                _ => (false, true),
+                ExprKind::Let(..) => true,
+                _ => false,
             }
         }
         if !self.eat_keyword(exp!(If)) {
@@ -3422,14 +3426,9 @@ impl<'a> Parser<'a> {
         let if_span = self.prev_token.span;
         let mut cond = self.parse_match_guard_condition()?;
 
-        CondChecker::new(self).visit_expr(&mut cond);
+        CondChecker::new(self, LetChainsPolicy::AlwaysAllowed).visit_expr(&mut cond);
 
-        let (has_let_expr, does_not_have_bin_op) = check_let_expr(&cond);
-        if has_let_expr {
-            if does_not_have_bin_op {
-                // Remove the last feature gating of a `let` expression since it's stable.
-                self.psess.gated_spans.ungate_last(sym::let_chains, cond.span);
-            }
+        if has_let_expr(&cond) {
             let span = if_span.to(cond.span);
             self.psess.gated_spans.gate(sym::if_let_guard, span);
         }
@@ -3456,7 +3455,7 @@ impl<'a> Parser<'a> {
                     unreachable!()
                 };
                 self.psess.gated_spans.ungate_last(sym::guard_patterns, cond.span);
-                CondChecker::new(self).visit_expr(&mut cond);
+                CondChecker::new(self, LetChainsPolicy::AlwaysAllowed).visit_expr(&mut cond);
                 let right = self.prev_token.span;
                 self.dcx().emit_err(errors::ParenthesesInMatchPat {
                     span: vec![left, right],
@@ -4027,7 +4026,14 @@ pub(crate) enum ForbiddenLetReason {
     NotSupportedParentheses(#[primary_span] Span),
 }
 
-/// Visitor to check for invalid/unstable use of `ExprKind::Let` that can't
+/// Whether let chains are allowed on all editions, or it's edition dependent (allowed only on
+/// 2024 and later). In case of edition dependence, specify the currently present edition.
+pub enum LetChainsPolicy {
+    AlwaysAllowed,
+    EditionDependent { current_edition: Edition },
+}
+
+/// Visitor to check for invalid use of `ExprKind::Let` that can't
 /// easily be caught in parsing. For example:
 ///
 /// ```rust,ignore (example)
@@ -4038,19 +4044,29 @@ pub(crate) enum ForbiddenLetReason {
 /// ```
 struct CondChecker<'a> {
     parser: &'a Parser<'a>,
+    let_chains_policy: LetChainsPolicy,
+    depth: u32,
     forbid_let_reason: Option<ForbiddenLetReason>,
     missing_let: Option<errors::MaybeMissingLet>,
     comparison: Option<errors::MaybeComparison>,
 }
 
 impl<'a> CondChecker<'a> {
-    fn new(parser: &'a Parser<'a>) -> Self {
-        CondChecker { parser, forbid_let_reason: None, missing_let: None, comparison: None }
+    fn new(parser: &'a Parser<'a>, let_chains_policy: LetChainsPolicy) -> Self {
+        CondChecker {
+            parser,
+            forbid_let_reason: None,
+            missing_let: None,
+            comparison: None,
+            let_chains_policy,
+            depth: 0,
+        }
     }
 }
 
 impl MutVisitor for CondChecker<'_> {
     fn visit_expr(&mut self, e: &mut P<Expr>) {
+        self.depth += 1;
         use ForbiddenLetReason::*;
 
         let span = e.span;
@@ -4065,8 +4081,16 @@ impl MutVisitor for CondChecker<'_> {
                             comparison: self.comparison,
                         },
                     ));
-                } else {
-                    self.parser.psess.gated_spans.gate(sym::let_chains, span);
+                } else if self.depth > 1 {
+                    // Top level `let` is always allowed; only gate chains
+                    match self.let_chains_policy {
+                        LetChainsPolicy::AlwaysAllowed => (),
+                        LetChainsPolicy::EditionDependent { current_edition } => {
+                            if !current_edition.at_least_rust_2024() || !span.at_least_rust_2024() {
+                                self.parser.psess.gated_spans.gate(sym::let_chains, span);
+                            }
+                        }
+                    }
                 }
             }
             ExprKind::Binary(Spanned { node: BinOpKind::And, .. }, _, _) => {
@@ -4168,5 +4192,6 @@ impl MutVisitor for CondChecker<'_> {
                 // These would forbid any let expressions they contain already.
             }
         }
+        self.depth -= 1;
     }
 }
@@ -1,6 +1,6 @@
 // skip-filecheck
 //@ compile-flags: -Z validate-mir
-#![feature(let_chains)]
+//@ edition: 2024
 struct Droppy(u8);
 impl Drop for Droppy {
     fn drop(&mut self) {
 
@@ -19,7 +19,7 @@ fn test_complex() -> () {
     bb0: {
         StorageLive(_1);
         StorageLive(_2);
-        _2 = E::f() -> [return: bb1, unwind: bb34];
+        _2 = E::f() -> [return: bb1, unwind: bb35];
     }
 
     bb1: {
@@ -42,7 +42,7 @@ fn test_complex() -> () {
 
     bb5: {
         StorageLive(_4);
-        _4 = always_true() -> [return: bb6, unwind: bb34];
+        _4 = always_true() -> [return: bb6, unwind: bb35];
     }
 
     bb6: {
@@ -64,7 +64,7 @@ fn test_complex() -> () {
     }
 
     bb9: {
-        drop(_7) -> [return: bb11, unwind: bb34];
+        drop(_7) -> [return: bb11, unwind: bb35];
     }
 
     bb10: {
@@ -78,7 +78,7 @@ fn test_complex() -> () {
     }
 
     bb12: {
-        drop(_7) -> [return: bb13, unwind: bb34];
+        drop(_7) -> [return: bb13, unwind: bb35];
     }
 
     bb13: {
@@ -98,7 +98,7 @@ fn test_complex() -> () {
     }
 
     bb15: {
-        drop(_10) -> [return: bb17, unwind: bb34];
+        drop(_10) -> [return: bb17, unwind: bb35];
     }
 
     bb16: {
@@ -113,11 +113,12 @@ fn test_complex() -> () {
 
     bb18: {
         _1 = const ();
+        StorageDead(_2);
         goto -> bb22;
     }
 
     bb19: {
-        drop(_10) -> [return: bb20, unwind: bb34];
+        drop(_10) -> [return: bb20, unwind: bb35];
     }
 
     bb20: {
@@ -127,6 +128,7 @@ fn test_complex() -> () {
     }
 
     bb21: {
+        StorageDead(_2);
         _1 = const ();
         goto -> bb22;
     }
@@ -135,18 +137,17 @@ fn test_complex() -> () {
         StorageDead(_8);
         StorageDead(_5);
         StorageDead(_4);
-        StorageDead(_2);
         StorageDead(_1);
         StorageLive(_11);
-        _11 = always_true() -> [return: bb23, unwind: bb34];
+        _11 = always_true() -> [return: bb23, unwind: bb35];
     }
 
     bb23: {
         switchInt(move _11) -> [0: bb25, otherwise: bb24];
     }
 
     bb24: {
-        goto -> bb32;
+        goto -> bb33;
     }
 
     bb25: {
@@ -155,7 +156,7 @@ fn test_complex() -> () {
 
     bb26: {
         StorageLive(_12);
-        _12 = E::f() -> [return: bb27, unwind: bb34];
+        _12 = E::f() -> [return: bb27, unwind: bb35];
     }
 
     bb27: {
@@ -178,21 +179,26 @@ fn test_complex() -> () {
 
     bb31: {
         _0 = const ();
-        goto -> bb33;
+        StorageDead(_12);
+        goto -> bb34;
     }
 
     bb32: {
-        _0 = const ();
+        StorageDead(_12);
         goto -> bb33;
     }
 
     bb33: {
+        _0 = const ();
+        goto -> bb34;
+    }
+
+    bb34: {
         StorageDead(_11);
-        StorageDead(_12);
         return;
     }
 
-    bb34 (cleanup): {
+    bb35 (cleanup): {
         resume;
     }
 }
@@ -1,4 +1,4 @@
-#![feature(let_chains)]
+//@ edition: 2024
 
 extern crate proc_macro;
 
 
@@ -24,7 +24,7 @@
 //@ [e2024] edition: 2024
 //@ run-pass
 
-#![feature(let_chains)]
+#![cfg_attr(e2021, feature(let_chains))]
 #![cfg_attr(e2021, warn(rust_2024_compatibility))]
 
 fn t_bindings() {
 
@@ -24,7 +24,7 @@
 //@ [e2024] edition: 2024
 //@ run-pass
 
-#![feature(let_chains)]
+#![cfg_attr(e2021, feature(let_chains))]
 #![cfg_attr(e2021, warn(rust_2024_compatibility))]
 
 fn t_bindings() {
 
@@ -2,9 +2,10 @@
 //@ compile-flags: -Z validate-mir
 //@ revisions: edition2021 edition2024
 //@ [edition2021] edition: 2021
+//@ [edition2024] compile-flags: -Z lint-mir
 //@ [edition2024] edition: 2024
 
-#![feature(let_chains)]
+#![cfg_attr(edition2021, feature(let_chains))]
 
 use std::cell::RefCell;
 use std::convert::TryInto;
 
@@ -1,8 +1,6 @@
 //@ run-pass
 //@ edition:2024
-//@ compile-flags: -Z validate-mir
-
-#![feature(let_chains)]
+//@ compile-flags: -Z validate-mir -Z lint-mir
 
 use std::cell::RefCell;
 use std::convert::TryInto;
 
@@ -1,6 +1,11 @@
 //@ check-pass
 //@ compile-flags: -Z validate-mir
-#![feature(let_chains)]
+//@ revisions: edition2021 edition2024
+//@ [edition2021] edition: 2021
+//@ [edition2024] compile-flags: -Z lint-mir
+//@ [edition2024] edition: 2024
+
+#![cfg_attr(edition2021, feature(let_chains))]
 
 fn let_chains(entry: std::io::Result<std::fs::DirEntry>) {
     if let Ok(entry) = entry
 
@@ -1,6 +1,5 @@
 //@ check-pass
-
-#![feature(let_chains)]
+//@ edition:2024
 
 #[cfg(false)]
 fn foo() {
 
@@ -1,6 +1,6 @@
 //@ check-pass
+//@ edition:2024
 
-#![feature(let_chains)]
 #![allow(irrefutable_let_patterns)]
 fn main() {
     let _a = 0..1;
 
@@ -1,6 +1,6 @@
 //@ check-pass
 //@ compile-flags: -Z validate-mir
-#![feature(let_chains)]
+//@ edition: 2024
 
 fn lambda<T, U>() -> U
 where
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ fn test_complex() -> () {`
`19`	`19`	`bb0: {`
`20`	`20`	`StorageLive(_1);`
`21`	`21`	`StorageLive(_2);`
`22`		`- _2 = E::f() -> [return: bb1, unwind: bb34];`
	`22`	`+ _2 = E::f() -> [return: bb1, unwind: bb35];`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`bb1: {`
`@@ -42,7 +42,7 @@ fn test_complex() -> () {`
`42`	`42`
`43`	`43`	`bb5: {`
`44`	`44`	`StorageLive(_4);`
`45`		`- _4 = always_true() -> [return: bb6, unwind: bb34];`
	`45`	`+ _4 = always_true() -> [return: bb6, unwind: bb35];`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`bb6: {`
`@@ -64,7 +64,7 @@ fn test_complex() -> () {`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`bb9: {`
`67`		`- drop(_7) -> [return: bb11, unwind: bb34];`
	`67`	`+ drop(_7) -> [return: bb11, unwind: bb35];`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`bb10: {`
`@@ -78,7 +78,7 @@ fn test_complex() -> () {`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`bb12: {`
`81`		`- drop(_7) -> [return: bb13, unwind: bb34];`
	`81`	`+ drop(_7) -> [return: bb13, unwind: bb35];`
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`bb13: {`
`@@ -98,7 +98,7 @@ fn test_complex() -> () {`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`bb15: {`
`101`		`- drop(_10) -> [return: bb17, unwind: bb34];`
	`101`	`+ drop(_10) -> [return: bb17, unwind: bb35];`
`102`	`102`	`}`
`103`	`103`
`104`	`104`	`bb16: {`
`@@ -113,11 +113,12 @@ fn test_complex() -> () {`
`113`	`113`
`114`	`114`	`bb18: {`
`115`	`115`	`_1 = const ();`
	`116`	`+ StorageDead(_2);`
`116`	`117`	`goto -> bb22;`
`117`	`118`	`}`
`118`	`119`
`119`	`120`	`bb19: {`
`120`		`- drop(_10) -> [return: bb20, unwind: bb34];`
	`121`	`+ drop(_10) -> [return: bb20, unwind: bb35];`
`121`	`122`	`}`
`122`	`123`
`123`	`124`	`bb20: {`
`@@ -127,6 +128,7 @@ fn test_complex() -> () {`
`127`	`128`	`}`
`128`	`129`
`129`	`130`	`bb21: {`
	`131`	`+ StorageDead(_2);`
`130`	`132`	`_1 = const ();`
`131`	`133`	`goto -> bb22;`
`132`	`134`	`}`
`@@ -135,18 +137,17 @@ fn test_complex() -> () {`
`135`	`137`	`StorageDead(_8);`
`136`	`138`	`StorageDead(_5);`
`137`	`139`	`StorageDead(_4);`
`138`		`- StorageDead(_2);`
`139`	`140`	`StorageDead(_1);`
`140`	`141`	`StorageLive(_11);`
`141`		`- _11 = always_true() -> [return: bb23, unwind: bb34];`
	`142`	`+ _11 = always_true() -> [return: bb23, unwind: bb35];`
`142`	`143`	`}`
`143`	`144`
`144`	`145`	`bb23: {`
`145`	`146`	`switchInt(move _11) -> [0: bb25, otherwise: bb24];`
`146`	`147`	`}`
`147`	`148`
`148`	`149`	`bb24: {`
`149`		`- goto -> bb32;`
	`150`	`+ goto -> bb33;`
`150`	`151`	`}`
`151`	`152`
`152`	`153`	`bb25: {`
`@@ -155,7 +156,7 @@ fn test_complex() -> () {`
`155`	`156`
`156`	`157`	`bb26: {`
`157`	`158`	`StorageLive(_12);`
`158`		`- _12 = E::f() -> [return: bb27, unwind: bb34];`
	`159`	`+ _12 = E::f() -> [return: bb27, unwind: bb35];`
`159`	`160`	`}`
`160`	`161`
`161`	`162`	`bb27: {`
`@@ -178,21 +179,26 @@ fn test_complex() -> () {`
`178`	`179`
`179`	`180`	`bb31: {`
`180`	`181`	`_0 = const ();`
`181`		`- goto -> bb33;`
	`182`	`+ StorageDead(_12);`
	`183`	`+ goto -> bb34;`
`182`	`184`	`}`
`183`	`185`
`184`	`186`	`bb32: {`
`185`		`- _0 = const ();`
	`187`	`+ StorageDead(_12);`
`186`	`188`	`goto -> bb33;`
`187`	`189`	`}`
`188`	`190`
`189`	`191`	`bb33: {`
	`192`	`+ _0 = const ();`
	`193`	`+ goto -> bb34;`
	`194`	`+ }`
	`195`	`+`
	`196`	`+ bb34: {`
`190`	`197`	`StorageDead(_11);`
`191`		`- StorageDead(_12);`
`192`	`198`	`return;`
`193`	`199`	`}`
`194`	`200`
`195`		`- bb34 (cleanup): {`
	`201`	`+ bb35 (cleanup): {`
`196`	`202`	`resume;`
`197`	`203`	`}`
`198`	`204`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-#![feature(let_chains)]`
	`1`	`+//@ edition: 2024`
`2`	`2`
`3`	`3`	`extern crate proc_macro;`
`4`	`4`