diff --git a/bridge.c b/bridge.c index b02279e..c36008a 100644 --- a/bridge.c +++ b/bridge.c @@ -1038,6 +1038,61 @@ void SetExecuteTimeout(JSRuntime *rt, time_t timeout) { } } +// ============================================================================ +// DYNAMIC IMPORT (quickjs-ng v0.18.0+) +// ============================================================================ + +static void defaultDynamicImportHandler(JSContext *ctx, const char *basename, + const char *filename, JSValue token, + JSValueConst attributes, void *opaque) { + JSValue exception = JS_UNDEFINED; + JSValue promise; + + (void)opaque; + promise = JS_LoadModule(ctx, basename, filename, attributes); + if (JS_IsException(promise)) { + exception = JS_GetException(ctx); + } + JS_FinishDynamicImport(ctx, token, promise, exception); +} + +static void goDynamicImportHandler(JSContext *ctx, const char *basename, + const char *filename, JSValue token, + JSValueConst attributes, void *opaque) { + (void)opaque; + goDynamicImport(ctx, (char *)basename, (char *)filename, token, attributes); +} + +void SetDefaultDynamicImportFunc(JSRuntime *rt) { + JS_SetDynamicImportFunc(rt, defaultDynamicImportHandler, NULL); +} + +void SetGoDynamicImportFunc(JSRuntime *rt) { + JS_SetDynamicImportFunc(rt, goDynamicImportHandler, (void *)rt); +} + +void ClearDynamicImportFunc(JSRuntime *rt) { + JS_SetDynamicImportFunc(rt, NULL, NULL); +} + +int FinishDynamicImportSuccess(JSContext *ctx, JSValue token, JSValue promise) { + return JS_FinishDynamicImport(ctx, token, promise, JS_UNDEFINED); +} + +int FinishDynamicImportWithError(JSContext *ctx, JSValue token, const char *message) { + JSValue exception = JS_NewError(ctx); + if (!JS_IsException(exception)) { + const char *msg = message ? message : "dynamic import failed"; + JS_DefinePropertyValueStr(ctx, exception, "message", + JS_NewString(ctx, msg), + JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE); + JS_DefinePropertyValueStr(ctx, exception, "name", + JS_NewString(ctx, "Error"), + JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE); + } + return JS_FinishDynamicImport(ctx, token, JS_EXCEPTION, exception); +} + // ============================================================================ // MODULE LOADING // ============================================================================ diff --git a/bridge.h b/bridge.h index 7ff5b26..0798f1f 100644 --- a/bridge.h +++ b/bridge.h @@ -132,6 +132,13 @@ extern void SetExecuteTimeout(JSRuntime *rt, time_t timeout); extern void SetPromiseRejectionTracker(JSRuntime *rt, int enabled); extern int GetTimeoutOpaqueCount(void); +// Dynamic import (quickjs-ng v0.18.0+) +extern void SetDefaultDynamicImportFunc(JSRuntime *rt); +extern void SetGoDynamicImportFunc(JSRuntime *rt); +extern void ClearDynamicImportFunc(JSRuntime *rt); +extern int FinishDynamicImportSuccess(JSContext *ctx, JSValue token, JSValue promise); +extern int FinishDynamicImportWithError(JSContext *ctx, JSValue token, const char *message); + // ============================================================================= // MODULE-RELATED DECLARATIONS - NEW FOR MODULE BUILDER // ============================================================================= diff --git a/callback_dispatch.go b/callback_dispatch.go index 616a936..fc051de 100644 --- a/callback_dispatch.go +++ b/callback_dispatch.go @@ -1,6 +1,9 @@ package quickjs -import "unsafe" +import ( + "errors" + "unsafe" +) /* #include @@ -48,6 +51,50 @@ func goInterruptHandler(runtimePtr *C.JSRuntime) C.int { return C.int(runtime.callInterruptHandler()) } +//export goDynamicImport +func goDynamicImport(ctx *C.JSContext, basename *C.char, filename *C.char, token C.JSValue, attributes C.JSValueConst) { + goCtx := getContextFromJS(ctx) + if goCtx == nil || goCtx.runtime == nil { + msg := C.CString("quickjs: context not found for dynamic import") + C.FinishDynamicImportWithError(ctx, token, msg) + C.free(unsafe.Pointer(msg)) + return + } + + rt := goCtx.runtime + tokenVal := &Value{ctx: goCtx, ref: token} + attrsVal := &Value{ctx: goCtx, ref: C.JSValue(attributes), borrowed: true} + + promise, err := rt.callDynamicImportHandler(goCtx, C.GoString(basename), C.GoString(filename), tokenVal, attrsVal) + if errors.Is(err, ErrDynamicImportPending) { + rt.registerPendingDynamicImport(goCtx, tokenVal) + return + } + + if err != nil { + msg := C.CString(err.Error()) + C.FinishDynamicImportWithError(ctx, tokenVal.ref, msg) + C.free(unsafe.Pointer(msg)) + tokenVal.ref = C.JS_NewUndefined() + if promise != nil { + promise.Free() + } + return + } + + if promise == nil || !promise.belongsTo(goCtx) { + msg := C.CString("quickjs: dynamic import handler returned nil promise") + C.FinishDynamicImportWithError(ctx, tokenVal.ref, msg) + C.free(unsafe.Pointer(msg)) + tokenVal.ref = C.JS_NewUndefined() + return + } + + C.FinishDynamicImportSuccess(ctx, tokenVal.ref, promise.ref) + tokenVal.ref = C.JS_NewUndefined() + promise.ref = C.JS_NewUndefined() +} + //export goFunctionProxy func goFunctionProxy(ctx *C.JSContext, thisVal C.JSValueConst, argc C.int, argv *C.JSValueConst, magic C.int) C.JSValue { diff --git a/context.go b/context.go index 037eb5b..153d592 100644 --- a/context.go +++ b/context.go @@ -991,6 +991,86 @@ func (ctx *Context) EvalFile(filePath string, opts ...EvalOption) *Value { return ctx.Eval(string(b), opts...) } +// LoadModuleURL loads a module via JS_LoadModule and returns its evaluate promise. +// attributes may be nil (treated as undefined). Caller must Free the returned value. +func (ctx *Context) LoadModuleURL(basename, filename string, attributes *Value) *Value { + if !ctx.hasValidRef() { + return nil + } + if attributes != nil && !attributes.belongsTo(ctx) { + return nil + } + + basePtr := C.CString(basename) + filePtr := C.CString(filename) + defer C.free(unsafe.Pointer(basePtr)) + defer C.free(unsafe.Pointer(filePtr)) + + attrs := C.JS_NewUndefined() + if attributes != nil { + attrs = attributes.ref + } + return &Value{ctx: ctx, ref: C.JS_LoadModule(ctx.ref, basePtr, filePtr, attrs)} +} + +// finishDynamicImportResultHook overrides FinishDynamicImport C return codes in tests. +var finishDynamicImportResultHook func(ret C.int) C.int + +func applyFinishDynamicImportResult(ret C.int) C.int { + if hook := finishDynamicImportResultHook; hook != nil { + return hook(ret) + } + return ret +} + +// FinishDynamicImport completes a previously deferred JS import(). +// token ownership is consumed. On success, modulePromise ownership is consumed. +// On error, modulePromise (if any) is freed by the caller still; pass nil with err set. +func (ctx *Context) FinishDynamicImport(token *Value, modulePromise *Value, err error) error { + if ctx == nil || !ctx.hasValidRef() { + // hasValidRef also enforces owner-goroutine access. + return errors.New("quickjs: context is closed") + } + if token == nil || !token.belongsTo(ctx) || token.borrowed { + return errors.New("quickjs: invalid dynamic import token") + } + + ctx.runtime.unregisterPendingDynamicImport(token) + + if err != nil { + msg := C.CString(err.Error()) + ret := applyFinishDynamicImportResult(C.FinishDynamicImportWithError(ctx.ref, token.ref, msg)) + C.free(unsafe.Pointer(msg)) + token.ref = C.JS_NewUndefined() + if modulePromise != nil { + modulePromise.Free() + } + if ret != 0 { + return errors.New("quickjs: FinishDynamicImport failed") + } + return nil + } + + if modulePromise == nil || !modulePromise.belongsTo(ctx) { + msg := C.CString("quickjs: dynamic import module promise is required") + ret := applyFinishDynamicImportResult(C.FinishDynamicImportWithError(ctx.ref, token.ref, msg)) + C.free(unsafe.Pointer(msg)) + token.ref = C.JS_NewUndefined() + if ret != 0 { + return errors.New("quickjs: FinishDynamicImport failed") + } + return nil + } + + ret := applyFinishDynamicImportResult(C.FinishDynamicImportSuccess(ctx.ref, token.ref, modulePromise.ref)) + token.ref = C.JS_NewUndefined() + modulePromise.ref = C.JS_NewUndefined() + if ret != 0 { + return errors.New("quickjs: FinishDynamicImport failed") + } + return nil +} + // LoadModule returns a js value with given code and module name. func (ctx *Context) LoadModule(code string, moduleName string, opts ...EvalOption) *Value { options := EvalOptions{ diff --git a/dynamic_import_test_helpers.go b/dynamic_import_test_helpers.go new file mode 100644 index 0000000..23ec0d9 --- /dev/null +++ b/dynamic_import_test_helpers.go @@ -0,0 +1,34 @@ +package quickjs + +/* +#include "bridge.h" +*/ +import "C" +import "unsafe" + +func drainPendingJobsForTest(rt *Runtime) { + for { + var jobCtx *C.JSContext + if C.JS_ExecutePendingJob(rt.ref, &jobCtx) <= 0 { + return + } + } +} + +func invokeGoDynamicImportForTest(ctx *Context, basename, filename string) { + basePtr := C.CString(basename) + filePtr := C.CString(filename) + defer C.free(unsafe.Pointer(basePtr)) + defer C.free(unsafe.Pointer(filePtr)) + goDynamicImport(ctx.ref, basePtr, filePtr, C.JS_NewObject(ctx.ref), C.JS_NewUndefined()) +} + +func forceFinishDynamicImportFailureForTest(enable bool) func() { + prev := finishDynamicImportResultHook + if enable { + finishDynamicImportResultHook = func(ret C.int) C.int { return 1 } + } else { + finishDynamicImportResultHook = nil + } + return func() { finishDynamicImportResultHook = prev } +} diff --git a/runtime.go b/runtime.go index 215b980..4441c9a 100644 --- a/runtime.go +++ b/runtime.go @@ -23,6 +23,25 @@ type interruptHandlerHolder struct { fn InterruptHandler } +// ErrDynamicImportPending indicates the DynamicImportHandler will finish later +// via Context.FinishDynamicImport on the owner goroutine (e.g. after Context.Schedule). +var ErrDynamicImportPending = errors.New("quickjs: dynamic import pending") + +// DynamicImportHandler handles JS import() after the microtask runs. +// token ownership transfers to the handler when returning ErrDynamicImportPending; +// otherwise the bridge finishes the import and consumes token/modulePromise. +// attributes is borrowed for the duration of the call; Dup if retaining. +type DynamicImportHandler func(ctx *Context, basename, filename string, token *Value, attributes *Value) (modulePromise *Value, err error) + +type dynamicImportHandlerHolder struct { + fn DynamicImportHandler +} + +type pendingDynamicImport struct { + ctx *Context + token *Value +} + // runtimeNewContextHook is used in tests to force JS_NewContext failure paths. // It must remain nil in production. var runtimeNewContextHook func(rt *C.JSRuntime) *C.JSContext @@ -66,17 +85,20 @@ type Runtime struct { options *Options ownerGoroutineID atomic.Uint64 ownerThreadID atomic.Uint64 - interruptHandlerState atomic.Pointer[interruptHandlerHolder] - contexts sync.Map - contextsByID sync.Map - contextIDCounter atomic.Uint64 - constructorRegistry sync.Map - classObjectRegistry sync.Map - classObjectIDsByCtx sync.Map - classObjectIDCounter atomic.Int32 - closeOnce sync.Once - closed atomic.Bool - stdHandlersInitialized bool + interruptHandlerState atomic.Pointer[interruptHandlerHolder] + dynamicImportHandlerState atomic.Pointer[dynamicImportHandlerHolder] + defaultDynamicImportEnabled atomic.Bool + pendingDynamicImports sync.Map // map[uintptr]*pendingDynamicImport + contexts sync.Map + contextsByID sync.Map + contextIDCounter atomic.Uint64 + constructorRegistry sync.Map + classObjectRegistry sync.Map + classObjectIDsByCtx sync.Map + classObjectIDCounter atomic.Int32 + closeOnce sync.Once + closed atomic.Bool + stdHandlersInitialized bool } // isAlive reports whether the runtime still has a valid native handle and @@ -552,7 +574,7 @@ func NewRuntime(opts ...Option) *Runtime { } if rt.options.moduleImport { - rt.SetModuleImport(rt.options.moduleImport) + rt.SetModuleImport(true) } // Set timeout after other options (will override interrupt handler) @@ -602,9 +624,11 @@ func (r *Runtime) Close() { return } - r.closeOnce.Do(func() { + r.closeOnce.Do(func() { r.closed.Store(true) + r.failClosePendingDynamicImports() + var contexts []*Context r.contexts.Range(func(_, value interface{}) bool { if ctx, ok := value.(*Context); ok { @@ -624,7 +648,10 @@ func (r *Runtime) Close() { ref := r.ref r.interruptHandlerState.Store(nil) + r.dynamicImportHandlerState.Store(nil) + r.defaultDynamicImportEnabled.Store(false) C.ClearInterruptHandler(ref) + C.ClearDynamicImportFunc(ref) C.SetPromiseRejectionTracker(ref, 0) r.constructorRegistry.Range(func(key, _ interface{}) bool { @@ -919,6 +946,8 @@ func (r *Runtime) SetStripInfo(strip int) { // SetModuleImport installs or clears the default quickjs-libc file/module loader. // When disabled, import resolution fails closed unless another loader is installed. +// Note: this does not install JS_SetDynamicImportFunc; use SetDefaultDynamicImport +// or SetDynamicImportHandler for the v0.18+ dynamic-import callback path. func (r *Runtime) SetModuleImport(moduleImport bool) { if r == nil { return @@ -938,6 +967,122 @@ func (r *Runtime) SetModuleImport(moduleImport bool) { C.JS_SetModuleLoaderFunc2(r.ref, (*C.JSModuleNormalizeFunc)(unsafe.Pointer(nil)), nil, nil, unsafe.Pointer(nil)) } +// SetDefaultDynamicImport installs or clears the qjs-compatible C stub +// (JS_LoadModule + JS_FinishDynamicImport). Prefer the legacy sync import() path +// (callback unset) when using ModuleBuilder virtual modules. +func (r *Runtime) SetDefaultDynamicImport(enabled bool) { + if r == nil { + return + } + if !r.ensureOwnerAccess() { + return + } + r.mu.Lock() + defer r.mu.Unlock() + if r.closed.Load() || r.ref == nil { + return + } + r.defaultDynamicImportEnabled.Store(enabled) + if r.dynamicImportHandlerState.Load() != nil { + return // custom Go handler wins until cleared + } + if enabled { + C.SetDefaultDynamicImportFunc(r.ref) + return + } + C.ClearDynamicImportFunc(r.ref) +} + +// SetDynamicImportHandler installs a custom JS import() handler. +// Passing nil clears the custom handler; restores SetDefaultDynamicImport stub if enabled. +func (r *Runtime) SetDynamicImportHandler(handler DynamicImportHandler) { + if r == nil { + return + } + if !r.ensureOwnerAccess() { + return + } + r.mu.Lock() + defer r.mu.Unlock() + if r.closed.Load() || r.ref == nil { + return + } + if handler != nil { + r.dynamicImportHandlerState.Store(&dynamicImportHandlerHolder{fn: handler}) + C.SetGoDynamicImportFunc(r.ref) + return + } + r.clearDynamicImportHandlerLocked() +} + +// ClearDynamicImportHandler clears the custom dynamic-import handler. +func (r *Runtime) ClearDynamicImportHandler() { + if r == nil { + return + } + if !r.ensureOwnerAccess() { + return + } + r.mu.Lock() + defer r.mu.Unlock() + if r.ref == nil { + return + } + r.clearDynamicImportHandlerLocked() +} + +func (r *Runtime) clearDynamicImportHandlerLocked() { + r.dynamicImportHandlerState.Store(nil) + if r.defaultDynamicImportEnabled.Load() { + C.SetDefaultDynamicImportFunc(r.ref) + return + } + C.ClearDynamicImportFunc(r.ref) +} + +func (r *Runtime) callDynamicImportHandler(ctx *Context, basename, filename string, token *Value, attributes *Value) (*Value, error) { + holder := r.dynamicImportHandlerState.Load() + if holder == nil || holder.fn == nil { + return nil, errors.New("quickjs: dynamic import handler not set") + } + return holder.fn(ctx, basename, filename, token, attributes) +} + +func (r *Runtime) registerPendingDynamicImport(ctx *Context, token *Value) { + if r == nil || token == nil { + return + } + r.pendingDynamicImports.Store(uintptr(unsafe.Pointer(token)), &pendingDynamicImport{ctx: ctx, token: token}) +} + +func (r *Runtime) unregisterPendingDynamicImport(token *Value) { + if r == nil || token == nil { + return + } + r.pendingDynamicImports.Delete(uintptr(unsafe.Pointer(token))) +} + +func (r *Runtime) failClosePendingDynamicImports() { + r.pendingDynamicImports.Range(func(key, value interface{}) bool { + r.pendingDynamicImports.Delete(key) + pending, ok := value.(*pendingDynamicImport) + if !ok || pending == nil || pending.token == nil { + return true + } + token := pending.token + ctx := pending.ctx + if ctx != nil && ctx.hasValidRef() { + msg := C.CString("quickjs: runtime closed with pending dynamic import") + C.FinishDynamicImportWithError(ctx.ref, token.ref, msg) + C.free(unsafe.Pointer(msg)) + token.ref = C.JS_NewUndefined() + return true + } + token.ref = C.JS_NewUndefined() + return true + }) +} + // SetInterruptHandler sets a user interrupt handler using simplified approach. // This will override any timeout handler (expected behavior) func (r *Runtime) SetInterruptHandler(handler InterruptHandler) { diff --git a/runtime_test.go b/runtime_test.go index f91b255..44dda55 100644 --- a/runtime_test.go +++ b/runtime_test.go @@ -2,11 +2,13 @@ package quickjs import ( "errors" + "fmt" "strings" "sync" "sync/atomic" "testing" "time" + "unsafe" "github.com/stretchr/testify/require" ) @@ -978,6 +980,396 @@ func TestRuntimeSetModuleImportToggle(t *testing.T) { requireImportFailure(ctx) } +func TestRuntimeDynamicImportHandlerSync(t *testing.T) { + rt := NewRuntime(WithModuleImport(true)) + defer rt.Close() + + calls := 0 + rt.SetDynamicImportHandler(func(ctx *Context, basename, filename string, token *Value, attributes *Value) (*Value, error) { + calls++ + require.NotNil(t, token) + require.NotNil(t, attributes) + promise := ctx.LoadModuleURL(basename, filename, attributes) + require.NotNil(t, promise) + return promise, nil + }) + + ctx := rt.NewContext() + defer ctx.Close() + + result := ctx.Eval(` + (async function() { + const mod = await import("./test/fib_module.js"); + return mod.fib(6); + })() + `, EvalAwait(true)) + defer result.Free() + + require.False(t, result.IsException(), "%v", ctx.Exception()) + require.EqualValues(t, 8, result.ToInt32()) + require.GreaterOrEqual(t, calls, 1) + + rt.ClearDynamicImportHandler() + // Legacy sync import() path (no dynamic-import callback) still loads files. + result2 := ctx.Eval(` + (async function() { + const mod = await import("./test/fib_module.js"); + return mod.fib(5); + })() + `, EvalAwait(true)) + defer result2.Free() + require.False(t, result2.IsException(), "%v", ctx.Exception()) + require.EqualValues(t, 5, result2.ToInt32()) + + rt.SetDefaultDynamicImport(true) + result3 := ctx.Eval(` + (async function() { + const mod = await import("./test/fib_module.js"); + return mod.fib(4); + })() + `, EvalAwait(true)) + defer result3.Free() + require.False(t, result3.IsException(), "%v", ctx.Exception()) + require.EqualValues(t, 3, result3.ToInt32()) +} + +func TestRuntimeDynamicImportHandlerError(t *testing.T) { + rt := NewRuntime(WithModuleImport(true)) + defer rt.Close() + + rt.SetDynamicImportHandler(func(ctx *Context, basename, filename string, token *Value, attributes *Value) (*Value, error) { + return nil, fmt.Errorf("blocked import: %s", filename) + }) + + ctx := rt.NewContext() + defer ctx.Close() + + result := ctx.Eval(`(async () => import("./test/fib_module.js"))()`, EvalAwait(true)) + defer result.Free() + require.True(t, result.IsException()) + err := ctx.Exception() + require.Error(t, err) + require.Contains(t, err.Error(), "blocked import") +} + +func TestRuntimeDynamicImportHandlerDeferred(t *testing.T) { + rt := NewRuntime(WithModuleImport(true)) + defer rt.Close() + + var pendingToken *Value + rt.SetDynamicImportHandler(func(ctx *Context, basename, filename string, token *Value, attributes *Value) (*Value, error) { + pendingToken = token + base, file := basename, filename + attrs := ctx.duplicateValue(attributes) + ok := ctx.Schedule(func(c *Context) { + promise := c.LoadModuleURL(base, file, attrs) + require.NoError(t, c.FinishDynamicImport(pendingToken, promise, nil)) + attrs.Free() + }) + require.True(t, ok) + return nil, ErrDynamicImportPending + }) + + ctx := rt.NewContext() + defer ctx.Close() + + // EvalAwait uses C EvalAndAwait and does not drain Context.Schedule; + // deferred FinishDynamicImport requires Go Await/ProcessJobs. + promise := ctx.Eval(` + (async function() { + const mod = await import("./test/fib_module.js"); + return mod.fib(7); + })() + `) + require.NotNil(t, promise) + result := ctx.Await(promise) + defer result.Free() + + require.False(t, result.IsException(), "%v", ctx.Exception()) + require.EqualValues(t, 13, result.ToInt32()) + require.NotNil(t, pendingToken) +} + +func TestRuntimeDynamicImportFailClosed(t *testing.T) { + var nilRT *Runtime + nilRT.SetDynamicImportHandler(func(ctx *Context, basename, filename string, token *Value, attributes *Value) (*Value, error) { + return nil, nil + }) + nilRT.ClearDynamicImportHandler() + nilRT.SetDefaultDynamicImport(true) + nilRT.registerPendingDynamicImport(nil, nil) + nilRT.unregisterPendingDynamicImport(nil) + + rt := NewRuntime() + rt.Close() + rt.SetDynamicImportHandler(func(ctx *Context, basename, filename string, token *Value, attributes *Value) (*Value, error) { + return nil, nil + }) + rt.ClearDynamicImportHandler() + rt.SetDefaultDynamicImport(true) + rt.SetDefaultDynamicImport(false) + + closed := NewRuntime() + ctx := closed.NewContext() + require.Error(t, ctx.FinishDynamicImport(nil, nil, fmt.Errorf("x"))) + ctx.Close() + require.Error(t, ctx.FinishDynamicImport(nil, nil, fmt.Errorf("x"))) + require.Nil(t, ctx.LoadModuleURL(".", "./x.js", nil)) + closed.Close() +} + +func TestRuntimeDynamicImportDefaultFlagWithCustomHandler(t *testing.T) { + rt := NewRuntime(WithModuleImport(true)) + defer rt.Close() + ctx := rt.NewContext() + defer ctx.Close() + + rt.SetDynamicImportHandler(func(ctx *Context, basename, filename string, token *Value, attributes *Value) (*Value, error) { + return nil, fmt.Errorf("custom still active") + }) + rt.SetDefaultDynamicImport(true) // custom handler wins + result := ctx.Eval(`(async () => import("./test/fib_module.js"))()`, EvalAwait(true)) + defer result.Free() + require.True(t, result.IsException()) + require.Contains(t, ctx.Exception().Error(), "custom still active") + + rt.ClearDynamicImportHandler() // restores default stub because flag stayed enabled + result2 := ctx.Eval(` + (async function() { + const mod = await import("./test/fib_module.js"); + return mod.fib(3); + })() + `, EvalAwait(true)) + defer result2.Free() + require.False(t, result2.IsException(), "%v", ctx.Exception()) + require.EqualValues(t, 2, result2.ToInt32()) + + rt.SetDefaultDynamicImport(false) + rt.SetDynamicImportHandler(nil) +} + +func TestRuntimeDynamicImportOwnerDenied(t *testing.T) { + oldGIDHook := ownerCheckCurrentGoroutineID + oldThreadHook := ownerCheckCurrentThreadID + defer func() { + ownerCheckCurrentGoroutineID = oldGIDHook + ownerCheckCurrentThreadID = oldThreadHook + }() + + var gid atomic.Uint64 + gid.Store(601) + ownerCheckCurrentGoroutineID = func() uint64 { return gid.Load() } + ownerCheckCurrentThreadID = func() uint64 { return 1 } + + rt := NewRuntime(WithModuleImport(true)) + defer rt.Close() + ctx := rt.NewContext() + defer ctx.Close() + + gid.Store(602) + rt.SetDefaultDynamicImport(true) + rt.SetDynamicImportHandler(func(ctx *Context, basename, filename string, token *Value, attributes *Value) (*Value, error) { + return nil, nil + }) + rt.ClearDynamicImportHandler() + tok := ctx.NewString("tok") + require.Error(t, ctx.FinishDynamicImport(tok, nil, fmt.Errorf("x"))) + tok.Free() +} + +func TestRuntimeDynamicImportGoDispatchBranches(t *testing.T) { + rt := NewRuntime(WithModuleImport(true)) + defer rt.Close() + ctx := rt.NewContext() + defer ctx.Close() + + _, err := rt.callDynamicImportHandler(ctx, ".", "./x.js", nil, nil) + require.Error(t, err) + + calls := 0 + rt.SetDynamicImportHandler(func(c *Context, basename, filename string, token *Value, attributes *Value) (*Value, error) { + calls++ + return c.NewString("leftover"), fmt.Errorf("fail with promise") + }) + invokeGoDynamicImportForTest(ctx, ".", "./missing.js") + require.Equal(t, 1, calls) + _ = ctx.Exception() + + rt.SetDynamicImportHandler(func(c *Context, basename, filename string, token *Value, attributes *Value) (*Value, error) { + calls++ + return nil, nil + }) + invokeGoDynamicImportForTest(ctx, ".", "./missing.js") + require.Equal(t, 2, calls) + _ = ctx.Exception() + + other := rt.NewContext() + var foreignPromise *Value + rt.SetDynamicImportHandler(func(c *Context, basename, filename string, token *Value, attributes *Value) (*Value, error) { + calls++ + foreignPromise = other.NewString("foreign-promise") + return foreignPromise, nil + }) + invokeGoDynamicImportForTest(ctx, ".", "./missing.js") + require.Equal(t, 3, calls) + if foreignPromise != nil { + foreignPromise.Free() + } + other.Close() + _ = ctx.Exception() + + rt.SetDynamicImportHandler(func(c *Context, basename, filename string, token *Value, attributes *Value) (*Value, error) { + calls++ + return c.LoadModuleURL(basename, filename, attributes), nil + }) + invokeGoDynamicImportForTest(ctx, ".", "./test/fib_module.js") + require.Equal(t, 4, calls) + rt.ClearDynamicImportHandler() + + // Missing context / nil-runtime early returns (after handler coverage above). + unregisterContext(ctx.ref) + invokeGoDynamicImportForTest(ctx, ".", "./missing.js") + registerContext(ctx.ref, ctx) + + savedRT := ctx.runtime + ctx.runtime = nil + invokeGoDynamicImportForTest(ctx, ".", "./missing.js") + ctx.runtime = savedRT +} + +func TestRuntimeDynamicImportLoadModuleURLAttrs(t *testing.T) { + rt := NewRuntime(WithModuleImport(true)) + defer rt.Close() + ctx := rt.NewContext() + defer ctx.Close() + + other := rt.NewContext() + foreign := other.NewString("attr") + require.Nil(t, ctx.LoadModuleURL(".", "./test/fib_module.js", foreign)) + foreign.Free() + other.Close() + + attrs := ctx.NewObject() + mod := ctx.LoadModuleURL(".", "./test/fib_module.js", attrs) + require.NotNil(t, mod) + mod.Free() + attrs.Free() +} + +func TestRuntimeDynamicImportFinishErrorAndNilPromise(t *testing.T) { + rt := NewRuntime(WithModuleImport(true)) + defer rt.Close() + + var pendingToken *Value + rt.SetDynamicImportHandler(func(c *Context, basename, filename string, token *Value, attributes *Value) (*Value, error) { + pendingToken = token + base, file := basename, filename + ok := c.Schedule(func(c *Context) { + leftover := c.NewString("to-free") + require.NoError(t, c.FinishDynamicImport(pendingToken, leftover, fmt.Errorf("deferred fail"))) + _ = base + _ = file + }) + require.True(t, ok) + return nil, ErrDynamicImportPending + }) + + ctx := rt.NewContext() + defer ctx.Close() + p := ctx.Eval(`(async () => import("./test/fib_module.js"))()`) + require.NotNil(t, p) + awaited := ctx.Await(p) + if awaited != nil { + awaited.Free() + } + require.NotNil(t, pendingToken) + + pendingToken = nil + rt.SetDynamicImportHandler(func(c *Context, basename, filename string, token *Value, attributes *Value) (*Value, error) { + pendingToken = token + ok := c.Schedule(func(c *Context) { + borrowed := &Value{ctx: c, ref: pendingToken.ref, borrowed: true} + require.Error(t, c.FinishDynamicImport(borrowed, nil, nil)) + require.NoError(t, c.FinishDynamicImport(pendingToken, nil, nil)) + }) + require.True(t, ok) + return nil, ErrDynamicImportPending + }) + p2 := ctx.Eval(`(async () => import("./test/fib_module.js"))()`) + require.NotNil(t, p2) + awaited2 := ctx.Await(p2) + if awaited2 != nil { + awaited2.Free() + } + require.NotNil(t, pendingToken) +} + +func TestRuntimeDynamicImportFinishFailureHook(t *testing.T) { + _ = forceFinishDynamicImportFailureForTest(false) // cover disable no-op path + + rt := NewRuntime(WithModuleImport(true)) + defer rt.Close() + restore := forceFinishDynamicImportFailureForTest(true) + defer restore() + + var pendingToken *Value + phase := 0 + rt.SetDynamicImportHandler(func(c *Context, basename, filename string, token *Value, attributes *Value) (*Value, error) { + pendingToken = token + p := phase + phase++ + ok := c.Schedule(func(c *Context) { + switch p { + case 0: + require.Error(t, c.FinishDynamicImport(pendingToken, c.NewString("x"), fmt.Errorf("hooked"))) + case 1: + require.Error(t, c.FinishDynamicImport(pendingToken, nil, nil)) + case 2: + promise := c.LoadModuleURL(basename, filename, attributes) + require.Error(t, c.FinishDynamicImport(pendingToken, promise, nil)) + } + }) + require.True(t, ok) + return nil, ErrDynamicImportPending + }) + + ctx := rt.NewContext() + defer ctx.Close() + for i := 0; i < 3; i++ { + p := ctx.Eval(`(async () => import("./test/fib_module.js"))()`) + require.NotNil(t, p) + awaited := ctx.Await(p) + if awaited != nil { + awaited.Free() + } + } + require.Equal(t, 3, phase) + _ = pendingToken +} + +func TestRuntimeDynamicImportFailClosePending(t *testing.T) { + rt := NewRuntime(WithModuleImport(true)) + ctx := rt.NewContext() + + rt.pendingDynamicImports.Store(uintptr(1), "bad-type") + rt.pendingDynamicImports.Store(uintptr(2), &pendingDynamicImport{}) + // Nil-context pending entries cannot JS_FreeValue; use an already-undefined ref. + deadTok := &Value{} + rt.pendingDynamicImports.Store(uintptr(unsafe.Pointer(deadTok)), &pendingDynamicImport{ctx: nil, token: deadTok}) + + var livePending *Value + rt.SetDynamicImportHandler(func(c *Context, basename, filename string, token *Value, attributes *Value) (*Value, error) { + livePending = token + return nil, ErrDynamicImportPending + }) + p := ctx.Eval(`(async () => import("./test/fib_module.js"))()`) + require.NotNil(t, p) + drainPendingJobsForTest(rt) + require.NotNil(t, livePending) + p.Free() + rt.Close() +} + func TestRuntimeTimeoutOpaqueLifecycle(t *testing.T) { base := timeoutOpaqueCount()