Backtestsvuerun-20261002-115633#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 way. They thread comparison state through `looseEqual`, `looseCompareArrays` and `looseCompareCollections`, track object pairs on the current recursion stack, and remove a pair after its comparison so a failed pair is never cached as equal. Both stop the RangeError for all three repro shapes in the issue: the mutually-referencing Set, the Map with cyclic values, and the self-containing Set. Both also cover cyclic plain objects and arrays. Correctness differences: - Patch A returns `true` when a pair is re-encountered, which is exactly what the issue suggests. Its `try/finally` guarantees the pair is cleaned up. - Patch B enforces a bijection (seenA/seenB maps), so it returns false for a self-loop compared with a 2-cycle. That is a stricter semantic, but beyond what the issue asks. It is defensible either way, since the two structures are bisimilar. - Patch B changes the public signature of the exported `looseEqual` by adding a third `seen` parameter. Internal state leaks into a public API, and any caller that passes `looseEqual` as a callback with extra arguments could inject a bogus state tuple. Patch A keeps `looseEqual(a, b)` clean and puts the state in a private `looseEqualImpl`, which is lower risk. Tests: Patch A is clearly stronger. - It adds component-level `<select v-model>` tests that mirror the issue's reproduction, for both Sets and Maps. - It adds unit tests for cyclic Sets and Maps, including negative cases. - It covers cyclic objects and arrays, including through `looseIndexOf`. - It adds a targeted test that a failed cyclic pair is not cached as equal, including the Set candidate-matching order case. - Patch B's unit tests are reasonable and include a symmetry test, but it has no component-level test for the reported scenario. Scope and craft: both refactor similarly. Patch A's comments explain the cycle-assumption reasoning, and its private-impl approach is cleaner. Overall Patch A wins on test coverage and API hygiene, with equivalent core correctness.
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 52s
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
245vs 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..a18810f15 100644@@ -1900,6 +1900,68 @@ describe('vModel', () => { render(h(component), root) + 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 optA = makeGraph(1)+ const optB = makeGraph(3)+ const value = ref(makeGraph(3))+ 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 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 value = ref(makeMap(2))+ const component = defineComponent(+ () => () =>+ withVModel(+ h(+ 'select',+ {+ 'onUpdate:modelValue': (val: Map<string, any>) =>+ (value.value = val),+ },+ [+ h('option', { value: makeMap(1) }, 'A'),+ h('option', { value: makeMap(2) }, 'B'),+ ],+ ),+ value.value,+ ),+ )++ render(h(component), root)+ expect(root.querySelector('select').selectedIndex).toBe(1) }) })packages/shared/__tests__/looseEqual.spec.tsindex 777f3cfad..3b5f5c37f 100644@@ -1,7 +1,7 @@ /** * @vitest-environment jsdom */-import { looseEqual } from '../src'+import { looseEqual, looseIndexOf } from '../src' describe('utils/looseEqual', () => { test('compares booleans correctly', () => {@@ -288,4 +288,78 @@ 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(3))).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('foo')+ 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, peer: a }+ a.peer = b+ 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(3))).toBe(false)+ })++ // #5318+ test('compares objects and arrays with circular references', () => {+ const makeObject = (id: number) => {+ const obj: any = { id, list: [] }+ obj.self = obj+ obj.list.push(obj, obj.list)+ return obj+ }++ expect(looseEqual(makeObject(1), makeObject(1))).toBe(true)+ expect(looseEqual(makeObject(1), makeObject(2))).toBe(false)++ const arr1: any[] = [1]+ arr1.push(arr1)+ const arr2: any[] = [1]+ arr2.push(arr2)+ expect(looseEqual(arr1, arr2)).toBe(true)+ expect(looseIndexOf([1, arr1], arr2)).toBe(1)+ })++ test('does not cache a failed cyclic pair as equal', () => {+ // the cyclic key is visited before the differing one, so the cycle is+ // assumed equal while `v` still decides the result+ const x1: any = {}+ const x2: any = {}+ x1.self = x1+ x2.self = x2+ x1.v = 1+ x2.v = 2+ expect(looseEqual(x1, x2)).toBe(false)+ expect(looseEqual(x1, x2)).toBe(false)+ // the first candidate fails, the matching one must still be found and the+ // failed pair must not be cached as equal+ expect(looseEqual(new Set([x1, x2]), new Set([x2, x1]))).toBe(true)+ expect(looseEqual([x1, x1], [x1, x2])).toBe(false)+ }) })packages/shared/src/looseEqual.tsindex d037b0a57..a44a26cc8 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 ComparingPairs = WeakMap<object, WeakSet<object>>++function looseCompareArrays(a: any[], b: any[], comparing: ComparingPairs) { 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], comparing) } 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>,+ comparing: ComparingPairs, ) { 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], comparing)) { 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, comparing?: ComparingPairs): boolean { if (a === b) return true let aValidType = isDate(a) let bValidType = isDate(b)@@ -42,42 +51,80 @@ export function looseEqual(a: any, b: any): boolean { if (aValidType || bValidType) { return a === b }- aValidType = isArray(a)- bValidType = isArray(b)- if (aValidType || bValidType) {- return aValidType && bValidType ? looseCompareArrays(a, b) : false- } aValidType = isObject(a) bValidType = isObject(b) if (aValidType || bValidType) { if (!aValidType || !bValidType) { return false }- aValidType = isMap(a)- bValidType = isMap(b)- if (aValidType || bValidType) {- return aValidType && bValidType ? looseCompareCollections(a, b) : false+ // if this pair is already being compared further up the stack we have+ // hit a cycle: assume equality here and let the remaining (non-cyclic)+ // parts of the structures decide the result+ if (!comparing) {+ comparing = new WeakMap() }- aValidType = isSet(a)- bValidType = isSet(b)- if (aValidType || bValidType) {- return aValidType && bValidType ? looseCompareCollections(a, b) : false+ let pending = comparing.get(a)+ if (pending) {+ if (pending.has(b)) return true+ } else {+ comparing.set(a, (pending = new WeakSet())) }- const aKeysCount = Object.keys(a).length- const bKeysCount = Object.keys(b).length- if (aKeysCount !== bKeysCount) {- return false+ pending.add(b)+ try {+ return looseCompareObjects(a, b, comparing)+ } finally {+ // only pairs on the current stack count as cycles; a pair that was+ // compared and found unequal must not be treated as equal later+ pending.delete(b) }- 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 String(a) === String(b)+}++function looseCompareObjects(+ a: object,+ b: object,+ comparing: ComparingPairs,+): boolean {+ let aValidType = isArray(a)+ let bValidType = isArray(b)+ if (aValidType || bValidType) {+ return aValidType && bValidType+ ? looseCompareArrays(a as any[], b as any[], comparing)+ : false+ }+ aValidType = isMap(a)+ bValidType = isMap(b)+ if (aValidType || bValidType) {+ return aValidType && bValidType+ ? looseCompareCollections(+ a as Map<any, any>,+ b as Map<any, any>,+ comparing,+ )+ : false+ }+ aValidType = isSet(a)+ bValidType = isSet(b)+ if (aValidType || bValidType) {+ return aValidType && bValidType+ ? looseCompareCollections(a as Set<any>, b as Set<any>, comparing)+ : 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) ||+ !looseEqualImpl((a as any)[key], (b as any)[key], comparing)+ ) {+ return false } } return String(a) === String(b)
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) }