@zigc/lib 0.17.0-dev.39 → 0.17.0-dev.420

package/std/heap/debug_allocator.zig

@@ -164,7 +164,7 @@ pub fn DebugAllocator(comptime config: Config) type {
     return struct {
         backing_allocator: Allocator = std.heap.page_allocator,
         /// Tracks the active bucket, which is the one that has free slots in it.
-        buckets: [small_bucket_count]?*BucketHeader = [1]?*BucketHeader{null} ** small_bucket_count,
+        buckets: [small_bucket_count]?*BucketHeader = @splat(null),
         large_allocations: LargeAllocTable = .empty,
         total_requested_bytes: @TypeOf(total_requested_bytes_init) = total_requested_bytes_init,
         requested_memory_limit: @TypeOf(requested_memory_limit_init) = requested_memory_limit_init,
@@ -189,7 +189,7 @@ pub fn DebugAllocator(comptime config: Config) type {
         const page_size = config.page_size;
         const page_align: mem.Alignment = .fromByteUnits(page_size);
         /// Integer type for pointing to slots in a small allocation
-        const SlotIndex = std.meta.Int(.unsigned, math.log2(page_size) + 1);
+        const SlotIndex = @Int(.unsigned, math.log2(page_size) + 1);
 
         const total_requested_bytes_init = if (config.enable_memory_limit) @as(usize, 0) else {};
         const requested_memory_limit_init = if (config.enable_memory_limit) @as(usize, math.maxInt(usize)) else {};

package/std/heap/memory_pool.zig

@@ -3,11 +3,6 @@ const Allocator = std.mem.Allocator;
 const Alignment = std.mem.Alignment;
 const MemoryPool = std.heap.MemoryPool;
 
-/// Deprecated.
-pub fn Managed(comptime Item: type) type {
-    return ExtraManaged(Item, .{ .alignment = null });
-}
-
 /// A memory pool that can allocate objects of a single type very quickly.
 /// Use this when you need to allocate a lot of objects of the same type,
 /// because it outperforms general purpose allocators.
@@ -18,11 +13,6 @@ pub fn Aligned(comptime Item: type, comptime alignment: Alignment) type {
     return Extra(Item, .{ .alignment = alignment });
 }
 
-/// Deprecated.
-pub fn AlignedManaged(comptime Item: type, comptime alignment: Alignment) type {
-    return ExtraManaged(Item, .{ .alignment = alignment });
-}
-
 pub const Options = struct {
     /// The alignment of the memory pool items. Use `null` for natural alignment.
     alignment: ?Alignment = null,
@@ -83,13 +73,6 @@ pub fn Extra(comptime Item: type, comptime pool_options: Options) type {
             pool.* = undefined;
         }
 
-        pub fn toManaged(pool: Pool, allocator: Allocator) ExtraManaged(Item, pool_options) {
-            return .{
-                .allocator = allocator,
-                .unmanaged = pool,
-            };
-        }
-
         /// Pre-allocates `num` items and adds them to the memory pool.
         /// This allows at least `num` active allocations before an
         /// `OutOfMemory` error might happen when calling `create()`.
@@ -114,7 +97,7 @@ pub fn Extra(comptime Item: type, comptime pool_options: Options) type {
         /// NOTE: If `mode` is `free_all`, the function will always return `true`.
         pub fn reset(pool: *Pool, allocator: Allocator, mode: ResetMode) bool {
             // TODO: Potentially store all allocated objects in a list as well, allowing to
-            //       just move them into the free list instead of actually releasing the memory.
+            // just move them into the free list instead of actually releasing the memory.
 
             var arena = pool.arena_state.promote(allocator);
             defer pool.arena_state = arena.state;
@@ -155,182 +138,56 @@ pub fn Extra(comptime Item: type, comptime pool_options: Options) type {
     };
 }
 
-/// Deprecated.
-pub fn ExtraManaged(comptime Item: type, comptime pool_options: Options) type {
-    if (pool_options.alignment) |a| {
-        if (a.compare(.eq, .of(Item))) {
-            var new_options = pool_options;
-            new_options.alignment = null;
-            return ExtraManaged(Item, new_options);
-        }
-    }
-    return struct {
-        const Pool = @This();
-
-        allocator: Allocator,
-        unmanaged: Unmanaged,
-
-        pub const Unmanaged = Extra(Item, pool_options);
-        pub const item_size = Unmanaged.item_size;
-        pub const item_alignment = Unmanaged.item_alignment;
-
-        const ItemPtr = Unmanaged.ItemPtr;
-
-        /// Creates a new memory pool.
-        pub fn init(allocator: Allocator) Pool {
-            return Unmanaged.empty.toManaged(allocator);
-        }
-
-        /// Creates a new memory pool and pre-allocates `num` items.
-        /// This allows up to `num` active allocations before an
-        /// `OutOfMemory` error might happen when calling `create()`.
-        pub fn initCapacity(allocator: Allocator, num: usize) Allocator.Error!Pool {
-            return (try Unmanaged.initCapacity(allocator, num)).toManaged(allocator);
-        }
-
-        /// Destroys the memory pool and frees all allocated memory.
-        pub fn deinit(pool: *Pool) void {
-            pool.unmanaged.deinit(pool.allocator);
-            pool.* = undefined;
-        }
-
-        /// Pre-allocates `num` items and adds them to the memory pool.
-        /// This allows at least `num` active allocations before an
-        /// `OutOfMemory` error might happen when calling `create()`.
-        pub fn addCapacity(pool: *Pool, num: usize) Allocator.Error!void {
-            return pool.unmanaged.addCapacity(pool.allocator, num);
-        }
-
-        pub const ResetMode = Unmanaged.ResetMode;
-
-        /// Resets the memory pool and destroys all allocated items.
-        /// This can be used to batch-destroy all objects without invalidating the memory pool.
-        ///
-        /// The function will return whether the reset operation was successful or not.
-        /// If the reallocation  failed `false` is returned. The pool will still be fully
-        /// functional in that case, all memory is released. Future allocations just might
-        /// be slower.
-        ///
-        /// NOTE: If `mode` is `free_all`, the function will always return `true`.
-        pub fn reset(pool: *Pool, mode: ResetMode) bool {
-            return pool.unmanaged.reset(pool.allocator, mode);
-        }
-
-        /// Creates a new item and adds it to the memory pool.
-        pub fn create(pool: *Pool) Allocator.Error!ItemPtr {
-            return pool.unmanaged.create(pool.allocator);
-        }
-
-        /// Destroys a previously created item.
-        /// Only pass items to `ptr` that were previously created with `create()` of the same memory pool!
-        pub fn destroy(pool: *Pool, ptr: ItemPtr) void {
-            return pool.unmanaged.destroy(ptr);
-        }
-
-        fn allocNew(pool: *Pool) Allocator.Error!*align(item_alignment) [item_size]u8 {
-            return pool.unmanaged.allocNew(pool.allocator);
-        }
-    };
-}
-
 test "basic" {
     const a = std.testing.allocator;
 
-    {
-        var pool: MemoryPool(u32) = .empty;
-        defer pool.deinit(a);
-
-        const p1 = try pool.create(a);
-        const p2 = try pool.create(a);
-        const p3 = try pool.create(a);
-
-        // Assert uniqueness
-        try std.testing.expect(p1 != p2);
-        try std.testing.expect(p1 != p3);
-        try std.testing.expect(p2 != p3);
+    var pool: MemoryPool(u32) = .empty;
+    defer pool.deinit(a);
 
-        pool.destroy(p2);
-        const p4 = try pool.create(a);
-
-        // Assert memory reuse
-        try std.testing.expect(p2 == p4);
-    }
+    const p1 = try pool.create(a);
+    const p2 = try pool.create(a);
+    const p3 = try pool.create(a);
 
-    {
-        var pool: Managed(u32) = .init(std.testing.allocator);
-        defer pool.deinit();
+    // Assert uniqueness
+    try std.testing.expect(p1 != p2);
+    try std.testing.expect(p1 != p3);
+    try std.testing.expect(p2 != p3);
 
-        const p1 = try pool.create();
-        const p2 = try pool.create();
-        const p3 = try pool.create();
+    pool.destroy(p2);
+    const p4 = try pool.create(a);
 
-        // Assert uniqueness
-        try std.testing.expect(p1 != p2);
-        try std.testing.expect(p1 != p3);
-        try std.testing.expect(p2 != p3);
-
-        pool.destroy(p2);
-        const p4 = try pool.create();
-
-        // Assert memory reuse
-        try std.testing.expect(p2 == p4);
-    }
+    // Assert memory reuse
+    try std.testing.expect(p2 == p4);
 }
 
 test "initCapacity (success)" {
     const a = std.testing.allocator;
 
-    {
-        var pool: MemoryPool(u32) = try .initCapacity(a, 4);
-        defer pool.deinit(a);
-
-        _ = try pool.create(a);
-        _ = try pool.create(a);
-        _ = try pool.create(a);
-    }
-
-    {
-        var pool: Managed(u32) = try .initCapacity(a, 4);
-        defer pool.deinit();
+    var pool: MemoryPool(u32) = try .initCapacity(a, 4);
+    defer pool.deinit(a);
 
-        _ = try pool.create();
-        _ = try pool.create();
-        _ = try pool.create();
-    }
+    _ = try pool.create(a);
+    _ = try pool.create(a);
+    _ = try pool.create(a);
 }
 
 test "initCapacity (failure)" {
     const failer = std.testing.failing_allocator;
     try std.testing.expectError(error.OutOfMemory, MemoryPool(u32).initCapacity(failer, 5));
-    try std.testing.expectError(error.OutOfMemory, Managed(u32).initCapacity(failer, 5));
 }
 
 test "growable" {
     const a = std.testing.allocator;
 
-    {
-        var pool: Extra(u32, .{ .growable = false }) = try .initCapacity(a, 4);
-        defer pool.deinit(a);
-
-        _ = try pool.create(a);
-        _ = try pool.create(a);
-        _ = try pool.create(a);
-        _ = try pool.create(a);
-
-        try std.testing.expectError(error.OutOfMemory, pool.create(a));
-    }
-
-    {
-        var pool: ExtraManaged(u32, .{ .growable = false }) = try .initCapacity(a, 4);
-        defer pool.deinit();
+    var pool: Extra(u32, .{ .growable = false }) = try .initCapacity(a, 4);
+    defer pool.deinit(a);
 
-        _ = try pool.create();
-        _ = try pool.create();
-        _ = try pool.create();
-        _ = try pool.create();
+    _ = try pool.create(a);
+    _ = try pool.create(a);
+    _ = try pool.create(a);
+    _ = try pool.create(a);
 
-        try std.testing.expectError(error.OutOfMemory, pool.create());
-    }
+    try std.testing.expectError(error.OutOfMemory, pool.create(a));
 }
 
 test "greater than pointer default alignment" {
@@ -339,21 +196,11 @@ test "greater than pointer default alignment" {
     };
     const a = std.testing.allocator;
 
-    {
-        var pool: MemoryPool(Foo) = .empty;
-        defer pool.deinit(a);
-
-        const foo: *Foo = try pool.create(a);
-        pool.destroy(foo);
-    }
-
-    {
-        var pool: Managed(Foo) = .init(a);
-        defer pool.deinit();
+    var pool: MemoryPool(Foo) = .empty;
+    defer pool.deinit(a);
 
-        const foo: *Foo = try pool.create();
-        pool.destroy(foo);
-    }
+    const foo: *Foo = try pool.create(a);
+    pool.destroy(foo);
 }
 
 test "greater than pointer manual alignment" {
@@ -362,19 +209,9 @@ test "greater than pointer manual alignment" {
     };
     const a = std.testing.allocator;
 
-    {
-        var pool: Aligned(Foo, .@"16") = .empty;
-        defer pool.deinit(a);
-
-        const foo: *align(16) Foo = try pool.create(a);
-        pool.destroy(foo);
-    }
+    var pool: Aligned(Foo, .@"16") = .empty;
+    defer pool.deinit(a);
 
-    {
-        var pool: AlignedManaged(Foo, .@"16") = .init(a);
-        defer pool.deinit();
-
-        const foo: *align(16) Foo = try pool.create();
-        pool.destroy(foo);
-    }
+    const foo: *align(16) Foo = try pool.create(a);
+    pool.destroy(foo);
 }

package/std/heap.zig

@@ -11,13 +11,18 @@ const Alignment = std.mem.Alignment;
 
 pub const ArenaAllocator = @import("heap/ArenaAllocator.zig");
 pub const SmpAllocator = @import("heap/SmpAllocator.zig");
+pub const SafeAllocator = @import("heap/SafeAllocator.zig");
 pub const FixedBufferAllocator = @import("heap/FixedBufferAllocator.zig");
+pub const BufferFirstAllocator = @import("heap/BufferFirstAllocator.zig");
 pub const PageAllocator = @import("heap/PageAllocator.zig");
 pub const WasmAllocator = if (builtin.single_threaded) BrkAllocator else @compileError("unimplemented");
 pub const BrkAllocator = @import("heap/BrkAllocator.zig");
 
+/// Deprecated; use `SafeAllocator.Options`.
 pub const DebugAllocatorConfig = @import("heap/debug_allocator.zig").Config;
+/// Deprecated; use `SafeAllocator`.
 pub const DebugAllocator = @import("heap/debug_allocator.zig").DebugAllocator;
+/// Deprecated.
 pub const Check = enum { ok, leak };
 
 /// A memory pool that can allocate objects of a single type very quickly.
@@ -29,13 +34,6 @@ pub fn MemoryPool(comptime Item: type) type {
 }
 pub const memory_pool = @import("heap/memory_pool.zig");
 
-/// Deprecated; use `memory_pool.Aligned`.
-pub const MemoryPoolAligned = memory_pool.Aligned;
-/// Deprecated; use `memory_pool.Extra`.
-pub const MemoryPoolExtra = memory_pool.Extra;
-/// Deprecated; use `memory_pool.Options`.
-pub const MemoryPoolOptions = memory_pool.Options;
-
 /// comptime-known minimum page size of the target.
 ///
 /// All pointers from `mmap` or `NtAllocateVirtualMemory` are aligned to at least
@@ -367,113 +365,6 @@ pub const brk_allocator: Allocator = .{
     .vtable = &BrkAllocator.vtable,
 };
 
-/// Returns a `StackFallbackAllocator` allocating using either a
-/// `FixedBufferAllocator` on an array of size `size` and falling back to
-/// `fallback_allocator` if that fails.
-pub fn stackFallback(comptime size: usize, fallback_allocator: Allocator) StackFallbackAllocator(size) {
-    return StackFallbackAllocator(size){
-        .buffer = undefined,
-        .fallback_allocator = fallback_allocator,
-        .fixed_buffer_allocator = undefined,
-    };
-}
-
-/// An allocator that attempts to allocate using a
-/// `FixedBufferAllocator` using an array of size `size`. If the
-/// allocation fails, it will fall back to using
-/// `fallback_allocator`. Easily created with `stackFallback`.
-pub fn StackFallbackAllocator(comptime size: usize) type {
-    return struct {
-        const Self = @This();
-
-        buffer: [size]u8,
-        fallback_allocator: Allocator,
-        fixed_buffer_allocator: FixedBufferAllocator,
-        get_called: if (std.debug.runtime_safety) bool else void =
-            if (std.debug.runtime_safety) false else {},
-
-        /// This function both fetches a `Allocator` interface to this
-        /// allocator *and* resets the internal buffer allocator.
-        pub fn get(self: *Self) Allocator {
-            if (std.debug.runtime_safety) {
-                assert(!self.get_called); // `get` called multiple times; instead use `const allocator = stackFallback(N).get();`
-                self.get_called = true;
-            }
-            self.fixed_buffer_allocator = FixedBufferAllocator.init(self.buffer[0..]);
-            return .{
-                .ptr = self,
-                .vtable = &.{
-                    .alloc = alloc,
-                    .resize = resize,
-                    .remap = remap,
-                    .free = free,
-                },
-            };
-        }
-
-        /// Unlike most std allocators `StackFallbackAllocator` modifies
-        /// its internal state before returning an implementation of
-        /// the`Allocator` interface and therefore also doesn't use
-        /// the usual `.allocator()` method.
-        pub const allocator = @compileError("use 'const allocator = stackFallback(N).get();' instead");
-
-        fn alloc(
-            ctx: *anyopaque,
-            len: usize,
-            alignment: Alignment,
-            ra: usize,
-        ) ?[*]u8 {
-            const self: *Self = @ptrCast(@alignCast(ctx));
-            return FixedBufferAllocator.alloc(&self.fixed_buffer_allocator, len, alignment, ra) orelse
-                return self.fallback_allocator.rawAlloc(len, alignment, ra);
-        }
-
-        fn resize(
-            ctx: *anyopaque,
-            buf: []u8,
-            alignment: Alignment,
-            new_len: usize,
-            ra: usize,
-        ) bool {
-            const self: *Self = @ptrCast(@alignCast(ctx));
-            if (self.fixed_buffer_allocator.ownsPtr(buf.ptr)) {
-                return FixedBufferAllocator.resize(&self.fixed_buffer_allocator, buf, alignment, new_len, ra);
-            } else {
-                return self.fallback_allocator.rawResize(buf, alignment, new_len, ra);
-            }
-        }
-
-        fn remap(
-            context: *anyopaque,
-            memory: []u8,
-            alignment: Alignment,
-            new_len: usize,
-            return_address: usize,
-        ) ?[*]u8 {
-            const self: *Self = @ptrCast(@alignCast(context));
-            if (self.fixed_buffer_allocator.ownsPtr(memory.ptr)) {
-                return FixedBufferAllocator.remap(&self.fixed_buffer_allocator, memory, alignment, new_len, return_address);
-            } else {
-                return self.fallback_allocator.rawRemap(memory, alignment, new_len, return_address);
-            }
-        }
-
-        fn free(
-            ctx: *anyopaque,
-            buf: []u8,
-            alignment: Alignment,
-            ra: usize,
-        ) void {
-            const self: *Self = @ptrCast(@alignCast(ctx));
-            if (self.fixed_buffer_allocator.ownsPtr(buf.ptr)) {
-                return FixedBufferAllocator.free(&self.fixed_buffer_allocator, buf, alignment, ra);
-            } else {
-                return self.fallback_allocator.rawFree(buf, alignment, ra);
-            }
-        }
-    };
-}
-
 test c_allocator {
     if (builtin.link_libc) {
         try testAllocator(c_allocator);
@@ -491,6 +382,17 @@ test smp_allocator {
     try testAllocatorAlignedShrink(smp_allocator);
 }
 
+test SafeAllocator {
+    var instance: SafeAllocator = .init(page_allocator, .{});
+    defer _ = instance.deinit();
+    const allocator = instance.allocator();
+
+    try testAllocator(allocator);
+    try testAllocatorAligned(allocator);
+    try testAllocatorLargeAlignment(allocator);
+    try testAllocatorAlignedShrink(allocator);
+}
+
 test PageAllocator {
     const allocator = page_allocator;
     try testAllocator(allocator);
@@ -524,25 +426,6 @@ test ArenaAllocator {
     try testAllocatorAlignedShrink(allocator);
 }
 
-test "StackFallbackAllocator" {
-    {
-        var stack_allocator = stackFallback(4096, std.testing.allocator);
-        try testAllocator(stack_allocator.get());
-    }
-    {
-        var stack_allocator = stackFallback(4096, std.testing.allocator);
-        try testAllocatorAligned(stack_allocator.get());
-    }
-    {
-        var stack_allocator = stackFallback(4096, std.testing.allocator);
-        try testAllocatorLargeAlignment(stack_allocator.get());
-    }
-    {
-        var stack_allocator = stackFallback(4096, std.testing.allocator);
-        try testAllocatorAlignedShrink(stack_allocator.get());
-    }
-}
-
 /// This one should not try alignments that exceed what C malloc can handle.
 pub fn testAllocator(base_allocator: mem.Allocator) !void {
     var validationAllocator = mem.validationWrap(base_allocator);
@@ -740,6 +623,7 @@ const page_size_min_default: ?usize = switch (builtin.os.tag) {
         .hppa => 4 << 10,
         .x86, .x86_64 => 4 << 10,
         .thumb, .thumbeb, .arm, .armeb, .aarch64, .aarch64_be => 4 << 10,
+        .m88k => 4 << 10,
         .mips64, .mips64el => 4 << 10,
         .powerpc, .powerpc64, .powerpc64le, .powerpcle => 4 << 10,
         .riscv64 => 4 << 10,
@@ -903,6 +787,7 @@ const page_size_max_default: ?usize = switch (builtin.os.tag) {
         .hppa => 4 << 10,
         .x86, .x86_64 => 4 << 10,
         .thumb, .thumbeb, .arm, .armeb, .aarch64, .aarch64_be => 4 << 10,
+        .m88k => 4 << 10,
         .mips64, .mips64el => 16 << 10,
         .powerpc, .powerpc64, .powerpc64le, .powerpcle => 4 << 10,
         .riscv64 => 4 << 10,
@@ -1010,7 +895,9 @@ test {
     _ = @import("heap/memory_pool.zig");
     _ = ArenaAllocator;
     _ = DebugAllocator(.{});
+    _ = SafeAllocator;
     _ = FixedBufferAllocator;
+    _ = BufferFirstAllocator;
     if (builtin.single_threaded) {
         if (builtin.cpu.arch.isWasm() or (builtin.os.tag == .linux and !builtin.link_libc)) {
             _ = brk_allocator;

package/std/http/Client.zig

@@ -4,8 +4,6 @@
 //!
 //! TLS support may be disabled via `std.options.http_disable_tls`.
 //!
-//! TODO all the lockUncancelable in this file should be changed to regular lock and
-//! `error.Canceled` added to more error sets.
 const Client = @This();
 
 const builtin = @import("builtin");
@@ -84,8 +82,8 @@ pub const ConnectionPool = struct {
     /// If no connection is found, null is returned.
     ///
     /// Threadsafe.
-    pub fn findConnection(pool: *ConnectionPool, io: Io, criteria: Criteria) ?*Connection {
-        pool.mutex.lockUncancelable(io);
+    pub fn findConnection(pool: *ConnectionPool, io: Io, criteria: Criteria) Io.Cancelable!?*Connection {
+        try pool.mutex.lock(io);
         defer pool.mutex.unlock(io);
 
         var next = pool.free.last;
@@ -113,8 +111,8 @@ pub const ConnectionPool = struct {
     }
 
     /// Acquires an existing connection from the connection pool. This function is threadsafe.
-    pub fn acquire(pool: *ConnectionPool, io: Io, connection: *Connection) void {
-        pool.mutex.lockUncancelable(io);
+    pub fn acquire(pool: *ConnectionPool, io: Io, connection: *Connection) Io.Cancelable!void {
+        try pool.mutex.lock(io);
         defer pool.mutex.unlock(io);
 
         return pool.acquireUnsafe(connection);
@@ -150,8 +148,8 @@ pub const ConnectionPool = struct {
     }
 
     /// Adds a newly created node to the pool of used connections. This function is threadsafe.
-    pub fn addUsed(pool: *ConnectionPool, io: Io, connection: *Connection) void {
-        pool.mutex.lockUncancelable(io);
+    pub fn addUsed(pool: *ConnectionPool, io: Io, connection: *Connection) Io.Cancelable!void {
+        try pool.mutex.lock(io);
         defer pool.mutex.unlock(io);
 
         pool.used.append(&connection.pool_node);
@@ -162,18 +160,15 @@ pub const ConnectionPool = struct {
     /// If the new size is smaller than the current size, then idle connections will be closed until the pool is the new size.
     ///
     /// Threadsafe.
-    pub fn resize(pool: *ConnectionPool, io: Io, allocator: Allocator, new_size: usize) void {
-        pool.mutex.lockUncancelable(io);
+    pub fn resize(pool: *ConnectionPool, io: Io, new_size: usize) Io.Cancelable!void {
+        try pool.mutex.lock(io);
         defer pool.mutex.unlock(io);
 
-        const next = pool.free.first;
-        _ = next;
         while (pool.free_len > new_size) {
-            const popped = pool.free.popFirst() orelse unreachable;
+            const popped: *Connection = @alignCast(@fieldParentPtr("pool_node", pool.free.popFirst().?));
             pool.free_len -= 1;
 
-            popped.data.close(allocator);
-            allocator.destroy(popped);
+            popped.destroy(io);
         }
 
         pool.free_size = new_size;
@@ -1323,7 +1318,7 @@ pub fn initDefaultProxies(client: *Client, arena: Allocator, environ_map: *const
     const io = client.io;
 
     // Prevent any new connections from being created.
-    client.connection_pool.mutex.lockUncancelable(io);
+    try client.connection_pool.mutex.lock(io);
     defer client.connection_pool.mutex.unlock(io);
 
     assert(client.connection_pool.used.first == null); // There are active requests.
@@ -1418,7 +1413,7 @@ pub const basic_authorization = struct {
 
 pub const ConnectTcpError = error{
     TlsInitializationFailed,
-} || Allocator.Error || HostName.ConnectError;
+} || Allocator.Error || HostName.ConnectError || Io.Cancelable;
 
 /// Reuses a `Connection` if one matching `host` and `port` is already open.
 ///
@@ -1451,7 +1446,7 @@ pub fn connectTcpOptions(client: *Client, options: ConnectTcpOptions) ConnectTcp
     const proxied_host = options.proxied_host orelse host;
     const proxied_port = options.proxied_port orelse port;
 
-    if (client.connection_pool.findConnection(io, .{
+    if (try client.connection_pool.findConnection(io, .{
         .host = proxied_host,
         .port = proxied_port,
         .protocol = protocol,
@@ -1469,18 +1464,20 @@ pub fn connectTcpOptions(client: *Client, options: ConnectTcpOptions) ConnectTcp
                 error.Canceled => |e| return e,
                 else => return error.TlsInitializationFailed,
             };
-            client.connection_pool.addUsed(io, &tc.connection);
+            errdefer tc.destroy();
+            try client.connection_pool.addUsed(io, &tc.connection);
             return &tc.connection;
         },
         .plain => {
             const pc = try Connection.Plain.create(client, proxied_host, proxied_port, stream);
-            client.connection_pool.addUsed(io, &pc.connection);
+            errdefer pc.destroy();
+            try client.connection_pool.addUsed(io, &pc.connection);
             return &pc.connection;
         },
     }
 }
 
-pub const ConnectUnixError = Allocator.Error || std.posix.SocketError || error{NameTooLong} || std.posix.ConnectError;
+pub const ConnectUnixError = Allocator.Error || std.posix.SocketError || error{NameTooLong} || std.posix.ConnectError || Io.Cancelable;
 
 /// Connect to `path` as a unix domain socket. This will reuse a connection if one is already open.
 ///
@@ -1488,7 +1485,7 @@ pub const ConnectUnixError = Allocator.Error || std.posix.SocketError || error{N
 pub fn connectUnix(client: *Client, path: []const u8) ConnectUnixError!*Connection {
     const io = client.io;
 
-    if (client.connection_pool.findConnection(io, .{
+    if (try client.connection_pool.findConnection(io, .{
         .host = path,
         .port = 0,
         .protocol = .plain,
@@ -1512,7 +1509,7 @@ pub fn connectUnix(client: *Client, path: []const u8) ConnectUnixError!*Connecti
     };
     errdefer client.allocator.free(conn.data.host);
 
-    client.connection_pool.addUsed(conn);
+    try client.connection_pool.addUsed(conn);
 
     return &conn.data;
 }
@@ -1530,7 +1527,7 @@ pub fn connectProxied(
     const io = client.io;
     if (!proxy.supports_connect) return error.TunnelNotSupported;
 
-    if (client.connection_pool.findConnection(io, .{
+    if (try client.connection_pool.findConnection(io, .{
         .host = proxied_host,
         .port = proxied_port,
         .protocol = proxy.protocol,