Move from symbols to strings + fix things

Author: blyxyas

compiler/rustc_lint/src/late.rs

@@ -372,35 +372,37 @@ 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_allowed = &**tcx.lints_that_can_emit(());
+        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;
 
         // 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()
-            .filter(|pass| {
-                let pass = LintPass::get_lints(pass);
-                pass.iter().any(|&lint| {
-                    let lint_name = &lint.name.to_lowercase()
+        .into_iter()
+        .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)
+                        [lint.name.find("::").unwrap_or(lint.name.len() - 2) + 2..].to_string();
+                lints_to_emit.contains(&lint_name) || ( !lints_allowed.contains(&lint_name) && 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();
+        .collect();
 
         filtered_passes.push(Box::new(builtin_lints));
 
@@ -453,24 +455,35 @@ fn late_lint_crate<'tcx>(tcx: TyCtxt<'tcx>) {
         only_module: false,
     };
 
-    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 (lints_to_emit, lints_allowed) = &**tcx.lints_that_can_emit(());
 
     // 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()
         .filter(|pass| {
             let pass = LintPass::get_lints(pass);
             pass.iter().any(|&lint| {
-                let lint_name = &lint.name.to_lowercase()
+                                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
+                        [lint.name.find("::").unwrap_or(lint.name.len() - 2) + 2..].to_string();
+                lints_to_emit.contains(&lint_name) ||
+                        (!lints_allowed.contains(lint_name) && lint.default_level != crate::Level::Allow)
             })
-        })
-        .collect();
+            // 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();
 
     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::{par_for_each_in, Lock},
+    sync::{join, par_for_each_in, Lock, Lrc},
 };
 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<'_>, (): ()) -> Vec<String> {
+pub fn lints_that_can_emit(tcx: TyCtxt<'_>, (): ()) -> Lrc<(Vec<String>, Vec<String>)> {
     let mut visitor = LintLevelMinimum::new(tcx);
     visitor.process_opts();
     visitor.lint_level_minimums();
 
-    visitor.lints_allowed.into_inner()
+    Lrc::new((visitor.lints_to_emit.into_inner(), visitor.lints_allowed.into_inner()))
 }
 
 #[instrument(level = "trace", skip(tcx), ret)]
@@ -474,29 +474,51 @@ impl<'tcx> Visitor<'tcx> for LintLevelsBuilder<'_, QueryMapExpectationsWrapper<'
 struct LintLevelMinimum<'tcx> {
     tcx: TyCtxt<'tcx>,
     /// The actual list of detected lints.
+    lints_to_emit: Lock<Vec<String>>,
     lints_allowed: Lock<Vec<String>>,
 }
 
 impl<'tcx> LintLevelMinimum<'tcx> {
     pub fn new(tcx: TyCtxt<'tcx>) -> Self {
-        Self { tcx, lints_allowed: Lock::new(Vec::with_capacity(100)) }
+        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)),
+        }
     }
 
     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(lint.to_string()));
+                self.lints_allowed
+                    .with_lock(|lints_allowed| lints_allowed.push(lint.to_string()));
+            } else {
+                self.lints_to_emit
+                    .with_lock(|lints_to_emit| lints_to_emit.push(lint.to_string()));
             }
         }
     }
 
     fn lint_level_minimums(&mut self) {
-        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()));
-            });
-        });
+        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.to_string()));
+                    });
+                });
+            },
+            || {
+                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 Vec<String> {
+    query lints_that_can_emit(_: ()) -> &'tcx Lrc<(Vec<String>, Vec<String>)> {
         arena_cache
         desc { "Computing all lints that are explicitly enabled or with a default level great than Allow" }
     }

compiler/rustc_parse/src/parser/attr.rs

@@ -148,11 +148,11 @@ impl<'a> Parser<'a> {
                         if let ast::NestedMetaItem::MetaItem(ref meta_item) = meta_list {
                             if meta_item.path.segments.len() == 1 {
                                 self.psess.lints_that_can_emit.with_lock(|lints_that_can_emit| {
-                                    lints_that_can_emit.push(meta_list.ident().unwrap().name);
+                                    lints_that_can_emit.push(meta_list.ident().unwrap().name.as_str().to_string());
                                 })
                             } else {
                                 self.psess.lints_that_can_emit.with_lock(|lints_that_can_emit| {
-                                    lints_that_can_emit.push(meta_item.path.segments[1].ident.name);
+                                    lints_that_can_emit.push(meta_item.path.segments[1].ident.name.as_str().to_string());
                                 })
                             }
                         }
@@ -163,11 +163,11 @@ impl<'a> Parser<'a> {
                         if let ast::NestedMetaItem::MetaItem(ref meta_item) = meta_list {
                             if meta_item.path.segments.len() == 1 {
                                 self.psess.lints_allowed.with_lock(|lints_allowed| {
-                                    lints_allowed.push(meta_list.name_or_empty())
+                                    lints_allowed.push(meta_list.name_or_empty().as_str().to_string())
                                 })
                             } else {
                                 self.psess.lints_allowed.with_lock(|lints_allowed| {
-                                    lints_allowed.push(meta_item.path.segments[1].ident.name);
+                                    lints_allowed.push(meta_item.path.segments[1].ident.name.as_str().to_string());
                                 })
                             }
                         }

compiler/rustc_session/src/parse.rs

@@ -232,6 +232,9 @@ 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<String>>,
     /// 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
@@ -270,6 +273,7 @@ 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)),
         }
     }