Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

zig: error dead code removal #13989

Open
wants to merge 5 commits into
base: main
Choose a base branch
from
Open

zig: error dead code removal #13989

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
5 commits
Select commit Hold shift + click to select a range
208ffdf
remove ERR_INVALID_ARG_TYPE_static
nektro Sep 17, 2024
d0a8eb2
more dead code removal
nektro Sep 17, 2024
9a29978
Merge branch 'main' into nektro-patch-11207
nektro Sep 18, 2024
577b619
Merge branch 'main' into nektro-patch-11207
nektro Sep 24, 2024
d4c8812
make argument list to throwMissingArgumentsValue must be comptime-known
nektro Sep 24, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
6 changes: 1 addition & 5 deletions src/bun.js/api/js_brotli.zig
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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;
}
Expand Down
100 changes: 0 additions & 100 deletions src/bun.js/bindings/ErrorCode.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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__) \
Expand Down Expand Up @@ -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();
Expand Down Expand Up @@ -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));
}
Expand Down
28 changes: 12 additions & 16 deletions src/bun.js/bindings/bindings.zig
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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,
Expand Down Expand Up @@ -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.
Expand Down Expand Up @@ -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;
Expand Down
8 changes: 2 additions & 6 deletions src/bun.js/javascript.zig
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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);
Expand Down
22 changes: 5 additions & 17 deletions src/bun.js/node/node_cluster_binding.zig
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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();
Expand Down Expand Up @@ -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();
Expand Down Expand Up @@ -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();
Expand Down
12 changes: 2 additions & 10 deletions src/bun.js/node/node_fs.zig
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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()));
Expand All @@ -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()));
Expand Down
Loading