@zigc/lib 0.17.0-dev.27 → 0.17.0-dev.296

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zigc/lib",
-  "version": "0.17.0-dev.27",
+  "version": "0.17.0-dev.296",
   "description": "Zig standard library and libc headers (shared across all platforms)",
   "repository": {
     "type": "git",

package/std/Build/Cache/Path.zig

@@ -59,7 +59,7 @@ pub fn joinStringZ(p: Path, gpa: Allocator, sub_path: []const u8) Allocator.Erro
     return p.root_dir.joinZ(gpa, parts);
 }
 
-pub fn openFile(p: Path, io: Io, sub_path: []const u8, flags: Io.File.OpenFlags) !Io.File {
+pub fn openFile(p: Path, io: Io, sub_path: []const u8, flags: Io.Dir.OpenFileOptions) !Io.File {
     var buf: [fs.max_path_bytes]u8 = undefined;
     const joined_path = if (p.sub_path.len == 0) sub_path else p: {
         break :p std.fmt.bufPrint(&buf, "{s}" ++ fs.path.sep_str ++ "{s}", .{

package/std/Build/Cache.zig

@@ -562,14 +562,14 @@ pub const Manifest = struct {
                             self.diagnostic = .{ .manifest_create = error.FileNotFound };
                             return error.CacheCheckFailed;
                         },
-                        error.Canceled => return error.Canceled,
+                        error.Canceled => |e| return e,
                         else => |e| {
                             self.diagnostic = .{ .manifest_create = e };
                             return error.CacheCheckFailed;
                         },
                     }
                 },
-                error.Canceled => return error.Canceled,
+                error.Canceled => |e| return e,
                 else => |e| {
                     self.diagnostic = .{ .manifest_create = e };
                     return error.CacheCheckFailed;
@@ -675,7 +675,7 @@ pub const Manifest = struct {
         var manifest_reader = self.manifest_file.?.reader(io, &tiny_buffer); // Reads positionally from zero.
         const limit: std.Io.Limit = .limited(manifest_file_size_max);
         const file_contents = manifest_reader.interface.allocRemaining(gpa, limit) catch |err| switch (err) {
-            error.OutOfMemory => return error.OutOfMemory,
+            error.OutOfMemory => |e| return e,
             error.StreamTooLong => return error.OutOfMemory,
             error.ReadFailed => {
                 self.diagnostic = .{ .manifest_read = manifest_reader.err.? };
@@ -767,7 +767,7 @@ pub const Manifest = struct {
                     // Every digest before this one has been populated successfully.
                     return .{ .miss = .{ .file_digests_populated = idx } };
                 },
-                error.Canceled => return error.Canceled,
+                error.Canceled => |e| return e,
                 else => |e| {
                     self.diagnostic = .{ .file_open = .{
                         .file_index = idx,
@@ -880,14 +880,14 @@ pub const Manifest = struct {
                 .read = true,
                 .truncate = true,
             }) catch |err| switch (err) {
-                error.Canceled => return error.Canceled,
+                error.Canceled => |e| return e,
                 else => return true,
             };
             defer file.close(io);
 
             // Save locally and also save globally (we still hold the global lock).
             const stat = file.stat(io) catch |err| switch (err) {
-                error.Canceled => return error.Canceled,
+                error.Canceled => |e| return e,
                 else => return true,
             };
             man.recent_problematic_timestamp = stat.mtime;

package/std/Build/Step/Compile.zig

@@ -611,10 +611,6 @@ pub fn addObjCopy(cs: *Compile, options: Step.ObjCopy.Options) *Step.ObjCopy {
     return b.addObjCopy(cs.getEmittedBin(), copy);
 }
 
-pub fn checkObject(compile: *Compile) *Step.CheckObject {
-    return Step.CheckObject.create(compile.step.owner, compile.getEmittedBin(), compile.rootModuleTarget().ofmt);
-}
-
 pub fn setLinkerScript(compile: *Compile, source: LazyPath) void {
     const b = compile.step.owner;
     compile.linker_script = source.dupe(b);
@@ -778,43 +774,46 @@ pub fn runPkgConfig(step: *Step, lib_name: []const u8) !PkgConfigResult {
         else => return err,
     };
 
-    var zig_cflags = std.array_list.Managed([]const u8).init(b.allocator);
-    defer zig_cflags.deinit();
-    var zig_libs = std.array_list.Managed([]const u8).init(b.allocator);
-    defer zig_libs.deinit();
+    var zig_cflags: std.ArrayList([]const u8) = .empty;
+    defer zig_cflags.deinit(b.allocator);
+    var zig_libs: std.ArrayList([]const u8) = .empty;
+    defer zig_libs.deinit(b.allocator);
 
     var arg_it = mem.tokenizeAny(u8, stdout, " \r\n\t");
     while (arg_it.next()) |arg| {
         if (mem.eql(u8, arg, "-I")) {
             const dir = arg_it.next() orelse return error.PkgConfigInvalidOutput;
-            try zig_cflags.appendSlice(&[_][]const u8{ "-I", dir });
+            try zig_cflags.appendSlice(b.allocator, &.{ "-I", dir });
         } else if (mem.startsWith(u8, arg, "-I")) {
-            try zig_cflags.append(arg);
+            try zig_cflags.append(b.allocator, arg);
         } else if (mem.eql(u8, arg, "-L")) {
             const dir = arg_it.next() orelse return error.PkgConfigInvalidOutput;
-            try zig_libs.appendSlice(&[_][]const u8{ "-L", dir });
+            try zig_libs.appendSlice(b.allocator, &.{ "-L", dir });
         } else if (mem.startsWith(u8, arg, "-L")) {
-            try zig_libs.append(arg);
+            try zig_libs.append(b.allocator, arg);
         } else if (mem.eql(u8, arg, "-l")) {
             const lib = arg_it.next() orelse return error.PkgConfigInvalidOutput;
-            try zig_libs.appendSlice(&[_][]const u8{ "-l", lib });
+            try zig_libs.appendSlice(b.allocator, &.{ "-l", lib });
         } else if (mem.startsWith(u8, arg, "-l")) {
-            try zig_libs.append(arg);
+            try zig_libs.append(b.allocator, arg);
         } else if (mem.eql(u8, arg, "-D")) {
             const macro = arg_it.next() orelse return error.PkgConfigInvalidOutput;
-            try zig_cflags.appendSlice(&[_][]const u8{ "-D", macro });
+            try zig_cflags.appendSlice(b.allocator, &.{ "-D", macro });
         } else if (mem.startsWith(u8, arg, "-D")) {
-            try zig_cflags.append(arg);
+            try zig_cflags.append(b.allocator, arg);
         } else if (mem.startsWith(u8, arg, wl_rpath_prefix)) {
-            try zig_cflags.appendSlice(&[_][]const u8{ "-rpath", arg[wl_rpath_prefix.len..] });
+            try zig_cflags.appendSlice(b.allocator, &.{ "-rpath", arg[wl_rpath_prefix.len..] });
         } else if (b.debug_pkg_config) {
             return step.fail("unknown pkg-config flag '{s}'", .{arg});
         }
     }
 
+    try zig_cflags.shrinkToLen(b.allocator);
+    try zig_libs.shrinkToLen(b.allocator);
+
     return .{
-        .cflags = try zig_cflags.toOwnedSlice(),
-        .libs = try zig_libs.toOwnedSlice(),
+        .cflags = zig_cflags.toOwnedSliceAssert(),
+        .libs = zig_libs.toOwnedSliceAssert(),
     };
 }
 
@@ -1393,7 +1392,6 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {
         try zig_args.append("--debug-incremental");
     }
 
-    if (b.verbose_cimport) try zig_args.append("--verbose-cimport");
     if (b.verbose_air) try zig_args.append("--verbose-air");
     if (b.verbose_llvm_ir) |path| try zig_args.append(b.fmt("--verbose-llvm-ir={s}", .{path}));
     if (b.verbose_llvm_bc) |path| try zig_args.append(b.fmt("--verbose-llvm-bc={s}", .{path}));

package/std/Build/Step/ConfigHeader.zig

@@ -290,7 +290,7 @@ fn render_autoconf_undef(
     const build = step.owner;
     const allocator = build.allocator;
 
-    var is_used: std.DynamicBitSetUnmanaged = try .initEmpty(allocator, values.count());
+    var is_used: std.bit_set.Dynamic = try .initEmpty(allocator, values.count());
     defer is_used.deinit(allocator);
 
     var any_errors = false;

package/std/Build/Step/Run.zig

@@ -2166,11 +2166,15 @@ const FuzzTestRunner = struct {
                 const result = completion.result;
                 switch (completion.index % 3) {
                     0 => try f.completeStdinWrite(id, result.file_write_streaming catch |e| switch (e) {
-                        error.BrokenPipe => return f.instanceEos(id),
+                        // Avoid calling `instanceEos` until EndOfStream is seen with stderr so
+                        // that all stderr is collected.
+                        error.BrokenPipe => continue,
                         else => |write_e| return write_e,
                     }),
                     1 => try f.completeStdoutRead(id, result.file_read_streaming catch |e| switch (e) {
-                        error.EndOfStream => return f.instanceEos(id),
+                        // Avoid calling `instanceEos` until EndOfStream is seen with stderr so
+                        // that all stderr is collected.
+                        error.EndOfStream => continue,
                         else => |read_e| return read_e,
                     }),
                     2 => try f.completeStderrRead(id, result.file_read_streaming catch |e| switch (e) {
@@ -2360,7 +2364,10 @@ const FuzzTestRunner = struct {
         var in_name_buf: [12]u8 = undefined;
         var in_name: []const u8 = undefined;
         var i: u32 = 0;
-        const header: InputHeader = while (true) {
+        const header: InputHeader = while (true) : ({
+            if (i == std.math.maxInt(u32)) return;
+            i += 1;
+        }) {
             const name_prefix = "f" ++ Io.Dir.path.sep_str ++ "in";
             in_name = std.fmt.bufPrint(&in_name_buf, name_prefix ++ "{x}", .{i}) catch unreachable;
             in_f = b.cache_root.handle.openFile(io, in_name, .{
@@ -2394,8 +2401,6 @@ const FuzzTestRunner = struct {
             }
 
             in_f.close(io);
-            if (i == std.math.maxInt(u32)) return;
-            i += 1;
         };
         defer in_f.close(io);
 
@@ -2479,7 +2484,7 @@ const FuzzTestRunner = struct {
         const step_owner = f.run.step.owner;
         const arena = step_owner.allocator;
 
-        // Collect any remaining stderr
+        // Collect any available stderr
         while (f.batch.next()) |completion| {
             if (completion.index % 3 != 2) continue;
             const len = completion.result.file_read_streaming catch continue;
@@ -2699,12 +2704,14 @@ fn evalGeneric(run: *Run, spawn_options: process.SpawnOptions) !EvalGenericResul
 
             try multi_reader.checkAnyError();
 
+            // TODO: this string can leak since alloc below can return error.
             stdout_bytes = try multi_reader.toOwnedSlice(0);
+            // TODO: this string can leak since its allocated using gpa and `try child.wait(io)` below can fail.
             stderr_bytes = try multi_reader.toOwnedSlice(1);
         } else {
             var stdout_reader = stdout.readerStreaming(io, &.{});
             stdout_bytes = stdout_reader.interface.allocRemaining(arena, run.stdio_limit) catch |err| switch (err) {
-                error.OutOfMemory => return error.OutOfMemory,
+                error.OutOfMemory => |e| return e,
                 error.ReadFailed => return stdout_reader.err.?,
                 error.StreamTooLong => return error.StdoutStreamTooLong,
             };
@@ -2712,7 +2719,7 @@ fn evalGeneric(run: *Run, spawn_options: process.SpawnOptions) !EvalGenericResul
     } else if (child.stderr) |stderr| {
         var stderr_reader = stderr.readerStreaming(io, &.{});
         stderr_bytes = stderr_reader.interface.allocRemaining(arena, run.stdio_limit) catch |err| switch (err) {
-            error.OutOfMemory => return error.OutOfMemory,
+            error.OutOfMemory => |e| return e,
             error.ReadFailed => return stderr_reader.err.?,
             error.StreamTooLong => return error.StderrStreamTooLong,
         };

package/std/Build/Step.zig

@@ -176,7 +176,6 @@ pub const Id = enum {
             .update_source_files => UpdateSourceFiles,
             .run => Run,
             .check_file => CheckFile,
-            .check_object => CheckObject,
             .config_header => ConfigHeader,
             .objcopy => ObjCopy,
             .options => Options,
@@ -186,7 +185,6 @@ pub const Id = enum {
 };
 
 pub const CheckFile = @import("Step/CheckFile.zig");
-pub const CheckObject = @import("Step/CheckObject.zig");
 pub const ConfigHeader = @import("Step/ConfigHeader.zig");
 pub const Fail = @import("Step/Fail.zig");
 pub const Fmt = @import("Step/Fmt.zig");
@@ -282,8 +280,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;
@@ -845,8 +842,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", .{}),
     }
 }
@@ -985,6 +981,7 @@ pub fn reset(step: *Step, gpa: Allocator) void {
     step.result_peak_rss = 0;
     step.result_failed_command = null;
     step.test_results = .{};
+    step.clearWatchInputs();
 
     step.result_error_bundle.deinit(gpa);
     step.result_error_bundle = std.zig.ErrorBundle.empty;
@@ -1006,7 +1003,6 @@ pub fn invalidateResult(step: *Step, gpa: Allocator) bool {
 
 test {
     _ = CheckFile;
-    _ = CheckObject;
     _ = Fail;
     _ = Fmt;
     _ = InstallArtifact;

package/std/Build/Watch/FsEvents.zig

@@ -195,7 +195,7 @@ pub fn setPaths(fse: *FsEvents, gpa: Allocator, steps: []const *std.Build.Step)
     } else {
         fse.watch_roots = try gpa.realloc(fse.watch_roots, need_dirs.count());
         for (fse.watch_roots, need_dirs.keys()) |*out, in| {
-            out.* = try paths_arena.dupeZ(u8, in);
+            out.* = try paths_arena.dupeSentinel(u8, in, 0);
         }
     }
     if (enable_debug_logs) {

package/std/Build/WebServer.zig

@@ -622,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();

package/std/Build/abi.zig

@@ -266,7 +266,7 @@ pub const fuzz = struct {
                 .comptime_int => x,
                 .bool => @intFromBool(x),
                 .@"enum" => @intFromEnum(x),
-                else => @as(std.meta.Int(.unsigned, @bitSizeOf(T)), @bitCast(x)),
+                else => @as(@Int(.unsigned, @bitSizeOf(T)), @bitCast(x)),
 
                 .int => |i| x: {
                     comptime {

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,
@@ -278,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,
@@ -377,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,

package/std/Io/Dir.zig

@@ -944,7 +944,7 @@ pub const RealPathFileAllocError = RealPathFileError || Allocator.Error;
 pub fn realPathFileAlloc(dir: Dir, io: Io, sub_path: []const u8, allocator: Allocator) RealPathFileAllocError![:0]u8 {
     var buffer: [max_path_bytes]u8 = undefined;
     const n = try realPathFile(dir, io, sub_path, &buffer);
-    return allocator.dupeZ(u8, buffer[0..n]);
+    return allocator.dupeSentinel(u8, buffer[0..n], 0);
 }
 
 /// Same as `realPathFile` except `absolute_path` is asserted to be an absolute
@@ -974,7 +974,7 @@ pub fn realPathFileAbsolute(io: Io, absolute_path: []const u8, out_buffer: []u8)
 pub fn realPathFileAbsoluteAlloc(io: Io, absolute_path: []const u8, allocator: Allocator) RealPathFileAllocError![:0]u8 {
     var buffer: [max_path_bytes]u8 = undefined;
     const n = try realPathFileAbsolute(io, absolute_path, &buffer);
-    return allocator.dupeZ(u8, buffer[0..n]);
+    return allocator.dupeSentinel(u8, buffer[0..n], 0);
 }
 
 pub const DeleteFileError = error{
@@ -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) {
@@ -2466,7 +2468,7 @@ fn dirCreateFile(
     userdata: ?*anyopaque,
     dir: Dir,
     sub_path: []const u8,
-    flags: File.CreateFlags,
+    flags: Dir.CreateFileOptions,
 ) File.OpenError!File {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
     _ = ev;
@@ -2599,7 +2601,7 @@ fn dirOpenFile(
     userdata: ?*anyopaque,
     dir: Dir,
     sub_path: []const u8,
-    flags: File.OpenFlags,
+    flags: Dir.OpenFileOptions,
 ) File.OpenError!File {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
 
@@ -3934,7 +3936,7 @@ fn fileMemoryMapWrite(userdata: ?*anyopaque, mm: *File.MemoryMap) File.WritePosi
 
 fn processExecutableOpen(
     userdata: ?*anyopaque,
-    flags: File.OpenFlags,
+    flags: Dir.OpenFileOptions,
 ) process.OpenExecutableError!File {
     const ev: *Evented = @ptrCast(@alignCast(userdata));
     // _NSGetExecutablePath() returns a path that might be a symlink to
@@ -4084,7 +4086,7 @@ fn processReplace(userdata: ?*anyopaque, options: process.ReplaceOptions) proces
     const arena = arena_allocator.allocator();
 
     const argv_buf = try arena.allocSentinel(?[*:0]const u8, options.argv.len, null);
-    for (options.argv, 0..) |arg, i| argv_buf[i] = (try arena.dupeZ(u8, arg)).ptr;
+    for (options.argv, 0..) |arg, i| argv_buf[i] = (try arena.dupeSentinel(u8, arg, 0)).ptr;
 
     const env_block = env_block: {
         const prog_fd: i32 = -1;
@@ -4220,7 +4222,7 @@ fn spawn(ev: *Evented, options: process.SpawnOptions) process.SpawnError!Spawned
     // Therefore, we do all the allocation for the execve() before the fork().
     // This means we must do the null-termination of argv and env vars here.
     const argv_buf = try arena.allocSentinel(?[*:0]const u8, options.argv.len, null);
-    for (options.argv, 0..) |arg, i| argv_buf[i] = (try arena.dupeZ(u8, arg)).ptr;
+    for (options.argv, 0..) |arg, i| argv_buf[i] = (try arena.dupeSentinel(u8, arg, 0)).ptr;
 
     const env_block = env_block: {
         const prog_fd: i32 = if (prog_pipe[1] == -1) -1 else prog_fileno;
@@ -4877,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/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

@@ -142,21 +142,12 @@ pub fn stat(file: File, io: Io) StatError!Stat {
     return io.vtable.fileStat(io.userdata, file);
 }
 
-/// Deprecated, renamed to `Dir.OpenFileOptions.Mode`.
-pub const OpenMode = Dir.OpenFileOptions.Mode;
-
 pub const Lock = enum {
     none,
     shared,
     exclusive,
 };
 
-/// Deprecated, renamed to `Dir.OpenFileOptions`
-pub const OpenFlags = Dir.OpenFileOptions;
-
-/// Deprecated, renamed to `Dir.CreateFileOptions`.
-pub const CreateFlags = Dir.CreateFileOptions;
-
 pub const OpenError = error{
     PipeBusy,
     NoDevice,

package/std/Io/Kqueue.zig

@@ -79,7 +79,7 @@ const Fiber = struct {
     awaiter: ?*Fiber,
     queue_next: ?*Fiber,
     cancel_thread: ?*Thread,
-    awaiting_completions: std.StaticBitSet(3),
+    awaiting_completions: std.bit_set.Static(3),
 
     const finished: ?*Fiber = @ptrFromInt(@alignOf(Thread));
 
@@ -877,7 +877,7 @@ fn dirAccess(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, options: Dir
     _ = options;
     @panic("TODO");
 }
-fn dirCreateFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, flags: File.CreateFlags) File.OpenError!File {
+fn dirCreateFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, flags: Dir.CreateFileOptions) File.OpenError!File {
     const k: *Kqueue = @ptrCast(@alignCast(userdata));
     _ = k;
     _ = dir;
@@ -885,7 +885,7 @@ fn dirCreateFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, flags: F
     _ = flags;
     @panic("TODO");
 }
-fn dirOpenFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, flags: File.OpenFlags) File.OpenError!File {
+fn dirOpenFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, flags: Dir.OpenFileOptions) File.OpenError!File {
     const k: *Kqueue = @ptrCast(@alignCast(userdata));
     _ = k;
     _ = dir;

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| {
@@ -2098,7 +2097,6 @@ test "deserialize signed LEB128" {
     try testing.expectEqual(std.math.minInt(i128), testLeb128(i128, "\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x7E"));
 
     // Specific cases
-    try testing.expectEqual(0, testLeb128(i0, "\x00"));
     try testing.expectEqual(0, testLeb128(i2, "\x00"));
     try testing.expectEqual(0, testLeb128(i8, "\x00"));
 
@@ -2135,8 +2133,6 @@ test "deserialize signed LEB128" {
     try testing.expectError(error.EndOfStream, testLeb128(i128, &end_of_stream));
 
     // Overflow
-    try testing.expectError(error.Overflow, testLeb128(i0, "\x01"));
-    try testing.expectError(error.Overflow, testLeb128(i0, "\x7F"));
     try testing.expectError(error.Overflow, testLeb128(i8, "\x80\x01"));
     try testing.expectError(error.Overflow, testLeb128(i8, "\xFF\x7E"));
     try testing.expectError(error.Overflow, testLeb128(i8, "\x80\x80\x40"));
@@ -2146,7 +2142,6 @@ test "deserialize signed LEB128" {
     try testing.expectError(error.Overflow, testLeb128(i64, "\x80\x80\x80\x80\x80\x80\x80\x80\x80\x01"));
     try testing.expectError(error.Overflow, testLeb128(i64, "\x80\x80\x80\x80\x80\x80\x80\x80\x80\x40"));
 
-    try testing.expectError(error.Overflow, testLeb128(i0, &overflow));
     try testing.expectError(error.Overflow, testLeb128(i7, &overflow));
     try testing.expectError(error.Overflow, testLeb128(i8, &overflow));
     try testing.expectError(error.Overflow, testLeb128(i14, &overflow));
@@ -2160,7 +2155,6 @@ test "deserialize signed LEB128" {
     try testing.expectEqual(0x80, testLeb128(i64, "\x80\x81\x00"));
     try testing.expectEqual(0x80, testLeb128(i64, "\x80\x81\x80\x00"));
 
-    try testing.expectEqual(0, testLeb128(i0, &long_zero));
     try testing.expectEqual(0, testLeb128(i7, &long_zero));
     try testing.expectEqual(0, testLeb128(i8, &long_zero));
     try testing.expectEqual(0, testLeb128(i14, &long_zero));