fix for writergate + delete BoudedArray + update to lastest zig

Nyaa97 · Nyaa97 · commit e4a8fb8bf93d · 2025-08-13T21:58:51.000+02:00
diff --git a/docs/pages/coro-blocking-code.mdx b/docs/pages/coro-blocking-code.mdx
@@ -10,7 +10,7 @@ finishes on a worker thread.
 
 ```zig
 fn blockingCode() u32 {
-    std.time.sleep(1 * std.time.ns_per_s);
+    std.Thread.sleep(1 * std.time.ns_per_s);
     return 69;
 }
 
diff --git a/examples/coro_wttr.zig b/examples/coro_wttr.zig
@@ -10,19 +10,21 @@ pub const std_options: std.Options = .{
 
 fn getWeather(completed: *std.atomic.Value(u32), allocator: std.mem.Allocator, city: []const u8, lang: []const u8) anyerror![]const u8 {
     defer _ = completed.fetchAdd(1, .monotonic);
-    var url: std.BoundedArray(u8, 256) = .{};
+    var buf: [256]u8 = undefined;
+    var url: std.ArrayListUnmanaged(u8) = .initBuffer(&buf);
     if (builtin.target.os.tag == .windows) {
-        try url.writer().print("https://wttr.in/{s}?AFT&lang={s}", .{ city, lang });
+        try url.fixedWriter().print("https://wttr.in/{s}?AFT&lang={s}", .{ city, lang });
     } else {
-        try url.writer().print("https://wttr.in/{s}?AF&lang={s}", .{ city, lang });
+        try url.fixedWriter().print("https://wttr.in/{s}?AF&lang={s}", .{ city, lang });
     }
     var body = std.ArrayList(u8).init(allocator);
     errdefer body.deinit();
     var client: std.http.Client = .{ .allocator = allocator };
     defer client.deinit();
+    var writer = body.writer().adaptToNewApi();
     _ = try client.fetch(.{
-        .location = .{ .url = url.constSlice() },
-        .response_storage = .{ .dynamic = &body },
+        .location = .{ .url = &buf },
+        .response_writer = &writer.new_interface,
     });
     return body.toOwnedSlice();
 }
@@ -33,9 +35,10 @@ fn getLatestZig(completed: *std.atomic.Value(u32), allocator: std.mem.Allocator)
     defer body.deinit();
     var client: std.http.Client = .{ .allocator = allocator };
     defer client.deinit();
+    var writer = body.writer().adaptToNewApi();
     _ = try client.fetch(.{
         .location = .{ .url = "https://ziglang.org/download/index.json" },
-        .response_storage = .{ .dynamic = &body },
+        .response_writer = &writer.new_interface,
     });
     const Index = struct {
         master: struct { version: []const u8 },
@@ -102,18 +105,20 @@ pub fn main() !void {
     // don't really have to call this, but I want the defer that cleans the progress bar to run
     ltask.cancel();
 
+    var buf: [std.heap.pageSize()]u8 = undefined;
+    var writer = std.fs.File.stdout().writer(&buf);
     for (tasks.items, 0..) |task, idx| {
         if (task.complete(.wait)) |body| {
             defer allocator.free(body);
             if (idx == 3) {
-                try std.io.getStdOut().writer().print("\nAaand the current master zig version is... ", .{});
+                try writer.interface.print("\nAaand the current master zig version is... ", .{});
             }
-            try std.io.getStdOut().writeAll(body);
-            try std.io.getStdOut().writeAll("\n");
+            try writer.interface.writeAll(body);
+            try writer.interface.writeAll("\n");
         } else |err| {
-            try std.io.getStdOut().writer().print("request {} failed with: {}\n", .{ idx, err });
+            try writer.interface.print("request {} failed with: {}\n", .{ idx, err });
         }
     }
 
-    try std.io.getStdOut().writer().print("\nThat's all folks\n", .{});
+    try writer.interface.print("\nThat's all folks\n", .{});
 }
diff --git a/src/aio/IoUring.zig b/src/aio/IoUring.zig
@@ -3,7 +3,6 @@ const aio = @import("../aio.zig");
 const Operation = @import("ops.zig").Operation;
 const posix = @import("posix/posix.zig");
 const linux = @import("posix/linux.zig");
-const BoundedArray = @import("minilib").BoundedArray;
 const log = std.log.scoped(.aio_io_uring);
 
 const Supported = struct {
@@ -160,14 +159,15 @@ pub fn queue(self: *@This(), pairs: anytype, handler: anytype) aio.Error!void {
     const saved_sq = self.io.sq;
     errdefer self.io.sq = saved_sq;
     if (comptime pairs.len > 1) {
-        var ids: BoundedArray(aio.Id, pairs.len) = .{};
-        errdefer inline for (ids.constSlice(), pairs) |id, pair| {
+        var buf: [pairs.len]aio.Id = undefined;
+        var ids: std.ArrayListUnmanaged(aio.Id) = .initBuffer(&buf);
+        errdefer inline for (buf, pairs) |id, pair| {
             debug("dequeue: {f}: {any}, {s}", .{ id, pair.tag, @tagName(pair.link) });
             self.ops.release(id) catch unreachable;
         };
-        inline for (pairs) |pair| ids.append(try self.queueOperation(pair.tag, pair.op, pair.link)) catch unreachable;
+        inline for (pairs) |pair| ids.appendAssumeCapacity(try self.queueOperation(pair.tag, pair.op, pair.link));
         if (@TypeOf(handler) != void) {
-            inline for (ids.constSlice(), pairs) |id, pair| {
+            inline for (buf, pairs) |id, pair| {
                 handler.aio_queue(id, pair.op.userdata);
             }
         }
diff --git a/src/aio/posix/wasi.zig b/src/aio/posix/wasi.zig
@@ -207,11 +207,12 @@ fn clock(userdata: usize, timeout: i32) std.os.wasi.subscription_t {
 pub fn poll(fds: []std.posix.pollfd, timeout: i32) std.posix.PollError!usize {
     // TODO: maybe use thread local arena instead?
     const MAX_POLL_FDS = 4096;
-    var subs: std.BoundedArray(std.os.wasi.subscription_t, MAX_POLL_FDS) = .{};
+    var buf: [MAX_POLL_FDS]std.os.wasi.subscription_t = undefined;
+    var subs: std.ArrayListUnmanaged(std.os.wasi.subscription_t) = .initBuffer(&buf);
     for (fds) |*pfd| {
         pfd.revents = 0;
         if (pfd.events & std.posix.POLL.IN != 0) {
-            subs.append(.{
+            subs.appendBounded(.{
                 .userdata = @intFromPtr(pfd),
                 .u = .{
                     .tag = .FD_READ,
@@ -220,7 +221,7 @@ pub fn poll(fds: []std.posix.pollfd, timeout: i32) std.posix.PollError!usize {
             }) catch return error.SystemResources;
         }
         if (pfd.events & std.posix.POLL.OUT != 0) {
-            subs.append(.{
+            subs.appendBounded(.{
                 .userdata = @intFromPtr(pfd),
                 .u = .{
                     .tag = .FD_WRITE,
@@ -235,12 +236,12 @@ pub fn poll(fds: []std.posix.pollfd, timeout: i32) std.posix.PollError!usize {
     }
 
     if (timeout >= 0) {
-        subs.append(clock(0, timeout)) catch return error.SystemResources;
+        subs.appendBounded(clock(0, timeout)) catch return error.SystemResources;
     }
 
     var n: usize = 0;
     var events: [MAX_POLL_FDS]std.os.wasi.event_t = undefined;
-    switch (std.os.wasi.poll_oneoff(@ptrCast(subs.constSlice().ptr), @ptrCast(events[0..subs.len].ptr), subs.len, &n)) {
+    switch (std.os.wasi.poll_oneoff(@ptrCast(&buf), @ptrCast(events[0..subs.len].ptr), subs.len, &n)) {
         .SUCCESS => {},
         else => |e| {
             log.err("poll: {}", .{e});
diff --git a/src/aio/uringlator.zig b/src/aio/uringlator.zig
@@ -5,7 +5,6 @@ const aio = @import("../aio.zig");
 const Operation = @import("ops.zig").Operation;
 const DoubleBufferedFixedArrayList = @import("minilib").DoubleBufferedFixedArrayList;
 const FixedArrayList = @import("minilib").FixedArrayList;
-const BoundedArray = @import("minilib").BoundedArray;
 const posix = @import("posix/posix.zig");
 const log = std.log.scoped(.aio_uringlator);
 
@@ -284,16 +283,17 @@ pub fn Uringlator(BackendOperation: type) type {
 
         pub fn queue(self: *@This(), pairs: anytype, backend: anytype, handler: anytype) aio.Error!void {
             if (comptime pairs.len > 1) {
-                var ids: BoundedArray(aio.Id, pairs.len) = .{};
-                errdefer inline for (ids.constSlice(), pairs) |id, pair| {
-                    debug("dequeue: {f}: {any}, {s} ({?f})", .{ id, pair.tag, @tagName(pair.link), self.prev_id });
+                var buf: [pairs.len]aio.Id = undefined;
+                var ids: std.ArrayListUnmanaged(aio.Id) = .initBuffer(&buf);
+                errdefer inline for (buf, pairs) |id, pair| {
+                    debug("dequeue: {f}: {any}, {s} ({any})", .{ id, pair.tag, @tagName(pair.link), self.prev_id });
                     backend.uringlator_dequeue(id, pair.tag, pair.op);
                     self.ops.release(id) catch unreachable;
                 };
-                inline for (pairs) |pair| ids.append(try self.queueOperation(pair.tag, pair.op, pair.link, backend)) catch unreachable;
-                inline for (ids.constSlice()[0..pairs.len]) |id| self.queued.add(id) catch unreachable;
+                inline for (pairs) |pair| ids.appendAssumeCapacity(try self.queueOperation(pair.tag, pair.op, pair.link, backend));
+                inline for (buf) |id| self.queued.add(id) catch unreachable;
                 if (@TypeOf(handler) != void) {
-                    inline for (ids.constSlice(), pairs) |id, pair| handler.aio_queue(id, pair.op.userdata);
+                    inline for (buf, pairs) |id, pair| handler.aio_queue(id, pair.op.userdata);
                 }
             } else {
                 inline for (pairs) |pair| {
diff --git a/src/minilib.zig b/src/minilib.zig
@@ -3,7 +3,6 @@ pub const FixedArrayList = @import("minilib/fixed_array_list.zig").FixedArrayLis
 pub const DoubleBufferedFixedArrayList = @import("minilib/fixed_array_list.zig").DoubleBufferedFixedArrayList;
 pub const Id = @import("minilib/id.zig").Id;
 pub const TimerQueue = @import("minilib/TimerQueue.zig");
-pub const BoundedArray = @import("minilib/bounded_array.zig").BoundedArray;
 
 const std = @import("std");
 
diff --git a/src/minilib/bounded_array.zig b/src/minilib/bounded_array.zig

Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ finishes on a worker thread.`
`10`	`10`
`11`	`11`	```zig
`12`	`12`	`fn blockingCode() u32 {`
`13`		`- std.time.sleep(1 * std.time.ns_per_s);`
	`13`	`+ std.Thread.sleep(1 * std.time.ns_per_s);`
`14`	`14`	`return 69;`
`15`	`15`	`}`
`16`	`16`