fix compilation failures found by CI

Author: andrewrk

lib/compiler/resinator/main.zig

@@ -26,7 +26,7 @@ pub fn main() !void {
 
     if (args.len < 2) {
         try renderErrorMessage(stderr.writer(), stderr_config, .err, "expected zig lib dir as first argument", .{});
-        std.os.exit(1);
+        std.process.exit(1);
     }
     const zig_lib_dir = args[1];
     var cli_args = args[2..];
@@ -62,7 +62,7 @@ pub fn main() !void {
         var options = cli.parse(allocator, cli_args, &cli_diagnostics) catch |err| switch (err) {
             error.ParseError => {
                 try error_handler.emitCliDiagnostics(allocator, cli_args, &cli_diagnostics);
-                std.os.exit(1);
+                std.process.exit(1);
             },
             else => |e| return e,
         };
@@ -117,7 +117,7 @@ pub fn main() !void {
                 },
             }
             try error_handler.emitMessage(allocator, .note, "to disable auto includes, use the option /:auto-includes none", .{});
-            std.os.exit(1);
+            std.process.exit(1);
         },
     };
 
@@ -153,16 +153,16 @@ pub fn main() !void {
             preprocess.preprocess(&comp, preprocessed_buf.writer(), argv.items, maybe_dependencies_list) catch |err| switch (err) {
                 error.GeneratedSourceError => {
                     try error_handler.emitAroDiagnostics(allocator, "failed during preprocessor setup (this is always a bug):", &comp);
-                    std.os.exit(1);
+                    std.process.exit(1);
                 },
                 // ArgError can occur if e.g. the .rc file is not found
                 error.ArgError, error.PreprocessError => {
                     try error_handler.emitAroDiagnostics(allocator, "failed during preprocessing:", &comp);
-                    std.os.exit(1);
+                    std.process.exit(1);
                 },
                 error.StreamTooLong => {
                     try error_handler.emitMessage(allocator, .err, "failed during preprocessing: maximum file size exceeded", .{});
-                    std.os.exit(1);
+                    std.process.exit(1);
                 },
                 error.OutOfMemory => |e| return e,
             };
@@ -171,7 +171,7 @@ pub fn main() !void {
         } else {
             break :full_input std.fs.cwd().readFileAlloc(allocator, options.input_filename, std.math.maxInt(usize)) catch |err| {
                 try error_handler.emitMessage(allocator, .err, "unable to read input file path '{s}': {s}", .{ options.input_filename, @errorName(err) });
-                std.os.exit(1);
+                std.process.exit(1);
             };
         }
     };
@@ -191,14 +191,14 @@ pub fn main() !void {
     const final_input = removeComments(mapping_results.result, mapping_results.result, &mapping_results.mappings) catch |err| switch (err) {
         error.InvalidSourceMappingCollapse => {
             try error_handler.emitMessage(allocator, .err, "failed during comment removal; this is a known bug", .{});
-            std.os.exit(1);
+            std.process.exit(1);
         },
         else => |e| return e,
     };
 
     var output_file = std.fs.cwd().createFile(options.output_filename, .{}) catch |err| {
         try error_handler.emitMessage(allocator, .err, "unable to create output file '{s}': {s}", .{ options.output_filename, @errorName(err) });
-        std.os.exit(1);
+        std.process.exit(1);
     };
     var output_file_closed = false;
     defer if (!output_file_closed) output_file.close();
@@ -231,7 +231,7 @@ pub fn main() !void {
             output_file_closed = true;
             // Failing to delete is not really a big deal, so swallow any errors
             std.fs.cwd().deleteFile(options.output_filename) catch {};
-            std.os.exit(1);
+            std.process.exit(1);
         },
         else => |e| return e,
     };
