Add field representing types

compiler/rustc_ast/src/ast.rs

@@ -2488,6 +2488,11 @@ pub enum TyKind {
     ImplTrait(NodeId, #[visitable(extra = BoundKind::Impl)] GenericBounds),
     /// No-op; kept solely so that we can pretty-print faithfully.
     Paren(Box<Ty>),
+    /// A `field_of` expression (e.g., `builtin # field_of(Struct, fields)`).
+    ///
+    /// Usually not written directly in user code but
+    /// indirectly via the macro `core::field::field_of!(...)`.
+    FieldOf(Box<Ty>, Vec<Ident>),
     /// Unused for now.
     Typeof(AnonConst),
     /// This means the type should be inferred instead of it having been

compiler/rustc_ast/src/util/classify.rs

@@ -294,6 +294,7 @@ fn type_trailing_braced_mac_call(mut ty: &ast::Ty) -> Option<&ast::MacCall> {
             | ast::TyKind::Never
             | ast::TyKind::Tup(..)
             | ast::TyKind::Paren(..)
+            | ast::TyKind::FieldOf(..)
             | ast::TyKind::Typeof(..)
             | ast::TyKind::Infer
             | ast::TyKind::ImplicitSelf

compiler/rustc_ast_lowering/src/lib.rs

@@ -1354,6 +1354,10 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 self.lower_ty(ty, itctx),
                 self.lower_array_length_to_const_arg(length),
             ),
+            TyKind::FieldOf(container, fields) => hir::TyKind::FieldOf(
+                self.lower_ty(container, itctx),
+                self.arena.alloc_from_iter(fields.iter().map(|field| self.lower_ident(*field))),
+            ),
             TyKind::Typeof(expr) => hir::TyKind::Typeof(self.lower_anon_const_to_anon_const(expr)),
             TyKind::TraitObject(bounds, kind) => {
                 let mut lifetime_bound = None;

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -1324,6 +1324,25 @@ impl<'a> State<'a> {
                 self.print_expr(&length.value, FixupContext::default());
                 self.word("]");
             }
+            ast::TyKind::FieldOf(container, fields) => {
+                self.word("builtin # field_of");
+                self.popen();
+                let ib = self.ibox(0);
+                self.print_type(container);
+                self.word(",");
+                self.space();
+
+                if let Some((&first, rest)) = fields.split_first() {
+                    self.print_ident(first);
+
+                    for &field in rest {
+                        self.word(".");
+                        self.print_ident(field);
+                    }
+                }
+                self.end(ib);
+                self.pclose();
+            }
             ast::TyKind::Typeof(e) => {
                 self.word("typeof(");
                 self.print_expr(&e.value, FixupContext::default());

compiler/rustc_borrowck/src/lib.rs

@@ -1892,6 +1892,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
                         }
                     }
                     ty::Bool
+                    | ty::Field(..)
                     | ty::Char
                     | ty::Int(_)
                     | ty::Uint(_)
@@ -1936,6 +1937,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
                     | ty::Coroutine(_, _)
                     | ty::Tuple(_) => (),
                     ty::Bool
+                    | ty::Field(..)
                     | ty::Char
                     | ty::Int(_)
                     | ty::Uint(_)

compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs

@@ -482,6 +482,7 @@ pub(crate) fn spanned_type_di_node<'ll, 'tcx>(
             AdtKind::Enum => enums::build_enum_type_di_node(cx, unique_type_id, span),
         },
         ty::Tuple(_) => build_tuple_type_di_node(cx, unique_type_id),
+        ty::Field(..) => build_field_type_di_node(cx, unique_type_id),
         _ => bug!("debuginfo: unexpected type in type_di_node(): {:?}", t),
     };
 
@@ -1273,6 +1274,32 @@ fn build_closure_env_di_node<'ll, 'tcx>(
     )
 }
 
