matching on 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_data_structures/src/attributes.rs

@@ -1,5 +1,4 @@
 use rustc_abi::Align;
-
 use rustc_ast::token::CommentKind;
 use rustc_ast::{self as ast, AttrStyle};
 use rustc_macros::{Decodable, Encodable, HashStable_Generic};

compiler/rustc_attr_parsing/messages.ftl

@@ -66,10 +66,6 @@ attr_parsing_invalid_repr_hint_no_paren =
 attr_parsing_invalid_repr_hint_no_value =
     invalid representation hint: `{$name}` does not take a value
 
-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_invalid_since =
     'since' must be a Rust version number, such as "1.31.0"
 
@@ -94,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
 
@@ -112,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
 
@@ -132,6 +134,3 @@ attr_parsing_unused_multiple =
     multiple `{$name}` attributes
     .suggestion = remove this attribute
     .note = attribute also specified here
-
-attr_parsing_repr_ident =
-    meta item in `repr` must be an identifier

compiler/rustc_attr_parsing/src/attributes/allow_unstable.rs

@@ -3,7 +3,7 @@ use rustc_span::{Symbol, sym};
 
 use super::{CombineAttributeGroup, ConvertFn};
 use crate::context::AttributeAcceptContext;
-use crate::parser::{ArgParser, GenericArgParser, MetaItemParser};
+use crate::parser::ArgParser;
 use crate::session_diagnostics;
 
 pub(crate) struct AllowInternalUnstableGroup;
@@ -14,7 +14,7 @@ impl CombineAttributeGroup for AllowInternalUnstableGroup {
 
     fn extend<'a>(
         cx: &'a AttributeAcceptContext<'a>,
-        args: &'a GenericArgParser<'a, rustc_ast::Expr>,
+        args: &'a ArgParser<'a>,
     ) -> impl IntoIterator<Item = Self::Item> + 'a {
         parse_unstable(cx, args, Self::PATH[0])
     }
@@ -28,15 +28,15 @@ impl CombineAttributeGroup for AllowConstFnUnstableGroup {
 
     fn extend<'a>(
         cx: &'a AttributeAcceptContext<'a>,
-        args: &'a GenericArgParser<'a, rustc_ast::Expr>,
+        args: &'a ArgParser<'a>,
     ) -> impl IntoIterator<Item = Self::Item> + 'a {
         parse_unstable(cx, args, Self::PATH[0])
     }
 }
 
 fn parse_unstable<'a>(
     cx: &AttributeAcceptContext<'_>,
