Auto merge of #152230 - JonathanBrouwer:rollup-de59XEq, r=JonathanBrouwer

Rollup of 6 pull requests Successful merges: - rust-lang/rust#151590 (cmse: don't use `BackendRepr` when checking return type) - rust-lang/rust#151945 (feat: Add `NonZero::<T>::from_str_radix`) - rust-lang/rust#152000 (Fix ICE in normalizing inherent associated consts with `#[type_const]`) - rust-lang/rust#152192 (Always use Xcode-provided Clang in macOS CI) - rust-lang/rust#152196 (bootstrap: Remove `ShouldRun::paths`) - rust-lang/rust#152222 (Re-add TaKO8Ki to triagebot review queue)
2026-02-06 15:32:38 +00:00 · 2026-02-06 15:32:38 +00:00 · bce89b6a56
commit bce89b6a56
parent 55bfca7d7d 4ae29f946a
40 changed files with 496 additions and 192 deletions
--- a/compiler/rustc_abi/src/layout/ty.rs
+++ b/compiler/rustc_abi/src/layout/ty.rs
@ -290,7 +290,19 @@ impl<'a, Ty> TyAndLayout<'a, Ty> {
    /// function call isn't allowed (a.k.a. `va_list`).
    ///
    /// This function handles transparent types automatically.
-    pub fn pass_indirectly_in_non_rustic_abis<C>(mut self, cx: &C) -> bool
+    pub fn pass_indirectly_in_non_rustic_abis<C>(self, cx: &C) -> bool
+    where
+        Ty: TyAbiInterface<'a, C> + Copy,
+    {
+        let base = self.peel_transparent_wrappers(cx);
+        Ty::is_pass_indirectly_in_non_rustic_abis_flag_set(base)
+    }
+
+    /// Recursively peel away transparent wrappers, returning the inner value.
+    ///
+    /// The return value is not `repr(transparent)` and/or does
+    /// not have a non-1zst field.
+    pub fn peel_transparent_wrappers<C>(mut self, cx: &C) -> Self
    where
        Ty: TyAbiInterface<'a, C> + Copy,
    {
@ -300,7 +312,7 @@ impl<'a, Ty> TyAndLayout<'a, Ty> {
            self = field;
        }

-        Ty::is_pass_indirectly_in_non_rustic_abis_flag_set(self)
+        self
    }

    /// Finds the one field that is not a 1-ZST.
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/cmse.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/cmse.rs
@ -1,8 +1,8 @@
-use rustc_abi::{BackendRepr, ExternAbi, Float, Integer, Primitive, Scalar};
+use rustc_abi::ExternAbi;
 use rustc_errors::{DiagCtxtHandle, E0781, struct_span_code_err};
 use rustc_hir::{self as hir, HirId};
 use rustc_middle::bug;
-use rustc_middle::ty::layout::{LayoutError, TyAndLayout};
+use rustc_middle::ty::layout::{LayoutCx, LayoutError, TyAndLayout};
 use rustc_middle::ty::{self, TyCtxt, TypeVisitableExt};
 use rustc_span::Span;

@ -150,8 +150,9 @@ fn is_valid_cmse_output<'tcx>(

    let typing_env = ty::TypingEnv::fully_monomorphized();
    let layout = tcx.layout_of(typing_env.as_query_input(return_type))?;
+    let layout_cx = LayoutCx::new(tcx, typing_env);

-    if !is_valid_cmse_output_layout(layout) {
+    if !is_valid_cmse_output_layout(layout_cx, layout) {
        dcx.emit_err(errors::CmseOutputStackSpill { span: fn_decl.output.span(), abi });
    }

@ -159,25 +160,20 @@ fn is_valid_cmse_output<'tcx>(
 }

 /// Returns whether the output will fit into the available registers
-fn is_valid_cmse_output_layout<'tcx>(layout: TyAndLayout<'tcx>) -> bool {
+fn is_valid_cmse_output_layout<'tcx>(cx: LayoutCx<'tcx>, layout: TyAndLayout<'tcx>) -> bool {
    let size = layout.layout.size().bytes();

    if size <= 4 {
        return true;
-    } else if size > 8 {
+    } else if size != 8 {
        return false;
    }

-    // Accept scalar 64-bit types.
-    let BackendRepr::Scalar(scalar) = layout.layout.backend_repr else {
-        return false;
-    };
-
-    let Scalar::Initialized { value, .. } = scalar else {
-        return false;
-    };
-
-    matches!(value, Primitive::Int(Integer::I64, _) | Primitive::Float(Float::F64))
+    // Accept (transparently wrapped) scalar 64-bit primitives.
+    matches!(
+        layout.peel_transparent_wrappers(&cx).ty.kind(),
+        ty::Int(ty::IntTy::I64) | ty::Uint(ty::UintTy::U64) | ty::Float(ty::FloatTy::F64)
+    )
 }

 fn should_emit_layout_error<'tcx>(abi: ExternAbi, layout_err: &'tcx LayoutError<'tcx>) -> bool {
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
@ -45,6 +45,38 @@ use crate::method::{self, MethodCallee};
 use crate::{BreakableCtxt, Diverges, Expectation, FnCtxt, LoweredTy};

 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
+    /// Transform generic args for inherent associated type constants (IACs).
+    ///
+    /// IACs have a different generic parameter structure than regular associated constants:
+    /// - Regular assoc const: parent (impl) generic params + own generic params
+    /// - IAC (type_const): Self type + own generic params
+    pub(crate) fn transform_args_for_inherent_type_const(
+        &self,
+        def_id: DefId,
+        args: GenericArgsRef<'tcx>,
+    ) -> GenericArgsRef<'tcx> {
+        let tcx = self.tcx;
+        if !tcx.is_type_const(def_id) {
+            return args;
+        }
+        let Some(assoc_item) = tcx.opt_associated_item(def_id) else {
+            return args;
+        };
+        if !matches!(assoc_item.container, ty::AssocContainer::InherentImpl) {
+            return args;
+        }
+
+        let impl_def_id = assoc_item.container_id(tcx);
+        let generics = tcx.generics_of(def_id);
+        let impl_args = &args[..generics.parent_count];
+        let self_ty = tcx.type_of(impl_def_id).instantiate(tcx, impl_args);
+        // Build new args: [Self, own_args...]
+        let own_args = &args[generics.parent_count..];
+        tcx.mk_args_from_iter(
+            std::iter::once(ty::GenericArg::from(self_ty)).chain(own_args.iter().copied()),
+        )
+    }
+
    /// Produces warning on the given node, if the current point in the
    /// function is unreachable, and there hasn't been another warning.
    pub(crate) fn warn_if_unreachable(&self, id: HirId, span: Span, kind: &str) {
@ -1281,8 +1313,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
            )
        });

+        let args_for_user_type = if let Res::Def(DefKind::AssocConst, def_id) = res {
+            self.transform_args_for_inherent_type_const(def_id, args_raw)
+        } else {
+            args_raw
+        };
+
        // First, store the "user args" for later.
-        self.write_user_type_annotation_from_args(hir_id, def_id, args_raw, user_self_ty);
+        self.write_user_type_annotation_from_args(hir_id, def_id, args_for_user_type, user_self_ty);

        // Normalize only after registering type annotations.
        let args = self.normalize(span, args_raw);
