WIP

Author: petrochenkov

src/librustc_ast/attr/mod.rs

@@ -177,6 +177,10 @@ impl Attribute {
     /// If it matches, then the attribute is marked as used.
     /// Should only be used by rustc, other tools can use `has_name` instead.
     pub fn check_name(&self, name: Symbol) -> bool {
+        self.has_name(name)
+    }
+
+    pub fn check_name2(&self, name: Symbol) -> bool {
         let matches = self.has_name(name);
         if matches {
             mark_used(self);
@@ -413,18 +417,34 @@ pub fn contains_name(attrs: &[Attribute], name: Symbol) -> bool {
     attrs.iter().any(|item| item.check_name(name))
 }
 
+pub fn contains_name2(attrs: &[Attribute], name: Symbol) -> bool {
+    attrs.iter().any(|item| item.check_name2(name))
+}
+
 pub fn find_by_name(attrs: &[Attribute], name: Symbol) -> Option<&Attribute> {
     attrs.iter().find(|attr| attr.check_name(name))
 }
 
+pub fn find_by_name2(attrs: &[Attribute], name: Symbol) -> Option<&Attribute> {
+    attrs.iter().find(|attr| attr.check_name2(name))
+}
+
 pub fn filter_by_name(attrs: &[Attribute], name: Symbol) -> impl Iterator<Item = &Attribute> {
     attrs.iter().filter(move |attr| attr.check_name(name))
 }
 
+pub fn filter_by_name2(attrs: &[Attribute], name: Symbol) -> impl Iterator<Item = &Attribute> {
+    attrs.iter().filter(move |attr| attr.check_name2(name))
+}
+
 pub fn first_attr_value_str_by_name(attrs: &[Attribute], name: Symbol) -> Option<Symbol> {
     attrs.iter().find(|at| at.check_name(name)).and_then(|at| at.value_str())
 }
 
+pub fn first_attr_value_str_by_name2(attrs: &[Attribute], name: Symbol) -> Option<Symbol> {
+    attrs.iter().find(|at| at.check_name2(name)).and_then(|at| at.value_str())
+}
+
 impl MetaItem {
     fn token_trees_and_joints(&self) -> Vec<TreeAndJoint> {
         let mut idents = vec![];

src/librustc_ast_lowering/lib.rs

@@ -2236,7 +2236,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             hir_id: self.lower_node_id(param.id),
             name,
             span: param.ident.span,
-            pure_wrt_drop: attr::contains_name(&param.attrs, sym::may_dangle),
+            pure_wrt_drop: attr::contains_name2(&param.attrs, sym::may_dangle),
             attrs: self.lower_attrs(&param.attrs),
             bounds: self.arena.alloc_from_iter(bounds),
             kind,

src/librustc_attr/builtin.rs

@@ -1,6 +1,6 @@
 //! Parsing and validation of builtin attributes
 
-use super::{find_by_name, mark_used};
+use super::find_by_name;
 
 use rustc_ast::ast::{self, Attribute, Lit, LitKind, MetaItem, MetaItemKind, NestedMetaItem};
 use rustc_ast_pretty::pprust;
@@ -214,8 +214,6 @@ where
             continue; // not a stability level
         }
 
-        mark_used(attr);
-
         let meta = attr.meta();
 
         if attr.has_name(sym::rustc_promotable) {
@@ -650,7 +648,7 @@ where
     let diagnostic = &sess.span_diagnostic;
 
     'outer: for attr in attrs_iter {
-        if !(attr.check_name(sym::deprecated) || attr.check_name(sym::rustc_deprecated)) {
+        if !(attr.check_name2(sym::deprecated) || attr.check_name(sym::rustc_deprecated)) {
             continue;
         }
 
@@ -773,8 +771,6 @@ where
             }
         }
 
-        mark_used(&attr);
-
         let is_since_rustc_version = attr.check_name(sym::rustc_deprecated);
         depr = Some(Deprecation { since, note, suggestion, is_since_rustc_version });
     }
@@ -823,9 +819,8 @@ pub fn find_repr_attrs(sess: &ParseSess, attr: &Attribute) -> Vec<ReprAttr> {
 
     let mut acc = Vec::new();
     let diagnostic = &sess.span_diagnostic;
-    if attr.has_name(sym::repr) {
+    if attr.check_name2(sym::repr) {
         if let Some(items) = attr.meta_item_list() {
-            mark_used(attr);
             for item in items {
                 if !item.is_meta_item() {
                     handle_errors(

src/librustc_builtin_macros/deriving/generic/mod.rs

@@ -676,8 +676,6 @@ impl<'a> TraitDef<'a> {
         let self_type = cx.ty_path(path);
 
         let attr = cx.attribute(cx.meta_word(self.span, sym::automatically_derived));
-        // Just mark it now since we know that it'll end up used downstream
-        attr::mark_used(&attr);
         let opt_trait_ref = Some(trait_ref);
         let unused_qual = {
             let word = rustc_ast::attr::mk_nested_word_item(Ident::new(

src/librustc_builtin_macros/proc_macro_harness.rs

@@ -264,6 +264,7 @@ impl<'a> Visitor<'a> for CollectProcMacros<'a> {
 
         for attr in &item.attrs {
             if is_proc_macro_attr(&attr) {
+                attr::mark_used(attr);
                 if let Some(prev_attr) = found_attr {
                     let prev_item = prev_attr.get_normal_item();
                     let item = attr.get_normal_item();

src/librustc_builtin_macros/standard_library_imports.rs

@@ -17,9 +17,9 @@ pub fn inject(
     let rust_2018 = sess.edition >= Edition::Edition2018;
 
     // the first name in this list is the crate name of the crate with the prelude
-    let names: &[Symbol] = if attr::contains_name(&krate.attrs, sym::no_core) {
+    let names: &[Symbol] = if attr::contains_name2(&krate.attrs, sym::no_core) {
         return (krate, None);
-    } else if attr::contains_name(&krate.attrs, sym::no_std) {
+    } else if attr::contains_name2(&krate.attrs, sym::no_std) {
         if attr::contains_name(&krate.attrs, sym::compiler_builtins) {
             &[sym::core]
         } else {

src/librustc_builtin_macros/test.rs

@@ -319,15 +319,15 @@ enum ShouldPanic {
 }
 
 fn should_ignore(i: &ast::Item) -> bool {
-    attr::contains_name(&i.attrs, sym::ignore)
+    attr::contains_name2(&i.attrs, sym::ignore)
 }
 
 fn should_fail(i: &ast::Item) -> bool {
-    attr::contains_name(&i.attrs, sym::allow_fail)
+    attr::contains_name2(&i.attrs, sym::allow_fail)
 }
 
 fn should_panic(cx: &ExtCtxt<'_>, i: &ast::Item) -> ShouldPanic {
-    match attr::find_by_name(&i.attrs, sym::should_panic) {
+    match attr::find_by_name2(&i.attrs, sym::should_panic) {
         Some(attr) => {
             let sd = &cx.parse_sess.span_diagnostic;
 

src/librustc_builtin_macros/test_harness.rs

@@ -51,7 +51,7 @@ pub fn inject(
     // unconditional, so that the attribute is still marked as used in
     // non-test builds.
     let reexport_test_harness_main =
-        attr::first_attr_value_str_by_name(&krate.attrs, sym::reexport_test_harness_main);
+        attr::first_attr_value_str_by_name2(&krate.attrs, sym::reexport_test_harness_main);
 
     // Do this here so that the test_runner crate attribute gets marked as used
     // even in non-test builds
@@ -344,7 +344,7 @@ fn is_test_case(i: &ast::Item) -> bool {
 }
 
 fn get_test_runner(sd: &rustc_errors::Handler, krate: &ast::Crate) -> Option<ast::Path> {
-    let test_attr = attr::find_by_name(&krate.attrs, sym::test_runner)?;
+    let test_attr = attr::find_by_name2(&krate.attrs, sym::test_runner)?;
     let meta_list = test_attr.meta_item_list()?;
     let span = test_attr.span;
     match &*meta_list {

src/librustc_expand/base.rs

@@ -818,7 +818,7 @@ impl SyntaxExtension {
             kind,
             span,
             allow_internal_unstable,
-            allow_internal_unsafe: attr::contains_name(attrs, sym::allow_internal_unsafe),
+            allow_internal_unsafe: attr::contains_name2(attrs, sym::allow_internal_unsafe),
             local_inner_macros,
             stability,
             deprecation: attr::find_deprecation(&sess, attrs, span),

src/librustc_expand/config.rs

@@ -70,7 +70,7 @@ fn get_features(
     // Process the edition umbrella feature-gates first, to ensure
     // `edition_enabled_features` is completed before it's queried.
     for attr in krate_attrs {
-        if !attr.check_name(sym::feature) {
+        if !attr.check_name2(sym::feature) {
             continue;
         }
 
@@ -280,9 +280,6 @@ impl<'a> StripUnconfigured<'a> {
             return vec![attr];
         }
 
-        // At this point we know the attribute is considered used.
-        attr::mark_used(&attr);
-
         if !attr::cfg_matches(&cfg_predicate, self.sess, self.features) {
             return vec![];
         }
@@ -528,5 +525,5 @@ impl<'a> MutVisitor for StripUnconfigured<'a> {
 }
 
 fn is_cfg(attr: &Attribute) -> bool {
-    attr.check_name(sym::cfg)
+    attr.check_name2(sym::cfg)
 }