Allow matching on argument parsers

Author: jdonszelmann

,

@@ -0,0 +1 @@
+  4             } else if let Some((feature, level)) = parse_stability(cx, args) {                                                                          │  3         (<unsize>&*&[sym::unstable], <closure-to-fn-pointer>|this: &mut StabilityGroup, cx: &AttributeAcceptContext<_ args:

compiler/rustc_attr_parsing/messages.ftl

@@ -90,6 +90,8 @@ attr_parsing_multiple_stability_levels =
 attr_parsing_non_ident_feature =
     'feature' is not an identifier
 
+attr_parsing_repr_ident =
+    meta item in `repr` must be an identifier
 attr_parsing_rustc_allowed_unstable_pairing =
     `rustc_allowed_through_unstable_modules` attribute must be paired with a `stable` attribute
 
@@ -108,6 +110,10 @@ attr_parsing_unknown_meta_item =
 attr_parsing_unknown_version_literal =
     unknown version literal format, assuming it refers to a future version
 
+attr_parsing_unrecognized_repr_hint =
+    unrecognized representation hint
+    .help = valid reprs are `Rust` (default), `C`, `align`, `packed`, `transparent`, `simd`, `i8`, `u8`, `i16`, `u16`, `i32`, `u32`, `i64`, `u64`, `i128`, `u128`, `isize`, `usize`
+
 attr_parsing_unstable_cfg_target_compact =
     compact `cfg(target(..))` is experimental and subject to change
 

compiler/rustc_attr_parsing/src/attributes/confusables.rs

@@ -2,10 +2,10 @@ use rustc_attr_data_structures::AttributeKind;
 use rustc_span::{Span, Symbol, sym};
 use thin_vec::ThinVec;
 
-use super::{AcceptMapping, AttributeParser};
-use crate::context::FinalizeContext;
 use crate::session_diagnostics;
 
+use super::{AcceptMapping, AttributeParser, FinalizeContext};
+
 #[derive(Default)]
 pub(crate) struct ConfusablesParser {
     confusables: ThinVec<Symbol>,

compiler/rustc_attr_parsing/src/context.rs

@@ -243,7 +243,7 @@ impl<'sess> AttributeParser<'sess> {
                 //     }))
                 // }
                 ast::AttrKind::Normal(n) => {
-                    let parser = MetaItemParser::from_attr(&n, self.dcx());
+                    let parser = MetaItemParser::from_attr(n, self.dcx());
                     let (path, args) = parser.deconstruct();
                     let parts = path.segments().map(|i| i.name).collect::<Vec<_>>();
 

compiler/rustc_hir/src/hir.rs

@@ -1105,7 +1105,9 @@ impl AttributeExt for Attribute {
     fn span(&self) -> Span {
         match &self {
             Attribute::Unparsed(u) => u.span,
-            _ => panic!(),
+            // FIXME: should not be needed anymore when all attrs are parsed
+            Attribute::Parsed(AttributeKind::Deprecation { span, .. }) => *span,
+            a => panic!("can't get the span of an arbitrary parsed attribute: {a:?}"),
         }
     }
 

compiler/rustc_passes/src/check_attr.rs

@@ -604,6 +604,17 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                         continue;
                     }
 
+                    // FIXME(jdonszelmann): once naked uses new-style parsing,
+                    // this check can be part of the parser and be removed here
+                    match other_attr {
+                        Attribute::Parsed(
+                            AttributeKind::Deprecation { .. } | AttributeKind::Repr { .. },
+                        ) => {
+                            continue;
+                        }
+                        _ => {}
+                    }
+
                     if !ALLOW_LIST.iter().any(|name| other_attr.has_name(*name)) {
                         self.dcx().emit_err(errors::NakedFunctionIncompatibleAttribute {
                             span: other_attr.span(),