fix(javascript): bound member-mutation paths through reassignment loops
Fixes #1401. Refs #1065. Preserve exact member facts and equal-depth write effects while bounding the observed reassignment-loop expansion. Validated with the JavaScript semantic/application suite, focused alias regressions, full static checks, real compiled CLI and SDK MCP Notion workflows, and all 20 checks on the final PR head. Co-Authored-By: Marnix Pluim <286664873+marnixpluim@users.noreply.github.com> Co-Authored-By: N0zoM1z0 <161784452+N0zoM1z0@users.noreply.github.com> Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
co-authored by
Marnix Pluim
N0zoM1z0
Claude
parent
98022a8352
commit
28595276fa
@@ -9,6 +9,163 @@ const resultValue = (body: string) =>
|
||||
"result",
|
||||
).returnSites[0]?.value;
|
||||
|
||||
describe("bounded member path propagation", () => {
|
||||
it("bounds cyclic member paths with no observed container origin", () => {
|
||||
const branches = Array.from(
|
||||
{ length: 16 },
|
||||
(_, index) => `if (flag === ${index}) node = node.m${index};`,
|
||||
).join(" else ");
|
||||
const start = performance.now();
|
||||
const callable = onlyCallable(
|
||||
analyzeJavaScriptSemantics(
|
||||
`export function result(seed) { let node=seed; while(node) { ${branches} use(node.state); } return seed.keep; }`,
|
||||
),
|
||||
"result",
|
||||
);
|
||||
expect(callable.returnSites[0]?.value.status).toBe("unknown");
|
||||
expect(performance.now() - start).toBeLessThan(2000);
|
||||
}, 30000);
|
||||
|
||||
it("preserves Array prototype effects through an otherwise unknown alias", () => {
|
||||
expect(
|
||||
resultValue(
|
||||
"const values=[1]; const prototype=Array.prototype; prototype[Symbol.iterator]=custom; for(const item of values) { mutate(item); } return values[0];",
|
||||
)?.status,
|
||||
).toBe("unknown");
|
||||
});
|
||||
|
||||
it("bounds loops derived from a scalar member while preserving sibling facts", () => {
|
||||
const branches = Array.from(
|
||||
{ length: 16 },
|
||||
(_, index) => `if (flag === ${index}) node = node.m${index};`,
|
||||
).join(" else ");
|
||||
const start = performance.now();
|
||||
expect(
|
||||
resultValue(
|
||||
`const source={child:1,keep:{value:3}}; let node=source.child; while(node) { ${branches} use(node.state); } return source.keep.value;`,
|
||||
),
|
||||
).toEqual({ status: "literal", value: 3 });
|
||||
expect(performance.now() - start).toBeLessThan(2000);
|
||||
}, 30000);
|
||||
|
||||
it.each([
|
||||
["child:external,", "child", "present"],
|
||||
["", "missing", "unknown-coverage"],
|
||||
])(
|
||||
"retains slot presence below an unobserved container: %s",
|
||||
(property, name, presence) => {
|
||||
expect(
|
||||
resultValue(
|
||||
`const source={${property}keep:3}; const alias=source.${name}; alias.deep.value=2; return source;`,
|
||||
),
|
||||
).toMatchObject({
|
||||
status: "object",
|
||||
properties: expect.arrayContaining([
|
||||
{
|
||||
name,
|
||||
presence,
|
||||
value: {
|
||||
status: "unknown",
|
||||
reason: "This property may have been mutated.",
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "keep",
|
||||
presence: "present",
|
||||
value: { status: "literal", value: 3 },
|
||||
},
|
||||
]),
|
||||
});
|
||||
},
|
||||
);
|
||||
|
||||
it.each([
|
||||
["use(node);", "m0.value", "unknown"],
|
||||
["node.value = 2;", "m0.value", "unknown"],
|
||||
["node.value = 2;", "mode", "literal"],
|
||||
])(
|
||||
"bounds a loop that reassigns one reference through many members: %s seed.%s",
|
||||
(effect, read, status) => {
|
||||
const branches = Array.from(
|
||||
{ length: 9 },
|
||||
(_, index) => `if (flag === ${index}) node = node.m${index};`,
|
||||
).join(" else ");
|
||||
const start = performance.now();
|
||||
const value = resultValue(
|
||||
`const seed = { mode: "initial", m0: { value: 1 } }; let node = seed; while (node) { ${branches} ${effect} } return seed.${read};`,
|
||||
);
|
||||
expect(performance.now() - start).toBeLessThan(2000);
|
||||
expect(value?.status).toBe(status);
|
||||
},
|
||||
30000,
|
||||
);
|
||||
|
||||
it.each([
|
||||
["const alias = flag ? owner.child : owner; alias.value = 2;", "value"],
|
||||
["const alias = flag ? owner : owner.child; alias.value = 2;", "value"],
|
||||
["const alias = flag ? owner.child : owner; alias[key] = 2;", "value"],
|
||||
[
|
||||
"const alias = flag ? owner.child : owner; alias.child = 2;",
|
||||
"child.value",
|
||||
],
|
||||
[
|
||||
"let alias = owner; let i = 0; while (i++ < 1) { alias = flag ? alias.child : alias; alias.value = 2; }",
|
||||
"value",
|
||||
],
|
||||
])(
|
||||
"keeps a write that reaches a child through a longer path: %s",
|
||||
(body, read) => {
|
||||
expect(
|
||||
resultValue(
|
||||
`const shared = { value: 1, child: { value: 1 } }; const owner = { child: shared }; ${body} return shared.${read};`,
|
||||
)?.status,
|
||||
).toBe("unknown");
|
||||
},
|
||||
);
|
||||
|
||||
it.each([
|
||||
"mutate(source.left, source.right);",
|
||||
"const alias = flag ? source.left : source.right; mutate(alias);",
|
||||
"const copy = flag ? [source.left] : [source.right]; mutate(copy);",
|
||||
"const alias = flag ? source.left : source.right; alias.value = 2;",
|
||||
])("keeps members outside the mutated paths: %s", (body) => {
|
||||
expect(
|
||||
resultValue(
|
||||
`const source = { left: { value: 1 }, right: { value: 2 }, keep: { value: 3 } }; ${body} return source.keep.value;`,
|
||||
),
|
||||
).toEqual({ status: "literal", value: 3 });
|
||||
});
|
||||
});
|
||||
|
||||
describe("distinct observable mutation paths", () => {
|
||||
it.each([
|
||||
["alias.value = 2;", "left"],
|
||||
["alias.value = 2;", "right"],
|
||||
["mutate(alias);", "left"],
|
||||
["mutate(alias);", "right"],
|
||||
])(
|
||||
"propagates both conditional paths to shared bindings: %s %s",
|
||||
(effect, target) => {
|
||||
expect(
|
||||
resultValue(
|
||||
`const left={value:1}; const right={value:2}; const source={left,right}; const alias=flag?source.left:source.right; ${effect} return ${target}.value;`,
|
||||
)?.status,
|
||||
).toBe("unknown");
|
||||
},
|
||||
);
|
||||
|
||||
it.each(["mutate(alias);", "alias.value = 2;"])(
|
||||
"preserves sibling facts below a shared prefix: %s",
|
||||
(effect) => {
|
||||
expect(
|
||||
resultValue(
|
||||
`const shared={left:{value:1},right:{value:2},keep:{value:3}}; const source={nested:shared}; const alias=flag?source.nested.left:source.nested.right; ${effect} return shared.keep.value;`,
|
||||
),
|
||||
).toEqual({ status: "literal", value: 3 });
|
||||
},
|
||||
);
|
||||
});
|
||||
|
||||
describe("reference lifetimes across calls and shallow copies", () => {
|
||||
it("bounds dynamic destructuring across shared alias branches", () => {
|
||||
const declarations = Array.from(
|
||||
|
||||
@@ -18,6 +18,7 @@ import { semanticIterationSources } from "./javascriptSemanticIterationSources.j
|
||||
import { semanticMutationInitializers } from "./javascriptSemanticMutationInitializers.js";
|
||||
import {
|
||||
semanticArrayIndex,
|
||||
SemanticPropertyPathCoverage,
|
||||
semanticPropertyPathKeyMatches,
|
||||
type JavaScriptSemanticPropertyPath,
|
||||
} from "./javascriptSemanticPropertyPaths.js";
|
||||
@@ -42,8 +43,10 @@ export const collectSemanticMemberMutations = (
|
||||
if (parent !== null) parents.set(node, parent);
|
||||
},
|
||||
});
|
||||
const normalizePath = observableMutationPaths(state);
|
||||
const recordedEffects = new Set<string>();
|
||||
const selections = new Map<string, readonly string[]>();
|
||||
const coveringPaths = new Map<string, SemanticPropertyPathCoverage>();
|
||||
let arrayIterationUnknown = false;
|
||||
const pendingReferences: {
|
||||
readonly initializer: JavaScriptSemanticBindingState["referenceInitializers"][number];
|
||||
@@ -93,8 +96,10 @@ export const collectSemanticMemberMutations = (
|
||||
originAt: t.Node | undefined = mutation,
|
||||
): void => {
|
||||
const pending = [{ node, path, bindings, originAt }];
|
||||
while (pending.length > 0) {
|
||||
const current = pending.pop();
|
||||
// Visit shallower alias traversals first so their exact prefixes suppress
|
||||
// longer loop paths before those paths enumerate every assignment order.
|
||||
for (let cursor = 0; cursor < pending.length; cursor++) {
|
||||
const current = pending[cursor];
|
||||
if (current === undefined) break;
|
||||
const expression = unwrapJavaScriptExpression(current.node).node;
|
||||
if (t.isIdentifier(expression)) {
|
||||
@@ -126,10 +131,13 @@ export const collectSemanticMemberMutations = (
|
||||
if (current.bindings.has(lifetime)) continue;
|
||||
// Union compatible copied-slot selections at each binding. Carrying every
|
||||
// combination of exclusions through branch diamonds is exponential.
|
||||
const selectorIndex = current.path.findIndex(
|
||||
// Preserve paths that can change observed slots or Array prototype
|
||||
// effects; canonicalize suffixes that cannot distinguish lattice facts.
|
||||
let path = normalizePath(binding.bindingId, current.path, effect);
|
||||
if (path === null) continue;
|
||||
const selectorIndex = path.findIndex(
|
||||
(key) => key !== null && typeof key === "object",
|
||||
);
|
||||
let path = current.path;
|
||||
const selector = path[selectorIndex];
|
||||
if (selector !== null && typeof selector === "object") {
|
||||
const selectionIdentity = JSON.stringify([
|
||||
@@ -157,6 +165,25 @@ export const collectSemanticMemberMutations = (
|
||||
index === selectorIndex ? { ...selector, excludedKeys } : key,
|
||||
);
|
||||
}
|
||||
// Keep an antichain of exact paths. Widening distinct member keys would
|
||||
// also invalidate unrelated siblings that never reach this effect.
|
||||
const pathState = JSON.stringify([
|
||||
binding.bindingId,
|
||||
effect,
|
||||
// Short writes stop at owned literal slots, whereas longer writes
|
||||
// reach shared children. Only equal-depth writes cover one another.
|
||||
effect === "write" ? path.length : null,
|
||||
mutation?.start,
|
||||
mutation?.end,
|
||||
current.originAt?.start,
|
||||
current.originAt?.end,
|
||||
]);
|
||||
let covering = coveringPaths.get(pathState);
|
||||
if (covering === undefined) {
|
||||
covering = new SemanticPropertyPathCoverage();
|
||||
coveringPaths.set(pathState, covering);
|
||||
}
|
||||
if (!covering.retain(path)) continue;
|
||||
const identity = JSON.stringify([
|
||||
binding.bindingId,
|
||||
effect,
|
||||
@@ -544,6 +571,241 @@ const referencedValues = (
|
||||
return [];
|
||||
};
|
||||
|
||||
type MutationObservableOrigin =
|
||||
| t.ObjectExpression
|
||||
| t.ArrayExpression
|
||||
| "ambient"
|
||||
| "array"
|
||||
| "array-prototype"
|
||||
| "opaque";
|
||||
|
||||
interface MutationObserverNode {
|
||||
readonly origins: Set<MutationObservableOrigin>;
|
||||
readonly sources: Set<MutationObserverNode>;
|
||||
readonly dependents: Set<MutationObserverNode>;
|
||||
readonly projections: Map<string, MutationObserverNode>;
|
||||
readonly read?: {
|
||||
readonly source: MutationObserverNode;
|
||||
readonly key: PropertyPath[number];
|
||||
};
|
||||
}
|
||||
|
||||
const observableMutationPaths = (
|
||||
state: JavaScriptSemanticAnalysisState,
|
||||
): ((
|
||||
bindingId: string,
|
||||
path: PropertyPath,
|
||||
effect: ValueEffect,
|
||||
) => PropertyPath | null) => {
|
||||
const bindingNodes = new Map<string, MutationObserverNode>();
|
||||
const expressions = new WeakMap<t.Node, MutationObserverNode>();
|
||||
const pendingExpressions: {
|
||||
readonly expression: t.Node;
|
||||
readonly observer: MutationObserverNode;
|
||||
}[] = [];
|
||||
const pending: MutationObserverNode[] = [];
|
||||
const queued = new Set<MutationObserverNode>();
|
||||
const schedule = (node: MutationObserverNode): void => {
|
||||
if (queued.has(node)) return;
|
||||
queued.add(node);
|
||||
pending.push(node);
|
||||
};
|
||||
const create = (
|
||||
read?: MutationObserverNode["read"],
|
||||
): MutationObserverNode => ({
|
||||
origins: new Set(),
|
||||
sources: new Set(),
|
||||
dependents: new Set(),
|
||||
projections: new Map(),
|
||||
...(read === undefined ? {} : { read }),
|
||||
});
|
||||
const link = (
|
||||
source: MutationObserverNode,
|
||||
target: MutationObserverNode,
|
||||
): void => {
|
||||
if (target.sources.has(source)) return;
|
||||
target.sources.add(source);
|
||||
source.dependents.add(target);
|
||||
schedule(target);
|
||||
};
|
||||
const expressionNode = (node: t.Node): MutationObserverNode => {
|
||||
const expression = unwrapJavaScriptExpression(node).node;
|
||||
const existing = expressions.get(expression);
|
||||
if (existing !== undefined) return existing;
|
||||
const observer = create();
|
||||
expressions.set(expression, observer);
|
||||
pendingExpressions.push({ expression, observer });
|
||||
return observer;
|
||||
};
|
||||
const project = (
|
||||
source: MutationObserverNode,
|
||||
path: PropertyPath,
|
||||
): MutationObserverNode => {
|
||||
let observer = source;
|
||||
for (const key of path) {
|
||||
const identity = JSON.stringify(
|
||||
key === null || typeof key === "object" ? key : String(key),
|
||||
);
|
||||
let selected = observer.projections.get(identity);
|
||||
if (selected === undefined) {
|
||||
selected = create({ source: observer, key });
|
||||
observer.projections.set(identity, selected);
|
||||
observer.dependents.add(selected);
|
||||
schedule(selected);
|
||||
}
|
||||
observer = selected;
|
||||
}
|
||||
return observer;
|
||||
};
|
||||
for (const binding of state.bindingsById.values())
|
||||
bindingNodes.set(binding.bindingId, create());
|
||||
for (const binding of state.bindingsById.values()) {
|
||||
const observer = bindingNodes.get(binding.bindingId);
|
||||
if (observer === undefined) continue;
|
||||
for (const initializer of binding.initializers)
|
||||
link(
|
||||
project(expressionNode(initializer.node), initializer.projection),
|
||||
observer,
|
||||
);
|
||||
// Preserve exact paths where copies, defaults or iteration need their
|
||||
// reference-specific projections; an opaque origin prevents pruning.
|
||||
if (binding.referenceInitializers.length > 0)
|
||||
observer.origins.add("opaque");
|
||||
for (const initializer of binding.referenceInitializers) {
|
||||
for (const source of [
|
||||
initializer,
|
||||
...(initializer.requiredSources ?? []),
|
||||
...(initializer.fallbackSources ?? []),
|
||||
])
|
||||
link(expressionNode(source.node), observer);
|
||||
}
|
||||
}
|
||||
const settle = (): void => {
|
||||
while (pendingExpressions.length > 0 || pending.length > 0) {
|
||||
while (pendingExpressions.length > 0) {
|
||||
const selected = pendingExpressions.pop();
|
||||
if (selected === undefined) break;
|
||||
const { expression, observer } = selected;
|
||||
if (t.isObjectExpression(expression) || t.isArrayExpression(expression))
|
||||
observer.origins.add(expression);
|
||||
else if (t.isIdentifier(expression)) {
|
||||
const binding = resolveSemanticBindingState(
|
||||
state,
|
||||
expression,
|
||||
expression.name,
|
||||
);
|
||||
if (binding !== undefined) {
|
||||
const origin = bindingNodes.get(binding.bindingId);
|
||||
if (origin !== undefined) link(origin, observer);
|
||||
} else if (expression.name === "Array") observer.origins.add("array");
|
||||
else if (
|
||||
["globalThis", "global", "window", "self"].includes(expression.name)
|
||||
)
|
||||
observer.origins.add("ambient");
|
||||
} else if (
|
||||
t.isMemberExpression(expression) ||
|
||||
t.isOptionalMemberExpression(expression)
|
||||
)
|
||||
link(
|
||||
project(expressionNode(expression.object), [
|
||||
semanticStaticPropertyKey(
|
||||
expression.property,
|
||||
expression.computed,
|
||||
),
|
||||
]),
|
||||
observer,
|
||||
);
|
||||
else
|
||||
for (const reference of referencedValues(expression, [], "escape"))
|
||||
link(
|
||||
project(expressionNode(reference.node), reference.path),
|
||||
observer,
|
||||
);
|
||||
schedule(observer);
|
||||
}
|
||||
const observer = pending.pop();
|
||||
if (observer === undefined) continue;
|
||||
queued.delete(observer);
|
||||
let changed = false;
|
||||
const add = (origin: MutationObservableOrigin): void => {
|
||||
if (observer.origins.has(origin)) return;
|
||||
observer.origins.add(origin);
|
||||
changed = true;
|
||||
};
|
||||
for (const source of observer.sources)
|
||||
for (const origin of source.origins) add(origin);
|
||||
if (observer.read !== undefined) {
|
||||
const { source, key } = observer.read;
|
||||
if (key === null || typeof key === "object") {
|
||||
// Dynamic keys and copied-slot masks retain their original paths.
|
||||
// Enumerating their exclusion combinations would recreate the growth
|
||||
// that the mutation collector's selection union already prevents.
|
||||
if (source.origins.size > 0) add("opaque");
|
||||
} else
|
||||
for (const origin of source.origins) {
|
||||
if (typeof origin === "string") {
|
||||
if (origin === "array-prototype" || origin === "opaque")
|
||||
add(origin);
|
||||
else if (
|
||||
origin === "ambient" &&
|
||||
semanticPropertyPathKeyMatches(key, "Array")
|
||||
)
|
||||
add("array");
|
||||
else if (
|
||||
origin === "array" &&
|
||||
semanticPropertyPathKeyMatches(key, "prototype")
|
||||
)
|
||||
add("array-prototype");
|
||||
} else {
|
||||
for (const reference of referencedValues(
|
||||
origin,
|
||||
[key],
|
||||
"escape",
|
||||
)) {
|
||||
link(
|
||||
project(expressionNode(reference.node), reference.path),
|
||||
observer,
|
||||
);
|
||||
if (reference.iterableFallbackPath !== undefined)
|
||||
link(
|
||||
project(
|
||||
expressionNode(reference.node),
|
||||
reference.iterableFallbackPath,
|
||||
),
|
||||
observer,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (changed)
|
||||
for (const dependent of observer.dependents) schedule(dependent);
|
||||
}
|
||||
};
|
||||
settle();
|
||||
return (bindingId, path, effect) => {
|
||||
let observer = bindingNodes.get(bindingId);
|
||||
if (observer === undefined) return path;
|
||||
if (path.some((key) => key !== null && typeof key === "object"))
|
||||
return path;
|
||||
if (effect === "escape") {
|
||||
observer = project(observer, path);
|
||||
settle();
|
||||
return observer.origins.size === 0 ? null : path;
|
||||
}
|
||||
if (observer.origins.size === 0) return path.length === 0 ? path : [null];
|
||||
for (let offset = 0; offset < path.length; offset++) {
|
||||
const key = path[offset];
|
||||
if (key === undefined) break;
|
||||
observer = project(observer, [key]);
|
||||
settle();
|
||||
if (observer.origins.size === 0 && offset + 1 < path.length)
|
||||
return [...path.slice(0, offset + 1), null];
|
||||
}
|
||||
return path;
|
||||
};
|
||||
};
|
||||
|
||||
const objectReferencedValues = (
|
||||
node: t.ObjectExpression,
|
||||
path: PropertyPath,
|
||||
|
||||
@@ -35,3 +35,89 @@ export const semanticPropertyPathKeyMatches = (
|
||||
const index = semanticArrayIndex(name);
|
||||
return index !== null && index >= key.startIndex;
|
||||
};
|
||||
|
||||
interface PropertyPathCoverageNode {
|
||||
terminal: boolean;
|
||||
readonly exact: Map<string, PropertyPathCoverageNode>;
|
||||
readonly selectors: Map<
|
||||
string,
|
||||
{
|
||||
readonly key: JavaScriptSemanticPropertyPath[number];
|
||||
readonly node: PropertyPathCoverageNode;
|
||||
}
|
||||
>;
|
||||
}
|
||||
|
||||
const coverageNode = (): PropertyPathCoverageNode => ({
|
||||
terminal: false,
|
||||
exact: new Map(),
|
||||
selectors: new Map(),
|
||||
});
|
||||
|
||||
/** Index exact effect prefixes without widening distinct member paths. */
|
||||
export class SemanticPropertyPathCoverage {
|
||||
readonly #root = coverageNode();
|
||||
|
||||
/** Retain a path only when no previously retained prefix covers it. */
|
||||
retain(path: JavaScriptSemanticPropertyPath): boolean {
|
||||
const pending = [{ node: this.#root, offset: 0 }];
|
||||
while (pending.length > 0) {
|
||||
const current = pending.pop();
|
||||
if (current === undefined) break;
|
||||
if (current.node.terminal) return false;
|
||||
const key = path[current.offset];
|
||||
if (key === undefined) continue;
|
||||
if (key !== null && typeof key !== "object") {
|
||||
const exact = current.node.exact.get(String(key));
|
||||
if (exact !== undefined)
|
||||
pending.push({ node: exact, offset: current.offset + 1 });
|
||||
}
|
||||
for (const selected of current.node.selectors.values()) {
|
||||
if (keyCovers(selected.key, key))
|
||||
pending.push({ node: selected.node, offset: current.offset + 1 });
|
||||
}
|
||||
}
|
||||
let node = this.#root;
|
||||
for (const key of path) {
|
||||
if (key !== null && typeof key !== "object") {
|
||||
const name = String(key);
|
||||
let child = node.exact.get(name);
|
||||
if (child === undefined) {
|
||||
child = coverageNode();
|
||||
node.exact.set(name, child);
|
||||
}
|
||||
node = child;
|
||||
} else {
|
||||
const identity = JSON.stringify(key);
|
||||
let selected = node.selectors.get(identity);
|
||||
if (selected === undefined) {
|
||||
selected = { key, node: coverageNode() };
|
||||
node.selectors.set(identity, selected);
|
||||
}
|
||||
node = selected.node;
|
||||
}
|
||||
}
|
||||
node.terminal = true;
|
||||
node.exact.clear();
|
||||
node.selectors.clear();
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
const keyCovers = (
|
||||
covering: JavaScriptSemanticPropertyPath[number],
|
||||
key: JavaScriptSemanticPropertyPath[number],
|
||||
): boolean => {
|
||||
if (covering === null) return true;
|
||||
if (key === null) return false;
|
||||
if (typeof key !== "object")
|
||||
return typeof covering === "object"
|
||||
? semanticPropertyPathKeyMatches(covering, String(key))
|
||||
: String(covering) === String(key);
|
||||
return (
|
||||
typeof covering === "object" &&
|
||||
covering.excludedKeys.every((name) => key.excludedKeys.includes(name)) &&
|
||||
(covering.startIndex === undefined ||
|
||||
(key.startIndex !== undefined && covering.startIndex <= key.startIndex))
|
||||
);
|
||||
};
|
||||
|
||||
@@ -211,12 +211,17 @@ const evaluateBinding = (
|
||||
if (isPrimitive(captured)) value = captured;
|
||||
}
|
||||
}
|
||||
const mutated = binding.mutatedPaths.reduce(
|
||||
invalidateSemanticMutationPath,
|
||||
value,
|
||||
);
|
||||
const projected = binding.escapedPaths.reduce(
|
||||
(value, escape) =>
|
||||
let projected = value;
|
||||
for (const path of binding.mutatedPaths) {
|
||||
projected = invalidateSemanticMutationPath(projected, path);
|
||||
// Every subsequent write returns this same root unknown. Replaying those
|
||||
// paths at every newly collected effect otherwise becomes quadratic.
|
||||
if (projected.status === "unknown") break;
|
||||
}
|
||||
for (const escape of binding.escapedPaths) {
|
||||
// Escapes only invalidate object references; other lattice values survive.
|
||||
if (projected.status !== "object" && projected.status !== "array") break;
|
||||
if (
|
||||
context.capturePoint !== undefined &&
|
||||
semanticEscapeFollowsCapture(
|
||||
binding,
|
||||
@@ -224,10 +229,10 @@ const evaluateBinding = (
|
||||
escape.node,
|
||||
context.state.parentsByNode,
|
||||
)
|
||||
? value
|
||||
: invalidateSemanticEscapedPath(value, escape.path),
|
||||
mutated,
|
||||
);
|
||||
)
|
||||
continue;
|
||||
projected = invalidateSemanticEscapedPath(projected, escape.path);
|
||||
}
|
||||
// Point-local memoization also bounds failed speculative captures. Only a
|
||||
// primitive result is allowed back into ordinary value evaluation.
|
||||
if (
|
||||
|
||||
Reference in New Issue
Block a user