From 7aab011dbb6ab2a46c12107d8a516b10a961f2a2 Mon Sep 17 00:00:00 2001
From: Berrysoft <Strawberry_Str@hotmail.com>
Date: Thu, 10 Apr 2025 15:12:19 +0800
Subject: [PATCH 01/20] Use posix_spawn on cygwin

---
 library/std/src/sys/process/unix/unix.rs | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/library/std/src/sys/process/unix/unix.rs b/library/std/src/sys/process/unix/unix.rs
index 191a09c8da91..c293c8871ece 100644
--- a/library/std/src/sys/process/unix/unix.rs
+++ b/library/std/src/sys/process/unix/unix.rs
@@ -415,6 +415,7 @@ impl Command {
         all(target_os = "linux", target_env = "musl"),
         target_os = "nto",
         target_vendor = "apple",
+        target_os = "cygwin",
     )))]
     fn posix_spawn(
         &mut self,
@@ -433,6 +434,7 @@ impl Command {
         all(target_os = "linux", target_env = "musl"),
         target_os = "nto",
         target_vendor = "apple",
+        target_os = "cygwin",
     ))]
     // FIXME(#115199): Rust currently omits weak function definitions
     // and its metadata from LLVM IR.
@@ -587,7 +589,7 @@ impl Command {
         /// Some platforms can set a new working directory for a spawned process in the
         /// `posix_spawn` path. This function looks up the function pointer for adding
         /// such an action to a `posix_spawn_file_actions_t` struct.
-        #[cfg(not(all(target_os = "linux", target_env = "musl")))]
+        #[cfg(not(any(all(target_os = "linux", target_env = "musl"), target_os = "cygwin")))]
         fn get_posix_spawn_addchdir() -> Option<PosixSpawnAddChdirFn> {
             use crate::sys::weak::weak;
 
@@ -621,7 +623,9 @@ impl Command {
         /// Weak symbol lookup doesn't work with statically linked libcs, so in cases
         /// where static linking is possible we need to either check for the presence
         /// of the symbol at compile time or know about it upfront.
-        #[cfg(all(target_os = "linux", target_env = "musl"))]
+        ///
+        /// Cygwin doesn't support weak symbol, so just link it.
+        #[cfg(any(all(target_os = "linux", target_env = "musl"), target_os = "cygwin"))]
         fn get_posix_spawn_addchdir() -> Option<PosixSpawnAddChdirFn> {
             // Our minimum required musl supports this function, so we can just use it.
             Some(libc::posix_spawn_file_actions_addchdir_np)

From 2e61af2fca192e155cc99ddd90ec534fdc70cf98 Mon Sep 17 00:00:00 2001
From: est31 <MTest31@outlook.com>
Date: Sun, 10 Nov 2024 20:58:00 +0100
Subject: [PATCH 02/20] Stabilize let chains on edition 2024

---
 compiler/rustc_parse/src/parser/expr.rs    | 31 +++++++++++++++++++---
 tests/ui/drop/drop_order.rs                |  3 ++-
 tests/ui/drop/drop_order_if_let_rescope.rs |  4 +--
 tests/ui/drop/issue-100276.rs              |  7 ++++-
 tests/ui/mir/mir_let_chains_drop_order.rs  |  2 +-
 5 files changed, 38 insertions(+), 9 deletions(-)

diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index df44b3cc23c8..e60912d85b74 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -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};
@@ -2605,7 +2606,7 @@ 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()?;
+        let cond = self.parse_expr_cond(lo.edition())?;
         self.parse_if_after_cond(lo, cond)
     }
 
@@ -2714,8 +2715,11 @@ impl<'a> Parser<'a> {
     }
 
     /// Parses the condition of a `if` or `while` expression.
+    ///
+    /// The specified `edition` should be that of the whole `if` or `while` construct: the same
+    /// span that we later decide the drop behaviour on (editions ..=2021 vs 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, edition: Edition) -> 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)?;
@@ -2725,6 +2729,27 @@ impl<'a> Parser<'a> {
         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);
+        } else {
+            fn ungate_let_exprs(this: &mut Parser<'_>, expr: &Expr) {
+                if !expr.span.at_least_rust_2024() {
+                    return;
+                }
+                match &expr.kind {
+                    ExprKind::Binary(BinOp { node: BinOpKind::And, .. }, lhs, rhs) => {
+                        ungate_let_exprs(this, rhs);
+                        ungate_let_exprs(this, lhs);
+                    }
+                    ExprKind::Let(..) => {
+                        this.psess.gated_spans.ungate_last(sym::let_chains, expr.span)
+                    }
+                    _ => (),
+                }
+            }
+            if edition.at_least_rust_2024() {
+                // Scoping code checks the top level edition of the `if`: let's match it here.
+                // Also check all editions in between, just to make sure.
+                ungate_let_exprs(self, &cond);
+            }
         }
 
         Ok(cond)
@@ -3020,7 +3045,7 @@ 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 cond = self.parse_expr_cond(lo.edition()).map_err(|mut err| {
             err.span_label(lo, "while parsing the condition of this `while` expression");
             err
         })?;
diff --git a/tests/ui/drop/drop_order.rs b/tests/ui/drop/drop_order.rs
index d1a5b9bc5e26..b96e55a2535a 100644
--- a/tests/ui/drop/drop_order.rs
+++ b/tests/ui/drop/drop_order.rs
@@ -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;
diff --git a/tests/ui/drop/drop_order_if_let_rescope.rs b/tests/ui/drop/drop_order_if_let_rescope.rs
index 7445e3a6a5f1..27bced5fa62f 100644
--- a/tests/ui/drop/drop_order_if_let_rescope.rs
+++ b/tests/ui/drop/drop_order_if_let_rescope.rs
@@ -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;
diff --git a/tests/ui/drop/issue-100276.rs b/tests/ui/drop/issue-100276.rs
index b44710e7c3f2..5d212b3a0a95 100644
--- a/tests/ui/drop/issue-100276.rs
+++ b/tests/ui/drop/issue-100276.rs
@@ -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
diff --git a/tests/ui/mir/mir_let_chains_drop_order.rs b/tests/ui/mir/mir_let_chains_drop_order.rs
index 8991c6db7b98..4794f3427dda 100644
--- a/tests/ui/mir/mir_let_chains_drop_order.rs
+++ b/tests/ui/mir/mir_let_chains_drop_order.rs
@@ -6,7 +6,7 @@
 
 // See `mir_drop_order.rs` for more information
 
-#![feature(let_chains)]
+#![cfg_attr(edition2021, feature(let_chains))]
 #![allow(irrefutable_let_patterns)]
 
 use std::cell::RefCell;

From 0e91190b05cfe05199e9ecbecc1d1d5fa57c9384 Mon Sep 17 00:00:00 2001
From: est31 <MTest31@outlook.com>
Date: Sun, 10 Nov 2024 21:54:48 +0100
Subject: [PATCH 03/20] Remove let_chains feature gate from some places in the
 testsuite

---
 tests/ui/expr/if/attrs/let-chains-attr.rs       | 3 +--
 tests/ui/unpretty/expanded-exhaustive.rs        | 1 -
 tests/ui/unpretty/expanded-exhaustive.stdout    | 1 -
 tests/ui/unpretty/expanded-interpolation.rs     | 3 +--
 tests/ui/unpretty/expanded-interpolation.stdout | 6 ++----
 5 files changed, 4 insertions(+), 10 deletions(-)

diff --git a/tests/ui/expr/if/attrs/let-chains-attr.rs b/tests/ui/expr/if/attrs/let-chains-attr.rs
index 2cf1b169f069..7b74b17784e8 100644
--- a/tests/ui/expr/if/attrs/let-chains-attr.rs
+++ b/tests/ui/expr/if/attrs/let-chains-attr.rs
@@ -1,6 +1,5 @@
 //@ check-pass
-
-#![feature(let_chains)]
+//@ edition:2024
 
 #[cfg(false)]
 fn foo() {
diff --git a/tests/ui/unpretty/expanded-exhaustive.rs b/tests/ui/unpretty/expanded-exhaustive.rs
index 4d1f12e34900..0fb5a26c5aae 100644
--- a/tests/ui/unpretty/expanded-exhaustive.rs
+++ b/tests/ui/unpretty/expanded-exhaustive.rs
@@ -12,7 +12,6 @@
 #![feature(dyn_star)]
 #![feature(explicit_tail_calls)]
 #![feature(gen_blocks)]
-#![feature(let_chains)]
 #![feature(more_qualified_paths)]
 #![feature(never_patterns)]
 #![feature(never_type)]
diff --git a/tests/ui/unpretty/expanded-exhaustive.stdout b/tests/ui/unpretty/expanded-exhaustive.stdout
index d8da941a3407..8febd2d6d492 100644
--- a/tests/ui/unpretty/expanded-exhaustive.stdout
+++ b/tests/ui/unpretty/expanded-exhaustive.stdout
@@ -13,7 +13,6 @@
 #![feature(dyn_star)]
 #![feature(explicit_tail_calls)]
 #![feature(gen_blocks)]
-#![feature(let_chains)]
 #![feature(more_qualified_paths)]
 #![feature(never_patterns)]
 #![feature(never_type)]
diff --git a/tests/ui/unpretty/expanded-interpolation.rs b/tests/ui/unpretty/expanded-interpolation.rs
index 0c447ae669dd..95280f97dac1 100644
--- a/tests/ui/unpretty/expanded-interpolation.rs
+++ b/tests/ui/unpretty/expanded-interpolation.rs
@@ -1,6 +1,6 @@
 //@ compile-flags: -Zunpretty=expanded
+//@ edition:2024
 //@ check-pass
-//@ edition: 2015
 
 // This test covers the AST pretty-printer's insertion of parentheses in some
 // macro metavariable edge cases. Synthetic parentheses (i.e. not appearing in
@@ -8,7 +8,6 @@
 // Rust syntax. We also test negative cases: the pretty-printer should not be
 // synthesizing parentheses indiscriminately; only where necessary.
 
-#![feature(let_chains)]
 #![feature(if_let_guard)]
 
 macro_rules! expr {
diff --git a/tests/ui/unpretty/expanded-interpolation.stdout b/tests/ui/unpretty/expanded-interpolation.stdout
index 10729a96ef59..d46b46b67f41 100644
--- a/tests/ui/unpretty/expanded-interpolation.stdout
+++ b/tests/ui/unpretty/expanded-interpolation.stdout
@@ -1,8 +1,7 @@
 #![feature(prelude_import)]
-#![no_std]
 //@ compile-flags: -Zunpretty=expanded
+//@ edition:2024
 //@ check-pass
-//@ edition: 2015
 
 // This test covers the AST pretty-printer's insertion of parentheses in some
 // macro metavariable edge cases. Synthetic parentheses (i.e. not appearing in
@@ -10,10 +9,9 @@
 // Rust syntax. We also test negative cases: the pretty-printer should not be
 // synthesizing parentheses indiscriminately; only where necessary.
 
-#![feature(let_chains)]
 #![feature(if_let_guard)]
 #[prelude_import]
-use ::std::prelude::rust_2015::*;
+use std::prelude::rust_2024::*;
 #[macro_use]
 extern crate std;
 

From eb1639bd336e83255f9d8d0b8c726feef59ec574 Mon Sep 17 00:00:00 2001
From: est31 <MTest31@outlook.com>
Date: Wed, 13 Nov 2024 10:50:08 +0100
Subject: [PATCH 04/20] Add tests to check the situation with heterogenous
 spans

The edition gate is a bit stricter than the drop behaviour,
which is fine. The cases we want to avoid are the opposite:
not gated but 2021 drop behaviour.
---
 .../auxiliary/macro-in-2021.rs                | 26 +++++++
 .../auxiliary/macro-in-2024.rs                | 26 +++++++
 ...dition-gate-macro-error.edition2021.stderr | 65 ++++++++++++++++
 ...dition-gate-macro-error.edition2024.stderr | 45 +++++++++++
 .../edition-gate-macro-error.rs               | 30 ++++++++
 .../edition-gate-macro.rs                     | 76 +++++++++++++++++++
 6 files changed, 268 insertions(+)
 create mode 100644 tests/ui/rfcs/rfc-2497-if-let-chains/auxiliary/macro-in-2021.rs
 create mode 100644 tests/ui/rfcs/rfc-2497-if-let-chains/auxiliary/macro-in-2024.rs
 create mode 100644 tests/ui/rfcs/rfc-2497-if-let-chains/edition-gate-macro-error.edition2021.stderr
 create mode 100644 tests/ui/rfcs/rfc-2497-if-let-chains/edition-gate-macro-error.edition2024.stderr
 create mode 100644 tests/ui/rfcs/rfc-2497-if-let-chains/edition-gate-macro-error.rs
 create mode 100644 tests/ui/rfcs/rfc-2497-if-let-chains/edition-gate-macro.rs

diff --git a/tests/ui/rfcs/rfc-2497-if-let-chains/auxiliary/macro-in-2021.rs b/tests/ui/rfcs/rfc-2497-if-let-chains/auxiliary/macro-in-2021.rs
new file mode 100644
index 000000000000..d2d5ae111041
--- /dev/null
+++ b/tests/ui/rfcs/rfc-2497-if-let-chains/auxiliary/macro-in-2021.rs
@@ -0,0 +1,26 @@
+//@ edition: 2021
+
+#[macro_export]
+macro_rules! make_if {
+    (($($tt:tt)*) { $body:expr } { $else:expr }) => {{
+        if $($tt)* {
+            $body
+        } else {
+            $else
+        }
+    }};
+    (let ($expr:expr) { $body:expr } { $else:expr }) => {{
+        if let None = $expr {
+            $body
+        } else {
+            $else
+        }
+    }};
+    (let ($expr:expr) let ($expr2:expr) { $body:expr } { $else:expr }) => {{
+        if let None = $expr && let None = $expr2 {
+            $body
+        } else {
+            $else
+        }
+    }};
+}
diff --git a/tests/ui/rfcs/rfc-2497-if-let-chains/auxiliary/macro-in-2024.rs b/tests/ui/rfcs/rfc-2497-if-let-chains/auxiliary/macro-in-2024.rs
new file mode 100644
index 000000000000..f5b6f35abf8f
--- /dev/null
+++ b/tests/ui/rfcs/rfc-2497-if-let-chains/auxiliary/macro-in-2024.rs
@@ -0,0 +1,26 @@
+//@ edition: 2024
+
+#[macro_export]
+macro_rules! make_if {
+    (($($tt:tt)*) { $body:expr } { $else:expr }) => {{
+        if $($tt)* {
+            $body
+        } else {
+            $else
+        }
+    }};
+    (let ($expr:expr) { $body:expr } { $else:expr }) => {{
+        if let None = $expr {
+            $body
+        } else {
+            $else
+        }
+    }};
+    (let ($expr:expr) let ($expr2:expr) { $body:expr } { $else:expr }) => {{
+        if let None = $expr && let None = $expr2 {
+            $body
+        } else {
+            $else
+        }
+    }};
+}
diff --git a/tests/ui/rfcs/rfc-2497-if-let-chains/edition-gate-macro-error.edition2021.stderr b/tests/ui/rfcs/rfc-2497-if-let-chains/edition-gate-macro-error.edition2021.stderr
new file mode 100644
index 000000000000..23700f89f108
--- /dev/null
+++ b/tests/ui/rfcs/rfc-2497-if-let-chains/edition-gate-macro-error.edition2021.stderr
@@ -0,0 +1,65 @@
+error[E0658]: `let` expressions in this position are unstable
+  --> $DIR/edition-gate-macro-error.rs:19:30
+   |
+LL |     macro_in_2021::make_if!((let Some(0) = None && let Some(0) = None) { never!() } { never!() });
+   |                              ^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #53667 <https://github.com/rust-lang/rust/issues/53667> for more information
+   = help: add `#![feature(let_chains)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: `let` expressions in this position are unstable
+  --> $DIR/edition-gate-macro-error.rs:19:52
+   |
+LL |     macro_in_2021::make_if!((let Some(0) = None && let Some(0) = None) { never!() } { never!() });
+   |                                                    ^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #53667 <https://github.com/rust-lang/rust/issues/53667> for more information
+   = help: add `#![feature(let_chains)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: `let` expressions in this position are unstable
+  --> $DIR/edition-gate-macro-error.rs:22:5
+   |
+LL |     macro_in_2021::make_if!(let (Some(0)) let (Some(0)) { never!() } { never!() });
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #53667 <https://github.com/rust-lang/rust/issues/53667> for more information
+   = help: add `#![feature(let_chains)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+   = note: this error originates in the macro `macro_in_2021::make_if` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0658]: `let` expressions in this position are unstable
+  --> $DIR/edition-gate-macro-error.rs:22:5
+   |
+LL |     macro_in_2021::make_if!(let (Some(0)) let (Some(0)) { never!() } { never!() });
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #53667 <https://github.com/rust-lang/rust/issues/53667> for more information
+   = help: add `#![feature(let_chains)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+   = note: this error originates in the macro `macro_in_2021::make_if` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0658]: `let` expressions in this position are unstable
+  --> $DIR/edition-gate-macro-error.rs:26:30
+   |
+LL |     macro_in_2024::make_if!((let Some(0) = None && let Some(0) = None) { never!() } { never!() });
+   |                              ^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #53667 <https://github.com/rust-lang/rust/issues/53667> for more information
+   = help: add `#![feature(let_chains)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: `let` expressions in this position are unstable
+  --> $DIR/edition-gate-macro-error.rs:26:52
+   |
+LL |     macro_in_2024::make_if!((let Some(0) = None && let Some(0) = None) { never!() } { never!() });
+   |                                                    ^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #53667 <https://github.com/rust-lang/rust/issues/53667> for more information
+   = help: add `#![feature(let_chains)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error: aborting due to 6 previous errors
+
+For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/rfcs/rfc-2497-if-let-chains/edition-gate-macro-error.edition2024.stderr b/tests/ui/rfcs/rfc-2497-if-let-chains/edition-gate-macro-error.edition2024.stderr
new file mode 100644
index 000000000000..3af844f4f966
--- /dev/null
+++ b/tests/ui/rfcs/rfc-2497-if-let-chains/edition-gate-macro-error.edition2024.stderr
@@ -0,0 +1,45 @@
+error[E0658]: `let` expressions in this position are unstable
+  --> $DIR/edition-gate-macro-error.rs:19:30
+   |
+LL |     macro_in_2021::make_if!((let Some(0) = None && let Some(0) = None) { never!() } { never!() });
+   |                              ^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #53667 <https://github.com/rust-lang/rust/issues/53667> for more information
+   = help: add `#![feature(let_chains)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: `let` expressions in this position are unstable
+  --> $DIR/edition-gate-macro-error.rs:19:52
+   |
+LL |     macro_in_2021::make_if!((let Some(0) = None && let Some(0) = None) { never!() } { never!() });
+   |                                                    ^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #53667 <https://github.com/rust-lang/rust/issues/53667> for more information
+   = help: add `#![feature(let_chains)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: `let` expressions in this position are unstable
+  --> $DIR/edition-gate-macro-error.rs:22:5
+   |
+LL |     macro_in_2021::make_if!(let (Some(0)) let (Some(0)) { never!() } { never!() });
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #53667 <https://github.com/rust-lang/rust/issues/53667> for more information
+   = help: add `#![feature(let_chains)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+   = note: this error originates in the macro `macro_in_2021::make_if` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0658]: `let` expressions in this position are unstable
+  --> $DIR/edition-gate-macro-error.rs:22:5
+   |
+LL |     macro_in_2021::make_if!(let (Some(0)) let (Some(0)) { never!() } { never!() });
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #53667 <https://github.com/rust-lang/rust/issues/53667> for more information
+   = help: add `#![feature(let_chains)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+   = note: this error originates in the macro `macro_in_2021::make_if` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/rfcs/rfc-2497-if-let-chains/edition-gate-macro-error.rs b/tests/ui/rfcs/rfc-2497-if-let-chains/edition-gate-macro-error.rs
new file mode 100644
index 000000000000..89b555d2c50b
--- /dev/null
+++ b/tests/ui/rfcs/rfc-2497-if-let-chains/edition-gate-macro-error.rs
@@ -0,0 +1,30 @@
+//@ revisions: edition2021 edition2024
+//@ compile-flags: -Z lint-mir -Z validate-mir
+//@ [edition2021] edition: 2021
+//@ [edition2024] edition: 2024
+//@ aux-build:macro-in-2021.rs
+//@ aux-build:macro-in-2024.rs
+
+use std::unreachable as never;
+
+// Compiletest doesn't specify the needed --extern flags to make `extern crate` unneccessary
+extern crate macro_in_2021;
+extern crate macro_in_2024;
+
+fn main() {
+    // Gated on both 2021 and 2024 if the `if` comes from a 2021 macro
+    // Gated only on 2021 if the `if` comes from a 2024 macro
+    // No gating if both the `if` and the chain are from a 2024 macro
+
+    macro_in_2021::make_if!((let Some(0) = None && let Some(0) = None) { never!() } { never!() });
+    //~^ ERROR `let` expressions in this position are unstable
+    //~| ERROR `let` expressions in this position are unstable
+    macro_in_2021::make_if!(let (Some(0)) let (Some(0)) { never!() } { never!() });
+    //~^ ERROR `let` expressions in this position are unstable
+    //~| ERROR `let` expressions in this position are unstable
+
+    macro_in_2024::make_if!((let Some(0) = None && let Some(0) = None) { never!() } { never!() });
+    //[edition2021]~^ ERROR `let` expressions in this position are unstable
+    //[edition2021]~| ERROR `let` expressions in this position are unstable
+    macro_in_2024::make_if!(let (Some(0)) let (Some(0)) { never!() } { never!() });
+}
diff --git a/tests/ui/rfcs/rfc-2497-if-let-chains/edition-gate-macro.rs b/tests/ui/rfcs/rfc-2497-if-let-chains/edition-gate-macro.rs
new file mode 100644
index 000000000000..5dd928dbce5b
--- /dev/null
+++ b/tests/ui/rfcs/rfc-2497-if-let-chains/edition-gate-macro.rs
@@ -0,0 +1,76 @@
+//@ revisions: edition2021 edition2024
+//@ compile-flags: -Z lint-mir -Z validate-mir
+//@ [edition2021] edition: 2021
+//@ [edition2024] edition: 2024
+//@ aux-build:macro-in-2021.rs
+//@ aux-build:macro-in-2024.rs
+//@ run-pass
+
+#![allow(dead_code)]
+
+use std::unreachable as never;
+use std::cell::RefCell;
+use std::convert::TryInto;
+
+// Compiletest doesn't specify the needed --extern flags to make `extern crate` unneccessary
+extern crate macro_in_2021;
+extern crate macro_in_2024;
+
+#[derive(Default)]
+struct DropOrderCollector(RefCell<Vec<u32>>);
+
+struct LoudDrop<'a>(&'a DropOrderCollector, u32);
+
+impl Drop for LoudDrop<'_> {
+    fn drop(&mut self) {
+        println!("{}", self.1);
+        self.0.0.borrow_mut().push(self.1);
+    }
+}
+
+impl DropOrderCollector {
+    fn print(&self, n: u32) {
+        println!("{n}");
+        self.0.borrow_mut().push(n)
+    }
+    fn some_loud(&self, n: u32) -> Option<LoudDrop> {
+        Some(LoudDrop(self, n))
+    }
+
+    #[track_caller]
+    fn validate(self) {
+        assert!(
+            self.0
+                .into_inner()
+                .into_iter()
+                .enumerate()
+                .all(|(idx, item)| idx + 1 == item.try_into().unwrap())
+        );
+    }
+    fn with_macro_2021(self) {
+        // Edition 2021 drop behaviour
+        macro_in_2021::make_if!((let None = self.some_loud(2)) { never!() } {self.print(1) });
+        macro_in_2021::make_if!(let (self.some_loud(4)) { never!() } { self.print(3) });
+        self.validate();
+    }
+    fn with_macro_2024(self) {
+        // Edition 2024 drop behaviour
+        macro_in_2024::make_if!((let None = self.some_loud(1)) { never!() } { self.print(2) });
+        macro_in_2024::make_if!(let (self.some_loud(3)) { never!() } { self.print(4) });
+        self.validate();
+    }
+}
+
+fn main() {
+    // 2021 drop order if it's a 2021 macro creating the `if`
+    // 2024 drop order if it's a 2024 macro creating the `if`
+
+    // Compare this with edition-gate-macro-error.rs: We want to avoid exposing 2021 drop order,
+    // because it can create bad MIR (issue #104843)
+    // This test doesn't contain any let chains at all: it should be understood
+    // in combination with `edition-gate-macro-error.rs`
+
+    DropOrderCollector::default().with_macro_2021();
+    DropOrderCollector::default().with_macro_2024();
+
+}

From d75f8cde2f54daa18f9b68e1b221e2d412855086 Mon Sep 17 00:00:00 2001
From: est31 <MTest31@outlook.com>
Date: Sun, 16 Mar 2025 06:32:43 +0100
Subject: [PATCH 05/20] Also allow let chains in match guards

---
 compiler/rustc_parse/src/parser/expr.rs | 31 ++++++++++++++++---------
 1 file changed, 20 insertions(+), 11 deletions(-)

diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index e60912d85b74..3bd7aaee78e4 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -3431,15 +3431,15 @@ 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
         // `&&` 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)) {
@@ -3452,12 +3452,21 @@ impl<'a> Parser<'a> {
 
         CondChecker::new(self).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 chains are allowed in match guards, but only there
+            fn ungate_let_exprs(this: &mut Parser<'_>, expr: &Expr) {
+                match &expr.kind {
+                    ExprKind::Binary(BinOp { node: BinOpKind::And, .. }, lhs, rhs) => {
+                        ungate_let_exprs(this, rhs);
+                        ungate_let_exprs(this, lhs);
+                    }
+                    ExprKind::Let(..) => {
+                        this.psess.gated_spans.ungate_last(sym::let_chains, expr.span)
+                    }
+                    _ => (),
+                }
             }
+            ungate_let_exprs(self, &cond);
             let span = if_span.to(cond.span);
             self.psess.gated_spans.gate(sym::if_let_guard, span);
         }

From 162daaa2fa9e78dad0219eb995a7903d778f7801 Mon Sep 17 00:00:00 2001
From: est31 <MTest31@outlook.com>
Date: Sun, 16 Mar 2025 06:14:36 +0100
Subject: [PATCH 06/20] Remove let_chains feature gate from even more tests

---
 .../building/logical_or_in_conditional.rs     |   2 +-
 ...n_conditional.test_complex.built.after.mir |  34 +++---
 .../ui/deriving/auxiliary/malicious-macro.rs  |   2 +-
 .../drop/drop-order-comparisons.e2021.fixed   |   2 +-
 tests/ui/drop/drop-order-comparisons.rs       |   2 +-
 tests/ui/lint/issue-121070-let-range.rs       |   2 +-
 tests/ui/mir/issue-99852.rs                   |   2 +-
 tests/ui/parser/brace-in-let-chain.rs         |   2 +-
 tests/ui/parser/deli-ident-issue-1.rs         |   2 +-
 tests/ui/parser/issues/issue-103381.fixed     |   2 +-
 tests/ui/parser/issues/issue-103381.rs        |   2 +-
 tests/ui/parser/semi-in-let-chain.rs          |   3 +-
 tests/ui/parser/semi-in-let-chain.stderr      |  12 +--
 .../rfc-0000-never_patterns/diverges-not.rs   |   2 +-
 .../rfc-2294-if-let-guard/feature-gate.rs     |   5 -
 .../rfc-2294-if-let-guard/feature-gate.stderr | 100 +++++-------------
 .../rfc-2294-if-let-guard/macro-expanded.rs   |   1 -
 .../macro-expanded.stderr                     |   2 +-
 .../move-guard-if-let-chain.rs                |   2 +-
 tests/ui/rfcs/rfc-2294-if-let-guard/parens.rs |   2 +-
 .../rfcs/rfc-2294-if-let-guard/shadowing.rs   |   2 +-
 .../ast-lowering-does-not-wrap-let-chains.rs  |   2 +-
 .../ast-validate-guards.rs                    |   2 +-
 ...-else-does-not-interact-with-let-chains.rs |   2 +-
 .../rfc-2497-if-let-chains/issue-90722.rs     |   3 +-
 .../rfc-2497-if-let-chains/issue-92145.rs     |   3 +-
 .../rfc-2497-if-let-chains/issue-93150.rs     |   1 -
 .../rfc-2497-if-let-chains/issue-93150.stderr |  12 +--
 .../rfc-2497-if-let-chains/issue-99938.rs     |   3 +-
 .../temporary-early-drop.rs                   |   1 -
 30 files changed, 75 insertions(+), 139 deletions(-)

diff --git a/tests/mir-opt/building/logical_or_in_conditional.rs b/tests/mir-opt/building/logical_or_in_conditional.rs
index e6872e6f2ec8..249ccf728044 100644
--- a/tests/mir-opt/building/logical_or_in_conditional.rs
+++ b/tests/mir-opt/building/logical_or_in_conditional.rs
@@ -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) {
diff --git a/tests/mir-opt/building/logical_or_in_conditional.test_complex.built.after.mir b/tests/mir-opt/building/logical_or_in_conditional.test_complex.built.after.mir
index 72bd4605b264..327b3b618a03 100644
--- a/tests/mir-opt/building/logical_or_in_conditional.test_complex.built.after.mir
+++ b/tests/mir-opt/building/logical_or_in_conditional.test_complex.built.after.mir
@@ -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,10 +137,9 @@ 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: {
@@ -146,7 +147,7 @@ fn test_complex() -> () {
     }
 
     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;
     }
 }
