add builtin field_of! macro

Author: BennoLossin

compiler/rustc_ast/src/ast.rs

@@ -2441,6 +2441,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, field)`).
+    ///
+    /// 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_parse/src/parser/expr.rs

@@ -1132,7 +1132,7 @@ impl<'a> Parser<'a> {
     /// Parse the field access used in offset_of, matched by `$(e:expr)+`.
     /// Currently returns a list of idents. However, it should be possible in
     /// future to also do array indices, which might be arbitrary expressions.
-    fn parse_floating_field_access(&mut self) -> PResult<'a, Vec<Ident>> {
+    pub(super) fn parse_floating_field_access(&mut self) -> PResult<'a, Vec<Ident>> {
         let mut fields = Vec::new();
         let mut trailing_dot = None;
 

compiler/rustc_parse/src/parser/ty.rs

@@ -321,6 +321,8 @@ impl<'a> Parser<'a> {
             self.parse_borrowed_pointee()?
         } else if self.eat_keyword_noexpect(kw::Typeof) {
             self.parse_typeof_ty()?
+        } else if self.is_builtin() {
+            self.parse_builtin_ty()?
         } else if self.eat_keyword(exp!(Underscore)) {
             // A type to be inferred `_`
             TyKind::Infer
@@ -763,6 +765,42 @@ impl<'a> Parser<'a> {
         Ok(TyKind::Typeof(expr))
     }
 
+    fn parse_builtin_ty(&mut self) -> PResult<'a, TyKind> {
+        self.parse_builtin(|this, lo, ident| {
+            Ok(match ident.name {
+                sym::field_of => Some(this.parse_ty_field_of(lo)?),
+                _ => None,
+            })
+        })
+    }
+
+    /// Built-in macro for `field_of!` expressions.
+    pub(crate) fn parse_ty_field_of(&mut self, _lo: Span) -> PResult<'a, TyKind> {
+        let container = self.parse_ty()?;
+        self.expect(exp!(Comma))?;
+
+        let fields = self.parse_floating_field_access()?;
+        let trailing_comma = self.eat_noexpect(&TokenKind::Comma);
+
+        if let Err(mut e) = self.expect_one_of(&[], &[exp!(CloseParen)]) {
+            if trailing_comma {
+                e.note("unexpected third argument to field_of");
+            } else {
+                e.note("field_of expects dot-separated field and variant names");
+            }
+            e.emit();
+        }
+
+        // Eat tokens until the macro call ends.
+        if self.may_recover() {
+            while !self.token.kind.is_close_delim_or_eof() {
+                self.bump();
+            }
+        }
+
+        Ok(TyKind::FieldOf(container, fields))
+    }
+
     /// Parses a function pointer type (`TyKind::FnPtr`).
     /// ```ignore (illustrative)
     ///    [unsafe] [extern "ABI"] fn (S) -> T

compiler/rustc_span/src/symbol.rs

@@ -1040,6 +1040,7 @@ symbols! {
         ffi_returns_twice,
         field,
         field_init_shorthand,
+        field_of,
         field_projections,
         file,
         file_options,

library/core/src/field.rs

@@ -31,3 +31,15 @@ pub unsafe trait UnalignedField: Sized {
 #[lang = "Field"]
 #[unstable(feature = "field_projections", issue = "145383")]
 pub unsafe trait Field: UnalignedField {}
+
+/// Expands to the field representing type of the given field.
+///
+/// The container type may be a `struct` or a tuple.
+///
+/// The field may be a nested field (`field1.field2`), but not an array index.
+/// The field must be visible to the call site.
+#[unstable(feature = "field_projections", issue = "145383")]
+#[allow_internal_unstable(builtin_syntax)]
+pub macro field_of($Container:ty, $($fields:expr)+ $(,)?) {
+    builtin # field_of($Container, $($fields)+)
+}

src/tools/rustfmt/src/types.rs

@@ -1031,6 +1031,8 @@ impl Rewrite for ast::Ty {
             }
             ast::TyKind::CVarArgs => Ok("...".to_owned()),
             ast::TyKind::Dummy | ast::TyKind::Err(_) => Ok(context.snippet(self.span).to_owned()),
+            // Builtin type expression, cannot be written by users.
+            ast::TyKind::FieldOf(..) => Err(RewriteError::Unknown),
             ast::TyKind::Typeof(ref anon_const) => rewrite_call(
                 context,
                 "typeof",

tests/ui/feature-gates/feature-gate-field-projections.rs

@@ -1,6 +1,7 @@
 #![allow(dead_code)]
 
-use std::field::Field; //~ ERROR: use of unstable library feature `field_projections` [E0658]
+use std::field::{Field, field_of}; //~ ERROR: use of unstable library feature `field_projections` [E0658]
+//~^ ERROR: use of unstable library feature `field_projections` [E0658]
 use std::ptr;
 
 fn project_ref<F: Field>(
@@ -14,4 +15,7 @@ where
     unsafe { &*ptr::from_ref(r).byte_add(F::OFFSET).cast() } //~ ERROR: use of unstable library feature `field_projections` [E0658]
 }
 
-fn main() {}
+fn main() {
+    struct Foo(());
+    let _ = project_ref::<field_of!(Foo, 0)>(&Foo(())); //~ ERROR: use of unstable library feature `field_projections` [E0658]
+}