add field representing types

Author: BennoLossin

Cargo.lock

@@ -4748,6 +4748,7 @@ dependencies = [
  "ena",
  "indexmap",
  "rustc-hash 2.1.1",
+ "rustc_abi",
  "rustc_ast_ir",
  "rustc_data_structures",
  "rustc_error_messages",

compiler/rustc_ast/src/ast.rs

@@ -2553,6 +2553,11 @@ pub enum TyKind {
     /// Pattern types like `pattern_type!(u32 is 1..=)`, which is the same as `NonZero<u32>`,
     /// just as part of the type system.
     Pat(Box<Ty>, Box<TyPat>),
+    /// A `field_of` expression (e.g., `builtin # field_of(Struct, field)`).
+    ///
+    /// Usually not written directly in user code but indirectly via the macro
+    /// `core::field::field_of!(...)`.
+    FieldOf(Box<Ty>, Option<Ident>, Ident),
     /// Sometimes we need a dummy value when no error has occurred.
     Dummy,
     /// Placeholder for a kind that has failed to be defined.

compiler/rustc_ast/src/util/classify.rs

@@ -298,6 +298,7 @@ fn type_trailing_braced_mac_call(mut ty: &ast::Ty) -> Option<&ast::MacCall> {
             | ast::TyKind::ImplicitSelf
             | ast::TyKind::CVarArgs
             | ast::TyKind::Pat(..)
+            | ast::TyKind::FieldOf(..)
             | ast::TyKind::Dummy
             | ast::TyKind::Err(..) => break None,
         }

compiler/rustc_ast_lowering/src/lib.rs

@@ -1496,6 +1496,13 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             TyKind::Pat(ty, pat) => {
                 hir::TyKind::Pat(self.lower_ty_alloc(ty, itctx), self.lower_ty_pat(pat, ty.span))
             }
+            TyKind::FieldOf(ty, variant, field) => hir::TyKind::FieldOf(
+                self.lower_ty_alloc(ty, itctx),
+                self.arena.alloc(hir::TyFieldPath {
+                    variant: variant.map(|variant| self.lower_ident(variant)),
+                    field: self.lower_ident(*field),
+                }),
+            ),
             TyKind::MacCall(_) => {
                 span_bug!(t.span, "`TyKind::MacCall` should have been expanded by now")
             }

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -1377,6 +1377,23 @@ impl<'a> State<'a> {
                 self.word(" is ");
                 self.print_ty_pat(pat);
             }
+            ast::TyKind::FieldOf(ty, variant, field) => {
+                self.word("builtin # field_of");
+                self.popen();
+                let ib = self.ibox(0);
+                self.print_type(ty);
+                self.word(",");
+                self.space();
+
+                if let Some(variant) = variant {
+                    self.print_ident(*variant);
+                    self.word(".");
+                }
+                self.print_ident(*field);
+
+                self.end(ib);
+                self.pclose();
+            }
         }
         self.end(ib);
     }

compiler/rustc_const_eval/src/const_eval/machine.rs

@@ -12,8 +12,8 @@ use rustc_middle::mir::AssertMessage;
 use rustc_middle::mir::interpret::ReportedErrorInfo;
 use rustc_middle::query::TyCtxtAt;
 use rustc_middle::ty::layout::{HasTypingEnv, TyAndLayout, ValidityRequirement};
-use rustc_middle::ty::{self, Ty, TyCtxt};
-use rustc_middle::{bug, mir};
+use rustc_middle::ty::{self, FieldInfo, Ty, TyCtxt};
+use rustc_middle::{bug, mir, span_bug};
 use rustc_span::{Span, Symbol, sym};
 use rustc_target::callconv::FnAbi;
 use tracing::debug;
@@ -23,8 +23,9 @@ use crate::errors::{LongRunning, LongRunningWarn};
 use crate::interpret::{
     self, AllocId, AllocInit, AllocRange, ConstAllocation, CtfeProvenance, FnArg, Frame,
     GlobalAlloc, ImmTy, InterpCx, InterpResult, OpTy, PlaceTy, Pointer, RangeSet, Scalar,
-    compile_time_machine, err_inval, interp_ok, throw_exhaust, throw_inval, throw_ub,
-    throw_ub_custom, throw_unsup, throw_unsup_format, type_implements_dyn_trait,
+    compile_time_machine, ensure_monomorphic_enough, err_inval, interp_ok, throw_exhaust,
+    throw_inval, throw_ub, throw_ub_custom, throw_unsup, throw_unsup_format,
+    type_implements_dyn_trait,
 };
 
 /// When hitting this many interpreted terminators we emit a deny by default lint
@@ -619,6 +620,27 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
                 ecx.write_type_info(ty, dest)?;
             }
 