diff --git a/tests/ui/deriving/auxiliary/malicious-macro.rs b/tests/ui/deriving/auxiliary/malicious-macro.rs
index 6665b40a14f2..c551b3f927c6 100644
--- a/tests/ui/deriving/auxiliary/malicious-macro.rs
+++ b/tests/ui/deriving/auxiliary/malicious-macro.rs
@@ -1,4 +1,4 @@
-#![feature(let_chains)]
+//@ edition: 2024
 
 extern crate proc_macro;
 
diff --git a/tests/ui/drop/drop-order-comparisons.e2021.fixed b/tests/ui/drop/drop-order-comparisons.e2021.fixed
index 78cf421cfbf3..71158cb80621 100644
--- a/tests/ui/drop/drop-order-comparisons.e2021.fixed
+++ b/tests/ui/drop/drop-order-comparisons.e2021.fixed
@@ -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() {
diff --git a/tests/ui/drop/drop-order-comparisons.rs b/tests/ui/drop/drop-order-comparisons.rs
index 78c75a9449f1..0492b3a4db7f 100644
--- a/tests/ui/drop/drop-order-comparisons.rs
+++ b/tests/ui/drop/drop-order-comparisons.rs
@@ -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() {
diff --git a/tests/ui/lint/issue-121070-let-range.rs b/tests/ui/lint/issue-121070-let-range.rs
index 1f575cfaca55..82878587f8d7 100644
--- a/tests/ui/lint/issue-121070-let-range.rs
+++ b/tests/ui/lint/issue-121070-let-range.rs
@@ -1,6 +1,6 @@
 //@ check-pass
+//@ edition:2024
 
-#![feature(let_chains)]
 #![allow(irrefutable_let_patterns)]
 fn main() {
     let _a = 0..1;
diff --git a/tests/ui/mir/issue-99852.rs b/tests/ui/mir/issue-99852.rs
index 59459c672281..af754cf85469 100644
--- a/tests/ui/mir/issue-99852.rs
+++ b/tests/ui/mir/issue-99852.rs
@@ -1,6 +1,6 @@
 //@ check-pass
 //@ compile-flags: -Z validate-mir
-#![feature(let_chains)]
+//@ edition: 2024
 
 fn lambda<T, U>() -> U
 where
diff --git a/tests/ui/parser/brace-in-let-chain.rs b/tests/ui/parser/brace-in-let-chain.rs
index 2009bc88d9e8..25586441c188 100644
--- a/tests/ui/parser/brace-in-let-chain.rs
+++ b/tests/ui/parser/brace-in-let-chain.rs
@@ -1,6 +1,6 @@
 // issue #117766
+//@ edition: 2024
 
-#![feature(let_chains)]
 fn main() {
     if let () = ()
         && let () = () {
diff --git a/tests/ui/parser/deli-ident-issue-1.rs b/tests/ui/parser/deli-ident-issue-1.rs
index 224ee6c09e0c..b7e7df1f860b 100644
--- a/tests/ui/parser/deli-ident-issue-1.rs
+++ b/tests/ui/parser/deli-ident-issue-1.rs
@@ -1,4 +1,4 @@
-#![feature(let_chains)]
+//@ edition: 2024
 trait Demo {}
 
 impl dyn Demo {
diff --git a/tests/ui/parser/issues/issue-103381.fixed b/tests/ui/parser/issues/issue-103381.fixed
index 87c308789a18..955b246b8636 100644
--- a/tests/ui/parser/issues/issue-103381.fixed
+++ b/tests/ui/parser/issues/issue-103381.fixed
@@ -1,6 +1,6 @@
+//@ edition: 2024
 //@ run-rustfix
 
-#![feature(let_chains)]
 #![allow(unused_variables)]
 #![allow(dead_code)]
 #![allow(irrefutable_let_patterns)]
diff --git a/tests/ui/parser/issues/issue-103381.rs b/tests/ui/parser/issues/issue-103381.rs
index ccbc40e5d021..d4b06b9c7701 100644
--- a/tests/ui/parser/issues/issue-103381.rs
+++ b/tests/ui/parser/issues/issue-103381.rs
@@ -1,6 +1,6 @@
+//@ edition: 2024
 //@ run-rustfix
 
-#![feature(let_chains)]
 #![allow(unused_variables)]
 #![allow(dead_code)]
 #![allow(irrefutable_let_patterns)]
diff --git a/tests/ui/parser/semi-in-let-chain.rs b/tests/ui/parser/semi-in-let-chain.rs
index 9c21af0372d2..522b90ea250b 100644
--- a/tests/ui/parser/semi-in-let-chain.rs
+++ b/tests/ui/parser/semi-in-let-chain.rs
@@ -1,6 +1,5 @@
 // Issue #117720
-
-#![feature(let_chains)]
+//@ edition: 2024
 
 fn main() {
     if let () = ()
diff --git a/tests/ui/parser/semi-in-let-chain.stderr b/tests/ui/parser/semi-in-let-chain.stderr
index c1a8f92965eb..f36d5e041e5d 100644
--- a/tests/ui/parser/semi-in-let-chain.stderr
+++ b/tests/ui/parser/semi-in-let-chain.stderr
@@ -1,11 +1,11 @@
 error: expected `{`, found `;`
-  --> $DIR/semi-in-let-chain.rs:7:23
+  --> $DIR/semi-in-let-chain.rs:6:23
    |
 LL |         && let () = ();
    |                       ^ expected `{`
    |
 note: you likely meant to continue parsing the let-chain starting here
-  --> $DIR/semi-in-let-chain.rs:8:9
+  --> $DIR/semi-in-let-chain.rs:7:9
    |
 LL |         && let () = ()
    |         ^^^^^^
@@ -16,13 +16,13 @@ LL +         && let () = ()
    |
 
 error: expected `{`, found `;`
-  --> $DIR/semi-in-let-chain.rs:15:20
+  --> $DIR/semi-in-let-chain.rs:14:20
    |
 LL |         && () == ();
    |                    ^ expected `{`
    |
 note: the `if` expression is missing a block after this condition
-  --> $DIR/semi-in-let-chain.rs:14:8
+  --> $DIR/semi-in-let-chain.rs:13:8
    |
 LL |       if let () = ()
    |  ________^
@@ -30,13 +30,13 @@ LL | |         && () == ();
    | |___________________^
 
 error: expected `{`, found `;`
-  --> $DIR/semi-in-let-chain.rs:23:20
+  --> $DIR/semi-in-let-chain.rs:22:20
    |
 LL |         && () == ();
    |                    ^ expected `{`
    |
 note: you likely meant to continue parsing the let-chain starting here
-  --> $DIR/semi-in-let-chain.rs:24:9
+  --> $DIR/semi-in-let-chain.rs:23:9
    |
 LL |         && let () = ()
    |         ^^^^^^
diff --git a/tests/ui/rfcs/rfc-0000-never_patterns/diverges-not.rs b/tests/ui/rfcs/rfc-0000-never_patterns/diverges-not.rs
index 6b85ada3aade..60e5452edb38 100644
--- a/tests/ui/rfcs/rfc-0000-never_patterns/diverges-not.rs
+++ b/tests/ui/rfcs/rfc-0000-never_patterns/diverges-not.rs
@@ -1,5 +1,5 @@
+//@ edition: 2024
 #![feature(never_patterns)]
-#![feature(let_chains)]
 #![allow(incomplete_features)]
 #![deny(unreachable_patterns)]
 
diff --git a/tests/ui/rfcs/rfc-2294-if-let-guard/feature-gate.rs b/tests/ui/rfcs/rfc-2294-if-let-guard/feature-gate.rs
index 983fe87451f2..b1e305834cb2 100644
--- a/tests/ui/rfcs/rfc-2294-if-let-guard/feature-gate.rs
+++ b/tests/ui/rfcs/rfc-2294-if-let-guard/feature-gate.rs
@@ -15,11 +15,9 @@ fn _if_let_guard() {
 
         () if true && let 0 = 1 => {}
         //~^ ERROR `if let` guards are experimental
-        //~| ERROR `let` expressions in this position are unstable
 
         () if let 0 = 1 && true => {}
         //~^ ERROR `if let` guards are experimental
-        //~| ERROR `let` expressions in this position are unstable
 
         () if (let 0 = 1) && true => {}
         //~^ ERROR expected expression, found `let` statement
@@ -33,8 +31,6 @@ fn _if_let_guard() {
 
         () if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) => {}
         //~^ ERROR `if let` guards are experimental
-        //~| ERROR `let` expressions in this position are unstable
-        //~| ERROR `let` expressions in this position are unstable
         //~| ERROR expected expression, found `let` statement
         //~| ERROR expected expression, found `let` statement
         //~| ERROR expected expression, found `let` statement
@@ -42,7 +38,6 @@ fn _if_let_guard() {
 
         () if let Range { start: _, end: _ } = (true..true) && false => {}
         //~^ ERROR `if let` guards are experimental
-        //~| ERROR `let` expressions in this position are unstable
 
         _ => {}
     }
diff --git a/tests/ui/rfcs/rfc-2294-if-let-guard/feature-gate.stderr b/tests/ui/rfcs/rfc-2294-if-let-guard/feature-gate.stderr
index 0997f0c81a01..19d1f4b0a573 100644
--- a/tests/ui/rfcs/rfc-2294-if-let-guard/feature-gate.stderr
+++ b/tests/ui/rfcs/rfc-2294-if-let-guard/feature-gate.stderr
@@ -25,98 +25,98 @@ LL |         () if (((let 0 = 1))) => {}
    |                  ^^^^^^^^^
 
 error: expected expression, found `let` statement
-  --> $DIR/feature-gate.rs:24:16
+  --> $DIR/feature-gate.rs:22:16
    |
 LL |         () if (let 0 = 1) && true => {}
    |                ^^^^^^^^^
    |
    = note: only supported directly in conditions of `if` and `while` expressions
 note: `let`s wrapped in parentheses are not supported in a context with let chains
-  --> $DIR/feature-gate.rs:24:16
+  --> $DIR/feature-gate.rs:22:16
    |
 LL |         () if (let 0 = 1) && true => {}
    |                ^^^^^^^^^
 
 error: expected expression, found `let` statement
-  --> $DIR/feature-gate.rs:27:24
+  --> $DIR/feature-gate.rs:25:24
    |
 LL |         () if true && (let 0 = 1) => {}
    |                        ^^^^^^^^^
    |
    = note: only supported directly in conditions of `if` and `while` expressions
 note: `let`s wrapped in parentheses are not supported in a context with let chains
-  --> $DIR/feature-gate.rs:27:24
+  --> $DIR/feature-gate.rs:25:24
    |
 LL |         () if true && (let 0 = 1) => {}
    |                        ^^^^^^^^^
 
 error: expected expression, found `let` statement
-  --> $DIR/feature-gate.rs:30:16
+  --> $DIR/feature-gate.rs:28:16
    |
 LL |         () if (let 0 = 1) && (let 0 = 1) => {}
    |                ^^^^^^^^^
    |
    = note: only supported directly in conditions of `if` and `while` expressions
 note: `let`s wrapped in parentheses are not supported in a context with let chains
-  --> $DIR/feature-gate.rs:30:16
+  --> $DIR/feature-gate.rs:28:16
    |
 LL |         () if (let 0 = 1) && (let 0 = 1) => {}
    |                ^^^^^^^^^
 
 error: expected expression, found `let` statement
-  --> $DIR/feature-gate.rs:30:31
+  --> $DIR/feature-gate.rs:28:31
    |
 LL |         () if (let 0 = 1) && (let 0 = 1) => {}
    |                               ^^^^^^^^^
    |
    = note: only supported directly in conditions of `if` and `while` expressions
 note: `let`s wrapped in parentheses are not supported in a context with let chains
-  --> $DIR/feature-gate.rs:30:31
+  --> $DIR/feature-gate.rs:28:31
    |
 LL |         () if (let 0 = 1) && (let 0 = 1) => {}
    |                               ^^^^^^^^^
 
 error: expected expression, found `let` statement
-  --> $DIR/feature-gate.rs:34:42
+  --> $DIR/feature-gate.rs:32:42
    |
 LL |         () if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) => {}
    |                                          ^^^^^^^^^
    |
    = note: only supported directly in conditions of `if` and `while` expressions
 note: `let`s wrapped in parentheses are not supported in a context with let chains
-  --> $DIR/feature-gate.rs:34:42
+  --> $DIR/feature-gate.rs:32:42
    |
 LL |         () if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) => {}
    |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: expected expression, found `let` statement
-  --> $DIR/feature-gate.rs:34:55
+  --> $DIR/feature-gate.rs:32:55
    |
 LL |         () if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) => {}
    |                                                       ^^^^^^^^^
    |
    = note: only supported directly in conditions of `if` and `while` expressions
 note: `let`s wrapped in parentheses are not supported in a context with let chains
-  --> $DIR/feature-gate.rs:34:42
+  --> $DIR/feature-gate.rs:32:42
    |
 LL |         () if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) => {}
    |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: expected expression, found `let` statement
-  --> $DIR/feature-gate.rs:34:68
+  --> $DIR/feature-gate.rs:32:68
    |
 LL |         () if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) => {}
    |                                                                    ^^^^^^^^^
    |
    = note: only supported directly in conditions of `if` and `while` expressions
 note: `let`s wrapped in parentheses are not supported in a context with let chains
-  --> $DIR/feature-gate.rs:34:42
+  --> $DIR/feature-gate.rs:32:42
    |
 LL |         () if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) => {}
    |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: expected expression, found `let` statement
-  --> $DIR/feature-gate.rs:60:16
+  --> $DIR/feature-gate.rs:55:16
    |
 LL |     use_expr!((let 0 = 1 && 0 == 0));
    |                ^^^
@@ -124,7 +124,7 @@ LL |     use_expr!((let 0 = 1 && 0 == 0));
    = note: only supported directly in conditions of `if` and `while` expressions
 
 error: expected expression, found `let` statement
-  --> $DIR/feature-gate.rs:60:16
+  --> $DIR/feature-gate.rs:55:16
    |
 LL |     use_expr!((let 0 = 1 && 0 == 0));
    |                ^^^
@@ -133,7 +133,7 @@ LL |     use_expr!((let 0 = 1 && 0 == 0));
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 error: expected expression, found `let` statement
-  --> $DIR/feature-gate.rs:63:16
+  --> $DIR/feature-gate.rs:58:16
    |
 LL |     use_expr!((let 0 = 1));
    |                ^^^
@@ -141,7 +141,7 @@ LL |     use_expr!((let 0 = 1));
    = note: only supported directly in conditions of `if` and `while` expressions
 
 error: expected expression, found `let` statement
-  --> $DIR/feature-gate.rs:63:16
+  --> $DIR/feature-gate.rs:58:16
    |
 LL |     use_expr!((let 0 = 1));
    |                ^^^
@@ -150,7 +150,7 @@ LL |     use_expr!((let 0 = 1));
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 error: no rules expected keyword `let`
-  --> $DIR/feature-gate.rs:72:15
+  --> $DIR/feature-gate.rs:67:15
    |
 LL |     macro_rules! use_expr {
    |     --------------------- when calling this macro
@@ -159,7 +159,7 @@ LL |     use_expr!(let 0 = 1);
    |               ^^^ no rules expected this token in macro call
    |
 note: while trying to match meta-variable `$e:expr`
-  --> $DIR/feature-gate.rs:53:10
+  --> $DIR/feature-gate.rs:48:10
    |
 LL |         ($e:expr) => {
    |          ^^^^^^^
@@ -187,7 +187,7 @@ LL |         () if true && let 0 = 1 => {}
    = help: you can write `if matches!(<expr>, <pattern>)` instead of `if let <pattern> = <expr>`
 
 error[E0658]: `if let` guards are experimental
-  --> $DIR/feature-gate.rs:20:12
+  --> $DIR/feature-gate.rs:19:12
    |
 LL |         () if let 0 = 1 && true => {}
    |            ^^^^^^^^^^^^^^^^^^^^
@@ -198,7 +198,7 @@ LL |         () if let 0 = 1 && true => {}
    = help: you can write `if matches!(<expr>, <pattern>)` instead of `if let <pattern> = <expr>`
 
 error[E0658]: `if let` guards are experimental
-  --> $DIR/feature-gate.rs:34:12
+  --> $DIR/feature-gate.rs:32:12
    |
 LL |         () if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) => {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -209,7 +209,7 @@ LL |         () if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 =
    = help: you can write `if matches!(<expr>, <pattern>)` instead of `if let <pattern> = <expr>`
 
 error[E0658]: `if let` guards are experimental
-  --> $DIR/feature-gate.rs:43:12
+  --> $DIR/feature-gate.rs:39:12
    |
 LL |         () if let Range { start: _, end: _ } = (true..true) && false => {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -220,7 +220,7 @@ LL |         () if let Range { start: _, end: _ } = (true..true) && false => {}
    = help: you can write `if matches!(<expr>, <pattern>)` instead of `if let <pattern> = <expr>`
 
 error[E0658]: `if let` guards are experimental
-  --> $DIR/feature-gate.rs:68:12
+  --> $DIR/feature-gate.rs:63:12
    |
 LL |         () if let 0 = 1 => {}
    |            ^^^^^^^^^^^^
@@ -230,56 +230,6 @@ LL |         () if let 0 = 1 => {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
    = help: you can write `if matches!(<expr>, <pattern>)` instead of `if let <pattern> = <expr>`
 
-error[E0658]: `let` expressions in this position are unstable
-  --> $DIR/feature-gate.rs:16:23
-   |
-LL |         () if true && let 0 = 1 => {}
-   |                       ^^^^^^^^^
-   |
-   = note: see issue #53667 <https://github.com/rust-lang/rust/issues/53667> for more information
-   = help: add `#![feature(let_chains)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error[E0658]: `let` expressions in this position are unstable
-  --> $DIR/feature-gate.rs:20:15
-   |
-LL |         () if let 0 = 1 && true => {}
-   |               ^^^^^^^^^
-   |
-   = note: see issue #53667 <https://github.com/rust-lang/rust/issues/53667> for more information
-   = help: add `#![feature(let_chains)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error[E0658]: `let` expressions in this position are unstable
-  --> $DIR/feature-gate.rs:34:15
-   |
-LL |         () if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) => {}
-   |               ^^^^^^^^^
-   |
-   = note: see issue #53667 <https://github.com/rust-lang/rust/issues/53667> for more information
-   = help: add `#![feature(let_chains)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error[E0658]: `let` expressions in this position are unstable
-  --> $DIR/feature-gate.rs:34:28
-   |
-LL |         () if let 0 = 1 && let 1 = 2 && (let 2 = 3 && let 3 = 4 && let 4 = 5) => {}
-   |                            ^^^^^^^^^
-   |
-   = note: see issue #53667 <https://github.com/rust-lang/rust/issues/53667> for more information
-   = help: add `#![feature(let_chains)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error[E0658]: `let` expressions in this position are unstable
-  --> $DIR/feature-gate.rs:43:15
-   |
-LL |         () if let Range { start: _, end: _ } = (true..true) && false => {}
-   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #53667 <https://github.com/rust-lang/rust/issues/53667> for more information
-   = help: add `#![feature(let_chains)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error: aborting due to 25 previous errors
+error: aborting due to 20 previous errors
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/rfcs/rfc-2294-if-let-guard/macro-expanded.rs b/tests/ui/rfcs/rfc-2294-if-let-guard/macro-expanded.rs
index 423a2cd53fc5..e1138835006b 100644
--- a/tests/ui/rfcs/rfc-2294-if-let-guard/macro-expanded.rs
+++ b/tests/ui/rfcs/rfc-2294-if-let-guard/macro-expanded.rs
@@ -1,7 +1,6 @@
 // Expression macros can't expand to a let match guard.
 
 #![feature(if_let_guard)]
-#![feature(let_chains)]
 
 macro_rules! m {
     ($e:expr) => { let Some(x) = $e }
diff --git a/tests/ui/rfcs/rfc-2294-if-let-guard/macro-expanded.stderr b/tests/ui/rfcs/rfc-2294-if-let-guard/macro-expanded.stderr
index b8065b9f5560..921cd083fffd 100644
--- a/tests/ui/rfcs/rfc-2294-if-let-guard/macro-expanded.stderr
+++ b/tests/ui/rfcs/rfc-2294-if-let-guard/macro-expanded.stderr
@@ -1,5 +1,5 @@
 error: expected expression, found `let` statement
-  --> $DIR/macro-expanded.rs:7:20
+  --> $DIR/macro-expanded.rs:6:20
    |
 LL |     ($e:expr) => { let Some(x) = $e }
    |                    ^^^
diff --git a/tests/ui/rfcs/rfc-2294-if-let-guard/move-guard-if-let-chain.rs b/tests/ui/rfcs/rfc-2294-if-let-guard/move-guard-if-let-chain.rs
index 47653efffb7b..29f529a30c2f 100644
--- a/tests/ui/rfcs/rfc-2294-if-let-guard/move-guard-if-let-chain.rs
+++ b/tests/ui/rfcs/rfc-2294-if-let-guard/move-guard-if-let-chain.rs
@@ -1,5 +1,5 @@
+//@ edition: 2024
 #![feature(if_let_guard)]
-#![feature(let_chains)]
 #![allow(irrefutable_let_patterns)]
 
 fn same_pattern(c: bool) {
diff --git a/tests/ui/rfcs/rfc-2294-if-let-guard/parens.rs b/tests/ui/rfcs/rfc-2294-if-let-guard/parens.rs
index 0e71a9d24c97..a4cb73c65083 100644
--- a/tests/ui/rfcs/rfc-2294-if-let-guard/parens.rs
+++ b/tests/ui/rfcs/rfc-2294-if-let-guard/parens.rs
@@ -1,7 +1,7 @@
+//@ edition: 2024
 // Parenthesised let "expressions" are not allowed in guards
 
 #![feature(if_let_guard)]
-#![feature(let_chains)]
 
 #[cfg(false)]
 fn un_cfged() {
diff --git a/tests/ui/rfcs/rfc-2294-if-let-guard/shadowing.rs b/tests/ui/rfcs/rfc-2294-if-let-guard/shadowing.rs
index 32a223c91595..e7946a2a23b1 100644
--- a/tests/ui/rfcs/rfc-2294-if-let-guard/shadowing.rs
+++ b/tests/ui/rfcs/rfc-2294-if-let-guard/shadowing.rs
@@ -1,8 +1,8 @@
 // Check shadowing in if let guards works as expected.
 //@ check-pass
+//@ edition: 2024
 
 #![feature(if_let_guard)]
-#![feature(let_chains)]
 
 fn main() {
     let x: Option<Option<i32>> = Some(Some(6));
diff --git a/tests/ui/rfcs/rfc-2497-if-let-chains/ast-lowering-does-not-wrap-let-chains.rs b/tests/ui/rfcs/rfc-2497-if-let-chains/ast-lowering-does-not-wrap-let-chains.rs
index e1edde6de19c..dc052c38fe7a 100644
--- a/tests/ui/rfcs/rfc-2497-if-let-chains/ast-lowering-does-not-wrap-let-chains.rs
+++ b/tests/ui/rfcs/rfc-2497-if-let-chains/ast-lowering-does-not-wrap-let-chains.rs
@@ -1,6 +1,6 @@
 //@ run-pass
+//@ edition: 2024
 
-#![feature(let_chains)]
 #![allow(irrefutable_let_patterns)]
 
 fn main() {
diff --git a/tests/ui/rfcs/rfc-2497-if-let-chains/ast-validate-guards.rs b/tests/ui/rfcs/rfc-2497-if-let-chains/ast-validate-guards.rs
index cb3be59bee01..ae13f7c76bad 100644
--- a/tests/ui/rfcs/rfc-2497-if-let-chains/ast-validate-guards.rs
+++ b/tests/ui/rfcs/rfc-2497-if-let-chains/ast-validate-guards.rs
@@ -1,4 +1,4 @@
-#![feature(let_chains)]
+//@ edition: 2024
 
 fn let_or_guard(x: Result<Option<i32>, ()>) {
     match x {
diff --git a/tests/ui/rfcs/rfc-2497-if-let-chains/ensure-that-let-else-does-not-interact-with-let-chains.rs b/tests/ui/rfcs/rfc-2497-if-let-chains/ensure-that-let-else-does-not-interact-with-let-chains.rs
index 3c572054e3fa..8e7db9a430cc 100644
--- a/tests/ui/rfcs/rfc-2497-if-let-chains/ensure-that-let-else-does-not-interact-with-let-chains.rs
+++ b/tests/ui/rfcs/rfc-2497-if-let-chains/ensure-that-let-else-does-not-interact-with-let-chains.rs
@@ -1,4 +1,4 @@
-#![feature(let_chains)]
+//@ edition: 2024
 
 fn main() {
     let opt = Some(1i32);
diff --git a/tests/ui/rfcs/rfc-2497-if-let-chains/issue-90722.rs b/tests/ui/rfcs/rfc-2497-if-let-chains/issue-90722.rs
index 59c81d053bc7..0113a87cecc2 100644
--- a/tests/ui/rfcs/rfc-2497-if-let-chains/issue-90722.rs
+++ b/tests/ui/rfcs/rfc-2497-if-let-chains/issue-90722.rs
@@ -1,6 +1,5 @@
 //@ check-pass
-
-#![feature(let_chains)]
+//@ edition: 2024
 
 fn main() {
     let x = Some(vec!["test"]);
diff --git a/tests/ui/rfcs/rfc-2497-if-let-chains/issue-92145.rs b/tests/ui/rfcs/rfc-2497-if-let-chains/issue-92145.rs
index ea4b34eacba5..f5d87d6999a2 100644
--- a/tests/ui/rfcs/rfc-2497-if-let-chains/issue-92145.rs
+++ b/tests/ui/rfcs/rfc-2497-if-let-chains/issue-92145.rs
@@ -1,6 +1,5 @@
 //@ check-pass
-
-#![feature(let_chains)]
+//@ edition:2024
 
 fn main() {
     let opt = Some("foo bar");
diff --git a/tests/ui/rfcs/rfc-2497-if-let-chains/issue-93150.rs b/tests/ui/rfcs/rfc-2497-if-let-chains/issue-93150.rs
index f90b9ab0d40f..f6de37867d85 100644
--- a/tests/ui/rfcs/rfc-2497-if-let-chains/issue-93150.rs
+++ b/tests/ui/rfcs/rfc-2497-if-let-chains/issue-93150.rs
@@ -2,7 +2,6 @@ fn main() {
     match true {
         _ if let true = true && true => {}
         //~^ ERROR `if let` guards are
-        //~| ERROR `let` expressions in this
         _ => {}
     }
 }
diff --git a/tests/ui/rfcs/rfc-2497-if-let-chains/issue-93150.stderr b/tests/ui/rfcs/rfc-2497-if-let-chains/issue-93150.stderr
index 637ae4915ed1..17fa37d2df32 100644
--- a/tests/ui/rfcs/rfc-2497-if-let-chains/issue-93150.stderr
+++ b/tests/ui/rfcs/rfc-2497-if-let-chains/issue-93150.stderr
@@ -9,16 +9,6 @@ LL |         _ if let true = true && true => {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
    = help: you can write `if matches!(<expr>, <pattern>)` instead of `if let <pattern> = <expr>`
 
-error[E0658]: `let` expressions in this position are unstable
-  --> $DIR/issue-93150.rs:3:14
-   |
-LL |         _ if let true = true && true => {}
-   |              ^^^^^^^^^^^^^^^
-   |
-   = note: see issue #53667 <https://github.com/rust-lang/rust/issues/53667> for more information
-   = help: add `#![feature(let_chains)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/rfcs/rfc-2497-if-let-chains/issue-99938.rs b/tests/ui/rfcs/rfc-2497-if-let-chains/issue-99938.rs
index 77756d0bee06..7589b33a73c1 100644
--- a/tests/ui/rfcs/rfc-2497-if-let-chains/issue-99938.rs
+++ b/tests/ui/rfcs/rfc-2497-if-let-chains/issue-99938.rs
@@ -1,6 +1,7 @@
 //@ compile-flags: -Zvalidate-mir -C opt-level=3
 //@ build-pass
-#![feature(let_chains)]
+//@ edition: 2024
+
 struct TupleIter<T, I: Iterator<Item = T>> {
     inner: I,
 }
diff --git a/tests/ui/rfcs/rfc-2497-if-let-chains/temporary-early-drop.rs b/tests/ui/rfcs/rfc-2497-if-let-chains/temporary-early-drop.rs
index 2c7fe2eea330..7d8dfe37135c 100644
--- a/tests/ui/rfcs/rfc-2497-if-let-chains/temporary-early-drop.rs
+++ b/tests/ui/rfcs/rfc-2497-if-let-chains/temporary-early-drop.rs
@@ -3,7 +3,6 @@
 //@ edition: 2024
 //@ check-pass
 
-#![feature(let_chains)]
 #![allow(irrefutable_let_patterns)]
 
 struct Pd;

From 2d21c140154c5387712938dbc2ca427e2df4dfc2 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Sun, 20 Apr 2025 12:52:50 +0200
Subject: [PATCH 07/20] respect `repr(align(N))` on functions in miri

---
 .../rustc_const_eval/src/interpret/memory.rs  | 16 ++++++++++++--
 src/tools/miri/tests/pass/fn_align.rs         | 21 +++++++++++++++++++
 2 files changed, 35 insertions(+), 2 deletions(-)
 create mode 100644 src/tools/miri/tests/pass/fn_align.rs

diff --git a/compiler/rustc_const_eval/src/interpret/memory.rs b/compiler/rustc_const_eval/src/interpret/memory.rs
index d077900587e9..3bde7457ad60 100644
--- a/compiler/rustc_const_eval/src/interpret/memory.rs
+++ b/compiler/rustc_const_eval/src/interpret/memory.rs
@@ -872,8 +872,20 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
 
         // # Function pointers
         // (both global from `alloc_map` and local from `extra_fn_ptr_map`)
-        if self.get_fn_alloc(id).is_some() {
-            return AllocInfo::new(Size::ZERO, Align::ONE, AllocKind::Function, Mutability::Not);
+        if let Some(fn_val) = self.get_fn_alloc(id) {
+            let align = match fn_val {
+                FnVal::Instance(instance) => {
+                    // Function alignment can be set globally with the `-Zmin-function-alignment=<n>` flag;
+                    // the alignment from a `#[repr(align(<n>))]` is used if it specifies a higher alignment.
+                    let fn_align = self.tcx.codegen_fn_attrs(instance.def_id()).alignment;
+                    let global_align = self.tcx.sess.opts.unstable_opts.min_function_alignment;
+
+                    Ord::max(global_align, fn_align).unwrap_or(Align::ONE)
+                }
+                FnVal::Other(_) => Align::ONE,
+            };
+
+            return AllocInfo::new(Size::ZERO, align, AllocKind::Function, Mutability::Not);
         }
 
         // # Global allocations
diff --git a/src/tools/miri/tests/pass/fn_align.rs b/src/tools/miri/tests/pass/fn_align.rs
new file mode 100644
index 000000000000..550bb1cb4d71
--- /dev/null
+++ b/src/tools/miri/tests/pass/fn_align.rs
@@ -0,0 +1,21 @@
+//@compile-flags: -Zmin-function-alignment=8
+#![feature(fn_align)]
+
+// When a function uses `repr(align(N))`, the function address should be a multiple of `N`.
+
+#[repr(align(256))]
+fn foo() {}
+
+#[repr(align(16))]
+fn bar() {}
+
+#[repr(align(4))]
+fn baz() {}
+
+fn main() {
+    assert!((foo as usize).is_multiple_of(256));
+    assert!((bar as usize).is_multiple_of(16));
+
+    // The maximum of `repr(align(N))` and `-Zmin-function-alignment=N` is used.
+    assert!((baz as usize).is_multiple_of(8));
+}

From 5258cb76a590b6828d6f90a48ce07deffac13a67 Mon Sep 17 00:00:00 2001
From: est31 <MTest31@outlook.com>
Date: Fri, 18 Apr 2025 15:41:07 +0200
Subject: [PATCH 08/20] Don't call ungate_last

---
 compiler/rustc_parse/src/parser/expr.rs | 99 +++++++++++--------------
 1 file changed, 45 insertions(+), 54 deletions(-)

diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index 3bd7aaee78e4..20a5252624d5 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -2606,7 +2606,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(lo.edition())?;
+        // 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)
     }
 
@@ -2716,41 +2719,16 @@ impl<'a> Parser<'a> {
 
     /// Parses the condition of a `if` or `while` expression.
     ///
-    /// The specified `edition` should be that of the whole `if` or `while` construct: the same
-    /// span that we later decide the drop behaviour on (editions ..=2021 vs 2024..)
+    /// 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, edition: Edition) -> 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);
-        } else {
-            fn ungate_let_exprs(this: &mut Parser<'_>, expr: &Expr) {
-                if !expr.span.at_least_rust_2024() {
-                    return;
-                }
-                match &expr.kind {
-                    ExprKind::Binary(BinOp { node: BinOpKind::And, .. }, lhs, rhs) => {
-                        ungate_let_exprs(this, rhs);
-                        ungate_let_exprs(this, lhs);
-                    }
-                    ExprKind::Let(..) => {
-                        this.psess.gated_spans.ungate_last(sym::let_chains, expr.span)
-                    }
-                    _ => (),
-                }
-            }
-            if edition.at_least_rust_2024() {
-                // Scoping code checks the top level edition of the `if`: let's match it here.
-                // Also check all editions in between, just to make sure.
-                ungate_let_exprs(self, &cond);
-            }
-        }
+        CondChecker::new(self, let_chains_policy).visit_expr(&mut cond);
 
         Ok(cond)
     }
@@ -3045,7 +3023,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(lo.edition()).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
         })?;
@@ -3429,7 +3408,7 @@ 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 has_let_expr(expr: &Expr) -> bool {
             match &expr.kind {
@@ -3450,23 +3429,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);
 
         if has_let_expr(&cond) {
-            // Let chains are allowed in match guards, but only there
-            fn ungate_let_exprs(this: &mut Parser<'_>, expr: &Expr) {
-                match &expr.kind {
-                    ExprKind::Binary(BinOp { node: BinOpKind::And, .. }, lhs, rhs) => {
-                        ungate_let_exprs(this, rhs);
-                        ungate_let_exprs(this, lhs);
-                    }
-                    ExprKind::Let(..) => {
-                        this.psess.gated_spans.ungate_last(sym::let_chains, expr.span)
-                    }
-                    _ => (),
-                }
-            }
-            ungate_let_exprs(self, &cond);
             let span = if_span.to(cond.span);
             self.psess.gated_spans.gate(sym::if_let_guard, span);
         }
@@ -3493,7 +3458,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],
@@ -4072,7 +4037,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)
@@ -4083,19 +4055,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;
@@ -4110,8 +4092,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, .. }, _, _) => {
@@ -4213,5 +4203,6 @@ impl MutVisitor for CondChecker<'_> {
                 // These would forbid any let expressions they contain already.
             }
         }