+fn build_field_type_di_node<'ll, 'tcx>(
+    cx: &CodegenCx<'ll, 'tcx>,
+    unique_type_id: UniqueTypeId<'tcx>,
+) -> DINodeCreationResult<'ll> {
+    let ty = unique_type_id.expect_ty();
+    let ty::Field(_, _) = ty.kind() else {
+        bug!("build_field_type_di_node() called with non-field-type: {ty:?}")
+    };
+    let type_name = compute_debuginfo_type_name(cx.tcx, ty, false);
+    type_map::build_type_with_children(
+        cx,
+        type_map::stub(
+            cx,
+            Stub::Struct,
+            unique_type_id,
+            &type_name,
+            None,
+            cx.size_and_align_of(ty),
+            None,
+            DIFlags::FlagZero,
+        ),
+        |_, _| smallvec![],
+        NO_GENERICS,
+    )
+}
+
 /// Build the debuginfo node for a Rust `union` type.
 fn build_union_type_di_node<'ll, 'tcx>(
     cx: &CodegenCx<'ll, 'tcx>,

compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs

@@ -119,6 +119,19 @@ fn push_debuginfo_type_name<'tcx>(
                 push_generic_params_internal(tcx, args, output, visited);
             }
         }
+        ty::Field(container, field_path) => {
+            output.push_str("field_of!(");
+            push_debuginfo_type_name(tcx, container, qualified, output, visited);
+            output.push_str(", ");
+            field_path.walk(tcx, container, |_, name, _, last| {
+                output.push_str(name.as_str());
+                if !last {
+                    output.push('.');
+                }
+                std::ops::ControlFlow::<()>::Continue(())
+            });
+            output.push(')');
+        }
         ty::Tuple(component_types) => {
             if cpp_like_debuginfo {
                 output.push_str("tuple$<");

compiler/rustc_const_eval/src/const_eval/valtrees.rs

@@ -162,7 +162,8 @@ fn const_to_valtree_inner<'tcx>(
             branches(ecx, place, def.variant(variant).fields.len(), def.is_enum().then_some(variant), num_nodes)
         }
 
-        ty::Never
+        ty::Field(..)
+        | ty::Never
         | ty::Error(_)
         | ty::Foreign(..)
         | ty::Infer(ty::FreshIntTy(_))
@@ -325,7 +326,9 @@ pub fn valtree_to_const_value<'tcx>(
 
             op_to_const(&ecx, &place.into(), /* for diagnostics */ false)
         }
-        ty::Never
+
+        ty::Field(..)
+        | ty::Never
         | ty::Error(_)
         | ty::Foreign(..)
         | ty::Infer(ty::FreshIntTy(_))

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -7,10 +7,10 @@ use std::assert_matches::assert_matches;
 use rustc_abi::{FieldIdx, HasDataLayout, Size};
 use rustc_apfloat::ieee::{Double, Half, Quad, Single};
 use rustc_middle::mir::interpret::{CTFE_ALLOC_SALT, read_target_uint, write_target_uint};
-use rustc_middle::mir::{self, BinOp, ConstValue, NonDivergingIntrinsic};
+use rustc_middle::mir::{self, BinOp, ConstValue, NonDivergingIntrinsic, NullOp};
 use rustc_middle::ty::layout::TyAndLayout;
 use rustc_middle::ty::{Ty, TyCtxt};
-use rustc_middle::{bug, ty};
+use rustc_middle::{bug, span_bug, ty};
 use rustc_span::{Symbol, sym};
 use tracing::trace;
 
@@ -188,6 +188,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                     | ty::CoroutineWitness(..)
                     | ty::UnsafeBinder(_)
                     | ty::Never
+                    | ty::Field(..)
                     | ty::Tuple(_)
                     | ty::Error(_) => ConstValue::from_target_usize(0u64, &tcx),
                 };
@@ -645,6 +646,8 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             sym::fmuladdf64 => self.float_muladd_intrinsic::<Double>(args, dest)?,
             sym::fmuladdf128 => self.float_muladd_intrinsic::<Quad>(args, dest)?,
 
+            sym::field_offset => self.field_offset(instance, dest)?,
+
             // Unsupported intrinsic: skip the return_to_block below.
             _ => return interp_ok(false),
         }
@@ -654,6 +657,26 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         interp_ok(true)
     }
 
