@zigc/lib 0.16.0-dev.3128 → 0.16.0-dev.3133

package/compiler/aro/backend/Ir/x86/Renderer.zig

@@ -21,17 +21,17 @@ const RegisterManager = zig.RegisterManager(Renderer, Register, Ir.Ref, abi.allo
 const RegisterBitSet = RegisterManager.RegisterBitSet;
 const RegisterClass = struct {
     const gp: RegisterBitSet = blk: {
-        var set = RegisterBitSet.initEmpty();
+        var set = RegisterBitSet.empty;
         for (abi.allocatable_regs, 0..) |reg, index| if (reg.class() == .general_purpose) set.set(index);
         break :blk set;
     };
     const x87: RegisterBitSet = blk: {
-        var set = RegisterBitSet.initEmpty();
+        var set = RegisterBitSet.empty;
         for (abi.allocatable_regs, 0..) |reg, index| if (reg.class() == .x87) set.set(index);
         break :blk set;
     };
     const sse: RegisterBitSet = blk: {
-        var set = RegisterBitSet.initEmpty();
+        var set = RegisterBitSet.empty;
         for (abi.allocatable_regs, 0..) |reg, index| if (reg.class() == .sse) set.set(index);
         break :blk set;
     };

package/compiler/resinator/compile.zig

@@ -2746,7 +2746,7 @@ pub const Compiler = struct {
         // 1. Any permutation that does not have PRELOAD in it just uses the
         //    default flags.
         const initial_flags = flags.*;
-        var flags_set = std.enums.EnumSet(rc.CommonResourceAttributes).initEmpty();
+        var flags_set = std.enums.EnumSet(rc.CommonResourceAttributes).empty;
         for (tokens) |token| {
             const attribute = rc.CommonResourceAttributes.map.get(token.slice(source)).?;
             flags_set.insert(attribute);
@@ -2769,7 +2769,7 @@ pub const Compiler = struct {
         // 3. If none of DISCARDABLE, SHARED, or PURE is specified, then PRELOAD
         //    implies `flags &= ~SHARED` and LOADONCALL implies `flags |= SHARED`
         const shared_set = comptime blk: {
-            var set = std.enums.EnumSet(rc.CommonResourceAttributes).initEmpty();
+            var set = std.enums.EnumSet(rc.CommonResourceAttributes).empty;
             set.insert(.discardable);
             set.insert(.shared);
             set.insert(.pure);

package/package.json

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

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/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.zig

@@ -500,8 +500,8 @@ pub const Batch = struct {
     /// Returns the index that will be returned by `next` after the operation completes.
     /// Asserts that no more than `storage.len` operations are active at a time.
     pub fn add(batch: *Batch, operation: Operation) u32 {
-        const index = batch.unused.next;
-        batch.addAt(index.toIndex(), operation);
+        const index = batch.unused.head.toIndex();
+        batch.addAt(index, operation);
         return index;
     }
 
@@ -2491,3 +2491,964 @@ test {
     _ = Semaphore;
     _ = @import("Io/test.zig");
 }
+
+/// An implementation of `Io` which simulates a system supporting no `Io` operations.
+///
+/// This system has the following properties:
+/// * Concurrency is unavailable.
+/// * The stdio handles are pipes whose remote ends are already closed.
+/// * The filesystem is entirely empty, including that the cwd is no longer present.
+/// * The filesystem is full, so attempting to create entries always returns `error.NoSpaceLeft`.
+/// * No entropy source is supported, so `randomSecure` always returns `error.EntropyUnavailable`, and `random` always returns (fills the buffer) with 0.
+/// * No clocks are supported, so `now` and `sleep` always return `error.UnsupportedClock`.
+/// * No network is connected, so network operations always return `error.NetworkDown`.
+pub const failing: std.Io = .{
+    .userdata = null,
+    .vtable = &.{
+        .crashHandler = noCrashHandler,
+
+        .async = noAsync,
+        .concurrent = failingConcurrent,
+        .await = unreachableAwait,
+        .cancel = unreachableCancel,
+
+        .groupAsync = noGroupAsync,
+        .groupConcurrent = failingGroupConcurrent,
+        .groupAwait = unreachableGroupAwait,
+        .groupCancel = unreachableGroupCancel,
+
+        .recancel = unreachableRecancel,
+        .swapCancelProtection = unreachableSwapCancelProtection,
+        .checkCancel = unreachableCheckCancel,
+
+        .futexWait = noFutexWait,
+        .futexWaitUncancelable = noFutexWaitUncancelable,
+        .futexWake = noFutexWake,
+
+        .operate = failingOperate,
+        .batchAwaitAsync = unreachableBatchAwaitAsync,
+        .batchAwaitConcurrent = unreachableBatchAwaitConcurrent,
+        .batchCancel = unreachableBatchCancel,
+
+        .dirCreateDir = failingDirCreateDir,
+        .dirCreateDirPath = failingDirCreateDirPath,
+        .dirCreateDirPathOpen = failingDirCreateDirPathOpen,
+        .dirOpenDir = failingDirOpenDir,
+        .dirStat = failingDirStat,
+        .dirStatFile = failingDirStatFile,
+        .dirAccess = failingDirAccess,
+        .dirCreateFile = failingDirCreateFile,
+        .dirCreateFileAtomic = failingDirCreateFileAtomic,
+        .dirOpenFile = failingDirOpenFile,
+        .dirClose = unreachableDirClose,
+        .dirRead = noDirRead,
+        .dirRealPath = failingDirRealPath,
+        .dirRealPathFile = failingDirRealPathFile,
+        .dirDeleteFile = failingDirDeleteFile,
+        .dirDeleteDir = failingDirDeleteDir,
+        .dirRename = failingDirRename,
+        .dirRenamePreserve = failingDirRenamePreserve,
+        .dirSymLink = failingDirSymLink,
+        .dirReadLink = failingDirReadLink,
+        .dirSetOwner = failingDirSetOwner,
+        .dirSetFileOwner = failingDirSetFileOwner,
+        .dirSetPermissions = failingDirSetPermissions,
+        .dirSetFilePermissions = failingDirSetFilePermissions,
+        .dirSetTimestamps = noDirSetTimestamps,
+        .dirHardLink = failingDirHardLink,
+
+        .fileStat = failingFileStat,
+        .fileLength = failingFileLength,
+        .fileClose = unreachableFileClose,
+        .fileWritePositional = failingFileWritePositional,
+        .fileWriteFileStreaming = noFileWriteFileStreaming,
+        .fileWriteFilePositional = noFileWriteFilePositional,
+        .fileReadPositional = failingFileReadPositional,
+        .fileSeekBy = failingFileSeekBy,
+        .fileSeekTo = failingFileSeekTo,
+        .fileSync = failingFileSync,
+        .fileIsTty = unreachableFileIsTty,
+        .fileEnableAnsiEscapeCodes = unreachableFileEnableAnsiEscapeCodes,
+        .fileSupportsAnsiEscapeCodes = unreachableFileSupportsAnsiEscapeCodes,
+        .fileSetLength = failingFileSetLength,
+        .fileSetOwner = failingFileSetOwner,
+        .fileSetPermissions = failingFileSetPermissions,
+        .fileSetTimestamps = noFileSetTimestamps,
+        .fileLock = failingFileLock,
+        .fileTryLock = failingFileTryLock,
+        .fileUnlock = unreachableFileUnlock,
+        .fileDowngradeLock = failingFileDowngradeLock,
+        .fileRealPath = failingFileRealPath,
+        .fileHardLink = failingFileHardLink,
+
+        .fileMemoryMapCreate = failingFileMemoryMapCreate,
+        .fileMemoryMapDestroy = unreachableFileMemoryMapDestroy,
+        .fileMemoryMapSetLength = unreachableFileMemoryMapSetLength,
+        .fileMemoryMapRead = unreachableFileMemoryMapRead,
+        .fileMemoryMapWrite = unreachableFileMemoryMapWrite,
+
+        .processExecutableOpen = failingProcessExecutableOpen,
+        .processExecutablePath = failingProcessExecutablePath,
+        .lockStderr = unreachableLockStderr,
+        .tryLockStderr = noTryLockStderr,
+        .unlockStderr = unreachableUnlockStderr,
+        .processCurrentPath = failingProcessCurrentPath,
+        .processSetCurrentDir = failingProcessSetCurrentDir,
+        .processSetCurrentPath = failingProcessSetCurrentPath,
+        .processReplace = failingProcessReplace,
+        .processReplacePath = failingProcessReplacePath,
+        .processSpawn = failingProcessSpawn,
+        .processSpawnPath = failingProcessSpawnPath,
+        .childWait = unreachableChildWait,
+        .childKill = unreachableChildKill,
+
+        .progressParentFile = failingProgressParentFile,
+
+        .random = noRandom,
+        .randomSecure = failingRandomSecure,
+
+        .now = noNow,
+        .clockResolution = failingClockResolution,
+        .sleep = noSleep,
+
+        .netListenIp = failingNetListenIp,
+        .netAccept = failingNetAccept,
+        .netBindIp = failingNetBindIp,
+        .netConnectIp = failingNetConnectIp,
+        .netListenUnix = failingNetListenUnix,
+        .netConnectUnix = failingNetConnectUnix,
+        .netSocketCreatePair = failingNetSocketCreatePair,
+        .netSend = failingNetSend,
+        .netRead = failingNetRead,
+        .netWrite = failingNetWrite,
+        .netWriteFile = failingNetWriteFile,
+        .netClose = unreachableNetClose,
+        .netShutdown = failingNetShutdown,
+        .netInterfaceNameResolve = failingNetInterfaceNameResolve,
+        .netInterfaceName = unreachableNetInterfaceName,
+        .netLookup = failingNetLookup,
+    },
+};
+
+pub fn noCrashHandler(userdata: ?*anyopaque) void {
+    _ = userdata;
+}
+
+pub fn noAsync(userdata: ?*anyopaque, result: []u8, result_alignment: std.mem.Alignment, context: []const u8, context_alignment: std.mem.Alignment, start: *const fn (context: *const anyopaque, result: *anyopaque) void) ?*AnyFuture {
+    _ = userdata;
+    _ = result_alignment;
+    _ = context_alignment;
+    start(context.ptr, result.ptr);
+    return null;
+}
+
+pub fn failingConcurrent(
+    userdata: ?*anyopaque,
+    result_len: usize,
+    result_alignment: std.mem.Alignment,
+    context: []const u8,
+    context_alignment: std.mem.Alignment,
+    start: *const fn (context: *const anyopaque, result: *anyopaque) void,
+) ConcurrentError!*AnyFuture {
+    _ = userdata;
+    _ = result_len;
+    _ = result_alignment;
+    _ = context;
+    _ = context_alignment;
+    _ = start;
+    return error.ConcurrencyUnavailable;
+}
+
+pub fn unreachableAwait(
+    userdata: ?*anyopaque,
+    any_future: *AnyFuture,
+    result: []u8,
+    result_alignment: std.mem.Alignment,
+) void {
+    _ = userdata;
+    _ = any_future;
+    _ = result;
+    _ = result_alignment;
+    unreachable;
+}
+
+pub fn unreachableCancel(
+    userdata: ?*anyopaque,
+    any_future: *AnyFuture,
+    result: []u8,
+    result_alignment: std.mem.Alignment,
+) void {
+    _ = userdata;
+    _ = any_future;
+    _ = result;
+    _ = result_alignment;
+    unreachable;
+}
+
+pub fn noGroupAsync(
+    userdata: ?*anyopaque,
+    group: *Group,
+    context: []const u8,
+    context_alignment: std.mem.Alignment,
+    start: *const fn (context: *const anyopaque) void,
+) void {
+    _ = userdata;
+    _ = group;
+    _ = context_alignment;
+    start(context.ptr);
+}
+
+pub fn failingGroupConcurrent(
+    userdata: ?*anyopaque,
+    group: *Group,
+    context: []const u8,
+    context_alignment: std.mem.Alignment,
+    start: *const fn (context: *const anyopaque) void,
+) ConcurrentError!void {
+    _ = userdata;
+    _ = group;
+    _ = context;
+    _ = context_alignment;
+    _ = start;
+    return error.ConcurrencyUnavailable;
+}
+
+pub fn unreachableGroupAwait(userdata: ?*anyopaque, group: *Group, token: *anyopaque) Cancelable!void {
+    _ = userdata;
+    _ = group;
+    _ = token;
+    unreachable;
+}
+
+pub fn unreachableGroupCancel(userdata: ?*anyopaque, group: *Group, token: *anyopaque) void {
+    _ = userdata;
+    _ = group;
+    _ = token;
+    unreachable;
+}
+
+pub fn unreachableRecancel(userdata: ?*anyopaque) void {
+    _ = userdata;
+    unreachable;
+}
+
+pub fn unreachableSwapCancelProtection(userdata: ?*anyopaque, new: CancelProtection) CancelProtection {
+    _ = userdata;
+    _ = new;
+    unreachable;
+}
+
+pub fn unreachableCheckCancel(userdata: ?*anyopaque) Cancelable!void {
+    _ = userdata;
+    unreachable;
+}
+
+pub fn noFutexWait(userdata: ?*anyopaque, ptr: *const u32, expected: u32, timeout: Timeout) Cancelable!void {
+    _ = userdata;
+    std.debug.assert(ptr.* == expected or timeout != .none);
+}
+
+pub fn noFutexWaitUncancelable(userdata: ?*anyopaque, ptr: *const u32, expected: u32) void {
+    _ = userdata;
+    std.debug.assert(ptr.* == expected);
+}
+
+pub fn noFutexWake(userdata: ?*anyopaque, ptr: *const u32, max_waiters: u32) void {
+    _ = userdata;
+    _ = ptr;
+    _ = max_waiters;
+    // no-op
+}
+
+pub fn failingOperate(userdata: ?*anyopaque, operation: Operation) Cancelable!Operation.Result {
+    _ = userdata;
+    return switch (operation) {
+        .file_read_streaming => .{ .file_read_streaming = error.InputOutput },
+        .file_write_streaming => .{ .file_write_streaming = error.InputOutput },
+        .device_io_control => unreachable,
+        .net_receive => .{ .net_receive = .{ error.NetworkDown, 0 } },
+    };
+}
+
+pub fn unreachableBatchAwaitAsync(userdata: ?*anyopaque, b: *Batch) Cancelable!void {
+    _ = userdata;
+    _ = b;
+    unreachable;
+}
+
+pub fn unreachableBatchAwaitConcurrent(userdata: ?*anyopaque, b: *Batch, timeout: Timeout) Batch.AwaitConcurrentError!void {
+    _ = userdata;
+    _ = b;
+    _ = timeout;
+    unreachable;
+}
+
+pub fn unreachableBatchCancel(userdata: ?*anyopaque, b: *Batch) void {
+    _ = userdata;
+    _ = b;
+    unreachable;
+}
+
+pub fn failingDirCreateDir(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, permissions: Dir.Permissions) Dir.CreateDirError!void {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = permissions;
+    return error.NoSpaceLeft;
+}
+
+pub fn failingDirCreateDirPath(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, permissions: Dir.Permissions) Dir.CreateDirPathError!Dir.CreatePathStatus {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = permissions;
+    return error.NoSpaceLeft;
+}
+
+pub fn failingDirCreateDirPathOpen(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, permissions: Dir.Permissions, options: Dir.OpenOptions) Dir.CreateDirPathOpenError!Dir {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = permissions;
+    _ = options;
+    return error.NoSpaceLeft;
+}
+
+pub fn failingDirOpenDir(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, options: Dir.OpenOptions) Dir.OpenError!Dir {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = options;
+    return error.FileNotFound;
+}
+
+pub fn failingDirStat(userdata: ?*anyopaque, dir: Dir) Dir.StatError!Dir.Stat {
+    _ = userdata;
+    _ = dir;
+    return error.Streaming;
+}
+
+pub fn failingDirStatFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, options: Dir.StatFileOptions) Dir.StatFileError!File.Stat {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = options;
+    return error.FileNotFound;
+}
+
+pub fn failingDirAccess(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, options: Dir.AccessOptions) Dir.AccessError!void {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = options;
+    return error.FileNotFound;
+}
+
+pub fn failingDirCreateFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, options: File.CreateFlags) File.OpenError!File {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = options;
+    return error.NoSpaceLeft;
+}
+
+pub fn failingDirCreateFileAtomic(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, options: Dir.CreateFileAtomicOptions) Dir.CreateFileAtomicError!File.Atomic {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = options;
+    return error.NoSpaceLeft;
+}
+
+pub fn failingDirOpenFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, flags: File.OpenFlags) File.OpenError!File {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = flags;
+    return error.FileNotFound;
+}
+
+pub fn unreachableDirClose(userdata: ?*anyopaque, dirs: []const Dir) void {
+    _ = userdata;
+    _ = dirs;
+    unreachable;
+}
+
+pub fn noDirRead(userdata: ?*anyopaque, dir_reader: *Dir.Reader, buffer: []Dir.Entry) Dir.Reader.Error!usize {
+    _ = userdata;
+    _ = dir_reader;
+    _ = buffer;
+    return 0;
+}
+
+pub fn failingDirRealPath(userdata: ?*anyopaque, dir: Dir, out_buffer: []u8) Dir.RealPathError!usize {
+    _ = userdata;
+    _ = dir;
+    _ = out_buffer;
+    return error.FileNotFound;
+}
+
+pub fn failingDirRealPathFile(userdata: ?*anyopaque, dir: Dir, path_name: []const u8, out_buffer: []u8) Dir.RealPathFileError!usize {
+    _ = userdata;
+    _ = dir;
+    _ = path_name;
+    _ = out_buffer;
+    return error.FileNotFound;
+}
+
+pub fn failingDirDeleteFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8) Dir.DeleteFileError!void {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    return error.FileNotFound;
+}
+
+pub fn failingDirDeleteDir(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8) Dir.DeleteDirError!void {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    return error.FileNotFound;
+}
+
+pub fn failingDirRename(userdata: ?*anyopaque, old_dir: Dir, old_sub_path: []const u8, new_dir: Dir, new_sub_path: []const u8) Dir.RenameError!void {
+    _ = userdata;
+    _ = old_dir;
+    _ = old_sub_path;
+    _ = new_dir;
+    _ = new_sub_path;
+    return error.FileNotFound;
+}
+
+pub fn failingDirRenamePreserve(userdata: ?*anyopaque, old_dir: Dir, old_sub_path: []const u8, new_dir: Dir, new_sub_path: []const u8) Dir.RenamePreserveError!void {
+    _ = userdata;
+    _ = old_dir;
+    _ = old_sub_path;
+    _ = new_dir;
+    _ = new_sub_path;
+    return error.FileNotFound;
+}
+
+pub fn failingDirSymLink(userdata: ?*anyopaque, dir: Dir, target_path: []const u8, sym_link_path: []const u8, flags: Dir.SymLinkFlags) Dir.SymLinkError!void {
+    _ = userdata;
+    _ = dir;
+    _ = target_path;
+    _ = sym_link_path;
+    _ = flags;
+    return error.FileNotFound;
+}
+
+pub fn failingDirReadLink(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, buffer: []u8) Dir.ReadLinkError!usize {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = buffer;
+    return error.FileNotFound;
+}
+
+pub fn failingDirSetOwner(userdata: ?*anyopaque, dir: Dir, owner: ?File.Uid, group: ?File.Gid) Dir.SetOwnerError!void {
+    _ = userdata;
+    _ = dir;
+    _ = owner;
+    _ = group;
+    return error.FileNotFound;
+}
+
+pub fn failingDirSetFileOwner(userdata: ?*anyopaque, dir: std.Io.Dir, sub_path: []const u8, owner: ?File.Uid, group: ?File.Gid, options: Dir.SetFileOwnerOptions) Dir.SetFileOwnerError!void {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = owner;
+    _ = group;
+    _ = options;
+    return error.FileNotFound;
+}
+
+pub fn failingDirSetPermissions(userdata: ?*anyopaque, dir: Dir, permissions: Dir.Permissions) Dir.SetPermissionsError!void {
+    _ = userdata;
+    _ = dir;
+    _ = permissions;
+    return error.FileNotFound;
+}
+
+pub fn failingDirSetFilePermissions(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, permissions: File.Permissions, options: Dir.SetFilePermissionsOptions) Dir.SetFilePermissionsError!void {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = permissions;
+    _ = options;
+    return error.FileNotFound;
+}
+
+pub fn noDirSetTimestamps(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, options: Dir.SetTimestampsOptions) Dir.SetTimestampsError!void {
+    _ = userdata;
+    _ = dir;
+    _ = sub_path;
+    _ = options;
+    // no-op
+}
+
+pub fn failingDirHardLink(userdata: ?*anyopaque, old_dir: Dir, old_sub_path: []const u8, new_dir: Dir, new_sub_path: []const u8, options: Dir.HardLinkOptions) Dir.HardLinkError!void {
+    _ = userdata;
+    _ = old_dir;
+    _ = old_sub_path;
+    _ = new_dir;
+    _ = new_sub_path;
+    _ = options;
+    return error.FileNotFound;
+}
+
+pub fn failingFileStat(userdata: ?*anyopaque, file: File) File.StatError!File.Stat {
+    _ = userdata;
+    _ = file;
+    return error.Streaming;
+}
+
+pub fn failingFileLength(userdata: ?*anyopaque, file: File) File.LengthError!u64 {
+    _ = userdata;
+    _ = file;
+    return error.Streaming;
+}
+
+pub fn unreachableFileClose(userdata: ?*anyopaque, files: []const File) void {
+    _ = userdata;
+    _ = files;
+    unreachable;
+}
+
+pub fn failingFileWritePositional(userdata: ?*anyopaque, file: File, header: []const u8, data: []const []const u8, splat: usize, offset: u64) File.WritePositionalError!usize {
+    _ = userdata;
+    _ = file;
+    _ = header;
+    _ = offset;
+    for (data[0 .. data.len - 1]) |item| {
+        if (item.len > 0) return error.BrokenPipe;
+    }
+    if (data[data.len - 1].len != 0 and splat != 0) return error.BrokenPipe;
+    return 0;
+}
+
+pub fn noFileWriteFileStreaming(userdata: ?*anyopaque, file: File, header: []const u8, file_reader: *Io.File.Reader, limit: Io.Limit) File.Writer.WriteFileError!usize {
+    _ = userdata;
+    _ = file;
+    _ = header;
+    _ = file_reader;
+    _ = limit;
+    return error.Unimplemented;
+}
+
+pub fn noFileWriteFilePositional(userdata: ?*anyopaque, file: File, header: []const u8, file_reader: *Io.File.Reader, limit: Io.Limit, offset: u64) File.WriteFilePositionalError!usize {
+    _ = userdata;
+    _ = file;
+    _ = header;
+    _ = file_reader;
+    _ = limit;
+    _ = offset;
+    return error.Unimplemented;
+}
+
+pub fn failingFileReadPositional(userdata: ?*anyopaque, file: File, data: []const []u8, offset: u64) File.ReadPositionalError!usize {
+    _ = userdata;
+    _ = file;
+    _ = offset;
+    for (data) |item| {
+        if (item.len > 0) return error.InputOutput;
+    }
+    return 0;
+}
+
+pub fn failingFileSeekBy(userdata: ?*anyopaque, file: File, relative_offset: i64) File.SeekError!void {
+    _ = userdata;
+    _ = file;
+    _ = relative_offset;
+    return error.Unseekable;
+}
+
+pub fn failingFileSeekTo(userdata: ?*anyopaque, file: File, absolute_offset: u64) File.SeekError!void {
+    _ = userdata;
+    _ = file;
+    _ = absolute_offset;
+    return error.Unseekable;
+}
+
+pub fn failingFileSync(userdata: ?*anyopaque, file: File) File.SyncError!void {
+    _ = userdata;
+    _ = file;
+    return error.NoSpaceLeft;
+}
+
+pub fn unreachableFileIsTty(userdata: ?*anyopaque, file: File) Cancelable!bool {
+    _ = userdata;
+    _ = file;
+    unreachable;
+}
+
+pub fn unreachableFileEnableAnsiEscapeCodes(userdata: ?*anyopaque, file: File) File.EnableAnsiEscapeCodesError!void {
+    _ = userdata;
+    _ = file;
+    unreachable;
+}
+
+pub fn unreachableFileSupportsAnsiEscapeCodes(userdata: ?*anyopaque, file: File) Cancelable!bool {
+    _ = userdata;
+    _ = file;
+    unreachable;
+}
+
+pub fn failingFileSetLength(userdata: ?*anyopaque, file: File, length: u64) File.SetLengthError!void {
+    _ = userdata;
+    _ = file;
+    _ = length;
+    return error.NonResizable;
+}
+
+pub fn failingFileSetOwner(userdata: ?*anyopaque, file: File, owner: ?File.Uid, group: ?File.Gid) File.SetOwnerError!void {
+    _ = userdata;
+    _ = file;
+    _ = owner;
+    _ = group;
+    return error.FileNotFound;
+}
+
+pub fn failingFileSetPermissions(userdata: ?*anyopaque, file: File, permissions: File.Permissions) File.SetPermissionsError!void {
+    _ = userdata;
+    _ = file;
+    _ = permissions;
+    return error.FileNotFound;
+}
+
+pub fn noFileSetTimestamps(userdata: ?*anyopaque, file: File, options: File.SetTimestampsOptions) File.SetTimestampsError!void {
+    _ = userdata;
+    _ = file;
+    _ = options;
+    // no-op
+}
+
+pub fn failingFileLock(userdata: ?*anyopaque, file: File, lock: File.Lock) File.LockError!void {
+    _ = userdata;
+    _ = file;
+    _ = lock;
+    return error.FileLocksUnsupported;
+}
+
+pub fn failingFileTryLock(userdata: ?*anyopaque, file: File, lock: File.Lock) File.LockError!bool {
+    _ = userdata;
+    _ = file;
+    _ = lock;
+    return error.FileLocksUnsupported;
+}
+
+pub fn unreachableFileUnlock(userdata: ?*anyopaque, file: File) void {
+    _ = userdata;
+    _ = file;
+    unreachable;
+}
+
+pub fn failingFileDowngradeLock(userdata: ?*anyopaque, file: File) File.DowngradeLockError!void {
+    _ = userdata;
+    _ = file;
+    // no-op
+}
+
+pub fn failingFileRealPath(userdata: ?*anyopaque, file: File, out_buffer: []u8) File.RealPathError!usize {
+    _ = userdata;
+    _ = file;
+    _ = out_buffer;
+    return error.FileNotFound;
+}
+
+pub fn failingFileHardLink(userdata: ?*anyopaque, file: File, new_dir: Dir, new_sub_path: []const u8, options: File.HardLinkOptions) File.HardLinkError!void {
+    _ = userdata;
+    _ = file;
+    _ = new_dir;
+    _ = new_sub_path;
+    _ = options;
+    return error.FileNotFound;
+}
+
+pub fn failingFileMemoryMapCreate(userdata: ?*anyopaque, file: File, options: File.MemoryMap.CreateOptions) File.MemoryMap.CreateError!File.MemoryMap {
+    _ = userdata;
+    _ = file;
+    _ = options;
+    return error.AccessDenied;
+}
+
+pub fn unreachableFileMemoryMapDestroy(userdata: ?*anyopaque, mm: *File.MemoryMap) void {
+    _ = userdata;
+    _ = mm;
+    unreachable;
+}
+
+pub fn unreachableFileMemoryMapSetLength(userdata: ?*anyopaque, mm: *File.MemoryMap, new_len: usize) File.MemoryMap.SetLengthError!void {
+    _ = userdata;
+    _ = mm;
+    _ = new_len;
+    unreachable;
+}
+
+pub fn unreachableFileMemoryMapRead(userdata: ?*anyopaque, mm: *File.MemoryMap) File.ReadPositionalError!void {
+    _ = userdata;
+    _ = mm;
+    unreachable;
+}
+
+pub fn unreachableFileMemoryMapWrite(userdata: ?*anyopaque, mm: *File.MemoryMap) File.WritePositionalError!void {
+    _ = userdata;
+    _ = mm;
+    unreachable;
+}
+
+pub fn failingProcessExecutableOpen(userdata: ?*anyopaque, flags: File.OpenFlags) std.process.OpenExecutableError!File {
+    _ = userdata;
+    _ = flags;
+    return error.FileNotFound;
+}
+
+pub fn failingProcessExecutablePath(userdata: ?*anyopaque, buffer: []u8) std.process.ExecutablePathError!usize {
+    _ = userdata;
+    _ = buffer;
+    return error.FileNotFound;
+}
+
+pub fn unreachableLockStderr(userdata: ?*anyopaque, terminal_mode: ?Terminal.Mode) Cancelable!LockedStderr {
+    _ = userdata;
+    _ = terminal_mode;
+    unreachable;
+}
+
+pub fn noTryLockStderr(userdata: ?*anyopaque, terminal_mode: ?Terminal.Mode) Cancelable!?LockedStderr {
+    _ = userdata;
+    _ = terminal_mode;
+    return null;
+}
+
+pub fn unreachableUnlockStderr(userdata: ?*anyopaque) void {
+    _ = userdata;
+    unreachable;
+}
+
+pub fn failingProcessCurrentPath(userdata: ?*anyopaque, buffer: []u8) std.process.CurrentPathError!usize {
+    _ = userdata;
+    _ = buffer;
+    return error.CurrentDirUnlinked;
+}
+
+pub fn failingProcessSetCurrentDir(userdata: ?*anyopaque, dir: Dir) std.process.SetCurrentDirError!void {
+    _ = userdata;
+    _ = dir;
+    return error.FileNotFound;
+}
+
+pub fn failingProcessSetCurrentPath(userdata: ?*anyopaque, path: []const u8) std.process.SetCurrentPathError!void {
+    _ = userdata;
+    _ = path;
+    return error.FileNotFound;
+}
+
+pub fn failingProcessReplace(userdata: ?*anyopaque, options: std.process.ReplaceOptions) std.process.ReplaceError {
+    _ = userdata;
+    _ = options;
+    return error.OperationUnsupported;
+}
+
+pub fn failingProcessReplacePath(userdata: ?*anyopaque, dir: Dir, options: std.process.ReplaceOptions) std.process.ReplaceError {
+    _ = userdata;
+    _ = dir;
+    _ = options;
+    return error.OperationUnsupported;
+}
+
+pub fn failingProcessSpawn(userdata: ?*anyopaque, options: std.process.SpawnOptions) std.process.SpawnError!std.process.Child {
+    _ = userdata;
+    _ = options;
+    return error.OperationUnsupported;
+}
+
+pub fn failingProcessSpawnPath(userdata: ?*anyopaque, dir: Dir, options: std.process.SpawnOptions) std.process.SpawnError!std.process.Child {
+    _ = userdata;
+    _ = dir;
+    _ = options;
+    return error.OperationUnsupported;
+}
+
+pub fn unreachableChildWait(userdata: ?*anyopaque, child: *std.process.Child) std.process.Child.WaitError!std.process.Child.Term {
+    _ = userdata;
+    _ = child;
+    unreachable;
+}
+
+pub fn unreachableChildKill(userdata: ?*anyopaque, child: *std.process.Child) void {
+    _ = userdata;
+    _ = child;
+    unreachable;
+}
+
+pub fn failingProgressParentFile(userdata: ?*anyopaque) std.Progress.ParentFileError!File {
+    _ = userdata;
+    return error.UnsupportedOperation;
+}
+
+pub fn noRandom(userdata: ?*anyopaque, buffer: []u8) void {
+    _ = userdata;
+    @memset(buffer, 0);
+}
+
+pub fn failingRandomSecure(userdata: ?*anyopaque, buffer: []u8) RandomSecureError!void {
+    _ = userdata;
+    _ = buffer;
+    return error.EntropyUnavailable;
+}
+
+pub fn noNow(userdata: ?*anyopaque, clock: Clock) Timestamp {
+    _ = userdata;
+    _ = clock;
+    return .zero;
+}
+
+pub fn failingClockResolution(userdata: ?*anyopaque, clock: Clock) Clock.ResolutionError!Duration {
+    _ = userdata;
+    _ = clock;
+    return error.ClockUnavailable;
+}
+
+pub fn noSleep(userdata: ?*anyopaque, clock: Timeout) Cancelable!void {
+    _ = userdata;
+    _ = clock;
+}
+
+pub fn failingNetListenIp(userdata: ?*anyopaque, address: *const net.IpAddress, options: net.IpAddress.ListenOptions) net.IpAddress.ListenError!net.Socket {
+    _ = userdata;
+    _ = address;
+    _ = options;
+    return error.NetworkDown;
+}
+
+pub fn failingNetAccept(userdata: ?*anyopaque, listen_fd: net.Socket.Handle, options: net.Server.AcceptOptions) net.Server.AcceptError!net.Socket {
+    _ = userdata;
+    _ = listen_fd;
+    _ = options;
+    return error.NetworkDown;
+}
+
+pub fn failingNetBindIp(userdata: ?*anyopaque, address: *const net.IpAddress, options: net.IpAddress.BindOptions) net.IpAddress.BindError!net.Socket {
+    _ = userdata;
+    _ = address;
+    _ = options;
+    return error.NetworkDown;
+}
+
+pub fn failingNetConnectIp(userdata: ?*anyopaque, address: *const net.IpAddress, options: net.IpAddress.ConnectOptions) net.IpAddress.ConnectError!net.Socket {
+    _ = userdata;
+    _ = address;
+    _ = options;
+    return error.NetworkDown;
+}
+
+pub fn failingNetListenUnix(userdata: ?*anyopaque, address: *const net.UnixAddress, options: net.UnixAddress.ListenOptions) net.UnixAddress.ListenError!net.Socket.Handle {
+    _ = userdata;
+    _ = address;
+    _ = options;
+    return error.NetworkDown;
+}
+
+pub fn failingNetConnectUnix(userdata: ?*anyopaque, address: *const net.UnixAddress) net.UnixAddress.ConnectError!net.Socket.Handle {
+    _ = userdata;
+    _ = address;
+    return error.NetworkDown;
+}
+
+pub fn failingNetSocketCreatePair(userdata: ?*anyopaque, options: net.Socket.CreatePairOptions) net.Socket.CreatePairError![2]net.Socket {
+    _ = userdata;
+    _ = options;
+    return error.OperationUnsupported;
+}
+
+pub fn failingNetSend(userdata: ?*anyopaque, handle: net.Socket.Handle, messages: []net.OutgoingMessage, flags: net.SendFlags) struct { ?net.Socket.SendError, usize } {
+    _ = userdata;
+    _ = handle;
+    _ = messages;
+    _ = flags;
+    return .{ error.NetworkDown, 0 };
+}
+
+pub fn failingNetRead(userdata: ?*anyopaque, src: net.Socket.Handle, data: [][]u8) net.Stream.Reader.Error!usize {
+    _ = userdata;
+    _ = src;
+    _ = data;
+    return error.NetworkDown;
+}
+
+pub fn failingNetWrite(userdata: ?*anyopaque, dest: net.Socket.Handle, header: []const u8, data: []const []const u8, splat: usize) net.Stream.Writer.Error!usize {
+    _ = userdata;
+    _ = dest;
+    _ = header;
+    _ = data;
+    _ = splat;
+    return error.NetworkDown;
+}
+
+pub fn failingNetWriteFile(userdata: ?*anyopaque, handle: net.Socket.Handle, header: []const u8, file_reader: *Io.File.Reader, limit: Io.Limit) net.Stream.Writer.WriteFileError!usize {
+    _ = userdata;
+    _ = handle;
+    _ = header;
+    _ = file_reader;
+    _ = limit;
+    return error.NetworkDown;
+}
+
+pub fn unreachableNetClose(userdata: ?*anyopaque, handle: []const net.Socket.Handle) void {
+    _ = userdata;
+    _ = handle;
+    unreachable;
+}
+
+pub fn failingNetShutdown(userdata: ?*anyopaque, handle: net.Socket.Handle, how: net.ShutdownHow) net.ShutdownError!void {
+    _ = userdata;
+    _ = handle;
+    _ = how;
+    return error.NetworkDown;
+}
+
+pub fn failingNetInterfaceNameResolve(userdata: ?*anyopaque, name: *const net.Interface.Name) net.Interface.Name.ResolveError!net.Interface {
+    _ = userdata;
+    _ = name;
+    return error.InterfaceNotFound;
+}
+
+pub fn unreachableNetInterfaceName(userdata: ?*anyopaque, interface: net.Interface) net.Interface.NameError!net.Interface.Name {
+    _ = userdata;
+    _ = interface;
+    unreachable;
+}
+
+pub fn failingNetLookup(userdata: ?*anyopaque, host_name: net.HostName, resolved: *Queue(net.HostName.LookupResult), options: net.HostName.LookupOptions) net.HostName.LookupError!void {
+    _ = userdata;
+    _ = host_name;
+    _ = resolved;
+    _ = options;
+    return error.NetworkDown;
+}
+
+test failing {
+    const f: Io = .failing;
+    // file stuff
+    try std.testing.expectError(error.NoSpaceLeft, Dir.createDir(.cwd(), f, "test", .default_dir));
+    try std.testing.expectError(error.NoSpaceLeft, Dir.createFile(.cwd(), f, "test", .{}));
+    try std.testing.expectError(error.FileNotFound, Dir.openDir(.cwd(), f, "test", .{}));
+    try std.testing.expectError(error.FileNotFound, Dir.openFile(.cwd(), f, "test", .{}));
+    try File.writeStreamingAll(.stdout(), f, &.{});
+    try std.testing.expectError(error.AccessDenied, File.MemoryMap.create(f, .stdout(), .{ .len = 0 }));
+    // async stuff
+    const closure = struct {
+        var foo: usize = 0;
+        fn doOp() void {
+            foo = 4;
+        }
+    };
+    var future = f.async(closure.doOp, .{});
+    _ = future.await(f);
+    try std.testing.expect(closure.foo == 4);
+    // random stuff
+    var buffer: [1]u8 = undefined;
+    f.random(&buffer);
+    try std.testing.expect(buffer[0] == 0);
+}

package/std/bit_set.zig

@@ -68,16 +68,24 @@ pub fn IntegerBitSet(comptime size: u16) type {
         /// The bit mask, as a single integer
         mask: MaskInt,
 
+        /// Deprecated: use `.empty`.
         /// Creates a bit set with no elements present.
         pub fn initEmpty() Self {
             return .{ .mask = 0 };
         }
 
+        /// Deprecated: use `.full`.
         /// Creates a bit set with all elements present.
         pub fn initFull() Self {
             return .{ .mask = ~@as(MaskInt, 0) };
         }
 
+        /// A bit set with no elements present.
+        pub const empty: Self = .{ .mask = 0 };
+
+        /// A bit set with all elements present.
+        pub const full: Self = .{ .mask = ~@as(MaskInt, 0) };
+
         /// Returns the number of bits in this bit set
         pub inline fn capacity(self: Self) usize {
             _ = self;
@@ -387,11 +395,13 @@ pub fn ArrayBitSet(comptime MaskIntType: type, comptime size: usize) type {
         /// Padding bits at the end are undefined.
         masks: [num_masks]MaskInt,
 
+        /// Deprecated: use `.empty`.
         /// Creates a bit set with no elements present.
         pub fn initEmpty() Self {
             return .{ .masks = [_]MaskInt{0} ** num_masks };
         }
 
+        /// Deprecated: use `.full`.
         /// Creates a bit set with all elements present.
         pub fn initFull() Self {
             if (num_masks == 0) {
@@ -401,6 +411,12 @@ pub fn ArrayBitSet(comptime MaskIntType: type, comptime size: usize) type {
             }
         }
 
+        /// A bit set with no elements present.
+        pub const empty: Self = .{ .masks = @splat(0) };
+
+        /// A bit set with all elements present.
+        pub const full: Self = .{ .masks = if (num_masks == 0) .{} else ([_]MaskInt{~@as(MaskInt, 0)} ** (num_masks - 1) ++ [_]MaskInt{last_item_mask}) };
+
         /// Returns the number of bits in this bit set
         pub inline fn capacity(self: Self) usize {
             _ = self;
@@ -1633,17 +1649,17 @@ fn fillOdd(set: anytype, len: usize) void {
 }
 
 fn testPureBitSet(comptime Set: type) !void {
-    const empty = Set.initEmpty();
-    const full = Set.initFull();
+    const empty = Set.empty;
+    const full = Set.full;
 
     const even = even: {
-        var bit_set = Set.initEmpty();
+        var bit_set = Set.empty;
         fillEven(&bit_set, Set.bit_length);
         break :even bit_set;
     };
 
     const odd = odd: {
-        var bit_set = Set.initEmpty();
+        var bit_set = Set.empty;
         fillOdd(&bit_set, Set.bit_length);
         break :odd bit_set;
     };
@@ -1686,8 +1702,8 @@ fn testPureBitSet(comptime Set: type) !void {
 }
 
 fn testStaticBitSet(comptime Set: type) !void {
-    var a = Set.initEmpty();
-    var b = Set.initFull();
+    var a = Set.empty;
+    var b = Set.full;
     try testing.expectEqual(@as(usize, 0), a.count());
     try testing.expectEqual(@as(usize, Set.bit_length), b.count());
 

package/std/crypto/codecs/base64_hex_ct.zig

@@ -93,7 +93,7 @@ pub const hex = struct {
     /// The decoder will skip any characters that are in the ignore list.
     /// The ignore list must not contain any valid hexadecimal characters.
     pub fn decoderWithIgnore(ignore_chars: []const u8) error{InvalidCharacter}!DecoderWithIgnore {
-        var ignored_chars = StaticBitSet(256).initEmpty();
+        var ignored_chars = StaticBitSet(256).empty;
         for (ignore_chars) |c| {
             switch (c) {
                 '0'...'9', 'a'...'f', 'A'...'F' => return error.InvalidCharacter,
@@ -269,7 +269,7 @@ pub const base64 = struct {
 
     /// Creates a new decoder that ignores certain characters.
     pub fn decoderWithIgnore(ignore_chars: []const u8) error{InvalidCharacter}!DecoderWithIgnore {
-        var ignored_chars = StaticBitSet(256).initEmpty();
+        var ignored_chars = StaticBitSet(256).empty;
         for (ignore_chars) |c| {
             switch (c) {
                 'A'...'Z', 'a'...'z', '0'...'9' => return error.InvalidCharacter,

package/std/enums.zig

@@ -252,7 +252,7 @@ pub fn EnumSet(comptime E: type) type {
         /// The maximum number of items in this set.
         pub const len = Indexer.count;
 
-        bits: BitSet = BitSet.initEmpty(),
+        bits: BitSet = .empty,
 
         /// Initializes the set using a struct of bools
         pub fn init(init_values: EnumFieldStruct(E, bool, false)) Self {
@@ -278,19 +278,15 @@ pub fn EnumSet(comptime E: type) type {
             return result;
         }
 
-        /// Returns a set containing no keys.
-        pub fn initEmpty() Self {
-            return .{ .bits = BitSet.initEmpty() };
-        }
+        /// A set containing no keys.
+        pub const empty: Self = .{ .bits = .empty };
 
-        /// Returns a set containing all possible keys.
-        pub fn initFull() Self {
-            return .{ .bits = BitSet.initFull() };
-        }
+        /// A set containing all possible keys.
+        pub const full: Self = .{ .bits = .full };
 
         /// Returns a set containing multiple keys.
         pub fn initMany(keys: []const Key) Self {
-            var set = initEmpty();
+            var set: Self = .empty;
             for (keys) |key| set.insert(key);
             return set;
         }
@@ -440,7 +436,7 @@ pub fn EnumMap(comptime E: type, comptime V: type) type {
         const BitSet = std.StaticBitSet(Indexer.count);
 
         /// Bits determining whether items are in the map
-        bits: BitSet = BitSet.initEmpty(),
+        bits: BitSet = .empty,
         /// Values of items in the map.  If the associated
         /// bit is zero, the value is undefined.
         values: [Indexer.count]Value = undefined,
@@ -475,7 +471,7 @@ pub fn EnumMap(comptime E: type, comptime V: type) type {
         /// Consider using EnumArray instead if the map will remain full.
         pub fn initFull(value: Value) Self {
             var result: Self = .{
-                .bits = Self.BitSet.initFull(),
+                .bits = .full,
                 .values = undefined,
             };
             @memset(&result.values, value);
@@ -493,7 +489,7 @@ pub fn EnumMap(comptime E: type, comptime V: type) type {
         pub fn initFullWithDefault(comptime default: ?Value, init_values: EnumFieldStruct(E, Value, default)) Self {
             @setEvalBranchQuota(2 * @typeInfo(E).@"enum".fields.len);
             var result: Self = .{
-                .bits = Self.BitSet.initFull(),
+                .bits = .full,
                 .values = undefined,
             };
             inline for (0..Self.len) |i| {
@@ -687,16 +683,14 @@ pub fn BoundedEnumMultiset(comptime E: type, comptime CountSize: type) type {
             return self;
         }
 
-        /// Initializes the multiset with a count of zero.
-        pub fn initEmpty() Self {
-            return initWithCount(0);
-        }
+        /// A multiset with a count of zero.
+        pub const empty: Self = .initWithCount(0);
 
         /// Initializes the multiset with all keys at the
         /// same count.
         pub fn initWithCount(comptime c: CountSize) Self {
             return .{
-                .counts = EnumArray(E, CountSize).initDefault(c, .{}),
+                .counts = .initDefault(c, .{}),
             };
         }
 
@@ -855,7 +849,7 @@ pub fn BoundedEnumMultiset(comptime E: type, comptime CountSize: type) type {
 test EnumMultiset {
     const Ball = enum { red, green, blue };
 
-    const empty = EnumMultiset(Ball).initEmpty();
+    const empty = EnumMultiset(Ball).empty;
     const r0_g1_b2 = EnumMultiset(Ball).init(.{
         .red = 0,
         .green = 1,
@@ -1162,8 +1156,8 @@ pub fn EnumArray(comptime E: type, comptime V: type) type {
 test "pure EnumSet fns" {
     const Suit = enum { spades, hearts, clubs, diamonds };
 
-    const empty = EnumSet(Suit).initEmpty();
-    const full = EnumSet(Suit).initFull();
+    const empty = EnumSet(Suit).empty;
+    const full = EnumSet(Suit).full;
     const black = EnumSet(Suit).initMany(&[_]Suit{ .spades, .clubs });
     const red = EnumSet(Suit).initMany(&[_]Suit{ .hearts, .diamonds });
 
@@ -1224,8 +1218,8 @@ test "pure EnumSet fns" {
 
 test "EnumSet empty" {
     const E = enum {};
-    const empty = EnumSet(E).initEmpty();
-    const full = EnumSet(E).initFull();
+    const empty = EnumSet(E).empty;
+    const full = EnumSet(E).full;
 
     try std.testing.expect(empty.eql(full));
     try std.testing.expect(empty.complement().eql(full));
@@ -1236,13 +1230,13 @@ test "EnumSet empty" {
 test "EnumSet const iterator" {
     const Direction = enum { up, down, left, right };
     const diag_move = init: {
-        var move = EnumSet(Direction).initEmpty();
+        var move = EnumSet(Direction).empty;
         move.insert(.right);
         move.insert(.up);
         break :init move;
     };
 
-    var result = EnumSet(Direction).initEmpty();
+    var result = EnumSet(Direction).empty;
     var it = diag_move.iterator();
     while (it.next()) |dir| {
         result.insert(dir);

package/std/http/Client.zig

@@ -1133,7 +1133,16 @@ pub const Request = struct {
     pub fn receiveHead(r: *Request, redirect_buffer: []u8) ReceiveHeadError!Response {
         var aux_buf = redirect_buffer;
         while (true) {
-            const head_buffer = try r.reader.receiveHead();
+            // This while loop is for handling redirects, which means the request's
+            // connection may be different than the previous iteration. However, it
+            // is still guaranteed to be non-null with each iteration of this loop.
+            const connection = r.connection.?;
+
+            const head_buffer = r.reader.receiveHead() catch |err| {
+                // Failure here means the connection can no longer be reused.
+                connection.closing = true;
+                return err;
+            };
             const response: Response = .{
                 .request = r,
                 .head = Response.Head.parse(head_buffer) catch return error.HttpHeadersInvalid,
@@ -1147,11 +1156,6 @@ pub const Request = struct {
                 return response; // we're not handling the 100-continue
             }
 
-            // This while loop is for handling redirects, which means the request's
-            // connection may be different than the previous iteration. However, it
-            // is still guaranteed to be non-null with each iteration of this loop.
-            const connection = r.connection.?;
-
             if (r.method == .CONNECT and head.status.class() == .success) {
                 // This connection is no longer doing HTTP.
                 connection.closing = false;