@ -1322,6 +1360,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
        }

        debug!("instantiate_value_path: type of {:?} is {:?}", hir_id, ty_instantiated);
+
+        let args = if let Res::Def(DefKind::AssocConst, def_id) = res {
+            self.transform_args_for_inherent_type_const(def_id, args)
+        } else {
+            args
+        };
+
        self.write_args(hir_id, args);

        (ty_instantiated, res)
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@ -2920,12 +2920,15 @@ impl<'tcx> TyCtxt<'tcx> {
    ) -> bool {
        let generics = self.generics_of(def_id);

-        // IATs themselves have a weird arg setup (self + own args), but nested items *in* IATs
-        // (namely: opaques, i.e. ATPITs) do not.
-        let own_args = if !nested
-            && let DefKind::AssocTy = self.def_kind(def_id)
-            && let DefKind::Impl { of_trait: false } = self.def_kind(self.parent(def_id))
-        {
+        // IATs and IACs (inherent associated types/consts with #[type_const]) themselves have a
+        // weird arg setup (self + own args), but nested items *in* IATs (namely: opaques, i.e.
+        // ATPITs) do not.
+        let is_inherent_assoc_ty = matches!(self.def_kind(def_id), DefKind::AssocTy)
+            && matches!(self.def_kind(self.parent(def_id)), DefKind::Impl { of_trait: false });
+        let is_inherent_assoc_type_const = matches!(self.def_kind(def_id), DefKind::AssocConst)
+            && matches!(self.def_kind(self.parent(def_id)), DefKind::Impl { of_trait: false })
+            && self.is_type_const(def_id);
+        let own_args = if !nested && (is_inherent_assoc_ty || is_inherent_assoc_type_const) {
            if generics.own_params.len() + 1 != args.len() {
                return false;
            }
@ -2967,9 +2970,12 @@ impl<'tcx> TyCtxt<'tcx> {
    /// and print out the args if not.
    pub fn debug_assert_args_compatible(self, def_id: DefId, args: &'tcx [ty::GenericArg<'tcx>]) {
        if cfg!(debug_assertions) && !self.check_args_compatible(def_id, args) {
-            if let DefKind::AssocTy = self.def_kind(def_id)
-                && let DefKind::Impl { of_trait: false } = self.def_kind(self.parent(def_id))
-            {
+            let is_inherent_assoc_ty = matches!(self.def_kind(def_id), DefKind::AssocTy)
+                && matches!(self.def_kind(self.parent(def_id)), DefKind::Impl { of_trait: false });
+            let is_inherent_assoc_type_const = matches!(self.def_kind(def_id), DefKind::AssocConst)
+                && matches!(self.def_kind(self.parent(def_id)), DefKind::Impl { of_trait: false })
+                && self.is_type_const(def_id);
+            if is_inherent_assoc_ty || is_inherent_assoc_type_const {
                bug!(
                    "args not compatible with generics for {}: args={:#?}, generics={:#?}",
                    self.def_path_str(def_id),
--- a/compiler/rustc_trait_selection/src/traits/query/type_op/ascribe_user_type.rs
+++ b/compiler/rustc_trait_selection/src/traits/query/type_op/ascribe_user_type.rs
@ -1,3 +1,4 @@
+use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{CRATE_DEF_ID, DefId};
 use rustc_infer::traits::Obligation;
 use rustc_middle::traits::query::NoSolution;
@ -96,6 +97,26 @@ fn relate_mir_and_user_args<'tcx>(
    let tcx = ocx.infcx.tcx;
    let cause = ObligationCause::dummy_with_span(span);

+    // For IACs, the user args are in the format [SelfTy, GAT_args...] but type_of expects [impl_args..., GAT_args...].
+    // We need to infer the impl args by equating the impl's self type with the user-provided self type.
+    let is_inherent_assoc_const = tcx.def_kind(def_id) == DefKind::AssocConst
+        && tcx.def_kind(tcx.parent(def_id)) == DefKind::Impl { of_trait: false }
+        && tcx.is_type_const(def_id);
+
+    let args = if is_inherent_assoc_const {
+        let impl_def_id = tcx.parent(def_id);
+        let impl_args = ocx.infcx.fresh_args_for_item(span, impl_def_id);
+        let impl_self_ty =
+            ocx.normalize(&cause, param_env, tcx.type_of(impl_def_id).instantiate(tcx, impl_args));
+        let user_self_ty = ocx.normalize(&cause, param_env, args[0].expect_ty());
+        ocx.eq(&cause, param_env, impl_self_ty, user_self_ty)?;
+
+        let gat_args = &args[1..];
+        tcx.mk_args_from_iter(impl_args.iter().chain(gat_args.iter().copied()))
+    } else {
+        args
+    };
+
    let ty = tcx.type_of(def_id).instantiate(tcx, args);
    let ty = ocx.normalize(&cause, param_env, ty);
    debug!("relate_type_and_user_type: ty of def-id is {:?}", ty);
--- a/library/core/src/num/nonzero.rs
+++ b/library/core/src/num/nonzero.rs
@ -1240,16 +1240,78 @@ macro_rules! nonzero_integer {
                // So the result cannot be zero.
                unsafe { Self::new_unchecked(self.get().saturating_pow(other)) }
            }
+
+            /// Parses a non-zero integer from a string slice with digits in a given base.
+            ///
+            /// The string is expected to be an optional
+            #[doc = sign_dependent_expr!{
+                $signedness ?
+                if signed {
+                    " `+` or `-` "
+                }
+                if unsigned {
+                    " `+` "
+                }
+            }]
+            /// sign followed by only digits. Leading and trailing non-digit characters (including
+            /// whitespace) represent an error. Underscores (which are accepted in Rust literals)
+            /// also represent an error.
+            ///
+            /// Digits are a subset of these characters, depending on `radix`:
+            ///
+            /// - `0-9`
+            /// - `a-z`
+            /// - `A-Z`
+            ///
+            /// # Panics
+            ///
+            /// This method panics if `radix` is not in the range from 2 to 36.
+            ///
+            /// # Examples
+            ///
+            /// Basic usage:
+            ///
+            /// ```
+            /// #![feature(nonzero_from_str_radix)]
+            ///
+            /// # use std::num::NonZero;
+            /// #
+            /// # fn main() { test().unwrap(); }
+            /// # fn test() -> Option<()> {
+            #[doc = concat!("assert_eq!(NonZero::<", stringify!($Int), ">::from_str_radix(\"A\", 16), Ok(NonZero::new(10)?));")]
+            /// # Some(())
+            /// # }
+            /// ```
+            ///
+            /// Trailing space returns error:
+            ///
+            /// ```
+            /// #![feature(nonzero_from_str_radix)]
+            ///
+            /// # use std::num::NonZero;
+            /// #
+            #[doc = concat!("assert!(NonZero::<", stringify!($Int), ">::from_str_radix(\"1 \", 10).is_err());")]
+            /// ```
+            #[unstable(feature = "nonzero_from_str_radix", issue = "152193")]
+            #[inline]
+            pub const fn from_str_radix(src: &str, radix: u32) -> Result<Self, ParseIntError> {
+                let n = match <$Int>::from_str_radix(src, radix) {
+                    Ok(n) => n,
+                    Err(err) => return Err(err),
+                };
+                if let Some(n) = Self::new(n) {
+                    Ok(n)
+                } else {
+                    Err(ParseIntError { kind: IntErrorKind::Zero })
+                }
+            }
        }

        #[stable(feature = "nonzero_parse", since = "1.35.0")]
        impl FromStr for NonZero<$Int> {
            type Err = ParseIntError;
            fn from_str(src: &str) -> Result<Self, Self::Err> {
-                Self::new(<$Int>::from_str_radix(src, 10)?)
-                    .ok_or(ParseIntError {
-                        kind: IntErrorKind::Zero
-                    })
+                Self::from_str_radix(src, 10)
            }
        }

--- a/library/coretests/tests/lib.rs
+++ b/library/coretests/tests/lib.rs
@ -90,6 +90,7 @@
 #![feature(new_range_api)]
 #![feature(next_index)]
 #![feature(non_exhaustive_omitted_patterns_lint)]
+#![feature(nonzero_from_str_radix)]
 #![feature(numfmt)]
 #![feature(one_sided_range)]
 #![feature(option_reduce)]
--- a/library/coretests/tests/nonzero.rs
+++ b/library/coretests/tests/nonzero.rs
@ -124,6 +124,41 @@ fn test_from_signed_nonzero() {
    assert_eq!(num, 1i32);
 }

+#[test]
+fn test_from_str_radix() {
+    assert_eq!(NonZero::<u8>::from_str_radix("123", 10), Ok(NonZero::new(123).unwrap()));
+    assert_eq!(NonZero::<u8>::from_str_radix("1001", 2), Ok(NonZero::new(9).unwrap()));
+    assert_eq!(NonZero::<u8>::from_str_radix("123", 8), Ok(NonZero::new(83).unwrap()));
+    assert_eq!(NonZero::<u16>::from_str_radix("123", 16), Ok(NonZero::new(291).unwrap()));
+    assert_eq!(NonZero::<u16>::from_str_radix("ffff", 16), Ok(NonZero::new(65535).unwrap()));
+    assert_eq!(NonZero::<u8>::from_str_radix("z", 36), Ok(NonZero::new(35).unwrap()));
+    assert_eq!(
+        NonZero::<u8>::from_str_radix("0", 10).err().map(|e| e.kind().clone()),
+        Some(IntErrorKind::Zero)
+    );
+    assert_eq!(
+        NonZero::<u8>::from_str_radix("-1", 10).err().map(|e| e.kind().clone()),
+        Some(IntErrorKind::InvalidDigit)
+    );
+    assert_eq!(
+        NonZero::<i8>::from_str_radix("-129", 10).err().map(|e| e.kind().clone()),
+        Some(IntErrorKind::NegOverflow)
+    );
+    assert_eq!(
+        NonZero::<u8>::from_str_radix("257", 10).err().map(|e| e.kind().clone()),
+        Some(IntErrorKind::PosOverflow)
+    );
+
+    assert_eq!(
+        NonZero::<u8>::from_str_radix("Z", 10).err().map(|e| e.kind().clone()),
+        Some(IntErrorKind::InvalidDigit)
+    );
+    assert_eq!(
+        NonZero::<u8>::from_str_radix("_", 2).err().map(|e| e.kind().clone()),
+        Some(IntErrorKind::InvalidDigit)
+    );
+}
+
 #[test]
 fn test_from_str() {
    assert_eq!("123".parse::<NonZero<u8>>(), Ok(NonZero::new(123).unwrap()));
--- a/src/bootstrap/src/core/build_steps/check.rs
+++ b/src/bootstrap/src/core/build_steps/check.rs
@ -706,7 +706,7 @@ macro_rules! tool_check_step {
            const IS_HOST: bool = true;

            fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
-                run.paths(&[ $path, $( $alt_path ),* ])
+                run.path($path) $( .path( $alt_path ) )*
            }

            fn is_default_step(_builder: &Builder<'_>) -> bool {
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@ -3156,7 +3156,7 @@ impl Step for CrateRustdoc {
    const IS_HOST: bool = true;

    fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
-        run.paths(&["src/librustdoc", "src/tools/rustdoc"])
+        run.path("src/librustdoc").path("src/tools/rustdoc")
    }

    fn is_default_step(_builder: &Builder<'_>) -> bool {
@ -3817,7 +3817,7 @@ impl Step for CodegenCranelift {
    const IS_HOST: bool = true;

    fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
-        run.paths(&["compiler/rustc_codegen_cranelift"])
+        run.path("compiler/rustc_codegen_cranelift")
    }

    fn is_default_step(_builder: &Builder<'_>) -> bool {
@ -3938,7 +3938,7 @@ impl Step for CodegenGCC {
    const IS_HOST: bool = true;

    fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
-        run.paths(&["compiler/rustc_codegen_gcc"])
+        run.path("compiler/rustc_codegen_gcc")
    }

    fn is_default_step(_builder: &Builder<'_>) -> bool {
--- a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_bench.snap
+++ b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_bench.snap
@ -98,4 +98,5 @@ expression: bench
    - Set({bench::compiler/rustc_windows_rc})
 [Bench] test::CrateRustdoc
    targets: [x86_64-unknown-linux-gnu]
-    - Set({bench::src/librustdoc, bench::src/tools/rustdoc})
+    - Set({bench::src/librustdoc})
+    - Set({bench::src/tools/rustdoc})
--- a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_check.snap
+++ b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_check.snap
@ -82,7 +82,8 @@ expression: check
    - Set({check::compiler/rustc_windows_rc})
 [Check] check::Rustdoc
    targets: [x86_64-unknown-linux-gnu]
-    - Set({check::src/librustdoc, check::src/tools/rustdoc})
+    - Set({check::src/librustdoc})
+    - Set({check::src/tools/rustdoc})
 [Check] check::CraneliftCodegenBackend
    targets: [x86_64-unknown-linux-gnu]
    - Set({check::cg_clif})
--- a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_check_compiletest_include_default_paths.snap
+++ b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_check_compiletest_include_default_paths.snap
@ -82,7 +82,8 @@ expression: check compiletest --include-default-paths
    - Set({check::compiler/rustc_windows_rc})
 [Check] check::Rustdoc
    targets: [x86_64-unknown-linux-gnu]
-    - Set({check::src/librustdoc, check::src/tools/rustdoc})
+    - Set({check::src/librustdoc})
+    - Set({check::src/tools/rustdoc})
 [Check] check::CraneliftCodegenBackend
    targets: [x86_64-unknown-linux-gnu]
    - Set({check::cg_clif})
--- a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_fix.snap
+++ b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_fix.snap
@ -82,7 +82,8 @@ expression: fix
    - Set({fix::compiler/rustc_windows_rc})
 [Fix] check::Rustdoc
    targets: [x86_64-unknown-linux-gnu]
-    - Set({fix::src/librustdoc, fix::src/tools/rustdoc})
+    - Set({fix::src/librustdoc})
+    - Set({fix::src/tools/rustdoc})
 [Fix] check::CraneliftCodegenBackend
    targets: [x86_64-unknown-linux-gnu]
    - Set({fix::cg_clif})
--- a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test.snap
+++ b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test.snap
@ -148,7 +148,8 @@ expression: test
    - Set({test::compiler/rustc_windows_rc})
 [Test] test::CrateRustdoc
    targets: [x86_64-unknown-linux-gnu]
-    - Set({test::src/librustdoc, test::src/tools/rustdoc})
+    - Set({test::src/librustdoc})
+    - Set({test::src/tools/rustdoc})
 [Test] test::CrateRustdocJsonTypes
    targets: [x86_64-unknown-linux-gnu]
    - Set({test::src/rustdoc-json-types})
--- a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_librustdoc_rustdoc.snap
+++ b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_librustdoc_rustdoc.snap
@ -4,7 +4,8 @@ expression: test librustdoc rustdoc
 ---
 [Test] test::CrateRustdoc
    targets: [x86_64-unknown-linux-gnu]
-    - Set({test::src/librustdoc, test::src/tools/rustdoc})
+    - Set({test::src/librustdoc})
+    - Set({test::src/tools/rustdoc})
 [Test] test::RustdocBook
    targets: [x86_64-unknown-linux-gnu]
    - Set({test::src/doc/rustdoc})
--- a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_skip_coverage.snap
+++ b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_skip_coverage.snap
@ -147,7 +147,8 @@ expression: test --skip=coverage
    - Set({test::compiler/rustc_windows_rc})
 [Test] test::CrateRustdoc
    targets: [x86_64-unknown-linux-gnu]
-    - Set({test::src/librustdoc, test::src/tools/rustdoc})
+    - Set({test::src/librustdoc})
+    - Set({test::src/tools/rustdoc})
 [Test] test::CrateRustdocJsonTypes
    targets: [x86_64-unknown-linux-gnu]
    - Set({test::src/rustdoc-json-types})
--- a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_skip_tests.snap
+++ b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_skip_tests.snap
@ -112,7 +112,8 @@ expression: test --skip=tests
    - Set({test::compiler/rustc_windows_rc})
 [Test] test::CrateRustdoc
    targets: [x86_64-unknown-linux-gnu]
-    - Set({test::src/librustdoc, test::src/tools/rustdoc})
+    - Set({test::src/librustdoc})
+    - Set({test::src/tools/rustdoc})
 [Test] test::CrateRustdocJsonTypes
    targets: [x86_64-unknown-linux-gnu]
    - Set({test::src/rustdoc-json-types})
--- a/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_skip_tests_etc.snap
+++ b/src/bootstrap/src/core/builder/cli_paths/snapshots/x_test_skip_tests_etc.snap
@ -92,7 +92,8 @@ expression: test --skip=tests --skip=coverage-map --skip=coverage-run --skip=lib
    - Set({test::compiler/rustc_windows_rc})
 [Test] test::CrateRustdoc
    targets: [x86_64-unknown-linux-gnu]
-    - Set({test::src/librustdoc, test::src/tools/rustdoc})
+    - Set({test::src/librustdoc})
+    - Set({test::src/tools/rustdoc})
 [Test] test::CrateRustdocJsonTypes
    targets: [x86_64-unknown-linux-gnu]
    - Set({test::src/rustdoc-json-types})
--- a/src/bootstrap/src/core/builder/mod.rs
+++ b/src/bootstrap/src/core/builder/mod.rs
@ -558,38 +558,19 @@ impl<'a> ShouldRun<'a> {
    /// single, non-aliased path
    ///
    /// Must be an on-disk path; use `alias` for names that do not correspond to on-disk paths.
-    pub fn path(self, path: &str) -> Self {
-        self.paths(&[path])
-    }
-
-    /// Multiple aliases for the same job.
-    ///
-    /// This differs from [`path`] in that multiple calls to path will end up calling `make_run`
-    /// multiple times, whereas a single call to `paths` will only ever generate a single call to
-    /// `make_run`.
-    ///
-    /// This is analogous to `all_krates`, although `all_krates` is gone now. Prefer [`path`] where possible.
-    ///
-    /// [`path`]: ShouldRun::path
-    pub fn paths(mut self, paths: &[&str]) -> Self {
+    pub fn path(mut self, path: &str) -> Self {
        let submodules_paths = self.builder.submodule_paths();

-        self.paths.insert(PathSet::Set(
-            paths
-                .iter()
-                .map(|p| {
-                    // assert only if `p` isn't submodule
-                    if !submodules_paths.iter().any(|sm_p| p.contains(sm_p)) {
-                        assert!(
-                            self.builder.src.join(p).exists(),
-                            "`should_run.paths` should correspond to real on-disk paths - use `alias` if there is no relevant path: {p}"
-                        );
-                    }
+        // assert only if `p` isn't submodule
+        if !submodules_paths.iter().any(|sm_p| path.contains(sm_p)) {
+            assert!(
+                self.builder.src.join(path).exists(),
+                "`should_run.path` should correspond to a real on-disk path - use `alias` if there is no relevant path: {path}"
+            );
+        }

-                    TaskPath { path: p.into(), kind: Some(self.kind) }
-                })
-                .collect(),
-        ));
+        let task = TaskPath { path: path.into(), kind: Some(self.kind) };
+        self.paths.insert(PathSet::Set(BTreeSet::from_iter([task])));
        self
    }

--- a/src/ci/citool/tests/jobs.rs
+++ b/src/ci/citool/tests/jobs.rs
@ -6,7 +6,7 @@ const TEST_JOBS_YML_PATH: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/tests/tes
 fn auto_jobs() {
    let stdout = get_matrix("push", "commit", "refs/heads/automation/bors/auto");
    insta::assert_snapshot!(stdout, @r#"
-    jobs=[{"name":"aarch64-gnu","full_name":"auto - aarch64-gnu","os":"ubuntu-22.04-arm","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","DEPLOY_BUCKET":"rust-lang-ci2","TOOLSTATE_PUBLISH":1},"free_disk":true},{"name":"x86_64-gnu-llvm-18-1","full_name":"auto - x86_64-gnu-llvm-18-1","os":"ubuntu-24.04","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","DEPLOY_BUCKET":"rust-lang-ci2","DOCKER_SCRIPT":"stage_2_test_set1.sh","IMAGE":"x86_64-gnu-llvm-18","READ_ONLY_SRC":"0","RUST_BACKTRACE":1,"TOOLSTATE_PUBLISH":1},"free_disk":true},{"name":"aarch64-apple","full_name":"auto - aarch64-apple","os":"macos-14","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","DEPLOY_BUCKET":"rust-lang-ci2","DEVELOPER_DIR":"/Applications/Xcode_15.4.app/Contents/Developer","MACOSX_DEPLOYMENT_TARGET":11.0,"MACOSX_STD_DEPLOYMENT_TARGET":11.0,"NO_DEBUG_ASSERTIONS":1,"NO_LLVM_ASSERTIONS":1,"NO_OVERFLOW_CHECKS":1,"RUSTC_RETRY_LINKER_ON_SEGFAULT":1,"RUST_CONFIGURE_ARGS":"--enable-sanitizers --enable-profiler --set rust.jemalloc","SCRIPT":"./x.py --stage 2 test --host=aarch64-apple-darwin --target=aarch64-apple-darwin","TOOLSTATE_PUBLISH":1,"USE_XCODE_CLANG":1}},{"name":"dist-i686-msvc","full_name":"auto - dist-i686-msvc","os":"windows-2022","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","CODEGEN_BACKENDS":"llvm,cranelift","DEPLOY_BUCKET":"rust-lang-ci2","DIST_REQUIRE_ALL_TOOLS":1,"RUST_CONFIGURE_ARGS":"--build=i686-pc-windows-msvc --host=i686-pc-windows-msvc --target=i686-pc-windows-msvc,i586-pc-windows-msvc --enable-full-tools --enable-profiler","SCRIPT":"python x.py dist bootstrap --include-default-paths","TOOLSTATE_PUBLISH":1}},{"name":"pr-check-1","full_name":"auto - pr-check-1","os":"ubuntu-24.04","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","DEPLOY_BUCKET":"rust-lang-ci2","TOOLSTATE_PUBLISH":1},"continue_on_error":false,"free_disk":true},{"name":"pr-check-2","full_name":"auto - pr-check-2","os":"ubuntu-24.04","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","DEPLOY_BUCKET":"rust-lang-ci2","TOOLSTATE_PUBLISH":1},"continue_on_error":false,"free_disk":true},{"name":"tidy","full_name":"auto - tidy","os":"ubuntu-24.04","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","DEPLOY_BUCKET":"rust-lang-ci2","TOOLSTATE_PUBLISH":1},"continue_on_error":false,"free_disk":true,"doc_url":"https://foo.bar"}]
+    jobs=[{"name":"aarch64-gnu","full_name":"auto - aarch64-gnu","os":"ubuntu-22.04-arm","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","DEPLOY_BUCKET":"rust-lang-ci2","TOOLSTATE_PUBLISH":1},"free_disk":true},{"name":"x86_64-gnu-llvm-18-1","full_name":"auto - x86_64-gnu-llvm-18-1","os":"ubuntu-24.04","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","DEPLOY_BUCKET":"rust-lang-ci2","DOCKER_SCRIPT":"stage_2_test_set1.sh","IMAGE":"x86_64-gnu-llvm-18","READ_ONLY_SRC":"0","RUST_BACKTRACE":1,"TOOLSTATE_PUBLISH":1},"free_disk":true},{"name":"aarch64-apple","full_name":"auto - aarch64-apple","os":"macos-14","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","DEPLOY_BUCKET":"rust-lang-ci2","DEVELOPER_DIR":"/Applications/Xcode_15.4.app/Contents/Developer","MACOSX_DEPLOYMENT_TARGET":11.0,"MACOSX_STD_DEPLOYMENT_TARGET":11.0,"NO_DEBUG_ASSERTIONS":1,"NO_LLVM_ASSERTIONS":1,"NO_OVERFLOW_CHECKS":1,"RUSTC_RETRY_LINKER_ON_SEGFAULT":1,"RUST_CONFIGURE_ARGS":"--enable-sanitizers --enable-profiler --set rust.jemalloc","SCRIPT":"./x.py --stage 2 test --host=aarch64-apple-darwin --target=aarch64-apple-darwin","TOOLSTATE_PUBLISH":1}},{"name":"dist-i686-msvc","full_name":"auto - dist-i686-msvc","os":"windows-2022","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","CODEGEN_BACKENDS":"llvm,cranelift","DEPLOY_BUCKET":"rust-lang-ci2","DIST_REQUIRE_ALL_TOOLS":1,"RUST_CONFIGURE_ARGS":"--build=i686-pc-windows-msvc --host=i686-pc-windows-msvc --target=i686-pc-windows-msvc,i586-pc-windows-msvc --enable-full-tools --enable-profiler","SCRIPT":"python x.py dist bootstrap --include-default-paths","TOOLSTATE_PUBLISH":1}},{"name":"pr-check-1","full_name":"auto - pr-check-1","os":"ubuntu-24.04","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","DEPLOY_BUCKET":"rust-lang-ci2","TOOLSTATE_PUBLISH":1},"continue_on_error":false,"free_disk":true},{"name":"pr-check-2","full_name":"auto - pr-check-2","os":"ubuntu-24.04","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","DEPLOY_BUCKET":"rust-lang-ci2","TOOLSTATE_PUBLISH":1},"continue_on_error":false,"free_disk":true},{"name":"tidy","full_name":"auto - tidy","os":"ubuntu-24.04","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","DEPLOY_BUCKET":"rust-lang-ci2","TOOLSTATE_PUBLISH":1},"continue_on_error":false,"free_disk":true,"doc_url":"https://foo.bar"}]
    run_type=auto
    "#);
 }
