fix(javascript): bound loop capture and rest-copy expansion

src/domain/javascript/javascriptSemanticMemberMutations.ts

@@ -61,6 +61,7 @@ import { createSemanticReturnedReferences } from "./javascriptSemanticReturnedRe
 import {
   semanticMutationInitializers,
   semanticBindingAtRead,
+  semanticCaptureOrderingIdentity,
   semanticScopeExitEffect,
 } from "./javascriptSemanticMutationInitializers.js";
 import { semanticCoercionOperands } from "./javascriptSemanticLanguageInvocations.js";
@@ -551,6 +552,26 @@ export function* collectSemanticMemberMutationsSteps(
     resolvedBindings.set(node, resolved ?? null);
     return resolved;
   };
+  const nodeIdentities = new WeakMap<t.Node, number>();
+  let nextNodeIdentity = 0;
+  const nodeIdentity = (node: t.Node | undefined): number | null => {
+    if (node === undefined) return null;
+    const prior = nodeIdentities.get(node);
+    if (prior !== undefined) return prior;
+    const identity = nextNodeIdentity++;
+    nodeIdentities.set(node, identity);
+    return identity;
+  };
+  const captureIdentity = ({ at, ownEnumerable }: SemanticCapturedSelection) =>
+    ownEnumerable ? at : semanticCaptureOrderingIdentity(at, parents);
+  const capturedSelectionKey = (
+    captures: readonly SemanticCapturedSelection[] | undefined,
+  ) =>
+    captures?.map((capture) => [
+      nodeIdentity(captureIdentity(capture)),
+      capture.depth,
+      capture.ownEnumerable === true,
+    ]);
   // One capture tuple recurs across every alias it reaches. Re-encoding it
   // would rebuild the same long key and force a fresh string hash per lookup.
   const captureKeys = new WeakMap<
