feat(semantic): memoize Bindings hashmap's key hash (POC)

crates/oxc_linter/src/rules/jest/no_jasmine_globals.rs

@@ -50,7 +50,7 @@ impl Rule for NoJasmineGlobals {
             .scopes()
             .root_unresolved_references()
             .iter()
-            .filter(|(key, _)| NON_JASMINE_PROPERTY_NAMES.contains(key));
+            .filter(|(key, _)| NON_JASMINE_PROPERTY_NAMES.contains(&key.name));
 
         for (name, reference_ids) in jasmine_references {
             for &reference_id in reference_ids {

crates/oxc_linter/src/rules/jest/no_mocks_import.rs

@@ -3,6 +3,7 @@ use std::path::PathBuf;
 use oxc_ast::{ast::Argument, AstKind};
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
+use oxc_semantic::Key;
 use oxc_span::Span;
 
 use crate::{context::LintContext, rule::Rule};
@@ -55,7 +56,8 @@ impl Rule for NoMocksImport {
             }
         }
 
-        let Some(require_reference_ids) = ctx.scopes().root_unresolved_references().get("require")
+        let Some(require_reference_ids) =
+            ctx.scopes().root_unresolved_references().get(&Key::new("require"))
         else {
             return;
         };

crates/oxc_linter/src/rules/react/exhaustive_deps.rs

@@ -16,7 +16,7 @@ use oxc_ast::{
 };
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
-use oxc_semantic::{ReferenceId, ScopeId, Semantic, SymbolId};
+use oxc_semantic::{Key, ReferenceId, ScopeId, Semantic, SymbolId};
 use oxc_span::{Atom, GetSpan, Span};
 
 use crate::{
@@ -770,7 +770,7 @@ fn is_identifier_a_dependency<'a>(
     component_scope_id: ScopeId,
 ) -> bool {
     // if it is a global e.g. `console` or `window`, then it's not a dependency
-    if ctx.semantic().scopes().root_unresolved_references().contains_key(ident_name.as_str()) {
+    if ctx.semantic().scopes().root_unresolved_references().contains_key(&Key::new(ident_name)) {
         return false;
     }
 

crates/oxc_linter/src/snapshots/jest_no_confusing_set_timeout.snap

@@ -1,6 +1,5 @@
 ---
 source: crates/oxc_linter/src/tester.rs
-snapshot_kind: text
 ---
   ⚠ eslint-plugin-jest(no-confusing-set-timeout): `jest.setTimeout` should be placed before any other jest methods
     ╭─[no_confusing_set_timeout.tsx:10:17]
@@ -18,14 +17,13 @@ snapshot_kind: text
  11 │             
     ╰────
 
-  ⚠ eslint-plugin-jest(no-confusing-set-timeout): Do not call `jest.setTimeout` multiple times
+  ⚠ eslint-plugin-jest(no-confusing-set-timeout): `jest.setTimeout` should be placed before any other jest methods
     ╭─[no_confusing_set_timeout.tsx:10:17]
   9 │                 });
  10 │                 jest.setTimeout(800);
     ·                 ───────────────
  11 │             
     ╰────
-  help: Only the last call to `jest.setTimeout` will have an effect.
 
   ⚠ eslint-plugin-jest(no-confusing-set-timeout): `jest.setTimeout` should be placed before any other jest methods
     ╭─[no_confusing_set_timeout.tsx:10:17]
@@ -35,13 +33,14 @@ snapshot_kind: text
  11 │             
     ╰────
 
-  ⚠ eslint-plugin-jest(no-confusing-set-timeout): `jest.setTimeout` should be placed before any other jest methods
+  ⚠ eslint-plugin-jest(no-confusing-set-timeout): Do not call `jest.setTimeout` multiple times
     ╭─[no_confusing_set_timeout.tsx:10:17]
   9 │                 });
  10 │                 jest.setTimeout(800);
     ·                 ───────────────
  11 │             
     ╰────
