1 files changed, 23 insertions, 40 deletions

diff --git a/src/bundler.zig b/src/bundler.zig
index aa7bfaec9..42b515678 100644
--- a/src/bundler.zig
+++ b/src/bundler.zig
@@ -80,9 +80,6 @@ pub const Bundler = struct {
         log: *logger.Log,
         opts: Api.TransformOptions,
     ) !Bundler {
-        js_ast.Expr.Data.Store.create(allocator);
-        js_ast.Stmt.Data.Store.create(allocator);
-
         var fs = try Fs.FileSystem.init1(allocator, opts.absolute_working_dir, opts.serve orelse false);
         const bundle_options = try options.BundleOptions.fromApi(allocator, fs, log, opts);
 
@@ -171,36 +168,35 @@ pub const Bundler = struct {
             bundler.needs_runtime = true;
         }
 
-        import_record.path = try bundler.generateImportPath(source_dir, resolve_result.path_pair.primary.text);
-
         // lazy means:
         // Run the resolver
         // Don't parse/print automatically.
         if (bundler.options.resolve_mode != .lazy) {
-            try bundler.enqueueResolveResult(resolve_result);
+            try bundler.enqueueResolveResult(&resolve_result);
         }
+
+        import_record.path = try bundler.generateImportPath(source_dir, resolve_result.path_pair.primary.text);
     }
 
-    pub fn resolveResultHashKey(bundler: *Bundler, path: string) string {
-        var hash_key = path;
+    pub fn resolveResultHashKey(bundler: *Bundler, resolve_result: *Resolver.Resolver.Result) string {
+        var hash_key = resolve_result.path_pair.primary.text;
 
         // Shorter hash key is faster to hash
-        if (strings.startsWith(path, bundler.fs.top_level_dir)) {
-            hash_key = path[bundler.fs.top_level_dir.len..];
+        if (strings.startsWith(resolve_result.path_pair.primary.text, bundler.fs.top_level_dir)) {
+            hash_key = resolve_result.path_pair.primary.text[bundler.fs.top_level_dir.len..];
         }
 
         return hash_key;
     }
 
-    pub fn enqueueResolveResult(bundler: *Bundler, resolve_result: Resolver.Resolver.Result) !void {
-        const hash_key = bundler.resolveResultHashKey(resolve_result.path_pair.primary.text);
+    pub fn enqueueResolveResult(bundler: *Bundler, resolve_result: *Resolver.Resolver.Result) !void {
+        const hash_key = bundler.resolveResultHashKey(resolve_result);
 
         const get_or_put_entry = try bundler.resolve_results.backing.getOrPut(hash_key);
 
-        get_or_put_entry.entry.value = resolve_result;
-
         if (!get_or_put_entry.found_existing) {
-            try bundler.resolve_queue.writeItem(resolve_result);
+            get_or_put_entry.entry.value = resolve_result.*;
+            try bundler.resolve_queue.writeItem(resolve_result.*);
         }
     }
 
@@ -514,17 +510,22 @@ pub const Bundler = struct {
         };
     }
 
-    pub fn run(bundler: *Bundler) !options.TransformResult {
-        const allocator = bundler.allocator;
+    pub fn bundle(
+        allocator: *std.mem.Allocator,
+        log: *logger.Log,
+        opts: Api.TransformOptions,
+    ) !options.TransformResult {
+        var bundler = try Bundler.init(allocator, log, opts);
+
         //  100.00 µs std.fifo.LinearFifo(resolver.resolver.Result,std.fifo.LinearFifoBufferType { .Dynamic = {}}).writeItemAssumeCapacity
-        // if (bundler.options.resolve_mode != .lazy) {
-        //     try bundler.resolve_queue.ensureUnusedCapacity(1000);
-        // }
+        if (bundler.options.resolve_mode != .lazy) {
+            try bundler.resolve_queue.ensureUnusedCapacity(1000);
+        }
 
         var entry_points = try allocator.alloc(Resolver.Resolver.Result, bundler.options.entry_points.len);
 
         if (isDebug) {
-            bundler.log.level = .verbose;
+            log.level = .verbose;
             bundler.resolver.debug_logs = try Resolver.Resolver.DebugLogs.init(allocator);
         }
 
@@ -595,10 +596,6 @@ pub const Bundler = struct {
             bundler.resolve_queue.writeItem(result) catch unreachable;
         }
 
-        // The resolver may use the AST store when parsing package.json / tsconfig.json
-        js_ast.Stmt.Data.Store.reset();
-        js_ast.Expr.Data.Store.reset();
-
         switch (bundler.options.resolve_mode) {
             .lazy, .dev, .bundle => {
                 while (bundler.resolve_queue.readItem()) |item| {
@@ -631,21 +628,7 @@ pub const Bundler = struct {
             );
         }
 
-        return try options.TransformResult.init(
-            try allocator.dupe(u8, bundler.result.outbase),
-            bundler.output_files.toOwnedSlice(),
-            bundler.log,
-            bundler.allocator,
-        );
-    }
-
-    pub fn bundle(
-        allocator: *std.mem.Allocator,
-        log: *logger.Log,
-        opts: Api.TransformOptions,
-    ) !options.TransformResult {
-        var bundler = try Bundler.init(allocator, log, opts);
-        return try bundler.run();
+        return try options.TransformResult.init(try allocator.dupe(u8, bundler.result.outbase), bundler.output_files.toOwnedSlice(), log, allocator);
     }
 };