std.Build,build_runner: fix more gpa/arena mixups

Author: mlugg

lib/compiler/build_runner.zig

@@ -416,8 +416,8 @@ pub fn main() !void {
         .skip_oom_steps = skip_oom_steps,
         .watch = watch,
         .web_server = undefined, // set after `prepare`
-        .memory_blocked_steps = std.ArrayList(*Step).init(arena),
-        .step_stack = .{},
+        .memory_blocked_steps = .empty,
+        .step_stack = .empty,
         .prominent_compile_errors = prominent_compile_errors,
 
         .claimed_rss = 0,
@@ -426,6 +426,10 @@ pub fn main() !void {
         .stderr = stderr,
         .thread_pool = undefined,
     };
+    defer {
+        run.memory_blocked_steps.deinit(gpa);
+        run.step_stack.deinit(gpa);
+    }
 
     if (run.max_rss == 0) {
         run.max_rss = process.totalSystemMemory() catch std.math.maxInt(u64);
@@ -557,7 +561,9 @@ const Run = struct {
     skip_oom_steps: bool,
     watch: bool,
     web_server: ?WebServer,
-    memory_blocked_steps: std.ArrayList(*Step),
+    /// Allocated into `gpa`.
+    memory_blocked_steps: std.ArrayListUnmanaged(*Step),
+    /// Allocated into `gpa`.
     step_stack: std.AutoArrayHashMapUnmanaged(*Step, void),
     prominent_compile_errors: bool,
     thread_pool: std.Thread.Pool,
@@ -604,7 +610,7 @@ fn prepare(
     rand.shuffle(*Step, starting_steps);
 
     for (starting_steps) |s| {
-        constructGraphAndCheckForDependencyLoop(b, s, &run.step_stack, rand) catch |err| switch (err) {
+        constructGraphAndCheckForDependencyLoop(gpa, b, s, &run.step_stack, rand) catch |err| switch (err) {
             error.DependencyLoopDetected => return uncleanExit(),
             else => |e| return e,
         };
@@ -1044,6 +1050,7 @@ fn printTreeStep(
 ///   when it finishes executing in `workerMakeOneStep`, it spawns next steps
 ///   to run in random order
 fn constructGraphAndCheckForDependencyLoop(
+    gpa: Allocator,
     b: *std.Build,
     s: *Step,
     step_stack: *std.AutoArrayHashMapUnmanaged(*Step, void),
@@ -1057,17 +1064,19 @@ fn constructGraphAndCheckForDependencyLoop(
         .precheck_unstarted => {
             s.state = .precheck_started;
 
-            try step_stack.ensureUnusedCapacity(b.allocator, s.dependencies.items.len);
+            try step_stack.ensureUnusedCapacity(gpa, s.dependencies.items.len);
 
             // We dupe to avoid shuffling the steps in the summary, it depends
             // on s.dependencies' order.
-            const deps = b.allocator.dupe(*Step, s.dependencies.items) catch @panic("OOM");
+            const deps = gpa.dupe(*Step, s.dependencies.items) catch @panic("OOM");
+            defer gpa.free(deps);
+
             rand.shuffle(*Step, deps);
 
             for (deps) |dep| {
-                try step_stack.put(b.allocator, dep, {});
+                try step_stack.put(gpa, dep, {});
                 try dep.dependants.append(b.allocator, s);
-                constructGraphAndCheckForDependencyLoop(b, dep, step_stack, rand) catch |err| {
+                constructGraphAndCheckForDependencyLoop(gpa, b, dep, step_stack, rand) catch |err| {
                     if (err == error.DependencyLoopDetected) {
                         std.debug.print("  {s}\n", .{s.name});
                     }
@@ -1132,7 +1141,7 @@ fn workerMakeOneStep(
         if (new_claimed_rss > run.max_rss) {
             // Running this step right now could possibly exceed the allotted RSS.
             // Add this step to the queue of memory-blocked steps.
-            run.memory_blocked_steps.append(s) catch @panic("OOM");
+            run.memory_blocked_steps.append(run.gpa, s) catch @panic("OOM");
             return;
         }
 
@@ -1285,10 +1294,10 @@ pub fn printErrorMessages(
 }
 
 fn printSteps(builder: *std.Build, w: *Writer) !void {
-    const allocator = builder.allocator;
+    const arena = builder.graph.arena;
     for (builder.top_level_steps.values()) |top_level_step| {
         const name = if (&top_level_step.step == builder.default_step)
-            try fmt.allocPrint(allocator, "{s} (default)", .{top_level_step.step.name})
+            try fmt.allocPrint(arena, "{s} (default)", .{top_level_step.step.name})
         else
             top_level_step.step.name;
         try w.print("  {s:<28} {s}\n", .{ name, top_level_step.description });
@@ -1361,7 +1370,7 @@ fn printUsage(b: *std.Build, w: *Writer) !void {
         \\
     );
 
-    const arena = b.allocator;
+    const arena = b.graph.arena;
     if (b.available_options_list.items.len == 0) {
         try w.print("  (none)\n", .{});
     } else {

lib/std/Build/Step.zig

@@ -454,7 +454,10 @@ pub fn evalZigProcess(
         .progress_ipc_fd = if (std.Progress.have_ipc) child.progress_node.getIpcFd() else {},
     };
     if (watch) s.setZigProcess(zp);
-    defer if (!watch) zp.poller.deinit();
+    defer if (!watch) {
+        zp.poller.deinit();
+        gpa.destroy(zp);
+    };
 
     const result = try zigProcessUpdate(s, zp, watch, web_server, gpa);