upgrade zig 0.12

0.12.0-dev.3439+31a7f22b8

Author: krichprollsch

build.zig

@@ -1,13 +1,11 @@
 const std = @import("std");
 const json = std.json;
-const Builder = std.build.Builder;
-const CompileStep = std.build.CompileStep;
-const Step = std.build.Step;
+const Step = std.Build.Step;
 const print = std.debug.print;
 const builtin = @import("builtin");
-const Pkg = std.build.Pkg;
+const Pkg = std.Build.Pkg;
 
-pub fn build(b: *Builder) !void {
+pub fn build(b: *std.Build) !void {
     // Options.
     //const build_v8 = b.option(bool, "build_v8", "Whether to build from v8 source") orelse false;
     const path = b.option([]const u8, "path", "Path to main file, for: build, run") orelse "";
@@ -45,7 +43,7 @@ const UseGclient = false;
 // V8's build process is complex and porting it to zig could take quite awhile.
 // It would be nice if there was a way to import .gn files into the zig build system.
 // For now we just use gn/ninja like rusty_v8 does: https://github.com/denoland/rusty_v8/blob/main/build.rs
-fn createV8_Build(b: *Builder, target: std.zig.CrossTarget, mode: std.builtin.Mode, use_zig_tc: bool) !*std.build.Step {
+fn createV8_Build(b: *std.Build, target: std.Build.ResolvedTarget, mode: std.builtin.Mode, use_zig_tc: bool) !*std.Build.Step {
     const step = b.step("v8", "Build v8 c binding lib.");
 
     var cp: *CopyFileStep = undefined;
@@ -65,19 +63,19 @@ fn createV8_Build(b: *Builder, target: std.zig.CrossTarget, mode: std.builtin.Mo
 
     var gn_args = std.ArrayList([]const u8).init(b.allocator);
 
-    switch (target.getOsTag()) {
+    switch (target.result.os.tag) {
         .macos => try gn_args.append("target_os=\"mac\""),
         .windows => {
             try gn_args.append("target_os=\"win\"");
             if (!UseGclient) {
                 // Don't use depot_tools.
-                try b.env_map.put("DEPOT_TOOLS_WIN_TOOLCHAIN", "0");
+                try b.graph.env_map.put("DEPOT_TOOLS_WIN_TOOLCHAIN", "0");
             }
         },
         .linux => try gn_args.append("target_os=\"linux\""),
         else => {},
     }
-    switch (target.getCpuArch()) {
+    switch (target.result.cpu.arch) {
         .x86_64 => try gn_args.append("target_cpu=\"x64\""),
         .aarch64 => try gn_args.append("target_cpu=\"arm64\""),
         else => {},
@@ -133,8 +131,8 @@ fn createV8_Build(b: *Builder, target: std.zig.CrossTarget, mode: std.builtin.Mo
     if (use_zig_tc) {
         // Set target and cpu for building the lib.
         // TODO: If mcpu is equavalent to -Dcpu then use that instead
-        try zig_cc.append(b.fmt("zig cc --target={s} -mcpu=baseline", .{try target.zigTriple(b.allocator)}));
-        try zig_cxx.append(b.fmt("zig c++ --target={s} -mcpu=baseline", .{try target.zigTriple(b.allocator)}));
+        try zig_cc.append(b.fmt("zig cc --target={s} -mcpu=baseline", .{try target.result.zigTriple(b.allocator)}));
+        try zig_cxx.append(b.fmt("zig c++ --target={s} -mcpu=baseline", .{try target.result.zigTriple(b.allocator)}));
 
         try host_zig_cc.append("zig cc --target=native");
         try host_zig_cxx.append("zig c++ --target=native");
@@ -149,11 +147,11 @@ fn createV8_Build(b: *Builder, target: std.zig.CrossTarget, mode: std.builtin.Mo
         try zig_cc.append("-mcrc32");
         try zig_cxx.append("-mcrc32");
 
-        if (target.getOsTag() == .windows and target.getAbi() == .gnu) {
+        if (target.result.os.tag == .windows and target.result.abi == .gnu) {
             // V8 expects __declspec(dllexport) to not expand in it's test in src/base/export-template.h but it does when compiling with mingw.
             try zig_cxx.append("-DEXPORT_TEMPLATE_TEST_MSVC_HACK_DEFAULT\\(...\\)=true");
         }
-        if (target.getOsTag() == .windows and builtin.os.tag != .windows) {
+        if (target.result.os.tag == .windows and builtin.os.tag != .windows) {
             // Cross building to windows probably is case sensitive to header files, so provide them in include.
             // Note: Directory is relative to ninja build folder.
             try zig_cxx.append("-I../../../../cross-windows");
@@ -192,12 +190,12 @@ fn createV8_Build(b: *Builder, target: std.zig.CrossTarget, mode: std.builtin.Mo
         // custom_toolchain is how we can set zig as the cc/cxx compiler and linker.
         try gn_args.append("custom_toolchain=\"//zig:main_zig_toolchain\"");
 
-        if (target.getOsTag() == .linux and target.getCpuArch() == .x86_64) {
+        if (target.result.os.tag == .linux and target.result.cpu.arch == .x86_64) {
             // Should add target flags that matches: //build/config/compiler:compiler_cpu_abi
             try zig_cc.append("-m64");
             try zig_cxx.append("-m64");
-        } else if (target.getOsTag() == .macos) {
-            if (!target.isNative()) {
+        } else if (target.result.os.tag == .macos) {
+            if (!target.query.isNative()) {
                 // Cross compiling.
                 const sysroot_abs = b.pathFromRoot("./cross-macos/sysroot/macos-12/usr/include");
                 try zig_cc.append("-isystem");
@@ -206,7 +204,7 @@ fn createV8_Build(b: *Builder, target: std.zig.CrossTarget, mode: std.builtin.Mo
                 try zig_cxx.append(sysroot_abs);
             }
         }
-        if (builtin.cpu.arch != target.getCpuArch() or builtin.os.tag != target.getOsTag()) {
+        if (builtin.cpu.arch != target.result.cpu.arch or builtin.os.tag != target.result.os.tag) {
             try gn_args.append("v8_snapshot_toolchain=\"//zig:v8_zig_toolchain\"");
         }
 
@@ -231,7 +229,7 @@ fn createV8_Build(b: *Builder, target: std.zig.CrossTarget, mode: std.builtin.Mo
         if (builtin.os.tag != .windows) {
             try gn_args.append("cxx_use_ld=\"lld\"");
         }
-        if (target.getOsTag() == .linux and target.getCpuArch() == .aarch64) {
+        if (target.result.os.tag == .linux and target.result.cpu.arch == .aarch64) {
             // On linux aarch64, we can not use the clang version provided in v8 sources
             // as it's built for x86_64 (TODO: using Rosetta2 for Linux VM on Apple Sillicon?)
             // Instead we can use a clang system version
@@ -245,13 +243,13 @@ fn createV8_Build(b: *Builder, target: std.zig.CrossTarget, mode: std.builtin.Mo
 
     // sccache, currently does not work with zig cc
     if (!use_zig_tc) {
-        if (b.env_map.get("SCCACHE")) |path| {
+        if (b.graph.env_map.get("SCCACHE")) |path| {
             const cc_wrapper = try std.fmt.allocPrint(b.allocator, "cc_wrapper=\"{s}\"", .{path});
             try gn_args.append(cc_wrapper);
         } else {
             if (builtin.os.tag == .windows) {
                 // findProgram look for "PATH" case sensitive.
-                try b.env_map.put("PATH", b.env_map.get("Path") orelse "");
+                try b.graph.env_map.put("PATH", b.graph.env_map.get("Path") orelse "");
             }
             if (b.findProgram(&.{"sccache"}, &.{})) |_| {
                 const cc_wrapper = try std.fmt.allocPrint(b.allocator, "cc_wrapper=\"{s}\"", .{"sccache"});
@@ -264,7 +262,7 @@ fn createV8_Build(b: *Builder, target: std.zig.CrossTarget, mode: std.builtin.Mo
             if (builtin.os.tag == .windows) {
                 // After creating PATH for windows so findProgram can find sccache, we need to delete it
                 // or a gn tool (build/toolchain/win/setup_toolchain.py) will complain about not finding cl.exe.
-                b.env_map.remove("PATH");
+                b.graph.env_map.remove("PATH");
             }
         }
     }
@@ -313,20 +311,20 @@ fn getArchOs(alloc: std.mem.Allocator, arch: std.Target.Cpu.Arch, os: std.Target
     return std.fmt.allocPrint(alloc, "{s}-{s}-gnu", .{ @tagName(arch), @tagName(os) }) catch unreachable;
 }
 
-fn getTargetId(alloc: std.mem.Allocator, target: std.zig.CrossTarget) []const u8 {
-    return std.fmt.allocPrint(alloc, "{s}-{s}", .{ @tagName(target.getCpuArch()), @tagName(target.getOsTag()) }) catch unreachable;
+fn getTargetId(alloc: std.mem.Allocator, target: std.Build.ResolvedTarget) []const u8 {
+    return std.fmt.allocPrint(alloc, "{s}-{s}", .{ @tagName(target.result.cpu.arch), @tagName(target.result.os.tag) }) catch unreachable;
 }
 
 const CheckV8DepsStep = struct {
     const Self = @This();
 
     step: Step,
-    b: *Builder,
+    b: *std.Build,
 
-    fn create(b: *Builder) *Self {
+    fn create(b: *std.Build) *Self {
         const step = b.allocator.create(Self) catch unreachable;
         step.* = .{
-            .step = std.build.Step.init(.{
+            .step = std.Build.Step.init(.{
                 .id = .custom,
                 .name = "check_v8_deps",
                 .makeFn = make,
@@ -353,7 +351,7 @@ const CheckV8DepsStep = struct {
     }
 };
 
-fn createGetV8(b: *Builder) *std.build.Step {
+fn createGetV8(b: *std.Build) *std.Build.Step {
     const step = b.step("get-v8", "Gets v8 source using gclient.");
     if (UseGclient) {
         const mkpath = MakePathStep.create(b, "./gclient");
@@ -371,7 +369,7 @@ fn createGetV8(b: *Builder) *std.build.Step {
     return step;
 }
 
-fn createGetTools(b: *Builder) *std.build.Step {
+fn createGetTools(b: *std.Build) *std.Build.Step {
     const step = b.step("get-tools", "Gets the build tools.");
 
     var sub_step = b.addSystemCommand(&.{ "python3", "./tools/get_ninja_gn_binaries.py", "--dir", "./tools" });
@@ -386,7 +384,7 @@ fn createGetTools(b: *Builder) *std.build.Step {
     return step;
 }
 
-fn getNinjaPath(b: *Builder) []const u8 {
+fn getNinjaPath(b: *std.Build) []const u8 {
     const os = switch (builtin.os.tag) {
         .windows => "windows",
         .linux => "linux",
@@ -404,7 +402,7 @@ fn getNinjaPath(b: *Builder) []const u8 {
     return std.fs.path.resolve(b.allocator, &.{ "./tools/ninja_gn_binaries-20221218", platform, bin }) catch unreachable;
 }
 
-fn getGnPath(b: *Builder) []const u8 {
+fn getGnPath(b: *std.Build) []const u8 {
     const os = switch (builtin.os.tag) {
         .windows => "windows",
         .linux => "linux",
@@ -425,14 +423,14 @@ fn getGnPath(b: *Builder) []const u8 {
 const MakePathStep = struct {
     const Self = @This();
 
-    step: std.build.Step,
-    b: *Builder,
+    step: std.Build.Step,
+    b: *std.Build,
     path: []const u8,
 
-    fn create(b: *Builder, root_path: []const u8) *Self {
+    fn create(b: *std.Build, root_path: []const u8) *Self {
         const new = b.allocator.create(Self) catch unreachable;
         new.* = .{
-            .step = std.build.Step.init(.{
+            .step = std.Build.Step.init(.{
                 .id = .custom,
                 .name = b.fmt("make-path", .{}),
                 .makeFn = make,
@@ -454,15 +452,15 @@ const MakePathStep = struct {
 const CopyFileStep = struct {
     const Self = @This();
 
-    step: std.build.Step,
-    b: *Builder,
+    step: std.Build.Step,
+    b: *std.Build,
     src_path: []const u8,
     dst_path: []const u8,
 
-    fn create(b: *Builder, src_path: []const u8, dst_path: []const u8) *Self {
+    fn create(b: *std.Build, src_path: []const u8, dst_path: []const u8) *Self {
         const new = b.allocator.create(Self) catch unreachable;
         new.* = .{
-            .step = std.build.Step.init(.{
+            .step = std.Build.Step.init(.{
                 .id = .custom,
                 .name = b.fmt("cp", .{}),
                 .makeFn = make,
@@ -483,12 +481,12 @@ const CopyFileStep = struct {
 };
 
 // TODO: Make this usable from external project.
-fn linkV8(b: *Builder, step: *std.build.CompileStep, use_zig_tc: bool) void {
-    const mode = step.optimize;
-    const target = step.target;
+fn linkV8(b: *std.Build, step: *std.Build.Step.Compile, use_zig_tc: bool) void {
+    const mode = step.root_module.optimize;
+    const target = step.root_module.resolved_target.?;
 
     const mode_str: []const u8 = if (mode == .Debug) "debug" else "release";
-    const lib: []const u8 = if (target.getOsTag() == .windows and target.getAbi() == .msvc) "c_v8.lib" else "libc_v8.a";
+    const lib: []const u8 = if (target.result.os.tag == .windows and target.result.abi == .msvc) "c_v8.lib" else "libc_v8.a";
     const lib_path = std.fmt.allocPrint(b.allocator, "./v8-build/{s}/{s}/ninja/obj/zig/{s}", .{
         getTargetId(b.allocator, target),
         mode_str,
@@ -501,8 +499,8 @@ fn linkV8(b: *Builder, step: *std.build.CompileStep, use_zig_tc: bool) void {
             step.linkLibCpp();
         }
         step.linkSystemLibrary("unwind");
-    } else if (target.getOsTag() == .windows) {
-        if (target.getAbi() == .gnu) {
+    } else if (target.result.os.tag == .windows) {
+        if (target.result.abi == .gnu) {
             step.linkLibCpp();
         } else {
             step.linkSystemLibrary("Dbghelp");
@@ -518,10 +516,9 @@ fn linkV8(b: *Builder, step: *std.build.CompileStep, use_zig_tc: bool) void {
     }
 }
 
-fn createTest(b: *Builder, target: std.zig.CrossTarget, mode: std.builtin.Mode, use_zig_tc: bool) *std.build.CompileStep {
+fn createTest(b: *std.Build, target: std.Build.ResolvedTarget, mode: std.builtin.Mode, use_zig_tc: bool) *std.Build.Step.Compile {
     const step = b.addTest(.{
-        .root_source_file = .{ .path = "./test/test.zig" },
-        .main_pkg_path = .{ .path = "." },
+        .root_source_file = .{ .path = "./src/test.zig" },
         .target = target,
         .optimize = mode,
         .link_libc = true,
@@ -544,12 +541,12 @@ const DepEntry = struct {
     }
 };
 
-fn getV8Rev(b: *Builder) ![]const u8 {
+fn getV8Rev(b: *std.Build) ![]const u8 {
     var file: std.fs.File = undefined;
     if (comptime isMinZigVersion()) {
-        file = try std.fs.openFileAbsolute(b.pathFromRoot("V8_REVISION"), .{ .read = true, .write = false });
+        file = try std.fs.openFileAbsolute(b.pathFromRoot("V8_REVISION"), .{ .mode = .read_only });
     } else {
-        file = try std.fs.openFileAbsolute(b.pathFromRoot("V8_REVISION"), .{ .mode = std.fs.File.OpenMode.read_write });
+        file = try std.fs.openFileAbsolute(b.pathFromRoot("V8_REVISION"), .{ .mode = .read_only });
     }
     defer file.close();
     return std.mem.trim(u8, try file.readToEndAlloc(b.allocator, 1e9), "\n\r ");
@@ -559,13 +556,13 @@ pub const GetV8SourceStep = struct {
     const Self = @This();
 
     step: Step,
-    b: *Builder,
+    b: *std.Build,
 
-    pub fn create(b: *Builder) *Self {
+    pub fn create(b: *std.Build) *Self {
         const self = b.allocator.create(Self) catch unreachable;
         self.* = .{
             .b = b,
-            .step = std.build.Step.init(.{
+            .step = std.Build.Step.init(.{
                 .id = .run,
                 .name = "Get V8 Sources.",
                 .makeFn = make,
@@ -736,7 +733,7 @@ pub const GetV8SourceStep = struct {
     }
 };
 
-fn createCompileStep(b: *Builder, path: []const u8, target: std.zig.CrossTarget, mode: std.builtin.Mode, use_zig_tc: bool) *CompileStep {
+fn createCompileStep(b: *std.Build, path: []const u8, target: std.Build.ResolvedTarget, mode: std.builtin.Mode, use_zig_tc: bool) *std.Build.Step.Compile {
     const basename = std.fs.path.basename(path);
     const i = std.mem.indexOf(u8, basename, ".zig") orelse basename.len;
     const name = basename[0..i];
@@ -751,7 +748,7 @@ fn createCompileStep(b: *Builder, path: []const u8, target: std.zig.CrossTarget,
     step.addIncludePath(.{ .path = "src" });
 
     if (mode == .ReleaseSafe) {
-        step.strip = true;
+        step.root_module.strip = true;
     }
 
     linkV8(b, step, use_zig_tc);
@@ -767,11 +764,11 @@ const PathStat = enum {
     Unknown,
 };
 
-fn statPathFromRoot(b: *Builder, path_rel: []const u8) !PathStat {
+fn statPathFromRoot(b: *std.Build, path_rel: []const u8) !PathStat {
     const path_abs = b.pathFromRoot(path_rel);
     var file: std.fs.File = undefined;
     if (comptime isMinZigVersion()) {
-        file = std.fs.openFileAbsolute(path_abs, .{ .read = false, .write = false }) catch |err| {
+        file = std.fs.openFileAbsolute(path_abs, .{ .mode = .read_only }) catch |err| {
             if (err == error.FileNotFound) {
                 return .NotExist;
             } else if (err == error.IsDir) {
@@ -781,7 +778,7 @@ fn statPathFromRoot(b: *Builder, path_rel: []const u8) !PathStat {
             }
         };
     } else {
-        file = std.fs.openFileAbsolute(path_abs, .{ .mode = std.fs.File.OpenMode.read_only }) catch |err| {
+        file = std.fs.openFileAbsolute(path_abs, .{ .mode = .read_only }) catch |err| {
             if (err == error.FileNotFound) {
                 return .NotExist;
             } else if (err == error.IsDir) {
@@ -803,5 +800,5 @@ fn statPathFromRoot(b: *Builder, path_rel: []const u8) !PathStat {
 }
 
 fn isMinZigVersion() bool {
-    return builtin.zig_version.major == 0 and builtin.zig_version.minor == 9;
+    return builtin.zig_version.major == 0 and builtin.zig_version.minor == 12;
 }

test/test.zig renamed to src/test.zig

@@ -1,6 +1,6 @@
 const std = @import("std");
 const t = std.testing;
-const v8 = @import("../src/v8.zig");
+const v8 = @import("v8.zig");
 
 test {
     // Based on https://chromium.googlesource.com/v8/v8/+/branch-heads/6.8/samples/hello-world.cc