+            sym::field_offset => {
+                let frt_ty = instance.args.type_at(0);
+                ensure_monomorphic_enough(ecx.tcx.tcx, frt_ty)?;
+
+                let (ty, variant, field) = if let ty::Adt(def, args) = frt_ty.kind()
+                    && let Some(FieldInfo { base, variant_idx, field_idx, .. }) =
+                        def.field_representing_type_info(ecx.tcx.tcx, args)
+                {
+                    (base, variant_idx, field_idx)
+                } else {
+                    span_bug!(ecx.cur_span(), "expected field representing type, got {frt_ty}")
+                };
+                let layout = ecx.layout_of(ty)?;
+                let cx = ty::layout::LayoutCx::new(ecx.tcx.tcx, ecx.typing_env());
+
+                let layout = layout.for_variant(&cx, variant);
+                let offset = layout.fields.offset(field.index()).bytes();
+
+                ecx.write_scalar(Scalar::from_target_usize(offset, ecx), dest)?;
+            }
+
             _ => {
                 // We haven't handled the intrinsic, let's see if we can use a fallback body.
                 if ecx.tcx.intrinsic(instance.def_id()).unwrap().must_be_overridden {

compiler/rustc_const_eval/src/interpret/mod.rs

@@ -38,6 +38,8 @@ use self::place::{MemPlace, Place};
 pub use self::projection::{OffsetMode, Projectable};
 pub use self::stack::{Frame, FrameInfo, LocalState, ReturnContinuation};
 pub use self::util::EnteredTraceSpan;
-pub(crate) use self::util::{create_static_alloc, type_implements_dyn_trait};
+pub(crate) use self::util::{
+    create_static_alloc, ensure_monomorphic_enough, type_implements_dyn_trait,
+};
 pub use self::validity::{CtfeValidationMode, RangeSet, RefTracking};
 pub use self::visitor::ValueVisitor;

compiler/rustc_feature/src/unstable.rs

@@ -221,6 +221,8 @@ declare_features! (
     (internal, custom_mir, "1.65.0", None),
     /// Implementation details of externally implementable items
     (internal, eii_internals, "1.94.0", None),
+    /// Implementation details of field representing types.
+    (internal, field_representing_type_raw, "CURRENT_RUSTC_VERSION", None),
     /// Outputs useful `assert!` messages
     (unstable, generic_assert, "1.63.0", None),
     /// Allows using the #[rustc_intrinsic] attribute.
@@ -486,6 +488,8 @@ declare_features! (
     (unstable, ffi_const, "1.45.0", Some(58328)),
     /// Allows the use of `#[ffi_pure]` on foreign functions.
     (unstable, ffi_pure, "1.45.0", Some(58329)),
+    /// Experimental field projections.
+    (incomplete, field_projections, "CURRENT_RUSTC_VERSION", Some(145383)),
     /// Allows marking trait functions as `final` to prevent overriding impls
     (unstable, final_associated_functions, "CURRENT_RUSTC_VERSION", Some(131179)),
     /// Controlling the behavior of fmt::Debug

compiler/rustc_hir/src/hir.rs

@@ -1741,6 +1741,12 @@ impl<'hir> Block<'hir> {
     }
 }
 
+#[derive(Debug, Clone, Copy, HashStable_Generic)]
+pub struct TyFieldPath {
+    pub variant: Option<Ident>,
+    pub field: Ident,
+}
+
 #[derive(Debug, Clone, Copy, HashStable_Generic)]
 pub struct TyPat<'hir> {
     #[stable_hasher(ignore)]
@@ -3804,6 +3810,10 @@ pub enum TyKind<'hir, Unambig = ()> {
     Err(rustc_span::ErrorGuaranteed),
     /// Pattern types (`pattern_type!(u32 is 1..)`)
     Pat(&'hir Ty<'hir>, &'hir TyPat<'hir>),
+    /// Field representing type (`field_of!(Struct, field)`).
+    ///
+    /// The optional ident is the variant when an enum is passed `field_of!(Enum, Variant.field)`.
+    FieldOf(&'hir Ty<'hir>, &'hir TyFieldPath),
     /// `TyKind::Infer` means the type should be inferred instead of it having been
     /// specified. This can appear anywhere in a type.
     ///

compiler/rustc_hir/src/intravisit.rs

@@ -1047,6 +1047,11 @@ pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty<'v, AmbigArg>) -
             try_visit!(visitor.visit_ty_unambig(ty));
             try_visit!(visitor.visit_pattern_type_pattern(pat));
         }
+        TyKind::FieldOf(ty, TyFieldPath { variant, field }) => {
+            try_visit!(visitor.visit_ty_unambig(ty));
+            visit_opt!(visitor, visit_ident, *variant);
+            try_visit!(visitor.visit_ident(*field));
+        }
     }
     V::Result::output()
 }