+        self.depth -= 1;
     }
 }

From c0c6d4280c31a426f48efe15d76d565bbf464136 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Mon, 21 Apr 2025 13:22:56 +0530
Subject: [PATCH 09/20] support both trait and non-trail associated declaration

---
 compiler/rustc_builtin_macros/src/autodiff.rs | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/compiler/rustc_builtin_macros/src/autodiff.rs b/compiler/rustc_builtin_macros/src/autodiff.rs
index daebd516499b..b33856ac2366 100644
--- a/compiler/rustc_builtin_macros/src/autodiff.rs
+++ b/compiler/rustc_builtin_macros/src/autodiff.rs
@@ -217,14 +217,12 @@ mod llvm_enzyme {
                 ast::StmtKind::Item(iitem) => extract_item_info(iitem),
                 _ => None,
             },
-            Annotatable::AssocItem(assoc_item, Impl { of_trait: false }) => {
-                match &assoc_item.kind {
-                    ast::AssocItemKind::Fn(box ast::Fn { sig, ident, .. }) => {
-                        Some((assoc_item.vis.clone(), sig.clone(), ident.clone()))
-                    }
-                    _ => None,
+            Annotatable::AssocItem(assoc_item, Impl { .. }) => match &assoc_item.kind {
+                ast::AssocItemKind::Fn(box ast::Fn { sig, ident, .. }) => {
+                    Some((assoc_item.vis.clone(), sig.clone(), ident.clone()))
                 }
-            }
+                _ => None,
+            },
             _ => None,
         }) else {
             dcx.emit_err(errors::AutoDiffInvalidApplication { span: item.span() });
@@ -365,7 +363,7 @@ mod llvm_enzyme {
                 }
                 Annotatable::Item(iitem.clone())
             }
