Add generics info for structs in type info

Author: SpriteOvO

compiler/rustc_const_eval/src/const_eval/type_info.rs

@@ -4,9 +4,12 @@ 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, AdtDef, AdtKind, Const, GenericArgs, ScalarInt, Ty, VariantDef};
+use rustc_middle::ty::{
+    self, AdtDef, AdtKind, Const, ConstKind, GenericArgKind, GenericArgs, Region, ScalarInt, Ty,
+    VariantDef,
+};
+use rustc_middle::{bug, span_bug};
 use rustc_span::{Symbol, sym};
 
 use crate::const_eval::CompileTimeMachine;
@@ -30,6 +33,37 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
         interp_ok((variant_id, self.project_downcast(place, variant_id)?))
     }
 
+    // A general method to write an array to a static slice place.
+    fn project_write_array(
+        &mut self,
+        slice_place: impl Writeable<'tcx, CtfeProvenance>,
+        len: usize,
+        writer: impl Fn(&mut Self, /* index */ usize, MPlaceTy<'tcx>) -> InterpResult<'tcx>,
+    ) -> InterpResult<'tcx> {
+        // Array element type
+        let field_ty = slice_place
+            .layout()
+            .ty
+            .builtin_deref(false)
+            .unwrap()
+            .sequence_element_type(self.tcx.tcx);
+
+        // Allocate an array
+        let array_layout = self.layout_of(Ty::new_array(self.tcx.tcx, field_ty, len as u64))?;
+        let array_place = self.allocate(array_layout, MemoryKind::Stack)?;
+
+        // Fill the array fields
+        let mut field_places = self.project_array_fields(&array_place)?;
+        while let Some((i, place)) = field_places.next(self)? {
+            writer(self, i as usize, place)?;
+        }
+
+        // Write the slice pointing to the array
+        let array_place = array_place.map_provenance(CtfeProvenance::as_immutable);
+        let ptr = Immediate::new_slice(array_place.ptr(), len as u64, self);
+        self.write_immediate(ptr, &slice_place)
+    }
+
     /// Writes a `core::mem::type_info::TypeInfo` for a given type, `ty` to the given place.
     pub(crate) fn write_type_info(
         &mut self,
@@ -183,6 +217,7 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
         interp_ok(())
     }
 
