Add TypeId::field method to get field TypeId for type_info

SpriteOvO · SpriteOvO · commit c503c8375bef · 2026-05-10T15:46:03.000Z
diff --git a/compiler/rustc_const_eval/src/const_eval/machine.rs b/compiler/rustc_const_eval/src/const_eval/machine.rs
@@ -644,6 +644,38 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
                 ecx.write_scalar(Scalar::from_target_usize(fields_num as u64, ecx), dest)?;
             }
 
+            sym::type_id_field => {
+                let ty = ecx.read_type_id(&args[0])?;
+                let variant_idx = ecx.read_target_usize(&args[1])? as usize;
+                let field_idx = ecx.read_target_usize(&args[2])? as usize;
+
+                let ty::Adt(adt_def, generics) = ty.kind() else {
+                    throw_ub!(BoundsCheckFailed { len: 0, index: variant_idx as u64 });
+                };
+
+                let varients_num = adt_def.variants().len();
+                if variant_idx >= varients_num {
+                    throw_ub!(BoundsCheckFailed {
+                        len: varients_num as u64,
+                        index: variant_idx as u64
+                    });
+                }
+
+                let variant_def = &adt_def.variants()[VariantIdx::from_usize(variant_idx)];
+                let fields_num = variant_def.fields.len();
+                if field_idx >= fields_num {
+                    throw_ub!(BoundsCheckFailed {
+                        len: fields_num as u64,
+                        index: field_idx as u64
+                    });
+                }
+
+                let field_def = &variant_def.fields[FieldIdx::from_usize(field_idx)];
+                let field_ty = field_def.ty(ecx.tcx.tcx, generics);
+                let field_ty = ecx.tcx.erase_and_anonymize_regions(field_ty);
+                ecx.write_type_id(field_ty, dest)?;
+            }
+
             sym::type_id_variants => {
                 let ty = ecx.read_type_id(&args[0])?;
                 let variants_num = ty.ty_adt_def().map(|def| def.variants().len()).unwrap_or(1);
diff --git a/compiler/rustc_hir_analysis/src/check/intrinsic.rs b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
@@ -212,6 +212,7 @@ fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -> hi
         | sym::truncf128
         | sym::type_id
         | sym::type_id_eq
+        | sym::type_id_field
         | sym::type_id_fields
         | sym::type_id_variants
         | sym::type_id_vtable
@@ -320,6 +321,9 @@ pub(crate) fn check_intrinsic_type(
         sym::type_name => (1, 0, vec![], Ty::new_static_str(tcx)),
         sym::type_id => (1, 0, vec![], type_id_ty()),
         sym::type_id_eq => (0, 0, vec![type_id_ty(), type_id_ty()], tcx.types.bool),
+        sym::type_id_field => {
+            (0, 0, vec![type_id_ty(), tcx.types.usize, tcx.types.usize], type_id_ty())
+        }
         sym::type_id_fields => (0, 0, vec![type_id_ty(), tcx.types.usize], tcx.types.usize),
         sym::type_id_variants => (0, 0, vec![type_id_ty()], tcx.types.usize),
         sym::type_id_vtable => {
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
@@ -2093,6 +2093,7 @@ symbols! {
         type_changing_struct_update,
         type_id,
         type_id_eq,
+        type_id_field,
         type_id_fields,
         type_id_variants,
         type_id_vtable,
diff --git a/library/core/src/intrinsics/mod.rs b/library/core/src/intrinsics/mod.rs
@@ -2964,6 +2964,19 @@ pub const fn type_id_fields(_id: crate::any::TypeId, _variant_index: usize) -> u
     panic!("`TypeId::fields` can only be called at compile-time")
 }
 
+/// Gets the `TypeId` of the field at the given index of the type represented by this `TypeId`.
+///
+/// The more user-friendly version of this intrinsic is [`core::any::TypeId::field`].
+#[rustc_intrinsic]
+#[unstable(feature = "core_intrinsics", issue = "none")]
+pub const fn type_id_field(
+    _id: crate::any::TypeId,
+    _variant_index: usize,
+    _field_index: usize,
+) -> crate::any::TypeId {
+    panic!("`TypeId::field` can only be called at compile-time")
+}
+
 /// Lowers in MIR to `Rvalue::Aggregate` with `AggregateKind::RawPtr`.
 ///
 /// This is used to implement functions like `slice::from_raw_parts_mut` and
diff --git a/library/core/src/mem/type_info.rs b/library/core/src/mem/type_info.rs
@@ -451,4 +451,52 @@ impl TypeId {
     pub const fn fields(self, variant_index: usize) -> usize {
         intrinsics::type_id_fields(self, variant_index)
     }
+
+    /// Returns the field `TypeId` at the given index of the type represented by this `TypeId`.
+    ///
+    /// ```
+    /// #![feature(type_info)]
+    /// use std::any::TypeId;
+    ///
+    /// struct Point {
+    ///     x: u32,
+    ///     y: u32,
+    /// }
+    /// assert_eq!(const { TypeId::of::<Point>().field(0, 0) }, TypeId::of::<u32>());
+    /// assert_eq!(const { TypeId::of::<Point>().field(0, 1) }, TypeId::of::<u32>());
+    ///
+    /// enum Enum {
+    ///     Unit,
+    ///     Tuple(u32, u64),
+    ///     Struct { x: u32, y: u32, z: String },
+    /// }
+    /// assert_eq!(const { TypeId::of::<Enum>().field(1, 0) }, TypeId::of::<u32>());
+    /// assert_eq!(const { TypeId::of::<Enum>().field(2, 2) }, TypeId::of::<String>());
+    /// ```
+    ///
+    /// Out-of-bounds indexing will be treated as a compile-time error.
+    ///
+    /// ```compile_fail,E0080
+    /// # #![feature(type_info)]
+    /// # use std::any::TypeId;
+    /// #
+    /// # struct Point {
+    /// #     x: u32,
+    /// #     y: u32,
+    /// # }
+    /// # enum Enum {
+    /// #     Unit,
+    /// #     Tuple(u32, u64),
+    /// #     Struct { x: u32, y: u32, z: String },
+    /// # }
+    /// const {
+    ///     _ = TypeId::of::<Point>().field(0, 2); // error: indexing out of bounds: the len is 2 but the index is 2
+    ///     _ = TypeId::of::<Enum>().field(2, 3); // error: indexing out of bounds: the len is 3 but the index is 3
+    /// }
+    /// ```
+    #[unstable(feature = "type_info", issue = "146922")]
+    #[rustc_const_unstable(feature = "type_info", issue = "146922")]
+    pub const fn field(self, variant_index: usize, field_index: usize) -> TypeId {
+        intrinsics::type_id_field(self, variant_index, field_index)
+    }
 }
diff --git a/library/coretests/tests/mem/type_info.rs b/library/coretests/tests/mem/type_info.rs
@@ -97,6 +97,9 @@ fn test_structs() {
         assert!(ty_id.size() == Some(size_of::<TestStruct>()));
         assert!(ty_id.variants() == 1);
         assert!(ty_id.fields(0) == 3);
+        assert!(ty_id.field(0, 0) == TypeId::of::<u8>());
+        assert!(ty_id.field(0, 1) == TypeId::of::<u16>());
+        assert!(ty_id.field(0, 2) == TypeId::of::<&u16>());
     }
 
     const {
@@ -160,6 +163,8 @@ fn test_unions() {
         assert!(ty_id.size() == Some(size_of::<TestUnion>()));
         assert!(ty_id.variants() == 1);
         assert!(ty_id.fields(0) == 2);
+        assert!(ty_id.field(0, 0) == TypeId::of::<i16>());
+        assert!(ty_id.field(0, 1) == TypeId::of::<u16>());
     }
 
     const {
@@ -220,6 +225,9 @@ fn test_enums() {
         assert!(ty_id.fields(0) == 1);
         assert!(ty_id.fields(1) == 0);
         assert!(ty_id.fields(2) == 2);
+        assert!(ty_id.field(0, 0) == TypeId::of::<u32>());
+        assert!(ty_id.field(2, 0) == TypeId::of::<()>());
+        assert!(ty_id.field(2, 1) == TypeId::of::<&str>());
     }
 
     const {
@@ -234,6 +242,7 @@ fn test_enums() {
         assert!(ty_id.variants() == 2);
         assert!(ty_id.fields(0) == 0);
         assert!(ty_id.fields(1) == 1);
+        assert!(ty_id.field(1, 0) == TypeId::of::<i32>());
     }
 }
 
diff --git a/tests/ui/reflection/variant_index_out_of_bounds.rs b/tests/ui/reflection/variant_index_out_of_bounds.rs
@@ -8,3 +8,13 @@ const _: () = const {
     TypeId::of::<Option::<()>>().fields(2);
     //~^ ERROR indexing out of bounds: the len is 2 but the index is 2
 };
+
+const _: () = const {
+    TypeId::of::<u32>().field(0, 1);
+    //~^ ERROR indexing out of bounds: the len is 0 but the index is 0
+};
+
+const _: () = const {
+    TypeId::of::<Option::<()>>().field(0, 1);
+    //~^ ERROR indexing out of bounds: the len is 0 but the index is 1
+};
diff --git a/tests/ui/reflection/variant_index_out_of_bounds.stderr b/tests/ui/reflection/variant_index_out_of_bounds.stderr
@@ -17,6 +17,44 @@ LL | |
 LL | | };
    | |_^
 
-error: aborting due to 1 previous error
+error[E0080]: indexing out of bounds: the len is 0 but the index is 0
+  --> $DIR/variant_index_out_of_bounds.rs:18:5
+   |
+LL |     TypeId::of::<u32>().field(0, 1);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `_::{constant#0}` failed inside this call
+   |
+note: inside `type_info::<impl TypeId>::field`
+  --> $SRC_DIR/core/src/mem/type_info.rs:LL:COL
+
+note: erroneous constant encountered
+  --> $DIR/variant_index_out_of_bounds.rs:17:15
+   |
+LL |   const _: () = const {
+   |  _______________^
+LL | |     TypeId::of::<u32>().field(0, 1);
+LL | |
+LL | | };
+   | |_^
+
+error[E0080]: indexing out of bounds: the len is 0 but the index is 1
+  --> $DIR/variant_index_out_of_bounds.rs:23:5
+   |
+LL |     TypeId::of::<Option::<()>>().field(0, 1);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `_::{constant#0}` failed inside this call
+   |
+note: inside `type_info::<impl TypeId>::field`
+  --> $SRC_DIR/core/src/mem/type_info.rs:LL:COL
+
+note: erroneous constant encountered
+  --> $DIR/variant_index_out_of_bounds.rs:22:15
+   |
+LL |   const _: () = const {
+   |  _______________^
+LL | |     TypeId::of::<Option::<()>>().field(0, 1);
+LL | |
+LL | | };
+   | |_^
+
+error: aborting due to 4 previous errors
 
 For more information about this error, try `rustc --explain E0080`.
