Support structs in type info reflection

Author: SpriteOvO

compiler/rustc_const_eval/src/const_eval/type_info.rs

@@ -1,23 +1,40 @@
-use rustc_abi::FieldIdx;
+use std::borrow::Cow;
+
+use rustc_abi::{FieldIdx, VariantIdx};
 use rustc_ast::Mutability;
 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, AdtDef, AdtKind, Const, GenericArgs, ScalarInt, Ty, VariantDef};
 use rustc_span::{Symbol, sym};
 
 use crate::const_eval::CompileTimeMachine;
 use crate::interpret::{
-    Immediate, InterpCx, InterpResult, MPlaceTy, MemoryKind, Writeable, interp_ok,
+    Immediate, InterpCx, InterpResult, MPlaceTy, MemoryKind, Projectable, Writeable, interp_ok,
 };
 
 impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
+    fn downcast(
+        &self,
+        place: &(impl Writeable<'tcx, CtfeProvenance> + 'tcx),
+        name: Symbol,
+    ) -> InterpResult<'tcx, (VariantIdx, impl Writeable<'tcx, CtfeProvenance> + 'tcx)> {
+        let variants = place.layout().ty.ty_adt_def().unwrap().variants();
+        let variant_id = variants
+            .iter_enumerated()
+            .find(|(_idx, var)| var.name == name)
+            .unwrap_or_else(|| panic!("got {name} but expected one of {variants:#?}"))
+            .0;
+
+        interp_ok((variant_id, self.project_downcast(place, variant_id)?))
+    }
+
     /// Writes a `core::mem::type_info::TypeInfo` for a given type, `ty` to the given place.
     pub(crate) fn write_type_info(
         &mut self,
         ty: Ty<'tcx>,
-        dest: &impl Writeable<'tcx, CtfeProvenance>,
+        dest: &(impl Writeable<'tcx, CtfeProvenance> + 'tcx),
     ) -> InterpResult<'tcx> {
         let ty_struct = self.tcx.require_lang_item(LangItem::Type, self.tcx.span);
         let ty_struct = self.tcx.type_of(ty_struct).no_bound_vars().unwrap();