+    fn field_offset(
+        &mut self,
+        instance: ty::Instance<'tcx>,
+        dest: &PlaceTy<'tcx, M::Provenance>,
+    ) -> InterpResult<'tcx, ()> {
+        assert_eq!(instance.args.len(), 1);
+        let ty = instance.args.type_at(0);
+        match ty.kind() {
+            &ty::Field(container, field_path) => {
+                let offset = self.nullary_op(NullOp::OffsetOf(field_path), container)?;
+                self.write_immediate(*offset, dest)
+            }
+            ty::Alias(..) | ty::Param(..) | ty::Placeholder(..) | ty::Infer(..) => {
+                // This can happen in code which is generic over the field type.
+                throw_inval!(TooGeneric)
+            }
+            _ => span_bug!(self.cur_span(), "expected field representing type, found {ty}"),
+        }
+    }
+
     pub(super) fn eval_nondiverging_intrinsic(
         &mut self,
         intrinsic: &NonDivergingIntrinsic<'tcx>,

compiler/rustc_const_eval/src/interpret/stack.rs

@@ -507,6 +507,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 | ty::Closure(..)
                 | ty::CoroutineClosure(..)
                 | ty::Never
+                | ty::Field(..)
                 | ty::Error(_) => true,
 
                 ty::Str | ty::Slice(_) | ty::Dynamic(_, _) | ty::Foreign(..) => false,

compiler/rustc_const_eval/src/interpret/validity.rs

@@ -778,6 +778,7 @@ impl<'rt, 'tcx, M: Machine<'tcx>> ValidityVisitor<'rt, 'tcx, M> {
                 interp_ok(true)
             }
             ty::Never => throw_validation_failure!(self.path, NeverVal),
+            ty::Field(..) => throw_validation_failure!(self.path, NeverVal),
             ty::Foreign(..) | ty::FnDef(..) => {
                 // Nothing to check.
                 interp_ok(true)

compiler/rustc_const_eval/src/util/type_name.rs

@@ -1,4 +1,5 @@
 use std::fmt::Write;
+use std::ops::ControlFlow;
 
 use rustc_data_structures::intern::Interned;
 use rustc_hir::def_id::{CrateNum, DefId};
@@ -58,6 +59,29 @@ impl<'tcx> Printer<'tcx> for TypeNamePrinter<'tcx> {
             | ty::CoroutineClosure(def_id, args)
             | ty::Coroutine(def_id, args) => self.print_def_path(def_id, args),
             ty::Foreign(def_id) => self.print_def_path(def_id, &[]),
+            ty::Field(container, field_path) => {
+                write!(self, "field_of!(")?;
+                self.print_type(container)?;
+                write!(self, ", ")?;
+                field_path
+                    .walk(self.tcx, container, |_, name, _, last| {
+                        match write!(self, "{name}") {
+                            Ok(()) => ControlFlow::Continue(()),
+                            Err(err) => ControlFlow::Break(Err(err)),
+                        }?;
+                        if !last {
+                            match write!(self, ".") {
+                                Ok(()) => ControlFlow::Continue(()),
+                                Err(err) => ControlFlow::Break(Err(err)),
+                            }
+                        } else {
+                            ControlFlow::Continue(())
+                        }
+                    })
+                    .unwrap_or(Ok(()))?;
+                write!(self, ")")?;
+                Ok(())
+            }
 
             ty::Alias(ty::Free, _) => bug!("type_name: unexpected free alias"),
             ty::Alias(ty::Inherent, _) => bug!("type_name: unexpected inherent projection"),

compiler/rustc_feature/src/unstable.rs

@@ -500,6 +500,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)),
     /// Controlling the behavior of fmt::Debug
     (unstable, fmt_debug, "1.82.0", Some(129709)),
     /// Allows using `#[align(...)]` on function items

compiler/rustc_hir/src/hir.rs

