Parse unnamed fields and anonymous structs or unions

Anonymous structs or unions are parsed as a special type of field,
instead of a gerenal kind of `Ty`.

Author: frank-king

compiler/rustc_ast/src/ast.rs

@@ -2074,10 +2074,6 @@ pub enum TyKind {
     Never,
     /// A tuple (`(A, B, C, D,...)`).
     Tup(ThinVec<P<Ty>>),
-    /// An anonymous struct type i.e. `struct { foo: Type }`
-    AnonStruct(ThinVec<FieldDef>),
-    /// An anonymous union type i.e. `union { bar: Type }`
-    AnonUnion(ThinVec<FieldDef>),
     /// A path (`module::module::...::Type`), optionally
     /// "qualified", e.g., `<Vec<T> as SomeTrait>::SomeType`.
     ///
@@ -2721,6 +2717,93 @@ impl VisibilityKind {
     }
 }
 
+#[derive(Clone, Copy, Encodable, Decodable, Debug)]
+pub enum AnonRecordKind {
+    Struct,
+    Union,
+}
+
+impl AnonRecordKind {
+    /// Returns the lowercase name.
+    pub fn name(self) -> &'static str {
+        match self {
+            Self::Struct => "struct",
+            Self::Union => "union",
+        }
+    }
+}
+
+/// An anonymous struct or union, i.e. `struct { foo: Foo }` or `union { foo: Foo }`.
+#[derive(Clone, Encodable, Decodable, Debug)]
+pub struct AnonRecord {
+    pub id: NodeId,
+    pub span: Span,
+    pub fields: ThinVec<FieldDef>,
+    pub kind: AnonRecordKind,
+    pub recovered: bool,
+}
+
+impl AnonRecord {
+    pub fn is_union(&self) -> bool {
+        matches!(self.kind, AnonRecordKind::Union)
+    }
+    pub fn is_struct(&self) -> bool {
+        matches!(self.kind, AnonRecordKind::Struct)
+    }
+}
+
+/// Type of fields in a struct, variant or union.
+#[derive(Clone, Encodable, Decodable, Debug)]
+pub enum FieldTy {
+    Ty(P<Ty>),
+    /// An anonymous struct or union, i.e. `struct { foo: Foo }` or `union { foo: Foo }`.
+    // AnonRecord(P<Item>),
+    AnonRecord(P<AnonRecord>),
+}
+
+impl From<P<Ty>> for FieldTy {
+    fn from(ty: P<Ty>) -> Self {
+        Self::Ty(ty)
+    }
+}
+
+impl From<AnonRecord> for FieldTy {
+    fn from(anon_record: AnonRecord) -> Self {
+        Self::AnonRecord(P(anon_record))
+    }
+}
+
+impl FieldTy {
+    pub fn id(&self) -> NodeId {
+        match self {
+            Self::Ty(ty) => ty.id,
+            Self::AnonRecord(anon_record) => anon_record.id,
+        }
+    }
+
+    pub fn span(&self) -> Span {
+        match self {
+            Self::Ty(ty) => ty.span,
+            Self::AnonRecord(anon_record) => anon_record.span,
+        }
+    }
+
+    pub fn as_ty(&self) -> Option<&P<Ty>> {
+        match self {
+            Self::Ty(ty) => Some(ty),
+            _ => None,
+        }
+    }
+
+    /// Expects a `Ty`, otherwise panics.
+    pub fn expect_ty(&self) -> &P<Ty> {
+        let FieldTy::Ty(ty) = &self else {
+            panic!("expect a type, found {self:?}");
+        };
+        ty
+    }
+}
+
 /// Field definition in a struct, variant or union.
 ///
 /// E.g., `bar: usize` as in `struct Foo { bar: usize }`.
@@ -2732,7 +2815,7 @@ pub struct FieldDef {
     pub vis: Visibility,
     pub ident: Option<Ident>,
 
-    pub ty: P<Ty>,
+    pub ty: FieldTy,
     pub is_placeholder: bool,
 }
 
@@ -2762,6 +2845,27 @@ impl VariantData {
         }
     }
 
