std: move abort and exit from posix into process

and delete the unit tests that called fork()

no forking allowed in the std lib, including unit tests, except to implement child process spawning.

3 files changed, 15 insertions, 11 deletions

diff --git a/src/Compilation.zig b/src/Compilation.zig
index 3a48705880..280d34cdbf 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -3180,7 +3180,7 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) UpdateE
             const s = fs.path.sep_str;
             const tmp_dir_sub_path = "tmp" ++ s ++ std.fmt.hex(tmp_dir_rand_int);
             const o_sub_path = "o" ++ s ++ hex_digest;
-            renameTmpIntoCache(comp.dirs.local_cache, tmp_dir_sub_path, o_sub_path) catch |err| {
+            renameTmpIntoCache(io, comp.dirs.local_cache, tmp_dir_sub_path, o_sub_path) catch |err| {
                 return comp.setMiscFailure(
                     .rename_results,
                     "failed to rename compilation results ('{f}{s}') into local cache ('{f}{s}'): {t}",
@@ -3399,17 +3399,19 @@ fn flush(
 /// implementation at the bottom of this function.
 /// This function is only called when CacheMode is `whole`.
 fn renameTmpIntoCache(
+    io: Io,
     cache_directory: Cache.Directory,
     tmp_dir_sub_path: []const u8,
     o_sub_path: []const u8,
 ) !void {
     var seen_eaccess = false;
     while (true) {
-        fs.rename(
+        Io.Dir.rename(
             cache_directory.handle,
             tmp_dir_sub_path,
             cache_directory.handle,
             o_sub_path,
+            io,
         ) catch |err| switch (err) {
             // On Windows, rename fails with `AccessDenied` rather than `PathAlreadyExists`.
             // See https://github.com/ziglang/zig/issues/8362
@@ -3427,7 +3429,7 @@ fn renameTmpIntoCache(
                 continue;
             },
             error.FileNotFound => {
-                try cache_directory.handle.makePath("o");
+                try cache_directory.handle.makePath(io, "o");
                 continue;
             },
             else => |e| return e,
@@ -5816,7 +5818,7 @@ pub fn translateC(
     const o_sub_path = "o" ++ fs.path.sep_str ++ hex_digest;
 
     if (comp.verbose_cimport) log.info("renaming {s} to {s}", .{ tmp_sub_path, o_sub_path });
-    try renameTmpIntoCache(comp.dirs.local_cache, tmp_sub_path, o_sub_path);
+    try renameTmpIntoCache(io, comp.dirs.local_cache, tmp_sub_path, o_sub_path);
 
     return .{
         .digest = bin_digest,
diff --git a/src/Package/Fetch.zig b/src/Package/Fetch.zig
index a651107bf5..e54dcb9914 100644
--- a/src/Package/Fetch.zig
+++ b/src/Package/Fetch.zig
@@ -1414,6 +1414,7 @@ fn unpackGitPack(f: *Fetch, out_dir: Io.Dir, resource: *Resource.Git) anyerror!U
 
 fn recursiveDirectoryCopy(f: *Fetch, dir: Io.Dir, tmp_dir: Io.Dir) anyerror!void {
     const gpa = f.arena.child_allocator;
+    const io = f.job_queue.io;
     // Recursive directory copy.
     var it = try dir.walk(gpa);
     defer it.deinit();
@@ -1428,7 +1429,7 @@ fn recursiveDirectoryCopy(f: *Fetch, dir: Io.Dir, tmp_dir: Io.Dir) anyerror!void
                     .{},
                 ) catch |err| switch (err) {
                     error.FileNotFound => {
-                        if (fs.path.dirname(entry.path)) |dirname| try tmp_dir.makePath(dirname);
+                        if (fs.path.dirname(entry.path)) |dirname| try tmp_dir.makePath(io, dirname);
                         try dir.copyFile(entry.path, tmp_dir, entry.path, .{});
                     },
                     else => |e| return e,
@@ -1441,7 +1442,7 @@ fn recursiveDirectoryCopy(f: *Fetch, dir: Io.Dir, tmp_dir: Io.Dir) anyerror!void
                 // the destination directory, fail with an error instead.
                 tmp_dir.symLink(link_name, entry.path, .{}) catch |err| switch (err) {
                     error.FileNotFound => {
-                        if (fs.path.dirname(entry.path)) |dirname| try tmp_dir.makePath(dirname);
+                        if (fs.path.dirname(entry.path)) |dirname| try tmp_dir.makePath(io, dirname);
                         try tmp_dir.symLink(link_name, entry.path, .{});
                     },
                     else => |e| return e,
diff --git a/src/main.zig b/src/main.zig
index fe48efa2fd..a063591b64 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -3382,7 +3382,7 @@ fn buildOutputType(
         const dump_path = try std.fmt.allocPrint(arena, "tmp" ++ sep ++ "{x}-dump-stdin{s}", .{
             std.crypto.random.int(u64), ext.canonicalName(target),
         });
-        try dirs.local_cache.handle.makePath("tmp");
+        try dirs.local_cache.handle.makePath(io, "tmp");
 
         // Note that in one of the happy paths, execve() is used to switch to
         // clang in which case any cleanup logic that exists for this temporary
@@ -4773,7 +4773,7 @@ fn cmdInit(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8) !
             var ok_count: usize = 0;
 
             for (template_paths) |template_path| {
-                if (templates.write(arena, Io.Dir.cwd(), sanitized_root_name, template_path, fingerprint)) |_| {
+                if (templates.write(arena, io, Io.Dir.cwd(), sanitized_root_name, template_path, fingerprint)) |_| {
                     std.log.info("created {s}", .{template_path});
                     ok_count += 1;
                 } else |err| switch (err) {
@@ -7394,20 +7394,21 @@ const Templates = struct {
     fn write(
         templates: *Templates,
         arena: Allocator,
+        io: Io,
         out_dir: Io.Dir,
         root_name: []const u8,
         template_path: []const u8,
         fingerprint: Package.Fingerprint,
     ) !void {
         if (fs.path.dirname(template_path)) |dirname| {
-            out_dir.makePath(dirname) catch |err| {
-                fatal("unable to make path '{s}': {s}", .{ dirname, @errorName(err) });
+            out_dir.makePath(io, dirname) catch |err| {
+                fatal("unable to make path '{s}': {t}", .{ dirname, err });
             };
         }
 
         const max_bytes = 10 * 1024 * 1024;
         const contents = templates.dir.readFileAlloc(template_path, arena, .limited(max_bytes)) catch |err| {
-            fatal("unable to read template file '{s}': {s}", .{ template_path, @errorName(err) });
+            fatal("unable to read template file '{s}': {t}", .{ template_path, err });
         };
         templates.buffer.clearRetainingCapacity();
         try templates.buffer.ensureUnusedCapacity(contents.len);