Commit 597306838dcc4802c17e94ba156ccf3912e9934c | zig

author	Andrew Kelley <andrew@ziglang.org> 2026-09-15 17:00:34-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2026-09-16 13:12:47-07:00
log	597306838dcc4802c17e94ba156ccf3912e9934c
tree	2eba931f1c697dbb4e5cd0cae27f4ece04c41a8b
parent	e8882ffcf0d97cabfc974bdbc1c592f911832623

frontend: better error reporting for cache check failures

14 files changed, 292 insertions(+), 177 deletions(-)

lib
- compiler
  - Maker.zig
  - Maker
    Step.zig
- std
  - Build
    Cache.zig
src
test
- incremental

lib/compiler/Maker.zig+7-1

 @@ -1399,7 +1399,13 @@ fn configure(graph: *Graph, options: ConfigureOptions) !ScannedConfig {
             defer compile_prog_node.end();
             if (config_man) |man| {
-                if (.hit == try man.check(compile_prog_node)) {
+                var diagnostic: Cache.Manifest.CheckDiagnostic = undefined;
+                const status = man.check(&diagnostic, compile_prog_node) catch |err| switch (err) {
+                    error.Canceled, error.OutOfMemory => |e| return e,
+                    error.CacheCheckFailed => fatal("checking cache failed: {f}", .{diagnostic.fmt(man)}),
+                };
+                log.debug("configuration cache {f}", .{status.fmt(man)});
+                if (status == .hit) {
                     const digest = man.hitDigestHex();
                     const path: Path = .{
                         .root_dir = graph.local_cache_root,

lib/compiler/Maker/Step.zig+10-13

 @@ -726,7 +726,10 @@ pub fn handleChildProcessTerm(s: *Step, maker: *Maker, term: std.process.Child.T
 /// Prefer `cacheHitWatched` unless you already added watch inputs
 /// separately from using the cache system.
 pub fn cacheHit(s: *Step, maker: *Maker, man: *Cache.Manifest, parent_progress_node: std.Progress.Node) !bool {
-    const hit = .hit == (man.check(parent_progress_node) catch |err| return failWithCacheError(s, maker, man, err));
+    var diag: Cache.Manifest.CheckDiagnostic = undefined;
+    const status = man.check(&diag, parent_progress_node) catch |err|
+        return failWithCacheError(s, maker, man, &diag, err);
+    const hit = .hit == status; // TODO cache miss reason in the build summary
     s.result_cached = hit;
     return hit;
 }
 @@ -736,7 +739,10 @@ pub fn cacheHit(s: *Step, maker: *Maker, man: *Cache.Manifest, parent_progress_n
 ///
 /// Must be accompanied with `finalizeManifestAndWatch`.
 pub fn cacheHitWatched(s: *Step, maker: *Maker, man: *Cache.Manifest, parent_progress_node: std.Progress.Node) !bool {
-    const hit = .hit == (man.check(parent_progress_node) catch |err| return failWithCacheError(s, maker, man, err));
+    var diag: Cache.Manifest.CheckDiagnostic = undefined;
+    const status = man.check(&diag, parent_progress_node) catch |err|
+        return failWithCacheError(s, maker, man, &diag, err);
+    const hit = .hit == status; // TODO cache miss reason in the build summary
     s.result_cached = hit;
     // The above call to hit() populates the manifest with files, so in case of
     // a hit, we need to populate watch inputs.
 @@ -748,20 +754,11 @@ fn failWithCacheError(
     s: *Step,
     maker: *Maker,
     man: *const Cache.Manifest,
+    diag: *const Cache.Manifest.CheckDiagnostic,
     err: Cache.Manifest.CheckError,
 ) error{ OutOfMemory, Canceled, MakeFailed } {
     switch (err) {
-        error.CacheCheckFailed => switch (man.diagnostic) {
+        error.CacheCheckFailed => return s.fail(maker, "checking cache failed: {f}", .{diag.fmt(man)}),
-            .none => unreachable,
-            .manifest_oversize => return s.fail(maker, "checking cache failed: {t}", .{man.diagnostic}),
-            .manifest_create, .manifest_stat, .manifest_read, .manifest_lock => |e| {
-                return s.fail(maker, "checking cache failed: {t} {t}", .{ man.diagnostic, e });
-            },
-            .file_open, .file_stat, .file_read, .file_hash => |op| {
-                const path = op.path(man);
-                return s.fail(maker, "checking cache failed: {f} {t} {t}", .{ path, man.diagnostic, op.err });
-            },
-        },
         error.OutOfMemory, error.Canceled => |e| return e,
     }
 }

lib/std/Build/Cache.zig+142-99

 @@ -289,7 +289,6 @@ pub const Manifest = struct {
     /// Indexes line up with `files`, but only up until `hit` is called. Uses
     /// `Cache.gpa`.
     input_paths: std.ArrayList(InputPath) = .empty,
-    diagnostic: Diagnostic = .none,
     /// Keeps track of the last time we performed a file system write to observe
     /// what time the file system thinks it is, according to its own granularity.
     recent_problematic_timestamp: Io.Timestamp = .zero,
 @@ -591,8 +590,7 @@ pub const Manifest = struct {
         }
     };
-    pub const Diagnostic = union(enum) {
+    pub const CheckDiagnostic = union(enum) {
-        none,
         manifest_create: Io.File.OpenError,
         manifest_stat: Io.File.StatError,
         manifest_oversize,
 @@ -617,6 +615,31 @@ pub const Manifest = struct {
                 };
             }
         };
+        pub const Format = struct {
+            diagnostic: CheckDiagnostic,
+            manifest: *const Manifest,
+            pub fn format(this: @This(), w: *Io.Writer) Io.Writer.Error!void {
+                switch (this.diagnostic) {
+                    .manifest_oversize => return w.writeAll(@tagName(this.diagnostic)),
+                    .manifest_create, .manifest_stat, .manifest_read, .manifest_lock => |e| {
+                        return w.print("{t} {t}", .{ this.diagnostic, e });
+                    },
+                    .file_open, .file_stat, .file_read, .file_hash => |op| {
+                        const path = op.path(this.manifest);
+                        return w.print("{t} {t} {f}", .{ this.diagnostic, op.err, path });
+                    },
+                }
+            }
+        };
+        pub fn fmt(diagnostic: CheckDiagnostic, manifest: *const Manifest) Format {
+            return .{
+                .diagnostic = diagnostic,
+                .manifest = manifest,
+            };
+        }
     };
     pub const Stat = struct {
 @@ -816,6 +839,28 @@ pub const Manifest = struct {
         directory_status_changed: File.Offset,
         metadata_changed: File.Offset,
         contents_changed: File.Offset,
+        pub const Format = struct {
+            check_result: CheckResult,
+            manifest: *const Manifest,
+            pub fn format(this: @This(), w: *Io.Writer) Io.Writer.Error!void {
+                switch (this.check_result) {
+                    .hit, .incomplete_manifest, .invalid_manifest => return w.writeAll(@tagName(this.check_result)),
+                    .path_deleted, .directory_status_changed, .metadata_changed, .contents_changed => |off| {
+                        const path = off.path(this.manifest.contents.items);
+                        return w.print("{t} {s}", .{ this.check_result, path });
+                    },
+                }
+            }
+        };
+        pub fn fmt(check_result: CheckResult, manifest: *const Manifest) Format {
+            return .{
+                .check_result = check_result,
+                .manifest = manifest,
+            };
+        }
     };
     pub const CheckError = error{
 @@ -836,13 +881,17 @@ pub const Manifest = struct {
     /// The lock on the manifest file is released when `deinit` is called. As another
     /// option, one may call `toOwnedLock` to obtain a smaller object which can represent
     /// the lock. `deinit` is safe to call whether or not `toOwnedLock` has been called.
-    pub fn check(man: *Manifest, parent_progress_node: std.Progress.Node) CheckError!CheckResult {
+    pub fn check(
+        man: *Manifest,
+        diag: *CheckDiagnostic,
+        parent_progress_node: std.Progress.Node,
+    ) CheckError!CheckResult {
         const node = parent_progress_node.start("Reusing Cache Artifacts", 0);
         defer node.end();
-        return checkProgressless(man);
+        return checkProgressless(man, diag);
     }
-    pub fn checkProgressless(man: *Manifest) CheckError!CheckResult {
+    pub fn checkProgressless(man: *Manifest, diag: *CheckDiagnostic) CheckError!CheckResult {
         assert(man.state == .input);
         assert(man.manifest_file == null);
 @@ -852,8 +901,6 @@ pub const Manifest = struct {
             man.hashFlagsAndPath(file_off, &man.hash.hasher);
         }
-        man.diagnostic = .none;
         var input_digest: BinDigest = undefined;
         man.hash.hasher.final(&input_digest);
         const input_hex_digest = binToHex(input_digest);
 @@ -879,10 +926,7 @@ pub const Manifest = struct {
                     man.manifest_file = man.cache.manifest_dir.openFile(io, manifest_file_path, .{
                         .mode = .read_write,
                         .lock = .shared,
-                    }) catch |e| {
+                    }) catch |e| return fail(diag, .{ .manifest_create = e });
-                        man.diagnostic = .{ .manifest_create = e };
-                        return error.CacheCheckFailed;
-                    };
                     break;
                 },
                 error.FileNotFound => {
 @@ -895,10 +939,7 @@ pub const Manifest = struct {
                     // disambiguates by returning EEXIST, indicating original
                     // failure was a race, or ENOENT, indicating deletion of
                     // the directory of our open handle.
-                    if (!builtin.os.tag.isDarwin()) {
+                    if (!builtin.os.tag.isDarwin()) return fail(diag, .{ .manifest_create = error.FileNotFound });
-                        man.diagnostic = .{ .manifest_create = error.FileNotFound };
-                        return error.CacheCheckFailed;
-                    }
                     if (man.cache.manifest_dir.createFile(io, manifest_file_path, .{
                         .read = true,
 @@ -912,22 +953,13 @@ pub const Manifest = struct {
                         break;
                     } else |excl_err| switch (excl_err) {
                         error.WouldBlock, error.PathAlreadyExists => continue,
-                        error.FileNotFound => {
+                        error.FileNotFound => return fail(diag, .{ .manifest_create = error.FileNotFound }),
-                            man.diagnostic = .{ .manifest_create = error.FileNotFound };
-                            return error.CacheCheckFailed;
-                        },
                         error.Canceled => |e| return e,
-                        else => |e| {
+                        else => |e| return fail(diag, .{ .manifest_create = e }),
-                            man.diagnostic = .{ .manifest_create = e };
-                            return error.CacheCheckFailed;
-                        },
                     }
                 },
                 error.Canceled => |e| return e,
-                else => |e| {
+                else => |e| return fail(diag, .{ .manifest_create = e }),
-                    man.diagnostic = .{ .manifest_create = e };
-                    return error.CacheCheckFailed;
-                },
             }
         }
 @@ -949,16 +981,16 @@ pub const Manifest = struct {
         hit: {
             const miss_result = miss: {
-                const result = try man.checkLocked();
+                const result = try man.checkLocked(diag);
                 if (result == .hit) {
                     break :hit;
-                } else if (!try man.upgradeToExclusiveLock()) {
+                } else if (!try man.upgradeToExclusiveLock(diag)) {
                     break :miss result;
                 }
                 // Missed with the shared lock, and upgraded to an exclusive lock. However, another process may have
                 // modified the cache directory, so we need to check again before deciding to miss.
                 man.shrinkFilesToInput();
-                const refreshed_result = try man.checkLocked();
+                const refreshed_result = try man.checkLocked(diag);
                 if (refreshed_result == .hit) break :hit;
                 break :miss refreshed_result;
             };
 @@ -970,10 +1002,7 @@ pub const Manifest = struct {
         }
         if (man.want_shared_lock) {
-            man.downgradeToSharedLock() catch |err| {
+            man.downgradeToSharedLock() catch |err| return fail(diag, .{ .manifest_lock = err });
-                man.diagnostic = .{ .manifest_lock = err };
-                return error.CacheCheckFailed;
-            };
         }
         man.state = .hit;
 @@ -1006,7 +1035,7 @@ pub const Manifest = struct {
     }
     /// Does not observe or modify `self.hash.hasher`. Asserts `self.files` contains only the original input files.
-    fn checkLocked(m: *Manifest) CheckError!CheckResult {
+    fn checkLocked(m: *Manifest, diag: *CheckDiagnostic) CheckError!CheckResult {
         assert(m.files.count() == m.input_paths.items.len);
         const gpa = m.cache.gpa;
         const io = m.cache.io;
 @@ -1014,15 +1043,15 @@ pub const Manifest = struct {
         const manifest_stat = manifest_file.stat(io) catch |err| switch (err) {
             error.Canceled => |e| return e,
-            else => |e| return fail(&m.diagnostic, .{ .manifest_stat = e }),
+            else => |e| return fail(diag, .{ .manifest_stat = e }),
         };
         const manifest_size = std.math.cast(u32, manifest_stat.size) orelse
-            return fail(&m.diagnostic, .manifest_oversize);
+            return fail(diag, .manifest_oversize);
         if (manifest_size == 0 or manifest_size < m.contents.items.len) {
             // Manifest file was never finalized.
             try m.contents.ensureUnusedCapacity(gpa, 1);
-            return populateMissingInputFileHashes(m, 0, .incomplete_manifest);
+            return populateMissingInputFileHashes(m, diag, 0, .incomplete_manifest);
         }
         // We must not clobber existing `Manifest.contents` because it possibly contains prepopulated stat and digest
 @@ -1039,9 +1068,9 @@ pub const Manifest = struct {
         {
             const n = manifest_file.readPositionalAll(io, m.contents.items, 0) catch |err| switch (err) {
                 error.Canceled => |e| return e,
-                else => |e| return fail(&m.diagnostic, .{ .manifest_read = e }),
+                else => |e| return fail(diag, .{ .manifest_read = e }),
             };
-            if (n != manifest_size) return missInput(m, 0, input_contents_len, manifest_size, .incomplete_manifest);
+            if (n != manifest_size) return missInput(m, diag, 0, input_contents_len, manifest_size, .incomplete_manifest);
         }
         const disk_contents = m.contents.items[0..manifest_size];
         const input_contents = m.contents.items[manifest_size..][0..input_contents_len];
 @@ -1050,12 +1079,12 @@ pub const Manifest = struct {
         var off: usize = 0;
         for (m.input_paths.items, m.files.keys()[0..m.input_paths.items.len], 0..) |*input_path, file_off, i| {
             if (@backingInt(file_off) + 1 >= disk_contents.len)
-                return missInput(m, i, input_contents_len, manifest_size, .incomplete_manifest);
+                return missInput(m, diag, i, input_contents_len, manifest_size, .incomplete_manifest);
             if (!mem.eql(u8, file_off.flagsAndPath(disk_contents), file_off.flagsAndPath(input_contents)))
-                return missInput(m, i, input_contents_len, manifest_size, .invalid_manifest);
+                return missInput(m, diag, i, input_contents_len, manifest_size, .invalid_manifest);
-            const result = try checkInputPath(m, file_off, input_path, disk_contents, input_contents);
+            const result = try checkInputPath(m, diag, file_off, input_path, disk_contents, input_contents);
-            if (result != .hit) return missInput(m, i + 1, input_contents_len, manifest_size, result);
+            if (result != .hit) return missInput(m, diag, i + 1, input_contents_len, manifest_size, result);
             off = @backingInt(file_off);
         }
 @@ -1074,7 +1103,7 @@ pub const Manifest = struct {
             if (path.len == 0) return .invalid_manifest;
             try m.files.putContext(gpa, file_off, {}, .{ .contents = disk_contents });
-            const result = try checkDiscoveredPath(m, file_off, disk_contents);
+            const result = try checkDiscoveredPath(m, diag, file_off, disk_contents);
             if (result != .hit) return result;
             off += File.sizeOf(path.len);
 @@ -1098,6 +1127,7 @@ pub const Manifest = struct {
     /// missed one.
     fn missInput(
         m: *Manifest,
+        diag: *CheckDiagnostic,
         next_file_index: usize,
         input_contents_len: usize,
         manifest_size: usize,
 @@ -1114,18 +1144,19 @@ pub const Manifest = struct {
             m.contents.items[manifest_size + off ..][0..copy_len],
         );
         m.contents.shrinkRetainingCapacity(input_contents_len);
-        return populateMissingInputFileHashes(m, next_file_index, result);
+        return populateMissingInputFileHashes(m, diag, next_file_index, result);
     }
     fn populateMissingInputFileHashes(
         m: *Manifest,
+        diag: *CheckDiagnostic,
         next_file_index: usize,
         result: CheckResult,
     ) CheckError!CheckResult {
         const file_offs = m.files.keys();
         const contents = m.contents.items;
         for (file_offs[next_file_index..], m.input_paths.items[next_file_index..]) |input_file_off, *input_path| {
-            try populateInputPath(m, input_file_off, input_path, contents);
+            try populateInputPath(m, diag, input_file_off, input_path, contents);
         }
         return result;
     }
 @@ -1134,6 +1165,7 @@ pub const Manifest = struct {
     /// system. Only ensures that metadata and digest are available.
     fn populateInputPath(
         m: *Manifest,
+        diag: *CheckDiagnostic,
         file_off: File.Offset,
         input_path: *InputPath,
         contents: []u8,
 @@ -1156,21 +1188,21 @@ pub const Manifest = struct {
             const actual_stat = switch (input_path.getHandle(input_file)) {
                 .none => parent_dir.statFile(io, file_path, .{}) catch |err| switch (err) {
                     error.Canceled => |e| return e,
-                    else => |e| return fail(&m.diagnostic, .{ .file_stat = .{
+                    else => |e| return fail(diag, .{ .file_stat = .{
                         .file_offset = file_off,
                         .err = e,
                     } }),
                 },
                 .file => |opened_file| opened_file.stat(io) catch |err| switch (err) {
                     error.Canceled => |e| return e,
-                    else => |e| return fail(&m.diagnostic, .{ .file_stat = .{
+                    else => |e| return fail(diag, .{ .file_stat = .{
                         .file_offset = file_off,
                         .err = e,
                     } }),
                 },
                 .dir => |opened_dir| opened_dir.stat(io) catch |err| switch (err) {
                     error.Canceled => |e| return e,
-                    else => |e| return fail(&m.diagnostic, .{ .file_stat = .{
+                    else => |e| return fail(diag, .{ .file_stat = .{
                         .file_offset = file_off,
                         .err = e,
                     } }),
 @@ -1179,7 +1211,7 @@ pub const Manifest = struct {
             const actual_is_directory = actual_stat.kind == .directory;
             if (actual_is_directory != input_file.flags.is_directory) {
                 // Since this is an input file, this is a failure, not a cache miss.
-                return fail(&m.diagnostic, .{ .file_stat = .{
+                return fail(diag, .{ .file_stat = .{
                     .file_offset = file_off,
                     .err = if (actual_is_directory) error.IsDir else error.NotDir,
                 } });
 @@ -1210,7 +1242,7 @@ pub const Manifest = struct {
                     .access_sub_paths = false,
                 }) catch |err| switch (err) {
                     error.Canceled => |e| return e,
-                    else => |e| return fail(&m.diagnostic, .{ .file_open = .{
+                    else => |e| return fail(diag, .{ .file_open = .{
                         .file_offset = file_off,
                         .err = e,
                     } }),
 @@ -1224,7 +1256,7 @@ pub const Manifest = struct {
                 assert(!stat_path_ok);
                 const actual_stat = opened_dir.stat(io) catch |err| switch (err) {
                     error.Canceled => |e| return e,
-                    else => |e| return fail(&m.diagnostic, .{ .file_stat = .{
+                    else => |e| return fail(diag, .{ .file_stat = .{
                         .file_offset = file_off,
                         .err = e,
                     } }),
 @@ -1235,7 +1267,7 @@ pub const Manifest = struct {
             const dir_contents_start = m.all_input_content.items.len;
             hashDir(gpa, io, opened_dir, &input_file.digest, &m.all_input_content) catch |err| switch (err) {
                 error.Canceled, error.OutOfMemory => |e| return e,
-                else => |e| return fail(&m.diagnostic, .{ .file_read = .{
+                else => |e| return fail(diag, .{ .file_read = .{
                     .file_offset = file_off,
                     .err = e,
                 } }),
 @@ -1254,7 +1286,7 @@ pub const Manifest = struct {
             else
                 parent_dir.openFile(io, file_path, .{ .mode = .read_only }) catch |err| switch (err) {
                     error.Canceled => |e| return e,
-                    else => |e| return fail(&m.diagnostic, .{ .file_open = .{
+                    else => |e| return fail(diag, .{ .file_open = .{
                         .file_offset = file_off,
                         .err = e,
                     } }),
 @@ -1268,7 +1300,7 @@ pub const Manifest = struct {
                 assert(!stat_path_ok);
                 const actual_stat = opened_file.stat(io) catch |err| switch (err) {
                     error.Canceled => |e| return e,
-                    else => |e| return fail(&m.diagnostic, .{ .file_stat = .{
+                    else => |e| return fail(diag, .{ .file_stat = .{
                         .file_offset = file_off,
                         .err = e,
                     } }),
 @@ -1281,7 +1313,7 @@ pub const Manifest = struct {
                     const start = m.all_input_content.items.len;
                     hashFileAppend(io, opened_file, &input_file.digest, &m.all_input_content, gpa) catch |err| switch (err) {
                         error.Canceled, error.OutOfMemory => |e| return e,
-                        else => |e| return fail(&m.diagnostic, .{ .file_read = .{
+                        else => |e| return fail(diag, .{ .file_read = .{
                             .file_offset = file_off,
                             .err = e,
                         } }),
 @@ -1293,7 +1325,7 @@ pub const Manifest = struct {
                 },
                 .unrequested => hashFile(io, opened_file, &input_file.digest) catch |err| switch (err) {
                     error.Canceled => |e| return e,
-                    else => |e| return fail(&m.diagnostic, .{ .file_read = .{
+                    else => |e| return fail(diag, .{ .file_read = .{
                         .file_offset = file_off,
                         .err = e,
                     } }),
 @@ -1306,6 +1338,7 @@ pub const Manifest = struct {
     /// Upon return, disk_contents digest and stat will be populated regardless of whether hit or miss occurs.
     fn checkInputPath(
         m: *Manifest,
+        diag: *CheckDiagnostic,
         file_off: File.Offset,
         input_path: *InputPath,
         disk_contents: []u8,
 @@ -1337,21 +1370,21 @@ pub const Manifest = struct {
                 const actual_stat = switch (input_path.getHandle(input_file)) {
                     .none => parent_dir.statFile(io, file_path, .{}) catch |err| switch (err) {
                         error.Canceled => |e| return e,
-                        else => |e| return fail(&m.diagnostic, .{ .file_stat = .{
+                        else => |e| return fail(diag, .{ .file_stat = .{
                             .file_offset = file_off,
                             .err = e,
                         } }),
                     },
                     .file => |opened_file| opened_file.stat(io) catch |err| switch (err) {
                         error.Canceled => |e| return e,
-                        else => |e| return fail(&m.diagnostic, .{ .file_stat = .{
+                        else => |e| return fail(diag, .{ .file_stat = .{
                             .file_offset = file_off,
                             .err = e,
                         } }),
                     },
                     .dir => |opened_dir| opened_dir.stat(io) catch |err| switch (err) {
                         error.Canceled => |e| return e,
-                        else => |e| return fail(&m.diagnostic, .{ .file_stat = .{
+                        else => |e| return fail(diag, .{ .file_stat = .{
                             .file_offset = file_off,
                             .err = e,
                         } }),
 @@ -1362,7 +1395,7 @@ pub const Manifest = struct {
                 const actual_is_directory = actual_stat.kind == .directory;
                 if (actual_is_directory != disk_file.flags.is_directory) {
                     // Since this is an input file, this is a failure, not a cache miss.
-                    return fail(&m.diagnostic, .{ .file_stat = .{
+                    return fail(diag, .{ .file_stat = .{
                         .file_offset = file_off,
                         .err = if (actual_is_directory) error.IsDir else error.NotDir,
                     } });
 @@ -1393,7 +1426,7 @@ pub const Manifest = struct {
                     .access_sub_paths = false,
                 }) catch |err| switch (err) {
                     error.Canceled => |e| return e,
-                    else => |e| return fail(&m.diagnostic, .{ .file_open = .{
+                    else => |e| return fail(diag, .{ .file_open = .{
                         .file_offset = file_off,
                         .err = e,
                     } }),
 @@ -1406,7 +1439,7 @@ pub const Manifest = struct {
             if (!input_path.have_stat) {
                 const actual_stat = opened_dir.stat(io) catch |err| switch (err) {
                     error.Canceled => |e| return e,
-                    else => |e| return fail(&m.diagnostic, .{ .file_stat = .{
+                    else => |e| return fail(diag, .{ .file_stat = .{
                         .file_offset = file_off,
                         .err = e,
                     } }),
 @@ -1417,7 +1450,7 @@ pub const Manifest = struct {
             const dir_contents_start = m.all_input_content.items.len;
             hashDir(gpa, io, opened_dir, &disk_file.digest, &m.all_input_content) catch |err| switch (err) {
                 error.Canceled, error.OutOfMemory => |e| return e,
-                else => |e| return fail(&m.diagnostic, .{ .file_read = .{
+                else => |e| return fail(diag, .{ .file_read = .{
                     .file_offset = file_off,
                     .err = e,
                 } }),
 @@ -1439,7 +1472,7 @@ pub const Manifest = struct {
             else
                 parent_dir.openFile(io, file_path, .{ .mode = .read_only }) catch |err| switch (err) {
                     error.Canceled => |e| return e,
-                    else => |e| return fail(&m.diagnostic, .{ .file_open = .{
+                    else => |e| return fail(diag, .{ .file_open = .{
                         .file_offset = file_off,
                         .err = e,
                     } }),
 @@ -1452,7 +1485,7 @@ pub const Manifest = struct {
             if (!input_path.have_stat) {
                 const actual_stat = opened_file.stat(io) catch |err| switch (err) {
                     error.Canceled => |e| return e,
-                    else => |e| return fail(&m.diagnostic, .{ .file_stat = .{
+                    else => |e| return fail(diag, .{ .file_stat = .{
                         .file_offset = file_off,
                         .err = e,
                     } }),
 @@ -1465,7 +1498,7 @@ pub const Manifest = struct {
                     const start = m.all_input_content.items.len;
                     hashFileAppend(io, opened_file, &disk_file.digest, &m.all_input_content, gpa) catch |err| switch (err) {
                         error.Canceled, error.OutOfMemory => |e| return e,
-                        else => |e| return fail(&m.diagnostic, .{ .file_read = .{
+                        else => |e| return fail(diag, .{ .file_read = .{
                             .file_offset = file_off,
                             .err = e,
                         } }),
 @@ -1477,7 +1510,7 @@ pub const Manifest = struct {
                 },
                 .unrequested => hashFile(io, opened_file, &disk_file.digest) catch |err| switch (err) {
                     error.Canceled => |e| return e,
-                    else => |e| return fail(&m.diagnostic, .{ .file_read = .{
+                    else => |e| return fail(diag, .{ .file_read = .{
                         .file_offset = file_off,
                         .err = e,
                     } }),
 @@ -1490,7 +1523,12 @@ pub const Manifest = struct {
         }
     }
-    fn checkDiscoveredPath(m: *Manifest, file_off: File.Offset, contents: []u8) CheckError!CheckResult {
+    fn checkDiscoveredPath(
+        m: *Manifest,
+        diag: *CheckDiagnostic,
+        file_off: File.Offset,
+        contents: []u8,
+    ) CheckError!CheckResult {
         const file = file_off.get(contents);
         const cache = m.cache;
         const gpa = cache.gpa;
 @@ -1502,7 +1540,7 @@ pub const Manifest = struct {
             const actual_stat = parent_dir.statFile(io, file_path, .{}) catch |err| switch (err) {
                 error.FileNotFound => return .{ .path_deleted = file_off },
                 error.Canceled => |e| return e,
-                else => |e| return fail(&m.diagnostic, .{ .file_stat = .{
+                else => |e| return fail(diag, .{ .file_stat = .{
                     .file_offset = file_off,
                     .err = e,
                 } }),
 @@ -1525,7 +1563,7 @@ pub const Manifest = struct {
                 error.FileNotFound => return .{ .path_deleted = file_off },
                 error.NotDir => return .{ .directory_status_changed = file_off },
                 error.Canceled => |e| return e,
-                else => |e| return fail(&m.diagnostic, .{ .file_open = .{
+                else => |e| return fail(diag, .{ .file_open = .{
                     .file_offset = file_off,
                     .err = e,
                 } }),
 @@ -1534,7 +1572,7 @@ pub const Manifest = struct {
             const actual_stat = opened_dir.stat(io) catch |err| switch (err) {
                 error.Canceled => |e| return e,
-                else => |e| return fail(&m.diagnostic, .{ .file_stat = .{
+                else => |e| return fail(diag, .{ .file_stat = .{
                     .file_offset = file_off,
                     .err = e,
                 } }),
 @@ -1545,7 +1583,7 @@ pub const Manifest = struct {
                 defer m.all_input_content.shrinkRetainingCapacity(dir_contents_start);
                 hashDir(gpa, io, opened_dir, &file.digest, &m.all_input_content) catch |err| switch (err) {
                     error.Canceled, error.OutOfMemory => |e| return e,
-                    else => |e| return fail(&m.diagnostic, .{ .file_read = .{
+                    else => |e| return fail(diag, .{ .file_read = .{
                         .file_offset = file_off,
                         .err = e,
                     } }),
 @@ -1560,7 +1598,7 @@ pub const Manifest = struct {
             error.FileNotFound => return .{ .path_deleted = file_off },
             error.IsDir => return .{ .directory_status_changed = file_off },
             error.Canceled => |e| return e,
-            else => |e| return fail(&m.diagnostic, .{ .file_open = .{
+            else => |e| return fail(diag, .{ .file_open = .{
                 .file_offset = file_off,
                 .err = e,
             } }),
 @@ -1569,7 +1607,7 @@ pub const Manifest = struct {
         const actual_stat = opened_file.stat(io) catch |err| switch (err) {
             error.Canceled => |e| return e,
-            else => |e| return fail(&m.diagnostic, .{ .file_stat = .{
+            else => |e| return fail(diag, .{ .file_stat = .{
                 .file_offset = file_off,
                 .err = e,
             } }),
 @@ -1579,7 +1617,7 @@ pub const Manifest = struct {
             const prev_digest: BinDigest = file.digest;
             hashFile(io, opened_file, &file.digest) catch |err| switch (err) {
                 error.Canceled => |e| return e,
-                else => |e| return fail(&m.diagnostic, .{ .file_read = .{
+                else => |e| return fail(diag, .{ .file_read = .{
                     .file_offset = file_off,
                     .err = e,
                 } }),
 @@ -1591,8 +1629,7 @@ pub const Manifest = struct {
         return .hit;
     }
-    fn fail(ptr: *Diagnostic, d: Diagnostic) error{CacheCheckFailed} {
+    fn fail(ptr: *CheckDiagnostic, d: CheckDiagnostic) error{CacheCheckFailed} {
-        assert(ptr.* == .none);
         ptr.* = d;
         return error.CacheCheckFailed;
     }
 @@ -2002,22 +2039,19 @@ pub const Manifest = struct {
         self.have_exclusive_lock = false;
     }
-    fn upgradeToExclusiveLock(self: *Manifest) error{CacheCheckFailed}!bool {
+    fn upgradeToExclusiveLock(m: *Manifest, diag: *CheckDiagnostic) error{CacheCheckFailed}!bool {
-        if (self.have_exclusive_lock) return false;
+        if (m.have_exclusive_lock) return false;
-        assert(self.manifest_file != null);
+        assert(m.manifest_file != null);
-        const io = self.cache.io;
+        const io = m.cache.io;
         if (std.process.can_spawn or !builtin.single_threaded) {
-            const manifest_file = self.manifest_file.?;
+            const manifest_file = m.manifest_file.?;
             // Here we intentionally have a period where the lock is released, in case there are
             // other processes holding a shared lock.
             manifest_file.unlock(io);
-            manifest_file.lock(io, .exclusive) catch |err| {
+            manifest_file.lock(io, .exclusive) catch |err| return fail(diag, .{ .manifest_lock = err });
-                self.diagnostic = .{ .manifest_lock = err };
-                return error.CacheCheckFailed;
-            };
         }
-        self.have_exclusive_lock = true;
+        m.have_exclusive_lock = true;
         return true;
     }
 @@ -2327,7 +2361,8 @@ test "cache file and then recall it" {
                 .sub_path = temp_file,
             }, .{});
-            try testing.expectEqual(.incomplete_manifest, try man.check(.none));
+            var diag: Manifest.CheckDiagnostic = undefined;
+            try testing.expectEqual(.incomplete_manifest, try man.check(&diag, .none));
             digest1 = man.missDigestHex();
             try man.finalize();
 @@ -2345,7 +2380,8 @@ test "cache file and then recall it" {
             }, .{});
             // Cache hit! We just "built" the same file
-            try testing.expectEqual(.hit, try man.check(.none));
+            var diag: Manifest.CheckDiagnostic = undefined;
+            try testing.expectEqual(.hit, try man.check(&diag, .none));
             digest2 = man.hitDigestHex();
             try testing.expectEqual(false, man.have_exclusive_lock);
 @@ -2406,7 +2442,8 @@ test "check that changing a file causes cache miss" {
                 .sub_path = temp_file,
             }, .{ .request_contents = true });
-            try testing.expectEqual(.incomplete_manifest, try man.check(.none));
+            var diag: Manifest.CheckDiagnostic = undefined;
+            try testing.expectEqual(.incomplete_manifest, try man.check(&diag, .none));
             try testing.expectEqualStrings(original_temp_file_contents, temp_file_idx.contents(&man));
 @@ -2428,9 +2465,10 @@ test "check that changing a file causes cache miss" {
             }, .{ .request_contents = true });
             // The one input file changed.
+            var diag: Manifest.CheckDiagnostic = undefined;
             try testing.expectEqual(
                 @as(Manifest.CheckResult, .{ .contents_changed = temp_file_idx.offset(&man) }),
-                try man.check(.none),
+                try man.check(&diag, .none),
             );
             try testing.expectEqualStrings(updated_temp_file_contents, temp_file_idx.contents(&man));
 @@ -2473,7 +2511,8 @@ test "no file inputs" {
         man.hash.addBytes("1234");
-        try testing.expectEqual(.incomplete_manifest, try man.check(.none));
+        var diag: Manifest.CheckDiagnostic = undefined;
+        try testing.expectEqual(.incomplete_manifest, try man.check(&diag, .none));
         digest1 = man.missDigestHex();
 @@ -2485,7 +2524,8 @@ test "no file inputs" {
         man.hash.addBytes("1234");
-        try testing.expectEqual(.hit, try man.check(.none));
+        var diag: Manifest.CheckDiagnostic = undefined;
+        try testing.expectEqual(.hit, try man.check(&diag, .none));
         digest2 = man.hitDigestHex();
         try testing.expectEqual(false, man.have_exclusive_lock);
     }
 @@ -2545,7 +2585,8 @@ test "Manifest with files added after initial hash" {
                 .sub_path = temp_file1,
             }, .{});
-            try testing.expectEqual(.incomplete_manifest, try man.check(.none));
+            var diag: Manifest.CheckDiagnostic = undefined;
+            try testing.expectEqual(.incomplete_manifest, try man.check(&diag, .none));
             try man.addDiscoveredPath(.{ .discovered_path = .{ .unresolved = .{
                 .root_dir = tmp_directory,
 @@ -2565,7 +2606,8 @@ test "Manifest with files added after initial hash" {
                 .sub_path = temp_file1,
             }, .{});
-            try testing.expect(.hit == try man.check(.none));
+            var diag: Manifest.CheckDiagnostic = undefined;
+            try testing.expect(.hit == try man.check(&diag, .none));
             digest2 = man.hitDigestHex();
             try testing.expectEqual(false, man.have_exclusive_lock);
 @@ -2591,7 +2633,8 @@ test "Manifest with files added after initial hash" {
                 .sub_path = temp_file1,
             }, .{});
-            switch (try man.check(.none)) {
+            var diag: Manifest.CheckDiagnostic = undefined;
+            switch (try man.check(&diag, .none)) {
                 .contents_changed => |off| {
                     try testing.expectEqualStrings(temp_file2, off.path(man.contents.items));
                 },

src/Compilation.zig+52-28

 @@ -2813,27 +2813,14 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) UpdateE
                 man.want_shared_lock = false;
             }
-            const status = man.check(main_progress_node) catch |err| switch (err) {
+            var diag: Cache.Manifest.CheckDiagnostic = undefined;
+            const status = man.check(&diag, main_progress_node) catch |err| switch (err) {
                 error.Canceled, error.OutOfMemory => |e| return e,
-                error.CacheCheckFailed => switch (man.diagnostic) {
+                error.CacheCheckFailed => {
-                    .none => unreachable,
+                    return comp.setMiscFailure(.check_whole_cache, "checking cache failed: {f}", .{diag.fmt(&man)});
-                    .manifest_oversize => {
-                        return comp.setMiscFailure(.check_whole_cache, "checking cache failed: {t}", .{
-                            man.diagnostic,
-                        });
-                    },
-                    .manifest_create, .manifest_stat, .manifest_read, .manifest_lock => |e| {
-                        return comp.setMiscFailure(.check_whole_cache, "checking cache failed: {t} {t}", .{
-                            man.diagnostic, e,
-                        });
-                    },
-                    .file_open, .file_stat, .file_read, .file_hash => |op| {
-                        return comp.setMiscFailure(.check_whole_cache, "checking cache failed: {f} {t} {t}", .{
-                            op.path(&man), man.diagnostic, op.err,
-                        });
-                    },
                 },
             };
+            log.debug("{s} whole cache {f} ignore_hit={}", .{ comp.root_name, status.fmt(&man), ignore_hit });
             if (status == .hit and !ignore_hit) {
                 // In this case the cache hit contains the full set of file system inputs. Nice!
                 if (comp.file_system_inputs) |buf| try man.populateFileSystemInputs(buf);
 @@ -2844,7 +2831,6 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) UpdateE
                 }
                 comp.last_update_was_cache_hit = true;
-                log.debug("CacheMode.whole cache hit for {s}", .{comp.root_name});
                 const bin_digest = man.hitDigest();
                 comp.digest = bin_digest;
 @@ -2853,7 +2839,6 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) UpdateE
                 whole.lock = man.toOwnedLock();
                 return;
             }
-            log.debug("CacheMode.whole cache miss for {s}", .{comp.root_name});
             if (ignore_hit) {
                 // Okay, now set this back so that `Manifest.finalize` will downgrade our lock later.
 @@ -5536,7 +5521,18 @@ fn updateCObject(comp: *Compilation, c_object: *CObject, c_obj_prog_node: std.Pr
     const target = comp.getTarget();
     assert(target.ofmt != .c);
     const o_ext = target.ofmt.fileExt(target.cpu.arch);
-    const digest = if (!comp.disable_c_depfile and .hit == try man.check(child_progress_node)) man.hitDigestHex() else miss: {
+    const digest = d: {
+        if (!comp.disable_c_depfile) {
+            var diagnostic: Cache.Manifest.CheckDiagnostic = undefined;
+            const status = man.check(&diagnostic, child_progress_node) catch |err| switch (err) {
+                error.Canceled, error.OutOfMemory => |e| return e,
+                error.CacheCheckFailed => {
+                    return comp.failCObj(c_object, "checking cache failed: {f}", .{diagnostic.fmt(&man)});
+                },
+            };
+            log.debug("C object cache {f}", .{status.fmt(&man)});
+            if (status == .hit) break :d man.hitDigestHex();
+        }
         var argv: std.array_list.Managed([]const u8) = .init(gpa);
         defer argv.deinit();
 @@ -5811,16 +5807,28 @@ fn updateCObject(comp: *Compilation, c_object: *CObject, c_obj_prog_node: std.Pr
         }
         // We don't actually care whether it's a cache hit or miss; we just need the digest and the lock.
-        if (comp.disable_c_depfile) _ = try man.check(child_progress_node);
+        const digest = inner: {
+            if (comp.disable_c_depfile) {
+                var diagnostic: Cache.Manifest.CheckDiagnostic = undefined;
+                const status = man.check(&diagnostic, child_progress_node) catch |err| switch (err) {
+                    error.OutOfMemory, error.Canceled => |e| return e,
+                    error.CacheCheckFailed => {
+                        return comp.failCObj(c_object, "checking cache failed: {f}", .{diagnostic.fmt(&man)});
+                    },
+                };
+                log.debug("ignored C object cache {f}", .{status.fmt(&man)});
+                if (status == .hit) break :inner man.hitDigestHex();
+            }
+            break :inner man.missDigestHex();
+        };
         // Rename into place.
-        const digest = man.missDigestHex();
         const o_sub_path = try fs.path.join(arena, &.{ "o", &digest });
         var o_dir = try comp.dirs.local_cache.handle.createDirPathOpen(io, o_sub_path, .{});
         defer o_dir.close(io);
         const tmp_basename = fs.path.basename(out_obj_path);
         try Io.Dir.rename(zig_cache_tmp_dir, tmp_basename, o_dir, o_basename, io);
-        break :miss digest;
+        break :d digest;
     };
     if (man.have_exclusive_lock) {
 @@ -5896,7 +5904,15 @@ fn updateWin32Resource(comp: *Compilation, win32_resource: *Win32Resource, win32
         const rc_basename = try std.fmt.allocPrint(arena, "{s}.rc", .{src_basename});
         const res_basename = try std.fmt.allocPrint(arena, "{s}.res", .{src_basename});
-        const digest = if (.hit == try man.check(child_progress_node)) man.hitDigestHex() else blk: {
+        var diag: Cache.Manifest.CheckDiagnostic = undefined;
+        const status = man.check(&diag, child_progress_node) catch |err| switch (err) {
+            error.OutOfMemory, error.Canceled => |e| return e,
+            error.CacheCheckFailed => return comp.failWin32Resource(win32_resource, "checking cache failed: {f}", .{
+                diag.fmt(&man),
+            }),
+        };
+        log.debug("win32 resource cache {f}", .{status.fmt(&man)});
+        const digest = if (status == .hit) man.hitDigestHex() else miss: {
             // The digest only depends on the .manifest file, so we can
             // get the digest now and write the .res directly to the cache
             const digest = man.missDigestHex();
 @@ -5961,7 +5977,7 @@ fn updateWin32Resource(comp: *Compilation, win32_resource: *Win32Resource, win32
             try spawnZigRc(comp, win32_resource, arena, argv.items, child_progress_node);
-            break :blk digest;
+            break :miss digest;
         };
         if (man.have_exclusive_lock) {
 @@ -5988,7 +6004,15 @@ fn updateWin32Resource(comp: *Compilation, win32_resource: *Win32Resource, win32
     const rc_basename_noext = src_basename[0 .. src_basename.len - fs.path.extension(src_basename).len];
-    const digest = if (.hit == try man.check(child_progress_node)) man.hitDigestHex() else blk: {
+    var diagnostic: Cache.Manifest.CheckDiagnostic = undefined;
+    const status = man.check(&diagnostic, child_progress_node) catch |err| switch (err) {
+        error.OutOfMemory, error.Canceled => |e| return e,
+        error.CacheCheckFailed => return comp.failWin32Resource(win32_resource, "checking cache failed: {f}", .{
+            diagnostic.fmt(&man),
+        }),
+    };
+    log.debug("win32 resource cache {f}", .{status.fmt(&man)});
+    const digest = if (status == .hit) man.hitDigestHex() else miss: {
         var zig_cache_tmp_dir = try comp.dirs.local_cache.handle.createDirPathOpen(io, "tmp", .{});
         defer zig_cache_tmp_dir.close(io);
 @@ -6066,7 +6090,7 @@ fn updateWin32Resource(comp: *Compilation, win32_resource: *Win32Resource, win32
         defer o_dir.close(io);
         const tmp_basename = fs.path.basename(out_res_path);
         try Io.Dir.rename(zig_cache_tmp_dir, tmp_basename, o_dir, res_filename, io);
-        break :blk digest;
+        break :miss digest;
     };
     if (man.have_exclusive_lock) {

src/Sema.zig+4-8

...	@@ -12974,7 +12974,7 @@ fn zirEmbedFile(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!A	...	@@ -12974,7 +12974,7 @@ fn zirEmbedFile(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!A
12974		12974
12975	const result = ef_idx.get(zcu);	12975	const result = ef_idx.get(zcu);
12976	if (result.val == .none) {	12976	if (result.val == .none) {
12977	return sema.fail(block, operand_src, "unable to open '{s}': {s}", .{ name, @errorName(result.err.?) });	12977	return sema.fail(block, operand_src, "failed opening {q}: {t}", .{ name, result.err.? });
12978	}	12978	}
12979		12979
12980	return Air.internedToRef(result.val);	12980	return Air.internedToRef(result.val);
...	@@ -15911,9 +15911,7 @@ fn zirClosureGet(sema: Sema, block: Block, extended: Zir.Inst.Extended.InstDat	...	@@ -15911,9 +15911,7 @@ fn zirClosureGet(sema: Sema, block: Block, extended: Zir.Inst.Extended.InstDat
15911	const file, const src_base_node = Zcu.LazySrcLoc.resolveBaseNode(block.src_base_inst, zcu).?;	15911	const file, const src_base_node = Zcu.LazySrcLoc.resolveBaseNode(block.src_base_inst, zcu).?;
15912	const tree = file.getTree(zcu) catch \|err\| {	15912	const tree = file.getTree(zcu) catch \|err\| {
15913	// In this case we emit a warning + a less precise source location.	15913	// In this case we emit a warning + a less precise source location.
15914	log.warn("unable to load {f}: {s}", .{	15914	log.warn("failed loading {qf}: {t}", .{ file.path.fmt(zcu.comp), err });
15915	file.path.fmt(zcu.comp), @errorName(err),
15916	});
15917	break :name null;	15915	break :name null;
15918	};	15916	};
15919	const node = src_node.toAbsolute(src_base_node);	15917	const node = src_node.toAbsolute(src_base_node);
...	@@ -15939,9 +15937,7 @@ fn zirClosureGet(sema: Sema, block: Block, extended: Zir.Inst.Extended.InstDat	...	@@ -15939,9 +15937,7 @@ fn zirClosureGet(sema: Sema, block: Block, extended: Zir.Inst.Extended.InstDat
15939	const file, const src_base_node = Zcu.LazySrcLoc.resolveBaseNode(block.src_base_inst, zcu).?;	15937	const file, const src_base_node = Zcu.LazySrcLoc.resolveBaseNode(block.src_base_inst, zcu).?;
15940	const tree = file.getTree(zcu) catch \|err\| {	15938	const tree = file.getTree(zcu) catch \|err\| {
15941	// In this case we emit a warning + a less precise source location.	15939	// In this case we emit a warning + a less precise source location.
15942	log.warn("unable to load {f}: {s}", .{	15940	log.warn("failed loading {qf}: {t}", .{ file.path.fmt(zcu.comp), err });
15943	file.path.fmt(zcu.comp), @errorName(err),
15944	});
15945	break :name null;	15941	break :name null;
15946	};	15942	};
15947	const node = src_node.toAbsolute(src_base_node);	15943	const node = src_node.toAbsolute(src_base_node);
...	@@ -15950,7 +15946,7 @@ fn zirClosureGet(sema: Sema, block: Block, extended: Zir.Inst.Extended.InstDat	...	@@ -15950,7 +15946,7 @@ fn zirClosureGet(sema: Sema, block: Block, extended: Zir.Inst.Extended.InstDat
15950	};	15946	};
15951		15947
15952	const msg = if (name) \|some\|	15948	const msg = if (name) \|some\|
15953	try sema.errMsg(src, "'{s}' not accessible from inner function", .{some})	15949	try sema.errMsg(src, "{q} not accessible from inner function", .{some})
15954	else	15950	else
15955	try sema.errMsg(src, "variable not accessible from inner function", .{});	15951	try sema.errMsg(src, "variable not accessible from inner function", .{});
15956	errdefer msg.destroy(sema.gpa);	15952	errdefer msg.destroy(sema.gpa);

src/libs/freebsd.zig+14-1

...	@@ -465,7 +465,20 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) anye	...	@@ -465,7 +465,20 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) anye
465	.request_contents = true,	465	.request_contents = true,
466	});	466	});
467		467
468	if (.hit == try man.check(prog_node)) {	468	var diag: Cache.Manifest.CheckDiagnostic = undefined;
		469	const status = man.check(&diag, prog_node) catch \|err\| switch (err) {
		470	error.OutOfMemory, error.Canceled => \|e\| return e,
		471	error.CacheCheckFailed => {
		472	comp.lockAndSetMiscFailure(
		473	.freebsd_shared_objects,
		474	"compiling FreeBSD libc shared objects: checking cache failed: {f}",
		475	.{diag.fmt(&man)},
		476	);
		477	return error.AlreadyReported;
		478	},
		479	};
		480	log.debug("freebsd_shared_objects cache {f}", .{status.fmt(&man)});
		481	if (status == .hit) {
469	const digest = man.hitDigestHex();	482	const digest = man.hitDigestHex();
470	return queueSharedObjects(comp, .{	483	return queueSharedObjects(comp, .{
471	.lock = man.toOwnedLock(),	484	.lock = man.toOwnedLock(),

src/libs/glibc.zig+14-1

...	@@ -705,7 +705,20 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) anye	...	@@ -705,7 +705,20 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) anye
705	.request_contents = true,	705	.request_contents = true,
706	});	706	});
707		707
708	if (.hit == try man.check(prog_node)) {	708	var diag: Cache.Manifest.CheckDiagnostic = undefined;
		709	const status = man.check(&diag, prog_node) catch \|err\| switch (err) {
		710	error.OutOfMemory, error.Canceled => \|e\| return e,
		711	error.CacheCheckFailed => {
		712	comp.lockAndSetMiscFailure(
		713	.glibc_shared_objects,
		714	"compiling glibc shared objects: checking cache failed: {f}",
		715	.{diag.fmt(&man)},
		716	);
		717	return error.AlreadyReported;
		718	},
		719	};
		720	log.debug("glibc_shared_objects cache {f}", .{status.fmt(&man)});
		721	if (status == .hit) {
709	const digest = man.hitDigestHex();	722	const digest = man.hitDigestHex();
710	return queueSharedObjects(comp, .{	723	return queueSharedObjects(comp, .{
711	.lock = man.toOwnedLock(),	724	.lock = man.toOwnedLock(),

src/libs/mingw.zig+8-17

 @@ -251,26 +251,17 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8, prog_node: std.P
     const final_lib_basename = try std.fmt.allocPrint(gpa, "{s}.lib", .{lib_name});
     errdefer gpa.free(final_lib_basename);
-    const status = man.check(prog_node) catch |err| switch (err) {
+    var diag: Cache.Manifest.CheckDiagnostic = undefined;
-        error.CacheCheckFailed => switch (man.diagnostic) {
+    const status = man.check(&diag, prog_node) catch |err| switch (err) {
-            .none => unreachable,
+        error.CacheCheckFailed => {
-            .manifest_oversize => {
+            comp.setMiscFailure(.windows_import_lib, "{s} cache check failed: {f}", .{
-                comp.setMiscFailure(.windows_import_lib, "checking cache failed: {t}", .{man.diagnostic});
+                final_lib_basename, diag.fmt(&man),
-                return error.AlreadyReported;
+            });
-            },
+            return error.AlreadyReported;
-            .manifest_create, .manifest_stat, .manifest_read, .manifest_lock => |e| {
-                comp.setMiscFailure(.windows_import_lib, "checking cache failed: {t} {t}", .{ man.diagnostic, e });
-                return error.AlreadyReported;
-            },
-            .file_open, .file_stat, .file_read, .file_hash => |op| {
-                comp.setMiscFailure(.windows_import_lib, "checking cache failed: {f} {t} {t}", .{
-                    op.path(&man), man.diagnostic, op.err,
-                });
-                return error.AlreadyReported;
-            },
         },
         error.OutOfMemory, error.Canceled => |e| return e,
     };
+    log.debug("{s} cache {f}", .{ final_lib_basename, status.fmt(&man) });
     if (status == .hit) {
         const digest = man.hitDigestHex();
         const sub_path = try std.fs.path.join(gpa, &.{ "o", &digest, final_lib_basename });

src/libs/netbsd.zig+14-1

...	@@ -413,7 +413,20 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) anye	...	@@ -413,7 +413,20 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) anye
413	.request_contents = true,	413	.request_contents = true,
414	});	414	});
415		415
416	if (.hit == try man.check(prog_node)) {	416	var diag: Cache.Manifest.CheckDiagnostic = undefined;
		417	const status = man.check(&diag, prog_node) catch \|err\| switch (err) {
		418	error.CacheCheckFailed => {
		419	comp.lockAndSetMiscFailure(
		420	.netbsd_shared_objects,
		421	"compiling NetBSD libc shared objects: checking cache failed: {f}",
		422	.{diag.fmt(&man)},
		423	);
		424	return error.AlreadyReported;
		425	},
		426	error.OutOfMemory, error.Canceled => \|e\| return e,
		427	};
		428	log.debug("netbsd_shared_objects cache {f}", .{status.fmt(&man)});
		429	if (status == .hit) {
417	const digest = man.hitDigestHex();	430	const digest = man.hitDigestHex();
418	return queueSharedObjects(comp, .{	431	return queueSharedObjects(comp, .{
419	.lock = man.toOwnedLock(),	432	.lock = man.toOwnedLock(),

src/libs/openbsd.zig+14-1

...	@@ -334,7 +334,20 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) anye	...	@@ -334,7 +334,20 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) anye
334	.request_contents = true,	334	.request_contents = true,
335	});	335	});
336		336
337	if (.hit == try man.check(prog_node)) {	337	var diag: Cache.Manifest.CheckDiagnostic = undefined;
		338	const status = man.check(&diag, prog_node) catch \|err\| switch (err) {
		339	error.OutOfMemory, error.Canceled => \|e\| return e,
		340	error.CacheCheckFailed => {
		341	comp.lockAndSetMiscFailure(
		342	.openbsd_shared_objects,
		343	"compiling OpenBSD libc shared objects: checking cache failed: {f}",
		344	.{diag.fmt(&man)},
		345	);
		346	return error.AlreadyReported;
		347	},
		348	};
		349	log.debug("openbsd_shared_objects cache {f}", .{status.fmt(&man)});
		350	if (status == .hit) {
338	const digest = man.hitDigestHex();	351	const digest = man.hitDigestHex();
339	return queueSharedObjects(comp, .{	352	return queueSharedObjects(comp, .{
340	.lock = man.toOwnedLock(),	353	.lock = man.toOwnedLock(),

src/main.zig+7-1

 @@ -4878,7 +4878,13 @@ fn cmdTranslateC(
     Compilation.cache_helpers.hashCSource(&man, c_source_file) catch |err|
         fatal("unable to process {q}: {t}", .{ c_source_file.src_path, err });
-    const result: Compilation.TranslateCResult = if (.hit == try man.check(prog_node)) .{
+    var diag: Cache.Manifest.CheckDiagnostic = undefined;
+    const status = man.check(&diag, prog_node) catch |err| switch (err) {
+        error.OutOfMemory, error.Canceled => |e| return e,
+        error.CacheCheckFailed => fatal("translate-c checking cache failed: {f}", .{diag.fmt(&man)}),
+    };
+    std.log.debug("translate-c cache {f}", .{status.fmt(&man)});
+    const result: Compilation.TranslateCResult = if (status == .hit) .{
         .digest = man.hitDigest(),
         .cache_hit = true,
         .errors = std.zig.ErrorBundle.empty,

test/incremental/bad_import+2-2

...	@@ -10,7 +10,7 @@ const io = std.Io.Threaded.global_single_threaded.io();	...	@@ -10,7 +10,7 @@ const io = std.Io.Threaded.global_single_threaded.io();
10	comptime {	10	comptime {
11	_ = @import("bad.zig");	11	_ = @import("bad.zig");
12	}	12	}
13	#expect_error=bad.zig:1:1: error: unable to load 'bad.zig': FileNotFound	13	#expect_error=bad.zig:1:1: error: unable to load "bad.zig": FileNotFound
14	#expect_error=foo.zig:2:17: note: file imported here	14	#expect_error=foo.zig:2:17: note: file imported here
15		15
16	#update=change bad import	16	#update=change bad import
...	@@ -18,7 +18,7 @@ comptime {	...	@@ -18,7 +18,7 @@ comptime {
18	comptime {	18	comptime {
19	_ = @import("this_is/not_real.zig");	19	_ = @import("this_is/not_real.zig");
20	}	20	}
21	#expect_error=this_is/not_real.zig:1:1: error: unable to load 'not_real.zig': FileNotFound	21	#expect_error=this_is/not_real.zig:1:1: error: unable to load "not_real.zig": FileNotFound
22	#expect_error=foo.zig:2:17: note: file imported here	22	#expect_error=foo.zig:2:17: note: file imported here
23		23
24	#update=remove import of 'foo.zig'	24	#update=remove import of 'foo.zig'

test/incremental/change_embed_file+2-2

...	@@ -17,7 +17,7 @@ Hello again, World!	...	@@ -17,7 +17,7 @@ Hello again, World!
17		17
18	#update=delete file	18	#update=delete file
19	#rm_file=string.txt	19	#rm_file=string.txt
20	#expect_error=main.zig:2:27: error: unable to open 'string.txt': FileNotFound	20	#expect_error=main.zig:2:27: error: failed opening "string.txt": FileNotFound
21		21
22	#update=remove reference to file	22	#update=remove reference to file
23	#file=main.zig	23	#file=main.zig
...	@@ -37,7 +37,7 @@ pub fn main() !void {	...	@@ -37,7 +37,7 @@ pub fn main() !void {
37	try std.Io.File.stdout().writeStreamingAll(io, string);	37	try std.Io.File.stdout().writeStreamingAll(io, string);
38	}	38	}
39	const io = std.Io.Threaded.global_single_threaded.io();	39	const io = std.Io.Threaded.global_single_threaded.io();
40	#expect_error=main.zig:2:27: error: unable to open 'string.txt': FileNotFound	40	#expect_error=main.zig:2:27: error: failed opening "string.txt": FileNotFound
41		41
42	#update=recreate file	42	#update=recreate file
43	#file=string.txt	43	#file=string.txt

test/incremental/change_zon_file+2-2

...	@@ -17,7 +17,7 @@ const io = std.Io.Threaded.global_single_threaded.io();	...	@@ -17,7 +17,7 @@ const io = std.Io.Threaded.global_single_threaded.io();
17		17
18	#update=delete file	18	#update=delete file
19	#rm_file=message.zon	19	#rm_file=message.zon
20	#expect_error=message.zon:1:1: error: unable to load 'message.zon': FileNotFound	20	#expect_error=message.zon:1:1: error: unable to load "message.zon": FileNotFound
21	#expect_error=main.zig:2:37: note: file imported here	21	#expect_error=main.zig:2:37: note: file imported here
22		22
23	#update=remove reference to ZON file	23	#update=remove reference to ZON file
...	@@ -28,7 +28,7 @@ pub fn main() !void {	...	@@ -28,7 +28,7 @@ pub fn main() !void {
28	try std.Io.File.stdout().writeStreamingAll(io, "a hardcoded string\n");	28	try std.Io.File.stdout().writeStreamingAll(io, "a hardcoded string\n");
29	}	29	}
30	const io = std.Io.Threaded.global_single_threaded.io();	30	const io = std.Io.Threaded.global_single_threaded.io();
31	#expect_error=message.zon:1:1: error: unable to load 'message.zon': FileNotFound	31	#expect_error=message.zon:1:1: error: unable to load "message.zon": FileNotFound
32	#expect_error=main.zig:2:37: note: file imported here	32	#expect_error=main.zig:2:37: note: file imported here
33		33
34	#update=recreate ZON file	34	#update=recreate ZON file