perf(semantic): avoid repeated hashing resolving bindings

Cargo.toml

@@ -115,6 +115,7 @@ dashmap = "6.0.0"
 flate2 = "1.0.30"
 futures = "0.3.30"
 glob = "0.3.1"
+hashbrown = "0.14.5"
 ignore = "0.4.22"
 itertools = "0.13.0"
 jemallocator = "0.5.4"

crates/oxc_linter/src/snapshots/no_confusing_set_timeout.snap

@@ -1,5 +1,6 @@
 ---
 source: crates/oxc_linter/src/tester.rs
+assertion_line: 216
 ---
  ⚠ eslint-plugin-jest(no-confusing-set-timeout)
  ╭─[no_confusing_set_timeout.tsx:10:17]
@@ -35,7 +36,7 @@ source: crates/oxc_linter/src/tester.rs
  · ───────────────
  11 │ 
  ╰────
- help: Do not call `jest.setTimeout` multiple times, as only the last call will have an effect
+ help: `jest.setTimeout` should be placed before any other jest methods
 
  ⚠ eslint-plugin-jest(no-confusing-set-timeout)
  ╭─[no_confusing_set_timeout.tsx:10:17]
@@ -44,7 +45,7 @@ source: crates/oxc_linter/src/tester.rs
  · ───────────────
  11 │ 
  ╰────
- help: `jest.setTimeout` should be placed before any other jest methods
+ help: Do not call `jest.setTimeout` multiple times, as only the last call will have an effect
 
  ⚠ eslint-plugin-jest(no-confusing-set-timeout)
  ╭─[no_confusing_set_timeout.tsx:3:21]

crates/oxc_semantic/Cargo.toml

@@ -27,6 +27,7 @@ oxc_diagnostics = { workspace = true }
 oxc_index = { workspace = true }
 oxc_allocator = { workspace = true }
 
+hashbrown = { workspace = true }
 indexmap = { workspace = true }
 phf = { workspace = true, features = ["macros"] }
 rustc-hash = { workspace = true }

crates/oxc_semantic/src/builder.rs

@@ -21,12 +21,13 @@ use crate::{
  checker,
  class::ClassTableBuilder,
  diagnostics::redeclaration,
+ hash::TempUnresolvedReferences,
  jsdoc::JSDocBuilder,
  label::LabelBuilder,
  module_record::ModuleRecordBuilder,
  node::{AstNodeId, AstNodes, NodeFlags},
  reference::{Reference, ReferenceFlag, ReferenceId},
- scope::{ScopeFlags, ScopeId, ScopeTree, UnresolvedReferences},
+ scope::{ScopeFlags, ScopeId, ScopeTree},
  symbol::{SymbolFlags, SymbolId, SymbolTable},
  JSDocFinder, Semantic,
 };
@@ -74,10 +75,10 @@ pub struct SemanticBuilder<'a> {
  pub symbols: SymbolTable,
 
  // Stack used to accumulate unresolved refs while traversing scopes.
- // Indexed by scope depth. We recycle `UnresolvedReferences` instances during traversal
+ // Indexed by scope depth. We recycle `TempUnresolvedReferences` instances during traversal
  // to reduce allocations, so the stack grows to maximum scope depth, but never shrinks.
  // See: <https://github.com/oxc-project/oxc/issues/4169>
- unresolved_references: Vec<UnresolvedReferences>,
+ unresolved_references: Vec<TempUnresolvedReferences>,
 
  pub(crate) module_record: Arc<ModuleRecord>,
 
