Backtestsvuerun-20261005-124535#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 stop the unbounded recursion by threading state through looseEqual, looseCompareArrays and looseCompareCollections, so both fix the reported RangeError.
**Correctness.** Patch A implements what the issue suggests. It tracks (a, b) pairs on the current recursion path, returns true when the same pair comes up again, and removes each pair once its comparison finishes. This is pair-based tracking, so a shared object can still be compared against different counterparts. The result is that two structurally identical cyclic values compare equal, which is the behaviour the issue asks for.
Patch B instead enforces a one-to-one mapping between a and b (seenA/seenB). If an object is already on the stack and is now paired with a different partner, B returns false. That rejects some values that are structurally equal. For example, `a = {self: a}` versus `b = {self: b2}` with `b2 = {self: b2}` unfolds to identical infinite trees, but B returns false. B's own 'symmetric' test even asserts that `self` vs `first/second` (also identical when unfolded) are unequal. That is a stricter, debatable semantics that the issue did not ask for.
**API surface.** Patch B also adds a third `seen` parameter to the exported `looseEqual`, which exposes internal state in the public signature. Patch A keeps the public API unchanged behind a private `looseEqualImpl`.
**Tests.** Patch A's tests are broader. They cover:
- Sets and Maps with mutually-referencing values, including mismatches.
- Maps with cyclic keys.
- Self-containing Sets and Maps, both equal and unequal.
- Cyclic objects and arrays.
- A shared object compared against different targets.
- Two component-level `<select v-model>` tests that reproduce the issue's actual failure path.
Patch B has a single, smaller unit test block and no component test.
**Scope and craft.** Both are reasonably scoped. Patch A's refactor is clean and well commented.
Overall, A is closer to the issue's requested semantics, keeps the API clean, and is better tested.
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
6m 1s
Wall-clock time in the container
Full test suite
No new failures
3,748 passed · 6 skipped · 3,754 total
Contamination audit
Clean
No sign the agent saw the real fix
Patch size
215vs 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..e70950579 100644@@ -1900,6 +1900,70 @@ describe('vModel', () => { render(h(component), root) + expect(root.querySelector('select').selectedIndex).toBe(1)+ })+ it('selects the matching option when set values contain circular references', () => {+ const makeGraph = (id1: number, id2: number) => {+ const n1: any = { id: id1 }+ const n2: any = { id: id2 }+ n1.peer = n2+ n2.peer = n1+ return new Set([n1, n2])+ }+ const optA = makeGraph(1, 2)+ const optB = makeGraph(3, 4)+ const value = ref(makeGraph(3, 4))+ const component = defineComponent(+ () => () =>+ withVModel(+ h(+ 'select',+ {+ 'onUpdate:modelValue': (val: Set<any>) => (value.value = val),+ },+ [+ h('option', { value: optA }, 'A'),+ h('option', { value: optB }, 'B'),+ ],+ ),+ value.value,+ ),+ )++ render(h(component), root)++ expect(root.querySelector('select').selectedIndex).toBe(1)+ })++ it('selects the matching option when map values contain circular references', () => {+ const makeMap = (id: number) => {+ const map = new Map<string, any>([['id', id]])+ map.set('self', map)+ return map+ }+ const optA = makeMap(1)+ const optB = 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: optA }, 'A'),+ h('option', { value: optB }, 'B'),+ ],+ ),+ value.value,+ ),+ )++ render(h(component), root)+ expect(root.querySelector('select').selectedIndex).toBe(1) }) })packages/shared/__tests__/looseEqual.spec.tsindex 777f3cfad..00f9ebcee 100644@@ -288,4 +288,106 @@ 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) })+ describe('cyclic structures', () => {+ const makeGraph = (id1: any, id2: any) => {+ const n1: any = { id: id1 }+ const n2: any = { id: id2 }+ n1.peer = n2+ n2.peer = n1+ return [n1, n2]+ }++ test('sets with mutually-referencing values', () => {+ expect(+ looseEqual(new Set(makeGraph(1, 2)), new Set(makeGraph(1, 2))),+ ).toBe(true)+ expect(+ looseEqual(new Set(makeGraph(1, 2)), new Set(makeGraph('1', '2'))),+ ).toBe(true)+ expect(+ looseEqual(new Set(makeGraph(1, 2)), new Set(makeGraph(1, 3))),+ ).toBe(false)+ })++ test('maps with mutually-referencing values', () => {+ const toMap = ([n1, n2]: any[]) =>+ new Map<any, any>([+ ['a', n1],+ ['b', n2],+ ])+ expect(looseEqual(toMap(makeGraph(1, 2)), toMap(makeGraph(1, 2)))).toBe(+ true,+ )+ expect(looseEqual(toMap(makeGraph(1, 2)), toMap(makeGraph(2, 1)))).toBe(+ false,+ )++ const keysA = makeGraph(1, 2)+ const keysB = makeGraph(1, 2)+ expect(+ looseEqual(new Map([[keysA[0], 'x']]), new Map([[keysB[0], 'x']])),+ ).toBe(true)+ expect(+ looseEqual(new Map([[keysA[0], 'x']]), new Map([[keysB[0], 'y']])),+ ).toBe(false)+ })++ test('self-containing sets and maps', () => {+ const s1 = new Set<any>()+ s1.add(s1)+ const s2 = new Set<any>()+ s2.add(s2)+ expect(looseEqual(s1, s2)).toBe(true)++ const s3 = new Set<any>([1])+ s3.add(s3)+ const s4 = new Set<any>([2])+ s4.add(s4)+ expect(looseEqual(s3, s4)).toBe(false)++ const m1 = new Map<any, any>()+ m1.set('self', m1)+ const m2 = new Map<any, any>()+ m2.set('self', m2)+ expect(looseEqual(m1, m2)).toBe(true)+ m2.set('other', 1)+ expect(looseEqual(m1, m2)).toBe(false)+ })++ test('cyclic objects and arrays', () => {+ const [a] = makeGraph(1, 2)+ const [b] = makeGraph(1, 2)+ const [c] = makeGraph(1, 3)+ expect(looseEqual(a, b)).toBe(true)+ expect(looseEqual(a, c)).toBe(false)++ const o1: any = { id: 1 }+ o1.self = o1+ const o2: any = { id: 1 }+ o2.self = o2+ expect(looseEqual(o1, o2)).toBe(true)+ o2.id = 2+ expect(looseEqual(o1, o2)).toBe(false)++ const arr1: any[] = [1]+ arr1.push(arr1)+ const arr2: any[] = [1]+ arr2.push(arr2)+ expect(looseEqual(arr1, arr2)).toBe(true)+ arr2[0] = 2+ expect(looseEqual(arr1, arr2)).toBe(false)+ })++ test('same object compared against different targets', () => {+ // a shared (non-cyclic) object reached twice must still be compared+ // against each of its counterparts+ const shared = { id: 1 }+ expect(+ looseEqual({ x: shared, y: shared }, { x: { id: 1 }, y: { id: 2 } }),+ ).toBe(false)+ expect(+ looseEqual({ x: shared, y: shared }, { x: { id: 1 }, y: { id: 1 } }),+ ).toBe(true)+ })+ }) })packages/shared/src/looseEqual.tsindex d037b0a57..0b1b2cba4 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 path,+// used to terminate on cyclic structures+type CompareStack = Map<object, Set<object>>++function looseCompareArrays(a: any[], b: any[], stack?: CompareStack) { 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 = looseEqualImpl(a[i], b[i], stack) } 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>,+ stack?: CompareStack, ) { 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] && looseEqualImpl(item, candidates[i], stack)) { index = i break }@@ -31,6 +36,10 @@ function looseCompareCollections( } export function looseEqual(a: any, b: any): boolean {+ return looseEqualImpl(a, b)+}++function looseEqualImpl(a: any, b: any, stack?: CompareStack): boolean { if (a === b) return true let aValidType = isDate(a) let bValidType = isDate(b)@@ -42,10 +51,28 @@ export function looseEqual(a: any, b: any): boolean { if (aValidType || bValidType) { return a === b }- aValidType = isArray(a)- bValidType = isArray(b)+ if (isObject(a) && isObject(b)) {+ // the same pair is already being compared further up the recursion path+ // (cyclic reference): assume equal here and let the outer comparison+ // decide based on the remaining properties+ if (!stack) stack = new Map()+ let compared = stack.get(a)+ if (compared && compared.has(b)) return true+ if (!compared) stack.set(a, (compared = new Set()))+ compared.add(b)+ const result = looseCompareObjects(a, b, stack)+ compared.delete(b)+ if (!compared.size) stack.delete(a)+ return result+ }+ return looseCompareObjects(a, b, stack)+}++function looseCompareObjects(a: any, b: any, stack?: CompareStack): boolean {+ let aValidType = isArray(a)+ let bValidType = isArray(b) if (aValidType || bValidType) {- return aValidType && bValidType ? looseCompareArrays(a, b) : false+ return aValidType && bValidType ? looseCompareArrays(a, b, stack) : false } aValidType = isObject(a) bValidType = isObject(b)@@ -56,12 +83,16 @@ 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+ ? looseCompareCollections(a, b, stack)+ : false } aValidType = isSet(a) bValidType = isSet(b) if (aValidType || bValidType) {- return aValidType && bValidType ? looseCompareCollections(a, b) : false+ return aValidType && bValidType+ ? looseCompareCollections(a, b, stack)+ : false } const aKeysCount = Object.keys(a).length const bKeysCount = Object.keys(b).length@@ -74,7 +105,7 @@ export function looseEqual(a: any, b: any): boolean { if ( (aHasKey && !bHasKey) || (!aHasKey && bHasKey) ||- !looseEqual(a[key], b[key])+ !looseEqualImpl(a[key], b[key], stack) ) { return false }
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) }