refactor(mangler): use external allocator

Author: Cameron McHenry

crates/oxc/src/compiler.rs

@@ -208,7 +208,8 @@ pub trait CompilerInterface {
 
         /* Mangler */
 
-        let mangler = self.mangle_options().map(|options| self.mangle(&mut program, options));
+        let mangler =
+            self.mangle_options().map(|options| self.mangle(&allocator, &mut program, options));
 
         /* Codegen */
 
@@ -279,8 +280,13 @@ pub trait CompilerInterface {
         Compressor::new(allocator, options).build(program);
     }
 
-    fn mangle(&self, program: &mut Program<'_>, options: MangleOptions) -> Scoping {
-        Mangler::new().with_options(options).build(program)
+    fn mangle(
+        &self,
+        allocator: &Allocator,
+        program: &mut Program<'_>,
+        options: MangleOptions,
+    ) -> Scoping {
+        Mangler::new(allocator).with_options(options).build(program)
     }
 
     fn codegen(

crates/oxc_mangler/src/lib.rs

@@ -155,15 +155,15 @@ type Slot = usize;
 /// - slot 1: `top_level_b`, `foo_a`, `bar_a`
 /// - slot 2: `foo`
 /// - slot 3: `bar`
-#[derive(Default)]
-pub struct Mangler {
+pub struct Mangler<'m> {
     options: MangleOptions,
+    allocator: &'m Allocator,
 }
 
-impl Mangler {
+impl<'m> Mangler<'m> {
     #[must_use]
-    pub fn new() -> Self {
-        Self::default()
+    pub fn new(allocator: &'m Allocator) -> Self {
+        Self { options: MangleOptions::default(), allocator }
     }
 
     #[must_use]
@@ -216,10 +216,8 @@ impl Mangler {
         let (keep_name_names, keep_name_symbols) =
             Mangler::collect_keep_name_symbols(self.options.keep_names, scoping, ast_nodes);
 
-        let allocator = Allocator::default();
-
         // All symbols with their assigned slots. Keyed by symbol id.
-        let mut slots = Vec::from_iter_in(iter::repeat_n(0, scoping.symbols_len()), &allocator);
+        let mut slots = Vec::from_iter_in(iter::repeat_n(0, scoping.symbols_len()), self.allocator);
 
         // Stores the lived scope ids for each slot. Keyed by slot number.
         let mut slot_liveness: std::vec::Vec<FixedBitSet> = vec![];
@@ -300,13 +298,13 @@ impl Mangler {
             &keep_name_symbols,
             total_number_of_slots,
             &slots,
-            &allocator,
+            self.allocator,
         );
 
         let root_unresolved_references = scoping.root_unresolved_references();
         let root_bindings = scoping.get_bindings(scoping.root_scope_id());
 
-        let mut reserved_names = Vec::with_capacity_in(total_number_of_slots, &allocator);
+        let mut reserved_names = Vec::with_capacity_in(total_number_of_slots, self.allocator);
 
         let mut count = 0;
         for _ in 0..total_number_of_slots {

crates/oxc_minifier/examples/mangler.rs

@@ -24,26 +24,32 @@ fn main() -> std::io::Result<()> {
     let source_text = std::fs::read_to_string(path)?;
     let source_type = SourceType::from_path(path).unwrap();
 
+    let mut allocator = Allocator::default();
     let options = MangleOptions {
         top_level: source_type.is_module(),
         keep_names: MangleOptionsKeepNames { function: keep_names, class: keep_names },
         debug,
     };
-    let printed = mangler(&source_text, source_type, options);
+    let printed = mangler(&allocator, &source_text, source_type, options);
     println!("{printed}");
 
     if twice {
-        let printed2 = mangler(&printed, source_type, options);
+        allocator.reset();
+        let printed2 = mangler(&allocator, &printed, source_type, options);
         println!("{printed2}");
         println!("same = {}", printed == printed2);
     }
 
     Ok(())
 }
 
-fn mangler(source_text: &str, source_type: SourceType, options: MangleOptions) -> String {
-    let allocator = Allocator::default();
-    let ret = Parser::new(&allocator, source_text, source_type).parse();
-    let symbol_table = Mangler::new().with_options(options).build(&ret.program);
+fn mangler(
+    allocator: &Allocator,
+    source_text: &str,
+    source_type: SourceType,
+    options: MangleOptions,
+) -> String {
+    let ret = Parser::new(allocator, source_text, source_type).parse();
+    let symbol_table = Mangler::new(allocator).with_options(options).build(&ret.program);
     Codegen::new().with_scoping(Some(symbol_table)).build(&ret.program).code
 }

crates/oxc_minifier/src/lib.rs

@@ -63,7 +63,9 @@ impl Minifier {
                 .with_scope_tree_child_ids(true)
                 .build(program)
                 .semantic;
-            Mangler::default().with_options(options).build_with_semantic(&mut semantic, program);
+            Mangler::new(allocator)
+                .with_options(options)
+                .build_with_semantic(&mut semantic, program);
             semantic.into_scoping()
         });
         MinifierReturn { scoping }

crates/oxc_minifier/tests/mangler/mod.rs

@@ -11,7 +11,7 @@ fn mangle(source_text: &str, options: MangleOptions) -> String {
     let source_type = SourceType::mjs();
     let ret = Parser::new(&allocator, source_text, source_type).parse();
     let program = ret.program;
-    let symbol_table = Mangler::new().with_options(options).build(&program);
+    let symbol_table = Mangler::new(&allocator).with_options(options).build(&program);
     Codegen::new().with_scoping(Some(symbol_table)).build(&program).code
 }
 

tasks/benchmark/benches/minifier.rs

@@ -57,14 +57,16 @@ fn bench_mangler(criterion: &mut Criterion) {
         let source_type = SourceType::from_path(&file.file_name).unwrap();
         let source_text = file.source_text.as_str();
         let mut allocator = Allocator::default();
+        let mut mangler_allocator = Allocator::default();
         group.bench_function(id, |b| {
             b.iter_with_setup_wrapper(|runner| {
                 allocator.reset();
+                mangler_allocator.reset();
                 let program = Parser::new(&allocator, source_text, source_type).parse().program;
                 let mut semantic =
                     SemanticBuilder::new().with_scope_tree_child_ids(true).build(&program).semantic;
                 runner.run(|| {
-                    Mangler::new().build_with_semantic(&mut semantic, &program);
+                    Mangler::new(&mangler_allocator).build_with_semantic(&mut semantic, &program);
                 });
             });
         });