Backtestsvuerun-20261013-093701#15496
looseEqual: comparing Map/Set values with circular references throws RangeError (regression in 3.5.42)
Our patch was judged better than the merged fix.
In this judgment, Patch A = our agent, Patch B = the merged fix.
Both patches fix the root cause the same basic way. Each threads comparison state through the recursion and tracks pairs only while their comparison is on the stack. So both terminate on the issue's three repro shapes (mutual-peer Sets, cyclic Maps, self-containing Sets) and return true for structurally identical cyclic collections. Both also cover cyclic plain objects and arrays. Correctness differences: - Patch A uses co-inductive semantics: a pair already under comparison is assumed equal, and the outer comparison catches any real difference. It removes pairs in a `finally`, so a failed Set-candidate probe never leaks an unproven assumption into later comparisons. A dedicated test (`does not reuse assumptions from failed set candidate matches`) checks exactly that subtle case, and tracing it confirms it behaves correctly. - Patch B enforces a bijection: on re-encounter, the mapping must match in both directions. This is stricter. It returns false for some structurally equivalent but differently shaped cycles, such as a 1-cycle vs a 2-cycle. That is defensible, but it is a semantic choice the issue didn't ask for, and it could reject candidates during nested Set probing that the looser rule would accept. - Patch B also changes the exported signature of `looseEqual` to take an optional third `seen` parameter. That leaks internal state into the public API and is a hazard if `looseEqual` is ever passed directly as a callback, e.g. to `findIndex`, which supplies an index as the third argument. Patch A keeps the public signature intact and routes through a private `baseLooseEqual`. Tests: Patch A adds unit tests for cyclic Sets, Maps, objects and arrays, with both positive and negative assertions. It also adds component-level `vModel` tests that reproduce the issue's actual `<select v-model>` scenario and assert the correct `selectedIndex`. Patch B adds unit tests only, including a reasonable symmetry test, but nothing at the runtime-dom level where the regression was reported. Scope and craft: Patch A's change is small: a helper that wraps each composite comparison, with clear comments explaining why the assumption is sound. Patch B restructures more code, moving the Map/Set dispatch into a new `looseCompareObjects`, and widens the public API. Overall Patch A is the safer, better-tested fix.
The judge saw only the two patches, labelled A and B in random order, with issue links and version numbers removed. The reasoning above is shown verbatim.
Solve
5m 12s
Wall-clock time in the container
Full test suite
No new failures
3,747 passed · 6 skipped · 3,753 total
Contamination audit
Clean
No sign the agent saw the real fix
Patch size
214vs 138 merged
Changed lines, ours vs merged
The issue
View on GitHubVue version
3.5.42 (also reproduced on current main, commit 5409708)
Link to minimal reproduction
Steps to reproduce
Open the reproduction above: a <select v-model> whose option :values are Sets containing mutually-referencing objects. The component throws during mount, before any interaction.
<script setup>
import { ref } from 'vue'
const makeGraph = () => {
const n1 = { id: 1 }
const n2 = { id: 2 }
n1.peer = n2
n2.peer = n1 // circular reference
return new Set([n1, n2])
}
const optA = makeGraph()
const optB = makeGraph()
const selected = ref(optB)
</script>
<template>
<select v-model="selected">
<option :value="optA">A</option>
<option :value="optB">B</option>
</select>
</template>
What is expected?
Mounting the select should not throw. looseEqual should safely terminate on cyclic structures (e.g. by tracking already-visited pairs) and return true for two structurally identical cyclic Sets/Maps.
What is actually happening?
Mounting throws RangeError: Maximum call stack size exceeded:
RangeError: Maximum call stack size exceeded
at looseCompareCollections (packages/shared/src/looseEqual.ts:16)
at looseEqual (packages/shared/src/looseEqual.ts:64)
at looseCompareCollections (packages/shared/src/looseEqual.ts:22)
at looseEqual (packages/shared/src/looseEqual.ts:64)
...
[Vue warn]: Unhandled error during execution of directive hook
System Info
Reproduced locally with vuejs/core@main (5409708) via vitest: both the unit-level looseEqual calls and the component-level render path (same shape as the test added in #15328) throw RangeError.
Any additional comments?
This is a regression introduced by #15328 ("fix(shared): correctly compare Map and Set values", released in v3.5.42), which added looseCompareCollections in packages/shared/src/looseEqual.ts:
function looseCompareCollections(
a: Map<any, any> | Set<any>,
b: Map<any, any> | Set<any>,
) {
if (a.size !== b.size) return false
const candidates = Array.from(b)
const matched = new Uint8Array(candidates.length)
for (const item of a) {
let index = -1
for (let i = 0; i < candidates.length; i++) {
if (!matched[i] && looseEqual(item, candidates[i])) {
index = i
break
}
}
if (index < 0) return false
matched[index] = 1
}
return true
}
looseEqual(item, candidates[i]) recurses into each [key, value] pair (Map) or element (Set), so a Map/Set whose entries point back to the collection itself or to each other causes unbounded recursion. Before 3.5.42, Maps/Sets never recursed into their entries (they fell through to String() comparison), so this exact code path — a <select v-model> with Map/Set values, which is precisely the scenario #15320/#15328 added support for — did not throw on 3.5.41; it silently compared wrong, which #15328 fixed.
Note: #5318 covers the same root cause for cyclic plain objects (pre-existing, still open). The Map/Set case is new in 3.5.42: cyclic Maps/Sets did not throw before.
Suggested fix: make looseEqual cycle-safe by tracking visited (a, b) pairs (e.g. with a WeakMap<object, Set<object>> and returning true on re-encounter), which also fixes #5318.
Additional local repro cases that all throw RangeError on current main:
looseEqual(new Set([a1, a2]), new Set([b1, b2]))wherea1.peer = a2; a2.peer = a1andb1.peer = b2; b2.peer = b1looseEqual(mapA, mapB)where both maps hold mutually-referencing valueslooseEqual(s1, s2)wheres1.add(s1)ands2.add(s2)
The two patches
packages/runtime-dom/__tests__/directives/vModel.spec.tsindex a94cb8e0d..a44cfb191 100644@@ -1902,4 +1902,66 @@ describe('vModel', () => { expect(root.querySelector('select').selectedIndex).toBe(1) })+ it('selects the matching option when values are sets with circular references', () => {+ const makeGraph = (id: number) => {+ const n1: any = { id }+ const n2: any = { id: id + 1 }+ n1.peer = n2+ n2.peer = n1+ return new Set([n1, n2])+ }+ const setA = makeGraph(1)+ const setB = makeGraph(10)+ const value = ref(makeGraph(10))+ const component = defineComponent(+ () => () =>+ withVModel(+ h(+ 'select',+ {+ 'onUpdate:modelValue': (val: Set<any>) => (value.value = val),+ },+ [+ h('option', { value: setA }, 'A'),+ h('option', { value: setB }, 'B'),+ ],+ ),+ value.value,+ ),+ )++ expect(() => render(h(component), root)).not.toThrow()+ expect(root.querySelector('select').selectedIndex).toBe(1)+ })++ it('selects the matching option when values are maps with circular references', () => {+ const makeMap = (id: number) => {+ const map = new Map<string, any>([['id', id]])+ map.set('self', map)+ return map+ }+ const mapA = makeMap(1)+ const mapB = makeMap(2)+ const value = ref(makeMap(2))+ const component = defineComponent(+ () => () =>+ withVModel(+ h(+ 'select',+ {+ 'onUpdate:modelValue': (val: Map<string, any>) =>+ (value.value = val),+ },+ [+ h('option', { value: mapA }, 'A'),+ h('option', { value: mapB }, 'B'),+ ],+ ),+ value.value,+ ),+ )++ expect(() => render(h(component), root)).not.toThrow()+ expect(root.querySelector('select').selectedIndex).toBe(1)+ }) })packages/shared/__tests__/looseEqual.spec.tsindex 777f3cfad..93138c875 100644@@ -288,4 +288,79 @@ describe('utils/looseEqual', () => { expect(looseEqual(new Set<any>([1, '1']), new Set<any>([1, 2]))).toBe(false) expect(looseEqual(new Set(), new Map())).toBe(false) })+ test('compares sets with circular references', () => {+ const makeGraph = (id: number) => {+ const n1: any = { id }+ const n2: any = { id: id + 1 }+ n1.peer = n2+ n2.peer = n1+ return new Set([n1, n2])+ }+ expect(looseEqual(makeGraph(1), makeGraph(1))).toBe(true)+ expect(looseEqual(makeGraph(1), makeGraph(2))).toBe(false)++ const s1 = new Set<any>()+ s1.add(s1)+ const s2 = new Set<any>()+ s2.add(s2)+ expect(looseEqual(s1, s2)).toBe(true)+ s2.add(1)+ expect(looseEqual(s1, s2)).toBe(false)+ })++ test('compares maps with circular references', () => {+ const makeMap = (id: number) => {+ const a: any = { id }+ const b: any = { id: id + 1 }+ a.peer = b+ b.peer = a+ const map = new Map<any, any>([+ ['a', a],+ ['b', b],+ ])+ map.set('self', map)+ return map+ }+ expect(looseEqual(makeMap(1), makeMap(1))).toBe(true)+ expect(looseEqual(makeMap(1), makeMap(2))).toBe(false)+ })++ // #5318+ test('compares objects and arrays with circular references', () => {+ const makeObj = (id: number) => {+ const obj: any = { id, list: [] }+ obj.self = obj+ obj.list.push(obj, obj.list)+ return obj+ }+ expect(looseEqual(makeObj(1), makeObj(1))).toBe(true)+ expect(looseEqual(makeObj(1), makeObj(2))).toBe(false)++ const a: any = [1]+ a.push(a)+ const b: any = [1]+ b.push(b)+ expect(looseEqual(a, b)).toBe(true)+ b[0] = 2+ expect(looseEqual(a, b)).toBe(false)+ })++ test('does not reuse assumptions from failed set candidate matches', () => {+ // `self` is visited before `v`, so comparing x with y crosses the cycle+ // and only fails afterwards+ const x: any = { self: null, v: 1 }+ x.self = x+ const y: any = { self: null, v: 2 }+ y.self = y+ // probing p against r fails on (x, y); that pair must not be treated as+ // equal later when q is compared against r+ const p = { k: x, t: 'a' }+ const q = { k: x, t: 'a' }+ const r = { k: y, t: 'a' }+ const s = { k: x, t: 'a' }+ expect(looseEqual(new Set([p, q]), new Set([r, s]))).toBe(false)+ expect(looseEqual(new Set([p, q]), new Set([s, { k: x, t: 'a' }]))).toBe(+ true,+ )+ }) })packages/shared/src/looseEqual.tsindex d037b0a57..072ff3e61 100644@@ -1,10 +1,14 @@ import { isArray, isDate, isMap, isObject, isSet, isSymbol } from './general' -function looseCompareArrays(a: any[], b: any[]) {+// pairs of objects currently being compared further up the recursion stack,+// used to terminate on cyclic structures+type SeenPairs = Map<object, Set<object>>++function looseCompareArrays(a: any[], b: any[], seen: SeenPairs) { if (a.length !== b.length) return false let equal = true for (let i = 0; equal && i < a.length; i++) {- equal = looseEqual(a[i], b[i])+ equal = baseLooseEqual(a[i], b[i], seen) } return equal }@@ -12,6 +16,7 @@ function looseCompareArrays(a: any[], b: any[]) { function looseCompareCollections( a: Map<any, any> | Set<any>, b: Map<any, any> | Set<any>,+ seen: SeenPairs, ) { if (a.size !== b.size) return false const candidates = Array.from(b)@@ -19,7 +24,7 @@ function looseCompareCollections( for (const item of a) { let index = -1 for (let i = 0; i < candidates.length; i++) {- if (!matched[i] && looseEqual(item, candidates[i])) {+ if (!matched[i] && baseLooseEqual(item, candidates[i], seen)) { index = i break }@@ -31,6 +36,10 @@ function looseCompareCollections( } export function looseEqual(a: any, b: any): boolean {+ return baseLooseEqual(a, b, new Map())+}++function baseLooseEqual(a: any, b: any, seen: SeenPairs): boolean { if (a === b) return true let aValidType = isDate(a) let bValidType = isDate(b)@@ -45,7 +54,9 @@ export function looseEqual(a: any, b: any): boolean { aValidType = isArray(a) bValidType = isArray(b) if (aValidType || bValidType) {- return aValidType && bValidType ? looseCompareArrays(a, b) : false+ return aValidType && bValidType+ ? withSeen(a, b, seen, () => looseCompareArrays(a, b, seen))+ : false } aValidType = isObject(a) bValidType = isObject(b)@@ -56,33 +67,67 @@ export function looseEqual(a: any, b: any): boolean { aValidType = isMap(a) bValidType = isMap(b) if (aValidType || bValidType) {- return aValidType && bValidType ? looseCompareCollections(a, b) : false+ return aValidType && bValidType+ ? withSeen(a, b, seen, () => looseCompareCollections(a, b, seen))+ : false } aValidType = isSet(a) bValidType = isSet(b) if (aValidType || bValidType) {- return aValidType && bValidType ? looseCompareCollections(a, b) : false+ return aValidType && bValidType+ ? withSeen(a, b, seen, () => looseCompareCollections(a, b, seen))+ : false } const aKeysCount = Object.keys(a).length const bKeysCount = Object.keys(b).length if (aKeysCount !== bKeysCount) { return false }- for (const key in a) {- const aHasKey = a.hasOwnProperty(key)- const bHasKey = b.hasOwnProperty(key)- if (- (aHasKey && !bHasKey) ||- (!aHasKey && bHasKey) ||- !looseEqual(a[key], b[key])- ) {- return false- }+ if (!withSeen(a, b, seen, () => looseCompareObjects(a, b, seen))) {+ return false } } return String(a) === String(b) } +function looseCompareObjects(a: any, b: any, seen: SeenPairs) {+ for (const key in a) {+ const aHasKey = a.hasOwnProperty(key)+ const bHasKey = b.hasOwnProperty(key)+ if (+ (aHasKey && !bHasKey) ||+ (!aHasKey && bHasKey) ||+ !baseLooseEqual(a[key], b[key], seen)+ ) {+ return false+ }+ }+ return true+}++// If the pair (a, b) is already being compared higher up the stack, assume it+// is equal: any actual difference will be detected by that outer comparison.+// The pair is only tracked while its own comparison is in progress, so a+// failed tentative match (e.g. when probing Set candidates) never leaks an+// unproven assumption into later comparisons.+function withSeen(+ a: object,+ b: object,+ seen: SeenPairs,+ compare: () => boolean,+): boolean {+ let bs = seen.get(a)+ if (bs && bs.has(b)) return true+ if (!bs) seen.set(a, (bs = new Set()))+ bs.add(b)+ try {+ return compare()+ } finally {+ bs.delete(b)+ if (!bs.size) seen.delete(a)+ }+}+ export function looseIndexOf(arr: any[], val: any): number { return arr.findIndex(item => looseEqual(item, val)) }
packages/shared/__tests__/looseEqual.spec.tsindex 777f3cfad..bc1bc3acd 100644@@ -288,4 +288,45 @@ describe('utils/looseEqual', () => { expect(looseEqual(new Set<any>([1, '1']), new Set<any>([1, 2]))).toBe(false) expect(looseEqual(new Set(), new Map())).toBe(false) })++ test('compares circular references correctly', () => {+ const makeGraph = () => {+ const n1: any = { id: 1 }+ const n2: any = { id: 2 }+ n1.peer = n2+ n2.peer = n1+ return [n1, n2]+ }++ expect(looseEqual(new Set(makeGraph()), new Set(makeGraph()))).toBe(true)+ expect(+ looseEqual(new Map([['a', makeGraph()]]), new Map([['a', makeGraph()]])),+ ).toBe(true)+ expect(looseEqual(makeGraph(), makeGraph())).toBe(true)+ expect(looseEqual({ n: makeGraph() }, { n: makeGraph() })).toBe(true)++ const selfSet = new Set<any>()+ selfSet.add(selfSet)+ const otherSelfSet = new Set<any>()+ otherSelfSet.add(otherSelfSet)+ expect(looseEqual(selfSet, otherSelfSet)).toBe(true)+ expect(looseEqual(selfSet, new Set([new Set()]))).toBe(false)++ const shared = { id: 1 }+ expect(+ looseEqual({ a: shared, b: shared }, { a: { id: 1 }, b: { id: 1 } }),+ ).toBe(true)+ })++ test('compares circular references symmetrically', () => {+ const self: any = {}+ self.next = self+ const first: any = {}+ const second: any = {}+ first.next = second+ second.next = first++ expect(looseEqual(self, first)).toBe(false)+ expect(looseEqual(first, self)).toBe(false)+ }) })packages/shared/src/looseEqual.tsindex d037b0a57..7e3e7f44e 100644@@ -1,10 +1,12 @@ import { isArray, isDate, isMap, isObject, isSet, isSymbol } from './general' -function looseCompareArrays(a: any[], b: any[]) {+type ComparisonState = [Map<any, any>, Map<any, any>]++function looseCompareArrays(a: any[], b: any[], seen: ComparisonState) { if (a.length !== b.length) return false let equal = true for (let i = 0; equal && i < a.length; i++) {- equal = looseEqual(a[i], b[i])+ equal = looseEqual(a[i], b[i], seen) } return equal }@@ -12,6 +14,7 @@ function looseCompareArrays(a: any[], b: any[]) { function looseCompareCollections( a: Map<any, any> | Set<any>, b: Map<any, any> | Set<any>,+ seen: ComparisonState, ) { if (a.size !== b.size) return false const candidates = Array.from(b)@@ -19,7 +22,7 @@ function looseCompareCollections( for (const item of a) { let index = -1 for (let i = 0; i < candidates.length; i++) {- if (!matched[i] && looseEqual(item, candidates[i])) {+ if (!matched[i] && looseEqual(item, candidates[i], seen)) { index = i break }@@ -30,7 +33,62 @@ function looseCompareCollections( return true } -export function looseEqual(a: any, b: any): boolean {+function looseCompareObjects(a: any, b: any, seen: ComparisonState) {+ let aValidType = isMap(a)+ let bValidType = isMap(b)+ if (aValidType || bValidType) {+ return aValidType && bValidType+ ? looseCompareCollections(a, b, seen)+ : false+ }+ aValidType = isSet(a)+ bValidType = isSet(b)+ if (aValidType || bValidType) {+ return aValidType && bValidType+ ? looseCompareCollections(a, b, seen)+ : false+ }+ const aKeysCount = Object.keys(a).length+ const bKeysCount = Object.keys(b).length+ if (aKeysCount !== bKeysCount) {+ return false+ }+ for (const key in a) {+ const aHasKey = a.hasOwnProperty(key)+ const bHasKey = b.hasOwnProperty(key)+ if (+ (aHasKey && !bHasKey) ||+ (!aHasKey && bHasKey) ||+ !looseEqual(a[key], b[key], seen)+ ) {+ return false+ }+ }+ return String(a) === String(b)+}++function looseCompareNested(+ a: any,+ b: any,+ seen: ComparisonState | undefined,+ compare: (a: any, b: any, seen: ComparisonState) => boolean,+) {+ if (!seen) {+ seen = [new Map(), new Map()]+ }+ const [seenA, seenB] = seen+ if (seenA.has(a) || seenB.has(b)) {+ return seenA.get(a) === b && seenB.get(b) === a+ }+ seenA.set(a, b)+ seenB.set(b, a)+ const equal = compare(a, b, seen)+ seenA.delete(a)+ seenB.delete(b)+ return equal+}++export function looseEqual(a: any, b: any, seen?: ComparisonState): boolean { if (a === b) return true let aValidType = isDate(a) let bValidType = isDate(b)@@ -45,7 +103,9 @@ export function looseEqual(a: any, b: any): boolean { aValidType = isArray(a) bValidType = isArray(b) if (aValidType || bValidType) {- return aValidType && bValidType ? looseCompareArrays(a, b) : false+ return aValidType && bValidType+ ? looseCompareNested(a, b, seen, looseCompareArrays)+ : false } aValidType = isObject(a) bValidType = isObject(b)@@ -53,32 +113,7 @@ export function looseEqual(a: any, b: any): boolean { if (!aValidType || !bValidType) { return false }- aValidType = isMap(a)- bValidType = isMap(b)- if (aValidType || bValidType) {- return aValidType && bValidType ? looseCompareCollections(a, b) : false- }- aValidType = isSet(a)- bValidType = isSet(b)- if (aValidType || bValidType) {- return aValidType && bValidType ? looseCompareCollections(a, b) : false- }- const aKeysCount = Object.keys(a).length- const bKeysCount = Object.keys(b).length- if (aKeysCount !== bKeysCount) {- return false- }- for (const key in a) {- const aHasKey = a.hasOwnProperty(key)- const bHasKey = b.hasOwnProperty(key)- if (- (aHasKey && !bHasKey) ||- (!aHasKey && bHasKey) ||- !looseEqual(a[key], b[key])- ) {- return false- }- }+ return looseCompareNested(a, b, seen, looseCompareObjects) } return String(a) === String(b) }