marramiau miau miau 🎉

Author: blyxyas

compiler/rustc_lint/src/builtin.rs

@@ -73,8 +73,8 @@ use rustc_trait_selection::traits::{self, misc::type_allowed_to_implement_copy};
 
 use crate::nonstandard_style::{method_context, MethodLateContext};
 
-use std::fmt::Write;
 use std::default::Default;
+use std::fmt::Write;
 
 // hardwired lints from rustc_lint_defs
 pub use rustc_session::lint::builtin::*;

compiler/rustc_lint/src/late.rs

@@ -14,7 +14,7 @@
 //! upon. As the ast is traversed, this keeps track of the current lint level
 //! for all lint attributes.
 
-use crate::{passes::LateLintPassObject, LateContext, LateLintPass, LintStore, LintId};
+use crate::{passes::LateLintPassObject, LateContext, LateLintPass, LintStore};
 use rustc_data_structures::stack::ensure_sufficient_stack;
 use rustc_data_structures::sync::{join, Lrc};
 use rustc_hir as hir;
@@ -25,7 +25,7 @@ use rustc_middle::hir::nested_filter;
 use rustc_middle::ty::{self, TyCtxt};
 use rustc_session::lint::LintPass;
 use rustc_session::Session;
-use rustc_span::Span;
+use rustc_span::{Span, Symbol};
 
 use std::any::Any;
 use std::cell::Cell;
@@ -363,21 +363,43 @@ pub fn late_lint_mod<'tcx, T: LateLintPass<'tcx> + 'tcx>(
     // Note: `passes` is often empty. In that case, it's faster to run
     // `builtin_lints` directly rather than bundling it up into the
     // `RuntimeCombinedLateLintPass`.
-let store = unerased_lint_store(tcx.sess);
-        
-        if store.late_module_passes.is_empty() {
-            late_lint_mod_inner(tcx, module_def_id, context, builtin_lints);
-        } else {
-            let passes: Vec<_> = store
-            .late_module_passes
-            .iter()
-            .map(|mk_pass| (mk_pass)(tcx))
+    let store = unerased_lint_store(tcx.sess);
+
+    if store.late_module_passes.is_empty() {
+        late_lint_mod_inner(tcx, module_def_id, context, builtin_lints);
+    } else {
+        let passes: Vec<_> =
+            store.late_module_passes.iter().map(|mk_pass| (mk_pass)(tcx)).collect();
+
+        // Filter unused lints
+        let (lints_to_emit, lints_allowed) = &**tcx.lints_that_can_emit(());
+        // let lints_to_emit = &lints_that_can_emit.0;
+        // let lints_allowed = &lints_that_can_emit.1;
+        let passes_lints: Vec<_> = passes.iter().map(|pass| LintPass::get_lints(pass)).collect();
+
+        // Now, we'll filtered passes in a way that discards any lint that
+        let mut filtered_passes: Vec<Box<dyn LateLintPass<'tcx>>> = passes
+            .into_iter()
+            .enumerate()
+            .filter_map(|(i, pass)| {
+                if passes_lints[i].iter().any(|&lint| {
+                    let symbol = Symbol::intern(lint.name);
+                    // ^^^ Expensive, but more expensive would be having to
+                    // cast every element to &str
+
+                    lints_to_emit.contains(&symbol)
+                        || (!lints_allowed.contains(&symbol)
+                            && lint.default_level > crate::Level::Allow)
+                }) {
+                    Some(pass)
+                } else {
+                    None
+                }
+            })
             .collect();
-            let emittable_lints = tcx.lints_that_can_emit(());
-            let mut filtered_passes: Vec<Box<dyn LateLintPass<'tcx>>> = passes.into_iter().filter(|pass| {
-                LintPass::get_lints(pass).iter().any(|&lint| emittable_lints.contains(&LintId::of(lint)))
-            }).collect();
-            filtered_passes.push(Box::new(builtin_lints));
+
+        filtered_passes.push(Box::new(builtin_lints));
+
         let pass = RuntimeCombinedLateLintPass { passes: &mut filtered_passes[..] };
         late_lint_mod_inner(tcx, module_def_id, context, pass);
     }
@@ -427,11 +449,36 @@ fn late_lint_crate<'tcx>(tcx: TyCtxt<'tcx>) {
         only_module: false,
     };
 
