Retire GlobalId.

Author: cjgillot

compiler/rustc_const_eval/src/const_eval/eval_queries.rs

@@ -17,7 +17,7 @@ use rustc_target::abi::{self, Abi};
 use super::{CompileTimeEvalContext, CompileTimeInterpreter, ConstEvalErr};
 use crate::interpret::eval_nullary_intrinsic;
 use crate::interpret::{
-    intern_const_alloc_recursive, Allocation, ConstAlloc, ConstValue, CtfeValidationMode, GlobalId,
+    intern_const_alloc_recursive, Allocation, ConstAlloc, ConstValue, CtfeValidationMode,
     Immediate, InternKind, InterpCx, InterpError, InterpResult, MPlaceTy, MemoryKind, OpTy,
     RefTracking, StackPopCleanup,
 };
@@ -29,14 +29,14 @@ const NOTE_ON_UNDEFINED_BEHAVIOR_ERROR: &str = "The rules on what exactly is und
 // Returns a pointer to where the result lives
 fn eval_body_using_ecx<'mir, 'tcx>(
     ecx: &mut CompileTimeEvalContext<'mir, 'tcx>,
-    cid: GlobalId<'tcx>,
+    instance: ty::Instance<'tcx>,
     body: &'mir mir::Body<'tcx>,
 ) -> InterpResult<'tcx, MPlaceTy<'tcx>> {
-    debug!("eval_body_using_ecx: {:?}, {:?}", cid, ecx.param_env);
+    debug!("eval_body_using_ecx: {:?}, {:?}", instance, ecx.param_env);
     let tcx = *ecx.tcx;
     assert!(
         matches!(
-            ecx.tcx.def_kind(cid.instance.def_id()),
+            ecx.tcx.def_kind(instance.def_id()),
             DefKind::Const
                 | DefKind::Static(_)
                 | DefKind::ConstParam
@@ -46,29 +46,21 @@ fn eval_body_using_ecx<'mir, 'tcx>(
                 | DefKind::Promoted
         ),
         "Unexpected DefKind: {:?}",
-        ecx.tcx.def_kind(cid.instance.def_id())
+        ecx.tcx.def_kind(instance.def_id())
     );
-    let layout = ecx.layout_of(body.bound_return_ty().subst(tcx, cid.instance.substs))?;
+    let layout = ecx.layout_of(body.bound_return_ty().subst(tcx, instance.substs))?;
     assert!(layout.is_sized());
     let ret = ecx.allocate(layout, MemoryKind::Stack)?;
 
-    trace!(
-        "eval_body_using_ecx: pushing stack frame for global: {}",
-        with_no_trimmed_paths!(ecx.tcx.def_path_str(cid.instance.def_id())),
-    );
+    trace!("eval_body_using_ecx: pushing stack frame for global: {:?}", instance.def_id());
 
-    ecx.push_stack_frame(
-        cid.instance,
-        body,
-        &ret.into(),
-        StackPopCleanup::Root { cleanup: false },
-    )?;
+    ecx.push_stack_frame(instance, body, &ret.into(), StackPopCleanup::Root { cleanup: false })?;
 
     // The main interpreter loop.
     while ecx.step()? {}
 
     // Intern the result
-    let intern_kind = match tcx.def_kind(cid.instance.def_id()) {
+    let intern_kind = match tcx.def_kind(instance.def_id()) {
         DefKind::Promoted => InternKind::Promoted,
         DefKind::Static(m) => InternKind::Static(m),
         _ => InternKind::Constant,
@@ -196,15 +188,15 @@ pub(super) fn op_to_const<'tcx>(
 pub(crate) fn turn_into_const_value<'tcx>(
     tcx: TyCtxt<'tcx>,
     constant: ConstAlloc<'tcx>,
-    key: ty::ParamEnvAnd<'tcx, GlobalId<'tcx>>,
+    key: ty::ParamEnvAnd<'tcx, ty::Instance<'tcx>>,
 ) -> ConstValue<'tcx> {
-    let cid = key.value;
-    let def_id = cid.instance.def.def_id();
+    let instance = key.value;
+    let def_id = instance.def.def_id();
     let is_static = tcx.is_static(def_id);
     // This is just accessing an already computed constant, so no need to check alignment here.
     let ecx = mk_eval_cx(
         tcx,
-        tcx.def_span(key.value.instance.def_id()),
+        tcx.def_span(def_id),
         key.param_env,
         /*can_access_statics:*/ is_static,
     );
@@ -225,7 +217,7 @@ pub(crate) fn turn_into_const_value<'tcx>(
 #[instrument(skip(tcx), level = "debug")]
 pub fn eval_to_const_value_raw_provider<'tcx>(
     tcx: TyCtxt<'tcx>,
-    key: ty::ParamEnvAnd<'tcx, GlobalId<'tcx>>,
+    key: ty::ParamEnvAnd<'tcx, ty::Instance<'tcx>>,
 ) -> ::rustc_middle::mir::interpret::EvalToConstValueResult<'tcx> {
     assert!(key.param_env.is_const());
     // see comment in eval_to_allocation_raw_provider for what we're doing here
@@ -242,8 +234,8 @@ pub fn eval_to_const_value_raw_provider<'tcx>(
 
     // We call `const_eval` for zero arg intrinsics, too, in order to cache their value.
     // Catch such calls and evaluate them instead of trying to load a constant's MIR.
-    if let ty::InstanceDef::Intrinsic(def_id) = key.value.instance.def {
-        let ty = key.value.instance.ty(tcx, key.param_env);
+    if let ty::InstanceDef::Intrinsic(def_id) = key.value.def {
+        let ty = key.value.ty(tcx, key.param_env);
         let ty::FnDef(_, substs) = ty.kind() else {
             bug!("intrinsic with type {:?}", ty);
         };
@@ -260,7 +252,7 @@ pub fn eval_to_const_value_raw_provider<'tcx>(
 #[instrument(skip(tcx), level = "debug")]
 pub fn eval_to_allocation_raw_provider<'tcx>(
     tcx: TyCtxt<'tcx>,
-    key: ty::ParamEnvAnd<'tcx, GlobalId<'tcx>>,
+    key: ty::ParamEnvAnd<'tcx, ty::Instance<'tcx>>,
 ) -> ::rustc_middle::mir::interpret::EvalToAllocationRawResult<'tcx> {
     assert!(key.param_env.is_const());
     // Because the constant is computed twice (once per value of `Reveal`), we are at risk of
@@ -281,18 +273,10 @@ pub fn eval_to_allocation_raw_provider<'tcx>(
             other => return other,
         }
     }
-    if cfg!(debug_assertions) {
-        // Make sure we format the instance even if we do not print it.
-        // This serves as a regression test against an ICE on printing.
-        // The next two lines concatenated contain some discussion:
-        // https://rust-lang.zulipchat.com/#narrow/stream/146212-t-compiler.2Fconst-eval/
-        // subject/anon_const_instance_printing/near/135980032
-        let instance = with_no_trimmed_paths!(key.value.instance.to_string());
-        trace!("const eval: {:?} ({})", key, instance);
-    }
+    trace!("const eval: {:?}", key);
 
-    let cid = key.value;
-    let def = cid.instance.def.def_id();
+    let instance = key.value;
+    let def = instance.def.def_id();
     let within_static = match tcx.def_kind(def) {
         DefKind::Promoted => tcx.is_static(tcx.parent(def)),
         DefKind::Static(_) => true,
@@ -316,8 +300,8 @@ pub fn eval_to_allocation_raw_provider<'tcx>(
         ),
     );
 
