Remove from MetaItemParser::from_attr

Author: JonathanBrouwer

compiler/rustc_attr_parsing/src/interface.rs

@@ -1,4 +1,5 @@
 use std::borrow::Cow;
+use std::convert::identity;
 
 use rustc_ast as ast;
 use rustc_ast::{AttrStyle, NodeId, Safety};
@@ -12,7 +13,7 @@ use rustc_session::lint::BuiltinLintDiag;
 use rustc_span::{DUMMY_SP, Span, Symbol, sym};
 
 use crate::context::{AcceptContext, FinalizeContext, SharedContext, Stage};
-use crate::parser::{ArgParser, MetaItemParser, PathParser};
+use crate::parser::{ArgParser, PathParser};
 use crate::session_diagnostics::ParsedDescription;
 use crate::{Early, Late, OmitDoc, ShouldEmit};
 
@@ -143,22 +144,23 @@ impl<'sess> AttributeParser<'sess, Early> {
         };
         let parts =
             normal_attr.item.path.segments.iter().map(|seg| seg.ident.name).collect::<Vec<_>>();
-        let meta_parser = MetaItemParser::from_attr(normal_attr, &parts, &sess.psess, emit_errors)?;
-        let path = meta_parser.path();
-        let args = meta_parser.args();
+
+        let path = AttrPath::from_ast(&normal_attr.item.path, identity);
+        let args =
+            ArgParser::from_attr_args(&normal_attr.item.args, &parts, &sess.psess, emit_errors)?;
         Self::parse_single_args(
             sess,
             attr.span,
             normal_attr.item.span(),
             attr.style,
-            path.get_attribute_path(),
+            path,
             Some(normal_attr.item.unsafety),
             ParsedDescription::Attribute,
             target_span,
             target_node_id,
             features,
             emit_errors,
-            args,
+            &args,
             parse_fn,
             template,
         )
@@ -325,15 +327,14 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                         n.item.path.segments.iter().map(|seg| seg.ident.name).collect::<Vec<_>>();
 
                     if let Some(accepts) = S::parsers().accepters.get(parts.as_slice()) {
-                        let Some(parser) = MetaItemParser::from_attr(
-                            n,
+                        let Some(args) = ArgParser::from_attr_args(
+                            &n.item.args,
                             &parts,
                             &self.sess.psess,
                             self.stage.should_emit(),
                         ) else {
                             continue;
                         };
-                        let args = parser.args();
                         for accept in accepts {
                             let mut cx: AcceptContext<'_, 'sess, S> = AcceptContext {
                                 shared: SharedContext {
@@ -350,7 +351,7 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                                 attr_path: attr_path.clone(),
                             };
 
-                            (accept.accept_fn)(&mut cx, args);
+                            (accept.accept_fn)(&mut cx, &args);
                             if !matches!(cx.stage.should_emit(), ShouldEmit::Nothing) {
                                 Self::check_target(&accept.allowed_targets, target, &mut cx);
                             }

compiler/rustc_attr_parsing/src/parser.rs

@@ -8,7 +8,7 @@ use std::fmt::{Debug, Display};
 
 use rustc_ast::token::{self, Delimiter, MetaVarKind};
 use rustc_ast::tokenstream::TokenStream;
-use rustc_ast::{AttrArgs, Expr, ExprKind, LitKind, MetaItemLit, NormalAttr, Path};
+use rustc_ast::{AttrArgs, Expr, ExprKind, LitKind, MetaItemLit, Path};
 use rustc_ast_pretty::pprust;
 use rustc_errors::{Diag, PResult};
 use rustc_hir::{self as hir, AttrPath};
@@ -252,22 +252,6 @@ impl<'a> Debug for MetaItemParser<'a> {
     }
 }
 
-impl<'a> MetaItemParser<'a> {
-    /// Create a new parser from a [`NormalAttr`], which is stored inside of any
-    /// [`ast::Attribute`](rustc_ast::Attribute)
-    pub fn from_attr<'sess>(
-        attr: &'a NormalAttr,
-        parts: &[Symbol],
-        psess: &'sess ParseSess,
-        should_emit: ShouldEmit,
-    ) -> Option<Self> {
-        Some(Self {
-            path: PathParser(Cow::Borrowed(&attr.item.path)),
-            args: ArgParser::from_attr_args(&attr.item.args, parts, psess, should_emit)?,
-        })
-    }
-}
-
 impl<'a> MetaItemParser<'a> {
     pub fn span(&self) -> Span {
         if let Some(other) = self.args.span() {