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

Remove two usages of cppFn() #17278

Merged
merged 2 commits into from
Feb 12, 2025
Merged

Remove two usages of cppFn() #17278

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
20493c8
Remove some usages of cppFn
Jarred-Sumner Feb 12, 2025
00fa421
Update bindings.zig
Jarred-Sumner Feb 12, 2025
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
197 changes: 81 additions & 116 deletions src/bun.js/bindings/bindings.zig
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2169,12 +2169,9 @@ pub const JSModuleLoader = extern struct {
exception,
});
}

pub fn loadAndEvaluateModule(globalObject: *JSGlobalObject, module_name: *const bun.String) ?*JSInternalPromise {
return shim.cppFn("loadAndEvaluateModule", .{
globalObject,
module_name,
});
extern fn JSC__JSModuleLoader__loadAndEvaluateModule(arg0: *JSGlobalObject, arg1: ?*const String) *JSInternalPromise;
pub fn loadAndEvaluateModule(globalObject: *JSGlobalObject, module_name: ?*const bun.String) ?*JSInternalPromise {
return JSC__JSModuleLoader__loadAndEvaluateModule(globalObject, module_name);
}

extern fn JSModuleLoader__import(*JSGlobalObject, *const bun.String) *JSInternalPromise;
Expand Down Expand Up @@ -2222,11 +2219,15 @@ pub const CommonAbortReason = enum(u8) {
};

pub const AbortSignal = extern opaque {
pub const shim = Shimmer("WebCore", "AbortSignal", @This());
const cppFn = shim.cppFn;
pub const include = "webcore/AbortSignal.h";
pub const name = "WebCore::AbortSignal";
pub const namespace = "WebCore";
extern fn WebCore__AbortSignal__aborted(arg0: *AbortSignal) bool;
extern fn WebCore__AbortSignal__abortReason(arg0: *AbortSignal) JSValue;
extern fn WebCore__AbortSignal__addListener(arg0: *AbortSignal, arg1: ?*anyopaque, ArgFn2: ?*const fn (?*anyopaque, JSValue) callconv(.C) void) *AbortSignal;
extern fn WebCore__AbortSignal__cleanNativeBindings(arg0: *AbortSignal, arg1: ?*anyopaque) void;
extern fn WebCore__AbortSignal__create(arg0: *JSGlobalObject) JSValue;
extern fn WebCore__AbortSignal__fromJS(JSValue0: JSValue) ?*AbortSignal;
extern fn WebCore__AbortSignal__ref(arg0: *AbortSignal) *AbortSignal;
extern fn WebCore__AbortSignal__toJS(arg0: *AbortSignal, arg1: *JSGlobalObject) JSValue;
extern fn WebCore__AbortSignal__unref(arg0: *AbortSignal) void;

pub fn listen(
this: *AbortSignal,
Expand All @@ -2253,11 +2254,11 @@ pub const AbortSignal = extern opaque {
ctx: ?*anyopaque,
callback: *const fn (?*anyopaque, JSValue) callconv(.C) void,
) *AbortSignal {
return cppFn("addListener", .{ this, ctx, callback });
return WebCore__AbortSignal__addListener(this, ctx, callback);
}

pub fn cleanNativeBindings(this: *AbortSignal, ctx: ?*anyopaque) void {
return cppFn("cleanNativeBindings", .{ this, ctx });
return WebCore__AbortSignal__cleanNativeBindings(this, ctx);
}

extern fn WebCore__AbortSignal__signal(*AbortSignal, *JSC.JSGlobalObject, CommonAbortReason) void;
Expand All @@ -2284,12 +2285,12 @@ pub const AbortSignal = extern opaque {

/// This function is not threadsafe. aborted is a boolean, not an atomic!
pub fn aborted(this: *AbortSignal) bool {
return cppFn("aborted", .{this});
return WebCore__AbortSignal__aborted(this);
}

/// This function is not threadsafe. JSValue cannot safely be passed between threads.
pub fn abortReason(this: *AbortSignal) JSValue {
return cppFn("abortReason", .{this});
return WebCore__AbortSignal__abortReason(this);
}

extern fn WebCore__AbortSignal__reasonIfAborted(*AbortSignal, *JSC.JSGlobalObject, *u8) JSValue;
Expand Down Expand Up @@ -2327,11 +2328,11 @@ pub const AbortSignal = extern opaque {
}

pub fn ref(this: *AbortSignal) *AbortSignal {
return cppFn("ref", .{this});
return WebCore__AbortSignal__ref(this);
}

pub fn unref(this: *AbortSignal) void {
cppFn("unref", .{this});
WebCore__AbortSignal__unref(this);
}

pub fn detach(this: *AbortSignal, ctx: ?*anyopaque) void {
Expand All @@ -2340,39 +2341,44 @@ pub const AbortSignal = extern opaque {
}

pub fn fromJS(value: JSValue) ?*AbortSignal {
return cppFn("fromJS", .{value});
return WebCore__AbortSignal__fromJS(value);
}

pub fn toJS(this: *AbortSignal, global: *JSGlobalObject) JSValue {
return cppFn("toJS", .{ this, global });
return WebCore__AbortSignal__toJS(this, global);
}

pub fn create(global: *JSGlobalObject) JSValue {
return cppFn("create", .{global});
return WebCore__AbortSignal__create(global);
}

extern fn WebCore__AbortSignal__new(*JSGlobalObject) *AbortSignal;
pub fn new(global: *JSGlobalObject) *AbortSignal {
JSC.markBinding(@src());
return WebCore__AbortSignal__new(global);
}

pub const Extern = [_][]const u8{ "create", "ref", "unref", "signal", "abortReason", "aborted", "addListener", "fromJS", "toJS", "cleanNativeBindings" };
};

pub const JSPromise = extern struct {
pub const shim = Shimmer("JSC", "JSPromise", @This());
bytes: shim.Bytes,
const cppFn = shim.cppFn;
pub const include = "JavaScriptCore/JSPromise.h";
pub const name = "JSC::JSPromise";
pub const namespace = "JSC";

pub const JSPromise = opaque {
pub const Status = enum(u32) {
pending = 0, // Making this as 0, so that, we can change the status from Pending to others without masking.
fulfilled = 1,
rejected = 2,
};
extern fn JSC__JSPromise__asValue(arg0: *JSPromise, arg1: *JSGlobalObject) JSValue;
extern fn JSC__JSPromise__create(arg0: *JSGlobalObject) *JSPromise;
extern fn JSC__JSPromise__isHandled(arg0: *const JSPromise, arg1: *VM) bool;
extern fn JSC__JSPromise__reject(arg0: *JSPromise, arg1: *JSGlobalObject, JSValue2: JSValue) void;
extern fn JSC__JSPromise__rejectAsHandled(arg0: *JSPromise, arg1: *JSGlobalObject, JSValue2: JSValue) void;
extern fn JSC__JSPromise__rejectAsHandledException(arg0: *JSPromise, arg1: *JSGlobalObject, arg2: ?*JSC.Exception) void;
extern fn JSC__JSPromise__rejectedPromise(arg0: *JSGlobalObject, JSValue1: JSValue) *JSPromise;
extern fn JSC__JSPromise__rejectedPromiseValue(arg0: *JSGlobalObject, JSValue1: JSValue) JSValue;
extern fn JSC__JSPromise__resolve(arg0: *JSPromise, arg1: *JSGlobalObject, JSValue2: JSValue) void;
extern fn JSC__JSPromise__resolvedPromise(arg0: *JSGlobalObject, JSValue1: JSValue) *JSPromise;
extern fn JSC__JSPromise__resolvedPromiseValue(arg0: *JSGlobalObject, JSValue1: JSValue) JSValue;
extern fn JSC__JSPromise__result(arg0: *JSPromise, arg1: *VM) JSValue;
extern fn JSC__JSPromise__setHandled(arg0: *JSPromise, arg1: *VM) void;
extern fn JSC__JSPromise__status(arg0: *const JSPromise, arg1: *VM) JSPromise.Status;

pub fn Weak(comptime T: type) type {
return struct {
Expand Down Expand Up @@ -2404,10 +2410,6 @@ pub const JSPromise = extern struct {
this.resolve(globalThis, val);
}

pub fn resolveOnNextTick(this: *WeakType, globalThis: *JSC.JSGlobalObject, val: JSC.JSValue) void {
this.swap().resolveOnNextTick(globalThis, val);
}

pub fn init(
globalThis: *JSC.JSGlobalObject,
promise: JSValue,
Expand Down Expand Up @@ -2483,10 +2485,6 @@ pub const JSPromise = extern struct {
this.resolve(globalThis, val);
}

pub fn resolveOnNextTick(this: *Strong, globalThis: *JSC.JSGlobalObject, val: JSC.JSValue) void {
this.swap().resolveOnNextTick(globalThis, val);
}

pub fn init(globalThis: *JSC.JSGlobalObject) Strong {
return Strong{
.strong = JSC.Strong.create(
Expand Down Expand Up @@ -2566,38 +2564,37 @@ pub const JSPromise = extern struct {
return resolvedPromiseValue(globalObject, value);
}
pub fn status(this: *const JSPromise, vm: *VM) Status {
return shim.cppFn("status", .{ this, vm });
return JSC__JSPromise__status(this, vm);
}

pub fn result(this: *JSPromise, vm: *VM) JSValue {
return cppFn("result", .{ this, vm });
return JSC__JSPromise__result(this, vm);
}

pub fn isHandled(this: *const JSPromise, vm: *VM) bool {
return cppFn("isHandled", .{ this, vm });
return JSC__JSPromise__isHandled(this, vm);
}

pub fn setHandled(this: *JSPromise, vm: *VM) void {
cppFn("setHandled", .{ this, vm });
JSC__JSPromise__setHandled(this, vm);
}

pub fn resolvedPromise(globalThis: *JSGlobalObject, value: JSValue) *JSPromise {
return cppFn("resolvedPromise", .{ globalThis, value });
}

pub fn resolveOnNextTick(promise: *JSC.JSPromise, globalThis: *JSGlobalObject, value: JSC.JSValue) void {
return cppFn("resolveOnNextTick", .{ promise, globalThis, value });
return JSC__JSPromise__resolvedPromise(globalThis, value);
}

/// Create a new promise with an already fulfilled value
/// This is the faster function for doing that.
pub fn resolvedPromiseValue(globalThis: *JSGlobalObject, value: JSValue) JSValue {
return cppFn("resolvedPromiseValue", .{ globalThis, value });
return JSC__JSPromise__resolvedPromiseValue(globalThis, value);
}

pub fn rejectedPromise(globalThis: *JSGlobalObject, value: JSValue) *JSPromise {
return cppFn("rejectedPromise", .{ globalThis, value });
return JSC__JSPromise__rejectedPromise(globalThis, value);
}

pub fn rejectedPromiseValue(globalThis: *JSGlobalObject, value: JSValue) JSValue {
return cppFn("rejectedPromiseValue", .{ globalThis, value });
return JSC__JSPromise__rejectedPromiseValue(globalThis, value);
}

/// Fulfill an existing promise with the value
Expand All @@ -2612,8 +2609,9 @@ pub const JSPromise = extern struct {
}
}

cppFn("resolve", .{ this, globalThis, value });
JSC__JSPromise__resolve(this, globalThis, value);
}

pub fn reject(this: *JSPromise, globalThis: *JSGlobalObject, value: JSValue) void {
if (comptime bun.Environment.isDebug) {
const loop = JSC.VirtualMachine.get().eventLoop();
Expand All @@ -2623,39 +2621,21 @@ pub const JSPromise = extern struct {
}
}

cppFn("reject", .{ this, globalThis, value });
JSC__JSPromise__reject(this, globalThis, value);
}

pub fn rejectAsHandled(this: *JSPromise, globalThis: *JSGlobalObject, value: JSValue) void {
cppFn("rejectAsHandled", .{ this, globalThis, value });
JSC__JSPromise__rejectAsHandled(this, globalThis, value);
}

pub fn create(globalThis: *JSGlobalObject) *JSPromise {
return cppFn("create", .{globalThis});
return JSC__JSPromise__create(globalThis);
}

pub fn asValue(this: *JSPromise, globalThis: *JSGlobalObject) JSValue {
return cppFn("asValue", .{ this, globalThis });
return JSC__JSPromise__asValue(this, globalThis);
}

pub const Extern = [_][]const u8{
"asValue",
"create",
"isHandled",
"setHandled",
"reject",
"rejectAsHandled",
"rejectAsHandledException",
"rejectedPromise",
"rejectedPromiseValue",
"resolve",
"resolveOnNextTick",
"resolvedPromise",
"resolvedPromiseValue",
"result",
"status",
// "rejectException",
};

pub const Unwrapped = union(enum) {
pending,
fulfilled: JSValue,
Expand All @@ -2676,25 +2656,30 @@ pub const JSPromise = extern struct {
}
};

pub const JSInternalPromise = extern struct {
pub const shim = Shimmer("JSC", "JSInternalPromise", @This());
bytes: shim.Bytes,
const cppFn = shim.cppFn;
pub const include = "JavaScriptCore/JSInternalPromise.h";
pub const name = "JSC::JSInternalPromise";
pub const namespace = "JSC";
pub const JSInternalPromise = opaque {
extern fn JSC__JSInternalPromise__create(arg0: *JSGlobalObject) *JSInternalPromise;
extern fn JSC__JSInternalPromise__isHandled(arg0: *const JSInternalPromise, arg1: *VM) bool;
extern fn JSC__JSInternalPromise__reject(arg0: *JSInternalPromise, arg1: *JSGlobalObject, JSValue2: JSValue) void;
extern fn JSC__JSInternalPromise__rejectAsHandled(arg0: *JSInternalPromise, arg1: *JSGlobalObject, JSValue2: JSValue) void;
extern fn JSC__JSInternalPromise__rejectAsHandledException(arg0: *JSInternalPromise, arg1: *JSGlobalObject, arg2: *JSC.Exception) void;
extern fn JSC__JSInternalPromise__rejectedPromise(arg0: *JSGlobalObject, JSValue1: JSValue) *JSInternalPromise;
extern fn JSC__JSInternalPromise__resolve(arg0: *JSInternalPromise, arg1: *JSGlobalObject, JSValue2: JSValue) void;
extern fn JSC__JSInternalPromise__resolvedPromise(arg0: *JSGlobalObject, JSValue1: JSValue) *JSInternalPromise;
extern fn JSC__JSInternalPromise__result(arg0: *const JSInternalPromise, arg1: *VM) JSValue;
extern fn JSC__JSInternalPromise__setHandled(arg0: *JSInternalPromise, arg1: *VM) void;
extern fn JSC__JSInternalPromise__status(arg0: *const JSInternalPromise, arg1: *VM) JSPromise.Status;

pub fn status(this: *const JSInternalPromise, vm: *VM) JSPromise.Status {
return shim.cppFn("status", .{ this, vm });
return JSC__JSInternalPromise__status(this, vm);
}
pub fn result(this: *const JSInternalPromise, vm: *VM) JSValue {
return cppFn("result", .{ this, vm });
return JSC__JSInternalPromise__result(this, vm);
}
pub fn isHandled(this: *const JSInternalPromise, vm: *VM) bool {
return cppFn("isHandled", .{ this, vm });
return JSC__JSInternalPromise__isHandled(this, vm);
}
pub fn setHandled(this: *JSInternalPromise, vm: *VM) void {
cppFn("setHandled", .{ this, vm });
JSC__JSInternalPromise__setHandled(this, vm);
}

pub fn unwrap(promise: *JSInternalPromise, vm: *VM, mode: JSPromise.UnwrapMode) JSPromise.Unwrapped {
Expand All @@ -2709,47 +2694,29 @@ pub const JSInternalPromise = extern struct {
}

pub fn resolvedPromise(globalThis: *JSGlobalObject, value: JSValue) *JSInternalPromise {
return cppFn("resolvedPromise", .{ globalThis, value });
return JSC__JSInternalPromise__resolvedPromise(globalThis, value);
}
pub fn rejectedPromise(globalThis: *JSGlobalObject, value: JSValue) *JSInternalPromise {
return cppFn("rejectedPromise", .{ globalThis, value });
return JSC__JSInternalPromise__rejectedPromise(globalThis, value);
}

pub fn resolve(this: *JSInternalPromise, globalThis: *JSGlobalObject, value: JSValue) void {
cppFn("resolve", .{ this, globalThis, value });
JSC__JSInternalPromise__resolve(this, globalThis, value);
}
pub fn reject(this: *JSInternalPromise, globalThis: *JSGlobalObject, value: JSValue) void {
cppFn("reject", .{ this, globalThis, value });
JSC__JSInternalPromise__reject(this, globalThis, value);
}
pub fn rejectAsHandled(this: *JSInternalPromise, globalThis: *JSGlobalObject, value: JSValue) void {
cppFn("rejectAsHandled", .{ this, globalThis, value });
JSC__JSInternalPromise__rejectAsHandled(this, globalThis, value);
}

pub fn create(globalThis: *JSGlobalObject) *JSInternalPromise {
return cppFn("create", .{globalThis});
return JSC__JSInternalPromise__create(globalThis);
}

pub fn asValue(this: *JSInternalPromise) JSValue {
return JSValue.fromCell(this);
}

pub const Extern = [_][]const u8{
"create",
// "then_",
"status",
"result",
"isHandled",
"setHandled",
"resolvedPromise",
"rejectedPromise",
"resolve",
"reject",
"rejectAsHandled",
// "thenResolve_",
// "thenReject_",
// "rejectException",
"rejectAsHandledException",
};
};

pub const AnyPromise = union(enum) {
Expand Down Expand Up @@ -4512,20 +4479,18 @@ pub const JSValue = enum(i64) {
return cppFn("createInternalPromise", .{globalObject});
}

extern fn JSC__JSValue__asInternalPromise(JSValue0: JSValue) ?*JSInternalPromise;

pub fn asInternalPromise(
value: JSValue,
) ?*JSInternalPromise {
return cppFn("asInternalPromise", .{
value,
});
return JSC__JSValue__asInternalPromise(value);
}

extern fn JSC__JSValue__asPromise(JSValue0: JSValue) ?*JSPromise;
pub fn asPromise(
value: JSValue,
) ?*JSPromise {
return cppFn("asPromise", .{
value,
});
return JSC__JSValue__asPromise(value);
}

pub fn asAnyPromise(
Expand Down
1 change: 0 additions & 1 deletion src/bun.js/bindings/headers.h
View file
Open in desktop

Some generated files are not rendered by default. Learn more about how customized files appear on GitHub.

Loading