@@ -110,7 +111,7 @@ impl<'a> SemanticBuilder<'a> {
  // This is just an estimate of a good initial size, but certainly better than
  // `Vec`'s default initial capacity of 4.
  let mut unresolved_references = vec![];
- unresolved_references.resize_with(16, Default::default);
+ unresolved_references.resize_with(16, TempUnresolvedReferences::default);
 
  let trivias = Trivias::default();
  Self {
@@ -198,11 +199,13 @@ impl<'a> SemanticBuilder<'a> {
  if self.check_syntax_error {
  checker::check_module_record(&self);
  }
- }
 
- debug_assert_eq!(self.current_scope_depth, 0);
- self.scope.root_unresolved_references =
- self.unresolved_references.into_iter().next().unwrap();
+ // Convert remaining unresolved references to a standard hash map
+ debug_assert_eq!(self.current_scope_depth, 0);
+ let mut unresolved_references = self.unresolved_references.into_iter().next().unwrap();
+ self.scope.root_unresolved_references =
+ unresolved_references.drain().map(|line| (line.name, line.reference_ids)).collect();
+ }
 
  let jsdoc = if self.build_jsdoc { self.jsdoc.build() } else { JSDocFinder::default() };
 
@@ -339,10 +342,7 @@ impl<'a> SemanticBuilder<'a> {
  let reference_name = reference.name().clone();
  let reference_id = self.symbols.create_reference(reference);
 
- self.unresolved_references[self.current_scope_depth]
- .entry(reference_name)
- .or_default()
- .push(reference_id);
+ self.unresolved_references[self.current_scope_depth].insert(reference_name, reference_id);
  reference_id
  }
 
@@ -370,18 +370,16 @@ impl<'a> SemanticBuilder<'a> {
  let current_refs = iter.next().unwrap();
 
  let bindings = self.scope.get_bindings(self.current_scope_id);
- for (name, reference_ids) in current_refs.drain() {
+ for line in current_refs.drain() {
  // Try to resolve a reference.
  // If unresolved, transfer it to parent scope's unresolved references.
- if let Some(symbol_id) = bindings.get(&name).copied() {
- for reference_id in &reference_ids {
+ if let Some(symbol_id) = bindings.get(&line.name).copied() {
+ for reference_id in &line.reference_ids {
  self.symbols.references[*reference_id].set_symbol_id(symbol_id);
  }
- self.symbols.resolved_references[symbol_id].extend(reference_ids);
- } else if let Some(parent_reference_ids) = parent_refs.get_mut(&name) {
- parent_reference_ids.extend(reference_ids);
+ self.symbols.resolved_references[symbol_id].extend(line.reference_ids);
  } else {
- parent_refs.insert(name, reference_ids);
+ parent_refs.extend(line.name, line.hash, line.reference_ids);
  }
  }
  }
@@ -442,7 +440,7 @@ impl<'a> Visit<'a> for SemanticBuilder<'a> {
  // `self.unresolved_references[self.current_scope_depth]` is initialized
  self.current_scope_depth += 1;
  if self.unresolved_references.len() <= self.current_scope_depth {
- self.unresolved_references.push(UnresolvedReferences::default());
+ self.unresolved_references.push(TempUnresolvedReferences::default());
  }
  }
 

crates/oxc_semantic/src/hash.rs

@@ -0,0 +1,77 @@
+use std::hash::Hasher;
+
+use hashbrown::hash_table::{Drain, HashTable};
+use rustc_hash::FxHasher;
+
+use oxc_span::CompactStr;
+
+use crate::reference::ReferenceId;
+
+#[derive(Clone, Copy, PartialEq)]
+pub struct IdentifierHash(u64);
+
+impl IdentifierHash {
+ fn new(name: &str) -> Self {
+ let mut hasher = FxHasher::default();
+ hasher.write(name.as_bytes());
+ Self(hasher.finish())
+ }
+}
+
+pub struct Line {
+ pub name: CompactStr,
+ pub hash: IdentifierHash,
+ pub reference_ids: Vec<ReferenceId>,
+}
+
+#[derive(Default)]
+pub struct TempUnresolvedReferences {
+ inner: HashTable<Line>,
+}
+
+impl TempUnresolvedReferences {
+ #[allow(dead_code)]
+ pub fn get(&self, name: &str, hash: IdentifierHash) -> Option<&Vec<ReferenceId>> {
+ self.inner
+ .find(hash.0, |line| line.hash == hash && line.name.as_ref() == name)
+ .map(|entry| &entry.reference_ids)
+ }
+
+ #[allow(dead_code)]
+ pub fn get_mut(&mut self, name: &str, hash: IdentifierHash) -> Option<&mut Vec<ReferenceId>> {
+ self.inner
+ .find_mut(hash.0, |line| line.hash == hash && line.name.as_ref() == name)
+ .map(|entry| &mut entry.reference_ids)
+ }
+
+ pub fn insert(&mut self, name: CompactStr, reference_id: ReferenceId) {
+ let hash = IdentifierHash::new(&name);
+ if let Some(line) = self.inner.find_mut(hash.0, |line| line.name == name) {
+ line.reference_ids.push(reference_id);
+ } else {
+ self.inner.insert_unique(
+ hash.0,
+ Line { name, hash, reference_ids: vec![reference_id] },
+ |line| line.hash.0,
+ );
+ }
+ }
+
+ pub fn extend(
+ &mut self,
+ name: CompactStr,
+ hash: IdentifierHash,
+ reference_ids: Vec<ReferenceId>,
+ ) {
+ if let Some(line) = self.inner.find_mut(hash.0, |line| line.name == name) {
+ line.reference_ids.extend(reference_ids);
+ } else {
+ self.inner
+ .insert_unique(hash.0, Line { name, hash, reference_ids }, |line| line.hash.0);
+ }
+ }
+
+ pub fn drain(&mut self) -> Drain<Line> {
+ self.inner.drain()
+ }
+}

crates/oxc_semantic/src/lib.rs

@@ -3,6 +3,7 @@ mod builder;
 mod checker;
 mod class;
 mod diagnostics;
+mod hash;
 mod jsdoc;
 mod label;
 mod module_record;