Rollup of 14 pull requests

.mailmap

@@ -64,6 +64,7 @@ Arthur Cohen <arthur.cohen@epita.fr>
 Arthur Silva <arthurprs@gmail.com>
 Arthur Woimbée <arthur.woimbee@gmail.com>
 Artyom Pavlov <newpavlov@gmail.com>
+Austin K. <akiekintveld@icloud.com>
 Austin Seipp <mad.one@gmail.com> <as@hacks.yi.org>
 Ayaz Hafiz <ayaz.hafiz.1@gmail.com>
 Aydin Kim <ladinjin@hanmail.net> aydin.kim <aydin.kim@samsung.com>

Cargo.lock

@@ -3493,9 +3493,9 @@ dependencies = [
 
 [[package]]
 name = "rustc-build-sysroot"
-version = "0.5.13"
+version = "0.5.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "569d545953ee9a1ab9d3e9112e961739ff0cfd50bce06b126937395940be69c9"
+checksum = "0d0ed7817483b026efc0492f4ccca177f00fb711537f37943cc412bbf12682b4"
 dependencies = [
  "anyhow",
  "rustc_version",

compiler/rustc_const_eval/src/const_eval/machine.rs

@@ -608,7 +608,7 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
                 }
             }
 
-            sym::type_of => {
+            sym::type_id_type_of => {
                 let ty = ecx.read_type_id(&args[0])?;
                 ecx.write_type_info(ty, dest)?;
             }
@@ -627,7 +627,7 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
                 ecx.write_scalar(Scalar::from_bool(is_mutable), dest)?;
             }
 
