reflection: add coretests for variant_getter

Author: yara-blue

compiler/rustc_const_eval/src/const_eval/type_info/adt.rs

@@ -15,26 +15,25 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
         place: &impl Writeable<'tcx, CtfeProvenance>,
         ty: Ty<'tcx>,
     ) -> InterpResult<'tcx, ()> {
-        // a discriminant is an int of some size (up to 128bits or 127... ?) // TODO(yara) figure out
         let cast_to = ty.discriminant_ty(*self.tcx);
         let discriminant_size = cast_to.primitive_size(*self.tcx);
 
-        let ty::Adt(def, _) = ty.kind() else {
-            span_bug!(self.cur_span(), "expected enum type, got {ty}");
+        let num_variants = if let ty::Adt(def, _) = ty.kind()
+            && def.is_enum()
+        {
+            def.variants().len() as u64
+        } else {
+            0
         };
-        self.allocate_fill_and_write_slice_ptr(
-            place,
-            def.variants().len() as u64,
-            |this, i, place| {
-                let discriminant = ty
-                    .discriminant_for_variant(*this.tcx, VariantIdx::from_usize(i as usize))
-                    .expect("i is in range")
-                    .val;
-                let discriminant = ScalarInt::try_from_uint(discriminant, discriminant_size)
-                    .expect("127 bits should be enough discriminant"); // TODO(yara): test this
-                this.write_scalar(discriminant, &place)
-            },
-        )
+        self.allocate_fill_and_write_slice_ptr(place, num_variants, |this, i, place| {
+            let discriminant = ty
+                .discriminant_for_variant(*this.tcx, VariantIdx::from_usize(i as usize))
+                .expect("i is in range")
+                .val;
+            let discriminant = ScalarInt::try_from_uint(discriminant, discriminant_size)
+                .expect("discriminant ty fits the current value");
+            this.write_scalar(discriminant, &place)
+        })
     }
 
     // FIXME(type_info): No semver considerations for now

compiler/rustc_hir_analysis/src/check/intrinsic.rs