@@ -611,12 +632,7 @@ export function* collectSemanticMemberMutationsSteps(
       reference.originAt?.end,
       reference.memberReadAt?.start,
       reference.memberReadAt?.end,
-      reference.capturedSelections?.map(({ at, depth, ownEnumerable }) => [
-        at.start,
-        at.end,
-        depth,
-        ownEnumerable,
-      ]),
+      capturedSelectionKey(reference.capturedSelections),
       reference.iterationOnly,
       reference.widenedGetterResult === true,
       reference.definiteReceiver === true,
@@ -688,16 +704,6 @@ export function* collectSemanticMemberMutationsSteps(
     const exactProjections = new Map<string, Set<string>>();
     let additionalAlternatives = 0;
     let projectionsWidened = false;
-    const nodeIdentities = new WeakMap<t.Node, number>();
-    let nextNodeIdentity = 0;
-    const nodeIdentity = (node: t.Node | undefined): number | null => {
-      if (node === undefined) return null;
-      const prior = nodeIdentities.get(node);
-      if (prior !== undefined) return prior;
-      const identity = nextNodeIdentity++;
-      nodeIdentities.set(node, identity);
-      return identity;
-    };
     const enqueue = (candidate: PendingValue): void => {
       // A capture deeper than this projection is no longer applicable. Keep
       // the canonical context before indexing or scheduling alias histories.
@@ -718,6 +724,20 @@ export function* collectSemanticMemberMutationsSteps(
         pending.push(value);
         return;
       }
+      const observablePath = observablePaths.normalize(
+        binding.bindingId,
+        value.path,
+        effect,
+      );
+      // Join unobserved suffixes within their exact prefix. Joining distinct
+      // prefixes first could invent a wildcard reaching unrelated siblings.
+      // Keep the raw path for capture, cycle and stored-source selection.
+      const unobservedPrefix =
+        observablePath === null
+          ? value.path
+          : observablePath !== value.path
+            ? observablePath.slice(0, -1)
+            : undefined;
       const context = JSON.stringify([
         binding.bindingId,
         nodeIdentity(value.originAt),
@@ -726,16 +746,11 @@ export function* collectSemanticMemberMutationsSteps(
         value.definiteReceiver,
         value.path.length,
         value.widenedGetterResult === true,
+        unobservedPrefix,
       ]);
-      const captures = value.capturedSelections?.map(
-        ({ at, depth, ownEnumerable }) => [
-          nodeIdentity(at),
-          depth,
-          ownEnumerable === true,
-        ],
-      );
-      // Capture vectors are additional precise states, but distinct captured
-      // reads keep separate may-projection joins after the budget is reached.
+      const captures = capturedSelectionKey(value.capturedSelections);
+      // Distinct selection times remain distinct; syntactic histories with
+      // the same unknown ordering in one repeating loop share a context.
       const key = JSON.stringify([context, captures]);
       if (!projectionsWidened) {
         const exact = exactProjections.get(context) ?? new Set<string>();
@@ -870,12 +885,7 @@ export function* collectSemanticMemberMutationsSteps(
         const captureSelectionIdentity = JSON.stringify([
           current.memberReadAt?.start,
           current.memberReadAt?.end,
-          current.capturedSelections?.map(({ at, depth, ownEnumerable }) => [
-            at.start,
-            at.end,
-            depth,
-            ownEnumerable,
-          ]),
+          capturedSelectionKey(current.capturedSelections),
         ]);
         // Ancestry closes repeated source identities before recursively selected
         // copy vectors grow; independent contexts remain distinct in coverage.
@@ -980,8 +990,7 @@ export function* collectSemanticMemberMutationsSteps(
               const capture = captures[captureIndex];
               if (capture === undefined) return undefined;
               return JSON.stringify([
-                capture.at.start,
-                capture.at.end,
+                nodeIdentity(captureIdentity(capture)),
                 capture.depth === index + 1 && capture.ownEnumerable === true,
               ]);
             })
@@ -2227,9 +2236,10 @@ const observableMutationPaths = (
   ): PropertyPath | null => {
     let observer = bindingNodes.get(bindingId);
     if (observer === undefined) return path;
-    if (path.some((key) => key !== null && typeof key === "object"))
-      return path;
-    if (effect === "escape") {
+    if (
+      effect === "escape" &&
+      !path.some((key) => key !== null && typeof key === "object")
+    ) {
       observer = project(observer, path);
       settle();
       const origins = observer.origins;
@@ -2244,6 +2254,9 @@ const observableMutationPaths = (
     for (let offset = 0; offset < path.length; offset++) {
       const key = path[offset];
       if (key === undefined) break;
+      // Copied-slot masks remain symbolic. An unobserved exact prefix before
+      // the mask still ends a growing path; do not skip that prefix entirely.
+      if (key !== null && typeof key === "object") break;
       observer = project(observer, [key]);
       settle();
       if ((observer.origins?.size ?? 0) === 0 && offset + 1 < path.length)

src/domain/javascript/javascriptSemanticMutationCycles.test.ts

@@ -0,0 +1,111 @@
+import { describe, expect, it } from "vitest";
+
+import { analyzeJavaScriptSemantics } from "./javascriptSemanticAnalysis.js";
+import { onlyCallable } from "./javascriptSemanticAnalysis.fixture.js";
+
+const returnedValue = (body: string, expression: string) =>
+  onlyCallable(
+    analyzeJavaScriptSemantics(
+      `export function result() { ${body} return ${expression}; }`,
+    ),
+    "result",
+  ).returnSites[0]?.value;
+
+describe("member-path cycles and captured aliases", () => {
+  const branches = Array.from(
+    { length: 16 },
+    (_, index) => `if (flag === ${index}) node = node.m${index};`,
+  ).join(" else ");
+
+  it.each(["copy[key].value = 2;", "mutate(copy[key]);"])(
+    "retains shared-child effects through rest copies: %s",
+    (effect) => {
+      const body = `
+      const seed = { mode: "initial", m15: { m15: { child: { value: 1 } } } };
+      let node = seed.m15;
+      while (node) {
+        ${branches}
+        const { ignore, ...copy } = node;
+        ${effect}
+      }
+    `;
+      expect(returnedValue(body, "seed.m15.m15.child.value")?.status).toBe(
+        "unknown",
+      );
+      expect(returnedValue(body, "seed.mode")).toEqual({
+        status: "literal",
+        value: "initial",
+      });
+    },
+  );
+
+  it.each([
+    ["while", (body: string) => `while (node) { ${body} }`],
+    ["do/while", (body: string) => `do { ${body} } while (node);`],
+    ["for", (body: string) => `for (; node; ) { ${body} }`],
+    ["for/in", (body: string) => `for (const key in { a: 1 }) { ${body} }`],
+    ["for/of", (body: string) => `for (const item of [1]) { ${body} }`],
+  ] as const)(
+    "keeps a late child effect within its siblings in %s",
+    (_kind, loop) => {
+      const body = `
+      const seed = { mode: "initial", m15: { value: 1, keep: 3 } };
+      let node = seed;
+      ${loop(`${branches} node.value = 2;`)}
+    `;
+      expect(returnedValue(body, "seed.m15.value")?.status).toBe("unknown");
+      expect(returnedValue(body, "seed.mode")).toEqual({
+        status: "literal",
+        value: "initial",
+      });
+      expect(returnedValue(body, "seed.m15.keep")).toEqual({
+        status: "literal",
+        value: 3,
+      });
+    },
+  );
+
+  it("keeps an acyclic chain of reassignments within its selected child", () => {
+    const body = `
+      const seed = { branch: { child: { value: 1 }, keep: 3 }, keep: 4 };
+      let node = seed;
+      node = node.branch;
+      node = node.child;
+      mutate(node);
+    `;
+    expect(returnedValue(body, "seed.branch.child.value")?.status).toBe(
+      "unknown",
+    );
+    expect(returnedValue(body, "seed.branch.keep")).toEqual({
+      status: "literal",
+      value: 3,
+    });
+    expect(returnedValue(body, "seed.keep")).toEqual({
+      status: "literal",
+      value: 4,
+    });
+  });
+
+  it("selects saved aliases at their capture, before or after a rebind", () => {
+    const body = `
+      const seed = { branch: { child: { value: 1 }, keep: 3 } };
+      let node = seed.branch;
+      const before = node;
+      node = node.child;
+      const after = node;
+    `;
+    expect(
+      returnedValue(`${body} mutate(after);`, "seed.branch.child.value")
+        ?.status,
+    ).toBe("unknown");
+    expect(returnedValue(`${body} mutate(after);`, "seed.branch.keep")).toEqual(
+      {
+        status: "literal",
+        value: 3,
+      },
+    );
+    expect(
+      returnedValue(`${body} mutate(before);`, "seed.branch.keep")?.status,
+    ).toBe("unknown");
+  });
+});

src/domain/javascript/javascriptSemanticMutationInitializers.ts

@@ -26,7 +26,7 @@ interface StatementPosition {
 
 interface BindingReadPosition {
   readonly position: StatementPosition | null;
-  readonly repeating: boolean;
+  readonly repeatingLoop: t.Loop | undefined;
 }
 
 interface ExpressionSiblings {
@@ -545,7 +545,7 @@ export const semanticDefiniteEffectPrecedesReference = (
 ): boolean => {
   const before = directMutationPosition(effect, parents);
   const after = bindingReadPosition(reference, parents);
-  if (before === null || after.position === null || after.repeating)
+  if (before === null || after.position === null || after.repeatingLoop)
     return false;
   if (positionPrecedes(before, after.position)) return true;
   return (
@@ -701,7 +701,7 @@ const bindingReadPosition = (
     path.push(current);
     const parent = parents.get(current);
     if (t.isLoop(parent)) {
-      result = { position: null, repeating: true };
+      result = { position: null, repeatingLoop: parent };
       break;
     }
     if (
@@ -709,7 +709,7 @@ const bindingReadPosition = (
       (t.isFunction(parent) && !semanticComputedMethodKey(parent, current)) ||
       delayedInstanceFieldValue(parent, current)
     ) {
-      result = { position: null, repeating: false };
+      result = { position: null, repeatingLoop: undefined };
       break;
     }
     current = parent;
@@ -736,6 +736,33 @@ const bindingReadPosition = (
   return result;
 };
 
+/** Repeated member reads share unknown ordering, while retaining their source sites. */
+export const semanticCaptureOrderingIdentity = (
+  capture: t.Node,
+  parents: WeakMap<t.Node, t.Node>,
+): t.Node => {
+  // Calls can have a distinct invocation effect at their own selection site.
+  if (!t.isMemberExpression(capture) && !t.isOptionalMemberExpression(capture))
+    return capture;
+  const loop = bindingReadPosition(capture, parents).repeatingLoop;
+  if (loop === undefined) return capture;
+  let child: t.Node = capture;
+  for (
+    let parent = parents.get(child);
+    parent !== undefined && parent !== loop;
+    parent = parents.get(child)
+  )
+    child = parent;
+  // These inputs run once, before the repeating portion of the loop.
+  if (
+    (t.isForStatement(loop) && child === loop.init) ||
+    ((t.isForInStatement(loop) || t.isForOfStatement(loop)) &&
+      child === loop.right)
+  )
+    return capture;
+  return loop;
+};
+
 /** Select a local alias at its read, before any later straight-line reassignment. */
 type SemanticBindingRead = {
   readonly status: "ordered" | "unresolved";
@@ -811,7 +838,7 @@ export const semanticBindingAtRead = (
         ? null
         : initializerPosition(reference, parents, true)
       : initializerPosition(initializer, parents);
-  const { position, repeating } = bindingReadPosition(read, parents);
+  const { position, repeatingLoop } = bindingReadPosition(read, parents);
   // Coverage and latest-value selection are independent. A preceding write
   // can cover entry even when another write's order remains unknown.
   const hasDefiniteInitializer =
@@ -832,7 +859,7 @@ export const semanticBindingAtRead = (
       );
     });
   if (
-    !repeating &&
+    !repeatingLoop &&
     origin !== undefined &&
     binding.initializers.length + binding.referenceInitializers.length === 1 &&
     sourcePosition !== null &&
@@ -845,7 +872,7 @@ export const semanticBindingAtRead = (
       hasDefiniteInitializer,
     };
   const uncertainOrder =
-    repeating ||
+    repeatingLoop ||
     sourcePosition === null ||
     position === null ||
     sourcePosition.body !== position.body;