zig

commit 149e611688b012b6f99e0c07a0f5eba22f7cc8b0 (tree)
parent 67b18eadb907fcceb58129363f9f38a5cb2e1056
Author: Motiejus Jakštys <motiejus@jakstys.lt>
Date:   Thu, 19 Feb 2026 20:19:14 +0000

Fix test-zig0 cache invalidation on every commit

The git-describe version string (including commit hash) was passed via
exe_options to zig_internals_mod, causing verbose_dumper to recompile
(~7 min) after every commit. Create separate zig0_exe_options with a
fixed version "0.15.2-zig0-dev" for test-zig0/all-zig0 targets.

Also verify matched_count against c_func_count in Air comparisons to
catch spurious extra functions from the C pipeline.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Diffstat:
M
build.zig
 | 
31
++++++++++++++++++++++++++++---
M
stage0/sema_test.zig
 | 
4
++++
M
stage0/stages_test.zig
 | 
4
++++

3 files changed, 36 insertions(+), 3 deletions(-)
diff --git a/build.zig b/build.zig
@@ -252,7 +252,8 @@ pub fn build(b: *std.Build) !void {
     exe_options.addOption(bool, "llvm_has_arc", llvm_has_arc);
     exe_options.addOption(bool, "llvm_has_xtensa", llvm_has_xtensa);
     exe_options.addOption(bool, "debug_gpa", debug_gpa);
-    exe_options.addOption(DevEnv, "dev", b.option(DevEnv, "dev", "Build a compiler with a reduced feature set for development of specific features") orelse if (only_c) .bootstrap else .full);
+    const dev_mode: DevEnv = b.option(DevEnv, "dev", "Build a compiler with a reduced feature set for development of specific features") orelse if (only_c) .bootstrap else .full;
+    exe_options.addOption(DevEnv, "dev", dev_mode);
     exe_options.addOption(ValueInterpretMode, "value_interpret_mode", value_interpret_mode);
 
     if (link_libc) {
@@ -685,8 +686,32 @@ pub fn build(b: *std.Build) !void {
         break :blk b.resolveTargetQuery(query);
     };
 
+    // Separate build_options for zig0 tests with a fixed version string, so
+    // that the verbose_dumper cache is not invalidated on every git commit.
+    const zig0_exe_options = b.addOptions();
+    zig0_exe_options.addOption(u32, "mem_leak_frames", mem_leak_frames);
+    zig0_exe_options.addOption(bool, "skip_non_native", skip_non_native);
+    zig0_exe_options.addOption(bool, "have_llvm", enable_llvm);
+    zig0_exe_options.addOption(bool, "llvm_has_m68k", llvm_has_m68k);
+    zig0_exe_options.addOption(bool, "llvm_has_csky", llvm_has_csky);
+    zig0_exe_options.addOption(bool, "llvm_has_arc", llvm_has_arc);
+    zig0_exe_options.addOption(bool, "llvm_has_xtensa", llvm_has_xtensa);
+    zig0_exe_options.addOption(bool, "debug_gpa", debug_gpa);
+    zig0_exe_options.addOption(DevEnv, "dev", dev_mode);
+    zig0_exe_options.addOption(ValueInterpretMode, "value_interpret_mode", value_interpret_mode);
+    zig0_exe_options.addOption([:0]const u8, "version", try b.allocator.dupeZ(u8, "0.15.2-zig0-dev"));
+    zig0_exe_options.addOption(std.SemanticVersion, "semver", try std.SemanticVersion.parse("0.15.2-zig0-dev"));
+    zig0_exe_options.addOption(bool, "enable_debug_extensions", enable_debug_extensions);
+    zig0_exe_options.addOption(bool, "enable_logging", enable_logging);
+    zig0_exe_options.addOption(bool, "enable_link_snapshots", enable_link_snapshots);
+    zig0_exe_options.addOption(bool, "enable_tracy", tracy != null);
+    zig0_exe_options.addOption(bool, "enable_tracy_callstack", tracy_callstack);
+    zig0_exe_options.addOption(bool, "enable_tracy_allocation", tracy_allocation);
+    zig0_exe_options.addOption(u32, "tracy_callstack_depth", tracy_callstack_depth);
+    zig0_exe_options.addOption(bool, "value_tracing", value_tracing);
+
     const test_zig0_step = b.step("test-zig0", "Run zig0 C implementation tests");
-    addZig0TestStep(b, test_zig0_step, zig0_target, optimize, zig0_cc, zig0_no_exec, zig0_valgrind, zig0_test_timeout, exe_options);
+    addZig0TestStep(b, test_zig0_step, zig0_target, optimize, zig0_cc, zig0_no_exec, zig0_valgrind, zig0_test_timeout, zig0_exe_options);
 
     const fmt_zig0 = b.step("fmt-zig0", "Format zig0 C code");
     const clang_format = b.addSystemCommand(&.{ "clang-format", "-i" });
@@ -749,7 +774,7 @@ pub fn build(b: *std.Build) !void {
     all_zig0.dependOn(&zig0_fmt_check.step);
     all_zig0.dependOn(lint_zig0);
     for (zig0_compilers) |compiler| {
-        addZig0TestStep(b, all_zig0, zig0_target, optimize, compiler, false, zig0_valgrind, zig0_test_timeout, exe_options);
+        addZig0TestStep(b, all_zig0, zig0_target, optimize, compiler, false, zig0_valgrind, zig0_test_timeout, zig0_exe_options);
     }
 }
 
diff --git a/stage0/sema_test.zig b/stage0/sema_test.zig
@@ -251,6 +251,10 @@ fn semaAirRawCheck(source: [:0]const u8) !void {
         std.debug.print("zig_compare_air error: {s}\n", .{std.mem.span(e)});
         return error.AirMismatch;
     }
+    if (cmp_result.matched_count != result.c_func_air_list.len) {
+        std.debug.print("Air func count mismatch: zig matched {d}, c produced {d}\n", .{ cmp_result.matched_count, result.c_func_air_list.len });
+        return error.AirMismatch;
+    }
 }
 
 test "sema: Air raw C vs Zig comparison (empty)" {
diff --git a/stage0/stages_test.zig b/stage0/stages_test.zig
@@ -92,6 +92,10 @@ fn stagesCheck(gpa: Allocator, comptime path: []const u8, source: [:0]const u8) 
             std.debug.print("zig_compare_air error: {s}\n", .{std.mem.span(e)});
             return error.AirMismatch;
         }
+        if (cmp_result.matched_count != c_func_air_list.len) {
+            std.debug.print("Air func count mismatch: zig matched {d}, c produced {d}\n", .{ cmp_result.matched_count, c_func_air_list.len });
+            return error.AirMismatch;
+        }
     }
 }