feat!: remove bool, char, and str variants from TypeKind

Author: BD103

compiler/rustc_const_eval/src/const_eval/type_info.rs

@@ -74,14 +74,6 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
 
                             variant
                         }
-                        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)?;
@@ -108,10 +100,6 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
                             self.write_float_type_info(place, float_ty.bit_width())?;
                             variant
                         }
-                        ty::Str => {
-                            let (variant, _variant_place) = downcast(sym::Str)?;
-                            variant
-                        }
                         ty::Ref(_, ty, mutability) => {
                             let (variant, variant_place) = downcast(sym::Reference)?;
                             let reference_place =
@@ -136,6 +124,9 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
                             variant
                         }
                         ty::Adt(_, _)
+                        | ty::Bool
+                        | ty::Char
+                        | ty::Str
                         | ty::Foreign(_)
                         | ty::Pat(_, _)
                         | ty::FnDef(..)

library/core/src/mem/type_info.rs

@@ -49,16 +49,10 @@ pub enum TypeKind {
     Slice(Slice),
     /// Dynamic Traits.
     DynTrait(DynTrait),
-    /// 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),
     /// References.
     Reference(Reference),
     /// Pointers.
@@ -137,22 +131,6 @@ pub struct Trait {
     pub is_auto: bool,
 }
 
-/// 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]
@@ -173,14 +151,6 @@ pub struct Float {
     pub bits: u32,
 }
 
-/// 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.
-}
-
 /// Compile-time type information about references.
 #[derive(Debug)]
 #[non_exhaustive]

library/coretests/tests/mem/type_info.rs

@@ -70,10 +70,10 @@ fn test_tuples() {
 fn test_primitives() {
     use TypeKind::*;
 
-    let Type { kind: Bool(_ty), size, .. } = (const { Type::of::<bool>() }) else { panic!() };
+    let Type { kind: Other, size, .. } = (const { Type::of::<bool>() }) else { panic!() };
     assert_eq!(size, Some(1));
 
-    let Type { kind: Char(_ty), size, .. } = (const { Type::of::<char>() }) else { panic!() };
+    let Type { kind: Other, size, .. } = (const { Type::of::<char>() }) else { panic!() };
     assert_eq!(size, Some(4));
 
     let Type { kind: Int(ty), size, .. } = (const { Type::of::<i32>() }) else { panic!() };
@@ -100,7 +100,7 @@ fn test_primitives() {
     assert_eq!(size, Some(4));
     assert_eq!(ty.bits, 32);
 
-    let Type { kind: Str(_ty), size, .. } = (const { Type::of::<str>() }) else { panic!() };
+    let Type { kind: Other, size, .. } = (const { Type::of::<str>() }) else { panic!() };
     assert_eq!(size, None);
 }