Switch to store Instance directly within VtblEntry, fix TraitVPtr representation.

Author: crlf0710

compiler/rustc_middle/src/ty/vtable.rs

@@ -1,18 +1,32 @@
 use std::convert::TryFrom;
+use std::fmt;
 
 use crate::mir::interpret::{alloc_range, AllocId, Allocation, Pointer, Scalar, ScalarMaybeUninit};
-use crate::ty::fold::TypeFoldable;
-use crate::ty::{self, DefId, PolyExistentialTraitRef, SubstsRef, Ty, TyCtxt};
+use crate::ty::{self, Instance, PolyTraitRef, Ty, TyCtxt};
 use rustc_ast::Mutability;
 
-#[derive(Clone, Copy, Debug, PartialEq, HashStable)]
+#[derive(Clone, Copy, PartialEq, HashStable)]
 pub enum VtblEntry<'tcx> {
     MetadataDropInPlace,
     MetadataSize,
     MetadataAlign,
     Vacant,
-    Method(DefId, SubstsRef<'tcx>),
-    TraitVPtr(PolyExistentialTraitRef<'tcx>),
+    Method(Instance<'tcx>),
+    TraitVPtr(PolyTraitRef<'tcx>),
+}
+
+impl<'tcx> fmt::Debug for VtblEntry<'tcx> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            VtblEntry::MetadataDropInPlace => write!(f, "MetadataDropInPlace")?,
+            VtblEntry::MetadataSize => write!(f, "MetadataSize")?,
+            VtblEntry::MetadataAlign => write!(f, "MetadataAlign")?,
+            VtblEntry::Vacant => write!(f, "Vacant")?,
+            VtblEntry::Method(instance) => write!(f, "Method: {}", instance)?,
+            VtblEntry::TraitVPtr(trait_ref) => write!(f, "TraitVPtr: {}", trait_ref)?,
+        }
+        Ok(())
+    }
 }
 
 pub const COMMON_VTABLE_ENTRIES: &[VtblEntry<'_>] =
@@ -37,11 +51,6 @@ impl<'tcx> TyCtxt<'tcx> {
         }
         drop(vtables_cache);
 
-        // See https://github.com/rust-lang/rust/pull/86475#discussion_r655162674
-        assert!(
-            !ty.needs_subst() && !poly_trait_ref.map_or(false, |trait_ref| trait_ref.needs_subst())
-        );
-        let param_env = ty::ParamEnv::reveal_all();
         let vtable_entries = if let Some(poly_trait_ref) = poly_trait_ref {
             let trait_ref = poly_trait_ref.with_self_ty(tcx, ty);
             let trait_ref = tcx.erase_regions(trait_ref);
@@ -51,8 +60,9 @@ impl<'tcx> TyCtxt<'tcx> {
             COMMON_VTABLE_ENTRIES
         };
 
-        let layout =
-            tcx.layout_of(param_env.and(ty)).expect("failed to build vtable representation");
+        let layout = tcx
+            .layout_of(ty::ParamEnv::reveal_all().and(ty))
+            .expect("failed to build vtable representation");
         assert!(!layout.is_unsized(), "can't create a vtable for an unsized type");
         let size = layout.size.bytes();
         let align = layout.align.abi.bytes();
@@ -80,21 +90,18 @@ impl<'tcx> TyCtxt<'tcx> {
                 VtblEntry::MetadataSize => Scalar::from_uint(size, ptr_size).into(),
                 VtblEntry::MetadataAlign => Scalar::from_uint(align, ptr_size).into(),
                 VtblEntry::Vacant => continue,
-                VtblEntry::Method(def_id, substs) => {
-                    // See https://github.com/rust-lang/rust/pull/86475#discussion_r655162674
-                    assert!(!substs.needs_subst());
-
+                VtblEntry::Method(instance) => {
                     // Prepare the fn ptr we write into the vtable.
-                    let instance =
-                        ty::Instance::resolve_for_vtable(tcx, param_env, *def_id, substs)
-                            .expect("resolution failed during building vtable representation")
-                            .polymorphize(tcx);
+                    let instance = instance.polymorphize(tcx);
                     let fn_alloc_id = tcx.create_fn_alloc(instance);
                     let fn_ptr = Pointer::from(fn_alloc_id);
                     ScalarMaybeUninit::from_pointer(fn_ptr, &tcx)
                 }
                 VtblEntry::TraitVPtr(trait_ref) => {
-                    let supertrait_alloc_id = self.vtable_allocation(ty, Some(*trait_ref));
+                    let super_trait_ref = trait_ref.map_bound(|trait_ref| {
+                        ty::ExistentialTraitRef::erase_self_ty(tcx, trait_ref)
+                    });
+                    let supertrait_alloc_id = self.vtable_allocation(ty, Some(super_trait_ref));
                     let vptr = Pointer::from(supertrait_alloc_id);
                     ScalarMaybeUninit::from_pointer(vptr, &tcx)
                 }

compiler/rustc_mir/src/monomorphize/collector.rs

@@ -1120,13 +1120,9 @@ fn create_mono_items_for_vtable_methods<'tcx>(
                         // all super trait items already covered, so skip them.
                         None
                     }
-                    VtblEntry::Method(def_id, substs) => ty::Instance::resolve_for_vtable(
-                        tcx,
-                        ty::ParamEnv::reveal_all(),
-                        *def_id,
-                        substs,
-                    )
-                    .filter(|instance| should_codegen_locally(tcx, instance)),
+                    VtblEntry::Method(instance) => {
+                        Some(*instance).filter(|instance| should_codegen_locally(tcx, instance))
+                    }
                 })
                 .map(|item| create_fn_mono_item(tcx, item, source));
             output.extend(methods);

compiler/rustc_trait_selection/src/traits/mod.rs

@@ -678,15 +678,19 @@ fn vtable_entries<'tcx>(
                         return VtblEntry::Vacant;
                     }
 
