@zigc/lib 0.16.0-test.1 → 0.17.0-dev.131

package/std/Build/Step/TranslateC.zig

@@ -18,14 +18,12 @@ target: std.Build.ResolvedTarget,
 optimize: std.builtin.OptimizeMode,
 output_file: std.Build.GeneratedFile,
 link_libc: bool,
-use_clang: bool,
 
 pub const Options = struct {
     root_source_file: std.Build.LazyPath,
     target: std.Build.ResolvedTarget,
     optimize: std.builtin.OptimizeMode,
     link_libc: bool = true,
-    use_clang: bool = true,
 };
 
 pub fn create(owner: *std.Build, options: Options) *TranslateC {
@@ -46,7 +44,6 @@ pub fn create(owner: *std.Build, options: Options) *TranslateC {
         .optimize = options.optimize,
         .output_file = .{ .step = &translate_c.step },
         .link_libc = options.link_libc,
-        .use_clang = options.use_clang,
         .system_libs = .empty,
     };
     source.addStepDependencies(&translate_c.step);
@@ -175,9 +172,6 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
     if (translate_c.link_libc) {
         try argv_list.append("-lc");
     }
-    if (!translate_c.use_clang) {
-        try argv_list.append("-fno-clang");
-    }
 
     try argv_list.append("--cache-dir");
     try argv_list.append(b.cache_root.path orelse ".");

package/std/Build/Step.zig

@@ -67,7 +67,7 @@ test_results: TestResults,
 
 /// The return address associated with creation of this step that can be useful
 /// to print along with debugging messages.
-debug_stack_trace: std.builtin.StackTrace,
+debug_stack_trace: std.debug.StackTrace,
 
 pub const TestResults = struct {
     /// The total number of tests in the step. Every test has a "status" from the following:
@@ -282,8 +282,7 @@ pub fn make(s: *Step, options: MakeOptions) error{ MakeFailed, MakeSkipped }!voi
     }
 
     make_result catch |err| switch (err) {
-        error.MakeFailed => return error.MakeFailed,
-        error.MakeSkipped => return error.MakeSkipped,
+        error.MakeFailed, error.MakeSkipped => |e| return e,
         else => {
             s.result_error_msgs.append(arena, @errorName(err)) catch @panic("OOM");
             return error.MakeFailed;
@@ -328,7 +327,7 @@ pub fn cast(step: *Step, comptime T: type) ?*T {
 /// For debugging purposes, prints identifying information about this Step.
 pub fn dump(step: *Step, t: Io.Terminal) void {
     const w = t.writer;
-    if (step.debug_stack_trace.instruction_addresses.len > 0) {
+    if (step.debug_stack_trace.return_addresses.len > 0) {
         w.print("name: '{s}'. creation stack trace:\n", .{step.name}) catch {};
         std.debug.writeStackTrace(&step.debug_stack_trace, t) catch {};
     } else {
@@ -725,19 +724,12 @@ pub inline fn handleChildProcUnsupported(s: *Step) error{ OutOfMemory, MakeFaile
 /// Asserts that the caller has already populated `s.result_failed_command`.
 pub fn handleChildProcessTerm(s: *Step, term: std.process.Child.Term) error{ MakeFailed, OutOfMemory }!void {
     assert(s.result_failed_command != null);
-    switch (term) {
-        .exited => |code| {
-            if (code != 0) {
-                return s.fail("process exited with error code {d}", .{code});
-            }
-        },
-        .signal => |sig| {
-            return s.fail("process terminated with signal {t}", .{sig});
-        },
-        .stopped, .unknown => {
-            return s.fail("process terminated unexpectedly", .{});
-        },
-    }
+    return switch (term) {
+        .exited => |code| if (code != 0) s.fail("process exited with error code {d}", .{code}),
+        .signal => |sig| s.fail("process terminated with signal {t}", .{sig}),
+        .stopped => |sig| s.fail("process stopped with signal {t}", .{sig}),
+        .unknown => s.fail("process terminated unexpectedly", .{}),
+    };
 }
 
 pub fn allocPrintCmd(
@@ -852,8 +844,7 @@ fn failWithCacheError(
                 });
             },
         },
-        error.OutOfMemory => return error.OutOfMemory,
-        error.Canceled => return error.Canceled,
+        error.OutOfMemory, error.Canceled => |e| return e,
         error.InvalidFormat => return s.fail("failed to check cache: invalid manifest file format", .{}),
     }
 }

package/std/Build/WebServer.zig

@@ -6,7 +6,7 @@ root_prog_node: std.Progress.Node,
 watch: bool,
 
 tcp_server: ?net.Server,
-serve_thread: ?std.Thread,
+serve_task: ?Io.Future(Io.Cancelable!void),
 
 /// Uses `Io.Clock.awake`.
 base_timestamp: Io.Timestamp,
@@ -103,7 +103,7 @@ pub fn init(opts: Options) WebServer {
         .watch = opts.watch,
 
         .tcp_server = null,
-        .serve_thread = null,
+        .serve_task = null,
 
         .base_timestamp = opts.base_timestamp.raw,
         .step_names_trailing = step_names_trailing,
@@ -136,9 +136,9 @@ pub fn deinit(ws: *WebServer) void {
     gpa.free(ws.time_report_msgs);
     gpa.free(ws.time_report_update_times);
 
-    if (ws.serve_thread) |t| {
+    if (ws.serve_task) |t| {
         if (ws.tcp_server) |*s| s.stream.close(io);
-        t.join();
+        t.await();
     }
     if (ws.tcp_server) |*s| s.deinit();
 
@@ -146,15 +146,15 @@ pub fn deinit(ws: *WebServer) void {
 }
 pub fn start(ws: *WebServer) error{AlreadyReported}!void {
     assert(ws.tcp_server == null);
-    assert(ws.serve_thread == null);
+    assert(ws.serve_task == null);
     const io = ws.graph.io;
 
     ws.tcp_server = ws.listen_address.listen(io, .{ .reuse_address = true }) catch |err| {
-        log.err("failed to listen to port {d}: {s}", .{ ws.listen_address.getPort(), @errorName(err) });
+        log.err("failed to listen to port {d}: {t}", .{ ws.listen_address.getPort(), err });
         return error.AlreadyReported;
     };
-    ws.serve_thread = std.Thread.spawn(.{}, serve, .{ws}) catch |err| {
-        log.err("unable to spawn web server thread: {s}", .{@errorName(err)});
+    ws.serve_task = io.concurrent(serve, .{ws}) catch |err| {
+        log.err("unable to spawn web server thread: {t}", .{err});
         ws.tcp_server.?.deinit(io);
         ws.tcp_server = null;
         return error.AlreadyReported;
@@ -165,15 +165,20 @@ pub fn start(ws: *WebServer) error{AlreadyReported}!void {
         log.info("hint: pass '--webui={f}' to use the same port next time", .{ws.tcp_server.?.socket.address});
     }
 }
-fn serve(ws: *WebServer) void {
+fn serve(ws: *WebServer) Io.Cancelable!void {
     const io = ws.graph.io;
+    var group: Io.Group = .init;
+    defer group.cancel(io);
     while (true) {
-        var stream = ws.tcp_server.?.accept(io) catch |err| {
-            log.err("failed to accept connection: {s}", .{@errorName(err)});
-            return;
+        var stream = ws.tcp_server.?.accept(io) catch |err| switch (err) {
+            error.Canceled => |e| return e,
+            else => |e| {
+                log.err("failed to accept connection: {t}", .{e});
+                return;
+            },
         };
-        _ = std.Thread.spawn(.{}, accept, .{ ws, stream }) catch |err| {
-            log.err("unable to spawn connection thread: {s}", .{@errorName(err)});
+        group.concurrent(io, accept, .{ ws, stream }) catch |err| {
+            log.err("unable to spawn connection thread: {t}", .{err});
             stream.close(io);
             continue;
         };
@@ -303,8 +308,8 @@ fn serveWebSocket(ws: *WebServer, sock: *http.Server.WebSocket) !noreturn {
         copy.* = @atomicLoad(u8, shared, .monotonic);
     }
 
-    const recv_thread = try std.Thread.spawn(.{}, recvWebSocketMessages, .{ ws, sock });
-    defer recv_thread.join();
+    var recv_thread = try io.concurrent(recvWebSocketMessages, .{ ws, sock });
+    defer recv_thread.cancel(io);
 
     {
         const hello_header: abi.Hello = .{
@@ -617,8 +622,8 @@ fn buildClientWasm(ws: *WebServer, arena: Allocator, optimize: std.builtin.Optim
     defer body_buffer.deinit(gpa);
 
     while (true) {
-        const header = stdout.takeStruct(Header, .little) catch |e| switch (e) {
-            error.ReadFailed => return error.ReadFailed,
+        const header = stdout.takeStruct(Header, .little) catch |err| switch (err) {
+            error.ReadFailed => |e| return e,
             error.EndOfStream => break,
         };
         body_buffer.clearRetainingCapacity();
@@ -676,7 +681,14 @@ fn buildClientWasm(ws: *WebServer, arena: Allocator, optimize: std.builtin.Optim
             );
             return error.WasmCompilationFailed;
         },
-        .stopped, .unknown => {
+        .stopped => |sig| {
+            log.err(
+                "the following command stopped unexpectedly with signal {t}:\n{s}",
+                .{ sig, try Build.Step.allocPrintCmd(arena, .inherit, null, argv.items) },
+            );
+            return error.WasmCompilationFailed;
+        },
+        .unknown => {
             log.err(
                 "the following command terminated unexpectedly:\n{s}",
                 .{try Build.Step.allocPrintCmd(arena, .inherit, null, argv.items)},

package/std/Build/abi.zig

@@ -162,15 +162,39 @@ pub const fuzz = struct {
     pub extern fn fuzzer_init(cache_dir_path: Slice) void;
     /// `fuzzer_init` must be called first.
     pub extern fn fuzzer_coverage() Coverage;
+    pub extern fn fuzzer_unslide_address(addr: usize) usize;
+
+    /// Performs all the fuzzing work and selects tests to run
+    ///
     /// `fuzzer_init` must be called first.
-    pub extern fn fuzzer_set_test(test_one: TestOne, unit_test_name: Slice) void;
-    /// `fuzzer_set_test` must be called first.
-    /// The callee owns the memory of bytes and must not free it until `fuzzer_main` returns
+    pub extern fn fuzzer_main(
+        n_tests: u32,
+        seed: u32,
+        limit_kind: LimitKind,
+        amount_or_instance: u64,
+    ) void;
+    pub extern fn runner_test_run(i: u32) void;
+    pub extern fn runner_test_name(i: u32) Slice;
+    // Since the runner owns the `std.zig.Server` instance, it also controls the
+    // concurrent Io instance so reads can be canceled. As such, the fuzzer has
+    // to call into the runner for any zig server / concurrent operation.
+    pub extern fn runner_start_input_poller() void;
+    pub extern fn runner_stop_input_poller() void;
+    /// Returns if cancelation has been indicated.
+    pub extern fn runner_futex_wait(*const u32, expected: u32) bool;
+    pub extern fn runner_futex_wake(*const u32, waiters: u32) void;
+    pub extern fn runner_broadcast_input(test_i: u32, bytes: Slice) void;
+    /// `fuzzer_main` must be called first.
+    ///
+    /// Called concurrently with `fuzzer_main`. Returns if cancelation has been indicated.
+    pub extern fn fuzzer_receive_input(test_i: u32, bytes: Slice) bool;
+
+    /// Must be called from inside a test function
+    pub extern fn fuzzer_set_test(test_one: TestOne) void;
+    /// Must be called from inside a test function where `fuzzer_set_test` has been called first.
     pub extern fn fuzzer_new_input(bytes: Slice) void;
-    /// `fuzzer_set_test` must be called first.
-    /// Resets the fuzzer's state to that of `fuzzer_init`.
-    pub extern fn fuzzer_main(limit_kind: LimitKind, amount: u64) void;
-    pub extern fn fuzzer_unslide_address(addr: usize) usize;
+    /// Must be called from inside a test function where `fuzzer_set_test` has been called first.
+    pub extern fn fuzzer_start_test() void;
 
     pub extern fn fuzzer_int(uid: Uid, weights: Weights) u64;
     pub extern fn fuzzer_eos(uid: Uid, weights: Weights) bool;
@@ -235,7 +259,8 @@ pub const fuzz = struct {
         max: u64,
         weight: u64,
 
-        fn intFromValue(x: anytype) u64 {
+        /// `inline` to propogate comptimeness
+        inline fn intFromValue(x: anytype) u64 {
             const T = @TypeOf(x);
             return switch (@typeInfo(T)) {
                 .comptime_int => x,
@@ -269,11 +294,13 @@ pub const fuzz = struct {
             };
         }
 
-        pub fn value(T: type, x: T, weight: u64) Weight {
+        /// `inline` to propogate comptimeness
+        pub inline fn value(T: type, x: T, weight: u64) Weight {
             return .{ .min = intFromValue(x), .max = intFromValue(x), .weight = weight };
         }
 
-        pub fn rangeAtMost(T: type, at_least: T, at_most: T, weight: u64) Weight {
+        /// `inline` to propogate comptimeness
+        pub inline fn rangeAtMost(T: type, at_least: T, at_most: T, weight: u64) Weight {
             std.debug.assert(intFromValue(at_least) <= intFromValue(at_most));
             return .{
                 .min = intFromValue(at_least),
@@ -282,7 +309,8 @@ pub const fuzz = struct {
             };
         }
 
-        pub fn rangeLessThan(T: type, at_least: T, less_than: T, weight: u64) Weight {
+        /// `inline` to propogate comptimeness
+        pub inline fn rangeLessThan(T: type, at_least: T, less_than: T, weight: u64) Weight {
             std.debug.assert(intFromValue(at_least) < intFromValue(less_than));
             return .{
                 .min = intFromValue(at_least),
@@ -333,6 +361,14 @@ pub const fuzz = struct {
         }
     };
 
+    /// Fields are little-endian
+    pub const MmapInputHeader = extern struct {
+        pc_digest: u64 align(4), // aligned so header does not have padding
+        instance_id: u32,
+        test_i: u32,
+        len: u32,
+    };
+
     /// WebSocket server->client.
     ///
     /// Sent once, when fuzzing starts, to indicate the available coverage data.

package/std/Build.zig

@@ -38,7 +38,6 @@ verbose_cc: bool,
 verbose_air: bool,
 verbose_llvm_ir: ?[]const u8,
 verbose_llvm_bc: ?[]const u8,
-verbose_cimport: bool,
 verbose_llvm_cpu_features: bool,
 reference_trace: ?u32 = null,
 invalid_user_input: bool,
@@ -86,10 +85,10 @@ libc_runtimes_dir: ?[]const u8 = null,
 
 dep_prefix: []const u8 = "",
 
-modules: std.StringArrayHashMap(*Module),
+modules: std.array_hash_map.String(*Module),
 
-named_writefiles: std.StringArrayHashMap(*Step.WriteFile),
-named_lazy_paths: std.StringArrayHashMap(LazyPath),
+named_writefiles: std.array_hash_map.String(*Step.WriteFile),
+named_lazy_paths: std.array_hash_map.String(LazyPath),
 /// The hash of this instance's package. `""` means that this is the root package.
 pkg_hash: []const u8,
 /// A mapping from dependency names to package hashes.
@@ -128,6 +127,9 @@ pub const Graph = struct {
     random_seed: u32 = 0,
     dependency_cache: InitializedDepMap = .empty,
     allow_so_scripts: ?bool = null,
+    /// Steps should use `io` to limit the number of jobs, however in the case of
+    /// a single step spawning a fixed number of processes this can be used.
+    max_jobs: ?u32 = null,
     time_report: bool,
     /// Similar to the `Io.Terminal.Mode` returned by `Io.lockStderr`, but also
     /// respects the '--color' flag.
@@ -275,7 +277,6 @@ pub fn create(
         .verbose_air = false,
         .verbose_llvm_ir = null,
         .verbose_llvm_bc = null,
-        .verbose_cimport = false,
         .verbose_llvm_cpu_features = false,
         .invalid_user_input = false,
         .allocator = arena,
@@ -309,9 +310,9 @@ pub fn create(
         },
         .install_path = undefined,
         .args = null,
-        .modules = .init(arena),
-        .named_writefiles = .init(arena),
-        .named_lazy_paths = .init(arena),
+        .modules = .empty,
+        .named_writefiles = .empty,
+        .named_lazy_paths = .empty,
         .pkg_hash = "",
         .available_deps = available_deps,
         .release_mode = .off,
@@ -374,7 +375,6 @@ fn createChildOnly(
         .verbose_air = parent.verbose_air,
         .verbose_llvm_ir = parent.verbose_llvm_ir,
         .verbose_llvm_bc = parent.verbose_llvm_bc,
-        .verbose_cimport = parent.verbose_cimport,
         .verbose_llvm_cpu_features = parent.verbose_llvm_cpu_features,
         .reference_trace = parent.reference_trace,
         .invalid_user_input = false,
@@ -402,9 +402,9 @@ fn createChildOnly(
         .enable_wine = parent.enable_wine,
         .libc_runtimes_dir = parent.libc_runtimes_dir,
         .dep_prefix = parent.fmt("{s}{s}.", .{ parent.dep_prefix, dep_name }),
-        .modules = .init(allocator),
-        .named_writefiles = .init(allocator),
-        .named_lazy_paths = .init(allocator),
+        .modules = .empty,
+        .named_writefiles = .empty,
+        .named_lazy_paths = .empty,
         .pkg_hash = pkg_hash,
         .available_deps = pkg_deps,
         .release_mode = parent.release_mode,
@@ -905,7 +905,7 @@ pub const AssemblyOptions = struct {
 /// `createModule` can be used instead to create a private module.
 pub fn addModule(b: *Build, name: []const u8, options: Module.CreateOptions) *Module {
     const module = Module.create(b, options);
-    b.modules.put(b.dupe(name), module) catch @panic("OOM");
+    b.modules.put(b.graph.arena, b.dupe(name), module) catch @panic("OOM");
     return module;
 }
 
@@ -1053,12 +1053,12 @@ pub fn addWriteFile(b: *Build, file_path: []const u8, data: []const u8) *Step.Wr
 
 pub fn addNamedWriteFiles(b: *Build, name: []const u8) *Step.WriteFile {
     const wf = Step.WriteFile.create(b);
-    b.named_writefiles.put(b.dupe(name), wf) catch @panic("OOM");
+    b.named_writefiles.put(b.graph.arena, b.dupe(name), wf) catch @panic("OOM");
     return wf;
 }
 
 pub fn addNamedLazyPath(b: *Build, name: []const u8, lp: LazyPath) void {
-    b.named_lazy_paths.put(b.dupe(name), lp.dupe(b)) catch @panic("OOM");
+    b.named_lazy_paths.put(b.graph.arena, b.dupe(name), lp.dupe(b)) catch @panic("OOM");
 }
 
 /// Creates a step for mutating files inside a temporary directory created lazily
@@ -1896,11 +1896,11 @@ pub fn runAllowFail(
             }
             return stdout;
         },
-        .signal => |sig| {
+        .signal, .stopped => |sig| {
             out_code.* = @as(u8, @truncate(@intFromEnum(sig)));
             return error.ProcessTerminated;
         },
-        .stopped, .unknown => |code| {
+        .unknown => |code| {
             out_code.* = @as(u8, @truncate(code));
             return error.ProcessTerminated;
         },

package/std/Io/Dir.zig

@@ -1993,7 +1993,7 @@ pub fn setFileOwner(
     owner: ?File.Uid,
     group: ?File.Gid,
     options: SetFileOwnerOptions,
-) SetOwnerError!void {
+) SetFileOwnerError!void {
     return io.vtable.dirSetFileOwner(io.userdata, dir, sub_path, owner, group, options);
 }
 
@@ -2032,9 +2032,14 @@ pub fn setTimestampsNow(
     sub_path: []const u8,
     options: SetTimestampsNowOptions,
 ) SetTimestampsError!void {
-    return io.vtable.fileSetTimestamps(io.userdata, dir, sub_path, .{
+    return io.vtable.dirSetTimestamps(io.userdata, dir, sub_path, .{
         .follow_symlinks = options.follow_symlinks,
         .access_timestamp = .now,
         .modify_timestamp = .now,
     });
 }
+
+test {
+    _ = &setFileOwner;
+    _ = &setTimestampsNow;
+}

package/std/Io/Dispatch.zig

@@ -459,7 +459,6 @@ pub fn io(ev: *Evented) Io {
             .netConnectUnix = netConnectUnixUnavailable,
             .netSocketCreatePair = netSocketCreatePairUnavailable,
             .netSend = netSendUnavailable,
-            .netRead = netReadUnavailable,
             .netWrite = netWriteUnavailable,
             .netWriteFile = netWriteFileUnavailable,
             .netClose = netClose,
@@ -1713,6 +1712,7 @@ fn operate(userdata: ?*anyopaque, operation: Io.Operation) Io.Cancelable!Io.Oper
         },
         .device_io_control => |*o| return .{ .device_io_control = try deviceIoControl(o) },
         .net_receive => @panic("TODO implement net_receive operation"),
+        .net_read => @panic("TODO implement net_read operation"),
     }
 }
 
@@ -2134,6 +2134,7 @@ fn batchDrainSubmitted(
                 },
                 .device_io_control => {},
                 .net_receive => @panic("TODO implement batched net_receive"),
+                .net_read => @panic("TODO implement batched net_read"),
             };
             if (concurrency) return error.ConcurrencyUnavailable;
             break :result try operate(ev, storage.submission.operation);
@@ -2193,6 +2194,7 @@ fn batchSourceEvent(context: ?*anyopaque) callconv(.c) void {
         },
         .device_io_control => unreachable,
         .net_receive => @panic("TODO implement batched net_receive"),
+        .net_read => @panic("TODO implement batched net_read"),
     };
 
     switch (pending.node.prev) {
@@ -2512,6 +2514,7 @@ fn dirCreateFile(
             .OPNOTSUPP => return error.FileLocksUnsupported,
             .AGAIN => return error.WouldBlock,
             .TXTBSY => return error.FileBusy,
+            .ROFS => return error.ReadOnlyFileSystem,
             .NXIO => return error.NoDevice,
             .ILSEQ => return error.BadPathName,
             else => |err| return unexpectedErrno(err),
@@ -2647,6 +2650,7 @@ fn dirOpenFile(
             .AGAIN => return error.WouldBlock,
             .TXTBSY => return error.FileBusy,
             .NXIO => return error.NoDevice,
+            .ROFS => return error.ReadOnlyFileSystem,
             .ILSEQ => return error.BadPathName,
             else => |err| return unexpectedErrno(err),
         }
@@ -4875,18 +4879,6 @@ fn netSendUnavailable(
     return .{ error.NetworkDown, 0 };
 }
 
-fn netReadUnavailable(
-    userdata: ?*anyopaque,
-    fd: net.Socket.Handle,
-    data: [][]u8,
-) net.Stream.Reader.Error!usize {
-    const ev: *Evented = @ptrCast(@alignCast(userdata));
-    _ = ev;
-    _ = fd;
-    _ = data;
-    return error.NetworkDown;
-}
-
 fn netWriteUnavailable(
     userdata: ?*anyopaque,
     handle: net.Socket.Handle,

package/std/Io/File/Reader.zig

@@ -309,7 +309,9 @@ fn discard(io_reader: *Io.Reader, limit: Io.Limit) Io.Reader.Error!usize {
                 return 0;
             };
             const logical_pos = logicalPos(r);
-            const delta = @min(@intFromEnum(limit), size - logical_pos);
+            const bytes_remaining = size - logical_pos;
+            if (bytes_remaining == 0) return error.EndOfStream;
+            const delta = @min(@intFromEnum(limit), bytes_remaining);
             setLogicalPos(r, logical_pos + delta);
             return delta;
         },

package/std/Io/File/Writer.zig

@@ -162,9 +162,10 @@ fn sendFilePositional(w: *Writer, file_reader: *Io.File.Reader, limit: Io.Limit)
             w.err = error.Canceled;
             return error.WriteFailed;
         },
-        error.EndOfStream => return error.EndOfStream,
-        error.Unimplemented => return error.Unimplemented,
-        error.ReadFailed => return error.ReadFailed,
+        error.EndOfStream,
+        error.Unimplemented,
+        error.ReadFailed,
+        => |e| return e,
         else => |e| {
             w.write_file_err = e;
             return error.WriteFailed;
@@ -182,9 +183,10 @@ fn sendFileStreaming(w: *Writer, file_reader: *Io.File.Reader, limit: Io.Limit)
             w.err = error.Canceled;
             return error.WriteFailed;
         },
-        error.EndOfStream => return error.EndOfStream,
-        error.Unimplemented => return error.Unimplemented,
-        error.ReadFailed => return error.ReadFailed,
+        error.EndOfStream,
+        error.Unimplemented,
+        error.ReadFailed,
+        => |e| return e,
         else => |e| {
             w.write_file_err = e;
             return error.WriteFailed;

package/std/Io/File.zig

@@ -202,6 +202,7 @@ pub const OpenError = error{
     NotDir,
     /// The path already exists and the `CREAT` and `EXCL` flags were provided.
     PathAlreadyExists,
+    ReadOnlyFileSystem,
     DeviceBusy,
     FileLocksUnsupported,
     /// One of these three things:

package/std/Io/Kqueue.zig

@@ -186,7 +186,7 @@ pub fn init(k: *Kqueue, gpa: Allocator, options: InitOptions) !void {
         .awaiter = null,
         .queue_next = null,
         .cancel_thread = null,
-        .awaiting_completions = .initEmpty(),
+        .awaiting_completions = .empty,
     };
     const main_thread = &k.threads.allocated[0];
     Thread.self = main_thread;
@@ -713,7 +713,7 @@ fn concurrent(
         .awaiter = null,
         .queue_next = null,
         .cancel_thread = null,
-        .awaiting_completions = .initEmpty(),
+        .awaiting_completions = .empty,
     };
     closure.* = .{
         .kqueue = k,

package/std/Io/Reader.zig

@@ -200,8 +200,7 @@ pub fn defaultDiscard(r: *Reader, limit: Limit) Error!usize {
     var d: Writer.Discarding = .init(r.buffer);
     var n = r.stream(&d.writer, limit) catch |err| switch (err) {
         error.WriteFailed => unreachable,
-        error.ReadFailed => return error.ReadFailed,
-        error.EndOfStream => return error.EndOfStream,
+        error.ReadFailed, error.EndOfStream => |e| return e,
     };
     // If `stream` wrote to `r.buffer` without going through the writer,
     // we need to discard as much of the buffered data as possible.
@@ -379,7 +378,7 @@ pub fn appendRemainingAligned(
         const n = stream(r, &a.writer, remaining) catch |err| switch (err) {
             error.EndOfStream => return,
             error.WriteFailed => return error.OutOfMemory,
-            error.ReadFailed => return error.ReadFailed,
+            error.ReadFailed => |e| return e,
         };
         remaining = remaining.subtract(n).?;
     }
@@ -400,7 +399,7 @@ pub fn appendRemainingUnlimited(r: *Reader, gpa: Allocator, list: *ArrayList(u8)
     }
     _ = streamRemaining(r, &a.writer) catch |err| switch (err) {
         error.WriteFailed => return error.OutOfMemory,
-        error.ReadFailed => return error.ReadFailed,
+        error.ReadFailed => |e| return e,
     };
 }
 
@@ -428,7 +427,7 @@ pub fn readVec(r: *Reader, data: [][]u8) Error!usize {
         defer data[i] = buf;
         return n + (r.vtable.readVec(r, data[i..]) catch |err| switch (err) {
             error.EndOfStream => if (n == 0) return error.EndOfStream else 0,
-            error.ReadFailed => return error.ReadFailed,
+            error.ReadFailed => |e| return e,
         });
     }
     const n = seek - r.seek;
@@ -639,7 +638,7 @@ pub fn discardShort(r: *Reader, n: usize) ShortError!usize {
     while (true) {
         const discard_len = r.vtable.discard(r, .limited(remaining)) catch |err| switch (err) {
             error.EndOfStream => return n - remaining,
-            error.ReadFailed => return error.ReadFailed,
+            error.ReadFailed => |e| return e,
         };
         remaining -= discard_len;
         if (remaining == 0) return n;
@@ -687,7 +686,7 @@ pub fn readSliceShort(r: *Reader, buffer: []u8) ShortError!usize {
         data[0] = buffer[i..];
         i += readVec(r, &data) catch |err| switch (err) {
             error.EndOfStream => return i,
-            error.ReadFailed => return error.ReadFailed,
+            error.ReadFailed => |e| return e,
         };
         if (buffer.len - i == 0) return buffer.len;
     }
@@ -1009,7 +1008,7 @@ pub fn streamDelimiterLimit(
     var remaining = @intFromEnum(limit);
     while (remaining != 0) {
         const available = Limit.limited(remaining).slice(r.peekGreedy(1) catch |err| switch (err) {
-            error.ReadFailed => return error.ReadFailed,
+            error.ReadFailed => |e| return e,
             error.EndOfStream => return @intFromEnum(limit) - remaining,
         });
         if (std.mem.findScalar(u8, available, delimiter)) |delimiter_index| {
@@ -1080,7 +1079,7 @@ pub fn discardDelimiterLimit(r: *Reader, delimiter: u8, limit: Limit) DiscardDel
     var remaining = @intFromEnum(limit);
     while (remaining != 0) {
         const available = Limit.limited(remaining).slice(r.peekGreedy(1) catch |err| switch (err) {
-            error.ReadFailed => return error.ReadFailed,
+            error.ReadFailed => |e| return e,
             error.EndOfStream => return @intFromEnum(limit) - remaining,
         });
         if (std.mem.findScalar(u8, available, delimiter)) |delimiter_index| {