Commit 6e025fc2e298c633ab36e9058a2cc610f57e4522 | zig

author	Andrew Kelley <andrew@ziglang.org> 2024-07-05 12:24:32-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2024-07-12 00:14:07-07:00
log	6e025fc2e298c633ab36e9058a2cc610f57e4522
tree	dc58c61d22da365eaae0321de0af242f250b43c6
parent	d2bec8f92f15ac16a0714ddc8282ab31dd5bb889

build system: add --watch flag and report source file in InstallFile

This direction is not quite right because it mutates shared state in a
threaded context, so the next commit will need to fix this.

4 files changed, 147 insertions(+), 21 deletions(-)

lib
- compiler
  - build_runner.zig
- std
  - Build.zig
  - Build
    Step.zig
    Step
    InstallFile.zig

lib/compiler/build_runner.zig+45-21

 @@ -74,6 +74,7 @@ pub fn main() !void {
             .query = .{},
             .result = try std.zig.system.resolveTargetQuery(.{}),
         },
+        .watch = null,
     };
     graph.cache.addPrefix(.{ .path = null, .handle = std.fs.cwd() });
 @@ -97,12 +98,12 @@ pub fn main() !void {
     var dir_list = std.Build.DirList{};
     var summary: ?Summary = null;
     var max_rss: u64 = 0;
-    var skip_oom_steps: bool = false;
+    var skip_oom_steps = false;
     var color: Color = .auto;
     var seed: u32 = 0;
-    var prominent_compile_errors: bool = false;
+    var prominent_compile_errors = false;
-    var help_menu: bool = false;
+    var help_menu = false;
-    var steps_menu: bool = false;
+    var steps_menu = false;
     var output_tmp_nonce: ?[16]u8 = null;
     while (nextArg(args, &arg_idx)) |arg| {
 @@ -227,6 +228,10 @@ pub fn main() !void {
                 builder.verbose_llvm_cpu_features = true;
             } else if (mem.eql(u8, arg, "--prominent-compile-errors")) {
                 prominent_compile_errors = true;
+            } else if (mem.eql(u8, arg, "--watch")) {
+                const watch = try arena.create(std.Build.Watch);
+                watch.* = std.Build.Watch.init;
+                graph.watch = watch;
             } else if (mem.eql(u8, arg, "-fwine")) {
                 builder.enable_wine = true;
             } else if (mem.eql(u8, arg, "-fno-wine")) {
 @@ -344,7 +349,7 @@ pub fn main() !void {
         .prominent_compile_errors = prominent_compile_errors,
         .claimed_rss = 0,
-        .summary = summary,
+        .summary = summary orelse if (graph.watch != null) .new else .failures,
         .ttyconf = ttyconf,
         .stderr = stderr,
     };
 @@ -363,7 +368,10 @@ pub fn main() !void {
         &run,
         seed,
     ) catch |err| switch (err) {
-        error.UncleanExit => process.exit(1),
+        error.UncleanExit => {
+            if (graph.watch == null)
+                process.exit(1);
+        },
         else => return err,
     };
 }
 @@ -377,7 +385,7 @@ const Run = struct {
     prominent_compile_errors: bool,
     claimed_rss: usize,
-    summary: ?Summary,
+    summary: Summary,
     ttyconf: std.io.tty.Config,
     stderr: File,
 };
 @@ -417,7 +425,7 @@ fn runStepNames(
     for (starting_steps) |s| {
         constructGraphAndCheckForDependencyLoop(b, s, &step_stack, rand) catch |err| switch (err) {
-            error.DependencyLoopDetected => return error.UncleanExit,
+            error.DependencyLoopDetected => return uncleanExit(),
             else => |e| return e,
         };
     }
 @@ -442,7 +450,7 @@ fn runStepNames(
             if (run.max_rss_is_default) {
                 std.debug.print("note: use --maxrss to override the default", .{});
             }
-            return error.UncleanExit;
+            return uncleanExit();
         }
     }
 @@ -524,13 +532,19 @@ fn runStepNames(
     // A proper command line application defaults to silently succeeding.
     // The user may request verbose mode if they have a different preference.
-    const failures_only = run.summary != .all and run.summary != .new;
+    const failures_only = switch (run.summary) {
-    if (failure_count == 0 and failures_only) return cleanExit();
+        .failures, .none => true,
+        else => false,
+    };
+    if (failure_count == 0 and failures_only) {
+        if (b.graph.watch != null) return;
+        return cleanExit();
+    }
     const ttyconf = run.ttyconf;
     const stderr = run.stderr;
-    if (run.summary != Summary.none) {
+    if (run.summary != .none) {
         const total_count = success_count + failure_count + pending_count + skipped_count;
         ttyconf.setColor(stderr, .cyan) catch {};
         stderr.writeAll("Build Summary:") catch {};
 @@ -544,11 +558,6 @@ fn runStepNames(
         if (test_fail_count > 0) stderr.writer().print("; {d} failed", .{test_fail_count}) catch {};
         if (test_leak_count > 0) stderr.writer().print("; {d} leaked", .{test_leak_count}) catch {};
-        if (run.summary == null) {
-            ttyconf.setColor(stderr, .dim) catch {};
-            stderr.writeAll(" (disable with --summary none)") catch {};
-            ttyconf.setColor(stderr, .reset) catch {};
-        }
         stderr.writeAll("\n") catch {};
         // Print a fancy tree with build results.
 @@ -562,7 +571,7 @@ fn runStepNames(
                 while (i > 0) {
                     i -= 1;
                     const step = b.top_level_steps.get(step_names[i]).?.step;
-                    const found = switch (run.summary orelse .failures) {
+                    const found = switch (run.summary) {
                         .all, .none => unreachable,
                         .failures => step.state != .success,
                         .new => !step.result_cached,
 @@ -579,7 +588,10 @@ fn runStepNames(
         }
     }
-    if (failure_count == 0) return cleanExit();
+    if (failure_count == 0) {
+        if (b.graph.watch != null) return;
+        return cleanExit();
+    }
     // Finally, render compile errors at the bottom of the terminal.
     // We use a separate compile_error_steps array list because step_stack is destructively
 @@ -591,13 +603,24 @@ fn runStepNames(
             }
         }
+        if (b.graph.watch != null) return uncleanExit();
         // Signal to parent process that we have printed compile errors. The
         // parent process may choose to omit the "following command failed"
         // line in this case.
         process.exit(2);
     }
-    process.exit(1);
+    return uncleanExit();
+}
+fn uncleanExit() error{UncleanExit}!void {
+    if (builtin.mode == .Debug) {
+        return error.UncleanExit;
+    } else {
+        std.debug.lockStdErr();
+        process.exit(1);
+    }
 }
 const PrintNode = struct {
 @@ -768,7 +791,7 @@ fn printTreeStep(
     step_stack: *std.AutoArrayHashMapUnmanaged(*Step, void),
 ) !void {
     const first = step_stack.swapRemove(s);
-    const summary = run.summary orelse .failures;
+    const summary = run.summary;
     const skip = switch (summary) {
         .none => unreachable,
         .all => false,
 @@ -1124,6 +1147,7 @@ fn usage(b: *std.Build, out_stream: anytype) !void {
         \\  --maxrss <bytes>             Limit memory usage (default is to use available memory)
         \\  --skip-oom-steps             Instead of failing, skip steps that would exceed --maxrss
         \\  --fetch                      Exit after fetching dependency tree
+        \\  --watch                      Continuously rebuild when source files are modified
         \\
         \\Project-Specific Options:
         \\

lib/std/Build.zig+55

...	@@ -120,6 +120,61 @@ pub const Graph = struct {	...	@@ -120,6 +120,61 @@ pub const Graph = struct {
120	needed_lazy_dependencies: std.StringArrayHashMapUnmanaged(void) = .{},	120	needed_lazy_dependencies: std.StringArrayHashMapUnmanaged(void) = .{},
121	/// Information about the native target. Computed before build() is invoked.	121	/// Information about the native target. Computed before build() is invoked.
122	host: ResolvedTarget,	122	host: ResolvedTarget,
		123	/// When `--watch` is provided, collects the set of files that should be
		124	/// watched and the state to required to poll the system for changes.
		125	watch: ?*Watch,
		126	};
		127
		128	pub const Watch = struct {
		129	table: Table,
		130
		131	pub const init: Watch = .{
		132	.table = .{},
		133	};
		134
		135	/// Key is the directory to watch which contains one or more files we are
		136	/// interested in noticing changes to.
		137	pub const Table = std.ArrayHashMapUnmanaged(Cache.Path, ReactionSet, TableContext, false);
		138
		139	const Hash = std.hash.Wyhash;
		140
		141	pub const TableContext = struct {
		142	pub fn hash(self: TableContext, a: Cache.Path) u32 {
		143	_ = self;
		144	const seed: u32 = @bitCast(a.root_dir.handle.fd);
		145	return @truncate(Hash.hash(seed, a.sub_path));
		146	}
		147	pub fn eql(self: TableContext, a: Cache.Path, b: Cache.Path, b_index: usize) bool {
		148	_ = self;
		149	_ = b_index;
		150	return a.eql(b);
		151	}
		152	};
		153
		154	pub const ReactionSet = std.ArrayHashMapUnmanaged(Match, void, Match.Context, false);
		155
		156	pub const Match = struct {
		157	/// Relative to the watched directory, the file path that triggers this
		158	/// match.
		159	basename: []const u8,
		160	/// The step to re-run when file corresponding to `basename` is changed.
		161	step: *Step,
		162
		163	pub const Context = struct {
		164	pub fn hash(self: Context, a: Match) u32 {
		165	_ = self;
		166	var hasher = Hash.init(0);
		167	std.hash.autoHash(&hasher, a.step);
		168	hasher.update(a.basename);
		169	return @truncate(hasher.final());
		170	}
		171	pub fn eql(self: Context, a: Match, b: Match, b_index: usize) bool {
		172	_ = self;
		173	_ = b_index;
		174	return a.step == b.step and mem.eql(u8, a.basename, b.basename);
		175	}
		176	};
		177	};
123	};	178	};
124		179
125	const AvailableDeps = []const struct { []const u8, []const u8 };	180	const AvailableDeps = []const struct { []const u8, []const u8 };

lib/std/Build/Step.zig+46

...	@@ -562,6 +562,52 @@ pub fn writeManifest(s: Step, man: std.Build.Cache.Manifest) !void {	...	@@ -562,6 +562,52 @@ pub fn writeManifest(s: Step, man: std.Build.Cache.Manifest) !void {
562	}	562	}
563	}	563	}
564		564
		565	fn oom(err: anytype) noreturn {
		566	switch (err) {
		567	error.OutOfMemory => @panic("out of memory"),
		568	}
		569	}
		570
		571	pub fn addWatchInput(step: *Step, lazy_path: std.Build.LazyPath) void {
		572	errdefer \|err\| oom(err);
		573	const w = step.owner.graph.watch orelse return;
		574	switch (lazy_path) {
		575	.src_path => \|src_path\| try addWatchInputFromBuilder(step, w, src_path.owner, src_path.sub_path),
		576	.dependency => \|d\| try addWatchInputFromBuilder(step, w, d.dependency.builder, d.sub_path),
		577	.cwd_relative => \|path_string\| {
		578	try addWatchInputFromPath(w, .{
		579	.root_dir = .{
		580	.path = null,
		581	.handle = std.fs.cwd(),
		582	},
		583	.sub_path = std.fs.path.dirname(path_string) orelse "",
		584	}, .{
		585	.step = step,
		586	.basename = std.fs.path.basename(path_string),
		587	});
		588	},
		589	// Nothing to watch because this dependency edge is modeled instead via `dependants`.
		590	.generated => {},
		591	}
		592	}
		593
		594	fn addWatchInputFromBuilder(step: Step, w: std.Build.Watch, builder: *std.Build, sub_path: []const u8) !void {
		595	return addWatchInputFromPath(w, .{
		596	.root_dir = builder.build_root,
		597	.sub_path = std.fs.path.dirname(sub_path) orelse "",
		598	}, .{
		599	.step = step,
		600	.basename = std.fs.path.basename(sub_path),
		601	});
		602	}
		603
		604	fn addWatchInputFromPath(w: *std.Build.Watch, path: std.Build.Cache.Path, match: std.Build.Watch.Match) !void {
		605	const gpa = match.step.owner.allocator;
		606	const gop = try w.table.getOrPut(gpa, path);
		607	if (!gop.found_existing) gop.value_ptr.* = .{};
		608	try gop.value_ptr.put(gpa, match, {});
		609	}
		610
565	test {	611	test {
566	_ = CheckFile;	612	_ = CheckFile;
567	_ = CheckObject;	613	_ = CheckObject;

lib/std/Build/Step/InstallFile.zig+1

...	@@ -40,6 +40,7 @@ fn make(step: *Step, prog_node: std.Progress.Node) !void {	...	@@ -40,6 +40,7 @@ fn make(step: *Step, prog_node: std.Progress.Node) !void {
40	_ = prog_node;	40	_ = prog_node;
41	const b = step.owner;	41	const b = step.owner;
42	const install_file: *InstallFile = @fieldParentPtr("step", step);	42	const install_file: *InstallFile = @fieldParentPtr("step", step);
		43	step.addWatchInput(install_file.source);
43	const full_src_path = install_file.source.getPath2(b, step);	44	const full_src_path = install_file.source.getPath2(b, step);
44	const full_dest_path = b.getInstallPath(install_file.dir, install_file.dest_rel_path);	45	const full_dest_path = b.getInstallPath(install_file.dir, install_file.dest_rel_path);
45	const cwd = std.fs.cwd();	46	const cwd = std.fs.cwd();