Rename GlobalAlloc::Type to TypeId

oli-obk · oli-obk · commit d48376462a12 · 2025-07-04T12:54:34.000Z
diff --git a/compiler/rustc_codegen_cranelift/src/constant.rs b/compiler/rustc_codegen_cranelift/src/constant.rs
@@ -175,7 +175,7 @@ pub(crate) fn codegen_const_value<'tcx>(
                             fx.module.declare_data_in_func(data_id, &mut fx.bcx.func);
                         fx.bcx.ins().global_value(fx.pointer_type, local_data_id)
                     }
-                    GlobalAlloc::Type { .. } => {
+                    GlobalAlloc::TypeId { .. } => {
                         return CValue::const_val(
                             fx,
                             layout,
@@ -367,7 +367,7 @@ fn define_all_allocs(tcx: TyCtxt<'_>, module: &mut dyn Module, cx: &mut Constant
                     GlobalAlloc::Memory(alloc) => alloc,
                     GlobalAlloc::Function { .. }
                     | GlobalAlloc::Static(_)
-                    | GlobalAlloc::Type { .. }
+                    | GlobalAlloc::TypeId { .. }
                     | GlobalAlloc::VTable(..) => {
                         unreachable!()
                     }
@@ -479,7 +479,7 @@ fn define_all_allocs(tcx: TyCtxt<'_>, module: &mut dyn Module, cx: &mut Constant
                         .principal()
                         .map(|principal| tcx.instantiate_bound_regions_with_erased(principal)),
                 ),
-                GlobalAlloc::Type { .. } => {
+                GlobalAlloc::TypeId { .. } => {
                     // Nothing to do, the bytes/offset of this pointer have already been written together with all other bytes,
                     // so we just need to drop this provenance.
                     continue;
diff --git a/compiler/rustc_codegen_gcc/src/common.rs b/compiler/rustc_codegen_gcc/src/common.rs
@@ -281,7 +281,7 @@ impl<'gcc, 'tcx> ConstCodegenMethods for CodegenCx<'gcc, 'tcx> {
                         let init = self.const_data_from_alloc(alloc);
                         self.static_addr_of(init, alloc.inner().align, None)
                     }
-                    GlobalAlloc::Type { .. } => {
+                    GlobalAlloc::TypeId { .. } => {
                         let val = self.const_usize(offset.bytes());
                         return self.context.new_cast(None, val, ty);
                     }
diff --git a/compiler/rustc_codegen_llvm/src/common.rs b/compiler/rustc_codegen_llvm/src/common.rs
@@ -324,7 +324,7 @@ impl<'ll, 'tcx> ConstCodegenMethods for CodegenCx<'ll, 'tcx> {
                         assert!(!self.tcx.is_thread_local_static(def_id));
                         self.get_static(def_id)
                     }
-                    GlobalAlloc::Type { .. } => {
+                    GlobalAlloc::TypeId { .. } => {
                         // Drop the provenance, the offset contains the bytes of the hash
                         let llval = self.const_usize(offset.bytes());
                         return unsafe { llvm::LLVMConstIntToPtr(llval, llty) };
diff --git a/compiler/rustc_const_eval/src/interpret/memory.rs b/compiler/rustc_const_eval/src/interpret/memory.rs
@@ -346,7 +346,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                         kind = "vtable",
                     )
                 }
-                Some(GlobalAlloc::Type { .. }) => {
+                Some(GlobalAlloc::TypeId { .. }) => {
                     err_ub_custom!(
                         fluent::const_eval_invalid_dealloc,
                         alloc_id = alloc_id,
@@ -622,7 +622,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             }
             Some(GlobalAlloc::Function { .. }) => throw_ub!(DerefFunctionPointer(id)),
             Some(GlobalAlloc::VTable(..)) => throw_ub!(DerefVTablePointer(id)),
-            Some(GlobalAlloc::Type { .. }) => throw_ub!(DerefTypeIdPointer(id)),
+            Some(GlobalAlloc::TypeId { .. }) => throw_ub!(DerefTypeIdPointer(id)),
             None => throw_ub!(PointerUseAfterFree(id, CheckInAllocMsg::MemoryAccess)),
             Some(GlobalAlloc::Static(def_id)) => {
                 assert!(self.tcx.is_static(def_id));
@@ -904,7 +904,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             let (size, align) = global_alloc.size_and_align(*self.tcx, self.typing_env);
             let mutbl = global_alloc.mutability(*self.tcx, self.typing_env);
             let kind = match global_alloc {
-                GlobalAlloc::Type { .. }
+                GlobalAlloc::TypeId { .. }
                 | GlobalAlloc::Static { .. }
                 | GlobalAlloc::Memory { .. } => AllocKind::LiveData,
                 GlobalAlloc::Function { .. } => bug!("We already checked function pointers above"),
@@ -953,7 +953,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         ptr: Pointer<Option<M::Provenance>>,
     ) -> InterpResult<'tcx, (Ty<'tcx>, Size)> {
         let (alloc_id, offset, _meta) = self.ptr_get_alloc_id(ptr, 0)?;
-        let GlobalAlloc::Type { ty } = self.tcx.global_alloc(alloc_id) else {
+        let GlobalAlloc::TypeId { ty } = self.tcx.global_alloc(alloc_id) else {
             throw_ub_format!("type_id_eq: `TypeId` provenance is not a type id")
         };
         interp_ok((ty, offset))
@@ -1220,7 +1220,7 @@ impl<'a, 'tcx, M: Machine<'tcx>> std::fmt::Debug for DumpAllocs<'a, 'tcx, M> {
                         Some(GlobalAlloc::VTable(ty, dyn_ty)) => {
                             write!(fmt, " (vtable: impl {dyn_ty} for {ty})")?;
                         }
-                        Some(GlobalAlloc::Type { ty }) => {
+                        Some(GlobalAlloc::TypeId { ty }) => {
                             write!(fmt, " (typeid for {ty})")?;
                         }
                         Some(GlobalAlloc::Static(did)) => {
diff --git a/compiler/rustc_middle/src/mir/interpret/mod.rs b/compiler/rustc_middle/src/mir/interpret/mod.rs
@@ -128,7 +128,7 @@ pub fn specialized_encode_alloc_id<'tcx, E: TyEncoder<'tcx>>(
             ty.encode(encoder);
             poly_trait_ref.encode(encoder);
         }
-        GlobalAlloc::Type { ty } => {
+        GlobalAlloc::TypeId { ty } => {
             trace!("encoding {alloc_id:?} with {ty:#?}");
             AllocDiscriminant::Type.encode(encoder);
             ty.encode(encoder);
@@ -272,7 +272,7 @@ pub enum GlobalAlloc<'tcx> {
     Memory(ConstAllocation<'tcx>),
     /// The first pointer-sized segment of a type id. On 64 bit systems, the 128 bit type id
     /// is split into two segments, on 32 bit systems there are 4 segments, and so on.
-    Type { ty: Ty<'tcx> },
+    TypeId { ty: Ty<'tcx> },
 }
 
 impl<'tcx> GlobalAlloc<'tcx> {
@@ -311,7 +311,7 @@ impl<'tcx> GlobalAlloc<'tcx> {
     pub fn address_space(&self, cx: &impl HasDataLayout) -> AddressSpace {
         match self {
             GlobalAlloc::Function { .. } => cx.data_layout().instruction_address_space,
-            GlobalAlloc::Type { .. }
+            GlobalAlloc::TypeId { .. }
             | GlobalAlloc::Static(..)
             | GlobalAlloc::Memory(..)
             | GlobalAlloc::VTable(..) => AddressSpace::DATA,
@@ -350,7 +350,7 @@ impl<'tcx> GlobalAlloc<'tcx> {
                 }
             }
             GlobalAlloc::Memory(alloc) => alloc.inner().mutability,
-            GlobalAlloc::Type { .. } | GlobalAlloc::Function { .. } | GlobalAlloc::VTable(..) => {
+            GlobalAlloc::TypeId { .. } | GlobalAlloc::Function { .. } | GlobalAlloc::VTable(..) => {
                 // These are immutable.
                 Mutability::Not
             }
@@ -399,7 +399,7 @@ impl<'tcx> GlobalAlloc<'tcx> {
                 (Size::ZERO, tcx.data_layout.pointer_align.abi)
             }
             // Fake allocation, there's nothing to access here
-            GlobalAlloc::Type { .. } => (Size::ZERO, Align::ONE),
+            GlobalAlloc::TypeId { .. } => (Size::ZERO, Align::ONE),
         }
     }
 }
@@ -507,7 +507,7 @@ impl<'tcx> TyCtxt<'tcx> {
 
     /// Generates an [AllocId] for a [core::any::TypeId]. Will get deduplicated.
     pub fn reserve_and_set_type_id_alloc(self, ty: Ty<'tcx>) -> AllocId {
-        self.reserve_and_set_dedup(GlobalAlloc::Type { ty }, 0)
+        self.reserve_and_set_dedup(GlobalAlloc::TypeId { ty }, 0)
     }
 
     /// Interns the `Allocation` and return a new `AllocId`, even if there's already an identical
diff --git a/compiler/rustc_middle/src/mir/pretty.rs b/compiler/rustc_middle/src/mir/pretty.rs
@@ -1621,7 +1621,7 @@ pub fn write_allocations<'tcx>(
             Some(GlobalAlloc::VTable(ty, dyn_ty)) => {
                 write!(w, " (vtable: impl {dyn_ty} for {ty})")?
             }
-            Some(GlobalAlloc::Type { ty }) => write!(w, " (typeid for {ty})")?,
+            Some(GlobalAlloc::TypeId { ty }) => write!(w, " (typeid for {ty})")?,
             Some(GlobalAlloc::Static(did)) if !tcx.is_foreign_item(did) => {
                 write!(w, " (static: {}", tcx.def_path_str(did))?;
                 if body.phase <= MirPhase::Runtime(RuntimePhase::PostCleanup)
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -1779,7 +1779,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
                         }
                         Some(GlobalAlloc::Function { .. }) => p!("<function>"),
                         Some(GlobalAlloc::VTable(..)) => p!("<vtable>"),
-                        Some(GlobalAlloc::Type { .. }) => p!("<typeid>"),
+                        Some(GlobalAlloc::TypeId { .. }) => p!("<typeid>"),
                         None => p!("<dangling pointer>"),
                     }
                     return Ok(());
diff --git a/compiler/rustc_monomorphize/src/collector.rs b/compiler/rustc_monomorphize/src/collector.rs
@@ -1219,7 +1219,7 @@ fn collect_alloc<'tcx>(tcx: TyCtxt<'tcx>, alloc_id: AllocId, output: &mut MonoIt
             ));
             collect_alloc(tcx, alloc_id, output)
         }
-        GlobalAlloc::Type { .. } => {}
+        GlobalAlloc::TypeId { .. } => {}
     }
 }
 
diff --git a/compiler/rustc_passes/src/reachable.rs b/compiler/rustc_passes/src/reachable.rs
@@ -325,7 +325,7 @@ impl<'tcx> ReachableContext<'tcx> {
                         self.visit(args);
                     }
                 }
-                GlobalAlloc::Type { ty, .. } => self.visit(ty),
+                GlobalAlloc::TypeId { ty, .. } => self.visit(ty),
                 GlobalAlloc::Memory(alloc) => self.propagate_from_alloc(alloc),
             }
         }
diff --git a/compiler/rustc_smir/src/rustc_smir/convert/mir.rs b/compiler/rustc_smir/src/rustc_smir/convert/mir.rs
@@ -753,7 +753,7 @@ impl<'tcx> Stable<'tcx> for mir::interpret::GlobalAlloc<'tcx> {
                 GlobalAlloc::Static(tables.static_def(*def))
             }
             mir::interpret::GlobalAlloc::Memory(alloc) => GlobalAlloc::Memory(alloc.stable(tables)),
-            mir::interpret::GlobalAlloc::Type { .. } => todo!(),
+            mir::interpret::GlobalAlloc::TypeId { .. } => todo!(),
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -281,7 +281,7 @@ impl<'gcc, 'tcx> ConstCodegenMethods for CodegenCx<'gcc, 'tcx> {`
`281`	`281`	`let init = self.const_data_from_alloc(alloc);`
`282`	`282`	`self.static_addr_of(init, alloc.inner().align, None)`
`283`	`283`	`}`
`284`		`- GlobalAlloc::Type { .. } => {`
	`284`	`+ GlobalAlloc::TypeId { .. } => {`
`285`	`285`	`let val = self.const_usize(offset.bytes());`
`286`	`286`	`return self.context.new_cast(None, val, ty);`
`287`	`287`	`}`
Original file line number	Diff line number	Diff line change
`@@ -324,7 +324,7 @@ impl<'ll, 'tcx> ConstCodegenMethods for CodegenCx<'ll, 'tcx> {`
`324`	`324`	`assert!(!self.tcx.is_thread_local_static(def_id));`
`325`	`325`	`self.get_static(def_id)`
`326`	`326`	`}`
`327`		`- GlobalAlloc::Type { .. } => {`
	`327`	`+ GlobalAlloc::TypeId { .. } => {`
`328`	`328`	`// Drop the provenance, the offset contains the bytes of the hash`
`329`	`329`	`let llval = self.const_usize(offset.bytes());`
`330`	`330`	`return unsafe { llvm::LLVMConstIntToPtr(llval, llty) };`
Original file line number	Diff line number	Diff line change
`@@ -128,7 +128,7 @@ pub fn specialized_encode_alloc_id<'tcx, E: TyEncoder<'tcx>>(`
`128`	`128`	`ty.encode(encoder);`
`129`	`129`	`poly_trait_ref.encode(encoder);`
`130`	`130`	`}`
`131`		`- GlobalAlloc::Type { ty } => {`
	`131`	`+ GlobalAlloc::TypeId { ty } => {`
`132`	`132`	`trace!("encoding {alloc_id:?} with {ty:#?}");`
`133`	`133`	`AllocDiscriminant::Type.encode(encoder);`
`134`	`134`	`ty.encode(encoder);`
`@@ -272,7 +272,7 @@ pub enum GlobalAlloc<'tcx> {`
`272`	`272`	`Memory(ConstAllocation<'tcx>),`
`273`	`273`	`/// The first pointer-sized segment of a type id. On 64 bit systems, the 128 bit type id`
`274`	`274`	`/// is split into two segments, on 32 bit systems there are 4 segments, and so on.`
`275`		`- Type { ty: Ty<'tcx> },`
	`275`	`+ TypeId { ty: Ty<'tcx> },`
`276`	`276`	`}`
`277`	`277`
`278`	`278`	`impl<'tcx> GlobalAlloc<'tcx> {`
`@@ -311,7 +311,7 @@ impl<'tcx> GlobalAlloc<'tcx> {`
`311`	`311`	`pub fn address_space(&self, cx: &impl HasDataLayout) -> AddressSpace {`
`312`	`312`	`match self {`
`313`	`313`	`GlobalAlloc::Function { .. } => cx.data_layout().instruction_address_space,`
`314`		`- GlobalAlloc::Type { .. }`
	`314`	`+ GlobalAlloc::TypeId { .. }`
`315`	`315`	`\| GlobalAlloc::Static(..)`
`316`	`316`	`\| GlobalAlloc::Memory(..)`
`317`	`317`	`\| GlobalAlloc::VTable(..) => AddressSpace::DATA,`
`@@ -350,7 +350,7 @@ impl<'tcx> GlobalAlloc<'tcx> {`
`350`	`350`	`}`
`351`	`351`	`}`
`352`	`352`	`GlobalAlloc::Memory(alloc) => alloc.inner().mutability,`
`353`		`- GlobalAlloc::Type { .. } \| GlobalAlloc::Function { .. } \| GlobalAlloc::VTable(..) => {`
	`353`	`+ GlobalAlloc::TypeId { .. } \| GlobalAlloc::Function { .. } \| GlobalAlloc::VTable(..) => {`
`354`	`354`	`// These are immutable.`
`355`	`355`	`Mutability::Not`
`356`	`356`	`}`
`@@ -399,7 +399,7 @@ impl<'tcx> GlobalAlloc<'tcx> {`
`399`	`399`	`(Size::ZERO, tcx.data_layout.pointer_align.abi)`
`400`	`400`	`}`
`401`	`401`	`// Fake allocation, there's nothing to access here`
`402`		`- GlobalAlloc::Type { .. } => (Size::ZERO, Align::ONE),`
	`402`	`+ GlobalAlloc::TypeId { .. } => (Size::ZERO, Align::ONE),`
`403`	`403`	`}`
`404`	`404`	`}`
`405`	`405`	`}`
`@@ -507,7 +507,7 @@ impl<'tcx> TyCtxt<'tcx> {`
`507`	`507`
`508`	`508`	`/// Generates an [AllocId] for a [core::any::TypeId]. Will get deduplicated.`
`509`	`509`	`pub fn reserve_and_set_type_id_alloc(self, ty: Ty<'tcx>) -> AllocId {`
`510`		`- self.reserve_and_set_dedup(GlobalAlloc::Type { ty }, 0)`
	`510`	`+ self.reserve_and_set_dedup(GlobalAlloc::TypeId { ty }, 0)`
`511`	`511`	`}`
`512`	`512`
`513`	`513`	/// Interns the `Allocation` and return a new `AllocId`, even if there's already an identical
Original file line number	Diff line number	Diff line change
`@@ -1621,7 +1621,7 @@ pub fn write_allocations<'tcx>(`
`1621`	`1621`	`Some(GlobalAlloc::VTable(ty, dyn_ty)) => {`
`1622`	`1622`	`write!(w, " (vtable: impl {dyn_ty} for {ty})")?`
`1623`	`1623`	`}`
`1624`		`- Some(GlobalAlloc::Type { ty }) => write!(w, " (typeid for {ty})")?,`
	`1624`	`+ Some(GlobalAlloc::TypeId { ty }) => write!(w, " (typeid for {ty})")?,`
`1625`	`1625`	`Some(GlobalAlloc::Static(did)) if !tcx.is_foreign_item(did) => {`
`1626`	`1626`	`write!(w, " (static: {}", tcx.def_path_str(did))?;`
`1627`	`1627`	`if body.phase <= MirPhase::Runtime(RuntimePhase::PostCleanup)`
Original file line number	Diff line number	Diff line change
`@@ -1779,7 +1779,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {`
`1779`	`1779`	`}`
`1780`	`1780`	`Some(GlobalAlloc::Function { .. }) => p!("<function>"),`
`1781`	`1781`	`Some(GlobalAlloc::VTable(..)) => p!("<vtable>"),`
`1782`		`- Some(GlobalAlloc::Type { .. }) => p!("<typeid>"),`
	`1782`	`+ Some(GlobalAlloc::TypeId { .. }) => p!("<typeid>"),`
`1783`	`1783`	`None => p!("<dangling pointer>"),`
`1784`	`1784`	`}`
`1785`	`1785`	`return Ok(());`
Original file line number	Diff line number	Diff line change
`@@ -1219,7 +1219,7 @@ fn collect_alloc<'tcx>(tcx: TyCtxt<'tcx>, alloc_id: AllocId, output: &mut MonoIt`
`1219`	`1219`	`));`
`1220`	`1220`	`collect_alloc(tcx, alloc_id, output)`
`1221`	`1221`	`}`
`1222`		`- GlobalAlloc::Type { .. } => {}`
	`1222`	`+ GlobalAlloc::TypeId { .. } => {}`
`1223`	`1223`	`}`
`1224`	`1224`	`}`
`1225`	`1225`
Original file line number	Diff line number	Diff line change
`@@ -325,7 +325,7 @@ impl<'tcx> ReachableContext<'tcx> {`
`325`	`325`	`self.visit(args);`
`326`	`326`	`}`
`327`	`327`	`}`
`328`		`- GlobalAlloc::Type { ty, .. } => self.visit(ty),`
	`328`	`+ GlobalAlloc::TypeId { ty, .. } => self.visit(ty),`
`329`	`329`	`GlobalAlloc::Memory(alloc) => self.propagate_from_alloc(alloc),`
`330`	`330`	`}`
`331`	`331`	`}`
Original file line number	Diff line number	Diff line change
`@@ -753,7 +753,7 @@ impl<'tcx> Stable<'tcx> for mir::interpret::GlobalAlloc<'tcx> {`
`753`	`753`	`GlobalAlloc::Static(tables.static_def(*def))`
`754`	`754`	`}`
`755`	`755`	`mir::interpret::GlobalAlloc::Memory(alloc) => GlobalAlloc::Memory(alloc.stable(tables)),`
`756`		`- mir::interpret::GlobalAlloc::Type { .. } => todo!(),`
	`756`	`+ mir::interpret::GlobalAlloc::TypeId { .. } => todo!(),`
`757`	`757`	`}`
`758`	`758`	`}`
`759`	`759`	`}`