diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 3e373c42eca34..9ecf5afcbcb35 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -2350,6 +2350,7 @@ unsafe extern "C" {
     pub(crate) fn LLVMRustWriteValueToString(value_ref: &Value, s: &RustString);
 
     pub(crate) fn LLVMRustHasFeature(T: &TargetMachine, s: *const c_char) -> bool;
+    pub(crate) fn LLVMRustTargetHasMnemonic(T: &TargetMachine, s: *const c_char) -> bool;
 
     pub(crate) fn LLVMRustPrintTargetCPUs(TM: &TargetMachine, OutStr: &RustString);
     pub(crate) fn LLVMRustGetTargetFeaturesCount(T: &TargetMachine) -> size_t;
diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs
index 180559d28d848..e9983d11c127f 100644
--- a/compiler/rustc_codegen_llvm/src/llvm_util.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm_util.rs
@@ -480,6 +480,10 @@ pub(crate) fn print(req: &PrintRequest, out: &mut String, sess: &Session) {
     match req.kind {
         PrintKind::TargetCPUs => print_target_cpus(sess, tm.raw(), out),
         PrintKind::TargetFeatures => print_target_features(sess, tm.raw(), out),
+        PrintKind::BackendHasMnemonic => {
+            let mnemonic = req.arg.as_deref().expect("BackendHasMnemonic requires arg");
+            print_target_has_mnemonic(tm.raw(), mnemonic, out)
+        }
         _ => bug!("rustc_codegen_llvm can't handle print request: {:?}", req),
     }
 }
@@ -738,3 +742,10 @@ pub(crate) fn tune_cpu(sess: &Session) -> Option<&str> {
     let name = sess.opts.unstable_opts.tune_cpu.as_ref()?;
     Some(handle_native(name))
 }
+
+fn print_target_has_mnemonic(tm: &llvm::TargetMachine, mnemonic: &str, out: &mut String) {
+    use std::fmt::Write;
+    let cstr = SmallCStr::new(mnemonic);
+    let has_mnemonic = unsafe { llvm::LLVMRustTargetHasMnemonic(tm, cstr.as_ptr()) };
+    writeln!(out, "{}", has_mnemonic).unwrap();
+}
diff --git a/compiler/rustc_driver_impl/src/lib.rs b/compiler/rustc_driver_impl/src/lib.rs
index c15c3c229398c..b05f5bc4a8e20 100644
--- a/compiler/rustc_driver_impl/src/lib.rs
+++ b/compiler/rustc_driver_impl/src/lib.rs
@@ -804,6 +804,9 @@ fn print_crate_info(
                 let calling_conventions = rustc_abi::all_names();
                 println_info!("{}", calling_conventions.join("\n"));
             }
+            BackendHasMnemonic => {
+                codegen_backend.print(req, &mut crate_info, sess);
+            }
             BackendHasZstd => {
                 let has_zstd: bool = codegen_backend.has_zstd();
                 println_info!("{has_zstd}");
diff --git a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
index 726f05e36ac9f..c7e8f99465e18 100644
--- a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
@@ -19,6 +19,7 @@
 #include "llvm/IR/Verifier.h"
 #include "llvm/IRPrinter/IRPrintingPasses.h"
 #include "llvm/LTO/LTO.h"
+#include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Object/ObjectFile.h"
@@ -94,6 +95,25 @@ extern "C" bool LLVMRustHasFeature(LLVMTargetMachineRef TM,
   return MCInfo->checkFeatures(std::string("+") + Feature);
 }
 
+/// Check whether the target has a specific assembly mnemonic like `ret` or
+/// `nop`.
+/// This should be fast enough but if its not we have to look into another
+/// method of checking.
+extern "C" bool LLVMRustTargetHasMnemonic(LLVMTargetMachineRef TM,
+                                          const char *Mnemonic) {
+  TargetMachine *Target = unwrap(TM);
+  const MCInstrInfo *MII = Target->getMCInstrInfo();
+  StringRef MnemonicRef(Mnemonic);
+
+  for (unsigned i = 0; i < MII->getNumOpcodes(); i++) {
+    StringRef Name = MII->getName(i);
+    if (Name.equals_insensitive(MnemonicRef)) {
+      return true;
+    }
+  }
+  return false;
+}
+
 enum class LLVMRustCodeModel {
   Tiny,
   Small,
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 60237c98fed2c..e1ef06ca7c713 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -1416,12 +1416,12 @@ impl<'tcx> TyCtxt<'tcx> {
         self,
         stable_crate_id: StableCrateId,
     ) -> Result<TyCtxtFeed<'tcx, CrateNum>, CrateNum> {
-        if let Some(&existing) = self.untracked().stable_crate_ids.read().get(&stable_crate_id) {
+        let mut lock = self.untracked().stable_crate_ids.write();
+        if let Some(&existing) = lock.get(&stable_crate_id) {
             return Err(existing);
         }
-
-        let num = CrateNum::new(self.untracked().stable_crate_ids.read().len());
-        self.untracked().stable_crate_ids.write().insert(stable_crate_id, num);
+        let num = CrateNum::new(lock.len());
+        lock.insert(stable_crate_id, num);
         Ok(TyCtxtFeed { key: num, tcx: self })
     }
 
diff --git a/compiler/rustc_mir_build/src/errors.rs b/compiler/rustc_mir_build/src/errors.rs
index 857a4056bae87..6199e3766604d 100644
--- a/compiler/rustc_mir_build/src/errors.rs
+++ b/compiler/rustc_mir_build/src/errors.rs
@@ -924,22 +924,24 @@ pub(crate) struct IrrefutableLetPatternsIfLetGuard {
 }
 
 #[derive(Diagnostic)]
-#[diag(
-    "irrefutable `let...else` {$count ->
-    [one] pattern
-    *[other] patterns
-}"
-)]
-#[note(
-    "{$count ->
-    [one] this pattern always matches, so the else clause is unreachable
-    *[other] these patterns always match, so the else clause is unreachable
-}"
-)]
+#[diag("unreachable `else` clause")]
+#[note("this pattern always matches, so the else clause is unreachable")]
 pub(crate) struct IrrefutableLetPatternsLetElse {
-    pub(crate) count: usize,
-    #[help("remove this `else` block")]
-    pub(crate) else_span: Option<Span>,
+    #[subdiagnostic]
+    pub(crate) be_replaced: Option<LetElseReplacementSuggestion>,
+}
+
+#[derive(Subdiagnostic, Debug)]
+#[suggestion(
+    "consider using `let {$lhs} = {$rhs}` to match on a specific variant",
+    code = "let {lhs} = {rhs}",
+    applicability = "machine-applicable"
+)]
+pub(crate) struct LetElseReplacementSuggestion {
+    #[primary_span]
+    pub(crate) span: Span,
+    pub(crate) lhs: String,
+    pub(crate) rhs: String,
 }
 
 #[derive(Diagnostic)]
diff --git a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
index 8a34320990e19..4dc3e02ace71a 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -168,7 +168,7 @@ impl<'p, 'tcx> Visitor<'p, 'tcx> for MatchVisitor<'p, 'tcx> {
                 let Ok(()) = self.visit_land(ex, &mut chain_refutabilities) else { return };
                 // Lint only single irrefutable let binding.
                 if let [Some((_, Irrefutable))] = chain_refutabilities[..] {
-                    self.lint_single_let(ex.span, None);
+                    self.lint_single_let(ex.span, None, None);
                 }
                 return;
             }
