Zig 0.14 compatibility

Author: karlseguin

.github/workflows/build-release.yml

@@ -11,7 +11,7 @@ permissions:
   contents: write
 
 env:
-  ZIG_VERSION: 0.13.0
+  ZIG_VERSION: 0.14.0
 
 jobs:
   build-x86_64-linux:

README.md

@@ -24,7 +24,7 @@ Static libs are built and released with [Github Actions](https://github.com/fuba
 \* Time is measured on standard Github instances.
 
 ## System Requirements
-- Zig compiler (0.13.0). You can get that [here](https://ziglang.org/download/).
+- Zig compiler (0.14.0). Clone and build https://github.com/ziglang/zig.
 - Python 3 (2.7 seems to work as well)
 - For native macOS builds:
   - XCode (You won't need this when using zig's c++ toolchain!)<br/>
@@ -50,17 +50,17 @@ zig build get-v8
 
 # Build, resulting static library should be at:
 # v8-build/{target}/{debug/release}/ninja/obj/zig/libc_v8.a
-# On windows, use msvc: zig build -Drelease-safe -Dtarget=x86_64-windows-msvc
-zig build -Drelease-safe
+# On windows, use msvc: zig build zig build -Doptimize=ReleaseSafe -Dtarget=x86_64-windows-msvc
+zig build -Doptimize=ReleaseSafe
 ```
 ## Demo
 ```sh
 # shell.zig is a simple JS repl.
 # Assumes you've already built v8.
-zig build run -Dpath="src/shell.zig" -Drelease-safe
+zig build run -Dpath="src/shell.zig" -Doptimize=ReleaseSafe
 
 # If you built v8 using the zig toolchain, you'll need to add the flag here as well.
-zig build run -Dpath="src/shell.zig" -Drelease-safe -Dzig-toolchain
+zig build run -Dpath="src/shell.zig" -Doptimize=ReleaseSafe -Dzig-toolchain
 ```
 
 ## Cross Compiling
@@ -70,13 +70,13 @@ With Zig's toolchain, we can build V8 from libstdc++ that's bundled with zig and
 # Assumes you've fetched tools and v8 sources. See above build steps.
 # Resulting static lib will be at:
 # v8-build/aarch64-macos/release/ninja/obj/zig/libc_v8.a
-zig build -Drelease-safe -Dtarget=aarch64-macos-gnu -Dzig-toolchain
+zig build -Doptimize=ReleaseSafe -Dtarget=aarch64-macos-gnu -Dzig-toolchain
 ```
 
 ### Cross compile to Windows with gnu (mingw64)
 Zig comes with mingw64 source and headers so you'll be able to target Windows without MSVC.
 ```sh
-zig build -Drelease-safe -Dtarget=x86_64-windows-gnu -Dzig-toolchain
+zig build -Doptimize=ReleaseSafe -Dtarget=x86_64-windows-gnu -Dzig-toolchain
 ```
 
 ## Usage

build.zig

@@ -127,7 +127,7 @@ fn createV8_Build(b: *std.Build, target: std.Build.ResolvedTarget, mode: std.bui
 
     if (use_zig_tc) {
         // Set target and cpu for building the lib.
-        // TODO: If mcpu is equavalent to -Dcpu then use that instead
+        // TODO: If mcpu is equivalent to -Dcpu then use that instead
         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)}));
 
@@ -228,7 +228,7 @@ fn createV8_Build(b: *std.Build, target: std.Build.ResolvedTarget, mode: std.bui
         }
         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?)
+            // as it's built for x86_64 (TODO: using Rosetta2 for Linux VM on Apple Silicon?)
             // Instead we can use a clang system version
             // as long as we use the same version number (currently clang-16)
             // Currently v8 uses clang-16 but Debian/Ubuntu are using older versions
@@ -332,8 +332,7 @@ const CheckV8DepsStep = struct {
         return step;
     }
 
