fix(javascript): retain array-pattern iterator close effects (#12534)

* fix(javascript): retain array-pattern iterator close effects

* fix(javascript): bound array-pattern close exposure

* fix(javascript): follow stored array elements at iterator close

* fix(javascript): retain iterator closes before array rest
This commit is contained in:
morluto authored and GitHub committed 2026-11-19 21:57:50 +00:00
1 parent 756f772430
commit 8ef5a34ff5
9 files changed
+601 -49

No files matched your search

@@ -1117,3 +1117,370 @@ it.each([
).toEqual(path);
},
);
const closeHandler =
"function () { delete this.next().value.mode; return {}; }";
it.each([
["native close", "", "resolved"],
[
"direct Array Iterator prototype",
"Object.getPrototypeOf([].values()).return = " + closeHandler + ";",
"candidate",
],
[
"captured Array Iterator prototype",
"const iterator=[].values(); const p=Object.getPrototypeOf(iterator); p.return = " +
closeHandler +
";",
"candidate",
],
[
"inherited Iterator prototype",
"Object.getPrototypeOf(Object.getPrototypeOf([].values())).return = " +
closeHandler +
";",
"candidate",
],
[
"global Iterator prototype",
"Iterator.prototype.return = " + closeHandler + ";",
"candidate",
],
[
"inherited Object prototype",
"Object.prototype.return = " + closeHandler + ";",
"candidate",
],
[
"unrelated Array prototype",
"Array.prototype.return = " + closeHandler + ";",
"resolved",
],
] as const)(
"tracks a nested array-pattern close through %s",
(_name, hook, resolution) => {
const graph = graphForJavaScript(`
const box={label:"ready",items:[0,{mode:"before"}]};
${hook}
const {label:before,items:[first],items:{0:primitive,1:{mode:selected}}}=box;
`);
const edge = (name: string) => {
const binding = graph.nodes.find(
(n) => n.kind === "binding" && n.label === name,
);
return graph.relations.find(
(r) =>
r.relation === "destructures" &&
r.target_node_id === binding?.node_id,
);
};
expect(edge("before")).toMatchObject({ resolution: "resolved" });
expect(edge("primitive")).toMatchObject({ resolution: "resolved" });
expect(edge("selected")).toMatchObject({ resolution });
},
);
it.each([
[
"hook before read",
`Object.getPrototypeOf([].values()).return = ${closeHandler};`,
"",
"candidate",
],
[
"hook after read",
"",
`Object.getPrototypeOf([].values()).return = ${closeHandler};`,
"resolved",
],
] as const)(
"preserves outer iterator close timing for %s",
(_name, before, after, resolution) => {
const graph = graphForJavaScript(`
const box=[0,{mode:"before"}];
${before}
const [first]=box;
const {1:{mode:selected}}=box;
${after}
`);
for (const [name, expected] of [
["first", "resolved"],
["selected", resolution],
]) {
const binding = graph.nodes.find(
(n) => n.kind === "binding" && n.label === name,
);
expect(
graph.relations.find(
(r) =>
r.relation === "destructures" &&
r.target_node_id === binding?.node_id,
),
).toMatchObject({ resolution: expected });
}
},
);
it.each([
["empty pattern", "", "candidate"],
["rest drains iterator", "...rest", "resolved"],
] as const)("preserves close presence for %s", (_name, pattern, resolution) => {
const graph = graphForJavaScript(`
const box={items:[{mode:"before"}]};
Object.getPrototypeOf([].values()).return = ${closeHandler};
const {items:[${pattern}],items:{0:{mode:selected}}}=box;
`);
const selected = graph.nodes.find(
(n) => n.kind === "binding" && n.label === "selected",
);
expect(
graph.relations.find(
(r) =>
r.relation === "destructures" && r.target_node_id === selected?.node_id,
),
).toMatchObject({ resolution });
});
const closeNextObject =
"Object.getPrototypeOf([].values()).return=function(){const next=this.next().value;if(next)delete next.mode;return {}};";
it.each([
[
"unconsumed suffix",
'const items=[{mode:"first"},{mode:"second"}];',
"const [used]=items;",
"resolved",
"candidate",
],
[
"shared element identity",
'const value={mode:"shared"};const items=[value,value];',
"const [used]=items;",
"candidate",
"candidate",
],
[
"all slots consumed",
'const items=[{mode:"first"},{mode:"second"}];',
"const [used,alsoUsed]=items;",
"resolved",
"resolved",
],
[
"native exhaustion observed",
'const items=[{mode:"first"},{mode:"second"}];',
"const [used,alsoUsed,done]=items;",
"resolved",
"resolved",
],
[
"earlier default",
'const items=[undefined,{mode:"second"}];',
'const [used=(items.push({mode:"added"}),0)]=items;',
"candidate",
"candidate",
],
] as const)(
"bounds native close exposure for %s",
(_name, setup, pattern, first, second) => {
const graph = graphForJavaScript(`
${setup}
${closeNextObject}
${pattern}
const {0:{mode:first},1:{mode:second}}=items;
`);
for (const [name, resolution] of [
["first", first],
["second", second],
]) {
const binding = graph.nodes.find(
(n) => n.kind === "binding" && n.label === name,
);
expect(
graph.relations.find(
(r) =>
r.relation === "destructures" &&
r.target_node_id === binding?.node_id,
),
).toMatchObject({ resolution });
}
},
);
it.each([
[
"earlier declarator",
"const {1:{mode:selected}}=items,[used]=items;",
"resolved",
],
[
"later declarator",
"const [used]=items,{1:{mode:selected}}=items;",
"candidate",
],
[
"earlier assignment",
"let selected,used; (({1:{mode:selected}}=items),[used]=items);",
"resolved",
],
[
"later assignment",
"let selected,used; ([used]=items,({1:{mode:selected}}=items));",
"candidate",
],
] as const)(
"orders a native close relative to an %s",
(_name, pattern, resolution) => {
const graph = graphForJavaScript(`
const items=[0,{mode:"inherited"}]; ${closeNextObject}
${pattern}
`);
const binding = graph.nodes.find(
(n) => n.kind === "binding" && n.label === "selected",
);
expect(
graph.relations.find(
(r) =>
r.relation === "destructures" &&
r.target_node_id === binding?.node_id,
),
).toMatchObject({ resolution });
},
);
it.each([
[
"after close",
"items:[used], missing=(Object.getPrototypeOf([].values()).return=hook)",
"resolved",
],
[
"before close",
"missing=(Object.getPrototypeOf([].values()).return=hook), items:[used]",
"candidate",
],
] as const)(
"keeps a hook assigned by a default %s in order",
(_name, prefix, resolution) => {
const graph = graphForJavaScript(`
const box={items:[0,{mode:"initial"}]};
function hook(){const next=this.next().value;if(next)delete next.mode;return {};}
const {${prefix}, items:{1:{mode:selected}}}=box;
`);
const binding = graph.nodes.find(
(n) => n.kind === "binding" && n.label === "selected",
);
expect(
graph.relations.find(
(r) =>
r.relation === "destructures" &&
r.target_node_id === binding?.node_id,
),
).toMatchObject({ resolution });
},
);
it.each([
["before close", "none=(box.items[1]=box.next), items:[used]", "candidate"],
["after close", "items:[used], none=(box.items[1]=box.next)", "resolved"],
] as const)(
"follows an array-pattern close through a slot assigned %s",
(_name, prefix, resolution) => {
const graph = graphForJavaScript(`
const box={items:[0],next:{mode:"second"}};
${closeNextObject}
const {${prefix},next:{mode:selected}}=box;
`);
const selected = graph.nodes.find(
(n) => n.kind === "binding" && n.label === "selected",
);
expect(
graph.relations.find(
(r) =>
r.relation === "destructures" &&
r.target_node_id === selected?.node_id,
),
).toMatchObject({ resolution });
},
);
it("keeps consumed objects uncertain when an earlier default also stores them in the suffix", () => {
const graph = graphForJavaScript(`
const box={items:[{mode:"first"}]};
${closeNextObject}
const {none=(box.items[1]=box.items[0]),items:[used],items:{0:{mode:selected}}}=box;
`);
const selected = graph.nodes.find(
(n) => n.kind === "binding" && n.label === "selected",
);
expect(
graph.relations.find(
(r) =>
r.relation === "destructures" && r.target_node_id === selected?.node_id,
),
).toMatchObject({ resolution: "candidate" });
});
it.each([
[
"throwing default",
"undefined,",
"const [first = null.value, ...rest] = items;",
"1",
"candidate",
],
[
"plain lexical prefix",
"undefined,",
"const [first, ...rest] = items;",
"1",
"resolved",
],
[
"known unused default",
"0,",
"const [first = null.value, ...rest] = items;",
"1",
"resolved",
],
[
"nested target that throws",
"null,",
"const [{first}, ...rest] = items;",
"1",
"candidate",
],
[
"immutable assignment target",
"0,",
"const first = 0; let rest; [first, ...rest] = items;",
"1",
"candidate",
],
[
"computed rest target that throws before draining",
"",
"const target = {}; [...target[null.value]] = items;",
"0",
"candidate",
],
] as const)(
"models a native close before rest for %s",
(_name, prefix, pattern, key, resolution) => {
const graph = graphForJavaScript(`
const items=[${prefix}{mode:"before"}];
Object.getPrototypeOf([].values()).return = ${closeHandler};
try { ${pattern} } catch {}
const {${key}:{mode:selected}}=items;
`);
const selected = graph.nodes.find(
(n) => n.kind === "binding" && n.label === "selected",
);
expect(
graph.relations.find(
(r) =>
r.relation === "destructures" &&
r.target_node_id === selected?.node_id,
),
).toMatchObject({ resolution });
},
);