From 34c7c0104bb0033f3267cf0a4aa7c502305c8b3a Mon Sep 17 00:00:00 2001 From: Jarred Sumner Date: Mon, 16 Nov 2026 14:32:46 -0800 Subject: [PATCH 01/19] AOT test runs: code from source asks for a preload's mock whose entry a reset has removed It loaded or called what the reset had set aside. --- .../aot/runtime/AOTTestRunFactories.cpp | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/Source/JavaScriptCore/aot/runtime/AOTTestRunFactories.cpp b/Source/JavaScriptCore/aot/runtime/AOTTestRunFactories.cpp index d083a7f9d3b84..0046fa8395175 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTTestRunFactories.cpp +++ b/Source/JavaScriptCore/aot/runtime/AOTTestRunFactories.cpp @@ -1347,9 +1347,14 @@ bool Modules::runMocksInFetchedGraphSlow(ModuleID module) return false; evaluateModulesOwedBelow(module); RETURN_IF_EXCEPTION(scope, false); - scope.release(); - if (m_modulesWithPendingMock.isEmpty()) [[likely]] + auto noteRequest = [&] { + if (data(module).isESModuleOfProgram() && wasActiveMockEntryRemoved(module)) + noteImportUnderMockInPlace(module); + }; + if (m_modulesWithPendingMock.isEmpty()) [[likely]] { + noteRequest(); return false; + } bool isAskedForByImportCall = m_instance.vm->aotState().importFrameInLoader; if (isAskedForByImportCall) clearCachedMockError(module); @@ -1357,7 +1362,11 @@ bool Modules::runMocksInFetchedGraphSlow(ModuleID module) SetForScope moduleBeingFetched(m_moduleBeingFetched, loadOfFetch(module)); bool wasFetchedForStatement = m_statementFetchesDelayedByTick.get(module.index()); m_statementFetchesDelayedByTick.clear(module.index()); - return runMocksInGraph(module, wasFetchedForStatement || (!isAskedForByImportCall && isFetchedForImportStatement(module)) ? LoadRootKind::ImportStatement : LoadRootKind::StartsLoad); + bool hasCalledWaitingFactory = runMocksInGraph(module, wasFetchedForStatement || (!isAskedForByImportCall && isFetchedForImportStatement(module)) ? LoadRootKind::ImportStatement : LoadRootKind::StartsLoad); + RETURN_IF_EXCEPTION(scope, false); + if (!hasCalledWaitingFactory) + noteRequest(); + return hasCalledWaitingFactory; } void Modules::willFetchAfterTick(ModuleID module) From eff6a66cb6b9f19996488be49c3ad74e0f3a3381 Mon Sep 17 00:00:00 2001 From: Jarred Sumner Date: Mon, 16 Nov 2026 14:32:52 -0800 Subject: [PATCH 02/19] AOT: a check of proofs follows a value through the head of a loop and through a join A build could stop under `--aot-harden=proof-checks` where the name that a check asks about is handed on at a head of a loop, at a join, or at a call that was copied. --- .../aot/walk/AOTCodeVerifier.cpp | 79 +++++++++++++++---- 1 file changed, 62 insertions(+), 17 deletions(-) diff --git a/Source/JavaScriptCore/aot/walk/AOTCodeVerifier.cpp b/Source/JavaScriptCore/aot/walk/AOTCodeVerifier.cpp index 446b4b631ff62..913470fa625d1 100644 --- a/Source/JavaScriptCore/aot/walk/AOTCodeVerifier.cpp +++ b/Source/JavaScriptCore/aot/walk/AOTCodeVerifier.cpp @@ -154,6 +154,7 @@ class CodeVerifier { void verifyUsersOfReadNumbers(); bool treatsUndefinedAsNaN(ValueID, const Operation& user, uint32_t operandIndex) const; bool isOperatorSpecializationCheck(ValueID test) const; + bool failingEdgeLeavesScope(ValueID test) const; void verifyTestsPassed(); void verifyLengthsHeldAgainst(); void verifyDataViewAccesses(); @@ -1487,6 +1488,10 @@ bool CodeVerifier::isOperatorSpecializationCheck(ValueID test) const BitVector names(m_code.numberOfValues()); bool isUsedOnPass = false; bool isUsedOnFailure = false; + bool isUsedByOtherOperator = false; + const bool isAtInlinedCall = std::ranges::any_of(m_code.inlineFrames().subspan(1), [&](const InlineFrame& copied) { + return copied.parent == asked.inlineFrame && copied.callPosition == asked.position; + }); for (bool someNameIsNew = true; std::exchange(someNameIsNew, false);) { for (BlockID block : m_reachedBlocks) { for (ValueID id : operationsOf(block)) { @@ -1502,32 +1507,52 @@ bool CodeVerifier::isOperatorSpecializationCheck(ValueID test) const name = m_code.at(name).operand(0); return m_code.at(name).isOnTakenEdge(); }; - BitVector isBehindFailingEdge(m_code.numberOfBlocks()); - const BlockID blockOfTest = m_code.blockOf(test); - if (EdgeID fails = findAnswerEdge(test, false, blockOfTest)) { - Vector waiting { m_code.at(fails).to }; - while (!waiting.isEmpty()) { - BlockID block = waiting.takeLast(); - if (!isReached(block) || dominates(headOf(block), headOf(blockOfTest)) || isBehindFailingEdge.set(block.index())) - continue; - m_code.forEachEdgeOf(block, [&](EdgeID, const Edge& edge) { - waiting.append(edge.to); - }); + auto arrivesIn = [](const BitVector& found, ValueID value) { return value && found.get(value.index()); }; + auto followThroughParameters = [&](BitVector& found, const auto& isFirst) { + for (bool someArrivesFurther = true; std::exchange(someArrivesFurther, false);) { + for (BlockID block : m_reachedBlocks) { + for (ValueID id : operationsOf(block)) { + const Operation& record = m_code.at(id); + if (valuePreservingOpcodes.contains(record.opcode) && !names.get(id.index()) && arrivesIn(found, record.operand(0)) && !found.set(id.index())) + someArrivesFurther = true; + } + m_code.forEachEdgeOf(block, [&](EdgeID, const Edge& edge) { + std::span parameters = m_code.at(edge.to).parameters(); + std::span arguments = edge.arguments(); + for (size_t place = 0; place < std::min(arguments.size(), parameters.size()); ++place) { + if (arguments[place] && (arrivesIn(found, arguments[place]) || isFirst(arguments[place])) && !found.set(parameters[place].index())) + someArrivesFurther = true; + } + }); + } } - } + }; + BitVector arrivals(m_code.numberOfValues()); + followThroughParameters(arrivals, [&](ValueID argument) { return names.get(argument.index()) && isOnPassingEdge(argument); }); + BitVector arrivalsOfValue(m_code.numberOfValues()); + arrivalsOfValue.set(asked.valueOperand().index()); + followThroughParameters(arrivalsOfValue, [&](ValueID argument) { return names.get(argument.index()) && !isOnPassingEdge(argument); }); for (BlockID block : m_reachedBlocks) { for (ValueID id : operationsOf(block)) { const Operation& user = m_code.at(id); for (uint32_t operandIndex = 0; operandIndex < user.numberOfOperands(); ++operandIndex) { + const bool isOperator = (allRelations | arithmeticOnTwoNumbersInCodeVerifier).contains(user.opcode) && user.position == asked.position && user.inlineFrame == asked.inlineFrame; + isUsedOnPass |= isOperator && arrivesIn(arrivals, user.operand(operandIndex)); + isUsedOnFailure |= isOperator && arrivesIn(arrivalsOfValue, user.operand(operandIndex)); if (user.operand(operandIndex) == test && (user.opcode != Opcode::Narrowed || user.valueOperand() == test)) return false; - if (user.operand(operandIndex) == asked.valueOperand() && (allRelations | arithmeticOnTwoNumbersInCodeVerifier).contains(user.opcode) && user.position == asked.position && user.inlineFrame == asked.inlineFrame && isBehindFailingEdge.get(block.index())) + if (user.operand(operandIndex) == asked.valueOperand() && (allRelations | arithmeticOnTwoNumbersInCodeVerifier).contains(user.opcode) && user.position == asked.position && user.inlineFrame == asked.inlineFrame) isUsedOnFailure = true; if (!user.operand(operandIndex) || !names.get(user.operand(operandIndex).index()) || names.get(id.index())) continue; - if (user.position != asked.position || user.inlineFrame != asked.inlineFrame) - return false; - (isOnPassingEdge(user.operand(operandIndex)) ? isUsedOnPass : isUsedOnFailure) = true; + bool isOnPass = isOnPassingEdge(user.operand(operandIndex)); + if (user.position != asked.position || user.inlineFrame != asked.inlineFrame) { + bool isArithmetic = user.opcode != Opcode::TypeTest && treatsUndefinedAsNaN(id, user, operandIndex); + if (!isArithmetic || !isOnPass || !isAtInlinedCall) + return false; + isUsedByOtherOperator = true; + } + (isOnPass ? isUsedOnPass : isUsedOnFailure) = true; } } const Terminator& end = m_code.at(block).terminator; @@ -1542,7 +1567,27 @@ bool CodeVerifier::isOperatorSpecializationCheck(ValueID test) const if (isEdgeArgument) return false; } - return isUsedOnPass && isUsedOnFailure; + return isUsedOnPass && ((isUsedOnFailure && !isUsedByOtherOperator) || failingEdgeLeavesScope(test)); +} + +bool CodeVerifier::failingEdgeLeavesScope(ValueID test) const +{ + ValueID value = m_code.at(test).valueOperand(); + bool leavesScope = false; + for (BlockID block : m_reachedBlocks) { + EdgeID edge = findAnswerEdge(test, false, block); + if (!edge) + continue; + BlockID to = m_code.at(edge).to; + for (uint32_t step = 0; isDefinedWhereBlockMayThrow(value, to); ++step) { + const Terminator& end = m_code.at(to).terminator; + if (step == m_code.numberOfBlocks() || end.kind != TerminatorKind::Jump || !std::ranges::all_of(operationsOf(to), [&](ValueID id) { return m_code.at(id).traits().isPure(); })) + return false; + to = m_code.at(end.next()).to; + } + leavesScope = true; + } + return leavesScope; } bool CodeVerifier::treatsUndefinedAsNaN(ValueID id, const Operation& user, uint32_t operandIndex) const From 742a03acfad7a6e67f21df8fe2e2ac289f31c67b Mon Sep 17 00:00:00 2001 From: Jarred Sumner Date: Mon, 16 Nov 2026 14:32:56 -0800 Subject: [PATCH 03/19] AOT test runs: whether what a file imports threw in an earlier test file For the mock of a later file that takes the place of it. --- Source/JavaScriptCore/aot/runtime/AOTModuleHost.h | 1 + Source/JavaScriptCore/aot/runtime/AOTModules.cpp | 6 ++++++ Source/JavaScriptCore/aot/runtime/AOTModules.h | 1 + .../aot/runtime/AOTTestRunFactories.cpp | 11 +++++++++++ 4 files changed, 19 insertions(+) diff --git a/Source/JavaScriptCore/aot/runtime/AOTModuleHost.h b/Source/JavaScriptCore/aot/runtime/AOTModuleHost.h index 25e2e27efba9e..a938b5efa2042 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTModuleHost.h +++ b/Source/JavaScriptCore/aot/runtime/AOTModuleHost.h @@ -329,6 +329,7 @@ JS_EXPORT_PRIVATE bool wasDisplacedDuringEvaluation(JSGlobalObject*, ModuleID); JS_EXPORT_PRIVATE bool wasRegisteredByFailedLoad(JSGlobalObject*, ModuleID); JS_EXPORT_PRIVATE bool wasLinkedBeforeTestFile(JSGlobalObject*, ModuleID); JS_EXPORT_PRIVATE bool wasLinkedByFailedGraph(JSGlobalObject*, ModuleID, bool byEarlierTestFile = false); +JS_EXPORT_PRIVATE bool failedWithImportInEarlierTestFile(JSGlobalObject*, ModuleID); JS_EXPORT_PRIVATE bool wasLinkedBeforeLinkFailure(JSGlobalObject*, ModuleID); JS_EXPORT_PRIVATE bool hasImporterLinkedBeforeFailure(JSGlobalObject*, ModuleID); JS_EXPORT_PRIVATE bool isLinkedForPendingImporter(JSGlobalObject*, ModuleID, std::optional asking); diff --git a/Source/JavaScriptCore/aot/runtime/AOTModules.cpp b/Source/JavaScriptCore/aot/runtime/AOTModules.cpp index d10706c2dbe17..f35e178d45f17 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTModules.cpp +++ b/Source/JavaScriptCore/aot/runtime/AOTModules.cpp @@ -9340,6 +9340,12 @@ bool wasLinkedByFailedGraph(JSGlobalObject* realm, ModuleID module, bool byEarli return modules && modules->wasLinkedByFailedGraph(module, byEarlierTestFile); } +bool failedWithImportInEarlierTestFile(JSGlobalObject* realm, ModuleID module) +{ + Modules* modules = modulesOf(realm); + return modules && modules->failedWithImportInEarlierTestFile(module); +} + bool hasImporterLinkedBeforeFailure(JSGlobalObject* realm, ModuleID module) { Modules* modules = modulesOf(realm); diff --git a/Source/JavaScriptCore/aot/runtime/AOTModules.h b/Source/JavaScriptCore/aot/runtime/AOTModules.h index 57046b176a8e4..47124dc93578b 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTModules.h +++ b/Source/JavaScriptCore/aot/runtime/AOTModules.h @@ -919,6 +919,7 @@ class Modules { void forgetLoadsRefusedByCheckOfNames(ModuleID mocked); bool wasRegisteredByFailedLoad(ModuleID) const; bool wasLinkedByFailedGraph(ModuleID, bool byEarlierTestFile); + bool failedWithImportInEarlierTestFile(ModuleID); bool isImportedByFailedRoot(ModuleID, bool ofEarlierTestFile = false) const; bool wasReachedByFailedGraph(ModuleID) const; bool isFailedLoadRoot(ModuleID module) const { return m_loadRoots.get(module.index()) && status(module) == ModuleStatus::Failed; } diff --git a/Source/JavaScriptCore/aot/runtime/AOTTestRunFactories.cpp b/Source/JavaScriptCore/aot/runtime/AOTTestRunFactories.cpp index 0046fa8395175..7f5d4d4f6b713 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTTestRunFactories.cpp +++ b/Source/JavaScriptCore/aot/runtime/AOTTestRunFactories.cpp @@ -326,6 +326,17 @@ bool Modules::wasLinkedByFailedGraph(ModuleID module, bool byEarlierTestFile) return data(module).isESModuleOfProgram() && !data(module).isFacade() && status(module) <= ModuleStatus::Linked && !hasRun(module) && !didCaptureExports(module) && (!byEarlierTestFile || !wasLoadedByTestFile(module)) && isImportedByFailedRoot(module, byEarlierTestFile); } +bool Modules::failedWithImportInEarlierTestFile(ModuleID module) +{ + if (!isFailedESModule(module) || isMocked(module) || activeMock(module) || m_loadedInPreload.get(module.index()) || wasLoadedByTestFile(module)) + return false; + for (size_t index : staticImportClosure(module, MockTraversal::Continue)) { + if (ModuleID imported(index); imported != module && isFailedESModule(imported) && !isMocked(imported)) + return true; + } + return false; +} + bool Modules::wasReachedByFailedGraph(ModuleID module) const { for (uint32_t index = 0; index < m_table.size(); ++index) { From 1989ffc3b31df19e30e73c44c0daaa12b83afd05 Mon Sep 17 00:00:00 2001 From: Jarred Sumner Date: Mon, 16 Nov 2026 14:33:02 -0800 Subject: [PATCH 04/19] A store of code made at run time to a constant of a script throws Such a script's constant is not cached for code made at run time, and only where the process has compiled code: in plain Bun the place asks one byte. Instructions of a store into a global that a text made at run time makes, in plain Bun: 66 on x64, as before, and 63.5 on arm64 (61.5 before). A read takes 39 and 36, as before. --- Source/JavaScriptCore/runtime/CommonSlowPathsInlines.h | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/Source/JavaScriptCore/runtime/CommonSlowPathsInlines.h b/Source/JavaScriptCore/runtime/CommonSlowPathsInlines.h index b72774bcc2afa..6477bc3bf69e6 100644 --- a/Source/JavaScriptCore/runtime/CommonSlowPathsInlines.h +++ b/Source/JavaScriptCore/runtime/CommonSlowPathsInlines.h @@ -84,7 +84,10 @@ inline void tryCachePutToScopeGlobal( case GlobalPropertyWithVarInjectionChecks: { // Global Lexical Binding Epoch is changed. Update op_get_from_scope from GlobalProperty to GlobalLexicalVar. if (scope->isGlobalLexicalEnvironment()) { - cacheGlobalLexicalVar(codeBlock, metadata, uncheckedDowncast(scope), ident); + auto* globalLexicalEnvironment = uncheckedDowncast(scope); + if (getVM(globalObject).hasCompiledCode() && globalLexicalEnvironment->symbolTable()->get(ident.impl()).isReadOnly()) + return; + cacheGlobalLexicalVar(codeBlock, metadata, globalLexicalEnvironment, ident); return; } break; From 76d6a7c09f80724a1799ebfe8c76b39d0e39a68e Mon Sep 17 00:00:00 2001 From: Jarred Sumner Date: Mon, 16 Nov 2026 14:33:09 -0800 Subject: [PATCH 05/19] AOT: under proof checks a front asks again where what is narrowed holds more A build stopped where something else stood between a branch and what it narrowed. --- Source/JavaScriptCore/aot/walk/AOTWalkLoopsBuiltTwice.cpp | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/Source/JavaScriptCore/aot/walk/AOTWalkLoopsBuiltTwice.cpp b/Source/JavaScriptCore/aot/walk/AOTWalkLoopsBuiltTwice.cpp index 4ebbf706be716..4e7306540b127 100644 --- a/Source/JavaScriptCore/aot/walk/AOTWalkLoopsBuiltTwice.cpp +++ b/Source/JavaScriptCore/aot/walk/AOTWalkLoopsBuiltTwice.cpp @@ -2611,6 +2611,13 @@ bool Walker::tryBranchInPreheader(Reference test, bool passesWithYes, IterationP BlockID behind = earlier + 1 < loop.earlierPreheaderBlocks.size() ? loop.earlierPreheaderBlocks[earlier + 1] : front; if (behind != front && !testsWithoutNarrowedValue.contains(m_code.at(test.id()).opcode)) continue; + if (behind == front && checksProofs() && !testsWithoutNarrowedValue.contains(m_code.at(test.id()).opcode)) { + bool holdsMore = false; + for (ValueID id = m_code.lastOperationOf(front); id && !holdsMore; id = m_code.at(id).previous) + holdsMore = m_code.at(id).opcode != Opcode::Narrowed && !operationsThatStandAmongNarrowedValues.contains(m_code.at(id).opcode); + if (holdsMore) + continue; + } if (m_code.at(passesWithYes ? end.taken() : end.notTaken()).to == behind) { count(StatisticID::PreheaderChecksEliminated); return true; From ad04c53db6a7270b1118b422d5e1b52297d9f307 Mon Sep 17 00:00:00 2001 From: Jarred Sumner Date: Mon, 16 Nov 2026 14:33:13 -0800 Subject: [PATCH 06/19] AOT test runs: an import whose load has passed a factory waits for its patch The text that a call has waited for is asked again for the factories it reaches, and a file that the load imports is known. --- .../aot/runtime/AOTModuleHost.h | 1 + .../JavaScriptCore/aot/runtime/AOTModules.cpp | 4 ++++ .../JavaScriptCore/aot/runtime/AOTModules.h | 1 + .../aot/runtime/AOTTestRunImportTurns.cpp | 20 +++++++++++++++++++ 4 files changed, 26 insertions(+) diff --git a/Source/JavaScriptCore/aot/runtime/AOTModuleHost.h b/Source/JavaScriptCore/aot/runtime/AOTModuleHost.h index a938b5efa2042..8331c653ae3d0 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTModuleHost.h +++ b/Source/JavaScriptCore/aot/runtime/AOTModuleHost.h @@ -442,6 +442,7 @@ JS_EXPORT_PRIVATE bool fulfillDeferredFetches(VM&, uint64_t completedDiskReads = JS_EXPORT_PRIVATE void didDrainDeferredFetchJobs(VM&); JS_EXPORT_PRIVATE std::optional firstDeferredBatchNumber(VM&); JS_EXPORT_PRIVATE bool shouldDeferFetchFulfillment(JSGlobalObject*, ModuleID); +JS_EXPORT_PRIVATE bool isImportedByLoad(JSGlobalObject*, ModuleID root, ModuleID file); JS_EXPORT_PRIVATE void deferFetchFulfillment(JSGlobalObject*, ModuleID, JSPromise* fetched, AbstractModuleRecord*); JS_EXPORT_PRIVATE void didFetch(JSGlobalObject*, AbstractModuleRecord*); JS_EXPORT_PRIVATE void noteHostImportInFlight(JSGlobalObject*, ModuleID, JSPromise*, bool isFromOwnFactory); diff --git a/Source/JavaScriptCore/aot/runtime/AOTModules.cpp b/Source/JavaScriptCore/aot/runtime/AOTModules.cpp index f35e178d45f17..cbe9b16ac9764 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTModules.cpp +++ b/Source/JavaScriptCore/aot/runtime/AOTModules.cpp @@ -5602,6 +5602,10 @@ JSPromise* Modules::startImport(ModuleID module, std::optional referrer factories = pendingFactoryInGraph(module, askedBy, importWaitState); RETURN_IF_EXCEPTION(scope, rejectedPromiseWithPendingException(realm, scope)); } + if (!factories && text != ImportSourceState::MayArriveLater && askedBy == PendingFactoryRequester::ImportCall) [[unlikely]] { + factories = pendingFactoryInGraph(module, PendingFactoryRequester::ImportCallAfterSource, importWaitState); + RETURN_IF_EXCEPTION(scope, rejectedPromiseWithPendingException(realm, scope)); + } if (!factories && needsOriginal) [[unlikely]] { factories = ensureActualKeyLoad(fileOf(module)); RETURN_IF_EXCEPTION(scope, rejectedPromiseWithPendingException(realm, scope)); diff --git a/Source/JavaScriptCore/aot/runtime/AOTModules.h b/Source/JavaScriptCore/aot/runtime/AOTModules.h index 47124dc93578b..212eff4448227 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTModules.h +++ b/Source/JavaScriptCore/aot/runtime/AOTModules.h @@ -1929,6 +1929,7 @@ class Modules { void fulfillQueuedFetch(JSPromise*); void fulfillQueuedFetchAfterJobs(JSPromise*); bool isOriginalLoaded(ModuleID); + bool isImportedByLoad(ModuleID root, ModuleID file) const; enum class AskedBy : bool { Loader, Import }; bool textOfImportComesInLaterTurn(ModuleID, AskedBy); bool hasTextAtHand() const; diff --git a/Source/JavaScriptCore/aot/runtime/AOTTestRunImportTurns.cpp b/Source/JavaScriptCore/aot/runtime/AOTTestRunImportTurns.cpp index 0dcbb16815d56..549e7e6a6c5f5 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTTestRunImportTurns.cpp +++ b/Source/JavaScriptCore/aot/runtime/AOTTestRunImportTurns.cpp @@ -82,6 +82,20 @@ bool Modules::isFetchedBesideFactory(ModuleID module) return false; } +bool Modules::isImportedByLoad(ModuleID root, ModuleID file) const +{ + for (size_t index : modulesInLoadGraph(root)) { + ModuleID importer(index); + if (isCommonJSModuleOrFacade(importer) || status(importer) >= ModuleStatus::Evaluating) + continue; + for (const ModuleRequestData& request : m_table.imports(importer)) { + if (fileOf(moduleLoadedBy(request)) == file) + return true; + } + } + return false; +} + bool Modules::textOfImportComesInLaterTurn(ModuleID module, AskedBy askedBy) { ModuleID file = fileOf(module); @@ -923,6 +937,12 @@ bool wasOriginalRequiredFirst(JSGlobalObject* realm, ModuleID file) return modules && modules->wasOriginalRequiredFirst(file); } +bool isImportedByLoad(JSGlobalObject* realm, ModuleID root, ModuleID file) +{ + Modules* modules = modulesOf(realm); + return modules && modules->isImportedByLoad(root, file); +} + bool isMockUnseen(JSGlobalObject* realm, ModuleID mocked) { Modules* modules = modulesOf(realm); From bab053b2bdc27d8e6b7718aaa178be779f518390 Mon Sep 17 00:00:00 2001 From: Jarred Sumner Date: Mon, 16 Nov 2026 14:33:17 -0800 Subject: [PATCH 07/19] The module loader asks whether a process has compiled code in front of a class of a module The class of a module is asked for behind the flag of the process, in the loader's steps that are taken for each module. Instructions a call in plain Bun, x64 | arm64, before and now: runModuleLoadStep() 108 > 100 | 120 > 108, runModuleRegistryFetchSettled() 60 > 53 | 62 > 51, runModuleRegistryModuleSettled() 66 > 57 on arm64, moduleNamespaceObject() 11 > 9 | 16 > 9, makeModule() of a module that imports 180 > 174 | 161 > 158. innerModuleLinking() takes more, 108 > 111 | 126 > 132, and innerModuleEvaluation() 111 > 117 | 123 > 134. A fresh module takes 17 fewer of 145,683 (x64) and 55 of 142,515 (arm64), one that imports 44 and 194 fewer. --- .../aot/runtime/AOTModuleRecord.h | 7 +++++ .../runtime/AbstractModuleRecord.cpp | 22 +++++++-------- .../runtime/CyclicModuleRecord.cpp | 4 +-- Source/JavaScriptCore/runtime/JSMicrotask.cpp | 27 +++++++++---------- .../runtime/JSModuleEnvironment.cpp | 2 +- .../JavaScriptCore/runtime/JSModuleLoader.cpp | 8 +++--- .../runtime/JSModuleNamespaceObject.cpp | 2 +- Source/JavaScriptCore/runtime/JSScope.cpp | 2 +- 8 files changed, 40 insertions(+), 34 deletions(-) diff --git a/Source/JavaScriptCore/aot/runtime/AOTModuleRecord.h b/Source/JavaScriptCore/aot/runtime/AOTModuleRecord.h index 8c4a5fe4a8c6c..969341f0b5261 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTModuleRecord.h +++ b/Source/JavaScriptCore/aot/runtime/AOTModuleRecord.h @@ -10,6 +10,7 @@ #include "AOTRecordTypes.h" #include "AOTVector.h" #include "CyclicModuleRecord.h" +#include "VM.h" #include #include #include @@ -224,6 +225,12 @@ class ModuleRecord final : public CyclicModuleRecord { WriteBarrier m_moduleInstance; }; +template +ALWAYS_INLINE ModuleRecord* compiledModule(const VM& vm, T module) +{ + return vm.hasCompiledCode() ? dynamicDowncast(module) : nullptr; +} + void tryBindOriginal(JSGlobalObject*, JSModuleRecord*); void noteOriginalsRequestedBySource(JSGlobalObject*, JSModuleRecord* importer); void linkOriginal(JSGlobalObject*, JSModuleRecord*); diff --git a/Source/JavaScriptCore/runtime/AbstractModuleRecord.cpp b/Source/JavaScriptCore/runtime/AbstractModuleRecord.cpp index 019e4ded7e983..4f6fad54ffafb 100644 --- a/Source/JavaScriptCore/runtime/AbstractModuleRecord.cpp +++ b/Source/JavaScriptCore/runtime/AbstractModuleRecord.cpp @@ -1354,7 +1354,7 @@ auto AbstractModuleRecord::resolveExportImpl(JSGlobalObject* globalObject, const frames[0] = firstLiveRecordViaStarExport; #endif #if ENABLE(AOT) - if (auto* compiled = dynamicDowncast(root.moduleRecord); compiled && frames[0].type == Resolution::Type::Resolved) { + if (auto* compiled = AOT::compiledModule(vm, root.moduleRecord); compiled && frames[0].type == Resolution::Type::Resolved) { if (compiled->hasAnyActiveMock() || compiled->mayOutlive(frames[0].moduleRecord) || frames[0].moduleRecord->hasLiveExports() || wasAmbiguityResolvedByMock || wasResolvedByRemovedMock) { if (!wasAmbiguityResolvedByMock && !wasResolvedByRemovedMock) compiled->storeResolution(root.exportName.get(), frames[0]); @@ -1416,7 +1416,7 @@ auto AbstractModuleRecord::resolveExportByName(JSGlobalObject* globalObject, con #endif #if ENABLE(AOT) - if (auto* compiled = dynamicDowncast(this)) { + if (auto* compiled = AOT::compiledModule(vm, this)) { if (!compiled->hasAnyActiveMock()) { if (std::optional cachedResolution = tryGetCachedResolution(exportName.impl())) return *cachedResolution; @@ -1456,7 +1456,7 @@ auto AbstractModuleRecord::resolveExportByName(JSGlobalObject* globalObject, con JSObject* AbstractModuleRecord::moduleNamespaceObject(JSGlobalObject* globalObject, ModulePhase phase) { #if ENABLE(AOT) - if (auto* compiled = dynamicDowncast(this)) + if (auto* compiled = AOT::compiledModule(globalObject->vm(), this)) return compiled->moduleNamespaceObject(globalObject, phase); #endif return getModuleNamespace(globalObject, phase); @@ -1464,10 +1464,10 @@ JSObject* AbstractModuleRecord::moduleNamespaceObject(JSGlobalObject* globalObje JSModuleNamespaceObject* AbstractModuleRecord::getModuleNamespace(JSGlobalObject* globalObject, ModulePhase phase, bool shouldPreventExtensions) { + VM& vm = globalObject->vm(); #if ENABLE(AOT) - RELEASE_ASSERT(!inherits()); + RELEASE_ASSERT(!AOT::compiledModule(vm, this)); #endif - VM& vm = globalObject->vm(); auto scope = DECLARE_THROW_SCOPE(vm); #if ASSERT_ENABLED @@ -1526,7 +1526,7 @@ JSModuleNamespaceObject* AbstractModuleRecord::getModuleNamespace(JSGlobalObject #endif #if ENABLE(AOT) - if (auto* compiled = dynamicDowncast(moduleRecord)) { + if (auto* compiled = AOT::compiledModule(vm, moduleRecord)) { Vector names; compiled->collectExportedNames(globalObject, names, pendingModules); RETURN_IF_EXCEPTION(scope, nullptr); @@ -1886,7 +1886,7 @@ void AbstractModuleRecord::link(JSGlobalObject* globalObject, RefPtr(this)) { + if (auto* compiled = AOT::compiledModule(vm, this)) { compiled->adoptStatusIfNeeded(); // A linked module stays linked no matter how this step ends. The loader is done with the graph. if (compiled->status() >= CyclicModuleRecord::Status::Linked) { @@ -1951,7 +1951,7 @@ JSPromise* AbstractModuleRecord::evaluate(JSGlobalObject* globalObject) }; #if ENABLE(AOT) - if (auto* compiled = dynamicDowncast(this)) { + if (auto* compiled = AOT::compiledModule(vm, this)) { compiled->adoptStatusIfNeeded(); // An importer of a CommonJS module that is still evaluating gets whatever the module has exported so far. if (compiled->isEvaluatingCommonJSModule()) @@ -2162,7 +2162,7 @@ unsigned AbstractModuleRecord::innerModuleEvaluation(JSGlobalObject* globalObjec VM& vm = globalObject->vm(); auto scope = DECLARE_THROW_SCOPE(vm); #if ENABLE(AOT) - if (auto* compiled = dynamicDowncast(this)) + if (auto* compiled = AOT::compiledModule(vm, this)) RELEASE_AND_RETURN(scope, compiled->innerModuleEvaluation(globalObject, stack, index, referrerAsyncOrder, dynamicImportPromise)); #endif auto* module = dynamicDowncast(this); @@ -2365,7 +2365,7 @@ void AbstractModuleRecord::generateDeferredSyntheticModules(JSGlobalObject* glob if (auto* synthetic = dynamicDowncast(this)) RELEASE_AND_RETURN(scope, synthetic->runDeferredGenerator(globalObject)); #if ENABLE(AOT) - if (auto* compiled = dynamicDowncast(this)) + if (auto* compiled = AOT::compiledModule(vm, this)) RELEASE_AND_RETURN(scope, compiled->generateDeferredSyntheticModules(globalObject, visited)); #endif @@ -2397,7 +2397,7 @@ unsigned AbstractModuleRecord::innerModuleLinking(JSGlobalObject* globalObject, VM& vm = globalObject->vm(); auto scope = DECLARE_THROW_SCOPE(vm); #if ENABLE(AOT) - if (auto* compiled = dynamicDowncast(this)) + if (auto* compiled = AOT::compiledModule(vm, this)) RELEASE_AND_RETURN(scope, compiled->innerModuleLinking(globalObject, stack, index, WTF::move(scriptFetcher))); #endif auto* module = dynamicDowncast(this); diff --git a/Source/JavaScriptCore/runtime/CyclicModuleRecord.cpp b/Source/JavaScriptCore/runtime/CyclicModuleRecord.cpp index 254ce64d7bd55..c738bf4e00b52 100644 --- a/Source/JavaScriptCore/runtime/CyclicModuleRecord.cpp +++ b/Source/JavaScriptCore/runtime/CyclicModuleRecord.cpp @@ -740,7 +740,7 @@ void CyclicModuleRecord::execute(JSGlobalObject* globalObject, JSPromise* capabi auto scope = DECLARE_THROW_SCOPE(vm); #if ENABLE(AOT) - if (auto* compiled = dynamicDowncast(this)) + if (auto* compiled = AOT::compiledModule(vm, this)) RELEASE_AND_RETURN(scope, compiled->execute(globalObject, capability)); #endif #if ENABLE(WEBASSEMBLY) @@ -777,7 +777,7 @@ void CyclicModuleRecord::executeAsync(JSGlobalObject* globalObject) // 2. Assert: module.[[HasTLA]] is true. ASSERT(hasTLA()); #if ENABLE(AOT) - if (auto* compiled = dynamicDowncast(this)) + if (auto* compiled = AOT::compiledModule(vm, this)) RELEASE_AND_RETURN(scope, compiled->executeAsync(globalObject)); if (isCompiledOriginal()) RELEASE_AND_RETURN(scope, AOT::evaluateOriginalAsync(globalObject, uncheckedDowncast(this))); diff --git a/Source/JavaScriptCore/runtime/JSMicrotask.cpp b/Source/JavaScriptCore/runtime/JSMicrotask.cpp index 2a4ad3e710977..443ee3906eb98 100644 --- a/Source/JavaScriptCore/runtime/JSMicrotask.cpp +++ b/Source/JavaScriptCore/runtime/JSMicrotask.cpp @@ -1217,7 +1217,8 @@ static void runModuleRegistryFetchSettled(JSGlobalObject* globalObject, VM& vm, if (status == JSPromise::Status::Fulfilled) { auto moduleData = argument1; #if ENABLE(AOT) - if (auto* compiled = dynamicDowncast(moduleData)) { + auto* compiled = AOT::compiledModule(vm, moduleData); + if (compiled) { JSPromise* source = compiled->sourceAfterRelease(globalObject); if (scope.exception()) [[unlikely]] { modulePromise->rejectWithCaughtException(vm, scope); @@ -1228,10 +1229,7 @@ static void runModuleRegistryFetchSettled(JSGlobalObject* globalObject, VM& vm, return; } } -#endif -#if ENABLE(AOT) - auto* compiledData = dynamicDowncast(moduleData); - bool mayBeMade = compiledData && compiledData->isFileYetToBeEvaluated(); + const bool mayBeMade = compiled && compiled->isFileYetToBeEvaluated(); #endif JSPromise* makeModulePromise = entry->loader()->makeModule(globalObject, entry->key(), moduleData); if (scope.exception()) { @@ -1239,8 +1237,8 @@ static void runModuleRegistryFetchSettled(JSGlobalObject* globalObject, VM& vm, return; } #if ENABLE(AOT) - if (mayBeMade && modulePromise->status() == JSPromise::Status::Pending && makeModulePromise->status() == JSPromise::Status::Fulfilled && makeModulePromise->result() == JSValue(compiledData)) - compiledData->setIsMadeAndNotStored(true); + if (mayBeMade && modulePromise->status() == JSPromise::Status::Pending && makeModulePromise->status() == JSPromise::Status::Fulfilled && makeModulePromise->result() == JSValue(compiled)) + compiled->setIsMadeAndNotStored(true); #endif makeModulePromise->performPromiseThenWithInternalMicrotask(vm, InternalMicrotask::ModuleRegistryModuleSettled, modulePromise, entry); } else { @@ -1261,7 +1259,7 @@ static void runModuleRegistryModuleSettled(JSGlobalObject* globalObject, VM& vm, auto* modulePromise = uncheckedDowncast(argument0); auto status = static_cast(payload); #if ENABLE(AOT) - if (auto* compiled = status == JSPromise::Status::Fulfilled ? dynamicDowncast(argument1) : nullptr) + if (auto* compiled = status == JSPromise::Status::Fulfilled ? AOT::compiledModule(vm, argument1) : nullptr) compiled->setIsMadeAndNotStored(false); #endif #if USE(BUN_JSC_ADDITIONS) @@ -1358,7 +1356,7 @@ static void runModuleLoadStep(JSGlobalObject* globalObject, VM& vm, InternalMicr auto* module = downcast(argument1); context->module(vm, module); #if ENABLE(AOT) - if (auto* compiled = context->payload()->inherits() ? nullptr : dynamicDowncast(module)) + if (auto* compiled = AOT::compiledModule(vm, module); compiled && !context->payload()->inherits()) compiled->willBeLoadedByImport(); #endif JSPromise* requestedPromise = context->loader()->loadRequestedModules(globalObject, module, context->scriptFetcher(), vm.hasCompiledCode() && context->referrer().getModule() ? dynamicDowncast(context->payload()) : nullptr); @@ -1382,14 +1380,15 @@ static void runModuleLoadStep(JSGlobalObject* globalObject, VM& vm, InternalMicr if (status == JSPromise::Status::Fulfilled) { auto* module = context->module(); #if ENABLE(AOT) - if (auto* compiled = dynamicDowncast(module); compiled && compiled->takeExtraLoadStep()) { + auto* compiled = AOT::compiledModule(vm, module); + if (compiled && compiled->takeExtraLoadStep()) { JSPromise* delayedLoadPromise = JSPromise::create(vm, globalObject->promiseStructure()); delayedLoadPromise->markAsHandled(); delayedLoadPromise->fulfill(vm, module); delayedLoadPromise->performPromiseThenWithInternalMicrotask(vm, InternalMicrotask::ModuleLoadStep, loadPromise, context); return; } - if (auto* compiled = dynamicDowncast(module); compiled && context->referrer().isRealm() && compiled->takeMainModuleLoadStep()) { + if (compiled && context->referrer().isRealm() && compiled->takeMainModuleLoadStep()) { // From here on the entry point counts as loaded for every past and future importer. The caller that loaded the program is notified in the next step. JSPromise* importerLoadPromise = JSPromise::create(vm, globalObject->promiseStructure()); importerLoadPromise->markAsHandled(); @@ -1475,7 +1474,7 @@ static void runModuleLoadTopSettled(JSGlobalObject* globalObject, VM& vm, Intern // ModuleRegistryEntry::provideModule(): the entry already holds its record, nothing to provide. #if ENABLE(AOT) // No registry entry holds the record that the fetch hook returns for a compiled module yet. Without one the module would be fetched again. - if (!moduleData.inherits() || moduleData.inherits()) { + if (!moduleData.inherits() || AOT::compiledModule(vm, moduleData)) { #else if (!moduleData.inherits()) { #endif @@ -1695,7 +1694,7 @@ static void runModuleLoadLinkEvaluateSettled(JSGlobalObject* globalObject, VM& v return; } #if ENABLE(AOT) - if (auto* compiled = dynamicDowncast(record)) { + if (auto* compiled = AOT::compiledModule(vm, record)) { evaluatePromise = compiled->evaluateMainModule(evaluatePromise); if (scope.exception()) { resultPromise->rejectWithCaughtException(vm, scope); @@ -1796,7 +1795,7 @@ static void dynamicImportLoadSettled(JSGlobalObject* globalObject, VM& vm, JSVal // Step-6 linkAndEvaluateClosure #if ENABLE(AOT) - if (auto* compiled = vm.hasCompiledCode() ? dynamicDowncast(module) : nullptr; compiled && compiled->tryDeferForEarlierImports(dynamicPayload, deferred)) + if (auto* compiled = AOT::compiledModule(vm, module); compiled && compiled->tryDeferForEarlierImports(dynamicPayload, deferred)) return; #endif // 6.a. Let link be Completion(module.Link()). diff --git a/Source/JavaScriptCore/runtime/JSModuleEnvironment.cpp b/Source/JavaScriptCore/runtime/JSModuleEnvironment.cpp index 0faf08f5783a1..f16ed93a7908f 100644 --- a/Source/JavaScriptCore/runtime/JSModuleEnvironment.cpp +++ b/Source/JavaScriptCore/runtime/JSModuleEnvironment.cpp @@ -158,7 +158,7 @@ bool JSModuleEnvironment::getOwnPropertySlot(JSObject* cell, JSGlobalObject* glo } #endif #if ENABLE(AOT) - if (auto* compiled = dynamicDowncast(resolution.moduleRecord)) { + if (auto* compiled = AOT::compiledModule(vm, resolution.moduleRecord)) { bool isRead = slot.internalMethodType() == PropertySlot::InternalMethodType::Get || slot.internalMethodType() == PropertySlot::InternalMethodType::GetOwnProperty; JSValue value = jsUndefined(); if (isRead) { diff --git a/Source/JavaScriptCore/runtime/JSModuleLoader.cpp b/Source/JavaScriptCore/runtime/JSModuleLoader.cpp index be6ebd055e471..7f0395e952345 100644 --- a/Source/JavaScriptCore/runtime/JSModuleLoader.cpp +++ b/Source/JavaScriptCore/runtime/JSModuleLoader.cpp @@ -936,7 +936,7 @@ JSPromise* JSModuleLoader::hostLoadImportedModule(JSGlobalObject* globalObject, if (fetchPromise->status() == JSPromise::Status::Pending) { #if ENABLE(AOT) // A compiled module already has the record for each of its requests, so there is nothing to fetch. - auto* compiled = record && !moduleRequest.m_attributes ? dynamicDowncast(record) : nullptr; + auto* compiled = record && !moduleRequest.m_attributes ? AOT::compiledModule(vm, record) : nullptr; AbstractModuleRecord* requested = compiled ? compiled->findRequestedRecord(resolved) : nullptr; if (Exception* exception = scope.exception()) [[unlikely]] { TRY_CLEAR_EXCEPTION(scope, nullptr); @@ -1036,7 +1036,7 @@ JSPromise* JSModuleLoader::hostLoadImportedModule(JSGlobalObject* globalObject, JSPromise* promise = nullptr; #if ENABLE(AOT) // A compiled module already knows the record of each compiled module it requests. This promise replaces the one the host would return. - if (auto* compiled = record && !moduleRequest.m_attributes ? dynamicDowncast(record) : nullptr) { + if (auto* compiled = record && !moduleRequest.m_attributes ? AOT::compiledModule(vm, record) : nullptr) { AbstractModuleRecord* requested = compiled->nextRequestedRecord(globalObject, resolved); if (scope.exception()) [[unlikely]] { promise = JSPromise::create(vm, globalObject->promiseStructure()); @@ -1149,7 +1149,7 @@ void JSModuleLoader::innerModuleLoading(JSGlobalObject* globalObject, ModuleGrap // 2.a. Append module to state.[[Visited]]. state->appendVisited(vm, cyclic); #if ENABLE(AOT) - if (auto* compiled = dynamicDowncast(cyclic)) { + if (auto* compiled = AOT::compiledModule(vm, cyclic)) { compiled->willLoadRequests(*state); RETURN_IF_EXCEPTION(scope, void()); // A CommonJS module that this module imports ran inside willLoadRequests() and already resumed this load. @@ -1195,7 +1195,7 @@ void JSModuleLoader::innerModuleLoading(JSGlobalObject* globalObject, ModuleGrap unsigned loadedModulesCountBefore = module->loadedModules().size(); bool useImportMap = true; #if ENABLE(AOT) - auto* compiled = dynamicDowncast(cyclic); + auto* compiled = AOT::compiledModule(vm, cyclic); useImportMap = !compiled; uint8_t flagsBefore = compiled ? compiled->willLoadImportedModule(request.m_specifier) : 0; #endif diff --git a/Source/JavaScriptCore/runtime/JSModuleNamespaceObject.cpp b/Source/JavaScriptCore/runtime/JSModuleNamespaceObject.cpp index 70a2c96a7db95..ca48d4ac0d401 100644 --- a/Source/JavaScriptCore/runtime/JSModuleNamespaceObject.cpp +++ b/Source/JavaScriptCore/runtime/JSModuleNamespaceObject.cpp @@ -212,7 +212,7 @@ bool JSModuleNamespaceObject::getOwnPropertySlotCommon(JSGlobalObject* globalObj case PropertySlot::InternalMethodType::GetOwnProperty: case PropertySlot::InternalMethodType::Get: { #if ENABLE(AOT) - if (auto* compiled = dynamicDowncast(exportEntry.moduleRecord.get())) { + if (auto* compiled = AOT::compiledModule(vm, exportEntry.moduleRecord.get())) { JSValue value = exportEntry.localName == vm.propertyNames->starNamespacePrivateName ? JSValue(compiled->moduleNamespaceObject(globalObject, AbstractModuleRecord::ModulePhase::Evaluation)) : compiled->readExport(globalObject, exportEntry.localName, exportEntry.compiledExportIndex); diff --git a/Source/JavaScriptCore/runtime/JSScope.cpp b/Source/JavaScriptCore/runtime/JSScope.cpp index 66cd977e8f24e..8ba5f49a74df7 100644 --- a/Source/JavaScriptCore/runtime/JSScope.cpp +++ b/Source/JavaScriptCore/runtime/JSScope.cpp @@ -113,7 +113,7 @@ static inline bool abstractAccess(JSGlobalObject* globalObject, JSScope* scope, } #endif #if ENABLE(AOT) - if (importedRecord->inherits()) { + if (AOT::compiledModule(vm, importedRecord)) { op = ResolveOp(Dynamic, 0, nullptr, nullptr, nullptr, 0); return true; } From 7c11c65a9ecbf7a5165b0782cd54602585215ebc Mon Sep 17 00:00:00 2001 From: Jarred Sumner Date: Mon, 16 Nov 2026 14:33:21 -0800 Subject: [PATCH 08/19] AOT test runs: a require() under a second patch that waits is told of An earlier patch in place leaves the original to the file of the factory alone. --- Source/JavaScriptCore/aot/runtime/AOTModuleEvaluation.cpp | 2 +- Source/JavaScriptCore/aot/runtime/AOTModuleInstances.cpp | 5 +++-- Source/JavaScriptCore/aot/runtime/AOTModules.h | 2 +- 3 files changed, 5 insertions(+), 4 deletions(-) diff --git a/Source/JavaScriptCore/aot/runtime/AOTModuleEvaluation.cpp b/Source/JavaScriptCore/aot/runtime/AOTModuleEvaluation.cpp index 7ef60a712399d..3368dba92b411 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTModuleEvaluation.cpp +++ b/Source/JavaScriptCore/aot/runtime/AOTModuleEvaluation.cpp @@ -5285,7 +5285,7 @@ JSValue Modules::answerRequire(ModuleID target, ModuleID referrer, RequiredBy re tellOfFilesThatStayedLoadedBelow(target); if (m_modulesReleasedByLoader.get(target.index()) && !hasInstances(target)) [[unlikely]] bringBackWhatLoaderLetGoBelow(target); - if (isEvaluatedUnderPendingPatch(target)) [[unlikely]] + if (isEvaluatedUnderPendingPatch(target, referrer)) [[unlikely]] tellThatFileDidNotRunAgain(fileOf(target)); if (!m_modulesWithRunningFactory.isEmpty()) [[unlikely]] tellIfFactoryIsRunning(target, LoadKind::Require); diff --git a/Source/JavaScriptCore/aot/runtime/AOTModuleInstances.cpp b/Source/JavaScriptCore/aot/runtime/AOTModuleInstances.cpp index 55cc6882bb0e4..7d306887dd3fa 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTModuleInstances.cpp +++ b/Source/JavaScriptCore/aot/runtime/AOTModuleInstances.cpp @@ -3469,14 +3469,15 @@ void Modules::reportImportersWithoutInstances(ModuleID module) } } -bool Modules::isEvaluatedUnderPendingPatch(ModuleID module) +bool Modules::isEvaluatedUnderPendingPatch(ModuleID module, ModuleID requirer) { ModuleID file = fileOf(module); if (!host().isPatchPending || status(file) != ModuleStatus::Evaluated || !m_table.hasFilePath(file)) [[likely]] return false; if (!isPatchPending(file)) [[likely]] return false; - if (activeMock(file) || hasIntactOriginal(file) || isPatchedByMock(file) || m_originalsEvaluatedUnderMock.get(file.index()) || hasRunBesideMockAlone(file)) + bool isPatchedForRequirer = isPatchedByMock(file) && !(requirer && data(requirer).isEntryPoint()); + if (activeMock(file) || hasIntactOriginal(file) || isPatchedForRequirer || m_originalsEvaluatedUnderMock.get(file.index()) || hasRunBesideMockAlone(file)) return false; return data(file).kind == ModuleKind::CommonJs ? wasLoadedByImport(file) : !!currentInstance(file); } diff --git a/Source/JavaScriptCore/aot/runtime/AOTModules.h b/Source/JavaScriptCore/aot/runtime/AOTModules.h index 212eff4448227..935c075053bcb 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTModules.h +++ b/Source/JavaScriptCore/aot/runtime/AOTModules.h @@ -1492,7 +1492,7 @@ class Modules { bool isRequiredModulePatchPending(ModuleID); std::optional importOriginalUnderPatch(ModuleID, ModuleID referrer, const RefPtr&); bool isPatchPending(ModuleID file) const; - bool isEvaluatedUnderPendingPatch(ModuleID); + bool isEvaluatedUnderPendingPatch(ModuleID, ModuleID requirer); void tellIfFactoryIsRunning(ModuleID requested, LoadKind); void tellIfPatchIsPending(ModuleID required); bool isRequireUnderPendingMock(ModuleID required, ModuleID requirer); From e3a6f906f6d8d5d0311e1899b2d196c31e68ae61 Mon Sep 17 00:00:00 2001 From: Jarred Sumner Date: Mon, 16 Nov 2026 14:33:25 -0800 Subject: [PATCH 09/19] AOT: the name 4294967295 is no name that a class says is absent A view of 4,294,967,296 elements has an element under it, and a short view of the same class has none: what was found on one said it of the other. --- Source/JavaScriptCore/aot/runtime/AOTPropertyCachesAnswers.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Source/JavaScriptCore/aot/runtime/AOTPropertyCachesAnswers.cpp b/Source/JavaScriptCore/aot/runtime/AOTPropertyCachesAnswers.cpp index 22960ff518a6e..e150e12b7c970 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTPropertyCachesAnswers.cpp +++ b/Source/JavaScriptCore/aot/runtime/AOTPropertyCachesAnswers.cpp @@ -73,6 +73,8 @@ static bool isFunctionOwnName(VM& vm, UniquedStringImpl* uid) bool isNeverCachedName(VM& vm, UniquedStringImpl* uid) { + if (uid->length() == 10 && equal(uid, "4294967295"_s)) [[unlikely]] + return true; return parseIndex(PropertyName(uid)) || uid == vm.propertyNames->underscoreProto.impl() || (PropertyName(uid).isPrivateName() && !PropertyName(uid).passesThroughProxies()); } From d60e2c5b7df93d952df8e8045e6d5c99fe80b475 Mon Sep 17 00:00:00 2001 From: Jarred Sumner Date: Mon, 16 Nov 2026 14:33:29 -0800 Subject: [PATCH 10/19] AOT test runs: what a test file's statements import runs in order in front of mocks' factories A factory ran in front of what stood above it in the file. --- .../aot/runtime/AOTModuleHost.h | 1 + .../JavaScriptCore/aot/runtime/AOTModules.h | 14 +- .../aot/runtime/AOTTestRunFactories.cpp | 163 +++++++++++++++++- 3 files changed, 174 insertions(+), 4 deletions(-) diff --git a/Source/JavaScriptCore/aot/runtime/AOTModuleHost.h b/Source/JavaScriptCore/aot/runtime/AOTModuleHost.h index 8331c653ae3d0..96363243cc65a 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTModuleHost.h +++ b/Source/JavaScriptCore/aot/runtime/AOTModuleHost.h @@ -410,6 +410,7 @@ JS_EXPORT_PRIVATE void noteOriginalRequiredFromSource(JSGlobalObject*, ModuleID) JS_EXPORT_PRIVATE JSPromise* pendingFactoryInGraph(JSGlobalObject*, ModuleID, JSValue& state); JS_EXPORT_PRIVATE bool didMockFailForImportStatement(JSGlobalObject*, ModuleID); JS_EXPORT_PRIVATE void willFetchAfterTick(JSGlobalObject*, ModuleID); +JS_EXPORT_PRIVATE void noteImporterOfFetch(JSGlobalObject*, ModuleID, ModuleID importer); JS_EXPORT_PRIVATE void didResumeFetchAfterFactory(JSGlobalObject*); JS_EXPORT_PRIVATE bool wasReleasedByLoader(JSGlobalObject*, ModuleID); JS_EXPORT_PRIVATE void letGoUntilEndOfTestFile(JSGlobalObject*, ModuleID); diff --git a/Source/JavaScriptCore/aot/runtime/AOTModules.h b/Source/JavaScriptCore/aot/runtime/AOTModules.h index 935c075053bcb..cca3a997e3373 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTModules.h +++ b/Source/JavaScriptCore/aot/runtime/AOTModules.h @@ -904,7 +904,7 @@ class Modules { void restoreLibraryOriginal(ModuleID, LibraryMock); bool doesMockReplaceLibraryModule(ModuleID module) const { return m_libraryModulesThatMockReplaces.get(module.index()); } bool isLibraryOriginalDisplaced(ModuleID module) const { return m_displacedLibraryModules.get(module.index()); } - enum class LoadRootKind : bool { StartsLoad, ImportStatement }; + enum class LoadRootKind : uint8_t { StartsLoad, ImportStatement, StatementOfCompiledFile }; bool runMocksInGraph(ModuleID root, LoadRootKind = LoadRootKind::StartsLoad); bool runMocksInGraphSlow(ModuleID root, LoadRootKind); bool wasLoadedWhenMockWasMade(ModuleID); @@ -987,6 +987,12 @@ class Modules { JSValue mockLoadError(ModuleID module) const { return m_modulesWithMockLoadError.get(module.index()) ? loadedIfExists(module)->cachedLoadError.get() : JSValue(); } bool didMockFailForImportStatement(ModuleID); void willFetchAfterTick(ModuleID); + void noteImporterOfFetch(ModuleID, ModuleID importer); + bool importsAbsentNameThroughLoader(ModuleID importer); + bool evaluateStatementsInFrontOf(ModuleID importer, ModuleID); + void evaluateStatementsBehind(ModuleID importer, ModuleID); + std::optional fileOfStatement(const ModuleRequestData&); + bool mayEvaluateInFrontOfMocks(ModuleID); std::optional loadOfFetch(ModuleID fetched); JSPromise* pendingFactoryForFetch(ModuleID fetched, JSValue& state); std::optional currentLoadTarget() const { return m_currentImportTarget ? std::optional(fileOf(m_currentImportTarget)) : m_moduleBeingFetched; } @@ -2676,6 +2682,12 @@ class Modules { void didCallFactoryOfLoad(ModuleID file); bool shouldRunMocksAtFetch(ModuleID); BitVector m_statementFetchesDelayedByTick; + struct FetchForStatement { + ModuleID importer; + bool walksInFrontOfMocks { false }; + }; + UncheckedKeyHashMap m_fetchesForStatements; + std::optional m_importerOfWalkedStatement; struct FactoryCaller { ModuleID root; ModuleID mocked; diff --git a/Source/JavaScriptCore/aot/runtime/AOTTestRunFactories.cpp b/Source/JavaScriptCore/aot/runtime/AOTTestRunFactories.cpp index 7f5d4d4f6b713..b937447e2f78d 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTTestRunFactories.cpp +++ b/Source/JavaScriptCore/aot/runtime/AOTTestRunFactories.cpp @@ -1373,13 +1373,158 @@ bool Modules::runMocksInFetchedGraphSlow(ModuleID module) SetForScope moduleBeingFetched(m_moduleBeingFetched, loadOfFetch(module)); bool wasFetchedForStatement = m_statementFetchesDelayedByTick.get(module.index()); m_statementFetchesDelayedByTick.clear(module.index()); - bool hasCalledWaitingFactory = runMocksInGraph(module, wasFetchedForStatement || (!isAskedForByImportCall && isFetchedForImportStatement(module)) ? LoadRootKind::ImportStatement : LoadRootKind::StartsLoad); + LoadRootKind kind = wasFetchedForStatement || (!isAskedForByImportCall && isFetchedForImportStatement(module)) ? LoadRootKind::ImportStatement : LoadRootKind::StartsLoad; + std::optional importerOfStatement; + auto fetch = m_fetchesForStatements.find(module); + if (fetch != m_fetchesForStatements.end() && status(fetch->value.importer) <= ModuleStatus::Linked && (kind == LoadRootKind::ImportStatement || fetch->value.walksInFrontOfMocks)) { + ModuleID importer = fetch->value.importer; + bool haveRun = fetch->value.walksInFrontOfMocks || evaluateStatementsInFrontOf(importer, module); + RETURN_IF_EXCEPTION(scope, false); + if (haveRun) { + kind = LoadRootKind::StatementOfCompiledFile; + importerOfStatement = importer; + if (auto walked = m_fetchesForStatements.find(module); walked != m_fetchesForStatements.end()) + walked->value.walksInFrontOfMocks = true; + } + } + SetForScope importerOfWalkedStatement(m_importerOfWalkedStatement, importerOfStatement); + bool hasCalledWaitingFactory = runMocksInGraph(module, kind); RETURN_IF_EXCEPTION(scope, false); if (!hasCalledWaitingFactory) noteRequest(); return hasCalledWaitingFactory; } +void Modules::noteImporterOfFetch(ModuleID module, ModuleID importer) +{ + if (importer && status(importer) <= ModuleStatus::Linked) + m_fetchesForStatements.set(module, FetchForStatement { importer }); + else + m_fetchesForStatements.remove(module); +} + +bool Modules::importsAbsentNameThroughLoader(ModuleID importer) +{ + auto scope = DECLARE_THROW_SCOPE(*m_instance.vm); + for (const RequiredNameData& requiredName : m_table.requiredNames(importer)) { + if (!data(requiredName.exporterModule()).isUncompiledCode()) + continue; + const Identifier& key = resolvedKey(requiredName.exporterModule()); + RETURN_IF_EXCEPTION(scope, false); + std::optional exporter = m_table.findByPath(key.string()); + if (exporter && data(*exporter).isESModuleOfProgram() && data(*exporter).hasExportTable() && !data(*exporter).hasDynamicStarExport() && !isMocked(*exporter) && !m_table.findExport(*exporter, requiredName.name)) + return true; + } + return false; +} + +std::optional Modules::fileOfStatement(const ModuleRequestData& request) +{ + auto scope = DECLARE_THROW_SCOPE(*m_instance.vm); + std::optional imported = request.targetModule(); + if (data(*imported).isUncompiledCode()) { + const Identifier& key = resolvedKey(*imported); + RETURN_IF_EXCEPTION(scope, std::nullopt); + imported = m_table.findByPath(key.string()); + } + if (!imported) + return ModuleID(); + return isFileOfProgram(fileOf(*imported)) ? std::optional(fileOf(*imported)) : std::nullopt; +} + +bool Modules::mayEvaluateInFrontOfMocks(ModuleID file) +{ + auto scope = DECLARE_THROW_SCOPE(*m_instance.vm); + if (status(file) > ModuleStatus::Linked || !data(file).isESModuleOfProgram() || !data(file).isSynchronous() || isEvicted(file)) + return false; + bool importsUnloaded = importsUnloadedCode(file); + RETURN_IF_EXCEPTION(scope, false); + if (importsUnloaded) + return false; + for (size_t index : modulesInLoadGraph(file)) { + ModuleID below = fileOf(ModuleID(index)); + if (m_modulesWithPendingMock.get(index) || isMockPending(below) || pendingFactoryCallID(below) || status(ModuleID(index)) == ModuleStatus::EvaluatingAsync) + return false; + } + return true; +} + +bool Modules::evaluateStatementsInFrontOf(ModuleID importer, ModuleID module) +{ + auto scope = DECLARE_THROW_SCOPE(*m_instance.vm); + BitVector reached = modulesInLoadGraph(module); + reached.filter(m_modulesWithPendingMock); + bool leadsToOriginal = false; + for (size_t mocked : reached) + leadsToOriginal |= data(ModuleID(mocked)).isESModuleOfProgram() && needsOriginalBeforeFactory(ModuleID(mocked)); + if (!leadsToOriginal) + return false; + Vector inFront; + bool isFound = false; + for (const ModuleRequestData& request : m_table.imports(importer)) { + if (request.isHoisted || request.isDeferred) + continue; + std::optional file = fileOfStatement(request); + RETURN_IF_EXCEPTION(scope, false); + isFound = file && *file == fileOf(module); + if (isFound) + break; + if (file) + inFront.append(*file); + } + bool failsToLink = !isFound || m_table.importsAbsentExport(importer) || importsAbsentNameThroughLoader(importer); + RETURN_IF_EXCEPTION(scope, false); + if (failsToLink) + return false; + for (ModuleID file : inFront) { + if (file && status(file) == ModuleStatus::Evaluated) + continue; + bool mayRun = file && mayEvaluateInFrontOfMocks(file); + RETURN_IF_EXCEPTION(scope, false); + if (!mayRun) + return false; + if (isMocked(file)) + continue; + JSPromise* evaluation = evaluate(file, std::nullopt, nullptr, nullptr); + RETURN_IF_EXCEPTION(scope, false); + evaluation->markAsHandled(); + if (status(file) == ModuleStatus::Failed) + return false; + } + return true; +} + +void Modules::evaluateStatementsBehind(ModuleID importer, ModuleID module) +{ + auto scope = DECLARE_THROW_SCOPE(*m_instance.vm); + bool isFound = false; + for (const ModuleRequestData& request : m_table.imports(importer)) { + if (request.isHoisted || request.isDeferred) + continue; + std::optional file = fileOfStatement(request); + RETURN_IF_EXCEPTION(scope, void()); + if (!file) + continue; + if (!std::exchange(isFound, isFound || *file == fileOf(module))) + continue; + if (!*file || isEvicted(*file) || (data(*file).isESModuleOfProgram() && !data(*file).isSynchronous())) + return; + bool importsUnloaded = importsUnloadedCode(*file); + RETURN_IF_EXCEPTION(scope, void()); + if (importsUnloaded) + return; + bool mayRun = !isMocked(*file) && mayEvaluateInFrontOfMocks(*file); + RETURN_IF_EXCEPTION(scope, void()); + if (!mayRun) + continue; + JSPromise* evaluation = evaluate(*file, std::nullopt, nullptr, nullptr); + RETURN_IF_EXCEPTION(scope, void()); + evaluation->markAsHandled(); + if (status(*file) == ModuleStatus::Failed) + return; + } +} + void Modules::willFetchAfterTick(ModuleID module) { m_statementFetchesDelayedByTick.set(module.index(), !m_instance.vm->aotState().importFrameInLoader && isFetchedForImportStatement(module)); @@ -2297,7 +2442,7 @@ bool Modules::runMocksInGraphSlow(ModuleID root, LoadRootKind rootOfLoad) if (!mayComeToOne) return isRequireBlocked; std::optional fileOfRoot = m_table.moduleBehindFacade(root); - bool walksInFrontOfMocks = rootOfLoad == LoadRootKind::StartsLoad && m_modulesWithRunningFactory.isEmpty() && !m_evaluatesSynchronously && !m_rootWhoseLoadIsSwept && !vm.aotState().requireRunsMocks && !vm.synchronousModuleQueue(); + bool walksInFrontOfMocks = rootOfLoad != LoadRootKind::ImportStatement && m_modulesWithRunningFactory.isEmpty() && !m_evaluatesSynchronously && !m_rootWhoseLoadIsSwept && !vm.aotState().requireRunsMocks && !vm.synchronousModuleQueue(); bool isRequired = vm.aotState().requireRunsMocks && m_currentRequireTarget == root; std::optional endsBeforeLink; bool hasCalledOrdinaryFactories = !walksInFrontOfMocks; @@ -2335,7 +2480,7 @@ bool Modules::runMocksInGraphSlow(ModuleID root, LoadRootKind rootOfLoad) auto [module, importer, depth] = isBreadthFirst ? work.takeFirst() : work.takeLast(); if (reached.quickSet(module.index()) || (!isRequired && isDeferredByCurrentSweep(module)) || m_originalBeingEvaluated == module) continue; - bool isImportedByStatement = (module != root && module != fileOfRoot) || rootOfLoad == LoadRootKind::ImportStatement; + bool isImportedByStatement = (module != root && module != fileOfRoot) || rootOfLoad != LoadRootKind::StartsLoad; JSValue kept = mockLoadError(module); if (!kept && isImportedByStatement && m_modulesWithCachedMockError.get(module.index())) kept = loadedIfExists(module)->cachedMockError.get(); @@ -2398,6 +2543,12 @@ bool Modules::runMocksInGraphSlow(ModuleID root, LoadRootKind rootOfLoad) if (!m_modulesWithPendingMock.get(module.index())) continue; } + if (rootOfLoad == LoadRootKind::StatementOfCompiledFile && m_importerOfWalkedStatement && (m_importersEnteredAboveMocks.containsIf([&](const ImportersEnteredAboveMock& above) { return above.mocked == module && above.mockHasFactory; }) || (module == root && m_mocksRetriedAfterFailure.get(module.index()) && wasOriginalEvaluated(module)))) { + evaluateStatementsBehind(*std::exchange(m_importerOfWalkedStatement, std::nullopt), root); + RETURN_IF_EXCEPTION(scope, false); + if (!m_modulesWithPendingMock.get(module.index())) + continue; + } m_mocksCalledAgain.set(module.index(), m_mocksCalledInTestFile.set(module.index())); FactoryCaller caller { root, module, m_innermostFactoryCaller }; bool isCalledByRequire = vm.aotState().requireRunsMocks || m_evaluatesSynchronously; @@ -2792,6 +2943,12 @@ JSPromise* pendingFactoryInGraph(JSGlobalObject* realm, ModuleID module, JSValue return modules ? modules->pendingFactoryForFetch(module, state) : nullptr; } +void noteImporterOfFetch(JSGlobalObject* realm, ModuleID module, ModuleID importer) +{ + if (Modules* modules = modulesOf(realm)) + modules->noteImporterOfFetch(module, importer); +} + void willFetchAfterTick(JSGlobalObject* realm, ModuleID module) { if (Modules* modules = modulesOf(realm)) From 4c26e98491319d8a00e24ff21661246520a52788 Mon Sep 17 00:00:00 2001 From: Jarred Sumner Date: Mon, 16 Nov 2026 14:33:32 -0800 Subject: [PATCH 11/19] AOT test runs: an original that ran in front of its factory leaves with the mock A mock that is laid again loads it again. --- Source/JavaScriptCore/aot/runtime/AOTModuleHost.h | 1 + Source/JavaScriptCore/aot/runtime/AOTModuleInstances.cpp | 1 + Source/JavaScriptCore/aot/runtime/AOTModules.h | 2 ++ Source/JavaScriptCore/aot/runtime/AOTTestRunFactories.cpp | 1 + Source/JavaScriptCore/aot/runtime/AOTTestRunImportTurns.cpp | 6 ++++++ 5 files changed, 11 insertions(+) diff --git a/Source/JavaScriptCore/aot/runtime/AOTModuleHost.h b/Source/JavaScriptCore/aot/runtime/AOTModuleHost.h index 96363243cc65a..fc36ebf5bf839 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTModuleHost.h +++ b/Source/JavaScriptCore/aot/runtime/AOTModuleHost.h @@ -461,6 +461,7 @@ JS_EXPORT_PRIVATE void didEndMocksOfTestFile(JSGlobalObject*); JS_EXPORT_PRIVATE void didRequireOwnOriginal(JSGlobalObject*, ModuleID); JS_EXPORT_PRIVATE bool takeRequirerOfOwnOriginal(JSGlobalObject*, ModuleID); JS_EXPORT_PRIVATE bool tryEvictRequirerOfOriginal(JSGlobalObject*, ModuleID); +JS_EXPORT_PRIVATE bool wasOriginalRunForStatement(JSGlobalObject*, ModuleID); JS_EXPORT_PRIVATE JSValue exportsBeforeMock(JSGlobalObject*, ModuleID, bool evenIfEvaluationFailed, bool* didExportReadThrow = nullptr); JS_EXPORT_PRIVATE JSValue retainedOriginalExports(JSGlobalObject*, ModuleID file); JS_EXPORT_PRIVATE JSValue revalidateRetainedOriginalExports(JSGlobalObject*, ModuleID file); diff --git a/Source/JavaScriptCore/aot/runtime/AOTModuleInstances.cpp b/Source/JavaScriptCore/aot/runtime/AOTModuleInstances.cpp index 7d306887dd3fa..c823d37713c0d 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTModuleInstances.cpp +++ b/Source/JavaScriptCore/aot/runtime/AOTModuleInstances.cpp @@ -3378,6 +3378,7 @@ bool Modules::tryEvictRequirerOfOriginal(ModuleID module) return false; releaseImportersOf(file, ReleasedImporters::All); forgetUnmockedOriginal(file); + m_originalsRunForStatements.clear(file.index()); didRemoveActiveMockEntry(file); return true; } diff --git a/Source/JavaScriptCore/aot/runtime/AOTModules.h b/Source/JavaScriptCore/aot/runtime/AOTModules.h index cca3a997e3373..8518d83f04bc5 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTModules.h +++ b/Source/JavaScriptCore/aot/runtime/AOTModules.h @@ -1059,6 +1059,7 @@ class Modules { m_requirersOfOwnOriginals.set(module.index()); } bool tryEvictRequirerOfOriginal(ModuleID); + bool wasOriginalRunForStatement(ModuleID file) const { return m_originalsRunForStatements.get(file.index()); } bool takeRequirerOfOwnOriginal(ModuleID module) { return m_requirersOfOwnOriginals.clear(module.index()); } bool takeEvictedOriginal(ModuleID module) { return m_evictedOriginals.clear(fileOf(module).index()); } void forgetMockRegisteredAfter(ModuleID, uint32_t moment); @@ -3335,6 +3336,7 @@ class Modules { UncheckedKeyHashMap m_pendingMockCalls; BitVector m_unseenMocks; BitVector m_evictedOriginals; + BitVector m_originalsRunForStatements; BitVector m_originalsFetchedByTestFiles; void didEvaluateOriginalUnderMock(ModuleID module) { diff --git a/Source/JavaScriptCore/aot/runtime/AOTTestRunFactories.cpp b/Source/JavaScriptCore/aot/runtime/AOTTestRunFactories.cpp index b937447e2f78d..fe214267fff1f 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTTestRunFactories.cpp +++ b/Source/JavaScriptCore/aot/runtime/AOTTestRunFactories.cpp @@ -2549,6 +2549,7 @@ bool Modules::runMocksInGraphSlow(ModuleID root, LoadRootKind rootOfLoad) if (!m_modulesWithPendingMock.get(module.index())) continue; } + m_originalsRunForStatements.set(fileOf(module).index(), rootOfLoad == LoadRootKind::StatementOfCompiledFile && data(module).isESModuleOfProgram() && needsOriginalBeforeFactory(module)); m_mocksCalledAgain.set(module.index(), m_mocksCalledInTestFile.set(module.index())); FactoryCaller caller { root, module, m_innermostFactoryCaller }; bool isCalledByRequire = vm.aotState().requireRunsMocks || m_evaluatesSynchronously; diff --git a/Source/JavaScriptCore/aot/runtime/AOTTestRunImportTurns.cpp b/Source/JavaScriptCore/aot/runtime/AOTTestRunImportTurns.cpp index 549e7e6a6c5f5..bca4396b4f525 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTTestRunImportTurns.cpp +++ b/Source/JavaScriptCore/aot/runtime/AOTTestRunImportTurns.cpp @@ -870,6 +870,12 @@ bool tryEvictRequirerOfOriginal(JSGlobalObject* realm, ModuleID module) return modules && modules->tryEvictRequirerOfOriginal(module); } +bool wasOriginalRunForStatement(JSGlobalObject* realm, ModuleID file) +{ + Modules* modules = modulesOf(realm); + return modules && modules->wasOriginalRunForStatement(file); +} + bool takeRequirerOfOwnOriginal(JSGlobalObject* realm, ModuleID module) { Modules* modules = modulesOf(realm); From 7cdda59a8184dc3de386178c60b3b333eae4d0e4 Mon Sep 17 00:00:00 2001 From: Jarred Sumner Date: Mon, 16 Nov 2026 14:33:35 -0800 Subject: [PATCH 12/19] AOT: a watched operation declares its user's accesses again only where the user had declared them A build stopped under `--aot-check=VerifyEachStage`. --- Source/JavaScriptCore/aot/codegen/AOTCodeGenerator.cpp | 3 ++- Source/JavaScriptCore/aot/machine/AOTMachineBuilder.h | 1 + 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/Source/JavaScriptCore/aot/codegen/AOTCodeGenerator.cpp b/Source/JavaScriptCore/aot/codegen/AOTCodeGenerator.cpp index 01289eead18d0..a80966b6d04da 100644 --- a/Source/JavaScriptCore/aot/codegen/AOTCodeGenerator.cpp +++ b/Source/JavaScriptCore/aot/codegen/AOTCodeGenerator.cpp @@ -3304,6 +3304,7 @@ NEVER_INLINE void CodeGenerator::endScheduledLifetimes(const ValueContext& conte NEVER_INLINE void CodeGenerator::generateWatched(const ValueContext& context) { const OperationContext* user = std::exchange(m_operation, &context); + const bool userDeclaresAccesses = user && m_out.hasDeclaredAccesses(); Machine::Origin originOfUser = m_out.origin(); m_out.setOrigin(machineOriginOf(context.id())); bool userOwesFenceBehindStores = std::exchange(m_owesFenceBehindStores, false); @@ -3323,7 +3324,7 @@ NEVER_INLINE void CodeGenerator::generateWatched(const ValueContext& context) if (m_looksBehindEachOperation) [[unlikely]] { if (barrierIsCountedOn(context.id()) && !m_storesBehindWhichOwnerIsRemembered.get(context.id().index()) && !m_hasFailed) fail(context, InternalErrorKind::OpcodeNotInForm, "the barrier of an earlier store is left to this one, and the code of this one does not remember its owner"_s); - if (m_checksAllocation && user) + if (m_checksAllocation && userDeclaresAccesses) declareAccessesSlow(*user); else if (m_checksAllocation) m_out.clearDeclaredAccesses(); diff --git a/Source/JavaScriptCore/aot/machine/AOTMachineBuilder.h b/Source/JavaScriptCore/aot/machine/AOTMachineBuilder.h index 1e885a543ea50..6d1902182aa74 100644 --- a/Source/JavaScriptCore/aot/machine/AOTMachineBuilder.h +++ b/Source/JavaScriptCore/aot/machine/AOTMachineBuilder.h @@ -173,6 +173,7 @@ class Builder { JS_EXPORT_PRIVATE void setDeclaredAccesses(const HeapSet& reads, const HeapSet& writes); JS_EXPORT_PRIVATE void clearDeclaredAccesses(); + bool hasDeclaredAccesses() const { return m_suspensionsOfDeclaredAccesses ? m_hadDeclaredAccessesWhenSuspended : m_hasDeclaredAccesses; } void suspendDeclaredAccesses() { if (!m_suspensionsOfDeclaredAccesses++) { From 25051fb0a9c5f9a29e7992297f4872514634f413 Mon Sep 17 00:00:00 2001 From: Jarred Sumner Date: Mon, 16 Nov 2026 14:35:26 -0800 Subject: [PATCH 13/19] AOT: for-of calls the return() and next() that code lays on an iterator of a collection A loop steps the collection itself only where each method hands the iterator back untouched from the call that made it. Elsewhere the iterator's own methods are called. --- .../aot/walk/AOTWalkIteration.cpp | 38 ++++++++++++++++--- 1 file changed, 33 insertions(+), 5 deletions(-) diff --git a/Source/JavaScriptCore/aot/walk/AOTWalkIteration.cpp b/Source/JavaScriptCore/aot/walk/AOTWalkIteration.cpp index b0b5936035d85..25802716ed60f 100644 --- a/Source/JavaScriptCore/aot/walk/AOTWalkIteration.cpp +++ b/Source/JavaScriptCore/aot/walk/AOTWalkIteration.cpp @@ -681,23 +681,50 @@ static uint32_t endOfRowOfAppendsInIteration(const BodyIndex& index, const BodyB static FunctionID functionWrittenUnderNextOfIteratorOf(Walker&, ValueID iterated); -static bool returnsFreshIterator(const Walker& walker, FunctionID function) +static ValueID callHandedBack(const Walker& walker, FunctionID function) { const BodyIndex* body = walker.facts().bodies().find(function); if (!body || walker.program().at(function).isCoroutine()) - return false; + return { }; ValueID returned; for (uint32_t number = 0; number < body->numberOfBlocks(); ++number) { BodyTerminator end = body->terminator(BlockID(number)); if (!body->isReachable(BlockID(number)) || (end.kind() != TerminatorKind::Return && end.kind() != TerminatorKind::ReturnCall)) continue; if (returned || !end.operand(0)) - return false; + return { }; returned = end.operand(0); while (!body->isParameter(returned) && inputPassThroughOpcodes.contains(body->opcodeOf(returned)) && body->useCount(returned) == 1) returned = body->value(returned).operand(0); } - return returned && !body->isParameter(returned) && body->opcodeOf(returned) == Opcode::Call && body->useCount(returned) == 1 && body->value(returned).as().argumentsOperands().empty(); + bool isFresh = returned && !body->isParameter(returned) && body->opcodeOf(returned) == Opcode::Call && body->useCount(returned) == 1 && body->value(returned).as().argumentsOperands().empty(); + return isFresh ? returned : ValueID(); +} + +static bool returnsFreshIterator(const Walker& walker, FunctionID function) +{ + return !!callHandedBack(walker, function); +} + +static bool isHandedBackUntouched(const Walker& walker, Reference value, uint32_t firstFrame) +{ + const auto& frames = walker.code().inlineFrames(); + const Operation& made = walker.code().at(underlyingCellOf(walker.code(), value.id())); + if (made.inlineFrame < firstFrame) + return false; + uint32_t position = made.position; + for (uint32_t frame = made.inlineFrame; frame != walker.inlineFrameAtWork(); frame = frames[frame].parent) { + if (!frame || !frames[frame].callee) + return false; + if (!frames[frame].calledBuiltin) { + const FunctionID function(frames[frame].callee); + ValueID call = callHandedBack(walker, function); + if (!call || walker.facts().bodies().find(function)->value(call).origin().position != position) + return false; + } + position = frames[frame].callPosition; + } + return true; } static std::optional findCollectionOfIterator(Walker& walker, Reference iterator, Reference& collection) @@ -1315,12 +1342,13 @@ class BuilderOfIteration { return m_walker.isUnreachable() ? std::optional(Walker::IndexedIteration()) : std::nullopt; m_walker.count(StatisticID::IteratorMethodsCalledDirectly); + const uint32_t firstFrameOfCall = static_cast(m_walker.code().inlineFrames().size()); Reference iterator = call(method, iterable); if (m_walker.isUnreachable()) return Walker::IndexedIteration(); Reference collection; std::optional stepped = findCollectionOfIterator(m_walker, iterator, collection); - if (!stepped) + if (!stepped || !isHandedBackUntouched(m_walker, iterator, firstFrameOfCall)) return openByProtocolAlone(iterable, iterator); m_walker.count(StatisticID::IteratorAllocationsElidedInInlinees); if (stepped->contents == ContentsStepped::List) { From 56ec39e5fd73d3ec05f2ec894d70acdf9f419341 Mon Sep 17 00:00:00 2001 From: Jarred Sumner Date: Mon, 16 Nov 2026 15:30:33 -0800 Subject: [PATCH 14/19] AOT test runs: what a preload has run under its own mock keeps that mock while no test file loads A mock that a hook laid and nothing has called doesn't take its place. --- .../aot/runtime/AOTTestRunMockViews.cpp | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/Source/JavaScriptCore/aot/runtime/AOTTestRunMockViews.cpp b/Source/JavaScriptCore/aot/runtime/AOTTestRunMockViews.cpp index c53f1dffca501..0e6bdf39c90ae 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTTestRunMockViews.cpp +++ b/Source/JavaScriptCore/aot/runtime/AOTTestRunMockViews.cpp @@ -922,7 +922,16 @@ bool Modules::keepsMockThatStandsWhileAnotherWaits(ModuleID mocked, ModuleID imp return false; auto waiting = m_pendingMockCalls.find(fileOrModule); uint32_t linked = momentLinked(importer); - return waiting != m_pendingMockCalls.end() && waiting->value.keepsActiveMock && linked && linked < waiting->value.moment; + if (waiting == m_pendingMockCalls.end() || !linked || linked >= waiting->value.moment) + return false; + if (waiting->value.keepsActiveMock) + return true; + bool hasRunInPreload = m_loadedInPreload.get(importer.index()) && data(importer).isESModuleOfProgram() && status(importer) == ModuleStatus::Evaluated && !isEvicted(importer) && (!hasInstances(importer) || currentInstance(importer)); + bool isTestFileLoading = false; + m_instance.vm->aotState().filesStartedByHost.forEachSetBit([&](size_t index) { + isTestFileLoading |= status(ModuleID(index)) < ModuleStatus::Evaluated; + }); + return hasRunInPreload && (waiting->value.isInPreload || !isTestFileLoading) && !hasRemovedMock(fileOrModule) && activeMock(fileOrModule) == loadedIfExists(fileOrModule)->preloadMock.get(); } void Modules::noteMomentMockComesInPlace(ModuleID fileOrModule, JSObject* mock, bool stoodInPlace, bool keepsEarlierMockForImporters) From c731074b15bdd7e0b050ee82c074f754c3bbe9fa Mon Sep 17 00:00:00 2001 From: Jarred Sumner Date: Mon, 16 Nov 2026 15:47:48 -0800 Subject: [PATCH 15/19] AOT test runs: a package that a preload has run takes the mock that a hook laid What a preload has run under its own mock keeps it for the files of the program alone. --- Source/JavaScriptCore/aot/runtime/AOTTestRunMockViews.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Source/JavaScriptCore/aot/runtime/AOTTestRunMockViews.cpp b/Source/JavaScriptCore/aot/runtime/AOTTestRunMockViews.cpp index 0e6bdf39c90ae..12b7f35854b29 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTTestRunMockViews.cpp +++ b/Source/JavaScriptCore/aot/runtime/AOTTestRunMockViews.cpp @@ -926,7 +926,7 @@ bool Modules::keepsMockThatStandsWhileAnotherWaits(ModuleID mocked, ModuleID imp return false; if (waiting->value.keepsActiveMock) return true; - bool hasRunInPreload = m_loadedInPreload.get(importer.index()) && data(importer).isESModuleOfProgram() && status(importer) == ModuleStatus::Evaluated && !isEvicted(importer) && (!hasInstances(importer) || currentInstance(importer)); + bool hasRunInPreload = !isOfPackage(fileOrModule) && m_loadedInPreload.get(importer.index()) && data(importer).isESModuleOfProgram() && status(importer) == ModuleStatus::Evaluated && !isEvicted(importer) && (!hasInstances(importer) || currentInstance(importer)); bool isTestFileLoading = false; m_instance.vm->aotState().filesStartedByHost.forEachSetBit([&](size_t index) { isTestFileLoading |= status(ModuleID(index)) < ModuleStatus::Evaluated; From e58827bbac0d46183e0cc168e5fab87695c269de Mon Sep 17 00:00:00 2001 From: Jarred Sumner Date: Mon, 16 Nov 2026 16:01:23 -0800 Subject: [PATCH 16/19] Revert "AOT test runs: an original that ran in front of its factory leaves with the mock" Reverts 4c26e98491319d8a00e24ff21661246520a52788. --- Source/JavaScriptCore/aot/runtime/AOTModuleHost.h | 1 - Source/JavaScriptCore/aot/runtime/AOTModuleInstances.cpp | 1 - Source/JavaScriptCore/aot/runtime/AOTModules.h | 2 -- Source/JavaScriptCore/aot/runtime/AOTTestRunFactories.cpp | 1 - Source/JavaScriptCore/aot/runtime/AOTTestRunImportTurns.cpp | 6 ------ 5 files changed, 11 deletions(-) diff --git a/Source/JavaScriptCore/aot/runtime/AOTModuleHost.h b/Source/JavaScriptCore/aot/runtime/AOTModuleHost.h index fc36ebf5bf839..96363243cc65a 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTModuleHost.h +++ b/Source/JavaScriptCore/aot/runtime/AOTModuleHost.h @@ -461,7 +461,6 @@ JS_EXPORT_PRIVATE void didEndMocksOfTestFile(JSGlobalObject*); JS_EXPORT_PRIVATE void didRequireOwnOriginal(JSGlobalObject*, ModuleID); JS_EXPORT_PRIVATE bool takeRequirerOfOwnOriginal(JSGlobalObject*, ModuleID); JS_EXPORT_PRIVATE bool tryEvictRequirerOfOriginal(JSGlobalObject*, ModuleID); -JS_EXPORT_PRIVATE bool wasOriginalRunForStatement(JSGlobalObject*, ModuleID); JS_EXPORT_PRIVATE JSValue exportsBeforeMock(JSGlobalObject*, ModuleID, bool evenIfEvaluationFailed, bool* didExportReadThrow = nullptr); JS_EXPORT_PRIVATE JSValue retainedOriginalExports(JSGlobalObject*, ModuleID file); JS_EXPORT_PRIVATE JSValue revalidateRetainedOriginalExports(JSGlobalObject*, ModuleID file); diff --git a/Source/JavaScriptCore/aot/runtime/AOTModuleInstances.cpp b/Source/JavaScriptCore/aot/runtime/AOTModuleInstances.cpp index c823d37713c0d..7d306887dd3fa 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTModuleInstances.cpp +++ b/Source/JavaScriptCore/aot/runtime/AOTModuleInstances.cpp @@ -3378,7 +3378,6 @@ bool Modules::tryEvictRequirerOfOriginal(ModuleID module) return false; releaseImportersOf(file, ReleasedImporters::All); forgetUnmockedOriginal(file); - m_originalsRunForStatements.clear(file.index()); didRemoveActiveMockEntry(file); return true; } diff --git a/Source/JavaScriptCore/aot/runtime/AOTModules.h b/Source/JavaScriptCore/aot/runtime/AOTModules.h index 8518d83f04bc5..cca3a997e3373 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTModules.h +++ b/Source/JavaScriptCore/aot/runtime/AOTModules.h @@ -1059,7 +1059,6 @@ class Modules { m_requirersOfOwnOriginals.set(module.index()); } bool tryEvictRequirerOfOriginal(ModuleID); - bool wasOriginalRunForStatement(ModuleID file) const { return m_originalsRunForStatements.get(file.index()); } bool takeRequirerOfOwnOriginal(ModuleID module) { return m_requirersOfOwnOriginals.clear(module.index()); } bool takeEvictedOriginal(ModuleID module) { return m_evictedOriginals.clear(fileOf(module).index()); } void forgetMockRegisteredAfter(ModuleID, uint32_t moment); @@ -3336,7 +3335,6 @@ class Modules { UncheckedKeyHashMap m_pendingMockCalls; BitVector m_unseenMocks; BitVector m_evictedOriginals; - BitVector m_originalsRunForStatements; BitVector m_originalsFetchedByTestFiles; void didEvaluateOriginalUnderMock(ModuleID module) { diff --git a/Source/JavaScriptCore/aot/runtime/AOTTestRunFactories.cpp b/Source/JavaScriptCore/aot/runtime/AOTTestRunFactories.cpp index fe214267fff1f..b937447e2f78d 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTTestRunFactories.cpp +++ b/Source/JavaScriptCore/aot/runtime/AOTTestRunFactories.cpp @@ -2549,7 +2549,6 @@ bool Modules::runMocksInGraphSlow(ModuleID root, LoadRootKind rootOfLoad) if (!m_modulesWithPendingMock.get(module.index())) continue; } - m_originalsRunForStatements.set(fileOf(module).index(), rootOfLoad == LoadRootKind::StatementOfCompiledFile && data(module).isESModuleOfProgram() && needsOriginalBeforeFactory(module)); m_mocksCalledAgain.set(module.index(), m_mocksCalledInTestFile.set(module.index())); FactoryCaller caller { root, module, m_innermostFactoryCaller }; bool isCalledByRequire = vm.aotState().requireRunsMocks || m_evaluatesSynchronously; diff --git a/Source/JavaScriptCore/aot/runtime/AOTTestRunImportTurns.cpp b/Source/JavaScriptCore/aot/runtime/AOTTestRunImportTurns.cpp index bca4396b4f525..549e7e6a6c5f5 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTTestRunImportTurns.cpp +++ b/Source/JavaScriptCore/aot/runtime/AOTTestRunImportTurns.cpp @@ -870,12 +870,6 @@ bool tryEvictRequirerOfOriginal(JSGlobalObject* realm, ModuleID module) return modules && modules->tryEvictRequirerOfOriginal(module); } -bool wasOriginalRunForStatement(JSGlobalObject* realm, ModuleID file) -{ - Modules* modules = modulesOf(realm); - return modules && modules->wasOriginalRunForStatement(file); -} - bool takeRequirerOfOwnOriginal(JSGlobalObject* realm, ModuleID module) { Modules* modules = modulesOf(realm); From 376b38e9eae123228fb9a13f0860672aa76f7a34 Mon Sep 17 00:00:00 2001 From: Jarred Sumner Date: Mon, 16 Nov 2026 16:01:23 -0800 Subject: [PATCH 17/19] Revert "AOT test runs: what a test file's statements import runs in order in front of mocks' factories" Reverts d60e2c5b7df93d952df8e8045e6d5c99fe80b475. --- .../aot/runtime/AOTModuleHost.h | 1 - .../JavaScriptCore/aot/runtime/AOTModules.h | 14 +- .../aot/runtime/AOTTestRunFactories.cpp | 163 +----------------- 3 files changed, 4 insertions(+), 174 deletions(-) diff --git a/Source/JavaScriptCore/aot/runtime/AOTModuleHost.h b/Source/JavaScriptCore/aot/runtime/AOTModuleHost.h index 96363243cc65a..8331c653ae3d0 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTModuleHost.h +++ b/Source/JavaScriptCore/aot/runtime/AOTModuleHost.h @@ -410,7 +410,6 @@ JS_EXPORT_PRIVATE void noteOriginalRequiredFromSource(JSGlobalObject*, ModuleID) JS_EXPORT_PRIVATE JSPromise* pendingFactoryInGraph(JSGlobalObject*, ModuleID, JSValue& state); JS_EXPORT_PRIVATE bool didMockFailForImportStatement(JSGlobalObject*, ModuleID); JS_EXPORT_PRIVATE void willFetchAfterTick(JSGlobalObject*, ModuleID); -JS_EXPORT_PRIVATE void noteImporterOfFetch(JSGlobalObject*, ModuleID, ModuleID importer); JS_EXPORT_PRIVATE void didResumeFetchAfterFactory(JSGlobalObject*); JS_EXPORT_PRIVATE bool wasReleasedByLoader(JSGlobalObject*, ModuleID); JS_EXPORT_PRIVATE void letGoUntilEndOfTestFile(JSGlobalObject*, ModuleID); diff --git a/Source/JavaScriptCore/aot/runtime/AOTModules.h b/Source/JavaScriptCore/aot/runtime/AOTModules.h index cca3a997e3373..935c075053bcb 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTModules.h +++ b/Source/JavaScriptCore/aot/runtime/AOTModules.h @@ -904,7 +904,7 @@ class Modules { void restoreLibraryOriginal(ModuleID, LibraryMock); bool doesMockReplaceLibraryModule(ModuleID module) const { return m_libraryModulesThatMockReplaces.get(module.index()); } bool isLibraryOriginalDisplaced(ModuleID module) const { return m_displacedLibraryModules.get(module.index()); } - enum class LoadRootKind : uint8_t { StartsLoad, ImportStatement, StatementOfCompiledFile }; + enum class LoadRootKind : bool { StartsLoad, ImportStatement }; bool runMocksInGraph(ModuleID root, LoadRootKind = LoadRootKind::StartsLoad); bool runMocksInGraphSlow(ModuleID root, LoadRootKind); bool wasLoadedWhenMockWasMade(ModuleID); @@ -987,12 +987,6 @@ class Modules { JSValue mockLoadError(ModuleID module) const { return m_modulesWithMockLoadError.get(module.index()) ? loadedIfExists(module)->cachedLoadError.get() : JSValue(); } bool didMockFailForImportStatement(ModuleID); void willFetchAfterTick(ModuleID); - void noteImporterOfFetch(ModuleID, ModuleID importer); - bool importsAbsentNameThroughLoader(ModuleID importer); - bool evaluateStatementsInFrontOf(ModuleID importer, ModuleID); - void evaluateStatementsBehind(ModuleID importer, ModuleID); - std::optional fileOfStatement(const ModuleRequestData&); - bool mayEvaluateInFrontOfMocks(ModuleID); std::optional loadOfFetch(ModuleID fetched); JSPromise* pendingFactoryForFetch(ModuleID fetched, JSValue& state); std::optional currentLoadTarget() const { return m_currentImportTarget ? std::optional(fileOf(m_currentImportTarget)) : m_moduleBeingFetched; } @@ -2682,12 +2676,6 @@ class Modules { void didCallFactoryOfLoad(ModuleID file); bool shouldRunMocksAtFetch(ModuleID); BitVector m_statementFetchesDelayedByTick; - struct FetchForStatement { - ModuleID importer; - bool walksInFrontOfMocks { false }; - }; - UncheckedKeyHashMap m_fetchesForStatements; - std::optional m_importerOfWalkedStatement; struct FactoryCaller { ModuleID root; ModuleID mocked; diff --git a/Source/JavaScriptCore/aot/runtime/AOTTestRunFactories.cpp b/Source/JavaScriptCore/aot/runtime/AOTTestRunFactories.cpp index b937447e2f78d..7f5d4d4f6b713 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTTestRunFactories.cpp +++ b/Source/JavaScriptCore/aot/runtime/AOTTestRunFactories.cpp @@ -1373,158 +1373,13 @@ bool Modules::runMocksInFetchedGraphSlow(ModuleID module) SetForScope moduleBeingFetched(m_moduleBeingFetched, loadOfFetch(module)); bool wasFetchedForStatement = m_statementFetchesDelayedByTick.get(module.index()); m_statementFetchesDelayedByTick.clear(module.index()); - LoadRootKind kind = wasFetchedForStatement || (!isAskedForByImportCall && isFetchedForImportStatement(module)) ? LoadRootKind::ImportStatement : LoadRootKind::StartsLoad; - std::optional importerOfStatement; - auto fetch = m_fetchesForStatements.find(module); - if (fetch != m_fetchesForStatements.end() && status(fetch->value.importer) <= ModuleStatus::Linked && (kind == LoadRootKind::ImportStatement || fetch->value.walksInFrontOfMocks)) { - ModuleID importer = fetch->value.importer; - bool haveRun = fetch->value.walksInFrontOfMocks || evaluateStatementsInFrontOf(importer, module); - RETURN_IF_EXCEPTION(scope, false); - if (haveRun) { - kind = LoadRootKind::StatementOfCompiledFile; - importerOfStatement = importer; - if (auto walked = m_fetchesForStatements.find(module); walked != m_fetchesForStatements.end()) - walked->value.walksInFrontOfMocks = true; - } - } - SetForScope importerOfWalkedStatement(m_importerOfWalkedStatement, importerOfStatement); - bool hasCalledWaitingFactory = runMocksInGraph(module, kind); + bool hasCalledWaitingFactory = runMocksInGraph(module, wasFetchedForStatement || (!isAskedForByImportCall && isFetchedForImportStatement(module)) ? LoadRootKind::ImportStatement : LoadRootKind::StartsLoad); RETURN_IF_EXCEPTION(scope, false); if (!hasCalledWaitingFactory) noteRequest(); return hasCalledWaitingFactory; } -void Modules::noteImporterOfFetch(ModuleID module, ModuleID importer) -{ - if (importer && status(importer) <= ModuleStatus::Linked) - m_fetchesForStatements.set(module, FetchForStatement { importer }); - else - m_fetchesForStatements.remove(module); -} - -bool Modules::importsAbsentNameThroughLoader(ModuleID importer) -{ - auto scope = DECLARE_THROW_SCOPE(*m_instance.vm); - for (const RequiredNameData& requiredName : m_table.requiredNames(importer)) { - if (!data(requiredName.exporterModule()).isUncompiledCode()) - continue; - const Identifier& key = resolvedKey(requiredName.exporterModule()); - RETURN_IF_EXCEPTION(scope, false); - std::optional exporter = m_table.findByPath(key.string()); - if (exporter && data(*exporter).isESModuleOfProgram() && data(*exporter).hasExportTable() && !data(*exporter).hasDynamicStarExport() && !isMocked(*exporter) && !m_table.findExport(*exporter, requiredName.name)) - return true; - } - return false; -} - -std::optional Modules::fileOfStatement(const ModuleRequestData& request) -{ - auto scope = DECLARE_THROW_SCOPE(*m_instance.vm); - std::optional imported = request.targetModule(); - if (data(*imported).isUncompiledCode()) { - const Identifier& key = resolvedKey(*imported); - RETURN_IF_EXCEPTION(scope, std::nullopt); - imported = m_table.findByPath(key.string()); - } - if (!imported) - return ModuleID(); - return isFileOfProgram(fileOf(*imported)) ? std::optional(fileOf(*imported)) : std::nullopt; -} - -bool Modules::mayEvaluateInFrontOfMocks(ModuleID file) -{ - auto scope = DECLARE_THROW_SCOPE(*m_instance.vm); - if (status(file) > ModuleStatus::Linked || !data(file).isESModuleOfProgram() || !data(file).isSynchronous() || isEvicted(file)) - return false; - bool importsUnloaded = importsUnloadedCode(file); - RETURN_IF_EXCEPTION(scope, false); - if (importsUnloaded) - return false; - for (size_t index : modulesInLoadGraph(file)) { - ModuleID below = fileOf(ModuleID(index)); - if (m_modulesWithPendingMock.get(index) || isMockPending(below) || pendingFactoryCallID(below) || status(ModuleID(index)) == ModuleStatus::EvaluatingAsync) - return false; - } - return true; -} - -bool Modules::evaluateStatementsInFrontOf(ModuleID importer, ModuleID module) -{ - auto scope = DECLARE_THROW_SCOPE(*m_instance.vm); - BitVector reached = modulesInLoadGraph(module); - reached.filter(m_modulesWithPendingMock); - bool leadsToOriginal = false; - for (size_t mocked : reached) - leadsToOriginal |= data(ModuleID(mocked)).isESModuleOfProgram() && needsOriginalBeforeFactory(ModuleID(mocked)); - if (!leadsToOriginal) - return false; - Vector inFront; - bool isFound = false; - for (const ModuleRequestData& request : m_table.imports(importer)) { - if (request.isHoisted || request.isDeferred) - continue; - std::optional file = fileOfStatement(request); - RETURN_IF_EXCEPTION(scope, false); - isFound = file && *file == fileOf(module); - if (isFound) - break; - if (file) - inFront.append(*file); - } - bool failsToLink = !isFound || m_table.importsAbsentExport(importer) || importsAbsentNameThroughLoader(importer); - RETURN_IF_EXCEPTION(scope, false); - if (failsToLink) - return false; - for (ModuleID file : inFront) { - if (file && status(file) == ModuleStatus::Evaluated) - continue; - bool mayRun = file && mayEvaluateInFrontOfMocks(file); - RETURN_IF_EXCEPTION(scope, false); - if (!mayRun) - return false; - if (isMocked(file)) - continue; - JSPromise* evaluation = evaluate(file, std::nullopt, nullptr, nullptr); - RETURN_IF_EXCEPTION(scope, false); - evaluation->markAsHandled(); - if (status(file) == ModuleStatus::Failed) - return false; - } - return true; -} - -void Modules::evaluateStatementsBehind(ModuleID importer, ModuleID module) -{ - auto scope = DECLARE_THROW_SCOPE(*m_instance.vm); - bool isFound = false; - for (const ModuleRequestData& request : m_table.imports(importer)) { - if (request.isHoisted || request.isDeferred) - continue; - std::optional file = fileOfStatement(request); - RETURN_IF_EXCEPTION(scope, void()); - if (!file) - continue; - if (!std::exchange(isFound, isFound || *file == fileOf(module))) - continue; - if (!*file || isEvicted(*file) || (data(*file).isESModuleOfProgram() && !data(*file).isSynchronous())) - return; - bool importsUnloaded = importsUnloadedCode(*file); - RETURN_IF_EXCEPTION(scope, void()); - if (importsUnloaded) - return; - bool mayRun = !isMocked(*file) && mayEvaluateInFrontOfMocks(*file); - RETURN_IF_EXCEPTION(scope, void()); - if (!mayRun) - continue; - JSPromise* evaluation = evaluate(*file, std::nullopt, nullptr, nullptr); - RETURN_IF_EXCEPTION(scope, void()); - evaluation->markAsHandled(); - if (status(*file) == ModuleStatus::Failed) - return; - } -} - void Modules::willFetchAfterTick(ModuleID module) { m_statementFetchesDelayedByTick.set(module.index(), !m_instance.vm->aotState().importFrameInLoader && isFetchedForImportStatement(module)); @@ -2442,7 +2297,7 @@ bool Modules::runMocksInGraphSlow(ModuleID root, LoadRootKind rootOfLoad) if (!mayComeToOne) return isRequireBlocked; std::optional fileOfRoot = m_table.moduleBehindFacade(root); - bool walksInFrontOfMocks = rootOfLoad != LoadRootKind::ImportStatement && m_modulesWithRunningFactory.isEmpty() && !m_evaluatesSynchronously && !m_rootWhoseLoadIsSwept && !vm.aotState().requireRunsMocks && !vm.synchronousModuleQueue(); + bool walksInFrontOfMocks = rootOfLoad == LoadRootKind::StartsLoad && m_modulesWithRunningFactory.isEmpty() && !m_evaluatesSynchronously && !m_rootWhoseLoadIsSwept && !vm.aotState().requireRunsMocks && !vm.synchronousModuleQueue(); bool isRequired = vm.aotState().requireRunsMocks && m_currentRequireTarget == root; std::optional endsBeforeLink; bool hasCalledOrdinaryFactories = !walksInFrontOfMocks; @@ -2480,7 +2335,7 @@ bool Modules::runMocksInGraphSlow(ModuleID root, LoadRootKind rootOfLoad) auto [module, importer, depth] = isBreadthFirst ? work.takeFirst() : work.takeLast(); if (reached.quickSet(module.index()) || (!isRequired && isDeferredByCurrentSweep(module)) || m_originalBeingEvaluated == module) continue; - bool isImportedByStatement = (module != root && module != fileOfRoot) || rootOfLoad != LoadRootKind::StartsLoad; + bool isImportedByStatement = (module != root && module != fileOfRoot) || rootOfLoad == LoadRootKind::ImportStatement; JSValue kept = mockLoadError(module); if (!kept && isImportedByStatement && m_modulesWithCachedMockError.get(module.index())) kept = loadedIfExists(module)->cachedMockError.get(); @@ -2543,12 +2398,6 @@ bool Modules::runMocksInGraphSlow(ModuleID root, LoadRootKind rootOfLoad) if (!m_modulesWithPendingMock.get(module.index())) continue; } - if (rootOfLoad == LoadRootKind::StatementOfCompiledFile && m_importerOfWalkedStatement && (m_importersEnteredAboveMocks.containsIf([&](const ImportersEnteredAboveMock& above) { return above.mocked == module && above.mockHasFactory; }) || (module == root && m_mocksRetriedAfterFailure.get(module.index()) && wasOriginalEvaluated(module)))) { - evaluateStatementsBehind(*std::exchange(m_importerOfWalkedStatement, std::nullopt), root); - RETURN_IF_EXCEPTION(scope, false); - if (!m_modulesWithPendingMock.get(module.index())) - continue; - } m_mocksCalledAgain.set(module.index(), m_mocksCalledInTestFile.set(module.index())); FactoryCaller caller { root, module, m_innermostFactoryCaller }; bool isCalledByRequire = vm.aotState().requireRunsMocks || m_evaluatesSynchronously; @@ -2943,12 +2792,6 @@ JSPromise* pendingFactoryInGraph(JSGlobalObject* realm, ModuleID module, JSValue return modules ? modules->pendingFactoryForFetch(module, state) : nullptr; } -void noteImporterOfFetch(JSGlobalObject* realm, ModuleID module, ModuleID importer) -{ - if (Modules* modules = modulesOf(realm)) - modules->noteImporterOfFetch(module, importer); -} - void willFetchAfterTick(JSGlobalObject* realm, ModuleID module) { if (Modules* modules = modulesOf(realm)) From 61bfe89b3e1a9c7e74510d22f81caf072d0db74f Mon Sep 17 00:00:00 2001 From: Jarred Sumner Date: Mon, 16 Nov 2026 16:39:44 -0800 Subject: [PATCH 18/19] Revert "AOT test runs: a package that a preload has run takes the mock that a hook laid" Reverts c731074b15bdd7e0b050ee82c074f754c3bbe9fa. --- Source/JavaScriptCore/aot/runtime/AOTTestRunMockViews.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Source/JavaScriptCore/aot/runtime/AOTTestRunMockViews.cpp b/Source/JavaScriptCore/aot/runtime/AOTTestRunMockViews.cpp index 12b7f35854b29..0e6bdf39c90ae 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTTestRunMockViews.cpp +++ b/Source/JavaScriptCore/aot/runtime/AOTTestRunMockViews.cpp @@ -926,7 +926,7 @@ bool Modules::keepsMockThatStandsWhileAnotherWaits(ModuleID mocked, ModuleID imp return false; if (waiting->value.keepsActiveMock) return true; - bool hasRunInPreload = !isOfPackage(fileOrModule) && m_loadedInPreload.get(importer.index()) && data(importer).isESModuleOfProgram() && status(importer) == ModuleStatus::Evaluated && !isEvicted(importer) && (!hasInstances(importer) || currentInstance(importer)); + bool hasRunInPreload = m_loadedInPreload.get(importer.index()) && data(importer).isESModuleOfProgram() && status(importer) == ModuleStatus::Evaluated && !isEvicted(importer) && (!hasInstances(importer) || currentInstance(importer)); bool isTestFileLoading = false; m_instance.vm->aotState().filesStartedByHost.forEachSetBit([&](size_t index) { isTestFileLoading |= status(ModuleID(index)) < ModuleStatus::Evaluated; From e7fa8cbb0ba4f09b39580d314b0b2d6f039c674d Mon Sep 17 00:00:00 2001 From: Jarred Sumner Date: Mon, 16 Nov 2026 16:39:44 -0800 Subject: [PATCH 19/19] Revert "AOT test runs: what a preload has run under its own mock keeps that mock while no test file loads" Reverts 56ec39e5fd73d3ec05f2ec894d70acdf9f419341. --- .../aot/runtime/AOTTestRunMockViews.cpp | 11 +---------- 1 file changed, 1 insertion(+), 10 deletions(-) diff --git a/Source/JavaScriptCore/aot/runtime/AOTTestRunMockViews.cpp b/Source/JavaScriptCore/aot/runtime/AOTTestRunMockViews.cpp index 0e6bdf39c90ae..c53f1dffca501 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTTestRunMockViews.cpp +++ b/Source/JavaScriptCore/aot/runtime/AOTTestRunMockViews.cpp @@ -922,16 +922,7 @@ bool Modules::keepsMockThatStandsWhileAnotherWaits(ModuleID mocked, ModuleID imp return false; auto waiting = m_pendingMockCalls.find(fileOrModule); uint32_t linked = momentLinked(importer); - if (waiting == m_pendingMockCalls.end() || !linked || linked >= waiting->value.moment) - return false; - if (waiting->value.keepsActiveMock) - return true; - bool hasRunInPreload = m_loadedInPreload.get(importer.index()) && data(importer).isESModuleOfProgram() && status(importer) == ModuleStatus::Evaluated && !isEvicted(importer) && (!hasInstances(importer) || currentInstance(importer)); - bool isTestFileLoading = false; - m_instance.vm->aotState().filesStartedByHost.forEachSetBit([&](size_t index) { - isTestFileLoading |= status(ModuleID(index)) < ModuleStatus::Evaluated; - }); - return hasRunInPreload && (waiting->value.isInPreload || !isTestFileLoading) && !hasRemovedMock(fileOrModule) && activeMock(fileOrModule) == loadedIfExists(fileOrModule)->preloadMock.get(); + return waiting != m_pendingMockCalls.end() && waiting->value.keepsActiveMock && linked && linked < waiting->value.moment; } void Modules::noteMomentMockComesInPlace(ModuleID fileOrModule, JSObject* mock, bool stoodInPlace, bool keepsEarlierMockForImporters)