diff --git a/src/domain/javascript/javascriptSemanticReadPresence.ts b/src/domain/javascript/javascriptSemanticReadPresence.ts index cf6329b2e8..be6f1aba56 100644 --- a/src/domain/javascript/javascriptSemanticReadPresence.ts +++ b/src/domain/javascript/javascriptSemanticReadPresence.ts @@ -10,7 +10,8 @@ import { } from "./javascriptSemanticEffectLog.js"; import { semanticBindingPrecedesCapture } from "./javascriptSemanticMutationInitializers.js"; import { semanticArrayIndex } from "./javascriptSemanticPropertyPaths.js"; -import { semanticNativeArrayIterationValueAt } from "./javascriptSemanticReferenceSources.js"; +import { semanticKnownArrayIteration } from "./javascriptSemanticReferenceSources.js"; +import { evaluateSemanticExpression } from "./javascriptSemanticValues.js"; import type { JavaScriptSemanticAnalysisState } from "./javascriptSemanticState.js"; /** Prove a direct data slot in its source at the time of the read. */ @@ -44,8 +45,17 @@ export const createSemanticReadPresenceQuery = ( const value = unwrapJavaScriptExpression(initializer.node).node; if (source === "array-iteration") { if (!t.isArrayExpression(value)) return undefined; - const array = semanticNativeArrayIterationValueAt(capture, state); - if (array === undefined || array.unknownItems) return undefined; + const array = evaluateSemanticExpression( + capture, + state, + capture, + "query", + ); + if ( + !semanticKnownArrayIteration(array, state, capture) || + array.unknownItems + ) + return undefined; return (path: readonly string[]): boolean => { const [key] = path; if (key === undefined || path.length !== 1) return false; diff --git a/src/domain/javascript/javascriptSemanticReferenceSources.ts b/src/domain/javascript/javascriptSemanticReferenceSources.ts index 8181fb9cc0..3dc73d07f2 100644 --- a/src/domain/javascript/javascriptSemanticReferenceSources.ts +++ b/src/domain/javascript/javascriptSemanticReferenceSources.ts @@ -53,23 +53,16 @@ export const semanticKnownArrayIteration = ( !ambientPathMayObserveAt(state, read, arrayIteratorNextPath, "contents") && value.items.every((item) => semanticArrayIndex(item.name) !== null); -/** - * Return the array that admits native iteration at this read. A plain array's - * numeric properties are the values consumed by its native iterator. - */ -export const semanticNativeArrayIterationValueAt = ( - node: t.Node, - state: JavaScriptSemanticAnalysisState, -) => { - const value = evaluateSemanticExpression(node, state, node); - return semanticKnownArrayIteration(value, state, node) ? value : undefined; -}; - /** Invocation spreads use the same native-iteration proof at their source read. */ export const semanticKnownArrayIterationAt = ( node: t.Node, state: JavaScriptSemanticAnalysisState, -): boolean => semanticNativeArrayIterationValueAt(node, state) !== undefined; +): boolean => + semanticKnownArrayIteration( + evaluateSemanticExpression(node, state, node), + state, + node, + ); /** Numeric destructuring projections do not select slots of custom iterators. */ export const semanticReferenceIterationUnknown = ( diff --git a/src/domain/javascript/javascriptSemanticValues.memo.test.ts b/src/domain/javascript/javascriptSemanticValues.memo.test.ts index d2670bd1f8..abd21c61d7 100644 --- a/src/domain/javascript/javascriptSemanticValues.memo.test.ts +++ b/src/domain/javascript/javascriptSemanticValues.memo.test.ts @@ -1,6 +1,14 @@ import { expect, it, vi } from "vitest"; -import { analyzeJavaScriptSemantics } from "./javascriptSemanticAnalysis.js"; +import { + analyzeJavaScriptSemantics, + indexJavaScriptBindingsWithReceiversSteps, +} from "./javascriptSemanticAnalysis.js"; +import { collectJavaScriptSemanticObjects } from "./javascriptSemanticObjects.js"; +import { + completeSemanticSteps, + traverseJavaScriptAst, +} from "./javascriptSemanticTraversal.js"; import { indexJavaScriptBindingsSteps } from "../../../tests/fixtures/javascriptSemanticIndex.js"; import { SemanticDependencyProofs } from "./javascriptSemanticDependencies.js"; import { JAVASCRIPT_SEMANTIC_PRECISION_DEFAULTS } from "./javascriptSemanticPrecision.js"; @@ -8,6 +16,7 @@ import type { JavaScriptSemanticValue } from "./javascriptSemanticValueTypes.js" import { clearSemanticValueCaches, evaluateSemanticBinding, + evaluateSemanticExpression, evaluateSemanticProvenance, } from "./javascriptSemanticValues.js"; import { parseJavaScriptSource } from "./javascriptSourceParser.js"; @@ -495,3 +504,98 @@ it("releases query union ownership when state-owned values are invalidated", () spy.mockRestore(); } }); + +it.each([false, true])( + "keeps array read-presence snapshots query-owned (prewarmed: %s)", + (prewarmed) => { + const reads = 16; + const items = Array.from({ length: 128 }, (_, index) => index).join(","); + const parsed = parseJavaScriptSource( + `const config=[${items}]; let selected;${"[selected]=config;".repeat(reads)} config[0]=999;`, + "array-presence.js", + ); + if (parsed === null) throw new Error("Expected parsed source"); + const index = completeSemanticSteps( + indexJavaScriptBindingsWithReceiversSteps(parsed.program), + ); + completeSemanticSteps(index.indexMemberMutationFactsSteps()); + const state = index.bindings; + const binding = [...state.bindingsById.values()].find( + ({ name }) => name === "config", + ); + if (binding === undefined) throw new Error("Missing source binding"); + + // Track aggregate values only in snapshots owned by the analysis state. + const stateCaptures = new WeakSet(); + const stateSnapshots = new WeakSet(); + let aggregateAccesses = 0; + const observeOwner = (owner: object, key: unknown, value: unknown) => { + if (key === state && value instanceof WeakMap) stateCaptures.add(value); + if (stateCaptures.has(owner) && value instanceof Map) + stateSnapshots.add(value); + }; + const observeAggregate = (owner: object, key: unknown, value: unknown) => { + if ( + stateSnapshots.has(owner) && + key === binding.bindingId && + value !== null && + typeof value === "object" && + "status" in value && + value.status === "array" + ) + aggregateAccesses += 1; + }; + const weakGet = WeakMap.prototype.get; + const weakSet = WeakMap.prototype.set; + const mapGet = Map.prototype.get; + const mapSet = Map.prototype.set; + try { + WeakMap.prototype.get = function (key) { + const value = weakGet.call(this, key); + observeOwner(this, key, value); + return value; + }; + WeakMap.prototype.set = function (key, value) { + observeOwner(this, key, value); + return weakSet.call(this, key, value); + }; + Map.prototype.get = function (key) { + const value = mapGet.call(this, key); + observeAggregate(this, key, value); + return value; + }; + Map.prototype.set = function (key, value) { + observeAggregate(this, key, value); + return mapSet.call(this, key, value); + }; + if (prewarmed) { + traverseJavaScriptAst(parsed.program, { + enter: (node) => { + if ( + node.type === "AssignmentExpression" && + node.left.type === "ArrayPattern" + ) + evaluateSemanticExpression(node.right, state, node.right); + }, + }); + expect(aggregateAccesses).toBeGreaterThan(0); + aggregateAccesses = 0; + } + const operations = collectJavaScriptSemanticObjects( + parsed.program, + state, + [], + ).filter(({ kind }) => kind === "destructure"); + expect(operations).toHaveLength(reads); + expect( + operations.every(({ sourcePresence }) => sourcePresence === "present"), + ).toBe(true); + expect(aggregateAccesses).toBe(0); + } finally { + WeakMap.prototype.get = weakGet; + WeakMap.prototype.set = weakSet; + Map.prototype.get = mapGet; + Map.prototype.set = mapSet; + } + }, +); diff --git a/src/domain/javascript/javascriptSemanticValues.ts b/src/domain/javascript/javascriptSemanticValues.ts index 37a3cafc4e..cd65818f69 100644 --- a/src/domain/javascript/javascriptSemanticValues.ts +++ b/src/domain/javascript/javascriptSemanticValues.ts @@ -95,8 +95,15 @@ type ReadSnapshotValues = WeakMap< Map> >; +type CapturedBindingValues = WeakMap< + t.Node, + Map +>; + /** Read/provenance memos live for one query; whole values follow state effects. */ interface EvaluationMemo { + /** Capture snapshots scoped to this evaluation instead of the source state. */ + readonly capturedBindings?: CapturedBindingValues; snapshotValues?: ReadSnapshotValues; capturedSnapshotValues?: WeakMap; readonly provenance: Map< @@ -116,6 +123,7 @@ const dependencyProofsByState = new WeakMap< const createEvaluationMemo = ( state: JavaScriptSemanticAnalysisState, + capturedBindings?: CapturedBindingValues, ): EvaluationMemo => { let dependencies = dependencyProofsByState.get(state); if (dependencies === undefined) { @@ -125,6 +133,7 @@ const createEvaluationMemo = ( dependencyProofsByState.set(state, dependencies); } return { + ...(capturedBindings === undefined ? {} : { capturedBindings }), provenance: new Map(), dependencyFrames: [], dependencies: dependencies.forQuery(), @@ -178,7 +187,7 @@ const primitiveExpressionValuesByState = new WeakMap< const capturedBindingValuesByState = new WeakMap< JavaScriptSemanticAnalysisState, - WeakMap> + CapturedBindingValues >(); /** Discard every state-owned value derived before the effects boundary changed. */ @@ -244,6 +253,7 @@ export const evaluateSemanticExpression = ( node: t.Node, state: JavaScriptSemanticAnalysisState, capturePoint?: t.Node, + captureScope: "state" | "query" = "state", ): JavaScriptSemanticValue => { const context: EvaluationContext = { state, @@ -251,7 +261,10 @@ export const evaluateSemanticExpression = ( expressionDepth: 0, primitiveBindingValues: primitiveBindingValuesFor(state), dependence: { lowest: CALLER_INDEPENDENT }, - memo: createEvaluationMemo(state), + memo: createEvaluationMemo( + state, + captureScope === "query" ? new WeakMap() : undefined, + ), }; return capturePoint === undefined ? evaluateCapturedExpression(node, context) @@ -1458,7 +1471,9 @@ const captureContextAt = ( semanticCapturePosition(node, context.state.parentsByNode) === null ) return undefined; - let captures = capturedBindingValuesByState.get(context.state); + let captures = + context.memo.capturedBindings ?? + capturedBindingValuesByState.get(context.state); if (captures === undefined) { captures = new WeakMap(); capturedBindingValuesByState.set(context.state, captures);