internal: HashMap -> FxHashMap, FxHashSet

Cargo.toml

@@ -69,6 +69,7 @@ crossbeam-utils = "0.8.21"
 jod-thread = "0.1.2"
 libc = "0.2.171"
 tracing = "0.1.40"
+rustc-hash = "2.1.1"
 
 # local
 # we have to make the versions explicit otherwise `cargo publish` won't work
@@ -89,6 +90,7 @@ doc_markdown = "deny"
 manual_let_else = "deny"
 explicit_iter_loop = "deny"
 too_many_arguments = "allow"
+disallowed_types = "deny"
 
 [profile.dev]
 debug = 0

clippy.toml

@@ -0,0 +1,4 @@
+disallowed-types = [
+  { path = "std::collections::HashMap", reason = "Use rustc_hash::FxHashMap instead" },
+  { path = "std::collections::HashSet", reason = "Use rustc_hash::FxHashSet instead" },
+]

crates/squawk_ide/Cargo.toml

@@ -28,6 +28,7 @@ la-arena.workspace = true
 smallvec.workspace = true
 itertools.workspace = true
 etcetera.workspace = true
+rustc-hash.workspace = true
 
 [dev-dependencies]
 insta.workspace = true

crates/squawk_ide/src/folding_ranges.rs

@@ -27,7 +27,7 @@
 // NOTE: pretty much copied as is but simplfied a fair bit. I don't use folding
 // much so not sure if this is optimal.
 
-use std::collections::HashSet;
+use rustc_hash::FxHashSet;
 
 use rowan::{Direction, NodeOrToken, TextRange};
 use salsa::Database as Db;