@@ -26,22 +43,13 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
         // Fill all fields of the `TypeInfo` struct.
         for (idx, field) in ty_struct.fields.iter_enumerated() {
             let field_dest = self.project_field(dest, idx)?;
-            let downcast = |name: Symbol| {
-                let variants = field_dest.layout().ty.ty_adt_def().unwrap().variants();
-                let variant_id = variants
-                    .iter_enumerated()
-                    .find(|(_idx, var)| var.name == name)
-                    .unwrap_or_else(|| panic!("got {name} but expected one of {variants:#?}"))
-                    .0;
-
-                interp_ok((variant_id, self.project_downcast(&field_dest, variant_id)?))
-            };
             let ptr_bit_width = || self.tcx.data_layout.pointer_size().bits();
             match field.name {
                 sym::kind => {
                     let variant_index = match ty.kind() {
                         ty::Tuple(fields) => {
-                            let (variant, variant_place) = downcast(sym::Tuple)?;
+                            let (variant, variant_place) =
+                                self.downcast(&field_dest, sym::Tuple)?;
                             // project to the single tuple variant field of `type_info::Tuple` struct type
                             let tuple_place = self.project_field(&variant_place, FieldIdx::ZERO)?;
                             assert_eq!(
@@ -59,23 +67,38 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
                             variant
                         }
                         ty::Array(ty, len) => {
-                            let (variant, variant_place) = downcast(sym::Array)?;
+                            let (variant, variant_place) =
+                                self.downcast(&field_dest, sym::Array)?;
                             let array_place = self.project_field(&variant_place, FieldIdx::ZERO)?;
 
                             self.write_array_type_info(array_place, *ty, *len)?;
 
                             variant
                         }
+                        ty::Adt(adt_def, generics) => {
+                            // TODO(type_info): Handle enum and union
+                            if !adt_def.is_struct() {
+                                self.downcast(&field_dest, sym::Other)?.0
+                            } else {
+                                let (variant, variant_place) =
+                                    self.downcast(&field_dest, sym::Struct)?;
+                                let place = self.project_field(&variant_place, FieldIdx::ZERO)?;
+                                self.write_adt_type_info(place, (ty, *adt_def), generics)?;
+                                variant
+                            }
+                        }
                         ty::Bool => {
-                            let (variant, _variant_place) = downcast(sym::Bool)?;
+                            let (variant, _variant_place) =
+                                self.downcast(&field_dest, sym::Bool)?;
                             variant
                         }
                         ty::Char => {
-                            let (variant, _variant_place) = downcast(sym::Char)?;
+                            let (variant, _variant_place) =
+                                self.downcast(&field_dest, sym::Char)?;
                             variant
                         }
                         ty::Int(int_ty) => {
-                            let (variant, variant_place) = downcast(sym::Int)?;
+                            let (variant, variant_place) = self.downcast(&field_dest, sym::Int)?;
                             let place = self.project_field(&variant_place, FieldIdx::ZERO)?;
                             self.write_int_type_info(
                                 place,
@@ -85,7 +108,7 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
                             variant
                         }
                         ty::Uint(uint_ty) => {
-                            let (variant, variant_place) = downcast(sym::Int)?;
+                            let (variant, variant_place) = self.downcast(&field_dest, sym::Int)?;
                             let place = self.project_field(&variant_place, FieldIdx::ZERO)?;
                             self.write_int_type_info(
                                 place,
@@ -95,25 +118,26 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
                             variant
                         }
                         ty::Float(float_ty) => {
-                            let (variant, variant_place) = downcast(sym::Float)?;
+                            let (variant, variant_place) =
+                                self.downcast(&field_dest, sym::Float)?;
                             let place = self.project_field(&variant_place, FieldIdx::ZERO)?;
                             self.write_float_type_info(place, float_ty.bit_width())?;
                             variant
                         }
                         ty::Str => {
-                            let (variant, _variant_place) = downcast(sym::Str)?;
+                            let (variant, _variant_place) = self.downcast(&field_dest, sym::Str)?;
                             variant
                         }
                         ty::Ref(_, ty, mutability) => {
-                            let (variant, variant_place) = downcast(sym::Reference)?;
+                            let (variant, variant_place) =
+                                self.downcast(&field_dest, sym::Reference)?;
                             let reference_place =
                                 self.project_field(&variant_place, FieldIdx::ZERO)?;
                             self.write_reference_type_info(reference_place, *ty, *mutability)?;
 
                             variant
                         }
-                        ty::Adt(_, _)
-                        | ty::Foreign(_)
+                        ty::Foreign(_)
                         | ty::Pat(_, _)
                         | ty::Slice(_)
                         | ty::RawPtr(..)
@@ -131,14 +155,14 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
                         | ty::Bound(..)
                         | ty::Placeholder(_)
                         | ty::Infer(..)
-                        | ty::Error(_) => downcast(sym::Other)?.0,
+                        | ty::Error(_) => self.downcast(&field_dest, sym::Other)?.0,
                     };
                     self.write_discriminant(variant_index, &field_dest)?
                 }
                 sym::size => {
                     let layout = self.layout_of(ty)?;
                     let variant_index = if layout.is_sized() {
-                        let (variant, variant_place) = downcast(sym::Some)?;
+                        let (variant, variant_place) = self.downcast(&field_dest, sym::Some)?;
                         let size_field_place =
                             self.project_field(&variant_place, FieldIdx::ZERO)?;
                         self.write_scalar(
@@ -148,7 +172,7 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
                         )?;
                         variant
                     } else {
-                        downcast(sym::None)?.0
+                        self.downcast(&field_dest, sym::None)?.0
                     };
                     self.write_discriminant(variant_index, &field_dest)?;
                 }
@@ -184,7 +208,7 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
 
         while let Some((i, place)) = fields_places.next(self)? {
             let field_ty = fields[i as usize];
-            self.write_field(field_ty, place, tuple_layout, i)?;
+            self.write_field(field_ty, place, tuple_layout, None, i)?;
         }
 
         let fields_place = fields_place.map_provenance(CtfeProvenance::as_immutable);
@@ -199,13 +223,23 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
         field_ty: Ty<'tcx>,
         place: MPlaceTy<'tcx>,
         layout: TyAndLayout<'tcx>,
+        name: Option<Symbol>,
         idx: u64,
     ) -> InterpResult<'tcx> {
         for (field_idx, field_ty_field) in
             place.layout.ty.ty_adt_def().unwrap().non_enum_variant().fields.iter_enumerated()
         {
             let field_place = self.project_field(&place, field_idx)?;
             match field_ty_field.name {
+                sym::name => {
+                    let name = match name.as_ref() {
+                        Some(name) => Cow::Borrowed(name.as_str()),
+                        None => Cow::Owned(idx.to_string()), // For tuples
+                    };
+                    let name_place = self.allocate_str_dedup(&name)?;
+                    let ptr = self.mplace_to_ref(&name_place)?;
+                    self.write_immediate(*ptr, &field_place)?
+                }
                 sym::ty => self.write_type_id(field_ty, &field_place)?,
                 sym::offset => {
                     let offset = layout.fields.offset(idx as usize);
@@ -246,6 +280,82 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
         interp_ok(())
     }
 
+    // FIXME(type_info): No semver considerations for now
+    pub(crate) fn write_adt_type_info(
+        &mut self,
+        place: impl Writeable<'tcx, CtfeProvenance>,
+        adt: (Ty<'tcx>, AdtDef<'tcx>),
+        generics: &'tcx GenericArgs<'tcx>,
+    ) -> InterpResult<'tcx> {
+        let (adt_ty, adt_def) = adt;
+        match adt_def.adt_kind() {
+            AdtKind::Struct => self.write_struct_type_info(
+                place,
+                (adt_ty, adt_def.variant(VariantIdx::ZERO)),
+                generics,
+            ),
+            AdtKind::Union => todo!(),
+            AdtKind::Enum => todo!(),
+        }
+    }
+
+    pub(crate) fn write_struct_type_info(
+        &mut self,
+        place: impl Writeable<'tcx, CtfeProvenance>,
+        struct_: (Ty<'tcx>, &'tcx VariantDef),
+        generics: &'tcx GenericArgs<'tcx>,
+    ) -> InterpResult<'tcx> {
+        let (struct_ty, struct_def) = struct_;
+        let struct_layout = self.layout_of(struct_ty)?;
+
+        for (field_idx, field) in
+            place.layout().ty.ty_adt_def().unwrap().non_enum_variant().fields.iter_enumerated()
+        {
+            let field_place = self.project_field(&place, field_idx)?;
+
+            match field.name {
+                sym::fields => {
+                    let fields_slice_place = field_place;
+                    let field_type = fields_slice_place
+                        .layout()
+                        .ty
+                        .builtin_deref(false)
+                        .unwrap()
+                        .sequence_element_type(self.tcx.tcx);
+                    let fields_layout = self.layout_of(Ty::new_array(
+                        self.tcx.tcx,
+                        field_type,
+                        struct_def.fields.len() as u64,
+                    ))?;
+                    let fields_place = self.allocate(fields_layout, MemoryKind::Stack)?;
+                    let mut fields_places = self.project_array_fields(&fields_place)?;
+
+                    for field_def in &struct_def.fields {
+                        let (i, place) = fields_places.next(self)?.unwrap();
+                        let field_ty = field_def.ty(*self.tcx, generics);
+                        self.write_field(field_ty, place, struct_layout, Some(field_def.name), i)?;
+                    }
+
+                    let fields_place = fields_place.map_provenance(CtfeProvenance::as_immutable);
+                    let ptr = Immediate::new_slice(
+                        fields_place.ptr(),
+                        struct_def.fields.len() as u64,
+                        self,
+                    );
+                    self.write_immediate(ptr, &fields_slice_place)?
+                }
+                sym::non_exhaustive => {
+                    let is_non_exhaustive = struct_def.is_field_list_non_exhaustive();
+                    self.write_scalar(Scalar::from_bool(is_non_exhaustive), &field_place)?
+                }
+                // TODO(type_info): Write more info
+                other => span_bug!(self.tcx.def_span(field.did), "unimplemented field {other}"),
+            }
+        }
+
+        interp_ok(())
+    }
+
     fn write_int_type_info(
         &mut self,
         place: impl Writeable<'tcx, CtfeProvenance>,

compiler/rustc_span/src/symbol.rs

@@ -369,6 +369,7 @@ symbols! {
         Stdin,
         Str,
         String,
+        Struct,
         StructuralPartialEq,
         SubdiagMessage,
         Subdiagnostic,
@@ -1079,6 +1080,7 @@ symbols! {
         ffi_pure,
         ffi_returns_twice,
         field,
+        fields,
         field_init_shorthand,
         file,
         file_options,

library/core/src/mem/type_info.rs

@@ -45,6 +45,8 @@ pub enum TypeKind {
     Tuple(Tuple),
     /// Arrays.
     Array(Array),
+    /// Structs.
+    Struct(Struct),
     /// Primitive boolean type.
     Bool(Bool),
     /// Primitive character type.
@@ -75,6 +77,8 @@ pub struct Tuple {
 #[non_exhaustive]
 #[unstable(feature = "type_info", issue = "146922")]
 pub struct Field {
+    /// The name of the field.
+    pub name: &'static str,
     /// The field's type.
     pub ty: TypeId,
     /// Offset in bytes from the parent type
@@ -92,6 +96,17 @@ pub struct Array {
     pub len: usize,
 }
 
+/// Compile-time type information about arrays.
+#[derive(Debug)]
+#[non_exhaustive]
+#[unstable(feature = "type_info", issue = "146922")]
+pub struct Struct {
+    /// All fields of the struct.
+    pub fields: &'static [Field],
+    /// Whether the struct is non-exhaustive.
+    pub non_exhaustive: bool,
+}
+
 /// Compile-time type information about `bool`.
 #[derive(Debug)]
 #[non_exhaustive]

library/coretests/tests/mem/type_info.rs

@@ -58,6 +58,43 @@ fn test_tuples() {
     }
 }
 
+#[test]
+fn test_structs() {
+    use TypeKind::*;
+
+    struct TestStruct {
+        first: u8,
+        second: u16,
+    }
+    #[non_exhaustive]
+    struct NonExhaustive {
+        a: u8,
+    }
+    struct TupleStruct(u8, u16);
+
+    let Type { kind: Struct(ty), size, .. } = (const { Type::of::<TestStruct>() }) else {
+        panic!()
+    };
+    assert_eq!(size, Some(size_of::<TestStruct>()));
+    assert!(!ty.non_exhaustive);
+    assert_eq!(ty.fields.len(), 2);
+    assert_eq!(ty.fields[0].name, "first");
+    assert_eq!(ty.fields[1].name, "second");
+
+    let Type { kind: Struct(ty), size, .. } = (const { Type::of::<NonExhaustive>() }) else {
+        panic!()
+    };
+    assert_eq!(size, Some(1));
+    assert!(ty.non_exhaustive);
+
+    let Type { kind: Struct(ty), size, .. } = (const { Type::of::<TupleStruct>() }) else {
+        panic!()
+    };
+    assert_eq!(ty.fields.len(), 2);
+    assert_eq!(ty.fields[0].name, "0");
+    assert_eq!(ty.fields[1].name, "1");
+}
+
 #[test]
 fn test_primitives() {
     use TypeKind::*;