--- a/src/ci/citool/tests/test-jobs.yml
+++ b/src/ci/citool/tests/test-jobs.yml
@ -113,7 +113,6 @@ auto:
        --set rust.jemalloc
      RUSTC_RETRY_LINKER_ON_SEGFAULT: 1
      DEVELOPER_DIR: /Applications/Xcode_15.4.app/Contents/Developer
-      USE_XCODE_CLANG: 1
      # Aarch64 tooling only needs to support macOS 11.0 and up as nothing else
      # supports the hardware, so only need to test it there.
      MACOSX_DEPLOYMENT_TARGET: 11.0
--- a/src/ci/github-actions/jobs.yml
+++ b/src/ci/github-actions/jobs.yml
@ -460,7 +460,6 @@ auto:
      MACOSX_DEPLOYMENT_TARGET: 10.12
      MACOSX_STD_DEPLOYMENT_TARGET: 10.12
      DEVELOPER_DIR: /Applications/Xcode_15.4.app/Contents/Developer
-      USE_XCODE_CLANG: 1
      DIST_REQUIRE_ALL_TOOLS: 1
      CODEGEN_BACKENDS: llvm,cranelift
    <<: *job-macos
@ -497,7 +496,6 @@ auto:
      MACOSX_DEPLOYMENT_TARGET: 11.0
      MACOSX_STD_DEPLOYMENT_TARGET: 11.0
      DEVELOPER_DIR: /Applications/Xcode_15.4.app/Contents/Developer
