Commit 0795e2b2ef96c75b8d5e68ed1b8ac23ced28bfce | zig

author	Timothy Bess <timbessmail@gmail.com> 2025-03-09 18:05:11-04:00
committer	Alex Rønne Petersen <alex@alexrp.com> 2025-10-01 04:36:15+02:00
log	0795e2b2ef96c75b8d5e68ed1b8ac23ced28bfce
tree	c9f7a5aaaef8107c5fed5bd5e18bc72303ff40c5
parent	4fd78f9c2639921739836c08f12949e2476ca2ce
signature	Signed by SSH key SHA256:7B/LJ7bpR1eX8aCXSr4mtd5M45VMPKcx9zY8e95b5QM

Fix zig build lazy -> eager dependency promotion

Before, this had a subtle ordering bug where duplicate
deps that are specified as both lazy and eager in different
parts of the dependency tree end up not getting fetched
depending on the ordering. I modified it to resubmit lazy
deps that were promoted to eager for fetching so that it will
be around for the builds that expect it to be eager downstream
of this.

1 files changed, 29 insertions(+), 19 deletions(-)

src
- Package
  - Fetch.zig

src/Package/Fetch.zig+29-19

 @@ -735,28 +735,34 @@ fn queueJobsForDeps(f: *Fetch) RunError!void {
         //     calling run(); no need to add it again.
         //
         // If we add a dep as lazy and then later try to add the same dep as eager,
-        // eagerness takes precedence and the existing entry is updated.
+        // eagerness takes precedence and the existing entry is updated and re-scheduled
+        // for fetching.
         for (dep_names, deps) |dep_name, dep| {
+            var promoted_existing_to_eager = false;
             const new_fetch = &new_fetches[new_fetch_index];
             const location: Location = switch (dep.location) {
-                .url => |url| .{ .remote = .{
+                .url => |url| .{
-                    .url = url,
+                    .remote = .{
-                    .hash = h: {
+                        .url = url,
-                        const h = dep.hash orelse break :h null;
+                        .hash = h: {
-                        const pkg_hash: Package.Hash = .fromSlice(h);
+                            const h = dep.hash orelse break :h null;
-                        if (h.len == 0) break :h pkg_hash;
+                            const pkg_hash: Package.Hash = .fromSlice(h);
-                        const gop = f.job_queue.table.getOrPutAssumeCapacity(pkg_hash);
+                            if (h.len == 0) break :h pkg_hash;
-                        if (gop.found_existing) {
+                            const gop = f.job_queue.table.getOrPutAssumeCapacity(pkg_hash);
-                            if (!dep.lazy) {
+                            if (gop.found_existing) {
-                                gop.value_ptr.*.lazy_status = .eager;
+                                if (!dep.lazy and gop.value_ptr.*.lazy_status != .eager) {
+                                    gop.value_ptr.*.lazy_status = .eager;
+                                    promoted_existing_to_eager = true;
+                                } else {
+                                    continue;
+                                }
                             }
-                            continue;
+                            gop.value_ptr.* = new_fetch;
-                        }
+                            break :h pkg_hash;
-                        gop.value_ptr.* = new_fetch;
+                        },
-                        break :h pkg_hash;
                     },
-                } },
+                },
                 .path => |rel_path| l: {
                     // This might produce an invalid path, which is checked for
                     // at the beginning of run().
 @@ -764,10 +770,12 @@ fn queueJobsForDeps(f: *Fetch) RunError!void {
                     const pkg_hash = relativePathDigest(new_root, cache_root);
                     const gop = f.job_queue.table.getOrPutAssumeCapacity(pkg_hash);
                     if (gop.found_existing) {
-                        if (!dep.lazy) {
+                        if (!dep.lazy and gop.value_ptr.*.lazy_status != .eager) {
                             gop.value_ptr.*.lazy_status = .eager;
+                            promoted_existing_to_eager = true;
+                        } else {
+                            continue;
                         }
-                        continue;
                     }
                     gop.value_ptr.* = new_fetch;
                     break :l .{ .relative_path = new_root };
 @@ -775,7 +783,9 @@ fn queueJobsForDeps(f: *Fetch) RunError!void {
             };
             prog_names[new_fetch_index] = dep_name;
             new_fetch_index += 1;
-            f.job_queue.all_fetches.appendAssumeCapacity(new_fetch);
+            if (!promoted_existing_to_eager) {
+                f.job_queue.all_fetches.appendAssumeCapacity(new_fetch);
+            }
             new_fetch.* = .{
                 .arena = std.heap.ArenaAllocator.init(gpa),
                 .location = location,