perf(semantics): avoid hashing when resolving references

crates/oxc_linter/src/context.rs

@@ -143,6 +143,13 @@ impl<'a> LintContext<'a> {
 
     /* Symbols */
 
+    pub fn is_unresolved_reference(&self, node_id: NodeId) -> bool {
+        let AstKind::IdentifierReference(id) = self.kind(node_id) else { return false; };
+        let reference_node = &self.nodes()[node_id];
+        let scope = self.scope(reference_node);
+        scope.unresolved_references.contains_key(&id.name)
+    }
+
     #[allow(clippy::unused_self)]
     pub fn is_reference_to_global_variable(&self, _ident: &IdentifierReference) -> bool {
         true

crates/oxc_linter/src/rules/valid_typeof.rs

@@ -93,7 +93,7 @@ impl Rule for ValidTypeof {
             }
 
             if sibling.is_undefined()
-                && ctx.symbols().get_resolved_reference(sibling_id.into()).is_none()
+                && ctx.is_unresolved_reference(sibling_id)
             {
                 ctx.diagnostic_with_fix(
                     if self.require_string_literals {

crates/oxc_semantic/src/scope/builder.rs

@@ -73,10 +73,8 @@ impl ScopeBuilder {
                 let scope = &self.scopes[scope];
                 if let Some(symbol_id) = scope.get().get_variable_symbol_id(&variable) {
                     // We have resolved this reference.
-                    let symbol = &mut symbol_table[symbol_id];
-                    symbol.add_references(&reference);
                     for r in reference {
-                        symbol_table.resolve_reference(r.ast_node_id, r.resolve_to(symbol_id));
+                        symbol_table.resolve_reference(r, symbol_id);
                     }
                     continue 'outer;
                 }

crates/oxc_semantic/src/symbol/mod.rs

@@ -8,6 +8,7 @@ mod table;
 use bitflags::bitflags;
 use oxc_ast::{Atom, Span};
 
+use self::reference::ResolvedReferenceId;
 pub use self::{
     id::SymbolId,
     reference::{Reference, ReferenceFlag, ResolvedReference},
@@ -24,7 +25,7 @@ pub struct Symbol {
     span: Span,
     flags: SymbolFlags,
     /// Pointers to the AST Nodes that reference this symbol
-    references: Vec<AstNodeId>,
+    references: Vec<ResolvedReferenceId>,
 }
 
 #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
@@ -119,12 +120,12 @@ impl Symbol {
         self.flags.contains(SymbolFlags::Export)
     }
 
-    pub fn add_references(&mut self, new_references: &[Reference]) {
-        self.references.extend(new_references.iter().map(|r| r.ast_node_id));
+    pub fn add_reference(&mut self, reference_id: ResolvedReferenceId) {
+        self.references.push(reference_id);
     }
 
     #[must_use]
-    pub fn references(&self) -> &[AstNodeId] {
+    pub fn references(&self) -> &[ResolvedReferenceId] {
         &self.references
     }
 

crates/oxc_semantic/src/symbol/reference.rs

@@ -1,5 +1,7 @@
 #![allow(non_upper_case_globals)]
 
+use std::num::NonZeroUsize;
+
 use bitflags::bitflags;
 use oxc_ast::Span;
 
@@ -83,3 +85,24 @@ impl ResolvedReference {
         self.reference.span
     }
 }
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct ResolvedReferenceId(NonZeroUsize);
+
+impl Default for ResolvedReferenceId {
+    fn default() -> Self {
+        Self::new(1)
+    }
+}
+
+impl ResolvedReferenceId {
+    #[must_use]
+    pub fn new(n: usize) -> Self {
+        unsafe { Self(NonZeroUsize::new_unchecked(n)) }
+    }
+
+    #[must_use]
+    pub(crate) fn index0(self) -> usize {
+        self.0.get() - 1
+    }
+}

crates/oxc_semantic/src/symbol/table.rs

@@ -1,16 +1,16 @@
 use std::ops::{Deref, Index, IndexMut};
 
 use oxc_ast::{Atom, Span};
-use rustc_hash::FxHashMap;
 
+use super::reference::ResolvedReferenceId;
 use super::{Symbol, SymbolFlags, SymbolId};
 use crate::node::AstNodeId;
-use crate::ResolvedReference;
+use crate::{Reference, ResolvedReference};
 
 #[derive(Debug, Default)]
 pub struct SymbolTable {
     symbols: Vec<Symbol>,
-    resolved_references: FxHashMap<AstNodeId, ResolvedReference>,
+    resolved_references: Vec<ResolvedReference>,
 }
 
 impl Index<SymbolId> for SymbolTable {
@@ -61,11 +61,15 @@ impl SymbolTable {
     }
 
     #[must_use]
-    pub fn get_resolved_reference(&self, id: AstNodeId) -> Option<&ResolvedReference> {
-        self.resolved_references.get(&id)
+    pub fn get_resolved_reference(&self, id: ResolvedReferenceId) -> Option<&ResolvedReference> {
+        self.resolved_references.get(id.index0())
     }
 
-    pub fn resolve_reference(&mut self, id: AstNodeId, reference: ResolvedReference) {
-        self.resolved_references.insert(id, reference);
+    /// Resolve `reference` to `symbol_id`
+    pub fn resolve_reference(&mut self, reference: Reference, symbol_id: SymbolId) {
+        let resolved_reference_id = ResolvedReferenceId::new(self.resolved_references.len() + 1);
+        let resolved_reference = reference.resolve_to(symbol_id);
+        self.resolved_references.push(resolved_reference);
+        self.symbols[symbol_id].add_reference(resolved_reference_id);
     }
 }