-    fn make(step: *Step, prog_node: *std.Progress.Node) anyerror!void {
-        _ = prog_node;
+    fn make(step: *Step, _: Step.MakeOptions) anyerror!void {
         const output = try step.evalChildProcess(&.{ "clang", "--version" });
         print("clang: {s}", .{output});
 
@@ -439,8 +438,7 @@ const MakePathStep = struct {
         return new;
     }
 
-    fn make(step: *Step, prog_node: std.Progress.Node) anyerror!void {
-        _ = prog_node;
+    fn make(step: *Step, _: Step.MakeOptions) anyerror!void {
         const self: *Self = @fieldParentPtr("step", step);
         try std.fs.cwd().makePath(self.b.pathFromRoot(self.path));
     }
@@ -470,8 +468,7 @@ const CopyFileStep = struct {
         return new;
     }
 
-    fn make(step: *Step, prog_node: std.Progress.Node) anyerror!void {
-        _ = prog_node;
+    fn make(step: *Step, _: Step.MakeOptions) anyerror!void {
         const self: *Self = @fieldParentPtr("step", step);
         try std.fs.copyFileAbsolute(self.src_path, self.dst_path, .{});
     }
@@ -641,8 +638,7 @@ pub const GetV8SourceStep = struct {
         }
     }
 
-    fn make(step: *Step, prog_node: std.Progress.Node) anyerror!void {
-        _ = prog_node;
+    fn make(step: *Step, _: Step.MakeOptions) anyerror!void {
         const self: *Self = @fieldParentPtr("step", step);
 
         // Pull the minimum source we need by looking at DEPS.
@@ -804,5 +800,5 @@ fn statPathFromRoot(b: *std.Build, path_rel: []const u8) !PathStat {
 }
 
 fn isMinZigVersion() bool {
-    return builtin.zig_version.major == 0 and builtin.zig_version.minor == 12;
+    return builtin.zig_version.major == 0 and builtin.zig_version.minor == 14;
 }

src/shell.zig

@@ -120,9 +120,9 @@ pub fn executeString(alloc: std.mem.Allocator, isolate: v8.Isolate, src: []const
     try_catch.init(isolate);
     defer try_catch.deinit();
 
-    var origin = v8.ScriptOrigin.initDefault(isolate, src_origin.toValue());
+    const origin = v8.ScriptOrigin.initDefault(isolate, src_origin.toValue());
 
-    var context = isolate.getCurrentContext();
+    const context = isolate.getCurrentContext();
 
     const js_src = v8.String.initUtf8(isolate, src);
 

src/v8.zig

@@ -780,7 +780,7 @@ pub const Function = struct {
         } else return null;
     }
 
-    // Equavalent to js "new".
+    // Equivalent to js "new".
     pub fn initInstance(self: Self, ctx: Context, args: []const Value) ?Object {
         const c_args = @as(?[*]const ?*c.Value, @ptrCast(args.ptr));
         if (c.v8__Function__NewInstance(self.handle, ctx.handle, @as(c_int, @intCast(args.len)), c_args)) |ret| {
@@ -816,7 +816,7 @@ pub const Function = struct {
 pub fn Persistent(comptime T: type) type {
     comptime var handleT: type = undefined;
     comptime {
-        for (@typeInfo(T).Struct.fields) |field| {
+        for (@typeInfo(T).@"struct".fields) |field| {
             if (!std.mem.eql(u8, field.name, "handle")) {
                 continue;
             }
@@ -1770,7 +1770,7 @@ pub const Module = struct {
         } else return error.JsException;
     }
 
-    /// Evaulates the module, assumes module has been instantiated.
+    /// Evaluates the module, assumes module has been instantiated.
     /// [v8]
     /// Evaluates the module and its dependencies.
     ///
@@ -2312,7 +2312,7 @@ pub const Inspector = struct {
     // Set when a context is created.
     ctx_handle: ?*const C_Context = null,
 
-    const RndGen = std.rand.DefaultPrng;
+    const RndGen = std.Random.DefaultPrng;
 
     const contextGroupId = 1;
     const clientTrustLevel = 1;