@@ -438,7 +438,45 @@ impl<'p, 'tcx> MatchVisitor<'p, 'tcx> {
         if let LetSource::PlainLet = self.let_source {
             self.check_binding_is_irrefutable(pat, "local binding", scrut, Some(span));
         } else if let Ok(Irrefutable) = self.is_let_irrefutable(pat, scrut) {
-            self.lint_single_let(span, else_span);
+            if span.from_expansion() {
+                self.lint_single_let(span, None, None);
+                return;
+            }
+            let let_else_span = self.check_irrefutable_option_some(pat, scrut, span);
+
+            let sm = self.tcx.sess.source_map();
+            let next_token_start = sm.span_extend_while_whitespace(span.clone()).hi();
+            let line_span = sm.span_extend_to_line(span.clone()).with_lo(next_token_start);
+            let else_keyword_span = sm.span_until_whitespace(line_span);
+            self.lint_single_let(span, Some(else_keyword_span), let_else_span);
+        }
+    }
+
+    /// Check case `let x = Some(y);`, user likely intended to destructure `Option`
+    fn check_irrefutable_option_some(
+        &self,
+        pat: &'p Pat<'tcx>,
+        initializer: Option<&Expr<'tcx>>,
+        span: Span,
+    ) -> Option<LetElseReplacementSuggestion> {
+        if let sm = self.tcx.sess.source_map()
+            && let Some(initializer) = initializer
+            && let Some(s_ty) = initializer.ty.ty_adt_def()
+            && self.tcx.is_diagnostic_item(rustc_span::sym::Option, s_ty.did())
+            && let ExprKind::Scope { value, .. } = initializer.kind
+            && let initializer_expr = &self.thir[value]
+            && let ExprKind::Adt(box AdtExpr { fields, .. }) = &initializer_expr.kind
+            && let Some(field) = fields.first()
+            && let inner = &self.thir[field.expr]
+            && let Some(inner_ty) = inner.ty.ty_adt_def()
+            && self.tcx.is_diagnostic_item(rustc_span::sym::Option, inner_ty.did())
+            && let Ok(rhs) = sm.span_to_snippet(inner.span)
+            && let Ok(lhs) = sm.span_to_snippet(pat.span)
+        {
+            let lhs = format!("Some({})", lhs);
+            Some(LetElseReplacementSuggestion { span, lhs, rhs })
+        } else {
+            None
         }
     }
 
@@ -559,14 +597,20 @@ impl<'p, 'tcx> MatchVisitor<'p, 'tcx> {
     }
 
     #[instrument(level = "trace", skip(self))]