-    args: &'a impl ArgParser<'a>,
+    args: &'a ArgParser<'a>,
     symbol: Symbol,
 ) -> impl IntoIterator<Item = Symbol> {
     let mut res = Vec::new();

compiler/rustc_attr_parsing/src/attributes/cfg.rs

@@ -11,8 +11,8 @@ use rustc_session::parse::feature_err;
 use rustc_span::symbol::kw;
 use rustc_span::{Span, Symbol, sym};
 
-use crate::{fluent_generated, parse_version};
 use crate::session_diagnostics::{self, UnsupportedLiteralReason};
+use crate::{fluent_generated, parse_version};
 
 #[derive(Clone, Debug)]
 pub struct Condition {

compiler/rustc_attr_parsing/src/attributes/confusables.rs

@@ -5,7 +5,6 @@ use thin_vec::ThinVec;
 
 use super::{AttributeGroup, AttributeMapping};
 use crate::context::AttributeGroupContext;
-use crate::parser::ArgParser;
 use crate::session_diagnostics;
 
 // TODO: turn into CombineGroup?

compiler/rustc_attr_parsing/src/attributes/deprecation.rs

@@ -5,17 +5,17 @@ use rustc_span::{Span, Symbol, sym};
 use super::SingleAttributeGroup;
 use super::util::parse_version;
 use crate::context::AttributeAcceptContext;
-use crate::parser::{ArgParser, GenericArgParser, MetaItemParser, NameValueParser};
+use crate::parser::ArgParser;
 use crate::session_diagnostics;
 use crate::session_diagnostics::UnsupportedLiteralReason;
 
 pub(crate) struct DeprecationGroup;
 
-fn get<'a>(
+fn get(
     cx: &AttributeAcceptContext<'_>,
     ident: Ident,
     param_span: Span,
-    arg: impl ArgParser<'a>,
+    arg: &ArgParser<'_>,
     item: &mut Option<Symbol>,
 ) -> bool {
     if item.is_some() {
@@ -32,7 +32,7 @@ fn get<'a>(
         } else {
             let lit = v.value_as_lit();
             cx.dcx().emit_err(session_diagnostics::UnsupportedLiteral {
-                span: v.value_span(),
+                span: v.value_span,
                 reason: UnsupportedLiteralReason::DeprecatedString,
                 is_bytestr: lit.kind.is_bytestr(),
                 start_point_span: cx.sess().source_map().start_point(lit.span),
@@ -52,7 +52,7 @@ fn get<'a>(
 impl SingleAttributeGroup for DeprecationGroup {
     const PATH: &'static [rustc_span::Symbol] = &[sym::deprecated];
 
-    fn on_duplicate(cx: &crate::context::AttributeAcceptContext<'_>, first_span: rustc_span::Span) {
+    fn on_duplicate(cx: &AttributeAcceptContext<'_>, first_span: rustc_span::Span) {
         // FIXME(jdonszelmann): merge with errors from check_attrs.rs
         cx.dcx().emit_err(session_diagnostics::UnusedMultiple {
             this: cx.attr_span,
@@ -61,10 +61,7 @@ impl SingleAttributeGroup for DeprecationGroup {
         });
     }
 
-    fn convert(
-        cx: &AttributeAcceptContext<'_>,
-        args: &GenericArgParser<'_, rustc_ast::Expr>,
-    ) -> Option<AttributeKind> {
+    fn convert(cx: &AttributeAcceptContext<'_>, args: &ArgParser<'_>) -> Option<AttributeKind> {
         let features = cx.features();
 
         let mut since = None;

compiler/rustc_attr_parsing/src/attributes/mod.rs

@@ -17,13 +17,12 @@
 
 use std::marker::PhantomData;
 
-use rustc_ast::Expr;
 use rustc_attr_data_structures::AttributeKind;
 use rustc_span::Span;
 use thin_vec::ThinVec;
 
 use crate::context::{AttributeAcceptContext, AttributeGroupContext};
-use crate::parser::GenericArgParser;
+use crate::parser::ArgParser;
 
 pub(crate) mod allow_unstable;
 pub(crate) mod cfg;
@@ -34,7 +33,7 @@ pub(crate) mod stability;
 pub(crate) mod transparency;
 pub(crate) mod util;
 
-type AttributeHandler<T> = fn(&mut T, &AttributeAcceptContext<'_>, &GenericArgParser<'_, Expr>);
+type AttributeHandler<T> = fn(&mut T, &AttributeAcceptContext<'_>, &ArgParser<'_>);
 type AttributeMapping<T> = &'static [(&'static [rustc_span::Symbol], AttributeHandler<T>)];
 
 /// An [`AttributeGroup`] is a type which searches for syntactic attributes.
@@ -75,10 +74,7 @@ pub(crate) trait SingleAttributeGroup: 'static {
 
     /// The extractor has gotten a chance to accept the attributes on an item,
     /// now produce an attribute.
-    fn convert(
-        cx: &AttributeAcceptContext<'_>,
-        args: &GenericArgParser<'_, Expr>,
-    ) -> Option<AttributeKind>;
+    fn convert(cx: &AttributeAcceptContext<'_>, args: &ArgParser<'_>) -> Option<AttributeKind>;
 }
 
 pub(crate) struct Single<T: SingleAttributeGroup>(PhantomData<T>, Option<(AttributeKind, Span)>);
@@ -125,7 +121,7 @@ pub(crate) trait CombineAttributeGroup: 'static {
     /// now produce an attribute.
     fn extend<'a>(
         cx: &'a AttributeAcceptContext<'a>,
-        args: &'a GenericArgParser<'a, Expr>,
+        args: &'a ArgParser<'a>,
     ) -> impl IntoIterator<Item = Self::Item> + 'a;
 }
 

compiler/rustc_attr_parsing/src/attributes/repr.rs

@@ -6,10 +6,7 @@ use rustc_span::{Span, Symbol, sym};
 
 use super::{CombineAttributeGroup, ConvertFn};
 use crate::context::AttributeAcceptContext;
-use crate::parser::{
-    ArgParser, GenericArgParser, MetaItemListParser, MetaItemOrLitParser, MetaItemParser,
-    NameValueParser,
-};
+use crate::parser::{ArgParser, MetaItemListParser, MetaItemOrLitParser, MetaItemParser};
 use crate::session_diagnostics;
 use crate::session_diagnostics::IncorrectReprFormatGenericCause;
 
@@ -30,7 +27,7 @@ impl CombineAttributeGroup for ReprGroup {
 
     fn extend<'a>(
         cx: &'a AttributeAcceptContext<'a>,
-        args: &'a GenericArgParser<'a, rustc_ast::Expr>,
+        args: &'a ArgParser<'a>,
     ) -> impl IntoIterator<Item = Self::Item> + 'a {
         let mut reprs = Vec::new();
 
@@ -49,7 +46,7 @@ impl CombineAttributeGroup for ReprGroup {
 
 fn parse_repr<'a, 'b>(
     cx: &AttributeAcceptContext<'_>,
-    param: &'a impl MetaItemParser<'b>,
+    param: &'a MetaItemParser<'b>,
 ) -> Option<ReprAttr> {
     // FIXME(jdonszelmann): invert the parsing here to match on the word first and then the
     // structure.
@@ -68,10 +65,10 @@ fn parse_repr<'a, 'b>(
     }
 }
 
-fn parse_list_repr<'b>(
+fn parse_list_repr(
     cx: &AttributeAcceptContext<'_>,
     ident: Ident,
-    list: MetaItemListParser<'b>,
+    list: &MetaItemListParser<'_>,
     param_span: Span,
 ) -> Option<ReprAttr> {
     if let Some(single) = list.single() {
@@ -156,7 +153,7 @@ fn reject_not_literal_list(
 fn reject_name_value_repr(
     cx: &AttributeAcceptContext<'_>,
     ident: Ident,
-    value: MetaItemLit,
+    value: &MetaItemLit,
     param_span: Span,
 ) {
     match ident.name {
@@ -193,7 +190,7 @@ fn reject_name_value_repr(
 fn parse_singleton_list_repr(
     cx: &AttributeAcceptContext<'_>,
     ident: Ident,
-    lit: MetaItemLit,
+    lit: &MetaItemLit,
     param_span: Span,
 ) -> Option<ReprAttr> {
     match ident.name {

compiler/rustc_attr_parsing/src/attributes/stability.rs

@@ -1,12 +1,14 @@
 use std::num::NonZero;
 
-use rustc_attr_data_structures::{AllowedThroughUnstableModules, AttributeKind, DefaultBodyStability, PartialConstStability, Stability, StabilityLevel, StableSince, UnstableReason, VERSION_PLACEHOLDER};
+use rustc_attr_data_structures::{
+    AllowedThroughUnstableModules, AttributeKind, DefaultBodyStability, PartialConstStability, Stability, StabilityLevel, StableSince, UnstableReason, VERSION_PLACEHOLDER
+};
 use rustc_span::{ErrorGuaranteed, Span, Symbol, sym};
 
 use super::util::parse_version;
 use super::{AttributeGroup, AttributeMapping, SingleAttributeGroup};
 use crate::context::{AttributeAcceptContext, AttributeGroupContext};
-use crate::parser::{ArgParser, MetaItemParser, NameValueParser};
+use crate::parser::{ArgParser, MetaItemParser};
 use crate::session_diagnostics::{self, UnsupportedLiteralReason};
 
 #[derive(Default)]
@@ -112,10 +114,7 @@ impl SingleAttributeGroup for ConstStabilityIndirectGroup {
     // ignore
     fn on_duplicate(_cx: &AttributeAcceptContext<'_>, _first_span: Span) {}
 
-    fn convert(
-        _cx: &AttributeAcceptContext<'_>,
-        _args: &super::GenericArgParser<'_, rustc_ast::Expr>,
-    ) -> Option<AttributeKind> {
+    fn convert(_cx: &AttributeAcceptContext<'_>, _args: &ArgParser<'_>) -> Option<AttributeKind> {
         Some(AttributeKind::ConstStabilityIndirect)
     }
 }
@@ -190,9 +189,9 @@ impl AttributeGroup for ConstStabilityGroup {
 ///
 /// Emits an error when either the option was already Some, or the arguments weren't of form
 /// `name = value`
-fn insert_value_into_option_or_error<'a>(
+fn insert_value_into_option_or_error(
     cx: &AttributeAcceptContext<'_>,
-    param: &impl MetaItemParser<'a>,
+    param: &MetaItemParser<'_>,
     item: &mut Option<Symbol>,
 ) -> Option<()> {
     if item.is_some() {
@@ -217,9 +216,9 @@ fn insert_value_into_option_or_error<'a>(
 
 /// Read the content of a `stable`/`rustc_const_stable` attribute, and return the feature name and
 /// its stability information.
-pub(crate) fn parse_stability<'a>(
+pub(crate) fn parse_stability(
     cx: &AttributeAcceptContext<'_>,
-    args: &'a impl ArgParser<'a>,
+    args: &ArgParser<'_>,
 ) -> Option<(Symbol, StabilityLevel)> {
     let mut feature = None;
     let mut since = None;
@@ -283,9 +282,9 @@ pub(crate) fn parse_stability<'a>(
 
 // Read the content of a `unstable`/`rustc_const_unstable`/`rustc_default_body_unstable`
 /// attribute, and return the feature name and its stability information.
-pub(crate) fn parse_unstability<'a>(
+pub(crate) fn parse_unstability(
     cx: &AttributeAcceptContext<'_>,
-    args: &'a impl ArgParser<'a>,
+    args: &ArgParser<'_>,
 ) -> Option<(Symbol, StabilityLevel)> {
     let mut feature = None;
     let mut reason = None;

compiler/rustc_attr_parsing/src/attributes/transparency.rs

@@ -2,8 +2,8 @@ use rustc_attr_data_structures::AttributeKind;
 use rustc_span::hygiene::Transparency;
 use rustc_span::sym;
 
-use super::SingleAttributeGroup;
-use crate::parser::{ArgParser, NameValueParser};
+use super::{AttributeAcceptContext, SingleAttributeGroup};
+use crate::parser::ArgParser;
 
 pub(crate) struct TransparencyGroup;
 
@@ -17,10 +17,7 @@ impl SingleAttributeGroup for TransparencyGroup {
         cx.dcx().span_err(vec![first_span, cx.attr_span], "multiple macro transparency attributes");
     }
 
-    fn convert(
-        cx: &crate::context::AttributeAcceptContext<'_>,
-        args: &crate::parser::GenericArgParser<'_, rustc_ast::Expr>,
-    ) -> Option<AttributeKind> {
+    fn convert(cx: &AttributeAcceptContext<'_>, args: &ArgParser<'_>) -> Option<AttributeKind> {
         match args.name_value().and_then(|nv| nv.value_as_str()) {
             Some(sym::transparent) => Some(Transparency::Transparent),
             Some(sym::semitransparent) => Some(Transparency::SemiTransparent),

compiler/rustc_attr_parsing/src/context.rs

@@ -4,10 +4,10 @@ use std::ops::Deref;
 use std::sync::LazyLock;
 
 use rustc_ast::{self as ast, DelimArgs};
+use rustc_attr_data_structures::AttributeKind;
 use rustc_errors::DiagCtxtHandle;
 use rustc_feature::Features;
 use rustc_hir::{AttrArgs, AttrItem, AttrPath, Attribute, HashIgnoredAttrId};
-use rustc_attr_data_structures::AttributeKind;
 use rustc_session::Session;
 use rustc_span::symbol::kw;
 use rustc_span::{DUMMY_SP, Span, Symbol, sym};
@@ -21,17 +21,17 @@ use crate::attributes::stability::{
 };
 use crate::attributes::transparency::TransparencyGroup;
 use crate::attributes::{AttributeGroup, Combine, Single};
-use crate::parser::{GenericArgParser, GenericMetaItemParser, MetaItemParser};
+use crate::parser::{ArgParser, MetaItemParser};
 
 macro_rules! attribute_groups {
     (
         pub(crate) static $name: ident = [$($names: ty),* $(,)?];
     ) => {
         pub(crate) static $name: LazyLock<(
-            BTreeMap<&'static [Symbol], Vec<Box<dyn Fn(&AttributeAcceptContext<'_>, &GenericArgParser<'_, ast::Expr>) + Send + Sync>>>,
+            BTreeMap<&'static [Symbol], Vec<Box<dyn Fn(&AttributeAcceptContext<'_>, &ArgParser<'_>) + Send + Sync>>>,
             Vec<Box<dyn Send + Sync + Fn(&AttributeGroupContext<'_>) -> Option<AttributeKind>>>
         )> = LazyLock::new(|| {
-            let mut accepts = BTreeMap::<_, Vec<Box<dyn Fn(&AttributeAcceptContext<'_>, &GenericArgParser<'_, ast::Expr>) + Send + Sync>>>::new();
+            let mut accepts = BTreeMap::<_, Vec<Box<dyn Fn(&AttributeAcceptContext<'_>, &ArgParser<'_>) + Send + Sync>>>::new();
             let mut finalizes = Vec::<Box<dyn Send + Sync + Fn(&AttributeGroupContext<'_>) -> Option<AttributeKind>>>::new();
 
             $(
@@ -238,7 +238,7 @@ impl<'sess> AttributeParseContext<'sess> {
                 //     }))
                 // }
                 ast::AttrKind::Normal(n) => {
-                    let parser = GenericMetaItemParser::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<_>>();