fixup the entire compiler to use hir::Attribute

Author: jdonszelmann

compiler/rustc_ast/src/ast.rs

@@ -1697,7 +1697,7 @@ impl AttrArgs {
         match self {
             AttrArgs::Empty => None,
             AttrArgs::Delimited(args) => Some(args.dspan.entire()),
-            AttrArgs::Eq(eq_span, expr) => Some(eq_span.to(expr.span)),
+            AttrArgs::Eq { eq_span, value } => Some(eq_span.to(value.span)),
         }
     }
 
@@ -1707,7 +1707,7 @@ impl AttrArgs {
         match self {
             AttrArgs::Empty => TokenStream::default(),
             AttrArgs::Delimited(args) => args.tokens.clone(),
-            AttrArgs::Eq(_, expr) => TokenStream::from_ast(expr),
+            AttrArgs::Eq { eq_span: _, value } => TokenStream::from_ast(value),
         }
     }
 }

compiler/rustc_ast/src/attr/mod.rs

@@ -1,5 +1,6 @@
 //! Functions dealing with attributes and meta items.
 
+use std::fmt::Debug;
 use std::iter;
 use std::sync::atomic::{AtomicU32, Ordering};
 
@@ -68,7 +69,7 @@ impl AttributeExt for Attribute {
     fn value_span(&self) -> Option<Span> {
         match &self.kind {
             AttrKind::Normal(normal) => match &normal.item.args {
-                AttrArgs::Eq(_, l) => Some(l.span),
+                AttrArgs::Eq { eq_span: _, value } => Some(value.span),
                 _ => None,
             },
             AttrKind::DocComment(..) => None,
@@ -225,13 +226,13 @@ impl AttrItem {
             AttrArgs::Delimited(args) if args.delim == Delimiter::Parenthesis => {
                 MetaItemKind::list_from_tokens(args.tokens.clone())
             }
-            AttrArgs::Delimited(_) | AttrArgs::Eq(..) | AttrArgs::Empty => None,
+            AttrArgs::Delimited(_) | AttrArgs::Eq { .. } | AttrArgs::Empty => None,
         }
     }
 
     fn value_str(&self) -> Option<Symbol> {
         match &self.args {
-            AttrArgs::Eq(_, expr) => match expr.kind {
+            AttrArgs::Eq { eq_span: _, value } => match value.kind {
                 ExprKind::Lit(token_lit) => {
                     LitKind::from_token_lit(token_lit).ok().and_then(|lit| lit.str())
                 }
@@ -435,10 +436,10 @@ impl MetaItemKind {
                 MetaItemKind::list_from_tokens(tokens.clone()).map(MetaItemKind::List)
             }
             AttrArgs::Delimited(..) => None,
-            AttrArgs::Eq(_, expr) => match expr.kind {
+            AttrArgs::Eq { eq_span: _, value } => match value.kind {
                 ExprKind::Lit(token_lit) => {
                     // Turn failures to `None`, we'll get parse errors elsewhere.
-                    MetaItemLit::from_token_lit(token_lit, expr.span)
+                    MetaItemLit::from_token_lit(token_lit, value.span)
                         .ok()
                         .map(|lit| MetaItemKind::NameValue(lit))
                 }
@@ -636,15 +637,15 @@ pub fn mk_attr_name_value_str(
     span: Span,
 ) -> Attribute {
     let lit = token::Lit::new(token::Str, escape_string_symbol(val), None);
-    let expr = P(Expr {
+    let value = P(Expr {
         id: DUMMY_NODE_ID,
         kind: ExprKind::Lit(lit),
         span,
         attrs: AttrVec::new(),
         tokens: None,
     });
     let path = Path::from_ident(Ident::new(name, span));
-    let args = AttrArgs::Eq(span, expr);
+    let args = AttrArgs::Eq { eq_span: span, value };
     mk_attr(g, style, unsafety, path, args, span)
 }
 

compiler/rustc_ast/src/entry.rs

@@ -1,7 +1,7 @@
 use rustc_span::Symbol;
 use rustc_span::symbol::sym;
 
-use crate::{Attribute, attr};
+use crate::attr::{self, AttributeExt};
 
 #[derive(Debug)]
 pub enum EntryPointType {
@@ -37,7 +37,7 @@ pub enum EntryPointType {
 }
 
 pub fn entry_point_type(
-    attrs: &[Attribute],
+    attrs: &[impl AttributeExt],
     at_root: bool,
     name: Option<Symbol>,
 ) -> EntryPointType {

compiler/rustc_ast/src/mut_visit.rs

@@ -394,8 +394,8 @@ fn visit_attr_args<T: MutVisitor>(vis: &mut T, args: &mut AttrArgs) {
     match args {
         AttrArgs::Empty => {}
         AttrArgs::Delimited(args) => visit_delim_args(vis, args),
-        AttrArgs::Eq(eq_span, expr) => {
-            vis.visit_expr(expr);
+        AttrArgs::Eq { eq_span, value } => {
+            vis.visit_expr(value);
             vis.visit_span(eq_span);
         }
     }

compiler/rustc_ast/src/visit.rs

@@ -1234,7 +1234,7 @@ pub fn walk_attr_args<'a, V: Visitor<'a>>(visitor: &mut V, args: &'a AttrArgs) -
     match args {
         AttrArgs::Empty => {}
         AttrArgs::Delimited(_args) => {}
-        AttrArgs::Eq(_eq_span, expr) => try_visit!(visitor.visit_expr(expr)),
+        AttrArgs::Eq { eq_span: _, value } => try_visit!(visitor.visit_expr(value)),
     }
     V::Result::output()
 }

compiler/rustc_ast_lowering/src/expr.rs

@@ -1,5 +1,6 @@
 use std::assert_matches::assert_matches;
 
+use rustc_ast::attr::AttributeExt;
 use rustc_ast::ptr::P as AstP;
 use rustc_ast::*;
 use rustc_data_structures::stack::ensure_sufficient_stack;

compiler/rustc_ast_lowering/src/item.rs

@@ -1,3 +1,4 @@
+use rustc_ast::attr::AttributeExt;
 use rustc_ast::ptr::P;
 use rustc_ast::visit::AssocCtxt;
 use rustc_ast::*;

compiler/rustc_ast_lowering/src/lib.rs

@@ -976,11 +976,11 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             // This is an inert key-value attribute - it will never be visible to macros
             // after it gets lowered to HIR. Therefore, we can extract literals to handle
             // nonterminals in `#[doc]` (e.g. `#[doc = $e]`).
-            AttrArgs::Eq(eq_span, AttrArgsEq::Ast(expr)) => {
+            AttrArgs::Eq { eq_span, value } => {
                 // In valid code the value always ends up as a single literal. Otherwise, a dummy
                 // literal suffices because the error is handled elsewhere.
-                let lit = if let ExprKind::Lit(token_lit) = expr.kind
-                    && let Ok(lit) = MetaItemLit::from_token_lit(token_lit, expr.span)
+                let lit = if let ExprKind::Lit(token_lit) = value.kind
+                    && let Ok(lit) = MetaItemLit::from_token_lit(token_lit, value.span)
                 {
                     lit
                 } else {
@@ -992,10 +992,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         span: DUMMY_SP,
                     }
                 };
-                AttrArgs::Eq(*eq_span, AttrArgsEq::Hir(lit))
-            }
-            AttrArgs::Eq(_, AttrArgsEq::Hir(lit)) => {
-                unreachable!("in literal form when lowering mac args eq: {:?}", lit)
+                hir::AttrArgs::Eq { eq_span: *eq_span, value: lit }
             }
         }
     }
@@ -2512,7 +2509,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
     fn stmt_let_pat(
         &mut self,
-        attrs: Option<&'hir [Attribute]>,
+        attrs: Option<&'hir [hir::Attribute]>,
         span: Span,
         init: Option<&'hir hir::Expr<'hir>>,
         pat: &'hir hir::Pat<'hir>,

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -19,6 +19,7 @@
 use std::mem;
 use std::ops::{Deref, DerefMut};
 
+use attr::AttributeExt;
 use itertools::{Either, Itertools};
 use rustc_ast::ptr::P;
 use rustc_ast::visit::{AssocCtxt, BoundKind, FnCtxt, FnKind, Visitor, walk_list};
@@ -383,7 +384,7 @@ impl<'a> AstValidator<'a> {
                     sym::forbid,
                     sym::warn,
                 ];
-                !arr.contains(&attr.name_or_empty()) && rustc_attr::is_builtin_attr(attr)
+                !arr.contains(&attr.name_or_empty()) && rustc_attr::is_builtin_attr(*attr)
             })
             .for_each(|attr| {
                 if attr.is_doc_comment() {

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -1,4 +1,5 @@
 use rustc_ast as ast;
+use rustc_ast::attr::AttributeExt;
 use rustc_ast::visit::{self, AssocCtxt, FnCtxt, FnKind, Visitor};
 use rustc_ast::{NodeId, PatKind, attr, token};
 use rustc_feature::{AttributeGate, BUILTIN_ATTRIBUTE_MAP, BuiltinAttribute, Features, GateIssue};