Address review feedback

- Remove unnecessary @truncate for i32->i32 conversions
- Remove unnecessary @as(usize) cast for result.items.len
- Use @intCast where maxInt checks ensure safe conversion
- Revert skip function change that didn't add value

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

src/sql/postgres/DataCell.zig

@@ -418,7 +418,7 @@ fn parseArray(bytes: []const u8, bigint: bool, comptime arrayType: types.Tag, gl
                                     else => {
                                         const value = std.fmt.parseInt(i32, element, 0) catch return error.UnsupportedArrayFormat;
 
-                                        try array.append(bun.default_allocator, SQLDataCell{ .tag = .int4, .value = .{ .int4 = @intCast(value) } });
+                                        try array.append(bun.default_allocator, SQLDataCell{ .tag = .int4, .value = .{ .int4 = value } });
                                         slice = trySlice(slice, current_idx);
                                         continue;
                                     },
@@ -685,7 +685,7 @@ fn pg_ntoT(comptime IntSize: usize, i: anytype) std.meta.Int(.unsigned, IntSize)
         return pg_ntoT(IntSize, @as(std.meta.Int(.unsigned, IntSize), @bitCast(i)));
     }
 
-    const casted: std.meta.Int(.unsigned, IntSize) = @intCast(i);
+    const casted: std.meta.Int(.unsigned, IntSize) = @truncate(i);
     return @byteSwap(casted);
 }
 fn pg_ntoh16(x: anytype) u16 {
@@ -747,7 +747,7 @@ fn parseBinaryNumeric(input: []const u8, result: *std.ArrayList(u8)) !PGNummeric
     var scale_start: i32 = 0;
     if (weight < 0) {
         try result.append('0');
-        scale_start = @as(i32, @intCast(weight)) + 1;
+        scale_start = @as(i32, weight) + 1;
     } else {
         var idx: usize = 0;
         var first_non_zero = false;
@@ -776,7 +776,7 @@ fn parseBinaryNumeric(input: []const u8, result: *std.ArrayList(u8)) !PGNummeric
         // negative scale means we need to add zeros before the decimal point
         // greater than ndigits means we need to add zeros after the decimal point
         var idx: isize = scale_start;
-        const end: usize = result.items.len + @as(usize, @intCast(dscale));
+        const end: usize = result.items.len + @as(usize, @max(dscale, 0));
         while (idx < dscale) : (idx += 4) {
             if (idx >= 0 and idx < ndigits) {
                 const digit = reader.readInt(u16, .big) catch 0;
@@ -927,7 +927,7 @@ pub const Putter = struct {
             // The indexed columns can be out of order.
             .index => |i| i,
 
-            else => @intCast(index),
+            else => index,
         };
 
         // TODO: when duplicate and we know the result will be an object

src/sql/postgres/PostgresProtocol.zig

@@ -13,7 +13,7 @@ pub const SSLRequest = toBytes(Int32(8)) ++ toBytes(Int32(80877103));
 pub const NoData = [_]u8{'n'} ++ toBytes(Int32(4));
 
 pub fn writeQuery(query: []const u8, comptime Context: type, writer: NewWriter(Context)) !void {
-    const count: u32 = @sizeOf((u32)) + @as(u32, @intCast(query.len)) + 1;
+    const count: u32 = @sizeOf((u32)) + @as(u32, @truncate(query.len)) + 1;
     const header = [_]u8{
         'Q',
     } ++ toBytes(Int32(count));

src/sql/postgres/PostgresSQLConnection.zig

@@ -135,7 +135,7 @@ pub fn resetConnectionTimeout(this: *PostgresSQLConnection) void {
         return;
     }
 
-    this.timer.next = bun.timespec.msFromNow(@intCast(interval));
+    this.timer.next = bun.timespec.msFromNow(@as(i64, interval));
     this.vm.timer.insert(&this.timer);
 }
 
@@ -194,7 +194,7 @@ fn setupMaxLifetimeTimerIfNecessary(this: *PostgresSQLConnection) void {
     if (this.max_lifetime_interval_ms == 0) return;
     if (this.max_lifetime_timer.state == .ACTIVE) return;
 
-    this.max_lifetime_timer.next = bun.timespec.msFromNow(@intCast(this.max_lifetime_interval_ms));
+    this.max_lifetime_timer.next = bun.timespec.msFromNow(@as(i64, this.max_lifetime_interval_ms));
     this.vm.timer.insert(&this.max_lifetime_timer);
 }
 
@@ -301,8 +301,8 @@ pub fn flushData(this: *PostgresSQLConnection) void {
     this.flags.has_backpressure = wrote < chunk.len;
     debug("flushData: wrote {d}/{d} bytes", .{ wrote, chunk.len });
     if (wrote > 0) {
-        SocketMonitor.write(chunk[0..@intCast(wrote)]);
-        this.write_buffer.consume(@intCast(wrote));
+        SocketMonitor.write(chunk[0..@as(usize, @max(wrote, 0))]);
+        this.write_buffer.consume(@as(u32, @max(wrote, 0)));
     }
 }
 
@@ -397,7 +397,7 @@ fn startTLS(this: *PostgresSQLConnection, socket: uws.AnySocket) void {
     const written = socket.write(ssl_request[offset..]);
     if (written > 0) {
         this.tls_status = .{
-            .message_sent = offset + @as(u8, @intCast(written)),
+            .message_sent = offset + @as(u8, @truncate(@as(u32, @max(written, 0)))),
         };
     } else {
         this.tls_status = .{
@@ -714,9 +714,9 @@ pub fn call(globalObject: *jsc.JSGlobalObject, callframe: *jsc.CallFrame) bun.JS
         .tls_ctx = tls_ctx,
         .ssl_mode = ssl_mode,
         .tls_status = if (ssl_mode != .disable) .pending else .none,
-        .idle_timeout_interval_ms = @intCast(idle_timeout),
-        .connection_timeout_ms = @intCast(connection_timeout),
-        .max_lifetime_interval_ms = @intCast(max_lifetime),
+        .idle_timeout_interval_ms = @as(u32, @max(idle_timeout, 0)),
+        .connection_timeout_ms = @as(u32, @max(connection_timeout, 0)),
+        .max_lifetime_interval_ms = @as(u32, @max(max_lifetime, 0)),
         .flags = .{
             .use_unnamed_prepared_statements = use_unnamed_prepared_statements,
         },
@@ -1031,7 +1031,8 @@ pub const Reader = struct {
         return this.connection.read_buffer.remaining();
     }
     pub fn skip(this: Reader, count: usize) void {
-        this.connection.read_buffer.head = @min(this.connection.read_buffer.head + @as(u32, @truncate(count)), this.connection.read_buffer.byte_list.len);
+        const new_head = @as(usize, this.connection.read_buffer.head) + count;
+        this.connection.read_buffer.head = @truncate(@min(new_head, @as(usize, this.connection.read_buffer.byte_list.len)));
     }
     pub fn ensureCapacity(this: Reader, count: usize) bool {
         return @as(usize, this.connection.read_buffer.head) + count <= @as(usize, this.connection.read_buffer.byte_list.len);

src/sql/postgres/PostgresSQLStatement.zig

@@ -49,7 +49,7 @@ pub fn checkForDuplicateFields(this: *PostgresSQLStatement) void {
     var seen_numbers = std.ArrayList(u32).init(bun.default_allocator);
     defer seen_numbers.deinit();
     var seen_fields = bun.StringHashMap(void).init(bun.default_allocator);
-    bun.handleOom(seen_fields.ensureUnusedCapacity(@intCast(this.fields.len)));
+    bun.handleOom(seen_fields.ensureUnusedCapacity(@truncate(this.fields.len)));
     defer seen_fields.deinit();
 
     // iterate backwards

src/sql/postgres/SASL.zig

@@ -56,7 +56,7 @@ pub fn computeServerSignature(this: *SASL, auth_string: []const u8) !void {
 
     const server_key = hmac(this.saltedPassword(), "Server Key") orelse return error.InvalidServerKey;
     const server_signature_bytes = hmac(&server_key, auth_string) orelse return error.InvalidServerSignature;
-    this.server_signature_len = @intCast(bun.base64.encode(&this.server_signature_base64_bytes, &server_signature_bytes));
+    this.server_signature_len = @truncate(bun.base64.encode(&this.server_signature_base64_bytes, &server_signature_bytes));
 }
 
 pub fn clientKey(this: *const SASL) [32]u8 {
@@ -73,7 +73,7 @@ pub fn nonce(this: *SASL) []const u8 {
     if (this.nonce_len == 0) {
         var bytes: [nonce_byte_len]u8 = .{0} ** nonce_byte_len;
         bun.csprng(&bytes);
-        this.nonce_len = @intCast(bun.base64.encode(&this.nonce_base64_bytes, &bytes));
+        this.nonce_len = @truncate(bun.base64.encode(&this.nonce_base64_bytes, &bytes));
     }
     return this.nonce_base64_bytes[0..this.nonce_len];
 }

src/sql/postgres/protocol/CopyData.zig

@@ -5,7 +5,7 @@ data: Data = .{ .empty = {} },
 pub fn decodeInternal(this: *@This(), comptime Container: type, reader: NewReader(Container)) !void {
     const length = try reader.length();
 
-    const data = try reader.read(@intCast(length -| 5));
+    const data = try reader.read(@as(usize, length -| 5));
     this.* = .{
         .data = data,
     };

src/sql/postgres/protocol/DataRow.zig

@@ -2,21 +2,21 @@ pub fn decode(context: anytype, comptime ContextType: type, reader: NewReader(Co
     var remaining_bytes = try reader.length();
     remaining_bytes -|= 4;
 
-    const remaining_fields: usize = @intCast(@max(try reader.short(), 0));
+    const remaining_fields: usize = @as(usize, @max(try reader.short(), 0));
 
     for (0..remaining_fields) |index| {
         const byte_length = try reader.int4();
         switch (byte_length) {
             0 => {
                 var empty = Data.Empty;
-                if (!try forEach(context, @intCast(index), &empty)) break;
+                if (!try forEach(context, @truncate(index), &empty)) break;
             },
             null_int4 => {
-                if (!try forEach(context, @intCast(index), null)) break;
+                if (!try forEach(context, @truncate(index), null)) break;
             },
             else => {
-                var bytes = try reader.bytes(@intCast(byte_length));
-                if (!try forEach(context, @intCast(index), &bytes)) break;
+                var bytes = try reader.bytes(@as(usize, byte_length));
+                if (!try forEach(context, @truncate(index), &bytes)) break;
             },
         }
     }

src/sql/postgres/protocol/NegotiateProtocolVersion.zig

@@ -14,7 +14,7 @@ pub fn decodeInternal(
         .version = version,
     };
 
-    const unrecognized_options_count: u32 = @intCast(@max(try reader.int4(), 0));
+    const unrecognized_options_count: u32 = @max(try reader.int4(), 0);
     try this.unrecognized_options.ensureTotalCapacity(bun.default_allocator, unrecognized_options_count);
     errdefer {
         for (this.unrecognized_options.items) |*option| {

src/sql/postgres/protocol/NewReader.zig

@@ -91,7 +91,7 @@ pub fn NewReaderWrap(
         pub fn length(this: @This()) !PostgresInt32 {
             const expected = try this.int(PostgresInt32);
             if (expected > -1) {
-                try this.ensureCapacity(@intCast(expected -| 4));
+                try this.ensureCapacity(@as(usize, expected -| 4));
             }
 
             return expected;

src/sql/postgres/protocol/NewWriter.zig

@@ -23,11 +23,13 @@ pub fn NewWriterWrap(
             context: WrappedWriter,
 
             pub fn write(this: LengthWriter) AnyPostgresError!void {
-                try this.context.pwrite(&Int32(this.context.offset() - this.index), this.index);
+                const result = @as(usize, this.context.offset()) - @as(usize, this.index);
+                try this.context.pwrite(&Int32(@as(u32, @truncate(result))), this.index);
             }
 
             pub fn writeExcludingSelf(this: LengthWriter) AnyPostgresError!void {
-                try this.context.pwrite(&Int32(this.context.offset() -| (this.index + 4)), this.index);
+                const result = @as(usize, this.context.offset()) -| (@as(usize, this.index) + 4);
+                try this.context.pwrite(&Int32(@as(u32, @truncate(result))), this.index);
             }
         };
 
@@ -69,7 +71,7 @@ pub fn NewWriterWrap(
         }
 
         pub fn short(this: @This(), value: anytype) !void {
-            try this.write(std.mem.asBytes(&@byteSwap(@as(u16, @intCast(value)))));
+            try this.write(std.mem.asBytes(&@byteSwap(@as(u16, @truncate(value)))));
         }
 
         pub fn string(this: @This(), value: []const u8) !void {

src/sql/postgres/protocol/ParameterDescription.zig

@@ -7,9 +7,9 @@ pub fn decodeInternal(this: *@This(), comptime Container: type, reader: NewReade
     remaining_bytes -|= 4;
 
     const count = try reader.short();
-    const parameters = try bun.default_allocator.alloc(int4, @intCast(@max(count, 0)));
+    const parameters = try bun.default_allocator.alloc(int4, @as(usize, @max(count, 0)));
 
-    var data = try reader.read(@as(usize, @intCast(@max(count, 0))) * @sizeOf((int4)));
+    var data = try reader.read(@as(usize, @max(count, 0)) * @sizeOf((int4)));
     defer data.deinit();
     const input_params: []align(1) const int4 = toInt32Slice(int4, data.slice());
     for (input_params, parameters) |src, *dest| {

src/sql/postgres/protocol/RowDescription.zig

@@ -13,7 +13,7 @@ pub fn decodeInternal(this: *@This(), comptime Container: type, reader: NewReade
     var remaining_bytes = try reader.length();
     remaining_bytes -|= 4;
 
-    const field_count: usize = @intCast(@max(try reader.short(), 0));
+    const field_count: usize = @as(usize, @max(try reader.short(), 0));
     var fields = try bun.default_allocator.alloc(
         FieldDescription,
         field_count,

src/sql/postgres/types/Tag.zig

@@ -210,7 +210,7 @@ pub const Tag = enum(short) {
 
                 var head = @as([*]T, @ptrCast(&this.first_value));
                 var current = head;
-                const len: usize = @intCast(this.len);
+                const len: usize = @as(usize, @max(this.len, 0));
                 for (0..len) |i| {
                     // Skip every other value as it contains the size of the element
                     current = current[1..];

src/sql/postgres/types/int_types.zig

@@ -6,5 +6,5 @@ pub const short = u16;
 pub const PostgresShort = u16;
 
 pub fn Int32(value: anytype) [4]u8 {
-    return @bitCast(@byteSwap(@as(int4, @intCast(value))));
+    return @bitCast(@byteSwap(@as(int4, @truncate(value))));
 }