Support primitives in type info reflection

Support {bool,char,int,uint,float,str} primitive types for feature
`type_info` reflection.

Author: SpriteOvO

compiler/rustc_const_eval/src/const_eval/type_info.rs

@@ -35,6 +35,7 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
 
                 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() {
@@ -64,13 +65,60 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
 
                             variant
                         }
-                        // For now just merge all primitives into one `Leaf` variant with no data
-                        ty::Uint(_) | ty::Int(_) | ty::Float(_) | ty::Char | ty::Bool => {
-                            downcast(sym::Leaf)?.0
+                        ty::Bool => {
+                            let (variant, variant_place) = downcast(sym::Bool)?;
+                            let place = self.project_field(&variant_place, FieldIdx::ZERO)?;
+                            self.write_primitive_type_info(place, ty, None)?;
+                            variant
+                        }
+                        ty::Char => {
+                            let (variant, variant_place) = downcast(sym::Char)?;
+                            let place = self.project_field(&variant_place, FieldIdx::ZERO)?;
+                            self.write_primitive_type_info(place, ty, None)?;
+                            variant
+                        }
+                        ty::Int(int_ty) => {
+                            let (variant, variant_place) = downcast(sym::Int)?;
+                            let place = self.project_field(&variant_place, FieldIdx::ZERO)?;
+                            self.write_primitive_type_info(
+                                place,
+                                ty,
+                                Some(
+                                    int_ty
+                                        .bit_width()
+                                        .unwrap_or_else(/* isize */ ptr_bit_width),
+                                ),
+                            )?;
+                            variant
+                        }
+                        ty::Uint(uint_ty) => {
+                            let (variant, variant_place) = downcast(sym::Uint)?;
+                            let place = self.project_field(&variant_place, FieldIdx::ZERO)?;
+                            self.write_primitive_type_info(
+                                place,
+                                ty,
+                                Some(
+                                    uint_ty
+                                        .bit_width()
+                                        .unwrap_or_else(/* usize */ ptr_bit_width),
+                                ),
+                            )?;
+                            variant
+                        }
+                        ty::Float(float_ty) => {
+                            let (variant, variant_place) = downcast(sym::Float)?;
+                            let place = self.project_field(&variant_place, FieldIdx::ZERO)?;
+                            self.write_primitive_type_info(place, ty, Some(float_ty.bit_width()))?;
+                            variant
+                        }
+                        ty::Str => {
+                            let (variant, variant_place) = downcast(sym::Str)?;
+                            let place = self.project_field(&variant_place, FieldIdx::ZERO)?;
+                            self.write_primitive_type_info(place, ty, None)?;
+                            variant
                         }
                         ty::Adt(_, _)
                         | ty::Foreign(_)
-                        | ty::Str
                         | ty::Pat(_, _)
                         | ty::Slice(_)
                         | ty::RawPtr(..)
@@ -203,4 +251,32 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
 
         interp_ok(())
     }
+
+    // This method always writes to field `ty`.
+    // If field `bit_width` is present, it also writes to it (in which case parameter `write_bit_width` must be `Some`).
+    fn write_primitive_type_info(
+        &mut self,
+        place: impl Writeable<'tcx, CtfeProvenance>,
+        ty: Ty<'tcx>,
+        write_bit_width: Option<u64>,
+    ) -> InterpResult<'tcx> {
+        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::ty => self.write_type_id(ty, &field_place)?,
+                sym::bit_width => {
+                    let bit_width = write_bit_width
+                        .expect("type info struct needs a `bit_width` but none was provided");
+                    self.write_scalar(
+                        ScalarInt::try_from_target_usize(bit_width, self.tcx.tcx).unwrap(),
+                        &field_place,
+                    )?
+                }
+                other => span_bug!(self.tcx.def_span(field.did), "unimplemented field {other}"),
+            }
+        }
+        interp_ok(())
+    }
 }

compiler/rustc_span/src/symbol.rs

