Merge branch 'master' into add-no-undefined-version-linker-arg

Author: behos

ci/x86_64-windows-debug.ps1

@@ -96,9 +96,8 @@ Enter-VsDevShell -VsInstallPath "C:\Program Files\Microsoft Visual Studio\2022\E
 CheckLastExitCode
 
 Write-Output "Build and run behavior tests with msvc..."
-Write-Output "Skipped due to https://github.com/ziglang/zig/issues/17817"
-#& cl.exe -I..\lib test-x86_64-windows-msvc.c compiler_rt-x86_64-windows-msvc.c /W3 /Z7 -link -nologo -debug -subsystem:console kernel32.lib ntdll.lib libcmt.lib
-#CheckLastExitCode
-#
-#& .\test-x86_64-windows-msvc.exe
-#CheckLastExitCode
+& cl.exe -I..\lib test-x86_64-windows-msvc.c compiler_rt-x86_64-windows-msvc.c /W3 /Z7 -link -nologo -debug -subsystem:console kernel32.lib ntdll.lib libcmt.lib
+CheckLastExitCode
+
+& .\test-x86_64-windows-msvc.exe
+CheckLastExitCode

ci/x86_64-windows-release.ps1

@@ -95,9 +95,8 @@ Enter-VsDevShell -VsInstallPath "C:\Program Files\Microsoft Visual Studio\2022\E
 CheckLastExitCode
 
 Write-Output "Build and run behavior tests with msvc..."
-Write-Output "Skipped due to https://github.com/ziglang/zig/issues/17817"
-#& cl.exe -I..\lib test-x86_64-windows-msvc.c compiler_rt-x86_64-windows-msvc.c /W3 /Z7 -link -nologo -debug -subsystem:console kernel32.lib ntdll.lib libcmt.lib
-#CheckLastExitCode
-#
-#& .\test-x86_64-windows-msvc.exe
-#CheckLastExitCode
+& cl.exe -I..\lib test-x86_64-windows-msvc.c compiler_rt-x86_64-windows-msvc.c /W3 /Z7 -link -nologo -debug -subsystem:console kernel32.lib ntdll.lib libcmt.lib
+CheckLastExitCode
+
+& .\test-x86_64-windows-msvc.exe
+CheckLastExitCode

lib/std/Build.zig

