Commit 6b7ce1fa22b301ac06d3bfa0a8938546966f684c | zig

author	Andrew Kelley <andrew@ziglang.org> 2026-02-18 17:30:54-08:00
committer	Andrew Kelley <andrew@ziglang.org> 2026-05-25 18:54:34-07:00
log	6b7ce1fa22b301ac06d3bfa0a8938546966f684c
tree	88d5a9c33855fa67da2c0f1ab2ab1f70ab724fd2
parent	b3d162d6bfe82d84d55edd58016347a420732fe2

massage Step code into compiling

10 files changed, 630 insertions(+), 453 deletions(-)

lib
- compiler
  - Maker.zig
  - Maker
    Fuzz.zig
    Step.zig
    Step
    Compile.zig
    Run.zig
    Watch.zig
    WebServer.zig
- std
  - Build.zig
  - Build
    Step
    Compile.zig
  - zig
    Configuration.zig

lib/compiler/Maker.zig+64-53

 @@ -419,7 +419,7 @@ pub fn main(init: process.Init.Minimal) !void {
         var top_level_steps: std.StringArrayHashMapUnmanaged(Configuration.Step.Index) = .empty;
         for (configuration.steps, 0..) |*conf_step, step_index_usize| {
             const step_index: Configuration.Step.Index = @enumFromInt(step_index_usize);
-            const flags: Configuration.Step.Flags = @bitCast(configuration.extra[conf_step.extra_index]);
+            const flags = conf_step.flags(&configuration);
             if (flags.tag == .top_level) {
                 const name = step_index.ptr(&configuration).name.slice(&configuration);
                 try top_level_steps.put(arena, name, step_index);
 @@ -538,7 +538,7 @@ pub fn main(init: process.Init.Minimal) !void {
     var w: Watch = w: {
         if (!watch) break :w undefined;
         if (!Watch.have_impl) fatal("--watch not yet implemented for {t}", .{builtin.os.tag});
-        break :w try .init(graph.cache.cwd, &scanned_config.configuration, maker.steps);
+        break :w try .init(&maker);
     };
     const now = Io.Clock.Timestamp.now(io, .awake);
 @@ -546,14 +546,10 @@ pub fn main(init: process.Init.Minimal) !void {
     maker.web_server = if (webui_listen) |listen_address| ws: {
         if (builtin.single_threaded) unreachable; // `fatal` above
         break :ws .init(.{
-            .gpa = gpa,
+            .maker = &maker,
-            .graph = &graph,
-            .all_steps = maker.step_stack.keys(),
             .root_prog_node = main_progress_node,
-            .watch = watch,
             .listen_address = listen_address,
             .base_timestamp = now,
-            .configuration = &scanned_config.configuration,
         });
     } else null;
 @@ -564,7 +560,9 @@ pub fn main(init: process.Init.Minimal) !void {
     rebuild: while (true) : (if (maker.error_style.clearOnUpdate()) {
         const stderr = try io.lockStderr(&stdio_buffer_allocation, graph.stderr_mode);
         defer io.unlockStderr();
-        try stderr.file_writer.interface.writeAll("\x1B[2J\x1B[3J\x1B[H");
+        stderr.file_writer.interface.writeAll("\x1B[2J\x1B[3J\x1B[H") catch |err| switch (err) {
+            error.WriteFailed => return stderr.file_writer.err.?,
+        };
     }) {
         if (maker.web_server) |*ws| ws.startBuild();
 @@ -608,15 +606,15 @@ pub fn main(init: process.Init.Minimal) !void {
         // recursive dependants.
         var caption_buf: [std.Progress.Node.max_name_len]u8 = undefined;
         const caption = std.fmt.bufPrint(&caption_buf, "watching {d} directories, {d} processes", .{
-            w.dir_count, countSubProcesses(maker.steps, maker.step_stack.keys()),
+            w.dir_count, countSubProcesses(&maker),
         }) catch &caption_buf;
         var debouncing_node = main_progress_node.start(caption, 0);
         var in_debounce = false;
-        while (true) switch (try w.wait(gpa, io, if (in_debounce) .{ .ms = debounce_interval_ms } else .none)) {
+        while (true) switch (try w.wait(if (in_debounce) .{ .ms = debounce_interval_ms } else .none)) {
             .timeout => {
                 assert(in_debounce);
                 debouncing_node.end();
-                markFailedStepsDirty(gpa, maker.steps, maker.step_stack.keys());
+                markFailedStepsDirty(&maker);
                 continue :rebuild;
             },
             .dirty => if (!in_debounce) {
 @@ -629,18 +627,20 @@ pub fn main(init: process.Init.Minimal) !void {
     }
 }
-fn markFailedStepsDirty(gpa: Allocator, make_steps: []Step, all_steps: []const Configuration.Step.Index) void {
+fn markFailedStepsDirty(maker: *Maker) void {
+    const all_steps = maker.step_stack.keys();
     for (all_steps) |step_index| {
-        const step = &make_steps[@intFromEnum(step_index)];
+        const step = maker.stepByIndex(step_index);
         switch (step.state) {
-            .dependency_failure, .failure, .skipped => _ = step.invalidateResult(gpa),
+            .dependency_failure, .failure, .skipped => _ = maker.invalidateResult(step),
             else => continue,
         }
     }
     // Now that all dirty steps have been found, the remaining steps that
     // succeeded from last run shall be marked "cached".
     for (all_steps) |step_index| {
-        const step = &make_steps[@intFromEnum(step_index)];
+        const step = maker.stepByIndex(step_index);
         switch (step.state) {
             .success => step.result_cached = true,
             else => continue,
 @@ -648,10 +648,11 @@ fn markFailedStepsDirty(gpa: Allocator, make_steps: []Step, all_steps: []const C
     }
 }
-fn countSubProcesses(make_steps: []Step, all_steps: []const Configuration.Step.Index) usize {
+fn countSubProcesses(maker: *Maker) usize {
+    const all_steps = maker.step_stack.keys();
     var count: usize = 0;
     for (all_steps) |step_index| {
-        const s = &make_steps[@intFromEnum(step_index)];
+        const s = maker.stepByIndex(step_index);
         count += @intFromBool(s.getZigProcess() != null);
     }
     return count;
 @@ -664,7 +665,7 @@ const InstallPaths = struct {
     include: Path,
 };
-fn stepByIndex(maker: *const Maker, i: Configuration.Step.Index) *Step {
+pub fn stepByIndex(maker: *const Maker, i: Configuration.Step.Index) *Step {
     return &maker.steps[@intFromEnum(i)];
 }
 @@ -676,7 +677,10 @@ fn prepare(maker: *Maker, step_names: []const []const u8) !void {
     const step_stack = &maker.step_stack;
     const c = &maker.scanned_config.configuration;
-    @memset(maker.steps, .{});
+    for (maker.steps, 0..) |*step, step_index_usize| {
+        const step_index: Configuration.Step.Index = @enumFromInt(step_index_usize);
+        step.* = .{ .extended = .init(step_index.ptr(c).flags(c).tag) };
+    }
     if (step_names.len == 0) {
         try step_stack.put(gpa, c.default_step, {});
 @@ -699,7 +703,7 @@ fn prepare(maker: *Maker, step_names: []const []const u8) !void {
     rand.shuffle(Configuration.Step.Index, starting_steps);
     for (starting_steps) |s| {
-        try constructGraphAndCheckForDependencyLoop(gpa, c, maker.steps, s, &maker.step_stack, rand);
+        try constructGraphAndCheckForDependencyLoop(maker, s, &maker.step_stack, rand);
     }
     {
 @@ -847,13 +851,8 @@ fn makeStepNames(
         }
         assert(mode == .limit);
-        var f = Fuzz.init(
+        var f = Fuzz.init(maker, step_stack.keys(), parent_prog_node, mode) catch |err|
-            gpa,
+            fatal("failed to start fuzzer: {t}", .{err});
-            io,
-            step_stack.keys(),
-            parent_prog_node,
-            mode,
-        ) catch |err| fatal("failed to start fuzzer: {t}", .{err});
         defer f.deinit();
         f.start();
 @@ -1048,13 +1047,7 @@ fn makeStep(
                 .success, .skipped => {},
             }
-        } else if (make_step.make(.{
+        } else if (Step.make(step_index, maker, step_prog_node)) state: {
-            .progress_node = step_prog_node,
-            .watch = maker.watch,
-            .web_server = if (maker.web_server) |*ws| ws else null,
-            .unit_test_timeout_ns = maker.unit_test_timeout_ns,
-            .gpa = gpa,
-        })) state: {
             break :state .success;
         } else |err| switch (err) {
             error.MakeFailed => .failure,
 @@ -1091,7 +1084,7 @@ fn makeStep(
     {
         const stderr = try io.lockStderr(&stdio_buffer_allocation, graph.stderr_mode);
         defer io.unlockStderr();
-        printErrorMessages(gpa, c, maker.steps, step_index, .{}, stderr.terminal(), maker.error_style, maker.multiline_errors) catch |err| switch (err) {
+        printErrorMessages(maker, step_index, .{}, stderr.terminal(), maker.error_style, maker.multiline_errors) catch |err| switch (err) {
             error.Canceled => |e| return e,
             error.WriteFailed => switch (stderr.file_writer.err.?) {
                 error.Canceled => |e| return e,
 @@ -1136,7 +1129,7 @@ fn makeStep(
 }
 fn printTreeStep(
-    maker: *const Maker,
+    maker: *Maker,
     step_index: Configuration.Step.Index,
     stderr: Io.Terminal,
     parent_node: *PrintNode,
 @@ -1211,7 +1204,7 @@ fn printTreeStep(
     }
 }
-fn printStepStatus(maker: *const Maker, step_index: Configuration.Step.Index, stderr: Io.Terminal) !void {
+fn printStepStatus(maker: *Maker, step_index: Configuration.Step.Index, stderr: Io.Terminal) !void {
     const s = maker.stepByIndex(step_index);
     const writer = stderr.writer;
     switch (s.state) {
 @@ -1293,20 +1286,20 @@ fn printStepStatus(maker: *const Maker, step_index: Configuration.Step.Index, st
             try stderr.setColor(.reset);
         },
         .failure => {
-            try printStepFailure(maker.steps, step_index, stderr, false);
+            try printStepFailure(maker, step_index, stderr, false);
             try stderr.setColor(.reset);
         },
     }
 }
 fn printStepFailure(
-    make_steps: []Step,
+    maker: *Maker,
     step_index: Configuration.Step.Index,
     stderr: Io.Terminal,
     dim: bool,
 ) !void {
     const w = stderr.writer;
-    const s = &make_steps[@intFromEnum(step_index)];
+    const s = maker.stepByIndex(step_index);
     if (s.result_error_bundle.errorMessageCount() > 0) {
         try stderr.setColor(.red);
         try w.print(" {d} errors\n", .{
 @@ -1428,14 +1421,14 @@ fn printChildNodePrefix(stderr: Io.Terminal) !void {
 ///   when it finishes executing in `makeStep`, it spawns next steps to run in
 ///   random order
 fn constructGraphAndCheckForDependencyLoop(
-    gpa: Allocator,
+    maker: *Maker,
-    c: *const Configuration,
-    steps: []Step,
     step_index: Configuration.Step.Index,
     step_stack: *std.AutoArrayHashMapUnmanaged(Configuration.Step.Index, void),
     rand: std.Random,
 ) error{ DependencyLoopDetected, OutOfMemory }!void {
-    const make_step: *Step = &steps[@intFromEnum(step_index)];
+    const c = &maker.scanned_config.configuration;
+    const gpa = maker.gpa;
+    const make_step = maker.stepByIndex(step_index);
     switch (make_step.state) {
         .precheck_started => {
             log.err("dependency loop detected: {s}", .{step_index.ptr(c).name.slice(c)});
 @@ -1456,10 +1449,10 @@ fn constructGraphAndCheckForDependencyLoop(
             rand.shuffle(Configuration.Step.Index, deps);
             for (deps) |dep| {
-                const dep_step: *Step = &steps[@intFromEnum(dep)];
+                const dep_step = maker.stepByIndex(dep);
                 try step_stack.put(gpa, dep, {});
                 try dep_step.dependants.append(gpa, step_index);
-                constructGraphAndCheckForDependencyLoop(gpa, c, steps, dep, step_stack, rand) catch |err| switch (err) {
+                constructGraphAndCheckForDependencyLoop(maker, dep, step_stack, rand) catch |err| switch (err) {
                     error.DependencyLoopDetected => {
                         log.info("needed by: {s}", .{step_index.ptr(c).name.slice(c)});
                         return err;
 @@ -1482,16 +1475,34 @@ fn constructGraphAndCheckForDependencyLoop(
     }
 }
+/// When file watching, prepares the step for being re-evaluated. Returns
+/// `true` if the step was newly invalidated, `false` if it was already
+/// invalidated.
+pub fn invalidateResult(maker: *Maker, step: *Step) bool {
+    if (step.state == .precheck_done) return false;
+    const gpa = maker.gpa;
+    assert(step.pending_deps == 0);
+    step.state = .precheck_done;
+    step.reset(gpa);
+    for (step.dependants.items) |dependant_index| {
+        const dependant = maker.stepByIndex(dependant_index);
+        _ = invalidateResult(maker, dependant);
+        dependant.pending_deps += 1;
+    }
+    return true;
+}
 pub fn printErrorMessages(
-    gpa: Allocator,
+    maker: *Maker,
-    c: *const Configuration,
-    make_steps: []Step,
     failing_step_index: Configuration.Step.Index,
     options: std.zig.ErrorBundle.RenderOptions,
     stderr: Io.Terminal,
     error_style: ErrorStyle,
     multiline_errors: MultilineErrors,
 ) !void {
+    const c = &maker.scanned_config.configuration;
+    const gpa = maker.gpa;
+    log.err("TODO also report if result_oom flag is set", .{});
     const writer = stderr.writer;
     if (error_style.verboseContext()) {
         // Provide context for where these error messages are coming from by
 @@ -1500,7 +1511,7 @@ pub fn printErrorMessages(
         defer step_stack.deinit(gpa);
         try step_stack.append(gpa, failing_step_index);
         while (true) {
-            const last_step = &make_steps[@intFromEnum(step_stack.items[step_stack.items.len - 1])];
+            const last_step = maker.stepByIndex(step_stack.items[step_stack.items.len - 1]);
             if (last_step.dependants.items.len == 0) break;
             try step_stack.append(gpa, last_step.dependants.items[0]);
         }
 @@ -1517,7 +1528,7 @@ pub fn printErrorMessages(
             try writer.writeAll(step_index.ptr(c).name.slice(c));
             if (step_index == failing_step_index) {
-                try printStepFailure(make_steps, step_index, stderr, true);
+                try printStepFailure(maker, step_index, stderr, true);
             } else {
                 try writer.writeAll("\n");
             }
 @@ -1527,11 +1538,11 @@ pub fn printErrorMessages(
         // Just print the failing step itself.
         try stderr.setColor(.dim);
         try writer.writeAll(failing_step_index.ptr(c).name.slice(c));
-        try printStepFailure(make_steps, failing_step_index, stderr, true);
+        try printStepFailure(maker, failing_step_index, stderr, true);
         try stderr.setColor(.reset);
     }
-    const failing_step = &make_steps[@intFromEnum(failing_step_index)];
+    const failing_step = maker.stepByIndex(failing_step_index);
     if (failing_step.result_stderr.len > 0) {
         try writer.writeAll(failing_step.result_stderr);

lib/compiler/Maker/Fuzz.zig+39-19

 @@ -15,8 +15,7 @@ const log = std.log;
 const Maker = @import("../Maker.zig");
 const WebServer = @import("WebServer.zig");
-gpa: Allocator,
+maker: *Maker,
-io: Io,
 mode: Mode,
 /// Allocated into `gpa`.
 @@ -76,12 +75,15 @@ const CoverageMap = struct {
 };
 pub fn init(
-    gpa: Allocator,
+    maker: *Maker,
-    io: Io,
     all_steps: []const Configuration.Step.Index,
     root_prog_node: std.Progress.Node,
     mode: Mode,
 ) error{ OutOfMemory, Canceled }!Fuzz {
+    const graph = maker.graph;
+    const gpa = graph.cache.gpa;
+    const io = graph.io;
     const run_steps: []const Configuration.Step.Index = steps: {
         var steps: std.ArrayList(Configuration.Step.Index) = .empty;
         defer steps.deinit(gpa);
 @@ -115,8 +117,7 @@ pub fn init(
     }
     return .{
-        .gpa = gpa,
+        .maker = maker,
-        .io = io,
         .mode = mode,
         .run_steps = run_steps,
         .group = .init,
 @@ -131,7 +132,10 @@ pub fn init(
 }
 pub fn start(fuzz: *Fuzz) void {
-    const io = fuzz.io;
+    const maker = fuzz.maker;
+    const graph = maker.graph;
+    const io = graph.io;
     fuzz.prog_node = fuzz.root_prog_node.start("Fuzzing", 0);
     if (fuzz.mode == .forever) {
 @@ -149,10 +153,14 @@ pub fn start(fuzz: *Fuzz) void {
 }
 pub fn deinit(fuzz: *Fuzz) void {
-    const io = fuzz.io;
+    const maker = fuzz.maker;
+    const graph = maker.graph;
+    const io = graph.io;
+    const gpa = maker.gpa;
     fuzz.group.cancel(io);
     fuzz.prog_node.end();
-    fuzz.gpa.free(fuzz.run_steps);
+    gpa.free(fuzz.run_steps);
 }
 fn rebuildTestsWorkerRun(run: Configuration.Step.Index, gpa: Allocator, parent_prog_node: std.Progress.Node) void {
 @@ -215,19 +223,20 @@ fn fuzzWorkerRun(fuzz: *Fuzz, run: Configuration.Step.Index) void {
 pub fn serveSourcesTar(fuzz: *Fuzz, req: *std.http.Server.Request) !void {
     if (true) @panic("TODO");
     assert(fuzz.mode == .forever);
+    const gpa = fuzz.maker.gpa;
-    var arena_state: std.heap.ArenaAllocator = .init(fuzz.gpa);
+    var arena_state: std.heap.ArenaAllocator = .init(gpa);
     defer arena_state.deinit();
     const arena = arena_state.allocator();
     const DedupTable = std.ArrayHashMapUnmanaged(Build.Cache.Path, void, Build.Cache.Path.TableAdapter, false);
     var dedup_table: DedupTable = .empty;
-    defer dedup_table.deinit(fuzz.gpa);
+    defer dedup_table.deinit(gpa);
     for (fuzz.run_steps) |run_step| {
         const compile_inputs = run_step.producer.?.step.inputs.table;
         for (compile_inputs.keys(), compile_inputs.values()) |dir_path, *file_list| {
-            try dedup_table.ensureUnusedCapacity(fuzz.gpa, file_list.items.len);
+            try dedup_table.ensureUnusedCapacity(gpa, file_list.items.len);
             for (file_list.items) |sub_path| {
                 if (!std.mem.endsWith(u8, sub_path, ".zig")) continue;
                 const joined_path = try dir_path.join(arena, sub_path);
 @@ -266,7 +275,9 @@ pub fn sendUpdate(
     socket: *std.http.Server.WebSocket,
     prev: *Previous,
 ) !void {
-    const io = fuzz.io;
+    const maker = fuzz.maker;
+    const graph = maker.graph;
+    const io = graph.io;
     try fuzz.coverage_mutex.lock(io);
     defer fuzz.coverage_mutex.unlock(io);
 @@ -337,7 +348,9 @@ fn coverageRun(fuzz: *Fuzz) void {
 }
 fn coverageRunCancelable(fuzz: *Fuzz) Io.Cancelable!void {
-    const io = fuzz.io;
+    const maker = fuzz.maker;
+    const graph = maker.graph;
+    const io = graph.io;
     try fuzz.queue_mutex.lock(io);
     defer fuzz.queue_mutex.unlock(io);
 @@ -363,8 +376,10 @@ fn prepareTables(fuzz: *Fuzz, run_step_index: Configuration.Step.Index, coverage
     if (true) @panic("TODO");
     assert(fuzz.mode == .forever);
     const ws = fuzz.mode.forever.ws;
-    const gpa = fuzz.gpa;
+    const maker = fuzz.maker;
-    const io = fuzz.io;
+    const graph = maker.graph;
+    const io = graph.io;
+    const gpa = maker.gpa;
     try fuzz.coverage_mutex.lock(io);
     defer fuzz.coverage_mutex.unlock(io);
 @@ -470,7 +485,10 @@ fn prepareTables(fuzz: *Fuzz, run_step_index: Configuration.Step.Index, coverage
 }
 fn addEntryPoint(fuzz: *Fuzz, coverage_id: u64, addr: u64) error{ AlreadyReported, OutOfMemory, Canceled }!void {
-    const io = fuzz.io;
+    const maker = fuzz.maker;
+    const graph = maker.graph;
+    const io = graph.io;
+    const gpa = maker.gpa;
     try fuzz.coverage_mutex.lock(io);
     defer fuzz.coverage_mutex.unlock(io);
 @@ -516,13 +534,15 @@ fn addEntryPoint(fuzz: *Fuzz, coverage_id: u64, addr: u64) error{ AlreadyReporte
             });
         }
     }
-    try coverage_map.entry_points.append(fuzz.gpa, @intCast(index));
+    try coverage_map.entry_points.append(gpa, @intCast(index));
 }
 pub fn waitAndPrintReport(fuzz: *Fuzz) Io.Cancelable!void {
     if (true) @panic("TODO");
     assert(fuzz.mode == .limit);
-    const io = fuzz.io;
+    const maker = fuzz.maker;
+    const graph = maker.graph;
+    const io = graph.io;
     try fuzz.group.await(io);
     fuzz.group = .init;

lib/compiler/Maker/Step.zig+124-49

 @@ -1,4 +1,5 @@
-//! The state that maker needs in order to process a step.
+//! The *mutable* state that `Maker` needs in order to process one node from
+//! the build graph.
 const Step = @This();
 const builtin = @import("builtin");
 @@ -14,14 +15,20 @@ const Configuration = std.Build.Configuration;
 const assert = std.debug.assert;
 const WebServer = @import("WebServer.zig");
+const Maker = @import("../Maker.zig");
-pub const Compile = void; // @import("Step/Compile.zig");
+const Compile = @import("Step/Compile.zig");
-pub const Run = void; // @import("Step/Run.zig");
+const Run = @import("Step/Run.zig");
 /// Avoid false sharing.
 _: void align(std.atomic.cache_line) = {},
+/// Extra data for specific types of steps.
+extended: Extended,
+/// This field is atomically accessed multi-threaded.
 state: State = .precheck_unstarted,
 dependants: std.ArrayList(Configuration.Step.Index) = .empty,
 /// Collects the set of files that retrigger this step to run.
 ///
 @@ -38,6 +45,8 @@ result_error_msgs: std.ArrayList([]const u8) = .empty,
 result_error_bundle: std.zig.ErrorBundle = .empty,
 result_stderr: []const u8 = "",
 result_cached: bool = false,
+/// Indicates error information is missing due to allocation failure.
+result_oom: bool = false,
 result_duration_ns: ?u64 = null,
 /// 0 means unavailable or not reported.
 result_peak_rss: usize = 0,
 @@ -46,6 +55,70 @@ result_peak_rss: usize = 0,
 result_failed_command: ?[]const u8 = null,
 test_results: TestResults = .{},
+comptime {
+    // Common cache line size is 128. This check prevents accidentally crossing
+    // an additional cache line. In the future it might be nice to try to fit
+    // this struct in 128 bytes or less.
+    assert(@sizeOf(@This()) <= 128 * 3);
+}
+pub const Extended = union(enum) {
+    check_file: Todo,
+    check_object: Todo,
+    compile: Compile,
+    config_header: Todo,
+    fail: Todo,
+    fmt: Todo,
+    install_artifact: Todo,
+    install_dir: Todo,
+    install_file: Todo,
+    objcopy: Todo,
+    options: Todo,
+    remove_dir: Todo,
+    run: Run,
+    top_level: Todo,
+    translate_c: Todo,
+    update_source_files: Todo,
+    write_file: Todo,
+    pub fn init(tag: Configuration.Step.Tag) Extended {
+        return switch (tag) {
+            .check_file => .{ .check_file = .{} },
+            .check_object => .{ .check_object = .{} },
+            .compile => .{ .compile = .{} },
+            .config_header => .{ .config_header = .{} },
+            .fail => .{ .fail = .{} },
+            .fmt => .{ .fmt = .{} },
+            .install_artifact => .{ .install_artifact = .{} },
+            .install_dir => .{ .install_dir = .{} },
+            .install_file => .{ .install_file = .{} },
+            .objcopy => .{ .objcopy = .{} },
+            .options => .{ .options = .{} },
+            .remove_dir => .{ .remove_dir = .{} },
+            .run => .{ .run = .{} },
+            .top_level => .{ .top_level = .{} },
+            .translate_c => .{ .translate_c = .{} },
+            .update_source_files => .{ .update_source_files = .{} },
+            .write_file => .{ .write_file = .{} },
+        };
+    }
+    pub const Todo = struct {
+        pub fn make(
+            todo: *Todo,
+            step_index: Configuration.Step.Index,
+            maker: *Maker,
+            progress_node: std.Progress.Node,
+        ) Step.ExtendedMakeError!void {
+            _ = todo;
+            _ = step_index;
+            _ = maker;
+            _ = progress_node;
+            @panic("TODO implement another step type");
+        }
+    };
+};
 pub const State = enum {
     precheck_unstarted,
     precheck_started,
 @@ -128,43 +201,51 @@ pub const TestResults = struct {
     }
 };
-pub const MakeOptions = struct {
+pub const MakeError = error{
-    progress_node: std.Progress.Node,
+    /// Indicates the error is already reported.
-    watch: bool,
+    MakeFailed,
-    web_server: ?*WebServer,
+    MakeSkipped,
-    /// If set, this is a timeout to enforce on all individual unit tests, in nanoseconds.
-    unit_test_timeout_ns: ?u64,
-    /// Not to be confused with `Build.allocator`, which is an alias of `Build.graph.arena`.
-    gpa: Allocator,
 };
-pub const MakeFn = *const fn (step: *Step, options: MakeOptions) anyerror!void;
+pub const ExtendedMakeError = MakeError || Allocator.Error;
-/// If the Step's `make` function reports `error.MakeFailed`, it indicates they
+pub fn make(
-/// have already reported the error. Otherwise, we add a simple error report
+    step_index: Configuration.Step.Index,
-/// here.
+    maker: *Maker,
-pub fn make(s: *Step, options: MakeOptions) error{ MakeFailed, MakeSkipped }!void {
+    progress_node: std.Progress.Node,
-    if (true) @panic("TODO Step.make");
+) MakeError!void {
-    const arena = s.owner.allocator;
+    const graph = maker.graph;
-    const graph = s.owner.graph;
+    const process_arena = graph.arena; // TODO don't leak into the process arena
     const io = graph.io;
+    const c = &maker.scanned_config.configuration;
+    const conf_step = step_index.ptr(c);
+    const s = maker.stepByIndex(step_index);
     var start_ts: ?Io.Timestamp = t: {
         if (!graph.time_report) break :t null;
-        if (s.id == .compile) break :t null;
+        const flags = conf_step.flags(c);
-        if (s.id == .run and s.cast(Run).?.stdio == .zig_test) break :t null;
+        switch (flags.tag) {
+            .compile => break :t null,
+            .run => {
+                const run_flags: Configuration.Step.Run.Flags = @bitCast(flags);
+                if (run_flags.stdio == .zig_test) break :t null;
+            },
+            else => {},
+        }
         break :t Io.Clock.awake.now(io);
     };
-    const make_result = s.makeFn(s, options);
+    const make_result = switch (s.extended) {
+        inline else => |*extended| extended.make(step_index, maker, progress_node),
+    };
     if (start_ts) |*ts| {
         const duration = ts.untilNow(io, .awake);
-        options.web_server.?.updateTimeReportGeneric(s, duration);
+        maker.web_server.?.updateTimeReportGeneric(step_index, duration);
     }
     make_result catch |err| switch (err) {
         error.MakeFailed, error.MakeSkipped => |e| return e,
-        else => {
+        error.OutOfMemory => {
-            s.result_error_msgs.append(arena, @errorName(err)) catch @panic("OOM");
+            s.result_oom = true;
             return error.MakeFailed;
         },
     };
 @@ -173,30 +254,19 @@ pub fn make(s: *Step, options: MakeOptions) error{ MakeFailed, MakeSkipped }!voi
         return error.MakeFailed;
     }
-    if (s.max_rss != 0 and s.result_peak_rss > s.max_rss) {
+    const max_rss = conf_step.max_rss.toBytes();
-        const msg = std.fmt.allocPrint(arena, "memory usage peaked at {0B:.2} ({0d} bytes), exceeding the declared upper bound of {1B:.2} ({1d} bytes)", .{
+    if (max_rss != 0 and s.result_peak_rss > max_rss) {
-            s.result_peak_rss, s.max_rss,
+        if (std.fmt.allocPrint(
-        }) catch @panic("OOM");
+            process_arena,
-        s.result_error_msgs.append(arena, msg) catch @panic("OOM");
+            "memory usage peaked at {0B:.2} ({0d} bytes), exceeding the declared upper bound of {1B:.2} ({1d} bytes)",
+            .{ s.result_peak_rss, max_rss },
+        )) |msg| {
+            s.oomWrap(s.result_error_msgs.append(process_arena, msg));
+        } else |_| s.result_oom = true;
     }
 }
-/// Implementation detail of file watching. Prepares the step for being re-evaluated.
+/// Prepares the step for being re-evaluated.
-/// Returns `true` if the step was newly invalidated, `false` if it was already invalidated.
-pub fn invalidateResult(step: *Step, gpa: Allocator) bool {
-    if (true) @panic("TODO Step.invalidateResult");
-    if (step.state == .precheck_done) return false;
-    assert(step.pending_deps == 0);
-    step.state = .precheck_done;
-    step.reset(gpa);
-    for (step.dependants.items) |dependant| {
-        _ = dependant.invalidateResult(gpa);
-        dependant.pending_deps += 1;
-    }
-    return true;
-}
-/// Implementation detail of file watching and forced rebuilds. Prepares the step for being re-evaluated.
 pub fn reset(step: *Step, gpa: Allocator) void {
     assert(step.state == .precheck_done);
 @@ -547,9 +617,8 @@ fn zigProcessUpdate(s: *Step, zp: *ZigProcess, watch: bool, web_server: ?*WebSer
 }
 pub fn getZigProcess(s: *Step) ?*ZigProcess {
-    if (true) @panic("TODO getZigProcess");
+    return switch (s.extended) {
-    return switch (s.id) {
+        .compile => |*compile| compile.zig_process,
-        .compile => s.cast(Compile).?.zig_process,
         else => null,
     };
 }
 @@ -838,3 +907,9 @@ pub fn allocPrintCmd(
     }
     return aw.toOwnedSlice();
 }
+fn oomWrap(s: *Step, result: error{OutOfMemory}!void) void {
+    result catch {
+        s.result_oom = true;
+    };
+}

lib/compiler/Maker/Step/Compile.zig+123-42

...	@@ -1,19 +1,40 @@	...	@@ -1,19 +1,40 @@
		1	const Compile = @This();
		2
		3	const std = @import("std");
		4	const Allocator = std.mem.Allocator;
		5	const Configuration = std.Build.Configuration;
		6	const Dir = std.Io.Dir;
		7	const Path = std.Build.Cache.Path;
		8	const Module = std.Build.Configuration.Module;
		9	const Io = std.Io;
		10	const Sha256 = std.crypto.hash.sha2.Sha256;
		11	const assert = std.debug.assert;
		12	const mem = std.mem;
		13
		14	const Step = @import("../Step.zig");
		15	const Maker = @import("../../Maker.zig");
		16
1	/// Populated during the make phase when there is a long-lived compiler process.	17	/// Populated during the make phase when there is a long-lived compiler process.
2	/// Managed by the build runner, not user build script.	18	/// Managed by the build runner, not user build script.
3	zig_process: ?*Step.ZigProcess,	19	zig_process: ?*Step.ZigProcess = null,
4		20
5	fn make(step: *Step, options: Step.MakeOptions) !void {	21	pub fn make(
6	const b = step.owner;	22	compile: *Compile,
7	const compile: *Compile = @fieldParentPtr("step", step);	23	step_index: Configuration.Step.Index,
8		24	maker: *Maker,
9	const zig_args = try getZigArgs(compile, false);	25	progress_node: std.Progress.Node,
		26	) Step.ExtendedMakeError!void {
		27	if (true) @panic("TODO implement compile.make()");
		28	const graph = maker.graph;
		29	const step = maker.stepByIndex(step_index);
		30	const zig_args = try getZigArgs(compile, maker, false);
		31	const process_arena = graph.arena; // TODO don't leak into the process_arena
10		32
11	const maybe_output_dir = step.evalZigProcess(	33	const maybe_output_dir = step.evalZigProcess(
12	zig_args,	34	zig_args,
13	options.progress_node,	35	progress_node,
14	(b.graph.incremental == true) and (options.watch or options.web_server != null),	36	(graph.incremental == true) and (maker.watch or maker.web_server != null),
15	options.web_server,	37	maker,
16	options.gpa,
17	) catch \|err\| switch (err) {	38	) catch \|err\| switch (err) {
18	error.NeedCompileErrorCheck => {	39	error.NeedCompileErrorCheck => {
19	assert(compile.expect_errors != null);	40	assert(compile.expect_errors != null);
...	@@ -26,7 +47,7 @@ fn make(step: *Step, options: Step.MakeOptions) !void {	...	@@ -26,7 +47,7 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
26	// Update generated files	47	// Update generated files
27	if (maybe_output_dir) \|output_dir\| {	48	if (maybe_output_dir) \|output_dir\| {
28	if (compile.emit_directory) \|lp\| {	49	if (compile.emit_directory) \|lp\| {
29	lp.path = b.fmt("{f}", .{output_dir});	50	lp.path = try std.fmt.allocPrint(process_arena, "{f}", .{output_dir});
30	}	51	}
31		52
32	// zig fmt: off	53	// zig fmt: off
...	@@ -49,22 +70,23 @@ fn make(step: *Step, options: Step.MakeOptions) !void {	...	@@ -49,22 +70,23 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
49	{	70	{
50	try doAtomicSymLinks(	71	try doAtomicSymLinks(
51	step,	72	step,
52	compile.getEmittedBin().getPath2(b, step),	73	compile.getEmittedBin().getPath2(step.owner, step),
53	compile.major_only_filename.?,	74	compile.major_only_filename.?,
54	compile.name_only_filename.?,	75	compile.name_only_filename.?,
55	);	76	);
56	}	77	}
57	}	78	}
58		79
59	fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {	80	fn getZigArgs(compile: Compile, maker: Maker, fuzz: bool) ![][]const u8 {
60	const step = &compile.step;	81	const step = &compile.step;
61	const b = step.owner;	82	const b = step.owner;
62	const arena = b.allocator;	83	const graph = maker.graph;
		84	const arena = graph.arena; // TODO don't leak into the process arena
63		85
64	var zig_args = std.array_list.Managed([]const u8).init(arena);	86	var zig_args = std.array_list.Managed([]const u8).init(arena);
65	defer zig_args.deinit();	87	defer zig_args.deinit();
66		88
67	try zig_args.append(b.graph.zig_exe);	89	try zig_args.append(graph.zig_exe);
68		90
69	const cmd = switch (compile.kind) {	91	const cmd = switch (compile.kind) {
70	.lib => "build-lib",	92	.lib => "build-lib",
...	@@ -78,7 +100,7 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {	...	@@ -78,7 +100,7 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {
78	if (b.reference_trace) \|some\| {	100	if (b.reference_trace) \|some\| {
79	try zig_args.append(try std.fmt.allocPrint(arena, "-freference-trace={d}", .{some}));	101	try zig_args.append(try std.fmt.allocPrint(arena, "-freference-trace={d}", .{some}));
80	}	102	}
81	try addFlag(&zig_args, "allow-so-scripts", compile.allow_so_scripts orelse b.graph.allow_so_scripts);	103	try addFlag(&zig_args, "allow-so-scripts", compile.allow_so_scripts orelse graph.allow_so_scripts);
82		104
83	try addFlag(&zig_args, "llvm", compile.use_llvm);	105	try addFlag(&zig_args, "llvm", compile.use_llvm);
84	try addFlag(&zig_args, "lld", compile.use_lld);	106	try addFlag(&zig_args, "lld", compile.use_lld);
...	@@ -118,7 +140,7 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {	...	@@ -118,7 +140,7 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {
118	// module, along with any arguments that need to be passed to the	140	// module, along with any arguments that need to be passed to the
119	// compiler for each module individually.	141	// compiler for each module individually.
120	var seen_system_libs: std.StringHashMapUnmanaged([]const []const u8) = .empty;	142	var seen_system_libs: std.StringHashMapUnmanaged([]const []const u8) = .empty;
121	var frameworks: std.StringArrayHashMapUnmanaged(Module.LinkFrameworkOptions) = .empty;	143	var frameworks: std.StringArrayHashMapUnmanaged(Module.FrameworkFlags) = .empty;
122		144
123	var prev_has_cflags = false;	145	var prev_has_cflags = false;
124	var prev_has_rcflags = false;	146	var prev_has_rcflags = false;
...	@@ -130,7 +152,7 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {	...	@@ -130,7 +152,7 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {
130		152
131	// Fully recursive iteration including dynamic libraries to detect	153	// Fully recursive iteration including dynamic libraries to detect
132	// libc and libc++ linkage.	154	// libc and libc++ linkage.
133	for (compile.getCompileDependencies(true)) \|some_compile\| {	155	for (getCompileDependencies(true)) \|some_compile\| {
134	for (some_compile.root_module.getGraph().modules) \|mod\| {	156	for (some_compile.root_module.getGraph().modules) \|mod\| {
135	if (mod.link_libc == true) compile.is_linking_libc = true;	157	if (mod.link_libc == true) compile.is_linking_libc = true;
136	if (mod.link_libcpp == true) compile.is_linking_libcpp = true;	158	if (mod.link_libcpp == true) compile.is_linking_libcpp = true;
...	@@ -141,7 +163,7 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {	...	@@ -141,7 +163,7 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {
141		163
142	// For this loop, don't chase dynamic libraries because their link	164	// For this loop, don't chase dynamic libraries because their link
143	// objects are already linked.	165	// objects are already linked.
144	for (compile.getCompileDependencies(false)) \|dep_compile\| {	166	for (getCompileDependencies(false)) \|dep_compile\| {
145	for (dep_compile.root_module.getGraph().modules) \|mod\| {	167	for (dep_compile.root_module.getGraph().modules) \|mod\| {
146	// While walking transitive dependencies, if a given link object is	168	// While walking transitive dependencies, if a given link object is
147	// already included in a library, it should not redundantly be	169	// already included in a library, it should not redundantly be
...	@@ -207,7 +229,7 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {	...	@@ -207,7 +229,7 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {
207	switch (system_lib.use_pkg_config) {	229	switch (system_lib.use_pkg_config) {
208	.no => try zig_args.append(b.fmt("{s}{s}", .{ prefix, system_lib.name })),	230	.no => try zig_args.append(b.fmt("{s}{s}", .{ prefix, system_lib.name })),
209	.yes, .force => {	231	.yes, .force => {
210	if (compile.runPkgConfig(system_lib.name)) \|result\| {	232	if (compile.runPkgConfig(maker, system_lib.name)) \|result\| {
211	try zig_args.appendSlice(result.cflags);	233	try zig_args.appendSlice(result.cflags);
212	try zig_args.appendSlice(result.libs);	234	try zig_args.appendSlice(result.libs);
213	try seen_system_libs.put(arena, system_lib.name, result.cflags);	235	try seen_system_libs.put(arena, system_lib.name, result.cflags);
...	@@ -227,7 +249,7 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {	...	@@ -227,7 +249,7 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {
227	}));	249	}));
228	},	250	},
229	.force => {	251	.force => {
230	panic("pkg-config failed for library {s}", .{system_lib.name});	252	return step.fail("pkg-config failed for library {s}", .{system_lib.name});
231	},	253	},
232	.no => unreachable,	254	.no => unreachable,
233	},	255	},
...	@@ -272,7 +294,7 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {	...	@@ -272,7 +294,7 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {
272	if (other.linkage == .dynamic and	294	if (other.linkage == .dynamic and
273	compile.rootModuleTarget().os.tag != .windows)	295	compile.rootModuleTarget().os.tag != .windows)
274	{	296	{
275	if (fs.path.dirname(full_path_lib)) \|dirname\| {	297	if (Dir.path.dirname(full_path_lib)) \|dirname\| {
276	try zig_args.append("-rpath");	298	try zig_args.append("-rpath");
277	try zig_args.append(dirname);	299	try zig_args.append(dirname);
278	}	300	}
...	@@ -479,7 +501,7 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {	...	@@ -479,7 +501,7 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {
479	if (b.verbose_link or compile.verbose_link) try zig_args.append("--verbose-link");	501	if (b.verbose_link or compile.verbose_link) try zig_args.append("--verbose-link");
480	if (b.verbose_cc or compile.verbose_cc) try zig_args.append("--verbose-cc");	502	if (b.verbose_cc or compile.verbose_cc) try zig_args.append("--verbose-cc");
481	if (b.verbose_llvm_cpu_features) try zig_args.append("--verbose-llvm-cpu-features");	503	if (b.verbose_llvm_cpu_features) try zig_args.append("--verbose-llvm-cpu-features");
482	if (b.graph.time_report) try zig_args.append("--time-report");	504	if (graph.time_report) try zig_args.append("--time-report");
483		505
484	if (compile.generated_asm != null) try zig_args.append("-femit-asm");	506	if (compile.generated_asm != null) try zig_args.append("-femit-asm");
485	if (compile.generated_bin == null) try zig_args.append("-fno-emit-bin");	507	if (compile.generated_bin == null) try zig_args.append("-fno-emit-bin");
...	@@ -555,9 +577,9 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {	...	@@ -555,9 +577,9 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {
555	try zig_args.append(b.cache_root.path orelse ".");	577	try zig_args.append(b.cache_root.path orelse ".");
556		578
557	try zig_args.append("--global-cache-dir");	579	try zig_args.append("--global-cache-dir");
558	try zig_args.append(b.graph.global_cache_root.path orelse ".");	580	try zig_args.append(graph.global_cache_root.path orelse ".");
559		581
560	if (b.graph.debug_compiler_runtime_libs) \|mode\|	582	if (graph.debug_compiler_runtime_libs) \|mode\|
561	try zig_args.append(b.fmt("--debug-rt={t}", .{mode}));	583	try zig_args.append(b.fmt("--debug-rt={t}", .{mode}));
562		584
563	try zig_args.append("--name");	585	try zig_args.append("--name");
...	@@ -681,7 +703,7 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {	...	@@ -681,7 +703,7 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {
681		703
682	// -I and -L arguments that appear after the last --mod argument apply to all modules.	704	// -I and -L arguments that appear after the last --mod argument apply to all modules.
683	const cwd: Io.Dir = .cwd();	705	const cwd: Io.Dir = .cwd();
684	const io = b.graph.io;	706	const io = graph.io;
685		707
686	for (b.search_prefixes.items) \|search_prefix\| {	708	for (b.search_prefixes.items) \|search_prefix\| {
687	var prefix_dir = cwd.openDir(io, search_prefix, .{}) catch \|err\| {	709	var prefix_dir = cwd.openDir(io, search_prefix, .{}) catch \|err\| {
...	@@ -734,8 +756,8 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {	...	@@ -734,8 +756,8 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {
734		756
735	const opt_zig_lib_dir = if (compile.zig_lib_dir) \|dir\|	757	const opt_zig_lib_dir = if (compile.zig_lib_dir) \|dir\|
736	dir.getPath2(b, step)	758	dir.getPath2(b, step)
737	else if (b.graph.zig_lib_directory.path) \|_\|	759	else if (graph.zig_lib_directory.path) \|_\|
738	b.fmt("{f}", .{b.graph.zig_lib_directory})	760	b.fmt("{f}", .{graph.zig_lib_directory})
739	else	761	else
740	null;	762	null;
741		763
...	@@ -769,7 +791,7 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {	...	@@ -769,7 +791,7 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {
769	"--error-limit", b.fmt("{d}", .{err_limit}),	791	"--error-limit", b.fmt("{d}", .{err_limit}),
770	});	792	});
771		793
772	try addFlag(&zig_args, "incremental", b.graph.incremental);	794	try addFlag(&zig_args, "incremental", graph.incremental);
773		795
774	try zig_args.append("--listen=-");	796	try zig_args.append("--listen=-");
775		797
...	@@ -814,7 +836,7 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {	...	@@ -814,7 +836,7 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {
814	var args_hex_hash: [Sha256.digest_length * 2]u8 = undefined;	836	var args_hex_hash: [Sha256.digest_length * 2]u8 = undefined;
815	_ = try std.fmt.bufPrint(&args_hex_hash, "{x}", .{&args_hash});	837	_ = try std.fmt.bufPrint(&args_hex_hash, "{x}", .{&args_hash});
816		838
817	const args_file = "args" ++ fs.path.sep_str ++ args_hex_hash;	839	const args_file = "args" ++ Dir.path.sep_str ++ args_hex_hash;
818	if (b.cache_root.handle.access(io, args_file, .{})) \|_\| {	840	if (b.cache_root.handle.access(io, args_file, .{})) \|_\| {
819	// The args file is already present from a previous run.	841	// The args file is already present from a previous run.
820	} else \|err\| switch (err) {	842	} else \|err\| switch (err) {
...	@@ -859,7 +881,9 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {	...	@@ -859,7 +881,9 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {
859	return try zig_args.toOwnedSlice();	881	return try zig_args.toOwnedSlice();
860	}	882	}
861		883
862	pub fn rebuildInFuzzMode(c: *Compile, gpa: Allocator, progress_node: std.Progress.Node) !Path {	884	pub fn rebuildInFuzzMode(c: Compile, maker: Maker, progress_node: std.Progress.Node) !Path {
		885	const gpa = maker.graph.gpa;
		886
863	c.step.result_error_msgs.clearRetainingCapacity();	887	c.step.result_error_msgs.clearRetainingCapacity();
864	c.step.result_stderr = "";	888	c.step.result_stderr = "";
865		889
...	@@ -871,21 +895,23 @@ pub fn rebuildInFuzzMode(c: *Compile, gpa: Allocator, progress_node: std.Progres	...	@@ -871,21 +895,23 @@ pub fn rebuildInFuzzMode(c: *Compile, gpa: Allocator, progress_node: std.Progres
871	c.step.result_failed_command = null;	895	c.step.result_failed_command = null;
872	}	896	}
873		897
874	const zig_args = try getZigArgs(c, true);	898	const zig_args = try getZigArgs(c, maker, true);
875	const maybe_output_bin_path = try c.step.evalZigProcess(zig_args, progress_node, false, null, gpa);	899	const maybe_output_bin_path = try c.step.evalZigProcess(zig_args, progress_node, false, null, gpa);
876	return maybe_output_bin_path.?;	900	return maybe_output_bin_path.?;
877	}	901	}
878		902
879	pub fn doAtomicSymLinks(	903	pub fn doAtomicSymLinks(
880	step: *Step,	904	step: *Step,
		905	maker: *Maker,
881	output_path: []const u8,	906	output_path: []const u8,
882	filename_major_only: []const u8,	907	filename_major_only: []const u8,
883	filename_name_only: []const u8,	908	filename_name_only: []const u8,
884	) !void {	909	) !void {
885	const b = step.owner;	910	const b = step.owner;
886	const io = b.graph.io;	911	const graph = maker.graph;
887	const out_dir = fs.path.dirname(output_path) orelse ".";	912	const io = graph.io;
888	const out_basename = fs.path.basename(output_path);	913	const out_dir = Dir.path.dirname(output_path) orelse ".";
		914	const out_basename = Dir.path.basename(output_path);
889	// sym link for libfoo.so.1 to libfoo.so.1.2.3	915	// sym link for libfoo.so.1 to libfoo.so.1.2.3
890	const major_only_path = b.pathJoin(&.{ out_dir, filename_major_only });	916	const major_only_path = b.pathJoin(&.{ out_dir, filename_major_only });
891	const cwd: Io.Dir = .cwd();	917	const cwd: Io.Dir = .cwd();
...	@@ -903,10 +929,24 @@ pub fn doAtomicSymLinks(	...	@@ -903,10 +929,24 @@ pub fn doAtomicSymLinks(
903	};	929	};
904	}	930	}
905		931
906	fn execPkgConfigList(b: std.Build, out_code: u8) (PkgConfigError \|\| RunError)![]const PkgConfigPkg {	932	pub const PkgConfigError = error{
907	const pkg_config_exe = b.graph.environ_map.get("PKG_CONFIG") orelse "pkg-config";	933	PkgConfigCrashed,
908	const stdout = try b.runAllowFail(&[_][]const u8{ pkg_config_exe, "--list-all" }, out_code, .ignore);	934	PkgConfigFailed,
909	var list = std.array_list.Managed(PkgConfigPkg).init(b.allocator);	935	PkgConfigNotInstalled,
		936	PkgConfigInvalidOutput,
		937	};
		938
		939	pub const PkgConfigPkg = struct {
		940	name: []const u8,
		941	desc: []const u8,
		942	};
		943
		944	fn execPkgConfigList(maker: Maker, out_code: u8) (PkgConfigError \|\| Maker.RunError)![]const PkgConfigPkg {
		945	const graph = maker.graph;
		946	const process_arena = graph.arena; // TODO don't leak into process arena
		947	const pkg_config_exe = graph.environ_map.get("PKG_CONFIG") orelse "pkg-config";
		948	const stdout = try maker.runAllowFail(&[_][]const u8{ pkg_config_exe, "--list-all" }, out_code, .ignore);
		949	var list = std.array_list.Managed(PkgConfigPkg).init(process_arena);
910	errdefer list.deinit();	950	errdefer list.deinit();
911	var line_it = mem.tokenizeAny(u8, stdout, "\r\n");	951	var line_it = mem.tokenizeAny(u8, stdout, "\r\n");
912	while (line_it.next()) \|line\| {	952	while (line_it.next()) \|line\| {
...	@@ -960,7 +1000,8 @@ const PkgConfigResult = struct {	...	@@ -960,7 +1000,8 @@ const PkgConfigResult = struct {
960		1000
961	/// Run pkg-config for the given library name and parse the output, returning the arguments	1001	/// Run pkg-config for the given library name and parse the output, returning the arguments
962	/// that should be passed to zig to link the given library.	1002	/// that should be passed to zig to link the given library.
963	fn runPkgConfig(compile: *Compile, lib_name: []const u8) !PkgConfigResult {	1003	fn runPkgConfig(compile: Compile, maker: Maker, lib_name: []const u8) !PkgConfigResult {
		1004	const graph = maker.graph;
964	const wl_rpath_prefix = "-Wl,-rpath,";	1005	const wl_rpath_prefix = "-Wl,-rpath,";
965		1006
966	const b = compile.step.owner;	1007	const b = compile.step.owner;
...	@@ -1013,7 +1054,7 @@ fn runPkgConfig(compile: *Compile, lib_name: []const u8) !PkgConfigResult {	...	@@ -1013,7 +1054,7 @@ fn runPkgConfig(compile: *Compile, lib_name: []const u8) !PkgConfigResult {
1013	};	1054	};
1014		1055
1015	var code: u8 = undefined;	1056	var code: u8 = undefined;
1016	const pkg_config_exe = b.graph.environ_map.get("PKG_CONFIG") orelse "pkg-config";	1057	const pkg_config_exe = graph.environ_map.get("PKG_CONFIG") orelse "pkg-config";
1017	const stdout = if (b.runAllowFail(&[_][]const u8{	1058	const stdout = if (b.runAllowFail(&[_][]const u8{
1018	pkg_config_exe,	1059	pkg_config_exe,
1019	pkg_name,	1060	pkg_name,
...	@@ -1198,3 +1239,43 @@ fn moduleNeedsCliArg(mod: *const Module) bool {	...	@@ -1198,3 +1239,43 @@ fn moduleNeedsCliArg(mod: *const Module) bool {
1198	} else false;	1239	} else false;
1199	}	1240	}
1200		1241
		1242	const CliNamedModules = struct {
		1243	modules: std.AutoArrayHashMapUnmanaged(*Module, void),
		1244	names: std.StringArrayHashMapUnmanaged(void),
		1245
		1246	/// Traverse the whole dependency graph and give every module a unique
		1247	/// name, ideally one named after what it's called somewhere in the graph.
		1248	/// It will help here to have both a mapping from module to name and a set
		1249	/// of all the currently-used names.
		1250	fn init(arena: Allocator, root_module: *Module) Allocator.Error!CliNamedModules {
		1251	var compile: CliNamedModules = .{
		1252	.modules = .{},
		1253	.names = .{},
		1254	};
		1255	const graph = root_module.getGraph();
		1256	{
		1257	assert(graph.modules[0] == root_module);
		1258	try compile.modules.put(arena, root_module, {});
		1259	try compile.names.put(arena, "root", {});
		1260	}
		1261	for (graph.modules[1..], graph.names[1..]) \|mod, orig_name\| {
		1262	var name = orig_name;
		1263	var n: usize = 0;
		1264	while (true) {
		1265	const gop = try compile.names.getOrPut(arena, name);
		1266	if (!gop.found_existing) {
		1267	try compile.modules.putNoClobber(arena, mod, {});
		1268	break;
		1269	}
		1270	name = try std.fmt.allocPrint(arena, "{s}{d}", .{ orig_name, n });
		1271	n += 1;
		1272	}
		1273	}
		1274	return compile;
		1275	}
		1276	};
		1277
		1278	fn getCompileDependencies(chase_dynamic: bool) void {
		1279	_ = chase_dynamic;
		1280	@panic("TODO");
		1281	}

lib/compiler/Maker/Step/Run.zig+126-117

 @@ -3,38 +3,46 @@ const Run = @This();
 const builtin = @import("builtin");
 const std = @import("std");
-const Io = std.Io;
+const Cache = std.Build.Cache;
+const Configuration = std.Build.Configuration;
 const Dir = std.Io.Dir;
-const mem = std.mem;
-const process = std.process;
 const EnvMap = std.process.Environ.Map;
-const assert = std.debug.assert;
+const Io = std.Io;
-const Cache = std.Build.Cache;
 const Path = std.Build.Cache.Path;
+const assert = std.debug.assert;
+const mem = std.mem;
+const process = std.process;
 const Step = @import("../Step.zig");
+const Maker = @import("../../Maker.zig");
 /// If this is a Zig unit test binary, this tracks the names of the unit
 /// tests that are also fuzz tests. Indexes cannot be used as they may
 /// change between reruns.
-fuzz_tests: std.ArrayList([]const u8),
+fuzz_tests: std.ArrayList([]const u8) = .empty,
 cached_test_metadata: ?CachedTestMetadata = null,
 /// Populated during the fuzz phase if this run step corresponds to a unit test
 /// executable that contains fuzz tests.
-rebuilt_executable: ?Path,
+rebuilt_executable: ?Path = null,
-fn make(step: *Step, options: Step.MakeOptions) !void {
+pub fn make(
-    const b = step.owner;
+    run: *Run,
-    const io = b.graph.io;
+    step_index: Configuration.Step.Index,
-    const arena = b.allocator;
+    maker: *Maker,
-    const run: *Run = @fieldParentPtr("step", step);
+    progress_node: std.Progress.Node,
+) Step.ExtendedMakeError!void {
+    if (true) @panic("TODO implement run.make()");
+    const graph = maker.graph;
+    const step = maker.stepByIndex(step_index);
+    const io = graph.io;
+    const arena = graph.arena; // TODO don't leak into the process arena
     const has_side_effects = run.hasSideEffects();
     var argv_list = std.array_list.Managed([]const u8).init(arena);
     var output_placeholders = std.array_list.Managed(IndexedOutput).init(arena);
-    var man = b.graph.cache.obtain();
+    var man = graph.cache.obtain();
     defer man.deinit();
     if (run.environ_map) |environ_map| {
 @@ -54,19 +62,19 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
                 man.hash.addBytes(bytes);
             },
             .lazy_path => |file| {
-                const file_path = file.lazy_path.getPath3(b, step);
+                const file_path = file.lazy_path.getPath3(graph, step);
-                try argv_list.append(b.fmt("{s}{s}", .{ file.prefix, run.convertPathArg(file_path) }));
+                try argv_list.append(graph.fmt("{s}{s}", .{ file.prefix, run.convertPathArg(maker, file_path) }));
                 man.hash.addBytes(file.prefix);
                 _ = try man.addFilePath(file_path, null);
             },
             .decorated_directory => |dd| {
-                const file_path = dd.lazy_path.getPath3(b, step);
+                const file_path = dd.lazy_path.getPath3(graph, step);
-                const resolved_arg = b.fmt("{s}{s}{s}", .{ dd.prefix, run.convertPathArg(file_path), dd.suffix });
+                const resolved_arg = graph.fmt("{s}{s}{s}", .{ dd.prefix, run.convertPathArg(maker, file_path), dd.suffix });
                 try argv_list.append(resolved_arg);
                 man.hash.addBytes(resolved_arg);
             },
             .file_content => |file_plp| {
-                const file_path = file_plp.lazy_path.getPath3(b, step);
+                const file_path = file_plp.lazy_path.getPath3(graph, step);
                 var result: std.Io.Writer.Allocating = .init(arena);
                 errdefer result.deinit();
 @@ -99,13 +107,13 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
                 if (artifact.rootModuleTarget().os.tag == .windows) {
                     // On Windows we don't have rpaths so we have to add .dll search paths to PATH
-                    run.addPathForDynLibs(artifact);
+                    addPathForDynLibs(artifact);
                 }
                 const file_path = artifact.installed_path orelse artifact.generated_bin.?.path.?;
-                try argv_list.append(b.fmt("{s}{s}", .{
+                try argv_list.append(graph.fmt("{s}{s}", .{
                     pa.prefix,
-                    run.convertPathArg(.{ .root_dir = .cwd(), .sub_path = file_path }),
+                    run.convertPathArg(maker, .{ .root_dir = .cwd(), .sub_path = file_path }),
                 }));
                 _ = try man.addFile(file_path, null);
 @@ -131,7 +139,7 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
             man.hash.addBytes(bytes);
         },
         .lazy_path => |lazy_path| {
-            const file_path = lazy_path.getPath2(b, step);
+            const file_path = lazy_path.getPath2(graph, step);
             _ = try man.addFile(file_path, null);
         },
         .none => {},
 @@ -147,14 +155,15 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
         man.hash.add(captured.trim_whitespace);
     }
-    hashStdIo(&man.hash, run.stdio);
+    std.log.err("TODO hashStdIo", .{});
+    //hashStdIo(&man.hash, run.stdio);
     for (run.file_inputs.items) |lazy_path| {
-        _ = try man.addFile(lazy_path.getPath2(b, step), null);
+        _ = try man.addFile(lazy_path.getPath2(graph, step), null);
     }
     if (run.cwd) |cwd| {
-        const cwd_path = cwd.getPath3(b, step);
+        const cwd_path = cwd.getPath3(graph, step);
         _ = man.hash.addBytes(try cwd_path.toString(arena));
     }
 @@ -165,9 +174,7 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
         try populateGeneratedPaths(
             arena,
             output_placeholders.items,
-            run.captured_stdout,
+            graph.cache_root,
-            run.captured_stderr,
-            b.cache_root,
             &digest,
         );
 @@ -185,36 +192,34 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
         try populateGeneratedPaths(
             arena,
             output_placeholders.items,
-            run.captured_stdout,
+            graph.cache_root,
-            run.captured_stderr,
-            b.cache_root,
             &digest,
         );
         const output_dir_path = "o" ++ Dir.path.sep_str ++ &digest;
         for (output_placeholders.items) |placeholder| {
-            const output_sub_path = b.pathJoin(&.{ output_dir_path, placeholder.output.basename });
+            const output_sub_path = graph.pathJoin(&.{ output_dir_path, placeholder.output.basename });
             const output_sub_dir_path = switch (placeholder.tag) {
                 .output_file => Dir.path.dirname(output_sub_path).?,
                 .output_directory => output_sub_path,
                 else => unreachable,
             };
-            b.cache_root.handle.createDirPath(io, output_sub_dir_path) catch |err| {
+            graph.cache_root.handle.createDirPath(io, output_sub_dir_path) catch |err| {
-                return step.fail("unable to make path '{f}{s}': {s}", .{
+                return step.fail("unable to make path '{f}{s}': {t}", .{
-                    b.cache_root, output_sub_dir_path, @errorName(err),
+                    graph.cache_root, output_sub_dir_path, err,
                 });
             };
-            const arg_output_path = run.convertPathArg(.{
+            const arg_output_path = run.convertPathArg(maker, .{
                 .root_dir = .cwd(),
                 .sub_path = placeholder.output.generated_file.getPath(),
             });
             argv_list.items[placeholder.index] = if (placeholder.output.prefix.len == 0)
                 arg_output_path
             else
-                b.fmt("{s}{s}", .{ placeholder.output.prefix, arg_output_path });
+                graph.fmt("{s}{s}", .{ placeholder.output.prefix, arg_output_path });
         }
-        try runCommand(run, argv_list.items, has_side_effects, output_dir_path, options, null);
+        try runCommand(run, maker, progress_node, argv_list.items, has_side_effects, output_dir_path, null);
         if (!has_side_effects) try step.writeManifestAndWatch(&man);
         return;
     };
 @@ -226,32 +231,32 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
     for (output_placeholders.items) |placeholder| {
         const output_components = .{ tmp_dir_path, placeholder.output.basename };
-        const output_sub_path = b.pathJoin(&output_components);
+        const output_sub_path = graph.pathJoin(&output_components);
         const output_sub_dir_path = switch (placeholder.tag) {
             .output_file => Dir.path.dirname(output_sub_path).?,
             .output_directory => output_sub_path,
             else => unreachable,
         };
-        b.cache_root.handle.createDirPath(io, output_sub_dir_path) catch |err| {
+        graph.cache_root.handle.createDirPath(io, output_sub_dir_path) catch |err| {
-            return step.fail("unable to make path '{f}{s}': {s}", .{
+            return step.fail("unable to make path '{f}{s}': {t}", .{
-                b.cache_root, output_sub_dir_path, @errorName(err),
+                graph.cache_root, output_sub_dir_path, err,
             });
         };
-        const raw_output_path: Cache.Path = .{
+        const raw_output_path: Path = .{
-            .root_dir = b.cache_root,
+            .root_dir = graph.cache_root,
-            .sub_path = b.pathJoin(&output_components),
+            .sub_path = graph.pathJoin(&output_components),
         };
-        placeholder.output.generated_file.path = raw_output_path.toString(b.graph.arena) catch @panic("OOM");
+        placeholder.output.generated_file.path = raw_output_path.toString(arena) catch @panic("OOM");
-        argv_list.items[placeholder.index] = b.fmt("{s}{s}", .{
+        argv_list.items[placeholder.index] = graph.fmt("{s}{s}", .{
             placeholder.output.prefix,
-            run.convertPathArg(raw_output_path),
+            run.convertPathArg(maker, raw_output_path),
         });
     }
-    try runCommand(run, argv_list.items, has_side_effects, tmp_dir_path, options, null);
+    try runCommand(run, maker, progress_node, argv_list.items, has_side_effects, tmp_dir_path, null);
     const dep_file_dir = Dir.cwd();
-    const dep_file_basename = dep_output_file.generated_file.getPath2(b, step);
+    const dep_file_basename = dep_output_file.generated_file.getPath2(graph, step);
     if (has_side_effects)
         try man.addDepFile(dep_file_dir, dep_file_basename)
     else
 @@ -269,21 +274,21 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
     if (any_output) {
         const o_sub_path = "o" ++ Dir.path.sep_str ++ &digest;
-        b.cache_root.handle.rename(tmp_dir_path, b.cache_root.handle, o_sub_path, io) catch |err| switch (err) {
+        graph.cache_root.handle.rename(tmp_dir_path, graph.cache_root.handle, o_sub_path, io) catch |err| switch (err) {
             Dir.RenameError.DirNotEmpty => {
-                b.cache_root.handle.deleteTree(io, o_sub_path) catch |del_err| {
+                graph.cache_root.handle.deleteTree(io, o_sub_path) catch |del_err| {
                     return step.fail("unable to remove dir '{f}'{s}: {t}", .{
-                        b.cache_root, tmp_dir_path, del_err,
+                        graph.cache_root, tmp_dir_path, del_err,
                     });
                 };
-                b.cache_root.handle.rename(tmp_dir_path, b.cache_root.handle, o_sub_path, io) catch |retry_err| {
+                graph.cache_root.handle.rename(tmp_dir_path, graph.cache_root.handle, o_sub_path, io) catch |retry_err| {
                     return step.fail("unable to rename dir '{f}{s}' to '{f}{s}': {t}", .{
-                        b.cache_root, tmp_dir_path, b.cache_root, o_sub_path, retry_err,
+                        graph.cache_root, tmp_dir_path, graph.cache_root, o_sub_path, retry_err,
                     });
                 };
             },
             else => return step.fail("unable to rename dir '{f}{s}' to '{f}{s}': {t}", .{
-                b.cache_root, tmp_dir_path, b.cache_root, o_sub_path, err,
+                graph.cache_root, tmp_dir_path, graph.cache_root, o_sub_path, err,
             }),
         };
     }
 @@ -293,9 +298,7 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
     try populateGeneratedPaths(
         arena,
         output_placeholders.items,
-        run.captured_stdout,
+        graph.cache_root,
-        run.captured_stderr,
-        b.cache_root,
         &digest,
     );
 }
 @@ -347,7 +350,6 @@ fn waitZigTest(
     // start and it acknowledging the test starting, we terminate the child and raise an error. This
     // *should* never happen, but could in theory be caused by some very unlucky IB in a test.
     const response_timeout: Io.Clock.Duration = t: {
-        if (fuzz_context != null) break :t null; // don't timeout fuzz tests
         const ns = @max(options.unit_test_timeout_ns orelse 0, 60 * std.time.ns_per_s);
         break :t .{ .clock = .awake, .raw = .fromNanoseconds(ns) };
     };
 @@ -773,8 +775,8 @@ const FuzzTestRunner = struct {
                     try f.pending_broadcasts.ensureUnusedCapacity(gpa, size);
                     f.pending_broadcasts.appendSliceAssumeCapacity(body);
                     f.pending_broadcasts.appendSliceAssumeCapacity(@ptrCast(&footer));
-                 }
+                }
-             },
+            },
             else => {}, // ignore other messages
         }
 @@ -863,7 +865,7 @@ const FuzzTestRunner = struct {
         if (f.coverage_id == null) return;
         // Search for the input file corresponding to the instance
-        const InputHeader = Build.abi.fuzz.MmapInputHeader;
+        const InputHeader = std.Build.abi.fuzz.MmapInputHeader;
         var in_r_buf: [@sizeOf(InputHeader)]u8 = undefined;
         var in_r: Io.File.Reader = undefined;
         var in_f: Io.File = undefined;
 @@ -1299,11 +1301,11 @@ fn sendRunFuzzTestMessage(
     }
 }
-fn evalGeneric(run: *Run, spawn_options: process.SpawnOptions) !EvalGenericResult {
+fn evalGeneric(run: *Run, maker: *Maker, spawn_options: process.SpawnOptions) !EvalGenericResult {
-    const b = run.step.owner;
+    const graph = maker.graph;
-    const io = b.graph.io;
+    const io = graph.io;
-    const arena = b.allocator;
+    const arena = graph.allocator; // TODO don't leak into the process arena
-    const gpa = b.allocator;
+    const gpa = maker.gpa;
     var child = try process.spawn(io, spawn_options);
     defer child.kill(io);
 @@ -1317,7 +1319,7 @@ fn evalGeneric(run: *Run, spawn_options: process.SpawnOptions) !EvalGenericResul
             child.stdin = null;
         },
         .lazy_path => |lazy_path| {
-            const path = lazy_path.getPath3(b, &run.step);
+            const path = lazy_path.getPath3(graph, &run.step);
             const file = path.root_dir.handle.openFile(io, path.subPathOrDot(), .{}) catch |err| {
                 return run.step.fail("unable to open stdin file: {t}", .{err});
             };
 @@ -1417,18 +1419,22 @@ fn evalGeneric(run: *Run, spawn_options: process.SpawnOptions) !EvalGenericResul
 const IndexedOutput = struct {
     index: usize,
-    tag: @typeInfo(Arg).@"union".tag_type.?,
+    tag: Configuration.Step.Run.Arg.Tag,
     output: *Output,
 };
+const Output = void; // TODO
 pub fn rerunInFuzzMode(
     run: *Run,
     fuzz: *std.Build.Fuzz,
     prog_node: std.Progress.Node,
 ) !void {
+    const maker = fuzz.maker;
+    const graph = maker.graph;
     const step = &run.step;
     const b = step.owner;
-    const io = b.graph.io;
+    const io = graph.io;
     const arena = b.allocator;
     var argv_list: std.ArrayList([]const u8) = .empty;
     for (run.argv.items) |arg| {
 @@ -1438,11 +1444,11 @@ pub fn rerunInFuzzMode(
             },
             .lazy_path => |file| {
                 const file_path = file.lazy_path.getPath3(b, step);
-                try argv_list.append(arena, b.fmt("{s}{s}", .{ file.prefix, run.convertPathArg(file_path) }));
+                try argv_list.append(arena, b.fmt("{s}{s}", .{ file.prefix, run.convertPathArg(maker, file_path) }));
             },
             .decorated_directory => |dd| {
                 const file_path = dd.lazy_path.getPath3(b, step);
-                try argv_list.append(arena, b.fmt("{s}{s}{s}", .{ dd.prefix, run.convertPathArg(file_path), dd.suffix }));
+                try argv_list.append(arena, b.fmt("{s}{s}{s}", .{ dd.prefix, run.convertPathArg(maker, file_path), dd.suffix }));
             },
             .file_content => |file_plp| {
                 const file_path = file_plp.lazy_path.getPath3(b, step);
 @@ -1471,7 +1477,7 @@ pub fn rerunInFuzzMode(
                 };
                 try argv_list.append(arena, b.fmt("{s}{s}", .{
                     pa.prefix,
-                    run.convertPathArg(.{ .root_dir = .cwd(), .sub_path = file_path }),
+                    run.convertPathArg(maker, .{ .root_dir = .cwd(), .sub_path = file_path }),
                 }));
             },
             .output_file, .output_directory => unreachable,
 @@ -1487,17 +1493,13 @@ pub fn rerunInFuzzMode(
     var rand_int: u64 = undefined;
     io.random(@ptrCast(&rand_int));
     const tmp_dir_path = "tmp" ++ Dir.path.sep_str ++ std.fmt.hex(rand_int);
-    try runCommand(run, argv_list.items, has_side_effects, tmp_dir_path, .{
+    try runCommand(run, maker, prog_node, argv_list.items, has_side_effects, tmp_dir_path, .{
-        .progress_node = prog_node,
-        .watch = undefined, // not used by `runCommand`
-        .web_server = null, // only needed for time reports
-        .unit_test_timeout_ns = null, // don't time out fuzz tests for now
-        .gpa = fuzz.gpa,
-    }, .{
         .fuzz = fuzz,
     });
 }
+const CapturedStdIo = void; // TODO get it from Configuration
 fn populateGeneratedPaths(
     arena: std.mem.Allocator,
     output_placeholders: []const IndexedOutput,
 @@ -1545,17 +1547,19 @@ const FuzzContext = struct {
 fn runCommand(
     run: *Run,
+    maker: *Maker,
+    progress_node: std.Progress.Node,
     argv: []const []const u8,
     has_side_effects: bool,
     output_dir_path: []const u8,
-    options: Step.MakeOptions,
     fuzz_context: ?FuzzContext,
 ) !void {
+    const graph = maker.graph;
+    const arena = graph.arena; // TODO don't leak into process arena
+    const gpa = maker.gpa;
     const step = &run.step;
     const b = step.owner;
-    const arena = b.allocator;
+    const io = graph.io;
-    const gpa = options.gpa;
-    const io = b.graph.io;
     const cwd: process.Child.Cwd = if (run.cwd) |lazy_cwd| .{ .path = lazy_cwd.getPath2(b, step) } else .inherit;
 @@ -1571,12 +1575,12 @@ fn runCommand(
     defer interp_argv.deinit();
     var environ_map: EnvMap = env: {
-        const orig = run.environ_map orelse &b.graph.environ_map;
+        const orig = run.environ_map orelse &graph.environ_map;
         break :env try orig.clone(gpa);
     };
     defer environ_map.deinit();
-    const opt_generic_result = spawnChildAndCollect(run, argv, &environ_map, has_side_effects, options, fuzz_context) catch |err| term: {
+    const opt_generic_result = spawnChildAndCollect(run, maker, progress_node, argv, &environ_map, has_side_effects, fuzz_context) catch |err| term: {
         // InvalidExe: cpu arch mismatch
         // FileNotFound: can happen with a wrong dynamic linker path
         if (err == error.InvalidExe or err == error.FileNotFound) interpret: {
 @@ -1597,7 +1601,7 @@ fn runCommand(
             const need_cross_libc = exe.is_linking_libc and
                 (root_target.isGnuLibC() or (root_target.isMuslLibC() and exe.linkage == .dynamic));
             const other_target = exe.root_module.resolved_target.?.result;
-            switch (std.zig.system.getExternalExecutor(io, &b.graph.host.result, &other_target, .{
+            switch (std.zig.system.getExternalExecutor(io, &graph.host.result, &other_target, .{
                 .qemu_fixes_dl = need_cross_libc and b.libc_runtimes_dir != null,
                 .link_libc = exe.is_linking_libc,
             })) {
 @@ -1669,7 +1673,7 @@ fn runCommand(
                 .bad_dl => |foreign_dl| {
                     if (allow_skip) return error.MakeSkipped;
-                    const host_dl = b.graph.host.result.dynamic_linker.get() orelse "(none)";
+                    const host_dl = graph.host.result.dynamic_linker.get() orelse "(none)";
                     return step.fail(
                         \\the host system is unable to execute binaries from the target
 @@ -1681,7 +1685,7 @@ fn runCommand(
                 .bad_os_or_cpu => {
                     if (allow_skip) return error.MakeSkipped;
-                    const host_name = try b.graph.host.result.zigTriple(b.allocator);
+                    const host_name = try graph.host.result.zigTriple(b.allocator);
                     const foreign_name = try root_target.zigTriple(b.allocator);
                     return step.fail("the host system ({s}) is unable to execute binaries from the target ({s})", .{
 @@ -1692,14 +1696,14 @@ fn runCommand(
             if (root_target.os.tag == .windows) {
                 // On Windows we don't have rpaths so we have to add .dll search paths to PATH
-                run.addPathForDynLibs(exe);
+                addPathForDynLibs(exe);
             }
             gpa.free(step.result_failed_command.?);
             step.result_failed_command = null;
             try Step.handleVerbose2(step.owner, cwd, run.environ_map, interp_argv.items);
-            break :term spawnChildAndCollect(run, interp_argv.items, &environ_map, has_side_effects, options, fuzz_context) catch |e| {
+            break :term spawnChildAndCollect(run, maker, progress_node, interp_argv.items, &environ_map, has_side_effects, fuzz_context) catch |e| {
                 if (!run.failing_to_execute_foreign_is_an_error) return error.MakeSkipped;
                 if (e == error.MakeFailed) return error.MakeFailed; // error already reported
                 return step.fail("unable to spawn interpreter {s}: {t}", .{ interp_argv.items[0], e });
 @@ -1851,14 +1855,16 @@ const EvalGenericResult = struct {
 fn spawnChildAndCollect(
     run: *Run,
+    maker: *Maker,
+    progress_node: std.Progress.Node,
     argv: []const []const u8,
     environ_map: *EnvMap,
     has_side_effects: bool,
-    options: Step.MakeOptions,
     fuzz_context: ?FuzzContext,
 ) !?EvalGenericResult {
     const b = run.step.owner;
-    const graph = b.graph;
+    const graph = maker.graph;
+    const gpa = maker.gpa;
     const io = graph.io;
     if (fuzz_context != null) {
 @@ -1870,7 +1876,7 @@ fn spawnChildAndCollect(
     // If an error occurs, it's caused by this command:
     assert(run.step.result_failed_command == null);
-    run.step.result_failed_command = try Step.allocPrintCmd(options.gpa, child_cwd, .{
+    run.step.result_failed_command = try Step.allocPrintCmd(gpa, child_cwd, .{
         .child = environ_map,
         .parent = &graph.environ_map,
     }, argv);
 @@ -1905,7 +1911,7 @@ fn spawnChildAndCollect(
     if (run.stdio == .zig_test) {
         const started: Io.Clock.Timestamp = .now(io, .awake);
-        const result = evalZigTest(run, spawn_options, options, fuzz_context) catch |err| switch (err) {
+        const result = evalZigTest(run, maker, progress_node, spawn_options, fuzz_context) catch |err| switch (err) {
             error.Canceled => |e| return e,
             else => |e| e,
         };
 @@ -1915,7 +1921,7 @@ fn spawnChildAndCollect(
     } else {
         const inherit = spawn_options.stdout == .inherit or spawn_options.stderr == .inherit;
         if (!run.disable_zig_progress and !inherit) {
-            spawn_options.progress_node = options.progress_node;
+            spawn_options.progress_node = progress_node;
         }
         const terminal_mode: Io.Terminal.Mode = if (inherit) m: {
             const stderr = try io.lockStderr(&.{}, graph.stderr_mode);
 @@ -1925,7 +1931,7 @@ fn spawnChildAndCollect(
         try setColorEnvironmentVariables(run, environ_map, terminal_mode);
         const started: Io.Clock.Timestamp = .now(io, .awake);
-        const result = evalGeneric(run, spawn_options) catch |err| switch (err) {
+        const result = evalGeneric(run, maker, spawn_options) catch |err| switch (err) {
             error.Canceled => |e| return e,
             else => |e| e,
         };
 @@ -1934,11 +1940,11 @@ fn spawnChildAndCollect(
     }
 }
-fn hashStdIo(hh: *Cache.HashHelper, stdio: StdIo) void {
+fn hashStdIo(hh: *Cache.HashHelper, stdio: void) void {
     switch (stdio) {
         .infer_from_args, .inherit, .zig_test => {},
         .check => |checks| for (checks.items) |check| {
-            hh.add(@as(std.meta.Tag(StdIo.Check), check));
+            hh.add(@as(std.meta.Tag(@This().StdIo.Check), check));
             switch (check) {
                 .expect_stderr_exact,
                 .expect_stderr_match,
 @@ -2010,7 +2016,7 @@ fn setColorEnvironmentVariables(run: *Run, environ_map: *EnvMap, terminal_mode:
     }
 }
-fn checksContainStdout(checks: []const StdIo.Check) bool {
+fn checksContainStdout(checks: []const @This().StdIo.Check) bool {
     for (checks) |check| switch (check) {
         .expect_stderr_exact,
         .expect_stderr_match,
 @@ -2024,7 +2030,7 @@ fn checksContainStdout(checks: []const StdIo.Check) bool {
     return false;
 }
-fn checksContainStderr(checks: []const StdIo.Check) bool {
+fn checksContainStderr(checks: []const @This().StdIo.Check) bool {
     for (checks) |check| switch (check) {
         .expect_stdout_exact,
         .expect_stdout_match,
 @@ -2063,9 +2069,9 @@ fn hasAnyOutputArgs(run: Run) bool {
 ///
 /// Whenever a path is included in the argv of a child, it should be put through this function first
 /// to make sure the child doesn't see paths relative to a cwd other than its own.
-fn convertPathArg(run: *Run, path: Build.Cache.Path) []const u8 {
+fn convertPathArg(run: *Run, maker: *Maker, path: Path) []const u8 {
     const b = run.step.owner;
-    const graph = b.graph;
+    const graph = maker.graph;
     const arena = graph.arena;
     const path_str = path.toString(arena) catch @panic("OOM");
 @@ -2091,40 +2097,43 @@ fn convertPathArg(run: *Run, path: Build.Cache.Path) []const u8 {
     return Dir.path.join(arena, &.{ ".", child_cwd_rel }) catch @panic("OOM");
 }
-fn addPathForDynLibs(run: *Run, artifact: *Step.Compile) void {
+fn addPathForDynLibs(artifact: *Step.Compile) void {
-    const b = run.step.owner;
+    if (true) @panic("TODO");
-    const compiles = artifact.getCompileDependencies(true);
+    for (artifact.getCompileDependencies(true)) |compile| {
-    for (compiles) |compile| {
         if (compile.root_module.resolved_target.?.result.os.tag == .windows and
             compile.isDynamicLibrary())
         {
-            addPathDir(run, Dir.path.dirname(compile.getEmittedBin().getPath2(b, &run.step)).?);
+            @panic("TODO");
+            //addPathDir(run, Dir.path.dirname(compile.getEmittedBin().getPath2(b, &run.step)).?);
         }
     }
 }
 fn failForeign(
     run: *Run,
+    maker: *Maker,
+    step_index: Configuration.Step.Index,
     suggested_flag: []const u8,
     argv0: []const u8,
     exe: *Step.Compile,
-) error{ MakeFailed, MakeSkipped, OutOfMemory } {
+) Step.ExtendedMakeError {
+    const step = maker.stepByIndex(step_index);
     switch (run.stdio) {
         .check, .zig_test => {
-            if (run.skip_foreign_checks)
+            if (run.skip_foreign_checks) return error.MakeSkipped;
-                return error.MakeSkipped;
-            const b = run.step.owner;
+            const graph = maker.graph;
-            const host_name = try b.graph.host.result.zigTriple(b.allocator);
+            const process_arena = graph.arena; // TODO don't leak into process arena
-            const foreign_name = try exe.rootModuleTarget().zigTriple(b.allocator);
+            const host_name = try graph.host.result.zigTriple(process_arena);
+            const foreign_name = try exe.rootModuleTarget().zigTriple(process_arena);
-            return run.step.fail(
+            return step.fail(
                 \\unable to spawn foreign binary '{s}' ({s}) on host system ({s})
                 \\  consider using {s} or enabling skip_foreign_checks in the Run step
             , .{ argv0, foreign_name, host_name, suggested_flag });
         },
         else => {
-            return run.step.fail("unable to spawn foreign binary '{s}'", .{argv0});
+            return step.fail("unable to spawn foreign binary '{s}'", .{argv0});
         },
     }
 }

lib/compiler/Maker/Watch.zig+45-38

 @@ -10,6 +10,7 @@ const Configuration = std.Build.Configuration;
 const FsEvents = @import("Watch/FsEvents.zig");
 const Step = @import("Step.zig");
+const Maker = @import("../Maker.zig");
 os: Os,
 /// The number to show as the number of directories being watched.
 @@ -18,8 +19,7 @@ dir_count: usize,
 // They are `undefined` on implementations which do not utilize then.
 dir_table: DirTable,
 generation: Generation,
-configuration: *const Configuration,
+maker: *Maker,
-make_steps: []Step,
 pub const have_impl = Os != void;
 @@ -105,8 +105,7 @@ const Os = switch (builtin.os.tag) {
             };
         };
-        fn init(cwd_path: []const u8, configuration: *const Configuration, make_steps: []Step) !Watch {
+        fn init(maker: *Maker) !Watch {
-            _ = cwd_path;
             return .{
                 .dir_table = .{},
                 .dir_count = 0,
 @@ -118,8 +117,7 @@ const Os = switch (builtin.os.tag) {
                     else => {},
                 },
                 .generation = 0,
-                .make_steps = make_steps,
+                .maker = maker,
-                .configuration = configuration,
             };
         }
 @@ -136,7 +134,8 @@ const Os = switch (builtin.os.tag) {
             return stack_lfh.clone(gpa);
         }
-        fn markDirtySteps(w: *Watch, gpa: Allocator, fan_fd: posix.fd_t) !bool {
+        fn markDirtySteps(w: *Watch, fan_fd: posix.fd_t) !bool {
+            const maker = w.maker;
             const fanotify = std.os.linux.fanotify;
             const M = fanotify.event_metadata;
             var events_buf: [256 + 4096]u8 = undefined;
 @@ -155,7 +154,7 @@ const Os = switch (builtin.os.tag) {
                     if (meta[0].mask.Q_OVERFLOW) {
                         any_dirty = true;
                         std.log.warn("file system watch queue overflowed; falling back to fstat", .{});
-                        markAllFilesDirty(w, gpa);
+                        markAllFilesDirty(w);
                         return true;
                     }
                     const fid: *align(1) fanotify.event_info_fid = @ptrCast(meta + 1);
 @@ -167,9 +166,9 @@ const Os = switch (builtin.os.tag) {
                             const lfh: FileHandle = .{ .handle = file_handle };
                             if (w.os.handle_table.getPtr(lfh)) |value| {
                                 if (value.reaction_set.getPtr(".")) |glob_set|
-                                    any_dirty = markStepSetDirty(gpa, w.make_steps, glob_set, any_dirty);
+                                    any_dirty = markStepSetDirty(maker, glob_set, any_dirty);
                                 if (value.reaction_set.getPtr(file_name)) |step_set|
-                                    any_dirty = markStepSetDirty(gpa, w.make_steps, step_set, any_dirty);
+                                    any_dirty = markStepSetDirty(maker, step_set, any_dirty);
                             }
                         },
                         else => |t| std.log.warn("unexpected fanotify event '{t}'", .{t}),
 @@ -179,9 +178,11 @@ const Os = switch (builtin.os.tag) {
         }
         fn update(w: *Watch, gpa: Allocator, steps: []const Configuration.Step.Index) !void {
+            const maker = w.maker;
             // Add missing marks and note persisted ones.
             for (steps) |step_index| {
-                const step = &w.make_steps[@intFromEnum(step_index)];
+                const step = maker.stepByIndex(step_index);
                 for (step.inputs.table.keys(), step.inputs.table.values()) |path, *files| {
                     const reaction_set = rs: {
                         const gop = try w.dir_table.getOrPut(gpa, path);
 @@ -298,13 +299,12 @@ const Os = switch (builtin.os.tag) {
             w.dir_count = w.dir_table.count();
         }
-        fn wait(w: *Watch, gpa: Allocator, io: Io, timeout: Timeout) !WaitResult {
+        fn wait(w: *Watch, timeout: Timeout) !WaitResult {
-            _ = io;
             const events_len = try std.posix.poll(w.os.poll_fds.values(), timeout.to_i32_ms());
             if (events_len == 0)
                 return .timeout;
             for (w.os.poll_fds.values()) |poll_fd| {
-                if (poll_fd.revents & std.posix.POLL.IN == std.posix.POLL.IN and try markDirtySteps(w, gpa, poll_fd.fd))
+                if (poll_fd.revents & std.posix.POLL.IN == std.posix.POLL.IN and try markDirtySteps(w, poll_fd.fd))
                     return .dirty;
             }
             return .clean;
 @@ -515,12 +515,14 @@ const Os = switch (builtin.os.tag) {
             return file_id;
         }
-        fn markDirtySteps(w: *Watch, gpa: Allocator, dir: *Directory) !bool {
+        fn markDirtySteps(w: *Watch, dir: *Directory) !bool {
+            const maker = w.maker;
             var any_dirty = false;
             const bytes_returned = dir.iosb.Information;
             if (bytes_returned == 0) {
                 std.log.warn("file system watch queue overflowed; falling back to fstat", .{});
-                markAllFilesDirty(w, gpa);
+                markAllFilesDirty(w);
                 try dir.startListening(w);
                 return true;
             }
 @@ -530,9 +532,9 @@ const Os = switch (builtin.os.tag) {
                 const notify: *windows.FILE.NOTIFY.INFORMATION = @ptrCast(@alignCast(&dir.buffer[offset]));
                 const file_name = file_name_buf[0..std.unicode.wtf16LeToWtf8(&file_name_buf, notify.fileName())];
                 if (dir.reaction_set.getPtr(".")) |glob_set|
-                    any_dirty = markStepSetDirty(gpa, glob_set, any_dirty);
+                    any_dirty = markStepSetDirty(maker, glob_set, any_dirty);
                 if (dir.reaction_set.getPtr(file_name)) |step_set|
-                    any_dirty = markStepSetDirty(gpa, step_set, any_dirty);
+                    any_dirty = markStepSetDirty(maker, step_set, any_dirty);
                 if (notify.NextEntryOffset == 0)
                     break;
 @@ -619,14 +621,17 @@ const Os = switch (builtin.os.tag) {
             w.dir_count = w.dir_table.count();
         }
-        fn wait(w: *Watch, gpa: Allocator, io: Io, timeout: Timeout) !WaitResult {
+        fn wait(w: *Watch, timeout: Timeout) !WaitResult {
+            const maker = w.maker;
+            const io = maker.graph.io;
             for (0..2) |attempt| {
                 while (w.os.ready_dirs.popFirst()) |ready_node| {
                     const dir: *Directory = @fieldParentPtr("ready_node", ready_node);
                     assert(dir.state == .ready);
                     dir.state = .idle;
                     switch (dir.iosb.u.Status) {
-                        .SUCCESS => return if (try markDirtySteps(w, gpa, dir)) .dirty else .clean,
+                        .SUCCESS => return if (try markDirtySteps(w, dir)) .dirty else .clean,
                         .PENDING => unreachable,
                         .CANCELLED => {},
                         else => |status| return windows.unexpectedStatus(status),
 @@ -810,25 +815,25 @@ const Os = switch (builtin.os.tag) {
             w.dir_count = w.dir_table.count();
         }
-        fn wait(w: *Watch, gpa: Allocator, io: Io, timeout: Timeout) !WaitResult {
+        fn wait(w: *Watch, timeout: Timeout) !WaitResult {
-            _ = io;
+            const maker = w.maker;
             var timespec_buffer: posix.timespec = undefined;
             var event_buffer: [100]posix.Kevent = undefined;
             var n = try Io.Kqueue.kevent(w.os.kq_fd, &.{}, &event_buffer, timeout.toTimespec(&timespec_buffer));
             if (n == 0) return .timeout;
             const reaction_sets = w.os.handles.items(.rs);
-            var any_dirty = markDirtySteps(gpa, reaction_sets, event_buffer[0..n], false);
+            var any_dirty = markDirtySteps(maker, reaction_sets, event_buffer[0..n], false);
             timespec_buffer = .{ .sec = 0, .nsec = 0 };
             while (n == event_buffer.len) {
                 n = try Io.Kqueue.kevent(w.os.kq_fd, &.{}, &event_buffer, &timespec_buffer);
                 if (n == 0) break;
-                any_dirty = markDirtySteps(gpa, reaction_sets, event_buffer[0..n], any_dirty);
+                any_dirty = markDirtySteps(maker, reaction_sets, event_buffer[0..n], any_dirty);
             }
             return if (any_dirty) .dirty else .clean;
         }
         fn markDirtySteps(
-            gpa: Allocator,
+            maker: *Maker,
             reaction_sets: []ReactionSet,
             events: []const std.c.Kevent,
             start_any_dirty: bool,
 @@ -840,13 +845,13 @@ const Os = switch (builtin.os.tag) {
                 // If we knew the basename of the changed file, here we would
                 // mark only the step set dirty, and possibly the glob set:
                 //if (reaction_set.getPtr(".")) |glob_set|
-                //    any_dirty = markStepSetDirty(gpa, glob_set, any_dirty);
+                //    any_dirty = markStepSetDirty(maker, glob_set, any_dirty);
                 //if (reaction_set.getPtr(file_name)) |step_set|
-                //    any_dirty = markStepSetDirty(gpa, step_set, any_dirty);
+                //    any_dirty = markStepSetDirty(maker, step_set, any_dirty);
                 // However we don't know the file name so just mark all the
                 // sets dirty for this directory.
                 for (reaction_set.values()) |*step_set| {
-                    any_dirty = markStepSetDirty(gpa, step_set, any_dirty);
+                    any_dirty = markStepSetDirty(maker, step_set, any_dirty);
                 }
             }
             return any_dirty;
 @@ -878,8 +883,8 @@ const Os = switch (builtin.os.tag) {
     else => void,
 };
-pub fn init(cwd_path: []const u8, configuration: *const Configuration, make_steps: []Step) !Watch {
+pub fn init(maker: *Maker) !Watch {
-    return Os.init(cwd_path, configuration, make_steps);
+    return Os.init(maker);
 }
 pub const Match = struct {
 @@ -904,7 +909,9 @@ pub const Match = struct {
     };
 };
-fn markAllFilesDirty(w: *Watch, gpa: Allocator) void {
+fn markAllFilesDirty(w: *Watch) void {
+    const maker = w.maker;
     for (switch (builtin.os.tag) {
         .windows => w.os.handle_table.keys(),
         else => w.os.handle_table.values(),
 @@ -915,18 +922,18 @@ fn markAllFilesDirty(w: *Watch, gpa: Allocator) void {
         };
         for (reaction_set.values()) |step_set| {
             for (step_set.keys()) |step_index| {
-                const step = &w.make_steps[@intFromEnum(step_index)];
+                const step = maker.stepByIndex(step_index);
-                _ = step.invalidateResult(gpa);
+                _ = maker.invalidateResult(step);
             }
         }
     }
 }
-fn markStepSetDirty(gpa: Allocator, make_steps: []Step, step_set: *StepSet, any_dirty: bool) bool {
+fn markStepSetDirty(maker: *Maker, step_set: *StepSet, any_dirty: bool) bool {
     var this_any_dirty = false;
     for (step_set.keys()) |step_index| {
-        const step = &make_steps[@intFromEnum(step_index)];
+        const step = maker.stepByIndex(step_index);
-        if (step.invalidateResult(gpa)) this_any_dirty = true;
+        if (maker.invalidateResult(step)) this_any_dirty = true;
     }
     return any_dirty or this_any_dirty;
 }
 @@ -971,6 +978,6 @@ pub const WaitResult = enum {
     clean,
 };
-pub fn wait(w: *Watch, gpa: Allocator, io: Io, timeout: Timeout) !WaitResult {
+pub fn wait(w: *Watch, timeout: Timeout) !WaitResult {
-    return Os.wait(w, gpa, io, timeout);
+    return Os.wait(w, timeout);
 }

lib/compiler/Maker/WebServer.zig+94-71

 @@ -14,16 +14,14 @@ const log = std.log.scoped(.web_server);
 const mem = std.mem;
 const net = std.Io.net;
+const Maker = @import("../Maker.zig");
 const Fuzz = @import("Fuzz.zig");
 const Graph = @import("Graph.zig");
 const Step = @import("Step.zig");
-gpa: Allocator,
+maker: *Maker,
-graph: *const Graph,
-all_steps: []const Configuration.Step.Index,
 listen_address: net.IpAddress,
 root_prog_node: std.Progress.Node,
-watch: bool,
 tcp_server: ?net.Server,
 serve_task: ?Io.Future(Io.Cancelable!void),
 @@ -65,19 +63,16 @@ pub const base_clock: Io.Clock = .awake;
 /// Thread-safe. Triggers updates to be sent to connected WebSocket clients; see `update_id`.
 pub fn notifyUpdate(ws: *WebServer) void {
+    const io = ws.maker.graph.io;
     _ = ws.update_id.rmw(.Add, 1, .release);
-    ws.graph.io.futexWake(u32, &ws.update_id.raw, 16);
+    io.futexWake(u32, &ws.update_id.raw, 16);
 }
 pub const Options = struct {
-    gpa: Allocator,
+    maker: *Maker,
-    graph: *const Graph,
-    all_steps: []const Configuration.Step.Index,
     root_prog_node: std.Progress.Node,
-    watch: bool,
     listen_address: net.IpAddress,
     base_timestamp: Io.Clock.Timestamp,
-    configuration: *const Configuration,
 };
 pub fn init(opts: Options) WebServer {
     // The upcoming `Io` interface should allow us to use `Io.async` and `Io.concurrent`
 @@ -85,10 +80,13 @@ pub fn init(opts: Options) WebServer {
     comptime assert(!builtin.single_threaded);
     assert(opts.base_timestamp.clock == base_clock);
-    const all_steps = opts.all_steps;
+    const maker = opts.maker;
-    const c = opts.configuration;
+    const all_steps = maker.step_stack.keys();
+    const c = &maker.scanned_config.configuration;
+    const gpa = maker.gpa;
+    const graph = maker.graph;
-    const step_names_trailing = opts.gpa.alloc(u8, len: {
+    const step_names_trailing = gpa.alloc(u8, len: {
         var name_bytes: usize = 0;
         for (all_steps) |step_index| name_bytes += step_index.ptr(c).name.slice(c).len;
         break :len name_bytes + all_steps.len * 4;
 @@ -105,25 +103,22 @@ pub fn init(opts: Options) WebServer {
         assert(idx == step_names_trailing.len);
     }
-    const step_status_bits = opts.gpa.alloc(
+    const step_status_bits = gpa.alloc(
         u8,
         std.math.divCeil(usize, all_steps.len, 4) catch unreachable,
     ) catch @panic("out of memory");
     @memset(step_status_bits, 0);
-    const time_reports_len: usize = if (opts.graph.time_report) all_steps.len else 0;
+    const time_reports_len: usize = if (graph.time_report) all_steps.len else 0;
-    const time_report_msgs = opts.gpa.alloc([]u8, time_reports_len) catch @panic("out of memory");
+    const time_report_msgs = gpa.alloc([]u8, time_reports_len) catch @panic("out of memory");
-    const time_report_update_times = opts.gpa.alloc(i64, time_reports_len) catch @panic("out of memory");
+    const time_report_update_times = gpa.alloc(i64, time_reports_len) catch @panic("out of memory");
     @memset(time_report_msgs, &.{});
     @memset(time_report_update_times, std.math.minInt(i64));
     return .{
-        .gpa = opts.gpa,
+        .maker = maker,
-        .graph = opts.graph,
-        .all_steps = all_steps,
         .listen_address = opts.listen_address,
         .root_prog_node = opts.root_prog_node,
-        .watch = opts.watch,
         .tcp_server = null,
         .serve_task = null,
 @@ -148,8 +143,9 @@ pub fn init(opts: Options) WebServer {
     };
 }
 pub fn deinit(ws: *WebServer) void {
-    const gpa = ws.gpa;
+    const maker = ws.maker;
-    const io = ws.graph.io;
+    const gpa = maker.gpa;
+    const io = maker.graph.io;
     gpa.free(ws.step_names_trailing);
     gpa.free(ws.step_status_bits);
 @@ -170,7 +166,8 @@ pub fn deinit(ws: *WebServer) void {
 pub fn start(ws: *WebServer) error{AlreadyReported}!void {
     assert(ws.tcp_server == null);
     assert(ws.serve_task == null);
-    const io = ws.graph.io;
+    const maker = ws.maker;
+    const io = maker.graph.io;
     ws.tcp_server = ws.listen_address.listen(io, .{ .reuse_address = true }) catch |err| {
         log.err("failed to listen to port {d}: {t}", .{ ws.listen_address.getPort(), err });
 @@ -189,9 +186,12 @@ pub fn start(ws: *WebServer) error{AlreadyReported}!void {
     }
 }
 fn serve(ws: *WebServer) Io.Cancelable!void {
-    const io = ws.graph.io;
+    const maker = ws.maker;
+    const io = maker.graph.io;
     var group: Io.Group = .init;
     defer group.cancel(io);
     while (true) {
         var stream = ws.tcp_server.?.accept(io) catch |err| switch (err) {
             error.Canceled => |e| return e,
 @@ -223,8 +223,10 @@ pub fn updateStepStatus(
     step_index: Configuration.Step.Index,
     new_status: abi.StepUpdate.Status,
 ) void {
+    const maker = ws.maker;
+    const all_steps = maker.step_stack.keys();
     // TODO don't do linear search, especially in a hot loop like this
-    const step_idx: u32 = for (ws.all_steps, 0..) |s, i| {
+    const step_idx: u32 = for (all_steps, 0..) |s, i| {
         if (s == step_index) break @intCast(i);
     } else unreachable;
     const ptr = &ws.step_status_bits[step_idx / 4];
 @@ -238,13 +240,16 @@ pub fn updateStepStatus(
 pub fn finishBuild(ws: *WebServer, opts: struct {
     fuzz: bool,
 }) void {
+    const maker = ws.maker;
+    const all_steps = maker.step_stack.keys();
     if (opts.fuzz) {
         switch (builtin.os.tag) {
             // Current implementation depends on two things that need to be ported to Windows:
             // * Memory-mapping to share data between the fuzzer and build runner.
             // * COFF/PE support added to `std.debug.Info` (it needs a batching API for resolving
             //   many addresses to source locations).
-            .windows => std.process.fatal("--fuzz not yet implemented for {s}", .{@tagName(builtin.os.tag)}),
+            .windows => std.process.fatal("--fuzz not yet implemented for {t}", .{builtin.os.tag}),
             else => {},
         }
         if (@bitSizeOf(usize) != 64) {
 @@ -260,28 +265,26 @@ pub fn finishBuild(ws: *WebServer, opts: struct {
         ws.build_status.store(.fuzz_init, .monotonic);
         ws.notifyUpdate();
-        ws.fuzz = Fuzz.init(
+        ws.fuzz = Fuzz.init(maker, all_steps, ws.root_prog_node, .{ .forever = .{ .ws = ws } }) catch |err|
-            ws.gpa,
+            std.process.fatal("failed to start fuzzer: {t}", .{err});
-            ws.graph.io,
-            ws.all_steps,
-            ws.root_prog_node,
-            .{ .forever = .{ .ws = ws } },
-        ) catch |err| std.process.fatal("failed to start fuzzer: {s}", .{@errorName(err)});
         ws.fuzz.?.start();
     }
-    ws.build_status.store(if (ws.watch) .watching else .idle, .monotonic);
+    ws.build_status.store(if (maker.watch) .watching else .idle, .monotonic);
     ws.notifyUpdate();
 }
-pub fn now(s: *const WebServer) i64 {
+pub fn now(ws: *const WebServer) i64 {
-    const io = s.graph.io;
+    const maker = ws.maker;
+    const io = maker.graph.io;
     const ts = base_clock.now(io);
-    return @intCast(s.base_timestamp.durationTo(ts).toNanoseconds());
+    return @intCast(ws.base_timestamp.durationTo(ts).toNanoseconds());
 }
 fn accept(ws: *WebServer, stream: net.Stream) void {
-    const io = ws.graph.io;
+    const maker = ws.maker;
+    const io = maker.graph.io;
     defer {
         // `net.Stream.close` wants to helpfully overwrite `stream` with
         // `undefined`, but it cannot do so since it is an immutable parameter.
 @@ -326,12 +329,16 @@ fn accept(ws: *WebServer, stream: net.Stream) void {
 }
 fn serveWebSocket(ws: *WebServer, sock: *http.Server.WebSocket) !noreturn {
-    const io = ws.graph.io;
+    const maker = ws.maker;
+    const gpa = maker.gpa;
+    const graph = maker.graph;
+    const io = graph.io;
+    const all_steps = maker.step_stack.keys();
     var prev_build_status = ws.build_status.load(.monotonic);
-    const prev_step_status_bits = try ws.gpa.alloc(u8, ws.step_status_bits.len);
+    const prev_step_status_bits = try gpa.alloc(u8, ws.step_status_bits.len);
-    defer ws.gpa.free(prev_step_status_bits);
+    defer gpa.free(prev_step_status_bits);
     for (prev_step_status_bits, ws.step_status_bits) |*copy, *shared| {
         copy.* = @atomicLoad(u8, shared, .monotonic);
     }
 @@ -343,10 +350,10 @@ fn serveWebSocket(ws: *WebServer, sock: *http.Server.WebSocket) !noreturn {
         const hello_header: abi.Hello = .{
             .status = prev_build_status,
             .flags = .{
-                .time_report = ws.graph.time_report,
+                .time_report = graph.time_report,
             },
             .timestamp = ws.now(),
-            .steps_len = @intCast(ws.all_steps.len),
+            .steps_len = @intCast(all_steps.len),
         };
         var bufs: [3][]const u8 = .{ @ptrCast(&hello_header), ws.step_names_trailing, prev_step_status_bits };
         try sock.writeMessageVec(&bufs, .binary);
 @@ -369,8 +376,8 @@ fn serveWebSocket(ws: *WebServer, sock: *http.Server.WebSocket) !noreturn {
                 if (update_time <= prev_time) continue;
                 // We want to send `msg`, but shouldn't block `ws.time_report_mutex` while we do, so
                 // that we don't hold up the build system on the client accepting this packet.
-                const owned_msg = try ws.gpa.dupe(u8, msg);
+                const owned_msg = try gpa.dupe(u8, msg);
-                defer ws.gpa.free(owned_msg);
+                defer gpa.free(owned_msg);
                 // Temporarily unlock, then re-lock after the message is sent.
                 ws.time_report_mutex.unlock(io);
                 defer ws.time_report_mutex.lockUncancelable(io);
 @@ -427,7 +434,8 @@ fn serveWebSocket(ws: *WebServer, sock: *http.Server.WebSocket) !noreturn {
     }
 }
 fn recvWebSocketMessages(ws: *WebServer, sock: *http.Server.WebSocket) void {
-    const io = ws.graph.io;
+    const maker = ws.maker;
+    const io = maker.graph.io;
     while (true) {
         const msg = sock.readSmallMessage() catch return;
 @@ -485,8 +493,11 @@ fn serveLibFile(
     sub_path: []const u8,
     content_type: []const u8,
 ) !void {
+    const maker = ws.maker;
+    const graph = maker.graph;
     return serveFile(ws, request, .{
-        .root_dir = ws.graph.zig_lib_directory,
+        .root_dir = graph.zig_lib_directory,
         .sub_path = sub_path,
     }, content_type);
 }
 @@ -495,7 +506,9 @@ fn serveClientWasm(
     req: *http.Server.Request,
     optimize_mode: std.builtin.OptimizeMode,
 ) !void {
-    var arena_state: std.heap.ArenaAllocator = .init(ws.gpa);
+    const gpa = ws.maker.gpa;
+    var arena_state: std.heap.ArenaAllocator = .init(gpa);
     defer arena_state.deinit();
     const arena = arena_state.allocator();
 @@ -510,8 +523,10 @@ pub fn serveFile(
     path: Cache.Path,
     content_type: []const u8,
 ) !void {
-    const gpa = ws.gpa;
+    const maker = ws.maker;
-    const io = ws.graph.io;
+    const gpa = ws.maker.gpa;
+    const io = maker.graph.io;
     // The desired API is actually sendfile, which will require enhancing http.Server.
     // We load the file with every request so that the user can make changes to the file
     // and refresh the HTML page without restarting this server.
 @@ -528,7 +543,8 @@ pub fn serveFile(
     });
 }
 pub fn serveTarFile(ws: *WebServer, request: *http.Server.Request, paths: []const Cache.Path) !void {
-    const graph = ws.graph;
+    const maker = ws.maker;
+    const graph = maker.graph;
     const io = graph.io;
     var send_buffer: [0x4000]u8 = undefined;
 @@ -576,8 +592,9 @@ fn buildClientWasm(ws: *WebServer, arena: Allocator, optimize: std.builtin.Optim
     const arch_os_abi = "wasm32-freestanding";
     const cpu_features = "baseline+atomics+bulk_memory+multivalue+mutable_globals+nontrapping_fptoint+reference_types+sign_ext";
-    const gpa = ws.gpa;
+    const maker = ws.maker;
-    const graph = ws.graph;
+    const gpa = maker.gpa;
+    const graph = maker.graph;
     const io = graph.io;
     const main_src_path: Cache.Path = .{
 @@ -697,7 +714,7 @@ fn buildClientWasm(ws: *WebServer, arena: Allocator, optimize: std.builtin.Optim
             if (code != 0) {
                 log.err(
                     "the following command exited with error code {d}:\n{s}",
-                    .{ code, try Step.allocPrintCmd(arena, .inherit, null, argv.items) },
+                    .{ code, try std.zig.allocPrintCmd(arena, .inherit, null, argv.items) },
                 );
                 return error.WasmCompilationFailed;
             }
 @@ -705,21 +722,21 @@ fn buildClientWasm(ws: *WebServer, arena: Allocator, optimize: std.builtin.Optim
         .signal => |sig| {
             log.err(
                 "the following command terminated with signal {t}:\n{s}",
-                .{ sig, try Step.allocPrintCmd(arena, .inherit, null, argv.items) },
+                .{ sig, try std.zig.allocPrintCmd(arena, .inherit, null, argv.items) },
             );
             return error.WasmCompilationFailed;
         },
         .stopped => |sig| {
             log.err(
                 "the following command stopped unexpectedly with signal {t}:\n{s}",
-                .{ sig, try Build.Step.allocPrintCmd(arena, .inherit, null, argv.items) },
+                .{ sig, try std.zig.allocPrintCmd(arena, .inherit, null, argv.items) },
             );
             return error.WasmCompilationFailed;
         },
         .unknown => {
             log.err(
                 "the following command terminated unexpectedly:\n{s}",
-                .{try Step.allocPrintCmd(arena, .inherit, null, argv.items)},
+                .{try std.zig.allocPrintCmd(arena, .inherit, null, argv.items)},
             );
             return error.WasmCompilationFailed;
         },
 @@ -729,14 +746,14 @@ fn buildClientWasm(ws: *WebServer, arena: Allocator, optimize: std.builtin.Optim
         try result_error_bundle.renderToStderr(io, .{}, .auto);
         log.err("the following command failed with {d} compilation errors:\n{s}", .{
             result_error_bundle.errorMessageCount(),
-            try Step.allocPrintCmd(arena, .inherit, null, argv.items),
+            try std.zig.allocPrintCmd(arena, .inherit, null, argv.items),
         });
         return error.WasmCompilationFailed;
     }
     const base_path = result orelse {
         log.err("child process failed to report result\n{s}", .{
-            try Step.allocPrintCmd(arena, .inherit, null, argv.items),
+            try std.zig.allocPrintCmd(arena, .inherit, null, argv.items),
         });
         return error.WasmCompilationFailed;
     };
 @@ -773,11 +790,13 @@ pub fn updateTimeReportCompile(ws: *WebServer, opts: struct {
     /// The trailing data of `abi.time_report.CompileResult`, except the step name.
     trailing: []const u8,
 }) void {
-    const gpa = ws.gpa;
+    const maker = ws.maker;
-    const io = ws.graph.io;
+    const gpa = maker.gpa;
+    const io = maker.graph.io;
+    const all_steps = maker.step_stack.keys();
     // TODO don't do linear search
-    const step_idx: u32 = for (ws.all_steps, 0..) |s, i| {
+    const step_idx: u32 = for (all_steps, 0..) |s, i| {
         if (s == opts.compile_step) break @intCast(i);
     } else unreachable;
 @@ -815,11 +834,13 @@ pub fn updateTimeReportCompile(ws: *WebServer, opts: struct {
 }
 pub fn updateTimeReportGeneric(ws: *WebServer, step_index: Configuration.Step.Index, duration: Io.Duration) void {
-    const gpa = ws.gpa;
+    const maker = ws.maker;
-    const io = ws.graph.io;
+    const gpa = maker.gpa;
+    const io = maker.graph.io;
+    const all_steps = maker.step_stack.keys();
     // TODO don't do linear search
-    const step_idx: u32 = for (ws.all_steps, 0..) |s, i| {
+    const step_idx: u32 = for (all_steps, 0..) |s, i| {
         if (s == step_index) break @intCast(i);
     } else unreachable;
 @@ -852,11 +873,13 @@ pub fn updateTimeReportRunTest(
     tests: *const Step.Run.CachedTestMetadata,
     ns_per_test: []const u64,
 ) void {
-    const gpa = ws.gpa;
+    const maker = ws.maker;
-    const io = ws.graph.io;
+    const gpa = maker.gpa;
+    const io = maker.graph.io;
+    const all_steps = maker.step_stack.keys();
     // TODO don't do linear search
-    const step_idx: u32 = for (ws.all_steps, 0..) |s, i| {
+    const step_idx: u32 = for (all_steps, 0..) |s, i| {
         if (s == run_step_index) break @intCast(i);
     } else unreachable;
 @@ -910,7 +933,7 @@ const RunnerRequest = union(enum) {
     rebuild,
 };
 pub fn getRunnerRequest(ws: *WebServer) ?RunnerRequest {
-    const io = ws.graph.io;
+    const io = ws.maker.graph.io;
     ws.runner_request_mutex.lock(io) catch return;
     defer ws.runner_request_mutex.unlock(io);
     if (ws.runner_request) |req| {
 @@ -921,7 +944,7 @@ pub fn getRunnerRequest(ws: *WebServer) ?RunnerRequest {
     return null;
 }
 pub fn wait(ws: *WebServer) Io.Cancelable!RunnerRequest {
-    const io = ws.graph.io;
+    const io = ws.maker.graph.io;
     try ws.runner_request_mutex.lock(io);
     defer ws.runner_request_mutex.unlock(io);
     while (true) {

lib/std/Build.zig-13

...	@@ -45,7 +45,6 @@ install_prefix: []const u8,	...	@@ -45,7 +45,6 @@ install_prefix: []const u8,
45	/// Path to the directory containing build.zig.	45	/// Path to the directory containing build.zig.
46	build_root: Cache.Directory,	46	build_root: Cache.Directory,
47	cache_root: Cache.Directory,	47	cache_root: Cache.Directory,
48	pkg_config_pkg_list: ?(PkgConfigError![]const PkgConfigPkg) = null,
49	debug_log_scopes: []const []const u8 = &.{},	48	debug_log_scopes: []const []const u8 = &.{},
50	debug_compile_errors: bool = false,	49	debug_compile_errors: bool = false,
51	debug_incremental: bool = false,	50	debug_incremental: bool = false,
...	@@ -176,18 +175,6 @@ pub const RunError = error{	...	@@ -176,18 +175,6 @@ pub const RunError = error{
176	ExecNotSupported,	175	ExecNotSupported,
177	} \|\| std.process.SpawnError;	176	} \|\| std.process.SpawnError;
178		177
179	pub const PkgConfigError = error{
180	PkgConfigCrashed,
181	PkgConfigFailed,
182	PkgConfigNotInstalled,
183	PkgConfigInvalidOutput,
184	};
185
186	pub const PkgConfigPkg = struct {
187	name: []const u8,
188	desc: []const u8,
189	};
190
191	const UserInputOptionsMap = StringHashMap(UserInputOption);	178	const UserInputOptionsMap = StringHashMap(UserInputOption);
192	const AvailableOptionsMap = StringHashMap(AvailableOption);	179	const AvailableOptionsMap = StringHashMap(AvailableOption);
193		180

lib/std/Build/Step/Compile.zig-40

...	@@ -8,13 +8,9 @@ const fs = std.fs;	...	@@ -8,13 +8,9 @@ const fs = std.fs;
8	const assert = std.debug.assert;	8	const assert = std.debug.assert;
9	const panic = std.debug.panic;	9	const panic = std.debug.panic;
10	const StringHashMap = std.StringHashMap;	10	const StringHashMap = std.StringHashMap;
11	const Sha256 = std.crypto.hash.sha2.Sha256;
12	const Allocator = std.mem.Allocator;	11	const Allocator = std.mem.Allocator;
13	const Step = std.Build.Step;	12	const Step = std.Build.Step;
14	const LazyPath = std.Build.LazyPath;	13	const LazyPath = std.Build.LazyPath;
15	const PkgConfigPkg = std.Build.PkgConfigPkg;
16	const PkgConfigError = std.Build.PkgConfigError;
17	const RunError = std.Build.RunError;
18	const Module = std.Build.Module;	14	const Module = std.Build.Module;
19	const InstallDir = std.Build.InstallDir;	15	const InstallDir = std.Build.InstallDir;
20	const GeneratedFile = std.Build.GeneratedFile;	16	const GeneratedFile = std.Build.GeneratedFile;
...	@@ -777,42 +773,6 @@ pub fn setExecCmd(compile: *Compile, args: []const ?[]const u8) void {	...	@@ -777,42 +773,6 @@ pub fn setExecCmd(compile: *Compile, args: []const ?[]const u8) void {
777	compile.exec_cmd_args = duped_args;	773	compile.exec_cmd_args = duped_args;
778	}	774	}
779		775
780	const CliNamedModules = struct {
781	modules: std.AutoArrayHashMapUnmanaged(*Module, void),
782	names: std.StringArrayHashMapUnmanaged(void),
783
784	/// Traverse the whole dependency graph and give every module a unique
785	/// name, ideally one named after what it's called somewhere in the graph.
786	/// It will help here to have both a mapping from module to name and a set
787	/// of all the currently-used names.
788	fn init(arena: Allocator, root_module: *Module) Allocator.Error!CliNamedModules {
789	var compile: CliNamedModules = .{
790	.modules = .{},
791	.names = .{},
792	};
793	const graph = root_module.getGraph();
794	{
795	assert(graph.modules[0] == root_module);
796	try compile.modules.put(arena, root_module, {});
797	try compile.names.put(arena, "root", {});
798	}
799	for (graph.modules[1..], graph.names[1..]) \|mod, orig_name\| {
800	var name = orig_name;
801	var n: usize = 0;
802	while (true) {
803	const gop = try compile.names.getOrPut(arena, name);
804	if (!gop.found_existing) {
805	try compile.modules.putNoClobber(arena, mod, {});
806	break;
807	}
808	name = try std.fmt.allocPrint(arena, "{s}{d}", .{ orig_name, n });
809	n += 1;
810	}
811	}
812	return compile;
813	}
814	};
815
816	fn getGeneratedFilePath(compile: Compile, comptime tag_name: []const u8, asking_step: ?Step) ![]const u8 {	776	fn getGeneratedFilePath(compile: Compile, comptime tag_name: []const u8, asking_step: ?Step) ![]const u8 {
817	const step = &compile.step;	777	const step = &compile.step;
818	const b = step.owner;	778	const b = step.owner;

lib/std/zig/Configuration.zig+15-11

 @@ -436,23 +436,23 @@ pub const Step = extern struct {
     };
     pub const Tag = enum(u5) {
-        top_level,
+        check_file,
+        check_object,
         compile,
+        config_header,
+        fail,
+        fmt,
         install_artifact,
-        install_file,
         install_dir,
+        install_file,
+        objcopy,
+        options,
         remove_dir,
-        fail,
+        run,
-        fmt,
+        top_level,
         translate_c,
-        write_file,
         update_source_files,
-        run,
+        write_file,
-        check_file,
-        check_object,
-        config_header,
-        objcopy,
-        options,
     };
     pub const TopLevel = struct {
 @@ -808,6 +808,10 @@ pub const Step = extern struct {
             _: u23 = 0,
         };
     };
+    pub fn flags(s: *const Step, c: *const Configuration) Flags {
+        return @bitCast(c.extra[s.extra_index]);
+    }
 };
 pub const MaxRss = enum(u32) {