make argument list to throwMissingArgumentsValue must be comptime-known

src/bun.js/api/js_brotli.zig

@@ -105,11 +105,7 @@ pub const BrotliEncoder = struct {
                 if (params.hasOwnPropertyValue(globalThis, JSC.ZigString.static(std.fmt.comptimePrint("{d}", .{f.value})).toJS(globalThis))) {
                     const idx = params.getIndex(globalThis, f.value);
                     if (!idx.isNumber()) {
-                        globalThis.throwValue(globalThis.ERR_INVALID_ARG_TYPE_static(
-                            JSC.ZigString.static("options.params[key]"),
-                            JSC.ZigString.static("number"),
-                            idx,
-                        ));
+                        _ = globalThis.throwInvalidPropertyTypeValue("options.params[key]", "number", idx);
                         this.deinit();
                         return .zero;
                     }

src/bun.js/bindings/ErrorCode.cpp

@@ -61,12 +61,6 @@ static JSC::JSObject* createErrorPrototype(JSC::VM& vm, JSC::JSGlobalObject* glo
     return prototype;
 }
 
-extern "C" JSC::EncodedJSValue Bun__ERR_INVALID_ARG_TYPE(JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue val_arg_name, JSC::EncodedJSValue val_expected_type, JSC::EncodedJSValue val_actual_value);
-extern "C" JSC::EncodedJSValue Bun__ERR_INVALID_ARG_TYPE_static(JSC::JSGlobalObject* globalObject, const ZigString* val_arg_name, const ZigString* val_expected_type, JSC::EncodedJSValue val_actual_value);
-extern "C" JSC::EncodedJSValue Bun__ERR_MISSING_ARGS(JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue arg1, JSC::EncodedJSValue arg2, JSC::EncodedJSValue arg3);
-extern "C" JSC::EncodedJSValue Bun__ERR_MISSING_ARGS_static(JSC::JSGlobalObject* globalObject, const ZigString* arg1, const ZigString* arg2, const ZigString* arg3);
-extern "C" JSC::EncodedJSValue Bun__ERR_IPC_CHANNEL_CLOSED(JSC::JSGlobalObject* globalObject);
-
 // clang-format on
 
 #define EXPECT_ARG_COUNT(count__)                                                          \
@@ -326,25 +320,6 @@ static JSC::JSValue ERR_INVALID_ARG_TYPE(JSC::ThrowScope& scope, JSC::JSGlobalOb
     return createError(globalObject, ErrorCode::ERR_INVALID_ARG_TYPE, msg);
 }
 
-extern "C" JSC::EncodedJSValue Bun__ERR_INVALID_ARG_TYPE(JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue val_arg_name, JSC::EncodedJSValue val_expected_type, JSC::EncodedJSValue val_actual_value)
-{
-    JSC::VM& vm = globalObject->vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-
-    auto message = Message::ERR_INVALID_ARG_TYPE(scope, globalObject, JSValue::decode(val_arg_name), JSValue::decode(val_expected_type), JSValue::decode(val_actual_value));
-    RETURN_IF_EXCEPTION(scope, {});
-    return JSC::JSValue::encode(createError(globalObject, ErrorCode::ERR_INVALID_ARG_TYPE, message));
-}
-extern "C" JSC::EncodedJSValue Bun__ERR_INVALID_ARG_TYPE_static(JSC::JSGlobalObject* globalObject, const ZigString* val_arg_name, const ZigString* val_expected_type, JSC::EncodedJSValue val_actual_value)
-{
-    JSC::VM& vm = globalObject->vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-
-    WTF::String message = Message::ERR_INVALID_ARG_TYPE(scope, globalObject, val_arg_name, val_expected_type, JSValue::decode(val_actual_value));
-    RETURN_IF_EXCEPTION(scope, {});
-    return JSC::JSValue::encode(createError(globalObject, ErrorCode::ERR_INVALID_ARG_TYPE, message));
-}
-
 JSC_DEFINE_HOST_FUNCTION(jsFunction_ERR_OUT_OF_RANGE, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
 {
     JSC::VM& vm = globalObject->vm();
@@ -372,82 +347,7 @@ extern "C" JSC::EncodedJSValue Bun__createErrorWithCode(JSC::JSGlobalObject* glo
     return JSValue::encode(createError(globalObject, code, message->toWTFString(BunString::ZeroCopy)));
 }
 
-extern "C" JSC::EncodedJSValue Bun__ERR_MISSING_ARGS(JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue arg1, JSC::EncodedJSValue arg2, JSC::EncodedJSValue arg3)
-{
-    JSC::VM& vm = globalObject->vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-
-    if (arg1 == 0) {
-        JSC::throwTypeError(globalObject, scope, "requires at least 1 argument"_s);
-        return {};
-    }
-
-    auto name1 = JSValue::decode(arg1).toWTFString(globalObject);
-    RETURN_IF_EXCEPTION(scope, {});
-
-    if (arg2 == 0) {
-        // 1 arg name passed
-        auto message = makeString("The \""_s, name1, "\" argument must be specified"_s);
-        return JSC::JSValue::encode(createError(globalObject, ErrorCode::ERR_MISSING_ARGS, message));
-    }
-
-    auto name2 = JSValue::decode(arg2).toWTFString(globalObject);
-    RETURN_IF_EXCEPTION(scope, {});
-
-    if (arg3 == 0) {
-        // 2 arg names passed
-        auto message = makeString("The \""_s, name1, "\" and \""_s, name2, "\" arguments must be specified"_s);
-        return JSC::JSValue::encode(createError(globalObject, ErrorCode::ERR_MISSING_ARGS, message));
-    }
-
-    auto name3 = JSValue::decode(arg3).toWTFString(globalObject);
-    RETURN_IF_EXCEPTION(scope, {});
-
-    // 3 arg names passed
-    auto message = makeString("The \""_s, name1, "\", \""_s, name2, "\", and \""_s, name3, "\" arguments must be specified"_s);
-    return JSC::JSValue::encode(createError(globalObject, ErrorCode::ERR_MISSING_ARGS, message));
-}
-extern "C" JSC::EncodedJSValue Bun__ERR_MISSING_ARGS_static(JSC::JSGlobalObject* globalObject, const ZigString* arg1, const ZigString* arg2, const ZigString* arg3)
-{
-    JSC::VM& vm = globalObject->vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-
-    if (arg1 == nullptr) {
-        JSC::throwTypeError(globalObject, scope, "requires at least 1 argument"_s);
-        return {};
-    }
-
-    auto name1 = std::span<const unsigned char>(arg1->ptr, arg1->len);
-    ASSERT(WTF::charactersAreAllASCII(name1));
-
-    if (arg2 == nullptr) {
-        // 1 arg name passed
-        auto message = makeString("The \""_s, name1, "\" argument must be specified"_s);
-        return JSC::JSValue::encode(createError(globalObject, ErrorCode::ERR_MISSING_ARGS, message));
-    }
-
-    auto name2 = std::span<const unsigned char>(arg2->ptr, arg2->len);
-    ASSERT(WTF::charactersAreAllASCII(name2));
-
-    if (arg3 == nullptr) {
-        // 2 arg names passed
-        auto message = makeString("The \""_s, name1, "\" and \""_s, name2, "\" arguments must be specified"_s);
-        return JSC::JSValue::encode(createError(globalObject, ErrorCode::ERR_MISSING_ARGS, message));
-    }
-
-    auto name3 = std::span<const unsigned char>(arg3->ptr, arg3->len);
-    ASSERT(WTF::charactersAreAllASCII(name3));
-
-    // 3 arg names passed
-    auto message = makeString("The \""_s, name1, "\", \""_s, name2, "\", and \""_s, name3, "\" arguments must be specified"_s);
-    return JSC::JSValue::encode(createError(globalObject, ErrorCode::ERR_MISSING_ARGS, message));
-}
-
 JSC_DEFINE_HOST_FUNCTION(jsFunction_ERR_IPC_CHANNEL_CLOSED, (JSC::JSGlobalObject * globalObject, JSC::CallFrame*))
-{
-    return Bun__ERR_IPC_CHANNEL_CLOSED(globalObject);
-}
-extern "C" JSC::EncodedJSValue Bun__ERR_IPC_CHANNEL_CLOSED(JSC::JSGlobalObject* globalObject)
 {
     return JSC::JSValue::encode(createError(globalObject, ErrorCode::ERR_IPC_CHANNEL_CLOSED, "Channel closed."_s));
 }

src/bun.js/bindings/bindings.zig

@@ -2927,6 +2927,17 @@ pub const JSGlobalObject = opaque {
         this.vm().throwError(this, err);
     }
 
+    pub inline fn throwMissingArgumentsValue(this: *JSGlobalObject, comptime arg_names: []const []const u8) JSValue {
+        switch (arg_names.len) {
+            0 => @compileError("requires at least one argument"),
+            1 => this.ERR_MISSING_ARGS("The \"{s}\" argument must be specified", .{arg_names[0]}).throw(),
+            2 => this.ERR_MISSING_ARGS("The \"{s}\" and \"{s}\" arguments must be specified", .{ arg_names[0], arg_names[1] }).throw(),
+            3 => this.ERR_MISSING_ARGS("The \"{s}\", \"{s}\", and \"{s}\" arguments must be specified", .{ arg_names[0], arg_names[1], arg_names[2] }).throw(),
+            else => @compileError("implement this message"),
+        }
+        return .zero;
+    }
+
     pub fn createInvalidArgumentType(
         this: *JSGlobalObject,
         comptime name_: []const u8,
@@ -3370,22 +3381,12 @@ pub const JSGlobalObject = opaque {
             (!opts.allowArray and value.isArray()) or
             (!value.isObject() and (!opts.allowFunction or !value.isFunction())))
         {
-            this.throwValue(this.ERR_INVALID_ARG_TYPE_static(
-                ZigString.static(arg_name),
-                ZigString.static("object"),
-                value,
-            ));
+            _ = this.throwInvalidArgumentTypeValue(arg_name, "object", value);
             return false;
         }
         return true;
     }
 
-    extern fn Bun__ERR_INVALID_ARG_TYPE_static(*JSGlobalObject, *const ZigString, *const ZigString, JSValue) JSValue;
-    /// Caller asserts 'arg_name' and 'etype' are utf-8 literals.
-    pub fn ERR_INVALID_ARG_TYPE_static(this: *JSGlobalObject, arg_name: *const ZigString, etype: *const ZigString, atype: JSValue) JSValue {
-        return Bun__ERR_INVALID_ARG_TYPE_static(this, arg_name, etype, atype);
-    }
-
     pub fn throwRangeError(this: *JSGlobalObject, value: anytype, options: bun.fmt.OutOfRangeOptions) void {
         // This works around a Zig compiler bug
         // when using this.ERR_OUT_OF_RANGE.
@@ -3466,11 +3467,6 @@ pub const JSGlobalObject = opaque {
         return default;
     }
 
-    extern fn Bun__ERR_MISSING_ARGS_static(*JSGlobalObject, *const ZigString, ?*const ZigString, ?*const ZigString) JSValue;
-    pub fn ERR_MISSING_ARGS_static(this: *JSGlobalObject, arg1: *const ZigString, arg2: ?*const ZigString, arg3: ?*const ZigString) JSValue {
-        return Bun__ERR_MISSING_ARGS_static(this, arg1, arg2, arg3);
-    }
-
     pub usingnamespace @import("ErrorCode").JSGlobalObjectExtensions;
 
     extern fn JSC__JSGlobalObject__bunVM(*JSGlobalObject) *VM;

src/bun.js/javascript.zig

@@ -474,14 +474,10 @@ pub export fn Bun__Process__send(
     };
 
     if (message.isUndefined()) {
-        return globalObject.throwValueRet(globalObject.ERR_MISSING_ARGS_static(ZigString.static("message"), null, null));
+        return globalObject.throwMissingArgumentsValue(&.{"message"});
     }
     if (!message.isString() and !message.isObject() and !message.isNumber() and !message.isBoolean()) {
-        return globalObject.throwValueRet(globalObject.ERR_INVALID_ARG_TYPE_static(
-            ZigString.static("message"),
-            ZigString.static("string, object, number, or boolean"),
-            message,
-        ));
+        return globalObject.throwInvalidArgumentTypeValue("message", "string, object, number, or boolean", message);
     }
 
     const good = ipc_instance.data.serializeAndSend(globalObject, message);

src/bun.js/node/node_cluster_binding.zig

@@ -26,18 +26,14 @@ pub fn sendHelperChild(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFram
         return .false;
     }
     if (message.isUndefined()) {
-        return globalThis.throwValueRet(globalThis.ERR_MISSING_ARGS_static(ZigString.static("message"), null, null));
+        return globalThis.throwMissingArgumentsValue(&.{"message"});
     }
     if (!handle.isNull()) {
         globalThis.throw("passing 'handle' not implemented yet", .{});
         return .zero;
     }
     if (!message.isObject()) {
-        return globalThis.throwValueRet(globalThis.ERR_INVALID_ARG_TYPE_static(
-            ZigString.static("message"),
-            ZigString.static("object"),
-            message,
-        ));
+        return globalThis.throwInvalidArgumentTypeValue("message", "object", message);
     }
     if (callback.isFunction()) {
         child_singleton.callbacks.put(bun.default_allocator, child_singleton.seq, JSC.Strong.create(callback, globalThis)) catch bun.outOfMemory();
@@ -188,14 +184,10 @@ pub fn sendHelperPrimary(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFr
     const ipc_data = subprocess.ipc() orelse return .false;
 
     if (message.isUndefined()) {
-        return globalThis.throwValueRet(globalThis.ERR_MISSING_ARGS_static(ZigString.static("message"), null, null));
+        return globalThis.throwMissingArgumentsValue(&.{"message"});
     }
     if (!message.isObject()) {
-        return globalThis.throwValueRet(globalThis.ERR_INVALID_ARG_TYPE_static(
-            ZigString.static("message"),
-            ZigString.static("object"),
-            message,
-        ));
+        return globalThis.throwInvalidArgumentTypeValue("message", "object", message);
     }
     if (callback.isFunction()) {
         ipc_data.internal_msg_queue.callbacks.put(bun.default_allocator, ipc_data.internal_msg_queue.seq, JSC.Strong.create(callback, globalThis)) catch bun.outOfMemory();
@@ -267,11 +259,7 @@ pub fn setRef(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.
         return globalObject.throwValueRet(globalObject.ERR_MISSING_ARGS_1(ZigString.static("enabled").toJS(globalObject)));
     }
     if (!arguments[0].isBoolean()) {
-        return globalObject.throwValueRet(globalObject.ERR_INVALID_ARG_TYPE_static(
-            ZigString.static("enabled"),
-            ZigString.static("boolean"),
-            arguments[0],
-        ));
+        return globalObject.throwInvalidArgumentTypeValue("enabled", "boolean", arguments[0]);
     }
 
     const enabled = arguments[0].toBoolean();

src/bun.js/node/node_fs.zig

@@ -1638,11 +1638,7 @@ pub const Arguments = struct {
 
                 arguments.eat();
                 if (!uid_value.isNumber()) {
-                    ctx.throwValue(ctx.ERR_INVALID_ARG_TYPE_static(
-                        JSC.ZigString.static("uid"),
-                        JSC.ZigString.static("number"),
-                        uid_value,
-                    ));
+                    _ = ctx.throwInvalidArgumentTypeValue("uid", "number", uid_value);
                     return null;
                 }
                 break :brk @as(uid_t, @intCast(uid_value.toInt32()));
@@ -1663,11 +1659,7 @@ pub const Arguments = struct {
 
                 arguments.eat();
                 if (!gid_value.isNumber()) {
-                    ctx.throwValue(ctx.ERR_INVALID_ARG_TYPE_static(
-                        JSC.ZigString.static("gid"),
-                        JSC.ZigString.static("number"),
-                        gid_value,
-                    ));
+                    _ = ctx.throwInvalidArgumentTypeValue("gid", "number", gid_value);
                     return null;
                 }
                 break :brk @as(gid_t, @intCast(gid_value.toInt32()));