Implemented trait upcasting.

Author: Alexander Regueiro

src/librustc_codegen_ssa/base.rs

@@ -20,7 +20,7 @@ use crate::back::write::{
 use crate::common::{IntPredicate, RealPredicate, TypeKind};
 use crate::meth;
 use crate::mir;
-use crate::mir::operand::OperandValue;
+use crate::mir::operand::{OperandRef, OperandValue};
 use crate::mir::place::PlaceRef;
 use crate::traits::*;
 use crate::{CachedModuleCodegen, CrateInfo, MemFlags, ModuleCodegen, ModuleKind};
@@ -221,6 +221,57 @@ pub fn unsize_thin_ptr<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
     }
 }
 
+/// Coerces `op` to `dst.ty`. `op` may be a fat pointer.
+pub fn coerce_ptr_unsized<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
+    bx: &mut Bx,
+    op: OperandRef<'tcx, Bx::Value>,
+    dst: TyLayout<'tcx>,
+) -> OperandValue<Bx::Value> {
+    assert!(bx.cx().is_backend_scalar_pair(dst));
+    let src = op.layout;
+    let (base, info) = match op.val {
+        OperandValue::Pair(base, info) => {
+            // Fat-ptr to fat-ptr unsize (e.g., `&'a fmt::Debug + Send` => `&'a fmt::Debug`).
+            // We always need to `pointercast` the base to ensure the types match up.
+            // In some cases, e.g., `&'a Bar` => `&'a Foo` where `Bar: Foo`, we also need to
+            // modify the info (i.e., the pointer to the vtable), by offsetting into the
+            // existing vtable. See the `get_vtable` fn in `meth.rs` for more details of vtable
+            // layout.
+
+            let base = bx.pointercast(
+                base,
+                bx.cx().scalar_pair_element_backend_type(dst, 0, true),
+            );
+            let info = match (&src.ty.kind, &dst.ty.kind) {
+                (&ty::Ref(_, a, _),
+                 &ty::Ref(_, b, _)) |
+                (&ty::Ref(_, a, _),
+                 &ty::RawPtr(ty::TypeAndMut { ty: b, .. })) |
+                (&ty::RawPtr(ty::TypeAndMut { ty: a, .. }),
+                 &ty::RawPtr(ty::TypeAndMut { ty: b, .. })) => {
+                    unsized_info(bx, a, b, Some(info))
+                }
+                (&ty::Adt(def_a, _), &ty::Adt(def_b, _)) => {
+                    assert_eq!(def_a, def_b);
+                    unsized_info(bx, src.ty, dst.ty, Some(info))
+                }
+                _ => bug!("coerce_ptr_unsized: called on bad types"),
+            };
+            (base, info)
+        }
+        OperandValue::Immediate(base) => {
+            unsize_thin_ptr(bx, base, src.ty, dst.ty)
+        }
+        OperandValue::Ref(..) => {
+            bug!(
+                "coerce_ptr_unsized: unexpected by-ref operand {:?}",
+                op
+            );
+        }
+    };
+    OperandValue::Pair(base, info)
+}
+
 /// Coerces `src`, which is a reference to a value of type `src_ty`,
 /// to a value of type `dst_ty`, and stores the result in `dst`.
 pub fn coerce_unsized_into<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(

src/librustc_codegen_ssa/meth.rs

@@ -85,17 +85,21 @@ pub fn get_vtable<'tcx, Cx: CodegenMethods<'tcx>>(
         (&[]).iter()
     };
 
-    let methods = methods.cloned().map(|opt_mth| {
-        opt_mth.map_or(nullptr, |(def_id, substs)| {
-            cx.get_fn_addr(
-                ty::Instance::resolve_for_vtable(
-                    cx.tcx(),
-                    ty::ParamEnv::reveal_all(),
-                    def_id,
-                    substs,
+    // Resolve instances for each method in the vtable.
+    // Preserve nested (per-supertrait) structure of list of methods.
+    let methods = methods.cloned().map(|trait_methods| {
+        trait_methods.into_iter().map(|opt_meth| {
+            opt_meth.map_or(nullptr, |(def_id, substs)| {
+                cx.get_fn_addr(
+                    ty::Instance::resolve_for_vtable(
+                        cx.tcx(),
+                        ty::ParamEnv::reveal_all(),
+                        def_id,
+                        substs,
+                    )
+                    .unwrap(),
                 )
-                .unwrap(),
-            )
+            })
         })
     });
 
@@ -104,15 +108,20 @@ pub fn get_vtable<'tcx, Cx: CodegenMethods<'tcx>>(
     // If you touch this code, be sure to also make the corresponding changes to
     // `get_vtable` in `rust_mir/interpret/traits.rs`.
     // /////////////////////////////////////////////////////////////////////////////////////////////
-    let components: Vec<_> = [
+    let metadata = [
         cx.get_fn_addr(Instance::resolve_drop_in_place(cx.tcx(), ty)),
         cx.const_usize(layout.size.bytes()),
         cx.const_usize(layout.align.abi.bytes()),
-    ]
-    .iter()
-    .cloned()
-    .chain(methods)
-    .collect();
+    ];
+    let mut components: Vec<_> = methods
+        .flat_map(|trait_methods| {
+            // Insert copy of metadata before methods for the current (super)trait.
+            metadata.iter().cloned().chain(trait_methods)
+        })
+        .collect();
+    if components.is_empty() {
+        components.extend(&metadata);
+    }
 
     let vtable_const = cx.const_struct(&components, false);
     let align = cx.data_layout().pointer_align.abi;

src/librustc_middle/query/mod.rs

@@ -670,8 +670,9 @@ rustc_queries! {
     }
 
     Other {
-        query vtable_methods(key: ty::PolyTraitRef<'tcx>)
-                            -> &'tcx [Option<(DefId, SubstsRef<'tcx>)>] {
+        query vtable_methods(
+            key: ty::PolyTraitRef<'tcx>
+        ) -> &'tcx [&'tcx [Option<(DefId, SubstsRef<'tcx>)>]] {
             desc { |tcx| "finding all methods for trait {}", tcx.def_path_str(key.def_id()) }
         }
     }

src/librustc_middle/traits/mod.rs

@@ -834,6 +834,6 @@ pub enum MethodViolationCode {
     /// e.g., `fn foo<A>()`
     Generic,
 
-    /// the method's receiver (`self` argument) can't be dispatched on
+    /// The method's receiver (`self` argument) cannot be dispatched on.
     UndispatchableReceiver,
 }

src/librustc_mir/interpret/traits.rs

@@ -56,7 +56,14 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         // `get_vtable` in `rust_codegen_llvm/meth.rs`.
         // /////////////////////////////////////////////////////////////////////////////////////////
         let vtable = self.memory.allocate(
-            ptr_size * u64::try_from(methods.len()).unwrap().checked_add(3).unwrap(),
+            // Compute size of vtable, including 3 entries per supertrait for (drop, size, align)
+            // metadata.
+            ptr_size * (
+                methods
+                    .iter()
+                    .map(|l| u64::try_from(methods.len()).unwrap().checked_add(3).unwrap())
+                    .sum()
+            ),
             ptr_align,
             MemoryKind::Vtable,
         );
@@ -76,21 +83,23 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         let drop = Instance::resolve_drop_in_place(*tcx, ty);
         let drop = self.memory.create_fn_alloc(FnVal::Instance(drop));
 
-        // No need to do any alignment checks on the memory accesses below, because we know the
-        // allocation is correctly aligned, as we created it above. Also. we're only offsetting
-        // by multiples of `ptr_align`, which means that it will stay aligned to `ptr_align`.
-        write_ptr(&mut self.memory, Scalar::Ptr(drop).into())?;
-        write_ptr(&mut self.memory, Scalar::from_uint(size, ptr_size).into())?;
-        write_ptr(&mut self.memory, Scalar::from_uint(align, ptr_size).into())?;
-
-        for method in methods.iter() {
-            if let Some((def_id, substs)) = *method {
-                // Resolve for vtable; insert shims where needed.
-                let instance =
-                    ty::Instance::resolve_for_vtable(*tcx, self.param_env, def_id, substs)
-                        .ok_or_else(|| err_inval!(TooGeneric))?;
-                let fn_ptr = self.memory.create_fn_alloc(FnVal::Instance(instance));
-                write_ptr(&mut self.memory, Scalar::Ptr(fn_ptr).into())?;
+        for trait_methods in methods.iter() {
+            // No need to do any alignment checks on the memory accesses below, because we know the
+            // allocation is correctly aligned, as we created it above. Also. we're only offsetting
+            // by multiples of `ptr_align`, which means that it will stay aligned to `ptr_align`.
+            write_ptr(&mut self.memory, Scalar::Ptr(drop).into())?;
+            write_ptr(&mut self.memory, Scalar::from_uint(size, ptr_size).into())?;
+            write_ptr(&mut self.memory, Scalar::from_uint(align, ptr_size).into())?;
+
+            for method in trait_methods.iter() {
+                if let Some((def_id, substs)) = *method {
+                    // Resolve for vtable; insert shims where needed.
+                    let instance =
+                        ty::Instance::resolve_for_vtable(*tcx, self.param_env, def_id, substs)
+                            .ok_or_else(|| err_inval!(TooGeneric))?;
+                    let fn_ptr = self.memory.create_fn_alloc(FnVal::Instance(instance));
+                    write_ptr(&mut self.memory, Scalar::Ptr(fn_ptr).into())?;
+                }
             }
         }
 

src/librustc_mir/monomorphize/collector.rs

@@ -882,10 +882,9 @@ fn create_mono_items_for_vtable_methods<'tcx>(
             let poly_trait_ref = principal.with_self_ty(tcx, impl_ty);
             assert!(!poly_trait_ref.has_escaping_bound_vars());
 
-            // Walk all methods of the trait, including those of its supertraits
+            // Walk all methods of the trait, including those of its supertraits.
             let methods = tcx.vtable_methods(poly_trait_ref);
             let methods = methods
-                .iter()
                 .cloned()
                 .filter_map(|method| method)
                 .map(|(def_id, substs)| {

src/librustc_trait_selection/traits/mod.rs

@@ -462,24 +462,24 @@ fn substitute_normalize_and_test_predicates<'tcx>(
     result
 }
 
-/// Given a trait `trait_ref`, iterates the vtable entries
-/// that come from `trait_ref`, including its supertraits.
+/// Given a trait `trait_ref`, iterates the vtable entries that come from `trait_ref`, including its
+/// supertraits, and returns them per-trait.
 #[inline] // FIXME(#35870): avoid closures being unexported due to `impl Trait`.
 fn vtable_methods<'tcx>(
     tcx: TyCtxt<'tcx>,
     trait_ref: ty::PolyTraitRef<'tcx>,
-) -> &'tcx [Option<(DefId, SubstsRef<'tcx>)>] {
+) -> &'tcx [&'tcx [Option<(DefId, SubstsRef<'tcx>)>]] {
     debug!("vtable_methods({:?})", trait_ref);
 
-    tcx.arena.alloc_from_iter(supertraits(tcx, trait_ref).flat_map(move |trait_ref| {
+    tcx.arena.alloc_from_iter(supertraits(tcx, trait_ref).map(move |trait_ref| {
         let trait_methods = tcx
             .associated_items(trait_ref.def_id())
             .in_definition_order()
             .filter(|item| item.kind == ty::AssocKind::Fn);
 
-        // Now list each method's DefId and InternalSubsts (for within its trait).
-        // If the method can never be called from this object, produce None.
-        trait_methods.map(move |trait_method| {
+        // Now, list each method's `DefId` and `InternalSubsts` (for within its trait).
+        // If the method can never be called from this object, produce `None`.
+        &*tcx.arena.alloc_from_iter(trait_methods.map(move |trait_method| {
             debug!("vtable_methods: trait_method={:?}", trait_method);
             let def_id = trait_method.def_id;
 
@@ -516,7 +516,7 @@ fn vtable_methods<'tcx>(
             }
 
             Some((def_id, substs))
-        })
+        }))
     }))
 }