make vtable_allocation return an Allocation, not an AllocId

Author: compiler-errors

compiler/rustc_codegen_cranelift/src/vtable.rs

@@ -68,7 +68,8 @@ pub(crate) fn get_vtable<'tcx>(
     ty: Ty<'tcx>,
     trait_ref: Option<ty::PolyExistentialTraitRef<'tcx>>,
 ) -> Value {
-    let alloc_id = fx.tcx.vtable_allocation((ty, trait_ref));
+    let alloc = fx.tcx.vtable_allocation((ty, trait_ref));
+    let alloc_id = fx.tcx.create_memory_alloc(alloc);
     let data_id =
         data_id_for_alloc_id(&mut fx.constants_cx, &mut *fx.module, alloc_id, Mutability::Not);
     let local_data_id = fx.module.declare_data_in_func(data_id, &mut fx.bcx.func);

compiler/rustc_codegen_ssa/src/meth.rs

@@ -72,8 +72,7 @@ pub fn get_vtable<'tcx, Cx: CodegenMethods<'tcx>>(
         return val;
     }
 
-    let vtable_alloc_id = tcx.vtable_allocation((ty, trait_ref));
-    let vtable_allocation = tcx.global_alloc(vtable_alloc_id).unwrap_memory();
+    let vtable_allocation = tcx.vtable_allocation((ty, trait_ref));
     let vtable_const = cx.const_data_from_alloc(vtable_allocation);
     let align = cx.data_layout().pointer_align.abi;
     let vtable = cx.static_addr_of(vtable_const, align, Some("vtable"));

compiler/rustc_const_eval/src/interpret/traits.rs

@@ -31,8 +31,8 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         ensure_monomorphic_enough(*self.tcx, poly_trait_ref)?;
 
         let vtable_allocation = self.tcx.vtable_allocation((ty, poly_trait_ref));
-
-        let vtable_ptr = self.memory.global_base_pointer(Pointer::from(vtable_allocation))?;
+        let vtable_allocation_id = self.tcx.create_memory_alloc(vtable_allocation);
+        let vtable_ptr = self.memory.global_base_pointer(Pointer::from(vtable_allocation_id))?;
 
         Ok(vtable_ptr.into())
     }

compiler/rustc_middle/src/query/mod.rs

@@ -1066,7 +1066,7 @@ rustc_queries! {
             key.1, key.0 }
     }
 
-    query vtable_allocation(key: (Ty<'tcx>, Option<ty::PolyExistentialTraitRef<'tcx>>)) -> mir::interpret::AllocId {
+    query vtable_allocation(key: (Ty<'tcx>, Option<ty::PolyExistentialTraitRef<'tcx>>)) -> &'tcx mir::interpret::Allocation {
         desc { |tcx| "vtable const allocation for <{} as {}>",
             key.0,
             key.1.map(|trait_ref| format!("{}", trait_ref)).unwrap_or("_".to_owned())

compiler/rustc_middle/src/ty/vtable.rs

@@ -1,7 +1,7 @@
 use std::convert::TryFrom;
 use std::fmt;
 
-use crate::mir::interpret::{alloc_range, AllocId, Allocation, Pointer, Scalar, ScalarMaybeUninit};
+use crate::mir::interpret::{alloc_range, Allocation, Pointer, Scalar, ScalarMaybeUninit};
 use crate::ty::{self, Instance, PolyTraitRef, Ty, TyCtxt};
 use rustc_ast::Mutability;
 
@@ -48,7 +48,7 @@ pub const COMMON_VTABLE_ENTRIES_ALIGN: usize = 2;
 pub(super) fn vtable_allocation_provider<'tcx>(
     tcx: TyCtxt<'tcx>,
     key: (Ty<'tcx>, Option<ty::PolyExistentialTraitRef<'tcx>>),
-) -> AllocId {
+) -> &'tcx Allocation {
     let (ty, poly_trait_ref) = key;
 
     let vtable_entries = if let Some(poly_trait_ref) = poly_trait_ref {
@@ -99,7 +99,8 @@ pub(super) fn vtable_allocation_provider<'tcx>(
             VtblEntry::TraitVPtr(trait_ref) => {
                 let super_trait_ref = trait_ref
                     .map_bound(|trait_ref| ty::ExistentialTraitRef::erase_self_ty(tcx, trait_ref));
-                let supertrait_alloc_id = tcx.vtable_allocation((ty, Some(super_trait_ref)));
+                let supertrait_alloc = tcx.vtable_allocation((ty, Some(super_trait_ref)));
+                let supertrait_alloc_id = tcx.create_memory_alloc(supertrait_alloc);
                 let vptr = Pointer::from(supertrait_alloc_id);
                 ScalarMaybeUninit::from_pointer(vptr, &tcx)
             }
@@ -110,5 +111,5 @@ pub(super) fn vtable_allocation_provider<'tcx>(
     }
 
     vtable.mutability = Mutability::Not;
-    tcx.create_memory_alloc(tcx.intern_const_alloc(vtable))
+    tcx.intern_const_alloc(vtable)
 }