Merge pull request #20688 from ziglang/incr-test

introduce a new tool for testing incremental compilation

lib/std/Build.zig

@@ -2522,7 +2522,7 @@ pub const InstallDir = union(enum) {
 /// function.
 pub fn makeTempPath(b: *Build) []const u8 {
     const rand_int = std.crypto.random.int(u64);
-    const tmp_dir_sub_path = "tmp" ++ fs.path.sep_str ++ hex64(rand_int);
+    const tmp_dir_sub_path = "tmp" ++ fs.path.sep_str ++ std.fmt.hex(rand_int);
     const result_path = b.cache_root.join(b.allocator, &.{tmp_dir_sub_path}) catch @panic("OOM");
     b.cache_root.handle.makePath(tmp_dir_sub_path) catch |err| {
         std.debug.print("unable to make tmp path '{s}': {s}\n", .{
@@ -2532,18 +2532,9 @@ pub fn makeTempPath(b: *Build) []const u8 {
     return result_path;
 }
 
-/// There are a few copies of this function in miscellaneous places. Would be nice to find
-/// a home for them.
+/// Deprecated; use `std.fmt.hex` instead.
 pub fn hex64(x: u64) [16]u8 {
-    const hex_charset = "0123456789abcdef";
-    var result: [16]u8 = undefined;
-    var i: usize = 0;
-    while (i < 8) : (i += 1) {
-        const byte: u8 = @truncate(x >> @as(u6, @intCast(8 * i)));
-        result[i * 2 + 0] = hex_charset[byte >> 4];
-        result[i * 2 + 1] = hex_charset[byte & 15];
-    }
-    return result;
+    return std.fmt.hex(x);
 }
 
 /// A pair of target query and fully resolved target.

lib/std/Build/Step/Options.zig

@@ -457,7 +457,7 @@ fn make(step: *Step, make_options: Step.MakeOptions) !void {
 
             const rand_int = std.crypto.random.int(u64);
             const tmp_sub_path = "tmp" ++ fs.path.sep_str ++
-                std.Build.hex64(rand_int) ++ fs.path.sep_str ++
+                std.fmt.hex(rand_int) ++ fs.path.sep_str ++
                 basename;
             const tmp_sub_path_dirname = fs.path.dirname(tmp_sub_path).?;
 

lib/std/Build/Step/Run.zig

@@ -743,7 +743,7 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
 
     // We do not know the final output paths yet, use temp paths to run the command.
     const rand_int = std.crypto.random.int(u64);
-    const tmp_dir_path = "tmp" ++ fs.path.sep_str ++ std.Build.hex64(rand_int);
+    const tmp_dir_path = "tmp" ++ fs.path.sep_str ++ std.fmt.hex(rand_int);
 
     for (output_placeholders.items) |placeholder| {
         const output_components = .{ tmp_dir_path, placeholder.output.basename };

lib/std/fmt.zig

@@ -2718,3 +2718,32 @@ test "recursive format function" {
     var r = R{ .Leaf = 1 };
     try expectFmt("Leaf(1)\n", "{}\n", .{&r});
 }
+
+pub const hex_charset = "0123456789abcdef";
+
+/// Converts an unsigned integer of any multiple of u8 to an array of lowercase
+/// hex bytes, little endian.
+pub fn hex(x: anytype) [@sizeOf(@TypeOf(x)) * 2]u8 {
+    comptime assert(@typeInfo(@TypeOf(x)).Int.signedness == .unsigned);
+    var result: [@sizeOf(@TypeOf(x)) * 2]u8 = undefined;
+    var i: usize = 0;
+    while (i < result.len / 2) : (i += 1) {
+        const byte: u8 = @truncate(x >> @intCast(8 * i));
+        result[i * 2 + 0] = hex_charset[byte >> 4];
+        result[i * 2 + 1] = hex_charset[byte & 15];
+    }
+    return result;
+}
+
+test hex {
+    {
+        const x = hex(@as(u32, 0xdeadbeef));
+        try std.testing.expect(x.len == 8);
+        try std.testing.expectEqualStrings("efbeadde", &x);
+    }
+    {
+        const s = "[" ++ hex(@as(u64, 0x12345678_abcdef00)) ++ "]";
+        try std.testing.expect(s.len == 18);
+        try std.testing.expectEqualStrings("[00efcdab78563412]", s);
+    }
+}

lib/std/process.zig

@@ -2032,3 +2032,9 @@ pub fn createWindowsEnvBlock(allocator: mem.Allocator, env_map: *const EnvMap) !
     i += 1;
     return try allocator.realloc(result, i);
 }
+
+/// Logs an error and then terminates the process with exit code 1.
+pub fn fatal(comptime format: []const u8, format_arguments: anytype) noreturn {
+    std.log.err(format, format_arguments);
+    exit(1);
+}

lib/std/zig.zig

@@ -667,10 +667,8 @@ pub fn parseTargetQueryOrReportFatalError(
     };
 }
 
-pub fn fatal(comptime format: []const u8, args: anytype) noreturn {
-    std.log.err(format, args);
-    std.process.exit(1);
-}
+/// Deprecated; see `std.process.fatal`.
+pub const fatal = std.process.fatal;
 
 /// Collects all the environment variables that Zig could possibly inspect, so
 /// that we can do reflection on this and print them with `zig env`.

lib/std/zig/Server.zig

@@ -109,6 +109,7 @@ pub fn deinit(s: *Server) void {
 pub fn receiveMessage(s: *Server) !InMessage.Header {
     const Header = InMessage.Header;
     const fifo = &s.receive_fifo;
+    var last_amt_zero = false;
 
     while (true) {
         const buf = fifo.readableSlice(0);
@@ -136,6 +137,10 @@ pub fn receiveMessage(s: *Server) !InMessage.Header {
         const write_buffer = try fifo.writableWithSize(256);
         const amt = try s.in.read(write_buffer);
         fifo.update(amt);
+        if (amt == 0) {
+            if (last_amt_zero) return error.BrokenPipe;
+            last_amt_zero = true;
+        }
     }
 }
 

src/Compilation.zig

@@ -2105,7 +2105,7 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) !void {
             const tmp_artifact_directory = d: {
                 const s = std.fs.path.sep_str;
                 tmp_dir_rand_int = std.crypto.random.int(u64);
-                const tmp_dir_sub_path = "tmp" ++ s ++ Package.Manifest.hex64(tmp_dir_rand_int);
+                const tmp_dir_sub_path = "tmp" ++ s ++ std.fmt.hex(tmp_dir_rand_int);
 
                 const path = try comp.local_cache_directory.join(gpa, &.{tmp_dir_sub_path});
                 errdefer gpa.free(path);
@@ -2297,7 +2297,7 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) !void {
             } else unreachable;
 
             const s = std.fs.path.sep_str;
-            const tmp_dir_sub_path = "tmp" ++ s ++ Package.Manifest.hex64(tmp_dir_rand_int);
+            const tmp_dir_sub_path = "tmp" ++ s ++ std.fmt.hex(tmp_dir_rand_int);
             const o_sub_path = "o" ++ s ++ digest;
 
             // Work around windows `AccessDenied` if any files within this

src/Package/Fetch.zig

@@ -445,7 +445,7 @@ fn runResource(
     const s = fs.path.sep_str;
     const cache_root = f.job_queue.global_cache;
     const rand_int = std.crypto.random.int(u64);
-    const tmp_dir_sub_path = "tmp" ++ s ++ Manifest.hex64(rand_int);
+    const tmp_dir_sub_path = "tmp" ++ s ++ std.fmt.hex(rand_int);
 
     const package_sub_path = blk: {
         const tmp_directory_path = try cache_root.join(arena, &.{tmp_dir_sub_path});

src/Package/Manifest.zig

@@ -1,3 +1,12 @@
+const Manifest = @This();
+const std = @import("std");
+const mem = std.mem;
+const Allocator = std.mem.Allocator;
+const assert = std.debug.assert;
+const Ast = std.zig.Ast;
+const testing = std.testing;
+const hex_charset = std.fmt.hex_charset;
+
 pub const max_bytes = 10 * 1024 * 1024;
 pub const basename = "build.zig.zon";
 pub const Hash = std.crypto.hash.sha2.Sha256;
@@ -153,24 +162,6 @@ pub fn copyErrorsIntoBundle(
     }
 }
 
-const hex_charset = "0123456789abcdef";
-
-pub fn hex64(x: u64) [16]u8 {
-    var result: [16]u8 = undefined;
-    var i: usize = 0;
-    while (i < 8) : (i += 1) {
-        const byte = @as(u8, @truncate(x >> @as(u6, @intCast(8 * i))));
-        result[i * 2 + 0] = hex_charset[byte >> 4];
-        result[i * 2 + 1] = hex_charset[byte & 15];
-    }
-    return result;
-}
-
-test hex64 {
-    const s = "[" ++ hex64(0x12345678_abcdef00) ++ "]";
-    try std.testing.expectEqualStrings("[00efcdab78563412]", s);
-}
-
 pub fn hexDigest(digest: Digest) MultiHashHexDigest {
     var result: MultiHashHexDigest = undefined;
 
@@ -590,14 +581,6 @@ const Parse = struct {
     }
 };
 
-const Manifest = @This();
-const std = @import("std");
-const mem = std.mem;
-const Allocator = std.mem.Allocator;
-const assert = std.debug.assert;
-const Ast = std.zig.Ast;
-const testing = std.testing;
-
 test "basic" {
     const gpa = testing.allocator;
 

src/link.zig

@@ -1031,7 +1031,7 @@ pub fn spawnLld(
             error.NameTooLong => err: {
                 const s = fs.path.sep_str;
                 const rand_int = std.crypto.random.int(u64);
-                const rsp_path = "tmp" ++ s ++ Package.Manifest.hex64(rand_int) ++ ".rsp";
+                const rsp_path = "tmp" ++ s ++ std.fmt.hex(rand_int) ++ ".rsp";
 
                 const rsp_file = try comp.local_cache_directory.handle.createFileZ(rsp_path, .{});
                 defer comp.local_cache_directory.handle.deleteFileZ(rsp_path) catch |err|

src/main.zig

@@ -4746,7 +4746,7 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, args: []const []const u8) !void {
     // the strategy is to choose a temporary file name ahead of time, and then
     // read this file in the parent to obtain the results, in the case the child
     // exits with code 3.
-    const results_tmp_file_nonce = Package.Manifest.hex64(std.crypto.random.int(u64));
+    const results_tmp_file_nonce = std.fmt.hex(std.crypto.random.int(u64));
     try child_argv.append("-Z" ++ results_tmp_file_nonce);
 
     var color: Color = .auto;
@@ -7196,8 +7196,7 @@ fn createDependenciesModule(
     // Atomically create the file in a directory named after the hash of its contents.
     const basename = "dependencies.zig";
     const rand_int = std.crypto.random.int(u64);
-    const tmp_dir_sub_path = "tmp" ++ fs.path.sep_str ++
-        Package.Manifest.hex64(rand_int);
+    const tmp_dir_sub_path = "tmp" ++ fs.path.sep_str ++ std.fmt.hex(rand_int);
     {
         var tmp_dir = try local_cache_directory.handle.makeOpenPath(tmp_dir_sub_path, .{});
         defer tmp_dir.close();

test/incremental/hello

@@ -0,0 +1,15 @@
+#target=x86_64-linux
+#update=initial version
+#file=main.zig
+const std = @import("std");
+pub fn main() !void {
+    try std.io.getStdOut().writeAll("good morning\n");
+}
+#expect_stdout="good morning\n"
+#update=change the string
+#file=main.zig
+const std = @import("std");
+pub fn main() !void {
+    try std.io.getStdOut().writeAll("おはようございます\n");
+}
+#expect_stdout="おはようございます\n"

tools/incr-check.zig

@@ -0,0 +1,403 @@
+const std = @import("std");
+const fatal = std.process.fatal;
+const Allocator = std.mem.Allocator;
+
+pub fn main() !void {
+    var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer arena_instance.deinit();
+    const arena = arena_instance.allocator();
+
+    const args = try std.process.argsAlloc(arena);
+    const zig_exe = args[1];
+    const input_file_name = args[2];
+
+    const input_file_bytes = try std.fs.cwd().readFileAlloc(arena, input_file_name, std.math.maxInt(u32));
+    const case = try Case.parse(arena, input_file_bytes);
+
+    const prog_node = std.Progress.start(.{});
+    defer prog_node.end();
+
+    const rand_int = std.crypto.random.int(u64);
+    const tmp_dir_path = "tmp_" ++ std.fmt.hex(rand_int);
+    const tmp_dir = try std.fs.cwd().makeOpenPath(tmp_dir_path, .{});
+
+    const child_prog_node = prog_node.start("zig build-exe", 0);
+    defer child_prog_node.end();
+
+    var child = std.process.Child.init(&.{
+        // Convert incr-check-relative path to subprocess-relative path.
+        try std.fs.path.relative(arena, tmp_dir_path, zig_exe),
+        "build-exe",
+        case.root_source_file,
+        "-fno-llvm",
+        "-fno-lld",
+        "-fincremental",
+        "-target",
+        case.target_query,
+        "--cache-dir",
+        ".local-cache",
+        "--global-cache-dir",
+        ".global_cache",
+        "--listen=-",
+    }, arena);
+
+    child.stdin_behavior = .Pipe;
+    child.stdout_behavior = .Pipe;
+    child.stderr_behavior = .Pipe;
+    child.progress_node = child_prog_node;
+    child.cwd_dir = tmp_dir;
+    child.cwd = tmp_dir_path;
+
+    var eval: Eval = .{
+        .arena = arena,
+        .case = case,
+        .tmp_dir = tmp_dir,
+        .tmp_dir_path = tmp_dir_path,
+        .child = &child,
+    };
+
+    try child.spawn();
+
+    var poller = std.io.poll(arena, Eval.StreamEnum, .{
+        .stdout = child.stdout.?,
+        .stderr = child.stderr.?,
+    });
+    defer poller.deinit();
+
+    for (case.updates) |update| {
+        eval.write(update);
+        try eval.requestUpdate();
+        try eval.check(&poller, update);
+    }
+
+    try eval.end(&poller);
+
+    waitChild(&child);
+}
+
+const Eval = struct {
+    arena: Allocator,
+    case: Case,
+    tmp_dir: std.fs.Dir,
+    tmp_dir_path: []const u8,
+    child: *std.process.Child,
+
+    const StreamEnum = enum { stdout, stderr };
+    const Poller = std.io.Poller(StreamEnum);
+
+    /// Currently this function assumes the previous updates have already been written.
+    fn write(eval: *Eval, update: Case.Update) void {
+        for (update.changes) |full_contents| {
+            eval.tmp_dir.writeFile(.{
+                .sub_path = full_contents.name,
+                .data = full_contents.bytes,
+            }) catch |err| {
+                fatal("failed to update '{s}': {s}", .{ full_contents.name, @errorName(err) });
+            };
+        }
+        for (update.deletes) |doomed_name| {
+            eval.tmp_dir.deleteFile(doomed_name) catch |err| {
+                fatal("failed to delete '{s}': {s}", .{ doomed_name, @errorName(err) });
+            };
+        }
+    }
+
+    fn check(eval: *Eval, poller: *Poller, update: Case.Update) !void {
+        const arena = eval.arena;
+        const Header = std.zig.Server.Message.Header;
+        const stdout = poller.fifo(.stdout);
+        const stderr = poller.fifo(.stderr);
+
+        poll: while (true) {
+            while (stdout.readableLength() < @sizeOf(Header)) {
+                if (!(try poller.poll())) break :poll;
+            }
+            const header = stdout.reader().readStruct(Header) catch unreachable;
+            while (stdout.readableLength() < header.bytes_len) {
+                if (!(try poller.poll())) break :poll;
+            }
+            const body = stdout.readableSliceOfLen(header.bytes_len);
+
+            switch (header.tag) {
+                .error_bundle => {
+                    const EbHdr = std.zig.Server.Message.ErrorBundle;
+                    const eb_hdr = @as(*align(1) const EbHdr, @ptrCast(body));
+                    const extra_bytes =
+                        body[@sizeOf(EbHdr)..][0 .. @sizeOf(u32) * eb_hdr.extra_len];
+                    const string_bytes =
+                        body[@sizeOf(EbHdr) + extra_bytes.len ..][0..eb_hdr.string_bytes_len];
+                    // TODO: use @ptrCast when the compiler supports it
+                    const unaligned_extra = std.mem.bytesAsSlice(u32, extra_bytes);
+                    const extra_array = try arena.alloc(u32, unaligned_extra.len);
+                    @memcpy(extra_array, unaligned_extra);
+                    const result_error_bundle: std.zig.ErrorBundle = .{
+                        .string_bytes = try arena.dupe(u8, string_bytes),
+                        .extra = extra_array,
+                    };
+                    if (stderr.readableLength() > 0) {
+                        const stderr_data = try stderr.toOwnedSlice();
+                        fatal("error_bundle included unexpected stderr:\n{s}", .{stderr_data});
+                    }
+                    try eval.checkErrorOutcome(update, result_error_bundle);
+                    // This message indicates the end of the update.
+                    stdout.discard(body.len);
+                    return;
+                },
+                .emit_bin_path => {
+                    const EbpHdr = std.zig.Server.Message.EmitBinPath;
+                    const ebp_hdr = @as(*align(1) const EbpHdr, @ptrCast(body));
+                    _ = ebp_hdr;
+                    const result_binary = try arena.dupe(u8, body[@sizeOf(EbpHdr)..]);
+                    if (stderr.readableLength() > 0) {
+                        const stderr_data = try stderr.toOwnedSlice();
+                        fatal("emit_bin_path included unexpected stderr:\n{s}", .{stderr_data});
+                    }
+                    try eval.checkSuccessOutcome(update, result_binary);
+                    // This message indicates the end of the update.
+                    stdout.discard(body.len);
+                    return;
+                },
+                else => {
+                    // Ignore other messages.
+                    stdout.discard(body.len);
+                },
+            }
+        }
+
+        if (stderr.readableLength() > 0) {
+            const stderr_data = try stderr.toOwnedSlice();
+            fatal("update '{s}' failed:\n{s}", .{ update.name, stderr_data });
+        }
+
+        waitChild(eval.child);
+        fatal("update '{s}': compiler failed to send error_bundle or emit_bin_path", .{update.name});
+    }
+
+    fn checkErrorOutcome(eval: *Eval, update: Case.Update, error_bundle: std.zig.ErrorBundle) !void {
+        _ = eval;
+        switch (update.outcome) {
+            .unknown => return,
+            .compile_errors => |expected_errors| {
+                for (expected_errors) |expected_error| {
+                    _ = expected_error;
+                    @panic("TODO check if the expected error matches the compile errors");
+                }
+            },
+            .stdout, .exit_code => {
+                const color: std.zig.Color = .auto;
+                error_bundle.renderToStdErr(color.renderOptions());
+                fatal("update '{s}': unexpected compile errors", .{update.name});
+            },
+        }
+    }
+
+    fn checkSuccessOutcome(eval: *Eval, update: Case.Update, binary_path: []const u8) !void {
+        switch (update.outcome) {
+            .unknown => return,
+            .compile_errors => fatal("expected compile errors but compilation incorrectly succeeded", .{}),
+            .stdout, .exit_code => {},
+        }
+        const result = std.process.Child.run(.{
+            .allocator = eval.arena,
+            .argv = &.{binary_path},
+            .cwd_dir = eval.tmp_dir,
+            .cwd = eval.tmp_dir_path,
+        }) catch |err| {
+            fatal("update '{s}': failed to run the generated executable '{s}': {s}", .{
+                update.name, binary_path, @errorName(err),
+            });
+        };
+        if (result.stderr.len != 0) {
+            std.log.err("update '{s}': generated executable '{s}' had unexpected stderr:\n{s}", .{
+                update.name, binary_path, result.stderr,
+            });
+        }
+        switch (result.term) {
+            .Exited => |code| switch (update.outcome) {
+                .unknown, .compile_errors => unreachable,
+                .stdout => |expected_stdout| {
+                    if (code != 0) {
+                        fatal("update '{s}': generated executable '{s}' failed with code {d}", .{
+                            update.name, binary_path, code,
+                        });
+                    }
+                    try std.testing.expectEqualStrings(expected_stdout, result.stdout);
+                },
+                .exit_code => |expected_code| try std.testing.expectEqual(expected_code, result.term.Exited),
+            },
+            .Signal, .Stopped, .Unknown => {
+                fatal("update '{s}': generated executable '{s}' terminated unexpectedly", .{
+                    update.name, binary_path,
+                });
+            },
+        }
+        if (result.stderr.len != 0) std.process.exit(1);
+    }
+
+    fn requestUpdate(eval: *Eval) !void {
+        const header: std.zig.Client.Message.Header = .{
+            .tag = .update,
+            .bytes_len = 0,
+        };
+        try eval.child.stdin.?.writeAll(std.mem.asBytes(&header));
+    }
+
+    fn end(eval: *Eval, poller: *Poller) !void {
+        requestExit(eval.child);
+
+        const Header = std.zig.Server.Message.Header;
+        const stdout = poller.fifo(.stdout);
+        const stderr = poller.fifo(.stderr);
+
+        poll: while (true) {
+            while (stdout.readableLength() < @sizeOf(Header)) {
+                if (!(try poller.poll())) break :poll;
+            }
+            const header = stdout.reader().readStruct(Header) catch unreachable;
+            while (stdout.readableLength() < header.bytes_len) {
+                if (!(try poller.poll())) break :poll;
+            }
+            const body = stdout.readableSliceOfLen(header.bytes_len);
+            stdout.discard(body.len);
+        }
+
+        if (stderr.readableLength() > 0) {
+            const stderr_data = try stderr.toOwnedSlice();
+            fatal("unexpected stderr:\n{s}", .{stderr_data});
+        }
+    }
+};
+
+const Case = struct {
+    updates: []Update,
+    root_source_file: []const u8,
+    target_query: []const u8,
+
+    const Update = struct {
+        name: []const u8,
+        outcome: Outcome,
+        changes: []const FullContents = &.{},
+        deletes: []const []const u8 = &.{},
+    };
+
+    const FullContents = struct {
+        name: []const u8,
+        bytes: []const u8,
+    };
+
+    const Outcome = union(enum) {
+        unknown,
+        compile_errors: []const ExpectedError,
+        stdout: []const u8,
+        exit_code: u8,
+    };
+
+    const ExpectedError = struct {
+        file_name: ?[]const u8 = null,
+        line: ?u32 = null,
+        column: ?u32 = null,
+        msg_exact: ?[]const u8 = null,
+        msg_substring: ?[]const u8 = null,
+    };
+
+    fn parse(arena: Allocator, bytes: []const u8) !Case {
+        var updates: std.ArrayListUnmanaged(Update) = .{};
+        var changes: std.ArrayListUnmanaged(FullContents) = .{};
+        var target_query: ?[]const u8 = null;
+        var it = std.mem.splitScalar(u8, bytes, '\n');
+        var line_n: usize = 1;
+        var root_source_file: ?[]const u8 = null;
+        while (it.next()) |line| : (line_n += 1) {
+            if (std.mem.startsWith(u8, line, "#")) {
+                var line_it = std.mem.splitScalar(u8, line, '=');
+                const key = line_it.first()[1..];
+                const val = line_it.rest();
+                if (val.len == 0) {
+                    fatal("line {d}: missing value", .{line_n});
+                } else if (std.mem.eql(u8, key, "target")) {
+                    if (target_query != null) fatal("line {d}: duplicate target", .{line_n});
+                    target_query = val;
+                } else if (std.mem.eql(u8, key, "update")) {
+                    if (updates.items.len > 0) {
+                        const last_update = &updates.items[updates.items.len - 1];
+                        last_update.changes = try changes.toOwnedSlice(arena);
+                    }
+                    try updates.append(arena, .{
+                        .name = val,
+                        .outcome = .unknown,
+                    });
+                } else if (std.mem.eql(u8, key, "file")) {
+                    if (updates.items.len == 0) fatal("line {d}: expect directive before update", .{line_n});
+
+                    if (root_source_file == null)
+                        root_source_file = val;
+
+                    const start_index = it.index.?;
+                    const src = while (true) : (line_n += 1) {
+                        const old = it;
+                        const next_line = it.next() orelse fatal("line {d}: unexpected EOF", .{line_n});
+                        if (std.mem.startsWith(u8, next_line, "#")) {
+                            const end_index = old.index.?;
+                            const src = bytes[start_index..end_index];
+                            it = old;
+                            break src;
+                        }
+                    };
+
+                    try changes.append(arena, .{
+                        .name = val,
+                        .bytes = src,
+                    });
+                } else if (std.mem.eql(u8, key, "expect_stdout")) {
+                    if (updates.items.len == 0) fatal("line {d}: expect directive before update", .{line_n});
+                    const last_update = &updates.items[updates.items.len - 1];
+                    if (last_update.outcome != .unknown) fatal("line {d}: conflicting expect directive", .{line_n});
+                    last_update.outcome = .{
+                        .stdout = std.zig.string_literal.parseAlloc(arena, val) catch |err| {
+                            fatal("line {d}: bad string literal: {s}", .{ line_n, @errorName(err) });
+                        },
+                    };
+                } else {
+                    fatal("line {d}: unrecognized key '{s}'", .{ line_n, key });
+                }
+            }
+        }
+
+        if (changes.items.len > 0) {
+            const last_update = &updates.items[updates.items.len - 1];
+            last_update.changes = try changes.toOwnedSlice(arena);
+        }
+
+        return .{
+            .updates = updates.items,
+            .root_source_file = root_source_file orelse fatal("missing root source file", .{}),
+            .target_query = target_query orelse fatal("missing target", .{}),
+        };
+    }
+};
+
+fn requestExit(child: *std.process.Child) void {
+    if (child.stdin == null) return;
+
+    const header: std.zig.Client.Message.Header = .{
+        .tag = .exit,
+        .bytes_len = 0,
+    };
+    child.stdin.?.writeAll(std.mem.asBytes(&header)) catch |err| switch (err) {
+        error.BrokenPipe => {},
+        else => fatal("failed to send exit: {s}", .{@errorName(err)}),
+    };
+
+    // Send EOF to stdin.
+    child.stdin.?.close();
+    child.stdin = null;
+}
+
+fn waitChild(child: *std.process.Child) void {
+    requestExit(child);
+    const term = child.wait() catch |err| fatal("child process failed: {s}", .{@errorName(err)});
+    switch (term) {
+        .Exited => |code| if (code != 0) fatal("compiler failed with code {d}", .{code}),
+        .Signal, .Stopped, .Unknown => fatal("compiler terminated unexpectedly", .{}),
+    }
+}