Make `Bun.build` more reliable (#2718)

* One possible implementation to make `Bun.build` work better

* Pass allocator in

* Make our temporary buffers a little safer

* rename

* Fix memory corruption in symbol table

* Add support for deferred idle events in ThreadPool

* Free more memory

* Use a global allocator FS cache

* more `inline`

* Make duping keys optional in StringMap

* Close file handles more often

* Update router.zig

* wip possibly delete this commit

* Fix memory issues and reduce memory usage

* > 0.8

* Switch to AsyncIO.Waker and fix memory leak in JSBundleCompletionTask

* We don't need to clone this actually

* Fix error

* Format

* Fixup

* Fixup

---------

Co-authored-by: Jarred Sumner <709451+Jarred-Sumner@users.noreply.github.com>

1 files changed, 53 insertions, 10 deletions

diff --git a/src/js_ast.zig b/src/js_ast.zig
index dbd0fb010..bccf4e0d8 100644
--- a/src/js_ast.zig
+++ b/src/js_ast.zig
@@ -2130,6 +2130,20 @@ pub const E = struct {
             };
         }
 
+        pub fn cloneSliceIfNecessary(str: *const String, allocator: std.mem.Allocator) !bun.string {
+            if (Expr.Data.Store.memory_allocator) |mem| {
+                if (mem == GlobalStoreHandle.global_store_ast) {
+                    return str.string(allocator);
+                }
+            }
+
+            if (str.isUTF8()) {
+                return allocator.dupe(u8, str.string(allocator) catch unreachable);
+            }
+
+            return str.string(allocator);
+        }
+
         pub fn javascriptLength(s: *const String) u32 {
             if (s.rope_len > 0) {
                 // We only support ascii ropes for now
@@ -2226,6 +2240,14 @@ pub const E = struct {
             }
         }
 
+        pub fn stringCloned(s: *const String, allocator: std.mem.Allocator) !bun.string {
+            if (s.isUTF8()) {
+                return try allocator.dupe(u8, s.data);
+            } else {
+                return strings.toUTF8Alloc(allocator, s.slice16());
+            }
+        }
+
         pub fn hash(s: *const String) u64 {
             if (s.isBlank()) return 0;
 
@@ -9542,18 +9564,12 @@ pub const ASTMemoryAllocator = struct {
     allocator: std.mem.Allocator,
     previous: ?*ASTMemoryAllocator = null,
 
-    pub fn push(this: *ASTMemoryAllocator) void {
-        if (Stmt.Data.Store.memory_allocator == this) {
-            return;
-        }
+    pub fn reset(this: *ASTMemoryAllocator) void {
         this.stack_allocator.fallback_allocator = this.allocator;
         this.bump_allocator = this.stack_allocator.get();
-        var prev = Stmt.Data.Store.memory_allocator;
-        if (this.previous) |other| {
-            other.previous = prev;
-        } else {
-            this.previous = prev;
-        }
+    }
+
+    pub fn push(this: *ASTMemoryAllocator) void {
         Stmt.Data.Store.memory_allocator = this;
         Expr.Data.Store.memory_allocator = this;
     }
@@ -9646,6 +9662,32 @@ pub const UseDirective = enum {
     }
 };
 
+pub const GlobalStoreHandle = struct {
+    prev_memory_allocator: ?*ASTMemoryAllocator = null,
+
+    var global_store_ast: ?*ASTMemoryAllocator = null;
+    var global_store_threadsafe: std.heap.ThreadSafeAllocator = undefined;
+
+    pub fn get() ?*ASTMemoryAllocator {
+        if (global_store_ast == null) {
+            var global = bun.default_allocator.create(ASTMemoryAllocator) catch unreachable;
+            global.allocator = bun.default_allocator;
+            global.bump_allocator = bun.default_allocator;
+            global_store_ast = global;
+        }
+
+        var prev = Stmt.Data.Store.memory_allocator;
+        Stmt.Data.Store.memory_allocator = global_store_ast;
+        Expr.Data.Store.memory_allocator = global_store_ast;
+        return prev;
+    }
+
+    pub fn unget(handle: ?*ASTMemoryAllocator) void {
+        Stmt.Data.Store.memory_allocator = handle;
+        Expr.Data.Store.memory_allocator = handle;
+    }
+};
+
 // test "Binding.init" {
 //     var binding = Binding.alloc(
 //         std.heap.page_allocator,
@@ -9834,3 +9876,4 @@ pub const UseDirective = enum {
 // Stmt               | 192
 // STry               | 384
 // -- ESBuild bit sizes
+