@@ -247,7 +247,7 @@ pub fn main() !void {
     if (options.depfile_path) |depfile_path| {
         var depfile = std.fs.cwd().createFile(depfile_path, .{}) catch |err| {
             try error_handler.emitMessage(allocator, .err, "unable to create depfile '{s}': {s}", .{ depfile_path, @errorName(err) });
-            std.os.exit(1);
+            std.process.exit(1);
         };
         defer depfile.close();
 

lib/std/c/wasi.zig

@@ -8,6 +8,8 @@ pub fn _errno() *c_int {
     return &errno;
 }
 
+pub const PATH_MAX = 4096;
+
 pub const mode_t = u32;
 pub const time_t = i64;
 

lib/std/fs.zig

@@ -53,14 +53,12 @@ pub const MAX_PATH_BYTES = max_path_bytes;
 /// * On other platforms, `[]u8` file paths are opaque sequences of bytes with
 ///   no particular encoding.
 pub const max_path_bytes = switch (native_os) {
-    .linux, .macos, .ios, .freebsd, .openbsd, .netbsd, .dragonfly, .haiku, .solaris, .illumos, .plan9, .emscripten => posix.PATH_MAX,
+    .linux, .macos, .ios, .freebsd, .openbsd, .netbsd, .dragonfly, .haiku, .solaris, .illumos, .plan9, .emscripten, .wasi => posix.PATH_MAX,
     // Each WTF-16LE code unit may be expanded to 3 WTF-8 bytes.
     // If it would require 4 WTF-8 bytes, then there would be a surrogate
     // pair in the WTF-16LE, and we (over)account 3 bytes for it that way.
     // +1 for the null byte at the end, which can be encoded in 1 byte.
     .windows => windows.PATH_MAX_WIDE * 3 + 1,
-    // TODO work out what a reasonable value we should use here
-    .wasi => 4096,
     else => if (@hasDecl(root, "os") and @hasDecl(root.os, "PATH_MAX"))
         root.os.PATH_MAX
     else

lib/std/fs/Dir.zig

@@ -2555,7 +2555,7 @@ pub fn statFile(self: Dir, sub_path: []const u8) StatFileError!Stat {
         return file.stat();
     }
     if (native_os == .wasi and !builtin.link_libc) {
-        const st = try posix.fstatat_wasi(self.fd, sub_path, .{ .SYMLINK_FOLLOW = true });
+        const st = try std.os.fstatat_wasi(self.fd, sub_path, .{ .SYMLINK_FOLLOW = true });
         return Stat.fromWasi(st);
     }
     const st = try posix.fstatat(self.fd, sub_path, 0);

lib/std/fs/File.zig

@@ -457,7 +457,7 @@ pub fn stat(self: File) StatError!Stat {
     }
 
     if (builtin.os.tag == .wasi and !builtin.link_libc) {
-        const st = try posix.fstat_wasi(self.handle);
+        const st = try std.os.fstat_wasi(self.handle);
         return Stat.fromWasi(st);
     }
 
@@ -1004,7 +1004,7 @@ pub fn metadata(self: File) MetadataError!Metadata {
                     .statx = stx,
                 };
             },
-            .wasi => .{ .stat = try posix.fstat_wasi(self.handle) },
+            .wasi => .{ .stat = try std.os.fstat_wasi(self.handle) },
             else => .{ .stat = try posix.fstat(self.handle) },
         },
     };

lib/std/fs/wasi.zig

@@ -1,6 +1,5 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const os = std.os;
 const mem = std.mem;
 const math = std.math;
 const fs = std.fs;
