some tidy ups

Signed-off-by: Richard Tjokroutomo <richard.tjokro2@gmail.com>

Author: RichardTjokroutomo

compiler/rustc_attr_ir/src/target.rs

@@ -15,7 +15,7 @@ use rustc_macros::StableHash;
 pub enum AstTarget<'a> {
     // Target types that may correspond to different kinds of items.
     Delegation { target: DelegationAstTarget<'a>, mac: bool },
-    MacroCall(MacroCallAstTarget<'a>),
+    MacroCall,
 
     // Target types that correspond exclusively to `AssocItem` kind. Mapping is obtained from `Target::from_assoc_item_kind`.
     AssocConst(&'a AssocItemKind),
@@ -79,13 +79,6 @@ pub enum DelegationAstTarget<'a> {
     Item(&'a ItemKind),
 }
 
-#[derive(Clone, Copy, Debug)]
-pub enum MacroCallAstTarget<'a> {
-    AssocItem(&'a AssocItemKind),
-    ForeignItem(&'a ForeignItemKind),
-    Item(&'a ItemKind),
-}
-
 #[derive(Copy, Clone, PartialEq, Debug, Eq, StableHash)]
 pub enum MethodKind {
     /// Method in a `trait Trait` block
@@ -177,9 +170,7 @@ impl<'a> AstTarget<'a> {
             ForeignItemKind::Static(_) => AstTarget::ForeignStatic(kind),
             ForeignItemKind::Fn(_) => AstTarget::ForeignFn(kind),
             ForeignItemKind::TyAlias(_) => AstTarget::ForeignTy(kind),
-            ForeignItemKind::MacCall(_) => {
-                AstTarget::MacroCall(MacroCallAstTarget::ForeignItem(kind))
-            }
+            ForeignItemKind::MacCall(_) => AstTarget::MacroCall,
         }
     }
 
@@ -194,7 +185,7 @@ impl<'a> AstTarget<'a> {
             AssocItemKind::DelegationMac(_) => {
                 AstTarget::Delegation { target: DelegationAstTarget::AssocItem(kind), mac: true }
             }
-            AssocItemKind::MacCall(_) => AstTarget::MacroCall(MacroCallAstTarget::AssocItem(kind)),
+            AssocItemKind::MacCall(_) => AstTarget::MacroCall,
         }
     }
 
@@ -218,17 +209,15 @@ impl<'a> AstTarget<'a> {
             ast::ItemKind::Impl(i) => {
                 AstTarget::Impl { item: kind, of_trait: i.of_trait.is_some() }
             }
-            ast::ItemKind::MacCall(..) => AstTarget::MacroCall(MacroCallAstTarget::Item(kind)),
+            ast::ItemKind::MacCall(..) => AstTarget::MacroCall,
             ast::ItemKind::MacroDef(..) => AstTarget::MacroDef(kind),
             ast::ItemKind::Delegation(..) => {
                 AstTarget::Delegation { target: DelegationAstTarget::Item(kind), mac: false }
             }
             ast::ItemKind::DelegationMac(..) => {
                 AstTarget::Delegation { target: DelegationAstTarget::Item(kind), mac: true }
             }
-            ast::ItemKind::TestBinderConstraints(..) => {
-                AstTarget::MacroCall(MacroCallAstTarget::Item(kind))
-            }
+            ast::ItemKind::TestBinderConstraints(..) => AstTarget::MacroCall,
         }
     }
 }

compiler/rustc_attr_parsing/src/attributes/link_attrs.rs

@@ -262,11 +262,15 @@ impl CombineAttributeParser for LinkParser {
     }
 
     fn finalize_check(cx: &mut FinalizeCheckContext<'_, '_>, attr_span: Span) {
-        match cx.ast_target {
-            rustc_attr_ir::target::AstTarget::ForeignMod(ast_item)
-                if let ItemKind::ForeignMod(fm) = &ast_item =>
-            {
-                let abi = fm.abi.map_or(ExternAbi::FALLBACK, |abi| {
+        let rustc_attr_ir::target::AstTarget::ForeignMod(ast_item) = cx.ast_target else {
+            return;
+        };
+
+        let ItemKind::ForeignMod(fm) = &ast_item else {
+            panic!("expected field ForeignMod for AstTarget::ForeignMod");
+        };
+
+        let abi = fm.abi.map_or(ExternAbi::FALLBACK, |abi| {
                 abi.symbol_unescaped.as_str().parse().unwrap_or_else(|_| {
                     cx.dcx().span_delayed_bug(
                         abi.span,
@@ -275,11 +279,8 @@ impl CombineAttributeParser for LinkParser {
                     ExternAbi::Rust
                     })
                 });
-                if matches!(abi, ExternAbi::Rust) {
-                    cx.emit_lint(UNUSED_ATTRIBUTES, Link, attr_span);
-                }
-            }
-            _ => {}
+        if matches!(abi, ExternAbi::Rust) {
+            cx.emit_lint(UNUSED_ATTRIBUTES, Link, attr_span);
         }
     }
 }

compiler/rustc_attr_parsing/src/attributes/macro_attrs.rs

@@ -182,15 +182,14 @@ impl SingleAttributeParser for MacroExportParser {
     }
 
     fn finalize_check(cx: &mut FinalizeCheckContext<'_, '_>, attr_span: Span) {
-        match cx.ast_target {
-            AstTarget::MacroDef(item_kind) => {
-                if let ItemKind::MacroDef(_, macro_def) = item_kind
-                    && !macro_def.macro_rules
-                {
-                    cx.emit_lint(UNUSED_ATTRIBUTES, MacroExport::OnDeclMacro, attr_span);
-                }
-            }
-            _ => {}
+        let AstTarget::MacroDef(item_kind) = cx.ast_target else {
+            return;
+        };
+
+        if let ItemKind::MacroDef(_, macro_def) = item_kind
+            && !macro_def.macro_rules
+        {
+            cx.emit_lint(UNUSED_ATTRIBUTES, MacroExport::OnDeclMacro, attr_span);
         }
     }
 }

compiler/rustc_attr_parsing/src/attributes/non_exhaustive.rs

@@ -22,24 +22,21 @@ impl NoArgsAttributeParser for NonExhaustiveParser {
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::NonExhaustive;
 
     fn finalize_check(cx: &mut FinalizeCheckContext<'_, '_>, attr_span: Span) {
-        if cx.target != Target::Struct {
+        let rustc_attr_ir::target::AstTarget::Struct(ast_item) = cx.ast_target else {
             return;
-        }
+        };
+
+        let ItemKind::Struct(_, _, data) = ast_item else {
+            panic!("expected struct AST target item for AstTarget::Struct");
+        };
 
-        match cx.ast_target {
-            rustc_attr_ir::target::AstTarget::Struct(ast_item)
-                if let ItemKind::Struct(_, _, data) = &ast_item =>
-            {
-                if let VariantData::Struct { fields, .. } = data
-                    && fields.iter().any(|f| f.default_value().is_some())
-                {
-                    cx.emit_err(NonExhaustiveWithDefaultFieldValues {
-                        attr_span,
-                        defn_span: cx.target_span,
-                    });
-                }
-            }
-            _ => {}
+        if let VariantData::Struct { fields, .. } = data
+            && fields.iter().any(|f| f.default_value().is_some())
+        {
+            cx.emit_err(NonExhaustiveWithDefaultFieldValues {
+                attr_span,
+                defn_span: cx.target_span,
+            });
         }
     }
 }