Support primitives in type info reflection

compiler/rustc_const_eval/src/const_eval/type_info.rs

@@ -1,6 +1,6 @@
 use rustc_abi::FieldIdx;
 use rustc_hir::LangItem;
-use rustc_middle::mir::interpret::CtfeProvenance;
+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};
@@ -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,46 @@ 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)?;
+                            variant
+                        }
+                        ty::Char => {
+                            let (variant, _variant_place) = downcast(sym::Char)?;
+                            variant
+                        }
+                        ty::Int(int_ty) => {
+                            let (variant, variant_place) = downcast(sym::Int)?;
+                            let place = self.project_field(&variant_place, FieldIdx::ZERO)?;
+                            self.write_int_type_info(
+                                place,
+                                int_ty.bit_width().unwrap_or_else(/* isize */ ptr_bit_width),
+                                true,
+                            )?;
+                            variant
+                        }
+                        ty::Uint(uint_ty) => {
+                            let (variant, variant_place) = downcast(sym::Int)?;
+                            let place = self.project_field(&variant_place, FieldIdx::ZERO)?;
+                            self.write_int_type_info(
+                                place,
+                                uint_ty.bit_width().unwrap_or_else(/* usize */ ptr_bit_width),
+                                false,
+                            )?;
+                            variant
+                        }
+                        ty::Float(float_ty) => {
+                            let (variant, variant_place) = downcast(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)?;
+                            variant
                         }
                         ty::Adt(_, _)
                         | ty::Foreign(_)
-                        | ty::Str
                         | ty::Pat(_, _)
                         | ty::Slice(_)
                         | ty::RawPtr(..)
@@ -203,4 +237,46 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
 
         interp_ok(())
     }
+
+    fn write_int_type_info(
+        &mut self,
+        place: impl Writeable<'tcx, CtfeProvenance>,
+        bit_width: u64,
+        signed: bool,
+    ) -> 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::bit_width => self.write_scalar(
+                    ScalarInt::try_from_target_usize(bit_width, self.tcx.tcx).unwrap(),
+                    &field_place,
+                )?,
+                sym::signed => self.write_scalar(Scalar::from_bool(signed), &field_place)?,
+                other => span_bug!(self.tcx.def_span(field.did), "unimplemented field {other}"),
+            }
+        }
+        interp_ok(())
+    }
+
+    fn write_float_type_info(
+        &mut self,
+        place: impl Writeable<'tcx, CtfeProvenance>,
+        bit_width: 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::bit_width => 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,
@@ -584,6 +588,7 @@ symbols! {
         binaryheap_iter,
         bind_by_move_pattern_guards,
         bindings_after_at,
+        bit_width,
         bitand,
         bitand_assign,
         bitor,
@@ -2060,6 +2065,7 @@ symbols! {
         shr_assign,
         sig_dfl,
         sig_ign,
+        signed,
         simd,
         simd_add,
         simd_and,

library/core/src/mem/type_info.rs

@@ -45,9 +45,16 @@ 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 and unsigned integer type.
+    Int(Int),
+    /// Primitive floating-point type.
+    Float(Float),
+    /// String slice type.
+    Str(Str),
     /// FIXME(#146922): add all the common types
     Other,
 }
@@ -82,3 +89,47 @@ 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 {
+    // No additional information to provide for now.
+}
+
+/// Compile-time type information about `char`.
+#[derive(Debug)]
+#[non_exhaustive]
+#[unstable(feature = "type_info", issue = "146922")]
+pub struct Char {
+    // No additional information to provide for now.
+}
+
+/// Compile-time type information about signed and unsigned integer types.
+#[derive(Debug)]
+#[non_exhaustive]
+#[unstable(feature = "type_info", issue = "146922")]
+pub struct Int {
+    /// The bit width of the signed integer type.
+    pub bit_width: usize,
+    /// Whether the integer type is signed.
+    pub signed: bool,
+}
+
+/// Compile-time type information about floating-point types.
+#[derive(Debug)]
+#[non_exhaustive]
+#[unstable(feature = "type_info", issue = "146922")]
+pub struct Float {
+    /// 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 {
+    // No additional information to provide for now.
+}

library/coretests/tests/mem/type_info.rs

@@ -38,19 +38,60 @@ fn test_tuples() {
     assert_tuple_arity::<(u8, u8), 2>();
 
     const {
-        match Type::of::<(u8, u8)>().kind {
+        match Type::of::<(i8, u8)>().kind {
             TypeKind::Tuple(tup) => {
                 let [a, b] = tup.fields else { unreachable!() };
 
                 assert!(a.offset == 0);
                 assert!(b.offset == 1);
 
                 match (a.ty.info().kind, b.ty.info().kind) {
-                    (TypeKind::Leaf, TypeKind::Leaf) => {}
+                    (TypeKind::Int(a), TypeKind::Int(b)) => {
+                        assert!(a.bit_width == 8 && a.signed);
+                        assert!(b.bit_width == 8 && !b.signed);
+                    }
                     _ => 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);
+    assert!(ty.signed);
+
+    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);
+    assert!(ty.signed);
+
+    let Type { kind: Int(ty), size, .. } = (const { Type::of::<u32>() }) else { panic!() };
+    assert_eq!(size, Some(4));
+    assert_eq!(ty.bit_width, 32);
+    assert!(!ty.signed);
+
+    let Type { kind: Int(ty), size, .. } = (const { Type::of::<usize>() }) else { panic!() };
+    assert_eq!(size, Some(size_of::<usize>()));
+    assert_eq!(ty.bit_width, size_of::<usize>() * 8);
+    assert!(!ty.signed);
+
+    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