diff --git a/compiler/rustc_ast/src/token.rs b/compiler/rustc_ast/src/token.rs
index efa2a008e65ae..0144aabb24413 100644
--- a/compiler/rustc_ast/src/token.rs
+++ b/compiler/rustc_ast/src/token.rs
@@ -308,8 +308,13 @@ impl LitKind {
 }
 
 pub fn ident_can_begin_expr(name: Symbol, span: Span, is_raw: IdentIsRaw) -> bool {
+    // WARNING: Take care when modifying this function! It will change the stable(!) set of
+    //          tokens that are allowed to match an `expr` nonterminal which is user observable.
+
     let ident_token = Token::new(Ident(name, is_raw), span);
 
+    // FIXME: Remove `box` from this list given we officially no longer support box expressions
+    //        (#108471) (needs lang FCP as it affects stable macro matching behavior).
     !ident_token.is_reserved_ident()
         || ident_token.is_path_segment_keyword()
         || [
@@ -340,6 +345,9 @@ pub fn ident_can_begin_expr(name: Symbol, span: Span, is_raw: IdentIsRaw) -> boo
 }
 
 fn ident_can_begin_type(name: Symbol, span: Span, is_raw: IdentIsRaw) -> bool {
+    // WARNING: Take care when modifying this function! It will change the stable(!) set of
+    //          tokens that are allowed to match an `ty` nonterminal which is user observable.
+
     let ident_token = Token::new(Ident(name, is_raw), span);
 
     !ident_token.is_reserved_ident()
@@ -661,10 +669,10 @@ impl Token {
     }
 
     /// Returns `true` if the token can appear at the start of an expression.
-    ///
-    /// **NB**: Take care when modifying this function, since it will change
-    /// the stable set of tokens that are allowed to match an expr nonterminal.
     pub fn can_begin_expr(&self) -> bool {
+        // WARNING: Take care when modifying this function! It will change the stable(!) set of
+        //          tokens that are allowed to match an `expr` nonterminal which is user observable.
+
         match self.uninterpolate().kind {
             Ident(name, is_raw)              =>
                 ident_can_begin_expr(name, self.span, is_raw), // value name or keyword
@@ -695,9 +703,10 @@ impl Token {
     }
 
     /// Returns `true` if the token can appear at the start of a pattern.
-    ///
-    /// Shamelessly borrowed from `can_begin_expr`.
     pub fn can_begin_pattern(&self, pat_kind: NtPatKind) -> bool {
+        // WARNING: Take care when modifying this function! It will change the stable(!) set of
+        //          tokens that are allowed to match an `pat` nonterminal which is user observable.
+
         match &self.uninterpolate().kind {
             // box, ref, mut, and other identifiers (can stricten)
             Ident(..) | NtIdent(..) |
@@ -727,6 +736,12 @@ impl Token {
 
     /// Returns `true` if the token can appear at the start of a type.
     pub fn can_begin_type(&self) -> bool {
+        // WARNING: Take care when modifying this function! It will change the stable(!) set of
+        //          tokens that are allowed to match an `ty` nonterminal which is user observable.
+
+        // FIXME: Arguably, `use` should be included in this list since it can begin bare trait
+        //        object types (consider `use<>+` and `use<T> + Trait` for example).
+
         match self.uninterpolate().kind {
             Ident(name, is_raw) =>
                 ident_can_begin_type(name, self.span, is_raw), // type name or keyword
diff --git a/compiler/rustc_ast_lowering/src/delegation/attributes.rs b/compiler/rustc_ast_lowering/src/delegation/attributes.rs
index 885ee0d51c730..834f85450a2cd 100644
--- a/compiler/rustc_ast_lowering/src/delegation/attributes.rs
+++ b/compiler/rustc_ast_lowering/src/delegation/attributes.rs
@@ -43,17 +43,17 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let &DelegationResolution { span, sig_id, .. } = resolution;
 
         const PARENT_ID: hir::ItemLocalId = hir::ItemLocalId::ZERO;
-        let new_attrs = self.create_new_attrs(span, sig_id, self.attrs.get(&PARENT_ID));
+        let new_attrs = self.create_new_attrs(span, sig_id, self.curr_owner.attrs.get(&PARENT_ID));
 
         if !new_attrs.is_empty() {
-            let new_attrs = match self.attrs.get(&PARENT_ID) {
+            let new_attrs = match self.curr_owner.attrs.get(&PARENT_ID) {
                 Some(existing_attrs) => self.arena.alloc_from_iter(
                     existing_attrs.iter().map(|a| a.clone()).chain(new_attrs.into_iter()),
                 ),
                 None => self.arena.alloc_from_iter(new_attrs.into_iter()),
             };
 
-            self.attrs.insert(PARENT_ID, new_attrs);
+            self.curr_owner.attrs.insert(PARENT_ID, new_attrs);
         }
     }
 
diff --git a/compiler/rustc_ast_lowering/src/delegation/generics.rs b/compiler/rustc_ast_lowering/src/delegation/generics.rs
index 911ec5956006d..867ed364433e7 100644
--- a/compiler/rustc_ast_lowering/src/delegation/generics.rs
+++ b/compiler/rustc_ast_lowering/src/delegation/generics.rs
@@ -587,7 +587,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             };
 
             // Important: we don't use `self.next_id()` as we want to execute
-            // `lower_node_id` routine so param's id is added to `self.children`.
+            // `lower_node_id` routine so param's id is added to `self.curr_owner.children`.
             let hir_id = self.lower_node_id(node_id);
 
             Some(hir::GenericParam {
diff --git a/compiler/rustc_ast_lowering/src/delegation/mod.rs b/compiler/rustc_ast_lowering/src/delegation/mod.rs
index 3b9074e67bdd2..a92b62517e61d 100644
--- a/compiler/rustc_ast_lowering/src/delegation/mod.rs
+++ b/compiler/rustc_ast_lowering/src/delegation/mod.rs
@@ -140,9 +140,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         let id = match source {
                             DelegationSource::Single => None,
                             DelegationSource::List(expn_id) => Some(expn_id),
-                            DelegationSource::Glob => {
-                                Some(self.tcx.expn_that_defined(self.owner.def_id).expect_local())
-                            }
+                            DelegationSource::Glob => Some(
+                                self.tcx
+                                    .expn_that_defined(self.curr_owner.owner.def_id)
+                                    .expect_local(),
+                            ),
                         };
 
                         id.map(|id| (id, unused_target_expr))
@@ -335,7 +337,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let overwrites = self_resolver.overwrites;
 
         // Target expr needs to lower `self` path.
-        self.ident_and_label_to_local_id.insert(pat_node_id, param_local_id);
+        self.curr_owner.ident_and_label_to_local_id.insert(pat_node_id, param_local_id);
 
         let block = cfg_select! {
             debug_assertions => {
diff --git a/compiler/rustc_ast_lowering/src/delegation/resolution.rs b/compiler/rustc_ast_lowering/src/delegation/resolution.rs
index dd1b9518e6d7f..85604223c8509 100644
--- a/compiler/rustc_ast_lowering/src/delegation/resolution.rs
+++ b/compiler/rustc_ast_lowering/src/delegation/resolution.rs
@@ -73,7 +73,7 @@ pub(super) mod resolver {
 
         #[inline]
         pub(crate) fn owner_id(&self) -> LocalDefId {
-            self.0.owner.def_id
+            self.0.curr_owner.owner.def_id
         }
 
         /// (from `tests\ui\delegation\target-expr-removal-defs-inside.rs`):
@@ -91,7 +91,7 @@ pub(super) mod resolver {
         #[inline]
         pub(crate) fn is_definition(&self, id: NodeId) -> bool {
             self.0.resolver.owners.contains_key(&id)
-                || self.0.owner.node_id_to_def_id.contains_key(&id)
+                || self.0.curr_owner.owner.node_id_to_def_id.contains_key(&id)
         }
 
         #[inline]
diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
index 4d5b98fd1ac00..0a4a2ae7145e3 100644
--- a/compiler/rustc_ast_lowering/src/expr.rs
+++ b/compiler/rustc_ast_lowering/src/expr.rs
@@ -172,7 +172,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 }
                 // Merge attributes into the inner expression.
                 if !e.attrs.is_empty() {
-                    let old_attrs = self.attrs.get(&ex.hir_id.local_id).copied().unwrap_or(&[]);
+                    let old_attrs =
+                        self.curr_owner.attrs.get(&ex.hir_id.local_id).copied().unwrap_or(&[]);
                     let new_attrs = self
                         .lower_attrs_vec(&e.attrs, e.span, ex.hir_id, Target::from_expr(e))
                         .into_iter()
@@ -181,7 +182,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     if new_attrs.is_empty() {
                         return ex;
                     }
-                    self.attrs.insert(ex.hir_id.local_id, new_attrs);
+                    self.curr_owner.attrs.insert(ex.hir_id.local_id, new_attrs);
                 }
                 return ex;
             }
@@ -884,7 +885,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     /// `inner_hir_id` in case the `async_fn_track_caller` feature is enabled.
     pub(super) fn maybe_forward_track_caller(&mut self, outer_hir_id: HirId, inner_hir_id: HirId) {
         if self.tcx.features().async_fn_track_caller()
-            && let Some(attrs) = self.attrs.get(&outer_hir_id.local_id)
+            && let Some(attrs) = self.curr_owner.attrs.get(&outer_hir_id.local_id)
             && let Some(t) = attrs.iter().find(|a| {
                 matches!(
                     a,
@@ -892,7 +893,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 )
             })
         {
-            self.attrs.insert(inner_hir_id.local_id, std::slice::from_ref(t));
+            self.curr_owner.attrs.insert(inner_hir_id.local_id, std::slice::from_ref(t));
         }
     }
 
@@ -1505,16 +1506,16 @@ impl<'hir> LoweringContext<'_, 'hir> {
         dest_hir_id: hir::HirId,
     ) -> Option<Label> {
         let label = opt_label?;
-        self.ident_and_label_to_local_id.insert(dest_id, dest_hir_id.local_id);
+        self.curr_owner.ident_and_label_to_local_id.insert(dest_id, dest_hir_id.local_id);
         Some(Label { ident: self.lower_ident(label.ident) })
     }
 
     fn lower_loop_destination(&mut self, destination: Option<(NodeId, Label)>) -> hir::Destination {
         let target_id = match destination {
             Some((id, _)) => {
-                if let Some(loop_id) = self.owner.get_label_res(id) {
-                    let local_id = self.ident_and_label_to_local_id[&loop_id];
-                    let loop_hir_id = HirId { owner: self.current_hir_id_owner, local_id };
+                if let Some(loop_id) = self.curr_owner.owner.get_label_res(id) {
+                    let local_id = self.curr_owner.ident_and_label_to_local_id[&loop_id];
+                    let loop_hir_id = HirId { owner: self.curr_owner.owner_id, local_id };
                     Ok(loop_hir_id)
                 } else {
                     Err(hir::LoopIdError::UnresolvedLabel)
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
index 1ad96d1057042..fc3fa99fa0644 100644
--- a/compiler/rustc_ast_lowering/src/item.rs
+++ b/compiler/rustc_ast_lowering/src/item.rs
@@ -61,17 +61,15 @@ impl<'hir> ItemLowerer<'_, 'hir> {
         let mut lctx = LoweringContext::new(self.tcx, self.resolver, owner);
 
         let item = f(&mut lctx);
-        debug_assert_eq!(lctx.current_hir_id_owner, item.def_id());
-
-        let info = lctx.make_owner_info(item);
 
+        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.current_hir_id_owner, CRATE_OWNER_ID);
+            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)
@@ -206,7 +204,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     }
 
     fn lower_item(&mut self, i: &Item) -> &'hir hir::Item<'hir> {
-        let owner_id = self.current_hir_id_owner;
+        let owner_id = self.curr_owner.owner_id;
         let hir_id: HirId = owner_id.into();
         let vis_span = self.lower_span(i.vis.span);
 
@@ -399,7 +397,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                             ty,
                             ImplTraitContext::OpaqueTy {
                                 origin: hir::OpaqueTyOrigin::TyAlias {
-                                    parent: this.owner.def_id,
+                                    parent: this.curr_owner.owner.def_id,
                                     in_assoc_ty: false,
                                 },
                             },
@@ -547,7 +545,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 def_id = self.owner.def_id;
+                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 {
                     unreachable!(
@@ -695,7 +693,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         // `ItemLocalId` and the new owner. (See `lower_node_id`)
                         let kind = this.lower_use_tree(use_tree, &prefix, id, vis_span, attrs);
                         if !attrs.is_empty() {
-                            this.attrs.insert(hir::ItemLocalId::ZERO, attrs);
+                            this.curr_owner.attrs.insert(hir::ItemLocalId::ZERO, attrs);
                         }
 
                         let item = hir::Item {
@@ -731,7 +729,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     }
 
     fn lower_foreign_item(&mut self, i: &ForeignItem) -> &'hir hir::ForeignItem<'hir> {
-        let owner_id = self.current_hir_id_owner;
+        let owner_id = self.curr_owner.owner_id;
         let hir_id: HirId = owner_id.into();
         let attrs =
             self.lower_attrs(hir_id, &i.attrs, i.span, Target::from_foreign_item_kind(&i.kind));
@@ -914,7 +912,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     }
 
     fn lower_trait_item(&mut self, i: &AssocItem) -> &'hir hir::TraitItem<'hir> {
-        let trait_item_def_id = self.current_hir_id_owner;
+        let trait_item_def_id = self.curr_owner.owner_id;
         let hir_id: HirId = trait_item_def_id.into();
         let attrs = self.lower_attrs(
             hir_id,
@@ -1169,7 +1167,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     }
 
     fn lower_impl_item(&mut self, i: &AssocItem) -> &'hir hir::ImplItem<'hir> {
-        let owner_id = self.current_hir_id_owner;
+        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);
         let is_in_trait_impl =
@@ -1258,7 +1256,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                                     ty,
                                     ImplTraitContext::OpaqueTy {
                                         origin: hir::OpaqueTyOrigin::TyAlias {
-                                            parent: this.owner.def_id,
+                                            parent: this.curr_owner.owner.def_id,
                                             in_assoc_ty: true,
                                         },
                                     },
@@ -1336,8 +1334,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
     ) -> hir::BodyId {
         let body = hir::Body { params, value: self.arena.alloc(value) };
         let id = body.id();
-        assert_eq!(id.hir_id.owner, self.current_hir_id_owner);
-        self.bodies.push((id.hir_id.local_id, self.arena.alloc(body)));
+        assert_eq!(id.hir_id.owner, self.curr_owner.owner_id);
+        self.curr_owner.bodies.push((id.hir_id.local_id, self.arena.alloc(body)));
         id
     }
 
@@ -1545,7 +1543,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             //
             // If this is the simple case, this parameter will end up being the same as the
             // original parameter, but with a different pattern id.
-            let stmt_attrs = self.attrs.get(&parameter.hir_id.local_id).copied();
+            let stmt_attrs = self.curr_owner.attrs.get(&parameter.hir_id.local_id).copied();
             let (new_parameter_pat, new_parameter_id) = self.pat_ident(desugared_span, ident);
             let new_parameter = hir::Param {
                 hir_id: parameter.hir_id,
@@ -1883,8 +1881,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
         itctx: ImplTraitContext,
         f: impl FnOnce(&mut Self) -> T,
     ) -> (&'hir hir::Generics<'hir>, T) {
-        assert!(self.impl_trait_defs.is_empty());
-        assert!(self.impl_trait_bounds.is_empty());
+        assert!(self.curr_owner.impl_trait_defs.is_empty());
+        assert!(self.curr_owner.impl_trait_bounds.is_empty());
 
         let mut predicates: SmallVec<[hir::WherePredicate<'hir>; 4]> = SmallVec::new();
         // We need to make sure that generic params don't have multiple relaxed bounds for the same trait
@@ -1914,7 +1912,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             .collect();
 
         // Introduce extra lifetimes if late resolution tells us to.
-        let extra_lifetimes = self.owner.extra_lifetime_params(self.owner.id);
+        let extra_lifetimes = self.curr_owner.owner.extra_lifetime_params(self.curr_owner.owner.id);
         params.extend(extra_lifetimes.into_iter().map(|&(ident, node_id, kind)| {
             self.lifetime_res_to_generic_param(
                 ident,
@@ -1929,10 +1927,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let span = self.lower_span(generics.span);
         let res = f(self);
 
-        let impl_trait_defs = std::mem::take(&mut self.impl_trait_defs);
+        let impl_trait_defs = std::mem::take(&mut self.curr_owner.impl_trait_defs);
         params.extend(impl_trait_defs.into_iter());
 
-        let impl_trait_bounds = std::mem::take(&mut self.impl_trait_bounds);
+        let impl_trait_bounds = std::mem::take(&mut self.curr_owner.impl_trait_bounds);
         predicates.extend(impl_trait_bounds.into_iter());
 
         let lowered_generics = self.arena.alloc(hir::Generics {
@@ -1951,7 +1949,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         hir_id: HirId,
         define_opaque: &Option<ThinVec<(NodeId, Path)>>,
     ) {
-        assert_eq!(self.define_opaque, None);
+        assert_eq!(self.curr_owner.define_opaque, None);
         assert!(hir_id.is_owner());
         let Some(define_opaque) = define_opaque.as_ref() else {
             return;
@@ -1972,7 +1970,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             Some((self.lower_span(path.span), did))
         });
         let define_opaque = self.arena.alloc_from_iter(define_opaque);
-        self.define_opaque = Some(define_opaque);
+        self.curr_owner.define_opaque = Some(define_opaque);
     }
 
     pub(super) fn lower_generic_bound_predicate(
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index def0934214ef2..5b76606d101bc 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -131,36 +131,155 @@ pub(crate) mod re_lowering {
             ctx: &mut LoweringContext<'a, 'hir>,
             op: impl FnOnce(&mut LoweringContext<'a, 'hir>) -> TRes,
         ) -> TRes {
-            assert!(!ctx.relowering_checker.can_relower, "reentrant relowering is not supported");
+            assert!(
+                !ctx.curr_owner.relowering_checker.can_relower,
+                "reentrant relowering is not supported"
+            );
 
-            ctx.relowering_checker.can_relower = true;
+            ctx.curr_owner.relowering_checker.can_relower = true;
 
             let res = op(ctx);
 
-            ctx.relowering_checker.can_relower = false;
+            ctx.curr_owner.relowering_checker.can_relower = false;
 
             res
         }
     }
 }
 
-struct LoweringContext<'a, 'hir> {
-    tcx: TyCtxt<'hir>,
-    resolver: &'a ResolverAstLowering<'hir>,
-    current_disambiguator: PerParentDisambiguatorState,
+struct PerOwnerLoweringState<'a, 'hir> {
+    // -- Identity --
+    owner: &'a PerOwnerResolverData<'hir>,
+    owner_id: hir::OwnerId,
+    disambiguator: PerParentDisambiguatorState,
 
-    /// Used to allocate HIR nodes.
-    arena: &'hir hir::Arena<'hir>,
+    // -- HirId allocation --
+    item_local_id_counter: hir::ItemLocalId,
+    /// NodeIds of pattern identifiers and labelled nodes that are lowered inside the current HIR
+    /// owner.
+    ident_and_label_to_local_id: NodeMap<hir::ItemLocalId>,
+    /// NodeIds that are lowered inside the current HIR owner. Only used for duplicate lowering
+    /// check.
+    #[cfg(debug_assertions)]
+    relowering_checker: re_lowering::ReloweringChecker,
 
+    // -- Accumulated outputs --
+    /// Attributes inside the owner being lowered.
+    attrs: SortedMap<hir::ItemLocalId, &'hir [hir::Attribute]>,
     /// Bodies inside the owner being lowered.
     bodies: Vec<(hir::ItemLocalId, &'hir hir::Body<'hir>)>,
     /// `#[define_opaque]` attributes
     define_opaque: Option<&'hir [(Span, LocalDefId)]>,
-    /// Attributes inside the owner being lowered.
-    attrs: SortedMap<hir::ItemLocalId, &'hir [hir::Attribute]>,
+    trait_map: ItemLocalMap<&'hir [TraitCandidate<'hir>]>,
+    delayed_lints: Vec<DelayedLint>,
     /// Collect items that were created by lowering the current owner.
     children: LocalDefIdMap<hir::MaybeOwner<'hir>>,
 
+    // -- Transient --
+    impl_trait_defs: Vec<hir::GenericParam<'hir>>,
+    impl_trait_bounds: Vec<hir::WherePredicate<'hir>>,
+}
+
+impl<'a, 'hir> PerOwnerLoweringState<'a, 'hir> {
+    fn new(resolver: &'a ResolverAstLowering<'hir>, owner: NodeId) -> Self {
+        let owner = &resolver.owners[&owner];
+
+        let disambiguator = resolver
+            .disambiguators
+            .get(&owner.def_id)
+            .map(|s| s.steal())
+            .unwrap_or_else(|| PerParentDisambiguatorState::new(owner.def_id));
+
+        PerOwnerLoweringState {
+            owner,
+            owner_id: hir::OwnerId { def_id: owner.def_id },
+            disambiguator,
+            // 0 corresponds to `owner` lowered as `owner_id`, and we never call
+            // `lower_node_id(owner)`.
+            item_local_id_counter: hir::ItemLocalId::new(1),
+            ident_and_label_to_local_id: Default::default(),
+            #[cfg(debug_assertions)]
+            relowering_checker: Default::default(),
+            attrs: SortedMap::default(),
+            bodies: Vec::new(),
+            define_opaque: None,
+            trait_map: Default::default(),
+            delayed_lints: Vec::new(),
+            children: LocalDefIdMap::default(),
+            impl_trait_defs: Vec::new(),
+            impl_trait_bounds: Vec::new(),
+        }
+    }
+
+    fn into_owner_info(
+        self,
+        tcx: TyCtxt<'hir>,
+        node: hir::OwnerNode<'hir>,
+    ) -> &'hir hir::OwnerInfo<'hir> {
+        assert_eq!(self.owner_id, node.def_id());
+        assert!(self.impl_trait_defs.is_empty());
+        assert!(self.impl_trait_bounds.is_empty());
+
+        let attrs = self.attrs;
+        let mut bodies = self.bodies;
+        let define_opaque = self.define_opaque;
+        let trait_map = self.trait_map;
+        let delayed_lints = Steal::new(self.delayed_lints.into_boxed_slice());
+        let children = self.children;
+
+        #[cfg(debug_assertions)]
+        for (id, attrs) in attrs.iter() {
+            // Verify that we do not store empty slices in the map.
+            if attrs.is_empty() {
+                panic!("Stored empty attributes for {:?}", id);
+            }
+        }
+
+        bodies.sort_by_key(|(k, _)| *k);
+        let bodies = SortedMap::from_presorted_elements(bodies);
+
+        // Don't hash unless necessary, because it's expensive.
+        let rustc_middle::hir::Hashes { bodies_hash, attrs_hash } =
+            tcx.hash_owner_nodes(node, &bodies, &attrs, define_opaque);
+        let num_nodes = self.item_local_id_counter.as_usize();
+        let (nodes, parenting) = index::index_hir(tcx, node, &bodies, num_nodes);
+        let nodes = hir::OwnerNodes { opt_hash: bodies_hash, nodes, bodies };
+        let attrs = hir::AttributeMap { map: attrs, opt_hash: attrs_hash, define_opaque };
+
+        let opt_hash = tcx.needs_hir_hash().then(|| {
+            tcx.with_stable_hashing_context(|mut hcx| {
+                let mut stable_hasher = StableHasher::new();
+                bodies_hash.unwrap().stable_hash(&mut hcx, &mut stable_hasher);
+                attrs_hash.unwrap().stable_hash(&mut hcx, &mut stable_hasher);
+                // Do not hash delayed_lints.
+                parenting.stable_hash(&mut hcx, &mut stable_hasher);
+                trait_map.stable_hash(&mut hcx, &mut stable_hasher);
+                children.stable_hash(&mut hcx, &mut stable_hasher);
+                stable_hasher.finish()
+            })
+        });
+
+        tcx.hir_arena.alloc(hir::OwnerInfo {
+            opt_hash,
+            nodes,
+            parenting,
+            attrs,
+            trait_map,
+            delayed_lints,
+            children,
+        })
+    }
+}
+
+struct LoweringContext<'a, 'hir> {
+    tcx: TyCtxt<'hir>,
+    resolver: &'a ResolverAstLowering<'hir>,
+
+    curr_owner: PerOwnerLoweringState<'a, 'hir>,
+
+    /// Used to allocate HIR nodes.
+    arena: &'hir hir::Arena<'hir>,
+
     contract_ensures: Option<(Span, Ident, HirId)>,
 
     coroutine_kind: Option<hir::CoroutineKind>,
@@ -178,19 +297,6 @@ struct LoweringContext<'a, 'hir> {
     is_in_loop_condition: bool,
     is_in_dyn_type: bool,
 
-    current_hir_id_owner: hir::OwnerId,
-    owner: &'a PerOwnerResolverData<'hir>,
-    item_local_id_counter: hir::ItemLocalId,
-    trait_map: ItemLocalMap<&'hir [TraitCandidate<'hir>]>,
-
-    impl_trait_defs: Vec<hir::GenericParam<'hir>>,
-    impl_trait_bounds: Vec<hir::WherePredicate<'hir>>,
-
-    /// NodeIds of pattern identifiers and labelled nodes that are lowered inside the current HIR owner.
-    ident_and_label_to_local_id: NodeMap<hir::ItemLocalId>,
-    /// NodeIds that are lowered inside the current HIR owner. Only used for duplicate lowering check.
-    #[cfg(debug_assertions)]
-    relowering_checker: re_lowering::ReloweringChecker,
     /// The `NodeId` space is split in two.
     /// `0..resolver.next_node_id` are created by the resolver on the AST.
     /// The higher part `resolver.next_node_id..next_node_id` are created during lowering.
@@ -211,8 +317,6 @@ struct LoweringContext<'a, 'hir> {
     allow_for_await: Arc<[Symbol]>,
     allow_async_fn_traits: Arc<[Symbol]>,
 
-    delayed_lints: Vec<DelayedLint>,
-
     /// Stack of `move(...)` collection states. A plain closure body pushes
     /// `Some`, so `move(...)` expressions can record the generated locals they
     /// should lower to. Nested bodies that cannot use `move(...)` push `None`.
@@ -223,37 +327,14 @@ struct LoweringContext<'a, 'hir> {
 
 impl<'a, 'hir> LoweringContext<'a, 'hir> {
     fn new(tcx: TyCtxt<'hir>, resolver: &'a ResolverAstLowering<'hir>, owner: NodeId) -> Self {
-        let current_ast_owner = &resolver.owners[&owner];
-        let current_hir_id_owner = hir::OwnerId { def_id: current_ast_owner.def_id };
-        let current_disambiguator = resolver
-            .disambiguators
-            .get(&current_hir_id_owner.def_id)
-            .map(|s| s.steal())
-            .unwrap_or_else(|| PerParentDisambiguatorState::new(current_hir_id_owner.def_id));
-
         Self {
             tcx,
             resolver,
-            current_disambiguator,
-            owner: current_ast_owner,
+            curr_owner: PerOwnerLoweringState::new(resolver, owner),
             arena: tcx.hir_arena,
 
-            // HirId handling.
-            bodies: Vec::new(),
-            define_opaque: None,
-            attrs: SortedMap::default(),
-            children: LocalDefIdMap::default(),
             contract_ensures: None,
-            current_hir_id_owner,
-            // 0 corresponds to `owner` lowered as `current_hir_id_owner`,
-            // and we never call `lower_node_id(owner)`.
-            item_local_id_counter: hir::ItemLocalId::new(1),
-            ident_and_label_to_local_id: Default::default(),
-
-            #[cfg(debug_assertions)]
-            relowering_checker: Default::default(),
 
-            trait_map: Default::default(),
             next_node_id: resolver.next_node_id,
             node_id_to_def_id: NodeMap::default(),
             partial_res_overrides: NodeMap::default(),
@@ -266,8 +347,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             coroutine_kind: None,
             task_context: None,
             current_item: None,
-            impl_trait_defs: Vec::new(),
-            impl_trait_bounds: Vec::new(),
             allow_contracts: [sym::contracts_internals].into(),
             allow_try_trait: [
                 sym::try_trait_v2,
@@ -295,7 +374,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 tcx.registered_attr_tools(()),
                 ShouldEmit::ErrorsAndLints { recovery: Recovery::Allowed },
             ),
-            delayed_lints: Vec::new(),
         }
     }
 
@@ -746,7 +824,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         def_kind: DefKind,
         span: Span,
     ) -> LocalDefId {
-        let parent = self.current_hir_id_owner.def_id;
+        let parent = self.curr_owner.owner_id.def_id;
         assert_ne!(node_id, ast::DUMMY_NODE_ID);
         assert!(
             self.opt_local_def_id(node_id).is_none(),
@@ -759,7 +837,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let def_id = self
             .tcx
             .at(span)
-            .create_def(parent, name, def_kind, None, &mut self.current_disambiguator)
+            .create_def(parent, name, def_kind, None, &mut self.curr_owner.disambiguator)
             .def_id();
 
         debug!("create_def: def_id_to_node_id[{:?}] <-> {:?}", def_id, node_id);
@@ -781,7 +859,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     fn opt_local_def_id(&self, node: NodeId) -> Option<LocalDefId> {
         self.node_id_to_def_id
             .get(&node)
-            .or_else(|| self.owner.node_id_to_def_id.get(&node))
+            .or_else(|| self.curr_owner.owner.node_id_to_def_id.get(&node))
             .copied()
     }
 
@@ -813,43 +891,18 @@ impl<'hir> LoweringContext<'_, 'hir> {
     }
 
     /// Freshen the `LoweringContext` and ready it to lower a nested item.
-    /// The lowered item is registered into `self.children`.
+    /// The lowered item is registered into `self.curr_owner.children`.
     ///
     /// This function sets up `HirId` lowering infrastructure,
-    /// and stashes the shared mutable state to avoid pollution by the closure.
+    /// and stashes the per-owner state to avoid pollution by the closure.
     #[instrument(level = "debug", skip(self, f))]
     fn with_hir_id_owner(
         &mut self,
         owner: NodeId,
         f: impl FnOnce(&mut Self) -> hir::OwnerNode<'hir>,
     ) {
-        let owner_id = self.owner_id(owner);
-        let def_id = owner_id.def_id;
-
-        let new_disambig = self
-            .resolver
-            .disambiguators
-            .get(&def_id)
-            .map(|s| s.steal())
-            .unwrap_or_else(|| PerParentDisambiguatorState::new(def_id));
-
-        let disambiguator = mem::replace(&mut self.current_disambiguator, new_disambig);
-        let current_ast_owner = mem::replace(&mut self.owner, &self.resolver.owners[&owner]);
-        let current_attrs = mem::take(&mut self.attrs);
-        let current_bodies = mem::take(&mut self.bodies);
-        let current_define_opaque = mem::take(&mut self.define_opaque);
-        let current_ident_and_label_to_local_id = mem::take(&mut self.ident_and_label_to_local_id);
-
-        #[cfg(debug_assertions)]
-        let current_relowering_checker = mem::take(&mut self.relowering_checker);
-        let current_trait_map = mem::take(&mut self.trait_map);
-        let current_owner = mem::replace(&mut self.current_hir_id_owner, owner_id);
-        let current_local_counter =
-            mem::replace(&mut self.item_local_id_counter, hir::ItemLocalId::new(1));
-        let current_impl_trait_defs = mem::take(&mut self.impl_trait_defs);
-        let current_impl_trait_bounds = mem::take(&mut self.impl_trait_bounds);
-        let current_delayed_lints = mem::take(&mut self.delayed_lints);
-        let current_children = mem::take(&mut self.children);
+        let child_owner = PerOwnerLoweringState::new(self.resolver, owner);
+        let parent_owner = mem::replace(&mut self.curr_owner, child_owner);
 
         // Do not reset `next_node_id` and `node_id_to_def_id`:
         // we want `f` to be able to refer to the `LocalDefId`s that the caller created.
@@ -857,88 +910,21 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
         // Always allocate the first `HirId` for the owner itself.
         #[cfg(debug_assertions)]
-        self.relowering_checker.assert_node_is_not_relowered(owner, hir::ItemLocalId::ZERO);
+        self.curr_owner
+            .relowering_checker
+            .assert_node_is_not_relowered(owner, hir::ItemLocalId::ZERO);
 
         let item = f(self);
-        assert_eq!(owner_id, item.def_id());
-        // `f` should have consumed all the elements in these vectors when constructing `item`.
-        assert!(self.impl_trait_defs.is_empty());
-        assert!(self.impl_trait_bounds.is_empty());
-        let info = self.make_owner_info(item);
+        let completed_child_owner = mem::replace(&mut self.curr_owner, parent_owner);
+        let owner_id = completed_child_owner.owner_id;
+        let info = completed_child_owner.into_owner_info(self.tcx, item);
 
-        self.current_disambiguator = disambiguator;
-        self.owner = current_ast_owner;
-        self.attrs = current_attrs;
-        self.bodies = current_bodies;
-        self.define_opaque = current_define_opaque;
-        self.ident_and_label_to_local_id = current_ident_and_label_to_local_id;
+        self.curr_owner
+            .children
+            .extend_unord(info.children.items().map(|(&def_id, &info)| (def_id, info)));
 
-        #[cfg(debug_assertions)]
-        {
-            self.relowering_checker = current_relowering_checker;
-        }
-        self.trait_map = current_trait_map;
-        self.current_hir_id_owner = current_owner;
-        self.item_local_id_counter = current_local_counter;
-        self.impl_trait_defs = current_impl_trait_defs;
-        self.impl_trait_bounds = current_impl_trait_bounds;
-        self.delayed_lints = current_delayed_lints;
-        self.children = current_children;
-        self.children.extend_unord(info.children.items().map(|(&def_id, &info)| (def_id, info)));
-
-        debug_assert!(!self.children.contains_key(&owner_id.def_id));
-        self.children.insert(owner_id.def_id, hir::MaybeOwner::Owner(info));
-    }
-
-    fn make_owner_info(&mut self, node: hir::OwnerNode<'hir>) -> &'hir hir::OwnerInfo<'hir> {
-        let attrs = mem::take(&mut self.attrs);
-        let mut bodies = mem::take(&mut self.bodies);
-        let define_opaque = mem::take(&mut self.define_opaque);
-        let trait_map = mem::take(&mut self.trait_map);
-        let delayed_lints = Steal::new(mem::take(&mut self.delayed_lints).into_boxed_slice());
-        let children = mem::take(&mut self.children);
-
-        #[cfg(debug_assertions)]
-        for (id, attrs) in attrs.iter() {
-            // Verify that we do not store empty slices in the map.
-            if attrs.is_empty() {
-                panic!("Stored empty attributes for {:?}", id);
-            }
-        }
-
-        bodies.sort_by_key(|(k, _)| *k);
-        let bodies = SortedMap::from_presorted_elements(bodies);
-
-        // Don't hash unless necessary, because it's expensive.
-        let rustc_middle::hir::Hashes { bodies_hash, attrs_hash } =
-            self.tcx.hash_owner_nodes(node, &bodies, &attrs, define_opaque);
-        let num_nodes = self.item_local_id_counter.as_usize();
-        let (nodes, parenting) = index::index_hir(self.tcx, node, &bodies, num_nodes);
-        let nodes = hir::OwnerNodes { opt_hash: bodies_hash, nodes, bodies };
-        let attrs = hir::AttributeMap { map: attrs, opt_hash: attrs_hash, define_opaque };
-
-        let opt_hash = self.tcx.needs_hir_hash().then(|| {
-            self.tcx.with_stable_hashing_context(|mut hcx| {
-                let mut stable_hasher = StableHasher::new();
-                bodies_hash.unwrap().stable_hash(&mut hcx, &mut stable_hasher);
-                attrs_hash.unwrap().stable_hash(&mut hcx, &mut stable_hasher);
-                // Do not hash delayed_lints.
-                parenting.stable_hash(&mut hcx, &mut stable_hasher);
-                trait_map.stable_hash(&mut hcx, &mut stable_hasher);
-                children.stable_hash(&mut hcx, &mut stable_hasher);
-                stable_hasher.finish()
-            })
-        });
-
-        self.arena.alloc(hir::OwnerInfo {
-            opt_hash,
-            nodes,
-            parenting,
-            attrs,
-            trait_map,
-            delayed_lints,
-            children,
-        })
+        debug_assert!(!self.curr_owner.children.contains_key(&owner_id.def_id));
+        self.curr_owner.children.insert(owner_id.def_id, hir::MaybeOwner::Owner(info));
     }
 
     /// This method allocates a new `HirId` for the given `NodeId`.
@@ -950,23 +936,23 @@ impl<'hir> LoweringContext<'_, 'hir> {
     fn lower_node_id(&mut self, ast_node_id: NodeId) -> HirId {
         assert_ne!(ast_node_id, DUMMY_NODE_ID);
 
-        let owner = self.current_hir_id_owner;
-        let local_id = self.item_local_id_counter;
+        let owner = self.curr_owner.owner_id;
+        let local_id = self.curr_owner.item_local_id_counter;
         assert_ne!(local_id, hir::ItemLocalId::ZERO);
-        self.item_local_id_counter.increment_by(1);
+        self.curr_owner.item_local_id_counter.increment_by(1);
         let hir_id = HirId { owner, local_id };
 
         if let Some(def_id) = self.opt_local_def_id(ast_node_id) {
-            self.children.insert(def_id, hir::MaybeOwner::NonOwner(hir_id));
+            self.curr_owner.children.insert(def_id, hir::MaybeOwner::NonOwner(hir_id));
         }
 
-        if let Some(traits) = self.owner.trait_map.get(&ast_node_id) {
-            self.trait_map.insert(hir_id.local_id, *traits);
+        if let Some(traits) = self.curr_owner.owner.trait_map.get(&ast_node_id) {
+            self.curr_owner.trait_map.insert(hir_id.local_id, *traits);
         }
 
         // Check whether the same `NodeId` is lowered more than once.
         #[cfg(debug_assertions)]
-        self.relowering_checker.assert_node_is_not_relowered(ast_node_id, local_id);
+        self.curr_owner.relowering_checker.assert_node_is_not_relowered(ast_node_id, local_id);
 
         hir_id
     }
@@ -974,18 +960,19 @@ impl<'hir> LoweringContext<'_, 'hir> {
     /// Generate a new `HirId` without a backing `NodeId`.
     #[instrument(level = "debug", skip(self), ret)]
     fn next_id(&mut self) -> HirId {
-        let owner = self.current_hir_id_owner;
-        let local_id = self.item_local_id_counter;
+        let owner = self.curr_owner.owner_id;
+        let local_id = self.curr_owner.item_local_id_counter;
         assert_ne!(local_id, hir::ItemLocalId::ZERO);
-        self.item_local_id_counter.increment_by(1);
+        self.curr_owner.item_local_id_counter.increment_by(1);
         HirId { owner, local_id }
     }
 
     #[instrument(level = "trace", skip(self))]
     fn lower_res(&mut self, res: Res<NodeId>) -> Res {
         let res: Result<Res, ()> = res.apply_id(|id| {
-            let owner = self.current_hir_id_owner;
-            let local_id = self.ident_and_label_to_local_id.get(&id).copied().ok_or(())?;
+            let owner = self.curr_owner.owner_id;
+            let local_id =
+                self.curr_owner.ident_and_label_to_local_id.get(&id).copied().ok_or(())?;
             Ok(HirId { owner, local_id })
         });
         trace!(?res);
@@ -1003,8 +990,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
     }
 
     fn lower_import_res(&mut self, id: NodeId, span: Span) -> PerNS<Option<Res>> {
-        debug_assert_eq!(id, self.owner.id);
-        let per_ns = self.owner.import_res.map(|res| res.map(|res| self.lower_res(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() {
             // Propagate the error to all namespaces, just to be sure.
             self.dcx().span_delayed_bug(span, "no resolution for an import");
@@ -1062,7 +1049,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     fn span_lowerer(&self) -> SpanLowerer {
         SpanLowerer {
             is_incremental: self.tcx.sess.opts.incremental.is_some(),
-            def_id: self.current_hir_id_owner.def_id,
+            def_id: self.curr_owner.owner_id.def_id,
         }
     }
 
@@ -1122,7 +1109,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     ) -> &'hir [hir::GenericParam<'hir>] {
         // Start by creating params for extra lifetimes params, as this creates the definitions
         // that may be referred to by the AST inside `generic_params`.
-        let extra_lifetimes = self.owner.extra_lifetime_params(binder);
+        let extra_lifetimes = self.curr_owner.owner.extra_lifetime_params(binder);
         debug!(?extra_lifetimes);
         let extra_lifetimes: Vec<_> = extra_lifetimes
             .iter()
@@ -1201,7 +1188,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 self.lower_attrs_vec(attrs, self.lower_span(target_span), id, target);
             lowered_attrs.extend(extra_hir_attributes.iter().cloned());
 
-            assert_eq!(id.owner, self.current_hir_id_owner);
+            assert_eq!(id.owner, self.curr_owner.owner_id);
             let ret = self.arena.alloc_from_iter(lowered_attrs);
 
             // this is possible if an item contained syntactical attribute,
@@ -1213,7 +1200,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             if ret.is_empty() {
                 &[]
             } else {
-                self.attrs.insert(id.local_id, ret);
+                self.curr_owner.attrs.insert(id.local_id, ret);
                 ret
             }
         }
@@ -1233,7 +1220,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             target,
             |s| l.lower(s),
             |lint_id, span, kind| {
-                self.delayed_lints.push(DelayedLint {
+                self.curr_owner.delayed_lints.push(DelayedLint {
                     lint_id,
                     id: target_hir_id,
                     span,
@@ -1249,11 +1236,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
     }
 
     fn alias_attrs(&mut self, id: HirId, target_id: HirId) {
-        assert_eq!(id.owner, self.current_hir_id_owner);
-        assert_eq!(target_id.owner, self.current_hir_id_owner);
-        if let Some(&a) = self.attrs.get(&target_id.local_id) {
+        assert_eq!(id.owner, self.curr_owner.owner_id);
+        assert_eq!(target_id.owner, self.curr_owner.owner_id);
+        if let Some(&a) = self.curr_owner.attrs.get(&target_id.local_id) {
             assert!(!a.is_empty());
-            self.attrs.insert(id.local_id, a);
+            self.curr_owner.attrs.insert(id.local_id, a);
         }
     }
 
@@ -1706,9 +1693,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
                             ident,
                             bounds,
                         );
-                        self.impl_trait_defs.push(param);
+                        self.curr_owner.impl_trait_defs.push(param);
                         if let Some(bounds) = bounds {
-                            self.impl_trait_bounds.push(bounds);
+                            self.curr_owner.impl_trait_bounds.push(bounds);
                         }
                         path
                     }
@@ -1812,7 +1799,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
             None => {
                 let id = if let Some(LifetimeRes::ElidedAnchor { start, end }) =
-                    self.owner.get_lifetime_res(t.id)
+                    self.curr_owner.owner.get_lifetime_res(t.id)
                 {
                     assert_eq!(start.plus(1), end);
                     start
@@ -1996,7 +1983,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
         let output = match coro {
             Some(coro) => {
-                let fn_def_id = self.owner.def_id;
+                let fn_def_id = self.curr_owner.owner.def_id;
                 self.lower_coroutine_fn_ret_ty(&decl.output, fn_def_id, coro, kind)
             }
             None => match &decl.output {
@@ -2004,19 +1991,19 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     let itctx = match kind {
                         FnDeclKind::Fn | FnDeclKind::Inherent => ImplTraitContext::OpaqueTy {
                             origin: hir::OpaqueTyOrigin::FnReturn {
-                                parent: self.owner.def_id,
+                                parent: self.curr_owner.owner.def_id,
                                 in_trait_or_impl: None,
                             },
                         },
                         FnDeclKind::Trait => ImplTraitContext::OpaqueTy {
                             origin: hir::OpaqueTyOrigin::FnReturn {
-                                parent: self.owner.def_id,
+                                parent: self.curr_owner.owner.def_id,
                                 in_trait_or_impl: Some(hir::RpitContext::Trait),
                             },
                         },
                         FnDeclKind::Impl => ImplTraitContext::OpaqueTy {
                             origin: hir::OpaqueTyOrigin::FnReturn {
-                                parent: self.owner.def_id,
+                                parent: self.curr_owner.owner.def_id,
                                 in_trait_or_impl: Some(hir::RpitContext::TraitImpl),
                             },
                         },
@@ -2061,7 +2048,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 }
             }))
             .set_lifetime_elision_allowed(
-                self.owner.id == fn_node_id && self.owner.lifetime_elision_allowed,
+                self.curr_owner.owner.id == fn_node_id
+                    && self.curr_owner.owner.lifetime_elision_allowed,
             )
             .set_c_variadic(c_variadic)
             .set_splatted(splatted, inputs.len())
@@ -2229,7 +2217,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         source: LifetimeSource,
         syntax: LifetimeSyntax,
     ) -> &'hir hir::Lifetime {
-        let res = if let Some(res) = self.owner.get_lifetime_res(id) {
+        let res = if let Some(res) = self.curr_owner.owner.get_lifetime_res(id) {
             match res {
                 LifetimeRes::Param { param, .. } => hir::LifetimeKind::Param(param),
                 LifetimeRes::Fresh { param, .. } => {
@@ -2315,12 +2303,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 // AST resolution emitted an error on those parameters, so we lower them using
                 // `ParamName::Error`.
                 let ident = self.lower_ident(param.ident);
-                let param_name =
-                    if let Some(LifetimeRes::Error(..)) = self.owner.get_lifetime_res(param.id) {
-                        ParamName::Error(ident)
-                    } else {
-                        ParamName::Plain(ident)
-                    };
+                let param_name = if let Some(LifetimeRes::Error(..)) =
+                    self.curr_owner.owner.get_lifetime_res(param.id)
+                {
+                    ParamName::Error(ident)
+                } else {
+                    ParamName::Plain(ident)
+                };
                 let kind =
                     hir::GenericParamKind::Lifetime { kind: hir::LifetimeParamKind::Explicit };
 
@@ -3102,7 +3091,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let hir_id = self.next_id();
         if let Some(a) = attrs {
             assert!(!a.is_empty());
-            self.attrs.insert(hir_id.local_id, a);
+            self.curr_owner.attrs.insert(hir_id.local_id, a);
         }
         let local = hir::LetStmt {
             super_: None,
diff --git a/compiler/rustc_ast_lowering/src/pat.rs b/compiler/rustc_ast_lowering/src/pat.rs
index a65b228e335c1..074e2f1c103cf 100644
--- a/compiler/rustc_ast_lowering/src/pat.rs
+++ b/compiler/rustc_ast_lowering/src/pat.rs
@@ -289,17 +289,17 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         // will be resolved to the same `Res::Local`. Thus they just share a single
                         // `HirId`.
                         if id == p.id {
-                            self.ident_and_label_to_local_id.insert(id, hir_id.local_id);
+                            self.curr_owner.ident_and_label_to_local_id.insert(id, hir_id.local_id);
                             hir_id
                         } else {
                             hir::HirId {
-                                owner: self.current_hir_id_owner,
-                                local_id: self.ident_and_label_to_local_id[&id],
+                                owner: self.curr_owner.owner_id,
+                                local_id: self.curr_owner.ident_and_label_to_local_id[&id],
                             }
                         }
                     }
                     _ => {
-                        self.ident_and_label_to_local_id.insert(p.id, hir_id.local_id);
+                        self.curr_owner.ident_and_label_to_local_id.insert(p.id, hir_id.local_id);
                         hir_id
                     }
                 };
diff --git a/compiler/rustc_ast_lowering/src/path.rs b/compiler/rustc_ast_lowering/src/path.rs
index 3937dc95893d6..261fcd18d96ba 100644
--- a/compiler/rustc_ast_lowering/src/path.rs
+++ b/compiler/rustc_ast_lowering/src/path.rs
@@ -425,7 +425,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         segment_ident_span: Span,
         generic_args: &mut GenericArgsCtor<'hir>,
     ) {
-        let (start, end) = match self.owner.get_lifetime_res(segment_id) {
+        let (start, end) = match self.curr_owner.owner.get_lifetime_res(segment_id) {
             Some(LifetimeRes::ElidedAnchor { start, end }) => (start, end),
             None => return,
             Some(res) => {
diff --git a/compiler/rustc_builtin_macros/src/deriving/debug.rs b/compiler/rustc_builtin_macros/src/deriving/debug.rs
index c09ac52e74820..94e0b704e6c08 100644
--- a/compiler/rustc_builtin_macros/src/deriving/debug.rs
+++ b/compiler/rustc_builtin_macros/src/deriving/debug.rs
@@ -1,4 +1,4 @@
-use rustc_ast::{self as ast, EnumDef, ExprKind, MetaItem, Safety, TyKind, token};
+use rustc_ast::{self as ast, EnumDef, MetaItem, Safety};
 use rustc_expand::base::{Annotatable, ExtCtxt};
 use rustc_session::config::FmtDebug;
 use rustc_span::{Ident, Span, Symbol, sym};
@@ -227,10 +227,6 @@ fn show_fieldless_enum(
     substr: &Substructure<'_>,
 ) -> BlockOrExpr {
     let fmt = substr.nonselflike_args[0].clone();
-    if let Some((stmts, expr)) = show_fieldless_enum_concat_str(cx, span, def, fmt.clone()) {
-        return BlockOrExpr::new_mixed(stmts, Some(expr));
-    }
-    let fn_path_write_str = cx.std_path(&[sym::fmt, sym::Formatter, sym::write_str]);
     let arms = def
         .variants
         .iter()
@@ -251,128 +247,6 @@ fn show_fieldless_enum(
         })
         .collect::<ThinVec<_>>();
     let name = cx.expr_match(span, cx.expr_self(span), arms);
+    let fn_path_write_str = cx.std_path(&[sym::fmt, sym::Formatter, sym::write_str]);
     BlockOrExpr::new_expr(cx.expr_call_global(span, fn_path_write_str, thin_vec![fmt, name]))
 }
-
-/// Special case for fieldless enums with no discriminants. Builds
-/// ```text
-/// impl ::core::fmt::Debug for A {
-///     fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-///         static __NAMES: &str = "ABBBCC";
-///         static __OFFSET: [usize; 4] =[0, 1, 4, 6];
-///         let __d = ::core::intrinsics::discriminant_value(self) as usize;
-///         ::core::fmt::Formatter::debug_c_like_enums_write_str(f, __NAMES, &__OFFSET, __d)
-///     }
-/// }
-/// ```
-fn show_fieldless_enum_concat_str(
-    cx: &ExtCtxt<'_>,
-    span: Span,
-    def: &EnumDef,
-    fmt: Box<ast::Expr>,
-) -> Option<(ThinVec<ast::Stmt>, Box<ast::Expr>)> {
-    // Minimum variants count where this optimization starts to pay off.
-    // See https://github.com/rust-lang/rust/pull/155452 for more details.
-    const THRESHOLD: usize = 10;
-    let variants_count = def.variants.len();
-    if variants_count < THRESHOLD {
-        return None;
-    }
-
-    let variant_names = def
-        .variants
-        .iter()
-        .map(|v| v.disr_expr.is_none().then_some(v.ident.name.as_str()))
-        .collect::<Option<ThinVec<_>>>()?;
-
-    let total_bytes: usize = variant_names.iter().map(|n| n.len()).sum();
-    let mut concatenated_names = String::with_capacity(total_bytes);
-    let mut offset_indices = Vec::with_capacity(variant_names.len() + 1);
-    offset_indices.push(0);
-
-    for name in variant_names.iter() {
-        concatenated_names.push_str(name);
-        offset_indices.push(concatenated_names.len());
-    }
-
-    // Create the constant concatenated string
-    let names_ident = Ident::from_str_and_span("__NAMES", span);
-    let str_ty = cx.ty(
-        span,
-        TyKind::Ref(
-            None,
-            ast::MutTy {
-                ty: cx.ty(
-                    span,
-                    TyKind::Path(None, ast::Path::from_ident(Ident::new(sym::str, span))),
-                ),
-                mutbl: ast::Mutability::Not,
-            },
-        ),
-    );
-    let names_str_body = cx.expr_str(span, Symbol::intern(&concatenated_names));
-    let names_static_item =
-        cx.item_static(span, names_ident, str_ty, ast::Mutability::Not, names_str_body);
-
-    // Create the constant offset array
-    let offset_ident = Ident::from_str_and_span("__OFFSET", span);
-    let offset_index_exprs =
-        offset_indices.iter().map(|s| cx.expr_usize(span, *s)).collect::<ThinVec<_>>();
-    let starts_array_body = cx.expr_array(span, offset_index_exprs);
-    let usize_ty =
-        cx.ty(span, TyKind::Path(None, ast::Path::from_ident(Ident::new(sym::usize, span))));
-    let offset_array_len_expr = cx.anon_const(
-        span,
-        ExprKind::Lit(token::Lit::new(
-            token::LitKind::Integer,
-            Symbol::intern(&(variants_count + 1).to_string()),
-            None,
-        )),
-    );
-    let offset_static_item = cx.item_static(
-        span,
-        offset_ident,
-        cx.ty(span, TyKind::Array(usize_ty, offset_array_len_expr)),
-        ast::Mutability::Not,
-        starts_array_body,
-    );
-
-    // let __d = ::core::intrinsics::discriminant_value(self) as usize;
-    let discriminant_ident = Ident::from_str_and_span("__d", span);
-    let discriminant_intrinsic_path = cx.std_path(&[sym::intrinsics, sym::discriminant_value]);
-    let discriminant_cast_expr = cx.expr(
-        span,
-        ast::ExprKind::Cast(
-            cx.expr_call_global(span, discriminant_intrinsic_path, thin_vec![cx.expr_self(span)]),
-            cx.ty_path(ast::Path::from_ident(Ident::new(sym::usize, span))),
-        ),
-    );
-    let discriminant_let_stmt =
-        cx.stmt_let(span, false, discriminant_ident, discriminant_cast_expr);
-
-    // __d expression
-    let discriminant_expr = cx.expr_ident(span, discriminant_ident);
-
-    // __NAMES expression
-    let names_expr = cx.expr_ident(span, names_ident);
-
-    // &__OFFSET expression
-    let offset_ref_expr = cx.expr_addr_of(span, cx.expr_ident(span, offset_ident));
-
-    // ::core::fmt::Formatter::debug_c_like_enum_write_str(f, __NAMES, &__OFFSET, __d)
-    let fn_path = cx.std_path(&[sym::fmt, sym::Formatter, sym::debug_c_like_enum_write_str]);
-    let call_expr = cx.expr_call_global(
-        span,
-        fn_path,
-        thin_vec![fmt, names_expr, offset_ref_expr, discriminant_expr],
-    );
-
-    Some((
-        thin_vec![
-            cx.stmt_item(span, names_static_item),
-            cx.stmt_item(span, offset_static_item),
-            discriminant_let_stmt,
-        ],
-        call_expr,
-    ))
-}
diff --git a/compiler/rustc_codegen_llvm/src/asm.rs b/compiler/rustc_codegen_llvm/src/asm.rs
index 0f74f5e81d684..1d14e31ffa94f 100644
--- a/compiler/rustc_codegen_llvm/src/asm.rs
+++ b/compiler/rustc_codegen_llvm/src/asm.rs
@@ -1256,7 +1256,10 @@ fn llvm_fixup_input<'ll, 'tcx>(
         (LoongArch(LoongArchInlineAsmRegClass::freg), BackendRepr::Scalar(s))
             if s.primitive() == Primitive::Float(Float::F16) =>
         {
-            // Smaller floats are always "NaN-boxed" inside larger floats on LoongArch.
+            // The LoongArch psABI only requires the upper bits to be widened to
+            // GRLEN, leaving them undefined. We NaN-box instead (set all upper
+            // bits to 1), matching LLVM's own codegen, to avoid an `f16` value
+            // being mistaken for a valid `f32` value.
             let value = bx.bitcast(value, bx.type_i16());
             let value = bx.zext(value, bx.type_i32());
             let value = bx.or(value, bx.const_u32(0xFFFF_0000));
diff --git a/compiler/rustc_codegen_llvm/src/coverageinfo/llvm_cov.rs b/compiler/rustc_codegen_llvm/src/coverageinfo/llvm_cov.rs
index a58202834cfa5..93d0b09578315 100644
--- a/compiler/rustc_codegen_llvm/src/coverageinfo/llvm_cov.rs
+++ b/compiler/rustc_codegen_llvm/src/coverageinfo/llvm_cov.rs
@@ -64,7 +64,7 @@ pub(crate) fn write_filenames_to_buffer(filenames: &[impl AsRef<str>]) -> Vec<u8
 ///
 /// Each field name has a `_regions` suffix for improved readability after
 /// exhaustive destructing, which ensures that all region types are handled.
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub(crate) struct Regions {
     pub(crate) code_regions: Vec<ffi::CodeRegion>,
     pub(crate) expansion_regions: Vec<ffi::ExpansionRegion>,
diff --git a/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs b/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs
index 18818fd1a56c0..3dac4b3e0167f 100644
--- a/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs
+++ b/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs
@@ -1,11 +1,9 @@
 use std::assert_matches;
-use std::sync::Arc;
 
 use itertools::Itertools;
 use rustc_abi::Align;
 use rustc_codegen_ssa::traits::{BaseTypeCodegenMethods, ConstCodegenMethods};
 use rustc_data_structures::fx::FxIndexMap;
-use rustc_index::IndexVec;
 use rustc_middle::ty::TyCtxt;
 use rustc_span::{FileName, RemapPathScopeComponents, SourceFile, StableSourceFileId};
 use tracing::debug;
@@ -74,7 +72,7 @@ pub(crate) fn finalize(cx: &mut CodegenCx<'_, '_>) {
         unused::prepare_covfun_records_for_unused_functions(cx, &mut covfun_records);
     }
 
-    // If there are no covfun records for this CGU, don't generate a covmap record.
+    // If there are no covfun records for this CGU, don't emit a covmap record.
     // Emitting a covmap record without any covfun records causes `llvm-cov` to
     // fail when generating coverage reports, and if there are no covfun records
     // then the covmap record isn't useful anyway.
@@ -89,13 +87,13 @@ pub(crate) fn finalize(cx: &mut CodegenCx<'_, '_>) {
         GlobalFileTable::build(tcx, covfun_records.iter().flat_map(|c| c.all_source_files()));
 
     for covfun in &covfun_records {
-        covfun::generate_covfun_record(cx, &global_file_table, covfun)
+        covfun::emit_covfun_record(cx, &global_file_table, covfun);
     }
 
-    // Generate the coverage map header, which contains the filenames used by
+    // Emit the coverage map header, which contains the filenames used by
     // this CGU's coverage mappings, and store it in a well-known global.
     // (This is skipped if we returned early due to having no covfun records.)
-    generate_covmap_record(cx, covmap_version, &global_file_table.filenames_buffer);
+    emit_covmap_record(cx, covmap_version, &global_file_table.filenames_buffer);
 }
 
 /// Maps "global" (per-CGU) file ID numbers to their underlying source file paths.
@@ -190,38 +188,10 @@ rustc_index::newtype_index! {
     struct LocalFileId {}
 }
 
-/// Holds a mapping from "local" (per-function) file IDs to their corresponding
-/// source files.
-#[derive(Debug, Default)]
-struct VirtualFileMapping {
-    local_file_table: IndexVec<LocalFileId, Arc<SourceFile>>,
-}
-
-impl VirtualFileMapping {
-    fn push_file(&mut self, source_file: &Arc<SourceFile>) -> LocalFileId {
-        self.local_file_table.push(Arc::clone(source_file))
-    }
-
-    /// Resolves all of the filenames in this local file mapping to a list of
-    /// global file IDs in its CGU, for inclusion in this function's
-    /// `__llvm_covfun` record.
-    ///
-    /// The global file IDs are returned as `u32` to make FFI easier.
-    fn resolve_all(&self, global_file_table: &GlobalFileTable) -> Option<Vec<u32>> {
-        self.local_file_table
-            .iter()
-            .map(|file| try {
-                let id = global_file_table.get_existing_id(file)?;
-                GlobalFileId::as_u32(id)
-            })
-            .collect::<Option<Vec<_>>>()
-    }
-}
-
-/// Generates the contents of the covmap record for this CGU, which mostly
-/// consists of a header and a list of filenames. The record is then stored
+/// Generates and emits the covmap record for this CGU, which mostly
+/// consists of a header and a list of filenames. The record is emitted
 /// as a global variable in the `__llvm_covmap` section.
-fn generate_covmap_record<'ll>(
+fn emit_covmap_record<'ll>(
     cx: &mut CodegenCx<'ll, '_>,
     version: CovmapVersion,
     filenames_buffer: &[u8],
diff --git a/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen/covfun.rs b/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen/covfun.rs
index 28985448fd1c1..d01ed8765302e 100644
--- a/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen/covfun.rs
+++ b/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen/covfun.rs
@@ -5,13 +5,15 @@
 //! [^win]: On Windows the section name is `.lcovfun`.
 
 use std::ffi::CString;
+use std::iter;
 use std::sync::Arc;
 
 use rustc_abi::Align;
 use rustc_codegen_ssa::traits::{BaseTypeCodegenMethods as _, ConstCodegenMethods};
+use rustc_index::IndexVec;
 use rustc_middle::mir::coverage::{
-    BasicCoverageBlock, CounterId, CovTerm, CoverageCodegenInfo, CoverageMirInfo, Expression,
-    ExpressionId, Mapping, MappingKind, Op,
+    BasicCoverageBlock, CounterId, CovTerm, CoverageCodegenInfo, Expression, ExpressionId, Mapping,
+    MappingKind, Op,
 };
 use rustc_middle::ty::{Instance, TyCtxt};
 use rustc_span::{SourceFile, Span};
@@ -19,7 +21,7 @@ use rustc_target::spec::HasTargetSpec;
 use tracing::debug;
 
 use crate::common::CodegenCx;
-use crate::coverageinfo::mapgen::{GlobalFileTable, VirtualFileMapping, spans};
+use crate::coverageinfo::mapgen::{GlobalFileTable, LocalFileId, spans};
 use crate::coverageinfo::{ffi, llvm_cov};
 use crate::llvm;
 
@@ -34,16 +36,15 @@ pub(crate) struct CovfunRecord<'tcx> {
     source_hash: u64,
     is_used: bool,
 
-    virtual_file_mapping: VirtualFileMapping,
     expressions: Vec<ffi::CounterExpression>,
-    regions: llvm_cov::Regions,
+    mappings: ResolvedMappings,
 }
 
 impl<'tcx> CovfunRecord<'tcx> {
     /// Iterator that yields all source files referred to by this function's
     /// coverage mappings. Used to build the global file table for the CGU.
     pub(crate) fn all_source_files(&self) -> impl Iterator<Item = &SourceFile> {
-        self.virtual_file_mapping.local_file_table.iter().map(Arc::as_ref)
+        self.mappings.all_source_files()
     }
 }
 
@@ -56,36 +57,29 @@ pub(crate) fn prepare_covfun_record<'tcx>(
     let cg_info = tcx.coverage_codegen_info(instance.def)?;
 
     let expressions = prepare_expressions(cg_info);
+    let mappings = prepare_resolved_mappings(tcx, cg_info, is_used, &mir_info.mappings)?;
 
-    let mut covfun = CovfunRecord {
+    let covfun = CovfunRecord {
         _instance: instance,
         mangled_function_name: tcx.symbol_name(instance).name,
         source_hash: if is_used { mir_info.function_source_hash } else { 0 },
         is_used,
-        virtual_file_mapping: VirtualFileMapping::default(),
         expressions,
-        regions: llvm_cov::Regions::default(),
+        mappings,
     };
 
-    fill_region_tables(tcx, mir_info, cg_info, &mut covfun);
-
-    if covfun.regions.has_no_regions() {
-        debug!(?covfun, "function has no mappings to embed; skipping");
-        return None;
-    }
-
     Some(covfun)
 }
 
-pub(crate) fn counter_for_term(term: CovTerm) -> ffi::Counter {
-    use ffi::Counter;
+fn counter_for_term(term: CovTerm) -> ffi::Counter {
     match term {
-        CovTerm::Zero => Counter::ZERO,
-        CovTerm::Counter(id) => {
-            Counter { kind: ffi::CounterKind::CounterValueReference, id: CounterId::as_u32(id) }
-        }
+        CovTerm::Zero => ffi::Counter::ZERO,
+        CovTerm::Counter(id) => ffi::Counter {
+            kind: ffi::CounterKind::CounterValueReference,
+            id: CounterId::as_u32(id),
+        },
         CovTerm::Expression(id) => {
-            Counter { kind: ffi::CounterKind::Expression, id: ExpressionId::as_u32(id) }
+            ffi::Counter { kind: ffi::CounterKind::Expression, id: ExpressionId::as_u32(id) }
         }
     }
 }
@@ -110,16 +104,60 @@ fn prepare_expressions(cg_info: &CoverageCodegenInfo) -> Vec<ffi::CounterExpress
         .collect::<Vec<_>>()
 }
 
-/// Populates the mapping region tables in the current function's covfun record.
-fn fill_region_tables<'tcx>(
+/// Intermediate representation of coverage mappings, after all mapping spans
+/// have been resolved to file coordinates (or discarded), but before producing
+/// a final [`llvm_cov::Regions`].
+///
+/// Having a separate resolution step makes it easier to handle edge cases
+/// where a function (or someday an expansion) manages to lose all of its spans,
+/// without accidentally emitting invalid covfun records containing empty files.
+#[derive(Debug)]
+struct ResolvedMappings {
+    /// Source file for all of the [`spans::Coords`] in these mappings.
+    source_file: Arc<SourceFile>,
+
+    code_mappings: Vec<CodeMapping>,
+    branch_mappings: Vec<BranchMapping>,
+}
+
+impl ResolvedMappings {
+    fn ensure_nonempty(self) -> Option<Self> {
+        let ResolvedMappings { source_file: _, code_mappings, branch_mappings } = &self;
+        if code_mappings.is_empty() && branch_mappings.is_empty() { None } else { Some(self) }
+    }
+
+    fn all_source_files(&self) -> impl Iterator<Item = &SourceFile> {
+        // FIXME(Zalathar): When expansion regions are supported, this also needs to yield
+        // any source files used by descendant expansions.
+        let ResolvedMappings { source_file, code_mappings: _, branch_mappings: _ } = self;
+        iter::once(source_file.as_ref())
+    }
+}
+
+/// Resolved from [`MappingKind::Code`], and the precursor to [`ffi::CodeRegion`].
+#[derive(Debug)]
+struct CodeMapping {
+    coords: spans::Coords,
+    counter: ffi::Counter,
+}
+
+/// Resolved from [`MappingKind::Branch`], and the precursor to [`ffi::BranchRegion`].
+#[derive(Debug)]
+struct BranchMapping {
+    coords: spans::Coords,
+    true_counter: ffi::Counter,
+    false_counter: ffi::Counter,
+}
+
+fn prepare_resolved_mappings<'tcx>(
     tcx: TyCtxt<'tcx>,
-    mir_info: &'tcx CoverageMirInfo,
     cg_info: &'tcx CoverageCodegenInfo,
-    covfun: &mut CovfunRecord<'tcx>,
-) {
+    is_used: bool,
+    mappings: &[Mapping],
+) -> Option<ResolvedMappings> {
     // If this function is unused, replace all counters with zero.
     let counter_for_bcb = |bcb: BasicCoverageBlock| -> ffi::Counter {
-        let term = if covfun.is_used {
+        let term = if is_used {
             cg_info.term_for_bcb[bcb].expect("every BCB in a mapping was given a term")
         } else {
             CovTerm::Zero
@@ -130,14 +168,9 @@ fn fill_region_tables<'tcx>(
     // Currently a function's mappings must all be in the same file, so use the
     // first mapping's span to determine the file.
     let source_map = tcx.sess.source_map();
-    let Some(first_span) = (try { mir_info.mappings.first()?.span }) else {
-        debug_assert!(false, "function has no mappings: {covfun:?}");
-        return;
-    };
+    let first_span = mappings.first()?.span;
     let source_file = source_map.lookup_source_file(first_span.lo());
 
-    let local_file_id = covfun.virtual_file_mapping.push_file(&source_file);
-
     // In rare cases, _all_ of a function's spans are discarded, and coverage
     // codegen needs to handle that gracefully to avoid #133606.
     // It's hard for tests to trigger this organically, so instead we set
@@ -147,37 +180,64 @@ fn fill_region_tables<'tcx>(
         if discard_all { None } else { spans::make_coords(source_map, &source_file, span) }
     };
 
+    let mut code_mappings = vec![];
+    let mut branch_mappings = vec![];
+
+    for &Mapping { ref kind, span } in mappings {
+        let Some(coords) = make_coords(span) else { continue };
+        match *kind {
+            MappingKind::Code { bcb } => {
+                code_mappings.push(CodeMapping { coords, counter: counter_for_bcb(bcb) })
+            }
+            MappingKind::Branch { true_bcb, false_bcb } => branch_mappings.push(BranchMapping {
+                coords,
+                true_counter: counter_for_bcb(true_bcb),
+                false_counter: counter_for_bcb(false_bcb),
+            }),
+        }
+    }
+
+    ResolvedMappings { source_file, code_mappings, branch_mappings }.ensure_nonempty()
+}
+
+/// Populates the mapping region tables for the current function's covfun record.
+fn fill_region_tables(
+    global_file_table: &GlobalFileTable,
+    mappings: &ResolvedMappings,
+    virtual_file_mapping: &mut IndexVec<LocalFileId, u32>,
+    regions: &mut llvm_cov::Regions,
+) {
+    let ResolvedMappings { source_file, code_mappings, branch_mappings } = mappings;
+    let Some(global_file_id) = global_file_table.get_existing_id(source_file) else {
+        debug_assert!(false, "couldn't find an existing global-file-id for {source_file:?}");
+        return;
+    };
+
     let llvm_cov::Regions {
         code_regions,
         expansion_regions: _, // FIXME(Zalathar): Fill out support for expansion regions
         branch_regions,
-    } = &mut covfun.regions;
+    } = regions;
 
-    // For each counter/region pair in this function+file, convert it to a
-    // form suitable for FFI.
-    for &Mapping { ref kind, span } in &mir_info.mappings {
-        let Some(coords) = make_coords(span) else { continue };
+    // The global file IDs are stored as `u32` to make FFI easier.
+    // FIXME(Zalathar): Consider giving `newtype_index!` a safe transmute to `&[u32]`.
+    let local_file_id = virtual_file_mapping.push(global_file_id.as_u32());
+
+    for &CodeMapping { coords, counter } in code_mappings {
         let cov_span = coords.make_coverage_span(local_file_id);
+        code_regions.push(ffi::CodeRegion { cov_span, counter });
+    }
 
-        match *kind {
-            MappingKind::Code { bcb } => {
-                code_regions.push(ffi::CodeRegion { cov_span, counter: counter_for_bcb(bcb) });
-            }
-            MappingKind::Branch { true_bcb, false_bcb } => {
-                branch_regions.push(ffi::BranchRegion {
-                    cov_span,
-                    true_counter: counter_for_bcb(true_bcb),
-                    false_counter: counter_for_bcb(false_bcb),
-                });
-            }
-        }
+    for &BranchMapping { coords, true_counter, false_counter } in branch_mappings {
+        let cov_span = coords.make_coverage_span(local_file_id);
+        branch_regions.push(ffi::BranchRegion { cov_span, true_counter, false_counter });
     }
 }
 
-/// Generates the contents of the covfun record for this function, which
-/// contains the function's coverage mapping data. The record is then stored
+/// Generates and emits the covfun record for this function, which
+/// contains the function's coverage mapping data. The record is emitted
 /// as a global variable in the `__llvm_covfun` section.
-pub(crate) fn generate_covfun_record<'tcx>(
+pub(crate) fn emit_covfun_record<'tcx>(
     cx: &mut CodegenCx<'_, 'tcx>,
     global_file_table: &GlobalFileTable,
     covfun: &CovfunRecord<'tcx>,
@@ -187,24 +247,25 @@ pub(crate) fn generate_covfun_record<'tcx>(
         mangled_function_name,
         source_hash,
         is_used,
-        ref virtual_file_mapping,
         ref expressions,
-        ref regions,
+        ref mappings,
     } = covfun;
 
-    let Some(local_file_table) = virtual_file_mapping.resolve_all(global_file_table) else {
-        debug_assert!(
-            false,
-            "all local files should be present in the global file table: \
-                global_file_table = {global_file_table:?}, \
-                virtual_file_mapping = {virtual_file_mapping:?}"
-        );
+    let mut regions = llvm_cov::Regions::default();
+    let mut virtual_file_mapping = IndexVec::new();
+    fill_region_tables(global_file_table, mappings, &mut virtual_file_mapping, &mut regions);
+
+    if regions.has_no_regions() {
+        debug_assert!(false, "mappings should have produced at least one region: {mappings:#?}");
         return;
-    };
+    }
 
     // Encode the function's coverage mappings into a buffer.
-    let coverage_mapping_buffer =
-        llvm_cov::write_function_mappings_to_buffer(&local_file_table, expressions, regions);
+    let coverage_mapping_buffer = llvm_cov::write_function_mappings_to_buffer(
+        &virtual_file_mapping.raw,
+        expressions,
+        &regions,
+    );
 
     // A covfun record consists of four target-endian integers, followed by the
     // encoded mapping data in bytes. Note that the length field is 32 bits.
diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs
index 58957b46964c7..c4ff1eee56750 100644
--- a/compiler/rustc_codegen_llvm/src/intrinsic.rs
+++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs
@@ -138,6 +138,42 @@ fn call_simple_intrinsic<'ll, 'tcx>(
     ))
 }
 
+impl<'ll, 'tcx> Builder<'_, 'll, 'tcx> {
+    fn black_box(&mut self, result: PlaceRef<'tcx, &'ll Value>, span: Span) {
+        let result_val_span = [result.val.llval];
+        // We need to "use" the argument in some way LLVM can't introspect, and on
+        // targets that support it we can typically leverage inline assembly to do
+        // this. LLVM's interpretation of inline assembly is that it's, well, a black
+        // box. This isn't the greatest implementation since it probably deoptimizes
+        // more than we want, but it's so far good enough.
+        //
+        // For zero-sized types, the location pointed to by the result may be
+        // uninitialized. Do not "use" the result in this case; instead just clobber
+        // the memory.
+        let (constraint, inputs): (&str, &[_]) = if result.layout.is_zst() {
+            ("~{memory}", &[])
+        } else {
+            ("r,~{memory}", &result_val_span)
+        };
+        crate::asm::inline_asm_call(
+            self,
+            "",
+            constraint,
+            inputs,
+            self.type_void(),
+            &[],
+            true,
+            false,
+            llvm::AsmDialect::Att,
+            &[span],
+            false,
+            None,
+            None,
+        )
+        .unwrap_or_else(|| bug!("failed to generate inline asm call for `black_box`"));
+    }
+}
+
 impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
     fn codegen_intrinsic_call(
         &mut self,
@@ -327,9 +363,12 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                 let ptr = args[0].immediate();
                 let abi_align = result_layout.align.abi;
                 let ptr_align = if name == sym::volatile_load { abi_align } else { Align::ONE };
+                let need_black_box = llvm_version < (23, 0, 0);
                 if result_layout.is_zst() {
                     return IntrinsicResult::Operand(OperandValue::ZeroSized);
-                } else if let BackendRepr::Scalar(scalar) = result_layout.backend_repr {
+                } else if let BackendRepr::Scalar(scalar) = result_layout.backend_repr
+                    && !need_black_box
+                {
                     let load = self.volatile_load(self.type_from_scalar(scalar), ptr, ptr_align);
                     self.to_immediate_scalar(load, scalar)
                 } else {
@@ -344,6 +383,13 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                     };
                     let llval = self.volatile_load(llty, ptr, ptr_align);
                     self.store(llval, temp.val.llval, abi_align);
+                    if need_black_box {
+                        // LLVM up until v22 considers volatile reads `willreturn` and hence can
+                        // move UB from further down up across this read. To prevent that, insert an
+                        // inline asm block that, as far as LLVM is concerned, might not terminate,
+                        // and hence should prevent such reordering.
+                        self.black_box(temp, span);
+                    }
                     return if result_place.is_none() {
                         IntrinsicResult::Operand(self.load_operand(temp).val)
                     } else {
@@ -608,39 +654,11 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
             }
 
             sym::black_box => {
+                // This `unwrap` is justified by `intrinsic_call_expects_place_always` declaring
+                // this intrinsic as always needing a return place.
                 let result = PlaceRef { val: result_place.unwrap(), layout: result_layout };
                 args[0].val.store(self, result);
-                let result_val_span = [result.val.llval];
-                // We need to "use" the argument in some way LLVM can't introspect, and on
-                // targets that support it we can typically leverage inline assembly to do
-                // this. LLVM's interpretation of inline assembly is that it's, well, a black
-                // box. This isn't the greatest implementation since it probably deoptimizes
-                // more than we want, but it's so far good enough.
-                //
-                // For zero-sized types, the location pointed to by the result may be
-                // uninitialized. Do not "use" the result in this case; instead just clobber
-                // the memory.
-                let (constraint, inputs): (&str, &[_]) = if result.layout.is_zst() {
-                    ("~{memory}", &[])
-                } else {
-                    ("r,~{memory}", &result_val_span)
-                };
-                crate::asm::inline_asm_call(
-                    self,
-                    "",
-                    constraint,
-                    inputs,
-                    self.type_void(),
-                    &[],
-                    true,
-                    false,
-                    llvm::AsmDialect::Att,
-                    &[span],
-                    false,
-                    None,
-                    None,
-                )
-                .unwrap_or_else(|| bug!("failed to generate inline asm call for `black_box`"));
+                self.black_box(result, span);
 
                 // We have copied the value to `result` already.
                 return IntrinsicResult::WroteIntoPlace;
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 684bba7a717db..c20b4ccd776da 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -2172,9 +2172,13 @@ unsafe extern "C" {
 
     pub(crate) safe fn LLVMRustCoverageMappingVersion() -> u32;
     pub(crate) fn LLVMRustDebugMetadataVersion() -> u32;
+
+    /// Returns the LLVM major version that the compiler was built with.
+    ///
+    /// Note that this is hard-coded as `LLVM_VERSION_MAJOR` when `RustWrapper.cpp` is built. This
+    /// could be different than what the runtime LLVM library reports in `LLVMGetVersion`, so we
+    /// assert their equality in `configure_llvm`.
     pub(crate) fn LLVMRustVersionMajor() -> u32;
-    pub(crate) fn LLVMRustVersionMinor() -> u32;
-    pub(crate) fn LLVMRustVersionPatch() -> u32;
 
     /// Add LLVM module flags.
     ///
diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs
index 82ddcca3e1530..a5441b1ef1135 100644
--- a/compiler/rustc_codegen_llvm/src/llvm_util.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm_util.rs
@@ -50,10 +50,7 @@ unsafe fn configure_llvm(sess: &Session) {
 
     // Check to ensure we're running against the correct LLVM version.
     unsafe {
-        let mut llvm_major = 0;
-        let mut llvm_minor = 0;
-        let mut llvm_patch = 0;
-        llvm::LLVMGetVersion(&mut llvm_major, &mut llvm_minor, &mut llvm_patch);
+        let (llvm_major, llvm_minor, llvm_patch) = get_version();
         let expected_version = llvm::LLVMRustVersionMajor();
         if llvm_major != expected_version {
             sess.dcx().emit_fatal(diagnostics::LlvmVersionMismatch {
@@ -465,7 +462,11 @@ pub(crate) fn print_version() {
 pub(crate) fn get_version() -> (u32, u32, u32) {
     // Can be called without initializing LLVM
     unsafe {
-        (llvm::LLVMRustVersionMajor(), llvm::LLVMRustVersionMinor(), llvm::LLVMRustVersionPatch())
+        let mut llvm_major = 0;
+        let mut llvm_minor = 0;
+        let mut llvm_patch = 0;
+        llvm::LLVMGetVersion(&mut llvm_major, &mut llvm_minor, &mut llvm_patch);
+        (llvm_major, llvm_minor, llvm_patch)
     }
 }
 
diff --git a/compiler/rustc_hir_typeck/src/expr.rs b/compiler/rustc_hir_typeck/src/expr.rs
index 6ebf382083f25..548177a150b9a 100644
--- a/compiler/rustc_hir_typeck/src/expr.rs
+++ b/compiler/rustc_hir_typeck/src/expr.rs
@@ -430,6 +430,16 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 if let Some(sp) = tcx.sess.psess.ambiguous_block_expr_parse.borrow().get(&sp) {
                     err.subdiagnostic(ExprParenthesesNeeded::surrounding(*sp));
                 }
+                // The operand may be an uncalled function, in which case it is its return type
+                // the user meant to dereference. Only suggest the call when that return type is
+                // itself dereferenceable, mirroring the checks `lookup_derefing` just failed.
+                self.suggest_fn_call(&mut err, oprnd, oprnd_t, |output| {
+                    output.builtin_deref(true).is_some()
+                        || self.tcx.lang_items().deref_trait().is_some_and(|deref_trait| {
+                            self.type_implements_trait(deref_trait, [output], self.param_env)
+                                .may_apply()
+                        })
+                });
                 Ty::new_error(tcx, err.emit())
             }),
             hir::UnOp::Not => {
@@ -555,7 +565,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 LangItem::IntoIterIntoIter | LangItem::IteratorNext
                     if expr.span.is_desugaring(DesugaringKind::ForLoop) =>
                 {
-                    Some(ObligationCauseCode::ForLoopIterator)
+                    Some(ObligationCauseCode::ForLoopIterator(arg.hir_id))
                 }
                 LangItem::TryTraitFromOutput
                     if expr.span.is_desugaring(DesugaringKind::TryBlock) =>
diff --git a/compiler/rustc_hir_typeck/src/method/probe.rs b/compiler/rustc_hir_typeck/src/method/probe.rs
index f5b8b9d6a1e6f..40bf435e6d110 100644
--- a/compiler/rustc_hir_typeck/src/method/probe.rs
+++ b/compiler/rustc_hir_typeck/src/method/probe.rs
@@ -2184,28 +2184,6 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
                 }
             }
 
-            // See <https://github.com/rust-lang/trait-system-refactor-initiative/issues/134>.
-            //
-            // In the new solver, check the well-formedness of the return type.
-            // This emulates, in a way, the predicates that fall out of
-            // normalizing the return type in the old solver.
-            //
-            // FIXME(-Znext-solver): We alternatively could check the predicates of
-            // the method itself hold, but we intentionally do not do this in the old
-            // solver b/c of cycles, and doing it in the new solver would be stronger.
-            // This should be fixed in the future, since it likely leads to much better
-            // method winnowing.
-            if let Some(xform_ret_ty) = xform_ret_ty
-                && self.infcx.next_trait_solver()
-            {
-                ocx.register_obligation(traits::Obligation::new(
-                    self.tcx,
-                    cause.clone(),
-                    self.param_env,
-                    ty::ClauseKind::WellFormed(xform_ret_ty.into()),
-                ));
-            }
-
             // Evaluate those obligations to see if they might possibly hold.
             for error in ocx.try_evaluate_obligations() {
                 result = ProbeResult::NoMatch;
diff --git a/compiler/rustc_lint/src/unused.rs b/compiler/rustc_lint/src/unused.rs
index c78c2de5f8dd1..1ff2a2cb1a404 100644
--- a/compiler/rustc_lint/src/unused.rs
+++ b/compiler/rustc_lint/src/unused.rs
@@ -1094,6 +1094,10 @@ impl UnusedDelimLint for UnusedBraces {
                 if let [stmt] = inner.stmts.as_slice()
                     && let ast::StmtKind::Expr(ref expr) = stmt.kind
                     && !Self::is_expr_delims_necessary(expr, ctx, followed_by_block)
+                    // In Rust 2024, this block may drop tail-expression temporaries, such as a
+                    // lock guard, before the loop starts.
+                    && !(ctx == UnusedDelimsCtx::ForIterExpr
+                        && value.span.edition().at_least_rust_2024())
                     && (ctx != UnusedDelimsCtx::AnonConst
                         || (matches!(expr.kind, ast::ExprKind::Lit(_))
                             && !expr.span.from_expansion()))
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index 189296dc9c4c8..6947c4766eccf 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -885,10 +885,6 @@ extern "C" uint32_t LLVMRustDebugMetadataVersion() {
   return DEBUG_METADATA_VERSION;
 }
 
-extern "C" uint32_t LLVMRustVersionPatch() { return LLVM_VERSION_PATCH; }
-
-extern "C" uint32_t LLVMRustVersionMinor() { return LLVM_VERSION_MINOR; }
-
 extern "C" uint32_t LLVMRustVersionMajor() { return LLVM_VERSION_MAJOR; }
 
 // FFI equivalent of LLVM's `llvm::Module::ModFlagBehavior`.
diff --git a/compiler/rustc_middle/src/mir/consts.rs b/compiler/rustc_middle/src/mir/consts.rs
index 3b85651ee5f76..a5d5b37b2ebb6 100644
--- a/compiler/rustc_middle/src/mir/consts.rs
+++ b/compiler/rustc_middle/src/mir/consts.rs
@@ -320,6 +320,10 @@ impl<'tcx> Const<'tcx> {
     ) -> Result<ConstValue, ErrorHandled> {
         match self {
             Const::Ty(_, c) => {
+                if let Err(e) = c.error_reported() {
+                    return Err(ReportedErrorInfo::non_const_eval_error(e).into());
+                }
+
                 // FIXME(generic_const_exprs): We shouldn't encounter placeholders here
                 // and could change this to ICE when encountering them instead.
                 if c.has_non_region_param() || c.has_non_region_placeholders() {
diff --git a/compiler/rustc_middle/src/thir.rs b/compiler/rustc_middle/src/thir.rs
index f65295080f61d..a27c6bc43171d 100644
--- a/compiler/rustc_middle/src/thir.rs
+++ b/compiler/rustc_middle/src/thir.rs
@@ -344,7 +344,7 @@ pub enum ExprKind<'tcx> {
     /// expression. This is inserted in some places where an operation would
     /// otherwise be erased completely (e.g. some no-op casts), but we still
     /// need to ensure that its operand is treated as a value and not a place.
-    Use {
+    ValueExpr {
         source: ExprId,
     },
     /// A coercion from `!` to any type.
diff --git a/compiler/rustc_middle/src/thir/visit.rs b/compiler/rustc_middle/src/thir/visit.rs
index 24aa4ac513d45..c76e993f92f7d 100644
--- a/compiler/rustc_middle/src/thir/visit.rs
+++ b/compiler/rustc_middle/src/thir/visit.rs
@@ -71,7 +71,7 @@ pub fn walk_expr<'thir, 'tcx: 'thir, V: Visitor<'thir, 'tcx>>(
         }
         Unary { arg, op: _ } => visitor.visit_expr(&visitor.thir()[arg]),
         Cast { source } => visitor.visit_expr(&visitor.thir()[source]),
-        Use { source } => visitor.visit_expr(&visitor.thir()[source]),
+        ValueExpr { source } => visitor.visit_expr(&visitor.thir()[source]),
         NeverToAny { source } => visitor.visit_expr(&visitor.thir()[source]),
         PointerCoercion { source, cast: _, is_from_as_cast: _ } => {
             visitor.visit_expr(&visitor.thir()[source])
diff --git a/compiler/rustc_middle/src/traits/mod.rs b/compiler/rustc_middle/src/traits/mod.rs
index 9736aabf29009..4dfc8d7c9705d 100644
--- a/compiler/rustc_middle/src/traits/mod.rs
+++ b/compiler/rustc_middle/src/traits/mod.rs
@@ -374,7 +374,7 @@ pub enum ObligationCauseCode<'tcx> {
 
     AwaitableExpr(HirId),
 
-    ForLoopIterator,
+    ForLoopIterator(HirId),
 
     QuestionMark,
 
diff --git a/compiler/rustc_middle/src/ty/abstract_const.rs b/compiler/rustc_middle/src/ty/abstract_const.rs
index f0692817fb60b..2853c43ae079d 100644
--- a/compiler/rustc_middle/src/ty/abstract_const.rs
+++ b/compiler/rustc_middle/src/ty/abstract_const.rs
@@ -11,9 +11,9 @@ use crate::ty::{
 #[derive(Hash, Debug, Clone, Copy, Ord, PartialOrd, PartialEq, Eq)]
 #[derive(TyDecodable, TyEncodable, StableHash, TypeVisitable, TypeFoldable)]
 pub enum CastKind {
-    /// thir::ExprKind::As
+    /// `thir::ExprKind::As`
     As,
-    /// thir::ExprKind::Use
+    /// `thir::ExprKind::ValueExpr`
     Use,
 }
 
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index 0ced7d1ea2bc5..3db521dfb5dee 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -210,8 +210,8 @@ pub struct PerOwnerResolverData<'tcx> {
     pub node_id_to_def_id: NodeMap<LocalDefId> = Default::default(),
     /// Whether lifetime elision was successful.
     pub lifetime_elision_allowed: bool = false,
-    /// Resolutions for labels.
-    /// Maps from NodeId of the break/continue expression to the NodeId of their corresponding blocks or loops.
+    /// Resolutions for labels. Maps from NodeId of the break/continue expression to the NodeId of
+    /// their corresponding blocks or loops.
     pub label_res_map: NodeMap<ast::NodeId> = Default::default(),
     /// Resolutions for lifetimes.
     pub lifetimes_res_map: NodeMap<LifetimeRes> = Default::default(),
@@ -221,7 +221,8 @@ pub struct PerOwnerResolverData<'tcx> {
     /// Resolution for import nodes, which have multiple resolutions in different namespaces.
     pub import_res: hir::def::PerNS<Option<Res<ast::NodeId>>> = Default::default(),
     /// Lifetime parameters that lowering will have to introduce.
-    pub extra_lifetime_params_map: NodeMap<Vec<(Ident, ast::NodeId, hir::MissingLifetimeKind)>> = Default::default(),
+    pub extra_lifetime_params_map: NodeMap<Vec<(Ident, ast::NodeId, hir::MissingLifetimeKind)>> =
+        Default::default(),
 
     /// The id of the owner
     pub id: ast::NodeId,
diff --git a/compiler/rustc_mir_build/src/builder/coverageinfo.rs b/compiler/rustc_mir_build/src/builder/coverageinfo.rs
index 75261fc89504d..09c32fe6008ca 100644
--- a/compiler/rustc_mir_build/src/builder/coverageinfo.rs
+++ b/compiler/rustc_mir_build/src/builder/coverageinfo.rs
@@ -120,7 +120,7 @@ impl CoverageInfoBuilder {
                 self.visit_with_not_info(thir, arg, not_info);
             }
             ExprKind::Scope { value, .. } => self.visit_with_not_info(thir, value, not_info),
-            ExprKind::Use { source } => self.visit_with_not_info(thir, source, not_info),
+            ExprKind::ValueExpr { source } => self.visit_with_not_info(thir, source, not_info),
             // All other expressions (including `&&` and `||`) don't need any
             // special handling of their contents, so stop visiting.
             _ => {}
@@ -190,7 +190,7 @@ impl<'tcx> Builder<'_, 'tcx> {
         };
 
         // Remove any wrappers, so that we can inspect the real underlying expression.
-        while let ExprKind::Use { source: inner } | ExprKind::Scope { value: inner, .. } =
+        while let ExprKind::ValueExpr { source: inner } | ExprKind::Scope { value: inner, .. } =
             self.thir[expr_id].kind
         {
             expr_id = inner;
diff --git a/compiler/rustc_mir_build/src/builder/expr/as_place.rs b/compiler/rustc_mir_build/src/builder/expr/as_place.rs
index 4c717d70c742b..22f424a724a81 100644
--- a/compiler/rustc_mir_build/src/builder/expr/as_place.rs
+++ b/compiler/rustc_mir_build/src/builder/expr/as_place.rs
@@ -553,7 +553,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             | ExprKind::Binary { .. }
             | ExprKind::LogicalOp { .. }
             | ExprKind::Cast { .. }
-            | ExprKind::Use { .. }
+            | ExprKind::ValueExpr { .. }
             | ExprKind::NeverToAny { .. }
             | ExprKind::PointerCoercion { .. }
             | ExprKind::Repeat { .. }
diff --git a/compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs b/compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs
index ea484bd05878b..76d9bd4d2ae45 100644
--- a/compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs
+++ b/compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs
@@ -385,7 +385,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             | ExprKind::Match { .. }
             | ExprKind::If { .. }
             | ExprKind::NeverToAny { .. }
-            | ExprKind::Use { .. }
+            | ExprKind::ValueExpr { .. }
             | ExprKind::Borrow { .. }
             | ExprKind::RawBorrow { .. }
             | ExprKind::Adt { .. }
@@ -600,7 +600,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             debug!(?kind, "check_constness");
             match kind {
                 &ExprKind::ValueTypeAscription { source: eid, user_ty: _, user_ty_span: _ }
-                | &ExprKind::Use { source: eid }
+                | &ExprKind::ValueExpr { source: eid }
                 | &ExprKind::PointerCoercion {
                     cast: PointerCoercion::Unsize,
                     source: eid,
diff --git a/compiler/rustc_mir_build/src/builder/expr/category.rs b/compiler/rustc_mir_build/src/builder/expr/category.rs
index 1a2f0a791b697..9e5e4c16d9d96 100644
--- a/compiler/rustc_mir_build/src/builder/expr/category.rs
+++ b/compiler/rustc_mir_build/src/builder/expr/category.rs
@@ -50,7 +50,7 @@ impl Category {
             | ExprKind::If { .. }
             | ExprKind::Let { .. }
             | ExprKind::NeverToAny { .. }
-            | ExprKind::Use { .. }
+            | ExprKind::ValueExpr { .. }
             | ExprKind::Adt { .. }
             | ExprKind::Borrow { .. }
             | ExprKind::RawBorrow { .. }
diff --git a/compiler/rustc_mir_build/src/builder/expr/into.rs b/compiler/rustc_mir_build/src/builder/expr/into.rs
index 39b6389018c8e..72135df46e904 100644
--- a/compiler/rustc_mir_build/src/builder/expr/into.rs
+++ b/compiler/rustc_mir_build/src/builder/expr/into.rs
@@ -569,7 +569,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     block.unit()
                 }
             }
-            ExprKind::Use { source } => this.expr_into_dest(destination, block, source),
+            ExprKind::ValueExpr { source } => this.expr_into_dest(destination, block, source),
             ExprKind::Borrow { arg, borrow_kind } => {
                 // We don't do this in `as_rvalue` because we use `as_place`
                 // for borrow expressions, so we cannot create an `RValue` that
diff --git a/compiler/rustc_mir_build/src/builder/matches/mod.rs b/compiler/rustc_mir_build/src/builder/matches/mod.rs
index de5a93b2c5a89..528300804c172 100644
--- a/compiler/rustc_mir_build/src/builder/matches/mod.rs
+++ b/compiler/rustc_mir_build/src/builder/matches/mod.rs
@@ -172,7 +172,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     this.lower_if_condition(block, value, args)
                 })
             }
-            ExprKind::Use { source } => this.lower_if_condition(block, source, args),
+            ExprKind::ValueExpr { source } => this.lower_if_condition(block, source, args),
             ExprKind::Let { expr, ref pat } => this.lower_let_expr(
                 block,
                 expr,
@@ -749,7 +749,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             ExprKind::Scope { value, .. } => {
                 self.declare_guard_bindings(value, scope_span, visibility_scope);
             }
-            ExprKind::Use { source } => {
+            ExprKind::ValueExpr { source } => {
                 self.declare_guard_bindings(source, scope_span, visibility_scope);
             }
             ExprKind::LogicalOp { op: LogicalOp::And, lhs, rhs } => {
diff --git a/compiler/rustc_mir_build/src/check_unsafety.rs b/compiler/rustc_mir_build/src/check_unsafety.rs
index ad07b91d673aa..c2366b78a7786 100644
--- a/compiler/rustc_mir_build/src/check_unsafety.rs
+++ b/compiler/rustc_mir_build/src/check_unsafety.rs
@@ -393,7 +393,7 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> {
             | ExprKind::If { .. }
             | ExprKind::InlineAsm { .. }
             | ExprKind::LogicalOp { .. }
-            | ExprKind::Use { .. }
+            | ExprKind::ValueExpr { .. }
             | ExprKind::Reborrow { .. } => {
                 // We don't need to save the old value and restore it
                 // because all the place expressions can't have more
diff --git a/compiler/rustc_mir_build/src/thir/cx/expr.rs b/compiler/rustc_mir_build/src/thir/cx/expr.rs
index fc82b8e2bc430..e7789e71af34c 100644
--- a/compiler/rustc_mir_build/src/thir/cx/expr.rs
+++ b/compiler/rustc_mir_build/src/thir/cx/expr.rs
@@ -312,7 +312,7 @@ impl<'tcx> ThirBuildCx<'tcx> {
         // using a coercion (or is a no-op).
         if self.typeck_results.is_coercion_cast(source.hir_id) {
             // Convert the lexpr to a vexpr.
-            ExprKind::Use { source: self.mirror_expr(source) }
+            ExprKind::ValueExpr { source: self.mirror_expr(source) }
         } else if self.typeck_results.expr_ty(source).is_ref() {
             // Special cased so that we can type check that the element
             // type of the source matches the pointed to type of the
@@ -1178,7 +1178,9 @@ impl<'tcx> ThirBuildCx<'tcx> {
                 ExprKind::WrapUnsafeBinder { source: mirrored }
             }
 
-            hir::ExprKind::DropTemps(source) => ExprKind::Use { source: self.mirror_expr(source) },
+            hir::ExprKind::DropTemps(source) => {
+                ExprKind::ValueExpr { source: self.mirror_expr(source) }
+            }
             hir::ExprKind::Array(fields) => ExprKind::Array { fields: self.mirror_exprs(fields) },
             hir::ExprKind::Tup(fields) => ExprKind::Tuple { fields: self.mirror_exprs(fields) },
 
@@ -1605,7 +1607,7 @@ impl<'tcx> ThirBuildCx<'tcx> {
                     name: field,
                 },
                 HirProjectionKind::OpaqueCast => {
-                    ExprKind::Use { source: self.thir.exprs.push(captured_place_expr) }
+                    ExprKind::ValueExpr { source: self.thir.exprs.push(captured_place_expr) }
                 }
                 HirProjectionKind::UnwrapUnsafeBinder => ExprKind::PlaceUnwrapUnsafeBinder {
                     source: self.thir.exprs.push(captured_place_expr),
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 5e69dc0624729..86a13736a4cff 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -314,7 +314,7 @@ impl<'p, 'tcx> MatchVisitor<'p, 'tcx> {
             // Casts don't cause a load.
             NeverToAny { source }
             | Cast { source }
-            | Use { source }
+            | ValueExpr { source }
             | PointerCoercion { source, .. }
             | PlaceTypeAscription { source, .. }
             | ValueTypeAscription { source, .. }
diff --git a/compiler/rustc_mir_build/src/thir/print.rs b/compiler/rustc_mir_build/src/thir/print.rs
index ddb56a04c308d..7cfd313218d33 100644
--- a/compiler/rustc_mir_build/src/thir/print.rs
+++ b/compiler/rustc_mir_build/src/thir/print.rs
@@ -301,8 +301,8 @@ impl<'a, 'tcx> ThirPrinter<'a, 'tcx> {
                 self.print_expr(*source, depth_lvl + 2);
                 print_indented!(self, "}", depth_lvl);
             }
-            Use { source } => {
-                print_indented!(self, "Use {", depth_lvl);
+            ValueExpr { source } => {
+                print_indented!(self, "ValueExpr {", depth_lvl);
                 print_indented!(self, "source:", depth_lvl + 1);
                 self.print_expr(*source, depth_lvl + 2);
                 print_indented!(self, "}", depth_lvl);
diff --git a/compiler/rustc_next_trait_solver/src/solve/project_goals/inherent.rs b/compiler/rustc_next_trait_solver/src/solve/project_goals/inherent.rs
index 51c2475a33461..20c0564b0eeba 100644
--- a/compiler/rustc_next_trait_solver/src/solve/project_goals/inherent.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/project_goals/inherent.rs
@@ -50,8 +50,11 @@ where
             }
             ty::AliasTermKind::InherentConstImpl { def_id } if cx.is_type_const(def_id.into()) => {
                 let inherent = cx.const_of_item(def_id.into()).instantiate(cx, inherent_args);
-                let inherent = self.normalize(GoalSource::Misc, goal.param_env, inherent)?;
-                inherent.into()
+                let normalized_ct = self.normalize(GoalSource::Misc, goal.param_env, inherent)?;
+                let normalized = normalized_ct.into();
+                let term = ty::AliasTerm::new_from_args(cx, inherent_kind, inherent_args);
+                self.push_const_arg_has_type_goal(goal.param_env, term, normalized)?;
+                normalized
             }
             ty::AliasTermKind::InherentConstImpl { .. } => {
                 let term = ty::AliasTerm::new_from_args(cx, inherent_kind, inherent_args);
@@ -68,11 +71,6 @@ where
             kind => panic!("expected inherent alias, found {kind:?}"),
         };
 
-        self.push_const_arg_has_type_goal(
-            goal.param_env,
-            goal.predicate.projection_term,
-            normalized,
-        )?;
         self.eq(goal.param_env, goal.predicate.term, normalized)?;
         self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
     }
diff --git a/compiler/rustc_parse/src/diagnostics.rs b/compiler/rustc_parse/src/diagnostics.rs
index 84786cdbf5c1e..a09b2a38593ed 100644
--- a/compiler/rustc_parse/src/diagnostics.rs
+++ b/compiler/rustc_parse/src/diagnostics.rs
@@ -3728,32 +3728,44 @@ impl HelpUseLatestEdition {
 }
 
 #[derive(Diagnostic)]
-#[diag("`box_syntax` has been removed")]
-pub(crate) struct BoxSyntaxRemoved {
+#[diag("`box` patterns have been removed (feature `box_patterns`)")]
+#[help("enable feature `deref_patterns` instead and...")]
+pub(crate) struct BoxPatsRemoved {
     #[primary_span]
     pub span: Span,
+    #[suggestion(
+        "...if possible just remove keyword `box`...",
+        code = "",
+        applicability = "maybe-incorrect",
+        style = "verbose"
+    )]
+    pub sugg_removal: Span,
     #[subdiagnostic]
-    pub sugg: AddBoxNew,
+    pub sugg_deref_macro_call: UseDerefMacro,
 }
 
-#[derive(Subdiagnostic)]
-#[multipart_suggestion(
-    "use `Box::new()` instead",
-    applicability = "machine-applicable",
-    style = "verbose"
-)]
-pub(crate) struct AddBoxNew {
-    #[suggestion_part(code = "Box::new(")]
-    pub box_kw_and_lo: Span,
-    #[suggestion_part(code = ")")]
-    pub hi: Span,
+pub(crate) struct UseDerefMacro {
+    pub field: Option<(Span, Ident)>,
+    pub before: Span,
+    pub after: Span,
 }
 
-#[derive(Diagnostic)]
-#[diag("`box_patterns` has been removed")]
-pub(crate) struct BoxPatternsRemoved {
-    #[primary_span]
-    pub span: Span,
+impl Subdiagnostic for UseDerefMacro {
+    fn add_to_diag<G: EmissionGuarantee>(self, diag: &mut Diag<'_, G>) {
+        let Self { field, before, after } = self;
+
+        let mut parts = Vec::new();
+        if let Some((span, field)) = field {
+            parts.push((span, format!("{field}: ")));
+        }
+        parts.push((before, "deref!(".into()));
+        parts.push((after, ")".into()));
+        diag.multipart_suggestion(
+            "...otherwise replace it with an invocation of macro `deref`",
+            parts,
+            Applicability::MaybeIncorrect,
+        );
+    }
 }
 
 #[derive(Diagnostic)]
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index 7227c814ce9d6..12de4957e99c2 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -542,9 +542,6 @@ impl<'a> Parser<'a> {
                 let operand_expr = this.parse_expr_dot_or_call(attrs)?;
                 this.recover_from_prefix_increment(operand_expr, pre_span, starts_stmt)
             }
-            token::Ident(..) if this.token.is_keyword(kw::Box) => {
-                make_it!(this, attrs, |this, _| this.parse_expr_box(lo))
-            }
             token::Ident(..)
                 if this.token.is_keyword(kw::Move)
                     && this.look_ahead(1, |t| *t == token::OpenParen) =>
@@ -582,19 +579,6 @@ impl<'a> Parser<'a> {
         self.parse_expr_unary(lo, UnOp::Not)
     }
 
-    /// Parse `box expr` - this syntax has been removed, but we still parse this
-    /// for now to provide a more useful error
-    fn parse_expr_box(&mut self, box_kw: Span) -> PResult<'a, (Span, ExprKind)> {
-        self.bump(); // `box`
-        let (span, expr) = self.parse_expr_prefix_common(box_kw)?;
-        // Make a multipart suggestion instead of `span_to_snippet` in case source isn't available
-        let box_kw_and_lo = box_kw.until(self.interpolated_or_expr_span(&expr));
-        let hi = span.shrink_to_hi();
-        let sugg = diagnostics::AddBoxNew { box_kw_and_lo, hi };
-        let guar = self.dcx().emit_err(diagnostics::BoxSyntaxRemoved { span, sugg });
-        Ok((span, ExprKind::Err(guar)))
-    }
-
     fn parse_expr_move(&mut self, move_kw: Span) -> PResult<'a, (Span, ExprKind)> {
         self.bump();
         self.psess.gated_spans.gate(sym::move_expr, move_kw);
diff --git a/compiler/rustc_parse/src/parser/pat.rs b/compiler/rustc_parse/src/parser/pat.rs
index 65d3de93f7199..64cc8ad9812f2 100644
--- a/compiler/rustc_parse/src/parser/pat.rs
+++ b/compiler/rustc_parse/src/parser/pat.rs
@@ -1650,8 +1650,15 @@ impl<'a> Parser<'a> {
             Ok(PatKind::Ident(BindingMode::NONE, Ident::new(kw::Box, box_span), sub))
         } else {
             let pat = Box::new(self.parse_pat_with_range_pat(false, None, None)?);
-            self.dcx().emit_err(diagnostics::BoxPatternsRemoved {
-                span: box_span.to(self.prev_token.span),
+            let before_span = box_span.until(pat.span);
+            self.dcx().emit_err(diagnostics::BoxPatsRemoved {
+                span: box_span,
+                sugg_deref_macro_call: diagnostics::UseDerefMacro {
+                    field: None,
+                    before: before_span,
+                    after: pat.span.shrink_to_hi(),
+                },
+                sugg_removal: before_span,
             });
             // Treat the box pattern like a deref pattern to avoid lots of "value not found" errors.
             Ok(PatKind::Deref(pat))
@@ -1905,12 +1912,13 @@ impl<'a> Parser<'a> {
             (pat, fieldname, false)
         } else {
             // FIXME: remove the recovery for parsing box patterrns entirely
-            let is_box = self.eat_keyword(exp!(Box));
-            if is_box {
-                self.dcx()
-                    .create_err(diagnostics::BoxPatternsRemoved { span: self.prev_token.span })
-                    .emit();
-            }
+            let is_box = if self.eat_keyword(exp!(Box)) {
+                let span = self.prev_token.span;
+                self.dcx().span_delayed_bug(span, "box patterns have been removed");
+                Some(span)
+            } else {
+                None
+            };
             let boxed_span = self.token.span;
             let mutability = self.parse_mutability();
             let by_ref = self.parse_byref();
@@ -1925,7 +1933,21 @@ impl<'a> Parser<'a> {
             ) {
                 self.psess.gated_spans.gate(sym::mut_ref, fieldpat.span);
             }
-            let subpat = if is_box {
+            let subpat = if let Some(box_span) = is_box {
+                let prefix_span = box_span.until(boxed_span);
+
+                self.dcx()
+                    .create_err(diagnostics::BoxPatsRemoved {
+                        span: box_span,
+                        sugg_deref_macro_call: diagnostics::UseDerefMacro {
+                            field: Some((prefix_span, fieldname)),
+                            before: boxed_span.shrink_to_lo(),
+                            after: hi.shrink_to_hi(),
+                        },
+                        sugg_removal: prefix_span,
+                    })
+                    .emit();
+
                 self.mk_pat(lo.to(hi), PatKind::Deref(Box::new(fieldpat)))
             } else {
                 fieldpat
diff --git a/compiler/rustc_parse/src/parser/ty.rs b/compiler/rustc_parse/src/parser/ty.rs
index 760b02622c678..31732882f7e86 100644
--- a/compiler/rustc_parse/src/parser/ty.rs
+++ b/compiler/rustc_parse/src/parser/ty.rs
@@ -1086,6 +1086,10 @@ impl<'a> Parser<'a> {
 
     /// Can the current token begin a bound?
     fn can_begin_bound(&mut self) -> bool {
+        // NOTE: Tokens `!`, `~`, `const` & `async` which represent the start of currently unstable
+        //       trait bound modifiers are intentionally not included in `Token::can_begin_type` to
+        //       avoid affecting stable macro matching behavior.
+
         self.check_path()
             || self.check_lifetime()
             || self.check(exp!(Bang))
diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs
index 37ec1dc01bd4b..7404b466f1d54 100644
--- a/compiler/rustc_passes/src/stability.rs
+++ b/compiler/rustc_passes/src/stability.rs
@@ -932,9 +932,6 @@ impl<'tcx> Visitor<'tcx> for CheckTraitImplStable<'tcx> {
     }
 
     fn visit_ty(&mut self, t: &'tcx Ty<'tcx, AmbigArg>) {
-        if let TyKind::Never = t.kind {
-            self.fully_stable = false;
-        }
         if let TyKind::FnPtr(function) = t.kind {
             if extern_abi_stability(function.abi).is_err() {
                 self.fully_stable = false;
@@ -942,18 +939,6 @@ impl<'tcx> Visitor<'tcx> for CheckTraitImplStable<'tcx> {
         }
         intravisit::walk_ty(self, t)
     }
-
-    fn visit_fn_decl(&mut self, fd: &'tcx hir::FnDecl<'tcx>) {
-        for ty in fd.inputs {
-            self.visit_ty_unambig(ty)
-        }
-        if let hir::FnRetTy::Return(output_ty) = fd.output {
-            match output_ty.kind {
-                TyKind::Never => {} // `-> !` is stable
-                _ => self.visit_ty_unambig(output_ty),
-            }
-        }
-    }
 }
 
 /// Given the list of enabled features that were not language features (i.e., that
diff --git a/compiler/rustc_resolve/src/diagnostics/impls.rs b/compiler/rustc_resolve/src/diagnostics/impls.rs
index 47a05b3f65d86..9a84985bed51a 100644
--- a/compiler/rustc_resolve/src/diagnostics/impls.rs
+++ b/compiler/rustc_resolve/src/diagnostics/impls.rs
@@ -3622,10 +3622,15 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 }
             } else {
                 // If the root import is module-relative, add the import separately
-                corrections.push((
-                    import.use_span.shrink_to_lo(),
-                    format!("use {module_name}::{import_snippet};\n"),
-                ));
+                if let Ok(vis) = source_map.span_to_snippet(import.vis_span)
+                    && let Some(indentation) = source_map.indentation_before(import.use_span)
+                {
+                    let vis = if vis.trim().is_empty() { String::new() } else { format!("{vis} ") };
+                    corrections.push((
+                        import.use_span.shrink_to_lo(),
+                        format!("{vis}use {module_name}::{import_snippet};\n{indentation}"),
+                    ));
+                }
             }
         }
 
diff --git a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/encode.rs b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/encode.rs
index e51f571db857c..b0462ab4867cb 100644
--- a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/encode.rs
+++ b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/encode.rs
@@ -19,6 +19,7 @@ use rustc_middle::ty::{
     IntTy, List, Region, RegionKind, TermKind, Ty, TyCtxt, TypeFoldable, UintTy,
 };
 use rustc_span::def_id::DefId;
+use rustc_target::spec::Arch;
 use tracing::instrument;
 
 use crate::cfi::typeid::TypeIdOptions;
@@ -469,7 +470,10 @@ pub(crate) fn encode_ty<'tcx>(
                 FloatTy::F16 => "Dh",
                 FloatTy::F32 => "f",
                 FloatTy::F64 => "d",
-                FloatTy::F128 => "g",
+                FloatTy::F128 => match tcx.sess.target.arch {
+                    Arch::PowerPC | Arch::PowerPC64 => "u9__ieee128", // "g" is used for __ibm128
+                    _ => "g",
+                },
             });
         }
 
@@ -552,9 +556,10 @@ pub(crate) fn encode_ty<'tcx>(
                 // Don't compress user-defined builtin types (see
                 // https://itanium-cxx-abi.github.io/cxx-abi/abi.html#mangling-builtin and
                 // https://itanium-cxx-abi.github.io/cxx-abi/abi.html#mangling-compression).
+                #[rustfmt::skip]
                 let builtin_types = [
                     "v", "w", "b", "c", "a", "h", "s", "t", "i", "j", "l", "m", "x", "y", "n", "o",
-                    "f", "d", "e", "g", "z", "Dh",
+                    "f", "d", "e", "g", "z", "Dh", "u9__ieee128",
                 ];
                 if !builtin_types.contains(&encoding) {
                     compress(dict, DictKey::Ty(ty, TyQ::None), &mut s);
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 3fcb59ea2d701..768f1be1cd48d 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -774,7 +774,6 @@ symbols! {
         debug_assert_macro,
         debug_assert_ne_macro,
         debug_assertions,
-        debug_c_like_enum_write_str,
         debug_struct_fields_finish,
         debug_tuple_fields_finish,
         debugger_visualizer,
diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_fuchsia.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_fuchsia.rs
index dbff5e30828a9..b8fb1fb6d3a52 100644
--- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_fuchsia.rs
+++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_fuchsia.rs
@@ -9,7 +9,9 @@ pub(crate) fn target() -> Target {
     base.features = "+cmpxchg16b,+lahfsahf,+popcnt,+sse3,+sse4.1,+sse4.2,+ssse3".into();
     base.max_atomic_width = Some(128);
     base.stack_probes = StackProbeType::Inline;
-    base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::CFI | SanitizerSet::LEAK;
+    base.supported_sanitizers =
+        SanitizerSet::ADDRESS | SanitizerSet::CFI | SanitizerSet::LEAK | SanitizerSet::SAFESTACK;
+    base.default_sanitizers = SanitizerSet::SAFESTACK;
     base.supports_xray = true;
 
     Target {
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
index c4ad541e5b30c..3e7b3d2ae2daa 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
@@ -79,7 +79,6 @@ use crate::error_reporting::traits::ambiguity::{
 use crate::infer;
 use crate::infer::relate::{self, RelateResult, TypeRelation};
 use crate::infer::{InferCtxt, InferCtxtExt as _, TypeTrace, ValuePairs};
-use crate::solve::deeply_normalize_for_diagnostics;
 use crate::traits::{
     MatchExpressionArmCause, Obligation, ObligationCause, ObligationCauseCode, ObligationCtxt,
     specialization_graph,
@@ -1577,10 +1576,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         let (expected_found, exp_found, is_simple_error, values, param_env) = match values {
             None => (None, Mismatch::Fixed("type"), false, None, None),
             Some(ty::ParamEnvAnd { param_env, value: values }) => {
-                let mut values = self.resolve_vars_if_possible(values);
-                if self.next_trait_solver() {
-                    values = deeply_normalize_for_diagnostics(self, param_env, values);
-                }
+                let values = self.resolve_vars_if_possible(values);
                 let (is_simple_error, exp_found) = match values {
                     ValuePairs::Terms(ExpectedFound { expected, found }) => {
                         match (expected.kind(), found.kind()) {
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
index 11b051b530198..29ae564d9eb9a 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
@@ -1669,8 +1669,6 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         bound_predicate.rebind(data),
                     );
                     let unnormalized_term = data.projection_term.to_term(self.tcx, ty::IsRigid::No);
-                    // FIXME(-Znext-solver): For diagnostic purposes, it would be nice
-                    // to deeply normalize this type.
                     let normalized_term = ocx.normalize(
                         &obligation.cause,
                         obligation.param_env,
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
index 7921250a85a9e..a7f05d756af0f 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
@@ -1119,12 +1119,29 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             .collect::<Vec<_>>()
             .join(", ");
 
-        if let ObligationCauseCode::FunctionArg { arg_hir_id, .. } = obligation.cause.code()
-            && obligation.cause.span.can_be_used_for_suggestions()
-        {
+        let callee_hir_id = match obligation.cause.code() {
+            ObligationCauseCode::FunctionArg { arg_hir_id, .. }
+                if obligation.cause.span.can_be_used_for_suggestions() =>
+            {
+                Some(*arg_hir_id)
+            }
+            // The iterator of a `for` loop is passed to `IntoIterator::into_iter`, so the failing
+            // `Iterator` goal is a derived obligation and `cause.span` carries the loop's
+            // desugaring context. The expression is still the user's, which its own span attests.
+            code => match code.peel_derives() {
+                ObligationCauseCode::ForLoopIterator(iter_hir_id)
+                    if self.tcx.hir_span(*iter_hir_id).can_be_used_for_suggestions() =>
+                {
+                    Some(*iter_hir_id)
+                }
+                _ => None,
+            },
+        };
+
+        if let Some(callee_hir_id) = callee_hir_id {
             let span = obligation.cause.span;
 
-            let arg_expr = match self.tcx.hir_node(*arg_hir_id) {
+            let arg_expr = match self.tcx.hir_node(callee_hir_id) {
                 hir::Node::Expr(expr) => Some(expr),
                 _ => None,
             };
@@ -3779,7 +3796,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             | ObligationCauseCode::ReturnValue(_)
             | ObligationCauseCode::BlockTailExpression(..)
             | ObligationCauseCode::AwaitableExpr(_)
-            | ObligationCauseCode::ForLoopIterator
+            | ObligationCauseCode::ForLoopIterator(_)
             | ObligationCauseCode::QuestionMark
             | ObligationCauseCode::CheckAssociatedTypeBounds { .. }
             | ObligationCauseCode::LetElse
diff --git a/compiler/rustc_trait_selection/src/traits/wf.rs b/compiler/rustc_trait_selection/src/traits/wf.rs
index dc29b6311cc7e..fc16b6d44c310 100644
--- a/compiler/rustc_trait_selection/src/traits/wf.rs
+++ b/compiler/rustc_trait_selection/src/traits/wf.rs
@@ -504,7 +504,16 @@ impl<'a, 'tcx> WfPredicates<'a, 'tcx> {
         // (*) The predicates of an inherent associated type include the
         //     predicates of the impl that it's contained in.
 
-        if !data.self_ty().has_escaping_bound_vars() {
+        // In an ideal world, there are no escaping bound vars here. However, WF is jank, and
+        // sometimes there are. We can only `compute_inherent_assoc_term_args` if the Self ty in the
+        // args has no escaping bound vars. If we already have impl format args, though,
+        // `compute_inherent_assoc_term_args` is a no-op (and we have no Self type), so no need to
+        // check for escaping bound vars.
+        let can_compute_impl_args =
+            matches!(data.kind, ty::AliasTermKind::InherentConstImpl { .. })
+                || !data.self_ty().has_escaping_bound_vars();
+
+        if can_compute_impl_args {
             // FIXME(inherent_associated_types): Should this happen inside of a snapshot?
             // FIXME(inherent_associated_types): This is incompatible with the new solver and lazy norm!
             let args = traits::project::compute_inherent_assoc_term_args(
@@ -1099,10 +1108,12 @@ impl<'a, 'tcx> TypeVisitor<TyCtxt<'tcx>> for WfPredicates<'a, 'tcx> {
                             self.add_wf_preds_for_inherent_projection(alias_const.into());
                             return; // Subtree is handled by above function
                         }
-                        // please ping khyperia and/or BoxyUwU if this `bug!` fires
-                        ty::AliasConstKind::InherentImpl { .. } => bug!(
-                            "This ought to be unreachable, the entrypoints of WF should still have InherentSelf-form alias consts."
-                        ),
+                        // FIXME: This should be unreachable but isn't because we normalize in item
+                        // wfck before computing wf requirements
+                        ty::AliasConstKind::InherentImpl { .. } => {
+                            self.add_wf_preds_for_inherent_projection(alias_const.into());
+                            return;
+                        }
                         ty::AliasConstKind::Projection { def_id }
                         | ty::AliasConstKind::Free { def_id }
                         | ty::AliasConstKind::Anon { def_id } => {
diff --git a/compiler/rustc_ty_utils/src/consts.rs b/compiler/rustc_ty_utils/src/consts.rs
index d48438819040a..6db234fd886ca 100644
--- a/compiler/rustc_ty_utils/src/consts.rs
+++ b/compiler/rustc_ty_utils/src/consts.rs
@@ -119,10 +119,10 @@ fn recurse_build<'tcx>(
                 maybe_supported_error(GenericConstantTooComplexSub::BlockNotSupported(node.span))?
             }
         }
-        // `ExprKind::Use` happens when a `hir::ExprKind::Cast` is a
+        // `ExprKind::ValueExpr` happens when a `hir::ExprKind::Cast` is a
         // "coercion cast" i.e. using a coercion or is a no-op.
         // This is important so that `N as usize as usize` doesn't unify with `N as usize`. (untested)
-        &ExprKind::Use { source } => {
+        &ExprKind::ValueExpr { source } => {
             let value_ty = body.exprs[source].ty;
             let value = recurse_build(tcx, body, source, root_span)?;
             ty::Const::new_expr(tcx, Expr::new_cast(tcx, CastKind::Use, value_ty, value, node.ty))
@@ -279,7 +279,7 @@ impl<'a, 'tcx> IsThirPolymorphic<'a, 'tcx> {
             | thir::ExprKind::LogicalOp { .. }
             | thir::ExprKind::Unary { .. }
             | thir::ExprKind::Cast { .. }
-            | thir::ExprKind::Use { .. }
+            | thir::ExprKind::ValueExpr { .. }
             | thir::ExprKind::NeverToAny { .. }
             | thir::ExprKind::PointerCoercion { .. }
             | thir::ExprKind::Loop { .. }
diff --git a/compiler/rustc_type_ir/src/term_kind.rs b/compiler/rustc_type_ir/src/term_kind.rs
index bb4ebf054d263..ed23b196fe269 100644
--- a/compiler/rustc_type_ir/src/term_kind.rs
+++ b/compiler/rustc_type_ir/src/term_kind.rs
@@ -1,3 +1,5 @@
+use std::debug_assert_matches;
+
 use derive_where::derive_where;
 #[cfg(feature = "nightly")]
 use rustc_macros::{Decodable_NoContext, Encodable_NoContext, StableHash_NoContext};
@@ -265,11 +267,25 @@ impl<I: Interner> AliasTerm<I> {
 /// The following methods work only with (trait) associated term projections.
 // FIXME: Replace by an impl on Alias<ProjectionAliasTermKind>
 impl<I: Interner> AliasTerm<I> {
+    fn debug_assert_has_self(self) {
+        // InherentConstImpl is deliberately omitted here, it is not self-format args
+        debug_assert_matches!(
+            self.kind,
+            AliasTermKind::ProjectionTy { .. }
+                | AliasTermKind::ProjectionConst { .. }
+                | AliasTermKind::InherentTy { .. }
+                | AliasTermKind::InherentConstSelf { .. },
+            "AliasTerm::self_ty is only valid on projection and inherent aliases"
+        );
+    }
+
     pub fn self_ty(self) -> I::Ty {
+        self.debug_assert_has_self();
         self.args.type_at(0)
     }
 
     pub fn with_replaced_self_ty(self, interner: I, self_ty: I::Ty) -> Self {
+        self.debug_assert_has_self();
         AliasTerm::new(
             interner,
             self.kind,
diff --git a/library/core/src/cmp/clamp.rs b/library/core/src/cmp/clamp.rs
index a737b59bbbe51..e42cd7fb39f29 100644
--- a/library/core/src/cmp/clamp.rs
+++ b/library/core/src/cmp/clamp.rs
@@ -66,6 +66,7 @@ macro impl_for_float($t:ty) {
     #[unstable(feature = "clamp_bounds", issue = "147781")]
     #[rustc_const_unstable(feature = "clamp_bounds", issue = "147781")]
     const impl ClampBounds<$t> for RangeFrom<$t> {
+        #[inline]
         fn clamp(self, value: $t) -> $t {
             assert!(!self.start.is_nan(), "start was NaN");
             value.max(self.start)
@@ -75,6 +76,7 @@ macro impl_for_float($t:ty) {
     #[unstable(feature = "clamp_bounds", issue = "147781")]
     #[rustc_const_unstable(feature = "clamp_bounds", issue = "147781")]
     const impl ClampBounds<$t> for RangeToInclusive<$t> {
+        #[inline]
         fn clamp(self, value: $t) -> $t {
             assert!(!self.end.is_nan(), "end was NaN");
             value.min(self.end)
@@ -88,6 +90,7 @@ macro impl_for_float($t:ty) {
             clippy::neg_cmp_op_on_partial_ord,
             reason = "NaN check is intentionally included in comparison"
         )]
+        #[inline]
         fn clamp(self, value: $t) -> $t {
             let (start, end) = self.into_inner();
             assert!(start <= end, "start > end, or either was NaN");
diff --git a/library/core/src/convert/num.rs b/library/core/src/convert/num.rs
index 64e429b2f2591..c0d8fd670d7ad 100644
--- a/library/core/src/convert/num.rs
+++ b/library/core/src/convert/num.rs
@@ -336,8 +336,7 @@ macro_rules! impl_try_from_unbounded {
             type Error = TryFromIntError;
 
             /// Tries to create the target number type from a source
-            /// number type. This returns an error if the source value
-            /// is outside of the range of the target type.
+            /// number type. This never returns an error.
             #[inline]
             fn try_from(value: $source) -> Result<Self, Self::Error> {
                 Ok(value as Self)
@@ -356,7 +355,7 @@ macro_rules! impl_try_from_lower_bounded {
 
             /// Tries to create the target number type from a source
             /// number type. This returns an error if the source value
-            /// is outside of the range of the target type.
+            #[doc = concat!("is less than [`", stringify!($target), "::MIN`].")]
             #[inline]
             fn try_from(u: $source) -> Result<Self, Self::Error> {
                 if u >= 0 {
@@ -379,7 +378,7 @@ macro_rules! impl_try_from_upper_bounded {
 
             /// Tries to create the target number type from a source
             /// number type. This returns an error if the source value
-            /// is outside of the range of the target type.
+            #[doc = concat!("is greater than [`", stringify!($target), "::MAX`].")]
             #[inline]
             fn try_from(u: $source) -> Result<Self, Self::Error> {
                 if u > (Self::MAX as $source) {
diff --git a/library/core/src/fmt/mod.rs b/library/core/src/fmt/mod.rs
index a77910b1475f4..43dba18375992 100644
--- a/library/core/src/fmt/mod.rs
+++ b/library/core/src/fmt/mod.rs
@@ -2577,21 +2577,6 @@ impl<'a> Formatter<'a> {
         builder.finish()
     }
 
-    /// Shrinks `derive(Debug)` code, for faster compilation and smaller binaries.
-    /// For C-like enums with concatenated variant name strings.
-    #[doc(hidden)]
-    #[unstable(feature = "fmt_helpers_for_derive", issue = "none")]
-    pub fn debug_c_like_enum_write_str<'b>(
-        &'b mut self,
-        names: &str,
-        offset: &[usize],
-        discr: usize,
-    ) -> Result {
-        let start = offset[discr];
-        let end = offset[discr + 1];
-        self.write_str(&names[start..end])
-    }
-
     /// Creates a `DebugTuple` builder designed to assist with creation of
     /// `fmt::Debug` implementations for tuple structs.
     ///
diff --git a/library/core/src/ptr/mod.rs b/library/core/src/ptr/mod.rs
index f1b81de50942a..9019e3a486921 100644
--- a/library/core/src/ptr/mod.rs
+++ b/library/core/src/ptr/mod.rs
@@ -2082,10 +2082,10 @@ pub const unsafe fn write_unaligned<T>(dst: *mut T, src: T) {
 ///   semantics associated to their manipulation, and cannot be used as general purpose memory.
 ///   Here, any address value is possible, including 0 and [`usize::MAX`], so long as the semantics
 ///   of such a read are well-defined by the target hardware. The provenance of the pointer is
-///   irrelevant, and it can be created with [`without_provenance`]. The access must not trap. It
-///   can cause side-effects, but those must not affect Rust-allocated memory in any way. This
-///   access is still not considered [atomic], and as such it cannot be used for inter-thread
-///   synchronization.
+///   irrelevant, and it can be created with [`without_provenance`]. The access is allowed to trap,
+///   which must immediately abort the process. It can also cause other side-effects, but those
+///   must not affect Rust-allocated memory in any way. This access is still not considered
+///   [atomic], and as such it cannot be used for inter-thread synchronization.
 ///
 /// Note that volatile memory operations where T is a zero-sized type are noops and may be ignored.
 ///
@@ -2120,9 +2120,8 @@ pub const unsafe fn write_unaligned<T>(dst: *mut T, src: T) {
 /// Behavior is undefined if any of the following conditions are violated:
 ///
 /// * `src` must be either [valid] for reads, or `T` must be a ZST, or `src` must point to memory
-///   outside of all Rust allocations and reading from that memory must:
-///   - not trap, and
-///   - not cause any memory inside a Rust allocation to be modified.
+///   outside of all Rust allocations and reading from that memory must not cause any memory inside
+///   a Rust allocation to be modified.
 ///
 /// * `src` must be properly aligned.
 ///
@@ -2189,10 +2188,10 @@ pub const unsafe fn read_volatile<T>(src: *const T) -> T {
 ///   semantics associated to their manipulation, and cannot be used as general purpose memory.
 ///   Here, any address value is possible, including 0 and [`usize::MAX`], so long as the semantics
 ///   of such a write are well-defined by the target hardware. The provenance of the pointer is
-///   irrelevant, and it can be created with [`without_provenance_mut`]. The access must not trap. It
-///   can cause side-effects, but those must not affect Rust-allocated memory in any way. This
-///   access is still not considered [atomic], and as such it cannot be used for inter-thread
-///   synchronization.
+///   irrelevant, and it can be created with [`without_provenance_mut`]. The access is allowed to
+///   trap, which must immediately abort the process. It can also cause other side-effects, but
+///   those must not affect Rust-allocated memory in any way. This access is still not considered
+///   [atomic], and as such it cannot be used for inter-thread synchronization.
 ///
 /// Note that volatile memory operations on zero-sized types (e.g., if a zero-sized type is passed
 /// to `write_volatile`) are noops and may be ignored.
@@ -2228,9 +2227,8 @@ pub const unsafe fn read_volatile<T>(src: *const T) -> T {
 /// Behavior is undefined if any of the following conditions are violated:
 ///
 /// * `dst` must be either [valid] for writes, or `T` must be a ZST, or `dst` must point to memory
-///   outside of all Rust allocations and writing to that memory must:
-///   - not trap, and
-///   - not cause any memory inside a Rust allocation to be modified.
+///   outside of all Rust allocations and writing to that memory must not cause any memory inside a
+///   Rust allocation to be modified.
 ///
 /// * `dst` must be properly aligned.
 ///
diff --git a/library/core/src/sync/atomic_load_volatile.md b/library/core/src/sync/atomic_load_volatile.md
index be02c4bcfeccf..a2cc3275f41a8 100644
--- a/library/core/src/sync/atomic_load_volatile.md
+++ b/library/core/src/sync/atomic_load_volatile.md
@@ -17,8 +17,9 @@ are two cases of usage that need to be distinguished:
   associated to their manipulation, and cannot be used as general purpose memory. Here, any address
   value is possible, including 0 and [`usize::MAX`], so long as the semantics of such a read are
   well-defined by the target hardware. The provenance of the pointer is irrelevant, and it can be
-  created with [`without_provenance`][crate::ptr::without_provenance]. The access must not trap. It
-  can cause side-effects, but those must not affect Rust-allocated memory in any way.
+  created with [`without_provenance`][crate::ptr::without_provenance]. The access is allowed to
+  trap, which must immediately abort the process. It can also cause other side-effects, but those
+  must not affect Rust-allocated memory in any way.
 
 In both cases, the access is also considered atomic with the given `order`. This allows
 synchronization with other threads or devices that share memory with this program.
diff --git a/library/core/src/sync/atomic_store_volatile.md b/library/core/src/sync/atomic_store_volatile.md
index bb78099020c15..e72622dea86bb 100644
--- a/library/core/src/sync/atomic_store_volatile.md
+++ b/library/core/src/sync/atomic_store_volatile.md
@@ -16,8 +16,9 @@ usage that need to be distinguished:
   associated to their manipulation, and cannot be used as general purpose memory. Here, any address
   value is possible, including 0 and [`usize::MAX`], so long as the semantics of such a write are
   well-defined by the target hardware. The provenance of the pointer is irrelevant, and it can be
-  created with [`without_provenance_mut`][crate::ptr::without_provenance_mut]. The access must not
-  trap. It can cause side-effects, but those must not affect Rust-allocated memory in any way.
+  created with [`without_provenance_mut`][crate::ptr::without_provenance_mut]. The access is allowed
+  to trap, which must immediately abort the process. It can also cause other side-effects, but those
+  must not affect Rust-allocated memory in any way.
 
 In both cases, the access is also considered atomic with the given `order`. This allows
 synchronization with other threads or devices that share memory with this program.
diff --git a/library/core/src/time.rs b/library/core/src/time.rs
index 816da7a2fb7f2..f9e2dc6b7f849 100644
--- a/library/core/src/time.rs
+++ b/library/core/src/time.rs
@@ -345,6 +345,8 @@ impl Duration {
 
     /// Creates a new `Duration` from the specified number of weeks.
     ///
+    /// For this method, one week is defined as 7 days, or 604,800 seconds.
+    ///
     /// # Panics
     ///
     /// Panics if the given number of weeks overflows the `Duration` size.
@@ -373,6 +375,8 @@ impl Duration {
 
     /// Creates a new `Duration` from the specified number of days.
     ///
+    /// For this method, one day is defined as 24 hours, or 86,400 seconds.
+    ///
     /// # Panics
     ///
     /// Panics if the given number of days overflows the `Duration` size.
@@ -401,6 +405,8 @@ impl Duration {
 
     /// Creates a new `Duration` from the specified number of hours.
     ///
+    /// For this method, one hour is defined as 60 minutes, or 3,600 seconds.
+    ///
     /// # Panics
     ///
     /// Panics if the given number of hours overflows the `Duration` size.
@@ -429,6 +435,8 @@ impl Duration {
 
     /// Creates a new `Duration` from the specified number of minutes.
     ///
+    /// For this method, one minute is defined as 60 seconds.
+    ///
     /// # Panics
     ///
     /// Panics if the given number of minutes overflows the `Duration` size.
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index c2007433ff5ea..817d208a8a620 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -390,6 +390,7 @@
 #![feature(str_internals)]
 #![feature(sync_unsafe_cell)]
 #![feature(temporary_niche_types)]
+#![feature(trim_prefix_suffix)]
 #![feature(ub_checks)]
 #![feature(uint_carryless_mul)]
 #![feature(unsafe_pinned)]
diff --git a/library/std/src/sys/fs/unix.rs b/library/std/src/sys/fs/unix.rs
index 74b4322d027c5..5ea6cd03812f6 100644
--- a/library/std/src/sys/fs/unix.rs
+++ b/library/std/src/sys/fs/unix.rs
@@ -1884,6 +1884,13 @@ pub fn set_perm(p: &CStr, perm: FilePermissions) -> io::Result<()> {
     cvt_r(|| unsafe { libc::chmod(p.as_ptr(), perm.mode) }).map(|_| ())
 }
 
+#[cfg(target_os = "vxworks")]
+pub fn set_perm_nofollow(_p: &CStr, _perm: FilePermissions) -> io::Result<()> {
+    // VxWorks has no `O_NOFOLLOW`, and its `fchmodat` rejects
+    // `AT_SYMLINK_NOFOLLOW` with `ENOTSUP`, so a no-follow chmod is unsupported.
+    Err(crate::io::ErrorKind::Unsupported.into())
+}
+
 #[cfg(target_os = "android")]
 pub fn set_perm_nofollow(_p: &CStr, _perm: FilePermissions) -> io::Result<()> {
     // Currently Android seems to be having inconsistent behavior with fchmodat
@@ -1896,7 +1903,7 @@ pub fn set_perm_nofollow(_p: &CStr, _perm: FilePermissions) -> io::Result<()> {
     Err(crate::io::ErrorKind::Unsupported.into())
 }
 
-#[cfg(not(target_os = "android"))]
+#[cfg(not(any(target_os = "android", target_os = "vxworks")))]
 pub fn set_perm_nofollow(p: &CStr, perm: FilePermissions) -> io::Result<()> {
     #[inline]
     /// Helper function for fallback open with `O_NOFOLLOW` + `fchmod` behavior
diff --git a/library/std/src/sys/fs/windows.rs b/library/std/src/sys/fs/windows.rs
index c99524375113a..2889a17f6780f 100644
--- a/library/std/src/sys/fs/windows.rs
+++ b/library/std/src/sys/fs/windows.rs
@@ -6,6 +6,7 @@ use crate::ffi::{OsStr, OsString, c_void};
 use crate::fs::TryLockError;
 use crate::io::{self, BorrowedCursor, Error, IoSlice, IoSliceMut, SeekFrom};
 use crate::mem::{self, MaybeUninit, offset_of};
+use crate::os::windows::ffi::{OsStrExt, OsStringExt};
 use crate::os::windows::io::{AsHandle, BorrowedHandle};
 use crate::os::windows::prelude::*;
 use crate::path::{Path, PathBuf};
@@ -18,6 +19,9 @@ use crate::sys::time::SystemTime;
 use crate::sys::{Align8, AsInner, FromInner, IntoInner, c, cvt};
 use crate::{fmt, ptr, slice};
 
+#[cfg(test)]
+mod tests;
+
 mod dir;
 pub use dir::Dir;
 mod remove_dir_all;
@@ -1591,14 +1595,77 @@ pub fn set_times_nofollow(p: &WCStr, times: FileTimes) -> io::Result<()> {
 }
 
 fn get_path(f: impl AsRawHandle) -> io::Result<PathBuf> {
+    let h = f.as_raw_handle();
+    // If getting the canonical path fails with ERROR_INVALID_FUNCTION
+    // then it's likely it failed to resolve the path's drive.
+    // In that case, use the fallback method to resolve it.
+    let invalid_function = Some(c::ERROR_INVALID_FUNCTION as i32);
+    match get_path_canonical(h) {
+        Err(e) if e.raw_os_error() == invalid_function => get_path_fallback(h).ok_or(e),
+        result => result,
+    }
+}
+
+fn get_path_canonical(handle: c::HANDLE) -> io::Result<PathBuf> {
     fill_utf16_buf(
-        |buf, sz| unsafe {
-            c::GetFinalPathNameByHandleW(f.as_raw_handle(), buf, sz, c::VOLUME_NAME_DOS)
-        },
+        |buf, sz| unsafe { c::GetFinalPathNameByHandleW(handle, buf, sz, c::VOLUME_NAME_DOS) },
         |buf| PathBuf::from(OsString::from_wide(buf)),
     )
 }
 
+/// Fallback in case `get_path_canonical` fails.
+///
+/// `get_path_canonical` can fail if the Win32 drive name cannot be resolved.
+/// This can happen with certain third party drivers that don't integrate
+/// with the mount manager.
+///
+/// Instead we manually do the same job by getting the NT path
+/// and then finding the first drive letter that points to a prefix of
+/// that path. From there we can construct a Win32 path.
+///
+/// It's implemented by first getting the NT path, which should always succeed.
+/// Then we use [`GetLogicalDrives`] to get a bit array of win32 drive letters
+/// from 'A' to 'Z'. If the corresponding bit is set then it means that drive exists.
+/// E.g. bit 2 being set means there's a `C:` drive.
+///
+/// Then for each drive we use [`QueryDosDeviceW`] to see the NT path that drive resolves to.
+/// If that path is a prefix to the path we got initially then we treat that as the canonical drive letter.
+/// So in the unlikely even two drives point to the same device, the lowest one is considered canonical.
+///
+/// [`GetLogicalDrives`]: https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-getlogicaldrives
+/// [`QueryDosDeviceW`]:
+fn get_path_fallback(handle: c::HANDLE) -> Option<PathBuf> {
+    fill_utf16_buf(
+        |buf, sz| unsafe { c::GetFinalPathNameByHandleW(handle, buf, sz, c::VOLUME_NAME_NT) },
+        |nt_path| {
+            let mut buf = [0_u16; c::MAX_PATH as usize];
+            for letter in api::get_logical_drives() {
+                let device_name = [letter as u16, b':' as u16, 0];
+                // SAFETY: `device_name` is a null terminated u16 string
+                if let Some(drive_path) = unsafe { api::query_dos_device(&device_name, &mut buf) } {
+                    if let Some(nt_path) = nt_path.strip_prefix(drive_path) {
+                        // Reserve approximately enough space for the drive + path.
+                        let mut path = Vec::with_capacity(r"\\?\C:".len() + nt_path.len());
+                        // Create a verbatim drive root (e.g. \\?\D:)
+                        let mut verbatim_root = *br#"\\?\C:"#;
+                        verbatim_root[4] = letter;
+                        path.extend_from_slice(&verbatim_root);
+                        path.extend(OsString::from_wide(nt_path).into_encoded_bytes());
+                        // SAFETY: All characters are either in the ASCII range (the prefix)
+                        // or else came from an OsString.
+                        unsafe {
+                            return Some(OsString::from_encoded_bytes_unchecked(path).into());
+                        }
+                    }
+                }
+            }
+            None
+        },
+    )
+    .ok()
+    .flatten()
+}
+
 pub fn canonicalize(p: &WCStr) -> io::Result<PathBuf> {
     let mut opts = OpenOptions::new();
     // No read or write permissions are necessary
diff --git a/library/std/src/sys/fs/windows/tests.rs b/library/std/src/sys/fs/windows/tests.rs
new file mode 100644
index 0000000000000..b53dfddecf627
--- /dev/null
+++ b/library/std/src/sys/fs/windows/tests.rs
@@ -0,0 +1,21 @@
+use super::{get_path_canonical, get_path_fallback};
+use crate::env;
+use crate::fs::{File, canonicalize};
+use crate::os::windows::io::AsRawHandle;
+use crate::test_helpers::tmpdir;
+
+#[test]
+/// Test that `get_path_canonical` and `get_path_fallback` return the exact same path.
+fn canonicalize_fallback() {
+    let t = tmpdir();
+    let fname = t.join("hello.txt");
+    // This test may break if run in an environment that requires the fallback.
+    // So skip it if not in CI.
+    if env::var_os("CI").is_none() && canonicalize(&fname).is_err() {
+        return;
+    }
+    let f = File::create(fname).unwrap();
+    let canonical = get_path_canonical(f.as_raw_handle()).unwrap();
+    let fallback = get_path_fallback(f.as_raw_handle()).unwrap();
+    assert_eq!(canonical, fallback);
+}
diff --git a/library/std/src/sys/pal/unix/stack_overflow.rs b/library/std/src/sys/pal/unix/stack_overflow.rs
index 5679b55e0d486..5604e3e6dbf42 100644
--- a/library/std/src/sys/pal/unix/stack_overflow.rs
+++ b/library/std/src/sys/pal/unix/stack_overflow.rs
@@ -1,4 +1,5 @@
 #![cfg_attr(test, allow(dead_code))]
+#![forbid(unsafe_op_in_unsafe_fn)]
 
 pub use self::imp::init;
 use self::imp::{drop_handler, make_handler};
@@ -73,31 +74,33 @@ mod imp {
     use crate::sys::pal::unix::conf;
     use crate::{io, mem, ptr};
 
-    // Signal handler for the SIGSEGV and SIGBUS handlers. We've got guard pages
-    // (unmapped pages) at the end of every thread's stack, so if a thread ends
-    // up running into the guard page it'll trigger this handler. We want to
-    // detect these cases and print out a helpful error saying that the stack
-    // has overflowed. All other signals, however, should go back to what they
-    // were originally supposed to do.
-    //
-    // This handler currently exists purely to print an informative message
-    // whenever a thread overflows its stack. We then abort to exit and
-    // indicate a crash, but to avoid a misleading SIGSEGV that might lead
-    // users to believe that unsafe code has accessed an invalid pointer; the
-    // SIGSEGV encountered when overflowing the stack is expected and
-    // well-defined.
-    //
-    // If this is not a stack overflow, the handler un-registers itself and
-    // then returns (to allow the original signal to be delivered again).
-    // Returning from this kind of signal handler is technically not defined
-    // to work when reading the POSIX spec strictly, but in practice it turns
-    // out many large systems and all implementations allow returning from a
-    // signal handler to work. For a more detailed explanation see the
-    // comments on #26458.
-    /// SIGSEGV/SIGBUS entry point
+    /// Signal handler for the SIGSEGV and SIGBUS handlers.
+    ///
+    /// We've got guard pages (unmapped pages) at the end of every thread's
+    /// stack, so if a thread ends up running into the guard page it'll trigger
+    /// this handler. We want to detect these cases and print out a helpful error
+    /// saying that the stack has overflowed. All other signals, however, should
+    /// go back to what they were originally supposed to do.
+    ///
+    /// This handler currently exists purely to print an informative message
+    /// whenever a thread overflows its stack. We then abort to exit and
+    /// indicate a crash, but to avoid a misleading SIGSEGV that might lead
+    /// users to believe that unsafe code has accessed an invalid pointer; the
+    /// SIGSEGV encountered when overflowing the stack is expected and
+    /// well-defined.
+    ///
+    /// If this is not a stack overflow, the handler un-registers itself and
+    /// then returns (to allow the original signal to be delivered again).
+    /// Returning from this kind of signal handler is technically not defined
+    /// to work when reading the POSIX spec strictly, but in practice it turns
+    /// out many large systems and all implementations allow returning from a
+    /// signal handler to work. For a more detailed explanation see the
+    /// comments on #26458.
+    ///
     /// # Safety
-    /// Rust doesn't call this, it *gets called*.
-    #[forbid(unsafe_op_in_unsafe_fn)]
+    /// Rust doesn't call this, it *gets called* by the kernel, which we expect
+    /// to provide valid parameters. Apart from that, this function does not
+    /// have any other preconditions.
     unsafe extern "C" fn signal_handler(
         signum: libc::c_int,
         info: *mut libc::siginfo_t,
@@ -153,11 +156,14 @@ mod imp {
     static NEED_ALTSTACK: Atomic<bool> = AtomicBool::new(false);
 
     /// # Safety
-    /// Must be called only once
-    #[forbid(unsafe_op_in_unsafe_fn)]
+    /// Must be called only once, on the main thread, during program startup.
     pub unsafe fn init() {
         PAGE_SIZE.store(conf::page_size(), Ordering::Relaxed);
 
+        // SAFETY:
+        // This is only called on the main thread, and since it is still early
+        // in the programs lifetime there is (almost) certainly enough stack
+        // space left to install the guard page.
         let mut guard_page_range = unsafe { install_main_guard() };
 
         // Even for panic=immediate-abort, installing the guard pages is important for soundness.
@@ -167,17 +173,20 @@ mod imp {
             return;
         }
 
-        // SAFETY: assuming all platforms define struct sigaction as "zero-initializable"
+        // SAFETY: C structures are always zero-initializable.
         let mut action: sigaction = unsafe { mem::zeroed() };
         for &signal in &[SIGSEGV, SIGBUS] {
             // SAFETY: just fetches the current signal handler into action
             unsafe { sigaction(signal, ptr::null_mut(), &mut action) };
-            // Configure our signal handler if one is not already set.
+            // We assume that overriding the signal handler is always safe,
+            // which might conflict with certain libraries that rely on a
+            // specific signal behaviour. To prevent problems, we only
+            // override the handler if it has not been set yet.
             if action.sa_sigaction == SIG_DFL {
                 if !NEED_ALTSTACK.load(Ordering::Relaxed) {
                     // haven't set up our sigaltstack yet
                     NEED_ALTSTACK.store(true, Ordering::Release);
-                    let handler = unsafe { make_handler(true) };
+                    let handler = make_handler(true);
                     MAIN_ALTSTACK.store(handler.data, Ordering::Relaxed);
                     mem::forget(handler);
 
@@ -190,13 +199,15 @@ mod imp {
                 action.sa_sigaction = signal_handler
                     as unsafe extern "C" fn(i32, *mut libc::siginfo_t, *mut libc::c_void)
                     as sighandler_t;
-                // SAFETY: only overriding signals if the default is set
+                // SAFETY:
+                // `&action` describes a valid `sigaction` and `signal_handler`
+                // is safe to use as a signal handler for `SIGSEGV` and `SIGBUS`.
                 unsafe { sigaction(signal, &action, ptr::null_mut()) };
             }
         }
     }
 
-    unsafe fn get_stack() -> libc::stack_t {
+    fn get_stack() -> libc::stack_t {
         // OpenBSD requires this flag for stack mapping
         // otherwise the said mapping will fail as a no-op on most systems
         // and has a different meaning on FreeBSD
@@ -218,51 +229,62 @@ mod imp {
         let sigstack_size = sigstack_size();
         let page_size = PAGE_SIZE.load(Ordering::Relaxed);
 
-        let stackp = mmap64(
-            ptr::null_mut(),
-            sigstack_size + page_size,
-            PROT_READ | PROT_WRITE,
-            flags,
-            -1,
-            0,
-        );
+        // SAFETY: this does not unmap any existing pages.
+        let stackp = unsafe {
+            mmap64(ptr::null_mut(), sigstack_size + page_size, PROT_READ | PROT_WRITE, flags, -1, 0)
+        };
         if stackp == MAP_FAILED {
             panic!("failed to allocate an alternative stack: {}", io::Error::last_os_error());
         }
-        let guard_result = libc::mprotect(stackp, page_size, PROT_NONE);
+        // SAFETY: this only affects the memory we just allocated.
+        let guard_result = unsafe { libc::mprotect(stackp, page_size, PROT_NONE) };
         if guard_result != 0 {
             panic!("failed to set up alternative stack guard page: {}", io::Error::last_os_error());
         }
-        let stackp = stackp.add(page_size);
+        // SAFETY:
+        // The region was allocated with a larger size than `page_size`, so this
+        // addition is within bounds.
+        let stackp = unsafe { stackp.add(page_size) };
 
         libc::stack_t { ss_sp: stackp, ss_flags: 0, ss_size: sigstack_size }
     }
 
-    /// # Safety
-    /// Mutates the alternate signal stack
-    #[forbid(unsafe_op_in_unsafe_fn)]
-    pub unsafe fn make_handler(main_thread: bool) -> Handler {
+    pub fn make_handler(main_thread: bool) -> Handler {
         if cfg!(panic = "immediate-abort") || !NEED_ALTSTACK.load(Ordering::Acquire) {
             return Handler::null();
         }
 
         if !main_thread {
-            if let Some(guard_page_range) = unsafe { current_guard() } {
+            if let Some(guard_page_range) = current_guard() {
                 set_current_info(guard_page_range);
             }
         }
 
-        // SAFETY: assuming stack_t is zero-initializable
+        // Load the current alternate signal stack to see if we need to install
+        // our own.
+        //
+        // SAFETY: C structures are always zero-initializable.
         let mut stack = unsafe { mem::zeroed() };
-        // SAFETY: reads current stack_t into stack
+        // SAFETY: `&mut stack` is valid for writing a `stack_t`.
         unsafe { sigaltstack(ptr::null(), &mut stack) };
+
         // Configure alternate signal stack, if one is not already set.
         if stack.ss_flags & SS_DISABLE != 0 {
-            // SAFETY: We warned our caller this would happen!
-            unsafe {
-                stack = get_stack();
-                sigaltstack(&stack, ptr::null_mut());
-            }
+            let stack = get_stack();
+            // SAFETY:
+            // `stack_t` is a freshly allocated stack that's not used anywhere
+            // else. It contains a guard page, so stack overflows in signal
+            // handlers will not cause undefined behaviour. We must make the
+            // fundamental runtime assumption that it is safe to install an
+            // alternate signal stack if there is none currently installed.
+            // This might conflict with foreign libraries that use the existence
+            // of an alternate signal stack as indication that certain runtime
+            // initialisation by the library has been performed (e.g. old
+            // versions of `std` assumed that certain thread-locals were already
+            // accessed and thus initialized in the thread if the stack overflow
+            // signal was successfully delivered). Such assumptions in other
+            // libraries are fundamentally flawed, so we pay no regard to them.
+            unsafe { sigaltstack(&stack, ptr::null_mut()) };
             Handler { data: stack.ss_sp as *mut libc::c_void }
         } else {
             Handler::null()
@@ -270,11 +292,8 @@ mod imp {
     }
 
     /// # Safety
-    /// Must be called
-    /// - only with our handler or nullptr
-    /// - only when done with our altstack
-    /// This disables the alternate signal stack!
-    #[forbid(unsafe_op_in_unsafe_fn)]
+    /// Must only be called with a pointer returned by `make_handler`, and only
+    /// once per `Handler`.
     pub unsafe fn drop_handler(data: *mut libc::c_void) {
         if !data.is_null() {
             let sigstack_size = sigstack_size();
@@ -288,10 +307,22 @@ mod imp {
                 // both ss_sp and ss_size should be ignored in this case.
                 ss_size: sigstack_size,
             };
-            // SAFETY: we warned the caller this disables the alternate signal stack!
+            // SAFETY:
+            // We assume that disabling the alternate signal stack is always
+            // sound, even if the current alternate signal stack is not the one
+            // we installed in `make_handler`. Any stack overflows from this
+            // point on will abort the program when the kernel tries to write
+            // the signal information to the guard page.
+            //
+            // FIXME: detect if the stack has changed, and only uninstall if it hasn't.
             unsafe { sigaltstack(&disabling_stack, ptr::null_mut()) };
-            // SAFETY: We know from `get_stackp` that the alternate stack we installed is part of
-            // a mapping that started one page earlier, so walk back a page and unmap from there.
+            // The stack returned by `get_stack` is part of a mapping that
+            // started one page earlier, so walk back a page and unmap from
+            // there.
+            //
+            // SAFETY:
+            // This allocation was created by us in `get_stack` and, as the
+            // alternate signal stack is now disabled, is no longer in use.
             unsafe { munmap(data.sub(page_size), sigstack_size + page_size) };
         }
 
@@ -301,6 +332,7 @@ mod imp {
     /// Modern kernels on modern hardware can have dynamic signal stack sizes.
     #[cfg(all(any(target_os = "linux", target_os = "android"), not(target_env = "uclibc")))]
     fn sigstack_size() -> usize {
+        // SAFETY: `getauxval` is always safe to call.
         let dynamic_sigstksz = unsafe { libc::getauxval(libc::AT_MINSIGSTKSZ) };
         // If getauxval couldn't find the entry, it returns 0,
         // so take the higher of the "constant" and auxval.
@@ -315,26 +347,43 @@ mod imp {
     }
 
     #[cfg(any(target_os = "solaris", target_os = "illumos"))]
-    unsafe fn get_stack_start() -> Option<*mut libc::c_void> {
-        let mut current_stack: libc::stack_t = crate::mem::zeroed();
-        assert_eq!(libc::stack_getbounds(&mut current_stack), 0);
+    fn get_stack_start() -> Option<*mut libc::c_void> {
+        // SAFETY: C types are always zero-initializable.
+        let mut current_stack: libc::stack_t = unsafe { crate::mem::zeroed() };
+        // SAFETY:
+        // The pointer is valid for writing a `stack_t`.
+        assert_eq!(unsafe { libc::stack_getbounds(&mut current_stack) }, 0);
         Some(current_stack.ss_sp)
     }
 
     #[cfg(target_os = "macos")]
-    unsafe fn get_stack_start() -> Option<*mut libc::c_void> {
-        let th = libc::pthread_self();
-        let stackptr = libc::pthread_get_stackaddr_np(th);
-        Some(stackptr.map_addr(|addr| addr - libc::pthread_get_stacksize_np(th)))
+    fn get_stack_start() -> Option<*mut libc::c_void> {
+        // SAFETY: always safe to call.
+        let th = unsafe { libc::pthread_self() };
+        // SAFETY: `th` is a valid `pthread_t`.
+        unsafe {
+            let stackptr = libc::pthread_get_stackaddr_np(th);
+            let stacksize = libc::pthread_get_stacksize_np(th);
+            Some(stackptr.map_addr(|addr| addr - stacksize))
+        }
     }
 
     #[cfg(target_os = "openbsd")]
-    unsafe fn get_stack_start() -> Option<*mut libc::c_void> {
-        let mut current_stack: libc::stack_t = crate::mem::zeroed();
-        assert_eq!(libc::pthread_stackseg_np(libc::pthread_self(), &mut current_stack), 0);
+    fn get_stack_start() -> Option<*mut libc::c_void> {
+        // SAFETY: C types are always zero-initializable.
+        let mut current_stack: libc::stack_t = unsafe { crate::mem::zeroed() };
+        // SAFETY:
+        // * calling `pthread_self` is always valid and returns a valid `pthread_t`.
+        // * `&mut current_stack` is coerced to a pointer that is valid for writing
+        //   a `stack_t`.
+        assert_eq!(
+            unsafe { libc::pthread_stackseg_np(libc::pthread_self(), &mut current_stack) },
+            0
+        );
 
         let stack_ptr = current_stack.ss_sp;
-        let stackaddr = if libc::pthread_main_np() == 1 {
+        // SAFETY: this is always safe to call.
+        let stackaddr = if unsafe { libc::pthread_main_np() } == 1 {
             // main thread
             stack_ptr.addr() - current_stack.ss_size + PAGE_SIZE.load(Ordering::Relaxed)
         } else {
@@ -352,7 +401,7 @@ mod imp {
         target_os = "linux",
         target_os = "l4re"
     ))]
-    unsafe fn get_stack_start() -> Option<*mut libc::c_void> {
+    fn get_stack_start() -> Option<*mut libc::c_void> {
         use crate::pin::pin;
         use crate::sys::helpers::COpaque;
 
@@ -365,26 +414,44 @@ mod imp {
         // FIXME(pin-ergonomics): remove the next line.
         let attr = attr.into_ref();
 
+        // SAFETY:
+        // The attributes object has not been initialized yet and will not be
+        // moved until destroyed.
         #[cfg(target_os = "freebsd")]
-        assert_eq!(libc::pthread_attr_init(attr.get()), 0);
+        assert_eq!(unsafe { libc::pthread_attr_init(attr.get()) }, 0);
+        // SAFETY:
+        // * calling `pthread_self` is always valid and returns a valid `pthread_t`
+        // * `attr` is an initialized attribute object that can be written to.
         #[cfg(target_os = "freebsd")]
-        let e = libc::pthread_attr_get_np(libc::pthread_self(), attr.get());
+        let e = unsafe { libc::pthread_attr_get_np(libc::pthread_self(), attr.get()) };
+        // SAFETY:
+        // * calling `pthread_self` is always valid and returns a valid `pthread_t`
+        // * `attr` can be written to, and will be initialized by this call.
         #[cfg(not(target_os = "freebsd"))]
-        let e = libc::pthread_getattr_np(libc::pthread_self(), attr.get());
+        let e = unsafe { libc::pthread_getattr_np(libc::pthread_self(), attr.get()) };
         if e == 0 {
             let mut stackaddr = crate::ptr::null_mut();
             let mut stacksize = 0;
-            assert_eq!(libc::pthread_attr_getstack(attr.get(), &mut stackaddr, &mut stacksize), 0);
+            // SAFETY:
+            // `attr` is an initialized attribute object and both the pointers
+            // are valid for writing.
+            assert_eq!(
+                unsafe { libc::pthread_attr_getstack(attr.get(), &mut stackaddr, &mut stacksize) },
+                0
+            );
             ret = Some(stackaddr);
         }
         if e == 0 || cfg!(target_os = "freebsd") {
-            assert_eq!(libc::pthread_attr_destroy(attr.get()), 0);
+            // SAFETY:
+            // `attr` was initialized either by `pthread_attr_init` (FreeBSD) or
+            // by `pthread_attr_get_np`, and is not used after this point.
+            assert_eq!(unsafe { libc::pthread_attr_destroy(attr.get()) }, 0);
         }
         ret
     }
 
     fn stack_start_aligned(page_size: usize) -> Option<*mut libc::c_void> {
-        let stackptr = unsafe { get_stack_start()? };
+        let stackptr = get_stack_start()?;
         let stackaddr = stackptr.addr();
 
         // Ensure stackaddr is page aligned! A parent process might
@@ -401,32 +468,32 @@ mod imp {
         })
     }
 
-    #[forbid(unsafe_op_in_unsafe_fn)]
+    /// # Safety
+    /// This function must only be called from the main thread, and there must
+    /// be sufficient stack space remaining to place a stack guard.
     unsafe fn install_main_guard() -> Option<Range<usize>> {
         let page_size = PAGE_SIZE.load(Ordering::Relaxed);
 
-        unsafe {
-            // this way someone on any unix-y OS can check that all these compile
-            if cfg!(all(target_os = "linux", not(target_env = "musl"))) {
-                install_main_guard_linux(page_size)
-            } else if cfg!(all(target_os = "linux", target_env = "musl")) {
-                install_main_guard_linux_musl(page_size)
-            } else if cfg!(target_os = "freebsd") {
-                #[cfg(not(target_os = "freebsd"))]
-                return None;
-                // The FreeBSD code cannot be checked on non-BSDs.
-                #[cfg(target_os = "freebsd")]
-                install_main_guard_freebsd(page_size)
-            } else if cfg!(any(target_os = "netbsd", target_os = "openbsd")) {
-                install_main_guard_bsds(page_size)
-            } else {
-                install_main_guard_default(page_size)
-            }
+        // this way someone on any unix-y OS can check that all these compile
+        if cfg!(all(target_os = "linux", not(target_env = "musl"))) {
+            install_main_guard_linux(page_size)
+        } else if cfg!(all(target_os = "linux", target_env = "musl")) {
+            install_main_guard_linux_musl(page_size)
+        } else if cfg!(target_os = "freebsd") {
+            #[cfg(not(target_os = "freebsd"))]
+            return None;
+            // The FreeBSD code cannot be checked on non-BSDs.
+            #[cfg(target_os = "freebsd")]
+            install_main_guard_freebsd(page_size)
+        } else if cfg!(any(target_os = "netbsd", target_os = "openbsd")) {
+            install_main_guard_bsds(page_size)
+        } else {
+            // SAFETY: guaranteed by caller.
+            unsafe { install_main_guard_default(page_size) }
         }
     }
 
-    #[forbid(unsafe_op_in_unsafe_fn)]
-    unsafe fn install_main_guard_linux(page_size: usize) -> Option<Range<usize>> {
+    fn install_main_guard_linux(page_size: usize) -> Option<Range<usize>> {
         // See the corresponding conditional in init().
         // Avoid stack_start_aligned, which makes slow syscalls to read /proc/self/maps
         if cfg!(panic = "immediate-abort") {
@@ -447,8 +514,7 @@ mod imp {
         Some(stackaddr - page_size..stackaddr)
     }
 
-    #[forbid(unsafe_op_in_unsafe_fn)]
-    unsafe fn install_main_guard_linux_musl(_page_size: usize) -> Option<Range<usize>> {
+    fn install_main_guard_linux_musl(_page_size: usize) -> Option<Range<usize>> {
         // For the main thread, the musl's pthread_attr_getstack
         // returns the current stack size, rather than maximum size
         // it can eventually grow to. It cannot be used to determine
@@ -456,9 +522,8 @@ mod imp {
         None
     }
 
-    #[forbid(unsafe_op_in_unsafe_fn)]
     #[cfg(target_os = "freebsd")]
-    unsafe fn install_main_guard_freebsd(page_size: usize) -> Option<Range<usize>> {
+    fn install_main_guard_freebsd(page_size: usize) -> Option<Range<usize>> {
         // See the corresponding conditional in install_main_guard_linux().
         if cfg!(panic = "immediate-abort") {
             return None;
@@ -473,6 +538,7 @@ mod imp {
         // by the security.bsd.stack_guard_page sysctl.
         // By default it is 1, checking once is enough since it is
         // a boot time config value.
+        // FIXME(joboet): this function is only called once, remove the caching.
         static PAGES: crate::sync::OnceLock<usize> = crate::sync::OnceLock::new();
 
         let pages = PAGES.get_or_init(|| {
@@ -494,8 +560,7 @@ mod imp {
         Some(guardaddr..guardaddr + pages * page_size)
     }
 
-    #[forbid(unsafe_op_in_unsafe_fn)]
-    unsafe fn install_main_guard_bsds(page_size: usize) -> Option<Range<usize>> {
+    fn install_main_guard_bsds(page_size: usize) -> Option<Range<usize>> {
         // See the corresponding conditional in install_main_guard_linux().
         if cfg!(panic = "immediate-abort") {
             return None;
@@ -512,7 +577,9 @@ mod imp {
         Some(stackaddr - page_size..stackaddr)
     }
 
-    #[forbid(unsafe_op_in_unsafe_fn)]
+    /// # Safety
+    /// This function must only be called from the main thread, and there must
+    /// be sufficient stack space remaining to place a stack guard.
     unsafe fn install_main_guard_default(page_size: usize) -> Option<Range<usize>> {
         // Reallocate the last page of the stack.
         // This ensures SIGBUS will be raised on
@@ -523,6 +590,11 @@ mod imp {
         // read/write permissions and only then mprotect() it to
         // no permissions at all. See issue #50313.
         let stackptr = stack_start_aligned(page_size)?;
+        // SAFETY:
+        // The memory region from `stackptr..stackptr + page_size` belongs to
+        // the current thread's stack, and the caller has asserted that there
+        // is sufficient stack space, which means that this will not overwrite
+        // any existing allocations.
         let result = unsafe {
             mmap64(
                 stackptr,
@@ -537,6 +609,10 @@ mod imp {
             panic!("failed to allocate a guard page: {}", io::Error::last_os_error());
         }
 
+        // SAFETY:
+        // Since this function is only called on the main thread, the stack will
+        // not be reused until program exit, so the runtime will never observe
+        // that part of the stack has been made unusable in this way.
         let result = unsafe { mprotect(stackptr, page_size, PROT_NONE) };
         if result != 0 {
             panic!("failed to protect the guard page: {}", io::Error::last_os_error());
@@ -553,8 +629,7 @@ mod imp {
         target_os = "solaris",
         target_os = "illumos",
     ))]
-    // FIXME: I am probably not unsafe.
-    unsafe fn current_guard() -> Option<Range<usize>> {
+    fn current_guard() -> Option<Range<usize>> {
         let stackptr = get_stack_start()?;
         let stackaddr = stackptr.addr();
         Some(stackaddr - PAGE_SIZE.load(Ordering::Relaxed)..stackaddr)
@@ -568,8 +643,7 @@ mod imp {
         target_os = "netbsd",
         target_os = "l4re"
     ))]
-    // FIXME: I am probably not unsafe.
-    unsafe fn current_guard() -> Option<Range<usize>> {
+    fn current_guard() -> Option<Range<usize>> {
         use crate::pin::pin;
         use crate::sys::helpers::COpaque;
 
@@ -583,15 +657,27 @@ mod imp {
         // FIXME(pin-ergonomics): remove the next line.
         let attr = attr.into_ref();
 
+        // SAFETY:
+        // The attributes object has not been initialized yet and will not be
+        // moved until destroyed.
         #[cfg(target_os = "freebsd")]
-        assert_eq!(libc::pthread_attr_init(attr.get()), 0);
+        assert_eq!(unsafe { libc::pthread_attr_init(attr.get()) }, 0);
+        // SAFETY:
+        // * calling `pthread_self` is always valid and returns a valid `pthread_t`
+        // * `attr` is an initialized attribute object that can be written to.
         #[cfg(target_os = "freebsd")]
-        let e = libc::pthread_attr_get_np(libc::pthread_self(), attr.get());
+        let e = unsafe { libc::pthread_attr_get_np(libc::pthread_self(), attr.get()) };
+        // SAFETY:
+        // * calling `pthread_self` is always valid and returns a valid `pthread_t`
+        // * `attr` can be written to, and will be initialized by this call.
         #[cfg(not(target_os = "freebsd"))]
-        let e = libc::pthread_getattr_np(libc::pthread_self(), attr.get());
+        let e = unsafe { libc::pthread_getattr_np(libc::pthread_self(), attr.get()) };
         if e == 0 {
             let mut guardsize = 0;
-            assert_eq!(libc::pthread_attr_getguardsize(attr.get(), &mut guardsize), 0);
+            // SAFETY:
+            // `attr` is an initialized attribute object and the pointer is valid
+            // for writing.
+            assert_eq!(unsafe { libc::pthread_attr_getguardsize(attr.get(), &mut guardsize) }, 0);
             if guardsize == 0 {
                 if cfg!(all(target_os = "linux", target_env = "musl")) {
                     // musl versions before 1.1.19 always reported guard
@@ -604,7 +690,13 @@ mod imp {
             }
             let mut stackptr = crate::ptr::null_mut::<libc::c_void>();
             let mut size = 0;
-            assert_eq!(libc::pthread_attr_getstack(attr.get(), &mut stackptr, &mut size), 0);
+            // SAFETY:
+            // `attr` is an initialized attribute object and both the pointers
+            // are valid for writing.
+            assert_eq!(
+                unsafe { libc::pthread_attr_getstack(attr.get(), &mut stackptr, &mut size) },
+                0
+            );
 
             let stackaddr = stackptr.addr();
             ret = if cfg!(any(target_os = "freebsd", target_os = "netbsd", target_os = "hurd")) {
@@ -625,7 +717,10 @@ mod imp {
             };
         }
         if e == 0 || cfg!(target_os = "freebsd") {
-            assert_eq!(libc::pthread_attr_destroy(attr.get()), 0);
+            // SAFETY:
+            // `attr` was initialized either by `pthread_attr_init` (FreeBSD) or
+            // by `pthread_attr_get_np`, and is not used after this point.
+            assert_eq!(unsafe { libc::pthread_attr_destroy(attr.get()) }, 0);
         }
         ret
     }
@@ -656,7 +751,7 @@ mod imp {
 mod imp {
     pub unsafe fn init() {}
 
-    pub unsafe fn make_handler(_main_thread: bool) -> super::Handler {
+    pub fn make_handler(_main_thread: bool) -> super::Handler {
         super::Handler::null()
     }
 
@@ -738,7 +833,7 @@ mod imp {
         reserve_stack();
     }
 
-    pub unsafe fn make_handler(main_thread: bool) -> super::Handler {
+    pub fn make_handler(main_thread: bool) -> super::Handler {
         if !main_thread {
             reserve_stack();
         }
diff --git a/library/std/src/sys/pal/windows/api.rs b/library/std/src/sys/pal/windows/api.rs
index 25a6c2d7d8eda..c3494bf9aa4e6 100644
--- a/library/std/src/sys/pal/windows/api.rs
+++ b/library/std/src/sys/pal/windows/api.rs
@@ -364,3 +364,42 @@ pub macro unicode_str {
         )
     }
 }
+
+/// Returns a list of enabled drive letters.
+///
+/// This is a wrapper around [`GetLogicalDrives`].
+/// Each letter is returned as an ascii byte.
+///
+/// [`GetLogicalDrives`]: (https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-getlogicaldrives)
+pub fn get_logical_drives() -> impl Iterator<Item = u8> {
+    // SAFETY: `GetLogicalDrives` only returns information.
+    let drives = unsafe { c::GetLogicalDrives() };
+    (b'A'..=b'Z').filter(move |letter| drives >> (letter - b'A') & 1 == 1)
+}
+
+/// Get the NT path a device name points to.
+///
+/// # Safety
+///
+/// `device_name` must be null-terminated.
+// FIXME: Use a null-terminated wide string type to assert validity, similar to CStr.
+// Then this function can be safe.
+pub unsafe fn query_dos_device<'a>(
+    device_name: &[u16],
+    buffer: &'a mut [u16],
+) -> Option<&'a [u16]> {
+    let device_ptr = device_name.as_ptr();
+    let buffer_ptr = buffer.as_mut_ptr();
+    let buffer_len = buffer.len().try_into().ok()?;
+    // SAFETY: `device_ptr` points to a null-terminated u16 string.
+    // `buffer_ptr` is writeable up to buffer_len u16s.
+    let result = unsafe { c::QueryDosDeviceW(device_ptr, buffer_ptr, buffer_len) } as usize;
+    if result > 0 {
+        // QueryDosDeviceW returns a list of null-terminated strings where the list itself is also null-terminated
+        // In the case where you pass a device name (which we always) it only returns one string.
+        // Therefore to get the string we trim off both the list null termination and the string null termination.
+        Some(buffer[..result].trim_suffix(&[0, 0]))
+    } else {
+        None
+    }
+}
diff --git a/library/std/src/sys/pal/windows/c/bindings.txt b/library/std/src/sys/pal/windows/c/bindings.txt
index a0b2126af9a58..c4c4ac8c7d06e 100644
--- a/library/std/src/sys/pal/windows/c/bindings.txt
+++ b/library/std/src/sys/pal/windows/c/bindings.txt
@@ -2181,6 +2181,7 @@ GETFINALPATHNAMEBYHANDLE_FLAGS
 GetFinalPathNameByHandleW
 GetFullPathNameW
 GetLastError
+GetLogicalDrives
 GetModuleFileNameW
 GetModuleHandleA
 GetModuleHandleExW
@@ -2354,6 +2355,7 @@ PROFILE_KERNEL
 PROFILE_SERVER
 PROFILE_USER
 PROGRESS_CONTINUE
+QueryDosDeviceW
 QueryPerformanceCounter
 QueryPerformanceFrequency
 READ_CONTROL
@@ -2508,6 +2510,7 @@ UpdateProcThreadAttribute
 VOLUME_NAME_DOS
 VOLUME_NAME_GUID
 VOLUME_NAME_NONE
+VOLUME_NAME_NT
 WAIT_ABANDONED
 WAIT_ABANDONED_0
 WAIT_FAILED
diff --git a/library/std/src/sys/pal/windows/c/windows_sys.rs b/library/std/src/sys/pal/windows/c/windows_sys.rs
index 9c6f593e1e108..c3c5e193e41f1 100644
--- a/library/std/src/sys/pal/windows/c/windows_sys.rs
+++ b/library/std/src/sys/pal/windows/c/windows_sys.rs
@@ -54,6 +54,7 @@ windows_link::link!("kernel32.dll" "system" fn GetFileType(hfile : HANDLE) -> FI
 windows_link::link!("kernel32.dll" "system" fn GetFinalPathNameByHandleW(hfile : HANDLE, lpszfilepath : PWSTR, cchfilepath : u32, dwflags : GETFINALPATHNAMEBYHANDLE_FLAGS) -> u32);
 windows_link::link!("kernel32.dll" "system" fn GetFullPathNameW(lpfilename : PCWSTR, nbufferlength : u32, lpbuffer : PWSTR, lpfilepart : *mut PWSTR) -> u32);
 windows_link::link!("kernel32.dll" "system" fn GetLastError() -> WIN32_ERROR);
+windows_link::link!("kernel32.dll" "system" fn GetLogicalDrives() -> u32);
 windows_link::link!("kernel32.dll" "system" fn GetModuleFileNameW(hmodule : HMODULE, lpfilename : PWSTR, nsize : u32) -> u32);
 windows_link::link!("kernel32.dll" "system" fn GetModuleHandleA(lpmodulename : PCSTR) -> HMODULE);
 windows_link::link!("kernel32.dll" "system" fn GetModuleHandleExW(dwflags : u32, lpmodulename : PCWSTR, phmodule : *mut HMODULE) -> BOOL);
@@ -83,6 +84,7 @@ windows_link::link!("ntdll.dll" "system" fn NtReadFile(filehandle : HANDLE, even
 windows_link::link!("ntdll.dll" "system" fn NtSetInformationFile(filehandle : HANDLE, iostatusblock : *mut IO_STATUS_BLOCK, fileinformation : *const core::ffi::c_void, length : u32, fileinformationclass : FILE_INFORMATION_CLASS) -> NTSTATUS);
 windows_link::link!("ntdll.dll" "system" fn NtWriteFile(filehandle : HANDLE, event : HANDLE, apcroutine : PIO_APC_ROUTINE, apccontext : *const core::ffi::c_void, iostatusblock : *mut IO_STATUS_BLOCK, buffer : *const core::ffi::c_void, length : u32, byteoffset : *const i64, key : *const u32) -> NTSTATUS);
 windows_link::link!("advapi32.dll" "system" fn OpenProcessToken(processhandle : HANDLE, desiredaccess : TOKEN_ACCESS_MASK, tokenhandle : *mut HANDLE) -> BOOL);
+windows_link::link!("kernel32.dll" "system" fn QueryDosDeviceW(lpdevicename : PCWSTR, lptargetpath : PWSTR, ucchmax : u32) -> u32);
 windows_link::link!("kernel32.dll" "system" fn QueryPerformanceCounter(lpperformancecount : *mut i64) -> BOOL);
 windows_link::link!("kernel32.dll" "system" fn QueryPerformanceFrequency(lpfrequency : *mut i64) -> BOOL);
 windows_link::link!("kernel32.dll" "system" fn ReadConsoleW(hconsoleinput : HANDLE, lpbuffer : *mut core::ffi::c_void, nnumberofcharstoread : u32, lpnumberofcharsread : *mut u32, pinputcontrol : *const CONSOLE_READCONSOLE_CONTROL) -> BOOL);
@@ -3411,6 +3413,7 @@ impl Default for UNICODE_STRING {
 pub const VOLUME_NAME_DOS: GETFINALPATHNAMEBYHANDLE_FLAGS = 0u32;
 pub const VOLUME_NAME_GUID: GETFINALPATHNAMEBYHANDLE_FLAGS = 1u32;
 pub const VOLUME_NAME_NONE: GETFINALPATHNAMEBYHANDLE_FLAGS = 4u32;
+pub const VOLUME_NAME_NT: GETFINALPATHNAMEBYHANDLE_FLAGS = 2u32;
 pub const WAIT_ABANDONED: WAIT_EVENT = 128u32;
 pub const WAIT_ABANDONED_0: WAIT_EVENT = 128u32;
 pub type WAIT_EVENT = u32;
diff --git a/src/tools/compiletest/src/cli.rs b/src/tools/compiletest/src/cli.rs
index 45681eabe03a3..893f5b76724b8 100644
--- a/src/tools/compiletest/src/cli.rs
+++ b/src/tools/compiletest/src/cli.rs
@@ -401,13 +401,6 @@ pub(crate) fn parse_config(args: Vec<String>) -> Config {
     let iteration_count = args.iteration_count.unwrap_or(Config::DEFAULT_ITERATION_COUNT);
     assert!(iteration_count > 0, "`--iteration-count` must be a positive integer");
 
-    let gcc_supported_target_tuples = match default_codegen_backend {
-        CodegenBackend::Gcc => {
-            directives::find_gcc_supported_targets(&args.sysroot_base, &args.host)
-        }
-        CodegenBackend::Llvm | CodegenBackend::Cranelift => vec![],
-    };
-
     // FIXME: this run scheme is... confusing.
     let run = args.run.and_then(|mode| match mode.as_str() {
         "auto" => None,
@@ -455,8 +448,6 @@ pub(crate) fn parse_config(args: Vec<String>) -> Config {
         force_pass_mode: args.pass,
         force_rerun: args.force_rerun,
 
-        gcc_supported_target_tuples,
-
         gdb: args.gdb,
         gdb_version,
         git_hash: args.git_hash,
diff --git a/src/tools/compiletest/src/common.rs b/src/tools/compiletest/src/common.rs
index 4123dcf5b600a..8c580d3520dfd 100644
--- a/src/tools/compiletest/src/common.rs
+++ b/src/tools/compiletest/src/common.rs
@@ -770,9 +770,6 @@ pub(crate) struct Config {
     /// Whether to ignore `//@ ignore-backends`.
     pub(crate) bypass_ignore_backends: bool,
 
-    /// Target tuples for which we've found libgccjit.so.
-    pub(crate) gcc_supported_target_tuples: Vec<String>,
-
     /// Number of parallel jobs configured for the build.
     ///
     /// This is forwarded from bootstrap's `jobs` configuration.
diff --git a/src/tools/compiletest/src/directives.rs b/src/tools/compiletest/src/directives.rs
index 3499821f7b6e0..3459273c922a1 100644
--- a/src/tools/compiletest/src/directives.rs
+++ b/src/tools/compiletest/src/directives.rs
@@ -851,30 +851,6 @@ pub(crate) fn extract_llvm_version_from_binary(binary_path: &str) -> Option<Vers
     None
 }
 
-pub(crate) fn find_gcc_supported_targets(sysroot_base: &Utf8Path, host: &str) -> Vec<String> {
-    // E.g. `lib/rustlib/x86_64-unknown-linux-gnu/codegen-backends/lib`.
-    let backends_dir =
-        sysroot_base.join("lib").join("rustlib").join(host).join("codegen-backends").join("lib");
-
-    match std::fs::read_dir(&backends_dir) {
-        Ok(entries) => {
-            // Search for `aarch64-unknown-linux-gnu/libgccjit.so` et cetera.
-            let target_tuples: Vec<_> = entries
-                .filter_map(|entry| entry.ok())
-                .filter(|entry| entry.path().join("libgccjit.so").exists())
-                .filter_map(|entry| entry.file_name().into_string().ok())
-                .collect();
-
-            if target_tuples.is_empty() {
-                panic!("did not find `libgccjit.so` for any target in {backends_dir}");
-            }
-
-            target_tuples
-        }
-        Err(e) => panic!("unable to find `libgccjit.so` for any target in {backends_dir}: {e:?}",),
-    }
-}
-
 /// Takes a directive of the form `"<version1> [- <version2>]"`, returns the numeric representation
 /// of `<version1>` and `<version2>` as tuple: `(<version1>, <version2>)`.
 ///
@@ -1255,7 +1231,7 @@ fn ignore_unsupported_backend_target(config: &Config, line: &DirectiveLine<'_>)
         return IgnoreDecision::Continue;
     };
 
-    if !config.gcc_supported_target_tuples.iter().any(|t| t == target) {
+    if target != "x86_64-unknown-linux-gnu" {
         IgnoreDecision::Ignore {
             reason: format!(
                 "backend `{}` cannot build for target `{target}`",
diff --git a/src/tools/compiletest/src/rustdoc_gui_test.rs b/src/tools/compiletest/src/rustdoc_gui_test.rs
index b2d23bcf8ec0a..5a768519f616d 100644
--- a/src/tools/compiletest/src/rustdoc_gui_test.rs
+++ b/src/tools/compiletest/src/rustdoc_gui_test.rs
@@ -143,7 +143,6 @@ fn incomplete_config_for_rustdoc_gui_test() -> Config {
         default_codegen_backend: CodegenBackend::Llvm,
         override_codegen_backend: None,
         bypass_ignore_backends: Default::default(),
-        gcc_supported_target_tuples: vec![],
         jobs: Default::default(),
         parallel_frontend_threads: Config::DEFAULT_PARALLEL_FRONTEND_THREADS,
         iteration_count: Config::DEFAULT_ITERATION_COUNT,
diff --git a/src/tools/generate-windows-sys/src/main.rs b/src/tools/generate-windows-sys/src/main.rs
index 9b1d62f14bb7b..e51340af9a95c 100644
--- a/src/tools/generate-windows-sys/src/main.rs
+++ b/src/tools/generate-windows-sys/src/main.rs
@@ -33,7 +33,7 @@ fn main() -> Result<(), Box<dyn Error>> {
 
     let mut f = std::fs::File::options().append(true).open("windows_sys.rs")?;
     f.write_all(ARM32_SHIM.as_bytes())?;
-    writeln!(&mut f, "// ignore-tidy-filelength")?;
+    writeln!(&mut f, "// ignore-tidy-file-filelength")?;
 
     Ok(())
 }
diff --git a/src/tools/miri/tests/pass/async-panic-track-caller.rs b/src/tools/miri/tests/pass/async-panic-track-caller.rs
new file mode 100644
index 0000000000000..062e07cffc8b9
--- /dev/null
+++ b/src/tools/miri/tests/pass/async-panic-track-caller.rs
@@ -0,0 +1,170 @@
+// This test is duplicated (with changes) at
+// tests/ui/async-await/track-caller/panic-track-caller.rs
+
+//@ edition:2021
+//@ revisions: afn cls afn_cls nofeat
+//@ run-native
+//
+//
+//
+// Padding comment so that the line numbers are the same as panic-track-caller.rs
+#![feature(stmt_expr_attributes)]
+#![cfg_attr(any(afn, afn_cls), feature(async_fn_track_caller))]
+#![cfg_attr(any(cls, afn_cls), feature(closure_track_caller))]
+#![allow(unused)]
+
+use std::future::Future;
+use std::panic;
+use std::sync::{Arc, Mutex};
+use std::task::{Context, Poll, Wake};
+use std::thread::{self, Thread};
+
+/// A waker that wakes up the current thread when called.
+struct ThreadWaker(Thread);
+
+impl Wake for ThreadWaker {
+    fn wake(self: Arc<Self>) {
+        self.0.unpark();
+    }
+}
+
+/// Run a future to completion on the current thread.
+fn block_on<T>(fut: impl Future<Output = T>) -> T {
+    // Pin the future so it can be polled.
+    let mut fut = Box::pin(fut);
+
+    // Create a new context to be passed to the future.
+    let t = thread::current();
+    let waker = Arc::new(ThreadWaker(t)).into();
+    let mut cx = Context::from_waker(&waker);
+
+    // Run the future to completion.
+    loop {
+        match fut.as_mut().poll(&mut cx) {
+            Poll::Ready(res) => return res,
+            Poll::Pending => thread::park(),
+        }
+    }
+}
+
+async fn bar() {
+    panic!()
+}
+
+async fn foo() {
+    let future = bar();
+    future.await;
+}
+
+#[cfg_attr(any(cls, nofeat), expect(ungated_async_fn_track_caller))]
+#[track_caller]
+async fn bar_track_caller() {
+    panic!()
+}
+
+async fn foo_track_caller() {
+    let future = bar_track_caller();
+    future.await;
+}
+
+struct Foo;
+
+impl Foo {
+    #[cfg_attr(any(cls, nofeat), expect(ungated_async_fn_track_caller))]
+    #[track_caller]
+    async fn bar_assoc() {
+        panic!();
+    }
+}
+
+async fn foo_assoc() {
+    let future = Foo::bar_assoc();
+    future.await;
+}
+
+// Since compilation is expected to fail for this fn when `closure_track_caller`
+// is disabled, we test that separately in `async-closure-gate.rs`
+#[cfg(any(cls, afn_cls))]
+async fn foo_closure() {
+    let closure = #[track_caller]
+    async || {
+        panic!();
+    };
+    let future = closure();
+    future.await;
+}
+
+// Since compilation is expected to fail for this fn when `closure_track_caller`
+// is disabled, we test that separately in `async-closure-gate.rs`
+#[cfg(any(cls, afn_cls))]
+async fn foo_block() {
+    let future = #[track_caller]
+    async {
+        panic!();
+    };
+    future.await;
+}
+
+#[cfg_attr(any(cls, nofeat), expect(ungated_async_fn_track_caller))]
+#[track_caller]
+async fn bar_manual_poll() {
+    panic!();
+}
+
+fn foo_manual_poll() {
+    let future = bar_manual_poll();
+    let future = std::pin::pin!(future);
+    let mut cx = std::task::Context::from_waker(std::task::Waker::noop());
+    let res = future.poll(&mut cx);
+    assert_eq!(res, std::task::Poll::Ready(()));
+}
+
+fn panicked_at(f: impl FnOnce() + panic::UnwindSafe) -> u32 {
+    let loc = Arc::new(Mutex::new(None));
+
+    let hook = panic::take_hook();
+    {
+        let loc = loc.clone();
+        panic::set_hook(Box::new(move |info| {
+            *loc.lock().unwrap() = info.location().map(|loc| loc.line())
+        }));
+    }
+    panic::catch_unwind(f).unwrap_err();
+    panic::set_hook(hook);
+    let x = loc.lock().unwrap().unwrap();
+    x
+}
+
+// FIXME(async_fn_track_caller): Currently, #[track_caller] on an async function
+// uses the location where the future is awaited or polled.
+// The correct behavior as per T-lang is to use the location where the function is called.
+fn main() {
+    assert_eq!(panicked_at(|| block_on(foo())), 51);
+
+    #[cfg(any(afn, afn_cls))]
+    assert_eq!(panicked_at(|| block_on(foo_track_caller())), 67);
+    #[cfg(any(cls, nofeat))]
+    assert_eq!(panicked_at(|| block_on(foo_track_caller())), 62);
+
+    #[cfg(any(afn, afn_cls))]
+    assert_eq!(panicked_at(|| block_on(foo_assoc())), 82);
+    #[cfg(any(cls, nofeat))]
+    assert_eq!(panicked_at(|| block_on(foo_assoc())), 76);
+
+    // FIXME(closure_track_caller): if closure_track_caller is enabled, but
+    // async_fn_track_caller is disabled, then #[track_caller] on async closures
+    // silently do nothing. Either it should function, or we should emit a warning.
+    // See #161961
+    #[cfg(cls)]
+    assert_eq!(panicked_at(|| block_on(foo_closure())), 91);
+    #[cfg(afn_cls)]
+    assert_eq!(panicked_at(|| block_on(foo_closure())), 94);
+
+    #[cfg(any(cls, afn_cls))]
+    assert_eq!(panicked_at(|| block_on(foo_block())), 105);
+
+    #[cfg(any(afn, afn_cls))]
+    assert_eq!(panicked_at(|| foo_manual_poll()), 118);
+    #[cfg(any(cls, nofeat))]
+    assert_eq!(panicked_at(|| foo_manual_poll()), 111);
+}
diff --git a/tests/assembly-llvm/stack-protector/stack-protector-heuristics-effect-2.rs b/tests/assembly-llvm/stack-protector/stack-protector-heuristics-effect-2.rs
index e355602f2c3f1..07e92fbfde6dc 100644
--- a/tests/assembly-llvm/stack-protector/stack-protector-heuristics-effect-2.rs
+++ b/tests/assembly-llvm/stack-protector/stack-protector-heuristics-effect-2.rs
@@ -8,6 +8,7 @@
 //@ [strong] compile-flags: -Z stack-protector=strong
 //@ [none] compile-flags: -Z stack-protector=none
 //@ compile-flags: -C opt-level=2 -Z merge-functions=disabled
+//@ min-llvm-version: 23
 
 #![crate_type = "lib"]
 #![allow(internal_features)]
diff --git a/tests/assembly-llvm/stack-protector/stack-protector-target-support.rs b/tests/assembly-llvm/stack-protector/stack-protector-target-support.rs
index 9f182985d1573..f883e7ac8691f 100644
--- a/tests/assembly-llvm/stack-protector/stack-protector-target-support.rs
+++ b/tests/assembly-llvm/stack-protector/stack-protector-target-support.rs
@@ -177,13 +177,15 @@
 //@ compile-flags: -C opt-level=2
 
 #![crate_type = "lib"]
-#![feature(no_core, lang_items)]
+#![feature(no_core, lang_items, sanitize)]
 #![crate_type = "lib"]
 #![no_core]
 
 extern crate minicore;
 use minicore::*;
 
+// We only do this because we can't disable default sanitizers via compile-flags.
+#[sanitize(safestack = "off")]
 #[no_mangle]
 pub fn foo() {
     // CHECK: foo{{:|()}}
diff --git a/tests/codegen-llvm/i128-x86-align.rs b/tests/codegen-llvm/i128-x86-align.rs
index 998821d17e80c..2b4d7349efc7e 100644
--- a/tests/codegen-llvm/i128-x86-align.rs
+++ b/tests/codegen-llvm/i128-x86-align.rs
@@ -1,5 +1,6 @@
 //@ only-x86_64
 //@ compile-flags: -Copt-level=3 -C no-prepopulate-passes --crate-type=lib
+//@ min-llvm-version: 23
 
 // On LLVM 17 and earlier LLVM's own data layout specifies that i128 has 8 byte alignment,
 // while rustc wants it to have 16 byte alignment. This test checks that we handle this
diff --git a/tests/codegen-llvm/intrinsics/volatile.rs b/tests/codegen-llvm/intrinsics/volatile.rs
index 42ffd196f3d86..a93348703cee9 100644
--- a/tests/codegen-llvm/intrinsics/volatile.rs
+++ b/tests/codegen-llvm/intrinsics/volatile.rs
@@ -1,4 +1,5 @@
 //@ compile-flags: -C no-prepopulate-passes
+//@ min-llvm-version: 23
 
 #![crate_type = "lib"]
 #![feature(core_intrinsics)]
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-primitive-types.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-primitive-types.rs
index 93845d0519541..59e794df69990 100644
--- a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-primitive-types.rs
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-primitive-types.rs
@@ -1,13 +1,18 @@
 // Verifies that type metadata identifiers for functions are emitted correctly
 // for primitive types.
 //
+//@ add-minicore
 //@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static -C unsafe-allow-abi-mismatch=sanitizer
+//@ compile-flags: -Cno-prepopulate-passes -Copt-level=0 -C link-dead-code
+//@ compile-flags: -Clto -Zsanitizer=cfi -Ctarget-feature=-crt-static -C unsafe-allow-abi-mismatch=sanitizer
+//@ minicore-compile-flags: -Ccodegen-units=1
 
 #![crate_type = "lib"]
+#![feature(no_core, f16, f128)]
+#![no_core]
 
-extern crate core;
-use core::ffi::*;
+extern crate minicore;
+use minicore::*;
 
 pub fn foo1(_: ()) {}
 // CHECK: define{{.*}}4foo1{{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
@@ -15,114 +20,133 @@ pub fn foo2(_: (), _: c_void) {}
 // CHECK: define{{.*}}4foo2{{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo3(_: (), _: c_void, _: c_void) {}
 // CHECK: define{{.*}}4foo3{{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+
 pub fn foo4(_: *mut ()) {}
 // CHECK: define{{.*}}4foo4{{.*}}!type ![[TYPE4:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo5(_: *mut (), _: *mut c_void) {}
 // CHECK: define{{.*}}4foo5{{.*}}!type ![[TYPE5:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo6(_: *mut (), _: *mut c_void, _: *mut c_void) {}
 // CHECK: define{{.*}}4foo6{{.*}}!type ![[TYPE6:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+
 pub fn foo7(_: *const ()) {}
 // CHECK: define{{.*}}4foo7{{.*}}!type ![[TYPE7:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo8(_: *const (), _: *const c_void) {}
 // CHECK: define{{.*}}4foo8{{.*}}!type ![[TYPE8:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo9(_: *const (), _: *const c_void, _: *const c_void) {}
 // CHECK: define{{.*}}4foo9{{.*}}!type ![[TYPE9:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+
 pub fn foo10(_: bool) {}
 // CHECK: define{{.*}}5foo10{{.*}}!type ![[TYPE10:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo11(_: bool, _: bool) {}
 // CHECK: define{{.*}}5foo11{{.*}}!type ![[TYPE11:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo12(_: bool, _: bool, _: bool) {}
 // CHECK: define{{.*}}5foo12{{.*}}!type ![[TYPE12:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+
 pub fn foo13(_: i8) {}
 // CHECK: define{{.*}}5foo13{{.*}}!type ![[TYPE13:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo14(_: i8, _: i8) {}
 // CHECK: define{{.*}}5foo14{{.*}}!type ![[TYPE14:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo15(_: i8, _: i8, _: i8) {}
 // CHECK: define{{.*}}5foo15{{.*}}!type ![[TYPE15:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+
 pub fn foo16(_: i16) {}
 // CHECK: define{{.*}}5foo16{{.*}}!type ![[TYPE16:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo17(_: i16, _: i16) {}
 // CHECK: define{{.*}}5foo17{{.*}}!type ![[TYPE17:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo18(_: i16, _: i16, _: i16) {}
 // CHECK: define{{.*}}5foo18{{.*}}!type ![[TYPE18:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+
 pub fn foo19(_: i32) {}
 // CHECK: define{{.*}}5foo19{{.*}}!type ![[TYPE19:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo20(_: i32, _: i32) {}
 // CHECK: define{{.*}}5foo20{{.*}}!type ![[TYPE20:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo21(_: i32, _: i32, _: i32) {}
 // CHECK: define{{.*}}5foo21{{.*}}!type ![[TYPE21:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+
 pub fn foo22(_: i64) {}
 // CHECK: define{{.*}}5foo22{{.*}}!type ![[TYPE22:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo23(_: i64, _: i64) {}
 // CHECK: define{{.*}}5foo23{{.*}}!type ![[TYPE23:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo24(_: i64, _: i64, _: i64) {}
 // CHECK: define{{.*}}5foo24{{.*}}!type ![[TYPE24:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+
 pub fn foo25(_: i128) {}
 // CHECK: define{{.*}}5foo25{{.*}}!type ![[TYPE25:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo26(_: i128, _: i128) {}
 // CHECK: define{{.*}}5foo26{{.*}}!type ![[TYPE26:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo27(_: i128, _: i128, _: i128) {}
 // CHECK: define{{.*}}5foo27{{.*}}!type ![[TYPE27:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+
 pub fn foo28(_: isize) {}
 // CHECK: define{{.*}}5foo28{{.*}}!type ![[TYPE28:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo29(_: isize, _: isize) {}
 // CHECK: define{{.*}}5foo29{{.*}}!type ![[TYPE29:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo30(_: isize, _: isize, _: isize) {}
 // CHECK: define{{.*}}5foo30{{.*}}!type ![[TYPE30:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+
 pub fn foo31(_: u8) {}
 // CHECK: define{{.*}}5foo31{{.*}}!type ![[TYPE31:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo32(_: u8, _: u8) {}
 // CHECK: define{{.*}}5foo32{{.*}}!type ![[TYPE32:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo33(_: u8, _: u8, _: u8) {}
 // CHECK: define{{.*}}5foo33{{.*}}!type ![[TYPE33:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+
 pub fn foo34(_: u16) {}
 // CHECK: define{{.*}}5foo34{{.*}}!type ![[TYPE34:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo35(_: u16, _: u16) {}
 // CHECK: define{{.*}}5foo35{{.*}}!type ![[TYPE35:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo36(_: u16, _: u16, _: u16) {}
 // CHECK: define{{.*}}5foo36{{.*}}!type ![[TYPE36:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+
 pub fn foo37(_: u32) {}
 // CHECK: define{{.*}}5foo37{{.*}}!type ![[TYPE37:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo38(_: u32, _: u32) {}
 // CHECK: define{{.*}}5foo38{{.*}}!type ![[TYPE38:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo39(_: u32, _: u32, _: u32) {}
 // CHECK: define{{.*}}5foo39{{.*}}!type ![[TYPE39:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+
 pub fn foo40(_: u64) {}
 // CHECK: define{{.*}}5foo40{{.*}}!type ![[TYPE40:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo41(_: u64, _: u64) {}
 // CHECK: define{{.*}}5foo41{{.*}}!type ![[TYPE41:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo42(_: u64, _: u64, _: u64) {}
 // CHECK: define{{.*}}5foo42{{.*}}!type ![[TYPE42:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+
 pub fn foo43(_: u128) {}
 // CHECK: define{{.*}}5foo43{{.*}}!type ![[TYPE43:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo44(_: u128, _: u128) {}
 // CHECK: define{{.*}}5foo44{{.*}}!type ![[TYPE44:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo45(_: u128, _: u128, _: u128) {}
 // CHECK: define{{.*}}5foo45{{.*}}!type ![[TYPE45:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+
 pub fn foo46(_: usize) {}
 // CHECK: define{{.*}}5foo46{{.*}}!type ![[TYPE46:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo47(_: usize, _: usize) {}
 // CHECK: define{{.*}}5foo47{{.*}}!type ![[TYPE47:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo48(_: usize, _: usize, _: usize) {}
 // CHECK: define{{.*}}5foo48{{.*}}!type ![[TYPE48:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+
 pub fn foo49(_: f32) {}
 // CHECK: define{{.*}}5foo49{{.*}}!type ![[TYPE49:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo50(_: f32, _: f32) {}
 // CHECK: define{{.*}}5foo50{{.*}}!type ![[TYPE50:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo51(_: f32, _: f32, _: f32) {}
 // CHECK: define{{.*}}5foo51{{.*}}!type ![[TYPE51:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+
 pub fn foo52(_: f64) {}
 // CHECK: define{{.*}}5foo52{{.*}}!type ![[TYPE52:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo53(_: f64, _: f64) {}
 // CHECK: define{{.*}}5foo53{{.*}}!type ![[TYPE53:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo54(_: f64, _: f64, _: f64) {}
 // CHECK: define{{.*}}5foo54{{.*}}!type ![[TYPE54:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+
 pub fn foo55(_: char) {}
 // CHECK: define{{.*}}5foo55{{.*}}!type ![[TYPE55:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo56(_: char, _: char) {}
 // CHECK: define{{.*}}5foo56{{.*}}!type ![[TYPE56:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo57(_: char, _: char, _: char) {}
 // CHECK: define{{.*}}5foo57{{.*}}!type ![[TYPE57:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+
 pub fn foo58(_: &str) {}
 // CHECK: define{{.*}}5foo58{{.*}}!type ![[TYPE58:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 pub fn foo59(_: &str, _: &str) {}
@@ -130,6 +154,20 @@ pub fn foo59(_: &str, _: &str) {}
 pub fn foo60(_: &str, _: &str, _: &str) {}
 // CHECK: define{{.*}}5foo60{{.*}}!type ![[TYPE60:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
 
+pub fn foo61(_: f16) {}
+// CHECK: define{{.*}}5foo61{{.*}}!type ![[TYPE61:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo62(_: f16, _: f16) {}
+// CHECK: define{{.*}}5foo62{{.*}}!type ![[TYPE62:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo63(_: f16, _: f16, _: f16) {}
+// CHECK: define{{.*}}5foo63{{.*}}!type ![[TYPE63:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+
+pub fn foo64(_: f128) {}
+// CHECK: define{{.*}}5foo64{{.*}}!type ![[TYPE64:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo65(_: f128, _: f128) {}
+// CHECK: define{{.*}}5foo65{{.*}}!type ![[TYPE65:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo66(_: f128, _: f128, _: f128) {}
+// CHECK: define{{.*}}5foo66{{.*}}!type ![[TYPE66:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+
 // CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFvvE"}
 // CHECK: ![[TYPE4]] = !{i64 0, !"_ZTSFvPvE"}
 // CHECK: ![[TYPE5]] = !{i64 0, !"_ZTSFvPvS_E"}
@@ -188,3 +226,9 @@ pub fn foo60(_: &str, _: &str, _: &str) {}
 // CHECK: ![[TYPE58]] = !{i64 0, !"_ZTSFvu3refIu3strEE"}
 // CHECK: ![[TYPE59]] = !{i64 0, !"_ZTSFvu3refIu3strES0_E"}
 // CHECK: ![[TYPE60]] = !{i64 0, !"_ZTSFvu3refIu3strES0_S0_E"}
+// CHECK: ![[TYPE61]] = !{i64 0, !"_ZTSFvDhE"}
+// CHECK: ![[TYPE62]] = !{i64 0, !"_ZTSFvDhDhE"}
+// CHECK: ![[TYPE63]] = !{i64 0, !"_ZTSFvDhDhDhE"}
+// CHECK: ![[TYPE64]] = !{i64 0, !"_ZTSFvgE"}
+// CHECK: ![[TYPE65]] = !{i64 0, !"_ZTSFvggE"}
+// CHECK: ![[TYPE66]] = !{i64 0, !"_ZTSFvgggE"}
diff --git a/tests/crashes/150969.rs b/tests/crashes/150969.rs
deleted file mode 100644
index 5f0e09becf36f..0000000000000
--- a/tests/crashes/150969.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-//@ known-bug: #150969
-#![feature(generic_const_exprs)]
-#![feature(min_generic_const_args)]
-
-fn pass_enum<const N : usize, const M : usize = const {N}> {
-  pass_enum::<{core::direct_const_arg!(None)}>
-}
diff --git a/tests/run-make/complex-abi/main.rs b/tests/run-make/complex-abi/main.rs
new file mode 100644
index 0000000000000..75d446c480441
--- /dev/null
+++ b/tests/run-make/complex-abi/main.rs
@@ -0,0 +1,518 @@
+// ignore-tidy-file-linelength
+#![feature(complex_numbers, f128)]
+#![allow(improper_ctypes)]
+#![allow(unused_features)]
+#![deny(dead_code)]
+
+use std::ffi::*;
+use std::num::Complex;
+
+fn main() {
+    sqrt();
+    #[cfg(target_env = "gnu")]
+    mul();
+    #[cfg(target_env = "gnu")]
+    div();
+    pass_simple();
+    aligned_int();
+    aligned_float();
+    spill_gpr();
+    spill_fpr();
+    partial_gpr();
+}
+
+// This is just a placeholder until we actually add c_longdouble.
+#[allow(non_camel_case_types)]
+#[allow(unused)]
+type c_longdouble = cfg_select! {
+    target_arch = "aarch64" => {
+        cfg_select! {
+            any(windows, target_vendor = "apple", target_os = "android") => f64,
+            _ => f128,
+        }
+    }
+    _ => (),
+};
+
+/// Test calling the complex square root libc function.
+fn sqrt() {
+    unsafe extern "C" {
+        safe fn csqrtf(_: Complex<c_float>) -> Complex<c_float>;
+        safe fn csqrt(_: Complex<c_double>) -> Complex<c_double>;
+        #[cfg(target_arch = "aarch64")]
+        safe fn csqrtl(_: Complex<c_longdouble>) -> Complex<c_longdouble>;
+    }
+
+    let c = Complex::new(-1.0, 0.0);
+    assert_eq!(csqrtf(c), Complex::new(0.0, 1.0));
+
+    let c = Complex::new(-1.0, 0.0);
+    assert_eq!(csqrt(c), Complex::new(0.0, 1.0));
+
+    #[cfg(target_arch = "aarch64")]
+    {
+        let c = Complex::new(-1.0, 0.0);
+        assert_eq!(csqrtl(c), Complex::new(0.0, 1.0));
+    }
+}
+
+/// Test calling the complex multiplication libcall.
+#[cfg(target_env = "gnu")]
+fn mul() {
+    unsafe extern "C" {
+        safe fn __mulsc3(a: c_float, b: c_float, c: c_float, d: c_float) -> Complex<c_float>;
+        safe fn __muldc3(a: c_double, b: c_double, c: c_double, d: c_double) -> Complex<c_double>;
+        #[cfg(target_arch = "aarch64")]
+        safe fn __multc3(
+            a: c_longdouble,
+            b: c_longdouble,
+            c: c_longdouble,
+            d: c_longdouble,
+        ) -> Complex<c_longdouble>;
+    }
+
+    assert_eq!(__mulsc3(1.0, 2.0, 3.0, 4.0), Complex::new(-5.0, 10.0));
+    assert_eq!(__muldc3(1.0, 2.0, 3.0, 4.0), Complex::new(-5.0, 10.0));
+
+    #[cfg(target_arch = "aarch64")]
+    assert_eq!(__multc3(1.0, 2.0, 3.0, 4.0), Complex::new(-5.0, 10.0));
+
+    // The naive algorithm would return NaN + NaNi for these inputs, but the libcall handles it.
+    assert_eq!(
+        __mulsc3(1.0, 0.0, c_float::INFINITY, c_float::INFINITY),
+        Complex::new(c_float::INFINITY, c_float::INFINITY)
+    );
+    assert_eq!(
+        __muldc3(1.0, 0.0, c_double::INFINITY, c_double::INFINITY),
+        Complex::new(c_double::INFINITY, c_double::INFINITY)
+    );
+
+    #[cfg(target_arch = "aarch64")]
+    assert_eq!(
+        __multc3(1.0, 0.0, c_longdouble::INFINITY, c_longdouble::INFINITY),
+        Complex::new(c_longdouble::INFINITY, c_longdouble::INFINITY)
+    );
+}
+
+/// Test calling the complex division libcall.
+#[cfg(target_env = "gnu")]
+fn div() {
+    unsafe extern "C" {
+        safe fn __divsc3(a: c_float, b: c_float, c: c_float, d: c_float) -> Complex<c_float>;
+        safe fn __divdc3(a: c_double, b: c_double, c: c_double, d: c_double) -> Complex<c_double>;
+        #[cfg(target_arch = "aarch64")]
+        safe fn __divtc3(
+            a: c_longdouble,
+            b: c_longdouble,
+            c: c_longdouble,
+            d: c_longdouble,
+        ) -> Complex<c_longdouble>;
+    }
+
+    assert_eq!(__divsc3(2.0, 11.0, 2.0, 1.0), Complex::new(3.0, 4.0));
+    assert_eq!(__divdc3(2.0, 11.0, 2.0, 1.0), Complex::new(3.0, 4.0));
+
+    #[cfg(target_arch = "aarch64")]
+    assert_eq!(__divtc3(2.0, 11.0, 2.0, 1.0), Complex::new(3.0, 4.0));
+
+    assert_eq!(
+        __divsc3(c_float::INFINITY, 0.0, 1.0, 1.0),
+        Complex::new(c_float::INFINITY, c_float::NEG_INFINITY)
+    );
+    assert_eq!(
+        __divdc3(c_double::INFINITY, 0.0, 1.0, 1.0),
+        Complex::new(c_double::INFINITY, c_double::NEG_INFINITY)
+    );
+
+    #[cfg(target_arch = "aarch64")]
+    assert_eq!(
+        __divtc3(c_longdouble::INFINITY, 0.0, 1.0, 1.0),
+        Complex::new(c_longdouble::INFINITY, c_longdouble::NEG_INFINITY)
+    );
+}
+
+/// Pass and return a complex value, check input and output are equal.
+fn pass_simple() {
+    #[rustfmt::skip]
+    #[link(name = "test", kind = "static")]
+    unsafe extern "C" {
+        safe fn pass_simple_complex_float(x: Complex<c_float>) -> Complex<c_float>;
+        safe fn pass_simple_complex_double(x: Complex<c_double>) -> Complex<c_double>;
+        #[cfg(target_arch = "aarch64")]
+        safe fn pass_simple_complex_long_double(x: Complex<c_longdouble>) -> Complex<c_longdouble>;
+
+        safe fn pass_simple_complex_char(x: Complex<c_char>) -> Complex<c_char>;
+        safe fn pass_simple_complex_short(x: Complex<c_short>) -> Complex<c_short>;
+        safe fn pass_simple_complex_int(x: Complex<c_int>) -> Complex<c_int>;
+        safe fn pass_simple_complex_long(x: Complex<c_long>) -> Complex<c_long>;
+        safe fn pass_simple_complex_long_long(x: Complex<c_longlong>) -> Complex<c_longlong>;
+    }
+
+    assert_eq!(Complex::new(3.5, 4.5), pass_simple_complex_float(Complex::new(3.5, 4.5)));
+    assert_eq!(Complex::new(3.5, 4.5), pass_simple_complex_double(Complex::new(3.5, 4.5)));
+
+    assert_eq!(
+        Complex::new(c_float::INFINITY, c_float::NEG_INFINITY),
+        pass_simple_complex_float(Complex::new(c_float::INFINITY, c_float::NEG_INFINITY))
+    );
+    assert_eq!(
+        Complex::new(c_double::INFINITY, c_double::NEG_INFINITY),
+        pass_simple_complex_double(Complex::new(c_double::INFINITY, c_double::NEG_INFINITY))
+    );
+    #[cfg(target_arch = "aarch64")]
+    assert_eq!(
+        Complex::new(c_longdouble::INFINITY, c_longdouble::NEG_INFINITY),
+        pass_simple_complex_long_double(Complex::new(
+            c_longdouble::INFINITY,
+            c_longdouble::NEG_INFINITY
+        ))
+    );
+
+    assert_eq!(Complex::new(3, 4), pass_simple_complex_char(Complex::new(3, 4)));
+    assert_eq!(Complex::new(3, 4), pass_simple_complex_short(Complex::new(3, 4)));
+    assert_eq!(Complex::new(3, 4), pass_simple_complex_int(Complex::new(3, 4)));
+    assert_eq!(Complex::new(3, 4), pass_simple_complex_long(Complex::new(3, 4)));
+    assert_eq!(Complex::new(3, 4), pass_simple_complex_long_long(Complex::new(3, 4)));
+
+    assert_eq!(
+        Complex::new(c_char::MIN, c_char::MAX),
+        pass_simple_complex_char(Complex::new(c_char::MIN, c_char::MAX))
+    );
+    assert_eq!(
+        Complex::new(c_short::MIN, c_short::MAX),
+        pass_simple_complex_short(Complex::new(c_short::MIN, c_short::MAX))
+    );
+    assert_eq!(
+        Complex::new(c_int::MIN, c_int::MAX),
+        pass_simple_complex_int(Complex::new(c_int::MIN, c_int::MAX))
+    );
+    assert_eq!(
+        Complex::new(c_long::MIN, c_long::MAX),
+        pass_simple_complex_long(Complex::new(c_long::MIN, c_long::MAX))
+    );
+    assert_eq!(
+        Complex::new(c_longlong::MIN, c_longlong::MAX),
+        pass_simple_complex_long_long(Complex::new(c_longlong::MIN, c_longlong::MAX))
+    );
+}
+
+/// Check that a complex number after a `c_int` argument is correctly aligned.
+fn aligned_int() {
+    #[rustfmt::skip]
+    #[link(name = "test", kind = "static")]
+    unsafe extern "C" {
+        safe fn complex_float_align_int(_: c_int, x: Complex<c_float>) -> Complex<c_float>;
+        safe fn complex_double_align_int(_: c_int, x: Complex<c_double>) -> Complex<c_double>;
+        #[cfg(target_arch = "aarch64")]
+        safe fn complex_long_double_align_int(_: c_int, x: Complex<c_longdouble>) -> Complex<c_longdouble>;
+
+        safe fn complex_char_align_int(_: c_int, x: Complex<c_char>) -> Complex<c_char>;
+        safe fn complex_short_align_int(_: c_int, x: Complex<c_short>) -> Complex<c_short>;
+        safe fn complex_int_align_int(_: c_int, x: Complex<c_int>) -> Complex<c_int>;
+        safe fn complex_long_align_int(_: c_int, x: Complex<c_long>) -> Complex<c_long>;
+        safe fn complex_long_long_align_int(_: c_int, x: Complex<c_longlong>) -> Complex<c_longlong>;
+    }
+
+    let a = 0xAAAA_AAAAu32 as c_int;
+
+    assert_eq!(Complex::new(3.5, 4.5), complex_float_align_int(a, Complex::new(3.5, 4.5)));
+    assert_eq!(Complex::new(3.5, 4.5), complex_double_align_int(a, Complex::new(3.5, 4.5)));
+
+    assert_eq!(
+        Complex::new(c_float::INFINITY, c_float::NEG_INFINITY),
+        complex_float_align_int(a, Complex::new(c_float::INFINITY, c_float::NEG_INFINITY))
+    );
+    assert_eq!(
+        Complex::new(c_double::INFINITY, c_double::NEG_INFINITY),
+        complex_double_align_int(a, Complex::new(c_double::INFINITY, c_double::NEG_INFINITY))
+    );
+    #[cfg(target_arch = "aarch64")]
+    assert_eq!(
+        Complex::new(c_longdouble::INFINITY, c_longdouble::NEG_INFINITY),
+        complex_long_double_align_int(
+            a,
+            Complex::new(c_longdouble::INFINITY, c_longdouble::NEG_INFINITY)
+        )
+    );
+
+    assert_eq!(Complex::new(3, 4), complex_char_align_int(a, Complex::new(3, 4)));
+    assert_eq!(Complex::new(3, 4), complex_short_align_int(a, Complex::new(3, 4)));
+    assert_eq!(Complex::new(3, 4), complex_int_align_int(a, Complex::new(3, 4)));
+    assert_eq!(Complex::new(3, 4), complex_long_align_int(a, Complex::new(3, 4)));
+    assert_eq!(Complex::new(3, 4), complex_long_long_align_int(a, Complex::new(3, 4)));
+
+    assert_eq!(
+        Complex::new(c_char::MIN, c_char::MAX),
+        complex_char_align_int(a, Complex::new(c_char::MIN, c_char::MAX))
+    );
+    assert_eq!(
+        Complex::new(c_short::MIN, c_short::MAX),
+        complex_short_align_int(a, Complex::new(c_short::MIN, c_short::MAX))
+    );
+    assert_eq!(
+        Complex::new(c_int::MIN, c_int::MAX),
+        complex_int_align_int(a, Complex::new(c_int::MIN, c_int::MAX))
+    );
+    assert_eq!(
+        Complex::new(c_long::MIN, c_long::MAX),
+        complex_long_align_int(a, Complex::new(c_long::MIN, c_long::MAX))
+    );
+    assert_eq!(
+        Complex::new(c_longlong::MIN, c_longlong::MAX),
+        complex_long_long_align_int(a, Complex::new(c_longlong::MIN, c_longlong::MAX))
+    );
+}
+
+/// Check that a complex number after a `c_float` argument is correctly aligned.
+fn aligned_float() {
+    #[rustfmt::skip]
+    #[link(name = "test", kind = "static")]
+    unsafe extern "C" {
+        safe fn complex_float_align_float(_: c_float, x: Complex<c_float>) -> Complex<c_float>;
+        safe fn complex_double_align_float(_: c_float, x: Complex<c_double>) -> Complex<c_double>;
+        #[cfg(target_arch = "aarch64")]
+        safe fn complex_long_double_align_float(_: c_float, x: Complex<c_longdouble>) -> Complex<c_longdouble>;
+
+        safe fn complex_char_align_float(_: c_float, x: Complex<c_char>) -> Complex<c_char>;
+        safe fn complex_short_align_float(_: c_float, x: Complex<c_short>) -> Complex<c_short>;
+        safe fn complex_int_align_float(_: c_float, x: Complex<c_int>) -> Complex<c_int>;
+        safe fn complex_long_align_float(_: c_float, x: Complex<c_long>) -> Complex<c_long>;
+        safe fn complex_long_long_align_float(_: c_float, x: Complex<c_longlong>) -> Complex<c_longlong>;
+    }
+
+    let a = 3.14 as c_float;
+
+    assert_eq!(Complex::new(3.5, 4.5), complex_float_align_float(a, Complex::new(3.5, 4.5)));
+    assert_eq!(Complex::new(3.5, 4.5), complex_double_align_float(a, Complex::new(3.5, 4.5)));
+
+    assert_eq!(
+        Complex::new(c_float::INFINITY, c_float::NEG_INFINITY),
+        complex_float_align_float(a, Complex::new(c_float::INFINITY, c_float::NEG_INFINITY))
+    );
+    assert_eq!(
+        Complex::new(c_double::INFINITY, c_double::NEG_INFINITY),
+        complex_double_align_float(a, Complex::new(c_double::INFINITY, c_double::NEG_INFINITY))
+    );
+    #[cfg(target_arch = "aarch64")]
+    assert_eq!(
+        Complex::new(c_longdouble::INFINITY, c_longdouble::NEG_INFINITY),
+        complex_long_double_align_float(
+            a,
+            Complex::new(c_longdouble::INFINITY, c_longdouble::NEG_INFINITY)
+        )
+    );
+
+    assert_eq!(Complex::new(3, 4), complex_char_align_float(a, Complex::new(3, 4)));
+    assert_eq!(Complex::new(3, 4), complex_short_align_float(a, Complex::new(3, 4)));
+    assert_eq!(Complex::new(3, 4), complex_int_align_float(a, Complex::new(3, 4)));
+    assert_eq!(Complex::new(3, 4), complex_long_align_float(a, Complex::new(3, 4)));
+    assert_eq!(Complex::new(3, 4), complex_long_long_align_float(a, Complex::new(3, 4)));
+
+    assert_eq!(
+        Complex::new(c_char::MIN, c_char::MAX),
+        complex_char_align_float(a, Complex::new(c_char::MIN, c_char::MAX))
+    );
+    assert_eq!(
+        Complex::new(c_short::MIN, c_short::MAX),
+        complex_short_align_float(a, Complex::new(c_short::MIN, c_short::MAX))
+    );
+    assert_eq!(
+        Complex::new(c_int::MIN, c_int::MAX),
+        complex_int_align_float(a, Complex::new(c_int::MIN, c_int::MAX))
+    );
+    assert_eq!(
+        Complex::new(c_long::MIN, c_long::MAX),
+        complex_long_align_float(a, Complex::new(c_long::MIN, c_long::MAX))
+    );
+    assert_eq!(
+        Complex::new(c_longlong::MIN, c_longlong::MAX),
+        complex_long_long_align_float(a, Complex::new(c_longlong::MIN, c_longlong::MAX))
+    );
+}
+
+/// Assuming 8 GPRs, put a complex number right at the boundary where it only partially fits in the
+/// remaining GPRs. ABIs can either split the value or pass it completely in memory.
+#[rustfmt::skip]
+fn partial_gpr() {
+    #[link(name = "test", kind = "static")]
+    unsafe extern "C" {
+        safe fn partial_complex_float(a: c_int, b: c_int, c: c_int, d: c_int, e: c_int, f: c_int, g: c_int, x: Complex<c_float>) -> Complex<c_float>;
+        safe fn partial_complex_double(a: c_int, b: c_int, c: c_int, d: c_int, e: c_int, f: c_int, g: c_int, x: Complex<c_double>) -> Complex<c_double>;
+        #[cfg(target_arch = "aarch64")]
+        safe fn partial_complex_long_double(a: c_int, b: c_int, c: c_int, d: c_int, e: c_int, f: c_int, g: c_int, x: Complex<c_longdouble>) -> Complex<c_longdouble>;
+
+        safe fn partial_complex_char(a: c_int, b: c_int, c: c_int, d: c_int, e: c_int, f: c_int, g: c_int, x: Complex<c_schar>) -> Complex<c_schar>;
+        safe fn partial_complex_short(a: c_int, b: c_int, c: c_int, d: c_int, e: c_int, f: c_int, g: c_int, x: Complex<c_short>) -> Complex<c_short>;
+        safe fn partial_complex_int(a: c_int, b: c_int, c: c_int, d: c_int, e: c_int, f: c_int, g: c_int, x: Complex<c_int>) -> Complex<c_int>;
+        safe fn partial_complex_long(a: c_int, b: c_int, c: c_int, d: c_int, e: c_int, f: c_int, g: c_int, x: Complex<c_long>) -> Complex<c_long>;
+        safe fn partial_complex_long_long(a: c_int, b: c_int, c: c_int, d: c_int, e: c_int, f: c_int, g: c_int, x: Complex<c_longlong>) -> Complex<c_longlong>;
+    }
+
+    let complex = Complex { re: 3.14, im: 6.28 };
+    assert_eq!(
+        partial_complex_float(
+            0x11111111, 0x22222222, 0x33333333, 0x44444444,
+            0x55555555, 0x66666666, 0x77777777, complex,
+        ),
+        complex,
+    );
+
+    let complex = Complex { re: 3.14, im: 6.28 };
+    assert_eq!(
+        partial_complex_double(
+            0x11111111, 0x22222222, 0x33333333, 0x44444444,
+            0x55555555, 0x66666666, 0x77777777, complex,
+        ),
+        complex,
+    );
+
+    #[cfg(target_arch = "aarch64")]
+    {
+        let complex = Complex { re: 3.14 as c_longdouble, im: 6.28 as c_longdouble };
+        assert_eq!(
+            partial_complex_long_double(
+                0x11111111, 0x22222222, 0x33333333, 0x44444444,
+                0x55555555, 0x66666666, 0x77777777, complex,
+            ),
+            complex,
+        );
+    }
+
+    let complex = Complex { re: 3 as c_schar, im: 6 as c_schar };
+    assert_eq!(
+        partial_complex_char(
+            0x11111111, 0x22222222, 0x33333333, 0x44444444,
+            0x55555555, 0x66666666, 0x77777777, complex,
+        ),
+        complex,
+    );
+
+    let complex = Complex { re: 3 as c_short, im: 6 as c_short };
+    assert_eq!(
+        partial_complex_short(
+            0x11111111, 0x22222222, 0x33333333, 0x44444444,
+            0x55555555, 0x66666666, 0x77777777, complex,
+        ),
+        complex,
+    );
+
+    let complex = Complex { re: 3 as c_int, im: 6 as c_int };
+    assert_eq!(
+        partial_complex_int(
+            0x11111111, 0x22222222, 0x33333333, 0x44444444,
+            0x55555555, 0x66666666, 0x77777777, complex,
+        ),
+        complex,
+    );
+
+    let complex = Complex { re: 3 as c_long, im: 6 as c_long };
+    assert_eq!(
+        partial_complex_long(
+            0x11111111, 0x22222222, 0x33333333, 0x44444444,
+            0x55555555, 0x66666666, 0x77777777, complex,
+        ),
+        complex,
+    );
+
+    let complex = Complex { re: 3 as c_longlong, im: 6 as c_longlong };
+    assert_eq!(
+        partial_complex_long_long(
+            0x11111111, 0x22222222, 0x33333333, 0x44444444,
+            0x55555555, 0x66666666, 0x77777777, complex,
+        ),
+        complex,
+    );
+}
+
+/// Same as partial_gpr but test an argument following the complex number.
+///
+/// This test is based on 32-bit powerpc behavior where a complex number in this position is moved to
+/// the stack (and not split), and remaining registers are consumed so that any subsequent arguments
+/// are also passed via the stack.
+#[rustfmt::skip]
+fn spill_gpr() {
+    #[link(name = "test", kind = "static")]
+    unsafe extern "C" {
+        fn spill_trailing_complex_float_1(a: c_int, b: c_int, c: c_int, d: c_int, e: c_int, f: c_int, g: c_int, x: Complex<c_float>, h: c_int) -> c_int;
+
+        fn spill_trailing_complex_double_1(a: c_int, b: c_int, c: c_int, d: c_int, e: c_int, f: c_int, x: Complex<c_double>, g: c_int) -> c_int;
+        fn spill_trailing_complex_double_2(a: c_int, b: c_int, c: c_int, d: c_int, e: c_int, x: Complex<c_double>, f: c_int, g: c_int) -> c_int;
+        fn spill_trailing_complex_double_3(a: c_int, b: c_int, c: c_int, d: c_int, x: Complex<c_double>, e: c_int, f: c_int, g: c_int) -> c_int;
+
+        #[cfg(target_arch = "aarch64")]
+        fn spill_trailing_complex_long_double_1(a: c_int, x: Complex<c_longdouble>, b: c_int) -> c_int;
+    }
+
+    unsafe {
+        assert_eq!(
+            spill_trailing_complex_float_1(0x11111111, 0x22222222, 0x33333333, 0x44444444, 0x55555555, 0x66666666, 0x77777777, Complex::new(1.0, 2.0), 0x88888888_u32 as c_int),
+            0x88888888_u32 as c_int,
+        );
+
+        assert_eq!(
+            spill_trailing_complex_double_1(0x11111111, 0x22222222, 0x33333333, 0x44444444, 0x55555555, 0x66666666, Complex::new(1.0, 2.0), 0x77777777),
+            0x77777777,
+        );
+
+        assert_eq!(
+            spill_trailing_complex_double_2(0x11111111, 0x22222222, 0x33333333, 0x44444444, 0x55555555, Complex::new(1.0, 2.0), 0x66666666, 0x77777777),
+            0x77777777,
+        );
+
+        assert_eq!(
+            spill_trailing_complex_double_3(0x11111111, 0x22222222, 0x33333333, 0x44444444, Complex::new(1.0, 2.0), 0x55555555, 0x66666666, 0x77777777),
+            0x77777777,
+        );
+
+        #[cfg(target_arch = "aarch64")]
+        assert_eq!(
+            spill_trailing_complex_long_double_1(0x11111111, Complex::new(1.0, 2.0), 0x22222222,),
+            0x22222222,
+        );
+    }
+}
+
+/// Same as spill_gpr but for float registers.
+#[rustfmt::skip]
+fn spill_fpr() {
+    #[link(name = "test", kind = "static")]
+    unsafe extern "C" {
+        safe fn spill_trailing_complex_float_1_float(a0: f32, a1: f32, a2: f32, a3: f32, a4: f32, a5: f32, a6: f32, value: Complex<f32>, x: f32) -> f32;
+        safe fn spill_trailing_complex_float_2_float(a0: f32, a1: f32, a2: f32, a3: f32, a4: f32, a5: f32, a6: f32, a7: f32, value: Complex<f32>, x: f32) -> f32;
+
+        safe fn spill_trailing_complex_double_1_float(a0: f32, a1: f32, a2: f32, a3: f32, a4: f32, a5: f32, value: Complex<f64>, x: f32) -> f32;
+        safe fn spill_trailing_complex_double_2_float(a0: f32, a1: f32, a2: f32, a3: f32, a4: f32, a5: f32, a6: f32, value: Complex<f64>, x: f32, y: f32) -> f32;
+        safe fn spill_trailing_complex_double_3_float(a0: f32, a1: f32, a2: f32, a3: f32, a4: f32, a5: f32, a6: f32, a7: f32, value: Complex<f64>, x: f32, y: f32) -> f32;
+
+        #[cfg(target_arch = "aarch64")]
+        safe fn spill_trailing_complex_long_double_1_float(a0: f32, a1: f32, a2: f32, a3: f32, a4: f32, a5: f32, value: Complex<c_longdouble>, x: f32) -> f32;
+    }
+
+    assert_eq!(
+        spill_trailing_complex_float_1_float(0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, Complex::new(1.0, 2.0), 0.8),
+        0.8,
+    );
+    assert_eq!(
+       spill_trailing_complex_float_2_float(0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, Complex::new(1.0, 2.0), 0.8),
+        0.8,
+    );
+
+    assert_eq!(
+        spill_trailing_complex_double_1_float(0.0, 0.1, 0.2, 0.3, 0.4, 0.5, Complex::new(1.0, 2.0), 0.6),
+        0.6,
+    );
+    assert_eq!(
+        spill_trailing_complex_double_2_float(0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, Complex::new(1.0, 2.0), 0.7, 0.8),
+        0.8,
+    );
+    assert_eq!(
+        spill_trailing_complex_double_3_float(0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, Complex::new(1.0, 2.0), 0.8, 0.9),
+        0.9,
+    );
+
+    #[cfg(target_arch = "aarch64")]
+    assert_eq!(
+        spill_trailing_complex_long_double_1_float(0.0, 0.1, 0.2, 0.3, 0.4, 0.5, Complex::new(1.0, 2.0), 0.6),
+        0.6,
+    );
+}
diff --git a/tests/run-make/complex-abi/rmake.rs b/tests/run-make/complex-abi/rmake.rs
new file mode 100644
index 0000000000000..4836e72717513
--- /dev/null
+++ b/tests/run-make/complex-abi/rmake.rs
@@ -0,0 +1,14 @@
+//@ needs-target-std
+//@ ignore-msvc: `_Complex` is not supported by msvc
+//@ ignore-android: FIXME(#142855)
+//@ ignore-sgx: (x86 machine code cannot be directly executed)
+//@ ignore-pauthtest: (it requires non-trivial compilation of c sources, and only supports dynamic
+//  linking, ignore the test).
+
+use run_make_support::{bin_name, build_native_static_lib, env_var, run, rustc};
+
+fn main() {
+    build_native_static_lib("test");
+    rustc().linker(&env_var("CC")).input("main.rs").run();
+    run(&bin_name("main"));
+}
diff --git a/tests/run-make/complex-abi/test.c b/tests/run-make/complex-abi/test.c
new file mode 100644
index 0000000000000..45155ca6f113d
--- /dev/null
+++ b/tests/run-make/complex-abi/test.c
@@ -0,0 +1,113 @@
+// ignore-tidy-file-linelength
+
+_Complex float pass_simple_complex_float(_Complex float x) { return x; }
+_Complex double pass_simple_complex_double(_Complex double x) { return x; }
+_Complex long double pass_simple_complex_long_double(_Complex long double x) { return x; }
+
+_Complex char pass_simple_complex_char(_Complex char x) { return x; }
+_Complex short pass_simple_complex_short(_Complex short x) { return x; }
+_Complex int pass_simple_complex_int(_Complex int x) { return x; }
+_Complex long pass_simple_complex_long(_Complex long x) { return x; }
+_Complex long long pass_simple_complex_long_long(_Complex long long x) { return x; }
+
+
+
+_Complex float complex_float_align_int(int a0, _Complex float value) { return value; }
+_Complex double complex_double_align_int(int a0, _Complex double value) { return value; }
+_Complex long double complex_long_double_align_int(int a0, _Complex long double value) { return value; }
+
+_Complex char complex_char_align_int(int a0, _Complex char value) { return value; }
+_Complex short complex_short_align_int(int a0, _Complex short value) { return value; }
+_Complex int complex_int_align_int(int a0, _Complex int value) { return value; }
+_Complex long complex_long_align_int(int a0, _Complex long value) { return value; }
+_Complex long long complex_long_long_align_int(int a0, _Complex long long value) { return value; }
+
+
+
+_Complex float complex_float_align_float(float a0, _Complex float value) { return value; }
+_Complex double complex_double_align_float(float a0, _Complex double value) { return value; }
+_Complex long double complex_long_double_align_float(float a0, _Complex long double value) { return value; }
+
+_Complex char complex_char_align_float(float a0, _Complex char value) { return value; }
+_Complex short complex_short_align_float(float a0, _Complex short value) { return value; }
+_Complex int complex_int_align_float(float a0, _Complex int value) { return value; }
+_Complex long complex_long_align_float(float a0, _Complex long value) { return value; }
+_Complex long long complex_long_long_align_float(float a0, _Complex long long value) { return value; }
+
+
+
+int spill_trailing_complex_float_1(int a0, int a1, int a2, int a3, int a4, int a5, int a6, _Complex float value, int x) { return x; }
+
+int spill_trailing_complex_double_1(int a0, int a1, int a2, int a3, int a4, int a5, _Complex double value, int x) { return x; }
+int spill_trailing_complex_double_2(int a0, int a1, int a2, int a3, int a4, _Complex double value, int x, int y) { return y; }
+int spill_trailing_complex_double_3(int a0, int a1, int a2, int a3, _Complex double value, int x, int y, int z) { return z; }
+
+int spill_trailing_complex_long_double_1(int a0, _Complex long double value, int x) { return x; }
+
+
+
+float spill_trailing_complex_float_1_float(float a0, float a1, float a2, float a3, float a4, float a5, float a6, _Complex float value, float x) { return x; }
+float spill_trailing_complex_float_2_float(float a0, float a1, float a2, float a3, float a4, float a5, float a6, float a7, _Complex float value, float x) { return x; }
+
+float spill_trailing_complex_double_1_float(float a0, float a1, float a2, float a3, float a4, float a5, _Complex double value, float x) { return x; }
+float spill_trailing_complex_double_2_float(float a0, float a1, float a2, float a3, float a4, float a5, float a6, _Complex double value, float x, float y) { return y; }
+float spill_trailing_complex_double_3_float(float a0, float a1, float a2, float a3, float a4, float a5, float a6, float a7, _Complex double value, float x, float y) { return y; }
+
+float spill_trailing_complex_long_double_1_float(float a0, float a1, float a2, float a3, float a4, float a5, _Complex long double value, float x) { return x; }
+
+
+_Complex float partial_complex_float(
+    int a0, int a1, int a2, int a3,
+    int a4, int a5, int a6,
+    _Complex float value) {
+  return value;
+}
+
+_Complex double partial_complex_double(
+    int a0, int a1, int a2, int a3,
+    int a4, int a5, int a6,
+    _Complex double value) {
+  return value;
+}
+
+_Complex long double partial_complex_long_double(
+    int a0, int a1, int a2, int a3,
+    int a4, int a5, int a6,
+    _Complex long double value) {
+  return value;
+}
+
+_Complex char partial_complex_char(
+    int a0, int a1, int a2, int a3,
+    int a4, int a5, int a6,
+    _Complex char value) {
+  return value;
+}
+
+_Complex short partial_complex_short(
+    int a0, int a1, int a2, int a3,
+    int a4, int a5, int a6,
+    _Complex short value) {
+  return value;
+}
+
+_Complex int partial_complex_int(
+    int a0, int a1, int a2, int a3,
+    int a4, int a5, int a6,
+    _Complex int value) {
+  return value;
+}
+
+_Complex long partial_complex_long(
+    int a0, int a1, int a2, int a3,
+    int a4, int a5, int a6,
+    _Complex long value) {
+  return value;
+}
+
+_Complex long long partial_complex_long_long(
+    int a0, int a1, int a2, int a3,
+    int a4, int a5, int a6,
+    _Complex long long value) {
+  return value;
+}
diff --git a/tests/rustdoc-html/async/async-move-doctest.rs b/tests/rustdoc-ui/doctest/async-move-doctest.rs
similarity index 77%
rename from tests/rustdoc-html/async/async-move-doctest.rs
rename to tests/rustdoc-ui/doctest/async-move-doctest.rs
index e18ec353533df..f491a9a04f851 100644
--- a/tests/rustdoc-html/async/async-move-doctest.rs
+++ b/tests/rustdoc-ui/doctest/async-move-doctest.rs
@@ -1,5 +1,7 @@
 //@ compile-flags:--test
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 //@ edition:2018
+//@ check-pass
 
 // Prior to setting the default edition for the doctest pre-parser,
 // this doctest would fail due to a fatal parsing error.
diff --git a/tests/rustdoc-ui/doctest/async-move-doctest.stdout b/tests/rustdoc-ui/doctest/async-move-doctest.stdout
new file mode 100644
index 0000000000000..4790438d4602f
--- /dev/null
+++ b/tests/rustdoc-ui/doctest/async-move-doctest.stdout
@@ -0,0 +1,6 @@
+
+running 1 test
+test $DIR/async-move-doctest.rs - (line 10) ... ok
+
+test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
+
diff --git a/tests/rustdoc-html/comment-in-doctest.rs b/tests/rustdoc-ui/doctest/comment-in-doctest.rs
similarity index 89%
rename from tests/rustdoc-html/comment-in-doctest.rs
rename to tests/rustdoc-ui/doctest/comment-in-doctest.rs
index e580aa2bb72c6..2caec5db9c920 100644
--- a/tests/rustdoc-html/comment-in-doctest.rs
+++ b/tests/rustdoc-ui/doctest/comment-in-doctest.rs
@@ -1,4 +1,6 @@
 //@ compile-flags:--test
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ check-pass
 
 // comments, both doc comments and regular ones, used to trick rustdoc's doctest parser into
 // thinking that everything after it was part of the regular program. combined with the librustc_ast
diff --git a/tests/rustdoc-ui/doctest/comment-in-doctest.stdout b/tests/rustdoc-ui/doctest/comment-in-doctest.stdout
new file mode 100644
index 0000000000000..5cb97c53f37fd
--- /dev/null
+++ b/tests/rustdoc-ui/doctest/comment-in-doctest.stdout
@@ -0,0 +1,6 @@
+
+running 1 test
+test $DIR/comment-in-doctest.rs - (line 12) ... ok
+
+test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
+
diff --git a/tests/rustdoc-html/demo-allocator-54478.rs b/tests/rustdoc-ui/doctest/demo-allocator-54478.rs
similarity index 93%
rename from tests/rustdoc-html/demo-allocator-54478.rs
rename to tests/rustdoc-ui/doctest/demo-allocator-54478.rs
index 80acfc0ff58a1..073d83e11120e 100644
--- a/tests/rustdoc-html/demo-allocator-54478.rs
+++ b/tests/rustdoc-ui/doctest/demo-allocator-54478.rs
@@ -1,4 +1,9 @@
 // https://github.com/rust-lang/rust/issues/54478
+
+//@ compile-flags:--test
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ check-pass
+
 #![crate_name="foo"]
 
 // Issue #54478: regression test showing that we can demonstrate
@@ -15,8 +20,6 @@
 // decided to change `rustdoc` to behave more like the compiler's
 // default setting, by leaving off `-C prefer-dynamic`.
 
-//@ compile-flags:--test
-
 //! This is a doc comment
 //!
 //! ```rust
diff --git a/tests/rustdoc-ui/doctest/demo-allocator-54478.stdout b/tests/rustdoc-ui/doctest/demo-allocator-54478.stdout
new file mode 100644
index 0000000000000..f32d9a5b7d932
--- /dev/null
+++ b/tests/rustdoc-ui/doctest/demo-allocator-54478.stdout
@@ -0,0 +1,6 @@
+
+running 1 test
+test $DIR/demo-allocator-54478.rs - (line 25) ... ok
+
+test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
+
diff --git a/tests/rustdoc-html/doc-cfg/doc-cfg-target-feature.rs b/tests/rustdoc-ui/doctest/doc-cfg-target-feature.rs
similarity index 65%
rename from tests/rustdoc-html/doc-cfg/doc-cfg-target-feature.rs
rename to tests/rustdoc-ui/doctest/doc-cfg-target-feature.rs
index b66e86e36af8b..7769dfa18fc8c 100644
--- a/tests/rustdoc-html/doc-cfg/doc-cfg-target-feature.rs
+++ b/tests/rustdoc-ui/doctest/doc-cfg-target-feature.rs
@@ -1,6 +1,9 @@
 //@ only-x86_64
+//@ only-linux
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "rust_out::main::.+" -> "rust_out::main::$$PATH"
 //@ compile-flags:--test
-//@ should-fail
+//@ failure-status: 101
 
 // #49723: rustdoc didn't add target features when extracting or running doctests
 
diff --git a/tests/rustdoc-ui/doctest/doc-cfg-target-feature.stdout b/tests/rustdoc-ui/doctest/doc-cfg-target-feature.stdout
new file mode 100644
index 0000000000000..5cc999924e891
--- /dev/null
+++ b/tests/rustdoc-ui/doctest/doc-cfg-target-feature.stdout
@@ -0,0 +1,39 @@
+
+running 1 test
+test $DIR/doc-cfg-target-feature.rs - foo (line 16) ... FAILED
+
+failures:
+
+---- $DIR/doc-cfg-target-feature.rs - foo (line 16) stdout ----
+warning: the feature `cfg_target_feature` has been stable since 1.27.0 and no longer requires an attribute to enable
+  --> $DIR/doc-cfg-target-feature.rs:16:12
+   |
+LL | #![feature(cfg_target_feature)]
+   |            ^^^^^^^^^^^^^^^^^^
+   |
+   = note: `#[warn(stable_features)]` on by default
+
+warning: 1 warning emitted
+
+Test executable failed (exit status: 101).
+
+stderr:
+
+thread 'main' ($TID) panicked at $DIR/doc-cfg-target-feature.rs:7:1:
+assertion failed: false
+stack backtrace:
+   0: __rustc::rust_begin_unwind
+   1: core::panicking::panic_fmt
+   2: core::panicking::panic
+   3: rust_out::main::$PATH
+   4: rust_out::main
+   5: <fn() as core::ops::function::FnOnce<()>>::call_once
+note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.
+
+
+
+failures:
+    $DIR/doc-cfg-target-feature.rs - foo (line 16)
+
+test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
+
diff --git a/tests/rustdoc-html/doc-test-attr-18199.rs b/tests/rustdoc-ui/doctest/doc-test-attr-18199.rs
similarity index 74%
rename from tests/rustdoc-html/doc-test-attr-18199.rs
rename to tests/rustdoc-ui/doctest/doc-test-attr-18199.rs
index 64016e32eeeb1..8350f244fccac 100644
--- a/tests/rustdoc-html/doc-test-attr-18199.rs
+++ b/tests/rustdoc-ui/doctest/doc-test-attr-18199.rs
@@ -1,6 +1,9 @@
-//@ compile-flags:--test
 // https://github.com/rust-lang/rust/issues/18199
 
+//@ compile-flags:--test
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ check-pass
+
 #![doc(test(attr(feature(staged_api))))]
 
 /// ```
diff --git a/tests/rustdoc-ui/doctest/doc-test-attr-18199.stdout b/tests/rustdoc-ui/doctest/doc-test-attr-18199.stdout
new file mode 100644
index 0000000000000..a182a3b911af6
--- /dev/null
+++ b/tests/rustdoc-ui/doctest/doc-test-attr-18199.stdout
@@ -0,0 +1,6 @@
+
+running 1 test
+test $DIR/doc-test-attr-18199.rs - foo (line 9) ... ok
+
+test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
+
diff --git a/tests/rustdoc-html/edition-doctest.rs b/tests/rustdoc-ui/doctest/edition-doctest.rs
similarity index 87%
rename from tests/rustdoc-html/edition-doctest.rs
rename to tests/rustdoc-ui/doctest/edition-doctest.rs
index f43c074f806bd..066475dae7bf0 100644
--- a/tests/rustdoc-html/edition-doctest.rs
+++ b/tests/rustdoc-ui/doctest/edition-doctest.rs
@@ -1,4 +1,6 @@
-//@ compile-flags:--test
+//@ compile-flags:--test --test-args=--test-threads=1
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ check-pass
 
 /// ```rust,edition2018
 /// #![feature(try_blocks)]
diff --git a/tests/rustdoc-ui/doctest/edition-doctest.stdout b/tests/rustdoc-ui/doctest/edition-doctest.stdout
new file mode 100644
index 0000000000000..40d0df0575a76
--- /dev/null
+++ b/tests/rustdoc-ui/doctest/edition-doctest.stdout
@@ -0,0 +1,7 @@
+
+running 2 tests
+test $DIR/edition-doctest.rs - foo (line 24) - compile fail ... ok
+test $DIR/edition-doctest.rs - foo (line 5) ... ok
+
+test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
+
diff --git a/tests/rustdoc-html/edition-flag.rs b/tests/rustdoc-ui/doctest/edition-flag.rs
similarity index 63%
rename from tests/rustdoc-html/edition-flag.rs
rename to tests/rustdoc-ui/doctest/edition-flag.rs
index c57c8d50b2357..51235634dbf4a 100644
--- a/tests/rustdoc-html/edition-flag.rs
+++ b/tests/rustdoc-ui/doctest/edition-flag.rs
@@ -1,5 +1,7 @@
 //@ compile-flags:--test
 //@ edition:2018
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ check-pass
 
 /// ```rust
 /// fn main() {
diff --git a/tests/rustdoc-ui/doctest/edition-flag.stdout b/tests/rustdoc-ui/doctest/edition-flag.stdout
new file mode 100644
index 0000000000000..4833a6dcf9adf
--- /dev/null
+++ b/tests/rustdoc-ui/doctest/edition-flag.stdout
@@ -0,0 +1,6 @@
+
+running 1 test
+test $DIR/edition-flag.rs - main (line 6) ... ok
+
+test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
+
diff --git a/tests/rustdoc-html/force-target-feature.rs b/tests/rustdoc-ui/doctest/force-target-feature.rs
similarity index 50%
rename from tests/rustdoc-html/force-target-feature.rs
rename to tests/rustdoc-ui/doctest/force-target-feature.rs
index fa71bbeea2747..3019eb7cb16d9 100644
--- a/tests/rustdoc-html/force-target-feature.rs
+++ b/tests/rustdoc-ui/doctest/force-target-feature.rs
@@ -1,6 +1,11 @@
 //@ only-x86_64
+//@ only-linux
 //@ compile-flags:--test -C target-feature=+avx
-//@ should-fail
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "rust_out::main::.+" -> "rust_out::main::$$PATH"
+//@ failure-status: 101
+
+#![feature(doc_cfg)]
 
 /// (written on a spider's web) Some Struct
 ///
diff --git a/tests/rustdoc-ui/doctest/force-target-feature.stdout b/tests/rustdoc-ui/doctest/force-target-feature.stdout
new file mode 100644
index 0000000000000..d6e91306efc4f
--- /dev/null
+++ b/tests/rustdoc-ui/doctest/force-target-feature.stdout
@@ -0,0 +1,27 @@
+
+running 1 test
+test $DIR/force-target-feature.rs - SomeStruct (line 12) ... FAILED
+
+failures:
+
+---- $DIR/force-target-feature.rs - SomeStruct (line 12) stdout ----
+Test executable failed (exit status: 101).
+
+stderr:
+
+thread 'main' ($TID) panicked at $DIR/force-target-feature.rs:3:1:
+oh no
+stack backtrace:
+   0: std::panicking::begin_panic::<&str>
+   1: rust_out::main::$PATH
+   2: rust_out::main
+   3: <fn() as core::ops::function::FnOnce<()>>::call_once
+note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.
+
+
+
+failures:
+    $DIR/force-target-feature.rs - SomeStruct (line 12)
+
+test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
+
diff --git a/tests/rustdoc-html/ice-type-error-19181.rs b/tests/rustdoc-ui/doctest/ice-type-error-19181.rs
similarity index 65%
rename from tests/rustdoc-html/ice-type-error-19181.rs
rename to tests/rustdoc-ui/doctest/ice-type-error-19181.rs
index 02c6404762222..accb9e2cab1f4 100644
--- a/tests/rustdoc-html/ice-type-error-19181.rs
+++ b/tests/rustdoc-ui/doctest/ice-type-error-19181.rs
@@ -1,4 +1,7 @@
 //@ compile-flags:--test
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ check-pass
+
 // https://github.com/rust-lang/rust/issues/19181
 
 // rustdoc should not panic when target crate has compilation errors
diff --git a/tests/rustdoc-ui/doctest/ice-type-error-19181.stdout b/tests/rustdoc-ui/doctest/ice-type-error-19181.stdout
new file mode 100644
index 0000000000000..7326c0a25a069
--- /dev/null
+++ b/tests/rustdoc-ui/doctest/ice-type-error-19181.stdout
@@ -0,0 +1,5 @@
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
+
diff --git a/tests/rustdoc-html/no-run-still-checks-lints.rs b/tests/rustdoc-ui/doctest/no-run-still-checks-lints.rs
similarity index 55%
rename from tests/rustdoc-html/no-run-still-checks-lints.rs
rename to tests/rustdoc-ui/doctest/no-run-still-checks-lints.rs
index 73e311b72d5e5..cae6331f4723d 100644
--- a/tests/rustdoc-html/no-run-still-checks-lints.rs
+++ b/tests/rustdoc-ui/doctest/no-run-still-checks-lints.rs
@@ -1,5 +1,6 @@
 //@ compile-flags:--test
-//@ should-fail
+//@ failure-status: 101
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 
 #![doc(test(attr(deny(warnings))))]
 
diff --git a/tests/rustdoc-ui/doctest/no-run-still-checks-lints.stdout b/tests/rustdoc-ui/doctest/no-run-still-checks-lints.stdout
new file mode 100644
index 0000000000000..86d1b4d3094b6
--- /dev/null
+++ b/tests/rustdoc-ui/doctest/no-run-still-checks-lints.stdout
@@ -0,0 +1,29 @@
+
+running 1 test
+test $DIR/no-run-still-checks-lints.rs - foo (line 7) - compile ... FAILED
+
+failures:
+
+---- $DIR/no-run-still-checks-lints.rs - foo (line 7) stdout ----
+error: unused variable: `a`
+  --> $DIR/no-run-still-checks-lints.rs:8:5
+   |
+LL | let a = 3;
+   |     ^ help: if this is intentional, prefix it with an underscore: `_a`
+   |
+note: the lint level is defined here
+  --> $DIR/no-run-still-checks-lints.rs:6:9
+   |
+LL | #![deny(warnings)]
+   |         ^^^^^^^^
+   = note: `#[deny(unused_variables)]` implied by `#[deny(warnings)]`
+
+error: aborting due to 1 previous error
+
+Couldn't compile the test.
+
+failures:
+    $DIR/no-run-still-checks-lints.rs - foo (line 7)
+
+test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
+
diff --git a/tests/rustdoc-html/process-termination.rs b/tests/rustdoc-ui/doctest/process-termination.rs
similarity index 80%
rename from tests/rustdoc-html/process-termination.rs
rename to tests/rustdoc-ui/doctest/process-termination.rs
index 73a86e57424a2..02ac594b3f0d4 100644
--- a/tests/rustdoc-html/process-termination.rs
+++ b/tests/rustdoc-ui/doctest/process-termination.rs
@@ -1,4 +1,6 @@
-//@ compile-flags:--test
+//@ compile-flags:--test --test-args=--test-threads=1
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ check-pass
 
 /// A check of using various process termination strategies
 ///
diff --git a/tests/rustdoc-ui/doctest/process-termination.stdout b/tests/rustdoc-ui/doctest/process-termination.stdout
new file mode 100644
index 0000000000000..3e15b9a5df80a
--- /dev/null
+++ b/tests/rustdoc-ui/doctest/process-termination.stdout
@@ -0,0 +1,8 @@
+
+running 3 tests
+test $DIR/process-termination.rs - check_process_termination (line 16) ... ok
+test $DIR/process-termination.rs - check_process_termination (line 22) ... ok
+test $DIR/process-termination.rs - check_process_termination (line 9) ... ok
+
+test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
+
diff --git a/tests/rustdoc-html/sanitizer-option.rs b/tests/rustdoc-ui/doctest/sanitizer-option.rs
similarity index 86%
rename from tests/rustdoc-html/sanitizer-option.rs
rename to tests/rustdoc-ui/doctest/sanitizer-option.rs
index 7b0038138f09f..5f29f1b8bac7e 100644
--- a/tests/rustdoc-html/sanitizer-option.rs
+++ b/tests/rustdoc-ui/doctest/sanitizer-option.rs
@@ -1,7 +1,9 @@
 //@ needs-sanitizer-support
 //@ needs-sanitizer-address
 //@ compile-flags: --test -Z sanitizer=address -C unsafe-allow-abi-mismatch=sanitizer
-//
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ check-pass
+
 // #43031: Verify that rustdoc passes `-Z` options to rustc. Use an extern
 // function that is provided by the sanitizer runtime, if flag is not passed
 // correctly, then linking will fail.
diff --git a/tests/rustdoc-ui/doctest/sanitizer-option.stdout b/tests/rustdoc-ui/doctest/sanitizer-option.stdout
new file mode 100644
index 0000000000000..62040048335f2
--- /dev/null
+++ b/tests/rustdoc-ui/doctest/sanitizer-option.stdout
@@ -0,0 +1,6 @@
+
+running 1 test
+test $DIR/sanitizer-option.rs - z_flag_is_passed_to_rustc (line 11) ... ok
+
+test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
+
diff --git a/tests/rustdoc-html/test_option_check/test.rs b/tests/rustdoc-ui/doctest/test-option-check-2.rs
similarity index 54%
rename from tests/rustdoc-html/test_option_check/test.rs
rename to tests/rustdoc-ui/doctest/test-option-check-2.rs
index af7a5827690f0..2e74da1eca794 100644
--- a/tests/rustdoc-html/test_option_check/test.rs
+++ b/tests/rustdoc-ui/doctest/test-option-check-2.rs
@@ -1,6 +1,9 @@
-//@ compile-flags: --test
+//@ compile-flags: --test --test-args=--test-threads=1
 //@ check-test-line-numbers-match
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ check-pass
 
+#[path = "test-option-check.rs"]
 pub mod bar;
 
 /// This is a Foo;
diff --git a/tests/rustdoc-ui/doctest/test-option-check-2.stdout b/tests/rustdoc-ui/doctest/test-option-check-2.stdout
new file mode 100644
index 0000000000000..ab2db4938dfab
--- /dev/null
+++ b/tests/rustdoc-ui/doctest/test-option-check-2.stdout
@@ -0,0 +1,8 @@
+
+running 3 tests
+test $DIR/test-option-check-2.rs - Bar (line 18) ... ok
+test $DIR/test-option-check-2.rs - Foo (line 11) ... ok
+test $DIR/test-option-check.rs - bar::foooo (line 8) ... ok
+
+test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
+
diff --git a/tests/rustdoc-html/test_option_check/bar.rs b/tests/rustdoc-ui/doctest/test-option-check.rs
similarity index 65%
rename from tests/rustdoc-html/test_option_check/bar.rs
rename to tests/rustdoc-ui/doctest/test-option-check.rs
index 7c2309a79d4b9..e5d3350e3f981 100644
--- a/tests/rustdoc-html/test_option_check/bar.rs
+++ b/tests/rustdoc-ui/doctest/test-option-check.rs
@@ -1,5 +1,7 @@
 //@ compile-flags: --test
 //@ check-test-line-numbers-match
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ check-pass
 
 /// This looks like another awesome test!
 ///
diff --git a/tests/rustdoc-ui/doctest/test-option-check.stdout b/tests/rustdoc-ui/doctest/test-option-check.stdout
new file mode 100644
index 0000000000000..38f949612a47a
--- /dev/null
+++ b/tests/rustdoc-ui/doctest/test-option-check.stdout
@@ -0,0 +1,6 @@
+
+running 1 test
+test $DIR/test-option-check.rs - foooo (line 8) ... ok
+
+test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
+
diff --git a/tests/rustdoc-ui/lints/renamed-lint-still-applies.rs b/tests/rustdoc-ui/lints/renamed-lint-still-applies.rs
index a4d3a4b497117..30eb2b819d057 100644
--- a/tests/rustdoc-ui/lints/renamed-lint-still-applies.rs
+++ b/tests/rustdoc-ui/lints/renamed-lint-still-applies.rs
@@ -1,4 +1,3 @@
-// compile-args: --crate-type lib
 #![deny(broken_intra_doc_links)]
 //~^ WARNING renamed to `rustdoc::broken_intra_doc_links`
 //! [x]
diff --git a/tests/rustdoc-ui/lints/renamed-lint-still-applies.stderr b/tests/rustdoc-ui/lints/renamed-lint-still-applies.stderr
index 88807dfb495d0..9365dab4bae6c 100644
--- a/tests/rustdoc-ui/lints/renamed-lint-still-applies.stderr
+++ b/tests/rustdoc-ui/lints/renamed-lint-still-applies.stderr
@@ -1,5 +1,5 @@
 warning: lint `broken_intra_doc_links` has been renamed to `rustdoc::broken_intra_doc_links`
-  --> $DIR/renamed-lint-still-applies.rs:2:9
+  --> $DIR/renamed-lint-still-applies.rs:1:9
    |
 LL | #![deny(broken_intra_doc_links)]
    |         ^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `rustdoc::broken_intra_doc_links`
@@ -7,33 +7,33 @@ LL | #![deny(broken_intra_doc_links)]
    = note: `#[warn(renamed_and_removed_lints)]` on by default
 
 warning: lint `rustdoc::non_autolinks` has been renamed to `rustdoc::bare_urls`
-  --> $DIR/renamed-lint-still-applies.rs:7:9
+  --> $DIR/renamed-lint-still-applies.rs:6:9
    |
 LL | #![deny(rustdoc::non_autolinks)]
    |         ^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `rustdoc::bare_urls`
 
 error: unresolved link to `x`
-  --> $DIR/renamed-lint-still-applies.rs:4:6
+  --> $DIR/renamed-lint-still-applies.rs:3:6
    |
 LL | //! [x]
    |      ^ no item named `x` in scope
    |
    = help: to escape `[` and `]` characters, add '\' before them like `\[` or `\]`
 note: the lint level is defined here
-  --> $DIR/renamed-lint-still-applies.rs:2:9
+  --> $DIR/renamed-lint-still-applies.rs:1:9
    |
 LL | #![deny(broken_intra_doc_links)]
    |         ^^^^^^^^^^^^^^^^^^^^^^
 
 error: this URL is not a hyperlink
-  --> $DIR/renamed-lint-still-applies.rs:9:5
+  --> $DIR/renamed-lint-still-applies.rs:8:5
    |
 LL | //! http://example.com
    |     ^^^^^^^^^^^^^^^^^^
    |
    = note: bare URLs are not automatically turned into clickable links
 note: the lint level is defined here
-  --> $DIR/renamed-lint-still-applies.rs:7:9
+  --> $DIR/renamed-lint-still-applies.rs:6:9
    |
 LL | #![deny(rustdoc::non_autolinks)]
    |         ^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/async-await/track-caller/async-block.afn.stderr b/tests/ui/async-await/track-caller/async-block.afn.stderr
index b6a7481a4d119..89ebe2df60609 100644
--- a/tests/ui/async-await/track-caller/async-block.afn.stderr
+++ b/tests/ui/async-await/track-caller/async-block.afn.stderr
@@ -1,7 +1,7 @@
 error[E0658]: `#[track_caller]` on closures is currently unstable
-  --> $DIR/async-block.rs:8:13
+  --> $DIR/async-block.rs:11:13
    |
-LL |     let _ = #[track_caller] async {
+LL |     let _ = #[track_caller]
    |             ^^^^^^^^^^^^^^^
    |
    = note: see issue #87417 <https://github.com/rust-lang/rust/issues/87417> for more information
@@ -9,9 +9,9 @@ LL |     let _ = #[track_caller] async {
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: `#[track_caller]` on closures is currently unstable
-  --> $DIR/async-block.rs:15:13
+  --> $DIR/async-block.rs:19:13
    |
-LL |     let _ = #[track_caller] async {
+LL |     let _ = #[track_caller]
    |             ^^^^^^^^^^^^^^^
    |
    = note: see issue #87417 <https://github.com/rust-lang/rust/issues/87417> for more information
@@ -19,9 +19,9 @@ LL |     let _ = #[track_caller] async {
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: `#[track_caller]` on closures is currently unstable
-  --> $DIR/async-block.rs:23:17
+  --> $DIR/async-block.rs:28:17
    |
-LL |         let _ = #[track_caller] async {
+LL |         let _ = #[track_caller]
    |                 ^^^^^^^^^^^^^^^
    |
    = note: see issue #87417 <https://github.com/rust-lang/rust/issues/87417> for more information
diff --git a/tests/ui/async-await/track-caller/async-block.cls.stderr b/tests/ui/async-await/track-caller/async-block.cls.stderr
new file mode 100644
index 0000000000000..0e9dbc4afa05f
--- /dev/null
+++ b/tests/ui/async-await/track-caller/async-block.cls.stderr
@@ -0,0 +1,42 @@
+error: `#[track_caller]` on async functions is a no-op
+  --> $DIR/async-block.rs:16:1
+   |
+LL |   #[track_caller]
+   |   ^^^^^^^^^^^^^^^
+LL |
+LL | / async fn foo() {
+LL | |     let _ = #[track_caller]
+LL | |
+LL | |     async {};
+LL | | }
+   | |_- this function will not propagate the caller location
+   |
+   = note: see issue #110011 <https://github.com/rust-lang/rust/issues/110011> for more information
+   = help: add `#![feature(async_fn_track_caller)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+note: the lint level is defined here
+  --> $DIR/async-block.rs:6:9
+   |
+LL | #![deny(ungated_async_fn_track_caller)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: `#[track_caller]` on async functions is a no-op
+  --> $DIR/async-block.rs:24:1
+   |
+LL |   #[track_caller]
+   |   ^^^^^^^^^^^^^^^
+LL |
+LL | / async fn foo2() {
+LL | |     let _ = async {
+LL | |         let _ = #[track_caller]
+...  |
+LL | |     };
+LL | | }
+   | |_- this function will not propagate the caller location
+   |
+   = note: see issue #110011 <https://github.com/rust-lang/rust/issues/110011> for more information
+   = help: add `#![feature(async_fn_track_caller)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/async-await/track-caller/async-block.nofeat.stderr b/tests/ui/async-await/track-caller/async-block.nofeat.stderr
index b6a7481a4d119..89ebe2df60609 100644
--- a/tests/ui/async-await/track-caller/async-block.nofeat.stderr
+++ b/tests/ui/async-await/track-caller/async-block.nofeat.stderr
@@ -1,7 +1,7 @@
 error[E0658]: `#[track_caller]` on closures is currently unstable
-  --> $DIR/async-block.rs:8:13
+  --> $DIR/async-block.rs:11:13
    |
-LL |     let _ = #[track_caller] async {
+LL |     let _ = #[track_caller]
    |             ^^^^^^^^^^^^^^^
    |
    = note: see issue #87417 <https://github.com/rust-lang/rust/issues/87417> for more information
@@ -9,9 +9,9 @@ LL |     let _ = #[track_caller] async {
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: `#[track_caller]` on closures is currently unstable
-  --> $DIR/async-block.rs:15:13
+  --> $DIR/async-block.rs:19:13
    |
-LL |     let _ = #[track_caller] async {
+LL |     let _ = #[track_caller]
    |             ^^^^^^^^^^^^^^^
    |
    = note: see issue #87417 <https://github.com/rust-lang/rust/issues/87417> for more information
@@ -19,9 +19,9 @@ LL |     let _ = #[track_caller] async {
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: `#[track_caller]` on closures is currently unstable
-  --> $DIR/async-block.rs:23:17
+  --> $DIR/async-block.rs:28:17
    |
-LL |         let _ = #[track_caller] async {
+LL |         let _ = #[track_caller]
    |                 ^^^^^^^^^^^^^^^
    |
    = note: see issue #87417 <https://github.com/rust-lang/rust/issues/87417> for more information
diff --git a/tests/ui/async-await/track-caller/async-block.rs b/tests/ui/async-await/track-caller/async-block.rs
index 900d5ef25504d..f56921c017d12 100644
--- a/tests/ui/async-await/track-caller/async-block.rs
+++ b/tests/ui/async-await/track-caller/async-block.rs
@@ -1,27 +1,32 @@
 //@ edition:2021
-//@ revisions: afn nofeat
+//@ revisions: afn cls afn_cls nofeat
+//@[afn_cls] check-pass
 
 #![feature(stmt_expr_attributes)]
-#![cfg_attr(afn, feature(async_fn_track_caller))]
+#![deny(ungated_async_fn_track_caller)]
+#![cfg_attr(any(afn, afn_cls), feature(async_fn_track_caller))]
+#![cfg_attr(any(cls, afn_cls), feature(closure_track_caller))]
 
 fn main() {
-    let _ = #[track_caller] async {
-        //~^ ERROR `#[track_caller]` on closures is currently unstable [E0658]
-    };
+    let _ = #[track_caller]
+    //[nofeat,afn]~^ ERROR `#[track_caller]` on closures is currently unstable [E0658]
+    async {};
 }
 
 #[track_caller]
+//[cls]~^ ERROR `#[track_caller]` on async functions is a no-op
 async fn foo() {
-    let _ = #[track_caller] async {
-        //~^ ERROR `#[track_caller]` on closures is currently unstable [E0658]
-    };
+    let _ = #[track_caller]
+    //[nofeat,afn]~^ ERROR `#[track_caller]` on closures is currently unstable [E0658]
+    async {};
 }
 
 #[track_caller]
+//[cls]~^ ERROR `#[track_caller]` on async functions is a no-op
 async fn foo2() {
     let _ = async {
-        let _ = #[track_caller] async {
-            //~^ ERROR `#[track_caller]` on closures is currently unstable [E0658]
-        };
+        let _ = #[track_caller]
+        //[nofeat,afn]~^ ERROR `#[track_caller]` on closures is currently unstable [E0658]
+        async {};
     };
 }
diff --git a/tests/ui/async-await/track-caller/async-closure-gate.afn.stderr b/tests/ui/async-await/track-caller/async-closure-gate.afn.stderr
index 6887a904211ec..fb774290bde4e 100644
--- a/tests/ui/async-await/track-caller/async-closure-gate.afn.stderr
+++ b/tests/ui/async-await/track-caller/async-closure-gate.afn.stderr
@@ -1,7 +1,7 @@
 error[E0658]: `#[track_caller]` on closures is currently unstable
-  --> $DIR/async-closure-gate.rs:8:13
+  --> $DIR/async-closure-gate.rs:11:13
    |
-LL |     let _ = #[track_caller] async || {
+LL |     let _ = #[track_caller]
    |             ^^^^^^^^^^^^^^^
    |
    = note: see issue #87417 <https://github.com/rust-lang/rust/issues/87417> for more information
@@ -9,9 +9,9 @@ LL |     let _ = #[track_caller] async || {
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: `#[track_caller]` on closures is currently unstable
-  --> $DIR/async-closure-gate.rs:15:13
+  --> $DIR/async-closure-gate.rs:19:13
    |
-LL |     let _ = #[track_caller] async || {
+LL |     let _ = #[track_caller]
    |             ^^^^^^^^^^^^^^^
    |
    = note: see issue #87417 <https://github.com/rust-lang/rust/issues/87417> for more information
@@ -19,9 +19,9 @@ LL |     let _ = #[track_caller] async || {
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: `#[track_caller]` on closures is currently unstable
-  --> $DIR/async-closure-gate.rs:21:13
+  --> $DIR/async-closure-gate.rs:25:13
    |
-LL |     let _ = #[track_caller] || {
+LL |     let _ = #[track_caller]
    |             ^^^^^^^^^^^^^^^
    |
    = note: see issue #87417 <https://github.com/rust-lang/rust/issues/87417> for more information
@@ -29,9 +29,9 @@ LL |     let _ = #[track_caller] || {
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: `#[track_caller]` on closures is currently unstable
-  --> $DIR/async-closure-gate.rs:29:17
+  --> $DIR/async-closure-gate.rs:32:17
    |
-LL |         let _ = #[track_caller] || {
+LL |         let _ = #[track_caller]
    |                 ^^^^^^^^^^^^^^^
    |
    = note: see issue #87417 <https://github.com/rust-lang/rust/issues/87417> for more information
@@ -39,9 +39,9 @@ LL |         let _ = #[track_caller] || {
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: `#[track_caller]` on closures is currently unstable
-  --> $DIR/async-closure-gate.rs:37:9
+  --> $DIR/async-closure-gate.rs:40:9
    |
-LL |         #[track_caller] || {
+LL |         #[track_caller]
    |         ^^^^^^^^^^^^^^^
    |
    = note: see issue #87417 <https://github.com/rust-lang/rust/issues/87417> for more information
@@ -49,48 +49,15 @@ LL |         #[track_caller] || {
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: `#[track_caller]` on closures is currently unstable
-  --> $DIR/async-closure-gate.rs:47:13
+  --> $DIR/async-closure-gate.rs:49:13
    |
-LL |             #[track_caller] || {
+LL |             #[track_caller]
    |             ^^^^^^^^^^^^^^^
    |
    = note: see issue #87417 <https://github.com/rust-lang/rust/issues/87417> for more information
    = help: add `#![feature(closure_track_caller)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0308]: mismatched types
-  --> $DIR/async-closure-gate.rs:27:5
-   |
-LL |   fn foo3() {
-   |            - help: try adding a return type: `-> impl Future<Output = ()>`
-LL | /     async {
-LL | |
-LL | |         let _ = #[track_caller] || {
-...  |
-LL | |     }
-   | |_____^ expected `()`, found `async` block
-   |
-   = note:  expected unit type `()`
-           found `async` block `{async block@$DIR/async-closure-gate.rs:27:5: 27:10}`
-
-error[E0308]: mismatched types
-  --> $DIR/async-closure-gate.rs:44:5
-   |
-LL |   fn foo5() {
-   |            - help: try adding a return type: `-> impl Future<Output = ()>`
-LL | /     async {
-LL | |
-LL | |         let _ = || {
-LL | |             #[track_caller] || {
-...  |
-LL | |         };
-LL | |     }
-   | |_____^ expected `()`, found `async` block
-   |
-   = note:  expected unit type `()`
-           found `async` block `{async block@$DIR/async-closure-gate.rs:44:5: 44:10}`
-
-error: aborting due to 8 previous errors
+error: aborting due to 6 previous errors
 
-Some errors have detailed explanations: E0308, E0658.
-For more information about an error, try `rustc --explain E0308`.
+For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/async-await/track-caller/async-closure-gate.cls.stderr b/tests/ui/async-await/track-caller/async-closure-gate.cls.stderr
new file mode 100644
index 0000000000000..5fe7a2fb7d36a
--- /dev/null
+++ b/tests/ui/async-await/track-caller/async-closure-gate.cls.stderr
@@ -0,0 +1,24 @@
+error: `#[track_caller]` on async functions is a no-op
+  --> $DIR/async-closure-gate.rs:16:1
+   |
+LL |   #[track_caller]
+   |   ^^^^^^^^^^^^^^^
+LL |
+LL | / async fn foo() {
+LL | |     let _ = #[track_caller]
+LL | |
+LL | |     async || {};
+LL | | }
+   | |_- this function will not propagate the caller location
+   |
+   = note: see issue #110011 <https://github.com/rust-lang/rust/issues/110011> for more information
+   = help: add `#![feature(async_fn_track_caller)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+note: the lint level is defined here
+  --> $DIR/async-closure-gate.rs:6:9
+   |
+LL | #![deny(ungated_async_fn_track_caller)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/async-await/track-caller/async-closure-gate.nofeat.stderr b/tests/ui/async-await/track-caller/async-closure-gate.nofeat.stderr
index 6887a904211ec..fb774290bde4e 100644
--- a/tests/ui/async-await/track-caller/async-closure-gate.nofeat.stderr
+++ b/tests/ui/async-await/track-caller/async-closure-gate.nofeat.stderr
@@ -1,7 +1,7 @@
 error[E0658]: `#[track_caller]` on closures is currently unstable
-  --> $DIR/async-closure-gate.rs:8:13
+  --> $DIR/async-closure-gate.rs:11:13
    |
-LL |     let _ = #[track_caller] async || {
+LL |     let _ = #[track_caller]
    |             ^^^^^^^^^^^^^^^
    |
    = note: see issue #87417 <https://github.com/rust-lang/rust/issues/87417> for more information
@@ -9,9 +9,9 @@ LL |     let _ = #[track_caller] async || {
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: `#[track_caller]` on closures is currently unstable
-  --> $DIR/async-closure-gate.rs:15:13
+  --> $DIR/async-closure-gate.rs:19:13
    |
-LL |     let _ = #[track_caller] async || {
+LL |     let _ = #[track_caller]
    |             ^^^^^^^^^^^^^^^
    |
    = note: see issue #87417 <https://github.com/rust-lang/rust/issues/87417> for more information
@@ -19,9 +19,9 @@ LL |     let _ = #[track_caller] async || {
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: `#[track_caller]` on closures is currently unstable
-  --> $DIR/async-closure-gate.rs:21:13
+  --> $DIR/async-closure-gate.rs:25:13
    |
-LL |     let _ = #[track_caller] || {
+LL |     let _ = #[track_caller]
    |             ^^^^^^^^^^^^^^^
    |
    = note: see issue #87417 <https://github.com/rust-lang/rust/issues/87417> for more information
@@ -29,9 +29,9 @@ LL |     let _ = #[track_caller] || {
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: `#[track_caller]` on closures is currently unstable
-  --> $DIR/async-closure-gate.rs:29:17
+  --> $DIR/async-closure-gate.rs:32:17
    |
-LL |         let _ = #[track_caller] || {
+LL |         let _ = #[track_caller]
    |                 ^^^^^^^^^^^^^^^
    |
    = note: see issue #87417 <https://github.com/rust-lang/rust/issues/87417> for more information
@@ -39,9 +39,9 @@ LL |         let _ = #[track_caller] || {
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: `#[track_caller]` on closures is currently unstable
-  --> $DIR/async-closure-gate.rs:37:9
+  --> $DIR/async-closure-gate.rs:40:9
    |
-LL |         #[track_caller] || {
+LL |         #[track_caller]
    |         ^^^^^^^^^^^^^^^
    |
    = note: see issue #87417 <https://github.com/rust-lang/rust/issues/87417> for more information
@@ -49,48 +49,15 @@ LL |         #[track_caller] || {
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: `#[track_caller]` on closures is currently unstable
-  --> $DIR/async-closure-gate.rs:47:13
+  --> $DIR/async-closure-gate.rs:49:13
    |
-LL |             #[track_caller] || {
+LL |             #[track_caller]
    |             ^^^^^^^^^^^^^^^
    |
    = note: see issue #87417 <https://github.com/rust-lang/rust/issues/87417> for more information
    = help: add `#![feature(closure_track_caller)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0308]: mismatched types
-  --> $DIR/async-closure-gate.rs:27:5
-   |
-LL |   fn foo3() {
-   |            - help: try adding a return type: `-> impl Future<Output = ()>`
-LL | /     async {
-LL | |
-LL | |         let _ = #[track_caller] || {
-...  |
-LL | |     }
-   | |_____^ expected `()`, found `async` block
-   |
-   = note:  expected unit type `()`
-           found `async` block `{async block@$DIR/async-closure-gate.rs:27:5: 27:10}`
-
-error[E0308]: mismatched types
-  --> $DIR/async-closure-gate.rs:44:5
-   |
-LL |   fn foo5() {
-   |            - help: try adding a return type: `-> impl Future<Output = ()>`
-LL | /     async {
-LL | |
-LL | |         let _ = || {
-LL | |             #[track_caller] || {
-...  |
-LL | |         };
-LL | |     }
-   | |_____^ expected `()`, found `async` block
-   |
-   = note:  expected unit type `()`
-           found `async` block `{async block@$DIR/async-closure-gate.rs:44:5: 44:10}`
-
-error: aborting due to 8 previous errors
+error: aborting due to 6 previous errors
 
-Some errors have detailed explanations: E0308, E0658.
-For more information about an error, try `rustc --explain E0308`.
+For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/async-await/track-caller/async-closure-gate.rs b/tests/ui/async-await/track-caller/async-closure-gate.rs
index e72ce2afa45fd..13d3a5787ca9d 100644
--- a/tests/ui/async-await/track-caller/async-closure-gate.rs
+++ b/tests/ui/async-await/track-caller/async-closure-gate.rs
@@ -1,52 +1,54 @@
 //@ edition:2021
-//@ revisions: afn nofeat
+//@ revisions: afn cls afn_cls nofeat
+//@[afn_cls] check-pass
 
 #![feature(stmt_expr_attributes)]
-#![cfg_attr(afn, feature(async_fn_track_caller))]
+#![deny(ungated_async_fn_track_caller)]
+#![cfg_attr(any(afn, afn_cls), feature(async_fn_track_caller))]
+#![cfg_attr(any(cls, afn_cls), feature(closure_track_caller))]
 
 fn main() {
-    let _ = #[track_caller] async || {
-        //~^ ERROR `#[track_caller]` on closures is currently unstable [E0658]
-    };
+    let _ = #[track_caller]
+    //[nofeat,afn]~^ ERROR `#[track_caller]` on closures is currently unstable [E0658]
+    async || {};
 }
 
 #[track_caller]
+//[cls]~^ ERROR `#[track_caller]` on async functions is a no-op
 async fn foo() {
-    let _ = #[track_caller] async || {
-        //~^ ERROR `#[track_caller]` on closures is currently unstable [E0658]
-    };
+    let _ = #[track_caller]
+    //[nofeat,afn]~^ ERROR `#[track_caller]` on closures is currently unstable [E0658]
+    async || {};
 }
 
 async fn foo2() {
-    let _ = #[track_caller] || {
-        //~^ ERROR `#[track_caller]` on closures is currently unstable [E0658]
-    };
+    let _ = #[track_caller]
+    //[nofeat,afn]~^ ERROR `#[track_caller]` on closures is currently unstable [E0658]
+    || {};
 }
 
 fn foo3() {
-    async {
-        //~^ ERROR mismatched types
-        let _ = #[track_caller] || {
-            //~^ ERROR `#[track_caller]` on closures is currently unstable [E0658]
-        };
-    }
+    let _ = async {
+        let _ = #[track_caller]
+        //[nofeat,afn]~^ ERROR `#[track_caller]` on closures is currently unstable [E0658]
+        || {};
+    };
 }
 
 async fn foo4() {
     let _ = || {
-        #[track_caller] || {
-            //~^ ERROR `#[track_caller]` on closures is currently unstable [E0658]
-        };
+        #[track_caller]
+        //[nofeat,afn]~^ ERROR `#[track_caller]` on closures is currently unstable [E0658]
+        || {};
     };
 }
 
 fn foo5() {
-    async {
-        //~^ ERROR mismatched types
+    let _ = async {
         let _ = || {
-            #[track_caller] || {
-                //~^ ERROR `#[track_caller]` on closures is currently unstable [E0658]
-            };
+            #[track_caller]
+            //[nofeat,afn]~^ ERROR `#[track_caller]` on closures is currently unstable [E0658]
+            || {};
         };
-    }
+    };
 }
diff --git a/tests/ui/async-await/track-caller/panic-track-caller.cls.stderr b/tests/ui/async-await/track-caller/panic-track-caller.cls.stderr
index 464cbfba2acfe..5611e53f50a40 100644
--- a/tests/ui/async-await/track-caller/panic-track-caller.cls.stderr
+++ b/tests/ui/async-await/track-caller/panic-track-caller.cls.stderr
@@ -1,9 +1,9 @@
 warning: `#[track_caller]` on async functions is a no-op
-  --> $DIR/panic-track-caller.rs:53:1
+  --> $DIR/panic-track-caller.rs:59:1
    |
 LL |   #[track_caller]
    |   ^^^^^^^^^^^^^^^
-...
+LL |
 LL | / async fn bar_track_caller() {
 LL | |     panic!()
 LL | | }
@@ -15,11 +15,11 @@ LL | | }
    = note: `#[warn(ungated_async_fn_track_caller)]` on by default
 
 warning: `#[track_caller]` on async functions is a no-op
-  --> $DIR/panic-track-caller.rs:67:5
+  --> $DIR/panic-track-caller.rs:73:5
    |
 LL |       #[track_caller]
    |       ^^^^^^^^^^^^^^^
-...
+LL |
 LL | /     async fn bar_assoc() {
 LL | |         panic!();
 LL | |     }
@@ -29,5 +29,20 @@ LL | |     }
    = help: add `#![feature(async_fn_track_caller)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-warning: 2 warnings emitted
+warning: `#[track_caller]` on async functions is a no-op
+  --> $DIR/panic-track-caller.rs:108:1
+   |
+LL |   #[track_caller]
+   |   ^^^^^^^^^^^^^^^
+LL |
+LL | / async fn bar_manual_poll() {
+LL | |     panic!();
+LL | | }
+   | |_- this function will not propagate the caller location
+   |
+   = note: see issue #110011 <https://github.com/rust-lang/rust/issues/110011> for more information
+   = help: add `#![feature(async_fn_track_caller)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+warning: 3 warnings emitted
 
diff --git a/tests/ui/async-await/track-caller/panic-track-caller.nofeat.stderr b/tests/ui/async-await/track-caller/panic-track-caller.nofeat.stderr
index 464cbfba2acfe..5611e53f50a40 100644
--- a/tests/ui/async-await/track-caller/panic-track-caller.nofeat.stderr
+++ b/tests/ui/async-await/track-caller/panic-track-caller.nofeat.stderr
@@ -1,9 +1,9 @@
 warning: `#[track_caller]` on async functions is a no-op
-  --> $DIR/panic-track-caller.rs:53:1
+  --> $DIR/panic-track-caller.rs:59:1
    |
 LL |   #[track_caller]
    |   ^^^^^^^^^^^^^^^
-...
+LL |
 LL | / async fn bar_track_caller() {
 LL | |     panic!()
 LL | | }
@@ -15,11 +15,11 @@ LL | | }
    = note: `#[warn(ungated_async_fn_track_caller)]` on by default
 
 warning: `#[track_caller]` on async functions is a no-op
-  --> $DIR/panic-track-caller.rs:67:5
+  --> $DIR/panic-track-caller.rs:73:5
    |
 LL |       #[track_caller]
    |       ^^^^^^^^^^^^^^^
-...
+LL |
 LL | /     async fn bar_assoc() {
 LL | |         panic!();
 LL | |     }
@@ -29,5 +29,20 @@ LL | |     }
    = help: add `#![feature(async_fn_track_caller)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-warning: 2 warnings emitted
+warning: `#[track_caller]` on async functions is a no-op
+  --> $DIR/panic-track-caller.rs:108:1
+   |
+LL |   #[track_caller]
+   |   ^^^^^^^^^^^^^^^
+LL |
+LL | / async fn bar_manual_poll() {
+LL | |     panic!();
+LL | | }
+   | |_- this function will not propagate the caller location
+   |
+   = note: see issue #110011 <https://github.com/rust-lang/rust/issues/110011> for more information
+   = help: add `#![feature(async_fn_track_caller)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+warning: 3 warnings emitted
 
diff --git a/tests/ui/async-await/track-caller/panic-track-caller.rs b/tests/ui/async-await/track-caller/panic-track-caller.rs
index bd12bf11d6c84..294150500170d 100644
--- a/tests/ui/async-await/track-caller/panic-track-caller.rs
+++ b/tests/ui/async-await/track-caller/panic-track-caller.rs
@@ -1,11 +1,16 @@
+// This test is duplicated (with changes) at
+// src/tools/miri/tests/pass/async-panic-track-caller.rs
+
+// FIXME: catch_unwind is broken in gcc. Will be fixed in the next rustc_codegen_gcc sync.
+//@ ignore-backends: gcc
 //@ run-pass
 //@ edition:2021
-//@ revisions: afn cls nofeat
+//@ revisions: afn cls afn_cls nofeat
 //@ needs-unwind
 // gate-test-async_fn_track_caller
 #![feature(stmt_expr_attributes)]
-#![cfg_attr(afn, feature(async_fn_track_caller))]
-#![cfg_attr(cls, feature(closure_track_caller))]
+#![cfg_attr(any(afn, afn_cls), feature(async_fn_track_caller))]
+#![cfg_attr(any(cls, afn_cls), feature(closure_track_caller))]
 #![allow(unused)]
 
 use std::future::Future;
@@ -47,53 +52,71 @@ async fn bar() {
 }
 
 async fn foo() {
-    bar().await
+    let future = bar();
+    future.await;
 }
 
 #[track_caller]
-//[cls]~^ WARN `#[track_caller]` on async functions is a no-op
-//[nofeat]~^^ WARN `#[track_caller]` on async functions is a no-op
+//[cls,nofeat]~^ WARN `#[track_caller]` on async functions is a no-op
 async fn bar_track_caller() {
     panic!()
 }
 
 async fn foo_track_caller() {
-    bar_track_caller().await
+    let future = bar_track_caller();
+    future.await;
 }
 
 struct Foo;
 
 impl Foo {
     #[track_caller]
-    //[cls]~^ WARN `#[track_caller]` on async functions is a no-op
-    //[nofeat]~^^ WARN `#[track_caller]` on async functions is a no-op
+    //[cls,nofeat]~^ WARN `#[track_caller]` on async functions is a no-op
     async fn bar_assoc() {
         panic!();
     }
 }
 
 async fn foo_assoc() {
-    Foo::bar_assoc().await
+    let future = Foo::bar_assoc();
+    future.await;
 }
 
-// Since compilation is expected to fail for this fn when using
-// `nofeat`, we test that separately in `async-closure-gate.rs`
-#[cfg(cls)]
+// Since compilation is expected to fail for this fn when `closure_track_caller`
+// is disabled, we test that separately in `async-closure-gate.rs`
+#[cfg(any(cls, afn_cls))]
 async fn foo_closure() {
-    let c = #[track_caller] async || {
+    let closure = #[track_caller]
+    async || {
         panic!();
     };
-    c().await
+    let future = closure();
+    future.await;
 }
 
-// Since compilation is expected to fail for this fn when using
-// `nofeat`, we test that separately in `async-block.rs`
-#[cfg(cls)]
+// Since compilation is expected to fail for this fn when `closure_track_caller`
+// is disabled, we test that separately in `async-closure-gate.rs`
+#[cfg(any(cls, afn_cls))]
 async fn foo_block() {
-    let a = #[track_caller] async {
+    let future = #[track_caller]
+    async {
         panic!();
     };
-    a.await
+    future.await;
+}
+
+#[track_caller]
+//[cls,nofeat]~^ WARN `#[track_caller]` on async functions is a no-op
+async fn bar_manual_poll() {
+    panic!();
+}
+
+fn foo_manual_poll() {
+    let future = bar_manual_poll();
+    let future = std::pin::pin!(future);
+    let mut cx = std::task::Context::from_waker(std::task::Waker::noop());
+    let res = future.poll(&mut cx);
+    assert_eq!(res, std::task::Poll::Ready(()));
 }
 
 fn panicked_at(f: impl FnOnce() + panic::UnwindSafe) -> u32 {
@@ -112,23 +135,36 @@ fn panicked_at(f: impl FnOnce() + panic::UnwindSafe) -> u32 {
     x
 }
 
+// FIXME(async_fn_track_caller): Currently, #[track_caller] on an async function
+// uses the location where the future is awaited or polled.
+// The correct behavior as per T-lang is to use the location where the function is called.
 fn main() {
-    assert_eq!(panicked_at(|| block_on(foo())), 46
-);
+    assert_eq!(panicked_at(|| block_on(foo())), 51);
 
-    #[cfg(afn)]
-    assert_eq!(panicked_at(|| block_on(foo_track_caller())), 61);
+    #[cfg(any(afn, afn_cls))]
+    assert_eq!(panicked_at(|| block_on(foo_track_caller())), 67);
     #[cfg(any(cls, nofeat))]
-    assert_eq!(panicked_at(|| block_on(foo_track_caller())), 57);
+    assert_eq!(panicked_at(|| block_on(foo_track_caller())), 62);
 
-    #[cfg(afn)]
-    assert_eq!(panicked_at(|| block_on(foo_assoc())), 76);
+    #[cfg(any(afn, afn_cls))]
+    assert_eq!(panicked_at(|| block_on(foo_assoc())), 82);
     #[cfg(any(cls, nofeat))]
-    assert_eq!(panicked_at(|| block_on(foo_assoc())), 71);
+    assert_eq!(panicked_at(|| block_on(foo_assoc())), 76);
 
+    // FIXME(closure_track_caller): if closure_track_caller is enabled, but
+    // async_fn_track_caller is disabled, then #[track_caller] on async closures
+    // silently do nothing. Either it should function, or we should emit a warning.
+    // See #161961
     #[cfg(cls)]
-    assert_eq!(panicked_at(|| block_on(foo_closure())), 84);
+    assert_eq!(panicked_at(|| block_on(foo_closure())), 91);
+    #[cfg(afn_cls)]
+    assert_eq!(panicked_at(|| block_on(foo_closure())), 94);
 
-    #[cfg(cls)]
-    assert_eq!(panicked_at(|| block_on(foo_block())), 96);
+    #[cfg(any(cls, afn_cls))]
+    assert_eq!(panicked_at(|| block_on(foo_block())), 105);
+
+    #[cfg(any(afn, afn_cls))]
+    assert_eq!(panicked_at(|| foo_manual_poll()), 118);
+    #[cfg(any(cls, nofeat))]
+    assert_eq!(panicked_at(|| foo_manual_poll()), 111);
 }
diff --git a/tests/ui/const-generics/gca/wf-inherentimpl.old.stderr b/tests/ui/const-generics/gca/wf-inherentimpl.old.stderr
new file mode 100644
index 0000000000000..0766847a93b18
--- /dev/null
+++ b/tests/ui/const-generics/gca/wf-inherentimpl.old.stderr
@@ -0,0 +1,10 @@
+error: `generic_const_args` requires -Znext-solver=globally to be enabled
+  --> $DIR/wf-inherentimpl.rs:7:12
+   |
+LL | #![feature(generic_const_args, min_generic_const_args)]
+   |            ^^^^^^^^^^^^^^^^^^
+   |
+   = help: enable all of these features
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/const-generics/gca/wf-inherentimpl.rs b/tests/ui/const-generics/gca/wf-inherentimpl.rs
new file mode 100644
index 0000000000000..cb3df20daa2dc
--- /dev/null
+++ b/tests/ui/const-generics/gca/wf-inherentimpl.rs
@@ -0,0 +1,16 @@
+//@[next] check-pass
+//@ revisions: next old
+//@[next] compile-flags: -Znext-solver
+//@ ignore-compare-mode-next-solver (explicit revisions)
+#![feature(inherent_associated_types)]
+#![feature(macroless_generic_const_args)]
+#![feature(generic_const_args, min_generic_const_args)]
+//[old]~^ ERROR `generic_const_args` requires -Znext-solver=globally to be enabled
+struct Foo<const A: usize>;
+impl<const A: usize> Foo<A> {
+    const SIZE: usize = { todo!() };
+    fn to_bytes() -> [u8; Self::SIZE] {
+        todo!()
+    }
+}
+fn main() {}
diff --git a/tests/ui/const-generics/generic_const_parameter_types/inherent-type-const.rs b/tests/ui/const-generics/generic_const_parameter_types/inherent-type-const.rs
index 86eab5ec70eb2..6a2d6eecbb743 100644
--- a/tests/ui/const-generics/generic_const_parameter_types/inherent-type-const.rs
+++ b/tests/ui/const-generics/generic_const_parameter_types/inherent-type-const.rs
@@ -1,4 +1,7 @@
 //@ check-pass
+//@ revisions: next old
+//@[next] compile-flags: -Znext-solver
+//@ ignore-compare-mode-next-solver (explicit revisions)
 #![feature(
     min_generic_const_args,
     generic_const_parameter_types,
diff --git a/tests/ui/const-generics/mgca/none-as-usize-const-arg.rs b/tests/ui/const-generics/mgca/none-as-usize-const-arg.rs
new file mode 100644
index 0000000000000..c21f1d0014ad5
--- /dev/null
+++ b/tests/ui/const-generics/mgca/none-as-usize-const-arg.rs
@@ -0,0 +1,14 @@
+// Regression test for https://github.com/rust-lang/rust/issues/150969
+
+#![feature(generic_const_exprs)]
+#![feature(min_generic_const_args)]
+
+fn pass_enum<const N: usize, const M: usize = const { N }> {
+    //~^ ERROR: missing parameters for function definition
+    //~| ERROR: defaults for generic parameters are not allowed here
+    //~| ERROR: overly complex generic constant
+    pass_enum::<{ core::direct_const_arg!(None) }>
+    //~^ ERROR: missing generics for enum `Option` [E0107]
+}
+
+fn main() {}
diff --git a/tests/ui/const-generics/mgca/none-as-usize-const-arg.stderr b/tests/ui/const-generics/mgca/none-as-usize-const-arg.stderr
new file mode 100644
index 0000000000000..dbd1ac607e88c
--- /dev/null
+++ b/tests/ui/const-generics/mgca/none-as-usize-const-arg.stderr
@@ -0,0 +1,40 @@
+error: missing parameters for function definition
+  --> $DIR/none-as-usize-const-arg.rs:6:59
+   |
+LL | fn pass_enum<const N: usize, const M: usize = const { N }> {
+   |                                                           ^
+   |
+help: add a parameter list
+   |
+LL | fn pass_enum<const N: usize, const M: usize = const { N }>() {
+   |                                                           ++
+
+error: defaults for generic parameters are not allowed here
+  --> $DIR/none-as-usize-const-arg.rs:6:30
+   |
+LL | fn pass_enum<const N: usize, const M: usize = const { N }> {
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0107]: missing generics for enum `Option`
+  --> $DIR/none-as-usize-const-arg.rs:10:43
+   |
+LL |     pass_enum::<{ core::direct_const_arg!(None) }>
+   |                                           ^^^^ expected 1 generic argument
+   |
+help: add missing generic argument
+   |
+LL |     pass_enum::<{ core::direct_const_arg!(None<T>) }>
+   |                                               +++
+
+error: overly complex generic constant
+  --> $DIR/none-as-usize-const-arg.rs:6:47
+   |
+LL | fn pass_enum<const N: usize, const M: usize = const { N }> {
+   |                                               ^^^^^^^^^^^ const blocks are not supported in generic constants
+   |
+   = help: consider moving this anonymous constant into a `const` function
+   = note: this operation may be supported in the future
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/const-generics/mgca/type_const-adt-expr-missing-field.rs b/tests/ui/const-generics/mgca/type_const-adt-expr-missing-field.rs
new file mode 100644
index 0000000000000..05be2097e124f
--- /dev/null
+++ b/tests/ui/const-generics/mgca/type_const-adt-expr-missing-field.rs
@@ -0,0 +1,14 @@
+// Regression test for https://github.com/rust-lang/rust/issues/154632
+
+#![feature(generic_const_exprs)]
+#![feature(min_generic_const_args)]
+#![feature(macroless_generic_const_args)]
+#![feature(generic_const_items)]
+
+type const ADD1<const N: usize>: usize = const { N + 1 };
+//~^ ERROR: unconstrained generic constant
+type const AliasFnUnused: ADD1 = ADD1::<{ Some::<usize> {} }>;
+//~^ ERROR: cannot find type `ADD1` in this scope [E0573]
+//~| ERROR: struct expression with missing field initialiser for `0`
+
+fn main() {}
diff --git a/tests/ui/const-generics/mgca/type_const-adt-expr-missing-field.stderr b/tests/ui/const-generics/mgca/type_const-adt-expr-missing-field.stderr
new file mode 100644
index 0000000000000..bc4821f20cf24
--- /dev/null
+++ b/tests/ui/const-generics/mgca/type_const-adt-expr-missing-field.stderr
@@ -0,0 +1,28 @@
+error[E0573]: cannot find type `ADD1` in this scope
+  --> $DIR/type_const-adt-expr-missing-field.rs:10:27
+   |
+LL | type const AliasFnUnused: ADD1 = ADD1::<{ Some::<usize> {} }>;
+   |                           ^^^^ not found in this scope
+   |
+   = note: a constant named `ADD1` exists in another namespace
+
+error: unconstrained generic constant
+  --> $DIR/type_const-adt-expr-missing-field.rs:8:1
+   |
+LL | type const ADD1<const N: usize>: usize = const { N + 1 };
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try adding a `where` bound
+   |
+LL | type const ADD1<const N: usize>: usize where [(); const { N + 1 }]: = const { N + 1 };
+   |                                        ++++++++++++++++++++++++++++
+
+error: struct expression with missing field initialiser for `0`
+  --> $DIR/type_const-adt-expr-missing-field.rs:10:43
+   |
+LL | type const AliasFnUnused: ADD1 = ADD1::<{ Some::<usize> {} }>;
+   |                                           ^^^^^^^^^^^^^^^^
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0573`.
diff --git a/tests/ui/derives/deriving-all-codegen.rs b/tests/ui/derives/deriving-all-codegen.rs
index a5342c73a5962..343d4095da470 100644
--- a/tests/ui/derives/deriving-all-codegen.rs
+++ b/tests/ui/derives/deriving-all-codegen.rs
@@ -154,29 +154,6 @@ enum Fieldless {
     C,
 }
 
-// A C-like, fieldless enum with variants of varying name lengths.
-#[derive(Debug)]
-enum Fieldless0 {
-    A,
-    BBB,
-    CC,
-}
-
-// A C-like, fieldless enum with 10 variants.
-#[derive(Debug)]
-enum Fieldless10 {
-    AAAAA,
-    BBBB,
-    CC,
-    DDDDDDDD,
-    E,
-    FFFFFFFFFFFFF,
-    GGGGGG,
-    Hatsune,
-    IIIIIII,
-    JJJJJJJJJ,
-}
-
 // An enum with multiple fieldless and fielded variants.
 #[derive(Clone, Copy, Debug, Default, Hash, PartialEq, Eq, PartialOrd, Ord)]
 enum Mixed {
diff --git a/tests/ui/derives/deriving-all-codegen.stdout b/tests/ui/derives/deriving-all-codegen.stdout
index d0b387dbc8b25..320c1b5861162 100644
--- a/tests/ui/derives/deriving-all-codegen.stdout
+++ b/tests/ui/derives/deriving-all-codegen.stdout
@@ -1243,49 +1243,6 @@ impl ::core::cmp::Ord for Fieldless {
     }
 }
 
-// A C-like, fieldless enum with variants of varying name lengths.
-enum Fieldless0 { A, BBB, CC, }
-#[automatically_derived]
-impl ::core::fmt::Debug for Fieldless0 {
-    #[inline]
-    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-        ::core::fmt::Formatter::write_str(f,
-            match self {
-                Fieldless0::A => "A",
-                Fieldless0::BBB => "BBB",
-                Fieldless0::CC => "CC",
-            })
-    }
-}
-
-// A C-like, fieldless enum with 10 variants.
-enum Fieldless10 {
-    AAAAA,
-    BBBB,
-    CC,
-    DDDDDDDD,
-    E,
-    FFFFFFFFFFFFF,
-    GGGGGG,
-    Hatsune,
-    IIIIIII,
-    JJJJJJJJJ,
-}
-#[automatically_derived]
-impl ::core::fmt::Debug for Fieldless10 {
-    #[inline]
-    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-        static __NAMES: &str =
-            "AAAAABBBBCCDDDDDDDDEFFFFFFFFFFFFFGGGGGGHatsuneIIIIIIIJJJJJJJJJ";
-        static __OFFSET: [usize; 11] =
-            [0usize, 5usize, 9usize, 11usize, 19usize, 20usize, 33usize,
-                    39usize, 46usize, 53usize, 62usize];
-        let __d = ::core::intrinsics::discriminant_value(self) as usize;
-        ::core::fmt::Formatter::debug_c_like_enum_write_str(f, __NAMES,
-            &__OFFSET, __d)
-    }
-}
-
 // An enum with multiple fieldless and fielded variants.
 enum Mixed {
 
diff --git a/tests/ui/imports/issue-99695-b.fixed b/tests/ui/imports/issue-99695-b.fixed
index ae63b0c4627c5..2804be27bbb2a 100644
--- a/tests/ui/imports/issue-99695-b.fixed
+++ b/tests/ui/imports/issue-99695-b.fixed
@@ -11,8 +11,8 @@ mod m {
         pub struct other_item;
     }
 
-    use crate::nu;
-pub use self::p::{other_item as _};
+    pub use crate::nu;
+    pub use self::p::{other_item as _};
     //~^ ERROR unresolved import `self::p::nu` [E0432]
     //~| HELP a macro with this name exists at the root of the crate
 }
diff --git a/tests/ui/imports/issue-99695-b.stderr b/tests/ui/imports/issue-99695-b.stderr
index ad752d5c45a7e..5352c26a06ae1 100644
--- a/tests/ui/imports/issue-99695-b.stderr
+++ b/tests/ui/imports/issue-99695-b.stderr
@@ -7,8 +7,8 @@ LL |     pub use self::p::{nu, other_item as _};
    = note: this could be because a macro annotated with `#[macro_export]` will be exported at the root of the crate instead of the module where it is defined
 help: a macro with this name exists at the root of the crate
    |
-LL ~     use crate::nu;
-LL ~ pub use self::p::{other_item as _};
+LL ~     pub use crate::nu;
+LL ~     pub use self::p::{other_item as _};
    |
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/imports/issue-99695.edition_2015.fixed b/tests/ui/imports/issue-99695.edition_2015.fixed
index 798acfd587467..58018baffd7b9 100644
--- a/tests/ui/imports/issue-99695.edition_2015.fixed
+++ b/tests/ui/imports/issue-99695.edition_2015.fixed
@@ -12,8 +12,8 @@ mod m {
 
     pub struct other_item;
 
-    use crate::nu;
-pub use self::{other_item as _};
+    pub use crate::nu;
+    pub use self::{other_item as _};
     //~^ ERROR unresolved import `self::nu` [E0432]
     //~| HELP a macro with this name exists at the root of the crate
 }
diff --git a/tests/ui/imports/issue-99695.edition_2015.stderr b/tests/ui/imports/issue-99695.edition_2015.stderr
index 4ef8e6426fb29..ad24b406c34ca 100644
--- a/tests/ui/imports/issue-99695.edition_2015.stderr
+++ b/tests/ui/imports/issue-99695.edition_2015.stderr
@@ -7,8 +7,8 @@ LL |     pub use self::{nu, other_item as _};
    = note: this could be because a macro annotated with `#[macro_export]` will be exported at the root of the crate instead of the module where it is defined
 help: a macro with this name exists at the root of the crate
    |
-LL ~     use crate::nu;
-LL ~ pub use self::{other_item as _};
+LL ~     pub use crate::nu;
+LL ~     pub use self::{other_item as _};
    |
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/imports/issue-99695.edition_2018.fixed b/tests/ui/imports/issue-99695.edition_2018.fixed
index 798acfd587467..58018baffd7b9 100644
--- a/tests/ui/imports/issue-99695.edition_2018.fixed
+++ b/tests/ui/imports/issue-99695.edition_2018.fixed
@@ -12,8 +12,8 @@ mod m {
 
     pub struct other_item;
 
-    use crate::nu;
-pub use self::{other_item as _};
+    pub use crate::nu;
+    pub use self::{other_item as _};
     //~^ ERROR unresolved import `self::nu` [E0432]
     //~| HELP a macro with this name exists at the root of the crate
 }
diff --git a/tests/ui/imports/issue-99695.edition_2018.stderr b/tests/ui/imports/issue-99695.edition_2018.stderr
index 4ef8e6426fb29..ad24b406c34ca 100644
--- a/tests/ui/imports/issue-99695.edition_2018.stderr
+++ b/tests/ui/imports/issue-99695.edition_2018.stderr
@@ -7,8 +7,8 @@ LL |     pub use self::{nu, other_item as _};
    = note: this could be because a macro annotated with `#[macro_export]` will be exported at the root of the crate instead of the module where it is defined
 help: a macro with this name exists at the root of the crate
    |
-LL ~     use crate::nu;
-LL ~ pub use self::{other_item as _};
+LL ~     pub use crate::nu;
+LL ~     pub use self::{other_item as _};
    |
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/imports/macro-export-nested-import-visibility-issue-141134.fixed b/tests/ui/imports/macro-export-nested-import-visibility-issue-141134.fixed
new file mode 100644
index 0000000000000..0311defd9e83f
--- /dev/null
+++ b/tests/ui/imports/macro-export-nested-import-visibility-issue-141134.fixed
@@ -0,0 +1,79 @@
+//@ run-rustfix
+//@ edition: 2021
+
+// Nested macro import suggestions should preserve the original `use` visibility.
+
+#![allow(unused)]
+
+mod a {
+    #[macro_export]
+    macro_rules! m_pub {
+        () => {};
+    }
+    #[macro_export]
+    macro_rules! m_crate {
+        () => {};
+    }
+    #[macro_export]
+    macro_rules! m_in {
+        () => {};
+    }
+    #[macro_export]
+    macro_rules! m_super {
+        () => {};
+    }
+    #[macro_export]
+    macro_rules! m_self {
+        () => {};
+    }
+    #[macro_export]
+    macro_rules! m_private {
+        () => {};
+    }
+
+    pub struct S;
+
+    mod b0 {
+        pub use crate::m_pub;
+        pub use super::{S as PubS};
+        //~^ ERROR unresolved import `super::m_pub`
+        //~| HELP a macro with this name exists at the root of the crate
+    }
+
+    mod b1 {
+        pub(crate) use crate::m_crate;
+        pub(crate) use super::{S as CrateS};
+        //~^ ERROR unresolved import `super::m_crate`
+        //~| HELP a macro with this name exists at the root of the crate
+    }
+
+    mod b2 {
+        pub(in crate::a) use crate::m_in;
+        pub(in crate::a) use super::{S as InS};
+        //~^ ERROR unresolved import `super::m_in`
+        //~| HELP a macro with this name exists at the root of the crate
+    }
+
+    mod b3 {
+        pub(super) use crate::m_super;
+        pub(super) use super::{S as SuperS};
+        //~^ ERROR unresolved import `super::m_super`
+        //~| HELP a macro with this name exists at the root of the crate
+    }
+
+    mod b4 {
+        pub(self) use crate::m_self;
+        pub(self) use super::{S as SelfS};
+        //~^ ERROR unresolved import `super::m_self`
+        //~| HELP a macro with this name exists at the root of the crate
+    }
+
+    mod b5 {
+        use crate::m_private;
+        use super::{S as PrivateS};
+        //~^ ERROR unresolved import `super::m_private`
+        //~| HELP a macro with this name exists at the root of the crate
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/imports/macro-export-nested-import-visibility-issue-141134.rs b/tests/ui/imports/macro-export-nested-import-visibility-issue-141134.rs
new file mode 100644
index 0000000000000..5be2ba6ff85df
--- /dev/null
+++ b/tests/ui/imports/macro-export-nested-import-visibility-issue-141134.rs
@@ -0,0 +1,73 @@
+//@ run-rustfix
+//@ edition: 2021
+
+// Nested macro import suggestions should preserve the original `use` visibility.
+
+#![allow(unused)]
+
+mod a {
+    #[macro_export]
+    macro_rules! m_pub {
+        () => {};
+    }
+    #[macro_export]
+    macro_rules! m_crate {
+        () => {};
+    }
+    #[macro_export]
+    macro_rules! m_in {
+        () => {};
+    }
+    #[macro_export]
+    macro_rules! m_super {
+        () => {};
+    }
+    #[macro_export]
+    macro_rules! m_self {
+        () => {};
+    }
+    #[macro_export]
+    macro_rules! m_private {
+        () => {};
+    }
+
+    pub struct S;
+
+    mod b0 {
+        pub use super::{m_pub, S as PubS};
+        //~^ ERROR unresolved import `super::m_pub`
+        //~| HELP a macro with this name exists at the root of the crate
+    }
+
+    mod b1 {
+        pub(crate) use super::{m_crate, S as CrateS};
+        //~^ ERROR unresolved import `super::m_crate`
+        //~| HELP a macro with this name exists at the root of the crate
+    }
+
+    mod b2 {
+        pub(in crate::a) use super::{m_in, S as InS};
+        //~^ ERROR unresolved import `super::m_in`
+        //~| HELP a macro with this name exists at the root of the crate
+    }
+
+    mod b3 {
+        pub(super) use super::{m_super, S as SuperS};
+        //~^ ERROR unresolved import `super::m_super`
+        //~| HELP a macro with this name exists at the root of the crate
+    }
+
+    mod b4 {
+        pub(self) use super::{m_self, S as SelfS};
+        //~^ ERROR unresolved import `super::m_self`
+        //~| HELP a macro with this name exists at the root of the crate
+    }
+
+    mod b5 {
+        use super::{m_private, S as PrivateS};
+        //~^ ERROR unresolved import `super::m_private`
+        //~| HELP a macro with this name exists at the root of the crate
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/imports/macro-export-nested-import-visibility-issue-141134.stderr b/tests/ui/imports/macro-export-nested-import-visibility-issue-141134.stderr
new file mode 100644
index 0000000000000..f1cf7e6aa56a0
--- /dev/null
+++ b/tests/ui/imports/macro-export-nested-import-visibility-issue-141134.stderr
@@ -0,0 +1,81 @@
+error[E0432]: unresolved import `super::m_pub`
+  --> $DIR/macro-export-nested-import-visibility-issue-141134.rs:37:25
+   |
+LL |         pub use super::{m_pub, S as PubS};
+   |                         ^^^^^ no `m_pub` in `a`
+   |
+   = note: this could be because a macro annotated with `#[macro_export]` will be exported at the root of the crate instead of the module where it is defined
+help: a macro with this name exists at the root of the crate
+   |
+LL ~         pub use crate::m_pub;
+LL ~         pub use super::{S as PubS};
+   |
+
+error[E0432]: unresolved import `super::m_crate`
+  --> $DIR/macro-export-nested-import-visibility-issue-141134.rs:43:32
+   |
+LL |         pub(crate) use super::{m_crate, S as CrateS};
+   |                                ^^^^^^^ no `m_crate` in `a`
+   |
+   = note: this could be because a macro annotated with `#[macro_export]` will be exported at the root of the crate instead of the module where it is defined
+help: a macro with this name exists at the root of the crate
+   |
+LL ~         pub(crate) use crate::m_crate;
+LL ~         pub(crate) use super::{S as CrateS};
+   |
+
+error[E0432]: unresolved import `super::m_in`
+  --> $DIR/macro-export-nested-import-visibility-issue-141134.rs:49:38
+   |
+LL |         pub(in crate::a) use super::{m_in, S as InS};
+   |                                      ^^^^ no `m_in` in `a`
+   |
+   = note: this could be because a macro annotated with `#[macro_export]` will be exported at the root of the crate instead of the module where it is defined
+help: a macro with this name exists at the root of the crate
+   |
+LL ~         pub(in crate::a) use crate::m_in;
+LL ~         pub(in crate::a) use super::{S as InS};
+   |
+
+error[E0432]: unresolved import `super::m_super`
+  --> $DIR/macro-export-nested-import-visibility-issue-141134.rs:55:32
+   |
+LL |         pub(super) use super::{m_super, S as SuperS};
+   |                                ^^^^^^^ no `m_super` in `a`
+   |
+   = note: this could be because a macro annotated with `#[macro_export]` will be exported at the root of the crate instead of the module where it is defined
+help: a macro with this name exists at the root of the crate
+   |
+LL ~         pub(super) use crate::m_super;
+LL ~         pub(super) use super::{S as SuperS};
+   |
+
+error[E0432]: unresolved import `super::m_self`
+  --> $DIR/macro-export-nested-import-visibility-issue-141134.rs:61:31
+   |
+LL |         pub(self) use super::{m_self, S as SelfS};
+   |                               ^^^^^^ no `m_self` in `a`
+   |
+   = note: this could be because a macro annotated with `#[macro_export]` will be exported at the root of the crate instead of the module where it is defined
+help: a macro with this name exists at the root of the crate
+   |
+LL ~         pub(self) use crate::m_self;
+LL ~         pub(self) use super::{S as SelfS};
+   |
+
+error[E0432]: unresolved import `super::m_private`
+  --> $DIR/macro-export-nested-import-visibility-issue-141134.rs:67:21
+   |
+LL |         use super::{m_private, S as PrivateS};
+   |                     ^^^^^^^^^ no `m_private` in `a`
+   |
+   = note: this could be because a macro annotated with `#[macro_export]` will be exported at the root of the crate instead of the module where it is defined
+help: a macro with this name exists at the root of the crate
+   |
+LL ~         use crate::m_private;
+LL ~         use super::{S as PrivateS};
+   |
+
+error: aborting due to 6 previous errors
+
+For more information about this error, try `rustc --explain E0432`.
diff --git a/tests/ui/lint/forbid-error-capped.rs b/tests/ui/lint/forbid-error-capped.rs
index e458ddf90746e..87c1e2626660b 100644
--- a/tests/ui/lint/forbid-error-capped.rs
+++ b/tests/ui/lint/forbid-error-capped.rs
@@ -1,13 +1,11 @@
-//@ check-pass
-// compile-args: --cap-lints=warn -Fwarnings
-
 // This checks that the forbid attribute checking is ignored when the forbidden
 // lint is capped.
 
+//@ check-pass
+//@ compile-flags: --cap-lints=warn -Fwarnings
+
 #![forbid(warnings)]
 #![allow(unused)]
-//~^ WARN allow(unused) incompatible with previous forbid
-//~| WARN previously accepted
 
 #[allow(unused)]
 mod bar {
diff --git a/tests/ui/lint/forbid-error-capped.stderr b/tests/ui/lint/forbid-error-capped.stderr
deleted file mode 100644
index 479e7b9412d57..0000000000000
--- a/tests/ui/lint/forbid-error-capped.stderr
+++ /dev/null
@@ -1,27 +0,0 @@
-warning: allow(unused) incompatible with previous forbid
-  --> $DIR/forbid-error-capped.rs:8:10
-   |
-LL | #![forbid(warnings)]
-   |           -------- `forbid` level set here
-LL | #![allow(unused)]
-   |          ^^^^^^ overruled by previous forbid
-   |
-   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = note: for more information, see issue #81670 <https://github.com/rust-lang/rust/issues/81670>
-   = note: `#[warn(forbidden_lint_groups)]` (part of `#[warn(future_incompatible)]`) on by default
-
-warning: 1 warning emitted
-
-Future incompatibility report: Future breakage diagnostic:
-warning: allow(unused) incompatible with previous forbid
-  --> $DIR/forbid-error-capped.rs:8:10
-   |
-LL | #![forbid(warnings)]
-   |           -------- `forbid` level set here
-LL | #![allow(unused)]
-   |          ^^^^^^ overruled by previous forbid
-   |
-   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = note: for more information, see issue #81670 <https://github.com/rust-lang/rust/issues/81670>
-   = note: `#[warn(forbidden_lint_groups)]` (part of `#[warn(future_incompatible)]`) on by default
-
diff --git a/tests/ui/lint/unused-braces-for-iterator-temp-scope-issue-160741.e2021.stderr b/tests/ui/lint/unused-braces-for-iterator-temp-scope-issue-160741.e2021.stderr
new file mode 100644
index 0000000000000..f7a77f5ec4ecb
--- /dev/null
+++ b/tests/ui/lint/unused-braces-for-iterator-temp-scope-issue-160741.e2021.stderr
@@ -0,0 +1,19 @@
+warning: unnecessary braces around `for` iterator expression
+  --> $DIR/unused-braces-for-iterator-temp-scope-issue-160741.rs:20:18
+   |
+LL |     for value in { data.lock().unwrap().values.clone() } {
+   |                  ^^                                   ^^
+   |
+note: the lint level is defined here
+  --> $DIR/unused-braces-for-iterator-temp-scope-issue-160741.rs:8:9
+   |
+LL | #![warn(unused_braces)]
+   |         ^^^^^^^^^^^^^
+help: remove these braces
+   |
+LL -     for value in { data.lock().unwrap().values.clone() } {
+LL +     for value in data.lock().unwrap().values.clone() {
+   |
+
+warning: 1 warning emitted
+
diff --git a/tests/ui/lint/unused-braces-for-iterator-temp-scope-issue-160741.rs b/tests/ui/lint/unused-braces-for-iterator-temp-scope-issue-160741.rs
new file mode 100644
index 0000000000000..d8c0dd00fe0bd
--- /dev/null
+++ b/tests/ui/lint/unused-braces-for-iterator-temp-scope-issue-160741.rs
@@ -0,0 +1,24 @@
+//! A block around a Rust 2024 `for` iterator expression may shorten the lifetime of temporaries.
+
+//@ revisions: e2021 e2024
+//@[e2021] edition: 2021
+//@[e2024] edition: 2024
+//@ check-pass
+
+#![warn(unused_braces)]
+
+use std::sync::{Arc, Mutex};
+
+struct State {
+    values: Vec<u32>,
+    total: u32,
+}
+
+fn main() {
+    let data = Arc::new(Mutex::new(State { values: vec![1, 2, 3], total: 0 }));
+
+    for value in { data.lock().unwrap().values.clone() } {
+        //[e2021]~^ WARN unnecessary braces around `for` iterator expression
+        data.lock().unwrap().total += value;
+    }
+}
diff --git a/tests/ui/mir/issue-71793-inline-args-storage.rs b/tests/ui/mir/issue-71793-inline-args-storage.rs
index 0ed4d4723731e..38ce28a035346 100644
--- a/tests/ui/mir/issue-71793-inline-args-storage.rs
+++ b/tests/ui/mir/issue-71793-inline-args-storage.rs
@@ -1,10 +1,10 @@
 // Verifies that inliner emits StorageLive & StorageDead when introducing
 // temporaries for arguments, so that they don't become part of the coroutine.
 // Regression test for #71793.
-//
+
 //@ check-pass
 //@ edition:2018
-// compile-args: -Zmir-opt-level=3
+//@ compile-flags: -Zmir-opt-level=3
 
 #![crate_type = "lib"]
 
diff --git a/tests/ui/parser/box-can-begin-expr.rs b/tests/ui/parser/box-can-begin-expr.rs
new file mode 100644
index 0000000000000..5f965d3f4e71d
--- /dev/null
+++ b/tests/ui/parser/box-can-begin-expr.rs
@@ -0,0 +1,18 @@
+// Demonstrate that we still consider keyword `box` to begin expressions (`can_begin_expr`) even
+// though we officially no longer support box expressions (#108471).
+// It means that we take the first rule and fail immediately afterward.
+
+// FIXME: Remove `box` from the list of tokens that can begin expressions which would make us take
+//        the second rule instead and consequently accept this program (needs lang FCP).
+//
+//        Alternatively we could unreserve keyword `box` (needs lang FCP) which would make us
+//        continue to take the first rule but also start accepting this program.
+
+macro_rules! mk {
+    ($e:expr) => {};
+    (box $e:expr) => {};
+}
+
+mk!(box 0); //~ ERROR expected expression, found reserved keyword `box`
+
+fn main() {}
diff --git a/tests/ui/parser/box-can-begin-expr.stderr b/tests/ui/parser/box-can-begin-expr.stderr
new file mode 100644
index 0000000000000..304680c116fc0
--- /dev/null
+++ b/tests/ui/parser/box-can-begin-expr.stderr
@@ -0,0 +1,11 @@
+error: expected expression, found reserved keyword `box`
+  --> $DIR/box-can-begin-expr.rs:16:5
+   |
+LL |     ($e:expr) => {};
+   |      ------- while parsing argument for this `expr` macro fragment
+...
+LL | mk!(box 0);
+   |     ^^^ expected expression
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/parser/removed-syntax/removed-syntax-box-patterns.rs b/tests/ui/parser/removed-syntax/removed-syntax-box-patterns.rs
index 872f050a04034..13928aaf9886f 100644
--- a/tests/ui/parser/removed-syntax/removed-syntax-box-patterns.rs
+++ b/tests/ui/parser/removed-syntax/removed-syntax-box-patterns.rs
@@ -1,9 +1,11 @@
 fn main() {
-    let box x = Box::new('c'); //~ ERROR `box_patterns` has been removed
+    let box x = Box::new('c'); //~ ERROR `box` patterns have been removed
     let _: char = x;
 
     struct Packet { x: Box<i32> }
 
-    let Packet { box x } = Packet { x: Box::new(0) }; //~ ERROR `box_patterns` has been removed
+    let Packet { box x } = Packet { x: Box::new(0) }; //~ ERROR `box` patterns have been removed
     let _: i32 = x;
+
+    let Packet { box ref mut x }; //~ ERROR `box` patterns have been removed
 }
diff --git a/tests/ui/parser/removed-syntax/removed-syntax-box-patterns.stderr b/tests/ui/parser/removed-syntax/removed-syntax-box-patterns.stderr
index df35336ece5a9..2081098b699e2 100644
--- a/tests/ui/parser/removed-syntax/removed-syntax-box-patterns.stderr
+++ b/tests/ui/parser/removed-syntax/removed-syntax-box-patterns.stderr
@@ -1,14 +1,56 @@
-error: `box_patterns` has been removed
+error: `box` patterns have been removed (feature `box_patterns`)
   --> $DIR/removed-syntax-box-patterns.rs:2:9
    |
 LL |     let box x = Box::new('c');
-   |         ^^^^^
+   |         ^^^
+   |
+   = help: enable feature `deref_patterns` instead and...
+help: ...if possible just remove keyword `box`...
+   |
+LL -     let box x = Box::new('c');
+LL +     let x = Box::new('c');
+   |
+help: ...otherwise replace it with an invocation of macro `deref`
+   |
+LL -     let box x = Box::new('c');
+LL +     let deref!(x) = Box::new('c');
+   |
 
-error: `box_patterns` has been removed
+error: `box` patterns have been removed (feature `box_patterns`)
   --> $DIR/removed-syntax-box-patterns.rs:7:18
    |
 LL |     let Packet { box x } = Packet { x: Box::new(0) };
    |                  ^^^
+   |
+   = help: enable feature `deref_patterns` instead and...
+help: ...if possible just remove keyword `box`...
+   |
+LL -     let Packet { box x } = Packet { x: Box::new(0) };
+LL +     let Packet { x } = Packet { x: Box::new(0) };
+   |
+help: ...otherwise replace it with an invocation of macro `deref`
+   |
+LL -     let Packet { box x } = Packet { x: Box::new(0) };
+LL +     let Packet { x: deref!(x) } = Packet { x: Box::new(0) };
+   |
+
+error: `box` patterns have been removed (feature `box_patterns`)
+  --> $DIR/removed-syntax-box-patterns.rs:10:18
+   |
+LL |     let Packet { box ref mut x };
+   |                  ^^^
+   |
+   = help: enable feature `deref_patterns` instead and...
+help: ...if possible just remove keyword `box`...
+   |
+LL -     let Packet { box ref mut x };
+LL +     let Packet { ref mut x };
+   |
+help: ...otherwise replace it with an invocation of macro `deref`
+   |
+LL -     let Packet { box ref mut x };
+LL +     let Packet { x: deref!(ref mut x) };
+   |
 
-error: aborting due to 2 previous errors
+error: aborting due to 3 previous errors
 
diff --git a/tests/ui/parser/removed-syntax/removed-syntax-box.fixed b/tests/ui/parser/removed-syntax/removed-syntax-box.fixed
deleted file mode 100644
index 8aec8c4cc435a..0000000000000
--- a/tests/ui/parser/removed-syntax/removed-syntax-box.fixed
+++ /dev/null
@@ -1,14 +0,0 @@
-//@ run-rustfix
-
-fn main() {
-    #[allow(dead_code)]
-    struct T {
-        a: u8,
-        b: u8,
-    }
-    let _ = Box::new(()); //~ ERROR `box_syntax` has been removed
-    let _ = Box::new(1); //~ ERROR `box_syntax` has been removed
-    let _ = Box::new(T { a: 12, b: 18 }); //~ ERROR `box_syntax` has been removed
-    let _ = Box::new([5; 30]); //~ ERROR `box_syntax` has been removed
-    let _: Box<()> = Box::new(()); //~ ERROR `box_syntax` has been removed
-}
diff --git a/tests/ui/parser/removed-syntax/removed-syntax-box.rs b/tests/ui/parser/removed-syntax/removed-syntax-box.rs
deleted file mode 100644
index b77880e37553f..0000000000000
--- a/tests/ui/parser/removed-syntax/removed-syntax-box.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//@ run-rustfix
-
-fn main() {
-    #[allow(dead_code)]
-    struct T {
-        a: u8,
-        b: u8,
-    }
-    let _ = box (); //~ ERROR `box_syntax` has been removed
-    let _ = box 1; //~ ERROR `box_syntax` has been removed
-    let _ = box T { a: 12, b: 18 }; //~ ERROR `box_syntax` has been removed
-    let _ = box [5; 30]; //~ ERROR `box_syntax` has been removed
-    let _: Box<()> = box (); //~ ERROR `box_syntax` has been removed
-}
diff --git a/tests/ui/parser/removed-syntax/removed-syntax-box.stderr b/tests/ui/parser/removed-syntax/removed-syntax-box.stderr
deleted file mode 100644
index 04e84a10fad68..0000000000000
--- a/tests/ui/parser/removed-syntax/removed-syntax-box.stderr
+++ /dev/null
@@ -1,62 +0,0 @@
-error: `box_syntax` has been removed
-  --> $DIR/removed-syntax-box.rs:9:13
-   |
-LL |     let _ = box ();
-   |             ^^^^^^
-   |
-help: use `Box::new()` instead
-   |
-LL -     let _ = box ();
-LL +     let _ = Box::new(());
-   |
-
-error: `box_syntax` has been removed
-  --> $DIR/removed-syntax-box.rs:10:13
-   |
-LL |     let _ = box 1;
-   |             ^^^^^
-   |
-help: use `Box::new()` instead
-   |
-LL -     let _ = box 1;
-LL +     let _ = Box::new(1);
-   |
-
-error: `box_syntax` has been removed
-  --> $DIR/removed-syntax-box.rs:11:13
-   |
-LL |     let _ = box T { a: 12, b: 18 };
-   |             ^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: use `Box::new()` instead
-   |
-LL -     let _ = box T { a: 12, b: 18 };
-LL +     let _ = Box::new(T { a: 12, b: 18 });
-   |
-
-error: `box_syntax` has been removed
-  --> $DIR/removed-syntax-box.rs:12:13
-   |
-LL |     let _ = box [5; 30];
-   |             ^^^^^^^^^^^
-   |
-help: use `Box::new()` instead
-   |
-LL -     let _ = box [5; 30];
-LL +     let _ = Box::new([5; 30]);
-   |
-
-error: `box_syntax` has been removed
-  --> $DIR/removed-syntax-box.rs:13:22
-   |
-LL |     let _: Box<()> = box ();
-   |                      ^^^^^^
-   |
-help: use `Box::new()` instead
-   |
-LL -     let _: Box<()> = box ();
-LL +     let _: Box<()> = Box::new(());
-   |
-
-error: aborting due to 5 previous errors
-
diff --git a/tests/ui/parser/removed-syntax/removed-syntax-uniq-mut-expr.rs b/tests/ui/parser/removed-syntax/removed-syntax-uniq-mut-expr.rs
deleted file mode 100644
index 08ef4b4326934..0000000000000
--- a/tests/ui/parser/removed-syntax/removed-syntax-uniq-mut-expr.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-fn main() {
-    let a_box = box mut 42; //~ ERROR expected expression, found keyword `mut`
-}
diff --git a/tests/ui/parser/removed-syntax/removed-syntax-uniq-mut-expr.stderr b/tests/ui/parser/removed-syntax/removed-syntax-uniq-mut-expr.stderr
deleted file mode 100644
index 7aaedad19d86e..0000000000000
--- a/tests/ui/parser/removed-syntax/removed-syntax-uniq-mut-expr.stderr
+++ /dev/null
@@ -1,8 +0,0 @@
-error: expected expression, found keyword `mut`
-  --> $DIR/removed-syntax-uniq-mut-expr.rs:2:21
-   |
-LL |     let a_box = box mut 42;
-   |                     ^^^ expected expression
-
-error: aborting due to 1 previous error
-
diff --git a/tests/ui/stability-attribute/stability-attribute-trait-impl.rs b/tests/ui/stability-attribute/stability-attribute-trait-impl.rs
index 2ef6ec81a56c5..124648017fe2b 100644
--- a/tests/ui/stability-attribute/stability-attribute-trait-impl.rs
+++ b/tests/ui/stability-attribute/stability-attribute-trait-impl.rs
@@ -23,6 +23,7 @@ impl StableTrait for UnstableType {}
 impl UnstableTrait for StableType {}
 
 #[unstable(feature = "h", issue = "none")]
+//~^ ERROR an `#[unstable]` annotation here has no effect [ineffective_unstable_trait_impl]
 impl StableTrait for ! {}
 
 // Note: If rust_cold_cc is stabilized, switch this to another (unstable) ABI.
@@ -40,4 +41,11 @@ impl StableTrait for fn() -> ! {}
 #[unstable(feature = "l", issue = "none")]
 impl StableTrait for fn() -> UnstableType {}
 
+#[unstable(feature = "m", issue = "none")]
+//~^ ERROR an `#[unstable]` annotation here has no effect [ineffective_unstable_trait_impl]
+impl StableTrait for fn(!) {}
+
+#[unstable(feature = "n", issue = "none")]
+impl StableTrait for fn(UnstableType) {}
+
 fn main() {}
diff --git a/tests/ui/stability-attribute/stability-attribute-trait-impl.stderr b/tests/ui/stability-attribute/stability-attribute-trait-impl.stderr
index 1f6762795e618..11feda60a73a1 100644
--- a/tests/ui/stability-attribute/stability-attribute-trait-impl.stderr
+++ b/tests/ui/stability-attribute/stability-attribute-trait-impl.stderr
@@ -1,20 +1,36 @@
 error: an `#[unstable]` annotation here has no effect
-  --> $DIR/stability-attribute-trait-impl.rs:32:1
+  --> $DIR/stability-attribute-trait-impl.rs:25:1
    |
-LL | #[unstable(feature = "j", issue = "none")]
+LL | #[unstable(feature = "h", issue = "none")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: see issue #55436 <https://github.com/rust-lang/rust/issues/55436> for more information
    = note: `#[deny(ineffective_unstable_trait_impl)]` on by default
 
 error: an `#[unstable]` annotation here has no effect
-  --> $DIR/stability-attribute-trait-impl.rs:36:1
+  --> $DIR/stability-attribute-trait-impl.rs:33:1
+   |
+LL | #[unstable(feature = "j", issue = "none")]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #55436 <https://github.com/rust-lang/rust/issues/55436> for more information
+
+error: an `#[unstable]` annotation here has no effect
+  --> $DIR/stability-attribute-trait-impl.rs:37:1
    |
 LL | #[unstable(feature = "k", issue = "none")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: see issue #55436 <https://github.com/rust-lang/rust/issues/55436> for more information
 
+error: an `#[unstable]` annotation here has no effect
+  --> $DIR/stability-attribute-trait-impl.rs:44:1
+   |
+LL | #[unstable(feature = "m", issue = "none")]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #55436 <https://github.com/rust-lang/rust/issues/55436> for more information
+
 error: module has missing stability attribute
   --> $DIR/stability-attribute-trait-impl.rs:1:1
    |
@@ -26,5 +42,5 @@ LL | | #[stable(feature = "a", since = "3.3.3")]
 LL | | fn main() {}
    | |____________^
 
-error: aborting due to 3 previous errors
+error: aborting due to 5 previous errors
 
diff --git a/tests/ui/suggestions/suggest-calling-fn-in-deref-issue-161564.rs b/tests/ui/suggestions/suggest-calling-fn-in-deref-issue-161564.rs
new file mode 100644
index 0000000000000..6f1bf4e4589b8
--- /dev/null
+++ b/tests/ui/suggestions/suggest-calling-fn-in-deref-issue-161564.rs
@@ -0,0 +1,73 @@
+// Dereferencing an uncalled function item should suggest calling it, rather than
+// only complaining that the function's own type cannot be dereferenced.
+
+pub fn ret_ref() -> &'static usize {
+    &const { 12 }
+}
+
+pub fn ret_val() -> usize {
+    12
+}
+
+pub fn with_args(_: u8) -> &'static usize {
+    &const { 12 }
+}
+
+pub fn ret_box() -> Box<usize> {
+    Box::new(12)
+}
+
+struct S;
+
+impl S {
+    fn assoc() -> &'static usize {
+        &const { 12 }
+    }
+}
+
+pub fn fn_item() {
+    let _a = *ret_ref;
+    //~^ ERROR type `fn() -> &'static usize {ret_ref}` cannot be dereferenced
+    //~| HELP use parentheses to call this function
+}
+
+pub fn takes_args() {
+    let _a = *with_args;
+    //~^ ERROR type `fn(u8) -> &'static usize {with_args}` cannot be dereferenced
+    //~| HELP use parentheses to call this function
+}
+
+pub fn assoc_fn() {
+    let _a = *S::assoc;
+    //~^ ERROR type `fn() -> &'static usize {S::assoc}` cannot be dereferenced
+    //~| HELP use parentheses to call this associated function
+}
+
+pub fn overloaded_deref() {
+    let _a = *ret_box;
+    //~^ ERROR type `fn() -> Box<usize> {ret_box}` cannot be dereferenced
+    //~| HELP use parentheses to call this function
+}
+
+pub fn fn_pointer() {
+    let f: fn() -> &'static usize = ret_ref;
+    let _a = *f;
+    //~^ ERROR type `fn() -> &'static usize` cannot be dereferenced
+    //~| HELP use parentheses to call this function pointer
+}
+
+pub fn closure() {
+    let c = || &const { 12usize };
+    let _a = *c;
+    //~^ ERROR cannot be dereferenced
+    //~| HELP use parentheses to call this closure
+}
+
+// Negative case: calling this one still would not produce something dereferenceable,
+// so no suggestion should be offered.
+pub fn not_derefable_when_called() {
+    let _a = *ret_val;
+    //~^ ERROR type `fn() -> usize {ret_val}` cannot be dereferenced
+}
+
+fn main() {}
diff --git a/tests/ui/suggestions/suggest-calling-fn-in-deref-issue-161564.stderr b/tests/ui/suggestions/suggest-calling-fn-in-deref-issue-161564.stderr
new file mode 100644
index 0000000000000..a119a368450c3
--- /dev/null
+++ b/tests/ui/suggestions/suggest-calling-fn-in-deref-issue-161564.stderr
@@ -0,0 +1,75 @@
+error[E0614]: type `fn() -> &'static usize {ret_ref}` cannot be dereferenced
+  --> $DIR/suggest-calling-fn-in-deref-issue-161564.rs:29:14
+   |
+LL |     let _a = *ret_ref;
+   |              ^^^^^^^^ can't be dereferenced
+   |
+help: use parentheses to call this function
+   |
+LL |     let _a = *ret_ref();
+   |                      ++
+
+error[E0614]: type `fn(u8) -> &'static usize {with_args}` cannot be dereferenced
+  --> $DIR/suggest-calling-fn-in-deref-issue-161564.rs:35:14
+   |
+LL |     let _a = *with_args;
+   |              ^^^^^^^^^^ can't be dereferenced
+   |
+help: use parentheses to call this function
+   |
+LL |     let _a = *with_args(/* u8 */);
+   |                        ++++++++++
+
+error[E0614]: type `fn() -> &'static usize {S::assoc}` cannot be dereferenced
+  --> $DIR/suggest-calling-fn-in-deref-issue-161564.rs:41:14
+   |
+LL |     let _a = *S::assoc;
+   |              ^^^^^^^^^ can't be dereferenced
+   |
+help: use parentheses to call this associated function
+   |
+LL |     let _a = *S::assoc();
+   |                       ++
+
+error[E0614]: type `fn() -> Box<usize> {ret_box}` cannot be dereferenced
+  --> $DIR/suggest-calling-fn-in-deref-issue-161564.rs:47:14
+   |
+LL |     let _a = *ret_box;
+   |              ^^^^^^^^ can't be dereferenced
+   |
+help: use parentheses to call this function
+   |
+LL |     let _a = *ret_box();
+   |                      ++
+
+error[E0614]: type `fn() -> &'static usize` cannot be dereferenced
+  --> $DIR/suggest-calling-fn-in-deref-issue-161564.rs:54:14
+   |
+LL |     let _a = *f;
+   |              ^^ can't be dereferenced
+   |
+help: use parentheses to call this function pointer
+   |
+LL |     let _a = *f();
+   |                ++
+
+error[E0614]: type `{closure@$DIR/suggest-calling-fn-in-deref-issue-161564.rs:60:13: 60:15}` cannot be dereferenced
+  --> $DIR/suggest-calling-fn-in-deref-issue-161564.rs:61:14
+   |
+LL |     let _a = *c;
+   |              ^^ can't be dereferenced
+   |
+help: use parentheses to call this closure
+   |
+LL |     let _a = *c();
+   |                ++
+
+error[E0614]: type `fn() -> usize {ret_val}` cannot be dereferenced
+  --> $DIR/suggest-calling-fn-in-deref-issue-161564.rs:69:14
+   |
+LL |     let _a = *ret_val;
+   |              ^^^^^^^^ can't be dereferenced
+
+error: aborting due to 7 previous errors
+
+For more information about this error, try `rustc --explain E0614`.
diff --git a/tests/ui/suggestions/suggest-calling-fn-in-for-loop-issue-161564.rs b/tests/ui/suggestions/suggest-calling-fn-in-for-loop-issue-161564.rs
new file mode 100644
index 0000000000000..5d50346b5b6fe
--- /dev/null
+++ b/tests/ui/suggestions/suggest-calling-fn-in-for-loop-issue-161564.rs
@@ -0,0 +1,37 @@
+//@ edition: 2021
+
+//! Check that a fn item used as the iterator of a `for` loop is suggested to be called, the way
+//! it already is when it is passed as a function argument.
+
+struct S;
+
+trait T {
+    fn assoc_in_trait() -> std::vec::IntoIter<u8>;
+}
+
+impl T for S {
+    fn assoc_in_trait() -> std::vec::IntoIter<u8> {
+        vec![1u8].into_iter()
+    }
+}
+
+impl S {
+    fn inherent_assoc() -> impl Iterator<Item = u8> {
+        [1u8].into_iter()
+    }
+}
+
+fn free_fn() -> impl Iterator<Item = u8> {
+    [1u8].into_iter()
+}
+
+fn main() {
+    for _ in S::inherent_assoc {} //~ ERROR [E0277]
+    for _ in <S as T>::assoc_in_trait {} //~ ERROR [E0277]
+    for _ in free_fn {} //~ ERROR [E0277]
+
+    let closure = || vec![1u8].into_iter();
+    for _ in closure {} //~ ERROR [E0277]
+
+    for _ in || vec![1u8].into_iter() {} //~ ERROR [E0277]
+}
diff --git a/tests/ui/suggestions/suggest-calling-fn-in-for-loop-issue-161564.stderr b/tests/ui/suggestions/suggest-calling-fn-in-for-loop-issue-161564.stderr
new file mode 100644
index 0000000000000..e2edaebb65c9b
--- /dev/null
+++ b/tests/ui/suggestions/suggest-calling-fn-in-for-loop-issue-161564.stderr
@@ -0,0 +1,68 @@
+error[E0277]: `fn() -> impl Iterator<Item = u8> {S::inherent_assoc}` is not an iterator
+  --> $DIR/suggest-calling-fn-in-for-loop-issue-161564.rs:29:14
+   |
+LL |     for _ in S::inherent_assoc {}
+   |              ^^^^^^^^^^^^^^^^^ `fn() -> impl Iterator<Item = u8> {S::inherent_assoc}` is not an iterator
+   |
+   = help: the trait `Iterator` is not implemented for fn item `fn() -> impl Iterator<Item = u8> {S::inherent_assoc}`
+   = note: required for `fn() -> impl Iterator<Item = u8> {S::inherent_assoc}` to implement `IntoIterator`
+help: use parentheses to call this associated function
+   |
+LL |     for _ in S::inherent_assoc() {}
+   |                               ++
+
+error[E0277]: `fn() -> std::vec::IntoIter<u8> {<S as T>::assoc_in_trait}` is not an iterator
+  --> $DIR/suggest-calling-fn-in-for-loop-issue-161564.rs:30:14
+   |
+LL |     for _ in <S as T>::assoc_in_trait {}
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^ `fn() -> std::vec::IntoIter<u8> {<S as T>::assoc_in_trait}` is not an iterator
+   |
+   = help: the trait `Iterator` is not implemented for fn item `fn() -> std::vec::IntoIter<u8> {<S as T>::assoc_in_trait}`
+   = note: required for `fn() -> std::vec::IntoIter<u8> {<S as T>::assoc_in_trait}` to implement `IntoIterator`
+help: use parentheses to call this associated function
+   |
+LL |     for _ in <S as T>::assoc_in_trait() {}
+   |                                      ++
+
+error[E0277]: `fn() -> impl Iterator<Item = u8> {free_fn}` is not an iterator
+  --> $DIR/suggest-calling-fn-in-for-loop-issue-161564.rs:31:14
+   |
+LL |     for _ in free_fn {}
+   |              ^^^^^^^ `fn() -> impl Iterator<Item = u8> {free_fn}` is not an iterator
+   |
+   = help: the trait `Iterator` is not implemented for fn item `fn() -> impl Iterator<Item = u8> {free_fn}`
+   = note: required for `fn() -> impl Iterator<Item = u8> {free_fn}` to implement `IntoIterator`
+help: use parentheses to call this function
+   |
+LL |     for _ in free_fn() {}
+   |                     ++
+
+error[E0277]: `{closure@$DIR/suggest-calling-fn-in-for-loop-issue-161564.rs:33:19: 33:21}` is not an iterator
+  --> $DIR/suggest-calling-fn-in-for-loop-issue-161564.rs:34:14
+   |
+LL |     for _ in closure {}
+   |              ^^^^^^^ `{closure@$DIR/suggest-calling-fn-in-for-loop-issue-161564.rs:33:19: 33:21}` is not an iterator
+   |
+   = help: the trait `Iterator` is not implemented for closure `{closure@$DIR/suggest-calling-fn-in-for-loop-issue-161564.rs:33:19: 33:21}`
+   = note: required for `{closure@$DIR/suggest-calling-fn-in-for-loop-issue-161564.rs:33:19: 33:21}` to implement `IntoIterator`
+help: use parentheses to call this closure
+   |
+LL |     for _ in closure() {}
+   |                     ++
+
+error[E0277]: `{closure@$DIR/suggest-calling-fn-in-for-loop-issue-161564.rs:36:14: 36:16}` is not an iterator
+  --> $DIR/suggest-calling-fn-in-for-loop-issue-161564.rs:36:14
+   |
+LL |     for _ in || vec![1u8].into_iter() {}
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^ `{closure@$DIR/suggest-calling-fn-in-for-loop-issue-161564.rs:36:14: 36:16}` is not an iterator
+   |
+   = help: the trait `Iterator` is not implemented for closure `{closure@$DIR/suggest-calling-fn-in-for-loop-issue-161564.rs:36:14: 36:16}`
+   = note: required for `{closure@$DIR/suggest-calling-fn-in-for-loop-issue-161564.rs:36:14: 36:16}` to implement `IntoIterator`
+help: use parentheses to call this closure
+   |
+LL |     for _ in (|| vec![1u8].into_iter())() {}
+   |              +                        +++
+
+error: aborting due to 5 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/thir-print/thir-tree-match-for.stdout b/tests/ui/thir-print/thir-tree-match-for.stdout
index 5e32526fc5633..b07b0c182a161 100644
--- a/tests/ui/thir-print/thir-tree-match-for.stdout
+++ b/tests/ui/thir-print/thir-tree-match-for.stdout
@@ -345,7 +345,7 @@ body:
                                                         temp_scope_id: 44
                                                         span: $DIR/thir-tree-match-for.rs:16:3: 18:4 (#7)
                                                         kind: 
-                                                            Use {
+                                                            ValueExpr {
                                                                 source:
                                                                     Expr {
                                                                         ty: ()