+    /// Return all fields of this variant, with anonymous structs or unions flattened.
+    pub fn all_fields(&self) -> AllFields<'_> {
+        AllFields { iters: smallvec::smallvec![self.fields().iter()] }
+    }
+
+    /// Return whether this variant contains inner anonymous unions.
+    pub fn find_inner_union(&self) -> Option<Span> {
+        // We only check the record-like structs
+        let VariantData::Struct(fields, ..) = self else { return None };
+        fn find_union(fields: &[FieldDef]) -> Option<Span> {
+            fields.iter().find_map(|field| {
+                let FieldTy::AnonRecord(anon_record) = &field.ty else { return None };
+                anon_record
+                    .is_union()
+                    .then(|| anon_record.span)
+                    .or_else(|| find_union(&anon_record.fields))
+            })
+        }
+        find_union(&fields)
+    }
+
     /// Return the `NodeId` of this variant's constructor, if it has one.
     pub fn ctor_node_id(&self) -> Option<NodeId> {
         match *self {
@@ -2771,6 +2875,44 @@ impl VariantData {
     }
 }
 
+/// Iterator of all fields of a `VariantData`.
+///
+/// It iterates on the field tree in preorder, where the unnamed fields with anonymous structs or unions
+/// are flattened to their inner fields.
+pub struct AllFields<'a> {
+    iters: smallvec::SmallVec<[std::slice::Iter<'a, FieldDef>; 1]>,
+}
+
+impl<'a> Iterator for AllFields<'a> {
+    type Item = &'a FieldDef;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let mut top = self.iters.last_mut()?;
+        loop {
+            if let Some(field) = top.next() {
+                if let FieldTy::AnonRecord(anon_record) = &field.ty {
+                    self.iters.push(anon_record.fields.iter());
+                    top = self.iters.last_mut().unwrap();
+                    continue;
+                }
+                return Some(field);
+            }
+            self.iters.pop();
+            top = self.iters.last_mut()?;
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        match &self.iters[..] {
+            [] => (0, Some(0)),
+            [single] => (single.size_hint().0, None),
+            [first, .., last] => (first.size_hint().0 + last.size_hint().0, None),
+        }
+    }
+}
+
+impl std::iter::FusedIterator for AllFields<'_> {}
+
 /// An item definition.
 #[derive(Clone, Encodable, Decodable, Debug)]
 pub struct Item<K = ItemKind> {

compiler/rustc_ast/src/mut_visit.rs

@@ -251,6 +251,10 @@ pub trait MutVisitor: Sized {
         noop_visit_variant_data(vdata, self);
     }
 
+    fn visit_anon_record(&mut self, anon_record: &mut AnonRecord) {
+        noop_visit_anon_record(anon_record, self);
+    }
+
     fn flat_map_generic_param(&mut self, param: GenericParam) -> SmallVec<[GenericParam; 1]> {
         noop_flat_map_generic_param(param, self)
     }
@@ -514,9 +518,6 @@ pub fn noop_visit_ty<T: MutVisitor>(ty: &mut P<Ty>, vis: &mut T) {
             visit_vec(bounds, |bound| vis.visit_param_bound(bound));
         }
         TyKind::MacCall(mac) => vis.visit_mac_call(mac),
-        TyKind::AnonStruct(fields) | TyKind::AnonUnion(fields) => {
-            fields.flat_map_in_place(|field| vis.flat_map_field_def(field));
-        }
     }
     vis.visit_span(span);
     visit_lazy_tts(tokens, vis);
@@ -986,6 +987,13 @@ pub fn noop_visit_variant_data<T: MutVisitor>(vdata: &mut VariantData, vis: &mut
     }
 }
 
+pub fn noop_visit_anon_record<T: MutVisitor>(anon_record: &mut AnonRecord, vis: &mut T) {
+    let AnonRecord { span, id, fields, recovered: _recovered, kind: _kind } = anon_record;
+    vis.visit_span(span);
+    vis.visit_id(id);
+    fields.flat_map_in_place(|field| vis.flat_map_field_def(field));
+}
+
 pub fn noop_visit_trait_ref<T: MutVisitor>(TraitRef { path, ref_id }: &mut TraitRef, vis: &mut T) {
     vis.visit_path(path);
     vis.visit_id(ref_id);
@@ -1007,7 +1015,12 @@ pub fn noop_flat_map_field_def<T: MutVisitor>(
     visit_opt(ident, |ident| visitor.visit_ident(ident));
     visitor.visit_vis(vis);
     visitor.visit_id(id);
-    visitor.visit_ty(ty);
+    match ty {
+        FieldTy::Ty(ty) => {
+            visitor.visit_ty(ty);
+        }
+        FieldTy::AnonRecord(anon_record) => visitor.visit_anon_record(anon_record),
+    }
     visit_attrs(attrs, visitor);
     smallvec![fd]
 }

compiler/rustc_ast/src/visit.rs

@@ -441,9 +441,6 @@ pub fn walk_ty<'a, V: Visitor<'a>>(visitor: &mut V, typ: &'a Ty) {
         TyKind::Infer | TyKind::ImplicitSelf | TyKind::Err => {}
         TyKind::MacCall(mac) => visitor.visit_mac_call(mac),
         TyKind::Never | TyKind::CVarArgs => {}
-        TyKind::AnonStruct(ref fields, ..) | TyKind::AnonUnion(ref fields, ..) => {
-            walk_list!(visitor, visit_field_def, fields)
-        }
     }
 }
 
