diff --git a/src/application/javascript/JavaScriptSemanticGraphDestructuring.test.ts b/src/application/javascript/JavaScriptSemanticGraphDestructuring.test.ts index 4fd7d7bf06..4f6bc68ad1 100644 --- a/src/application/javascript/JavaScriptSemanticGraphDestructuring.test.ts +++ b/src/application/javascript/JavaScriptSemanticGraphDestructuring.test.ts @@ -2705,6 +2705,78 @@ it.each([ ["1"], "resolved", ], + [ + "let target before an initializer-free declaration", + 'let selected;const xs=[1,"one"];[fixed,selected]=xs;let fixed;', + ["1"], + "candidate", + ], + [ + "let target declared by a later declarator in the same statement", + 'let selected;const xs=[1,"one"];let scratch=([fixed,selected]=xs),fixed;', + ["1"], + "candidate", + ], + [ + "let target in its own initializer", + 'let selected;const xs=[1,"one"];let fixed=flag?([fixed,selected]=xs):0;', + ["1"], + "candidate", + ], + [ + "let target in its own destructuring RHS", + 'let selected;const xs=[1,"one"];let [fixed]=([fixed,selected]=xs,[0]);', + ["1"], + "candidate", + ], + [ + "let target initialized by an earlier declarator", + 'let selected;const xs=[1,"one"];let fixed,scratch=([fixed,selected]=xs);', + ["1"], + "resolved", + ], + [ + "let target already initialized inside its binding pattern", + 'let selected;const xs=[1,"one"];let [fixed,scratch=([fixed,selected]=xs)]=[0];', + ["1"], + "resolved", + ], + [ + "deferred initializer callable runs after its let initializes", + 'let fixed=()=>{let selected;const xs=[1,"one"];[fixed,selected]=xs;};fixed();', + ["1"], + "resolved", + ], + [ + "let target before an initialized block declaration", + 'let selected;{const obj={fixed:1,mode:"one"};({fixed,mode:selected}=obj);let fixed=0;}', + ["mode"], + "candidate", + ], + [ + "let target before the declaration on each loop entry", + 'let selected;while(next()){const xs=[1,"one"];[fixed,selected]=xs;let fixed;}', + ["1"], + "candidate", + ], + [ + "read before an uninitialized target", + "let selected;let later;const xs=[1,2,3];[selected,fixed,later]=xs;let fixed;", + ["0"], + "resolved", + ], + [ + "shadowed later let and initialized inner assignment target", + 'let selected;{let fixed;const xs=[1,"one"];[fixed,selected]=xs;}let fixed;', + ["1"], + "resolved", + ], + [ + "deferred callable runs after initializing the outer let", + 'let selected;function read(){const xs=[1,"one"];[fixed,selected]=xs;}let fixed;read();', + ["1"], + "resolved", + ], [ "immutable lexical declaration", 'const xs=[1,"one"];const [fixed,selected]=xs;xs[1]="later";', diff --git a/src/domain/javascript/javascriptSemanticAnalysis.ts b/src/domain/javascript/javascriptSemanticAnalysis.ts index b2315b7855..6a34761692 100644 --- a/src/domain/javascript/javascriptSemanticAnalysis.ts +++ b/src/domain/javascript/javascriptSemanticAnalysis.ts @@ -155,6 +155,7 @@ interface BindPatternInput { readonly state: JavaScriptSemanticAnalysisState; readonly mutable: boolean; readonly declarationKind?: "var" | "let" | "const" | "using" | "await using"; + readonly letDeclarator?: t.VariableDeclarator; readonly kind?: JavaScriptSemanticDefinition["kind"]; readonly projection?: readonly (string | number | null)[]; readonly referenceOnly?: boolean; @@ -187,6 +188,7 @@ interface AddBindingInput { readonly kind: JavaScriptSemanticDefinition["kind"]; readonly mutable: boolean; readonly declarationKind?: "var" | "let" | "const" | "using" | "await using"; + readonly letDeclarator?: t.VariableDeclarator; readonly definitionNode: t.Node; readonly initializer: t.Node | null; readonly directOrigin?: JavaScriptModuleOrigin; @@ -1768,6 +1770,9 @@ const bindInnerDeclaration = ( ...(parent !== null && t.isVariableDeclaration(parent) ? { declarationKind: parent.kind } : {}), + ...(t.isVariableDeclaration(parent, { kind: "let" }) + ? { letDeclarator: node } + : {}), }); else if (t.isClass(node) && t.isIdentifier(node.id)) addBinding({ @@ -2260,6 +2265,9 @@ const bindPattern = (input: BindPatternInput): void => { kind, mutable, ...(declarationKind === undefined ? {} : { declarationKind }), + ...(input.letDeclarator === undefined + ? {} + : { letDeclarator: input.letDeclarator }), definitionNode: pattern, initializer, projection, @@ -2410,6 +2418,12 @@ const addBinding = (input: AddBindingInput): void => { binding.mutable ||= mutable; if (declarationKind !== undefined) binding.declarationKinds.add(declarationKind); + if (input.letDeclarator !== undefined) + binding.letDeclarator = + binding.letDeclarator === undefined || + binding.letDeclarator === input.letDeclarator + ? input.letDeclarator + : null; binding.definitions.push({ kind, location: range(definitionNode) }); if (initializer !== null) binding.initializers.push({ diff --git a/src/domain/javascript/javascriptSemanticMutationInitializers.ts b/src/domain/javascript/javascriptSemanticMutationInitializers.ts index a3841a7b34..a5d550c0a5 100644 --- a/src/domain/javascript/javascriptSemanticMutationInitializers.ts +++ b/src/domain/javascript/javascriptSemanticMutationInitializers.ts @@ -6,6 +6,7 @@ import { import { isTypeOnlyExportDeclaration } from "./javascriptModuleDeclaration.js"; import { javaScriptRuntimeContext, + javaScriptStrictnessAt, javaScriptThisOwner, } from "./javascriptSourceParser.js"; import { semanticPropertyReadSources } from "./javascriptSemanticIterationSources.js"; @@ -48,6 +49,7 @@ interface StatementPosition { interface BindingReadPosition { readonly position: StatementPosition | null; readonly repeatingLoop: t.Loop | undefined; + readonly initializer?: t.VariableDeclarator; } interface ExpressionSiblings { @@ -76,10 +78,7 @@ interface InitializerPositionCache { readonly read: WeakMap; readonly enclosingFunction: WeakMap; readonly functionPosition: WeakMap; - readonly statementIndices: WeakMap< - readonly t.Statement[], - ReadonlyMap - >; + readonly listIndices: WeakMap>; readonly moduleFunctionReads: WeakMap< readonly t.Statement[], { @@ -117,7 +116,7 @@ const initializerPositionCache = ( read: new WeakMap(), enclosingFunction: new WeakMap(), functionPosition: new WeakMap(), - statementIndices: new WeakMap(), + listIndices: new WeakMap(), moduleFunctionReads: new WeakMap(), evaluationChildren: new WeakMap(), expressionAncestry: undefined, @@ -126,6 +125,21 @@ const initializerPositionCache = ( return created; }; +const siblingIndex = ( + node: t.Node, + siblings: readonly t.Node[], + parents: WeakMap, +): number => { + if (siblings.length <= 1) return siblings[0] === node ? 0 : -1; + const cache = initializerPositionCache(parents).listIndices; + let indices = cache.get(siblings); + if (indices === undefined) { + indices = new Map(siblings.map((entry, index) => [entry, index])); + cache.set(siblings, indices); + } + return indices.get(node) ?? -1; +}; + const statementPosition = ( statement: t.Statement, parents: WeakMap, @@ -140,13 +154,7 @@ const statementPosition = ( : statement; const parent = parents.get(enclosing); if (!t.isProgram(parent) && !t.isBlockStatement(parent)) return null; - const cache = initializerPositionCache(parents).statementIndices; - let positions = cache.get(parent.body); - if (positions === undefined) { - positions = new Map(parent.body.map((entry, index) => [entry, index])); - cache.set(parent.body, positions); - } - const index = positions.get(enclosing) ?? -1; + const index = siblingIndex(enclosing, parent.body, parents); return index < 0 ? null : { @@ -154,7 +162,7 @@ const statementPosition = ( index, declaratorIndex: t.isVariableDeclaration(statement) && declarator !== undefined - ? statement.declarations.indexOf(declarator) + ? siblingIndex(declarator, statement.declarations, parents) : -1, }; }; @@ -929,23 +937,58 @@ const bindingReadPosition = ( if (node === undefined) continue; const parent = parents.get(node); let position: StatementPosition | null = null; + let initializer: t.VariableDeclarator | undefined; if (t.isVariableDeclarator(parent)) { const declaration = parents.get(parent); if (t.isVariableDeclaration(declaration)) position = statementPosition(declaration, parents, parent); + if (node === parent.init) initializer = parent; } else if ( t.isStatement(parent) && !t.isLoop(parent) && !t.isFunction(parent) ) position = statementPosition(parent, parents); - if (position !== null && position !== result.position) - result = { ...result, position }; + if (position !== null) + result = { + repeatingLoop: result.repeatingLoop, + position, + ...(initializer === undefined ? {} : { initializer }), + }; cache.set(node, result); } return result; }; +/** Check whether declaration rules or known execution order can reject a write. */ +export const semanticBindingMayRejectAssignmentAt = ( + binding: JavaScriptSemanticBindingState, + access: t.Node, + { parentsByNode }: JavaScriptSemanticAnalysisState, +): boolean => { + const { declarationKinds } = binding; + if ( + binding.runtimeImport || + declarationKinds.has("const") || + declarationKinds.has("using") || + declarationKinds.has("await using") || + binding.selfNameAssignment === "always-throws" || + (binding.selfNameAssignment === "throws-in-strict-mode" && + javaScriptStrictnessAt(access, parentsByNode) !== "sloppy") + ) + return true; + const declarator = binding.letDeclarator; + if (declarator == null || declarationKinds.size !== 1) return false; + const declaration = parentsByNode.get(declarator); + if (!t.isVariableDeclaration(declaration)) return false; + const { position, initializer } = bindingReadPosition(access, parentsByNode); + const end = statementPosition(declaration, parentsByNode, declarator); + if (position === null || end === null) return false; + // The RHS runs before any binding is initialized. Defaults inside the + // binding pattern itself can run after earlier targets are initialized. + return initializer === declarator || positionPrecedes(position, end); +}; + /** Repeated member reads share unknown ordering, while retaining their source sites. */ export const semanticCaptureOrderingIdentity = ( capture: t.Node, diff --git a/src/domain/javascript/javascriptSemanticObjects.ts b/src/domain/javascript/javascriptSemanticObjects.ts index 41594e1c45..1813d12372 100644 --- a/src/domain/javascript/javascriptSemanticObjects.ts +++ b/src/domain/javascript/javascriptSemanticObjects.ts @@ -5,6 +5,7 @@ import type { JavaScriptSemanticObjectOperation, } from "./javascriptSemanticIr.js"; import { createSemanticCallableIdStack } from "./javascriptSemanticCallableStack.js"; +import { semanticBindingMayRejectAssignmentAt } from "./javascriptSemanticMutationInitializers.js"; import { semanticStaticPropertyKey, semanticWriteSiteReadsFirst, @@ -14,7 +15,6 @@ import { } from "./javascriptAstValues.js"; import { resolveSemanticBindingState, - semanticBindingMayRejectAssignment, type JavaScriptSemanticAnalysisState, } from "./javascriptSemanticState.js"; import { traverseJavaScriptValueAst } from "./javascriptSemanticTraversal.js"; @@ -311,7 +311,7 @@ const collectDestructuring = ( assignmentBlocked ||= assignment && targetBinding !== undefined && - semanticBindingMayRejectAssignment(targetBinding, owner, state); + semanticBindingMayRejectAssignmentAt(targetBinding, owner, state); if (targetBinding === undefined || assignmentBlocked) ownSlot = undefined; if (path === null) continue; addObjectOperation( diff --git a/src/domain/javascript/javascriptSemanticState.ts b/src/domain/javascript/javascriptSemanticState.ts index 443a247423..1768ef52a0 100644 --- a/src/domain/javascript/javascriptSemanticState.ts +++ b/src/domain/javascript/javascriptSemanticState.ts @@ -8,7 +8,6 @@ import { unwrapJavaScriptExpression, } from "./javascriptAstValues.js"; import type { SemanticIterationSource } from "./javascriptSemanticIterationFacts.js"; -import { javaScriptStrictnessAt } from "./javascriptSourceParser.js"; import type { JavaScriptSemanticPropertyPath, @@ -96,6 +95,8 @@ export interface JavaScriptSemanticBindingState { kind: JavaScriptSemanticDefinition["kind"]; /** Source declaration form retained internally for CommonJS wrapper bindings. */ declarationKinds: Set<"var" | "let" | "const" | "using" | "await using">; + /** Declaration site even when a let binding has no initializer. */ + letDeclarator?: t.VariableDeclarator | null; mutable: boolean; readonly memberWrites: JavaScriptSemanticMemberEffect[]; readonly escapedPaths: JavaScriptSemanticMemberEffect[]; @@ -109,20 +110,6 @@ export interface JavaScriptSemanticBindingState { selfNameAssignment?: "always-throws" | "throws-in-strict-mode"; } -/** Classify rejection independently from whether a syntactic write was recorded. */ -export const semanticBindingMayRejectAssignment = ( - binding: JavaScriptSemanticBindingState, - site: t.Node, - { parentsByNode }: JavaScriptSemanticAnalysisState, -): boolean => - binding.runtimeImport || - binding.declarationKinds.has("const") || - binding.declarationKinds.has("using") || - binding.declarationKinds.has("await using") || - binding.selfNameAssignment === "always-throws" || - (binding.selfNameAssignment === "throws-in-strict-mode" && - javaScriptStrictnessAt(site, parentsByNode) !== "sloppy"); - /** Mutable lexical-scope state used only during AST recovery. */ export interface JavaScriptSemanticScopeState { readonly scopeId: string; diff --git a/tests/boundary/cli/javascriptDestructuringEvidence.test.ts b/tests/boundary/cli/javascriptDestructuringEvidence.test.ts index e09da005ea..71f4f57264 100644 --- a/tests/boundary/cli/javascriptDestructuringEvidence.test.ts +++ b/tests/boundary/cli/javascriptDestructuringEvidence.test.ts @@ -74,6 +74,20 @@ const classNameTargetSource = ` } `; +const uninitializedTargetSource = ` + let beforeUninitialized, afterUninitialized; + const cells = ["before", 1, "unreached"]; + [beforeUninitialized, pending, afterUninitialized] = cells; + let pending; +`; + +const declaratorOrderSource = ` + let initializedEarlier, uninitializedLater; + const cells = [1, "paired"]; + let earlier, readEarlier = ([earlier, initializedEarlier] = cells); + let readLater = ([later, uninitializedLater] = cells), later; +`; + const expectedDependencies = [ ["declared", ["a"]], ["a", ["a"]], @@ -86,6 +100,10 @@ const expectedDependencies = [ ["beforeClassName", ["0"]], ["afterClassName", ["2"], "candidate"], ["afterOuterClass", ["1"]], + ["beforeUninitialized", ["0"]], + ["afterUninitialized", ["2"], "candidate"], + ["initializedEarlier", ["1"]], + ["uninitializedLater", ["1"], "candidate"], ["arrayAssigned", ["0"]], ["elided", ["1"]], ["projected", ["items", "0"]], @@ -119,6 +137,10 @@ const tracedBindings = [ "beforeClassName", "afterClassName", "afterOuterClass", + "beforeUninitialized", + "afterUninitialized", + "initializedEarlier", + "uninitializedLater", "arrayAssigned", "elided", "projected", @@ -212,6 +234,8 @@ cliTest( ["first-default.js", firstDefaultSource], ["immutable-target.js", immutableTargetSource], ["class-name-target.js", classNameTargetSource], + ["uninitialized-target.js", uninitializedTargetSource], + ["declarator-order.js", declaratorOrderSource], ] as const) await writeFile(join(root, path), source); const output = await cli.run({