+  help: Only the last call to `jest.setTimeout` will have an effect.
 
   ⚠ eslint-plugin-jest(no-confusing-set-timeout): `jest.setTimeout` should be placed before any other jest methods
    ╭─[no_confusing_set_timeout.tsx:3:21]

crates/oxc_linter/src/utils/jest.rs

@@ -250,7 +250,7 @@ fn collect_ids_referenced_to_global<'c>(
         .scopes()
         .root_unresolved_references()
         .iter()
-        .filter(|(name, _)| JEST_METHOD_NAMES.contains(name))
+        .filter(|(key, _)| JEST_METHOD_NAMES.contains(key.name))
         .flat_map(|(_, reference_ids)| reference_ids.iter().copied())
 }
 

crates/oxc_mangler/src/lib.rs

@@ -6,7 +6,7 @@ use rustc_hash::FxHashSet;
 use oxc_allocator::{Allocator, Vec};
 use oxc_ast::ast::{Declaration, Program, Statement};
 use oxc_index::Idx;
-use oxc_semantic::{ReferenceId, ScopeTree, SemanticBuilder, SymbolId, SymbolTable};
+use oxc_semantic::{Key, ReferenceId, ScopeTree, SemanticBuilder, SymbolId, SymbolTable};
 use oxc_span::Atom;
 
 #[derive(Default, Debug, Clone, Copy)]
@@ -195,14 +195,22 @@ impl Mangler {
                 count += 1;
                 // Do not mangle keywords and unresolved references
                 let n = name.as_str();
-                if !is_keyword(n)
-                    && !is_special_name(n)
-                    && !root_unresolved_references.contains_key(n)
-                    && !(root_bindings.contains_key(n)
-                        && (!self.options.top_level || exported_names.contains(n)))
+                if is_keyword(n) {
+                    continue;
+                }
+                if is_special_name(n) {
+                    continue;
+                }
+                let key = Key::new(n);
+                if root_unresolved_references.contains_key(&key) {
+                    continue;
+                }
+                if root_bindings.contains_key(&key)
+                    && (!self.options.top_level || exported_names.contains(n))
                 {
-                    break name;
+                    continue;
                 }
+                break name;
             };
             reserved_names.push(name);
         }

crates/oxc_semantic/Cargo.toml

@@ -30,6 +30,7 @@ oxc_span = { workspace = true }
 oxc_syntax = { workspace = true }
 
 assert-unchecked = { workspace = true }
+hashbrown = { workspace = true, features = ["equivalent"] }
 itertools = { workspace = true }
 phf = { workspace = true, features = ["macros"] }
 rustc-hash = { workspace = true }

crates/oxc_semantic/src/builder.rs

@@ -2,17 +2,18 @@
 
 use std::{
     cell::{Cell, RefCell},
+    hash::BuildHasherDefault,
     mem,
 };
 
-use oxc_data_structures::stack::Stack;
 use rustc_hash::FxHashMap;
 
 use oxc_ast::{ast::*, AstKind, Visit};
 use oxc_cfg::{
     ControlFlowGraphBuilder, CtxCursor, CtxFlags, EdgeType, ErrorEdgeKind, InstructionKind,
     IterationInstructionKind, ReturnInstructionKind,
 };
