Update to Zig 0.16.0

This commit represents the majority of the work necessary to upgrade
Ghostty to use Zig 0.16.0.

Key parts:

* In addition to its previous responsibilities, the global state now
  houses state for global I/O implementations and the process
  environment. It is now also utilized in the main application along
  with the C library. Where necessary, global state is isolated from key
  parts of the implementation (e.g., in libghostty subsystems), and it's
  expected that this list will grow.

* We currently manage our own C translation layer where necessary. In
  these cases, cImport has been removed in favor of the new external
  translate-c package. Due to fixes that have needed be made to properly
  translate the dependencies that were swapped out, as mentioned, we
  have had to backport fixes from the current translate-c package (and
  the upstream Arocc dependency). We will host this ourselves until Zig
  0.17.0 is released with these fixes.

* Where necessary (only a small number of cases), some stdlib code from
  0.15.2 (and even from 0.17.0) has been taken, adopted, and vendored in
  lib/compat.

Co-authored-by: Leah Amelia Chen <hi@pluie.me>

src/cli/ssh.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const builtin = @import("builtin");
 const Allocator = std.mem.Allocator;
 const ArenaAllocator = std.heap.ArenaAllocator;
 const cli_args = @import("args.zig");
@@ -7,6 +8,7 @@ const Action = @import("ghostty.zig").Action;
 const DiskCache = @import("ssh_cache.zig").DiskCache;
 const internal_os = @import("../os/main.zig");
 const ghostty_terminfo = @import("../terminfo/main.zig").ghostty;
+const global = @import("../global.zig");
 
 const log = std.log.scoped(.ssh);
 
@@ -181,14 +183,14 @@ pub fn run(alloc_gpa: Allocator) !u8 {
     defer opts.deinit();
 
     {
-        var iter = try cli_args.argsIterator(alloc_gpa);
+        var iter = try cli_args.argsIterator(alloc_gpa, global.args());
         defer iter.deinit();
         try cli_args.parse(Options, alloc_gpa, &opts, &iter);
     }
 
     var stderr_buffer: [1024]u8 = undefined;
-    var stderr_file: std.fs.File = .stderr();
-    var stderr_writer = stderr_file.writer(&stderr_buffer);
+    var stderr_file: std.Io.File = .stderr();
+    var stderr_writer = stderr_file.writer(global.io(), &stderr_buffer);
     const stderr = &stderr_writer.interface;
 
     // Any diagnostic from the arg parser is an unknown flag or bad
@@ -294,7 +296,7 @@ fn runInner(
     });
     verbosePrint(opts, stderr, "exec: {f}", .{Joined{ .items = argv }});
 
-    const exit_code = childExec(alloc, argv) catch |err| {
+    const exit_code = childExec(argv) catch |err| {
         try stderr.print("Error: failed to run {s}: {}\n", .{ argv[0], err });
         return 1;
     };
@@ -302,7 +304,10 @@ fn runInner(
 
     // Attempt to cache (if needed) on a successful ssh execution.
     if (exit_code == 0) if (session.to_cache) |entry| {
-        if (entry.cache.add(alloc, entry.dest, std.time.timestamp())) |_| {
+        if (entry.cache.add(alloc, entry.dest, std.Io.Timestamp.now(
+            global.io(),
+            .real,
+        ).toSeconds())) |_| {
             verbosePrint(opts, stderr, "cache: wrote {s}", .{entry.dest});
         } else |err| {
             log.debug("cache add failed for '{s}': {}", .{ entry.dest, err });
@@ -370,7 +375,7 @@ const Joined = struct {
 
 fn checkExit(term: std.process.Child.Term, label: []const u8) error{ChildFailed}!void {
     switch (term) {
-        .Exited => |rc| if (rc != 0) {
+        .exited => |rc| if (rc != 0) {
             log.warn("{s} exited with non-zero status: {d}", .{ label, rc });
             return error.ChildFailed;
         },
@@ -393,10 +398,11 @@ fn resolveDestination(
         &.{ ssh, "-G" },
         args,
     }) catch return null;
-    const result = std.process.Child.run(.{
-        .allocator = alloc,
-        .argv = argv,
-    }) catch |err| {
+    const result = std.process.run(
+        alloc,
+        global.io(),
+        .{ .argv = argv },
+    ) catch |err| {
         log.warn("ssh -G spawn failed: {}", .{err});
         return null;
     };
@@ -491,23 +497,23 @@ fn installRemoteTerminfo(
     });
     verbosePrint(opts, stderr, "exec: {f}", .{Joined{ .items = argv }});
 
-    var child: std.process.Child = .init(argv, alloc);
-    child.stdin_behavior = .Pipe;
-    child.stdout_behavior = .Ignore;
-    child.stderr_behavior = if (opts.verbose) .Inherit else .Ignore;
-
-    child.spawn() catch |err| {
+    var child = std.process.spawn(global.io(), .{
+        .argv = argv,
+        .stdin = .pipe,
+        .stdout = .ignore,
+        .stderr = if (opts.verbose) .inherit else .ignore,
+    }) catch |err| {
         log.warn("terminfo install spawn failed: {}", .{err});
         return error.InstallFailed;
     };
 
     if (child.stdin) |stdin| {
-        stdin.writeAll(terminfo) catch {};
-        stdin.close();
+        stdin.writeStreamingAll(global.io(), terminfo) catch {};
+        stdin.close(global.io());
         child.stdin = null;
     }
 
-    const term = child.wait() catch |err| {
+    const term = child.wait(global.io()) catch |err| {
         log.warn("terminfo install wait failed: {}", .{err});
         return error.InstallFailed;
     };
@@ -515,23 +521,24 @@ fn installRemoteTerminfo(
 }
 
 /// Returns `128 + signum` for signal-killed children, matching shell convention.
-fn childExec(alloc: Allocator, argv: []const []const u8) !u8 {
-    var child: std.process.Child = .init(argv, alloc);
-    child.stdin_behavior = .Inherit;
-    child.stdout_behavior = .Inherit;
-    child.stderr_behavior = .Inherit;
+fn childExec(argv: []const []const u8) !u8 {
+    var child = try std.process.spawn(global.io(), .{
+        .argv = argv,
+        .stdin = .inherit,
+        .stdout = .inherit,
+        .stderr = .inherit,
+    });
 
-    try child.spawn();
-    const term = try child.wait();
+    const term = try child.wait(global.io());
     return switch (term) {
-        .Exited => |rc| rc,
-        .Signal => |sig| @as(u8, 128) + @as(u8, @intCast(@min(sig, 127))),
-        .Stopped, .Unknown => 1,
+        .exited => |rc| rc,
+        .signal => |sig| @as(u8, 128) + @as(u8, @intCast(@min(@intFromEnum(sig), 127))),
+        .stopped, .unknown => 1,
     };
 }
 
 fn parseTestArgs(alloc: Allocator, opts: *Options, line: []const u8) !void {
-    var iter = try std.process.ArgIteratorGeneral(.{}).init(alloc, line);
+    var iter = try std.process.Args.IteratorGeneral(.{}).init(alloc, line);
     defer iter.deinit();
     try cli_args.parse(Options, alloc, opts, &iter);
 }