Make TypeId const-comparable

Author: oli-obk

compiler/rustc_const_eval/src/const_eval/eval_queries.rs

@@ -282,7 +282,9 @@ pub fn eval_to_const_value_raw_provider<'tcx>(
 ) -> ::rustc_middle::mir::interpret::EvalToConstValueResult<'tcx> {
     // We call `const_eval` for zero arg intrinsics, too, in order to cache their value.
     // Catch such calls and evaluate them instead of trying to load a constant's MIR.
-    if let ty::InstanceKind::Intrinsic(def_id) = key.value.instance.def {
+    if let ty::InstanceKind::Intrinsic(def_id) = key.value.instance.def
+        && key.value.promoted.is_none()
+    {
         let ty = key.value.instance.ty(tcx, key.typing_env);
         let ty::FnDef(_, args) = ty.kind() else {
             bug!("intrinsic with type {:?}", ty);

compiler/rustc_const_eval/src/const_eval/machine.rs

@@ -2,7 +2,7 @@ use std::borrow::{Borrow, Cow};
 use std::fmt;
 use std::hash::Hash;
 
-use rustc_abi::{Align, Size};
+use rustc_abi::{Align, FieldIdx, Size};
 use rustc_ast::Mutability;
 use rustc_data_structures::fx::{FxHashMap, FxIndexMap, IndexEntry};
 use rustc_hir::def_id::{DefId, LocalDefId};
@@ -403,6 +403,21 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
                 let cmp = ecx.guaranteed_cmp(a, b)?;
                 ecx.write_scalar(Scalar::from_u8(cmp), dest)?;
             }
+            sym::type_id_eq => {
+                let a = ecx.project_field(&args[0], FieldIdx::ZERO)?;
+                let a = ecx.deref_pointer(&a)?;
+                let (a, offset) = a.ptr().into_parts();
+                assert_eq!(offset, Size::ZERO);
+                let a = a.unwrap().alloc_id();
+                let GlobalAlloc::Type(a) = ecx.tcx.global_alloc(a) else { bug!() };
+                let b = ecx.project_field(&args[1], FieldIdx::ZERO)?;
+                let b = ecx.deref_pointer(&b)?;
+                let (b, offset) = b.ptr().into_parts();
+                assert_eq!(offset, Size::ZERO);
+                let b = b.unwrap().alloc_id();
+                let GlobalAlloc::Type(b) = ecx.tcx.global_alloc(b) else { bug!() };
+                ecx.write_scalar(Scalar::from_bool(a == b), dest)?;
+            }
             sym::const_allocate => {
                 let size = ecx.read_scalar(&args[0])?.to_target_usize(ecx)?;
                 let align = ecx.read_scalar(&args[1])?.to_target_usize(ecx)?;

compiler/rustc_hir_analysis/src/check/intrinsic.rs

@@ -93,6 +93,7 @@ fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -> hi
         | sym::three_way_compare
         | sym::discriminant_value
         | sym::type_id
+        | sym::type_id_eq
         | sym::select_unpredictable
         | sym::cold_path
         | sym::ptr_guaranteed_cmp
@@ -223,6 +224,10 @@ pub(crate) fn check_intrinsic_type(
         sym::type_id => {
             (1, 0, vec![], tcx.type_of(tcx.lang_items().type_id().unwrap()).instantiate_identity())
         }
+        sym::type_id_eq => {
+            let type_id = tcx.type_of(tcx.lang_items().type_id().unwrap()).instantiate_identity();
+            (0, 0, vec![type_id, type_id], tcx.types.bool)
+        }
         sym::offset => (2, 0, vec![param(0), param(1)], param(0)),
         sym::arith_offset => (
             1,

compiler/rustc_span/src/symbol.rs

@@ -2183,6 +2183,7 @@ symbols! {
         type_changing_struct_update,
         type_const,
         type_id,
+        type_id_eq,
         type_ir,
         type_ir_infer_ctxt_like,
         type_ir_inherent,

library/core/src/any.rs

@@ -727,24 +727,42 @@ unsafe impl Send for TypeId {}
 unsafe impl Sync for TypeId {}
 
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-struct TypeIdData {
+pub(crate) struct TypeIdData {
     full_hash: [u8; 16],
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl PartialEq for TypeId {
+#[rustc_const_unstable(feature = "const_type_id", issue = "77125")]
+impl const PartialEq for TypeId {
     #[inline]
     fn eq(&self, other: &Self) -> bool {
-        self.data as *const TypeIdData == other.data as *const TypeIdData
-            || (self.partial_hash == other.partial_hash
-                && self.data.full_hash == other.data.full_hash)
+        const fn ct(a: &TypeId, b: &TypeId) -> bool {
+            crate::intrinsics::type_id_eq(*a, *b)
+        }
+
+        #[inline]
+        fn rt(a: &TypeId, b: &TypeId) -> bool {
+            a.data as *const TypeIdData == b.data as *const TypeIdData
+                || (a.partial_hash == b.partial_hash && a.data.full_hash == b.data.full_hash)
+        }
+
+        core::intrinsics::const_eval_select((self, other), ct, rt)
     }
 
     #[inline]
     fn ne(&self, other: &Self) -> bool {
-        self.partial_hash != other.partial_hash
-            || (self.data as *const TypeIdData != other.data as *const TypeIdData
-                && self.data.full_hash != other.data.full_hash)
+        const fn ct(a: &TypeId, b: &TypeId) -> bool {
+            !crate::intrinsics::type_id_eq(*a, *b)
+        }
+
+        #[inline]
+        fn rt(a: &TypeId, b: &TypeId) -> bool {
+            a.partial_hash != b.partial_hash
+                || (a.data as *const TypeIdData != b.data as *const TypeIdData
+                    && a.data.full_hash != b.data.full_hash)
+        }
+
+        core::intrinsics::const_eval_select((self, other), ct, rt)
     }
 }
 

library/core/src/intrinsics/mod.rs

@@ -2720,6 +2720,18 @@ pub const fn type_name<T: ?Sized>() -> &'static str;
 #[rustc_intrinsic]
 pub const fn type_id<T: ?Sized + 'static>() -> crate::any::TypeId;
 
+/// Tests (at compile-time) if two [`crate::any::TypeId`] instances identify the
+/// same type. This is necessary because at const-eval time the actual discriminating
+/// data is opaque and cannot be inspected directly.
+///
+/// The stabilized version of this intrinsic is the [PartialEq] impl for [`core::any::TypeId`].
+#[rustc_nounwind]
+#[unstable(feature = "core_intrinsics", issue = "none")]
+#[rustc_intrinsic]
+pub const fn type_id_eq(_a: crate::any::TypeId, _b: crate::any::TypeId) -> bool {
+    panic!("type_id_eq should only be used from const eval")
+}
+
 /// Lowers in MIR to `Rvalue::Aggregate` with `AggregateKind::RawPtr`.
 ///
 /// This is used to implement functions like `slice::from_raw_parts_mut` and

tests/ui/const-generics/issues/issue-90318.rs

@@ -1,5 +1,6 @@
 #![feature(const_type_id)]
 #![feature(generic_const_exprs)]
+#![feature(const_trait_impl)]
 #![feature(core_intrinsics)]
 #![allow(incomplete_features)]
 
@@ -13,15 +14,13 @@ fn consume<T: 'static>(_val: T)
 where
     If<{ TypeId::of::<T>() != TypeId::of::<()>() }>: True,
     //~^ ERROR overly complex generic constant
-    //~| ERROR: cannot call
 {
 }
 
 fn test<T: 'static>()
 where
     If<{ TypeId::of::<T>() != TypeId::of::<()>() }>: True,
     //~^ ERROR overly complex generic constant
-    //~| ERROR: cannot call
 {
 }
 

tests/ui/const-generics/issues/issue-90318.stderr

@@ -1,5 +1,5 @@
 error: overly complex generic constant
-  --> $DIR/issue-90318.rs:14:8
+  --> $DIR/issue-90318.rs:15:8
    |
 LL |     If<{ TypeId::of::<T>() != TypeId::of::<()>() }>: True,
    |        ^^-----------------^^^^^^^^^^^^^^^^^^^^^^^^
@@ -20,26 +20,5 @@ LL |     If<{ TypeId::of::<T>() != TypeId::of::<()>() }>: True,
    = help: consider moving this anonymous constant into a `const` function
    = note: this operation may be supported in the future
 
-error[E0015]: cannot call non-const operator in constants
-  --> $DIR/issue-90318.rs:14:10
-   |
-LL |     If<{ TypeId::of::<T>() != TypeId::of::<()>() }>: True,
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-note: impl defined here, but it is not `const`
-  --> $SRC_DIR/core/src/any.rs:LL:COL
-   = note: calls in constants are limited to constant functions, tuple structs and tuple variants
-
-error[E0015]: cannot call non-const operator in constants
-  --> $DIR/issue-90318.rs:22:10
-   |
-LL |     If<{ TypeId::of::<T>() != TypeId::of::<()>() }>: True,
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-note: impl defined here, but it is not `const`
-  --> $SRC_DIR/core/src/any.rs:LL:COL
-   = note: calls in constants are limited to constant functions, tuple structs and tuple variants
-
-error: aborting due to 4 previous errors
+error: aborting due to 2 previous errors
 
-For more information about this error, try `rustc --explain E0015`.

tests/ui/consts/const_cmp_type_id.rs

@@ -6,10 +6,9 @@ use std::any::TypeId;
 fn main() {
     const {
         assert!(TypeId::of::<u8>() == TypeId::of::<u8>());
-        //~^ ERROR the trait bound `TypeId: const PartialEq` is not satisfied
         assert!(TypeId::of::<()>() != TypeId::of::<u8>());
-        //~^ ERROR the trait bound `TypeId: const PartialEq` is not satisfied
         let _a = TypeId::of::<u8>() < TypeId::of::<u16>();
+        //~^ ERROR: cannot call non-const operator in constants
         // can't assert `_a` because it is not deterministic
         // FIXME(const_trait_impl) make it pass
     }

tests/ui/consts/const_cmp_type_id.stderr

@@ -1,15 +1,13 @@
-error[E0277]: the trait bound `TypeId: const PartialEq` is not satisfied
-  --> $DIR/const_cmp_type_id.rs:8:17
+error[E0015]: cannot call non-const operator in constants
+  --> $DIR/const_cmp_type_id.rs:10:18
    |
-LL |         assert!(TypeId::of::<u8>() == TypeId::of::<u8>());
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0277]: the trait bound `TypeId: const PartialEq` is not satisfied
-  --> $DIR/const_cmp_type_id.rs:10:17
+LL |         let _a = TypeId::of::<u8>() < TypeId::of::<u16>();
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-LL |         assert!(TypeId::of::<()>() != TypeId::of::<u8>());
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+note: impl defined here, but it is not `const`
+  --> $SRC_DIR/core/src/any.rs:LL:COL
+   = note: calls in constants are limited to constant functions, tuple structs and tuple variants
 
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0277`.
+For more information about this error, try `rustc --explain E0015`.

tests/ui/consts/issue-73976-monomorphic.rs

@@ -1,4 +1,4 @@
-//@ known-bug: #110395
+//@ check-pass
 //
 // This test is complement to the test in issue-73976-polymorphic.rs.
 // In that test we ensure that polymorphic use of type_id and type_name in patterns