Commit c106e2759578e787e5be235c8f6b227623ff2c3b | zig

author	Andrew Kelley <andrew@ziglang.org> 2026-09-17 21:04:22-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2026-09-17 21:04:22-07:00
log	c106e2759578e787e5be235c8f6b227623ff2c3b
tree	35589932ad26dbc7f28b4e8db6346395863cd5fe
parent	b27aacf8207bab54f62bfe78b25d05a0a758d99d

std.Build.Step.Options: add addOptionPathDirectory

Now, when adding an option that is a file path, one must explicitly
choose between:
* `addOptionPath` (must be a file)
* `addOptionPathDirectory` (must be a directory)
* `addOptionPathUntracked` (opt out of dependency tracking)

closes #35766

4 files changed, 67 insertions(+), 25 deletions(-)

lib
- compiler
  - Maker
    Step
    Options.zig
- std
  - Build
    Configuration.zig
    Serialize.zig
    Step
    Options.zig

lib/compiler/Maker/Step/Options.zig+16-3

 @@ -30,7 +30,7 @@ pub fn make(
     // generated zig file are observable by dependant steps.
     // Pathnames added to Options.args are assumed to be generated files whose
     // contents are also observable, while pathnames added to
-    // Options.args_untracked are treated as pure path string data with no
+    // Options.untracked_paths are treated as pure path string data with no
     // tracking of the path's state or contents.
     step.clearWatchInputs(maker);
 @@ -40,7 +40,7 @@ pub fn make(
     var args_bytes: std.ArrayList(u8) = .empty;
-    for (conf_options.args.slice) |arg| {
+    for (conf_options.files.slice) |arg| {
         const name = arg.name.slice(conf);
         const lazy_path = arg.path.get(conf);
         try step.addWatchInput(maker, arena, lazy_path);
 @@ -51,7 +51,20 @@ pub fn make(
         });
     }
-    for (conf_options.args_untracked.slice) |arg| {
+    for (conf_options.directories.slice) |arg| {
+        const name = arg.name.slice(conf);
+        const lazy_path = arg.path.get(conf);
+        _ = try step.addDirectoryWatchInput(maker, lazy_path);
+        const arg_path = try maker.resolveLazyPath(arena, lazy_path, step_index);
+        _ = try man.addInputPath(arg_path, .{
+            .handle = .{ .dir = null },
+        });
+        try args_bytes.print(arena, "pub const {f}: []const u8 = \"{f}\";\n", .{
+            std.zig.fmtId(name), arg_path.fmtEscapeString(),
+        });
+    }
+    for (conf_options.untracked_paths.slice) |arg| {
         const name = arg.name.slice(conf);
         const lazy_path = arg.path.get(conf);
         const arg_path = try maker.resolveLazyPath(arena, lazy_path, step_index);

lib/std/Build/Configuration.zig+8-6

 @@ -1378,19 +1378,21 @@ pub const Step = extern struct {
         flags: @This().Flags,
         generated_file: GeneratedFileIndex,
         contents: Bytes,
-        args: Storage.FlagLengthPrefixedList(.flags, .args, Arg),
+        files: Storage.FlagLengthPrefixedList(.flags, .files, NamedPath),
-        args_untracked: Storage.FlagLengthPrefixedList(.flags, .args_untracked, Arg),
+        directories: Storage.FlagLengthPrefixedList(.flags, .directories, NamedPath),
+        untracked_paths: Storage.FlagLengthPrefixedList(.flags, .untracked_paths, NamedPath),
-        pub const Arg = extern struct {
+        pub const NamedPath = extern struct {
             name: String,
             path: LazyPath.Index,
         };
         pub const Flags = packed struct(u32) {
             tag: Tag = .options,
-            args: bool,
+            files: bool,
-            args_untracked: bool,
+            directories: bool,
-            _: u25 = 0,
+            untracked_paths: bool,
+            _: u24 = 0,
         };
     };

lib/std/Build/Serialize.zig+16-8

 @@ -648,27 +648,35 @@ pub fn write(b: *std.Build, wc: *Configuration.Wip, writer: *std.Io.Writer) !voi
                     .options => e: {
                         const so: *Step.Options = @fieldParentPtr("step", step);
-                        const args = try arena.alloc(Configuration.Step.Options.Arg, so.args.items.len);
+                        const files = try arena.alloc(Configuration.Step.Options.NamedPath, so.files.items.len);
-                        for (args, so.args.items) |*dest, src| dest.* = .{
+                        for (files, so.files.items) |*dest, src| dest.* = .{
                             .name = src.name,
                             .path = try s.addLazyPath(src.path),
                         };
-                        const args_untracked = try arena.alloc(Configuration.Step.Options.Arg, so.args_untracked.items.len);
+                        const directories = try arena.alloc(Configuration.Step.Options.NamedPath, so.directories.items.len);
-                        for (args_untracked, so.args_untracked.items) |*dest, src| dest.* = .{
+                        for (directories, so.directories.items) |*dest, src| dest.* = .{
+                            .name = src.name,
+                            .path = try s.addLazyPath(src.path),
+                        };
+                        const untracked_paths = try arena.alloc(Configuration.Step.Options.NamedPath, so.untracked_paths.items.len);
+                        for (untracked_paths, so.untracked_paths.items) |*dest, src| dest.* = .{
                             .name = src.name,
                             .path = try s.addLazyPath(src.path),
                         };
                         break :e try wc.addExtraErased(Configuration.Step.Options, .{
                             .flags = .{
-                                .args = so.args.items.len != 0,
+                                .files = so.files.items.len != 0,
-                                .args_untracked = so.args_untracked.items.len != 0,
+                                .directories = so.directories.items.len != 0,
+                                .untracked_paths = so.untracked_paths.items.len != 0,
                             },
                             .generated_file = so.generated_file,
                             .contents = try wc.addBytes(so.contents.items),
-                            .args = .{ .slice = args },
+                            .files = .{ .slice = files },
-                            .args_untracked = .{ .slice = args_untracked },
+                            .directories = .{ .slice = directories },
+                            .untracked_paths = .{ .slice = untracked_paths },
                         });
                     },
                 })),

lib/std/Build/Step/Options.zig+27-8

 @@ -12,13 +12,14 @@ const Configuration = std.Build.Configuration;
 step: Step,
 generated_file: Configuration.GeneratedFileIndex,
 contents: std.ArrayList(u8) = .empty,
-args: std.ArrayList(Arg) = .empty,
+files: std.ArrayList(NamedPath) = .empty,
-args_untracked: std.ArrayList(Arg) = .empty,
+directories: std.ArrayList(NamedPath) = .empty,
+untracked_paths: std.ArrayList(NamedPath) = .empty,
 encountered_types: std.StringHashMapUnmanaged(void),
 pub const base_tag: Step.Tag = .options;
-pub const Arg = struct {
+pub const NamedPath = struct {
     name: Configuration.String,
     path: LazyPath,
 };
 @@ -421,18 +422,36 @@ fn printStructValue(
     }
 }
-/// The added option has type `[]const u8` and value of the provided path.
+/// The added option has type `[]const u8` and value of the provided file path. If the provided path is a
-/// This interface assumes the provided path is a generated file, and causes a
+/// generated file, causes a transitive dependency on the file's contents.
-/// transitive dependency through Options on the file's contents.
 ///
 /// See also:
+/// * `addOptionPathDirectory`
 /// * `addOptionPathUntracked`
 pub fn addOptionPath(options: *Options, name: []const u8, path: LazyPath) void {
     const graph = options.step.owner.graph;
     const arena = graph.arena;
     const wc = &graph.wip_configuration;
-    options.args.append(arena, .{
+    options.files.append(arena, .{
+        .name = wc.addString(name) catch @panic("OOM"),
+        .path = path.dupe(options.step.owner.graph),
+    }) catch @panic("OOM");
+    path.addStepDependencies(&options.step);
+}
+/// The added option has type `[]const u8` and value of the provided directory path. Causes a transitive
+/// dependency through Options on the directory's contents.
+///
+/// See also:
+/// * `addOptionPath`
+/// * `addOptionPathUntracked`
+pub fn addOptionPathDirectory(options: *Options, name: []const u8, path: LazyPath) void {
+    const graph = options.step.owner.graph;
+    const arena = graph.arena;
+    const wc = &graph.wip_configuration;
+    options.directories.append(arena, .{
         .name = wc.addString(name) catch @panic("OOM"),
         .path = path.dupe(options.step.owner.graph),
     }) catch @panic("OOM");
 @@ -450,7 +469,7 @@ pub fn addOptionPathUntracked(options: *Options, name: []const u8, path: LazyPat
     const arena = graph.arena;
     const wc = &graph.wip_configuration;
-    options.args_untracked.append(arena, .{
+    options.untracked_paths.append(arena, .{
         .name = wc.addString(name) catch @panic("OOM"),
         .path = path.dupe(options.step.owner.graph),
     }) catch @panic("OOM");