@@ -190,6 +190,7 @@ symbols! {
         BTreeMap,
         BTreeSet,
         BinaryHeap,
+        Bool,
         Borrow,
         BorrowMut,
         Break,
@@ -202,6 +203,7 @@ symbols! {
         Capture,
         Cell,
         Center,
+        Char,
         Child,
         Cleanup,
         Clone,
@@ -238,6 +240,7 @@ symbols! {
         Error,
         File,
         FileType,
+        Float,
         FmtArgumentsNew,
         FmtWrite,
         Fn,
@@ -263,6 +266,7 @@ symbols! {
         IndexOutput,
         Input,
         Instant,
+        Int,
         Into,
         IntoFuture,
         IntoIterator,
@@ -285,7 +289,6 @@ symbols! {
         IteratorItem,
         IteratorMap,
         Layout,
-        Leaf,
         Left,
         LinkedList,
         LintDiagnostic,
@@ -363,6 +366,7 @@ symbols! {
         Some,
         SpanCtxt,
         Stdin,
+        Str,
         String,
         StructuralPartialEq,
         SubdiagMessage,
@@ -387,6 +391,7 @@ symbols! {
         Ty,
         TyCtxt,
         TyKind,
+        Uint,
         Unknown,
         Unsize,
         UnsizedConstParamTy,
@@ -584,6 +589,7 @@ symbols! {
         binaryheap_iter,
         bind_by_move_pattern_guards,
         bindings_after_at,
+        bit_width,
         bitand,
         bitand_assign,
         bitor,

library/core/src/mem/type_info.rs

@@ -45,9 +45,18 @@ pub enum TypeKind {
     Tuple(Tuple),
     /// Arrays.
     Array(Array),
-    /// Primitives
-    /// FIXME(#146922): disambiguate further
-    Leaf,
+    /// Primitive boolean type.
+    Bool(Bool),
+    /// Primitive character type.
+    Char(Char),
+    /// Primitive signed integer type.
+    Int(Int),
+    /// Primitive unsigned integer type.
+    Uint(Uint),
+    /// Primitive floating-point type.
+    Float(Float),
+    /// String slice type.
+    Str(Str),
     /// FIXME(#146922): add all the common types
     Other,
 }
@@ -82,3 +91,63 @@ pub struct Array {
     /// The length of the array.
     pub len: usize,
 }
+
+/// Compile-time type information about `bool`.
+#[derive(Debug)]
+#[non_exhaustive]
+#[unstable(feature = "type_info", issue = "146922")]
+pub struct Bool {
+    /// The type id of `bool`.
+    pub ty: TypeId,
+}
+
+/// Compile-time type information about `char`.
+#[derive(Debug)]
+#[non_exhaustive]
+#[unstable(feature = "type_info", issue = "146922")]
+pub struct Char {
+    /// The type id of `char`.
+    pub ty: TypeId,
+}
+
+/// Compile-time type information about signed integer types.
+#[derive(Debug)]
+#[non_exhaustive]
+#[unstable(feature = "type_info", issue = "146922")]
+pub struct Int {
+    /// The type id of signed integer type.
+    pub ty: TypeId,
+    /// The bit width of the signed integer type.
+    pub bit_width: usize,
+}
+
+/// Compile-time type information about unsigned integer types.
+#[derive(Debug)]
+#[non_exhaustive]
+#[unstable(feature = "type_info", issue = "146922")]
+pub struct Uint {
+    /// The type id of unsigned integer type.
+    pub ty: TypeId,
+    /// The bit width of the unsigned integer type.
+    pub bit_width: usize,
+}
+
+/// Compile-time type information about floating-point types.
+#[derive(Debug)]
+#[non_exhaustive]
+#[unstable(feature = "type_info", issue = "146922")]
+pub struct Float {
+    /// The type id of floating-point type.
+    pub ty: TypeId,
+    /// The bit width of the floating-point type.
+    pub bit_width: usize,
+}
+
+/// Compile-time type information about string slice types.
+#[derive(Debug)]
+#[non_exhaustive]
+#[unstable(feature = "type_info", issue = "146922")]
+pub struct Str {
+    /// The type id of `str`.
+    pub ty: TypeId,
+}

library/coretests/tests/mem/type_info.rs

@@ -46,11 +46,48 @@ fn test_tuples() {
                 assert!(b.offset == 1);
 
                 match (a.ty.info().kind, b.ty.info().kind) {
-                    (TypeKind::Leaf, TypeKind::Leaf) => {}
+                    (TypeKind::Uint(a), TypeKind::Uint(b)) => {
+                        assert!(a.bit_width == 8);
+                        assert!(b.bit_width == 8);
+                    }
                     _ => unreachable!(),
                 }
             }
             _ => unreachable!(),
         }
     }
 }
+
+#[test]
+fn test_primitives() {
+    use TypeKind::*;
+
+    let Type { kind: Bool(_ty), size, .. } = (const { Type::of::<bool>() }) else { panic!() };
+    assert_eq!(size, Some(1));
+
+    let Type { kind: Char(_ty), size, .. } = (const { Type::of::<char>() }) else { panic!() };
+    assert_eq!(size, Some(4));
+
+    let Type { kind: Int(ty), size, .. } = (const { Type::of::<i32>() }) else { panic!() };
+    assert_eq!(size, Some(4));
+    assert_eq!(ty.bit_width, 32);
+
+    let Type { kind: Int(ty), size, .. } = (const { Type::of::<isize>() }) else { panic!() };
+    assert_eq!(size, Some(size_of::<isize>()));
+    assert_eq!(ty.bit_width, size_of::<isize>() * 8);
+
+    let Type { kind: Uint(ty), size, .. } = (const { Type::of::<u32>() }) else { panic!() };
+    assert_eq!(size, Some(4));
+    assert_eq!(ty.bit_width, 32);
+
+    let Type { kind: Uint(ty), size, .. } = (const { Type::of::<usize>() }) else { panic!() };
+    assert_eq!(size, Some(size_of::<usize>()));
+    assert_eq!(ty.bit_width, size_of::<usize>() * 8);
+
+    let Type { kind: Float(ty), size, .. } = (const { Type::of::<f32>() }) else { panic!() };
+    assert_eq!(size, Some(4));
+    assert_eq!(ty.bit_width, 32);
+
+    let Type { kind: Str(_ty), size, .. } = (const { Type::of::<str>() }) else { panic!() };
+    assert_eq!(size, None);
+}

tests/mir-opt/const_prop/invalid_constant.main.GVN.diff

@@ -19,7 +19,7 @@
                   debug _enum_without_variants => const [ZeroSized: Empty];
                   let _9: main::Str<"���">;
                   scope 4 {
-                      debug _non_utf8_str => const Str::<"���">;
+                      debug _non_utf8_str => const main::Str::<"���">;
                   }
               }
           }

tests/mir-opt/const_prop/invalid_constant.main.RemoveZsts.diff

@@ -21,7 +21,7 @@
                   let _9: main::Str<"���">;
                   scope 4 {
 -                     debug _non_utf8_str => _9;
-+                     debug _non_utf8_str => const Str::<"���">;
++                     debug _non_utf8_str => const main::Str::<"���">;
                   }
               }
           }

tests/ui/lint/recommend-literal.rs

@@ -1,3 +1,5 @@
+//~vv HELP consider importing this struct
+
 type Real = double;
 //~^ ERROR cannot find type `double` in this scope
 //~| HELP perhaps you intended to use this type