upgrade to zig 0.12

0.12.0-dev.3439+31a7f22b8

src/async/Client.zig

@@ -247,7 +247,7 @@ pub const Connection = struct {
     read_buf: [buffer_size]u8 = undefined,
     write_buf: [buffer_size]u8 = undefined,
 
-    pub fn readvDirectTls(conn: *Connection, buffers: []std.os.iovec) ReadError!usize {
+    pub fn readvDirectTls(conn: *Connection, buffers: []std.posix.iovec) ReadError!usize {
         return conn.tls_client.readv(conn.stream, buffers) catch |err| {
             // https://github.com/ziglang/zig/issues/2473
             if (mem.startsWith(u8, @errorName(err), "TlsAlert")) return error.TlsAlert;
@@ -261,7 +261,7 @@ pub const Connection = struct {
         };
     }
 
-    pub fn readvDirect(conn: *Connection, buffers: []std.os.iovec) ReadError!usize {
+    pub fn readvDirect(conn: *Connection, buffers: []std.posix.iovec) ReadError!usize {
         if (conn.protocol == .tls) {
             if (disable_tls) unreachable;
 
@@ -279,7 +279,7 @@ pub const Connection = struct {
     pub fn fill(conn: *Connection) ReadError!void {
         if (conn.read_end != conn.read_start) return;
 
-        var iovecs = [1]std.os.iovec{
+        var iovecs = [1]std.posix.iovec{
             .{ .iov_base = &conn.read_buf, .iov_len = conn.read_buf.len },
         };
         const nread = try conn.readvDirect(&iovecs);
@@ -315,7 +315,7 @@ pub const Connection = struct {
             return available_read;
         }
 
-        var iovecs = [2]std.os.iovec{
+        var iovecs = [2]std.posix.iovec{
             .{ .iov_base = buffer.ptr, .iov_len = buffer.len },
             .{ .iov_base = &conn.read_buf, .iov_len = conn.read_buf.len },
         };

src/async/stream.zig

@@ -18,7 +18,7 @@
 
 const std = @import("std");
 const builtin = @import("builtin");
-const os = std.os;
+const posix = std.posix;
 const io = std.io;
 const assert = std.debug.assert;
 
@@ -28,15 +28,15 @@ pub const Stream = struct {
     alloc: std.mem.Allocator,
     conn: *tcp.Conn,
 
-    handle: std.os.socket_t,
+    handle: posix.socket_t,
 
     pub fn close(self: Stream) void {
-        os.closeSocket(self.handle);
+        posix.closeSocket(self.handle);
         self.alloc.destroy(self.conn);
     }
 
-    pub const ReadError = os.ReadError;
-    pub const WriteError = os.WriteError;
+    pub const ReadError = posix.ReadError;
+    pub const WriteError = posix.WriteError;
 
     pub const Reader = io.Reader(Stream, ReadError, read);
     pub const Writer = io.Writer(Stream, WriteError, write);
@@ -55,8 +55,8 @@ pub const Stream = struct {
         };
     }
 
-    pub fn readv(s: Stream, iovecs: []const os.iovec) ReadError!usize {
-        return os.readv(s.handle, iovecs);
+    pub fn readv(s: Stream, iovecs: []const posix.iovec) ReadError!usize {
+        return posix.readv(s.handle, iovecs);
     }
 
     /// Returns the number of bytes read. If the number read is smaller than
@@ -105,7 +105,7 @@ pub const Stream = struct {
 
     /// See https://github.com/ziglang/zig/issues/7699
     /// See equivalent function: `std.fs.File.writev`.
-    pub fn writev(self: Stream, iovecs: []const os.iovec_const) WriteError!usize {
+    pub fn writev(self: Stream, iovecs: []const posix.iovec_const) WriteError!usize {
         if (iovecs.len == 0) return 0;
         const first_buffer = iovecs[0].iov_base[0..iovecs[0].iov_len];
         return try self.write(first_buffer);
@@ -115,7 +115,7 @@ pub const Stream = struct {
     /// order to handle partial writes from the underlying OS layer.
     /// See https://github.com/ziglang/zig/issues/7699
     /// See equivalent function: `std.fs.File.writevAll`.
-    pub fn writevAll(self: Stream, iovecs: []os.iovec_const) WriteError!void {
+    pub fn writevAll(self: Stream, iovecs: []posix.iovec_const) WriteError!void {
         if (iovecs.len == 0) return;
 
         var i: usize = 0;

src/async/tcp.zig

@@ -59,19 +59,19 @@ pub const Conn = struct {
 
     loop: *Loop,
 
-    pub fn connect(self: *Conn, socket: std.os.socket_t, address: std.net.Address) !void {
+    pub fn connect(self: *Conn, socket: std.posix.socket_t, address: std.net.Address) !void {
         var cmd = Command{ .impl = NetworkImpl.init(self.loop) };
         cmd.impl.connect(&cmd, socket, address);
         _ = try cmd.wait();
     }
 
-    pub fn send(self: *Conn, socket: std.os.socket_t, buffer: []const u8) !usize {
+    pub fn send(self: *Conn, socket: std.posix.socket_t, buffer: []const u8) !usize {
         var cmd = Command{ .impl = NetworkImpl.init(self.loop) };
         cmd.impl.send(&cmd, socket, buffer);
         return try cmd.wait();
     }
 
-    pub fn receive(self: *Conn, socket: std.os.socket_t, buffer: []u8) !usize {
+    pub fn receive(self: *Conn, socket: std.posix.socket_t, buffer: []u8) !usize {
         var cmd = Command{ .impl = NetworkImpl.init(self.loop) };
         cmd.impl.receive(&cmd, socket, buffer);
         return try cmd.wait();
@@ -93,12 +93,12 @@ pub fn tcpConnectToHost(alloc: std.mem.Allocator, loop: *Loop, name: []const u8,
             else => return err,
         };
     }
-    return std.os.ConnectError.ConnectionRefused;
+    return std.posix.ConnectError.ConnectionRefused;
 }
 
 pub fn tcpConnectToAddress(alloc: std.mem.Allocator, loop: *Loop, addr: net.Address) !Stream {
-    const sockfd = try std.os.socket(addr.any.family, std.os.SOCK.STREAM, std.os.IPPROTO.TCP);
-    errdefer std.os.closeSocket(sockfd);
+    const sockfd = try std.posix.socket(addr.any.family, std.posix.SOCK.STREAM, std.posix.IPPROTO.TCP);
+    errdefer std.posix.closeSocket(sockfd);
 
     var conn = try alloc.create(Conn);
     conn.* = Conn{ .loop = loop };