Add support for trait object types in type_info reflection

Author: izagawd

compiler/rustc_const_eval/src/const_eval/type_info.rs

@@ -4,7 +4,8 @@ use rustc_hir::LangItem;
 use rustc_middle::mir::interpret::{CtfeProvenance, Scalar};
 use rustc_middle::span_bug;
 use rustc_middle::ty::layout::TyAndLayout;
-use rustc_middle::ty::{self, Const, ScalarInt, Ty};
+use rustc_middle::ty::{self, Const, Region, ScalarInt, Ty};
+use rustc_span::def_id::DefId;
 use rustc_span::{Symbol, sym};
 
 use crate::const_eval::CompileTimeMachine;
@@ -112,6 +113,12 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
 
                             variant
                         }
+                        ty::Dynamic(predicates, region) => {
+                            let (variant, variant_place) = downcast(sym::DynTrait)?;
+                            let dyn_place = self.project_field(&variant_place, FieldIdx::ZERO)?;
+                            self.write_dyn_trait_type_info(dyn_place, *predicates, *region)?;
+                            variant
+                        }
                         ty::Adt(_, _)
                         | ty::Foreign(_)
                         | ty::Pat(_, _)
@@ -120,7 +127,6 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
                         | ty::FnDef(..)
                         | ty::FnPtr(..)
                         | ty::UnsafeBinder(..)
-                        | ty::Dynamic(..)
                         | ty::Closure(..)
                         | ty::CoroutineClosure(..)
                         | ty::Coroutine(..)
@@ -159,6 +165,140 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
         interp_ok(())
     }
 
