Improve the code style

compiler/rustc_ast/src/ast.rs

@@ -2093,9 +2093,9 @@ pub enum TyKind {
     /// A tuple (`(A, B, C, D,...)`).
     Tup(ThinVec<P<Ty>>),
     /// An anonymous struct type i.e. `struct { foo: Type }`
-    AnonymousStruct(ThinVec<FieldDef>),
+    AnonStruct(ThinVec<FieldDef>),
     /// An anonymous union type i.e. `union { bar: Type }`
-    AnonymousUnion(ThinVec<FieldDef>),
+    AnonUnion(ThinVec<FieldDef>),
     /// A path (`module::module::...::Type`), optionally
     /// "qualified", e.g., `<Vec<T> as SomeTrait>::SomeType`.
     ///

compiler/rustc_ast/src/mut_visit.rs

@@ -509,7 +509,7 @@ 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::AnonymousStruct(fields) | TyKind::AnonymousUnion(fields) => {
+        TyKind::AnonStruct(fields) | TyKind::AnonUnion(fields) => {
             fields.flat_map_in_place(|field| vis.flat_map_field_def(field));
         }
     }

compiler/rustc_ast/src/visit.rs

@@ -438,7 +438,7 @@ 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::AnonymousStruct(ref fields, ..) | TyKind::AnonymousUnion(ref fields, ..) => {
+        TyKind::AnonStruct(ref fields, ..) | TyKind::AnonUnion(ref fields, ..) => {
             walk_list!(visitor, visit_field_def, fields)
         }
     }

compiler/rustc_ast_lowering/src/lib.rs

@@ -1296,13 +1296,13 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             // FIXME(unnamed_fields): IMPLEMENTATION IN PROGRESS
             #[allow(rustc::untranslatable_diagnostic)]
             #[allow(rustc::diagnostic_outside_of_impl)]
-            TyKind::AnonymousStruct(ref _fields) => hir::TyKind::Err(
+            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::AnonymousUnion(ref _fields) => hir::TyKind::Err(
+            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)),

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -219,7 +219,7 @@ impl<'a> AstValidator<'a> {
                     }
                 }
             }
