Commit c3cdf484072d84f32e19c9286071a913269c90e9 | zig

author	Andrew Kelley <andrew@ziglang.org> 2026-10-15 16:37:06-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2026-10-15 16:37:06-07:00
log	c3cdf484072d84f32e19c9286071a913269c90e9
tree	a0be35e5e6b163f80eb94d4e8131d6de1754d1a6
parent	2c18bccf4428a6e23ed5c5572243337a560af9b5

Configuration: store unlazy dependencies differently

steps are many; unlazy dependencies are few

4 files changed, 57 insertions(+), 24 deletions(-)

lib
- compiler
  - Maker.zig
  - Maker
    ScannedConfig.zig
- std
  - Build
    Configuration.zig
    Serialize.zig

lib/compiler/Maker.zig+16-8

 @@ -1608,16 +1608,24 @@ fn configure(graph: *Graph, options: ConfigureOptions) !ScannedConfig {
         if (configuration.unlazy_deps.len != 0) {
             var any_errors = false;
-            for (configuration.unlazy_deps) |hash_string| {
+            for (configuration.unlazy_deps) |unlazy_dep| {
-                const hash = hash_string.slice(&configuration);
+                if (unlazy_dep.step.unwrap()) |step_index| {
-                assert(hash.len != 0);
+                    log.err("TODO implement step-associated lazy dependencies in maker", .{});
-                if (hash.len > Package.Hash.max_len) {
-                    log.err("invalid digest (length {d} exceeds maximum): {q}", .{ hash.len, hash });
                     any_errors = true;
-                    continue;
+                    _ = step_index;
+                } else {
+                    for (unlazy_dep.list.slice(&configuration)) |hash_string| {
+                        const hash = hash_string.slice(&configuration);
+                        assert(hash.len != 0);
+                        if (hash.len > Package.Hash.max_len) {
+                            log.err("invalid digest (length {d} exceeds maximum): {q}", .{ hash.len, hash });
+                            any_errors = true;
+                            continue;
+                        }
+                        log.info("fetching lazy dependency {s}", .{hash});
+                        try unlazy_set.put(arena, .fromSlice(hash), {});
+                    }
                 }
-                log.info("fetching lazy dependency {s}", .{hash});
-                try unlazy_set.put(arena, .fromSlice(hash), {});
             }
             if (any_errors) return error.FailedButCacheIntact;
             if (options.system_pkg_dir_path) |p| {

lib/compiler/Maker/ScannedConfig.zig+3-1

 @@ -55,7 +55,9 @@ pub fn print(sc: *const ScannedConfig, w: *Writer) Writer.Error!void {
     {
         var tf = try s.beginTupleField("unlazy_deps", .{});
         for (c.unlazy_deps) |dep| {
-            try tf.field(dep.slice(c), .{});
+            var field = try tf.beginStructField(.{});
+            try printStruct(sc, &field, Configuration.UnlazyDep, dep);
+            try field.end();
         }
         try tf.end();
     }

lib/std/Build/Configuration.zig+26-4

 @@ -11,7 +11,7 @@ const native_endian = builtin.target.cpu.arch.endian();
 string_bytes: []u8,
 steps: []Step,
 path_deps: []PathDep,
-unlazy_deps: []String,
+unlazy_deps: []UnlazyDep,
 system_integrations: []SystemIntegration,
 available_options: []AvailableOption,
 search_prefixes: []String,
 @@ -52,7 +52,7 @@ pub const Wip = struct {
     targets_table: TargetsTable = .empty,
     string_bytes: std.ArrayList(u8) = .empty,
-    unlazy_deps: std.ArrayList(String) = .empty,
+    unlazy_deps: std.ArrayList(UnlazyDep) = .empty,
     system_integrations: std.ArrayList(SystemIntegration) = .empty,
     available_options: std.ArrayList(AvailableOption) = .empty,
     steps: std.ArrayList(Step) = .empty,
 @@ -495,12 +495,17 @@ pub const AvailableOption = extern struct {
     };
 };
+pub const UnlazyDep = extern struct {
+    /// none indicates not associated with any particular step.
+    step: Step.OptionalIndex,
+    list: StringList,
+};
 pub const Step = extern struct {
     name: String,
     owner: Package.Index,
     deps: Deps.Index,
     max_rss: MaxRss,
-    unlazy_deps: OptionalStringList,
     extended: Storage.Extended(Flags, union(Tag) {
         check_file: CheckFile,
         compile: Compile,
 @@ -529,6 +534,23 @@ pub const Step = extern struct {
         }
     };
+    pub const OptionalIndex = enum(u32) {
+        none = max_u32,
+        _,
+        pub fn unwrap(this: @This()) ?Index {
+            return switch (this) {
+                .none => null,
+                else => @fromBackingInt(@intCast(@backingInt(this))),
+            };
+        }
+        pub fn ptr(i: @This(), c: *const Configuration) ?*const Step {
+            if (i == .none) return null;
+            return &c.steps[@backingInt(i)];
+        }
+    };
     /// Shared by all steps.
     pub const Flags = packed struct(u32) {
         tag: Tag,
 @@ -3156,7 +3178,7 @@ pub fn load(arena: Allocator, reader: *Io.Reader) LoadError!Configuration {
         .string_bytes = try arena.alloc(u8, header.string_bytes_len),
         .steps = try arena.alloc(Step, header.steps_len),
         .path_deps = try arena.alloc(PathDep, header.path_deps_len),
-        .unlazy_deps = try arena.alloc(String, header.unlazy_deps_len),
+        .unlazy_deps = try arena.alloc(UnlazyDep, header.unlazy_deps_len),
         .system_integrations = try arena.alloc(SystemIntegration, header.system_integrations_len),
         .available_options = try arena.alloc(AvailableOption, header.available_options_len),
         .search_prefixes = try arena.alloc(String, header.search_prefixes_len),

lib/std/Build/Serialize.zig+12-11

 @@ -681,22 +681,23 @@ pub fn write(b: *std.Build, wc: *Configuration.Wip, writer: *std.Io.Writer) !voi
                 .owner = try s.builderToPackage(step.owner),
                 .deps = deps,
                 .max_rss = .fromBytes(step.max_rss),
-                .unlazy_deps = if (step.unlazy_deps.count() != 0)
-                    .init(try wc.addStringListInterned(step.unlazy_deps.keys()))
-                else
-                    .none,
                 .extended = @fromBackingInt(extended),
             });
+            if (step.unlazy_deps.count() != 0) {
+                try wc.unlazy_deps.append(gpa, .{
+                    .step = @fromBackingInt(@intCast(wc.steps.items.len - 1)),
+                    .list = try wc.addStringListInterned(step.unlazy_deps.keys()),
+                });
+            }
         }
     }
-    {
+    if (graph.unlazy_deps.count() != 0) {
-        // TODO exchange graph.unlazy_deps.keys with the wc.unlazy_deps array list without copying
+        try wc.unlazy_deps.append(gpa, .{
-        // MultiArrayList should support this when there is only 1 non zero sized struct field
+            .step = .none,
-        const unlazy_deps = graph.unlazy_deps.keys();
+            .list = try wc.addStringListInterned(graph.unlazy_deps.keys()),
-        try wc.unlazy_deps.ensureTotalCapacityPrecise(gpa, unlazy_deps.len);
+        });
-        assert(wc.unlazy_deps.items.len == 0);
-        wc.unlazy_deps.appendSliceAssumeCapacity(unlazy_deps);
     }
     try wc.write(writer, .{