fix(javascript): preserve uncertainty after references escape to calls (#1292)

* fix(javascript): preserve uncertainty after references escape to calls

* fix(javascript): track iterator root escapes and preserve static captures

* fix(javascript): scope comparison unknowns to their evidence

* fix(javascript): track parameter origins at function body entry

---------

Co-authored-by: morluto <76467478+morluto@users.noreply.github.com>
This commit is contained in:
You Wish
2026-10-10 06:53:42 +08:00
committed by GitHub
co-authored by morluto
parent d0e606930a
commit 355a292198
17 changed files with 2574 additions and 220 deletions
@@ -164,7 +164,378 @@ describe("JavaScript semantic values after explicit property mutations", () => {
});
});
describe("JavaScript semantic values after mutable references escape", () => {
it("preserves copied scalar slots while invalidating shared children of an escaped object spread", () => {
expect(
resultValue(`
const source = { kind: "record", child: { value: 1 } };
const copy = { ...source };
mutate(copy);
return source;
`),
).toMatchObject({
status: "object",
properties: [
{ name: "child", value: { status: "unknown" }, presence: "present" },
{ name: "kind", value: { status: "literal", value: "record" } },
],
});
});
it("invalidates shared array children without invalidating copied primitives", () => {
expect(
resultValue(`
const child = { value: 1 };
const source = [child, "TOKEN"];
const copy = [...source];
mutate(copy);
return { token: source[1], value: child.value };
`),
).toMatchObject({
status: "object",
properties: [
{ name: "token", value: { status: "literal", value: "TOKEN" } },
{ name: "value", value: { status: "unknown" } },
],
});
});
it("keeps primitive spread arguments known", () => {
expect(
resultValue(
'const values = ["TOKEN"]; consume(...values); return values[0];',
),
).toEqual({ status: "literal", value: "TOKEN" });
});
it("does not treat a member constructor as a call with its container as receiver", () => {
expect(
resultValue(`
const namespace = { token: "TOKEN", Factory: class {} };
new namespace.Factory();
return namespace.token;
`),
).toEqual({ status: "literal", value: "TOKEN" });
});
it("does not reuse an initializer projection cached before call mutations were collected", () => {
expect(
resultValue(`
const source = { value: 1 };
function observe() { consume(copy); }
mutate(source);
const copy = source.value;
return copy;
`)?.status,
).toBe("unknown");
});
it.each([
"mutate(source as unknown);",
"mutate((0, source));",
"let alias; mutate(alias = source);",
"mutate(flag ? source : {});",
"let alias = source; mutate(alias ||= {});",
"let alias = source; mutate(alias ??= {});",
])("follows a reference through %s", (invocation) => {
expect(
resultValue(`
const source = { value: 1 };
${invocation}
return source.value;
`)?.status,
).toBe("unknown");
});
});
describe("JavaScript escaped references through async and destructuring syntax", () => {
it("follows an awaited object argument", () => {
const ir = analyzeJavaScriptSemantics(`export async function result() {
const source = { value: 1 };
mutate(await source);
return source.value;
}`);
expect(onlyCallable(ir, "result").returnSites[0]?.value.status).toBe(
"unknown",
);
});
it.each([
"const { ...copy } = source; mutate(copy);",
"const { ...copy } = source; mutate(copy.child);",
"const [ ...copy ] = [source.child]; mutate(copy);",
"const [ first, ...copy ] = [null, source.child]; mutate(copy[0]);",
"const [ ...[copy] ] = [source.child]; mutate(copy);",
"const [ ...[copy = source.child] ] = []; mutate(copy);",
"const { value = source.child } = {}; mutate(value);",
"const [ value = source.child ] = []; mutate(value);",
])("follows shared references through %s", (invocation) => {
expect(
resultValue(`
const source = { kind: "record", child: { value: 1 } };
${invocation}
return source;
`),
).toMatchObject({
status: "object",
properties: [
{ name: "child", value: { status: "unknown" }, presence: "present" },
{ name: "kind", value: { status: "literal", value: "record" } },
],
});
});
it("keeps an unused default reference unchanged when destructuring a defined value", () => {
expect(
resultValue(`
const source = { value: "TOKEN" };
const { value = source } = { value: 1 };
mutate(value);
return source.value;
`),
).toEqual({ status: "literal", value: "TOKEN" });
});
it("keeps an unused nested default reference unchanged", () => {
expect(
resultValue(`
const unused = { value: "TOKEN" };
const { box: { value = unused } = { value: 1 } } = {};
mutate(value);
return unused.value;
`),
).toEqual({ status: "literal", value: "TOKEN" });
});
it("reconsiders a destructuring fallback after later collection finds an escape", () => {
expect(
resultValue(`
const fallback = { value: 1 };
const source = { child: { value: 2 } };
function observe() { mutate(copy); }
remove(source);
const { child: copy = fallback } = source;
mutate(copy);
return fallback.value;
`)?.status,
).toBe("unknown");
});
it("follows a fallback write when the original projection appeared primitive", () => {
expect(
resultValue(`
const fallback = { value: 1 };
const source = { child: 1 };
function observe() { copy.value = 2; }
remove(source);
const { child: copy = fallback } = source;
observe();
return fallback.value;
`)?.status,
).toBe("unknown");
});
it("keeps fresh rest-copy slot writes from changing the original", () => {
expect(
resultValue(`
const source = { child: { value: "TOKEN" } };
const { ...copy } = source;
copy.child = {};
return source.child.value;
`),
).toEqual({ status: "literal", value: "TOKEN" });
});
it("follows writes to shared children of rest copies", () => {
expect(
resultValue(`
const source = { kind: "record", child: { value: 1 } };
const { ...copy } = source;
copy.child.value = 2;
return { kind: source.kind, value: source.child.value };
`),
).toMatchObject({
status: "object",
properties: [
{ name: "kind", value: { status: "literal", value: "record" } },
{ name: "value", value: { status: "unknown" } },
],
});
});
it.each([
"const source = { skipped: {}, child: { value: 1 } }; const { skipped, ...copy } = source; mutate(copy); return source.child.value;",
"const source = [{}, { value: 1 }]; const [head, ...copy] = source; mutate(copy[0]); return source[1].value;",
"const source = [{}, { value: 1 }]; const [head, ...copy] = source; copy[0].value = 2; return source[1].value;",
"const source = { child: { value: 1 } }; const copy = { child: {}, ...source }; mutate(copy.child); return source.child.value;",
"const source = { child: { value: 1 } }; const copy = { ...source, [key]: {} }; mutate(copy.child); return source.child.value;",
"const source = [{ value: 1 }]; const copy = [{}, ...source]; mutate(copy[1]); return source[0].value;",
"const source = [{ value: 1 }]; const copy = [...other, ...source]; mutate(copy[0]); return source[0].value;",
"const source = [{ value: 1 }]; mutate([... [...source]]); return source[0].value;",
"const child = { value: 1 }; const source = { child, *[Symbol.iterator]() { yield this.child; } }; const copy = [{}, ...source]; mutate(copy[1]); return child.value;",
"const child = { value: 1 }; const source = { child, *[Symbol.iterator]() { yield null; yield this.child; } }; const [head, ...copy] = source; mutate(copy); return child.value;",
"const child = { value: 1 }; const source = [child]; source[Symbol.iterator] = function* () { yield null; yield this[0]; }; const [head, ...copy] = source; mutate(copy); return child.value;",
"const child = { value: 1 }; const source = [null, child]; source.__proto__ = { *[Symbol.iterator]() { yield this[1]; } }; const copy = [{}, ...source]; mutate(copy[1]); return child.value;",
"const source = [{ value: 1 }, {}]; Array.prototype[Symbol.iterator] = function* () { yield null; yield this[0]; }; const [head, ...copy] = source; mutate(copy[0]); return source[0].value;",
"const source = [null, { value: 1 }]; const prototype = Array.prototype; prototype[Symbol.iterator] = function* () { yield this[1]; }; const copy = [{}, ...source]; mutate(copy[1]); return source[1].value;",
"const source = [null, { value: 1 }]; const other = []; other.__proto__[Symbol.iterator] = function* () { yield this[1]; }; const copy = [{}, ...source]; mutate(copy[1]); return source[1].value;",
"const source = { child: { value: 1 } }; const copy = { ...source, get child() { return source.child; } }; mutate(copy.child); return source.child.value;",
"const source = { child: { value: 1 } }; const copy = { ...source, get child() { return source.child; }, set child(value) {} }; mutate(copy.child); return source.child.value;",
])("preserves uncertainty for retained shared children: %s", (body) => {
expect(resultValue(body)?.status).toBe("unknown");
});
it("finishes repeated alias branches without expanding identical escape paths", () => {
const declarations = Array.from({ length: 24 }, (_, index) => {
const name = `alias${String(index + 1)}`;
const previous = `alias${String(index)}`;
return `let ${name} = ${previous}; ${name} = ${previous};`;
}).join("\n");
expect(
resultValue(`
let alias0 = { value: 1 };
${declarations}
mutate(alias24);
return alias0.value;
`)?.status,
).toBe("unknown");
});
});
describe("JavaScript shared array iteration", () => {
it.each([
"mutate(...source);",
"mutate?.(...source);",
"new Factory(...source);",
"const copy = [...source]; mutate(copy);",
"const copy = [{}, ...source]; mutate(copy[1]);",
"const copy = [...source]; copy[0].value = 2;",
"const [...copy] = source; mutate(copy);",
"const [...copy] = source; copy[0].value = 2;",
"const wrapper = { source }; const { source: [...copy] } = wrapper; mutate(copy);",
"const [copy] = source; mutate(copy);",
"let copy; [copy] = source; mutate(copy);",
"const { nested: [copy] } = { nested: source }; mutate(copy);",
"for (const copy of source) mutate(copy);",
"let copy; for (copy of source) mutate(copy);",
])("invalidates an iterable that yields itself through %s", (effect) => {
expect(
resultValue(`
const source = { *[Symbol.iterator]() { yield this; }, value: "TOKEN" };
${effect}
return source.value;
`)?.status,
).toBe("unknown");
});
it.each([
"const [copy] = source;",
"const copy = [...source];",
"for (const copy of source) {}",
"const { nested: [copy] } = { nested: source };",
"const [...[[copy]]] = [source];",
"const [...{ 0: [copy] }] = [source];",
"for (const [copy] of [source]) {}",
"const { missing: [copy] = source } = {};",
"function consume([copy] = source) {} consume();",
"function* copies() { yield* source; } consume(copies());",
])("accounts for custom iterator receiver effects in %s", (iteration) => {
expect(
resultValue(`
const source = { *[Symbol.iterator]() { this.value = "changed"; yield this; }, value: "TOKEN" };
${iteration}
return source.value;
`)?.status,
).toBe("unknown");
});
it.each([
"const [copy] = source;",
"const copy = [...source];",
"for (const copy of source) {}",
"const { nested: [copy] } = { nested: source };",
"const [...[[copy]]] = [source];",
"const [...{ 0: [copy] }] = [source];",
"for (const [copy] of [source]) {}",
])("preserves ordinary array values after %s", (iteration) => {
expect(
resultValue(`const source = ["TOKEN"]; ${iteration} return source[0];`),
).toEqual({ status: "literal", value: "TOKEN" });
});
it.each([
"const { nested: [copy] = source } = { nested: [] };",
"const [[copy] = source] = [[]];",
"const { a: { b: [copy] = source } = { b: [] } } = {};",
"for (const { nested: [copy] = source } of [{ nested: [] }]) {}",
"for (const [[copy] = source] of [[[]]]) {}",
"for (const { nested: [copy] = source } of []) {}",
])("does not execute unused iterator defaults in %s", (iteration) => {
expect(
resultValue(`
const source = { *[Symbol.iterator]() { yield this; }, value: "TOKEN" };
${iteration}
return source.value;
`),
).toEqual({ status: "literal", value: "TOKEN" });
});
it.each([
"source[Symbol.iterator] = function* () { yield this; };",
"Array.prototype[Symbol.iterator] = function* () { yield this; };",
])("invalidates a custom array iterator's root after %s", (override) => {
expect(
resultValue(`
const source = ["TOKEN"];
${override}
mutate(...source);
return source[0];
`)?.status,
).toBe("unknown");
});
it.each(["globalThis", "global", "window", "self"])(
"retains uncertainty after %s.Array.prototype changes",
(globalName) => {
expect(
resultValue(`
const source = [null, { value: 1 }];
${globalName}.Array.prototype[Symbol.iterator] = function* () { yield this[1]; };
const copy = [{}, ...source];
mutate(copy[1]);
return source[1].value;
`)?.status,
).toBe("unknown");
},
);
it("respects a shadowed global object when checking iteration", () => {
expect(
resultValue(`
const globalThis = { Array: { prototype: {} } };
globalThis.Array.prototype[Symbol.iterator] = function* () { yield null; };
const source = [{ value: "TOKEN" }];
const [head, ...copy] = source;
mutate(copy);
return source[0].value;
`),
).toEqual({ status: "literal", value: "TOKEN" });
});
});
const unchangedProperties = [
'const source = { only: { value: "TOKEN" } }; const { only, ...copy } = source; mutate(copy); return source.only.value;',
'const source = [{ value: "TOKEN" }]; const [head, ...copy] = source; mutate(copy); return source[0].value;',
'const source = { child: { value: "TOKEN" } }; const copy = { ...source, child: { value: 2 } }; mutate(copy.child); return source.child.value;',
'const source = [{ value: "TOKEN" }]; const copy = [{ value: 0 }, ...source]; mutate(copy[0]); return source[0].value;',
'const source = { child: { value: "TOKEN" } }; const copy = { ...source, ["child"]: { value: 2 } }; mutate(copy); return source.child.value;',
'const child = { value: "TOKEN" }; const copy = { child, child: {} }; mutate(copy); return child.value;',
'const source = [{ value: "TOKEN" }, { value: 2 }]; const [head, ...copy] = source; mutate(copy[0]); return source[0].value;',
'const source = [{ value: "TOKEN" }, { value: 2 }]; const copy = [{}, ...source]; mutate(copy[2]); return source[0].value;',
'const source = [{ value: "TOKEN" }]; const copy = [, ...source]; mutate(copy[0]); return source[0].value;',
'const source = [{ value: "TOKEN" }]; const copy = [...source]; mutate(copy["01"]); return source[0].value;',
'const source = { only: { value: "TOKEN" } }; const { ["only"]: consumed, ...copy } = source; mutate(copy); return source.only.value;',
'const source = { child: { value: "TOKEN" } }; const copy = { ...source, child() {} }; mutate(copy); return source.child.value;',
'const source = { token: "TOKEN", count: 1 }; source.count = 2; return source.token;',
'const source = { token: "TOKEN", count: 1 }; const alias = source; alias.count++; return source.token;',
'const source = { token: "TOKEN", count: 1 }; delete source.count; return source.token;',
@@ -0,0 +1,313 @@
import { describe, expect, it } from "vitest";
import { analyzeJavaScriptSemantics } from "./javascriptSemanticAnalysis.js";
import { onlyCallable } from "./javascriptSemanticAnalysis.fixture.js";
const resultValue = (body: string) =>
onlyCallable(
analyzeJavaScriptSemantics(`export function result() { ${body} }`),
"result",
).returnSites[0]?.value;
describe("reference lifetimes across calls and shallow copies", () => {
it("bounds dynamic destructuring across shared alias branches", () => {
const declarations = Array.from(
{ length: 9 },
(_, index) =>
`const alias${index + 1} = { left: alias${index}, right: alias${index} };`,
).join("\n");
const pattern = "{ [key]: ".repeat(9) + "[copy]" + " }".repeat(9);
const start = performance.now();
resultValue(
`const alias0 = [1]; ${declarations} const ${pattern} = alias9; return alias0[0];`,
);
expect(performance.now() - start).toBeLessThan(2000);
}, 30000);
it("bounds conditional shallow-copy traversal while retaining shared children", () => {
const declarations = Array.from(
{ length: 20 },
(_, i) =>
`const alias${i + 1} = flag ? {...alias${i}, a${i}:{}} : {...alias${i}, b${i}:{}};`,
).join("\n");
const start = performance.now();
expect(
resultValue(
`const alias0 = { value: { token: 1 } }; ${declarations} consume(alias20); return alias0.value.token;`,
)?.status,
).toBe("unknown");
expect(performance.now() - start).toBeLessThan(2000);
}, 30000);
it.each([
["child: {}", "child: {}", "literal"],
["child: {}", "other: {}", "unknown"],
])(
"retains exclusions common to both branches: %s / %s",
(left, right, status) => {
expect(
resultValue(
`const source = {child:{value:1}}; const copy = flag ? {...source, ${left}} : {...source, ${right}}; consume(copy); return source.child.value;`,
)?.status,
).toBe(status);
},
);
it.each([
"mutate(alias)",
"alias.method()",
"new Factory(alias)",
"tag`${alias}`",
"alias.tag``",
"mutate((0, alias))",
])("drops replaced call origins for %s", (call) => {
expect(
resultValue(
`const source={value:1}; let alias=source; alias={}; ${call}; return source.value;`,
),
).toEqual({ status: "literal", value: 1 });
});
it.each([
"mutate(alias); alias={};",
"if(flag) alias={}; mutate(alias);",
"alias={}; if(flag) mutate(alias);",
"function invoke(){mutate(alias);} alias={}; invoke();",
"alias={}; mutate(alias); alias=source;",
])("retains uncertain call ordering: %s", (body) => {
expect(
resultValue(
`const source={value:1}; let alias=source; ${body} return source.value;`,
)?.status,
).toBe("unknown");
});
it.each([
["let {...copy}={child};", "copy={child:{}};", "copy.child.value=2;"],
["let [...copy]=[child];", "copy=[{}];", "copy[0].value=2;"],
["let {copy=child}={};", "copy={};", "copy.value=2;"],
["let [copy=child]=[];", "copy={};", "mutate(copy);"],
])(
"drops replaced rest/default origins: %s",
(declaration, rebind, mutation) => {
expect(
resultValue(
`const child={value:1}; ${declaration} ${rebind} ${mutation} return child.value;`,
),
).toEqual({ status: "literal", value: 1 });
expect(
resultValue(
`const child={value:1}; ${declaration} if(flag) ${rebind} ${mutation} return child.value;`,
)?.status,
).toBe("unknown");
},
);
});
describe("primitive snapshots across calls", () => {
it.each([
"const [copy] = source;",
"const copy = [...source];",
"for (const copy of source) {}",
])("preserves snapshots taken before custom iteration: %s", (iteration) => {
expect(
resultValue(`
const source = { *[Symbol.iterator]() { yield this; }, value: 1 };
const snapshot = source.value;
${iteration}
return snapshot;
`),
).toEqual({ status: "literal", value: 1 });
});
it.each([
"const [copy] = alias;",
"const copy = [...alias];",
"for (const copy of alias) {}",
])("ignores iterable aliases replaced before %s", (iteration) => {
expect(
resultValue(`
const source = { *[Symbol.iterator]() { yield this; }, value: 1 };
let alias = source;
alias = [];
${iteration}
return source.value;
`),
).toEqual({ status: "literal", value: 1 });
});
it.each([
["const snapshot=source.value;", "snapshot"],
["const {value:snapshot}=source;", "snapshot"],
["const copy={value:source.value};", "copy.value"],
['const copy={["snapshot"]:source.value};', "copy.snapshot"],
['const copy={[""]:source.value};', 'copy[""]'],
["const copy={[0]:source.value};", "copy[0]"],
['const copy={[("snapshot" as string)]:source.value};', "copy.snapshot"],
["const copy=[source.value];", "copy[0]"],
])("preserves primitive capture before escape: %s", (capture, result) => {
expect(
resultValue(
`const source={value:1}; ${capture} mutate(source); return ${result};`,
),
).toEqual({ status: "literal", value: 1 });
expect(
resultValue(
`const source={value:1}; mutate(source); ${capture} return ${result};`,
)?.status,
).toBe("unknown");
});
it.each([
["const copy={value:source.value};", "copy.value"],
["const copy=[source.value];", "copy[0]"],
])(
"retains a literal field's earlier primitive capture: %s",
(copy, read) => {
expect(
resultValue(
`const source={value:1}; ${copy} mutate(source); const snapshot=${read}; mutate(copy); return snapshot;`,
),
).toEqual({ status: "literal", value: 1 });
expect(
resultValue(
`const source={value:1}; mutate(source); ${copy} const snapshot=${read}; mutate(copy); return snapshot;`,
)?.status,
).toBe("unknown");
},
);
it.each([
["const copy={child:source.child};", "copy.child"],
["const copy=[source.child];", "copy[0]"],
])(
"keeps a shared child uncertain across both capture points: %s",
(copy, read) => {
expect(
resultValue(
`const source={child:{value:1}}; ${copy} mutate(source); const snapshot=${read}; mutate(copy); return snapshot.value;`,
)?.status,
).toBe("unknown");
},
);
it.each([
"const alias=source; const snapshot=alias.value; mutate(alias); return snapshot;",
"const alias=source.child; const snapshot=alias.value; mutate(alias); return snapshot;",
])("captures through an earlier intermediate reference: %s", (body) => {
expect(
resultValue(`const source={value:1,child:{value:1}}; ${body}`),
).toEqual({ status: "literal", value: 1 });
});
it("does not read a later alias initializer at an earlier capture point", () => {
expect(
resultValue(
"const source={value:1}; var alias; const snapshot=alias?.value; mutate(source); alias=source; return snapshot;",
)?.status,
).toBe("unknown");
});
it("does not treat a persistent child as freshly allocated with its wrapper", () => {
const ir = analyzeJavaScriptSemantics(
"const child={value:1}; export function result(){const source={child}; const alias=source.child; const snapshot=alias.value; mutate(alias); return snapshot;}",
);
expect(onlyCallable(ir, "result").returnSites[0]?.value.status).toBe(
"unknown",
);
});
it("keeps persistent sources uncertain across function activations", () => {
const ir = analyzeJavaScriptSemantics(
"const source={value:1}; export function result(){const snapshot=source.value; mutate(source); return snapshot;}",
);
expect(onlyCallable(ir, "result").returnSites[0]?.value.status).toBe(
"unknown",
);
});
it("keeps reads from earlier loop iterations uncertain", () => {
expect(
resultValue(
"const source={value:1}; for(let i=0;i<2;i++){const snapshot=source.value; mutate(source); if(i===1)return snapshot;}",
)?.status,
).toBe("unknown");
});
it.each([
"const copy={child:source.child}; return copy.child.value;",
"const copy=source.child; return copy.value;",
"const copy=[source.child]; return copy[0].value;",
])("keeps shared children live: %s", (body) => {
expect(
resultValue(
`const source={child:{value:1}}; ${body.replace("return", "mutate(source); return")}`,
)?.status,
).toBe("unknown");
});
});
describe("references captured before an intermediate rebind", () => {
it.each([
["const saved=alias;", "alias=saved;", "mutate(alias);"],
["const saved=alias;", "alias=saved;", "alias.value=9;"],
["const saved={child:alias};", "alias=saved.child;", "mutate(alias);"],
["const {...saved}={child:alias};", "alias=saved.child;", "mutate(alias);"],
["const [...saved]=[alias];", "alias=saved[0];", "mutate(alias);"],
["const {saved=alias}={};", "alias=saved;", "mutate(alias);"],
])("follows an alias restored from %s", (capture, restore, effect) => {
expect(
resultValue(
`const source={value:1}; let alias=source; ${capture} ${restore} ${effect} return source.value;`,
)?.status,
).toBe("unknown");
});
it.each([
["const saved=alias;", "mutate(saved);"],
["const saved={child:alias};", "mutate(saved.child);"],
["const {...saved}={child:alias};", "mutate(saved.child);"],
["const [...saved]=[alias];", "mutate(saved[0]);"],
["const {saved=alias}={};", "mutate(saved);"],
["const [saved=alias]=[];", "mutate(saved);"],
["const saved=alias;", "saved.method();"],
["const saved=alias;", "mutate(alias,saved);"],
["const saved=alias;", "mutate(saved,alias);"],
])("preserves the original reference captured by %s", (capture, effect) => {
expect(
resultValue(
`const source={value:1}; let alias=source; ${capture} alias={}; ${effect} return source.value;`,
)?.status,
).toBe("unknown");
expect(
resultValue(
`const source={value:1}; let alias=source; alias={}; ${capture} ${effect} return source.value;`,
),
).toEqual({ status: "literal", value: 1 });
});
it.each([
[
"let {...alias}={child:source};",
"alias={child:{}};",
"saved.child.value=9;",
],
["let [...alias]=[source];", "alias=[{}];", "saved[0].value=9;"],
["let {alias=source}={};", "alias={};", "saved.value=9;"],
["let [alias=source]=[];", "alias={};", "saved.value=9;"],
])(
"preserves a saved rest/default reference from %s",
(declaration, rebind, effect) => {
expect(
resultValue(
`const source={value:1}; ${declaration} const saved=alias; ${rebind} ${effect} return source.value;`,
)?.status,
).toBe("unknown");
expect(
resultValue(
`const source={value:1}; ${declaration} ${rebind} const saved=alias; ${effect} return source.value;`,
),
).toEqual({ status: "literal", value: 1 });
},
);
});
@@ -52,6 +52,19 @@ interface BindPatternInput {
readonly mutable: boolean;
readonly kind?: JavaScriptSemanticDefinition["kind"];
readonly projection?: readonly (string | number | null)[];
readonly referenceOnly?: boolean;
readonly copyKind?: "object-rest" | "array-rest";
readonly copyProjectionOffset?: number;
readonly copyExcludedKeys?: readonly string[];
readonly copyStartIndex?: number;
readonly fallbackSources?: readonly {
readonly node: t.Node;
readonly projection: readonly (string | number | null)[];
}[];
readonly requiredSources?: readonly {
readonly node: t.Node;
readonly projection: readonly (string | number | null)[];
}[];
}
interface AddBindingInput {
@@ -279,6 +292,7 @@ const createState = (program: t.Program): JavaScriptSemanticAnalysisState => {
bindings: new Map(),
};
return {
parentsByNode: new WeakMap(),
scopes: [root],
scopesById: new Map([[root.scopeId, root]]),
scopeByNode: new WeakMap([[program, root]]),
@@ -752,12 +766,36 @@ const bindPattern = (input: BindPatternInput): void => {
mutable,
kind = "variable",
projection = [],
referenceOnly = false,
copyKind,
copyProjectionOffset,
copyExcludedKeys,
copyStartIndex,
fallbackSources,
requiredSources,
} = input;
if (t.isTSParameterProperty(pattern)) {
bindPattern({ ...input, pattern: pattern.parameter });
return;
}
if (t.isIdentifier(pattern)) {
if (referenceOnly) {
const binding = scope.bindings.get(pattern.name);
if (binding !== undefined && initializer !== null)
binding.referenceInitializers.push({
node: initializer,
projection,
...(copyKind === undefined ? {} : { copyKind }),
...(copyProjectionOffset === undefined
? {}
: { copyProjectionOffset }),
...(copyExcludedKeys === undefined ? {} : { copyExcludedKeys }),
...(copyStartIndex === undefined ? {} : { copyStartIndex }),
...(fallbackSources === undefined ? {} : { fallbackSources }),
...(requiredSources === undefined ? {} : { requiredSources }),
});
return;
}
addBinding({
state,
scope,
@@ -778,6 +816,25 @@ const bindPattern = (input: BindPatternInput): void => {
kind === "parameter" || kind === "catch"
? initializer
: (initializer ?? pattern.right),
requiredSources: [
...(requiredSources ?? []),
...(initializer === null ? [] : [{ node: initializer, projection }]),
],
});
bindPattern({
state,
scope,
mutable,
kind,
pattern: pattern.left,
initializer: pattern.right,
projection: [],
referenceOnly: true,
fallbackSources: [
...(fallbackSources ?? []),
...(initializer === null ? [] : [{ node: initializer, projection }]),
],
...(requiredSources === undefined ? {} : { requiredSources }),
});
return;
}
@@ -792,7 +849,7 @@ const bindPattern = (input: BindPatternInput): void => {
}
if (t.isObjectPattern(pattern))
for (const property of pattern.properties) {
if (t.isRestElement(property))
if (t.isRestElement(property)) {
bindPattern({
...input,
pattern: property.argument,
@@ -800,7 +857,23 @@ const bindPattern = (input: BindPatternInput): void => {
mutable: true,
projection: [],
});
else {
bindPattern({
...input,
pattern: property.argument,
projection: [...projection, null],
referenceOnly: true,
copyKind: "object-rest",
copyProjectionOffset: projection.length,
copyExcludedKeys: pattern.properties.flatMap((property) => {
if (t.isRestElement(property)) return [];
const key = semanticStaticPropertyKey(
property.key,
property.computed,
);
return key === null ? [] : [key];
}),
});
} else {
const name = semanticStaticPropertyKey(property.key, property.computed);
bindPattern({
...input,
@@ -811,12 +884,23 @@ const bindPattern = (input: BindPatternInput): void => {
}
else if (t.isArrayPattern(pattern))
pattern.elements.forEach((element, index) => {
if (element !== null)
if (element !== null) {
bindPattern({
...input,
pattern: element,
projection: [...projection, index],
});
if (t.isRestElement(element))
bindPattern({
...input,
pattern: element.argument,
projection: [...projection, null],
referenceOnly: true,
copyKind: "array-rest",
copyProjectionOffset: projection.length,
copyStartIndex: index,
});
}
});
};
@@ -858,8 +942,10 @@ const createBinding = (
kind,
mutable,
mutatedPaths: [],
escapedPaths: [],
definitions: [],
initializers: [],
referenceInitializers: [],
directOrigins: [],
});
@@ -0,0 +1,163 @@
import * as t from "@babel/types";
import { semanticStaticPropertyKey } from "./javascriptAstValues.js";
import { semanticArrayIndex } from "./javascriptSemanticPropertyPaths.js";
interface IterationSourceValue {
readonly node: t.Node;
readonly projection: readonly (string | number | null)[];
}
/** An implicit iterator receiver, with guards for destructuring defaults. */
export interface SemanticIterationSource extends IterationSourceValue {
readonly mutation: t.Node;
readonly fallbackSources?: readonly IterationSourceValue[];
readonly requiredSources?: readonly IterationSourceValue[];
}
interface PatternSource extends IterationSourceValue {
// A rest binding is a fresh array whose children retain their source indices.
readonly restStartIndex?: number;
}
interface SourceGuards {
readonly fallbackSources?: readonly IterationSourceValue[];
readonly requiredSources?: readonly IterationSourceValue[];
}
const add = (
sources: SemanticIterationSource[],
source: IterationSourceValue,
mutation: t.Node,
guards: SourceGuards,
): void => {
sources.push({
node: source.node,
projection: source.projection,
mutation,
...guards,
});
};
const project = (
source: PatternSource | undefined,
key: string | number | null,
): PatternSource | undefined => {
if (source === undefined) return undefined;
const index = key === null ? null : semanticArrayIndex(key);
return {
node: source.node,
projection: [
...source.projection,
source.restStartIndex !== undefined && index !== null
? source.restStartIndex + index
: key,
],
};
};
interface PatternCollection {
readonly sources: SemanticIterationSource[];
readonly mutation: t.Node;
}
const visit = (
context: PatternCollection,
pattern: t.Node,
source: PatternSource | undefined,
guards: SourceGuards = {},
): void => {
const { sources, mutation } = context;
if (t.isTSParameterProperty(pattern)) {
visit(context, pattern.parameter, source, guards);
return;
}
if (t.isAssignmentPattern(pattern)) {
visit(context, pattern.left, source, {
...guards,
requiredSources: [
...(guards.requiredSources ?? []),
...(source === undefined ? [] : [source]),
],
});
visit(
context,
pattern.left,
{ node: pattern.right, projection: [] },
{
...guards,
fallbackSources: [
...(guards.fallbackSources ?? []),
...(source === undefined ? [] : [source]),
],
},
);
return;
}
if (t.isObjectPattern(pattern)) {
for (const property of pattern.properties) {
// Object rest creates a fresh object and has no iterable binding pattern.
if (t.isRestElement(property)) continue;
visit(
context,
property.value,
project(
source,
semanticStaticPropertyKey(property.key, property.computed),
),
guards,
);
}
return;
}
if (t.isArrayPattern(pattern)) {
if (source !== undefined && source.restStartIndex === undefined)
add(sources, source, mutation, guards);
pattern.elements.forEach((element, index) => {
if (element === null) return;
if (t.isRestElement(element))
visit(
context,
element.argument,
source === undefined
? undefined
: {
node: source.node,
projection: source.projection,
restStartIndex: (source.restStartIndex ?? 0) + index,
},
guards,
);
else visit(context, element, project(source, index), guards);
});
return;
}
if (t.isRestElement(pattern))
visit(context, pattern.argument, undefined, guards);
};
/** Describe implicit iteration sources without deciding their runtime values. */
export const semanticIterationSources = (
node: t.Node,
parent: t.Node | null,
): readonly SemanticIterationSource[] => {
const sources: SemanticIterationSource[] = [];
const context = { sources, mutation: node };
if (t.isVariableDeclarator(node) && node.init != null)
visit(context, node.id, { node: node.init, projection: [] });
else if (t.isAssignmentExpression(node) && node.operator === "=")
visit(context, node.left, { node: node.right, projection: [] });
else if (t.isForOfStatement(node)) {
add(sources, { node: node.right, projection: [] }, node, {});
const source = { node: node.right, projection: [null] };
if (t.isVariableDeclaration(node.left)) {
for (const declaration of node.left.declarations)
visit(context, declaration.id, source);
} else visit(context, node.left, source);
} else if (t.isSpreadElement(node) && t.isArrayExpression(parent))
add(sources, { node: node.argument, projection: [] }, node, {});
else if (t.isYieldExpression(node) && node.delegate && node.argument != null)
add(sources, { node: node.argument, projection: [] }, node, {});
else if (t.isFunction(node))
for (const parameter of node.params) visit(context, parameter, undefined);
return sources;
};
@@ -2,77 +2,268 @@ import * as t from "@babel/types";
import {
resolveSemanticBindingState,
type JavaScriptSemanticAnalysisState,
type JavaScriptSemanticBindingState,
type JavaScriptSemanticAnalysisState,
} from "./javascriptSemanticState.js";
import { evaluateSemanticBinding } from "./javascriptSemanticValues.js";
import {
clearSemanticPrimitiveBindingValues,
evaluateSemanticBinding,
evaluateSemanticExpression,
} from "./javascriptSemanticValues.js";
import {
semanticContainer,
semanticSlotAtPath,
} from "./javascriptSemanticSlots.js";
import { semanticIterationSources } from "./javascriptSemanticIterationSources.js";
import { semanticMutationInitializers } from "./javascriptSemanticMutationInitializers.js";
import {
semanticArrayIndex,
semanticPropertyPathKeyMatches,
type JavaScriptSemanticPropertyPath,
} from "./javascriptSemanticPropertyPaths.js";
import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
import {
semanticStaticPropertyKey,
unwrapJavaScriptExpression,
} from "./javascriptAstValues.js";
type PropertyPath = readonly (string | number | null)[];
type PropertyPath = JavaScriptSemanticPropertyPath;
type ValueEffect = "write" | "escape";
/** Keep explicit property mutations outside the initializer-only value lattice. */
/** Preserve uncertainty from property writes and references exposed to calls. */
export const collectSemanticMemberMutations = (
program: t.Program,
state: JavaScriptSemanticAnalysisState,
): void => {
const parents = new WeakMap<t.Node, t.Node>();
const parents = state.parentsByNode;
traverseJavaScriptAst(program, {
enter: (node, parent) => {
if (parent !== null) parents.set(node, parent);
},
});
const recordedEffects = new Set<string>();
const selections = new Map<string, readonly string[]>();
let arrayIterationUnknown = false;
const pendingReferences: {
readonly initializer: JavaScriptSemanticBindingState["referenceInitializers"][number];
readonly path: PropertyPath;
readonly bindings: ReadonlySet<string>;
readonly effect: ValueEffect;
readonly mutation?: t.Node;
readonly originAt: t.Node | undefined;
}[] = [];
const iterableReferences: IterableReference[] = [];
const iterableReferenceKeys = new WeakMap<t.Node, Set<string>>();
const deferIterable = (reference: IterableReference): void => {
const keys = iterableReferenceKeys.get(reference.node) ?? new Set<string>();
const key = JSON.stringify([
reference.projection,
reference.path,
reference.fallbackPath,
reference.effect,
reference.mutation?.start,
reference.mutation?.end,
reference.originAt?.start,
reference.originAt?.end,
reference.iterationOnly,
reference.requiredSources?.map((source) => [
source.node.start,
source.node.end,
source.projection,
]),
reference.fallbackSources?.map((source) => [
source.node.start,
source.node.end,
source.projection,
]),
[...reference.bindings].sort(compareUnicodeCodePoints),
]);
if (keys.has(key)) return;
keys.add(key);
iterableReferenceKeys.set(reference.node, keys);
iterableReferences.push(reference);
};
const markValue = (
node: t.Node,
path: PropertyPath,
bindings: ReadonlySet<string>,
mutation: t.Node,
effect: ValueEffect = "write",
mutation?: t.Node,
originAt: t.Node | undefined = mutation,
): void => {
const unwrapped = unwrapJavaScriptExpression(node).node;
if (unwrapped !== node) {
markValue(unwrapped, path, bindings, mutation);
return;
}
if (t.isIdentifier(node)) {
const binding = resolveSemanticBindingState(state, node, node.name);
if (binding === undefined || bindings.has(binding.bindingId)) return;
const value = evaluateSemanticBinding(binding, state);
if (value.status === "literal" || value.status === "union") return;
binding.mutatedPaths.push(path);
const nested = new Set([...bindings, binding.bindingId]);
for (const initializer of mutationInitializers(
binding,
mutation,
parents,
))
markValue(
initializer.node,
[...initializer.projection, ...path],
nested,
mutation,
const pending = [{ node, path, bindings, originAt }];
while (pending.length > 0) {
const current = pending.pop();
if (current === undefined) break;
const expression = unwrapJavaScriptExpression(current.node).node;
if (t.isIdentifier(expression)) {
const binding = resolveSemanticBindingState(
state,
expression,
expression.name,
);
return;
}
if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
const members: (string | null)[] = [];
let current: t.Node = node;
while (
t.isMemberExpression(current) ||
t.isOptionalMemberExpression(current)
if (binding === undefined) {
if (
(expression.name === "Array" &&
(current.path[0] === "prototype" || current.path[0] === null)) ||
(["globalThis", "global", "window", "self"].includes(
expression.name,
) &&
(current.path[0] === "Array" || current.path[0] === null) &&
(current.path[1] === "prototype" || current.path[1] === null))
)
arrayIterationUnknown = true;
continue;
}
// An alias restored from a saved reference can revisit the same binding
// at an earlier capture. Only a repeated lifetime closes a cycle.
const lifetime = JSON.stringify([
binding.bindingId,
current.originAt?.start,
current.originAt?.end,
]);
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(
(key) => key !== null && typeof key === "object",
);
let path = current.path;
const selector = path[selectorIndex];
if (selector !== null && typeof selector === "object") {
const selectionIdentity = JSON.stringify([
binding.bindingId,
effect,
path.map((key, index) =>
index === selectorIndex
? { startIndex: selector.startIndex }
: key,
),
mutation?.start,
mutation?.end,
current.originAt?.start,
current.originAt?.end,
]);
const previous = selections.get(selectionIdentity);
const excludedKeys =
previous === undefined
? selector.excludedKeys
: previous.filter((key) => selector.excludedKeys.includes(key));
if (previous !== undefined && excludedKeys.length === previous.length)
continue;
selections.set(selectionIdentity, excludedKeys);
path = path.map((key, index) =>
index === selectorIndex ? { ...selector, excludedKeys } : key,
);
}
const identity = JSON.stringify([
binding.bindingId,
effect,
path,
mutation?.start,
mutation?.end,
current.originAt?.start,
current.originAt?.end,
]);
if (recordedEffects.has(identity)) continue;
const value =
effect === "write"
? evaluateSemanticBinding(binding, state)
: undefined;
const primitiveWrite =
value?.status === "literal" || value?.status === "union";
recordedEffects.add(identity);
const nested = new Set([...current.bindings, lifetime]);
const origins =
current.originAt === undefined
? binding
: semanticMutationInitializers(binding, current.originAt, parents);
if (!primitiveWrite) {
if (effect === "escape")
binding.escapedPaths.push({ path, node: mutation });
else binding.mutatedPaths.push(path);
clearSemanticPrimitiveBindingValues(state);
for (const initializer of origins.initializers)
pending.push({
node: initializer.node,
path: [...initializer.projection, ...path],
bindings: nested,
originAt: initializer.node,
});
}
for (const initializer of origins.referenceInitializers) {
const copiedPath = copiedReferencePath(initializer, path, effect);
if (copiedPath === null) continue;
pendingReferences.push({
initializer,
path: copiedPath,
bindings: nested,
effect,
originAt: initializer.node,
...(mutation === undefined ? {} : { mutation }),
});
}
} else if (
t.isMemberExpression(expression) ||
t.isOptionalMemberExpression(expression)
) {
members.push(
semanticStaticPropertyKey(current.property, current.computed),
);
current = current.object;
pending.push({
node: expression.object,
path: [
semanticStaticPropertyKey(expression.property, expression.computed),
...current.path,
],
bindings: current.bindings,
originAt: current.originAt,
});
} else {
if (
t.isArrayExpression(expression) &&
((current.path[0] === "__proto__" &&
(effect === "escape" || current.path.length > 1)) ||
(current.path[0] === "constructor" &&
current.path[1] === "prototype"))
)
arrayIterationUnknown = true;
for (const value of referencedValues(
expression,
current.path,
effect,
)) {
if (value.iterableFallbackPath !== undefined)
deferIterable({
node: value.node,
projection: [],
path: value.path,
fallbackPath: value.iterableFallbackPath,
bindings: current.bindings,
effect,
originAt: current.originAt,
...(mutation === undefined ? {} : { mutation }),
});
else
pending.push({
...value,
bindings: current.bindings,
originAt: current.originAt,
});
}
}
markValue(current, [...members.reverse(), ...path], bindings, mutation);
return;
}
for (const value of referencedValues(node, path))
markValue(value.node, value.path, bindings, mutation);
};
const markEscaped = (
node: t.Node,
mutation: t.Node,
path: PropertyPath = [],
): void => markValue(node, path, new Set(), "escape", mutation);
const markReceiver = (callee: t.Node, mutation: t.Node): void => {
const expression = unwrapJavaScriptExpression(callee).node;
if (
t.isMemberExpression(expression) ||
t.isOptionalMemberExpression(expression)
)
markEscaped(expression.object, mutation);
};
const markTarget = (node: t.Node, mutation: t.Node): void => {
if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node))
@@ -80,6 +271,7 @@ export const collectSemanticMemberMutations = (
node.object,
[semanticStaticPropertyKey(node.property, node.computed)],
new Set(),
"write",
mutation,
);
else if (t.isRestElement(node)) markTarget(node.argument, mutation);
@@ -96,143 +288,245 @@ export const collectSemanticMemberMutations = (
}
};
traverseJavaScriptAst(program, {
enter: (node) => {
enter: (node, parent) => {
for (const source of semanticIterationSources(node, parent))
deferIterable({
...source,
path: source.projection,
fallbackPath: source.projection,
bindings: new Set(),
effect: "escape",
originAt: source.mutation,
iterationOnly: true,
});
if (t.isAssignmentExpression(node)) markTarget(node.left, node);
else if (t.isUpdateExpression(node)) markTarget(node.argument, node);
else if (t.isUnaryExpression(node, { operator: "delete" }))
markTarget(node.argument, node);
else if (t.isForOfStatement(node) || t.isForInStatement(node))
markTarget(node.left, node);
else if (
t.isCallExpression(node) ||
t.isOptionalCallExpression(node) ||
t.isNewExpression(node)
) {
for (const argument of node.arguments)
if (t.isSpreadElement(argument))
deferIterable({
node: argument.argument,
projection: [],
path: [null],
fallbackPath: [],
bindings: new Set(),
effect: "escape",
mutation: node,
originAt: node,
});
else markEscaped(argument, node);
// Constructing a member does not pass its container as `this`.
if (!t.isNewExpression(node)) markReceiver(node.callee, node);
} else if (t.isTaggedTemplateExpression(node)) {
markReceiver(node.tag, node);
for (const expression of node.quasi.expressions)
markEscaped(expression, node);
}
},
});
};
interface StatementPosition {
readonly body: readonly t.Statement[];
readonly index: number;
}
const statementPosition = (
statement: t.Statement,
parents: WeakMap<t.Node, t.Node>,
): StatementPosition | null => {
const parent = parents.get(statement);
if (!t.isProgram(parent) && !t.isBlockStatement(parent)) return null;
const index = parent.body.indexOf(statement);
return index < 0 ? null : { body: parent.body, index };
};
const directInitializerPosition = (
node: t.Node,
parents: WeakMap<t.Node, t.Node>,
): StatementPosition | null => {
const parent = parents.get(node);
if (t.isVariableDeclarator(parent) && parent.init === node) {
const declaration = parents.get(parent);
return t.isVariableDeclaration(declaration)
? statementPosition(declaration, parents)
: null;
}
if (
t.isAssignmentExpression(parent) &&
parent.operator === "=" &&
parent.right === node &&
t.isIdentifier(parent.left)
) {
const statement = parents.get(parent);
return t.isExpressionStatement(statement) && statement.expression === parent
? statementPosition(statement, parents)
: null;
}
return null;
};
const directMutationPosition = (
node: t.Node,
parents: WeakMap<t.Node, t.Node>,
): StatementPosition | null => {
if (
!t.isAssignmentExpression(node) &&
!t.isUpdateExpression(node) &&
!t.isUnaryExpression(node, { operator: "delete" })
)
return null;
const statement = parents.get(node);
return t.isExpressionStatement(statement) && statement.expression === node
? statementPosition(statement, parents)
: null;
};
const mutationInitializers = (
binding: JavaScriptSemanticBindingState,
mutation: t.Node,
parents: WeakMap<t.Node, t.Node>,
): JavaScriptSemanticBindingState["initializers"] => {
if (binding.initializers.length < 2) return binding.initializers;
const mutationPosition = directMutationPosition(mutation, parents);
if (mutationPosition === null) return binding.initializers;
const positions = binding.initializers.map(({ node, entryBody }) =>
entryBody === undefined
? directInitializerPosition(node, parents)
: { body: entryBody.body, index: -1 },
);
if (
positions.some(
(position) =>
position === null ||
position.body !== mutationPosition.body ||
position.index >= mutationPosition.index,
// A later effect can make a previously defined destructuring source uncertain.
// Reconsider defaults and iterable origins until their effects are stable.
while (pendingReferences.length > 0 || iterableReferences.length > 0) {
const effectsBefore = recordedEffects.size;
const iterablesBefore = iterableReferences.length;
const iterationBefore: boolean = arrayIterationUnknown;
for (const reference of pendingReferences.splice(0)) {
const { initializer } = reference;
if (referenceSourcesInactive(initializer, state))
pendingReferences.push(reference);
else if (
initializer.copyKind === "array-rest" &&
initializer.copyProjectionOffset !== undefined
) {
const offset = initializer.copyProjectionOffset;
const projection = initializer.projection.slice(0, offset);
deferIterable({
node: initializer.node,
projection,
path: reference.path,
fallbackPath: projection,
bindings: reference.bindings,
effect: reference.effect,
originAt: reference.originAt,
...(reference.mutation === undefined
? {}
: { mutation: reference.mutation }),
});
} else
markValue(
initializer.node,
reference.path,
reference.bindings,
reference.effect,
reference.mutation,
reference.originAt,
);
}
for (const reference of [...iterableReferences]) {
if (referenceSourcesInactive(reference, state)) continue;
if (reference.iterationOnly) {
const expanded = expandedIterationReferences(reference, state);
if (expanded !== null) {
for (const selected of expanded) deferIterable(selected);
continue;
}
}
const slot = selectedReferenceSlot(reference, state);
// Custom iteration can yield the iterable itself as well as any child.
// Treat its root as escaped, including writes through yielded references.
const knownArray =
!arrayIterationUnknown &&
slot?.value.status === "array" &&
slot.value.items.every(
(item) => semanticArrayIndex(item.name) !== null,
);
if (knownArray && reference.iterationOnly) continue;
markValue(
reference.node,
knownArray ? reference.path : reference.fallbackPath,
reference.bindings,
knownArray ? reference.effect : "escape",
reference.mutation,
reference.originAt,
);
}
if (
recordedEffects.size === effectsBefore &&
iterableReferences.length === iterablesBefore &&
arrayIterationUnknown === iterationBefore
)
)
return binding.initializers;
const latestIndex = positions.reduce(
(latest, position) => Math.max(latest, position?.index ?? -1),
-1,
);
return binding.initializers.filter(
(_, index) => positions[index]?.index === latestIndex,
);
break;
}
// Gathering effects can evaluate a primitive projection before its object
// escapes. Final values must use the completed mutation state.
clearSemanticPrimitiveBindingValues(state);
};
interface ReferencedValue {
readonly node: t.Node;
readonly path: PropertyPath;
readonly iterableFallbackPath?: PropertyPath;
}
interface IterableReference extends ReferencedValue {
readonly projection: PropertyPath;
readonly fallbackPath: PropertyPath;
readonly bindings: ReadonlySet<string>;
readonly effect: ValueEffect;
readonly mutation?: t.Node;
readonly originAt: t.Node | undefined;
readonly iterationOnly?: boolean;
readonly requiredSources?: readonly {
readonly node: t.Node;
readonly projection: PropertyPath;
}[];
readonly fallbackSources?: readonly {
readonly node: t.Node;
readonly projection: PropertyPath;
}[];
}
const referenceSourcesInactive = (
reference: Pick<IterableReference, "requiredSources" | "fallbackSources">,
state: JavaScriptSemanticAnalysisState,
): boolean =>
reference.requiredSources?.some(
(source) => selectedReferenceSlot(source, state)?.presence === "absent",
) === true ||
reference.fallbackSources?.some((source) => {
const slot = selectedReferenceSlot(source, state);
return (
slot?.presence === "present" &&
(slot.value.status === "literal" ||
slot.value.status === "union" ||
slot.value.status === "object" ||
slot.value.status === "array")
);
}) === true;
const expandedIterationReferences = (
reference: IterableReference,
state: JavaScriptSemanticAnalysisState,
): readonly IterableReference[] | null => {
if (!t.isForOfStatement(reference.mutation)) return null;
const iterable = reference.mutation.right;
// Expand only the loop's yielded-item selector. Enumerating dynamic property
// selections would multiply paths through shared object aliases.
const source = [
reference,
...(reference.requiredSources ?? []),
...(reference.fallbackSources ?? []),
].find((source) => source.node === iterable && source.projection[0] === null);
if (source === undefined) return null;
const slot = selectedReferenceSlot({ node: iterable, projection: [] }, state);
const container = slot === undefined ? null : semanticContainer(slot.value);
if (container?.coverage.status !== "complete") return null;
const select = (
candidate: { readonly node: t.Node; readonly projection: PropertyPath },
name: string,
) => ({
...candidate,
projection:
candidate.node === iterable && candidate.projection[0] === null
? [name, ...candidate.projection.slice(1)]
: candidate.projection,
});
return container.slots.map((slot) => {
const { projection } = select(reference, slot.name);
return {
...reference,
projection,
path: projection,
fallbackPath: projection,
...(reference.requiredSources === undefined
? {}
: {
requiredSources: reference.requiredSources.map((source) =>
select(source, slot.name),
),
}),
...(reference.fallbackSources === undefined
? {}
: {
fallbackSources: reference.fallbackSources.map((source) =>
select(source, slot.name),
),
}),
};
});
};
const referencedValues = (
node: t.Node,
path: PropertyPath,
effect: ValueEffect,
): readonly ReferencedValue[] => {
const [key, ...remaining] = path;
// An initializer owns its slots; only deeper writes can affect shared children.
if (t.isObjectExpression(node))
return path.length < 2
? []
: node.properties.flatMap<ReferencedValue>((property) => {
if (t.isSpreadElement(property))
return [{ node: property.argument, path }];
if (!t.isObjectProperty(property)) return [];
const name = semanticStaticPropertyKey(
property.key,
property.computed,
);
return key === null || name === null || String(key) === name
? [{ node: property.value, path: remaining }]
: [];
});
if (t.isArrayExpression(node)) {
if (path.length < 2) return [];
let uncertainIndex = false;
return node.elements.flatMap<ReferencedValue>((element, index) => {
if (element === null) return [];
if (t.isSpreadElement(element)) {
uncertainIndex = true;
return [{ node: element.argument, path: [null, ...remaining] }];
}
return uncertainIndex || key === null || String(key) === String(index)
? [{ node: element, path: remaining }]
: [];
});
if (t.isObjectExpression(node) || t.isArrayExpression(node)) {
if (effect === "write" && path.length < 2) return [];
return t.isObjectExpression(node)
? objectReferencedValues(node, path)
: arrayReferencedValues(node, path);
}
if (t.isAssignmentExpression(node))
return node.operator === "||=" || node.operator === "??="
? [
{ node: node.left, path },
{ node: node.right, path },
]
: [{ node: node.right, path }];
if (t.isAwaitExpression(node)) return [{ node: node.argument, path }];
if (t.isSequenceExpression(node)) {
const last = node.expressions.at(-1);
return last === undefined ? [] : [{ node: last, path }];
}
if (t.isConditionalExpression(node))
return [
@@ -244,7 +538,169 @@ const referencedValues = (
{ node: node.left, path },
{ node: node.right, path },
];
if (t.isAssignmentExpression(node, { operator: "&&=" }))
return [{ node: node.right, path }];
return [];
};
const objectReferencedValues = (
node: t.ObjectExpression,
path: PropertyPath,
): readonly ReferencedValue[] => {
const [key, ...remaining] = path;
const references: ReferencedValue[] = [];
const overwritten = new Set<string>();
for (const property of [...node.properties].reverse()) {
if (t.isSpreadElement(property)) {
const selected = key ?? null;
if (typeof selected !== "object" && overwritten.has(String(selected)))
continue;
references.push({
node: property.argument,
path: [
typeof selected === "object"
? {
...(selected ?? {}),
excludedKeys: [
...new Set([
...(selected?.excludedKeys ?? []),
...overwritten,
]),
].sort(compareUnicodeCodePoints),
}
: selected,
...remaining,
],
});
continue;
}
const name = semanticStaticPropertyKey(property.key, property.computed);
if (name !== null && overwritten.has(name)) continue;
if (
t.isObjectProperty(property) &&
(name === null || semanticPropertyPathKeyMatches(key ?? null, name))
)
references.push({ node: property.value, path: remaining });
// A prototype setter does not replace an own property from a spread.
if (
name !== null &&
!(t.isObjectMethod(property) && property.kind !== "method") &&
!(
t.isObjectProperty(property) &&
!property.computed &&
!property.shorthand &&
name === "__proto__"
)
)
overwritten.add(name);
}
return references;
};
const arrayReferencedValues = (
node: t.ArrayExpression,
path: PropertyPath,
): readonly ReferencedValue[] => {
const [key, ...remaining] = path;
const selected = key ?? null;
const selectedIndex =
typeof selected === "object" ? null : semanticArrayIndex(selected);
if (typeof selected !== "object" && selectedIndex === null) return [];
const references: ReferencedValue[] = [];
let minimumIndex = 0;
let uncertainIndex = false;
for (const element of node.elements) {
if (t.isSpreadElement(element)) {
if (selectedIndex === null || selectedIndex >= minimumIndex) {
let sourceKey: PropertyPath[number] = null;
if (!uncertainIndex) {
if (selectedIndex !== null) sourceKey = selectedIndex - minimumIndex;
else if (selected !== null && typeof selected === "object")
sourceKey = {
excludedKeys: selected.excludedKeys.flatMap((name) => {
const index = semanticArrayIndex(name);
return index === null || index < minimumIndex
? []
: [String(index - minimumIndex)];
}),
startIndex: Math.max(
0,
(selected.startIndex ?? 0) - minimumIndex,
),
};
}
references.push({
node: element.argument,
path: [sourceKey, ...remaining],
iterableFallbackPath: [],
});
}
uncertainIndex = true;
continue;
}
if (
element !== null &&
(uncertainIndex
? selectedIndex === null || selectedIndex >= minimumIndex
: semanticPropertyPathKeyMatches(selected, String(minimumIndex)))
)
references.push({ node: element, path: remaining });
minimumIndex++;
}
return references;
};
const copiedReferencePath = (
initializer: JavaScriptSemanticBindingState["referenceInitializers"][number],
path: PropertyPath,
effect: ValueEffect,
): PropertyPath | null => {
const offset = initializer.copyProjectionOffset;
if (offset === undefined) return [...initializer.projection, ...path];
const copiedPath = [...initializer.projection.slice(offset + 1), ...path];
if (effect === "write" && copiedPath.length < 2) return null;
let [key, ...remaining] = copiedPath;
if (initializer.copyKind === "array-rest") {
const startIndex = initializer.copyStartIndex ?? 0;
if (key === undefined || key === null)
key = { excludedKeys: [], startIndex };
else if (typeof key === "object")
key = {
excludedKeys: key.excludedKeys.flatMap((name) => {
const index = semanticArrayIndex(name);
return index === null ? [] : [String(index + startIndex)];
}),
startIndex: (key.startIndex ?? 0) + startIndex,
};
else {
const index = semanticArrayIndex(key);
if (index === null) return null;
key = index + startIndex;
}
} else {
const excludedKeys = initializer.copyExcludedKeys ?? [];
if (key === undefined || key === null) key = { excludedKeys };
else if (typeof key === "object")
key = {
...key,
excludedKeys: [...new Set([...key.excludedKeys, ...excludedKeys])].sort(
compareUnicodeCodePoints,
),
};
else if (excludedKeys.includes(String(key))) return null;
}
return [...initializer.projection.slice(0, offset), key, ...remaining];
};
const selectedReferenceSlot = (
source: { readonly node: t.Node; readonly projection: PropertyPath },
state: JavaScriptSemanticAnalysisState,
) => {
const path: string[] = [];
for (const key of source.projection) {
if (key === null || typeof key === "object") return undefined;
path.push(String(key));
}
return semanticSlotAtPath(
evaluateSemanticExpression(source.node, state),
path,
);
};
@@ -0,0 +1,63 @@
import * as t from "@babel/types";
import { describe, expect, it } from "vitest";
import { semanticMutationInitializers } from "./javascriptSemanticMutationInitializers.js";
import type { JavaScriptSemanticBindingState } from "./javascriptSemanticState.js";
import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
import { parseJavaScriptSource } from "./javascriptSourceParser.js";
describe("parameter references copied into function body bindings", () => {
it.each([
["var arg = []; mutate(arg);", false],
["mutate(arg); var arg = [];", true],
["if (flag) { var arg = []; } mutate(arg);", true],
])(
"retains the entry reference only when still reachable: %s",
(body, retained) => {
const program = parseJavaScriptSource(
`function result(arg = source) { ${body} }`,
)?.program;
const callable = program?.body[0];
if (program === undefined || !t.isFunctionDeclaration(callable))
throw new Error("Expected a parsed function declaration");
const parameter = callable.params[0];
if (!t.isAssignmentPattern(parameter) || !t.isIdentifier(parameter.left))
throw new Error("Expected the source parameter binding");
const parents = new WeakMap<t.Node, t.Node>();
let replacement: t.Node | undefined;
let mutation: t.Node | undefined;
traverseJavaScriptAst(program, {
enter: (node, parent) => {
if (parent !== null) parents.set(node, parent);
if (t.isVariableDeclarator(node) && node.init !== null)
replacement = node.init;
if (t.isCallExpression(node)) mutation = node;
},
});
if (replacement === undefined || mutation === undefined)
throw new Error("Expected a body initializer and subsequent effect");
const entry = {
node: parameter.left,
projection: [],
entryBody: callable.body,
};
const assigned = { node: replacement, projection: [] };
const binding: JavaScriptSemanticBindingState = {
bindingId: "body:arg",
scopeId: "body",
name: "arg",
kind: "variable",
mutable: true,
mutatedPaths: [],
escapedPaths: [],
definitions: [],
initializers: [entry, assigned],
referenceInitializers: [],
directOrigins: [],
};
const origins = semanticMutationInitializers(binding, mutation, parents);
expect(origins.initializers.includes(entry)).toBe(retained);
expect(origins.initializers).toContain(assigned);
},
);
});
@@ -0,0 +1,228 @@
import * as t from "@babel/types";
import { semanticStaticPropertyKey } from "./javascriptAstValues.js";
import type { JavaScriptSemanticBindingState } from "./javascriptSemanticState.js";
interface StatementPosition {
readonly body: readonly t.Statement[];
readonly index: number;
}
const statementPosition = (
statement: t.Statement,
parents: WeakMap<t.Node, t.Node>,
): StatementPosition | null => {
const parent = parents.get(statement);
if (!t.isProgram(parent) && !t.isBlockStatement(parent)) return null;
const index = parent.body.indexOf(statement);
return index < 0 ? null : { body: parent.body, index };
};
const directInitializerPosition = (
node: t.Node,
parents: WeakMap<t.Node, t.Node>,
): StatementPosition | null => {
const parent = parents.get(node);
if (t.isVariableDeclarator(parent) && parent.init === node) {
const declaration = parents.get(parent);
return t.isVariableDeclaration(declaration)
? statementPosition(declaration, parents)
: null;
}
if (
t.isAssignmentExpression(parent) &&
parent.operator === "=" &&
parent.right === node &&
t.isIdentifier(parent.left)
) {
const statement = parents.get(parent);
return t.isExpressionStatement(statement) && statement.expression === parent
? statementPosition(statement, parents)
: null;
}
return null;
};
const directMutationPosition = (
node: t.Node,
parents: WeakMap<t.Node, t.Node>,
): StatementPosition | null => {
if (t.isForOfStatement(node)) return statementPosition(node, parents);
if (t.isVariableDeclarator(node)) {
const declaration = parents.get(node);
return t.isVariableDeclaration(declaration)
? statementPosition(declaration, parents)
: null;
}
if (t.isSpreadElement(node)) {
const array = parents.get(node);
return t.isArrayExpression(array)
? semanticCapturePosition(array, parents)
: null;
}
if (
!t.isAssignmentExpression(node) &&
!t.isUpdateExpression(node) &&
!t.isUnaryExpression(node, { operator: "delete" }) &&
!t.isCallExpression(node) &&
!t.isOptionalCallExpression(node) &&
!t.isNewExpression(node) &&
!t.isTaggedTemplateExpression(node)
)
return null;
const statement = parents.get(node);
return t.isExpressionStatement(statement) && statement.expression === node
? statementPosition(statement, parents)
: null;
};
const referenceInitializerPosition = (
node: t.Node,
parents: WeakMap<t.Node, t.Node>,
): StatementPosition | null => {
// Defaults live inside the declaration pattern rather than its initializer.
let current = node;
while (true) {
const direct = directInitializerPosition(current, parents);
if (direct !== null) return direct;
const parent = parents.get(current);
if (parent === undefined || t.isStatement(parent) || t.isFunction(parent))
return null;
if (t.isVariableDeclarator(parent)) {
const declaration = parents.get(parent);
return t.isVariableDeclaration(declaration)
? statementPosition(declaration, parents)
: null;
}
current = parent;
}
};
/** Resolve origins at their use or capture, never at a later transitive effect. */
export const semanticMutationInitializers = (
binding: JavaScriptSemanticBindingState,
mutation: t.Node,
parents: WeakMap<t.Node, t.Node>,
): Pick<
JavaScriptSemanticBindingState,
"initializers" | "referenceInitializers"
> => {
const mutationPosition =
directMutationPosition(mutation, parents) ??
referenceInitializerPosition(mutation, parents);
if (mutationPosition === null) return binding;
const origins = [
...binding.initializers.map((initializer) => ({
initializer,
position:
initializer.entryBody === undefined
? directInitializerPosition(initializer.node, parents)
: { body: initializer.entryBody.body, index: -1 },
})),
...binding.referenceInitializers.map((initializer) => ({
initializer,
position: referenceInitializerPosition(initializer.node, parents),
})),
];
if (
origins.some(
({ position }) =>
position === null ||
position.body !== mutationPosition.body ||
position.index >= mutationPosition.index,
)
)
return binding;
const latestIndex = origins.reduce(
(latest, { position }) => Math.max(latest, position?.index ?? -1),
-1,
);
const retained = new Set(
origins
.filter(({ position }) => position?.index === latestIndex)
.map(({ initializer }) => initializer),
);
return {
initializers: binding.initializers.filter((initializer) =>
retained.has(initializer),
),
referenceInitializers: binding.referenceInitializers.filter((initializer) =>
retained.has(initializer),
),
};
};
/** Locate a capture only in an unconditional declaration or literal initializer. */
export const semanticCapturePosition = (
node: t.Node,
parents: WeakMap<t.Node, t.Node>,
): StatementPosition | null => {
let current = node;
while (true) {
const direct = directInitializerPosition(current, parents);
if (direct !== null) return direct;
const parent = parents.get(current);
if (
t.isObjectProperty(parent) &&
parent.value === current &&
semanticStaticPropertyKey(parent.key, parent.computed) !== null
)
current = parent;
else if (t.isObjectExpression(parent) || t.isArrayExpression(parent))
current = parent;
else return null;
}
};
/** Intermediate values must themselves have been initialized before capture. */
export const semanticBindingPrecedesCapture = (
binding: JavaScriptSemanticBindingState,
capture: t.Node,
parents: WeakMap<t.Node, t.Node>,
): boolean => {
const initializer = binding.initializers[0];
if (binding.initializers.length !== 1 || initializer === undefined)
return false;
const sourcePosition = directInitializerPosition(initializer.node, parents);
const capturePosition = semanticCapturePosition(capture, parents);
return (
sourcePosition !== null &&
capturePosition !== null &&
sourcePosition.body === capturePosition.body &&
sourcePosition.index < capturePosition.index
);
};
/** Ignore later escapes only while reading earlier references in one activation. */
export const semanticEscapeFollowsCapture = (
binding: JavaScriptSemanticBindingState,
capture: t.Node,
escape: t.Node | undefined,
parents: WeakMap<t.Node, t.Node>,
): boolean => {
const initializer = binding.initializers[0];
if (
escape === undefined ||
initializer === undefined ||
!semanticBindingPrecedesCapture(binding, capture, parents)
)
return false;
// A literal allocates here. Aliases are evaluated at the same capture point,
// so an outer/persistent origin still receives all of its own escape effects.
if (
!t.isObjectExpression(initializer.node) &&
!t.isArrayExpression(initializer.node) &&
!t.isIdentifier(initializer.node) &&
!t.isMemberExpression(initializer.node) &&
!t.isOptionalMemberExpression(initializer.node)
)
return false;
const capturePosition = semanticCapturePosition(capture, parents);
const escapePosition = directMutationPosition(escape, parents);
return (
capturePosition !== null &&
escapePosition !== null &&
capturePosition.body === escapePosition.body &&
capturePosition.index < escapePosition.index
);
};
@@ -1,9 +1,42 @@
import type { JavaScriptSemanticValue } from "./javascriptSemanticValueTypes.js";
import type {
JavaScriptSemanticProperty,
JavaScriptSemanticValue,
} from "./javascriptSemanticValueTypes.js";
import {
semanticPropertyPathKeyMatches,
type JavaScriptSemanticPropertyPath,
} from "./javascriptSemanticPropertyPaths.js";
/** Invalidate escaped object references without rewriting their containing slots. */
export const invalidateSemanticEscapedPath = (
value: JavaScriptSemanticValue,
path: JavaScriptSemanticPropertyPath,
): JavaScriptSemanticValue => {
if (value.status !== "object" && value.status !== "array") return value;
const [key, ...remaining] = path;
if (key === undefined)
return {
status: "unknown",
reason: "This object reference may have been mutated by a call.",
};
const invalidateChild = (
property: JavaScriptSemanticProperty,
): JavaScriptSemanticProperty =>
semanticPropertyPathKeyMatches(key, property.name)
? {
...property,
value: invalidateSemanticEscapedPath(property.value, remaining),
}
: property;
return value.status === "object"
? { ...value, properties: value.properties.map(invalidateChild) }
: { ...value, items: value.items.map(invalidateChild) };
};
/** Invalidate only slots that an explicit mutation can affect. */
export const invalidateSemanticMutationPath = (
value: JavaScriptSemanticValue,
path: readonly (string | number | null)[],
path: JavaScriptSemanticPropertyPath,
): JavaScriptSemanticValue => {
const [key, ...remaining] = path;
const unknown: JavaScriptSemanticValue = {
@@ -11,13 +44,20 @@ export const invalidateSemanticMutationPath = (
reason: "This property may have been mutated.",
};
if (key === undefined || key === null) return unknown;
if (value.status === "object") {
const name = String(key);
const observed = value.properties.some(
(property) => property.name === name,
if (value.status === "object" || value.status === "array") {
if (value.status === "array" && key === "length")
return {
status: "array",
items: [],
unknownItems: true,
omittedItems: null,
};
const slots = value.status === "object" ? value.properties : value.items;
const observed = slots.some((property) =>
semanticPropertyPathKeyMatches(key, property.name),
);
const properties = value.properties.map((property) =>
property.name === name
const properties = slots.map((property) =>
semanticPropertyPathKeyMatches(key, property.name)
? {
...property,
...(remaining.length === 0
@@ -27,37 +67,15 @@ export const invalidateSemanticMutationPath = (
}
: property,
);
if (!observed)
properties.push({ name, value: unknown, presence: "unknown-coverage" });
return { ...value, properties };
}
if (value.status === "array") {
const name = String(key);
// Array length writes can remove every index; ordinary named properties
// and sparse indices affect only their own slot.
if (name === "length")
return {
status: "array",
items: [],
unknownItems: true,
omittedItems: null,
};
const observed = value.items.some((item) => item.name === name);
const items = value.items.map((item) =>
item.name === name
? {
...item,
presence:
remaining.length === 0
? ("unknown-coverage" as const)
: item.presence,
value: invalidateSemanticMutationPath(item.value, remaining),
}
: item,
);
if (!observed)
items.push({ name, presence: "unknown-coverage", value: unknown });
return { ...value, items };
if (!observed && typeof key !== "object")
properties.push({
name: String(key),
value: unknown,
presence: "unknown-coverage",
});
return value.status === "object"
? { ...value, properties }
: { ...value, items: properties };
}
return unknown;
};
@@ -0,0 +1,37 @@
/** Slots retained by a shallow copy after exclusions or an array prefix. */
export interface JavaScriptSemanticPropertySelection {
readonly excludedKeys: readonly string[];
readonly startIndex?: number;
}
/** Internal mutation path, including selected children of a shallow copy. */
export type JavaScriptSemanticPropertyPath = readonly (
| string
| number
| null
| JavaScriptSemanticPropertySelection
)[];
/** Read only canonical JavaScript array indices, excluding named properties. */
export const semanticArrayIndex = (key: string | number): number | null => {
const index = Number(key);
return Number.isInteger(index) &&
index >= 0 &&
index < 4_294_967_295 &&
String(index) === String(key)
? index
: null;
};
/** Test an exact key, wildcard, or copied-slot selection against an own key. */
export const semanticPropertyPathKeyMatches = (
key: JavaScriptSemanticPropertyPath[number],
name: string,
): boolean => {
if (key === null) return true;
if (typeof key !== "object") return String(key) === name;
if (key.excludedKeys.includes(name)) return false;
if (key.startIndex === undefined) return true;
const index = semanticArrayIndex(name);
return index !== null && index >= key.startIndex;
};
@@ -1,5 +1,7 @@
import * as t from "@babel/types";
import type { JavaScriptSemanticPropertyPath } from "./javascriptSemanticPropertyPaths.js";
import type {
JavaScriptModuleOrigin,
JavaScriptSemanticDefinition,
@@ -15,6 +17,16 @@ interface JavaScriptSemanticInitializer {
readonly entryBody?: t.BlockStatement;
}
/** Additional references from destructuring copies and possible defaults. */
interface JavaScriptSemanticReferenceInitializer extends JavaScriptSemanticInitializer {
readonly copyKind?: "object-rest" | "array-rest";
readonly copyProjectionOffset?: number;
readonly copyExcludedKeys?: readonly string[];
readonly copyStartIndex?: number;
readonly fallbackSources?: readonly JavaScriptSemanticInitializer[];
readonly requiredSources?: readonly JavaScriptSemanticInitializer[];
}
/** Mutable binding state used only while constructing the immutable IR. */
export interface JavaScriptSemanticBindingState {
readonly bindingId: string;
@@ -22,9 +34,14 @@ export interface JavaScriptSemanticBindingState {
readonly name: string;
kind: JavaScriptSemanticDefinition["kind"];
mutable: boolean;
readonly mutatedPaths: (readonly (string | number | null)[])[];
readonly mutatedPaths: JavaScriptSemanticPropertyPath[];
readonly escapedPaths: {
readonly path: JavaScriptSemanticPropertyPath;
readonly node: t.Node | undefined;
}[];
readonly definitions: JavaScriptSemanticDefinition[];
readonly initializers: JavaScriptSemanticInitializer[];
readonly referenceInitializers: JavaScriptSemanticReferenceInitializer[];
readonly directOrigins: JavaScriptModuleOrigin[];
}
@@ -40,6 +57,7 @@ export interface JavaScriptSemanticScopeState {
/** Shared state for semantic collection and evaluation. */
export interface JavaScriptSemanticAnalysisState {
readonly parentsByNode: WeakMap<t.Node, t.Node>;
readonly scopes: JavaScriptSemanticScopeState[];
readonly scopesById: Map<string, JavaScriptSemanticScopeState>;
readonly scopeByNode: WeakMap<t.Node, JavaScriptSemanticScopeState>;
@@ -1,8 +1,17 @@
import * as t from "@babel/types";
import {
semanticCapturePosition,
semanticEscapeFollowsCapture,
semanticBindingPrecedesCapture,
} from "./javascriptSemanticMutationInitializers.js";
import { semanticSlotAtPath } from "./javascriptSemanticSlots.js";
import { invalidateSemanticMutationPath } from "./javascriptSemanticMutationValues.js";
import {
invalidateSemanticEscapedPath,
invalidateSemanticMutationPath,
} from "./javascriptSemanticMutationValues.js";
import type { JavaScriptBindingProvenance } from "./javascriptSemanticIr.js";
import type {
@@ -46,6 +55,7 @@ interface EvaluationContext {
readonly state: JavaScriptSemanticAnalysisState;
readonly bindings: ReadonlySet<string>;
readonly expressionDepth: number;
readonly capturePoint?: t.Node;
readonly primitiveBindingValues: Map<string, JavaScriptSemanticValue>;
}
@@ -54,6 +64,25 @@ const primitiveBindingValuesByState = new WeakMap<
Map<string, JavaScriptSemanticValue>
>();
const primitiveExpressionValuesByState = new WeakMap<
JavaScriptSemanticAnalysisState,
WeakMap<t.Node, JavaScriptSemanticValue>
>();
const capturedBindingValuesByState = new WeakMap<
JavaScriptSemanticAnalysisState,
WeakMap<t.Node, Map<string, JavaScriptSemanticValue>>
>();
/** Discard primitive projections evaluated before mutation collection finished. */
export const clearSemanticPrimitiveBindingValues = (
state: JavaScriptSemanticAnalysisState,
): void => {
primitiveBindingValuesByState.delete(state);
capturedBindingValuesByState.delete(state);
primitiveExpressionValuesByState.delete(state);
};
const primitiveBindingValuesFor = (
state: JavaScriptSemanticAnalysisState,
): Map<string, JavaScriptSemanticValue> => {
@@ -115,6 +144,20 @@ const evaluateBinding = (
): JavaScriptSemanticValue => {
if (context.bindings.has(binding.bindingId))
return { status: "cycle", reason: `Alias cycle at ${binding.name}.` };
if (
context.capturePoint !== undefined &&
!semanticBindingPrecedesCapture(
binding,
context.capturePoint,
context.state.parentsByNode,
)
) {
const { capturePoint: _capturePoint, ...liveContext } = context;
return evaluateBinding(binding, {
...liveContext,
primitiveBindingValues: primitiveBindingValuesFor(context.state),
});
}
const cached = context.primitiveBindingValues.get(binding.bindingId);
if (cached !== undefined) return cached;
if (binding.initializers.length === 0)
@@ -146,15 +189,41 @@ const evaluateBinding = (
if (initializer === undefined)
return { status: "unknown", reason: "Missing binding initializer." };
const nested = nestedContext(context, binding.bindingId);
const value = projectValue(
let value = projectValue(
evaluateExpression(initializer.node, nested),
initializer.projection,
);
const projected = binding.mutatedPaths.reduce(
if (!isPrimitive(value)) {
const captureContext = primitiveCaptureContext(initializer.node, nested);
if (captureContext !== undefined) {
const captured = projectValue(
evaluateExpression(initializer.node, captureContext),
initializer.projection,
);
if (isPrimitive(captured)) value = captured;
}
}
const mutated = binding.mutatedPaths.reduce(
invalidateSemanticMutationPath,
value,
);
const projected = binding.escapedPaths.reduce(
(value, escape) =>
context.capturePoint !== undefined &&
semanticEscapeFollowsCapture(
binding,
context.capturePoint,
escape.node,
context.state.parentsByNode,
)
? value
: invalidateSemanticEscapedPath(value, escape.path),
mutated,
);
// Point-local memoization also bounds failed speculative captures. Only a
// primitive result is allowed back into ordinary value evaluation.
if (
context.capturePoint !== undefined ||
projected.status === "literal" ||
projected.status === "union" ||
(isSemanticResourceLimit(projected) &&
@@ -301,7 +370,7 @@ const evaluateObject = (
name,
presence: "present",
value: t.isObjectProperty(property)
? evaluateExpression(property.value, nestedContext(context))
? evaluateCapturedExpression(property.value, nestedContext(context))
: {
status: "unknown",
reason: "Object method or accessor value is not a primitive.",
@@ -351,7 +420,7 @@ const evaluateArray = (
items.push({
name: String(items.length),
presence: "present",
value: evaluateExpression(element, nestedContext(context)),
value: evaluateCapturedExpression(element, nestedContext(context)),
});
}
return unknownItems
@@ -648,9 +717,68 @@ const nestedContext = (
): EvaluationContext => ({
state: context.state,
primitiveBindingValues: context.primitiveBindingValues,
...(context.capturePoint === undefined
? {}
: { capturePoint: context.capturePoint }),
expressionDepth: context.expressionDepth + 1,
bindings:
bindingId === undefined
? context.bindings
: new Set([...context.bindings, bindingId]),
});
const isPrimitive = (value: JavaScriptSemanticValue): boolean =>
value.status === "literal" || value.status === "union";
const primitiveCaptureContext = (
node: t.Node,
context: EvaluationContext,
): EvaluationContext | undefined => {
if (
context.capturePoint !== undefined ||
t.isObjectExpression(node) ||
t.isArrayExpression(node) ||
semanticCapturePosition(node, context.state.parentsByNode) === null
)
return undefined;
let captures = capturedBindingValuesByState.get(context.state);
if (captures === undefined) {
captures = new WeakMap();
capturedBindingValuesByState.set(context.state, captures);
}
let values = captures.get(node);
if (values === undefined) {
values = new Map();
captures.set(node, values);
}
return { ...context, capturePoint: node, primitiveBindingValues: values };
};
const evaluateCapturedExpression = (
node: t.Node,
context: EvaluationContext,
): JavaScriptSemanticValue => {
// A literal field captures its primitive at construction, even when its
// containing object is subsequently read at another capture point.
let values = primitiveExpressionValuesByState.get(context.state);
const cached = values?.get(node);
if (cached !== undefined) return cached;
let value = evaluateExpression(node, context);
if (!isPrimitive(value)) {
const captureContext = primitiveCaptureContext(node, context);
if (captureContext !== undefined) {
const captured = evaluateExpression(node, captureContext);
if (isPrimitive(captured)) value = captured;
}
}
// Never publish values evaluated at somebody else's capture point. Like
// binding caches, these entries are discarded whenever effects change.
if (context.capturePoint === undefined && isPrimitive(value)) {
if (values === undefined) {
values = new WeakMap();
primitiveExpressionValuesByState.set(context.state, values);
}
values.set(node, value);
}
return value;
};