+use oxc_data_structures::stack::Stack;
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_span::{Atom, SourceType, Span};
 use oxc_syntax::{
@@ -30,7 +31,7 @@ use crate::{
     jsdoc::JSDocBuilder,
     label::UnusedLabels,
     node::AstNodes,
-    scope::{Bindings, ScopeTree},
+    scope::{Bindings, IdentityHasher, Key, ScopeTree},
     stats::Stats,
     symbol::SymbolTable,
     unresolved_stack::UnresolvedReferencesStack,
@@ -279,9 +280,8 @@ impl<'a> SemanticBuilder<'a> {
         if self.check_syntax_error && !self.source_type.is_typescript() {
             checker::check_unresolved_exports(&self);
         }
-        self.scope.set_root_unresolved_references(
-            self.unresolved_references.into_root().into_iter().map(|(k, v)| (k.as_str(), v)),
-        );
+        self.scope
+            .set_root_unresolved_references(self.unresolved_references.into_root().into_iter());
 
         let jsdoc = if self.build_jsdoc { self.jsdoc.build() } else { JSDocFinder::default() };
 
@@ -446,13 +446,8 @@ impl<'a> SemanticBuilder<'a> {
     /// Declare an unresolved reference in the current scope.
     ///
     /// # Panics
-    pub(crate) fn declare_reference(
-        &mut self,
-        name: Atom<'a>,
-        reference: Reference,
-    ) -> ReferenceId {
+    pub(crate) fn declare_reference(&mut self, name: Key<'a>, reference: Reference) -> ReferenceId {
         let reference_id = self.symbols.create_reference(reference);
-
         self.unresolved_references.current_mut().entry(name).or_default().push(reference_id);
         reference_id
     }
@@ -487,7 +482,7 @@ impl<'a> SemanticBuilder<'a> {
             // Try to resolve a reference.
             // If unresolved, transfer it to parent scope's unresolved references.
             let bindings = self.scope.get_bindings(self.current_scope_id);
-            if let Some(symbol_id) = bindings.get(name.as_str()).copied() {
+            if let Some(symbol_id) = bindings.get(&name).copied() {
                 let symbol_flags = self.symbols.get_flags(symbol_id);
                 references.retain(|&reference_id| {
                     let reference = &mut self.symbols.references[reference_id];
@@ -712,7 +707,10 @@ impl<'a> Visit<'a> for SemanticBuilder<'a> {
         if self.scope.get_flags(parent_scope_id).is_catch_clause() {
             self.scope.cell.with_dependent_mut(|allocator, inner| {
                 if !inner.bindings[parent_scope_id].is_empty() {
-                    let mut parent_bindings = Bindings::new_in(allocator);
+                    let mut parent_bindings = Bindings::with_hasher_in(
+                        BuildHasherDefault::<IdentityHasher>::default(),
+                        allocator,
+                    );
                     mem::swap(&mut inner.bindings[parent_scope_id], &mut parent_bindings);
                     for &symbol_id in parent_bindings.values() {
                         self.symbols.set_scope_id(symbol_id, self.current_scope_id);
@@ -2120,7 +2118,7 @@ impl<'a> SemanticBuilder<'a> {
     fn reference_identifier(&mut self, ident: &IdentifierReference<'a>) {
         let flags = self.resolve_reference_usages();
         let reference = Reference::new(self.current_node_id, flags);
-        let reference_id = self.declare_reference(ident.name, reference);
+        let reference_id = self.declare_reference(Key::new(ident.name.as_str()), reference);
         ident.reference_id.set(Some(reference_id));
     }
 

crates/oxc_semantic/src/lib.rs

@@ -38,7 +38,7 @@ mod unresolved_stack;
 pub use builder::{SemanticBuilder, SemanticBuilderReturn};
 pub use jsdoc::{JSDoc, JSDocFinder, JSDocTag};
 pub use node::{AstNode, AstNodes};
-pub use scope::ScopeTree;
+pub use scope::{Key, ScopeTree};
 pub use stats::Stats;
 pub use symbol::{IsGlobalReference, SymbolTable};
 
@@ -196,7 +196,7 @@ impl<'a> Semantic<'a> {
         let AstKind::IdentifierReference(id) = reference_node.kind() else {
             return false;
         };
-        self.scopes().root_unresolved_references().contains_key(id.name.as_str())
+        self.scopes().root_unresolved_references().contains_key(&Key::new(id.name.as_str()))
     }
 
     /// Find which scope a symbol is declared in
@@ -214,7 +214,7 @@ impl<'a> Semantic<'a> {
     }
 
     pub fn is_reference_to_global_variable(&self, ident: &IdentifierReference) -> bool {
-        self.scopes().root_unresolved_references().contains_key(ident.name.as_str())
+        self.scopes().root_unresolved_references().contains_key(&Key::new(ident.name.as_str()))
     }
 
     pub fn reference_name(&self, reference: &Reference) -> &str {