-      USE_XCODE_CLANG: 1
      DIST_REQUIRE_ALL_TOOLS: 1
      CODEGEN_BACKENDS: llvm,cranelift
    <<: *job-macos
@ -512,7 +510,6 @@ auto:
        --enable-profiler
        --set rust.jemalloc
      DEVELOPER_DIR: /Applications/Xcode_15.4.app/Contents/Developer
-      USE_XCODE_CLANG: 1
      # Aarch64 tooling only needs to support macOS 11.0 and up as nothing else
      # supports the hardware, so only need to test it there.
      MACOSX_DEPLOYMENT_TARGET: 11.0
--- a/src/ci/scripts/install-clang.sh
+++ b/src/ci/scripts/install-clang.sh
@ -9,41 +9,11 @@ IFS=$'\n\t'

 source "$(cd "$(dirname "$0")" && pwd)/../shared.sh"

-# Update both macOS's and Windows's tarballs when bumping the version here.
+# Update Windows's tarballs when bumping the version here.
 # Try to keep this in sync with src/ci/docker/scripts/build-clang.sh
 LLVM_VERSION="20.1.3"

-if isMacOS; then
-    # FIXME: This is the latest pre-built version of LLVM that's available for
-    # x86_64 MacOS. We may want to consider building our own LLVM binaries
-    # instead, or set `USE_XCODE_CLANG` like AArch64 does.
-    LLVM_VERSION="15.0.7"
-
-    # If the job selects a specific Xcode version, use that instead of
-    # downloading our own version.
-    if [[ ${USE_XCODE_CLANG-0} -eq 1 ]]; then
-        bindir="$(xcode-select --print-path)/Toolchains/XcodeDefault.xctoolchain/usr/bin"
-    else
-        file="${MIRRORS_BASE}/clang%2Bllvm-${LLVM_VERSION}-x86_64-apple-darwin21.0.tar.xz"
-        retry curl -f "${file}" -o "clang+llvm-${LLVM_VERSION}-x86_64-apple-darwin21.0.tar.xz"
-        tar xJf "clang+llvm-${LLVM_VERSION}-x86_64-apple-darwin21.0.tar.xz"
-        bindir="$(pwd)/clang+llvm-${LLVM_VERSION}-x86_64-apple-darwin21.0/bin"
-    fi
-
-    ciCommandSetEnv CC "${bindir}/clang"
-    ciCommandSetEnv CXX "${bindir}/clang++"
-
-    # macOS 10.15 onwards doesn't have libraries in /usr/include anymore: those
-    # are now located deep into the filesystem, under Xcode's own files. The
-    # native clang is configured to use the correct path, but our custom one
-    # doesn't. This sets the SDKROOT environment variable to the SDK so that
-    # our own clang can figure out the correct include path on its own.
-    ciCommandSetEnv SDKROOT "$(xcrun --sdk macosx --show-sdk-path)"
-
-    # Configure `AR` specifically so bootstrap doesn't try to infer it as
-    # `clang-ar` by accident.
-    ciCommandSetEnv AR "ar"
-elif isWindows && ! isKnownToBeMingwBuild; then
+if isWindows && ! isKnownToBeMingwBuild; then
    # If we're compiling for MSVC then we, like most other distribution builders,
    # switch to clang as the compiler. This'll allow us eventually to enable LTO
    # amongst LLVM and rustc. Note that we only do this on MSVC as I don't think
