Fix CI, and use FxIndexSet

Author: blyxyas

compiler/rustc_lint/src/levels.rs

@@ -1,6 +1,6 @@
 use rustc_ast_pretty::pprust;
-use rustc_data_structures::{fx::FxIndexMap, sync::Lrc};
-use rustc_errors::{Diag, DiagMessage, LintDiagnostic, MultiSpan};
+use rustc_data_structures::{fx::FxIndexMap, fx::FxIndexSet, sync::Lrc};
+use rustc_errors::{Diag, LintDiagnostic, MultiSpan};
 use rustc_feature::{Features, GateIssue};
 use rustc_hir::intravisit::{self, Visitor};
 use rustc_hir::HirId;
@@ -120,7 +120,7 @@ impl LintLevelSets {
 /// (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<String>, Vec<String>)> {
+pub fn lints_that_can_emit(tcx: TyCtxt<'_>, (): ()) -> Lrc<(FxIndexSet<String>, FxIndexSet<String>)> {
     let mut visitor = LintLevelMinimum::new(tcx);
     visitor.process_opts();
     tcx.hir().walk_attributes(&mut visitor);
@@ -133,11 +133,11 @@ pub fn lints_that_can_emit(tcx: TyCtxt<'_>, (): ()) -> Lrc<(Vec<String>, Vec<Str
         let group_name = name_without_tool(&binding).to_string();
         if visitor.lints_that_actually_run.contains(&group_name) {
             for lint in group.1 {
-                visitor.lints_that_actually_run.push(name_without_tool(&lint.to_string()).to_string());
+                visitor.lints_that_actually_run.insert(name_without_tool(&lint.to_string()).to_string());
             }
         } else if visitor.lints_allowed.contains(&group_name) {
             for lint in &group.1 {
-                visitor.lints_allowed.push(name_without_tool(&lint.to_string()).to_string());
+                visitor.lints_allowed.insert(name_without_tool(&lint.to_string()).to_string());
             }
         }
     }
@@ -347,20 +347,24 @@ struct LintLevelMinimum<'tcx> {
 
 impl<'tcx> LintLevelMinimum<'tcx> {
     pub fn new(tcx: TyCtxt<'tcx>) -> Self {
+        let mut lints_that_actually_run = FxIndexSet::default();
+        lints_that_actually_run.reserve(230);
+        let mut lints_allowed = FxIndexSet::default();
+        lints_allowed.reserve(100);
         Self {
             tcx,
             // That magic number is the current number of lints + some more for possible future lints
-            lints_that_actually_run: Vec::with_capacity(230),
-            lints_allowed: Vec::with_capacity(100),
+            lints_that_actually_run,
+            lints_allowed,
         }
     }
 
     fn process_opts(&mut self) {
         for (lint, level) in &self.tcx.sess.opts.lint_opts {
             if *level == Level::Allow {
-                self.lints_allowed.push(lint.clone());
+                self.lints_allowed.insert(lint.clone());
             } else {
-                self.lints_that_actually_run.push(lint.to_string());
+                self.lints_that_actually_run.insert(lint.to_string());
             }
         }
     }
@@ -385,13 +389,13 @@ impl<'tcx> Visitor<'tcx> for LintLevelMinimum<'tcx> {
                     // 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_that_actually_run.push(
+                            self.lints_that_actually_run.insert(
                                 // SAFETY: Lint attributes can only have literals
                                 meta_list.ident().unwrap().name.as_str().to_string(),
                             );
                         } else {
                             self.lints_that_actually_run
-                                .push(meta_item.path.segments[1].ident.name.as_str().to_string());
+                                .insert(meta_item.path.segments[1].ident.name.as_str().to_string());
                         }
                     }
                 }
@@ -403,10 +407,10 @@ impl<'tcx> Visitor<'tcx> for LintLevelMinimum<'tcx> {
                     // 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().as_str().to_string())
+                            self.lints_allowed.insert(meta_list.name_or_empty().as_str().to_string());
                         } else {
                             self.lints_allowed
-                                .push(meta_item.path.segments[1].ident.name.as_str().to_string());
+                                .insert(meta_item.path.segments[1].ident.name.as_str().to_string());
                         }
                     }
                 }

compiler/rustc_lint/src/shadowed_into_iter.rs

@@ -64,7 +64,7 @@ declare_lint! {
     };
 }
 
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, Default)]
 pub(crate) struct ShadowedIntoIter;
 
 impl_lint_pass!(ShadowedIntoIter => [ARRAY_INTO_ITER, BOXED_SLICE_INTO_ITER]);

compiler/rustc_middle/src/query/mod.rs

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