diff --git a/Source/JavaScriptCore/runtime/AbstractModuleRecord.cpp b/Source/JavaScriptCore/runtime/AbstractModuleRecord.cpp index 912df5f064e33..78f24884d12bd 100644 --- a/Source/JavaScriptCore/runtime/AbstractModuleRecord.cpp +++ b/Source/JavaScriptCore/runtime/AbstractModuleRecord.cpp @@ -1144,7 +1144,11 @@ JS_EXPORT_PRIVATE JSValue AbstractModuleRecord::evaluate(JSGlobalObject* globalO return jsUndefined(); } +#if USE(BUN_JSC_ADDITIONS) +JSPromise* AbstractModuleRecord::evaluate(JSGlobalObject* globalObject, int64_t referrerAsyncOrder) +#else JSPromise* AbstractModuleRecord::evaluate(JSGlobalObject* globalObject) +#endif { VM& vm = globalObject->vm(); @@ -1159,7 +1163,11 @@ JSPromise* AbstractModuleRecord::evaluate(JSGlobalObject* globalObject) }; if (auto* cyclicRecord = dynamicDowncast(this)) +#if USE(BUN_JSC_ADDITIONS) + return wrap(cyclicRecord->evaluate(globalObject, referrerAsyncOrder)); +#else return wrap(cyclicRecord->evaluate(globalObject)); +#endif if (auto* syntheticRecord = dynamicDowncast(this)) return wrap(syntheticRecord->evaluate(globalObject)); RELEASE_ASSERT_NOT_REACHED(); @@ -1188,7 +1196,7 @@ static void checkSafeToRecurse(JSGlobalObject* globalObject, ThrowScope& scope) } #if USE(BUN_JSC_ADDITIONS) -unsigned AbstractModuleRecord::innerModuleEvaluation(JSGlobalObject* globalObject, Vector& stack, unsigned index, int64_t asyncOrderWatermark) +unsigned AbstractModuleRecord::innerModuleEvaluation(JSGlobalObject* globalObject, Vector& stack, unsigned index, int64_t referrerAsyncOrder) #else unsigned AbstractModuleRecord::innerModuleEvaluation(JSGlobalObject* globalObject, Vector& stack, unsigned index) #endif @@ -1262,37 +1270,10 @@ unsigned AbstractModuleRecord::innerModuleEvaluation(JSGlobalObject* globalObjec for (AbstractModuleRecord* requiredModule : evaluationList) { checkSafeToRecurse(globalObject, scope); RETURN_IF_EXCEPTION(scope, invalid); -#if USE(BUN_JSC_ADDITIONS) - // Record whether this dep was already mid-TLA before our recursive - // visit. The spec (12.b.v) makes us wait on it, which is a guaranteed - // deadlock when we're running inside that very dep's TLA continuation - // (e.g. Nitro: index.mjs top-level `await fetch()` -> handler -> - // `import("./chunk")` -> chunk statically imports index.mjs). The - // pre-rewrite JS loader did not track async parents across dynamic - // imports, so it evaluated the chunk immediately with the parent's - // already-initialised bindings. Preserve that for back-compat. - // - // "Already EvaluatingAsync" alone is too broad: it also matches a - // sibling static import in the *same* Evaluate() pass that popped an - // SCC to EvaluatingAsync earlier in the walk. In that case the dep's - // body has not run yet (its bindings are TDZ) and skipping the wait - // executes the importer too early. We narrow at 12.b.v below: only - // skip when the cycle root's pendingAsyncDependencies is 0, i.e. its - // ExecuteModule/ExecuteAsyncModule has already been called and the - // bindings before its first await are initialised. For an SCC still - // queued behind an async dep the root's count is > 0. That alone is - // still insufficient: a TLA dep with no async deps of its own has - // count 0 yet may have only run to its first await within this same - // DFS, leaving post-await bindings TDZ (#30259). We additionally - // require asyncEvaluationOrder() < asyncOrderWatermark, i.e. the - // dep entered EvaluatingAsync in a *prior* Evaluate() call. - bool depWasAlreadyEvaluatingAsync = false; - if (auto* depCyclic = dynamicDowncast(requiredModule)) - depWasAlreadyEvaluatingAsync = depCyclic->status() == Status::EvaluatingAsync; // 12.a. Set index to ? InnerModuleEvaluation(requiredModule, stack, index). - unsigned result = requiredModule->innerModuleEvaluation(globalObject, stack, index, asyncOrderWatermark); +#if USE(BUN_JSC_ADDITIONS) + unsigned result = requiredModule->innerModuleEvaluation(globalObject, stack, index, referrerAsyncOrder); #else - // 12.a. Set index to ? InnerModuleEvaluation(requiredModule, stack, index). unsigned result = requiredModule->innerModuleEvaluation(globalObject, stack, index); #endif RETURN_IF_EXCEPTION(scope, invalid); @@ -1339,17 +1320,16 @@ unsigned AbstractModuleRecord::innerModuleEvaluation(JSGlobalObject* globalObjec // 12.b.v. If requiredModule.[[AsyncEvaluationOrder]] is an integer, then if (cyclic->asyncEvaluationOrder().hasOrder()) { #if USE(BUN_JSC_ADDITIONS) - // See note above the recursive call: skip the spec-mandated - // wait to avoid self-deadlock and match old-loader behaviour. - // Only skip when the cycle root entered EvaluatingAsync in a - // *prior* Evaluate() (order < asyncOrderWatermark) — a dep - // that became EvaluatingAsync earlier in *this* DFS is a - // sibling whose post-await bindings are still TDZ (#30259) — - // and its body has already been entered - // (pendingAsyncDependencies == 0). - if (!depWasAlreadyEvaluatingAsync - || cyclic->asyncEvaluationOrder().order() >= asyncOrderWatermark - || cyclic->pendingAsyncDependencies().value_or(1)) { + // Spec says wait on this dep. That's a guaranteed deadlock when + // the dep is the very module whose TLA continuation called the + // dynamic import() that started this Evaluate(): the dep can + // only finish after the import() promise settles, which is + // waiting on us. referrerAsyncOrder is that module's + // asyncEvaluationOrder(), captured at the import() call site + // (-1 when the referrer was not EvaluatingAsync). It is a + // VM-unique identity, so equality is exact — siblings that + // happen to be EvaluatingAsync (#30259, #30634) never match. + if (cyclic->asyncEvaluationOrder().order() != referrerAsyncOrder) { #endif // 12.b.v.1. Set module.[[PendingAsyncDependencies]] to module.[[PendingAsyncDependencies]] + 1. module->setPendingAsyncDependencies(module->pendingAsyncDependencies().value() + 1); diff --git a/Source/JavaScriptCore/runtime/AbstractModuleRecord.h b/Source/JavaScriptCore/runtime/AbstractModuleRecord.h index e803ddc52f081..dcaac0fb312dc 100644 --- a/Source/JavaScriptCore/runtime/AbstractModuleRecord.h +++ b/Source/JavaScriptCore/runtime/AbstractModuleRecord.h @@ -243,7 +243,7 @@ class AbstractModuleRecord : public JSInternalFieldObjectImpl<2> { void evaluateModuleSync(JSGlobalObject*); #if USE(BUN_JSC_ADDITIONS) - unsigned innerModuleEvaluation(JSGlobalObject*, Vector& stack, unsigned index, int64_t asyncOrderWatermark); + unsigned innerModuleEvaluation(JSGlobalObject*, Vector& stack, unsigned index, int64_t referrerAsyncOrder); #else unsigned innerModuleEvaluation(JSGlobalObject*, Vector& stack, unsigned index); #endif @@ -251,7 +251,11 @@ class AbstractModuleRecord : public JSInternalFieldObjectImpl<2> { DECLARE_VISIT_CHILDREN; +#if USE(BUN_JSC_ADDITIONS) + JSPromise* evaluate(JSGlobalObject*, int64_t referrerAsyncOrder = -1); +#else JSPromise* evaluate(JSGlobalObject*); +#endif #if USE(BUN_JSC_ADDITIONS) bool m_isTypeScript = false; diff --git a/Source/JavaScriptCore/runtime/Completion.cpp b/Source/JavaScriptCore/runtime/Completion.cpp index 52489cbe12458..3791b827dc115 100644 --- a/Source/JavaScriptCore/runtime/Completion.cpp +++ b/Source/JavaScriptCore/runtime/Completion.cpp @@ -280,14 +280,14 @@ JSPromise* linkAndEvaluateModule(JSGlobalObject* globalObject, const Identifier& return globalObject->moduleLoader()->linkAndEvaluateModule(globalObject, moduleKey, nullptr, WTF::move(scriptFetcher)); } -JSPromise* importModule(JSGlobalObject* globalObject, const Identifier& moduleName, const Identifier& referrer, RefPtr parameters, RefPtr scriptFetcher, bool deferred) +JSPromise* importModule(JSGlobalObject* globalObject, const Identifier& moduleName, const Identifier& referrer, RefPtr parameters, RefPtr scriptFetcher, bool deferred, int64_t referrerAsyncOrder) { VM& vm = globalObject->vm(); JSLockHolder lock(vm); RELEASE_ASSERT(vm.atomStringTable() == Thread::currentSingleton().atomStringTable()); RELEASE_ASSERT(!vm.isCollectorBusyOnCurrentThread()); - return globalObject->moduleLoader()->requestImportModule(globalObject, moduleName, referrer, WTF::move(parameters), WTF::move(scriptFetcher), deferred); + return globalObject->moduleLoader()->requestImportModule(globalObject, moduleName, referrer, WTF::move(parameters), WTF::move(scriptFetcher), deferred, referrerAsyncOrder); } UncheckedKeyHashMap, String> retrieveImportAttributesFromDynamicImportOptions(JSGlobalObject* globalObject, JSValue options, const Vector>& supportedImportAttributes) diff --git a/Source/JavaScriptCore/runtime/Completion.h b/Source/JavaScriptCore/runtime/Completion.h index 3f6701b707dc2..eaf81155acf89 100644 --- a/Source/JavaScriptCore/runtime/Completion.h +++ b/Source/JavaScriptCore/runtime/Completion.h @@ -78,7 +78,7 @@ JS_EXPORT_PRIVATE JSPromise* loadModule(JSGlobalObject*, SourceCode&&, RefPtr); -JS_EXPORT_PRIVATE JSPromise* importModule(JSGlobalObject*, const Identifier& moduleName, const Identifier& referrer, RefPtr, RefPtr, bool deferred = false); +JS_EXPORT_PRIVATE JSPromise* importModule(JSGlobalObject*, const Identifier& moduleName, const Identifier& referrer, RefPtr, RefPtr, bool deferred = false, int64_t referrerAsyncOrder = -1); JS_EXPORT_PRIVATE UncheckedKeyHashMap, String> retrieveImportAttributesFromDynamicImportOptions(JSGlobalObject*, JSValue, const Vector>& supportedAssertions); JS_EXPORT_PRIVATE std::optional retrieveTypeImportAttribute(JSGlobalObject*, const UncheckedKeyHashMap, String>&); diff --git a/Source/JavaScriptCore/runtime/CyclicModuleRecord.cpp b/Source/JavaScriptCore/runtime/CyclicModuleRecord.cpp index 11aee68f71cc0..a5de03d9ea688 100644 --- a/Source/JavaScriptCore/runtime/CyclicModuleRecord.cpp +++ b/Source/JavaScriptCore/runtime/CyclicModuleRecord.cpp @@ -409,7 +409,11 @@ void CyclicModuleRecord::link(JSGlobalObject* globalObject, RefPtrsetTopLevelCapability(vm, capability); // 8. Let result be Completion(InnerModuleEvaluation(module, stack, 0)). #if USE(BUN_JSC_ADDITIONS) - // Snapshot the async-order counter so the DFS can tell deps that were - // already EvaluatingAsync before this Evaluate() (re-entrant deadlock - // case, see note at 11.c.v) from siblings that transition during it. - module->innerModuleEvaluation(globalObject, stack, 0, vm.moduleAsyncEvaluationCount()); + module->innerModuleEvaluation(globalObject, stack, 0, referrerAsyncOrder); #else module->innerModuleEvaluation(globalObject, stack, 0); #endif diff --git a/Source/JavaScriptCore/runtime/CyclicModuleRecord.h b/Source/JavaScriptCore/runtime/CyclicModuleRecord.h index df49193eba1fc..d8acbba54cf05 100644 --- a/Source/JavaScriptCore/runtime/CyclicModuleRecord.h +++ b/Source/JavaScriptCore/runtime/CyclicModuleRecord.h @@ -57,7 +57,11 @@ class CyclicModuleRecord : public AbstractModuleRecord { void initializeEnvironment(JSGlobalObject*, RefPtr); void link(JSGlobalObject*, RefPtr); +#if USE(BUN_JSC_ADDITIONS) + JSPromise* evaluate(JSGlobalObject*, int64_t referrerAsyncOrder = -1); +#else JSPromise* evaluate(JSGlobalObject*); +#endif void execute(JSGlobalObject*, JSPromise* = nullptr); void executeAsync(JSGlobalObject*); void asyncExecutionFulfilled(JSGlobalObject*); diff --git a/Source/JavaScriptCore/runtime/JSMicrotask.cpp b/Source/JavaScriptCore/runtime/JSMicrotask.cpp index fe55ebd15bc8f..662c50ab7ad16 100644 --- a/Source/JavaScriptCore/runtime/JSMicrotask.cpp +++ b/Source/JavaScriptCore/runtime/JSMicrotask.cpp @@ -1074,7 +1074,11 @@ static void moduleLoadTopSettled(JSGlobalObject* globalObject, VM& vm, ThrowScop if (context->useImportMap()) innerLoadFlags.add(ModuleLoadFlag::UseImportMap); if (context->dynamic()) { +#if USE(BUN_JSC_ADDITIONS) + combinedCell = ModuleLoaderPayload::create(vm, statePromise, context->deferred(), context->referrerAsyncOrder()); +#else combinedCell = ModuleLoaderPayload::create(vm, statePromise, context->deferred()); +#endif loadPromise = globalObject->moduleLoader()->loadModule(globalObject, globalObject, request, combinedCell, scriptFetcher, innerLoadFlags); } else { combinedCell = ModuleGraphLoadingState::create(vm, statePromise, scriptFetcher); @@ -1346,11 +1350,12 @@ static void dynamicImportLoadSettled(JSGlobalObject* globalObject, VM& vm, Throw // Step-4 rejectedClosure or Step-6 linkAndEvaluateClosure // // continueDynamicImport: loadPromise settled - // arguments[0] = capabilityPromise + // arguments[0] = AbstractModuleRecord* // arguments[1] = resolution or error - // arguments[2] = AbstractModuleRecord* - auto* capabilityPromise = uncheckedDowncast(arguments[0]); - auto* module = uncheckedDowncast(arguments[2]); + // arguments[2] = ModuleLoaderPayload* + auto* module = uncheckedDowncast(arguments[0]); + auto* dynamicPayload = uncheckedDowncast(arguments[2]); + auto* capabilityPromise = dynamicPayload->promise(); auto status = static_cast(payload); if (status != JSPromise::Status::Fulfilled) { // Step-4 rejectedClosure @@ -1373,7 +1378,11 @@ static void dynamicImportLoadSettled(JSGlobalObject* globalObject, VM& vm, Throw if (!deferred) { // 6.c. Let evaluatePromise be module.Evaluate(). +#if USE(BUN_JSC_ADDITIONS) + JSPromise* evaluatePromise = module->evaluate(globalObject, dynamicPayload->referrerAsyncOrder()); +#else JSPromise* evaluatePromise = module->evaluate(globalObject); +#endif if (scope.exception()) [[unlikely]] { capabilityPromise->rejectWithCaughtException(vm, scope); return; @@ -1402,7 +1411,11 @@ static void dynamicImportLoadSettled(JSGlobalObject* globalObject, VM& vm, Throw // For each Module Record dep of evaluationList, append dep.Evaluate() to asyncDepsEvaluationPromises. MarkedArgumentBuffer asyncDepsEvaluationPromises; for (AbstractModuleRecord* dep : evaluationList) { +#if USE(BUN_JSC_ADDITIONS) + JSPromise* depPromise = dep->evaluate(globalObject, dynamicPayload->referrerAsyncOrder()); +#else JSPromise* depPromise = dep->evaluate(globalObject); +#endif if (scope.exception()) [[unlikely]] { capabilityPromise->rejectWithCaughtException(vm, scope); return; diff --git a/Source/JavaScriptCore/runtime/JSModuleLoader.cpp b/Source/JavaScriptCore/runtime/JSModuleLoader.cpp index 96144ec748e22..4ebd937f1f9bb 100644 --- a/Source/JavaScriptCore/runtime/JSModuleLoader.cpp +++ b/Source/JavaScriptCore/runtime/JSModuleLoader.cpp @@ -346,7 +346,7 @@ void JSModuleLoader::provideFetch(JSGlobalObject* globalObject, const Identifier entry->provideFetch(globalObject, jsSourceCode); // can throw } -JSPromise* JSModuleLoader::loadModule(JSGlobalObject* globalObject, const Identifier& specifier, RefPtr parameters, RefPtr scriptFetcher, OptionSet flags) +JSPromise* JSModuleLoader::loadModule(JSGlobalObject* globalObject, const Identifier& specifier, RefPtr parameters, RefPtr scriptFetcher, OptionSet flags, int64_t referrerAsyncOrder) { VM& vm = globalObject->vm(); auto scope = DECLARE_THROW_SCOPE(vm); @@ -380,7 +380,7 @@ JSPromise* JSModuleLoader::loadModule(JSGlobalObject* globalObject, const Identi #else AbstractModuleRecord::ModuleRequest request { specifier, ScriptFetchParameters::create(type) }; #endif - auto* context = ModuleLoadingContext::create(vm, request, WTF::move(scriptFetcher), flags); + auto* context = ModuleLoadingContext::create(vm, request, WTF::move(scriptFetcher), flags, referrerAsyncOrder); JSPromise* intermediatePromise = JSPromise::create(vm, globalObject->promiseStructure()); intermediatePromise->markAsHandled(); @@ -437,7 +437,7 @@ JSPromise* JSModuleLoader::linkAndEvaluateModule(JSGlobalObject* globalObject, c return promise; } -JSPromise* JSModuleLoader::requestImportModule(JSGlobalObject* globalObject, const Identifier& moduleName, const Identifier& referrer, RefPtr parameters, RefPtr scriptFetcher, bool deferred) +JSPromise* JSModuleLoader::requestImportModule(JSGlobalObject* globalObject, const Identifier& moduleName, const Identifier& referrer, RefPtr parameters, RefPtr scriptFetcher, bool deferred, int64_t referrerAsyncOrder) { VM& vm = globalObject->vm(); auto scope = DECLARE_THROW_SCOPE(vm); @@ -448,7 +448,7 @@ JSPromise* JSModuleLoader::requestImportModule(JSGlobalObject* globalObject, con OptionSet flags { ModuleLoadFlag::Evaluate, ModuleLoadFlag::Dynamic }; if (deferred) flags.add(ModuleLoadFlag::Deferred); - JSPromise* promise = loadModule(globalObject, resolved, WTF::move(parameters), WTF::move(scriptFetcher), flags); + JSPromise* promise = loadModule(globalObject, resolved, WTF::move(parameters), WTF::move(scriptFetcher), flags, referrerAsyncOrder); RETURN_IF_EXCEPTION(scope, nullptr); JSPromise* resultPromise = JSPromise::create(vm, globalObject->promiseStructure()); @@ -956,7 +956,7 @@ void JSModuleLoader::finishLoadingImportedModule(JSGlobalObject* globalObject, c } else { // 3.a. Perform ContinueDynamicImport(payload, result). auto* dynamicPayload = uncheckedDowncast(payload); - continueDynamicImport(globalObject, dynamicPayload->promise(), result, WTF::move(scriptFetcher), dynamicPayload->deferred()); + continueDynamicImport(globalObject, dynamicPayload, result, WTF::move(scriptFetcher)); RETURN_IF_EXCEPTION(scope, void()); } @@ -1008,7 +1008,7 @@ void JSModuleLoader::continueModuleLoading(JSGlobalObject* globalObject, ModuleG scope.release(); } -void JSModuleLoader::continueDynamicImport(JSGlobalObject* globalObject, JSPromise* promise, ModuleCompletion completion, RefPtr scriptFetcher, bool deferred) +void JSModuleLoader::continueDynamicImport(JSGlobalObject* globalObject, ModuleLoaderPayload* payload, ModuleCompletion completion, RefPtr scriptFetcher) { // ContinueDynamicImport(promiseCapability, moduleCompletion) // https://tc39.es/ecma262/#sec-ContinueDynamicImport @@ -1016,6 +1016,8 @@ void JSModuleLoader::continueDynamicImport(JSGlobalObject* globalObject, JSPromi VM& vm = globalObject->vm(); auto scope = DECLARE_THROW_SCOPE(vm); + JSPromise* promise = payload->promise(); + // 1. If moduleCompletion is an abrupt completion, then if (Exception** exception = std::get_if(&completion)) { // 1.a. Perform ! Call(promiseCapability.[[Reject]], undefined, « moduleCompletion.[[Value]] »). @@ -1030,7 +1032,7 @@ void JSModuleLoader::continueDynamicImport(JSGlobalObject* globalObject, JSPromi JSPromise* loadPromise = loadRequestedModules(globalObject, module, WTF::move(scriptFetcher)); RETURN_IF_EXCEPTION(scope, void()); // 4-8. Link and evaluate using microtask dispatch instead of closures. - loadPromise->performPromiseThenWithInternalMicrotask(vm, deferred ? InternalMicrotask::DynamicImportDeferLoadSettled : InternalMicrotask::DynamicImportLoadSettled, promise, module); + loadPromise->performPromiseThenWithInternalMicrotask(vm, payload->deferred() ? InternalMicrotask::DynamicImportDeferLoadSettled : InternalMicrotask::DynamicImportLoadSettled, module, payload); // 9. Return UNUSED. scope.release(); } @@ -1081,6 +1083,27 @@ ModuleRegistryEntry* JSModuleLoader::getRegisteredMayBeNull(const Identifier& ke return nullptr; } +#if USE(BUN_JSC_ADDITIONS) +int64_t JSModuleLoader::asyncEvaluationOrderForKey(const Identifier& key) +{ + // For the deadlock-avoidance skip at innerModuleEvaluation step 12.b.v. + // The order is assigned at step 12.b before ExecuteAsyncModule (step 12.c) + // runs the body, so it is set whether import() is called before the first + // await (status still Evaluating) or after a resume (status + // EvaluatingAsync); once the module finishes it is cleared to DONE. + if (key.isNull() || key.isEmpty()) + return -1; + auto* entry = getRegisteredMayBeNull(key, ScriptFetchParameters::Type::JavaScript); + if (!entry) + return -1; + auto* cyclic = dynamicDowncast(entry->record()); + if (!cyclic) + return -1; + auto order = cyclic->asyncEvaluationOrder(); + return order.hasOrder() ? order.order() : -1; +} +#endif + void JSModuleLoader::addResolutionFailure(VM& vm, const ResolutionMapKey& key, JSValue error) { Locker locker { cellLock() }; diff --git a/Source/JavaScriptCore/runtime/JSModuleLoader.h b/Source/JavaScriptCore/runtime/JSModuleLoader.h index 3d3222d262fa7..d6addcb90588c 100644 --- a/Source/JavaScriptCore/runtime/JSModuleLoader.h +++ b/Source/JavaScriptCore/runtime/JSModuleLoader.h @@ -92,9 +92,12 @@ class JSModuleLoader final : public JSCell { // APIs to control the module loader. void provideFetch(JSGlobalObject*, const Identifier& key, ScriptFetchParameters::Type, SourceCode&&); void provideFetch(JSGlobalObject*, const Identifier& key, ScriptFetchParameters::Type, JSSourceCode*); - JSPromise* loadModule(JSGlobalObject*, const Identifier& moduleName, RefPtr, RefPtr, OptionSet); + JSPromise* loadModule(JSGlobalObject*, const Identifier& moduleName, RefPtr, RefPtr, OptionSet, int64_t referrerAsyncOrder = -1); JSPromise* linkAndEvaluateModule(JSGlobalObject*, const Identifier& moduleKey, RefPtr, RefPtr); - JSPromise* requestImportModule(JSGlobalObject*, const Identifier& moduleName, const Identifier& referrer, RefPtr, RefPtr, bool deferred = false); + JSPromise* requestImportModule(JSGlobalObject*, const Identifier& moduleName, const Identifier& referrer, RefPtr, RefPtr, bool deferred = false, int64_t referrerAsyncOrder = -1); +#if USE(BUN_JSC_ADDITIONS) + JS_EXPORT_PRIVATE int64_t asyncEvaluationOrderForKey(const Identifier& key); +#endif // Platform dependent hooked APIs. JSPromise* importModule(JSGlobalObject*, JSString* moduleName, JSValue parameters, const SourceOrigin& referrer, bool deferred = false); @@ -159,7 +162,7 @@ class JSModuleLoader final : public JSCell { JSPromise* hostLoadImportedModule(JSGlobalObject*, const ModuleReferrer&, const ModuleRequest&, JSCell* payload, RefPtr, bool useImportMap); JSPromise* loadModule(JSGlobalObject*, const ModuleReferrer&, const ModuleRequest&, JSCell* payload, RefPtr, OptionSet); void continueModuleLoading(JSGlobalObject*, ModuleGraphLoadingState*, ModuleCompletion result); - void continueDynamicImport(JSGlobalObject*, JSPromise*, ModuleCompletion, RefPtr, bool deferred); + void continueDynamicImport(JSGlobalObject*, ModuleLoaderPayload*, ModuleCompletion, RefPtr); JSPromise* loadRequestedModules(JSGlobalObject*, AbstractModuleRecord*, RefPtr); static JSPromise* makeModule(JSGlobalObject*, const Identifier& moduleKey, JSSourceCode*); diff --git a/Source/JavaScriptCore/runtime/ModuleLoaderPayload.cpp b/Source/JavaScriptCore/runtime/ModuleLoaderPayload.cpp index 565b499e0df52..f171c676eafa2 100644 --- a/Source/JavaScriptCore/runtime/ModuleLoaderPayload.cpp +++ b/Source/JavaScriptCore/runtime/ModuleLoaderPayload.cpp @@ -33,11 +33,17 @@ namespace JSC { const ClassInfo ModuleLoaderPayload::s_info = { "ModuleLoaderPayload"_s, nullptr, nullptr, nullptr, CREATE_METHOD_TABLE(ModuleLoaderPayload) }; -ModuleLoaderPayload::ModuleLoaderPayload(VM& vm, Structure* structure, JSPromise* promise, bool deferred) +ModuleLoaderPayload::ModuleLoaderPayload(VM& vm, Structure* structure, JSPromise* promise, bool deferred, int64_t referrerAsyncOrder) : Base(vm, structure) , m_promise(promise, WriteBarrierEarlyInit) +#if USE(BUN_JSC_ADDITIONS) + , m_referrerAsyncOrder(referrerAsyncOrder) +#endif , m_deferred(deferred) { +#if !USE(BUN_JSC_ADDITIONS) + UNUSED_PARAM(referrerAsyncOrder); +#endif } void ModuleLoaderPayload::finishCreation(VM& vm) @@ -58,9 +64,9 @@ void ModuleLoaderPayload::visitChildrenImpl(JSCell* cell, Visitor& visitor) DEFINE_VISIT_CHILDREN(ModuleLoaderPayload); -ModuleLoaderPayload* ModuleLoaderPayload::create(VM& vm, JSPromise* promise, bool deferred) +ModuleLoaderPayload* ModuleLoaderPayload::create(VM& vm, JSPromise* promise, bool deferred, int64_t referrerAsyncOrder) { - ModuleLoaderPayload* instance = new (NotNull, allocateCell(vm)) ModuleLoaderPayload(vm, vm.moduleLoaderPayloadStructure.get(), promise, deferred); + ModuleLoaderPayload* instance = new (NotNull, allocateCell(vm)) ModuleLoaderPayload(vm, vm.moduleLoaderPayloadStructure.get(), promise, deferred, referrerAsyncOrder); instance->finishCreation(vm); return instance; } diff --git a/Source/JavaScriptCore/runtime/ModuleLoaderPayload.h b/Source/JavaScriptCore/runtime/ModuleLoaderPayload.h index e98d1c241ff49..5e91d69c2440d 100644 --- a/Source/JavaScriptCore/runtime/ModuleLoaderPayload.h +++ b/Source/JavaScriptCore/runtime/ModuleLoaderPayload.h @@ -49,7 +49,7 @@ class ModuleLoaderPayload final : public JSCell { } inline static Structure* createStructure(VM&, JSGlobalObject*, JSValue); - static ModuleLoaderPayload* create(VM&, JSPromise*, bool deferred = false); + static ModuleLoaderPayload* create(VM&, JSPromise*, bool deferred = false, int64_t referrerAsyncOrder = -1); JSPromise* promise() const { return m_promise.get(); } @@ -57,6 +57,9 @@ class ModuleLoaderPayload final : public JSCell { void setFulfillment(VM& vm, JSValue value) { m_fulfillment.set(vm, this, value); } bool deferred() const { return m_deferred; } +#if USE(BUN_JSC_ADDITIONS) + int64_t referrerAsyncOrder() const { return m_referrerAsyncOrder; } +#endif bool decrementRemaining() { @@ -65,12 +68,15 @@ class ModuleLoaderPayload final : public JSCell { } private: - ModuleLoaderPayload(VM&, Structure*, JSPromise*, bool deferred); + ModuleLoaderPayload(VM&, Structure*, JSPromise*, bool deferred, int64_t referrerAsyncOrder); void finishCreation(VM&); WriteBarrier m_promise; WriteBarrier m_fulfillment; +#if USE(BUN_JSC_ADDITIONS) + int64_t m_referrerAsyncOrder { -1 }; +#endif uint8_t m_remainingFulfillments { 2 }; bool m_deferred { false }; }; diff --git a/Source/JavaScriptCore/runtime/ModuleLoadingContext.cpp b/Source/JavaScriptCore/runtime/ModuleLoadingContext.cpp index babfdf32caaa9..e619c0f64fd55 100644 --- a/Source/JavaScriptCore/runtime/ModuleLoadingContext.cpp +++ b/Source/JavaScriptCore/runtime/ModuleLoadingContext.cpp @@ -62,18 +62,24 @@ ModuleLoadingContext* ModuleLoadingContext::create(VM& vm, Step step, const JSMo return context; } -ModuleLoadingContext::ModuleLoadingContext(VM& vm, Structure* structure, AbstractModuleRecord::ModuleRequest&& moduleRequest, RefPtr scriptFetcher, OptionSet flags) +ModuleLoadingContext::ModuleLoadingContext(VM& vm, Structure* structure, AbstractModuleRecord::ModuleRequest&& moduleRequest, RefPtr scriptFetcher, OptionSet flags, int64_t referrerAsyncOrder) : Base(vm, structure) , m_moduleRequest(WTF::move(moduleRequest)) , m_scriptFetcher(WTF::move(scriptFetcher)) +#if USE(BUN_JSC_ADDITIONS) + , m_referrerAsyncOrder(referrerAsyncOrder) +#endif , m_flags(flags) { +#if !USE(BUN_JSC_ADDITIONS) + UNUSED_PARAM(referrerAsyncOrder); +#endif } -ModuleLoadingContext* ModuleLoadingContext::create(VM& vm, const AbstractModuleRecord::ModuleRequest& moduleRequest, RefPtr scriptFetcher, OptionSet flags) +ModuleLoadingContext* ModuleLoadingContext::create(VM& vm, const AbstractModuleRecord::ModuleRequest& moduleRequest, RefPtr scriptFetcher, OptionSet flags, int64_t referrerAsyncOrder) { AbstractModuleRecord::ModuleRequest requestCopy { moduleRequest }; - auto* context = new (NotNull, allocateCell(vm)) ModuleLoadingContext(vm, vm.moduleLoadingContextStructure.get(), WTF::move(requestCopy), WTF::move(scriptFetcher), flags); + auto* context = new (NotNull, allocateCell(vm)) ModuleLoadingContext(vm, vm.moduleLoadingContextStructure.get(), WTF::move(requestCopy), WTF::move(scriptFetcher), flags, referrerAsyncOrder); context->finishCreation(vm); return context; } diff --git a/Source/JavaScriptCore/runtime/ModuleLoadingContext.h b/Source/JavaScriptCore/runtime/ModuleLoadingContext.h index cfdf6a2c9a4cb..5de814a243a11 100644 --- a/Source/JavaScriptCore/runtime/ModuleLoadingContext.h +++ b/Source/JavaScriptCore/runtime/ModuleLoadingContext.h @@ -61,7 +61,7 @@ class ModuleLoadingContext final : public JSCell { }; static ModuleLoadingContext* create(VM&, Step, const JSModuleLoader::ModuleReferrer&, const AbstractModuleRecord::ModuleRequest&, JSCell* payload, ModuleRegistryEntry*, RefPtr); - static ModuleLoadingContext* create(VM&, const AbstractModuleRecord::ModuleRequest&, RefPtr, OptionSet); + static ModuleLoadingContext* create(VM&, const AbstractModuleRecord::ModuleRequest&, RefPtr, OptionSet, int64_t referrerAsyncOrder = -1); Step step() const { return m_step; } void setStep(Step s) { m_step = s; } @@ -78,10 +78,13 @@ class ModuleLoadingContext final : public JSCell { bool dynamic() const { return m_flags.contains(ModuleLoadFlag::Dynamic); } bool useImportMap() const { return m_flags.contains(ModuleLoadFlag::UseImportMap); } bool deferred() const { return m_flags.contains(ModuleLoadFlag::Deferred); } +#if USE(BUN_JSC_ADDITIONS) + int64_t referrerAsyncOrder() const { return m_referrerAsyncOrder; } +#endif private: ModuleLoadingContext(VM&, Structure*, Step, const JSModuleLoader::ModuleReferrer&, AbstractModuleRecord::ModuleRequest&&, JSCell* payload, ModuleRegistryEntry*, RefPtr); - ModuleLoadingContext(VM&, Structure*, AbstractModuleRecord::ModuleRequest&&, RefPtr, OptionSet); + ModuleLoadingContext(VM&, Structure*, AbstractModuleRecord::ModuleRequest&&, RefPtr, OptionSet, int64_t referrerAsyncOrder); Step m_step { Step::Main }; AbstractModuleRecord::ModuleRequest m_moduleRequest; @@ -90,6 +93,9 @@ class ModuleLoadingContext final : public JSCell { WriteBarrier m_entry; WriteBarrier m_referrer; WriteBarrier m_module; +#if USE(BUN_JSC_ADDITIONS) + int64_t m_referrerAsyncOrder { -1 }; +#endif OptionSet m_flags; }; diff --git a/Source/JavaScriptCore/runtime/VM.h b/Source/JavaScriptCore/runtime/VM.h index 13f77f2430ac4..6df90ecf4b5b8 100644 --- a/Source/JavaScriptCore/runtime/VM.h +++ b/Source/JavaScriptCore/runtime/VM.h @@ -1156,9 +1156,6 @@ class VM : public ThreadSafeRefCountedWithSuppressingSaferCPPChecking { void notifyDebuggerHookInjected() { m_isDebuggerHookInjected = true; } bool isDebuggerHookInjected() const { return m_isDebuggerHookInjected; } int64_t incrementModuleAsyncEvaluationCount() { return m_moduleAsyncEvaluationCount++; } -#if USE(BUN_JSC_ADDITIONS) - int64_t moduleAsyncEvaluationCount() const { return m_moduleAsyncEvaluationCount; } -#endif #if ENABLE(WEBASSEMBLY_DEBUGGER) JS_EXPORT_PRIVATE Wasm::DebugState* NODELETE debugState();