-    let res = ecx.load_mir(cid.instance.def);
-    match res.and_then(|body| eval_body_using_ecx(&mut ecx, cid, &body)) {
+    let res = ecx.load_mir(instance.def);
+    match res.and_then(|body| eval_body_using_ecx(&mut ecx, instance, &body)) {
         Err(error) => {
             let err = ConstEvalErr::new(&ecx, error, None);
             let msg = if within_static {
@@ -326,7 +310,6 @@ pub fn eval_to_allocation_raw_provider<'tcx>(
                 // If the current item has generics, we'd like to enrich the message with the
                 // instance and its substs: to show the actual compile-time values, in addition to
                 // the expression, leading to the const eval error.
-                let instance = &key.value.instance;
                 if !instance.substs.is_empty() {
                     let instance = with_no_trimmed_paths!(instance.to_string());
                     let msg = format!("evaluation of `{}` failed", instance);

compiler/rustc_const_eval/src/const_eval/mod.rs

@@ -7,7 +7,7 @@ use crate::interpret::{
 };
 use rustc_hir::Mutability;
 use rustc_middle::mir;
-use rustc_middle::mir::interpret::{EvalToValTreeResult, GlobalId};
+use rustc_middle::mir::interpret::EvalToValTreeResult;
 use rustc_middle::ty::{self, TyCtxt};
 use rustc_span::{source_map::DUMMY_SP, symbol::Symbol};
 
@@ -51,9 +51,9 @@ pub(crate) type ValTreeCreationResult<'tcx> = Result<ty::ValTree<'tcx>, ValTreeC
 pub(crate) fn eval_to_valtree<'tcx>(
     tcx: TyCtxt<'tcx>,
     param_env: ty::ParamEnv<'tcx>,
-    cid: GlobalId<'tcx>,
+    instance: ty::Instance<'tcx>,
 ) -> EvalToValTreeResult<'tcx> {
-    let const_alloc = tcx.eval_to_allocation_raw(param_env.and(cid))?;
+    let const_alloc = tcx.eval_to_allocation_raw(param_env.and(instance))?;
 
     // FIXME Need to provide a span to `eval_to_valtree`
     let ecx = mk_eval_cx(
@@ -71,10 +71,10 @@ pub(crate) fn eval_to_valtree<'tcx>(
     match valtree_result {
         Ok(valtree) => Ok(Some(valtree)),
         Err(err) => {
-            let did = cid.instance.def_id();
-            let global_const_id = cid.display(tcx);
+            let did = instance.def_id();
             match err {
                 ValTreeCreationError::NodesOverflow => {
+                    let global_const_id = tcx.def_path_str(did);
                     let msg = format!(
                         "maximum number of nodes exceeded in constant {}",
                         &global_const_id

compiler/rustc_const_eval/src/interpret/eval_context.rs

@@ -20,9 +20,9 @@ use rustc_span::Span;
 use rustc_target::abi::{call::FnAbi, Align, HasDataLayout, Size, TargetDataLayout};
 
 use super::{
-    AllocId, GlobalId, Immediate, InterpErrorInfo, InterpResult, MPlaceTy, Machine, MemPlace,
-    MemPlaceMeta, Memory, MemoryKind, Operand, Place, PlaceTy, PointerArithmetic, Provenance,
-    Scalar, StackPopJump,
+    AllocId, Immediate, InterpErrorInfo, InterpResult, MPlaceTy, Machine, MemPlace, MemPlaceMeta,
+    Memory, MemoryKind, Operand, Place, PlaceTy, PointerArithmetic, Provenance, Scalar,
+    StackPopJump,
 };
 use crate::util;
 
@@ -911,21 +911,22 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
 
     pub fn eval_global(
         &self,
-        gid: GlobalId<'tcx>,
+        instance: ty::Instance<'tcx>,
         span: Option<Span>,
     ) -> InterpResult<'tcx, MPlaceTy<'tcx, M::Provenance>> {
         // For statics we pick `ParamEnv::reveal_all`, because statics don't have generics
         // and thus don't care about the parameter environment. While we could just use
         // `self.param_env`, that would mean we invoke the query to evaluate the static
         // with different parameter environments, thus causing the static to be evaluated
         // multiple times.
-        let param_env = if self.tcx.is_static(gid.instance.def_id()) {
+        let param_env = if self.tcx.is_static(instance.def_id()) {
             ty::ParamEnv::reveal_all()
         } else {
             self.param_env
         };
         let param_env = param_env.with_const();
-        let val = self.ctfe_query(span, |tcx| tcx.eval_to_allocation_raw(param_env.and(gid)))?;
+        let val =
+            self.ctfe_query(span, |tcx| tcx.eval_to_allocation_raw(param_env.and(instance)))?;
         self.raw_const_to_mplace(val)
     }
 

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -5,9 +5,7 @@
 use rustc_hir::def_id::DefId;
 use rustc_middle::mir::{
     self,
-    interpret::{
-        Allocation, ConstAllocation, ConstValue, GlobalId, InterpResult, PointerArithmetic, Scalar,
-    },
+    interpret::{Allocation, ConstAllocation, ConstValue, InterpResult, PointerArithmetic, Scalar},
     BinOp, NonDivergingIntrinsic,
 };
 use rustc_middle::ty;
@@ -163,7 +161,6 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             | sym::type_id
             | sym::type_name
             | sym::variant_count => {
-                let gid = GlobalId { instance };
                 let ty = match intrinsic_name {
                     sym::pref_align_of | sym::variant_count => self.tcx.types.usize,
                     sym::needs_drop => self.tcx.types.bool,
@@ -172,7 +169,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                     _ => bug!(),
                 };
                 let val = self.ctfe_query(None, |tcx| {
-                    tcx.const_eval_global_id(self.param_env, gid, Some(tcx.span))
+                    tcx.const_eval_global_id(self.param_env, instance, Some(tcx.span))
                 })?;
                 let val = self.const_val_to_op(val, ty, Some(dest.layout))?;
                 self.copy_op(&val, dest, /*allow_transmute*/ false)?;

compiler/rustc_const_eval/src/interpret/operand.rs

@@ -12,9 +12,9 @@ use rustc_span::Span;
 use rustc_target::abi::{self, Abi, Align, HasDataLayout, Size};
 
 use super::{
-    alloc_range, from_known_layout, mir_assign_valid_types, AllocId, ConstValue, Frame, GlobalId,
-    InterpCx, InterpResult, MPlaceTy, Machine, MemPlace, MemPlaceMeta, Place, PlaceTy, Pointer,
-    Provenance, Scalar,
+    alloc_range, from_known_layout, mir_assign_valid_types, AllocId, ConstValue, Frame, InterpCx,
+    InterpResult, MPlaceTy, Machine, MemPlace, MemPlaceMeta, Place, PlaceTy, Pointer, Provenance,
+    Scalar,
 };
 
 /// An `Immediate` represents a single immediate self-contained Rust value.
@@ -599,9 +599,8 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             }
             ty::ConstKind::Unevaluated(uv) => {
                 let instance = self.resolve(uv.def, uv.substs)?;
-                let cid = GlobalId { instance };
                 self.ctfe_query(span, |tcx| {
-                    tcx.eval_to_valtree(self.param_env.with_const().and(cid))
+                    tcx.eval_to_valtree(self.param_env.with_const().and(instance))
                 })?
                 .unwrap_or_else(|| bug!("unable to create ValTree for {uv:?}"))
             }
@@ -628,7 +627,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             mir::ConstantKind::Val(val, ty) => self.const_val_to_op(val, ty, layout),
             mir::ConstantKind::Unevaluated(uv, _) => {
                 let instance = self.resolve(uv.def, uv.substs)?;
-                Ok(self.eval_global(GlobalId { instance }, span)?.into())
+                Ok(self.eval_global(instance, span)?.into())
             }
         }
     }

compiler/rustc_middle/src/mir/interpret/mod.rs

@@ -108,7 +108,6 @@ use rustc_data_structures::tiny_list::TinyList;
 use rustc_errors::ErrorGuaranteed;
 use rustc_hir::def_id::DefId;
 use rustc_macros::HashStable;
-use rustc_middle::ty::print::with_no_trimmed_paths;
 use rustc_serialize::{Decodable, Encodable};
 use rustc_target::abi::{AddressSpace, Endian, HasDataLayout};
 
@@ -132,23 +131,6 @@ pub use self::allocation::{
 
 pub use self::pointer::{Pointer, PointerArithmetic, Provenance};
 
-/// Uniquely identifies one of the following:
-/// - A constant
-/// - A static
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, TyEncodable, TyDecodable)]
-#[derive(HashStable, Lift, TypeFoldable, TypeVisitable)]
-pub struct GlobalId<'tcx> {
-    /// For a constant or static, the `Instance` of the item itself.
-    /// For a promoted global, the `Instance` of the function they belong to.
-    pub instance: ty::Instance<'tcx>,
-}
-
-impl<'tcx> GlobalId<'tcx> {
-    pub fn display(self, tcx: TyCtxt<'tcx>) -> String {
-        with_no_trimmed_paths!(tcx.def_path_str(self.instance.def.def_id()))
-    }
-}
-
 /// Input argument for `tcx.lit_to_const`.
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, HashStable)]
 pub struct LitToConstInput<'tcx> {