diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
index 1c1b9a247f7a2..c3bc86a352644 100644
--- a/compiler/rustc_ast_lowering/src/expr.rs
+++ b/compiler/rustc_ast_lowering/src/expr.rs
@@ -1018,7 +1018,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     expr.span,
                     hir::ExprKind::Err(self.dcx().emit_err(AwaitOnlyInAsyncFnAndBlocks {
                         await_kw_span,
-                        item_span: self.current_item,
+                        item_span: self.current_item_span,
                     })),
                 );
                 return hir::ExprKind::Block(
@@ -1712,7 +1712,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             }
             Some(hir::CoroutineKind::Coroutine(_)) => false,
             None => {
-                let suggestion = self.current_item.map(|s| s.shrink_to_lo());
+                let suggestion = self.current_item_span.map(|s| s.shrink_to_lo());
                 self.dcx().emit_err(YieldInClosure { span, suggestion });
                 self.coroutine_kind = Some(hir::CoroutineKind::Coroutine(Movability::Movable));
 
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
index edf184f568b22..1073706499919 100644
--- a/compiler/rustc_ast_lowering/src/item.rs
+++ b/compiler/rustc_ast_lowering/src/item.rs
@@ -5,11 +5,8 @@ use rustc_errors::{E0570, ErrorGuaranteed, struct_span_code_err};
 use rustc_hir::attrs::{AttributeKind, EiiImplResolution};
 use rustc_hir::def::{DefKind, PerNS, Res};
 use rustc_hir::{
-    self as hir, CRATE_OWNER_ID, HirId, ImplItemImplKind, LifetimeSource, PredicateOrigin, Target,
-    find_attr,
+    self as hir, HirId, ImplItemImplKind, LifetimeSource, PredicateOrigin, Target, find_attr,
 };
-use rustc_middle::middle::resolve::ResolverAstLowering;
-use rustc_middle::ty::TyCtxt;
 use rustc_middle::ty::data_structures::IndexMap;
 use rustc_span::def_id::{DefId, LocalDefId};
 use rustc_span::edit_distance::find_best_match_for_name;
@@ -28,14 +25,9 @@ use super::{
 };
 use crate::diagnostics::{ConstComptimeFn, ResolvingRestrictionKind, RestrictionAncestorOnly};
 
-pub(super) struct ItemLowerer<'a, 'hir> {
-    pub(super) tcx: TyCtxt<'hir>,
-    pub(super) resolver: &'a ResolverAstLowering<'hir>,
-}
-
-/// When we have a ty alias we *may* have two where clauses. To give the best diagnostics, we set the span
-/// to the where clause that is preferred, if it exists. Otherwise, it sets the span to the other where
-/// clause if it exists.
+/// When we have a ty alias we *may* have two where clauses. To give the best diagnostics, we set
+/// the span to the where clause that is preferred, if it exists. Otherwise, it sets the span to
+/// the other where clause if it exists.
 fn add_ty_alias_where_clause(
     generics: &mut ast::Generics,
     after_where_clause: &ast::WhereClause,
@@ -52,48 +44,6 @@ fn add_ty_alias_where_clause(
         if before.0 || !after.0 { before } else { after };
 }
 
-impl<'hir> ItemLowerer<'_, 'hir> {
-    fn with_lctx(
-        &mut self,
-        owner: NodeId,
-        f: impl FnOnce(&mut LoweringContext<'_, 'hir>) -> hir::OwnerNode<'hir>,
-    ) -> hir::MaybeOwner<'hir> {
-        let mut lctx = LoweringContext::new(self.tcx, self.resolver, owner);
-
-        let item = f(&mut lctx);
-
-        let info = lctx.curr_owner.into_owner_info(self.tcx, item);
-        hir::MaybeOwner::Owner(lctx.arena.alloc(info))
-    }
-
-    #[instrument(level = "debug", skip(self, c))]
-    pub(super) fn lower_crate(&mut self, c: &Crate) -> hir::MaybeOwner<'hir> {
-        self.with_lctx(CRATE_NODE_ID, |lctx| {
-            debug_assert_eq!(lctx.curr_owner.owner_id(), CRATE_OWNER_ID);
-            let module = lctx.lower_mod(&c.items, &c.spans);
-            lctx.lower_attrs(hir::CRATE_HIR_ID, &c.attrs, c.spans.inner_span, Target::Crate);
-            hir::OwnerNode::Crate(module)
-        })
-    }
-
-    #[instrument(level = "debug", skip(self))]
-    pub(super) fn lower_item(&mut self, item: &Item) -> hir::MaybeOwner<'hir> {
-        self.with_lctx(item.id, |lctx| hir::OwnerNode::Item(lctx.lower_item(item)))
-    }
-
-    pub(super) fn lower_trait_item(&mut self, item: &AssocItem) -> hir::MaybeOwner<'hir> {
-        self.with_lctx(item.id, |lctx| hir::OwnerNode::TraitItem(lctx.lower_trait_item(item)))
-    }
-
-    pub(super) fn lower_impl_item(&mut self, item: &AssocItem) -> hir::MaybeOwner<'hir> {
-        self.with_lctx(item.id, |lctx| hir::OwnerNode::ImplItem(lctx.lower_impl_item(item)))
-    }
-
-    pub(super) fn lower_foreign_item(&mut self, item: &ForeignItem) -> hir::MaybeOwner<'hir> {
-        self.with_lctx(item.id, |lctx| hir::OwnerNode::ForeignItem(lctx.lower_foreign_item(item)))
-    }
-}
-
 impl<'hir> LoweringContext<'_, 'hir> {
     pub(super) fn lower_mod(
         &mut self,
@@ -203,7 +153,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }
     }
 
-    fn lower_item(&mut self, i: &Item) -> &'hir hir::Item<'hir> {
+    pub(super) fn lower_item(&mut self, i: &Item) -> &'hir hir::Item<'hir> {
         let owner_id = self.curr_owner.owner_id();
         let hir_id: HirId = owner_id.into();
         let vis_span = self.lower_span(i.vis.span);
@@ -544,7 +494,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             }
             ItemKind::MacroDef(ident, MacroDef { body, macro_rules, eii_declaration: _ }) => {
                 let ident = self.lower_ident(*ident);
-                let body = Box::new(self.lower_delim_args(body));
+                let body = body.clone();
                 let def_id = self.curr_owner.owner.def_id;
                 let def_kind = self.tcx.def_kind(def_id);
                 let DefKind::Macro(macro_kinds) = def_kind else {
@@ -730,7 +680,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }
     }
 
-    fn lower_foreign_item(&mut self, i: &ForeignItem) -> &'hir hir::ForeignItem<'hir> {
+    pub(super) fn lower_foreign_item(&mut self, i: &ForeignItem) -> &'hir hir::ForeignItem<'hir> {
         let owner_id = self.curr_owner.owner_id();
         let hir_id: HirId = owner_id.into();
         let attrs =
@@ -911,7 +861,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }
     }
 
-    fn lower_trait_item(&mut self, i: &AssocItem) -> &'hir hir::TraitItem<'hir> {
+    pub(super) fn lower_trait_item(&mut self, i: &AssocItem) -> &'hir hir::TraitItem<'hir> {
         let trait_item_def_id = self.curr_owner.owner_id();
         let hir_id: HirId = trait_item_def_id.into();
         let attrs = self.lower_attrs(
@@ -1160,7 +1110,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         ident
     }
 
-    fn lower_impl_item(&mut self, i: &AssocItem) -> &'hir hir::ImplItem<'hir> {
+    pub(super) fn lower_impl_item(&mut self, i: &AssocItem) -> &'hir hir::ImplItem<'hir> {
         let owner_id = self.curr_owner.owner_id();
         let hir_id: HirId = owner_id.into();
         let parent_id = self.tcx.local_parent(owner_id.def_id);
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index 19c37f4a76065..410823919c523 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -60,8 +60,9 @@ use rustc_hir::def_id::{DefId, LOCAL_CRATE, LocalDefId, LocalDefIdMap};
 use rustc_hir::definitions::PerParentDisambiguatorState;
 use rustc_hir::lints::DelayedLint;
 use rustc_hir::{
-    self as hir, AngleBrackets, ConstArg, GenericArg, HirId, ItemLocalMap, LifetimeSource,
-    LifetimeSyntax, MissingLifetimeKind, ParamName, Target, TraitCandidate, find_attr,
+    self as hir, AngleBrackets, CRATE_OWNER_ID, ConstArg, GenericArg, HirId, ItemLocalMap,
+    LifetimeSource, LifetimeSyntax, MissingLifetimeKind, ParamName, Target, TraitCandidate,
+    find_attr,
 };
 use rustc_index::{Idx, IndexSlice, IndexVec};
 use rustc_macros::extension;
@@ -296,7 +297,7 @@ struct LoweringContext<'a, 'hir> {
 
     /// Used to get the current `fn`'s def span to point to when using `await`
     /// outside of an `async fn`.
-    current_item: Option<Span>,
+    current_item_span: Option<Span>,
 
     try_block_scope: TryBlockScope,
     loop_scope: Option<HirId>,
@@ -366,7 +367,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             is_in_dyn_type: false,
             coroutine_kind: None,
             task_context: None,
-            current_item: None,
+            current_item_span: None,
 
             move_expr_bindings: Vec::new(),
             lowering_move_expr_initializer: false,
@@ -783,15 +784,37 @@ fn lower_to_hir(tcx: TyCtxt<'_>, def_id: LocalDefId) -> hir::MaybeOwner<'_> {
         return fallback_to_ancestor(tcx.local_parent(def_id));
     };
 
-    let mut item_lowerer = item::ItemLowerer { tcx, resolver: &*resolver };
+    fn with_lctx<'hir>(
+        tcx: TyCtxt<'hir>,
+        resolver: &ResolverAstLowering<'hir>,
+        owner: NodeId,
+        f: impl FnOnce(&mut LoweringContext<'_, 'hir>) -> hir::OwnerNode<'hir>,
+    ) -> hir::MaybeOwner<'hir> {
+        let mut lctx = LoweringContext::new(tcx, resolver, owner);
+        let item = f(&mut lctx);
+        hir::MaybeOwner::Owner(lctx.curr_owner.into_owner_info(tcx, item))
+    }
 
     let item = match &node {
         // The item existed in the AST.
-        AstOwner::Crate(c) => item_lowerer.lower_crate(&c),
-        AstOwner::Item(item) => item_lowerer.lower_item(&item),
-        AstOwner::TraitItem(item) => item_lowerer.lower_trait_item(&item),
-        AstOwner::ImplItem(item) => item_lowerer.lower_impl_item(&item),
-        AstOwner::ForeignItem(item) => item_lowerer.lower_foreign_item(&item),
+        AstOwner::Crate(c) => with_lctx(tcx, &*resolver, CRATE_NODE_ID, |lctx| {
+            debug_assert_eq!(lctx.curr_owner.owner_id(), CRATE_OWNER_ID);
+            let module = lctx.lower_mod(&c.items, &c.spans);
+            lctx.lower_attrs(hir::CRATE_HIR_ID, &c.attrs, c.spans.inner_span, Target::Crate);
+            hir::OwnerNode::Crate(module)
+        }),
+        AstOwner::Item(item) => {
+            with_lctx(tcx, &*resolver, item.id, |lctx| hir::OwnerNode::Item(lctx.lower_item(item)))
+        }
+        AstOwner::TraitItem(item) => with_lctx(tcx, &*resolver, item.id, |lctx| {
+            hir::OwnerNode::TraitItem(lctx.lower_trait_item(item))
+        }),
+        AstOwner::ImplItem(item) => with_lctx(tcx, &*resolver, item.id, |lctx| {
+            hir::OwnerNode::ImplItem(lctx.lower_impl_item(item))
+        }),
+        AstOwner::ForeignItem(item) => with_lctx(tcx, &*resolver, item.id, |lctx| {
+            hir::OwnerNode::ForeignItem(lctx.lower_foreign_item(item))
+        }),
         AstOwner::NestedUseTree(owner_id) => fallback_to_ancestor(*owner_id),
         // The item existed in the AST, but is not a HIR owner.
         // Fetch the correct information from its parent.
@@ -824,7 +847,7 @@ enum GenericArgsMode {
     ParenSugar,
     /// Allow RTN, don't allow paren sugar.
     ReturnTypeNotation,
-    // Error if parenthesized generics or RTN are encountered.
+    /// Error if parenthesized generics or RTN are encountered.
     Err,
     /// Silence errors when lowering generics. Only used with `Res::Err`.
     Silence,
@@ -982,7 +1005,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     }
 
     #[instrument(level = "trace", skip(self))]
-    fn lower_res(&mut self, res: Res<NodeId>) -> Res {
+    fn lower_res(&self, res: Res<NodeId>) -> Res {
         let res: Result<Res, ()> = res.apply_id(|id| {
             let owner = self.curr_owner.owner_id();
             let local_id =
@@ -999,11 +1022,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
         res.unwrap_or(Res::Err)
     }
 
-    fn expect_full_res(&mut self, id: NodeId) -> Res<NodeId> {
+    fn expect_full_res(&self, id: NodeId) -> Res<NodeId> {
         self.get_partial_res(id).map_or(Res::Err, |pr| pr.expect_full_res())
     }
 
-    fn lower_import_res(&mut self, id: NodeId, span: Span) -> PerNS<Option<Res>> {
+    fn lower_import_res(&self, id: NodeId, span: Span) -> PerNS<Option<Res>> {
         debug_assert_eq!(id, self.curr_owner.owner.id);
         let per_ns = self.curr_owner.owner.import_res.map(|res| res.map(|res| self.lower_res(res)));
         if per_ns.is_empty() {
@@ -1154,8 +1177,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
     }
 
     fn with_new_scopes<T>(&mut self, scope_span: Span, f: impl FnOnce(&mut Self) -> T) -> T {
-        let current_item = self.current_item;
-        self.current_item = Some(scope_span);
+        let current_item_span = self.current_item_span;
+        self.current_item_span = Some(scope_span);
 
         let was_in_loop_condition = self.is_in_loop_condition;
         self.is_in_loop_condition = false;
@@ -1172,7 +1195,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
         self.is_in_loop_condition = was_in_loop_condition;
 
-        self.current_item = current_item;
+        self.current_item_span = current_item_span;
 
         ret
     }
@@ -1261,10 +1284,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }
     }
 
-    fn lower_delim_args(&self, args: &DelimArgs) -> DelimArgs {
-        args.clone()
-    }
-
     /// Lower an associated item constraint.
     #[instrument(level = "debug", skip_all)]
     fn lower_assoc_item_constraint(
@@ -1647,8 +1666,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 self.lower_array_length_to_const_arg(length),
             ),
             TyKind::TraitObject(bounds, kind) => {
-                let mut lifetime_bound = None;
                 let (bounds, lifetime_bound) = self.with_dyn_type_scope(true, |this| {
+                    let mut lifetime_bound = None;
                     let bounds =
                         this.arena.alloc_from_iter(bounds.iter().filter_map(|bound| match bound {
                             // We can safely ignore constness here since AST validation
@@ -1681,9 +1700,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                                 None
                             }
                         }));
-                    let lifetime_bound =
-                        lifetime_bound.unwrap_or_else(|| this.elided_dyn_bound(t.span));
-                    (bounds, lifetime_bound)
+                    (bounds, lifetime_bound.unwrap_or_else(|| this.elided_dyn_bound(t.span)))
                 });
                 hir::TyKind::TraitObject(bounds, TaggedRef::new(lifetime_bound, *kind))
             }
@@ -3058,7 +3075,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }))
     }
 
-    fn lower_unsafe_source(&mut self, u: UnsafeSource) -> hir::UnsafeSource {
+    fn lower_unsafe_source(&self, u: UnsafeSource) -> hir::UnsafeSource {
         match u {
             CompilerGenerated => hir::UnsafeSource::CompilerGenerated,
             UserProvided => hir::UnsafeSource::UserProvided,
@@ -3066,7 +3083,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     }
 
     fn lower_trait_bound_modifiers(
-        &mut self,
+        &self,
         modifiers: TraitBoundModifiers,
     ) -> hir::TraitBoundModifiers {
         let constness = match modifiers.constness {
diff --git a/compiler/rustc_attr_parsing/src/attributes/allow_unstable.rs b/compiler/rustc_attr_parsing/src/attributes/allow_unstable.rs
index 743d3c9b5e76e..667c2d0838a25 100644
--- a/compiler/rustc_attr_parsing/src/attributes/allow_unstable.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/allow_unstable.rs
@@ -12,12 +12,8 @@ impl CombineAttributeParser for AllowInternalUnstableParser {
     type Item = (Symbol, Span);
     const CONVERT: ConvertFn<Self::Item> =
         |items, span| AttributeKind::AllowInternalUnstable(items, span);
-    const ALLOWED_TARGETS: AllowedTargets<'_> = AllowedTargets::AllowList(&[
-        Allow(Target::MacroDef),
-        Allow(Target::Fn),
-        Warn(Target::Field),
-        Warn(Target::Arm),
-    ]);
+    const ALLOWED_TARGETS: AllowedTargets<'_> =
+        AllowedTargets::AllowList(&[Allow(Target::MacroDef), Allow(Target::Fn)]);
     const TEMPLATE: AttributeTemplate = template!(Word, List: &["feat1, feat2, ..."]);
     const STABILITY: AttributeStability = unstable!(allow_internal_unstable);
 
diff --git a/compiler/rustc_attr_parsing/src/attributes/macro_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/macro_attrs.rs
index c9625521aec44..92b61fe00b1b9 100644
--- a/compiler/rustc_attr_parsing/src/attributes/macro_attrs.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/macro_attrs.rs
@@ -131,12 +131,8 @@ pub(crate) struct AllowInternalUnsafeParser;
 impl NoArgsAttributeParser for AllowInternalUnsafeParser {
     const PATH: &[Symbol] = &[sym::allow_internal_unsafe];
     const ON_DUPLICATE: OnDuplicate = OnDuplicate::Ignore;
-    const ALLOWED_TARGETS: AllowedTargets<'_> = AllowedTargets::AllowList(&[
-        Allow(Target::Fn),
-        Allow(Target::MacroDef),
-        Warn(Target::Field),
-        Warn(Target::Arm),
-    ]);
+    const ALLOWED_TARGETS: AllowedTargets<'_> =
+        AllowedTargets::AllowList(&[Allow(Target::Fn), Allow(Target::MacroDef)]);
     const STABILITY: AttributeStability = unstable!(allow_internal_unsafe);
     const CREATE: fn(Span) -> AttributeKind = |span| AttributeKind::AllowInternalUnsafe(span);
 
diff --git a/compiler/rustc_attr_parsing/src/attributes/traits.rs b/compiler/rustc_attr_parsing/src/attributes/traits.rs
index 1d0d26ea62cb3..e55a033eb3188 100644
--- a/compiler/rustc_attr_parsing/src/attributes/traits.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/traits.rs
@@ -8,7 +8,7 @@ use crate::attributes::{NoArgsAttributeParser, SingleAttributeParser};
 use crate::context::AcceptContext;
 use crate::parser::ArgParser;
 use crate::target_checking::AllowedTargets;
-use crate::target_checking::Policy::{Allow, Warn};
+use crate::target_checking::Policy::Allow;
 
 pub(crate) struct RustcSkipDuringMethodDispatchParser;
 impl SingleAttributeParser for RustcSkipDuringMethodDispatchParser {
@@ -63,12 +63,7 @@ impl NoArgsAttributeParser for RustcParenSugarParser {
 pub(crate) struct MarkerParser;
 impl NoArgsAttributeParser for MarkerParser {
     const PATH: &[Symbol] = &[sym::marker];
-    const ALLOWED_TARGETS: AllowedTargets<'_> = AllowedTargets::AllowList(&[
-        Allow(Target::Trait),
-        Warn(Target::Field),
-        Warn(Target::Arm),
-        Warn(Target::MacroDef),
-    ]);
+    const ALLOWED_TARGETS: AllowedTargets<'_> = AllowedTargets::AllowList(&[Allow(Target::Trait)]);
     const STABILITY: AttributeStability = unstable!(marker_trait_attr);
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::Marker;
 }
diff --git a/compiler/rustc_borrowck/src/region_infer/values.rs b/compiler/rustc_borrowck/src/region_infer/values.rs
index 35009c3bad485..2f03fec0d2245 100644
--- a/compiler/rustc_borrowck/src/region_infer/values.rs
+++ b/compiler/rustc_borrowck/src/region_infer/values.rs
@@ -409,16 +409,6 @@ impl<'tcx, N: Idx> RegionValues<'tcx, N> {
     }
 }
 
-/// For debugging purposes, returns a pretty-printed string of the given points.
-pub(crate) fn pretty_print_points(
-    location_map: &DenseLocationMap,
-    points: impl IntoIterator<Item = PointIndex>,
-) -> String {
-    pretty_print_region_elements(
-        points.into_iter().map(|p| location_map.to_location(p)).map(RegionElement::Location),
-    )
-}
-
 /// For debugging purposes, returns a pretty-printed string of the given region elements.
 fn pretty_print_region_elements<'tcx>(
     elements: impl IntoIterator<Item = RegionElement<'tcx>>,
diff --git a/compiler/rustc_borrowck/src/type_check/liveness/mod.rs b/compiler/rustc_borrowck/src/type_check/liveness/mod.rs
index 2de6635e93ac7..c2fa8ab8637af 100644
--- a/compiler/rustc_borrowck/src/type_check/liveness/mod.rs
+++ b/compiler/rustc_borrowck/src/type_check/liveness/mod.rs
@@ -1,15 +1,18 @@
 use itertools::{Either, Itertools};
 use rustc_data_structures::fx::FxHashSet;
+use rustc_index::interval::IntervalSet;
 use rustc_middle::mir::visit::{TyContext, Visitor};
 use rustc_middle::mir::{Body, Local, Location, SourceInfo};
 use rustc_middle::ty::relate::Relate;
 use rustc_middle::ty::{GenericArgsRef, Region, RegionVid, Ty, TyCtxt, TypeVisitable};
 use rustc_mir_dataflow::move_paths::MoveData;
-use rustc_mir_dataflow::points::DenseLocationMap;
+use rustc_mir_dataflow::points::{DenseLocationMap, PointIndex};
 use rustc_span::span_bug;
+use rustc_trait_selection::traits::outlives_for_liveness::FreeRegionsVisitor;
 use tracing::debug;
 
 use super::TypeChecker;
+use crate::BorrowckInferCtxt;
 use crate::constraints::OutlivesConstraintSet;
 use crate::polonius::{PoloniusContext, record_live_region_variance};
 use crate::region_infer::values::LivenessValues;
@@ -229,3 +232,18 @@ impl<'a, 'tcx> LiveVariablesVisitor<'a, 'tcx> {
         }
     }
 }
+
+pub(crate) fn make_all_regions_live<'tcx>(
+    infcx: &BorrowckInferCtxt<'tcx>,
+    universal_regions: &UniversalRegions<'tcx>,
+    liveness: &mut LivenessValues,
+    value: impl TypeVisitable<TyCtxt<'tcx>>,
+    live_at: &IntervalSet<PointIndex>,
+) {
+    debug!("make_all_regions_live(value={value:?})");
+    value.visit_with(&mut FreeRegionsVisitor {
+        tcx: infcx.tcx,
+        param_env: infcx.param_env,
+        op: |r| liveness.add_points(universal_regions.to_region_vid(r), live_at),
+    });
+}
diff --git a/compiler/rustc_borrowck/src/type_check/liveness/trace.rs b/compiler/rustc_borrowck/src/type_check/liveness/trace.rs
index 90126866cd500..d0302faa513b2 100644
--- a/compiler/rustc_borrowck/src/type_check/liveness/trace.rs
+++ b/compiler/rustc_borrowck/src/type_check/liveness/trace.rs
@@ -6,7 +6,7 @@ use rustc_infer::infer::canonical::QueryRegionConstraints;
 use rustc_infer::traits::TraitErrors;
 use rustc_middle::mir::{BasicBlock, Body, ConstraintCategory, Local, Location};
 use rustc_middle::traits::query::DropckOutlivesResult;
-use rustc_middle::ty::{Ty, TyCtxt, TypeVisitable, TypeVisitableExt};
+use rustc_middle::ty::{GenericArg, Ty, TypeVisitableExt};
 use rustc_mir_dataflow::impls::MaybeInitializedPlaces;
 use rustc_mir_dataflow::move_paths::{HasMoveData, MoveData, MovePathIndex};
 use rustc_mir_dataflow::points::{DenseLocationMap, PointIndex};
@@ -14,16 +14,17 @@ use rustc_mir_dataflow::{Analysis, MaybeReachable, ResultsCursor};
 use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span};
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::traits::ObligationCtxt;
-use rustc_trait_selection::traits::outlives_for_liveness::FreeRegionsVisitor;
 use rustc_trait_selection::traits::query::dropck_outlives;
 use rustc_trait_selection::traits::query::type_op::{DropckOutlives, TypeOpOutput};
 use tracing::debug;
 
-use crate::BorrowckInferCtxt;
-use crate::polonius::{self, record_live_region_variance};
-use crate::region_infer::values;
+use crate::polonius::{LiveRegionVariances, record_live_region_variance};
+use crate::region_infer::values::LivenessValues;
 use crate::type_check::liveness::local_use_map::LocalUseMap;
+use crate::type_check::liveness::make_all_regions_live;
 use crate::type_check::{NormalizeLocation, TypeChecker};
+use crate::universal_regions::UniversalRegions;
+use crate::{BorrowckInferCtxt, polonius};
 
 /// This is the heart of the liveness computation. For each variable X
 /// that requires a liveness computation, it walks over all the uses
@@ -48,33 +49,28 @@ pub(super) fn trace<'tcx>(
 ) {
     let _timer = typeck.tcx().prof.generic_activity("borrowck_liveness_trace");
 
-    let local_use_map = &LocalUseMap::build(&relevant_live_locals, location_map, typeck.body);
-    let cx = LivenessContext {
-        typeck,
-        flow_inits: None,
+    let local_use_map = LocalUseMap::build(&relevant_live_locals, location_map, typeck.body);
+    let comp = LivenessComputation::new(
+        typeck.infcx,
+        typeck.body,
         location_map,
-        local_use_map,
         move_data,
-        term_states: IndexVec::new(),
-        exit_states: IndexVec::new(),
-        drop_data: FxIndexMap::default(),
-    };
+        &local_use_map,
+    );
 
-    let mut results = LivenessResults::new(cx);
+    let mut results = LivenessResults::new(typeck, comp);
 
-    results.add_extra_drop_facts(relevant_live_locals);
+    results.record_legacy_polonius_drop_facts(relevant_live_locals);
 
     results.compute_for_all_locals(relevant_live_locals);
 
     results.dropck_boring_locals(boring_locals);
 }
 
-/// Contextual state for the type-liveness coroutine.
-struct LivenessContext<'a, 'typeck, 'tcx> {
-    /// Current type-checker, giving us our inference context etc.
-    ///
-    /// This also stores the body we're currently analyzing.
-    typeck: &'a mut TypeChecker<'typeck, 'tcx>,
+pub(crate) struct LivenessComputation<'a, 'tcx> {
+    pub(crate) infcx: &'a BorrowckInferCtxt<'tcx>,
+
+    pub(crate) body: &'a Body<'tcx>,
 
     /// Defines the `PointIndex` mapping
     location_map: &'a DenseLocationMap,
@@ -82,9 +78,6 @@ struct LivenessContext<'a, 'typeck, 'tcx> {
     /// Mapping to/from the various indices used for initialization tracking.
     move_data: &'a MoveData<'tcx>,
 
-    /// Cache for the results of `dropck_outlives` query.
-    drop_data: FxIndexMap<Ty<'tcx>, DropData<'tcx>>,
-
     /// Results of dataflow tracking which variables (and paths) have been
     /// initialized. Computed lazily when needed by drop-liveness.
     flow_inits: Option<ResultsCursor<'a, 'tcx, MaybeInitializedPlaces<'a, 'tcx>>>,
@@ -96,15 +89,6 @@ struct LivenessContext<'a, 'typeck, 'tcx> {
     // Caches for the results of `initialized_at_terminator` and `initialized_at_exit`.
     term_states: IndexVec<BasicBlock, Option<MaybeReachable<MixedBitSet<MovePathIndex>>>>,
     exit_states: IndexVec<BasicBlock, Option<MaybeReachable<MixedBitSet<MovePathIndex>>>>,
-}
-
-struct DropData<'tcx> {
-    dropck_result: DropckOutlivesResult<'tcx>,
-    region_constraint_data: Option<&'tcx QueryRegionConstraints<'tcx>>,
-}
-
-struct LivenessResults<'a, 'typeck, 'tcx> {
-    cx: LivenessContext<'a, 'typeck, 'tcx>,
 
     /// Set of points that define the current local.
     defs: DenseBitSet<PointIndex>,
@@ -125,43 +109,70 @@ struct LivenessResults<'a, 'typeck, 'tcx> {
     stack: Vec<PointIndex>,
 }
 
+struct LivenessResults<'a, 'typeck, 'tcx> {
+    /// Current type-checker, giving us our inference context etc.
+    typeck: &'a mut TypeChecker<'typeck, 'tcx>,
+
+    /// Cache for the results of `dropck_outlives` query.
+    drop_data: FxIndexMap<Ty<'tcx>, DropData<'tcx>>,
+
+    comp: LivenessComputation<'a, 'tcx>,
+}
+
 impl<'a, 'typeck, 'tcx> LivenessResults<'a, 'typeck, 'tcx> {
-    fn new(cx: LivenessContext<'a, 'typeck, 'tcx>) -> Self {
-        let num_points = cx.location_map.num_points();
-        LivenessResults {
-            cx,
-            defs: DenseBitSet::new_empty(num_points),
-            use_live_at: IntervalSet::new(num_points),
-            drop_live_at: DenseBitSet::new_empty(num_points),
-            drop_locations: vec![],
-            stack: vec![],
-        }
+    fn new(
+        typeck: &'a mut TypeChecker<'typeck, 'tcx>,
+        comp: LivenessComputation<'a, 'tcx>,
+    ) -> Self {
+        LivenessResults { typeck, drop_data: FxIndexMap::default(), comp }
     }
 
     fn compute_for_all_locals(&mut self, relevant_live_locals: &[Local]) {
         for &local in relevant_live_locals {
-            self.reset_local_state();
-            self.add_defs_for(local);
-            self.compute_use_live_points_for(local);
-            self.compute_drop_live_points_for(local);
+            self.compute_for_local(local);
+        }
+    }
 
-            let local_ty = self.cx.body().local_decls[local].ty;
+    fn compute_for_local(&mut self, local: Local) {
+        // If we end up needing to compute the drop data (because there are
+        // drop-live points), then we need to register region constraints and
+        // emit drop facts.
+        let mut computed_drop_data = None;
+
+        self.comp.compute(
+            local,
+            self.typeck.universal_regions,
+            self.typeck.polonius_context.as_mut().map(|c| &mut c.live_region_variances),
+            &mut self.typeck.constraints.liveness_constraints,
+            || {
+                let local_ty = self.comp.body.local_decls[local].ty;
+                let local_span = self.comp.body.local_decls[local].source_info.span;
+                let drop_data =
+                    dropck_local(&self.typeck.infcx, &mut self.drop_data, local_ty, local_span);
+                let drop_data = computed_drop_data.insert(drop_data);
+                &drop_data.dropck_result.kinds
+            },
+        );
 
-            if !self.use_live_at.is_empty() {
-                self.cx.add_use_live_facts_for(local_ty, &self.use_live_at);
+        if let Some(drop_data) = computed_drop_data {
+            if let Some(data) = &drop_data.region_constraint_data {
+                for &drop_location in &self.comp.drop_locations {
+                    self.typeck.push_region_constraints(
+                        drop_location.to_locations(),
+                        ConstraintCategory::Boring,
+                        data,
+                    );
+                }
             }
 
-            if !self.drop_live_at.is_empty() {
-                // `drop_live_at` is using a DenseBitSet, but `add_drop_live_facts_for` expects
-                // an IntervalSet. We thus convert between those two here.
-                let mut set: IntervalSet<PointIndex> =
-                    IntervalSet::new(self.drop_live_at.domain_size());
-                for item in self.drop_live_at.iter() {
-                    // We iterate the `drop_live_at` set from smallest to largest values, so
-                    // we can use append to add things to the interval set at the end.
-                    set.append(item);
-                }
-                self.cx.add_drop_live_facts_for(local, local_ty, &self.drop_locations, &set);
+            for &kind in &drop_data.dropck_result.kinds {
+                polonius::legacy::emit_drop_facts(
+                    self.typeck.tcx(),
+                    local,
+                    &kind,
+                    self.typeck.universal_regions,
+                    self.typeck.polonius_facts,
+                );
             }
         }
     }
@@ -174,27 +185,26 @@ impl<'a, 'typeck, 'tcx> LivenessResults<'a, 'typeck, 'tcx> {
     /// and can therefore safely be dropped.
     fn dropck_boring_locals(&mut self, boring_locals: &[Local]) {
         for &local in boring_locals {
-            let local_ty = self.cx.body().local_decls[local].ty;
-            let local_span = self.cx.body().local_decls[local].source_info.span;
-            dropck_local(&self.cx.typeck.infcx, &mut self.cx.drop_data, local_ty, local_span);
+            let local_ty = self.comp.body.local_decls[local].ty;
+            let local_span = self.comp.body.local_decls[local].source_info.span;
+            dropck_local(&self.typeck.infcx, &mut self.drop_data, local_ty, local_span);
         }
     }
 
-    /// Add extra drop facts needed for Polonius.
+    /// Add extra drop facts needed for Polonius Legacy.
     ///
     /// Add facts for all locals with free regions, since regions may outlive
     /// the function body only at certain nodes in the CFG.
-    fn add_extra_drop_facts(&mut self, relevant_live_locals: &[Local]) {
-        // This collect is more necessary than immediately apparent
-        // because these facts go into `add_drop_live_facts_for()`,
-        // which also writes to `polonius_facts`, and so this is genuinely
-        // a simultaneous overlapping mutable borrow.
+    fn record_legacy_polonius_drop_facts(&mut self, relevant_live_locals: &[Local]) {
+        // This is *all wonky* because this used to call a shared
+        // `add_drop_live_facts_for` function that was also used for regular
+        // relevant locals. Presumably, this can be cleaned up quite a bit.
         // FIXME for future hackers: investigate whether this is
         // actually necessary; these facts come from Polonius
         // and probably maybe plausibly does not need to go back in.
         // It may be necessary to just pick out the parts of
         // `add_drop_live_facts_for()` that make sense.
-        let Some(facts) = self.cx.typeck.polonius_facts.as_ref() else { return };
+        let Some(facts) = self.typeck.polonius_facts.as_ref() else { return };
         let facts_to_add: Vec<_> = {
             let relevant_live_locals: FxIndexSet<_> =
                 relevant_live_locals.iter().copied().collect();
@@ -203,20 +213,155 @@ impl<'a, 'typeck, 'tcx> LivenessResults<'a, 'typeck, 'tcx> {
                 .var_dropped_at
                 .iter()
                 .filter_map(|&(local, location_index)| {
-                    let local_ty = self.cx.body().local_decls[local].ty;
+                    let local_ty = self.comp.body.local_decls[local].ty;
                     if relevant_live_locals.contains(&local) || !local_ty.has_free_regions() {
                         return None;
                     }
 
-                    let location = self.cx.typeck.location_table.to_location(location_index);
+                    let location = self.typeck.location_table.to_location(location_index);
                     Some((local, local_ty, location))
                 })
                 .collect()
         };
 
-        let live_at = IntervalSet::new(self.cx.location_map.num_points());
+        let live_at = IntervalSet::new(self.comp.location_map.num_points());
         for (local, local_ty, location) in facts_to_add {
-            self.cx.add_drop_live_facts_for(local, local_ty, &[location], &live_at);
+            let local_span = self.comp.body.local_decls[local].source_info.span;
+            let drop_data =
+                dropck_local(&self.typeck.infcx, &mut self.drop_data, local_ty, local_span);
+
+            if let Some(data) = &drop_data.region_constraint_data {
+                self.typeck.push_region_constraints(
+                    location.to_locations(),
+                    ConstraintCategory::Boring,
+                    data,
+                );
+            }
+
+            for &kind in &drop_data.dropck_result.kinds {
+                make_all_regions_live(
+                    self.typeck.infcx,
+                    self.typeck.universal_regions,
+                    &mut self.typeck.constraints.liveness_constraints,
+                    kind,
+                    &live_at,
+                );
+                polonius::legacy::emit_drop_facts(
+                    self.typeck.tcx(),
+                    local,
+                    &kind,
+                    self.typeck.universal_regions,
+                    self.typeck.polonius_facts,
+                );
+            }
+
+            if let Some(polonius_context) = self.typeck.polonius_context.as_mut() {
+                record_live_region_variance(
+                    self.typeck.infcx.tcx,
+                    &mut polonius_context.live_region_variances,
+                    self.typeck.universal_regions,
+                    local_ty,
+                );
+            }
+        }
+    }
+}
+
+enum InitAtLocation {
+    Terminator,
+    Exit,
+}
+
+impl<'a, 'tcx> LivenessComputation<'a, 'tcx> {
+    pub(crate) fn new(
+        infcx: &'a BorrowckInferCtxt<'tcx>,
+        body: &'a Body<'tcx>,
+        location_map: &'a DenseLocationMap,
+        move_data: &'a MoveData<'tcx>,
+        local_use_map: &'a LocalUseMap,
+    ) -> Self {
+        let num_points = location_map.num_points();
+        LivenessComputation {
+            infcx,
+            body,
+            location_map,
+            move_data,
+            flow_inits: None,
+            local_use_map,
+            term_states: IndexVec::new(),
+            exit_states: IndexVec::new(),
+            defs: DenseBitSet::new_empty(num_points),
+            use_live_at: IntervalSet::new(num_points),
+            drop_live_at: DenseBitSet::new_empty(num_points),
+            drop_locations: vec![],
+            stack: vec![],
+        }
+    }
+
+    /// Compute for a given local the use- and drop-live points
+    fn compute<'drop_data>(
+        &mut self,
+        local: Local,
+        universal_regions: &UniversalRegions<'tcx>,
+        live_region_variances: Option<&mut LiveRegionVariances>,
+        liveness_constraints: &mut LivenessValues,
+        get_drop_args: impl FnOnce() -> &'drop_data Vec<GenericArg<'tcx>>,
+    ) where
+        'tcx: 'drop_data,
+    {
+        self.reset_local_state();
+        self.add_defs_for(local);
+        self.compute_use_live_points_for(local);
+        self.compute_drop_live_points_for(local);
+
+        let local_ty = self.body.local_decls[local].ty;
+
+        // When using `-Zpolonius=next`, we also record the variance of regions in this live type.
+        // For dropck in particular, note that we walk the type and not its live components seen in
+        // the dropck results. See issue #160670.
+        let is_live_anywhere = !self.use_live_at.is_empty() || !self.drop_live_at.is_empty();
+        if is_live_anywhere && let Some(live_region_variances) = live_region_variances {
+            record_live_region_variance(
+                self.infcx.tcx,
+                live_region_variances,
+                universal_regions,
+                local_ty,
+            );
+        }
+        if !self.use_live_at.is_empty() {
+            make_all_regions_live(
+                self.infcx,
+                universal_regions,
+                liveness_constraints,
+                local_ty,
+                &self.use_live_at,
+            );
+        }
+        if !self.drop_live_at.is_empty() {
+            let drop_data = get_drop_args();
+
+            // `drop_live_at` is using a DenseBitSet, but `make_all_regions_live`
+            // expects an IntervalSet. We thus convert between those two here.
+            // Using a `DenseBitSet` has better performance, but storing liveness
+            // as a dense matrix has worse performance. There's probably room here
+            // for some cleanup, but this works for now.
+            let mut drop_live_at: IntervalSet<PointIndex> =
+                IntervalSet::new(self.drop_live_at.domain_size());
+            for item in self.drop_live_at.iter() {
+                // We iterate the `drop_live_at` set from smallest to largest values, so
+                // we can use append to add things to the interval set at the end.
+                drop_live_at.append(item);
+            }
+
+            for &kind in drop_data {
+                make_all_regions_live(
+                    self.infcx,
+                    universal_regions,
+                    liveness_constraints,
+                    kind,
+                    &drop_live_at,
+                );
+            }
         }
     }
 
@@ -231,7 +376,7 @@ impl<'a, 'typeck, 'tcx> LivenessResults<'a, 'typeck, 'tcx> {
 
     /// Adds the definitions of `local` into `self.defs`.
     fn add_defs_for(&mut self, local: Local) {
-        for def in self.cx.local_use_map.defs(local) {
+        for def in self.local_use_map.defs(local) {
             debug!("- defined at {:?}", def);
             self.defs.insert(def);
         }
@@ -246,14 +391,14 @@ impl<'a, 'typeck, 'tcx> LivenessResults<'a, 'typeck, 'tcx> {
     fn compute_use_live_points_for(&mut self, local: Local) {
         debug!("compute_use_live_points_for(local={:?})", local);
 
-        self.stack.extend(self.cx.local_use_map.uses(local));
+        self.stack.extend(self.local_use_map.uses(local));
         while let Some(p) = self.stack.pop() {
             // We are live in this block from the closest to us of:
             //
             //  * Inclusively, the block start
             //  * Exclusively, the previous definition (if it's in this block)
             //  * Exclusively, the previous live_at setting (an optimization)
-            let block_start = self.cx.location_map.to_block_start(p);
+            let block_start = self.location_map.to_block_start(p);
             let previous_defs = self.defs.last_set_in(block_start..=p);
             let previous_live_at = self.use_live_at.last_set_in(block_start..=p);
 
@@ -277,12 +422,12 @@ impl<'a, 'typeck, 'tcx> LivenessResults<'a, 'typeck, 'tcx> {
                 // terminators of predecessor basic blocks. Push those onto the
                 // stack so that the next iteration(s) will process them.
 
-                let block = self.cx.location_map.to_location(block_start).block;
+                let block = self.location_map.to_location(block_start).block;
                 self.stack.extend(
-                    self.cx.body().basic_blocks.predecessors()[block]
+                    self.body.basic_blocks.predecessors()[block]
                         .iter()
-                        .map(|&pred_bb| self.cx.body().terminator_loc(pred_bb))
-                        .map(|pred_loc| self.cx.location_map.point_from_location(pred_loc)),
+                        .map(|&pred_bb| self.body.terminator_loc(pred_bb))
+                        .map(|pred_loc| self.location_map.point_from_location(pred_loc)),
                 );
             }
         }
@@ -300,15 +445,15 @@ impl<'a, 'typeck, 'tcx> LivenessResults<'a, 'typeck, 'tcx> {
     fn compute_drop_live_points_for(&mut self, local: Local) {
         debug!("compute_drop_live_points_for(local={:?})", local);
 
-        let Some(mpi) = self.cx.move_data.rev_lookup.find_local(local) else { return };
+        let Some(mpi) = self.move_data.rev_lookup.find_local(local) else { return };
         debug!("compute_drop_live_points_for: mpi = {:?}", mpi);
 
         // Find the drops where `local` is initialized.
-        for drop_point in self.cx.local_use_map.drops(local) {
-            let location = self.cx.location_map.to_location(drop_point);
-            debug_assert_eq!(self.cx.body().terminator_loc(location.block), location,);
+        for drop_point in self.local_use_map.drops(local) {
+            let location = self.location_map.to_location(drop_point);
+            debug_assert_eq!(self.body.terminator_loc(location.block), location,);
 
-            if self.cx.initialized_at_terminator(location.block, mpi) {
+            if self.initialized_at_terminator(location.block, mpi) {
                 let inserted = self.drop_live_at.insert(drop_point);
                 // Right now, we should not visit a drop_point twice.
                 // If we do, this will trigger a debug assert so we know we can optimize.
@@ -342,8 +487,8 @@ impl<'a, 'typeck, 'tcx> LivenessResults<'a, 'typeck, 'tcx> {
     fn compute_drop_live_points_for_block(&mut self, mpi: MovePathIndex, term_point: PointIndex) {
         debug!(
             "compute_drop_live_points_for_block(mpi={:?}, term_point={:?})",
-            self.cx.move_data.move_paths[mpi].place,
-            self.cx.location_map.to_location(term_point),
+            self.move_data.move_paths[mpi].place,
+            self.location_map.to_location(term_point),
         );
 
         // We are only invoked with terminators where `mpi` is
@@ -353,14 +498,14 @@ impl<'a, 'typeck, 'tcx> LivenessResults<'a, 'typeck, 'tcx> {
         // Otherwise, scan backwards through the statements in the
         // block. One of them may be either a definition or use
         // live point.
-        let term_location = self.cx.location_map.to_location(term_point);
-        debug_assert_eq!(self.cx.body().terminator_loc(term_location.block), term_location,);
+        let term_location = self.location_map.to_location(term_point);
+        debug_assert_eq!(self.body.terminator_loc(term_location.block), term_location,);
         let block = term_location.block;
-        let entry_point = self.cx.location_map.entry_point(term_location.block);
+        let entry_point = self.location_map.entry_point(term_location.block);
         for p in (entry_point..term_point).rev() {
             debug!(
                 "compute_drop_live_points_for_block: p = {:?}",
-                self.cx.location_map.to_location(p)
+                self.location_map.to_location(p)
             );
 
             if self.defs.contains(p) {
@@ -379,7 +524,7 @@ impl<'a, 'typeck, 'tcx> LivenessResults<'a, 'typeck, 'tcx> {
             }
         }
 
-        let body = self.cx.typeck.body;
+        let body = self.body;
         for &pred_block in body.basic_blocks.predecessors()[block].iter() {
             debug!("compute_drop_live_points_for_block: pred_block = {:?}", pred_block,);
 
@@ -401,13 +546,13 @@ impl<'a, 'typeck, 'tcx> LivenessResults<'a, 'typeck, 'tcx> {
             // terminator. *But*, in that case, the terminator is also
             // a *definition* of the variable, in which case we want
             // to stop the search anyhow. (But see Note 1 below.)
-            if !self.cx.initialized_at_exit(pred_block, mpi) {
+            if !self.initialized_at_exit(pred_block, mpi) {
                 debug!("compute_drop_live_points_for_block: not initialized");
                 continue;
             }
 
-            let pred_term_loc = self.cx.body().terminator_loc(pred_block);
-            let pred_term_point = self.cx.location_map.point_from_location(pred_term_loc);
+            let pred_term_loc = self.body.terminator_loc(pred_block);
+            let pred_term_point = self.location_map.point_from_location(pred_term_loc);
 
             // If the terminator of this predecessor either *assigns*
             // our value or is a "normal use", then stop.
@@ -463,17 +608,6 @@ impl<'a, 'typeck, 'tcx> LivenessResults<'a, 'typeck, 'tcx> {
         // for the call (`TMP = call()...`) and then a
         // `Drop(X)` followed by `X = TMP`  to swap that with `X`.
     }
-}
-
-enum InitAtLocation {
-    Terminator,
-    Exit,
-}
-
-impl<'tcx> LivenessContext<'_, '_, 'tcx> {
-    fn body(&self) -> &Body<'tcx> {
-        self.typeck.body
-    }
 
     /// Returns `true` if the local variable (or some part of it) is initialized
     /// at the location defined by `init_at_location`.
@@ -490,8 +624,8 @@ impl<'tcx> LivenessContext<'_, '_, 'tcx> {
         // - there are relevant live locals
         // - there are drop points for these relevant live locals.
         let flow_inits = self.flow_inits.get_or_insert_with(|| {
-            let tcx = self.typeck.tcx();
-            let body = self.typeck.body;
+            let tcx = self.infcx.tcx;
+            let body = self.body;
             // FIXME: reduce the `MaybeInitializedPlaces` domain to the useful `MovePath`s.
             //
             // This dataflow analysis computes maybe-initializedness of all move paths, which
@@ -515,7 +649,7 @@ impl<'tcx> LivenessContext<'_, '_, 'tcx> {
             InitAtLocation::Exit => &mut self.exit_states,
         };
         let state = states.get_or_insert_with(block, || {
-            let terminator_location = self.typeck.body.terminator_loc(block);
+            let terminator_location = self.body.terminator_loc(block);
             match init_at_location {
                 InitAtLocation::Terminator => {
                     flow_inits.seek_before_primary_effect(terminator_location)
@@ -548,109 +682,14 @@ impl<'tcx> LivenessContext<'_, '_, 'tcx> {
     fn initialized_at_exit(&mut self, block: BasicBlock, mpi: MovePathIndex) -> bool {
         self.initialized_at(block, mpi, InitAtLocation::Exit)
     }
+}
 
-    /// Stores the result that all regions in `value` are live for the
-    /// points `live_at`.
-    fn add_use_live_facts_for(&mut self, value: Ty<'tcx>, live_at: &IntervalSet<PointIndex>) {
-        debug!("add_use_live_facts_for(value={:?})", value);
-        Self::make_all_regions_live(self.location_map, self.typeck, value, live_at);
-
-        // When using `-Zpolonius=next`, we also record the variance of regions in this live type.
-        if let Some(polonius_context) = self.typeck.polonius_context.as_mut() {
-            record_live_region_variance(
-                self.typeck.infcx.tcx,
-                &mut polonius_context.live_region_variances,
-                self.typeck.universal_regions,
-                value,
-            );
-        }
-    }
-
-    /// Some variable with type `live_ty` is "drop live" at `location`
-    /// -- i.e., it may be dropped later. This means that *some* of
-    /// the regions in its type must be live at `location`. The
-    /// precise set will depend on the dropck constraints, and in
-    /// particular this takes `#[may_dangle]` into account.
-    fn add_drop_live_facts_for(
-        &mut self,
-        dropped_local: Local,
-        dropped_ty: Ty<'tcx>,
-        drop_locations: &[Location],
-        live_at: &IntervalSet<PointIndex>,
-    ) {
-        debug!(
-            "add_drop_live_constraint(\
-             dropped_local={:?}, \
-             dropped_ty={:?}, \
-             drop_locations={:?}, \
-             live_at={:?})",
-            dropped_local,
-            dropped_ty,
-            drop_locations,
-            values::pretty_print_points(self.location_map, live_at.iter()),
-        );
-
-        let dropped_span = self.body().local_decls[dropped_local].source_info.span;
-        let drop_data =
-            dropck_local(&self.typeck.infcx, &mut self.drop_data, dropped_ty, dropped_span);
-
-        if let Some(data) = &drop_data.region_constraint_data {
-            for &drop_location in drop_locations {
-                self.typeck.push_region_constraints(
-                    drop_location.to_locations(),
-                    ConstraintCategory::Boring,
-                    data,
-                );
-            }
-        }
-
-        // All things in the `outlives` array may be touched by
-        // the destructor and must be live at this point.
-        for &kind in &drop_data.dropck_result.kinds {
-            Self::make_all_regions_live(self.location_map, self.typeck, kind, live_at);
-            polonius::legacy::emit_drop_facts(
-                self.typeck.tcx(),
-                dropped_local,
-                &kind,
-                self.typeck.universal_regions,
-                self.typeck.polonius_facts,
-            );
-        }
-
-        // For polonius: since the local is drop live, record the variance of the regions in its
-        // type, not the ones in the type's live components seen in the dropck results above. See
-        // issue #160670.
-        if let Some(polonius_context) = self.typeck.polonius_context.as_mut() {
-            record_live_region_variance(
-                self.typeck.infcx.tcx,
-                &mut polonius_context.live_region_variances,
-                self.typeck.universal_regions,
-                dropped_ty,
-            );
-        }
-    }
-
-    fn make_all_regions_live(
-        location_map: &DenseLocationMap,
-        typeck: &mut TypeChecker<'_, 'tcx>,
-        value: impl TypeVisitable<TyCtxt<'tcx>>,
-        live_at: &IntervalSet<PointIndex>,
-    ) {
-        debug!("make_all_regions_live(value={:?})", value);
-        debug!(
-            "make_all_regions_live: live_at={}",
-            values::pretty_print_points(location_map, live_at.iter()),
-        );
-
-        value.visit_with(&mut FreeRegionsVisitor {
-            tcx: typeck.tcx(),
-            param_env: typeck.infcx.param_env,
-            op: |r| {
-                let live_region_vid = typeck.universal_regions.to_region_vid(r);
-                typeck.constraints.liveness_constraints.add_points(live_region_vid, live_at);
-            },
-        });
-    }
+/// Contains the results of computing dropck for a local. Namely, this includes
+/// the dropped types, and overflows found, and the region constraints that must
+/// hold at drop.
+struct DropData<'tcx> {
+    dropck_result: DropckOutlivesResult<'tcx>,
+    region_constraint_data: Option<&'tcx QueryRegionConstraints<'tcx>>,
 }
 
 /// Computes the `DropData` for a given type, caching the result.
diff --git a/compiler/rustc_builtin_macros/src/test_harness.rs b/compiler/rustc_builtin_macros/src/test_harness.rs
index 677db66530ecb..bd2ea5a3e6696 100644
--- a/compiler/rustc_builtin_macros/src/test_harness.rs
+++ b/compiler/rustc_builtin_macros/src/test_harness.rs
@@ -364,7 +364,12 @@ fn add_main(cx: &mut TestCtxt<'_>, c: &mut ast::Crate) {
     });
 
     // Integrate the new item into existing module structures.
-    let items = AstFragment::Items(smallvec![test_extern_stmt, main]);
+    // `extern crate test;` is only needed with the default runner.
+    let items = AstFragment::Items(if cx.test_runner.is_none() {
+        smallvec![test_extern_stmt, main]
+    } else {
+        smallvec![main]
+    });
     c.items.extend(cx.ext_cx.monotonic_expander().fully_expand_fragment(items).make_items());
 }
 
diff --git a/compiler/rustc_codegen_llvm/src/builder.rs b/compiler/rustc_codegen_llvm/src/builder.rs
index 9d4602e49968d..abc71f450a515 100644
--- a/compiler/rustc_codegen_llvm/src/builder.rs
+++ b/compiler/rustc_codegen_llvm/src/builder.rs
@@ -1523,21 +1523,6 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
             )
         };
 
-        if let Some(callee_instance) = callee_instance {
-            // Attributes on the function definition being called
-            let callee_attrs = self.cx.tcx.codegen_fn_attrs(callee_instance.def_id());
-
-            if let Some(inlining_rule) =
-                attributes::inline_attr(&self.cx, self.cx.tcx, callee_instance, callee_attrs)
-            {
-                attributes::apply_to_callsite(
-                    call,
-                    llvm::AttributePlace::Function,
-                    &[inlining_rule],
-                );
-            }
-        }
-
         if let Some(fn_abi) = fn_abi {
             fn_abi.apply_attrs_callsite(self, call);
         }
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
index e0fc60e1a9b7a..735dd0fbaba10 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
@@ -5,7 +5,7 @@ use std::path::PathBuf;
 use std::{assert_matches, iter, ptr};
 
 use libc::{c_longlong, c_uint};
-use rustc_abi::{Align, Layout, NumScalableVectors, Size};
+use rustc_abi::{Align, Endian, Layout, NumScalableVectors, Size};
 use rustc_codegen_ssa::debuginfo::type_names::{VTableNameKind, cpp_like_debuginfo};
 use rustc_codegen_ssa::traits::*;
 use rustc_hir::def::{CtorKind, DefKind};
@@ -21,7 +21,7 @@ use rustc_span::{
     DUMMY_SP, FileName, RemapPathScopeComponents, SourceFile, Span, Symbol, bug, hygiene,
 };
 use rustc_symbol_mangling::typeid_for_trait_ref;
-use rustc_target::spec::{Arch, DebuginfoKind};
+use rustc_target::spec::{Arch, DebuginfoKind, HasTargetSpec};
 use smallvec::smallvec;
 use tracing::{debug, instrument};
 
@@ -693,33 +693,22 @@ impl MsvcBasicName for ty::UintTy {
     }
 }
 
-impl MsvcBasicName for ty::FloatTy {
-    fn msvc_basic_name(self) -> &'static str {
-        // FIXME(f128): `f128` has no MSVC representation. We could improve the debuginfo.
-        // See: <https://github.com/rust-lang/rust/issues/121837>
-        match self {
-            ty::FloatTy::F16 => {
-                bug!("`f16` should have been handled in `build_basic_type_di_node`")
-            }
-            ty::FloatTy::F32 => "float",
-            ty::FloatTy::F64 => "double",
-            ty::FloatTy::F128 => "fp128",
-        }
-    }
-}
-
-fn build_cpp_f16_di_node<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>) -> DINodeCreationResult<'ll> {
-    // MSVC has no native support for `f16`. Instead, emit `struct f16 { bits: u16 }` to allow the
-    // `f16`'s value to be displayed using a Natvis visualiser in `intrinsic.natvis`.
-    let float_ty = cx.tcx.types.f16;
-    let bits_ty = cx.tcx.types.u16;
-    let def_location = if cx.sess().opts.unstable_opts.debug_info_type_line_numbers {
-        match float_ty.kind() {
-            ty::Adt(def, _) => Some(file_metadata_from_def_id(cx, Some(def.did()))),
-            _ => None,
-        }
+/// `float_ty` must be a [`ty::Float`] and `bits_ty` must be a [`ty::Uint`].
+/// `cx.size_of(bits_ty) * bits_names.len()` must equal `cx.size_of(float_ty)`.
+fn build_cpp_float_struct_di_node<'ll, 'tcx>(
+    cx: &CodegenCx<'ll, 'tcx>,
+    float_ty: Ty<'tcx>,
+    bits_ty: Ty<'tcx>,
+    bits_names: &[&str],
+) -> DINodeCreationResult<'ll> {
+    debug_assert!(matches!(bits_ty.kind(), ty::Uint(_)));
+    debug_assert_eq!(cx.size_of(bits_ty) * (bits_names.len() as u64), cx.size_of(float_ty));
+    // MSVC has no native support for `f16` or `f128`. Instead, emit a struct containing the bits as
+    // field(s) to allow the value to be displayed using a Natvis visualiser in `intrinsic.natvis`.
+    let name = if let ty::Float(f) = float_ty.kind() {
+        f.name_str()
     } else {
-        None
+        bug!("{float_ty:?} was not a float");
     };
     type_map::build_type_with_children(
         cx,
@@ -727,32 +716,33 @@ fn build_cpp_f16_di_node<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>) -> DINodeCreation
             cx,
             Stub::Struct,
             UniqueTypeId::for_ty(cx.tcx, float_ty),
-            "f16",
-            def_location,
+            name,
+            None,
             cx.size_and_align_of(float_ty),
             NO_SCOPE_METADATA,
             DIFlags::FlagZero,
         ),
         // Fields:
         |cx, float_di_node| {
-            let def_id = if cx.sess().opts.unstable_opts.debug_info_type_line_numbers {
-                match bits_ty.kind() {
-                    ty::Adt(def, _) => Some(def.did()),
-                    _ => None,
-                }
-            } else {
-                None
-            };
-            smallvec![build_field_di_node(
-                cx,
-                float_di_node,
-                "bits",
-                cx.layout_of(bits_ty),
-                Size::ZERO,
-                DIFlags::FlagZero,
-                type_di_node(cx, bits_ty),
-                def_id,
-            )]
+            let bits_layout = cx.layout_of(bits_ty);
+            let bits_node = type_di_node(cx, bits_ty);
+            bits_names
+                .iter()
+                .copied()
+                .enumerate()
+                .map(|(i, field_name)| {
+                    build_field_di_node(
+                        cx,
+                        float_di_node,
+                        field_name,
+                        bits_layout,
+                        bits_layout.size * (i as u64),
+                        DIFlags::FlagZero,
+                        bits_node,
+                        None,
+                    )
+                })
+                .collect()
         },
         NO_GENERICS,
     )
@@ -784,9 +774,20 @@ fn build_basic_type_di_node<'ll, 'tcx>(
         ty::Int(int_ty) if cpp_like_debuginfo => (int_ty.msvc_basic_name(), DW_ATE_signed),
         ty::Uint(uint_ty) if cpp_like_debuginfo => (uint_ty.msvc_basic_name(), DW_ATE_unsigned),
         ty::Float(ty::FloatTy::F16) if cpp_like_debuginfo => {
-            return build_cpp_f16_di_node(cx);
+            return build_cpp_float_struct_di_node(cx, t, cx.tcx.types.u16, &["bits"]);
+        }
+        ty::Float(ty::FloatTy::F128) if cpp_like_debuginfo => {
+            // All MSVC architectures are little endian.
+            assert_eq!(cx.target_spec().endian, Endian::Little);
+            return build_cpp_float_struct_di_node(
+                cx,
+                t,
+                cx.tcx.types.u64,
+                &["low_bits", "high_bits"],
+            );
         }
-        ty::Float(float_ty) if cpp_like_debuginfo => (float_ty.msvc_basic_name(), DW_ATE_float),
+        ty::Float(ty::FloatTy::F32) if cpp_like_debuginfo => ("float", DW_ATE_float),
+        ty::Float(ty::FloatTy::F64) if cpp_like_debuginfo => ("double", DW_ATE_float),
         ty::Int(int_ty) => (int_ty.name_str(), DW_ATE_signed),
         ty::Uint(uint_ty) => (uint_ty.name_str(), DW_ATE_unsigned),
         ty::Float(float_ty) => (float_ty.name_str(), DW_ATE_float),
diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs
index db896fa9c0f2b..c71e83d8f99bd 100644
--- a/compiler/rustc_codegen_llvm/src/intrinsic.rs
+++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs
@@ -347,8 +347,7 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                         // 64-bit floats are always OK.
                     }
                     Primitive::Float(Float::F128) => {
-                        // FIXME(f128) figure out whether we should support this.
-                        bug!("the va_arg intrinsic does not support `f128`")
+                        // Supported on some targets, especially where long double is IEEE f128.
                     }
                 }
 
diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs
index 90f31e0598f2d..5324ec240b0ab 100644
--- a/compiler/rustc_codegen_llvm/src/llvm_util.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm_util.rs
@@ -6,6 +6,7 @@ use std::sync::Once;
 use std::{ptr, slice, str};
 
 use libc::c_int;
+use rustc_abi::Endian;
 use rustc_codegen_ssa::back::versioned_llvm_target;
 use rustc_codegen_ssa::base::wants_wasm_eh;
 use rustc_codegen_ssa::target_features::internal_target_features;
@@ -15,7 +16,7 @@ use rustc_data_structures::small_c_str::SmallCStr;
 use rustc_fs_util::path_to_c_string;
 use rustc_session::config::{NATIVE_CPU, PrintKind, PrintRequest};
 use rustc_session::{EarlySession, Session};
-use rustc_span::bug;
+use rustc_span::{bug, sym};
 use rustc_target::spec::{
     Arch, CfgAbi, Env, MergeFunctions, Os, PanicStrategy, SmallDataThresholdSupport, Target,
 };
@@ -394,6 +395,7 @@ pub(crate) fn target_config(sess: &EarlySession) -> TargetConfig {
 fn update_target_reliable_float_cfg(target: &Target, cfg: &mut TargetConfig) {
     let target_arch = &target.arch;
     let target_os = &target.options.os;
+    let target_endian = &target.options.endian;
     let target_env = &target.options.env;
     let target_abi = &target.options.cfg_abi;
     let target_pointer_width = target.pointer_width;
@@ -426,9 +428,12 @@ fn update_target_reliable_float_cfg(target: &Target, cfg: &mut TargetConfig) {
         // Selection bug <https://github.com/llvm/llvm-project/issues/95471>. This issue is closed
         // but basic math still does not work.
         (Arch::Nvptx64, _) => false,
-        // ABI bugs <https://github.com/rust-lang/rust/issues/125109> et al. (full
-        // list at <https://github.com/rust-lang/rust/issues/116909>)
-        (Arch::PowerPC | Arch::PowerPC64, _) => false,
+        // ABI/LLVM bugs:
+        // - with +vsx <https://github.com/llvm/llvm-project/pull/216613>
+        // - without +vsx <https://github.com/rust-lang/rust/issues/125109>
+        (Arch::PowerPC, _) => false,
+        // ABI bugs on BE without +vsx <https://github.com/rust-lang/rust/issues/125109>.
+        (Arch::PowerPC64, _) => cfg.internal_target_features.contains(&sym::vsx),
         // ABI unsupported  <https://github.com/llvm/llvm-project/issues/41838> (fixed in llvm22)
         (Arch::Sparc, _) if major < 22 => false,
         // MinGW ABI bugs <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=115054> (fixed in llvm23)
@@ -456,9 +461,13 @@ fn update_target_reliable_float_cfg(target: &Target, cfg: &mut TargetConfig) {
         // (ld is `f64`), anything other than Linux (Windows and MacOS use `f64`), and `x86`
         // (ld is 80-bit extended precision).
         //
+        // On big-endian powerpc the symbol selection is correct, despite __ibmf128 being
+        // long double on the target, but the f128 symbols are not defined.
+        //
         // musl does not implement the symbols required for f128 math at all.
         _ if *target_env == Env::Musl => false,
         (Arch::X86_64, _) => false,
+        (Arch::PowerPC | Arch::PowerPC64, _) if *target_endian == Endian::Big => false,
         (_, Os::Linux) if target_pointer_width == 64 => true,
         _ => false,
     } && cfg.has_reliable_f128;
diff --git a/compiler/rustc_errors/src/diagnostic.rs b/compiler/rustc_errors/src/diagnostic.rs
index 987c9818bf0e5..888636365dc0c 100644
--- a/compiler/rustc_errors/src/diagnostic.rs
+++ b/compiler/rustc_errors/src/diagnostic.rs
@@ -93,10 +93,13 @@ pub struct DiagLocation {
 }
 
 impl DiagLocation {
+    pub fn from_location(loc: &'static panic::Location<'static>) -> Self {
+        DiagLocation { file: loc.file().into(), line: loc.line(), col: loc.column() }
+    }
+
     #[track_caller]
     pub fn caller() -> Self {
-        let loc = panic::Location::caller();
-        DiagLocation { file: loc.file().into(), line: loc.line(), col: loc.column() }
+        Self::from_location(panic::Location::caller())
     }
 }
 
@@ -1300,7 +1303,7 @@ impl<'a, G> Diag<'a, G> {
     }
 
     /// Most `emit` methods use this as a starting point.
-    pub fn emit_producing_nothing(mut self) {
+    fn emit_producing_nothing(mut self) {
         let diag = self.take_diag();
         self.dcx.emit_diagnostic(diag);
     }
diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs
index f7f42c9d366f5..89209b64e0108 100644
--- a/compiler/rustc_errors/src/lib.rs
+++ b/compiler/rustc_errors/src/lib.rs
@@ -57,6 +57,7 @@ pub use rustc_macros::msg;
 use rustc_macros::{Decodable, Encodable};
 pub use rustc_span::ErrorGuaranteed;
 pub use rustc_span::fatal_error::{FatalError, FatalErrorMarker, catch_fatal_errors};
+pub use rustc_span::macros::ExplicitBug;
 use rustc_span::source_map::SourceMap;
 use rustc_span::{DUMMY_SP, Span};
 use tracing::debug;
@@ -256,10 +257,6 @@ fn as_substr<'a>(original: &'a str, suggestion: &'a str) -> Option<(usize, &'a s
     }
 }
 
-/// Signifies that the compiler died with an explicit call to `.bug`
-/// or `.span_bug` rather than a failed assertion, etc.
-pub struct ExplicitBug;
-
 /// Signifies that the compiler died due to a delayed bug rather than a failed
 /// assertion, etc.
 pub struct DelayedBugPanic;
diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
index 705bb780a3ecf..52b69e6050a32 100644
--- a/compiler/rustc_hir_analysis/src/check/check.rs
+++ b/compiler/rustc_hir_analysis/src/check/check.rs
@@ -775,9 +775,23 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Result<(),
                 if has_default {
                     // need to store default and type of default
                     let ct = tcx.const_param_default(param.def_id).skip_binder();
-                    if let ty::ConstKind::Alias(_, alias_const) = ct.kind()
-                        && let Some(def_id) = alias_const.kind.opt_def_id()
-                    {
+                    if let ty::ConstKind::Alias(_, alias_const) = ct.kind() {
+                        let def_id = match alias_const.kind {
+                            ty::AliasConstKind::Projection { def_id } => def_id,
+                            ty::AliasConstKind::InherentSelf { def_id } => {
+                                // NOTE: typically, InherentSelf is illegal to pass to type_of,
+                                // because the generic args are incorrect (type_of expects impl-form
+                                // arguments). However, we are just checking ensure_ok().type_of(),
+                                // we are not instantiating the result, so it's OK here.
+                                def_id
+                            }
+                            ty::AliasConstKind::InherentImpl { .. } => span_bug!(
+                                tcx.def_span(param.def_id),
+                                "const_param_default should return an unnormalized constant, which should always be InherentSelf, not InherentImpl"
+                            ),
+                            ty::AliasConstKind::Free { def_id } => def_id,
+                            ty::AliasConstKind::Anon { def_id } => def_id,
+                        };
                         tcx.ensure_ok().type_of(def_id);
                     }
                 }
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
index e89caa6aeff8c..ecfe5d3c2c7c2 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -1480,9 +1480,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         )? {
             TypeRelativePath::AssocItem(alias_term) => {
                 let alias_ct = alias_term.expect_ct();
-                if let Some(def_id) = alias_ct.kind.opt_def_id() {
-                    self.check_const_item_in_type_system(def_id, span)?;
-                }
+                self.check_const_item_in_type_system(alias_ct.kind, span)?;
                 let ct = Const::new_alias(tcx, ty::IsRigid::No, alias_ct);
                 let ct = self.check_param_uses_if_mcg(ct, span, false);
                 Ok(ct)
@@ -1948,13 +1946,10 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             item_segment,
             ty::AssocTag::Const,
         )?;
-        self.check_const_item_in_type_system(item_def_id, span)?;
-        let alias_const = ty::AliasConst::new(
-            tcx,
-            ty::AliasConstKind::Projection { def_id: item_def_id },
-            item_args,
-        );
-        Ok(Const::new_alias(tcx, ty::IsRigid::No, alias_const))
+        let kind = ty::AliasConstKind::Projection { def_id: item_def_id };
+        self.check_const_item_in_type_system(kind, span)?;
+        let alias = ty::AliasConst::new(tcx, kind, item_args);
+        Ok(Const::new_alias(tcx, ty::IsRigid::No, alias))
     }
 
     /// Lower a [resolved][hir::QPath::Resolved] (type-level) associated item path.
@@ -2879,7 +2874,8 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 self.lower_const_param(def_id, hir_id)
             }
             Res::Def(DefKind::Const, did) => {
-                if let Err(guar) = self.check_const_item_in_type_system(did, span) {
+                let kind = ty::AliasConstKind::Free { def_id: did };
+                if let Err(guar) = self.check_const_item_in_type_system(kind, span) {
                     return Const::new_error(self.tcx(), guar);
                 }
 
@@ -2888,11 +2884,8 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 let _ = self
                     .prohibit_generic_args(leading_segments.iter(), GenericsArgsErrExtend::None);
                 let args = self.lower_generic_args_of_path_segment(span, did, segment);
-                ty::Const::new_alias(
-                    tcx,
-                    ty::IsRigid::No,
-                    ty::AliasConst::new(tcx, ty::AliasConstKind::Free { def_id: did }, args),
-                )
+                let alias = ty::AliasConst::new(tcx, kind, args);
+                ty::Const::new_alias(tcx, ty::IsRigid::No, alias)
             }
             Res::Def(kind @ DefKind::Ctor(ctor_of, CtorKind::Const), did) => {
                 assert_eq!(opt_self_ty, None);
@@ -3126,18 +3119,27 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
     /// `def_id` is a const item used in the type system. Checks if that's OK.
     fn check_const_item_in_type_system(
         &self,
-        def_id: DefId,
+        alias_const: ty::AliasConstKind<'tcx>,
         span: Span,
     ) -> Result<(), ErrorGuaranteed> {
         let tcx = self.tcx();
-        if tcx.features().generic_const_args() || tcx.is_direct_const(def_id) {
+        if tcx.features().generic_const_args() || alias_const.is_direct_const(tcx) {
             Ok(())
         } else {
             let mut err = self
                 .dcx()
                 .struct_span_err(span, "use of `const` in the type system not marked as direct");
-            if let Some(local_def_id) = def_id.as_local() {
-                if let Some(body_id) = tcx.hir_node_by_def_id(local_def_id).body_id() {
+            let hir_node = match alias_const {
+                ty::AliasConstKind::Projection { def_id }
+                | ty::AliasConstKind::InherentSelf { def_id }
+                | ty::AliasConstKind::InherentImpl { def_id }
+                | ty::AliasConstKind::Free { def_id }
+                | ty::AliasConstKind::Anon { def_id } => {
+                    def_id.as_local().map(|id| tcx.hir_node_by_def_id(id))
+                }
+            };
+            if let Some(hir_node) = hir_node {
+                if let Some(body_id) = hir_node.body_id() {
                     let body_span = tcx.hir_body(body_id).value.span;
 
                     err.multipart_suggestion(
@@ -3148,10 +3150,8 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                         ],
                         Applicability::MaybeIncorrect,
                     );
-                } else if let DefKind::AssocConst = tcx.def_kind(def_id)
-                    && let DefKind::Trait = tcx.def_kind(tcx.parent(def_id))
-                {
-                    let node = tcx.hir_node_by_def_id(local_def_id).expect_trait_item();
+                } else if let ty::AliasConstKind::Projection { .. } = alias_const {
+                    let node = hir_node.expect_trait_item();
                     let sp = node.span.shrink_to_lo();
                     err.span_suggestion_verbose(
                         sp,
diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
index 07c98f884cebb..545516f2e41a0 100644
--- a/compiler/rustc_hir_typeck/src/method/suggest.rs
+++ b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -425,12 +425,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                                         ));
                                     } else {
                                         msg += &format!(" but {} not reachable", pluralize!("is", suggs.len()));
-                                        err.span_suggestions(
-                                            span,
-                                            msg,
-                                            suggs,
-                                            Applicability::MaybeIncorrect,
-                                        );
+                                        err.help(format!("{msg}:\n{}", suggs.join("").trim_end()));
                                     }
                                 };
                             if accessible_sugg.is_empty() {
@@ -4001,6 +3996,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             candidates.into_iter().partition(|id| {
                 let vis = self.tcx.visibility(*id);
                 vis.is_accessible_from(scope, self.tcx)
+                    // Visibility alone does not make `fn_name::Trait` an importable path.
+                    // We need to make sure all parent are modules, otherwise the path is not importable.
+                    && std::iter::successors(self.tcx.opt_parent(*id), |&id| self.tcx.opt_parent(id))
+                        .all(|id| self.tcx.def_kind(id) == DefKind::Mod)
             });
 
         let sugg = |candidates: Vec<_>, visible| {
@@ -4114,7 +4113,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     if suggs.len() == 1 {
                         err.help(msg);
                     } else {
-                        err.span_suggestions(span, msg, suggs, Applicability::MaybeIncorrect);
+                        err.help(format!("{msg}:\n{}", suggs.join("").trim_end()));
                     }
                 };
                 if accessible_sugg.is_empty() {
diff --git a/compiler/rustc_hir_typeck/src/upvar.rs b/compiler/rustc_hir_typeck/src/upvar.rs
index 1497bfeb0f774..875517ee4c87e 100644
--- a/compiler/rustc_hir_typeck/src/upvar.rs
+++ b/compiler/rustc_hir_typeck/src/upvar.rs
@@ -2318,9 +2318,9 @@ fn restrict_precision_for_drop_types<'a, 'tcx>(
     mut place: Place<'tcx>,
     mut curr_mode: ty::UpvarCapture,
 ) -> (Place<'tcx>, ty::UpvarCapture) {
-    let is_copy_type = fcx.infcx.type_is_copy_modulo_regions(fcx.param_env, place.ty());
-
-    if let (false, UpvarCapture::ByValue) = (is_copy_type, curr_mode) {
+    if curr_mode == UpvarCapture::ByValue
+        && !fcx.infcx.type_is_copy_modulo_regions(fcx.param_env, place.ty())
+    {
         for i in 0..place.projections.len() {
             match place.ty_before_projection(i).kind() {
                 ty::Adt(def, _) if def.destructor(fcx.tcx).is_some() => {
diff --git a/compiler/rustc_interface/src/callbacks.rs b/compiler/rustc_interface/src/callbacks.rs
index 0d8b565b4e384..2b9170c80de21 100644
--- a/compiler/rustc_interface/src/callbacks.rs
+++ b/compiler/rustc_interface/src/callbacks.rs
@@ -13,7 +13,7 @@ use std::fmt;
 use std::fmt::Arguments;
 use std::panic::Location;
 
-use rustc_errors::DiagInner;
+use rustc_errors::{DiagInner, DiagLocation, Level};
 use rustc_middle::dep_graph::{QuerySideEffect, TaskDepsRef};
 use rustc_middle::ty::tls;
 use rustc_span::{Span, Symbol};
@@ -86,16 +86,26 @@ fn def_id_debug(def_id: rustc_hir::def_id::DefId, f: &mut fmt::Formatter<'_>) ->
     write!(f, ")")
 }
 
-fn emit_bug_diagnostic(span: Option<Span>, args: Arguments<'_>, location: &Location<'_>) {
+/// Returns true if it printed the diagnostic, which happens if a `tcx` is available.
+fn emit_bug_diagnostic(
+    span: Option<Span>,
+    args: Arguments<'_>,
+    location: &'static Location<'static>,
+) -> bool {
     tls::with_opt(move |tcx| {
         if let Some(tcx) = tcx {
-            let message = format!("{location}: {args}");
+            let mut diag = DiagInner::new(Level::Bug, format!("{location}: {args}"));
             if let Some(span) = span {
-                tcx.dcx().struct_span_bug(span, message)
-            } else {
-                tcx.dcx().struct_bug(message)
+                diag.span = span.into();
             }
-            .emit_producing_nothing();
+            diag.emitted_at = DiagLocation::from_location(location);
+            // Emit the bug without aborting. We let `bug_impl` do the abort because it has
+            // `#[track_caller]` which gives a better location. (`#[track_caller]` doesn't work
+            // here because this function is called via a function pointer.)
+            tcx.dcx().emit_diagnostic(diag);
+            true
+        } else {
+            false
         }
     })
 }
diff --git a/compiler/rustc_middle/src/thir.rs b/compiler/rustc_middle/src/thir.rs
index fe7b1bf493051..b20dfe68d98e2 100644
--- a/compiler/rustc_middle/src/thir.rs
+++ b/compiler/rustc_middle/src/thir.rs
@@ -661,7 +661,7 @@ pub struct PatExtra<'tcx> {
     ///
     /// This is used by some diagnostics for non-exhaustive matches, to map
     /// the pattern node back to the `DefId` of its original constant.
-    pub expanded_const: Option<DefId>,
+    pub expanded_const: Option<ty::AliasConstKind<'tcx>>,
 
     /// User-written types that must be preserved into MIR so that they can be
     /// checked.
diff --git a/compiler/rustc_middle/src/ty/abstract_const.rs b/compiler/rustc_middle/src/ty/abstract_const.rs
index 2853c43ae079d..2227841923514 100644
--- a/compiler/rustc_middle/src/ty/abstract_const.rs
+++ b/compiler/rustc_middle/src/ty/abstract_const.rs
@@ -52,9 +52,14 @@ impl<'tcx> TyCtxt<'tcx> {
             }
             fn fold_const(&mut self, c: Const<'tcx>) -> Const<'tcx> {
                 let ct = match c.kind() {
-                    ty::ConstKind::Alias(_, alias_const)
-                        if let Some(def_id) = alias_const.kind.opt_def_id() =>
-                    {
+                    ty::ConstKind::Alias(_, alias_const) => {
+                        let def_id = match alias_const.kind {
+                            ty::AliasConstKind::Projection { def_id }
+                            | ty::AliasConstKind::InherentSelf { def_id }
+                            | ty::AliasConstKind::InherentImpl { def_id }
+                            | ty::AliasConstKind::Free { def_id }
+                            | ty::AliasConstKind::Anon { def_id } => def_id,
+                        };
                         match self.tcx.thir_abstract_const(def_id) {
                             Err(e) => ty::Const::new_error(self.tcx, e),
                             Ok(Some(bac)) => {
diff --git a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
index befe4d67253a3..3414ee751585c 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -1229,8 +1229,7 @@ fn is_const_pat_that_looks_like_binding<'tcx>(tcx: TyCtxt<'tcx>, pat: &Pat<'tcx>
     // The pattern must be a named constant, and the name that appears in
     // the pattern's source text must resemble a plain identifier without any
     // `::` namespace separators or other non-identifier characters.
-    if let Some(def_id) = try { pat.extra.as_deref()?.expanded_const? }
-        && tcx.def_kind(def_id) == DefKind::Const
+    if let ty::AliasConstKind::Free { def_id } = pat.extra.as_deref()?.expanded_const?
         && let Ok(snippet) = tcx.sess.source_map().span_to_snippet(pat.span)
         && snippet.chars().all(|c| c.is_alphanumeric() || c == '_')
     {
diff --git a/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs b/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
index 55eef6006f278..e24ef5ea5b52d 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
@@ -224,7 +224,7 @@ impl<'tcx> ConstToPat<'tcx> {
 
         // Mark the pattern to indicate that it is the result of lowering a named
         // constant. This is used for diagnostics.
-        thir_pat.extra.get_or_insert_default().expanded_const = alias_const.kind.opt_def_id();
+        thir_pat.extra.get_or_insert_default().expanded_const = Some(alias_const.kind);
         thir_pat
     }
 
diff --git a/compiler/rustc_parse/src/diagnostics.rs b/compiler/rustc_parse/src/diagnostics.rs
index 829fc5a600e8a..4f3c702c77ef9 100644
--- a/compiler/rustc_parse/src/diagnostics.rs
+++ b/compiler/rustc_parse/src/diagnostics.rs
@@ -257,7 +257,7 @@ pub(crate) enum InvalidComparisonOperatorSub {
 pub(crate) struct InvalidLogicalOperator {
     #[primary_span]
     pub span: Span,
-    pub incorrect: String,
+    pub incorrect: Symbol,
     #[subdiagnostic]
     pub sub: InvalidLogicalOperatorSub,
 }
@@ -797,7 +797,7 @@ pub(crate) struct EqFieldInit {
 
 #[derive(Diagnostic)]
 #[diag("unexpected token: `...`")]
-pub(crate) struct DotDotDot {
+pub(crate) struct DotDotDotExprOp {
     #[primary_span]
     #[suggestion(
         "use `..` for an exclusive range",
@@ -816,7 +816,7 @@ pub(crate) struct DotDotDot {
 
 #[derive(Diagnostic)]
 #[diag("unexpected token: `<-`")]
-pub(crate) struct LeftArrowOperator {
+pub(crate) struct LArrowExprOp {
     #[primary_span]
     #[suggestion(
         "if you meant to write a comparison against a negative value, add a space in between `<` and `-`",
diff --git a/compiler/rustc_parse/src/parser/diagnostics.rs b/compiler/rustc_parse/src/parser/diagnostics.rs
index 40dbda2466de4..f5fa592585099 100644
--- a/compiler/rustc_parse/src/parser/diagnostics.rs
+++ b/compiler/rustc_parse/src/parser/diagnostics.rs
@@ -141,64 +141,6 @@ impl AttemptLocalParseRecovery {
     }
 }
 
-/// Information for emitting suggestions and recovering from
-/// C-style `i++`, `--i`, etc.
-#[derive(Debug, Copy, Clone)]
-struct IncDecRecovery {
-    /// Is this increment/decrement its own statement?
-    standalone: IsStandalone,
-    /// Is this an increment or decrement?
-    op: IncOrDec,
-    /// Is this pre- or postfix?
-    fixity: UnaryFixity,
-}
-
-/// Is an increment or decrement expression its own statement?
-#[derive(Debug, Copy, Clone)]
-enum IsStandalone {
-    /// It's standalone, i.e., its own statement.
-    Standalone,
-    /// It's a subexpression, i.e., *not* standalone.
-    Subexpr,
-}
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-enum IncOrDec {
-    Inc,
-    Dec,
-}
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-enum UnaryFixity {
-    Pre,
-    Post,
-}
-
-impl IncOrDec {
-    fn chr(&self) -> char {
-        match self {
-            Self::Inc => '+',
-            Self::Dec => '-',
-        }
-    }
-
-    fn name(&self) -> &'static str {
-        match self {
-            Self::Inc => "increment",
-            Self::Dec => "decrement",
-        }
-    }
-}
-
-impl std::fmt::Display for UnaryFixity {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Pre => write!(f, "prefix"),
-            Self::Post => write!(f, "postfix"),
-        }
-    }
-}
-
 /// Checks if the given `lookup` identifier is similar to any keyword symbol in `candidates`.
 ///
 /// This is a specialized version of [`Symbol::find_similar`] that constructs an error when a
@@ -211,22 +153,6 @@ fn find_similar_kw(lookup: Ident, candidates: &[Symbol]) -> Option<MisspelledKw>
     })
 }
 
-struct MultiSugg {
-    msg: String,
-    patches: Vec<(Span, String)>,
-    applicability: Applicability,
-}
-
-impl MultiSugg {
-    fn emit(self, err: &mut Diag<'_>) {
-        err.multipart_suggestion(self.msg, self.patches, self.applicability);
-    }
-
-    fn emit_verbose(self, err: &mut Diag<'_>) {
-        err.multipart_suggestion(self.msg, self.patches, self.applicability);
-    }
-}
-
 /// SnapshotParser is used to create a snapshot of the parser
 /// without causing duplicate errors being emitted when the `Parser`
 /// is dropped.
@@ -1649,146 +1575,6 @@ impl<'a> Parser<'a> {
         Ok(())
     }
 
-    pub(super) fn recover_from_prefix_increment(
-        &mut self,
-        operand_expr: Box<Expr>,
-        op_span: Span,
-        start_stmt: bool,
-    ) -> PResult<'a, Box<Expr>> {
-        let standalone = if start_stmt { IsStandalone::Standalone } else { IsStandalone::Subexpr };
-        let kind = IncDecRecovery { standalone, op: IncOrDec::Inc, fixity: UnaryFixity::Pre };
-        self.recover_from_inc_dec(operand_expr, kind, op_span)
-    }
-
-    pub(super) fn recover_from_postfix_increment(
-        &mut self,
-        operand_expr: Box<Expr>,
-        op_span: Span,
-        start_stmt: bool,
-    ) -> PResult<'a, Box<Expr>> {
-        let kind = IncDecRecovery {
-            standalone: if start_stmt { IsStandalone::Standalone } else { IsStandalone::Subexpr },
-            op: IncOrDec::Inc,
-            fixity: UnaryFixity::Post,
-        };
-        self.recover_from_inc_dec(operand_expr, kind, op_span)
-    }
-
-    pub(super) fn recover_from_postfix_decrement(
-        &mut self,
-        operand_expr: Box<Expr>,
-        op_span: Span,
-        start_stmt: bool,
-    ) -> PResult<'a, Box<Expr>> {
-        let kind = IncDecRecovery {
-            standalone: if start_stmt { IsStandalone::Standalone } else { IsStandalone::Subexpr },
-            op: IncOrDec::Dec,
-            fixity: UnaryFixity::Post,
-        };
-        self.recover_from_inc_dec(operand_expr, kind, op_span)
-    }
-
-    fn recover_from_inc_dec(
-        &mut self,
-        base: Box<Expr>,
-        kind: IncDecRecovery,
-        op_span: Span,
-    ) -> PResult<'a, Box<Expr>> {
-        let mut err = self.dcx().struct_span_err(
-            op_span,
-            format!("Rust has no {} {} operator", kind.fixity, kind.op.name()),
-        );
-        err.span_label(op_span, format!("not a valid {} operator", kind.fixity));
-
-        let help_base_case = |mut err: Diag<'_, ErrorGuaranteed>, base| {
-            err.help(format!("use `{}= 1` instead", kind.op.chr()));
-            err.emit();
-            Ok(base)
-        };
-
-        // (pre, post)
-        let spans = match kind.fixity {
-            UnaryFixity::Pre => (op_span, base.span.shrink_to_hi()),
-            UnaryFixity::Post => (base.span.shrink_to_lo(), op_span),
-        };
-
-        match kind.standalone {
-            IsStandalone::Standalone => {
-                self.inc_dec_standalone_suggest(kind, spans).emit_verbose(&mut err)
-            }
-            IsStandalone::Subexpr => {
-                let Ok(base_src) = self.span_to_snippet(base.span) else {
-                    return help_base_case(err, base);
-                };
-                match kind.fixity {
-                    UnaryFixity::Pre => {
-                        self.prefix_inc_dec_suggest(base_src, kind, spans).emit(&mut err)
-                    }
-                    UnaryFixity::Post => {
-                        // won't suggest since we can not handle the precedences
-                        // for example: `a + b++` has been parsed (a + b)++ and we can not suggest here
-                        if !matches!(base.kind, ExprKind::Binary(_, _, _)) {
-                            self.postfix_inc_dec_suggest(base_src, kind, spans).emit(&mut err)
-                        }
-                    }
-                }
-            }
-        }
-        Err(err)
-    }
-
-    fn prefix_inc_dec_suggest(
-        &mut self,
-        base_src: String,
-        kind: IncDecRecovery,
-        (pre_span, post_span): (Span, Span),
-    ) -> MultiSugg {
-        MultiSugg {
-            msg: format!("use `{}= 1` instead", kind.op.chr()),
-            patches: vec![
-                (pre_span, "{ ".to_string()),
-                (post_span, format!(" {}= 1; {} }}", kind.op.chr(), base_src)),
-            ],
-            applicability: Applicability::MachineApplicable,
-        }
-    }
-
-    fn postfix_inc_dec_suggest(
-        &mut self,
-        base_src: String,
-        kind: IncDecRecovery,
-        (pre_span, post_span): (Span, Span),
-    ) -> MultiSugg {
-        let tmp_var = if base_src.trim() == "tmp" { "tmp_" } else { "tmp" };
-        MultiSugg {
-            msg: format!("use `{}= 1` instead", kind.op.chr()),
-            patches: vec![
-                (pre_span, format!("{{ let {tmp_var} = ")),
-                (post_span, format!("; {} {}= 1; {} }}", base_src, kind.op.chr(), tmp_var)),
-            ],
-            applicability: Applicability::HasPlaceholders,
-        }
-    }
-
-    fn inc_dec_standalone_suggest(
-        &mut self,
-        kind: IncDecRecovery,
-        (pre_span, post_span): (Span, Span),
-    ) -> MultiSugg {
-        let mut patches = Vec::new();
-
-        if !pre_span.is_empty() {
-            patches.push((pre_span, String::new()));
-        }
-
-        patches.push((post_span, format!(" {}= 1", kind.op.chr())));
-        MultiSugg {
-            msg: format!("use `{}= 1` instead", kind.op.chr()),
-            patches,
-            applicability: Applicability::MachineApplicable,
-        }
-    }
-
     /// Tries to recover from associated item paths like `[T]::AssocItem` / `(T, U)::AssocItem`.
     /// Attempts to convert the base expression/pattern/type into a type, parses the `::AssocItem`
     /// tail, and combines them into a `<Ty>::AssocItem` expression/pattern/type.
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index 8238a6518e41d..58e98a64b5e41 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -34,8 +34,9 @@ use super::{
     AttrWrapper, BlockMode, ClosureSpans, ExpTokenPair, ForceCollect, Parser, PathStyle,
     Restrictions, SemiColonMode, SeqSep, TokenType, Trailing, UsePreAttrPos,
 };
-use crate::diagnostics::ExprParenthesesNeeded;
-use crate::{diagnostics, exp, maybe_recover_from_interpolated_ty_qpath};
+use crate::{exp, maybe_recover_from_interpolated_ty_qpath};
+
+mod diagnostics;
 
 #[derive(Debug)]
 pub(super) enum DestructuredFloat {
@@ -151,7 +152,6 @@ impl<'a> Parser<'a> {
         self.expected_token_types.insert(TokenType::Operator);
         while let Some(op) = self.check_assoc_op() {
             let lhs_span = self.interpolated_or_expr_span(&lhs);
-            let cur_op_span = self.token.span;
             let restrictions = if op.node.is_assign_like() {
                 self.restrictions & Restrictions::NO_STRUCT_LITERAL
             } else {
@@ -165,134 +165,60 @@ impl<'a> Parser<'a> {
             } {
                 break;
             }
-            // Check for deprecated `...` syntax
-            if self.token == token::DotDotDot && op.node == AssocOp::Range(RangeLimits::Closed) {
-                self.err_dotdotdot_syntax(self.token.span);
-            }
 
-            if self.token == token::LArrow {
-                self.err_larrow_operator(self.token.span);
-            }
+            self.reject_dotdotdot_expr_op();
+            self.reject_larrow_expr_op();
 
             parsed_something = true;
             self.bump();
-            if op.node.is_comparison() {
-                if let Some(expr) = self.check_no_chained_comparison(&lhs, &op)? {
-                    return Ok((expr, parsed_something));
-                }
-            }
 
-            // Look for JS' `===` and `!==` and recover
-            if let AssocOp::Binary(bop @ BinOpKind::Eq | bop @ BinOpKind::Ne) = op.node
-                && self.token == token::Eq
-                && self.prev_token.span.hi() == self.token.span.lo()
+            if op.node.is_comparison()
+                && let Some(expr) = self.check_no_chained_comparison(&lhs, &op)?
             {
-                let sp = op.span.to(self.token.span);
-                let sugg = bop.as_str().into();
-                let invalid = format!("{sugg}=");
-                self.dcx().emit_err(diagnostics::InvalidComparisonOperator {
-                    span: sp,
-                    invalid: invalid.clone(),
-                    sub: diagnostics::InvalidComparisonOperatorSub::Correctable {
-                        span: sp,
-                        invalid,
-                        correct: sugg,
-                    },
-                });
-                self.bump();
+                return Ok((expr, parsed_something));
             }
 
-            // Look for PHP's `<>` and recover
-            if op.node == AssocOp::Binary(BinOpKind::Lt)
-                && self.token == token::Gt
-                && self.prev_token.span.hi() == self.token.span.lo()
-            {
-                let sp = op.span.to(self.token.span);
-                self.dcx().emit_err(diagnostics::InvalidComparisonOperator {
-                    span: sp,
-                    invalid: "<>".into(),
-                    sub: diagnostics::InvalidComparisonOperatorSub::Correctable {
-                        span: sp,
-                        invalid: "<>".into(),
-                        correct: "!=".into(),
-                    },
-                });
-                self.bump();
-            }
+            self.recover_from_strict_eq_op(op);
+            self.recover_from_diamond_ne_op();
+            self.recover_from_spaceship_cmp_op();
+            self.recover_from_postfix_inc_op(&lhs, starts_stmt)?;
+            self.recover_from_postfix_dec_op(&lhs, starts_stmt)?;
 
-            // Look for C++'s `<=>` and recover
-            if op.node == AssocOp::Binary(BinOpKind::Le)
-                && self.token == token::Gt
-                && self.prev_token.span.hi() == self.token.span.lo()
-            {
-                let sp = op.span.to(self.token.span);
-                self.dcx().emit_err(diagnostics::InvalidComparisonOperator {
-                    span: sp,
-                    invalid: "<=>".into(),
-                    sub: diagnostics::InvalidComparisonOperatorSub::Spaceship(sp),
-                });
-                self.bump();
-            }
-
-            if self.prev_token == token::Plus
-                && self.token == token::Plus
-                && self.prev_token.span.between(self.token.span).is_empty()
-            {
-                let op_span = self.prev_token.span.to(self.token.span);
-                // Eat the second `+`
-                self.bump();
-                lhs = self.recover_from_postfix_increment(lhs, op_span, starts_stmt)?;
-                continue;
-            }
-
-            if self.prev_token == token::Minus
-                && self.token == token::Minus
-                && self.prev_token.span.between(self.token.span).is_empty()
-                && !self.look_ahead(1, |tok| tok.can_begin_expr())
-            {
-                let op_span = self.prev_token.span.to(self.token.span);
-                // Eat the second `-`
-                self.bump();
-                lhs = self.recover_from_postfix_decrement(lhs, op_span, starts_stmt)?;
-                continue;
-            }
-
-            let op_span = op.span;
-            let op = op.node;
-            // Special cases:
-            if op == AssocOp::Cast {
-                lhs = self.parse_assoc_op_cast(lhs, lhs_span, op_span, ExprKind::Cast)?;
-                continue;
-            } else if let AssocOp::Range(limits) = op {
-                // If we didn't have to handle `x..`/`x..=`, it would be pretty easy to
-                // generalise it to the Fixity::None code.
-                lhs = self.parse_expr_range(prec, lhs, limits, cur_op_span)?;
-                break;
-            }
-
-            let min_prec = match op.fixity() {
+            let min_prec = match op.node.fixity() {
                 Fixity::Right => Bound::Included(prec),
                 Fixity::Left | Fixity::None => Bound::Excluded(prec),
             };
-            let rhs = self.with_res(restrictions - Restrictions::STMT_EXPR, |this| {
-                this.parse_expr_assoc(min_prec)
-            })?;
 
-            let span = self.mk_expr_sp(&lhs, lhs_span, op_span, rhs.span);
-            lhs = match op {
+            let finish_parsing_bin_op = |this: &mut Self| {
+                let rhs = this.with_res(restrictions - Restrictions::STMT_EXPR, |this| {
+                    this.parse_expr_assoc(min_prec)
+                })?;
+                let span = this.mk_expr_sp(&lhs, lhs_span, op.span, rhs.span);
+                Ok((rhs, span))
+            };
+
+            lhs = match op.node {
                 AssocOp::Binary(ast_op) => {
-                    let binary = self.mk_binary(respan(cur_op_span, ast_op), lhs, rhs);
-                    self.mk_expr(span, binary)
+                    let (rhs, span) = finish_parsing_bin_op(self)?;
+                    self.mk_expr(span, self.mk_binary(respan(op.span, ast_op), lhs, rhs))
                 }
-                AssocOp::Assign => self.mk_expr(span, ExprKind::Assign(lhs, rhs, cur_op_span)),
                 AssocOp::AssignOp(aop) => {
-                    let aopexpr = self.mk_assign_op(respan(cur_op_span, aop), lhs, rhs);
-                    self.mk_expr(span, aopexpr)
+                    let (rhs, span) = finish_parsing_bin_op(self)?;
+                    self.mk_expr(span, self.mk_assign_op(respan(op.span, aop), lhs, rhs))
+                }
+                AssocOp::Assign => {
+                    let (rhs, span) = finish_parsing_bin_op(self)?;
+                    self.mk_expr(span, ExprKind::Assign(lhs, rhs, op.span))
                 }
-                AssocOp::Cast | AssocOp::Range(_) => {
-                    self.dcx().span_bug(span, "AssocOp should have been handled by special case")
+                AssocOp::Cast => {
+                    self.parse_assoc_op_cast(lhs, lhs_span, op.span, ExprKind::Cast)?
                 }
+                AssocOp::Range(limits) => self.parse_expr_range(min_prec, lhs, limits, op.span)?,
             };
+
+            if let AssocOp::Range(_) = op.node {
+                break;
+            }
         }
 
         Ok((lhs, parsed_something))
@@ -337,64 +263,44 @@ impl<'a> Parser<'a> {
     /// but the next token implies this should be parsed as an expression.
     /// For example: `if let Some(x) = x { x } else { 0 } / 2`.
     fn error_found_expr_would_be_stmt(&self, lhs: &Expr) {
-        self.dcx().emit_err(diagnostics::FoundExprWouldBeStmt {
+        self.dcx().emit_err(crate::diagnostics::FoundExprWouldBeStmt {
             span: self.token.span,
             token: pprust::token_to_string(&self.token),
-            suggestion: ExprParenthesesNeeded::surrounding(lhs.span),
+            suggestion: crate::diagnostics::ExprParenthesesNeeded::surrounding(lhs.span),
         });
     }
 
     /// Possibly translate the current token to an associative operator.
     /// The method does not advance the current token.
-    ///
-    /// Also performs recovery for `and` / `or` which are mistaken for `&&` and `||` respectively.
     pub(super) fn check_assoc_op(&self) -> Option<Spanned<AssocOp>> {
-        let (op, span) = match (AssocOp::from_token(&self.token), self.token.ident()) {
-            // When parsing const expressions, stop parsing when encountering `>`.
-            (
-                Some(
-                    AssocOp::Binary(BinOpKind::Shr | BinOpKind::Gt | BinOpKind::Ge)
-                    | AssocOp::AssignOp(AssignOpKind::ShrAssign),
-                ),
-                _,
-            ) if self.restrictions.contains(Restrictions::CONST_EXPR) => {
-                return None;
-            }
-            // When recovering patterns as expressions, stop parsing when encountering an
-            // assignment `=`, an alternative `|`, or a range `..`.
-            (
-                Some(
-                    AssocOp::Assign
-                    | AssocOp::AssignOp(_)
-                    | AssocOp::Binary(BinOpKind::BitOr)
-                    | AssocOp::Range(_),
-                ),
-                _,
-            ) if self.restrictions.contains(Restrictions::IS_PAT) => {
-                return None;
-            }
-            (Some(op), _) => (op, self.token.span),
-            (None, Some((Ident { name: sym::and, span }, IdentIsRaw::No)))
-                if self.may_recover() =>
-            {
-                self.dcx().emit_err(diagnostics::InvalidLogicalOperator {
-                    span: self.token.span,
-                    incorrect: "and".into(),
-                    sub: diagnostics::InvalidLogicalOperatorSub::Conjunction(self.token.span),
-                });
-                (AssocOp::Binary(BinOpKind::And), span)
-            }
-            (None, Some((Ident { name: sym::or, span }, IdentIsRaw::No))) if self.may_recover() => {
-                self.dcx().emit_err(diagnostics::InvalidLogicalOperator {
-                    span: self.token.span,
-                    incorrect: "or".into(),
-                    sub: diagnostics::InvalidLogicalOperatorSub::Disjunction(self.token.span),
-                });
-                (AssocOp::Binary(BinOpKind::Or), span)
-            }
-            _ => return None,
-        };
-        Some(respan(span, op))
+        let op = AssocOp::from_token(&self.token);
+
+        // When parsing const expressions, stop parsing when encountering `>`.
+        if self.restrictions.contains(Restrictions::CONST_EXPR)
+            && let Some(op) = op
+            && let AssocOp::Binary(BinOpKind::Shr | BinOpKind::Gt | BinOpKind::Ge)
+            | AssocOp::AssignOp(AssignOpKind::ShrAssign) = op
+        {
+            return None;
+        }
+
+        // When recovering patterns as expressions, stop parsing when encountering an
+        // assignment `=`, an alternative `|`, or a range `..`.
+        if self.restrictions.contains(Restrictions::IS_PAT)
+            && let Some(op) = op
+            && let AssocOp::Assign
+            | AssocOp::AssignOp(_)
+            | AssocOp::Binary(BinOpKind::BitOr)
+            | AssocOp::Range(_) = op
+        {
+            return None;
+        }
+
+        if let Some(op) = op {
+            return Some(respan(self.token.span, op));
+        }
+
+        self.recover_from_alpha_logic_op()
     }
 
     /// Checks if this expression is a successfully parsed statement.
@@ -406,7 +312,7 @@ impl<'a> Parser<'a> {
     /// The other two variants are handled in `parse_prefix_range_expr` below.
     fn parse_expr_range(
         &mut self,
-        prec: ExprPrecedence,
+        min_prec: Bound<ExprPrecedence>,
         lhs: Box<Expr>,
         limits: RangeLimits,
         cur_op_span: Span,
@@ -414,7 +320,7 @@ impl<'a> Parser<'a> {
         let rhs = if self.is_at_start_of_range_notation_rhs() {
             let maybe_lt = self.token;
             Some(
-                self.parse_expr_assoc(Bound::Excluded(prec))
+                self.parse_expr_assoc(min_prec)
                     .map_err(|err| self.maybe_err_dotdotlt_syntax(maybe_lt, err))?,
             )
         } else {
@@ -441,14 +347,11 @@ impl<'a> Parser<'a> {
     /// Parses prefix-forms of range notation: `..expr`, `..`, `..=expr`.
     fn parse_expr_prefix_range(&mut self, attrs: AttrWrapper) -> PResult<'a, Box<Expr>> {
         if !attrs.is_empty() {
-            let err = diagnostics::DotDotRangeAttribute { span: self.token.span };
+            let err = crate::diagnostics::DotDotRangeAttribute { span: self.token.span };
             self.dcx().emit_err(err);
         }
 
-        // Check for deprecated `...` syntax.
-        if self.token == token::DotDotDot {
-            self.err_dotdotdot_syntax(self.token.span);
-        }
+        self.reject_dotdotdot_expr_op();
 
         debug_assert!(
             self.token.is_range_separator(),
@@ -513,7 +416,7 @@ impl<'a> Parser<'a> {
             }
             // `+lit`
             token::Plus if this.look_ahead(1, |tok| tok.is_numeric_lit()) => {
-                let mut err = diagnostics::LeadingPlusNotSupported {
+                let mut err = crate::diagnostics::LeadingPlusNotSupported {
                     span: lo,
                     remove_plus: None,
                     add_parentheses: None,
@@ -521,7 +424,8 @@ impl<'a> Parser<'a> {
 
                 // a block on the LHS might have been intended to be an expression instead
                 if let Some(sp) = this.psess.ambiguous_block_expr_parse.borrow().get(&lo) {
-                    err.add_parentheses = Some(ExprParenthesesNeeded::surrounding(*sp));
+                    err.add_parentheses =
+                        Some(crate::diagnostics::ExprParenthesesNeeded::surrounding(*sp));
                 } else {
                     err.remove_plus = Some(lo);
                 }
@@ -539,8 +443,14 @@ impl<'a> Parser<'a> {
                 this.bump();
                 this.bump();
 
-                let operand_expr = this.parse_expr_dot_or_call(attrs)?;
-                this.recover_from_prefix_increment(operand_expr, pre_span, starts_stmt)
+                let operand = this.parse_expr_dot_or_call(attrs)?;
+                return Err(this.report_inc_dec_op(
+                    &operand,
+                    starts_stmt,
+                    diagnostics::IncOrDec::Inc,
+                    diagnostics::UnaryFixity::Pre,
+                    pre_span,
+                ));
             }
             token::Ident(..)
                 if this.token.is_keyword(kw::Move)
@@ -551,7 +461,7 @@ impl<'a> Parser<'a> {
             token::Ident(..) if this.may_recover() && this.is_mistaken_not_ident_negation() => {
                 make_it!(this, attrs, |this, _| this.recover_not_expr(lo))
             }
-            _ => return this.parse_expr_dot_or_call(attrs),
+            _ => this.parse_expr_dot_or_call(attrs),
         }
     }
 
@@ -574,7 +484,7 @@ impl<'a> Parser<'a> {
 
     /// Recover on `~expr` in favor of `!expr`.
     fn recover_tilde_expr(&mut self, lo: Span) -> PResult<'a, (Span, ExprKind)> {
-        self.dcx().emit_err(diagnostics::TildeAsUnaryOperator(lo));
+        self.dcx().emit_err(crate::diagnostics::TildeAsUnaryOperator(lo));
 
         self.parse_expr_unary(lo, UnOp::Not)
     }
@@ -605,14 +515,14 @@ impl<'a> Parser<'a> {
         let negated_token = self.look_ahead(1, |t| *t);
 
         let sub_diag = if negated_token.is_numeric_lit() {
-            diagnostics::NotAsNegationOperatorSub::SuggestNotBitwise
+            crate::diagnostics::NotAsNegationOperatorSub::SuggestNotBitwise
         } else if negated_token.is_bool_lit() {
-            diagnostics::NotAsNegationOperatorSub::SuggestNotLogical
+            crate::diagnostics::NotAsNegationOperatorSub::SuggestNotLogical
         } else {
-            diagnostics::NotAsNegationOperatorSub::SuggestNotDefault
+            crate::diagnostics::NotAsNegationOperatorSub::SuggestNotDefault
         };
 
-        self.dcx().emit_err(diagnostics::NotAsNegationOperator {
+        self.dcx().emit_err(crate::diagnostics::NotAsNegationOperator {
             negated: negated_token.span,
             negated_desc: super::token_descr(&negated_token),
             // Span the `not` plus trailing whitespace to avoid
@@ -683,7 +593,7 @@ impl<'a> Parser<'a> {
                         match self.parse_expr_labeled(label, false) {
                             Ok(expr) => {
                                 type_err.cancel();
-                                self.dcx().emit_err(diagnostics::MalformedLoopLabel {
+                                self.dcx().emit_err(crate::diagnostics::MalformedLoopLabel {
                                     span: label.ident.span,
                                     suggestion: label.ident.span.shrink_to_lo(),
                                 });
@@ -709,23 +619,24 @@ impl<'a> Parser<'a> {
 
                         let args_span = self.look_ahead(1, |t| t.span).to(span_after_type);
                         match self.token.kind {
-                            token::Lt => {
-                                self.dcx().emit_err(diagnostics::ComparisonInterpretedAsGeneric {
+                            token::Lt => self.dcx().emit_err(
+                                crate::diagnostics::ComparisonInterpretedAsGeneric {
                                     comparison: self.token.span,
                                     r#type: pprust::path_to_string(&path),
                                     args: args_span,
-                                    suggestion: diagnostics::ComparisonInterpretedAsGenericSugg {
-                                        left: expr.span.shrink_to_lo(),
-                                        right: expr.span.shrink_to_hi(),
-                                    },
-                                })
-                            }
+                                    suggestion:
+                                        crate::diagnostics::ComparisonInterpretedAsGenericSugg {
+                                            left: expr.span.shrink_to_lo(),
+                                            right: expr.span.shrink_to_hi(),
+                                        },
+                                },
+                            ),
                             token::Shl => {
-                                self.dcx().emit_err(diagnostics::ShiftInterpretedAsGeneric {
+                                self.dcx().emit_err(crate::diagnostics::ShiftInterpretedAsGeneric {
                                     shift: self.token.span,
                                     r#type: pprust::path_to_string(&path),
                                     args: args_span,
-                                    suggestion: diagnostics::ShiftInterpretedAsGenericSugg {
+                                    suggestion: crate::diagnostics::ShiftInterpretedAsGenericSugg {
                                         left: expr.span.shrink_to_lo(),
                                         right: expr.span.shrink_to_hi(),
                                     },
@@ -835,8 +746,10 @@ impl<'a> Parser<'a> {
     }
 
     fn error_remove_borrow_lifetime(&self, span: Span, lt_span: Span) {
-        self.dcx()
-            .emit_err(diagnostics::LifetimeInBorrowExpression { span, lifetime_span: lt_span });
+        self.dcx().emit_err(crate::diagnostics::LifetimeInBorrowExpression {
+            span,
+            lifetime_span: lt_span,
+        });
     }
 
     /// Parse `mut?` or `[ raw | pin ] [ const | mut ]`.
@@ -895,7 +808,7 @@ impl<'a> Parser<'a> {
                 // Recovery for `expr->suffix`.
                 self.bump();
                 let span = self.prev_token.span;
-                self.dcx().emit_err(diagnostics::ExprRArrowCall { span });
+                self.dcx().emit_err(crate::diagnostics::ExprRArrowCall { span });
                 true
             } else {
                 self.eat(exp!(Dot))
@@ -1018,7 +931,7 @@ impl<'a> Parser<'a> {
             }
             _ => (span, actual),
         };
-        self.dcx().emit_err(diagnostics::UnexpectedTokenAfterDot { span, actual });
+        self.dcx().emit_err(crate::diagnostics::UnexpectedTokenAfterDot { span, actual });
     }
 
     /// We need an identifier or integer, but the next token is a float.
@@ -1135,7 +1048,7 @@ impl<'a> Parser<'a> {
                     // Parse this both to give helpful error messages and to
                     // verify it can be done with this parser setup.
                     ExprKind::Index(ref left, ref _right, span) => {
-                        self.dcx().emit_err(diagnostics::ArrayIndexInOffsetOf(span));
+                        self.dcx().emit_err(crate::diagnostics::ArrayIndexInOffsetOf(span));
                         current = left;
                     }
                     ExprKind::Lit(token::Lit {
@@ -1144,10 +1057,12 @@ impl<'a> Parser<'a> {
                         suffix,
                     }) => {
                         if let Some(suffix) = suffix {
-                            self.dcx().emit_err(diagnostics::InvalidLiteralSuffixOnTupleIndex {
-                                span: current.span,
-                                suffix,
-                            });
+                            self.dcx().emit_err(
+                                crate::diagnostics::InvalidLiteralSuffixOnTupleIndex {
+                                    span: current.span,
+                                    suffix,
+                                },
+                            );
                         }
                         match self.break_up_float(symbol, current.span) {
                             // 1e2
@@ -1187,14 +1102,15 @@ impl<'a> Parser<'a> {
                                 fields.insert(start_idx, *ident)
                             }
                             _ => {
-                                self.dcx().emit_err(diagnostics::InvalidOffsetOf(current.span));
+                                self.dcx()
+                                    .emit_err(crate::diagnostics::InvalidOffsetOf(current.span));
                                 break;
                             }
                         }
                         break;
                     }
                     _ => {
-                        self.dcx().emit_err(diagnostics::InvalidOffsetOf(current.span));
+                        self.dcx().emit_err(crate::diagnostics::InvalidOffsetOf(current.span));
                         break;
                     }
                 }
@@ -1204,12 +1120,12 @@ impl<'a> Parser<'a> {
                 break;
             } else if trailing_dot.is_none() {
                 // This loop should only repeat if there is a trailing dot.
-                self.dcx().emit_err(diagnostics::InvalidOffsetOf(self.token.span));
+                self.dcx().emit_err(crate::diagnostics::InvalidOffsetOf(self.token.span));
                 break;
             }
         }
         if let Some(dot) = trailing_dot {
-            self.dcx().emit_err(diagnostics::InvalidOffsetOf(dot));
+            self.dcx().emit_err(crate::diagnostics::InvalidOffsetOf(dot));
         }
         Ok(fields.into_iter().collect())
     }
@@ -1223,7 +1139,7 @@ impl<'a> Parser<'a> {
         suffix: Option<Symbol>,
     ) -> Box<Expr> {
         if let Some(suffix) = suffix {
-            self.dcx().emit_err(diagnostics::InvalidLiteralSuffixOnTupleIndex {
+            self.dcx().emit_err(crate::diagnostics::InvalidLiteralSuffixOnTupleIndex {
                 span: ident_span,
                 suffix,
             });
@@ -1310,14 +1226,14 @@ impl<'a> Parser<'a> {
                             err.cancel();
                             let type_str = pprust::path_to_string(&path);
                             self.dcx()
-                                .create_err(diagnostics::ParenthesesWithStructFields {
+                                .create_err(crate::diagnostics::ParenthesesWithStructFields {
                                     span,
-                                    braces_for_struct: diagnostics::BracesForStructLiteral {
+                                    braces_for_struct: crate::diagnostics::BracesForStructLiteral {
                                         first: open_paren,
                                         second: close_paren,
                                         r#type: type_str.clone(),
                                     },
-                                    no_fields_for_fn: diagnostics::NoFieldsForFnCall {
+                                    no_fields_for_fn: crate::diagnostics::NoFieldsForFnCall {
                                         r#type: type_str,
                                         fields: fields
                                             .into_iter()
@@ -1419,7 +1335,7 @@ impl<'a> Parser<'a> {
             if let Some(args) = seg.args {
                 // See `StashKey::GenericInFieldExpr` for more info on why we stash this.
                 self.dcx()
-                    .create_err(diagnostics::FieldExpressionWithGeneric(args.span()))
+                    .create_err(crate::diagnostics::FieldExpressionWithGeneric(args.span()))
                     .stash(seg.ident.span, StashKey::GenericInFieldExpr);
             }
 
@@ -1491,7 +1407,9 @@ impl<'a> Parser<'a> {
                     // If the input is something like `if a { 1 } else { 2 } | if a { 3 } else { 4 }`
                     // then suggest parens around the lhs.
                     if let Some(sp) = this.psess.ambiguous_block_expr_parse.borrow().get(&lo) {
-                        err.subdiagnostic(ExprParenthesesNeeded::surrounding(*sp));
+                        err.subdiagnostic(crate::diagnostics::ExprParenthesesNeeded::surrounding(
+                            *sp,
+                        ));
                     }
                     err
                 })
@@ -1689,7 +1607,8 @@ impl<'a> Parser<'a> {
         let (span, kind) = if self.eat(exp!(Bang)) {
             // MACRO INVOCATION expression
             if qself.is_some() {
-                self.dcx().emit_err(diagnostics::MacroInvocationWithQualifiedPath(path.span));
+                self.dcx()
+                    .emit_err(crate::diagnostics::MacroInvocationWithQualifiedPath(path.span));
             }
             let lo = path.span;
             let mac = Box::new(MacCall { path, args: self.parse_delim_args()? });
@@ -1734,7 +1653,7 @@ impl<'a> Parser<'a> {
         {
             let (lit, _) =
                 self.recover_unclosed_char(label_.ident, Parser::mk_token_lit_char, |self_| {
-                    self_.dcx().create_err(diagnostics::UnexpectedTokenAfterLabel {
+                    self_.dcx().create_err(crate::diagnostics::UnexpectedTokenAfterLabel {
                         span: self_.token.span,
                         remove_label: None,
                         enclose_in_block: None,
@@ -1746,7 +1665,7 @@ impl<'a> Parser<'a> {
             && (self.check_noexpect(&TokenKind::Comma) || self.check_noexpect(&TokenKind::Gt))
         {
             // We're probably inside of a `Path<'a>` that needs a turbofish
-            let guar = self.dcx().emit_err(diagnostics::UnexpectedTokenAfterLabel {
+            let guar = self.dcx().emit_err(crate::diagnostics::UnexpectedTokenAfterLabel {
                 span: self.token.span,
                 remove_label: None,
                 enclose_in_block: None,
@@ -1754,7 +1673,7 @@ impl<'a> Parser<'a> {
             consume_colon = false;
             Ok(self.mk_expr_err(lo, guar))
         } else {
-            let mut err = diagnostics::UnexpectedTokenAfterLabel {
+            let mut err = crate::diagnostics::UnexpectedTokenAfterLabel {
                 span: self.token.span,
                 remove_label: None,
                 enclose_in_block: None,
@@ -1791,7 +1710,7 @@ impl<'a> Parser<'a> {
                     return expr;
                 }
 
-                err.enclose_in_block = Some(diagnostics::UnexpectedTokenAfterLabelSugg {
+                err.enclose_in_block = Some(crate::diagnostics::UnexpectedTokenAfterLabelSugg {
                     left: span.shrink_to_lo(),
                     right: span.shrink_to_hi(),
                 });
@@ -1807,7 +1726,7 @@ impl<'a> Parser<'a> {
         }?;
 
         if !ate_colon && consume_colon {
-            self.dcx().emit_err(diagnostics::RequireColonAfterLabeledExpression {
+            self.dcx().emit_err(crate::diagnostics::RequireColonAfterLabeledExpression {
                 span: expr.span,
                 label: lo,
                 label_end: lo.between(tok_sp),
@@ -1856,7 +1775,7 @@ impl<'a> Parser<'a> {
         self.bump(); // `catch`
 
         let span = lo.to(self.prev_token.span);
-        self.dcx().emit_err(diagnostics::DoCatchSyntaxRemoved { span });
+        self.dcx().emit_err(crate::diagnostics::DoCatchSyntaxRemoved { span });
 
         self.parse_try_block(lo)
     }
@@ -1916,9 +1835,9 @@ impl<'a> Parser<'a> {
             // The value expression can be a labeled loop, see issue #86948, e.g.:
             // `loop { break 'label: loop { break 'label 42; }; }`
             let lexpr = self.parse_expr_labeled(label, true)?;
-            self.dcx().emit_err(diagnostics::LabeledLoopInBreak {
+            self.dcx().emit_err(crate::diagnostics::LabeledLoopInBreak {
                 span: lexpr.span,
-                sub: diagnostics::WrapInParentheses::Expression {
+                sub: crate::diagnostics::WrapInParentheses::Expression {
                     left: lexpr.span.shrink_to_lo(),
                     right: lexpr.span.shrink_to_hi(),
                 },
@@ -1945,8 +1864,8 @@ impl<'a> Parser<'a> {
                         BREAK_WITH_LABEL_AND_LOOP,
                         lo.to(expr.span),
                         ast::CRATE_NODE_ID,
-                        diagnostics::BreakWithLabelAndLoop {
-                            sub: diagnostics::BreakWithLabelAndLoopSub {
+                        crate::diagnostics::BreakWithLabelAndLoop {
+                            sub: crate::diagnostics::BreakWithLabelAndLoopSub {
                                 left: span.shrink_to_lo(),
                                 right: span.shrink_to_hi(),
                             },
@@ -2028,8 +1947,9 @@ impl<'a> Parser<'a> {
         self.bump(); // `#`
 
         let Some((ident, IdentIsRaw::No)) = self.token.ident() else {
-            let err =
-                self.dcx().create_err(diagnostics::ExpectedBuiltinIdent { span: self.token.span });
+            let err = self
+                .dcx()
+                .create_err(crate::diagnostics::ExpectedBuiltinIdent { span: self.token.span });
             return Err(err);
         };
         self.psess.gated_spans.gate(sym::builtin_syntax, ident.span);
@@ -2039,7 +1959,7 @@ impl<'a> Parser<'a> {
         let ret = if let Some(res) = parse(self, lo, ident)? {
             Ok(res)
         } else {
-            let err = self.dcx().create_err(diagnostics::UnknownBuiltinConstruct {
+            let err = self.dcx().create_err(crate::diagnostics::UnknownBuiltinConstruct {
                 span: lo.to(ident.span),
                 name: ident,
             });
@@ -2188,7 +2108,7 @@ impl<'a> Parser<'a> {
                 }
             });
             if let Some(recovered) = recovered {
-                self.dcx().emit_err(diagnostics::FloatLiteralRequiresIntegerPart {
+                self.dcx().emit_err(crate::diagnostics::FloatLiteralRequiresIntegerPart {
                     span: recovered.span,
                     suggestion: recovered.span.shrink_to_lo(),
                 });
@@ -2322,9 +2242,9 @@ impl<'a> Parser<'a> {
         let mut snapshot = self.create_snapshot_for_diagnostic();
         match snapshot.parse_expr_array_or_repeat(exp!(CloseBrace)) {
             Ok(arr) => {
-                let guar = self.dcx().emit_err(diagnostics::ArrayBracketsInsteadOfBraces {
+                let guar = self.dcx().emit_err(crate::diagnostics::ArrayBracketsInsteadOfBraces {
                     span: arr.span,
-                    sub: diagnostics::ArrayBracketsInsteadOfBracesSugg {
+                    sub: crate::diagnostics::ArrayBracketsInsteadOfBracesSugg {
                         left: lo,
                         right: snapshot.prev_token.span,
                     },
@@ -2370,7 +2290,7 @@ impl<'a> Parser<'a> {
                         .span_to_snippet(snapshot.token.span)
                         .is_ok_and(|snippet| snippet == "]") =>
                 {
-                    return Err(self.dcx().create_err(diagnostics::MissingSemicolonBeforeArray {
+                    return Err(self.dcx().create_err(crate::diagnostics::MissingSemicolonBeforeArray {
                         open_delim: open_delim_span,
                         semicolon: prev_span.shrink_to_hi(),
                     }));
@@ -2396,10 +2316,10 @@ impl<'a> Parser<'a> {
         }
 
         if self.token.is_metavar_block() {
-            self.dcx().emit_err(diagnostics::InvalidBlockMacroSegment {
+            self.dcx().emit_err(crate::diagnostics::InvalidBlockMacroSegment {
                 span: self.token.span,
                 context: lo.to(self.token.span),
-                wrap: diagnostics::WrapInExplicitBlock {
+                wrap: crate::diagnostics::WrapInExplicitBlock {
                     lo: self.token.span.shrink_to_lo(),
                     hi: self.token.span.shrink_to_hi(),
                 },
@@ -2571,9 +2491,9 @@ impl<'a> Parser<'a> {
             // Check for `move async` and recover
             if self.check_keyword(exp!(Async)) {
                 let move_async_span = self.token.span.with_lo(self.prev_token.span.data().lo);
-                Err(self
-                    .dcx()
-                    .create_err(diagnostics::AsyncMoveOrderIncorrect { span: move_async_span }))
+                Err(self.dcx().create_err(crate::diagnostics::AsyncMoveOrderIncorrect {
+                    span: move_async_span,
+                }))
             } else {
                 Ok(CaptureBy::Value { move_kw: move_kw_span })
             }
@@ -2583,9 +2503,9 @@ impl<'a> Parser<'a> {
             // Check for `use async` and recover
             if self.check_keyword(exp!(Async)) {
                 let use_async_span = self.token.span.with_lo(self.prev_token.span.data().lo);
-                Err(self
-                    .dcx()
-                    .create_err(diagnostics::AsyncUseOrderIncorrect { span: use_async_span }))
+                Err(self.dcx().create_err(crate::diagnostics::AsyncUseOrderIncorrect {
+                    span: use_async_span,
+                }))
             } else {
                 Ok(CaptureBy::Use { use_kw: use_kw_span })
             }
@@ -2667,10 +2587,10 @@ impl<'a> Parser<'a> {
                 ExprKind::Binary(Spanned { span: binop_span, .. }, _, right)
                     if let ExprKind::Block(_, None) = right.kind =>
                 {
-                    let guar = this.dcx().emit_err(diagnostics::IfExpressionMissingThenBlock {
+                    let guar = this.dcx().emit_err(crate::diagnostics::IfExpressionMissingThenBlock {
                         if_span: lo,
                         missing_then_block_sub:
-                            diagnostics::IfExpressionMissingThenBlockSub::UnfinishedCondition(
+                            crate::diagnostics::IfExpressionMissingThenBlockSub::UnfinishedCondition(
                                 cond_span.shrink_to_lo().to(*binop_span),
                             ),
                         let_else_sub: None,
@@ -2678,10 +2598,11 @@ impl<'a> Parser<'a> {
                     std::mem::replace(right, this.mk_expr_err(binop_span.shrink_to_hi(), guar))
                 }
                 ExprKind::Block(_, None) => {
-                    let guar = this.dcx().emit_err(diagnostics::IfExpressionMissingCondition {
-                        if_span: lo.with_neighbor(cond.span).shrink_to_hi(),
-                        block_span: self.psess.source_map().start_point(cond_span),
-                    });
+                    let guar =
+                        this.dcx().emit_err(crate::diagnostics::IfExpressionMissingCondition {
+                            if_span: lo.with_neighbor(cond.span).shrink_to_hi(),
+                            block_span: self.psess.source_map().start_point(cond_span),
+                        });
                     std::mem::replace(&mut cond, this.mk_expr_err(cond_span.shrink_to_hi(), guar))
                 }
                 _ => {
@@ -2699,13 +2620,14 @@ impl<'a> Parser<'a> {
             if let Some(block) = recover_block_from_condition(self) {
                 block
             } else {
-                let let_else_sub = matches!(cond.kind, ExprKind::Let(..))
-                    .then(|| diagnostics::IfExpressionLetSomeSub { if_span: lo.until(cond_span) });
+                let let_else_sub = matches!(cond.kind, ExprKind::Let(..)).then(|| {
+                    crate::diagnostics::IfExpressionLetSomeSub { if_span: lo.until(cond_span) }
+                });
 
-                let guar = self.dcx().emit_err(diagnostics::IfExpressionMissingThenBlock {
+                let guar = self.dcx().emit_err(crate::diagnostics::IfExpressionMissingThenBlock {
                     if_span: lo,
                     missing_then_block_sub:
-                        diagnostics::IfExpressionMissingThenBlockSub::AddThenBlock(
+                        crate::diagnostics::IfExpressionMissingThenBlockSub::AddThenBlock(
                             cond_span.shrink_to_hi(),
                         ),
                     let_else_sub,
@@ -2798,9 +2720,9 @@ impl<'a> Parser<'a> {
     /// Parses a `let $pat = $expr` pseudo-expression.
     fn parse_expr_let(&mut self, restrictions: Restrictions) -> PResult<'a, Box<Expr>> {
         let recovered: Recovered = if !restrictions.contains(Restrictions::ALLOW_LET) {
-            let err = diagnostics::ExpectedExpressionFoundLet {
+            let err = crate::diagnostics::ExpectedExpressionFoundLet {
                 span: self.token.span,
-                reason: diagnostics::ForbiddenLetReason::OtherForbidden,
+                reason: crate::diagnostics::ForbiddenLetReason::OtherForbidden,
                 missing_let: None,
                 comparison: None,
             };
@@ -2822,7 +2744,7 @@ impl<'a> Parser<'a> {
             CommaRecoveryMode::LikelyTuple,
         )?;
         if self.token == token::EqEq {
-            self.dcx().emit_err(diagnostics::ExpectedEqForLetExpr {
+            self.dcx().emit_err(crate::diagnostics::ExpectedEqForLetExpr {
                 span: self.token.span,
                 sugg_span: self.token.span,
             });
@@ -2888,7 +2810,7 @@ impl<'a> Parser<'a> {
                             || matches!(cond.kind, ExprKind::MacCall(..)))
                     =>
                 {
-                    self.dcx().emit_err(diagnostics::ExpectedElseBlock {
+                    self.dcx().emit_err(crate::diagnostics::ExpectedElseBlock {
                         first_tok_span,
                         first_tok,
                         else_span,
@@ -2924,7 +2846,7 @@ impl<'a> Parser<'a> {
             let attributes = x0.span.until(branch_span);
             let last = xn.span;
             let ctx = if is_ctx_else { "else" } else { "if" };
-            self.dcx().emit_err(diagnostics::OuterAttributeNotAllowedOnIfElse {
+            self.dcx().emit_err(crate::diagnostics::OuterAttributeNotAllowedOnIfElse {
                 last,
                 branch_span,
                 ctx_span,
@@ -2939,7 +2861,7 @@ impl<'a> Parser<'a> {
             && let BinOpKind::And = binop
             && let ExprKind::If(cond, ..) = &right.kind
         {
-            Err(self.dcx().create_err(diagnostics::UnexpectedIfWithIf(
+            Err(self.dcx().create_err(crate::diagnostics::UnexpectedIfWithIf(
                 binop_span.shrink_to_hi().to(cond.span.shrink_to_lo()),
             )))
         } else {
@@ -2989,12 +2911,12 @@ impl<'a> Parser<'a> {
                     let right = self.prev_token.span.between(self.look_ahead(1, |t| t.span));
                     self.bump(); // )
                     err.cancel();
-                    self.dcx().emit_err(diagnostics::ParenthesesInForHead {
+                    self.dcx().emit_err(crate::diagnostics::ParenthesesInForHead {
                         span,
                         // With e.g. `for (x) in y)` this would replace `(x) in y)`
                         // with `x) in y)` which is syntactically invalid.
                         // However, this is prevented before we get here.
-                        sugg: diagnostics::ParenthesesInForHeadSugg { left, right },
+                        sugg: crate::diagnostics::ParenthesesInForHeadSugg { left, right },
                     });
                     Ok((self.mk_pat(start_span.to(right), ast::PatKind::Wild), expr))
                 } else {
@@ -3029,7 +2951,7 @@ impl<'a> Parser<'a> {
             && self.token.kind != token::OpenBrace
             && self.may_recover()
         {
-            let guar = self.dcx().emit_err(diagnostics::MissingExpressionInForLoop {
+            let guar = self.dcx().emit_err(crate::diagnostics::MissingExpressionInForLoop {
                 span: expr.span.shrink_to_lo(),
             });
             let err_expr = self.mk_expr(expr.span, ExprKind::Err(guar));
@@ -3071,7 +2993,7 @@ impl<'a> Parser<'a> {
             let else_span = self.token.span;
             self.bump();
             let else_clause = self.parse_expr_else()?;
-            self.dcx().emit_err(diagnostics::LoopElseNotSupported {
+            self.dcx().emit_err(crate::diagnostics::LoopElseNotSupported {
                 span: else_span.to(else_clause.span),
                 loop_kind,
                 loop_kw,
@@ -3085,18 +3007,18 @@ impl<'a> Parser<'a> {
             // Possibly using JS syntax (#75311).
             let span = self.token.span;
             self.bump();
-            (span, Some(diagnostics::MissingInInForLoopSub::InNotOf(span)))
+            (span, Some(crate::diagnostics::MissingInInForLoopSub::InNotOf(span)))
         } else if self.eat(exp!(Eq)) {
             let span = self.prev_token.span;
-            (span, Some(diagnostics::MissingInInForLoopSub::InNotEq(span)))
+            (span, Some(crate::diagnostics::MissingInInForLoopSub::InNotEq(span)))
         } else {
             let span = self.prev_token.span.between(self.token.span);
             let sub = (!self.for_loop_head_has_in())
-                .then_some(diagnostics::MissingInInForLoopSub::AddIn(span));
+                .then_some(crate::diagnostics::MissingInInForLoopSub::AddIn(span));
             (span, sub)
         };
 
-        self.dcx().emit_err(diagnostics::MissingInInForLoop { span, sub });
+        self.dcx().emit_err(crate::diagnostics::MissingInInForLoop { span, sub });
     }
 
     /// Whether the `for` loop header already contains an `in` before its body.
@@ -3166,7 +3088,7 @@ impl<'a> Parser<'a> {
         if let Some((ident, is_raw)) = self.token.lifetime() {
             // Disallow `'fn`, but with a better error message than `expect_lifetime`.
             if is_raw == IdentIsRaw::No && ident.without_first_quote().is_reserved() {
-                self.dcx().emit_err(diagnostics::KeywordLabel { span: ident.span });
+                self.dcx().emit_err(crate::diagnostics::KeywordLabel { span: ident.span });
             }
 
             self.bump();
@@ -3263,18 +3185,20 @@ impl<'a> Parser<'a> {
         let err = |this: &Parser<'_>, stmts: Vec<ast::Stmt>| {
             let span = stmts[0].span.to(stmts[stmts.len() - 1].span);
 
-            let guar = this.dcx().emit_err(diagnostics::MatchArmBodyWithoutBraces {
+            let guar = this.dcx().emit_err(crate::diagnostics::MatchArmBodyWithoutBraces {
                 statements: span,
                 arrow: arrow_span,
                 num_statements: stmts.len(),
                 sub: if stmts.len() > 1 {
-                    diagnostics::MatchArmBodyWithoutBracesSugg::AddBraces {
+                    crate::diagnostics::MatchArmBodyWithoutBracesSugg::AddBraces {
                         left: span.shrink_to_lo(),
                         right: span.shrink_to_hi(),
                         num_statements: stmts.len(),
                     }
                 } else {
-                    diagnostics::MatchArmBodyWithoutBracesSugg::UseComma { semicolon: semi_sp }
+                    crate::diagnostics::MatchArmBodyWithoutBracesSugg::UseComma {
+                        semicolon: semi_sp,
+                    }
                 },
             });
             (span, guar)
@@ -3492,7 +3416,7 @@ impl<'a> Parser<'a> {
                         .is_ok();
                     if pattern_follows && snapshot.check(exp!(FatArrow)) {
                         err.cancel();
-                        let guar = this.dcx().emit_err(diagnostics::MissingCommaAfterMatchArm {
+                        let guar = this.dcx().emit_err(crate::diagnostics::MissingCommaAfterMatchArm {
                             span: arm_span.shrink_to_hi(),
                         });
                         return Ok(Recovered::Yes(guar));
@@ -3585,9 +3509,9 @@ impl<'a> Parser<'a> {
                 checker.visit_expr(&mut guard.cond);
 
                 let right = self.prev_token.span;
-                self.dcx().emit_err(diagnostics::ParenthesesInMatchPat {
+                self.dcx().emit_err(crate::diagnostics::ParenthesesInMatchPat {
                     span: vec![left, right],
-                    sugg: diagnostics::ParenthesesInMatchPatSugg { left, right },
+                    sugg: crate::diagnostics::ParenthesesInMatchPatSugg { left, right },
                 });
 
                 if let Some(guar) = checker.found_incorrect_let_chain {
@@ -3664,7 +3588,9 @@ impl<'a> Parser<'a> {
 
         let (attrs, body) = self.parse_inner_attrs_and_block(None)?;
         if self.eat_keyword(exp!(Catch)) {
-            Err(self.dcx().create_err(diagnostics::CatchAfterTry { span: self.prev_token.span }))
+            Err(self
+                .dcx()
+                .create_err(crate::diagnostics::CatchAfterTry { span: self.prev_token.span }))
         } else {
             let span = span_lo.to(body.span);
             let gate_sym =
@@ -3767,9 +3693,9 @@ impl<'a> Parser<'a> {
                 match self.parse_expr_struct(qself.clone(), path.clone(), false) {
                     Ok(expr) => {
                         // This is a struct literal, but we don't accept them here.
-                        self.dcx().emit_err(diagnostics::StructLiteralNotAllowedHere {
+                        self.dcx().emit_err(crate::diagnostics::StructLiteralNotAllowedHere {
                             span: expr.span,
-                            sub: diagnostics::StructLiteralNotAllowedHereSugg {
+                            sub: crate::diagnostics::StructLiteralNotAllowedHereSugg {
                                 left: path.span.shrink_to_lo(),
                                 right: expr.span.shrink_to_hi(),
                             },
@@ -3811,10 +3737,12 @@ impl<'a> Parser<'a> {
             )?;
 
             let guar = if is_underscore_entry_point {
-                self.dcx().create_err(diagnostics::StructLiteralPlaceholderPath { span }).emit()
+                self.dcx()
+                    .create_err(crate::diagnostics::StructLiteralPlaceholderPath { span })
+                    .emit()
             } else {
                 self.dcx()
-                    .create_err(diagnostics::StructLiteralWithoutPathLate {
+                    .create_err(crate::diagnostics::StructLiteralWithoutPathLate {
                         span: expr.span,
                         suggestion_span: expr.span.shrink_to_lo(),
                     })
@@ -3846,8 +3774,8 @@ impl<'a> Parser<'a> {
         let in_if_guard = self.restrictions.contains(Restrictions::IN_IF_GUARD);
 
         let async_block_err = |e: &mut Diag<'_>, span: Span| {
-            diagnostics::AsyncBlockIn2015 { span }.add_to_diag(e);
-            diagnostics::HelpUseLatestEdition::new().add_to_diag(e);
+            crate::diagnostics::AsyncBlockIn2015 { span }.add_to_diag(e);
+            crate::diagnostics::HelpUseLatestEdition::new().add_to_diag(e);
         };
 
         while self.token != close.tok {
@@ -4029,7 +3957,7 @@ impl<'a> Parser<'a> {
         if self.token != token::Comma {
             return;
         }
-        self.dcx().emit_err(diagnostics::CommaAfterBaseStruct {
+        self.dcx().emit_err(crate::diagnostics::CommaAfterBaseStruct {
             span: span.to(self.prev_token.span),
             comma: self.token.span,
         });
@@ -4040,7 +3968,8 @@ impl<'a> Parser<'a> {
         if !self.look_ahead(1, |t| t == close) && self.eat(exp!(DotDotDot)) {
             // recover from typo of `...`, suggest `..`
             let span = self.prev_token.span;
-            self.dcx().emit_err(diagnostics::MissingDotDot { token_span: span, sugg_span: span });
+            self.dcx()
+                .emit_err(crate::diagnostics::MissingDotDot { token_span: span, sugg_span: span });
             return true;
         }
         false
@@ -4053,7 +3982,7 @@ impl<'a> Parser<'a> {
         let label = format!("'{}", ident.name);
         let ident = Ident::new(Symbol::intern(&label), ident.span);
 
-        self.dcx().emit_err(diagnostics::ExpectedLabelFoundIdent {
+        self.dcx().emit_err(crate::diagnostics::ExpectedLabelFoundIdent {
             span: ident.span,
             start: ident.span.shrink_to_lo(),
         });
@@ -4080,7 +4009,7 @@ impl<'a> Parser<'a> {
                         || t == &token::CloseParen
                 });
             if is_wrong {
-                return Err(this.dcx().create_err(diagnostics::ExpectedStructField {
+                return Err(this.dcx().create_err(crate::diagnostics::ExpectedStructField {
                     span: this.look_ahead(1, |t| t.span),
                     ident_span: this.token.span,
                     token: pprust::token_to_string(&this.look_ahead(1, |t| *t)),
@@ -4121,20 +4050,12 @@ impl<'a> Parser<'a> {
             return;
         }
 
-        self.dcx().emit_err(diagnostics::EqFieldInit {
+        self.dcx().emit_err(crate::diagnostics::EqFieldInit {
             span: self.token.span,
             eq: field_name.span.shrink_to_hi().to(self.token.span),
         });
     }
 
-    fn err_dotdotdot_syntax(&self, span: Span) {
-        self.dcx().emit_err(diagnostics::DotDotDot { span });
-    }
-
-    fn err_larrow_operator(&self, span: Span) {
-        self.dcx().emit_err(diagnostics::LeftArrowOperator { span });
-    }
-
     fn mk_assign_op(&self, assign_op: AssignOp, lhs: Box<Expr>, rhs: Box<Expr>) -> ExprKind {
         ExprKind::AssignOp(assign_op, lhs, rhs)
     }
@@ -4282,9 +4203,9 @@ struct CondChecker<'a> {
     parser: &'a Parser<'a>,
     let_chains_policy: LetChainsPolicy,
     depth: u32,
-    forbid_let_reason: Option<diagnostics::ForbiddenLetReason>,
-    missing_let: Option<diagnostics::MaybeMissingLet>,
-    comparison: Option<diagnostics::MaybeComparison>,
+    forbid_let_reason: Option<crate::diagnostics::ForbiddenLetReason>,
+    missing_let: Option<crate::diagnostics::MaybeMissingLet>,
+    comparison: Option<crate::diagnostics::MaybeComparison>,
     found_incorrect_let_chain: Option<ErrorGuaranteed>,
 }
 
@@ -4311,12 +4232,13 @@ impl MutVisitor for CondChecker<'_> {
             ExprKind::Let(_, _, _, ref mut recovered @ Recovered::No) => {
                 if let Some(reason) = self.forbid_let_reason {
                     let error = match reason {
-                        diagnostics::ForbiddenLetReason::NotSupportedOr(or_span) => {
-                            self.parser.dcx().emit_err(diagnostics::OrInLetChain { span: or_span })
-                        }
+                        crate::diagnostics::ForbiddenLetReason::NotSupportedOr(or_span) => self
+                            .parser
+                            .dcx()
+                            .emit_err(crate::diagnostics::OrInLetChain { span: or_span }),
                         _ => {
                             let guar = self.parser.dcx().emit_err(
-                                diagnostics::ExpectedExpressionFoundLet {
+                                crate::diagnostics::ExpectedExpressionFoundLet {
                                     span,
                                     reason,
                                     missing_let: self.missing_let,
@@ -4336,7 +4258,9 @@ impl MutVisitor for CondChecker<'_> {
                         LetChainsPolicy::AlwaysAllowed => (),
                         LetChainsPolicy::EditionDependent { current_edition } => {
                             if !current_edition.at_least_rust_2024() || !span.at_least_rust_2024() {
-                                self.parser.dcx().emit_err(diagnostics::LetChainPre2024 { span });
+                                self.parser
+                                    .dcx()
+                                    .emit_err(crate::diagnostics::LetChainPre2024 { span });
                             }
                         }
                     }
@@ -4346,22 +4270,24 @@ impl MutVisitor for CondChecker<'_> {
                 mut_visit::walk_expr(self, e);
             }
             ExprKind::Binary(Spanned { node: BinOpKind::Or, span: or_span }, _, _)
-                if let None | Some(diagnostics::ForbiddenLetReason::NotSupportedOr(_)) =
+                if let None | Some(crate::diagnostics::ForbiddenLetReason::NotSupportedOr(_)) =
                     self.forbid_let_reason =>
             {
                 let forbid_let_reason = self.forbid_let_reason;
                 self.forbid_let_reason =
-                    Some(diagnostics::ForbiddenLetReason::NotSupportedOr(or_span));
+                    Some(crate::diagnostics::ForbiddenLetReason::NotSupportedOr(or_span));
                 mut_visit::walk_expr(self, e);
                 self.forbid_let_reason = forbid_let_reason;
             }
             ExprKind::Paren(ref inner)
-                if let None | Some(diagnostics::ForbiddenLetReason::NotSupportedParentheses(_)) =
+                if let None
+                | Some(crate::diagnostics::ForbiddenLetReason::NotSupportedParentheses(_)) =
                     self.forbid_let_reason =>
             {
                 let forbid_let_reason = self.forbid_let_reason;
-                self.forbid_let_reason =
-                    Some(diagnostics::ForbiddenLetReason::NotSupportedParentheses(inner.span));
+                self.forbid_let_reason = Some(
+                    crate::diagnostics::ForbiddenLetReason::NotSupportedParentheses(inner.span),
+                );
                 mut_visit::walk_expr(self, e);
                 self.forbid_let_reason = forbid_let_reason;
             }
@@ -4399,13 +4325,14 @@ impl MutVisitor for CondChecker<'_> {
                         if let Some(later_rhs) = find_let_some(rhs)
                             && depth > 0
                         {
-                            let guar =
-                                self.parser.dcx().emit_err(diagnostics::LetChainMissingLet {
+                            let guar = self.parser.dcx().emit_err(
+                                crate::diagnostics::LetChainMissingLet {
                                     span: lhs.span,
                                     label_span: expr_span,
                                     rhs_span: later_rhs.span,
                                     sug_span: lhs.span.shrink_to_lo(),
-                                });
+                                },
+                            );
 
                             self.found_incorrect_let_chain = Some(guar);
                         }
@@ -4413,7 +4340,8 @@ impl MutVisitor for CondChecker<'_> {
                 }
 
                 let forbid_let_reason = self.forbid_let_reason;
-                self.forbid_let_reason = Some(diagnostics::ForbiddenLetReason::OtherForbidden);
+                self.forbid_let_reason =
+                    Some(crate::diagnostics::ForbiddenLetReason::OtherForbidden);
                 let missing_let = self.missing_let;
                 if let ExprKind::Binary(_, _, rhs) = &lhs.kind
                     && let ExprKind::Path(_, _)
@@ -4422,10 +4350,11 @@ impl MutVisitor for CondChecker<'_> {
                     | ExprKind::Array(_) = rhs.kind
                 {
                     self.missing_let =
-                        Some(diagnostics::MaybeMissingLet { span: rhs.span.shrink_to_lo() });
+                        Some(crate::diagnostics::MaybeMissingLet { span: rhs.span.shrink_to_lo() });
                 }
                 let comparison = self.comparison;
-                self.comparison = Some(diagnostics::MaybeComparison { span: span.shrink_to_hi() });
+                self.comparison =
+                    Some(crate::diagnostics::MaybeComparison { span: span.shrink_to_hi() });
                 mut_visit::walk_expr(self, e);
                 self.forbid_let_reason = forbid_let_reason;
                 self.missing_let = missing_let;
@@ -4447,7 +4376,8 @@ impl MutVisitor for CondChecker<'_> {
             | ExprKind::Tup(_)
             | ExprKind::Paren(_) => {
                 let forbid_let_reason = self.forbid_let_reason;
-                self.forbid_let_reason = Some(diagnostics::ForbiddenLetReason::OtherForbidden);
+                self.forbid_let_reason =
+                    Some(crate::diagnostics::ForbiddenLetReason::OtherForbidden);
                 mut_visit::walk_expr(self, e);
                 self.forbid_let_reason = forbid_let_reason;
             }
@@ -4455,7 +4385,8 @@ impl MutVisitor for CondChecker<'_> {
             | ExprKind::Type(ref mut op, _)
             | ExprKind::UnsafeBinderCast(_, ref mut op, _) => {
                 let forbid_let_reason = self.forbid_let_reason;
-                self.forbid_let_reason = Some(diagnostics::ForbiddenLetReason::OtherForbidden);
+                self.forbid_let_reason =
+                    Some(crate::diagnostics::ForbiddenLetReason::OtherForbidden);
                 self.visit_expr(op);
                 self.forbid_let_reason = forbid_let_reason;
             }
diff --git a/compiler/rustc_parse/src/parser/expr/diagnostics.rs b/compiler/rustc_parse/src/parser/expr/diagnostics.rs
new file mode 100644
index 0000000000000..707ae5d34bc75
--- /dev/null
+++ b/compiler/rustc_parse/src/parser/expr/diagnostics.rs
@@ -0,0 +1,231 @@
+use rustc_ast::util::parser::AssocOp;
+use rustc_ast::{BinOpKind, Expr, ExprKind, token};
+use rustc_errors::{Applicability, Diag, PResult};
+use rustc_span::{Span, Spanned, respan, sym};
+
+use crate::diagnostics;
+use crate::parser::Parser;
+
+impl<'a> Parser<'a> {
+    /// Recover from alphabetic logic operators `and` and `or` as found in e.g., Python and PHP.
+    pub(super) fn recover_from_alpha_logic_op(&self) -> Option<Spanned<AssocOp>> {
+        if self.may_recover()
+            && let Some((ident, token::IdentIsRaw::No)) = self.token.ident()
+        {
+            let (op, sub): (_, fn(_) -> _) = match ident.name {
+                sym::and => (BinOpKind::And, diagnostics::InvalidLogicalOperatorSub::Conjunction),
+                sym::or => (BinOpKind::Or, diagnostics::InvalidLogicalOperatorSub::Disjunction),
+                _ => return None,
+            };
+
+            self.dcx().emit_err(diagnostics::InvalidLogicalOperator {
+                span: self.token.span,
+                incorrect: ident.name,
+                sub: sub(self.token.span),
+            });
+
+            Some(respan(self.token.span, AssocOp::Binary(op)))
+        } else {
+            None
+        }
+    }
+
+    /// Reject `...` being used as an expression operator.
+    pub(super) fn reject_dotdotdot_expr_op(&self) {
+        if self.token == token::DotDotDot {
+            self.dcx().emit_err(diagnostics::DotDotDotExprOp { span: self.token.span });
+        }
+    }
+
+    /// Reject `<-` being used as an expression operator.
+    pub(super) fn reject_larrow_expr_op(&self) {
+        if self.token == token::LArrow {
+            self.dcx().emit_err(diagnostics::LArrowExprOp { span: self.token.span });
+        }
+    }
+
+    /// Recover from strict equality operators `===` and `!==` as found in e.g., JS and PHP.
+    pub(super) fn recover_from_strict_eq_op(&mut self, op: Spanned<AssocOp>) {
+        if let AssocOp::Binary(bop @ BinOpKind::Eq | bop @ BinOpKind::Ne) = op.node
+            && self.token == token::Eq
+            && self.prev_token.span.hi() == self.token.span.lo()
+        {
+            let sp = op.span.to(self.token.span);
+            let sugg = bop.as_str().into();
+            let invalid = format!("{sugg}=");
+            self.dcx().emit_err(diagnostics::InvalidComparisonOperator {
+                span: sp,
+                invalid: invalid.clone(),
+                sub: diagnostics::InvalidComparisonOperatorSub::Correctable {
+                    span: sp,
+                    invalid,
+                    correct: sugg,
+                },
+            });
+            self.bump();
+        }
+    }
+
+    /// Recover from inequality operator `<>` ("diamond") as found in e.g., PHP.
+    pub(super) fn recover_from_diamond_ne_op(&mut self) {
+        if let (token::Lt, token::Gt) = (self.prev_token.kind, self.token.kind)
+            && self.prev_token.span.hi() == self.token.span.lo()
+        {
+            let sp = self.prev_token.span.to(self.token.span);
+            self.dcx().emit_err(diagnostics::InvalidComparisonOperator {
+                span: sp,
+                invalid: "<>".into(),
+                sub: diagnostics::InvalidComparisonOperatorSub::Correctable {
+                    span: sp,
+                    invalid: "<>".into(),
+                    correct: "!=".into(),
+                },
+            });
+            self.bump();
+        }
+    }
+
+    /// Recover from comparison operator `<=>` ("spaceship") as found in e.g., C++.
+    pub(super) fn recover_from_spaceship_cmp_op(&mut self) {
+        if let (token::Le, token::Gt) = (self.prev_token.kind, self.token.kind)
+            && self.prev_token.span.hi() == self.token.span.lo()
+        {
+            let sp = self.prev_token.span.to(self.token.span);
+            self.dcx().emit_err(diagnostics::InvalidComparisonOperator {
+                span: sp,
+                invalid: "<=>".into(),
+                sub: diagnostics::InvalidComparisonOperatorSub::Spaceship(sp),
+            });
+            self.bump();
+        }
+    }
+
+    /// Recover from postfix increment operator `++` as found in many C-style languages.
+    pub(super) fn recover_from_postfix_inc_op(
+        &mut self,
+        lhs: &Expr,
+        starts_stmt: bool,
+    ) -> PResult<'a, ()> {
+        if let (token::Plus, token::Plus) = (self.prev_token.kind, self.token.kind)
+            && self.prev_token.span.hi() == self.token.span.lo()
+        {
+            let op_span = self.prev_token.span.to(self.token.span);
+            self.bump(); // eat the second `+`
+            Err(self.report_inc_dec_op(lhs, starts_stmt, IncOrDec::Inc, UnaryFixity::Post, op_span))
+        } else {
+            Ok(())
+        }
+    }
+
+    /// Recover from postfix decrement operator `--` as found in many C-style languages.
+    pub(super) fn recover_from_postfix_dec_op(
+        &mut self,
+        lhs: &Expr,
+        starts_stmt: bool,
+    ) -> PResult<'a, ()> {
+        if let (token::Minus, token::Minus) = (self.prev_token.kind, self.token.kind)
+            && self.prev_token.span.hi() == self.token.span.lo()
+            && !self.look_ahead(1, |tok| tok.can_begin_expr())
+        {
+            let op_span = self.prev_token.span.to(self.token.span);
+            self.bump(); // eat the second `-`
+            Err(self.report_inc_dec_op(lhs, starts_stmt, IncOrDec::Dec, UnaryFixity::Post, op_span))
+        } else {
+            Ok(())
+        }
+    }
+
+    /// Report increment operator `++` & decrement operator `--` as found in many C-style languages.
+    pub(super) fn report_inc_dec_op(
+        &mut self,
+        base: &Expr,
+        starts_stmt: bool,
+        op: IncOrDec,
+        fixity: UnaryFixity,
+        op_span: Span,
+    ) -> Diag<'a> {
+        // FIXME: Don't return an error diag, emit the diag here *and* return a new expr of the form
+        //        `$base += 1` / `$base -= 1` (taking `base: Expr` by value) for *proper* recovery.
+        //        (Just emitting the diag would be insufficient since callers would most likely just
+        //        use `$base` as the recovered AST node which would lead to annoying follow-up diags
+        //        like "variable doesn't need to be mutable" getting emitted in some cases.)
+
+        let mut err = {
+            let fixity = match fixity {
+                UnaryFixity::Pre => "prefix",
+                UnaryFixity::Post => "postfix",
+            };
+            let op = match op {
+                IncOrDec::Inc => "increment",
+                IncOrDec::Dec => "decrement",
+            };
+            self.dcx()
+                .struct_span_err(op_span, format!("Rust has no {fixity} {op} operator"))
+                .with_span_label(op_span, format!("not a valid {fixity} operator"))
+        };
+
+        let op = match op {
+            IncOrDec::Inc => "+= 1",
+            IncOrDec::Dec => "-= 1",
+        };
+        let (pre_span, post_span) = match fixity {
+            UnaryFixity::Pre => (op_span, base.span.shrink_to_hi()),
+            UnaryFixity::Post => (base.span.shrink_to_lo(), op_span),
+        };
+
+        if starts_stmt {
+            let mut patches = Vec::new();
+            if !pre_span.is_empty() {
+                patches.push((pre_span, String::new()));
+            }
+            patches.push((post_span, format!(" {op}")));
+            err.multipart_suggestion(
+                format!("use `{op}` instead"),
+                patches,
+                Applicability::MachineApplicable,
+            );
+        } else {
+            let Ok(base_src) = self.span_to_snippet(base.span) else {
+                err.help(format!("use `{op}` instead"));
+                return err;
+            };
+            match fixity {
+                UnaryFixity::Pre => {
+                    err.multipart_suggestion(
+                        format!("use `{op}` instead"),
+                        vec![(pre_span, "{ ".into()), (post_span, format!(" {op}; {base_src} }}"))],
+                        Applicability::MachineApplicable,
+                    );
+                }
+                UnaryFixity::Post => {
+                    // won't suggest since we can not handle the precedences
+                    // for example: `a + b++` has been parsed (a + b)++ and we can not suggest here
+                    if !matches!(base.kind, ExprKind::Binary(..)) {
+                        let tmp_var = if base_src.trim() == "tmp" { "tmp_" } else { "tmp" };
+                        err.multipart_suggestion(
+                            format!("use `{op}` instead"),
+                            vec![
+                                (pre_span, format!("{{ let {tmp_var} = ")),
+                                (post_span, format!("; {base_src} {op}; {tmp_var} }}")),
+                            ],
+                            Applicability::HasPlaceholders,
+                        );
+                    }
+                }
+            }
+        }
+        err
+    }
+}
+
+#[derive(Copy, Clone)]
+pub(super) enum IncOrDec {
+    Inc,
+    Dec,
+}
+
+#[derive(Copy, Clone)]
+pub(super) enum UnaryFixity {
+    Pre,
+    Post,
+}
diff --git a/compiler/rustc_public/src/unstable/convert/stable/ty.rs b/compiler/rustc_public/src/unstable/convert/stable/ty.rs
index ad1aa1b47132a..c3eebccb6b762 100644
--- a/compiler/rustc_public/src/unstable/convert/stable/ty.rs
+++ b/compiler/rustc_public/src/unstable/convert/stable/ty.rs
@@ -557,9 +557,13 @@ impl<'tcx> Stable<'tcx> for ty::Const<'tcx> {
             }
             ty::ConstKind::Param(param) => crate::ty::TyConstKind::Param(param.stable(tables, cx)),
             ty::ConstKind::Alias(_, alias_const) => {
-                let Some(def_id) = alias_const.kind.opt_def_id() else {
-                    // FIXME: implement (both AliasTy and AliasConst will be needing this soon)
-                    panic!("non-defid alias consts are not supported by rustc_public at the moment")
+                // rustc_public must change its API once we introduce a variant without a def_id.
+                let def_id = match alias_const.kind {
+                    ty::AliasConstKind::Projection { def_id }
+                    | ty::AliasConstKind::InherentSelf { def_id }
+                    | ty::AliasConstKind::InherentImpl { def_id }
+                    | ty::AliasConstKind::Free { def_id }
+                    | ty::AliasConstKind::Anon { def_id } => def_id,
                 };
                 crate::ty::TyConstKind::Unevaluated(
                     tables.const_def(def_id),
diff --git a/compiler/rustc_span/src/macros.rs b/compiler/rustc_span/src/macros.rs
index 9b042a2b416c5..db8b7ebbfa11f 100644
--- a/compiler/rustc_span/src/macros.rs
+++ b/compiler/rustc_span/src/macros.rs
@@ -1,10 +1,14 @@
 use std::fmt;
-use std::panic::Location;
+use std::panic::{Location, panic_any};
 
 use rustc_data_structures::AtomicRef;
 
 use crate::Span;
 
+/// Signifies that the compiler died with an explicit call to `.bug` or `.span_bug` rather than a
+/// failed assertion, etc.
+pub struct ExplicitBug;
+
 /// A macro for triggering an ICE.
 /// Calling `bug` instead of panicking will result in a nicer error message and should
 /// therefore be preferred over `panic`/`unreachable` or others.
@@ -40,12 +44,32 @@ pub macro span_bug($span:expr, $($arg:tt)+){
 
 #[cold]
 #[track_caller]
-pub fn bug_impl(span: Option<Span>, args: fmt::Arguments<'_>, location: &Location<'_>) -> ! {
-    (*EMIT_BUG_DIAGNOSTIC)(span, args, location);
-    panic!("{args}")
+pub fn bug_impl(
+    span: Option<Span>,
+    args: fmt::Arguments<'_>,
+    location: &'static Location<'static>,
+) -> ! {
+    // Emit the bug without aborting.
+    let emitted = (*EMIT_BUG_DIAGNOSTIC)(span, args, location);
+
+    if emitted {
+        // Panic with `ExplicitBug`, which tells `report_ice` that it's expected, e.g. originating
+        // from `bug!` or `dcx.emit_bug(..)`.
+        panic_any(ExplicitBug);
+    } else {
+        // Panic with just a string, which means it's unexpected.
+        panic_any(format!("{args}"));
+    }
 }
 
-pub static EMIT_BUG_DIAGNOSTIC: AtomicRef<fn(Option<Span>, fmt::Arguments<'_>, &Location<'_>)> =
-    AtomicRef::new(&(default_emit_diagnostic as _));
+pub static EMIT_BUG_DIAGNOSTIC: AtomicRef<
+    fn(Option<Span>, fmt::Arguments<'_>, &'static Location<'static>) -> bool,
+> = AtomicRef::new(&(default_emit_bug_diagnostic as _));
 
-fn default_emit_diagnostic(_: Option<Span>, _: fmt::Arguments<'_>, _: &Location<'_>) {}
+fn default_emit_bug_diagnostic(
+    _: Option<Span>,
+    _args: fmt::Arguments<'_>,
+    _location: &'static Location<'static>,
+) -> bool {
+    false
+}
diff --git a/compiler/rustc_type_ir/src/const_kind.rs b/compiler/rustc_type_ir/src/const_kind.rs
index dd0578610a2a0..f66322e034814 100644
--- a/compiler/rustc_type_ir/src/const_kind.rs
+++ b/compiler/rustc_type_ir/src/const_kind.rs
@@ -160,16 +160,6 @@ impl<I: Interner> AliasConstKind<I> {
             AliasConstKind::Anon { def_id } => interner.def_span(def_id.into()),
         }
     }
-
-    pub fn opt_def_id(self) -> Option<I::DefId> {
-        match self {
-            AliasConstKind::Projection { def_id } => Some(def_id.into()),
-            AliasConstKind::InherentSelf { def_id } => Some(def_id.into()),
-            AliasConstKind::InherentImpl { def_id } => Some(def_id.into()),
-            AliasConstKind::Free { def_id } => Some(def_id.into()),
-            AliasConstKind::Anon { def_id } => Some(def_id.into()),
-        }
-    }
 }
 
 rustc_index::newtype_index! {
diff --git a/library/alloc/src/rc.rs b/library/alloc/src/rc.rs
index 7e793aea71e3c..229de8337d94b 100644
--- a/library/alloc/src/rc.rs
+++ b/library/alloc/src/rc.rs
@@ -4319,6 +4319,13 @@ impl<T> UniqueRc<T> {
     pub fn new(value: T) -> Self {
         Self::new_in(value, Global)
     }
+
+    /// Like [`new`](Self::new), but returns an error if the allocation
+    /// fails, instead of calling [`handle_alloc_error`].
+    #[unstable(feature = "unique_rc_arc", issue = "112566")]
+    pub fn try_new(value: T) -> Result<Self, AllocError> {
+        Self::try_new_in(value, Global)
+    }
 }
 
 impl<T, A: Allocator> UniqueRc<T, A> {
@@ -4330,8 +4337,8 @@ impl<T, A: Allocator> UniqueRc<T, A> {
     /// point to the new [`Rc`].
     #[cfg(not(no_global_oom_handling))]
     #[unstable(feature = "unique_rc_arc", issue = "112566")]
-    #[must_use]
     // #[unstable(feature = "allocator_api", issue = "32838")]
+    #[must_use]
     pub fn new_in(value: T, alloc: A) -> Self {
         let (ptr, alloc) = Box::into_non_null_with_allocator(Box::new_in(
             RcInner {
@@ -4346,8 +4353,29 @@ impl<T, A: Allocator> UniqueRc<T, A> {
         Self { ptr, _marker: PhantomData, _marker2: PhantomData, alloc }
     }
 
-    #[cfg(not(no_global_oom_handling))]
-    fn unwrap_with_allocator(this: Self) -> (T, A) {
+    /// Like [`new_in`](Self::new_in), but returns an error if the allocation
+    /// fails, instead of calling [`handle_alloc_error`].
+    #[unstable(feature = "unique_rc_arc", issue = "112566")]
+    // #[unstable(feature = "allocator_api", issue = "32838")]
+    pub fn try_new_in(value: T, alloc: A) -> Result<Self, AllocError> {
+        let (ptr, alloc) = Box::into_non_null_with_allocator(Box::try_new_in(
+            RcInner {
+                strong: Cell::new(0),
+                // keep one weak reference so if all the weak pointers that are created are dropped
+                // the UniqueRc still stays valid.
+                weak: Cell::new(1),
+                value,
+            },
+            alloc,
+        )?);
+        Ok(Self { ptr, _marker: PhantomData, _marker2: PhantomData, alloc })
+    }
+
+    /// Consumes the `UniqueRc`, returning its wrapped value and allocator.
+    #[unstable(feature = "unique_rc_arc", issue = "112566")]
+    // #[unstable(feature = "allocator_api", issue = "32838")]
+    #[must_use]
+    pub fn unwrap_with_allocator(this: Self) -> (T, A) {
         let inner_ptr = this.ptr;
         let (data_ptr, alloc) = Self::into_raw_with_allocator(this);
 
@@ -4361,6 +4389,13 @@ impl<T, A: Allocator> UniqueRc<T, A> {
         (val, alloc)
     }
 
+    /// Consumes the `UniqueRc`, returning its wrapped value.
+    #[unstable(feature = "unique_rc_arc", issue = "112566")]
+    #[must_use]
+    pub fn unwrap(this: Self) -> T {
+        Self::unwrap_with_allocator(this).0
+    }
+
     /// Maps the value in a `UniqueRc`, reusing the allocation if possible.
     ///
     /// `f` is called on a reference to the value in the `UniqueRc`, and the result is returned,
@@ -4392,11 +4427,10 @@ impl<T, A: Allocator> UniqueRc<T, A> {
             unsafe {
                 let (ptr, alloc) = UniqueRc::into_raw_with_allocator(this);
                 let value = ptr.read();
-                let mut allocation =
+                let allocation =
                     UniqueRc::from_raw_with_allocator(ptr.cast::<mem::MaybeUninit<U>>(), alloc);
 
-                allocation.write(f(value));
-                allocation.assume_init()
+                UniqueRc::write(allocation, f(value))
             }
         } else {
             let (val, alloc) = UniqueRc::unwrap_with_allocator(this);
@@ -4443,13 +4477,12 @@ impl<T, A: Allocator> UniqueRc<T, A> {
             unsafe {
                 let (ptr, alloc) = UniqueRc::into_raw_with_allocator(this);
                 let value = ptr.read();
-                let mut allocation = UniqueRc::from_raw_with_allocator(
+                let allocation = UniqueRc::from_raw_with_allocator(
                     ptr.cast::<mem::MaybeUninit<R::Output>>(),
                     alloc,
                 );
 
-                allocation.write(f(value)?);
-                try { allocation.assume_init() }
+                try { UniqueRc::write(allocation, f(value)?) }
             }
         } else {
             let (val, alloc) = UniqueRc::unwrap_with_allocator(this);
@@ -4477,7 +4510,6 @@ impl<T: ?Sized, A: Allocator> UniqueRc<T, A> {
         }
     }
 
-    #[cfg(not(no_global_oom_handling))]
     fn into_raw_with_allocator(this: Self) -> (*const T, A) {
         let this = ManuallyDrop::new(this);
         // SAFETY: The copy of the allocator stored in `this` is forgotten
@@ -4519,7 +4551,6 @@ impl<T: ?Sized, A: Allocator> UniqueRc<T, A> {
         unsafe { self.ptr.as_ref() }
     }
 
-    #[cfg(not(no_global_oom_handling))]
     fn as_ptr(this: &Self) -> *const T {
         let ptr: *mut RcInner<T> = NonNull::as_ptr(this.ptr);
 
@@ -4530,7 +4561,6 @@ impl<T: ?Sized, A: Allocator> UniqueRc<T, A> {
     }
 
     #[inline]
-    #[cfg(not(no_global_oom_handling))]
     fn into_inner_with_allocator(this: Self) -> (NonNull<RcInner<T>>, A) {
         let this = mem::ManuallyDrop::new(this);
         // SAFETY: Pointer is valid for reads.
@@ -4538,7 +4568,6 @@ impl<T: ?Sized, A: Allocator> UniqueRc<T, A> {
     }
 
     #[inline]
-    #[cfg(not(no_global_oom_handling))]
     unsafe fn from_inner_in(ptr: NonNull<RcInner<T>>, alloc: A) -> Self {
         Self { ptr, _marker: PhantomData, _marker2: PhantomData, alloc }
     }
@@ -4560,9 +4589,35 @@ impl<T: ?Sized, A: AllocatorClone> UniqueRc<T, A> {
     }
 }
 
-#[cfg(not(no_global_oom_handling))]
 impl<T, A: Allocator> UniqueRc<mem::MaybeUninit<T>, A> {
-    unsafe fn assume_init(self) -> UniqueRc<T, A> {
+    /// Writes the value and converts to `UniqueRc<T, A>`.
+    ///
+    /// This method converts similarly to [`assume_init`](Self::assume_init) but
+    /// writes `value` into it before conversion, thus guaranteeing safety.
+    #[unstable(feature = "unique_rc_arc", issue = "112566")]
+    #[must_use]
+    pub fn write(mut this: Self, value: T) -> UniqueRc<T, A> {
+        // SAFETY: Writing initialises the wrapped value.
+        unsafe {
+            this.write(value);
+            this.assume_init()
+        }
+    }
+
+    /// Converts to `UniqueRc<T, A>`.
+    ///
+    /// # Safety
+    ///
+    /// As with [`MaybeUninit::assume_init`],
+    /// it is up to the caller to guarantee that the value
+    /// really is in an initialized state.
+    /// Calling this when the content is not yet fully initialized
+    /// causes immediate undefined behavior.
+    ///
+    /// [`MaybeUninit::assume_init`]: mem::MaybeUninit::assume_init
+    #[unstable(feature = "unique_rc_arc", issue = "112566")]
+    #[must_use]
+    pub unsafe fn assume_init(self) -> UniqueRc<T, A> {
         let (ptr, alloc) = UniqueRc::into_inner_with_allocator(self);
         // SAFETY: Upheld by caller.
         unsafe { UniqueRc::from_inner_in(ptr.cast(), alloc) }
diff --git a/library/alloc/src/sync.rs b/library/alloc/src/sync.rs
index 52b3b13fa5a0e..c71544925bef7 100644
--- a/library/alloc/src/sync.rs
+++ b/library/alloc/src/sync.rs
@@ -4798,6 +4798,13 @@ impl<T> UniqueArc<T, Global> {
     pub fn new(value: T) -> Self {
         Self::new_in(value, Global)
     }
+
+    /// Like [`new`](Self::new), but returns an error if the allocation
+    /// fails, instead of calling [`handle_alloc_error`].
+    #[unstable(feature = "unique_rc_arc", issue = "112566")]
+    pub fn try_new(value: T) -> Result<Self, AllocError> {
+        Self::try_new_in(value, Global)
+    }
 }
 
 impl<T, A: Allocator> UniqueArc<T, A> {
@@ -4809,8 +4816,8 @@ impl<T, A: Allocator> UniqueArc<T, A> {
     /// point to the new [`Arc`].
     #[cfg(not(no_global_oom_handling))]
     #[unstable(feature = "unique_rc_arc", issue = "112566")]
-    #[must_use]
     // #[unstable(feature = "allocator_api", issue = "32838")]
+    #[must_use]
     pub fn new_in(data: T, alloc: A) -> Self {
         let (ptr, alloc) = Box::into_non_null_with_allocator(Box::new_in(
             ArcInner {
@@ -4825,8 +4832,29 @@ impl<T, A: Allocator> UniqueArc<T, A> {
         Self { ptr, _marker: PhantomData, _marker2: PhantomData, alloc }
     }
 
-    #[cfg(not(no_global_oom_handling))]
-    fn unwrap_with_allocator(this: Self) -> (T, A) {
+    /// Like [`new_in`](Self::new_in), but returns an error if the allocation
+    /// fails, instead of calling [`handle_alloc_error`].
+    #[unstable(feature = "unique_rc_arc", issue = "112566")]
+    // #[unstable(feature = "allocator_api", issue = "32838")]
+    pub fn try_new_in(data: T, alloc: A) -> Result<Self, AllocError> {
+        let (ptr, alloc) = Box::into_non_null_with_allocator(Box::try_new_in(
+            ArcInner {
+                strong: atomic::AtomicUsize::new(0),
+                // keep one weak reference so if all the weak pointers that are created are dropped
+                // the UniqueArc still stays valid.
+                weak: atomic::AtomicUsize::new(1),
+                data,
+            },
+            alloc,
+        )?);
+        Ok(Self { ptr, _marker: PhantomData, _marker2: PhantomData, alloc })
+    }
+
+    /// Consumes the `UniqueArc`, returning its wrapped value and allocator.
+    #[unstable(feature = "unique_rc_arc", issue = "112566")]
+    // #[unstable(feature = "allocator_api", issue = "32838")]
+    #[must_use]
+    pub fn unwrap_with_allocator(this: Self) -> (T, A) {
         let inner_ptr = this.ptr;
         let (data_ptr, alloc) = Self::into_raw_with_allocator(this);
 
@@ -4834,11 +4862,19 @@ impl<T, A: Allocator> UniqueArc<T, A> {
         // We do not use the data inside ever again.
         let val = unsafe { data_ptr.read() };
 
+        // Drop the strong-weak ref
         drop(Weak { ptr: inner_ptr, alloc: &alloc });
 
         (val, alloc)
     }
 
+    /// Consumes the `UniqueArc`, returning its wrapped value.
+    #[unstable(feature = "unique_rc_arc", issue = "112566")]
+    #[must_use]
+    pub fn unwrap(this: Self) -> T {
+        Self::unwrap_with_allocator(this).0
+    }
+
     /// Maps the value in a `UniqueArc`, reusing the allocation if possible.
     ///
     /// `f` is called on a reference to the value in the `UniqueArc`, and the result is returned,
@@ -4870,11 +4906,10 @@ impl<T, A: Allocator> UniqueArc<T, A> {
             unsafe {
                 let (ptr, alloc) = UniqueArc::into_raw_with_allocator(this);
                 let value = ptr.read();
-                let mut allocation =
+                let allocation =
                     UniqueArc::from_raw_with_allocator(ptr.cast::<mem::MaybeUninit<U>>(), alloc);
 
-                allocation.write(f(value));
-                allocation.assume_init()
+                UniqueArc::write(allocation, f(value))
             }
         } else {
             let (val, alloc) = UniqueArc::unwrap_with_allocator(this);
@@ -4921,13 +4956,12 @@ impl<T, A: Allocator> UniqueArc<T, A> {
             unsafe {
                 let (ptr, alloc) = UniqueArc::into_raw_with_allocator(this);
                 let value = ptr.read();
-                let mut allocation = UniqueArc::from_raw_with_allocator(
+                let allocation = UniqueArc::from_raw_with_allocator(
                     ptr.cast::<mem::MaybeUninit<R::Output>>(),
                     alloc,
                 );
 
-                allocation.write(f(value)?);
-                try { allocation.assume_init() }
+                try { UniqueArc::write(allocation, f(value)?) }
             }
         } else {
             let (val, alloc) = UniqueArc::unwrap_with_allocator(this);
@@ -4955,7 +4989,6 @@ impl<T: ?Sized, A: Allocator> UniqueArc<T, A> {
         }
     }
 
-    #[cfg(not(no_global_oom_handling))]
     fn into_raw_with_allocator(this: Self) -> (*const T, A) {
         let this = ManuallyDrop::new(this);
         // SAFETY: The copy of the allocator stored in `this` is forgotten
@@ -4998,7 +5031,6 @@ impl<T: ?Sized, A: Allocator> UniqueArc<T, A> {
         unsafe { self.ptr.as_ref() }
     }
 
-    #[cfg(not(no_global_oom_handling))]
     fn as_ptr(this: &Self) -> *const T {
         let ptr: *mut ArcInner<T> = NonNull::as_ptr(this.ptr);
 
@@ -5009,7 +5041,6 @@ impl<T: ?Sized, A: Allocator> UniqueArc<T, A> {
     }
 
     #[inline]
-    #[cfg(not(no_global_oom_handling))]
     fn into_inner_with_allocator(this: Self) -> (NonNull<ArcInner<T>>, A) {
         let this = mem::ManuallyDrop::new(this);
         // SAFETY: Pointer is valid for reads and only read once.
@@ -5017,7 +5048,6 @@ impl<T: ?Sized, A: Allocator> UniqueArc<T, A> {
     }
 
     #[inline]
-    #[cfg(not(no_global_oom_handling))]
     unsafe fn from_inner_in(ptr: NonNull<ArcInner<T>>, alloc: A) -> Self {
         Self { ptr, _marker: PhantomData, _marker2: PhantomData, alloc }
     }
@@ -5051,9 +5081,35 @@ impl<T: ?Sized, A: AllocatorClone> UniqueArc<T, A> {
     }
 }
 
-#[cfg(not(no_global_oom_handling))]
 impl<T, A: Allocator> UniqueArc<mem::MaybeUninit<T>, A> {
-    unsafe fn assume_init(self) -> UniqueArc<T, A> {
+    /// Writes the value and converts to `UniqueArc<T, A>`.
+    ///
+    /// This method converts similarly to [`assume_init`](Self::assume_init) but
+    /// writes `value` into it before conversion, thus guaranteeing safety.
+    #[unstable(feature = "unique_rc_arc", issue = "112566")]
+    #[must_use]
+    pub fn write(mut this: Self, value: T) -> UniqueArc<T, A> {
+        // SAFETY: Writing initialises the wrapped value.
+        unsafe {
+            this.write(value);
+            this.assume_init()
+        }
+    }
+
+    /// Converts to `UniqueArc<T, A>`.
+    ///
+    /// # Safety
+    ///
+    /// As with [`MaybeUninit::assume_init`],
+    /// it is up to the caller to guarantee that the value
+    /// really is in an initialized state.
+    /// Calling this when the content is not yet fully initialized
+    /// causes immediate undefined behavior.
+    ///
+    /// [`MaybeUninit::assume_init`]: mem::MaybeUninit::assume_init
+    #[unstable(feature = "unique_rc_arc", issue = "112566")]
+    #[must_use]
+    pub unsafe fn assume_init(self) -> UniqueArc<T, A> {
         let (ptr, alloc) = UniqueArc::into_inner_with_allocator(self);
         // SAFETY: Upheld by caller.
         unsafe { UniqueArc::from_inner_in(ptr.cast(), alloc) }
diff --git a/library/core/src/ffi/va_list.rs b/library/core/src/ffi/va_list.rs
index 21f8e264db953..b308cb7f85df2 100644
--- a/library/core/src/ffi/va_list.rs
+++ b/library/core/src/ffi/va_list.rs
@@ -416,6 +416,55 @@ cfg_select! {
 #[unstable(feature = "c_variadic_va_arg_safe", issue = "162911", implied_by = "c_variadic")]
 unsafe impl VaArgSafe for f64 {}
 
+// Implement `VaArgSafe` for f128 on targets where either:
+//
+// - clang provides `__float128`
+// - `long double` is IEEE f128 on the platform.
+//
+// When updating this cfg, also update the tests to match. Currently this condition
+// is duplicated in:
+//
+// - tests/ui/c-variadic/roundtrip.rs
+// - tests/run-make/c-link-to-rust-va-list-fn/checkrust.rs
+//
+// # Known incompatibilities
+//
+// Testing versus clang exposed bugs in clang. GCC has no known incompatibilities.
+//
+// - Clang <= 23 on sparc, see https://github.com/llvm/llvm-project/pull/214981.
+// - Clang <= 23 on x86, see https://github.com/llvm/llvm-project/issues/217747.
+cfg_select! {
+    any(
+        all(target_arch = "x86_64", not(target_vendor = "apple"), not(target_env = "msvc")),
+        all(target_arch = "x86", not(target_vendor = "apple"), not(target_env = "msvc")),
+        // PowerPC requires VSX (only little endian has it enabled by default).
+        all(target_arch = "powerpc64", target_feature = "vsx"),
+        all(
+            not(windows),
+            not(target_vendor = "apple"),
+            any(
+                target_arch = "aarch64",
+                target_arch = "loongarch32",
+                target_arch = "loongarch64",
+                target_arch = "mips64",
+                target_arch = "mips64r6",
+                target_arch = "riscv32",
+                target_arch = "riscv64",
+                target_arch = "s390x",
+                target_arch = "sparc",
+                target_arch = "sparc64",
+                target_arch = "wasm32",
+                target_arch = "wasm64",
+            ),
+        ),
+    ) => {
+        #[unstable_feature_bound(f128)]
+        #[unstable(feature = "f128", issue = "116909")]
+        unsafe impl VaArgSafe for f128 {}
+    }
+    _ => { /* unsupported */ }
+}
+
 #[unstable(feature = "c_variadic_va_arg_safe", issue = "162911", implied_by = "c_variadic")]
 unsafe impl<T> VaArgSafe for *mut T {}
 #[unstable(feature = "c_variadic_va_arg_safe", issue = "162911", implied_by = "c_variadic")]
diff --git a/library/std/src/num/f32.rs b/library/std/src/num/f32.rs
index ac3f2e263195d..b89c71dd1abe1 100644
--- a/library/std/src/num/f32.rs
+++ b/library/std/src/num/f32.rs
@@ -80,6 +80,11 @@ impl f32 {
     ///
     /// This function always returns the precise result.
     ///
+    /// On most hardware platforms, [`round_ties_even`](Self::round_ties_even) may execute faster
+    /// than `round`. If both rounding methods fit the use case, consider using `round_ties_even`.
+    /// Note that the two methods apply different rounding rules to values exactly halfway between
+    /// two integers.
+    ///
     /// # Examples
     ///
     /// ```
diff --git a/library/std/src/num/f64.rs b/library/std/src/num/f64.rs
index 9b3086b1ce12e..c3f5d8cca6014 100644
--- a/library/std/src/num/f64.rs
+++ b/library/std/src/num/f64.rs
@@ -80,6 +80,11 @@ impl f64 {
     ///
     /// This function always returns the precise result.
     ///
+    /// On most hardware platforms, [`round_ties_even`](Self::round_ties_even) may execute faster
+    /// than `round`. If both rounding methods fit the use case, consider using `round_ties_even`.
+    /// Note that the two methods apply different rounding rules to values exactly halfway between
+    /// two integers.
+    ///
     /// # Examples
     ///
     /// ```
diff --git a/package.json b/package.json
index d9a3ced805ba5..876d81c1d60ef 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "browser-ui-test": "^0.25.0",
+    "browser-ui-test": "^0.25.2",
     "es-check": "^9.4.4",
     "eslint": "^8.57.1",
     "typescript": "^5.8.3"
diff --git a/src/ci/github-actions/jobs.yml b/src/ci/github-actions/jobs.yml
index d0645a0f9d475..0fdf50d20a255 100644
--- a/src/ci/github-actions/jobs.yml
+++ b/src/ci/github-actions/jobs.yml
@@ -378,13 +378,16 @@ auto:
   - name: test-various
     <<: *job-linux-4c
 
-  - name: test-x86_64-fuchsia
-    # Only run this job on the nightly channel. Fuchsia requires
-    # nightly features to compile, and this job would fail if
-    # executed on beta and stable.
-    only_on_channel: nightly
-    doc_url: https://rustc-dev-guide.rust-lang.org/tests/fuchsia.html
-    <<: *job-linux-x86-8c-ec2
+  # FIXME(#162999): temporarily disabled due to unauthenticated
+  # servers getting overwhelmed
+  #
+  #- name: test-x86_64-fuchsia
+  #  # Only run this job on the nightly channel. Fuchsia requires
+  #  # nightly features to compile, and this job would fail if
+  #  # executed on beta and stable.
+  #  only_on_channel: nightly
+  #  doc_url: https://rustc-dev-guide.rust-lang.org/tests/fuchsia.html
+  #  <<: *job-linux-x86-8c-ec2
 
   # Tests integration with Rust for Linux.
   # Builds stage 1 compiler and tries to compile a few RfL examples with it.
diff --git a/src/doc/rustc-dev-guide/.github/workflows/ci.yml b/src/doc/rustc-dev-guide/.github/workflows/ci.yml
index 5ff245b168b07..23b590e4aebaf 100644
--- a/src/doc/rustc-dev-guide/.github/workflows/ci.yml
+++ b/src/doc/rustc-dev-guide/.github/workflows/ci.yml
@@ -22,11 +22,14 @@ jobs:
       BASE_SHA: ${{ github.event.pull_request.base.sha }}
       GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           # linkcheck needs the base commit.
           fetch-depth: 0
 
+      - name: Test CI scripts
+        run: ci/tests/report-scheduled-linkcheck-failure.sh
+
       - name: Cache binaries
         id: mdbook-cache
         uses: actions/cache@v4
@@ -94,3 +97,34 @@ jobs:
         run: |
           # using split_inclusive that uses regex feature that uses an unstable feature
           RUSTC_BOOTSTRAP=1 cargo run --release --manifest-path ci/sembr/Cargo.toml src
+
+  notify-scheduled-failure:
+    name: Open an issue if links are broken
+    needs: ci
+    if: failure() && github.event_name == 'schedule'
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      issues: write
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - name: Open an issue or comment on an existing one
+        run: ci/report-scheduled-linkcheck-failure.sh
+        env:
+          GH_TOKEN: ${{ github.token }}
+
+  close-scheduled-failure:
+    name: Close linkcheck issue if no links are broken
+    needs: ci
+    if: success() && github.event_name == 'schedule'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      issues: write
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - name: Close issue
+        run: ci/close-scheduled-linkcheck-issues.sh
+        env:
+          GH_TOKEN: ${{ github.token }}
diff --git a/src/doc/rustc-dev-guide/ci/close-scheduled-linkcheck-issues.sh b/src/doc/rustc-dev-guide/ci/close-scheduled-linkcheck-issues.sh
new file mode 100755
index 0000000000000..7fb4c74cc128c
--- /dev/null
+++ b/src/doc/rustc-dev-guide/ci/close-scheduled-linkcheck-issues.sh
@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+: "${GITHUB_REPOSITORY:?GITHUB_REPOSITORY must be set}"
+: "${GITHUB_RUN_ID:?GITHUB_RUN_ID must be set}"
+: "${GITHUB_SERVER_URL:?GITHUB_SERVER_URL must be set}"
+: "${GH_TOKEN:?GH_TOKEN must be set}"
+
+successful_run_url="$GITHUB_SERVER_URL/$GITHUB_REPOSITORY/actions/runs/$GITHUB_RUN_ID"
+
+issue_numbers=$(gh issue list \
+  --repo "$GITHUB_REPOSITORY" \
+  --state open \
+  --label C-broken-links \
+  --label C-CI \
+  --label A-linkcheck \
+  --limit 100 \
+  --json number,title \
+  --jq '.[] | select(.title == "[automation] Dead links found") | .number')
+
+if [[ -z "$issue_numbers" ]]; then
+  echo "No scheduled linkcheck failure issue is open."
+  exit 0
+fi
+
+while read -r issue_number; do
+  gh issue close "$issue_number" \
+    --repo "$GITHUB_REPOSITORY" \
+    --comment "The scheduled link check is succeeding again: $successful_run_url"
+done <<< "$issue_numbers"
diff --git a/src/doc/rustc-dev-guide/ci/report-scheduled-linkcheck-failure.sh b/src/doc/rustc-dev-guide/ci/report-scheduled-linkcheck-failure.sh
new file mode 100755
index 0000000000000..178b3b40a75bf
--- /dev/null
+++ b/src/doc/rustc-dev-guide/ci/report-scheduled-linkcheck-failure.sh
@@ -0,0 +1,51 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+: "${GITHUB_REPOSITORY:?GITHUB_REPOSITORY must be set}"
+: "${GITHUB_RUN_ID:?GITHUB_RUN_ID must be set}"
+: "${GITHUB_RUN_NUMBER:?GITHUB_RUN_NUMBER must be set}"
+: "${GITHUB_SERVER_URL:?GITHUB_SERVER_URL must be set}"
+: "${GITHUB_SHA:?GITHUB_SHA must be set}"
+: "${GH_TOKEN:?GH_TOKEN must be set}"
+
+title="[automation] Dead links found"
+job_url=$(gh api \
+  "repos/$GITHUB_REPOSITORY/actions/runs/$GITHUB_RUN_ID/jobs" \
+  --jq '.jobs[] | select(.name == "ci") | .html_url')
+
+issue_number=$(gh issue list \
+  --repo "$GITHUB_REPOSITORY" \
+  --state open \
+  --label C-broken-links \
+  --label C-CI \
+  --label A-linkcheck \
+  --limit 100 \
+  --json number,title \
+  --jq '[.[] | select(.title == "[automation] Dead links found")][0].number // empty')
+
+if [[ -n "$issue_number" ]]; then
+  gh issue comment "$issue_number" \
+    --repo "$GITHUB_REPOSITORY" \
+    --body "The scheduled link check failed again in [CI run #$GITHUB_RUN_NUMBER]($job_url)."
+  exit 0
+fi
+
+body=$(cat <<EOF
+The scheduled link check failed in [CI run #$GITHUB_RUN_NUMBER]($job_url).
+
+Commit: [$GITHUB_SHA]($GITHUB_SERVER_URL/$GITHUB_REPOSITORY/commit/$GITHUB_SHA)
+
+Please inspect the failed run for broken links or an automation error. Close this issue after the scheduled link check succeeds again.
+
+**WARNING**: Do not rename this issue or remove \`C-broken-links\`, \`C-CI\`, or \`A-linkcheck\`; doing so will break the automation.
+EOF
+)
+
+gh issue create \
+  --repo "$GITHUB_REPOSITORY" \
+  --title "$title" \
+  --body "$body" \
+  --label C-broken-links \
+  --label C-CI \
+  --label A-linkcheck
diff --git a/src/doc/rustc-dev-guide/ci/sembr/src/main.rs b/src/doc/rustc-dev-guide/ci/sembr/src/main.rs
index 92143aaa1fb87..742671ee7b1dd 100644
--- a/src/doc/rustc-dev-guide/ci/sembr/src/main.rs
+++ b/src/doc/rustc-dev-guide/ci/sembr/src/main.rs
@@ -182,13 +182,26 @@ fn lengthen_lines(content: &str, limit: usize) -> String {
             new_content[new_n] = format!("{line} {}", next_line.trim_start());
             new_content.remove(new_n + 1);
             skip_next = true;
-        } else {
-            const SEP: &str = ", ";
-            let Some((before_comma, after_comma)) = next_line.split_once(SEP) else { continue };
-            if line.len() + before_comma.len() < limit - SEP.len() {
-                new_content[new_n] = format!("{line} {before_comma}{}", SEP.trim_end());
+            continue;
+        }
+        const SEP: &str = ", ";
+        let indent = next_line.find(|ch: char| !ch.is_whitespace()).unwrap();
+        if next_line.contains(SEP) {
+            let (before_sep, after_sep) = next_line.split_once(SEP).unwrap();
+            if line.len() + before_sep.len() < limit - SEP.len() {
+                new_content[new_n] =
+                    format!("{line} {}{}", before_sep.trim_start(), SEP.trim_end());
+                new_n += 1;
+                new_content[new_n] = format!("{:indent$}{after_sep}", "");
+                skip_next = true;
+            }
+        } else if line.contains(SEP) {
+            let (before_sep, after_sep) = line.rsplit_once(SEP).unwrap();
+            if after_sep.len() + next_line.len() < limit {
+                new_content[new_n] = format!("{before_sep}{}", SEP.trim_end());
                 new_n += 1;
-                new_content[new_n] = after_comma.to_owned();
+                new_content[new_n] =
+                    format!("{:indent$}{after_sep} {}", "", next_line.trim_start());
                 skip_next = true;
             }
         }
@@ -334,15 +347,20 @@ fn should_pass() {
 }
 
 #[test]
-#[ignore]
 fn split_on_comma_of_current_line() {
     let original = "
-Each derived value has a dependency on other values, which could themselves be either base or
+Each derived value has a dependency, on other values, which could themselves be either base or
 derived.
+
+  Each derived value has a dependency, on other values, which could themselves be either base or
+  derived.
 ";
     let expected = "
-Each derived value has a dependency on other values,
+Each derived value has a dependency, on other values,
 which could themselves be either base or derived.
+
+  Each derived value has a dependency, on other values,
+  which could themselves be either base or derived.
 ";
     assert_eq!(expected, lengthen_lines(original, 100))
 }
@@ -352,10 +370,16 @@ fn split_on_comma_of_next_line() {
     let original = "
 Because of canonicalization of regions and
 inference variables, encountering a cycle doesn't mean that we would get an infinite proof tree.
+
+  Because of canonicalization of regions and
+  inference variables, encountering a cycle doesn't mean that we would get an infinite proof tree.
 ";
     let expected = "
 Because of canonicalization of regions and inference variables,
 encountering a cycle doesn't mean that we would get an infinite proof tree.
+
+  Because of canonicalization of regions and inference variables,
+  encountering a cycle doesn't mean that we would get an infinite proof tree.
 ";
     assert_eq!(expected, lengthen_lines(original, 100))
 }
diff --git a/src/doc/rustc-dev-guide/ci/tests/fakes/gh b/src/doc/rustc-dev-guide/ci/tests/fakes/gh
new file mode 100755
index 0000000000000..197b83af250ca
--- /dev/null
+++ b/src/doc/rustc-dev-guide/ci/tests/fakes/gh
@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+command=$1
+{
+  printf '%s' "$command"
+  shift
+  printf ' <%s>' "$@"
+  printf '\n'
+} >> "$GH_MOCK_LOG"
+
+case "$command" in
+  api)
+    if [[ ${GH_MOCK_API_FAIL-} == 1 ]]; then
+      exit 1
+    fi
+    echo "https://github.example/jobs/123"
+    ;;
+  issue)
+    if [[ ${1-} == list && -n ${GH_MOCK_ISSUE_NUMBER-} ]]; then
+      echo "$GH_MOCK_ISSUE_NUMBER"
+    fi
+    ;;
+esac
diff --git a/src/doc/rustc-dev-guide/ci/tests/report-scheduled-linkcheck-failure.sh b/src/doc/rustc-dev-guide/ci/tests/report-scheduled-linkcheck-failure.sh
new file mode 100755
index 0000000000000..96526ef0ea350
--- /dev/null
+++ b/src/doc/rustc-dev-guide/ci/tests/report-scheduled-linkcheck-failure.sh
@@ -0,0 +1,69 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+repo_root=$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)
+script="$repo_root/ci/report-scheduled-linkcheck-failure.sh"
+tmp=$(mktemp -d)
+trap 'rm -rf "$tmp"' EXIT
+
+export PATH="$repo_root/ci/tests/fakes:$PATH"
+export GH_MOCK_LOG="$tmp/gh.log"
+export GITHUB_REPOSITORY="rust-lang/rustc-dev-guide"
+export GITHUB_RUN_ID=123
+export GITHUB_RUN_NUMBER=456
+export GITHUB_SERVER_URL="https://github.com"
+export GITHUB_SHA=0123456789abcdef
+export GH_TOKEN=test-token
+
+fail() {
+  echo "error: $*" >&2
+  exit 1
+}
+
+assert_log_contains() {
+  grep -F -- "$1" "$GH_MOCK_LOG" >/dev/null || fail "gh log does not contain: $1"
+}
+
+assert_log_excludes() {
+  if grep -F -- "$1" "$GH_MOCK_LOG" >/dev/null; then
+    fail "gh log unexpectedly contains: $1"
+  fi
+}
+
+# A first failure creates the issue with all labels and links to the failed job.
+: > "$GH_MOCK_LOG"
+unset GH_MOCK_ISSUE_NUMBER GH_MOCK_API_FAIL
+"$script" >/dev/null
+assert_log_contains 'issue <list> <--repo> <rust-lang/rustc-dev-guide> <--state> <open>'
+assert_log_contains '<--label> <C-broken-links> <--label> <C-CI> <--label> <A-linkcheck>'
+assert_log_contains '<--json> <number,title> <--jq> <[.[] | select(.title == "[automation] Dead links found")][0].number // empty>'
+assert_log_contains 'issue <create>'
+assert_log_contains '<--title> <[automation] Dead links found>'
+assert_log_contains '<--label> <C-broken-links> <--label> <C-CI> <--label> <A-linkcheck>'
+assert_log_contains '[CI run #456](https://github.example/jobs/123)'
+assert_log_excludes 'issue <comment>'
+
+# A later failure comments on the existing issue instead of creating another.
+: > "$GH_MOCK_LOG"
+export GH_MOCK_ISSUE_NUMBER=42
+"$script" >/dev/null
+assert_log_contains 'issue <comment> <42>'
+assert_log_contains 'failed again in [CI run #456](https://github.example/jobs/123)'
+assert_log_excludes 'issue <create>'
+
+# GitHub API errors and missing required environment variables remain fatal.
+: > "$GH_MOCK_LOG"
+export GH_MOCK_API_FAIL=1
+if "$script" >/dev/null 2>&1; then
+  fail "script succeeded after gh api failed"
+fi
+unset GH_MOCK_API_FAIL
+
+for variable in GITHUB_REPOSITORY GITHUB_RUN_ID GITHUB_RUN_NUMBER GITHUB_SERVER_URL GITHUB_SHA GH_TOKEN; do
+  if env -u "$variable" "$script" >/dev/null 2>&1; then
+    fail "script succeeded without $variable"
+  fi
+done
+
+echo "report-scheduled-linkcheck-failure tests passed"
diff --git a/src/doc/rustc-dev-guide/rust-version b/src/doc/rustc-dev-guide/rust-version
index 18fea436747c7..1c3d6e0224718 100644
--- a/src/doc/rustc-dev-guide/rust-version
+++ b/src/doc/rustc-dev-guide/rust-version
@@ -1 +1 @@
-32d94cc9be3f6e6c3fa1deaea9e0ab93c4980dba
+420ed2a0c3d7225b1744266fd884d431b4d8cfe0
diff --git a/src/doc/rustc-dev-guide/src/backend/monomorph.md b/src/doc/rustc-dev-guide/src/backend/monomorph.md
index 670614fe51379..f25211b23e602 100644
--- a/src/doc/rustc-dev-guide/src/backend/monomorph.md
+++ b/src/doc/rustc-dev-guide/src/backend/monomorph.md
@@ -33,7 +33,7 @@ Take this example:
 
 ```rust
 fn banana() {
-   peach::<u64>();
+    peach::<u64>();
 }
 
 fn main() {
@@ -67,9 +67,9 @@ or more modules in Crate B.
 
 | Crate A function | Behavior |
 | - | - |
-| Non-generic function | Crate A function doesn't appear in any codegen units of Crate B |
-| Non-generic `#[inline]` function |  Crate A function appears within a single CGU  of Crate B, and exists even after post-inlining stage|
-| Generic function |  Regardless of inlining, all monomorphized (specialized) functions <br> from Crate A appear within a single codegen unit for Crate B. <br> The codegen unit exists even after the post inlining stage.|
+| Non-generic function | Crate A function doesn't appear in any codegen units of Crate B. |
+| Non-generic `#[inline]` function |  Crate A function appears within a single CGU  of Crate B. <br> The codegen unit exists even after the post inlining stage. |
+| Generic function |  Regardless of inlining, all monomorphized (specialized) functions <br> from Crate A appear within a single codegen unit for Crate B. <br> The codegen unit exists even after the post inlining stage. |
 | Generic `#[inline]` function |   - same - |
 
 For more details about the partitioner read the module level [documentation].
diff --git a/src/doc/rustc-dev-guide/src/bug-fix-procedure.md b/src/doc/rustc-dev-guide/src/bug-fix-procedure.md
index 0db0e07d4e7be..5416e361e5d24 100644
--- a/src/doc/rustc-dev-guide/src/bug-fix-procedure.md
+++ b/src/doc/rustc-dev-guide/src/bug-fix-procedure.md
@@ -101,7 +101,7 @@ declare_lint! {
     },
 }
 
-// 2. Add a decidacted lint pass for it.
+// 2. Add a dedicated lint pass for it.
 //    This step can be skipped if you emit the lint as part of an existing pass.
 
 #[derive(Default)]
diff --git a/src/doc/rustc-dev-guide/src/closure.md b/src/doc/rustc-dev-guide/src/closure.md
index 427919cd57995..81bddd73caba7 100644
--- a/src/doc/rustc-dev-guide/src/closure.md
+++ b/src/doc/rustc-dev-guide/src/closure.md
@@ -1,13 +1,12 @@
 # Closure Capture Inference
 
-This section describes how rustc handles closures. Closures in Rust are
-effectively "desugared" into structs that contain the values they use (or
-references to the values they use) from their creator's stack frame. rustc has
-the job of figuring out which values a closure uses and how, so it can decide
-whether to capture a given variable by shared reference, mutable reference, or
-by move. rustc also has to figure out which of the closure traits ([`Fn`][fn],
-[`FnMut`][fn_mut], or [`FnOnce`][fn_once]) a closure is capable of
-implementing.
+This section describes how rustc handles closures.
+Closures in Rust are effectively "desugared" into structs that contain the values they use (or
+references to the values they use) from their creator's stack frame.
+rustc has the job of figuring out which values a closure uses and how, so it can decide
+whether to capture a given variable by shared reference, mutable reference, or by move.
+rustc also has to figure out which of the closure traits ([`Fn`][fn],
+[`FnMut`][fn_mut], or [`FnOnce`][fn_once]) a closure is capable of implementing.
 
 [fn]: https://doc.rust-lang.org/std/ops/trait.Fn.html
 [fn_mut]:https://doc.rust-lang.org/std/ops/trait.FnMut.html
@@ -31,9 +30,11 @@ fn main() {
 }
 ```
 
-Let's say the above is the content of a file called `immut.rs`. If we compile
-`immut.rs` using the following command. The [`-Z dump-mir=all`][dump-mir] flag will cause
-`rustc` to generate and dump the [MIR][mir] to a directory called `mir_dump`.
+Let's say the above is the content of a file called `immut.rs`.
+If we compile `immut.rs` using the following command,
+the [`-Z dump-mir=all`][dump-mir] flag will cause
+`rustc` to generate and dump the [MIR] to a directory called `mir_dump`.
+
 ```console
 > rustc +stage1 immut.rs -Z dump-mir=all
 ```
@@ -43,8 +44,8 @@ Let's say the above is the content of a file called `immut.rs`. If we compile
 
 After we run this command, we will see a newly generated directory in our
 current working directory called `mir_dump`, which will contain several files.
-If we look at file `rustc.main.-------.mir_map.0.mir`, we will find, among
-other things, it also contains this line:
+If we look at file `rustc.main.-------.mir_map.0.mir`, we will find, among other things,
+it also contains this line:
 
 ```rust,ignore
 _4 = &_1;
@@ -53,9 +54,9 @@ _3 = [closure@immut.rs:7:13: 7:36] { x: move _4 };
 
 Note that in the MIR examples in this chapter, `_1` is `x`.
 
-Here in first line `_4 = &_1;`, the `mir_dump` tells us that `x` was borrowed
-as an immutable reference.  This is what we would hope as our closure just
-reads `x`.
+Here in first line `_4 = &_1;`,
+the `mir_dump` tells us that `x` was borrowed as an immutable reference.
+This is what we would hope as our closure just reads `x`.
 
 ### Example 2
 
@@ -81,7 +82,8 @@ _4 = &mut _1;
 _3 = [closure@mut.rs:7:13: 10:6] { x: move _4 };
 ```
 This time along, in the line `_4 = &mut _1;`, we see that the borrow is changed to mutable borrow.
-Fair enough! The closure increments `x` by 10.
+Fair enough!
+The closure increments `x` by 10.
 
 ### Example 3
 
@@ -104,33 +106,39 @@ fn main() {
 ```rust,ignore
 _6 = [closure@move.rs:7:13: 9:6] { x: move _1 }; // bb16[3]: scope 1 at move.rs:7:13: 9:6
 ```
-Here, `x` is directly moved into the closure and the access to it will not be permitted after the
-closure.
+Here, `x` is directly moved into the closure,
+and the access to it will not be permitted after the closure.
 
 ## Inferences in the compiler
 
 Now let's dive into rustc code and see how all these inferences are done by the compiler.
 
 Let's start with defining a term that we will be using quite a bit in the rest of the discussion -
-*upvar*. An **upvar** is a variable that is local to the function where the closure is defined. So,
-in the above examples, **x** will be an upvar to the closure. They are also sometimes referred to as
-the *free variables* meaning they are not bound to the context of the closure.
+*upvar*.
+An **upvar** is a variable that is local to the function where the closure is defined.
+So, in the above examples, **x** will be an upvar to the closure.
+They are also sometimes referred to as the *free variables*,
+meaning they are not bound to the context of the closure.
 [`compiler/rustc_passes/src/upvars.rs`][upvars] defines a query called *upvars_mentioned*
 for this purpose.
 
 [upvars]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_passes/upvars/index.html
 
-Other than lazy invocation, one other thing that distinguishes a closure from a
-normal function is that it can use the upvars. It borrows these upvars from its surrounding
-context; therefore the compiler has to determine the upvar's borrow type. The compiler starts with
-assigning an immutable borrow type and lowers the restriction (that is, changes it from
-**immutable** to **mutable** to **move**) as needed, based on the usage. In the Example 1 above, the
-closure only uses the variable for printing but does not modify it in any way and therefore, in the
-`mir_dump`, we find the borrow type for the upvar `x` to be immutable.  In example 2, however, the
-closure modifies `x` and increments it by some value.  Because of this mutation, the compiler, which
+Other than lazy invocation,
+one other thing that distinguishes a closure from a normal function is that it can use the upvars.
+It borrows these upvars from its surrounding
+context; therefore the compiler has to determine the upvar's borrow type.
+The compiler starts with assigning an immutable borrow type and lowers the restriction
+(that is, changes it from **immutable** to **mutable** to **move**) as needed, based on the usage.
+In the Example 1 above,
+the closure only uses the variable for printing but does not modify it in any way and therefore,
+in the `mir_dump`, we find the borrow type for the upvar `x` to be immutable.
+In example 2, however, the closure modifies `x` and increments it by some value.
+Because of this mutation, the compiler, which
 started off assigning `x` as an immutable reference type, has to adjust it as a mutable reference.
 Likewise in the third example, the closure drops the vector and therefore this requires the variable
-`x` to be moved into the closure. Depending on the borrow kind, the closure has to implement the
+`x` to be moved into the closure.
+Depending on the borrow kind, the closure has to implement the
 appropriate trait: `Fn` trait for immutable borrow, `FnMut` for mutable borrow,
 and `FnOnce` for move semantics.
 
@@ -141,17 +149,17 @@ declared in the file [`compiler/rustc_middle/src/ty/mod.rs`][ty].
 [upvar]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir_typeck/upvar/index.html
 [ty]:https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/index.html
 
-Before we go any further, let's discuss how we can examine the flow of control through the rustc
-codebase. For closures specifically, set the `RUSTC_LOG` env variable as below and collect the
-output in a file:
+Before we go any further,
+let's discuss how we can examine the flow of control through the rustc codebase.
+For closures specifically,
+set the `RUSTC_LOG` env variable as below and collect the output in a file:
 
 ```console
 > RUSTC_LOG=rustc_hir_typeck::upvar rustc +stage1 -Z dump-mir=all \
     <.rs file to compile> 2> <file where the output will be dumped>
 ```
 
-This uses the stage1 compiler and enables `debug!` logging for the
-`rustc_hir_typeck::upvar` module.
+This uses the stage1 compiler and enables `debug!` logging for the `rustc_hir_typeck::upvar` module.
 
 The other option is to step through the code using lldb or gdb.
 
@@ -160,8 +168,8 @@ The other option is to step through the code using lldb or gdb.
     1. `b upvar.rs:134`  // Setting the breakpoint on a certain line in the upvar.rs file
     2. `r`  // Run the program until it hits the breakpoint
 
-Let's start with [`upvar.rs`][upvar]. This file has something called
-the [`euv::ExprUseVisitor`] which walks the source of the closure and
+Let's start with [`upvar.rs`][upvar].
+This file has something called the [`euv::ExprUseVisitor`] which walks the source of the closure and
 invokes a callback for each upvar that is borrowed, mutated, or moved.
 
 [`euv::ExprUseVisitor`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir_typeck/expr_use_visitor/struct.ExprUseVisitor.html
@@ -176,32 +184,33 @@ fn main() {
 }
 ```
 
-In the above example, our visitor will be called twice, for the lines marked 1 and 2, once for a
-shared borrow and another one for a mutable borrow. It will also tell us what was borrowed.
+In the above example, our visitor will be called twice, for the lines marked 1 and 2,
+once for a shared borrow and another one for a mutable borrow.
+It will also tell us what was borrowed.
 
-The callbacks are defined by implementing the [`Delegate`] trait. The
-[`InferBorrowKind`][ibk] type implements `Delegate` and keeps a map that
-records for each upvar which mode of capture was required. The modes of capture
-can be `ByValue` (moved) or `ByRef` (borrowed). For `ByRef` borrows, the possible
-[`BorrowKind`]s are `ImmBorrow`, `UniqueImmBorrow`, `MutBorrow` as defined in the
+The callbacks are defined by implementing the [`Delegate`] trait.
+The [`InferBorrowKind`][ibk] type implements `Delegate` and keeps a map that
+records for each upvar which mode of capture was required.
+The modes of capture can be `ByValue` (moved) or `ByRef` (borrowed).
+For `ByRef` borrows, the possible [`BorrowKind`]s are `ImmBorrow`,
+`UniqueImmBorrow`, `MutBorrow` as defined in the
 [`compiler/rustc_middle/src/ty/mod.rs`][middle_ty].
 
 [`BorrowKind`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/enum.BorrowKind.html
 [middle_ty]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/index.html
 
 `Delegate` defines a few different methods (the different callbacks):
-**consume** for *move* of a variable, **borrow** for a *borrow* of some kind
-(shared or mutable), and **mutate** when we see an *assignment* of something.
+**consume** for *move* of a variable, **borrow** for a *borrow* of some kind (shared or mutable),
+and **mutate** when we see an *assignment* of something.
 
 All of these callbacks have a common argument *cmt* which stands for Category,
-Mutability and Type and is defined in
-[`compiler/rustc_hir_typeck/src/expr_use_visitor.rs`][cmt]. Borrowing from the code
-comments, "`cmt` is a complete categorization of a value indicating where it
+Mutability and Type and is defined in [`compiler/rustc_hir_typeck/src/expr_use_visitor.rs`][cmt].
+Borrowing from the code comments, "`cmt` is a complete categorization of a value indicating where it
 originated and how it is located, as well as the mutability of the memory in
 which the value is stored". Based on the callback (consume, borrow etc.), we
-will call the relevant `adjust_upvar_borrow_kind_for_<something>` and pass the
-`cmt` along. Once the borrow type is adjusted, we store it in the table, which
-basically says what borrows were made for each closure.
+will call the relevant `adjust_upvar_borrow_kind_for_<something>` and pass the `cmt` along.
+Once the borrow type is adjusted, we store it in the table,
+which basically says what borrows were made for each closure.
 
 ```rust,ignore
 self.tables
diff --git a/src/doc/rustc-dev-guide/src/offload/installation.md b/src/doc/rustc-dev-guide/src/offload/installation.md
index 8422d072bca3b..2bb7ea98f6d5b 100644
--- a/src/doc/rustc-dev-guide/src/offload/installation.md
+++ b/src/doc/rustc-dev-guide/src/offload/installation.md
@@ -3,9 +3,16 @@
 `std::offload` is partly available in nightly builds for users.
 For now, everyone however still needs to build rustc from source to use all features of it.
 
+## Rustup installation.
+
+If you are on `x86_64` Linux, you can install the nightly toolchain with:
+```console
+rustup +nightly component add offload
+```
+
 ## Build instructions
 
-First you need to clone and configure the Rust repository:
+Otherwise you need to clone and configure the Rust repository:
 ```console
 git clone git@github.com:rust-lang/rust
 cd rust
@@ -14,7 +21,8 @@ cd rust
 
 If you would rather reuse an existing clang than build one, drop `--enable-clang` and pass
 `--enable-llvm-offload-clang-dir=<absolute path to the directory holding ClangConfig.cmake>`
-instead. It should match the (major version of the) LLVM in `src/llvm-project`.
+instead.
+It should match the (major version of the) LLVM in `src/llvm-project`.
 
 Afterwards you can build rustc using:
 ```console
@@ -27,9 +35,8 @@ rustup toolchain link offload build/host/stage1
 rustup toolchain install nightly # enables -Z unstable-options
 ```
 
-
-
 ## Build instruction for LLVM itself
+
 ```console
 git clone git@github.com:llvm/llvm-project
 cd llvm-project
@@ -41,8 +48,8 @@ ninja install
 ```
 This gives you a working LLVM build.
 
-
 ## Testing
+
 Run this test script for offload-specific tests:
 ```console
 ./x test --stage 1 tests/codegen-llvm/gpu_offload
diff --git a/src/doc/rustc-dev-guide/src/offload/usage.md b/src/doc/rustc-dev-guide/src/offload/usage.md
index 77b8935fab837..9d61a5a87c744 100644
--- a/src/doc/rustc-dev-guide/src/offload/usage.md
+++ b/src/doc/rustc-dev-guide/src/offload/usage.md
@@ -49,7 +49,7 @@ fn kernel<T: Copy>(x: *mut [T; 256], value: T) {
 fn main() {
     let mut x = [0.0f64; 256];
     core::offload::offload! {
-        kernel = kernel,
+        kernel = kernel::<f64>,
         workgroup_dim = [256, 1, 1],
         args = (&mut x as *mut [f64; 256], 2.5),
     }
@@ -89,38 +89,21 @@ Now we generate the device (GPU) code, passing the manifest:
 ```
 RUSTFLAGS="-Ctarget-cpu=gfx90a --emit=llvm-bc,llvm-ir -Zoffload=Device=/absolute/path/to/offload.manifest -Csave-temps -Zunstable-options" cargo +offload build -Zunstable-options -r -v --target amdgcn-amd-amdhsa -Zbuild-std=core
 ```
-You might afterwards need to copy your target/release/deps/<lib_name>.bc to lib.bc for now, before the next step.
 
-Now we generate the host (CPU) code.
+Next we generate the host (CPU) code.
 ```
-RUSTFLAGS="--emit=llvm-bc,llvm-ir -Csave-temps -Zoffload=Host=/p/lustre1/drehwald1/prog/offload/r/target/amdgcn-amd-amdhsa/release/deps/device.bin -Zunstable-options" cargo +offload build -r
-```
-This call also does a lot of work and generates multiple intermediate files for LLVM offload.
-While we integrated most offload steps into rustc by now, one binary invocation still remains for now:
-
-```
-"clang-linker-wrapper" "--should-extract=gfx90a" "--device-compiler=amdgcn-amd-amdhsa=-g" "--device-compiler=amdgcn-amd-amdhsa=-save-temps=cwd" "--device-linker=amdgcn-amd-amdhsa=-lompdevice" "--host-triple=x86_64-unknown-linux-gnu" "--save-temps" "--linker-path=/ABSOlUTE_PATH_TO/rust/build/x86_64-unknown-linux-gnu/lld/bin/ld.lld" "--hash-style=gnu" "--eh-frame-hdr" "-m" "elf_x86_64" "-pie" "-dynamic-linker" "/lib64/ld-linux-x86-64.so.2" "-o" "main" "/lib/../lib64/Scrt1.o" "/lib/../lib64/crti.o" "/ABSOLUTE_PATH_TO/crtbeginS.o" "-L/ABSOLUTE_PATH_TO/rust/build/x86_64-unknown-linux-gnu/llvm/bin/../lib/x86_64-unknown-linux-gnu" "-L/ABSOLUTE_PATH_TO/rust/build/x86_64-unknown-linux-gnu/llvm/lib/clang/21/lib/x86_64-unknown-linux-gnu" "-L/lib/../lib64" "-L/usr/lib64" "-L/lib" "-L/usr/lib" "target/<GPU_DIR>/release/host.o" "-lstdc++" "-lm" "-lomp" "-lomptarget" "-L/ABSOLUTE_PATH_TO/rust/build/x86_64-unknown-linux-gnu/llvm/lib" "-lgcc_s" "-lgcc" "-lpthread" "-lc" "-lgcc_s" "-lgcc" "/ABSOLUTE_PATH_TO/crtendS.o" "/lib/../lib64/crtn.o"
-```
-
-You can try to find the paths to those files on your system.
-However, I recommend to not fix the paths, but rather just re-generate them by copying a bare-mode OpenMP example and compiling it with your clang.
-By adding `-###` to your clang invocation, you can see the invidual steps.
-It will show multiple steps, just look for the clang-linker-wrapper example.
-Make sure to still include the path to the `host.o` file, and not whatever tmp file you got when compiling your c++ example with the following call.
-```
-myclang++ -fuse-ld=lld -O3 -fopenmp  -fopenmp-offload-mandatory --offload-arch=gfx90a omp_bare.cpp -o main -###
+RUSTFLAGS="--emit=llvm-bc,llvm-ir -Csave-temps -Zoffload=Host=$PWD/target/amdgcn-amd-amdhsa/release/deps/device.bin -Zunstable-options" cargo +offload build -r
 ```
 
 In the final step, you can now run your binary
 
 ```
-./main
+LD_LIBRARY_PATH=$(rustc +nightly --print sysroot)/lib  ./target/x86_64-unknown-linux-gnu/release/binary-name
 all checks passed!
 ```
 
-To receive more information about the memory transfer, you can enable info printing with
-```
-LIBOMPTARGET_INFO=-1  ./main
-```
+These three steps will soon be wrapped into a single command, once we had more time to test all steps.
+
+To receive more information about the memory transfer, you can enable info printing by adding `LIBOMPTARGET_INFO=-1` ahead of your binary call.
 
 [^list]: https://rocm.docs.amd.com/en/latest/reference/gpu-arch-specs.html or https://developer.nvidia.com/cuda/gpus. Alternatively, check `rustc --print target-cpus`.
diff --git a/src/doc/rustc-dev-guide/src/solve/sharing-crates-with-rust-analyzer.md b/src/doc/rustc-dev-guide/src/solve/sharing-crates-with-rust-analyzer.md
index 2b06f5b414c1b..19db5016eb073 100644
--- a/src/doc/rustc-dev-guide/src/solve/sharing-crates-with-rust-analyzer.md
+++ b/src/doc/rustc-dev-guide/src/solve/sharing-crates-with-rust-analyzer.md
@@ -59,7 +59,7 @@ solver.
 `rustc_next_trait_solver` is intended to depend only on the abstract interfaces defined in
 `rustc_type_ir`.
 To support this, the type-system traits in `rustc_type_ir` must expose every interface the solver
-requires—for example, [creating a new inference type variable][ir new_infer] 
+requires—for example, [creating a new inference type variable][ir new_infer]
 ([rustc][rustc new_infer], [rust-analyzer][r-a new_infer]).
 For items that do not need compiler-specific representations, `rustc_type_ir` defines them directly
 as structs or enums parameterized over these traits—for example, [`TraitRef`][ir tr].
@@ -77,7 +77,8 @@ Among its essential responsibilities:
   instantiates the shared IR,
 - it provides the context required by the solver (e.g., querying [lang items][ir require_lang_item],
   enumerating [all blanket impls for a trait][ir for_each_blanket_impl]);
-- and it must implement [`IrPrint`][ir irprint] for formatting and tracing.  
+- and it must implement [`IrPrint`][ir irprint] for formatting and tracing.
+
   In practice, these `IrPrint` impls simply route to existing formatting logic inside rustc or
   rust-analyzer.
 
@@ -91,7 +92,8 @@ rather than rustc queries.
 
 Another notable item in `rustc_type_ir` is the [`inherent` module][ir inherent].
 This module provides *forward definitions* of inherent methods—expressed as traits—corresponding to
-methods that exist on compiler-specific types such as `Ty` or `GenericArg`.  
+methods that exist on compiler-specific types such as `Ty` or `GenericArg`.
+
 These definitions allow the generic crates (such as `rustc_next_trait_solver`) to call methods that
 are implemented differently in rustc and rust-analyzer.
 
@@ -151,9 +153,9 @@ This infrastructure is used by the external fuzzing project:
 - [`trait Lift` and `Lift_Generic`][lift-trait-macro]
 - [`trait GenericTypeVisitable`][generictypevisitable]
 
-These traits are used heavily in `rustc_type_ir`, their associated macros 
-primarily exist to reduce the amount of boilerplate otherwise required to
-implement `Lift`, `TypeFoldable`, `TypeVisitable` and `GenericTypeVisitable`.
+These traits are used heavily in `rustc_type_ir`, their associated macros
+primarily exist to reduce the amount of boilerplate otherwise required to implement `Lift`,
+`TypeFoldable`, `TypeVisitable` and `GenericTypeVisitable`.
 
 ### `trait TypeVisitable` and `TypeVisitable_Generic`
 [type-visitable-trait-macro]: #type-visitable-trait-macro
@@ -163,8 +165,7 @@ which in turn will transfer control to `TypeVisitor`, this can be
 [seen in detail here][rustc_typevisitable].
 
 While ostensibly similar due to their names, `TypeVisitable_Generic` and
-[`GenericTypeVisitable`][generictypevisitable] they implement two different
-visiting systems.
+[`GenericTypeVisitable`][generictypevisitable] they implement two different visiting systems.
 
 - `TypeVisitable_Generic` means: derive the ordinary `TypeVisitable` trait
   generically over an `Interner`.
@@ -175,50 +176,49 @@ visiting systems.
 [typevisitable_generic]: #typevisitable_generic
 
 It visits the value's fields in declaration order, delegating each field to that
-field's own `TypeVisitable<I>` implementation. The traversal can stop early if
-the visitor returns a residual result.
+field's own `TypeVisitable<I>` implementation.
+The traversal can stop early if the visitor returns a residual result.
 
 Use `#[type_visitable(ignore)]` to ignore a field; it will not be part of the
-traversal and will not need to implement `TypeVisitable<I>`. This should only
-be used when the field does not need to be traversed.
+traversal and will not need to implement `TypeVisitable<I>`.
+This should only be used when the field does not need to be traversed.
 
 ### `trait TypeFoldable` and `TypeFoldable_Generic`
 [type-foldable-trait-macro]: #type-foldable-trait-macro
 
-The trait is implemented by things that need to embed types. This concept is
-discussed in detail [here](../ty-fold.md) and can be
+The trait is implemented by things that need to embed types.
+This concept is discussed in detail [here](../ty-fold.md) and can be
 [followed in the source][rustc_typefoldable].
 
-`TypeFoldable_Generic` derives `rustc_type_ir::TypeFoldable<I>` for a struct or
-enum.
+`TypeFoldable_Generic` derives `rustc_type_ir::TypeFoldable<I>` for a struct or enum.
 
-It consumes a value and reconstructs the same struct or enum variant after
-folding its fields. It generates both fallible and infallible folding methods.
+It consumes a value and reconstructs the same struct or enum variant after folding its fields.
+It generates both fallible and infallible folding methods.
 
-Use `#[type_foldable(identity)]` for a field whose value must be preserved
-unchanged. The macro moves that field directly into the reconstructed value
-instead of passing it to the folder. Its type therefore does not need to
-implement `TypeFoldable<I>`.
+Use `#[type_foldable(identity)]` for a field whose value must be preserved unchanged.
+The macro moves that field directly into the reconstructed value
+instead of passing it to the folder.
+Its type therefore does not need to implement `TypeFoldable<I>`.
 
 For an enum, the generated match contains one reconstruction arm per variant.
 
 ### `trait Lift` and `Lift_Generic`
 [lift-trait-macro]: #lift-trait-macro
 
-The trait has a method `lift_to_interner(...)`. As the name suggests, it should
-'lift' something to the interner. [See here](../memory.md) to read more about
-the interner [and here for the source][rustc_lift].
+The trait has a method `lift_to_interner(...)`.
+As the name suggests, it should 'lift' something to the interner.
+[See here](../memory.md) to read more about the interner [and here for the source][rustc_lift].
 
-The macro `Lift_Generic` derives `Lift` for a struct or enum, with three
-non-obvious considerations:
+The macro `Lift_Generic` derives `Lift` for a struct or enum, with three non-obvious considerations:
 
 1. The generic parameters `I` and `J` are reserved for `I: Interner` and `J`
    being the interner it is being lifted to.
-2. `PhantomData` is handled automatically, creating a new `PhantomData`. But it
-   _has_ to be used in the fully unqualified form -- you cannot use
+2. `PhantomData` is handled automatically, creating a new `PhantomData`.
+   But it _has_ to be used in the fully unqualified form -- you cannot use
    `std::marker::PhantomData` directly in the field.
 3. The bounds are deliberately written as associated type bounds on the `Interner`
-   trait rather than as `where` clauses on `LiftInto`. Given only `I: LiftInto<J>`,
+   trait rather than as `where` clauses on `LiftInto`.
+   Given only `I: LiftInto<J>`,
    Rust can then treat bounds such as the following as implied:
 
 ```rust
@@ -228,15 +228,14 @@ I::Const: Lift<J, Lifted = J::Const>
 
 This allows `Lift_Generic` to emit the bound `I: LiftInto<J>` while still
 calling `lift_to_interner` on fields of type `I::Ty`, `I::Const`, and the other
-declared associated types. It also guarantees that each call produces the
-destination field type expected after the derive rewrites `I::Assoc` to
-`J::Assoc`.
+declared associated types.
+It also guarantees that each call produces the
+destination field type expected after the derive rewrites `I::Assoc` to `J::Assoc`.
 
 Without `declare_lift_into!`, the derive would need to generate a separate bound
-for every interner-associated type used by every field. If a new `Interner`
-associated type is expected to work with `Lift_Generic`, it needs an appropriate
-`Lift` implementation and normally needs to be included in the
-`declare_lift_into!` invocation.
+for every interner-associated type used by every field.
+If a new `Interner` associated type is expected to work with `Lift_Generic`, it needs an appropriate
+`Lift` implementation and normally needs to be included in the `declare_lift_into!` invocation.
 
 If you want to ignore a field, such as a primitive like a `u32` which can't be
 lifted you can skip the field with `#[lift(ignore)]`.
@@ -245,28 +244,28 @@ lifted you can skip the field with `#[lift(ignore)]`.
 [generictypevisitable]: #generictypevisitable
 
 This a separate more general traversal trait purely used by `rust-analyzer`.
-The visitor type is a parameter of the trait rather than a parameter of the
-method, and visiting neither returns a result nor supports short-circuiting.
+The visitor type is a parameter of the trait rather than a parameter of the method,
+and visiting neither returns a result nor supports short-circuiting.
 
-As such a struct or enum can derive both `TypeVisitable_Generic` and
-`GenericTypeVisitable`
+As such a struct or enum can derive both `TypeVisitable_Generic` and `GenericTypeVisitable`
 
-There is intentionally no ignore attribute. The traversal must visit every
-field. This is a soundness requirement for rust-analyzer's use of the traversal
+There is intentionally no ignore attribute.
+The traversal must visit every field.
+This is a soundness requirement for rust-analyzer's use of the traversal
 when tracing and garbage-collecting interned types.
 
 ## Long-term plans for supporting rust-analyzer
 
 In general, we aim to support rust-analyzer just as well as rustc in these shared crates—provided
-doing so does not substantially harm rustc's performance or maintainability. 
+doing so does not substantially harm rustc's performance or maintainability.
 (e.g., [#145377][pr 145377], [#146111][pr 146111], [#146182][pr 146182] and [#147723][pr 147723])
 
 Shared crates that require nightly-only features must guard such code behind a `nightly` feature
 flag, since rust-analyzer is built with the stable toolchain.
 
 Looking forward, we plan to uplift more shared logic into `rustc_type_ir`.
-There are still duplicated implementations between rustc and rust-analyzer—such as `ObligationCtxt` 
-([rustc][rustc oblctxt], [rust-analyzer][r-a oblctxt]) and type coercion logic 
+There are still duplicated implementations between rustc and rust-analyzer—such as `ObligationCtxt`
+([rustc][rustc oblctxt], [rust-analyzer][r-a oblctxt]) and type coercion logic
 ([rustc][rustc coerce], [rust-analyzer][r-a coerce])—that we would like to unify over time.
 
 [rustc-auto-publish]: https://github.com/rust-analyzer/rustc-auto-publish
@@ -303,5 +302,5 @@ There are still duplicated implementations between rustc and rust-analyzer—suc
 [rustc coerce]: https://github.com/rust-lang/rust/blob/63b1db05801271e400954e41b8600a3cf1482363/compiler/rustc_hir_typeck/src/coercion.rs
 [r-a coerce]: https://github.com/rust-lang/rust-analyzer/blob/34f47d9298c478c12c6c4c0348771d1b05706e09/crates/hir-ty/src/infer/coerce.rs
 [rustc_lift]: https://github.com/rust-lang/rust/blob/0913b18e489ac1011b580e31fa5559654be12bfc/compiler/rustc_type_ir/src/lift.rs#L18
-[rustc_typevisitable]: https://github.com/rust-lang/rust/blob/0913b18e489ac1011b580e31fa5559654be12bfc/compiler/rustc_type_ir/src/visit.rs#L62 
+[rustc_typevisitable]: https://github.com/rust-lang/rust/blob/0913b18e489ac1011b580e31fa5559654be12bfc/compiler/rustc_type_ir/src/visit.rs#L62
 [rustc_typefoldable]: https://github.com/rust-lang/rust/blob/0913b18e489ac1011b580e31fa5559654be12bfc/compiler/rustc_type_ir/src/fold.rs#L71
diff --git a/src/doc/rustc-dev-guide/src/test-implementation.md b/src/doc/rustc-dev-guide/src/test-implementation.md
index 707ba040609e0..5df7d8d304d22 100644
--- a/src/doc/rustc-dev-guide/src/test-implementation.md
+++ b/src/doc/rustc-dev-guide/src/test-implementation.md
@@ -1,9 +1,7 @@
 # The `#[test]` attribute
 
-
-
-Many Rust programmers rely on a built-in attribute called `#[test]`. All
-you have to do is mark a function and include some asserts like so:
+Many Rust programmers rely on a built-in attribute called `#[test]`.
+All you have to do is mark a function and include some asserts like so:
 
 
 ```rust,ignore
@@ -14,9 +12,9 @@ fn my_test() {
 ```
 
 When this program is compiled using `rustc --test` or `cargo test`, it will
-produce an executable that can run this, and any other test function. This
-method of testing allows tests to live alongside code in an organic way. You
-can even put tests inside private modules:
+produce an executable that can run this, and any other test function.
+This method of testing allows tests to live alongside code in an organic way.
+You can even put tests inside private modules:
 
 ```rust,ignore
 mod my_priv_mod {
@@ -30,22 +28,23 @@ mod my_priv_mod {
 ```
 
 Private items can thus be easily tested without worrying about how to expose
-them to any sort of external testing apparatus. This is key to the
-ergonomics of testing in Rust. Semantically, however, it's rather odd.
+them to any sort of external testing apparatus.
+This is key to the ergonomics of testing in Rust.
+Semantically, however, it's rather odd.
 How does any sort of `main` function invoke these tests if they're not visible?
 What exactly is `rustc --test` doing?
 
 `#[test]` is implemented as a syntactic transformation inside the compiler's
-[`rustc_ast`][rustc_ast]. Essentially, it's a fancy [`macro`] that
-rewrites the crate in 3 steps:
+[`rustc_ast`][rustc_ast].
+Essentially, it's a fancy [`macro`] that rewrites the crate in 3 steps:
 
 ## Step 1: Re-Exporting
 
 As mentioned earlier, tests can exist inside private modules, so we need a
-way of exposing them to the main function, without breaking any existing
-code. To that end, [`rustc_ast`][rustc_ast] will create local modules called
-`__test_reexports` that recursively reexport tests. This expansion translates
-the above example into:
+way of exposing them to the main function, without breaking any existing code.
+To that end, [`rustc_ast`][rustc_ast] will create local modules called
+`__test_reexports` that recursively reexport tests.
+This expansion translates the above example into:
 
 ```rust,ignore
 mod my_priv_mod {
@@ -61,24 +60,24 @@ mod my_priv_mod {
 }
 ```
 
-Now, our test can be accessed as
-`my_priv_mod::__test_reexports::test_priv_func`. For deeper module
-structures, `__test_reexports` will reexport modules that contain tests, so a
-test at `a::b::my_test` becomes
-`a::__test_reexports::b::__test_reexports::my_test`. While this process seems
-pretty safe, what happens if there is an existing `__test_reexports` module?
+Now, our test can be accessed as `my_priv_mod::__test_reexports::test_priv_func`.
+For deeper module structures, `__test_reexports` will reexport modules that contain tests, so a
+test at `a::b::my_test` becomes `a::__test_reexports::b::__test_reexports::my_test`.
+While this process seems pretty safe,
+what happens if there is an existing `__test_reexports` module?
 The answer: nothing.
 
 To explain, we need to understand how Rust's [Abstract Syntax Tree][ast]
-represents [identifiers][Ident]. The name of every function, variable, module,
-etc. is not stored as a string, but rather as an opaque [Symbol][Symbol] which
-is essentially an ID number for each identifier. The compiler keeps a separate
-hashtable that allows us to recover the human-readable name of a Symbol when
-necessary (such as when printing a syntax error). When the compiler generates
-the `__test_reexports` module, it generates a new [Symbol][Symbol] for the
-identifier, so while the compiler-generated `__test_reexports` may share a name
-with your hand-written one, it will not share a [Symbol][Symbol]. This
-technique prevents name collision during code generation and is the foundation
+represents [identifiers][Ident].
+The name of every function, variable, module, etc. is not stored as a string,
+but rather as an opaque [Symbol] which is essentially an ID number for each identifier.
+The compiler keeps a separate hashtable that allows us to recover
+the human-readable name of a Symbol when necessary (such as when printing a syntax error).
+When the compiler generates the `__test_reexports` module,
+it generates a new [Symbol] for the identifier,
+so while the compiler-generated `__test_reexports` may share a name
+with your hand-written one, it will not share a [Symbol].
+This technique prevents name collision during code generation and is the foundation
 of Rust's [`macro`] hygiene.
 
 ## Step 2: Harness generation
@@ -96,20 +95,20 @@ pub fn main() {
 
 Here `path::to::test1` is a constant of type [`test::TestDescAndFn`][tdaf].
 
-While this transformation is simple, it gives us a lot of insight into how
-tests are actually run. The tests are aggregated into an array and passed to
-a test runner called `test_main_env_args`. We'll come back to exactly what
-[`TestDescAndFn`][tdaf] is, but for now, the key takeaway is that there is a crate
-called [`test`][test] that is part of Rust core, that implements all of the
-runtime for testing. [`test`][test]'s interface is unstable, so the only stable way
+While this transformation is simple, it gives us a lot of insight into how tests are actually run.
+The tests are aggregated into an array and passed to a test runner called `test_main_env_args`.
+We'll come back to exactly what [`TestDescAndFn`][tdaf] is,
+but for now, the key takeaway is that there is a crate
+called [`test`][test] that is part of Rust core, that implements all of the runtime for testing.
+[`test`][test]'s interface is unstable, so the only stable way
 to interact with it is through the `#[test]` macro.
 
 ## Step 3: Test object generation
 
 If you've written tests in Rust before, you may be familiar with some of the
-optional attributes available on test functions. For example, a test can be
-annotated with `#[should_panic]` if we expect the test to cause a panic. It
-looks something like this:
+optional attributes available on test functions.
+For example, a test can be annotated with `#[should_panic]` if we expect the test to cause a panic.
+It looks something like this:
 
 ```rust,ignore
 #[test]
@@ -120,12 +119,12 @@ fn foo() {
 ```
 
 This means our tests are more than just simple functions, they have
-configuration information as well. `test` encodes this configuration data into
-a `struct` called [`TestDesc`]. For each test function in a crate,
-[`rustc_ast`][rustc_ast] will parse its attributes and generate a [`TestDesc`]
-instance. It then combines the [`TestDesc`] and test function into the
-predictably named [`TestDescAndFn`][tdaf] `struct`, that [`test_main_env_args`]
-operates on.
+configuration information as well.
+`test` encodes this configuration data into a `struct` called [`TestDesc`].
+For each test function in a crate,
+[`rustc_ast`][rustc_ast] will parse its attributes and generate a [`TestDesc`] instance.
+It then combines the [`TestDesc`] and test function into the
+predictably named [`TestDescAndFn`][tdaf] `struct`, that [`test_main_env_args`] operates on.
 For a given test, the generated [`TestDescAndFn`][tdaf] instance looks like so:
 
 ```rust,ignore
diff --git a/src/doc/rustc-dev-guide/src/tests/compiletest.md b/src/doc/rustc-dev-guide/src/tests/compiletest.md
index 4573a04d0281c..ee42cf1fa1d87 100644
--- a/src/doc/rustc-dev-guide/src/tests/compiletest.md
+++ b/src/doc/rustc-dev-guide/src/tests/compiletest.md
@@ -3,8 +3,8 @@
 ## Introduction
 
 `compiletest` is the main test harness of the Rust test suite.
-It allows test authors to organize large numbers of tests (the Rust compiler has many
-thousands), efficient test execution (parallel execution is supported), and
+It allows test authors to organize large numbers of tests (the Rust compiler has many thousands),
+efficient test execution (parallel execution is supported), and
 allows the test author to configure behavior and expected results of both
 individual and groups of tests.
 
@@ -23,14 +23,14 @@ individual and groups of tests.
 
 Tests are typically organized as a Rust source file with annotations in comments
 before and/or within the test code.
-These comments serve to direct `compiletest`
-on if or how to run the test, what behavior to expect, and more.
+These comments serve to direct `compiletest` on if or how to run the test,
+what behavior to expect, and more.
 See [directives](directives.md) and the test suite documentation below for more details
 on these annotations.
 
 See the [Adding new tests](adding.md) and [Best practices](best-practices.md)
-chapters for a tutorial on creating a new test and advice on writing a good
-test, and the [Running tests](running.md) chapter on how to run the test suite.
+chapters for a tutorial on creating a new test and advice on writing a good test,
+and the [Running tests](running.md) chapter on how to run the test suite.
 
 Arguments can be passed to compiletest using `--test-args` or by placing them after `--`, e.g.
 - `x test --test-args --force-rerun`
@@ -49,8 +49,8 @@ You can use `x test --test-args
 
 All of the tests are in the [`tests`] directory.
 The tests are organized into "suites", with each suite in a separate subdirectory.
-Each test suite behaves a
-little differently, with different compiler behavior and different checks for correctness.
+Each test suite behaves a little differently,
+with different compiler behavior and different checks for correctness.
 For example, the [`tests/incremental`] directory contains tests for incremental compilation.
 The various suites are defined in
 [`src/tools/compiletest/src/common.rs`] in the `pub enum Mode` declaration.
@@ -114,8 +114,8 @@ The `-Z unpretty` CLI option for `rustc` causes it to translate the
 input source into various different formats, such as the Rust source after macro expansion.
 
 The pretty-printer tests have several [directives](directives.md) described below.
-These commands can significantly change the behavior of the test, but the
-default behavior without any commands is to:
+These commands can significantly change the behavior of the test,
+but the default behavior without any commands is to:
 
 1. Run `rustc -Zunpretty=normal` on the source file.
 2. Run `rustc -Zunpretty=normal` on the output of the previous step.
@@ -133,17 +133,17 @@ The directives for pretty-printing tests are:
 - `pretty-compare-only` causes a pretty test to only compare the pretty-printed
   output (stopping after step 3 from above).
   It will not try to compile the expanded output to type check it.
-  This is needed for a pretty-mode that does
-  not expand to valid Rust, or for other situations where the expanded output cannot be compiled.
+  This is needed for a pretty-mode that does not expand to valid Rust,
+  or for other situations where the expanded output cannot be compiled.
 - `pp-exact` is used to ensure a pretty-print test results in specific output.
-  If specified without a value, then it means the pretty-print output should
-  match the original source.
-  If specified with a value, as in `//@
-  pp-exact:foo.pp`, it will ensure that the pretty-printed output matches the
+  If specified without a value,
+  then it means the pretty-print output should match the original source.
+  If specified with a value, as in `//@ pp-exact:foo.pp`,
+  it will ensure that the pretty-printed output matches the
   contents of the given file.
   Otherwise, if `pp-exact` is not specified, then
-  the pretty-printed output will be pretty-printed one more time, and the output
-  of the two pretty-printing rounds will be compared to ensure that the
+  the pretty-printed output will be pretty-printed one more time,
+  and the output of the two pretty-printing rounds will be compared to ensure that the
   pretty-printed output converges to a steady state.
 
 [`tests/pretty`]: https://github.com/rust-lang/rust/tree/HEAD/tests/pretty
@@ -166,8 +166,8 @@ Each revision name must start with one of:
 
 To make the revisions unique, you should add a suffix like `rpass1` and `rpass2`.
 
-To simulate changing the source, compiletest also passes a `--cfg` flag with the
-current revision name.
+To simulate changing the source,
+compiletest also passes a `--cfg` flag with the current revision name.
 
 For example, this will run twice, simulating changing a function:
 
@@ -221,9 +221,10 @@ A simple example of a test using `rustc_clean` is the [hello_world test].
 > opt-in. For further context, see:
 > [Stabilizing the state of the debuginfo test suite](https://github.com/rust-lang/compiler-team/issues/1012)
 
-The tests in [`tests/debuginfo`] test how debuginfo is interpreted by the supported debuggers, and
-confirm our visualizers still work as expected. They build a program, launch a debugger, and issue
-commands to the debugger. A single test can work with cdb, gdb, and lldb.
+The tests in [`tests/debuginfo`] test how debuginfo is interpreted by the supported debuggers,
+and confirm our visualizers still work as expected.
+They build a program, launch a debugger, and issue commands to the debugger.
+A single test can work with cdb, gdb, and lldb.
 
 Most tests should have the `//@ compile-flags: -g` directive or something
 similar to generate the appropriate debuginfo.
@@ -245,8 +246,8 @@ The debugger values can be:
 The command to check the output are of the form `//@ $DEBUGGER-check:$OUTPUT`
 where `$OUTPUT` is the output to expect.
 
-For example, the following will build the test, start the debugger, set a
-breakpoint, launch the program, inspect a value, and check what the debugger prints:
+For example, the following will build the test, start the debugger, set a breakpoint,
+launch the program, inspect a value, and check what the debugger prints:
 
 ```rust,ignore
 //@ compile-flags: -g
@@ -265,7 +266,8 @@ fn b() {}
 
 Additionally, there is a special command, `//@ $DEBUGGER-repr:$VAR_NAME` intended to verify
 variables (and their visualizers) with more granularity than can be achieved with simple string
-comparison. This directive should be preferred over the `-command`/`-check` whenever possible.
+comparison.
+This directive should be preferred over the `-command`/`-check` whenever possible.
 
 > [!NOTE]
 > At time of writing (July 2026) this command is limited to LLDB, with an implementation coming soon
@@ -279,8 +281,8 @@ This command effectivly desugars into:
 ```
 
 The `repr $VAR_NAME` command is intercepted by special logic that uses the debuggers' API to inspect
-data that isn't reflected in the variable's printed output. The variable in memory is compared
-against input data stored in
+data that isn't reflected in the variable's printed output.
+The variable in memory is compared against input data stored in
 `tests/debuginfo/<test_name>/input/<debugger>_input/<target_group>.json` and
 provides detailed error messages on failure.
 
@@ -305,8 +307,9 @@ the debugger currently being used:
 - `min-apple-lldb-version: 1703.0.236.21`/`min-llvm-lldb-version: 21.1.0` — ignores the test if the
   version of lldb is below the given version.
   Note: Apple's fork of LLDB (distributed with Xcode) uses a different versioning scheme that is not
-  easily mappable to LLVM's LLDB version numbers. As such, the version gates are specified by
-  vendor. Further info on manually checking version equivalence is available [here](../debuginfo/testing.md#lldb-versioning)
+  easily mappable to LLVM's LLDB version numbers.
+  As such, the version gates are specified by vendor.
+  Further info on manually checking version equivalence is available [here](../debuginfo/testing.md#lldb-versioning)
 - `rust-lldb` — ignores the test if lldb is not contain the Rust plugin.
   NOTE: The "Rust" version of LLDB doesn't exist anymore, so this will always be ignored.
   This should probably be removed.
@@ -361,14 +364,14 @@ See the [FileCheck] documentation for a tutorial and more information.
 See also the [assembly tests](#assembly-tests) for a similar set of tests.
 
 By default, codegen tests will have `//@ needs-target-std` *implied* (that the
-target needs to support std), *unless* the `#![no_std]`/`#![no_core]` attribute
-was specified in the test source.
+target needs to support std),
+*unless* the `#![no_std]`/`#![no_core]` attribute was specified in the test source.
 You can override this behavior and explicitly
-write `//@ needs-target-std` to only run the test when target supports std, even
-if the test is `#![no_std]`/`#![no_core]`.
+write `//@ needs-target-std` to only run the test when target supports std,
+even if the test is `#![no_std]`/`#![no_core]`.
 
-If you need to work with `#![no_std]` cross-compiling tests, consult the
-[`minicore` test auxiliary](./minicore.md) chapter.
+If you need to work with `#![no_std]` cross-compiling tests,
+consult the [`minicore` test auxiliary](./minicore.md) chapter.
 
 [`tests/codegen-llvm`]: https://github.com/rust-lang/rust/tree/HEAD/tests/codegen-llvm
 [FileCheck]: https://llvm.org/docs/CommandGuide/FileCheck.html
@@ -388,8 +391,8 @@ See the [FileCheck] documentation for a tutorial and more information.
 
 See also the [codegen tests](#codegen-tests) for a similar set of tests.
 
-If you need to work with `#![no_std]` cross-compiling tests, consult the
-[`minicore` test auxiliary](./minicore.md) chapter.
+If you need to work with `#![no_std]` cross-compiling tests,
+consult the [`minicore` test auxiliary](./minicore.md) chapter.
 
 [`tests/assembly-llvm`]: https://github.com/rust-lang/rust/tree/HEAD/tests/assembly-llvm
 
@@ -444,10 +447,10 @@ There are several forms the `EMIT_MIR` comment can take:
   interested in the final state after an optimization.
   Some rare cases may want to use the "before" file for completeness.
 
-- `// EMIT_MIR $MIR_PATH.diff` — where `$MIR_PATH` is the filename of the MIR
-  dump, such as `my_test_name.my_function.EarlyOtherwiseBranch`.
-  Compiletest will diff the `.before.mir` and `.after.mir` files, and compare the diff
-  output to the expected `.diff` file from the `EMIT_MIR` comment.
+- `// EMIT_MIR $MIR_PATH.diff` — where `$MIR_PATH` is the filename of the MIR dump,
+  such as `my_test_name.my_function.EarlyOtherwiseBranch`.
+  Compiletest will diff the `.before.mir` and `.after.mir` files,
+  and compare the diff output to the expected `.diff` file from the `EMIT_MIR` comment.
 
   This is useful if you want to see how an optimization changes the MIR.
 
@@ -457,8 +460,8 @@ There are several forms the `EMIT_MIR` comment can take:
 
 By default 32 bit and 64 bit targets use the same dump files, which can be
 problematic in the presence of pointers in constants or other bit width dependent things.
-In that case you can add `// EMIT_MIR_FOR_EACH_BIT_WIDTH` to
-your test, causing separate files to be generated for 32bit and 64bit systems.
+In that case you can add `// EMIT_MIR_FOR_EACH_BIT_WIDTH` to your test,
+causing separate files to be generated for 32bit and 64bit systems.
 
 [`tests/mir-opt`]: https://github.com/rust-lang/rust/tree/HEAD/tests/mir-opt
 
@@ -491,8 +494,8 @@ Each test should be in a separate directory with a `rmake.rs` Rust program,
 called the *recipe*. A recipe will be compiled and executed by compiletest with
 the `run_make_support` library linked in.
 
-If you need new utilities or functionality, consider extending and improving the
-[`run_make_support`] library.
+If you need new utilities or functionality,
+consider extending and improving the [`run_make_support`] library.
 
 Compiletest directives like `//@ only-<target>` or `//@ ignore-<target>` are
 supported in `rmake.rs`, like in UI tests.
@@ -524,11 +527,11 @@ Of course, some tests will not successfully *run* in this way.
 
 #### Using rust-analyzer with `rmake.rs`
 
-Like other test programs, the `rmake.rs` scripts used by run-make tests do not
-have rust-analyzer integration by default.
+Like other test programs,
+the `rmake.rs` scripts used by run-make tests do not have rust-analyzer integration by default.
 
-To work around this when working on a particular test, temporarily create a
-`Cargo.toml` file in the test's directory
+To work around this when working on a particular test,
+temporarily create a `Cargo.toml` file in the test's directory
 (e.g. `tests/run-make/sysroot-crates-are-unstable/Cargo.toml`)
 with these contents:
 
@@ -589,8 +592,8 @@ Each mode also has an alias to run the coverage tests in just that mode:
 ./x test coverage-map -- tests/coverage/if.rs # runs the specified test in "coverage-map" mode only
 ```
 
-If a particular test should not be run in one of the coverage test modes for
-some reason, use the `//@ ignore-coverage-map` or `//@ ignore-coverage-run` directives.
+If a particular test should not be run in one of the coverage test modes for some reason,
+use the `//@ ignore-coverage-map` or `//@ ignore-coverage-run` directives.
 
 #### `coverage-map` suite
 
@@ -598,11 +601,11 @@ In `coverage-map` mode, these tests verify the mappings between source code
 regions and coverage counters that are emitted by LLVM.
 They compile the test with `--emit llvm-ir`, then use a custom tool ([`src/tools/coverage-dump`]) to
 extract and pretty-print the coverage mappings embedded in the IR.
-These tests don't require the profiler runtime, so they run in PR CI jobs and are easy to
-run/bless locally.
+These tests don't require the profiler runtime,
+so they run in PR CI jobs and are easy to run/bless locally.
 
-These coverage map tests can be sensitive to changes in MIR lowering or MIR
-optimizations, producing mappings that are different but produce identical coverage reports.
+These coverage map tests can be sensitive to changes in MIR lowering or MIR optimizations,
+producing mappings that are different but produce identical coverage reports.
 
 As a rule of thumb, any PR that doesn't change coverage-specific code should
 **feel free to re-bless** the `coverage-map` tests as necessary, without
@@ -612,19 +615,19 @@ worrying about the actual changes, as long as the `coverage-run` tests still pas
 
 In `coverage-run` mode, these tests perform an end-to-end test of coverage reporting.
 They compile a test program with coverage instrumentation, run that
-program to produce raw coverage data, and then use LLVM tools to process that
-data into a human-readable code coverage report.
+program to produce raw coverage data,
+and then use LLVM tools to process that data into a human-readable code coverage report.
 
-Instrumented binaries need to be linked against the LLVM profiler runtime, so
-`coverage-run` tests are **automatically skipped** unless the profiler runtime
+Instrumented binaries need to be linked against the LLVM profiler runtime,
+so `coverage-run` tests are **automatically skipped** unless the profiler runtime
 is enabled in `bootstrap.toml`:
 
 ```toml
 build.profiler = true
 ```
 
-This also means that they typically don't run in PR CI jobs, though they do run
-as part of the full set of CI jobs used for merging.
+This also means that they typically don't run in PR CI jobs,
+though they do run as part of the full set of CI jobs used for merging.
 
 #### `coverage-run-rustdoc` suite
 
@@ -638,8 +641,8 @@ This avoids having to build rustdoc when only running the main `coverage` suite.
 
 ### Crash tests
 
-[`tests/crashes`] serve as a collection of tests that are expected to cause the
-compiler to ICE, panic or crash in some other way, so that accidental fixes are tracked.
+[`tests/crashes`] serve as a collection of tests that are expected to cause the compiler to ICE,
+panic, or crash in some other way, so that accidental fixes are tracked.
 Formerly, this was done at <https://github.com/rust-lang/glacier> but
 doing it inside the rust-lang/rust testsuite is more convenient.
 
@@ -659,8 +662,8 @@ When you do so, each issue number should be noted in the file name (`12345.rs`
 should suffice) and also inside the file by means of a `//@ known-bug: #12345` directive.
 Please [label][labeling] the relevant issues with `S-bug-has-test` once your PR is merged.
 
-If you happen to fix one of the crashes, please move it to a fitting
-subdirectory in `tests/ui` and give it a meaningful name.
+If you happen to fix one of the crashes,
+please move it to a fitting subdirectory in `tests/ui` and give it a meaningful name.
 Please add a doc comment at the top of the file explaining why this test exists.
 Even better will be if you can briefly explain how the example caused rustc to crash previously,
 and what was done to fix it.
@@ -711,8 +714,8 @@ The `-L` flag is used to find the extern crates.
 `aux-crate` is very similar to `aux-build`.
 However, it uses the `--extern` flag
 to link to the extern crate to make the crate be available as an extern prelude.
-That allows you to specify the additional syntax of the `--extern` flag, such as
-renaming a dependency.
+That allows you to specify the additional syntax of the `--extern` flag,
+such as renaming a dependency.
 For example, `//@ aux-crate: foo=bar.rs` will compile
 `auxiliary/bar.rs` and make it available under the name `foo` within the test.
 This is similar to how Cargo does dependency renaming.
@@ -722,8 +725,8 @@ For example, `//@ aux-crate: noprelude:foo=bar.rs`.
 `aux-bin` is similar to `aux-build` but will build a binary instead of a library.
 The binary will be available in `auxiliary/bin` relative to the working directory of the test.
 
-`aux-codegen-backend` is similar to `aux-build`, but will then pass the compiled
-dylib to `-Zcodegen-backend` when building the main file.
+`aux-codegen-backend` is similar to `aux-build`,
+but will then pass the compiled dylib to `-Zcodegen-backend` when building the main file.
 This will only work for tests in `tests/ui-fulldeps`, since it requires the use of compiler crates.
 
 ### Auxiliary proc-macro
@@ -740,8 +743,8 @@ preset behavior compared to `aux-build` for the proc-macro test auxiliary:
    to produce a dylib for the aux crate.
 3. The aux crate is made available to the test file via extern prelude with
    `--extern <aux_crate_name>`.
-   Note that since UI tests default to edition
-   2015, you still need to specify `extern <aux_crate_name>` unless the main
+   Note that since UI tests default to edition 2015,
+   you still need to specify `extern <aux_crate_name>` unless the main
    test file is using an edition that is 2018 or newer if you want to use the
    aux crate name in a `use` import.
 4. The `proc_macro` crate is made available as an extern prelude module.
@@ -794,8 +797,8 @@ This is done by adding a special directive at the top of the file:
 //@ revisions: foo bar baz
 ```
 
-This will result in the test being compiled (and tested) three times, once with
-`--cfg foo`, once with `--cfg bar`, and once with `--cfg baz`.
+This will result in the test being compiled (and tested) three times, once with `--cfg foo`,
+once with `--cfg bar`, and once with `--cfg baz`.
 You can therefore use `#[cfg(foo)]` etc within the test to tweak each of these results.
 
 You can also customize directives and expected error messages to a particular revision.
@@ -814,8 +817,8 @@ fn test_foo() {
 
 Multiple revisions can be specified in a comma-separated list, such as `//[foo,bar,baz]~^`.
 
-In test suites that use the LLVM [FileCheck] tool, the current revision name is
-also registered as an additional prefix for FileCheck directives:
+In test suites that use the LLVM [FileCheck] tool,
+the current revision name is also registered as an additional prefix for FileCheck directives:
 
 ```rust,ignore
 //@ revisions: NORMAL COVERAGE
@@ -848,8 +851,8 @@ Normally, revision names mentioned in other directives and error annotations
 must correspond to an actual revision declared in a `revisions` directive.
 This is enforced by an `./x test tidy` check.
 
-If a revision name needs to be temporarily removed from the revision list for
-some reason, the above check can be suppressed by adding the revision name to an
+If a revision name needs to be temporarily removed from the revision list for some reason,
+the above check can be suppressed by adding the revision name to an
 `//@ unused-revision-names:` header instead.
 
 Specifying an unused name of `*` (i.e. `//@ unused-revision-names: *`) will
@@ -857,10 +860,10 @@ permit any unused revision name to be mentioned.
 
 ## Compare modes
 
-Compiletest can be run in different modes, called _compare modes_, which can be
-used to compare the behavior of all tests with different compiler flags enabled.
-This can help highlight what differences might appear with certain flags, and
-check for any problems that might arise.
+Compiletest can be run in different modes, called _compare modes_,
+which can be used to compare the behavior of all tests with different compiler flags enabled.
+This can help highlight what differences might appear with certain flags,
+and check for any problems that might arise.
 
 To run the tests in a different mode, you need to pass the `--compare-mode` CLI flag:
 
@@ -885,8 +888,8 @@ In CI, compare modes are only used in one Linux builder, and only with the follo
   This helps ensure that none of the debuginfo tests are affected when enabling split-DWARF.
 
 Note that compare modes are separate to [revisions](#revisions).
-All revisions are tested when running `./x test tests/ui`, however compare-modes must be
-manually run individually via the `--compare-mode` flag.
+All revisions are tested when running `./x test tests/ui`,
+however compare-modes must be manually run individually via the `--compare-mode` flag.
 
 ## Parallel frontend
 
diff --git a/src/doc/rustc-dev-guide/src/tests/ecosystem-test-jobs/fuchsia.md b/src/doc/rustc-dev-guide/src/tests/ecosystem-test-jobs/fuchsia.md
index 3f274464c6e63..ca7a9f482f1ae 100644
--- a/src/doc/rustc-dev-guide/src/tests/ecosystem-test-jobs/fuchsia.md
+++ b/src/doc/rustc-dev-guide/src/tests/ecosystem-test-jobs/fuchsia.md
@@ -14,12 +14,11 @@ Please contact the [fuchsia][fuchsia-ping] ping group and ask them for help.
 
 ## Building Fuchsia in CI
 
-Fuchsia builds as part of the suite of bors tests that run before a pull request
-is merged.
+Fuchsia builds as part of the suite of bors tests that run before a pull request is merged.
 
 If you are worried that a pull request might break the Fuchsia builder and want
-to test it out before submitting it to the bors queue, simply ask bors to run
-the try job that builds the Fuchsia integration:
+to test it out before submitting it to the bors queue,
+simply ask bors to run the try job that builds the Fuchsia integration:
 
 ```text
 @bors try jobs=test-x86_64-fuchsia
@@ -27,13 +26,13 @@ the try job that builds the Fuchsia integration:
 
 ## Building Fuchsia locally
 
-Because Fuchsia uses languages other than Rust, it does not use Cargo as a build
-system. It also requires the toolchain build to be configured in a [certain
-way][build-toolchain].
+Because Fuchsia uses languages other than Rust, it does not use Cargo as a build system.
+It also requires the toolchain build to be configured in a [certain way][build-toolchain].
 
 The recommended way to build Fuchsia is to use the Docker scripts that check out
-and run a Fuchsia build for you. If you've run Docker tests before, you can
-simply run this command from your Rust checkout to download and build Fuchsia
+and run a Fuchsia build for you.
+If you've run Docker tests before,
+you can simply run this command from your Rust checkout to download and build Fuchsia
 using your local Rust toolchain.
 
 ```
@@ -44,20 +43,21 @@ See the [Testing with Docker](../docker.md) chapter for more details on how to r
 and debug jobs with Docker.
 
 Note that a Fuchsia checkout is *large* – as of this writing, a checkout and
-build takes over 67G of space – and as you might imagine, it takes a while to
-complete.
+build takes over 67G of space – and as you might imagine, it takes a while to complete.
 
 ### Modifying the Fuchsia checkout
 
 The main reason you would want to build Fuchsia locally is because you need to
-investigate a regression. After running a Docker build, you'll find the Fuchsia
-checkout inside the `obj/test-x86_64-fuchsia/fuchsia` directory of your Rust
-checkout.  If you modify the `KEEP_CHECKOUT` line in the [build-fuchsia.sh]
-script to `KEEP_CHECKOUT=1`, you can change the checkout as needed and rerun
-the build command above. This will reuse all the build results from before.
+investigate a regression.
+After running a Docker build,
+you'll find the Fuchsia checkout inside the `obj/test-x86_64-fuchsia/fuchsia` directory of your Rust
+checkout.
+If you modify the `KEEP_CHECKOUT` line in the [build-fuchsia.sh] script to `KEEP_CHECKOUT=1`,
+you can change the checkout as needed and rerun
+the build command above.
+This will reuse all the build results from before.
 
-You can find more options to customize the Fuchsia checkout in the
-[build-fuchsia.sh] script.
+You can find more options to customize the Fuchsia checkout in the [build-fuchsia.sh] script.
 
 ### Customizing the Fuchsia build
 
@@ -73,14 +73,15 @@ to add this to your `$PATH` for some workflows.
 
 There are a few `fx` subcommands that are relevant, including:
 
-- `fx set` accepts build arguments, writes them to `out/default/args.gn`, and
-  runs GN.
-- `fx build` builds the Fuchsia project using Ninja. It will automatically pick
-  up changes to build arguments and rerun GN. By default it builds everything,
+- `fx set` accepts build arguments, writes them to `out/default/args.gn`, and runs GN.
+- `fx build` builds the Fuchsia project using Ninja.
+  It will automatically pick up changes to build arguments and rerun GN.
+  By default, it builds everything,
   but it also accepts target paths to build specific targets (see below).
-- `fx clippy` runs Clippy on specific Rust targets (or all of them). We use this
-  in the Rust CI build to avoid running codegen on most Rust targets. Underneath
-  it invokes Ninja, just like `fx build`. The clippy results are saved in json
+- `fx clippy` runs Clippy on specific Rust targets (or all of them).
+  We use this in the Rust CI build to avoid running codegen on most Rust targets.
+  Underneath, it invokes Ninja, just like `fx build`.
+  The clippy results are saved in json
   files inside the build output directory before being printed.
 
 #### Target paths
@@ -91,20 +92,20 @@ GN uses paths like the following to identify build targets:
 //src/starnix/kernel:starnix_core
 ```
 
-The initial `//` means the root of the checkout, and the remaining slashes are
-directory names. The string after `:` is the _target name_ of a target defined
+The initial `//` means the root of the checkout, and the remaining slashes are directory names.
+The string after `:` is the _target name_ of a target defined
 in the `BUILD.gn` file of that directory.
 
-The target name can be omitted if it is the same as the directory name. In other
-words, `//src/starnix/kernel` is the same as `//src/starnix/kernel:kernel`.
+The target name can be omitted if it is the same as the directory name.
+In other words, `//src/starnix/kernel` is the same as `//src/starnix/kernel:kernel`.
 
 These target paths are used inside `BUILD.gn` files to reference dependencies,
 and can also be used in `fx build`.
 
 #### Modifying compiler flags
 
-You can put custom compiler flags inside a GN `config` that is added to a
-target. As a simple example:
+You can put custom compiler flags inside a GN `config` that is added to a target.
+As a simple example:
 
 ```
 config("everybody_loops") {
@@ -118,20 +119,20 @@ rustc_binary("example") {
 }
 ```
 
-This will add the flag `-Zeverybody-loops` to rustc when building the `example`
-target. Note that you can also use [`public_configs`] for a config to be added
+This will add the flag `-Zeverybody-loops` to rustc when building the `example` target.
+Note that you can also use [`public_configs`] for a config to be added
 to every target that depends on that target.
 
-If you want to add a flag to every Rust target in the build, you can add
-rustflags to the [`//build/config:compiler`] config or to the OS-specific
-configs referenced in that file. Note that `cflags` and `ldflags` are ignored on
-Rust targets.
+If you want to add a flag to every Rust target in the build,
+you can add rustflags to the [`//build/config:compiler`] config or to the OS-specific
+configs referenced in that file.
+Note that `cflags` and `ldflags` are ignored on Rust targets.
 
 #### Running ninja and rustc commands directly
 
-Going down one layer, `fx build` invokes `ninja`, which in turn eventually
-invokes `rustc`. All build actions are run inside the out directory, which is
-usually `out/default` inside the Fuchsia checkout.
+Going down one layer, `fx build` invokes `ninja`, which in turn eventually invokes `rustc`.
+All build actions are run inside the out directory,
+which is usually `out/default` inside the Fuchsia checkout.
 
 You can get ninja to print the actual command it invokes by forcing that command
 to fail, e.g. by adding a syntax error to one of the source files of the target.
@@ -139,26 +140,25 @@ Once you have the command, you can run it from inside the output directory.
 
 After changing the toolchain itself, the build setting `rustc_version_string` in
 `out/default/args.gn` needs to be changed so that `fx build` or `ninja` will
-rebuild all the Rust targets. This can be done in a text editor and the contents
-of the string do not matter, as long as it changes from one build to the next.
-[build_fuchsia_from_rust_ci.sh] does this for you by hashing the toolchain
-directory.
+rebuild all the Rust targets.
+This can be done in a text editor, and the contents of the string do not matter,
+as long as it changes from one build to the next.
+[build_fuchsia_from_rust_ci.sh] does this for you by hashing the toolchain directory.
 
 The Fuchsia website has more detailed documentation of the [build system].
 
 #### Other tips and tricks
 
 When using `build_fuchsia_from_rust_ci.sh` you can comment out the `fx set`
-command after the initial run so it won't rerun GN each time. If you do this you
-can also comment out the version_string line to save a couple seconds.
+command after the initial run so it won't rerun GN each time.
+If you do this, you can also comment out the version_string line to save a couple seconds.
 
-`export NINJA_PERSISTENT_MODE=1` to get faster ninja startup times after the
-initial build.
+`export NINJA_PERSISTENT_MODE=1` to get faster ninja startup times after the initial build.
 
 ## Fuchsia target support
 
-To learn more about Fuchsia target support, see the Fuchsia chapter in [the
-rustc book][platform-support].
+To learn more about Fuchsia target support,
+see the Fuchsia chapter in [the rustc book][platform-support].
 
 [regressions]: https://gist.github.com/tmandry/7103eba4bd6a6fb0c439b5a90ae355fa
 [build-toolchain]: https://fuchsia.dev/fuchsia-src/development/build/rust_toolchain
@@ -173,5 +173,5 @@ rustc book][platform-support].
 [fuchsia-ping]: ../../notification-groups/fuchsia.md
 
 [^loc]: As of June 2024, Fuchsia had about 2 million lines of first-party Rust
-code and a roughly equal amount of third-party code, as counted by tokei
-(excluding comments and blanks).
+code and a roughly equal amount of third-party code,
+as counted by tokei (excluding comments and blanks).
diff --git a/src/doc/rustc-dev-guide/src/tests/ecosystem-test-jobs/rust-for-linux.md b/src/doc/rustc-dev-guide/src/tests/ecosystem-test-jobs/rust-for-linux.md
index a6a7374b811be..e2d3bec5d86f7 100644
--- a/src/doc/rustc-dev-guide/src/tests/ecosystem-test-jobs/rust-for-linux.md
+++ b/src/doc/rustc-dev-guide/src/tests/ecosystem-test-jobs/rust-for-linux.md
@@ -7,23 +7,22 @@ support for the Rust programming language into the Linux kernel.
 
 If a PR breaks the Rust for Linux CI job, then:
 
-- If the breakage was unintentional and seems spurious, then let [RfL][rfl-ping]
-  know and retry.
-    - If the PR is urgent and retrying doesn't fix it, then disable the CI job
-      temporarily (comment out the `image: x86_64-rust-for-linux` job in
+- If the breakage was unintentional and seems spurious, then let [RfL][rfl-ping] know and retry.
+    - If the PR is urgent and retrying doesn't fix it,
+      then disable the CI job temporarily (comment out the `image: x86_64-rust-for-linux` job in
       `src/ci/github-actions/jobs.yml`).
 - If the breakage was unintentional, then change the PR to resolve the breakage.
-- If the breakage was intentional, then let [RfL][rfl-ping] know and discuss
-  what will the kernel need to change.
+- If the breakage was intentional,
+  then let [RfL][rfl-ping] know and discuss what will the kernel need to change.
     - If the PR is urgent, then disable the CI job temporarily (comment out
       the `image: x86_64-rust-for-linux` job in `src/ci/github-actions/jobs.yml`).
     - If the PR can wait a few days, then wait for RfL maintainers to provide a
-      new Linux kernel commit hash with the needed changes done, and apply it to
-      the PR, which would confirm the changes work (update the  `LINUX_VERSION`
+      new Linux kernel commit hash with the needed changes done, and apply it to the PR,
+      which would confirm the changes work (update the  `LINUX_VERSION`
       environment variable in `src/ci/docker/scripts/rfl-build.sh`).
 
-If you need to contact the RfL developers, you can ping the [Rust for Linux][rfl-ping]
-ping group to ask for help:
+If you need to contact the RfL developers,
+you can ping the [Rust for Linux][rfl-ping] ping group to ask for help:
 
 ```text
 @rustbot ping rfl
@@ -31,17 +30,17 @@ ping group to ask for help:
 
 ## Building Rust for Linux in CI
 
-Rust for Linux builds as part of the suite of bors tests that run before a pull
-request is merged.
+Rust for Linux builds as part of the suite of bors tests that run before a pull request is merged.
 
-The workflow builds a stage1 sysroot of the Rust compiler, downloads the Linux
-kernel, and tries to compile several Rust for Linux drivers and examples using
-this sysroot. RfL uses several unstable compiler/language features, therefore
-this workflow notifies us if a given compiler change would break it.
+The workflow builds a stage1 sysroot of the Rust compiler, downloads the Linux kernel,
+and tries to compile several Rust for Linux drivers and examples using
+this sysroot.
+RfL uses several unstable compiler/language features,
+therefore this workflow notifies us if a given compiler change would break it.
 
 If you are worried that a pull request might break the Rust for Linux builder
-and want to test it out before submitting it to the bors queue, simply ask
-bors to run the try job that builds the Rust for Linux integration:
+and want to test it out before submitting it to the bors queue,
+simply ask bors to run the try job that builds the Rust for Linux integration:
 `@bors try jobs=x86_64-rust-for-linux`.
 
 [rfl-ping]: ../../notification-groups/rust-for-linux.md
diff --git a/src/doc/rustc-dev-guide/src/tests/ecosystem.md b/src/doc/rustc-dev-guide/src/tests/ecosystem.md
index 9e5b3a1e1c11d..ff9aca59ebe49 100644
--- a/src/doc/rustc-dev-guide/src/tests/ecosystem.md
+++ b/src/doc/rustc-dev-guide/src/tests/ecosystem.md
@@ -7,9 +7,10 @@ regressions and make informed decisions about the evolution of the language.
 
 ### Crater
 
-Crater is a tool which runs tests on many thousands of public projects. This
-tool has its own separate infrastructure for running, and is not run as part of
-CI. See the [Crater chapter](crater.md) for more details.
+Crater is a tool which runs tests on many thousands of public projects.
+This tool has its own separate infrastructure for running, and is not run as part of
+CI.
+See the [Crater chapter](crater.md) for more details.
 
 ### `cargotest`
 
@@ -23,8 +24,8 @@ there aren't any significant regressions:
 
 ### Large OSS Project builders
 
-We have CI jobs that build large open-source Rust projects that are used as
-regression tests in CI. Our integration jobs build the following projects:
+We have CI jobs that build large open-source Rust projects that are used as regression tests in CI.
+Our integration jobs build the following projects:
 
 - [Fuchsia](./ecosystem-test-jobs/fuchsia.md)
 - [Rust for Linux](./ecosystem-test-jobs/rust-for-linux.md)
diff --git a/src/doc/rustc-dev-guide/src/tests/intro.md b/src/doc/rustc-dev-guide/src/tests/intro.md
index 82fb9597cb500..162f8b836fadb 100644
--- a/src/doc/rustc-dev-guide/src/tests/intro.md
+++ b/src/doc/rustc-dev-guide/src/tests/intro.md
@@ -1,9 +1,9 @@
 # Testing the compiler
 
-The Rust project runs a wide variety of different tests, orchestrated by the
-build system (`./x test`). This section gives a brief overview of the different
-testing tools. Subsequent chapters dive into [running tests](running.md) and
-[adding new tests](adding.md).
+The Rust project runs a wide variety of different tests,
+orchestrated by the build system (`./x test`).
+This section gives a brief overview of the different testing tools.
+Subsequent chapters dive into [running tests](running.md) and [adding new tests](adding.md).
 
 ## Kinds of tests
 
@@ -12,11 +12,10 @@ Almost all of them are driven by `./x test`, with some exceptions noted below.
 
 ### Compiletest
 
-The main test harness for testing the compiler itself is a tool called
-[compiletest].
+The main test harness for testing the compiler itself is a tool called [compiletest].
 
-[compiletest] supports running different styles of tests, organized into *test
-suites*. A *test mode* may provide common presets/behavior for a set of *test
+[compiletest] supports running different styles of tests,
+organized into *test suites*. A *test mode* may provide common presets/behavior for a set of *test
 suites*. [compiletest]-supported tests are located in the [`tests`] directory.
 
 The [Compiletest chapter][compiletest] goes into detail on how to use this tool.
@@ -28,9 +27,9 @@ The [Compiletest chapter][compiletest] goes into detail on how to use this tool.
 
 ### Package tests
 
-The standard library and many of the compiler packages include typical Rust
-`#[test]` unit tests, integration tests, and documentation tests. You can pass a
-path to `./x test` for almost any package in the `library/` or `compiler/`
+The standard library and many of the compiler packages include typical Rust `#[test]` unit tests,
+integration tests, and documentation tests.
+You can pass a path to `./x test` for almost any package in the `library/` or `compiler/`
 directory, and `x` will essentially run `cargo test` on that package.
 
 Examples:
@@ -41,13 +40,14 @@ Examples:
 | `./x test library/core`                   | Runs tests on `core` only             |
 | `./x test compiler/rustc_data_structures` | Runs tests on `rustc_data_structures` |
 
-The standard library relies very heavily on documentation tests to cover its
-functionality. However, unit tests and integration tests can also be used as
-needed. Almost all of the compiler packages have doctests disabled.
+The standard library relies very heavily on documentation tests to cover its functionality.
+However, unit tests and integration tests can also be used as needed.
+Almost all of the compiler packages have doctests disabled.
 
 All standard library and compiler unit tests are placed in separate `tests` file
-(which is enforced in [tidy][tidy-unit-tests]). This ensures that when the test
-file is changed, the crate does not need to be recompiled. For example:
+(which is enforced in [tidy][tidy-unit-tests]).
+This ensures that when the test file is changed, the crate does not need to be recompiled.
+For example:
 
 ```rust,ignore
 #[cfg(test)]
@@ -55,11 +55,9 @@ mod tests;
 ```
 
 If it wasn't done this way, and you were working on something like `core`, that
-would require recompiling the entire standard library, and the entirety of
-`rustc`.
+would require recompiling the entire standard library, and the entirety of `rustc`.
 
-`./x test` includes some CLI options for controlling the behavior with these
-package tests:
+`./x test` includes some CLI options for controlling the behavior with these package tests:
 
 * `--doc` — Only runs documentation tests in the package.
 * `--all-targets` — Run all tests *except* documentation tests.
@@ -69,8 +67,9 @@ package tests:
 
 ### Tidy
 
-Tidy is a custom tool used for validating source code style and formatting
-conventions, such as rejecting long lines. There is more information in the
+Tidy is a custom tool used for validating source code style and formatting conventions,
+such as rejecting long lines.
+There is more information in the
 [section on coding conventions](../conventions.md#formatting) or the [Tidy Readme].
 
 > Examples: `./x test tidy`
@@ -80,9 +79,8 @@ conventions, such as rejecting long lines. There is more information in the
 
 ### Formatting
 
-Rustfmt is integrated with the build system to enforce uniform style across the
-compiler. The formatting check is automatically run by the Tidy tool mentioned
-above.
+Rustfmt is integrated with the build system to enforce uniform style across the compiler.
+The formatting check is automatically run by the Tidy tool mentioned above.
 
 Examples:
 
@@ -94,10 +92,10 @@ Examples:
 
 ### Book documentation tests
 
-All of the books that are published have their own tests, primarily for
-validating that the Rust code examples pass. Under the hood, these are
-essentially using `rustdoc --test` on the markdown files. The tests can be run
-by passing a path to a book to `./x test`.
+All of the books that are published have their own tests,
+primarily for validating that the Rust code examples pass.
+Under the hood, these are essentially using `rustdoc --test` on the markdown files.
+The tests can be run by passing a path to a book to `./x test`.
 
 > Example: `./x test src/doc/book`
 
@@ -114,8 +112,8 @@ This requires building all of the documentation, which might take a while.
 
 ### `distcheck`
 
-`distcheck` verifies that the source distribution tarball created by the build
-system will unpack, build, and run all tests.
+`distcheck` verifies that the source distribution tarball created by the build system will unpack,
+build, and run all tests.
 
 ```console
 ./x test distcheck
@@ -123,25 +121,24 @@ system will unpack, build, and run all tests.
 
 ### Tool tests
 
-Packages that are included with Rust have all of their tests run as well. This
-includes things such as cargo, clippy, rustfmt, miri, bootstrap (testing the
+Packages that are included with Rust have all of their tests run as well.
+This includes things such as cargo, clippy, rustfmt, miri, bootstrap (testing the
 Rust build system itself), etc.
 
-Most of the tools are located in the [`src/tools`] directory. To run the tool's
-tests, just pass its path to `./x test`.
+Most of the tools are located in the [`src/tools`] directory.
+To run the tool's tests, just pass its path to `./x test`.
 
 > Example: `./x test src/tools/cargo`
 
 Usually these tools involve running `cargo test` within the tool's directory.
 
-If you want to run only a specified set of tests, append `--test-args
-FILTER_NAME` to the command.
+If you want to run only a specified set of tests, append `--test-args FILTER_NAME` to the command.
 
 > Example: `./x test src/tools/miri --test-args padding`
 
-In CI, some tools are allowed to fail. Failures send notifications to the
-corresponding teams, and is tracked on the [toolstate website]. More information
-can be found in the [toolstate documentation].
+In CI, some tools are allowed to fail.
+Failures send notifications to the corresponding teams, and is tracked on the [toolstate website].
+More information can be found in the [toolstate documentation].
 
 [`src/tools`]: https://github.com/rust-lang/rust/tree/HEAD/src/tools/
 [toolstate documentation]: https://forge.rust-lang.org/infra/toolstate.html
@@ -150,14 +147,14 @@ can be found in the [toolstate documentation].
 ### Ecosystem testing
 
 Rust tests integration with real-world code to catch regressions and make
-informed decisions about the evolution of the language. There are several kinds
-of ecosystem tests, including Crater. See the [Ecosystem testing
-chapter](ecosystem.md) for more details.
+informed decisions about the evolution of the language.
+There are several kinds of ecosystem tests, including Crater.
+See the [Ecosystem testing chapter](ecosystem.md) for more details.
 
 ### Performance testing
 
-A separate infrastructure is used for testing and tracking performance of the
-compiler. See the [Performance testing chapter](perf.md) for more details.
+A separate infrastructure is used for testing and tracking performance of the compiler.
+See the [Performance testing chapter](perf.md) for more details.
 
 ### Codegen backend testing
 
diff --git a/src/doc/rustc-dev-guide/src/thir.md b/src/doc/rustc-dev-guide/src/thir.md
index 1ba30d86a6913..8b80d0be16874 100644
--- a/src/doc/rustc-dev-guide/src/thir.md
+++ b/src/doc/rustc-dev-guide/src/thir.md
@@ -136,7 +136,7 @@ Thir {
             kind: Scope {
                 region_scope: Node(5),
                 hir_id: HirId(DefId(0:3 ~ main[26fd]::main).5),
-                // reference to expression 0 above
+                // reference to expression 2 above
                 value: e2,
             },
             ty: i32,
diff --git a/src/etc/debugger_tester/lldb/batchmode.py b/src/etc/debugger_tester/lldb/batchmode.py
index fdf6a34c01716..ebc7b7ff91577 100644
--- a/src/etc/debugger_tester/lldb/batchmode.py
+++ b/src/etc/debugger_tester/lldb/batchmode.py
@@ -16,6 +16,7 @@
 import _thread as thread
 import os
 import re
+import signal
 import sys
 import threading
 import time
@@ -184,6 +185,27 @@ def dispatch_repr(var_name: str, breakpoint_index: int, frame: lldb.SBFrame) ->
     return check(var_name, breakpoint_index, frame) == Result.Ok
 
 
+def quit_with_error(debugger: lldb.SBDebugger):
+    """Kills the parent LLDB process with a non-0 exit code"""
+
+    # file handles aren't guaranteed to be flushed when python doesn't return control back to LLDB,
+    # so we need to do it manually
+    debugger.GetOutputFile().Flush()
+    debugger.GetErrorFile().Flush()
+    sys.stdout.flush()
+    sys.stderr.flush()
+
+    # When using a debugger created from the python script (e.g. `lldb.SBDebugger.Create()`), this
+    # doesn't actually work, but it doesn't hurt to try =)
+    debugger.HandleCommand("quit 1")
+
+    # Returning status codes using `sys.exit` doesn't work since we're in an LLDB managed python
+    # instance. Instead, we kill the PID, which happens to be the parent LLDB process.
+    # Note: We use SIGTERM because it works on linux and windows, unlike SIGKILL, and doesn't cause
+    # LLDB to spit out a backtrace like SIGABRT.
+    os.kill(os.getpid(), signal.SIGTERM)
+
+
 ####################################################################################################
 # ~main
 ####################################################################################################
@@ -203,12 +225,12 @@ def main():
     # Start the timeout watchdog
     start_watchdog()
 
-    # This is the debugger instance of the lldb executable that imported and ran this python script.
-    # There is some weird behavior around LLDB reassigning, clearing, or not updating their own
-    # references (like `lldb.debugger`) while a python function is actively running (i.e. if control
-    # is not given back to the REPL). To prevent LLDB from changing things out from under us, we
-    # store this reference locally.
-    debugger = lldb.debugger
+    # We use a new `SBDebugger` instance, since LLDB often doesn't update internal state/python
+    # state while a command is being run. Since the entirety of `batchmode` is executed via a
+    # `script` command, the parent LLDB never gets a chance to update.
+    # In LLDB <23 this was less of an issue, but a change in LLDB 23 made it difficult to create
+    # targets from the parent debugger instance.
+    debugger = lldb.SBDebugger.Create()
 
     # When we step or continue, don't return from the function until the process
     # stops. We do this by setting the async mode to false.
@@ -283,13 +305,10 @@ def main():
         print(f"Could not read debugging script '{script_path}'.")
         traceback.print_exception(type(e), e, e.__traceback__, file=sys.stdout)
         print("Aborting.")
-        # Returning status codes using `sys.exit` doesn't work since we're in an LLDB managed python
-        # instance. This command sets the exit code but *does not* kill LLDB, the debugee process,
-        # or the SBDebugger object.
-        debugger.HandleCommand("quit 1")
+        quit_with_error(debugger)
     except Exception as e:
         traceback.print_exception(type(e), e, e.__traceback__, file=sys.stdout)
-        debugger.HandleCommand("quit 1")
+        quit_with_error(debugger)
     else:  # Executes if the `try` block throws no exceptions.
         if repr_cmd_run:
             # We save importing these until we actually see a repr command. This prevents us
@@ -329,7 +348,7 @@ def main():
                 )
 
             if not tested_all_types() or not tested_all_variables():
-                debugger.HandleCommand("quit 1")
+                quit_with_error(debugger)
             elif BLESS:
                 from lldb_providers import FEATURE_FLAGS
 
diff --git a/src/etc/lldb_lookup.py b/src/etc/lldb_lookup.py
index 365816dc8489a..94ed47af1891f 100644
--- a/src/etc/lldb_lookup.py
+++ b/src/etc/lldb_lookup.py
@@ -40,6 +40,7 @@
     ClangEncodedEnumSummaryProvider,
     StructSummaryProvider,
     f16SummaryProvider,
+    f128SummaryProvider,
     # re-exports
     get_template_args as get_template_args,
     resolve_msvc_template_arg as resolve_msvc_template_arg,
@@ -181,6 +182,17 @@ def register_providers_compatibility():
             DEFAULT_TYPE_OPTIONS | lldb.eTypeOptionHideChildren,
         )
 
+        if LLDBFeature.Float128 in FEATURE_FLAGS:
+            # Force f128 summary on windows-msvc since most Windows debuggers don't support PDB f128
+            register_summary(
+                f128SummaryProvider,
+                lldb.SBTypeNameSpecifier(
+                    MOD_PREFIX + is_msvc_f128.__name__,
+                    lldb.eFormatterMatchCallback,
+                ),
+                DEFAULT_TYPE_OPTIONS | lldb.eTypeOptionHideChildren,
+            )
+
         # Tuple-structs
         register_synth(
             TupleSyntheticProvider,
@@ -501,6 +513,11 @@ def is_msvc_f16(type: lldb.SBType, _dict: LLDBOpaque) -> bool:
     return type.GetName() == "f16" and type.IsAggregateType()
 
 
+def is_msvc_f128(type: lldb.SBType, _dict: LLDBOpaque) -> bool:
+    # Most Windows debuggers don't support PDB f128.
+    return type.GetName() == "f128" and type.IsAggregateType()
+
+
 def classify_rust_type(type: lldb.SBType, is_msvc: bool) -> RustType:
     if type.IsPointerType():
         return RustType.Indirection
diff --git a/src/etc/lldb_providers.py b/src/etc/lldb_providers.py
index 2791dae3600b0..a3a424ac1abce 100644
--- a/src/etc/lldb_providers.py
+++ b/src/etc/lldb_providers.py
@@ -542,6 +542,12 @@ def f16SummaryProvider(valobj: SBValue, _dict: LLDBOpaque) -> str:
     )
 
 
+def f128SummaryProvider(valobj: SBValue, _dict: LLDBOpaque) -> str:
+    from lldb import eBasicTypeFloat128
+
+    return valobj.Cast(valobj.GetTarget().GetBasicType(eBasicTypeFloat128)).GetValue()
+
+
 def sequence_formatter(output: str, valobj: SBValue, _dict: LLDBOpaque):
     length: int = valobj.GetNumChildren()
 
diff --git a/src/etc/natvis/intrinsic.natvis b/src/etc/natvis/intrinsic.natvis
index 49e0ce319efac..ac9bf1c427957 100644
--- a/src/etc/natvis/intrinsic.natvis
+++ b/src/etc/natvis/intrinsic.natvis
@@ -59,6 +59,118 @@
     <!-- Normal -->
     <DisplayString>{(float) (sign() * (raw_significand() + 1.0) * two_pow_exponent())}</DisplayString>
   </Type>
+  <Type Name="f128">
+    <Intrinsic Name="sign_mask" Expression="(unsigned __int64) 0x8000000000000000" />
+    <Intrinsic Name="exponent_mask" Expression="(unsigned __int64) 0x7fff000000000000" />
+    <Intrinsic Name="high_significand_mask" Expression="(unsigned __int64) 0x0000ffffffffffff" />
+    <Intrinsic Name="sign_bit" Expression="(unsigned __int64) (high_bits &amp; sign_mask())" />
+    <Intrinsic Name="exponent_bits" Expression="(unsigned __int64) (high_bits &amp; exponent_mask())" />
+    <Intrinsic Name="high_significand_bits" Expression="(unsigned __int64) (high_bits &amp; high_significand_mask())" />
+    <Intrinsic Name="high_non_sign_bits" Expression="(unsigned __int64) (high_bits &amp; ~sign_mask())" />
+
+    <!-- Either "-" or an empty string for positive numbers -->
+    <Intrinsic Name="sign" Expression="sign_bit() == 0 ? &quot;&quot; : &quot;-&quot;" />
+    <Intrinsic Name="normal_exponent" Expression="(__int64) (((__int64) (exponent_bits() &gt;&gt; 48)) - 0x3fff)" />
+    <!-- "+" if the exponent is positive or zero, otherwise an empty string as converting a negative
+      exponent to a decimal string will already prepend a "-".  -->
+    <Intrinsic Name="normal_exponent_sign" Expression="normal_exponent() >= 0 ? &quot;+&quot; : &quot;&quot;" />
+
+    <!-- Converts a number between 0 and 15 (inclusive) to a single hexdecimal character -->
+    <Intrinsic Name="to_hex" Expression="v == 0x0 ? &quot;0&quot; : v == 0x1 ? &quot;1&quot; : v == 0x2 ? &quot;2&quot; : v == 0x3 ? &quot;3&quot; : v == 0x4 ? &quot;4&quot; : v == 0x5 ? &quot;5&quot; : v == 0x6 ? &quot;6&quot; : v == 0x7 ? &quot;7&quot; : v == 0x8 ? &quot;8&quot; : v == 0x9 ? &quot;9&quot; : v == 0xa ? &quot;a&quot; : v == 0xb ? &quot;b&quot; : v == 0xc ? &quot;c&quot; : v == 0xd ? &quot;d&quot; : v == 0xe ? &quot;e&quot; : v == 0xf ? &quot;f&quot; : &quot;ERROR&quot;">
+      <Parameter Name="v" Type="unsigned __int64" />
+    </Intrinsic>
+    <!-- hexN convert integers of size N to hexdecimal strings. `count` specifies how many bits should be displayed.
+      `count` is rounded up to the nearest hexdecimal digit, and is presumed to be non-zero -->
+    <Intrinsic Name="hex4" Expression="to_hex(value &amp; 0xf)">
+      <Parameter Name="value" Type="unsigned __int64" />
+    </Intrinsic>
+    <Intrinsic Name="hex8" Expression="count > 4 ? hex4(value >> 4) + hex4(value) : hex4(value)">
+      <Parameter Name="value" Type="unsigned __int64" />
+      <Parameter Name="count" Type="unsigned __int64" />
+    </Intrinsic>
+    <Intrinsic Name="hex16" Expression="count > 8 ? hex8(value >> 8, count - 8) + hex8(value, 8) : hex8(value, count)">
+      <Parameter Name="value" Type="unsigned __int64" />
+      <Parameter Name="count" Type="unsigned __int64" />
+    </Intrinsic>
+    <Intrinsic Name="hex32" Expression="count > 16 ? hex16(value >> 16, count - 16) + hex16(value, 16) : hex16(value, count)">
+      <Parameter Name="value" Type="unsigned __int64" />
+      <Parameter Name="count" Type="unsigned __int64" />
+    </Intrinsic>
+    <Intrinsic Name="hex64" Expression="count > 32 ? hex32(value >> 32, count - 32) + hex32(value, 32) : hex32(value, count)">
+      <Parameter Name="value" Type="unsigned __int64" />
+      <Parameter Name="count" Type="unsigned __int64" />
+    </Intrinsic>
+    <Intrinsic Name="hex128" Expression="count > 64 ? hex64(value_high, count - 64) + hex64(value_low, 64) : hex64(value_low, count)">
+      <Parameter Name="value_high" Type="unsigned __int64" />
+      <Parameter Name="value_low" Type="unsigned __int64" />
+      <Parameter Name="count" Type="unsigned __int64" />
+    </Intrinsic>
+
+    <!-- trailingN does the equivalent of `iN::trailing_zeros` in Rust. -->
+    <!-- We only need to count in whole hex digits (4 bits) -->
+    <Intrinsic Name="trailing4" Expression="(unsigned __int64) ((value &amp; 0xf) == 0 ? 4 : 0)">
+      <Parameter Name="value" Type="unsigned __int64" />
+    </Intrinsic>
+    <Intrinsic Name="trailing8" Expression="(unsigned __int64) ((value &amp; 0xf) == 0 ? 4 + trailing4(value &gt;&gt; 4) : trailing4(value))">
+      <Parameter Name="value" Type="unsigned __int64" />
+    </Intrinsic>
+    <Intrinsic Name="trailing16" Expression="(unsigned __int64) ((value &amp; 0xff) == 0 ? 8 + trailing8(value &gt;&gt; 8) : trailing8(value))">
+      <Parameter Name="value" Type="unsigned __int64" />
+    </Intrinsic>
+    <Intrinsic Name="trailing32" Expression="(unsigned __int64) ((value &amp; 0xffff) == 0 ? 16 + trailing16(value &gt;&gt; 16) : trailing16(value))">
+      <Parameter Name="value" Type="unsigned __int64" />
+    </Intrinsic>
+    <Intrinsic Name="trailing64" Expression="(unsigned __int64) ((value &amp; 0xffffffff) == 0 ? 32 + trailing32(value &gt;&gt; 32) : trailing32(value))">
+      <Parameter Name="value" Type="unsigned __int64" />
+    </Intrinsic>
+    <Intrinsic Name="trailing128" Expression="(unsigned __int64) (value_low == 0 ? 64 + trailing64(value_high) : trailing64(value_low))">
+      <Parameter Name="value_high" Type="unsigned __int64" />
+      <Parameter Name="value_low" Type="unsigned __int64" />
+    </Intrinsic>
+
+    <!-- Equivalent to `u128::funnel_shr` -->
+    <Intrinsic Name="funnel_shift_right" Expression="(unsigned __int64) (shift == 0 ? low : ((low &gt;&gt; shift) | (high &lt;&lt; (64 - shift))))">
+      <Parameter Name="high" Type="unsigned __int64" />
+      <Parameter Name="low" Type="unsigned __int64" />
+      <Parameter Name="shift" Type="unsigned __int64" />
+    </Intrinsic>
+    <!-- Equivalent to `u128::funnel_shl` -->
+    <Intrinsic Name="funnel_shift_left" Expression="(unsigned __int64) (shift == 0 ? high : ((high &lt;&lt; shift) | (low &gt;&gt; (64 - shift))))">
+      <Parameter Name="high" Type="unsigned __int64" />
+      <Parameter Name="low" Type="unsigned __int64" />
+      <Parameter Name="shift" Type="unsigned __int64" />
+    </Intrinsic>
+
+    <Intrinsic Name="bits_to_hex_inner" Expression="trailing >= 64 ? hex64(high &gt;&gt; (trailing - 64), 48 - (trailing - 64)) : hex128(high &gt;&gt; trailing, funnel_shift_right(high, low, trailing), 112 - trailing)">
+      <Parameter Name="high" Type="unsigned __int64" />
+      <Parameter Name="low" Type="unsigned __int64" />
+      <Parameter Name="trailing" Type="unsigned __int64" />
+    </Intrinsic>
+    <!-- Converts the low 48 bits of `high` and all 64 bits of `low` to a hexdecimal string, without
+      any trailing zeros. The result will start with a "." unless it is empty. -->
+    <!-- Trailing is precomputed here as an argument to `bits_to_hex_inner` avoid needing to
+      calculate it multiple times. -->
+    <Intrinsic Name="bits_to_hex" Expression="(high &amp; high_significand_mask()) == 0 &amp;&amp; low == 0 ? &quot;&quot; : &quot;.&quot; + bits_to_hex_inner(high, low, trailing128(high, low))">
+      <Parameter Name="high" Type="unsigned __int64" />
+      <Parameter Name="low" Type="unsigned __int64" />
+    </Intrinsic>
+
+    <Intrinsic Name="normal_hex" Expression="bits_to_hex(high_significand_bits(), low_bits)" />
+    <Intrinsic Name="subnormal_shift" Expression="(__int64) (high_significand_bits() == 0 ? 48 + (64 - __log2(low_bits)) : (48 - __log2(high_significand_bits())))" />
+    <Intrinsic Name="subnormal_hex" Expression="subnormal_shift() >= 64 ? bits_to_hex(low_bits &lt;&lt; (subnormal_shift() - 64), 0) : bits_to_hex(funnel_shift_left(high_significand_bits(), low_bits, subnormal_shift()), low_bits &lt;&lt; subnormal_shift())" />
+
+    <DisplayString Condition="high_non_sign_bits() == exponent_mask() &amp;&amp; low_bits == 0">{sign()}inf</DisplayString>
+    <DisplayString Condition="exponent_bits() == exponent_mask()">NaN</DisplayString>
+    <!-- Handle zeros separately so they use the conventional exponent "+0". -->
+    <DisplayString Condition="high_non_sign_bits() == 0 &amp;&amp; low_bits == 0">{sign()}0x0p+0</DisplayString>
+    <!-- Subnormals are shifted so that the integer portion is "1", with the exponent adjusted. -->
+    <DisplayString Condition="exponent_bits() == 0">{sign()}0x1{subnormal_hex()}p{-16382 - subnormal_shift(),d}</DisplayString>
+    <DisplayString>{sign()}0x1{normal_hex()}p{normal_exponent_sign()}{normal_exponent(),d}</DisplayString>
+    <Expand>
+      <!-- Display the bits as a single number instead of the two `u64` halves. -->
+      <Item Name="bits">"0x" + hex128(high_bits, low_bits, 128)</Item>
+    </Expand>
+  </Type>
   <Type Name="tuple$&lt;&gt;">
     <DisplayString>()</DisplayString>
   </Type>
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index 744c7eb288dfa..1b5968e20e4b4 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -576,7 +576,7 @@ impl Item {
     }
 
     pub(crate) fn links(&self, cx: &Context<'_>) -> Vec<RenderedLink> {
-        use crate::html::format::{href, link_tooltip};
+        use crate::html::format::{href_with_path_check, link_tooltip};
 
         let Some(links) = cx.cache().intra_doc_links.get(&self.item_or_reexport_id()) else {
             return vec![];
@@ -585,7 +585,7 @@ impl Item {
             .iter()
             .filter_map(|ItemLink { link: s, link_text, page_id: id, fragment }| {
                 debug!(?id);
-                if let Ok(HrefInfo { mut url, .. }) = href(*id, cx) {
+                if let Ok(HrefInfo { mut url, .. }) = href_with_path_check(*id, cx, link_text) {
                     debug!(?url);
                     match fragment {
                         Some(UrlFragment::Item(def_id)) => {
@@ -601,7 +601,7 @@ impl Item {
                     Some(RenderedLink {
                         original_text: s.clone(),
                         new_text: link_text.clone(),
-                        tooltip: link_tooltip(*id, fragment, cx).to_string(),
+                        tooltip: link_tooltip(*id, fragment, cx, Some(link_text)).to_string(),
                         href: url,
                     })
                 } else {
diff --git a/src/librustdoc/formats/cache.rs b/src/librustdoc/formats/cache.rs
index ccee062584e01..c89c3dbd3fbf5 100644
--- a/src/librustdoc/formats/cache.rs
+++ b/src/librustdoc/formats/cache.rs
@@ -18,6 +18,45 @@ use crate::formats::item_type::ItemType;
 use crate::html::render::{IndexItem, IndexItemInfo};
 use crate::visit_lib::RustdocEffectiveVisibilities;
 
+pub(crate) struct PathInfo {
+    /// Parts of the fully qualified path. So in `foo::bar::bib`, it will
+    /// be `["foo", "bar", "bib"]`.
+    pub(crate) parts: Vec<Symbol>,
+    pub(crate) ty: ItemType,
+    /// When a reexport inline an item, we can end up with the same `DefId` with multiple local
+    /// targets. So in case like:
+    ///
+    /// ```
+    /// /// Link to [`a2`].
+    /// pub use std::ffi::os_str::OsString as a1;
+    /// /// Link to [`a1`].
+    /// pub use std::ffi::os_str::OsString as a2;
+    /// /// Link to [`a2`].
+    /// pub use std::ffi::os_str::OsString as a3;
+    /// ```
+    ///
+    /// To ensure that `a1` and `a2` links to `a1` and `a2` which have the same `DefId`, we need
+    /// to store both `a1` and `a2` paths.
+    ///
+    /// The path stored in `parts` is not present in `alternatives`.
+    pub(crate) alternatives: Vec<Vec<Symbol>>,
+}
+
+impl PathInfo {
+    pub(crate) fn get_preferred_path(&self, preferred_name: Option<&str>) -> &[Symbol] {
+        if let Some(preferred_name) = preferred_name
+            && let Some(alternative_path) = self
+                .alternatives
+                .iter()
+                .find(|path| path.last().is_some_and(|last| last.as_str() == preferred_name))
+        {
+            alternative_path
+        } else {
+            &self.parts
+        }
+    }
+}
+
 /// This cache is used to store information about the [`clean::Crate`] being
 /// rendered in order to provide more useful documentation. This contains
 /// information like all implementors of a trait, all traits a type implements,
@@ -42,7 +81,7 @@ pub(crate) struct Cache {
     /// URLs when a type is being linked to. External paths are not located in
     /// this map because the `External` type itself has all the information
     /// necessary.
-    pub(crate) paths: FxIndexMap<DefId, (Vec<Symbol>, ItemType)>,
+    pub(crate) paths: FxIndexMap<DefId, PathInfo>,
 
     /// Similar to `paths`, but only holds external paths. This is only used for
     /// generating explicit hyperlinks to other crates.
@@ -358,7 +397,8 @@ impl DocFolder for CacheBuilder<'_, '_> {
             | clean::ForeignTypeItem
             | clean::MacroItem(..)
             | clean::ProcMacroItem(..)
-            | clean::VariantItem(..) => {
+            | clean::VariantItem(..)
+            | clean::PrimitiveItem(..) => {
                 use rustc_data_structures::fx::IndexEntry as Entry;
 
                 let skip_because_unstable = matches!(
@@ -376,21 +416,31 @@ impl DocFolder for CacheBuilder<'_, '_> {
                     let item_def_id = item.item_id.expect_def_id();
                     match self.cache.paths.entry(item_def_id) {
                         Entry::Vacant(entry) => {
-                            entry.insert((self.cache.stack.clone(), item.type_()));
+                            entry.insert(PathInfo {
+                                parts: self.cache.stack.clone(),
+                                ty: item.type_(),
+                                alternatives: Vec::new(),
+                            });
                         }
                         Entry::Occupied(mut entry) => {
-                            if entry.get().0.len() > self.cache.stack.len() {
-                                entry.insert((self.cache.stack.clone(), item.type_()));
+                            // Shorter paths are preferred by default.
+                            if entry.get().parts.len() > self.cache.stack.len() {
+                                let old_parts = std::mem::replace(
+                                    &mut entry.get_mut().parts,
+                                    self.cache.stack.clone(),
+                                );
+                                // We only keep the old path if it's a different (final) name.
+                                if old_parts.last() != self.cache.stack.last() {
+                                    entry.get_mut().alternatives.push(old_parts);
+                                }
+                            }
+                            if !entry.get().alternatives.contains(&self.cache.stack) {
+                                entry.get_mut().alternatives.push(self.cache.stack.clone());
                             }
                         }
                     }
                 }
             }
-            clean::PrimitiveItem(..) => {
-                self.cache
-                    .paths
-                    .insert(item.item_id.expect_def_id(), (self.cache.stack.clone(), item.type_()));
-            }
 
             clean::ExternCrateItem { .. }
             | clean::ImportItem(..)
@@ -570,7 +620,7 @@ fn add_item_to_search_index(tcx: TyCtxt<'_>, cache: &mut Cache, item: &clean::It
             // in a field of the cache whose elements are added to the search index later,
             // after cache building is complete (see `handle_orphan_impl_child`).
             match cache.paths.get(&parent_did) {
-                Some((fqp, _)) => (Some(parent_did), &fqp[..fqp.len() - 1]),
+                Some(info) => (Some(parent_did), &info.parts[..info.parts.len() - 1]),
                 None => {
                     handle_orphan_impl_child(cache, item, parent_did);
                     return;
diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
index 54ff94ed1d614..0ca2782ed2151 100644
--- a/src/librustdoc/html/format.rs
+++ b/src/librustdoc/html/format.rs
@@ -543,6 +543,7 @@ pub(crate) fn href_with_root_path(
     original_did: DefId,
     cx: &Context<'_>,
     root_path: Option<&str>,
+    preferred_name: Option<&str>,
 ) -> Result<HrefInfo, HrefError> {
     let tcx = cx.tcx();
     let def_kind = tcx.def_kind(original_did);
@@ -553,7 +554,9 @@ pub(crate) fn href_with_root_path(
         }
         // If this a constructor, we get the parent (either a struct or a variant) and then
         // generate the link for this item.
-        DefKind::Ctor(..) => return href_with_root_path(tcx.parent(original_did), cx, root_path),
+        DefKind::Ctor(..) => {
+            return href_with_root_path(tcx.parent(original_did), cx, root_path, preferred_name);
+        }
         DefKind::ExternCrate => {
             // Link to the crate itself, not the `extern crate` item.
             if let Some(local_did) = original_did.as_local() {
@@ -564,7 +567,7 @@ pub(crate) fn href_with_root_path(
         }
         _ => original_did,
     };
-    if is_unnamable(cx.tcx(), did) {
+    if is_unnamable(tcx, did) {
         return Err(HrefError::UnnamableItem);
     }
     let cache = cx.cache();
@@ -586,12 +589,12 @@ pub(crate) fn href_with_root_path(
     }
 
     let (fqp, shortty, url_parts, is_absolute) = match cache.paths.get(&did) {
-        Some(&(ref fqp, shortty)) => (
-            fqp,
-            shortty,
+        Some(info) => (
+            info.get_preferred_path(preferred_name),
+            info.ty,
             {
-                let module_fqp = to_module_fqp(shortty, fqp.as_slice());
-                debug!(?fqp, ?shortty, ?module_fqp);
+                let module_fqp = to_module_fqp(info.ty, info.parts.as_slice());
+                debug!(?info.parts, ?info.ty, ?module_fqp);
                 href_relative_parts(module_fqp, relative_to)
             },
             false,
@@ -604,7 +607,7 @@ pub(crate) fn href_with_root_path(
             if let Some(&(ref fqp, shortty)) = cache.external_paths.get(&def_id_to_get) {
                 let module_fqp = to_module_fqp(shortty, fqp);
                 let (parts, is_absolute) = url_parts(cache, did, module_fqp, relative_to)?;
-                (fqp, shortty, parts, is_absolute)
+                (fqp.as_slice(), shortty, parts, is_absolute)
             } else if matches!(def_kind, DefKind::Macro(_)) {
                 return generate_macro_def_id_path(did, cx, root_path);
             } else if did.is_local() {
@@ -617,12 +620,20 @@ pub(crate) fn href_with_root_path(
     Ok(HrefInfo {
         url: make_href(root_path, shortty, url_parts, fqp, is_absolute),
         kind: shortty,
-        rust_path: fqp.clone(),
+        rust_path: fqp.to_vec(),
     })
 }
 
 pub(crate) fn href(did: DefId, cx: &Context<'_>) -> Result<HrefInfo, HrefError> {
-    href_with_root_path(did, cx, None)
+    href_with_root_path(did, cx, None, None)
+}
+
+pub(crate) fn href_with_path_check(
+    did: DefId,
+    cx: &Context<'_>,
+    text: &str,
+) -> Result<HrefInfo, HrefError> {
+    href_with_root_path(did, cx, None, Some(text))
 }
 
 /// Both paths should only be modules.
@@ -660,14 +671,21 @@ pub(crate) fn link_tooltip(
     did: DefId,
     fragment: &Option<UrlFragment>,
     cx: &Context<'_>,
+    preferred_name: Option<&str>,
 ) -> impl fmt::Display {
     fmt::from_fn(move |f| {
         let cache = cx.cache();
-        let Some((fqp, shortty)) = cache.paths.get(&did).or_else(|| cache.external_paths.get(&did))
+        let Some((fqp, shortty)) = cache
+            .paths
+            .get(&did)
+            .map(|info| (info.get_preferred_path(preferred_name), info.ty))
+            .or_else(|| {
+                cache.external_paths.get(&did).map(|(fqp, shortty)| (fqp.as_slice(), *shortty))
+            })
         else {
             return Ok(());
         };
-        let fqp = if *shortty == ItemType::Primitive {
+        let fqp = if shortty == ItemType::Primitive {
             // primitives are documented in a crate, but not actually part of it
             slice::from_ref(fqp.last().unwrap())
         } else {
@@ -679,7 +697,7 @@ pub(crate) fn link_tooltip(
             for component in fqp {
                 write!(f, "{component}::")?;
             }
-            if *shortty == ItemType::Enum && tcx.def_kind(id) == DefKind::Field {
+            if shortty == ItemType::Enum && tcx.def_kind(id) == DefKind::Field {
                 write!(f, "{}::", tcx.item_name(tcx.parent(id)))?;
             }
             write!(f, "{}", tcx.item_name(id))?;
diff --git a/src/librustdoc/html/highlight.rs b/src/librustdoc/html/highlight.rs
index 89d50680c3a3b..9c73e3b4ad687 100644
--- a/src/librustdoc/html/highlight.rs
+++ b/src/librustdoc/html/highlight.rs
@@ -1406,23 +1406,30 @@ fn generate_link_to_def(
                     LinkFromSrc::Local(span) => {
                         context.href_from_span_relative(*span, &href_context.current_href)
                     }
-                    LinkFromSrc::External(def_id) => {
-                        format::href_with_root_path(*def_id, context, Some(href_context.root_path))
-                            .ok()
-                            .map(|HrefInfo { url, .. }| url)
-                    }
+                    LinkFromSrc::External(def_id) => format::href_with_root_path(
+                        *def_id,
+                        context,
+                        Some(href_context.root_path),
+                        None,
+                    )
+                    .ok()
+                    .map(|HrefInfo { url, .. }| url),
                     LinkFromSrc::Primitive(prim) => format::href_with_root_path(
                         PrimitiveType::primitive_locations(context.tcx())[prim],
                         context,
                         Some(href_context.root_path),
+                        None,
+                    )
+                    .ok()
+                    .map(|HrefInfo { url, .. }| url),
+                    LinkFromSrc::Doc(def_id) => format::href_with_root_path(
+                        *def_id,
+                        context,
+                        Some(href_context.root_path),
+                        None,
                     )
                     .ok()
                     .map(|HrefInfo { url, .. }| url),
-                    LinkFromSrc::Doc(def_id) => {
-                        format::href_with_root_path(*def_id, context, Some(href_context.root_path))
-                            .ok()
-                            .map(|HrefInfo { url, .. }| url)
-                    }
                 }
             })
     {
diff --git a/src/librustdoc/html/render/context.rs b/src/librustdoc/html/render/context.rs
index 56dd665177a93..d00b705d3766c 100644
--- a/src/librustdoc/html/render/context.rs
+++ b/src/librustdoc/html/render/context.rs
@@ -296,19 +296,19 @@ impl<'tcx> Context<'tcx> {
                 &self.shared.style_files,
             )
         } else {
-            if let Some(&(ref names, ty)) = self.cache().paths.get(&it.item_id.expect_def_id())
-                && (self.current.len() + 1 != names.len()
-                    || self.current.iter().zip(names.iter()).any(|(a, b)| a != b))
+            if let Some(info) = self.cache().paths.get(&it.item_id.expect_def_id())
+                && (self.current.len() + 1 != info.parts.len()
+                    || self.current.iter().zip(info.parts.iter()).any(|(a, b)| a != b))
             {
                 // We checked that the redirection isn't pointing to the current file,
                 // preventing an infinite redirection loop in the generated
                 // documentation.
 
                 let path = fmt::from_fn(|f| {
-                    for name in &names[..names.len() - 1] {
+                    for name in &info.parts[..info.parts.len() - 1] {
                         write!(f, "{name}/")?;
                     }
-                    write!(f, "{}", print_ty_path(ty, names.last().unwrap().as_str()))
+                    write!(f, "{}", print_ty_path(info.ty, info.parts.last().unwrap().as_str()))
                 });
                 match self.shared.redirections {
                     Some(ref redirections) => {
@@ -320,7 +320,7 @@ impl<'tcx> Context<'tcx> {
                         let _ = write!(
                             current_path,
                             "{}",
-                            print_ty_path(ty, names.last().unwrap().as_str())
+                            print_ty_path(info.ty, info.parts.last().unwrap().as_str())
                         );
                         redirections.borrow_mut().insert(current_path, path.to_string());
                     }
diff --git a/src/librustdoc/html/render/print_item.rs b/src/librustdoc/html/render/print_item.rs
index 6f66dcf9eae83..46dba0253766a 100644
--- a/src/librustdoc/html/render/print_item.rs
+++ b/src/librustdoc/html/render/print_item.rs
@@ -1455,12 +1455,12 @@ fn item_type_alias(cx: &Context<'_>, it: &clean::Item, t: &clean::TypeAlias) ->
         // [^115718]: https://github.com/rust-lang/rust/issues/115718
         let cache = &cx.shared.cache;
         if let Some(target_did) = t.type_.def_id(cache)
-            && let get_extern = { || cache.external_paths.get(&target_did) }
-            && let Some(&(ref target_fqp, target_type)) =
-                cache.paths.get(&target_did).or_else(get_extern)
+            && let get_extern = { || cache.external_paths.get(&target_did).map(|(fqp, shortty)| (fqp, *shortty)) }
+            && let Some((target_fqp, target_type)) =
+                cache.paths.get(&target_did).map(|info| (&info.parts, info.ty)).or_else(get_extern)
             && target_type.is_adt() // primitives cannot be inlined
             && let Some(self_did) = it.item_id.as_def_id()
-            && let get_local = { || cache.paths.get(&self_did).map(|(p, _)| p) }
+            && let get_local = { || cache.paths.get(&self_did).map(|info| &info.parts) }
             && let Some(self_fqp) = cache.exact_paths.get(&self_did).or_else(get_local)
         {
             let mut js_src_path: UrlPartsBuilder =
diff --git a/src/librustdoc/html/render/search_index.rs b/src/librustdoc/html/render/search_index.rs
index 4c93e632ab467..b459ead9481cb 100644
--- a/src/librustdoc/html/render/search_index.rs
+++ b/src/librustdoc/html/render/search_index.rs
@@ -1279,7 +1279,7 @@ pub(crate) fn build_index(
     for &OrphanImplItem { impl_id, parent, trait_parent, ref item, ref impl_generics } in
         &cache.orphan_impl_items
     {
-        if let Some((fqp, _)) = cache.paths.get(&parent) {
+        if let Some(path_info) = cache.paths.get(&parent) {
             let info = IndexItemInfo::new(
                 tcx,
                 cache,
@@ -1291,7 +1291,7 @@ pub(crate) fn build_index(
             search_index.push(IndexItem {
                 defid: item.item_id.as_def_id(),
                 name: item.name.unwrap(),
-                module_path: fqp[..fqp.len() - 1].to_vec(),
+                module_path: path_info.parts[..path_info.parts.len() - 1].to_vec(),
                 parent: Some(parent),
                 parent_idx: None,
                 trait_parent,
@@ -1418,8 +1418,15 @@ pub(crate) fn build_index(
                 cache
                     .paths
                     .get(&defid)
-                    .or_else(|| check_external.then(|| cache.external_paths.get(&defid)).flatten())
-                    .map(|&(ref fqp, ty)| {
+                    .map(|info| (&info.parts, info.ty))
+                    .or_else(|| {
+                        check_external
+                            .then(|| {
+                                cache.external_paths.get(&defid).map(|(parts, ty)| (parts, *ty))
+                            })
+                            .flatten()
+                    })
+                    .map(|(fqp, ty)| {
                         let pathid = serialized_index.names.len();
                         match serialized_index.crate_paths_index.entry((ty, fqp.clone())) {
                             Entry::Occupied(entry) => *entry.get(),
@@ -1661,8 +1668,10 @@ pub(crate) fn build_index(
                     used_in_function_signature,
                 )),
                 RenderTypeId::DefId(defid) => {
-                    if let Some(&(ref fqp, item_type)) =
-                        paths.get(&defid).or_else(|| external_paths.get(&defid))
+                    if let Some((fqp, item_type)) = paths
+                        .get(&defid)
+                        .map(|info| (&info.parts, info.ty))
+                        .or_else(|| external_paths.get(&defid).map(|(parts, ty)| (parts, *ty)))
                     {
                         if tcx.lang_items().fn_mut_trait() == Some(defid)
                             || tcx.lang_items().fn_once_trait() == Some(defid)
@@ -1974,8 +1983,11 @@ pub(crate) fn get_function_type_for_search(
     let impl_or_trait_generics = impl_generics.or_else(|| {
         if let Some(def_id) = parent
             && let Some(trait_) = cache.traits.get(&def_id)
-            && let Some((path, _)) =
-                cache.paths.get(&def_id).or_else(|| cache.external_paths.get(&def_id))
+            && let Some((path, _)) = cache
+                .paths
+                .get(&def_id)
+                .map(|info| (&info.parts, info.ty))
+                .or_else(|| cache.external_paths.get(&def_id).map(|(parts, ty)| (parts, *ty)))
         {
             let path = clean::Path {
                 res: rustc_hir::def::Res::Def(rustc_hir::def::DefKind::Trait, def_id),
diff --git a/src/librustdoc/html/render/write_shared.rs b/src/librustdoc/html/render/write_shared.rs
index 5c963afd3a221..258970bbb3b8f 100644
--- a/src/librustdoc/html/render/write_shared.rs
+++ b/src/librustdoc/html/render/write_shared.rs
@@ -834,12 +834,17 @@ impl TraitAliasPart {
             // FIXME: this is a vague explanation for why this can't be a `get`, in
             //        theory it should be...
             let (remote_path, remote_item_type) = match cache.exact_paths.get(&did) {
-                Some(p) => match cache.paths.get(&did).or_else(|| cache.external_paths.get(&did)) {
+                Some(p) => match cache
+                    .paths
+                    .get(&did)
+                    .map(|info| (&info.parts, info.ty))
+                    .or_else(|| cache.external_paths.get(&did).map(|(parts, ty)| (parts, *ty)))
+                {
                     Some((_, t)) => (p, t),
                     None => continue,
                 },
                 None => match cache.external_paths.get(&did) {
-                    Some((p, t)) => (p, t),
+                    Some((p, t)) => (p, *t),
                     None => continue,
                 },
             };
@@ -987,8 +992,10 @@ impl<'item> DocVisitor<'item> for TypeImplCollector<'_, '_, 'item> {
             return;
         }
         let Some(target_did) = t.type_.def_id(cache) else { return };
-        let get_extern = { || cache.external_paths.get(&target_did) };
-        let Some(&(ref target_fqp, target_type)) = cache.paths.get(&target_did).or_else(get_extern)
+        let get_extern =
+            { || cache.external_paths.get(&target_did).map(|(parts, ty)| (parts, *ty)) };
+        let Some((target_fqp, target_type)) =
+            cache.paths.get(&target_did).map(|info| (&info.parts, info.ty)).or_else(get_extern)
         else {
             return;
         };
@@ -1004,7 +1011,7 @@ impl<'item> DocVisitor<'item> for TypeImplCollector<'_, '_, 'item> {
                 .collect();
             AliasedType { target_fqp: &target_fqp[..], target_type, impl_ }
         });
-        let get_local = { || cache.paths.get(&self_did).map(|(p, _)| p) };
+        let get_local = { || cache.paths.get(&self_did).map(|info| &info.parts) };
         let Some(self_fqp) = cache.exact_paths.get(&self_did).or_else(get_local) else {
             return;
         };
diff --git a/src/librustdoc/json/mod.rs b/src/librustdoc/json/mod.rs
index f161b31f94dcb..bdd2b7d416d80 100644
--- a/src/librustdoc/json/mod.rs
+++ b/src/librustdoc/json/mod.rs
@@ -113,8 +113,9 @@ impl<'tcx> JsonRenderer<'tcx> {
             .cache
             .paths
             .iter()
-            .chain(&self.cache.external_paths)
-            .map(|(&k, &(ref path, kind))| {
+            .map(|(k, info)| (k, (&info.parts, info.ty)))
+            .chain(self.cache.external_paths.iter().map(|(k, (parts, ty))| (k, (parts, *ty))))
+            .map(|(&k, (path, kind))| {
                 (
                     self.id_from_item_default(k.into()),
                     types::ItemSummary {
@@ -195,8 +196,9 @@ impl<'tcx> JsonRenderer<'tcx> {
         self.cache
             .paths
             .get(&item_id)
-            .or_else(|| self.cache.external_paths.get(&item_id))
-            .map(|(path, _)| path.iter().map(|name| name.to_string()).collect())
+            .map(|info| &info.parts)
+            .or_else(|| self.cache.external_paths.get(&item_id).map(|(parts, _)| parts))
+            .map(|path| path.iter().map(|name| name.to_string()).collect())
     }
 }
 
diff --git a/src/tools/miri/tests/panic/mir-validation.stderr b/src/tools/miri/tests/panic/mir-validation.stderr
index 115820510dd89..1d40c93d709e6 100644
--- a/src/tools/miri/tests/panic/mir-validation.stderr
+++ b/src/tools/miri/tests/panic/mir-validation.stderr
@@ -7,12 +7,9 @@ LL |             *(tuple.0) = 1;
 
 
 thread 'rustc' ($TID) panicked at compiler/rustc_mir_transform/src/validate.rs:LL:CC:
-broken MIR in Item(DefId) (after phase change to runtime-optimized) at bb0[1]:
-place (*(_2.0: *mut i32)) has deref as a later projection (it is only permitted as the first projection)
+Box<dyn Any>
 stack backtrace:
 
-error: the compiler unexpectedly panicked. This is a bug
-
 
 
 
diff --git a/tests/assembly-llvm/asm/amdgpu-vec-types.rs b/tests/assembly-llvm/asm/amdgpu-vec-types.rs
index 1613e603fca49..8ff4208636bc6 100644
--- a/tests/assembly-llvm/asm/amdgpu-vec-types.rs
+++ b/tests/assembly-llvm/asm/amdgpu-vec-types.rs
@@ -14,11 +14,12 @@
 #![allow(
     asm_sub_register,
     improper_gpu_kernel_arg,
-    improper_ctypes_definitions,
     non_camel_case_types,
     unused_assignments,
     unused_variables
 )]
+#![deny(unfulfilled_lint_expectations)]
+#![expect(improper_ctypes_definitions)]
 
 extern crate minicore;
 use minicore::simd::*;
diff --git a/tests/assembly-llvm/naked-functions/wasm32.rs b/tests/assembly-llvm/naked-functions/wasm32.rs
index e2a2ab94c8a33..b2754029021bf 100644
--- a/tests/assembly-llvm/naked-functions/wasm32.rs
+++ b/tests/assembly-llvm/naked-functions/wasm32.rs
@@ -99,7 +99,6 @@ extern "C" fn fn_i64_i64(num: i64) -> i64 {
 // wasm32-unknown: .functype fn_i128_i128 (i32, i64, i64) -> ()
 // wasm32-wasip1: .functype fn_i128_i128 (i32, i64, i64) -> ()
 // wasm64-unknown: .functype fn_i128_i128 (i64, i64, i64) -> ()
-#[allow(improper_ctypes_definitions)]
 #[no_mangle]
 #[unsafe(naked)]
 extern "C" fn fn_i128_i128(num: i128) -> i128 {
diff --git a/tests/assembly-llvm/reg-struct-return.rs b/tests/assembly-llvm/reg-struct-return.rs
index d364954abe30d..59e40c9e6fb12 100644
--- a/tests/assembly-llvm/reg-struct-return.rs
+++ b/tests/assembly-llvm/reg-struct-return.rs
@@ -23,6 +23,7 @@ use minicore::*;
 // Verifies ABI changes for small structs, where both fields fit into one register.
 // WITH is expected to use register return, WITHOUT should use hidden pointer.
 mod Small {
+    #[repr(C)]
     struct SmallStruct {
         a: i8,
         b: i8,
@@ -66,6 +67,7 @@ mod Small {
 // WITH is expected to still use register return, WITHOUT should use hidden
 // pointer.
 mod Pivot {
+    #[repr(C)]
     struct PivotStruct {
         a: i32,
         b: i32,
@@ -109,6 +111,7 @@ mod Pivot {
 // maximum size for reg-struct-return (8 bytes).
 // Here, the hidden pointer convention should be used even when `-Zreg-struct-return` is set.
 mod Large {
+    #[repr(C)]
     struct LargeStruct {
         a: i32,
         b: i32,
diff --git a/tests/codegen-llvm/abi-x86_64_sysv.rs b/tests/codegen-llvm/abi-x86_64_sysv.rs
index 09909f994d652..b8912c91ebaee 100644
--- a/tests/codegen-llvm/abi-x86_64_sysv.rs
+++ b/tests/codegen-llvm/abi-x86_64_sysv.rs
@@ -4,12 +4,14 @@
 
 #![crate_type = "lib"]
 
+#[repr(C)]
 pub struct S24 {
     a: i8,
     b: i8,
     c: i8,
 }
 
+#[repr(C)]
 pub struct S48 {
     a: i16,
     b: i16,
diff --git a/tests/codegen-llvm/bpf-abi/indirect-return.rs b/tests/codegen-llvm/bpf-abi/indirect-return.rs
index c285bd9431c58..437f4ab0f3abc 100644
--- a/tests/codegen-llvm/bpf-abi/indirect-return.rs
+++ b/tests/codegen-llvm/bpf-abi/indirect-return.rs
@@ -11,6 +11,7 @@
 
 extern crate minicore;
 
+#[repr(C)]
 struct Big {
     a: [u16; 32],
     b: u64,
diff --git a/tests/codegen-llvm/call-site-inline-attributes.rs b/tests/codegen-llvm/call-site-inline-attributes.rs
deleted file mode 100644
index 01839526c50c1..0000000000000
--- a/tests/codegen-llvm/call-site-inline-attributes.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-//@ compile-flags: -O -Zinline-mir=no -Cno-prepopulate-passes -Zmerge-functions=disabled
-
-#![crate_type = "lib"]
-
-// This test checks that we add inlinehint for #[inline], noinline for #[inline(never)], and
-// alwaysinline for #[inline(always)] to call sites.
-
-#[unsafe(no_mangle)]
-fn calls_something_noinline() {
-    // CHECK-LABEL @calls_something_noinline
-    // CHECK: call void @{{.*}}noinline_fn() #[[NOINLINE:[0-9]+]]
-    noinline_fn();
-}
-
-#[inline(never)]
-fn noinline_fn() {}
-
-#[unsafe(no_mangle)]
-fn calls_something_inline() {
-    // CHECK-LABEL @calls_something_inlinehint
-    // CHECK: call void @{{.*}}inlinehint_fn() #[[INLINEHINT:[0-9]+]]
-    inlinehint_fn();
-}
-
-#[inline]
-fn inlinehint_fn() {}
-
-#[unsafe(no_mangle)]
-fn calls_something_alwaysinline() {
-    // CHECK-LABEL @calls_something_alwaysinline
-    // CHECK: call void @{{.*}}alwaysinline_fn() #[[ALWAYSINLINE:[0-9]+]]
-    alwaysinline_fn();
-}
-
-#[inline(always)]
-fn alwaysinline_fn() {}
-
-//CHECK: attributes #[[NOINLINE]] = {{{.*}} noinline {{.*}}}
-//CHECK: attributes #[[INLINEHINT]] = {{{.*}} inlinehint {{.*}}}
-//CHECK: attributes #[[ALWAYSINLINE]] = {{{.*}} alwaysinline {{.*}}}
diff --git a/tests/codegen-llvm/complex-abi.rs b/tests/codegen-llvm/complex-abi.rs
index 4ba7ecad764f2..c900c3debd504 100644
--- a/tests/codegen-llvm/complex-abi.rs
+++ b/tests/codegen-llvm/complex-abi.rs
@@ -103,7 +103,8 @@
 
 #![feature(no_core, lang_items, f16, f128)]
 #![no_core]
-#![allow(improper_ctypes)] // only Complex<{float}> is guaranteed to be ABI-compatible for now
+// only Complex<{float}> is guaranteed to be ABI-compatible for now
+#![expect(improper_ctypes_definitions)]
 #![crate_type = "lib"]
 
 extern crate minicore;
diff --git a/tests/codegen-llvm/regparm-inreg.rs b/tests/codegen-llvm/regparm-inreg.rs
index 77d4c206071e7..bf6bc4dd7bf0e 100644
--- a/tests/codegen-llvm/regparm-inreg.rs
+++ b/tests/codegen-llvm/regparm-inreg.rs
@@ -52,14 +52,15 @@ pub mod tests {
     #[no_mangle]
     pub extern "thiscall" fn f6(_: i32, _: i32, _: i32) {}
 
+    #[repr(C)]
     struct S1 {
         x1: i32,
     }
-    // regparm0: @f7(i32 noundef %_1, i32 noundef %_2, i32 noundef %_3, i32 noundef %_4)
-    // regparm1: @f7(i32 inreg noundef %_1, i32 noundef %_2, i32 noundef %_3, i32 noundef %_4)
-    // regparm2: @f7(i32 inreg noundef %_1, i32 inreg noundef %_2, i32 noundef %_3, i32 noundef %_4)
-    // regparm3: @f7(i32 inreg noundef %_1, i32 inreg noundef %_2, i32 inreg noundef %_3,
-    // regparm3-SAME: i32 noundef %_4)
+    // regparm0: @f7(i32 noundef %_1, i32 noundef %_2, ptr {{.*}} byval([4 x i8]) {{.*}} %_3, i32 noundef %_4)
+    // regparm1: @f7(i32 inreg noundef %_1, i32 noundef %_2, ptr {{.*}} byval([4 x i8]) {{.*}}  %_3, i32 noundef %_4)
+    // regparm2: @f7(i32 inreg noundef %_1, i32 inreg noundef %_2, ptr {{.*}} byval([4 x i8]) {{.*}} %_3, i32 noundef %_4)
+    // regparm3: @f7(i32 inreg noundef %_1, i32 inreg noundef %_2, ptr {{.*}} byval([4 x i8]) {{.*}} %_3,
+    // regparm3-SAME: i32 inreg noundef %_4)
     #[no_mangle]
     pub extern "C" fn f7(_: i32, _: i32, _: S1, _: i32) {}
 
diff --git a/tests/codegen-llvm/riscv-abi/riscv64-lp64-lp64f-lp64d-abi.rs b/tests/codegen-llvm/riscv-abi/riscv64-lp64-lp64f-lp64d-abi.rs
index 0f5a449ead133..ae806aa64f513 100644
--- a/tests/codegen-llvm/riscv-abi/riscv64-lp64-lp64f-lp64d-abi.rs
+++ b/tests/codegen-llvm/riscv-abi/riscv64-lp64-lp64f-lp64d-abi.rs
@@ -5,7 +5,7 @@
 #![crate_type = "lib"]
 #![no_core]
 #![feature(no_core, lang_items)]
-#![allow(improper_ctypes)]
+#![deny(unfulfilled_lint_expectations, improper_ctypes_definitions)]
 
 extern crate minicore;
 use minicore::*;
@@ -59,6 +59,7 @@ pub extern "C" fn f_fp_scalar_2(x: f64) -> f64 {
 pub struct Empty {}
 
 // CHECK: define void @f_agg_empty_struct()
+#[expect(improper_ctypes_definitions)]
 #[no_mangle]
 pub extern "C" fn f_agg_empty_struct(e: Empty) -> Empty {
     e
diff --git a/tests/codegen-llvm/scalable-vectors/memcpy.rs b/tests/codegen-llvm/scalable-vectors/memcpy.rs
index 859f50b5b1178..30d4b0d17ebe1 100644
--- a/tests/codegen-llvm/scalable-vectors/memcpy.rs
+++ b/tests/codegen-llvm/scalable-vectors/memcpy.rs
@@ -5,12 +5,13 @@
 #![crate_type = "lib"]
 #![feature(simd_ffi)]
 #![feature(stdarch_aarch64_sve)]
+#![deny(unfulfilled_lint_expectations)]
 
 // Test that `vscale * size` is generated for `memcpy` of scalable vector types
 
 use std::arch::aarch64::*;
 
-#[allow(improper_ctypes)]
+#[expect(improper_ctypes)]
 unsafe extern "C" {
     fn svcreate2_s16_wrapper(__dst: *mut svint16x2_t, x0: *const svint16_t, x1: *const svint16_t);
     fn svcreate3_s16_wrapper(
diff --git a/tests/debuginfo/basic-types-globals-metadata.rs b/tests/debuginfo/basic-types-globals-metadata.rs
index 3f1d9fd5de278..f7f3504ae26fa 100644
--- a/tests/debuginfo/basic-types-globals-metadata.rs
+++ b/tests/debuginfo/basic-types-globals-metadata.rs
@@ -33,11 +33,12 @@
 //@ gdb-check:type = f32
 //@ gdb-command:whatis basic_types_globals_metadata::F64
 //@ gdb-check:type = f64
+// FIXME(f128): gdb doesn't support Rust `f128` yet.
 //@ gdb-command:continue
 
 #![allow(unused_variables)]
 #![allow(dead_code)]
-#![feature(f16)]
+#![feature(f16, f128)]
 
 // N.B. These are `mut` only so they don't constant fold away.
 static mut B: bool = false;
@@ -55,13 +56,14 @@ static mut U64: u64 = 64;
 static mut F16: f16 = 1.5;
 static mut F32: f32 = 2.5;
 static mut F64: f64 = 3.5;
+static mut F128: f128 = 4.5;
 
 fn main() {
     _zzz(); // #break
 
-    let a = unsafe { (B, I, C, I8, I16, I32, I64, U, U8, U16, U32, U64, F32, F64) };
-    // FIXME: Including f16 and f32 in the same tuple emits `__gnu_h2f_ieee`, which
-    // does not exist on some targets like PowerPC.
+    let a = unsafe { (B, I, C, I8, I16, I32, I64, U, U8, U16, U32, U64, F32, F64, F128) };
+    // FIXME(f16): Including f16 and f32 in the same tuple emits `__gnu_h2f_ieee`, which
+    // does not exist on some targets like PowerPC (fixed in llvm22).
     // See https://github.com/llvm/llvm-project/issues/97981 and
     // https://github.com/rust-lang/compiler-builtins/issues/655
     let b = unsafe { F16 };
diff --git a/tests/debuginfo/basic-types-globals.rs b/tests/debuginfo/basic-types-globals.rs
index 044b757aaf470..3bc9d3becdade 100644
--- a/tests/debuginfo/basic-types-globals.rs
+++ b/tests/debuginfo/basic-types-globals.rs
@@ -1,11 +1,20 @@
-//@ revisions: lto no-lto
+//@ revisions: lto no-lto lto-apple no-lto-apple
 
 //@ compile-flags:-g --crate-name=basic_types_globals
 //@ disable-gdb-pretty-printers
 
+// FIXME(f128): Merge `-apple` revisions once Apple releases Xcode with LLVM 22.
+//@ [lto] ignore-apple
+//@ [no-lto] ignore-apple
+//@ [lto-apple] only-apple
+//@ [no-lto-apple] only-apple
 //@ [lto] compile-flags:-C lto
 //@ [lto] no-prefer-dynamic
+//@ [lto-apple] compile-flags:-C lto
+//@ [lto-apple] no-prefer-dynamic
 //@ ignore-backends: gcc
+// `f128` support was added to `lldb` in version 22.
+//@ min-llvm-lldb-version: 22
 
 //@ lldb-command:run
 //@ lldb-command:v basic_types_globals::B
@@ -38,6 +47,9 @@
 //@ lldb-check:[...]basic_types_globals::F32 = 2.5
 //@ lldb-command:v basic_types_globals::F64
 //@ lldb-check:[...]basic_types_globals::F64 = 3.5
+//@ lldb-command:v basic_types_globals::F128
+//@[no-lto] lldb-check:[...]basic_types_globals::F128 = 4.5
+//@[lto] lldb-check:[...]basic_types_globals::F128 = 4.5
 
 //@ gdb-command:run
 //@ gdb-command:print B
@@ -70,10 +82,11 @@
 //@ gdb-check:$14 = 2.5
 //@ gdb-command:print F64
 //@ gdb-check:$15 = 3.5
+// FIXME(f128): gdb doesn't support Rust `f128` yet.
 //@ gdb-command:continue
 
 #![allow(unused_variables)]
-#![feature(f16)]
+#![feature(f16, f128)]
 
 // N.B. These are `mut` only so they don't constant fold away.
 static mut B: bool = false;
@@ -91,13 +104,14 @@ static mut U64: u64 = 64;
 static mut F16: f16 = 1.5;
 static mut F32: f32 = 2.5;
 static mut F64: f64 = 3.5;
+static mut F128: f128 = 4.5;
 
 fn main() {
     _zzz(); // #break
 
-    let a = unsafe { (B, I, C, I8, I16, I32, I64, U, U8, U16, U32, U64, F32, F64) };
-    // FIXME: Including f16 and f32 in the same tuple emits `__gnu_h2f_ieee`, which
-    // does not exist on some targets like PowerPC.
+    let a = unsafe { (B, I, C, I8, I16, I32, I64, U, U8, U16, U32, U64, F32, F64, F128) };
+    // FIXME(f16): Including f16 and f32 in the same tuple emits `__gnu_h2f_ieee`, which
+    // does not exist on some targets like PowerPC (fixed in llvm22).
     // See https://github.com/llvm/llvm-project/issues/97981 and
     // https://github.com/rust-lang/compiler-builtins/issues/655
     let b = unsafe { F16 };
diff --git a/tests/debuginfo/basic-types-metadata.rs b/tests/debuginfo/basic-types-metadata.rs
index d3a3d03ef7424..7171840077265 100644
--- a/tests/debuginfo/basic-types-metadata.rs
+++ b/tests/debuginfo/basic-types-metadata.rs
@@ -35,6 +35,7 @@
 //@ gdb-check:type = f32
 //@ gdb-command:whatis f64
 //@ gdb-check:type = f64
+// FIXME(f128): gdb doesn't support Rust `f128` yet.
 //@ gdb-command:whatis fnptr
 //@ gdb-check:type = *mut fn ()
 //@ gdb-command:info functions _yyy
@@ -54,7 +55,7 @@
 //@ gdb-command:continue
 
 #![allow(unused_variables)]
-#![feature(f16)]
+#![feature(f16, f128)]
 
 fn main() {
     let unit: () = ();
@@ -73,6 +74,7 @@ fn main() {
     let f16: f16 = 1.5;
     let f32: f32 = 2.5;
     let f64: f64 = 3.5;
+    let f128: f128 = 4.5;
     let fnptr : fn() = _zzz;
     let closure_0 = || {};
     let closure_1 = || { b; };
diff --git a/tests/debuginfo/basic-types-mut-globals.rs b/tests/debuginfo/basic-types-mut-globals.rs
index c3cc7be549d47..3f59da2a5d2e0 100644
--- a/tests/debuginfo/basic-types-mut-globals.rs
+++ b/tests/debuginfo/basic-types-mut-globals.rs
@@ -1,13 +1,14 @@
-// Caveats - gdb prints any 8-bit value (meaning rust I8 and u8 values)
-// as its numerical value along with its associated ASCII char, there
-// doesn't seem to be any way around this. Also, gdb doesn't know
-// about UTF-32 character encoding and will print a rust char as only
-// its numerical value.
-
-//@ compile-flags:-g
+//@ compile-flags:-g --crate-name=basic_types_mut_globals
 //@ disable-gdb-pretty-printers
 //@ ignore-backends: gcc
 
+// FIXME(f128): Merge `apple` revision once Apple releases Xcode with LLVM 22.
+//@ revisions: not-apple apple
+//@[not-apple] ignore-apple
+//@[apple] only-apple
+// `f128` support was added to `lldb` in version 22.
+//@ min-llvm-lldb-version: 22
+
 //@ gdb-command:run
 
 // Check initializers
@@ -41,6 +42,7 @@
 //@ gdb-check:$14 = 2.5
 //@ gdb-command:print F64
 //@ gdb-check:$15 = 3.5
+// FIXME(f128): gdb doesn't support Rust `f128` yet.
 //@ gdb-command:continue
 
 // Check new values
@@ -50,7 +52,7 @@
 //@ gdb-check:$17 = 2
 //@ gdb-command:print C
 //@ gdb-check:$18 = 102 'f'
-//@ gdb-command:print/d I8
+//@ gdb-command:print I8
 //@ gdb-check:$19 = 78
 //@ gdb-command:print I16
 //@ gdb-check:$20 = -26
@@ -60,7 +62,7 @@
 //@ gdb-check:$22 = -54
 //@ gdb-command:print U
 //@ gdb-check:$23 = 5
-//@ gdb-command:print/d U8
+//@ gdb-command:print U8
 //@ gdb-check:$24 = 20
 //@ gdb-command:print U16
 //@ gdb-check:$25 = 32
@@ -74,9 +76,81 @@
 //@ gdb-check:$29 = 5.75
 //@ gdb-command:print F64
 //@ gdb-check:$30 = 9.25
+// FIXME(f128): gdb doesn't support Rust `f128` yet.
+
+//@ lldb-command:run
+
+// Check initializers
+//@ lldb-command:v basic_types_mut_globals::B
+//@ lldb-check:[...]basic_types_mut_globals::B = false
+//@ lldb-command:v basic_types_mut_globals::I
+//@ lldb-check:[...]basic_types_mut_globals::I = -1
+//@ lldb-command:v basic_types_mut_globals::C
+//@ lldb-check:[...]basic_types_mut_globals::C = U+0x00000061 U'a'
+//@ lldb-command:v/d basic_types_mut_globals::I8
+//@ lldb-check:[...]basic_types_mut_globals::I8 = 68
+//@ lldb-command:v basic_types_mut_globals::I16
+//@ lldb-check:[...]basic_types_mut_globals::I16 = -16
+//@ lldb-command:v basic_types_mut_globals::I32
+//@ lldb-check:[...]basic_types_mut_globals::I32 = -32
+//@ lldb-command:v basic_types_mut_globals::I64
+//@ lldb-check:[...]basic_types_mut_globals::I64 = -64
+//@ lldb-command:v basic_types_mut_globals::U
+//@ lldb-check:[...]basic_types_mut_globals::U = 1
+//@ lldb-command:v/d basic_types_mut_globals::U8
+//@ lldb-check:[...]basic_types_mut_globals::U8 = 100
+//@ lldb-command:v basic_types_mut_globals::U16
+//@ lldb-check:[...]basic_types_mut_globals::U16 = 16
+//@ lldb-command:v basic_types_mut_globals::U32
+//@ lldb-check:[...]basic_types_mut_globals::U32 = 32
+//@ lldb-command:v basic_types_mut_globals::U64
+//@ lldb-check:[...]basic_types_mut_globals::U64 = 64
+//@ lldb-command:v basic_types_mut_globals::F16
+//@ lldb-check:[...]basic_types_mut_globals::F16 = 1.5
+//@ lldb-command:v basic_types_mut_globals::F32
+//@ lldb-check:[...]basic_types_mut_globals::F32 = 2.5
+//@ lldb-command:v basic_types_mut_globals::F64
+//@ lldb-check:[...]basic_types_mut_globals::F64 = 3.5
+//@ lldb-command:v basic_types_mut_globals::F128
+//@[not-apple] lldb-check:[...]basic_types_mut_globals::F128 = 4.5
+//@ lldb-command:continue
+
+// Check new values
+//@ lldb-command:v basic_types_mut_globals::B
+//@ lldb-check:[...]basic_types_mut_globals::B = true
+//@ lldb-command:v basic_types_mut_globals::I
+//@ lldb-check:[...]basic_types_mut_globals::I = 2
+//@ lldb-command:v basic_types_mut_globals::C
+//@ lldb-check:[...]basic_types_mut_globals::C = U+0x00000066 U'f'
+//@ lldb-command:v/d basic_types_mut_globals::I8
+//@ lldb-check:[...]basic_types_mut_globals::I8 = 78
+//@ lldb-command:v basic_types_mut_globals::I16
+//@ lldb-check:[...]basic_types_mut_globals::I16 = -26
+//@ lldb-command:v basic_types_mut_globals::I32
+//@ lldb-check:[...]basic_types_mut_globals::I32 = -12
+//@ lldb-command:v basic_types_mut_globals::I64
+//@ lldb-check:[...]basic_types_mut_globals::I64 = -54
+//@ lldb-command:v basic_types_mut_globals::U
+//@ lldb-check:[...]basic_types_mut_globals::U = 5
+//@ lldb-command:v/d basic_types_mut_globals::U8
+//@ lldb-check:[...]basic_types_mut_globals::U8 = 20
+//@ lldb-command:v basic_types_mut_globals::U16
+//@ lldb-check:[...]basic_types_mut_globals::U16 = 32
+//@ lldb-command:v basic_types_mut_globals::U32
+//@ lldb-check:[...]basic_types_mut_globals::U32 = 16
+//@ lldb-command:v basic_types_mut_globals::U64
+//@ lldb-check:[...]basic_types_mut_globals::U64 = 128
+//@ lldb-command:v basic_types_mut_globals::F16
+//@ lldb-check:[...]basic_types_mut_globals::F16 = 2.25
+//@ lldb-command:v basic_types_mut_globals::F32
+//@ lldb-check:[...]basic_types_mut_globals::F32 = 5.75
+//@ lldb-command:v basic_types_mut_globals::F64
+//@ lldb-check:[...]basic_types_mut_globals::F64 = 9.25
+//@ lldb-command:v basic_types_mut_globals::F128
+//@[not-apple] lldb-check:[...]basic_types_mut_globals::F128 = 12.75
 
 #![allow(unused_variables)]
-#![feature(f16)]
+#![feature(f16, f128)]
 
 static mut B: bool = false;
 static mut I: isize = -1;
@@ -93,6 +167,7 @@ static mut U64: u64 = 64;
 static mut F16: f16 = 1.5;
 static mut F32: f32 = 2.5;
 static mut F64: f64 = 3.5;
+static mut F128: f128 = 4.5;
 
 fn main() {
     _zzz(); // #break
@@ -113,6 +188,7 @@ fn main() {
         F16 = 2.25;
         F32 = 5.75;
         F64 = 9.25;
+        F128 = 12.75;
     }
 
     _zzz(); // #break
diff --git a/tests/debuginfo/basic-types/main.rs b/tests/debuginfo/basic-types/main.rs
index 9f61862c0dfd8..d01e51036f201 100644
--- a/tests/debuginfo/basic-types/main.rs
+++ b/tests/debuginfo/basic-types/main.rs
@@ -1,9 +1,3 @@
-// Caveats - gdb prints any 8-bit value (meaning rust i8 and u8 values)
-// as its numerical value along with its associated ASCII char, there
-// doesn't seem to be any way around this. Also, gdb doesn't know
-// about UTF-32 character encoding and will print a rust char as only
-// its numerical value.
-
 //@ compile-flags:-g
 //@ disable-gdb-pretty-printers
 //@ ignore-backends: gcc
@@ -32,6 +26,7 @@
 //@ gdb-repr:f16
 //@ gdb-repr:f32
 //@ gdb-repr:f64
+// FIXME(f128): gdb doesn't support Rust `f128` yet.
 //@ gdb-repr:s
 
 // === LLDB TESTS ==================================================================================
@@ -85,13 +80,16 @@
 //@ cdb-check:f32              : 2.500000 [Type: float]
 //@ cdb-command:dx f64
 //@ cdb-check:f64              : 3.500000 [Type: double]
+//@ cdb-command:dx f128
+//@ cdb-check:f128             : 0x1.2p+2 [Type: f128]
+//@ cdb-check:bits             : 0x40012000000000000000000000000000
 //@ cdb-command:.enable_unicode 1
 // FIXME(#88840): The latest version of the Windows SDK broke the visualizer for str.
 //@ cdb-command:dx  s
 //@ cdb-check:s                : [...] [Type: ref$<str$>]
 
 #![allow(unused_variables)]
-#![feature(f16)]
+#![feature(f16, f128)]
 
 fn main() {
     let b: bool = false;
@@ -109,6 +107,7 @@ fn main() {
     let f16: f16 = 1.5;
     let f32: f32 = 2.5;
     let f64: f64 = 3.5;
+    let f128: f128 = 4.5;
     let s: &str = "Hello, World!";
     _zzz(); // #break
 }
diff --git a/tests/debuginfo/borrowed-basic.rs b/tests/debuginfo/borrowed-basic.rs
index f7b7d2cbd810c..2872bc65fac3f 100644
--- a/tests/debuginfo/borrowed-basic.rs
+++ b/tests/debuginfo/borrowed-basic.rs
@@ -2,6 +2,13 @@
 //@ disable-gdb-pretty-printers
 //@ ignore-backends: gcc
 
+// FIXME(f128): Merge `apple` revision once Apple releases Xcode with LLVM 22.
+//@ revisions: not-apple apple
+//@[not-apple] ignore-apple
+//@[apple] only-apple
+// `f128` support was added to `lldb` in version 22.
+//@ min-llvm-lldb-version: 22
+
 // === GDB TESTS ===================================================================================
 
 //@ gdb-command:run
@@ -50,6 +57,8 @@
 //@ gdb-command:print *f64_ref
 //@ gdb-check:$15 = 3.5
 
+// FIXME(f128): gdb doesn't support Rust `f128` yet.
+
 
 // === LLDB TESTS ==================================================================================
 
@@ -99,8 +108,11 @@
 //@ lldb-command:v *f64_ref
 //@ lldb-check:[...] 3.5
 
+//@ lldb-command:v *f128_ref
+//@[not-apple] lldb-check:[...] 4.5
+
 #![allow(unused_variables)]
-#![feature(f16)]
+#![feature(f16, f128)]
 
 fn main() {
     let bool_val: bool = true;
@@ -148,6 +160,9 @@ fn main() {
     let f64_val: f64 = 3.5;
     let f64_ref: &f64 = &f64_val;
 
+    let f128_val: f128 = 4.5;
+    let f128_ref: &f128 = &f128_val;
+
     zzz(); // #break
 }
 
diff --git a/tests/debuginfo/borrowed-unique-basic.rs b/tests/debuginfo/borrowed-unique-basic.rs
index 17939239c0dea..0d1fdec0f58d1 100644
--- a/tests/debuginfo/borrowed-unique-basic.rs
+++ b/tests/debuginfo/borrowed-unique-basic.rs
@@ -2,6 +2,13 @@
 //@ disable-gdb-pretty-printers
 //@ ignore-backends: gcc
 
+// FIXME(f128): Merge `apple` revision once Apple releases Xcode with LLVM 22.
+//@ revisions: not-apple apple
+//@[not-apple] ignore-apple
+//@[apple] only-apple
+// `f128` support was added to `lldb` in version 22.
+//@ min-llvm-lldb-version: 22
+
 // === GDB TESTS ===================================================================================
 
 //@ gdb-command:run
@@ -51,6 +58,8 @@
 //@ gdb-command:print *f64_ref
 //@ gdb-check:$15 = 3.5
 
+// FIXME(f128): gdb doesn't support Rust `f128` yet.
+
 
 // === LLDB TESTS ==================================================================================
 
@@ -102,8 +111,11 @@
 //@ lldb-command:v *f64_ref
 //@ lldb-check:[...] 3.5
 
+//@ lldb-command:v *f128_ref
+//@[not-apple] lldb-check:[...] 4.5
+
 #![allow(unused_variables)]
-#![feature(f16)]
+#![feature(f16, f128)]
 
 fn main() {
     let bool_box: Box<bool> = Box::new(true);
@@ -151,6 +163,9 @@ fn main() {
     let f64_box: Box<f64> = Box::new(3.5);
     let f64_ref: &f64 = &*f64_box;
 
+    let f128_box: Box<f128> = Box::new(4.5);
+    let f128_ref: &f128 = &*f128_box;
+
     zzz(); // #break
 }
 
diff --git a/tests/debuginfo/f128-natvis.rs b/tests/debuginfo/f128-natvis.rs
new file mode 100644
index 0000000000000..5f91014cfe5db
--- /dev/null
+++ b/tests/debuginfo/f128-natvis.rs
@@ -0,0 +1,92 @@
+//@ compile-flags: -g
+//@ only-msvc
+
+// This tests the `f128` Natvis visualiser.
+//@ cdb-command:g
+//@ cdb-command:dx v0_0
+//@ cdb-check:v0_0             : 0x0p+0 [Type: f128]
+//@ cdb-check:bits             : 0x00000000000000000000000000000000
+//@ cdb-command:dx neg_0_0
+//@ cdb-check:neg_0_0          : -0x0p+0 [Type: f128]
+//@ cdb-check:bits             : 0x80000000000000000000000000000000
+//@ cdb-command:dx v1_0
+//@ cdb-check:v1_0             : 0x1p+0 [Type: f128]
+//@ cdb-check:bits             : 0x3fff0000000000000000000000000000
+//@ cdb-command:dx v1_5
+//@ cdb-check:v1_5             : 0x1.8p+0 [Type: f128]
+//@ cdb-check:bits             : 0x3fff8000000000000000000000000000
+//@ cdb-command:dx v72_3
+//@ cdb-check:v72_3            : 0x1.2133333333333333333333333333p+6 [Type: f128]
+//@ cdb-check:bits             : 0x40052133333333333333333333333333
+//@ cdb-command:dx neg_0_126
+//@ cdb-check:neg_0_126        : -0x1.020c49ba5e353f7ced916872b021p-3 [Type: f128]
+//@ cdb-check:bits             : 0xbffc020c49ba5e353f7ced916872b021
+//@ cdb-command:dx v0_00003
+//@ cdb-check:v0_00003         : 0x1.f75104d551d68c692f6e82949a56p-16 [Type: f128]
+//@ cdb-check:bits             : 0x3feff75104d551d68c692f6e82949a56
+//@ cdb-command:dx neg_0_00004
+//@ cdb-check:neg_0_00004      : -0x1.4f8b588e368f08461f9f01b866e4p-15 [Type: f128]
+//@ cdb-check:bits             : 0xbff04f8b588e368f08461f9f01b866e4
+//@ cdb-command:dx very_small
+//@ cdb-check:very_small       : 0x1p-16494 [Type: f128]
+//@ cdb-check:bits             : 0x00000000000000000000000000000001
+//@ cdb-command:dx not_quite_as_small
+//@ cdb-check:not_quite_as_small : 0x1.8p-16385 [Type: f128]
+//@ cdb-check:bits             : 0x00003000000000000000000000000000
+//@ cdb-command:dx smallest_pos_normal
+//@ cdb-check:smallest_pos_normal : 0x1p-16382 [Type: f128]
+//@ cdb-check:bits             : 0x00010000000000000000000000000000
+//@ cdb-command:dx smallest_subnormal
+//@ cdb-check:smallest_subnormal : -0x1.fffffffffffffffffffffffffffep-16383 [Type: f128]
+//@ cdb-check:bits             : 0x8000ffffffffffffffffffffffffffff
+//@ cdb-command:dx just_above
+//@ cdb-check:just_above       : -0x1.ffffffffffffffffffffffffff8p-1 [Type: f128]
+//@ cdb-check:bits             : 0xbffeffffffffffffffffffffffffff80
+//@ cdb-command:dx max
+//@ cdb-check:max              : 0x1.ffffffffffffffffffffffffffffp+16383 [Type: f128]
+//@ cdb-check:bits             : 0x7ffeffffffffffffffffffffffffffff
+//@ cdb-command:dx min
+//@ cdb-check:min              : -0x1.ffffffffffffffffffffffffffffp+16383 [Type: f128]
+//@ cdb-check:bits             : 0xfffeffffffffffffffffffffffffffff
+//@ cdb-command:dx inf
+//@ cdb-check:inf              : inf [Type: f128]
+//@ cdb-check:bits             : 0x7fff0000000000000000000000000000
+//@ cdb-command:dx neg_inf
+//@ cdb-check:neg_inf          : -inf [Type: f128]
+//@ cdb-check:bits             : 0xffff0000000000000000000000000000
+//@ cdb-command:dx nan
+//@ cdb-check:nan              : NaN [Type: f128]
+//@ cdb-check:bits             : 0x7fff8000000000000000000000000000
+//@ cdb-command:dx other_nan
+//@ cdb-check:other_nan        : NaN [Type: f128]
+//@ cdb-check:bits             : 0xffff123456789abcdef123456789abcd
+
+#![feature(f128)]
+
+fn main() {
+    let v0_0 = 0.0_f128;
+    let neg_0_0 = -0.0_f128;
+    let v1_0 = 1.0_f128;
+    let v1_5 = 1.5_f128;
+    let v72_3 = 72.3_f128;
+    let neg_0_126 = -0.126_f128;
+    let v0_00003 = 0.00003_f128;
+    let neg_0_00004 = -0.00004_f128;
+    let very_small = 0.0_f128.next_up();
+    let not_quite_as_small = const { f128::MIN_POSITIVE / 8.0 + f128::MIN_POSITIVE / 16.0 };
+    let smallest_pos_normal = f128::MIN_POSITIVE;
+    let smallest_subnormal = (-f128::MIN_POSITIVE).next_up();
+    let just_above = const { -1.0 + f128::EPSILON * 64.0 };
+    let max = f128::MAX;
+    let min = f128::MIN;
+    let inf = f128::INFINITY;
+    let neg_inf = f128::NEG_INFINITY;
+    let nan = f128::NAN;
+    let other_nan = f128::from_bits(0xffff_1234_5678_9abc_def1_2345_6789_abcd);
+
+    _zzz(); // #break
+}
+
+fn _zzz() {
+    ()
+}
diff --git a/tests/debuginfo/reference-debuginfo.rs b/tests/debuginfo/reference-debuginfo.rs
index 518e1dac2885e..495dde379da7e 100644
--- a/tests/debuginfo/reference-debuginfo.rs
+++ b/tests/debuginfo/reference-debuginfo.rs
@@ -2,10 +2,18 @@
 // That pass replaces debuginfo for `a => _x` where `_x = &b` to be `a => &b`,
 // and leaves codegen to create a ladder of allocations so as `*a == b`.
 //
+// FIXME: Currently emits warning: MIR pass `ConstDebugInfo` is unknown and will be ignored
 //@ compile-flags:-g -Zmir-enable-passes=+ReferencePropagation,-ConstDebugInfo
 //@ disable-gdb-pretty-printers
 //@ ignore-backends: gcc
 
+// FIXME(f128): Merge `apple` revision once Apple releases Xcode with LLVM 22.
+//@ revisions: not-apple apple
+//@[not-apple] ignore-apple
+//@[apple] only-apple
+// `f128` support was added to `lldb` in version 22.
+//@ min-llvm-lldb-version: 22
+
 // === GDB TESTS ===================================================================================
 
 //@ gdb-command:run
@@ -54,6 +62,8 @@
 //@ gdb-command:print *f64_ref
 //@ gdb-check:$15 = 3.5
 
+// FIXME(f128): gdb doesn't support Rust `f128` yet.
+
 //@ gdb-command:print *f64_double_ref
 //@ gdb-check:$16 = 3.5
 
@@ -106,11 +116,14 @@
 //@ lldb-command:v *f64_ref
 //@ lldb-check:[...] 3.5
 
+//@ lldb-command:v *f128_ref
+//@[not-apple] lldb-check:[...] 4.5
+
 //@ lldb-command:v *f64_double_ref
 //@ lldb-check:[...] 3.5
 
 #![allow(unused_variables)]
-#![feature(f16)]
+#![feature(f16, f128)]
 
 fn main() {
     let bool_val: bool = true;
@@ -159,6 +172,9 @@ fn main() {
     let f64_ref: &f64 = &f64_val;
     let f64_double_ref: &f64 = &f64_ref;
 
+    let f128_val: f128 = 4.5;
+    let f128_ref: &f128 = &f128_val;
+
     zzz(); // #break
 }
 
diff --git a/tests/pretty/custom-test-runner.pp b/tests/pretty/custom-test-runner.pp
new file mode 100644
index 0000000000000..5965d76bbc8a5
--- /dev/null
+++ b/tests/pretty/custom-test-runner.pp
@@ -0,0 +1,32 @@
+#![feature(prelude_import)]
+#![no_std]
+//@ compile-flags: --crate-type=lib --test --remap-path-prefix={{src-base}}/=/the/src/ --remap-path-prefix={{src-base}}\=/the/src/
+//@ pretty-compare-only
+//@ pretty-mode:expanded
+//@ pp-exact:custom-test-runner.pp
+
+// Example taken from the unstable book.
+
+#![feature(custom_test_frameworks)]
+#![test_runner(my_runner)]
+extern crate std;
+#[prelude_import]
+use ::std::prelude::rust_2015::*;
+
+fn my_runner(tests: &[&i32]) {
+    for t in tests {
+        if **t == 0 {
+
+
+            { ::std::io::_print(format_args!("PASSED\n")); };
+        } else { { ::std::io::_print(format_args!("FAILED\n")); }; }
+    }
+}
+#[rustc_test_marker = "WILL_PASS"]
+pub const WILL_PASS: i32 = 0;
+#[rustc_test_marker = "WILL_FAIL"]
+pub const WILL_FAIL: i32 = 4;
+#[rustc_main]
+#[coverage(off)]
+#[doc(hidden)]
+pub fn main() -> () { my_runner(&[&WILL_FAIL, &WILL_PASS]) }
diff --git a/tests/pretty/custom-test-runner.rs b/tests/pretty/custom-test-runner.rs
new file mode 100644
index 0000000000000..b0d7360bcd879
--- /dev/null
+++ b/tests/pretty/custom-test-runner.rs
@@ -0,0 +1,25 @@
+//@ compile-flags: --crate-type=lib --test --remap-path-prefix={{src-base}}/=/the/src/ --remap-path-prefix={{src-base}}\=/the/src/
+//@ pretty-compare-only
+//@ pretty-mode:expanded
+//@ pp-exact:custom-test-runner.pp
+
+// Example taken from the unstable book.
+
+#![feature(custom_test_frameworks)]
+#![test_runner(my_runner)]
+
+fn my_runner(tests: &[&i32]) {
+    for t in tests {
+        if **t == 0 {
+            println!("PASSED");
+        } else {
+            println!("FAILED");
+        }
+    }
+}
+
+#[test_case]
+const WILL_PASS: i32 = 0;
+
+#[test_case]
+const WILL_FAIL: i32 = 4;
diff --git a/tests/run-make/c-link-to-rust-va-list-fn/checkrust.rs b/tests/run-make/c-link-to-rust-va-list-fn/checkrust.rs
index 37110e75f4779..3f9698afe2d6c 100644
--- a/tests/run-make/c-link-to-rust-va-list-fn/checkrust.rs
+++ b/tests/run-make/c-link-to-rust-va-list-fn/checkrust.rs
@@ -1,5 +1,5 @@
 #![crate_type = "staticlib"]
-#![feature(c_variadic_int128, c_variadic_experimental_arch)]
+#![feature(c_variadic_int128, c_variadic_experimental_arch, f128)]
 
 use core::ffi::{CStr, VaList, c_char, c_double, c_int, c_long, c_longlong};
 
@@ -100,6 +100,59 @@ pub unsafe extern "C" fn check_list_i128(mut ap: VaList) -> usize {
     }
 }
 
+cfg_select! {
+    any(
+        all(target_arch = "x86_64", not(target_vendor = "apple"), not(target_env = "msvc")),
+        all(target_arch = "x86", not(target_vendor = "apple"), not(target_env = "msvc")),
+        all(target_arch = "powerpc64", target_feature = "vsx"),
+        all(
+            not(windows),
+            not(target_vendor = "apple"),
+            any(
+                target_arch = "aarch64",
+                target_arch = "loongarch32",
+                target_arch = "loongarch64",
+                target_arch = "mips64",
+                target_arch = "mips64r6",
+                target_arch = "riscv64",
+                target_arch = "s390x",
+                target_arch = "sparc",
+                target_arch = "sparc64",
+                target_arch = "wasm32",
+                target_arch = "wasm64",
+            ),
+        ),
+    ) => {
+        #[unsafe(no_mangle)]
+        pub static RUST_HAS_F128: c_int = 1;
+
+        #[unsafe(no_mangle)]
+        pub unsafe extern "C" fn check_list_f128(mut ap: VaList) -> usize {
+            continue_if!(ap.next_arg::<f128>() == -42.0);
+            // use a 32-bit value here to test the alignment logic.
+            continue_if!(ap.next_arg::<c_int>() == 0xAAAA_AAAAu32.cast_signed());
+            continue_if!(ap.next_arg::<f128>() == f128::MAX);
+
+            return 0;
+        }
+    }
+    _ => {
+        #[unsafe(no_mangle)]
+        pub static RUST_HAS_F128: c_int = 0;
+
+        #[unsafe(no_mangle)]
+        pub unsafe extern "C" fn check_list_f128(_: VaList) -> usize {
+            // This function was called a platform where rustc does not implement
+            // VaArgSafe for f128 but clang does define _Float128.
+            //
+            // This occurs on powerpc64 where f128 support depends on a target feature.
+            //
+            // Otherwise, rustc should add the implementation if this comes up.
+            0xFF
+        }
+    }
+}
+
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn check_varargs_0(_: c_int, mut ap: ...) -> usize {
     continue_if!(ap.next_arg::<c_int>() == 42);
diff --git a/tests/run-make/c-link-to-rust-va-list-fn/test.c b/tests/run-make/c-link-to-rust-va-list-fn/test.c
index c7510a29445a5..14c507cd6cccd 100644
--- a/tests/run-make/c-link-to-rust-va-list-fn/test.c
+++ b/tests/run-make/c-link-to-rust-va-list-fn/test.c
@@ -3,12 +3,14 @@
 #include <stdint.h>
 #include <stdlib.h>
 #include <stdio.h>
+#include <math.h>
 
 extern size_t check_list_0(va_list ap);
 extern size_t check_list_1(va_list ap);
 extern size_t check_list_2(va_list ap);
 extern size_t check_list_copy_0(va_list ap);
 extern size_t check_list_i128(va_list ap);
+extern size_t check_list_f128(va_list ap);
 extern size_t check_varargs_0(int fixed, ...);
 extern size_t check_varargs_1(int fixed, ...);
 extern size_t check_varargs_2(int fixed, ...);
@@ -21,6 +23,9 @@ extern size_t run_test_va_list_by_value();
 extern size_t run_test_va_list_by_pointer();
 extern size_t run_test_va_list_by_pointer_pointer();
 
+// Was the rust side compiled with f128 support?
+extern const int RUST_HAS_F128;
+
 int test_rust(size_t (*fn)(va_list), ...) {
     size_t ret = 0;
     va_list ap;
@@ -40,9 +45,43 @@ int main(int argc, char* argv[]) {
     assert(test_rust(check_list_copy_0, 6.28, 16, 'A', "Skip Me!", "Correct") == 0);
 
 #if defined(__SIZEOF_INT128__)
+
     assert(test_rust(check_list_i128, (__int128)-42, 0xAAAAAAAA, (unsigned __int128)-1) == 0);
 #endif
 
+    // Run the f128 test when __float128/_Float128 is defined or long double is IEEE f128.
+    // Use #define instead of typedef so that `#ifdef` can detect it.
+#if defined(__LDBL_MANT_DIG__) && __LDBL_MANT_DIG__ == 113
+#define f128 long double
+#elif defined(__SIZEOF_FLOAT128__)
+#ifdef __clang__
+#define f128 __float128
+#else
+#define f128 _Float128
+#endif
+#endif
+
+#ifdef f128
+    // construct f128::MAX.
+    union cvt128 {
+        struct {
+#if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+            uint64_t hi, lo;
+#else
+            uint64_t lo, hi;
+#endif
+        } i;
+        f128 f;
+    };
+    union cvt128 f128_max;
+    f128_max.i.hi = 0x7ffeffffffffffff;
+    f128_max.i.lo = 0xffffffffffffffff;
+
+    if (RUST_HAS_F128) {
+        assert(test_rust(check_list_f128, (f128)-42.0, 0xAAAAAAAA, f128_max.f) == 0);
+    }
+#endif
+
     assert(check_varargs_0(0, 42, "Hello, World!") == 0);
 
     assert(check_varargs_1(0, 3.14, 12l, 'A', 0x1LL) == 0);
diff --git a/tests/rustdoc-html/intra-doc/inline-same-item-with-different-names.rs b/tests/rustdoc-html/intra-doc/inline-same-item-with-different-names.rs
new file mode 100644
index 0000000000000..c7801da5c98c2
--- /dev/null
+++ b/tests/rustdoc-html/intra-doc/inline-same-item-with-different-names.rs
@@ -0,0 +1,43 @@
+// This test ensures that when a same item is inlined with different names, the intra
+// doc links generate the correct href/title.
+// Regression test for <https://github.com/rust-lang/rust/issues/136777>.
+
+#![crate_name = "foo"]
+
+// We check that the macros and structs are correctly generated.
+//@ has 'foo/macro.d1.html'
+//@ has 'foo/macro.d2.html'
+//@ has 'foo/macro.d3.html'
+//@ has 'foo/struct.a1.html'
+//@ has 'foo/struct.a2.html'
+//@ has 'foo/struct.a3.html'
+
+//@ has 'foo/index.html'
+
+//@ has - '//dd/a[@href="macro.d1.html"]' 'd1'
+//@ has - '//dd/a[@title="macro foo::d1"]' 'd1'
+//@ has - '//dd/a[@href="macro.d2.html"]' 'd2'
+//@ has - '//dd/a[@title="macro foo::d2"]' 'd2'
+//@ has - '//dd/a[@href="macro.d3.html"]' 'd3'
+//@ has - '//dd/a[@title="macro foo::d3"]' 'd3'
+
+/// Link to [`d3`].
+pub use std::debug_assert as d1;
+/// Link to [`d1`].
+pub use std::debug_assert as d2;
+/// Link to [`d2`].
+pub use std::debug_assert as d3;
+
+//@ has - '//dd/a[@href="struct.a1.html"]' 'a1'
+//@ has - '//dd/a[@title="struct foo::a1"]' 'a1'
+//@ has - '//dd/a[@href="struct.a2.html"]' 'a2'
+//@ has - '//dd/a[@title="struct foo::a2"]' 'a2'
+//@ has - '//dd/a[@href="struct.a3.html"]' 'a3'
+//@ has - '//dd/a[@title="struct foo::a3"]' 'a3'
+
+/// Link to [`a3`].
+pub use std::ffi::os_str::OsString as a1;
+/// Link to [`a1`].
+pub use std::ffi::os_str::OsString as a2;
+/// Link to [`a2`].
+pub use std::ffi::os_str::OsString as a3;
diff --git a/tests/ui/abi/abi-sysv64-arg-passing.rs b/tests/ui/abi/abi-sysv64-arg-passing.rs
index 362a1862f9d4c..e21ca94aa6e8f 100644
--- a/tests/ui/abi/abi-sysv64-arg-passing.rs
+++ b/tests/ui/abi/abi-sysv64-arg-passing.rs
@@ -34,7 +34,6 @@
 // the sysv64 ABI on Windows.
 
 #[allow(dead_code)]
-#[allow(improper_ctypes)]
 
 #[cfg(target_arch = "x86_64")]
 mod tests {
@@ -87,6 +86,7 @@ mod tests {
     #[derive(Copy, Clone)]
     pub struct Quad { a: u64, b: u64, c: u64, d: u64 }
 
+    #[repr(C)]
     #[derive(Copy, Clone)]
     pub struct QuadFloats { a: f32, b: f32, c: f32, d: f32 }
 
@@ -113,6 +113,7 @@ mod tests {
         pub fn rust_dbg_extern_identity_u32(v: u32) -> u32;
         pub fn rust_dbg_extern_identity_u64(v: u64) -> u64;
         pub fn rust_dbg_extern_identity_double(v: f64) -> f64;
+        #[expect(improper_ctypes)]
         pub fn rust_dbg_extern_empty_struct(v1: ManyInts, e: Empty, v2: ManyInts);
         pub fn rust_dbg_extern_identity_TwoU8s(v: TwoU8s) -> TwoU8s;
         pub fn rust_dbg_extern_identity_TwoU16s(v: TwoU16s) -> TwoU16s;
diff --git a/tests/ui/abi/abi-sysv64-register-usage.rs b/tests/ui/abi/abi-sysv64-register-usage.rs
index cf1620db6f7be..576af8e696438 100644
--- a/tests/ui/abi/abi-sysv64-register-usage.rs
+++ b/tests/ui/abi/abi-sysv64-register-usage.rs
@@ -45,11 +45,11 @@ pub extern "sysv64" fn all_the_registers(
 // this struct contains 8 i64's, while only 6 can be passed in registers.
 #[cfg(target_arch = "x86_64")]
 #[derive(PartialEq, Eq, Debug)]
+#[repr(C)]
 pub struct LargeStruct(i64, i64, i64, i64, i64, i64, i64, i64);
 
 #[cfg(target_arch = "x86_64")]
 #[inline(never)]
-#[allow(improper_ctypes_definitions)]
 pub extern "sysv64" fn large_struct_by_val(mut foo: LargeStruct) -> LargeStruct {
     foo.0 *= 1;
     foo.1 *= 2;
diff --git a/tests/ui/abi/arm-unadjusted-intrinsic.rs b/tests/ui/abi/arm-unadjusted-intrinsic.rs
index f20fda4c61534..4340369d5ecc7 100644
--- a/tests/ui/abi/arm-unadjusted-intrinsic.rs
+++ b/tests/ui/abi/arm-unadjusted-intrinsic.rs
@@ -28,7 +28,7 @@ impl Copy for int8x16x4_t {}
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 pub unsafe fn vld1q_s8_x4(a: *const i8) -> int8x16x4_t {
-    #[allow(improper_ctypes)]
+    #[expect(improper_ctypes)]
     extern "llvm-intrinsic" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vld1x4.v16i8.p0i8")]
         #[cfg_attr(target_arch = "aarch64", link_name = "llvm.aarch64.neon.ld1x4.v16i8.p0i8")]
diff --git a/tests/ui/abi/compatibility.rs b/tests/ui/abi/compatibility.rs
index e2496726f4b3f..c0a124208b21e 100644
--- a/tests/ui/abi/compatibility.rs
+++ b/tests/ui/abi/compatibility.rs
@@ -89,7 +89,7 @@
 #![feature(no_core, rustc_attrs, lang_items)]
 #![feature(unsized_fn_params, transparent_unions)]
 #![no_core]
-#![allow(unused, improper_ctypes_definitions, internal_features)]
+#![expect(unused, improper_ctypes_definitions, internal_features)]
 
 // FIXME: some targets are broken in various ways.
 // Hence there are `cfg` throughout this test to disable parts of it on those targets.
diff --git a/tests/ui/abi/extern-c-two-doubles-x86_64-5754.rs b/tests/ui/abi/extern-c-two-doubles-x86_64-5754.rs
index 7f44ef9c68535..5b278f2506a24 100644
--- a/tests/ui/abi/extern-c-two-doubles-x86_64-5754.rs
+++ b/tests/ui/abi/extern-c-two-doubles-x86_64-5754.rs
@@ -1,8 +1,8 @@
 // https://github.com/rust-lang/rust/issues/5754
 //@ build-pass
 #![allow(dead_code)]
-#![allow(improper_ctypes)]
 
+#[repr(C)]
 struct TwoDoubles {
     r: f64,
     i: f64
diff --git a/tests/ui/abi/extern/extern-c-method-return-struct.rs b/tests/ui/abi/extern/extern-c-method-return-struct.rs
index 679f0b37758ab..08cfe495ba2a3 100644
--- a/tests/ui/abi/extern/extern-c-method-return-struct.rs
+++ b/tests/ui/abi/extern/extern-c-method-return-struct.rs
@@ -2,13 +2,14 @@
 //@ build-pass
 
 #![allow(dead_code)]
+
+#[repr(C)]
 pub struct Foo {
     x: isize,
     y: isize
 }
 
 impl Foo {
-    #[allow(improper_ctypes_definitions)]
     pub extern "C" fn foo_new() -> Foo {
         Foo { x: 21, y: 33 }
     }
diff --git a/tests/ui/abi/extern/extern-pass-FiveU16s.rs b/tests/ui/abi/extern/extern-pass-FiveU16s.rs
index 5f1307beb28e6..48edb8d4a5a92 100644
--- a/tests/ui/abi/extern/extern-pass-FiveU16s.rs
+++ b/tests/ui/abi/extern/extern-pass-FiveU16s.rs
@@ -1,5 +1,4 @@
 //@ run-pass
-#![allow(improper_ctypes)]
 
 // Test a foreign function that accepts and returns a struct by value.
 
@@ -8,6 +7,7 @@
 // sizes, causing there to be padding in the last element.
 
 #[derive(Copy, Clone, PartialEq, Debug)]
+#[repr(C)]
 pub struct FiveU16s {
     one: u16,
     two: u16,
diff --git a/tests/ui/abi/extern/extern-pass-TwoU16s.rs b/tests/ui/abi/extern/extern-pass-TwoU16s.rs
index 8bde553050a40..47dd0674ae439 100644
--- a/tests/ui/abi/extern/extern-pass-TwoU16s.rs
+++ b/tests/ui/abi/extern/extern-pass-TwoU16s.rs
@@ -1,10 +1,10 @@
 //@ run-pass
-#![allow(improper_ctypes)]
 
 // Test a foreign function that accepts and returns a struct
 // by value.
 
 #[derive(Copy, Clone, PartialEq, Debug)]
+#[repr(C)]
 pub struct TwoU16s {
     one: u16,
     two: u16,
diff --git a/tests/ui/abi/extern/extern-pass-TwoU32s.rs b/tests/ui/abi/extern/extern-pass-TwoU32s.rs
index fc90eb6945c7e..f7d9459e8f82f 100644
--- a/tests/ui/abi/extern/extern-pass-TwoU32s.rs
+++ b/tests/ui/abi/extern/extern-pass-TwoU32s.rs
@@ -1,10 +1,10 @@
 //@ run-pass
-#![allow(improper_ctypes)]
 
 // Test a foreign function that accepts and returns a struct
 // by value.
 
 #[derive(Copy, Clone, PartialEq, Debug)]
+#[repr(C)]
 pub struct TwoU32s {
     one: u32,
     two: u32,
diff --git a/tests/ui/abi/extern/extern-pass-TwoU64s.rs b/tests/ui/abi/extern/extern-pass-TwoU64s.rs
index 603de2e49ab2d..dbce8690d78cd 100644
--- a/tests/ui/abi/extern/extern-pass-TwoU64s.rs
+++ b/tests/ui/abi/extern/extern-pass-TwoU64s.rs
@@ -1,10 +1,10 @@
 //@ run-pass
-#![allow(improper_ctypes)]
 
 // Test a foreign function that accepts and returns a struct
 // by value.
 
 #[derive(Copy, Clone, PartialEq, Debug)]
+#[repr(C)]
 pub struct TwoU64s {
     one: u64,
     two: u64,
diff --git a/tests/ui/abi/extern/extern-pass-TwoU8s.rs b/tests/ui/abi/extern/extern-pass-TwoU8s.rs
index a712d79a98dd2..56db34dcefea7 100644
--- a/tests/ui/abi/extern/extern-pass-TwoU8s.rs
+++ b/tests/ui/abi/extern/extern-pass-TwoU8s.rs
@@ -1,10 +1,10 @@
 //@ run-pass
-#![allow(improper_ctypes)]
 
 // Test a foreign function that accepts and returns a struct
 // by value.
 
 #[derive(Copy, Clone, PartialEq, Debug)]
+#[repr(C)]
 pub struct TwoU8s {
     one: u8,
     two: u8,
diff --git a/tests/ui/abi/extern/extern-pass-empty.rs b/tests/ui/abi/extern/extern-pass-empty.rs
index 1ad52b128ad93..707c1944cdd63 100644
--- a/tests/ui/abi/extern/extern-pass-empty.rs
+++ b/tests/ui/abi/extern/extern-pass-empty.rs
@@ -1,5 +1,5 @@
 //@ run-pass
-#![allow(improper_ctypes)] // FIXME: this test is inherently not FFI-safe.
+#![expect(improper_ctypes)] // FIXME: this test is inherently not FFI-safe.
 
 // Test a foreign function that accepts empty struct.
 
diff --git a/tests/ui/abi/extern/extern-return-FiveU16s.rs b/tests/ui/abi/extern/extern-return-FiveU16s.rs
index d8ae8b2661c5a..d0566de1e6975 100644
--- a/tests/ui/abi/extern/extern-return-FiveU16s.rs
+++ b/tests/ui/abi/extern/extern-return-FiveU16s.rs
@@ -1,6 +1,6 @@
 //@ run-pass
-#![allow(improper_ctypes)]
 
+#[repr(C)]
 pub struct FiveU16s {
     one: u16,
     two: u16,
diff --git a/tests/ui/abi/extern/extern-return-TwoU16s.rs b/tests/ui/abi/extern/extern-return-TwoU16s.rs
index bf909a8db24c7..601daf35b4ea9 100644
--- a/tests/ui/abi/extern/extern-return-TwoU16s.rs
+++ b/tests/ui/abi/extern/extern-return-TwoU16s.rs
@@ -1,6 +1,6 @@
 //@ run-pass
-#![allow(improper_ctypes)]
 
+#[repr(C)]
 pub struct TwoU16s {
     one: u16,
     two: u16,
diff --git a/tests/ui/abi/extern/extern-return-TwoU32s.rs b/tests/ui/abi/extern/extern-return-TwoU32s.rs
index c528da8cfc464..9f81286009959 100644
--- a/tests/ui/abi/extern/extern-return-TwoU32s.rs
+++ b/tests/ui/abi/extern/extern-return-TwoU32s.rs
@@ -1,6 +1,6 @@
 //@ run-pass
-#![allow(improper_ctypes)]
 
+#[repr(C)]
 pub struct TwoU32s {
     one: u32,
     two: u32,
diff --git a/tests/ui/abi/extern/extern-return-TwoU64s.rs b/tests/ui/abi/extern/extern-return-TwoU64s.rs
index d4f9540ec7b35..a7dd142ffbc0d 100644
--- a/tests/ui/abi/extern/extern-return-TwoU64s.rs
+++ b/tests/ui/abi/extern/extern-return-TwoU64s.rs
@@ -1,6 +1,6 @@
 //@ run-pass
-#![allow(improper_ctypes)]
 
+#[repr(C)]
 pub struct TwoU64s {
     one: u64,
     two: u64,
diff --git a/tests/ui/abi/extern/extern-return-TwoU8s.rs b/tests/ui/abi/extern/extern-return-TwoU8s.rs
index 228b27396249b..5f2d0418fd166 100644
--- a/tests/ui/abi/extern/extern-return-TwoU8s.rs
+++ b/tests/ui/abi/extern/extern-return-TwoU8s.rs
@@ -1,6 +1,6 @@
 //@ run-pass
-#![allow(improper_ctypes)]
 
+#[repr(C)]
 pub struct TwoU8s {
     one: u8,
     two: u8,
diff --git a/tests/ui/abi/foreign/foreign-fn-with-byval.rs b/tests/ui/abi/foreign/foreign-fn-with-byval.rs
index 9908ec2d2c01a..d5f87c1a804b5 100644
--- a/tests/ui/abi/foreign/foreign-fn-with-byval.rs
+++ b/tests/ui/abi/foreign/foreign-fn-with-byval.rs
@@ -1,7 +1,7 @@
 //@ run-pass
-#![allow(improper_ctypes, improper_ctypes_definitions)]
 
 #[derive(Copy, Clone)]
+#[repr(C)]
 pub struct S {
     x: u64,
     y: u64,
diff --git a/tests/ui/abi/issue-28676.rs b/tests/ui/abi/issue-28676.rs
index 2abb4ce52b3b3..616ed6bde24b1 100644
--- a/tests/ui/abi/issue-28676.rs
+++ b/tests/ui/abi/issue-28676.rs
@@ -2,9 +2,9 @@
 //@ ignore-backends: gcc
 
 #![allow(dead_code)]
-#![allow(improper_ctypes)]
 
 #[derive(Copy, Clone)]
+#[repr(C)]
 pub struct Quad {
     a: u64,
     b: u64,
diff --git a/tests/ui/abi/issues/issue-62350-sysv-neg-reg-counts.rs b/tests/ui/abi/issues/issue-62350-sysv-neg-reg-counts.rs
index 314db42280d99..578381dcd32d1 100644
--- a/tests/ui/abi/issues/issue-62350-sysv-neg-reg-counts.rs
+++ b/tests/ui/abi/issues/issue-62350-sysv-neg-reg-counts.rs
@@ -1,8 +1,8 @@
 //@ run-pass
 #![allow(dead_code)]
-#![allow(improper_ctypes)]
 
 #[derive(Copy, Clone)]
+#[repr(C)]
 pub struct QuadFloats {
     a: f32,
     b: f32,
diff --git a/tests/ui/abi/issues/issue-97463-broken-abi-leaked-uninit-data.rs b/tests/ui/abi/issues/issue-97463-broken-abi-leaked-uninit-data.rs
index f694205174889..fa8ac0bfe594a 100644
--- a/tests/ui/abi/issues/issue-97463-broken-abi-leaked-uninit-data.rs
+++ b/tests/ui/abi/issues/issue-97463-broken-abi-leaked-uninit-data.rs
@@ -1,6 +1,4 @@
 //@ run-pass
-#![allow(dead_code)]
-#![allow(improper_ctypes)]
 
 #[link(name = "rust_test_helpers", kind = "static")]
 extern "C" {
diff --git a/tests/ui/abi/large-byval-align.rs b/tests/ui/abi/large-byval-align.rs
index 69418e1cbc7b8..7e640fb42a3cb 100644
--- a/tests/ui/abi/large-byval-align.rs
+++ b/tests/ui/abi/large-byval-align.rs
@@ -3,10 +3,9 @@
 //@ build-pass
 //@ ignore-backends: gcc
 
-#[repr(align(536870912))]
+#[repr(C, align(536870912))]
 pub struct A(i64);
 
-#[allow(improper_ctypes_definitions)]
 pub extern "C" fn foo(x: A) {}
 
 fn main() {
diff --git a/tests/ui/abi/non-rustic-unsized.rs b/tests/ui/abi/non-rustic-unsized.rs
index d26c4af72ccaf..fa22f91afeb67 100644
--- a/tests/ui/abi/non-rustic-unsized.rs
+++ b/tests/ui/abi/non-rustic-unsized.rs
@@ -3,7 +3,7 @@
 #![no_core]
 #![crate_type = "lib"]
 #![feature(no_core, unsized_fn_params)]
-#![allow(improper_ctypes_definitions, improper_ctypes)]
+#![expect(improper_ctypes_definitions, improper_ctypes)]
 
 extern crate minicore;
 use minicore::*;
diff --git a/tests/ui/abi/simd-abi-checks-avx.rs b/tests/ui/abi/simd-abi-checks-avx.rs
index 7432381d15b72..e47346d02ea59 100644
--- a/tests/ui/abi/simd-abi-checks-avx.rs
+++ b/tests/ui/abi/simd-abi-checks-avx.rs
@@ -4,7 +4,7 @@
 
 #![feature(portable_simd)]
 #![feature(simd_ffi)]
-#![allow(improper_ctypes_definitions)]
+#![expect(improper_ctypes_definitions)]
 
 use std::arch::x86_64::*;
 
diff --git a/tests/ui/abi/simd-abi-checks-s390x.rs b/tests/ui/abi/simd-abi-checks-s390x.rs
index 8ca3d2f457899..95028b8286d55 100644
--- a/tests/ui/abi/simd-abi-checks-s390x.rs
+++ b/tests/ui/abi/simd-abi-checks-s390x.rs
@@ -15,7 +15,7 @@
 #![feature(no_core)]
 #![no_core]
 #![crate_type = "lib"]
-#![allow(non_camel_case_types, improper_ctypes_definitions)]
+#![expect(improper_ctypes_definitions)]
 
 extern crate minicore;
 use minicore::simd::*;
diff --git a/tests/ui/abi/simd-abi-checks-sse.rs b/tests/ui/abi/simd-abi-checks-sse.rs
index 906b6ec65610e..4ed4b78166f9e 100644
--- a/tests/ui/abi/simd-abi-checks-sse.rs
+++ b/tests/ui/abi/simd-abi-checks-sse.rs
@@ -9,7 +9,7 @@
 //@ dont-require-annotations: NOTE
 #![feature(no_core)]
 #![no_core]
-#![allow(improper_ctypes_definitions)]
+#![expect(improper_ctypes_definitions)]
 
 extern crate minicore;
 use minicore::simd::Simd;
diff --git a/tests/ui/abi/unsized-args-in-c-abi-issues-94223-115845.rs b/tests/ui/abi/unsized-args-in-c-abi-issues-94223-115845.rs
index 7d21307e1b2d9..f0f6bb3f765b2 100644
--- a/tests/ui/abi/unsized-args-in-c-abi-issues-94223-115845.rs
+++ b/tests/ui/abi/unsized-args-in-c-abi-issues-94223-115845.rs
@@ -1,5 +1,5 @@
 //@ check-pass
-#![allow(improper_ctypes_definitions)]
+#![expect(improper_ctypes_definitions)]
 #![feature(unsized_fn_params)]
 #![crate_type = "lib"]
 
diff --git a/tests/ui/c-variadic/roundtrip.rs b/tests/ui/c-variadic/roundtrip.rs
index 9fa55c36e2441..1fb96ab7cfad7 100644
--- a/tests/ui/c-variadic/roundtrip.rs
+++ b/tests/ui/c-variadic/roundtrip.rs
@@ -5,7 +5,8 @@
     c_variadic_va_arg_safe,
     c_variadic_int128,
     const_destruct,
-    const_raw_ptr_comparison
+    const_raw_ptr_comparison,
+    f128
 )]
 #![allow(unused_features)] // c_variadic_int128 is only used on 64-bit targets.
 
@@ -113,7 +114,38 @@ fn main() {
                 roundtrip!(i128, -1, -2);
                 roundtrip!(u128, 1, 2);
             }
-            _ => {}
+            _ => { /* unsupported */ }
+        }
+
+        cfg_select! {
+            any(
+                all(
+                    any(target_arch = "x86_64", target_arch = "x86"),
+                    not(target_vendor = "apple"),
+                    not(target_env = "msvc")
+                ),
+                all(target_arch = "powerpc64", target_feature = "vsx"),
+                all(
+                    not(windows),
+                    not(target_vendor = "apple"),
+                    any(
+                        target_arch = "aarch64",
+                        target_arch = "loongarch32",
+                        target_arch = "loongarch64",
+                        target_arch = "mips64",
+                        target_arch = "mips64r6",
+                        target_arch = "riscv64",
+                        target_arch = "s390x",
+                        target_arch = "sparc",
+                        target_arch = "sparc64",
+                        target_arch = "wasm32",
+                        target_arch = "wasm64",
+                    ),
+                ),
+            ) => {
+                roundtrip!(f128, -1.0, f128::MAX);
+            }
+            _ => { /* unsupported */ }
         }
     }
 }
diff --git a/tests/ui/const-generics/mgca/inherent-alias-default.rs b/tests/ui/const-generics/mgca/inherent-alias-default.rs
new file mode 100644
index 0000000000000..9ba6d1d15e856
--- /dev/null
+++ b/tests/ui/const-generics/mgca/inherent-alias-default.rs
@@ -0,0 +1,15 @@
+//@ check-pass
+//! rustc_hir_analysis::check_item_type does type_of() on the default value. This is wonky, because
+//! the generic args are in Self format at that point, not in impl format, so the result can't be
+//! used with the Self-format args. However, it does not instantiate the result, it just does
+//! ensure_ok(). This test just makes sure that codepath is hit in tests.
+#![feature(min_generic_const_args, inherent_associated_types)]
+
+struct Struct<T1, T2, T3>(T1, T2, T3);
+impl<T1, T2, T3> Struct<T1, T2, T3> {
+    const INHERENT: usize = core::direct_const_arg!(2);
+}
+
+struct WithDefault<const N: usize = { core::direct_const_arg!(Struct::<u8, u16, u32>::INHERENT) }>;
+
+fn main() {}
diff --git a/tests/ui/ffi/ffi-struct-size-alignment.rs b/tests/ui/ffi/ffi-struct-size-alignment.rs
index 287ae7cad2b6d..00f25f0673c5c 100644
--- a/tests/ui/ffi/ffi-struct-size-alignment.rs
+++ b/tests/ui/ffi/ffi-struct-size-alignment.rs
@@ -1,12 +1,12 @@
 //@ run-pass
 #![allow(dead_code)]
-#![allow(improper_ctypes)]
 // Issue #3656
 // Incorrect struct size computation in the FFI, because of not taking
 // the alignment of elements into account.
 
 use std::ffi::{c_uint, c_void};
 
+#[repr(C)]
 pub struct KEYGEN {
     hash_algorithm: [c_uint; 2],
     count: u32,
diff --git a/tests/ui/internal/internal-unstable.rs b/tests/ui/internal/internal-unstable.rs
index 5564852e98888..41aa76dea3f7b 100644
--- a/tests/ui/internal/internal-unstable.rs
+++ b/tests/ui/internal/internal-unstable.rs
@@ -8,8 +8,7 @@ extern crate internal_unstable;
 
 struct Baz {
     #[allow_internal_unstable] //~ ERROR `allow_internal_unstable` expects a list of feature names
-    //~^ WARN cannot be used on
-    //~| WARN previously accepted
+    //~^ ERROR cannot be used on
     baz: u8,
 }
 
@@ -59,8 +58,7 @@ fn main() {
 
     match true {
         #[allow_internal_unstable] //~ ERROR `allow_internal_unstable` expects a list of feature names
-        //~^ WARN cannot be used on
-        //~| WARN previously accepted
+        //~^ ERROR cannot be used on
         _ => {}
     }
 
diff --git a/tests/ui/internal/internal-unstable.stderr b/tests/ui/internal/internal-unstable.stderr
index b816dc6f7454c..924d512e99836 100644
--- a/tests/ui/internal/internal-unstable.stderr
+++ b/tests/ui/internal/internal-unstable.stderr
@@ -4,14 +4,30 @@ error: `allow_internal_unstable` expects a list of feature names
 LL |     #[allow_internal_unstable]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+error: the `allow_internal_unstable` attribute cannot be used on struct fields
+  --> $DIR/internal-unstable.rs:10:7
+   |
+LL |     #[allow_internal_unstable]
+   |       ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: the `allow_internal_unstable` attribute can be applied to functions and macro defs
+
 error: `allow_internal_unstable` expects a list of feature names
-  --> $DIR/internal-unstable.rs:61:9
+  --> $DIR/internal-unstable.rs:60:9
    |
 LL |         #[allow_internal_unstable]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+error: the `allow_internal_unstable` attribute cannot be used on match arms
+  --> $DIR/internal-unstable.rs:60:11
+   |
+LL |         #[allow_internal_unstable]
+   |           ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: the `allow_internal_unstable` attribute can be applied to functions and macro defs
+
 error[E0658]: use of unstable library feature `function`
-  --> $DIR/internal-unstable.rs:50:25
+  --> $DIR/internal-unstable.rs:49:25
    |
 LL |     pass_through_allow!(internal_unstable::unstable());
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -20,7 +36,7 @@ LL |     pass_through_allow!(internal_unstable::unstable());
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: use of unstable library feature `function`
-  --> $DIR/internal-unstable.rs:52:27
+  --> $DIR/internal-unstable.rs:51:27
    |
 LL |     pass_through_noallow!(internal_unstable::unstable());
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -29,7 +45,7 @@ LL |     pass_through_noallow!(internal_unstable::unstable());
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: use of unstable library feature `function`
-  --> $DIR/internal-unstable.rs:56:22
+  --> $DIR/internal-unstable.rs:55:22
    |
 LL |     println!("{:?}", internal_unstable::unstable());
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -38,7 +54,7 @@ LL |     println!("{:?}", internal_unstable::unstable());
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: use of unstable library feature `function`
-  --> $DIR/internal-unstable.rs:58:10
+  --> $DIR/internal-unstable.rs:57:10
    |
 LL |     bar!(internal_unstable::unstable());
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -47,7 +63,7 @@ LL |     bar!(internal_unstable::unstable());
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: use of unstable library feature `function`
-  --> $DIR/internal-unstable.rs:20:9
+  --> $DIR/internal-unstable.rs:19:9
    |
 LL |         internal_unstable::unstable();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -59,25 +75,6 @@ LL |     bar!(internal_unstable::unstable());
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
    = note: this error originates in the macro `foo` which comes from the expansion of the macro `bar` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-warning: the `allow_internal_unstable` attribute cannot be used on struct fields
-  --> $DIR/internal-unstable.rs:10:7
-   |
-LL |     #[allow_internal_unstable]
-   |       ^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: the `allow_internal_unstable` attribute can be applied to functions and macro defs
-   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = note: requested on the command line with `-W unused-attributes`
-
-warning: the `allow_internal_unstable` attribute cannot be used on match arms
-  --> $DIR/internal-unstable.rs:61:11
-   |
-LL |         #[allow_internal_unstable]
-   |           ^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: the `allow_internal_unstable` attribute can be applied to functions and macro defs
-   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-
-error: aborting due to 7 previous errors; 2 warnings emitted
+error: aborting due to 9 previous errors
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/intrinsics/not-overridden.stderr b/tests/ui/intrinsics/not-overridden.stderr
index ae5586b2f0a85..45c5c37318b89 100644
--- a/tests/ui/intrinsics/not-overridden.stderr
+++ b/tests/ui/intrinsics/not-overridden.stderr
@@ -5,8 +5,6 @@ LL |     unsafe { const_deallocate(std::ptr::null_mut(), 0, 0) }
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 
-error: the compiler unexpectedly panicked. This is a bug
-
 query stack during panic:
 end of query stack
 error: aborting due to 1 previous error
diff --git a/tests/ui/resolve/multiple_definitions_attribute_merging.stderr b/tests/ui/resolve/multiple_definitions_attribute_merging.stderr
index 63bdcfddf3ca2..b8b33e3417bf7 100644
--- a/tests/ui/resolve/multiple_definitions_attribute_merging.stderr
+++ b/tests/ui/resolve/multiple_definitions_attribute_merging.stderr
@@ -17,9 +17,7 @@ LL | struct Dealigned<T>(u8, T);
    |                         ^
 
 
-builtin derive created an unaligned reference
-error: the compiler unexpectedly panicked. This is a bug
-
+Box<dyn Any>
 query stack during panic:
 #0 [mir_built] building MIR for `<impl at $DIR/multiple_definitions_attribute_merging.rs:16:10: 16:19>::eq`
 #1 [check_unsafety] unsafety-checking `<impl at $DIR/multiple_definitions_attribute_merging.rs:16:10: 16:19>::eq`
diff --git a/tests/ui/resolve/proc_macro_generated_packed.stderr b/tests/ui/resolve/proc_macro_generated_packed.stderr
index 3e63abb4b9e6b..d8e160d0c6a03 100644
--- a/tests/ui/resolve/proc_macro_generated_packed.stderr
+++ b/tests/ui/resolve/proc_macro_generated_packed.stderr
@@ -8,9 +8,7 @@ LL | struct Dealigned<T>(u8, T);
    |                         ^
 
 
-builtin derive created an unaligned reference
-error: the compiler unexpectedly panicked. This is a bug
-
+Box<dyn Any>
 query stack during panic:
 #0 [mir_built] building MIR for `<impl at $DIR/proc_macro_generated_packed.rs:16:10: 16:19>::eq`
 #1 [check_unsafety] unsafety-checking `<impl at $DIR/proc_macro_generated_packed.rs:16:10: 16:19>::eq`
diff --git a/tests/ui/thir-print/str-patterns.stdout b/tests/ui/thir-print/str-patterns.stdout
index da1f86b8fc591..61bcbaef5029a 100644
--- a/tests/ui/thir-print/str-patterns.stdout
+++ b/tests/ui/thir-print/str-patterns.stdout
@@ -46,7 +46,9 @@ Thir {
                 extra: Some(
                     PatExtra {
                         expanded_const: Some(
-                            DefId(0:4 ~ str_patterns[fc71]::CONSTANT),
+                            Free {
+                                def_id: DefId(0:4 ~ str_patterns[fc71]::CONSTANT),
+                            },
                         ),
                         ascriptions: [],
                     },
diff --git a/tests/ui/track-diagnostics/track7.rs b/tests/ui/track-diagnostics/track7.rs
new file mode 100644
index 0000000000000..f43c1e1a81c23
--- /dev/null
+++ b/tests/ui/track-diagnostics/track7.rs
@@ -0,0 +1,40 @@
+// This test checks that -Ztrack-diagnostics reports the correct source locations for an ICE
+// triggered with `span_bug!`.
+//
+//@ compile-flags: -Zvalidate-mir -Ztrack-diagnostics
+//@ rustc-env:RUST_BACKTRACE=0
+//@ failure-status: 101
+//
+// Normalize the emitted location so this doesn't need
+// updating everytime someone adds or removes a line.
+//@ normalize-stderr: ".rs:\d+:\d+" -> ".rs:LL:CC"
+//@ normalize-stderr: "note: rustc .+ running on .+" -> "note: rustc $$VERSION running on $$TARGET"
+//@ normalize-stderr: "/rustc(?:-dev)?/[a-z0-9.]+/" -> ""
+//@ normalize-stderr: "track7\[....\]" -> "track7[HASH]"
+// The test becomes too flaky if we care about exact args. If `-Z ui-testing`
+// from compiletest and `-Z track-diagnostics` from `// compile-flags` at the
+// top of this file are present, then assume all args are present.
+//@ normalize-stderr: "note: compiler flags: .*-Z ui-testing.*-Z track-diagnostics" -> "note: compiler flags: ... -Z ui-testing ... -Z track-diagnostics"
+
+#![feature(custom_mir, core_intrinsics)]
+extern crate core;
+use core::intrinsics::mir::*;
+
+fn bar(_x: i32) {}
+
+// Use of `mir!` here is just because it's an easy way to trigger a `span_bug!`.
+#[custom_mir(dialect = "built")]
+pub fn main() {
+    mir! {
+        let a: (i32, i32);
+        {
+            a = (1, 2);
+            Call(RET = bar(Move(a.0)), ReturnTo(retblock), UnwindContinue())
+            //~^ ERROR broken MIR in
+            //~| ERROR encountered `Move` of a non-local, non-box place in `Call` terminator
+        }
+        retblock = {
+            Return()
+        }
+    }
+}
diff --git a/tests/ui/track-diagnostics/track7.stderr b/tests/ui/track-diagnostics/track7.stderr
new file mode 100644
index 0000000000000..61a615f782b8e
--- /dev/null
+++ b/tests/ui/track-diagnostics/track7.stderr
@@ -0,0 +1,26 @@
+error: internal compiler error: compiler/rustc_mir_transform/src/validate.rs:LL:CC: broken MIR in Item(DefId(0:6 ~ track7[HASH]::main)) (after pass LintAndRemoveUninhabited) at bb0[1]:
+                                encountered `Move` of a non-local, non-box place in `Call` terminator: _0 = bar(move (_1.0: i32)) -> [return: bb1, unwind continue]
+  --> $DIR/track7.rs:LL:CC
+   |
+LL |             Call(RET = bar(Move(a.0)), ReturnTo(retblock), UnwindContinue())
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: -Ztrack-diagnostics: created at compiler/rustc_mir_transform/src/validate.rs:LL:CC
+
+
+thread 'rustc' ($TID) panicked at compiler/rustc_mir_transform/src/validate.rs:LL:CC:
+Box<dyn Any>
+note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
+
+note: using internal features is not supported and expected to cause internal compiler errors when used incorrectly
+
+note: rustc $VERSION running on $TARGET
+
+note: compiler flags: ... -Z ui-testing ... -Z track-diagnostics
+
+query stack during panic:
+#0 [mir_built] building MIR for `main`
+#1 [has_ffi_unwind_calls] checking if `main` contains FFI-unwind calls
+... and 3 other queries... use `env RUST_BACKTRACE=1` to see the full query stack
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/traits/block-scoped-trait-import-issue-134146.rs b/tests/ui/traits/block-scoped-trait-import-issue-134146.rs
new file mode 100644
index 0000000000000..0a9874c281d67
--- /dev/null
+++ b/tests/ui/traits/block-scoped-trait-import-issue-134146.rs
@@ -0,0 +1,59 @@
+//! Regression test for https://github.com/rust-lang/rust/issues/134146.
+//! Traits declared inside bodies cannot be imported through their enclosing function or const.
+
+#![allow(dead_code)]
+
+fn main() {
+    {
+        trait Hello {
+            fn hello(&self) {
+                println!("hello world");
+            }
+        }
+        impl<T> Hello for T {}
+    }
+
+    ().hello();
+    //~^ ERROR no method named `hello` found
+}
+
+fn nested_module() {
+    mod inner {
+        pub trait Nested {
+            fn nested(&self) {}
+        }
+        impl Nested for () {}
+    }
+}
+
+fn use_nested() {
+    ().nested();
+    //~^ ERROR no method named `nested` found
+}
+
+const _: () = {
+    trait InConst {
+        fn in_const(&self) {}
+    }
+    impl InConst for () {}
+};
+
+fn use_const() {
+    ().in_const();
+    //~^ ERROR no method named `in_const` found
+}
+
+fn multiple_candidates() {
+    {
+        trait First {
+            fn several(&self) {}
+        }
+        trait Second {
+            fn several(&self) {}
+        }
+        impl First for () {}
+        impl Second for () {}
+    }
+    ().several();
+    //~^ ERROR no method named `several` found
+}
diff --git a/tests/ui/traits/block-scoped-trait-import-issue-134146.stderr b/tests/ui/traits/block-scoped-trait-import-issue-134146.stderr
new file mode 100644
index 0000000000000..41827953bb796
--- /dev/null
+++ b/tests/ui/traits/block-scoped-trait-import-issue-134146.stderr
@@ -0,0 +1,50 @@
+error[E0599]: no method named `hello` found for unit type `()` in the current scope
+  --> $DIR/block-scoped-trait-import-issue-134146.rs:16:8
+   |
+LL |             fn hello(&self) {
+   |                ----- the method is available for `()` here
+...
+LL |     ().hello();
+   |        ^^^^^ method not found in `()`
+   |
+   = help: items from traits can only be used if the trait is in scope
+   = help: trait `main::Hello` which provides `hello` is implemented but not reachable
+
+error[E0599]: no method named `nested` found for unit type `()` in the current scope
+  --> $DIR/block-scoped-trait-import-issue-134146.rs:30:8
+   |
+LL |             fn nested(&self) {}
+   |                ------ the method is available for `()` here
+...
+LL |     ().nested();
+   |        ^^^^^^ method not found in `()`
+   |
+   = help: items from traits can only be used if the trait is in scope
+   = help: trait `nested_module::inner::Nested` which provides `nested` is implemented but not reachable
+
+error[E0599]: no method named `in_const` found for unit type `()` in the current scope
+  --> $DIR/block-scoped-trait-import-issue-134146.rs:42:8
+   |
+LL |         fn in_const(&self) {}
+   |            -------- the method is available for `()` here
+...
+LL |     ().in_const();
+   |        ^^^^^^^^ method not found in `()`
+   |
+   = help: items from traits can only be used if the trait is in scope
+   = help: trait `_::InConst` which provides `in_const` is implemented but not reachable
+
+error[E0599]: no method named `several` found for unit type `()` in the current scope
+  --> $DIR/block-scoped-trait-import-issue-134146.rs:57:8
+   |
+LL |     ().several();
+   |        ^^^^^^^ method not found in `()`
+   |
+   = help: items from traits can only be used if the trait is in scope
+   = help: the following traits which provide `several` are implemented but not reachable:
+           multiple_candidates::First
+           multiple_candidates::Second
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0599`.
diff --git a/triagebot.toml b/triagebot.toml
index 4f2d0a262fdc1..475cf6e044f9b 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -850,7 +850,7 @@ zulip_stream = 542373 # #t-libs/backports
 topic = "#{number}: beta-nominated"
 message_on_add = [
     """\
-@*T-libs-fcp* PR #{number} "{title}" has been nominated for beta backport.
+@*T-libs-ping* PR #{number} "{title}" has been nominated for beta backport.
 """,
     """\
 /poll Should #{number} be beta backported?
@@ -874,7 +874,7 @@ zulip_stream = 542373 # #t-libs/backports
 topic = "#{number}: stable-nominated"
 message_on_add = [
     """\
-@*T-libs-fcp* PR #{number} "{title}" has been nominated for stable backport.
+@*T-libs-ping* PR #{number} "{title}" has been nominated for stable backport.
 """,
     """\
 /poll Approve stable backport of #{number}?
diff --git a/yarn.lock b/yarn.lock
index 55c862d1e75dd..e49c9209142f9 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -154,10 +154,10 @@ braces@^3.0.3:
   dependencies:
     fill-range "^7.1.1"
 
-browser-ui-test@^0.25.0:
-  version "0.25.1"
-  resolved "https://registry.yarnpkg.com/browser-ui-test/-/browser-ui-test-0.25.1.tgz#c7f22a5e2b9e51be4ba34df3adf7bd7a9249bce6"
-  integrity sha512-woRwKU1dPBIwYmCI6npox8qlPO0WQ8GZH2YbL39mNkiWymByebiB4EK0PlaGMbmEja0MEqfMQD+d33LCW4S2AA==
+browser-ui-test@^0.25.2:
+  version "0.25.2"
+  resolved "https://registry.yarnpkg.com/browser-ui-test/-/browser-ui-test-0.25.2.tgz#31db7386497b3eef4d79e236bd2091c1162148a9"
+  integrity sha512-74njL1/xjg5UumbhQblWa6oAn/PcaOnlJmoSe9FabJaXrLsI2f8DJ3B8vunvCJwZa90V4Jm94xyg/JPi+l+zZQ==
   dependencies:
     css-unit-converter "^1.1.2"
     pngjs "^3.4.0"