@@ -1551,7 +1551,7 @@ pub fn fmt(self: *Build, comptime format: []const u8, args: anytype) []u8 {
 
 pub fn findProgram(self: *Build, names: []const []const u8, paths: []const []const u8) ![]const u8 {
     // TODO report error for ambiguous situations
-    const exe_extension = @as(Target.Query, .{}).exeFileExt();
+    const exe_extension = self.host.result.exeFileExt();
     for (self.search_prefixes.items) |search_prefix| {
         for (names) |name| {
             if (fs.path.isAbsolute(name)) {

lib/std/Build/Cache.zig

@@ -179,6 +179,7 @@ fn getPrefixSubpath(allocator: Allocator, prefix: []const u8, path: []u8) ![]u8
 pub const bin_digest_len = 16;
 pub const hex_digest_len = bin_digest_len * 2;
 pub const BinDigest = [bin_digest_len]u8;
+pub const HexDigest = [hex_digest_len]u8;
 
 /// This is currently just an arbitrary non-empty string that can't match another manifest line.
 const manifest_header = "0";
@@ -300,11 +301,11 @@ pub const HashHelper = struct {
     }
 
     /// Returns a hex encoded hash of the inputs, mutating the state of the hasher.
-    pub fn final(hh: *HashHelper) [hex_digest_len]u8 {
+    pub fn final(hh: *HashHelper) HexDigest {
         var bin_digest: BinDigest = undefined;
         hh.hasher.final(&bin_digest);
 
-        var out_digest: [hex_digest_len]u8 = undefined;
+        var out_digest: HexDigest = undefined;
         _ = fmt.bufPrint(
             &out_digest,
             "{s}",
@@ -360,7 +361,7 @@ pub const Manifest = struct {
     // will then use the same timestamp, to avoid unnecessary filesystem writes.
     want_refresh_timestamp: bool = true,
     files: std.ArrayListUnmanaged(File) = .{},
-    hex_digest: [hex_digest_len]u8,
+    hex_digest: HexDigest,
     /// Populated when hit() returns an error because of one
     /// of the files listed in the manifest.
     failed_file_index: ?usize = null,
@@ -843,7 +844,7 @@ pub const Manifest = struct {
     }
 
     /// Returns a hex encoded hash of the inputs.
-    pub fn final(self: *Manifest) [hex_digest_len]u8 {
+    pub fn final(self: *Manifest) HexDigest {
         assert(self.manifest_file != null);
 
         // We don't close the manifest file yet, because we want to
@@ -855,7 +856,7 @@ pub const Manifest = struct {
         var bin_digest: BinDigest = undefined;
         self.hash.hasher.final(&bin_digest);
 
-        var out_digest: [hex_digest_len]u8 = undefined;
+        var out_digest: HexDigest = undefined;
         _ = fmt.bufPrint(
             &out_digest,
             "{s}",
@@ -1035,8 +1036,8 @@ test "cache file and then recall it" {
         std.time.sleep(1);
     }
 
-    var digest1: [hex_digest_len]u8 = undefined;
-    var digest2: [hex_digest_len]u8 = undefined;
+    var digest1: HexDigest = undefined;
+    var digest2: HexDigest = undefined;
 
     {
         var cache = Cache{
@@ -1103,8 +1104,8 @@ test "check that changing a file makes cache fail" {
         std.time.sleep(1);
     }
 
-    var digest1: [hex_digest_len]u8 = undefined;
-    var digest2: [hex_digest_len]u8 = undefined;
+    var digest1: HexDigest = undefined;
+    var digest2: HexDigest = undefined;
 
     {
         var cache = Cache{
@@ -1166,8 +1167,8 @@ test "no file inputs" {
 
     const temp_manifest_dir = "no_file_inputs_manifest_dir";
 
-    var digest1: [hex_digest_len]u8 = undefined;
-    var digest2: [hex_digest_len]u8 = undefined;
+    var digest1: HexDigest = undefined;
+    var digest2: HexDigest = undefined;
 
     var cache = Cache{
         .gpa = testing.allocator,
@@ -1225,9 +1226,9 @@ test "Manifest with files added after initial hash work" {
         std.time.sleep(1);
     }
 
-    var digest1: [hex_digest_len]u8 = undefined;
-    var digest2: [hex_digest_len]u8 = undefined;
-    var digest3: [hex_digest_len]u8 = undefined;
+    var digest1: HexDigest = undefined;
+    var digest2: HexDigest = undefined;
+    var digest3: HexDigest = undefined;
 
     {
         var cache = Cache{

lib/std/Build/Step/Run.zig

@@ -243,7 +243,7 @@ pub fn addDepFileOutputArg(self: *Run, basename: []const u8) std.Build.LazyPath
 /// Add a prefixed path argument to a dep file (.d) for the child process to
 /// write its discovered additional dependencies.
 /// Only one dep file argument is allowed by instance.
-pub fn addPrefixedDepFileOutputArg(self: *Run, prefix: []const u8, basename: []const u8) void {
+pub fn addPrefixedDepFileOutputArg(self: *Run, prefix: []const u8, basename: []const u8) std.Build.LazyPath {
     assert(self.dep_output_file == null);
 
     const b = self.step.owner;
@@ -258,6 +258,8 @@ pub fn addPrefixedDepFileOutputArg(self: *Run, prefix: []const u8, basename: []c
     self.dep_output_file = dep_file;
 
     self.argv.append(.{ .output = dep_file }) catch @panic("OOM");
+
+    return .{ .generated = &dep_file.generated_file };
 }
 
 pub fn addArg(self: *Run, arg: []const u8) void {
@@ -448,17 +450,18 @@ fn checksContainStderr(checks: []const StdIo.Check) bool {
     return false;
 }
 
+const IndexedOutput = struct {
+    index: usize,
+    output: *Output,
+};
 fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     const b = step.owner;
     const arena = b.allocator;
     const self = @fieldParentPtr(Run, "step", step);
     const has_side_effects = self.hasSideEffects();
 
     var argv_list = ArrayList([]const u8).init(arena);
-    var output_placeholders = ArrayList(struct {
-        index: usize,
-        output: *Output,
-    }).init(arena);
+    var output_placeholders = ArrayList(IndexedOutput).init(arena);
 
     var man = b.cache.obtain();
     defer man.deinit();
@@ -540,32 +543,25 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     if (try step.cacheHit(&man)) {
         // cache hit, skip running command
         const digest = man.final();
-        for (output_placeholders.items) |placeholder| {
-            placeholder.output.generated_file.path = try b.cache_root.join(arena, &.{
-                "o", &digest, placeholder.output.basename,
-            });
-        }
 
-        if (self.captured_stdout) |output| {
-            output.generated_file.path = try b.cache_root.join(arena, &.{
-                "o", &digest, output.basename,
-            });
-        }
-
-        if (self.captured_stderr) |output| {
-            output.generated_file.path = try b.cache_root.join(arena, &.{
-                "o", &digest, output.basename,
-            });
-        }
+        try populateGeneratedPaths(
+            arena,
+            output_placeholders.items,
+            self.captured_stdout,
+            self.captured_stderr,
+            b.cache_root,
+            &digest,
+        );
 
         step.result_cached = true;
         return;
     }
 
-    const digest = man.final();
+    const rand_int = std.crypto.random.int(u64);
+    const tmp_dir_path = "tmp" ++ fs.path.sep_str ++ std.Build.hex64(rand_int);
 
     for (output_placeholders.items) |placeholder| {
-        const output_components = .{ "o", &digest, placeholder.output.basename };
+        const output_components = .{ tmp_dir_path, placeholder.output.basename };
         const output_sub_path = try fs.path.join(arena, &output_components);
         const output_sub_dir_path = fs.path.dirname(output_sub_path).?;
         b.cache_root.handle.makePath(output_sub_dir_path) catch |err| {
@@ -582,12 +578,83 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
         argv_list.items[placeholder.index] = cli_arg;
     }
 
-    try runCommand(self, argv_list.items, has_side_effects, &digest, prog_node);
+    try runCommand(self, argv_list.items, has_side_effects, tmp_dir_path, prog_node);
 
     if (self.dep_output_file) |dep_output_file|
         try man.addDepFilePost(std.fs.cwd(), dep_output_file.generated_file.getPath());
 
+    const digest = man.final();
+
+    const any_output = output_placeholders.items.len > 0 or
+        self.captured_stdout != null or self.captured_stderr != null;
+
+    // Rename into place
+    if (any_output) {
+        const o_sub_path = "o" ++ fs.path.sep_str ++ &digest;
+
+        b.cache_root.handle.rename(tmp_dir_path, o_sub_path) catch |err| {
+            if (err == error.PathAlreadyExists) {
+                b.cache_root.handle.deleteTree(o_sub_path) catch |del_err| {
+                    return step.fail("unable to remove dir '{}'{s}: {s}", .{
+                        b.cache_root,
+                        tmp_dir_path,
+                        @errorName(del_err),
+                    });
+                };
+                b.cache_root.handle.rename(tmp_dir_path, o_sub_path) catch |retry_err| {
+                    return step.fail("unable to rename dir '{}{s}' to '{}{s}': {s}", .{
+                        b.cache_root,          tmp_dir_path,
+                        b.cache_root,          o_sub_path,
+                        @errorName(retry_err),
+                    });
+                };
+            } else {
+                return step.fail("unable to rename dir '{}{s}' to '{}{s}': {s}", .{
+                    b.cache_root,    tmp_dir_path,
+                    b.cache_root,    o_sub_path,
+                    @errorName(err),
+                });
+            }
+        };
+    }
+
     try step.writeManifest(&man);
+
+    try populateGeneratedPaths(
+        arena,
+        output_placeholders.items,
+        self.captured_stdout,
+        self.captured_stderr,
+        b.cache_root,
+        &digest,
+    );
+}
+
+fn populateGeneratedPaths(
+    arena: std.mem.Allocator,
+    output_placeholders: []const IndexedOutput,
+    captured_stdout: ?*Output,
+    captured_stderr: ?*Output,
+    cache_root: Build.Cache.Directory,
+    digest: *const Build.Cache.HexDigest,
+) !void {
+    for (output_placeholders) |placeholder| {
+        placeholder.output.generated_file.path = try cache_root.join(arena, &.{
+            "o", digest, placeholder.output.basename,
+        });
+    }
+
+    if (captured_stdout) |output| {
+        output.generated_file.path = try cache_root.join(arena, &.{
+            "o", digest, output.basename,
+        });
+    }
+
+    if (captured_stderr) |output| {
+        output.generated_file.path = try cache_root.join(arena, &.{
+            "o", digest, output.basename,
+        });
+    }
 }
 
 fn formatTerm(
@@ -639,7 +706,7 @@ fn runCommand(
     self: *Run,
     argv: []const []const u8,
     has_side_effects: bool,
-    digest: ?*const [std.Build.Cache.hex_digest_len]u8,
+    tmp_dir_path: ?[]const u8,
     prog_node: *std.Progress.Node,
 ) !void {
     const step = &self.step;
@@ -812,7 +879,7 @@ fn runCommand(
         },
     }) |stream| {
         if (stream.captured) |output| {
-            const output_components = .{ "o", digest.?, output.basename };
+            const output_components = .{ tmp_dir_path.?, output.basename };
             const output_path = try b.cache_root.join(arena, &output_components);
             output.generated_file.path = output_path;
 

lib/std/debug.zig

@@ -853,8 +853,8 @@ test "machoSearchSymbols" {
         .{ .addr = 300, .strx = undefined, .size = undefined, .ofile = undefined },
     };
 
-    try testing.expectEqual(@as(?*const MachoSymbol, null), machoSearchSymbols(&symbols, 0));
-    try testing.expectEqual(@as(?*const MachoSymbol, null), machoSearchSymbols(&symbols, 99));
+    try testing.expectEqual(null, machoSearchSymbols(&symbols, 0));
+    try testing.expectEqual(null, machoSearchSymbols(&symbols, 99));
     try testing.expectEqual(&symbols[0], machoSearchSymbols(&symbols, 100).?);
     try testing.expectEqual(&symbols[0], machoSearchSymbols(&symbols, 150).?);
     try testing.expectEqual(&symbols[0], machoSearchSymbols(&symbols, 199).?);

lib/std/http.zig

@@ -283,8 +283,8 @@ pub const Status = enum(u10) {
     }
 
     test {
-        try std.testing.expectEqual(@as(?Status.Class, Status.Class.success), Status.ok.class());
-        try std.testing.expectEqual(@as(?Status.Class, Status.Class.client_error), Status.not_found.class());
+        try std.testing.expectEqual(Status.Class.success, Status.ok.class());
+        try std.testing.expectEqual(Status.Class.client_error, Status.not_found.class());
     }
 };
 

lib/std/json/static_test.zig

@@ -373,19 +373,19 @@ test "test all types" {
 test "parse" {
     try testing.expectEqual(false, try parseFromSliceLeaky(bool, testing.allocator, "false", .{}));
     try testing.expectEqual(true, try parseFromSliceLeaky(bool, testing.allocator, "true", .{}));
-    try testing.expectEqual(@as(u1, 1), try parseFromSliceLeaky(u1, testing.allocator, "1", .{}));
+    try testing.expectEqual(1, try parseFromSliceLeaky(u1, testing.allocator, "1", .{}));
     try testing.expectError(error.Overflow, parseFromSliceLeaky(u1, testing.allocator, "50", .{}));
-    try testing.expectEqual(@as(u64, 42), try parseFromSliceLeaky(u64, testing.allocator, "42", .{}));
-    try testing.expectEqual(@as(f64, 42), try parseFromSliceLeaky(f64, testing.allocator, "42.0", .{}));
-    try testing.expectEqual(@as(?bool, null), try parseFromSliceLeaky(?bool, testing.allocator, "null", .{}));
-    try testing.expectEqual(@as(?bool, true), try parseFromSliceLeaky(?bool, testing.allocator, "true", .{}));
+    try testing.expectEqual(42, try parseFromSliceLeaky(u64, testing.allocator, "42", .{}));
+    try testing.expectEqual(42, try parseFromSliceLeaky(f64, testing.allocator, "42.0", .{}));
+    try testing.expectEqual(null, try parseFromSliceLeaky(?bool, testing.allocator, "null", .{}));
+    try testing.expectEqual(true, try parseFromSliceLeaky(?bool, testing.allocator, "true", .{}));
 
-    try testing.expectEqual(@as([3]u8, "foo".*), try parseFromSliceLeaky([3]u8, testing.allocator, "\"foo\"", .{}));
-    try testing.expectEqual(@as([3]u8, "foo".*), try parseFromSliceLeaky([3]u8, testing.allocator, "[102, 111, 111]", .{}));
-    try testing.expectEqual(@as([0]u8, undefined), try parseFromSliceLeaky([0]u8, testing.allocator, "[]", .{}));
+    try testing.expectEqual("foo".*, try parseFromSliceLeaky([3]u8, testing.allocator, "\"foo\"", .{}));
+    try testing.expectEqual("foo".*, try parseFromSliceLeaky([3]u8, testing.allocator, "[102, 111, 111]", .{}));
+    try testing.expectEqual(undefined, try parseFromSliceLeaky([0]u8, testing.allocator, "[]", .{}));
 
-    try testing.expectEqual(@as(u64, 12345678901234567890), try parseFromSliceLeaky(u64, testing.allocator, "\"12345678901234567890\"", .{}));
-    try testing.expectEqual(@as(f64, 123.456), try parseFromSliceLeaky(f64, testing.allocator, "\"123.456\"", .{}));
+    try testing.expectEqual(12345678901234567890, try parseFromSliceLeaky(u64, testing.allocator, "\"12345678901234567890\"", .{}));
+    try testing.expectEqual(123.456, try parseFromSliceLeaky(f64, testing.allocator, "\"123.456\"", .{}));
 }
 
 test "parse into enum" {
@@ -394,9 +394,9 @@ test "parse into enum" {
         Bar,
         @"with\\escape",
     };
-    try testing.expectEqual(@as(T, .Foo), try parseFromSliceLeaky(T, testing.allocator, "\"Foo\"", .{}));
-    try testing.expectEqual(@as(T, .Foo), try parseFromSliceLeaky(T, testing.allocator, "42", .{}));
-    try testing.expectEqual(@as(T, .@"with\\escape"), try parseFromSliceLeaky(T, testing.allocator, "\"with\\\\escape\"", .{}));
+    try testing.expectEqual(.Foo, try parseFromSliceLeaky(T, testing.allocator, "\"Foo\"", .{}));
+    try testing.expectEqual(.Foo, try parseFromSliceLeaky(T, testing.allocator, "42", .{}));
+    try testing.expectEqual(.@"with\\escape", try parseFromSliceLeaky(T, testing.allocator, "\"with\\\\escape\"", .{}));
     try testing.expectError(error.InvalidEnumTag, parseFromSliceLeaky(T, testing.allocator, "5", .{}));
     try testing.expectError(error.InvalidEnumTag, parseFromSliceLeaky(T, testing.allocator, "\"Qux\"", .{}));
 }

lib/std/math.zig

@@ -1266,6 +1266,7 @@ pub fn lerp(a: anytype, b: anytype, t: anytype) @TypeOf(a, b, t) {
 }
 
 test "lerp" {
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/17884
     if (builtin.zig_backend == .stage2_x86_64 and
         !comptime std.Target.x86.featureSetHas(builtin.cpu.features, .fma)) return error.SkipZigTest;