--- a/tests/crashes/138089.rs
+++ b/tests/crashes/138089.rs
@ -1,16 +0,0 @@
-//@ known-bug: #138089
-//@ needs-rustc-debug-assertions
-
-#![feature(generic_const_exprs)]
-#![feature(min_generic_const_args)]
-#![feature(inherent_associated_types)]
-struct OnDiskDirEntry<'a> {}
-
-impl<'a> OnDiskDirEntry<'a> {
-    #[type_const]
-    const LFN_FRAGMENT_LEN: i64 = 2;
-
-    fn lfn_contents() -> [char; Self::LFN_FRAGMENT_LEN] {
-        loop {}
-    }
-}
--- a/tests/crashes/138226-2.rs
+++ b/tests/crashes/138226-2.rs
@ -1,13 +0,0 @@
-//@ known-bug: #138226
-//@ needs-rustc-debug-assertions
-#![feature(min_generic_const_args)]
-#![feature(inherent_associated_types)]
-struct Bar<const N: usize>;
-impl<const N: usize> Bar<N> {
-    #[type_const]
-    const LEN: usize = 4;
-
-    fn bar() {
-        let _ = [0; Self::LEN];
-    }
-}
--- a/tests/crashes/138226.rs
+++ b/tests/crashes/138226.rs
@ -1,13 +0,0 @@
-//@ known-bug: #138226
-//@ needs-rustc-debug-assertions
-#![feature(min_generic_const_args)]
-#![feature(inherent_associated_types)]
-struct Foo<A, B>(A, B);
-impl<A, B> Foo<A, B> {
-    #[type_const]
-    const LEN: usize = 4;
-
-    fn foo() {
-        let _ = [5; Self::LEN];
-    }
-}
--- a/tests/crashes/150960.rs
+++ b/tests/crashes/150960.rs
@ -1,11 +0,0 @@
-//@ known-bug: #150960
-#![feature(min_generic_const_args)]
-struct Baz;
-impl Baz {
-    #[type_const]
-    const LEN: usize = 4;
-
-    fn baz() {
-        let _ = [0; const { Self::LEN }];
-    }
-}
--- a/tests/ui/associated-consts/type-const-in-array-len-wrong-type.rs
+++ b/tests/ui/associated-consts/type-const-in-array-len-wrong-type.rs
@ -0,0 +1,20 @@
+#![feature(generic_const_exprs)]
+//~^ WARN the feature `generic_const_exprs` is incomplete
+#![feature(min_generic_const_args)]
+//~^ WARN the feature `min_generic_const_args` is incomplete
+#![feature(inherent_associated_types)]
+//~^ WARN the feature `inherent_associated_types` is incomplete
+
+struct OnDiskDirEntry<'a>(&'a ());
+
+impl<'a> OnDiskDirEntry<'a> {
+    #[type_const]
+    const LFN_FRAGMENT_LEN: i64 = 2;
+
+    fn lfn_contents() -> [char; Self::LFN_FRAGMENT_LEN] {
+        //~^ ERROR the constant `2` is not of type `usize`
+        loop {}
+    }
+}
+
+fn main() {}
--- a/tests/ui/associated-consts/type-const-in-array-len-wrong-type.stderr
+++ b/tests/ui/associated-consts/type-const-in-array-len-wrong-type.stderr
@ -0,0 +1,35 @@
+warning: the feature `generic_const_exprs` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/type-const-in-array-len-wrong-type.rs:1:12
+   |
+LL | #![feature(generic_const_exprs)]
+   |            ^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
+   = note: `#[warn(incomplete_features)]` on by default
+
+warning: the feature `min_generic_const_args` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/type-const-in-array-len-wrong-type.rs:3:12
+   |
+LL | #![feature(min_generic_const_args)]
+   |            ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #132980 <https://github.com/rust-lang/rust/issues/132980> for more information
+
+warning: the feature `inherent_associated_types` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/type-const-in-array-len-wrong-type.rs:5:12
+   |
+LL | #![feature(inherent_associated_types)]
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #8995 <https://github.com/rust-lang/rust/issues/8995> for more information
+
+error: the constant `2` is not of type `usize`
+  --> $DIR/type-const-in-array-len-wrong-type.rs:14:26
+   |
+LL |     fn lfn_contents() -> [char; Self::LFN_FRAGMENT_LEN] {
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `usize`, found `i64`
+   |
+   = note: the length of array `[char; 2]` must be type `usize`
+
+error: aborting due to 1 previous error; 3 warnings emitted
+
--- a/tests/ui/associated-consts/type-const-in-array-len.rs
+++ b/tests/ui/associated-consts/type-const-in-array-len.rs
@ -0,0 +1,41 @@
+//@ check-pass
+
+#![feature(min_generic_const_args)]
+//~^ WARN the feature `min_generic_const_args` is incomplete
+#![feature(inherent_associated_types)]
+//~^ WARN the feature `inherent_associated_types` is incomplete
+
+// Test case from #138226: generic impl with multiple type parameters
+struct Foo<A, B>(A, B);
+impl<A, B> Foo<A, B> {
+    #[type_const]
+    const LEN: usize = 4;
+
+    fn foo() {
+        let _ = [5; Self::LEN];
+    }
+}
+
+// Test case from #138226: generic impl with const parameter
+struct Bar<const N: usize>;
+impl<const N: usize> Bar<N> {
+    #[type_const]
+    const LEN: usize = 4;
+
+    fn bar() {
+        let _ = [0; Self::LEN];
+    }
+}
+
+// Test case from #150960: non-generic impl with const block
+struct Baz;
+impl Baz {
+    #[type_const]
+    const LEN: usize = 4;
+
+    fn baz() {
+        let _ = [0; { Self::LEN }];
+    }
+}
+
+fn main() {}
--- a/tests/ui/associated-consts/type-const-in-array-len.stderr
+++ b/tests/ui/associated-consts/type-const-in-array-len.stderr
@ -0,0 +1,19 @@
+warning: the feature `min_generic_const_args` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/type-const-in-array-len.rs:3:12
+   |
+LL | #![feature(min_generic_const_args)]
+   |            ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #132980 <https://github.com/rust-lang/rust/issues/132980> for more information
+   = note: `#[warn(incomplete_features)]` on by default
+
+warning: the feature `inherent_associated_types` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/type-const-in-array-len.rs:5:12
+   |
+LL | #![feature(inherent_associated_types)]
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #8995 <https://github.com/rust-lang/rust/issues/8995> for more information
+
+warning: 2 warnings emitted
+
--- a/tests/ui/associated-types/type-const-inherent-impl-normalize.rs
+++ b/tests/ui/associated-types/type-const-inherent-impl-normalize.rs
@ -0,0 +1,16 @@
+struct S<const N: usize>;
+impl<const N: usize> S<N> {
+    #[type_const]
+    //~^ ERROR: the `#[type_const]` attribute is an experimental feature
+    const LEN: usize = 1;
+    fn arr() {
+        [8; Self::LEN]
+        //~^ WARN: cannot use constants which depend on generic parameters in types
+        //~| WARN: this was previously accepted by the compiler but is being phased out
+        //~| WARN: cannot use constants which depend on generic parameters in types
+        //~| WARN: this was previously accepted by the compiler but is being phased out
+        //~| ERROR: mismatched types
+    }
+}
+
+pub fn main() {}
--- a/tests/ui/associated-types/type-const-inherent-impl-normalize.stderr
+++ b/tests/ui/associated-types/type-const-inherent-impl-normalize.stderr
@ -0,0 +1,42 @@
+error[E0658]: the `#[type_const]` attribute is an experimental feature
+  --> $DIR/type-const-inherent-impl-normalize.rs:3:5
+   |
+LL |     #[type_const]
+   |     ^^^^^^^^^^^^^
+   |
+   = note: see issue #132980 <https://github.com/rust-lang/rust/issues/132980> for more information
+   = help: add `#![feature(min_generic_const_args)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+warning: cannot use constants which depend on generic parameters in types
+  --> $DIR/type-const-inherent-impl-normalize.rs:7:13
+   |
+LL |         [8; Self::LEN]
+   |             ^^^^^^^^^
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #76200 <https://github.com/rust-lang/rust/issues/76200>
+   = note: `#[warn(const_evaluatable_unchecked)]` (part of `#[warn(future_incompatible)]`) on by default
+
+warning: cannot use constants which depend on generic parameters in types
+  --> $DIR/type-const-inherent-impl-normalize.rs:7:13
+   |
+LL |         [8; Self::LEN]
+   |             ^^^^^^^^^
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #76200 <https://github.com/rust-lang/rust/issues/76200>
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error[E0308]: mismatched types
+  --> $DIR/type-const-inherent-impl-normalize.rs:7:9
+   |
+LL |     fn arr() {
+   |             - help: try adding a return type: `-> [i32; 1]`
+LL |         [8; Self::LEN]
+   |         ^^^^^^^^^^^^^^ expected `()`, found `[{integer}; 1]`
+
+error: aborting due to 2 previous errors; 2 warnings emitted
+
+Some errors have detailed explanations: E0308, E0658.
+For more information about an error, try `rustc --explain E0308`.
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/return-via-stack.rs
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/return-via-stack.rs
@ -13,6 +13,9 @@ use minicore::*;
 #[repr(C)]
 pub struct ReprCU64(u64);

+#[repr(Rust)]
+pub struct ReprRustU64(u64);
+
 #[repr(C)]
 pub struct ReprCBytes(u8, u8, u8, u8, u8);

@ -25,10 +28,11 @@ pub struct ReprCAlign16(u16);
 #[no_mangle]
 pub fn test(
    f1: extern "cmse-nonsecure-call" fn() -> ReprCU64, //~ ERROR [E0798]
-    f2: extern "cmse-nonsecure-call" fn() -> ReprCBytes, //~ ERROR [E0798]
-    f3: extern "cmse-nonsecure-call" fn() -> U64Compound, //~ ERROR [E0798]
-    f4: extern "cmse-nonsecure-call" fn() -> ReprCAlign16, //~ ERROR [E0798]
-    f5: extern "cmse-nonsecure-call" fn() -> [u8; 5],  //~ ERROR [E0798]
+    f2: extern "cmse-nonsecure-call" fn() -> ReprRustU64, //~ ERROR [E0798]
+    f3: extern "cmse-nonsecure-call" fn() -> ReprCBytes, //~ ERROR [E0798]
+    f4: extern "cmse-nonsecure-call" fn() -> U64Compound, //~ ERROR [E0798]
+    f5: extern "cmse-nonsecure-call" fn() -> ReprCAlign16, //~ ERROR [E0798]
+    f6: extern "cmse-nonsecure-call" fn() -> [u8; 5],  //~ ERROR [E0798]
 ) {
 }

--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/return-via-stack.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/return-via-stack.stderr
@ -1,5 +1,5 @@
 error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/return-via-stack.rs:37:48
+  --> $DIR/return-via-stack.rs:41:48
   |
 LL |     u128: extern "cmse-nonsecure-call" fn() -> u128,
   |                                                ^^^^ this type doesn't fit in the available registers
@ -8,7 +8,7 @@ LL |     u128: extern "cmse-nonsecure-call" fn() -> u128,
   = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size

 error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/return-via-stack.rs:38:48
+  --> $DIR/return-via-stack.rs:42:48
   |
 LL |     i128: extern "cmse-nonsecure-call" fn() -> i128,
   |                                                ^^^^ this type doesn't fit in the available registers
@ -17,7 +17,7 @@ LL |     i128: extern "cmse-nonsecure-call" fn() -> i128,
   = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size

 error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/return-via-stack.rs:27:46
+  --> $DIR/return-via-stack.rs:30:46
   |
 LL |     f1: extern "cmse-nonsecure-call" fn() -> ReprCU64,
   |                                              ^^^^^^^^ this type doesn't fit in the available registers
@ -26,43 +26,52 @@ LL |     f1: extern "cmse-nonsecure-call" fn() -> ReprCU64,
   = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size

 error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/return-via-stack.rs:28:46
+  --> $DIR/return-via-stack.rs:31:46
   |
-LL |     f2: extern "cmse-nonsecure-call" fn() -> ReprCBytes,
-   |                                              ^^^^^^^^^^ this type doesn't fit in the available registers
-   |
-   = note: functions with the `"cmse-nonsecure-call"` ABI must pass their result via the available return registers
-   = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
-
-error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/return-via-stack.rs:29:46
-   |
-LL |     f3: extern "cmse-nonsecure-call" fn() -> U64Compound,
+LL |     f2: extern "cmse-nonsecure-call" fn() -> ReprRustU64,
   |                                              ^^^^^^^^^^^ this type doesn't fit in the available registers
   |
   = note: functions with the `"cmse-nonsecure-call"` ABI must pass their result via the available return registers
   = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size

 error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/return-via-stack.rs:30:46
+  --> $DIR/return-via-stack.rs:32:46
   |
-LL |     f4: extern "cmse-nonsecure-call" fn() -> ReprCAlign16,
+LL |     f3: extern "cmse-nonsecure-call" fn() -> ReprCBytes,
+   |                                              ^^^^^^^^^^ this type doesn't fit in the available registers
+   |
+   = note: functions with the `"cmse-nonsecure-call"` ABI must pass their result via the available return registers
+   = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
+
+error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
+  --> $DIR/return-via-stack.rs:33:46
+   |
+LL |     f4: extern "cmse-nonsecure-call" fn() -> U64Compound,
+   |                                              ^^^^^^^^^^^ this type doesn't fit in the available registers
+   |
+   = note: functions with the `"cmse-nonsecure-call"` ABI must pass their result via the available return registers
+   = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
+
+error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
+  --> $DIR/return-via-stack.rs:34:46
+   |
+LL |     f5: extern "cmse-nonsecure-call" fn() -> ReprCAlign16,
   |                                              ^^^^^^^^^^^^ this type doesn't fit in the available registers
   |
   = note: functions with the `"cmse-nonsecure-call"` ABI must pass their result via the available return registers
   = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size

 error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/return-via-stack.rs:31:46
+  --> $DIR/return-via-stack.rs:35:46
   |
-LL |     f5: extern "cmse-nonsecure-call" fn() -> [u8; 5],
+LL |     f6: extern "cmse-nonsecure-call" fn() -> [u8; 5],
   |                                              ^^^^^^^ this type doesn't fit in the available registers
   |
   = note: functions with the `"cmse-nonsecure-call"` ABI must pass their result via the available return registers
   = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size

 error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/return-via-stack.rs:53:46
+  --> $DIR/return-via-stack.rs:57:46
   |
 LL |     f1: extern "cmse-nonsecure-call" fn() -> ReprRustUnionU64,
   |                                              ^^^^^^^^^^^^^^^^ this type doesn't fit in the available registers
@ -71,7 +80,7 @@ LL |     f1: extern "cmse-nonsecure-call" fn() -> ReprRustUnionU64,
   = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size

 error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/return-via-stack.rs:54:46
+  --> $DIR/return-via-stack.rs:58:46
   |
 LL |     f2: extern "cmse-nonsecure-call" fn() -> ReprCUnionU64,
   |                                              ^^^^^^^^^^^^^ this type doesn't fit in the available registers
@ -79,6 +88,6 @@ LL |     f2: extern "cmse-nonsecure-call" fn() -> ReprCUnionU64,
   = note: functions with the `"cmse-nonsecure-call"` ABI must pass their result via the available return registers
   = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size

-error: aborting due to 9 previous errors
+error: aborting due to 10 previous errors

 For more information about this error, try `rustc --explain E0798`.
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/params-via-stack.rs
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/params-via-stack.rs
@ -24,3 +24,24 @@ pub extern "cmse-nonsecure-entry" fn f4(_: AlignRelevant, _: u32) {} //~ ERROR [
 #[no_mangle]
 #[allow(improper_ctypes_definitions)]
 pub extern "cmse-nonsecure-entry" fn f5(_: [u32; 5]) {} //~ ERROR [E0798]
+
+struct Four {
+    a: u32,
+    b: u32,
+    c: u32,
+    d: u32,
+}
+
+struct Five {
+    a: u32,
+    b: u32,
+    c: u32,
+    d: u32,
+    e: u32,
+}
+
+#[no_mangle]
+pub extern "cmse-nonsecure-entry" fn four(_: Four) {}
+
+#[no_mangle]
+pub extern "cmse-nonsecure-entry" fn five(_: Five) {} //~ ERROR [E0798]
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/params-via-stack.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/params-via-stack.stderr
@ -40,6 +40,14 @@ LL | pub extern "cmse-nonsecure-entry" fn f5(_: [u32; 5]) {}
   |
   = note: functions with the `"cmse-nonsecure-entry"` ABI must pass all their arguments via the 4 32-bit argument registers

-error: aborting due to 5 previous errors
+error[E0798]: arguments for `"cmse-nonsecure-entry"` function too large to pass via registers
+  --> $DIR/params-via-stack.rs:47:46
+   |
+LL | pub extern "cmse-nonsecure-entry" fn five(_: Five) {}
+   |                                              ^^^^ does not fit in the available registers
+   |
+   = note: functions with the `"cmse-nonsecure-entry"` ABI must pass all their arguments via the 4 32-bit argument registers
+
+error: aborting due to 6 previous errors

 For more information about this error, try `rustc --explain E0798`.
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/via-registers.rs
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/via-registers.rs
@ -40,9 +40,15 @@ pub extern "cmse-nonsecure-entry" fn inputs5(_: f64, _: f32, _: f32) {}
 #[no_mangle]
 pub extern "cmse-nonsecure-entry" fn inputs6(_: ReprTransparentStruct<u64>, _: U32Compound) {}
 #[no_mangle]
-#[allow(improper_ctypes_definitions)]
+#[expect(improper_ctypes_definitions)]
 pub extern "cmse-nonsecure-entry" fn inputs7(_: [u32; 4]) {}

+// With zero-sized types we can actually have more than 4 arguments.
+#[expect(improper_ctypes_definitions)]
+pub extern "cmse-nonsecure-entry" fn inputs8(_: (), _: (), _: (), _: (), _: ()) {}
+#[expect(improper_ctypes_definitions)]
+pub extern "cmse-nonsecure-entry" fn inputs9(_: (), _: (), _: (), _: (), _: ()) {}
+
 #[no_mangle]
 pub extern "cmse-nonsecure-entry" fn outputs1() -> u32 {
    0
@ -69,8 +75,8 @@ pub extern "cmse-nonsecure-entry" fn outputs6() -> ReprTransparentStruct<u64> {
    ReprTransparentStruct { _marker1: (), _marker2: (), field: 0xAA, _marker3: () }
 }
 #[no_mangle]
-pub extern "cmse-nonsecure-entry" fn outputs7(
-) -> ReprTransparentStruct<ReprTransparentStruct<u64>> {
+pub extern "cmse-nonsecure-entry" fn outputs7() -> ReprTransparentStruct<ReprTransparentStruct<u64>>
+{
    ReprTransparentStruct {
        _marker1: (),
        _marker2: (),
--- a/triagebot.toml
+++ b/triagebot.toml
@ -1467,6 +1467,7 @@ compiler = [
    "@oli-obk",
    "@petrochenkov",
    "@SparrowLii",
+    "@TaKO8Ki",
    "@tiif",
    "@WaffleLapkin",
    "@wesleywiser",
@ -1513,6 +1514,7 @@ diagnostics = [
    "@davidtwco",
    "@oli-obk",
    "@chenyukang",
+    "@TaKO8Ki"
 ]
 parser = [
    "@davidtwco",