Wipu/vjpr/zig-0.10

4 files changed, 40 insertions, 40 deletions

diff --git a/src/bun.js/api/bun.zig b/src/bun.js/api/bun.zig
index e37ed0862..f8f7b55a8 100644
--- a/src/bun.js/api/bun.zig
+++ b/src/bun.js/api/bun.zig
@@ -307,7 +307,7 @@ pub fn registerMacro(
     }
 
     if (!arguments[1].?.value().isCell() or !arguments[1].?.value().isCallable(ctx.vm())) {
-        JSError(getAllocator(ctx), "Macro must be a function. Received: {any}", .{@tagName(js.JSValueGetType(ctx, arguments[1]))}, ctx, exception);
+        JSError(getAllocator(ctx), "Macro must be a function. Received: {s}", .{@tagName(js.JSValueGetType(ctx, arguments[1]))}, ctx, exception);
         return js.JSValueMakeUndefined(ctx);
     }
 
@@ -591,26 +591,26 @@ pub fn readFileAsStringCallback(
 ) js.JSValueRef {
     const path = buf_z.ptr[0..buf_z.len];
     var file = std.fs.cwd().openFileZ(buf_z, .{ .mode = .read_only }) catch |err| {
-        JSError(getAllocator(ctx), "Opening file {any} for path: \"{any}\"", .{ @errorName(err), path }, ctx, exception);
+        JSError(getAllocator(ctx), "Opening file {s} for path: \"{s}\"", .{ @errorName(err), path }, ctx, exception);
         return js.JSValueMakeUndefined(ctx);
     };
 
     defer file.close();
 
     const stat = file.stat() catch |err| {
-        JSError(getAllocator(ctx), "Getting file size {any} for \"{any}\"", .{ @errorName(err), path }, ctx, exception);
+        JSError(getAllocator(ctx), "Getting file size {s} for \"{s}\"", .{ @errorName(err), path }, ctx, exception);
         return js.JSValueMakeUndefined(ctx);
     };
 
     if (stat.kind != .File) {
-        JSError(getAllocator(ctx), "Can't read a {any} as a string (\"{any}\")", .{ @tagName(stat.kind), path }, ctx, exception);
+        JSError(getAllocator(ctx), "Can't read a {s} as a string (\"{s}\")", .{ @tagName(stat.kind), path }, ctx, exception);
         return js.JSValueMakeUndefined(ctx);
     }
 
     var contents_buf = VirtualMachine.vm.allocator.alloc(u8, stat.size + 2) catch unreachable; // OOM
     defer VirtualMachine.vm.allocator.free(contents_buf);
     const contents_len = file.readAll(contents_buf) catch |err| {
-        JSError(getAllocator(ctx), "{any} reading file (\"{any}\")", .{ @errorName(err), path }, ctx, exception);
+        JSError(getAllocator(ctx), "{s} reading file (\"{s}\")", .{ @errorName(err), path }, ctx, exception);
         return js.JSValueMakeUndefined(ctx);
     };
 
@@ -631,26 +631,26 @@ pub fn readFileAsBytesCallback(
     const path = buf_z.ptr[0..buf_z.len];
 
     var file = std.fs.cwd().openFileZ(buf_z, .{ .mode = .read_only }) catch |err| {
-        JSError(getAllocator(ctx), "Opening file {any} for path: \"{any}\"", .{ @errorName(err), path }, ctx, exception);
+        JSError(getAllocator(ctx), "Opening file {s} for path: \"{s}\"", .{ @errorName(err), path }, ctx, exception);
         return js.JSValueMakeUndefined(ctx);
     };
 
     defer file.close();
 
     const stat = file.stat() catch |err| {
-        JSError(getAllocator(ctx), "Getting file size {any} for \"{any}\"", .{ @errorName(err), path }, ctx, exception);
+        JSError(getAllocator(ctx), "Getting file size {s} for \"{s}\"", .{ @errorName(err), path }, ctx, exception);
         return js.JSValueMakeUndefined(ctx);
     };
 
     if (stat.kind != .File) {
-        JSError(getAllocator(ctx), "Can't read a {any} as a string (\"{any}\")", .{ @tagName(stat.kind), path }, ctx, exception);
+        JSError(getAllocator(ctx), "Can't read a {s} as a string (\"{s}\")", .{ @tagName(stat.kind), path }, ctx, exception);
         return js.JSValueMakeUndefined(ctx);
     }
 
     var contents_buf = VirtualMachine.vm.allocator.alloc(u8, stat.size + 2) catch unreachable; // OOM
     errdefer VirtualMachine.vm.allocator.free(contents_buf);
     const contents_len = file.readAll(contents_buf) catch |err| {
-        JSError(getAllocator(ctx), "{any} reading file (\"{any}\")", .{ @errorName(err), path }, ctx, exception);
+        JSError(getAllocator(ctx), "{s} reading file (\"{s}\")", .{ @errorName(err), path }, ctx, exception);
         return js.JSValueMakeUndefined(ctx);
     };
 
@@ -743,7 +743,7 @@ pub fn openInEditor(
                     editor_choice = edit.editor;
                     if (editor_choice == null) {
                         edit.* = prev;
-                        JSError(getAllocator(ctx), "Could not find editor \"{any}\"", .{sliced.slice()}, ctx, exception);
+                        JSError(getAllocator(ctx), "Could not find editor \"{s}\"", .{sliced.slice()}, ctx, exception);
                         return js.JSValueMakeUndefined(ctx);
                     } else if (edit.name.ptr == edit.path.ptr) {
                         edit.name = bun.default_allocator.dupe(u8, edit.path) catch unreachable;
@@ -778,7 +778,7 @@ pub fn openInEditor(
     }
 
     editor.open(edit.path, path, line, column, bun.default_allocator) catch |err| {
-        JSC.JSError(bun.default_allocator, "Opening editor failed {any}", .{@errorName(err)}, ctx, exception);
+        JSC.JSError(bun.default_allocator, "Opening editor failed {s}", .{@errorName(err)}, ctx, exception);
         return null;
     };
 
@@ -1049,7 +1049,7 @@ pub fn readAllStdinSync(
 
     var stdin = std.io.getStdIn();
     var result = stdin.readToEndAlloc(allocator, std.math.maxInt(u32)) catch |err| {
-        JSError(undefined, "{any} reading stdin", .{@errorName(err)}, ctx, exception);
+        JSError(undefined, "{s} reading stdin", .{@errorName(err)}, ctx, exception);
         return null;
     };
     var out = ZigString.init(result);
@@ -1375,7 +1375,7 @@ pub const Crypto = struct {
                     switch (string_or_buffer) {
                         .string => |str| {
                             const encoding = JSC.Node.Encoding.from(str) orelse {
-                                globalThis.throwInvalidArguments("Unknown encoding: {any}", .{str});
+                                globalThis.throwInvalidArguments("Unknown encoding: {s}", .{str});
                                 return JSC.JSValue.zero;
                             };
 
@@ -1428,7 +1428,7 @@ pub const Crypto = struct {
                     switch (string_or_buffer) {
                         .string => |str| {
                             const encoding = JSC.Node.Encoding.from(str) orelse {
-                                globalThis.throwInvalidArguments("Unknown encoding: {any}", .{str});
+                                globalThis.throwInvalidArguments("Unknown encoding: {s}", .{str});
                                 return JSC.JSValue.zero;
                             };
 
@@ -2124,19 +2124,19 @@ pub const Unsafe = struct {
 //                 defer getAllocator(ctx).destroy(lockfile);
 //                 switch (cause.step) {
 //                     .open_file => {
-//                         JSError(undefined, "error opening lockfile: {any}", .{
+//                         JSError(undefined, "error opening lockfile: {s}", .{
 //                             @errorName(cause.value),
 //                         }, ctx, exception);
 //                         return null;
 //                     },
 //                     .parse_file => {
-//                         JSError(undefined, "error parsing lockfile: {any}", .{
+//                         JSError(undefined, "error parsing lockfile: {s}", .{
 //                             @errorName(cause.value),
 //                         }, ctx, exception);
 //                         return null;
 //                     },
 //                     .read_file => {
-//                         JSError(undefined, "error reading lockfile: {any}", .{
+//                         JSError(undefined, "error reading lockfile: {s}", .{
 //                             @errorName(cause.value),
 //                         }, ctx, exception);
 //                         return null;
@@ -2934,7 +2934,7 @@ pub const FFI = struct {
         }
 
         const array_buffer = value.asArrayBuffer(globalThis) orelse {
-            return JSC.toInvalidArguments("Expected ArrayBufferView but received {any}", .{@tagName(value.jsType())}, globalThis);
+            return JSC.toInvalidArguments("Expected ArrayBufferView but received {s}", .{@tagName(value.jsType())}, globalThis);
         };
 
         if (array_buffer.len == 0) {
diff --git a/src/bun.js/api/ffi.zig b/src/bun.js/api/ffi.zig
index 7d97d50dc..53ced79b3 100644
--- a/src/bun.js/api/ffi.zig
+++ b/src/bun.js/api/ffi.zig
@@ -331,7 +331,7 @@ pub const FFI = struct {
             // optional if the user passed "ptr"
             if (function.symbol_from_dynamic_library == null) {
                 var resolved_symbol = dylib.lookup(*anyopaque, function_name) orelse {
-                    const ret = JSC.toInvalidArguments("Symbol \"{any}\" not found in \"{any}\"", .{ std.mem.span(function_name), name_slice.slice() }, global);
+                    const ret = JSC.toInvalidArguments("Symbol \"{s}\" not found in \"{s}\"", .{ std.mem.span(function_name), name_slice.slice() }, global);
                     for (symbols.values()) |*value| {
                         allocator.free(bun.constStrToU8(std.mem.span(value.base_name.?)));
                         value.arg_types.clearAndFree(allocator);
@@ -345,7 +345,7 @@ pub const FFI = struct {
             }
 
             function.compile(allocator) catch |err| {
-                const ret = JSC.toInvalidArguments("{any} when compiling symbol \"{any}\" in \"{any}\"", .{
+                const ret = JSC.toInvalidArguments("{s} when compiling symbol \"{s}\" in \"{s}\"", .{
                     std.mem.span(@errorName(err)),
                     std.mem.span(function_name),
                     name_slice.slice(),
@@ -434,7 +434,7 @@ pub const FFI = struct {
             const function_name = function.base_name.?;
 
             if (function.symbol_from_dynamic_library == null) {
-                const ret = JSC.toInvalidArguments("Symbol for \"{any}\" not found", .{std.mem.span(function_name)}, global);
+                const ret = JSC.toInvalidArguments("Symbol for \"{s}\" not found", .{std.mem.span(function_name)}, global);
                 for (symbols.values()) |*value| {
                     allocator.free(bun.constStrToU8(std.mem.span(value.base_name.?)));
                     value.arg_types.clearAndFree(allocator);
@@ -444,7 +444,7 @@ pub const FFI = struct {
             }
 
             function.compile(allocator) catch |err| {
-                const ret = JSC.toInvalidArguments("{any} when compiling symbol \"{any}\"", .{
+                const ret = JSC.toInvalidArguments("{s} when compiling symbol \"{s}\"", .{
                     std.mem.span(@errorName(err)),
                     std.mem.span(function_name),
                 }, global);
@@ -544,7 +544,7 @@ pub const FFI = struct {
                 defer type_name.deinit();
                 abi_types.appendAssumeCapacity(ABIType.label.get(type_name.slice()) orelse {
                     abi_types.clearAndFree(allocator);
-                    return JSC.toTypeError(JSC.Node.ErrorCode.ERR_INVALID_ARG_VALUE, "Unknown type {any}", .{type_name.slice()}, global);
+                    return JSC.toTypeError(JSC.Node.ErrorCode.ERR_INVALID_ARG_VALUE, "Unknown type {s}", .{type_name.slice()}, global);
                 });
             }
         }
@@ -576,7 +576,7 @@ pub const FFI = struct {
             defer ret_slice.deinit();
             return_type = ABIType.label.get(ret_slice.slice()) orelse {
                 abi_types.clearAndFree(allocator);
-                return JSC.toTypeError(JSC.Node.ErrorCode.ERR_INVALID_ARG_VALUE, "Unknown return type {any}", .{ret_slice.slice()}, global);
+                return JSC.toTypeError(JSC.Node.ErrorCode.ERR_INVALID_ARG_VALUE, "Unknown return type {s}", .{ret_slice.slice()}, global);
             };
         }
 
@@ -624,7 +624,7 @@ pub const FFI = struct {
             const value = symbols_iter.value;
 
             if (value.isEmptyOrUndefinedOrNull()) {
-                return JSC.toTypeError(JSC.Node.ErrorCode.ERR_INVALID_ARG_VALUE, "Expected an object for key \"{any}\"", .{prop}, global);
+                return JSC.toTypeError(JSC.Node.ErrorCode.ERR_INVALID_ARG_VALUE, "Expected an object for key \"{s}\"", .{prop}, global);
             }
 
             var function: Function = .{};
@@ -1143,7 +1143,7 @@ pub const FFI = struct {
                 try this.return_type.typename(writer);
                 try writer.writeAll(" return_value = ");
             }
-            try writer.print("{any}(", .{std.mem.span(this.base_name.?)});
+            try writer.print("{s}(", .{std.mem.span(this.base_name.?)});
             first = true;
             arg_buf[0..3].* = "arg".*;
             for (this.arg_types.items) |arg, i| {
@@ -1296,7 +1296,7 @@ pub const FFI = struct {
                 const len = inner_buf.len + 1;
                 inner_buf = inner_buf_[0..len];
                 inner_buf[0] = '_';
-                try writer.print("return {any}", .{this.return_type.toCExact(inner_buf)});
+                try writer.print("return {s}", .{this.return_type.toCExact(inner_buf)});
             }
 
             try writer.writeAll(";\n}\n\n");
@@ -1449,7 +1449,7 @@ pub const FFI = struct {
                     },
                     .char, .int8_t, .uint8_t, .int16_t, .uint16_t, .int32_t, .uint32_t => {
                         if (self.exact)
-                            try writer.print("({any})", .{std.mem.span(@tagName(self.tag))});
+                            try writer.print("({s})", .{std.mem.span(@tagName(self.tag))});
 
                         try writer.writeAll("JSVALUE_TO_INT32(");
                     },
@@ -1498,31 +1498,31 @@ pub const FFI = struct {
                 switch (self.tag) {
                     .void => {},
                     .bool => {
-                        try writer.print("BOOLEAN_TO_JSVALUE({any})", .{self.symbol});
+                        try writer.print("BOOLEAN_TO_JSVALUE({s})", .{self.symbol});
                     },
                     .char, .int8_t, .uint8_t, .int16_t, .uint16_t, .int32_t => {
-                        try writer.print("INT32_TO_JSVALUE((int32_t){any})", .{self.symbol});
+                        try writer.print("INT32_TO_JSVALUE((int32_t){s})", .{self.symbol});
                     },
                     .uint32_t, .i64_fast => {
-                        try writer.print("INT64_TO_JSVALUE(JS_GLOBAL_OBJECT, (int64_t){any})", .{self.symbol});
+                        try writer.print("INT64_TO_JSVALUE(JS_GLOBAL_OBJECT, (int64_t){s})", .{self.symbol});
                     },
                     .int64_t => {
-                        try writer.print("INT64_TO_JSVALUE_SLOW(JS_GLOBAL_OBJECT, {any})", .{self.symbol});
+                        try writer.print("INT64_TO_JSVALUE_SLOW(JS_GLOBAL_OBJECT, {s})", .{self.symbol});
                     },
                     .u64_fast => {
-                        try writer.print("UINT64_TO_JSVALUE(JS_GLOBAL_OBJECT, {any})", .{self.symbol});
+                        try writer.print("UINT64_TO_JSVALUE(JS_GLOBAL_OBJECT, {s})", .{self.symbol});
                     },
                     .uint64_t => {
-                        try writer.print("UINT64_TO_JSVALUE_SLOW(JS_GLOBAL_OBJECT, {any})", .{self.symbol});
+                        try writer.print("UINT64_TO_JSVALUE_SLOW(JS_GLOBAL_OBJECT, {s})", .{self.symbol});
                     },
                     .function, .cstring, .ptr => {
-                        try writer.print("PTR_TO_JSVALUE({any})", .{self.symbol});
+                        try writer.print("PTR_TO_JSVALUE({s})", .{self.symbol});
                     },
                     .double => {
-                        try writer.print("DOUBLE_TO_JSVALUE({any})", .{self.symbol});
+                        try writer.print("DOUBLE_TO_JSVALUE({s})", .{self.symbol});
                     },
                     .float => {
-                        try writer.print("FLOAT_TO_JSVALUE({any})", .{self.symbol});
+                        try writer.print("FLOAT_TO_JSVALUE({s})", .{self.symbol});
                     },
                 }
             }
diff --git a/src/bun.js/api/html_rewriter.zig b/src/bun.js/api/html_rewriter.zig
index 252915f56..a3632bf32 100644
--- a/src/bun.js/api/html_rewriter.zig
+++ b/src/bun.js/api/html_rewriter.zig
@@ -735,7 +735,7 @@ const DocumentHandler = struct {
             .Object, .ProxyObject, .Cell, .FinalObject => {},
             else => |kind| {
                 JSC.throwInvalidArguments(
-                    "Expected object but received {any}",
+                    "Expected object but received {s}",
                     .{@as(string, @tagName(kind))},
                     global,
                     exception,
@@ -886,7 +886,7 @@ const ElementHandler = struct {
             .Object, .ProxyObject, .Cell, .FinalObject => {},
             else => |kind| {
                 JSC.throwInvalidArguments(
-                    "Expected object but received {any}",
+                    "Expected object but received {s}",
                     .{@as(string, @tagName(kind))},
                     global,
                     exception,
diff --git a/src/bun.js/api/transpiler.zig b/src/bun.js/api/transpiler.zig
index 75b5866bf..eba9ef7aa 100644
--- a/src/bun.js/api/transpiler.zig
+++ b/src/bun.js/api/transpiler.zig
@@ -667,7 +667,7 @@ fn transformOptionsFromJSC(ctx: JSC.C.JSContextRef, temp_allocator: std.mem.Allo
                     var key = try key_.toOwnedSlice(bun.default_allocator);
 
                     if (!JSLexer.isIdentifier(key)) {
-                        JSC.throwInvalidArguments("\"{any}\" is not a valid ECMAScript identifier", .{key}, ctx, exception);
+                        JSC.throwInvalidArguments("\"{s}\" is not a valid ECMAScript identifier", .{key}, ctx, exception);
                         bun.default_allocator.free(key);
                         return transpiler;
                     }