@@ -60,7 +60,7 @@ pub fn folding_ranges(db: &dyn Db, file: File) -> Vec<Fold> {
     let parse = parse(db, file);
 
     let mut folds = vec![];
-    let mut visited_comments = HashSet::default();
+    let mut visited_comments = FxHashSet::default();
 
     for element in parse.tree().syntax().descendants_with_tokens() {
         match &element {
@@ -166,7 +166,7 @@ fn fold_kind(kind: SyntaxKind) -> Option<FoldKind> {
 
 fn contiguous_range_for_comment(
     first: ast::Comment,
-    visited: &mut HashSet<ast::Comment>,
+    visited: &mut FxHashSet<ast::Comment>,
 ) -> Option<TextRange> {
     visited.insert(first.clone());
 

crates/squawk_ide/src/scope.rs

@@ -1,5 +1,5 @@
 use la_arena::Idx;
-use std::collections::HashMap;
+use rustc_hash::FxHashMap;
 
 use crate::symbols::{Name, SymbolId};
 
@@ -9,14 +9,14 @@ pub(crate) type ScopeId = Idx<Scope>;
 pub(crate) struct Scope {
     #[allow(dead_code)]
     pub(crate) parent: Option<ScopeId>,
-    pub(crate) entries: HashMap<Name, Vec<SymbolId>>,
+    pub(crate) entries: FxHashMap<Name, Vec<SymbolId>>,
 }
 
 impl Scope {
     pub(crate) fn with_parent(parent: Option<ScopeId>) -> Self {
         Scope {
             parent,
-            entries: HashMap::new(),
+            entries: FxHashMap::default(),
         }
     }
 

crates/squawk_linter/Cargo.toml

@@ -24,7 +24,7 @@ enum-iterator.workspace = true
 line-index.workspace = true
 serde_plain.workspace = true
 annotate-snippets.workspace = true
-
+rustc-hash.workspace = true
 
 [lints]
 workspace = true

crates/squawk_linter/src/ignore.rs

@@ -1,4 +1,4 @@
-use std::collections::HashSet;
+use rustc_hash::FxHashSet;
 
 use rowan::{NodeOrToken, TextRange, TextSize};
 use squawk_syntax::{SyntaxKind, SyntaxNode, SyntaxToken};
@@ -14,7 +14,7 @@ pub enum IgnoreKind {
 #[derive(Debug)]
 pub struct Ignore {
     pub range: TextRange,
-    pub violation_names: HashSet<Rule>,
+    pub violation_names: FxHashSet<Rule>,
     pub ignore_all: bool,
     pub kind: IgnoreKind,
 }
@@ -79,7 +79,7 @@ pub(crate) fn find_ignores(ctx: &mut Linter, file: &SyntaxNode) {
                 if token.kind() == SyntaxKind::COMMENT =>
             {
                 if let Some((rule_names, range, kind)) = ignore_rule_info(&token) {
-                    let mut set = HashSet::new();
+                    let mut set = FxHashSet::default();
                     let mut offset = 0usize;
                     // We have a specific check instead of going off of empty
                     // rules in case we have invalid rule names specified in the

crates/squawk_linter/src/ignore_index.rs

@@ -1,16 +1,15 @@
-use std::{
-    collections::{HashMap, HashSet},
-    fmt,
-};
+use std::fmt;
+
+use rustc_hash::{FxHashMap, FxHashSet};
 
 use line_index::LineIndex;
 use rowan::TextRange;
 
 use crate::{Ignore, Rule, ignore::IgnoreKind};
 
 pub(crate) struct IgnoreIndex {
-    line_to_ignored: HashMap<u32, HashSet<Rule>>,
-    file_ignored: HashSet<Rule>,
+    line_to_ignored: FxHashMap<u32, FxHashSet<Rule>>,
+    file_ignored: FxHashSet<Rule>,
     ignore_all: bool,
     line_index: LineIndex,
 }
@@ -32,8 +31,8 @@ impl fmt::Debug for IgnoreIndex {
 impl IgnoreIndex {
     pub(crate) fn new(text: &str, ignores: &[Ignore]) -> Self {
         let line_index = LineIndex::new(text);
-        let mut line_to_ignored: HashMap<u32, HashSet<Rule>> = HashMap::new();
-        let mut file_ignored: HashSet<Rule> = HashSet::new();
+        let mut line_to_ignored: FxHashMap<u32, FxHashSet<Rule>> = FxHashMap::default();
+        let mut file_ignored: FxHashSet<Rule> = FxHashSet::default();
         let mut ignore_all = false;
         for ignore in ignores {
             match ignore.kind {

crates/squawk_linter/src/lib.rs

@@ -1,4 +1,4 @@
-use std::collections::HashSet;
+use rustc_hash::{FxBuildHasher, FxHashSet};
 use std::fmt;
 
 use enum_iterator::Sequence;
@@ -317,7 +317,7 @@ pub struct LinterSettings {
 pub struct Linter {
     errors: Vec<Violation>,
     ignores: Vec<Ignore>,
-    pub rules: HashSet<Rule>,
+    pub rules: FxHashSet<Rule>,
     pub settings: LinterSettings,
 }
 
@@ -452,30 +452,30 @@ impl Linter {
     }
 
     pub fn with_all_rules() -> Self {
-        let rules = all::<Rule>().collect::<HashSet<_>>();
+        let rules = all::<Rule>().collect::<FxHashSet<_>>();
         Linter::from(rules)
     }
 
     pub fn without_rules(exclude: &[Rule]) -> Self {
-        let all_rules = all::<Rule>().collect::<HashSet<_>>();
-        let mut exclude_set = HashSet::with_capacity(exclude.len());
+        let all_rules = all::<Rule>().collect::<FxHashSet<_>>();
+        let mut exclude_set = FxHashSet::with_capacity_and_hasher(exclude.len(), FxBuildHasher);
         for e in exclude {
             exclude_set.insert(e);
         }
 
         let rules = all_rules
             .into_iter()
             .filter(|x| !exclude_set.contains(x))
-            .collect::<HashSet<_>>();
+            .collect::<FxHashSet<_>>();
 
         Linter::from(rules)
     }
 
-    pub fn from(rules: impl Into<HashSet<Rule>>) -> Self {
+    pub fn from(rules: impl IntoIterator<Item = Rule>) -> Self {
         Self {
             errors: vec![],
             ignores: vec![],
-            rules: rules.into(),
+            rules: rules.into_iter().collect(),
             settings: Default::default(),
         }
     }

crates/squawk_linter/src/rules/adding_field_with_default.rs

@@ -1,5 +1,5 @@
 use lazy_static::lazy_static;
-use std::collections::HashSet;
+use rustc_hash::FxHashSet;
 
 use squawk_syntax::ast::AstNode;
 use squawk_syntax::{Parse, SourceFile, SyntaxKind};
@@ -8,7 +8,7 @@ use squawk_syntax::{ast, identifier::Identifier};
 use crate::{Linter, Rule, Version, Violation};
 
 lazy_static! {
-    static ref NON_VOLATILE_FUNCS: HashSet<Identifier> = {
+    static ref NON_VOLATILE_FUNCS: FxHashSet<Identifier> = {
         NON_VOLATILE_BUILT_IN_FUNCTIONS
             .split('\n')
             .map(|x| x.trim())

crates/squawk_linter/src/rules/adding_not_null_field.rs

@@ -1,4 +1,4 @@
-use std::collections::{HashMap, HashSet};
+use rustc_hash::{FxHashMap, FxHashSet};
 
 use squawk_syntax::{
     Parse, SourceFile,
@@ -49,11 +49,12 @@ pub(crate) fn adding_not_null_field(ctx: &mut Linter, parse: &Parse<SourceFile>)
 
     let is_pg12_plus = ctx.settings.pg_version >= Version::new(12, None, None);
 
-    let mut not_null_constraints: HashMap<Identifier, TableColumn> = HashMap::new();
-    let mut validated_not_null_columns: HashSet<TableColumn> = HashSet::new();
+    let mut not_null_constraints: FxHashMap<Identifier, TableColumn> = FxHashMap::default();
+    let mut validated_not_null_columns: FxHashSet<TableColumn> = FxHashSet::default();
     // Tables where VALIDATE CONSTRAINT was seen without a matching ADD CONSTRAINT
     // in the same file (cross-migration pattern).
-    let mut tables_with_external_validated_constraints: HashSet<Identifier> = HashSet::new();
+    let mut tables_with_external_validated_constraints: FxHashSet<Identifier> =
+        FxHashSet::default();
 
     for stmt in file.stmts() {
         if let ast::Stmt::AlterTable(alter_table) = stmt {

crates/squawk_linter/src/rules/ban_char_field.rs

@@ -1,4 +1,4 @@
-use std::collections::HashSet;
+use rustc_hash::FxHashSet;
 
 use rowan::TextRange;
 use squawk_syntax::{
@@ -13,11 +13,13 @@ use crate::{Edit, Fix, Linter, Rule, Violation};
 use lazy_static::lazy_static;
 
 lazy_static! {
-    static ref CHAR_TYPES: HashSet<Identifier> = HashSet::from([
+    static ref CHAR_TYPES: FxHashSet<Identifier> = [
         Identifier::new("char"),
         Identifier::new("character"),
         Identifier::new("bpchar"),
-    ]);
+    ]
+    .into_iter()
+    .collect();
 }
 
 fn is_char_type(x: TokenText<'_>) -> bool {

crates/squawk_linter/src/rules/constraint_missing_not_valid.rs

@@ -1,4 +1,4 @@
-use std::collections::HashSet;
+use rustc_hash::FxHashSet;
 
 use squawk_syntax::{
     Parse, SourceFile,
@@ -11,8 +11,8 @@ use crate::{Linter, Rule, Violation};
 pub fn tables_created_in_transaction(
     assume_in_transaction: bool,
     file: &ast::SourceFile,
-) -> HashSet<Identifier> {
-    let mut created_table_names = HashSet::new();
+) -> FxHashSet<Identifier> {
+    let mut created_table_names = FxHashSet::default();
     let mut inside_transaction = assume_in_transaction;
     for stmt in file.stmts() {
         match stmt {
@@ -44,7 +44,7 @@ fn not_valid_validate_in_transaction(
     file: &ast::SourceFile,
 ) {
     let mut inside_transaction = assume_in_transaction;
-    let mut not_valid_names: HashSet<Identifier> = HashSet::new();
+    let mut not_valid_names: FxHashSet<Identifier> = FxHashSet::default();
     for stmt in file.stmts() {
         match stmt {
             ast::Stmt::AlterTable(alter_table) => {

crates/squawk_linter/src/rules/prefer_bigint_over_int.rs

@@ -1,4 +1,4 @@
-use std::collections::HashSet;
+use rustc_hash::FxHashSet;
 
 use squawk_syntax::ast::AstNode;
 use squawk_syntax::{Parse, SourceFile, ast, identifier::Identifier};
@@ -11,13 +11,15 @@ use crate::visitors::is_not_valid_int_type;
 use lazy_static::lazy_static;
 
 lazy_static! {
-    static ref INT_TYPES: HashSet<Identifier> = HashSet::from([
+    static ref INT_TYPES: FxHashSet<Identifier> = [
         Identifier::new("int"),
         Identifier::new("integer"),
         Identifier::new("int4"),
         Identifier::new("serial"),
         Identifier::new("serial4"),
-    ]);
+    ]
+    .into_iter()
+    .collect();
 }
 
 fn int_to_bigint_replacement(int_type: &str) -> &'static str {

crates/squawk_linter/src/rules/prefer_bigint_over_smallint.rs

@@ -1,4 +1,4 @@
-use std::collections::HashSet;
+use rustc_hash::FxHashSet;
 
 use squawk_syntax::ast::AstNode;
 use squawk_syntax::{Parse, SourceFile, ast, identifier::Identifier};
@@ -11,12 +11,14 @@ use crate::visitors::is_not_valid_int_type;
 use lazy_static::lazy_static;
 
 lazy_static! {
-    static ref SMALL_INT_TYPES: HashSet<Identifier> = HashSet::from([
+    static ref SMALL_INT_TYPES: FxHashSet<Identifier> = [
         Identifier::new("smallint"),
         Identifier::new("int2"),
         Identifier::new("smallserial"),
         Identifier::new("serial2"),
-    ]);
+    ]
+    .into_iter()
+    .collect();
 }
 
 fn smallint_to_bigint(smallint_type: &str) -> &'static str {

crates/squawk_linter/src/rules/prefer_identity.rs

@@ -1,4 +1,4 @@
-use std::collections::HashSet;
+use rustc_hash::FxHashSet;
 
 use squawk_syntax::{
     Parse, SourceFile,
@@ -13,14 +13,16 @@ use lazy_static::lazy_static;
 use crate::visitors::{check_not_allowed_types, is_not_valid_int_type};
 
 lazy_static! {
-    static ref SERIAL_TYPES: HashSet<Identifier> = HashSet::from([
+    static ref SERIAL_TYPES: FxHashSet<Identifier> = [
         Identifier::new("serial"),
         Identifier::new("serial2"),
         Identifier::new("serial4"),
         Identifier::new("serial8"),
         Identifier::new("smallserial"),
         Identifier::new("bigserial"),
-    ]);
+    ]
+    .into_iter()
+    .collect();
 }
 
 fn replace_serial(serial_type: &str) -> &'static str {