-            Annotatable::AssocItem(ref mut assoc_item, i @ Impl { of_trait: false }) => {
+            Annotatable::AssocItem(ref mut assoc_item, i @ Impl { .. }) => {
                 if !assoc_item.attrs.iter().any(|a| same_attribute(&a.kind, &attr.kind)) {
                     assoc_item.attrs.push(attr);
                 }

From b70763e306992af3e2b2cc06b7abdd8dfb7f2d88 Mon Sep 17 00:00:00 2001
From: rustbot <47979223+rustbot@users.noreply.github.com>
Date: Mon, 21 Apr 2025 19:00:50 +0200
Subject: [PATCH 10/20] Update books

---
 src/doc/nomicon   | 2 +-
 src/doc/reference | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/doc/nomicon b/src/doc/nomicon
index 0c10c30cc547..c76a20f0d987 160000
--- a/src/doc/nomicon
+++ b/src/doc/nomicon
@@ -1 +1 @@
-Subproject commit 0c10c30cc54736c5c194ce98c50e2de84eeb6e79
+Subproject commit c76a20f0d987145dcedf05c5c073ce8d91f2e82a
diff --git a/src/doc/reference b/src/doc/reference
index 3340922df189..3bf3402aea98 160000
--- a/src/doc/reference
+++ b/src/doc/reference
@@ -1 +1 @@
-Subproject commit 3340922df189bddcbaad17dc3927d51a76bcd5ed
+Subproject commit 3bf3402aea982b876eb56c87da17b0685c6461d5

From b5e8f1f0cec8065eb9cb453ad4c5aa5bec8baf32 Mon Sep 17 00:00:00 2001
From: Kivooeo <Kivooeo123@gmail.com>
Date: Wed, 16 Apr 2025 18:16:04 +0500
Subject: [PATCH 11/20] improve diagnostic for raw pointer field access using
 `->`

---
 compiler/rustc_hir_typeck/src/expr.rs         |  4 +-
 compiler/rustc_parse/messages.ftl             |  4 +-
 .../expr-rarrow-call-on-a-raw-pointer.rs      | 22 ++++++++
 .../expr-rarrow-call-on-a-raw-pointer.stderr  | 53 +++++++++++++++++++
 tests/ui/parser/expr-rarrow-call.fixed        | 10 ++--
 tests/ui/parser/expr-rarrow-call.rs           | 10 ++--
 tests/ui/parser/expr-rarrow-call.stderr       | 20 +++----
 tests/ui/parser/issues/issue-118530-ice.rs    |  2 +-
 .../ui/parser/issues/issue-118530-ice.stderr  |  4 +-
 9 files changed, 102 insertions(+), 27 deletions(-)
 create mode 100644 tests/ui/parser/expr-rarrow-call-on-a-raw-pointer.rs
 create mode 100644 tests/ui/parser/expr-rarrow-call-on-a-raw-pointer.stderr

diff --git a/compiler/rustc_hir_typeck/src/expr.rs b/compiler/rustc_hir_typeck/src/expr.rs
index d6a7bfc446a4..9c6d4ee096f1 100644
--- a/compiler/rustc_hir_typeck/src/expr.rs
+++ b/compiler/rustc_hir_typeck/src/expr.rs
@@ -3289,8 +3289,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         err.multipart_suggestion(
             format!("{val} is a raw pointer; try dereferencing it"),
             vec![
-                (base.span.shrink_to_lo(), "(*".to_string()),
-                (base.span.shrink_to_hi(), ")".to_string()),
+                (base.span.shrink_to_lo(), "(*".into()),
+                (base.span.between(field.span), format!(").")),
             ],
             Applicability::MaybeIncorrect,
         );
diff --git a/compiler/rustc_parse/messages.ftl b/compiler/rustc_parse/messages.ftl
index e7f17bb6f996..97bade2d31e2 100644
--- a/compiler/rustc_parse/messages.ftl
+++ b/compiler/rustc_parse/messages.ftl
@@ -246,9 +246,9 @@ parse_expected_struct_field = expected one of `,`, `:`, or `{"}"}`, found `{$tok
 
 parse_expected_trait_in_trait_impl_found_type = expected a trait, found type
 
-parse_expr_rarrow_call = `->` used for field access or method call
+parse_expr_rarrow_call = `->` is not valid syntax for field accesses and method calls
     .suggestion = try using `.` instead
-    .help = the `.` operator will dereference the value if needed
+    .help = the `.` operator will automatically dereference the value, except if the value is a raw pointer
 
 parse_extern_crate_name_with_dashes = crate name using dashes are not valid in `extern crate` statements
     .label = dash-separated idents are not valid
diff --git a/tests/ui/parser/expr-rarrow-call-on-a-raw-pointer.rs b/tests/ui/parser/expr-rarrow-call-on-a-raw-pointer.rs
new file mode 100644
index 000000000000..0ce5e233930e
--- /dev/null
+++ b/tests/ui/parser/expr-rarrow-call-on-a-raw-pointer.rs
@@ -0,0 +1,22 @@
+#![allow(
+    dead_code,
+    unused_must_use
+)]
+
+struct Named {
+    foo: usize,
+}
+
+struct Unnamed(usize);
+
+unsafe fn named_struct_field_access(named: *mut Named) {
+    named->foo += 1; //~ ERROR `->` is not valid syntax for field accesses and method calls
+    //~^ ERROR no field `foo` on type `*mut Named`
+}
+
+unsafe fn unnamed_struct_field_access(unnamed: *mut Unnamed) {
+    unnamed->0 += 1; //~ ERROR `->` is not valid syntax for field accesses and method calls
+    //~^ ERROR no field `0` on type `*mut Unnamed`
+}
+
+fn main() {}
diff --git a/tests/ui/parser/expr-rarrow-call-on-a-raw-pointer.stderr b/tests/ui/parser/expr-rarrow-call-on-a-raw-pointer.stderr
new file mode 100644
index 000000000000..45f3c5549f7e
--- /dev/null
+++ b/tests/ui/parser/expr-rarrow-call-on-a-raw-pointer.stderr
@@ -0,0 +1,53 @@
+error: `->` is not valid syntax for field accesses and method calls
+  --> $DIR/expr-rarrow-call-on-a-raw-pointer.rs:13:10
+   |
+LL |     named->foo += 1;
+   |          ^^
+   |
+   = help: the `.` operator will automatically dereference the value, except if the value is a raw pointer
+help: try using `.` instead
+   |
+LL -     named->foo += 1;
+LL +     named.foo += 1;
+   |
+
+error: `->` is not valid syntax for field accesses and method calls
+  --> $DIR/expr-rarrow-call-on-a-raw-pointer.rs:18:12
+   |
+LL |     unnamed->0 += 1;
+   |            ^^
+   |
+   = help: the `.` operator will automatically dereference the value, except if the value is a raw pointer
+help: try using `.` instead
+   |
+LL -     unnamed->0 += 1;
+LL +     unnamed.0 += 1;
+   |
+
+error[E0609]: no field `foo` on type `*mut Named`
+  --> $DIR/expr-rarrow-call-on-a-raw-pointer.rs:13:12
+   |
+LL |     named->foo += 1;
+   |            ^^^ unknown field
+   |
+help: `named` is a raw pointer; try dereferencing it
+   |
+LL -     named->foo += 1;
+LL +     (*named).foo += 1;
+   |
+
+error[E0609]: no field `0` on type `*mut Unnamed`
+  --> $DIR/expr-rarrow-call-on-a-raw-pointer.rs:18:14
+   |
+LL |     unnamed->0 += 1;
+   |              ^ unknown field
+   |
+help: `unnamed` is a raw pointer; try dereferencing it
+   |
+LL -     unnamed->0 += 1;
+LL +     (*unnamed).0 += 1;
+   |
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0609`.
diff --git a/tests/ui/parser/expr-rarrow-call.fixed b/tests/ui/parser/expr-rarrow-call.fixed
index 9a05e20092dd..c97284c4b01e 100644
--- a/tests/ui/parser/expr-rarrow-call.fixed
+++ b/tests/ui/parser/expr-rarrow-call.fixed
@@ -11,23 +11,23 @@ struct Named {
 struct Unnamed(usize);
 
 fn named_struct_field_access(named: &Named) {
-    named.foo; //~ ERROR `->` used for field access or method call
+    named.foo; //~ ERROR `->` is not valid syntax for field accesses and method calls
 }
 
 fn unnamed_struct_field_access(unnamed: &Unnamed) {
-    unnamed.0; //~ ERROR `->` used for field access or method call
+    unnamed.0; //~ ERROR `->` is not valid syntax for field accesses and method calls
 }
 
 fn tuple_field_access(t: &(u8, u8)) {
-    t.0; //~ ERROR `->` used for field access or method call
-    t.1; //~ ERROR `->` used for field access or method call
+    t.0; //~ ERROR `->` is not valid syntax for field accesses and method calls
+    t.1; //~ ERROR `->` is not valid syntax for field accesses and method calls
 }
 
 #[derive(Clone)]
 struct Foo;
 
 fn method_call(foo: &Foo) {
-    foo.clone(); //~ ERROR `->` used for field access or method call
+    foo.clone(); //~ ERROR `->` is not valid syntax for field accesses and method calls
 }
 
 fn main() {}
diff --git a/tests/ui/parser/expr-rarrow-call.rs b/tests/ui/parser/expr-rarrow-call.rs
index 760b0f6f345b..78cd72b12ec8 100644
--- a/tests/ui/parser/expr-rarrow-call.rs
+++ b/tests/ui/parser/expr-rarrow-call.rs
@@ -11,23 +11,23 @@ struct Named {
 struct Unnamed(usize);
 
 fn named_struct_field_access(named: &Named) {
-    named->foo; //~ ERROR `->` used for field access or method call
+    named->foo; //~ ERROR `->` is not valid syntax for field accesses and method calls
 }
 
 fn unnamed_struct_field_access(unnamed: &Unnamed) {
-    unnamed->0; //~ ERROR `->` used for field access or method call
+    unnamed->0; //~ ERROR `->` is not valid syntax for field accesses and method calls
 }
 
 fn tuple_field_access(t: &(u8, u8)) {
-    t->0; //~ ERROR `->` used for field access or method call
-    t->1; //~ ERROR `->` used for field access or method call
+    t->0; //~ ERROR `->` is not valid syntax for field accesses and method calls
+    t->1; //~ ERROR `->` is not valid syntax for field accesses and method calls
 }
 
 #[derive(Clone)]
 struct Foo;
 
 fn method_call(foo: &Foo) {
-    foo->clone(); //~ ERROR `->` used for field access or method call
+    foo->clone(); //~ ERROR `->` is not valid syntax for field accesses and method calls
 }
 
 fn main() {}
diff --git a/tests/ui/parser/expr-rarrow-call.stderr b/tests/ui/parser/expr-rarrow-call.stderr
index 2e168ca26fec..0b105273861f 100644
--- a/tests/ui/parser/expr-rarrow-call.stderr
+++ b/tests/ui/parser/expr-rarrow-call.stderr
@@ -1,62 +1,62 @@
-error: `->` used for field access or method call
+error: `->` is not valid syntax for field accesses and method calls
   --> $DIR/expr-rarrow-call.rs:14:10
    |
 LL |     named->foo;
    |          ^^
    |
-   = help: the `.` operator will dereference the value if needed
+   = help: the `.` operator will automatically dereference the value, except if the value is a raw pointer
 help: try using `.` instead
    |
 LL -     named->foo;
 LL +     named.foo;
    |
 
-error: `->` used for field access or method call
+error: `->` is not valid syntax for field accesses and method calls
   --> $DIR/expr-rarrow-call.rs:18:12
    |
 LL |     unnamed->0;
    |            ^^
    |
-   = help: the `.` operator will dereference the value if needed
+   = help: the `.` operator will automatically dereference the value, except if the value is a raw pointer
 help: try using `.` instead
    |
 LL -     unnamed->0;
 LL +     unnamed.0;
    |
 
-error: `->` used for field access or method call
+error: `->` is not valid syntax for field accesses and method calls
   --> $DIR/expr-rarrow-call.rs:22:6
    |
 LL |     t->0;
    |      ^^
    |
-   = help: the `.` operator will dereference the value if needed
+   = help: the `.` operator will automatically dereference the value, except if the value is a raw pointer
 help: try using `.` instead
    |
 LL -     t->0;
 LL +     t.0;
    |
 
-error: `->` used for field access or method call
+error: `->` is not valid syntax for field accesses and method calls
   --> $DIR/expr-rarrow-call.rs:23:6
    |
 LL |     t->1;
    |      ^^
    |
-   = help: the `.` operator will dereference the value if needed
+   = help: the `.` operator will automatically dereference the value, except if the value is a raw pointer
 help: try using `.` instead
    |
 LL -     t->1;
 LL +     t.1;
    |
 
-error: `->` used for field access or method call
+error: `->` is not valid syntax for field accesses and method calls
   --> $DIR/expr-rarrow-call.rs:30:8
    |
 LL |     foo->clone();
    |        ^^
    |
-   = help: the `.` operator will dereference the value if needed
+   = help: the `.` operator will automatically dereference the value, except if the value is a raw pointer
 help: try using `.` instead
    |
 LL -     foo->clone();
diff --git a/tests/ui/parser/issues/issue-118530-ice.rs b/tests/ui/parser/issues/issue-118530-ice.rs
index cf14eebec2b7..8930eb86c6b2 100644
--- a/tests/ui/parser/issues/issue-118530-ice.rs
+++ b/tests/ui/parser/issues/issue-118530-ice.rs
@@ -5,7 +5,7 @@ fn bar() -> String {
     attr::fn bar() -> String { //~ ERROR expected identifier, found keyword `fn`
     //~^ ERROR expected one of `(`, `.`, `::`, `;`, `?`, `}`, or an operator, found `{`
     //~| ERROR expected `;`, found `bar`
-    //~| ERROR `->` used for field access or method call
+    //~| ERROR `->` is not valid syntax for field accesses and method calls
     #[attr]
     [1, 2, 3].iter().map().collect::<String>()
     #[attr]
diff --git a/tests/ui/parser/issues/issue-118530-ice.stderr b/tests/ui/parser/issues/issue-118530-ice.stderr
index 72c0397e9c95..ef891d1dc290 100644
--- a/tests/ui/parser/issues/issue-118530-ice.stderr
+++ b/tests/ui/parser/issues/issue-118530-ice.stderr
@@ -33,13 +33,13 @@ LL |     attr::fn bar() -> String {
    |             |
    |             help: add `;` here
 
-error: `->` used for field access or method call
+error: `->` is not valid syntax for field accesses and method calls
   --> $DIR/issue-118530-ice.rs:5:20
    |
 LL |     attr::fn bar() -> String {
    |                    ^^
    |
-   = help: the `.` operator will dereference the value if needed
+   = help: the `.` operator will automatically dereference the value, except if the value is a raw pointer
 help: try using `.` instead
    |
 LL -     attr::fn bar() -> String {

From a7c7119ed2f98501141d59795a28c2235927e601 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Mon, 21 Apr 2025 13:26:25 +0530
Subject: [PATCH 12/20] Added test

---
 tests/pretty/inherent_impl.pp | 41 +++++++++++++++++++++++++++++++++++
 tests/pretty/inherent_impl.rs | 24 ++++++++++++++++++++
 2 files changed, 65 insertions(+)
 create mode 100644 tests/pretty/inherent_impl.pp
 create mode 100644 tests/pretty/inherent_impl.rs

diff --git a/tests/pretty/inherent_impl.pp b/tests/pretty/inherent_impl.pp
new file mode 100644
index 000000000000..97ac766b6b99
--- /dev/null
+++ b/tests/pretty/inherent_impl.pp
@@ -0,0 +1,41 @@
+#![feature(prelude_import)]
+#![no_std]
+//@ needs-enzyme
+
+#![feature(autodiff)]
+#[prelude_import]
+use ::std::prelude::rust_2015::*;
+#[macro_use]
+extern crate std;
+//@ pretty-mode:expanded
+//@ pretty-compare-only
+//@ pp-exact:inherent_impl.pp
+
+use std::autodiff::autodiff;
+
+struct Foo {
+    a: f64,
+}
+
+trait MyTrait {
+    fn f(&self, x: f64)
+    -> f64;
+    fn df(&self, x: f64, seed: f64)
+    -> (f64, f64);
+}
+
+impl MyTrait for Foo {
+    #[rustc_autodiff]
+    #[inline(never)]
+    fn f(&self, x: f64) -> f64 {
+        self.a * 0.25 * (x * x - 1.0 - 2.0 * x.ln())
+    }
+    #[rustc_autodiff(Reverse, 1, Const, Active, Active)]
+    #[inline(never)]
+    fn df(&self, x: f64, dret: f64) -> (f64, f64) {
+        unsafe { asm!("NOP", options(pure, nomem)); };
+        ::core::hint::black_box(self.f(x));
+        ::core::hint::black_box((dret,));
+        ::core::hint::black_box((self.f(x), f64::default()))
+    }
+}
diff --git a/tests/pretty/inherent_impl.rs b/tests/pretty/inherent_impl.rs
new file mode 100644
index 000000000000..59de93f7e0ff
--- /dev/null
+++ b/tests/pretty/inherent_impl.rs
@@ -0,0 +1,24 @@
+//@ needs-enzyme
+
+#![feature(autodiff)]
+//@ pretty-mode:expanded
+//@ pretty-compare-only
+//@ pp-exact:inherent_impl.pp
+
+use std::autodiff::autodiff;
+
+struct Foo {
+    a: f64,
+}
+
+trait MyTrait {
+    fn f(&self, x: f64) -> f64;
+    fn df(&self, x: f64, seed: f64) -> (f64, f64);
+}
+
+impl MyTrait for Foo {
+    #[autodiff(df, Reverse, Const, Active, Active)]
+    fn f(&self, x: f64) -> f64 {
+        self.a * 0.25 * (x * x - 1.0 - 2.0 * x.ln())
+    }
+}

From b8ca0073c8e4d1d9e324db832500beb41c129040 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Tue, 22 Apr 2025 09:53:08 +0530
Subject: [PATCH 13/20] move autodiff pretty test to a autodiff sub module

---
 tests/pretty/{ => autodiff}/autodiff_forward.pp | 0
 tests/pretty/{ => autodiff}/autodiff_forward.rs | 0
 tests/pretty/{ => autodiff}/autodiff_reverse.pp | 0
 tests/pretty/{ => autodiff}/autodiff_reverse.rs | 0
 tests/pretty/{ => autodiff}/inherent_impl.pp    | 0
 tests/pretty/{ => autodiff}/inherent_impl.rs    | 0
 6 files changed, 0 insertions(+), 0 deletions(-)
 rename tests/pretty/{ => autodiff}/autodiff_forward.pp (100%)
 rename tests/pretty/{ => autodiff}/autodiff_forward.rs (100%)
 rename tests/pretty/{ => autodiff}/autodiff_reverse.pp (100%)
 rename tests/pretty/{ => autodiff}/autodiff_reverse.rs (100%)
 rename tests/pretty/{ => autodiff}/inherent_impl.pp (100%)
 rename tests/pretty/{ => autodiff}/inherent_impl.rs (100%)

diff --git a/tests/pretty/autodiff_forward.pp b/tests/pretty/autodiff/autodiff_forward.pp
similarity index 100%
rename from tests/pretty/autodiff_forward.pp
rename to tests/pretty/autodiff/autodiff_forward.pp
diff --git a/tests/pretty/autodiff_forward.rs b/tests/pretty/autodiff/autodiff_forward.rs
similarity index 100%
rename from tests/pretty/autodiff_forward.rs
rename to tests/pretty/autodiff/autodiff_forward.rs
diff --git a/tests/pretty/autodiff_reverse.pp b/tests/pretty/autodiff/autodiff_reverse.pp
similarity index 100%
rename from tests/pretty/autodiff_reverse.pp
rename to tests/pretty/autodiff/autodiff_reverse.pp
diff --git a/tests/pretty/autodiff_reverse.rs b/tests/pretty/autodiff/autodiff_reverse.rs
similarity index 100%
rename from tests/pretty/autodiff_reverse.rs
rename to tests/pretty/autodiff/autodiff_reverse.rs
diff --git a/tests/pretty/inherent_impl.pp b/tests/pretty/autodiff/inherent_impl.pp
similarity index 100%
rename from tests/pretty/inherent_impl.pp
rename to tests/pretty/autodiff/inherent_impl.pp
diff --git a/tests/pretty/inherent_impl.rs b/tests/pretty/autodiff/inherent_impl.rs
similarity index 100%
rename from tests/pretty/inherent_impl.rs
rename to tests/pretty/autodiff/inherent_impl.rs

From 6be270be0c3b0ac06621c0528b8230076d12d4e9 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 22 Apr 2025 14:56:45 +1000
Subject: [PATCH 14/20] Handle another negated literal in `eat_token_lit`.

Extends the change from #139653, which was on expressions, to literals.

Fixes #140098.
---
 compiler/rustc_parse/src/parser/expr.rs       | 26 +++++++++----------
 tests/ui/macros/reparse-expr-issue-139495.rs  | 14 +++++++---
 .../macros/reparse-expr-issue-139495.stderr   | 25 +++++++++++++-----
 3 files changed, 42 insertions(+), 23 deletions(-)

diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index 71cc814cb500..53028bff8a73 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -2148,6 +2148,17 @@ impl<'a> Parser<'a> {
     /// Keep this in sync with `Token::can_begin_literal_maybe_minus` and
     /// `Lit::from_token` (excluding unary negation).
     fn eat_token_lit(&mut self) -> Option<token::Lit> {
+        let check_expr = |expr: P<Expr>| {
+            if let ast::ExprKind::Lit(token_lit) = expr.kind {
+                Some(token_lit)
+            } else if let ast::ExprKind::Unary(UnOp::Neg, inner) = &expr.kind
+                && let ast::Expr { kind: ast::ExprKind::Lit(_), .. } = **inner
+            {
+                None
+            } else {
+                panic!("unexpected reparsed expr/literal: {:?}", expr.kind);
+            }
+        };
         match self.token.uninterpolate().kind {
             token::Ident(name, IdentIsRaw::No) if name.is_bool_lit() => {
                 self.bump();
@@ -2163,10 +2174,7 @@ impl<'a> Parser<'a> {
                 let lit = self
                     .eat_metavar_seq(MetaVarKind::Literal, |this| this.parse_literal_maybe_minus())
                     .expect("metavar seq literal");
-                let ast::ExprKind::Lit(token_lit) = lit.kind else {
-                    panic!("didn't reparse a literal");
-                };
-                Some(token_lit)
+                check_expr(lit)
             }
             token::OpenDelim(Delimiter::Invisible(InvisibleOrigin::MetaVar(
                 mv_kind @ MetaVarKind::Expr { can_begin_literal_maybe_minus: true, .. },
@@ -2174,15 +2182,7 @@ impl<'a> Parser<'a> {
                 let expr = self
                     .eat_metavar_seq(mv_kind, |this| this.parse_expr())
                     .expect("metavar seq expr");
-                if let ast::ExprKind::Lit(token_lit) = expr.kind {
-                    Some(token_lit)
-                } else if let ast::ExprKind::Unary(UnOp::Neg, inner) = &expr.kind
-                    && let ast::Expr { kind: ast::ExprKind::Lit(_), .. } = **inner
-                {
-                    None
-                } else {
-                    panic!("unexpected reparsed expr: {:?}", expr.kind);
-                }
+                check_expr(expr)
             }
             _ => None,
         }
diff --git a/tests/ui/macros/reparse-expr-issue-139495.rs b/tests/ui/macros/reparse-expr-issue-139495.rs
index 38d24573a533..89734cae0a61 100644
--- a/tests/ui/macros/reparse-expr-issue-139495.rs
+++ b/tests/ui/macros/reparse-expr-issue-139495.rs
@@ -1,7 +1,15 @@
-macro_rules! m {
-  ($abi : expr) => { extern $abi } //~ ERROR expected expression, found keyword `extern`
+macro_rules! m1 {
+  ($abi: literal) => { extern $abi } //~ ERROR expected expression, found keyword `extern`
+}
+
+macro_rules! m2 {
+  ($abi: expr) => { extern $abi } //~ ERROR expected expression, found keyword `extern`
 }
 
 fn main() {
-    m!(-2)
+    m1!(-2)
+}
+
+fn f() {
+    m2!(-2)
 }
diff --git a/tests/ui/macros/reparse-expr-issue-139495.stderr b/tests/ui/macros/reparse-expr-issue-139495.stderr
index 73a8ed87ba05..e2e05d67ecc2 100644
--- a/tests/ui/macros/reparse-expr-issue-139495.stderr
+++ b/tests/ui/macros/reparse-expr-issue-139495.stderr
@@ -1,13 +1,24 @@
 error: expected expression, found keyword `extern`
-  --> $DIR/reparse-expr-issue-139495.rs:2:22
+  --> $DIR/reparse-expr-issue-139495.rs:2:24
    |
-LL |   ($abi : expr) => { extern $abi }
-   |                      ^^^^^^ expected expression
+LL |   ($abi: literal) => { extern $abi }
+   |                        ^^^^^^ expected expression
 ...
-LL |     m!(-2)
-   |     ------ in this macro invocation
+LL |     m1!(-2)
+   |     ------- in this macro invocation
    |
-   = note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `m1` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 1 previous error
+error: expected expression, found keyword `extern`
+  --> $DIR/reparse-expr-issue-139495.rs:6:21
+   |
+LL |   ($abi: expr) => { extern $abi }
+   |                     ^^^^^^ expected expression
+...
+LL |     m2!(-2)
+   |     ------- in this macro invocation
+   |
+   = note: this error originates in the macro `m2` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 2 previous errors
 

From e7a865448a3ed5cc192f1e1cf2a7443d13a14e50 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 22 Apr 2025 09:06:43 +0200
Subject: [PATCH 15/20] test_nan: ensure the NAN contant is quiet

---
 library/std/tests/floats/f128.rs | 2 ++
 library/std/tests/floats/f16.rs  | 2 ++
 library/std/tests/floats/f32.rs  | 2 ++
 library/std/tests/floats/f64.rs  | 2 ++
 4 files changed, 8 insertions(+)

diff --git a/library/std/tests/floats/f128.rs b/library/std/tests/floats/f128.rs
index df28e8129ddd..677738bac8f9 100644
--- a/library/std/tests/floats/f128.rs
+++ b/library/std/tests/floats/f128.rs
@@ -112,6 +112,8 @@ fn test_nan() {
     assert!(!nan.is_sign_negative());
     assert!(!nan.is_normal());
     assert_eq!(Fp::Nan, nan.classify());
+    // Ensure the quiet bit is set.
+    assert!(nan.to_bits() & (1 << (f128::MANTISSA_DIGITS - 2)) != 0);
 }
 
 #[test]
diff --git a/library/std/tests/floats/f16.rs b/library/std/tests/floats/f16.rs
index 1a90f00aecce..0fc4df8115a2 100644
--- a/library/std/tests/floats/f16.rs
+++ b/library/std/tests/floats/f16.rs
@@ -95,6 +95,8 @@ fn test_nan() {
     assert!(!nan.is_sign_negative());
     assert!(!nan.is_normal());
     assert_eq!(Fp::Nan, nan.classify());
+    // Ensure the quiet bit is set.
+    assert!(nan.to_bits() & (1 << (f16::MANTISSA_DIGITS - 2)) != 0);
 }
 
 #[test]
diff --git a/library/std/tests/floats/f32.rs b/library/std/tests/floats/f32.rs
index d99b03cb255f..9af23afc5bbf 100644
--- a/library/std/tests/floats/f32.rs
+++ b/library/std/tests/floats/f32.rs
@@ -72,6 +72,8 @@ fn test_nan() {
     assert!(nan.is_sign_positive());
     assert!(!nan.is_sign_negative());
     assert_eq!(Fp::Nan, nan.classify());
+    // Ensure the quiet bit is set.
+    assert!(nan.to_bits() & (1 << (f32::MANTISSA_DIGITS - 2)) != 0);
 }
 
 #[test]
diff --git a/library/std/tests/floats/f64.rs b/library/std/tests/floats/f64.rs
index 611670751bb5..de9c27eb33d3 100644
--- a/library/std/tests/floats/f64.rs
+++ b/library/std/tests/floats/f64.rs
@@ -60,6 +60,8 @@ fn test_nan() {
     assert!(nan.is_sign_positive());
     assert!(!nan.is_sign_negative());
     assert_eq!(Fp::Nan, nan.classify());
+    // Ensure the quiet bit is set.
+    assert!(nan.to_bits() & (1 << (f64::MANTISSA_DIGITS - 2)) != 0);
 }
 
 #[test]

From 5717623778b580bcecc6211c394b91eaf9c88e72 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 22 Apr 2025 09:07:05 +0200
Subject: [PATCH 16/20] MANTISSA_DIGITS: explain relation to bitwise
 representation

---
 library/core/src/num/f128.rs | 3 +++
 library/core/src/num/f16.rs  | 3 +++
 library/core/src/num/f32.rs  | 3 +++
 library/core/src/num/f64.rs  | 3 +++
 4 files changed, 12 insertions(+)

diff --git a/library/core/src/num/f128.rs b/library/core/src/num/f128.rs
index d3d1eebc2275..2ee25969289f 100644
--- a/library/core/src/num/f128.rs
+++ b/library/core/src/num/f128.rs
@@ -145,6 +145,9 @@ impl f128 {
     pub const RADIX: u32 = 2;
 
     /// Number of significant digits in base 2.
+    ///
+    /// Note that the size of the mantissa in the bitwise representation is one
+    /// smaller than this since the leading 1 is not stored explicitly.
     #[unstable(feature = "f128", issue = "116909")]
     pub const MANTISSA_DIGITS: u32 = 113;
 
diff --git a/library/core/src/num/f16.rs b/library/core/src/num/f16.rs
index dceb30177e66..69882d13c177 100644
--- a/library/core/src/num/f16.rs
+++ b/library/core/src/num/f16.rs
@@ -140,6 +140,9 @@ impl f16 {
     pub const RADIX: u32 = 2;
 
     /// Number of significant digits in base 2.
+    ///
+    /// Note that the size of the mantissa in the bitwise representation is one
+    /// smaller than this since the leading 1 is not stored explicitly.
     #[unstable(feature = "f16", issue = "116909")]
     pub const MANTISSA_DIGITS: u32 = 11;
 
diff --git a/library/core/src/num/f32.rs b/library/core/src/num/f32.rs
index c97dbfb63ae1..7e056a6c1f3f 100644
--- a/library/core/src/num/f32.rs
+++ b/library/core/src/num/f32.rs
@@ -390,6 +390,9 @@ impl f32 {
     pub const RADIX: u32 = 2;
 
     /// Number of significant digits in base 2.
+    ///
+    /// Note that the size of the mantissa in the bitwise representation is one
+    /// smaller than this since the leading 1 is not stored explicitly.
     #[stable(feature = "assoc_int_consts", since = "1.43.0")]
     pub const MANTISSA_DIGITS: u32 = 24;
 
diff --git a/library/core/src/num/f64.rs b/library/core/src/num/f64.rs
index 91affdb3794b..b9ebbb1d7649 100644
--- a/library/core/src/num/f64.rs
+++ b/library/core/src/num/f64.rs
@@ -390,6 +390,9 @@ impl f64 {
     pub const RADIX: u32 = 2;
 
     /// Number of significant digits in base 2.
+    ///
+    /// Note that the size of the mantissa in the bitwise representation is one
+    /// smaller than this since the leading 1 is not stored explicitly.
     #[stable(feature = "assoc_int_consts", since = "1.43.0")]
     pub const MANTISSA_DIGITS: u32 = 53;
     /// Approximate number of significant digits in base 10.

From 47a127884135771ae557eca71f964a5db655c2ea Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 22 Apr 2025 11:40:48 +0200
Subject: [PATCH 17/20] add comment for "Other" case

---
 compiler/rustc_const_eval/src/interpret/memory.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/compiler/rustc_const_eval/src/interpret/memory.rs b/compiler/rustc_const_eval/src/interpret/memory.rs
index 3bde7457ad60..9d8130661b04 100644
--- a/compiler/rustc_const_eval/src/interpret/memory.rs
+++ b/compiler/rustc_const_eval/src/interpret/memory.rs
@@ -882,6 +882,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
 
                     Ord::max(global_align, fn_align).unwrap_or(Align::ONE)
                 }
+                // Machine-specific extra functions currently do not support alignment restrictions.
                 FnVal::Other(_) => Align::ONE,
             };
 

From e9d374c6573a413f598c9b52f938a8abd5e041cf Mon Sep 17 00:00:00 2001
From: Amanda Stjerna <amanda.stjerna@it.uu.se>
Date: Thu, 17 Apr 2025 10:36:37 +0200
Subject: [PATCH 18/20] Add tests for two untested cases of placeholder
 relations

During work on #130227, I discovered several situations not covered by any
previously existing UI test. This commit introudces tests to cover that.
---
 tests/ui/borrowck/static-trait-bound-lost.rs  | 54 +++++++++++++++++++
 .../placeholder-outlives-existential.rs       | 31 +++++++++++
 .../placeholder-outlives-existential.stderr   | 25 +++++++++
 3 files changed, 110 insertions(+)
 create mode 100644 tests/ui/borrowck/static-trait-bound-lost.rs
 create mode 100644 tests/ui/nll/relate_tys/placeholder-outlives-existential.rs
 create mode 100644 tests/ui/nll/relate_tys/placeholder-outlives-existential.stderr

diff --git a/tests/ui/borrowck/static-trait-bound-lost.rs b/tests/ui/borrowck/static-trait-bound-lost.rs
new file mode 100644
index 000000000000..0288acea0f60
--- /dev/null
+++ b/tests/ui/borrowck/static-trait-bound-lost.rs
@@ -0,0 +1,54 @@
+// This test is a reduced version of a bug introduced during work on type-tests for Polonius.
+// The underlying problem is that the 'static bound is lost for a type parameter that is
+// threaded deeply enough, causing an error.
+// The bug was first observed in exr-1.4.1/src/image/read/mod.rs:124:5 during perf test.
+
+//@ check-pass
+
+use std::marker::PhantomData;
+
+struct ReadAllLayers<ReadChannels> {
+    px: PhantomData<ReadChannels>,
+}
+
+trait ReadLayers<'s> {}
+
+impl<'s, C> ReadLayers<'s> for ReadAllLayers<C> where C: ReadChannels<'s> {}
+
+fn make_builder<A, Set, Pixels>(
+    _: Set,
+) -> ReadAllLayers<CollectPixels<A, Pixels, Set>>
+where
+    Set: Fn(&mut Pixels),
+{
+    todo!()
+}
+
+struct CollectPixels<Pixel, PixelStorage, SetPixel> {
+    px: PhantomData<(SetPixel, Pixel, PixelStorage)>,
+}
+
+impl<'s, PixelStorage, SetPixel: 's> ReadChannels<'s>
+    for CollectPixels<usize, PixelStorage, SetPixel>
+where
+    SetPixel: Fn(&mut PixelStorage),
+{
+}
+
+trait ReadChannels<'s> {}
+
+fn from_file<L>(_: L)
+where
+    for<'s> L: ReadLayers<'s>,
+{
+}
+
+pub fn read_all_rgba_layers_from_file<Set: 'static, Pixels: 'static>(
+    set_pixel: Set,
+) where
+    Set: Fn(&mut Pixels),
+{
+    from_file(make_builder(set_pixel)); // Error triggered.
+}
+
+pub fn main() {}
diff --git a/tests/ui/nll/relate_tys/placeholder-outlives-existential.rs b/tests/ui/nll/relate_tys/placeholder-outlives-existential.rs
new file mode 100644
index 000000000000..3f22e9a313af
--- /dev/null
+++ b/tests/ui/nll/relate_tys/placeholder-outlives-existential.rs
@@ -0,0 +1,31 @@
+// Test that we correctly handle some cases of placeholder leaks.
+//
+//@ compile-flags:-Zno-leak-check
+
+
+struct Co<'a>(&'a ());
+struct Inv<'a>(*mut &'a ());
+struct Contra<'a>(fn(&'a ()));
+
+// `exists<'e> forall<'p> 'p: 'e` -> ERROR
+fn p_outlives_e(
+    x: for<'e> fn(for<'p> fn(fn(fn(Contra<'e>, Co<'p>)))),
+) -> fn(fn(fn(for<'unify> fn(Contra<'unify>, Co<'unify>)))) {
+    x //~ ERROR mismatched types [E0308]
+}
+
+// `exists<'e> forall<'p> 'e: 'p` -> Ok, 'e: 'static
+fn e_outlives_p_static(
+    x: for<'e> fn(Inv<'e>, for<'p> fn(fn(fn(Contra<'p>, Co<'e>)))),
+) -> fn(Inv<'static>, fn(fn(for<'unify> fn(Contra<'unify>, Co<'unify>)))) {
+    x
+}
+
+// `exists<'e> forall<'p> 'e: 'p` -> Ok, 'e: 'static -> ERROR
+fn e_outlives_p_static_err<'not_static>(
+    x: for<'e> fn(Inv<'e>, for<'p> fn(fn(fn(Contra<'p>, Co<'e>)))),
+) -> fn(Inv<'not_static>, fn(fn(for<'unify> fn(Contra<'unify>, Co<'unify>)))) {
+    x //~ ERROR lifetime may not live long enough
+}
+
+fn main() {}
diff --git a/tests/ui/nll/relate_tys/placeholder-outlives-existential.stderr b/tests/ui/nll/relate_tys/placeholder-outlives-existential.stderr
new file mode 100644
index 000000000000..80ab5c8d6e9d
--- /dev/null
+++ b/tests/ui/nll/relate_tys/placeholder-outlives-existential.stderr
@@ -0,0 +1,25 @@
+error[E0308]: mismatched types
+  --> $DIR/placeholder-outlives-existential.rs:14:5
+   |
+LL |     x
+   |     ^ one type is more general than the other
+   |
+   = note: expected fn pointer `fn(fn(fn(for<'unify> fn(Contra<'unify>, Co<'unify>))))`
+              found fn pointer `for<'e> fn(for<'e, 'p> fn(for<'e, 'p> fn(for<'e, 'p> fn(Contra<'e>, Co<'p>))))`
+
+error: lifetime may not live long enough
+  --> $DIR/placeholder-outlives-existential.rs:28:5
+   |
+LL | fn e_outlives_p_static_err<'not_static>(
+   |                            ----------- lifetime `'not_static` defined here
+...
+LL |     x
+   |     ^ returning this value requires that `'not_static` must outlive `'static`
+   |
+   = note: requirement occurs because of the type `Inv<'_>`, which makes the generic argument `'_` invariant
+   = note: the struct `Inv<'a>` is invariant over the parameter `'a`
+   = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0308`.

From f7b1e035a86e0c4ebcfda81e1651e25004094e50 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sat, 19 Apr 2025 15:46:08 +1000
Subject: [PATCH 19/20] compiletest: Fix deadline bugs in new executor

---
 src/tools/compiletest/src/executor.rs         |  8 ++-
 .../compiletest/src/executor/deadline.rs      | 60 +++++++++++++------
 2 files changed, 47 insertions(+), 21 deletions(-)

diff --git a/src/tools/compiletest/src/executor.rs b/src/tools/compiletest/src/executor.rs
index 0c173d476aff..990be56ce0c5 100644
--- a/src/tools/compiletest/src/executor.rs
+++ b/src/tools/compiletest/src/executor.rs
@@ -57,9 +57,11 @@ pub(crate) fn run_tests(config: &Config, tests: Vec<CollectedTest>) -> bool {
         }
 
         let completion = deadline_queue
-            .read_channel_while_checking_deadlines(&completion_rx, |_id, test| {
-                listener.test_timed_out(test);
-            })
+            .read_channel_while_checking_deadlines(
+                &completion_rx,
+                |id| running_tests.contains_key(&id),
+                |_id, test| listener.test_timed_out(test),
+            )
             .expect("receive channel should never be closed early");
 
         let RunningTest { test, join_handle } = running_tests.remove(&completion.id).unwrap();
diff --git a/src/tools/compiletest/src/executor/deadline.rs b/src/tools/compiletest/src/executor/deadline.rs
index 83b8591a4164..3536eff2fd80 100644
--- a/src/tools/compiletest/src/executor/deadline.rs
+++ b/src/tools/compiletest/src/executor/deadline.rs
@@ -21,16 +21,26 @@ impl<'a> DeadlineQueue<'a> {
         Self { queue: VecDeque::with_capacity(capacity) }
     }
 
+    /// All calls to [`Instant::now`] go through this wrapper method.
+    /// This makes it easier to find all places that read the current time.
+    fn now(&self) -> Instant {
+        Instant::now()
+    }
+
     pub(crate) fn push(&mut self, id: TestId, test: &'a CollectedTest) {
-        let deadline = Instant::now() + Duration::from_secs(TEST_WARN_TIMEOUT_S);
+        let deadline = self.now() + Duration::from_secs(TEST_WARN_TIMEOUT_S);
+        if let Some(back) = self.queue.back() {
+            assert!(back.deadline <= deadline);
+        }
         self.queue.push_back(DeadlineEntry { id, test, deadline });
     }
 
-    /// Equivalent to `rx.read()`, except that if any test exceeds its deadline
+    /// Equivalent to `rx.recv()`, except that if a test exceeds its deadline
     /// during the wait, the given callback will also be called for that test.
     pub(crate) fn read_channel_while_checking_deadlines<T>(
         &mut self,
         rx: &mpsc::Receiver<T>,
+        is_running: impl Fn(TestId) -> bool,
         mut on_deadline_passed: impl FnMut(TestId, &CollectedTest),
     ) -> Result<T, RecvError> {
         loop {
@@ -39,18 +49,18 @@ impl<'a> DeadlineQueue<'a> {
                 // deadline, so do a normal receive.
                 return rx.recv();
             };
-            let wait_duration = next_deadline.saturating_duration_since(Instant::now());
+            let next_deadline_timeout = next_deadline.saturating_duration_since(self.now());
+
+            let recv_result = rx.recv_timeout(next_deadline_timeout);
+            // Process deadlines after every receive attempt, regardless of
+            // outcome, so that we don't build up an unbounded backlog of stale
+            // entries due to a constant stream of tests finishing.
+            self.for_each_entry_past_deadline(&is_running, &mut on_deadline_passed);
 
-            let recv_result = rx.recv_timeout(wait_duration);
             match recv_result {
                 Ok(value) => return Ok(value),
-                Err(RecvTimeoutError::Timeout) => {
-                    // Notify the callback of tests that have exceeded their
-                    // deadline, then loop and do annother channel read.
-                    for DeadlineEntry { id, test, .. } in self.remove_tests_past_deadline() {
-                        on_deadline_passed(id, test);
-                    }
-                }
+                // Deadlines have already been processed, so loop and do another receive.
+                Err(RecvTimeoutError::Timeout) => {}
                 Err(RecvTimeoutError::Disconnected) => return Err(RecvError),
             }
         }
@@ -60,14 +70,28 @@ impl<'a> DeadlineQueue<'a> {
         Some(self.queue.front()?.deadline)
     }
 
-    fn remove_tests_past_deadline(&mut self) -> Vec<DeadlineEntry<'a>> {
-        let now = Instant::now();
-        let mut timed_out = vec![];
-        while let Some(deadline_entry) = pop_front_if(&mut self.queue, |entry| now < entry.deadline)
-        {
-            timed_out.push(deadline_entry);
+    fn for_each_entry_past_deadline(
+        &mut self,
+        is_running: impl Fn(TestId) -> bool,
+        mut on_deadline_passed: impl FnMut(TestId, &CollectedTest),
+    ) {
+        let now = self.now();
+
+        // Clear out entries that are past their deadline, but only invoke the
+        // callback for tests that are still considered running.
+        while let Some(entry) = pop_front_if(&mut self.queue, |entry| entry.deadline <= now) {
+            if is_running(entry.id) {
+                on_deadline_passed(entry.id, entry.test);
+            }
+        }
+
+        // Also clear out any leading entries that are no longer running, even
+        // if their deadline hasn't been reached.
+        while let Some(_) = pop_front_if(&mut self.queue, |entry| !is_running(entry.id)) {}
+
+        if let Some(front) = self.queue.front() {
+            assert!(now < front.deadline);
         }
-        timed_out
     }
 }
 

From fdf2c47f83fd4eead8b4d39a8a712bf7d5e68fc6 Mon Sep 17 00:00:00 2001
From: Amy Kwan <amy.kwan1@ibm.com>
Date: Tue, 22 Apr 2025 22:55:19 -0400
Subject: [PATCH 20/20] [AIX] Handle AIX dynamic library extensions within
 c-link-to-rust-dylib run-make test

Dynamic libraries on AIX have the ".a" extension. The c-link-to-rust-dylib
run-make test checks for the extension explicitly, so the extension for AIX
is also added to accommodate the test case on AIX.
---
 tests/run-make/c-link-to-rust-dylib/rmake.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/tests/run-make/c-link-to-rust-dylib/rmake.rs b/tests/run-make/c-link-to-rust-dylib/rmake.rs
index ab9aa445402b..3a48af8a3665 100644
--- a/tests/run-make/c-link-to-rust-dylib/rmake.rs
+++ b/tests/run-make/c-link-to-rust-dylib/rmake.rs
@@ -23,7 +23,11 @@ fn main() {
         if path.is_file()
             && path.extension().is_some_and(|ext| ext == expected_extension)
             && path.file_name().and_then(|name| name.to_str()).is_some_and(|name| {
-                name.ends_with(".so") || name.ends_with(".dll") || name.ends_with(".dylib")
+                if cfg!(target_os = "aix") {
+                    name.ends_with(".a")
+                } else {
+                    name.ends_with(".so") || name.ends_with(".dll") || name.ends_with(".dylib")
+                }
             })
         {
             rfs::remove_file(path);