diff --git a/compiler/rustc_borrowck/src/type_check/liveness/trace.rs b/compiler/rustc_borrowck/src/type_check/liveness/trace.rs
index 7718644b9a9a8..512288a0f7d85 100644
--- a/compiler/rustc_borrowck/src/type_check/liveness/trace.rs
+++ b/compiler/rustc_borrowck/src/type_check/liveness/trace.rs
@@ -621,13 +621,7 @@ impl<'tcx> LivenessContext<'_, '_, '_, 'tcx> {
                         &ocx, op, span,
                     ) {
                         Ok(_) => ocx.select_all_or_error(),
-                        Err(e) => {
-                            if e.is_empty() {
-                                ocx.select_all_or_error()
-                            } else {
-                                e
-                            }
-                        }
+                        Err(e) => e,
                     };
 
                     // Could have no errors if a type lowering error, say, caused the query
diff --git a/compiler/rustc_lint/messages.ftl b/compiler/rustc_lint/messages.ftl
index 99b42ee548029..08180bf8f8b2c 100644
--- a/compiler/rustc_lint/messages.ftl
+++ b/compiler/rustc_lint/messages.ftl
@@ -362,6 +362,10 @@ lint_impl_trait_redundant_captures = all possible in-scope parameters are alread
 
 lint_implicit_unsafe_autorefs = implicit autoref creates a reference to the dereference of a raw pointer
     .note = creating a reference requires the pointer target to be valid and imposes aliasing requirements
+    .raw_ptr = this raw pointer has type `{$raw_ptr_ty}`
+    .autoref = autoref is being applied to this expression, resulting in: `{$autoref_ty}`
+    .overloaded_deref = references are created through calls to explicit `Deref(Mut)::deref(_mut)` implementations
+    .method_def = method calls to `{$method_name}` require a reference
     .suggestion = try using a raw pointer method instead; or if this reference is intentional, make it explicit
 
 lint_improper_ctypes = `extern` {$desc} uses type `{$ty}`, which is not FFI-safe
diff --git a/compiler/rustc_lint/src/autorefs.rs b/compiler/rustc_lint/src/autorefs.rs
index 91d58d92466ac..5de2cbf9939db 100644
--- a/compiler/rustc_lint/src/autorefs.rs
+++ b/compiler/rustc_lint/src/autorefs.rs
@@ -4,7 +4,10 @@ use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow, OverloadedDer
 use rustc_session::{declare_lint, declare_lint_pass};
 use rustc_span::sym;
 