-    let hashmap = tcx.lints_that_can_emit(());
-    
-    let mut filtered_passes: Vec<Box<dyn LateLintPass<'tcx>>> = passes.into_iter().filter(|pass| {
-        LintPass::get_lints(pass).iter().any(|&lint| hashmap.contains(&LintId::of(lint)))
-    }).collect();
+    let (lints_to_emit, lints_allowed) = &**tcx.lints_that_can_emit(());
+    // let lints_to_emit = &lints_that_can_emit.0;
+    // let lints_allowed = &lints_that_can_emit.1;
+    let passes_lints: Vec<_> = passes.iter().map(|pass| LintPass::get_lints(pass)).collect();
+
+    // Now, we'll filtered passes in a way that discards any lint that
+    let mut filtered_passes: Vec<Box<dyn LateLintPass<'tcx>>> = passes
+        .into_iter()
+        .enumerate()
+        .filter_map(|(i, pass)| {
+            if passes_lints[i].iter().any(|&lint| {
+                let symbol = Symbol::intern(
+                    &lint.name.to_lowercase()
+                        // Doing some calculations here to account for those separators
+                        [lint.name.find("::").unwrap_or(lint.name.len() - 2) + 2..],
+                );
+
+                // ^^^ Expensive, but more expensive would be having to
+                // cast every element to &str
+
+                lints_to_emit.contains(&symbol)
+                    || (!lints_allowed.contains(&symbol)
+                        && lint.default_level > crate::Level::Allow)
+            }) {
+                Some(pass)
+            } else {
+                None
+            }
+        })
+        .collect();
 
     // filtered_passes may be empty in case of `#[allow(all)]`
     if filtered_passes.is_empty() {

compiler/rustc_lint/src/levels.rs

@@ -15,7 +15,7 @@ use crate::{
 };
 use rustc_ast as ast;
 use rustc_ast_pretty::pprust;
-use rustc_data_structures::fx::FxIndexMap;
+use rustc_data_structures::{fx::FxIndexMap, sync::Lrc};
 use rustc_errors::{Diag, DiagMessage, LintDiagnostic, MultiSpan};
 use rustc_feature::{Features, GateIssue};
 use rustc_hir as hir;
@@ -153,30 +153,18 @@ fn lint_expectations(tcx: TyCtxt<'_>, (): ()) -> Vec<(LintExpectationId, LintExp
 
 /// Walk the whole crate collecting nodes where lint levels change
 /// (e.g. `#[allow]` attributes), and joins that list with the warn-by-default
-/// (and not allowed in the crate) and CLI lints. The final result is a builder
-/// that has information about just lints that can be emitted (leaving out
-/// globally-allowed lints)
-pub fn lints_that_can_emit(
-    tcx: TyCtxt<'_>,
-    (): ()
-) -> Vec<LintId> {
-    let store = unerased_lint_store(&tcx.sess);
-
-    let specs = tcx.shallow_lint_levels_on(hir::CRATE_HIR_ID.owner);
-    let lints = store.get_lints();
-
-    let mut hashmap: Vec<LintId> = Vec::new();
-    hashmap.reserve((lints.len() >> 1) * usize::from(tcx.sess.opts.lint_cap.is_some())); // Avoid allocations
-
-    for &lint in lints {
-        let lint_id = LintId::of(lint);
-        let actual_level = specs.probe_for_lint_level(tcx, lint_id, hir::CRATE_HIR_ID).0.unwrap_or(lint.default_level);
-        if actual_level > Level::Allow {
-            hashmap.push(lint_id);
-        }
-    }
-
-    hashmap
+/// (and not allowed in the crate) and CLI lints. The returned value is a tuple
+/// of 1. The lints that will emit (or at least, should run), and 2.
+/// The lints that are allowed at the crate level and will not emit.
+pub fn lints_that_can_emit(tcx: TyCtxt<'_>, (): ()) -> Lrc<(Vec<Symbol>, Vec<Symbol>)> {
+    // builder.add_command_line();
+    // builder.add_id(hir::CRATE_HIR_ID);
+
+    let mut visitor = LintLevelMinimumVisitor::new(tcx);
+    visitor.process_opts();
+    tcx.hir().walk_attributes(&mut visitor);
+
+    Lrc::new((visitor.lints_to_emit, visitor.lints_allowed))
 }
 
 #[instrument(level = "trace", skip(tcx), ret)]
@@ -478,6 +466,86 @@ impl<'tcx> Visitor<'tcx> for LintLevelsBuilder<'_, QueryMapExpectationsWrapper<'
     }
 }
 
+/// Visitor with the only function of visiting every item-like in a crate and
+/// computing the highest level that every lint gets put to.
+///
+/// E.g., if a crate has a global #![allow(lint)] attribute, but a single item
+/// uses #[warn(lint)], this visitor will set that lint level as `Warn`
+struct LintLevelMinimumVisitor<'tcx> {
+    tcx: TyCtxt<'tcx>,
+    /// The actual list of detected lints.
+    lints_to_emit: Vec<Symbol>,
+    lints_allowed: Vec<Symbol>,
+}
+
+impl<'tcx> LintLevelMinimumVisitor<'tcx> {
+    pub fn new(tcx: TyCtxt<'tcx>) -> Self {
+        Self {
+            tcx,
+            // That magic number is the current number of lints + some more for possible future lints
+            lints_to_emit: Vec::with_capacity(230),
+            lints_allowed: Vec::with_capacity(100),
+        }
+    }
+
+    fn process_opts(&mut self) {
+        for (lint, level) in &self.tcx.sess.opts.lint_opts {
+            if *level == Level::Allow {
+                self.lints_allowed.push(Symbol::intern(&lint));
+            } else {
+                self.lints_to_emit.push(Symbol::intern(&lint));
+            }
+        }
+    }
+}
+
+impl<'tcx> Visitor<'tcx> for LintLevelMinimumVisitor<'tcx> {
+    type NestedFilter = nested_filter::All;
+
+    fn nested_visit_map(&mut self) -> Self::Map {
+        self.tcx.hir()
+    }
+
+    fn visit_attribute(&mut self, attribute: &'tcx ast::Attribute) {
+        if let Some(meta) = attribute.meta() {
+            if [sym::warn, sym::deny, sym::forbid, sym::expect]
+                .iter()
+                .any(|kind| meta.has_name(*kind))
+            {
+                // SAFETY: Lint attributes are always a metalist inside a
+                // metalist (even with just one lint).
+                for meta_list in meta.meta_item_list().unwrap() {
+                    // If it's a tool lint (e.g. clippy::my_clippy_lint)
+                    if let ast::NestedMetaItem::MetaItem(meta_item) = meta_list {
+                        if meta_item.path.segments.len() == 1 {
+                            self.lints_to_emit.push(
+                                // SAFETY: Lint attributes can only have literals
+                                meta_list.ident().unwrap().name,
+                            );
+                        } else {
+                            self.lints_to_emit.push(meta_item.path.segments[1].ident.name);
+                        }
+                    }
+                }
+            // We handle #![allow]s differently, as these remove checking rather than adding.
+            } else if meta.has_name(sym::allow)
+                && let ast::AttrStyle::Inner = attribute.style
+            {
+                for meta_list in meta.meta_item_list().unwrap() {
+                    // If it's a tool lint (e.g. clippy::my_clippy_lint)
+                    if let ast::NestedMetaItem::MetaItem(meta_item) = meta_list {
+                        if meta_item.path.segments.len() == 1 {
+                            self.lints_allowed.push(meta_list.name_or_empty())
+                        } else {
+                            self.lints_allowed.push(meta_item.path.segments[1].ident.name);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
 pub struct LintLevelsBuilder<'s, P> {
     sess: &'s Session,
     features: &'s Features,
@@ -1161,7 +1229,8 @@ impl<'s, P: LintLevelsProvider> LintLevelsBuilder<'s, P> {
 }
 
 pub(crate) fn provide(providers: &mut Providers) {
-    *providers = Providers { shallow_lint_levels_on, lint_expectations, lints_that_can_emit, ..*providers };
+    *providers =
+        Providers { shallow_lint_levels_on, lint_expectations, lints_that_can_emit, ..*providers };
 }
 
 pub fn parse_lint_and_tool_name(lint_name: &str) -> (Option<Symbol>, &str) {

compiler/rustc_middle/src/query/mod.rs

@@ -71,7 +71,6 @@ use rustc_hir::def_id::{
 };
 use rustc_hir::lang_items::{LangItem, LanguageItems};
 use rustc_hir::{Crate, ItemLocalId, ItemLocalMap, TraitCandidate};
-use rustc_lint_defs::LintId;
 use rustc_index::IndexVec;
 use rustc_macros::rustc_queries;
 use rustc_query_system::ich::StableHashingContext;
@@ -432,9 +431,9 @@ rustc_queries! {
         desc { "computing `#[expect]`ed lints in this crate" }
     }
 
-    query lints_that_can_emit(_: ()) -> &'tcx Vec<LintId> {
+    query lints_that_can_emit(_: ()) -> &'tcx Lrc<(Vec<Symbol>, Vec<Symbol>)> {
         arena_cache
-        desc { "Computing all lints that are not `[#allow]ed` / allow-by-default" }
+        desc { "Computing all lints that are explicitly enabled or with a default level great than Allow" }
     }
 
     query expn_that_defined(key: DefId) -> rustc_span::ExpnId {