Fix author lint + stop using symbols

Author: blyxyas

compiler/rustc_lint/src/late.rs

@@ -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, Symbol};
+use rustc_span::Span;
 
 use std::any::Any;
 use std::cell::Cell;
@@ -372,29 +372,33 @@ pub fn late_lint_mod<'tcx, T: LateLintPass<'tcx> + 'tcx>(
             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_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
-                }
+            .filter(|pass| {
+                let pass = LintPass::get_lints(pass);
+                pass.iter().any(|&lint| {
+                    let lint_name = &lint.name.to_lowercase()
+                        // Doing some calculations here to account for those separators
+                        [lint.name.find("::").unwrap_or(lint.name.len() - 2) + 2..];
+                    !lints_allowed.contains(&lint_name.to_string())
+                        && lint.default_level != crate::Level::Allow
+                })
+                // if passes_lints[i].iter().any(|&lint| {
+                //     let symbol =
+                //         &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_allowed.contains(&lint.name)
+                //             && lint.default_level != crate::Level::Allow)
             })
             .collect();
 
@@ -449,42 +453,25 @@ fn late_lint_crate<'tcx>(tcx: TyCtxt<'tcx>) {
         only_module: false,
     };
 
-    let (lints_to_emit, lints_allowed) = &**tcx.lints_that_can_emit(());
+    let 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()
+        .filter(|pass| {
+            let pass = LintPass::get_lints(pass);
+            pass.iter().any(|&lint| {
+                let lint_name = &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
-            }
+                        [lint.name.find("::").unwrap_or(lint.name.len() - 2) + 2..];
+                !lints_allowed.contains(&lint_name.to_string())
+                    && lint.default_level != crate::Level::Allow
+            })
         })
         .collect();
 
-    // filtered_passes may be empty in case of `#[allow(all)]`
-    if filtered_passes.is_empty() {
-        return;
-    }
-
     let pass = RuntimeCombinedLateLintPass { passes: &mut filtered_passes[..] };
     late_lint_crate_inner(tcx, context, pass);
 }

compiler/rustc_lint/src/levels.rs

@@ -17,7 +17,7 @@ use rustc_ast as ast;
 use rustc_ast_pretty::pprust;
 use rustc_data_structures::{
     fx::FxIndexMap,
-    sync::{join, par_for_each_in, Lock, Lrc},
+    sync::{par_for_each_in, Lock},
 };
 use rustc_errors::{Diag, DiagMessage, LintDiagnostic, MultiSpan};
 use rustc_feature::{Features, GateIssue};
@@ -159,12 +159,12 @@ fn lint_expectations(tcx: TyCtxt<'_>, (): ()) -> Vec<(LintExpectationId, LintExp
 /// (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>)> {
+pub fn lints_that_can_emit(tcx: TyCtxt<'_>, (): ()) -> Vec<String> {
     let mut visitor = LintLevelMinimum::new(tcx);
     visitor.process_opts();
     visitor.lint_level_minimums();
 
-    Lrc::new((visitor.lints_to_emit.into_inner(), visitor.lints_allowed.into_inner()))
+    visitor.lints_allowed.into_inner()
 }
 
 #[instrument(level = "trace", skip(tcx), ret)]
@@ -474,51 +474,29 @@ impl<'tcx> Visitor<'tcx> for LintLevelsBuilder<'_, QueryMapExpectationsWrapper<'
 struct LintLevelMinimum<'tcx> {
     tcx: TyCtxt<'tcx>,
     /// The actual list of detected lints.
-    lints_to_emit: Lock<Vec<Symbol>>,
-    lints_allowed: Lock<Vec<Symbol>>,
+    lints_allowed: Lock<Vec<String>>,
 }
 
 impl<'tcx> LintLevelMinimum<'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: Lock::new(Vec::with_capacity(230)),
-            lints_allowed: Lock::new(Vec::with_capacity(100)),
-        }
+        Self { tcx, lints_allowed: Lock::new(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
-                    .with_lock(|lints_allowed| lints_allowed.push(Symbol::intern(&lint)));
-            } else {
-                self.lints_to_emit
-                    .with_lock(|lints_to_emit| lints_to_emit.push(Symbol::intern(&lint)));
+                self.lints_allowed.with_lock(|lints_allowed| lints_allowed.push(lint.to_string()));
             }
         }
     }
 
     fn lint_level_minimums(&mut self) {
-        join(
-            || {
-                self.tcx.sess.psess.lints_that_can_emit.with_lock(|vec| {
-                    par_for_each_in(vec, |lint_symbol| {
-                        self.lints_to_emit
-                            .with_lock(|lints_to_emit| lints_to_emit.push(*lint_symbol));
-                    });
-                });
-            },
-            || {
-                self.tcx.sess.psess.lints_allowed.with_lock(|vec| {
-                    par_for_each_in(vec, |lint_symbol| {
-                        self.lints_allowed
-                            .with_lock(|lints_allowed| lints_allowed.push(*lint_symbol));
-                    });
-                });
-            },
-        );
+        self.tcx.sess.psess.lints_allowed.with_lock(|vec| {
+            par_for_each_in(vec, |lint_symbol| {
+                self.lints_allowed
+                    .with_lock(|lints_allowed| lints_allowed.push(lint_symbol.to_string()));
+            });
+        });
     }
 }
 

