[blocked on upstream] Parse builtin syntax field_of

src/cli/diagnostics.rs

@@ -58,6 +58,9 @@ fn convert(error: Error, cx: RenderCx<'_>) -> Diag {
             Diag::new("comparison operators cannot be chained").highlight(span)
         }
         Error::TyRelMacroCall(span) => Diag::new("type-relative macro call").highlight(span),
+        Error::InvalidExtraFieldProjections(span) => {
+            Diag::new("invalid extra field accesses").highlight(span)
+        }
         Error::ReservedLabel(span) => Diag::new("reserved label").highlight(span),
         Error::ReservedLifetime(span) => Diag::new("reserved lifetime").highlight(span),
         Error::ReservedPrefix(span) => Diag::new("reserved prefix").highlight(span),

src/lib/ast/ty.rs

@@ -10,6 +10,7 @@ pub(crate) enum Ty<'src> {
     CVariadics,
     DynTrait(DynKind, Vec<Bound<'src>>),
     Error(Span),
+    FieldOf(Box<Ty<'src>>, Option<Ident<'src>>, Ident<'src>),
     FnPtr(Box<FnPtrTy<'src>>),
     Grouped(Box<Ty<'src>>),
     ImplTrait(Vec<Bound<'src>>),

src/lib/error.rs

@@ -80,6 +80,7 @@ pub enum Error {
     ReservedPrefix(Span),
     ReuseInherentImpl,
     StrLitGuardTooLarge(Span),
+    InvalidExtraFieldProjections(Span),
     TraitImplModifierInInherentImpl(&'static str),
     TyRelMacroCall(Span),
     UnexpectedClosingDelimiter(Token),

src/lib/fmter/ty.rs

@@ -1,5 +1,5 @@
 use super::{Cx, Fmt, InterleaveExt as _, TrailingSpace, TrailingSpaceExt as _, Tup, fmt};
-use crate::ast;
+use crate::{ast, fmter::BuiltinSyntax};
 
 impl Fmt for ast::Ty<'_> {
     fn fmt(self, cx: &mut Cx<'_>) {
@@ -65,6 +65,16 @@ impl Fmt for ast::Ty<'_> {
                 fmt!(cx, " ");
                 ty.fmt(cx);
             }
+            Self::FieldOf(ty, variant, field) => BuiltinSyntax("field_of", |cx| {
+                ty.fmt(cx);
+                fmt!(cx, ", ");
+                if let Some(variant) = variant {
+                    variant.fmt(cx);
+                    fmt!(cx, ".");
+                }
+                field.fmt(cx);
+            })
+            .fmt(cx),
         }
     }
 }

src/lib/parser/common.rs

@@ -1,5 +1,5 @@
 use super::{
-    ExpectedFragment, Parser, Result, TokenKind,
+    ExpectedFragment, Parser, Result, TokenKind, one_of,
     pat::OrPolicy,
     weak::{self, Weak as _},
 };
@@ -315,6 +315,36 @@ impl<'src> Parser<'_, '_, 'src> {
 
         (ast::Ident::new(name, span), extra)
     }
+
+    pub(super) fn fin_parse_delimited_field_seq(&mut self) -> Result<Vec<ast::Ident<'src>>> {
+        let mut fields = Vec::new();
+
+        const DELIMITER: TokenKind = TokenKind::CloseRoundBracket;
+        const SEPARATOR: TokenKind = TokenKind::SingleDot;
+        loop {
+            let (TokenKind::CommonIdent | TokenKind::NumLit) = self.token.kind else {
+                return self.fatal(Error::UnexpectedToken(
+                    self.token,
+                    one_of![TokenKind::CommonIdent, TokenKind::NumLit],
+                ));
+            };
+
+            let (ident, extra) = self.split_float_lit();
+
+            fields.push(ident);
+            if let Some(ident) = extra {
+                fields.push(ident);
+            }
+
+            if self.consume(DELIMITER) {
+                break;
+            }
+
+            self.parse(SEPARATOR)?;
+        }
+
+        Ok(fields)
+    }
 }
 
 #[derive(Clone, Copy)]

src/lib/parser/expr.rs

@@ -1048,30 +1048,7 @@ impl<'src> Parser<'_, '_, 'src> {
                 weak::OffsetOf::STR => {
                     let ty = this.parse_ty()?;
                     this.parse(TokenKind::Comma)?;
-
-                    let mut fields = Vec::new();
-
-                    const DELIMITER: TokenKind = TokenKind::CloseRoundBracket;
-                    const SEPARATOR: TokenKind = TokenKind::SingleDot;
-                    while !this.consume(DELIMITER) {
-                        let (TokenKind::CommonIdent | TokenKind::NumLit) = this.token.kind else {
-                            return this.fatal(Error::UnexpectedToken(
-                                this.token,
-                                one_of![TokenKind::CommonIdent, TokenKind::NumLit],
-                            ));
-                        };
-
-                        let (ident, extra) = this.split_float_lit();
-
-                        fields.push(ident);
-                        if let Some(ident) = extra {
-                            fields.push(ident);
-                        }
-
-                        if !this.matches(DELIMITER, this.token) {
-                            this.parse(SEPARATOR)?;
-                        }
-                    }
+                    let fields = this.fin_parse_delimited_field_seq()?;
 
                     Some(ast::ExprKind::OffsetOf(Box::new(ty), fields))
                 }

src/lib/parser/ty.rs

@@ -88,10 +88,18 @@ impl<'src> Parser<'_, '_, 'src> {
         }
 
         match self.token.kind {
-            TokenKind::CommonIdent if self.check(weak::Dyn) => {
-                self.advance();
-                return self.fin_parse_dyn_trait_object_ty(p_policy);
-            }
+            TokenKind::CommonIdent => match () {
+                // FEATURE: `builtin_syntax` <https://github.com/rust-lang/rust/issues/110680>
+                () if self.check(weak::Builtin) => {
+                    self.advance();
+                    return self.fin_parse_builtin_ty(start);
+                }
+                () if self.check(weak::Dyn) => {
+                    self.advance();
+                    return self.fin_parse_dyn_trait_object_ty(p_policy);
+                }
+                () => {}
+            },
             TokenKind::DoubleAmpersand => {
                 self.advance();
                 let pointee = self.fin_parse_ref_ty()?;
@@ -326,6 +334,36 @@ impl<'src> Parser<'_, '_, 'src> {
         Ok(Some(ast::Ty::DynTrait(ast::DynKind::Bare, bounds)))
     }
 
+    fn fin_parse_builtin_ty(&mut self, start: Span) -> Result<ast::Ty<'src>> {
+        self.fin_parse_builtin_syntax(start, ast::Ty::Error, |this, name| match name {
+            weak::FieldOf::STR => {
+                let ty = this.parse_ty()?;
+                this.parse(TokenKind::Comma)?;
+                let fields = this.fin_parse_delimited_field_seq()?;
+
+                let (variant, field) = match *fields {
+                    [] => unreachable!(),
+                    [field] => (None, field),
+                    [variant, field, ref extra @ ..] => {
+                        let extra = match extra {
+                            [] => None,
+                            [single] => Some(single.span),
+                            [first, .., last] => Some(first.span.to(last.span)),
+                        };
+                        if let Some(span) = extra {
+                            this.error(Error::InvalidExtraFieldProjections(span));
+                        }
+
+                        (Some(variant), field)
+                    }
+                };
+
+                Ok(Some(ast::Ty::FieldOf(Box::new(ty), variant, field)))
+            }
+            _ => Ok(None),
+        })
+    }
+
     fn fin_parse_dyn_trait_object_ty(&mut self, p_policy: PlusPolicy) -> Result<ast::Ty<'src>> {
         Ok(ast::Ty::DynTrait(ast::DynKind::Dyn, self.parse_bounds_where(p_policy.elevate())?))
     }

src/lib/parser/weak.rs

@@ -52,6 +52,7 @@ weak! {
     Default "default" |p| p.peek(1).kind.is_ident(),
     Deref "deref",
     Dyn "dyn" |p| p.edition == Edition::Rust2015 && p.begins_2015_dyn_bound(p.peek(1)),
+    FieldOf "field_of",
     MacroRules "macro_rules" |p|
         p.peek(1).kind == TokenKind::SingleBang
             && p.peek(2).kind == TokenKind::CommonIdent,