-                    VtblEntry::Method(def_id, substs)
+                    let instance = ty::Instance::resolve_for_vtable(
+                        tcx,
+                        ty::ParamEnv::reveal_all(),
+                        def_id,
+                        substs,
+                    )
+                    .expect("resolution failed during building vtable representation");
+                    VtblEntry::Method(instance)
                 });
 
                 entries.extend(own_entries);
 
                 if emit_vptr {
-                    let trait_ref = trait_ref.map_bound(|trait_ref| {
-                        ty::ExistentialTraitRef::erase_self_ty(tcx, trait_ref)
-                    });
                     entries.push(VtblEntry::TraitVPtr(trait_ref));
                 }
             }

src/test/ui/traits/vtable/vtable-diamond.stderr

@@ -2,54 +2,19 @@ error: Vtable Entries: [
     MetadataDropInPlace,
     MetadataSize,
     MetadataAlign,
-    Method(
-        DefId(0:4 ~ vtable_diamond[4564]::A::foo_a),
-        [
-            S,
-        ],
-    ),
-    Method(
-        DefId(0:6 ~ vtable_diamond[4564]::B::foo_b),
-        [
-            S,
-        ],
-    ),
-    Method(
-        DefId(0:8 ~ vtable_diamond[4564]::C::foo_c),
-        [
-            S,
-        ],
-    ),
-    TraitVPtr(
-        Binder(
-            C,
-            [],
-        ),
-    ),
-    Method(
-        DefId(0:10 ~ vtable_diamond[4564]::D::foo_d),
-        [
-            S,
-        ],
-    ),
+    Method: <S as A>::foo_a,
+    Method: <S as B>::foo_b,
+    Method: <S as C>::foo_c,
+    TraitVPtr: <S as C>,
+    Method: <S as D>::foo_d,
 ]
 
 error: Vtable Entries: [
     MetadataDropInPlace,
     MetadataSize,
     MetadataAlign,
-    Method(
-        DefId(0:4 ~ vtable_diamond[4564]::A::foo_a),
-        [
-            S,
-        ],
-    ),
-    Method(
-        DefId(0:8 ~ vtable_diamond[4564]::C::foo_c),
-        [
-            S,
-        ],
-    ),
+    Method: <S as A>::foo_a,
+    Method: <S as C>::foo_c,
 ]
 
 error: aborting due to 2 previous errors

src/test/ui/traits/vtable/vtable-multiple.stderr

@@ -2,42 +2,17 @@ error: Vtable Entries: [
     MetadataDropInPlace,
     MetadataSize,
     MetadataAlign,
-    Method(
-        DefId(0:4 ~ vtable_multiple[5246]::A::foo_a),
-        [
-            S,
-        ],
-    ),
-    Method(
-        DefId(0:6 ~ vtable_multiple[5246]::B::foo_b),
-        [
-            S,
-        ],
-    ),
-    TraitVPtr(
-        Binder(
-            B,
-            [],
-        ),
-    ),
-    Method(
-        DefId(0:8 ~ vtable_multiple[5246]::C::foo_c),
-        [
-            S,
-        ],
-    ),
+    Method: <S as A>::foo_a,
+    Method: <S as B>::foo_b,
+    TraitVPtr: <S as B>,
+    Method: <S as C>::foo_c,
 ]
 
 error: Vtable Entries: [
     MetadataDropInPlace,
     MetadataSize,
     MetadataAlign,
-    Method(
-        DefId(0:6 ~ vtable_multiple[5246]::B::foo_b),
-        [
-            S,
-        ],
-    ),
+    Method: <S as B>::foo_b,
 ]
 
 error: aborting due to 2 previous errors