zig upgrade (#3667)

* upgrade

* more fixes

* Bump Zig

---------

Co-authored-by: Jarred Sumner <709451+Jarred-Sumner@users.noreply.github.com>

1 files changed, 93 insertions, 93 deletions

diff --git a/src/bun.js/api/bun.zig b/src/bun.js/api/bun.zig
index 97ad056e8..d63765b16 100644
--- a/src/bun.js/api/bun.zig
+++ b/src/bun.js/api/bun.zig
@@ -105,12 +105,12 @@ pub fn onImportCSS(
     var writer = css_imports_buf.writer();
     const offset = css_imports_buf.items.len;
     css_imports_list[css_imports_list_tail] = .{
-        .offset = @truncate(u32, offset),
+        .offset = @as(u32, @truncate(offset)),
         .length = 0,
     };
     getPublicPath(resolve_result.path_pair.primary.text, origin, @TypeOf(writer), writer);
     const length = css_imports_buf.items.len - offset;
-    css_imports_list[css_imports_list_tail].length = @truncate(u32, length);
+    css_imports_list[css_imports_list_tail].length = @as(u32, @truncate(length));
     css_imports_list_tail += 1;
 }
 
@@ -239,7 +239,7 @@ pub fn inspect(
     ZigConsoleClient.format(
         .Debug,
         ctx.ptr(),
-        @ptrCast([*]const JSValue, arguments.ptr),
+        @as([*]const JSValue, @ptrCast(arguments.ptr)),
         arguments.len,
         Writer,
         Writer,
@@ -303,7 +303,7 @@ pub fn registerMacro(
         return js.JSValueMakeUndefined(ctx);
     }
     // TODO: make this faster
-    const id = @truncate(i32, @intFromFloat(i64, js.JSValueToNumber(ctx, arguments[0], exception)));
+    const id = @as(i32, @truncate(@as(i64, @intFromFloat(js.JSValueToNumber(ctx, arguments[0], exception)))));
     if (id == -1 or id == 0) {
         JSError(getAllocator(ctx), "Internal error registering macros: invalid id", .{}, ctx, exception);
         return js.JSValueMakeUndefined(ctx);
@@ -882,7 +882,7 @@ pub fn sleepSync(
         return ret;
     }
 
-    std.time.sleep(@intCast(u64, milliseconds) * std.time.ns_per_ms);
+    std.time.sleep(@as(u64, @intCast(milliseconds)) * std.time.ns_per_ms);
     return ret;
 }
 
@@ -1398,21 +1398,21 @@ pub fn indexOfLine(
 
     var offset: usize = 0;
     if (arguments.len > 1) {
-        offset = @intCast(
+        offset = @as(
             usize,
-            @max(
+            @intCast(@max(
                 arguments[1].to(u32),
                 0,
-            ),
+            )),
         );
     }
 
     const bytes = buffer.byteSlice();
     var current_offset = offset;
-    const end = @truncate(u32, bytes.len);
+    const end = @as(u32, @truncate(bytes.len));
 
     while (current_offset < end) {
-        if (strings.indexOfNewlineOrNonASCII(bytes, @truncate(u32, current_offset))) |i| {
+        if (strings.indexOfNewlineOrNonASCII(bytes, @as(u32, @truncate(current_offset)))) |i| {
             const byte = bytes[i];
             if (byte > 0x7F) {
                 current_offset += @max(strings.wtf8ByteSequenceLength(byte), 1);
@@ -1537,7 +1537,7 @@ pub const Crypto = struct {
         }
 
         pub fn hash(this: *EVP, engine: *BoringSSL.ENGINE, input: []const u8, output: []u8) ?u32 {
-            var outsize: c_uint = @min(@truncate(u16, output.len), this.size());
+            var outsize: c_uint = @min(@as(u16, @truncate(output.len)), this.size());
             if (BoringSSL.EVP_Digest(input.ptr, input.len, output.ptr, &outsize, this.md, engine) != 1) {
                 return null;
             }
@@ -1546,7 +1546,7 @@ pub const Crypto = struct {
         }
 
         pub fn final(this: *EVP, engine: *BoringSSL.ENGINE, output: []u8) []const u8 {
-            var outsize: u32 = @min(@truncate(u16, output.len), this.size());
+            var outsize: u32 = @min(@as(u16, @truncate(output.len)), this.size());
             if (BoringSSL.EVP_DigestFinal_ex(
                 &this.ctx,
                 output.ptr,
@@ -1565,7 +1565,7 @@ pub const Crypto = struct {
         }
 
         pub fn size(this: *EVP) u16 {
-            return @truncate(u16, BoringSSL.EVP_MD_CTX_size(&this.ctx));
+            return @as(u16, @truncate(BoringSSL.EVP_MD_CTX_size(&this.ctx)));
         }
 
         pub fn copy(this: *const EVP, engine: *BoringSSL.ENGINE) error{OutOfMemory}!EVP {
@@ -1683,7 +1683,7 @@ pub const Crypto = struct {
                                             return null;
                                         }
 
-                                        algorithm.bcrypt = @intCast(u6, rounds);
+                                        algorithm.bcrypt = @as(u6, @intCast(rounds));
                                     }
 
                                     return algorithm;
@@ -1704,7 +1704,7 @@ pub const Crypto = struct {
                                             return null;
                                         }
 
-                                        argon.time_cost = @intCast(u32, time_cost);
+                                        argon.time_cost = @as(u32, @intCast(time_cost));
                                     }
 
                                     if (value.getTruthy(globalObject, "memoryCost")) |memory_value| {
@@ -1720,7 +1720,7 @@ pub const Crypto = struct {
                                             return null;
                                         }
 
-                                        argon.memory_cost = @intCast(u32, memory_cost);
+                                        argon.memory_cost = @as(u32, @intCast(memory_cost));
                                     }
 
                                     return @unionInit(Algorithm.Value, @tagName(tag), argon);
@@ -2444,7 +2444,7 @@ pub const Crypto = struct {
             this: *CryptoHasher,
             _: *JSC.JSGlobalObject,
         ) callconv(.C) JSC.JSValue {
-            return JSC.JSValue.jsNumber(@truncate(u16, this.evp.size()));
+            return JSC.JSValue.jsNumber(@as(u16, @truncate(this.evp.size())));
         }
 
         pub fn getAlgorithm(
@@ -3100,12 +3100,12 @@ pub fn allocUnsafe(
 ) js.JSValueRef {
     var args = JSC.Node.ArgumentsSlice.from(ctx.bunVM(), arguments);
 
-    const length = @intCast(
+    const length = @as(
         usize,
-        @min(
+        @intCast(@min(
             @max(1, (args.nextEat() orelse JSC.JSValue.jsNumber(@as(i32, 1))).toInt32()),
             std.math.maxInt(i32),
-        ),
+        )),
     );
     var bytes = bun.default_allocator.alloc(u8, length) catch {
         JSC.JSError(bun.default_allocator, "OOM! Out of memory", .{}, ctx, exception);
@@ -3152,11 +3152,11 @@ pub fn mmapFile(
         flags |= @as(u32, if (shared.toBoolean()) std.os.MAP.SHARED else std.os.MAP.PRIVATE);
 
         if (opts.get(ctx.ptr(), "size")) |value| {
-            map_size = @intCast(usize, value.toInt64());
+            map_size = @as(usize, @intCast(value.toInt64()));
         }
 
         if (opts.get(ctx.ptr(), "offset")) |value| {
-            offset = @intCast(usize, value.toInt64());
+            offset = @as(usize, @intCast(value.toInt64()));
             offset = std.mem.alignBackwardAnyAlign(offset, std.mem.page_size);
         }
     } else {
@@ -3172,11 +3172,11 @@ pub fn mmapFile(
         },
     };
 
-    return JSC.C.JSObjectMakeTypedArrayWithBytesNoCopy(ctx, JSC.C.JSTypedArrayType.kJSTypedArrayTypeUint8Array, @ptrCast(?*anyopaque, map.ptr), map.len, struct {
+    return JSC.C.JSObjectMakeTypedArrayWithBytesNoCopy(ctx, JSC.C.JSTypedArrayType.kJSTypedArrayTypeUint8Array, @as(?*anyopaque, @ptrCast(map.ptr)), map.len, struct {
         pub fn x(ptr: ?*anyopaque, size: ?*anyopaque) callconv(.C) void {
-            _ = JSC.Node.Syscall.munmap(@ptrCast([*]align(std.mem.page_size) u8, @alignCast(std.mem.page_size, ptr))[0..@intFromPtr(size)]);
+            _ = JSC.Node.Syscall.munmap(@as([*]align(std.mem.page_size) u8, @ptrCast(@alignCast(ptr)))[0..@intFromPtr(size)]);
         }
-    }.x, @ptrFromInt(?*anyopaque, map.len), exception);
+    }.x, @as(?*anyopaque, @ptrFromInt(map.len)), exception);
 }
 
 pub fn getTranspilerConstructor(
@@ -3327,17 +3327,17 @@ pub const Hash = struct {
                         }
                     }
                     if (comptime std.meta.trait.isNumber(@TypeOf(function_args[0]))) {
-                        function_args[0] = @intCast(@TypeOf(function_args[0]), seed);
+                        function_args[0] = @as(@TypeOf(function_args[0]), @intCast(seed));
                         function_args[1] = input;
                     } else {
-                        function_args[1] = @intCast(@TypeOf(function_args[1]), seed);
+                        function_args[1] = @as(@TypeOf(function_args[1]), @intCast(seed));
                         function_args[0] = input;
                     }
 
                     const value = @call(.auto, Function, function_args);
 
                     if (@TypeOf(value) == u32) {
-                        return JSC.JSValue.jsNumber(@bitCast(i32, value)).asObjectRef();
+                        return JSC.JSValue.jsNumber(@as(i32, @bitCast(value))).asObjectRef();
                     }
                     return JSC.JSValue.jsNumber(value).asObjectRef();
                 }
@@ -3443,7 +3443,7 @@ pub const Unsafe = struct {
         switch (array_buffer.typed_array_type) {
             .Uint16Array, .Int16Array => {
                 var zig_str = ZigString.init("");
-                zig_str._unsafe_ptr_do_not_use = @ptrCast([*]const u8, @alignCast(@alignOf([*]align(1) const u16), array_buffer.ptr));
+                zig_str._unsafe_ptr_do_not_use = @as([*]const u8, @ptrCast(@alignCast(array_buffer.ptr)));
                 zig_str.len = array_buffer.len;
                 zig_str.markUTF16();
                 // the deinitializer for string causes segfaults
@@ -3766,7 +3766,7 @@ pub const Timer = struct {
                         var arg = args.ptr;
                         var i: u32 = 0;
                         while (i < count) : (i += 1) {
-                            arg[0] = JSC.JSObject.getIndex(arguments, globalThis, @truncate(u32, i));
+                            arg[0] = JSC.JSObject.getIndex(arguments, globalThis, @as(u32, @truncate(i)));
                             arg += 1;
                         }
                     }
@@ -4365,8 +4365,8 @@ pub const FFI = struct {
             _: JSValue,
             arguments: []const JSValue,
         ) JSValue {
-            const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @intCast(usize, arguments[1].to(i32)) else @as(usize, 0);
-            const value = @ptrFromInt(*align(1) u8, addr).*;
+            const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @as(usize, @intCast(arguments[1].to(i32))) else @as(usize, 0);
+            const value = @as(*align(1) u8, @ptrFromInt(addr)).*;
             return JSValue.jsNumber(value);
         }
         pub fn @"u16"(
@@ -4374,8 +4374,8 @@ pub const FFI = struct {
             _: JSValue,
             arguments: []const JSValue,
         ) JSValue {
-            const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @intCast(usize, arguments[1].to(i32)) else @as(usize, 0);
-            const value = @ptrFromInt(*align(1) u16, addr).*;
+            const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @as(usize, @intCast(arguments[1].to(i32))) else @as(usize, 0);
+            const value = @as(*align(1) u16, @ptrFromInt(addr)).*;
             return JSValue.jsNumber(value);
         }
         pub fn @"u32"(
@@ -4383,8 +4383,8 @@ pub const FFI = struct {
             _: JSValue,
             arguments: []const JSValue,
         ) JSValue {
-            const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @intCast(usize, arguments[1].to(i32)) else @as(usize, 0);
-            const value = @ptrFromInt(*align(1) u32, addr).*;
+            const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @as(usize, @intCast(arguments[1].to(i32))) else @as(usize, 0);
+            const value = @as(*align(1) u32, @ptrFromInt(addr)).*;
             return JSValue.jsNumber(value);
         }
         pub fn ptr(
@@ -4392,8 +4392,8 @@ pub const FFI = struct {
             _: JSValue,
             arguments: []const JSValue,
         ) JSValue {
-            const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @intCast(usize, arguments[1].to(i32)) else @as(usize, 0);
-            const value = @ptrFromInt(*align(1) u64, addr).*;
+            const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @as(usize, @intCast(arguments[1].to(i32))) else @as(usize, 0);
+            const value = @as(*align(1) u64, @ptrFromInt(addr)).*;
             return JSValue.jsNumber(value);
         }
         pub fn @"i8"(
@@ -4401,8 +4401,8 @@ pub const FFI = struct {
             _: JSValue,
             arguments: []const JSValue,
         ) JSValue {
-            const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @intCast(usize, arguments[1].to(i32)) else @as(usize, 0);
-            const value = @ptrFromInt(*align(1) i8, addr).*;
+            const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @as(usize, @intCast(arguments[1].to(i32))) else @as(usize, 0);
+            const value = @as(*align(1) i8, @ptrFromInt(addr)).*;
             return JSValue.jsNumber(value);
         }
         pub fn @"i16"(
@@ -4410,8 +4410,8 @@ pub const FFI = struct {
             _: JSValue,
             arguments: []const JSValue,
         ) JSValue {
-            const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @intCast(usize, arguments[1].to(i32)) else @as(usize, 0);
-            const value = @ptrFromInt(*align(1) i16, addr).*;
+            const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @as(usize, @intCast(arguments[1].to(i32))) else @as(usize, 0);
+            const value = @as(*align(1) i16, @ptrFromInt(addr)).*;
             return JSValue.jsNumber(value);
         }
         pub fn @"i32"(
@@ -4419,8 +4419,8 @@ pub const FFI = struct {
             _: JSValue,
             arguments: []const JSValue,
         ) JSValue {
-            const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @intCast(usize, arguments[1].to(i32)) else @as(usize, 0);
-            const value = @ptrFromInt(*align(1) i32, addr).*;
+            const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @as(usize, @intCast(arguments[1].to(i32))) else @as(usize, 0);
+            const value = @as(*align(1) i32, @ptrFromInt(addr)).*;
             return JSValue.jsNumber(value);
         }
         pub fn intptr(
@@ -4428,8 +4428,8 @@ pub const FFI = struct {
             _: JSValue,
             arguments: []const JSValue,
         ) JSValue {
-            const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @intCast(usize, arguments[1].to(i32)) else @as(usize, 0);
-            const value = @ptrFromInt(*align(1) i64, addr).*;
+            const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @as(usize, @intCast(arguments[1].to(i32))) else @as(usize, 0);
+            const value = @as(*align(1) i64, @ptrFromInt(addr)).*;
             return JSValue.jsNumber(value);
         }
 
@@ -4438,8 +4438,8 @@ pub const FFI = struct {
             _: JSValue,
             arguments: []const JSValue,
         ) JSValue {
-            const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @intCast(usize, arguments[1].to(i32)) else @as(usize, 0);
-            const value = @ptrFromInt(*align(1) f32, addr).*;
+            const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @as(usize, @intCast(arguments[1].to(i32))) else @as(usize, 0);
+            const value = @as(*align(1) f32, @ptrFromInt(addr)).*;
             return JSValue.jsNumber(value);
         }
 
@@ -4448,8 +4448,8 @@ pub const FFI = struct {
             _: JSValue,
             arguments: []const JSValue,
         ) JSValue {
-            const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @intCast(usize, arguments[1].to(i32)) else @as(usize, 0);
-            const value = @ptrFromInt(*align(1) f64, addr).*;
+            const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @as(usize, @intCast(arguments[1].to(i32))) else @as(usize, 0);
+            const value = @as(*align(1) f64, @ptrFromInt(addr)).*;
             return JSValue.jsNumber(value);
         }
 
@@ -4458,8 +4458,8 @@ pub const FFI = struct {
             _: JSValue,
             arguments: []const JSValue,
         ) JSValue {
-            const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @intCast(usize, arguments[1].to(i32)) else @as(usize, 0);
-            const value = @ptrFromInt(*align(1) i64, addr).*;
+            const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @as(usize, @intCast(arguments[1].to(i32))) else @as(usize, 0);
+            const value = @as(*align(1) i64, @ptrFromInt(addr)).*;
             return JSValue.fromInt64NoTruncate(global, value);
         }
 
@@ -4468,8 +4468,8 @@ pub const FFI = struct {
             _: JSValue,
             arguments: []const JSValue,
         ) JSValue {
-            const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @intCast(usize, arguments[1].to(i32)) else @as(usize, 0);
-            const value = @ptrFromInt(*align(1) u64, addr).*;
+            const addr = arguments[0].asPtrAddress() + if (arguments.len > 1) @as(usize, @intCast(arguments[1].to(i32))) else @as(usize, 0);
+            const value = @as(*align(1) u64, @ptrFromInt(addr)).*;
             return JSValue.fromUInt64NoTruncate(global, value);
         }
 
@@ -4479,8 +4479,8 @@ pub const FFI = struct {
             raw_addr: i64,
             offset: i32,
         ) callconv(.C) JSValue {
-            const addr = @intCast(usize, raw_addr) + @intCast(usize, offset);
-            const value = @ptrFromInt(*align(1) u8, addr).*;
+            const addr = @as(usize, @intCast(raw_addr)) + @as(usize, @intCast(offset));
+            const value = @as(*align(1) u8, @ptrFromInt(addr)).*;
             return JSValue.jsNumber(value);
         }
         pub fn u16WithoutTypeChecks(
@@ -4489,8 +4489,8 @@ pub const FFI = struct {
             raw_addr: i64,
             offset: i32,
         ) callconv(.C) JSValue {
-            const addr = @intCast(usize, raw_addr) + @intCast(usize, offset);
-            const value = @ptrFromInt(*align(1) u16, addr).*;
+            const addr = @as(usize, @intCast(raw_addr)) + @as(usize, @intCast(offset));
+            const value = @as(*align(1) u16, @ptrFromInt(addr)).*;
             return JSValue.jsNumber(value);
         }
         pub fn u32WithoutTypeChecks(
@@ -4499,8 +4499,8 @@ pub const FFI = struct {
             raw_addr: i64,
             offset: i32,
         ) callconv(.C) JSValue {
-            const addr = @intCast(usize, raw_addr) + @intCast(usize, offset);
-            const value = @ptrFromInt(*align(1) u32, addr).*;
+            const addr = @as(usize, @intCast(raw_addr)) + @as(usize, @intCast(offset));
+            const value = @as(*align(1) u32, @ptrFromInt(addr)).*;
             return JSValue.jsNumber(value);
         }
         pub fn ptrWithoutTypeChecks(
@@ -4509,8 +4509,8 @@ pub const FFI = struct {
             raw_addr: i64,
             offset: i32,
         ) callconv(.C) JSValue {
-            const addr = @intCast(usize, raw_addr) + @intCast(usize, offset);
-            const value = @ptrFromInt(*align(1) u64, addr).*;
+            const addr = @as(usize, @intCast(raw_addr)) + @as(usize, @intCast(offset));
+            const value = @as(*align(1) u64, @ptrFromInt(addr)).*;
             return JSValue.jsNumber(value);
         }
         pub fn i8WithoutTypeChecks(
@@ -4519,8 +4519,8 @@ pub const FFI = struct {
             raw_addr: i64,
             offset: i32,
         ) callconv(.C) JSValue {
-            const addr = @intCast(usize, raw_addr) + @intCast(usize, offset);
-            const value = @ptrFromInt(*align(1) i8, addr).*;
+            const addr = @as(usize, @intCast(raw_addr)) + @as(usize, @intCast(offset));
+            const value = @as(*align(1) i8, @ptrFromInt(addr)).*;
             return JSValue.jsNumber(value);
         }
         pub fn i16WithoutTypeChecks(
@@ -4529,8 +4529,8 @@ pub const FFI = struct {
             raw_addr: i64,
             offset: i32,
         ) callconv(.C) JSValue {
-            const addr = @intCast(usize, raw_addr) + @intCast(usize, offset);
-            const value = @ptrFromInt(*align(1) i16, addr).*;
+            const addr = @as(usize, @intCast(raw_addr)) + @as(usize, @intCast(offset));
+            const value = @as(*align(1) i16, @ptrFromInt(addr)).*;
             return JSValue.jsNumber(value);
         }
         pub fn i32WithoutTypeChecks(
@@ -4539,8 +4539,8 @@ pub const FFI = struct {
             raw_addr: i64,
             offset: i32,
         ) callconv(.C) JSValue {
-            const addr = @intCast(usize, raw_addr) + @intCast(usize, offset);
-            const value = @ptrFromInt(*align(1) i32, addr).*;
+            const addr = @as(usize, @intCast(raw_addr)) + @as(usize, @intCast(offset));
+            const value = @as(*align(1) i32, @ptrFromInt(addr)).*;
             return JSValue.jsNumber(value);
         }
         pub fn intptrWithoutTypeChecks(
@@ -4549,8 +4549,8 @@ pub const FFI = struct {
             raw_addr: i64,
             offset: i32,
         ) callconv(.C) JSValue {
-            const addr = @intCast(usize, raw_addr) + @intCast(usize, offset);
-            const value = @ptrFromInt(*align(1) i64, addr).*;
+            const addr = @as(usize, @intCast(raw_addr)) + @as(usize, @intCast(offset));
+            const value = @as(*align(1) i64, @ptrFromInt(addr)).*;
             return JSValue.jsNumber(value);
         }
 
@@ -4560,8 +4560,8 @@ pub const FFI = struct {
             raw_addr: i64,
             offset: i32,
         ) callconv(.C) JSValue {
-            const addr = @intCast(usize, raw_addr) + @intCast(usize, offset);
-            const value = @ptrFromInt(*align(1) f32, addr).*;
+            const addr = @as(usize, @intCast(raw_addr)) + @as(usize, @intCast(offset));
+            const value = @as(*align(1) f32, @ptrFromInt(addr)).*;
             return JSValue.jsNumber(value);
         }
 
@@ -4571,8 +4571,8 @@ pub const FFI = struct {
             raw_addr: i64,
             offset: i32,
         ) callconv(.C) JSValue {
-            const addr = @intCast(usize, raw_addr) + @intCast(usize, offset);
-            const value = @ptrFromInt(*align(1) f64, addr).*;
+            const addr = @as(usize, @intCast(raw_addr)) + @as(usize, @intCast(offset));
+            const value = @as(*align(1) f64, @ptrFromInt(addr)).*;
             return JSValue.jsNumber(value);
         }
 
@@ -4582,8 +4582,8 @@ pub const FFI = struct {
             raw_addr: i64,
             offset: i32,
         ) callconv(.C) JSValue {
-            const addr = @intCast(usize, raw_addr) + @intCast(usize, offset);
-            const value = @ptrFromInt(*align(1) u64, addr).*;
+            const addr = @as(usize, @intCast(raw_addr)) + @as(usize, @intCast(offset));
+            const value = @as(*align(1) u64, @ptrFromInt(addr)).*;
             return JSValue.fromUInt64NoTruncate(global, value);
         }
 
@@ -4593,8 +4593,8 @@ pub const FFI = struct {
             raw_addr: i64,
             offset: i32,
         ) callconv(.C) JSValue {
-            const addr = @intCast(usize, raw_addr) + @intCast(usize, offset);
-            const value = @ptrFromInt(*align(1) i64, addr).*;
+            const addr = @as(usize, @intCast(raw_addr)) + @as(usize, @intCast(offset));
+            const value = @as(*align(1) i64, @ptrFromInt(addr)).*;
             return JSValue.fromInt64NoTruncate(global, value);
         }
 
@@ -4671,9 +4671,9 @@ pub const FFI = struct {
 
             const bytei64 = off.toInt64();
             if (bytei64 < 0) {
-                addr -|= @intCast(usize, bytei64 * -1);
+                addr -|= @as(usize, @intCast(bytei64 * -1));
             } else {
-                addr += @intCast(usize, bytei64);
+                addr += @as(usize, @intCast(bytei64));
             }
 
             if (addr > @intFromPtr(array_buffer.ptr) + @as(usize, array_buffer.byte_len)) {
@@ -4719,15 +4719,15 @@ pub const FFI = struct {
         //     return .{ .err = JSC.toInvalidArguments("ptr must be a finite number.", .{}, globalThis) };
         // }
 
-        var addr = @bitCast(usize, num);
+        var addr = @as(usize, @bitCast(num));
 
         if (byteOffset) |byte_off| {
             if (byte_off.isNumber()) {
                 const off = byte_off.toInt64();
                 if (off < 0) {
-                    addr -|= @intCast(usize, off * -1);
+                    addr -|= @as(usize, @intCast(off * -1));
                 } else {
-                    addr +|= @intCast(usize, off);
+                    addr +|= @as(usize, @intCast(off));
                 }
 
                 if (addr == 0) {
@@ -4767,12 +4767,12 @@ pub const FFI = struct {
                     return .{ .err = JSC.toInvalidArguments("length exceeds max addressable memory. This usually means a bug in your code.", .{}, globalThis) };
                 }
 
-                const length = @intCast(usize, length_i);
-                return .{ .slice = @ptrFromInt([*]u8, addr)[0..length] };
+                const length = @as(usize, @intCast(length_i));
+                return .{ .slice = @as([*]u8, @ptrFromInt(addr))[0..length] };
             }
         }
 
-        return .{ .slice = bun.span(@ptrFromInt([*:0]u8, addr)) };
+        return .{ .slice = bun.span(@as([*:0]u8, @ptrFromInt(addr))) };
     }
 
     fn getCPtr(value: JSValue) ?usize {
@@ -4781,7 +4781,7 @@ pub const FFI = struct {
             const addr = value.asPtrAddress();
             if (addr > 0) return addr;
         } else if (value.isBigInt()) {
-            const addr = @bitCast(u64, value.toUInt64NoTruncate());
+            const addr = @as(u64, @bitCast(value.toUInt64NoTruncate()));
             if (addr > 0) {
                 return addr;
             }
@@ -4807,11 +4807,11 @@ pub const FFI = struct {
                 var ctx: ?*anyopaque = null;
                 if (finalizationCallback) |callback_value| {
                     if (getCPtr(callback_value)) |callback_ptr| {
-                        callback = @ptrFromInt(JSC.C.JSTypedArrayBytesDeallocator, callback_ptr);
+                        callback = @as(JSC.C.JSTypedArrayBytesDeallocator, @ptrFromInt(callback_ptr));
 
                         if (finalizationCtxOrPtr) |ctx_value| {
                             if (getCPtr(ctx_value)) |ctx_ptr| {
-                                ctx = @ptrFromInt(*anyopaque, ctx_ptr);
+                                ctx = @as(*anyopaque, @ptrFromInt(ctx_ptr));
                             } else if (!ctx_value.isUndefinedOrNull()) {
                                 return JSC.toInvalidArguments("Expected user data to be a C pointer (number or BigInt)", .{}, globalThis);
                             }
@@ -4821,7 +4821,7 @@ pub const FFI = struct {
                     }
                 } else if (finalizationCtxOrPtr) |callback_value| {
                     if (getCPtr(callback_value)) |callback_ptr| {
-                        callback = @ptrFromInt(JSC.C.JSTypedArrayBytesDeallocator, callback_ptr);
+                        callback = @as(JSC.C.JSTypedArrayBytesDeallocator, @ptrFromInt(callback_ptr));
                     } else if (!callback_value.isEmptyOrUndefinedOrNull()) {
                         return JSC.toInvalidArguments("Expected callback to be a C pointer (number or BigInt)", .{}, globalThis);
                     }
@@ -4849,11 +4849,11 @@ pub const FFI = struct {
                 var ctx: ?*anyopaque = null;
                 if (finalizationCallback) |callback_value| {
                     if (getCPtr(callback_value)) |callback_ptr| {
-                        callback = @ptrFromInt(JSC.C.JSTypedArrayBytesDeallocator, callback_ptr);
+                        callback = @as(JSC.C.JSTypedArrayBytesDeallocator, @ptrFromInt(callback_ptr));
 
                         if (finalizationCtxOrPtr) |ctx_value| {
                             if (getCPtr(ctx_value)) |ctx_ptr| {
-                                ctx = @ptrFromInt(*anyopaque, ctx_ptr);
+                                ctx = @as(*anyopaque, @ptrFromInt(ctx_ptr));
                             } else if (!ctx_value.isEmptyOrUndefinedOrNull()) {
                                 return JSC.toInvalidArguments("Expected user data to be a C pointer (number or BigInt)", .{}, globalThis);
                             }
@@ -4863,7 +4863,7 @@ pub const FFI = struct {
                     }
                 } else if (finalizationCtxOrPtr) |callback_value| {
                     if (getCPtr(callback_value)) |callback_ptr| {
-                        callback = @ptrFromInt(JSC.C.JSTypedArrayBytesDeallocator, callback_ptr);
+                        callback = @as(JSC.C.JSTypedArrayBytesDeallocator, @ptrFromInt(callback_ptr));
                     } else if (!callback_value.isEmptyOrUndefinedOrNull()) {
                         return JSC.toInvalidArguments("Expected callback to be a C pointer (number or BigInt)", .{}, globalThis);
                     }