-use crate::lints::{ImplicitUnsafeAutorefsDiag, ImplicitUnsafeAutorefsSuggestion};
+use crate::lints::{
+    ImplicitUnsafeAutorefsDiag, ImplicitUnsafeAutorefsMethodNote, ImplicitUnsafeAutorefsOrigin,
+    ImplicitUnsafeAutorefsSuggestion,
+};
 use crate::{LateContext, LateLintPass, LintContext};
 
 declare_lint! {
@@ -92,25 +95,37 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitAutorefs {
             && let adjustments = peel_derefs_adjustments(&**adjustments)
             // 3. An automatically inserted reference (might come from a deref).
             && let [adjustment] = adjustments
-            && let Some(borrow_mutbl) = has_implicit_borrow(adjustment)
+            && let Some((borrow_mutbl, through_overloaded_deref)) = has_implicit_borrow(adjustment)
             && let ExprKind::Unary(UnOp::Deref, dereferenced) =
                 // 2. Any number of place projections.
                 peel_place_mappers(inner).kind
             // 1. Deref of a raw pointer.
             && typeck.expr_ty(dereferenced).is_raw_ptr()
-            // PERF: 5. b. A method call annotated with `#[rustc_no_implicit_refs]`
-            && match expr.kind {
-                ExprKind::MethodCall(..) => matches!(
-                    cx.typeck_results().type_dependent_def_id(expr.hir_id),
-                    Some(def_id) if cx.tcx.has_attr(def_id, sym::rustc_no_implicit_autorefs)
-                ),
-                _ => true,
+            && let method_did = match expr.kind {
+                // PERF: 5. b. A method call annotated with `#[rustc_no_implicit_refs]`
+                ExprKind::MethodCall(..) => cx.typeck_results().type_dependent_def_id(expr.hir_id),
+                _ => None,
             }
+            && method_did.map(|did| cx.tcx.has_attr(did, sym::rustc_no_implicit_autorefs)).unwrap_or(true)
         {
             cx.emit_span_lint(
                 DANGEROUS_IMPLICIT_AUTOREFS,
                 expr.span.source_callsite(),
                 ImplicitUnsafeAutorefsDiag {
+                    raw_ptr_span: dereferenced.span,
+                    raw_ptr_ty: typeck.expr_ty(dereferenced),
+                    origin: if through_overloaded_deref {
+                        ImplicitUnsafeAutorefsOrigin::OverloadedDeref
+                    } else {
+                        ImplicitUnsafeAutorefsOrigin::Autoref {
+                            autoref_span: inner.span,
+                            autoref_ty: typeck.expr_ty_adjusted(inner),
+                        }
+                    },
+                    method: method_did.map(|did| ImplicitUnsafeAutorefsMethodNote {
+                        def_span: cx.tcx.def_span(did),
+                        method_name: cx.tcx.item_name(did),
+                    }),
                     suggestion: ImplicitUnsafeAutorefsSuggestion {
                         mutbl: borrow_mutbl.ref_prefix_str(),
                         deref: if is_coming_from_deref { "*" } else { "" },
@@ -146,11 +161,12 @@ fn peel_derefs_adjustments<'a>(mut adjs: &'a [Adjustment<'a>]) -> &'a [Adjustmen
 
 /// Test if some adjustment has some implicit borrow.
 ///
-/// Returns `Some(mutability)` if the argument adjustment has implicit borrow in it.
-fn has_implicit_borrow(Adjustment { kind, .. }: &Adjustment<'_>) -> Option<Mutability> {
+/// Returns `Some((mutability, was_an_overloaded_deref))` if the argument adjustment is
+/// an implicit borrow (or has an implicit borrow via an overloaded deref).
+fn has_implicit_borrow(Adjustment { kind, .. }: &Adjustment<'_>) -> Option<(Mutability, bool)> {
     match kind {
-        &Adjust::Deref(Some(OverloadedDeref { mutbl, .. })) => Some(mutbl),
-        &Adjust::Borrow(AutoBorrow::Ref(mutbl)) => Some(mutbl.into()),
+        &Adjust::Deref(Some(OverloadedDeref { mutbl, .. })) => Some((mutbl, true)),
+        &Adjust::Borrow(AutoBorrow::Ref(mutbl)) => Some((mutbl.into(), false)),
         Adjust::NeverToAny
         | Adjust::Pointer(..)
         | Adjust::ReborrowPin(..)
diff --git a/compiler/rustc_lint/src/lints.rs b/compiler/rustc_lint/src/lints.rs
index 487184b836a43..7268a7f704fcb 100644
--- a/compiler/rustc_lint/src/lints.rs
+++ b/compiler/rustc_lint/src/lints.rs
@@ -59,11 +59,38 @@ pub(crate) enum ShadowedIntoIterDiagSub {
 #[derive(LintDiagnostic)]
 #[diag(lint_implicit_unsafe_autorefs)]
 #[note]
-pub(crate) struct ImplicitUnsafeAutorefsDiag {
+pub(crate) struct ImplicitUnsafeAutorefsDiag<'a> {
+    #[label(lint_raw_ptr)]
+    pub raw_ptr_span: Span,
+    pub raw_ptr_ty: Ty<'a>,
+    #[subdiagnostic]
+    pub origin: ImplicitUnsafeAutorefsOrigin<'a>,
+    #[subdiagnostic]
+    pub method: Option<ImplicitUnsafeAutorefsMethodNote>,
     #[subdiagnostic]
     pub suggestion: ImplicitUnsafeAutorefsSuggestion,
 }
 
+#[derive(Subdiagnostic)]
+pub(crate) enum ImplicitUnsafeAutorefsOrigin<'a> {
+    #[note(lint_autoref)]
+    Autoref {
+        #[primary_span]
+        autoref_span: Span,
+        autoref_ty: Ty<'a>,
+    },
+    #[note(lint_overloaded_deref)]
+    OverloadedDeref,
+}
+
+#[derive(Subdiagnostic)]
+#[note(lint_method_def)]
+pub(crate) struct ImplicitUnsafeAutorefsMethodNote {
+    #[primary_span]
+    pub def_span: Span,
+    pub method_name: Symbol,
+}
+
 #[derive(Subdiagnostic)]
 #[multipart_suggestion(lint_suggestion, applicability = "maybe-incorrect")]
 pub(crate) struct ImplicitUnsafeAutorefsSuggestion {
diff --git a/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs b/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
index 345a272895d39..542e212e1bfb1 100644
--- a/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
@@ -2,6 +2,7 @@
 
 pub(super) mod structural_traits;
 
+use std::cell::Cell;
 use std::ops::ControlFlow;
 
 use derive_where::derive_where;
@@ -117,24 +118,24 @@ where
     ) -> Result<Candidate<I>, NoSolution> {
         Self::fast_reject_assumption(ecx, goal, assumption)?;
 
-        ecx.probe(|candidate: &Result<Candidate<I>, NoSolution>| match candidate {
-            Ok(candidate) => inspect::ProbeKind::TraitCandidate {
-                source: candidate.source,
-                result: Ok(candidate.result),
-            },
-            Err(NoSolution) => inspect::ProbeKind::TraitCandidate {
-                source: CandidateSource::ParamEnv(ParamEnvSource::Global),
-                result: Err(NoSolution),
-            },
+        // Dealing with `ParamEnv` candidates is a bit of a mess as we need to lazily
+        // check whether the candidate is global while considering normalization.
+        //
+        // We need to write into `source` inside of `match_assumption`, but need to access it
+        // in `probe` even if the candidate does not apply before we get there. We handle this
+        // by using a `Cell` here. We only ever write into it inside of `match_assumption`.
+        let source = Cell::new(CandidateSource::ParamEnv(ParamEnvSource::Global));
+        ecx.probe(|result: &QueryResult<I>| inspect::ProbeKind::TraitCandidate {
+            source: source.get(),
+            result: *result,
         })
         .enter(|ecx| {
-            Self::match_assumption(ecx, goal, assumption)?;
-            let source = ecx.characterize_param_env_assumption(goal.param_env, assumption)?;
-            Ok(Candidate {
-                source,
-                result: ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)?,
+            Self::match_assumption(ecx, goal, assumption, |ecx| {
+                source.set(ecx.characterize_param_env_assumption(goal.param_env, assumption)?);
+                ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
             })
         })
+        .map(|result| Candidate { source: source.get(), result })
     }
 
     /// Try equating an assumption predicate against a goal's predicate. If it
@@ -150,10 +151,8 @@ where
     ) -> Result<Candidate<I>, NoSolution> {
         Self::fast_reject_assumption(ecx, goal, assumption)?;
 
-        ecx.probe_trait_candidate(source).enter(|ecx| {
-            Self::match_assumption(ecx, goal, assumption)?;
-            then(ecx)
-        })
+        ecx.probe_trait_candidate(source)
+            .enter(|ecx| Self::match_assumption(ecx, goal, assumption, then))
     }
 
     /// Try to reject the assumption based off of simple heuristics, such as [`ty::ClauseKind`]
@@ -169,7 +168,8 @@ where
         ecx: &mut EvalCtxt<'_, D>,
         goal: Goal<I, Self>,
         assumption: I::Clause,
-    ) -> Result<(), NoSolution>;
+        then: impl FnOnce(&mut EvalCtxt<'_, D>) -> QueryResult<I>,
+    ) -> QueryResult<I>;
 
     fn consider_impl_candidate(
         ecx: &mut EvalCtxt<'_, D>,
diff --git a/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs b/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs
index 84a83d79cf046..8413c2abbb969 100644
--- a/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs
@@ -61,13 +61,14 @@ where
         ecx: &mut EvalCtxt<'_, D>,
         goal: Goal<I, Self>,
         assumption: I::Clause,
-    ) -> Result<(), NoSolution> {
+        then: impl FnOnce(&mut EvalCtxt<'_, D>) -> QueryResult<I>,
+    ) -> QueryResult<I> {
         let host_clause = assumption.as_host_effect_clause().unwrap();
 
         let assumption_trait_pred = ecx.instantiate_binder_with_infer(host_clause);
         ecx.eq(goal.param_env, goal.predicate.trait_ref, assumption_trait_pred.trait_ref)?;
 
-        Ok(())
+        then(ecx)
     }
 
     /// Register additional assumptions for aliases corresponding to `~const` item bounds.
diff --git a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs
index b90e34e78101c..2fddc0044cb9e 100644
--- a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs
@@ -129,7 +129,40 @@ where
         ecx: &mut EvalCtxt<'_, D>,
         goal: Goal<I, Self>,
         assumption: I::Clause,
-    ) -> Result<(), NoSolution> {
+        then: impl FnOnce(&mut EvalCtxt<'_, D>) -> QueryResult<I>,
+    ) -> QueryResult<I> {
+        let cx = ecx.cx();
+        // FIXME(generic_associated_types): Addresses aggressive inference in #92917.
+        //
+        // If this type is a GAT with currently unconstrained arguments, we do not
+        // want to normalize it via a candidate which only applies for a specific
+        // instantiation. We could otherwise keep the GAT as rigid and succeed this way.
+        // See tests/ui/generic-associated-types/no-incomplete-gat-arg-inference.rs.
+        //
+        // This only avoids normalization if the GAT arguments are fully unconstrained.
+        // This is quite arbitrary but fixing it causes some ambiguity, see #125196.
+        match goal.predicate.alias.kind(cx) {
+            ty::AliasTermKind::ProjectionTy | ty::AliasTermKind::ProjectionConst => {
+                for arg in goal.predicate.alias.own_args(cx).iter() {
+                    let Some(term) = arg.as_term() else {
+                        continue;
+                    };
+                    let term = ecx.structurally_normalize_term(goal.param_env, term)?;
+                    if term.is_infer() {
+                        return ecx.evaluate_added_goals_and_make_canonical_response(
+                            Certainty::AMBIGUOUS,
+                        );
+                    }
+                }
+            }
+            ty::AliasTermKind::OpaqueTy
+            | ty::AliasTermKind::InherentTy
+            | ty::AliasTermKind::InherentConst
+            | ty::AliasTermKind::FreeTy
+            | ty::AliasTermKind::FreeConst
+            | ty::AliasTermKind::UnevaluatedConst => {}
+        }
+
         let projection_pred = assumption.as_projection_clause().unwrap();
 
         let assumption_projection_pred = ecx.instantiate_binder_with_infer(projection_pred);
@@ -139,7 +172,6 @@ where
 
         // Add GAT where clauses from the trait's definition
         // FIXME: We don't need these, since these are the type's own WF obligations.
-        let cx = ecx.cx();
         ecx.add_goals(
             GoalSource::AliasWellFormed,
             cx.own_predicates_of(goal.predicate.def_id())
@@ -147,7 +179,7 @@ where
                 .map(|pred| goal.with(cx, pred)),
         );
 
-        Ok(())
+        then(ecx)
     }
 
     fn consider_additional_alias_assumptions(
diff --git a/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs b/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
index e3addf8bf93fc..966d5422fbb7b 100644
--- a/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
@@ -17,7 +17,7 @@ use crate::solve::assembly::{self, AllowInferenceConstraints, AssembleCandidates
 use crate::solve::inspect::ProbeKind;
 use crate::solve::{
     BuiltinImplSource, CandidateSource, Certainty, EvalCtxt, Goal, GoalSource, MaybeCause,
-    NoSolution, ParamEnvSource,
+    NoSolution, ParamEnvSource, QueryResult,
 };
 
 impl<D, I> assembly::GoalKind<D> for TraitPredicate<I>
@@ -150,13 +150,14 @@ where
         ecx: &mut EvalCtxt<'_, D>,
         goal: Goal<I, Self>,
         assumption: I::Clause,
-    ) -> Result<(), NoSolution> {
+        then: impl FnOnce(&mut EvalCtxt<'_, D>) -> QueryResult<I>,
+    ) -> QueryResult<I> {
         let trait_clause = assumption.as_trait_clause().unwrap();
 
         let assumption_trait_pred = ecx.instantiate_binder_with_infer(trait_clause);
         ecx.eq(goal.param_env, goal.predicate.trait_ref, assumption_trait_pred.trait_ref)?;
 
-        Ok(())
+        then(ecx)
     }
 
     fn consider_auto_trait_candidate(
diff --git a/compiler/rustc_parse/messages.ftl b/compiler/rustc_parse/messages.ftl
index f88c15785d336..a6919afef12cf 100644
--- a/compiler/rustc_parse/messages.ftl
+++ b/compiler/rustc_parse/messages.ftl
@@ -815,7 +815,6 @@ parse_switch_ref_box_order = switch the order of `ref` and `box`
     .suggestion = swap them
 
 parse_ternary_operator = Rust has no ternary operator
-    .help = use an `if-else` expression instead
 
 parse_tilde_is_not_unary_operator = `~` cannot be used as a unary operator
     .suggestion = use `!` to perform bitwise not
@@ -963,6 +962,8 @@ parse_use_empty_block_not_semi = expected { "`{}`" }, found `;`
 parse_use_eq_instead = unexpected `==`
     .suggestion = try using `=` instead
 
+parse_use_if_else = use an `if-else` expression instead
+
 parse_use_let_not_auto = write `let` instead of `auto` to introduce a new variable
 parse_use_let_not_var = write `let` instead of `var` to introduce a new variable
 
diff --git a/compiler/rustc_parse/src/errors.rs b/compiler/rustc_parse/src/errors.rs
index 766baf6f80c75..31a48b22cfee1 100644
--- a/compiler/rustc_parse/src/errors.rs
+++ b/compiler/rustc_parse/src/errors.rs
@@ -436,10 +436,28 @@ pub(crate) enum IfExpressionMissingThenBlockSub {
 
 #[derive(Diagnostic)]
 #[diag(parse_ternary_operator)]
-#[help]
 pub(crate) struct TernaryOperator {
     #[primary_span]
     pub span: Span,
+    /// If we have a span for the condition expression, suggest the if/else
+    #[subdiagnostic]
+    pub sugg: Option<TernaryOperatorSuggestion>,
+    /// Otherwise, just print the suggestion message
+    #[help(parse_use_if_else)]
+    pub no_sugg: bool,
+}
+
+#[derive(Subdiagnostic, Copy, Clone)]
+#[multipart_suggestion(parse_use_if_else, applicability = "maybe-incorrect", style = "verbose")]
+pub(crate) struct TernaryOperatorSuggestion {
+    #[suggestion_part(code = "if ")]
+    pub before_cond: Span,
+    #[suggestion_part(code = "{{")]
+    pub question: Span,
+    #[suggestion_part(code = "}} else {{")]
+    pub colon: Span,
+    #[suggestion_part(code = " }}")]
+    pub end: Span,
 }
 
 #[derive(Subdiagnostic)]
diff --git a/compiler/rustc_parse/src/parser/diagnostics.rs b/compiler/rustc_parse/src/parser/diagnostics.rs
index 23c8db7bca784..6277dde7c974c 100644
--- a/compiler/rustc_parse/src/parser/diagnostics.rs
+++ b/compiler/rustc_parse/src/parser/diagnostics.rs
@@ -41,8 +41,9 @@ use crate::errors::{
     IncorrectSemicolon, IncorrectUseOfAwait, IncorrectUseOfUse, PatternMethodParamWithoutBody,
     QuestionMarkInType, QuestionMarkInTypeSugg, SelfParamNotFirst, StructLiteralBodyWithoutPath,
     StructLiteralBodyWithoutPathSugg, SuggAddMissingLetStmt, SuggEscapeIdentifier, SuggRemoveComma,
-    TernaryOperator, UnexpectedConstInGenericParam, UnexpectedConstParamDeclaration,
-    UnexpectedConstParamDeclarationSugg, UnmatchedAngleBrackets, UseEqInstead, WrapType,
+    TernaryOperator, TernaryOperatorSuggestion, UnexpectedConstInGenericParam,
+    UnexpectedConstParamDeclaration, UnexpectedConstParamDeclarationSugg, UnmatchedAngleBrackets,
+    UseEqInstead, WrapType,
 };
 use crate::parser::attr::InnerAttrPolicy;
 use crate::{exp, fluent_generated as fluent};
@@ -497,7 +498,7 @@ impl<'a> Parser<'a> {
             // If the user is trying to write a ternary expression, recover it and
             // return an Err to prevent a cascade of irrelevant diagnostics.
             if self.prev_token == token::Question
-                && let Err(e) = self.maybe_recover_from_ternary_operator()
+                && let Err(e) = self.maybe_recover_from_ternary_operator(None)
             {
                 return Err(e);
             }
@@ -1602,12 +1603,18 @@ impl<'a> Parser<'a> {
     /// Rust has no ternary operator (`cond ? then : else`). Parse it and try
     /// to recover from it if `then` and `else` are valid expressions. Returns
     /// an err if this appears to be a ternary expression.
-    pub(super) fn maybe_recover_from_ternary_operator(&mut self) -> PResult<'a, ()> {
+    /// If we have the span of the condition, we can provide a better error span
+    /// and code suggestion.
+    pub(super) fn maybe_recover_from_ternary_operator(
+        &mut self,
+        cond: Option<Span>,
+    ) -> PResult<'a, ()> {
         if self.prev_token != token::Question {
             return PResult::Ok(());
         }
 
-        let lo = self.prev_token.span.lo();
+        let question = self.prev_token.span;
+        let lo = cond.unwrap_or(question).lo();
         let snapshot = self.create_snapshot_for_diagnostic();
 
         if match self.parse_expr() {
@@ -1620,11 +1627,20 @@ impl<'a> Parser<'a> {
             }
         } {
             if self.eat_noexpect(&token::Colon) {
+                let colon = self.prev_token.span;
                 match self.parse_expr() {
-                    Ok(_) => {
-                        return Err(self
-                            .dcx()
-                            .create_err(TernaryOperator { span: self.token.span.with_lo(lo) }));
+                    Ok(expr) => {
+                        let sugg = cond.map(|cond| TernaryOperatorSuggestion {
+                            before_cond: cond.shrink_to_lo(),
+                            question,
+                            colon,
+                            end: expr.span.shrink_to_hi(),
+                        });
+                        return Err(self.dcx().create_err(TernaryOperator {
+                            span: self.prev_token.span.with_lo(lo),
+                            sugg,
+                            no_sugg: sugg.is_none(),
+                        }));
                     }
                     Err(err) => {
                         err.cancel();
diff --git a/compiler/rustc_parse/src/parser/stmt.rs b/compiler/rustc_parse/src/parser/stmt.rs
index 885a65d4de7a1..396ded96bde13 100644
--- a/compiler/rustc_parse/src/parser/stmt.rs
+++ b/compiler/rustc_parse/src/parser/stmt.rs
@@ -879,7 +879,12 @@ impl<'a> Parser<'a> {
             {
                 // Just check for errors and recover; do not eat semicolon yet.
 
-                let expect_result = self.expect_one_of(&[], &[exp!(Semi), exp!(CloseBrace)]);
+                let expect_result =
+                    if let Err(e) = self.maybe_recover_from_ternary_operator(Some(expr.span)) {
+                        Err(e)
+                    } else {
+                        self.expect_one_of(&[], &[exp!(Semi), exp!(CloseBrace)])
+                    };
 
                 // Try to both emit a better diagnostic, and avoid further errors by replacing
                 // the `expr` with `ExprKind::Err`.
diff --git a/compiler/rustc_pattern_analysis/src/lib.rs b/compiler/rustc_pattern_analysis/src/lib.rs
index f63d8b2d79f61..2b85d7b26cea0 100644
--- a/compiler/rustc_pattern_analysis/src/lib.rs
+++ b/compiler/rustc_pattern_analysis/src/lib.rs
@@ -6,7 +6,6 @@
 #![allow(rustc::diagnostic_outside_of_impl)]
 #![allow(rustc::untranslatable_diagnostic)]
 #![allow(unused_crate_dependencies)]
-#![cfg_attr(all(feature = "rustc", bootstrap), feature(let_chains))]
 // tidy-alphabetical-end
 
 pub mod constructor;
diff --git a/compiler/rustc_target/src/spec/targets/aarch64_pc_windows_msvc.rs b/compiler/rustc_target/src/spec/targets/aarch64_pc_windows_msvc.rs
index c5704c574483f..e79e9a397b526 100644
--- a/compiler/rustc_target/src/spec/targets/aarch64_pc_windows_msvc.rs
+++ b/compiler/rustc_target/src/spec/targets/aarch64_pc_windows_msvc.rs
@@ -14,7 +14,7 @@ pub(crate) fn target() -> Target {
     // MSVC emits a warning about code that may trip "Cortex-A53 MPCore processor bug #843419" (see
     // https://developer.arm.com/documentation/epm048406/latest) which is sometimes emitted by LLVM.
     // Since Arm64 Windows 10+ isn't supported on that processor, it's safe to disable the warning.
-    base.add_pre_link_args(LinkerFlavor::Msvc(Lld::No), &["/arm64hazardfree"]);
+    base.add_pre_link_args(LinkerFlavor::Msvc(Lld::No), &["-arm64hazardfree"]);
 
     Target {
         llvm_target: "aarch64-pc-windows-msvc".into(),
diff --git a/compiler/rustc_trait_selection/src/traits/query/dropck_outlives.rs b/compiler/rustc_trait_selection/src/traits/query/dropck_outlives.rs
index f04a5feba3011..38cfdcdc22d33 100644
--- a/compiler/rustc_trait_selection/src/traits/query/dropck_outlives.rs
+++ b/compiler/rustc_trait_selection/src/traits/query/dropck_outlives.rs
@@ -196,11 +196,31 @@ where
                 debug!("dropck_outlives: ty from dtorck_types = {:?}", ty);
                 ty
             } else {
-                ocx.deeply_normalize(&cause, param_env, ty)?;
+                // Flush errors b/c `deeply_normalize` doesn't expect pending
+                // obligations, and we may have pending obligations from the
+                // branch above (from other types).
+                let errors = ocx.select_all_or_error();
+                if !errors.is_empty() {
+                    return Err(errors);
+                }
 
-                let errors = ocx.select_where_possible();
-                debug!("normalize errors: {ty} ~> {errors:#?}");
-                return Err(errors);
+                // When query normalization fails, we don't get back an interesting
+                // reason that we could use to report an error in borrowck. In order to turn
+                // this into a reportable error, we deeply normalize again. We don't expect
+                // this to succeed, so delay a bug if it does.
+                match ocx.deeply_normalize(&cause, param_env, ty) {
+                    Ok(_) => {
+                        tcx.dcx().span_delayed_bug(
+                            span,
+                            format!(
+                                "query normalize succeeded of {ty}, \
+                                but deep normalize failed",
+                            ),
+                        );
+                        ty
+                    }
+                    Err(errors) => return Err(errors),
+                }
             };
 
             match ty.kind() {
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
index 4ce37db428002..77c24adabe3a5 100644
--- a/compiler/rustc_trait_selection/src/traits/select/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -1760,12 +1760,13 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
 
         if is_match {
             let generics = self.tcx().generics_of(obligation.predicate.def_id);
-            // FIXME(generic-associated-types): Addresses aggressive inference in #92917.
+            // FIXME(generic_associated_types): Addresses aggressive inference in #92917.
             // If this type is a GAT, and of the GAT args resolve to something new,
             // that means that we must have newly inferred something about the GAT.
             // We should give up in that case.
-            // FIXME(generic-associated-types): This only detects one layer of inference,
-            // which is probably not what we actually want, but fixing it causes some ambiguity:
+            //
+            // This only detects one layer of inference, which is probably not what we actually
+            // want, but fixing it causes some ambiguity:
             // <https://github.com/rust-lang/rust/issues/125196>.
             if !generics.is_own_empty()
                 && obligation.predicate.args[generics.parent_count..].iter().any(|&p| {
diff --git a/compiler/rustc_type_ir/src/inherent.rs b/compiler/rustc_type_ir/src/inherent.rs
index e6e6466766beb..ee4a8096462a0 100644
--- a/compiler/rustc_type_ir/src/inherent.rs
+++ b/compiler/rustc_type_ir/src/inherent.rs
@@ -298,6 +298,14 @@ pub trait GenericArg<I: Interner<GenericArg = Self>>:
     + From<I::Region>
     + From<I::Const>
 {
+    fn as_term(&self) -> Option<I::Term> {
+        match self.kind() {
+            ty::GenericArgKind::Lifetime(_) => None,
+            ty::GenericArgKind::Type(ty) => Some(ty.into()),
+            ty::GenericArgKind::Const(ct) => Some(ct.into()),
+        }
+    }
+
     fn as_type(&self) -> Option<I::Ty> {
         if let ty::GenericArgKind::Type(ty) = self.kind() { Some(ty) } else { None }
     }
diff --git a/compiler/rustc_type_ir/src/predicate.rs b/compiler/rustc_type_ir/src/predicate.rs
index b59495b93c836..f02d9c988c8de 100644
--- a/compiler/rustc_type_ir/src/predicate.rs
+++ b/compiler/rustc_type_ir/src/predicate.rs
@@ -682,6 +682,13 @@ impl<I: Interner> AliasTerm<I> {
     pub fn trait_ref(self, interner: I) -> TraitRef<I> {
         self.trait_ref_and_own_args(interner).0
     }
+
+    /// Extract the own args from this projection.
+    /// For example, if this is a projection of `<T as StreamingIterator>::Item<'a>`,
+    /// then this function would return the slice `['a]` as the own args.
+    pub fn own_args(self, interner: I) -> I::GenericArgsSlice {
+        self.trait_ref_and_own_args(interner).1
+    }
 }
 
 /// The following methods work only with inherent associated term projections.
diff --git a/library/alloc/src/raw_vec/mod.rs b/library/alloc/src/raw_vec/mod.rs
index a989e5b55b3d1..3e006a2d1bdf1 100644
--- a/library/alloc/src/raw_vec/mod.rs
+++ b/library/alloc/src/raw_vec/mod.rs
@@ -287,7 +287,7 @@ impl<T, A: Allocator> RawVec<T, A> {
     }
 
     #[inline]
-    pub(crate) fn non_null(&self) -> NonNull<T> {
+    pub(crate) const fn non_null(&self) -> NonNull<T> {
         self.inner.non_null()
     }
 
diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs
index a97912304c894..59879f23d7850 100644
--- a/library/alloc/src/vec/mod.rs
+++ b/library/alloc/src/vec/mod.rs
@@ -1816,10 +1816,10 @@ impl<T, A: Allocator> Vec<T, A> {
     /// [`as_ptr`]: Vec::as_ptr
     /// [`as_non_null`]: Vec::as_non_null
     #[unstable(feature = "box_vec_non_null", reason = "new API", issue = "130364")]
+    #[rustc_const_unstable(feature = "box_vec_non_null", reason = "new API", issue = "130364")]
     #[inline]
-    pub fn as_non_null(&mut self) -> NonNull<T> {
-        // SAFETY: A `Vec` always has a non-null pointer.
-        unsafe { NonNull::new_unchecked(self.as_mut_ptr()) }
+    pub const fn as_non_null(&mut self) -> NonNull<T> {
+        self.buf.non_null()
     }
 
     /// Returns a reference to the underlying allocator.
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index 64a7ec8906b6b..a56b9b67692f5 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -158,7 +158,6 @@
 #![feature(intra_doc_pointers)]
 #![feature(intrinsics)]
 #![feature(lang_items)]
-#![feature(let_chains)]
 #![feature(link_llvm_intrinsics)]
 #![feature(macro_metavar_expr)]
 #![feature(marker_trait_attr)]
diff --git a/library/core/src/pin.rs b/library/core/src/pin.rs
index ecfa723722d05..257424b355fbc 100644
--- a/library/core/src/pin.rs
+++ b/library/core/src/pin.rs
@@ -12,11 +12,11 @@
 //! "pinned," in that it has been permanently (until the end of its lifespan) attached to its
 //! location in memory, as though pinned to a pinboard. Pinning a value is an incredibly useful
 //! building block for [`unsafe`] code to be able to reason about whether a raw pointer to the
-//! pinned value is still valid. [As we'll see later][drop-guarantee], this is necessarily from the
-//! time the value is first pinned until the end of its lifespan. This concept of "pinning" is
-//! necessary to implement safe interfaces on top of things like self-referential types and
-//! intrusive data structures which cannot currently be modeled in fully safe Rust using only
-//! borrow-checked [references][reference].
+//! pinned value is still valid. [As we'll see later][drop-guarantee], once a value is pinned,
+//! it is necessarily valid at its memory location until the end of its lifespan. This concept
+//! of "pinning" is necessary to implement safe interfaces on top of things like self-referential
+//! types and intrusive data structures which cannot currently be modeled in fully safe Rust using
+//! only borrow-checked [references][reference].
 //!
 //! "Pinning" allows us to put a *value* which exists at some location in memory into a state where
 //! safe code cannot *move* that value to a different location in memory or otherwise invalidate it
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index 0bb40ee4b3177..d1f6b450214f9 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -304,7 +304,6 @@
 #![feature(iter_advance_by)]
 #![feature(iter_next_chunk)]
 #![feature(lang_items)]
-#![feature(let_chains)]
 #![feature(link_cfg)]
 #![feature(linkage)]
 #![feature(macro_metavar_expr_concat)]
diff --git a/library/std/src/os/wasi/fs.rs b/library/std/src/os/wasi/fs.rs
index 34f0e89f2f1ee..5ea91dd6521ad 100644
--- a/library/std/src/os/wasi/fs.rs
+++ b/library/std/src/os/wasi/fs.rs
@@ -72,7 +72,6 @@ pub trait FileExt {
     /// If this function returns an error, it is unspecified how many bytes it
     /// has read, but it will never read more than would be necessary to
     /// completely fill the buffer.
-    #[stable(feature = "rw_exact_all_at", since = "1.33.0")]
     fn read_exact_at(&self, mut buf: &mut [u8], mut offset: u64) -> io::Result<()> {
         while !buf.is_empty() {
             match self.read_at(buf, offset) {
@@ -144,7 +143,6 @@ pub trait FileExt {
     /// non-[`io::ErrorKind::Interrupted`] kind that [`write_at`] returns.
     ///
     /// [`write_at`]: FileExt::write_at
-    #[stable(feature = "rw_exact_all_at", since = "1.33.0")]
     fn write_all_at(&self, mut buf: &[u8], mut offset: u64) -> io::Result<()> {
         while !buf.is_empty() {
             match self.write_at(buf, offset) {
diff --git a/library/std/src/os/windows/process.rs b/library/std/src/os/windows/process.rs
index a084f452e55d0..c223eee95b5f5 100644
--- a/library/std/src/os/windows/process.rs
+++ b/library/std/src/os/windows/process.rs
@@ -344,6 +344,27 @@ pub trait CommandExt: Sealed {
         &mut self,
         attribute_list: &ProcThreadAttributeList<'_>,
     ) -> io::Result<process::Child>;
+
+    /// When true, sets the `STARTF_RUNFULLSCREEN` flag on the [STARTUPINFO][1] struct before passing it to `CreateProcess`.
+    ///
+    /// [1]: https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/ns-processthreadsapi-startupinfoa
+    #[unstable(feature = "windows_process_extensions_startupinfo", issue = "141010")]
+    fn startupinfo_fullscreen(&mut self, enabled: bool) -> &mut process::Command;
+
+    /// When true, sets the `STARTF_UNTRUSTEDSOURCE` flag on the [STARTUPINFO][1] struct before passing it to `CreateProcess`.
+    ///
+    /// [1]: https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/ns-processthreadsapi-startupinfoa
+    #[unstable(feature = "windows_process_extensions_startupinfo", issue = "141010")]
+    fn startupinfo_untrusted_source(&mut self, enabled: bool) -> &mut process::Command;
+
+    /// When specified, sets the following flags on the [STARTUPINFO][1] struct before passing it to `CreateProcess`:
+    /// - If `Some(true)`, sets `STARTF_FORCEONFEEDBACK`
+    /// - If `Some(false)`, sets `STARTF_FORCEOFFFEEDBACK`
+    /// - If `None`, does not set any flags
+    ///
+    /// [1]: https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/ns-processthreadsapi-startupinfoa
+    #[unstable(feature = "windows_process_extensions_startupinfo", issue = "141010")]
+    fn startupinfo_force_feedback(&mut self, enabled: Option<bool>) -> &mut process::Command;
 }
 
 #[stable(feature = "windows_process_extensions", since = "1.16.0")]
@@ -385,6 +406,21 @@ impl CommandExt for process::Command {
             .spawn_with_attributes(sys::process::Stdio::Inherit, true, Some(attribute_list))
             .map(process::Child::from_inner)
     }
+
+    fn startupinfo_fullscreen(&mut self, enabled: bool) -> &mut process::Command {
+        self.as_inner_mut().startupinfo_fullscreen(enabled);
+        self
+    }
+
+    fn startupinfo_untrusted_source(&mut self, enabled: bool) -> &mut process::Command {
+        self.as_inner_mut().startupinfo_untrusted_source(enabled);
+        self
+    }
+
+    fn startupinfo_force_feedback(&mut self, enabled: Option<bool>) -> &mut process::Command {
+        self.as_inner_mut().startupinfo_force_feedback(enabled);
+        self
+    }
 }
 
 #[unstable(feature = "windows_process_extensions_main_thread_handle", issue = "96723")]
diff --git a/library/std/src/sys/fs/unix.rs b/library/std/src/sys/fs/unix.rs
index 863358596c199..a3e520fdeef43 100644
--- a/library/std/src/sys/fs/unix.rs
+++ b/library/std/src/sys/fs/unix.rs
@@ -1498,11 +1498,10 @@ impl File {
             None => Ok(libc::timespec { tv_sec: 0, tv_nsec: libc::UTIME_OMIT as _ }),
         };
         cfg_if::cfg_if! {
-            if #[cfg(any(target_os = "redox", target_os = "espidf", target_os = "horizon", target_os = "vxworks", target_os = "nuttx"))] {
+            if #[cfg(any(target_os = "redox", target_os = "espidf", target_os = "horizon", target_os = "nuttx"))] {
                 // Redox doesn't appear to support `UTIME_OMIT`.
                 // ESP-IDF and HorizonOS do not support `futimens` at all and the behavior for those OS is therefore
                 // the same as for Redox.
-                // `futimens` and `UTIME_OMIT` are a work in progress for vxworks.
                 let _ = times;
                 Err(io::const_error!(
                     io::ErrorKind::Unsupported,
diff --git a/library/std/src/sys/pal/unix/thread.rs b/library/std/src/sys/pal/unix/thread.rs
index afda7c65e1084..d8b189413f4a3 100644
--- a/library/std/src/sys/pal/unix/thread.rs
+++ b/library/std/src/sys/pal/unix/thread.rs
@@ -222,16 +222,8 @@ impl Thread {
 
     #[cfg(target_os = "vxworks")]
     pub fn set_name(name: &CStr) {
-        // FIXME(libc): adding real STATUS, ERROR type eventually.
-        unsafe extern "C" {
-            fn taskNameSet(task_id: libc::TASK_ID, task_name: *mut libc::c_char) -> libc::c_int;
-        }
-
-        //  VX_TASK_NAME_LEN is 31 in VxWorks 7.
-        const VX_TASK_NAME_LEN: usize = 31;
-
-        let mut name = truncate_cstr::<{ VX_TASK_NAME_LEN }>(name);
-        let res = unsafe { taskNameSet(libc::taskIdSelf(), name.as_mut_ptr()) };
+        let mut name = truncate_cstr::<{ libc::VX_TASK_RENAME_LENGTH - 1 }>(name);
+        let res = unsafe { libc::taskNameSet(libc::taskIdSelf(), name.as_mut_ptr()) };
         debug_assert_eq!(res, libc::OK);
     }
 
diff --git a/library/std/src/sys/process/windows.rs b/library/std/src/sys/process/windows.rs
index 4acd753eec915..1ee3fbd285f52 100644
--- a/library/std/src/sys/process/windows.rs
+++ b/library/std/src/sys/process/windows.rs
@@ -155,6 +155,9 @@ pub struct Command {
     stdout: Option<Stdio>,
     stderr: Option<Stdio>,
     force_quotes_enabled: bool,
+    startupinfo_fullscreen: bool,
+    startupinfo_untrusted_source: bool,
+    startupinfo_force_feedback: Option<bool>,
 }
 
 pub enum Stdio {
@@ -186,6 +189,9 @@ impl Command {
             stdout: None,
             stderr: None,
             force_quotes_enabled: false,
+            startupinfo_fullscreen: false,
+            startupinfo_untrusted_source: false,
+            startupinfo_force_feedback: None,
         }
     }
 
@@ -222,6 +228,18 @@ impl Command {
         self.args.push(Arg::Raw(command_str_to_append.to_os_string()))
     }
 
+    pub fn startupinfo_fullscreen(&mut self, enabled: bool) {
+        self.startupinfo_fullscreen = enabled;
+    }
+
+    pub fn startupinfo_untrusted_source(&mut self, enabled: bool) {
+        self.startupinfo_untrusted_source = enabled;
+    }
+
+    pub fn startupinfo_force_feedback(&mut self, enabled: Option<bool>) {
+        self.startupinfo_force_feedback = enabled;
+    }
+
     pub fn get_program(&self) -> &OsStr {
         &self.program
     }
@@ -343,6 +361,24 @@ impl Command {
             si.wShowWindow = cmd_show;
         }
 
+        if self.startupinfo_fullscreen {
+            si.dwFlags |= c::STARTF_RUNFULLSCREEN;
+        }
+
+        if self.startupinfo_untrusted_source {
+            si.dwFlags |= c::STARTF_UNTRUSTEDSOURCE;
+        }
+
+        match self.startupinfo_force_feedback {
+            Some(true) => {
+                si.dwFlags |= c::STARTF_FORCEONFEEDBACK;
+            }
+            Some(false) => {
+                si.dwFlags |= c::STARTF_FORCEOFFFEEDBACK;
+            }
+            None => {}
+        }
+
         let si_ptr: *mut c::STARTUPINFOW;
 
         let mut si_ex;
diff --git a/src/doc/rustc-dev-guide/README.md b/src/doc/rustc-dev-guide/README.md
index 08158801788c9..0425c15f83c1c 100644
--- a/src/doc/rustc-dev-guide/README.md
+++ b/src/doc/rustc-dev-guide/README.md
@@ -91,6 +91,16 @@ Older versions of `josh-proxy` may not round trip commits losslessly so it is im
 3) Push the branch to your fork and create a PR into `rustc-dev-guide`
 
 ### Push changes from this repository into `rust-lang/rust`
+
+NOTE: If you use Git protocol to push to your fork of `rust-lang/rust`,
+ensure that you have this entry in your Git config,
+else the 2 steps that follow would prompt for a username and password:
+
+```
+[url "git@github.com:"]
+insteadOf = "https://github.com/"
+```
+
 1) Run the push command to create a branch named `<branch-name>` in a `rustc` fork under the `<gh-username>` account
     ```
     cargo run --manifest-path josh-sync/Cargo.toml rustc-push <branch-name> <gh-username>
diff --git a/src/doc/rustc-dev-guide/ci/date-check/Cargo.lock b/src/doc/rustc-dev-guide/ci/date-check/Cargo.lock
index 6326b2daf12c0..7107547332f13 100644
--- a/src/doc/rustc-dev-guide/ci/date-check/Cargo.lock
+++ b/src/doc/rustc-dev-guide/ci/date-check/Cargo.lock
@@ -1,6 +1,6 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 3
+version = 4
 
 [[package]]
 name = "aho-corasick"
@@ -28,21 +28,24 @@ dependencies = [
 
 [[package]]
 name = "autocfg"
-version = "1.3.0"
+version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0"
+checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
 
 [[package]]
 name = "bumpalo"
-version = "3.16.0"
+version = "3.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c"
+checksum = "1628fb46dfa0b37568d12e5edd512553eccf6a22a78e8bde00bb4aed84d5bdbf"
 
 [[package]]
 name = "cc"
-version = "1.0.106"
+version = "1.2.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "066fce287b1d4eafef758e89e09d724a24808a9196fe9756b8ca90e86d0719a2"
+checksum = "32db95edf998450acc7881c932f94cd9b05c87b4b2599e8bab064753da4acfd1"
+dependencies = [
+ "shlex",
+]
 
 [[package]]
 name = "cfg-if"
@@ -52,27 +55,27 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "chrono"
-version = "0.4.38"
+version = "0.4.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401"
+checksum = "c469d952047f47f91b68d1cba3f10d63c11d73e4636f24f08daf0278abf01c4d"
 dependencies = [
  "android-tzdata",
  "iana-time-zone",
  "js-sys",
  "num-traits",
  "wasm-bindgen",
- "windows-targets",
+ "windows-link",
 ]
 
 [[package]]
 name = "core-foundation-sys"
-version = "0.8.6"
+version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
 
 [[package]]
 name = "date-check"
-version = "0.1.0"
+version = "0.0.0"
 dependencies = [
  "chrono",
  "glob",
@@ -81,20 +84,21 @@ dependencies = [
 
 [[package]]
 name = "glob"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
+checksum = "a8d1add55171497b4705a648c6b583acafb01d58050a51727785f0b2c8e0a2b2"
 
 [[package]]
 name = "iana-time-zone"
-version = "0.1.60"
+version = "0.1.63"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7ffbb5a1b541ea2561f8c41c087286cc091e21e556a4f09a8f6cbf17b69b141"
+checksum = "b0c919e5debc312ad217002b8048a17b7d83f80703865bbfcfebb0458b0b27d8"
 dependencies = [
  "android_system_properties",
  "core-foundation-sys",
  "iana-time-zone-haiku",
  "js-sys",
+ "log",
  "wasm-bindgen",
  "windows-core",
 ]
@@ -110,24 +114,25 @@ dependencies = [
 
 [[package]]
 name = "js-sys"
-version = "0.3.69"
+version = "0.3.77"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29c15563dc2726973df627357ce0c9ddddbea194836909d655df6a75d2cf296d"
+checksum = "1cfaf33c695fc6e08064efbc1f72ec937429614f25eef83af942d0e227c3a28f"
 dependencies = [
+ "once_cell",
  "wasm-bindgen",
 ]
 
 [[package]]
 name = "libc"
-version = "0.2.155"
+version = "0.2.172"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
+checksum = "d750af042f7ef4f724306de029d18836c26c1765a54a6a3f094cbd23a7267ffa"
 
 [[package]]
 name = "log"
-version = "0.4.22"
+version = "0.4.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
+checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
 
 [[package]]
 name = "memchr"
@@ -146,33 +151,33 @@ dependencies = [
 
 [[package]]
 name = "once_cell"
-version = "1.19.0"
+version = "1.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.86"
+version = "1.0.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.36"
+version = "1.0.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
+checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"
 dependencies = [
  "proc-macro2",
 ]
 
 [[package]]
 name = "regex"
-version = "1.10.5"
+version = "1.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b91213439dad192326a0d7c6ee3955910425f441d7038e0d6933b0aec5c4517f"
+checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -182,9 +187,9 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.4.7"
+version = "0.4.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38caf58cc5ef2fed281f89292ef23f6365465ed9a41b7a7754eb4e26496c92df"
+checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -193,15 +198,27 @@ dependencies = [
 
 [[package]]
 name = "regex-syntax"
-version = "0.8.4"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a66a03ae7c801facd77a29370b4faec201768915ac14a721ba36f20bc9c209b"
+checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
+
+[[package]]
+name = "rustversion"
+version = "1.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eded382c5f5f786b989652c49544c4877d9f015cc22e145a5ea8ea66c2921cd2"
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
 [[package]]
 name = "syn"
-version = "2.0.70"
+version = "2.0.101"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f0209b68b3613b093e0ec905354eccaedcfe83b8cb37cbdeae64026c3064c16"
+checksum = "8ce2b7fc941b3a24138a0a7cf8e858bfc6a992e7978a068a5c760deb0ed43caf"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -210,29 +227,30 @@ dependencies = [
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.12"
+version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
+checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.92"
+version = "0.2.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8"
+checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5"
 dependencies = [
  "cfg-if",
+ "once_cell",
+ "rustversion",
  "wasm-bindgen-macro",
 ]
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.92"
+version = "0.2.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da"
+checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6"
 dependencies = [
  "bumpalo",
  "log",
- "once_cell",
  "proc-macro2",
  "quote",
  "syn",
@@ -241,9 +259,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.92"
+version = "0.2.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726"
+checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -251,9 +269,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.92"
+version = "0.2.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7"
+checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -264,79 +282,68 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.92"
+version = "0.2.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96"
+checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d"
+dependencies = [
+ "unicode-ident",
+]
 
 [[package]]
 name = "windows-core"
-version = "0.52.0"
+version = "0.61.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
+checksum = "4763c1de310c86d75a878046489e2e5ba02c649d185f21c67d4cf8a56d098980"
 dependencies = [
- "windows-targets",
+ "windows-implement",
+ "windows-interface",
+ "windows-link",
+ "windows-result",
+ "windows-strings",
 ]
 
 [[package]]
-name = "windows-targets"
-version = "0.52.6"
+name = "windows-implement"
+version = "0.60.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+checksum = "a47fddd13af08290e67f4acabf4b459f647552718f683a7b415d290ac744a836"
 dependencies = [
- "windows_aarch64_gnullvm",
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_gnullvm",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
- "windows_x86_64_msvc",
+ "proc-macro2",
+ "quote",
+ "syn",
 ]
 
 [[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
-
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
-
-[[package]]
-name = "windows_i686_gnu"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
-
-[[package]]
-name = "windows_i686_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.52.6"
+name = "windows-interface"
+version = "0.59.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+checksum = "bd9211b69f8dcdfa817bfd14bf1c97c9188afa36f4750130fcdf3f400eca9fa8"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
 
 [[package]]
-name = "windows_x86_64_gnu"
-version = "0.52.6"
+name = "windows-link"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+checksum = "76840935b766e1b0a05c0066835fb9ec80071d4c09a16f6bd5f7e655e3c14c38"
 
 [[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.52.6"
+name = "windows-result"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+checksum = "c64fd11a4fd95df68efcfee5f44a294fe71b8bc6a91993e2791938abcc712252"
+dependencies = [
+ "windows-link",
+]
 
 [[package]]
-name = "windows_x86_64_msvc"
-version = "0.52.6"
+name = "windows-strings"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+checksum = "7a2ba9642430ee452d5a7aa78d72907ebe8cfda358e8cb7918a2050581322f97"
+dependencies = [
+ "windows-link",
+]
diff --git a/src/doc/rustc-dev-guide/ci/date-check/Cargo.toml b/src/doc/rustc-dev-guide/ci/date-check/Cargo.toml
index 472529511d062..f49e6d0db940e 100644
--- a/src/doc/rustc-dev-guide/ci/date-check/Cargo.toml
+++ b/src/doc/rustc-dev-guide/ci/date-check/Cargo.toml
@@ -1,10 +1,6 @@
 [package]
 name = "date-check"
-version = "0.1.0"
-authors = ["Noah Lev <camelidcamel@gmail.com>"]
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+edition = "2024"
 
 [dependencies]
 glob = "0.3"
diff --git a/src/doc/rustc-dev-guide/ci/date-check/src/main.rs b/src/doc/rustc-dev-guide/ci/date-check/src/main.rs
index 9af69dbbf3f5c..0a32f4e9b7b66 100644
--- a/src/doc/rustc-dev-guide/ci/date-check/src/main.rs
+++ b/src/doc/rustc-dev-guide/ci/date-check/src/main.rs
@@ -114,7 +114,7 @@ fn filter_dates(
 fn main() {
     let mut args = env::args();
     if args.len() == 1 {
-        eprintln!("error: expected root Markdown directory as CLI argument");
+        eprintln!("error: expected root of Markdown directory as CLI argument");
         process::exit(1);
     }
     let root_dir = args.nth(1).unwrap();
diff --git a/src/doc/rustc-dev-guide/josh-sync/Cargo.lock b/src/doc/rustc-dev-guide/josh-sync/Cargo.lock
index 844518628c437..a8183a740db3b 100644
--- a/src/doc/rustc-dev-guide/josh-sync/Cargo.lock
+++ b/src/doc/rustc-dev-guide/josh-sync/Cargo.lock
@@ -161,7 +161,7 @@ checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
 
 [[package]]
 name = "josh-sync"
-version = "0.1.0"
+version = "0.0.0"
 dependencies = [
  "anyhow",
  "clap",
diff --git a/src/doc/rustc-dev-guide/josh-sync/Cargo.toml b/src/doc/rustc-dev-guide/josh-sync/Cargo.toml
index 81d0d1ebd22d8..1f8bf2a009333 100644
--- a/src/doc/rustc-dev-guide/josh-sync/Cargo.toml
+++ b/src/doc/rustc-dev-guide/josh-sync/Cargo.toml
@@ -1,7 +1,6 @@
 [package]
 name = "josh-sync"
-version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 [dependencies]
 anyhow = "1.0.95"
diff --git a/src/doc/rustc-dev-guide/josh-sync/src/main.rs b/src/doc/rustc-dev-guide/josh-sync/src/main.rs
index 175f016f73907..aeedee5be22d1 100644
--- a/src/doc/rustc-dev-guide/josh-sync/src/main.rs
+++ b/src/doc/rustc-dev-guide/josh-sync/src/main.rs
@@ -1,4 +1,5 @@
 use clap::Parser;
+
 use crate::sync::{GitSync, RustcPullError};
 
 mod sync;
@@ -11,10 +12,7 @@ enum Args {
     /// Push changes from `rustc-dev-guide` to the given `branch` of a `rustc` fork under the given
     /// GitHub `username`.
     /// The pushed branch should then be merged into the `rustc` repository.
-    RustcPush {
-        branch: String,
-        github_username: String
-    }
+    RustcPush { branch: String, github_username: String },
 }
 
 fn main() -> anyhow::Result<()> {
diff --git a/src/doc/rustc-dev-guide/josh-sync/src/sync.rs b/src/doc/rustc-dev-guide/josh-sync/src/sync.rs
index 41d96397faaba..ed38d1403a02b 100644
--- a/src/doc/rustc-dev-guide/josh-sync/src/sync.rs
+++ b/src/doc/rustc-dev-guide/josh-sync/src/sync.rs
@@ -1,10 +1,11 @@
+use std::io::Write;
 use std::ops::Not;
 use std::path::PathBuf;
-use std::{env, net, process};
-use std::io::Write;
 use std::time::Duration;
-use anyhow::{anyhow, bail, Context};
-use xshell::{cmd, Shell};
+use std::{env, net, process};
+
+use anyhow::{Context, anyhow, bail};
+use xshell::{Shell, cmd};
 
 /// Used for rustc syncs.
 const JOSH_FILTER: &str = ":/src/doc/rustc-dev-guide";
@@ -15,10 +16,13 @@ pub enum RustcPullError {
     /// No changes are available to be pulled.
     NothingToPull,
     /// A rustc-pull has failed, probably a git operation error has occurred.
-    PullFailed(anyhow::Error)
+    PullFailed(anyhow::Error),
 }
 
-impl<E> From<E> for RustcPullError where E: Into<anyhow::Error> {
+impl<E> From<E> for RustcPullError
+where
+    E: Into<anyhow::Error>,
+{
     fn from(error: E) -> Self {
         Self::PullFailed(error.into())
     }
@@ -32,9 +36,7 @@ pub struct GitSync {
 /// (https://github.com/rust-lang/miri/blob/6a68a79f38064c3bc30617cca4bdbfb2c336b140/miri-script/src/commands.rs#L236).
 impl GitSync {
     pub fn from_current_dir() -> anyhow::Result<Self> {
-        Ok(Self {
-            dir: std::env::current_dir()?
-        })
+        Ok(Self { dir: std::env::current_dir()? })
     }
 
     pub fn rustc_pull(&self, commit: Option<String>) -> Result<(), RustcPullError> {
@@ -51,7 +53,10 @@ impl GitSync {
         })?;
         // Make sure the repo is clean.
         if cmd!(sh, "git status --untracked-files=no --porcelain").read()?.is_empty().not() {
-            return Err(anyhow::anyhow!("working directory must be clean before performing rustc pull").into());
+            return Err(anyhow::anyhow!(
+                "working directory must be clean before performing rustc pull"
+            )
+            .into());
         }
         // Make sure josh is running.
         let josh = Self::start_josh()?;
@@ -94,7 +99,8 @@ impl GitSync {
         };
         let num_roots_before = num_roots()?;
 
-        let sha = cmd!(sh, "git rev-parse HEAD").output().context("FAILED to get current commit")?.stdout;
+        let sha =
+            cmd!(sh, "git rev-parse HEAD").output().context("FAILED to get current commit")?.stdout;
 
         // Merge the fetched commit.
         const MERGE_COMMIT_MESSAGE: &str = "Merge from rustc";
@@ -102,18 +108,24 @@ impl GitSync {
             .run()
             .context("FAILED to merge new commits, something went wrong")?;
 
-        let current_sha = cmd!(sh, "git rev-parse HEAD").output().context("FAILED to get current commit")?.stdout;
+        let current_sha =
+            cmd!(sh, "git rev-parse HEAD").output().context("FAILED to get current commit")?.stdout;
         if current_sha == sha {
             cmd!(sh, "git reset --hard HEAD^")
                 .run()
                 .expect("FAILED to clean up after creating the preparation commit");
-            eprintln!("No merge was performed, no changes to pull were found. Rolled back the preparation commit.");
+            eprintln!(
+                "No merge was performed, no changes to pull were found. Rolled back the preparation commit."
+            );
             return Err(RustcPullError::NothingToPull);
         }
 
         // Check that the number of roots did not increase.
         if num_roots()? != num_roots_before {
-            return Err(anyhow::anyhow!("Josh created a new root commit. This is probably not the history you want.").into());
+            return Err(anyhow::anyhow!(
+                "Josh created a new root commit. This is probably not the history you want."
+            )
+            .into());
         }
 
         drop(josh);
diff --git a/src/doc/rustc-dev-guide/rust-version b/src/doc/rustc-dev-guide/rust-version
index 66b4fe2bf3bf0..5e4266f61da2a 100644
--- a/src/doc/rustc-dev-guide/rust-version
+++ b/src/doc/rustc-dev-guide/rust-version
@@ -1 +1 @@
-0c33fe2c3d3eecadd17a84b110bb067288a64f1c
+414482f6a0d4e7290f614300581a0b55442552a3
diff --git a/src/doc/rustc-dev-guide/src/macro-expansion.md b/src/doc/rustc-dev-guide/src/macro-expansion.md
index ebab56ad20af0..a90f717004f0b 100644
--- a/src/doc/rustc-dev-guide/src/macro-expansion.md
+++ b/src/doc/rustc-dev-guide/src/macro-expansion.md
@@ -2,9 +2,6 @@
 
 <!-- toc -->
 
-> N.B. [`rustc_ast`], [`rustc_expand`], and [`rustc_builtin_macros`] are all
-> undergoing refactoring, so some of the links in this chapter may be broken.
-
 Rust has a very powerful macro system. In the previous chapter, we saw how
 the parser sets aside macros to be expanded (using temporary [placeholders]).
 This chapter is about the process of expanding those macros iteratively until
@@ -12,9 +9,6 @@ we have a complete [*Abstract Syntax Tree* (AST)][ast] for our crate with no
 unexpanded macros (or a compile error).
 
 [ast]: ./ast-validation.md
-[`rustc_ast`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast/index.html
-[`rustc_expand`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_expand/index.html
-[`rustc_builtin_macros`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_builtin_macros/index.html
 [placeholders]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_expand/placeholders/index.html
 
 First, we discuss the algorithm that expands and integrates macro output into
diff --git a/src/doc/rustc-dev-guide/src/rustdoc-internals.md b/src/doc/rustc-dev-guide/src/rustdoc-internals.md
index 7f1c83e00f98d..80421b85bf055 100644
--- a/src/doc/rustc-dev-guide/src/rustdoc-internals.md
+++ b/src/doc/rustc-dev-guide/src/rustdoc-internals.md
@@ -55,8 +55,8 @@ The first step in [`clean::utils::krate`][ck1] is to invoke
   * inlining public `use` exports of private items, or showing a "Reexport"
     line in the module page
   * inlining items with `#[doc(hidden)]` if the base item is hidden but the
-  * showing `#[macro_export]`-ed macros at the crate root, regardless of where
-    they're defined reexport is not
+  * showing `#[macro_export]`-ed macros at the crate root, regardless of whether
+    they're defined as a reexport or not
 
 After this step, `clean::krate` invokes [`clean_doc_module`], which actually
 converts the `HIR` items to the cleaned [`AST`][ast]. This is also the step where cross-
diff --git a/src/doc/rustc-dev-guide/src/serialization.md b/src/doc/rustc-dev-guide/src/serialization.md
index 670a37ffb0a97..47667061edaed 100644
--- a/src/doc/rustc-dev-guide/src/serialization.md
+++ b/src/doc/rustc-dev-guide/src/serialization.md
@@ -169,7 +169,7 @@ The `LazyArray<[T]>` and `LazyTable<I, T>` types provide some functionality over
   than the one being read.
 
 **note**: `LazyValue<T>` does not cache its value after being deserialized the
-first time. Instead the query system its self is the main way of caching these
+first time. Instead the query system itself is the main way of caching these
 results.
 
 [`LazyArray<T>`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_metadata/rmeta/struct.LazyValue.html
diff --git a/src/doc/rustc-dev-guide/src/tests/best-practices.md b/src/doc/rustc-dev-guide/src/tests/best-practices.md
index 2bdc7f3a2431b..be00207e3fb93 100644
--- a/src/doc/rustc-dev-guide/src/tests/best-practices.md
+++ b/src/doc/rustc-dev-guide/src/tests/best-practices.md
@@ -70,6 +70,11 @@ related tests.
 > //!
 > //! Regression test for <https://github.com/rust-lang/rust/issues/123456>.
 > ```
+>
+> One exception to this rule is [crashes tests]: there it is canonical that
+> tests are named only after issue numbers because its purpose is to track
+> snippets from which issues no longer ICE/crash, and they would either be
+> removed or converted into proper ui/other tests in the fix PRs.
 
 ## Test organization
 
@@ -194,3 +199,4 @@ See [LLVM FileCheck guide][FileCheck] for details.
 [compiletest directives]: ./directives.md
 [`run-make`]: ./compiletest.md#run-make-tests
 [FileCheck]: https://llvm.org/docs/CommandGuide/FileCheck.html
+[crashes tests]: ./compiletest.md#crashes-tests
diff --git a/src/doc/rustc-dev-guide/src/tests/intro.md b/src/doc/rustc-dev-guide/src/tests/intro.md
index 7bf30b106b43b..c55d60f4a5c7b 100644
--- a/src/doc/rustc-dev-guide/src/tests/intro.md
+++ b/src/doc/rustc-dev-guide/src/tests/intro.md
@@ -102,11 +102,12 @@ by passing a path to a book to `./x test`.
 
 ### Documentation link checker
 
-Links across all documentation is validated with a link checker tool.
+Links across all documentation is validated with a link checker tool,
+and it can be invoked so:
 
-> Example: `./x test src/tools/linkchecker`
-
-> Example: `./x test linkchecker`
+```console
+./x test linkchecker
+```
 
 This requires building all of the documentation, which might take a while.
 
diff --git a/src/doc/rustc-dev-guide/src/traits/unsize.md b/src/doc/rustc-dev-guide/src/traits/unsize.md
index dd57a1b079673..98a4452574817 100644
--- a/src/doc/rustc-dev-guide/src/traits/unsize.md
+++ b/src/doc/rustc-dev-guide/src/traits/unsize.md
@@ -32,21 +32,21 @@ Built-in implementations are provided for:
 
 ## Structural implementations
 
-There are two implementations of `Unsize` which can be thought of as
+There is one implementation of `Unsize` which can be thought of as
 structural:
-* `(A1, A2, .., An): Unsize<(A1, A2, .., U)>` given `An: Unsize<U>`, which
-  allows the tail field of a tuple to be unsized. This is gated behind the
-  [`unsized_tuple_coercion`] feature.
 * `Struct<.., Pi, .., Pj, ..>: Unsize<Struct<.., Ui, .., Uj, ..>>` given 
   `TailField<Pi, .., Pj>: Unsize<Ui, .. Uj>`, which allows the tail field of a
   struct to be unsized if it is the only field that mentions generic parameters
   `Pi`, .., `Pj` (which don't need to be contiguous).
 
-The rules for the latter implementation are slightly complicated, since they
+The rules for struct unsizing are slightly complicated, since they
 may allow more than one parameter to be changed (not necessarily unsized) and
 are best stated in terms of the tail field of the struct.
 
-[`unsized_tuple_coercion`]: https://doc.rust-lang.org/beta/unstable-book/language-features/unsized-tuple-coercion.html
+(Tuple unsizing was previously implemented behind the feature gate
+`unsized_tuple_coercion`, but the implementation was removed by [#137728].)
+
+[#137728]: https://github.com/rust-lang/rust/pull/137728
 
 ## Upcasting implementations
 
diff --git a/src/doc/rustc-dev-guide/src/ty-fold.md b/src/doc/rustc-dev-guide/src/ty-fold.md
index d4d0952fcc340..23253022ffe27 100644
--- a/src/doc/rustc-dev-guide/src/ty-fold.md
+++ b/src/doc/rustc-dev-guide/src/ty-fold.md
@@ -1,26 +1,28 @@
+<!-- date-check: may 2024 -->
 # `TypeFoldable` and `TypeFolder`
 
-In the previous chapter we discussed instantiating binders. This must involves looking at everything inside of a `Early/Binder`
-to find any usages of the bound vars in order to replace them. Binders can wrap an arbitrary rust type `T` not just a `Ty` so
-how do we implement the `instantiate` methods on the `Early/Binder` types.
+In [a previous chapter], we discussed instantiating binders.
+This involves looking at everything inside of a `Early(Binder)`
+to find any usages of the bound vars in order to replace them.
+Binders can wrap an arbitrary Rust type `T`, not just a `Ty`.
+So, how do we implement the `instantiate` methods on the `Early/Binder` types?
 
 The answer is a couple of traits:
-[`TypeFoldable`](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/fold/trait.TypeFoldable.html)
+[`TypeFoldable`]
 and
-[`TypeFolder`](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/fold/trait.TypeFolder.html).
+[`TypeFolder`].
 
 - `TypeFoldable` is implemented by types that embed type information. It allows you to recursively
   process the contents of the `TypeFoldable` and do stuff to them.
 - `TypeFolder` defines what you want to do with the types you encounter while processing the
   `TypeFoldable`.
 
-For example, the `TypeFolder` trait has a method
-[`fold_ty`](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/fold/trait.TypeFolder.html#method.fold_ty)
-that takes a type as input and returns a new type as a result. `TypeFoldable` invokes the
-`TypeFolder` `fold_foo` methods on itself, giving the `TypeFolder` access to its contents (the
-types, regions, etc that are contained within).
+For example, the `TypeFolder` trait has a method [`fold_ty`]
+that takes a type as input and returns a new type as a result.
+`TypeFoldable` invokes the `TypeFolder` `fold_foo` methods on itself,
+giving the `TypeFolder` access to its contents (the types, regions, etc that are contained within).
 
-You can think of it with this analogy to the iterator combinators we have come to love in rust:
+You can think of it with this analogy to the iterator combinators we have come to love in Rust:
 
 ```rust,ignore
 vec.iter().map(|e1| foo(e2)).collect()
@@ -33,8 +35,7 @@ So to reiterate:
 - `TypeFolder`  is a trait that defines a “map” operation.
 - `TypeFoldable`  is a trait that is implemented by things that embed types.
 
-In the case of `subst`, we can see that it is implemented as a `TypeFolder`:
-[`ArgFolder`](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_type_ir/binder/struct.ArgFolder.html).
+In the case of `subst`, we can see that it is implemented as a `TypeFolder`: [`ArgFolder`].
 Looking at its implementation, we see where the actual substitutions are happening.
 
 However, you might also notice that the implementation calls this `super_fold_with` method. What is
@@ -88,17 +89,22 @@ things. We only want to do something when we reach a type. That means there may
 `TypeFoldable` types whose implementations basically just forward to their fields’ `TypeFoldable`
 implementations. Such implementations of `TypeFoldable` tend to be pretty tedious to write by hand.
 For this reason, there is a `derive` macro that allows you to `#![derive(TypeFoldable)]`. It is
-defined
-[here](https://github.com/rust-lang/rust/blob/master/compiler/rustc_macros/src/type_foldable.rs).
-
-**`subst`** In the case of substitutions the [actual
-folder](https://github.com/rust-lang/rust/blob/75ff3110ac6d8a0259023b83fd20d7ab295f8dd6/src/librustc_middle/ty/subst.rs#L440-L451)
-is going to be doing the indexing we’ve already mentioned. There we define a `Folder` and call
-`fold_with` on the `TypeFoldable` to process yourself.  Then
-[fold_ty](https://github.com/rust-lang/rust/blob/75ff3110ac6d8a0259023b83fd20d7ab295f8dd6/src/librustc_middle/ty/subst.rs#L512-L536)
-the method that process each type it looks for a `ty::Param` and for those it replaces it for
-something from the list of substitutions, otherwise recursively process the type.  To replace it,
-calls
-[ty_for_param](https://github.com/rust-lang/rust/blob/75ff3110ac6d8a0259023b83fd20d7ab295f8dd6/src/librustc_middle/ty/subst.rs#L552-L587)
+defined [here].
+
+**`subst`** In the case of substitutions the [actual folder]
+is going to be doing the indexing we’ve already mentioned.
+There we define a `Folder` and call `fold_with` on the `TypeFoldable` to process yourself.
+Then [fold_ty] the method that process each type it looks for a `ty::Param` and for those
+it replaces it for something from the list of substitutions, otherwise recursively process the type.
+To replace it, calls [ty_for_param]
 and all that does is index into the list of substitutions with the index of the `Param`.
 
+[a previous chapter]: ty_module/instantiating_binders.md
+[`TypeFoldable`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/trait.TypeFoldable.html
+[`TypeFolder`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/trait.TypeFolder.html
+[`fold_ty`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/trait.TypeFolder.html#method.fold_ty
+[`ArgFolder`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_type_ir/binder/struct.ArgFolder.html
+[here]: https://github.com/rust-lang/rust/blob/master/compiler/rustc_macros/src/type_foldable.rs
+[actual folder]: https://github.com/rust-lang/rust/blob/75ff3110ac6d8a0259023b83fd20d7ab295f8dd6/src/librustc_middle/ty/subst.rs#L440-L451
+[fold_ty]: https://github.com/rust-lang/rust/blob/75ff3110ac6d8a0259023b83fd20d7ab295f8dd6/src/librustc_middle/ty/subst.rs#L512-L536
+[ty_for_param]: https://github.com/rust-lang/rust/blob/75ff3110ac6d8a0259023b83fd20d7ab295f8dd6/src/librustc_middle/ty/subst.rs#L552-L587
diff --git a/src/etc/lldb_lookup.py b/src/etc/lldb_lookup.py
index f4ea904b7f50b..f512bf966dba1 100644
--- a/src/etc/lldb_lookup.py
+++ b/src/etc/lldb_lookup.py
@@ -42,6 +42,11 @@ def summary_lookup(valobj: lldb.SBValue, _dict: LLDBOpaque) -> str:
     if rust_type == RustType.STD_HASH_SET:
         return SizeSummaryProvider(valobj, _dict)
 
+    if rust_type == RustType.STD_BTREE_MAP:
+        return SizeSummaryProvider(valobj, _dict)
+    if rust_type == RustType.STD_BTREE_SET:
+        return SizeSummaryProvider(valobj, _dict)
+
     if rust_type == RustType.STD_RC:
         return StdRcSummaryProvider(valobj, _dict)
     if rust_type == RustType.STD_ARC:
@@ -105,6 +110,12 @@ def synthetic_lookup(valobj: lldb.SBValue, _dict: LLDBOpaque) -> object:
         else:
             return StdOldHashMapSyntheticProvider(hash_map, _dict, show_values=False)
 
+    if rust_type == RustType.STD_BTREE_MAP:
+        return StdBTreeMapSyntheticProvider(valobj, _dict)
+    if rust_type == RustType.STD_BTREE_SET:
+        btree_map = valobj.GetChildAtIndex(0)
+        return StdBTreeMapSyntheticProvider(btree_map, _dict, show_values=False)
+
     if rust_type == RustType.STD_RC:
         return StdRcSyntheticProvider(valobj, _dict)
     if rust_type == RustType.STD_ARC:
diff --git a/src/etc/lldb_providers.py b/src/etc/lldb_providers.py
index 98426e4242398..1c104d9c7a8f2 100644
--- a/src/etc/lldb_providers.py
+++ b/src/etc/lldb_providers.py
@@ -1151,6 +1151,130 @@ def has_children(self) -> bool:
         return True
 
 
+def children_of_node(node_ptr: SBValue, height: int):
+    def get_edges(node: SBValue) -> SBValue:
+        # BTreeMap implementation does ad-hoc polymorphism between LeafNode and InternalNode
+        # with raw pointers.
+        # https://github.com/rust-lang/rust/issues/90520#issuecomment-2211103129
+        # Implementing this the same way as the GDB provider with type casting fails
+        # because LLDB does not find the target type for some reason.
+        # Therefore, we manually do the pointer arithmetic to get the edges array
+        # and handle it as raw pointers later instead of MaybeUninit<NonNull<LeafNode<K,V>>>.
+        # We can do that because InternalNode is repr(C).
+        leaf_ptr_type = node.GetType()
+        # Array has a constant length of 2 * B
+        edges_arr_type = leaf_ptr_type.GetArrayType(12)
+        node_addr = node.unsigned
+        leaf_size = leaf_ptr_type.GetPointeeType().size
+        edges_addr = node_addr + leaf_size
+        return node.CreateValueFromAddress("edges", edges_addr, edges_arr_type)
+
+    def unwrap_item_from_array_of_maybe_uninit(arr: SBValue, index: int) -> SBValue:
+        element = arr.GetChildAtIndex(index)
+        return element.GetChildMemberWithName("value").GetChildMemberWithName("value")
+
+    if node_ptr.type.name.startswith("alloc::collections::btree::node::BoxedNode<"):
+        # BACKCOMPAT: rust 1.49
+        node_ptr = node_ptr.GetChildMemberWithName("ptr")
+
+    if not node_ptr.type.IsPointerType():
+        # After the first recursion, this method is called with a raw pointer type directly
+        # instead of NonNull<T>
+        node_ptr = unwrap_unique_or_non_null(node_ptr)
+
+    leaf = node_ptr.Dereference()
+    keys = leaf.GetChildMemberWithName("keys")
+    vals = leaf.GetChildMemberWithName("vals")
+    length = leaf.GetChildMemberWithName("len").unsigned
+    edges = get_edges(node_ptr) if height > 0 else None
+
+    for i in range(length + 1):
+        if height > 0:
+            child_ptr = edges.GetChildAtIndex(i)
+            yield from children_of_node(child_ptr, height - 1)
+        if i < length:
+            # Avoid "Cannot perform pointer math on incomplete type" on zero-sized arrays.
+            key_type_size = keys.type.size
+            val_type_size = vals.type.size
+            key = (
+                unwrap_item_from_array_of_maybe_uninit(keys, i)
+                if key_type_size > 0
+                else node_ptr.EvaluateExpression("()")
+            )
+            val = (
+                unwrap_item_from_array_of_maybe_uninit(vals, i)
+                if val_type_size > 0
+                else node_ptr.EvaluateExpression("()")
+            )
+            yield key, val
+
+
+class StdBTreeMapSyntheticProvider:
+    def __init__(self, valobj: SBValue, _dict: LLDBOpaque, show_values: bool = True):
+        self.valobj = valobj
+        self._dict = _dict
+        self.show_values = show_values
+
+    def num_children(self) -> int:
+        return self.size
+
+    def get_child_index(self, name: str) -> int:
+        index = name.lstrip("[").rstrip("]")
+        if index.isdigit():
+            return int(index)
+        else:
+            return -1
+
+    def get_child_at_index(self, index: int) -> SBValue:
+        key, value = self.items[index]
+        if self.show_values:
+            data = key.GetData()
+            assert data.Append(value.GetData()), "Failed to create key value pair"
+            return self.valobj.CreateValueFromData("[%s]" % index, data, self.pair_type)
+        return self.valobj.CreateValueFromData("[%s]" % index, key.GetData(), key.type)
+
+    def update(self) -> bool:
+        self.size = self.valobj.GetChildMemberWithName("length").unsigned
+        self.items = []
+
+        # Determine the type for the tuple (Key, Value)
+        # - get_template_args helper breaks on console because type is shown as
+        #   `core::marker::PhantomData<(&str, &str) *>`
+        # - Type lookup after get_template_args helper fails with codelldb for unclear reasons
+        # - Native `template_args[0]` from LLDB fails with codelldb and just says `T` if printed
+        #   on console
+        marker = self.valobj.GetChildMemberWithName("_marker")
+        marker_type = marker.GetType()
+        box = marker_type.GetTemplateArgumentType(0)
+        self.pair_type = box.GetPointeeType()
+
+        if self.size == 0:
+            return
+
+        root = self.valobj.GetChildMemberWithName("root")
+
+        if root.type.name.startswith("core::option::Option<"):
+            synthetic_children = root.children[0]
+            current_variant = synthetic_children.GetChildMemberWithName("$variant$")
+            root = current_variant.GetChildMemberWithName(
+                "value"
+            ).GetChildMemberWithName("__0")
+
+        height = root.GetChildMemberWithName("height")
+        node_ptr = root.GetChildMemberWithName("node")
+
+        self.items = [
+            (key, value) for key, value in children_of_node(node_ptr, height.unsigned)
+        ]
+
+        assert len(self.items) == self.size
+
+        return False
+
+    def has_children(self) -> bool:
+        return True
+
+
 def StdRcSummaryProvider(valobj: SBValue, _dict: LLDBOpaque) -> str:
     strong = valobj.GetChildMemberWithName("strong").GetValueAsUnsigned()
     weak = valobj.GetChildMemberWithName("weak").GetValueAsUnsigned()
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index b4210e7b51819..b4003044e207b 100644
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -11,7 +11,6 @@
 #![feature(if_let_guard)]
 #![feature(impl_trait_in_assoc_type)]
 #![feature(iter_intersperse)]
-#![feature(let_chains)]
 #![feature(never_type)]
 #![feature(round_char_boundary)]
 #![feature(test)]
diff --git a/src/tools/compiletest/src/runtest/debugger.rs b/src/tools/compiletest/src/runtest/debugger.rs
index a4103c5b4a9a4..7d0a47ac90867 100644
--- a/src/tools/compiletest/src/runtest/debugger.rs
+++ b/src/tools/compiletest/src/runtest/debugger.rs
@@ -111,6 +111,9 @@ impl DebuggerCommands {
 }
 
 /// Check that the pattern in `check_line` applies to `line`. Returns `true` if they do match.
+/// Note that this matching is lazy, i.e. matches as little as possible and thus might leave
+/// stuff unparsed, failing the check.
+/// This is different to usual regex or global matching that is typically eager.
 fn check_single_line(line: &str, check_line: &str) -> bool {
     // Allow check lines to leave parts unspecified (e.g., uninitialized
     // bits in the  wrong case of an enum) with the notation "[...]".
diff --git a/src/tools/tidy/src/issues.txt b/src/tools/tidy/src/issues.txt
index 2c20e21f451ab..1d0ddd56eec5d 100644
--- a/src/tools/tidy/src/issues.txt
+++ b/src/tools/tidy/src/issues.txt
@@ -1183,47 +1183,39 @@ ui/impl-trait/explicit-generic-args-with-impl-trait/issue-87718.rs
 ui/impl-trait/in-trait/issue-102140.rs
 ui/impl-trait/in-trait/issue-102301.rs
 ui/impl-trait/in-trait/issue-102571.rs
-ui/impl-trait/issue-100075-2.rs
-ui/impl-trait/issue-100075.rs
-ui/impl-trait/issue-100187.rs
-ui/impl-trait/issue-102605.rs
-ui/impl-trait/issue-103181-1.rs
-ui/impl-trait/issue-103181-2.rs
-ui/impl-trait/issue-103599.rs
-ui/impl-trait/issue-108591.rs
-ui/impl-trait/issue-108592.rs
-ui/impl-trait/issue-35668.rs
-ui/impl-trait/issue-36792.rs
-ui/impl-trait/issue-46959.rs
-ui/impl-trait/issue-49556.rs
-ui/impl-trait/issue-49579.rs
-ui/impl-trait/issue-49685.rs
-ui/impl-trait/issue-51185.rs
-ui/impl-trait/issue-54966.rs
-ui/impl-trait/issue-55872-1.rs
-ui/impl-trait/issue-55872-2.rs
-ui/impl-trait/issue-55872-3.rs
-ui/impl-trait/issue-55872.rs
-ui/impl-trait/issue-56445.rs
-ui/impl-trait/issue-68532.rs
-ui/impl-trait/issue-72911.rs
-ui/impl-trait/issue-87450.rs
-ui/impl-trait/issue-99073-2.rs
-ui/impl-trait/issue-99073.rs
-ui/impl-trait/issue-99642-2.rs
-ui/impl-trait/issue-99642.rs
-ui/impl-trait/issue-99914.rs
+ui/impl-trait/issues/issue-100075-2.rs
+ui/impl-trait/issues/issue-100075.rs
+ui/impl-trait/issues/issue-100187.rs
+ui/impl-trait/issues/issue-102605.rs
+ui/impl-trait/issues/issue-103181-1.rs
+ui/impl-trait/issues/issue-103181-2.rs
+ui/impl-trait/issues/issue-103599.rs
 ui/impl-trait/issues/issue-104815.rs
 ui/impl-trait/issues/issue-105826.rs
+ui/impl-trait/issues/issue-108591.rs
+ui/impl-trait/issues/issue-108592.rs
 ui/impl-trait/issues/issue-21659-show-relevant-trait-impls-3.rs
+ui/impl-trait/issues/issue-35668.rs
+ui/impl-trait/issues/issue-36792.rs
 ui/impl-trait/issues/issue-42479.rs
+ui/impl-trait/issues/issue-46959.rs
 ui/impl-trait/issues/issue-49376.rs
+ui/impl-trait/issues/issue-49556.rs
+ui/impl-trait/issues/issue-49579.rs
+ui/impl-trait/issues/issue-49685.rs
+ui/impl-trait/issues/issue-51185.rs
 ui/impl-trait/issues/issue-52128.rs
 ui/impl-trait/issues/issue-53457.rs
 ui/impl-trait/issues/issue-54600.rs
 ui/impl-trait/issues/issue-54840.rs
 ui/impl-trait/issues/issue-54895.rs
+ui/impl-trait/issues/issue-54966.rs
 ui/impl-trait/issues/issue-55608-captures-empty-region.rs
+ui/impl-trait/issues/issue-55872-1.rs
+ui/impl-trait/issues/issue-55872-2.rs
+ui/impl-trait/issues/issue-55872-3.rs
+ui/impl-trait/issues/issue-55872.rs
+ui/impl-trait/issues/issue-56445.rs
 ui/impl-trait/issues/issue-57464-unexpected-regions.rs
 ui/impl-trait/issues/issue-57979-deeply-nested-impl-trait-in-assoc-proj.rs
 ui/impl-trait/issues/issue-57979-impl-trait-in-path.rs
@@ -1233,8 +1225,10 @@ ui/impl-trait/issues/issue-58956.rs
 ui/impl-trait/issues/issue-62742.rs
 ui/impl-trait/issues/issue-65581.rs
 ui/impl-trait/issues/issue-67830.rs
+ui/impl-trait/issues/issue-68532.rs
 ui/impl-trait/issues/issue-70877.rs
 ui/impl-trait/issues/issue-70971.rs
+ui/impl-trait/issues/issue-72911.rs
 ui/impl-trait/issues/issue-74282.rs
 ui/impl-trait/issues/issue-77987.rs
 ui/impl-trait/issues/issue-78722-2.rs
@@ -1251,12 +1245,18 @@ ui/impl-trait/issues/issue-86719.rs
 ui/impl-trait/issues/issue-86800.rs
 ui/impl-trait/issues/issue-87295.rs
 ui/impl-trait/issues/issue-87340.rs
+ui/impl-trait/issues/issue-87450.rs
 ui/impl-trait/issues/issue-88236-2.rs
 ui/impl-trait/issues/issue-88236.rs
 ui/impl-trait/issues/issue-89312.rs
 ui/impl-trait/issues/issue-92305.rs
 ui/impl-trait/issues/issue-93788.rs
+ui/impl-trait/issues/issue-99073-2.rs
+ui/impl-trait/issues/issue-99073.rs
 ui/impl-trait/issues/issue-99348-impl-compatibility.rs
+ui/impl-trait/issues/issue-99642-2.rs
+ui/impl-trait/issues/issue-99642.rs
+ui/impl-trait/issues/issue-99914.rs
 ui/implied-bounds/issue-100690.rs
 ui/implied-bounds/issue-101951.rs
 ui/implied-bounds/issue-110161.rs
diff --git a/tests/debuginfo/pretty-std-collections.rs b/tests/debuginfo/pretty-std-collections.rs
index 5e133ee718e2e..f78830162ca60 100644
--- a/tests/debuginfo/pretty-std-collections.rs
+++ b/tests/debuginfo/pretty-std-collections.rs
@@ -51,6 +51,33 @@
 
 // lldb-command:run
 
+// lldb-command: v btree_set
+// lldb-check:[...] size=15 { [0] = 0 [1] = 1 [2] = 2 [3] = 3 [4] = 4 [5] = 5 [6] = 6 [7] = 7 [8] = 8 [9] = 9 [10] = 10 [11] = 11 [12] = 12 [13] = 13 [14] = 14 }
+
+// lldb-command: v empty_btree_set
+// lldb-check:[...] size=0
+
+// lldb-command: v btree_map
+// lldb-check:[...] size=15 { [0] = { 0 = 0 1 = 0 } [1] = { 0 = 1 1 = 1 } [2] = { 0 = 2 1 = 2 } [3] = { 0 = 3 1 = 3 } [4] = { 0 = 4 1 = 4 } [5] = { 0 = 5 1 = 5 } [6] = { 0 = 6 1 = 6 } [7] = { 0 = 7 1 = 7 } [8] = { 0 = 8 1 = 8 } [9] = { 0 = 9 1 = 9 } [10] = { 0 = 10 1 = 10 } [11] = { 0 = 11 1 = 11 } [12] = { 0 = 12 1 = 12 } [13] = { 0 = 13 1 = 13 } [14] = { 0 = 14 1 = 14 } }
+
+// lldb-command: v option_btree_map
+// lldb-check:[...] size=2 { [0] = { 0 = false 1 = [...] } [1] = { 0 = true 1 = [...]
+// (The matching here is lazy, so we cannot add braces at the end because they would match
+// intermediate braces and fail because not the entire input was consumed.)
+
+// lldb-command: v nasty_btree_map
+// lldb-check:[...] size=15 { [0] = { 0 = 0 1 = { 0 = 0 } } [1] = { 0 = 1 1 = { 0 = 1 } } [2] = { 0 = 2 1 = { 0 = 2 } } [3] = { 0 = 3 1 = { 0 = 3 } } [4] = { 0 = 4 1 = { 0 = 4 } } [5] = { 0 = 5 1 = { 0 = 5 } } [6] = { 0 = 6 1 = { 0 = 6 } } [7] = { 0 = 7 1 = { 0 = 7 } } [8] = { 0 = 8 1 = { 0 = 8 } } [9] = { 0 = 9 1 = { 0 = 9 } } [10] = { 0 = 10 1 = { 0 = 10 } } [11] = { 0 = 11 1 = { 0 = 11 } } [12] = { 0 = 12 1 = { 0 = 12 } } [13] = { 0 = 13 1 = { 0 = 13 } } [14] = { 0 = 14 1 = { 0 = 14 } } }
+// (Does not print out the type name in lldb)
+
+// lldb-command: v zst_key_btree_map
+// lldb-check:[...] size=1 { [0] = { 1 = 1 } }
+
+// lldb-command: v zst_val_btree_map
+// lldb-check:[...] size=1 { [0] = { 0 = 1 } }
+
+// lldb-command: v zst_key_val_btree_map
+// lldb-check:[...] size=1 { [0] = {} }
+
 // lldb-command:v vec_deque
 // lldb-check:[...] size=3 { [0] = 5 [1] = 3 [2] = 7 }
 
diff --git a/tests/run-make/core-no-oom-handling/rmake.rs b/tests/run-make/core-no-oom-handling/rmake.rs
index a9e2b33e21073..5194d77311448 100644
--- a/tests/run-make/core-no-oom-handling/rmake.rs
+++ b/tests/run-make/core-no-oom-handling/rmake.rs
@@ -6,7 +6,7 @@ use run_make_support::{rustc, source_root};
 
 fn main() {
     rustc()
-        .edition("2021")
+        .edition("2024")
         .arg("-Dwarnings")
         .crate_type("rlib")
         .input(source_root().join("library/core/src/lib.rs"))
diff --git a/tests/ui/drop/dropck-normalize-errors.rs b/tests/ui/drop/dropck-normalize-errors.rs
new file mode 100644
index 0000000000000..793122bd33d4b
--- /dev/null
+++ b/tests/ui/drop/dropck-normalize-errors.rs
@@ -0,0 +1,31 @@
+// Test that we don't ICE when computing the drop types for
+
+trait Decode<'a> {
+    type Decoder;
+}
+
+trait NonImplementedTrait {
+    type Assoc;
+}
+struct NonImplementedStruct;
+
+pub struct ADecoder<'a> {
+    b: <B as Decode<'a>>::Decoder,
+}
+fn make_a_decoder<'a>() -> ADecoder<'a> {
+    //~^ ERROR the trait bound
+    //~| ERROR the trait bound
+    panic!()
+}
+
+struct B;
+impl<'a> Decode<'a> for B {
+    type Decoder = BDecoder;
+    //~^ ERROR the trait bound
+}
+pub struct BDecoder {
+    non_implemented: <NonImplementedStruct as NonImplementedTrait>::Assoc,
+    //~^ ERROR the trait bound
+}
+
+fn main() {}
diff --git a/tests/ui/drop/dropck-normalize-errors.stderr b/tests/ui/drop/dropck-normalize-errors.stderr
new file mode 100644
index 0000000000000..2bb5909c6b226
--- /dev/null
+++ b/tests/ui/drop/dropck-normalize-errors.stderr
@@ -0,0 +1,76 @@
+error[E0277]: the trait bound `NonImplementedStruct: NonImplementedTrait` is not satisfied in `ADecoder<'a>`
+  --> $DIR/dropck-normalize-errors.rs:15:28
+   |
+LL | fn make_a_decoder<'a>() -> ADecoder<'a> {
+   |                            ^^^^^^^^^^^^ within `ADecoder<'a>`, the trait `NonImplementedTrait` is not implemented for `NonImplementedStruct`
+   |
+help: this trait has no implementations, consider adding one
+  --> $DIR/dropck-normalize-errors.rs:7:1
+   |
+LL | trait NonImplementedTrait {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+note: required because it appears within the type `BDecoder`
+  --> $DIR/dropck-normalize-errors.rs:26:12
+   |
+LL | pub struct BDecoder {
+   |            ^^^^^^^^
+note: required because it appears within the type `ADecoder<'a>`
+  --> $DIR/dropck-normalize-errors.rs:12:12
+   |
+LL | pub struct ADecoder<'a> {
+   |            ^^^^^^^^
+   = note: the return type of a function must have a statically known size
+
+error[E0277]: the trait bound `NonImplementedStruct: NonImplementedTrait` is not satisfied in `BDecoder`
+  --> $DIR/dropck-normalize-errors.rs:23:20
+   |
+LL |     type Decoder = BDecoder;
+   |                    ^^^^^^^^ within `BDecoder`, the trait `NonImplementedTrait` is not implemented for `NonImplementedStruct`
+   |
+help: this trait has no implementations, consider adding one
+  --> $DIR/dropck-normalize-errors.rs:7:1
+   |
+LL | trait NonImplementedTrait {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+note: required because it appears within the type `BDecoder`
+  --> $DIR/dropck-normalize-errors.rs:26:12
+   |
+LL | pub struct BDecoder {
+   |            ^^^^^^^^
+note: required by a bound in `Decode::Decoder`
+  --> $DIR/dropck-normalize-errors.rs:4:5
+   |
+LL |     type Decoder;
+   |     ^^^^^^^^^^^^^ required by this bound in `Decode::Decoder`
+help: consider relaxing the implicit `Sized` restriction
+   |
+LL |     type Decoder: ?Sized;
+   |                 ++++++++
+
+error[E0277]: the trait bound `NonImplementedStruct: NonImplementedTrait` is not satisfied
+  --> $DIR/dropck-normalize-errors.rs:27:22
+   |
+LL |     non_implemented: <NonImplementedStruct as NonImplementedTrait>::Assoc,
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `NonImplementedTrait` is not implemented for `NonImplementedStruct`
+   |
+help: this trait has no implementations, consider adding one
+  --> $DIR/dropck-normalize-errors.rs:7:1
+   |
+LL | trait NonImplementedTrait {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0277]: the trait bound `NonImplementedStruct: NonImplementedTrait` is not satisfied
+  --> $DIR/dropck-normalize-errors.rs:15:28
+   |
+LL | fn make_a_decoder<'a>() -> ADecoder<'a> {
+   |                            ^^^^^^^^^^^^ the trait `NonImplementedTrait` is not implemented for `NonImplementedStruct`
+   |
+help: this trait has no implementations, consider adding one
+  --> $DIR/dropck-normalize-errors.rs:7:1
+   |
+LL | trait NonImplementedTrait {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/generic-associated-types/guide-inference-in-gat-arg-deeper.rs b/tests/ui/generic-associated-types/guide-inference-in-gat-arg-deeper.rs
index 96a0f2f40bf49..82ffa0221b997 100644
--- a/tests/ui/generic-associated-types/guide-inference-in-gat-arg-deeper.rs
+++ b/tests/ui/generic-associated-types/guide-inference-in-gat-arg-deeper.rs
@@ -1,5 +1,9 @@
-// Fix for <https://github.com/rust-lang/rust/issues/125196>.
 //@ check-pass
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
+
+// Fix for <https://github.com/rust-lang/rust/issues/125196>.
 
 trait Tr {
     type Gat<T>;
diff --git a/tests/ui/generic-associated-types/no-incomplete-gat-arg-inference.rs b/tests/ui/generic-associated-types/no-incomplete-gat-arg-inference.rs
new file mode 100644
index 0000000000000..0c25c64224b1d
--- /dev/null
+++ b/tests/ui/generic-associated-types/no-incomplete-gat-arg-inference.rs
@@ -0,0 +1,33 @@
+//@ check-pass
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
+
+// Regression test for trait-system-refactor-initiative#202. We have
+// to make sure we don't constrain ambiguous GAT args when normalizing
+// via where bounds or item bounds.
+
+trait Trait {
+    type Assoc<U>;
+}
+
+fn ret<T: Trait, U>(x: U) -> <T as Trait>::Assoc<U> {
+    loop {}
+}
+
+fn where_bound<T: Trait<Assoc<u32> = u32>>() {
+    let inf = Default::default();
+    let x = ret::<T, _>(inf);
+    let _: i32 = inf;
+}
+
+trait ItemBound {
+    type Bound: Trait<Assoc<u32> = u32>;
+}
+fn item_bound<T: ItemBound>() {
+    let inf = Default::default();
+    let x = ret::<T::Bound, _>(inf);
+    let _: i32 = inf;
+}
+
+fn main() {}
diff --git a/tests/ui/impl-trait/arg-position-impl-trait-too-long.rs b/tests/ui/impl-trait/apit/arg-position-impl-trait-too-long.rs
similarity index 100%
rename from tests/ui/impl-trait/arg-position-impl-trait-too-long.rs
rename to tests/ui/impl-trait/apit/arg-position-impl-trait-too-long.rs
diff --git a/tests/ui/impl-trait/arg-position-impl-trait-too-long.stderr b/tests/ui/impl-trait/apit/arg-position-impl-trait-too-long.stderr
similarity index 100%
rename from tests/ui/impl-trait/arg-position-impl-trait-too-long.stderr
rename to tests/ui/impl-trait/apit/arg-position-impl-trait-too-long.stderr
diff --git a/tests/ui/impl-trait/impl-generic-mismatch-ab.rs b/tests/ui/impl-trait/apit/impl-generic-mismatch-ab.rs
similarity index 100%
rename from tests/ui/impl-trait/impl-generic-mismatch-ab.rs
rename to tests/ui/impl-trait/apit/impl-generic-mismatch-ab.rs
diff --git a/tests/ui/impl-trait/impl-generic-mismatch-ab.stderr b/tests/ui/impl-trait/apit/impl-generic-mismatch-ab.stderr
similarity index 100%
rename from tests/ui/impl-trait/impl-generic-mismatch-ab.stderr
rename to tests/ui/impl-trait/apit/impl-generic-mismatch-ab.stderr
diff --git a/tests/ui/impl-trait/can-return-unconstrained-closure.rs b/tests/ui/impl-trait/can-return-unconstrained-closure.rs
deleted file mode 100644
index 1f8bdbc5054d8..0000000000000
--- a/tests/ui/impl-trait/can-return-unconstrained-closure.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Test that we are special casing "outlives" for opaque types.
-//
-// The return type of a closure is not required to outlive the closure. As such
-// the following code would not compile if we used a standard outlives check
-// when checking the return type, because the return type of the closure would
-// be `&ReEmpty i32`, and we don't allow `ReEmpty` to occur in the concrete
-// type used for an opaque type.
-//
-// However, opaque types are special cased to include check all regions in the
-// concrete type against the bound, which forces the return type to be
-// `&'static i32` here.
-
-//@ build-pass (FIXME(62277): could be check-pass?)
-
-fn make_identity() -> impl Sized {
-    |x: &'static i32| x
-}
-
-fn make_identity_static() -> impl Sized + 'static {
-    |x: &'static i32| x
-}
-
-fn main() {}
diff --git a/tests/ui/impl-trait/issue-100075-2.rs b/tests/ui/impl-trait/issues/issue-100075-2.rs
similarity index 100%
rename from tests/ui/impl-trait/issue-100075-2.rs
rename to tests/ui/impl-trait/issues/issue-100075-2.rs
diff --git a/tests/ui/impl-trait/issue-100075-2.stderr b/tests/ui/impl-trait/issues/issue-100075-2.stderr
similarity index 100%
rename from tests/ui/impl-trait/issue-100075-2.stderr
rename to tests/ui/impl-trait/issues/issue-100075-2.stderr
diff --git a/tests/ui/impl-trait/issue-100075.rs b/tests/ui/impl-trait/issues/issue-100075.rs
similarity index 100%
rename from tests/ui/impl-trait/issue-100075.rs
rename to tests/ui/impl-trait/issues/issue-100075.rs
diff --git a/tests/ui/impl-trait/issue-100075.stderr b/tests/ui/impl-trait/issues/issue-100075.stderr
similarity index 100%
rename from tests/ui/impl-trait/issue-100075.stderr
rename to tests/ui/impl-trait/issues/issue-100075.stderr
diff --git a/tests/ui/impl-trait/issue-100187.rs b/tests/ui/impl-trait/issues/issue-100187.rs
similarity index 100%
rename from tests/ui/impl-trait/issue-100187.rs
rename to tests/ui/impl-trait/issues/issue-100187.rs
diff --git a/tests/ui/impl-trait/issue-102605.rs b/tests/ui/impl-trait/issues/issue-102605.rs
similarity index 100%
rename from tests/ui/impl-trait/issue-102605.rs
rename to tests/ui/impl-trait/issues/issue-102605.rs
diff --git a/tests/ui/impl-trait/issue-102605.stderr b/tests/ui/impl-trait/issues/issue-102605.stderr
similarity index 100%
rename from tests/ui/impl-trait/issue-102605.stderr
rename to tests/ui/impl-trait/issues/issue-102605.stderr
diff --git a/tests/ui/impl-trait/issue-103181-1.current.stderr b/tests/ui/impl-trait/issues/issue-103181-1.current.stderr
similarity index 100%
rename from tests/ui/impl-trait/issue-103181-1.current.stderr
rename to tests/ui/impl-trait/issues/issue-103181-1.current.stderr
diff --git a/tests/ui/impl-trait/issue-103181-1.next.stderr b/tests/ui/impl-trait/issues/issue-103181-1.next.stderr
similarity index 100%
rename from tests/ui/impl-trait/issue-103181-1.next.stderr
rename to tests/ui/impl-trait/issues/issue-103181-1.next.stderr
diff --git a/tests/ui/impl-trait/issue-103181-1.rs b/tests/ui/impl-trait/issues/issue-103181-1.rs
similarity index 100%
rename from tests/ui/impl-trait/issue-103181-1.rs
rename to tests/ui/impl-trait/issues/issue-103181-1.rs
diff --git a/tests/ui/impl-trait/issue-103181-2.rs b/tests/ui/impl-trait/issues/issue-103181-2.rs
similarity index 100%
rename from tests/ui/impl-trait/issue-103181-2.rs
rename to tests/ui/impl-trait/issues/issue-103181-2.rs
diff --git a/tests/ui/impl-trait/issue-103181-2.stderr b/tests/ui/impl-trait/issues/issue-103181-2.stderr
similarity index 100%
rename from tests/ui/impl-trait/issue-103181-2.stderr
rename to tests/ui/impl-trait/issues/issue-103181-2.stderr
diff --git a/tests/ui/impl-trait/issue-103599.rs b/tests/ui/impl-trait/issues/issue-103599.rs
similarity index 100%
rename from tests/ui/impl-trait/issue-103599.rs
rename to tests/ui/impl-trait/issues/issue-103599.rs
diff --git a/tests/ui/impl-trait/issue-103599.stderr b/tests/ui/impl-trait/issues/issue-103599.stderr
similarity index 100%
rename from tests/ui/impl-trait/issue-103599.stderr
rename to tests/ui/impl-trait/issues/issue-103599.stderr
diff --git a/tests/ui/impl-trait/issue-108591.rs b/tests/ui/impl-trait/issues/issue-108591.rs
similarity index 100%
rename from tests/ui/impl-trait/issue-108591.rs
rename to tests/ui/impl-trait/issues/issue-108591.rs
diff --git a/tests/ui/impl-trait/issue-108592.rs b/tests/ui/impl-trait/issues/issue-108592.rs
similarity index 100%
rename from tests/ui/impl-trait/issue-108592.rs
rename to tests/ui/impl-trait/issues/issue-108592.rs
diff --git a/tests/ui/impl-trait/issue-35668.rs b/tests/ui/impl-trait/issues/issue-35668.rs
similarity index 100%
rename from tests/ui/impl-trait/issue-35668.rs
rename to tests/ui/impl-trait/issues/issue-35668.rs
diff --git a/tests/ui/impl-trait/issue-35668.stderr b/tests/ui/impl-trait/issues/issue-35668.stderr
similarity index 100%
rename from tests/ui/impl-trait/issue-35668.stderr
rename to tests/ui/impl-trait/issues/issue-35668.stderr
diff --git a/tests/ui/impl-trait/issue-36792.rs b/tests/ui/impl-trait/issues/issue-36792.rs
similarity index 100%
rename from tests/ui/impl-trait/issue-36792.rs
rename to tests/ui/impl-trait/issues/issue-36792.rs
diff --git a/tests/ui/impl-trait/issue-46959.rs b/tests/ui/impl-trait/issues/issue-46959.rs
similarity index 100%
rename from tests/ui/impl-trait/issue-46959.rs
rename to tests/ui/impl-trait/issues/issue-46959.rs
diff --git a/tests/ui/impl-trait/issue-49556.rs b/tests/ui/impl-trait/issues/issue-49556.rs
similarity index 100%
rename from tests/ui/impl-trait/issue-49556.rs
rename to tests/ui/impl-trait/issues/issue-49556.rs
diff --git a/tests/ui/impl-trait/issue-49579.rs b/tests/ui/impl-trait/issues/issue-49579.rs
similarity index 100%
rename from tests/ui/impl-trait/issue-49579.rs
rename to tests/ui/impl-trait/issues/issue-49579.rs
diff --git a/tests/ui/impl-trait/issue-49685.rs b/tests/ui/impl-trait/issues/issue-49685.rs
similarity index 100%
rename from tests/ui/impl-trait/issue-49685.rs
rename to tests/ui/impl-trait/issues/issue-49685.rs
diff --git a/tests/ui/impl-trait/issue-51185.rs b/tests/ui/impl-trait/issues/issue-51185.rs
similarity index 100%
rename from tests/ui/impl-trait/issue-51185.rs
rename to tests/ui/impl-trait/issues/issue-51185.rs
diff --git a/tests/ui/impl-trait/issue-54966.rs b/tests/ui/impl-trait/issues/issue-54966.rs
similarity index 100%
rename from tests/ui/impl-trait/issue-54966.rs
rename to tests/ui/impl-trait/issues/issue-54966.rs
diff --git a/tests/ui/impl-trait/issue-54966.stderr b/tests/ui/impl-trait/issues/issue-54966.stderr
similarity index 100%
rename from tests/ui/impl-trait/issue-54966.stderr
rename to tests/ui/impl-trait/issues/issue-54966.stderr
diff --git a/tests/ui/impl-trait/issue-55872-1.rs b/tests/ui/impl-trait/issues/issue-55872-1.rs
similarity index 100%
rename from tests/ui/impl-trait/issue-55872-1.rs
rename to tests/ui/impl-trait/issues/issue-55872-1.rs
diff --git a/tests/ui/impl-trait/issue-55872-1.stderr b/tests/ui/impl-trait/issues/issue-55872-1.stderr
similarity index 100%
rename from tests/ui/impl-trait/issue-55872-1.stderr
rename to tests/ui/impl-trait/issues/issue-55872-1.stderr
diff --git a/tests/ui/impl-trait/issue-55872-2.rs b/tests/ui/impl-trait/issues/issue-55872-2.rs
similarity index 100%
rename from tests/ui/impl-trait/issue-55872-2.rs
rename to tests/ui/impl-trait/issues/issue-55872-2.rs
diff --git a/tests/ui/impl-trait/issue-55872-2.stderr b/tests/ui/impl-trait/issues/issue-55872-2.stderr
similarity index 100%
rename from tests/ui/impl-trait/issue-55872-2.stderr
rename to tests/ui/impl-trait/issues/issue-55872-2.stderr
diff --git a/tests/ui/impl-trait/issue-55872-3.rs b/tests/ui/impl-trait/issues/issue-55872-3.rs
similarity index 100%
rename from tests/ui/impl-trait/issue-55872-3.rs
rename to tests/ui/impl-trait/issues/issue-55872-3.rs
diff --git a/tests/ui/impl-trait/issue-55872-3.stderr b/tests/ui/impl-trait/issues/issue-55872-3.stderr
similarity index 100%
rename from tests/ui/impl-trait/issue-55872-3.stderr
rename to tests/ui/impl-trait/issues/issue-55872-3.stderr
diff --git a/tests/ui/impl-trait/issue-55872.rs b/tests/ui/impl-trait/issues/issue-55872.rs
similarity index 100%
rename from tests/ui/impl-trait/issue-55872.rs
rename to tests/ui/impl-trait/issues/issue-55872.rs
diff --git a/tests/ui/impl-trait/issue-55872.stderr b/tests/ui/impl-trait/issues/issue-55872.stderr
similarity index 100%
rename from tests/ui/impl-trait/issue-55872.stderr
rename to tests/ui/impl-trait/issues/issue-55872.stderr
diff --git a/tests/ui/impl-trait/issue-56445.rs b/tests/ui/impl-trait/issues/issue-56445.rs
similarity index 100%
rename from tests/ui/impl-trait/issue-56445.rs
rename to tests/ui/impl-trait/issues/issue-56445.rs
diff --git a/tests/ui/impl-trait/issue-68532.rs b/tests/ui/impl-trait/issues/issue-68532.rs
similarity index 100%
rename from tests/ui/impl-trait/issue-68532.rs
rename to tests/ui/impl-trait/issues/issue-68532.rs
diff --git a/tests/ui/impl-trait/issue-72911.rs b/tests/ui/impl-trait/issues/issue-72911.rs
similarity index 100%
rename from tests/ui/impl-trait/issue-72911.rs
rename to tests/ui/impl-trait/issues/issue-72911.rs
diff --git a/tests/ui/impl-trait/issue-72911.stderr b/tests/ui/impl-trait/issues/issue-72911.stderr
similarity index 100%
rename from tests/ui/impl-trait/issue-72911.stderr
rename to tests/ui/impl-trait/issues/issue-72911.stderr
diff --git a/tests/ui/impl-trait/issue-87450.rs b/tests/ui/impl-trait/issues/issue-87450.rs
similarity index 100%
rename from tests/ui/impl-trait/issue-87450.rs
rename to tests/ui/impl-trait/issues/issue-87450.rs
diff --git a/tests/ui/impl-trait/issue-87450.stderr b/tests/ui/impl-trait/issues/issue-87450.stderr
similarity index 100%
rename from tests/ui/impl-trait/issue-87450.stderr
rename to tests/ui/impl-trait/issues/issue-87450.stderr
diff --git a/tests/ui/impl-trait/issue-99073-2.rs b/tests/ui/impl-trait/issues/issue-99073-2.rs
similarity index 100%
rename from tests/ui/impl-trait/issue-99073-2.rs
rename to tests/ui/impl-trait/issues/issue-99073-2.rs
diff --git a/tests/ui/impl-trait/issue-99073-2.stderr b/tests/ui/impl-trait/issues/issue-99073-2.stderr
similarity index 100%
rename from tests/ui/impl-trait/issue-99073-2.stderr
rename to tests/ui/impl-trait/issues/issue-99073-2.stderr
diff --git a/tests/ui/impl-trait/issue-99073.rs b/tests/ui/impl-trait/issues/issue-99073.rs
similarity index 100%
rename from tests/ui/impl-trait/issue-99073.rs
rename to tests/ui/impl-trait/issues/issue-99073.rs
diff --git a/tests/ui/impl-trait/issue-99073.stderr b/tests/ui/impl-trait/issues/issue-99073.stderr
similarity index 100%
rename from tests/ui/impl-trait/issue-99073.stderr
rename to tests/ui/impl-trait/issues/issue-99073.stderr
diff --git a/tests/ui/impl-trait/issue-99642-2.rs b/tests/ui/impl-trait/issues/issue-99642-2.rs
similarity index 100%
rename from tests/ui/impl-trait/issue-99642-2.rs
rename to tests/ui/impl-trait/issues/issue-99642-2.rs
diff --git a/tests/ui/impl-trait/issue-99642.rs b/tests/ui/impl-trait/issues/issue-99642.rs
similarity index 100%
rename from tests/ui/impl-trait/issue-99642.rs
rename to tests/ui/impl-trait/issues/issue-99642.rs
diff --git a/tests/ui/impl-trait/issue-99914.rs b/tests/ui/impl-trait/issues/issue-99914.rs
similarity index 100%
rename from tests/ui/impl-trait/issue-99914.rs
rename to tests/ui/impl-trait/issues/issue-99914.rs
diff --git a/tests/ui/impl-trait/issue-99914.stderr b/tests/ui/impl-trait/issues/issue-99914.stderr
similarity index 100%
rename from tests/ui/impl-trait/issue-99914.stderr
rename to tests/ui/impl-trait/issues/issue-99914.stderr
diff --git a/tests/ui/impl-trait/lifetimes2.rs b/tests/ui/impl-trait/lifetimes2.rs
deleted file mode 100644
index facf2f75bc4d0..0000000000000
--- a/tests/ui/impl-trait/lifetimes2.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//@ check-pass
-
-pub fn keys<'a>(x: &'a Result<u32, u32>) -> impl std::fmt::Debug + 'a {
-    match x {
-        Ok(map) => Ok(map),
-        Err(map) => Err(map),
-    }
-}
-
-fn main() {}
diff --git a/tests/ui/lint/implicit_autorefs.fixed b/tests/ui/lint/implicit_autorefs.fixed
index 96a617b20c918..454dfe7637261 100644
--- a/tests/ui/lint/implicit_autorefs.fixed
+++ b/tests/ui/lint/implicit_autorefs.fixed
@@ -96,4 +96,10 @@ unsafe fn test_string(ptr: *mut String) {
     //~^ WARN implicit autoref
 }
 
+unsafe fn slice_ptr_len_because_of_msrv<T>(slice: *const [T]) {
+    let _ = (&(&(*slice))[..]).len();
+    //~^ WARN implicit autoref
+    //~^^ WARN implicit autoref
+}
+
 fn main() {}
diff --git a/tests/ui/lint/implicit_autorefs.rs b/tests/ui/lint/implicit_autorefs.rs
index 61dd0ac50ce75..507d653682839 100644
--- a/tests/ui/lint/implicit_autorefs.rs
+++ b/tests/ui/lint/implicit_autorefs.rs
@@ -96,4 +96,10 @@ unsafe fn test_string(ptr: *mut String) {
     //~^ WARN implicit autoref
 }
 
+unsafe fn slice_ptr_len_because_of_msrv<T>(slice: *const [T]) {
+    let _ = (*slice)[..].len();
+    //~^ WARN implicit autoref
+    //~^^ WARN implicit autoref
+}
+
 fn main() {}
diff --git a/tests/ui/lint/implicit_autorefs.stderr b/tests/ui/lint/implicit_autorefs.stderr
index 6dd1ac65ada98..80ba8ae2fd277 100644
--- a/tests/ui/lint/implicit_autorefs.stderr
+++ b/tests/ui/lint/implicit_autorefs.stderr
@@ -2,9 +2,16 @@ warning: implicit autoref creates a reference to the dereference of a raw pointe
   --> $DIR/implicit_autorefs.rs:10:13
    |
 LL |     let _ = (*ptr)[..16];
-   |             ^^^^^^^^^^^^
+   |             ^^---^^^^^^^
+   |               |
+   |               this raw pointer has type `*const [u8]`
    |
    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
+note: autoref is being applied to this expression, resulting in: `&[u8]`
+  --> $DIR/implicit_autorefs.rs:10:13
+   |
+LL |     let _ = (*ptr)[..16];
+   |             ^^^^^^
    = note: `#[warn(dangerous_implicit_autorefs)]` on by default
 help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
    |
@@ -15,9 +22,18 @@ warning: implicit autoref creates a reference to the dereference of a raw pointe
   --> $DIR/implicit_autorefs.rs:19:13
    |
 LL |     let l = (*ptr).field.len();
-   |             ^^^^^^^^^^^^^^^^^^
+   |             ^^---^^^^^^^^^^^^^
+   |               |
+   |               this raw pointer has type `*const Test`
    |
    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
+note: autoref is being applied to this expression, resulting in: `&[u8]`
+  --> $DIR/implicit_autorefs.rs:19:13
+   |
+LL |     let l = (*ptr).field.len();
+   |             ^^^^^^^^^^^^
+note: method calls to `len` require a reference
+  --> $SRC_DIR/core/src/slice/mod.rs:LL:COL
 help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
    |
 LL |     let l = (&(*ptr).field).len();
@@ -27,9 +43,16 @@ warning: implicit autoref creates a reference to the dereference of a raw pointe
   --> $DIR/implicit_autorefs.rs:22:16
    |
 LL |     &raw const (*ptr).field[..l - 1]
-   |                ^^^^^^^^^^^^^^^^^^^^^
+   |                ^^---^^^^^^^^^^^^^^^^
+   |                  |
+   |                  this raw pointer has type `*const Test`
    |
    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
+note: autoref is being applied to this expression, resulting in: `&[u8]`
+  --> $DIR/implicit_autorefs.rs:22:16
+   |
+LL |     &raw const (*ptr).field[..l - 1]
+   |                ^^^^^^^^^^^^
 help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
    |
 LL |     &raw const (&(*ptr).field)[..l - 1]
@@ -39,9 +62,18 @@ warning: implicit autoref creates a reference to the dereference of a raw pointe
   --> $DIR/implicit_autorefs.rs:27:9
    |
 LL |     _ = (*a)[0].len();
-   |         ^^^^^^^^^^^^^
+   |         ^^-^^^^^^^^^^
+   |           |
+   |           this raw pointer has type `*mut [String]`
    |
    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
+note: autoref is being applied to this expression, resulting in: `&String`
+  --> $DIR/implicit_autorefs.rs:27:9
+   |
+LL |     _ = (*a)[0].len();
+   |         ^^^^^^^
+note: method calls to `len` require a reference
+  --> $SRC_DIR/alloc/src/string.rs:LL:COL
 help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
    |
 LL |     _ = (&(*a)[0]).len();
@@ -51,9 +83,18 @@ warning: implicit autoref creates a reference to the dereference of a raw pointe
   --> $DIR/implicit_autorefs.rs:30:9
    |
 LL |     _ = (*a)[..1][0].len();
-   |         ^^^^^^^^^^^^^^^^^^
+   |         ^^-^^^^^^^^^^^^^^^
+   |           |
+   |           this raw pointer has type `*mut [String]`
    |
    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
+note: autoref is being applied to this expression, resulting in: `&String`
+  --> $DIR/implicit_autorefs.rs:30:9
+   |
+LL |     _ = (*a)[..1][0].len();
+   |         ^^^^^^^^^^^^
+note: method calls to `len` require a reference
+  --> $SRC_DIR/alloc/src/string.rs:LL:COL
 help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
    |
 LL |     _ = (&(*a)[..1][0]).len();
@@ -63,9 +104,16 @@ warning: implicit autoref creates a reference to the dereference of a raw pointe
   --> $DIR/implicit_autorefs.rs:30:9
    |
 LL |     _ = (*a)[..1][0].len();
-   |         ^^^^^^^^^
+   |         ^^-^^^^^^
+   |           |
+   |           this raw pointer has type `*mut [String]`
    |
    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
+note: autoref is being applied to this expression, resulting in: `&[String]`
+  --> $DIR/implicit_autorefs.rs:30:9
+   |
+LL |     _ = (*a)[..1][0].len();
+   |         ^^^^
 help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
    |
 LL |     _ = (&(*a))[..1][0].len();
@@ -75,9 +123,12 @@ warning: implicit autoref creates a reference to the dereference of a raw pointe
   --> $DIR/implicit_autorefs.rs:36:13
    |
 LL |     let _ = (*ptr).field;
-   |             ^^^^^^^^^^^^
+   |             ^^---^^^^^^^
+   |               |
+   |               this raw pointer has type `*const ManuallyDrop<Test>`
    |
    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
+   = note: references are created through calls to explicit `Deref(Mut)::deref(_mut)` implementations
 help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
    |
 LL |     let _ = (&(*ptr)).field;
@@ -87,9 +138,12 @@ warning: implicit autoref creates a reference to the dereference of a raw pointe
   --> $DIR/implicit_autorefs.rs:38:24
    |
 LL |     let _ = &raw const (*ptr).field;
-   |                        ^^^^^^^^^^^^
+   |                        ^^---^^^^^^^
+   |                          |
+   |                          this raw pointer has type `*const ManuallyDrop<Test>`
    |
    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
+   = note: references are created through calls to explicit `Deref(Mut)::deref(_mut)` implementations
 help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
    |
 LL |     let _ = &raw const (&(*ptr)).field;
@@ -99,9 +153,12 @@ warning: implicit autoref creates a reference to the dereference of a raw pointe
   --> $DIR/implicit_autorefs.rs:43:13
    |
 LL |     let _ = (*ptr).field;
-   |             ^^^^^^^^^^^^
+   |             ^^---^^^^^^^
+   |               |
+   |               this raw pointer has type `*mut ManuallyDrop<Test>`
    |
    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
+   = note: references are created through calls to explicit `Deref(Mut)::deref(_mut)` implementations
 help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
    |
 LL |     let _ = (&(*ptr)).field;
@@ -111,9 +168,12 @@ warning: implicit autoref creates a reference to the dereference of a raw pointe
   --> $DIR/implicit_autorefs.rs:48:13
    |
 LL |     let _ = (*ptr).field;
-   |             ^^^^^^^^^^^^
+   |             ^^---^^^^^^^
+   |               |
+   |               this raw pointer has type `*const ManuallyDrop<ManuallyDrop<Test>>`
    |
    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
+   = note: references are created through calls to explicit `Deref(Mut)::deref(_mut)` implementations
 help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
    |
 LL |     let _ = (&(*ptr)).field;
@@ -123,9 +183,16 @@ warning: implicit autoref creates a reference to the dereference of a raw pointe
   --> $DIR/implicit_autorefs.rs:62:26
    |
 LL |     let _p: *const i32 = &raw const **w;
-   |                          ^^^^^^^^^^^^^^
+   |                          ^^^^^^^^^^^^^-
+   |                                       |
+   |                                       this raw pointer has type `*const W<i32>`
    |
    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
+note: autoref is being applied to this expression, resulting in: `&W<i32>`
+  --> $DIR/implicit_autorefs.rs:62:38
+   |
+LL |     let _p: *const i32 = &raw const **w;
+   |                                      ^^
 help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
    |
 LL |     let _p: *const i32 = &raw const *(&**w);
@@ -135,9 +202,18 @@ warning: implicit autoref creates a reference to the dereference of a raw pointe
   --> $DIR/implicit_autorefs.rs:72:14
    |
 LL |     unsafe { (*ptr).field.len() }
-   |              ^^^^^^^^^^^^^^^^^^
+   |              ^^---^^^^^^^^^^^^^
+   |                |
+   |                this raw pointer has type `*const Test2`
    |
    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
+note: autoref is being applied to this expression, resulting in: `&[u8]`
+  --> $DIR/implicit_autorefs.rs:72:14
+   |
+LL |     unsafe { (*ptr).field.len() }
+   |              ^^^^^^^^^^^^
+note: method calls to `len` require a reference
+  --> $SRC_DIR/core/src/slice/mod.rs:LL:COL
 help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
    |
 LL |     unsafe { (&(*ptr).field).len() }
@@ -147,9 +223,18 @@ warning: implicit autoref creates a reference to the dereference of a raw pointe
   --> $DIR/implicit_autorefs.rs:82:13
    |
 LL |     let _ = (*ptr).get(0);
-   |             ^^^^^^^^^^^^^
+   |             ^^---^^^^^^^^
+   |               |
+   |               this raw pointer has type `*mut Vec<u8>`
    |
    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
+note: autoref is being applied to this expression, resulting in: `&[u8]`
+  --> $DIR/implicit_autorefs.rs:82:13
+   |
+LL |     let _ = (*ptr).get(0);
+   |             ^^^^^^
+note: method calls to `get` require a reference
+  --> $SRC_DIR/core/src/slice/mod.rs:LL:COL
 help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
    |
 LL |     let _ = (&(*ptr)).get(0);
@@ -159,9 +244,18 @@ warning: implicit autoref creates a reference to the dereference of a raw pointe
   --> $DIR/implicit_autorefs.rs:84:13
    |
 LL |     let _ = (*ptr).get_unchecked(0);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^
+   |             ^^---^^^^^^^^^^^^^^^^^^
+   |               |
+   |               this raw pointer has type `*mut Vec<u8>`
    |
    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
+note: autoref is being applied to this expression, resulting in: `&[u8]`
+  --> $DIR/implicit_autorefs.rs:84:13
+   |
+LL |     let _ = (*ptr).get_unchecked(0);
+   |             ^^^^^^
+note: method calls to `get_unchecked` require a reference
+  --> $SRC_DIR/core/src/slice/mod.rs:LL:COL
 help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
    |
 LL |     let _ = (&(*ptr)).get_unchecked(0);
@@ -171,9 +265,18 @@ warning: implicit autoref creates a reference to the dereference of a raw pointe
   --> $DIR/implicit_autorefs.rs:86:13
    |
 LL |     let _ = (*ptr).get_mut(0);
-   |             ^^^^^^^^^^^^^^^^^
+   |             ^^---^^^^^^^^^^^^
+   |               |
+   |               this raw pointer has type `*mut Vec<u8>`
    |
    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
+note: autoref is being applied to this expression, resulting in: `&mut [u8]`
+  --> $DIR/implicit_autorefs.rs:86:13
+   |
+LL |     let _ = (*ptr).get_mut(0);
+   |             ^^^^^^
+note: method calls to `get_mut` require a reference
+  --> $SRC_DIR/core/src/slice/mod.rs:LL:COL
 help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
    |
 LL |     let _ = (&mut (*ptr)).get_mut(0);
@@ -183,9 +286,18 @@ warning: implicit autoref creates a reference to the dereference of a raw pointe
   --> $DIR/implicit_autorefs.rs:88:13
    |
 LL |     let _ = (*ptr).get_unchecked_mut(0);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |             ^^---^^^^^^^^^^^^^^^^^^^^^^
+   |               |
+   |               this raw pointer has type `*mut Vec<u8>`
    |
    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
+note: autoref is being applied to this expression, resulting in: `&mut [u8]`
+  --> $DIR/implicit_autorefs.rs:88:13
+   |
+LL |     let _ = (*ptr).get_unchecked_mut(0);
+   |             ^^^^^^
+note: method calls to `get_unchecked_mut` require a reference
+  --> $SRC_DIR/core/src/slice/mod.rs:LL:COL
 help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
    |
 LL |     let _ = (&mut (*ptr)).get_unchecked_mut(0);
@@ -195,9 +307,18 @@ warning: implicit autoref creates a reference to the dereference of a raw pointe
   --> $DIR/implicit_autorefs.rs:93:13
    |
 LL |     let _ = (*ptr).len();
-   |             ^^^^^^^^^^^^
+   |             ^^---^^^^^^^
+   |               |
+   |               this raw pointer has type `*mut String`
    |
    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
+note: autoref is being applied to this expression, resulting in: `&String`
+  --> $DIR/implicit_autorefs.rs:93:13
+   |
+LL |     let _ = (*ptr).len();
+   |             ^^^^^^
+note: method calls to `len` require a reference
+  --> $SRC_DIR/alloc/src/string.rs:LL:COL
 help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
    |
 LL |     let _ = (&(*ptr)).len();
@@ -207,13 +328,62 @@ warning: implicit autoref creates a reference to the dereference of a raw pointe
   --> $DIR/implicit_autorefs.rs:95:13
    |
 LL |     let _ = (*ptr).is_empty();
-   |             ^^^^^^^^^^^^^^^^^
+   |             ^^---^^^^^^^^^^^^
+   |               |
+   |               this raw pointer has type `*mut String`
    |
    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
+note: autoref is being applied to this expression, resulting in: `&String`
+  --> $DIR/implicit_autorefs.rs:95:13
+   |
+LL |     let _ = (*ptr).is_empty();
+   |             ^^^^^^
+note: method calls to `is_empty` require a reference
+  --> $SRC_DIR/alloc/src/string.rs:LL:COL
 help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
    |
 LL |     let _ = (&(*ptr)).is_empty();
    |             ++      +
 
-warning: 18 warnings emitted
+warning: implicit autoref creates a reference to the dereference of a raw pointer
+  --> $DIR/implicit_autorefs.rs:100:13
+   |
+LL |     let _ = (*slice)[..].len();
+   |             ^^-----^^^^^^^^^^^
+   |               |
+   |               this raw pointer has type `*const [T]`
+   |
+   = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
+note: autoref is being applied to this expression, resulting in: `&[T]`
+  --> $DIR/implicit_autorefs.rs:100:13
+   |
+LL |     let _ = (*slice)[..].len();
+   |             ^^^^^^^^^^^^
+note: method calls to `len` require a reference
+  --> $SRC_DIR/core/src/slice/mod.rs:LL:COL
+help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
+   |
+LL |     let _ = (&(*slice)[..]).len();
+   |             ++            +
+
+warning: implicit autoref creates a reference to the dereference of a raw pointer
+  --> $DIR/implicit_autorefs.rs:100:13
+   |
+LL |     let _ = (*slice)[..].len();
+   |             ^^-----^^^^^
+   |               |
+   |               this raw pointer has type `*const [T]`
+   |
+   = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
+note: autoref is being applied to this expression, resulting in: `&[T]`
+  --> $DIR/implicit_autorefs.rs:100:13
+   |
+LL |     let _ = (*slice)[..].len();
+   |             ^^^^^^^^
+help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
+   |
+LL |     let _ = (&(*slice))[..].len();
+   |             ++        +
+
+warning: 20 warnings emitted
 
diff --git a/tests/ui/parser/ternary_operator.rs b/tests/ui/parser/ternary_operator.rs
index c8810781b3d84..08f6a4b2a244f 100644
--- a/tests/ui/parser/ternary_operator.rs
+++ b/tests/ui/parser/ternary_operator.rs
@@ -28,3 +28,9 @@ fn main() {
     //~| HELP use an `if-else` expression instead
     //~| ERROR expected one of `.`, `;`, `?`, `else`, or an operator, found `:`
 }
+
+fn expr(a: u64, b: u64) -> u64 {
+    a > b ? a : b
+    //~^ ERROR Rust has no ternary operator
+    //~| HELP use an `if-else` expression instead
+}
diff --git a/tests/ui/parser/ternary_operator.stderr b/tests/ui/parser/ternary_operator.stderr
index e12a7ff3718e0..d4a633e5e5571 100644
--- a/tests/ui/parser/ternary_operator.stderr
+++ b/tests/ui/parser/ternary_operator.stderr
@@ -2,7 +2,7 @@ error: Rust has no ternary operator
   --> $DIR/ternary_operator.rs:2:19
    |
 LL |     let x = 5 > 2 ? true : false;
-   |                   ^^^^^^^^^^^^^^^
+   |                   ^^^^^^^^^^^^^^
    |
    = help: use an `if-else` expression instead
 
@@ -10,7 +10,7 @@ error: Rust has no ternary operator
   --> $DIR/ternary_operator.rs:8:19
    |
 LL |     let x = 5 > 2 ? { true } : { false };
-   |                   ^^^^^^^^^^^^^^^^^^^^^^^
+   |                   ^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use an `if-else` expression instead
 
@@ -18,7 +18,7 @@ error: Rust has no ternary operator
   --> $DIR/ternary_operator.rs:14:19
    |
 LL |     let x = 5 > 2 ? f32::MAX : f32::MIN;
-   |                   ^^^^^^^^^^^^^^^^^^^^^^
+   |                   ^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use an `if-else` expression instead
 
@@ -38,9 +38,21 @@ error: Rust has no ternary operator
   --> $DIR/ternary_operator.rs:26:19
    |
 LL |     let x = 5 > 2 ? { let x = vec![]: Vec<u16>; x } : { false };
-   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use an `if-else` expression instead
 
-error: aborting due to 6 previous errors
+error: Rust has no ternary operator
+  --> $DIR/ternary_operator.rs:33:5
+   |
+LL |     a > b ? a : b
+   |     ^^^^^^^^^^^^^
+   |
+help: use an `if-else` expression instead
+   |
+LL -     a > b ? a : b
+LL +     if a > b { a } else { b }
+   |
+
+error: aborting due to 7 previous errors
 
diff --git a/tests/ui/type-alias-impl-trait/auxiliary/coherence_cross_crate_trait_decl.rs b/tests/ui/type-alias-impl-trait/coherence/auxiliary/coherence_cross_crate_trait_decl.rs
similarity index 100%
rename from tests/ui/type-alias-impl-trait/auxiliary/coherence_cross_crate_trait_decl.rs
rename to tests/ui/type-alias-impl-trait/coherence/auxiliary/coherence_cross_crate_trait_decl.rs
diff --git a/tests/ui/type-alias-impl-trait/auxiliary/foreign-crate.rs b/tests/ui/type-alias-impl-trait/coherence/auxiliary/foreign-crate.rs
similarity index 100%
rename from tests/ui/type-alias-impl-trait/auxiliary/foreign-crate.rs
rename to tests/ui/type-alias-impl-trait/coherence/auxiliary/foreign-crate.rs
diff --git a/tests/ui/impl-trait/coherence-treats-tait-ambig.rs b/tests/ui/type-alias-impl-trait/coherence/coherence-treats-tait-ambig.rs
similarity index 100%
rename from tests/ui/impl-trait/coherence-treats-tait-ambig.rs
rename to tests/ui/type-alias-impl-trait/coherence/coherence-treats-tait-ambig.rs
diff --git a/tests/ui/impl-trait/coherence-treats-tait-ambig.stderr b/tests/ui/type-alias-impl-trait/coherence/coherence-treats-tait-ambig.stderr
similarity index 100%
rename from tests/ui/impl-trait/coherence-treats-tait-ambig.stderr
rename to tests/ui/type-alias-impl-trait/coherence/coherence-treats-tait-ambig.stderr
diff --git a/tests/ui/type-alias-impl-trait/coherence.classic.stderr b/tests/ui/type-alias-impl-trait/coherence/coherence.classic.stderr
similarity index 100%
rename from tests/ui/type-alias-impl-trait/coherence.classic.stderr
rename to tests/ui/type-alias-impl-trait/coherence/coherence.classic.stderr
diff --git a/tests/ui/type-alias-impl-trait/coherence.next.stderr b/tests/ui/type-alias-impl-trait/coherence/coherence.next.stderr
similarity index 100%
rename from tests/ui/type-alias-impl-trait/coherence.next.stderr
rename to tests/ui/type-alias-impl-trait/coherence/coherence.next.stderr
diff --git a/tests/ui/type-alias-impl-trait/coherence.rs b/tests/ui/type-alias-impl-trait/coherence/coherence.rs
similarity index 100%
rename from tests/ui/type-alias-impl-trait/coherence.rs
rename to tests/ui/type-alias-impl-trait/coherence/coherence.rs
diff --git a/tests/ui/type-alias-impl-trait/coherence_cross_crate.rs b/tests/ui/type-alias-impl-trait/coherence/coherence_cross_crate.rs
similarity index 100%
rename from tests/ui/type-alias-impl-trait/coherence_cross_crate.rs
rename to tests/ui/type-alias-impl-trait/coherence/coherence_cross_crate.rs
diff --git a/tests/ui/type-alias-impl-trait/coherence_cross_crate.stderr b/tests/ui/type-alias-impl-trait/coherence/coherence_cross_crate.stderr
similarity index 100%
rename from tests/ui/type-alias-impl-trait/coherence_cross_crate.stderr
rename to tests/ui/type-alias-impl-trait/coherence/coherence_cross_crate.stderr
diff --git a/tests/ui/type-alias-impl-trait/coherence_different_hidden_ty.rs b/tests/ui/type-alias-impl-trait/coherence/coherence_different_hidden_ty.rs
similarity index 100%
rename from tests/ui/type-alias-impl-trait/coherence_different_hidden_ty.rs
rename to tests/ui/type-alias-impl-trait/coherence/coherence_different_hidden_ty.rs
diff --git a/tests/ui/type-alias-impl-trait/coherence_different_hidden_ty.stderr b/tests/ui/type-alias-impl-trait/coherence/coherence_different_hidden_ty.stderr
similarity index 100%
rename from tests/ui/type-alias-impl-trait/coherence_different_hidden_ty.stderr
rename to tests/ui/type-alias-impl-trait/coherence/coherence_different_hidden_ty.stderr
diff --git a/tests/ui/type-alias-impl-trait/coherence_generalization.rs b/tests/ui/type-alias-impl-trait/coherence/coherence_generalization.rs
similarity index 100%
rename from tests/ui/type-alias-impl-trait/coherence_generalization.rs
rename to tests/ui/type-alias-impl-trait/coherence/coherence_generalization.rs
diff --git a/tests/ui/impl-trait/method-suggestion-no-duplication.rs b/tests/ui/where-clauses/method-suggestion-no-duplication.rs
similarity index 100%
rename from tests/ui/impl-trait/method-suggestion-no-duplication.rs
rename to tests/ui/where-clauses/method-suggestion-no-duplication.rs
diff --git a/tests/ui/impl-trait/method-suggestion-no-duplication.stderr b/tests/ui/where-clauses/method-suggestion-no-duplication.stderr
similarity index 100%
rename from tests/ui/impl-trait/method-suggestion-no-duplication.stderr
rename to tests/ui/where-clauses/method-suggestion-no-duplication.stderr