@@ -14,10 +13,10 @@ pub const Preopens = struct {
     // Indexed by file descriptor number.
     names: []const []const u8,
 
-    pub fn find(p: Preopens, name: []const u8) ?os.fd_t {
+    pub fn find(p: Preopens, name: []const u8) ?std.posix.fd_t {
         for (p.names, 0..) |elem_name, i| {
             if (mem.eql(u8, elem_name, name)) {
-                return @as(os.fd_t, @intCast(i));
+                return @intCast(i);
             }
         }
         return null;

lib/std/os.zig

@@ -22,6 +22,7 @@ const elf = std.elf;
 const fs = std.fs;
 const dl = @import("dynamic_library.zig");
 const MAX_PATH_BYTES = std.fs.MAX_PATH_BYTES;
+const posix = std.posix;
 
 pub const linux = @import("os/linux.zig");
 pub const plan9 = @import("os/plan9.zig");
@@ -98,7 +99,6 @@ pub fn isGetFdPathSupportedOnTarget(os: std.Target.Os) bool {
 ///
 /// Calling this function is usually a bug.
 pub fn getFdPath(fd: std.posix.fd_t, out_buffer: *[MAX_PATH_BYTES]u8) std.posix.RealPathError![]u8 {
-    const posix = std.posix;
     if (!comptime isGetFdPathSupportedOnTarget(builtin.os)) {
         @compileError("querying for canonical path of a handle is unsupported on this host");
     }
@@ -234,3 +234,37 @@ pub fn getFdPath(fd: std.posix.fd_t, out_buffer: *[MAX_PATH_BYTES]u8) std.posix.
         else => unreachable, // made unreachable by isGetFdPathSupportedOnTarget above
     }
 }
+
+/// WASI-only. Same as `fstatat` but targeting WASI.
+/// `pathname` should be encoded as valid UTF-8.
+/// See also `fstatat`.
+pub fn fstatat_wasi(dirfd: posix.fd_t, pathname: []const u8, flags: wasi.lookupflags_t) posix.FStatAtError!wasi.filestat_t {
+    var stat: wasi.filestat_t = undefined;
+    switch (wasi.path_filestat_get(dirfd, flags, pathname.ptr, pathname.len, &stat)) {
+        .SUCCESS => return stat,
+        .INVAL => unreachable,
+        .BADF => unreachable, // Always a race condition.
+        .NOMEM => return error.SystemResources,
+        .ACCES => return error.AccessDenied,
+        .FAULT => unreachable,
+        .NAMETOOLONG => return error.NameTooLong,
+        .NOENT => return error.FileNotFound,
+        .NOTDIR => return error.FileNotFound,
+        .NOTCAPABLE => return error.AccessDenied,
+        .ILSEQ => return error.InvalidUtf8,
+        else => |err| return posix.unexpectedErrno(err),
+    }
+}
+
+pub fn fstat_wasi(fd: posix.fd_t) posix.FStatError!wasi.filestat_t {
+    var stat: wasi.filestat_t = undefined;
+    switch (wasi.fd_filestat_get(fd, &stat)) {
+        .SUCCESS => return stat,
+        .INVAL => unreachable,
+        .BADF => unreachable, // Always a race condition.
+        .NOMEM => return error.SystemResources,
+        .ACCES => return error.AccessDenied,
+        .NOTCAPABLE => return error.AccessDenied,
+        else => |err| return posix.unexpectedErrno(err),
+    }
+}

lib/std/os/linux/start_pie.zig

@@ -81,7 +81,7 @@ pub fn relocate(phdrs: []elf.Phdr) void {
             break :base @intFromPtr(dynv) - phdr.p_vaddr;
         }
         // This is not supposed to happen for well-formed binaries.
-        std.os.abort();
+        @trap();
     };
 
     var rel_addr: usize = 0;

lib/std/posix.zig

@@ -1635,7 +1635,7 @@ pub fn openat(dir_fd: fd_t, file_path: []const u8, flags: O, mode: mode_t) OpenE
         errdefer close(fd);
 
         if (flags.write) {
-            const info = try fstat_wasi(fd);
+            const info = try std.os.fstat_wasi(fd);
             if (info.filetype == .DIRECTORY)
                 return error.IsDir;
         }
@@ -4282,7 +4282,7 @@ pub const FStatError = error{
 /// Return information about a file descriptor.
 pub fn fstat(fd: fd_t) FStatError!Stat {
     if (native_os == .wasi and !builtin.link_libc) {
-        return Stat.fromFilestat(try fstat_wasi(fd));
+        return Stat.fromFilestat(try std.os.fstat_wasi(fd));
     }
     if (native_os == .windows) {
         @compileError("fstat is not yet implemented on Windows");
@@ -4300,19 +4300,6 @@ pub fn fstat(fd: fd_t) FStatError!Stat {
     }
 }
 
-fn fstat_wasi(fd: fd_t) FStatError!wasi.filestat_t {
-    var stat: wasi.filestat_t = undefined;
-    switch (wasi.fd_filestat_get(fd, &stat)) {
-        .SUCCESS => return stat,
-        .INVAL => unreachable,
-        .BADF => unreachable, // Always a race condition.
-        .NOMEM => return error.SystemResources,
-        .ACCES => return error.AccessDenied,
-        .NOTCAPABLE => return error.AccessDenied,
-        else => |err| return unexpectedErrno(err),
-    }
-}
-
 pub const FStatAtError = FStatError || error{
     NameTooLong,
     FileNotFound,
@@ -4325,10 +4312,10 @@ pub const FStatAtError = FStatError || error{
 /// which is relative to `dirfd` handle.
 /// On WASI, `pathname` should be encoded as valid UTF-8.
 /// On other platforms, `pathname` is an opaque sequence of bytes with no particular encoding.
-/// See also `fstatatZ` and `fstatat_wasi`.
+/// See also `fstatatZ` and `std.os.fstatat_wasi`.
 pub fn fstatat(dirfd: fd_t, pathname: []const u8, flags: u32) FStatAtError!Stat {
     if (native_os == .wasi and !builtin.link_libc) {
-        const filestat = try fstatat_wasi(dirfd, pathname, .{
+        const filestat = try std.os.fstatat_wasi(dirfd, pathname, .{
             .SYMLINK_FOLLOW = (flags & AT.SYMLINK_NOFOLLOW) == 0,
         });
         return Stat.fromFilestat(filestat);
@@ -4344,7 +4331,7 @@ pub fn fstatat(dirfd: fd_t, pathname: []const u8, flags: u32) FStatAtError!Stat
 /// See also `fstatat`.
 pub fn fstatatZ(dirfd: fd_t, pathname: [*:0]const u8, flags: u32) FStatAtError!Stat {
     if (native_os == .wasi and !builtin.link_libc) {
-        const filestat = try fstatat_wasi(dirfd, mem.sliceTo(pathname, 0), .{
+        const filestat = try std.os.fstatat_wasi(dirfd, mem.sliceTo(pathname, 0), .{
             .SYMLINK_FOLLOW = (flags & AT.SYMLINK_NOFOLLOW) == 0,
         });
         return Stat.fromFilestat(filestat);
@@ -4372,27 +4359,6 @@ pub fn fstatatZ(dirfd: fd_t, pathname: [*:0]const u8, flags: u32) FStatAtError!S
     }
 }
 
-/// WASI-only. Same as `fstatat` but targeting WASI.
-/// `pathname` should be encoded as valid UTF-8.
-/// See also `fstatat`.
-fn fstatat_wasi(dirfd: fd_t, pathname: []const u8, flags: wasi.lookupflags_t) FStatAtError!wasi.filestat_t {
-    var stat: wasi.filestat_t = undefined;
-    switch (wasi.path_filestat_get(dirfd, flags, pathname.ptr, pathname.len, &stat)) {
-        .SUCCESS => return stat,
-        .INVAL => unreachable,
-        .BADF => unreachable, // Always a race condition.
-        .NOMEM => return error.SystemResources,
-        .ACCES => return error.AccessDenied,
-        .FAULT => unreachable,
-        .NAMETOOLONG => return error.NameTooLong,
-        .NOENT => return error.FileNotFound,
-        .NOTDIR => return error.FileNotFound,
-        .NOTCAPABLE => return error.AccessDenied,
-        .ILSEQ => return error.InvalidUtf8,
-        else => |err| return unexpectedErrno(err),
-    }
-}
-
 pub const KQueueError = error{
     /// The per-process limit on the number of open file descriptors has been reached.
     ProcessFdQuotaExceeded,
@@ -4822,7 +4788,7 @@ pub fn faccessat(dirfd: fd_t, path: []const u8, mode: u32, flags: u32) AccessErr
         const resolved: RelativePathWasi = .{ .dir_fd = dirfd, .relative_path = path };
 
         const st = blk: {
-            break :blk fstatat_wasi(dirfd, path, .{
+            break :blk std.os.fstatat_wasi(dirfd, path, .{
                 .SYMLINK_FOLLOW = (flags & AT.SYMLINK_NOFOLLOW) == 0,
             });
         } catch |err| switch (err) {

src/DarwinPosixSpawn.zig

@@ -81,7 +81,7 @@ pub const Actions = struct {
     }
 
     pub fn open(self: *Actions, fd: std.c.fd_t, path: []const u8, flags: u32, mode: std.c.mode_t) Error!void {
-        const posix_path = try std.os.toPosixPath(path);
+        const posix_path = try std.posix.toPosixPath(path);
         return self.openZ(fd, &posix_path, flags, mode);
     }
 
@@ -130,7 +130,7 @@ pub const Actions = struct {
     }
 
     pub fn chdir(self: *Actions, path: []const u8) Error!void {
-        const posix_path = try std.os.toPosixPath(path);
+        const posix_path = try std.posix.toPosixPath(path);
         return self.chdirZ(&posix_path);
     }
 
@@ -164,7 +164,7 @@ pub fn spawn(
     argv: [*:null]?[*:0]const u8,
     envp: [*:null]?[*:0]const u8,
 ) Error!std.c.pid_t {
-    const posix_path = try std.os.toPosixPath(path);
+    const posix_path = try std.posix.toPosixPath(path);
     return spawnZ(&posix_path, actions, attr, argv, envp);
 }
 
@@ -204,12 +204,12 @@ pub fn spawnZ(
     }
 }
 
-pub fn waitpid(pid: std.c.pid_t, flags: u32) Error!std.os.WaitPidResult {
+pub fn waitpid(pid: std.c.pid_t, flags: u32) Error!std.posix.WaitPidResult {
     var status: c_int = undefined;
     while (true) {
         const rc = waitpid(pid, &status, @as(c_int, @intCast(flags)));
         switch (errno(rc)) {
-            .SUCCESS => return std.os.WaitPidResult{
+            .SUCCESS => return std.posix.WaitPidResult{
                 .pid = @as(std.c.pid_t, @intCast(rc)),
                 .status = @as(u32, @bitCast(status)),
             },