compiler/rustc_middle/src/query/mod.rs

@@ -431,7 +431,7 @@ rustc_queries! {
         desc { "computing `#[expect]`ed lints in this crate" }
     }
 
-    query lints_that_can_emit(_: ()) -> &'tcx Lrc<(Vec<Symbol>, Vec<Symbol>)> {
+    query lints_that_can_emit(_: ()) -> &'tcx Vec<String> {
         arena_cache
         desc { "Computing all lints that are explicitly enabled or with a default level great than Allow" }
     }

compiler/rustc_session/src/parse.rs

@@ -232,13 +232,10 @@ pub struct ParseSess {
     proc_macro_quoted_spans: AppendOnlyVec<Span>,
     /// Used to generate new `AttrId`s. Every `AttrId` is unique.
     pub attr_id_generator: AttrIdGenerator,
-    /// All lints that can emit, even if not emitted (i.e. lints that are mentioned
-    /// in e.g. #![warn] attributes)
-    pub lints_that_can_emit: Lock<Vec<Symbol>>,
     /// The list of lints that cannot emit, maybe because they are allowed
     /// globally, or the default level is Allow and they are not activated
     /// manually
-    pub lints_allowed: Lock<Vec<Symbol>>,
+    pub lints_allowed: Lock<Vec<String>>,
 }
 
 impl ParseSess {
@@ -273,7 +270,6 @@ impl ParseSess {
             assume_incomplete_release: false,
             proc_macro_quoted_spans: Default::default(),
             attr_id_generator: AttrIdGenerator::new(),
-            lints_that_can_emit: Lock::new(Vec::with_capacity(230)),
             lints_allowed: Lock::new(Vec::with_capacity(100)),
         }
     }

src/tools/clippy/clippy_lints/src/lib.rs

@@ -640,6 +640,8 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
         store.register_late_pass(|_| {
             Box::new(utils::internal_lints::almost_standard_lint_formulation::AlmostStandardFormulation::new())
         });
+        store.register_late_pass(|_| Box::new(utils::author::Author));
+
     }
 
     store.register_late_pass(move |_| {
@@ -658,7 +660,6 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     });
     store.register_early_pass(|| Box::<utils::format_args_collector::FormatArgsCollector>::default());
     store.register_late_pass(|_| Box::new(utils::dump_hir::DumpHir));
-    store.register_late_pass(|_| Box::new(utils::author::Author));
     store.register_late_pass(move |_| {
         Box::new(await_holding_invalid::AwaitHolding::new(
             await_holding_invalid_types.clone(),

src/tools/clippy/clippy_lints/src/utils/author.rs renamed to src/tools/clippy/clippy_lints/src/utils/internal_lints/author.rs

@@ -16,7 +16,7 @@ use rustc_span::symbol::{Ident, Symbol};
 use std::cell::Cell;
 use std::fmt::{Display, Formatter, Write as _};
 
-declare_lint_pass!(
+declare_clippy_lint!{
     /// ### What it does
     /// Generates clippy code that detects the offending pattern
     ///
@@ -48,8 +48,13 @@ declare_lint_pass!(
     ///     // report your lint here
     /// }
     /// ```
-    Author => []
-);
+    #[clippy::version = "1.0.0"]
+    pub AUTHOR,
+    internal,
+    "The author lint, see documentation at <https://doc.rust-lang.org/nightly/clippy/development/adding_lints.html#author-lint>"
+};
+
+declare_lint_pass! { Author => [AUTHOR] }
 
 /// Writes a line of output with indentation added
 macro_rules! out {

src/tools/clippy/clippy_lints/src/utils/mod.rs

@@ -1,4 +1,3 @@
-pub mod author;
 pub mod dump_hir;
 pub mod format_args_collector;
 #[cfg(feature = "internal")]

src/tools/clippy/tests/ui/author.rs renamed to src/tools/clippy/tests/ui-internal/author.rs

@@ -1,3 +1,5 @@
+#![warn(clippy::author)]
+
 fn main() {
     #[clippy::author]
     let x: char = 0x45 as char;