@@ -319,7 +319,7 @@ pub(crate) fn check_intrinsic_type(
             let variant_id =
                 tcx.type_of(tcx.lang_items().variant_id().unwrap()).no_bound_vars().unwrap();
             let unit_ptr = Ty::new_ptr(tcx, tcx.types.unit, ty::Mutability::Not);
-            let fn_ty = ty::Binder::dummy(tcx.mk_fn_sig_safe_rust_abi([unit_ptr], variant_id));
+            let fn_ty = ty::Binder::dummy(tcx.mk_fn_sig_unsafe_rust_abi([unit_ptr], variant_id));
             (0, 0, vec![type_id_ty()], Ty::new_fn_ptr(tcx, fn_ty))
         }
         sym::type_id_variant_lookup_table => {

library/core/src/intrinsics/reflection.rs

@@ -236,10 +236,12 @@ pub fn type_id_name(_type_id: crate::any::TypeId) -> &'static str;
 #[rustc_intrinsic]
 #[unstable(feature = "core_intrinsics", issue = "none")]
 #[rustc_comptime]
-pub fn type_id_variant_getter(_type_id: crate::any::TypeId) -> fn(*const ()) -> VariantId;
+pub fn type_id_variant_getter(_type_id: crate::any::TypeId) -> unsafe fn(*const ()) -> VariantId;
 
-/// Returns a lookup table for converting between VariantId and Discriminant. This
-/// is use internally by variant getter. **Please do not use this.**
+/// **Please do not use this intrinsic directly.**
+///
+/// This returns a lookup table for converting between VariantId and Discriminant. This is use
+/// internally by [`variant_getter`](core::any::TypeId::variant_getter).
 ///
 /// The user-friendly way to get the `VariantId` of an enum at runtime is using
 /// the function pointer returned by [`core::any::TypeId::variant_getter`].

library/core/src/mem/type_info.rs

@@ -20,22 +20,34 @@ pub struct Type {
 /// This function is not called directly instead a pointer to a monomorphized
 /// instance of it is returned by [`TypeId::variant_getter`].
 ///
+/// # Errors
+/// It's an ICE to call this with anything not an enum. This is guarded for
+/// by [`TypeId::variant_getter`].
+///
 /// # Safety
 ///
 /// See [`TypeId::variant_getter`] on how to safely use this function.
 #[lang = "variant_getter"]
-unsafe fn variant_getter<T: 'static>(val: *const ()) -> VariantId {
-    // SAFETY up to the caller to uphold, documented in `TypeId::variant_getter`.
+unsafe fn variant_getter<T>(val: *const ()) -> VariantId
+where
+    <T as DiscriminantKind>::Discriminant: 'static,
+{
+    // SAFETY: up to the caller to uphold, documented in `TypeId::variant_getter`.
     let v: &T = unsafe { &*val.cast::<T>() };
     let discriminant = core::mem::discriminant(v);
     let lookup_table: &'static [<T as DiscriminantKind>::Discriminant] =
         const { intrinsics::reflection::type_id_variant_lookup_table::<T>() };
 
+    if lookup_table.is_empty() {
+        // for types other then enums the table will be empty
+        return VariantId { base: const { of::<T>() }, variant: 0 };
+    }
+
     let variant = lookup_table
         .iter()
         .position(|d| Discriminant(*d) == discriminant)
         .expect("table contains all possible discriminants");
-    VariantId { base: const { TypeId::of::<T>() }, variant }
+    VariantId { base: const { of::<T>() }, variant }
 }
 
 /// Info of a trait implementation, you can retrieve the vtable with [Self::get_vtable]
@@ -708,6 +720,9 @@ impl TypeId {
     /// When called on a `TypeId` representing some enum `T` this returns a function pointer
     /// which can be used to get the `VariantId` of an instance of `T` at runtime.
     ///
+    /// When given a `TypeId` for something which does not represent an enum the returned
+    /// function can still be called. It will then return the same as `TypeId::variant(0)`.
+    ///
     /// # Safety
     ///
     /// While calling this function is completely safe the returned function pointer
@@ -719,39 +734,49 @@ impl TypeId {
     /// # Examples
     ///
     /// ```
-    /// #![feature(type_info)]
-    /// # use std::any::TypeId;
+    /// # #![feature(const_trait_impl)]
+    /// # #![feature(const_heap)]
+    /// # #![feature(type_info)]
+    /// use std::any::TypeId;
     /// enum Kitty {
     ///     Sleepy,
     ///     Playful,
     ///     Cuddly,
     /// }
-    ///
+
     /// let names = const {
     ///     let type_id = TypeId::of::<Kitty>();
     ///     let mut names = Vec::new();
-    ///
+
     ///     while names.len() < type_id.variants() {
-    ///         let variant = type_id.variant(names.len());
-    ///         names.push(variant.name());
+    ///         let variant_id = type_id.variant(names.len());
+    ///         names.push((variant_id, variant_id.name()));
     ///     }
-    ///     names
+    ///     names.const_make_global()
     /// };
     /// let variant_getter = const { TypeId::of::<Kitty>().variant_getter() };
-    ///
+
     /// let kitty = Kitty::Playful;
-    /// // Normally when using this API you no longer have the Type but only
-    /// // a type erased pointer.
-    /// let type_erased_kitty = (*&kitty) as *const ();
-    ///
-    /// let variant_idx = variant_getter(type_erased_kitty);
-    /// println!("kitty is: {}", names[variant_idx].to_lower());
+    /// // Normally when using the getter you are manually offsetting pointers and you have no type.
+    /// // We'll pretend here for brevity.
+    /// let kitty_ptr = &kitty as *const Kitty;
+    /// let kitty_ptr = kitty_ptr.cast::<()>();
+
+    /// let variant_id = variant_getter(kitty_ptr);
+    /// let kitty_is_feeling = names
+    ///     .iter()
+    ///     .find(|(id, _)| *id == variant_id)
+    ///     .map(|(_, variant_name)| *variant_name)
+    ///     .expect("We have a list of steps for each VariantId")
+    ///     .to_lowercase();
+
+    /// assert_eq!(kitty_is_feeling, "playful");
     /// ```
     ///
     #[unstable(feature = "type_info", issue = "146922")]
     #[rustc_const_unstable(feature = "type_info", issue = "146922")]
     #[rustc_comptime]
-    pub fn variant_getter(self) -> fn(*const ()) -> VariantId {
+    pub fn variant_getter(self) -> unsafe fn(*const ()) -> VariantId {
         intrinsics::reflection::type_id_variant_getter(self)
     }
 }

library/coretests/tests/lib.rs

@@ -35,6 +35,7 @@
 #![feature(const_destruct)]
 #![feature(const_drop_in_place)]
 #![feature(const_eval_select)]
+#![feature(const_heap)]
 #![feature(const_index)]
 #![feature(const_iter)]
 #![feature(const_nonzero_strict_ops)]

library/coretests/tests/mem/type_info.rs

@@ -4,6 +4,8 @@ use std::any::{Any, TypeId};
 use std::mem::offset_of;
 use std::mem::type_info::{Const, Generic, GenericType, Type, TypeKind};
 
+mod runtime;
+
 #[test]
 fn test_arrays() {
     // Normal array.

library/coretests/tests/mem/type_info/runtime.rs

@@ -0,0 +1,95 @@
+use std::any::TypeId;
+
+fn as_unit_ptr<T: 'static>(test_case: &T) -> *const () {
+    (test_case as *const T).cast()
+}
+
+fn assert_unit_variant_getter<T: 'static>(test_input: &T) {
+    let variant_getter = const { TypeId::of::<T>().variant_getter() };
+    assert_eq!(variant_getter(as_unit_ptr(test_input)), const { TypeId::of::<T>().variant(0) });
+}
+
+#[test]
+fn correct_variant_id() {
+    use std::any::TypeId;
+    #[repr(u128)]
+    enum Kitty {
+        Sleepy,
+        Playful,
+        Cuddly = u128::MAX,
+    }
+
+    let variant_getter = const { TypeId::of::<Kitty>().variant_getter() };
+    assert_eq!(
+        variant_getter(as_unit_ptr(&Kitty::Sleepy)),
+        const { TypeId::of::<Kitty>().variant(0) }
+    );
+    assert_eq!(
+        variant_getter(as_unit_ptr(&Kitty::Playful)),
+        const { TypeId::of::<Kitty>().variant(1) }
+    );
+    assert_eq!(
+        variant_getter(as_unit_ptr(&Kitty::Cuddly)),
+        const { TypeId::of::<Kitty>().variant(2) }
+    );
+}
+
+#[test]
+fn variant_getter_for_unit() {
+    assert_unit_variant_getter(&());
+}
+
+#[test]
+fn array() {
+    assert_unit_variant_getter::<[u8; 3]>(&[0, 1, 2]);
+}
+
+#[test]
+fn slice() {
+    assert_unit_variant_getter::<&[u8]>(&[0, 1, 2].as_slice());
+}
+
+#[test]
+fn strukt() {
+    assert_unit_variant_getter(&String::new());
+}
+
+#[test]
+fn union() {
+    union TestUnion {
+        first: i16,
+    }
+    let test_union = TestUnion { first: 0 };
+    assert_unit_variant_getter(&test_union);
+}
+
+#[test]
+fn primitives() {
+    assert_unit_variant_getter(&true);
+    assert_unit_variant_getter(&0u8);
+    assert_unit_variant_getter(&'a');
+}
+
+#[test]
+fn reference_types() {
+    assert_unit_variant_getter(&&true);
+}
+
+#[test]
+fn pointers_types() {
+    let test_value = true;
+    let test_pointer = &test_value as *const bool;
+    assert_unit_variant_getter(&test_pointer);
+}
+
+#[test]
+fn trait_obj() {
+    let test_value = Box::new(String::new());
+    let test_object = Box::leak(test_value) as &dyn std::fmt::Debug;
+    assert_unit_variant_getter(&test_object);
+}
+
+#[test]
+fn never_type() {
+    let variant_getter = const { TypeId::of::<!>().variant_getter() };
+}