-            sym::size_of_type_id => {
+            sym::type_id_size_of => {
                 let ty = ecx.read_type_id(&args[0])?;
                 let layout = ecx.layout_of(ty)?;
                 let variant_index = if layout.is_sized() {
@@ -764,7 +764,7 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
                 ecx.write_scalar(Scalar::from_target_usize(variants_num as u64, ecx), dest)?;
             }
 
-            sym::variant_name => {
+            sym::type_id_variant_name => {
                 let base = ecx.read_type_id(&args[0])?;
 
                 let field_name = if let ty::Adt(def, _) = base.kind() {
@@ -790,7 +790,7 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
                 )?;
             }
 
-            sym::variant_non_exhaustive => {
+            sym::type_id_variant_non_exhaustive => {
                 let base = ecx.read_type_id(&args[0])?;
 
                 let non_exhaustive = if let ty::Adt(def, _) = base.kind() {
@@ -890,7 +890,7 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
                 ecx.write_type_id_generics(dest, ty)?;
             }
 
-            sym::non_exhaustive => {
+            sym::type_id_non_exhaustive => {
                 let ty = ecx.read_type_id(&args[0])?;
 
                 // FIXME(reflection): need a way to obtain non-exhaustiveness of a variant's fields.

compiler/rustc_const_eval/src/const_eval/type_info/adt.rs

@@ -126,7 +126,7 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
 
             match field.name {
                 sym::generics => self.write_generics(&field_place, generics)?,
-                sym::variants => {
+                sym::type_id_variants => {
                     self.allocate_fill_and_write_slice_ptr(
                         &field_place,
                         enum_def.variants().len() as u64,

compiler/rustc_driver_impl/src/lib.rs

@@ -169,7 +169,7 @@ impl Callbacks for TimePassesCallbacks {
 }
 
 /// This is the primary entry point for rustc.
-pub fn run_compiler(at_args: &[String], callbacks: &mut (dyn Callbacks + Send)) {
+pub fn compiler_entrypoint(at_args: &[String], callbacks: &mut (dyn Callbacks + Send)) {
     let mut default_early_dcx = EarlyDiagCtxt::new(ErrorOutputType::default());
 
     // Throw away the first argument, the name of the binary.
@@ -1386,7 +1386,7 @@ static ICE_PATH: OnceLock<Option<PathBuf>> = OnceLock::new();
 
 // This function should only be called from the ICE hook.
 //
-// The intended behavior is that `run_compiler` will invoke `ice_path_with_config` early in the
+// The intended behavior is that `compiler_entrypoint` will invoke `ice_path_with_config` early in the
 // initialization process to properly initialize the ICE_PATH static based on parsed CLI flags.
 //
 // Subsequent calls to either function will then return the proper ICE path as configured by
@@ -1674,7 +1674,7 @@ pub fn main() -> ExitCode {
     install_ctrlc_handler();
 
     let exit_code =
-        catch_with_exit_code(|| run_compiler(&args::raw_args(&early_dcx), &mut callbacks));
+        catch_with_exit_code(|| compiler_entrypoint(&args::raw_args(&early_dcx), &mut callbacks));
 
     if let Some(format) = callbacks.time_passes {
         let end_rss = get_resident_set_size();

compiler/rustc_hir_analysis/src/check/intrinsic.rs

@@ -151,7 +151,6 @@ fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -> hi
         | sym::minimumf128
         | sym::mul_with_overflow
         | sym::needs_drop
-        | sym::non_exhaustive
         | sym::offload
         | sym::offload_get_num_devices
         | sym::offset_of
@@ -208,17 +207,19 @@ fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -> hi
         | sym::type_id_function_ptr
         | sym::type_id_generics
         | sym::type_id_is_signed
+        | sym::type_id_non_exhaustive
         | sym::type_id_points_mutably
         | sym::type_id_points_to
+        | sym::type_id_size_of
+        | sym::type_id_type_of
+        | sym::type_id_variant_name
+        | sym::type_id_variant_non_exhaustive
         | sym::type_id_variants
         | sym::type_id_vtable
         | sym::type_name
-        | sym::type_of
         | sym::ub_checks
         | sym::va_copy
         | sym::variant_count
-        | sym::variant_name
-        | sym::variant_non_exhaustive
         | sym::wrapping_add
         | sym::wrapping_mul
         | sym::wrapping_sub
@@ -297,7 +298,7 @@ pub(crate) fn check_intrinsic_type(
         sym::size_of_val | sym::align_of_val => {
             (1, 0, vec![Ty::new_imm_ptr(tcx, param(0))], tcx.types.usize)
         }
-        sym::size_of_type_id => (0, 0, vec![type_id_ty()], Ty::new_option(tcx, tcx.types.usize)),
+        sym::type_id_size_of => (0, 0, vec![type_id_ty()], Ty::new_option(tcx, tcx.types.usize)),
         sym::offset_of => (1, 0, vec![tcx.types.u32, tcx.types.u32], tcx.types.usize),
         sym::field_offset => (1, 0, vec![], tcx.types.usize),
         sym::rustc_peek => (1, 0, vec![param(0)], param(0)),
@@ -340,8 +341,12 @@ pub(crate) fn check_intrinsic_type(
         sym::type_id_points_mutably => (0, 0, vec![type_id_ty()], tcx.types.bool),
         sym::type_id_points_to => (0, 0, vec![type_id_ty()], Ty::new_option(tcx, type_id_ty())),
         sym::type_id_variants => (0, 0, vec![type_id_ty()], tcx.types.usize),
-        sym::variant_name => (0, 0, vec![type_id_ty(), tcx.types.usize], Ty::new_static_str(tcx)),
-        sym::variant_non_exhaustive => (0, 0, vec![type_id_ty(), tcx.types.usize], tcx.types.bool),
+        sym::type_id_variant_name => {
+            (0, 0, vec![type_id_ty(), tcx.types.usize], Ty::new_static_str(tcx))
+        }
+        sym::type_id_variant_non_exhaustive => {
+            (0, 0, vec![type_id_ty(), tcx.types.usize], tcx.types.bool)
+        }
         sym::type_id_vtable => {
             let dyn_metadata = tcx.require_lang_item(LangItem::DynMetadata, span);
             let dyn_metadata_adt_ref = tcx.adt_def(dyn_metadata);
@@ -356,7 +361,7 @@ pub(crate) fn check_intrinsic_type(
 
             (0, 0, vec![type_id_ty(); 2], ret_ty)
         }
-        sym::type_of => (
+        sym::type_id_type_of => (
             0,
             0,
             vec![type_id_ty()],
@@ -365,7 +370,7 @@ pub(crate) fn check_intrinsic_type(
         sym::field_representing_type_actual_type_id => (0, 0, vec![type_id_ty()], type_id_ty()),
         sym::field_representing_type_name => (0, 0, vec![type_id_ty()], Ty::new_static_str(tcx)),
         sym::field_representing_type_offset => (0, 0, vec![type_id_ty()], tcx.types.usize),
-        sym::non_exhaustive => (0, 0, vec![type_id_ty()], tcx.types.bool),
+        sym::type_id_non_exhaustive => (0, 0, vec![type_id_ty()], tcx.types.bool),
         sym::type_id_generics => (
             0,
             0,

compiler/rustc_public/src/rustc_internal/mod.rs

@@ -168,7 +168,7 @@ macro_rules! optional {
 #[doc(hidden)]
 macro_rules! run_driver {
     ($args:expr, $callback:expr $(, $with_tcx:ident)?) => {{
-        use rustc_driver::{Callbacks, Compilation, run_compiler};
+        use rustc_driver::{Callbacks, Compilation, compiler_entrypoint};
         use rustc_middle::ty::TyCtxt;
         use rustc_interface::interface;
         use rustc_public::rustc_internal;
@@ -199,7 +199,7 @@ macro_rules! run_driver {
             /// Runs the compiler against given target and tests it with `test_function`
             pub fn run(&mut self, args: &[String]) -> Result<C, CompilerError<B>> {
                 let compiler_result = rustc_driver::catch_fatal_errors(|| -> interface::Result::<()> {
-                    run_compiler(&args, self);
+                    compiler_entrypoint(&args, self);
                     Ok(())
                 });
                 match (compiler_result, self.result.take()) {

compiler/rustc_resolve/src/late.rs

@@ -2861,12 +2861,14 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
     }
 
     fn resolve_item(&mut self, item: &'ast Item) {
+        let mut mod_inner_attrs_start = None;
         match item.kind {
             ItemKind::Mod(..) => {
                 // We only handle outer doc comments for modules here.
                 let attrs = if let Some(pos) = item.attrs.iter().position(|a| {
                     a.doc_resolution_scope().is_some_and(|style| style == AttrStyle::Inner)
                 }) {
+                    mod_inner_attrs_start = Some(pos);
                     &item.attrs[..pos]
                 } else {
                     &item.attrs
@@ -2972,9 +2974,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                     this.with_rib(TypeNS, RibKind::Module(module.expect_local()), |this| {
                         // Outer doc comments were already handled above, now we handle
                         // inner doc comments.
-                        let attrs = if let Some(pos) = item.attrs.iter().position(|a| {
-                            a.doc_resolution_scope().is_some_and(|style| style == AttrStyle::Inner)
-                        }) {
+                        let attrs = if let Some(pos) = mod_inner_attrs_start {
                             &item.attrs[pos..]
                         } else {
                             &[]