Upstreamable zig 0.16

.github/scripts/release_prep.sh

@@ -24,7 +24,7 @@ Optionally add the following to your \`MODULE.bazel\` file to install a specific
 
 \`\`\`starlark
 zig = use_extension("//zig:extensions.bzl", "zig")
-zig.toolchain(zig_version = "0.15.2")
+zig.toolchain(zig_version = "0.16.0")
 \`\`\`
 
 You can call \`zig.toolchain\` multiple times to install multiple Zig versions.

MODULE.bazel

@@ -39,8 +39,8 @@ zig_dev = use_extension(
     "zig",
     dev_dependency = True,
 )
+zig_dev.toolchain(zig_version = "0.16.0")
 zig_dev.toolchain(zig_version = "0.15.2")
-zig_dev.toolchain(zig_version = "0.14.1")
 
 bazel_dep(name = "toolchains_buildbuddy", version = "0.0.4", dev_dependency = True)
 

e2e/workspace/MODULE.bazel

@@ -15,8 +15,8 @@ zig = use_extension(
     "zig",
     dev_dependency = True,
 )
+zig.toolchain(zig_version = "0.16.0")
 zig.toolchain(zig_version = "0.15.2")
-zig.toolchain(zig_version = "0.14.1")
 use_repo(zig, "zig_toolchains")
 
 bazel_dep(name = "toolchains_buildbuddy", version = "0.0.4", dev_dependency = True)

e2e/workspace/c-sources/main.zig

@@ -7,14 +7,22 @@ export fn getCustomGlobalSymbol() i32 {
     return custom_global_symbol;
 }
 
-pub fn main() !void {
-    if (builtin.zig_version.major == 0 and builtin.zig_version.minor >= 15) {
-        var buffer: [512]u8 = undefined;
-        var writer = std.fs.File.stdout().writer(&buffer);
-        const stdout = &writer.interface;
-        try stdout.print("{d}\n", .{getCustomGlobalSymbol()});
-        try stdout.flush();
-    } else {
-        try std.io.getStdOut().writer().print("{d}\n", .{getCustomGlobalSymbol()});
-    }
+const is_zig_0_16_or_later = builtin.zig_version.major == 0 and builtin.zig_version.minor >= 16;
+
+pub const main = if (is_zig_0_16_or_later) main_016 else main_pre_016;
+
+fn main_pre_016() !void {
+    var buffer: [512]u8 = undefined;
+    var writer = std.fs.File.stdout().writer(&buffer);
+    const stdout = &writer.interface;
+    try stdout.print("{d}\n", .{getCustomGlobalSymbol()});
+    try stdout.flush();
+}
+
+fn main_016(init: std.process.Init) !void {
+    var buffer: [512]u8 = undefined;
+    var writer = std.Io.File.stdout().writer(init.io, &buffer);
+    const stdout = &writer.interface;
+    try stdout.print("{d}\n", .{getCustomGlobalSymbol()});
+    try stdout.flush();
 }

e2e/workspace/canonical-name-module/main.zig

@@ -3,14 +3,14 @@ const std = @import("std");
 const data = @import("data");
 const other_data = @import("other/data");
 
-pub fn main() void {
-    if (builtin.zig_version.major == 0 and builtin.zig_version.minor >= 15) {
-        std.fs.File.stdout().writeAll(
-            data.hello_world,
-        ) catch unreachable;
-    } else {
-        std.io.getStdOut().writeAll(
-            data.hello_world,
-        ) catch unreachable;
-    }
+const is_zig_0_16_or_later = builtin.zig_version.major == 0 and builtin.zig_version.minor >= 16;
+
+pub const main = if (is_zig_0_16_or_later) main_016 else main_pre_016;
+
+fn main_pre_016() void {
+    std.fs.File.stdout().writeAll(data.hello_world) catch unreachable;
+}
+
+fn main_016(init: std.process.Init) void {
+    std.Io.File.writeStreamingAll(.stdout(), init.io, data.hello_world) catch unreachable;
 }

e2e/workspace/configure-mode/binary.zig

@@ -1,20 +1,22 @@
 const std = @import("std");
 const builtin = @import("builtin");
 
-pub fn main() !void {
-    if (builtin.zig_version.major == 0 and builtin.zig_version.minor >= 15) {
-        var buffer: [512]u8 = undefined;
-        var writer = std.fs.File.stdout().writer(&buffer);
-        const stdout = &writer.interface;
-        try stdout.print(
-            "{s}\n",
-            .{@tagName(builtin.mode)},
-        );
-        try stdout.flush();
-    } else {
-        try std.io.getStdOut().writer().print(
-            "{s}\n",
-            .{@tagName(builtin.mode)},
-        );
-    }
+const is_zig_0_16_or_later = builtin.zig_version.major == 0 and builtin.zig_version.minor >= 16;
+
+pub const main = if (is_zig_0_16_or_later) main_016 else main_pre_016;
+
+fn main_pre_016() !void {
+    var buffer: [512]u8 = undefined;
+    var writer = std.fs.File.stdout().writer(&buffer);
+    const stdout = &writer.interface;
+    try stdout.print("{s}\n", .{@tagName(builtin.mode)});
+    try stdout.flush();
+}
+
+fn main_016(init: std.process.Init) !void {
+    var buffer: [512]u8 = undefined;
+    var writer = std.Io.File.stdout().writer(init.io, &buffer);
+    const stdout = &writer.interface;
+    try stdout.print("{s}\n", .{@tagName(builtin.mode)});
+    try stdout.flush();
 }

e2e/workspace/configure-mode/library.zig

@@ -1,17 +1,11 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const c = if (builtin.zig_version.major == 0 and builtin.zig_version.minor >= 15)
-    std.builtin.CallingConvention.c
-else
-    std.builtin.CallingConvention.C;
+const c = std.builtin.CallingConvention.c;
 
 comptime {
     @export(&internalName, .{
         .name = @tagName(builtin.mode),
-        .linkage = if (builtin.zig_version.major == 0 and builtin.zig_version.minor == 11)
-            .Strong
-        else
-            .strong,
+        .linkage = .strong,
     });
 }
 

e2e/workspace/configure-mode/test_debug.zig

@@ -2,9 +2,5 @@ const std = @import("std");
 const builtin = @import("builtin");
 
 test "mode is Debug" {
-    const debug = if (builtin.zig_version.major == 0 and builtin.zig_version.minor >= 15)
-        std.builtin.OptimizeMode.Debug
-    else
-        std.builtin.Mode.Debug;
-    try std.testing.expectEqual(debug, builtin.mode);
+    try std.testing.expectEqual(std.builtin.OptimizeMode.Debug, builtin.mode);
 }

e2e/workspace/configure-mode/test_release_safe.zig

@@ -2,9 +2,5 @@ const std = @import("std");
 const builtin = @import("builtin");
 
 test "mode is ReleaseSafe" {
-    const release_safe = if (builtin.zig_version.major == 0 and builtin.zig_version.minor >= 15)
-        std.builtin.OptimizeMode.ReleaseSafe
-    else
-        std.builtin.Mode.ReleaseSafe;
-    try std.testing.expectEqual(release_safe, builtin.mode);
+    try std.testing.expectEqual(std.builtin.OptimizeMode.ReleaseSafe, builtin.mode);
 }

e2e/workspace/configure-target/main.zig

@@ -1,12 +1,12 @@
 const builtin = @import("builtin");
 const std = @import("std");
 
-pub fn main() !void {
-    const stdout = if (builtin.zig_version.major == 0 and builtin.zig_version.minor >= 15)
-        std.fs.File.stdout()
-    else
-        std.io.getStdOut();
-    try stdout.writeAll(
-        "Hello World!\n",
-    );
+const is_zig_0_16_or_later = builtin.zig_version.major == 0 and builtin.zig_version.minor >= 16;
+
+pub const main = if (is_zig_0_16_or_later) main_016 else main_pre_016;
+
+fn main_pre_016() !void {}
+
+fn main_016(init: std.process.Init) !void {
+    try std.Io.File.writeStreamingAll(.stdout(), init.io, "Hello World!\n");
 }

e2e/workspace/configure-target/read_elf_arch.zig

@@ -2,47 +2,75 @@ const builtin = @import("builtin");
 const std = @import("std");
 const elf = std.elf;
 
-pub fn main() !void {
+const is_zig_0_16_or_later = builtin.zig_version.major == 0 and builtin.zig_version.minor >= 16;
+
+pub const main = if (is_zig_0_16_or_later) main_016 else main_pre_016;
+
+fn main_pre_016() !void {
     const args = try std.process.argsAlloc(std.heap.page_allocator);
     defer std.process.argsFree(std.heap.page_allocator, args);
 
     if (args.len < 2) {
-        if (builtin.zig_version.major == 0 and builtin.zig_version.minor >= 15) {
-            var buffer: [512]u8 = undefined;
-            var writer = std.fs.File.stderr().writer(&buffer);
-            const stderr = &writer.interface;
-            try stderr.print("Usage: {s} <binary_path>\n", .{args[0]});
-            try stderr.flush();
-        } else {
-            try std.io.getStdErr().writer().print("Usage: {s} <binary_path>\n", .{args[0]});
-        }
+        try printUsage(args[0]);
         return;
     }
 
     try printMachineType(args[1]);
 }
 
+fn main_016(init: std.process.Init) !void {
+    var iter = try init.minimal.args.iterateAllocator(std.heap.page_allocator);
+    defer iter.deinit();
+
+    const arg0 = iter.next() orelse "read_elf_arch";
+    const binary_path = iter.next() orelse {
+        try printUsage_016(init.io, arg0);
+        return;
+    };
+
+    try printMachineType_016(init.io, binary_path);
+}
+
+fn printUsage(arg0: []const u8) !void {
+    var buffer: [512]u8 = undefined;
+    var writer = std.fs.File.stderr().writer(&buffer);
+    const stderr = &writer.interface;
+    try stderr.print("Usage: {s} <binary_path>\n", .{arg0});
+    try stderr.flush();
+}
+
+fn printUsage_016(io: anytype, arg0: []const u8) !void {
+    var buffer: [512]u8 = undefined;
+    var writer = std.Io.File.stderr().writer(io, &buffer);
+    const stderr = &writer.interface;
+    try stderr.print("Usage: {s} <binary_path>\n", .{arg0});
+    try stderr.flush();
+}
+
 fn printMachineType(binary_path: []const u8) !void {
     const file = try std.fs.cwd().openFile(binary_path, .{});
     defer file.close();
+    var reader_buffer: [1024]u8 = undefined;
+    var reader = file.reader(&reader_buffer);
+    const elf_header = try elf.Header.read(&reader.interface);
 
-    const elf_header = header: {
-        if (builtin.zig_version.major == 0 and builtin.zig_version.minor >= 15) {
-            var buffer: [1024]u8 = undefined;
-            var reader = file.reader(&buffer);
-            break :header try elf.Header.read(&reader.interface);
-        } else {
-            break :header try elf.Header.read(file);
-        }
-    };
+    var buffer: [512]u8 = undefined;
+    var writer = std.fs.File.stdout().writer(&buffer);
+    const stdout = &writer.interface;
+    try stdout.print("{s}\n", .{@tagName(elf_header.machine)});
+    try stdout.flush();
+}
 
-    if (builtin.zig_version.major == 0 and builtin.zig_version.minor >= 15) {
-        var buffer: [512]u8 = undefined;
-        var writer = std.fs.File.stdout().writer(&buffer);
-        const stdout = &writer.interface;
-        try stdout.print("{s}\n", .{@tagName(elf_header.machine)});
-        try stdout.flush();
-    } else {
-        try std.io.getStdOut().writer().print("{s}\n", .{@tagName(elf_header.machine)});
-    }
+fn printMachineType_016(io: anytype, binary_path: []const u8) !void {
+    const file = try std.Io.Dir.cwd().openFile(io, binary_path, .{});
+    defer file.close(io);
+    var reader_buffer: [1024]u8 = undefined;
+    var reader = file.reader(io, &reader_buffer);
+    const elf_header = try elf.Header.read(&reader.interface);
+
+    var buffer: [512]u8 = undefined;
+    var writer = std.Io.File.stdout().writer(io, &buffer);
+    const stdout = &writer.interface;
+    try stdout.print("{s}\n", .{@tagName(elf_header.machine)});
+    try stdout.flush();
 }

e2e/workspace/configure-target/read_pe32_arch.zig

@@ -1,41 +1,82 @@
 const std = @import("std");
 const builtin = @import("builtin");
 
-pub fn main() !void {
+const is_zig_0_16_or_later = builtin.zig_version.major == 0 and builtin.zig_version.minor >= 16;
+
+pub const main = if (is_zig_0_16_or_later) main_016 else main_pre_016;
+
+fn main_pre_016() !void {
     const args = try std.process.argsAlloc(std.heap.page_allocator);
     defer std.process.argsFree(std.heap.page_allocator, args);
 
     if (args.len < 2) {
-        if (builtin.zig_version.major == 0 and builtin.zig_version.minor >= 15) {
-            var buffer: [512]u8 = undefined;
-            var writer = std.fs.File.stderr().writer(&buffer);
-            const stderr = &writer.interface;
-            try stderr.print("Usage: {s} <binary_path>\n", .{args[0]});
-            try stderr.flush();
-        } else {
-            try std.io.getStdErr().writer().print("Usage: {s} <binary_path>\n", .{args[0]});
-        }
+        try printUsage(args[0]);
         return;
     }
 
     try printMachineType(std.heap.page_allocator, args[1]);
 }
 
+fn main_016(init: std.process.Init) !void {
+    var iter = try init.minimal.args.iterateAllocator(std.heap.page_allocator);
+    defer iter.deinit();
+
+    const arg0 = iter.next() orelse "read_pe32_arch";
+    const binary_path = iter.next() orelse {
+        try printUsage_016(init.io, arg0);
+        return;
+    };
+
+    try printMachineType_016(init.io, std.heap.page_allocator, binary_path);
+}
+
+fn printUsage(arg0: []const u8) !void {
+    var buffer: [512]u8 = undefined;
+    var writer = std.fs.File.stderr().writer(&buffer);
+    const stderr = &writer.interface;
+    try stderr.print("Usage: {s} <binary_path>\n", .{arg0});
+    try stderr.flush();
+}
+
 fn printMachineType(allocator: std.mem.Allocator, binary_path: []const u8) !void {
     const content = try std.fs.cwd().readFileAlloc(allocator, binary_path, 2097152);
+    defer allocator.free(content);
 
-    var coff = if (builtin.zig_version.major == 0 and builtin.zig_version.minor == 11)
-        try std.coff.Coff.init(content)
-    else
-        try std.coff.Coff.init(content, false);
-
-    if (builtin.zig_version.major == 0 and builtin.zig_version.minor >= 15) {
-        var buffer: [512]u8 = undefined;
-        var writer = std.fs.File.stdout().writer(&buffer);
-        const stdout = &writer.interface;
-        try stdout.print("{s}\n", .{@tagName(coff.getCoffHeader().machine)});
-        try stdout.flush();
-    } else {
-        try std.io.getStdOut().writer().print("{s}\n", .{@tagName(coff.getCoffHeader().machine)});
-    }
+    var coff = try std.coff.Coff.init(content, false);
+    const machine_name = @tagName(coff.getCoffHeader().machine);
+
+    var buffer: [512]u8 = undefined;
+    var writer = std.fs.File.stdout().writer(&buffer);
+    const stdout = &writer.interface;
+    try stdout.print("{s}\n", .{machine_name});
+    try stdout.flush();
+}
+
+fn printUsage_016(io: anytype, arg0: []const u8) !void {
+    var buffer: [512]u8 = undefined;
+    var writer = std.Io.File.stderr().writer(io, &buffer);
+    const stderr = &writer.interface;
+    try stderr.print("Usage: {s} <binary_path>\n", .{arg0});
+    try stderr.flush();
+}
+
+fn printMachineType_016(io: anytype, allocator: std.mem.Allocator, binary_path: []const u8) !void {
+    const file = try std.Io.Dir.cwd().openFile(io, binary_path, .{});
+    defer file.close(io);
+    var reader_buffer: [1024]u8 = undefined;
+    var reader = file.reader(io, &reader_buffer);
+    const content = try reader.interface.allocRemaining(allocator, .limited(2097152));
+    defer allocator.free(content);
+
+    var coff = try std.coff.Coff.init(content, false);
+    const machine_name = switch (coff.getHeader().machine) {
+        .AMD64 => "X64",
+        else => |machine| @tagName(machine),
+    };
+
+    var buffer: [512]u8 = undefined;
+    var writer = std.Io.File.stdout().writer(io, &buffer);
+    const stdout = &writer.interface;
+    try stdout.print("{s}\n", .{machine_name});
+    try stdout.flush();
 }