diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index 42eb8673f30c0..350fa04ab3bdc 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -2517,6 +2517,28 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     span,
                 }
             }
+            ExprKind::Array(elements) => {
+                let lowered_elems = self.arena.alloc_from_iter(elements.iter().map(|element| {
+                    let const_arg = if let ExprKind::ConstBlock(anon_const) = &element.kind {
+                        let def_id = self.local_def_id(anon_const.id);
+                        assert_eq!(DefKind::AnonConst, self.tcx.def_kind(def_id));
+                        self.lower_anon_const_to_const_arg(anon_const)
+                    } else {
+                        self.lower_expr_to_const_arg_direct(element)
+                    };
+                    &*self.arena.alloc(const_arg)
+                }));
+                let array_expr = self.arena.alloc(hir::ConstArgArrayExpr {
+                    span: self.lower_span(expr.span),
+                    elems: lowered_elems,
+                });
+
+                ConstArg {
+                    hir_id: self.next_id(),
+                    kind: hir::ConstArgKind::Array(array_expr),
+                    span,
+                }
+            }
             ExprKind::Underscore => ConstArg {
                 hir_id: self.lower_node_id(expr.id),
                 kind: hir::ConstArgKind::Infer(()),
@@ -2532,6 +2554,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                             | ExprKind::Struct(..)
                             | ExprKind::Call(..)
                             | ExprKind::Tup(..)
+                            | ExprKind::Array(..)
                     )
                 {
                     return self.lower_expr_to_const_arg_direct(expr);
diff --git a/compiler/rustc_codegen_llvm/src/consts.rs b/compiler/rustc_codegen_llvm/src/consts.rs
index 08c53179bc142..2b04f81c267fd 100644
--- a/compiler/rustc_codegen_llvm/src/consts.rs
+++ b/compiler/rustc_codegen_llvm/src/consts.rs
@@ -187,6 +187,10 @@ fn check_and_apply_linkage<'ll, 'tcx>(
         };
         llvm::set_linkage(g1, base::linkage_to_llvm(linkage));
 
+        // Normally this is done in `get_static_inner`, but when as we generate an internal global,
+        // it will apply the dso_local to the internal global instead, so do it here, too.
+        cx.assume_dso_local(g1, true);
+
         // Declare an internal global `extern_with_linkage_foo` which
         // is initialized with the address of `foo`. If `foo` is
         // discarded during linking (for example, if `foo` has weak
diff --git a/compiler/rustc_codegen_ssa/messages.ftl b/compiler/rustc_codegen_ssa/messages.ftl
index 1d87dc5da8d2d..4875f309cca5f 100644
--- a/compiler/rustc_codegen_ssa/messages.ftl
+++ b/compiler/rustc_codegen_ssa/messages.ftl
@@ -10,6 +10,8 @@ codegen_ssa_archive_build_failure = failed to build archive at `{$path}`: {$erro
 
 codegen_ssa_binary_output_to_tty = option `-o` or `--emit` is used to write binary output type `{$shorthand}` to stdout, but stdout is a tty
 
+codegen_ssa_bpf_staticlib_not_supported = linking static libraries is not supported for BPF
+
 codegen_ssa_cgu_not_recorded =
     CGU-reuse for `{$cgu_user_name}` is (mangled: `{$cgu_name}`) was not recorded
 
diff --git a/compiler/rustc_codegen_ssa/src/back/archive.rs b/compiler/rustc_codegen_ssa/src/back/archive.rs
index 93f6cb3b87e66..3f12e857391b2 100644
--- a/compiler/rustc_codegen_ssa/src/back/archive.rs
+++ b/compiler/rustc_codegen_ssa/src/back/archive.rs
@@ -22,10 +22,11 @@ use tracing::trace;
 
 use super::metadata::{create_compressed_metadata_file, search_for_section};
 use crate::common;
-// Re-exporting for rustc_codegen_llvm::back::archive
-pub use crate::errors::{ArchiveBuildFailure, ExtractBundledLibsError, UnknownArchiveKind};
+// Public for ArchiveBuilderBuilder::extract_bundled_libs
+pub use crate::errors::ExtractBundledLibsError;
 use crate::errors::{
-    DlltoolFailImportLibrary, ErrorCallingDllTool, ErrorCreatingImportLibrary, ErrorWritingDEFFile,
+    ArchiveBuildFailure, DlltoolFailImportLibrary, ErrorCallingDllTool, ErrorCreatingImportLibrary,
+    ErrorWritingDEFFile, UnknownArchiveKind,
 };
 
 /// An item to be included in an import library.
diff --git a/compiler/rustc_codegen_ssa/src/back/linker.rs b/compiler/rustc_codegen_ssa/src/back/linker.rs
index b47652092ed5c..637d54dd06c65 100644
--- a/compiler/rustc_codegen_ssa/src/back/linker.rs
+++ b/compiler/rustc_codegen_ssa/src/back/linker.rs
@@ -2075,7 +2075,7 @@ impl<'a> Linker for BpfLinker<'a> {
     }
 
     fn link_staticlib_by_name(&mut self, _name: &str, _verbatim: bool, _whole_archive: bool) {
-        panic!("staticlibs not supported")
+        self.sess.dcx().emit_fatal(errors::BpfStaticlibNotSupported)
     }
 
     fn link_staticlib_by_path(&mut self, path: &Path, _whole_archive: bool) {
diff --git a/compiler/rustc_codegen_ssa/src/errors.rs b/compiler/rustc_codegen_ssa/src/errors.rs
index 95306c140895c..39727685aec1a 100644
--- a/compiler/rustc_codegen_ssa/src/errors.rs
+++ b/compiler/rustc_codegen_ssa/src/errors.rs
@@ -661,7 +661,7 @@ pub(crate) struct RlibArchiveBuildFailure {
 }
 
 #[derive(Diagnostic)]
-// Public for rustc_codegen_llvm::back::archive
+// Public for ArchiveBuilderBuilder::extract_bundled_libs
 pub enum ExtractBundledLibsError<'a> {
     #[diag(codegen_ssa_extract_bundled_libs_open_file)]
     OpenFile { rlib: &'a Path, error: Box<dyn std::error::Error> },
@@ -700,19 +700,21 @@ pub(crate) struct UnsupportedLinkSelfContained;
 
 #[derive(Diagnostic)]
 #[diag(codegen_ssa_archive_build_failure)]
-// Public for rustc_codegen_llvm::back::archive
-pub struct ArchiveBuildFailure {
+pub(crate) struct ArchiveBuildFailure {
     pub path: PathBuf,
     pub error: std::io::Error,
 }
 
 #[derive(Diagnostic)]
 #[diag(codegen_ssa_unknown_archive_kind)]
-// Public for rustc_codegen_llvm::back::archive
-pub struct UnknownArchiveKind<'a> {
+pub(crate) struct UnknownArchiveKind<'a> {
     pub kind: &'a str,
 }
 
+#[derive(Diagnostic)]
+#[diag(codegen_ssa_bpf_staticlib_not_supported)]
+pub(crate) struct BpfStaticlibNotSupported;
+
 #[derive(Diagnostic)]
 #[diag(codegen_ssa_multiple_main_functions)]
 #[help]
diff --git a/compiler/rustc_const_eval/src/check_consts/qualifs.rs b/compiler/rustc_const_eval/src/check_consts/qualifs.rs
index 113e0d66c48a2..02615e3bbc18c 100644
--- a/compiler/rustc_const_eval/src/check_consts/qualifs.rs
+++ b/compiler/rustc_const_eval/src/check_consts/qualifs.rs
@@ -6,9 +6,7 @@
 // having basically only two use-cases that act in different ways.
 
 use rustc_errors::ErrorGuaranteed;
-use rustc_hir::attrs::AttributeKind;
-use rustc_hir::def::DefKind;
-use rustc_hir::{LangItem, find_attr};
+use rustc_hir::LangItem;
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_middle::mir::*;
 use rustc_middle::ty::{self, AdtDef, Ty};
@@ -366,14 +364,10 @@ where
         // check performed after the promotion. Verify that with an assertion.
         assert!(promoted.is_none() || Q::ALLOW_PROMOTED);
 
-        // Avoid looking at attrs of anon consts as that will ICE
-        let is_type_const_item =
-            matches!(cx.tcx.def_kind(def), DefKind::Const | DefKind::AssocConst)
-                && find_attr!(cx.tcx.get_all_attrs(def), AttributeKind::TypeConst(_));
-
         // Don't peak inside trait associated constants, also `#[type_const] const` items
         // don't have bodies so there's nothing to look at
-        if promoted.is_none() && cx.tcx.trait_of_assoc(def).is_none() && !is_type_const_item {
+        if promoted.is_none() && cx.tcx.trait_of_assoc(def).is_none() && !cx.tcx.is_type_const(def)
+        {
             let qualifs = cx.tcx.at(constant.span).mir_const_qualif(def);
 
             if !Q::in_qualifs(&qualifs) {
diff --git a/compiler/rustc_const_eval/src/const_eval/machine.rs b/compiler/rustc_const_eval/src/const_eval/machine.rs
index 7538130e9d923..719187b990122 100644
--- a/compiler/rustc_const_eval/src/const_eval/machine.rs
+++ b/compiler/rustc_const_eval/src/const_eval/machine.rs
@@ -8,7 +8,7 @@ use rustc_data_structures::fx::{FxHashMap, FxIndexMap, IndexEntry};
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::{self as hir, CRATE_HIR_ID, LangItem};
 use rustc_middle::mir::AssertMessage;
-use rustc_middle::mir::interpret::ReportedErrorInfo;
+use rustc_middle::mir::interpret::{Pointer, ReportedErrorInfo};
 use rustc_middle::query::TyCtxtAt;
 use rustc_middle::ty::layout::{HasTypingEnv, TyAndLayout, ValidityRequirement};
 use rustc_middle::ty::{self, Ty, TyCtxt};
@@ -22,7 +22,7 @@ use crate::errors::{LongRunning, LongRunningWarn};
 use crate::fluent_generated as fluent;
 use crate::interpret::{
     self, AllocId, AllocInit, AllocRange, ConstAllocation, CtfeProvenance, FnArg, Frame,
-    GlobalAlloc, ImmTy, InterpCx, InterpResult, OpTy, PlaceTy, Pointer, RangeSet, Scalar,
+    GlobalAlloc, ImmTy, InterpCx, InterpResult, OpTy, PlaceTy, RangeSet, Scalar,
     compile_time_machine, err_inval, interp_ok, throw_exhaust, throw_inval, throw_ub,
     throw_ub_custom, throw_unsup, throw_unsup_format,
 };
@@ -586,6 +586,11 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
                 }
             }
 
+            sym::type_of => {
+                let ty = ecx.read_type_id(&args[0])?;
+                ecx.write_type_info(ty, dest)?;
+            }
+
             _ => {
                 // We haven't handled the intrinsic, let's see if we can use a fallback body.
                 if ecx.tcx.intrinsic(instance.def_id()).unwrap().must_be_overridden {
diff --git a/compiler/rustc_const_eval/src/const_eval/mod.rs b/compiler/rustc_const_eval/src/const_eval/mod.rs
index 624ca1dd2da0e..e70488b81c4ce 100644
--- a/compiler/rustc_const_eval/src/const_eval/mod.rs
+++ b/compiler/rustc_const_eval/src/const_eval/mod.rs
@@ -13,6 +13,7 @@ mod error;
 mod eval_queries;
 mod fn_queries;
 mod machine;
+mod type_info;
 mod valtrees;
 
 pub use self::dummy_machine::*;
diff --git a/compiler/rustc_const_eval/src/const_eval/type_info.rs b/compiler/rustc_const_eval/src/const_eval/type_info.rs
new file mode 100644
index 0000000000000..f932b198b4260
--- /dev/null
+++ b/compiler/rustc_const_eval/src/const_eval/type_info.rs
@@ -0,0 +1,175 @@
+use rustc_abi::FieldIdx;
+use rustc_hir::LangItem;
+use rustc_middle::mir::interpret::CtfeProvenance;
+use rustc_middle::span_bug;
+use rustc_middle::ty::layout::TyAndLayout;
+use rustc_middle::ty::{self, ScalarInt, Ty};
+use rustc_span::{Symbol, sym};
+
+use crate::const_eval::CompileTimeMachine;
+use crate::interpret::{
+    Immediate, InterpCx, InterpResult, MPlaceTy, MemoryKind, Writeable, interp_ok,
+};
+
+impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
+    /// Writes a `core::mem::type_info::TypeInfo` for a given type, `ty` to the given place.
+    pub(crate) fn write_type_info(
+        &mut self,
+        ty: Ty<'tcx>,
+        dest: &impl Writeable<'tcx, CtfeProvenance>,
+    ) -> InterpResult<'tcx> {
+        let ty_struct = self.tcx.require_lang_item(LangItem::Type, self.tcx.span);
+        let ty_struct = self.tcx.type_of(ty_struct).no_bound_vars().unwrap();
+        assert_eq!(ty_struct, dest.layout().ty);
+        let ty_struct = ty_struct.ty_adt_def().unwrap().non_enum_variant();
+        // Fill all fields of the `TypeInfo` struct.
+        for (idx, field) in ty_struct.fields.iter_enumerated() {
+            let field_dest = self.project_field(dest, idx)?;
+            let downcast = |name: Symbol| {
+                let variants = field_dest.layout().ty.ty_adt_def().unwrap().variants();
+                let variant_id = variants
+                    .iter_enumerated()
+                    .find(|(_idx, var)| var.name == name)
+                    .unwrap_or_else(|| panic!("got {name} but expected one of {variants:#?}"))
+                    .0;
+
+                interp_ok((variant_id, self.project_downcast(&field_dest, variant_id)?))
+            };
+            match field.name {
+                sym::kind => {
+                    let variant_index = match ty.kind() {
+                        ty::Tuple(fields) => {
+                            let (variant, variant_place) = downcast(sym::Tuple)?;
+                            // project to the single tuple variant field of `type_info::Tuple` struct type
+                            let tuple_place = self.project_field(&variant_place, FieldIdx::ZERO)?;
+                            assert_eq!(
+                                1,
+                                tuple_place
+                                    .layout()
+                                    .ty
+                                    .ty_adt_def()
+                                    .unwrap()
+                                    .non_enum_variant()
+                                    .fields
+                                    .len()
+                            );
+                            self.write_tuple_fields(tuple_place, fields, ty)?;
+                            variant
+                        }
+                        // For now just merge all primitives into one `Leaf` variant with no data
+                        ty::Uint(_) | ty::Int(_) | ty::Float(_) | ty::Char | ty::Bool => {
+                            downcast(sym::Leaf)?.0
+                        }
+                        ty::Adt(_, _)
+                        | ty::Foreign(_)
+                        | ty::Str
+                        | ty::Array(_, _)
+                        | ty::Pat(_, _)
+                        | ty::Slice(_)
+                        | ty::RawPtr(..)
+                        | ty::Ref(..)
+                        | ty::FnDef(..)
+                        | ty::FnPtr(..)
+                        | ty::UnsafeBinder(..)
+                        | ty::Dynamic(..)
+                        | ty::Closure(..)
+                        | ty::CoroutineClosure(..)
+                        | ty::Coroutine(..)
+                        | ty::CoroutineWitness(..)
+                        | ty::Never
+                        | ty::Alias(..)
+                        | ty::Param(_)
+                        | ty::Bound(..)
+                        | ty::Placeholder(_)
+                        | ty::Infer(..)
+                        | ty::Error(_) => downcast(sym::Other)?.0,
+                    };
+                    self.write_discriminant(variant_index, &field_dest)?
+                }
+                sym::size => {
+                    let layout = self.layout_of(ty)?;
+                    let variant_index = if layout.is_sized() {
+                        let (variant, variant_place) = downcast(sym::Some)?;
+                        let size_field_place =
+                            self.project_field(&variant_place, FieldIdx::ZERO)?;
+                        self.write_scalar(
+                            ScalarInt::try_from_target_usize(layout.size.bytes(), self.tcx.tcx)
+                                .unwrap(),
+                            &size_field_place,
+                        )?;
+                        variant
+                    } else {
+                        downcast(sym::None)?.0
+                    };
+                    self.write_discriminant(variant_index, &field_dest)?;
+                }
+                other => span_bug!(self.tcx.span, "unknown `Type` field {other}"),
+            }
+        }
+
+        interp_ok(())
+    }
+
+    pub(crate) fn write_tuple_fields(
+        &mut self,
+        tuple_place: impl Writeable<'tcx, CtfeProvenance>,
+        fields: &[Ty<'tcx>],
+        tuple_ty: Ty<'tcx>,
+    ) -> InterpResult<'tcx> {
+        // project into the `type_info::Tuple::fields` field
+        let fields_slice_place = self.project_field(&tuple_place, FieldIdx::ZERO)?;
+        // get the `type_info::Field` type from `fields: &[Field]`
+        let field_type = fields_slice_place
+            .layout()
+            .ty
+            .builtin_deref(false)
+            .unwrap()
+            .sequence_element_type(self.tcx.tcx);
+        // Create an array with as many elements as the number of fields in the inspected tuple
+        let fields_layout =
+            self.layout_of(Ty::new_array(self.tcx.tcx, field_type, fields.len() as u64))?;
+        let fields_place = self.allocate(fields_layout, MemoryKind::Stack)?;
+        let mut fields_places = self.project_array_fields(&fields_place)?;
+
+        let tuple_layout = self.layout_of(tuple_ty)?;
+
+        while let Some((i, place)) = fields_places.next(self)? {
+            let field_ty = fields[i as usize];
+            self.write_field(field_ty, place, tuple_layout, i)?;
+        }
+
+        let fields_place = fields_place.map_provenance(CtfeProvenance::as_immutable);
+
+        let ptr = Immediate::new_slice(fields_place.ptr(), fields.len() as u64, self);
+
+        self.write_immediate(ptr, &fields_slice_place)
+    }
+
+    fn write_field(
+        &mut self,
+        field_ty: Ty<'tcx>,
+        place: MPlaceTy<'tcx>,
+        layout: TyAndLayout<'tcx>,
+        idx: u64,
+    ) -> InterpResult<'tcx> {
+        for (field_idx, field_ty_field) in
+            place.layout.ty.ty_adt_def().unwrap().non_enum_variant().fields.iter_enumerated()
+        {
+            let field_place = self.project_field(&place, field_idx)?;
+            match field_ty_field.name {
+                sym::ty => self.write_type_id(field_ty, &field_place)?,
+                sym::offset => {
+                    let offset = layout.fields.offset(idx as usize);
+                    self.write_scalar(
+                        ScalarInt::try_from_target_usize(offset.bytes(), self.tcx.tcx).unwrap(),
+                        &field_place,
+                    )?;
+                }
+                other => {
+                    span_bug!(self.tcx.def_span(field_ty_field.did), "unimplemented field {other}")
+                }
+            }
+        }
+        interp_ok(())
+    }
+}
diff --git a/compiler/rustc_const_eval/src/interpret/intrinsics.rs b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
index d70d157d88085..94832c0c25776 100644
--- a/compiler/rustc_const_eval/src/interpret/intrinsics.rs
+++ b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
@@ -27,6 +27,7 @@ use super::{
     throw_ub_custom, throw_ub_format,
 };
 use crate::fluent_generated as fluent;
+use crate::interpret::Writeable;
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 enum MulAddType {
@@ -68,10 +69,10 @@ pub(crate) fn alloc_type_name<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> (AllocId
 }
 impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
     /// Generates a value of `TypeId` for `ty` in-place.
-    fn write_type_id(
+    pub(crate) fn write_type_id(
         &mut self,
         ty: Ty<'tcx>,
-        dest: &PlaceTy<'tcx, M::Provenance>,
+        dest: &impl Writeable<'tcx, M::Provenance>,
     ) -> InterpResult<'tcx, ()> {
         let tcx = self.tcx;
         let type_id_hash = tcx.type_id_hash(ty).as_u128();
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index 2fb6daf6469b7..055df9c2a0852 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -513,6 +513,8 @@ pub enum ConstArgKind<'hir, Unambig = ()> {
     Struct(QPath<'hir>, &'hir [&'hir ConstArgExprField<'hir>]),
     /// Tuple constructor variant
     TupleCall(QPath<'hir>, &'hir [&'hir ConstArg<'hir>]),
+    /// Array literal argument
+    Array(&'hir ConstArgArrayExpr<'hir>),
     /// Error const
     Error(ErrorGuaranteed),
     /// This variant is not always used to represent inference consts, sometimes
@@ -529,6 +531,12 @@ pub struct ConstArgExprField<'hir> {
     pub expr: &'hir ConstArg<'hir>,
 }
 
+#[derive(Clone, Copy, Debug, HashStable_Generic)]
+pub struct ConstArgArrayExpr<'hir> {
+    pub span: Span,
+    pub elems: &'hir [&'hir ConstArg<'hir>],
+}
+
 #[derive(Clone, Copy, Debug, HashStable_Generic)]
 pub struct InferArg {
     #[stable_hasher(ignore)]
diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs
index e5e6fc7b1d8de..d1b75325af268 100644
--- a/compiler/rustc_hir/src/intravisit.rs
+++ b/compiler/rustc_hir/src/intravisit.rs
@@ -1101,6 +1101,12 @@ pub fn walk_const_arg<'v, V: Visitor<'v>>(
             }
             V::Result::output()
         }
+        ConstArgKind::Array(array_expr) => {
+            for arg in array_expr.elems {
+                try_visit!(visitor.visit_const_arg_unambig(*arg));
+            }
+            V::Result::output()
+        }
         ConstArgKind::Path(qpath) => visitor.visit_qpath(qpath, *hir_id, qpath.span()),
         ConstArgKind::Anon(anon) => visitor.visit_anon_const(*anon),
         ConstArgKind::Error(_) => V::Result::output(), // errors and spans are not important
diff --git a/compiler/rustc_hir/src/lang_items.rs b/compiler/rustc_hir/src/lang_items.rs
index 4ac3e4e83e80a..557f76208bfe6 100644
--- a/compiler/rustc_hir/src/lang_items.rs
+++ b/compiler/rustc_hir/src/lang_items.rs
@@ -278,6 +278,7 @@ language_item_table! {
     PartialOrd,              sym::partial_ord,         partial_ord_trait,          Target::Trait,          GenericRequirement::Exact(1);
     CVoid,                   sym::c_void,              c_void,                     Target::Enum,           GenericRequirement::None;
 
+    Type,                    sym::type_info,           type_struct,                Target::Struct,         GenericRequirement::None;
     TypeId,                  sym::type_id,             type_id,                    Target::Struct,         GenericRequirement::None;
 
     // A number of panic-related lang items. The `panic` item corresponds to divide-by-zero and
diff --git a/compiler/rustc_hir_analysis/src/check/intrinsic.rs b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
index 9eaf5319cb040..c84c1a8ca16d8 100644
--- a/compiler/rustc_hir_analysis/src/check/intrinsic.rs
+++ b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
@@ -213,6 +213,7 @@ fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -> hi
         | sym::type_id
         | sym::type_id_eq
         | sym::type_name
+        | sym::type_of
         | sym::ub_checks
         | sym::variant_count
         | sym::vtable_for
@@ -308,13 +309,22 @@ pub(crate) fn check_intrinsic_type(
         sym::needs_drop => (1, 0, vec![], tcx.types.bool),
 
         sym::type_name => (1, 0, vec![], Ty::new_static_str(tcx)),
-        sym::type_id => {
-            (1, 0, vec![], tcx.type_of(tcx.lang_items().type_id().unwrap()).instantiate_identity())
-        }
+        sym::type_id => (
+            1,
+            0,
+            vec![],
+            tcx.type_of(tcx.lang_items().type_id().unwrap()).no_bound_vars().unwrap(),
+        ),
         sym::type_id_eq => {
-            let type_id = tcx.type_of(tcx.lang_items().type_id().unwrap()).instantiate_identity();
+            let type_id = tcx.type_of(tcx.lang_items().type_id().unwrap()).no_bound_vars().unwrap();
             (0, 0, vec![type_id, type_id], tcx.types.bool)
         }
+        sym::type_of => (
+            0,
+            0,
+            vec![tcx.type_of(tcx.lang_items().type_id().unwrap()).no_bound_vars().unwrap()],
+            tcx.type_of(tcx.lang_items().type_struct().unwrap()).no_bound_vars().unwrap(),
+        ),
         sym::offload => (
             3,
             0,
diff --git a/compiler/rustc_hir_analysis/src/collect/type_of.rs b/compiler/rustc_hir_analysis/src/collect/type_of.rs
index aa0e5c7fd7101..910176a0689c7 100644
--- a/compiler/rustc_hir_analysis/src/collect/type_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/type_of.rs
@@ -420,7 +420,22 @@ fn infer_placeholder_type<'tcx>(
     kind: &'static str,
 ) -> Ty<'tcx> {
     let tcx = cx.tcx();
-    let ty = tcx.typeck(def_id).node_type(hir_id);
+    // If the type is omitted on a #[type_const] we can't run
+    // type check on since that requires the const have a body
+    // which type_consts don't.
+    let ty = if tcx.is_type_const(def_id.to_def_id()) {
+        if let Some(trait_item_def_id) = tcx.trait_item_of(def_id.to_def_id()) {
+            tcx.type_of(trait_item_def_id).instantiate_identity()
+        } else {
+            Ty::new_error_with_message(
+                tcx,
+                ty_span,
+                "constant with #[type_const] requires an explicit type",
+            )
+        }
+    } else {
+        tcx.typeck(def_id).node_type(hir_id)
+    };
 
     // If this came from a free `const` or `static mut?` item,
     // then the user may have written e.g. `const A = 42;`.
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 1dd9bff425759..6f44a728242d7 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -2389,6 +2389,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             hir::ConstArgKind::TupleCall(qpath, args) => {
                 self.lower_const_arg_tuple_call(hir_id, qpath, args, const_arg.span)
             }
+            hir::ConstArgKind::Array(array_expr) => self.lower_const_arg_array(array_expr, feed),
             hir::ConstArgKind::Anon(anon) => self.lower_const_arg_anon(anon),
             hir::ConstArgKind::Infer(()) => self.ct_infer(None, const_arg.span),
             hir::ConstArgKind::Error(e) => ty::Const::new_error(tcx, e),
@@ -2402,6 +2403,36 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         }
     }
 
+    fn lower_const_arg_array(
+        &self,
+        array_expr: &'tcx hir::ConstArgArrayExpr<'tcx>,
+        feed: FeedConstTy<'tcx>,
+    ) -> Const<'tcx> {
+        let tcx = self.tcx();
+
+        let FeedConstTy::WithTy(ty) = feed else {
+            return Const::new_error_with_message(tcx, array_expr.span, "unsupported const array");
+        };
+
+        let ty::Array(elem_ty, _) = ty.kind() else {
+            return Const::new_error_with_message(
+                tcx,
+                array_expr.span,
+                "const array must have an array type",
+            );
+        };
+
+        let elems = array_expr
+            .elems
+            .iter()
+            .map(|elem| self.lower_const_arg(elem, FeedConstTy::WithTy(*elem_ty)))
+            .collect::<Vec<_>>();
+
+        let valtree = ty::ValTree::from_branches(tcx, elems);
+
+        ty::Const::new_value(tcx, valtree, ty)
+    }
+
     fn lower_const_arg_tuple_call(
         &self,
         hir_id: HirId,
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
index 37fa18c00887e..e0e9fe7758535 100644
--- a/compiler/rustc_hir_pretty/src/lib.rs
+++ b/compiler/rustc_hir_pretty/src/lib.rs
@@ -1153,6 +1153,7 @@ impl<'a> State<'a> {
             }
             ConstArgKind::Struct(qpath, fields) => self.print_const_struct(qpath, fields),
             ConstArgKind::TupleCall(qpath, args) => self.print_const_ctor(qpath, args),
+            ConstArgKind::Array(..) => self.word("/* ARRAY EXPR */"),
             ConstArgKind::Path(qpath) => self.print_qpath(qpath, true),
             ConstArgKind::Anon(anon) => self.print_anon_const(anon),
             ConstArgKind::Error(_) => self.word("/*ERROR*/"),
diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs
index eedb88783ec0e..a62826cd7cec0 100644
--- a/compiler/rustc_metadata/src/rmeta/encoder.rs
+++ b/compiler/rustc_metadata/src/rmeta/encoder.rs
@@ -1441,6 +1441,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                         // 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(..)
diff --git a/compiler/rustc_middle/src/thir.rs b/compiler/rustc_middle/src/thir.rs
index 3683c1cfb7ddb..e538c2182924a 100644
--- a/compiler/rustc_middle/src/thir.rs
+++ b/compiler/rustc_middle/src/thir.rs
@@ -643,10 +643,26 @@ pub struct FieldPat<'tcx> {
     pub pattern: Pat<'tcx>,
 }
 
+/// Additional per-node data that is not present on most THIR pattern nodes.
+#[derive(Clone, Debug, Default, HashStable, TypeVisitable)]
+pub struct PatExtra<'tcx> {
+    /// If present, this node represents a named constant that was lowered to
+    /// a pattern using `const_to_pat`.
+    ///
+    /// This is used by some diagnostics for non-exhaustive matches, to map
+    /// the pattern node back to the `DefId` of its original constant.
+    pub expanded_const: Option<DefId>,
+
+    /// User-written types that must be preserved into MIR so that they can be
+    /// checked.
+    pub ascriptions: Vec<Ascription<'tcx>>,
+}
+
 #[derive(Clone, Debug, HashStable, TypeVisitable)]
 pub struct Pat<'tcx> {
     pub ty: Ty<'tcx>,
     pub span: Span,
+    pub extra: Option<Box<PatExtra<'tcx>>>,
     pub kind: PatKind<'tcx>,
 }
 
@@ -762,11 +778,6 @@ pub enum PatKind<'tcx> {
     /// A wildcard pattern: `_`.
     Wild,
 
-    AscribeUserType {
-        ascription: Ascription<'tcx>,
-        subpattern: Box<Pat<'tcx>>,
-    },
-
     /// `x`, `ref x`, `x @ P`, etc.
     Binding {
         name: Symbol,
@@ -831,21 +842,6 @@ pub enum PatKind<'tcx> {
         value: ty::Value<'tcx>,
     },
 
-    /// Wrapper node representing a named constant that was lowered to a pattern
-    /// using `const_to_pat`.
-    ///
-    /// This is used by some diagnostics for non-exhaustive matches, to map
-    /// the pattern node back to the `DefId` of its original constant.
-    ///
-    /// FIXME(#150498): Can we make this an `Option<DefId>` field on `Pat`
-    /// instead, so that non-diagnostic code can ignore it more easily?
-    ExpandedConstant {
-        /// [DefId] of the constant item.
-        def_id: DefId,
-        /// The pattern that the constant lowered to.
-        subpattern: Box<Pat<'tcx>>,
-    },
-
     Range(Arc<PatRange<'tcx>>),
 
     /// Matches against a slice, checking the length and extracting elements.
@@ -1119,7 +1115,7 @@ mod size_asserts {
     static_assert_size!(Block, 48);
     static_assert_size!(Expr<'_>, 64);
     static_assert_size!(ExprKind<'_>, 40);
-    static_assert_size!(Pat<'_>, 64);
+    static_assert_size!(Pat<'_>, 72);
     static_assert_size!(PatKind<'_>, 48);
     static_assert_size!(Stmt<'_>, 48);
     static_assert_size!(StmtKind<'_>, 48);
diff --git a/compiler/rustc_middle/src/thir/visit.rs b/compiler/rustc_middle/src/thir/visit.rs
index d792bbe60c888..b611b23e52619 100644
--- a/compiler/rustc_middle/src/thir/visit.rs
+++ b/compiler/rustc_middle/src/thir/visit.rs
@@ -259,7 +259,7 @@ pub(crate) fn for_each_immediate_subpat<'a, 'tcx>(
     pat: &'a Pat<'tcx>,
     mut callback: impl FnMut(&'a Pat<'tcx>),
 ) {
-    let Pat { kind, ty: _, span: _ } = pat;
+    let Pat { kind, ty: _, span: _, extra: _ } = pat;
     match kind {
         PatKind::Missing
         | PatKind::Wild
@@ -269,11 +269,9 @@ pub(crate) fn for_each_immediate_subpat<'a, 'tcx>(
         | PatKind::Never
         | PatKind::Error(_) => {}
 
-        PatKind::AscribeUserType { subpattern, .. }
-        | PatKind::Binding { subpattern: Some(subpattern), .. }
+        PatKind::Binding { subpattern: Some(subpattern), .. }
         | PatKind::Deref { subpattern }
-        | PatKind::DerefPattern { subpattern, .. }
-        | PatKind::ExpandedConstant { subpattern, .. } => callback(subpattern),
+        | PatKind::DerefPattern { subpattern, .. } => callback(subpattern),
 
         PatKind::Variant { subpatterns, .. } | PatKind::Leaf { subpatterns } => {
             for field_pat in subpatterns {
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index a2f4714d1b2c2..a3eec72214c06 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -1891,6 +1891,12 @@ impl<'tcx> TyCtxt<'tcx> {
         self.is_lang_item(self.parent(def_id), LangItem::AsyncDropInPlace)
     }
 
+    /// Check if the given `def_id` is a const with the `#[type_const]` attribute.
+    pub fn is_type_const(self, def_id: DefId) -> bool {
+        matches!(self.def_kind(def_id), DefKind::Const | DefKind::AssocConst)
+            && find_attr!(self.get_all_attrs(def_id), AttributeKind::TypeConst(_))
+    }
+
     /// Returns the movability of the coroutine of `def_id`, or panics
     /// if given a `def_id` that is not a coroutine.
     pub fn coroutine_movability(self, def_id: DefId) -> hir::Movability {
diff --git a/compiler/rustc_mir_build/src/builder/custom/parse.rs b/compiler/rustc_mir_build/src/builder/custom/parse.rs
index c6ef362c6ea5a..3ae4b1fadee9e 100644
--- a/compiler/rustc_mir_build/src/builder/custom/parse.rs
+++ b/compiler/rustc_mir_build/src/builder/custom/parse.rs
@@ -287,22 +287,14 @@ impl<'a, 'tcx> ParseCtxt<'a, 'tcx> {
         self.parse_var(pattern)
     }
 
-    fn parse_var(&mut self, mut pat: &Pat<'tcx>) -> PResult<(LocalVarId, Ty<'tcx>, Span)> {
-        // Make sure we throw out any `AscribeUserType` we find
-        loop {
-            match &pat.kind {
-                PatKind::Binding { var, ty, .. } => break Ok((*var, *ty, pat.span)),
-                PatKind::AscribeUserType { subpattern, .. } => {
-                    pat = subpattern;
-                }
-                _ => {
-                    break Err(ParseError {
-                        span: pat.span,
-                        item_description: format!("{:?}", pat.kind),
-                        expected: "local".to_string(),
-                    });
-                }
-            }
+    fn parse_var(&mut self, pat: &Pat<'tcx>) -> PResult<(LocalVarId, Ty<'tcx>, Span)> {
+        match &pat.kind {
+            PatKind::Binding { var, ty, .. } => Ok((*var, *ty, pat.span)),
+            _ => Err(ParseError {
+                span: pat.span,
+                item_description: format!("{:?}", pat.kind),
+                expected: "local".to_string(),
+            }),
         }
     }
 
diff --git a/compiler/rustc_mir_build/src/builder/custom/parse/instruction.rs b/compiler/rustc_mir_build/src/builder/custom/parse/instruction.rs
index ddaa61c6cc910..13082d408ec08 100644
--- a/compiler/rustc_mir_build/src/builder/custom/parse/instruction.rs
+++ b/compiler/rustc_mir_build/src/builder/custom/parse/instruction.rs
@@ -144,11 +144,6 @@ impl<'a, 'tcx> ParseCtxt<'a, 'tcx> {
             let arm = &self.thir[*arm];
             let value = match arm.pattern.kind {
                 PatKind::Constant { value } => value,
-                PatKind::ExpandedConstant { ref subpattern, def_id: _ }
-                    if let PatKind::Constant { value } = subpattern.kind =>
-                {
-                    value
-                }
                 _ => {
                     return Err(ParseError {
                         span: arm.pattern.span,
diff --git a/compiler/rustc_mir_build/src/builder/expr/as_constant.rs b/compiler/rustc_mir_build/src/builder/expr/as_constant.rs
index 186fde4883df8..1772d66f5285a 100644
--- a/compiler/rustc_mir_build/src/builder/expr/as_constant.rs
+++ b/compiler/rustc_mir_build/src/builder/expr/as_constant.rs
@@ -1,7 +1,7 @@
 //! See docs in build/expr/mod.rs
 
 use rustc_abi::Size;
-use rustc_ast as ast;
+use rustc_ast::{self as ast};
 use rustc_hir::LangItem;
 use rustc_middle::mir::interpret::{CTFE_ALLOC_SALT, LitToConstInput, Scalar};
 use rustc_middle::mir::*;
@@ -47,6 +47,7 @@ pub(crate) fn as_constant_inner<'tcx>(
     tcx: TyCtxt<'tcx>,
 ) -> ConstOperand<'tcx> {
     let Expr { ty, temp_scope_id: _, span, ref kind } = *expr;
+
     match *kind {
         ExprKind::Literal { lit, neg } => {
             let const_ = lit_to_mir_constant(tcx, LitToConstInput { lit: lit.node, ty, neg });
@@ -69,6 +70,13 @@ pub(crate) fn as_constant_inner<'tcx>(
         }
         ExprKind::NamedConst { def_id, args, ref user_ty } => {
             let user_ty = user_ty.as_ref().and_then(push_cuta);
+            if tcx.is_type_const(def_id) {
+                let uneval = ty::UnevaluatedConst::new(def_id, args);
+                let ct = ty::Const::new_unevaluated(tcx, uneval);
+
+                let const_ = Const::Ty(ty, ct);
+                return ConstOperand { span, user_ty, const_ };
+            }
 
             let uneval = mir::UnevaluatedConst::new(def_id, args);
             let const_ = Const::Unevaluated(uneval, ty);
diff --git a/compiler/rustc_mir_build/src/builder/matches/match_pair.rs b/compiler/rustc_mir_build/src/builder/matches/match_pair.rs
index f0114c2193c3e..8cee3ff27e8f9 100644
--- a/compiler/rustc_mir_build/src/builder/matches/match_pair.rs
+++ b/compiler/rustc_mir_build/src/builder/matches/match_pair.rs
@@ -133,6 +133,20 @@ impl<'tcx> MatchPairTree<'tcx> {
         }
 
         let place = place_builder.try_to_place(cx);
+
+        // Apply any type ascriptions to the value at `match_pair.place`.
+        if let Some(place) = place
+            && let Some(extra) = &pattern.extra
+        {
+            for &Ascription { ref annotation, variance } in &extra.ascriptions {
+                extra_data.ascriptions.push(super::Ascription {
+                    source: place,
+                    annotation: annotation.clone(),
+                    variance,
+                });
+            }
+        }
+
         let mut subpairs = Vec::new();
         let testable_case = match pattern.kind {
             PatKind::Missing | PatKind::Wild | PatKind::Error(_) => None,
@@ -195,28 +209,6 @@ impl<'tcx> MatchPairTree<'tcx> {
                 Some(TestableCase::Constant { value, kind: const_kind })
             }
 
-            PatKind::AscribeUserType {
-                ascription: Ascription { ref annotation, variance },
-                ref subpattern,
-                ..
-            } => {
-                MatchPairTree::for_pattern(
-                    place_builder,
-                    subpattern,
-                    cx,
-                    &mut subpairs,
-                    extra_data,
-                );
-
-                // Apply the type ascription to the value at `match_pair.place`
-                if let Some(source) = place {
-                    let annotation = annotation.clone();
-                    extra_data.ascriptions.push(super::Ascription { source, annotation, variance });
-                }
-
-                None
-            }
-
             PatKind::Binding { mode, var, is_shorthand, ref subpattern, .. } => {
                 // In order to please the borrow checker, when lowering a pattern
                 // like `x @ subpat` we must establish any bindings in `subpat`
@@ -263,11 +255,6 @@ impl<'tcx> MatchPairTree<'tcx> {
                 None
             }
 
-            PatKind::ExpandedConstant { subpattern: ref pattern, .. } => {
-                MatchPairTree::for_pattern(place_builder, pattern, cx, &mut subpairs, extra_data);
-                None
-            }
-
             PatKind::Array { ref prefix, ref slice, ref suffix } => {
                 cx.prefix_slice_suffix(
                     &mut subpairs,
diff --git a/compiler/rustc_mir_build/src/builder/matches/mod.rs b/compiler/rustc_mir_build/src/builder/matches/mod.rs
index 9080e2ba801bf..590316a475549 100644
--- a/compiler/rustc_mir_build/src/builder/matches/mod.rs
+++ b/compiler/rustc_mir_build/src/builder/matches/mod.rs
@@ -576,7 +576,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         initializer_id: ExprId,
     ) -> BlockAnd<()> {
         match irrefutable_pat.kind {
-            // Optimize the case of `let x = ...` to write directly into `x`
+            // Optimize `let x = ...` and `let x: T = ...` to write directly into `x`,
+            // and then require that `T == typeof(x)` if present.
             PatKind::Binding { mode: BindingMode(ByRef::No, _), var, subpattern: None, .. } => {
                 let place = self.storage_live_binding(
                     block,
@@ -592,43 +593,14 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 let source_info = self.source_info(irrefutable_pat.span);
                 self.cfg.push_fake_read(block, source_info, FakeReadCause::ForLet(None), place);
 
-                self.schedule_drop_for_binding(var, irrefutable_pat.span, OutsideGuard);
-                block.unit()
-            }
+                let ascriptions: &[_] =
+                    try { irrefutable_pat.extra.as_deref()?.ascriptions.as_slice() }
+                        .unwrap_or_default();
+                for thir::Ascription { annotation, variance: _ } in ascriptions {
+                    let ty_source_info = self.source_info(annotation.span);
 
-            // Optimize the case of `let x: T = ...` to write directly
-            // into `x` and then require that `T == typeof(x)`.
-            PatKind::AscribeUserType {
-                ref subpattern,
-                ascription: thir::Ascription { ref annotation, variance: _ },
-            } if let PatKind::Binding {
-                mode: BindingMode(ByRef::No, _),
-                var,
-                subpattern: None,
-                ..
-            } = subpattern.kind =>
-            {
-                let place = self.storage_live_binding(
-                    block,
-                    var,
-                    irrefutable_pat.span,
-                    false,
-                    OutsideGuard,
-                    ScheduleDrops::Yes,
-                );
-                block = self.expr_into_dest(place, block, initializer_id).into_block();
-
-                // Inject a fake read, see comments on `FakeReadCause::ForLet`.
-                let pattern_source_info = self.source_info(irrefutable_pat.span);
-                let cause_let = FakeReadCause::ForLet(None);
-                self.cfg.push_fake_read(block, pattern_source_info, cause_let, place);
-
-                let ty_source_info = self.source_info(annotation.span);
-
-                let base = self.canonical_user_type_annotations.push(annotation.clone());
-                self.cfg.push(
-                    block,
-                    Statement::new(
+                    let base = self.canonical_user_type_annotations.push(annotation.clone());
+                    let stmt = Statement::new(
                         ty_source_info,
                         StatementKind::AscribeUserType(
                             Box::new((place, UserTypeProjection { base, projs: Vec::new() })),
@@ -648,8 +620,9 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                             // `<expr>`.
                             ty::Invariant,
                         ),
-                    ),
-                );
+                    );
+                    self.cfg.push(block, stmt);
+                }
 
                 self.schedule_drop_for_binding(var, irrefutable_pat.span, OutsideGuard);
                 block.unit()
@@ -879,6 +852,26 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             &ProjectedUserTypesNode<'_>,
         ),
     ) {
+        // Ascriptions correspond to user-written types like `let A::<'a>(_): A<'static> = ...;`.
+        //
+        // Caution: Pushing user types here is load-bearing even for
+        // patterns containing no bindings, to ensure that the type ends
+        // up represented in MIR _somewhere_.
+        let user_tys = match pattern.extra.as_deref() {
+            Some(PatExtra { ascriptions, .. }) if !ascriptions.is_empty() => {
+                let base_user_tys = ascriptions
+                    .iter()
+                    .map(|thir::Ascription { annotation, variance: _ }| {
+                        // Note that the variance doesn't apply here, as we are tracking the effect
+                        // of user types on any bindings contained with subpattern.
+                        self.canonical_user_type_annotations.push(annotation.clone())
+                    })
+                    .collect();
+                &user_tys.push_user_types(base_user_tys)
+            }
+            _ => user_tys,
+        };
+
         // Avoid having to write the full method name at each recursive call.
         let visit_subpat = |this: &mut Self, subpat, user_tys: &_, f: &mut _| {
             this.visit_primary_bindings_special(subpat, user_tys, f)
@@ -924,31 +917,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 visit_subpat(self, subpattern, &ProjectedUserTypesNode::None, f);
             }
 
-            PatKind::AscribeUserType {
-                ref subpattern,
-                ascription: thir::Ascription { ref annotation, variance: _ },
-            } => {
-                // This corresponds to something like
-                //
-                // ```
-                // let A::<'a>(_): A<'static> = ...;
-                // ```
-                //
-                // Note that the variance doesn't apply here, as we are tracking the effect
-                // of `user_ty` on any bindings contained with subpattern.
-
-                // Caution: Pushing this user type here is load-bearing even for
-                // patterns containing no bindings, to ensure that the type ends
-                // up represented in MIR _somewhere_.
-                let base_user_ty = self.canonical_user_type_annotations.push(annotation.clone());
-                let subpattern_user_tys = user_tys.push_user_type(base_user_ty);
-                visit_subpat(self, subpattern, &subpattern_user_tys, f)
-            }
-
-            PatKind::ExpandedConstant { ref subpattern, .. } => {
-                visit_subpat(self, subpattern, user_tys, f)
-            }
-
             PatKind::Leaf { ref subpatterns } => {
                 for subpattern in subpatterns {
                     let subpattern_user_tys = user_tys.leaf(subpattern.field);
diff --git a/compiler/rustc_mir_build/src/builder/matches/user_ty.rs b/compiler/rustc_mir_build/src/builder/matches/user_ty.rs
index df9f93ac328a6..2dcfd3772902c 100644
--- a/compiler/rustc_mir_build/src/builder/matches/user_ty.rs
+++ b/compiler/rustc_mir_build/src/builder/matches/user_ty.rs
@@ -8,15 +8,20 @@ use std::assert_matches::assert_matches;
 use std::iter;
 
 use rustc_abi::{FieldIdx, VariantIdx};
+use rustc_data_structures::smallvec::SmallVec;
 use rustc_middle::mir::{ProjectionElem, UserTypeProjection, UserTypeProjections};
 use rustc_middle::ty::{AdtDef, UserTypeAnnotationIndex};
 use rustc_span::Symbol;
 
+/// A single `thir::Pat` node should almost never have more than 0-2 user types.
+/// We can store up to 4 inline in the same size as an ordinary `Vec`.
+pub(crate) type UserTypeIndices = SmallVec<[UserTypeAnnotationIndex; 4]>;
+
 /// One of a list of "operations" that can be used to lazily build projections
 /// of user-specified types.
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub(crate) enum ProjectedUserTypesOp {
-    PushUserType { base: UserTypeAnnotationIndex },
+    PushUserTypes { base_types: UserTypeIndices },
 
     Index,
     Subslice { from: u64, to: u64 },
@@ -32,9 +37,10 @@ pub(crate) enum ProjectedUserTypesNode<'a> {
 }
 
 impl<'a> ProjectedUserTypesNode<'a> {
-    pub(crate) fn push_user_type(&'a self, base: UserTypeAnnotationIndex) -> Self {
-        // Pushing a base user type always causes the chain to become non-empty.
-        Self::Chain { parent: self, op: ProjectedUserTypesOp::PushUserType { base } }
+    pub(crate) fn push_user_types(&'a self, base_types: UserTypeIndices) -> Self {
+        assert!(!base_types.is_empty());
+        // Pushing one or more base user types always causes the chain to become non-empty.
+        Self::Chain { parent: self, op: ProjectedUserTypesOp::PushUserTypes { base_types } }
     }
 
     /// Push another projection op onto the chain, but only if it is already non-empty.
@@ -94,16 +100,19 @@ impl<'a> ProjectedUserTypesNode<'a> {
             return None;
         }
 
-        let ops_reversed = self.iter_ops_reversed().cloned().collect::<Vec<_>>();
+        let ops_reversed = self.iter_ops_reversed().collect::<Vec<_>>();
         // The "first" op should always be `PushUserType`.
         // Other projections are only added if there is at least one user type.
-        assert_matches!(ops_reversed.last(), Some(ProjectedUserTypesOp::PushUserType { .. }));
+        assert_matches!(ops_reversed.last(), Some(ProjectedUserTypesOp::PushUserTypes { .. }));
 
         let mut projections = vec![];
         for op in ops_reversed.into_iter().rev() {
-            match op {
-                ProjectedUserTypesOp::PushUserType { base } => {
-                    projections.push(UserTypeProjection { base, projs: vec![] })
+            match *op {
+                ProjectedUserTypesOp::PushUserTypes { ref base_types } => {
+                    assert!(!base_types.is_empty());
+                    for &base in base_types {
+                        projections.push(UserTypeProjection { base, projs: vec![] })
+                    }
                 }
 
                 ProjectedUserTypesOp::Index => {
diff --git a/compiler/rustc_mir_build/src/check_unsafety.rs b/compiler/rustc_mir_build/src/check_unsafety.rs
index 4f03e3d965c6c..68b8a842a2a69 100644
--- a/compiler/rustc_mir_build/src/check_unsafety.rs
+++ b/compiler/rustc_mir_build/src/check_unsafety.rs
@@ -342,8 +342,6 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> {
                 PatKind::Wild |
                 // these just wrap other patterns, which we recurse on below.
                 PatKind::Or { .. } |
-                PatKind::ExpandedConstant { .. } |
-                PatKind::AscribeUserType { .. } |
                 PatKind::Error(_) => {}
             }
         };
diff --git a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
index bf480cf601ee3..d9a06de32bb0f 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -680,20 +680,13 @@ impl<'p, 'tcx> MatchVisitor<'p, 'tcx> {
         let mut interpreted_as_const = None;
         let mut interpreted_as_const_sugg = None;
 
-        // These next few matches want to peek through `AscribeUserType` to see
-        // the underlying pattern.
-        let mut unpeeled_pat = pat;
-        while let PatKind::AscribeUserType { ref subpattern, .. } = unpeeled_pat.kind {
-            unpeeled_pat = subpattern;
-        }
-
-        if let Some(def_id) = is_const_pat_that_looks_like_binding(self.tcx, unpeeled_pat) {
+        if let Some(def_id) = is_const_pat_that_looks_like_binding(self.tcx, pat) {
             let span = self.tcx.def_span(def_id);
             let variable = self.tcx.item_name(def_id).to_string();
             // When we encounter a constant as the binding name, point at the `const` definition.
             interpreted_as_const = Some(InterpretedAsConst { span, variable: variable.clone() });
             interpreted_as_const_sugg = Some(InterpretedAsConstSugg { span: pat.span, variable });
-        } else if let PatKind::Constant { .. } = unpeeled_pat.kind
+        } else if let PatKind::Constant { .. } = pat.kind
             && let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(pat.span)
         {
             // If the pattern to match is an integer literal:
@@ -1213,7 +1206,7 @@ fn is_const_pat_that_looks_like_binding<'tcx>(tcx: TyCtxt<'tcx>, pat: &Pat<'tcx>
     // The pattern must be a named constant, and the name that appears in
     // the pattern's source text must resemble a plain identifier without any
     // `::` namespace separators or other non-identifier characters.
-    if let PatKind::ExpandedConstant { def_id, .. } = pat.kind
+    if let Some(def_id) = try { pat.extra.as_deref()?.expanded_const? }
         && matches!(tcx.def_kind(def_id), DefKind::Const)
         && let Ok(snippet) = tcx.sess.source_map().span_to_snippet(pat.span)
         && snippet.chars().all(|c| c.is_alphanumeric() || c == '_')
diff --git a/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs b/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
index 2da9a43f71d86..02409d2bae9fa 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
@@ -90,7 +90,7 @@ impl<'tcx> ConstToPat<'tcx> {
                 );
             }
         }
-        Box::new(Pat { span: self.span, ty, kind: PatKind::Error(err.emit()) })
+        Box::new(Pat { span: self.span, ty, kind: PatKind::Error(err.emit()), extra: None })
     }
 
     fn unevaluated_to_pat(
@@ -174,10 +174,10 @@ impl<'tcx> ConstToPat<'tcx> {
             }
         };
 
-        // Convert the valtree to a const.
-        let inlined_const_as_pat = self.valtree_to_pat(valtree, ty);
+        // Lower the valtree to a THIR pattern.
+        let mut thir_pat = self.valtree_to_pat(valtree, ty);
 
-        if !inlined_const_as_pat.references_error() {
+        if !thir_pat.references_error() {
             // Always check for `PartialEq` if we had no other errors yet.
             if !type_has_partial_eq_impl(self.tcx, typing_env, ty).has_impl {
                 let mut err = self.tcx.dcx().create_err(TypeNotPartialEq { span: self.span, ty });
@@ -186,10 +186,10 @@ impl<'tcx> ConstToPat<'tcx> {
             }
         }
 
-        // Wrap the pattern in a marker node to indicate that it is the result of lowering a
+        // Mark the pattern to indicate that it is the result of lowering a named
         // constant. This is used for diagnostics.
-        let kind = PatKind::ExpandedConstant { subpattern: inlined_const_as_pat, def_id: uv.def };
-        Box::new(Pat { kind, ty, span: self.span })
+        thir_pat.extra.get_or_insert_default().expanded_const = Some(uv.def);
+        thir_pat
     }
 
     fn field_pats(
@@ -351,7 +351,7 @@ impl<'tcx> ConstToPat<'tcx> {
             }
         };
 
-        Box::new(Pat { span, ty, kind })
+        Box::new(Pat { span, ty, kind, extra: None })
     }
 }
 
diff --git a/compiler/rustc_mir_build/src/thir/pattern/mod.rs b/compiler/rustc_mir_build/src/thir/pattern/mod.rs
index 4128508955cb3..650650cbaac90 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/mod.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/mod.rs
@@ -71,14 +71,11 @@ pub(super) fn pat_from_hir<'tcx>(
             span: let_stmt_type.span,
             inferred_ty: typeck_results.node_type(let_stmt_type.hir_id),
         };
-        thir_pat = Box::new(Pat {
-            ty: thir_pat.ty,
-            span: thir_pat.span,
-            kind: PatKind::AscribeUserType {
-                ascription: Ascription { annotation, variance: ty::Covariant },
-                subpattern: thir_pat,
-            },
-        });
+        thir_pat
+            .extra
+            .get_or_insert_default()
+            .ascriptions
+            .push(Ascription { annotation, variance: ty::Covariant });
     }
 
     if let Some(m) = pcx.rust_2024_migration {
@@ -142,7 +139,7 @@ impl<'tcx> PatCtxt<'tcx> {
                 }
                 PatAdjust::PinDeref => PatKind::Deref { subpattern: thir_pat },
             };
-            Box::new(Pat { span, ty: adjust.source, kind })
+            Box::new(Pat { span, ty: adjust.source, kind, extra: None })
         });
 
         if let Some(s) = &mut self.rust_2024_migration
@@ -167,25 +164,14 @@ impl<'tcx> PatCtxt<'tcx> {
         // Return None in that case; the caller will use NegInfinity or PosInfinity instead.
         let Some(expr) = expr else { return Ok(None) };
 
-        // Lower the endpoint into a temporary `PatKind` that will then be
+        // Lower the endpoint into a temporary `thir::Pat` that will then be
         // deconstructed to obtain the constant value and other data.
-        let mut kind: PatKind<'tcx> = self.lower_pat_expr(pat, expr);
-
-        // Unpeel any ascription or inline-const wrapper nodes.
-        loop {
-            match kind {
-                PatKind::AscribeUserType { ascription, subpattern } => {
-                    ascriptions.push(ascription);
-                    kind = subpattern.kind;
-                }
-                PatKind::ExpandedConstant { def_id: _, subpattern } => {
-                    // Expanded-constant nodes are currently only needed by
-                    // diagnostics that don't apply to range patterns, so we
-                    // can just discard them here.
-                    kind = subpattern.kind;
-                }
-                _ => break,
-            }
+        let endpoint_pat: Box<Pat<'tcx>> = self.lower_pat_expr(pat, expr);
+        let box Pat { ref kind, extra, .. } = endpoint_pat;
+
+        // Preserve any ascriptions from endpoint constants.
+        if let Some(extra) = extra {
+            ascriptions.extend(extra.ascriptions);
         }
 
         // The unpeeled kind should now be a constant, giving us the endpoint value.
@@ -250,7 +236,7 @@ impl<'tcx> PatCtxt<'tcx> {
         lo_expr: Option<&'tcx hir::PatExpr<'tcx>>,
         hi_expr: Option<&'tcx hir::PatExpr<'tcx>>,
         end: RangeEnd,
-    ) -> Result<PatKind<'tcx>, ErrorGuaranteed> {
+    ) -> Result<Box<Pat<'tcx>>, ErrorGuaranteed> {
         let ty = self.typeck_results.node_type(pat.hir_id);
         let span = pat.span;
 
@@ -306,27 +292,28 @@ impl<'tcx> PatCtxt<'tcx> {
                 return Err(e);
             }
         }
+        let mut thir_pat = Box::new(Pat { ty, span, kind, extra: None });
 
         // If we are handling a range with associated constants (e.g.
         // `Foo::<'a>::A..=Foo::B`), we need to put the ascriptions for the associated
         // constants somewhere. Have them on the range pattern.
-        for ascription in ascriptions {
-            let subpattern = Box::new(Pat { span, ty, kind });
-            kind = PatKind::AscribeUserType { ascription, subpattern };
-        }
-        // `PatKind::ExpandedConstant` wrappers from range endpoints used to
+        thir_pat.extra.get_or_insert_default().ascriptions.extend(ascriptions);
+        // IDs of expanded constants from range endpoints used to
         // also be preserved here, but that was only needed for unsafeck of
         // inline `const { .. }` patterns, which were removed by
         // <https://github.com/rust-lang/rust/pull/138492>.
 
-        Ok(kind)
+        Ok(thir_pat)
     }
 
     #[instrument(skip(self), level = "debug")]
     fn lower_pattern_unadjusted(&mut self, pat: &'tcx hir::Pat<'tcx>) -> Box<Pat<'tcx>> {
-        let mut ty = self.typeck_results.node_type(pat.hir_id);
-        let mut span = pat.span;
+        let ty = self.typeck_results.node_type(pat.hir_id);
+        let span = pat.span;
 
+        // Some of these match arms return a `Box<Pat>` early, while others
+        // evaluate to a `PatKind` that will become a `Box<Pat>` at the end of
+        // this function.
         let kind = match pat.kind {
             hir::PatKind::Missing => PatKind::Missing,
 
@@ -334,10 +321,13 @@ impl<'tcx> PatCtxt<'tcx> {
 
             hir::PatKind::Never => PatKind::Never,
 
-            hir::PatKind::Expr(value) => self.lower_pat_expr(pat, value),
+            hir::PatKind::Expr(value) => return self.lower_pat_expr(pat, value),
 
             hir::PatKind::Range(lo_expr, hi_expr, end) => {
-                self.lower_pattern_range(pat, lo_expr, hi_expr, end).unwrap_or_else(PatKind::Error)
+                match self.lower_pattern_range(pat, lo_expr, hi_expr, end) {
+                    Ok(thir_pat) => return thir_pat,
+                    Err(e) => PatKind::Error(e),
+                }
             }
 
             hir::PatKind::Deref(subpattern) => {
@@ -360,7 +350,7 @@ impl<'tcx> PatCtxt<'tcx> {
             },
 
             hir::PatKind::Slice(prefix, slice, suffix) => {
-                self.slice_or_array_pattern(pat, prefix, slice, suffix)
+                return self.slice_or_array_pattern(pat, prefix, slice, suffix);
             }
 
             hir::PatKind::Tuple(pats, ddpos) => {
@@ -372,8 +362,9 @@ impl<'tcx> PatCtxt<'tcx> {
             }
 
             hir::PatKind::Binding(explicit_ba, id, ident, sub) => {
+                let mut thir_pat_span = span;
                 if let Some(ident_span) = ident.span.find_ancestor_inside(span) {
-                    span = span.with_hi(ident_span.hi());
+                    thir_pat_span = span.with_hi(ident_span.hi());
                 }
 
                 let mode = *self
@@ -389,22 +380,23 @@ impl<'tcx> PatCtxt<'tcx> {
                 // A ref x pattern is the same node used for x, and as such it has
                 // x's type, which is &T, where we want T (the type being matched).
                 let var_ty = ty;
+                let mut thir_pat_ty = ty;
                 if let hir::ByRef::Yes(pinnedness, _) = mode.0 {
                     match pinnedness {
                         hir::Pinnedness::Pinned
                             if let Some(pty) = ty.pinned_ty()
                                 && let &ty::Ref(_, rty, _) = pty.kind() =>
                         {
-                            ty = rty;
+                            thir_pat_ty = rty;
                         }
                         hir::Pinnedness::Not if let &ty::Ref(_, rty, _) = ty.kind() => {
-                            ty = rty;
+                            thir_pat_ty = rty;
                         }
                         _ => bug!("`ref {}` has wrong type {}", ident, ty),
                     }
                 };
 
-                PatKind::Binding {
+                let kind = PatKind::Binding {
                     mode,
                     name: ident.name,
                     var: LocalVarId(id),
@@ -412,7 +404,10 @@ impl<'tcx> PatCtxt<'tcx> {
                     subpattern: self.lower_opt_pattern(sub),
                     is_primary: id == pat.hir_id,
                     is_shorthand: false,
-                }
+                };
+                // We might have modified the type or span, so use the modified
+                // values in the THIR pattern node.
+                return Box::new(Pat { ty: thir_pat_ty, span: thir_pat_span, kind, extra: None });
             }
 
             hir::PatKind::TupleStruct(ref qpath, pats, ddpos) => {
@@ -422,7 +417,7 @@ impl<'tcx> PatCtxt<'tcx> {
                 };
                 let variant_def = adt_def.variant_of_res(res);
                 let subpatterns = self.lower_tuple_subpats(pats, variant_def.fields.len(), ddpos);
-                self.lower_variant_or_leaf(pat, None, res, subpatterns)
+                return self.lower_variant_or_leaf(pat, None, res, subpatterns);
             }
 
             hir::PatKind::Struct(ref qpath, fields, _) => {
@@ -439,7 +434,7 @@ impl<'tcx> PatCtxt<'tcx> {
                     })
                     .collect();
 
-                self.lower_variant_or_leaf(pat, None, res, subpatterns)
+                return self.lower_variant_or_leaf(pat, None, res, subpatterns);
             }
 
             hir::PatKind::Or(pats) => PatKind::Or { pats: self.lower_patterns(pats) },
@@ -450,7 +445,9 @@ impl<'tcx> PatCtxt<'tcx> {
             hir::PatKind::Err(guar) => PatKind::Error(guar),
         };
 
-        Box::new(Pat { span, ty, kind })
+        // For pattern kinds that haven't already returned, create a `thir::Pat`
+        // with the HIR pattern node's type and span.
+        Box::new(Pat { span, ty, kind, extra: None })
     }
 
     fn lower_tuple_subpats(
@@ -482,13 +479,14 @@ impl<'tcx> PatCtxt<'tcx> {
         prefix: &'tcx [hir::Pat<'tcx>],
         slice: Option<&'tcx hir::Pat<'tcx>>,
         suffix: &'tcx [hir::Pat<'tcx>],
-    ) -> PatKind<'tcx> {
+    ) -> Box<Pat<'tcx>> {
         let ty = self.typeck_results.node_type(pat.hir_id);
+        let span = pat.span;
 
         let prefix = self.lower_patterns(prefix);
         let slice = self.lower_opt_pattern(slice);
         let suffix = self.lower_patterns(suffix);
-        match ty.kind() {
+        let kind = match ty.kind() {
             // Matching a slice, `[T]`.
             ty::Slice(..) => PatKind::Slice { prefix, slice, suffix },
             // Fixed-length array, `[T; len]`.
@@ -499,8 +497,9 @@ impl<'tcx> PatCtxt<'tcx> {
                 assert!(len >= prefix.len() as u64 + suffix.len() as u64);
                 PatKind::Array { prefix, slice, suffix }
             }
-            _ => span_bug!(pat.span, "bad slice pattern type {ty:?}"),
-        }
+            _ => span_bug!(span, "bad slice pattern type {ty:?}"),
+        };
+        Box::new(Pat { ty, span, kind, extra: None })
     }
 
     fn lower_variant_or_leaf(
@@ -509,7 +508,7 @@ impl<'tcx> PatCtxt<'tcx> {
         expr: Option<&'tcx hir::PatExpr<'tcx>>,
         res: Res,
         subpatterns: Vec<FieldPat<'tcx>>,
-    ) -> PatKind<'tcx> {
+    ) -> Box<Pat<'tcx>> {
         // Check whether the caller should have provided an `expr` for this pattern kind.
         assert_matches!(
             (pat.kind, expr),
@@ -533,7 +532,7 @@ impl<'tcx> PatCtxt<'tcx> {
             res => res,
         };
 
-        let mut kind = match res {
+        let kind = match res {
             Res::Def(DefKind::Variant, variant_id) => {
                 let enum_id = self.tcx.parent(variant_id);
                 let adt_def = self.tcx.adt_def(enum_id);
@@ -542,7 +541,12 @@ impl<'tcx> PatCtxt<'tcx> {
                         ty::Adt(_, args) | ty::FnDef(_, args) => args,
                         ty::Error(e) => {
                             // Avoid ICE (#50585)
-                            return PatKind::Error(*e);
+                            return Box::new(Pat {
+                                ty,
+                                span,
+                                kind: PatKind::Error(*e),
+                                extra: None,
+                            });
                         }
                         _ => bug!("inappropriate type for def: {:?}", ty),
                     };
@@ -583,21 +587,23 @@ impl<'tcx> PatCtxt<'tcx> {
                 PatKind::Error(e)
             }
         };
+        let mut thir_pat = Box::new(Pat { ty, span, kind, extra: None });
 
         if let Some(user_ty) = self.user_args_applied_to_ty_of_hir_id(hir_id) {
-            debug!("lower_variant_or_leaf: kind={:?} user_ty={:?} span={:?}", kind, user_ty, span);
+            debug!(?thir_pat, ?user_ty, ?span, "lower_variant_or_leaf: applying ascription");
             let annotation = CanonicalUserTypeAnnotation {
                 user_ty: Box::new(user_ty),
                 span,
                 inferred_ty: self.typeck_results.node_type(hir_id),
             };
-            kind = PatKind::AscribeUserType {
-                subpattern: Box::new(Pat { span, ty, kind }),
-                ascription: Ascription { annotation, variance: ty::Covariant },
-            };
+            thir_pat
+                .extra
+                .get_or_insert_default()
+                .ascriptions
+                .push(Ascription { annotation, variance: ty::Covariant });
         }
 
-        kind
+        thir_pat
     }
 
     fn user_args_applied_to_ty_of_hir_id(
@@ -632,8 +638,7 @@ impl<'tcx> PatCtxt<'tcx> {
             _ => {
                 // The path isn't the name of a constant, so it must actually
                 // be a unit struct or unit variant (e.g. `Option::None`).
-                let kind = self.lower_variant_or_leaf(pat, Some(expr), res, vec![]);
-                return Box::new(Pat { span, ty, kind });
+                return self.lower_variant_or_leaf(pat, Some(expr), res, vec![]);
             }
         };
 
@@ -652,16 +657,13 @@ impl<'tcx> PatCtxt<'tcx> {
                 span,
                 inferred_ty: self.typeck_results.node_type(id),
             };
-            let kind = PatKind::AscribeUserType {
-                subpattern: pattern,
-                ascription: Ascription {
-                    annotation,
-                    // Note that we use `Contravariant` here. See the
-                    // `variance` field documentation for details.
-                    variance: ty::Contravariant,
-                },
-            };
-            pattern = Box::new(Pat { span, kind, ty });
+            // Note that we use `Contravariant` here. See the
+            // `variance` field documentation for details.
+            pattern
+                .extra
+                .get_or_insert_default()
+                .ascriptions
+                .push(Ascription { annotation, variance: ty::Contravariant });
         }
 
         pattern
@@ -674,10 +676,10 @@ impl<'tcx> PatCtxt<'tcx> {
         &mut self,
         pat: &'tcx hir::Pat<'tcx>, // Pattern that directly contains `expr`
         expr: &'tcx hir::PatExpr<'tcx>,
-    ) -> PatKind<'tcx> {
+    ) -> Box<Pat<'tcx>> {
         assert_matches!(pat.kind, hir::PatKind::Expr(..) | hir::PatKind::Range(..));
         match &expr.kind {
-            hir::PatExprKind::Path(qpath) => self.lower_path(pat, expr, qpath).kind,
+            hir::PatExprKind::Path(qpath) => self.lower_path(pat, expr, qpath),
             hir::PatExprKind::Lit { lit, negated } => {
                 // We handle byte string literal patterns by using the pattern's type instead of the
                 // literal's type in `const_to_pat`: if the literal `b"..."` matches on a slice reference,
@@ -691,7 +693,7 @@ impl<'tcx> PatCtxt<'tcx> {
                 let pat_ty = self.typeck_results.node_type(pat.hir_id);
                 let lit_input = LitToConstInput { lit: lit.node, ty: pat_ty, neg: *negated };
                 let constant = self.tcx.at(expr.span).lit_to_const(lit_input);
-                self.const_to_pat(constant, pat_ty, expr.hir_id, lit.span).kind
+                self.const_to_pat(constant, pat_ty, expr.hir_id, lit.span)
             }
         }
     }
diff --git a/compiler/rustc_mir_build/src/thir/print.rs b/compiler/rustc_mir_build/src/thir/print.rs
index 5a2d6cfef1cc7..e12909305961d 100644
--- a/compiler/rustc_mir_build/src/thir/print.rs
+++ b/compiler/rustc_mir_build/src/thir/print.rs
@@ -73,6 +73,24 @@ impl<'a, 'tcx> ThirPrinter<'a, 'tcx> {
         self.fmt
     }
 
+    fn print_list<T>(
+        &mut self,
+        label: &str,
+        list: &[T],
+        depth_lvl: usize,
+        print_fn: impl Fn(&mut Self, &T, usize),
+    ) {
+        if list.is_empty() {
+            print_indented!(self, format_args!("{label}: []"), depth_lvl);
+        } else {
+            print_indented!(self, format_args!("{label}: ["), depth_lvl);
+            for item in list {
+                print_fn(self, item, depth_lvl + 1)
+            }
+            print_indented!(self, "]", depth_lvl);
+        }
+    }
+
     fn print_param(&mut self, param: &Param<'tcx>, depth_lvl: usize) {
         let Param { pat, ty, ty_span, self_kind, hir_id } = param;
 
@@ -663,15 +681,37 @@ impl<'a, 'tcx> ThirPrinter<'a, 'tcx> {
     }
 
     fn print_pat(&mut self, pat: &Pat<'tcx>, depth_lvl: usize) {
-        let &Pat { ty, span, ref kind } = pat;
+        let &Pat { ty, span, ref kind, ref extra } = pat;
 
         print_indented!(self, "Pat: {", depth_lvl);
         print_indented!(self, format!("ty: {:?}", ty), depth_lvl + 1);
         print_indented!(self, format!("span: {:?}", span), depth_lvl + 1);
+        self.print_pat_extra(extra.as_deref(), depth_lvl + 1);
         self.print_pat_kind(kind, depth_lvl + 1);
         print_indented!(self, "}", depth_lvl);
     }
 
+    fn print_pat_extra(&mut self, extra: Option<&PatExtra<'tcx>>, depth_lvl: usize) {
+        let Some(extra) = extra else {
+            // Skip printing in the common case of a pattern node with no extra data.
+            return;
+        };
+
+        let PatExtra { expanded_const, ascriptions } = extra;
+
+        print_indented!(self, "extra: PatExtra {", depth_lvl);
+        print_indented!(self, format_args!("expanded_const: {expanded_const:?}"), depth_lvl + 1);
+        self.print_list(
+            "ascriptions",
+            ascriptions,
+            depth_lvl + 1,
+            |this, ascription, depth_lvl| {
+                print_indented!(this, format_args!("{ascription:?}"), depth_lvl);
+            },
+        );
+        print_indented!(self, "}", depth_lvl);
+    }
+
     fn print_pat_kind(&mut self, pat_kind: &PatKind<'tcx>, depth_lvl: usize) {
         print_indented!(self, "kind: PatKind {", depth_lvl);
 
@@ -685,13 +725,6 @@ impl<'a, 'tcx> ThirPrinter<'a, 'tcx> {
             PatKind::Never => {
                 print_indented!(self, "Never", depth_lvl + 1);
             }
-            PatKind::AscribeUserType { ascription, subpattern } => {
-                print_indented!(self, "AscribeUserType: {", depth_lvl + 1);
-                print_indented!(self, format!("ascription: {:?}", ascription), depth_lvl + 2);
-                print_indented!(self, "subpattern: ", depth_lvl + 2);
-                self.print_pat(subpattern, depth_lvl + 3);
-                print_indented!(self, "}", depth_lvl + 1);
-            }
             PatKind::Binding { name, mode, var, ty, subpattern, is_primary, is_shorthand } => {
                 print_indented!(self, "Binding {", depth_lvl + 1);
                 print_indented!(self, format!("name: {:?}", name), depth_lvl + 2);
@@ -756,13 +789,6 @@ impl<'a, 'tcx> ThirPrinter<'a, 'tcx> {
                 print_indented!(self, format!("value: {}", value), depth_lvl + 2);
                 print_indented!(self, "}", depth_lvl + 1);
             }
-            PatKind::ExpandedConstant { def_id, subpattern } => {
-                print_indented!(self, "ExpandedConstant {", depth_lvl + 1);
-                print_indented!(self, format!("def_id: {def_id:?}"), depth_lvl + 2);
-                print_indented!(self, "subpattern:", depth_lvl + 2);
-                self.print_pat(subpattern, depth_lvl + 2);
-                print_indented!(self, "}", depth_lvl + 1);
-            }
             PatKind::Range(pat_range) => {
                 print_indented!(self, format!("Range ( {:?} )", pat_range), depth_lvl + 1);
             }
diff --git a/compiler/rustc_pattern_analysis/src/rustc.rs b/compiler/rustc_pattern_analysis/src/rustc.rs
index d66c303b17260..721635ed48ff5 100644
--- a/compiler/rustc_pattern_analysis/src/rustc.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc.rs
@@ -462,8 +462,6 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
         let arity;
         let fields: Vec<_>;
         match &pat.kind {
-            PatKind::AscribeUserType { subpattern, .. }
-            | PatKind::ExpandedConstant { subpattern, .. } => return self.lower_pat(subpattern),
             PatKind::Binding { subpattern: Some(subpat), .. } => return self.lower_pat(subpat),
             PatKind::Missing | PatKind::Binding { subpattern: None, .. } | PatKind::Wild => {
                 ctor = Wildcard;
diff --git a/compiler/rustc_resolve/src/def_collector.rs b/compiler/rustc_resolve/src/def_collector.rs
index b392b7747b554..ea5640ecc1fa9 100644
--- a/compiler/rustc_resolve/src/def_collector.rs
+++ b/compiler/rustc_resolve/src/def_collector.rs
@@ -419,7 +419,7 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
 
             // Avoid overwriting `const_arg_context` as we may want to treat const blocks
             // as being anon consts if we are inside a const argument.
-            ExprKind::Struct(_) | ExprKind::Call(..) | ExprKind::Tup(..) => {
+            ExprKind::Struct(_) | ExprKind::Call(..) | ExprKind::Tup(..) | ExprKind::Array(..) => {
                 return visit::walk_expr(self, expr);
             }
             // FIXME(mgca): we may want to handle block labels in some manner
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 1b868a933af8c..b473d36a45fcb 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -284,6 +284,7 @@ symbols! {
         IteratorItem,
         IteratorMap,
         Layout,
+        Leaf,
         Left,
         LinkedList,
         LintDiagnostic,
@@ -302,6 +303,7 @@ symbols! {
         Ordering,
         OsStr,
         OsString,
+        Other,
         Output,
         Param,
         ParamSet,
@@ -380,6 +382,7 @@ symbols! {
         TryCapturePrintable,
         TryFrom,
         TryInto,
+        Tuple,
         Ty,
         TyCtxt,
         TyKind,
@@ -2318,6 +2321,7 @@ symbols! {
         type_const,
         type_id,
         type_id_eq,
+        type_info,
         type_ir,
         type_ir_infer_ctxt_like,
         type_ir_inherent,
@@ -2325,6 +2329,7 @@ symbols! {
         type_length_limit,
         type_macros,
         type_name,
+        type_of,
         type_privacy_lints,
         typed_swap_nonoverlapping,
         u8,
diff --git a/library/core/src/cmp.rs b/library/core/src/cmp.rs
index 2f2477008206e..78ea1f1113258 100644
--- a/library/core/src/cmp.rs
+++ b/library/core/src/cmp.rs
@@ -1190,7 +1190,7 @@ pub macro Ord($item:item) {
 /// every `a`. This isn't always the case for types that implement `PartialOrd`, for example:
 ///
 /// ```
-/// let a = f64::sqrt(-1.0);
+/// let a = f64::NAN;
 /// assert_eq!(a <= a, false);
 /// ```
 ///
diff --git a/library/core/src/intrinsics/mod.rs b/library/core/src/intrinsics/mod.rs
index 27e1673c51de7..20f34036b25c9 100644
--- a/library/core/src/intrinsics/mod.rs
+++ b/library/core/src/intrinsics/mod.rs
@@ -2845,6 +2845,15 @@ pub const unsafe fn size_of_val<T: ?Sized>(ptr: *const T) -> usize;
 #[rustc_intrinsic_const_stable_indirect]
 pub const unsafe fn align_of_val<T: ?Sized>(ptr: *const T) -> usize;
 
+/// Compute the type information of a concrete type.
+/// It can only be called at compile time, the backends do
+/// not implement it.
+#[rustc_intrinsic]
+#[unstable(feature = "core_intrinsics", issue = "none")]
+pub const fn type_of(_id: crate::any::TypeId) -> crate::mem::type_info::Type {
+    panic!("`TypeId::info` can only be called at compile-time")
+}
+
 /// Gets a static string slice containing the name of a type.
 ///
 /// Note that, unlike most intrinsics, this can only be called at compile-time
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index 962b0cea4a4f1..dfc9a7b5dbc32 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -124,6 +124,7 @@
 #![feature(str_internals)]
 #![feature(str_split_inclusive_remainder)]
 #![feature(str_split_remainder)]
+#![feature(type_info)]
 #![feature(ub_checks)]
 #![feature(unsafe_pinned)]
 #![feature(utf16_extra)]
diff --git a/library/core/src/mem/mod.rs b/library/core/src/mem/mod.rs
index 4f7edce1e977f..1671c8219de16 100644
--- a/library/core/src/mem/mod.rs
+++ b/library/core/src/mem/mod.rs
@@ -37,6 +37,9 @@ pub use drop_guard::DropGuard;
 #[doc(inline)]
 pub use crate::intrinsics::transmute;
 
+#[unstable(feature = "type_info", issue = "146922")]
+pub mod type_info;
+
 /// Takes ownership and "forgets" about the value **without running its destructor**.
 ///
 /// Any resources the value manages, such as heap memory or a file handle, will linger
diff --git a/library/core/src/mem/type_info.rs b/library/core/src/mem/type_info.rs
new file mode 100644
index 0000000000000..7938e2b52ed02
--- /dev/null
+++ b/library/core/src/mem/type_info.rs
@@ -0,0 +1,71 @@
+//! MVP for exposing compile-time information about types in a
+//! runtime or const-eval processable way.
+
+use crate::any::TypeId;
+use crate::intrinsics::type_of;
+
+/// Compile-time type information.
+#[derive(Debug)]
+#[non_exhaustive]
+#[lang = "type_info"]
+#[unstable(feature = "type_info", issue = "146922")]
+pub struct Type {
+    /// Per-type information
+    pub kind: TypeKind,
+    /// Size of the type. `None` if it is unsized
+    pub size: Option<usize>,
+}
+
+impl TypeId {
+    /// Compute the type information of a concrete type.
+    /// It can only be called at compile time.
+    #[unstable(feature = "type_info", issue = "146922")]
+    #[rustc_const_unstable(feature = "type_info", issue = "146922")]
+    pub const fn info(self) -> Type {
+        type_of(self)
+    }
+}
+
+impl Type {
+    /// Returns the type information of the generic type parameter.
+    #[unstable(feature = "type_info", issue = "146922")]
+    #[rustc_const_unstable(feature = "type_info", issue = "146922")]
+    // FIXME(reflection): don't require the 'static bound
+    pub const fn of<T: 'static>() -> Self {
+        const { TypeId::of::<T>().info() }
+    }
+}
+
+/// Compile-time type information.
+#[derive(Debug)]
+#[non_exhaustive]
+#[unstable(feature = "type_info", issue = "146922")]
+pub enum TypeKind {
+    /// Tuples.
+    Tuple(Tuple),
+    /// Primitives
+    /// FIXME(#146922): disambiguate further
+    Leaf,
+    /// FIXME(#146922): add all the common types
+    Other,
+}
+
+/// Compile-time type information about tuples.
+#[derive(Debug)]
+#[non_exhaustive]
+#[unstable(feature = "type_info", issue = "146922")]
+pub struct Tuple {
+    /// All fields of a tuple.
+    pub fields: &'static [Field],
+}
+
+/// Compile-time type information about fields of tuples, structs and enum variants.
+#[derive(Debug)]
+#[non_exhaustive]
+#[unstable(feature = "type_info", issue = "146922")]
+pub struct Field {
+    /// The field's type.
+    pub ty: TypeId,
+    /// Offset in bytes from the parent type
+    pub offset: usize,
+}
diff --git a/library/std/Cargo.toml b/library/std/Cargo.toml
index 43caf7734fdbd..5c9ae52d9e6c0 100644
--- a/library/std/Cargo.toml
+++ b/library/std/Cargo.toml
@@ -128,10 +128,6 @@ debug_refcell = ["core/debug_refcell"]
 
 llvm_enzyme = ["core/llvm_enzyme"]
 
-# Enable std_detect features:
-std_detect_file_io = ["std_detect/std_detect_file_io"]
-std_detect_dlsym_getauxval = ["std_detect/std_detect_dlsym_getauxval"]
-
 # Enable using raw-dylib for Windows imports.
 # This will eventually be the default.
 windows_raw_dylib = ["windows-targets/windows_raw_dylib"]
diff --git a/library/std/src/fs.rs b/library/std/src/fs.rs
index 4edd35b310bd0..a24baad615012 100644
--- a/library/std/src/fs.rs
+++ b/library/std/src/fs.rs
@@ -3446,30 +3446,48 @@ impl DirBuilder {
     }
 
     fn create_dir_all(&self, path: &Path) -> io::Result<()> {
-        if path == Path::new("") {
+        // if path's parent is None, it is "/" path, which should
+        // return Ok immediately
+        if path == Path::new("") || path.parent() == None {
             return Ok(());
         }
 
-        match self.inner.mkdir(path) {
-            Ok(()) => return Ok(()),
-            Err(ref e) if e.kind() == io::ErrorKind::NotFound => {}
-            Err(_) if path.is_dir() => return Ok(()),
-            Err(e) => return Err(e),
-        }
-        match path.parent() {
-            Some(p) => self.create_dir_all(p)?,
-            None => {
-                return Err(io::const_error!(
-                    io::ErrorKind::Uncategorized,
-                    "failed to create whole tree",
-                ));
+        let ancestors = path.ancestors();
+        let mut uncreated_dirs = 0;
+
+        for ancestor in ancestors {
+            // for relative paths like "foo/bar", the parent of
+            // "foo" will be "" which there's no need to invoke
+            // a mkdir syscall on
+            if ancestor == Path::new("") || ancestor.parent() == None {
+                break;
+            }
+
+            match self.inner.mkdir(ancestor) {
+                Ok(()) => break,
+                Err(e) if e.kind() == io::ErrorKind::NotFound => uncreated_dirs += 1,
+                // we check if the err is AlreadyExists for two reasons
+                //    - in case the path exists as a *file*
+                //    - and to avoid calls to .is_dir() in case of other errs
+                //      (i.e. PermissionDenied)
+                Err(e) if e.kind() == io::ErrorKind::AlreadyExists && ancestor.is_dir() => break,
+                Err(e) => return Err(e),
             }
         }
-        match self.inner.mkdir(path) {
-            Ok(()) => Ok(()),
-            Err(_) if path.is_dir() => Ok(()),
-            Err(e) => Err(e),
+
+        // collect only the uncreated directories w/o letting the vec resize
+        let mut uncreated_dirs_vec = Vec::with_capacity(uncreated_dirs);
+        uncreated_dirs_vec.extend(ancestors.take(uncreated_dirs));
+
+        for uncreated_dir in uncreated_dirs_vec.iter().rev() {
+            if let Err(e) = self.inner.mkdir(uncreated_dir) {
+                if e.kind() != io::ErrorKind::AlreadyExists || !uncreated_dir.is_dir() {
+                    return Err(e);
+                }
+            }
         }
+
+        Ok(())
     }
 }
 
diff --git a/library/std/src/os/unix/io/mod.rs b/library/std/src/os/unix/io/mod.rs
index 6d4090ee31cfc..708ebaec362e4 100644
--- a/library/std/src/os/unix/io/mod.rs
+++ b/library/std/src/os/unix/io/mod.rs
@@ -92,9 +92,138 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
+use crate::io::{self, Stderr, StderrLock, Stdin, StdinLock, Stdout, StdoutLock, Write};
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use crate::os::fd::*;
+#[allow(unused_imports)] // not used on all targets
+use crate::sys::cvt;
 
 // Tests for this module
 #[cfg(test)]
 mod tests;
+
+#[unstable(feature = "stdio_swap", issue = "150667", reason = "recently added")]
+pub trait StdioExt: crate::sealed::Sealed {
+    /// Redirects the stdio file descriptor to point to the file description underpinning `fd`.
+    ///
+    /// Rust std::io write buffers (if any) are flushed, but other runtimes
+    /// (e.g. C stdio) or libraries that acquire a clone of the file descriptor
+    /// will not be aware of this change.
+    ///
+    /// # Platform-specific behavior
+    ///
+    /// This is [currently] implemented using
+    ///
+    /// - `fd_renumber` on wasip1
+    /// - `dup2` on most unixes
+    ///
+    /// [currently]: crate::io#platform-specific-behavior
+    ///
+    /// ```
+    /// #![feature(stdio_swap)]
+    /// use std::io::{self, Read, Write};
+    /// use std::os::unix::io::StdioExt;
+    ///
+    /// fn main() -> io::Result<()> {
+    ///    let (reader, mut writer) = io::pipe()?;
+    ///    let mut stdin = io::stdin();
+    ///    stdin.set_fd(reader)?;
+    ///    writer.write_all(b"Hello, world!")?;
+    ///    let mut buffer = vec![0; 13];
+    ///    assert_eq!(stdin.read(&mut buffer)?, 13);
+    ///    assert_eq!(&buffer, b"Hello, world!");
+    ///    Ok(())
+    /// }
+    /// ```
+    fn set_fd<T: Into<OwnedFd>>(&mut self, fd: T) -> io::Result<()>;
+
+    /// Redirects the stdio file descriptor and returns a new `OwnedFd`
+    /// backed by the previous file description.
+    ///
+    /// See [`set_fd()`] for details.
+    ///
+    /// [`set_fd()`]: StdioExt::set_fd
+    fn replace_fd<T: Into<OwnedFd>>(&mut self, replace_with: T) -> io::Result<OwnedFd>;
+
+    /// Redirects the stdio file descriptor to the null device (`/dev/null`)
+    /// and returns a new `OwnedFd` backed by the previous file description.
+    ///
+    /// Programs that communicate structured data via stdio can use this early in `main()` to
+    /// extract the fds, treat them as other IO types (`File`, `UnixStream`, etc),
+    /// apply custom buffering or avoid interference from stdio use later in the program.
+    ///
+    /// See [`set_fd()`] for additional details.
+    ///
+    /// [`set_fd()`]: StdioExt::set_fd
+    fn take_fd(&mut self) -> io::Result<OwnedFd>;
+}
+
+macro io_ext_impl($stdio_ty:ty, $stdio_lock_ty:ty, $writer:literal) {
+    #[unstable(feature = "stdio_swap", issue = "150667", reason = "recently added")]
+    impl StdioExt for $stdio_ty {
+        fn set_fd<T: Into<OwnedFd>>(&mut self, fd: T) -> io::Result<()> {
+            self.lock().set_fd(fd)
+        }
+
+        fn take_fd(&mut self) -> io::Result<OwnedFd> {
+            self.lock().take_fd()
+        }
+
+        fn replace_fd<T: Into<OwnedFd>>(&mut self, replace_with: T) -> io::Result<OwnedFd> {
+            self.lock().replace_fd(replace_with)
+        }
+    }
+
+    #[unstable(feature = "stdio_swap", issue = "150667", reason = "recently added")]
+    impl StdioExt for $stdio_lock_ty {
+        fn set_fd<T: Into<OwnedFd>>(&mut self, fd: T) -> io::Result<()> {
+            #[cfg($writer)]
+            self.flush()?;
+            replace_stdio_fd(self.as_fd(), fd.into())
+        }
+
+        fn take_fd(&mut self) -> io::Result<OwnedFd> {
+            let null = null_fd()?;
+            let cloned = self.as_fd().try_clone_to_owned()?;
+            self.set_fd(null)?;
+            Ok(cloned)
+        }
+
+        fn replace_fd<T: Into<OwnedFd>>(&mut self, replace_with: T) -> io::Result<OwnedFd> {
+            let cloned = self.as_fd().try_clone_to_owned()?;
+            self.set_fd(replace_with)?;
+            Ok(cloned)
+        }
+    }
+}
+
+io_ext_impl!(Stdout, StdoutLock<'_>, true);
+io_ext_impl!(Stdin, StdinLock<'_>, false);
+io_ext_impl!(Stderr, StderrLock<'_>, true);
+
+fn null_fd() -> io::Result<OwnedFd> {
+    let null_dev = crate::fs::OpenOptions::new().read(true).write(true).open("/dev/null")?;
+    Ok(null_dev.into())
+}
+
+/// Replaces the underlying file descriptor with the one from `other`.
+/// Does not set CLOEXEC.
+fn replace_stdio_fd(this: BorrowedFd<'_>, other: OwnedFd) -> io::Result<()> {
+    cfg_select! {
+        all(target_os = "wasi", target_env = "p1") => {
+            cvt(unsafe { libc::__wasilibc_fd_renumber(other.as_raw_fd(), this.as_raw_fd()) }).map(|_| ())
+        }
+        not(any(
+            target_arch = "wasm32",
+            target_os = "hermit",
+            target_os = "trusty",
+            target_os = "motor"
+        )) => {
+            cvt(unsafe {libc::dup2(other.as_raw_fd(), this.as_raw_fd())}).map(|_| ())
+        }
+        _ => {
+            let _ = (this, other);
+            Err(io::Error::UNSUPPORTED_PLATFORM)
+        }
+    }
+}
diff --git a/library/std/src/sys/fs/uefi.rs b/library/std/src/sys/fs/uefi.rs
index fcf21d9e97318..88c9d095ceccd 100644
--- a/library/std/src/sys/fs/uefi.rs
+++ b/library/std/src/sys/fs/uefi.rs
@@ -285,11 +285,11 @@ impl File {
     }
 
     pub fn fsync(&self) -> io::Result<()> {
-        unsupported()
+        self.datasync()
     }
 
     pub fn datasync(&self) -> io::Result<()> {
-        unsupported()
+        self.0.flush()
     }
 
     pub fn lock(&self) -> io::Result<()> {
@@ -336,8 +336,8 @@ impl File {
         crate::io::default_read_buf(|buf| self.read(buf), cursor)
     }
 
-    pub fn write(&self, _buf: &[u8]) -> io::Result<usize> {
-        unsupported()
+    pub fn write(&self, buf: &[u8]) -> io::Result<usize> {
+        self.0.write(buf)
     }
 
     pub fn write_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
@@ -348,8 +348,9 @@ impl File {
         false
     }
 
+    // Write::flush is only meant for buffered writers. So should be noop for unbuffered files.
     pub fn flush(&self) -> io::Result<()> {
-        unsupported()
+        Ok(())
     }
 
     pub fn seek(&self, _pos: SeekFrom) -> io::Result<u64> {
@@ -705,6 +706,25 @@ mod uefi_fs {
             }
         }
 
+        pub(crate) fn write(&self, buf: &[u8]) -> io::Result<usize> {
+            let file_ptr = self.protocol.as_ptr();
+            let mut buf_size = buf.len();
+
+            let r = unsafe {
+                ((*file_ptr).write)(
+                    file_ptr,
+                    &mut buf_size,
+                    buf.as_ptr().cast::<crate::ffi::c_void>().cast_mut(),
+                )
+            };
+
+            if buf_size == 0 && r.is_error() {
+                Err(io::Error::from_raw_os_error(r.as_usize()))
+            } else {
+                Ok(buf_size)
+            }
+        }
+
         pub(crate) fn file_info(&self) -> io::Result<UefiBox<file::Info>> {
             let file_ptr = self.protocol.as_ptr();
             let mut info_id = file::INFO_ID;
@@ -765,6 +785,12 @@ mod uefi_fs {
             if r.is_error() { Err(io::Error::from_raw_os_error(r.as_usize())) } else { Ok(()) }
         }
 
+        pub(crate) fn flush(&self) -> io::Result<()> {
+            let file_ptr = self.protocol.as_ptr();
+            let r = unsafe { ((*file_ptr).flush)(file_ptr) };
+            if r.is_error() { Err(io::Error::from_raw_os_error(r.as_usize())) } else { Ok(()) }
+        }
+
         pub(crate) fn path(&self) -> &Path {
             &self.path
         }
diff --git a/library/std_detect/Cargo.toml b/library/std_detect/Cargo.toml
index 2739bb5923009..a6785bb20555d 100644
--- a/library/std_detect/Cargo.toml
+++ b/library/std_detect/Cargo.toml
@@ -7,11 +7,6 @@ authors = [
     "Gonzalo Brito Gadeschi <gonzalobg88@gmail.com>",
 ]
 description = "`std::detect` - Rust's standard library run-time CPU feature detection."
-homepage = "https://github.com/rust-lang/stdarch"
-repository = "https://github.com/rust-lang/stdarch"
-readme = "README.md"
-keywords = ["std", "run-time", "feature", "detection"]
-categories = ["hardware-support"]
 license = "MIT OR Apache-2.0"
 edition = "2024"
 
@@ -25,10 +20,7 @@ core = { version = "1.0.0", package = 'rustc-std-workspace-core' }
 alloc = { version = "1.0.0", package = 'rustc-std-workspace-alloc' }
 
 [target.'cfg(not(windows))'.dependencies]
-libc = { version = "0.2.0", optional = true, default-features = false }
+libc = { version = "0.2.0", default-features = false }
 
 [features]
-default = []
-std_detect_file_io = [ "libc" ]
-std_detect_dlsym_getauxval = [ "libc" ]
-std_detect_env_override = [ "libc" ]
+std_detect_env_override = []
diff --git a/library/std_detect/README.md b/library/std_detect/README.md
index 177848dec1044..895f3426d0495 100644
--- a/library/std_detect/README.md
+++ b/library/std_detect/README.md
@@ -21,32 +21,6 @@ run-time feature detection support than the one offered by Rust's standard
 library. We intend to make `std_detect` more flexible and configurable in this
 regard to better serve the needs of `#[no_std]` targets.
 
-# Features
-
-* `std_detect_dlsym_getauxval` (enabled by default, requires `libc`): Enable to
-use `libc::dlsym` to query whether [`getauxval`] is linked into the binary. When
-this is not the case, this feature allows other fallback methods to perform
-run-time feature detection. When this feature is disabled, `std_detect` assumes
-that [`getauxval`] is linked to the binary. If that is not the case the behavior
-is undefined.
-
-  Note: This feature is ignored on `*-linux-{gnu,musl,ohos}*` and `*-android*` targets
-  because we can safely assume `getauxval` is linked to the binary.
-  * `*-linux-gnu*` targets ([since Rust 1.64](https://blog.rust-lang.org/2022/08/01/Increasing-glibc-kernel-requirements.html))
-    have glibc requirements higher than [glibc 2.16 that added `getauxval`](https://sourceware.org/legacy-ml/libc-announce/2012/msg00000.html).
-  * `*-linux-musl*` targets ([at least since Rust 1.15](https://github.com/rust-lang/rust/blob/1.15.0/src/ci/docker/x86_64-musl/build-musl.sh#L15))
-    use musl newer than [musl 1.1.0 that added `getauxval`](https://git.musl-libc.org/cgit/musl/tree/WHATSNEW?h=v1.1.0#n1197)
-  * `*-linux-ohos*` targets use a [fork of musl 1.2](https://gitee.com/openharmony/docs/blob/master/en/application-dev/reference/native-lib/musl.md)
-  * `*-android*` targets ([since Rust 1.68](https://blog.rust-lang.org/2023/01/09/android-ndk-update-r25.html))
-    have the minimum supported API level higher than [Android 4.3 (API level 18) that added `getauxval`](https://github.com/aosp-mirror/platform_bionic/blob/d3ebc2f7c49a9893b114124d4a6b315f3a328764/libc/include/sys/auxv.h#L49).
-
-* `std_detect_file_io` (enabled by default, requires `std`): Enable to perform run-time feature
-detection using file APIs (e.g. `/proc/self/auxv`, etc.) if other more performant
-methods fail. This feature requires `libstd` as a dependency, preventing the
-crate from working on applications in which `std` is not available.
-
-[`getauxval`]: https://man7.org/linux/man-pages/man3/getauxval.3.html
-
 # Platform support
 
 * All `x86`/`x86_64` targets are supported on all platforms by querying the
diff --git a/library/std_detect/src/detect/mod.rs b/library/std_detect/src/detect/mod.rs
index ae6fb2ab37279..c888dd34d9db5 100644
--- a/library/std_detect/src/detect/mod.rs
+++ b/library/std_detect/src/detect/mod.rs
@@ -47,21 +47,21 @@ cfg_select! {
         #[path = "os/x86.rs"]
         mod os;
     }
-    all(any(target_os = "linux", target_os = "android"), feature = "libc") => {
+    any(target_os = "linux", target_os = "android") => {
         #[cfg(any(target_arch = "riscv32", target_arch = "riscv64"))]
         #[path = "os/riscv.rs"]
         mod riscv;
         #[path = "os/linux/mod.rs"]
         mod os;
     }
-    all(target_os = "freebsd", feature = "libc") => {
+    target_os = "freebsd" => {
         #[cfg(target_arch = "aarch64")]
         #[path = "os/aarch64.rs"]
         mod aarch64;
         #[path = "os/freebsd/mod.rs"]
         mod os;
     }
-    all(target_os = "openbsd", feature = "libc") => {
+    target_os = "openbsd" => {
         #[allow(dead_code)] // we don't use code that calls the mrs instruction.
         #[cfg(target_arch = "aarch64")]
         #[path = "os/aarch64.rs"]
@@ -73,7 +73,7 @@ cfg_select! {
         #[path = "os/windows/aarch64.rs"]
         mod os;
     }
-    all(target_vendor = "apple", target_arch = "aarch64", feature = "libc") => {
+    all(target_vendor = "apple", target_arch = "aarch64") => {
         #[path = "os/darwin/aarch64.rs"]
         mod os;
     }
diff --git a/library/std_detect/src/detect/os/linux/aarch64/tests.rs b/library/std_detect/src/detect/os/linux/aarch64/tests.rs
index a3562f2fd9362..4d7c9a419d386 100644
--- a/library/std_detect/src/detect/os/linux/aarch64/tests.rs
+++ b/library/std_detect/src/detect/os/linux/aarch64/tests.rs
@@ -1,77 +1,70 @@
+use super::auxvec::auxv_from_file;
 use super::*;
+// The baseline hwcaps used in the (artificial) auxv test files.
+fn baseline_hwcaps() -> AtHwcap {
+    AtHwcap {
+        fp: true,
+        asimd: true,
+        aes: true,
+        pmull: true,
+        sha1: true,
+        sha2: true,
+        crc32: true,
+        atomics: true,
+        fphp: true,
+        asimdhp: true,
+        asimdrdm: true,
+        lrcpc: true,
+        dcpop: true,
+        asimddp: true,
+        ssbs: true,
+        ..AtHwcap::default()
+    }
+}
 
-#[cfg(feature = "std_detect_file_io")]
-mod auxv_from_file {
-    use super::auxvec::auxv_from_file;
-    use super::*;
-    // The baseline hwcaps used in the (artificial) auxv test files.
-    fn baseline_hwcaps() -> AtHwcap {
+#[test]
+fn linux_empty_hwcap2_aarch64() {
+    let file = concat!(
+        env!("CARGO_MANIFEST_DIR"),
+        "/src/detect/test_data/linux-empty-hwcap2-aarch64.auxv"
+    );
+    println!("file: {file}");
+    let v = auxv_from_file(file).unwrap();
+    println!("HWCAP : 0x{:0x}", v.hwcap);
+    println!("HWCAP2: 0x{:0x}", v.hwcap2);
+    assert_eq!(AtHwcap::from(v), baseline_hwcaps());
+}
+#[test]
+fn linux_no_hwcap2_aarch64() {
+    let file =
+        concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/linux-no-hwcap2-aarch64.auxv");
+    println!("file: {file}");
+    let v = auxv_from_file(file).unwrap();
+    println!("HWCAP : 0x{:0x}", v.hwcap);
+    println!("HWCAP2: 0x{:0x}", v.hwcap2);
+    assert_eq!(AtHwcap::from(v), baseline_hwcaps());
+}
+#[test]
+fn linux_hwcap2_aarch64() {
+    let file =
+        concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/linux-hwcap2-aarch64.auxv");
+    println!("file: {file}");
+    let v = auxv_from_file(file).unwrap();
+    println!("HWCAP : 0x{:0x}", v.hwcap);
+    println!("HWCAP2: 0x{:0x}", v.hwcap2);
+    assert_eq!(
+        AtHwcap::from(v),
         AtHwcap {
-            fp: true,
-            asimd: true,
-            aes: true,
-            pmull: true,
-            sha1: true,
-            sha2: true,
-            crc32: true,
-            atomics: true,
-            fphp: true,
-            asimdhp: true,
-            asimdrdm: true,
-            lrcpc: true,
-            dcpop: true,
-            asimddp: true,
-            ssbs: true,
-            ..AtHwcap::default()
+            // Some other HWCAP bits.
+            paca: true,
+            pacg: true,
+            // HWCAP2-only bits.
+            dcpodp: true,
+            frint: true,
+            rng: true,
+            bti: true,
+            mte: true,
+            ..baseline_hwcaps()
         }
-    }
-
-    #[test]
-    fn linux_empty_hwcap2_aarch64() {
-        let file = concat!(
-            env!("CARGO_MANIFEST_DIR"),
-            "/src/detect/test_data/linux-empty-hwcap2-aarch64.auxv"
-        );
-        println!("file: {file}");
-        let v = auxv_from_file(file).unwrap();
-        println!("HWCAP : 0x{:0x}", v.hwcap);
-        println!("HWCAP2: 0x{:0x}", v.hwcap2);
-        assert_eq!(AtHwcap::from(v), baseline_hwcaps());
-    }
-    #[test]
-    fn linux_no_hwcap2_aarch64() {
-        let file = concat!(
-            env!("CARGO_MANIFEST_DIR"),
-            "/src/detect/test_data/linux-no-hwcap2-aarch64.auxv"
-        );
-        println!("file: {file}");
-        let v = auxv_from_file(file).unwrap();
-        println!("HWCAP : 0x{:0x}", v.hwcap);
-        println!("HWCAP2: 0x{:0x}", v.hwcap2);
-        assert_eq!(AtHwcap::from(v), baseline_hwcaps());
-    }
-    #[test]
-    fn linux_hwcap2_aarch64() {
-        let file =
-            concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/linux-hwcap2-aarch64.auxv");
-        println!("file: {file}");
-        let v = auxv_from_file(file).unwrap();
-        println!("HWCAP : 0x{:0x}", v.hwcap);
-        println!("HWCAP2: 0x{:0x}", v.hwcap2);
-        assert_eq!(
-            AtHwcap::from(v),
-            AtHwcap {
-                // Some other HWCAP bits.
-                paca: true,
-                pacg: true,
-                // HWCAP2-only bits.
-                dcpodp: true,
-                frint: true,
-                rng: true,
-                bti: true,
-                mte: true,
-                ..baseline_hwcaps()
-            }
-        );
-    }
+    );
 }
diff --git a/library/std_detect/src/detect/os/linux/auxvec.rs b/library/std_detect/src/detect/os/linux/auxvec.rs
index 75e01bdc4499d..c0bbc7d4efa88 100644
--- a/library/std_detect/src/detect/os/linux/auxvec.rs
+++ b/library/std_detect/src/detect/os/linux/auxvec.rs
@@ -44,20 +44,16 @@ pub(crate) struct AuxVec {
 ///
 /// There is no perfect way of reading the auxiliary vector.
 ///
-/// - If the `std_detect_dlsym_getauxval` cargo feature is enabled, this will use
-///   `getauxval` if its linked to the binary, and otherwise proceed to a fallback implementation.
-///   When `std_detect_dlsym_getauxval` is disabled, this will assume that `getauxval` is
-///   linked to the binary - if that is not the case the behavior is undefined.
-/// - Otherwise, if the `std_detect_file_io` cargo feature is enabled, it will
+/// - If [`getauxval`] is linked to the binary we use it, and otherwise it will
 ///   try to read `/proc/self/auxv`.
 /// - If that fails, this function returns an error.
 ///
 /// Note that run-time feature detection is not invoked for features that can
 /// be detected at compile-time.
 ///
-///  Note: The `std_detect_dlsym_getauxval` cargo feature is ignored on
-/// `*-linux-{gnu,musl,ohos}*` and `*-android*` targets because we can safely assume `getauxval`
-/// is linked to the binary.
+///  Note: We always directly use `getauxval` on `*-linux-{gnu,musl,ohos}*` and
+/// `*-android*` targets rather than `dlsym` it because we can safely assume
+/// `getauxval` is linked to the binary.
 /// - `*-linux-gnu*` targets ([since Rust 1.64](https://blog.rust-lang.org/2022/08/01/Increasing-glibc-kernel-requirements.html))
 ///   have glibc requirements higher than [glibc 2.16 that added `getauxval`](https://sourceware.org/legacy-ml/libc-announce/2012/msg00000.html).
 /// - `*-linux-musl*` targets ([at least since Rust 1.15](https://github.com/rust-lang/rust/blob/1.15.0/src/ci/docker/x86_64-musl/build-musl.sh#L15))
@@ -71,6 +67,7 @@ pub(crate) struct AuxVec {
 ///
 /// [auxvec_h]: https://github.com/torvalds/linux/blob/master/include/uapi/linux/auxvec.h
 /// [auxv_docs]: https://docs.rs/auxv/0.3.3/auxv/
+/// [`getauxval`]: https://man7.org/linux/man-pages/man3/getauxval.3.html
 pub(crate) fn auxv() -> Result<AuxVec, ()> {
     // Try to call a getauxval function.
     if let Ok(hwcap) = getauxval(AT_HWCAP) {
@@ -115,16 +112,9 @@ pub(crate) fn auxv() -> Result<AuxVec, ()> {
         let _ = hwcap;
     }
 
-    #[cfg(feature = "std_detect_file_io")]
-    {
-        // If calling getauxval fails, try to read the auxiliary vector from
-        // its file:
-        auxv_from_file("/proc/self/auxv").map_err(|_| ())
-    }
-    #[cfg(not(feature = "std_detect_file_io"))]
-    {
-        Err(())
-    }
+    // If calling getauxval fails, try to read the auxiliary vector from
+    // its file:
+    auxv_from_file("/proc/self/auxv").map_err(|_| ())
 }
 
 /// Tries to read the `key` from the auxiliary vector by calling the
@@ -132,14 +122,16 @@ pub(crate) fn auxv() -> Result<AuxVec, ()> {
 fn getauxval(key: usize) -> Result<usize, ()> {
     type F = unsafe extern "C" fn(libc::c_ulong) -> libc::c_ulong;
     cfg_select! {
-        all(
-            feature = "std_detect_dlsym_getauxval",
-            not(all(
+        any(
+            all(
                 target_os = "linux",
                 any(target_env = "gnu", target_env = "musl", target_env = "ohos"),
-            )),
-            not(target_os = "android"),
+            ),
+            target_os = "android",
         ) => {
+            let ffi_getauxval: F = libc::getauxval;
+        }
+        _ => {
             let ffi_getauxval: F = unsafe {
                 let ptr = libc::dlsym(libc::RTLD_DEFAULT, c"getauxval".as_ptr());
                 if ptr.is_null() {
@@ -148,23 +140,18 @@ fn getauxval(key: usize) -> Result<usize, ()> {
                 core::mem::transmute(ptr)
             };
         }
-        _ => {
-            let ffi_getauxval: F = libc::getauxval;
-        }
     }
     Ok(unsafe { ffi_getauxval(key as libc::c_ulong) as usize })
 }
 
 /// Tries to read the auxiliary vector from the `file`. If this fails, this
 /// function returns `Err`.
-#[cfg(feature = "std_detect_file_io")]
 pub(super) fn auxv_from_file(file: &str) -> Result<AuxVec, alloc::string::String> {
     let file = super::read_file(file)?;
     auxv_from_file_bytes(&file)
 }
 
 /// Read auxiliary vector from a slice of bytes.
-#[cfg(feature = "std_detect_file_io")]
 pub(super) fn auxv_from_file_bytes(bytes: &[u8]) -> Result<AuxVec, alloc::string::String> {
     // See <https://github.com/torvalds/linux/blob/v5.15/include/uapi/linux/auxvec.h>.
     //
@@ -181,7 +168,6 @@ pub(super) fn auxv_from_file_bytes(bytes: &[u8]) -> Result<AuxVec, alloc::string
 
 /// Tries to interpret the `buffer` as an auxiliary vector. If that fails, this
 /// function returns `Err`.
-#[cfg(feature = "std_detect_file_io")]
 fn auxv_from_buf(buf: &[usize]) -> Result<AuxVec, alloc::string::String> {
     // Targets with only AT_HWCAP:
     #[cfg(any(
diff --git a/library/std_detect/src/detect/os/linux/auxvec/tests.rs b/library/std_detect/src/detect/os/linux/auxvec/tests.rs
index 631a3e5e9ef17..88f0d6d493376 100644
--- a/library/std_detect/src/detect/os/linux/auxvec/tests.rs
+++ b/library/std_detect/src/detect/os/linux/auxvec/tests.rs
@@ -41,7 +41,6 @@ fn auxv_dump() {
     }
 }
 
-#[cfg(feature = "std_detect_file_io")]
 cfg_select! {
     target_arch = "arm" => {
         // The tests below can be executed under qemu, where we do not have access to the test
@@ -86,7 +85,6 @@ cfg_select! {
 }
 
 #[test]
-#[cfg(feature = "std_detect_file_io")]
 fn auxv_dump_procfs() {
     if let Ok(auxvec) = auxv_from_file("/proc/self/auxv") {
         println!("{:?}", auxvec);
@@ -103,7 +101,6 @@ fn auxv_dump_procfs() {
     target_arch = "s390x",
 ))]
 #[test]
-#[cfg(feature = "std_detect_file_io")]
 fn auxv_crate_procfs() {
     if let Ok(procfs_auxv) = auxv_from_file("/proc/self/auxv") {
         assert_eq!(auxv().unwrap(), procfs_auxv);
diff --git a/library/std_detect/src/detect/os/linux/mod.rs b/library/std_detect/src/detect/os/linux/mod.rs
index 5273c16c0893c..aec94f963f5c1 100644
--- a/library/std_detect/src/detect/os/linux/mod.rs
+++ b/library/std_detect/src/detect/os/linux/mod.rs
@@ -1,11 +1,9 @@
 //! Run-time feature detection on Linux
-//!
-#[cfg(feature = "std_detect_file_io")]
+
 use alloc::vec::Vec;
 
 mod auxvec;
 
-#[cfg(feature = "std_detect_file_io")]
 fn read_file(orig_path: &str) -> Result<Vec<u8>, alloc::string::String> {
     use alloc::format;
 
diff --git a/library/std_detect/src/lib.rs b/library/std_detect/src/lib.rs
index 73e2f5dd96442..5e1d21bbfd17d 100644
--- a/library/std_detect/src/lib.rs
+++ b/library/std_detect/src/lib.rs
@@ -27,8 +27,7 @@
 extern crate std;
 
 // rust-lang/rust#83888: removing `extern crate` gives an error that `vec_spare>
-#[cfg_attr(feature = "std_detect_file_io", allow(unused_extern_crates))]
-#[cfg(feature = "std_detect_file_io")]
+#[allow(unused_extern_crates)]
 extern crate alloc;
 
 #[doc(hidden)]
diff --git a/library/sysroot/Cargo.toml b/library/sysroot/Cargo.toml
index eec8c461b6db4..a188680829166 100644
--- a/library/sysroot/Cargo.toml
+++ b/library/sysroot/Cargo.toml
@@ -20,7 +20,7 @@ test = { path = "../test", public = true }
 
 # Forward features to the `std` crate as necessary
 [features]
-default = ["std_detect_file_io", "std_detect_dlsym_getauxval", "panic-unwind"]
+default = ["panic-unwind"]
 backtrace = ["std/backtrace"]
 backtrace-trace-only = ["std/backtrace-trace-only"]
 compiler-builtins-c = ["std/compiler-builtins-c"]
@@ -32,7 +32,5 @@ system-llvm-libunwind = ["std/system-llvm-libunwind"]
 optimize_for_size = ["std/optimize_for_size"]
 panic-unwind = ["std/panic-unwind"]
 profiler = ["dep:profiler_builtins"]
-std_detect_file_io = ["std/std_detect_file_io"]
-std_detect_dlsym_getauxval = ["std/std_detect_dlsym_getauxval"]
 windows_raw_dylib = ["std/windows_raw_dylib"]
 llvm_enzyme = ["std/llvm_enzyme"]
diff --git a/src/bootstrap/download-ci-gcc-stamp b/src/bootstrap/download-ci-gcc-stamp
index bbe26afc95269..ec8d0fa3135d1 100644
--- a/src/bootstrap/download-ci-gcc-stamp
+++ b/src/bootstrap/download-ci-gcc-stamp
@@ -1,4 +1,4 @@
 Change this file to make users of the `download-ci-gcc` configuration download
 a new version of GCC from CI, even if the GCC submodule hasn’t changed.
 
-Last change is for: https://github.com/rust-lang/rust/pull/138051
+Last change is for: https://github.com/rust-lang/rust/pull/150873
diff --git a/src/bootstrap/src/core/download.rs b/src/bootstrap/src/core/download.rs
index 43efdcd7db173..074404b4cdf3e 100644
--- a/src/bootstrap/src/core/download.rs
+++ b/src/bootstrap/src/core/download.rs
@@ -396,7 +396,7 @@ impl Config {
     ";
             self.download_file(&format!("{base}/{gcc_sha}/{filename}"), &tarball, help_on_error);
         }
-        self.unpack(&tarball, root_dir, "gcc");
+        self.unpack(&tarball, root_dir, "gcc-dev");
     }
 }
 
diff --git a/src/ci/run.sh b/src/ci/run.sh
index 425ad38a66557..b486f0525f40d 100755
--- a/src/ci/run.sh
+++ b/src/ci/run.sh
@@ -187,9 +187,8 @@ else
     RUST_CONFIGURE_ARGS="$RUST_CONFIGURE_ARGS --set llvm.static-libstdcpp"
   fi
 
-  # Download GCC from CI on test builders (temporarily disabled because the CI gcc component
-  # was renamed).
-  RUST_CONFIGURE_ARGS="$RUST_CONFIGURE_ARGS --set gcc.download-ci-gcc=false"
+  # Download GCC from CI on test builders
+  RUST_CONFIGURE_ARGS="$RUST_CONFIGURE_ARGS --set gcc.download-ci-gcc=true"
 
   # download-rustc seems to be broken on CI after the stage0 redesign
   # Disable it until these issues are debugged and resolved
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index 817eda4c52ecc..597a85f397695 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -330,6 +330,9 @@ pub(crate) fn clean_const<'tcx>(constant: &hir::ConstArg<'tcx>) -> ConstantKind
             // FIXME(mgca): proper printing :3
             ConstantKind::Path { path: "/* TUPLE EXPR */".to_string().into() }
         }
+        hir::ConstArgKind::Array(..) => {
+            ConstantKind::Path { path: "/* ARRAY EXPR */".to_string().into() }
+        }
         hir::ConstArgKind::Anon(anon) => ConstantKind::Anonymous { body: anon.body },
         hir::ConstArgKind::Infer(..) | hir::ConstArgKind::Error(..) => ConstantKind::Infer,
         hir::ConstArgKind::Literal(..) => {
@@ -1818,6 +1821,7 @@ pub(crate) fn clean_ty<'tcx>(ty: &hir::Ty<'tcx>, cx: &mut DocContext<'tcx>) -> T
                 | hir::ConstArgKind::Path(..)
                 | hir::ConstArgKind::TupleCall(..)
                 | hir::ConstArgKind::Tup(..)
+                | hir::ConstArgKind::Array(..)
                 | hir::ConstArgKind::Literal(..) => {
                     let ct = lower_const_arg_for_rustdoc(cx.tcx, const_arg, FeedConstTy::No);
                     print_const(cx, ct)
diff --git a/src/tools/clippy/clippy_lints/src/utils/author.rs b/src/tools/clippy/clippy_lints/src/utils/author.rs
index acea701b2e830..8243077cab897 100644
--- a/src/tools/clippy/clippy_lints/src/utils/author.rs
+++ b/src/tools/clippy/clippy_lints/src/utils/author.rs
@@ -321,6 +321,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
             },
             ConstArgKind::Struct(..) => chain!(self, "let ConstArgKind::Struct(..) = {const_arg}.kind"),
             ConstArgKind::TupleCall(..) => chain!(self, "let ConstArgKind::TupleCall(..) = {const_arg}.kind"),
+            ConstArgKind::Array(..) => chain!(self, "let ConstArgKind::Array(..) = {const_arg}.kind"),
             ConstArgKind::Infer(..) => chain!(self, "let ConstArgKind::Infer(..) = {const_arg}.kind"),
             ConstArgKind::Error(..) => chain!(self, "let ConstArgKind::Error(..) = {const_arg}.kind"),
             ConstArgKind::Tup(..) => chain!(self, "let ConstArgKind::Tup(..) = {const_arg}.kind"),
diff --git a/src/tools/clippy/clippy_utils/src/consts.rs b/src/tools/clippy/clippy_utils/src/consts.rs
index 538f1fd2628c9..e2ada37d53b39 100644
--- a/src/tools/clippy/clippy_utils/src/consts.rs
+++ b/src/tools/clippy/clippy_utils/src/consts.rs
@@ -1144,6 +1144,7 @@ pub fn const_item_rhs_to_expr<'tcx>(tcx: TyCtxt<'tcx>, ct_rhs: ConstItemRhs<'tcx
             | ConstArgKind::Tup(..)
             | ConstArgKind::Literal(..)
             | ConstArgKind::TupleCall(..)
+            | ConstArgKind::Array(..)
             | ConstArgKind::Path(_)
             | ConstArgKind::Error(..)
             | ConstArgKind::Infer(..) => None,
diff --git a/src/tools/clippy/clippy_utils/src/hir_utils.rs b/src/tools/clippy/clippy_utils/src/hir_utils.rs
index 0bb641568879c..c7bb3a064a093 100644
--- a/src/tools/clippy/clippy_utils/src/hir_utils.rs
+++ b/src/tools/clippy/clippy_utils/src/hir_utils.rs
@@ -687,6 +687,11 @@ impl HirEqInterExpr<'_, '_, '_> {
                         .all(|(arg_a, arg_b)| self.eq_const_arg(arg_a, arg_b))
             },
             (ConstArgKind::Literal(kind_l), ConstArgKind::Literal(kind_r)) => kind_l == kind_r,
+            (ConstArgKind::Array(l_arr), ConstArgKind::Array(r_arr)) => {
+                l_arr.elems.len() == r_arr.elems.len()
+                && l_arr.elems.iter().zip(r_arr.elems.iter())
+                    .all(|(l_elem, r_elem)| self.eq_const_arg(l_elem, r_elem))
+            }
             // Use explicit match for now since ConstArg is undergoing flux.
             (
                 ConstArgKind::Path(..)
@@ -696,6 +701,7 @@ impl HirEqInterExpr<'_, '_, '_> {
                 | ConstArgKind::Infer(..)
                 | ConstArgKind::Struct(..)
                 | ConstArgKind::Literal(..)
+                | ConstArgKind::Array(..)
                 | ConstArgKind::Error(..),
                 _,
             ) => false,
@@ -1575,6 +1581,11 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
                     self.hash_const_arg(arg);
                 }
             },
+            ConstArgKind::Array(array_expr) => {
+                for elem in array_expr.elems {
+                    self.hash_const_arg(elem);
+                }
+            },
             ConstArgKind::Infer(..) | ConstArgKind::Error(..) => {},
             ConstArgKind::Literal(lit) => lit.hash(&mut self.s),
         }
diff --git a/src/tools/clippy/clippy_utils/src/sym.rs b/src/tools/clippy/clippy_utils/src/sym.rs
index 5357a0941d322..94591a7ee30a8 100644
--- a/src/tools/clippy/clippy_utils/src/sym.rs
+++ b/src/tools/clippy/clippy_utils/src/sym.rs
@@ -62,7 +62,6 @@ generate! {
     MsrvStack,
     Octal,
     OpenOptions,
-    Other,
     PathLookup,
     Regex,
     RegexBuilder,
diff --git a/src/tools/miri/src/shims/files.rs b/src/tools/miri/src/shims/files.rs
index f86933029341e..694a5922b7990 100644
--- a/src/tools/miri/src/shims/files.rs
+++ b/src/tools/miri/src/shims/files.rs
@@ -249,6 +249,15 @@ impl FileDescription for io::Stdin {
         finish.call(ecx, result)
     }
 
+    fn destroy<'tcx>(
+        self,
+        _self_id: FdId,
+        _communicate_allowed: bool,
+        _ecx: &mut MiriInterpCx<'tcx>,
+    ) -> InterpResult<'tcx, io::Result<()>> {
+        interp_ok(Ok(()))
+    }
+
     fn is_tty(&self, communicate_allowed: bool) -> bool {
         communicate_allowed && self.is_terminal()
     }
@@ -279,6 +288,15 @@ impl FileDescription for io::Stdout {
         finish.call(ecx, result)
     }
 
+    fn destroy<'tcx>(
+        self,
+        _self_id: FdId,
+        _communicate_allowed: bool,
+        _ecx: &mut MiriInterpCx<'tcx>,
+    ) -> InterpResult<'tcx, io::Result<()>> {
+        interp_ok(Ok(()))
+    }
+
     fn is_tty(&self, communicate_allowed: bool) -> bool {
         communicate_allowed && self.is_terminal()
     }
@@ -289,6 +307,15 @@ impl FileDescription for io::Stderr {
         "stderr"
     }
 
+    fn destroy<'tcx>(
+        self,
+        _self_id: FdId,
+        _communicate_allowed: bool,
+        _ecx: &mut MiriInterpCx<'tcx>,
+    ) -> InterpResult<'tcx, io::Result<()>> {
+        interp_ok(Ok(()))
+    }
+
     fn write<'tcx>(
         self: FileDescriptionRef<Self>,
         _communicate_allowed: bool,
@@ -436,6 +463,15 @@ impl FileDescription for NullOutput {
         // We just don't write anything, but report to the user that we did.
         finish.call(ecx, Ok(len))
     }
+
+    fn destroy<'tcx>(
+        self,
+        _self_id: FdId,
+        _communicate_allowed: bool,
+        _ecx: &mut MiriInterpCx<'tcx>,
+    ) -> InterpResult<'tcx, io::Result<()>> {
+        interp_ok(Ok(()))
+    }
 }
 
 /// Internal type of a file-descriptor - this is what [`FdTable`] expects
diff --git a/src/tools/miri/tests/fail-dep/libc/fs/close_stdout.rs b/src/tools/miri/tests/fail-dep/libc/fs/close_stdout.rs
deleted file mode 100644
index 7911133f548ff..0000000000000
--- a/src/tools/miri/tests/fail-dep/libc/fs/close_stdout.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//@ignore-target: windows # No libc IO on Windows
-//@compile-flags: -Zmiri-disable-isolation
-
-// FIXME: standard handles cannot be closed (https://github.com/rust-lang/rust/issues/40032)
-
-fn main() {
-    unsafe {
-        libc::close(1); //~ ERROR: cannot close stdout
-    }
-}
diff --git a/src/tools/miri/tests/fail-dep/libc/fs/close_stdout.stderr b/src/tools/miri/tests/fail-dep/libc/fs/close_stdout.stderr
deleted file mode 100644
index 84973ac020ded..0000000000000
--- a/src/tools/miri/tests/fail-dep/libc/fs/close_stdout.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-error: unsupported operation: cannot close stdout
-  --> tests/fail-dep/libc/fs/close_stdout.rs:LL:CC
-   |
-LL |         libc::close(1);
-   |         ^^^^^^^^^^^^^^ unsupported operation occurred here
-   |
-   = help: this is likely not a bug in the program; it indicates that the program performed an operation that Miri does not support
-
-note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
-
-error: aborting due to 1 previous error
-
diff --git a/src/tools/miri/tests/pass-dep/libc/libc-fs.rs b/src/tools/miri/tests/pass-dep/libc/libc-fs.rs
index 99685d6d976b6..8c860b5db7baf 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-fs.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-fs.rs
@@ -48,6 +48,7 @@ fn main() {
     test_nofollow_not_symlink();
     #[cfg(target_os = "macos")]
     test_ioctl();
+    test_close_stdout();
 }
 
 fn test_file_open_unix_allow_two_args() {
@@ -579,3 +580,11 @@ fn test_ioctl() {
         assert_eq!(libc::ioctl(fd, libc::FIOCLEX), 0);
     }
 }
+
+fn test_close_stdout() {
+    // This is std library UB, but that's not relevant since we're
+    // only interacting with libc here.
+    unsafe {
+        libc::close(1);
+    }
+}
diff --git a/tests/assembly-llvm/rust-abi-arg-attr.rs b/tests/assembly-llvm/rust-abi-arg-attr.rs
index 4f3673ccfc3b9..2d13feb021ba5 100644
--- a/tests/assembly-llvm/rust-abi-arg-attr.rs
+++ b/tests/assembly-llvm/rust-abi-arg-attr.rs
@@ -1,3 +1,4 @@
+//@ add-minicore
 //@ assembly-output: emit-asm
 //@ revisions: riscv64 riscv64-zbb loongarch64
 //@ compile-flags: -C opt-level=3
@@ -14,45 +15,8 @@
 #![no_std]
 #![no_core]
 // FIXME: Migrate these code after PR #130693 is landed.
-
-#[lang = "pointee_sized"]
-pub trait PointeeSized {}
-
-#[lang = "meta_sized"]
-pub trait MetaSized: PointeeSized {}
-
-#[lang = "sized"]
-pub trait Sized: MetaSized {}
-
-#[lang = "copy"]
-trait Copy {}
-
-impl Copy for i8 {}
-impl Copy for u32 {}
-impl Copy for i32 {}
-
-#[lang = "neg"]
-trait Neg {
-    type Output;
-
-    fn neg(self) -> Self::Output;
-}
-
-impl Neg for i8 {
-    type Output = i8;
-
-    fn neg(self) -> Self::Output {
-        -self
-    }
-}
-
-#[lang = "Ordering"]
-#[repr(i8)]
-enum Ordering {
-    Less = -1,
-    Equal = 0,
-    Greater = 1,
-}
+extern crate minicore;
+use minicore::*;
 
 #[rustc_intrinsic]
 fn three_way_compare<T: Copy>(lhs: T, rhs: T) -> Ordering;
diff --git a/tests/auxiliary/minicore.rs b/tests/auxiliary/minicore.rs
index 122a3a226015a..95b217c130317 100644
--- a/tests/auxiliary/minicore.rs
+++ b/tests/auxiliary/minicore.rs
@@ -210,6 +210,14 @@ impl Neg for isize {
     }
 }
 
+impl Neg for i8 {
+    type Output = i8;
+
+    fn neg(self) -> i8 {
+        loop {}
+    }
+}
+
 #[lang = "sync"]
 pub trait Sync {}
 impl_marker_trait!(
@@ -280,6 +288,16 @@ pub enum c_void {
     __variant2,
 }
 
+#[lang = "Ordering"]
+#[repr(i8)]
+pub enum Ordering {
+    Less = -1,
+    Equal = 0,
+    Greater = 1,
+}
+
+impl Copy for Ordering {}
+
 #[lang = "const_param_ty"]
 #[diagnostic::on_unimplemented(message = "`{Self}` can't be used as a const parameter type")]
 pub trait ConstParamTy_ {}
diff --git a/tests/codegen-llvm/direct-access-external-data.rs b/tests/codegen-llvm/direct-access-external-data.rs
index 5b2ff41ef0529..73dc08dc2b576 100644
--- a/tests/codegen-llvm/direct-access-external-data.rs
+++ b/tests/codegen-llvm/direct-access-external-data.rs
@@ -1,21 +1,48 @@
-//@ only-loongarch64-unknown-linux-gnu
+//@ ignore-powerpc64 (handles dso_local differently)
+//@ ignore-apple (handles dso_local differently)
 
-//@ revisions: DEFAULT DIRECT INDIRECT
+//@ revisions: DEFAULT PIE DIRECT INDIRECT
 //@ [DEFAULT] compile-flags: -C relocation-model=static
-//@ [DIRECT] compile-flags: -C relocation-model=static -Z direct-access-external-data=yes
+//@ [PIE] compile-flags: -C relocation-model=pie
+//@ [DIRECT] compile-flags: -C relocation-model=pie -Z direct-access-external-data=yes
 //@ [INDIRECT] compile-flags: -C relocation-model=static -Z direct-access-external-data=no
 
 #![crate_type = "rlib"]
+#![feature(linkage)]
 
-// DEFAULT: @VAR = external {{.*}} global i32
-// DIRECT: @VAR = external dso_local {{.*}} global i32
-// INDIRECT: @VAR = external {{.*}} global i32
+unsafe extern "C" {
+    // CHECK: @VAR = external
+    // DEFAULT-SAME: dso_local
+    // PIE-NOT: dso_local
+    // DIRECT-SAME: dso_local
+    // INDIRECT-NOT: dso_local
+    // CHECK-SAME: global i32
+    safe static VAR: i32;
 
-extern "C" {
-    static VAR: i32;
+    // When "linkage" is used, we generate an indirection global.
+    // Check dso_local is still applied to the actual global.
+    // CHECK: @EXTERNAL = external
+    // DEFAULT-SAME: dso_local
+    // PIE-NOT: dso_local
+    // DIRECT-SAME: dso_local
+    // INDIRECT-NOT: dso_local
+    // CHECK-SAME: global i8
+    #[linkage = "external"]
+    safe static EXTERNAL: *const u32;
+
+    // CHECK: @WEAK = extern_weak
+    // DEFAULT-SAME: dso_local
+    // PIE-NOT: dso_local
+    // DIRECT-SAME: dso_local
+    // INDIRECT-NOT: dso_local
+    // CHECK-SAME: global i8
+    #[linkage = "extern_weak"]
+    safe static WEAK: *const u32;
 }
 
 #[no_mangle]
-pub fn get() -> i32 {
-    unsafe { VAR }
+pub fn refer() {
+    core::hint::black_box(VAR);
+    core::hint::black_box(EXTERNAL);
+    core::hint::black_box(WEAK);
 }
diff --git a/tests/ui/abi/issues/issue-22565-rust-call.stderr b/tests/ui/abi/issues/issue-22565-rust-call.stderr
index 0fd3285cd3a52..3e296bdaea41d 100644
--- a/tests/ui/abi/issues/issue-22565-rust-call.stderr
+++ b/tests/ui/abi/issues/issue-22565-rust-call.stderr
@@ -2,7 +2,7 @@ error[E0277]: functions with the "rust-call" ABI must take a single non-self tup
   --> $DIR/issue-22565-rust-call.rs:3:1
    |
 LL | extern "rust-call" fn b(_i: i32) {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Tuple` is not implemented for `i32`
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::marker::Tuple` is not implemented for `i32`
 
 error: functions with the "rust-call" ABI must take a single non-self tuple argument
   --> $DIR/issue-22565-rust-call.rs:17:5
@@ -32,7 +32,7 @@ error[E0277]: functions with the "rust-call" ABI must take a single non-self tup
   --> $DIR/issue-22565-rust-call.rs:27:7
    |
 LL |     b(10);
-   |       ^^ the trait `Tuple` is not implemented for `i32`
+   |       ^^ the trait `std::marker::Tuple` is not implemented for `i32`
 
 error: functions with the "rust-call" ABI must take a single non-self tuple argument
   --> $DIR/issue-22565-rust-call.rs:29:5
diff --git a/tests/ui/const-generics/mgca/array-expr-complex.rs b/tests/ui/const-generics/mgca/array-expr-complex.rs
new file mode 100644
index 0000000000000..3e8320bc94de2
--- /dev/null
+++ b/tests/ui/const-generics/mgca/array-expr-complex.rs
@@ -0,0 +1,16 @@
+#![expect(incomplete_features)]
+#![feature(min_generic_const_args, adt_const_params)]
+
+fn takes_array<const A: [u32; 3]>() {}
+
+fn generic_caller<const X: u32, const Y: usize>() {
+    // not supported yet
+    takes_array::<{ [1, 2, 1 + 2] }>();
+    //~^ ERROR: complex const arguments must be placed inside of a `const` block
+    takes_array::<{ [X; 3] }>();
+    //~^ ERROR: complex const arguments must be placed inside of a `const` block
+    takes_array::<{ [0; Y] }>();
+    //~^ ERROR: complex const arguments must be placed inside of a `const` block
+}
+
+fn main() {}
diff --git a/tests/ui/const-generics/mgca/array-expr-complex.stderr b/tests/ui/const-generics/mgca/array-expr-complex.stderr
new file mode 100644
index 0000000000000..beac1aa232f2f
--- /dev/null
+++ b/tests/ui/const-generics/mgca/array-expr-complex.stderr
@@ -0,0 +1,20 @@
+error: complex const arguments must be placed inside of a `const` block
+  --> $DIR/array-expr-complex.rs:8:28
+   |
+LL |     takes_array::<{ [1, 2, 1 + 2] }>();
+   |                            ^^^^^
+
+error: complex const arguments must be placed inside of a `const` block
+  --> $DIR/array-expr-complex.rs:10:19
+   |
+LL |     takes_array::<{ [X; 3] }>();
+   |                   ^^^^^^^^^^
+
+error: complex const arguments must be placed inside of a `const` block
+  --> $DIR/array-expr-complex.rs:12:19
+   |
+LL |     takes_array::<{ [0; Y] }>();
+   |                   ^^^^^^^^^^
+
+error: aborting due to 3 previous errors
+
diff --git a/tests/ui/const-generics/mgca/array-expr-empty.rs b/tests/ui/const-generics/mgca/array-expr-empty.rs
new file mode 100644
index 0000000000000..d37c6f2fcfe35
--- /dev/null
+++ b/tests/ui/const-generics/mgca/array-expr-empty.rs
@@ -0,0 +1,9 @@
+#![expect(incomplete_features)]
+#![feature(min_generic_const_args)]
+
+fn takes_empty_array<const A: []>() {}
+//~^ ERROR: expected type, found `]`
+
+fn main() {
+    takes_empty_array::<{ [] }>();
+}
diff --git a/tests/ui/const-generics/mgca/array-expr-empty.stderr b/tests/ui/const-generics/mgca/array-expr-empty.stderr
new file mode 100644
index 0000000000000..91340e621acbb
--- /dev/null
+++ b/tests/ui/const-generics/mgca/array-expr-empty.stderr
@@ -0,0 +1,8 @@
+error: expected type, found `]`
+  --> $DIR/array-expr-empty.rs:4:32
+   |
+LL | fn takes_empty_array<const A: []>() {}
+   |                                ^ expected type
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/const-generics/mgca/array-expr-simple.rs b/tests/ui/const-generics/mgca/array-expr-simple.rs
new file mode 100644
index 0000000000000..44feeccb4f9f2
--- /dev/null
+++ b/tests/ui/const-generics/mgca/array-expr-simple.rs
@@ -0,0 +1,25 @@
+//@ run-pass
+#![expect(incomplete_features)]
+#![feature(min_generic_const_args, adt_const_params)]
+#![allow(dead_code)]
+
+fn takes_array_u32<const A: [u32; 3]>() {}
+fn takes_array_bool<const A: [bool; 2]>() {}
+fn takes_nested_array<const A: [[u32; 2]; 2]>() {}
+fn takes_empty_array<const A: [u32; 0]>() {}
+
+fn generic_caller<const X: u32, const Y: u32>() {
+    takes_array_u32::<{ [X, Y, X] }>();
+    takes_array_u32::<{ [X, Y, const { 1 }] }>();
+    takes_array_u32::<{ [X, Y, const { 1 + 1 }] }>();
+    takes_array_u32::<{ [2_002, 2u32, 1_u32] }>();
+
+    takes_array_bool::<{ [true, false] }>();
+
+    takes_nested_array::<{ [[X, Y], [3, 4]] }>();
+    takes_nested_array::<{ [[1u32, 2_u32], [const { 3 }, 4]] }>();
+
+    takes_empty_array::<{ [] }>();
+}
+
+fn main() {}
diff --git a/tests/ui/const-generics/mgca/array-expr-with-assoc-const.rs b/tests/ui/const-generics/mgca/array-expr-with-assoc-const.rs
new file mode 100644
index 0000000000000..47ecbfa6b7e15
--- /dev/null
+++ b/tests/ui/const-generics/mgca/array-expr-with-assoc-const.rs
@@ -0,0 +1,18 @@
+//@ run-pass
+#![expect(incomplete_features)]
+#![feature(min_generic_const_args, adt_const_params)]
+#![allow(dead_code)]
+
+fn takes_array<const A: [u32; 3]>() {}
+
+trait Trait {
+    #[type_const]
+    const ASSOC: u32;
+}
+
+fn generic_caller<T: Trait, const N: u32>() {
+    takes_array::<{ [T::ASSOC, N, T::ASSOC] }>();
+    takes_array::<{ [1_u32, T::ASSOC, 2] }>();
+}
+
+fn main() {}
diff --git a/tests/ui/const-generics/mgca/array-expr-with-macro.rs b/tests/ui/const-generics/mgca/array-expr-with-macro.rs
new file mode 100644
index 0000000000000..aef5acc1c8030
--- /dev/null
+++ b/tests/ui/const-generics/mgca/array-expr-with-macro.rs
@@ -0,0 +1,18 @@
+//@ run-pass
+#![expect(incomplete_features)]
+#![feature(min_generic_const_args, adt_const_params)]
+#![allow(dead_code)]
+
+macro_rules! make_array {
+    ($n:expr, $m:expr, $p:expr) => {
+        [N, $m, $p]
+    };
+}
+
+fn takes_array<const A: [u32; 3]>() {}
+
+fn generic_caller<const N: u32>() {
+    takes_array::<{ make_array!(N, 2, 3) }>();
+}
+
+fn main() {}
diff --git a/tests/ui/const-generics/mgca/array-expr-with-struct.rs b/tests/ui/const-generics/mgca/array-expr-with-struct.rs
new file mode 100644
index 0000000000000..883af57e918e3
--- /dev/null
+++ b/tests/ui/const-generics/mgca/array-expr-with-struct.rs
@@ -0,0 +1,20 @@
+//@ run-pass
+#![feature(min_generic_const_args, adt_const_params)]
+#![expect(incomplete_features)]
+#![allow(dead_code)]
+
+use std::marker::ConstParamTy;
+
+#[derive(PartialEq, Eq, ConstParamTy)]
+struct Container {
+    values: [u32; 3],
+}
+
+fn takes_container<const C: Container>() {}
+
+fn generic_caller<const N: u32, const M: u32>() {
+    takes_container::<{ Container { values: [N, M, 1] } }>();
+    takes_container::<{ Container { values: [1, 2, 3] } }>();
+}
+
+fn main() {}
diff --git a/tests/ui/const-generics/mgca/array-expr-with-tuple.rs b/tests/ui/const-generics/mgca/array-expr-with-tuple.rs
new file mode 100644
index 0000000000000..004663dcefaba
--- /dev/null
+++ b/tests/ui/const-generics/mgca/array-expr-with-tuple.rs
@@ -0,0 +1,13 @@
+//@ run-pass
+#![feature(min_generic_const_args, adt_const_params, unsized_const_params)]
+#![expect(incomplete_features)]
+#![allow(dead_code)]
+
+fn takes_tuple<const T: ([u32; 2], u32, [u32; 2])>() {}
+
+fn generic_caller<const N: u32, const M: u32>() {
+    takes_tuple::<{ ([N, M], 5, [M, N]) }>();
+    takes_tuple::<{ ([1, 2], 3, [4, 5]) }>();
+}
+
+fn main() {}
diff --git a/tests/ui/const-generics/mgca/type_const-array-return.rs b/tests/ui/const-generics/mgca/type_const-array-return.rs
new file mode 100644
index 0000000000000..5375e4fded6d7
--- /dev/null
+++ b/tests/ui/const-generics/mgca/type_const-array-return.rs
@@ -0,0 +1,26 @@
+//@ check-pass
+// This test should compile without an ICE.
+#![expect(incomplete_features)]
+#![feature(min_generic_const_args)]
+
+pub struct A;
+
+pub trait Array {
+    #[type_const]
+    const LEN: usize;
+    fn arr() -> [u8; Self::LEN];
+}
+
+impl Array for A {
+    #[type_const]
+    const LEN: usize = 4;
+
+    #[allow(unused_braces)]
+    fn arr() -> [u8; const { Self::LEN }] {
+        return [0u8; const { Self::LEN }];
+    }
+}
+
+fn main() {
+    let _ = A::arr();
+}
diff --git a/tests/ui/const-generics/mgca/type_const-inherent-const-omitted-type.rs b/tests/ui/const-generics/mgca/type_const-inherent-const-omitted-type.rs
new file mode 100644
index 0000000000000..b2c7340980091
--- /dev/null
+++ b/tests/ui/const-generics/mgca/type_const-inherent-const-omitted-type.rs
@@ -0,0 +1,12 @@
+#![expect(incomplete_features)]
+#![feature(min_generic_const_args)]
+
+struct A;
+
+impl A {
+    #[type_const]
+    const B = 4;
+    //~^ ERROR: missing type for `const` item
+}
+
+fn main() {}
diff --git a/tests/ui/const-generics/mgca/type_const-inherent-const-omitted-type.stderr b/tests/ui/const-generics/mgca/type_const-inherent-const-omitted-type.stderr
new file mode 100644
index 0000000000000..b44e47cd7e611
--- /dev/null
+++ b/tests/ui/const-generics/mgca/type_const-inherent-const-omitted-type.stderr
@@ -0,0 +1,13 @@
+error: missing type for `const` item
+  --> $DIR/type_const-inherent-const-omitted-type.rs:8:12
+   |
+LL |     const B = 4;
+   |            ^
+   |
+help: provide a type for the item
+   |
+LL |     const B: <type> = 4;
+   |            ++++++++
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/const-generics/mgca/type_const-only-in-impl-omitted-type.rs b/tests/ui/const-generics/mgca/type_const-only-in-impl-omitted-type.rs
new file mode 100644
index 0000000000000..ab613859aa5c6
--- /dev/null
+++ b/tests/ui/const-generics/mgca/type_const-only-in-impl-omitted-type.rs
@@ -0,0 +1,22 @@
+#![expect(incomplete_features)]
+#![feature(min_generic_const_args)]
+
+trait BadTr {
+    const NUM: usize;
+}
+
+struct GoodS;
+
+impl BadTr for GoodS {
+    #[type_const]
+    const NUM: = 84;
+    //~^ ERROR: missing type for `const` item
+
+}
+
+fn accept_bad_tr<const N: usize, T: BadTr<NUM = { N }>>(_x: &T) {}
+//~^ ERROR use of trait associated const without `#[type_const]`
+
+fn main() {
+    accept_bad_tr::<84, _>(&GoodS);
+}
diff --git a/tests/ui/const-generics/mgca/type_const-only-in-impl-omitted-type.stderr b/tests/ui/const-generics/mgca/type_const-only-in-impl-omitted-type.stderr
new file mode 100644
index 0000000000000..16f312454ed28
--- /dev/null
+++ b/tests/ui/const-generics/mgca/type_const-only-in-impl-omitted-type.stderr
@@ -0,0 +1,16 @@
+error: missing type for `const` item
+  --> $DIR/type_const-only-in-impl-omitted-type.rs:12:15
+   |
+LL |     const NUM: = 84;
+   |               ^ help: provide a type for the associated constant: `usize`
+
+error: use of trait associated const without `#[type_const]`
+  --> $DIR/type_const-only-in-impl-omitted-type.rs:17:43
+   |
+LL | fn accept_bad_tr<const N: usize, T: BadTr<NUM = { N }>>(_x: &T) {}
+   |                                           ^^^^^^^^^^^
+   |
+   = note: the declaration in the trait must be marked with `#[type_const]`
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/const-generics/mgca/type_const-recursive.rs b/tests/ui/const-generics/mgca/type_const-recursive.rs
new file mode 100644
index 0000000000000..15e49f747ed6b
--- /dev/null
+++ b/tests/ui/const-generics/mgca/type_const-recursive.rs
@@ -0,0 +1,8 @@
+#![expect(incomplete_features)]
+#![feature(min_generic_const_args)]
+
+#[type_const]
+const A: u8 = A;
+//~^ ERROR: overflow normalizing the unevaluated constant `A` [E0275]
+
+fn main() {}
diff --git a/tests/ui/const-generics/mgca/type_const-recursive.stderr b/tests/ui/const-generics/mgca/type_const-recursive.stderr
new file mode 100644
index 0000000000000..947319ec7eda2
--- /dev/null
+++ b/tests/ui/const-generics/mgca/type_const-recursive.stderr
@@ -0,0 +1,11 @@
+error[E0275]: overflow normalizing the unevaluated constant `A`
+  --> $DIR/type_const-recursive.rs:5:1
+   |
+LL | const A: u8 = A;
+   | ^^^^^^^^^^^
+   |
+   = note: in case this is a recursive type alias, consider using a struct, enum, or union instead
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/const-generics/mgca/type_const-use.rs b/tests/ui/const-generics/mgca/type_const-use.rs
new file mode 100644
index 0000000000000..04362cd285384
--- /dev/null
+++ b/tests/ui/const-generics/mgca/type_const-use.rs
@@ -0,0 +1,13 @@
+//@ check-pass
+// This test should compile without an ICE.
+#![expect(incomplete_features)]
+#![feature(min_generic_const_args)]
+
+#[type_const]
+const CONST: usize = 1;
+
+fn uses_const() {
+    CONST;
+}
+
+fn main() {}
diff --git a/tests/ui/error-codes/E0059.stderr b/tests/ui/error-codes/E0059.stderr
index d26fadcdbfa77..698ee0a2a9029 100644
--- a/tests/ui/error-codes/E0059.stderr
+++ b/tests/ui/error-codes/E0059.stderr
@@ -2,7 +2,7 @@ error[E0059]: type parameter to bare `Fn` trait must be a tuple
   --> $DIR/E0059.rs:3:11
    |
 LL | fn foo<F: Fn<i32>>(f: F) -> F::Output { f(3) }
-   |           ^^^^^^^ the trait `Tuple` is not implemented for `i32`
+   |           ^^^^^^^ the trait `std::marker::Tuple` is not implemented for `i32`
    |
 note: required by a bound in `Fn`
   --> $SRC_DIR/core/src/ops/function.rs:LL:COL
@@ -11,7 +11,7 @@ error[E0277]: `i32` is not a tuple
   --> $DIR/E0059.rs:3:41
    |
 LL | fn foo<F: Fn<i32>>(f: F) -> F::Output { f(3) }
-   |                                         ^^^^ the trait `Tuple` is not implemented for `i32`
+   |                                         ^^^^ the trait `std::marker::Tuple` is not implemented for `i32`
 
 error[E0059]: cannot use call notation; the first type parameter for the function trait is neither a tuple nor unit
   --> $DIR/E0059.rs:3:41
diff --git a/tests/ui/impl-trait/where-allowed.stderr b/tests/ui/impl-trait/where-allowed.stderr
index 6cab4fabb1ffb..1a8d6509e137d 100644
--- a/tests/ui/impl-trait/where-allowed.stderr
+++ b/tests/ui/impl-trait/where-allowed.stderr
@@ -384,11 +384,11 @@ LL | fn in_impl_Fn_return_in_return() -> &'static impl Fn() -> impl Debug { pani
    |
    = note: multiple `impl`s satisfying `_: Fn()` found in the following crates: `alloc`, `core`:
            - impl<A, F> Fn<A> for &F
-             where A: Tuple, F: Fn<A>, F: ?Sized;
+             where A: std::marker::Tuple, F: Fn<A>, F: ?Sized;
            - impl<Args, F, A> Fn<Args> for Box<F, A>
-             where Args: Tuple, F: Fn<Args>, A: Allocator, F: ?Sized;
+             where Args: std::marker::Tuple, F: Fn<Args>, A: Allocator, F: ?Sized;
            - impl<F, Args> Fn<Args> for Exclusive<F>
-             where F: Sync, F: Fn<Args>, Args: Tuple;
+             where F: Sync, F: Fn<Args>, Args: std::marker::Tuple;
 
 error[E0118]: no nominal type found for inherent implementation
   --> $DIR/where-allowed.rs:241:1
diff --git a/tests/ui/layout/rust-call-abi-not-a-tuple-ice-81974.stderr b/tests/ui/layout/rust-call-abi-not-a-tuple-ice-81974.stderr
index 75ee936d9e8ba..e7cb82687fa7d 100644
--- a/tests/ui/layout/rust-call-abi-not-a-tuple-ice-81974.stderr
+++ b/tests/ui/layout/rust-call-abi-not-a-tuple-ice-81974.stderr
@@ -2,7 +2,7 @@ error[E0059]: type parameter to bare `FnOnce` trait must be a tuple
   --> $DIR/rust-call-abi-not-a-tuple-ice-81974.rs:31:5
    |
 LL |     extern "rust-call" fn call_once(mut self, a: A) -> Self::Output {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Tuple` is not implemented for `A`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::marker::Tuple` is not implemented for `A`
    |
 note: required by a bound in `FnOnce`
   --> $SRC_DIR/core/src/ops/function.rs:LL:COL
@@ -15,7 +15,7 @@ error[E0059]: type parameter to bare `FnOnce` trait must be a tuple
   --> $DIR/rust-call-abi-not-a-tuple-ice-81974.rs:24:12
    |
 LL | impl<A, B> FnOnce<A> for CachedFun<A, B>
-   |            ^^^^^^^^^ the trait `Tuple` is not implemented for `A`
+   |            ^^^^^^^^^ the trait `std::marker::Tuple` is not implemented for `A`
    |
 note: required by a bound in `FnOnce`
   --> $SRC_DIR/core/src/ops/function.rs:LL:COL
@@ -28,7 +28,7 @@ error[E0059]: type parameter to bare `FnOnce` trait must be a tuple
   --> $DIR/rust-call-abi-not-a-tuple-ice-81974.rs:45:5
    |
 LL |     extern "rust-call" fn call_mut(&mut self, a: A) -> Self::Output {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Tuple` is not implemented for `A`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::marker::Tuple` is not implemented for `A`
    |
 note: required by a bound in `FnOnce`
   --> $SRC_DIR/core/src/ops/function.rs:LL:COL
@@ -41,7 +41,7 @@ error[E0059]: type parameter to bare `FnMut` trait must be a tuple
   --> $DIR/rust-call-abi-not-a-tuple-ice-81974.rs:39:12
    |
 LL | impl<A, B> FnMut<A> for CachedFun<A, B>
-   |            ^^^^^^^^ the trait `Tuple` is not implemented for `A`
+   |            ^^^^^^^^ the trait `std::marker::Tuple` is not implemented for `A`
    |
 note: required by a bound in `FnMut`
   --> $SRC_DIR/core/src/ops/function.rs:LL:COL
@@ -54,7 +54,7 @@ error[E0277]: functions with the "rust-call" ABI must take a single non-self tup
   --> $DIR/rust-call-abi-not-a-tuple-ice-81974.rs:31:5
    |
 LL |     extern "rust-call" fn call_once(mut self, a: A) -> Self::Output {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Tuple` is not implemented for `A`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::marker::Tuple` is not implemented for `A`
    |
 help: consider further restricting type parameter `A` with unstable trait `Tuple`
    |
@@ -65,7 +65,7 @@ error[E0277]: functions with the "rust-call" ABI must take a single non-self tup
   --> $DIR/rust-call-abi-not-a-tuple-ice-81974.rs:45:5
    |
 LL |     extern "rust-call" fn call_mut(&mut self, a: A) -> Self::Output {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Tuple` is not implemented for `A`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::marker::Tuple` is not implemented for `A`
    |
 help: consider further restricting type parameter `A` with unstable trait `Tuple`
    |
@@ -76,7 +76,7 @@ error[E0277]: `A` is not a tuple
   --> $DIR/rust-call-abi-not-a-tuple-ice-81974.rs:34:19
    |
 LL |     self.call_mut(a)
-   |          -------- ^ the trait `Tuple` is not implemented for `A`
+   |          -------- ^ the trait `std::marker::Tuple` is not implemented for `A`
    |          |
    |          required by a bound introduced by this call
    |
@@ -91,7 +91,7 @@ error[E0277]: `i32` is not a tuple
   --> $DIR/rust-call-abi-not-a-tuple-ice-81974.rs:59:26
    |
 LL |     cachedcoso.call_once(1);
-   |                --------- ^ the trait `Tuple` is not implemented for `i32`
+   |                --------- ^ the trait `std::marker::Tuple` is not implemented for `i32`
    |                |
    |                required by a bound introduced by this call
    |
diff --git a/tests/ui/overloaded/overloaded-calls-nontuple.stderr b/tests/ui/overloaded/overloaded-calls-nontuple.stderr
index 22598f3a39010..54a9d1f09b52a 100644
--- a/tests/ui/overloaded/overloaded-calls-nontuple.stderr
+++ b/tests/ui/overloaded/overloaded-calls-nontuple.stderr
@@ -2,7 +2,7 @@ error[E0059]: type parameter to bare `FnMut` trait must be a tuple
   --> $DIR/overloaded-calls-nontuple.rs:10:6
    |
 LL | impl FnMut<isize> for S {
-   |      ^^^^^^^^^^^^ the trait `Tuple` is not implemented for `isize`
+   |      ^^^^^^^^^^^^ the trait `std::marker::Tuple` is not implemented for `isize`
    |
 note: required by a bound in `FnMut`
   --> $SRC_DIR/core/src/ops/function.rs:LL:COL
@@ -11,7 +11,7 @@ error[E0059]: type parameter to bare `FnOnce` trait must be a tuple
   --> $DIR/overloaded-calls-nontuple.rs:18:6
    |
 LL | impl FnOnce<isize> for S {
-   |      ^^^^^^^^^^^^^ the trait `Tuple` is not implemented for `isize`
+   |      ^^^^^^^^^^^^^ the trait `std::marker::Tuple` is not implemented for `isize`
    |
 note: required by a bound in `FnOnce`
   --> $SRC_DIR/core/src/ops/function.rs:LL:COL
@@ -20,19 +20,19 @@ error[E0277]: functions with the "rust-call" ABI must take a single non-self tup
   --> $DIR/overloaded-calls-nontuple.rs:12:5
    |
 LL |     extern "rust-call" fn call_mut(&mut self, z: isize) -> isize {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Tuple` is not implemented for `isize`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::marker::Tuple` is not implemented for `isize`
 
 error[E0277]: functions with the "rust-call" ABI must take a single non-self tuple argument
   --> $DIR/overloaded-calls-nontuple.rs:21:5
    |
 LL |     extern "rust-call" fn call_once(mut self, z: isize) -> isize {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Tuple` is not implemented for `isize`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::marker::Tuple` is not implemented for `isize`
 
 error[E0277]: `isize` is not a tuple
   --> $DIR/overloaded-calls-nontuple.rs:23:23
    |
 LL |         self.call_mut(z)
-   |              -------- ^ the trait `Tuple` is not implemented for `isize`
+   |              -------- ^ the trait `std::marker::Tuple` is not implemented for `isize`
    |              |
    |              required by a bound introduced by this call
    |
@@ -53,7 +53,7 @@ error[E0277]: `isize` is not a tuple
   --> $DIR/overloaded-calls-nontuple.rs:29:10
    |
 LL |     drop(s(3))
-   |          ^^^^ the trait `Tuple` is not implemented for `isize`
+   |          ^^^^ the trait `std::marker::Tuple` is not implemented for `isize`
 
 error: aborting due to 7 previous errors
 
diff --git a/tests/ui/reflection/dump.rs b/tests/ui/reflection/dump.rs
new file mode 100644
index 0000000000000..3bf4f32b6641d
--- /dev/null
+++ b/tests/ui/reflection/dump.rs
@@ -0,0 +1,30 @@
+#![feature(type_info)]
+//@ run-pass
+//@ check-run-results
+#![allow(dead_code)]
+
+use std::mem::type_info::Type;
+
+struct Foo {
+    a: u32,
+}
+
+enum Bar {
+    Some(u32),
+    None,
+    Foomp { a: (), b: &'static str },
+}
+
+struct Unsized {
+    x: u16,
+    s: str,
+}
+
+fn main() {
+    println!("{:#?}", const { Type::of::<(u8, u8, ())>() }.kind);
+    println!("{:#?}", const { Type::of::<Foo>() }.kind);
+    println!("{:#?}", const { Type::of::<Bar>() }.kind);
+    println!("{:#?}", const { Type::of::<&Unsized>() }.kind);
+    println!("{:#?}", const { Type::of::<&str>() }.kind);
+    println!("{:#?}", const { Type::of::<&[u8]>() }.kind);
+}
diff --git a/tests/ui/reflection/dump.run.stdout b/tests/ui/reflection/dump.run.stdout
new file mode 100644
index 0000000000000..71fd80b466580
--- /dev/null
+++ b/tests/ui/reflection/dump.run.stdout
@@ -0,0 +1,23 @@
+Tuple(
+    Tuple {
+        fields: [
+            Field {
+                ty: TypeId(0x0596b48cc04376e64d5c788c2aa46bdb),
+                offset: 0,
+            },
+            Field {
+                ty: TypeId(0x0596b48cc04376e64d5c788c2aa46bdb),
+                offset: 1,
+            },
+            Field {
+                ty: TypeId(0x41223169ff28813ba79b7268a2a968d9),
+                offset: 2,
+            },
+        ],
+    },
+)
+Other
+Other
+Other
+Other
+Other
diff --git a/tests/ui/reflection/feature_gate.rs b/tests/ui/reflection/feature_gate.rs
new file mode 100644
index 0000000000000..2dde268097930
--- /dev/null
+++ b/tests/ui/reflection/feature_gate.rs
@@ -0,0 +1,8 @@
+use std::mem::type_info::Type;
+//~^ ERROR: use of unstable library feature `type_info`
+
+fn main() {
+    let ty = std::mem::type_info::Type::of::<()>();
+    //~^ ERROR: use of unstable library feature `type_info`
+    //~| ERROR: use of unstable library feature `type_info`
+}
diff --git a/tests/ui/reflection/feature_gate.stderr b/tests/ui/reflection/feature_gate.stderr
new file mode 100644
index 0000000000000..76ad18ffb0ba0
--- /dev/null
+++ b/tests/ui/reflection/feature_gate.stderr
@@ -0,0 +1,33 @@
+error[E0658]: use of unstable library feature `type_info`
+  --> $DIR/feature_gate.rs:1:5
+   |
+LL | use std::mem::type_info::Type;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #146922 <https://github.com/rust-lang/rust/issues/146922> for more information
+   = help: add `#![feature(type_info)]` 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[E0658]: use of unstable library feature `type_info`
+  --> $DIR/feature_gate.rs:5:14
+   |
+LL |     let ty = std::mem::type_info::Type::of::<()>();
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #146922 <https://github.com/rust-lang/rust/issues/146922> for more information
+   = help: add `#![feature(type_info)]` 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[E0658]: use of unstable library feature `type_info`
+  --> $DIR/feature_gate.rs:5:14
+   |
+LL |     let ty = std::mem::type_info::Type::of::<()>();
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #146922 <https://github.com/rust-lang/rust/issues/146922> for more information
+   = help: add `#![feature(type_info)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/reflection/tuples.rs b/tests/ui/reflection/tuples.rs
new file mode 100644
index 0000000000000..eab25a691efe2
--- /dev/null
+++ b/tests/ui/reflection/tuples.rs
@@ -0,0 +1,36 @@
+#![feature(type_info)]
+
+//@ run-pass
+
+use std::mem::type_info::{Type, TypeKind};
+
+fn assert_tuple_arity<T: 'static, const N: usize>() {
+    const {
+        match &Type::of::<T>().kind {
+            TypeKind::Tuple(tup) => {
+                assert!(tup.fields.len() == N);
+            }
+            _ => unreachable!(),
+        }
+    }
+}
+
+fn main() {
+    assert_tuple_arity::<(), 0>();
+    assert_tuple_arity::<(u8,), 1>();
+    assert_tuple_arity::<(u8, u8), 2>();
+    const {
+        match &Type::of::<(u8, u8)>().kind {
+            TypeKind::Tuple(tup) => {
+                let [a, b] = tup.fields else { unreachable!() };
+                assert!(a.offset == 0);
+                assert!(b.offset == 1);
+                match (&a.ty.info().kind, &b.ty.info().kind) {
+                    (TypeKind::Leaf, TypeKind::Leaf) => {}
+                    _ => unreachable!(),
+                }
+            }
+            _ => unreachable!(),
+        }
+    }
+}
diff --git a/tests/ui/resolve/resolve-assoc-suggestions.stderr b/tests/ui/resolve/resolve-assoc-suggestions.stderr
index ef519ac0d9217..7d94fb5ca35f4 100644
--- a/tests/ui/resolve/resolve-assoc-suggestions.stderr
+++ b/tests/ui/resolve/resolve-assoc-suggestions.stderr
@@ -31,6 +31,10 @@ help: you might have meant to use the associated type
    |
 LL |         let _: Self::Type;
    |                ++++++
+help: consider importing this struct
+   |
+LL + use std::mem::type_info::Type;
+   |
 
 error[E0531]: cannot find tuple struct or tuple variant `Type` in this scope
   --> $DIR/resolve-assoc-suggestions.rs:25:13
diff --git a/tests/ui/suggestions/fn-trait-notation.stderr b/tests/ui/suggestions/fn-trait-notation.stderr
index 9b47c8c02a782..9d0845478527b 100644
--- a/tests/ui/suggestions/fn-trait-notation.stderr
+++ b/tests/ui/suggestions/fn-trait-notation.stderr
@@ -32,7 +32,7 @@ error[E0059]: type parameter to bare `Fn` trait must be a tuple
   --> $DIR/fn-trait-notation.rs:4:8
    |
 LL |     F: Fn<i32, Output = i32>,
-   |        ^^^^^^^^^^^^^^^^^^^^^ the trait `Tuple` is not implemented for `i32`
+   |        ^^^^^^^^^^^^^^^^^^^^^ the trait `std::marker::Tuple` is not implemented for `i32`
    |
 note: required by a bound in `Fn`
   --> $SRC_DIR/core/src/ops/function.rs:LL:COL
@@ -47,7 +47,7 @@ error[E0277]: `i32` is not a tuple
   --> $DIR/fn-trait-notation.rs:9:5
    |
 LL |     f(3);
-   |     ^^^^ the trait `Tuple` is not implemented for `i32`
+   |     ^^^^ the trait `std::marker::Tuple` is not implemented for `i32`
 
 error[E0308]: mismatched types
   --> $DIR/fn-trait-notation.rs:17:5
diff --git a/tests/ui/thir-print/offset_of.stdout b/tests/ui/thir-print/offset_of.stdout
index ab924091ba7a0..dcf60a86af9b4 100644
--- a/tests/ui/thir-print/offset_of.stdout
+++ b/tests/ui/thir-print/offset_of.stdout
@@ -68,7 +68,7 @@ body:
                                             )
                                             else_block: None
                                             lint_level: Explicit(HirId(DefId(offset_of::concrete).10))
-                                            span: $DIR/offset_of.rs:37:5: 1437:57 (#0)
+                                            span: $DIR/offset_of.rs:37:5: 1440:57 (#0)
                                         }
                                     }
                                     Stmt {
@@ -117,7 +117,7 @@ body:
                                             )
                                             else_block: None
                                             lint_level: Explicit(HirId(DefId(offset_of::concrete).20))
-                                            span: $DIR/offset_of.rs:38:5: 1437:57 (#0)
+                                            span: $DIR/offset_of.rs:38:5: 1440:57 (#0)
                                         }
                                     }
                                     Stmt {
@@ -166,7 +166,7 @@ body:
                                             )
                                             else_block: None
                                             lint_level: Explicit(HirId(DefId(offset_of::concrete).30))
-                                            span: $DIR/offset_of.rs:39:5: 1437:57 (#0)
+                                            span: $DIR/offset_of.rs:39:5: 1440:57 (#0)
                                         }
                                     }
                                     Stmt {
@@ -215,7 +215,7 @@ body:
                                             )
                                             else_block: None
                                             lint_level: Explicit(HirId(DefId(offset_of::concrete).40))
-                                            span: $DIR/offset_of.rs:40:5: 1437:57 (#0)
+                                            span: $DIR/offset_of.rs:40:5: 1440:57 (#0)
                                         }
                                     }
                                     Stmt {
@@ -264,7 +264,7 @@ body:
                                             )
                                             else_block: None
                                             lint_level: Explicit(HirId(DefId(offset_of::concrete).50))
-                                            span: $DIR/offset_of.rs:41:5: 1437:57 (#0)
+                                            span: $DIR/offset_of.rs:41:5: 1440:57 (#0)
                                         }
                                     }
                                 ]
@@ -864,7 +864,7 @@ body:
                                             )
                                             else_block: None
                                             lint_level: Explicit(HirId(DefId(offset_of::generic).12))
-                                            span: $DIR/offset_of.rs:45:5: 1437:57 (#0)
+                                            span: $DIR/offset_of.rs:45:5: 1440:57 (#0)
                                         }
                                     }
                                     Stmt {
@@ -913,7 +913,7 @@ body:
                                             )
                                             else_block: None
                                             lint_level: Explicit(HirId(DefId(offset_of::generic).24))
-                                            span: $DIR/offset_of.rs:46:5: 1437:57 (#0)
+                                            span: $DIR/offset_of.rs:46:5: 1440:57 (#0)
                                         }
                                     }
                                     Stmt {
@@ -962,7 +962,7 @@ body:
                                             )
                                             else_block: None
                                             lint_level: Explicit(HirId(DefId(offset_of::generic).36))
-                                            span: $DIR/offset_of.rs:47:5: 1437:57 (#0)
+                                            span: $DIR/offset_of.rs:47:5: 1440:57 (#0)
                                         }
                                     }
                                     Stmt {
@@ -1011,7 +1011,7 @@ body:
                                             )
                                             else_block: None
                                             lint_level: Explicit(HirId(DefId(offset_of::generic).48))
-                                            span: $DIR/offset_of.rs:48:5: 1437:57 (#0)
+                                            span: $DIR/offset_of.rs:48:5: 1440:57 (#0)
                                         }
                                     }
                                 ]
diff --git a/tests/ui/traits/ignore-err-impls.stderr b/tests/ui/traits/ignore-err-impls.stderr
index 68077c435135c..46a2a7d55a2e5 100644
--- a/tests/ui/traits/ignore-err-impls.stderr
+++ b/tests/ui/traits/ignore-err-impls.stderr
@@ -4,10 +4,10 @@ error[E0425]: cannot find type `Type` in this scope
 LL | impl Generic<Type> for S {}
    |              ^^^^ not found in this scope
    |
-help: you might be missing a type parameter
+help: consider importing this struct
+   |
+LL + use std::mem::type_info::Type;
    |
-LL | impl<Type> Generic<Type> for S {}
-   |     ++++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/next-solver/well-formed-in-relate.stderr b/tests/ui/traits/next-solver/well-formed-in-relate.stderr
index d79e465b3e387..264ab9bebbb92 100644
--- a/tests/ui/traits/next-solver/well-formed-in-relate.stderr
+++ b/tests/ui/traits/next-solver/well-formed-in-relate.stderr
@@ -9,11 +9,11 @@ LL |     x = unconstrained_map();
    |
    = note: multiple `impl`s satisfying `_: Fn()` found in the following crates: `alloc`, `core`:
            - impl<A, F> Fn<A> for &F
-             where A: Tuple, F: Fn<A>, F: ?Sized;
+             where A: std::marker::Tuple, F: Fn<A>, F: ?Sized;
            - impl<Args, F, A> Fn<Args> for Box<F, A>
-             where Args: Tuple, F: Fn<Args>, A: Allocator, F: ?Sized;
+             where Args: std::marker::Tuple, F: Fn<Args>, A: Allocator, F: ?Sized;
            - impl<F, Args> Fn<Args> for Exclusive<F>
-             where F: Sync, F: Fn<Args>, Args: Tuple;
+             where F: Sync, F: Fn<Args>, Args: std::marker::Tuple;
 note: required by a bound in `unconstrained_map`
   --> $DIR/well-formed-in-relate.rs:21:25
    |
diff --git a/tests/ui/tuple/builtin-fail.stderr b/tests/ui/tuple/builtin-fail.stderr
index 44e79578f4c92..0dec88ded7ce2 100644
--- a/tests/ui/tuple/builtin-fail.stderr
+++ b/tests/ui/tuple/builtin-fail.stderr
@@ -2,7 +2,7 @@ error[E0277]: `T` is not a tuple
   --> $DIR/builtin-fail.rs:8:23
    |
 LL |     assert_is_tuple::<T>();
-   |                       ^ the trait `Tuple` is not implemented for `T`
+   |                       ^ the trait `std::marker::Tuple` is not implemented for `T`
    |
 note: required by a bound in `assert_is_tuple`
   --> $DIR/builtin-fail.rs:3:23
@@ -18,7 +18,7 @@ error[E0277]: `i32` is not a tuple
   --> $DIR/builtin-fail.rs:13:23
    |
 LL |     assert_is_tuple::<i32>();
-   |                       ^^^ the trait `Tuple` is not implemented for `i32`
+   |                       ^^^ the trait `std::marker::Tuple` is not implemented for `i32`
    |
 note: required by a bound in `assert_is_tuple`
   --> $DIR/builtin-fail.rs:3:23
@@ -30,7 +30,7 @@ error[E0277]: `i32` is not a tuple
   --> $DIR/builtin-fail.rs:15:24
    |
 LL |     assert_is_tuple::<(i32)>();
-   |                        ^^^ the trait `Tuple` is not implemented for `i32`
+   |                        ^^^ the trait `std::marker::Tuple` is not implemented for `i32`
    |
 note: required by a bound in `assert_is_tuple`
   --> $DIR/builtin-fail.rs:3:23
@@ -44,7 +44,7 @@ error[E0277]: `TupleStruct` is not a tuple
 LL |     assert_is_tuple::<TupleStruct>();
    |                       ^^^^^^^^^^^ unsatisfied trait bound
    |
-help: the trait `Tuple` is not implemented for `TupleStruct`
+help: the trait `std::marker::Tuple` is not implemented for `TupleStruct`
   --> $DIR/builtin-fail.rs:5:1
    |
 LL | struct TupleStruct(i32, i32);
diff --git a/tests/ui/typeck/issue-57404.stderr b/tests/ui/typeck/issue-57404.stderr
index 4c1bfc0cbf773..f1d28e475a072 100644
--- a/tests/ui/typeck/issue-57404.stderr
+++ b/tests/ui/typeck/issue-57404.stderr
@@ -2,7 +2,7 @@ error[E0277]: `&mut ()` is not a tuple
   --> $DIR/issue-57404.rs:6:41
    |
 LL |     handlers.unwrap().as_mut().call_mut(&mut ());
-   |                                -------- ^^^^^^^ the trait `Tuple` is not implemented for `&mut ()`
+   |                                -------- ^^^^^^^ the trait `std::marker::Tuple` is not implemented for `&mut ()`
    |                                |
    |                                required by a bound introduced by this call
    |
diff --git a/tests/ui/unboxed-closures/non-tupled-arg-mismatch.stderr b/tests/ui/unboxed-closures/non-tupled-arg-mismatch.stderr
index 0d4265ddf8bd9..621a533dd1c5c 100644
--- a/tests/ui/unboxed-closures/non-tupled-arg-mismatch.stderr
+++ b/tests/ui/unboxed-closures/non-tupled-arg-mismatch.stderr
@@ -2,7 +2,7 @@ error[E0059]: type parameter to bare `Fn` trait must be a tuple
   --> $DIR/non-tupled-arg-mismatch.rs:3:9
    |
 LL | fn a<F: Fn<usize>>(f: F) {}
-   |         ^^^^^^^^^ the trait `Tuple` is not implemented for `usize`
+   |         ^^^^^^^^^ the trait `std::marker::Tuple` is not implemented for `usize`
    |
 note: required by a bound in `Fn`
   --> $SRC_DIR/core/src/ops/function.rs:LL:COL
diff --git a/triagebot.toml b/triagebot.toml
index 59c5e5f24330c..9b71bf55f2182 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -1003,6 +1003,13 @@ cc = ["@lcnr"]
 message = "HIR ty lowering was modified"
 cc = ["@fmease"]
 
+[mentions."library/core/src/mem/type_info.rs"]
+message = """
+The reflection data structures are tied exactly to the implementation
+in the compiler. Make sure to also adjust `rustc_const_eval/src/const_eval/type_info.rs
+"""
+cc = ["@oli-obk"]
+
 [mentions."compiler/rustc_error_codes/src/lib.rs"]
 message = "Some changes occurred in diagnostic error codes"
 cc = ["@GuillaumeGomez"]