feat: support pointers in type info

Author: BD103

compiler/rustc_const_eval/src/const_eval/type_info.rs

@@ -1,4 +1,5 @@
 use rustc_abi::FieldIdx;
+use rustc_ast::Mutability;
 use rustc_hir::LangItem;
 use rustc_middle::mir::interpret::CtfeProvenance;
 use rustc_middle::span_bug;
@@ -8,7 +9,7 @@ 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, Scalar, Writeable, interp_ok,
 };
 
 impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
@@ -64,6 +65,15 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
 
                             variant
                         }
+                        ty::RawPtr(ty, mutability) => {
+                            let (variant, variant_place) = downcast(sym::Pointer)?;
+                            let pointer_place =
+                                self.project_field(&variant_place, FieldIdx::ZERO)?;
+
+                            self.write_pointer_type_info(pointer_place, *ty, *mutability)?;
+
+                            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
@@ -73,7 +83,6 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
                         | ty::Str
                         | ty::Pat(_, _)
                         | ty::Slice(_)
-                        | ty::RawPtr(..)
                         | ty::Ref(..)
                         | ty::FnDef(..)
                         | ty::FnPtr(..)
@@ -203,4 +212,30 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
 
         interp_ok(())
     }
+
+    pub(crate) fn write_pointer_type_info(
+        &mut self,
+        place: impl Writeable<'tcx, CtfeProvenance>,
+        ty: Ty<'tcx>,
+        mutability: Mutability,
+    ) -> InterpResult<'tcx> {
+        // Iterate over all fields of `type_info::Pointer`.
+        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 {
+                // Write the `TypeId` of the pointer's inner type to the `ty` field.
+                sym::pointee => self.write_type_id(ty, &field_place)?,
+                // Write the boolean representing the pointer's mutability to the `mutable` field.
+                sym::mutable => {
+                    self.write_scalar(Scalar::from_bool(mutability.is_mut()), &field_place)?
+                }
+                other => span_bug!(self.tcx.def_span(field.did), "unimplemented field {other}"),
+            }
+        }
+
+        interp_ok(())
+    }
 }

compiler/rustc_span/src/symbol.rs

@@ -1515,6 +1515,7 @@ symbols! {
         must_use,
         mut_preserve_binding_mode_2024,
         mut_ref,
+        mutable,
         naked,
         naked_asm,
         naked_functions,

library/core/src/mem/type_info.rs

@@ -45,6 +45,8 @@ pub enum TypeKind {
     Tuple(Tuple),
     /// Arrays.
     Array(Array),
+    /// Pointers.
+    Pointer(Pointer),
     /// Primitives
     /// FIXME(#146922): disambiguate further
     Leaf,
@@ -82,3 +84,14 @@ pub struct Array {
     /// The length of the array.
     pub len: usize,
 }
+
+/// Compile-time type information about pointers.
+#[derive(Debug)]
+#[non_exhaustive]
+#[unstable(feature = "type_info", issue = "146922")]
+pub struct Pointer {
+    /// The type of the value being pointed to.
+    pub pointee: TypeId,
+    /// Whether this pointer is mutable or not.
+    pub mutable: bool,
+}

library/coretests/tests/mem/type_info.rs

@@ -1,4 +1,4 @@
-use std::any::TypeId;
+use std::any::{Any, TypeId};
 use std::mem::type_info::{Type, TypeKind};
 
 #[test]
@@ -54,3 +54,33 @@ fn test_tuples() {
         }
     }
 }
+
+#[test]
+fn test_pointers() {
+    // Immutable pointer.
+    match const { Type::of::<*const u8>() }.kind {
+        TypeKind::Pointer(pointer) => {
+            assert_eq!(pointer.pointee, TypeId::of::<u8>());
+            assert!(!pointer.mutable);
+        }
+        _ => unreachable!(),
+    }
+
+    // Mutable pointer.
+    match const { Type::of::<*mut u64>() }.kind {
+        TypeKind::Pointer(pointer) => {
+            assert_eq!(pointer.pointee, TypeId::of::<u64>());
+            assert!(pointer.mutable);
+        }
+        _ => unreachable!(),
+    }
+
+    // Wide pointer.
+    match const { Type::of::<*const dyn Any>() }.kind {
+        TypeKind::Pointer(pointer) => {
+            assert_eq!(pointer.pointee, TypeId::of::<dyn Any>());
+            assert!(!pointer.mutable);
+        }
+        _ => unreachable!(),
+    }
+}

tests/ui/reflection/dump.rs

@@ -30,4 +30,6 @@ fn main() {
     println!("{:#?}", const { Type::of::<&[u8]>() }.kind);
     println!("{:#?}", const { Type::of::<str>() }.kind);
     println!("{:#?}", const { Type::of::<[u8]>() }.kind);
+    println!("{:#?}", const { Type::of::<*mut u8>() }.kind);
+    println!("{:#?}", const { Type::of::<*const Unsized>() }.kind);
 }

tests/ui/reflection/dump.run.stdout

@@ -29,3 +29,15 @@ Other
 Other
 Other
 Other
+Pointer(
+    Pointer {
+        pointee: TypeId(0x0596b48cc04376e64d5c788c2aa46bdb),
+        mutable: true,
+    },
+)
+Pointer(
+    Pointer {
+        pointee: TypeId(0xda1b6da9bd297bb2900de9303aadea79),
+        mutable: false,
+    },
+)