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)
 }

src/librustc_expand/module.rs

@@ -102,7 +102,7 @@ crate fn push_directory(
     attrs: &[Attribute],
     Directory { mut ownership, mut path }: Directory,
 ) -> Directory {
-    if let Some(filename) = attr::first_attr_value_str_by_name(attrs, sym::path) {
+    if let Some(filename) = attr::first_attr_value_str_by_name2(attrs, sym::path) {
         path.push(&*filename.as_str());
         ownership = DirectoryOwnership::Owned { relative: None };
     } else {
@@ -220,7 +220,7 @@ fn error_cannot_declare_mod_here<'a, T>(
 // Public for rustfmt usage.
 pub fn submod_path_from_attr(attrs: &[Attribute], dir_path: &Path) -> Option<PathBuf> {
     // Extract path string from first `#[path = "path_string"]` attribute.
-    let path_string = attr::first_attr_value_str_by_name(attrs, sym::path)?;
+    let path_string = attr::first_attr_value_str_by_name2(attrs, sym::path)?;
     let path_string = path_string.as_str();
 
     // On windows, the base path might have the form

src/librustc_hir/lang_items.rs

@@ -144,9 +144,9 @@ impl<CTX> HashStable<CTX> for LangItem {
 pub fn extract(attrs: &[ast::Attribute]) -> Option<(Symbol, Span)> {
     attrs.iter().find_map(|attr| {
         Some(match attr {
-            _ if attr.check_name(sym::lang) => (attr.value_str()?, attr.span),
-            _ if attr.check_name(sym::panic_handler) => (sym::panic_impl, attr.span),
-            _ if attr.check_name(sym::alloc_error_handler) => (sym::oom, attr.span),
+            _ if attr.check_name2(sym::lang) => (attr.value_str()?, attr.span),
+            _ if attr.check_name2(sym::panic_handler) => (sym::panic_impl, attr.span),
+            _ if attr.check_name2(sym::alloc_error_handler) => (sym::oom, attr.span),
             _ => return None,
         })
     })

src/librustc_interface/util.rs

@@ -469,7 +469,7 @@ pub fn collect_crate_types(session: &Session, attrs: &[ast::Attribute]) -> Vec<C
     let attr_types: Vec<CrateType> = attrs
         .iter()
         .filter_map(|a| {
-            if a.check_name(sym::crate_type) {
+            if a.check_name2(sym::crate_type) {
                 match a.value_str() {
                     Some(s) => categorize_crate_type(s),
                     _ => None,

src/librustc_lint/builtin.rs

@@ -737,7 +737,7 @@ impl EarlyLintPass for DeprecatedAttr {
                 return;
             }
         }
-        if attr.check_name(sym::no_start) || attr.check_name(sym::crate_id) {
+        if attr.check_name2(sym::no_start) || attr.check_name2(sym::crate_id) {
             let path_str = pprust::path_to_string(&attr.get_normal_item().path);
             let msg = format!("use of deprecated attribute `{}`: no longer used.", path_str);
             lint_deprecated_attr(cx, attr, &msg, None);

src/librustc_lint/levels.rs

@@ -121,12 +121,13 @@ impl<'s> LintLevelsBuilder<'s> {
         for attr in attrs {
             let level = match Level::from_symbol(attr.name_or_empty()) {
                 None => continue,
-                Some(lvl) => lvl,
+                Some(lvl) => {
+                    attr::mark_used(attr);
+                    lvl
+                }
             };
 
             let meta = unwrap_or!(attr.meta(), continue);
-            attr::mark_used(attr);
-
             let mut metas = unwrap_or!(meta.meta_item_list(), continue);
 
             if metas.is_empty() {

src/librustc_metadata/creader.rs

@@ -900,7 +900,7 @@ impl<'a> CrateLoader<'a> {
                     }
                     None => item.ident.name,
                 };
-                let dep_kind = if attr::contains_name(&item.attrs, sym::no_link) {
+                let dep_kind = if attr::contains_name2(&item.attrs, sym::no_link) {
                     DepKind::MacrosOnly
                 } else {
                     DepKind::Explicit

src/librustc_metadata/rmeta/decoder/cstore_impl.rs

@@ -5,7 +5,6 @@ use crate::native_libs;
 use crate::rmeta::{self, encoder};
 
 use rustc_ast::ast;
-use rustc_ast::attr;
 use rustc_ast::expand::allocator::AllocatorKind;
 use rustc_data_structures::svh::Svh;
 use rustc_hir as hir;
@@ -414,10 +413,6 @@ impl CStore {
 
         // Mark the attrs as used
         let attrs = data.get_item_attrs(id.index, sess);
-        for attr in attrs.iter() {
-            attr::mark_used(attr);
-        }
-
         let ident = data.item_ident(id.index, sess);
 
         LoadedMacro::MacroDef(

src/librustc_middle/middle/limits.rs

@@ -27,7 +27,7 @@ fn update_limit(
     default: usize,
 ) {
     for attr in &krate.attrs {
-        if !attr.check_name(name) {
+        if !attr.check_name2(name) {
             continue;
         }
 

src/librustc_middle/ty/mod.rs

@@ -3020,6 +3020,10 @@ impl<'tcx> TyCtxt<'tcx> {
         attr::contains_name(&self.get_attrs(did), attr)
     }
 
+    pub fn has_attr2(self, did: DefId, attr: Symbol) -> bool {
+        attr::contains_name2(&self.get_attrs(did), attr)
+    }
+
     /// Returns `true` if this is an `auto trait`.
     pub fn trait_is_auto(self, trait_def_id: DefId) -> bool {
         self.trait_def(trait_def_id).has_auto_impl

src/librustc_parse/validate_attr.rs

@@ -3,6 +3,7 @@
 use crate::parse_in;
 
 use rustc_ast::ast::{self, Attribute, MacArgs, MacDelimiter, MetaItem, MetaItemKind};
+use rustc_ast::attr;
 use rustc_ast::tokenstream::DelimSpan;
 use rustc_errors::{Applicability, PResult};
 use rustc_feature::{AttributeTemplate, BUILTIN_ATTRIBUTE_MAP};
@@ -154,6 +155,8 @@ pub fn check_builtin_attribute(
                         )
                         .emit();
                 }
+                // Avoid additional noise from the unused lint.
+                attr::mark_used(attr);
             }
         }
         Err(mut err) => {

src/librustc_passes/diagnostic_items.rs

@@ -88,7 +88,7 @@ fn collect_item(
 /// Extract the first `rustc_diagnostic_item = "$name"` out of a list of attributes.
 fn extract(attrs: &[ast::Attribute]) -> Option<Symbol> {
     attrs.iter().find_map(|attr| {
-        if attr.check_name(sym::rustc_diagnostic_item) { attr.value_str() } else { None }
+        if attr.check_name2(sym::rustc_diagnostic_item) { attr.value_str() } else { None }
     })
 }
 

src/librustc_passes/entry.rs

@@ -81,9 +81,9 @@ fn entry_fn(tcx: TyCtxt<'_>, cnum: CrateNum) -> Option<(LocalDefId, EntryFnType)
 fn entry_point_type(item: &Item<'_>, at_root: bool) -> EntryPointType {
     match item.kind {
         ItemKind::Fn(..) => {
-            if attr::contains_name(&item.attrs, sym::start) {
+            if attr::contains_name2(&item.attrs, sym::start) {
                 EntryPointType::Start
-            } else if attr::contains_name(&item.attrs, sym::main) {
+            } else if attr::contains_name2(&item.attrs, sym::main) {
                 EntryPointType::MainAttr
             } else if item.ident.name == sym::main {
                 if at_root {

src/librustc_passes/stability.rs

@@ -252,7 +252,6 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
         for attr in attrs {
             let name = attr.name_or_empty();
             if unstable_attrs.contains(&name) {
-                attr::mark_used(attr);
                 struct_span_err!(
                     self.tcx.sess,
                     attr.span,

src/librustc_plugin_impl/load.rs

@@ -32,7 +32,7 @@ pub fn load_plugins(
     let mut plugins = Vec::new();
 
     for attr in &krate.attrs {
-        if !attr.check_name(sym::plugin) {
+        if !attr.check_name2(sym::plugin) {
             continue;
         }