-            TyKind::AnonymousStruct(ref fields, ..) | TyKind::AnonymousUnion(ref fields, ..) => {
+            TyKind::AnonStruct(ref fields, ..) | TyKind::AnonUnion(ref fields, ..) => {
                 // self.with_banned_assoc_ty_bound(|this| {
                 walk_list!(self, visit_struct_field_def, fields)
                 // });
@@ -229,18 +229,17 @@ impl<'a> AstValidator<'a> {
     }
 
     fn visit_struct_field_def(&mut self, field: &'a FieldDef) {
-        if let Some(ident) = field.ident {
-            if ident.name == kw::Underscore {
-                self.check_anonymous_field(field);
+        if let Some(ident) = field.ident &&
+            ident.name == kw::Underscore {
+                self.check_unnamed_field_ty(&field.ty, field.span);
                 self.visit_vis(&field.vis);
                 self.visit_ident(ident);
                 self.visit_ty_common(&field.ty);
                 self.walk_ty(&field.ty);
                 walk_list!(self, visit_attribute, &field.attrs);
-                return;
-            }
+        } else {
+            self.visit_field_def(field);
         }
-        self.visit_field_def(field);
     }
 
     fn err_handler(&self) -> &rustc_errors::Handler {
@@ -280,63 +279,48 @@ impl<'a> AstValidator<'a> {
         }
     }
 
-    fn check_anonymous_field(&self, field: &FieldDef) {
-        let FieldDef { ty, .. } = field;
-        match &ty.kind {
-            TyKind::AnonymousStruct(..) | TyKind::AnonymousUnion(..) => {
-                // We already checked for `kw::Underscore` before calling this function,
-                // so skip the check
-            }
-            TyKind::Path(..) => {
-                // If the anonymous field contains a Path as type, we can't determine
-                // if the path is a valid struct or union, so skip the check
-            }
-            _ => {
-                let msg = "unnamed fields can only have struct or union types";
-                let label = "not a struct or union";
-                self.err_handler()
-                    .struct_span_err(field.span, msg)
-                    .span_label(ty.span, label)
-                    .emit();
-            }
+    fn check_unnamed_field_ty(&self, ty: &Ty, span: Span) {
+        if matches!(
+            &ty.kind,
+            // We already checked for `kw::Underscore` before calling this function,
+            // so skip the check
+            TyKind::AnonStruct(..) | TyKind::AnonUnion(..)
+            // If the anonymous field contains a Path as type, we can't determine
+            // if the path is a valid struct or union, so skip the check
+            | TyKind::Path(..)
+        ) {
+            return;
         }
+        let msg = "unnamed fields can only have struct or union types";
+        let label = "not a struct or union";
+        self.err_handler().struct_span_err(span, msg).span_label(ty.span, label).emit();
     }
 
-    fn deny_anonymous_struct(&self, ty: &Ty) {
-        match &ty.kind {
-            TyKind::AnonymousStruct(..) => {
-                self.err_handler()
-                    .struct_span_err(
-                        ty.span,
-                        "anonymous structs are not allowed outside of unnamed struct or union fields",
-                    )
-                    .span_label(ty.span, "anonymous struct declared here")
-                    .emit();
-            }
-            TyKind::AnonymousUnion(..) => {
-                self.err_handler()
+    fn deny_anon_struct_or_union(&self, ty: &Ty) {
+        let struct_or_union = match &ty.kind {
+            TyKind::AnonStruct(..) => "struct",
+            TyKind::AnonUnion(..) => "union",
+            _ => return,
+        };
+        self.err_handler()
                     .struct_span_err(
                         ty.span,
-                        "anonymous unions are not allowed outside of unnamed struct or union fields",
+                        format!("anonymous {struct_or_union}s are not allowed outside of unnamed struct or union fields"),
                     )
-                    .span_label(ty.span, "anonymous union declared here")
+                    .span_label(ty.span, format!("anonymous {struct_or_union} declared here"))
                     .emit();
-            }
-            _ => {}
-        }
     }
 
-    fn deny_anonymous_field(&self, field: &FieldDef) {
-        if let Some(ident) = field.ident {
-            if ident.name == kw::Underscore {
+    fn deny_unnamed_field(&self, field: &FieldDef) {
+        if let Some(ident) = field.ident &&
+            ident.name == kw::Underscore {
                 self.err_handler()
                     .struct_span_err(
                         field.span,
                         "anonymous fields are not allowed outside of structs or unions",
                     )
                     .span_label(ident.span, "anonymous field declared here")
                     .emit();
-            }
         }
     }
 
@@ -866,7 +850,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
     fn visit_ty(&mut self, ty: &'a Ty) {
         self.visit_ty_common(ty);
         tracing::info!(?ty);
-        self.deny_anonymous_struct(ty);
+        self.deny_anon_struct_or_union(ty);
         self.walk_ty(ty)
     }
 
@@ -881,7 +865,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
     }
 
     fn visit_field_def(&mut self, field: &'a FieldDef) {
-        self.deny_anonymous_field(field);
+        self.deny_unnamed_field(field);
         visit::walk_field_def(self, field)
     }
 

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -1053,11 +1053,11 @@ impl<'a> State<'a> {
                 }
                 self.pclose();
             }
-            ast::TyKind::AnonymousStruct(fields) => {
+            ast::TyKind::AnonStruct(fields) => {
                 self.head("struct");
                 self.print_record_struct_body(&fields, ty.span);
             }
-            ast::TyKind::AnonymousUnion(fields) => {
+            ast::TyKind::AnonUnion(fields) => {
                 self.head("union");
                 self.print_record_struct_body(&fields, ty.span);
             }

compiler/rustc_parse/src/parser/item.rs

@@ -1,5 +1,5 @@
 use super::diagnostics::{dummy_arg, ConsumeClosingDelim};
-use super::ty::{AllowPlus, RecoverAnonymousStructOrUnion, RecoverQPath, RecoverReturnSign};
+use super::ty::{AllowPlus, MaybeRecoverAnonStructOrUnion, RecoverQPath, RecoverReturnSign};
 use super::{AttrWrapper, FollowedByType, ForceCollect, Parser, PathStyle, TrailingToken};
 use crate::errors::{self, MacroExpandsToAdtField};
 use crate::fluent_generated as fluent;
@@ -1675,7 +1675,7 @@ impl<'a> Parser<'a> {
             adt_ty,
             ident_span,
             parsed_where,
-            RecoverAnonymousStructOrUnion::No,
+            MaybeRecoverAnonStructOrUnion::Parse,
         )
     }
 
@@ -1684,7 +1684,7 @@ impl<'a> Parser<'a> {
         adt_ty: &str,
         ident_span: Span,
         parsed_where: bool,
-        recover_anonymous_struct_or_union: RecoverAnonymousStructOrUnion,
+        maybe_recover_anon_struct_or_union: MaybeRecoverAnonStructOrUnion,
     ) -> PResult<'a, (ThinVec<FieldDef>, /* recovered */ bool)> {
         let mut fields = ThinVec::new();
         let mut recovered = false;
@@ -1705,7 +1705,9 @@ impl<'a> Parser<'a> {
                         //
                         // Instead, the error should be thrown and handled by the caller
                         // `parse_anonymous_struct_or_union`.
-                        if recover_anonymous_struct_or_union == RecoverAnonymousStructOrUnion::Yes {
+                        if maybe_recover_anon_struct_or_union
+                            == MaybeRecoverAnonStructOrUnion::Recover
+                        {
                             return Err(err);
                         }
                         err.span_label(ident_span, format!("while parsing this {adt_ty}"));