@@ -3736,6 +3736,8 @@ pub enum TyKind<'hir, Unambig = ()> {
     /// We use pointer tagging to represent a `&'hir Lifetime` and `TraitObjectSyntax` pair
     /// as otherwise this type being `repr(C)` would result in `TyKind` increasing in size.
     TraitObject(&'hir [PolyTraitRef<'hir>], TaggedRef<'hir, Lifetime, TraitObjectSyntax>),
+    /// Field representing type (`field_of!`)
+    FieldOf(&'hir Ty<'hir>, &'hir [Ident]),
     /// Unused for now.
     Typeof(&'hir AnonConst),
     /// Placeholder for a type that has failed to be defined.

compiler/rustc_hir/src/intravisit.rs

@@ -1026,6 +1026,12 @@ pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty<'v, AmbigArg>) -
             }
             try_visit!(visitor.visit_lifetime(lifetime));
         }
+        TyKind::FieldOf(ty, fields) => {
+            try_visit!(visitor.visit_ty_unambig(ty));
+            for field in fields {
+                try_visit!(visitor.visit_ident(*field));
+            }
+        }
         TyKind::Typeof(ref expression) => try_visit!(visitor.visit_anon_const(expression)),
         TyKind::InferDelegation(..) | TyKind::Err(_) => {}
         TyKind::Pat(ty, pat) => {

compiler/rustc_hir/src/lang_items.rs

@@ -441,6 +441,12 @@ language_item_table! {
     // Reborrowing related lang-items
     Reborrow,                sym::reborrow,            reborrow,                   Target::Trait,          GenericRequirement::Exact(0);
     CoerceShared,            sym::coerce_shared,       coerce_shared,              Target::Trait,          GenericRequirement::Exact(0);
+
+    // Experimental lang items for field projections.
+    Field,                 sym::Field,                field_trait,            Target::Trait,               GenericRequirement::None;
+    FieldBase,             sym::FieldBase,            field_base,             Target::AssocTy,             GenericRequirement::None;
+    FieldType,             sym::FieldType,            field_type,             Target::AssocTy,             GenericRequirement::None;
+    FieldOffset,           sym::FieldOffset,          field_offset,           Target::AssocConst,          GenericRequirement::None;
 }
 
 /// The requirement imposed on the generics of a lang item

compiler/rustc_hir_analysis/messages.ftl

@@ -612,3 +612,4 @@ hir_analysis_wrong_number_of_generic_arguments_to_intrinsic =
         [one] parameter
         *[other] parameters
     }
+hir_analysis_no_field_on_type = no field `{$field}` on type `{$ty}`

compiler/rustc_hir_analysis/src/check/intrinsic.rs

@@ -116,6 +116,7 @@ fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -> hi
         | sym::fabsf128
         | sym::fadd_algebraic
         | sym::fdiv_algebraic
+        | sym::field_offset
         | sym::floorf16
         | sym::floorf32
         | sym::floorf64
@@ -749,6 +750,8 @@ pub(crate) fn check_intrinsic_type(
         | sym::atomic_xor => (2, 1, vec![Ty::new_mut_ptr(tcx, param(0)), param(1)], param(0)),
         sym::atomic_fence | sym::atomic_singlethreadfence => (0, 1, Vec::new(), tcx.types.unit),
 
+        sym::field_offset => (1, 0, Vec::new(), tcx.types.usize),
+
         other => {
             tcx.dcx().emit_err(UnrecognizedIntrinsicFunction { span, name: other });
             return;

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -259,6 +259,17 @@ pub(super) fn check_item<'tcx>(
                         .with_span_label(sp, "auto trait")
                         .emit());
                 }
+                if is_auto && let rustc_hir::TyKind::FieldOf(..) = impl_.self_ty.kind {
+                    res = res.and(Err(tcx
+                        .dcx()
+                        .struct_span_err(
+                            item.span,
+                            "impls of auto traits for field representing types not supported",
+                        )
+                        .with_span_label(impl_.self_ty.span, "field representing type")
+                        .with_span_label(of_trait.trait_ref.path.span, "auto trait")
+                        .emit()));
+                }
                 match header.polarity {
                     ty::ImplPolarity::Positive => {
                         res = res.and(check_impl(tcx, item, impl_));