diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
index 632f138a4c798..bde6614b48548 100644
--- a/compiler/rustc_ast/src/ast.rs
+++ b/compiler/rustc_ast/src/ast.rs
@@ -1378,15 +1378,6 @@ pub enum UnsafeSource {
     UserProvided,
 }
 
-/// Track whether under `feature(min_generic_const_args)` this anon const
-/// was explicitly disambiguated as an anon const or not through the use of
-/// `const { ... }` syntax.
-#[derive(Clone, PartialEq, Encodable, Decodable, Debug, Copy, Walkable)]
-pub enum MgcaDisambiguation {
-    AnonConst,
-    Direct,
-}
-
 /// A constant (expression) that's not an item or associated item,
 /// but needs its own `DefId` for type-checking, const-eval, etc.
 /// These are usually found nested inside types (e.g., array lengths)
@@ -1396,7 +1387,6 @@ pub enum MgcaDisambiguation {
 pub struct AnonConst {
     pub id: NodeId,
     pub value: Box<Expr>,
-    pub mgca_disambiguation: MgcaDisambiguation,
 }
 
 /// An expression.
@@ -1627,6 +1617,7 @@ impl Expr {
             | ExprKind::UnsafeBinderCast(..)
             | ExprKind::While(..)
             | ExprKind::Yield(YieldKind::Postfix(..))
+            | ExprKind::DirectConstArg(..)
             | ExprKind::Err(_)
             | ExprKind::Dummy => prefix_attrs_precedence(&self.attrs),
         }
@@ -1920,6 +1911,9 @@ pub enum ExprKind {
 
     UnsafeBinderCast(UnsafeBinderCastKind, Box<Expr>, Option<Box<Ty>>),
 
+    /// An mGCA `direct_const_arg!()` expression.
+    DirectConstArg(Box<Expr>),
+
     /// Placeholder for an expression that wasn't syntactically well formed in some way.
     Err(ErrorGuaranteed),
 
@@ -2566,6 +2560,8 @@ pub enum TyKind {
     FieldOf(Box<Ty>, Option<Ident>, Ident),
     /// A view of a type. `T.{ field_1, field_2 }`.
     View(Box<Ty>, #[visitable(ignore)] ThinVec<Ident>),
+    /// An mGCA `direct_const_arg!()` expression.
+    DirectConstArg(Box<Expr>),
     /// Sometimes we need a dummy value when no error has occurred.
     Dummy,
     /// Placeholder for a kind that has failed to be defined.
@@ -3066,6 +3062,9 @@ impl FnDecl {
     /// Must have the same value as `FnSigKind::NO_SPLATTED_ARG_INDEX` and `FnDeclFlags::NO_SPLATTED_ARG_INDEX`.
     pub const NO_SPLATTED_ARG_INDEX: u8 = u8::MAX;
 
+    /// The maximum valid splatted argument index.
+    pub const MAX_VALID_SPLATTED_ARG_INDEX: u8 = Self::NO_SPLATTED_ARG_INDEX - 1;
+
     /// Returns a splatted argument index, if any are present.
     pub fn splatted(&self) -> Option<u8> {
         self.inputs.iter().enumerate().find_map(|(index, arg)| {
diff --git a/compiler/rustc_ast/src/tokenstream.rs b/compiler/rustc_ast/src/tokenstream.rs
index baad20a86784d..98caac2c88f77 100644
--- a/compiler/rustc_ast/src/tokenstream.rs
+++ b/compiler/rustc_ast/src/tokenstream.rs
@@ -22,6 +22,9 @@ use crate::ast_traits::{HasAttrs, HasTokens};
 use crate::token::{self, Delimiter, Token, TokenKind};
 use crate::{AttrVec, Attribute};
 
+#[cfg(test)]
+mod tests;
+
 /// Part of a `TokenStream`.
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Encodable, Decodable, StableHash)]
 pub enum TokenTree {
@@ -833,21 +836,18 @@ impl StableHash for TokenStream {
 }
 
 #[derive(Clone)]
-pub struct TokenStreamIter<'t> {
-    stream: &'t TokenStream,
-    index: usize,
-}
+pub struct TokenStreamIter<'t>(std::slice::Iter<'t, TokenTree>);
 
 impl<'t> TokenStreamIter<'t> {
     fn new(stream: &'t TokenStream) -> Self {
-        TokenStreamIter { stream, index: 0 }
+        TokenStreamIter(stream.0.as_slice().iter())
     }
 
     // Peeking could be done via `Peekable`, but most iterators need peeking,
     // and this is simple and avoids the need to use `peekable` and `Peekable`
     // at all the use sites.
     pub fn peek(&self) -> Option<&'t TokenTree> {
-        self.stream.0.get(self.index)
+        self.0.as_slice().first()
     }
 }
 
@@ -855,10 +855,11 @@ impl<'t> Iterator for TokenStreamIter<'t> {
     type Item = &'t TokenTree;
 
     fn next(&mut self) -> Option<&'t TokenTree> {
-        self.stream.0.get(self.index).map(|tree| {
-            self.index += 1;
-            tree
-        })
+        self.0.next()
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.0.size_hint()
     }
 }
 
diff --git a/compiler/rustc_ast/src/tokenstream/tests.rs b/compiler/rustc_ast/src/tokenstream/tests.rs
new file mode 100644
index 0000000000000..6c7e82a97c58e
--- /dev/null
+++ b/compiler/rustc_ast/src/tokenstream/tests.rs
@@ -0,0 +1,13 @@
+use rustc_span::DUMMY_SP;
+
+use crate::token::TokenKind;
+use crate::tokenstream::TokenStream;
+
+#[test]
+fn test_token_stream_iter() {
+    let ts = TokenStream::token_alone(TokenKind::Eq, DUMMY_SP);
+    assert_eq!(ts.len(), 1);
+
+    let iter = ts.iter();
+    assert_eq!(iter.size_hint(), (1, Some(1)));
+}
diff --git a/compiler/rustc_ast/src/util/classify.rs b/compiler/rustc_ast/src/util/classify.rs
index 56f96f9a8a279..0c2218e557f23 100644
--- a/compiler/rustc_ast/src/util/classify.rs
+++ b/compiler/rustc_ast/src/util/classify.rs
@@ -155,6 +155,7 @@ pub fn leading_labeled_expr(mut expr: &ast::Expr) -> bool {
             | Yeet(..)
             | Yield(..)
             | UnsafeBinderCast(..)
+            | DirectConstArg(..)
             | Err(..)
             | Dummy => return false,
         }
@@ -240,6 +241,7 @@ pub fn expr_trailing_brace(mut expr: &ast::Expr) -> Option<TrailingBrace<'_>> {
             | Try(_)
             | Yeet(None)
             | UnsafeBinderCast(..)
+            | DirectConstArg(..)
             | Err(_)
             | Dummy => {
                 break None;
@@ -301,9 +303,10 @@ fn type_trailing_braced_mac_call(mut ty: &ast::Ty) -> Option<&ast::MacCall> {
             | ast::TyKind::CVarArgs
             | ast::TyKind::Pat(..)
             | ast::TyKind::FieldOf(..)
+            | ast::TyKind::View(..)
+            | ast::TyKind::DirectConstArg(..)
             | ast::TyKind::Dummy
-            | ast::TyKind::Err(..)
-            | ast::TyKind::View(..) => break None,
+            | ast::TyKind::Err(..) => break None,
         }
     }
 }
diff --git a/compiler/rustc_ast/src/visit.rs b/compiler/rustc_ast/src/visit.rs
index fb4e76321d150..e25c1a0b31937 100644
--- a/compiler/rustc_ast/src/visit.rs
+++ b/compiler/rustc_ast/src/visit.rs
@@ -418,7 +418,6 @@ macro_rules! common_visitor_and_walkers {
             UnsafeBinderCastKind,
             BinOpKind,
             BlockCheckMode,
-            MgcaDisambiguation,
             BorrowKind,
             BoundAsyncness,
             BoundConstness,
@@ -1074,6 +1073,8 @@ macro_rules! common_visitor_and_walkers {
                     visit_visitable!($($mut)? vis, bytes),
                 ExprKind::UnsafeBinderCast(kind, expr, ty) =>
                     visit_visitable!($($mut)? vis, kind, expr, ty),
+                ExprKind::DirectConstArg(expr) =>
+                    visit_visitable!($($mut)? vis, expr),
                 ExprKind::Err(_guar) => {}
                 ExprKind::Dummy => {}
             }
diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
index f66d1ac16c907..4ed23e032d234 100644
--- a/compiler/rustc_ast_lowering/src/expr.rs
+++ b/compiler/rustc_ast_lowering/src/expr.rs
@@ -498,6 +498,18 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 }
 
                 ExprKind::MacCall(_) => panic!("{:?} shouldn't exist here", e.span),
+
+                ExprKind::DirectConstArg(_) => {
+                    let e = self
+                        .tcx
+                        .dcx()
+                        .struct_span_err(
+                            e.span,
+                            "expected expression, found `direct_const_arg!()` constant",
+                        )
+                        .emit();
+                    hir::ExprKind::Err(e)
+                }
             };
 
             hir::Expr { hir_id: expr_hir_id, kind, span }
@@ -599,11 +611,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         arg
                     };
 
-                let anon_const = AnonConst {
-                    id: node_id,
-                    value: const_value,
-                    mgca_disambiguation: MgcaDisambiguation::AnonConst,
-                };
+                let anon_const = AnonConst { id: node_id, value: const_value };
                 generic_args.push(AngleBracketedArg::Arg(GenericArg::Const(anon_const)));
             } else {
                 real_args.push(arg);
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index dc1acade85ed5..8753897cb53d3 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -1478,6 +1478,16 @@ impl<'hir> LoweringContext<'_, 'hir> {
                             }
                         }
                     }
+                    TyKind::DirectConstArg(expr)
+                        if self.tcx.features().min_generic_const_args() =>
+                    {
+                        let ct = match self.can_lower_expr_to_const_arg_direct(expr) {
+                            Ok(()) => self.lower_expr_to_const_arg_direct(expr, None),
+                            Err(e) => e.emit(self),
+                        };
+                        let ct = self.arena.alloc(ct);
+                        return GenericArg::Const(ct.try_as_ambig_ct().unwrap());
+                    }
                     _ => {}
                 }
                 GenericArg::Type(self.lower_ty_alloc(ty, itctx).try_as_ambig_ty().unwrap())
@@ -1750,9 +1760,18 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 );
                 hir::TyKind::Err(guar)
             }
-            TyKind::View(ty, _) => {
-                // FIXME(scrabsha): lower view types to HIR.
-                return self.lower_ty(ty, itctx);
+            TyKind::View(ty, fields) => {
+                let ty = self.lower_ty_alloc(ty, itctx);
+                let fields = self.arena.alloc_slice(fields);
+                hir::TyKind::View(ty, fields)
+            }
+            TyKind::DirectConstArg(_) => {
+                let e = self
+                    .tcx
+                    .dcx()
+                    .struct_span_err(t.span, "expected type, found `direct_const_arg!()` constant")
+                    .emit();
+                hir::TyKind::Err(e)
             }
             TyKind::Dummy => panic!("`TyKind::Dummy` should never be lowered"),
         };
@@ -2672,23 +2691,86 @@ impl<'hir> LoweringContext<'_, 'hir> {
     }
 
     #[instrument(level = "debug", skip(self), ret)]
-    fn lower_expr_to_const_arg_direct(&mut self, expr: &Expr) -> hir::ConstArg<'hir> {
-        let span = self.lower_span(expr.span);
-
-        let overly_complex_const = |this: &mut Self| {
-            let msg = "complex const arguments must be placed inside of a `const` block";
-            let e = if expr::WillCreateDefIdsVisitor.visit_expr(expr).is_break() {
-                // FIXME(mgca): make this non-fatal once we have a better way to handle
-                // nested items in const args
-                // Issue: https://github.com/rust-lang/rust/issues/154539
-                this.dcx().struct_span_fatal(expr.span, msg).emit()
-            } else {
-                this.dcx().struct_span_err(expr.span, msg).emit()
-            };
+    fn can_lower_expr_to_const_arg_direct(
+        &mut self,
+        expr: &Expr,
+    ) -> Result<(), UnrepresentableConstArgError> {
+        let is_mgca = self.tcx.features().min_generic_const_args();
+        // Note the only stable case is currently ExprKind::Path. All others have an is_mgca guard.
+        match &expr.kind {
+            ExprKind::Call(func, args)
+                if is_mgca && let ExprKind::Path(_qself, _path) = &func.kind =>
+            {
+                for arg in args {
+                    self.can_lower_expr_to_const_arg_direct(arg)?;
+                }
+                Ok(())
+            }
+            ExprKind::Tup(exprs) if is_mgca => {
+                for expr in exprs {
+                    self.can_lower_expr_to_const_arg_direct(expr)?;
+                }
+                Ok(())
+            }
+            ExprKind::Path(qself, path)
+                if is_mgca
+                    || path.is_potential_trivial_const_arg()
+                        && matches!(
+                            self.get_partial_res(expr.id)
+                                .and_then(|partial_res| partial_res.full_res()),
+                            Some(Res::Def(DefKind::ConstParam, _))
+                        ) =>
+            {
+                Ok(())
+            }
+            ExprKind::Struct(se) if is_mgca => {
+                for f in &se.fields {
+                    self.can_lower_expr_to_const_arg_direct(&f.expr)?;
+                }
+                Ok(())
+            }
+            ExprKind::Array(elements) if is_mgca => {
+                for element in elements {
+                    self.can_lower_expr_to_const_arg_direct(element)?;
+                }
+                Ok(())
+            }
+            ExprKind::Underscore if is_mgca => Ok(()),
+            ExprKind::Block(block, _)
+                if is_mgca
+                    && let [stmt] = block.stmts.as_slice()
+                    && let StmtKind::Expr(expr) = &stmt.kind =>
+            {
+                self.can_lower_expr_to_const_arg_direct(expr)
+            }
+            ExprKind::Lit(literal) if is_mgca => Ok(()),
+            ExprKind::Unary(UnOp::Neg, inner_expr)
+                if is_mgca && let ExprKind::Lit(_) = &inner_expr.kind =>
+            {
+                Ok(())
+            }
+            ExprKind::ConstBlock(anon) if is_mgca => Ok(()),
+            ExprKind::DirectConstArg(expr) if is_mgca => {
+                // Always report this as able to be represented directly. If it turns out not to be,
+                // `lower_expr_to_const_arg_direct` will report an error.
+                Ok(())
+            }
+            _ => Err(UnrepresentableConstArgError::new(expr)),
+        }
+    }
 
-            ConstArg { hir_id: this.next_id(), kind: hir::ConstArgKind::Error(e), span }
-        };
+    /// It is not allowed to call this function without checking can_lower_expr_to_const_arg_direct
+    /// first, as we assume all feature gates/etc. have been checked already.
+    #[instrument(level = "debug", skip(self), ret)]
+    fn lower_expr_to_const_arg_direct(
+        &mut self,
+        expr: &Expr,
+        id_override: Option<NodeId>,
+    ) -> hir::ConstArg<'hir> {
+        debug_assert!(self.can_lower_expr_to_const_arg_direct(expr).is_ok());
 
+        let span = self.lower_span(expr.span);
+        let node_id = id_override.unwrap_or(expr.id);
         match &expr.kind {
             ExprKind::Call(func, args) if let ExprKind::Path(qself, path) = &func.kind => {
                 let qpath = self.lower_qpath(
@@ -2702,23 +2784,27 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 );
 
                 let lowered_args = self.arena.alloc_from_iter(args.iter().map(|arg| {
-                    let const_arg = self.lower_expr_to_const_arg_direct(arg);
+                    let const_arg = self.lower_expr_to_const_arg_direct(arg, None);
                     &*self.arena.alloc(const_arg)
                 }));
 
                 ConstArg {
-                    hir_id: self.next_id(),
+                    hir_id: self.lower_node_id(node_id),
                     kind: hir::ConstArgKind::TupleCall(qpath, lowered_args),
                     span,
                 }
             }
             ExprKind::Tup(exprs) => {
                 let exprs = self.arena.alloc_from_iter(exprs.iter().map(|expr| {
-                    let expr = self.lower_expr_to_const_arg_direct(&expr);
+                    let expr = self.lower_expr_to_const_arg_direct(expr, None);
                     &*self.arena.alloc(expr)
                 }));
 
-                ConstArg { hir_id: self.next_id(), kind: hir::ConstArgKind::Tup(exprs), span }
+                ConstArg {
+                    hir_id: self.lower_node_id(node_id),
+                    kind: hir::ConstArgKind::Tup(exprs),
+                    span,
+                }
             }
             ExprKind::Path(qself, path) => {
                 let qpath = self.lower_qpath(
@@ -2732,7 +2818,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     None,
                 );
 
-                ConstArg { hir_id: self.next_id(), kind: hir::ConstArgKind::Path(qpath), span }
+                ConstArg {
+                    hir_id: self.lower_node_id(node_id),
+                    kind: hir::ConstArgKind::Path(qpath),
+                    span,
+                }
             }
             ExprKind::Struct(se) => {
                 let path = self.lower_qpath(
@@ -2754,7 +2844,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     // then go unused as the `Target::ExprField` is not actually
                     // corresponding to `Node::ExprField`.
                     self.lower_attrs(hir_id, &f.attrs, f.span, Target::ExprField);
-                    let expr = self.lower_expr_to_const_arg_direct(&f.expr);
+                    let expr = self.lower_expr_to_const_arg_direct(&f.expr, None);
 
                     &*self.arena.alloc(hir::ConstArgExprField {
                         hir_id,
@@ -2765,14 +2855,14 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 }));
 
                 ConstArg {
-                    hir_id: self.next_id(),
+                    hir_id: self.lower_node_id(node_id),
                     kind: hir::ConstArgKind::Struct(path, fields),
                     span,
                 }
             }
             ExprKind::Array(elements) => {
                 let lowered_elems = self.arena.alloc_from_iter(elements.iter().map(|element| {
-                    let const_arg = self.lower_expr_to_const_arg_direct(element);
+                    let const_arg = self.lower_expr_to_const_arg_direct(element, None);
                     &*self.arena.alloc(const_arg)
                 }));
                 let array_expr = self.arena.alloc(hir::ConstArgArrayExpr {
@@ -2781,31 +2871,28 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 });
 
                 ConstArg {
-                    hir_id: self.next_id(),
+                    hir_id: self.lower_node_id(node_id),
                     kind: hir::ConstArgKind::Array(array_expr),
                     span,
                 }
             }
             ExprKind::Underscore => ConstArg {
-                hir_id: self.lower_node_id(expr.id),
+                hir_id: self.lower_node_id(node_id),
                 kind: hir::ConstArgKind::Infer(()),
                 span,
             },
-            ExprKind::Block(block, _) => {
+            ExprKind::Block(block, _)
                 if let [stmt] = block.stmts.as_slice()
-                    && let StmtKind::Expr(expr) = &stmt.kind
-                {
-                    return self.lower_expr_to_const_arg_direct(expr);
-                }
-
-                overly_complex_const(self)
+                    && let StmtKind::Expr(expr) = &stmt.kind =>
+            {
+                return self.lower_expr_to_const_arg_direct(expr, id_override);
             }
             ExprKind::Lit(literal) => {
                 let span = self.lower_span(expr.span);
                 let literal = self.lower_lit(literal, span);
 
                 ConstArg {
-                    hir_id: self.lower_node_id(expr.id),
+                    hir_id: self.lower_node_id(node_id),
                     kind: hir::ConstArgKind::Literal { lit: literal.node, negated: false },
                     span,
                 }
@@ -2816,29 +2903,45 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 let span = self.lower_span(expr.span);
                 let literal = self.lower_lit(literal, span);
 
-                if !matches!(literal.node, LitKind::Int(..)) {
+                let kind = if !matches!(literal.node, LitKind::Int(..)) {
                     let err =
                         self.dcx().struct_span_err(expr.span, "negated literal must be an integer");
-
-                    return ConstArg {
-                        hir_id: self.next_id(),
-                        kind: hir::ConstArgKind::Error(err.emit()),
-                        span,
-                    };
-                }
-
-                ConstArg {
-                    hir_id: self.lower_node_id(expr.id),
-                    kind: hir::ConstArgKind::Literal { lit: literal.node, negated: true },
-                    span,
-                }
+                    hir::ConstArgKind::Error(err.emit())
+                } else {
+                    hir::ConstArgKind::Literal { lit: literal.node, negated: true }
+                };
+                ConstArg { hir_id: self.lower_node_id(node_id), kind, span }
             }
             ExprKind::ConstBlock(anon_const) => {
+                // Do not use lower_anon_const_to_const_arg, as that attempts to represent the body
+                // directly. Instead, force an anon const.
                 let def_id = self.local_def_id(anon_const.id);
                 assert_eq!(DefKind::InlineConst, self.tcx.def_kind(def_id));
-                self.lower_anon_const_to_const_arg(anon_const, span)
+                let lowered_anon = self.lower_anon_const_to_anon_const(anon_const, span);
+                ConstArg {
+                    hir_id: self.lower_node_id(node_id),
+                    kind: hir::ConstArgKind::Anon(lowered_anon),
+                    span,
+                }
+            }
+            ExprKind::DirectConstArg(expr) => {
+                // `can_lower_expr_to_const_arg_direct` always returns success upon encountering a
+                // ExprKind::DirectConstArg, which effectively forces the expression to be lowered
+                // as a direct arg. If it actually turns out to not be possible, emit an error
+                // instead.
+                match self.can_lower_expr_to_const_arg_direct(expr) {
+                    Ok(()) => self.lower_expr_to_const_arg_direct(expr, id_override),
+                    Err(err) => err.emit(self),
+                }
+            }
+            _ => {
+                span_bug!(
+                    expr.span,
+                    "lower_expr_to_const_arg_direct encountered an unlowerable expression, either \
+                    can_lower_expr_to_const_arg_direct returned Ok() on something it shouldn't \
+                    have, or you forgot to check can_lower_expr_to_const_arg_direct first"
+                );
             }
-            _ => overly_complex_const(self),
         }
     }
 
@@ -2857,67 +2960,23 @@ impl<'hir> LoweringContext<'_, 'hir> {
         anon: &AnonConst,
         span: Span,
     ) -> hir::ConstArg<'hir> {
-        let tcx = self.tcx;
-
-        // We cannot change parsing depending on feature gates available,
-        // we can only require feature gates to be active as a delayed check.
-        // Thus we just parse anon consts generally and make the real decision
-        // making in ast lowering.
-        // FIXME(min_generic_const_args): revisit once stable
-        if tcx.features().min_generic_const_args() {
-            return match anon.mgca_disambiguation {
-                MgcaDisambiguation::AnonConst => {
-                    let lowered_anon = self.lower_anon_const_to_anon_const(anon, span);
-                    ConstArg {
-                        hir_id: self.next_id(),
-                        kind: hir::ConstArgKind::Anon(lowered_anon),
-                        span: lowered_anon.span,
-                    }
-                }
-                MgcaDisambiguation::Direct => self.lower_expr_to_const_arg_direct(&anon.value),
-            };
-        }
-
-        // Unwrap a block, so that e.g. `{ P }` is recognised as a parameter. Const arguments
-        // currently have to be wrapped in curly brackets, so it's necessary to special-case.
-        let expr = if let ExprKind::Block(block, _) = &anon.value.kind
-            && let [stmt] = block.stmts.as_slice()
-            && let StmtKind::Expr(expr) = &stmt.kind
-            && let ExprKind::Path(..) = &expr.kind
-        {
-            expr
-        } else {
+        // Stable only allows one nesting of blocks for directly represented paths. mGCA allows
+        // arbitrarily many, and are handled inside lower_expr_to_const_arg_direct for consistency.
+        let expr = if self.tcx.features().min_generic_const_args() {
             &anon.value
+        } else {
+            anon.value.maybe_unwrap_block()
         };
 
-        let maybe_res =
-            self.get_partial_res(expr.id).and_then(|partial_res| partial_res.full_res());
-        if let ExprKind::Path(qself, path) = &expr.kind
-            && path.is_potential_trivial_const_arg()
-            && matches!(maybe_res, Some(Res::Def(DefKind::ConstParam, _)))
-        {
-            let qpath = self.lower_qpath(
-                expr.id,
-                qself,
-                path,
-                ParamMode::Explicit,
-                AllowReturnTypeNotation::No,
-                ImplTraitContext::Disallowed(ImplTraitPosition::Path),
-                None,
-            );
-
-            return ConstArg {
-                hir_id: self.lower_node_id(anon.id),
-                kind: hir::ConstArgKind::Path(qpath),
-                span: self.lower_span(expr.span),
-            };
+        if self.can_lower_expr_to_const_arg_direct(expr).is_ok() {
+            return self.lower_expr_to_const_arg_direct(expr, Some(anon.id));
         }
 
         let lowered_anon = self.lower_anon_const_to_anon_const(anon, anon.value.span);
         ConstArg {
             hir_id: self.next_id(),
             kind: hir::ConstArgKind::Anon(lowered_anon),
-            span: self.lower_span(expr.span),
+            span: self.lower_span(anon.value.span),
         }
     }
 
@@ -3213,3 +3272,36 @@ impl<'hir> GenericArgsCtor<'hir> {
         this.arena.alloc(ga)
     }
 }
+
+#[derive(Debug)]
+struct UnrepresentableConstArgError {
+    span: Span,
+    will_create_def_ids: bool,
+}
+
+impl UnrepresentableConstArgError {
+    fn new(expr: &Expr) -> Self {
+        Self {
+            span: expr.span,
+            will_create_def_ids: expr::WillCreateDefIdsVisitor.visit_expr(expr).is_break(),
+        }
+    }
+
+    fn emit<'hir>(self, lowering_context: &mut LoweringContext<'_, 'hir>) -> ConstArg<'hir> {
+        let msg = "complex const arguments must be placed inside of a `const` block";
+        let e = if self.will_create_def_ids {
+            // FIXME(mgca): make this non-fatal once we have a better way to handle
+            // nested items in const args
+            // Issue: https://github.com/rust-lang/rust/issues/154539
+            lowering_context.dcx().struct_span_fatal(self.span, msg).emit()
+        } else {
+            lowering_context.dcx().struct_span_err(self.span, msg).emit()
+        };
+
+        ConstArg {
+            hir_id: lowering_context.next_id(),
+            kind: hir::ConstArgKind::Error(e),
+            span: self.span,
+        }
+    }
+}
diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
index 06925994b052c..281f417500c55 100644
--- a/compiler/rustc_ast_passes/src/ast_validation.rs
+++ b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -16,6 +16,7 @@
 //! constructions produced by proc macros. This pass is only intended for simple checks that do not
 //! require name resolution or type checking, or other kinds of complex analysis.
 
+use std::collections::BTreeMap;
 use std::mem;
 use std::str::FromStr;
 
@@ -34,7 +35,7 @@ use rustc_session::lint::builtin::{
     DEPRECATED_WHERE_CLAUSE_LOCATION, MISSING_ABI, MISSING_UNSAFE_ON_EXTERN,
     PATTERNS_IN_FNS_WITHOUT_BODY, UNUSED_VISIBILITIES,
 };
-use rustc_span::{Ident, Span, kw, sym};
+use rustc_span::{Ident, Span, Symbol, kw, sym};
 use rustc_target::spec::{AbiMap, AbiMapping};
 
 use crate::diagnostics::{self, TildeConstReason};
@@ -45,6 +46,41 @@ enum SelfSemantic {
     No,
 }
 
+/// Is `#[splat]` allowed semantically in a function or closure?
+/// Only applies to the function kind and header, the parameters are checked elsewhere.
+enum SplatSemantic {
+    Yes,
+    NoClosures(Span),
+    NoAbiCall { span: Span, abi: Symbol },
+}
+
+impl SplatSemantic {
+    /// Returns if splatting is semantically allowed for the given `FnKind`,
+    /// Only checks the function kind and header, not the parameters.
+    fn from_fn_kind(fk: &FnKind<'_>) -> Self {
+        match fk {
+            FnKind::Fn(_, _, f) => Self::from_extern(f.sig.header.ext),
+            // Splatting closures is banned, because closure arguments are already de-tupled.
+            FnKind::Closure(_, _, _, expr) => SplatSemantic::NoClosures(expr.span),
+        }
+    }
+
+    fn from_extern(ext: Extern) -> Self {
+        match ext {
+            Extern::None => SplatSemantic::Yes,
+            // FIXME(splat): should splatting extern "C" or other ABIs be allowed?
+            Extern::Implicit(_) => SplatSemantic::Yes,
+            // For now, splatting rust-call is banned, because it already de-tuples args.
+            Extern::Explicit(abi_str, span) => match abi_str.symbol_unescaped {
+                sym::rust_dash_call => {
+                    SplatSemantic::NoAbiCall { span, abi: abi_str.symbol_unescaped }
+                }
+                _ => SplatSemantic::Yes,
+            },
+        }
+    }
+}
+
 enum TraitOrImpl {
     Trait { vis: Span, constness: Const },
     TraitImpl { constness: Const, polarity: ImplPolarity, trait_ref_span: Span },
@@ -350,10 +386,15 @@ impl<'a> AstValidator<'a> {
         });
     }
 
-    fn check_fn_decl(&self, fn_decl: &FnDecl, self_semantic: SelfSemantic) {
+    fn check_fn_decl(
+        &self,
+        fn_decl: &FnDecl,
+        self_semantic: SelfSemantic,
+        splat_semantic: SplatSemantic,
+    ) {
         self.check_decl_num_args(fn_decl);
         let c_variadic_span = self.check_decl_cvariadic_pos(fn_decl);
-        self.check_decl_splatting(fn_decl, c_variadic_span);
+        self.check_decl_splatting(fn_decl, c_variadic_span, splat_semantic);
         self.check_decl_attrs(fn_decl);
         self.check_decl_self_param(fn_decl, self_semantic);
     }
@@ -399,42 +440,76 @@ impl<'a> AstValidator<'a> {
     /// Emits an error if a function declaration has more than one splatted argument, with a
     /// C-variadic parameter, or a splat at an unsupported index (for performance).
     /// Example: `fn foo(#[splat] x: (), #[splat] y: ())` will emit an error.
-    fn check_decl_splatting(&self, fn_decl: &FnDecl, c_variadic_span: Option<Span>) {
-        let (splatted_arg_indexes, mut splatted_spans): (Vec<u16>, Vec<Span>) = fn_decl
+    fn check_decl_splatting(
+        &self,
+        fn_decl: &FnDecl,
+        c_variadic_span: Option<Span>,
+        splat_semantic: SplatSemantic,
+    ) {
+        let mut splatted_arg_spans: BTreeMap<u16, Vec<Span>> = fn_decl
             .inputs
             .iter()
             .enumerate()
             .filter_map(|(index, arg)| {
-                arg.attrs
+                let splat_arg_spans: Vec<Span> = arg
+                    .attrs
                     .iter()
-                    .any(|attr| attr.has_name(sym::splat))
-                    .then_some((u16::try_from(index).unwrap(), arg.span))
+                    .filter_map(|attr| attr.has_name(sym::splat).then_some(attr.span))
+                    .collect();
+                if splat_arg_spans.is_empty() {
+                    None
+                } else {
+                    Some((u16::try_from(index).unwrap(), splat_arg_spans))
+                }
             })
-            .unzip();
+            .collect();
 
         // A splatted argument greater than or equal to the "no splatted" marker index is not
-        // supported.
-        if let (Some(&splatted_arg_index), Some(&splatted_span)) =
-            (splatted_arg_indexes.last(), splatted_spans.last())
-            && splatted_arg_index >= u16::from(FnDecl::NO_SPLATTED_ARG_INDEX)
-        {
-            self.dcx().emit_err(diagnostics::InvalidSplattedArg {
-                splatted_arg_index,
-                span: splatted_span,
+        // supported. It is ok to drop these spans after issuing this error, because they are
+        // always invalid.
+        let out_of_range_spans =
+            splatted_arg_spans.split_off(&u16::from(FnDecl::NO_SPLATTED_ARG_INDEX));
+        if !out_of_range_spans.is_empty() {
+            self.dcx().emit_err(diagnostics::InvalidSplattedArgs {
+                max_valid_splatted_arg_index: u16::from(FnDecl::MAX_VALID_SPLATTED_ARG_INDEX),
+                first_invalid_splatted_arg_index: *out_of_range_spans.keys().next().unwrap(),
+                spans: out_of_range_spans.values().flatten().copied().collect(),
             });
         }
 
-        // Multiple splatted arguments are invalid: we can't know which arguments go in each splat.
-        if splatted_arg_indexes.len() > 1 {
-            self.dcx()
-                .emit_err(diagnostics::DuplicateSplattedArgs { spans: splatted_spans.clone() });
-        }
+        if !splatted_arg_spans.is_empty() {
+            let splatted_spans = || splatted_arg_spans.values().flatten().copied().collect();
 
-        if let Some(c_variadic_span) = c_variadic_span
-            && !splatted_spans.is_empty()
-        {
-            splatted_spans.push(c_variadic_span);
-            self.dcx().emit_err(diagnostics::CVarArgsAndSplat { spans: splatted_spans });
+            // Multiple splatted arguments are invalid: we can't know which arguments go in each splat.
+            if splatted_arg_spans.len() > 1 {
+                self.dcx().emit_err(diagnostics::DuplicateSplattedArgs { spans: splatted_spans() });
+            }
+
+            // C-variadic parameters and splats are not allowed together.
+            if let Some(c_variadic_span) = c_variadic_span {
+                let mut splatted_spans = splatted_spans();
+                splatted_spans.push(c_variadic_span);
+                self.dcx().emit_err(diagnostics::CVarArgsAndSplat { spans: splatted_spans });
+            }
+
+            // Splatting is not allowed on closures, or some function ABIs.
+            match splat_semantic {
+                SplatSemantic::NoClosures(closure_span) => {
+                    let mut splatted_spans = splatted_spans();
+                    splatted_spans.push(closure_span);
+                    self.dcx()
+                        .emit_err(diagnostics::SplatNotAllowedOnClosures { spans: splatted_spans });
+                }
+                SplatSemantic::NoAbiCall { span, abi } => {
+                    let mut splatted_spans = splatted_spans();
+                    splatted_spans.push(span);
+                    self.dcx().emit_err(diagnostics::SplatNotAllowedOnAbiCall {
+                        spans: splatted_spans,
+                        abi,
+                    });
+                }
+                SplatSemantic::Yes => {}
+            }
         }
     }
 
@@ -1055,7 +1130,11 @@ impl<'a> AstValidator<'a> {
         match &ty.kind {
             TyKind::FnPtr(bfty) => {
                 self.check_fn_ptr_safety(bfty.decl_span, bfty.safety);
-                self.check_fn_decl(&bfty.decl, SelfSemantic::No);
+                self.check_fn_decl(
+                    &bfty.decl,
+                    SelfSemantic::No,
+                    SplatSemantic::from_extern(bfty.ext),
+                );
                 Self::check_decl_no_pat(&bfty.decl, |span, _, _| {
                     self.dcx().emit_err(diagnostics::PatternFnPointer { span });
                 });
@@ -1746,7 +1825,8 @@ impl Visitor<'_> for AstValidator<'_> {
             Some(FnCtxt::Assoc(_)) => SelfSemantic::Yes,
             _ => SelfSemantic::No,
         };
-        self.check_fn_decl(fk.decl(), self_semantic);
+        let splat_semantic = SplatSemantic::from_fn_kind(&fk);
+        self.check_fn_decl(fk.decl(), self_semantic, splat_semantic);
 
         if let Some(&FnHeader { safety, .. }) = fk.header() {
             self.check_item_safety(span, safety);
diff --git a/compiler/rustc_ast_passes/src/diagnostics.rs b/compiler/rustc_ast_passes/src/diagnostics.rs
index 7a78e8e6213a5..0b610431cadd8 100644
--- a/compiler/rustc_ast_passes/src/diagnostics.rs
+++ b/compiler/rustc_ast_passes/src/diagnostics.rs
@@ -124,18 +124,22 @@ pub(crate) struct FnParamCVarArgsNotLast {
 }
 
 #[derive(Diagnostic)]
-#[diag("`#[splat]` is not supported on argument index {$splatted_arg_index}")]
+#[diag(
+    "`#[splat]` is only supported on argument index {$max_valid_splatted_arg_index} or less, this `#[splat]` is on index {$first_invalid_splatted_arg_index}"
+)]
 #[help("remove `#[splat]`, or use it on an argument closer to the start of the argument list")]
-pub(crate) struct InvalidSplattedArg {
-    pub splatted_arg_index: u16,
+pub(crate) struct InvalidSplattedArgs {
+    pub max_valid_splatted_arg_index: u16,
+
+    pub first_invalid_splatted_arg_index: u16,
 
     #[primary_span]
     #[label("`#[splat]` is not supported here")]
-    pub span: Span,
+    pub spans: Vec<Span>,
 }
 
 #[derive(Diagnostic)]
-#[diag("multiple `#[splat]`s are not allowed in the same function")]
+#[diag("multiple `#[splat]`s are not allowed in the same function argument list")]
 #[help("remove `#[splat]` from all but one argument")]
 pub(crate) struct DuplicateSplattedArgs {
     #[primary_span]
@@ -143,13 +147,30 @@ pub(crate) struct DuplicateSplattedArgs {
 }
 
 #[derive(Diagnostic)]
-#[diag("`...` and `#[splat]` are not allowed in the same function")]
+#[diag("`...` and `#[splat]` are not allowed in the same function argument list")]
 #[help("remove `#[splat]` or remove `...`")]
 pub(crate) struct CVarArgsAndSplat {
     #[primary_span]
     pub spans: Vec<Span>,
 }
 
+#[derive(Diagnostic)]
+#[diag("`#[splat]` is not allowed on closure arguments")]
+#[help("remove `#[splat]` or turn the closure into a function")]
+pub(crate) struct SplatNotAllowedOnClosures {
+    #[primary_span]
+    pub spans: Vec<Span>,
+}
+
+#[derive(Diagnostic)]
+#[diag("`#[splat]` is not allowed in the arguments of functions with the `{$abi}` ABI")]
+#[help("remove `#[splat]` or change the ABI")]
+pub(crate) struct SplatNotAllowedOnAbiCall {
+    #[primary_span]
+    pub spans: Vec<Span>,
+    pub abi: Symbol,
+}
+
 #[derive(Diagnostic)]
 #[diag("documentation comments cannot be applied to function parameters")]
 pub(crate) struct FnParamDocComment {
diff --git a/compiler/rustc_ast_pretty/src/pprust/state.rs b/compiler/rustc_ast_pretty/src/pprust/state.rs
index 106606877e110..bfca18a42635e 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state.rs
@@ -1459,6 +1459,12 @@ impl<'a> State<'a> {
                 self.print_type(ty);
                 self.print_view(fields);
             }
+            ast::TyKind::DirectConstArg(expr) => {
+                self.word_nbsp("core::direct_const_arg!");
+                self.popen();
+                self.print_expr(expr, FixupContext::default());
+                self.pclose();
+            }
         }
         self.end(ib);
     }
diff --git a/compiler/rustc_ast_pretty/src/pprust/state/expr.rs b/compiler/rustc_ast_pretty/src/pprust/state/expr.rs
index 176e91e544ec5..4f3281641359d 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state/expr.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state/expr.rs
@@ -883,6 +883,12 @@ impl<'a> State<'a> {
                 self.word("/*DUMMY*/");
                 self.pclose();
             }
+            ast::ExprKind::DirectConstArg(expr) => {
+                self.word_nbsp("core::direct_const_arg!");
+                self.popen();
+                self.print_expr(expr, FixupContext::default());
+                self.pclose()
+            }
         }
 
         self.ann.post(self, AnnNode::Expr(expr));
diff --git a/compiler/rustc_builtin_macros/src/assert/context.rs b/compiler/rustc_builtin_macros/src/assert/context.rs
index f15acc154baf3..1bc2bc8342559 100644
--- a/compiler/rustc_builtin_macros/src/assert/context.rs
+++ b/compiler/rustc_builtin_macros/src/assert/context.rs
@@ -323,6 +323,7 @@ impl<'cx, 'a> Context<'cx, 'a> {
             | ExprKind::Yeet(_)
             | ExprKind::Become(_)
             | ExprKind::Yield(_)
+            | ExprKind::DirectConstArg(_)
             | ExprKind::UnsafeBinderCast(..) => {}
         }
     }
diff --git a/compiler/rustc_builtin_macros/src/autodiff.rs b/compiler/rustc_builtin_macros/src/autodiff.rs
index 311a24280cfb7..bd5bf3a687d92 100644
--- a/compiler/rustc_builtin_macros/src/autodiff.rs
+++ b/compiler/rustc_builtin_macros/src/autodiff.rs
@@ -16,7 +16,7 @@ mod llvm_enzyme {
     use rustc_ast::{
         self as ast, AngleBracketedArg, AngleBracketedArgs, AnonConst, AssocItemKind, BindingMode,
         FnRetTy, FnSig, GenericArg, GenericArgs, GenericParamKind, Generics, ItemKind,
-        MetaItemInner, MgcaDisambiguation, PatKind, Path, PathSegment, TyKind, Visibility,
+        MetaItemInner, PatKind, Path, PathSegment, TyKind, Visibility,
     };
     use rustc_expand::base::{Annotatable, ExtCtxt};
     use rustc_hir::attrs::RustcAutodiff;
@@ -602,11 +602,7 @@ mod llvm_enzyme {
                 }
                 GenericParamKind::Const { .. } => {
                     let expr = ecx.expr_path(ast::Path::from_ident(p.ident));
-                    let anon_const = AnonConst {
-                        id: ast::DUMMY_NODE_ID,
-                        value: expr,
-                        mgca_disambiguation: MgcaDisambiguation::Direct,
-                    };
+                    let anon_const = AnonConst { id: ast::DUMMY_NODE_ID, value: expr };
                     Some(AngleBracketedArg::Arg(GenericArg::Const(anon_const)))
                 }
                 GenericParamKind::Lifetime { .. } => None,
@@ -861,7 +857,6 @@ mod llvm_enzyme {
                     let anon_const = rustc_ast::AnonConst {
                         id: ast::DUMMY_NODE_ID,
                         value: ecx.expr_usize(span, 1 + x.width as usize),
-                        mgca_disambiguation: MgcaDisambiguation::Direct,
                     };
                     TyKind::Array(ty.clone(), anon_const)
                 };
@@ -876,7 +871,6 @@ mod llvm_enzyme {
                     let anon_const = rustc_ast::AnonConst {
                         id: ast::DUMMY_NODE_ID,
                         value: ecx.expr_usize(span, x.width as usize),
-                        mgca_disambiguation: MgcaDisambiguation::Direct,
                     };
                     let kind = TyKind::Array(ty.clone(), anon_const);
                     let ty =
diff --git a/compiler/rustc_builtin_macros/src/direct_const_arg.rs b/compiler/rustc_builtin_macros/src/direct_const_arg.rs
new file mode 100644
index 0000000000000..51c169134e03f
--- /dev/null
+++ b/compiler/rustc_builtin_macros/src/direct_const_arg.rs
@@ -0,0 +1,39 @@
+use rustc_ast::ast;
+use rustc_ast::tokenstream::TokenStream;
+use rustc_expand::base::{self, DummyResult, ExpandResult, ExtCtxt, MacroExpanderResult};
+use rustc_span::Span;
+
+use crate::util::get_single_expr_from_tts;
+
+pub(crate) fn expand<'cx>(
+    cx: &'cx mut ExtCtxt<'_>,
+    span: Span,
+    tts: TokenStream,
+) -> MacroExpanderResult<'cx> {
+    let ExpandResult::Ready(expr) = get_single_expr_from_tts(cx, span, tts, "direct_const_arg!")
+    else {
+        return ExpandResult::Retry(());
+    };
+    let expr = match expr {
+        Ok(expr) => expr,
+        Err(err) => return ExpandResult::Ready(DummyResult::any(span, err)),
+    };
+
+    let id = ast::DUMMY_NODE_ID;
+    ExpandResult::Ready(Box::new(base::MacEager {
+        expr: Some(Box::new(ast::Expr {
+            id,
+            kind: ast::ExprKind::DirectConstArg(expr.clone()),
+            span,
+            attrs: Default::default(),
+            tokens: None,
+        })),
+        ty: Some(Box::new(ast::Ty {
+            id,
+            kind: ast::TyKind::DirectConstArg(expr),
+            span,
+            tokens: None,
+        })),
+        ..Default::default()
+    }))
+}
diff --git a/compiler/rustc_builtin_macros/src/lib.rs b/compiler/rustc_builtin_macros/src/lib.rs
index bd99b269ef5b6..78bf7d97bd7b8 100644
--- a/compiler/rustc_builtin_macros/src/lib.rs
+++ b/compiler/rustc_builtin_macros/src/lib.rs
@@ -34,6 +34,7 @@ mod define_opaque;
 mod derive;
 mod deriving;
 mod diagnostics;
+mod direct_const_arg;
 mod edition_panic;
 mod eii;
 mod env;
@@ -81,6 +82,7 @@ pub fn register_builtin_macros(resolver: &mut dyn ResolverExpand) {
         concat_bytes: concat_bytes::expand_concat_bytes,
         const_format_args: format::expand_format_args,
         core_panic: edition_panic::expand_panic,
+        direct_const_arg: direct_const_arg::expand,
         env: env::expand_env,
         file: source_util::expand_file,
         format_args: format::expand_format_args,
diff --git a/compiler/rustc_builtin_macros/src/pattern_type.rs b/compiler/rustc_builtin_macros/src/pattern_type.rs
index 53ab3fcd9b34b..065ba9f6a2096 100644
--- a/compiler/rustc_builtin_macros/src/pattern_type.rs
+++ b/compiler/rustc_builtin_macros/src/pattern_type.rs
@@ -1,5 +1,5 @@
 use rustc_ast::tokenstream::TokenStream;
-use rustc_ast::{AnonConst, DUMMY_NODE_ID, MgcaDisambiguation, Ty, TyPat, TyPatKind, ast, token};
+use rustc_ast::{AnonConst, DUMMY_NODE_ID, Ty, TyPat, TyPatKind, ast, token};
 use rustc_errors::PResult;
 use rustc_expand::base::{self, DummyResult, ExpandResult, ExtCtxt, MacroExpanderResult};
 use rustc_parse::exp;
@@ -60,20 +60,8 @@ fn ty_pat(kind: TyPatKind, span: Span) -> TyPat {
 fn pat_to_ty_pat(cx: &mut ExtCtxt<'_>, pat: ast::Pat) -> TyPat {
     let kind = match pat.kind {
         ast::PatKind::Range(start, end, include_end) => TyPatKind::Range(
-            start.map(|value| {
-                Box::new(AnonConst {
-                    id: DUMMY_NODE_ID,
-                    value,
-                    mgca_disambiguation: MgcaDisambiguation::Direct,
-                })
-            }),
-            end.map(|value| {
-                Box::new(AnonConst {
-                    id: DUMMY_NODE_ID,
-                    value,
-                    mgca_disambiguation: MgcaDisambiguation::Direct,
-                })
-            }),
+            start.map(|value| Box::new(AnonConst { id: DUMMY_NODE_ID, value })),
+            end.map(|value| Box::new(AnonConst { id: DUMMY_NODE_ID, value })),
             include_end,
         ),
         ast::PatKind::Or(variants) => {
diff --git a/compiler/rustc_codegen_gcc/src/builder.rs b/compiler/rustc_codegen_gcc/src/builder.rs
index 0bef86b1ae8c1..da17f05bb8a32 100644
--- a/compiler/rustc_codegen_gcc/src/builder.rs
+++ b/compiler/rustc_codegen_gcc/src/builder.rs
@@ -1155,7 +1155,7 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
         // NOTE: libgccjit does not support specifying the alignment on the assignment, so we cast
         // to type so it gets the proper alignment.
         let destination_type = destination.to_rvalue().get_type().unqualified();
-        let align = if flags.contains(MemFlags::UNALIGNED) { 1 } else { align.bytes() };
+        let align = align.bytes();
         let mut modified_destination_type = destination_type.get_aligned(align);
         if flags.contains(MemFlags::VOLATILE) {
             modified_destination_type = modified_destination_type.make_volatile();
diff --git a/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs b/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
index a5b8068e0f018..06fbd287435d6 100644
--- a/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
+++ b/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
@@ -377,16 +377,6 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tc
                     load
                 }
             }
-            sym::volatile_store => {
-                let dst = args[0].deref(self.cx());
-                args[1].val.volatile_store(self, dst);
-                return IntrinsicResult::WroteIntoPlace;
-            }
-            sym::unaligned_volatile_store => {
-                let dst = args[0].deref(self.cx());
-                args[1].val.unaligned_volatile_store(self, dst);
-                return IntrinsicResult::WroteIntoPlace;
-            }
             sym::prefetch_read_data
             | sym::prefetch_write_data
             | sym::prefetch_read_instruction
diff --git a/compiler/rustc_codegen_llvm/src/builder.rs b/compiler/rustc_codegen_llvm/src/builder.rs
index e753fff61aa41..95380e4cb7533 100644
--- a/compiler/rustc_codegen_llvm/src/builder.rs
+++ b/compiler/rustc_codegen_llvm/src/builder.rs
@@ -871,8 +871,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         unsafe {
             let store = llvm::LLVMBuildStore(self.llbuilder, val, ptr);
             let align = align.min(self.cx().tcx.sess.target.max_reliable_alignment());
-            let align =
-                if flags.contains(MemFlags::UNALIGNED) { 1 } else { align.bytes() as c_uint };
+            let align = align.bytes() as c_uint;
             llvm::LLVMSetAlignment(store, align);
             if flags.contains(MemFlags::VOLATILE) {
                 llvm::LLVMSetVolatile(store, llvm::TRUE);
diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs
index 54456ddea620b..24e9a6cb3e2d4 100644
--- a/compiler/rustc_codegen_llvm/src/intrinsic.rs
+++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs
@@ -3,8 +3,8 @@ use std::ffi::c_uint;
 use std::{assert_matches, iter, ptr};
 
 use rustc_abi::{
-    AddressSpace, Align, BackendRepr, CVariadicStatus, Float, HasDataLayout, Integer,
-    NumScalableVectors, Primitive, Size, WrappingRange,
+    AddressSpace, Align, BackendRepr, CVariadicStatus, Float, HasDataLayout, NumScalableVectors,
+    Primitive, Size, WrappingRange,
 };
 use rustc_codegen_ssa::RetagInfo;
 use rustc_codegen_ssa::base::{compare_simd_types, wants_msvc_seh, wants_wasm_eh};
@@ -315,11 +315,6 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                     Primitive::Pointer(_) => {
                         // Pointers are always OK.
                     }
-                    Primitive::Int(Integer::I128, _) => {
-                        // FIXME: maybe we should support these? At least on 32-bit powerpc
-                        // the logic in LLVM does not handle i128 correctly though.
-                        bug!("the va_arg intrinsic does not support `i128`/`u128`")
-                    }
                     Primitive::Int(..) => {
                         let int_width = self.cx().size_of(result_layout.ty).bits();
                         let target_c_int_width = self.cx().sess().target.options.c_int_width;
@@ -389,16 +384,6 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                     };
                 }
             }
-            sym::volatile_store => {
-                let dst = args[0].deref(self.cx());
-                args[1].val.volatile_store(self, dst);
-                return IntrinsicResult::Operand(OperandValue::ZeroSized);
-            }
-            sym::unaligned_volatile_store => {
-                let dst = args[0].deref(self.cx());
-                args[1].val.unaligned_volatile_store(self, dst);
-                return IntrinsicResult::Operand(OperandValue::ZeroSized);
-            }
             sym::prefetch_read_data
             | sym::prefetch_write_data
             | sym::prefetch_read_instruction
diff --git a/compiler/rustc_codegen_llvm/src/va_arg.rs b/compiler/rustc_codegen_llvm/src/va_arg.rs
index d2583f94cf80c..a64452dbc5a7e 100644
--- a/compiler/rustc_codegen_llvm/src/va_arg.rs
+++ b/compiler/rustc_codegen_llvm/src/va_arg.rs
@@ -1,5 +1,6 @@
-use rustc_abi::{Align, BackendRepr, CVariadicStatus, Endian, HasDataLayout, Primitive, Size};
-use rustc_codegen_ssa::MemFlags;
+use rustc_abi::{
+    Align, BackendRepr, CVariadicStatus, Endian, Float, HasDataLayout, Integer, Primitive, Size,
+};
 use rustc_codegen_ssa::common::IntPredicate;
 use rustc_codegen_ssa::mir::operand::OperandRef;
 use rustc_codegen_ssa::traits::{
@@ -77,6 +78,35 @@ fn emit_direct_ptr_va_arg<'ll, 'tcx>(
     }
 }
 
+/// Some backends apply special alignment rules to c-variadic arguments.
+fn get_param_type_alignment<'ll, 'tcx>(
+    bx: &mut Builder<'_, 'll, 'tcx>,
+    layout: TyAndLayout<'tcx>,
+) -> Align {
+    let BackendRepr::Scalar(scalar) = layout.backend_repr else {
+        bug!("unexpected backend repr {:?}", layout.backend_repr);
+    };
+
+    match bx.cx.tcx.sess.target.arch {
+        Arch::PowerPC64 => match scalar.primitive() {
+            Primitive::Int(integer, _) => match integer {
+                Integer::I8 | Integer::I16 => unreachable!(),
+                Integer::I32 | Integer::I64 => { /* fall through */ }
+                Integer::I128 => return Align::EIGHT,
+            },
+            Primitive::Float(float) => match float {
+                Float::F16 | Float::F32 => unreachable!(),
+                Float::F64 => { /* fall through */ }
+                Float::F128 => return Align::from_bytes(16).unwrap(),
+            },
+            Primitive::Pointer(_) => { /* fall through */ }
+        },
+        _ => { /* fall through */ }
+    }
+
+    layout.align.abi
+}
+
 enum PassMode {
     Direct,
     Indirect,
@@ -136,23 +166,23 @@ fn emit_ptr_va_arg<'ll, 'tcx>(
         (
             bx.cx.layout_of(Ty::new_imm_ptr(bx.cx.tcx, target_ty)).llvm_type(bx.cx),
             bx.cx.data_layout().pointer_size(),
-            bx.cx.data_layout().pointer_align(),
+            bx.cx.data_layout().pointer_align().abi,
         )
     } else {
-        (layout.llvm_type(bx.cx), layout.size, layout.align)
+        (layout.llvm_type(bx.cx), layout.size, get_param_type_alignment(bx, layout))
     };
     let (addr, addr_align) = emit_direct_ptr_va_arg(
         bx,
         list,
         size,
-        align.abi,
+        align,
         slot_size,
         allow_higher_align,
         force_right_adjust,
     );
     if indirect {
         let tmp_ret = bx.load(llty, addr, addr_align);
-        bx.load(layout.llvm_type(bx.cx), tmp_ret, align.abi)
+        bx.load(layout.llvm_type(bx.cx), tmp_ret, align)
     } else {
         bx.load(llty, addr, addr_align)
     }
@@ -585,8 +615,10 @@ fn emit_x86_64_sysv64_va_arg<'ll, 'tcx>(
     // registers. In the case: l->gp_offset > 48 - num_gp * 8 or
     // l->fp_offset > 176 - num_fp * 16 go to step 7.
 
+    // We support x86_64-unknown-linux-gnux32 which uses 4-byte pointers.
     let unsigned_int_offset = 4;
-    let ptr_offset = 8;
+    let ptr_offset = bx.tcx().data_layout.pointer_size().bytes();
+
     let gp_offset_ptr = va_list_addr;
     let fp_offset_ptr = bx.inbounds_ptradd(va_list_addr, bx.cx.const_usize(unsigned_int_offset));
 
@@ -660,7 +692,7 @@ fn emit_x86_64_sysv64_va_arg<'ll, 'tcx>(
                     let reg_hi_addr = bx.inbounds_ptradd(reg_lo_addr, bx.const_i32(16));
 
                     let align = layout.layout.align().abi;
-                    let tmp = bx.alloca(layout.layout.size(), align);
+                    let tmp = bx.alloca(layout.size, layout.align.abi);
 
                     let reg_lo = bx.load(ty_lo, reg_lo_addr, align_lo);
                     let reg_hi = bx.load(ty_hi, reg_hi_addr, align_hi);
@@ -682,7 +714,7 @@ fn emit_x86_64_sysv64_va_arg<'ll, 'tcx>(
                         Primitive::Int(_, _) | Primitive::Pointer(_) => (gp_addr, fp_addr),
                     };
 
-                    let tmp = bx.alloca(layout.layout.size(), layout.layout.align().abi);
+                    let tmp = bx.alloca(layout.size, layout.align.abi);
 
                     let reg_lo = bx.load(ty_lo, reg_lo_addr, align_lo);
                     let reg_hi = bx.load(ty_hi, reg_hi_addr, align_hi);
@@ -749,16 +781,12 @@ fn copy_to_temporary_if_more_aligned<'ll, 'tcx>(
     src_align: Align,
 ) -> &'ll Value {
     if layout.layout.align.abi > src_align {
-        let tmp = bx.alloca(layout.layout.size(), layout.layout.align().abi);
-        bx.memcpy(
-            tmp,
-            layout.layout.align.abi,
-            reg_addr,
-            src_align,
-            bx.const_u32(layout.layout.size().bytes() as u32),
-            MemFlags::empty(),
-            None,
-        );
+        assert!(layout.ty.is_integral());
+
+        // A memcpy below optimizes poorly for 128-bit integers.
+        let tmp = bx.alloca(layout.size, layout.align.abi);
+        let val = bx.load(layout.llvm_type(bx), reg_addr, src_align);
+        bx.store(val, tmp, layout.align.abi);
         tmp
     } else {
         reg_addr
@@ -780,9 +808,14 @@ fn x86_64_sysv64_va_arg_from_memory<'ll, 'tcx>(
     // byte boundary if alignment needed by type exceeds 8 byte boundary.
     // It isn't stated explicitly in the standard, but in practice we use
     // alignment greater than 16 where necessary.
-    if layout.layout.align.bytes() > 8 {
-        unreachable!("all instances of VaArgSafe have an alignment <= 8");
-    }
+    // The AMD64 psABI leaves unspecified what to do for alignments above 16, but
+    // this behavior for 32+ alignment matches clang.
+    // It currently (2026 July) can only occur for 16-byte-aligned types.
+    let overflow_arg_area_v = if layout.layout.align.bytes() > 8 {
+        round_pointer_up_to_alignment(bx, overflow_arg_area_v, layout.layout.align.abi)
+    } else {
+        overflow_arg_area_v
+    };
 
     // AMD64-ABI 3.5.7p5: Step 8. Fetch type from l->overflow_arg_area.
     let mem_addr = overflow_arg_area_v;
@@ -1052,9 +1085,15 @@ pub(super) fn emit_va_arg<'ll, 'tcx>(
             bx,
             addr,
             target_ty,
-            PassMode::Direct,
+            // MS x64 ABI requirement: "Any argument that doesn't fit in 8 bytes, or is
+            // not 1, 2, 4, or 8 bytes, must be passed by reference."
+            if target_ty_size > 8 || !target_ty_size.is_power_of_two() {
+                PassMode::Indirect
+            } else {
+                PassMode::Direct
+            },
             SlotSize::Bytes8,
-            if target.is_like_windows { AllowHigherAlign::No } else { AllowHigherAlign::Yes },
+            AllowHigherAlign::No,
             ForceRightAdjust::No,
         ),
         Arch::AArch64 if target.is_like_windows || target.is_like_darwin => emit_ptr_va_arg(
@@ -1063,13 +1102,14 @@ pub(super) fn emit_va_arg<'ll, 'tcx>(
             target_ty,
             PassMode::Direct,
             SlotSize::Bytes8,
-            if target.is_like_windows { AllowHigherAlign::No } else { AllowHigherAlign::Yes },
+            AllowHigherAlign::Yes,
             ForceRightAdjust::No,
         ),
         Arch::AArch64 => emit_aapcs_va_arg(bx, addr, target_ty),
         Arch::Arm => {
             // Types wider than 16 bytes are not currently supported. Clang has special logic for
-            // such types, but `VaArgSafe` is not implemented for any type that is this large.
+            // such types, but `VaArgSafe` is not implemented for any type that is this large on
+            // arm (i.e. 32-bit) targets.
             assert!(bx.cx.size_of(target_ty).bytes() <= 16);
 
             emit_ptr_va_arg(
@@ -1091,6 +1131,7 @@ pub(super) fn emit_va_arg<'ll, 'tcx>(
             PassMode::Direct,
             SlotSize::Bytes8,
             AllowHigherAlign::Yes,
+            // ForceRightAdjust only takes effect on big-endian architectures.
             ForceRightAdjust::Yes,
         ),
         Arch::RiscV32 if target.llvm_abiname == LlvmAbi::Ilp32e => {
diff --git a/compiler/rustc_codegen_ssa/src/lib.rs b/compiler/rustc_codegen_ssa/src/lib.rs
index 200f6aac12502..994c761a5901e 100644
--- a/compiler/rustc_codegen_ssa/src/lib.rs
+++ b/compiler/rustc_codegen_ssa/src/lib.rs
@@ -163,11 +163,12 @@ pub enum ModuleKind {
 }
 
 bitflags::bitflags! {
+    /// This previously had an `UNALIGNED` variant, but that should never be done via flags.
+    /// If you want something to be unaligned, see [`mir::place::PlaceRef::unaligned`].
     #[derive(Debug, Clone, Copy, PartialEq, Eq)]
     pub struct MemFlags: u8 {
         const VOLATILE = 1 << 0;
         const NONTEMPORAL = 1 << 1;
-        const UNALIGNED = 1 << 2;
         /// Indicates that writing through the stored pointer is undefined behavior.
         /// Only valid on stores of pointers, or pairs where the first element is a pointer.
         /// In the latter case, the flag only applies to the first element of the pair.
diff --git a/compiler/rustc_codegen_ssa/src/mir/intrinsic.rs b/compiler/rustc_codegen_ssa/src/mir/intrinsic.rs
index 413cb5f2c860a..6116c0fa9eb98 100644
--- a/compiler/rustc_codegen_ssa/src/mir/intrinsic.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/intrinsic.rs
@@ -273,16 +273,12 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 );
                 OperandValue::ZeroSized
             }
-            sym::volatile_store => {
+            sym::volatile_store | sym::unaligned_volatile_store => {
                 let dst = args[0].deref(bx.cx());
+                let dst = if name == sym::volatile_store { dst } else { dst.unaligned() };
                 args[1].val.volatile_store(bx, dst);
                 OperandValue::ZeroSized
             }
-            sym::unaligned_volatile_store => {
-                let dst = args[0].deref(bx.cx());
-                args[1].val.unaligned_volatile_store(bx, dst);
-                OperandValue::ZeroSized
-            }
             sym::disjoint_bitor => {
                 let a = args[0].immediate();
                 let b = args[1].immediate();
diff --git a/compiler/rustc_codegen_ssa/src/mir/operand.rs b/compiler/rustc_codegen_ssa/src/mir/operand.rs
index f2594b712d8cd..c53dd38a3af5e 100644
--- a/compiler/rustc_codegen_ssa/src/mir/operand.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/operand.rs
@@ -974,14 +974,6 @@ impl<'a, 'tcx, V: CodegenObject> OperandValue<V> {
         self.store_with_flags(bx, dest, MemFlags::VOLATILE);
     }
 
-    pub fn unaligned_volatile_store<Bx: BuilderMethods<'a, 'tcx, Value = V>>(
-        self,
-        bx: &mut Bx,
-        dest: PlaceRef<'tcx, V>,
-    ) {
-        self.store_with_flags(bx, dest, MemFlags::VOLATILE | MemFlags::UNALIGNED);
-    }
-
     pub fn nontemporal_store<Bx: BuilderMethods<'a, 'tcx, Value = V>>(
         self,
         bx: &mut Bx,
diff --git a/compiler/rustc_codegen_ssa/src/mir/place.rs b/compiler/rustc_codegen_ssa/src/mir/place.rs
index 50166609670b6..b592e4a339346 100644
--- a/compiler/rustc_codegen_ssa/src/mir/place.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/place.rs
@@ -318,6 +318,13 @@ impl<'a, 'tcx, V: CodegenObject> PlaceRef<'tcx, V> {
     pub fn storage_dead<Bx: BuilderMethods<'a, 'tcx, Value = V>>(&self, bx: &mut Bx) {
         bx.lifetime_end(self.val.llval, self.layout.size);
     }
+
+    /// The same place, but with [`PlaceValue::align`] lowered to [`Align::ONE`].
+    pub fn unaligned(self) -> Self {
+        let Self { val, layout } = self;
+        let val = PlaceValue { align: Align::ONE, ..val };
+        Self { val, layout }
+    }
 }
 
 impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
diff --git a/compiler/rustc_expand/src/build.rs b/compiler/rustc_expand/src/build.rs
index 01886a97f55a2..f3792d4d45235 100644
--- a/compiler/rustc_expand/src/build.rs
+++ b/compiler/rustc_expand/src/build.rs
@@ -2,8 +2,8 @@ use rustc_ast::token::Delimiter;
 use rustc_ast::tokenstream::TokenStream;
 use rustc_ast::util::literal;
 use rustc_ast::{
-    self as ast, AnonConst, AttrItem, AttrVec, BlockCheckMode, Expr, LocalKind, MatchKind,
-    MgcaDisambiguation, PatKind, UnOp, attr, token, tokenstream,
+    self as ast, AnonConst, AttrItem, AttrVec, BlockCheckMode, Expr, LocalKind, MatchKind, PatKind,
+    UnOp, attr, token, tokenstream,
 };
 use rustc_span::{DUMMY_SP, Ident, Span, Spanned, Symbol, kw, sym};
 use thin_vec::{ThinVec, thin_vec};
@@ -100,7 +100,6 @@ impl<'a> ExtCtxt<'a> {
                 attrs: AttrVec::new(),
                 tokens: None,
             }),
-            mgca_disambiguation: MgcaDisambiguation::Direct,
         }
     }
 
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index ee401376a6a5c..236ccca1a517e 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -3960,6 +3960,8 @@ pub enum TyKind<'hir, Unambig = ()> {
     ///
     /// The optional ident is the variant when an enum is passed `field_of!(Enum, Variant.field)`.
     FieldOf(&'hir Ty<'hir>, &'hir TyFieldPath),
+    /// A view of a type. `T.{ field_1, field_2 }`.
+    View(&'hir Ty<'hir>, &'hir [Ident]),
     /// `TyKind::Infer` means the type should be inferred instead of it having been
     /// specified. This can appear anywhere in a type.
     ///
diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs
index 44501b1aa892b..df410d680f533 100644
--- a/compiler/rustc_hir/src/intravisit.rs
+++ b/compiler/rustc_hir/src/intravisit.rs
@@ -1053,6 +1053,12 @@ pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty<'v, AmbigArg>) -
             visit_opt!(visitor, visit_ident, *variant);
             try_visit!(visitor.visit_ident(*field));
         }
+        TyKind::View(ty, fields) => {
+            try_visit!(visitor.visit_ty_unambig(ty));
+            for field in fields {
+                try_visit!(visitor.visit_ident(*field));
+            }
+        }
     }
     V::Result::output()
 }
diff --git a/compiler/rustc_hir_analysis/src/coherence/builtin.rs b/compiler/rustc_hir_analysis/src/coherence/builtin.rs
index 4ff870b405e5a..ecc7b170818d2 100644
--- a/compiler/rustc_hir_analysis/src/coherence/builtin.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/builtin.rs
@@ -34,44 +34,30 @@ pub(super) fn check_trait<'tcx>(
     impl_def_id: LocalDefId,
     impl_header: ty::ImplTraitHeader<'tcx>,
 ) -> Result<(), ErrorGuaranteed> {
-    let lang_items = tcx.lang_items();
-    let checker = Checker { tcx, trait_def_id, impl_def_id, impl_header };
-    checker.check(lang_items.drop_trait(), visit_implementation_of_drop)?;
-    checker.check(lang_items.async_drop_trait(), visit_implementation_of_drop)?;
-    checker.check(lang_items.copy_trait(), visit_implementation_of_copy)?;
-    checker.check(lang_items.unpin_trait(), visit_implementation_of_unpin)?;
-    checker.check(lang_items.const_param_ty_trait(), |checker| {
-        visit_implementation_of_const_param_ty(checker)
-    })?;
-    checker.check(lang_items.coerce_unsized_trait(), visit_implementation_of_coerce_unsized)?;
-    checker.check(lang_items.reborrow(), visit_implementation_of_reborrow)?;
-    checker.check(lang_items.coerce_shared(), visit_implementation_of_coerce_shared)?;
-    checker
-        .check(lang_items.dispatch_from_dyn_trait(), visit_implementation_of_dispatch_from_dyn)?;
-    checker.check(
-        lang_items.coerce_pointee_validated_trait(),
-        visit_implementation_of_coerce_pointee_validity,
-    )?;
-    Ok(())
+    let checker = Checker { tcx, impl_def_id, impl_header };
+    match tcx.as_lang_item(trait_def_id) {
+        Some(LangItem::Drop) => visit_implementation_of_drop(&checker),
+        Some(LangItem::AsyncDrop) => visit_implementation_of_drop(&checker),
+        Some(LangItem::Copy) => visit_implementation_of_copy(&checker),
+        Some(LangItem::Unpin) => visit_implementation_of_unpin(&checker),
+        Some(LangItem::ConstParamTy) => visit_implementation_of_const_param_ty(&checker),
+        Some(LangItem::CoerceUnsized) => visit_implementation_of_coerce_unsized(&checker),
+        Some(LangItem::Reborrow) => visit_implementation_of_reborrow(&checker),
+        Some(LangItem::CoerceShared) => visit_implementation_of_coerce_shared(&checker),
+        Some(LangItem::DispatchFromDyn) => visit_implementation_of_dispatch_from_dyn(&checker),
+        Some(LangItem::CoercePointeeValidated) => {
+            visit_implementation_of_coerce_pointee_validity(&checker)
+        }
+        _ => Ok(()),
+    }
 }
 
 struct Checker<'tcx> {
     tcx: TyCtxt<'tcx>,
-    trait_def_id: DefId,
     impl_def_id: LocalDefId,
     impl_header: ty::ImplTraitHeader<'tcx>,
 }
 
-impl<'tcx> Checker<'tcx> {
-    fn check(
-        &self,
-        trait_def_id: Option<DefId>,
-        f: impl FnOnce(&Self) -> Result<(), ErrorGuaranteed>,
-    ) -> Result<(), ErrorGuaranteed> {
-        if Some(self.trait_def_id) == trait_def_id { f(self) } else { Ok(()) }
-    }
-}
-
 fn visit_implementation_of_drop(checker: &Checker<'_>) -> Result<(), ErrorGuaranteed> {
     let tcx = checker.tcx;
     let impl_did = checker.impl_def_id;
diff --git a/compiler/rustc_hir_analysis/src/collect/generics_of.rs b/compiler/rustc_hir_analysis/src/collect/generics_of.rs
index 811ed83e0bf48..d6a5db4c22f24 100644
--- a/compiler/rustc_hir_analysis/src/collect/generics_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/generics_of.rs
@@ -214,6 +214,17 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
             "synthetic HIR should have its `generics_of` explicitly fed"
         ),
 
+        Node::ConstArg(..) => {
+            // These can show up in mGCA when representing "direct" const arguments. The
+            // DefCollector cannot know whether an anon const will be represented by an actual HIR
+            // Node::AnonConst, or whether it will be represented directly, so it must generate a
+            // DefId. If it ends up being direct, this DefId is then attached to the top-level
+            // ConstArg, which is what we are seeing here.
+            debug_assert!(tcx.features().min_generic_const_args());
+            // Forward to the real parent.
+            Some(tcx.local_parent(def_id))
+        }
+
         _ => span_bug!(tcx.def_span(def_id), "generics_of: unexpected node kind {node:?}"),
     };
 
diff --git a/compiler/rustc_hir_analysis/src/delegation.rs b/compiler/rustc_hir_analysis/src/delegation.rs
index 58474f0ee2e38..40adfeadc4411 100644
--- a/compiler/rustc_hir_analysis/src/delegation.rs
+++ b/compiler/rustc_hir_analysis/src/delegation.rs
@@ -4,7 +4,7 @@
 
 use std::debug_assert_matches;
 
-use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::{DelegationSelfTyPropagationKind, PathSegment};
@@ -21,6 +21,7 @@ type RemapTable = FxHashMap<u32, u32>;
 struct ParamIndexRemapper<'tcx> {
     tcx: TyCtxt<'tcx>,
     remap_table: RemapTable,
+    delegation_parent_consts: FxHashSet<ty::ParamConst>,
 }
 
 impl<'tcx> TypeFolder<TyCtxt<'tcx>> for ParamIndexRemapper<'tcx> {
@@ -337,7 +338,7 @@ fn create_generic_args<'tcx>(
     delegation_id: LocalDefId,
     mut parent_args: &[ty::GenericArg<'tcx>],
     mut child_args: &[ty::GenericArg<'tcx>],
-) -> Vec<ty::GenericArg<'tcx>> {
+) -> (Vec<ty::GenericArg<'tcx>>, &'tcx [ty::GenericArg<'tcx>]) {
     let delegation_generics = tcx.generics_of(delegation_id);
     let delegation_args = ty::GenericArgs::identity_for_item(tcx, delegation_id);
 
@@ -389,7 +390,7 @@ fn create_generic_args<'tcx>(
     let zero_self = zero_self.as_ref().into_iter();
     let after_lifetimes_self = after_lifetimes_self.as_ref().into_iter();
 
-    zero_self
+    let args = zero_self
         .chain(delegation_parent_args)
         .chain(parent_args.iter().filter(|a| a.as_region().is_some()))
         .chain(child_args.iter().filter(|a| a.as_region().is_some()))
@@ -398,7 +399,9 @@ fn create_generic_args<'tcx>(
         .chain(child_args.iter().filter(|a| a.as_region().is_none()))
         .chain(synth_args)
         .copied()
-        .collect::<Vec<_>>()
+        .collect::<Vec<_>>();
+
+    (args, delegation_parent_args)
 }
 
 pub(crate) fn inherit_predicates_for_delegation_item<'tcx>(
@@ -434,6 +437,44 @@ pub(crate) fn inherit_predicates_for_delegation_item<'tcx>(
                     continue;
                 }
 
+                // If we have a constant in parent or child args that came from delegation
+                // parent:
+                // ```rust
+                // trait Trait<T, const B: bool> { /* .. */}
+                // impl<const N: usize> S<N> {
+                //     reuse Trait::<S<N>, N>::foo;
+                // }
+                // ```
+                // Then if we inherit const predicate from `Trait` then we end up with
+                // two `ConstArgHasType` for `N` constant:
+                // 1) ConstArgHasType(N/#0, bool) from `Trait`
+                // 2) ConstArgHasType(N/#0, usize) from delegation parent
+                // So in case the constant came from delegation parent we will not inherit
+                // ConstArgHasType from signature.
+                // The check is so complicated because we build generic args for signature
+                // and predicates inheritance, for the example above it will be
+                // `args = [S<N/#0>, N/#0, S<N/#0>, N/#0]`, where
+                // args[0] - Self type, args[1] - delegation parent const, args[2] - first
+                // arg of callee path, args[3] - second arg of callee path.
+                // When processing predicate ConstArgHasType(B/#2, bool)
+                // from delegation signature (`Trait::foo`), we need to map `B/#2` into some
+                // arg from `args`. The mapping which is built by `create_mapping` function is:
+                // `{0: 0, 2: 3, 1: 2}`, so as `B/#2` has index `2` it is mapped into third
+                // arg from `args` - `N/#0`. After we obtained mapped const param, we check if
+                // it came from delegation parent, and if so we do not process its `ConstArgHasType`
+                // predicate.
+                // (Issue #158675).
+                if let ty::PredicateKind::Clause(ty::ClauseKind::ConstArgHasType(ct, _)) =
+                    pred.0.as_predicate().fold_with(&mut self.folder).kind().skip_binder()
+                {
+                    let unnorm_const = EarlyBinder::bind(self.tcx, ct).instantiate(self.tcx, args);
+                    if let ty::ConstKind::Param(param) = unnorm_const.skip_norm_wip().kind()
+                        && self.folder.delegation_parent_consts.contains(&param)
+                    {
+                        continue;
+                    }
+                }
+
                 let new_pred = pred.0.fold_with(&mut self.folder);
                 self.preds.push((
                     EarlyBinder::bind(self.tcx, new_pred)
@@ -497,10 +538,21 @@ fn create_folder_and_args<'tcx>(
     parent_args: &'tcx [ty::GenericArg<'tcx>],
     child_args: &'tcx [ty::GenericArg<'tcx>],
 ) -> (ParamIndexRemapper<'tcx>, Vec<ty::GenericArg<'tcx>>) {
-    let args = create_generic_args(tcx, sig_id, def_id, parent_args, child_args);
+    let (args, delegation_parent_args) =
+        create_generic_args(tcx, sig_id, def_id, parent_args, child_args);
+
     let remap_table = create_mapping(tcx, sig_id, def_id);
 
-    (ParamIndexRemapper { tcx, remap_table }, args)
+    let delegation_parent_consts = delegation_parent_args
+        .iter()
+        .filter_map(|a| {
+            a.as_const().and_then(|c| {
+                if let ty::ConstKind::Param(param) = c.kind() { Some(param) } else { None }
+            })
+        })
+        .collect();
+
+    (ParamIndexRemapper { tcx, remap_table, delegation_parent_consts }, args)
 }
 
 fn check_constraints<'tcx>(
diff --git a/compiler/rustc_hir_analysis/src/diagnostics.rs b/compiler/rustc_hir_analysis/src/diagnostics.rs
index 1bfc495071284..a671b02b5fa66 100644
--- a/compiler/rustc_hir_analysis/src/diagnostics.rs
+++ b/compiler/rustc_hir_analysis/src/diagnostics.rs
@@ -2000,3 +2000,33 @@ impl<G: EmissionGuarantee> Diagnostic<'_, G> for UncoveredTyParam<'_> {
         diag
     }
 }
+
+#[derive(Diagnostic)]
+#[diag("field `{$name}` is already part of the view")]
+pub(crate) struct ViewedFieldIsAlreadyPartOfTheView {
+    #[primary_span]
+    pub span: Span,
+    pub name: Symbol,
+    #[label("field `{$name}` is declared as viewed here")]
+    pub previous_field_span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag("only structs can be viewed")]
+pub(crate) struct OnlyStructsCanBeViewedNonAdt<'tcx> {
+    #[primary_span]
+    #[label("type `{$ty}` cannot be viewed")]
+    pub span: Span,
+    pub ty: Ty<'tcx>,
+}
+
+#[derive(Diagnostic)]
+#[diag("only structs can be viewed")]
+pub(crate) struct OnlyStructsCanBeViewedAdt<'tcx> {
+    #[primary_span]
+    #[label("`{$ty}` is {$article} {$kind}, it cannot be viewed")]
+    pub span: Span,
+    pub ty: Ty<'tcx>,
+    pub article: &'static str,
+    pub kind: &'static str,
+}
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
index 2b0219f356c3c..7409ea620228d 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -51,7 +51,7 @@ use rustc_trait_selection::traits::{self, FulfillmentError};
 use tracing::{debug, instrument};
 
 use crate::check::check_abi;
-use crate::diagnostics::{BadReturnTypeNotation, NoFieldOnType};
+use crate::diagnostics::{self, BadReturnTypeNotation, NoFieldOnType};
 use crate::hir_ty_lowering::errors::{GenericsArgsErrExtend, prohibit_assoc_item_constraint};
 use crate::hir_ty_lowering::generics::{check_generic_arg_count, lower_generic_args};
 use crate::middle::resolve_bound_vars as rbv;
@@ -3401,6 +3401,10 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 *variant,
                 *field,
             ),
+            hir::TyKind::View(ty, fields) => {
+                self.lower_view(self.lower_ty(ty), fields, hir_ty.span)
+            }
+
             hir::TyKind::Err(guar) => Ty::new_error(tcx, *guar),
         };
 
@@ -3812,4 +3816,73 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         let adt_ty = Ty::new_adt(tcx, adt_def, args);
         ty::Const::new_value(tcx, valtree, adt_ty)
     }
+
+    fn lower_view(&self, inner_ty: Ty<'tcx>, fields: &[Ident], ty_span: Span) -> Ty<'tcx> {
+        // Step 1: check that every field is unique, and keep a list of field that we know are
+        // unique.
+        let mut viewed_fields = Vec::<Ident>::with_capacity(fields.len());
+
+        for f in fields {
+            let f = f.normalize_to_macros_2_0();
+            // PERF: this is quadratic, but ~fine since the amount of fields is very low.
+            if let Some(previous_field_span) =
+                viewed_fields.iter().find_map(|f_| (*f_ == f).then_some(f_.span))
+            {
+                self.dcx().emit_err(diagnostics::ViewedFieldIsAlreadyPartOfTheView {
+                    name: f.name,
+                    span: f.span,
+                    previous_field_span,
+                });
+                continue;
+            }
+            viewed_fields.push(f);
+        }
+
+        // Step 2: check that the viewed type is a struct.
+        let variant = match inner_ty.kind() {
+            ty::Adt(def, _) if def.is_struct() => def.non_enum_variant(),
+
+            ty::Adt(def, _) => {
+                let guar = self.dcx().emit_err(diagnostics::OnlyStructsCanBeViewedAdt {
+                    ty: inner_ty,
+                    span: ty_span,
+                    article: def.article(),
+                    kind: def.descr(),
+                });
+                return Ty::new_error(self.tcx(), guar);
+            }
+
+            _ => {
+                let guar = self.dcx().emit_err(diagnostics::OnlyStructsCanBeViewedNonAdt {
+                    ty: inner_ty,
+                    span: ty_span,
+                });
+                return Ty::new_error(self.tcx(), guar);
+            }
+        };
+
+        // Step 3: check that every viewed field exists.
+        let mut viewed_indices = Vec::with_capacity(viewed_fields.len());
+        let mut error = None;
+        for field in viewed_fields {
+            let Some((_, field)) = variant
+                .fields
+                .iter_enumerated()
+                .find(|(_, f)| f.ident(self.tcx()).normalize_to_macros_2_0() == field)
+            else {
+                let err =
+                    self.dcx().emit_err(NoFieldOnType { span: field.span, field, ty: inner_ty });
+                error = Some(err);
+                continue;
+            };
+
+            viewed_indices.push(field);
+        }
+        if let Some(guar) = error {
+            return Ty::new_error(self.tcx(), guar);
+        }
+
+        // FIXME(scrabsha): actually lower view types.
+        inner_ty
+    }
 }
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
index 136fe22eea60f..447ad2447b3b9 100644
--- a/compiler/rustc_hir_pretty/src/lib.rs
+++ b/compiler/rustc_hir_pretty/src/lib.rs
@@ -476,6 +476,17 @@ impl<'a> State<'a> {
                 self.print_ident(*field);
                 self.word(")");
             }
+            hir::TyKind::View(ty, fields) => {
+                self.word("view_type!(");
+                self.print_type(ty);
+                self.word(".{");
+                if !fields.is_empty() {
+                    self.space();
+                    self.commasep(Breaks::Inconsistent, fields, |s, f| s.print_ident(*f));
+                    self.space();
+                }
+                self.word("})");
+            }
         }
         self.end(ib)
     }
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
index 1b6f366b9d133..e7b25dec4db59 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
@@ -299,7 +299,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 formal_input_tys,
                 provided_args,
                 expected_input_tys,
-                c_variadic,
                 tuple_arguments,
                 fn_def_id,
                 callee_generic_args,
@@ -573,10 +572,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         provided_args: &'tcx [hir::Expr<'tcx>],
         // The expected input types from the context of the call site
         mut expected_input_tys: Option<Vec<Ty<'tcx>>>,
-        // Whether the function is variadic (e.g. from C)
-        c_variadic: bool,
-        // Whether all the arguments have been bundled in a tuple (ex: closures).
-        // Splatting is handled separately.
+        // Whether all the arguments have been bundled in a tuple (ex: closures), or one has been splatted
         tuple_arguments: TupleArgumentsFlag,
         // The DefId for the function being called, for better error messages
         fn_def_id: Option<DefId>,
@@ -592,6 +588,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 untupled_expected_input_tys: expected_input_tys,
             };
         };
+        let first_tupled_arg_index_usz = usize::from(first_tupled_arg_index);
 
         // The argument difference can range from -1 to u16::MAX - 1, so we count the number
         // of tupled arguments instead.
@@ -604,28 +601,28 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         let tupled_args_count = (1 + provided_args.len()).checked_sub(formal_input_tys.len());
         debug!(
             ?first_tupled_arg_index, ?is_self_splatted,
-            ?tupled_args_count, ?tuple_arguments, ?c_variadic,
+            ?tupled_args_count, ?tuple_arguments,
             provided_args_len = ?provided_args.len(), formal_input_tys_len = ?formal_input_tys.len()
         );
 
         // If earlier code has modified the FnSig argument list without adjusting the splatted
         // argument, indexing into the formal input types will panic.
-        if first_tupled_arg_index >= formal_input_tys.len() {
+        if first_tupled_arg_index_usz >= formal_input_tys.len() {
             span_bug!(
                 call_span,
                 "splatted argument index is out of bounds: {first_tupled_arg_index:?} >= {}, \
                 is_self_splatted = {is_self_splatted:?}, \
                 tupled_args_count = {tupled_args_count:?}, {tuple_arguments:?}, \
-                c_variadic = {c_variadic:?}, provided_args: {}",
+                provided_args: {}",
                 formal_input_tys.len(),
                 provided_args.len(),
             );
         }
 
+        let formal_input_tupled_ty = formal_input_tys[first_tupled_arg_index_usz];
         // Keep the type variable if the argument is splatted, so we can force it to be a tuple later.
         let tuple_type = if tuple_arguments.is_splatted() {
-            let callee_tuple_type =
-                self.resolve_vars_with_obligations(formal_input_tys[first_tupled_arg_index]);
+            let callee_tuple_type = self.resolve_vars_with_obligations(formal_input_tupled_ty);
             if callee_tuple_type.is_ty_var()
                 && let Some(tupled_args_count) = tupled_args_count
             {
@@ -674,7 +671,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 callee_tuple_type
             }
         } else {
-            self.structurally_resolve_type(call_span, formal_input_tys[first_tupled_arg_index])
+            self.structurally_resolve_type(call_span, formal_input_tupled_ty)
         };
 
         // We expected a tuple and got a tuple (or made one ourselves).
@@ -687,7 +684,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 err_code = Some(E0057);
             }
             if let Some(ref mut expected_input_tys) = expected_input_tys
-                && let Some(ty) = expected_input_tys.get(first_tupled_arg_index)
+                && let Some(ty) = expected_input_tys.get(first_tupled_arg_index_usz)
                 && let ty::Tuple(detup_expected_arg_tys) = ty.kind()
             {
                 let substitute_tys = if Some(detup_expected_arg_tys.len()) == tupled_args_count {
@@ -697,26 +694,15 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     detup_formal_arg_tys.iter()
                 };
 
-                expected_input_tys
-                    .splice(first_tupled_arg_index..=first_tupled_arg_index, substitute_tys);
+                expected_input_tys.splice(
+                    first_tupled_arg_index_usz..=first_tupled_arg_index_usz,
+                    substitute_tys,
+                );
             } else {
                 expected_input_tys = None;
             }
-            // If splatting, record this call in a side-table, so MIR lowering can tuple the caller's arguments
-            if tuple_arguments.is_splatted() {
-                // FIXME(const_trait_impl): does not enforce constness yet
-                self.write_splatted_call(
-                    call_expr.hir_id,
-                    call_span,
-                    fn_def_id,
-                    callee_generic_args,
-                    first_tupled_arg_index.try_into().unwrap(),
-                    tupled_args_count.unwrap().try_into().unwrap(),
-                );
-            }
-
             formal_input_tys.splice(
-                first_tupled_arg_index..=first_tupled_arg_index,
+                first_tupled_arg_index_usz..=first_tupled_arg_index_usz,
                 detup_formal_arg_tys.iter(),
             );
             if let Some(ref expected_input_tys) = expected_input_tys {
@@ -724,7 +710,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     formal_input_tys.len(),
                     expected_input_tys.len(),
                     "incorrectly constructed input type tuples, argument counts must match: \
-                    tuple_arguments: {tuple_arguments:?}",
+                    tuple_arguments: {tuple_arguments:?}, \
+                    first_tupled_arg_index: {first_tupled_arg_index}",
                 )
             }
         }
@@ -751,7 +738,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     let spans = if let Some(def_id) = fn_def_id
                         && let Some(hir_node) = self.tcx.hir_get_if_local(def_id)
                         && let Some(fn_decl) = hir_node.fn_decl()
-                        && let Some(arg_ty) = fn_decl.inputs.get(first_tupled_arg_index)
+                        && let Some(arg_ty) = fn_decl.inputs.get(first_tupled_arg_index_usz)
                     {
                         let arg_def_span = arg_ty.span;
                         vec![call_span, arg_def_span]
@@ -768,7 +755,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         tuple_type.kind(),
                         self.structurally_resolve_type(
                             call_span,
-                            formal_input_tys[first_tupled_arg_index]
+                            formal_input_tys[first_tupled_arg_index_usz]
                         )
                         .kind(),
                     )
@@ -803,6 +790,19 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 untupled_expected_input_tys: None,
             }
         } else {
+            // If splatting, record this call in a side-table, so MIR lowering can tuple the caller's arguments
+            if tuple_arguments.is_splatted() {
+                // FIXME(const_trait_impl): does not enforce constness yet
+                self.write_splatted_call(
+                    call_expr.hir_id,
+                    call_span,
+                    fn_def_id,
+                    callee_generic_args,
+                    first_tupled_arg_index,
+                    tupled_args_count.unwrap().try_into().unwrap(),
+                );
+            }
+
             TupledArgCheckOutcome {
                 new_err_code: err_code,
                 untupled_formal_input_tys: formal_input_tys,
diff --git a/compiler/rustc_hir_typeck/src/lib.rs b/compiler/rustc_hir_typeck/src/lib.rs
index 6b5f084fc3dbe..85fdb9b6fe450 100644
--- a/compiler/rustc_hir_typeck/src/lib.rs
+++ b/compiler/rustc_hir_typeck/src/lib.rs
@@ -666,9 +666,9 @@ impl TupleArgumentsFlag {
 
     /// Returns the tupled argument index, and whether the `self` argument is splatted.
     /// Returns `None` if the arguments are not tupled, or if the `self` argument is splatted.
-    fn tupled_arg_index(self) -> (Option<usize>, bool /* is_self_splatted */) {
+    fn tupled_arg_index(self) -> (Option<u16>, bool /* is_self_splatted */) {
         match self {
-            Self::TupleSplattedArg(index) => (Some(usize::from(index)), false),
+            Self::TupleSplattedArg(index) => (Some(u16::from(index)), false),
             Self::TupleAllCallArgs => (Some(0), false),
             Self::TupleSplattedSelfArg => (None, true),
             Self::DontTupleArguments => (None, false),
diff --git a/compiler/rustc_index_macros/src/newtype.rs b/compiler/rustc_index_macros/src/newtype.rs
index 14fd147f96780..076dc4c6f81e5 100644
--- a/compiler/rustc_index_macros/src/newtype.rs
+++ b/compiler/rustc_index_macros/src/newtype.rs
@@ -152,13 +152,15 @@ impl Parse for Newtype {
                     }
                 }
                 impl ::std::cmp::Ord for #name {
+                    #[inline]
                     fn cmp(&self, other: &Self) -> std::cmp::Ordering {
                         self.as_u32().cmp(&other.as_u32())
                     }
                 }
                 impl ::std::cmp::PartialOrd for #name {
+                    #[inline]
                     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-                        self.as_u32().partial_cmp(&other.as_u32())
+                        Some(self.cmp(other))
                     }
                 }
             }
diff --git a/compiler/rustc_infer/src/infer/relate/generalize.rs b/compiler/rustc_infer/src/infer/relate/generalize.rs
index ee6e13250e709..12c577d3a50e2 100644
--- a/compiler/rustc_infer/src/infer/relate/generalize.rs
+++ b/compiler/rustc_infer/src/infer/relate/generalize.rs
@@ -5,10 +5,7 @@ use rustc_data_structures::stack::ensure_sufficient_stack;
 use rustc_hir::def_id::DefId;
 use rustc_middle::bug;
 use rustc_middle::ty::error::TypeError;
-use rustc_middle::ty::{
-    self, InferConst, Term, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitableExt,
-    TypeVisitor,
-};
+use rustc_middle::ty::{self, InferConst, Term, Ty, TyCtxt, TypeVisitableExt};
 use rustc_span::Span;
 use tracing::{debug, instrument, warn};
 
@@ -362,45 +359,6 @@ impl<'tcx> InferCtxt<'tcx> {
     }
 }
 
-/// Finds the max universe present
-struct MaxUniverse {
-    max_universe: ty::UniverseIndex,
-}
-
-impl MaxUniverse {
-    fn new() -> Self {
-        MaxUniverse { max_universe: ty::UniverseIndex::ROOT }
-    }
-
-    fn max_universe(self) -> ty::UniverseIndex {
-        self.max_universe
-    }
-}
-
-impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for MaxUniverse {
-    fn visit_ty(&mut self, t: Ty<'tcx>) {
-        if let ty::Placeholder(placeholder) = t.kind() {
-            self.max_universe = self.max_universe.max(placeholder.universe);
-        }
-
-        t.super_visit_with(self)
-    }
-
-    fn visit_const(&mut self, c: ty::Const<'tcx>) {
-        if let ty::ConstKind::Placeholder(placeholder) = c.kind() {
-            self.max_universe = self.max_universe.max(placeholder.universe);
-        }
-
-        c.super_visit_with(self)
-    }
-
-    fn visit_region(&mut self, r: ty::Region<'tcx>) {
-        if let ty::RePlaceholder(placeholder) = r.kind() {
-            self.max_universe = self.max_universe.max(placeholder.universe);
-        }
-    }
-}
-
 /// The "generalizer" is used when handling inference variables.
 ///
 /// The basic strategy for handling a constraint like `?A <: B` is to
@@ -511,10 +469,9 @@ impl<'tcx> Generalizer<'_, 'tcx> {
                 if is_nested_alias {
                     return Err(e);
                 } else {
-                    let mut visitor = MaxUniverse::new();
-                    alias.visit_with(&mut visitor);
+                    let alias_max_universe = ty::max_universe_of_placeholders(self.infcx, alias);
                     let infer_replacement_is_complete =
-                        self.for_universe.can_name(visitor.max_universe())
+                        self.for_universe.can_name(alias_max_universe)
                             && !alias.has_escaping_bound_vars();
                     if !infer_replacement_is_complete {
                         warn!("may incompletely handle alias type: {alias:?}");
diff --git a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
index fe5b8edce4a1d..e4807f10805c9 100644
--- a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
@@ -49,6 +49,9 @@
 #include "llvm/Transforms/Instrumentation/RealtimeSanitizer.h"
 #include "llvm/Transforms/Instrumentation/ThreadSanitizer.h"
 #include "llvm/Transforms/Scalar/AnnotationRemarks.h"
+#if LLVM_VERSION_GE(23, 0)
+#include "llvm/Transforms/Utils/AssignGUID.h"
+#endif
 #include "llvm/Transforms/Utils/CanonicalizeAliases.h"
 #include "llvm/Transforms/Utils/FunctionImportUtils.h"
 #include "llvm/Transforms/Utils/NameAnonGlobals.h"
@@ -934,6 +937,9 @@ extern "C" LLVMRustResult LLVMRustOptimize(
     if (NeedThinLTOBufferPasses) {
       MPM.addPass(CanonicalizeAliasesPass());
       MPM.addPass(NameAnonGlobalPass());
+#if LLVM_VERSION_GE(23, 0)
+      MPM.addPass(AssignGUIDPass());
+#endif
     }
     // For `-Copt-level=0`, and the pre-link fat/thin LTO stages.
     if (ThinLTOBufferRef && *ThinLTOBufferRef == nullptr) {
@@ -1475,6 +1481,9 @@ extern "C" LLVMRustBuffer *LLVMRustModuleSerialize(LLVMModuleRef M,
         PB.registerLoopAnalyses(LAM);
         PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
         ModulePassManager MPM;
+#if LLVM_VERSION_GE(23, 0)
+        MPM.addPass(AssignGUIDPass());
+#endif
         MPM.addPass(ThinLTOBitcodeWriterPass(OS, nullptr));
         MPM.run(*unwrap(M), MAM);
       } else {
diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs
index 16a5a6c8877a5..6a7942a2bad29 100644
--- a/compiler/rustc_metadata/src/rmeta/encoder.rs
+++ b/compiler/rustc_metadata/src/rmeta/encoder.rs
@@ -1108,7 +1108,7 @@ fn should_encode_mir(
         // instance_mir uses mir_for_ctfe rather than optimized_mir for constructors
         DefKind::Ctor(_, _) => (true, false),
         // Constants
-        DefKind::AnonConst { .. }
+        DefKind::AnonConst
         | DefKind::InlineConst
         | DefKind::AssocConst { .. }
         | DefKind::Const { .. } => (true, false),
@@ -1438,27 +1438,11 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
             // for trivial const arguments which are directly lowered to
             // `ConstArgKind::Path`. We never actually access this `DefId`
             // anywhere so we don't need to encode it for other crates.
+            // FIXME(mgca): This probably isn't true, they probably are accessed, but, test case?
             if def_kind == DefKind::AnonConst
-                && match tcx.hir_node_by_def_id(local_id) {
-                    hir::Node::ConstArg(hir::ConstArg { kind, .. }) => match kind {
-                        // Skip encoding defs for these as they should not have had a `DefId` created
-                        hir::ConstArgKind::Error(..)
-                        | hir::ConstArgKind::Struct(..)
-                        | hir::ConstArgKind::Array(..)
-                        | hir::ConstArgKind::TupleCall(..)
-                        | hir::ConstArgKind::Tup(..)
-                        | hir::ConstArgKind::Path(..)
-                        | hir::ConstArgKind::Literal { .. }
-                        | hir::ConstArgKind::Infer(..) => true,
-                        hir::ConstArgKind::Anon(..) => false,
-                    },
-                    _ => false,
-                }
+                && matches!(tcx.hir_node_by_def_id(local_id), hir::Node::ConstArg(_))
             {
-                // MGCA doesn't have unnecessary DefIds
-                if !tcx.features().min_generic_const_args() {
-                    continue;
-                }
+                continue;
             }
 
             if def_kind == DefKind::Field
diff --git a/compiler/rustc_middle/src/ty/adt.rs b/compiler/rustc_middle/src/ty/adt.rs
index d380b7f522636..a0daa04844e03 100644
--- a/compiler/rustc_middle/src/ty/adt.rs
+++ b/compiler/rustc_middle/src/ty/adt.rs
@@ -335,6 +335,17 @@ impl From<AdtKind> for DataTypeKind {
     }
 }
 
+impl AdtKind {
+    pub fn article(self) -> &'static str {
+        match self {
+            AdtKind::Struct => "a",
+            // https://english.stackexchange.com/a/266324
+            AdtKind::Union => "a",
+            AdtKind::Enum => "an",
+        }
+    }
+}
+
 impl AdtDefData {
     /// Creates a new `AdtDefData`.
     pub(super) fn new(
@@ -455,6 +466,14 @@ impl<'tcx> AdtDef<'tcx> {
         }
     }
 
+    /// Returns a description of this abstract data type with the article.
+    pub fn article(self) -> &'static str {
+        match self.adt_kind() {
+            AdtKind::Struct | AdtKind::Union => "a",
+            AdtKind::Enum => "an",
+        }
+    }
+
     /// Returns a description of a variant of this abstract data type.
     #[inline]
     pub fn variant_descr(self) -> &'static str {
diff --git a/compiler/rustc_mir_build/src/thir/cx/expr.rs b/compiler/rustc_mir_build/src/thir/cx/expr.rs
index c286c0819aea2..650dcf61c66ac 100644
--- a/compiler/rustc_mir_build/src/thir/cx/expr.rs
+++ b/compiler/rustc_mir_build/src/thir/cx/expr.rs
@@ -1225,26 +1225,50 @@ impl<'tcx> ThirBuildCx<'tcx> {
             self.typeck_results.splatted_def(expr.hir_id).unwrap_or_else(|| {
                 span_bug!(expr.span, "no splatted def for function or method callee")
             });
-        let def_id = def_id.unwrap_or_else(|| {
-            span_bug!(expr.span, "no splatted def for function or method callee")
-        });
-        let def_kind = self.tcx.def_kind(def_id);
-        let user_ty = self.user_args_applied_to_res(expr.hir_id, Res::Def(def_kind, def_id));
-        debug!(
-            "splatted_callee: user_ty={:?} def_kind={:?} def_id={:?} arg_index={:?} arg_count={:?}",
-            user_ty, def_kind, def_id, arg_index, arg_count
-        );
 
-        (
+        let expr = if let Some(def_id) = def_id {
+            // We're calling a function via a FnDef, and its possibly generic type
+            let def_kind = self.tcx.def_kind(def_id);
+            let user_ty = self.user_args_applied_to_res(expr.hir_id, Res::Def(def_kind, def_id));
+            debug!(
+                "splatted_callee FnDef: user_ty={:?} def_kind={:?} def_id={:?} arg_index={:?} arg_count={:?}",
+                user_ty, def_kind, def_id, arg_index, arg_count,
+            );
+
             Expr {
                 temp_scope_id: expr.hir_id.local_id,
+                // Create a new FnDef type, representing the splatted function arguments with
+                // user-supplied generic types applied
                 ty: Ty::new_fn_def(self.tcx, def_id, self.typeck_results.node_args(expr.hir_id)),
                 span,
                 kind: ExprKind::ZstLiteral { user_ty },
-            },
-            arg_index,
-            arg_count,
-        )
+            }
+        } else {
+            // We're calling a function via a FnPtr and its type
+            // FIXME(splat): populate the side-tables for FnPtrs, using liberated_fn_sigs if needed
+            let fn_ty = self.typeck_results.expr_ty_adjusted(expr);
+            let user_ty =
+                self.typeck_results.user_provided_types().get(expr.hir_id).copied().map(Box::new);
+            debug!(
+                "splatted_callee FnPtr: user_ty={:?} fn_ty={:?} arg_index={:?} arg_count={:?}",
+                user_ty, fn_ty, arg_index, arg_count,
+            );
+
+            if !fn_ty.is_fn() {
+                span_bug!(expr.span, "splatted FnPtr side-tables are not yet implemented")
+            }
+
+            Expr {
+                temp_scope_id: expr.hir_id.local_id,
+                // Create a new FnPtr FnSig type, representing the splatted function arguments with
+                // user-supplied generic types applied
+                ty: Ty::new_fn_ptr(self.tcx, fn_ty.fn_sig(self.tcx)),
+                span,
+                kind: ExprKind::ZstLiteral { user_ty },
+            }
+        };
+
+        (expr, arg_index, arg_count)
     }
 
     /// The callee has a splatted tuple argument.
diff --git a/compiler/rustc_next_trait_solver/src/normalize.rs b/compiler/rustc_next_trait_solver/src/normalize.rs
index 761b141202d98..959e18071bb57 100644
--- a/compiler/rustc_next_trait_solver/src/normalize.rs
+++ b/compiler/rustc_next_trait_solver/src/normalize.rs
@@ -3,9 +3,8 @@ use std::fmt::Debug;
 use rustc_type_ir::data_structures::ensure_sufficient_stack;
 use rustc_type_ir::inherent::*;
 use rustc_type_ir::{
-    self as ty, AliasTerm, Binder, FallibleTypeFolder, InferConst, InferCtxtLike, InferTy,
-    Interner, TypeFoldable, TypeSuperFoldable, TypeSuperVisitable, TypeVisitable, TypeVisitableExt,
-    TypeVisitor, UniverseIndex,
+    self as ty, AliasTerm, Binder, FallibleTypeFolder, InferCtxtLike, Interner, TypeFoldable,
+    TypeSuperFoldable, TypeVisitableExt, UniverseIndex,
 };
 use tracing::instrument;
 
@@ -37,72 +36,6 @@ pub enum NormalizationWasAmbiguous {
     No,
 }
 
-/// Finds the max universe present in infer vars.
-struct MaxUniverse<'a, Infcx, I>
-where
-    Infcx: InferCtxtLike<Interner = I>,
-    I: Interner,
-{
-    infcx: &'a Infcx,
-    max_universe: ty::UniverseIndex,
-}
-
-impl<'a, Infcx, I> MaxUniverse<'a, Infcx, I>
-where
-    Infcx: InferCtxtLike<Interner = I>,
-    I: Interner,
-{
-    fn new(infcx: &'a Infcx) -> Self {
-        MaxUniverse { infcx, max_universe: ty::UniverseIndex::ROOT }
-    }
-
-    fn max_universe(self) -> ty::UniverseIndex {
-        self.max_universe
-    }
-}
-
-impl<'a, Infcx, I> TypeVisitor<I> for MaxUniverse<'a, Infcx, I>
-where
-    Infcx: InferCtxtLike<Interner = I>,
-    I: Interner,
-{
-    type Result = ();
-
-    fn visit_ty(&mut self, t: I::Ty) {
-        if !t.has_infer() {
-            return;
-        }
-
-        if let ty::Infer(InferTy::TyVar(vid)) = t.kind() {
-            // We shallow resolved the infer var before.
-            // So it should be a unresolved infer var with an universe.
-            self.max_universe = self.max_universe.max(self.infcx.universe_of_ty(vid).unwrap());
-        }
-
-        t.super_visit_with(self)
-    }
-
-    fn visit_const(&mut self, c: I::Const) {
-        if !c.has_infer() {
-            return;
-        }
-
-        if let ty::ConstKind::Infer(InferConst::Var(vid)) = c.kind() {
-            // We shallow resolved the infer var before.
-            // So it should be a unresolved infer var with an universe.
-            self.max_universe = self.max_universe.max(self.infcx.universe_of_ct(vid).unwrap());
-        }
-
-        c.super_visit_with(self)
-    }
-
-    fn visit_region(&mut self, r: I::Region) {
-        if let ty::ReVar(vid) = r.kind() {
-            self.max_universe = self.max_universe.max(self.infcx.universe_of_lt(vid).unwrap());
-        }
-    }
-}
-
 impl<'a, Infcx, I, F, E> NormalizationFolder<'a, Infcx, I, F>
 where
     Infcx: InferCtxtLike<Interner = I>,
@@ -130,9 +63,7 @@ where
         if normalization_was_ambiguous == NormalizationWasAmbiguous::Yes
             && has_escaping == HasEscapingBoundVars::Yes
         {
-            let mut visitor = MaxUniverse::new(self.infcx);
-            normalized.visit_with(&mut visitor);
-            let max_universe = visitor.max_universe();
+            let max_universe = ty::max_universe_of_infer_vars(self.infcx, normalized);
             if max_universe.can_name(self.universes.first().unwrap().unwrap()) {
                 return Ok(None);
             }
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/solver_region_constraints.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/solver_region_constraints.rs
index aa92fc163f0ed..a232ab9192444 100644
--- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/solver_region_constraints.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/solver_region_constraints.rs
@@ -8,11 +8,11 @@ use rustc_type_ir::outlives::{Component, push_outlives_components};
 #[cfg(not(feature = "nightly"))]
 use rustc_type_ir::region_constraint::TransitiveRelationBuilder;
 use rustc_type_ir::region_constraint::{
-    Assumptions, RegionConstraint, eagerly_handle_placeholders_in_universe, max_universe,
+    Assumptions, RegionConstraint, eagerly_handle_placeholders_in_universe,
 };
 use rustc_type_ir::{
     AliasTy, Binder, ClauseKind, InferCtxtLike, Interner, OutlivesPredicate, TypeVisitable,
-    TypeVisitableExt, TypeVisitor, UniverseIndex,
+    TypeVisitableExt, TypeVisitor, UniverseIndex, max_universe,
 };
 use tracing::{debug, instrument};
 
diff --git a/compiler/rustc_parse/src/parser/asm.rs b/compiler/rustc_parse/src/parser/asm.rs
index 3fab234adaad4..11460e775d36d 100644
--- a/compiler/rustc_parse/src/parser/asm.rs
+++ b/compiler/rustc_parse/src/parser/asm.rs
@@ -1,4 +1,4 @@
-use rustc_ast::{self as ast, AsmMacro, MgcaDisambiguation};
+use rustc_ast::{self as ast, AsmMacro};
 use rustc_span::{Span, Symbol, kw};
 
 use super::{ExpKeywordPair, ForceCollect, IdentIsRaw, Trailing, UsePreAttrPos};
@@ -149,7 +149,7 @@ fn parse_asm_operand<'a>(
         let block = p.parse_block()?;
         ast::InlineAsmOperand::Label { block }
     } else if p.eat_keyword(exp!(Const)) {
-        let anon_const = p.parse_expr_anon_const(|_, _| MgcaDisambiguation::AnonConst)?;
+        let anon_const = p.parse_expr_anon_const()?;
         ast::InlineAsmOperand::Const { anon_const }
     } else if p.eat_keyword(exp!(Sym)) {
         let expr = p.parse_expr()?;
diff --git a/compiler/rustc_parse/src/parser/diagnostics.rs b/compiler/rustc_parse/src/parser/diagnostics.rs
index 28e2841b9f1fe..a91ee634f3d47 100644
--- a/compiler/rustc_parse/src/parser/diagnostics.rs
+++ b/compiler/rustc_parse/src/parser/diagnostics.rs
@@ -7,7 +7,7 @@ use rustc_ast::util::parser::AssocOp;
 use rustc_ast::{
     self as ast, AngleBracketedArg, AngleBracketedArgs, AnonConst, AttrVec, BinOpKind, BindingMode,
     Block, BlockCheckMode, Expr, ExprKind, GenericArg, GenericArgs, Generics, Item, ItemKind,
-    MgcaDisambiguation, Param, Pat, PatKind, Path, PathSegment, QSelf, Recovered, Ty, TyKind,
+    Param, Pat, PatKind, Path, PathSegment, QSelf, Recovered, Ty, TyKind,
 };
 use rustc_ast_pretty::pprust;
 use rustc_data_structures::fx::FxHashSet;
@@ -2585,11 +2585,7 @@ impl<'a> Parser<'a> {
             self.dcx().emit_err(UnexpectedConstParamDeclaration { span: param.span(), sugg });
 
         let value = self.mk_expr_err(param.span(), guar);
-        Some(GenericArg::Const(AnonConst {
-            id: ast::DUMMY_NODE_ID,
-            value,
-            mgca_disambiguation: MgcaDisambiguation::Direct,
-        }))
+        Some(GenericArg::Const(AnonConst { id: ast::DUMMY_NODE_ID, value }))
     }
 
     pub(super) fn recover_const_param_declaration(
@@ -2673,11 +2669,7 @@ impl<'a> Parser<'a> {
                     );
                     let guar = err.emit();
                     let value = self.mk_expr_err(start.to(expr.span), guar);
-                    return Ok(GenericArg::Const(AnonConst {
-                        id: ast::DUMMY_NODE_ID,
-                        value,
-                        mgca_disambiguation: MgcaDisambiguation::Direct,
-                    }));
+                    return Ok(GenericArg::Const(AnonConst { id: ast::DUMMY_NODE_ID, value }));
                 } else if snapshot.token == token::Colon
                     && expr.span.lo() == snapshot.token.span.hi()
                     && matches!(expr.kind, ExprKind::Path(..))
@@ -2746,11 +2738,7 @@ impl<'a> Parser<'a> {
         );
         let guar = err.emit();
         let value = self.mk_expr_err(span, guar);
-        GenericArg::Const(AnonConst {
-            id: ast::DUMMY_NODE_ID,
-            value,
-            mgca_disambiguation: MgcaDisambiguation::Direct,
-        })
+        GenericArg::Const(AnonConst { id: ast::DUMMY_NODE_ID, value })
     }
 
     /// Some special error handling for the "top-level" patterns in a match arm,
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index df1877b82cb93..e151899a57228 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -15,8 +15,8 @@ use rustc_ast::visit::{Visitor, walk_expr};
 use rustc_ast::{
     self as ast, AnonConst, Arm, AssignOp, AssignOpKind, AttrStyle, AttrVec, BinOp, BinOpKind,
     BlockCheckMode, CaptureBy, ClosureBinder, DUMMY_NODE_ID, Expr, ExprField, ExprKind, FnDecl,
-    FnRetTy, Guard, Label, MacCall, MetaItemLit, MgcaDisambiguation, Movability, Param,
-    RangeLimits, StmtKind, Ty, TyKind, UnOp, UnsafeBinderCastKind, YieldKind,
+    FnRetTy, Guard, Label, MacCall, MetaItemLit, Movability, Param, RangeLimits, StmtKind, Ty,
+    TyKind, UnOp, UnsafeBinderCastKind, YieldKind,
 };
 use rustc_ast_pretty::pprust;
 use rustc_data_structures::stack::ensure_sufficient_stack;
@@ -83,15 +83,8 @@ impl<'a> Parser<'a> {
         )
     }
 
-    pub fn parse_expr_anon_const(
-        &mut self,
-        mgca_disambiguation: impl FnOnce(&Self, &Expr) -> MgcaDisambiguation,
-    ) -> PResult<'a, AnonConst> {
-        self.parse_expr().map(|value| AnonConst {
-            id: DUMMY_NODE_ID,
-            mgca_disambiguation: mgca_disambiguation(self, &value),
-            value,
-        })
+    pub fn parse_expr_anon_const(&mut self) -> PResult<'a, AnonConst> {
+        self.parse_expr().map(|value| AnonConst { id: DUMMY_NODE_ID, value })
     }
 
     fn parse_expr_catch_underscore(
@@ -1672,7 +1665,7 @@ impl<'a> Parser<'a> {
             let first_expr = self.parse_expr()?;
             if self.eat(exp!(Semi)) {
                 // Repeating array syntax: `[ 0; 512 ]`
-                let count = self.parse_expr_anon_const(|_, _| MgcaDisambiguation::Direct)?;
+                let count = self.parse_expr_anon_const()?;
                 self.expect(close)?;
                 ExprKind::Repeat(first_expr, count)
             } else if self.eat(exp!(Comma)) {
@@ -4508,6 +4501,7 @@ impl MutVisitor for CondChecker<'_> {
             | ExprKind::IncludedBytes(_)
             | ExprKind::FormatArgs(_)
             | ExprKind::Err(_)
+            | ExprKind::DirectConstArg(_)
             | ExprKind::Dummy => {
                 // These would forbid any let expressions they contain already.
             }
diff --git a/compiler/rustc_parse/src/parser/item.rs b/compiler/rustc_parse/src/parser/item.rs
index 201601d91adfa..815f60c55538e 100644
--- a/compiler/rustc_parse/src/parser/item.rs
+++ b/compiler/rustc_parse/src/parser/item.rs
@@ -1696,9 +1696,9 @@ impl<'a> Parser<'a> {
             if self.may_recover() { self.parse_where_clause()? } else { WhereClause::default() };
 
         let rhs = match (self.eat(exp!(Eq)), const_arg) {
-            (true, true) => ConstItemRhsKind::TypeConst {
-                rhs: Some(self.parse_expr_anon_const(|_, _| MgcaDisambiguation::Direct)?),
-            },
+            (true, true) => {
+                ConstItemRhsKind::TypeConst { rhs: Some(self.parse_expr_anon_const()?) }
+            }
             (true, false) => ConstItemRhsKind::Body { rhs: Some(self.parse_expr()?) },
             (false, true) => ConstItemRhsKind::TypeConst { rhs: None },
             (false, false) => ConstItemRhsKind::Body { rhs: None },
@@ -1918,11 +1918,8 @@ impl<'a> Parser<'a> {
                 VariantData::Unit(DUMMY_NODE_ID)
             };
 
-            let disr_expr = if this.eat(exp!(Eq)) {
-                Some(this.parse_expr_anon_const(|_, _| MgcaDisambiguation::AnonConst)?)
-            } else {
-                None
-            };
+            let disr_expr =
+                if this.eat(exp!(Eq)) { Some(this.parse_expr_anon_const()?) } else { None };
 
             let span = vlo.to(this.prev_token.span);
             if ident.name == kw::Underscore {
@@ -2143,7 +2140,7 @@ impl<'a> Parser<'a> {
                 if p.token == token::Eq {
                     let mut snapshot = p.create_snapshot_for_diagnostic();
                     snapshot.bump();
-                    match snapshot.parse_expr_anon_const(|_, _| MgcaDisambiguation::AnonConst) {
+                    match snapshot.parse_expr_anon_const() {
                         Ok(const_expr) => {
                             let sp = ty.span.shrink_to_hi().to(const_expr.value.span);
                             p.psess.gated_spans.gate(sym::default_field_values, sp);
@@ -2372,7 +2369,7 @@ impl<'a> Parser<'a> {
         }
         let default = if self.token == token::Eq {
             self.bump();
-            let const_expr = self.parse_expr_anon_const(|_, _| MgcaDisambiguation::AnonConst)?;
+            let const_expr = self.parse_expr_anon_const()?;
             let sp = ty.span.shrink_to_hi().to(const_expr.value.span);
             self.psess.gated_spans.gate(sym::default_field_values, sp);
             Some(const_expr)
diff --git a/compiler/rustc_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs
index 04a9b1ff212a7..8b57968413d3d 100644
--- a/compiler/rustc_parse/src/parser/mod.rs
+++ b/compiler/rustc_parse/src/parser/mod.rs
@@ -36,8 +36,8 @@ use rustc_ast::util::classify;
 use rustc_ast::{
     self as ast, AnonConst, AttrArgs, AttrId, BinOpKind, ByRef, Const, CoroutineKind,
     DUMMY_NODE_ID, DelimArgs, Expr, ExprKind, Extern, HasAttrs, HasTokens, ImplRestriction,
-    MgcaDisambiguation, MutRestriction, Mutability, Recovered, RestrictionKind, Safety, StrLit,
-    Visibility, VisibilityKind,
+    MutRestriction, Mutability, Recovered, RestrictionKind, Safety, StrLit, Visibility,
+    VisibilityKind,
 };
 use rustc_ast_pretty::pprust;
 use rustc_data_structures::fx::FxHashMap;
@@ -1298,7 +1298,6 @@ impl<'a> Parser<'a> {
         let anon_const = AnonConst {
             id: DUMMY_NODE_ID,
             value: self.mk_expr(blk.span, ExprKind::Block(blk, None)),
-            mgca_disambiguation: MgcaDisambiguation::AnonConst,
         };
         let blk_span = anon_const.value.span;
         let kind = if pat {
diff --git a/compiler/rustc_parse/src/parser/path.rs b/compiler/rustc_parse/src/parser/path.rs
index ea86c08915b31..d3839579d1311 100644
--- a/compiler/rustc_parse/src/parser/path.rs
+++ b/compiler/rustc_parse/src/parser/path.rs
@@ -4,8 +4,8 @@ use ast::token::IdentIsRaw;
 use rustc_ast::token::{self, MetaVarKind, Token, TokenKind};
 use rustc_ast::{
     self as ast, AngleBracketedArg, AngleBracketedArgs, AnonConst, AssocItemConstraint,
-    AssocItemConstraintKind, BlockCheckMode, GenericArg, GenericArgs, Generics, MgcaDisambiguation,
-    ParenthesizedArgs, Path, PathSegment, QSelf,
+    AssocItemConstraintKind, BlockCheckMode, GenericArg, GenericArgs, Generics, ParenthesizedArgs,
+    Path, PathSegment, QSelf,
 };
 use rustc_errors::{Applicability, Diag, PResult};
 use rustc_span::{BytePos, Ident, Span, kw, sym};
@@ -876,13 +876,12 @@ impl<'a> Parser<'a> {
     /// the caller.
     pub(super) fn parse_const_arg(&mut self) -> PResult<'a, AnonConst> {
         // Parse const argument.
-        let (value, mgca_disambiguation) = if self.token.kind == token::OpenBrace {
-            let value = self.parse_expr_block(None, self.token.span, BlockCheckMode::Default)?;
-            (value, MgcaDisambiguation::Direct)
+        let value = if self.token.kind == token::OpenBrace {
+            self.parse_expr_block(None, self.token.span, BlockCheckMode::Default)?
         } else {
             self.parse_unambiguous_unbraced_const_arg()?
         };
-        Ok(AnonConst { id: ast::DUMMY_NODE_ID, value, mgca_disambiguation })
+        Ok(AnonConst { id: ast::DUMMY_NODE_ID, value })
     }
 
     /// Attempt to parse a const argument that has not been enclosed in braces.
@@ -892,9 +891,7 @@ impl<'a> Parser<'a> {
     /// - Single-segment paths (i.e. standalone generic const parameters).
     /// All other expressions that can be parsed will emit an error suggesting the expression be
     /// wrapped in braces.
-    pub(super) fn parse_unambiguous_unbraced_const_arg(
-        &mut self,
-    ) -> PResult<'a, (Box<Expr>, MgcaDisambiguation)> {
+    pub(super) fn parse_unambiguous_unbraced_const_arg(&mut self) -> PResult<'a, Box<Expr>> {
         let start = self.token.span;
         let attrs = self.parse_outer_attributes()?;
         let (expr, _) =
@@ -915,7 +912,7 @@ impl<'a> Parser<'a> {
             });
         }
 
-        Ok((expr, MgcaDisambiguation::Direct))
+        Ok(expr)
     }
 
     /// Parse a generic argument in a path segment.
@@ -1019,11 +1016,7 @@ impl<'a> Parser<'a> {
                 GenericArg::Type(_) => GenericArg::Type(self.mk_ty(attr_span, TyKind::Err(guar))),
                 GenericArg::Const(_) => {
                     let error_expr = self.mk_expr(attr_span, ExprKind::Err(guar));
-                    GenericArg::Const(AnonConst {
-                        id: ast::DUMMY_NODE_ID,
-                        value: error_expr,
-                        mgca_disambiguation: MgcaDisambiguation::Direct,
-                    })
+                    GenericArg::Const(AnonConst { id: ast::DUMMY_NODE_ID, value: error_expr })
                 }
                 GenericArg::Lifetime(lt) => GenericArg::Lifetime(lt),
             }));
diff --git a/compiler/rustc_parse/src/parser/ty.rs b/compiler/rustc_parse/src/parser/ty.rs
index 349c8d1bea9e8..7c91c15f34034 100644
--- a/compiler/rustc_parse/src/parser/ty.rs
+++ b/compiler/rustc_parse/src/parser/ty.rs
@@ -2,9 +2,9 @@ use rustc_ast::token::{self, IdentIsRaw, MetaVarKind, Token, TokenKind};
 use rustc_ast::util::case::Case;
 use rustc_ast::{
     self as ast, BoundAsyncness, BoundConstness, BoundPolarity, DUMMY_NODE_ID, FnPtrTy, FnRetTy,
-    GenericBound, GenericBounds, GenericParam, Generics, Lifetime, MacCall, MgcaDisambiguation,
-    MutTy, Mutability, Pinnedness, PolyTraitRef, PreciseCapturingArg, TraitBoundModifiers,
-    TraitObjectSyntax, Ty, TyKind, UnsafeBinderTy,
+    GenericBound, GenericBounds, GenericParam, Generics, Lifetime, MacCall, MutTy, Mutability,
+    Pinnedness, PolyTraitRef, PreciseCapturingArg, TraitBoundModifiers, TraitObjectSyntax, Ty,
+    TyKind, UnsafeBinderTy,
 };
 use rustc_data_structures::stack::ensure_sufficient_stack;
 use rustc_errors::{Applicability, Diag, E0516, PResult};
@@ -660,7 +660,7 @@ impl<'a> Parser<'a> {
         };
 
         let ty = if self.eat(exp!(Semi)) {
-            let mut length = self.parse_expr_anon_const(|_, _| MgcaDisambiguation::Direct)?;
+            let mut length = self.parse_expr_anon_const()?;
 
             if let Err(e) = self.expect(exp!(CloseBracket)) {
                 // Try to recover from `X<Y, ...>` when `X::<Y, ...>` works
@@ -704,7 +704,7 @@ impl<'a> Parser<'a> {
 
         // FIXME(mgca): recovery is broken for `const {` args
         // we first try to parse pattern like `[u8 5]`
-        let length = match self.parse_expr_anon_const(|_, _| MgcaDisambiguation::Direct) {
+        let length = match self.parse_expr_anon_const() {
             Ok(length) => length,
             Err(e) => {
                 e.cancel();
@@ -794,7 +794,7 @@ impl<'a> Parser<'a> {
     /// an error type.
     fn parse_typeof_ty(&mut self, lo: Span) -> PResult<'a, TyKind> {
         self.expect(exp!(OpenParen))?;
-        let _expr = self.parse_expr_anon_const(|_, _| MgcaDisambiguation::AnonConst)?;
+        let _expr = self.parse_expr_anon_const()?;
         self.expect(exp!(CloseParen))?;
         let span = lo.to(self.prev_token.span);
         let guar = self
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 7ae6005e9bc98..863e4d88872c9 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -233,8 +233,8 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             AttributeKind::OnUnimplemented { directive } => {
                 self.check_diagnostic_on_unimplemented(hir_id, directive.as_deref())
             }
-            AttributeKind::OnConst { span, .. } => {
-                self.check_diagnostic_on_const(*span, hir_id, target, item)
+            AttributeKind::OnConst { span, directive } => {
+                self.check_diagnostic_on_const(*span, hir_id, target, item, directive.as_deref())
             }
             AttributeKind::OnMove { directive } => {
                 self.check_diagnostic_on_move(hir_id, directive.as_deref())
@@ -545,10 +545,36 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         hir_id: HirId,
         target: Target,
         item: Option<ItemLike<'_>>,
+        directive: Option<&Directive>,
     ) {
         // We only check the non-constness here. A diagnostic for use
         // on not-trait impl items is issued during attribute parsing.
         if target == (Target::Impl { of_trait: true }) {
+            if let Some(directive) = directive
+                && let Node::Item(Item { kind: ItemKind::Impl(hir::Impl { generics, .. }), .. }) =
+                    self.tcx.hir_node(hir_id)
+            {
+                directive.visit_params(&mut |argument_name, span| {
+                    let has_generic = generics.params.iter().any(|p| {
+                        if !matches!(p.kind, GenericParamKind::Lifetime { .. })
+                            && let ParamName::Plain(name) = p.name
+                            && name.name == argument_name
+                        {
+                            true
+                        } else {
+                            false
+                        }
+                    });
+                    if !has_generic {
+                        self.tcx.emit_node_span_lint(
+                            MALFORMED_DIAGNOSTIC_FORMAT_LITERALS,
+                            hir_id,
+                            span,
+                            diagnostics::OnConstMalformedFormatLiterals { name: argument_name },
+                        )
+                    }
+                });
+            }
             match item.unwrap() {
                 ItemLike::Item(it) => match it.expect_impl().constness {
                     Constness::Const { .. } => {
@@ -566,9 +592,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 ItemLike::ForeignItem => {}
             }
         }
-        // FIXME(#155570) Can we do something with generic args here?
-        // regardless, we don't check the validity of generic args here
-        // ...whose generics would that be, anyway? The traits' or the impls'?
     }
 
     /// Checks use of generic formatting parameters in `#[diagnostic::on_move]`
diff --git a/compiler/rustc_passes/src/diagnostics.rs b/compiler/rustc_passes/src/diagnostics.rs
index 92562cc462b87..605d54ac0511a 100644
--- a/compiler/rustc_passes/src/diagnostics.rs
+++ b/compiler/rustc_passes/src/diagnostics.rs
@@ -1196,6 +1196,13 @@ pub(crate) struct OnMoveMalformedFormatLiterals {
     pub name: Symbol,
 }
 
+#[derive(Diagnostic)]
+#[diag("unknown parameter `{$name}`")]
+#[help(r#"expect either a generic argument name or {"`{Self}`"} as format argument"#)]
+pub(crate) struct OnConstMalformedFormatLiterals {
+    pub name: Symbol,
+}
+
 #[derive(Diagnostic)]
 #[diag("unused target expression is specified for glob or list delegation")]
 pub(crate) struct GlobOrListDelegationUnusedTargetExpr {
diff --git a/compiler/rustc_passes/src/input_stats.rs b/compiler/rustc_passes/src/input_stats.rs
index d2bcf0359342c..f9b6367d4a9d4 100644
--- a/compiler/rustc_passes/src/input_stats.rs
+++ b/compiler/rustc_passes/src/input_stats.rs
@@ -411,6 +411,7 @@ impl<'v> hir_visit::Visitor<'v> for StatCollector<'v> {
                 Infer,
                 Pat,
                 FieldOf,
+                View,
                 Err
             ]
         );
@@ -660,7 +661,7 @@ impl<'v> ast_visit::Visitor<'v> for StatCollector<'v> {
                 If, While, ForLoop, Loop, Match, Closure, Block, Await, Move, Use, TryBlock, Assign,
                 AssignOp, Field, Index, Range, Underscore, Path, AddrOf, Break, Continue, Ret,
                 InlineAsm, FormatArgs, OffsetOf, MacCall, Struct, Repeat, Paren, Try, Yield, Yeet,
-                Become, IncludedBytes, Gen, UnsafeBinderCast, Err, Dummy
+                Become, IncludedBytes, Gen, UnsafeBinderCast, Err, Dummy, DirectConstArg
             ]
         );
         ast_visit::walk_expr(self, e)
@@ -688,9 +689,10 @@ impl<'v> ast_visit::Visitor<'v> for StatCollector<'v> {
                 ImplicitSelf,
                 MacCall,
                 CVarArgs,
-                Dummy,
                 FieldOf,
                 View,
+                DirectConstArg,
+                Dummy,
                 Err
             ]
         );
diff --git a/compiler/rustc_resolve/src/def_collector.rs b/compiler/rustc_resolve/src/def_collector.rs
index de3f8c380fc44..81c6db6a9d6d7 100644
--- a/compiler/rustc_resolve/src/def_collector.rs
+++ b/compiler/rustc_resolve/src/def_collector.rs
@@ -425,26 +425,9 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
     fn visit_anon_const(&mut self, constant: &'a AnonConst) {
         // Note that `visit_anon_const` is skipped for AnonConst nodes wrapped in an
         // ExprKind::ConstBlock - these are handled in visit_expr, and are DefKind::InlineConst.
-
-        // `MgcaDisambiguation::Direct` is set even when MGCA is disabled, so
-        // to avoid affecting stable we have to feature gate the not creating
-        // anon consts
-        if !self.r.features.min_generic_const_args() {
-            let parent = self
-                .create_def(constant.id, None, DefKind::AnonConst, constant.value.span)
-                .def_id();
-            return self.with_parent(parent, |this| visit::walk_anon_const(this, constant));
-        }
-
-        match constant.mgca_disambiguation {
-            MgcaDisambiguation::Direct => visit::walk_anon_const(self, constant),
-            MgcaDisambiguation::AnonConst => {
-                let parent = self
-                    .create_def(constant.id, None, DefKind::AnonConst, constant.value.span)
-                    .def_id();
-                self.with_parent(parent, |this| visit::walk_anon_const(this, constant));
-            }
-        };
+        let parent =
+            self.create_def(constant.id, None, DefKind::AnonConst, constant.value.span).def_id();
+        self.with_parent(parent, |this| visit::walk_anon_const(this, constant));
     }
 
     #[instrument(level = "debug", skip(self))]
diff --git a/compiler/rustc_span/src/lib.rs b/compiler/rustc_span/src/lib.rs
index 5015741f10c5f..ae01956be9301 100644
--- a/compiler/rustc_span/src/lib.rs
+++ b/compiler/rustc_span/src/lib.rs
@@ -738,7 +738,7 @@ impl Default for SpanData {
 
 impl PartialOrd for Span {
     fn partial_cmp(&self, rhs: &Self) -> Option<Ordering> {
-        PartialOrd::partial_cmp(&self.data(), &rhs.data())
+        Some(self.cmp(rhs))
     }
 }
 impl Ord for Span {
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index db2804a3f83bf..f3034dbd16794 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -822,6 +822,7 @@ symbols! {
         diagnostic_on_unmatched_args,
         dialect,
         direct,
+        direct_const_arg,
         discriminant_kind,
         discriminant_type,
         discriminant_value,
@@ -1739,6 +1740,7 @@ symbols! {
         rust_analyzer,
         rust_begin_unwind,
         rust_cold_cc,
+        rust_dash_call: "rust-call",
         rust_eh_personality,
         rust_future,
         rust_logo,
diff --git a/compiler/rustc_target/src/spec/base/linux_gnu.rs b/compiler/rustc_target/src/spec/base/linux_gnu.rs
index 7a907c802df2e..02e243fe0a129 100644
--- a/compiler/rustc_target/src/spec/base/linux_gnu.rs
+++ b/compiler/rustc_target/src/spec/base/linux_gnu.rs
@@ -1,7 +1,11 @@
 use crate::spec::{Cc, Env, LinkerFlavor, Lld, TargetOptions, base};
 
 pub(crate) fn opts() -> TargetOptions {
-    let mut base = TargetOptions { env: Env::Gnu, ..base::linux::opts() };
+    let mut base = TargetOptions {
+        env: Env::Gnu,
+        static_position_independent_executables: true,
+        ..base::linux::opts()
+    };
 
     // When we're asked to use the `rust-lld` linker by default, set the appropriate lld-using
     // linker flavor, and self-contained linker component.
diff --git a/compiler/rustc_target/src/spec/base/linux_musl.rs b/compiler/rustc_target/src/spec/base/linux_musl.rs
index 6d3124b559b11..7d65cf9707d2d 100644
--- a/compiler/rustc_target/src/spec/base/linux_musl.rs
+++ b/compiler/rustc_target/src/spec/base/linux_musl.rs
@@ -3,6 +3,7 @@ use crate::spec::{Env, LinkSelfContainedDefault, TargetOptions, base, crt_object
 pub(crate) fn opts() -> TargetOptions {
     TargetOptions {
         env: Env::Musl,
+        static_position_independent_executables: true,
         pre_link_objects_self_contained: crt_objects::pre_musl_self_contained(),
         post_link_objects_self_contained: crt_objects::post_musl_self_contained(),
         link_self_contained: LinkSelfContainedDefault::InferredForMusl,
diff --git a/compiler/rustc_target/src/spec/targets/s390x_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/s390x_unknown_linux_musl.rs
index 5ff9f025ba1d9..c4f7320969696 100644
--- a/compiler/rustc_target/src/spec/targets/s390x_unknown_linux_musl.rs
+++ b/compiler/rustc_target/src/spec/targets/s390x_unknown_linux_musl.rs
@@ -9,7 +9,6 @@ pub(crate) fn target() -> Target {
     base.cpu = "z10".into();
     base.max_atomic_width = Some(128);
     base.min_global_align = Some(Align::from_bits(16).unwrap());
-    base.static_position_independent_executables = true;
     base.stack_probes = StackProbeType::Inline;
     base.supported_sanitizers =
         SanitizerSet::ADDRESS | SanitizerSet::LEAK | SanitizerSet::MEMORY | SanitizerSet::THREAD;
diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnu.rs
index 0d87a7b760c61..f8556b3415d94 100644
--- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnu.rs
+++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnu.rs
@@ -9,7 +9,6 @@ pub(crate) fn target() -> Target {
     base.max_atomic_width = Some(64);
     base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]);
     base.stack_probes = StackProbeType::Inline;
-    base.static_position_independent_executables = true;
     base.supported_sanitizers = SanitizerSet::ADDRESS
         | SanitizerSet::CFI
         | SanitizerSet::KCFI
diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_musl.rs
index a664f22479913..8c82639c599ac 100644
--- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_musl.rs
+++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_musl.rs
@@ -9,7 +9,6 @@ pub(crate) fn target() -> Target {
     base.max_atomic_width = Some(64);
     base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]);
     base.stack_probes = StackProbeType::Inline;
-    base.static_position_independent_executables = true;
     base.supported_sanitizers = SanitizerSet::ADDRESS
         | SanitizerSet::CFI
         | SanitizerSet::LEAK
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 617ec6c4ac229..b38c933151eb2 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
@@ -29,8 +29,8 @@ use rustc_middle::ty::print::{
     PrintTraitRefExt as _, with_forced_trimmed_paths,
 };
 use rustc_middle::ty::{
-    self, GenericArgKind, TraitRef, Ty, TyCtxt, TypeFoldable, TypeFolder, TypeSuperFoldable,
-    TypeVisitableExt, Unnormalized, Upcast,
+    self, GenericArgKind, GenericParamDefKind, TraitRef, Ty, TyCtxt, TypeFoldable, TypeFolder,
+    TypeSuperFoldable, TypeVisitableExt, Unnormalized, Upcast,
 };
 use rustc_middle::{bug, span_bug};
 use rustc_span::def_id::CrateNum;
@@ -916,11 +916,25 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                     find_attr!(self.tcx, impl_did, OnConst {directive, ..} => directive.as_deref())
                         .flatten()
                 {
-                    let (_, format_args) = self.on_unimplemented_components(
+                    let (_, mut format_args) = self.on_unimplemented_components(
                         trait_ref,
                         main_obligation,
                         diag.long_ty_path(),
+                        false,
                     );
+                    if let ty::Adt(def, args) = trait_ref.self_ty().skip_binder().kind() {
+                        for param in self.tcx.generics_of(def.did()).own_params.iter() {
+                            match param.kind {
+                                GenericParamDefKind::Type { .. }
+                                | GenericParamDefKind::Const { .. } => {
+                                    format_args
+                                        .generic_args
+                                        .push((param.name, args[param.index as usize].to_string()));
+                                }
+                                _ => continue,
+                            }
+                        }
+                    }
                     let CustomDiagnostic { message, label, notes, parent_label: _ } =
                         command.eval(None, &format_args);
 
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/on_unimplemented.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/on_unimplemented.rs
index 138c53d013ebc..f7e4ec6164c99 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/on_unimplemented.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/on_unimplemented.rs
@@ -46,7 +46,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
             return CustomDiagnostic::default();
         }
         let (filter_options, format_args) =
-            self.on_unimplemented_components(trait_pred, obligation, long_ty_path);
+            self.on_unimplemented_components(trait_pred, obligation, long_ty_path, true);
         if let Some(command) = find_attr!(self.tcx, trait_pred.def_id(), OnUnimplemented {directive, ..} => directive.as_deref()).flatten() {
             command.eval(
                 Some(&filter_options),
@@ -62,6 +62,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
         trait_pred: ty::PolyTraitPredicate<'tcx>,
         obligation: &PredicateObligation<'tcx>,
         long_ty_path: &mut Option<PathBuf>,
+        print_infer_ty_var: bool,
     ) -> (FilterOptions, FormatArgs) {
         let (def_id, args) = (trait_pred.def_id(), trait_pred.skip_binder().trait_ref.args);
         let trait_pred = trait_pred.skip_binder();
@@ -244,7 +245,13 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
                     GenericParamDefKind::Type { .. } | GenericParamDefKind::Const { .. } => {
                         if let Some(ty) = trait_pred.trait_ref.args[param.index as usize].as_type()
                         {
-                            self.tcx.short_string(ty, long_ty_path)
+                            if print_infer_ty_var == false
+                                && let ty::Infer(ty::TyVar(_)) = ty.kind()
+                            {
+                                format!("{}", param.name)
+                            } else {
+                                self.tcx.short_string(ty, long_ty_path)
+                            }
                         } else {
                             trait_pred.trait_ref.args[param.index as usize].to_string()
                         }
diff --git a/compiler/rustc_type_ir/src/lib.rs b/compiler/rustc_type_ir/src/lib.rs
index 0fdfe17b963fa..bef53e422b0d2 100644
--- a/compiler/rustc_type_ir/src/lib.rs
+++ b/compiler/rustc_type_ir/src/lib.rs
@@ -56,6 +56,7 @@ mod term_kind;
 mod ty;
 mod ty_info;
 mod ty_kind;
+mod universe;
 mod unnormalized;
 mod upcast;
 mod visit;
@@ -86,6 +87,7 @@ pub use term_kind::*;
 pub use ty::{Alias, *};
 pub use ty_info::*;
 pub use ty_kind::*;
+pub use universe::*;
 pub use unnormalized::Unnormalized;
 pub use upcast::*;
 pub use visit::*;
diff --git a/compiler/rustc_type_ir/src/region_constraint.rs b/compiler/rustc_type_ir/src/region_constraint.rs
index 626649027da28..e77e0b9e24d52 100644
--- a/compiler/rustc_type_ir/src/region_constraint.rs
+++ b/compiler/rustc_type_ir/src/region_constraint.rs
@@ -49,12 +49,11 @@ use crate::data_structures::IndexMap;
 use crate::fold::TypeSuperFoldable;
 use crate::inherent::*;
 use crate::relate::{Relate, RelateResult, TypeRelation, VarianceDiagInfo};
-use crate::visit::TypeSuperVisitable;
 use crate::{
-    AliasTy, Binder, BoundRegion, BoundVar, BoundVariableKind, ConstKind, DebruijnIndex,
-    FallibleTypeFolder, InferCtxtLike, InferTy, Interner, IsRigid, OutlivesPredicate, RegionKind,
-    TyKind, TypeFoldable, TypeFolder, TypeVisitable, TypeVisitor, TypingMode, UniverseIndex,
-    Variance, VisitorResult, set_aliases_to_non_rigid,
+    AliasTy, Binder, BoundRegion, BoundVar, BoundVariableKind, DebruijnIndex, FallibleTypeFolder,
+    InferCtxtLike, Interner, IsRigid, OutlivesPredicate, RegionKind, TyKind, TypeFoldable,
+    TypeFolder, TypeVisitable, TypeVisitor, TypingMode, UniverseIndex, Variance, VisitorResult,
+    max_universe, set_aliases_to_non_rigid,
 };
 
 #[derive_where(Clone, Debug; I: Interner)]
@@ -990,84 +989,6 @@ pub fn regions_outlived_by_placeholder<I: Interner>(
     })
 }
 
-/// The largest universe a variable or placeholder was from in `t`
-pub fn max_universe<Infcx: InferCtxtLike<Interner = I>, I: Interner, T: TypeFoldable<I>>(
-    infcx: &Infcx,
-    t: T,
-) -> UniverseIndex {
-    let mut visitor = MaxUniverse::new(infcx);
-    // `max_universe` is also used while rewriting constraints to lower universes,
-    // so do not rely on callers having already resolved non-region infer vars.
-    let t = infcx.resolve_vars_if_possible(t);
-    t.visit_with(&mut visitor);
-    visitor.max_universe()
-}
-
-// FIXME(-Zassumptions-on-binders): Share this with the visitor used by generalization. We currently don't
-// as generalization does not look at universes of inference variables but we do
-struct MaxUniverse<'a, Infcx: InferCtxtLike> {
-    max_universe: UniverseIndex,
-    infcx: &'a Infcx,
-}
-
-impl<'a, Infcx: InferCtxtLike> MaxUniverse<'a, Infcx> {
-    fn new(infcx: &'a Infcx) -> Self {
-        MaxUniverse { infcx, max_universe: UniverseIndex::ROOT }
-    }
-
-    fn max_universe(self) -> UniverseIndex {
-        self.max_universe
-    }
-}
-
-impl<'a, Infcx: InferCtxtLike<Interner = I>, I: Interner> TypeVisitor<I>
-    for MaxUniverse<'a, Infcx>
-{
-    type Result = ();
-
-    fn visit_ty(&mut self, t: I::Ty) {
-        match t.kind() {
-            TyKind::Placeholder(p) => self.max_universe = self.max_universe.max(p.universe),
-            TyKind::Infer(InferTy::TyVar(inf)) => {
-                let u = self.infcx.universe_of_ty(inf).unwrap();
-                debug!("var {inf:?} in universe {u:?}");
-                self.max_universe = self.max_universe.max(u);
-            }
-            _ => t.super_visit_with(self),
-        }
-    }
-
-    fn visit_const(&mut self, c: I::Const) {
-        match c.kind() {
-            ConstKind::Placeholder(p) => self.max_universe = self.max_universe.max(p.universe),
-            ConstKind::Infer(rustc_type_ir::InferConst::Var(inf)) => {
-                let u = self.infcx.universe_of_ct(inf).unwrap();
-                debug!("var {inf:?} in universe {u:?}");
-                self.max_universe = self.max_universe.max(u);
-            }
-            _ => c.super_visit_with(self),
-        }
-    }
-
-    fn visit_region(&mut self, r: I::Region) {
-        match r.kind() {
-            RegionKind::RePlaceholder(p) => self.max_universe = self.max_universe.max(p.universe),
-            RegionKind::ReVar(var) => match self.infcx.opportunistic_resolve_lt_var(var).kind() {
-                RegionKind::RePlaceholder(p) => {
-                    self.max_universe = self.max_universe.max(p.universe)
-                }
-                RegionKind::ReVar(var) => {
-                    let u = self.infcx.universe_of_lt(var).unwrap();
-                    debug!("var {var:?} in universe {u:?}");
-                    self.max_universe = self.max_universe.max(u);
-                }
-                _ => (),
-            },
-            _ => (),
-        }
-    }
-}
-
 pub struct PlaceholderReplacer<I: Interner> {
     cx: I,
     existing_var_count: usize,
diff --git a/compiler/rustc_type_ir/src/universe.rs b/compiler/rustc_type_ir/src/universe.rs
new file mode 100644
index 0000000000000..9b0990d4d0ff0
--- /dev/null
+++ b/compiler/rustc_type_ir/src/universe.rs
@@ -0,0 +1,154 @@
+use tracing::{debug, instrument};
+
+use crate::inherent::*;
+use crate::visit::TypeVisitableExt;
+use crate::{
+    ConstKind, InferCtxtLike, InferTy, Interner, RegionKind, TyKind, TypeFoldable,
+    TypeSuperVisitable, TypeVisitable, TypeVisitor, UniverseIndex,
+};
+
+/// The largest universe a variable or placeholder was from in `t`
+pub fn max_universe<Infcx: InferCtxtLike<Interner = I>, I: Interner, T: TypeFoldable<I>>(
+    infcx: &Infcx,
+    t: T,
+) -> UniverseIndex {
+    max_universe_inner::<_, _, _, true, true>(infcx, t)
+}
+
+/// The largest universe a variable was from in `t`
+pub fn max_universe_of_infer_vars<
+    Infcx: InferCtxtLike<Interner = I>,
+    I: Interner,
+    T: TypeFoldable<I>,
+>(
+    infcx: &Infcx,
+    t: T,
+) -> UniverseIndex {
+    max_universe_inner::<_, _, _, false, true>(infcx, t)
+}
+
+/// The largest universe a placeholder was from in `t`
+pub fn max_universe_of_placeholders<
+    Infcx: InferCtxtLike<Interner = I>,
+    I: Interner,
+    T: TypeFoldable<I>,
+>(
+    infcx: &Infcx,
+    t: T,
+) -> UniverseIndex {
+    max_universe_inner::<_, _, _, true, false>(infcx, t)
+}
+
+fn max_universe_inner<
+    Infcx: InferCtxtLike<Interner = I>,
+    I: Interner,
+    T: TypeFoldable<I>,
+    const VISIT_PLACEHOLDER: bool,
+    const VISIT_INFER: bool,
+>(
+    infcx: &Infcx,
+    t: T,
+) -> UniverseIndex {
+    if !MaxUniverse::<Infcx, VISIT_PLACEHOLDER, VISIT_INFER>::needs_visit(&t) {
+        return UniverseIndex::ROOT;
+    }
+
+    let mut visitor = MaxUniverse::<_, VISIT_PLACEHOLDER, VISIT_INFER>::new(infcx);
+    // FIXME: make this a debug_assert and let callers resolve vars if there's
+    // perf win here.
+    let t = infcx.resolve_vars_if_possible(t);
+    t.visit_with(&mut visitor);
+    visitor.max_universe()
+}
+
+struct MaxUniverse<'a, Infcx: InferCtxtLike, const VISIT_PLACEHOLDER: bool, const VISIT_INFER: bool>
+{
+    max_universe: UniverseIndex,
+    infcx: &'a Infcx,
+}
+
+impl<'a, Infcx: InferCtxtLike, const VISIT_PLACEHOLDER: bool, const VISIT_INFER: bool>
+    MaxUniverse<'a, Infcx, VISIT_PLACEHOLDER, VISIT_INFER>
+{
+    fn new(infcx: &'a Infcx) -> Self {
+        MaxUniverse { infcx, max_universe: UniverseIndex::ROOT }
+    }
+
+    fn max_universe(self) -> UniverseIndex {
+        self.max_universe
+    }
+
+    #[instrument(ret, level = "debug")]
+    fn needs_visit<T: TypeVisitable<I>, I: Interner>(t: &T) -> bool {
+        (VISIT_PLACEHOLDER && t.has_placeholders()) || (VISIT_INFER && t.has_infer())
+    }
+}
+
+impl<
+    'a,
+    Infcx: InferCtxtLike<Interner = I>,
+    I: Interner,
+    const VISIT_PLACEHOLDER: bool,
+    const VISIT_INFER: bool,
+> TypeVisitor<I> for MaxUniverse<'a, Infcx, VISIT_PLACEHOLDER, VISIT_INFER>
+{
+    type Result = ();
+
+    fn visit_ty(&mut self, t: I::Ty) {
+        if !Self::needs_visit(&t) {
+            return;
+        }
+
+        match t.kind() {
+            TyKind::Placeholder(p) if VISIT_PLACEHOLDER => {
+                self.max_universe = self.max_universe.max(p.universe)
+            }
+            TyKind::Infer(InferTy::TyVar(inf)) if VISIT_INFER => {
+                let u = self.infcx.universe_of_ty(inf).unwrap();
+                debug!("var {inf:?} in universe {u:?}");
+                self.max_universe = self.max_universe.max(u);
+            }
+            _ => t.super_visit_with(self),
+        }
+    }
+
+    fn visit_const(&mut self, c: I::Const) {
+        if !Self::needs_visit(&c) {
+            return;
+        }
+
+        match c.kind() {
+            ConstKind::Placeholder(p) if VISIT_PLACEHOLDER => {
+                self.max_universe = self.max_universe.max(p.universe)
+            }
+            ConstKind::Infer(rustc_type_ir::InferConst::Var(inf)) if VISIT_INFER => {
+                let u = self.infcx.universe_of_ct(inf).unwrap();
+                debug!("var {inf:?} in universe {u:?}");
+                self.max_universe = self.max_universe.max(u);
+            }
+            _ => c.super_visit_with(self),
+        }
+    }
+
+    fn visit_region(&mut self, r: I::Region) {
+        match r.kind() {
+            RegionKind::RePlaceholder(p) if VISIT_PLACEHOLDER => {
+                self.max_universe = self.max_universe.max(p.universe)
+            }
+            RegionKind::ReVar(var) if VISIT_INFER => {
+                match self.infcx.opportunistic_resolve_lt_var(var).kind() {
+                    RegionKind::RePlaceholder(p) if VISIT_PLACEHOLDER => {
+                        self.max_universe = self.max_universe.max(p.universe)
+                    }
+                    RegionKind::ReVar(var) if VISIT_INFER => {
+                        let u = self.infcx.universe_of_lt(var).unwrap();
+                        debug!("var {var:?} in universe {u:?}");
+                        self.max_universe = self.max_universe.max(u);
+                    }
+                    _ => (),
+                }
+            }
+            _ => (),
+        }
+    }
+}
diff --git a/library/alloc/src/io/cursor.rs b/library/alloc/src/io/cursor.rs
new file mode 100644
index 0000000000000..21f6b8b5b3ffd
--- /dev/null
+++ b/library/alloc/src/io/cursor.rs
@@ -0,0 +1,260 @@
+use crate::alloc::Allocator;
+use crate::boxed::Box;
+use crate::io::{
+    self, Cursor, ErrorKind, IoSlice, WriteThroughCursor, slice_write, slice_write_all,
+    slice_write_all_vectored, slice_write_vectored,
+};
+use crate::vec::Vec;
+
+/// Reserves the required space, and pads the vec with 0s if necessary.
+fn reserve_and_pad<A: Allocator>(
+    pos_mut: &mut u64,
+    vec: &mut Vec<u8, A>,
+    buf_len: usize,
+) -> io::Result<usize> {
+    let pos: usize = (*pos_mut).try_into().map_err(|_| {
+        io::const_error!(
+            ErrorKind::InvalidInput,
+            "cursor position exceeds maximum possible vector length",
+        )
+    })?;
+
+    // For safety reasons, we don't want these numbers to overflow
+    // otherwise our allocation won't be enough
+    let desired_cap = pos.saturating_add(buf_len);
+    if desired_cap > vec.capacity() {
+        // We want our vec's total capacity
+        // to have room for (pos+buf_len) bytes. Reserve allocates
+        // based on additional elements from the length, so we need to
+        // reserve the difference
+        cfg_select! {
+            no_global_oom_handling => {
+                vec.try_reserve(desired_cap - vec.len())?;
+            }
+            _ => {
+                vec.reserve(desired_cap - vec.len());
+            }
+        }
+    }
+    // Pad if pos is above the current len.
+    if pos > vec.len() {
+        let diff = pos - vec.len();
+        // Unfortunately, `resize()` would suffice but the optimiser does not
+        // realise the `reserve` it does can be eliminated. So we do it manually
+        // to eliminate that extra branch
+        let spare = vec.spare_capacity_mut();
+        debug_assert!(spare.len() >= diff);
+        // Safety: we have allocated enough capacity for this.
+        // And we are only writing, not reading
+        unsafe {
+            spare.get_unchecked_mut(..diff).fill(core::mem::MaybeUninit::new(0));
+            vec.set_len(pos);
+        }
+    }
+
+    Ok(pos)
+}
+
+/// Writes the slice to the vec without allocating.
+///
+/// # Safety
+///
+/// `vec` must have `buf.len()` spare capacity.
+unsafe fn vec_write_all_unchecked<A>(pos: usize, vec: &mut Vec<u8, A>, buf: &[u8]) -> usize
+where
+    A: Allocator,
+{
+    debug_assert!(vec.capacity() >= pos + buf.len());
+    unsafe { vec.as_mut_ptr().add(pos).copy_from(buf.as_ptr(), buf.len()) };
+    pos + buf.len()
+}
+
+/// Resizing `write_all` implementation for [`Cursor`].
+///
+/// Cursor is allowed to have a pre-allocated and initialised
+/// vector body, but with a position of 0. This means the [`Write`]
+/// will overwrite the contents of the vec.
+///
+/// This also allows for the vec body to be empty, but with a position of N.
+/// This means that [`Write`] will pad the vec with 0 initially,
+/// before writing anything from that point
+///
+/// [`Write`]: crate::io::Write
+fn vec_write_all<A>(pos_mut: &mut u64, vec: &mut Vec<u8, A>, buf: &[u8]) -> io::Result<usize>
+where
+    A: Allocator,
+{
+    let buf_len = buf.len();
+    let mut pos = reserve_and_pad(pos_mut, vec, buf_len)?;
+
+    // Write the buf then progress the vec forward if necessary
+    // Safety: we have ensured that the capacity is available
+    // and that all bytes get written up to pos
+    unsafe {
+        pos = vec_write_all_unchecked(pos, vec, buf);
+        if pos > vec.len() {
+            vec.set_len(pos);
+        }
+    };
+
+    // Bump us forward
+    *pos_mut += buf_len as u64;
+    Ok(buf_len)
+}
+
+/// Resizing `write_all_vectored` implementation for [`Cursor`].
+///
+/// Cursor is allowed to have a pre-allocated and initialised
+/// vector body, but with a position of 0. This means the [`Write`]
+/// will overwrite the contents of the vec.
+///
+/// This also allows for the vec body to be empty, but with a position of N.
+/// This means that [`Write`] will pad the vec with 0 initially,
+/// before writing anything from that point
+///
+/// [`Write`]: crate::io::Write
+fn vec_write_all_vectored<A>(
+    pos_mut: &mut u64,
+    vec: &mut Vec<u8, A>,
+    bufs: &[IoSlice<'_>],
+) -> io::Result<usize>
+where
+    A: Allocator,
+{
+    // For safety reasons, we don't want this sum to overflow ever.
+    // If this saturates, the reserve should panic to avoid any unsound writing.
+    let buf_len = bufs.iter().fold(0usize, |a, b| a.saturating_add(b.len()));
+    let mut pos = reserve_and_pad(pos_mut, vec, buf_len)?;
+
+    // Write the buf then progress the vec forward if necessary
+    // Safety: we have ensured that the capacity is available
+    // and that all bytes get written up to the last pos
+    unsafe {
+        for buf in bufs {
+            pos = vec_write_all_unchecked(pos, vec, buf);
+        }
+        if pos > vec.len() {
+            vec.set_len(pos);
+        }
+    }
+
+    // Bump us forward
+    *pos_mut += buf_len as u64;
+    Ok(buf_len)
+}
+
+#[stable(feature = "cursor_mut_vec", since = "1.25.0")]
+impl<A> WriteThroughCursor for &mut Vec<u8, A>
+where
+    A: Allocator,
+{
+    fn write(this: &mut Cursor<Self>, buf: &[u8]) -> io::Result<usize> {
+        let (pos, inner) = this.into_parts_mut();
+        vec_write_all(pos, inner, buf)
+    }
+
+    fn write_vectored(this: &mut Cursor<Self>, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        let (pos, inner) = this.into_parts_mut();
+        vec_write_all_vectored(pos, inner, bufs)
+    }
+
+    #[inline]
+    fn is_write_vectored(_this: &Cursor<Self>) -> bool {
+        true
+    }
+
+    fn write_all(this: &mut Cursor<Self>, buf: &[u8]) -> io::Result<()> {
+        let (pos, inner) = this.into_parts_mut();
+        vec_write_all(pos, inner, buf)?;
+        Ok(())
+    }
+
+    fn write_all_vectored(this: &mut Cursor<Self>, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        let (pos, inner) = this.into_parts_mut();
+        vec_write_all_vectored(pos, inner, bufs)?;
+        Ok(())
+    }
+
+    #[inline]
+    fn flush(_this: &mut Cursor<Self>) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<A> WriteThroughCursor for Vec<u8, A>
+where
+    A: Allocator,
+{
+    fn write(this: &mut Cursor<Self>, buf: &[u8]) -> io::Result<usize> {
+        let (pos, inner) = this.into_parts_mut();
+        vec_write_all(pos, inner, buf)
+    }
+
+    fn write_vectored(this: &mut Cursor<Self>, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        let (pos, inner) = this.into_parts_mut();
+        vec_write_all_vectored(pos, inner, bufs)
+    }
+
+    #[inline]
+    fn is_write_vectored(_this: &Cursor<Self>) -> bool {
+        true
+    }
+
+    fn write_all(this: &mut Cursor<Self>, buf: &[u8]) -> io::Result<()> {
+        let (pos, inner) = this.into_parts_mut();
+        vec_write_all(pos, inner, buf)?;
+        Ok(())
+    }
+
+    fn write_all_vectored(this: &mut Cursor<Self>, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        let (pos, inner) = this.into_parts_mut();
+        vec_write_all_vectored(pos, inner, bufs)?;
+        Ok(())
+    }
+
+    #[inline]
+    fn flush(_this: &mut Cursor<Self>) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+#[stable(feature = "cursor_box_slice", since = "1.5.0")]
+impl<A> WriteThroughCursor for Box<[u8], A>
+where
+    A: Allocator,
+{
+    #[inline]
+    fn write(this: &mut Cursor<Self>, buf: &[u8]) -> io::Result<usize> {
+        let (pos, inner) = this.into_parts_mut();
+        slice_write(pos, inner, buf)
+    }
+
+    #[inline]
+    fn write_vectored(this: &mut Cursor<Self>, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        let (pos, inner) = this.into_parts_mut();
+        slice_write_vectored(pos, inner, bufs)
+    }
+
+    #[inline]
+    fn is_write_vectored(_this: &Cursor<Self>) -> bool {
+        true
+    }
+
+    #[inline]
+    fn write_all(this: &mut Cursor<Self>, buf: &[u8]) -> io::Result<()> {
+        let (pos, inner) = this.into_parts_mut();
+        slice_write_all(pos, inner, buf)
+    }
+
+    #[inline]
+    fn write_all_vectored(this: &mut Cursor<Self>, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        let (pos, inner) = this.into_parts_mut();
+        slice_write_all_vectored(pos, inner, bufs)
+    }
+
+    #[inline]
+    fn flush(_this: &mut Cursor<Self>) -> io::Result<()> {
+        Ok(())
+    }
+}
diff --git a/library/alloc/src/io/impls.rs b/library/alloc/src/io/impls.rs
index 732842bc65df7..1351d3e3ef3a1 100644
--- a/library/alloc/src/io/impls.rs
+++ b/library/alloc/src/io/impls.rs
@@ -1,7 +1,12 @@
+use crate::alloc::Allocator;
 use crate::boxed::Box;
-use crate::io::{self, Seek, SeekFrom, SizeHint};
+#[cfg(not(no_global_oom_handling))]
+use crate::collections::VecDeque;
+use crate::fmt;
+use crate::io::{self, IoSlice, Seek, SeekFrom, SizeHint, Write};
 #[cfg(all(not(no_rc), not(no_sync), target_has_atomic = "ptr"))]
 use crate::sync::Arc;
+use crate::vec::Vec;
 
 // =============================================================================
 // Forwarding implementations
@@ -20,6 +25,43 @@ impl<T> SizeHint for Box<T> {
     }
 }
 
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<W: Write + ?Sized> Write for Box<W> {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        (**self).write(buf)
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        (**self).write_vectored(bufs)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        (**self).is_write_vectored()
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        (**self).flush()
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        (**self).write_all(buf)
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        (**self).write_all_vectored(bufs)
+    }
+
+    #[inline]
+    fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
+        (**self).write_fmt(fmt)
+    }
+}
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<S: Seek + ?Sized> Seek for Box<S> {
     #[inline]
@@ -51,6 +93,148 @@ impl<S: Seek + ?Sized> Seek for Box<S> {
 // =============================================================================
 // In-memory buffer implementations
 
+/// Write is implemented for `Vec<u8>` by appending to the vector.
+/// The vector will grow as needed.
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<A: Allocator> Write for Vec<u8, A> {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        <Self as Write>::write_all(self, buf)?;
+        Ok(buf.len())
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        let len = bufs.iter().map(|b| b.len()).sum();
+        cfg_select! {
+            no_global_oom_handling => {
+                self.try_reserve(len)?;
+            }
+            _ => {
+                self.reserve(len);
+            }
+        }
+        for buf in bufs {
+            <Self as Write>::write_all(self, buf)?;
+        }
+        Ok(len)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        cfg_select! {
+            no_global_oom_handling => {
+                self.try_extend_from_slice_of_bytes(buf)?;
+            }
+            _ => {
+                self.extend_from_slice(buf);
+            }
+        }
+        Ok(())
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        self.write_vectored(bufs)?;
+        Ok(())
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+/// Write is implemented for `VecDeque<u8>` by appending to the `VecDeque`, growing it as needed.
+#[cfg(not(no_global_oom_handling))]
+#[stable(feature = "vecdeque_read_write", since = "1.63.0")]
+impl<A: Allocator> Write for VecDeque<u8, A> {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.extend(buf);
+        Ok(buf.len())
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        let len = bufs.iter().map(|b| b.len()).sum();
+        self.reserve(len);
+        for buf in bufs {
+            self.extend(&**buf);
+        }
+        Ok(len)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        self.extend(buf);
+        Ok(())
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        self.write_vectored(bufs)?;
+        Ok(())
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+#[cfg(all(not(no_rc), not(no_sync), target_has_atomic = "ptr"))]
+#[stable(feature = "io_traits_arc", since = "1.73.0")]
+impl<W: Write + ?Sized> Write for Arc<W>
+where
+    for<'a> &'a W: Write,
+    W: crate::io::IoHandle,
+{
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        (&**self).write(buf)
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        (&**self).write_vectored(bufs)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        (&**self).is_write_vectored()
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        (&**self).flush()
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        (&**self).write_all(buf)
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        (&**self).write_all_vectored(bufs)
+    }
+
+    #[inline]
+    fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
+        (&**self).write_fmt(fmt)
+    }
+}
 #[cfg(all(not(no_rc), not(no_sync), target_has_atomic = "ptr"))]
 #[stable(feature = "io_traits_arc", since = "1.73.0")]
 impl<S: Seek + ?Sized> Seek for Arc<S>
diff --git a/library/alloc/src/io/mod.rs b/library/alloc/src/io/mod.rs
index 44a1d1b71d164..ef7e95ed5bd7c 100644
--- a/library/alloc/src/io/mod.rs
+++ b/library/alloc/src/io/mod.rs
@@ -1,5 +1,6 @@
 //! Traits, helpers, and type definitions for core I/O functionality.
 
+mod cursor;
 mod error;
 mod impls;
 
@@ -14,8 +15,12 @@ pub use core::io::{BorrowedBuf, BorrowedCursor};
 #[unstable(feature = "alloc_io", issue = "154046")]
 pub use core::io::{
     Chain, Cursor, Empty, Error, ErrorKind, IoSlice, IoSliceMut, Repeat, Result, Seek, SeekFrom,
-    Sink, Take, empty, repeat, sink,
+    Sink, Take, Write, empty, repeat, sink,
 };
 #[doc(hidden)]
 #[unstable(feature = "core_io_internals", reason = "exposed only for libstd", issue = "none")]
-pub use core::io::{IoHandle, OsFunctions, SizeHint, chain, stream_len_default, take};
+pub use core::io::{
+    IoHandle, OsFunctions, SizeHint, WriteThroughCursor, chain, default_write_vectored,
+    slice_write, slice_write_all, slice_write_all_vectored, slice_write_vectored,
+    stream_len_default, take,
+};
diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs
index 01b4e6f938616..9f82f5be82a68 100644
--- a/library/alloc/src/lib.rs
+++ b/library/alloc/src/lib.rs
@@ -96,6 +96,7 @@
 #![feature(async_iterator)]
 #![feature(bstr)]
 #![feature(bstr_internals)]
+#![feature(can_vector)]
 #![feature(case_ignorable)]
 #![feature(cast_maybe_uninit)]
 #![feature(cell_get_cloned)]
@@ -180,6 +181,7 @@
 #![feature(unicode_internals)]
 #![feature(unsize)]
 #![feature(unwrap_infallible)]
+#![feature(write_all_vectored)]
 #![feature(wtf8_internals)]
 // tidy-alphabetical-end
 //
diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs
index 7ca6c7b951ffc..78bd6a93e7df3 100644
--- a/library/alloc/src/vec/mod.rs
+++ b/library/alloc/src/vec/mod.rs
@@ -2964,8 +2964,26 @@ impl<T, A: Allocator> Vec<T, A> {
     #[cfg(not(no_global_oom_handling))]
     #[inline]
     unsafe fn append_elements(&mut self, other: *const [T]) {
+        self.reserve(other.len());
+        unsafe {
+            self.append_elements_unreserved(other);
+        }
+    }
+
+    /// Appends elements to `self` from other buffer, returning [`TryReserveError`] on OOM.
+    #[inline]
+    unsafe fn try_append_elements(&mut self, other: *const [T]) -> Result<(), TryReserveError> {
+        self.try_reserve(other.len())?;
+        unsafe {
+            self.append_elements_unreserved(other);
+        }
+        Ok(())
+    }
+
+    /// Appends elements to `self` from other buffer without reserving additional capacity.
+    #[inline]
+    unsafe fn append_elements_unreserved(&mut self, other: *const [T]) {
         let count = other.len();
-        self.reserve(count);
         let len = self.len();
         if count > 0 {
             unsafe {
@@ -3635,6 +3653,22 @@ impl<T: Clone, A: Allocator> Vec<T, A> {
     }
 }
 
+impl<A: Allocator> Vec<u8, A> {
+    #[cfg_attr(
+        not(no_global_oom_handling),
+        expect(
+            dead_code,
+            reason = "currently only used in IO module when global OOM handling is disabled"
+        )
+    )]
+    pub(crate) fn try_extend_from_slice_of_bytes(
+        &mut self,
+        other: &[u8],
+    ) -> Result<(), TryReserveError> {
+        unsafe { self.try_append_elements(other) }
+    }
+}
+
 impl<T, A: Allocator, const N: usize> Vec<[T; N], A> {
     /// Takes a `Vec<[T; N]>` and flattens it into a `Vec<T>`.
     ///
diff --git a/library/core/src/alloc/global.rs b/library/core/src/alloc/global.rs
index e97398aa5dc4a..44a8ab6e54196 100644
--- a/library/core/src/alloc/global.rs
+++ b/library/core/src/alloc/global.rs
@@ -1,4 +1,7 @@
+use super::{AllocError, GlobalAllocator};
 use crate::alloc::Layout;
+use crate::hint::assert_unchecked;
+use crate::ptr::NonNull;
 use crate::{cmp, ptr};
 
 /// A memory allocator that can be registered as the standard library’s default
@@ -301,3 +304,72 @@ pub unsafe trait GlobalAlloc {
         new_ptr
     }
 }
+
+/// Allows all [`GlobalAllocator`]s to be used with the legacy [`GlobalAlloc`] interface.
+#[stable(feature = "global_alloc", since = "1.28.0")]
+unsafe impl<A> GlobalAlloc for A
+where
+    A: GlobalAllocator + ?Sized,
+{
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        // SAFETY: guaranteed by the caller.
+        // This might lead to the removal of zero-size checks inside the
+        // `Allocator` implementation.
+        unsafe { assert_unchecked(layout.size() != 0) };
+        match self.allocate(layout) {
+            Ok(ptr) => ptr.cast().as_ptr(),
+            Err(AllocError) => ptr::null_mut(),
+        }
+    }
+
+    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
+        // SAFETY: guaranteed by the caller.
+        unsafe { assert_unchecked(layout.size() != 0) };
+        // SAFETY: only non-null pointers can be currently allocated.
+        let ptr = unsafe { NonNull::new_unchecked(ptr) };
+        // SAFETY: guaranteed by caller.
+        unsafe { self.deallocate(ptr, layout) };
+    }
+
+    unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
+        // SAFETY: guaranteed by the caller.
+        unsafe { assert_unchecked(layout.size() != 0) };
+        match self.allocate_zeroed(layout) {
+            Ok(ptr) => ptr.cast().as_ptr(),
+            Err(AllocError) => ptr::null_mut(),
+        }
+    }
+
+    unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
+        // SAFETY: guaranteed by the caller.
+        unsafe { assert_unchecked(layout.size() != 0) };
+        // SAFETY: guaranteed by the caller.
+        unsafe { assert_unchecked(new_size != 0) };
+
+        // SAFETY: only non-null pointers can be currently allocated.
+        let ptr = unsafe { NonNull::new_unchecked(ptr) };
+        let alignment = layout.alignment();
+        // SAFETY: the caller must ensure that the `new_size` does not overflow
+        // when rounded up to the next multiple of `alignment`.
+        let new_layout = unsafe { Layout::from_size_alignment_unchecked(new_size, alignment) };
+
+        // SAFETY:
+        // Two preconditions are guaranteed by the caller:
+        // * `ptr` is currently allocated with this allocator.
+        // * `layout` fits the block of memory.
+        // The size precondition is upheld by selecting between `grow` and `shrink`
+        // based on the size.
+        let ptr = unsafe {
+            if new_size >= layout.size() {
+                self.grow(ptr, layout, new_layout)
+            } else {
+                self.shrink(ptr, layout, new_layout)
+            }
+        };
+
+        match ptr {
+            Ok(ptr) => ptr.cast().as_ptr(),
+            Err(AllocError) => ptr::null_mut(),
+        }
+    }
+}
diff --git a/library/core/src/alloc/mod.rs b/library/core/src/alloc/mod.rs
index 806f67728efb8..339bc310c0b61 100644
--- a/library/core/src/alloc/mod.rs
+++ b/library/core/src/alloc/mod.rs
@@ -447,6 +447,96 @@ pub const unsafe trait Allocator {
     }
 }
 
+/// An [`Allocator`] that can be registered as the standard library’s default
+/// through the `#[global_allocator]` attribute.
+///
+/// Types implementing this trait can be used as the default allocator for
+/// memory allocations through `Box`, `Vec` and the collection types. For
+/// instance, the `System` allocator implements this trait, and thus can be
+/// explicitly set as the default like so:
+/// ```
+/// use std::alloc::System;
+///
+/// #[global_allocator]
+/// static ALLOCATOR: System = System;
+/// ```
+///
+/// The `Global` allocator forwards all memory allocation requests to the
+/// `static` annotated with `#[global_allocator]`. Hence, `Global` does not
+/// implement `GlobalAllocator` itself, as that would lead to infinite recursion.
+///
+/// # Note to implementors
+///
+/// This trait is used to prevent the infinite recursion that would occur if the
+/// default allocator were to attempt to allocate memory through `Global` (and
+/// thus from itself).
+///
+/// When to implement this trait:
+/// * for custom global allocators that only use system memory allocation
+///   services.
+/// * for allocators that wrap another allocator that implements `GlobalAllocator`.
+///
+/// When **not** to implement this trait:
+/// * for wrappers of arbitrary allocators (which might end up being `Global`,
+///   leading to infinite recursion).
+///
+/// # Safety
+///
+/// In addition to the safety requirements of `Allocator`, global allocators are
+/// subject to some additional constraints:
+///
+/// * It's undefined behavior if global allocators unwind. This restriction may
+///   be lifted in the future, but currently a panic from any of these
+///   functions may lead to memory unsafety.
+///
+/// * You must not rely on allocations actually happening, even if there are explicit
+///   heap allocations in the source. The optimizer may detect unused allocations that it can either
+///   eliminate entirely or move to the stack and thus never invoke the allocator. The
+///   optimizer may further assume that allocation is infallible, so code that used to fail due
+///   to allocator failures may now suddenly work because the optimizer worked around the
+///   need for an allocation. More concretely, the following code example is unsound, irrespective
+///   of whether your custom allocator allows counting how many allocations have happened.
+///
+///   ```rust,ignore (unsound and has placeholders)
+///   drop(Box::new(42));
+///   let number_of_heap_allocs = /* call private allocator API */;
+///   unsafe { std::hint::assert_unchecked(number_of_heap_allocs > 0); }
+///   ```
+///
+///   Note that the optimizations mentioned above are not the only
+///   optimization that can be applied. You may generally not rely on heap allocations
+///   happening if they can be removed without changing program behavior.
+///   Whether allocations happen or not is not part of the program behavior, even if it
+///   could be detected via an allocator that tracks allocations by printing or otherwise
+///   having side effects.
+///
+/// # Re-entrance
+///
+/// When implementing a global allocator, one has to be careful not to create an infinitely recursive
+/// implementation by accident, as many constructs in the Rust standard library may allocate in
+/// their implementation. For example, on some platforms, [`std::sync::Mutex`] may allocate, so using
+/// it is highly problematic in a global allocator.
+///
+/// For this reason, one should generally stick to library features available through
+/// [`core`], and avoid using [`std`] in a global allocator. A few features from [`std`] are
+/// guaranteed to not use `#[global_allocator]` to allocate:
+///
+///  - [`std::thread_local`],
+///  - [`std::thread::current`],
+///  - [`std::thread::park`] and [`std::thread::Thread`]'s [`unpark`] method and
+/// [`Clone`] implementation.
+///
+/// [`std`]: ../../std/index.html
+/// [`std::sync::Mutex`]: ../../std/sync/struct.Mutex.html
+/// [`std::thread_local`]: ../../std/macro.thread_local.html
+/// [`std::thread::current`]: ../../std/thread/fn.current.html
+/// [`std::thread::park`]: ../../std/thread/fn.park.html
+/// [`std::thread::Thread`]: ../../std/thread/struct.Thread.html
+/// [`unpark`]: ../../std/thread/struct.Thread.html#method.unpark
+#[unstable(feature = "allocator_api", issue = "32838")]
+#[expect(multiple_supertrait_upcastable)]
+pub unsafe trait GlobalAllocator: Allocator + Sync + 'static {}
+
 #[unstable(feature = "allocator_api", issue = "32838")]
 #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
 const unsafe impl<A> Allocator for &A
diff --git a/library/core/src/attribute_docs.rs b/library/core/src/attribute_docs.rs
index e3679ecd4d309..94ff7a8fee6d3 100644
--- a/library/core/src/attribute_docs.rs
+++ b/library/core/src/attribute_docs.rs
@@ -349,3 +349,59 @@ mod deprecated_attribute {}
 /// [`deny`]: ./attribute.deny.html
 /// [`forbid`]: ./attribute.forbid.html
 mod warn_attribute {}
+
+#[doc(attribute = "no_std")]
+//
+/// Prevents automatically linking the standard library.
+///
+/// Written as an inner attribute at the top of the crate root, the `no_std` attribute stops
+/// the compiler from linking [`std`] into the crate, and only links [`core`].
+///
+/// The attribute also swaps which prelude gets inserted, with the [`core`] prelude replacing
+/// the [`std`] prelude. Items like [`Option`], [`Result`], and the primitive types remain
+/// available from [`core`] without any imports needed:
+///
+/// ```rust,ignore (no_std)
+/// #![no_std]
+///
+/// fn halve(x: u32) -> Option<u32> {
+///     if x % 2 == 0 { Some(x / 2) } else { None }
+/// }
+/// ```
+///
+/// Anything that requires heap memory allocations is not part of [`core`]. Linking the [`alloc`]
+/// crate explicitly can be used to include these types:
+///
+/// ```rust,ignore (no_std + needs a global allocator to link)
+/// #![no_std]
+///
+/// extern crate alloc;
+///
+/// use alloc::vec::Vec;
+/// ```
+///
+/// A `no_std` binary also removes the startup routine and default panic handler `std`
+/// normally provides. It must define its own `#[panic_handler]`, and typically its own
+/// entry point by additionally using `#![no_main]`:
+///
+/// ```rust,ignore (no_std + needs more than no_main alone to link)
+/// #![no_std]
+/// #![no_main]
+///
+/// use core::panic::PanicInfo;
+///
+/// #[panic_handler]
+/// fn on_panic(_info: &PanicInfo) -> ! {
+///     loop {}
+/// }
+/// ```
+///
+/// For more information, see the Reference on [the `no_std` attribute].
+///
+/// [`std`]: ../std/index.html
+/// [`core`]: ../core/index.html
+/// [`alloc`]: ../alloc/index.html
+/// [`Option`]: option::Option
+/// [`Result`]: result::Result
+/// [the `no_std` attribute]: ../reference/names/preludes.html#the-no_std-attribute
+mod no_std_attribute {}
diff --git a/library/core/src/char/methods.rs b/library/core/src/char/methods.rs
index d0114c30a6b3c..2af5b4ef46b97 100644
--- a/library/core/src/char/methods.rs
+++ b/library/core/src/char/methods.rs
@@ -1812,6 +1812,28 @@ impl char {
         ToCasefold(CaseMappingIter::new(conversions::to_casefold(self)))
     }
 
+    /// Returns the code point value as a `u32`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(char_to_u32)]
+    ///
+    /// let ascii = 'a';
+    /// let heart = '❤';
+    ///
+    /// assert_eq!(ascii.to_u32(), 97_u32);
+    /// assert_eq!(heart.to_u32(), 0x2764_u32);
+    /// ```
+    #[must_use = "this returns the result of the operation, \
+                  without modifying the original"]
+    #[unstable(feature = "char_to_u32", issue = "158938")]
+    #[rustc_const_unstable(feature = "char_to_u32", issue = "158938")]
+    #[inline(always)]
+    pub const fn to_u32(self) -> u32 {
+        self as u32
+    }
+
     /// Checks if the value is within the ASCII range.
     ///
     /// # Examples
diff --git a/library/core/src/ffi/va_list.rs b/library/core/src/ffi/va_list.rs
index 55d3cd22354e5..e27f581c04ca2 100644
--- a/library/core/src/ffi/va_list.rs
+++ b/library/core/src/ffi/va_list.rs
@@ -299,6 +299,9 @@ const impl<'f> Drop for VaList<'f> {
 /// and [`c_float`] is promoted to [`c_double`]. Implementing this trait for types that are
 /// subject to this promotion rule is invalid.
 ///
+/// This trait is only implemented for 128-bit integers when the platform defines the `__int128`
+/// type.
+///
 /// [`c_int`]: core::ffi::c_int
 /// [`c_long`]: core::ffi::c_long
 /// [`c_longlong`]: core::ffi::c_longlong
@@ -310,8 +313,8 @@ const impl<'f> Drop for VaList<'f> {
 /// [`c_float`]: core::ffi::c_float
 /// [`c_double`]: core::ffi::c_double
 // We may unseal this trait in the future, but currently our `va_arg` implementations don't support
-// types with an alignment larger than 8, or with a non-scalar layout. Inline assembly can be used
-// to accept unsupported types in the meantime.
+// types with a non-scalar layout. Inline assembly can be used to accept unsupported types in the
+// meantime.
 #[lang = "va_arg_safe"]
 pub impl(self) unsafe trait VaArgSafe: Copy {}
 
@@ -352,6 +355,61 @@ unsafe impl VaArgSafe for u32 {}
 unsafe impl VaArgSafe for u64 {}
 unsafe impl VaArgSafe for usize {}
 
+// Implement `VaArgSafe` for 128-bit integers on targets where clang provides `__int128`.
+//
+// GCC does not implement `__int128` for any 16-bit/32-bit target:
+//
+// https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/_005f_005fint128.html
+//
+// > There is no support in GCC for expressing an integer constant of type __int128 for targets
+// > with long long integer less than 128 bits wide.
+//
+// Per https://learn.microsoft.com/en-us/cpp/cpp/data-type-ranges?view=msvc-170, MSVC does not
+// define `__int128`.
+//
+// Clang is slightly more permissive: it defines `__int128` on wasm32 (a 32-bit target) and also
+// does provide `__int128` on 64-bit `*-pc-windows-msvc`, and we follow suit.
+cfg_select! {
+    any(
+        target_arch = "aarch64",
+        target_arch = "amdgpu",
+        target_arch = "arm64ec",
+        target_arch = "bpf",
+        target_arch = "loongarch64",
+        target_arch = "mips64",
+        target_arch = "mips64r6",
+        target_arch = "nvptx64",
+        target_arch = "powerpc64",
+        target_arch = "riscv64",
+        target_arch = "s390x",
+        target_arch = "sparc64",
+        target_arch = "wasm32",
+        target_arch = "wasm64",
+        target_arch = "x86_64",
+    ) => {
+        #[cfg(not(any(target_arch = "wasm32", target_abi = "x32", target_pointer_width = "64")))]
+        compile_error!("unexpected target architecture for 128-bit c-variadic");
+
+        #[unstable_feature_bound(c_variadic_int128)]
+        #[unstable(feature = "c_variadic_int128", issue = "155752")]
+        unsafe impl VaArgSafe for i128 {}
+        #[unstable_feature_bound(c_variadic_int128)]
+        #[unstable(feature = "c_variadic_int128", issue = "155752")]
+        unsafe impl VaArgSafe for u128 {}
+    }
+    _ => {
+        #[repr(transparent)]
+        #[derive(Clone, Copy)]
+        struct S(i32);
+
+        // When there are no actual implementations on i128, declare the c_variadic_int128 feature
+        // on a private type so that the feature is defined on all targets.
+        #[unstable(feature = "c_variadic_int128", issue = "155752")]
+        unsafe impl VaArgSafe for S {}
+
+    }
+}
+
 unsafe impl VaArgSafe for f64 {}
 
 unsafe impl<T> VaArgSafe for *mut T {}
diff --git a/library/core/src/io/cursor.rs b/library/core/src/io/cursor.rs
index c104b426f48df..fe4def531a84a 100644
--- a/library/core/src/io/cursor.rs
+++ b/library/core/src/io/cursor.rs
@@ -1,4 +1,5 @@
-use crate::io::{self, ErrorKind, SeekFrom};
+use crate::cmp;
+use crate::io::{self, ErrorKind, IoSlice, SeekFrom, Write};
 
 /// A `Cursor` wraps an in-memory buffer and provides it with a
 /// [`Seek`] implementation.
@@ -22,7 +23,7 @@ use crate::io::{self, ErrorKind, SeekFrom};
 /// [bytes]: crate::slice "slice"
 /// [`File`]: ../../std/fs/struct.File.html
 /// [`Read`]: ../../std/io/trait.Read.html
-/// [`Write`]: ../../std/io/trait.Write.html
+/// [`Write`]: crate::io::Write
 /// [`Seek`]: crate::io::Seek
 /// [Vec]: ../../alloc/vec/struct.Vec.html
 ///
@@ -294,6 +295,144 @@ where
     }
 }
 
+/// Non-resizing [`Write::write`] implementation for slices.
+/// Exported for `Cursor<Box<[u8], A>>`'s implementation of [`Write`].
+#[inline]
+#[doc(hidden)]
+#[unstable(feature = "core_io_internals", reason = "exposed only for libstd", issue = "none")]
+pub fn slice_write(pos_mut: &mut u64, slice: &mut [u8], buf: &[u8]) -> io::Result<usize> {
+    let pos = cmp::min(*pos_mut, slice.len() as u64);
+    let dst = &mut slice[(pos as usize)..];
+    let amt = cmp::min(buf.len(), dst.len());
+    dst[..amt].copy_from_slice(&buf[..amt]);
+    *pos_mut += amt as u64;
+    Ok(amt)
+}
+
+/// Non-resizing [`Write::write_vectored`] implementation for slices.
+/// Exported for `Cursor<Box<[u8], A>>`'s implementation of [`Write`].
+#[inline]
+#[doc(hidden)]
+#[unstable(feature = "core_io_internals", reason = "exposed only for libstd", issue = "none")]
+pub fn slice_write_vectored(
+    pos_mut: &mut u64,
+    slice: &mut [u8],
+    bufs: &[IoSlice<'_>],
+) -> io::Result<usize> {
+    let mut nwritten = 0;
+    for buf in bufs {
+        let n = slice_write(pos_mut, slice, buf)?;
+        nwritten += n;
+        if n < buf.len() {
+            break;
+        }
+    }
+    Ok(nwritten)
+}
+
+/// Non-resizing [`Write::write_all`] implementation for slices.
+/// Exported for `Cursor<Box<[u8], A>>`'s implementation of [`Write`].
+#[inline]
+#[doc(hidden)]
+#[unstable(feature = "core_io_internals", reason = "exposed only for libstd", issue = "none")]
+pub fn slice_write_all(pos_mut: &mut u64, slice: &mut [u8], buf: &[u8]) -> io::Result<()> {
+    let n = slice_write(pos_mut, slice, buf)?;
+    if n < buf.len() { Err(io::Error::WRITE_ALL_EOF) } else { Ok(()) }
+}
+
+/// Non-resizing [`Write::write_all_vectored`] implementation for slices.
+/// Exported for `Cursor<Box<[u8], A>>`'s implementation of [`Write`].
+#[inline]
+#[doc(hidden)]
+#[unstable(feature = "core_io_internals", reason = "exposed only for libstd", issue = "none")]
+pub fn slice_write_all_vectored(
+    pos_mut: &mut u64,
+    slice: &mut [u8],
+    bufs: &[IoSlice<'_>],
+) -> io::Result<()> {
+    for buf in bufs {
+        let n = slice_write(pos_mut, slice, buf)?;
+        if n < buf.len() {
+            return Err(io::Error::WRITE_ALL_EOF);
+        }
+    }
+    Ok(())
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl Write for Cursor<&mut [u8]> {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let (pos, inner) = self.into_parts_mut();
+        slice_write(pos, inner, buf)
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        let (pos, inner) = self.into_parts_mut();
+        slice_write_vectored(pos, inner, bufs)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        let (pos, inner) = self.into_parts_mut();
+        slice_write_all(pos, inner, buf)
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        let (pos, inner) = self.into_parts_mut();
+        slice_write_all_vectored(pos, inner, bufs)
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+#[stable(feature = "cursor_array", since = "1.61.0")]
+impl<const N: usize> Write for Cursor<[u8; N]> {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let (pos, inner) = self.into_parts_mut();
+        slice_write(pos, inner, buf)
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        let (pos, inner) = self.into_parts_mut();
+        slice_write_vectored(pos, inner, bufs)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        let (pos, inner) = self.into_parts_mut();
+        slice_write_all(pos, inner, buf)
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        let (pos, inner) = self.into_parts_mut();
+        slice_write_all_vectored(pos, inner, bufs)
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> io::Seek for Cursor<T>
 where
@@ -328,3 +467,53 @@ where
         Ok(self.position())
     }
 }
+
+/// Trait used to allow indirect implementation of `Write` for `Cursor<Self>`.
+/// Since [`Cursor`] is not a foundational type, it is not possible to implement
+/// `Write` for `Cursor<T>` if `Write` is defined in `libcore` and `T` is in a
+/// downstream crate (e.g., `liballoc` or `libstd`).
+///
+/// Methods are identical in purpose and meaning to their `Write` namesakes.
+#[doc(hidden)]
+#[unstable(feature = "core_io_internals", reason = "exposed only for libstd", issue = "none")]
+pub trait WriteThroughCursor: Sized {
+    fn write(this: &mut Cursor<Self>, buf: &[u8]) -> io::Result<usize>;
+    fn write_vectored(this: &mut Cursor<Self>, bufs: &[IoSlice<'_>]) -> io::Result<usize>;
+    fn is_write_vectored(this: &Cursor<Self>) -> bool;
+    fn write_all(this: &mut Cursor<Self>, buf: &[u8]) -> io::Result<()>;
+    fn write_all_vectored(this: &mut Cursor<Self>, bufs: &mut [IoSlice<'_>]) -> io::Result<()>;
+    fn flush(this: &mut Cursor<Self>) -> io::Result<()>;
+}
+
+#[doc(hidden)]
+impl<W: WriteThroughCursor> Write for Cursor<W> {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        WriteThroughCursor::write(self, buf)
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        WriteThroughCursor::write_vectored(self, bufs)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        WriteThroughCursor::is_write_vectored(self)
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        WriteThroughCursor::write_all(self, buf)
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        WriteThroughCursor::write_all_vectored(self, bufs)
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        WriteThroughCursor::flush(self)
+    }
+}
diff --git a/library/core/src/io/error.rs b/library/core/src/io/error.rs
index 4214a5f87e3ef..eac7396bcfd83 100644
--- a/library/core/src/io/error.rs
+++ b/library/core/src/io/error.rs
@@ -79,7 +79,7 @@ pub type Result<T> = result::Result<T, Error>;
 ///
 // FIXME(#74481): Hard-links required to link from `core` to `std`
 /// [Read]: ../../std/io/trait.Read.html
-/// [Write]: ../../std/io/trait.Write.html
+/// [Write]: crate::io::Write
 /// [Seek]: crate::io::Seek
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_has_incoherent_inherent_impls]
@@ -853,7 +853,7 @@ pub enum ErrorKind {
     /// particular number of bytes but only a smaller number of bytes could be
     /// written.
     ///
-    /// [write]: ../../std/io/trait.Write.html#tymethod.write
+    /// [write]: crate::io::Write::write
     /// [`Ok(0)`]: Ok
     #[stable(feature = "rust1", since = "1.0.0")]
     WriteZero,
diff --git a/library/core/src/io/impls.rs b/library/core/src/io/impls.rs
index e8c716f060119..218bd7adc2a55 100644
--- a/library/core/src/io/impls.rs
+++ b/library/core/src/io/impls.rs
@@ -1,4 +1,5 @@
-use crate::io::{self, Seek, SeekFrom, SizeHint};
+use crate::io::{self, IoSlice, Seek, SeekFrom, SizeHint, Write};
+use crate::{cmp, fmt, mem};
 
 // =============================================================================
 // Forwarding implementations
@@ -17,6 +18,43 @@ impl<T> SizeHint for &mut T {
     }
 }
 
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<W: Write + ?Sized> Write for &mut W {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        (**self).write(buf)
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        (**self).write_vectored(bufs)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        (**self).is_write_vectored()
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        (**self).flush()
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        (**self).write_all(buf)
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        (**self).write_all_vectored(bufs)
+    }
+
+    #[inline]
+    fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
+        (**self).write_fmt(fmt)
+    }
+}
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<S: Seek + ?Sized> Seek for &mut S {
     #[inline]
@@ -61,3 +99,110 @@ impl SizeHint for &[u8] {
         Some(self.len())
     }
 }
+
+/// Write is implemented for `&mut [u8]` by copying into the slice, overwriting
+/// its data.
+///
+/// Note that writing updates the slice to point to the yet unwritten part.
+/// The slice will be empty when it has been completely overwritten.
+///
+/// If the number of bytes to be written exceeds the size of the slice, write operations will
+/// return short writes: ultimately, `Ok(0)`; in this situation, `write_all` returns an error of
+/// kind `ErrorKind::WriteZero`.
+#[stable(feature = "rust1", since = "1.0.0")]
+impl Write for &mut [u8] {
+    #[inline]
+    fn write(&mut self, data: &[u8]) -> io::Result<usize> {
+        let amt = cmp::min(data.len(), self.len());
+        let (a, b) = mem::take(self).split_at_mut(amt);
+        a.copy_from_slice(&data[..amt]);
+        *self = b;
+        Ok(amt)
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        let mut nwritten = 0;
+        for buf in bufs {
+            nwritten += self.write(buf)?;
+            if self.is_empty() {
+                break;
+            }
+        }
+
+        Ok(nwritten)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    #[inline]
+    fn write_all(&mut self, data: &[u8]) -> io::Result<()> {
+        if self.write(data)? < data.len() { Err(io::Error::WRITE_ALL_EOF) } else { Ok(()) }
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        for buf in bufs {
+            if self.write(buf)? < buf.len() {
+                return Err(io::Error::WRITE_ALL_EOF);
+            }
+        }
+        Ok(())
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+#[unstable(feature = "read_buf", issue = "78485")]
+impl<'a> io::Write for core::io::BorrowedCursor<'a, u8> {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let amt = cmp::min(buf.len(), self.capacity());
+        self.append(&buf[..amt]);
+        Ok(amt)
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        let mut nwritten = 0;
+        for buf in bufs {
+            let n = self.write(buf)?;
+            nwritten += n;
+            if n < buf.len() {
+                break;
+            }
+        }
+        Ok(nwritten)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        if self.write(buf)? < buf.len() { Err(io::Error::WRITE_ALL_EOF) } else { Ok(()) }
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        for buf in bufs {
+            if self.write(buf)? < buf.len() {
+                return Err(io::Error::WRITE_ALL_EOF);
+            }
+        }
+        Ok(())
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
diff --git a/library/core/src/io/mod.rs b/library/core/src/io/mod.rs
index 1c27e42229bb7..0134540ae86c8 100644
--- a/library/core/src/io/mod.rs
+++ b/library/core/src/io/mod.rs
@@ -8,6 +8,7 @@ mod io_slice;
 mod seek;
 mod size_hint;
 mod util;
+mod write;
 
 #[unstable(feature = "core_io_borrowed_buf", issue = "117693")]
 pub use self::borrowed_buf::{BorrowedBuf, BorrowedCursor};
@@ -24,14 +25,20 @@ pub use self::{
     io_slice::{IoSlice, IoSliceMut},
     seek::{Seek, SeekFrom},
     util::{Chain, Empty, Repeat, Sink, Take, empty, repeat, sink},
+    write::Write,
 };
 #[doc(hidden)]
 #[unstable(feature = "core_io_internals", reason = "exposed only for libstd", issue = "none")]
 pub use self::{
+    cursor::{
+        WriteThroughCursor, slice_write, slice_write_all, slice_write_all_vectored,
+        slice_write_vectored,
+    },
     error::{Custom, CustomOwner, OsFunctions},
     seek::stream_len_default,
     size_hint::SizeHint,
     util::{chain, take},
+    write::default_write_vectored,
 };
 
 /// Marks that a type `T` can have IO traits such as [`Seek`], [`Write`], etc. automatically
@@ -48,7 +55,7 @@ pub use self::{
 // FIXME(#74481): Hard-links required to link from `core` to `std`
 /// [file]: ../../std/fs/struct.File.html
 /// [arc]: ../../alloc/sync/struct.Arc.html
-/// [`Write`]: ../../std/io/trait.Write.html
+/// [`Write`]: crate::io::Write
 /// [`Seek`]: crate::io::Seek
 #[doc(hidden)]
 #[unstable(feature = "core_io_internals", reason = "exposed only for libstd", issue = "none")]
diff --git a/library/core/src/io/util.rs b/library/core/src/io/util.rs
index de37690436c80..b022d876eb8f5 100644
--- a/library/core/src/io/util.rs
+++ b/library/core/src/io/util.rs
@@ -1,10 +1,10 @@
-use crate::io::{ErrorKind, Result, Seek, SeekFrom, SizeHint};
+use crate::io::{self, ErrorKind, IoSlice, Result, Seek, SeekFrom, SizeHint, Write};
 use crate::{cmp, fmt};
 
 /// `Empty` ignores any data written via [`Write`], and will always be empty
 /// (returning zero bytes) when read via [`Read`].
 ///
-/// [`Write`]: ../../std/io/trait.Write.html
+/// [`Write`]: crate::io::Write
 /// [`Read`]: ../../std/io/trait.Read.html
 ///
 /// This struct is generally created by calling [`empty()`]. Please
@@ -23,6 +23,84 @@ impl SizeHint for Empty {
     }
 }
 
+#[stable(feature = "empty_write", since = "1.73.0")]
+impl Write for Empty {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        Ok(buf.len())
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        let total_len = bufs.iter().map(|b| b.len()).sum();
+        Ok(total_len)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    #[inline]
+    fn write_all(&mut self, _buf: &[u8]) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, _bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn write_fmt(&mut self, _args: fmt::Arguments<'_>) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+#[stable(feature = "empty_write", since = "1.73.0")]
+impl Write for &Empty {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        Ok(buf.len())
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        let total_len = bufs.iter().map(|b| b.len()).sum();
+        Ok(total_len)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    #[inline]
+    fn write_all(&mut self, _buf: &[u8]) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, _bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn write_fmt(&mut self, _args: fmt::Arguments<'_>) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
 #[stable(feature = "empty_seek", since = "1.51.0")]
 impl Seek for Empty {
     #[inline]
@@ -51,7 +129,7 @@ impl Seek for Empty {
 /// [`Ok(buf.len())`]: Ok
 /// [`Ok(0)`]: Ok
 ///
-/// [`write`]: ../../std/io/trait.Write.html#tymethod.write
+/// [`write`]: crate::io::Write::write
 /// [`read`]: ../../std/io/trait.Read.html#tymethod.read
 ///
 /// # Examples
@@ -142,12 +220,90 @@ impl fmt::Debug for Repeat {
 #[derive(Copy, Clone, Debug, Default)]
 pub struct Sink;
 
+#[stable(feature = "rust1", since = "1.0.0")]
+impl Write for Sink {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        Ok(buf.len())
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        let total_len = bufs.iter().map(|b| b.len()).sum();
+        Ok(total_len)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    #[inline]
+    fn write_all(&mut self, _buf: &[u8]) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, _bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn write_fmt(&mut self, _args: fmt::Arguments<'_>) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+#[stable(feature = "write_mt", since = "1.48.0")]
+impl Write for &Sink {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        Ok(buf.len())
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        let total_len = bufs.iter().map(|b| b.len()).sum();
+        Ok(total_len)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    #[inline]
+    fn write_all(&mut self, _buf: &[u8]) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, _bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn write_fmt(&mut self, _args: fmt::Arguments<'_>) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
 /// Creates an instance of a writer which will successfully consume all data.
 ///
 /// All calls to [`write`] on the returned instance will return [`Ok(buf.len())`]
 /// and the contents of the buffer will not be inspected.
 ///
-/// [`write`]: ../../std/io/trait.Write.html#tymethod.write
+/// [`write`]: crate::io::Write::write
 /// [`Ok(buf.len())`]: Ok
 ///
 /// # Examples
diff --git a/library/core/src/io/write.rs b/library/core/src/io/write.rs
new file mode 100644
index 0000000000000..cdddd380885f4
--- /dev/null
+++ b/library/core/src/io/write.rs
@@ -0,0 +1,417 @@
+use crate::fmt;
+use crate::io::{Error, IoSlice, Result};
+
+/// A trait for objects which are byte-oriented sinks.
+///
+/// Implementors of the `Write` trait are sometimes called 'writers'.
+///
+/// Writers are defined by two required methods, [`write`] and [`flush`]:
+///
+/// * The [`write`] method will attempt to write some data into the object,
+///   returning how many bytes were successfully written.
+///
+/// * The [`flush`] method is useful for adapters and explicit buffers
+///   themselves for ensuring that all buffered data has been pushed out to the
+///   'true sink'.
+///
+/// Writers are intended to be composable with one another. Many implementors
+/// throughout [`std::io`] take and provide types which implement the `Write`
+/// trait.
+///
+/// [`write`]: Write::write
+/// [`flush`]: Write::flush
+/// [`std::io`]: crate::io
+///
+/// # Examples
+///
+/// ```no_run
+/// use std::io::prelude::*;
+/// use std::fs::File;
+///
+/// fn main() -> std::io::Result<()> {
+///     let data = b"some bytes";
+///
+///     let mut pos = 0;
+///     let mut buffer = File::create("foo.txt")?;
+///
+///     while pos < data.len() {
+///         let bytes_written = buffer.write(&data[pos..])?;
+///         pos += bytes_written;
+///     }
+///     Ok(())
+/// }
+/// ```
+///
+/// The trait also provides convenience methods like [`write_all`], which calls
+/// `write` in a loop until its entire input has been written.
+///
+/// [`write_all`]: Write::write_all
+#[stable(feature = "rust1", since = "1.0.0")]
+#[doc(notable_trait)]
+#[cfg_attr(not(test), rustc_diagnostic_item = "IoWrite")]
+pub trait Write {
+    /// Writes a buffer into this writer, returning how many bytes were written.
+    ///
+    /// This function will attempt to write the entire contents of `buf`, but
+    /// the entire write might not succeed, or the write may also generate an
+    /// error. Typically, a call to `write` represents one attempt to write to
+    /// any wrapped object.
+    ///
+    /// Calls to `write` are not guaranteed to block waiting for data to be
+    /// written, and a write which would otherwise block can be indicated through
+    /// an [`Err`] variant.
+    ///
+    /// If this method consumed `n > 0` bytes of `buf` it must return [`Ok(n)`].
+    /// If the return value is `Ok(n)` then `n` must satisfy `n <= buf.len()`.
+    /// A return value of `Ok(0)` typically means that the underlying object is
+    /// no longer able to accept bytes and will likely not be able to in the
+    /// future as well, or that the buffer provided is empty.
+    ///
+    /// # Errors
+    ///
+    /// Each call to `write` may generate an I/O error indicating that the
+    /// operation could not be completed. If an error is returned then no bytes
+    /// in the buffer were written to this writer.
+    ///
+    /// It is **not** considered an error if the entire buffer could not be
+    /// written to this writer.
+    ///
+    /// An error of the [`ErrorKind::Interrupted`] kind is non-fatal and the
+    /// write operation should be retried if there is nothing else to do.
+    ///
+    /// [`ErrorKind::Interrupted`]: crate::io::ErrorKind::Interrupted
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::io::prelude::*;
+    /// use std::fs::File;
+    ///
+    /// fn main() -> std::io::Result<()> {
+    ///     let mut buffer = File::create("foo.txt")?;
+    ///
+    ///     // Writes some prefix of the byte string, not necessarily all of it.
+    ///     buffer.write(b"some bytes")?;
+    ///     Ok(())
+    /// }
+    /// ```
+    ///
+    /// [`Ok(n)`]: Ok
+    #[stable(feature = "rust1", since = "1.0.0")]
+    fn write(&mut self, buf: &[u8]) -> Result<usize>;
+
+    /// Like [`write`], except that it writes from a slice of buffers.
+    ///
+    /// Data is copied from each buffer in order, with the final buffer
+    /// read from possibly being only partially consumed. This method must
+    /// behave as a call to [`write`] with the buffers concatenated would.
+    ///
+    /// The default implementation calls [`write`] with either the first nonempty
+    /// buffer provided, or an empty one if none exists.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::io::IoSlice;
+    /// use std::io::prelude::*;
+    /// use std::fs::File;
+    ///
+    /// fn main() -> std::io::Result<()> {
+    ///     let data1 = [1; 8];
+    ///     let data2 = [15; 8];
+    ///     let io_slice1 = IoSlice::new(&data1);
+    ///     let io_slice2 = IoSlice::new(&data2);
+    ///
+    ///     let mut buffer = File::create("foo.txt")?;
+    ///
+    ///     // Writes some prefix of the byte string, not necessarily all of it.
+    ///     buffer.write_vectored(&[io_slice1, io_slice2])?;
+    ///     Ok(())
+    /// }
+    /// ```
+    ///
+    /// [`write`]: Write::write
+    #[stable(feature = "iovec", since = "1.36.0")]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize> {
+        default_write_vectored(|b| self.write(b), bufs)
+    }
+
+    /// Determines if this `Write`r has an efficient [`write_vectored`]
+    /// implementation.
+    ///
+    /// If a `Write`r does not override the default [`write_vectored`]
+    /// implementation, code using it may want to avoid the method all together
+    /// and coalesce writes into a single buffer for higher performance.
+    ///
+    /// The default implementation returns `false`.
+    ///
+    /// [`write_vectored`]: Write::write_vectored
+    #[unstable(feature = "can_vector", issue = "69941")]
+    fn is_write_vectored(&self) -> bool {
+        false
+    }
+
+    /// Flushes this output stream, ensuring that all intermediately buffered
+    /// contents reach their destination.
+    ///
+    /// # Errors
+    ///
+    /// It is considered an error if not all bytes could be written due to
+    /// I/O errors or EOF being reached.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::io::prelude::*;
+    /// use std::io::BufWriter;
+    /// use std::fs::File;
+    ///
+    /// fn main() -> std::io::Result<()> {
+    ///     let mut buffer = BufWriter::new(File::create("foo.txt")?);
+    ///
+    ///     buffer.write_all(b"some bytes")?;
+    ///     buffer.flush()?;
+    ///     Ok(())
+    /// }
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    fn flush(&mut self) -> Result<()>;
+
+    /// Attempts to write an entire buffer into this writer.
+    ///
+    /// This method will continuously call [`write`] until there is no more data
+    /// to be written or an error of non-[`ErrorKind::Interrupted`] kind is
+    /// returned. This method will not return until the entire buffer has been
+    /// successfully written or such an error occurs. The first error that is
+    /// not of [`ErrorKind::Interrupted`] kind generated from this method will be
+    /// returned.
+    ///
+    /// [`ErrorKind::Interrupted`]: crate::io::ErrorKind::Interrupted
+    ///
+    /// If the buffer contains no data, this will never call [`write`].
+    ///
+    /// # Errors
+    ///
+    /// This function will return the first error of
+    /// non-[`ErrorKind::Interrupted`] kind that [`write`] returns.
+    ///
+    /// [`write`]: Write::write
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::io::prelude::*;
+    /// use std::fs::File;
+    ///
+    /// fn main() -> std::io::Result<()> {
+    ///     let mut buffer = File::create("foo.txt")?;
+    ///
+    ///     buffer.write_all(b"some bytes")?;
+    ///     Ok(())
+    /// }
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    fn write_all(&mut self, mut buf: &[u8]) -> Result<()> {
+        while !buf.is_empty() {
+            match self.write(buf) {
+                Ok(0) => {
+                    return Err(Error::WRITE_ALL_EOF);
+                }
+                Ok(n) => buf = &buf[n..],
+                Err(ref e) if e.is_interrupted() => {}
+                Err(e) => return Err(e),
+            }
+        }
+        Ok(())
+    }
+
+    /// Attempts to write multiple buffers into this writer.
+    ///
+    /// This method will continuously call [`write_vectored`] until there is no
+    /// more data to be written or an error of non-[`ErrorKind::Interrupted`]
+    /// kind is returned. This method will not return until all buffers have
+    /// been successfully written or such an error occurs. The first error that
+    /// is not of [`ErrorKind::Interrupted`] kind generated from this method
+    /// will be returned.
+    ///
+    /// [`ErrorKind::Interrupted`]: crate::io::ErrorKind::Interrupted
+    ///
+    /// If the buffer contains no data, this will never call [`write_vectored`].
+    ///
+    /// # Notes
+    ///
+    /// Unlike [`write_vectored`], this takes a *mutable* reference to
+    /// a slice of [`IoSlice`]s, not an immutable one. That's because we need to
+    /// modify the slice to keep track of the bytes already written.
+    ///
+    /// Once this function returns, the contents of `bufs` are unspecified, as
+    /// this depends on how many calls to [`write_vectored`] were necessary. It is
+    /// best to understand this function as taking ownership of `bufs` and to
+    /// not use `bufs` afterwards. The underlying buffers, to which the
+    /// [`IoSlice`]s point (but not the [`IoSlice`]s themselves), are unchanged and
+    /// can be reused.
+    ///
+    /// [`write_vectored`]: Write::write_vectored
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(write_all_vectored)]
+    /// # fn main() -> std::io::Result<()> {
+    ///
+    /// use std::io::{Write, IoSlice};
+    ///
+    /// let mut writer = Vec::new();
+    /// let bufs = &mut [
+    ///     IoSlice::new(&[1]),
+    ///     IoSlice::new(&[2, 3]),
+    ///     IoSlice::new(&[4, 5, 6]),
+    /// ];
+    ///
+    /// writer.write_all_vectored(bufs)?;
+    /// // Note: the contents of `bufs` is now undefined, see the Notes section.
+    ///
+    /// assert_eq!(writer, &[1, 2, 3, 4, 5, 6]);
+    /// # Ok(()) }
+    /// ```
+    #[unstable(feature = "write_all_vectored", issue = "70436")]
+    fn write_all_vectored(&mut self, mut bufs: &mut [IoSlice<'_>]) -> Result<()> {
+        // Guarantee that bufs is empty if it contains no data,
+        // to avoid calling write_vectored if there is no data to be written.
+        IoSlice::advance_slices(&mut bufs, 0);
+        while !bufs.is_empty() {
+            match self.write_vectored(bufs) {
+                Ok(0) => {
+                    return Err(Error::WRITE_ALL_EOF);
+                }
+                Ok(n) => IoSlice::advance_slices(&mut bufs, n),
+                Err(ref e) if e.is_interrupted() => {}
+                Err(e) => return Err(e),
+            }
+        }
+        Ok(())
+    }
+
+    /// Writes a formatted string into this writer, returning any error
+    /// encountered.
+    ///
+    /// This method is primarily used to interface with the
+    /// [`format_args!()`] macro, and it is rare that this should
+    /// explicitly be called. The [`write!()`] macro should be favored to
+    /// invoke this method instead.
+    ///
+    /// This function internally uses the [`write_all`] method on
+    /// this trait and hence will continuously write data so long as no errors
+    /// are received. This also means that partial writes are not indicated in
+    /// this signature.
+    ///
+    /// [`write_all`]: Write::write_all
+    ///
+    /// # Errors
+    ///
+    /// This function will return any I/O error reported while formatting.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::io::prelude::*;
+    /// use std::fs::File;
+    ///
+    /// fn main() -> std::io::Result<()> {
+    ///     let mut buffer = File::create("foo.txt")?;
+    ///
+    ///     // this call
+    ///     write!(buffer, "{:.*}", 2, 1.234567)?;
+    ///     // turns into this:
+    ///     buffer.write_fmt(format_args!("{:.*}", 2, 1.234567))?;
+    ///     Ok(())
+    /// }
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    fn write_fmt(&mut self, args: fmt::Arguments<'_>) -> Result<()> {
+        if let Some(s) = args.as_statically_known_str() {
+            self.write_all(s.as_bytes())
+        } else {
+            default_write_fmt(self, args)
+        }
+    }
+
+    /// Creates a "by reference" adapter for this instance of `Write`.
+    ///
+    /// The returned adapter also implements `Write` and will simply borrow this
+    /// current writer.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::io::Write;
+    /// use std::fs::File;
+    ///
+    /// fn main() -> std::io::Result<()> {
+    ///     let mut buffer = File::create("foo.txt")?;
+    ///
+    ///     let reference = buffer.by_ref();
+    ///
+    ///     // we can use reference just like our original buffer
+    ///     reference.write_all(b"some bytes")?;
+    ///     Ok(())
+    /// }
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    fn by_ref(&mut self) -> &mut Self
+    where
+        Self: Sized,
+    {
+        self
+    }
+}
+
+/// Default implementation of [`Write::write_vectored`], which is currently used
+/// in `libstd` for file system implementations of similar methods.
+#[doc(hidden)]
+#[unstable(feature = "core_io_internals", reason = "exposed only for libstd", issue = "none")]
+pub fn default_write_vectored<F>(write: F, bufs: &[IoSlice<'_>]) -> Result<usize>
+where
+    F: FnOnce(&[u8]) -> Result<usize>,
+{
+    let buf = bufs.iter().find(|b| !b.is_empty()).map_or(&[][..], |b| &**b);
+    write(buf)
+}
+
+fn default_write_fmt<W: Write + ?Sized>(this: &mut W, args: fmt::Arguments<'_>) -> Result<()> {
+    // Create a shim which translates a `Write` to a `fmt::Write` and saves off
+    // I/O errors, instead of discarding them.
+    struct Adapter<'a, T: ?Sized + 'a> {
+        inner: &'a mut T,
+        error: Result<()>,
+    }
+
+    impl<T: Write + ?Sized> fmt::Write for Adapter<'_, T> {
+        fn write_str(&mut self, s: &str) -> fmt::Result {
+            match self.inner.write_all(s.as_bytes()) {
+                Ok(()) => Ok(()),
+                Err(e) => {
+                    self.error = Err(e);
+                    Err(fmt::Error)
+                }
+            }
+        }
+    }
+
+    let mut output = Adapter { inner: this, error: Ok(()) };
+    match fmt::write(&mut output, args) {
+        Ok(()) => Ok(()),
+        Err(..) => {
+            // Check whether the error came from the underlying `Write`.
+            if output.error.is_err() {
+                output.error
+            } else {
+                // This shouldn't happen: the underlying stream did not error,
+                // but somehow the formatter still errored?
+                panic!(
+                    "a formatting trait implementation returned an error when the underlying stream did not"
+                );
+            }
+        }
+    }
+}
diff --git a/library/core/src/marker.rs b/library/core/src/marker.rs
index 45b8b266a2671..e3785c92c8d0d 100644
--- a/library/core/src/marker.rs
+++ b/library/core/src/marker.rs
@@ -1073,6 +1073,20 @@ pub const trait Destruct: PointeeSized {}
 #[rustc_dyn_incompatible_trait]
 pub trait Tuple {}
 
+/// Creates a new style directly represented const argument.
+/// ```ignore (cannot test this from within core yet)
+/// type const BAR<const N: usize>: usize = N;
+/// type const FOO<const N: usize>: usize = direct!(BAR::<N>);
+/// ```
+#[rustc_builtin_macro(direct_const_arg)]
+#[unstable(feature = "min_generic_const_args", issue = "132980")]
+#[macro_export]
+macro_rules! direct_const_arg {
+    ($($arg:tt)*) => {
+        /* compiler built-in */
+    };
+}
+
 /// A marker for types which can be used as types of `const` generic parameters.
 ///
 /// These types must have a proper equivalence relation (`Eq`) and it must be automatically
diff --git a/library/std/src/alloc.rs b/library/std/src/alloc.rs
index 7a576e083df7c..753ca5aba561c 100644
--- a/library/std/src/alloc.rs
+++ b/library/std/src/alloc.rs
@@ -63,14 +63,15 @@
 #![deny(unsafe_op_in_unsafe_fn)]
 #![stable(feature = "alloc_module", since = "1.28.0")]
 
-use core::ptr::NonNull;
-use core::sync::atomic::{AtomicBool, AtomicPtr, Ordering};
-use core::{hint, mem, ptr};
-
 #[stable(feature = "alloc_module", since = "1.28.0")]
 #[doc(inline)]
 pub use alloc_crate::alloc::*;
 
+use crate::ptr::NonNull;
+use crate::sync::atomic::{AtomicBool, AtomicPtr, Ordering};
+use crate::sys::alloc as imp;
+use crate::{hint, mem, ptr};
+
 /// The default memory allocator provided by the operating system.
 ///
 /// This is based on `malloc` on Unix platforms and `HeapAlloc` on Windows,
@@ -145,11 +146,7 @@ impl System {
             0 => Ok(layout.dangling_ptr().cast_slice(0)),
             // SAFETY: `layout` is non-zero in size,
             size => unsafe {
-                let raw_ptr = if zeroed {
-                    GlobalAlloc::alloc_zeroed(self, layout)
-                } else {
-                    GlobalAlloc::alloc(self, layout)
-                };
+                let raw_ptr = if zeroed { imp::alloc_zeroed(layout) } else { imp::alloc(layout) };
                 let ptr = NonNull::new(raw_ptr).ok_or(AllocError)?;
                 Ok(ptr.cast_slice(size))
             },
@@ -182,7 +179,7 @@ impl System {
                 // `realloc` probably checks for `new_size >= old_layout.size()` or something similar.
                 hint::assert_unchecked(new_size >= old_layout.size());
 
-                let raw_ptr = GlobalAlloc::realloc(self, ptr.as_ptr(), old_layout, new_size);
+                let raw_ptr = imp::realloc(ptr.as_ptr(), old_layout, new_size);
                 let ptr = NonNull::new(raw_ptr).ok_or(AllocError)?;
                 if zeroed {
                     raw_ptr.add(old_size).write_bytes(0, new_size - old_size);
@@ -205,8 +202,8 @@ impl System {
     }
 }
 
-// The Allocator impl checks the layout size to be non-zero and forwards to the GlobalAlloc impl,
-// which is in `std::sys::*::alloc`.
+// The Allocator impl checks the layout size to be non-zero and forwards to the
+// platform functions in `std::sys::*::alloc`.
 #[unstable(feature = "allocator_api", issue = "32838")]
 unsafe impl Allocator for System {
     #[inline]
@@ -224,7 +221,7 @@ unsafe impl Allocator for System {
         if layout.size() != 0 {
             // SAFETY: `layout` is non-zero in size,
             // other conditions must be upheld by the caller
-            unsafe { GlobalAlloc::dealloc(self, ptr.as_ptr(), layout) }
+            unsafe { imp::dealloc(ptr.as_ptr(), layout) }
         }
     }
 
@@ -274,7 +271,7 @@ unsafe impl Allocator for System {
                 // `realloc` probably checks for `new_size <= old_layout.size()` or something similar.
                 hint::assert_unchecked(new_size <= old_layout.size());
 
-                let raw_ptr = GlobalAlloc::realloc(self, ptr.as_ptr(), old_layout, new_size);
+                let raw_ptr = imp::realloc(ptr.as_ptr(), old_layout, new_size);
                 let ptr = NonNull::new(raw_ptr).ok_or(AllocError)?;
                 Ok(ptr.cast_slice(new_size))
             },
@@ -294,6 +291,9 @@ unsafe impl Allocator for System {
     }
 }
 
+#[unstable(feature = "allocator_api", issue = "32838")]
+unsafe impl GlobalAllocator for System {}
+
 static HOOK: AtomicPtr<()> = AtomicPtr::new(ptr::null_mut());
 
 /// Registers a custom allocation error hook, replacing any that was previously registered.
@@ -435,7 +435,12 @@ pub fn rust_oom(layout: Layout) -> ! {
 #[allow(unused_attributes)]
 #[unstable(feature = "alloc_internals", issue = "none")]
 pub mod __default_lib_allocator {
-    use super::{GlobalAlloc, Layout, System};
+    use super::Layout;
+    // We call the system functions directly to avoid any overheads introduced
+    // by the roundtrip through `impl Allocator for System` and
+    // `impl<A: GlobalAllocator> GlobalAlloc for A`.
+    use crate::sys::alloc as imp;
+
     // These magic symbol names are used as a fallback for implementing the
     // `__rust_alloc` etc symbols (see `src/liballoc/alloc.rs`) when there is
     // no `#[global_allocator]` attribute.
@@ -452,7 +457,7 @@ pub mod __default_lib_allocator {
         // `GlobalAlloc::alloc`.
         unsafe {
             let layout = Layout::from_size_align_unchecked(size, align);
-            System.alloc(layout)
+            imp::alloc(layout)
         }
     }
 
@@ -460,7 +465,7 @@ pub mod __default_lib_allocator {
     pub unsafe extern "C" fn __rdl_dealloc(ptr: *mut u8, size: usize, align: usize) {
         // SAFETY: see the guarantees expected by `Layout::from_size_align` and
         // `GlobalAlloc::dealloc`.
-        unsafe { System.dealloc(ptr, Layout::from_size_align_unchecked(size, align)) }
+        unsafe { imp::dealloc(ptr, Layout::from_size_align_unchecked(size, align)) }
     }
 
     #[rustc_std_internal_symbol]
@@ -474,7 +479,7 @@ pub mod __default_lib_allocator {
         // `GlobalAlloc::realloc`.
         unsafe {
             let old_layout = Layout::from_size_align_unchecked(old_size, align);
-            System.realloc(ptr, old_layout, new_size)
+            imp::realloc(ptr, old_layout, new_size)
         }
     }
 
@@ -484,7 +489,7 @@ pub mod __default_lib_allocator {
         // `GlobalAlloc::alloc_zeroed`.
         unsafe {
             let layout = Layout::from_size_align_unchecked(size, align);
-            System.alloc_zeroed(layout)
+            imp::alloc_zeroed(layout)
         }
     }
 }
diff --git a/library/std/src/io/cursor.rs b/library/std/src/io/cursor.rs
index 5399789b4242f..e0b127bef8e2b 100644
--- a/library/std/src/io/cursor.rs
+++ b/library/std/src/io/cursor.rs
@@ -4,10 +4,8 @@ mod tests;
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use core::io::Cursor;
 
-use crate::alloc::Allocator;
-use crate::cmp;
 use crate::io::prelude::*;
-use crate::io::{self, BorrowedCursor, ErrorKind, IoSlice, IoSliceMut};
+use crate::io::{self, BorrowedCursor, IoSliceMut};
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> Read for Cursor<T>
@@ -101,414 +99,3 @@ where
         self.set_position(self.position() + amt as u64);
     }
 }
-
-/// Trait used to allow indirect implementation of `Write` for `Cursor<Self>`.
-/// Since [`Cursor`] is not a foundational type, it is not possible to implement
-/// `Write` for `Cursor<T>` if `Write` is defined in `libcore` and `T` is in a
-/// downstream crate (e.g., `liballoc` or `libstd`).
-///
-/// Methods are identical in purpose and meaning to their `Write` namesakes.
-trait WriteThroughCursor: Sized {
-    fn write(this: &mut Cursor<Self>, buf: &[u8]) -> io::Result<usize>;
-    fn write_vectored(this: &mut Cursor<Self>, bufs: &[IoSlice<'_>]) -> io::Result<usize>;
-    fn is_write_vectored(this: &Cursor<Self>) -> bool;
-    fn write_all(this: &mut Cursor<Self>, buf: &[u8]) -> io::Result<()>;
-    fn write_all_vectored(this: &mut Cursor<Self>, bufs: &mut [IoSlice<'_>]) -> io::Result<()>;
-    fn flush(this: &mut Cursor<Self>) -> io::Result<()>;
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<W: WriteThroughCursor> Write for Cursor<W> {
-    #[inline]
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        WriteThroughCursor::write(self, buf)
-    }
-
-    #[inline]
-    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        WriteThroughCursor::write_vectored(self, bufs)
-    }
-
-    #[inline]
-    fn is_write_vectored(&self) -> bool {
-        WriteThroughCursor::is_write_vectored(self)
-    }
-
-    #[inline]
-    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
-        WriteThroughCursor::write_all(self, buf)
-    }
-
-    #[inline]
-    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
-        WriteThroughCursor::write_all_vectored(self, bufs)
-    }
-
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> {
-        WriteThroughCursor::flush(self)
-    }
-}
-
-// Non-resizing write implementation
-#[inline]
-fn slice_write(pos_mut: &mut u64, slice: &mut [u8], buf: &[u8]) -> io::Result<usize> {
-    let pos = cmp::min(*pos_mut, slice.len() as u64);
-    let amt = (&mut slice[(pos as usize)..]).write(buf)?;
-    *pos_mut += amt as u64;
-    Ok(amt)
-}
-
-#[inline]
-fn slice_write_vectored(
-    pos_mut: &mut u64,
-    slice: &mut [u8],
-    bufs: &[IoSlice<'_>],
-) -> io::Result<usize> {
-    let mut nwritten = 0;
-    for buf in bufs {
-        let n = slice_write(pos_mut, slice, buf)?;
-        nwritten += n;
-        if n < buf.len() {
-            break;
-        }
-    }
-    Ok(nwritten)
-}
-
-#[inline]
-fn slice_write_all(pos_mut: &mut u64, slice: &mut [u8], buf: &[u8]) -> io::Result<()> {
-    let n = slice_write(pos_mut, slice, buf)?;
-    if n < buf.len() { Err(io::Error::WRITE_ALL_EOF) } else { Ok(()) }
-}
-
-#[inline]
-fn slice_write_all_vectored(
-    pos_mut: &mut u64,
-    slice: &mut [u8],
-    bufs: &[IoSlice<'_>],
-) -> io::Result<()> {
-    for buf in bufs {
-        let n = slice_write(pos_mut, slice, buf)?;
-        if n < buf.len() {
-            return Err(io::Error::WRITE_ALL_EOF);
-        }
-    }
-    Ok(())
-}
-
-/// Reserves the required space, and pads the vec with 0s if necessary.
-fn reserve_and_pad<A: Allocator>(
-    pos_mut: &mut u64,
-    vec: &mut Vec<u8, A>,
-    buf_len: usize,
-) -> io::Result<usize> {
-    let pos: usize = (*pos_mut).try_into().map_err(|_| {
-        io::const_error!(
-            ErrorKind::InvalidInput,
-            "cursor position exceeds maximum possible vector length",
-        )
-    })?;
-
-    // For safety reasons, we don't want these numbers to overflow
-    // otherwise our allocation won't be enough
-    let desired_cap = pos.saturating_add(buf_len);
-    if desired_cap > vec.capacity() {
-        // We want our vec's total capacity
-        // to have room for (pos+buf_len) bytes. Reserve allocates
-        // based on additional elements from the length, so we need to
-        // reserve the difference
-        vec.reserve(desired_cap - vec.len());
-    }
-    // Pad if pos is above the current len.
-    if pos > vec.len() {
-        let diff = pos - vec.len();
-        // Unfortunately, `resize()` would suffice but the optimiser does not
-        // realise the `reserve` it does can be eliminated. So we do it manually
-        // to eliminate that extra branch
-        let spare = vec.spare_capacity_mut();
-        debug_assert!(spare.len() >= diff);
-        // Safety: we have allocated enough capacity for this.
-        // And we are only writing, not reading
-        unsafe {
-            spare.get_unchecked_mut(..diff).fill(core::mem::MaybeUninit::new(0));
-            vec.set_len(pos);
-        }
-    }
-
-    Ok(pos)
-}
-
-/// Writes the slice to the vec without allocating.
-///
-/// # Safety
-///
-/// `vec` must have `buf.len()` spare capacity.
-unsafe fn vec_write_all_unchecked<A>(pos: usize, vec: &mut Vec<u8, A>, buf: &[u8]) -> usize
-where
-    A: Allocator,
-{
-    debug_assert!(vec.capacity() >= pos + buf.len());
-    unsafe { vec.as_mut_ptr().add(pos).copy_from(buf.as_ptr(), buf.len()) };
-    pos + buf.len()
-}
-
-/// Resizing `write_all` implementation for [`Cursor`].
-///
-/// Cursor is allowed to have a pre-allocated and initialised
-/// vector body, but with a position of 0. This means the [`Write`]
-/// will overwrite the contents of the vec.
-///
-/// This also allows for the vec body to be empty, but with a position of N.
-/// This means that [`Write`] will pad the vec with 0 initially,
-/// before writing anything from that point
-fn vec_write_all<A>(pos_mut: &mut u64, vec: &mut Vec<u8, A>, buf: &[u8]) -> io::Result<usize>
-where
-    A: Allocator,
-{
-    let buf_len = buf.len();
-    let mut pos = reserve_and_pad(pos_mut, vec, buf_len)?;
-
-    // Write the buf then progress the vec forward if necessary
-    // Safety: we have ensured that the capacity is available
-    // and that all bytes get written up to pos
-    unsafe {
-        pos = vec_write_all_unchecked(pos, vec, buf);
-        if pos > vec.len() {
-            vec.set_len(pos);
-        }
-    };
-
-    // Bump us forward
-    *pos_mut += buf_len as u64;
-    Ok(buf_len)
-}
-
-/// Resizing `write_all_vectored` implementation for [`Cursor`].
-///
-/// Cursor is allowed to have a pre-allocated and initialised
-/// vector body, but with a position of 0. This means the [`Write`]
-/// will overwrite the contents of the vec.
-///
-/// This also allows for the vec body to be empty, but with a position of N.
-/// This means that [`Write`] will pad the vec with 0 initially,
-/// before writing anything from that point
-fn vec_write_all_vectored<A>(
-    pos_mut: &mut u64,
-    vec: &mut Vec<u8, A>,
-    bufs: &[IoSlice<'_>],
-) -> io::Result<usize>
-where
-    A: Allocator,
-{
-    // For safety reasons, we don't want this sum to overflow ever.
-    // If this saturates, the reserve should panic to avoid any unsound writing.
-    let buf_len = bufs.iter().fold(0usize, |a, b| a.saturating_add(b.len()));
-    let mut pos = reserve_and_pad(pos_mut, vec, buf_len)?;
-
-    // Write the buf then progress the vec forward if necessary
-    // Safety: we have ensured that the capacity is available
-    // and that all bytes get written up to the last pos
-    unsafe {
-        for buf in bufs {
-            pos = vec_write_all_unchecked(pos, vec, buf);
-        }
-        if pos > vec.len() {
-            vec.set_len(pos);
-        }
-    }
-
-    // Bump us forward
-    *pos_mut += buf_len as u64;
-    Ok(buf_len)
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl Write for Cursor<&mut [u8]> {
-    #[inline]
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        let (pos, inner) = self.into_parts_mut();
-        slice_write(pos, inner, buf)
-    }
-
-    #[inline]
-    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        let (pos, inner) = self.into_parts_mut();
-        slice_write_vectored(pos, inner, bufs)
-    }
-
-    #[inline]
-    fn is_write_vectored(&self) -> bool {
-        true
-    }
-
-    #[inline]
-    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
-        let (pos, inner) = self.into_parts_mut();
-        slice_write_all(pos, inner, buf)
-    }
-
-    #[inline]
-    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
-        let (pos, inner) = self.into_parts_mut();
-        slice_write_all_vectored(pos, inner, bufs)
-    }
-
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-#[stable(feature = "cursor_mut_vec", since = "1.25.0")]
-impl<A> WriteThroughCursor for &mut Vec<u8, A>
-where
-    A: Allocator,
-{
-    fn write(this: &mut Cursor<Self>, buf: &[u8]) -> io::Result<usize> {
-        let (pos, inner) = this.into_parts_mut();
-        vec_write_all(pos, inner, buf)
-    }
-
-    fn write_vectored(this: &mut Cursor<Self>, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        let (pos, inner) = this.into_parts_mut();
-        vec_write_all_vectored(pos, inner, bufs)
-    }
-
-    #[inline]
-    fn is_write_vectored(_this: &Cursor<Self>) -> bool {
-        true
-    }
-
-    fn write_all(this: &mut Cursor<Self>, buf: &[u8]) -> io::Result<()> {
-        let (pos, inner) = this.into_parts_mut();
-        vec_write_all(pos, inner, buf)?;
-        Ok(())
-    }
-
-    fn write_all_vectored(this: &mut Cursor<Self>, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
-        let (pos, inner) = this.into_parts_mut();
-        vec_write_all_vectored(pos, inner, bufs)?;
-        Ok(())
-    }
-
-    #[inline]
-    fn flush(_this: &mut Cursor<Self>) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<A> WriteThroughCursor for Vec<u8, A>
-where
-    A: Allocator,
-{
-    fn write(this: &mut Cursor<Self>, buf: &[u8]) -> io::Result<usize> {
-        let (pos, inner) = this.into_parts_mut();
-        vec_write_all(pos, inner, buf)
-    }
-
-    fn write_vectored(this: &mut Cursor<Self>, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        let (pos, inner) = this.into_parts_mut();
-        vec_write_all_vectored(pos, inner, bufs)
-    }
-
-    #[inline]
-    fn is_write_vectored(_this: &Cursor<Self>) -> bool {
-        true
-    }
-
-    fn write_all(this: &mut Cursor<Self>, buf: &[u8]) -> io::Result<()> {
-        let (pos, inner) = this.into_parts_mut();
-        vec_write_all(pos, inner, buf)?;
-        Ok(())
-    }
-
-    fn write_all_vectored(this: &mut Cursor<Self>, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
-        let (pos, inner) = this.into_parts_mut();
-        vec_write_all_vectored(pos, inner, bufs)?;
-        Ok(())
-    }
-
-    #[inline]
-    fn flush(_this: &mut Cursor<Self>) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-#[stable(feature = "cursor_box_slice", since = "1.5.0")]
-impl<A> WriteThroughCursor for Box<[u8], A>
-where
-    A: Allocator,
-{
-    #[inline]
-    fn write(this: &mut Cursor<Self>, buf: &[u8]) -> io::Result<usize> {
-        let (pos, inner) = this.into_parts_mut();
-        slice_write(pos, inner, buf)
-    }
-
-    #[inline]
-    fn write_vectored(this: &mut Cursor<Self>, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        let (pos, inner) = this.into_parts_mut();
-        slice_write_vectored(pos, inner, bufs)
-    }
-
-    #[inline]
-    fn is_write_vectored(_this: &Cursor<Self>) -> bool {
-        true
-    }
-
-    #[inline]
-    fn write_all(this: &mut Cursor<Self>, buf: &[u8]) -> io::Result<()> {
-        let (pos, inner) = this.into_parts_mut();
-        slice_write_all(pos, inner, buf)
-    }
-
-    #[inline]
-    fn write_all_vectored(this: &mut Cursor<Self>, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
-        let (pos, inner) = this.into_parts_mut();
-        slice_write_all_vectored(pos, inner, bufs)
-    }
-
-    #[inline]
-    fn flush(_this: &mut Cursor<Self>) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-#[stable(feature = "cursor_array", since = "1.61.0")]
-impl<const N: usize> Write for Cursor<[u8; N]> {
-    #[inline]
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        let (pos, inner) = self.into_parts_mut();
-        slice_write(pos, inner, buf)
-    }
-
-    #[inline]
-    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        let (pos, inner) = self.into_parts_mut();
-        slice_write_vectored(pos, inner, bufs)
-    }
-
-    #[inline]
-    fn is_write_vectored(&self) -> bool {
-        true
-    }
-
-    #[inline]
-    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
-        let (pos, inner) = self.into_parts_mut();
-        slice_write_all(pos, inner, buf)
-    }
-
-    #[inline]
-    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
-        let (pos, inner) = self.into_parts_mut();
-        slice_write_all_vectored(pos, inner, bufs)
-    }
-
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
diff --git a/library/std/src/io/impls.rs b/library/std/src/io/impls.rs
index 08bb34376b075..61f82828149aa 100644
--- a/library/std/src/io/impls.rs
+++ b/library/std/src/io/impls.rs
@@ -3,9 +3,9 @@ mod tests;
 
 use crate::alloc::Allocator;
 use crate::collections::VecDeque;
-use crate::io::{self, BorrowedCursor, BufRead, IoSlice, IoSliceMut, Read, Write};
+use crate::io::{self, BorrowedCursor, BufRead, IoSliceMut, Read};
 use crate::sync::Arc;
-use crate::{cmp, fmt, mem, str};
+use crate::{cmp, str};
 
 // =============================================================================
 // Forwarding implementations
@@ -53,43 +53,6 @@ impl<R: Read + ?Sized> Read for &mut R {
     }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<W: Write + ?Sized> Write for &mut W {
-    #[inline]
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        (**self).write(buf)
-    }
-
-    #[inline]
-    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        (**self).write_vectored(bufs)
-    }
-
-    #[inline]
-    fn is_write_vectored(&self) -> bool {
-        (**self).is_write_vectored()
-    }
-
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> {
-        (**self).flush()
-    }
-
-    #[inline]
-    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
-        (**self).write_all(buf)
-    }
-
-    #[inline]
-    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
-        (**self).write_all_vectored(bufs)
-    }
-
-    #[inline]
-    fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
-        (**self).write_fmt(fmt)
-    }
-}
-#[stable(feature = "rust1", since = "1.0.0")]
 impl<B: BufRead + ?Sized> BufRead for &mut B {
     #[inline]
     fn fill_buf(&mut self) -> io::Result<&[u8]> {
@@ -165,43 +128,6 @@ impl<R: Read + ?Sized> Read for Box<R> {
     }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<W: Write + ?Sized> Write for Box<W> {
-    #[inline]
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        (**self).write(buf)
-    }
-
-    #[inline]
-    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        (**self).write_vectored(bufs)
-    }
-
-    #[inline]
-    fn is_write_vectored(&self) -> bool {
-        (**self).is_write_vectored()
-    }
-
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> {
-        (**self).flush()
-    }
-
-    #[inline]
-    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
-        (**self).write_all(buf)
-    }
-
-    #[inline]
-    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
-        (**self).write_all_vectored(bufs)
-    }
-
-    #[inline]
-    fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
-        (**self).write_fmt(fmt)
-    }
-}
-#[stable(feature = "rust1", since = "1.0.0")]
 impl<B: BufRead + ?Sized> BufRead for Box<B> {
     #[inline]
     fn fill_buf(&mut self) -> io::Result<&[u8]> {
@@ -362,108 +288,6 @@ impl BufRead for &[u8] {
     }
 }
 
-/// Write is implemented for `&mut [u8]` by copying into the slice, overwriting
-/// its data.
-///
-/// Note that writing updates the slice to point to the yet unwritten part.
-/// The slice will be empty when it has been completely overwritten.
-///
-/// If the number of bytes to be written exceeds the size of the slice, write operations will
-/// return short writes: ultimately, `Ok(0)`; in this situation, `write_all` returns an error of
-/// kind `ErrorKind::WriteZero`.
-#[stable(feature = "rust1", since = "1.0.0")]
-impl Write for &mut [u8] {
-    #[inline]
-    fn write(&mut self, data: &[u8]) -> io::Result<usize> {
-        let amt = cmp::min(data.len(), self.len());
-        let (a, b) = mem::take(self).split_at_mut(amt);
-        a.copy_from_slice(&data[..amt]);
-        *self = b;
-        Ok(amt)
-    }
-
-    #[inline]
-    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        let mut nwritten = 0;
-        for buf in bufs {
-            nwritten += self.write(buf)?;
-            if self.is_empty() {
-                break;
-            }
-        }
-
-        Ok(nwritten)
-    }
-
-    #[inline]
-    fn is_write_vectored(&self) -> bool {
-        true
-    }
-
-    #[inline]
-    fn write_all(&mut self, data: &[u8]) -> io::Result<()> {
-        if self.write(data)? < data.len() { Err(io::Error::WRITE_ALL_EOF) } else { Ok(()) }
-    }
-
-    #[inline]
-    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
-        for buf in bufs {
-            if self.write(buf)? < buf.len() {
-                return Err(io::Error::WRITE_ALL_EOF);
-            }
-        }
-        Ok(())
-    }
-
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-/// Write is implemented for `Vec<u8>` by appending to the vector.
-/// The vector will grow as needed.
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<A: Allocator> Write for Vec<u8, A> {
-    #[inline]
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.extend_from_slice(buf);
-        Ok(buf.len())
-    }
-
-    #[inline]
-    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        let len = bufs.iter().map(|b| b.len()).sum();
-        self.reserve(len);
-        for buf in bufs {
-            self.extend_from_slice(buf);
-        }
-        Ok(len)
-    }
-
-    #[inline]
-    fn is_write_vectored(&self) -> bool {
-        true
-    }
-
-    #[inline]
-    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
-        self.extend_from_slice(buf);
-        Ok(())
-    }
-
-    #[inline]
-    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
-        self.write_vectored(bufs)?;
-        Ok(())
-    }
-
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
 /// Read is implemented for `VecDeque<u8>` by consuming bytes from the front of the `VecDeque`.
 #[stable(feature = "vecdeque_read_write", since = "1.63.0")]
 impl<A: Allocator> Read for VecDeque<u8, A> {
@@ -573,96 +397,6 @@ impl<A: Allocator> BufRead for VecDeque<u8, A> {
     }
 }
 
-/// Write is implemented for `VecDeque<u8>` by appending to the `VecDeque`, growing it as needed.
-#[stable(feature = "vecdeque_read_write", since = "1.63.0")]
-impl<A: Allocator> Write for VecDeque<u8, A> {
-    #[inline]
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.extend(buf);
-        Ok(buf.len())
-    }
-
-    #[inline]
-    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        let len = bufs.iter().map(|b| b.len()).sum();
-        self.reserve(len);
-        for buf in bufs {
-            self.extend(&**buf);
-        }
-        Ok(len)
-    }
-
-    #[inline]
-    fn is_write_vectored(&self) -> bool {
-        true
-    }
-
-    #[inline]
-    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
-        self.extend(buf);
-        Ok(())
-    }
-
-    #[inline]
-    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
-        self.write_vectored(bufs)?;
-        Ok(())
-    }
-
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-#[unstable(feature = "read_buf", issue = "78485")]
-impl<'a> io::Write for core::io::BorrowedCursor<'a, u8> {
-    #[inline]
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        let amt = cmp::min(buf.len(), self.capacity());
-        self.append(&buf[..amt]);
-        Ok(amt)
-    }
-
-    #[inline]
-    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        let mut nwritten = 0;
-        for buf in bufs {
-            let n = self.write(buf)?;
-            nwritten += n;
-            if n < buf.len() {
-                break;
-            }
-        }
-        Ok(nwritten)
-    }
-
-    #[inline]
-    fn is_write_vectored(&self) -> bool {
-        true
-    }
-
-    #[inline]
-    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
-        if self.write(buf)? < buf.len() { Err(io::Error::WRITE_ALL_EOF) } else { Ok(()) }
-    }
-
-    #[inline]
-    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
-        for buf in bufs {
-            if self.write(buf)? < buf.len() {
-                return Err(io::Error::WRITE_ALL_EOF);
-            }
-        }
-        Ok(())
-    }
-
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
 #[stable(feature = "io_traits_arc", since = "1.73.0")]
 impl<R: Read + ?Sized> Read for Arc<R>
 where
@@ -709,44 +443,3 @@ where
         (&**self).read_buf_exact(cursor)
     }
 }
-#[stable(feature = "io_traits_arc", since = "1.73.0")]
-impl<W: Write + ?Sized> Write for Arc<W>
-where
-    for<'a> &'a W: Write,
-    W: crate::io::IoHandle,
-{
-    #[inline]
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        (&**self).write(buf)
-    }
-
-    #[inline]
-    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        (&**self).write_vectored(bufs)
-    }
-
-    #[inline]
-    fn is_write_vectored(&self) -> bool {
-        (&**self).is_write_vectored()
-    }
-
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> {
-        (&**self).flush()
-    }
-
-    #[inline]
-    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
-        (&**self).write_all(buf)
-    }
-
-    #[inline]
-    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
-        (&**self).write_all_vectored(bufs)
-    }
-
-    #[inline]
-    fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
-        (&**self).write_fmt(fmt)
-    }
-}
diff --git a/library/std/src/io/mod.rs b/library/std/src/io/mod.rs
index 38c8120d66fc6..b1dbcf1f5bd46 100644
--- a/library/std/src/io/mod.rs
+++ b/library/std/src/io/mod.rs
@@ -306,11 +306,14 @@ pub use alloc_crate::io::RawOsError;
 pub use alloc_crate::io::SimpleMessage;
 #[unstable(feature = "io_const_error", issue = "133448")]
 pub use alloc_crate::io::const_error;
+#[allow(unused_imports, reason = "only used by certain platforms")]
+pub(crate) use alloc_crate::io::default_write_vectored;
 #[unstable(feature = "read_buf", issue = "78485")]
 pub use alloc_crate::io::{BorrowedBuf, BorrowedCursor};
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use alloc_crate::io::{
-    Chain, Empty, Error, ErrorKind, Repeat, Result, Seek, SeekFrom, Sink, Take, empty, repeat, sink,
+    Chain, Empty, Error, ErrorKind, Repeat, Result, Seek, SeekFrom, Sink, Take, Write, empty,
+    repeat, sink,
 };
 pub(crate) use alloc_crate::io::{IoHandle, stream_len_default};
 #[stable(feature = "iovec", since = "1.36.0")]
@@ -338,7 +341,7 @@ pub use self::{
     stdio::{Stderr, StderrLock, Stdin, StdinLock, Stdout, StdoutLock, stderr, stdin, stdout},
 };
 use crate::mem::MaybeUninit;
-use crate::{cmp, fmt, slice, str};
+use crate::{cmp, slice, str};
 
 mod buffered;
 pub(crate) mod copy;
@@ -549,14 +552,6 @@ where
     read(buf)
 }
 
-pub(crate) fn default_write_vectored<F>(write: F, bufs: &[IoSlice<'_>]) -> Result<usize>
-where
-    F: FnOnce(&[u8]) -> Result<usize>,
-{
-    let buf = bufs.iter().find(|b| !b.is_empty()).map_or(&[][..], |b| &**b);
-    write(buf)
-}
-
 pub(crate) fn default_read_exact<R: Read + ?Sized>(this: &mut R, mut buf: &mut [u8]) -> Result<()> {
     while !buf.is_empty() {
         match this.read(buf) {
@@ -600,47 +595,6 @@ pub(crate) fn default_read_buf_exact<R: Read + ?Sized>(
     Ok(())
 }
 
-pub(crate) fn default_write_fmt<W: Write + ?Sized>(
-    this: &mut W,
-    args: fmt::Arguments<'_>,
-) -> Result<()> {
-    // Create a shim which translates a `Write` to a `fmt::Write` and saves off
-    // I/O errors, instead of discarding them.
-    struct Adapter<'a, T: ?Sized + 'a> {
-        inner: &'a mut T,
-        error: Result<()>,
-    }
-
-    impl<T: Write + ?Sized> fmt::Write for Adapter<'_, T> {
-        fn write_str(&mut self, s: &str) -> fmt::Result {
-            match self.inner.write_all(s.as_bytes()) {
-                Ok(()) => Ok(()),
-                Err(e) => {
-                    self.error = Err(e);
-                    Err(fmt::Error)
-                }
-            }
-        }
-    }
-
-    let mut output = Adapter { inner: this, error: Ok(()) };
-    match fmt::write(&mut output, args) {
-        Ok(()) => Ok(()),
-        Err(..) => {
-            // Check whether the error came from the underlying `Write`.
-            if output.error.is_err() {
-                output.error
-            } else {
-                // This shouldn't happen: the underlying stream did not error,
-                // but somehow the formatter still errored?
-                panic!(
-                    "a formatting trait implementation returned an error when the underlying stream did not"
-                );
-            }
-        }
-    }
-}
-
 /// The `Read` trait allows for reading bytes from a source.
 ///
 /// Implementors of the `Read` trait are called 'readers'.
@@ -1403,365 +1357,6 @@ pub fn read_to_string<R: Read>(mut reader: R) -> Result<String> {
     Ok(buf)
 }
 
-/// A trait for objects which are byte-oriented sinks.
-///
-/// Implementors of the `Write` trait are sometimes called 'writers'.
-///
-/// Writers are defined by two required methods, [`write`] and [`flush`]:
-///
-/// * The [`write`] method will attempt to write some data into the object,
-///   returning how many bytes were successfully written.
-///
-/// * The [`flush`] method is useful for adapters and explicit buffers
-///   themselves for ensuring that all buffered data has been pushed out to the
-///   'true sink'.
-///
-/// Writers are intended to be composable with one another. Many implementors
-/// throughout [`std::io`] take and provide types which implement the `Write`
-/// trait.
-///
-/// [`write`]: Write::write
-/// [`flush`]: Write::flush
-/// [`std::io`]: self
-///
-/// # Examples
-///
-/// ```no_run
-/// use std::io::prelude::*;
-/// use std::fs::File;
-///
-/// fn main() -> std::io::Result<()> {
-///     let data = b"some bytes";
-///
-///     let mut pos = 0;
-///     let mut buffer = File::create("foo.txt")?;
-///
-///     while pos < data.len() {
-///         let bytes_written = buffer.write(&data[pos..])?;
-///         pos += bytes_written;
-///     }
-///     Ok(())
-/// }
-/// ```
-///
-/// The trait also provides convenience methods like [`write_all`], which calls
-/// `write` in a loop until its entire input has been written.
-///
-/// [`write_all`]: Write::write_all
-#[stable(feature = "rust1", since = "1.0.0")]
-#[doc(notable_trait)]
-#[cfg_attr(not(test), rustc_diagnostic_item = "IoWrite")]
-pub trait Write {
-    /// Writes a buffer into this writer, returning how many bytes were written.
-    ///
-    /// This function will attempt to write the entire contents of `buf`, but
-    /// the entire write might not succeed, or the write may also generate an
-    /// error. Typically, a call to `write` represents one attempt to write to
-    /// any wrapped object.
-    ///
-    /// Calls to `write` are not guaranteed to block waiting for data to be
-    /// written, and a write which would otherwise block can be indicated through
-    /// an [`Err`] variant.
-    ///
-    /// If this method consumed `n > 0` bytes of `buf` it must return [`Ok(n)`].
-    /// If the return value is `Ok(n)` then `n` must satisfy `n <= buf.len()`.
-    /// A return value of `Ok(0)` typically means that the underlying object is
-    /// no longer able to accept bytes and will likely not be able to in the
-    /// future as well, or that the buffer provided is empty.
-    ///
-    /// # Errors
-    ///
-    /// Each call to `write` may generate an I/O error indicating that the
-    /// operation could not be completed. If an error is returned then no bytes
-    /// in the buffer were written to this writer.
-    ///
-    /// It is **not** considered an error if the entire buffer could not be
-    /// written to this writer.
-    ///
-    /// An error of the [`ErrorKind::Interrupted`] kind is non-fatal and the
-    /// write operation should be retried if there is nothing else to do.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// use std::io::prelude::*;
-    /// use std::fs::File;
-    ///
-    /// fn main() -> std::io::Result<()> {
-    ///     let mut buffer = File::create("foo.txt")?;
-    ///
-    ///     // Writes some prefix of the byte string, not necessarily all of it.
-    ///     buffer.write(b"some bytes")?;
-    ///     Ok(())
-    /// }
-    /// ```
-    ///
-    /// [`Ok(n)`]: Ok
-    #[stable(feature = "rust1", since = "1.0.0")]
-    fn write(&mut self, buf: &[u8]) -> Result<usize>;
-
-    /// Like [`write`], except that it writes from a slice of buffers.
-    ///
-    /// Data is copied from each buffer in order, with the final buffer
-    /// read from possibly being only partially consumed. This method must
-    /// behave as a call to [`write`] with the buffers concatenated would.
-    ///
-    /// The default implementation calls [`write`] with either the first nonempty
-    /// buffer provided, or an empty one if none exists.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// use std::io::IoSlice;
-    /// use std::io::prelude::*;
-    /// use std::fs::File;
-    ///
-    /// fn main() -> std::io::Result<()> {
-    ///     let data1 = [1; 8];
-    ///     let data2 = [15; 8];
-    ///     let io_slice1 = IoSlice::new(&data1);
-    ///     let io_slice2 = IoSlice::new(&data2);
-    ///
-    ///     let mut buffer = File::create("foo.txt")?;
-    ///
-    ///     // Writes some prefix of the byte string, not necessarily all of it.
-    ///     buffer.write_vectored(&[io_slice1, io_slice2])?;
-    ///     Ok(())
-    /// }
-    /// ```
-    ///
-    /// [`write`]: Write::write
-    #[stable(feature = "iovec", since = "1.36.0")]
-    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize> {
-        default_write_vectored(|b| self.write(b), bufs)
-    }
-
-    /// Determines if this `Write`r has an efficient [`write_vectored`]
-    /// implementation.
-    ///
-    /// If a `Write`r does not override the default [`write_vectored`]
-    /// implementation, code using it may want to avoid the method all together
-    /// and coalesce writes into a single buffer for higher performance.
-    ///
-    /// The default implementation returns `false`.
-    ///
-    /// [`write_vectored`]: Write::write_vectored
-    #[unstable(feature = "can_vector", issue = "69941")]
-    fn is_write_vectored(&self) -> bool {
-        false
-    }
-
-    /// Flushes this output stream, ensuring that all intermediately buffered
-    /// contents reach their destination.
-    ///
-    /// # Errors
-    ///
-    /// It is considered an error if not all bytes could be written due to
-    /// I/O errors or EOF being reached.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// use std::io::prelude::*;
-    /// use std::io::BufWriter;
-    /// use std::fs::File;
-    ///
-    /// fn main() -> std::io::Result<()> {
-    ///     let mut buffer = BufWriter::new(File::create("foo.txt")?);
-    ///
-    ///     buffer.write_all(b"some bytes")?;
-    ///     buffer.flush()?;
-    ///     Ok(())
-    /// }
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    fn flush(&mut self) -> Result<()>;
-
-    /// Attempts to write an entire buffer into this writer.
-    ///
-    /// This method will continuously call [`write`] until there is no more data
-    /// to be written or an error of non-[`ErrorKind::Interrupted`] kind is
-    /// returned. This method will not return until the entire buffer has been
-    /// successfully written or such an error occurs. The first error that is
-    /// not of [`ErrorKind::Interrupted`] kind generated from this method will be
-    /// returned.
-    ///
-    /// If the buffer contains no data, this will never call [`write`].
-    ///
-    /// # Errors
-    ///
-    /// This function will return the first error of
-    /// non-[`ErrorKind::Interrupted`] kind that [`write`] returns.
-    ///
-    /// [`write`]: Write::write
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// use std::io::prelude::*;
-    /// use std::fs::File;
-    ///
-    /// fn main() -> std::io::Result<()> {
-    ///     let mut buffer = File::create("foo.txt")?;
-    ///
-    ///     buffer.write_all(b"some bytes")?;
-    ///     Ok(())
-    /// }
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    fn write_all(&mut self, mut buf: &[u8]) -> Result<()> {
-        while !buf.is_empty() {
-            match self.write(buf) {
-                Ok(0) => {
-                    return Err(Error::WRITE_ALL_EOF);
-                }
-                Ok(n) => buf = &buf[n..],
-                Err(ref e) if e.is_interrupted() => {}
-                Err(e) => return Err(e),
-            }
-        }
-        Ok(())
-    }
-
-    /// Attempts to write multiple buffers into this writer.
-    ///
-    /// This method will continuously call [`write_vectored`] until there is no
-    /// more data to be written or an error of non-[`ErrorKind::Interrupted`]
-    /// kind is returned. This method will not return until all buffers have
-    /// been successfully written or such an error occurs. The first error that
-    /// is not of [`ErrorKind::Interrupted`] kind generated from this method
-    /// will be returned.
-    ///
-    /// If the buffer contains no data, this will never call [`write_vectored`].
-    ///
-    /// # Notes
-    ///
-    /// Unlike [`write_vectored`], this takes a *mutable* reference to
-    /// a slice of [`IoSlice`]s, not an immutable one. That's because we need to
-    /// modify the slice to keep track of the bytes already written.
-    ///
-    /// Once this function returns, the contents of `bufs` are unspecified, as
-    /// this depends on how many calls to [`write_vectored`] were necessary. It is
-    /// best to understand this function as taking ownership of `bufs` and to
-    /// not use `bufs` afterwards. The underlying buffers, to which the
-    /// [`IoSlice`]s point (but not the [`IoSlice`]s themselves), are unchanged and
-    /// can be reused.
-    ///
-    /// [`write_vectored`]: Write::write_vectored
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(write_all_vectored)]
-    /// # fn main() -> std::io::Result<()> {
-    ///
-    /// use std::io::{Write, IoSlice};
-    ///
-    /// let mut writer = Vec::new();
-    /// let bufs = &mut [
-    ///     IoSlice::new(&[1]),
-    ///     IoSlice::new(&[2, 3]),
-    ///     IoSlice::new(&[4, 5, 6]),
-    /// ];
-    ///
-    /// writer.write_all_vectored(bufs)?;
-    /// // Note: the contents of `bufs` is now undefined, see the Notes section.
-    ///
-    /// assert_eq!(writer, &[1, 2, 3, 4, 5, 6]);
-    /// # Ok(()) }
-    /// ```
-    #[unstable(feature = "write_all_vectored", issue = "70436")]
-    fn write_all_vectored(&mut self, mut bufs: &mut [IoSlice<'_>]) -> Result<()> {
-        // Guarantee that bufs is empty if it contains no data,
-        // to avoid calling write_vectored if there is no data to be written.
-        IoSlice::advance_slices(&mut bufs, 0);
-        while !bufs.is_empty() {
-            match self.write_vectored(bufs) {
-                Ok(0) => {
-                    return Err(Error::WRITE_ALL_EOF);
-                }
-                Ok(n) => IoSlice::advance_slices(&mut bufs, n),
-                Err(ref e) if e.is_interrupted() => {}
-                Err(e) => return Err(e),
-            }
-        }
-        Ok(())
-    }
-
-    /// Writes a formatted string into this writer, returning any error
-    /// encountered.
-    ///
-    /// This method is primarily used to interface with the
-    /// [`format_args!()`] macro, and it is rare that this should
-    /// explicitly be called. The [`write!()`] macro should be favored to
-    /// invoke this method instead.
-    ///
-    /// This function internally uses the [`write_all`] method on
-    /// this trait and hence will continuously write data so long as no errors
-    /// are received. This also means that partial writes are not indicated in
-    /// this signature.
-    ///
-    /// [`write_all`]: Write::write_all
-    ///
-    /// # Errors
-    ///
-    /// This function will return any I/O error reported while formatting.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// use std::io::prelude::*;
-    /// use std::fs::File;
-    ///
-    /// fn main() -> std::io::Result<()> {
-    ///     let mut buffer = File::create("foo.txt")?;
-    ///
-    ///     // this call
-    ///     write!(buffer, "{:.*}", 2, 1.234567)?;
-    ///     // turns into this:
-    ///     buffer.write_fmt(format_args!("{:.*}", 2, 1.234567))?;
-    ///     Ok(())
-    /// }
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    fn write_fmt(&mut self, args: fmt::Arguments<'_>) -> Result<()> {
-        if let Some(s) = args.as_statically_known_str() {
-            self.write_all(s.as_bytes())
-        } else {
-            default_write_fmt(self, args)
-        }
-    }
-
-    /// Creates a "by reference" adapter for this instance of `Write`.
-    ///
-    /// The returned adapter also implements `Write` and will simply borrow this
-    /// current writer.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// use std::io::Write;
-    /// use std::fs::File;
-    ///
-    /// fn main() -> std::io::Result<()> {
-    ///     let mut buffer = File::create("foo.txt")?;
-    ///
-    ///     let reference = buffer.by_ref();
-    ///
-    ///     // we can use reference just like our original buffer
-    ///     reference.write_all(b"some bytes")?;
-    ///     Ok(())
-    /// }
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    fn by_ref(&mut self) -> &mut Self
-    where
-        Self: Sized,
-    {
-        self
-    }
-}
-
 fn read_until<R: BufRead + ?Sized>(r: &mut R, delim: u8, buf: &mut Vec<u8>) -> Result<usize> {
     let mut read = 0;
     loop {
diff --git a/library/std/src/io/util.rs b/library/std/src/io/util.rs
index ce2137f9567c7..ac3e0f84d1e80 100644
--- a/library/std/src/io/util.rs
+++ b/library/std/src/io/util.rs
@@ -3,10 +3,7 @@
 #[cfg(test)]
 mod tests;
 
-use crate::fmt;
-use crate::io::{
-    self, BorrowedCursor, BufRead, Empty, IoSlice, IoSliceMut, Read, Repeat, Sink, Write,
-};
+use crate::io::{self, BorrowedCursor, BufRead, Empty, IoSliceMut, Read, Repeat};
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl Read for Empty {
@@ -83,84 +80,6 @@ impl BufRead for Empty {
     }
 }
 
-#[stable(feature = "empty_write", since = "1.73.0")]
-impl Write for Empty {
-    #[inline]
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        Ok(buf.len())
-    }
-
-    #[inline]
-    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        let total_len = bufs.iter().map(|b| b.len()).sum();
-        Ok(total_len)
-    }
-
-    #[inline]
-    fn is_write_vectored(&self) -> bool {
-        true
-    }
-
-    #[inline]
-    fn write_all(&mut self, _buf: &[u8]) -> io::Result<()> {
-        Ok(())
-    }
-
-    #[inline]
-    fn write_all_vectored(&mut self, _bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
-        Ok(())
-    }
-
-    #[inline]
-    fn write_fmt(&mut self, _args: fmt::Arguments<'_>) -> io::Result<()> {
-        Ok(())
-    }
-
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-#[stable(feature = "empty_write", since = "1.73.0")]
-impl Write for &Empty {
-    #[inline]
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        Ok(buf.len())
-    }
-
-    #[inline]
-    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        let total_len = bufs.iter().map(|b| b.len()).sum();
-        Ok(total_len)
-    }
-
-    #[inline]
-    fn is_write_vectored(&self) -> bool {
-        true
-    }
-
-    #[inline]
-    fn write_all(&mut self, _buf: &[u8]) -> io::Result<()> {
-        Ok(())
-    }
-
-    #[inline]
-    fn write_all_vectored(&mut self, _bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
-        Ok(())
-    }
-
-    #[inline]
-    fn write_fmt(&mut self, _args: fmt::Arguments<'_>) -> io::Result<()> {
-        Ok(())
-    }
-
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
 #[stable(feature = "rust1", since = "1.0.0")]
 impl Read for Repeat {
     #[inline]
@@ -213,81 +132,3 @@ impl Read for Repeat {
         true
     }
 }
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl Write for Sink {
-    #[inline]
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        Ok(buf.len())
-    }
-
-    #[inline]
-    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        let total_len = bufs.iter().map(|b| b.len()).sum();
-        Ok(total_len)
-    }
-
-    #[inline]
-    fn is_write_vectored(&self) -> bool {
-        true
-    }
-
-    #[inline]
-    fn write_all(&mut self, _buf: &[u8]) -> io::Result<()> {
-        Ok(())
-    }
-
-    #[inline]
-    fn write_all_vectored(&mut self, _bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
-        Ok(())
-    }
-
-    #[inline]
-    fn write_fmt(&mut self, _args: fmt::Arguments<'_>) -> io::Result<()> {
-        Ok(())
-    }
-
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-#[stable(feature = "write_mt", since = "1.48.0")]
-impl Write for &Sink {
-    #[inline]
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        Ok(buf.len())
-    }
-
-    #[inline]
-    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        let total_len = bufs.iter().map(|b| b.len()).sum();
-        Ok(total_len)
-    }
-
-    #[inline]
-    fn is_write_vectored(&self) -> bool {
-        true
-    }
-
-    #[inline]
-    fn write_all(&mut self, _buf: &[u8]) -> io::Result<()> {
-        Ok(())
-    }
-
-    #[inline]
-    fn write_all_vectored(&mut self, _bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
-        Ok(())
-    }
-
-    #[inline]
-    fn write_fmt(&mut self, _args: fmt::Arguments<'_>) -> io::Result<()> {
-        Ok(())
-    }
-
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index db37df63c5763..7cf576ecd8803 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -322,6 +322,7 @@
 #![feature(borrowed_buf_init)]
 #![feature(bstr)]
 #![feature(bstr_internals)]
+#![feature(can_vector)]
 #![feature(cast_maybe_uninit)]
 #![feature(char_internals)]
 #![feature(clone_to_uninit)]
@@ -389,6 +390,7 @@
 #![feature(ub_checks)]
 #![feature(uint_carryless_mul)]
 #![feature(used_with_arg)]
+#![feature(write_all_vectored)]
 // tidy-alphabetical-end
 //
 // Library features (alloc):
diff --git a/library/std/src/sys/alloc/hermit.rs b/library/std/src/sys/alloc/hermit.rs
index 77f8200a70a64..9afcb315f4ab5 100644
--- a/library/std/src/sys/alloc/hermit.rs
+++ b/library/std/src/sys/alloc/hermit.rs
@@ -1,27 +1,24 @@
-use crate::alloc::{GlobalAlloc, Layout, System};
+use crate::alloc::Layout;
 
-#[stable(feature = "alloc_system_type", since = "1.28.0")]
-unsafe impl GlobalAlloc for System {
-    #[inline]
-    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-        let size = layout.size();
-        let align = layout.align();
-        unsafe { hermit_abi::malloc(size, align) }
-    }
+#[inline]
+pub unsafe fn alloc(layout: Layout) -> *mut u8 {
+    let size = layout.size();
+    let align = layout.align();
+    unsafe { hermit_abi::malloc(size, align) }
+}
 
-    #[inline]
-    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
-        let size = layout.size();
-        let align = layout.align();
-        unsafe {
-            hermit_abi::free(ptr, size, align);
-        }
+#[inline]
+pub unsafe fn dealloc(ptr: *mut u8, layout: Layout) {
+    let size = layout.size();
+    let align = layout.align();
+    unsafe {
+        hermit_abi::free(ptr, size, align);
     }
+}
 
-    #[inline]
-    unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
-        let size = layout.size();
-        let align = layout.align();
-        unsafe { hermit_abi::realloc(ptr, size, align, new_size) }
-    }
+#[inline]
+pub unsafe fn realloc(ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
+    let size = layout.size();
+    let align = layout.align();
+    unsafe { hermit_abi::realloc(ptr, size, align, new_size) }
 }
diff --git a/library/std/src/sys/alloc/mod.rs b/library/std/src/sys/alloc/mod.rs
index f2f1d1c7feceb..73d35781f09bf 100644
--- a/library/std/src/sys/alloc/mod.rs
+++ b/library/std/src/sys/alloc/mod.rs
@@ -1,6 +1,6 @@
 #![forbid(unsafe_op_in_unsafe_fn)]
 
-use crate::alloc::{GlobalAlloc, Layout, System};
+use crate::alloc::Layout;
 use crate::ptr;
 
 // The minimum alignment guaranteed by the architecture. This value is used to
@@ -47,21 +47,16 @@ const MIN_ALIGN: usize = if cfg!(any(
 };
 
 #[allow(dead_code)]
-unsafe fn realloc_fallback(
-    alloc: &System,
-    ptr: *mut u8,
-    old_layout: Layout,
-    new_size: usize,
-) -> *mut u8 {
+unsafe fn realloc_fallback(ptr: *mut u8, old_layout: Layout, new_size: usize) -> *mut u8 {
     // SAFETY: Docs for GlobalAlloc::realloc require this to be valid
     unsafe {
         let new_layout = Layout::from_size_align_unchecked(new_size, old_layout.align());
 
-        let new_ptr = GlobalAlloc::alloc(alloc, new_layout);
+        let new_ptr = alloc(new_layout);
         if !new_ptr.is_null() {
             let size = usize::min(old_layout.size(), new_size);
             ptr::copy_nonoverlapping(ptr, new_ptr, size);
-            GlobalAlloc::dealloc(alloc, ptr, old_layout);
+            dealloc(ptr, old_layout);
         }
 
         new_ptr
@@ -76,35 +71,69 @@ cfg_select! {
         target_os = "trusty",
     ) => {
         mod unix;
+        use unix as imp;
     }
     target_os = "windows" => {
         mod windows;
+        use windows as imp;
     }
     target_os = "hermit" => {
         mod hermit;
+        use hermit as imp;
     }
     target_os = "motor" => {
         mod motor;
+        use motor as imp;
     }
     all(target_vendor = "fortanix", target_env = "sgx") => {
         mod sgx;
+        use sgx as imp;
     }
     target_os = "solid_asp3" => {
         mod solid;
+        use solid as imp;
     }
     target_os = "uefi" => {
         mod uefi;
+        use uefi as imp;
     }
     target_os = "vexos" => {
         mod vexos;
+        use vexos as imp;
     }
     target_family = "wasm" => {
         mod wasm;
+        use wasm as imp;
     }
     target_os = "xous" => {
         mod xous;
+        use xous as imp;
     }
     target_os = "zkvm" => {
         mod zkvm;
+        use zkvm as imp;
+    }
+}
+
+pub use imp::{alloc, dealloc, realloc};
+
+cfg_select! {
+    any(
+        target_os = "hermit",
+        target_os = "solid_asp3",
+        target_os = "uefi",
+        target_os = "zkvm",
+    ) => {
+        #[inline]
+        pub unsafe fn alloc_zeroed(layout: Layout) -> *mut u8 {
+            let ptr = unsafe { alloc(layout) };
+            if !ptr.is_null() {
+                unsafe { ptr.write_bytes(0, layout.size()) };
+            }
+            ptr
+        }
+    }
+    _ => {
+        pub use imp::alloc_zeroed;
     }
 }
diff --git a/library/std/src/sys/alloc/motor.rs b/library/std/src/sys/alloc/motor.rs
index 271e3c40c26ae..090dc198bb500 100644
--- a/library/std/src/sys/alloc/motor.rs
+++ b/library/std/src/sys/alloc/motor.rs
@@ -1,28 +1,13 @@
-use crate::alloc::{GlobalAlloc, Layout, System};
+use crate::alloc::Layout;
 
-#[stable(feature = "alloc_system_type", since = "1.28.0")]
-unsafe impl GlobalAlloc for System {
-    #[inline]
-    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-        // SAFETY: same requirements as in GlobalAlloc::alloc.
-        moto_rt::alloc::alloc(layout)
-    }
-
-    #[inline]
-    unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
-        // SAFETY: same requirements as in GlobalAlloc::alloc_zeroed.
-        moto_rt::alloc::alloc_zeroed(layout)
-    }
-
-    #[inline]
-    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
-        // SAFETY: same requirements as in GlobalAlloc::dealloc.
-        unsafe { moto_rt::alloc::dealloc(ptr, layout) }
-    }
+#[inline]
+pub unsafe fn alloc(layout: Layout) -> *mut u8 {
+    moto_rt::alloc::alloc(layout)
+}
 
-    #[inline]
-    unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
-        // SAFETY: same requirements as in GlobalAlloc::realloc.
-        unsafe { moto_rt::alloc::realloc(ptr, layout, new_size) }
-    }
+#[inline]
+pub unsafe fn alloc_zeroed(layout: Layout) -> *mut u8 {
+    moto_rt::alloc::alloc_zeroed(layout)
 }
+
+pub use moto_rt::alloc::{dealloc, realloc};
diff --git a/library/std/src/sys/alloc/sgx.rs b/library/std/src/sys/alloc/sgx.rs
index afdef7a5cb647..c20761259048e 100644
--- a/library/std/src/sys/alloc/sgx.rs
+++ b/library/std/src/sys/alloc/sgx.rs
@@ -1,4 +1,4 @@
-use crate::alloc::{GlobalAlloc, Layout, System};
+use crate::alloc::Layout;
 use crate::ptr;
 use crate::sync::atomic::{Atomic, AtomicBool, Ordering};
 use crate::sys::pal::abi::mem as sgx_mem;
@@ -57,31 +57,28 @@ unsafe impl dlmalloc::Allocator for Sgx {
     }
 }
 
-#[stable(feature = "alloc_system_type", since = "1.28.0")]
-unsafe impl GlobalAlloc for System {
-    #[inline]
-    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-        // SAFETY: the caller must uphold the safety contract for `malloc`
-        unsafe { DLMALLOC.lock().malloc(layout.size(), layout.align()) }
-    }
+#[inline]
+pub unsafe fn alloc(layout: Layout) -> *mut u8 {
+    // SAFETY: the caller must uphold the safety contract for `malloc`
+    unsafe { DLMALLOC.lock().malloc(layout.size(), layout.align()) }
+}
 
-    #[inline]
-    unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
-        // SAFETY: the caller must uphold the safety contract for `malloc`
-        unsafe { DLMALLOC.lock().calloc(layout.size(), layout.align()) }
-    }
+#[inline]
+pub unsafe fn alloc_zeroed(layout: Layout) -> *mut u8 {
+    // SAFETY: the caller must uphold the safety contract for `malloc`
+    unsafe { DLMALLOC.lock().calloc(layout.size(), layout.align()) }
+}
 
-    #[inline]
-    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
-        // SAFETY: the caller must uphold the safety contract for `malloc`
-        unsafe { DLMALLOC.lock().free(ptr, layout.size(), layout.align()) }
-    }
+#[inline]
+pub unsafe fn dealloc(ptr: *mut u8, layout: Layout) {
+    // SAFETY: the caller must uphold the safety contract for `malloc`
+    unsafe { DLMALLOC.lock().free(ptr, layout.size(), layout.align()) }
+}
 
-    #[inline]
-    unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
-        // SAFETY: the caller must uphold the safety contract for `malloc`
-        unsafe { DLMALLOC.lock().realloc(ptr, layout.size(), layout.align(), new_size) }
-    }
+#[inline]
+pub unsafe fn realloc(ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
+    // SAFETY: the caller must uphold the safety contract for `malloc`
+    unsafe { DLMALLOC.lock().realloc(ptr, layout.size(), layout.align(), new_size) }
 }
 
 // The following functions are needed by libunwind. These symbols are named
diff --git a/library/std/src/sys/alloc/solid.rs b/library/std/src/sys/alloc/solid.rs
index 47cfa2eb1162b..5d3f396f0dd11 100644
--- a/library/std/src/sys/alloc/solid.rs
+++ b/library/std/src/sys/alloc/solid.rs
@@ -1,30 +1,27 @@
 use super::{MIN_ALIGN, realloc_fallback};
-use crate::alloc::{GlobalAlloc, Layout, System};
+use crate::alloc::Layout;
 
-#[stable(feature = "alloc_system_type", since = "1.28.0")]
-unsafe impl GlobalAlloc for System {
-    #[inline]
-    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-        if layout.align() <= MIN_ALIGN && layout.align() <= layout.size() {
-            unsafe { libc::malloc(layout.size()) as *mut u8 }
-        } else {
-            unsafe { libc::memalign(layout.align(), layout.size()) as *mut u8 }
-        }
+#[inline]
+pub unsafe fn alloc(layout: Layout) -> *mut u8 {
+    if layout.align() <= MIN_ALIGN && layout.align() <= layout.size() {
+        unsafe { libc::malloc(layout.size()) as *mut u8 }
+    } else {
+        unsafe { libc::memalign(layout.align(), layout.size()) as *mut u8 }
     }
+}
 
-    #[inline]
-    unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
-        unsafe { libc::free(ptr as *mut libc::c_void) }
-    }
+#[inline]
+pub unsafe fn dealloc(ptr: *mut u8, _layout: Layout) {
+    unsafe { libc::free(ptr as *mut libc::c_void) }
+}
 
-    #[inline]
-    unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
-        unsafe {
-            if layout.align() <= MIN_ALIGN && layout.align() <= new_size {
-                libc::realloc(ptr as *mut libc::c_void, new_size) as *mut u8
-            } else {
-                realloc_fallback(self, ptr, layout, new_size)
-            }
+#[inline]
+pub unsafe fn realloc(ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
+    unsafe {
+        if layout.align() <= MIN_ALIGN && layout.align() <= new_size {
+            libc::realloc(ptr as *mut libc::c_void, new_size) as *mut u8
+        } else {
+            realloc_fallback(ptr, layout, new_size)
         }
     }
 }
diff --git a/library/std/src/sys/alloc/uefi.rs b/library/std/src/sys/alloc/uefi.rs
index 5221876e90866..aa7fcc9fe110c 100644
--- a/library/std/src/sys/alloc/uefi.rs
+++ b/library/std/src/sys/alloc/uefi.rs
@@ -3,47 +3,48 @@
 
 use r_efi::protocols::loaded_image;
 
-use crate::alloc::{GlobalAlloc, Layout, System};
+use crate::alloc::Layout;
 use crate::sync::OnceLock;
 use crate::sys::pal::helpers;
 
-#[stable(feature = "alloc_system_type", since = "1.28.0")]
-unsafe impl GlobalAlloc for System {
-    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-        static EFI_MEMORY_TYPE: OnceLock<u32> = OnceLock::new();
-
-        // Return null pointer if boot services are not available
-        if crate::os::uefi::env::boot_services().is_none() {
-            return crate::ptr::null_mut();
-        }
-
-        // If boot services is valid then SystemTable is not null.
-        let system_table = crate::os::uefi::env::system_table().as_ptr().cast();
-
-        // Each loaded image has an image handle that supports `EFI_LOADED_IMAGE_PROTOCOL`. Thus, this
-        // will never fail.
-        let mem_type = EFI_MEMORY_TYPE.get_or_init(|| {
-            let protocol = helpers::image_handle_protocol::<loaded_image::Protocol>(
-                loaded_image::PROTOCOL_GUID,
-            )
-            .unwrap();
-            // Gives allocations the memory type that the data sections were loaded as.
-            unsafe { (*protocol.as_ptr()).image_data_type }
-        });
-
-        // The caller must ensure non-0 layout
-        unsafe { r_efi_alloc::raw::alloc(system_table, layout, *mem_type) }
+pub unsafe fn alloc(layout: Layout) -> *mut u8 {
+    static EFI_MEMORY_TYPE: OnceLock<u32> = OnceLock::new();
+
+    // Return null pointer if boot services are not available
+    if crate::os::uefi::env::boot_services().is_none() {
+        return crate::ptr::null_mut();
     }
 
-    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
-        // Do nothing if boot services are not available
-        if crate::os::uefi::env::boot_services().is_none() {
-            return;
-        }
+    // If boot services is valid then SystemTable is not null.
+    let system_table = crate::os::uefi::env::system_table().as_ptr().cast();
+
+    // Each loaded image has an image handle that supports `EFI_LOADED_IMAGE_PROTOCOL`. Thus, this
+    // will never fail.
+    let mem_type = EFI_MEMORY_TYPE.get_or_init(|| {
+        let protocol =
+            helpers::image_handle_protocol::<loaded_image::Protocol>(loaded_image::PROTOCOL_GUID)
+                .unwrap();
+        // Gives allocations the memory type that the data sections were loaded as.
+        unsafe { (*protocol.as_ptr()).image_data_type }
+    });
+
+    // The caller must ensure non-0 layout
+    unsafe { r_efi_alloc::raw::alloc(system_table, layout, *mem_type) }
+}
 
-        // If boot services is valid then SystemTable is not null.
-        let system_table = crate::os::uefi::env::system_table().as_ptr().cast();
-        // The caller must ensure non-0 layout
-        unsafe { r_efi_alloc::raw::dealloc(system_table, ptr, layout) }
+pub unsafe fn dealloc(ptr: *mut u8, layout: Layout) {
+    // Do nothing if boot services are not available
+    if crate::os::uefi::env::boot_services().is_none() {
+        return;
     }
+
+    // If boot services is valid then SystemTable is not null.
+    let system_table = crate::os::uefi::env::system_table().as_ptr().cast();
+    // The caller must ensure non-0 layout
+    unsafe { r_efi_alloc::raw::dealloc(system_table, ptr, layout) }
+}
+
+pub unsafe fn realloc(ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
+    // SAFETY: this is just a `pub` wrapper.
+    unsafe { super::realloc_fallback(ptr, layout, new_size) }
 }
diff --git a/library/std/src/sys/alloc/unix.rs b/library/std/src/sys/alloc/unix.rs
index 3d369b08abc77..d6de8bf28c44c 100644
--- a/library/std/src/sys/alloc/unix.rs
+++ b/library/std/src/sys/alloc/unix.rs
@@ -1,60 +1,57 @@
 use super::{MIN_ALIGN, realloc_fallback};
-use crate::alloc::{GlobalAlloc, Layout, System};
+use crate::alloc::Layout;
 use crate::ptr;
 
-#[stable(feature = "alloc_system_type", since = "1.28.0")]
-unsafe impl GlobalAlloc for System {
-    #[inline]
-    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-        // jemalloc provides alignment less than MIN_ALIGN for small allocations.
-        // So only rely on MIN_ALIGN if size >= align.
-        // Also see <https://github.com/rust-lang/rust/issues/45955> and
-        // <https://github.com/rust-lang/rust/issues/62251#issuecomment-507580914>.
-        if layout.align() <= MIN_ALIGN && layout.align() <= layout.size() {
-            unsafe { libc::malloc(layout.size()) as *mut u8 }
-        } else {
-            // `posix_memalign` returns a non-aligned value if supplied a very
-            // large alignment on older versions of Apple's platforms (unknown
-            // exactly which version range, but the issue is definitely
-            // present in macOS 10.14 and iOS 13.3).
-            //
-            // <https://github.com/rust-lang/rust/issues/30170>
-            #[cfg(target_vendor = "apple")]
-            {
-                if layout.align() > (1 << 31) {
-                    return ptr::null_mut();
-                }
+#[inline]
+pub unsafe fn alloc(layout: Layout) -> *mut u8 {
+    // jemalloc provides alignment less than MIN_ALIGN for small allocations.
+    // So only rely on MIN_ALIGN if size >= align.
+    // Also see <https://github.com/rust-lang/rust/issues/45955> and
+    // <https://github.com/rust-lang/rust/issues/62251#issuecomment-507580914>.
+    if layout.align() <= MIN_ALIGN && layout.align() <= layout.size() {
+        unsafe { libc::malloc(layout.size()) as *mut u8 }
+    } else {
+        // `posix_memalign` returns a non-aligned value if supplied a very
+        // large alignment on older versions of Apple's platforms (unknown
+        // exactly which version range, but the issue is definitely
+        // present in macOS 10.14 and iOS 13.3).
+        //
+        // <https://github.com/rust-lang/rust/issues/30170>
+        #[cfg(target_vendor = "apple")]
+        {
+            if layout.align() > (1 << 31) {
+                return ptr::null_mut();
             }
-            unsafe { aligned_malloc(&layout) }
         }
+        unsafe { aligned_malloc(&layout) }
     }
+}
 
-    #[inline]
-    unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
-        // See the comment above in `alloc` for why this check looks the way it does.
-        if layout.align() <= MIN_ALIGN && layout.align() <= layout.size() {
-            unsafe { libc::calloc(layout.size(), 1) as *mut u8 }
-        } else {
-            let ptr = unsafe { self.alloc(layout) };
-            if !ptr.is_null() {
-                unsafe { ptr::write_bytes(ptr, 0, layout.size()) };
-            }
-            ptr
+#[inline]
+pub unsafe fn alloc_zeroed(layout: Layout) -> *mut u8 {
+    // See the comment above in `alloc` for why this check looks the way it does.
+    if layout.align() <= MIN_ALIGN && layout.align() <= layout.size() {
+        unsafe { libc::calloc(layout.size(), 1) as *mut u8 }
+    } else {
+        let ptr = unsafe { alloc(layout) };
+        if !ptr.is_null() {
+            unsafe { ptr::write_bytes(ptr, 0, layout.size()) };
         }
+        ptr
     }
+}
 
-    #[inline]
-    unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
-        unsafe { libc::free(ptr as *mut libc::c_void) }
-    }
+#[inline]
+pub unsafe fn dealloc(ptr: *mut u8, _layout: Layout) {
+    unsafe { libc::free(ptr as *mut libc::c_void) }
+}
 
-    #[inline]
-    unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
-        if layout.align() <= MIN_ALIGN && layout.align() <= new_size {
-            unsafe { libc::realloc(ptr as *mut libc::c_void, new_size) as *mut u8 }
-        } else {
-            unsafe { realloc_fallback(self, ptr, layout, new_size) }
-        }
+#[inline]
+pub unsafe fn realloc(ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
+    if layout.align() <= MIN_ALIGN && layout.align() <= new_size {
+        unsafe { libc::realloc(ptr as *mut libc::c_void, new_size) as *mut u8 }
+    } else {
+        unsafe { realloc_fallback(ptr, layout, new_size) }
     }
 }
 
diff --git a/library/std/src/sys/alloc/vexos.rs b/library/std/src/sys/alloc/vexos.rs
index 5ccf6625ed626..6aba6dc474911 100644
--- a/library/std/src/sys/alloc/vexos.rs
+++ b/library/std/src/sys/alloc/vexos.rs
@@ -1,7 +1,7 @@
 // FIXME(static_mut_refs): use raw pointers instead of references
 #![allow(static_mut_refs)]
 
-use crate::alloc::{GlobalAlloc, Layout, System};
+use crate::alloc::Layout;
 use crate::ptr;
 use crate::sync::atomic::{AtomicBool, Ordering};
 
@@ -60,37 +60,34 @@ unsafe impl dlmalloc::Allocator for Vexos {
     }
 }
 
-#[stable(feature = "alloc_system_type", since = "1.28.0")]
-unsafe impl GlobalAlloc for System {
-    #[inline]
-    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-        // SAFETY: DLMALLOC access is guaranteed to be safe because we are a single-threaded target, which
-        // guarantees unique and non-reentrant access to the allocator. As such, no allocator lock is used.
-        // Calling malloc() is safe because preconditions on this function match the trait method preconditions.
-        unsafe { DLMALLOC.malloc(layout.size(), layout.align()) }
-    }
+#[inline]
+pub unsafe fn alloc(layout: Layout) -> *mut u8 {
+    // SAFETY: DLMALLOC access is guaranteed to be safe because we are a single-threaded target, which
+    // guarantees unique and non-reentrant access to the allocator. As such, no allocator lock is used.
+    // Calling malloc() is safe because preconditions on this function match the trait method preconditions.
+    unsafe { DLMALLOC.malloc(layout.size(), layout.align()) }
+}
 
-    #[inline]
-    unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
-        // SAFETY: DLMALLOC access is guaranteed to be safe because we are a single-threaded target, which
-        // guarantees unique and non-reentrant access to the allocator. As such, no allocator lock is used.
-        // Calling calloc() is safe because preconditions on this function match the trait method preconditions.
-        unsafe { DLMALLOC.calloc(layout.size(), layout.align()) }
-    }
+#[inline]
+pub unsafe fn alloc_zeroed(layout: Layout) -> *mut u8 {
+    // SAFETY: DLMALLOC access is guaranteed to be safe because we are a single-threaded target, which
+    // guarantees unique and non-reentrant access to the allocator. As such, no allocator lock is used.
+    // Calling calloc() is safe because preconditions on this function match the trait method preconditions.
+    unsafe { DLMALLOC.calloc(layout.size(), layout.align()) }
+}
 
-    #[inline]
-    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
-        // SAFETY: DLMALLOC access is guaranteed to be safe because we are a single-threaded target, which
-        // guarantees unique and non-reentrant access to the allocator. As such, no allocator lock is used.
-        // Calling free() is safe because preconditions on this function match the trait method preconditions.
-        unsafe { DLMALLOC.free(ptr, layout.size(), layout.align()) }
-    }
+#[inline]
+pub unsafe fn dealloc(ptr: *mut u8, layout: Layout) {
+    // SAFETY: DLMALLOC access is guaranteed to be safe because we are a single-threaded target, which
+    // guarantees unique and non-reentrant access to the allocator. As such, no allocator lock is used.
+    // Calling free() is safe because preconditions on this function match the trait method preconditions.
+    unsafe { DLMALLOC.free(ptr, layout.size(), layout.align()) }
+}
 
-    #[inline]
-    unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
-        // SAFETY: DLMALLOC access is guaranteed to be safe because we are a single-threaded target, which
-        // guarantees unique and non-reentrant access to the allocator. As such, no allocator lock is used.
-        // Calling realloc() is safe because preconditions on this function match the trait method preconditions.
-        unsafe { DLMALLOC.realloc(ptr, layout.size(), layout.align(), new_size) }
-    }
+#[inline]
+pub unsafe fn realloc(ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
+    // SAFETY: DLMALLOC access is guaranteed to be safe because we are a single-threaded target, which
+    // guarantees unique and non-reentrant access to the allocator. As such, no allocator lock is used.
+    // Calling realloc() is safe because preconditions on this function match the trait method preconditions.
+    unsafe { DLMALLOC.realloc(ptr, layout.size(), layout.align(), new_size) }
 }
diff --git a/library/std/src/sys/alloc/wasm.rs b/library/std/src/sys/alloc/wasm.rs
index 48e2fdd4eccec..995230aebaa01 100644
--- a/library/std/src/sys/alloc/wasm.rs
+++ b/library/std/src/sys/alloc/wasm.rs
@@ -18,7 +18,7 @@
 
 use core::cell::SyncUnsafeCell;
 
-use crate::alloc::{GlobalAlloc, Layout, System};
+use crate::alloc::Layout;
 
 struct SyncDlmalloc(dlmalloc::Dlmalloc);
 unsafe impl Sync for SyncDlmalloc {}
@@ -26,39 +26,36 @@ unsafe impl Sync for SyncDlmalloc {}
 static DLMALLOC: SyncUnsafeCell<SyncDlmalloc> =
     SyncUnsafeCell::new(SyncDlmalloc(dlmalloc::Dlmalloc::new()));
 
-#[stable(feature = "alloc_system_type", since = "1.28.0")]
-unsafe impl GlobalAlloc for System {
-    #[inline]
-    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-        // SAFETY: DLMALLOC access is guaranteed to be safe because the lock gives us unique and non-reentrant access.
-        // Calling malloc() is safe because preconditions on this function match the trait method preconditions.
-        let _lock = lock::lock();
-        unsafe { (*DLMALLOC.get()).0.malloc(layout.size(), layout.align()) }
-    }
+#[inline]
+pub unsafe fn alloc(layout: Layout) -> *mut u8 {
+    // SAFETY: DLMALLOC access is guaranteed to be safe because the lock gives us unique and non-reentrant access.
+    // Calling malloc() is safe because preconditions on this function match the trait method preconditions.
+    let _lock = lock::lock();
+    unsafe { (*DLMALLOC.get()).0.malloc(layout.size(), layout.align()) }
+}
 
-    #[inline]
-    unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
-        // SAFETY: DLMALLOC access is guaranteed to be safe because the lock gives us unique and non-reentrant access.
-        // Calling calloc() is safe because preconditions on this function match the trait method preconditions.
-        let _lock = lock::lock();
-        unsafe { (*DLMALLOC.get()).0.calloc(layout.size(), layout.align()) }
-    }
+#[inline]
+pub unsafe fn alloc_zeroed(layout: Layout) -> *mut u8 {
+    // SAFETY: DLMALLOC access is guaranteed to be safe because the lock gives us unique and non-reentrant access.
+    // Calling calloc() is safe because preconditions on this function match the trait method preconditions.
+    let _lock = lock::lock();
+    unsafe { (*DLMALLOC.get()).0.calloc(layout.size(), layout.align()) }
+}
 
-    #[inline]
-    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
-        // SAFETY: DLMALLOC access is guaranteed to be safe because the lock gives us unique and non-reentrant access.
-        // Calling free() is safe because preconditions on this function match the trait method preconditions.
-        let _lock = lock::lock();
-        unsafe { (*DLMALLOC.get()).0.free(ptr, layout.size(), layout.align()) }
-    }
+#[inline]
+pub unsafe fn dealloc(ptr: *mut u8, layout: Layout) {
+    // SAFETY: DLMALLOC access is guaranteed to be safe because the lock gives us unique and non-reentrant access.
+    // Calling free() is safe because preconditions on this function match the trait method preconditions.
+    let _lock = lock::lock();
+    unsafe { (*DLMALLOC.get()).0.free(ptr, layout.size(), layout.align()) }
+}
 
-    #[inline]
-    unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
-        // SAFETY: DLMALLOC access is guaranteed to be safe because the lock gives us unique and non-reentrant access.
-        // Calling realloc() is safe because preconditions on this function match the trait method preconditions.
-        let _lock = lock::lock();
-        unsafe { (*DLMALLOC.get()).0.realloc(ptr, layout.size(), layout.align(), new_size) }
-    }
+#[inline]
+pub unsafe fn realloc(ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
+    // SAFETY: DLMALLOC access is guaranteed to be safe because the lock gives us unique and non-reentrant access.
+    // Calling realloc() is safe because preconditions on this function match the trait method preconditions.
+    let _lock = lock::lock();
+    unsafe { (*DLMALLOC.get()).0.realloc(ptr, layout.size(), layout.align(), new_size) }
 }
 
 #[cfg(target_feature = "atomics")]
diff --git a/library/std/src/sys/alloc/windows.rs b/library/std/src/sys/alloc/windows.rs
index 9336a6ec085aa..1d75cbd9d54f1 100644
--- a/library/std/src/sys/alloc/windows.rs
+++ b/library/std/src/sys/alloc/windows.rs
@@ -1,5 +1,18 @@
+//! Implements `System` on Windows.
+//!
+//! All pointers returned by this allocator have, in addition to the guarantees of `GlobalAlloc`, the
+//! following properties:
+//!
+//! If the pointer was allocated or reallocated with a `layout` specifying an alignment <= `MIN_ALIGN`
+//! the pointer will be aligned to at least `MIN_ALIGN` and point to the start of the allocated block.
+//!
+//! If the pointer was allocated or reallocated with a `layout` specifying an alignment > `MIN_ALIGN`
+//! the pointer will be aligned to the specified alignment and not point to the start of the allocated block.
+//! Instead there will be a header readable directly before the returned pointer, containing the actual
+//! location of the start of the block.
+
 use super::{MIN_ALIGN, realloc_fallback};
-use crate::alloc::{GlobalAlloc, Layout, System};
+use crate::alloc::Layout;
 use crate::ffi::c_void;
 use crate::mem::MaybeUninit;
 use crate::ptr;
@@ -150,70 +163,56 @@ unsafe fn allocate(layout: Layout, zeroed: bool) -> *mut u8 {
     }
 }
 
-// All pointers returned by this allocator have, in addition to the guarantees of `GlobalAlloc`, the
-// following properties:
-//
-// If the pointer was allocated or reallocated with a `layout` specifying an alignment <= `MIN_ALIGN`
-// the pointer will be aligned to at least `MIN_ALIGN` and point to the start of the allocated block.
-//
-// If the pointer was allocated or reallocated with a `layout` specifying an alignment > `MIN_ALIGN`
-// the pointer will be aligned to the specified alignment and not point to the start of the allocated block.
-// Instead there will be a header readable directly before the returned pointer, containing the actual
-// location of the start of the block.
-#[stable(feature = "alloc_system_type", since = "1.28.0")]
-unsafe impl GlobalAlloc for System {
-    #[inline]
-    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-        // SAFETY: Pointers returned by `allocate` satisfy the guarantees of `System`
-        let zeroed = false;
-        unsafe { allocate(layout, zeroed) }
-    }
+pub unsafe fn alloc(layout: Layout) -> *mut u8 {
+    // SAFETY: Pointers returned by `allocate` satisfy the guarantees of `System`
+    let zeroed = false;
+    unsafe { allocate(layout, zeroed) }
+}
 
-    #[inline]
-    unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
-        // SAFETY: Pointers returned by `allocate` satisfy the guarantees of `System`
-        let zeroed = true;
-        unsafe { allocate(layout, zeroed) }
-    }
+#[inline]
+pub unsafe fn alloc_zeroed(layout: Layout) -> *mut u8 {
+    // SAFETY: Pointers returned by `allocate` satisfy the guarantees of `System`
+    let zeroed = true;
+    unsafe { allocate(layout, zeroed) }
+}
 
-    #[inline]
-    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
-        let block = {
-            if layout.align() <= MIN_ALIGN {
-                ptr
-            } else {
-                // The location of the start of the block is stored in the padding before `ptr`.
+#[inline]
+pub unsafe fn dealloc(ptr: *mut u8, layout: Layout) {
+    let block = {
+        if layout.align() <= MIN_ALIGN {
+            ptr
+        } else {
+            // The location of the start of the block is stored in the padding before `ptr`.
 
-                // SAFETY: Because of the contract of `System`, `ptr` is guaranteed to be non-null
-                // and have a header readable directly before it.
-                unsafe { ptr::read((ptr as *mut Header).sub(1)).0 }
-            }
-        };
+            // SAFETY: Because of the contract of `System`, `ptr` is guaranteed to be non-null
+            // and have a header readable directly before it.
+            unsafe { ptr::read((ptr as *mut Header).sub(1)).0 }
+        }
+    };
 
+    // because `ptr` has been successfully allocated with this allocator,
+    // there must be a valid process heap.
+    let heap = get_process_heap();
+
+    // SAFETY: `heap` is a non-null handle returned by `GetProcessHeap`,
+    // `block` is a pointer to the start of an allocated block.
+    unsafe { HeapFree(heap, 0, block.cast::<c_void>()) };
+}
+
+#[inline]
+pub unsafe fn realloc(ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
+    if layout.align() <= MIN_ALIGN {
         // because `ptr` has been successfully allocated with this allocator,
         // there must be a valid process heap.
         let heap = get_process_heap();
 
         // SAFETY: `heap` is a non-null handle returned by `GetProcessHeap`,
-        // `block` is a pointer to the start of an allocated block.
-        unsafe { HeapFree(heap, 0, block.cast::<c_void>()) };
-    }
-
-    #[inline]
-    unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
-        if layout.align() <= MIN_ALIGN {
-            // because `ptr` has been successfully allocated with this allocator,
-            // there must be a valid process heap.
-            let heap = get_process_heap();
-
-            // SAFETY: `heap` is a non-null handle returned by `GetProcessHeap`,
-            // `ptr` is a pointer to the start of an allocated block.
-            // The returned pointer points to the start of an allocated block.
-            unsafe { HeapReAlloc(heap, 0, ptr.cast::<c_void>(), new_size).cast::<u8>() }
-        } else {
-            // SAFETY: `realloc_fallback` is implemented using `dealloc` and `alloc`, which will
-            // correctly handle `ptr` and return a pointer satisfying the guarantees of `System`
-            unsafe { realloc_fallback(self, ptr, layout, new_size) }
-        }
+        // `ptr` is a pointer to the start of an allocated block.
+        // The returned pointer points to the start of an allocated block.
+        unsafe { HeapReAlloc(heap, 0, ptr.cast::<c_void>(), new_size).cast::<u8>() }
+    } else {
+        // SAFETY: `realloc_fallback` is implemented using `dealloc` and `alloc`, which will
+        // correctly handle `ptr` and return a pointer satisfying the guarantees of `System`
+        unsafe { realloc_fallback(ptr, layout, new_size) }
     }
 }
diff --git a/library/std/src/sys/alloc/xous.rs b/library/std/src/sys/alloc/xous.rs
index af2dcabc1a23b..74229351f6d22 100644
--- a/library/std/src/sys/alloc/xous.rs
+++ b/library/std/src/sys/alloc/xous.rs
@@ -1,7 +1,7 @@
 // FIXME(static_mut_refs): use raw pointers instead of references
 #![allow(static_mut_refs)]
 
-use crate::alloc::{GlobalAlloc, Layout, System};
+use crate::alloc::Layout;
 
 #[cfg(not(test))]
 #[unsafe(export_name = "_ZN16__rust_internals3std3sys4xous5alloc8DLMALLOCE")]
@@ -13,39 +13,36 @@ unsafe extern "Rust" {
     static mut DLMALLOC: dlmalloc::Dlmalloc;
 }
 
-#[stable(feature = "alloc_system_type", since = "1.28.0")]
-unsafe impl GlobalAlloc for System {
-    #[inline]
-    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-        // SAFETY: DLMALLOC access is guaranteed to be safe because the lock gives us unique and non-reentrant access.
-        // Calling malloc() is safe because preconditions on this function match the trait method preconditions.
-        let _lock = lock::lock();
-        unsafe { DLMALLOC.malloc(layout.size(), layout.align()) }
-    }
+#[inline]
+pub unsafe fn alloc(layout: Layout) -> *mut u8 {
+    // SAFETY: DLMALLOC access is guaranteed to be safe because the lock gives us unique and non-reentrant access.
+    // Calling malloc() is safe because preconditions on this function match the trait method preconditions.
+    let _lock = lock::lock();
+    unsafe { DLMALLOC.malloc(layout.size(), layout.align()) }
+}
 
-    #[inline]
-    unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
-        // SAFETY: DLMALLOC access is guaranteed to be safe because the lock gives us unique and non-reentrant access.
-        // Calling calloc() is safe because preconditions on this function match the trait method preconditions.
-        let _lock = lock::lock();
-        unsafe { DLMALLOC.calloc(layout.size(), layout.align()) }
-    }
+#[inline]
+pub unsafe fn alloc_zeroed(layout: Layout) -> *mut u8 {
+    // SAFETY: DLMALLOC access is guaranteed to be safe because the lock gives us unique and non-reentrant access.
+    // Calling calloc() is safe because preconditions on this function match the trait method preconditions.
+    let _lock = lock::lock();
+    unsafe { DLMALLOC.calloc(layout.size(), layout.align()) }
+}
 
-    #[inline]
-    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
-        // SAFETY: DLMALLOC access is guaranteed to be safe because the lock gives us unique and non-reentrant access.
-        // Calling free() is safe because preconditions on this function match the trait method preconditions.
-        let _lock = lock::lock();
-        unsafe { DLMALLOC.free(ptr, layout.size(), layout.align()) }
-    }
+#[inline]
+pub unsafe fn dealloc(ptr: *mut u8, layout: Layout) {
+    // SAFETY: DLMALLOC access is guaranteed to be safe because the lock gives us unique and non-reentrant access.
+    // Calling free() is safe because preconditions on this function match the trait method preconditions.
+    let _lock = lock::lock();
+    unsafe { DLMALLOC.free(ptr, layout.size(), layout.align()) }
+}
 
-    #[inline]
-    unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
-        // SAFETY: DLMALLOC access is guaranteed to be safe because the lock gives us unique and non-reentrant access.
-        // Calling realloc() is safe because preconditions on this function match the trait method preconditions.
-        let _lock = lock::lock();
-        unsafe { DLMALLOC.realloc(ptr, layout.size(), layout.align(), new_size) }
-    }
+#[inline]
+pub unsafe fn realloc(ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
+    // SAFETY: DLMALLOC access is guaranteed to be safe because the lock gives us unique and non-reentrant access.
+    // Calling realloc() is safe because preconditions on this function match the trait method preconditions.
+    let _lock = lock::lock();
+    unsafe { DLMALLOC.realloc(ptr, layout.size(), layout.align(), new_size) }
 }
 
 mod lock {
diff --git a/library/std/src/sys/alloc/zkvm.rs b/library/std/src/sys/alloc/zkvm.rs
index a600cfa2220dd..7f39d7fed777e 100644
--- a/library/std/src/sys/alloc/zkvm.rs
+++ b/library/std/src/sys/alloc/zkvm.rs
@@ -1,15 +1,18 @@
-use crate::alloc::{GlobalAlloc, Layout, System};
+use crate::alloc::Layout;
 use crate::sys::pal::abi;
 
-#[stable(feature = "alloc_system_type", since = "1.28.0")]
-unsafe impl GlobalAlloc for System {
-    #[inline]
-    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-        unsafe { abi::sys_alloc_aligned(layout.size(), layout.align()) }
-    }
+#[inline]
+pub unsafe fn alloc(layout: Layout) -> *mut u8 {
+    unsafe { abi::sys_alloc_aligned(layout.size(), layout.align()) }
+}
+
+#[inline]
+pub unsafe fn dealloc(_ptr: *mut u8, _layout: Layout) {
+    // this allocator never deallocates memory
+}
 
-    #[inline]
-    unsafe fn dealloc(&self, _ptr: *mut u8, _layout: Layout) {
-        // this allocator never deallocates memory
-    }
+#[inline]
+pub unsafe fn realloc(ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
+    // SAFETY: this is just a `pub` wrapper.
+    unsafe { super::realloc_fallback(ptr, layout, new_size) }
 }
diff --git a/library/std/src/sys/mod.rs b/library/std/src/sys/mod.rs
index fe0c103952414..58c8dc43e12ae 100644
--- a/library/std/src/sys/mod.rs
+++ b/library/std/src/sys/mod.rs
@@ -1,11 +1,11 @@
 #![allow(unsafe_op_in_unsafe_fn)]
 
-mod alloc;
 mod configure_builtins;
 mod helpers;
 mod pal;
 mod personality;
 
+pub mod alloc;
 pub mod args;
 pub mod backtrace;
 pub mod cmath;
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index 3179bda868651..c7387bf157d10 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -1953,6 +1953,10 @@ pub(crate) fn clean_ty<'tcx>(ty: &hir::Ty<'tcx>, cx: &mut DocContext<'tcx>) -> T
         TyKind::UnsafeBinder(unsafe_binder_ty) => {
             UnsafeBinder(Box::new(clean_unsafe_binder_ty(unsafe_binder_ty, cx)))
         }
+        TyKind::View(ty, _) => {
+            // FIXME(scrabsha): propagate view types to `rustdoc`.
+            clean_ty(ty, cx)
+        }
         // Rustdoc handles `TyKind::Err`s by turning them into `Type::Infer`s.
         TyKind::Infer(())
         | TyKind::Err(_)
diff --git a/src/tools/clippy/clippy_lints/src/dereference.rs b/src/tools/clippy/clippy_lints/src/dereference.rs
index fbff41fe00914..0868ee322a646 100644
--- a/src/tools/clippy/clippy_lints/src/dereference.rs
+++ b/src/tools/clippy/clippy_lints/src/dereference.rs
@@ -902,6 +902,10 @@ impl TyCoercionStability {
                 | TyKind::TraitObject(..)
                 | TyKind::InferDelegation(..)
                 | TyKind::Err(_) => Self::Reborrow,
+                TyKind::View(ty, _) => {
+                    // FIXME(scrabsha): what are the semantics of view types here?
+                    Self::for_hir_ty(ty)
+                }
                 TyKind::UnsafeBinder(..) => Self::None,
             };
         }
diff --git a/src/tools/clippy/clippy_utils/src/check_proc_macro.rs b/src/tools/clippy/clippy_utils/src/check_proc_macro.rs
index 7400891f75b58..7b47141c9fb8a 100644
--- a/src/tools/clippy/clippy_utils/src/check_proc_macro.rs
+++ b/src/tools/clippy/clippy_utils/src/check_proc_macro.rs
@@ -537,6 +537,7 @@ fn ast_ty_search_pat(ty: &ast::Ty) -> (Pat, Pat) {
         | TyKind::Pat(..)
         | TyKind::FieldOf(..)
         | TyKind::View(..)
+        | TyKind::DirectConstArg(..)
 
         // unused
         | TyKind::CVarArgs
diff --git a/src/tools/clippy/clippy_utils/src/hir_utils.rs b/src/tools/clippy/clippy_utils/src/hir_utils.rs
index 050e43344d0c4..7c3fa51228bc9 100644
--- a/src/tools/clippy/clippy_utils/src/hir_utils.rs
+++ b/src/tools/clippy/clippy_utils/src/hir_utils.rs
@@ -1650,6 +1650,10 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
             TyKind::UnsafeBinder(binder) => {
                 self.hash_ty(binder.inner_ty);
             },
+            TyKind::View(ty, _) => {
+                self.hash_ty(ty);
+                // FIXME(scrabsha): probably hash the fields as well?
+            },
             TyKind::Err(_)
             | TyKind::Infer(())
             | TyKind::Never
diff --git a/src/tools/clippy/clippy_utils/src/sugg.rs b/src/tools/clippy/clippy_utils/src/sugg.rs
index f194103ae2e88..cb0db1ed014fc 100644
--- a/src/tools/clippy/clippy_utils/src/sugg.rs
+++ b/src/tools/clippy/clippy_utils/src/sugg.rs
@@ -248,6 +248,7 @@ impl<'a> Sugg<'a> {
             | ast::ExprKind::Array(..)
             | ast::ExprKind::While(..)
             | ast::ExprKind::Await(..)
+            | ast::ExprKind::DirectConstArg(..)
             | ast::ExprKind::Err(_)
             | ast::ExprKind::Dummy
             | ast::ExprKind::UnsafeBinderCast(..) => Sugg::NonParen(snippet(expr.span)),
diff --git a/src/tools/miri/tests/fail/alloc/global_system_mixup.stderr b/src/tools/miri/tests/fail/alloc/global_system_mixup.stderr
index 1e9d859b5cf81..1853ecbf43c70 100644
--- a/src/tools/miri/tests/fail/alloc/global_system_mixup.stderr
+++ b/src/tools/miri/tests/fail/alloc/global_system_mixup.stderr
@@ -1,13 +1,13 @@
 error: Undefined Behavior: deallocating ALLOC, which is Rust heap memory, using PLATFORM heap deallocation operation
   --> RUSTLIB/std/src/sys/alloc/PLATFORM.rs:LL:CC
    |
-LL |         FREE();
+LL |     FREE();
    | ^ Undefined Behavior occurred here
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
    = note: stack backtrace:
-           0: std::sys::alloc::PLATFORM::<impl std::alloc::GlobalAlloc for std::alloc::System>::dealloc
+           0: std::sys::alloc::PLATFORM::dealloc
                at RUSTLIB/std/src/sys/alloc/PLATFORM.rs:LL:CC
            1: <std::alloc::System as std::alloc::Allocator>::deallocate
                at RUSTLIB/std/src/alloc.rs:LL:CC
diff --git a/src/tools/rustfmt/src/expr.rs b/src/tools/rustfmt/src/expr.rs
index 8a3674bff1ca6..cc7fdaefc8fee 100644
--- a/src/tools/rustfmt/src/expr.rs
+++ b/src/tools/rustfmt/src/expr.rs
@@ -486,7 +486,8 @@ pub(crate) fn format_expr(
         | ast::ExprKind::Type(..)
         | ast::ExprKind::IncludedBytes(..)
         | ast::ExprKind::OffsetOf(..)
-        | ast::ExprKind::UnsafeBinderCast(..) => {
+        | ast::ExprKind::UnsafeBinderCast(..)
+        | ast::ExprKind::DirectConstArg(..) => {
             // These don't normally occur in the AST because macros aren't expanded. However,
             // rustfmt tries to parse macro arguments when formatting macros, so it's not totally
             // impossible for rustfmt to come across one of these nodes when formatting a file.
diff --git a/src/tools/rustfmt/src/types.rs b/src/tools/rustfmt/src/types.rs
index 9e7bbcc243ccf..d3a1279cfb325 100644
--- a/src/tools/rustfmt/src/types.rs
+++ b/src/tools/rustfmt/src/types.rs
@@ -1014,7 +1014,6 @@ impl Rewrite for ast::Ty {
                 })
             }
             ast::TyKind::CVarArgs => Ok("...".to_owned()),
-            ast::TyKind::Dummy | ast::TyKind::Err(_) => Ok(context.snippet(self.span).to_owned()),
             ast::TyKind::FieldOf(ref ty, ref variant, ref field) => {
                 let ty = ty.rewrite_result(context, shape)?;
                 if let Some(variant) = variant {
@@ -1049,14 +1048,14 @@ impl Rewrite for ast::Ty {
                 result.push_str(&rewrite);
                 Ok(result)
             }
-
-            ast::TyKind::Pat(..) | ast::TyKind::View(..) => {
+            ast::TyKind::Pat(..) | ast::TyKind::View(..) | ast::TyKind::DirectConstArg(..) => {
                 // These don't normally occur in the AST because macros aren't expanded. However,
                 // rustfmt tries to parse macro arguments when formatting macros, so it's not
                 // totally impossible for rustfmt to come across these nodes when formatting a file.
                 // Also, rustfmt might get passed the output from `-Zunpretty=expanded`.
                 Err(RewriteError::Unknown)
             }
+            ast::TyKind::Dummy | ast::TyKind::Err(_) => Ok(context.snippet(self.span).to_owned()),
         }
     }
 }
diff --git a/src/tools/rustfmt/src/utils.rs b/src/tools/rustfmt/src/utils.rs
index 1fcc59f2a1ea4..3e06f3899d1b3 100644
--- a/src/tools/rustfmt/src/utils.rs
+++ b/src/tools/rustfmt/src/utils.rs
@@ -532,9 +532,8 @@ pub(crate) fn is_block_expr(context: &RewriteContext<'_>, expr: &ast::Expr, repr
         | ast::ExprKind::Index(_, ref expr, _)
         | ast::ExprKind::Unary(_, ref expr)
         | ast::ExprKind::Try(ref expr)
-        | ast::ExprKind::Yield(YieldKind::Prefix(Some(ref expr))) => {
-            is_block_expr(context, expr, repr)
-        }
+        | ast::ExprKind::Yield(YieldKind::Prefix(Some(ref expr)))
+        | ast::ExprKind::DirectConstArg(ref expr) => is_block_expr(context, expr, repr),
         ast::ExprKind::Closure(ref closure) => is_block_expr(context, &closure.body, repr),
         // This can only be a string lit
         ast::ExprKind::Lit(_) => {
diff --git a/src/tools/rustfmt/tests/source/direct_const_arg.rs b/src/tools/rustfmt/tests/source/direct_const_arg.rs
new file mode 100644
index 0000000000000..f6f9c25d9a0d8
--- /dev/null
+++ b/src/tools/rustfmt/tests/source/direct_const_arg.rs
@@ -0,0 +1,14 @@
+// direct_const_arg! is a built-in macro relevant to min_generic_const_args; its contents should be
+// formatted as if its contents were passed through unchanged (the macro changes the semantics of
+// the contained expression, the syntax is unchanged)
+
+#![feature(min_generic_const_args)]
+
+trait Trait {
+    type const TYPE_CONST: usize;
+}
+
+struct S<const N: usize>;
+
+fn parsed_as_expr_kind<T: Trait>(_: S<{ core::direct_const_arg!( T  ::  TYPE_CONST ) }>) {}
+fn parsed_as_ty_kind<T: Trait>(_: S< core::direct_const_arg!( T  ::  TYPE_CONST ) >) {}
diff --git a/src/tools/rustfmt/tests/target/direct_const_arg.rs b/src/tools/rustfmt/tests/target/direct_const_arg.rs
new file mode 100644
index 0000000000000..1ebadae00ff05
--- /dev/null
+++ b/src/tools/rustfmt/tests/target/direct_const_arg.rs
@@ -0,0 +1,14 @@
+// direct_const_arg! is a built-in macro relevant to min_generic_const_args; its contents should be
+// formatted as if its contents were passed through unchanged (the macro changes the semantics of
+// the contained expression, the syntax is unchanged)
+
+#![feature(min_generic_const_args)]
+
+trait Trait {
+    type const TYPE_CONST: usize;
+}
+
+struct S<const N: usize>;
+
+fn parsed_as_expr_kind<T: Trait>(_: S<{ core::direct_const_arg!(T::TYPE_CONST) }>) {}
+fn parsed_as_ty_kind<T: Trait>(_: S<core::direct_const_arg!(T::TYPE_CONST)>) {}
diff --git a/tests/assembly-llvm/c-variadic/aarch64.rs b/tests/assembly-llvm/c-variadic/aarch64.rs
new file mode 100644
index 0000000000000..fcb44d044abb5
--- /dev/null
+++ b/tests/assembly-llvm/c-variadic/aarch64.rs
@@ -0,0 +1,333 @@
+//@ add-minicore
+//@ assembly-output: emit-asm
+//
+//@ revisions: AARCH64_LINUX AARCH64_DARWIN AARCH64_BE AARCH64_MSVC ARM64EC_MSVC
+//@ [AARCH64_LINUX] compile-flags: -Copt-level=3 --target aarch64-unknown-linux-gnu
+//@ [AARCH64_LINUX] needs-llvm-components: aarch64
+//@ [AARCH64_BE] compile-flags: -Copt-level=3 --target aarch64_be-unknown-linux-gnu
+//@ [AARCH64_BE] needs-llvm-components: aarch64
+//@ [AARCH64_DARWIN] compile-flags: -Copt-level=3 --target aarch64-apple-darwin
+//@ [AARCH64_DARWIN] needs-llvm-components: aarch64
+//@ [AARCH64_MSVC] compile-flags: -Copt-level=3 --target aarch64-pc-windows-msvc
+//@ [AARCH64_MSVC] needs-llvm-components: aarch64
+//@ [ARM64EC_MSVC] compile-flags: -Copt-level=3 --target arm64ec-pc-windows-msvc
+//@ [ARM64EC_MSVC] needs-llvm-components: aarch64
+#![feature(c_variadic, no_core, lang_items, intrinsics, rustc_attrs)]
+#![no_core]
+#![crate_type = "lib"]
+
+// Check that the assembly that rustc generates matches what clang emits.
+
+// For aarch64-unknown-linux-gnu LLVM canonicalizes a comparison, leading to slightly different
+// assembly.
+//
+// For aarch64-apple-darwin LLVM is able to optimize our output better, because we effectively
+// desugar va_arg early, hence we don't actually match Clang there.
+
+extern crate minicore;
+use minicore::*;
+
+#[lang = "va_arg_safe"]
+pub unsafe trait VaArgSafe {}
+
+unsafe impl VaArgSafe for i32 {}
+unsafe impl VaArgSafe for i64 {}
+unsafe impl VaArgSafe for i128 {}
+unsafe impl VaArgSafe for f64 {}
+unsafe impl<T> VaArgSafe for *const T {}
+
+#[repr(transparent)]
+struct VaListInner {
+    ptr: *const c_void,
+}
+
+#[repr(transparent)]
+#[lang = "va_list"]
+pub struct VaList<'a> {
+    inner: VaListInner,
+    _marker: PhantomData<&'a mut ()>,
+}
+
+#[rustc_intrinsic]
+#[rustc_nounwind]
+pub const unsafe fn va_arg<T: VaArgSafe>(ap: &mut VaList<'_>) -> T;
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_f64(ap: &mut VaList<'_>) -> f64 {
+    // AARCH64_LINUX-LABEL: read_f64:
+    // AARCH64_LINUX: ldrsw   x8, [x0, #28]
+    // AARCH64_LINUX-NEXT: tbz w8, #31, .LBB0_2
+    // AARCH64_LINUX-NEXT: add w9, w8, #16
+    // AARCH64_LINUX-NEXT: cmn w8, #16
+    // AARCH64_LINUX-NEXT: str w9, [x0, #28]
+    // AARCH64_LINUX-NEXT: b.ls    .LBB0_3
+    // AARCH64_LINUX-NEXT: .LBB0_2:
+    // AARCH64_LINUX-NEXT: ldr x8, [x0]
+    // AARCH64_LINUX-NEXT: ldr d0, [x8]
+    // AARCH64_LINUX-NEXT: add x9, x8, #8
+    // AARCH64_LINUX-NEXT: str x9, [x0]
+    // AARCH64_LINUX-NEXT: ret
+    // AARCH64_LINUX-NEXT: .LBB0_3
+    // AARCH64_LINUX-NEXT: ldr x9, [x0, #16]
+    // AARCH64_LINUX-NEXT: add x8, x9, x8
+    // AARCH64_LINUX-NEXT: ldr d0, [x8]
+    // AARCH64_LINUX-NEXT: ret
+
+    // AARCH64_BE-LABEL: read_f64:
+    // AARCH64_BE: ldrsw    x8, [x0, #28]
+    // AARCH64_BE-NEXT: tbz w8, #31, .LBB0_2
+    // AARCH64_BE-NEXT: add w9, w8, #16
+    // AARCH64_BE-NEXT: cmn w8, #16
+    // AARCH64_BE-NEXT: str w9, [x0, #28]
+    // AARCH64_BE-NEXT: b.ls    .LBB0_3
+    // AARCH64_BE-NEXT: .LBB0_2:
+    // AARCH64_BE-NEXT: ldr x8, [x0]
+    // AARCH64_BE-NEXT: ldr d0, [x8]
+    // AARCH64_BE-NEXT: add x9, x8, #8
+    // AARCH64_BE-NEXT: str x9, [x0]
+    // AARCH64_BE-NEXT: ret
+    // AARCH64_BE-NEXT: .LBB0_3:
+    // AARCH64_BE-NEXT: ldr x9, [x0, #16]
+    // AARCH64_BE-NEXT: add x8, x9, x8
+    // AARCH64_BE-NEXT: ldr d0, [x8, #8]!
+    // AARCH64_BE-NEXT: ret
+
+    // ARM64EC_MSVC-LABEL: read_f64 = "#read_f64"
+    // ARM64EC_MSVC: ldr x8, [x0]
+    // ARM64EC_MSVC-NEXT: ldr d0, [x8], #8
+    // ARM64EC_MSVC-NEXT: str x8, [x0]
+    // ARM64EC_MSVC-NEXT: ret
+
+    // AARCH64_DARWIN-LABEL: _read_f64:
+    // AARCH64_DARWIN: ldr x8, [x0]
+    // AARCH64_DARWIN-NEXT: ldr d0, [x8], #8
+    // AARCH64_DARWIN-NEXT: str x8, [x0]
+    // AARCH64_DARWIN-NEXT: ret
+
+    // AARCH64_MSVC-LABEL: read_f64:
+    // AARCH64_MSVC: ldr x8, [x0]
+    // AARCH64_MSVC-NEXT: ldr d0, [x8], #8
+    // AARCH64_MSVC-NEXT: str x8, [x0]
+    // AARCH64_MSVC-NEXT: ret
+    va_arg(ap)
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_i32(ap: &mut VaList<'_>) -> i32 {
+    // AARCH64_LINUX-LABEL: read_i32:
+    // AARCH64_LINUX: ldrsw   x8, [x0, #24]
+    // AARCH64_LINUX-NEXT: tbz w8, #31, .LBB1_2
+    // AARCH64_LINUX-NEXT: add w9, w8, #8
+    // AARCH64_LINUX-NEXT: cmn w8, #8
+    // AARCH64_LINUX-NEXT: str w9, [x0, #24]
+    // AARCH64_LINUX-NEXT: b.ls    .LBB1_3
+    // AARCH64_LINUX-NEXT: .LBB1_2:
+    // AARCH64_LINUX-NEXT: ldr x8, [x0]
+    // AARCH64_LINUX-NEXT: add x9, x8, #8
+    // AARCH64_LINUX-NEXT: str x9, [x0]
+    // AARCH64_LINUX-NEXT: ldr w0, [x8]
+    // AARCH64_LINUX-NEXT: ret
+    // AARCH64_LINUX-NEXT: .LBB1_3
+    // AARCH64_LINUX-NEXT: ldr x9, [x0, #8]
+    // AARCH64_LINUX-NEXT: add x8, x9, x8
+    // AARCH64_LINUX-NEXT: ldr w0, [x8]
+    // AARCH64_LINUX-NEXT: ret
+
+    // AARCH64_BE-LABEL: read_i32:
+    // AARCH64_BE: ldrsw    x8, [x0, #24]
+    // AARCH64_BE-NEXT: tbz w8, #31, .LBB1_2
+    // AARCH64_BE-NEXT: add w9, w8, #8
+    // AARCH64_BE-NEXT: cmn w8, #8
+    // AARCH64_BE-NEXT: str w9, [x0, #24]
+    // AARCH64_BE-NEXT: b.ls    .LBB1_3
+    // AARCH64_BE-NEXT: .LBB1_2:
+    // AARCH64_BE-NEXT: ldr x8, [x0]
+    // AARCH64_BE-NEXT: add x9, x8, #8
+    // AARCH64_BE-NEXT: str x9, [x0]
+    // AARCH64_BE-NEXT: ldr w0, [x8]
+    // AARCH64_BE-NEXT: ret
+    // AARCH64_BE-NEXT: .LBB1_3:
+    // AARCH64_BE-NEXT: ldr x9, [x0, #8]
+    // AARCH64_BE-NEXT: add x8, x9, x8
+    // AARCH64_BE-NEXT: ldr w0, [x8, #4]!
+    // AARCH64_BE-NEXT: ret
+
+    // ARM64EC_MSVC-LABEL: read_i32 = "#read_i32"
+    // ARM64EC_MSVC: ldr x9, [x0]
+    // ARM64EC_MSVC-NEXT: mov x8, x0
+    // ARM64EC_MSVC-NEXT: ldr w0, [x9], #8
+    // ARM64EC_MSVC-NEXT: str x9, [x8]
+    // ARM64EC_MSVC-NEXT: ret
+
+    // AARCH64_DARWIN-LABEL: _read_i32:
+    // AARCH64_DARWIN: ldr x9, [x0]
+    // AARCH64_DARWIN-NEXT: ldr w8, [x9], #8
+    // AARCH64_DARWIN-NEXT: str x9, [x0]
+    // AARCH64_DARWIN-NEXT: mov x0, x8
+    // AARCH64_DARWIN-NEXT: ret
+
+    // AARCH64_MSVC-LABEL: read_i32:
+    // AARCH64_MSVC: ldr x9, [x0]
+    // AARCH64_MSVC-NEXT: mov x8, x0
+    // AARCH64_MSVC-NEXT: ldr w0, [x9], #8
+    // AARCH64_MSVC-NEXT: str x9, [x8]
+    // AARCH64_MSVC-NEXT: ret
+    va_arg(ap)
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_i64(ap: &mut VaList<'_>) -> i64 {
+    // AARCH64_LINUX-LABEL: read_i64:
+    // AARCH64_LINUX: ldrsw   x8, [x0, #24]
+    // AARCH64_LINUX-NEXT: tbz w8, #31, .LBB2_2
+    // AARCH64_LINUX-NEXT: add w9, w8, #8
+    // AARCH64_LINUX-NEXT: cmn w8, #8
+    // AARCH64_LINUX-NEXT: str w9, [x0, #24]
+    // AARCH64_LINUX-NEXT: b.ls    .LBB2_3
+    // AARCH64_LINUX-NEXT: .LBB2_2:
+    // AARCH64_LINUX-NEXT: ldr x8, [x0]
+    // AARCH64_LINUX-NEXT: add x9, x8, #8
+    // AARCH64_LINUX-NEXT: str x9, [x0]
+    // AARCH64_LINUX-NEXT: ldr x0, [x8]
+    // AARCH64_LINUX-NEXT: ret
+    // AARCH64_LINUX-NEXT: .LBB2_3
+    // AARCH64_LINUX-NEXT: ldr x9, [x0, #8]
+    // AARCH64_LINUX-NEXT: add x8, x9, x8
+    // AARCH64_LINUX-NEXT: ldr x0, [x8]
+    // AARCH64_LINUX-NEXT: ret
+
+    // AARCH64_BE-LABEL: read_i64:
+    // AARCH64_BE: ldrsw    x8, [x0, #24]
+    // AARCH64_BE-NEXT: tbz w8, #31, .LBB2_2
+    // AARCH64_BE-NEXT: add w9, w8, #8
+    // AARCH64_BE-NEXT: cmn w8, #8
+    // AARCH64_BE-NEXT: str w9, [x0, #24]
+    // AARCH64_BE-NEXT: b.ls    .LBB2_3
+    // AARCH64_BE-NEXT: .LBB2_2:
+    // AARCH64_BE-NEXT: ldr x8, [x0]
+    // AARCH64_BE-NEXT: add x9, x8, #8
+    // AARCH64_BE-NEXT: str x9, [x0]
+    // AARCH64_BE-NEXT: ldr x0, [x8]
+    // AARCH64_BE-NEXT: ret
+    // AARCH64_BE-NEXT: .LBB2_3:
+    // AARCH64_BE-NEXT: ldr x9, [x0, #8]
+    // AARCH64_BE-NEXT: add x8, x9, x8
+    // AARCH64_BE-NEXT: ldr x0, [x8]
+    // AARCH64_BE-NEXT: ret
+
+    // ARM64EC_MSVC-LABEL: read_ptr = "#read_ptr"
+    // ARM64EC_MSVC-LABEL: read_i64 = "#read_i64"
+    // ARM64EC_MSVC: ldr x9, [x0]
+    // ARM64EC_MSVC-NEXT: mov x8, x0
+    // ARM64EC_MSVC-NEXT: ldr x0, [x9], #8
+    // ARM64EC_MSVC-NEXT: str x9, [x8]
+    // ARM64EC_MSVC-NEXT: ret
+
+    // AARCH64_DARWIN-LABEL: _read_i64:
+    // AARCH64_DARWIN: ldr x9, [x0]
+    // AARCH64_DARWIN-NEXT: ldr x8, [x9], #8
+    // AARCH64_DARWIN-NEXT: str x9, [x0]
+    // AARCH64_DARWIN-NEXT: mov x0, x8
+    // AARCH64_DARWIN-NEXT: ret
+
+    // AARCH64_MSVC-LABEL: read_i64:
+    // AARCH64_MSVC: ldr x9, [x0]
+    // AARCH64_MSVC-NEXT: mov x8, x0
+    // AARCH64_MSVC-NEXT: ldr x0, [x9], #8
+    // AARCH64_MSVC-NEXT: str x9, [x8]
+    // AARCH64_MSVC-NEXT: ret
+    va_arg(ap)
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_i128(ap: &mut VaList<'_>) -> i128 {
+    // AARCH64_LINUX-LABEL: read_i128:
+    // AARCH64_LINUX: ldrsw   x8, [x0, #24]
+    // AARCH64_LINUX-NEXT: tbz w8, #31, .LBB3_2
+    // AARCH64_LINUX-NEXT: add x8, x8, #15
+    // AARCH64_LINUX-NEXT: and x8, x8, #0xfffffffffffffff0
+    // AARCH64_LINUX-NEXT: add w9, w8, #16
+    // AARCH64_LINUX-NEXT: cmp w9, #0
+    // AARCH64_LINUX-NEXT: str w9, [x0, #24]
+    // AARCH64_LINUX-NEXT: b.le    .LBB3_3
+    // AARCH64_LINUX-NEXT: .LBB3_2:
+    // AARCH64_LINUX-NEXT: ldr x8, [x0]
+    // AARCH64_LINUX-NEXT: add x8, x8, #15
+    // AARCH64_LINUX-NEXT: and x8, x8, #0xfffffffffffffff0
+    // AARCH64_LINUX-NEXT: add x9, x8, #16
+    // AARCH64_LINUX-NEXT: str x9, [x0]
+    // AARCH64_LINUX-NEXT: ldp x0, x1, [x8]
+    // AARCH64_LINUX-NEXT: ret
+    // AARCH64_LINUX-NEXT: .LBB3_3
+    // AARCH64_LINUX-NEXT: ldr x9, [x0, #8]
+    // AARCH64_LINUX-NEXT: add x8, x9, x8
+    // AARCH64_LINUX-NEXT: ldp x0, x1, [x8]
+    // AARCH64_LINUX-NEXT: ret
+
+    // AARCH64_BE-LABEL: read_i128:
+    // AARCH64_BE: ldrsw   x8, [x0, #24]
+    // AARCH64_BE-NEXT: tbz     w8, #31, .LBB3_2
+    // AARCH64_BE-NEXT: add     x8, x8, #15
+    // AARCH64_BE-NEXT: and     x8, x8, #0xfffffffffffffff0
+    // AARCH64_BE-NEXT: add     w9, w8, #16
+    // AARCH64_BE-NEXT: cmp     w9, #0
+    // AARCH64_BE-NEXT: str     w9, [x0, #24]
+    // AARCH64_BE-NEXT: b.le    .LBB3_3
+    // AARCH64_BE-NEXT: .LBB3_2:
+    // AARCH64_BE-NEXT: ldr     x8, [x0]
+    // AARCH64_BE-NEXT: add     x8, x8, #15
+    // AARCH64_BE-NEXT: and     x8, x8, #0xfffffffffffffff0
+    // AARCH64_BE-NEXT: add     x9, x8, #16
+    // AARCH64_BE-NEXT: str     x9, [x0]
+    // AARCH64_BE-NEXT: ldp     x0, x1, [x8]
+    // AARCH64_BE-NEXT: ret
+    // AARCH64_BE-NEXT: .LBB3_3:
+    // AARCH64_BE-NEXT: ldr     x9, [x0, #8]
+    // AARCH64_BE-NEXT: add     x8, x9, x8
+    // AARCH64_BE-NEXT: ldp     x0, x1, [x8]
+    // AARCH64_BE-NEXT: ret
+
+    // NOTE: matches x86_64 Windows: an `i128` is passed indirectly, the slot holds a pointer.
+    //
+    // ARM64EC_MSVC-LABEL: read_i128 = "#read_i128"
+    // ARM64EC_MSVC: ldr x9, [x0]
+    // ARM64EC_MSVC-NEXT: ldr x10, [x9], #8
+    // ARM64EC_MSVC-NEXT: str x9, [x0]
+    // ARM64EC_MSVC-NEXT: ldp x0, x1, [x10]
+    // ARM64EC_MSVC-NEXT: ret
+
+    // AARCH64_DARWIN-LABEL: _read_i128:
+    // AARCH64_DARWIN: ldr x8, [x0]
+    // AARCH64_DARWIN-NEXT: add x8, x8, #15
+    // AARCH64_DARWIN-NEXT: and x9, x8, #0xfffffffffffffff0
+    // AARCH64_DARWIN-NEXT: ldr x1, [x9, #8]
+    // AARCH64_DARWIN-NEXT: ldr x8, [x9], #16
+    // AARCH64_DARWIN-NEXT: str x9, [x0]
+    // AARCH64_DARWIN-NEXT: mov x0, x8
+    // AARCH64_DARWIN-NEXT: ret
+
+    // NOTE: rustc bumps the alignment to 16, which deviates from clang's va_arg
+    // but matches MSVC and how clang passes i128 c-variadic arguments.
+    //
+    // AARCH64_MSVC-LABEL: read_i128:
+    // AARCH64_MSVC: ldr x9, [x0]
+    // AARCH64_MSVC-NEXT: mov x8, x0
+    // AARCH64_MSVC-NEXT: add x9, x9, #15
+    // AARCH64_MSVC-NEXT: and x9, x9, #0xfffffffffffffff0
+    // AARCH64_MSVC-NEXT: mov x10, x9
+    // AARCH64_MSVC-NEXT: ldr x1, [x9, #8]
+    // AARCH64_MSVC-NEXT: ldr x0, [x10], #16
+    // AARCH64_MSVC-NEXT: str x10, [x8]
+    // AARCH64_MSVC-NEXT: ret
+    va_arg(ap)
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_ptr(ap: &mut VaList<'_>) -> *const u8 {
+    // AARCH64_LINUX-CHECK: read_ptr = read_i64
+    // AARCH64_BE-CHECK: read_ptr = read_i64
+    // AARCH64_MSVC: read_ptr = read_i64
+    // ARM64EC_MSVC: "#read_ptr" = "#read_i64"
+    // AARCH64_DARWIN-CHECK: _read_ptr = _read_i64
+    va_arg(ap)
+}
diff --git a/tests/assembly-llvm/c-variadic/gpu.rs b/tests/assembly-llvm/c-variadic/gpu.rs
new file mode 100644
index 0000000000000..02798354bbf3d
--- /dev/null
+++ b/tests/assembly-llvm/c-variadic/gpu.rs
@@ -0,0 +1,178 @@
+//@ add-minicore
+//@ assembly-output: emit-asm
+//
+//@ revisions: AMDGPU NVPTX
+//@ [AMDGPU] compile-flags: --crate-type=rlib --target=amdgcn-amd-amdhsa -Ctarget-cpu=gfx900
+//@ [AMDGPU] needs-llvm-components: amdgpu
+//@ [NVPTX] compile-flags: --crate-type=rlib --target=nvptx64-nvidia-cuda
+//@ [NVPTX] needs-llvm-components: nvptx
+#![feature(c_variadic, no_core, lang_items, intrinsics, rustc_attrs)]
+#![no_core]
+#![crate_type = "lib"]
+
+extern crate minicore;
+use minicore::*;
+
+#[lang = "va_arg_safe"]
+pub unsafe trait VaArgSafe {}
+
+unsafe impl VaArgSafe for i32 {}
+unsafe impl VaArgSafe for i64 {}
+unsafe impl VaArgSafe for i128 {}
+unsafe impl VaArgSafe for f64 {}
+unsafe impl<T> VaArgSafe for *const T {}
+
+#[repr(transparent)]
+struct VaListInner {
+    ptr: *const c_void,
+}
+
+#[repr(transparent)]
+#[lang = "va_list"]
+pub struct VaList<'a> {
+    inner: VaListInner,
+    _marker: PhantomData<&'a mut ()>,
+}
+
+#[rustc_intrinsic]
+#[rustc_nounwind]
+pub const unsafe fn va_arg<T: VaArgSafe>(ap: &mut VaList<'_>) -> T;
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_f64(ap: &mut VaList<'_>) -> f64 {
+    // CHECK-LABEL: read_f64
+    //
+    // AMDGPU: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0)
+    // AMDGPU-NEXT: flat_load_dwordx2 v[4:5], v[0:1]
+    // AMDGPU-NEXT: s_waitcnt vmcnt(0) lgkmcnt(0)
+    // AMDGPU-NEXT: flat_load_dwordx2 v[2:3], v[4:5]
+    // AMDGPU-NEXT: v_add_co_u32_e32 v4, vcc, 8, v4
+    // AMDGPU-NEXT: v_addc_co_u32_e32 v5, vcc, 0, v5, vcc
+    // AMDGPU-NEXT: flat_store_dwordx2 v[0:1], v[4:5]
+    // AMDGPU-NEXT: s_waitcnt vmcnt(0) lgkmcnt(0)
+    // AMDGPU-NEXT: v_mov_b32_e32 v0, v2
+    // AMDGPU-NEXT: v_mov_b32_e32 v1, v3
+    // AMDGPU-NEXT: s_setpc_b64 s[30:31]
+    //
+    // NVPTX: ld.param.b64 %rd1, [read_f64_param_0];
+    // NVPTX-NEXT: ld.b64 %rd2, [%rd1];
+    // NVPTX-NEXT: add.s64 %rd3, %rd2, 7;
+    // NVPTX-NEXT: and.b64 %rd4, %rd3, -8;
+    // NVPTX-NEXT: add.s64 %rd5, %rd4, 8;
+    // NVPTX-NEXT: st.b64 [%rd1], %rd5;
+    // NVPTX-NEXT: ld.b64 %rd6, [%rd4];
+    // NVPTX-NEXT: st.param.b64 [func_retval0], %rd6;
+    // NVPTX-NEXT: ret;
+    va_arg(ap)
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_i32(ap: &mut VaList<'_>) -> i32 {
+    // CHECK-LABEL: read_i32
+    //
+    // AMDGPU: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0)
+    // AMDGPU-NEXT: flat_load_dwordx2 v[3:4], v[0:1]
+    // AMDGPU-NEXT: s_waitcnt vmcnt(0) lgkmcnt(0)
+    // AMDGPU-NEXT: flat_load_dword v2, v[3:4]
+    // AMDGPU-NEXT: v_add_co_u32_e32 v3, vcc, 4, v3
+    // AMDGPU-NEXT: v_addc_co_u32_e32 v4, vcc, 0, v4, vcc
+    // AMDGPU-NEXT: flat_store_dwordx2 v[0:1], v[3:4]
+    // AMDGPU-NEXT: s_waitcnt vmcnt(0) lgkmcnt(0)
+    // AMDGPU-NEXT: v_mov_b32_e32 v0, v2
+    // AMDGPU-NEXT: s_setpc_b64 s[30:31]
+    //
+    // NVPTX: ld.param.b64 %rd1, [read_i32_param_0];
+    // NVPTX-NEXT: ld.b64 %rd2, [%rd1];
+    // NVPTX-NEXT: add.s64 %rd3, %rd2, 3;
+    // NVPTX-NEXT: and.b64 %rd4, %rd3, -4;
+    // NVPTX-NEXT: add.s64 %rd5, %rd4, 4;
+    // NVPTX-NEXT: st.b64 [%rd1], %rd5;
+    // NVPTX-NEXT: ld.b32 %r1, [%rd4];
+    // NVPTX-NEXT: st.param.b32 [func_retval0], %r1;
+    // NVPTX-NEXT: ret;
+    va_arg(ap)
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_i64(ap: &mut VaList<'_>) -> i64 {
+    // CHECK-LABEL: read_i64
+    //
+    // AMDGPU: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0)
+    // AMDGPU-NEXT: flat_load_dwordx2 v[4:5], v[0:1]
+    // AMDGPU-NEXT: s_waitcnt vmcnt(0) lgkmcnt(0)
+    // AMDGPU-NEXT: flat_load_dwordx2 v[2:3], v[4:5]
+    // AMDGPU-NEXT: v_add_co_u32_e32 v4, vcc, 8, v4
+    // AMDGPU-NEXT: v_addc_co_u32_e32 v5, vcc, 0, v5, vcc
+    // AMDGPU-NEXT: flat_store_dwordx2 v[0:1], v[4:5]
+    // AMDGPU-NEXT: s_waitcnt vmcnt(0) lgkmcnt(0)
+    // AMDGPU-NEXT: v_mov_b32_e32 v0, v2
+    // AMDGPU-NEXT: v_mov_b32_e32 v1, v3
+    // AMDGPU-NEXT: s_setpc_b64 s[30:31]
+    //
+    // NVPTX: ld.param.b64 %rd1, [read_i64_param_0];
+    // NVPTX-NEXT: ld.b64 %rd2, [%rd1];
+    // NVPTX-NEXT: add.s64 %rd3, %rd2, 7;
+    // NVPTX-NEXT: and.b64 %rd4, %rd3, -8;
+    // NVPTX-NEXT: add.s64 %rd5, %rd4, 8;
+    // NVPTX-NEXT: st.b64 [%rd1], %rd5;
+    // NVPTX-NEXT: ld.b64 %rd6, [%rd4];
+    // NVPTX-NEXT: st.param.b64 [func_retval0], %rd6;
+    // NVPTX-NEXT: ret;
+    va_arg(ap)
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_i128(ap: &mut VaList<'_>) -> i128 {
+    // CHECK-LABEL: read_i128
+    //
+    // AMDGPU: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0)
+    // AMDGPU-NEXT: v_mov_b32_e32 v5, v1
+    // AMDGPU-NEXT: v_mov_b32_e32 v4, v0
+    // AMDGPU-NEXT: flat_load_dwordx2 v[6:7], v[4:5]
+    // AMDGPU-NEXT: s_waitcnt vmcnt(0) lgkmcnt(0)
+    // AMDGPU-NEXT: flat_load_dwordx4 v[0:3], v[6:7]
+    // AMDGPU-NEXT: v_add_co_u32_e32 v6, vcc, 16, v6
+    // AMDGPU-NEXT: v_addc_co_u32_e32 v7, vcc, 0, v7, vcc
+    // AMDGPU-NEXT: flat_store_dwordx2 v[4:5], v[6:7]
+    // AMDGPU-NEXT: s_waitcnt vmcnt(0) lgkmcnt(0)
+    // AMDGPU-NEXT: s_setpc_b64 s[30:31]
+    //
+    // NVPTX: ld.param.b64 %rd1, [read_i128_param_0];
+    // NVPTX-NEXT: ld.b64 %rd2, [%rd1];
+    // NVPTX-NEXT: add.s64 %rd3, %rd2, 15;
+    // NVPTX-NEXT: and.b64 %rd4, %rd3, -16;
+    // NVPTX-NEXT: add.s64 %rd5, %rd4, 16;
+    // NVPTX-NEXT: st.b64 [%rd1], %rd5;
+    // NVPTX-NEXT: ld.v2.b64 {%rd6, %rd7}, [%rd4];
+    // NVPTX-NEXT: st.param.v2.b64 [func_retval0], {%rd6, %rd7};
+    // NVPTX-NEXT: ret;
+    va_arg(ap)
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_ptr(ap: &mut VaList<'_>) -> *const u8 {
+    // CHECK-LABEL: read_ptr
+    //
+    // AMDGPU: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0)
+    // AMDGPU-NEXT: flat_load_dwordx2 v[4:5], v[0:1]
+    // AMDGPU-NEXT: s_waitcnt vmcnt(0) lgkmcnt(0)
+    // AMDGPU-NEXT: flat_load_dwordx2 v[2:3], v[4:5]
+    // AMDGPU-NEXT: v_add_co_u32_e32 v4, vcc, 8, v4
+    // AMDGPU-NEXT: v_addc_co_u32_e32 v5, vcc, 0, v5, vcc
+    // AMDGPU-NEXT: flat_store_dwordx2 v[0:1], v[4:5]
+    // AMDGPU-NEXT: s_waitcnt vmcnt(0) lgkmcnt(0)
+    // AMDGPU-NEXT: v_mov_b32_e32 v0, v2
+    // AMDGPU-NEXT: v_mov_b32_e32 v1, v3
+    // AMDGPU-NEXT: s_setpc_b64 s[30:31]
+    //
+    // NVPTX: ld.param.b64 %rd1, [read_ptr_param_0];
+    // NVPTX-NEXT: ld.b64 %rd2, [%rd1];
+    // NVPTX-NEXT: add.s64 %rd3, %rd2, 7;
+    // NVPTX-NEXT: and.b64 %rd4, %rd3, -8;
+    // NVPTX-NEXT: add.s64 %rd5, %rd4, 8;
+    // NVPTX-NEXT: st.b64 [%rd1], %rd5;
+    // NVPTX-NEXT: ld.b64 %rd6, [%rd4];
+    // NVPTX-NEXT: st.param.b64 [func_retval0], %rd6;
+    // NVPTX-NEXT: ret;
+    va_arg(ap)
+}
diff --git a/tests/assembly-llvm/c-variadic/powerpc.rs b/tests/assembly-llvm/c-variadic/powerpc.rs
new file mode 100644
index 0000000000000..47d35e7579737
--- /dev/null
+++ b/tests/assembly-llvm/c-variadic/powerpc.rs
@@ -0,0 +1,198 @@
+//@ add-minicore
+//@ assembly-output: emit-asm
+//
+//@ revisions: POWERPC POWERPC64 POWERPC64LE AIX
+//@ [POWERPC] compile-flags: -Copt-level=3 --target powerpc-unknown-linux-gnu
+//@ [POWERPC] needs-llvm-components: powerpc
+//@ [POWERPC64] compile-flags: -Copt-level=3 --target powerpc64-unknown-linux-gnu
+//@ [POWERPC64] needs-llvm-components: powerpc
+//@ [POWERPC64LE] compile-flags: -Copt-level=3 --target powerpc64le-unknown-linux-gnu
+//@ [POWERPC64LE] needs-llvm-components: powerpc
+//@ [AIX] compile-flags: -Copt-level=3 --target powerpc64-ibm-aix
+//@ [AIX] needs-llvm-components: powerpc
+#![feature(c_variadic, no_core, lang_items, intrinsics, rustc_attrs)]
+#![no_core]
+#![crate_type = "lib"]
+
+// Check that the assembly that rustc generates matches what clang emits.
+
+extern crate minicore;
+use minicore::*;
+
+#[lang = "va_arg_safe"]
+pub unsafe trait VaArgSafe {}
+
+unsafe impl VaArgSafe for i32 {}
+unsafe impl VaArgSafe for i64 {}
+#[cfg(target_pointer_width = "64")]
+unsafe impl VaArgSafe for i128 {}
+unsafe impl VaArgSafe for f64 {}
+unsafe impl<T> VaArgSafe for *const T {}
+
+#[repr(transparent)]
+struct VaListInner {
+    ptr: *const c_void,
+}
+
+#[repr(transparent)]
+#[lang = "va_list"]
+pub struct VaList<'a> {
+    inner: VaListInner,
+    _marker: PhantomData<&'a mut ()>,
+}
+
+#[rustc_intrinsic]
+#[rustc_nounwind]
+pub const unsafe fn va_arg<T: VaArgSafe>(ap: &mut VaList<'_>) -> T;
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_f64(ap: &mut VaList<'_>) -> f64 {
+    // CHECK-LABEL: read_f64
+    //
+    // POWERPC: lbz 5, 1(3)
+    // POWERPC-NEXT: cmplwi 5, 7
+    // POWERPC-NEXT: bgt 0, .LBB0_2
+    // POWERPC-NEXT: lwz 4, 8(3)
+    // POWERPC-NEXT: rlwinm 6, 5, 3, 24, 28
+    // POWERPC-NEXT: addi 5, 5, 1
+    // POWERPC-NEXT: add 4, 4, 6
+    // POWERPC-NEXT: addi 4, 4, 32
+    // POWERPC-NEXT: lfd 1, 0(4)
+    // POWERPC-NEXT: stb 5, 1(3)
+    // POWERPC-NEXT: blr
+    //
+    // POWERPC64: ld 4, 0(3)
+    // POWERPC64-NEXT: lfd 1, 0(4)
+    // POWERPC64-NEXT: addi 4, 4, 8
+    // POWERPC64-NEXT: std 4, 0(3)
+    // POWERPC64-NEXT: blr
+    //
+    // POWERPC64LE: ld 4, 0(3)
+    // POWERPC64LE-NEXT: lfd 1, 0(4)
+    // POWERPC64LE-NEXT: addi 5, 4, 8
+    // POWERPC64LE-NEXT: std 5, 0(3)
+    // POWERPC64LE-NEXT: blr
+    //
+    // AIX: ld 4, 0(3)
+    // AIX-NEXT: lfd 1, 0(4)
+    // AIX-NEXT: addi 5, 4, 8
+    // AIX-NEXT: std 5, 0(3)
+    // AIX-NEXT: blr
+    va_arg(ap)
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_i32(ap: &mut VaList<'_>) -> i32 {
+    // CHECK-LABEL: read_i32
+    //
+    // POWERPC: lbz 5, 0(3)
+    // POWERPC-NEXT: mr 4, 3
+    // POWERPC-NEXT: cmplwi 5, 7
+    // POWERPC-NEXT: bgt 0, .LBB1_2
+    // POWERPC-NEXT: lwz 3, 8(4)
+    // POWERPC-NEXT: rlwinm 6, 5, 2, 24, 29
+    // POWERPC-NEXT: addi 5, 5, 1
+    // POWERPC-NEXT: add 3, 3, 6
+    // POWERPC-NEXT: lwz 3, 0(3)
+    // POWERPC-NEXT: stb 5, 0(4)
+    // POWERPC-NEXT: blr
+    //
+    // POWERPC64: ld 5, 0(3)
+    // POWERPC64-NEXT: mr 4, 3
+    // POWERPC64-NEXT: lwa 3, 4(5)
+    // POWERPC64-NEXT: addi 5, 5, 8
+    // POWERPC64-NEXT: std 5, 0(4)
+    // POWERPC64-NEXT: blr
+    //
+    // POWERPC64LE: ld 4, 0(3)
+    // POWERPC64LE-NEXT: addi 5, 4, 8
+    // POWERPC64LE-NEXT: std 5, 0(3)
+    // POWERPC64LE-NEXT: lwa 3, 0(4)
+    // POWERPC64LE-NEXT: blr
+    //
+    // AIX: ld 4, 0(3)
+    // AIX-NEXT: addi 5, 4, 8
+    // AIX-NEXT: std 5, 0(3)
+    // AIX-NEXT: lwa 3, 4(4)
+    // AIX-NEXT: blr
+    va_arg(ap)
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_i64(ap: &mut VaList<'_>) -> i64 {
+    // CHECK-LABEL: read_i64
+    //
+    // POWERPC: mr 5, 3
+    // POWERPC-NEXT: lbz 3, 0(3)
+    // POWERPC-NEXT: addi 3, 3, 1
+    // POWERPC-NEXT: clrlwi 4, 3, 24
+    // POWERPC-NEXT: cmplwi 4, 7
+    // POWERPC-NEXT: bgt 0, .LBB2_2
+    // POWERPC-NEXT: lwz 4, 8(5)
+    // POWERPC-NEXT: rlwinm 6, 3, 0, 29, 30
+    // POWERPC-NEXT: rlwinm 3, 3, 2, 27, 28
+    // POWERPC-NEXT: addi 6, 6, 2
+    // POWERPC-NEXT: add 4, 4, 3
+    // POWERPC-NEXT: lwz 3, 0(4)
+    // POWERPC-NEXT: lwz 4, 4(4)
+    // POWERPC-NEXT: stb 6, 0(5)
+    // POWERPC-NEXT: blr
+    //
+    // POWERPC64: ld 5, 0(3)
+    // POWERPC64-NEXT: mr 4, 3
+    // POWERPC64-NEXT: ld 3, 0(5)
+    // POWERPC64-NEXT: addi 5, 5, 8
+    // POWERPC64-NEXT: std 5, 0(4)
+    // POWERPC64-NEXT: blr
+    //
+    // POWERPC64LE: ld 4, 0(3)
+    // POWERPC64LE-NEXT: addi 5, 4, 8
+    // POWERPC64LE-NEXT: std 5, 0(3)
+    // POWERPC64LE-NEXT: ld 3, 0(4)
+    // POWERPC64LE-NEXT: blr
+    //
+    // AIX: ld 4, 0(3)
+    // AIX-NEXT: addi 5, 4, 8
+    // AIX-NEXT: std 5, 0(3)
+    // AIX-NEXT: ld 3, 0(4)
+    // AIX-NEXT: blr
+    va_arg(ap)
+}
+
+#[unsafe(no_mangle)]
+#[cfg(target_pointer_width = "64")]
+unsafe extern "C" fn read_i128(ap: &mut VaList<'_>) -> i128 {
+    // POWERPC64-LABEL: read_i128
+    // POWERPC64: ld 6, 0(3)
+    // POWERPC64-NEXT: mr  5, 3
+    // POWERPC64-NEXT: ld 3, 0(6)
+    // POWERPC64-NEXT: ld 4, 8(6)
+    // POWERPC64-NEXT: addi 6, 6, 16
+    // POWERPC64-NEXT: std 6, 0(5)
+    // POWERPC64-NEXT: blr
+    //
+    // POWERPC64LE-LABEL: read_i128
+    // POWERPC64LE: ld 4, 0(3)
+    // POWERPC64LE-NEXT: addi 5, 4, 16
+    // POWERPC64LE-NEXT: std 5, 0(3)
+    // POWERPC64LE-NEXT: ld 3, 0(4)
+    // POWERPC64LE-NEXT: ld 4, 8(4)
+    // POWERPC64LE-NEXT: blr
+    //
+    // AIX-LABEL: read_i128
+    // AIX: ld 4, 0(3)
+    // AIX-NEXT: addi 5, 4, 16
+    // AIX-NEXT: std 5, 0(3)
+    // AIX-NEXT: ld 3, 0(4)
+    // AIX-NEXT: ld 4, 8(4)
+    // AIX-NEXT: blr
+    va_arg(ap)
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_ptr(ap: &mut VaList<'_>) -> *const u8 {
+    // POWERPC: read_ptr = read_i32
+    // POWERPC64: read_ptr = read_i64
+    // POWERPC64LE: read_ptr = read_i64
+    va_arg(ap)
+}
diff --git a/tests/assembly-llvm/c-variadic/riscv.rs b/tests/assembly-llvm/c-variadic/riscv.rs
new file mode 100644
index 0000000000000..893d2a65eb37d
--- /dev/null
+++ b/tests/assembly-llvm/c-variadic/riscv.rs
@@ -0,0 +1,127 @@
+//@ add-minicore
+//@ assembly-output: emit-asm
+//
+//@ revisions: RISCV32 RISCV64
+//@ [RISCV32] compile-flags: -Copt-level=3 --target riscv32gc-unknown-linux-gnu
+//@ [RISCV32] needs-llvm-components: riscv
+//@ [RISCV64] compile-flags: -Copt-level=3 --target riscv64gc-unknown-linux-gnu
+//@ [RISCV64] needs-llvm-components: riscv
+#![feature(c_variadic, no_core, lang_items, intrinsics, rustc_attrs)]
+#![no_core]
+#![crate_type = "lib"]
+
+extern crate minicore;
+use minicore::*;
+
+#[lang = "va_arg_safe"]
+pub unsafe trait VaArgSafe {}
+
+unsafe impl VaArgSafe for i32 {}
+unsafe impl VaArgSafe for i64 {}
+#[cfg(target_pointer_width = "64")]
+unsafe impl VaArgSafe for i128 {}
+unsafe impl VaArgSafe for f64 {}
+unsafe impl<T> VaArgSafe for *const T {}
+
+#[repr(transparent)]
+struct VaListInner {
+    ptr: *const c_void,
+}
+
+#[repr(transparent)]
+#[lang = "va_list"]
+pub struct VaList<'a> {
+    inner: VaListInner,
+    _marker: PhantomData<&'a mut ()>,
+}
+
+#[rustc_intrinsic]
+#[rustc_nounwind]
+pub const unsafe fn va_arg<T: VaArgSafe>(ap: &mut VaList<'_>) -> T;
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_f64(ap: &mut VaList<'_>) -> f64 {
+    // CHECK-LABEL: read_f64
+    //
+    // RISCV32: lw a1, 0(a0)
+    // RISCV32-NEXT: addi a1, a1, 7
+    // RISCV32-NEXT: andi a1, a1, -8
+    // RISCV32-NEXT: fld fa0, 0(a1)
+    // RISCV32-NEXT: addi a1, a1, 8
+    // RISCV32-NEXT: sw a1, 0(a0)
+    // RISCV32-NEXT: ret
+    //
+    // RISCV64: ld a1, 0(a0)
+    // RISCV64-NEXT: fld fa0, 0(a1)
+    // RISCV64-NEXT: addi a1, a1, 8
+    // RISCV64-NEXT: sd a1, 0(a0)
+    // RISCV64-NEXT: ret
+    va_arg(ap)
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_i32(ap: &mut VaList<'_>) -> i32 {
+    // CHECK-LABEL: read_i32
+    //
+    // RISCV32: lw a2, 0(a0)
+    // RISCV32-NEXT: lw a1, 0(a2)
+    // RISCV32-NEXT: addi a2, a2, 4
+    // RISCV32-NEXT: sw a2, 0(a0)
+    // RISCV32-NEXT: mv a0, a1
+    // RISCV32-NEXT: ret
+    //
+    // RISCV64: ld a2, 0(a0)
+    // RISCV64-NEXT: lw a1, 0(a2)
+    // RISCV64-NEXT: addi a2, a2, 8
+    // RISCV64-NEXT: sd a2, 0(a0)
+    // RISCV64-NEXT: mv a0, a1
+    // RISCV64-NEXT: ret
+    va_arg(ap)
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_i64(ap: &mut VaList<'_>) -> i64 {
+    // CHECK-LABEL: read_i64
+    //
+    // RISCV32: lw a1, 0(a0)
+    // RISCV32-NEXT: addi a1, a1, 7
+    // RISCV32-NEXT: andi a3, a1, -8
+    // RISCV32-NEXT: lw a2, 0(a3)
+    // RISCV32-NEXT: lw a1, 4(a3)
+    // RISCV32-NEXT: addi a3, a3, 8
+    // RISCV32-NEXT: sw a3, 0(a0)
+    // RISCV32-NEXT: mv a0, a2
+    // RISCV32-NEXT: ret
+    //
+    // RISCV64: ld a2, 0(a0)
+    // RISCV64-NEXT: ld a1, 0(a2)
+    // RISCV64-NEXT: addi a2, a2, 8
+    // RISCV64-NEXT: sd a2, 0(a0)
+    // RISCV64-NEXT: mv a0, a1
+    // RISCV64-NEXT: ret
+    va_arg(ap)
+}
+
+#[unsafe(no_mangle)]
+#[cfg(target_pointer_width = "64")]
+unsafe extern "C" fn read_i128(ap: &mut VaList<'_>) -> i128 {
+    // RISCV64-LABEL: read_i128
+    //
+    // RISCV64: ld a1, 0(a0)
+    // RISCV64-NEXT: addi a1, a1, 15
+    // RISCV64-NEXT: andi a3, a1, -16
+    // RISCV64-NEXT: ld a2, 0(a3)
+    // RISCV64-NEXT: ld a1, 8(a3)
+    // RISCV64-NEXT: addi a3, a3, 16
+    // RISCV64-NEXT: sd a3, 0(a0)
+    // RISCV64-NEXT: mv a0, a2
+    // RISCV64-NEXT: ret
+    va_arg(ap)
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_ptr(ap: &mut VaList<'_>) -> *const u8 {
+    // RISCV32: read_ptr = read_i32
+    // RISCV64: read_ptr = read_i64
+    va_arg(ap)
+}
diff --git a/tests/assembly-llvm/c-variadic/s390x.rs b/tests/assembly-llvm/c-variadic/s390x.rs
new file mode 100644
index 0000000000000..fef239273e2c5
--- /dev/null
+++ b/tests/assembly-llvm/c-variadic/s390x.rs
@@ -0,0 +1,133 @@
+//@ add-minicore
+//@ assembly-output: emit-asm
+//
+//@ compile-flags: -Copt-level=3 --target s390x-unknown-linux-gnu
+//@ needs-llvm-components: systemz
+#![feature(c_variadic, no_core, lang_items, intrinsics, rustc_attrs)]
+#![no_core]
+#![crate_type = "lib"]
+
+// Check that the assembly that rustc generates matches what clang emits.
+
+extern crate minicore;
+use minicore::*;
+
+#[lang = "va_arg_safe"]
+pub unsafe trait VaArgSafe {}
+
+unsafe impl VaArgSafe for i32 {}
+unsafe impl VaArgSafe for i64 {}
+unsafe impl VaArgSafe for i128 {}
+unsafe impl VaArgSafe for f64 {}
+unsafe impl<T> VaArgSafe for *const T {}
+
+#[repr(transparent)]
+struct VaListInner {
+    ptr: *const c_void,
+}
+
+#[repr(transparent)]
+#[lang = "va_list"]
+pub struct VaList<'a> {
+    inner: VaListInner,
+    _marker: PhantomData<&'a mut ()>,
+}
+
+#[rustc_intrinsic]
+#[rustc_nounwind]
+pub const unsafe fn va_arg<T: VaArgSafe>(ap: &mut VaList<'_>) -> T;
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_f64(ap: &mut VaList<'_>) -> f64 {
+    // CHECK-LABEL: read_f64:
+    // CHECK: lg %r3, 8(%r2)
+    // CHECK-NEXT: clgijh %r3, 3, .LBB0_2
+    // CHECK-NEXT: lg %r1, 24(%r2)
+    // CHECK-NEXT: sllg %r4, %r3, 3
+    // CHECK-NEXT: la %r1, 128(%r4,%r1)
+    // CHECK-NEXT: la %r0, 1(%r3)
+    // CHECK-NEXT: stg %r0, 8(%r2)
+    // CHECK-NEXT: ld %f0, 0(%r1)
+    // CHECK-NEXT: br %r14
+    // CHECK-NEXT: .LBB0_2:
+    // CHECK-NEXT: lg %r1, 16(%r2)
+    // CHECK-NEXT: la %r0, 8(%r1)
+    // CHECK-NEXT: stg %r0, 16(%r2)
+    // CHECK-NEXT: ld %f0, 0(%r1)
+    // CHECK-NEXT: br %r14
+    va_arg(ap)
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_i32(ap: &mut VaList<'_>) -> i32 {
+    // CHECK-LABEL: read_i32:
+    // CHECK: lg %r3, 0(%r2)
+    // CHECK-NEXT: clgijh %r3, 4, .LBB1_2
+    // CHECK-NEXT: lg %r1, 24(%r2)
+    // CHECK-NEXT: sllg %r4, %r3, 3
+    // CHECK-NEXT: la %r1, 20(%r4,%r1)
+    // CHECK-NEXT: la %r0, 1(%r3)
+    // CHECK-NEXT: stg %r0, 0(%r2)
+    // CHECK-NEXT: lgf %r2, 0(%r1)
+    // CHECK-NEXT: br %r14
+    // CHECK-NEXT: .LBB1_2:
+    // CHECK-NEXT: lg %r3, 16(%r2)
+    // CHECK-NEXT: la %r1, 4(%r3)
+    // CHECK-NEXT: la %r0, 8(%r3)
+    // CHECK-NEXT: stg %r0, 16(%r2)
+    // CHECK-NEXT: lgf %r2, 0(%r1)
+    // CHECK-NEXT: br %r14
+    va_arg(ap)
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_i64(ap: &mut VaList<'_>) -> i64 {
+    // CHECK-LABEL: read_i64:
+    // CHECK: lg %r3, 0(%r2)
+    // CHECK-NEXT: clgijh %r3, 4, .LBB2_2
+    // CHECK-NEXT: lg %r1, 24(%r2)
+    // CHECK-NEXT: sllg %r4, %r3, 3
+    // CHECK-NEXT: la %r1, 16(%r4,%r1)
+    // CHECK-NEXT: la %r0, 1(%r3)
+    // CHECK-NEXT: stg %r0, 0(%r2)
+    // CHECK-NEXT: lg %r2, 0(%r1)
+    // CHECK-NEXT: br %r14
+    // CHECK-NEXT: .LBB2_2:
+    // CHECK-NEXT: lg %r1, 16(%r2)
+    // CHECK-NEXT: la %r0, 8(%r1)
+    // CHECK-NEXT: stg %r0, 16(%r2)
+    // CHECK-NEXT: lg %r2, 0(%r1)
+    // CHECK-NEXT: br %r14
+    va_arg(ap)
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_i128(ap: &mut VaList<'_>) -> i128 {
+    // CHECK-LABEL: read_i128:
+    // CHECK: lg %r4, 0(%r3)
+    // CHECK-NEXT: clgijh %r4, 4, .LBB3_2
+    // CHECK-NEXT: lg %r1, 24(%r3)
+    // CHECK-NEXT: sllg %r5, %r4, 3
+    // CHECK-NEXT: la %r1, 16(%r5,%r1)
+    // CHECK-NEXT: la %r0, 1(%r4)
+    // CHECK-NEXT: stg %r0, 0(%r3)
+    // CHECK-NEXT: lg %r1, 0(%r1)
+    // CHECK-NEXT: mvc 8(8,%r2), 8(%r1)
+    // CHECK-NEXT: mvc 0(8,%r2), 0(%r1)
+    // CHECK-NEXT: br %r14
+    // CHECK-NEXT: .LBB3_2:
+    // CHECK-NEXT: lg %r1, 16(%r3)
+    // CHECK-NEXT: la %r0, 8(%r1)
+    // CHECK-NEXT: stg %r0, 16(%r3)
+    // CHECK-NEXT: lg %r1, 0(%r1)
+    // CHECK-NEXT: mvc 8(8,%r2), 8(%r1)
+    // CHECK-NEXT: mvc 0(8,%r2), 0(%r1)
+    // CHECK-NEXT: br %r14
+    va_arg(ap)
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_ptr(ap: &mut VaList<'_>) -> *const u8 {
+    // CHECK: read_ptr = read_i64
+    va_arg(ap)
+}
diff --git a/tests/assembly-llvm/c-variadic/sparc.rs b/tests/assembly-llvm/c-variadic/sparc.rs
index 6ce25119a135c..81e3313c244cc 100644
--- a/tests/assembly-llvm/c-variadic/sparc.rs
+++ b/tests/assembly-llvm/c-variadic/sparc.rs
@@ -21,6 +21,8 @@ pub unsafe trait VaArgSafe {}
 
 unsafe impl VaArgSafe for i32 {}
 unsafe impl VaArgSafe for i64 {}
+#[cfg(target_pointer_width = "64")]
+unsafe impl VaArgSafe for i128 {}
 unsafe impl VaArgSafe for f64 {}
 unsafe impl<T> VaArgSafe for *const T {}
 
@@ -105,6 +107,22 @@ unsafe extern "C" fn read_i64(ap: &mut VaList<'_>) -> i64 {
     va_arg(ap)
 }
 
+#[unsafe(no_mangle)]
+#[cfg(target_pointer_width = "64")]
+unsafe extern "C" fn read_i128(ap: &mut VaList<'_>) -> i128 {
+    // SPARC64-LABEL: read_i128
+    // SPARC64: ldx [%o0], %o1
+    // SPARC64-NEXT: add %o1, 15, %o1
+    // SPARC64-NEXT: and %o1, -16, %o1
+    // SPARC64-NEXT: add %o1, 16, %o2
+    // SPARC64-NEXT: stx %o2, [%o0]
+    // SPARC64-NEXT: ldx [%o1], %o0
+    // SPARC64-NEXT: or %o1, 8, %o1
+    // SPARC64-NEXT: retl
+    // SPARC64-NEXT: ldx [%o1], %o1
+    va_arg(ap)
+}
+
 #[unsafe(no_mangle)]
 unsafe extern "C" fn read_ptr(ap: &mut VaList<'_>) -> *const u8 {
     // SPARC: read_ptr = read_i32
diff --git a/tests/assembly-llvm/c-variadic/wasm.rs b/tests/assembly-llvm/c-variadic/wasm.rs
new file mode 100644
index 0000000000000..8d05cdb1923b4
--- /dev/null
+++ b/tests/assembly-llvm/c-variadic/wasm.rs
@@ -0,0 +1,224 @@
+//@ add-minicore
+//@ assembly-output: emit-asm
+//
+//@ revisions: WASM32 WASM64
+//@ [WASM32] compile-flags: -Copt-level=3 -Zmerge-functions=disabled --target wasm32-unknown-unknown
+//@ [WASM32] needs-llvm-components: webassembly
+//@ [WASM64] compile-flags: -Copt-level=3 -Zmerge-functions=disabled --target wasm64-unknown-unknown
+//@ [WASM64] needs-llvm-components: webassembly
+#![feature(c_variadic, no_core, lang_items, intrinsics, rustc_attrs)]
+#![no_core]
+#![crate_type = "lib"]
+
+// Check that the assembly that rustc generates matches what clang emits.
+
+extern crate minicore;
+use minicore::*;
+
+#[lang = "va_arg_safe"]
+pub unsafe trait VaArgSafe {}
+
+unsafe impl VaArgSafe for i32 {}
+unsafe impl VaArgSafe for i64 {}
+unsafe impl VaArgSafe for i128 {}
+unsafe impl VaArgSafe for f64 {}
+unsafe impl<T> VaArgSafe for *const T {}
+
+#[repr(transparent)]
+struct VaListInner {
+    ptr: *const c_void,
+}
+
+#[repr(transparent)]
+#[lang = "va_list"]
+pub struct VaList<'a> {
+    inner: VaListInner,
+    _marker: PhantomData<&'a mut ()>,
+}
+
+#[rustc_intrinsic]
+#[rustc_nounwind]
+pub const unsafe fn va_arg<T: VaArgSafe>(ap: &mut VaList<'_>) -> T;
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_f64(ap: &mut VaList<'_>) -> f64 {
+    // WASM32-LABEL: read_f64:
+    // WASM32: local.get 0
+    // WASM32-NEXT: local.get 0
+    // WASM32-NEXT: i32.load 0
+    // WASM32-NEXT: i32.const 7
+    // WASM32-NEXT: i32.add
+    // WASM32-NEXT: i32.const -8
+    // WASM32-NEXT: i32.and
+    // WASM32-NEXT: local.tee 1
+    // WASM32-NEXT: i32.const 8
+    // WASM32-NEXT: i32.add
+    // WASM32-NEXT: i32.store 0
+    // WASM32-NEXT: local.get 1
+    // WASM32-NEXT: f64.load 0
+    // WASM32-NEXT: end_function
+    //
+    // WASM64-LABEL: read_f64:
+    // WASM64: local.get 0
+    // WASM64-NEXT: local.get 0
+    // WASM64-NEXT: i64.load 0
+    // WASM64-NEXT: i64.const 7
+    // WASM64-NEXT: i64.add
+    // WASM64-NEXT: i64.const -8
+    // WASM64-NEXT: i64.and
+    // WASM64-NEXT: local.tee 1
+    // WASM64-NEXT: i64.const 8
+    // WASM64-NEXT: i64.add
+    // WASM64-NEXT: i64.store 0
+    // WASM64-NEXT: local.get 1
+    // WASM64-NEXT: f64.load 0
+    // WASM64-NEXT: end_function
+    va_arg(ap)
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_i32(ap: &mut VaList<'_>) -> i32 {
+    // WASM32-LABEL: read_i32:
+    // WASM32: local.get 0
+    // WASM32-NEXT: local.get 0
+    // WASM32-NEXT: i32.load 0
+    // WASM32-NEXT: local.tee 1
+    // WASM32-NEXT: i32.const 4
+    // WASM32-NEXT: i32.add
+    // WASM32-NEXT: i32.store 0
+    // WASM32-NEXT: local.get 1
+    // WASM32-NEXT: i32.load 0
+    // WASM32-NEXT: end_function
+    //
+    // WASM64-LABEL: read_i32:
+    // WASM64: local.get 0
+    // WASM64-NEXT: local.get 0
+    // WASM64-NEXT: i64.load 0
+    // WASM64-NEXT: local.tee 1
+    // WASM64-NEXT: i64.const 4
+    // WASM64-NEXT: i64.add
+    // WASM64-NEXT: i64.store 0
+    // WASM64-NEXT: local.get 1
+    // WASM64-NEXT: i32.load 0
+    // WASM64-NEXT: end_function
+    va_arg(ap)
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_ptr(ap: &mut VaList<'_>) -> *const u8 {
+    // WASM32-LABEL: read_ptr:
+    // WASM32: local.get 0
+    // WASM32-NEXT: local.get 0
+    // WASM32-NEXT: i32.load 0
+    // WASM32-NEXT: local.tee 1
+    // WASM32-NEXT: i32.const 4
+    // WASM32-NEXT: i32.add
+    // WASM32-NEXT: i32.store 0
+    // WASM32-NEXT: local.get 1
+    // WASM32-NEXT: i32.load 0
+    // WASM32-NEXT: end_function
+    //
+    // WASM64-LABEL: read_ptr:
+    // WASM64: local.get 0
+    // WASM64-NEXT: local.get 0
+    // WASM64-NEXT: i64.load 0
+    // WASM64-NEXT: i64.const 7
+    // WASM64-NEXT: i64.add
+    // WASM64-NEXT: i64.const -8
+    // WASM64-NEXT: i64.and
+    // WASM64-NEXT: local.tee 1
+    // WASM64-NEXT: i64.const 8
+    // WASM64-NEXT: i64.add
+    // WASM64-NEXT: i64.store 0
+    // WASM64-NEXT: local.get 1
+    // WASM64-NEXT: i64.load 0
+    // WASM64-NEXT: end_function
+    va_arg(ap)
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_i64(ap: &mut VaList<'_>) -> i64 {
+    // WASM32-LABEL: read_i64:
+    // WASM32: local.get 0
+    // WASM32-NEXT: local.get 0
+    // WASM32-NEXT: i32.load 0
+    // WASM32-NEXT: i32.const 7
+    // WASM32-NEXT: i32.add
+    // WASM32-NEXT: i32.const -8
+    // WASM32-NEXT: i32.and
+    // WASM32-NEXT: local.tee 1
+    // WASM32-NEXT: i32.const 8
+    // WASM32-NEXT: i32.add
+    // WASM32-NEXT: i32.store 0
+    // WASM32-NEXT: local.get 1
+    // WASM32-NEXT: i64.load 0
+    // WASM32-NEXT: end_function
+    //
+    // WASM64-LABEL: read_i64:
+    // WASM64: local.get 0
+    // WASM64-NEXT: local.get 0
+    // WASM64-NEXT: i64.load 0
+    // WASM64-NEXT: i64.const 7
+    // WASM64-NEXT: i64.add
+    // WASM64-NEXT: i64.const -8
+    // WASM64-NEXT: i64.and
+    // WASM64-NEXT: local.tee 1
+    // WASM64-NEXT: i64.const 8
+    // WASM64-NEXT: i64.add
+    // WASM64-NEXT: i64.store 0
+    // WASM64-NEXT: local.get 1
+    // WASM64-NEXT: i64.load 0
+    // WASM64-NEXT: end_function
+    va_arg(ap)
+}
+
+// Clang and Rustc use a different ABI for i128 on wasm32, and LLVM optimizes differently if we use
+// a mutable reference instead of just a pointer. With this setup we match the equivalent Clang
+// input exactly.
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_i128(out: *mut i128, ap: *mut VaList<'_>) {
+    // WASM32-LABEL: read_i128:
+    // WASM32: local.get 1
+    // WASM32-NEXT: local.get 1
+    // WASM32-NEXT: i32.load 0
+    // WASM32-NEXT: i32.const 15
+    // WASM32-NEXT: i32.add
+    // WASM32-NEXT: i32.const -16
+    // WASM32-NEXT: i32.and
+    // WASM32-NEXT: local.tee 2
+    // WASM32-NEXT: i32.const 16
+    // WASM32-NEXT: i32.add
+    // WASM32-NEXT: i32.store 0
+    // WASM32-NEXT: local.get 0
+    // WASM32-NEXT: local.get 2
+    // WASM32-NEXT: i64.load 0
+    // WASM32-NEXT: i64.store 0
+    // WASM32-NEXT: local.get 0
+    // WASM32-NEXT: local.get 2
+    // WASM32-NEXT: i64.load 8
+    // WASM32-NEXT: i64.store 8
+    // WASM32-NEXT: end_function
+    //
+    // WASM64-LABEL: read_i128:
+    // WASM64: local.get 1
+    // WASM64-NEXT: local.get 1
+    // WASM64-NEXT: i64.load 0
+    // WASM64-NEXT: i64.const 15
+    // WASM64-NEXT: i64.add
+    // WASM64-NEXT: i64.const -16
+    // WASM64-NEXT: i64.and
+    // WASM64-NEXT: local.tee 2
+    // WASM64-NEXT: i64.const 16
+    // WASM64-NEXT: i64.add
+    // WASM64-NEXT: i64.store 0
+    // WASM64-NEXT: local.get 0
+    // WASM64-NEXT: local.get 2
+    // WASM64-NEXT: i64.load 0
+    // WASM64-NEXT: i64.store 0
+    // WASM64-NEXT: local.get 0
+    // WASM64-NEXT: local.get 2
+    // WASM64-NEXT: i64.load 8
+    // WASM64-NEXT: i64.store 8
+    // WASM64-NEXT: end_function
+    *out = va_arg(mem::transmute(ap));
+}
diff --git a/tests/assembly-llvm/c-variadic/x86-linux.rs b/tests/assembly-llvm/c-variadic/x86-linux.rs
new file mode 100644
index 0000000000000..8cc4731346b17
--- /dev/null
+++ b/tests/assembly-llvm/c-variadic/x86-linux.rs
@@ -0,0 +1,237 @@
+//@ add-minicore
+//@ assembly-output: emit-asm
+//
+//@ revisions: X86_64 X86_64_GNUX32 I686
+//@ [X86_64] compile-flags: -Copt-level=3 -Cllvm-args=-x86-asm-syntax=intel
+//@ [X86_64] compile-flags: --target x86_64-unknown-linux-gnu
+//@ [X86_64] needs-llvm-components: x86
+//@ [X86_64_GNUX32] compile-flags: -Copt-level=3 -Cllvm-args=-x86-asm-syntax=intel
+//@ [X86_64_GNUX32] compile-flags: --target x86_64-unknown-linux-gnux32
+//@ [X86_64_GNUX32] needs-llvm-components: x86
+//@ [I686] compile-flags: -Copt-level=3 -Cllvm-args=-x86-asm-syntax=intel
+//@ [I686] compile-flags: --target i686-unknown-linux-gnu
+//@ [I686] needs-llvm-components: x86
+#![feature(c_variadic, no_core, lang_items, intrinsics, rustc_attrs)]
+#![no_core]
+#![crate_type = "lib"]
+
+// Check that the assembly that rustc generates matches what clang emits.
+
+extern crate minicore;
+use minicore::*;
+
+#[lang = "va_arg_safe"]
+pub unsafe trait VaArgSafe {}
+
+unsafe impl VaArgSafe for i32 {}
+unsafe impl VaArgSafe for i64 {}
+#[cfg(target_pointer_width = "64")]
+unsafe impl VaArgSafe for i128 {}
+unsafe impl VaArgSafe for f64 {}
+unsafe impl<T> VaArgSafe for *const T {}
+
+#[repr(transparent)]
+struct VaListInner {
+    ptr: *const c_void,
+}
+
+#[repr(transparent)]
+#[lang = "va_list"]
+pub struct VaList<'a> {
+    inner: VaListInner,
+    _marker: PhantomData<&'a mut ()>,
+}
+
+#[rustc_intrinsic]
+#[rustc_nounwind]
+pub const unsafe fn va_arg<T: VaArgSafe>(ap: &mut VaList<'_>) -> T;
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_f64(ap: &mut VaList<'_>) -> f64 {
+    // CHECK-LABEL: read_f64
+
+    // X86_64: mov     ecx, dword ptr [rdi + 4]
+    // X86_64-NEXT: cmp     rcx, 160
+    // X86_64-NEXT: ja      .LBB0_2
+    // X86_64-NEXT: mov     rax, rcx
+    // X86_64-NEXT: add     rax, qword ptr [rdi + 16]
+    // X86_64-NEXT: add     ecx, 16
+    // X86_64-NEXT: mov     dword ptr [rdi + 4], ecx
+    // X86_64-NEXT: movsd   xmm0, qword ptr [rax]
+    // X86_64-NEXT: ret
+    // X86_64-NEXT: .LBB0_2:
+    // X86_64-NEXT: mov     rax, qword ptr [rdi + 8]
+    // X86_64-NEXT: lea     rcx, [rax + 8]
+    // X86_64-NEXT: mov     qword ptr [rdi + 8], rcx
+    // X86_64-NEXT: movsd   xmm0, qword ptr [rax]
+    // X86_64-NEXT: ret
+
+    // X86_64-NEXT_GNUX32: mov     ecx, dword ptr [edi + 4]
+    // X86_64-NEXT_GNUX32-NEXT: cmp     ecx, 160
+    // X86_64-NEXT_GNUX32-NEXT: ja      .LBB0_2
+    // X86_64-NEXT_GNUX32-NEXT: mov     eax, dword ptr [edi + 12]
+    // X86_64-NEXT_GNUX32-NEXT: add     eax, ecx
+    // X86_64-NEXT_GNUX32-NEXT: add     ecx, 16
+    // X86_64-NEXT_GNUX32-NEXT: mov     dword ptr [edi + 4], ecx
+    // X86_64-NEXT_GNUX32-NEXT: movsd   xmm0, qword ptr [eax]
+    // X86_64-NEXT_GNUX32-NEXT: ret
+    // X86_64-NEXT_GNUX32-NEXT: .LBB0_2:
+    // X86_64-NEXT_GNUX32-NEXT: mov     eax, dword ptr [edi + 8]
+    // X86_64-NEXT_GNUX32-NEXT: lea     ecx, [rax + 8]
+    // X86_64-NEXT_GNUX32-NEXT: mov     dword ptr [edi + 8], ecx
+    // X86_64-NEXT_GNUX32-NEXT: movsd   xmm0, qword ptr [eax]
+    // X86_64-NEXT_GNUX32-NEXT: ret
+
+    // I686: mov eax, dword ptr [esp + 4]
+    // I686-NEXT: mov ecx, dword ptr [eax]
+    // I686-NEXT: lea edx, [ecx + 8]
+    // I686-NEXT: mov dword ptr [eax], edx
+    // I686-NEXT: fld qword ptr [ecx]
+    // I686-NEXT: ret
+    va_arg(ap)
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_i32(ap: &mut VaList<'_>) -> i32 {
+    // CHECK-LABEL: read_i32
+    //
+    // X86_64: mov     ecx, dword ptr [rdi]
+    // X86_64-NEXT: cmp     rcx, 40
+    // X86_64-NEXT: ja      .LBB1_2
+    // X86_64-NEXT: mov     rax, rcx
+    // X86_64-NEXT: add     rax, qword ptr [rdi + 16]
+    // X86_64-NEXT: add     ecx, 8
+    // X86_64-NEXT: mov     dword ptr [rdi], ecx
+    // X86_64-NEXT: mov     eax, dword ptr [rax]
+    // X86_64-NEXT: ret
+    // X86_64-NEXT: .LBB1_2:
+    // X86_64-NEXT: mov     rax, qword ptr [rdi + 8]
+    // X86_64-NEXT: lea     rcx, [rax + 8]
+    // X86_64-NEXT: mov     qword ptr [rdi + 8], rcx
+    // X86_64-NEXT: mov     eax, dword ptr [rax]
+    // X86_64-NEXT: ret
+
+    // X86_64-NEXT_GNUX32: mov     ecx, dword ptr [edi]
+    // X86_64-NEXT_GNUX32-NEXT: cmp     ecx, 40
+    // X86_64-NEXT_GNUX32-NEXT: ja      .LBB1_2
+    // X86_64-NEXT_GNUX32-NEXT: mov     eax, dword ptr [edi + 12]
+    // X86_64-NEXT_GNUX32-NEXT: add     eax, ecx
+    // X86_64-NEXT_GNUX32-NEXT: add     ecx, 8
+    // X86_64-NEXT_GNUX32-NEXT: mov     dword ptr [edi], ecx
+    // X86_64-NEXT_GNUX32-NEXT: mov     eax, dword ptr [eax]
+    // X86_64-NEXT_GNUX32-NEXT: ret
+    // X86_64-NEXT_GNUX32-NEXT: .LBB1_2:
+    // X86_64-NEXT_GNUX32-NEXT: mov     eax, dword ptr [edi + 8]
+    // X86_64-NEXT_GNUX32-NEXT: lea     ecx, [rax + 8]
+    // X86_64-NEXT_GNUX32-NEXT: mov     dword ptr [edi + 8], ecx
+    // X86_64-NEXT_GNUX32-NEXT: mov     eax, dword ptr [eax]
+    // X86_64-NEXT_GNUX32-NEXT: ret
+
+    // I686: mov eax, dword ptr [esp + 4]
+    // I686-NEXT: mov ecx, dword ptr [eax]
+    // I686-NEXT: lea edx, [ecx + 4]
+    // I686-NEXT: mov dword ptr [eax], edx
+    // I686-NEXT: mov eax, dword ptr [ecx]
+    // I686-NEXT: ret
+    va_arg(ap)
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_i64(ap: &mut VaList<'_>) -> i64 {
+    // CHECK-LABEL: read_i64
+
+    // X86_64: mov     ecx, dword ptr [rdi]
+    // X86_64-NEXT: cmp     rcx, 40
+    // X86_64-NEXT: ja      .LBB2_2
+    // X86_64-NEXT: mov     rax, rcx
+    // X86_64-NEXT: add     rax, qword ptr [rdi + 16]
+    // X86_64-NEXT: add     ecx, 8
+    // X86_64-NEXT: mov     dword ptr [rdi], ecx
+    // X86_64-NEXT: mov     rax, qword ptr [rax]
+    // X86_64-NEXT: ret
+    // X86_64-NEXT: .LBB2_2:
+    // X86_64-NEXT: mov     rax, qword ptr [rdi + 8]
+    // X86_64-NEXT: lea     rcx, [rax + 8]
+    // X86_64-NEXT: mov     qword ptr [rdi + 8], rcx
+    // X86_64-NEXT: mov     rax, qword ptr [rax]
+    // X86_64-NEXT: ret
+
+    // X86_64-NEXT_GNUX32: mov     ecx, dword ptr [edi]
+    // X86_64-NEXT_GNUX32-NEXT: cmp     ecx, 40
+    // X86_64-NEXT_GNUX32-NEXT: ja      .LBB2_2
+    // X86_64-NEXT_GNUX32-NEXT: mov     eax, dword ptr [edi + 12]
+    // X86_64-NEXT_GNUX32-NEXT: add     eax, ecx
+    // X86_64-NEXT_GNUX32-NEXT: add     ecx, 8
+    // X86_64-NEXT_GNUX32-NEXT: mov     dword ptr [edi], ecx
+    // X86_64-NEXT_GNUX32-NEXT: mov     rax, qword ptr [eax]
+    // X86_64-NEXT_GNUX32-NEXT: ret
+    // X86_64-NEXT_GNUX32-NEXT: .LBB2_2:
+    // X86_64-NEXT_GNUX32-NEXT: mov     eax, dword ptr [edi + 8]
+    // X86_64-NEXT_GNUX32-NEXT: lea     ecx, [rax + 8]
+    // X86_64-NEXT_GNUX32-NEXT: mov     dword ptr [edi + 8], ecx
+    // X86_64-NEXT_GNUX32-NEXT: mov     rax, qword ptr [eax]
+    // X86_64-NEXT_GNUX32-NEXT: ret
+
+    // I686: mov eax, dword ptr [esp + 4]
+    // I686-NEXT: mov ecx, dword ptr [eax]
+    // I686-NEXT: lea edx, [ecx + 8]
+    // I686-NEXT: mov dword ptr [eax], edx
+    // I686-NEXT: mov eax, dword ptr [ecx]
+    // I686-NEXT: mov edx, dword ptr [ecx + 4]
+    // I686-NEXT: ret
+    va_arg(ap)
+}
+
+#[unsafe(no_mangle)]
+#[cfg(target_pointer_width = "64")]
+unsafe extern "C" fn read_i128(ap: &mut VaList<'_>) -> i128 {
+    // X86_64-LABEL: read_i128
+    //
+    // X86_64: mov ecx, dword ptr [rdi]
+    // X86_64-NEXT: cmp rcx, 32
+    // X86_64-NEXT: ja  .LBB3_2
+    // X86_64-NEXT: mov rdx, qword ptr [rdi + 16]
+    // X86_64-NEXT: mov rax, qword ptr [rdx + rcx]
+    // X86_64-NEXT: mov rdx, qword ptr [rdx + rcx + 8]
+    // X86_64-NEXT: add ecx, 16
+    // X86_64-NEXT: mov dword ptr [rdi], ecx
+    // X86_64-NEXT: ret
+    // X86_64-NEXT: .LBB3_2:
+    // X86_64-NEXT: mov     rcx, qword ptr [rdi + 8]
+    // X86_64-NEXT: add     rcx, 15
+    // X86_64-NEXT: and     rcx, -16
+    // X86_64-NEXT: lea     rax, [rcx + 16]
+    // X86_64-NEXT: mov     qword ptr [rdi + 8], rax
+    // X86_64-NEXT: mov     rax, qword ptr [rcx]
+    // X86_64-NEXT: mov     rdx, qword ptr [rcx + 8]
+    // X86_64-NEXT: ret
+
+    // X86_64-NEXT_GNUX32: mov     ecx, dword ptr [edi]
+    // X86_64-NEXT_GNUX32-NEXT: cmp     ecx, 32
+    // X86_64-NEXT_GNUX32-NEXT: ja      .LBB3_2
+    // X86_64-NEXT_GNUX32-NEXT: mov     edx, dword ptr [edi + 12]
+    // X86_64-NEXT_GNUX32-NEXT: mov     rax, qword ptr [edx + ecx]
+    // X86_64-NEXT_GNUX32-NEXT: mov     rdx, qword ptr [edx + ecx + 8]
+    // X86_64-NEXT_GNUX32-NEXT: add     ecx, 16
+    // X86_64-NEXT_GNUX32-NEXT: mov     dword ptr [edi], ecx
+    // X86_64-NEXT_GNUX32-NEXT: ret
+    // X86_64-NEXT_GNUX32-NEXT: .LBB3_2:
+    // X86_64-NEXT_GNUX32-NEXT: mov     ecx, dword ptr [edi + 8]
+    // X86_64-NEXT_GNUX32-NEXT: add     ecx, 15
+    // X86_64-NEXT_GNUX32-NEXT: and     ecx, -16
+    // X86_64-NEXT_GNUX32-NEXT: lea     eax, [rcx + 16]
+    // X86_64-NEXT_GNUX32-NEXT: mov     dword ptr [edi + 8], eax
+    // X86_64-NEXT_GNUX32-NEXT: mov     rax, qword ptr [ecx]
+    // X86_64-NEXT_GNUX32-NEXT: mov     rdx, qword ptr [ecx + 8]
+    // X86_64-NEXT_GNUX32-NEXT: ret
+
+    va_arg(ap)
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_ptr(ap: &mut VaList<'_>) -> *const u8 {
+    // X86_64: read_ptr = read_i64
+    // X86_64_GNUX32: read_ptr = read_i32
+    // I686: read_ptr = read_i32
+    va_arg(ap)
+}
diff --git a/tests/assembly-llvm/c-variadic/x86_64-windows.rs b/tests/assembly-llvm/c-variadic/x86_64-windows.rs
new file mode 100644
index 0000000000000..fa40699af80b4
--- /dev/null
+++ b/tests/assembly-llvm/c-variadic/x86_64-windows.rs
@@ -0,0 +1,100 @@
+//@ add-minicore
+//@ assembly-output: emit-asm
+//
+//@ revisions: WINDOWS_GNU WINDOWS_MSVC
+//@ [WINDOWS_GNU] compile-flags: -Copt-level=3 -Cllvm-args=-x86-asm-syntax=intel
+//@ [WINDOWS_GNU] compile-flags: --target x86_64-pc-windows-gnu
+//@ [WINDOWS_GNU] needs-llvm-components: x86
+//@ [WINDOWS_MSVC] compile-flags: -Copt-level=3 -Cllvm-args=-x86-asm-syntax=intel
+//@ [WINDOWS_MSVC] compile-flags: --target x86_64-pc-windows-msvc
+//@ [WINDOWS_MSVC] needs-llvm-components: x86
+#![feature(c_variadic, no_core, lang_items, intrinsics, rustc_attrs)]
+#![no_core]
+#![crate_type = "lib"]
+
+// Check that the assembly that rustc generates matches what clang emits for
+//
+// ```c
+// T function(va_list ap) {
+//     return va_arg(ap, T);
+// }
+// ```
+
+extern crate minicore;
+use minicore::*;
+
+#[lang = "va_arg_safe"]
+pub unsafe trait VaArgSafe {}
+
+unsafe impl VaArgSafe for i32 {}
+unsafe impl VaArgSafe for i64 {}
+unsafe impl VaArgSafe for i128 {}
+unsafe impl VaArgSafe for f64 {}
+unsafe impl<T> VaArgSafe for *const T {}
+
+#[repr(transparent)]
+struct VaListInner {
+    ptr: *const c_void,
+}
+
+#[repr(transparent)]
+#[lang = "va_list"]
+pub struct VaList<'a> {
+    inner: VaListInner,
+    _marker: PhantomData<&'a mut ()>,
+}
+
+#[rustc_intrinsic]
+#[rustc_nounwind]
+pub const unsafe fn va_arg<T: VaArgSafe>(ap: &mut VaList<'_>) -> T;
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_f64(ap: &mut VaList<'_>) -> f64 {
+    // CHECK-LABEL: read_f64:
+    // CHECK: mov rax, qword ptr [rcx]
+    // CHECK-NEXT: lea rdx, [rax + 8]
+    // CHECK-NEXT: mov qword ptr [rcx], rdx
+    // CHECK-NEXT: movsd xmm0, qword ptr [rax]
+    // CHECK-NEXT: ret
+    va_arg(ap)
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_i32(ap: &mut VaList<'_>) -> i32 {
+    // CHECK-LABEL: read_i32:
+    // CHECK: mov rax, qword ptr [rcx]
+    // CHECK-NEXT: lea rdx, [rax + 8]
+    // CHECK-NEXT: mov qword ptr [rcx], rdx
+    // CHECK-NEXT: mov eax, dword ptr [rax]
+    // CHECK-NEXT: ret
+    va_arg(ap)
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_i64(ap: &mut VaList<'_>) -> i64 {
+    // CHECK-LABEL: read_i64:
+    // CHECK: mov rax, qword ptr [rcx]
+    // CHECK-NEXT: lea rdx, [rax + 8]
+    // CHECK-NEXT: mov qword ptr [rcx], rdx
+    // CHECK-NEXT: mov rax, qword ptr [rax]
+    // CHECK-NEXT: ret
+    va_arg(ap)
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_i128(ap: &mut VaList<'_>) -> i128 {
+    // CHECK-LABEL: read_i128:
+    // CHECK: mov rax, qword ptr [rcx]
+    // CHECK-NEXT: lea rdx, [rax + 8]
+    // CHECK-NEXT: mov qword ptr [rcx], rdx
+    // CHECK-NEXT: mov rax, qword ptr [rax]
+    // CHECK-NEXT: movups xmm0, xmmword ptr [rax]
+    // CHECK-NEXT: ret
+    va_arg(ap)
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_ptr(ap: &mut VaList<'_>) -> *const u8 {
+    // CHECK: read_ptr = read_i64
+    va_arg(ap)
+}
diff --git a/tests/codegen-llvm/array-cmp.rs b/tests/codegen-llvm/array-cmp.rs
index 0106b9c15c11b..5b0a802f4097e 100644
--- a/tests/codegen-llvm/array-cmp.rs
+++ b/tests/codegen-llvm/array-cmp.rs
@@ -2,6 +2,9 @@
 
 //@ compile-flags: -C opt-level=2
 //@ needs-deterministic-layouts (checks depend on tuple layout)
+//@ revisions: LLVM22 LLVM23
+//@ [LLVM22] max-llvm-major-version: 22
+//@ [LLVM23] min-llvm-version: 23
 
 #![crate_type = "lib"]
 
@@ -66,7 +69,8 @@ pub fn array_of_tuple_le(a: &[(i16, u16); 2], b: &[(i16, u16); 2]) -> bool {
     // CHECK-NEXT: br i1 %[[EQ01]], label %{{.+}}, label %[[EXIT_U]]
 
     // CHECK: [[DONE]]:
-    // CHECK: %[[RET:.+]] = phi i1 [ %{{.+}}, %[[EXIT_S]] ], [ %{{.+}}, %[[EXIT_U]] ], [ true, %[[L11]] ]
+    // LLVM22: %[[RET:.+]] = phi i1 [ %{{.+}}, %[[EXIT_S]] ], [ %{{.+}}, %[[EXIT_U]] ], [ true, %[[L11]] ]
+    // LLVM23: %[[RET:.+]] = phi i1 [ %{{.+}}, %[[EXIT_U]] ], [ %{{.+}}, %[[EXIT_S]] ], [ true, %[[L11]] ]
     // CHECK: ret i1 %[[RET]]
 
     a <= b
diff --git a/tests/codegen-llvm/bpf-allows-unaligned.rs b/tests/codegen-llvm/bpf-allows-unaligned.rs
index c7a70d5b2e502..7e95a56d984c9 100644
--- a/tests/codegen-llvm/bpf-allows-unaligned.rs
+++ b/tests/codegen-llvm/bpf-allows-unaligned.rs
@@ -5,7 +5,7 @@
 
 #[no_mangle]
 #[target_feature(enable = "allows-misaligned-mem-access")]
-// CHECK: define noundef zeroext i8 @foo(i8 noundef returned %arg) unnamed_addr #0 {
+// CHECK: define noundef zeroext i8 @foo(i8 noundef returned %arg) unnamed_addr #0
 pub unsafe fn foo(arg: u8) -> u8 {
     arg
 }
diff --git a/tests/codegen-llvm/branch-protection.rs b/tests/codegen-llvm/branch-protection.rs
index ed1cb2cd137ea..11847c256d6ba 100644
--- a/tests/codegen-llvm/branch-protection.rs
+++ b/tests/codegen-llvm/branch-protection.rs
@@ -22,7 +22,7 @@ extern crate minicore;
 use minicore::*;
 
 // A basic test function.
-// CHECK: @test(){{.*}} [[ATTR:#[0-9]+]] {
+// CHECK: @test(){{.*}} [[ATTR:#[0-9]+]]
 #[no_mangle]
 pub fn test() {}
 
diff --git a/tests/codegen-llvm/enum/enum-match.rs b/tests/codegen-llvm/enum/enum-match.rs
index 6d8b97328f8e0..a0cba452e123c 100644
--- a/tests/codegen-llvm/enum/enum-match.rs
+++ b/tests/codegen-llvm/enum/enum-match.rs
@@ -1,5 +1,8 @@
 //@ compile-flags: -Copt-level=1
 //@ only-64bit
+//@ revisions: LLVM22 LLVM23
+//@ [LLVM22] max-llvm-major-version: 22
+//@ [LLVM23] min-llvm-version: 23
 
 #![crate_type = "lib"]
 #![feature(core_intrinsics)]
@@ -18,8 +21,9 @@ pub enum Enum0 {
 // CHECK-LABEL: define{{( dso_local)?}} noundef{{( range\(i8 [0-9]+, [0-9]+\))?}} i8 @match0(i8{{.+}}%0)
 // CHECK-NEXT: start:
 // CHECK-NEXT: %[[IS_B:.+]] = icmp eq i8 %0, 2
-// CHECK-NEXT: %[[TRUNC:.+]] = and i8 %0, 1
-// CHECK-NEXT: %[[R:.+]] = select i1 %[[IS_B]], i8 13, i8 %[[TRUNC]]
+// LLVM22-NEXT: %[[TRUNC:.+]] = and i8 %0, 1
+// LLVM22-NEXT: %[[R:.+]] = select i1 %[[IS_B]], i8 13, i8 %[[TRUNC]]
+// LLVM23-NEXT: %[[R:.+]] = select i1 %[[IS_B]], i8 13, i8 %0
 // CHECK-NEXT: ret i8 %[[R]]
 #[no_mangle]
 pub fn match0(e: Enum0) -> u8 {
diff --git a/tests/codegen-llvm/frame-pointer-cli-control.rs b/tests/codegen-llvm/frame-pointer-cli-control.rs
index 911a5f03cbcda..79cdfc70f1ad7 100644
--- a/tests/codegen-llvm/frame-pointer-cli-control.rs
+++ b/tests/codegen-llvm/frame-pointer-cli-control.rs
@@ -45,7 +45,7 @@ Specific cases where platforms or tools rely on frame pointers for sound or corr
 
 extern crate minicore;
 
-// CHECK: i32 @peach{{.*}}[[PEACH_ATTRS:\#[0-9]+]] {
+// CHECK: i32 @peach{{.*}}[[PEACH_ATTRS:\#[0-9]+]]
 #[no_mangle]
 pub fn peach(x: u32) -> u32 {
     x
diff --git a/tests/codegen-llvm/frame-pointer.rs b/tests/codegen-llvm/frame-pointer.rs
index 1d0dd762826b2..a52d95a23862d 100644
--- a/tests/codegen-llvm/frame-pointer.rs
+++ b/tests/codegen-llvm/frame-pointer.rs
@@ -18,7 +18,7 @@
 extern crate minicore;
 use minicore::*;
 
-// CHECK: define i32 @peach{{.*}}[[PEACH_ATTRS:\#[0-9]+]] {
+// CHECK: define i32 @peach{{.*}}[[PEACH_ATTRS:\#[0-9]+]]
 #[no_mangle]
 pub fn peach(x: u32) -> u32 {
     x
diff --git a/tests/codegen-llvm/gpu-convergent.rs b/tests/codegen-llvm/gpu-convergent.rs
index bb9271ab69996..376d65a3d4a25 100644
--- a/tests/codegen-llvm/gpu-convergent.rs
+++ b/tests/codegen-llvm/gpu-convergent.rs
@@ -17,7 +17,7 @@ extern "C" {
     fn ext();
 }
 
-// CHECK: define {{.*}}_kernel void @fun(i32{{.*}}) unnamed_addr #[[ATTR:[0-9]+]] {
+// CHECK: define {{.*}}_kernel void @fun(i32{{.*}}) unnamed_addr #[[ATTR:[0-9]+]]
 // CHECK: declare void @ext() unnamed_addr #[[ATTR]]
 // CHECK: attributes #[[ATTR]] = {{.*}} convergent
 #[no_mangle]
diff --git a/tests/codegen-llvm/instrument-coverage/testprog.rs b/tests/codegen-llvm/instrument-coverage/testprog.rs
index ef61ede6de8ee..67c49c438f9f7 100644
--- a/tests/codegen-llvm/instrument-coverage/testprog.rs
+++ b/tests/codegen-llvm/instrument-coverage/testprog.rs
@@ -101,7 +101,7 @@ fn main() {
 // CHECK-SAME:   @__llvm_prf_nm
 // CHECK-SAME:   section "llvm.metadata"
 
-// CHECK:        define internal { {{.*}} } @_R{{[a-zA-Z0-9_]+}}testprog14will_be_called() unnamed_addr #{{[0-9]+}} {
+// CHECK:        define internal { {{.*}} } @_R{{[a-zA-Z0-9_]+}}testprog14will_be_called() unnamed_addr #{{[0-9]+}}
 // CHECK-NEXT:   start:
 // CHECK-NOT:    define internal
 // CHECK:        atomicrmw add ptr
@@ -109,7 +109,7 @@ fn main() {
 
 // CHECK:        declare void @llvm.instrprof.increment(ptr, i64, i32, i32) #[[LLVM_INSTRPROF_INCREMENT_ATTR:[0-9]+]]
 
-// WIN:          define linkonce_odr hidden i32 @__llvm_profile_runtime_user() #[[LLVM_PROFILE_RUNTIME_USER_ATTR:[0-9]+]] comdat {{.*}}{
+// WIN:          define linkonce_odr hidden i32 @__llvm_profile_runtime_user() #[[LLVM_PROFILE_RUNTIME_USER_ATTR:[0-9]+]] comdat {{.*}}
 // WIN-NEXT:     %1 = load i32, ptr @__llvm_profile_runtime
 // WIN-NEXT:     ret i32 %1
 // WIN-NEXT:     }
diff --git a/tests/codegen-llvm/intrinsics/volatile.rs b/tests/codegen-llvm/intrinsics/volatile.rs
index 4ba4c5edd2df6..42ffd196f3d86 100644
--- a/tests/codegen-llvm/intrinsics/volatile.rs
+++ b/tests/codegen-llvm/intrinsics/volatile.rs
@@ -162,7 +162,28 @@ pub unsafe fn unaligned_volatile_load_fat(a: *const UninitFatPointer) -> UninitF
 
 // CHECK-LABEL: @unaligned_volatile_store
 #[no_mangle]
-pub unsafe fn unaligned_volatile_store(a: *mut u8, b: u8) {
-    // CHECK: store volatile
+pub unsafe fn unaligned_volatile_store(a: *mut u16, b: u16) {
+    // CHECK: store volatile i16 %b, ptr %a, align 1
+    intrinsics::unaligned_volatile_store(a, b)
+}
+
+// CHECK-LABEL: @unaligned_volatile_store_pair
+#[no_mangle]
+pub unsafe fn unaligned_volatile_store_pair(a: *mut (u16, u16), b: (u16, u16)) {
+    // CHECK: store volatile i16 %b.0, ptr %a, align 1
+    // CHECK: [[TEMP:%.+]] = getelementptr inbounds i8, ptr %a, {{i16|i32|i64}} 2
+    // CHECK: store volatile i16 %b.1, ptr [[TEMP]], align 1
+    intrinsics::unaligned_volatile_store(a, b)
+}
+
+// CHECK-LABEL: @unaligned_volatile_store_array
+#[no_mangle]
+pub unsafe fn unaligned_volatile_store_array(a: *mut [u16; 7], b: [u16; 7]) {
+    // Note that only the store side is unaligned; the load from the argument is aligned.
+
+    // CHECK-NOT: memcpy
+    // CHECK: call void @llvm.memcpy{{.+}}(ptr align 1 %a, ptr align 2 %b, {{i16|i32|i64}} 14, i1 true)
+    // CHECK-NOT: memcpy
+    // CHECK: ret void
     intrinsics::unaligned_volatile_store(a, b)
 }
diff --git a/tests/codegen-llvm/link_section.rs b/tests/codegen-llvm/link_section.rs
index f196ea86c447d..61bde683c0a41 100644
--- a/tests/codegen-llvm/link_section.rs
+++ b/tests/codegen-llvm/link_section.rs
@@ -29,7 +29,7 @@ pub static VAR2: E = E::A(666);
 #[link_section = "__TEST,three"]
 pub static VAR3: E = E::B(1.);
 
-// CHECK: define {{(dso_local )?}}void @fn1() {{.*}} section "__TEST,four" {
+// CHECK: define {{(dso_local )?}}void @fn1() {{.*}} section "__TEST,four"
 #[no_mangle]
 #[link_section = "__TEST,four"]
 pub fn fn1() {}
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-normalized-generalized.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-normalized-generalized.rs
index 7639ce7b10448..5b1aa97ab3338 100644
--- a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-normalized-generalized.rs
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-normalized-generalized.rs
@@ -7,21 +7,21 @@
 
 pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
     // CHECK-LABEL: define{{.*}}foo
-    // CHECK-SAME:  {{.*}}![[TYPE1:[0-9]+]]
+    // CHECK-SAME:  {{.*}}!type ![[TYPE1:[0-9]+]]
     // CHECK:       call i1 @llvm.type.test(ptr {{%f|%0}}, metadata !"_ZTSFu3i32S_E.normalized.generalized")
     f(arg)
 }
 
 pub fn bar(f: fn(i32, i32) -> i32, arg1: i32, arg2: i32) -> i32 {
     // CHECK-LABEL: define{{.*}}bar
-    // CHECK-SAME:  {{.*}}![[TYPE2:[0-9]+]]
+    // CHECK-SAME:  {{.*}}!type ![[TYPE2:[0-9]+]]
     // CHECK:       call i1 @llvm.type.test(ptr {{%f|%0}}, metadata !"_ZTSFu3i32S_S_E.normalized.generalized")
     f(arg1, arg2)
 }
 
 pub fn baz(f: fn(i32, i32, i32) -> i32, arg1: i32, arg2: i32, arg3: i32) -> i32 {
     // CHECK-LABEL: define{{.*}}baz
-    // CHECK-SAME:  {{.*}}![[TYPE3:[0-9]+]]
+    // CHECK-SAME:  {{.*}}!type ![[TYPE3:[0-9]+]]
     // CHECK:       call i1 @llvm.type.test(ptr {{%f|%0}}, metadata !"_ZTSFu3i32S_S_S_E.normalized.generalized")
     f(arg1, arg2, arg3)
 }
diff --git a/tests/codegen-llvm/some-non-zero-from-atomic-optimization.rs b/tests/codegen-llvm/some-non-zero-from-atomic-optimization.rs
index 35317b0dd39cc..3df2d569f9a40 100644
--- a/tests/codegen-llvm/some-non-zero-from-atomic-optimization.rs
+++ b/tests/codegen-llvm/some-non-zero-from-atomic-optimization.rs
@@ -72,7 +72,7 @@ pub unsafe fn some_non_zero_from_atomic_get() -> Option<NonZeroUsize> {
 ///
 /// The way we check that the LLVM IR is correct is by making sure that neither
 /// `panic` nor `unreachable` is part of the LLVM IR:
-// CHECK-LABEL: define {{.*}} i64 @some_non_zero_from_atomic_get2() {{.*}} {
+// CHECK-LABEL: define {{.*}} i64 @some_non_zero_from_atomic_get2() {{.*}}
 // CHECK-NOT: panic
 // CHECK-NOT: unreachable
 #[no_mangle]
diff --git a/tests/codegen-llvm/target-feature-negative-implication.rs b/tests/codegen-llvm/target-feature-negative-implication.rs
index a9cdca4283991..376599738e526 100644
--- a/tests/codegen-llvm/target-feature-negative-implication.rs
+++ b/tests/codegen-llvm/target-feature-negative-implication.rs
@@ -13,7 +13,7 @@ use minicore::*;
 #[no_mangle]
 pub unsafe fn banana() {
     // CHECK-LABEL: @banana()
-    // CHECK-SAME: [[BANANAATTRS:#[0-9]+]] {
+    // CHECK-SAME: [[BANANAATTRS:#[0-9]+]]
 }
 
 // CHECK: attributes [[BANANAATTRS]]
diff --git a/tests/codegen-llvm/target-feature-overrides.rs b/tests/codegen-llvm/target-feature-overrides.rs
index 2adc8ee6f53bc..3bf05c7977ebf 100644
--- a/tests/codegen-llvm/target-feature-overrides.rs
+++ b/tests/codegen-llvm/target-feature-overrides.rs
@@ -23,7 +23,7 @@ extern "C" {
 #[no_mangle]
 pub unsafe fn apple() -> u32 {
     // CHECK-LABEL: @apple()
-    // CHECK-SAME: [[APPLEATTRS:#[0-9]+]] {
+    // CHECK-SAME: [[APPLEATTRS:#[0-9]+]]
     // CHECK: {{.*}}call{{.*}}@peach
     peach()
 }
@@ -32,7 +32,7 @@ pub unsafe fn apple() -> u32 {
 #[no_mangle]
 pub unsafe fn banana() -> u32 {
     // CHECK-LABEL: @banana()
-    // CHECK-SAME: [[BANANAATTRS:#[0-9]+]] {
+    // CHECK-SAME: [[BANANAATTRS:#[0-9]+]]
     // COMPAT: {{.*}}call{{.*}}@peach
     // INCOMPAT: {{.*}}call{{.*}}@apple
     apple() // Compatible for inline in COMPAT revision and can't be inlined in INCOMPAT
diff --git a/tests/codegen-llvm/unwind-abis/aapcs-unwind-abi.rs b/tests/codegen-llvm/unwind-abis/aapcs-unwind-abi.rs
index ecace722e0dbe..279780e3a7aeb 100644
--- a/tests/codegen-llvm/unwind-abis/aapcs-unwind-abi.rs
+++ b/tests/codegen-llvm/unwind-abis/aapcs-unwind-abi.rs
@@ -16,11 +16,11 @@ pub trait Sized: MetaSized {}
 // `aapcs-unwind` extern functions. `aapcs-unwind` functions MUST NOT have this attribute. We
 // disable optimizations above to prevent LLVM from inferring the attribute.
 
-// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0 {
+// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0
 #[no_mangle]
 pub extern "aapcs" fn rust_item_that_cannot_unwind() {}
 
-// CHECK: @rust_item_that_can_unwind() unnamed_addr #1 {
+// CHECK: @rust_item_that_can_unwind() unnamed_addr #1
 #[no_mangle]
 pub extern "aapcs-unwind" fn rust_item_that_can_unwind() {}
 
diff --git a/tests/codegen-llvm/unwind-abis/c-unwind-abi.rs b/tests/codegen-llvm/unwind-abis/c-unwind-abi.rs
index 46c08b5fc4ff4..1b3312839e3e8 100644
--- a/tests/codegen-llvm/unwind-abis/c-unwind-abi.rs
+++ b/tests/codegen-llvm/unwind-abis/c-unwind-abi.rs
@@ -7,11 +7,11 @@
 
 #![crate_type = "lib"]
 
-// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0 {
+// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0
 #[no_mangle]
 pub extern "C" fn rust_item_that_cannot_unwind() {}
 
-// CHECK: @rust_item_that_can_unwind() unnamed_addr #1 {
+// CHECK: @rust_item_that_can_unwind() unnamed_addr #1
 #[no_mangle]
 pub extern "C-unwind" fn rust_item_that_can_unwind() {}
 
diff --git a/tests/codegen-llvm/unwind-abis/cdecl-unwind-abi.rs b/tests/codegen-llvm/unwind-abis/cdecl-unwind-abi.rs
index 8e643d6ce4947..6f4eafb353ccb 100644
--- a/tests/codegen-llvm/unwind-abis/cdecl-unwind-abi.rs
+++ b/tests/codegen-llvm/unwind-abis/cdecl-unwind-abi.rs
@@ -7,11 +7,11 @@
 
 #![crate_type = "lib"]
 
-// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0 {
+// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0
 #[no_mangle]
 pub extern "cdecl" fn rust_item_that_cannot_unwind() {}
 
-// CHECK: @rust_item_that_can_unwind() unnamed_addr #1 {
+// CHECK: @rust_item_that_can_unwind() unnamed_addr #1
 #[no_mangle]
 pub extern "cdecl-unwind" fn rust_item_that_can_unwind() {}
 
diff --git a/tests/codegen-llvm/unwind-abis/fastcall-unwind-abi.rs b/tests/codegen-llvm/unwind-abis/fastcall-unwind-abi.rs
index 7df46813ed1dd..51c6fd15b9c5c 100644
--- a/tests/codegen-llvm/unwind-abis/fastcall-unwind-abi.rs
+++ b/tests/codegen-llvm/unwind-abis/fastcall-unwind-abi.rs
@@ -16,11 +16,11 @@ pub trait Sized: MetaSized {}
 // `fastcall-unwind` extern functions. `fastcall-unwind` functions MUST NOT have this attribute. We
 // disable optimizations above to prevent LLVM from inferring the attribute.
 
-// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0 {
+// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0
 #[no_mangle]
 pub extern "fastcall" fn rust_item_that_cannot_unwind() {}
 
-// CHECK: @rust_item_that_can_unwind() unnamed_addr #1 {
+// CHECK: @rust_item_that_can_unwind() unnamed_addr #1
 #[no_mangle]
 pub extern "fastcall-unwind" fn rust_item_that_can_unwind() {}
 
diff --git a/tests/codegen-llvm/unwind-abis/stdcall-unwind-abi.rs b/tests/codegen-llvm/unwind-abis/stdcall-unwind-abi.rs
index cc06ee125495a..b5fcea52b4d61 100644
--- a/tests/codegen-llvm/unwind-abis/stdcall-unwind-abi.rs
+++ b/tests/codegen-llvm/unwind-abis/stdcall-unwind-abi.rs
@@ -16,11 +16,11 @@ pub trait Sized: MetaSized {}
 // extern functions. `stdcall-unwind` functions MUST NOT have this attribute. We disable
 // optimizations above to prevent LLVM from inferring the attribute.
 
-// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0 {
+// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0
 #[no_mangle]
 pub extern "stdcall" fn rust_item_that_cannot_unwind() {}
 
-// CHECK: @rust_item_that_can_unwind() unnamed_addr #1 {
+// CHECK: @rust_item_that_can_unwind() unnamed_addr #1
 #[no_mangle]
 pub extern "stdcall-unwind" fn rust_item_that_can_unwind() {}
 
diff --git a/tests/codegen-llvm/unwind-abis/system-unwind-abi.rs b/tests/codegen-llvm/unwind-abis/system-unwind-abi.rs
index 5f9102483464b..15fce95fe285b 100644
--- a/tests/codegen-llvm/unwind-abis/system-unwind-abi.rs
+++ b/tests/codegen-llvm/unwind-abis/system-unwind-abi.rs
@@ -7,11 +7,11 @@
 
 #![crate_type = "lib"]
 
-// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0 {
+// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0
 #[no_mangle]
 pub extern "system" fn rust_item_that_cannot_unwind() {}
 
-// CHECK: @rust_item_that_can_unwind() unnamed_addr #1 {
+// CHECK: @rust_item_that_can_unwind() unnamed_addr #1
 #[no_mangle]
 pub extern "system-unwind" fn rust_item_that_can_unwind() {}
 
diff --git a/tests/codegen-llvm/unwind-abis/sysv64-unwind-abi.rs b/tests/codegen-llvm/unwind-abis/sysv64-unwind-abi.rs
index 69bfaf80b4be6..1293e7c0a5f82 100644
--- a/tests/codegen-llvm/unwind-abis/sysv64-unwind-abi.rs
+++ b/tests/codegen-llvm/unwind-abis/sysv64-unwind-abi.rs
@@ -16,11 +16,11 @@ pub trait Sized: MetaSized {}
 // `sysv64-unwind` extern functions. `sysv64-unwind` functions MUST NOT have this attribute. We
 // disable optimizations above to prevent LLVM from inferring the attribute.
 
-// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0 {
+// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0
 #[no_mangle]
 pub extern "sysv64" fn rust_item_that_cannot_unwind() {}
 
-// CHECK: @rust_item_that_can_unwind() unnamed_addr #1 {
+// CHECK: @rust_item_that_can_unwind() unnamed_addr #1
 #[no_mangle]
 pub extern "sysv64-unwind" fn rust_item_that_can_unwind() {}
 
diff --git a/tests/codegen-llvm/unwind-abis/thiscall-unwind-abi.rs b/tests/codegen-llvm/unwind-abis/thiscall-unwind-abi.rs
index 05f6b8b70e171..a9b6c34ee58e2 100644
--- a/tests/codegen-llvm/unwind-abis/thiscall-unwind-abi.rs
+++ b/tests/codegen-llvm/unwind-abis/thiscall-unwind-abi.rs
@@ -16,11 +16,11 @@ pub trait Sized: MetaSized {}
 // `thiscall-unwind` extern functions. `thiscall-unwind` functions MUST NOT have this attribute. We
 // disable optimizations above to prevent LLVM from inferring the attribute.
 
-// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0 {
+// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0
 #[no_mangle]
 pub extern "thiscall" fn rust_item_that_cannot_unwind() {}
 
-// CHECK: @rust_item_that_can_unwind() unnamed_addr #1 {
+// CHECK: @rust_item_that_can_unwind() unnamed_addr #1
 #[no_mangle]
 pub extern "thiscall-unwind" fn rust_item_that_can_unwind() {}
 
diff --git a/tests/codegen-llvm/unwind-abis/vectorcall-unwind-abi.rs b/tests/codegen-llvm/unwind-abis/vectorcall-unwind-abi.rs
index d001a16b32a1c..8cedb55ae1d28 100644
--- a/tests/codegen-llvm/unwind-abis/vectorcall-unwind-abi.rs
+++ b/tests/codegen-llvm/unwind-abis/vectorcall-unwind-abi.rs
@@ -16,11 +16,11 @@ pub trait Sized: MetaSized {}
 // `vectorcall-unwind` extern functions. `vectorcall-unwind` functions MUST NOT have this attribute.
 // We disable optimizations above to prevent LLVM from inferring the attribute.
 
-// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0 {
+// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0
 #[no_mangle]
 pub extern "vectorcall" fn rust_item_that_cannot_unwind() {}
 
-// CHECK: @rust_item_that_can_unwind() unnamed_addr #1 {
+// CHECK: @rust_item_that_can_unwind() unnamed_addr #1
 #[no_mangle]
 pub extern "vectorcall-unwind" fn rust_item_that_can_unwind() {}
 
diff --git a/tests/codegen-llvm/unwind-abis/win64-unwind-abi.rs b/tests/codegen-llvm/unwind-abis/win64-unwind-abi.rs
index 257f00b54e4d8..2a3ad330406e6 100644
--- a/tests/codegen-llvm/unwind-abis/win64-unwind-abi.rs
+++ b/tests/codegen-llvm/unwind-abis/win64-unwind-abi.rs
@@ -16,11 +16,11 @@ pub trait Sized: MetaSized {}
 // `win64-unwind` extern functions. `win64-unwind` functions MUST NOT have this attribute. We
 // disable optimizations above to prevent LLVM from inferring the attribute.
 
-// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0 {
+// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0
 #[no_mangle]
 pub extern "win64" fn rust_item_that_cannot_unwind() {}
 
-// CHECK: @rust_item_that_can_unwind() unnamed_addr #1 {
+// CHECK: @rust_item_that_can_unwind() unnamed_addr #1
 #[no_mangle]
 pub extern "win64-unwind" fn rust_item_that_can_unwind() {}
 
diff --git a/tests/pretty/direct-const-arg.pp b/tests/pretty/direct-const-arg.pp
new file mode 100644
index 0000000000000..a76ed9a480e71
--- /dev/null
+++ b/tests/pretty/direct-const-arg.pp
@@ -0,0 +1,15 @@
+#![feature(prelude_import)]
+#![no_std]
+//@ pretty-mode:expanded
+//@ pp-exact:direct-const-arg.pp
+#![feature(min_generic_const_args)]
+extern crate std;
+#[prelude_import]
+use ::std::prelude::rust_2015::*;
+
+fn f<const N : usize>() {}
+
+fn main() {
+    f::<core::direct_const_arg! (2)>();
+    f::<{ core::direct_const_arg! (2) }>();
+}
diff --git a/tests/pretty/direct-const-arg.rs b/tests/pretty/direct-const-arg.rs
new file mode 100644
index 0000000000000..330c1cac024de
--- /dev/null
+++ b/tests/pretty/direct-const-arg.rs
@@ -0,0 +1,10 @@
+//@ pretty-mode:expanded
+//@ pp-exact:direct-const-arg.pp
+#![feature(min_generic_const_args)]
+
+fn f<const N: usize>() {}
+
+fn main() {
+    f::<core::direct_const_arg!(2)>();
+    f::<{ core::direct_const_arg!(2) }>();
+}
diff --git a/tests/run-make/c-link-to-rust-va-list-fn/checkrust.rs b/tests/run-make/c-link-to-rust-va-list-fn/checkrust.rs
index f3d82474e94aa..9fc7523ecc7f3 100644
--- a/tests/run-make/c-link-to-rust-va-list-fn/checkrust.rs
+++ b/tests/run-make/c-link-to-rust-va-list-fn/checkrust.rs
@@ -1,5 +1,5 @@
 #![crate_type = "staticlib"]
-#![feature(c_variadic)]
+#![feature(c_variadic, c_variadic_int128)]
 
 use core::ffi::{CStr, VaList, c_char, c_double, c_int, c_long, c_longlong};
 
@@ -57,6 +57,49 @@ pub unsafe extern "C" fn check_list_copy_0(mut ap: VaList) -> usize {
     if compare_c_str(ap.next_arg::<*const c_char>(), c"Correct") { 0 } else { 0xff }
 }
 
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn check_list_i128(mut ap: VaList) -> usize {
+    cfg_select! {
+        any(
+            target_arch = "aarch64",
+            target_arch = "amdgpu",
+            target_arch = "arm64ec",
+            target_arch = "bpf",
+            target_arch = "loongarch64",
+            target_arch = "mips64",
+            target_arch = "mips64r6",
+            target_arch = "nvptx64",
+            target_arch = "powerpc64",
+            target_arch = "riscv64",
+            target_arch = "s390x",
+            target_arch = "sparc64",
+            target_arch = "wasm32",
+            target_arch = "wasm64",
+            target_arch = "x86_64",
+        ) => {
+            #[cfg(not(any(
+                target_arch = "wasm32",
+                target_abi = "x32",
+                target_pointer_width = "64",
+            )))]
+            compile_error!("unexpected target architecture for 128-bit c-variadic");
+
+            continue_if!(ap.next_arg::<i128>() == -42);
+            // use a 32-bit value here to test the alignment logic.
+            continue_if!(ap.next_arg::<c_int>() == 0xAAAA_AAAAu32.cast_signed());
+            continue_if!(ap.next_arg::<u128>() == u128::MAX);
+
+            return 0;
+        }
+        _ => {
+            // This function was called a platform where rustc does not implement
+            // VaArgSafe for i128 but clang does define __int128. Rustc should add
+            // the implementation if this comes up.
+            0xFF
+        }
+    }
+}
+
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn check_varargs_0(_: c_int, mut ap: ...) -> usize {
     continue_if!(ap.next_arg::<c_int>() == 42);
diff --git a/tests/run-make/c-link-to-rust-va-list-fn/test.c b/tests/run-make/c-link-to-rust-va-list-fn/test.c
index b368302326c71..c7510a29445a5 100644
--- a/tests/run-make/c-link-to-rust-va-list-fn/test.c
+++ b/tests/run-make/c-link-to-rust-va-list-fn/test.c
@@ -8,6 +8,7 @@ extern size_t check_list_0(va_list ap);
 extern size_t check_list_1(va_list ap);
 extern size_t check_list_2(va_list ap);
 extern size_t check_list_copy_0(va_list ap);
+extern size_t check_list_i128(va_list ap);
 extern size_t check_varargs_0(int fixed, ...);
 extern size_t check_varargs_1(int fixed, ...);
 extern size_t check_varargs_2(int fixed, ...);
@@ -38,6 +39,10 @@ int main(int argc, char* argv[]) {
 
     assert(test_rust(check_list_copy_0, 6.28, 16, 'A', "Skip Me!", "Correct") == 0);
 
+#if defined(__SIZEOF_INT128__)
+    assert(test_rust(check_list_i128, (__int128)-42, 0xAAAAAAAA, (unsigned __int128)-1) == 0);
+#endif
+
     assert(check_varargs_0(0, 42, "Hello, World!") == 0);
 
     assert(check_varargs_1(0, 3.14, 12l, 'A', 0x1LL) == 0);
diff --git a/tests/ui/allocator/not-an-allocator.u.stderr b/tests/ui/allocator/not-an-allocator.u.stderr
index f7400d16b1fd1..9be5dd495db02 100644
--- a/tests/ui/allocator/not-an-allocator.u.stderr
+++ b/tests/ui/allocator/not-an-allocator.u.stderr
@@ -4,10 +4,11 @@ error[E0277]: the trait bound `usize: GlobalAlloc` is not satisfied
 LL | #[global_allocator]
    | ------------------- in this attribute macro expansion
 LL | static A: usize = 0;
-   |           ^^^^^ the trait `GlobalAlloc` is not implemented for `usize`
+   |           ^^^^^ the nightly-only, unstable trait `GlobalAllocator` is not implemented for `usize`
    |
-help: the trait `GlobalAlloc` is implemented for `System`
-  --> $SRC_DIR/std/src/sys/alloc/unix.rs:LL:COL
+help: the trait `GlobalAllocator` is implemented for `System`
+  --> $SRC_DIR/std/src/alloc.rs:LL:COL
+   = note: required for `usize` to implement `GlobalAlloc`
 
 error[E0277]: the trait bound `usize: GlobalAlloc` is not satisfied
   --> $DIR/not-an-allocator.rs:5:11
@@ -15,10 +16,11 @@ error[E0277]: the trait bound `usize: GlobalAlloc` is not satisfied
 LL | #[global_allocator]
    | ------------------- in this attribute macro expansion
 LL | static A: usize = 0;
-   |           ^^^^^ the trait `GlobalAlloc` is not implemented for `usize`
+   |           ^^^^^ the nightly-only, unstable trait `GlobalAllocator` is not implemented for `usize`
    |
-help: the trait `GlobalAlloc` is implemented for `System`
-  --> $SRC_DIR/std/src/sys/alloc/unix.rs:LL:COL
+help: the trait `GlobalAllocator` is implemented for `System`
+  --> $SRC_DIR/std/src/alloc.rs:LL:COL
+   = note: required for `usize` to implement `GlobalAlloc`
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 error[E0277]: the trait bound `usize: GlobalAlloc` is not satisfied
@@ -27,10 +29,11 @@ error[E0277]: the trait bound `usize: GlobalAlloc` is not satisfied
 LL | #[global_allocator]
    | ------------------- in this attribute macro expansion
 LL | static A: usize = 0;
-   |           ^^^^^ the trait `GlobalAlloc` is not implemented for `usize`
+   |           ^^^^^ the nightly-only, unstable trait `GlobalAllocator` is not implemented for `usize`
    |
-help: the trait `GlobalAlloc` is implemented for `System`
-  --> $SRC_DIR/std/src/sys/alloc/unix.rs:LL:COL
+help: the trait `GlobalAllocator` is implemented for `System`
+  --> $SRC_DIR/std/src/alloc.rs:LL:COL
+   = note: required for `usize` to implement `GlobalAlloc`
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 error[E0277]: the trait bound `usize: GlobalAlloc` is not satisfied
@@ -39,10 +42,11 @@ error[E0277]: the trait bound `usize: GlobalAlloc` is not satisfied
 LL | #[global_allocator]
    | ------------------- in this attribute macro expansion
 LL | static A: usize = 0;
-   |           ^^^^^ the trait `GlobalAlloc` is not implemented for `usize`
+   |           ^^^^^ the nightly-only, unstable trait `GlobalAllocator` is not implemented for `usize`
    |
-help: the trait `GlobalAlloc` is implemented for `System`
-  --> $SRC_DIR/std/src/sys/alloc/unix.rs:LL:COL
+help: the trait `GlobalAllocator` is implemented for `System`
+  --> $SRC_DIR/std/src/alloc.rs:LL:COL
+   = note: required for `usize` to implement `GlobalAlloc`
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 error: aborting due to 4 previous errors
diff --git a/tests/ui/c-variadic/roundtrip.rs b/tests/ui/c-variadic/roundtrip.rs
index 22a545fec5a88..ab6d61a5b8250 100644
--- a/tests/ui/c-variadic/roundtrip.rs
+++ b/tests/ui/c-variadic/roundtrip.rs
@@ -1,6 +1,13 @@
 //@ run-pass
 //@ ignore-backends: gcc
-#![feature(c_variadic, const_c_variadic, const_destruct, const_raw_ptr_comparison)]
+#![feature(
+    c_variadic,
+    const_c_variadic,
+    c_variadic_int128,
+    const_destruct,
+    const_raw_ptr_comparison
+)]
+#![allow(unused_features)] // c_variadic_int128 is only used on 64-bit targets.
 
 use std::ffi::*;
 
@@ -12,7 +19,8 @@ use std::ffi::*;
 const unsafe extern "C" fn variadic<T: VaArgSafe>(mut ap: ...) -> (T, T) {
     let x = ap.next_arg::<T>();
     // Intersperse a small type to test alignment logic. A `u32` (i.e. `c_uint`) is the smallest
-    // type that implements `VaArgSafe`: smaller types would automatically be promoted.
+    // type that implements `VaArgSafe` (except on some 16-bit targets): smaller types would
+    // automatically be promoted.
     assert!(ap.next_arg::<u32>() == 0xAAAA_AAAA);
     let y = ap.next_arg::<T>();
 
@@ -74,5 +82,38 @@ fn main() {
         static mut B: u32 = 2u32;
         roundtrip_ptr!(*const u32, &raw const A, &raw const B);
         roundtrip_ptr!(*mut u32, &raw mut A, &raw mut B);
+
+        // The 128-bit integers only implement VaArgSafe on some targets, a subset of those that
+        // define `__int128`. We test some of those targets here.
+        cfg_select! {
+            any(
+                target_arch = "aarch64",
+                target_arch = "amdgpu",
+                target_arch = "arm64ec",
+                target_arch = "bpf",
+                target_arch = "loongarch64",
+                target_arch = "mips64",
+                target_arch = "mips64r6",
+                target_arch = "nvptx64",
+                target_arch = "powerpc64",
+                target_arch = "riscv64",
+                target_arch = "s390x",
+                target_arch = "sparc64",
+                target_arch = "wasm32",
+                target_arch = "wasm64",
+                target_arch = "x86_64",
+            ) => {
+                #[cfg(not(any(
+                    target_arch = "wasm32",
+                    target_abi = "x32",
+                    target_pointer_width = "64",
+                )))]
+                compile_error!("unexpected target architecture for 128-bit c-variadic");
+
+                roundtrip!(i128, -1, -2);
+                roundtrip!(u128, 1, 2);
+            }
+            _ => {}
+        }
     }
 }
diff --git a/tests/ui/const-generics/generic_const_exprs/assoc_const_unification/doesnt_unify_evaluatable.stderr b/tests/ui/const-generics/generic_const_exprs/assoc_const_unification/doesnt_unify_evaluatable.stderr
index 62bebd53b14a6..6cf4e881adae8 100644
--- a/tests/ui/const-generics/generic_const_exprs/assoc_const_unification/doesnt_unify_evaluatable.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/assoc_const_unification/doesnt_unify_evaluatable.stderr
@@ -1,8 +1,8 @@
 error: unconstrained generic constant
-  --> $DIR/doesnt_unify_evaluatable.rs:9:13
+  --> $DIR/doesnt_unify_evaluatable.rs:9:11
    |
 LL |     bar::<{ T::ASSOC }>();
-   |             ^^^^^^^^
+   |           ^^^^^^^^^^^^
    |
 help: try adding a `where` bound
    |
diff --git a/tests/ui/const-generics/mgca/adt_expr_arg_simple.rs b/tests/ui/const-generics/mgca/adt_expr_arg_simple.rs
index 8470b933cadd2..b09d17fb11262 100644
--- a/tests/ui/const-generics/mgca/adt_expr_arg_simple.rs
+++ b/tests/ui/const-generics/mgca/adt_expr_arg_simple.rs
@@ -10,7 +10,6 @@ use Option::Some;
 
 fn foo<const N: Option<u32>>() {}
 
-
 trait Trait {
     type const ASSOC: u32;
 }
@@ -26,7 +25,7 @@ fn bar<T: Trait, const N: u32>() {
 
     // this on the other hand is not allowed as `N + 1` is not a legal
     // const argument
-    foo::<{ Some::<u32> { 0: N + 1 } }>();
+    foo::<{ core::direct_const_arg!(Some::<u32> { 0: N + 1 }) }>();
     //~^ ERROR: complex const arguments must be placed inside of a `const` block
 
     // this also is not allowed as generic parameters cannot be used
diff --git a/tests/ui/const-generics/mgca/adt_expr_arg_simple.stderr b/tests/ui/const-generics/mgca/adt_expr_arg_simple.stderr
index 0060c94875b5c..8f02ce0f82315 100644
--- a/tests/ui/const-generics/mgca/adt_expr_arg_simple.stderr
+++ b/tests/ui/const-generics/mgca/adt_expr_arg_simple.stderr
@@ -1,11 +1,11 @@
 error: complex const arguments must be placed inside of a `const` block
-  --> $DIR/adt_expr_arg_simple.rs:29:30
+  --> $DIR/adt_expr_arg_simple.rs:28:54
    |
-LL |     foo::<{ Some::<u32> { 0: N + 1 } }>();
-   |                              ^^^^^
+LL |     foo::<{ core::direct_const_arg!(Some::<u32> { 0: N + 1 }) }>();
+   |                                                      ^^^^^
 
 error: generic parameters may not be used in const operations
-  --> $DIR/adt_expr_arg_simple.rs:34:38
+  --> $DIR/adt_expr_arg_simple.rs:33:38
    |
 LL |     foo::<{ Some::<u32> { 0: const { N + 1 } } }>();
    |                                      ^
diff --git a/tests/ui/const-generics/mgca/array-expr-complex.r1.stderr b/tests/ui/const-generics/mgca/array-expr-complex.r1.stderr
index 0c931af8d8b1c..a226d7ff0c225 100644
--- a/tests/ui/const-generics/mgca/array-expr-complex.r1.stderr
+++ b/tests/ui/const-generics/mgca/array-expr-complex.r1.stderr
@@ -1,8 +1,8 @@
 error: complex const arguments must be placed inside of a `const` block
-  --> $DIR/array-expr-complex.rs:11:28
+  --> $DIR/array-expr-complex.rs:11:52
    |
-LL |     takes_array::<{ [1, 2, 1 + 2] }>();
-   |                            ^^^^^
+LL |     takes_array::<{ core::direct_const_arg!([1, 2, 1 + 2]) }>();
+   |                                                    ^^^^^
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/mgca/array-expr-complex.r2.stderr b/tests/ui/const-generics/mgca/array-expr-complex.r2.stderr
index 335af9235e0c9..cc1e70c1d9a7a 100644
--- a/tests/ui/const-generics/mgca/array-expr-complex.r2.stderr
+++ b/tests/ui/const-generics/mgca/array-expr-complex.r2.stderr
@@ -1,8 +1,8 @@
 error: complex const arguments must be placed inside of a `const` block
-  --> $DIR/array-expr-complex.rs:14:21
+  --> $DIR/array-expr-complex.rs:14:45
    |
-LL |     takes_array::<{ [X; 3] }>();
-   |                     ^^^^^^
+LL |     takes_array::<{ core::direct_const_arg!([X; 3]) }>();
+   |                                             ^^^^^^
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/mgca/array-expr-complex.r3.stderr b/tests/ui/const-generics/mgca/array-expr-complex.r3.stderr
index 02d74c1b5d0c5..cc52abe0e8fb8 100644
--- a/tests/ui/const-generics/mgca/array-expr-complex.r3.stderr
+++ b/tests/ui/const-generics/mgca/array-expr-complex.r3.stderr
@@ -1,8 +1,8 @@
 error: complex const arguments must be placed inside of a `const` block
-  --> $DIR/array-expr-complex.rs:17:21
+  --> $DIR/array-expr-complex.rs:17:45
    |
-LL |     takes_array::<{ [0; Y] }>();
-   |                     ^^^^^^
+LL |     takes_array::<{ core::direct_const_arg!([0; Y]) }>();
+   |                                             ^^^^^^
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/mgca/array-expr-complex.rs b/tests/ui/const-generics/mgca/array-expr-complex.rs
index 26f4700b5885c..7f5a77fdff3df 100644
--- a/tests/ui/const-generics/mgca/array-expr-complex.rs
+++ b/tests/ui/const-generics/mgca/array-expr-complex.rs
@@ -8,13 +8,13 @@ fn takes_array<const A: [u32; 3]>() {}
 fn generic_caller<const X: u32, const Y: usize>() {
     // not supported yet
     #[cfg(r1)]
-    takes_array::<{ [1, 2, 1 + 2] }>();
+    takes_array::<{ core::direct_const_arg!([1, 2, 1 + 2]) }>();
     //[r1]~^ ERROR: complex const arguments must be placed inside of a `const` block
     #[cfg(r2)]
-    takes_array::<{ [X; 3] }>();
+    takes_array::<{ core::direct_const_arg!([X; 3]) }>();
     //[r2]~^ ERROR: complex const arguments must be placed inside of a `const` block
     #[cfg(r3)]
-    takes_array::<{ [0; Y] }>();
+    takes_array::<{ core::direct_const_arg!([0; Y]) }>();
     //[r3]~^ ERROR: complex const arguments must be placed inside of a `const` block
 }
 
diff --git a/tests/ui/const-generics/mgca/array_expr_arg_complex.rs b/tests/ui/const-generics/mgca/array_expr_arg_complex.rs
index 6d57e4f4b9686..4adb2bf6e429d 100644
--- a/tests/ui/const-generics/mgca/array_expr_arg_complex.rs
+++ b/tests/ui/const-generics/mgca/array_expr_arg_complex.rs
@@ -9,8 +9,8 @@ fn takes_array<const A: [u32; 2]>() {}
 fn takes_tuple_with_array<const A: ([u32; 2], u32)>() {}
 
 fn generic_caller<T: Trait, const N: u32, const N2: u32>() {
-    takes_array::<{ [N, N + 1] }>(); //~ ERROR complex const arguments must be placed inside of a `const` block
-    takes_tuple_with_array::<{ ([N, N + 1], N) }>(); //~ ERROR complex const arguments must be placed inside of a `const` block
+    takes_array::<{ core::direct_const_arg!([N, N + 1]) }>(); //~ ERROR complex const arguments must be placed inside of a `const` block
+    takes_tuple_with_array::<{ core::direct_const_arg!(([N, N + 1], N)) }>(); //~ ERROR complex const arguments must be placed inside of a `const` block
 }
 
 fn main() {}
diff --git a/tests/ui/const-generics/mgca/array_expr_arg_complex.stderr b/tests/ui/const-generics/mgca/array_expr_arg_complex.stderr
index f40d4b5035d86..c7b13351d453c 100644
--- a/tests/ui/const-generics/mgca/array_expr_arg_complex.stderr
+++ b/tests/ui/const-generics/mgca/array_expr_arg_complex.stderr
@@ -1,14 +1,14 @@
 error: complex const arguments must be placed inside of a `const` block
-  --> $DIR/array_expr_arg_complex.rs:12:25
+  --> $DIR/array_expr_arg_complex.rs:12:49
    |
-LL |     takes_array::<{ [N, N + 1] }>();
-   |                         ^^^^^
+LL |     takes_array::<{ core::direct_const_arg!([N, N + 1]) }>();
+   |                                                 ^^^^^
 
 error: complex const arguments must be placed inside of a `const` block
-  --> $DIR/array_expr_arg_complex.rs:13:37
+  --> $DIR/array_expr_arg_complex.rs:13:61
    |
-LL |     takes_tuple_with_array::<{ ([N, N + 1], N) }>();
-   |                                     ^^^^^
+LL |     takes_tuple_with_array::<{ core::direct_const_arg!(([N, N + 1], N)) }>();
+   |                                                             ^^^^^
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/const-generics/mgca/auxiliary/anon-const-def-id-on-const-arg-with-anon.rs b/tests/ui/const-generics/mgca/auxiliary/anon-const-def-id-on-const-arg-with-anon.rs
new file mode 100644
index 0000000000000..c1ebfc18e0816
--- /dev/null
+++ b/tests/ui/const-generics/mgca/auxiliary/anon-const-def-id-on-const-arg-with-anon.rs
@@ -0,0 +1,11 @@
+#![feature(min_generic_const_args)]
+#![allow(incomplete_features)]
+pub struct S<const N: usize>;
+// this is a directly represented anon const... it's a bit weird.
+// imagine `S<{ (2, const { 1 + 1 }) }>`. a directly represented tuple, containing an anon const.
+// now, replace `(2, _)` with `_`. it's a directly represented anon const.
+// this is different from const argument lowering failing to represent an argument directly and
+// falling back to representing it as an anon const instead.
+pub fn f() -> S<{ const { 1 + 1 } }> {
+    S
+}
diff --git a/tests/ui/const-generics/mgca/bad-const-arg-fn-154539.rs b/tests/ui/const-generics/mgca/bad-const-arg-fn-154539.rs
index 7c7ffd9a9bd5f..e3d1f577d4f60 100644
--- a/tests/ui/const-generics/mgca/bad-const-arg-fn-154539.rs
+++ b/tests/ui/const-generics/mgca/bad-const-arg-fn-154539.rs
@@ -2,10 +2,11 @@
 
 trait Iter<
     const FN: fn() = {
-        || { //~ ERROR complex const arguments must be placed inside of a `const` block
+        core::direct_const_arg!(|| {
+            //~^ ERROR complex const arguments must be placed inside of a `const` block
             use std::io::*;
             write!(_, "")
-        }
+        })
     },
 >
 {
diff --git a/tests/ui/const-generics/mgca/bad-const-arg-fn-154539.stderr b/tests/ui/const-generics/mgca/bad-const-arg-fn-154539.stderr
index 60774c4a3efea..96fcea9e906cf 100644
--- a/tests/ui/const-generics/mgca/bad-const-arg-fn-154539.stderr
+++ b/tests/ui/const-generics/mgca/bad-const-arg-fn-154539.stderr
@@ -1,10 +1,12 @@
 error: complex const arguments must be placed inside of a `const` block
-  --> $DIR/bad-const-arg-fn-154539.rs:5:9
+  --> $DIR/bad-const-arg-fn-154539.rs:5:33
    |
-LL | /         || {
+LL |           core::direct_const_arg!(|| {
+   |  _________________________________^
+LL | |
 LL | |             use std::io::*;
 LL | |             write!(_, "")
-LL | |         }
+LL | |         })
    | |_________^
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/const-generics/mgca/bad-direct-const-arg.rs b/tests/ui/const-generics/mgca/bad-direct-const-arg.rs
new file mode 100644
index 0000000000000..451806ca6e1db
--- /dev/null
+++ b/tests/ui/const-generics/mgca/bad-direct-const-arg.rs
@@ -0,0 +1,8 @@
+//! Simple error message test, nothing special here
+#![feature(min_generic_const_args)]
+
+fn main(x: core::direct_const_arg!(2)) {
+    //~^ ERROR expected type, found `direct_const_arg!()` constant
+    let _ = core::direct_const_arg!(2);
+    //~^ ERROR expected expression, found `direct_const_arg!()` constant
+}
diff --git a/tests/ui/const-generics/mgca/bad-direct-const-arg.stderr b/tests/ui/const-generics/mgca/bad-direct-const-arg.stderr
new file mode 100644
index 0000000000000..b77791ad5b3ee
--- /dev/null
+++ b/tests/ui/const-generics/mgca/bad-direct-const-arg.stderr
@@ -0,0 +1,14 @@
+error: expected expression, found `direct_const_arg!()` constant
+  --> $DIR/bad-direct-const-arg.rs:6:13
+   |
+LL |     let _ = core::direct_const_arg!(2);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: expected type, found `direct_const_arg!()` constant
+  --> $DIR/bad-direct-const-arg.rs:4:12
+   |
+LL | fn main(x: core::direct_const_arg!(2)) {
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/const-generics/mgca/direct-const-arg-feature-gate.rs b/tests/ui/const-generics/mgca/direct-const-arg-feature-gate.rs
new file mode 100644
index 0000000000000..16ba349a29be6
--- /dev/null
+++ b/tests/ui/const-generics/mgca/direct-const-arg-feature-gate.rs
@@ -0,0 +1,5 @@
+fn foo<const N: usize>(_: [(); core::direct_const_arg!(N)]) {}
+//~^ ERROR use of unstable library feature `min_generic_const_args`
+//~| ERROR expected expression, found `direct_const_arg!()` constant
+//~| ERROR generic parameters may not be used in const operations
+fn main() {}
diff --git a/tests/ui/const-generics/mgca/direct-const-arg-feature-gate.stderr b/tests/ui/const-generics/mgca/direct-const-arg-feature-gate.stderr
new file mode 100644
index 0000000000000..f5dc211c2f71a
--- /dev/null
+++ b/tests/ui/const-generics/mgca/direct-const-arg-feature-gate.stderr
@@ -0,0 +1,28 @@
+error[E0658]: use of unstable library feature `min_generic_const_args`
+  --> $DIR/direct-const-arg-feature-gate.rs:1:32
+   |
+LL | fn foo<const N: usize>(_: [(); core::direct_const_arg!(N)]) {}
+   |                                ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #132980 <https://github.com/rust-lang/rust/issues/132980> for more information
+   = help: add `#![feature(min_generic_const_args)]` 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: generic parameters may not be used in const operations
+  --> $DIR/direct-const-arg-feature-gate.rs:1:56
+   |
+LL | fn foo<const N: usize>(_: [(); core::direct_const_arg!(N)]) {}
+   |                                                        ^ cannot perform const operation using `N`
+   |
+   = help: const parameters may only be used as standalone arguments here, i.e. `N`
+   = help: add `#![feature(generic_const_exprs)]` to allow generic const expressions
+
+error: expected expression, found `direct_const_arg!()` constant
+  --> $DIR/direct-const-arg-feature-gate.rs:1:32
+   |
+LL | fn foo<const N: usize>(_: [(); core::direct_const_arg!(N)]) {}
+   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/const-generics/mgca/direct-const-arg-multiple-exprs.rs b/tests/ui/const-generics/mgca/direct-const-arg-multiple-exprs.rs
new file mode 100644
index 0000000000000..8c802e563db7c
--- /dev/null
+++ b/tests/ui/const-generics/mgca/direct-const-arg-multiple-exprs.rs
@@ -0,0 +1,5 @@
+#![feature(min_generic_const_args)]
+struct S<const N: usize>;
+fn foo<const N: usize, const M: usize>(_: S<core::direct_const_arg!(N, M)>) {}
+//~^ ERROR direct_const_arg! takes 1 argument
+fn main() {}
diff --git a/tests/ui/const-generics/mgca/direct-const-arg-multiple-exprs.stderr b/tests/ui/const-generics/mgca/direct-const-arg-multiple-exprs.stderr
new file mode 100644
index 0000000000000..6f54a563ffbfc
--- /dev/null
+++ b/tests/ui/const-generics/mgca/direct-const-arg-multiple-exprs.stderr
@@ -0,0 +1,8 @@
+error: direct_const_arg! takes 1 argument
+  --> $DIR/direct-const-arg-multiple-exprs.rs:3:45
+   |
+LL | fn foo<const N: usize, const M: usize>(_: S<core::direct_const_arg!(N, M)>) {}
+   |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/const-generics/mgca/double-wrapped-path-not-accidentally-stabilized.rs b/tests/ui/const-generics/mgca/double-wrapped-path-not-accidentally-stabilized.rs
new file mode 100644
index 0000000000000..09bce5c7f9aa2
--- /dev/null
+++ b/tests/ui/const-generics/mgca/double-wrapped-path-not-accidentally-stabilized.rs
@@ -0,0 +1,15 @@
+//! When doing some refactorings in mGCA, it was easy to accidentally stabilize doubly-brace-wrapped
+//! paths. Check to make sure we don't accidentally do so.
+//!
+//! Feel free to delete this test if/when mGCA is stabilized and we support this syntax on stable,
+//! it's testing nothing useful beyond that point.
+
+fn f<const N: usize>() {}
+
+fn g<const N: usize>() {
+    f::<{ N }>(); // ok
+    f::<{ { N } }>();
+    //~^ ERROR: generic parameters may not be used in const operations
+}
+
+fn main() {}
diff --git a/tests/ui/const-generics/mgca/double-wrapped-path-not-accidentally-stabilized.stderr b/tests/ui/const-generics/mgca/double-wrapped-path-not-accidentally-stabilized.stderr
new file mode 100644
index 0000000000000..6168ec242a38c
--- /dev/null
+++ b/tests/ui/const-generics/mgca/double-wrapped-path-not-accidentally-stabilized.stderr
@@ -0,0 +1,11 @@
+error: generic parameters may not be used in const operations
+  --> $DIR/double-wrapped-path-not-accidentally-stabilized.rs:11:13
+   |
+LL |     f::<{ { N } }>();
+   |             ^ cannot perform const operation using `N`
+   |
+   = help: const parameters may only be used as standalone arguments here, i.e. `N`
+   = help: add `#![feature(generic_const_exprs)]` to allow generic const expressions
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/const-generics/mgca/explicit_anon_consts.rs b/tests/ui/const-generics/mgca/explicit_anon_consts.rs
index 2b9909b43dfbb..9b642b286fa3e 100644
--- a/tests/ui/const-generics/mgca/explicit_anon_consts.rs
+++ b/tests/ui/const-generics/mgca/explicit_anon_consts.rs
@@ -10,7 +10,7 @@ type Adt1<const N: usize> = Foo<N>;
 type Adt2<const N: usize> = Foo<{ N }>;
 type Adt3<const N: usize> = Foo<const { N }>;
 //~^ ERROR: generic parameters may not be used in const operations
-type Adt4<const N: usize> = Foo<{ 1 + 1 }>;
+type Adt4<const N: usize> = Foo<core::direct_const_arg!(1 + 1)>;
 //~^ ERROR: complex const arguments must be placed inside of a `const` block
 type Adt5<const N: usize> = Foo<const { 1 + 1 }>;
 
@@ -18,7 +18,7 @@ type Arr<const N: usize> = [(); N];
 type Arr2<const N: usize> = [(); { N }];
 type Arr3<const N: usize> = [(); const { N }];
 //~^ ERROR: generic parameters may not be used in const operations
-type Arr4<const N: usize> = [(); 1 + 1];
+type Arr4<const N: usize> = [(); core::direct_const_arg!(1 + 1)];
 //~^ ERROR: complex const arguments must be placed inside of a `const` block
 type Arr5<const N: usize> = [(); const { 1 + 1 }];
 
@@ -27,7 +27,7 @@ fn repeats<const N: usize>() -> [(); N] {
     let _2 = [(); { N }];
     let _3 = [(); const { N }];
     //~^ ERROR: generic parameters may not be used in const operations
-    let _4 = [(); 1 + 1];
+    let _4 = [(); core::direct_const_arg!(1 + 1)];
     //~^ ERROR: complex const arguments must be placed inside of a `const` block
     let _5 = [(); const { 1 + 1 }];
     let _6: [(); const { N }] = todo!();
@@ -42,10 +42,10 @@ type const ITEM2<const N: usize>: usize = { N };
 type const ITEM3<const N: usize>: usize = const { N };
 //~^ ERROR: generic parameters may not be used in const operations
 
-type const ITEM4<const N: usize>: usize = { 1 + 1 };
+type const ITEM4<const N: usize>: usize = core::direct_const_arg!(1 + 1);
 //~^ ERROR: complex const arguments must be placed inside of a `const` block
 
-type const ITEM5<const N: usize>: usize = const { 1 + 1};
+type const ITEM5<const N: usize>: usize = const { 1 + 1 };
 
 trait Trait {
 
@@ -59,7 +59,7 @@ fn ace_bounds<
     T2: Trait<ASSOC = { N }>,
     T3: Trait<ASSOC = const { N }>,
     //~^ ERROR: generic parameters may not be used in const operations
-    T4: Trait<ASSOC = { 1 + 1 }>,
+    T4: Trait<ASSOC = { core::direct_const_arg!(1 + 1) }>,
     //~^ ERROR: complex const arguments must be placed inside of a `const` block
     T5: Trait<ASSOC = const { 1 + 1 }>,
 >() {}
@@ -68,6 +68,6 @@ struct Default1<const N: usize, const M: usize = N>;
 struct Default2<const N: usize, const M: usize = { N }>;
 struct Default3<const N: usize, const M: usize = const { N }>;
 //~^ ERROR: generic parameters may not be used in const operations
-struct Default4<const N: usize, const M: usize = { 1 + 1 }>;
+struct Default4<const N: usize, const M: usize = { core::direct_const_arg!(1 + 1) }>;
 //~^ ERROR: complex const arguments must be placed inside of a `const` block
-struct Default5<const N: usize, const M: usize = const { 1 + 1}>;
+struct Default5<const N: usize, const M: usize = const { 1 + 1 }>;
diff --git a/tests/ui/const-generics/mgca/explicit_anon_consts.stderr b/tests/ui/const-generics/mgca/explicit_anon_consts.stderr
index f634ec1cf12e4..9ab6af010bf21 100644
--- a/tests/ui/const-generics/mgca/explicit_anon_consts.stderr
+++ b/tests/ui/const-generics/mgca/explicit_anon_consts.stderr
@@ -1,38 +1,38 @@
 error: complex const arguments must be placed inside of a `const` block
-  --> $DIR/explicit_anon_consts.rs:13:35
+  --> $DIR/explicit_anon_consts.rs:13:57
    |
-LL | type Adt4<const N: usize> = Foo<{ 1 + 1 }>;
-   |                                   ^^^^^
+LL | type Adt4<const N: usize> = Foo<core::direct_const_arg!(1 + 1)>;
+   |                                                         ^^^^^
 
 error: complex const arguments must be placed inside of a `const` block
-  --> $DIR/explicit_anon_consts.rs:21:34
+  --> $DIR/explicit_anon_consts.rs:21:58
    |
-LL | type Arr4<const N: usize> = [(); 1 + 1];
-   |                                  ^^^^^
+LL | type Arr4<const N: usize> = [(); core::direct_const_arg!(1 + 1)];
+   |                                                          ^^^^^
 
 error: complex const arguments must be placed inside of a `const` block
-  --> $DIR/explicit_anon_consts.rs:30:19
+  --> $DIR/explicit_anon_consts.rs:30:43
    |
-LL |     let _4 = [(); 1 + 1];
-   |                   ^^^^^
+LL |     let _4 = [(); core::direct_const_arg!(1 + 1)];
+   |                                           ^^^^^
 
 error: complex const arguments must be placed inside of a `const` block
-  --> $DIR/explicit_anon_consts.rs:45:45
+  --> $DIR/explicit_anon_consts.rs:45:67
    |
-LL | type const ITEM4<const N: usize>: usize = { 1 + 1 };
-   |                                             ^^^^^
+LL | type const ITEM4<const N: usize>: usize = core::direct_const_arg!(1 + 1);
+   |                                                                   ^^^^^
 
 error: complex const arguments must be placed inside of a `const` block
-  --> $DIR/explicit_anon_consts.rs:62:25
+  --> $DIR/explicit_anon_consts.rs:62:49
    |
-LL |     T4: Trait<ASSOC = { 1 + 1 }>,
-   |                         ^^^^^
+LL |     T4: Trait<ASSOC = { core::direct_const_arg!(1 + 1) }>,
+   |                                                 ^^^^^
 
 error: complex const arguments must be placed inside of a `const` block
-  --> $DIR/explicit_anon_consts.rs:71:52
+  --> $DIR/explicit_anon_consts.rs:71:76
    |
-LL | struct Default4<const N: usize, const M: usize = { 1 + 1 }>;
-   |                                                    ^^^^^
+LL | struct Default4<const N: usize, const M: usize = { core::direct_const_arg!(1 + 1) }>;
+   |                                                                            ^^^^^
 
 error: generic parameters may not be used in const operations
   --> $DIR/explicit_anon_consts.rs:42:51
diff --git a/tests/ui/const-generics/mgca/mixed-direct-anon-expression-diagnostics.rs b/tests/ui/const-generics/mgca/mixed-direct-anon-expression-diagnostics.rs
new file mode 100644
index 0000000000000..1653fd63ed3f8
--- /dev/null
+++ b/tests/ui/const-generics/mgca/mixed-direct-anon-expression-diagnostics.rs
@@ -0,0 +1,17 @@
+//! Diagnostics for expressions that contain things that must be a mGCA direct expression, *and*
+//! things that must be an anon const, are currently less than ideal. This test merely asserts the
+//! current (bad) state of diagnostics, so we can track improvements over time.
+
+#![feature(min_generic_const_args, min_adt_const_params)]
+#![allow(incomplete_features)]
+
+fn f<const N: (u32, u32)>() {}
+
+fn g<const N: u32>() {
+    f::<{ (N, 1 + 1) }>();
+    //~^ ERROR: generic parameters may not be used in const operations
+    f::<{ core::direct_const_arg!((N, 1 + 1)) }>();
+    //~^ ERROR: complex const arguments must be placed inside of a `const` block
+}
+
+fn main() {}
diff --git a/tests/ui/const-generics/mgca/mixed-direct-anon-expression-diagnostics.stderr b/tests/ui/const-generics/mgca/mixed-direct-anon-expression-diagnostics.stderr
new file mode 100644
index 0000000000000..ae297de108493
--- /dev/null
+++ b/tests/ui/const-generics/mgca/mixed-direct-anon-expression-diagnostics.stderr
@@ -0,0 +1,16 @@
+error: complex const arguments must be placed inside of a `const` block
+  --> $DIR/mixed-direct-anon-expression-diagnostics.rs:13:39
+   |
+LL |     f::<{ core::direct_const_arg!((N, 1 + 1)) }>();
+   |                                       ^^^^^
+
+error: generic parameters may not be used in const operations
+  --> $DIR/mixed-direct-anon-expression-diagnostics.rs:11:12
+   |
+LL |     f::<{ (N, 1 + 1) }>();
+   |            ^
+   |
+   = help: add `#![feature(generic_const_args)]` to allow generic expressions as the RHS of const items
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/const-generics/mgca/serialized-direct-const-with-anon-const-body.rs b/tests/ui/const-generics/mgca/serialized-direct-const-with-anon-const-body.rs
new file mode 100644
index 0000000000000..985e14fddb676
--- /dev/null
+++ b/tests/ui/const-generics/mgca/serialized-direct-const-with-anon-const-body.rs
@@ -0,0 +1,16 @@
+//@ check-pass
+//@ aux-build:anon-const-def-id-on-const-arg-with-anon.rs
+//! The DefCollector sometimes generates "fake" DefKind::AnonConst DefIds for AST AnonConsts that
+//! are not actually lowered to HIR AnonConsts, and so the DefId is placed on a hir::Node::ConstArg
+//! (just to place it *somewhere*). These "fake" DefIds should not be serialized. Previously, the
+//! logic to skip serializing them was incorrect (we were still serializing fake DefIds for
+//! `ConstArg(ConstArgKind::Anon)` if the directly represented expression contained within it
+//! *another*, unrelated, anon const). This test checks that case, a directly-represented
+//! fake-anon-const directly containing another anon const.
+
+#![feature(min_generic_const_args)]
+#![allow(incomplete_features)]
+extern crate anon_const_def_id_on_const_arg_with_anon;
+fn main() {
+    anon_const_def_id_on_const_arg_with_anon::f();
+}
diff --git a/tests/ui/const-generics/mgca/tuple_ctor_complex_args.rs b/tests/ui/const-generics/mgca/tuple_ctor_complex_args.rs
index 2e39f8952b11d..460c8af840a1c 100644
--- a/tests/ui/const-generics/mgca/tuple_ctor_complex_args.rs
+++ b/tests/ui/const-generics/mgca/tuple_ctor_complex_args.rs
@@ -9,7 +9,7 @@ struct Point(u32, u32);
 fn with_point<const P: Point>() {}
 
 fn test<const N: u32>() {
-    with_point::<{ Point(N + 1, N) }>();
+    with_point::<{ core::direct_const_arg!(Point(N + 1, N)) }>();
     //~^ ERROR complex const arguments must be placed inside of a `const` block
 
     with_point::<{ Point(const { N + 1 }, N) }>();
diff --git a/tests/ui/const-generics/mgca/tuple_ctor_complex_args.stderr b/tests/ui/const-generics/mgca/tuple_ctor_complex_args.stderr
index 3a873ec33fb19..a4e7cb94c57c3 100644
--- a/tests/ui/const-generics/mgca/tuple_ctor_complex_args.stderr
+++ b/tests/ui/const-generics/mgca/tuple_ctor_complex_args.stderr
@@ -1,8 +1,8 @@
 error: complex const arguments must be placed inside of a `const` block
-  --> $DIR/tuple_ctor_complex_args.rs:12:26
+  --> $DIR/tuple_ctor_complex_args.rs:12:50
    |
-LL |     with_point::<{ Point(N + 1, N) }>();
-   |                          ^^^^^
+LL |     with_point::<{ core::direct_const_arg!(Point(N + 1, N)) }>();
+   |                                                  ^^^^^
 
 error: generic parameters may not be used in const operations
   --> $DIR/tuple_ctor_complex_args.rs:15:34
diff --git a/tests/ui/const-generics/mgca/tuple_expr_arg_complex.rs b/tests/ui/const-generics/mgca/tuple_expr_arg_complex.rs
index d7cab17bad124..0d99b8ae345d6 100644
--- a/tests/ui/const-generics/mgca/tuple_expr_arg_complex.rs
+++ b/tests/ui/const-generics/mgca/tuple_expr_arg_complex.rs
@@ -9,11 +9,11 @@ fn takes_tuple<const A: (u32, u32)>() {}
 fn takes_nested_tuple<const A: (u32, (u32, u32))>() {}
 
 fn generic_caller<T: Trait, const N: u32, const N2: u32>() {
-    takes_tuple::<{ (N, N + 1) }>(); //~ ERROR complex const arguments must be placed inside of a `const` block
-    takes_tuple::<{ (N, T::ASSOC + 1) }>(); //~ ERROR complex const arguments must be placed inside of a `const` block
+    takes_tuple::<{ core::direct_const_arg!((N, N + 1)) }>(); //~ ERROR complex const arguments must be placed inside of a `const` block
+    takes_tuple::<{ core::direct_const_arg!((N, T::ASSOC + 1)) }>(); //~ ERROR complex const arguments must be placed inside of a `const` block
 
-    takes_nested_tuple::<{ (N, (N, N + 1)) }>(); //~ ERROR complex const arguments must be placed inside of a `const` block
-    takes_nested_tuple::<{ (N, (N, const { N + 1 })) }>(); //~ ERROR generic parameters may not be used in const operations
+    takes_nested_tuple::<{ core::direct_const_arg!((N, (N, N + 1))) }>(); //~ ERROR complex const arguments must be placed inside of a `const` block
+    takes_nested_tuple::<{ core::direct_const_arg!((N, (N, const { N + 1 }))) }>(); //~ ERROR generic parameters may not be used in const operations
 }
 
 fn main() {}
diff --git a/tests/ui/const-generics/mgca/tuple_expr_arg_complex.stderr b/tests/ui/const-generics/mgca/tuple_expr_arg_complex.stderr
index a9d412964da29..4bed120284c08 100644
--- a/tests/ui/const-generics/mgca/tuple_expr_arg_complex.stderr
+++ b/tests/ui/const-generics/mgca/tuple_expr_arg_complex.stderr
@@ -1,26 +1,26 @@
 error: complex const arguments must be placed inside of a `const` block
-  --> $DIR/tuple_expr_arg_complex.rs:12:25
+  --> $DIR/tuple_expr_arg_complex.rs:12:49
    |
-LL |     takes_tuple::<{ (N, N + 1) }>();
-   |                         ^^^^^
+LL |     takes_tuple::<{ core::direct_const_arg!((N, N + 1)) }>();
+   |                                                 ^^^^^
 
 error: complex const arguments must be placed inside of a `const` block
-  --> $DIR/tuple_expr_arg_complex.rs:13:25
+  --> $DIR/tuple_expr_arg_complex.rs:13:49
    |
-LL |     takes_tuple::<{ (N, T::ASSOC + 1) }>();
-   |                         ^^^^^^^^^^^^
+LL |     takes_tuple::<{ core::direct_const_arg!((N, T::ASSOC + 1)) }>();
+   |                                                 ^^^^^^^^^^^^
 
 error: complex const arguments must be placed inside of a `const` block
-  --> $DIR/tuple_expr_arg_complex.rs:15:36
+  --> $DIR/tuple_expr_arg_complex.rs:15:60
    |
-LL |     takes_nested_tuple::<{ (N, (N, N + 1)) }>();
-   |                                    ^^^^^
+LL |     takes_nested_tuple::<{ core::direct_const_arg!((N, (N, N + 1))) }>();
+   |                                                            ^^^^^
 
 error: generic parameters may not be used in const operations
-  --> $DIR/tuple_expr_arg_complex.rs:16:44
+  --> $DIR/tuple_expr_arg_complex.rs:16:68
    |
-LL |     takes_nested_tuple::<{ (N, (N, const { N + 1 })) }>();
-   |                                            ^
+LL |     takes_nested_tuple::<{ core::direct_const_arg!((N, (N, const { N + 1 }))) }>();
+   |                                                                    ^
    |
    = help: add `#![feature(generic_const_args)]` to allow generic expressions as the RHS of const items
 
diff --git a/tests/ui/const-generics/mgca/type-const-free-anon-const-mismatch.stderr b/tests/ui/const-generics/mgca/type-const-free-anon-const-mismatch.stderr
index d0339d09cdc7a..52ef108a84dbf 100644
--- a/tests/ui/const-generics/mgca/type-const-free-anon-const-mismatch.stderr
+++ b/tests/ui/const-generics/mgca/type-const-free-anon-const-mismatch.stderr
@@ -4,7 +4,7 @@ error[E0284]: type annotations needed
 LL | type const X: usize = const { N };
    | ^^^^^^^^^^^^^^^^^^^ cannot infer the value of the constant `_`
    |
-   = note: cannot satisfy `X::{constant#0} == _`
+   = note: cannot satisfy `X::{constant#0}::{constant#0} == _`
 
 error: the constant `"this isn't a usize"` is not of type `usize`
   --> $DIR/type-const-free-anon-const-mismatch.rs:8:1
diff --git a/tests/ui/const-generics/mgca/type-const-free-value-type-mismatch.next.stderr b/tests/ui/const-generics/mgca/type-const-free-value-type-mismatch.next.stderr
index d96726829ee0b..3ef6ede90d933 100644
--- a/tests/ui/const-generics/mgca/type-const-free-value-type-mismatch.next.stderr
+++ b/tests/ui/const-generics/mgca/type-const-free-value-type-mismatch.next.stderr
@@ -10,7 +10,7 @@ error[E0284]: type annotations needed
 LL | fn f() -> [u8; const { N }] {}
    |           ^^^^^^^^^^^^^^^^^ cannot infer the value of the constant `_`
    |
-   = note: cannot satisfy `f::{constant#0} == _`
+   = note: cannot satisfy `f::{constant#0}::{constant#0} == _`
 
 error[E0308]: mismatched types
   --> $DIR/type-const-free-value-type-mismatch.rs:11:11
diff --git a/tests/ui/const-generics/mgca/type-const-inherent-value-type-mismatch.next.stderr b/tests/ui/const-generics/mgca/type-const-inherent-value-type-mismatch.next.stderr
index eeabde2d06320..551a1d496e910 100644
--- a/tests/ui/const-generics/mgca/type-const-inherent-value-type-mismatch.next.stderr
+++ b/tests/ui/const-generics/mgca/type-const-inherent-value-type-mismatch.next.stderr
@@ -4,7 +4,7 @@ error[E0284]: type annotations needed
 LL | fn f() -> [u8; const { Struct::N }] {}
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer the value of the constant `_`
    |
-   = note: cannot satisfy `f::{constant#0} == _`
+   = note: cannot satisfy `f::{constant#0}::{constant#0} == _`
 
 error: the constant `"this isn't a usize"` is not of type `usize`
   --> $DIR/type-const-inherent-value-type-mismatch.rs:13:5
diff --git a/tests/ui/const-generics/mgca/type-const-value-type-mismatch.next.stderr b/tests/ui/const-generics/mgca/type-const-value-type-mismatch.next.stderr
index 123c442a3938d..748ffe1294e0a 100644
--- a/tests/ui/const-generics/mgca/type-const-value-type-mismatch.next.stderr
+++ b/tests/ui/const-generics/mgca/type-const-value-type-mismatch.next.stderr
@@ -16,7 +16,7 @@ error[E0284]: type annotations needed
 LL |     fn arr() -> [u8; const { Self::LEN }] {}
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer the value of the constant `_`
    |
-   = note: cannot satisfy `<A as Array>::arr::{constant#0} == _`
+   = note: cannot satisfy `<A as Array>::arr::{constant#0}::{constant#0} == _`
 
 error[E0308]: mismatched types
   --> $DIR/type-const-value-type-mismatch.rs:21:17
diff --git a/tests/ui/delegation/generics/const-predicates-ice-158675.rs b/tests/ui/delegation/generics/const-predicates-ice-158675.rs
new file mode 100644
index 0000000000000..2e88ca8135534
--- /dev/null
+++ b/tests/ui/delegation/generics/const-predicates-ice-158675.rs
@@ -0,0 +1,30 @@
+#![feature(fn_delegation)]
+
+mod original_ice {
+    struct S<const N: usize>;
+
+    trait Trait<T, const B: bool> {
+        fn fun();
+    }
+
+    impl<const N: usize> S<N> {
+        reuse Trait::<S<N>, N>::fun;
+        //~^ ERROR: the constant `N` is not of type `bool`
+    }
+}
+
+mod with_child_constants {
+    struct S<const N: usize>;
+
+    trait Trait<T, const B: bool> {
+        fn fun<const C: char>();
+    }
+
+    impl<const N: usize> S<N> {
+        reuse Trait::<S<N>, N>::fun::<N>;
+        //~^ ERROR: the constant `N` is not of type `bool`
+        //~| ERROR: the constant `N` is not of type `char`
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/delegation/generics/const-predicates-ice-158675.stderr b/tests/ui/delegation/generics/const-predicates-ice-158675.stderr
new file mode 100644
index 0000000000000..6dbf017294822
--- /dev/null
+++ b/tests/ui/delegation/generics/const-predicates-ice-158675.stderr
@@ -0,0 +1,42 @@
+error: the constant `N` is not of type `bool`
+  --> $DIR/const-predicates-ice-158675.rs:11:29
+   |
+LL |         reuse Trait::<S<N>, N>::fun;
+   |                             ^ expected `bool`, found `usize`
+   |
+note: required by a const generic parameter in `original_ice::Trait::fun`
+  --> $DIR/const-predicates-ice-158675.rs:6:20
+   |
+LL |     trait Trait<T, const B: bool> {
+   |                    ^^^^^^^^^^^^^ required by this const generic parameter in `Trait::fun`
+LL |         fn fun();
+   |            --- required by a bound in this associated function
+
+error: the constant `N` is not of type `bool`
+  --> $DIR/const-predicates-ice-158675.rs:24:29
+   |
+LL |         reuse Trait::<S<N>, N>::fun::<N>;
+   |                             ^ expected `bool`, found `usize`
+   |
+note: required by a const generic parameter in `with_child_constants::Trait::fun`
+  --> $DIR/const-predicates-ice-158675.rs:19:20
+   |
+LL |     trait Trait<T, const B: bool> {
+   |                    ^^^^^^^^^^^^^ required by this const generic parameter in `Trait::fun`
+LL |         fn fun<const C: char>();
+   |            --- required by a bound in this associated function
+
+error: the constant `N` is not of type `char`
+  --> $DIR/const-predicates-ice-158675.rs:24:39
+   |
+LL |         reuse Trait::<S<N>, N>::fun::<N>;
+   |                                       ^ expected `char`, found `usize`
+   |
+note: required by a const generic parameter in `with_child_constants::Trait::fun`
+  --> $DIR/const-predicates-ice-158675.rs:20:16
+   |
+LL |         fn fun<const C: char>();
+   |                ^^^^^^^^^^^^^ required by this const generic parameter in `Trait::fun`
+
+error: aborting due to 3 previous errors
+
diff --git a/tests/ui/delegation/hir-crate-items-before-lowering-ices.ice_155125.stderr b/tests/ui/delegation/hir-crate-items-before-lowering-ices.ice_155125.stderr
index d2f0e87ecb593..6675831bddc86 100644
--- a/tests/ui/delegation/hir-crate-items-before-lowering-ices.ice_155125.stderr
+++ b/tests/ui/delegation/hir-crate-items-before-lowering-ices.ice_155125.stderr
@@ -9,13 +9,14 @@ LL |                 reuse foo;
    = note: `foo` must be defined only once in the value namespace of this block
 
 error: complex const arguments must be placed inside of a `const` block
-  --> $DIR/hir-crate-items-before-lowering-ices.rs:10:13
+  --> $DIR/hir-crate-items-before-lowering-ices.rs:10:37
    |
-LL | /             {
+LL |               core::direct_const_arg!({
+   |  _____________________________________^
 LL | |                 fn foo() {}
 LL | |                 reuse foo;
 LL | |                 2
-LL | |             },
+LL | |             }),
    | |_____________^
 
 error: aborting due to 2 previous errors
diff --git a/tests/ui/delegation/hir-crate-items-before-lowering-ices.ice_155164.stderr b/tests/ui/delegation/hir-crate-items-before-lowering-ices.ice_155164.stderr
index 34d1a92ccd225..6164dabe74bff 100644
--- a/tests/ui/delegation/hir-crate-items-before-lowering-ices.ice_155164.stderr
+++ b/tests/ui/delegation/hir-crate-items-before-lowering-ices.ice_155164.stderr
@@ -1,12 +1,13 @@
 error: complex const arguments must be placed inside of a `const` block
-  --> $DIR/hir-crate-items-before-lowering-ices.rs:47:13
+  --> $DIR/hir-crate-items-before-lowering-ices.rs:47:37
    |
-LL | /             {
+LL |               core::direct_const_arg!({
+   |  _____________________________________^
 LL | |
 LL | |                 struct W<I>;
 LL | |                 impl<I> W<I> {
 ...  |
-LL | |             },
+LL | |             }),
    | |_____________^
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/delegation/hir-crate-items-before-lowering-ices.rs b/tests/ui/delegation/hir-crate-items-before-lowering-ices.rs
index b9a7a73732cf3..07f5a1ad1712f 100644
--- a/tests/ui/delegation/hir-crate-items-before-lowering-ices.rs
+++ b/tests/ui/delegation/hir-crate-items-before-lowering-ices.rs
@@ -7,11 +7,11 @@ mod ice_155125 {
     struct S<const N: usize>;
     impl
         S<
-            { //[ice_155125]~ ERROR: complex const arguments must be placed inside of a `const` block
+            core::direct_const_arg!({ //[ice_155125]~ ERROR: complex const arguments must be placed inside of a `const` block
                 fn foo() {}
                 reuse foo; //[ice_155125]~ ERROR: the name `foo` is defined multiple times
                 2
-            },
+            }),
         >
     {
     }
@@ -44,13 +44,13 @@ mod ice_155128 {
 mod ice_155164 {
     struct X<const N: usize, F> {
         inner: std::iter::Map<
-            {
+            core::direct_const_arg!({
             //[ice_155164]~^ ERROR: complex const arguments must be placed inside of a `const` block
                 struct W<I>;
                 impl<I> W<I> {
                     reuse Iterator::fold;
                 }
-            },
+            }),
             F,
         >,
     }
diff --git a/tests/ui/delegation/inside-const-body-ice-155300.rs b/tests/ui/delegation/inside-const-body-ice-155300.rs
index 06addf7e5412d..2d13007bc807b 100644
--- a/tests/ui/delegation/inside-const-body-ice-155300.rs
+++ b/tests/ui/delegation/inside-const-body-ice-155300.rs
@@ -5,12 +5,13 @@ pub struct S<const N: usize>;
 
 impl
     S<
-        { //~ ERROR: complex const arguments must be placed inside of a `const` block
+        core::direct_const_arg!({
+            //~^ ERROR: complex const arguments must be placed inside of a `const` block
             fn foo() {}
             reuse foo::<> as bar;
             reuse bar;
             //~^ ERROR: the name `bar` is defined multiple times
-        },
+        }),
     >
 {
 }
diff --git a/tests/ui/delegation/inside-const-body-ice-155300.stderr b/tests/ui/delegation/inside-const-body-ice-155300.stderr
index 0d2020c997200..f0cb830109f8a 100644
--- a/tests/ui/delegation/inside-const-body-ice-155300.stderr
+++ b/tests/ui/delegation/inside-const-body-ice-155300.stderr
@@ -1,5 +1,5 @@
 error[E0428]: the name `bar` is defined multiple times
-  --> $DIR/inside-const-body-ice-155300.rs:11:13
+  --> $DIR/inside-const-body-ice-155300.rs:12:13
    |
 LL |             reuse foo::<> as bar;
    |             --------------------- previous definition of the value `bar` here
@@ -9,14 +9,15 @@ LL |             reuse bar;
    = note: `bar` must be defined only once in the value namespace of this block
 
 error: complex const arguments must be placed inside of a `const` block
-  --> $DIR/inside-const-body-ice-155300.rs:8:9
+  --> $DIR/inside-const-body-ice-155300.rs:8:33
    |
-LL | /         {
+LL |           core::direct_const_arg!({
+   |  _________________________________^
+LL | |
 LL | |             fn foo() {}
 LL | |             reuse foo::<> as bar;
-LL | |             reuse bar;
-LL | |
-LL | |         },
+...  |
+LL | |         }),
    | |_________^
 
 error: aborting due to 2 previous errors
diff --git a/tests/ui/diagnostic_namespace/on_const/generic_parameters_handling.current.stderr b/tests/ui/diagnostic_namespace/on_const/generic_parameters_handling.current.stderr
new file mode 100644
index 0000000000000..f9e33ff4fac58
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/on_const/generic_parameters_handling.current.stderr
@@ -0,0 +1,11 @@
+error[E0277]: the trait bound `X<u8, &str>: const Y<_>` is not satisfied
+  --> $DIR/generic_parameters_handling.rs:22:6
+   |
+LL |     .blah();
+   |      ^^^^
+   |
+   = note: Self = X<u8, &str>, Z = Z, A = u8, B = &str
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/diagnostic_namespace/on_const/generic_parameters_handling.next.stderr b/tests/ui/diagnostic_namespace/on_const/generic_parameters_handling.next.stderr
new file mode 100644
index 0000000000000..f9e33ff4fac58
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/on_const/generic_parameters_handling.next.stderr
@@ -0,0 +1,11 @@
+error[E0277]: the trait bound `X<u8, &str>: const Y<_>` is not satisfied
+  --> $DIR/generic_parameters_handling.rs:22:6
+   |
+LL |     .blah();
+   |      ^^^^
+   |
+   = note: Self = X<u8, &str>, Z = Z, A = u8, B = &str
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/diagnostic_namespace/on_const/generic_parameters_handling.rs b/tests/ui/diagnostic_namespace/on_const/generic_parameters_handling.rs
new file mode 100644
index 0000000000000..32a0caf96988a
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/on_const/generic_parameters_handling.rs
@@ -0,0 +1,25 @@
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
+#![crate_type = "lib"]
+#![feature(diagnostic_on_const, const_trait_impl)]
+
+pub struct X<A, B> {
+    field: (A, B),
+}
+
+pub const trait Y<Z> {
+    fn blah(&self) {}
+}
+
+#[diagnostic::on_const(note = "Self = {Self}, Z = {Z}, A = {A}, B = {B}")]
+impl<Z, A, B> Y<Z> for X<A, B> {}
+
+const _: () = {
+    X {
+        field: (42_u8, "hello"),
+    }
+    .blah();
+    //~^ ERROR the trait bound `X<u8, &str>: const Y<_>` is not satisfied [E0277]
+    //~| NOTE Self = X<u8, &str>, Z = Z, A = u8, B = &str
+};
diff --git a/tests/ui/diagnostic_namespace/on_const/malformed_format_literals.rs b/tests/ui/diagnostic_namespace/on_const/malformed_format_literals.rs
new file mode 100644
index 0000000000000..0c36ce25febb5
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/on_const/malformed_format_literals.rs
@@ -0,0 +1,25 @@
+#![crate_type = "lib"]
+#![feature(diagnostic_on_const)]
+#![feature(const_trait_impl)]
+
+pub struct X;
+
+const trait Y {
+    fn blah(&self) {}
+}
+
+#[diagnostic::on_const(
+    message = "my message {Foo}",
+    //~^ WARN unknown parameter `Foo`
+    label = "my label {Bar}",
+    //~^ WARN unknown parameter `Bar`
+    note = "my label {Baz}",
+    //~^ WARN unknown parameter `Baz`
+)]
+impl Y for X {}
+
+const _: () = {
+    X {}.blah();
+    //~^ ERROR my message {Foo} [E0277]
+
+};
diff --git a/tests/ui/diagnostic_namespace/on_const/malformed_format_literals.stderr b/tests/ui/diagnostic_namespace/on_const/malformed_format_literals.stderr
new file mode 100644
index 0000000000000..48bdc2c239a85
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/on_const/malformed_format_literals.stderr
@@ -0,0 +1,36 @@
+warning: unknown parameter `Foo`
+  --> $DIR/malformed_format_literals.rs:12:28
+   |
+LL |     message = "my message {Foo}",
+   |                            ^^^
+   |
+   = help: expect either a generic argument name or `{Self}` as format argument
+   = note: `#[warn(malformed_diagnostic_format_literals)]` (part of `#[warn(unknown_or_malformed_diagnostic_attributes)]`) on by default
+
+warning: unknown parameter `Bar`
+  --> $DIR/malformed_format_literals.rs:14:24
+   |
+LL |     label = "my label {Bar}",
+   |                        ^^^
+   |
+   = help: expect either a generic argument name or `{Self}` as format argument
+
+warning: unknown parameter `Baz`
+  --> $DIR/malformed_format_literals.rs:16:23
+   |
+LL |     note = "my label {Baz}",
+   |                       ^^^
+   |
+   = help: expect either a generic argument name or `{Self}` as format argument
+
+error[E0277]: my message {Foo}
+  --> $DIR/malformed_format_literals.rs:22:10
+   |
+LL |     X {}.blah();
+   |          ^^^^ my label {Bar}
+   |
+   = note: my label {Baz}
+
+error: aborting due to 1 previous error; 3 warnings emitted
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/splat/arg-count-ice-issue-158482.rs b/tests/ui/splat/arg-count-ice-issue-158482.rs
new file mode 100644
index 0000000000000..27f036b8a5906
--- /dev/null
+++ b/tests/ui/splat/arg-count-ice-issue-158482.rs
@@ -0,0 +1,14 @@
+//! Checks that an incorrect number of arguments to splat doesn't panic.
+
+#![feature(splat)]
+struct Foo {}
+trait BarTrait {
+    fn trait_assoc<W>(w: W, #[splat] _s: (u32, u8));
+}
+impl BarTrait for Foo {
+    fn trait_assoc<W>(_w: W, #[splat] _s: (u32, u8)) {}
+}
+fn main() {
+    Foo::trait_assoc()
+    //~^ ERROR: this splatted function takes 3 arguments, but 0 were provided
+}
diff --git a/tests/ui/splat/arg-count-ice-issue-158482.stderr b/tests/ui/splat/arg-count-ice-issue-158482.stderr
new file mode 100644
index 0000000000000..b7f3a8070f2b2
--- /dev/null
+++ b/tests/ui/splat/arg-count-ice-issue-158482.stderr
@@ -0,0 +1,9 @@
+error[E0057]: this splatted function takes 3 arguments, but 0 were provided
+  --> $DIR/arg-count-ice-issue-158482.rs:12:5
+   |
+LL |     Foo::trait_assoc()
+   |     ^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0057`.
diff --git a/tests/ui/splat/reject-closure-issue-158605.rs b/tests/ui/splat/reject-closure-issue-158605.rs
new file mode 100644
index 0000000000000..7464bab2a77d2
--- /dev/null
+++ b/tests/ui/splat/reject-closure-issue-158605.rs
@@ -0,0 +1,30 @@
+//! Checks that closures and rust-call functions can't be splatted.
+//! This should be rejected until we decide on sensible semantics.
+
+#![feature(splat, unboxed_closures, tuple_trait)]
+#![expect(incomplete_features)]
+
+use std::marker::Tuple;
+
+trait Trait: Tuple + Sized {
+    extern "rust-call" fn method(#[splat] self: Self);
+    //~^ ERROR: `#[splat]` is not allowed in the arguments of functions with the `rust-call` ABI
+}
+
+impl Trait for (i32, i64) {
+    extern "rust-call" fn method(#[splat] self: Self) {
+        //~^ ERROR: `#[splat]` is not allowed in the arguments of functions with the `rust-call` ABI
+        println!("{self:?}");
+    }
+}
+
+fn main() {
+    (|#[splat] x: i32| {
+        //~^ ERROR `#[splat]` is not allowed on closure arguments
+        println!("{x}");
+    })(1);
+
+    (1_i32, 2_i64).method();
+    Trait::method(3_i32, 4_i64);
+    //~^ ERROR functions with the "rust-call" ABI must take a single non-self tuple argument
+}
diff --git a/tests/ui/splat/reject-closure-issue-158605.stderr b/tests/ui/splat/reject-closure-issue-158605.stderr
new file mode 100644
index 0000000000000..c23211459a0db
--- /dev/null
+++ b/tests/ui/splat/reject-closure-issue-158605.stderr
@@ -0,0 +1,36 @@
+error: `#[splat]` is not allowed in the arguments of functions with the `rust-call` ABI
+  --> $DIR/reject-closure-issue-158605.rs:10:5
+   |
+LL |     extern "rust-call" fn method(#[splat] self: Self);
+   |     ^^^^^^^^^^^^^^^^^^           ^^^^^^^^
+   |
+   = help: remove `#[splat]` or change the ABI
+
+error: `#[splat]` is not allowed in the arguments of functions with the `rust-call` ABI
+  --> $DIR/reject-closure-issue-158605.rs:15:5
+   |
+LL |     extern "rust-call" fn method(#[splat] self: Self) {
+   |     ^^^^^^^^^^^^^^^^^^           ^^^^^^^^
+   |
+   = help: remove `#[splat]` or change the ABI
+
+error: `#[splat]` is not allowed on closure arguments
+  --> $DIR/reject-closure-issue-158605.rs:22:7
+   |
+LL |       (|#[splat] x: i32| {
+   |  _______^^^^^^^^_________^
+LL | |
+LL | |         println!("{x}");
+LL | |     })(1);
+   | |_____^
+   |
+   = help: remove `#[splat]` or turn the closure into a function
+
+error: functions with the "rust-call" ABI must take a single non-self tuple argument
+  --> $DIR/reject-closure-issue-158605.rs:28:26
+   |
+LL |     Trait::method(3_i32, 4_i64);
+   |                          ^^^^^
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/splat/splat-255-limit-fail.rs b/tests/ui/splat/splat-255-limit-fail.rs
index 31767f11d999b..f19ce37bc4566 100644
--- a/tests/ui/splat/splat-255-limit-fail.rs
+++ b/tests/ui/splat/splat-255-limit-fail.rs
@@ -47,7 +47,7 @@ fn s_255_terminal(
     _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A,
     _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A,
     _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A,
-    #[splat] (_a, _b): (u32, i8), //~ ERROR `#[splat]` is not supported on argument index 255
+    #[splat] (_a, _b): (u32, i8), //~ ERROR `#[splat]` is only supported on argument index 254 or less, this `#[splat]` is on index 255
 ) {}
 
 #[rustfmt::skip]
@@ -68,7 +68,7 @@ fn s_256_terminal(
     _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A,
     _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A,
     _: A,
-    #[splat] (_a, _b): (u32, i8), //~ ERROR `#[splat]` is not supported on argument index 256
+    #[splat] (_a, _b): (u32, i8), //~ ERROR `#[splat]` is only supported on argument index 254 or less, this `#[splat]` is on index 256
 ) {}
 
 #[rustfmt::skip]
@@ -88,7 +88,7 @@ fn s_255_non_terminal(
     _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A,
     _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A,
     _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A,
-    #[splat] (_a, _b): (u32, i8), //~ ERROR `#[splat]` is not supported on argument index 255
+    #[splat] (_a, _b): (u32, i8), //~ ERROR `#[splat]` is only supported on argument index 254 or less, this `#[splat]` is on index 255
     _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A,
 ) {}
 
@@ -110,7 +110,7 @@ fn s_256_non_terminal(
     _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A,
     _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A, _: A,
     _: A,
-    #[splat] (_a, _b): (u32, i8), //~ ERROR `#[splat]` is not supported on argument index 256
+    #[splat] (_a, _b): (u32, i8), //~ ERROR `#[splat]` is only supported on argument index 254 or less, this `#[splat]` is on index 256
     _: A,
 ) {}
 
diff --git a/tests/ui/splat/splat-255-limit-fail.stderr b/tests/ui/splat/splat-255-limit-fail.stderr
index da62da8aa605b..a3a0b9cf3d350 100644
--- a/tests/ui/splat/splat-255-limit-fail.stderr
+++ b/tests/ui/splat/splat-255-limit-fail.stderr
@@ -1,32 +1,32 @@
-error: `#[splat]` is not supported on argument index 255
+error: `#[splat]` is only supported on argument index 254 or less, this `#[splat]` is on index 255
   --> $DIR/splat-255-limit-fail.rs:50:5
    |
 LL |     #[splat] (_a, _b): (u32, i8),
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `#[splat]` is not supported here
+   |     ^^^^^^^^ `#[splat]` is not supported here
    |
    = help: remove `#[splat]`, or use it on an argument closer to the start of the argument list
 
-error: `#[splat]` is not supported on argument index 256
+error: `#[splat]` is only supported on argument index 254 or less, this `#[splat]` is on index 256
   --> $DIR/splat-255-limit-fail.rs:71:5
    |
 LL |     #[splat] (_a, _b): (u32, i8),
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `#[splat]` is not supported here
+   |     ^^^^^^^^ `#[splat]` is not supported here
    |
    = help: remove `#[splat]`, or use it on an argument closer to the start of the argument list
 
-error: `#[splat]` is not supported on argument index 255
+error: `#[splat]` is only supported on argument index 254 or less, this `#[splat]` is on index 255
   --> $DIR/splat-255-limit-fail.rs:91:5
    |
 LL |     #[splat] (_a, _b): (u32, i8),
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `#[splat]` is not supported here
+   |     ^^^^^^^^ `#[splat]` is not supported here
    |
    = help: remove `#[splat]`, or use it on an argument closer to the start of the argument list
 
-error: `#[splat]` is not supported on argument index 256
+error: `#[splat]` is only supported on argument index 254 or less, this `#[splat]` is on index 256
   --> $DIR/splat-255-limit-fail.rs:113:5
    |
 LL |     #[splat] (_a, _b): (u32, i8),
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `#[splat]` is not supported here
+   |     ^^^^^^^^ `#[splat]` is not supported here
    |
    = help: remove `#[splat]`, or use it on an argument closer to the start of the argument list
 
diff --git a/tests/ui/splat/splat-async-fn-tuple-fail.rs b/tests/ui/splat/splat-async-fn-tuple-fail.rs
index a1f67dfe606d6..308a6c4a2131e 100644
--- a/tests/ui/splat/splat-async-fn-tuple-fail.rs
+++ b/tests/ui/splat/splat-async-fn-tuple-fail.rs
@@ -8,7 +8,7 @@ async fn async_wrong_type(#[splat] _x: u32) {}
 //~^ ERROR cannot use splat attribute; the splatted argument type must be a tuple or unit, not a u32
 
 async fn async_multi_splat(#[splat] (_a, _b): (u32, i8), #[splat] (_c, _d): (u32, i8)) {}
-//~^ ERROR multiple `#[splat]`s are not allowed in the same function
+//~^ ERROR multiple `#[splat]`s are not allowed in the same function argument list
 
 fn main() {
     async_wrong_type(1u32);
diff --git a/tests/ui/splat/splat-async-fn-tuple-fail.stderr b/tests/ui/splat/splat-async-fn-tuple-fail.stderr
index e643b29c88c8a..7c73382d73a5a 100644
--- a/tests/ui/splat/splat-async-fn-tuple-fail.stderr
+++ b/tests/ui/splat/splat-async-fn-tuple-fail.stderr
@@ -1,8 +1,8 @@
-error: multiple `#[splat]`s are not allowed in the same function
+error: multiple `#[splat]`s are not allowed in the same function argument list
   --> $DIR/splat-async-fn-tuple-fail.rs:10:28
    |
 LL | async fn async_multi_splat(#[splat] (_a, _b): (u32, i8), #[splat] (_c, _d): (u32, i8)) {}
-   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                            ^^^^^^^^                      ^^^^^^^^
    |
    = help: remove `#[splat]` from all but one argument
 
diff --git a/tests/ui/splat/splat-fn-ptr-cast.rs b/tests/ui/splat/splat-fn-ptr-cast.rs
new file mode 100644
index 0000000000000..918e26c4dd741
--- /dev/null
+++ b/tests/ui/splat/splat-fn-ptr-cast.rs
@@ -0,0 +1,17 @@
+//@ run-fail
+//! Test never type casts to splatted and non-splatted functions.
+
+#![allow(incomplete_features)]
+#![feature(splat)]
+#![allow(unused_features)]
+
+fn main() {
+    // Bug #158603 regression test variants
+    #[rustfmt::skip]
+    let _x: fn(#[splat] (f32,)) = None.unwrap();
+    // FIXME(splat): causes an ICE until #158603 is fixed
+    //x(1.0);
+
+    let x: fn((i32,)) = None.unwrap();
+    x((1,));
+}
diff --git a/tests/ui/splat/splat-fn-ptr-ptr-tuple.rs b/tests/ui/splat/splat-fn-ptr-ptr-tuple.rs
new file mode 100644
index 0000000000000..321511f270915
--- /dev/null
+++ b/tests/ui/splat/splat-fn-ptr-ptr-tuple.rs
@@ -0,0 +1,42 @@
+//! Test using `#[splat]` on tuple arguments of pointers to pointers to simple functions.
+//! Currently ICEs, but if we fix it, we'll want to know and update this test to pass.
+
+//@ failure-status: 101
+
+//@ normalize-stderr: ".*error:.*compiler/([^:]+):\d{1,}:\d{1,}:(.*)" -> "error: compiler/$1:LL:CC:$2"
+//@ normalize-stderr: "thread.*panicked at .*compiler.*" -> ""
+//@ normalize-stderr: "note: rustc.*running on.*" -> "note: rustc {version} running on {platform}"
+//@ normalize-stderr: "note: compiler flags.*\n\n" -> ""
+//@ normalize-stderr: " +\d{1,}: .*\n" -> ""
+//@ normalize-stderr: " + at .*\n" -> ""
+//@ normalize-stderr: ".*omitted \d{1,} frames?.*\n" -> ""
+//@ normalize-stderr: ".*note: Some details are omitted.*\n" -> ""
+//@ normalize-stderr: ".*--> .*/splat-fn-ptr-tuple.rs:\d{1,}:\d{1,}.*\n" -> ""
+
+#![allow(incomplete_features)]
+#![feature(splat)]
+
+fn tuple_args(#[splat] (_a, _b): (u32, i8)) {}
+
+fn splat_non_terminal_arg(#[splat] (_a, _b): (u32, i8), _c: f64) {}
+
+fn main() {
+    // FIXME(splat): not currently supported, can be supported when we no longer require a DefId in
+    // MIR lowering
+    // FIXME(rustfmt): the attribute gets deleted by rustfmt
+    #[rustfmt::skip]
+    let fn_pp: *const fn(#[splat] (u32, i8)) = tuple_args as *const fn(#[splat] (u32, i8));
+    unsafe {
+        (*fn_pp)(1, 2); //~ ERROR splatted FnPtr side-tables are not yet implemented
+        // The ICE means that code after this line is not fully checked
+        (*fn_pp)(1u32, 2i8);
+    }
+
+    #[rustfmt::skip]
+    let fn_pp: *const fn(#[splat] (u32, i8), f64) =
+        splat_non_terminal_arg as *const fn(#[splat] (u32, i8), f64);
+    unsafe {
+        (*fn_pp)(1, 2, 3.5);
+        (*fn_pp)(1u32, 2i8, 3.5f64);
+    }
+}
diff --git a/tests/ui/splat/splat-fn-ptr-ptr-tuple.stderr b/tests/ui/splat/splat-fn-ptr-ptr-tuple.stderr
new file mode 100644
index 0000000000000..726561b366f80
--- /dev/null
+++ b/tests/ui/splat/splat-fn-ptr-ptr-tuple.stderr
@@ -0,0 +1,24 @@
+error: compiler/rustc_mir_build/src/thir/cx/expr.rs:LL:CC: splatted FnPtr side-tables are not yet implemented
+  --> $DIR/splat-fn-ptr-ptr-tuple.rs:30:9
+   |
+LL |         (*fn_pp)(1, 2);
+   |         ^^^^^^^^^^^^^^
+
+
+
+Box<dyn Any>
+stack backtrace:
+
+note: we would appreciate a bug report: https://github.com/rust-lang/rust/issues/new?labels=C-bug%2C+I-ICE%2C+T-compiler&template=ice.md
+
+note: please make sure that you have updated to the latest nightly
+
+note: rustc {version} running on {platform}
+
+query stack during panic:
+#0 [thir_body] building THIR for `main`
+#1 [check_unsafety] unsafety-checking `main`
+#2 [analysis] running analysis passes on crate `splat_fn_ptr_ptr_tuple`
+end of query stack
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/splat/splat-fn-ptr-rust-call.rs b/tests/ui/splat/splat-fn-ptr-rust-call.rs
new file mode 100644
index 0000000000000..a9fe48a459d8a
--- /dev/null
+++ b/tests/ui/splat/splat-fn-ptr-rust-call.rs
@@ -0,0 +1,18 @@
+//! Test using `#[splat]` on tuple arguments of pointers to "rust-call" functions.
+//! Currently ICEs at a later stage, but AST validation should catch it earlier.
+
+#![allow(incomplete_features)]
+#![feature(splat)]
+#![feature(unboxed_closures)]
+
+extern "rust-call" fn f(#[splat] _: ()) {} //~ ERROR `#[splat]` is not allowed in the arguments of functions with the `rust-call` ABI
+
+fn main() {
+    // FIXME(rustfmt): the attribute gets deleted by rustfmt
+    #[rustfmt::skip]
+    let f2: extern "rust-call" fn(#[splat] ()) = f; //~ ERROR `#[splat]` is not allowed in the arguments of functions with the `rust-call` ABI
+    // These errors could be confusing, but they're useful if the user meant to use "rust-call"
+    // instead of #[splat]
+    f(); //~ ERROR functions with the "rust-call" ABI must take a single non-self tuple argument
+    f2(); //~ ERROR functions with the "rust-call" ABI must take a single non-self tuple argument
+}
diff --git a/tests/ui/splat/splat-fn-ptr-rust-call.stderr b/tests/ui/splat/splat-fn-ptr-rust-call.stderr
new file mode 100644
index 0000000000000..6eacdfab5faac
--- /dev/null
+++ b/tests/ui/splat/splat-fn-ptr-rust-call.stderr
@@ -0,0 +1,30 @@
+error: `#[splat]` is not allowed in the arguments of functions with the `rust-call` ABI
+  --> $DIR/splat-fn-ptr-rust-call.rs:8:1
+   |
+LL | extern "rust-call" fn f(#[splat] _: ()) {}
+   | ^^^^^^^^^^^^^^^^^^      ^^^^^^^^
+   |
+   = help: remove `#[splat]` or change the ABI
+
+error: `#[splat]` is not allowed in the arguments of functions with the `rust-call` ABI
+  --> $DIR/splat-fn-ptr-rust-call.rs:13:13
+   |
+LL |     let f2: extern "rust-call" fn(#[splat] ()) = f;
+   |             ^^^^^^^^^^^^^^^^^^    ^^^^^^^^
+   |
+   = help: remove `#[splat]` or change the ABI
+
+error: functions with the "rust-call" ABI must take a single non-self tuple argument
+  --> $DIR/splat-fn-ptr-rust-call.rs:16:5
+   |
+LL |     f();
+   |     ^^^
+
+error: functions with the "rust-call" ABI must take a single non-self tuple argument
+  --> $DIR/splat-fn-ptr-rust-call.rs:17:5
+   |
+LL |     f2();
+   |     ^^^^
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/splat/splat-fn-ptr-tuple-const.rs b/tests/ui/splat/splat-fn-ptr-tuple-const.rs
new file mode 100644
index 0000000000000..faf8501cc650a
--- /dev/null
+++ b/tests/ui/splat/splat-fn-ptr-tuple-const.rs
@@ -0,0 +1,34 @@
+//! Test using `#[splat]` on tuple arguments of generic function constants.
+//! Currently ICEs (#158603), but if we fix it, we'll want to know and update this test to pass.
+
+//@ failure-status: 101
+
+//@ normalize-stderr: ".*error:.*compiler/([^:]+):\d{1,}:\d{1,}:(.*)" -> "error: compiler/$1:LL:CC:$2"
+//@ normalize-stderr: "thread.*panicked at .*compiler.*" -> ""
+//@ normalize-stderr: "note: rustc.*running on.*" -> "note: rustc {version} running on {platform}"
+//@ normalize-stderr: "note: compiler flags.*\n\n" -> ""
+//@ normalize-stderr: " +\d{1,}: .*\n" -> ""
+//@ normalize-stderr: " + at .*\n" -> ""
+//@ normalize-stderr: ".*omitted \d{1,} frames?.*\n" -> ""
+//@ normalize-stderr: ".*note: Some details are omitted.*\n" -> ""
+//@ normalize-stderr: ".*--> .*/splat-fn-ptr-tuple.rs:\d{1,}:\d{1,}.*\n" -> ""
+
+#![allow(incomplete_features)]
+#![feature(splat, tuple_trait)]
+
+use std::marker::Tuple;
+
+fn f<Args: Tuple>(#[splat] args: Args) {}
+
+fn main() {
+    // FIXME(splat): not currently supported, can be supported when we no longer require a DefId in
+    // MIR lowering
+    // FIXME(rustfmt): the attribute gets deleted by rustfmt
+    #[rustfmt::skip]
+    const F2: fn(#[splat] (u8, u32)) = f::<(u8, u32)>;
+    const R2: () = F2(1, 2); //~ ERROR splatted FnPtr side-tables are not yet implemented
+
+    #[rustfmt::skip]
+    const F1: fn(#[splat] ((u8, u32),)) = f::<((u8, u32),)>;
+    const R1: () = F1((1, 2)); //~ ERROR splatted FnPtr side-tables are not yet implemented
+}
diff --git a/tests/ui/splat/splat-fn-ptr-tuple-const.stderr b/tests/ui/splat/splat-fn-ptr-tuple-const.stderr
new file mode 100644
index 0000000000000..1767782a9535e
--- /dev/null
+++ b/tests/ui/splat/splat-fn-ptr-tuple-const.stderr
@@ -0,0 +1,52 @@
+error: compiler/rustc_mir_build/src/thir/cx/expr.rs:LL:CC: splatted FnPtr side-tables are not yet implemented
+  --> $DIR/splat-fn-ptr-tuple-const.rs:29:20
+   |
+LL |     const R2: () = F2(1, 2);
+   |                    ^^^^^^^^
+
+
+
+Box<dyn Any>
+stack backtrace:
+
+note: we would appreciate a bug report: https://github.com/rust-lang/rust/issues/new?labels=C-bug%2C+I-ICE%2C+T-compiler&template=ice.md
+
+note: please make sure that you have updated to the latest nightly
+
+note: rustc {version} running on {platform}
+
+query stack during panic:
+#0 [thir_body] building THIR for `main::R2`
+#1 [check_match] match-checking `main::R2`
+#2 [mir_built] building MIR for `main::R2`
+#3 [trivial_const] checking if `main::R2` is a trivial const
+#4 [eval_to_const_value_raw] simplifying constant for the type system `main::R2`
+#5 [analysis] running analysis passes on crate `splat_fn_ptr_tuple_const`
+end of query stack
+error: compiler/rustc_mir_build/src/thir/cx/expr.rs:LL:CC: splatted FnPtr side-tables are not yet implemented
+  --> $DIR/splat-fn-ptr-tuple-const.rs:33:20
+   |
+LL |     const R1: () = F1((1, 2));
+   |                    ^^^^^^^^^^
+
+
+
+Box<dyn Any>
+stack backtrace:
+
+note: we would appreciate a bug report: https://github.com/rust-lang/rust/issues/new?labels=C-bug%2C+I-ICE%2C+T-compiler&template=ice.md
+
+note: please make sure that you have updated to the latest nightly
+
+note: rustc {version} running on {platform}
+
+query stack during panic:
+#0 [thir_body] building THIR for `main::R1`
+#1 [check_match] match-checking `main::R1`
+#2 [mir_built] building MIR for `main::R1`
+#3 [trivial_const] checking if `main::R1` is a trivial const
+#4 [eval_to_const_value_raw] simplifying constant for the type system `main::R1`
+#5 [analysis] running analysis passes on crate `splat_fn_ptr_tuple_const`
+end of query stack
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/splat/splat-fn-ptr-tuple.rs b/tests/ui/splat/splat-fn-ptr-tuple.rs
index 297dbc0457794..395d30baedaaf 100644
--- a/tests/ui/splat/splat-fn-ptr-tuple.rs
+++ b/tests/ui/splat/splat-fn-ptr-tuple.rs
@@ -1,3 +1,6 @@
+//! Test using `#[splat]` on tuple arguments of pointers to simple functions.
+//! Currently ICEs, but if we fix it, we'll want to know and update this test to pass.
+
 //@ failure-status: 101
 
 //@ normalize-stderr: ".*error:.*compiler/([^:]+):\d{1,}:\d{1,}:(.*)" -> "error: compiler/$1:LL:CC:$2"
@@ -10,9 +13,6 @@
 //@ normalize-stderr: ".*note: Some details are omitted.*\n" -> ""
 //@ normalize-stderr: ".*--> .*/splat-fn-ptr-tuple.rs:\d{1,}:\d{1,}.*\n" -> ""
 
-//! Test using `#[splat]` on tuple arguments of simple functions.
-//! Currently ICEs, but if we fix it, we'll want to know and update this test to pass.
-
 #![allow(incomplete_features)]
 #![feature(splat)]
 
@@ -24,10 +24,10 @@ fn main() {
     // FIXME(splat): not currently supported, can be supported when we no longer require a DefId in
     // MIR lowering
     // FIXME(rustfmt): the attribute gets deleted by rustfmt
-    // Functions
     #[rustfmt::skip]
     let fn_ptr: fn(#[splat] (u32, i8)) = tuple_args;
-    fn_ptr(1, 2); //~ ERROR no splatted def for function or method callee
+    fn_ptr(1, 2); //~ ERROR splatted FnPtr side-tables are not yet implemented
+    // The ICE means that code after this line is not fully checked
     fn_ptr(1u32, 2i8);
 
     // FIXME(splat): should splatted functions be callable with tupled and un-tupled arguments?
@@ -39,15 +39,8 @@ fn main() {
     fn_ptr(1, 2, 3.5);
     fn_ptr(1u32, 2i8, 3.5f64);
 
-    // Function pointers
-    #[rustfmt::skip]
-    let fn_ptr: *const fn(#[splat] (u32, i8)) = tuple_args as *const fn(#[splat] (u32, i8));
-    (*fn_ptr)(1, 2);
-    (*fn_ptr)(1u32, 2i8);
-
+    // Bug #158603 regression test
     #[rustfmt::skip]
-    let fn_ptr: *const fn(#[splat] (u32, i8), f64) =
-        splat_non_terminal_arg as *const fn(#[splat] (u32, i8), f64);
-    (*fn_ptr)(1, 2, 3.5);
-    (*fn_ptr)(1u32, 2i8, 3.5f64);
+    let x: fn(#[splat] (i32,)) = None.unwrap();
+    x(1);
 }
diff --git a/tests/ui/splat/splat-fn-ptr-tuple.stderr b/tests/ui/splat/splat-fn-ptr-tuple.stderr
index a69175bd5e886..4cc861cafe968 100644
--- a/tests/ui/splat/splat-fn-ptr-tuple.stderr
+++ b/tests/ui/splat/splat-fn-ptr-tuple.stderr
@@ -1,4 +1,4 @@
-error: compiler/rustc_mir_build/src/thir/cx/expr.rs:LL:CC: no splatted def for function or method callee
+error: compiler/rustc_mir_build/src/thir/cx/expr.rs:LL:CC: splatted FnPtr side-tables are not yet implemented
    |
 LL |     fn_ptr(1, 2);
    |     ^^^^^^^^^^^^
diff --git a/tests/ui/splat/splat-invalid.rs b/tests/ui/splat/splat-invalid.rs
index 2c4bf57ef972a..1fe4d131fc584 100644
--- a/tests/ui/splat/splat-invalid.rs
+++ b/tests/ui/splat/splat-invalid.rs
@@ -4,14 +4,32 @@
 #![feature(splat)]
 #![feature(c_variadic)]
 
-fn multisplat_bad(#[splat] (_a, _b): (u32, i8), #[splat] (_c, _d): (u32, i8)) {}
-//~^ ERROR multiple `#[splat]`s are not allowed in the same function
+fn multisplat_fn_bad(#[splat] (_a, _b): (u32, i8), #[splat] (_c, _d): (u32, i8)) {}
+//~^ ERROR multiple `#[splat]`s are not allowed in the same function argument list
+
+fn multisplat_arg_bad(
+    #[splat]
+    #[splat]
+    //~^ ERROR  multiple `splat` attributes
+    (_a, _b): (u32, i8),
+) {
+}
+
+fn multisplat_arg_fn_bad(
+    #[splat]
+    //~^ ERROR multiple `#[splat]`s are not allowed in the same function argument list
+    #[splat]
+    //~^ ERROR  multiple `splat` attributes
+    (_a, _b): (u32, i8),
+    #[splat] (_c, _d): (u32, i8),
+) {
+}
 
 unsafe extern "C" fn splat_variadic(#[splat] (_a, _b): (u32, i8), varargs: ...) {}
-//~^ ERROR `...` and `#[splat]` are not allowed in the same function
+//~^ ERROR `...` and `#[splat]` are not allowed in the same function argument list
 
 unsafe extern "C" fn splat_variadic2(varargs: ..., #[splat] (_a, _b): (u32, i8)) {}
-//~^ ERROR `...` and `#[splat]` are not allowed in the same function
+//~^ ERROR `...` and `#[splat]` are not allowed in the same function argument list
 //~| ERROR `...` must be the last argument of a C-variadic function
 
 extern "C" {
diff --git a/tests/ui/splat/splat-invalid.stderr b/tests/ui/splat/splat-invalid.stderr
index 74c54c00cd285..86b1dbbb7e44b 100644
--- a/tests/ui/splat/splat-invalid.stderr
+++ b/tests/ui/splat/splat-invalid.stderr
@@ -1,35 +1,49 @@
-error: multiple `#[splat]`s are not allowed in the same function
-  --> $DIR/splat-invalid.rs:7:19
+error: multiple `#[splat]`s are not allowed in the same function argument list
+  --> $DIR/splat-invalid.rs:7:22
    |
-LL | fn multisplat_bad(#[splat] (_a, _b): (u32, i8), #[splat] (_c, _d): (u32, i8)) {}
-   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | fn multisplat_fn_bad(#[splat] (_a, _b): (u32, i8), #[splat] (_c, _d): (u32, i8)) {}
+   |                      ^^^^^^^^                      ^^^^^^^^
    |
    = help: remove `#[splat]` from all but one argument
 
-error: `...` and `#[splat]` are not allowed in the same function
-  --> $DIR/splat-invalid.rs:10:37
+error: multiple `#[splat]`s are not allowed in the same function argument list
+  --> $DIR/splat-invalid.rs:19:5
+   |
+LL |     #[splat]
+   |     ^^^^^^^^
+LL |
+LL |     #[splat]
+   |     ^^^^^^^^
+...
+LL |     #[splat] (_c, _d): (u32, i8),
+   |     ^^^^^^^^
+   |
+   = help: remove `#[splat]` from all but one argument
+
+error: `...` and `#[splat]` are not allowed in the same function argument list
+  --> $DIR/splat-invalid.rs:28:37
    |
 LL | unsafe extern "C" fn splat_variadic(#[splat] (_a, _b): (u32, i8), varargs: ...) {}
-   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^
+   |                                     ^^^^^^^^                      ^^^^^^^^^^^^
    |
    = help: remove `#[splat]` or remove `...`
 
 error: `...` must be the last argument of a C-variadic function
-  --> $DIR/splat-invalid.rs:13:38
+  --> $DIR/splat-invalid.rs:31:38
    |
 LL | unsafe extern "C" fn splat_variadic2(varargs: ..., #[splat] (_a, _b): (u32, i8)) {}
    |                                      ^^^^^^^^^^^^
 
-error: `...` and `#[splat]` are not allowed in the same function
-  --> $DIR/splat-invalid.rs:13:38
+error: `...` and `#[splat]` are not allowed in the same function argument list
+  --> $DIR/splat-invalid.rs:31:38
    |
 LL | unsafe extern "C" fn splat_variadic2(varargs: ..., #[splat] (_a, _b): (u32, i8)) {}
-   |                                      ^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                                      ^^^^^^^^^^^^  ^^^^^^^^
    |
    = help: remove `#[splat]` or remove `...`
 
 error: incorrect function inside `extern` block
-  --> $DIR/splat-invalid.rs:18:8
+  --> $DIR/splat-invalid.rs:36:8
    |
 LL | extern "C" {
    | ---------- `extern` blocks define existing foreign functions and functions inside of them cannot have a body
@@ -39,16 +53,16 @@ LL |     fn splat_variadic3(#[splat] (_a, _b): (u32, i8), ...) {}
    = help: you might have meant to write a function accessible through FFI, which can be done by writing `extern fn` outside of the `extern` block
    = note: for more information, visit https://doc.rust-lang.org/std/keyword.extern.html
 
-error: `...` and `#[splat]` are not allowed in the same function
-  --> $DIR/splat-invalid.rs:18:24
+error: `...` and `#[splat]` are not allowed in the same function argument list
+  --> $DIR/splat-invalid.rs:36:24
    |
 LL |     fn splat_variadic3(#[splat] (_a, _b): (u32, i8), ...) {}
-   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+   |                        ^^^^^^^^                      ^^^
    |
    = help: remove `#[splat]` or remove `...`
 
 error: incorrect function inside `extern` block
-  --> $DIR/splat-invalid.rs:22:8
+  --> $DIR/splat-invalid.rs:40:8
    |
 LL | extern "C" {
    | ---------- `extern` blocks define existing foreign functions and functions inside of them cannot have a body
@@ -60,27 +74,51 @@ LL |     fn splat_variadic4(..., #[splat] (_a, _b): (u32, i8)) {}
    = note: for more information, visit https://doc.rust-lang.org/std/keyword.extern.html
 
 error: `...` must be the last argument of a C-variadic function
-  --> $DIR/splat-invalid.rs:22:24
+  --> $DIR/splat-invalid.rs:40:24
    |
 LL |     fn splat_variadic4(..., #[splat] (_a, _b): (u32, i8)) {}
    |                        ^^^
 
-error: `...` and `#[splat]` are not allowed in the same function
-  --> $DIR/splat-invalid.rs:22:24
+error: `...` and `#[splat]` are not allowed in the same function argument list
+  --> $DIR/splat-invalid.rs:40:24
    |
 LL |     fn splat_variadic4(..., #[splat] (_a, _b): (u32, i8)) {}
-   |                        ^^^  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                        ^^^  ^^^^^^^^
    |
    = help: remove `#[splat]` or remove `...`
 
+error: multiple `splat` attributes
+  --> $DIR/splat-invalid.rs:12:5
+   |
+LL |     #[splat]
+   |     ^^^^^^^^ help: remove this attribute
+   |
+note: attribute also specified here
+  --> $DIR/splat-invalid.rs:11:5
+   |
+LL |     #[splat]
+   |     ^^^^^^^^
+
+error: multiple `splat` attributes
+  --> $DIR/splat-invalid.rs:21:5
+   |
+LL |     #[splat]
+   |     ^^^^^^^^ help: remove this attribute
+   |
+note: attribute also specified here
+  --> $DIR/splat-invalid.rs:19:5
+   |
+LL |     #[splat]
+   |     ^^^^^^^^
+
 error[E0053]: method `has_splat` has an incompatible type for trait
-  --> $DIR/splat-invalid.rs:42:5
+  --> $DIR/splat-invalid.rs:60:5
    |
 LL |     fn has_splat(_: ()) {}
    |     ^^^^^^^^^^^^^^^^^^^ expected fn with arg 0 splatted, found fn with no splatted arg
    |
 note: type in trait
-  --> $DIR/splat-invalid.rs:34:5
+  --> $DIR/splat-invalid.rs:52:5
    |
 LL |     fn has_splat(#[splat] _: ());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -88,19 +126,19 @@ LL |     fn has_splat(#[splat] _: ());
               found signature `fn(())`
 
 error[E0053]: method `no_splat` has an incompatible type for trait
-  --> $DIR/splat-invalid.rs:44:5
+  --> $DIR/splat-invalid.rs:62:5
    |
 LL |     fn no_splat(#[splat] _: (u32, f64)) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected fn with no splatted arg, found fn with arg 0 splatted
    |
 note: type in trait
-  --> $DIR/splat-invalid.rs:36:5
+  --> $DIR/splat-invalid.rs:54:5
    |
 LL |     fn no_splat(_: (u32, f64));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: expected signature `fn((_, _))`
               found signature `fn(#[splat] (_, _))`
 
-error: aborting due to 11 previous errors
+error: aborting due to 14 previous errors
 
 For more information about this error, try `rustc --explain E0053`.
diff --git a/tests/ui/splat/splat-unsafe-fn-tuple-fail.rs b/tests/ui/splat/splat-unsafe-fn-tuple-fail.rs
index 3f29b9d292d22..473aff7891636 100644
--- a/tests/ui/splat/splat-unsafe-fn-tuple-fail.rs
+++ b/tests/ui/splat/splat-unsafe-fn-tuple-fail.rs
@@ -7,7 +7,7 @@ unsafe fn unsafe_wrong_type(#[splat] _x: u32) {}
 //~^ ERROR cannot use splat attribute; the splatted argument type must be a tuple or unit, not a u32
 
 unsafe fn unsafe_multi_splat(#[splat] (_a, _b): (u32, i8), #[splat] (_c, _d): (u32, i8)) {}
-//~^ ERROR multiple `#[splat]`s are not allowed in the same function
+//~^ ERROR multiple `#[splat]`s are not allowed in the same function argument list
 
 fn main() {
     unsafe {
diff --git a/tests/ui/splat/splat-unsafe-fn-tuple-fail.stderr b/tests/ui/splat/splat-unsafe-fn-tuple-fail.stderr
index 67935e170671a..7ad15f0f960e2 100644
--- a/tests/ui/splat/splat-unsafe-fn-tuple-fail.stderr
+++ b/tests/ui/splat/splat-unsafe-fn-tuple-fail.stderr
@@ -1,8 +1,8 @@
-error: multiple `#[splat]`s are not allowed in the same function
+error: multiple `#[splat]`s are not allowed in the same function argument list
   --> $DIR/splat-unsafe-fn-tuple-fail.rs:9:30
    |
 LL | unsafe fn unsafe_multi_splat(#[splat] (_a, _b): (u32, i8), #[splat] (_c, _d): (u32, i8)) {}
-   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                              ^^^^^^^^                      ^^^^^^^^
    |
    = help: remove `#[splat]` from all but one argument
 
diff --git a/tests/ui/suggestions/issue-105645.stderr b/tests/ui/suggestions/issue-105645.stderr
index 2b9a94d8e0ab2..2342c22cfa80a 100644
--- a/tests/ui/suggestions/issue-105645.stderr
+++ b/tests/ui/suggestions/issue-105645.stderr
@@ -7,7 +7,7 @@ LL |     foo(&mut bref);
    |     required by a bound introduced by this call
    |
 help: the trait `std::io::Write` is implemented for `&mut [u8]`
-  --> $SRC_DIR/std/src/io/impls.rs:LL:COL
+  --> $SRC_DIR/core/src/io/impls.rs:LL:COL
 note: required by a bound in `foo`
   --> $DIR/issue-105645.rs:8:21
    |
diff --git a/tests/ui/view-types/auxiliary/hygiene.rs b/tests/ui/view-types/auxiliary/hygiene.rs
new file mode 100644
index 0000000000000..cf842b56e6970
--- /dev/null
+++ b/tests/ui/view-types/auxiliary/hygiene.rs
@@ -0,0 +1,12 @@
+//@ edition:2015
+
+#![feature(view_types, view_type_macro)]
+
+pub use std::view::view_type;
+
+#[macro_export]
+macro_rules! view_bar {
+    () => {
+        $crate::view_type!(Bar.{ async })
+    }
+}
diff --git a/tests/ui/view-types/duplicate_field.rs b/tests/ui/view-types/duplicate_field.rs
new file mode 100644
index 0000000000000..b45580510b6cb
--- /dev/null
+++ b/tests/ui/view-types/duplicate_field.rs
@@ -0,0 +1,30 @@
+#![feature(view_types, view_type_macro)]
+#![allow(unused)]
+
+use std::view::view_type;
+
+struct Foo {
+    bar: usize,
+}
+
+struct Pair(usize);
+
+fn f(
+    _foo: &mut view_type!(Foo.{ bar, bar }),
+    //~^ ERROR field `bar` is already part of the view
+    _pair: &mut view_type!(Pair.{ 0, 0 }),
+    //~^ ERROR field `0` is already part of the view
+) {
+}
+
+impl Foo {
+    fn f(self: &mut view_type!(Self.{ bar, bar })) {}
+    //~^ ERROR field `bar` is already part of the view
+}
+
+impl Pair {
+    fn f(self: &mut view_type!(Self.{ 0, 0 })) {}
+    //~^ ERROR field `0` is already part of the view
+}
+
+fn main() {}
diff --git a/tests/ui/view-types/duplicate_field.stderr b/tests/ui/view-types/duplicate_field.stderr
new file mode 100644
index 0000000000000..f0162f6e0a67d
--- /dev/null
+++ b/tests/ui/view-types/duplicate_field.stderr
@@ -0,0 +1,34 @@
+error: field `bar` is already part of the view
+  --> $DIR/duplicate_field.rs:13:38
+   |
+LL |     _foo: &mut view_type!(Foo.{ bar, bar }),
+   |                                 ---  ^^^
+   |                                 |
+   |                                 field `bar` is declared as viewed here
+
+error: field `0` is already part of the view
+  --> $DIR/duplicate_field.rs:15:38
+   |
+LL |     _pair: &mut view_type!(Pair.{ 0, 0 }),
+   |                                   -  ^
+   |                                   |
+   |                                   field `0` is declared as viewed here
+
+error: field `bar` is already part of the view
+  --> $DIR/duplicate_field.rs:21:44
+   |
+LL |     fn f(self: &mut view_type!(Self.{ bar, bar })) {}
+   |                                       ---  ^^^
+   |                                       |
+   |                                       field `bar` is declared as viewed here
+
+error: field `0` is already part of the view
+  --> $DIR/duplicate_field.rs:26:42
+   |
+LL |     fn f(self: &mut view_type!(Self.{ 0, 0 })) {}
+   |                                       -  ^
+   |                                       |
+   |                                       field `0` is declared as viewed here
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/view-types/hygiene.rs b/tests/ui/view-types/hygiene.rs
new file mode 100644
index 0000000000000..15a9f7f228f90
--- /dev/null
+++ b/tests/ui/view-types/hygiene.rs
@@ -0,0 +1,32 @@
+//@ run-pass
+//@ aux-build: hygiene.rs
+
+#![feature(view_types, view_type_macro, decl_macro)]
+#![allow(unused)]
+
+extern crate hygiene;
+
+use std::view::view_type;
+
+pub macro what($name: ident) {
+    struct Foo {
+        bar: usize,
+        $name: usize,
+    }
+
+    impl Foo {
+        fn f(self: &mut view_type!(Self.{ bar, $name })) {}
+    }
+}
+
+what!(bar);
+
+struct Bar {
+    r#async: (),
+}
+
+impl Bar {
+    fn f(self: hygiene::view_bar!()) {}
+}
+
+fn main() {}
diff --git a/tests/ui/view-types/must-be-struct.rs b/tests/ui/view-types/must-be-struct.rs
index 43dbae587e4ab..fb30ef1234cc5 100644
--- a/tests/ui/view-types/must-be-struct.rs
+++ b/tests/ui/view-types/must-be-struct.rs
@@ -1,6 +1,3 @@
-//@ known-bug: unknown
-//@ run-pass
-
 #![feature(view_types, view_type_macro)]
 #![allow(unused)]
 
@@ -11,9 +8,11 @@ enum Foo {
     Baz,
 }
 
-// The following types are not structs, we expect errors here.
 fn f(_: view_type!(Foo.{})) {}
+//~^ ERROR only structs can be viewed
 fn g(_: view_type!(u8.{})) {}
+//~^ ERROR only structs can be viewed
 fn h(_: view_type!(char.{})) {}
+//~^ ERROR only structs can be viewed
 
 fn main() {}
diff --git a/tests/ui/view-types/must-be-struct.stderr b/tests/ui/view-types/must-be-struct.stderr
new file mode 100644
index 0000000000000..3d47e4903af6c
--- /dev/null
+++ b/tests/ui/view-types/must-be-struct.stderr
@@ -0,0 +1,20 @@
+error: only structs can be viewed
+  --> $DIR/must-be-struct.rs:11:9
+   |
+LL | fn f(_: view_type!(Foo.{})) {}
+   |         ^^^^^^^^^^^^^^^^^^ `Foo` is an enum, it cannot be viewed
+
+error: only structs can be viewed
+  --> $DIR/must-be-struct.rs:13:9
+   |
+LL | fn g(_: view_type!(u8.{})) {}
+   |         ^^^^^^^^^^^^^^^^^ type `u8` cannot be viewed
+
+error: only structs can be viewed
+  --> $DIR/must-be-struct.rs:15:9
+   |
+LL | fn h(_: view_type!(char.{})) {}
+   |         ^^^^^^^^^^^^^^^^^^^ type `char` cannot be viewed
+
+error: aborting due to 3 previous errors
+
diff --git a/tests/ui/view-types/must-exist.rs b/tests/ui/view-types/must-exist.rs
index 05792b01b3265..efb43eb509e9c 100644
--- a/tests/ui/view-types/must-exist.rs
+++ b/tests/ui/view-types/must-exist.rs
@@ -1,6 +1,3 @@
-//@ known-bug: unknown
-//@ run-pass
-
 #![feature(view_types, view_type_macro)]
 #![allow(unused)]
 
@@ -10,8 +7,9 @@ struct S {
     foo: (),
 }
 
-// We expect  errors here, since `S` has no field `bar`.
 fn f(_: view_type!(S.{ bar })) {}
+//~^ ERROR no field `bar` on type `S`
 fn g(_: view_type!(S.{ foo, bar })) {}
+//~^ ERROR no field `bar` on type `S`
 
 fn main() {}
diff --git a/tests/ui/view-types/must-exist.stderr b/tests/ui/view-types/must-exist.stderr
new file mode 100644
index 0000000000000..a775ad84a7edf
--- /dev/null
+++ b/tests/ui/view-types/must-exist.stderr
@@ -0,0 +1,15 @@
+error[E0609]: no field `bar` on type `S`
+  --> $DIR/must-exist.rs:10:24
+   |
+LL | fn f(_: view_type!(S.{ bar })) {}
+   |                        ^^^
+
+error[E0609]: no field `bar` on type `S`
+  --> $DIR/must-exist.rs:12:29
+   |
+LL | fn g(_: view_type!(S.{ foo, bar })) {}
+   |                             ^^^
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0609`.
diff --git a/tests/ui/view-types/syntax-errors.rs b/tests/ui/view-types/syntax-errors.rs
index 19f5061cf820a..18ccb859d549e 100644
--- a/tests/ui/view-types/syntax-errors.rs
+++ b/tests/ui/view-types/syntax-errors.rs
@@ -9,13 +9,17 @@ struct Foo {
 }
 
 impl Foo {
-    fn not_a_field(self: &mut view_type!(Foo.{ _ }), _: &mut view_type!(Foo.{ _ })) {}
-    //~^ ERROR expected identifier
-    //~| ERROR expected identifier
+    fn not_a_field(self: &mut view_type!(Self.{ _ }), _: &mut view_type!(Foo.{ _ })) {}
+    //~^ ERROR expected identifier, found reserved identifier
+    //~| ERROR expected identifier, found reserved identifier
+    //~| ERROR no field `_` on type `Foo`
+    //~| ERROR no field `_` on type `Foo`
 
     fn keyword(self: &mut view_type!(Foo.{ where }), _: &mut view_type!(Foo.{ for })) {}
     //~^ ERROR expected identifier
     //~| ERROR expected identifier
+    //~| ERROR no field `r#where` on type `Foo`
+    //~| ERROR no field `r#for` on type `Foo`
 
     fn no_comma(self: &mut view_type!(Foo.{ bar baz }), _: &mut view_type!(Foo.{ bar baz })) {}
     //~^ ERROR expected one of
diff --git a/tests/ui/view-types/syntax-errors.stderr b/tests/ui/view-types/syntax-errors.stderr
index 86c167ca9a879..1c1e5fdafae1a 100644
--- a/tests/ui/view-types/syntax-errors.stderr
+++ b/tests/ui/view-types/syntax-errors.stderr
@@ -1,17 +1,17 @@
 error: expected identifier, found reserved identifier `_`
-  --> $DIR/syntax-errors.rs:12:48
+  --> $DIR/syntax-errors.rs:12:49
    |
-LL |     fn not_a_field(self: &mut view_type!(Foo.{ _ }), _: &mut view_type!(Foo.{ _ })) {}
-   |                                                ^ expected identifier, found reserved identifier
+LL |     fn not_a_field(self: &mut view_type!(Self.{ _ }), _: &mut view_type!(Foo.{ _ })) {}
+   |                                                 ^ expected identifier, found reserved identifier
 
 error: expected identifier, found reserved identifier `_`
-  --> $DIR/syntax-errors.rs:12:79
+  --> $DIR/syntax-errors.rs:12:80
    |
-LL |     fn not_a_field(self: &mut view_type!(Foo.{ _ }), _: &mut view_type!(Foo.{ _ })) {}
-   |                                                                               ^ expected identifier, found reserved identifier
+LL |     fn not_a_field(self: &mut view_type!(Self.{ _ }), _: &mut view_type!(Foo.{ _ })) {}
+   |                                                                                ^ expected identifier, found reserved identifier
 
 error: expected identifier, found keyword `where`
-  --> $DIR/syntax-errors.rs:16:44
+  --> $DIR/syntax-errors.rs:18:44
    |
 LL |     fn keyword(self: &mut view_type!(Foo.{ where }), _: &mut view_type!(Foo.{ for })) {}
    |                                            ^^^^^ expected identifier, found keyword
@@ -22,7 +22,7 @@ LL |     fn keyword(self: &mut view_type!(Foo.{ r#where }), _: &mut view_type!(F
    |                                            ++
 
 error: expected identifier, found keyword `for`
-  --> $DIR/syntax-errors.rs:16:79
+  --> $DIR/syntax-errors.rs:18:79
    |
 LL |     fn keyword(self: &mut view_type!(Foo.{ where }), _: &mut view_type!(Foo.{ for })) {}
    |                                                                               ^^^ expected identifier, found keyword
@@ -33,7 +33,7 @@ LL |     fn keyword(self: &mut view_type!(Foo.{ where }), _: &mut view_type!(Foo
    |                                                                               ++
 
 error: expected one of `,` or `}`, found `baz`
-  --> $DIR/syntax-errors.rs:20:49
+  --> $DIR/syntax-errors.rs:24:49
    |
 LL |     fn no_comma(self: &mut view_type!(Foo.{ bar baz }), _: &mut view_type!(Foo.{ bar baz })) {}
    |                                                -^^^ expected one of `,` or `}`
@@ -41,12 +41,37 @@ LL |     fn no_comma(self: &mut view_type!(Foo.{ bar baz }), _: &mut view_type!(
    |                                                help: missing `,`
 
 error: expected one of `,` or `}`, found `baz`
-  --> $DIR/syntax-errors.rs:20:86
+  --> $DIR/syntax-errors.rs:24:86
    |
 LL |     fn no_comma(self: &mut view_type!(Foo.{ bar baz }), _: &mut view_type!(Foo.{ bar baz })) {}
    |                                                                                     -^^^ expected one of `,` or `}`
    |                                                                                     |
    |                                                                                     help: missing `,`
 
-error: aborting due to 6 previous errors
+error[E0609]: no field `_` on type `Foo`
+  --> $DIR/syntax-errors.rs:12:49
+   |
+LL |     fn not_a_field(self: &mut view_type!(Self.{ _ }), _: &mut view_type!(Foo.{ _ })) {}
+   |                                                 ^
+
+error[E0609]: no field `_` on type `Foo`
+  --> $DIR/syntax-errors.rs:12:80
+   |
+LL |     fn not_a_field(self: &mut view_type!(Self.{ _ }), _: &mut view_type!(Foo.{ _ })) {}
+   |                                                                                ^
+
+error[E0609]: no field `r#where` on type `Foo`
+  --> $DIR/syntax-errors.rs:18:44
+   |
+LL |     fn keyword(self: &mut view_type!(Foo.{ where }), _: &mut view_type!(Foo.{ for })) {}
+   |                                            ^^^^^
+
+error[E0609]: no field `r#for` on type `Foo`
+  --> $DIR/syntax-errors.rs:18:79
+   |
+LL |     fn keyword(self: &mut view_type!(Foo.{ where }), _: &mut view_type!(Foo.{ for })) {}
+   |                                                                               ^^^
+
+error: aborting due to 10 previous errors
 
+For more information about this error, try `rustc --explain E0609`.