+    // TODO(type_info): Remove this method, use `project_write_array` as it's more general.
     pub(crate) fn write_tuple_fields(
         &mut self,
         tuple_place: impl Writeable<'tcx, CtfeProvenance>,
@@ -314,6 +349,18 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
             let field_place = self.project_field(&place, field_idx)?;
 
             match field.name {
+                sym::generics => {
+                    self.project_write_array(field_place, generics.len(), |this, i, place| {
+                        match generics[i].kind() {
+                            GenericArgKind::Lifetime(region) => {
+                                this.write_generic_lifetime(region, place)
+                            }
+                            GenericArgKind::Type(ty) => this.write_generic_type(ty, place),
+                            GenericArgKind::Const(c) => this.write_generic_const(c, place),
+                        }
+                    })?;
+                }
+                // TODO(type_info): Use method `project_write_array` as it's more general.
                 sym::fields => {
                     let fields_slice_place = field_place;
                     let field_type = fields_slice_place
@@ -356,6 +403,66 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
         interp_ok(())
     }
 
+    fn write_generic_lifetime(
+        &mut self,
+        _region: Region<'tcx>,
+        place: MPlaceTy<'tcx>,
+    ) -> InterpResult<'tcx> {
+        let (variant_idx, _) = self.downcast(&place, sym::Lifetime)?;
+        self.write_discriminant(variant_idx, &place)?;
+        interp_ok(())
+    }
+
+    fn write_generic_type(&mut self, ty: Ty<'tcx>, place: MPlaceTy<'tcx>) -> InterpResult<'tcx> {
+        let (variant_idx, variant_place) = self.downcast(&place, sym::Type)?;
+        let generic_type_place = self.project_field(&variant_place, FieldIdx::ZERO)?;
+
+        for (field_idx, field_def) in generic_type_place
+            .layout()
+            .ty
+            .ty_adt_def()
+            .unwrap()
+            .non_enum_variant()
+            .fields
+            .iter_enumerated()
+        {
+            let field_place = self.project_field(&generic_type_place, field_idx)?;
+            match field_def.name {
+                sym::ty => self.write_type_id(ty, &field_place)?,
+                other => span_bug!(self.tcx.def_span(field_def.did), "unimplemented field {other}"),
+            }
+        }
+
+        self.write_discriminant(variant_idx, &place)?;
+        interp_ok(())
+    }
+
+    fn write_generic_const(&mut self, c: Const<'tcx>, place: MPlaceTy<'tcx>) -> InterpResult<'tcx> {
+        let ConstKind::Value(c) = c.kind() else { bug!("expected a computed const, got {c:?}") };
+
+        let (variant_idx, variant_place) = self.downcast(&place, sym::Const)?;
+        let const_place = self.project_field(&variant_place, FieldIdx::ZERO)?;
+
+        for (field_idx, field_def) in const_place
+            .layout()
+            .ty
+            .ty_adt_def()
+            .unwrap()
+            .non_enum_variant()
+            .fields
+            .iter_enumerated()
+        {
+            let field_place = self.project_field(&const_place, field_idx)?;
+            match field_def.name {
+                sym::ty => self.write_type_id(c.ty, &field_place)?,
+                other => span_bug!(self.tcx.def_span(field_def.did), "unimplemented field {other}"),
+            }
+        }
+
+        self.write_discriminant(variant_idx, &place)?;
+        interp_ok(())
+    }
+
     fn write_int_type_info(
         &mut self,
         place: impl Writeable<'tcx, CtfeProvenance>,

compiler/rustc_span/src/symbol.rs

@@ -211,6 +211,7 @@ symbols! {
         CoercePointeeValidated,
         CoerceUnsized,
         Command,
+        Const,
         ConstParamTy,
         ConstParamTy_,
         Context,
@@ -290,6 +291,7 @@ symbols! {
         IteratorMap,
         Layout,
         Left,
+        Lifetime,
         LinkedList,
         LintDiagnostic,
         LintPass,
@@ -393,6 +395,7 @@ symbols! {
         Ty,
         TyCtxt,
         TyKind,
+        Type,
         Unknown,
         Unsize,
         UnsizedConstParamTy,
@@ -1080,8 +1083,8 @@ symbols! {
         ffi_pure,
         ffi_returns_twice,
         field,
-        fields,
         field_init_shorthand,
+        fields,
         file,
         file_options,
         flags,
@@ -1170,6 +1173,7 @@ symbols! {
         generic_const_parameter_types,
         generic_param_attrs,
         generic_pattern_types,
+        generics,
         get_context,
         global_alloc_ty,
         global_allocator,

library/core/src/mem/type_info.rs

@@ -101,12 +101,53 @@ pub struct Array {
 #[non_exhaustive]
 #[unstable(feature = "type_info", issue = "146922")]
 pub struct Struct {
+    /// Instantiated generics of the struct.
+    pub generics: &'static [Generic],
     /// All fields of the struct.
     pub fields: &'static [Field],
     /// Whether the struct is non-exhaustive.
     pub non_exhaustive: bool,
 }
 
+/// Compile-time type information about instantiated generics of structs, enum and union variants.
+#[derive(Debug)]
+#[non_exhaustive]
+#[unstable(feature = "type_info", issue = "146922")]
+pub enum Generic {
+    /// Lifetimes.
+    Lifetime(Lifetime),
+    /// Types.
+    Type(GenericType),
+    /// Const parameters.
+    Const(Const),
+}
+
+/// Compile-time type information about generic lifetimes.
+#[derive(Debug)]
+#[non_exhaustive]
+#[unstable(feature = "type_info", issue = "146922")]
+pub struct Lifetime {
+    // No additional information to provide for now.
+}
+
+/// Compile-time type information about instantiated generic types.
+#[derive(Debug)]
+#[non_exhaustive]
+#[unstable(feature = "type_info", issue = "146922")]
+pub struct GenericType {
+    /// The const's type.
+    pub ty: TypeId,
+}
+
+/// Compile-time type information about generic const parameters.
+#[derive(Debug)]
+#[non_exhaustive]
+#[unstable(feature = "type_info", issue = "146922")]
+pub struct Const {
+    /// The const's type.
+    pub ty: TypeId,
+}
+
 /// Compile-time type information about `bool`.
 #[derive(Debug)]
 #[non_exhaustive]

library/coretests/tests/mem/type_info.rs

@@ -71,6 +71,11 @@ fn test_structs() {
         a: u8,
     }
     struct TupleStruct(u8, u16);
+    struct Generics<'a, A, B, const C: u64> {
+        a: A,
+        b: B,
+        l: &'a (), // FIXME(type_info): offset of this field is dumped as 0, which may not be correct
+    }
 
     let Type { kind: Struct(ty), size, .. } = (const { Type::of::<TestStruct>() }) else {
         panic!()
@@ -93,6 +98,20 @@ fn test_structs() {
     assert_eq!(ty.fields.len(), 2);
     assert_eq!(ty.fields[0].name, "0");
     assert_eq!(ty.fields[1].name, "1");
+
+    let Type { kind: Struct(ty), size, .. } =
+        (const { Type::of::<Generics<'static, i32, u32, 1>>() })
+    else {
+        panic!()
+    };
+    assert_eq!(ty.fields.len(), 3);
+    let Generic::Lifetime(_) = ty.generics[0] else { panic!() };
+    let Generic::Type(GenericType { ty: generic_ty }) = ty.generics[1] else { panic!() };
+    let TypeKind::Int(generic_ty) = generic_ty.info().kind else { panic!() };
+    assert_eq!(generic_ty.bits, 32);
+    let Generic::Type(GenericType { ty: generic_ty }) = ty.generics[2] else { panic!() };
+    let TypeKind::Int(generic_ty) = generic_ty.info().kind else { panic!() };
+    assert_eq!(generic_ty.bits, 32);
 }
 
 #[test]

tests/ui/generics/wrong-number-of-args.rs

@@ -127,7 +127,7 @@ mod r#trait {
     //~| HELP remove
 
     type D = Box<dyn GenericType>;
-    //~^ ERROR missing generics for trait `GenericType`
+    //~^ ERROR missing generics for trait `r#trait::GenericType`
     //~| HELP add missing
 
     type E = Box<dyn GenericType<String, usize>>;

tests/ui/generics/wrong-number-of-args.stderr

@@ -469,7 +469,7 @@ note: trait defined here, with 1 lifetime parameter: `'a`
 LL |     trait GenericLifetime<'a> {
    |           ^^^^^^^^^^^^^^^ --
 
-error[E0107]: missing generics for trait `GenericType`
+error[E0107]: missing generics for trait `r#trait::GenericType`
   --> $DIR/wrong-number-of-args.rs:129:22
    |
 LL |     type D = Box<dyn GenericType>;

tests/ui/missing-trait-bounds/issue-69725.stderr

@@ -1,17 +1,17 @@
-error[E0599]: the method `clone` exists for struct `Struct<A>`, but its trait bounds were not satisfied
+error[E0599]: the method `clone` exists for struct `issue_69725::Struct<A>`, but its trait bounds were not satisfied
   --> $DIR/issue-69725.rs:9:32
    |
 LL |     let _ = Struct::<A>::new().clone();
-   |                                ^^^^^ method cannot be called on `Struct<A>` due to unsatisfied trait bounds
+   |                                ^^^^^ method cannot be called on `issue_69725::Struct<A>` due to unsatisfied trait bounds
    |
   ::: $DIR/auxiliary/issue-69725.rs:2:1
    |
 LL | pub struct Struct<A>(A);
-   | -------------------- doesn't satisfy `Struct<A>: Clone`
+   | -------------------- doesn't satisfy `issue_69725::Struct<A>: Clone`
    |
    = note: the following trait bounds were not satisfied:
            `A: Clone`
-           which is required by `Struct<A>: Clone`
+           which is required by `issue_69725::Struct<A>: Clone`
 help: consider restricting the type parameter to satisfy the trait bound
    |
 LL | fn crash<A>() where A: Clone {

tests/ui/reflection/dump.bit32.run.stdout

@@ -148,6 +148,7 @@ Type {
 Type {
     kind: Struct(
         Struct {
+            generics: [],
             fields: [
                 Field {
                     name: "a",
@@ -171,6 +172,7 @@ Type {
 Type {
     kind: Struct(
         Struct {
+            generics: [],
             fields: [
                 Field {
                     name: "a",
@@ -188,6 +190,7 @@ Type {
 Type {
     kind: Struct(
         Struct {
+            generics: [],
             fields: [
                 Field {
                     name: "0",
@@ -207,6 +210,53 @@ Type {
         12,
     ),
 }
+Type {
+    kind: Struct(
+        Struct {
+            generics: [
+                Lifetime(
+                    Lifetime,
+                ),
+                Type(
+                    GenericType {
+                        ty: TypeId(0x56ced5e4a15bd89050bb9674fa2df013),
+                    },
+                ),
+                Type(
+                    GenericType {
+                        ty: TypeId(0x1378bb1c0a0202683eb65e7c11f2e4d7),
+                    },
+                ),
+                Const(
+                    Const {
+                        ty: TypeId(0x9ed91be891e304132cb86891e578f4a5),
+                    },
+                ),
+            ],
+            fields: [
+                Field {
+                    name: "a",
+                    ty: TypeId(0x56ced5e4a15bd89050bb9674fa2df013),
+                    offset: 4,
+                },
+                Field {
+                    name: "b",
+                    ty: TypeId(0x1378bb1c0a0202683eb65e7c11f2e4d7),
+                    offset: 8,
+                },
+                Field {
+                    name: "l",
+                    ty: TypeId(0x5d686ae9be5f6232dca1f88c0b941fd9),
+                    offset: 0,
+                },
+            ],
+            non_exhaustive: false,
+        },
+    ),
+    size: Some(
+        12,
+    ),
+}
 Type {
     kind: Reference(
         Reference {