-    fn lint_single_let(&mut self, let_span: Span, else_span: Option<Span>) {
+    fn lint_single_let(
+        &mut self,
+        let_span: Span,
+        else_keyword_span: Option<Span>,
+        let_else_span: Option<LetElseReplacementSuggestion>,
+    ) {
         report_irrefutable_let_patterns(
             self.tcx,
             self.hir_source,
             self.let_source,
             1,
             let_span,
-            else_span,
+            else_keyword_span,
+            let_else_span,
         );
     }
 
@@ -862,7 +906,8 @@ fn report_irrefutable_let_patterns(
     source: LetSource,
     count: usize,
     span: Span,
-    else_span: Option<Span>,
+    else_keyword_span: Option<Span>,
+    let_else_span: Option<LetElseReplacementSuggestion>,
 ) {
     macro_rules! emit_diag {
         ($lint:tt) => {{
@@ -875,11 +920,23 @@ fn report_irrefutable_let_patterns(
         LetSource::IfLet | LetSource::ElseIfLet => emit_diag!(IrrefutableLetPatternsIfLet),
         LetSource::IfLetGuard => emit_diag!(IrrefutableLetPatternsIfLetGuard),
         LetSource::LetElse => {
+            let spans = match else_keyword_span {
+                Some(else_keyword_span) => {
+                    let mut spans = MultiSpan::from_span(else_keyword_span);
+                    spans.push_span_label(
+                        span,
+                        msg!("assigning to binding pattern will always succeed"),
+                    );
+                    spans
+                }
+                None => span.into(),
+            };
+
             tcx.emit_node_span_lint(
                 IRREFUTABLE_LET_PATTERNS,
                 id,
-                span,
-                IrrefutableLetPatternsLetElse { count, else_span },
+                spans,
+                IrrefutableLetPatternsLetElse { be_replaced: let_else_span },
             );
         }
         LetSource::WhileLet => emit_diag!(IrrefutableLetPatternsWhileLet),
diff --git a/compiler/rustc_session/src/config/print_request.rs b/compiler/rustc_session/src/config/print_request.rs
index b87236cef7646..65e25ab5e6006 100644
--- a/compiler/rustc_session/src/config/print_request.rs
+++ b/compiler/rustc_session/src/config/print_request.rs
@@ -15,6 +15,7 @@ use crate::macros::AllVariants;
 pub struct PrintRequest {
     pub kind: PrintKind,
     pub out: OutFileName,
+    pub arg: Option<String>,
 }
 
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
@@ -22,6 +23,7 @@ pub struct PrintRequest {
 pub enum PrintKind {
     // tidy-alphabetical-start
     AllTargetSpecsJson,
+    BackendHasMnemonic,
     BackendHasZstd,
     CallingConventions,
     Cfg,
@@ -55,6 +57,7 @@ impl PrintKind {
         match self {
             // tidy-alphabetical-start
             AllTargetSpecsJson => "all-target-specs-json",
+            BackendHasMnemonic => "backend-has-mnemonic",
             BackendHasZstd => "backend-has-zstd",
             CallingConventions => "calling-conventions",
             Cfg => "cfg",
@@ -108,7 +111,8 @@ impl PrintKind {
 
             // Unstable values:
             AllTargetSpecsJson => false,
-            BackendHasZstd => false, // (perma-unstable, for use by compiletest)
+            BackendHasMnemonic => false, // (perma-unstable, for use by compiletest)
+            BackendHasZstd => false,     // (perma-unstable, for use by compiletest)
             CheckCfg => false,
             CrateRootLintLevels => false,
             SupportedCrateTypes => false,
@@ -145,11 +149,19 @@ pub(crate) fn collect_print_requests(
 ) -> Vec<PrintRequest> {
     let mut prints = Vec::<PrintRequest>::new();
     if cg.target_cpu.as_deref() == Some("help") {
-        prints.push(PrintRequest { kind: PrintKind::TargetCPUs, out: OutFileName::Stdout });
+        prints.push(PrintRequest {
+            kind: PrintKind::TargetCPUs,
+            out: OutFileName::Stdout,
+            arg: None,
+        });
         cg.target_cpu = None;
     };
     if cg.target_feature == "help" {
-        prints.push(PrintRequest { kind: PrintKind::TargetFeatures, out: OutFileName::Stdout });
+        prints.push(PrintRequest {
+            kind: PrintKind::TargetFeatures,
+            out: OutFileName::Stdout,
+            arg: None,
+        });
         cg.target_feature = String::new();
     }
 
@@ -162,9 +174,22 @@ pub(crate) fn collect_print_requests(
     prints.extend(matches.opt_strs("print").into_iter().map(|req| {
         let (req, out) = split_out_file_name(&req);
 
-        let kind = if let Some(print_kind) = PrintKind::from_str(req) {
+        let (kind, arg) = if let Some(mnemonic) = req.strip_prefix("backend-has-mnemonic") {
+            check_print_request_stability(early_dcx, unstable_opts, PrintKind::BackendHasMnemonic);
+            // BackendHasMnemonic requires a mnemonic argument
+            if let Some(mnemonic) = mnemonic.strip_prefix(':')
+                && !mnemonic.is_empty()
+            {
+                (PrintKind::BackendHasMnemonic, Some(mnemonic.to_string()))
+            } else {
+                early_dcx.early_fatal(
+                    "expected mnemonic name after `--print=backend-has-mnemonic:`, \
+                    for example: `--print=backend-has-mnemonic:RET`",
+                );
+            }
+        } else if let Some(print_kind) = PrintKind::from_str(req) {
             check_print_request_stability(early_dcx, unstable_opts, print_kind);
-            print_kind
+            (print_kind, None)
         } else {
             let is_nightly = nightly_options::match_is_nightly_build(matches);
             emit_unknown_print_request_help(early_dcx, req, is_nightly)
@@ -180,7 +205,7 @@ pub(crate) fn collect_print_requests(
             }
         }
 
-        PrintRequest { kind, out }
+        PrintRequest { kind, out, arg }
     }));
 
     prints
diff --git a/compiler/rustc_trait_selection/src/traits/effects.rs b/compiler/rustc_trait_selection/src/traits/effects.rs
index f0587b8e4e23e..0f36edcdd830e 100644
--- a/compiler/rustc_trait_selection/src/traits/effects.rs
+++ b/compiler/rustc_trait_selection/src/traits/effects.rs
@@ -554,11 +554,7 @@ fn evaluate_host_effect_for_fn_goal<'tcx>(
         // but they don't really need to right now.
         ty::CoroutineClosure(_, _) => return Err(EvaluationFailure::NoSolution),
 
-        ty::Closure(def, args) => {
-            // For now we limit ourselves to closures without binders. The next solver can handle them.
-            args.as_closure().sig().no_bound_vars().ok_or(EvaluationFailure::NoSolution)?;
-            (def, args)
-        }
+        ty::Closure(def, args) => (def, args),
 
         // Everything else needs explicit impls or cannot have an impl
         _ => return Err(EvaluationFailure::NoSolution),
diff --git a/src/doc/rustc-dev-guide/src/tests/compiletest.md b/src/doc/rustc-dev-guide/src/tests/compiletest.md
index 4c534e9ae0eda..53a6c0cb5737d 100644
--- a/src/doc/rustc-dev-guide/src/tests/compiletest.md
+++ b/src/doc/rustc-dev-guide/src/tests/compiletest.md
@@ -346,6 +346,17 @@ See also the [codegen tests](#codegen-tests) for a similar set of tests.
 If you need to work with `#![no_std]` cross-compiling tests, consult the
 [`minicore` test auxiliary](./minicore.md) chapter.
 
+#### Conditional assembly tests based on instruction support
+
+Tests that depend on specific assembly instructions being available can use the
+`//@ needs-asm-mnemonic: <MNEMONIC>` directive. This will skip the test if the
+target backend does not support the specified instruction mnemonic.
+
+For example, a test that requires the `RET` instruction:
+```rust,ignore
+//@ needs-asm-mnemonic: RET
+```
+
 [`tests/assembly-llvm`]: https://github.com/rust-lang/rust/tree/HEAD/tests/assembly-llvm
 
 
diff --git a/src/doc/rustc-dev-guide/src/tests/directives.md b/src/doc/rustc-dev-guide/src/tests/directives.md
index 38450d991d05a..caa400b573135 100644
--- a/src/doc/rustc-dev-guide/src/tests/directives.md
+++ b/src/doc/rustc-dev-guide/src/tests/directives.md
@@ -163,6 +163,9 @@ The following directives will check rustc build settings and target settings:
   For tests that cross-compile to explicit targets
   via `--target`, use `needs-llvm-components` instead to ensure the appropriate
   backend is available.
+- `needs-asm-mnemonic: <MNEMONIC>` — ignores if the target backend does not
+  support the specified assembly mnemonic (e.g., `RET`, `NOP`).
+  Only supported with the LLVM backend.
 - `needs-profiler-runtime` — ignores the test if the profiler runtime was not
   enabled for the target (`build.profiler = true` in `bootstrap.toml`)
 - `needs-sanitizer-support` — ignores if the sanitizer support was not enabled
diff --git a/src/doc/rustc/src/platform-support/wasm32-wali-linux.md b/src/doc/rustc/src/platform-support/wasm32-wali-linux.md
index 001159b0d3266..c87cc1d5f863d 100644
--- a/src/doc/rustc/src/platform-support/wasm32-wali-linux.md
+++ b/src/doc/rustc/src/platform-support/wasm32-wali-linux.md
@@ -15,7 +15,7 @@ From the wider Wasm ecosystem perspective, implementing WALI within engines allo
 ## Requirements
 
 ### Compilation
-This target is cross-compiled and requires an installation of the [WALI compiler/sysroot](https://github.com/arjunr2/WALI). This produces standard `wasm32` binaries with the WALI interface methods as module imports that need to be implemented by a supported engine (see the  "Execution" section below).
+This target is cross-compiled and requires an installation of the [WALI sysroot](https://github.com/Wasm-Thin-Kernel-Interfaces/WALI.git). This produces standard `wasm32` binaries with the WALI interface methods as module imports that need to be implemented by a supported engine (see the  "Execution" section below).
 
 `wali` targets *minimally require* the following LLVM feature flags:
 
@@ -31,7 +31,7 @@ This target is cross-compiled and requires an installation of the [WALI compiler
 > **Note**: Users can expect that new enabled-by-default Wasm features for LLVM are transitively incorporatable into this target -- see [wasm32-unknown-unknown](wasm32-unknown-unknown.md) for detailed information on WebAssembly features.
 
 
-> **Note**: The WALI ABI is similar to default Clang wasm32 ABIs but *not identical*. The primary difference is 64-bit `long` types as opposed to 32-bit for wasm32. This is required to maintain minimum source code changes for 64-bit host platforms currently supported. This may change in the future as the spec evolves.
+> **Note**: The WALI ABI is *not identical* to the `wasm32-wasip2` or `wasm32-unknown-unknown` ABI. The primary difference is 64-bit `long` types as opposed to 32-bit for wasm32. This is required to maximize portability with minimum source code changes for currently supported 64-bit host platforms. These ABIs may converge in the future as the spec evolves.
 
 ### Execution
 Running generated WALI binaries also requires a supported compliant engine implementation -- a working implementation in the [WebAssembly Micro-Runtime (WAMR)](https://github.com/arjunr2/WALI) is included in the repo.
@@ -41,38 +41,28 @@ Running generated WALI binaries also requires a supported compliant engine imple
 ## Building the target
 
 You can build Rust with support for the target by adding it to the `target`
-list in `config.toml`, and pointing to the toolchain artifacts from the previous section ("Requirements->Compilation"). A sample `config.toml` for the `musl` environment will look like this, where `<WALI-root>` is the absolute path to the root directory of the [WALI repo](https://github.com/arjunr2/WALI):
+list in `bootstrap.toml`, and pointing to the toolchain artifacts from the previous section ("Requirements->Compilation"). A sample `bootstrap.toml` for the `musl` environment will look like this, where `<WALI-root>` is the absolute path to the root directory of the [WALI repo](https://github.com/arjunr2/WALI):
 
 ```toml
 [build]
 target = ["wasm32-wali-linux-musl"]
 
 [target.wasm32-wali-linux-musl]
-musl-root = "<WALI>/wali-musl/sysroot"
-llvm-config = "<WALI>/llvm-project/build/bin/llvm-config"
-cc = "<WALI>/llvm-project/build/bin/clang-18"
-cxx = "<WALI>/llvm-project/build/bin/clang-18"
-ar = "<WALI>/llvm-project/build/bin/llvm-ar"
-ranlib = "<WALI>/llvm-project/build/bin/llvm-ranlib"
+musl-root = "<WALI>/build/sysroot"
+cc = "<WALI>/build/llvm/bin/clang"
+cxx = "<WALI>/build/llvm/bin/clang++"
+ar = "<WALI>/build/llvm/bin/llvm-ar"
+ranlib = "<WALI>/build/llvm/bin/llvm-ranlib"
 llvm-libunwind = "system"
 crt-static = true
 ```
 
-> The `llvm-config` settings are only temporary, and the changes will eventually be upstreamed into LLVM
-
 ## Building Rust programs
 
 Rust does not yet ship pre-compiled artifacts for this target. To compile for
 this target, you will either need to build Rust with the target enabled (see
 "Building the target" above), or build your own copy of `core` by using
-`build-std` or similar.
-
-Rust program builds can use this target normally. Currently, linking WALI programs may require pointing the `linker` to the llvm build in the [Cargo config](https://doc.rust-lang.org/cargo/reference/config.html) (until LLVM is upstreamed). A `config.toml` for Cargo will look like the following:
-
-```toml
-[target.wasm32-wali-linux-musl]
-linker = "<WALI>/llvm-project/build/bin/lld"
-```
+`build-std` or similar (with the appropriate sysroot links).
 
 Note that the following `cfg` directives are set for `wasm32-wali-linux-*`:
 
diff --git a/src/tools/compiletest/src/directives/directive_names.rs b/src/tools/compiletest/src/directives/directive_names.rs
index 0d06f6e75af7c..5ef0335b24e58 100644
--- a/src/tools/compiletest/src/directives/directive_names.rs
+++ b/src/tools/compiletest/src/directives/directive_names.rs
@@ -156,6 +156,7 @@ pub(crate) const KNOWN_DIRECTIVE_NAMES: &[&str] = &[
     "min-llvm-version",
     "min-system-llvm-version",
     "minicore-compile-flags",
+    "needs-asm-mnemonic",
     "needs-asm-support",
     "needs-backends",
     "needs-crate-type",
diff --git a/src/tools/compiletest/src/directives/needs.rs b/src/tools/compiletest/src/directives/needs.rs
index e9f3d6c28d6ef..88ca347edd0a5 100644
--- a/src/tools/compiletest/src/directives/needs.rs
+++ b/src/tools/compiletest/src/directives/needs.rs
@@ -290,6 +290,37 @@ pub(super) fn handle_needs(
         }
     }
 
+    if name == "needs-asm-mnemonic" {
+        let Some(rest) = ln.value_after_colon() else {
+            return IgnoreDecision::Error {
+                message: "expected `needs-asm-mnemonic` to have a mnemonic name after colon"
+                    .to_string(),
+            };
+        };
+
+        if !config.default_codegen_backend.is_llvm() {
+            return IgnoreDecision::Ignore {
+                reason: "skipping test as non-LLVM backend does not support mnemonic queries"
+                    .to_string(),
+            };
+        }
+
+        let mnemonic = rest.trim();
+        let has_mnemonic = match mnemonic {
+            "ret" => cache.has_ret_mnemonic,
+            "nop" => cache.has_nop_mnemonic,
+            _ => has_mnemonic(config, mnemonic),
+        };
+
+        if has_mnemonic {
+            return IgnoreDecision::Continue;
+        } else {
+            return IgnoreDecision::Ignore {
+                reason: format!("skipping test as target does not have `{mnemonic}` mnemonic"),
+            };
+        }
+    }
+
     if !name.starts_with("needs-") {
         return IgnoreDecision::Continue;
     }
@@ -352,6 +383,10 @@ pub(super) struct CachedNeedsConditions {
     symlinks: bool,
     /// Whether LLVM built with zstd, for the `needs-llvm-zstd` directive.
     llvm_zstd: bool,
+    /// Might add particular other mnemonics heavily needed by tests here.
+    /// Otherwise call into llvm for every check
+    has_ret_mnemonic: bool,
+    has_nop_mnemonic: bool,
 }
 
 impl CachedNeedsConditions {
@@ -399,6 +434,8 @@ impl CachedNeedsConditions {
             llvm_zstd: llvm_has_zstd(&config),
             dlltool: find_dlltool(&config),
             symlinks: has_symlinks(),
+            has_ret_mnemonic: has_mnemonic(config, "ret"),
+            has_nop_mnemonic: has_mnemonic(config, "nop"),
         }
     }
 }
@@ -466,3 +503,26 @@ fn llvm_has_zstd(config: &Config) -> bool {
         _ => panic!("unexpected output from `--print=backend-has-zstd`: {output:?}"),
     }
 }
+
+fn has_mnemonic(config: &Config, mnemonic: &str) -> bool {
+    if !config.default_codegen_backend.is_llvm() {
+        return false;
+    }
+
+    let target_flag = format!("--target={}", config.target);
+    let output = query_rustc_output(
+        config,
+        &[
+            &target_flag,
+            "-Zunstable-options",
+            &format!("--print=backend-has-mnemonic:{}", mnemonic),
+        ],
+        Default::default(),
+    );
+
+    match output.trim() {
+        "true" => true,
+        "false" => false,
+        _ => panic!("unexpected output from `--print=backend-has-mnemonic:{mnemonic}`: {output:?}"),
+    }
+}
diff --git a/src/tools/compiletest/src/directives/tests.rs b/src/tools/compiletest/src/directives/tests.rs
index 4cd75fcfa511a..56d52982a8211 100644
--- a/src/tools/compiletest/src/directives/tests.rs
+++ b/src/tools/compiletest/src/directives/tests.rs
@@ -1254,3 +1254,25 @@ fn test_edition_range_edition_to_test() {
     assert_edition_to_test(2018, range, Some(e2024));
     assert_edition_to_test(2018, range, Some(efuture));
 }
+
+#[test]
+fn needs_asm_mnemonic() {
+    let config_x86_64 = cfg().target("x86_64-unknown-linux-gnu").build();
+    let config_aarch64 = cfg().target("aarch64-unknown-linux-gnu").build();
+
+    // invalid mnemonic
+    assert!(check_ignore(&config_x86_64, "//@ needs-asm-mnemonic:GRUGGY"));
+    assert!(check_ignore(&config_aarch64, "//@ needs-asm-mnemonic:gruggy"));
+
+    // valid x86 and aarch64
+    assert!(!check_ignore(&config_x86_64, "//@ needs-asm-mnemonic:RET"));
+    assert!(!check_ignore(&config_aarch64, "//@ needs-asm-mnemonic:ret"));
+
+    // this is aarch64 specific
+    assert!(check_ignore(&config_x86_64, "//@ needs-asm-mnemonic:ldrsbwui"));
+    assert!(!check_ignore(&config_aarch64, "//@ needs-asm-mnemonic:LDRSBWui"));
+
+    // this is x86 specific
+    assert!(check_ignore(&config_aarch64, "//@ needs-asm-mnemonic:CMPxCHG16B"));
+    assert!(!check_ignore(&config_x86_64, "//@ needs-asm-mnemonic:CMPXchg16B"));
+}
diff --git a/tests/run-make/naked-dead-code-elimination/rmake.rs b/tests/run-make/naked-dead-code-elimination/rmake.rs
index 1be22de367c99..8e4c26fc34508 100644
--- a/tests/run-make/naked-dead-code-elimination/rmake.rs
+++ b/tests/run-make/naked-dead-code-elimination/rmake.rs
@@ -1,5 +1,6 @@
 //@ ignore-cross-compile
 //@ needs-asm-support
+//@ needs-asm-mnemonic: RET
 
 use run_make_support::symbols::object_contains_any_symbol;
 use run_make_support::{bin_name, rustc};
diff --git a/tests/run-make/print-request-help-stable-unstable/help-diff.diff b/tests/run-make/print-request-help-stable-unstable/help-diff.diff
index e382a24782711..828a98d96b563 100644
--- a/tests/run-make/print-request-help-stable-unstable/help-diff.diff
+++ b/tests/run-make/print-request-help-stable-unstable/help-diff.diff
@@ -2,6 +2,6 @@
  error: unknown print request: `xxx`
    |
 -  = help: valid print requests are: `calling-conventions`, `cfg`, `code-models`, `crate-name`, `deployment-target`, `file-names`, `host-tuple`, `link-args`, `native-static-libs`, `relocation-models`, `split-debuginfo`, `stack-protector-strategies`, `sysroot`, `target-cpus`, `target-features`, `target-libdir`, `target-list`, `tls-models`
-+  = help: valid print requests are: `all-target-specs-json`, `backend-has-zstd`, `calling-conventions`, `cfg`, `check-cfg`, `code-models`, `crate-name`, `crate-root-lint-levels`, `deployment-target`, `file-names`, `host-tuple`, `link-args`, `native-static-libs`, `relocation-models`, `split-debuginfo`, `stack-protector-strategies`, `supported-crate-types`, `sysroot`, `target-cpus`, `target-features`, `target-libdir`, `target-list`, `target-spec-json`, `target-spec-json-schema`, `tls-models`
++  = help: valid print requests are: `all-target-specs-json`, `backend-has-mnemonic`, `backend-has-zstd`, `calling-conventions`, `cfg`, `check-cfg`, `code-models`, `crate-name`, `crate-root-lint-levels`, `deployment-target`, `file-names`, `host-tuple`, `link-args`, `native-static-libs`, `relocation-models`, `split-debuginfo`, `stack-protector-strategies`, `supported-crate-types`, `sysroot`, `target-cpus`, `target-features`, `target-libdir`, `target-list`, `target-spec-json`, `target-spec-json-schema`, `tls-models`
    = help: for more information, see the rustc book: https://doc.rust-lang.org/rustc/command-line-arguments.html#--print-print-compiler-information
  
diff --git a/tests/run-make/print-request-help-stable-unstable/unstable-invalid-print-request-help.err b/tests/run-make/print-request-help-stable-unstable/unstable-invalid-print-request-help.err
index 70764ea13aa87..d0e4c81f1de9d 100644
--- a/tests/run-make/print-request-help-stable-unstable/unstable-invalid-print-request-help.err
+++ b/tests/run-make/print-request-help-stable-unstable/unstable-invalid-print-request-help.err
@@ -1,5 +1,5 @@
 error: unknown print request: `xxx`
   |
-  = help: valid print requests are: `all-target-specs-json`, `backend-has-zstd`, `calling-conventions`, `cfg`, `check-cfg`, `code-models`, `crate-name`, `crate-root-lint-levels`, `deployment-target`, `file-names`, `host-tuple`, `link-args`, `native-static-libs`, `relocation-models`, `split-debuginfo`, `stack-protector-strategies`, `supported-crate-types`, `sysroot`, `target-cpus`, `target-features`, `target-libdir`, `target-list`, `target-spec-json`, `target-spec-json-schema`, `tls-models`
+  = help: valid print requests are: `all-target-specs-json`, `backend-has-mnemonic`, `backend-has-zstd`, `calling-conventions`, `cfg`, `check-cfg`, `code-models`, `crate-name`, `crate-root-lint-levels`, `deployment-target`, `file-names`, `host-tuple`, `link-args`, `native-static-libs`, `relocation-models`, `split-debuginfo`, `stack-protector-strategies`, `supported-crate-types`, `sysroot`, `target-cpus`, `target-features`, `target-libdir`, `target-list`, `target-spec-json`, `target-spec-json-schema`, `tls-models`
   = help: for more information, see the rustc book: https://doc.rust-lang.org/rustc/command-line-arguments.html#--print-print-compiler-information
 
diff --git a/tests/run-make/rustc-help/help-v.stdout b/tests/run-make/rustc-help/help-v.stdout
index 0acbb766c1556..1531f61089e9a 100644
--- a/tests/run-make/rustc-help/help-v.stdout
+++ b/tests/run-make/rustc-help/help-v.stdout
@@ -43,7 +43,7 @@ Options:
         --print <INFO>[=<FILE>]
                         Compiler information to print on stdout (or to a file)
                         INFO may be one of
-                        <all-target-specs-json|backend-has-zstd|calling-conventions|cfg|check-cfg|code-models|crate-name|crate-root-lint-levels|deployment-target|file-names|host-tuple|link-args|native-static-libs|relocation-models|split-debuginfo|stack-protector-strategies|supported-crate-types|sysroot|target-cpus|target-features|target-libdir|target-list|target-spec-json|target-spec-json-schema|tls-models>.
+                        <all-target-specs-json|backend-has-mnemonic|backend-has-zstd|calling-conventions|cfg|check-cfg|code-models|crate-name|crate-root-lint-levels|deployment-target|file-names|host-tuple|link-args|native-static-libs|relocation-models|split-debuginfo|stack-protector-strategies|supported-crate-types|sysroot|target-cpus|target-features|target-libdir|target-list|target-spec-json|target-spec-json-schema|tls-models>.
     -g                  Equivalent to -C debuginfo=2
     -O                  Equivalent to -C opt-level=3
     -o <FILENAME>       Write output to FILENAME
diff --git a/tests/run-make/rustc-help/help.stdout b/tests/run-make/rustc-help/help.stdout
index 4075dd0282999..f96feccf35980 100644
--- a/tests/run-make/rustc-help/help.stdout
+++ b/tests/run-make/rustc-help/help.stdout
@@ -43,7 +43,7 @@ Options:
         --print <INFO>[=<FILE>]
                         Compiler information to print on stdout (or to a file)
                         INFO may be one of
-                        <all-target-specs-json|backend-has-zstd|calling-conventions|cfg|check-cfg|code-models|crate-name|crate-root-lint-levels|deployment-target|file-names|host-tuple|link-args|native-static-libs|relocation-models|split-debuginfo|stack-protector-strategies|supported-crate-types|sysroot|target-cpus|target-features|target-libdir|target-list|target-spec-json|target-spec-json-schema|tls-models>.
+                        <all-target-specs-json|backend-has-mnemonic|backend-has-zstd|calling-conventions|cfg|check-cfg|code-models|crate-name|crate-root-lint-levels|deployment-target|file-names|host-tuple|link-args|native-static-libs|relocation-models|split-debuginfo|stack-protector-strategies|supported-crate-types|sysroot|target-cpus|target-features|target-libdir|target-list|target-spec-json|target-spec-json-schema|tls-models>.
     -g                  Equivalent to -C debuginfo=2
     -O                  Equivalent to -C opt-level=3
     -o <FILENAME>       Write output to FILENAME
diff --git a/tests/ui/compile-flags/invalid/print-without-arg.stderr b/tests/ui/compile-flags/invalid/print-without-arg.stderr
index ff9669614360a..98788b4b87228 100644
--- a/tests/ui/compile-flags/invalid/print-without-arg.stderr
+++ b/tests/ui/compile-flags/invalid/print-without-arg.stderr
@@ -3,5 +3,5 @@ error: Argument to option 'print' missing
            --print <INFO>[=<FILE>]
                                Compiler information to print on stdout (or to a file)
                                INFO may be one of
-                               <all-target-specs-json|backend-has-zstd|calling-conventions|cfg|check-cfg|code-models|crate-name|crate-root-lint-levels|deployment-target|file-names|host-tuple|link-args|native-static-libs|relocation-models|split-debuginfo|stack-protector-strategies|supported-crate-types|sysroot|target-cpus|target-features|target-libdir|target-list|target-spec-json|target-spec-json-schema|tls-models>.
+                               <all-target-specs-json|backend-has-mnemonic|backend-has-zstd|calling-conventions|cfg|check-cfg|code-models|crate-name|crate-root-lint-levels|deployment-target|file-names|host-tuple|link-args|native-static-libs|relocation-models|split-debuginfo|stack-protector-strategies|supported-crate-types|sysroot|target-cpus|target-features|target-libdir|target-list|target-spec-json|target-spec-json-schema|tls-models>.
 
diff --git a/tests/ui/compile-flags/invalid/print.stderr b/tests/ui/compile-flags/invalid/print.stderr
index e2521ebf26a41..3eb7634d915db 100644
--- a/tests/ui/compile-flags/invalid/print.stderr
+++ b/tests/ui/compile-flags/invalid/print.stderr
@@ -1,5 +1,5 @@
 error: unknown print request: `yyyy`
   |
-  = help: valid print requests are: `all-target-specs-json`, `backend-has-zstd`, `calling-conventions`, `cfg`, `check-cfg`, `code-models`, `crate-name`, `crate-root-lint-levels`, `deployment-target`, `file-names`, `host-tuple`, `link-args`, `native-static-libs`, `relocation-models`, `split-debuginfo`, `stack-protector-strategies`, `supported-crate-types`, `sysroot`, `target-cpus`, `target-features`, `target-libdir`, `target-list`, `target-spec-json`, `target-spec-json-schema`, `tls-models`
+  = help: valid print requests are: `all-target-specs-json`, `backend-has-mnemonic`, `backend-has-zstd`, `calling-conventions`, `cfg`, `check-cfg`, `code-models`, `crate-name`, `crate-root-lint-levels`, `deployment-target`, `file-names`, `host-tuple`, `link-args`, `native-static-libs`, `relocation-models`, `split-debuginfo`, `stack-protector-strategies`, `supported-crate-types`, `sysroot`, `target-cpus`, `target-features`, `target-libdir`, `target-list`, `target-spec-json`, `target-spec-json-schema`, `tls-models`
   = help: for more information, see the rustc book: https://doc.rust-lang.org/rustc/command-line-arguments.html#--print-print-compiler-information
 
diff --git a/tests/ui/consts/const-closure-hkl.rs b/tests/ui/consts/const-closure-hkl.rs
new file mode 100644
index 0000000000000..25927b3a61ecd
--- /dev/null
+++ b/tests/ui/consts/const-closure-hkl.rs
@@ -0,0 +1,20 @@
+//! Regression test for hkl const closures not working in old solver
+
+//@ check-pass
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
+
+#![feature(const_trait_impl)]
+#![feature(const_closures)]
+const fn partial_compare() {
+    let len_chain = const move |_a: &_, _b: &_| {};
+
+    chaining_impl(len_chain);
+}
+
+const fn chaining_impl(x: impl for<'a> [const] FnOnce(&'a usize, &'a usize)) {
+    std::mem::forget(x);
+}
+
+fn main() {}
diff --git a/tests/ui/let-else/let-else-irrefutable-152938.rs b/tests/ui/let-else/let-else-irrefutable-152938.rs
index 6e0ffe3fb8706..25e3e0f6e5708 100644
--- a/tests/ui/let-else/let-else-irrefutable-152938.rs
+++ b/tests/ui/let-else/let-else-irrefutable-152938.rs
@@ -6,7 +6,7 @@
 
 pub fn say_hello(name: Option<String>) {
     let name_str = Some(name) else { return; };
-    //~^ WARN irrefutable `let...else` pattern
+    //~^ WARN unreachable `else` clause
     drop(name_str);
 }
 
diff --git a/tests/ui/let-else/let-else-irrefutable-152938.stderr b/tests/ui/let-else/let-else-irrefutable-152938.stderr
index 57632964be9b3..e32f4960a3350 100644
--- a/tests/ui/let-else/let-else-irrefutable-152938.stderr
+++ b/tests/ui/let-else/let-else-irrefutable-152938.stderr
@@ -1,16 +1,18 @@
-warning: irrefutable `let...else` pattern
-  --> $DIR/let-else-irrefutable-152938.rs:8:5
+warning: unreachable `else` clause
+  --> $DIR/let-else-irrefutable-152938.rs:8:31
    |
 LL |     let name_str = Some(name) else { return; };
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ------------------------- ^^^^
+   |     |
+   |     assigning to binding pattern will always succeed
    |
    = note: this pattern always matches, so the else clause is unreachable
-help: remove this `else` block
-  --> $DIR/let-else-irrefutable-152938.rs:8:36
-   |
-LL |     let name_str = Some(name) else { return; };
-   |                                    ^^^^^^^^^^^
    = note: `#[warn(irrefutable_let_patterns)]` on by default
+help: consider using `let Some(name_str) = name` to match on a specific variant
+   |
+LL -     let name_str = Some(name) else { return; };
+LL +     let Some(name_str) = name else { return; };
+   |
 
 warning: 1 warning emitted
 
diff --git a/tests/ui/let-else/let-else-irrefutable.rs b/tests/ui/let-else/let-else-irrefutable.rs
index f9675ff5938eb..59de726d38ddf 100644
--- a/tests/ui/let-else/let-else-irrefutable.rs
+++ b/tests/ui/let-else/let-else-irrefutable.rs
@@ -1,10 +1,18 @@
 //@ check-pass
 
 fn main() {
-    let x = 1 else { return }; //~ WARN irrefutable `let...else` pattern
+    let x = 1 else { return }; //~ WARN unreachable `else` clause
 
     // Multiline else blocks should not get printed
-    let x = 1 else { //~ WARN irrefutable `let...else` pattern
+    let x = 1 else { //~ WARN unreachable `else` clause
+        eprintln!("problem case encountered");
+        return
+    };
+
+    let case = Some("a");
+    let name = Some(case) else {
+        //~^ WARN unreachable `else` clause
+        //~| HELP consider using `let Some(name) = case` to match on a specific variant
         eprintln!("problem case encountered");
         return
     };
diff --git a/tests/ui/let-else/let-else-irrefutable.stderr b/tests/ui/let-else/let-else-irrefutable.stderr
index d36d227b4156a..12338789d2a03 100644
--- a/tests/ui/let-else/let-else-irrefutable.stderr
+++ b/tests/ui/let-else/let-else-irrefutable.stderr
@@ -1,33 +1,38 @@
-warning: irrefutable `let...else` pattern
-  --> $DIR/let-else-irrefutable.rs:4:5
+warning: unreachable `else` clause
+  --> $DIR/let-else-irrefutable.rs:4:15
    |
 LL |     let x = 1 else { return };
-   |     ^^^^^^^^^
+   |     --------- ^^^^
+   |     |
+   |     assigning to binding pattern will always succeed
    |
    = note: this pattern always matches, so the else clause is unreachable
-help: remove this `else` block
-  --> $DIR/let-else-irrefutable.rs:4:20
-   |
-LL |     let x = 1 else { return };
-   |                    ^^^^^^^^^^
    = note: `#[warn(irrefutable_let_patterns)]` on by default
 
-warning: irrefutable `let...else` pattern
-  --> $DIR/let-else-irrefutable.rs:7:5
+warning: unreachable `else` clause
+  --> $DIR/let-else-irrefutable.rs:7:15
    |
 LL |     let x = 1 else {
-   |     ^^^^^^^^^
+   |     --------- ^^^^
+   |     |
+   |     assigning to binding pattern will always succeed
+   |
+   = note: this pattern always matches, so the else clause is unreachable
+
+warning: unreachable `else` clause
+  --> $DIR/let-else-irrefutable.rs:13:27
+   |
+LL |     let name = Some(case) else {
+   |     --------------------- ^^^^
+   |     |
+   |     assigning to binding pattern will always succeed
    |
    = note: this pattern always matches, so the else clause is unreachable
-help: remove this `else` block
-  --> $DIR/let-else-irrefutable.rs:7:20
-   |
-LL |       let x = 1 else {
-   |  ____________________^
-LL | |         eprintln!("problem case encountered");
-LL | |         return
-LL | |     };
-   | |_____^
+help: consider using `let Some(name) = case` to match on a specific variant
+   |
+LL -     let name = Some(case) else {
+LL +     let Some(name) = case else {
+   |
 
-warning: 2 warnings emitted
+warning: 3 warnings emitted
 
diff --git a/tests/ui/parser/bad-let-else-statement.rs b/tests/ui/parser/bad-let-else-statement.rs
index 3ede26dbcd06c..a552fbcfc1fc3 100644
--- a/tests/ui/parser/bad-let-else-statement.rs
+++ b/tests/ui/parser/bad-let-else-statement.rs
@@ -93,10 +93,10 @@ fn i() {
 fn j() {
     let mut bar = 0;
     let foo = bar = {
-        //~^ WARN irrefutable `let...else` pattern
         1
     } else {
-        //~^ ERROR right curly brace `}` before `else` in a `let...else` statement not allowed
+        //~^ WARN unreachable `else` clause
+        //~| ERROR right curly brace `}` before `else` in a `let...else` statement not allowed
         return;
     };
 }
@@ -158,21 +158,21 @@ fn o() -> Result<(), ()> {
 
 fn q() {
     let foo = |x: i32| {
-        //~^ WARN irrefutable `let...else` pattern
         x
     } else {
-        //~^ ERROR right curly brace `}` before `else` in a `let...else` statement not allowed
+        //~^ WARN unreachable `else` clause
+        //~| ERROR right curly brace `}` before `else` in a `let...else` statement not allowed
         return;
     };
 }
 
 fn r() {
     let ok = format_args!("") else { return; };
-    //~^ WARN irrefutable `let...else` pattern
+    //~^ WARN unreachable `else` clause
 
     let bad = format_args! {""} else { return; };
     //~^ ERROR right curly brace `}` before `else` in a `let...else` statement not allowed
-    //~| WARN irrefutable `let...else` pattern
+    //~| WARN unreachable `else` clause
 }
 
 fn s() {
@@ -202,10 +202,10 @@ fn t() {
     }
 
     let foo = &std::ptr::null as &'static dyn std::ops::Fn() -> *const primitive! {
-        //~^ WARN irrefutable `let...else` pattern
         8
     } else {
-        //~^ ERROR right curly brace `}` before `else` in a `let...else` statement not allowed
+        //~^ WARN unreachable `else` clause
+        //~| ERROR right curly brace `}` before `else` in a `let...else` statement not allowed
         return;
     };
 }
diff --git a/tests/ui/parser/bad-let-else-statement.stderr b/tests/ui/parser/bad-let-else-statement.stderr
index 8545d95f507f6..76fbbbb8c1e10 100644
--- a/tests/ui/parser/bad-let-else-statement.stderr
+++ b/tests/ui/parser/bad-let-else-statement.stderr
@@ -125,7 +125,7 @@ LL ~     }) else {
    |
 
 error: right curly brace `}` before `else` in a `let...else` statement not allowed
-  --> $DIR/bad-let-else-statement.rs:98:5
+  --> $DIR/bad-let-else-statement.rs:97:5
    |
 LL |     } else {
    |     ^
@@ -133,7 +133,6 @@ LL |     } else {
 help: wrap the expression in parentheses
    |
 LL ~     let foo = bar = ({
-LL |
 LL |         1
 LL ~     }) else {
    |
@@ -204,7 +203,7 @@ LL ~     }) else {
    |
 
 error: right curly brace `}` before `else` in a `let...else` statement not allowed
-  --> $DIR/bad-let-else-statement.rs:163:5
+  --> $DIR/bad-let-else-statement.rs:162:5
    |
 LL |     } else {
    |     ^
@@ -212,7 +211,6 @@ LL |     } else {
 help: wrap the expression in parentheses
    |
 LL ~     let foo = |x: i32| ({
-LL |
 LL |         x
 LL ~     }) else {
    |
@@ -230,7 +228,7 @@ LL +     let bad = format_args! ("") else { return; };
    |
 
 error: right curly brace `}` before `else` in a `let...else` statement not allowed
-  --> $DIR/bad-let-else-statement.rs:207:5
+  --> $DIR/bad-let-else-statement.rs:206:5
    |
 LL |     } else {
    |     ^
@@ -238,7 +236,6 @@ LL |     } else {
 help: use parentheses instead of braces for this macro
    |
 LL ~     let foo = &std::ptr::null as &'static dyn std::ops::Fn() -> *const primitive! (
-LL |
 LL |         8
 LL ~     ) else {
    |
@@ -259,92 +256,62 @@ LL -             let 0 = a! {} else { return; };
 LL +             let 0 = a! () else { return; };
    |
 
-warning: irrefutable `let...else` pattern
-  --> $DIR/bad-let-else-statement.rs:95:5
+warning: unreachable `else` clause
+  --> $DIR/bad-let-else-statement.rs:97:7
    |
 LL | /     let foo = bar = {
-LL | |
 LL | |         1
 LL | |     } else {
-   | |_____^
+   | |     - ^^^^
+   | |_____|
+   |       assigning to binding pattern will always succeed
    |
    = note: this pattern always matches, so the else clause is unreachable
-help: remove this `else` block
-  --> $DIR/bad-let-else-statement.rs:98:12
-   |
-LL |       } else {
-   |  ____________^
-LL | |
-LL | |         return;
-LL | |     };
-   | |_____^
    = note: `#[warn(irrefutable_let_patterns)]` on by default
 
-warning: irrefutable `let...else` pattern
-  --> $DIR/bad-let-else-statement.rs:160:5
+warning: unreachable `else` clause
+  --> $DIR/bad-let-else-statement.rs:162:7
    |
 LL | /     let foo = |x: i32| {
-LL | |
 LL | |         x
 LL | |     } else {
-   | |_____^
+   | |     - ^^^^
+   | |_____|
+   |       assigning to binding pattern will always succeed
    |
    = note: this pattern always matches, so the else clause is unreachable
-help: remove this `else` block
-  --> $DIR/bad-let-else-statement.rs:163:12
-   |
-LL |       } else {
-   |  ____________^
-LL | |
-LL | |         return;
-LL | |     };
-   | |_____^
 
-warning: irrefutable `let...else` pattern
-  --> $DIR/bad-let-else-statement.rs:170:5
+warning: unreachable `else` clause
+  --> $DIR/bad-let-else-statement.rs:170:31
    |
 LL |     let ok = format_args!("") else { return; };
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ------------------------- ^^^^
+   |     |
+   |     assigning to binding pattern will always succeed
    |
    = note: this pattern always matches, so the else clause is unreachable
-help: remove this `else` block
-  --> $DIR/bad-let-else-statement.rs:170:36
-   |
-LL |     let ok = format_args!("") else { return; };
-   |                                    ^^^^^^^^^^^
 
-warning: irrefutable `let...else` pattern
-  --> $DIR/bad-let-else-statement.rs:173:5
+warning: unreachable `else` clause
+  --> $DIR/bad-let-else-statement.rs:173:33
    |
 LL |     let bad = format_args! {""} else { return; };
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     --------------------------- ^^^^
+   |     |
+   |     assigning to binding pattern will always succeed
    |
    = note: this pattern always matches, so the else clause is unreachable
-help: remove this `else` block
-  --> $DIR/bad-let-else-statement.rs:173:38
-   |
-LL |     let bad = format_args! {""} else { return; };
-   |                                      ^^^^^^^^^^^
 
-warning: irrefutable `let...else` pattern
-  --> $DIR/bad-let-else-statement.rs:204:5
+warning: unreachable `else` clause
+  --> $DIR/bad-let-else-statement.rs:206:7
    |
 LL | /     let foo = &std::ptr::null as &'static dyn std::ops::Fn() -> *const primitive! {
-LL | |
 LL | |         8
 LL | |     } else {
-   | |_____^
+   | |     - ^^^^
+   | |_____|
+   |       assigning to binding pattern will always succeed
    |
    = note: this pattern always matches, so the else clause is unreachable
-help: remove this `else` block
-  --> $DIR/bad-let-else-statement.rs:207:12
-   |
-LL |       } else {
-   |  ____________^
-LL | |
-LL | |         return;
-LL | |     };
-   | |_____^
 
 error: aborting due to 19 previous errors; 5 warnings emitted
 
diff --git a/tests/ui/print-request/print-lints-help.stderr b/tests/ui/print-request/print-lints-help.stderr
index d39c6326e318b..c6e74e7dce7b6 100644
--- a/tests/ui/print-request/print-lints-help.stderr
+++ b/tests/ui/print-request/print-lints-help.stderr
@@ -1,6 +1,6 @@
 error: unknown print request: `lints`
   |
-  = help: valid print requests are: `all-target-specs-json`, `backend-has-zstd`, `calling-conventions`, `cfg`, `check-cfg`, `code-models`, `crate-name`, `crate-root-lint-levels`, `deployment-target`, `file-names`, `host-tuple`, `link-args`, `native-static-libs`, `relocation-models`, `split-debuginfo`, `stack-protector-strategies`, `supported-crate-types`, `sysroot`, `target-cpus`, `target-features`, `target-libdir`, `target-list`, `target-spec-json`, `target-spec-json-schema`, `tls-models`
+  = help: valid print requests are: `all-target-specs-json`, `backend-has-mnemonic`, `backend-has-zstd`, `calling-conventions`, `cfg`, `check-cfg`, `code-models`, `crate-name`, `crate-root-lint-levels`, `deployment-target`, `file-names`, `host-tuple`, `link-args`, `native-static-libs`, `relocation-models`, `split-debuginfo`, `stack-protector-strategies`, `supported-crate-types`, `sysroot`, `target-cpus`, `target-features`, `target-libdir`, `target-list`, `target-spec-json`, `target-spec-json-schema`, `tls-models`
   = help: use `-Whelp` to print a list of lints
   = help: for more information, see the rustc book: https://doc.rust-lang.org/rustc/command-line-arguments.html#--print-print-compiler-information
 
diff --git a/tests/ui/span/let-offset-of.rs b/tests/ui/span/let-offset-of.rs
index 99b34a1928470..eeecf38e6b6a9 100644
--- a/tests/ui/span/let-offset-of.rs
+++ b/tests/ui/span/let-offset-of.rs
@@ -15,5 +15,5 @@ fn init_to_offset_of() {
     //~^ WARN irrefutable `if let` pattern
 
     let x = offset_of!(Foo, field) else { return; };
-    //~^ WARN irrefutable `let...else` pattern
+    //~^ WARN unreachable `else` clause
 }
diff --git a/tests/ui/span/let-offset-of.stderr b/tests/ui/span/let-offset-of.stderr
index df9b1e695b1e4..afcf8a8103d9d 100644
--- a/tests/ui/span/let-offset-of.stderr
+++ b/tests/ui/span/let-offset-of.stderr
@@ -8,18 +8,15 @@ LL |     if let x = offset_of!(Foo, field) {}
    = help: consider replacing the `if let` with a `let`
    = note: `#[warn(irrefutable_let_patterns)]` on by default
 
-warning: irrefutable `let...else` pattern
-  --> $DIR/let-offset-of.rs:17:5
+warning: unreachable `else` clause
+  --> $DIR/let-offset-of.rs:17:36
    |
 LL |     let x = offset_of!(Foo, field) else { return; };
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ------------------------------ ^^^^
+   |     |
+   |     assigning to binding pattern will always succeed
    |
    = note: this pattern always matches, so the else clause is unreachable
-help: remove this `else` block
-  --> $DIR/let-offset-of.rs:17:41
-   |
-LL |     let x = offset_of!(Foo, field) else { return; };
-   |                                         ^^^^^^^^^^^
 
 warning: 2 warnings emitted