trick

Author: Boshen

crates/oxc_mangler/src/lib.rs

@@ -8,7 +8,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::{ReferenceId, ScopeTree, Semantic, SemanticBuilder, SymbolId, SymbolTable};
 use oxc_span::Atom;
 
 #[derive(Default, Debug, Clone, Copy)]
@@ -92,24 +92,18 @@ impl Mangler {
     pub fn build(self, program: &Program<'_>) -> Mangler {
         let semantic =
             SemanticBuilder::new().with_scope_tree_child_ids(true).build(program).semantic;
-        let (symbol_table, scope_tree) = semantic.into_symbol_table_and_scope_tree();
-        self.build_with_symbols_and_scopes(symbol_table, &scope_tree, program)
+        self.build_with_semantic(semantic, program)
     }
 
     /// # Panics
     ///
     /// Panics if the child_ids does not exist in scope_tree.
     #[must_use]
-    pub fn build_with_symbols_and_scopes(
-        self,
-        symbol_table: SymbolTable,
-        scope_tree: &ScopeTree,
-        program: &Program<'_>,
-    ) -> Mangler {
+    pub fn build_with_semantic(self, semantic: Semantic<'_>, program: &Program<'_>) -> Mangler {
         if self.options.debug {
-            self.build_with_symbols_and_scopes_impl(symbol_table, scope_tree, program, debug_name)
+            self.build_with_symbols_and_scopes_impl(semantic, program, debug_name)
         } else {
-            self.build_with_symbols_and_scopes_impl(symbol_table, scope_tree, program, base54)
+            self.build_with_symbols_and_scopes_impl(semantic, program, base54)
         }
     }
 
@@ -118,11 +112,12 @@ impl Mangler {
         G: Fn(usize) -> InlineString<CAPACITY>,
     >(
         mut self,
-        symbol_table: SymbolTable,
-        scope_tree: &ScopeTree,
+        semantic: Semantic<'_>,
         program: &Program<'_>,
         generate_name: G,
     ) -> Mangler {
+        let (mut symbol_table, scope_tree, ast_nodes) = semantic.into_symbols_scopes_nodes();
+
         assert!(scope_tree.has_child_ids(), "child_id needs to be generated");
 
         let (exported_names, exported_symbols) = if self.options.top_level {
@@ -133,10 +128,6 @@ impl Mangler {
 
         let allocator = Allocator::default();
 
-        // Mangle the symbol table by computing slots from the scope tree.
-        // A slot is the occurrence index of a binding identifier inside a scope.
-        let mut symbol_table = symbol_table;
-
         // All symbols with their assigned slots. Keyed by symbol id.
         let mut slots: Vec<'_, Slot> = Vec::with_capacity_in(symbol_table.len(), &allocator);
         for _ in 0..symbol_table.len() {
@@ -150,54 +141,57 @@ impl Mangler {
         for scope_id in iter::once(scope_tree.root_scope_id())
             .chain(scope_tree.iter_all_child_ids(scope_tree.root_scope_id()))
         {
+            let bindings = scope_tree.get_bindings(scope_id);
+            if bindings.is_empty() {
+                continue;
+            }
+
+            let mut slot = slot_liveness.len();
+
             let nearest_var_scope_id = scope_tree
                 .ancestors(scope_id)
                 .find(|s_id| scope_tree.get_flags(*s_id).is_var())
                 .unwrap_or(scope_tree.root_scope_id());
-            let bindings = scope_tree.get_bindings(scope_id);
 
-            let mut slot = slot_liveness.len();
-
-            if !bindings.is_empty() {
-                let reusable_slots = Vec::from_iter_in(
-                    slot_liveness
-                        .iter()
-                        .enumerate()
-                        .filter(|(_, slot_liveness)| !slot_liveness.contains(scope_id.index()))
-                        .map(|(slot, _)| slot)
-                        .take(bindings.len()),
-                    &allocator,
-                );
-                let remaining_count = bindings.len() - reusable_slots.len();
-
-                let assignable_slots =
-                    reusable_slots.into_iter().chain(slot..slot + remaining_count);
-                slot += remaining_count;
-                if slot_liveness.len() < slot {
-                    slot_liveness
-                        .resize_with(slot, || FixedBitSet::with_capacity(scope_tree.len()));
-                }
+            let reusable_slots = Vec::from_iter_in(
+                slot_liveness
+                    .iter()
+                    .enumerate()
+                    .filter(|(_, slot_liveness)| !slot_liveness.contains(scope_id.index()))
+                    .map(|(slot, _)| slot)
+                    .take(bindings.len()),
+                &allocator,
+            );
+
+            let remaining_count = bindings.len() - reusable_slots.len();
+
+            let assignable_slots = reusable_slots.into_iter().chain(slot..slot + remaining_count);
+            slot += remaining_count;
+            if slot_liveness.len() < slot {
+                slot_liveness.resize_with(slot, || FixedBitSet::with_capacity(scope_tree.len()));
+            }
 
-                // Sort `bindings` in declaration order.
-                tmp_bindings.clear();
-                tmp_bindings.extend(bindings.values().copied());
-                tmp_bindings.sort_unstable();
-                for (symbol_id, assigned_slot) in tmp_bindings.iter().zip(assignable_slots) {
-                    slots[symbol_id.index()] = assigned_slot;
-
-                    let lived_scope_ids = symbol_table
-                        .get_resolved_references(*symbol_id)
-                        .flat_map(|reference| {
-                            // treat all symbols as var for now
-                            // the reusability can be improved by reducing the lived scope ids for const / let / class
-                            scope_tree
-                                .ancestors(reference.scope_id())
-                                .take_while(|s_id| *s_id != nearest_var_scope_id)
-                        })
-                        .chain(iter::once(nearest_var_scope_id));
-                    for scope_id in lived_scope_ids {
-                        slot_liveness[assigned_slot].insert(scope_id.index());
-                    }
+            // Sort `bindings` in declaration order.
+            tmp_bindings.clear();
+            tmp_bindings.extend(bindings.values().copied());
+            tmp_bindings.sort_unstable();
+            for (symbol_id, assigned_slot) in tmp_bindings.iter().zip(assignable_slots) {
+                slots[symbol_id.index()] = assigned_slot;
+
+                let lived_scope_ids = symbol_table
+                    .get_resolved_references(*symbol_id)
+                    .flat_map(|reference| {
+                        let scope_id = ast_nodes.get_node(reference.node_id()).scope_id();
+                        // Treat all symbols as var for now.
+                        // Reusability can be improved by reducing the lived scope ids for const / let / class
+                        scope_tree
+                            .ancestors(scope_id)
+                            .take_while(|s_id| *s_id != nearest_var_scope_id)
+                    })
+                    .chain(iter::once(nearest_var_scope_id));
+
+                for scope_id in lived_scope_ids {
+                    slot_liveness[assigned_slot].insert(scope_id.index());
                 }
             }
         }
@@ -207,7 +201,7 @@ impl Mangler {
         let frequencies = self.tally_slot_frequencies(
             &symbol_table,
             &exported_symbols,
-            scope_tree,
+            &scope_tree,
             total_number_of_slots,
             &slots,
             &allocator,

crates/oxc_minifier/src/lib.rs

@@ -60,10 +60,7 @@ impl Minifier {
                 .with_scope_tree_child_ids(true)
                 .build(program)
                 .semantic;
-            let (symbols, scopes) = semantic.into_symbol_table_and_scope_tree();
-            Mangler::default()
-                .with_options(options)
-                .build_with_symbols_and_scopes(symbols, &scopes, program)
+            Mangler::default().with_options(options).build_with_semantic(semantic, program)
         });
         MinifierReturn { mangler }
     }

crates/oxc_semantic/src/builder.rs

@@ -2119,7 +2119,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, self.current_scope_id, flags);
+        let reference = Reference::new(self.current_node_id, flags);
         let reference_id = self.declare_reference(ident.name, reference);
         ident.reference_id.set(Some(reference_id));
     }

crates/oxc_semantic/src/lib.rs

@@ -90,12 +90,16 @@ pub struct Semantic<'a> {
 }
 
 impl<'a> Semantic<'a> {
-    /// Extract the [`SymbolTable`] and [`ScopeTree`] from the [`Semantic`]
-    /// instance, consuming `self`.
+    /// Extract [`SymbolTable`] and [`ScopeTree`] from [`Semantic`].
     pub fn into_symbol_table_and_scope_tree(self) -> (SymbolTable, ScopeTree) {
         (self.symbols, self.scopes)
     }
 
+    /// Extract [`SymbolTable`], [`ScopeTree`] and [`AstNode`] from the [`Semantic`].
+    pub fn into_symbols_scopes_nodes(self) -> (SymbolTable, ScopeTree, AstNodes<'a>) {
+        (self.symbols, self.scopes, self.nodes)
+    }
+
     /// Source code of the JavaScript/TypeScript program being analyzed.
     pub fn source_text(&self) -> &'a str {
         self.source_text

crates/oxc_syntax/src/reference.rs

@@ -6,7 +6,7 @@ use oxc_index::Idx;
 #[cfg(feature = "serialize")]
 use serde::{Serialize, Serializer};
 
-use crate::{node::NodeId, scope::ScopeId, symbol::SymbolId};
+use crate::{node::NodeId, symbol::SymbolId};
 
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
 pub struct ReferenceId(NonMaxU32);
@@ -234,8 +234,6 @@ impl<'alloc> CloneIn<'alloc> for ReferenceFlags {
 pub struct Reference {
     /// The AST node making the reference.
     node_id: NodeId,
-    /// The scope of the AST node making the reference.
-    scope_id: ScopeId,
     /// The symbol being referenced.
     ///
     /// This will be [`None`] if no symbol could be found within
@@ -250,19 +248,14 @@ pub struct Reference {
 impl Reference {
     /// Create a new unresolved reference.
     #[inline]
-    pub fn new(node_id: NodeId, scope_id: ScopeId, flags: ReferenceFlags) -> Self {
-        Self { node_id, scope_id, symbol_id: None, flags }
+    pub fn new(node_id: NodeId, flags: ReferenceFlags) -> Self {
+        Self { node_id, symbol_id: None, flags }
     }
 
     /// Create a new resolved reference on a symbol.
     #[inline]
-    pub fn new_with_symbol_id(
-        node_id: NodeId,
-        scope_id: ScopeId,
-        symbol_id: SymbolId,
-        flags: ReferenceFlags,
-    ) -> Self {
-        Self { node_id, scope_id, symbol_id: Some(symbol_id), flags }
+    pub fn new_with_symbol_id(node_id: NodeId, symbol_id: SymbolId, flags: ReferenceFlags) -> Self {
+        Self { node_id, symbol_id: Some(symbol_id), flags }
     }
 
     /// Get the id of the node that is referencing the symbol.
@@ -271,12 +264,6 @@ impl Reference {
         self.node_id
     }
 
-    /// Get the id of the scope that is referencing the symbol.
-    #[inline]
-    pub fn scope_id(&self) -> ScopeId {
-        self.scope_id
-    }
-
     /// Get the id of the symbol being referenced.
     ///
     /// Will return [`None`] if the symbol could not be resolved.

crates/oxc_traverse/src/context/scoping.rs

@@ -306,16 +306,15 @@ impl TraverseScoping {
         symbol_id: SymbolId,
         flags: ReferenceFlags,
     ) -> ReferenceId {
-        let reference =
-            Reference::new_with_symbol_id(NodeId::DUMMY, self.current_scope_id, symbol_id, flags);
+        let reference = Reference::new_with_symbol_id(NodeId::DUMMY, symbol_id, flags);
         let reference_id = self.symbols.create_reference(reference);
         self.symbols.add_resolved_reference(symbol_id, reference_id);
         reference_id
     }
 
     /// Create an unbound reference
     pub fn create_unbound_reference(&mut self, name: &str, flags: ReferenceFlags) -> ReferenceId {
-        let reference = Reference::new(NodeId::DUMMY, self.current_scope_id, flags);
+        let reference = Reference::new(NodeId::DUMMY, flags);
         let reference_id = self.symbols.create_reference(reference);
         self.scopes.add_root_unresolved_reference(name, reference_id);
         reference_id

tasks/benchmark/benches/minifier.rs

@@ -58,14 +58,10 @@ fn bench_mangler(criterion: &mut Criterion) {
             b.iter_with_setup_wrapper(|runner| {
                 allocator.reset();
                 let program = Parser::new(&allocator, source_text, source_type).parse().program;
-                let (symbols, scopes) = SemanticBuilder::new()
-                    .with_scope_tree_child_ids(true)
-                    .build(&program)
-                    .semantic
-                    .into_symbol_table_and_scope_tree();
+                let semantic =
+                    SemanticBuilder::new().with_scope_tree_child_ids(true).build(&program).semantic;
                 runner.run(|| {
-                    let _ =
-                        Mangler::new().build_with_symbols_and_scopes(symbols, &scopes, &program);
+                    let _ = Mangler::new().build_with_semantic(semantic, &program);
                 });
             });
         });