Skip to content

Commit 92bb890

Browse files
author
idfunctor
committed
fix(signals): avoid evaluating getters in attribution comparisons
1 parent 50dec1b commit 92bb890

4 files changed

Lines changed: 175 additions & 7 deletions

File tree

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,5 @@
1+
---
2+
"@solidjs/signals": patch
3+
---
4+
5+
Avoid evaluating property getters when attribution compares memo outputs and list items for unstable identity diagnostics.

‎packages/signals/src/core/attribution.ts‎

Lines changed: 10 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -1743,26 +1743,30 @@ function isPlainShape(v: unknown): v is object {
17431743

17441744
/** Shallow structural equivalence, capped so hot paths stay cheap. */
17451745
const UNSTABLE_KEY_CAP = 64;
1746+
function equivalentDataProperty(a: object, b: object, key: PropertyKey): boolean {
1747+
const left = Object.getOwnPropertyDescriptor(a, key);
1748+
const right = Object.getOwnPropertyDescriptor(b, key);
1749+
if (!left || !right) return !left && !right;
1750+
// Accessors are not passive metadata: reading one can run user code.
1751+
return "value" in left && "value" in right && left.value === right.value;
1752+
}
1753+
17461754
function shallowEquivalent(a: object, b: object): boolean {
17471755
const aArr = Array.isArray(a);
17481756
if (aArr !== Array.isArray(b)) return false;
17491757
if (aArr) {
17501758
const arrA = a as unknown[];
17511759
const arrB = b as unknown[];
17521760
if (arrA.length !== arrB.length || arrA.length > UNSTABLE_KEY_CAP) return false;
1753-
for (let i = 0; i < arrA.length; i++) if (arrA[i] !== arrB[i]) return false;
1761+
for (let i = 0; i < arrA.length; i++) if (!equivalentDataProperty(a, b, i)) return false;
17541762
return true;
17551763
}
17561764
// Every own key, symbols included: a symbol-keyed box holding a fresh value
17571765
// each run (web's `dynamic` boxes its in-flight promise) is not equivalent.
17581766
const keys = Reflect.ownKeys(a);
17591767
if (keys.length > UNSTABLE_KEY_CAP || keys.length !== Reflect.ownKeys(b).length) return false;
17601768
for (const key of keys) {
1761-
if (
1762-
!(key in b) ||
1763-
(a as Record<PropertyKey, unknown>)[key] !== (b as Record<PropertyKey, unknown>)[key]
1764-
)
1765-
return false;
1769+
if (!equivalentDataProperty(a, b, key)) return false;
17661770
}
17671771
return true;
17681772
}

‎packages/signals/tests/attribution-list-identity.test.ts‎

Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -91,6 +91,34 @@ describe("UNSTABLE_LIST_IDENTITY", () => {
9191
expect(hits).toHaveLength(1);
9292
});
9393

94+
it("does not evaluate accessors while comparing rows", () => {
95+
const hits = arm();
96+
const getter = vi.fn(() => "lazy");
97+
const records = () =>
98+
rows(10).map(row =>
99+
Object.defineProperty(row, "children", {
100+
enumerable: true,
101+
get: getter
102+
})
103+
);
104+
const [items, setItems] = createSignal(records());
105+
const dispose = createRoot(dispose => {
106+
const mapped = mapArray(items, item => item.id, { name: "rows" });
107+
createMemo(() => mapped().length);
108+
return dispose;
109+
});
110+
try {
111+
flush();
112+
setItems(records());
113+
flush();
114+
115+
expect(getter).not.toHaveBeenCalled();
116+
expect(hits).toHaveLength(0);
117+
} finally {
118+
dispose();
119+
}
120+
});
121+
94122
it("does not report a list keyed by a stable field", () => {
95123
const hits = arm();
96124
const { setItems, count } = listFixture(item => item.id);

‎packages/signals/tests/attribution-unstable-memo.test.ts‎

Lines changed: 132 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,12 +1,15 @@
11
import { afterEach, describe, expect, it, vi } from "vitest";
22
import { attribution } from "../src/attribution.js";
33
import {
4+
createContext,
45
createEffect,
56
createMemo,
67
createRoot,
78
createSignal,
89
flush,
9-
OBSERVE
10+
getContext,
11+
OBSERVE,
12+
setContext
1013
} from "../src/index.js";
1114
import type { DiagnosticEvent } from "../src/core/dev.js";
1215

@@ -79,6 +82,134 @@ describe("UNSTABLE_MEMO_OUTPUT", () => {
7982
expect(events[0].data).toMatchObject({ shape: "array" });
8083
});
8184

85+
it.each(["object", "symbol", "array"])("does not evaluate %s accessors", shape => {
86+
const getter = vi.fn(() => "lazy");
87+
const events = captureUnstable();
88+
const [n, setN] = createSignal(0);
89+
const key = shape === "symbol" ? Symbol("children") : shape === "array" ? "0" : "children";
90+
const dispose = createRoot(dispose => {
91+
const view = createMemo(() => {
92+
n();
93+
return Object.defineProperty(shape === "array" ? [] : {}, key, {
94+
enumerable: true,
95+
get: getter
96+
});
97+
});
98+
createEffect(view, () => {});
99+
return dispose;
100+
});
101+
try {
102+
flush();
103+
for (let i = 1; i <= 8; i++) {
104+
setN(i);
105+
flush();
106+
}
107+
108+
expect(getter).not.toHaveBeenCalled();
109+
expect(events).toHaveLength(0);
110+
} finally {
111+
dispose();
112+
}
113+
});
114+
115+
it.each([false, true])("leaves lazy context reads alone with attribution=%s", enabled => {
116+
if (enabled) captureUnstable();
117+
const context = createContext<string>();
118+
const [n, setN] = createSignal(0);
119+
const getter = vi.fn(() => getContext(context));
120+
const dispose = createRoot(dispose => {
121+
setContext(context, "provided");
122+
expect(getContext(context)).toBe("provided");
123+
const view = createMemo(() => {
124+
n();
125+
return {
126+
get children() {
127+
return getter();
128+
}
129+
};
130+
});
131+
createEffect(view, () => {});
132+
return dispose;
133+
});
134+
try {
135+
flush();
136+
setN(1);
137+
expect(() => flush()).not.toThrow();
138+
expect(getter).not.toHaveBeenCalled();
139+
} finally {
140+
dispose();
141+
}
142+
});
143+
144+
it("does not evaluate inherited array-index accessors", () => {
145+
const getter = vi.fn(() => "inherited");
146+
const prototype = Object.create(Array.prototype, { 0: { get: getter } });
147+
const events = captureUnstable();
148+
const [n, setN] = createSignal(0);
149+
const dispose = createRoot(dispose => {
150+
const view = createMemo(() => {
151+
n();
152+
return Object.setPrototypeOf(new Array(1), prototype);
153+
});
154+
createEffect(view, () => {});
155+
return dispose;
156+
});
157+
try {
158+
flush();
159+
for (let i = 1; i <= 8; i++) {
160+
setN(i);
161+
flush();
162+
}
163+
164+
expect(getter).not.toHaveBeenCalled();
165+
expect(events).toHaveLength(1);
166+
} finally {
167+
dispose();
168+
}
169+
});
170+
171+
it("distinguishes array holes from own undefined values", () => {
172+
const events = captureUnstable();
173+
const [n, setN] = createSignal(0);
174+
const dispose = createRoot(dispose => {
175+
const view = createMemo(() => (n() % 2 ? [undefined] : new Array(1)));
176+
createEffect(view, () => {});
177+
return dispose;
178+
});
179+
try {
180+
flush();
181+
for (let i = 1; i <= 8; i++) {
182+
setN(i);
183+
flush();
184+
}
185+
186+
expect(events).toHaveLength(0);
187+
} finally {
188+
dispose();
189+
}
190+
});
191+
192+
it("compares null-prototype objects", () => {
193+
const events = captureUnstable();
194+
const [n, setN] = createSignal(0);
195+
const dispose = createRoot(dispose => {
196+
const view = createMemo(() => (n(), Object.assign(Object.create(null), { on: true })));
197+
createEffect(view, () => {});
198+
return dispose;
199+
});
200+
try {
201+
flush();
202+
for (let i = 1; i <= 8; i++) {
203+
setN(i);
204+
flush();
205+
}
206+
207+
expect(events).toHaveLength(1);
208+
} finally {
209+
dispose();
210+
}
211+
});
212+
82213
it("resets the streak when the output genuinely changes", () => {
83214
const [n, setN] = createSignal(0, { name: "n" });
84215
// Content changes every third run — streak never reaches the threshold.

0 commit comments

Comments
 (0)