+    fn write_dyn_trait_type_info(
+        &mut self,
+        dyn_place: impl Writeable<'tcx, CtfeProvenance>,
+        data: &'tcx ty::List<ty::Binder<'tcx, ty::ExistentialPredicate<'tcx>>>,
+        region: Region<'tcx>,
+    ) -> InterpResult<'tcx> {
+        let tcx = self.tcx.tcx;
+
+        // Find the principal trait ref (for super trait collection), collect auto traits,
+        // and collect all projection predicates (used when computing TypeId for each supertrait).
+        let mut principal: Option<ty::Binder<'tcx, ty::ExistentialTraitRef<'tcx>>> = None;
+        let mut auto_traits_def_ids: Vec<ty::Binder<'tcx, DefId>> = Vec::new();
+        let mut projections: Vec<ty::Binder<'tcx, ty::ExistentialProjection<'tcx>>> = Vec::new();
+
+        for b in data.iter() {
+            match b.skip_binder() {
+                ty::ExistentialPredicate::Trait(tr) => principal = Some(b.rebind(tr)),
+                ty::ExistentialPredicate::AutoTrait(did) => auto_traits_def_ids.push(b.rebind(did)),
+                ty::ExistentialPredicate::Projection(p) => projections.push(b.rebind(p)),
+            }
+        }
+
+        // This is to make principal dyn type include Trait and projection predicates, excluding auto traits.
+        let principal_ty: Option<Ty<'tcx>> = principal.map(|_tr| {
+            let preds = tcx
+                .mk_poly_existential_predicates_from_iter(data.iter().filter(|b| {
+                    !matches!(b.skip_binder(), ty::ExistentialPredicate::AutoTrait(_))
+                }));
+            Ty::new_dynamic(tcx, preds, region)
+        });
+
+        // DynTrait { predicates: &'static [Trait] }
+        for (field_idx, field) in
+            dyn_place.layout().ty.ty_adt_def().unwrap().non_enum_variant().fields.iter_enumerated()
+        {
+            let field_place = self.project_field(&dyn_place, field_idx)?;
+            match field.name {
+                sym::predicates => {
+                    self.write_dyn_trait_predicates_slice(
+                        &field_place,
+                        principal_ty,
+                        &auto_traits_def_ids,
+                        region,
+                    )?;
+                }
+                other => {
+                    span_bug!(self.tcx.def_span(field.did), "unimplemented DynTrait field {other}")
+                }
+            }
+        }
+
+        interp_ok(())
+    }
+
+    fn mk_dyn_principal_auto_trait_ty(
+        &self,
+        auto_trait_def_id: ty::Binder<'tcx, DefId>,
+        region: Region<'tcx>,
+    ) -> Ty<'tcx> {
+        let tcx = self.tcx.tcx;
+
+        // Preserve the binder vars from the original auto-trait predicate.
+        let pred_inner = ty::ExistentialPredicate::AutoTrait(auto_trait_def_id.skip_binder());
+        let pred = ty::Binder::bind_with_vars(pred_inner, auto_trait_def_id.bound_vars());
+
+        let preds = tcx.mk_poly_existential_predicates_from_iter([pred].into_iter());
+        Ty::new_dynamic(tcx, preds, region)
+    }
+
+    fn write_dyn_trait_predicates_slice(
+        &mut self,
+        slice_place: &impl Writeable<'tcx, CtfeProvenance>,
+        principal_ty: Option<Ty<'tcx>>,
+        auto_trait_def_ids: &[ty::Binder<'tcx, DefId>],
+        region: Region<'tcx>,
+    ) -> InterpResult<'tcx> {
+        let tcx = self.tcx.tcx;
+
+        // total entries in DynTrait predicates
+        let total_len = principal_ty.map(|_| 1).unwrap_or(0) + auto_trait_def_ids.len();
+
+        // element type = Trait
+        let slice_ty = slice_place.layout().ty.builtin_deref(false).unwrap(); // [Trait]
+        let elem_ty = slice_ty.sequence_element_type(tcx); // Trait
+
+        let arr_layout = self.layout_of(Ty::new_array(tcx, elem_ty, total_len as u64))?;
+        let arr_place = self.allocate(arr_layout, MemoryKind::Stack)?;
+        let mut elems = self.project_array_fields(&arr_place)?;
+
+        // principal entry (if any)
+        if let Some(principal_ty) = principal_ty {
+            let Some((_i, elem_place)) = elems.next(self)? else {
+                span_bug!(self.tcx.span, "DynTrait.predicates length computed wrong (principal)");
+            };
+            self.write_dyn_trait_trait(elem_place, principal_ty, false)?;
+        }
+
+        // auto trait entries
+        for auto in auto_trait_def_ids {
+            let Some((_i, elem_place)) = elems.next(self)? else {
+                span_bug!(self.tcx.span, "DynTrait.predicates length computed wrong (auto)");
+            };
+            let auto_ty = self.mk_dyn_principal_auto_trait_ty(*auto, region);
+            self.write_dyn_trait_trait(elem_place, auto_ty, true)?;
+        }
+        let arr_place = arr_place.map_provenance(CtfeProvenance::as_immutable);
+        let imm = Immediate::new_slice(arr_place.ptr(), total_len as u64, self);
+        self.write_immediate(imm, slice_place)
+    }
+
+    fn write_dyn_trait_trait(
+        &mut self,
+        trait_place: MPlaceTy<'tcx>,
+        trait_ty: Ty<'tcx>,
+        is_auto: bool,
+    ) -> InterpResult<'tcx> {
+        // Trait { super_traits: &'static [TypeId], is_auto: bool }
+        for (field_idx, field) in
+            trait_place.layout.ty.ty_adt_def().unwrap().non_enum_variant().fields.iter_enumerated()
+        {
+            let field_place = self.project_field(&trait_place, field_idx)?;
+            match field.name {
+                sym::ty => {
+                    self.write_type_id(trait_ty, &field_place)?;
+                }
+                sym::is_auto => self.write_scalar(Scalar::from_bool(is_auto), &field_place)?,
+                other => {
+                    span_bug!(self.tcx.def_span(field.did), "unimplemented Trait field {other}")
+                }
+            }
+        }
+        interp_ok(())
+    }
+
     pub(crate) fn write_tuple_fields(
         &mut self,
         tuple_place: impl Writeable<'tcx, CtfeProvenance>,

compiler/rustc_span/src/symbol.rs

@@ -186,6 +186,7 @@ symbols! {
         AtomicU64,
         AtomicU128,
         AtomicUsize,
+        AutoTrait,
         BTreeEntry,
         BTreeMap,
         BTreeSet,
@@ -231,6 +232,7 @@ symbols! {
         Display,
         DoubleEndedIterator,
         Duration,
+        DynTrait,
         Encodable,
         Encoder,
         Enumerate,
@@ -1294,6 +1296,7 @@ symbols! {
         io_stdout,
         irrefutable_let_patterns,
         is,
+        is_auto,
         is_val_statically_known,
         isa_attribute,
         isize,
@@ -1747,6 +1750,7 @@ symbols! {
         precise_capturing_in_traits,
         precise_pointer_size_matching,
         precision,
+        predicates,
         pref_align_of,
         prefetch_read_data,
         prefetch_read_instruction,

library/core/src/mem/type_info.rs

@@ -45,6 +45,8 @@ pub enum TypeKind {
     Tuple(Tuple),
     /// Arrays.
     Array(Array),
+    /// Dynamic Traits.
+    DynTrait(DynTrait),
     /// Primitive boolean type.
     Bool(Bool),
     /// Primitive character type.
@@ -92,6 +94,26 @@ pub struct Array {
     pub len: usize,
 }
 
+/// Compile-time type information about dynamic traits.
+#[derive(Debug)]
+#[non_exhaustive]
+#[unstable(feature = "type_info", issue = "146922")]
+pub struct DynTrait {
+    /// The predicates of  a dynamic trait.
+    pub predicates: &'static [DynTraitPredicate],
+}
+
+/// Compile-time type information about a dynamic trait.
+#[derive(Debug)]
+#[non_exhaustive]
+#[unstable(feature = "type_info", issue = "146922")]
+pub struct DynTraitPredicate {
+    /// The type of the trait as a dynamic trait type.
+    pub ty: TypeId,
+    /// Whether the trait is an auto trait
+    pub is_auto: bool,
+}
+
 /// Compile-time type information about `bool`.
 #[derive(Debug)]
 #[non_exhaustive]

library/coretests/tests/mem/type_info.rs

@@ -125,3 +125,132 @@ fn test_references() {
         _ => unreachable!(),
     }
 }
+
+#[test]
+fn test_dynamic_traits() {
+    use std::collections::HashSet;
+    use std::mem::type_info::DynTraitPredicate;
+    trait A<T> {}
+
+    trait B<const CONST_NUM: i32> {
+        type Foo;
+    }
+
+    trait ProjectorTrait<'a, 'b> {}
+
+    trait FooTrait<'a, 'b, const CONST_NUM: i32> {}
+
+    fn preds_of<T: ?Sized + 'static>() -> &'static [DynTraitPredicate] {
+        match const { Type::of::<T>() }.kind {
+            TypeKind::DynTrait(d) => d.predicates,
+            _ => unreachable!(),
+        }
+    }
+
+    fn pred<'a>(preds: &'a [DynTraitPredicate], want: TypeId) -> &'a DynTraitPredicate {
+        preds
+            .iter()
+            .find(|p| p.ty == want)
+            .unwrap_or_else(|| panic!("missing predicate for {want:?}"))
+    }
+
+    fn assert_typeid_set_eq(actual: &[TypeId], expected: &[TypeId]) {
+        let actual_set: HashSet<TypeId> = actual.iter().copied().collect();
+        let expected_set: HashSet<TypeId> = expected.iter().copied().collect();
+        assert_eq!(actual.len(), actual_set.len(), "duplicates present: {actual:?}");
+        assert_eq!(
+            actual_set, expected_set,
+            "unexpected ids.\nactual: {actual:?}\nexpected: {expected:?}"
+        );
+    }
+
+    fn assert_predicates_exact(preds: &[DynTraitPredicate], expected_pred_ids: &[TypeId]) {
+        let actual_pred_ids: Vec<TypeId> = preds.iter().map(|p| p.ty).collect();
+        assert_typeid_set_eq(&actual_pred_ids, expected_pred_ids);
+    }
+
+    // dyn Send
+    {
+        let preds = preds_of::<dyn Send>();
+        assert_predicates_exact(preds, &[TypeId::of::<dyn Send>()]);
+
+        let p = pred(preds, TypeId::of::<dyn Send>());
+        assert!(p.is_auto);
+    }
+
+    // dyn A<i32>
+    {
+        let preds = preds_of::<dyn A<i32>>();
+        assert_predicates_exact(preds, &[TypeId::of::<dyn A<i32>>()]);
+
+        let p = pred(preds, TypeId::of::<dyn A<i32>>());
+        assert!(!p.is_auto);
+    }
+
+    // dyn B<5, Foo = i32>
+    {
+        let preds = preds_of::<dyn B<5, Foo = i32>>();
+        assert_predicates_exact(preds, &[TypeId::of::<dyn B<5, Foo = i32>>()]);
+
+        let e = pred(preds, TypeId::of::<dyn B<5, Foo = i32>>());
+        assert!(!e.is_auto);
+    }
+
+    // dyn for<'a> FooTrait<'a, 'a, 7>
+    {
+        let preds = preds_of::<dyn for<'a> FooTrait<'a, 'a, 7>>();
+        assert_predicates_exact(preds, &[TypeId::of::<dyn for<'a> FooTrait<'a, 'a, 7>>()]);
+
+        let foo = pred(preds, TypeId::of::<dyn for<'a> FooTrait<'a, 'a, 7>>());
+        assert!(!foo.is_auto);
+    }
+
+    // dyn FooTrait<'static, 'static, 7>
+    {
+        let preds = preds_of::<dyn FooTrait<'static, 'static, 7>>();
+        assert_predicates_exact(preds, &[TypeId::of::<dyn FooTrait<'static, 'static, 7>>()]);
+
+        let foo = pred(preds, TypeId::of::<dyn FooTrait<'static, 'static, 7>>());
+        assert!(!foo.is_auto);
+    }
+
+    // dyn for<'a, 'b> FooTrait<'a, 'b, 7>
+    {
+        let preds = preds_of::<dyn for<'a, 'b> FooTrait<'a, 'b, 7>>();
+        assert_predicates_exact(preds, &[TypeId::of::<dyn for<'a, 'b> FooTrait<'a, 'b, 7>>()]);
+
+        let foo = pred(preds, TypeId::of::<dyn for<'a, 'b> FooTrait<'a, 'b, 7>>());
+        assert!(!foo.is_auto);
+    }
+
+    // dyn for<'a, 'b> ProjectorTrait<'a, 'b>
+    {
+        let preds = preds_of::<dyn for<'a, 'b> ProjectorTrait<'a, 'b>>();
+        assert_predicates_exact(preds, &[TypeId::of::<dyn for<'a, 'b> ProjectorTrait<'a, 'b>>()]);
+
+        let proj = pred(preds, TypeId::of::<dyn for<'a, 'b> ProjectorTrait<'a, 'b>>());
+        assert!(!proj.is_auto);
+    }
+
+    // dyn for<'a> FooTrait<'a, 'a, 7> + Send + Sync
+    {
+        let preds = preds_of::<dyn for<'a> FooTrait<'a, 'a, 7> + Send + Sync>();
+        assert_predicates_exact(
+            preds,
+            &[
+                TypeId::of::<dyn for<'a> FooTrait<'a, 'a, 7>>(),
+                TypeId::of::<dyn Send>(),
+                TypeId::of::<dyn Sync>(),
+            ],
+        );
+
+        let foo = pred(preds, TypeId::of::<dyn for<'a> FooTrait<'a, 'a, 7>>());
+        assert!(!foo.is_auto);
+
+        let send = pred(preds, TypeId::of::<dyn Send>());
+        assert!(send.is_auto);
+
+        let sync = pred(preds, TypeId::of::<dyn Sync>());
+        assert!(sync.is_auto);
+    }
+}