@@ -716,7 +713,14 @@ pub fn walk_field_def<'a, V: Visitor<'a>>(visitor: &mut V, field: &'a FieldDef)
     if let Some(ident) = field.ident {
         visitor.visit_ident(ident);
     }
-    visitor.visit_ty(&field.ty);
+    match &field.ty {
+        FieldTy::Ty(ty) => {
+            visitor.visit_ty(ty);
+        }
+        FieldTy::AnonRecord(anon_record) => {
+            walk_list!(visitor, visit_field_def, &anon_record.fields);
+        }
+    }
     walk_list!(visitor, visit_attribute, &field.attrs);
 }
 

compiler/rustc_ast_lowering/src/item.rs

@@ -675,17 +675,35 @@ impl<'hir> LoweringContext<'_, 'hir> {
     }
 
     fn lower_field_def(&mut self, (index, f): (usize, &FieldDef)) -> hir::FieldDef<'hir> {
-        let ty = if let TyKind::Path(qself, path) = &f.ty.kind {
-            let t = self.lower_path_ty(
-                &f.ty,
-                qself,
-                path,
-                ParamMode::ExplicitNamed, // no `'_` in declarations (Issue #61124)
-                &ImplTraitContext::Disallowed(ImplTraitPosition::FieldTy),
-            );
-            self.arena.alloc(t)
-        } else {
-            self.lower_ty(&f.ty, &ImplTraitContext::Disallowed(ImplTraitPosition::FieldTy))
+        let ty = match &f.ty {
+            FieldTy::Ty(ty) if let TyKind::Path(qself, path) = &ty.kind => {
+                let t = self.lower_path_ty(
+                    ty,
+                    qself,
+                    path,
+                    ParamMode::ExplicitNamed, // no `'_` in declarations (Issue #61124)
+                    &ImplTraitContext::Disallowed(ImplTraitPosition::FieldTy),
+                );
+                self.arena.alloc(t)
+            }
+            FieldTy::Ty(ty) => {
+                self.lower_ty(ty, &ImplTraitContext::Disallowed(ImplTraitPosition::FieldTy))
+            }
+            FieldTy::AnonRecord(anon_record) => {
+                let struct_or_union = anon_record.kind.name();
+                let hir_id = self.lower_node_id(anon_record.id);
+                let span = anon_record.span;
+                // FIXME(unnamed_fields): IMPLEMENTATION IN PROGRESS
+                #[allow(rustc::untranslatable_diagnostic)]
+                #[allow(rustc::diagnostic_outside_of_impl)]
+                let kind = hir::TyKind::Err(
+                    self.tcx
+                        .sess
+                        .span_err(span, format!("anonymous {struct_or_union}s are unimplemented")),
+                );
+                let ty = hir::Ty { hir_id, kind, span };
+                self.arena.alloc(ty)
+            }
         };
         let hir_id = self.lower_node_id(f.id);
         self.lower_attrs(hir_id, &f.attrs);

compiler/rustc_ast_lowering/src/lib.rs

@@ -35,6 +35,8 @@
 #![doc(rust_logo)]
 #![feature(box_patterns)]
 #![feature(let_chains)]
+#![feature(if_let_guard)]
+#![feature(never_type)]
 #![recursion_limit = "256"]
 #![deny(rustc::untranslatable_diagnostic)]
 #![deny(rustc::diagnostic_outside_of_impl)]
@@ -1323,18 +1325,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             TyKind::Err => {
                 hir::TyKind::Err(self.tcx.sess.span_delayed_bug(t.span, "TyKind::Err lowered"))
             }
-            // FIXME(unnamed_fields): IMPLEMENTATION IN PROGRESS
-            #[allow(rustc::untranslatable_diagnostic)]
-            #[allow(rustc::diagnostic_outside_of_impl)]
-            TyKind::AnonStruct(ref _fields) => hir::TyKind::Err(
-                self.tcx.sess.span_err(t.span, "anonymous structs are unimplemented"),
-            ),
-            // FIXME(unnamed_fields): IMPLEMENTATION IN PROGRESS
-            #[allow(rustc::untranslatable_diagnostic)]
-            #[allow(rustc::diagnostic_outside_of_impl)]
-            TyKind::AnonUnion(ref _fields) => hir::TyKind::Err(
-                self.tcx.sess.span_err(t.span, "anonymous unions are unimplemented"),
-            ),
             TyKind::Slice(ty) => hir::TyKind::Slice(self.lower_ty(ty, itctx)),
             TyKind::Ptr(mt) => hir::TyKind::Ptr(self.lower_mt(mt, itctx)),
             TyKind::Ref(region, mt) => {