Merge remote-tracking branch 'origin/main' into nektro-patch-763

src/bun.js/ipc.zig

@@ -397,7 +397,7 @@ pub const SendHandle = struct {
 
 pub const WindowsWrite = struct {
     write_req: uv.uv_write_t = std.mem.zeroes(uv.uv_write_t),
-    write_buffer: uv.uv_buf_t = uv.uv_buf_t.init(""),
+    write_buffer: uv.uv_buf_t_const = .init(""),
     write_slice: []const u8,
     owner: ?*SendQueue,
     pub fn destroy(self: *WindowsWrite) void {
@@ -809,7 +809,7 @@ pub const SendQueue = struct {
                     .owner = this,
                     .write_slice = write_req_slice,
                     .write_req = std.mem.zeroes(uv.uv_write_t),
-                    .write_buffer = uv.uv_buf_t.init(write_req_slice),
+                    .write_buffer = .init(write_req_slice),
                 });
                 bun.assert(this.windows.windows_write == null);
                 this.windows.windows_write = write_req;

src/bun.js/node/node_fs.zig

@@ -202,14 +202,13 @@ pub const Async = struct {
                     },
                     .write => {
                         const args: Arguments.Write = task.args;
-                        const B = uv.uv_buf_t.init;
                         const fd = args.fd.uv();
 
                         var buf = args.buffer.slice();
                         buf = buf[@min(buf.len, args.offset)..];
                         buf = buf[0..@min(buf.len, args.length)];
 
-                        const rc = uv.uv_fs_write(loop, &task.req, fd, &.{B(buf)}, 1, args.position orelse -1, &uv_callback);
+                        const rc = uv.uv_fs_write(loop, &task.req, fd, &.{.init(buf)}, 1, args.position orelse -1, &uv_callback);
                         bun.debugAssert(rc == .zero);
                         log("uv write({d}) = scheduled", .{fd});
                     },
@@ -242,7 +241,7 @@ pub const Async = struct {
                         var sum: u64 = 0;
                         for (bufs) |b| sum += b.slice().len;
 
-                        const rc = uv.uv_fs_write(loop, &task.req, fd, bufs.ptr, @intCast(bufs.len), pos, &uv_callback);
+                        const rc = uv.uv_fs_write(loop, &task.req, fd, @ptrCast(bufs.ptr), @intCast(bufs.len), pos, &uv_callback);
                         bun.debugAssert(rc == .zero);
                         log("uv writev({d}, {*}, {d}, {d}, {d} total bytes) = scheduled", .{ fd, bufs.ptr, bufs.len, pos, sum });
                     },

src/bun.js/webcore/blob/write_file.zig

@@ -344,7 +344,7 @@ pub const WriteFileWindows = struct {
     onCompleteCallback: WriteFileOnWriteFileCallback,
     onCompleteCtx: *anyopaque,
     mkdirp_if_not_exists: bool = false,
-    uv_bufs: [1]uv.uv_buf_t,
+    uv_bufs: [1]uv.uv_buf_t_const,
 
     fd: uv.uv_file = -1,
     err: ?bun.sys.Error = null,

src/bun.zig

@@ -254,18 +254,16 @@ else
     std.posix.iovec;
 
 pub const PlatformIOVecConst = if (Environment.isWindows)
-    windows.libuv.uv_buf_t
+    windows.libuv.uv_buf_t_const
 else
     std.posix.iovec_const;
 
-pub fn platformIOVecCreate(input: []const u8) PlatformIOVec {
-    // TODO: remove this constCast by making the input mutable
-    return .{ .len = @truncate(input.len), .base = @constCast(input.ptr) };
+pub fn platformIOVecCreate(input: []u8) PlatformIOVec {
+    return .{ .len = @truncate(input.len), .base = input.ptr };
 }
 
 pub fn platformIOVecConstCreate(input: []const u8) PlatformIOVecConst {
-    // TODO: remove this constCast by adding uv_buf_t_const
-    return .{ .len = @truncate(input.len), .base = @constCast(input.ptr) };
+    return .{ .len = @truncate(input.len), .base = input.ptr };
 }
 
 pub fn platformIOVecToSlice(iovec: PlatformIOVec) []u8 {

src/deps/libuv.zig

@@ -728,9 +728,22 @@ pub const uv_buf_t = extern struct {
     len: ULONG,
     base: [*]u8,
 
-    pub fn init(input: []const u8) uv_buf_t {
+    pub fn init(input: []u8) uv_buf_t {
         bun.assert(input.len <= @as(usize, std.math.maxInt(ULONG)));
-        return .{ .len = @truncate(input.len), .base = @constCast(input.ptr) };
+        return .{ .len = @truncate(input.len), .base = input.ptr };
+    }
+
+    pub fn slice(this: *const @This()) []u8 {
+        return this.base[0..this.len];
+    }
+};
+pub const uv_buf_t_const = extern struct {
+    len: ULONG,
+    base: [*]const u8,
+
+    pub fn init(input: []const u8) uv_buf_t_const {
+        bun.assert(input.len <= @as(usize, std.math.maxInt(ULONG)));
+        return .{ .len = @truncate(input.len), .base = input.ptr };
     }
 
     pub fn slice(this: *const @This()) []u8 {
@@ -1257,11 +1270,11 @@ pub const struct_uv_write_s = extern struct {
     send_handle: *uv_stream_t,
     handle: *uv_stream_t,
     coalesced: c_int,
-    write_buffer: uv_buf_t,
+    write_buffer: uv_buf_t_const,
     event_handle: HANDLE,
     wait_handle: HANDLE,
 
-    pub fn write(req: *@This(), stream: *uv_stream_t, input: *uv_buf_t, context: anytype, comptime onWrite: ?*const (fn (@TypeOf(context), status: ReturnCode) void)) Maybe(void) {
+    pub fn write(req: *@This(), stream: *uv_stream_t, input: *uv_buf_t_const, context: anytype, comptime onWrite: ?*const (fn (@TypeOf(context), status: ReturnCode) void)) Maybe(void) {
         if (comptime onWrite) |callback| {
             const Wrapper = struct {
                 pub fn uvWriteCb(handler: *uv_write_t, status: ReturnCode) callconv(.C) void {
@@ -1271,7 +1284,7 @@ pub const struct_uv_write_s = extern struct {
 
             req.data = context;
 
-            const rc = uv_write(req, stream, @ptrCast(input), 1, &Wrapper.uvWriteCb);
+            const rc = uv_write(req, stream, input[0..1], 1, &Wrapper.uvWriteCb);
             bun.sys.syslog("uv_write({d}) = {d}", .{ input.len, rc.int() });
 
             if (rc.toError(.write)) |err| {
@@ -2222,7 +2235,7 @@ pub extern fn uv_listen(stream: [*c]uv_stream_t, backlog: c_int, cb: uv_connecti
 pub extern fn uv_accept(server: [*c]uv_stream_t, client: [*c]uv_stream_t) ReturnCode;
 pub extern fn uv_read_start(*uv_stream_t, alloc_cb: uv_alloc_cb, read_cb: uv_read_cb) ReturnCode;
 pub extern fn uv_read_stop(*uv_stream_t) ReturnCode;
-pub extern fn uv_write(req: *uv_write_t, handle: *uv_stream_t, bufs: [*]const uv_buf_t, nbufs: c_uint, cb: uv_write_cb) ReturnCode;
+pub extern fn uv_write(req: *uv_write_t, handle: *uv_stream_t, bufs: [*]const uv_buf_t_const, nbufs: c_uint, cb: uv_write_cb) ReturnCode;
 pub extern fn uv_write2(req: *uv_write_t, handle: *uv_stream_t, bufs: [*]const uv_buf_t, nbufs: c_uint, send_handle: *uv_stream_t, cb: uv_write_cb) ReturnCode;
 pub extern fn uv_try_write(handle: *uv_stream_t, bufs: [*]const uv_buf_t, nbufs: c_uint) ReturnCode;
 pub extern fn uv_try_write2(handle: *uv_stream_t, bufs: [*]const uv_buf_t, nbufs: c_uint, send_handle: *uv_stream_t) c_int;
@@ -2518,7 +2531,7 @@ pub extern fn uv_fs_close(loop: *uv_loop_t, req: *fs_t, file: uv_file, cb: uv_fs
 pub extern fn uv_fs_open(loop: *uv_loop_t, req: *fs_t, path: [*:0]const u8, flags: c_int, mode: c_int, cb: uv_fs_cb) ReturnCode;
 pub extern fn uv_fs_read(loop: *uv_loop_t, req: *fs_t, file: uv_file, bufs: [*]const uv_buf_t, nbufs: c_uint, offset: i64, cb: uv_fs_cb) ReturnCode;
 pub extern fn uv_fs_unlink(loop: *uv_loop_t, req: *fs_t, path: [*:0]const u8, cb: uv_fs_cb) ReturnCode;
-pub extern fn uv_fs_write(loop: *uv_loop_t, req: *fs_t, file: uv_file, bufs: [*]const uv_buf_t, nbufs: c_uint, offset: i64, cb: uv_fs_cb) ReturnCode;
+pub extern fn uv_fs_write(loop: *uv_loop_t, req: *fs_t, file: uv_file, bufs: [*]const uv_buf_t_const, nbufs: c_uint, offset: i64, cb: uv_fs_cb) ReturnCode;
 pub extern fn uv_fs_copyfile(loop: *uv_loop_t, req: *fs_t, path: [*:0]const u8, new_path: [*:0]const u8, flags: c_int, cb: uv_fs_cb) ReturnCode;
 pub extern fn uv_fs_mkdir(loop: *uv_loop_t, req: *fs_t, path: [*:0]const u8, mode: c_int, cb: uv_fs_cb) ReturnCode;
 pub extern fn uv_fs_mkdtemp(loop: *uv_loop_t, req: *fs_t, tpl: [*:0]const u8, cb: uv_fs_cb) ReturnCode;

src/io/PipeWriter.zig

@@ -940,7 +940,7 @@ pub fn WindowsBufferedWriter(Parent: type, function_table: anytype) type {
         is_done: bool = false,
         // we use only one write_req, any queued data in outgoing will be flushed after this ends
         write_req: uv.uv_write_t = std.mem.zeroes(uv.uv_write_t),
-        write_buffer: uv.uv_buf_t = uv.uv_buf_t.init(""),
+        write_buffer: uv.uv_buf_t_const = .init(""),
         pending_payload_size: usize = 0,
 
         const onWrite: *const fn (*Parent, amount: usize, status: WriteStatus) void = function_table.onWrite;
@@ -1057,7 +1057,7 @@ pub fn WindowsBufferedWriter(Parent: type, function_table: anytype) type {
                     this.pending_payload_size = buffer.len;
                     file.fs.setData(this);
                     file.prepare();
-                    this.write_buffer = uv.uv_buf_t.init(buffer);
+                    this.write_buffer = .init(buffer);
 
                     if (uv.uv_fs_write(uv.Loop.get(), &file.fs, file.file, @ptrCast(&this.write_buffer), 1, -1, onFsWriteComplete).toError(.write)) |err| {
                         file.complete(false);
@@ -1068,7 +1068,7 @@ pub fn WindowsBufferedWriter(Parent: type, function_table: anytype) type {
                 else => {
                     // the buffered version should always have a stable ptr
                     this.pending_payload_size = buffer.len;
-                    this.write_buffer = uv.uv_buf_t.init(buffer);
+                    this.write_buffer = .init(buffer);
                     if (this.write_req.write(pipe.toStream(), &this.write_buffer, this, onWriteComplete).asErr()) |write_err| {
                         this.close();
                         onError(this.parent, write_err);
@@ -1237,7 +1237,7 @@ pub fn WindowsStreamingWriter(comptime Parent: type, function_table: anytype) ty
         is_done: bool = false,
         // we use only one write_req, any queued data in outgoing will be flushed after this ends
         write_req: uv.uv_write_t = std.mem.zeroes(uv.uv_write_t),
-        write_buffer: uv.uv_buf_t = uv.uv_buf_t.init(""),
+        write_buffer: uv.uv_buf_t_const = .init(""),
 
         // queue any data that we want to write here
         outgoing: StreamBuffer = .{},
@@ -1402,7 +1402,7 @@ pub fn WindowsStreamingWriter(comptime Parent: type, function_table: anytype) ty
 
                     file.fs.setData(this);
                     file.prepare();
-                    this.write_buffer = uv.uv_buf_t.init(bytes);
+                    this.write_buffer = .init(bytes);
 
                     if (uv.uv_fs_write(uv.Loop.get(), &file.fs, file.file, @ptrCast(&this.write_buffer), 1, -1, onFsWriteComplete).toError(.write)) |err| {
                         file.complete(false);
@@ -1414,7 +1414,7 @@ pub fn WindowsStreamingWriter(comptime Parent: type, function_table: anytype) ty
                 },
                 else => {
                     // enqueue the write
-                    this.write_buffer = uv.uv_buf_t.init(bytes);
+                    this.write_buffer = .init(bytes);
                     if (this.write_req.write(pipe.toStream(), &this.write_buffer, this, onWriteComplete).asErr()) |err| {
                         this.last_write_result = .{ .err = err };
                         onError(this.parent, err);

src/sys_uv.zig

@@ -362,21 +362,21 @@ pub inline fn pread(fd: FileDescriptor, buf: []u8, position: i64) Maybe(usize) {
 }
 
 pub inline fn read(fd: FileDescriptor, buf: []u8) Maybe(usize) {
-    var bufs: [1]bun.PlatformIOVec = .{bun.platformIOVecCreate(buf)};
+    var bufs: [1]bun.PlatformIOVec = .{.init(buf)};
     return readv(fd, &bufs);
 }
 
-pub inline fn writev(fd: FileDescriptor, bufs: []bun.PlatformIOVec) Maybe(usize) {
+pub inline fn writev(fd: FileDescriptor, bufs: []const bun.PlatformIOVecConst) Maybe(usize) {
     return pwritev(fd, bufs, -1);
 }
 
 pub inline fn pwrite(fd: FileDescriptor, buf: []const u8, position: i64) Maybe(usize) {
-    var bufs: [1]bun.PlatformIOVec = .{bun.platformIOVecCreate(buf)};
+    var bufs: [1]bun.PlatformIOVecConst = .{.init(buf)};
     return pwritev(fd, &bufs, position);
 }
 
 pub inline fn write(fd: FileDescriptor, buf: []const u8) Maybe(usize) {
-    var bufs: [1]bun.PlatformIOVec = .{bun.platformIOVecCreate(buf)};
+    var bufs: [1]bun.PlatformIOVecConst = .{.init(buf)};
     return writev(fd, &bufs);
 }