Backtestsvuerun-20261009-161443#15320
looseEqual() reports Map and Set instances with different contents as equal
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 correctly. Each adds explicit Map/Set branches to `looseEqual`, rejects mismatched types (Map vs Set, Map vs object, Set vs array), checks size first, and does order-insensitive loose matching where each element pairs with a distinct counterpart. Patch B handles both collection types with one helper, `looseCompareCollections`. Iterating a Map yields `[k, v]` tuples, which `looseEqual` compares as arrays, so keys and values are compared loosely. Its branches sit inside the `isObject` block, which is also correct. Patch A has separate Map and Set comparators. Each has a SameValueZero fast path that falls back to the same unordered loose matching. I traced the fast paths and found no cases where they diverge from the fallback: - A Set whose members all pass `has()` with equal size is genuinely equal. - A Map with shared keys and loosely equal values would also pass the fallback. The fast paths add code but no correctness risk, and they make the common case cheaper. The main difference is tests, which rank above craft. - **Patch A** tests: empty vs non-empty in both directions, key-order insensitivity, loose values and loose object keys, the distinct-match requirement, nested Sets/Maps inside objects and arrays, and cross-type cases. It also extends the `v-model` select test to Sets, reactive updates and the no-match (-1) case, and adds SSR `ssrRenderDynamicModel` assertions. - **Patch B** tests: the core cases plus one static `v-model` select assertion for Maps only. Patch B is more concise and arguably cleaner. However, Patch A's broader, meaningful coverage of the issue's scenarios outweighs B's smaller craft advantage.
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 59s
Wall-clock time in the container
Full test suite
No new failures
3,692 passed · 6 skipped · 3,698 total
Contamination audit
Clean
No sign the agent saw the real fix
Patch size
220vs 116 merged
Changed lines, ours vs merged
The issue
View on GitHubVue version
3.5.x / main (verified at a2b40db)
Link to minimal reproduction
Reproducible directly against the repo (see below) — looseEqual is not exported publicly, so the SFC Playground can only show the v-model symptom, not the root cause.
Steps to reproduce
looseEqual() in packages/shared/src/looseEqual.ts reports unrelated Map and Set instances as equal:
import { looseEqual } from '@vue/shared'
looseEqual(new Map([['a', 1]]), new Map([['b', 2]])) // true, expected false
looseEqual(new Set([1]), new Set([2])) // true, expected false
looseEqual(new Map([['a', 1]]), new Map()) // true, expected false
This surfaces to users through v-model on <select>. The following selects the wrong option:
const mapA = new Map([['id', 1]])
const mapB = new Map([['id', 2]])
const selected = ref(mapB)
<select v-model="selected">
<option :value="mapA">A</option>
<option :value="mapB">B</option>
</select>
el.selectedIndex is 0 (option A) when it should be 1, because looseEqual(mapA, mapB) returns true and the loop in setSelected stops at the first option.
What is expected?
Map/Set values with different contents compare as not equal, so v-model selects the option that actually matches.
What is actually happening?
Map and Set fall through to the generic object branch. Object.keys() on either is always [], so the key-count check passes and the for...in loop body never executes — entries are never compared. Execution then reaches the final line:
return String(a) === String(b)
Every Map stringifies to '[object Map]' and every Set to '[object Set]', so any two of the same type are reported equal.
Note this differs from Date and Symbol, which are given explicit branches above, and from arrays and plain objects, which compare correctly:
looseEqual([1], [2]) // false, correct
looseEqual({ a: 1 }, { a: 2 }) // false, correct
packages/shared/__tests__/looseEqual.spec.ts has 13 cases but none for Map/Set, which is why this hasn't been caught.
Possible fix
Add explicit branches before the generic object check, mirroring the existing Date/Symbol pattern. isMap and isSet already exist in packages/shared/src/general.ts. Set needs content comparison rather than reference lookup to stay consistent with looseEqual's semantics (e.g. new Set([{ a: 1 }]) vs new Set([{ a: 1 }])).
Worth confirming the intended semantics first: should Map comparison be key-order-insensitive, and should Set compare loosely (looseEqual per element) or strictly? Happy to open a PR with tests once the direction is confirmed.
System Info
Vue: 3.5.x / main @ a2b40db
Any additional comments?
Unrelated to #15298, which touches only vModel.ts.
The two patches
packages/runtime-dom/__tests__/directives/vModel.spec.tsindex 429163126..9a7e78d14 100644@@ -1009,6 +1009,55 @@ describe('vModel', () => { expect(bar.selected).toEqual(true) }) + it('single select with Map / Set option values', async () => {+ const mapA = new Map([['id', 1]])+ const mapB = new Map([['id', 2]])+ const setA = new Set([1])+ const setB = new Set([2])+ const data = ref<any>(mapB)+ const component = defineComponent({+ render() {+ return [+ withVModel(+ h(+ 'select',+ {+ 'onUpdate:modelValue': (val: any) => (data.value = val),+ },+ [+ h('option', { value: mapA }),+ h('option', { value: mapB }),+ h('option', { value: setA }),+ h('option', { value: setB }),+ ],+ ),+ data.value,+ ),+ ]+ },+ })+ render(h(component), root)++ const select = root.querySelector('select')+ expect(select.selectedIndex).toBe(1)++ data.value = mapA+ await nextTick()+ expect(select.selectedIndex).toBe(0)++ data.value = setB+ await nextTick()+ expect(select.selectedIndex).toBe(3)++ data.value = setA+ await nextTick()+ expect(select.selectedIndex).toBe(2)++ data.value = new Map([['id', 3]])+ await nextTick()+ expect(select.selectedIndex).toBe(-1)+ })+ it('multiple select (model is Array)', async () => { const component = defineComponent({ data() {packages/server-renderer/__tests__/ssrVModelHelpers.spec.tsindex 7d00b9cb7..26f34e209 100644@@ -19,6 +19,22 @@ describe('ssr: v-model helpers', () => { expect(ssrRenderDynamicModel('radio', 'foo', 'foo')).toBe(` checked`) expect(ssrRenderDynamicModel('radio', 1, '1')).toBe(` checked`) expect(ssrRenderDynamicModel('radio', 1, 0)).toBe(``)++ expect(+ ssrRenderDynamicModel(+ 'radio',+ new Map([['id', 1]]),+ new Map([['id', 1]]),+ ),+ ).toBe(` checked`)+ expect(+ ssrRenderDynamicModel(+ 'radio',+ new Map([['id', 1]]),+ new Map([['id', 2]]),+ ),+ ).toBe(``)+ expect(ssrRenderDynamicModel('radio', new Set([1]), new Set([2]))).toBe(``) }) test('ssrGetDynamicModelProps', () => {packages/shared/__tests__/looseEqual.spec.tsindex 2dea58ce5..0d7e89b4f 100644@@ -233,4 +233,82 @@ describe('utils/looseEqual', () => { expect(looseEqual(arr1, arr5)).toBe(false) expect(looseEqual(arr5, arr1)).toBe(false) })++ test('compares maps correctly', () => {+ expect(looseEqual(new Map([['a', 1]]), new Map([['a', 1]]))).toBe(true)+ expect(looseEqual(new Map([['a', 1]]), new Map([['b', 2]]))).toBe(false)+ expect(looseEqual(new Map([['a', 1]]), new Map([['a', 2]]))).toBe(false)+ expect(looseEqual(new Map([['a', 1]]), new Map())).toBe(false)+ expect(looseEqual(new Map(), new Map([['a', 1]]))).toBe(false)+ expect(looseEqual(new Map(), new Map())).toBe(true)+ // key order does not matter+ expect(+ looseEqual(+ new Map<string, number>([+ ['a', 1],+ ['b', 2],+ ]),+ new Map<string, number>([+ ['b', 2],+ ['a', 1],+ ]),+ ),+ ).toBe(true)+ // values are compared loosely+ expect(+ looseEqual(new Map([['a', { x: 1 }]]), new Map([['a', { x: 1 }]])),+ ).toBe(true)+ expect(+ looseEqual(new Map([['a', { x: 1 }]]), new Map([['a', { x: 2 }]])),+ ).toBe(false)+ // object keys are compared loosely+ expect(+ looseEqual(new Map([[{ k: 1 }, 'v']]), new Map([[{ k: 1 }, 'v']])),+ ).toBe(true)+ expect(+ looseEqual(new Map([[{ k: 1 }, 'v']]), new Map([[{ k: 2 }, 'v']])),+ ).toBe(false)+ // loosely equal keys are matched consistently with other maps+ const looseKeys1 = new Map<any, string>([+ [1, 'a'],+ ['1', 'b'],+ ])+ const looseKeys2 = new Map<any, string>([+ [1, 'b'],+ ['1', 'a'],+ ])+ expect(looseEqual(looseKeys1, looseKeys2)).toBe(true)+ // not equal to other types+ expect(looseEqual(new Map(), {})).toBe(false)+ expect(looseEqual({}, new Map())).toBe(false)+ expect(looseEqual(new Map(), new Set())).toBe(false)+ expect(looseEqual(new Map(), [])).toBe(false)+ })++ test('compares sets correctly', () => {+ expect(looseEqual(new Set([1]), new Set([1]))).toBe(true)+ expect(looseEqual(new Set([1]), new Set([2]))).toBe(false)+ expect(looseEqual(new Set([1]), new Set())).toBe(false)+ expect(looseEqual(new Set(), new Set([1]))).toBe(false)+ expect(looseEqual(new Set(), new Set())).toBe(true)+ // order does not matter+ expect(looseEqual(new Set([1, 2]), new Set([2, 1]))).toBe(true)+ // members are compared loosely+ expect(looseEqual(new Set([{ a: 1 }]), new Set([{ a: 1 }]))).toBe(true)+ expect(looseEqual(new Set([{ a: 1 }]), new Set([{ a: 2 }]))).toBe(false)+ expect(looseEqual(new Set([1]), new Set(['1']))).toBe(true)+ // each member must be matched by a distinct member+ expect(+ looseEqual(new Set([{ a: 1 }, { a: 2 }]), new Set([{ a: 1 }, { a: 1 }])),+ ).toBe(false)+ // nested collections+ expect(looseEqual(new Set([new Set([1])]), new Set([new Set([2])]))).toBe(+ false,+ )+ expect(looseEqual({ s: new Set([1]) }, { s: new Set([1]) })).toBe(true)+ expect(looseEqual([new Map([['a', 1]])], [new Map([['a', 2]])])).toBe(false)+ // not equal to other types+ expect(looseEqual(new Set(), {})).toBe(false)+ expect(looseEqual(new Set([1]), [1])).toBe(false)+ }) })packages/shared/src/looseEqual.tsindex 9e7176721..2a239f57d 100644@@ -1,4 +1,4 @@-import { isArray, isDate, isObject, isSymbol } from './general'+import { isArray, isDate, isMap, isObject, isSet, isSymbol } from './general' function looseCompareArrays(a: any[], b: any[]) { if (a.length !== b.length) return false@@ -9,6 +9,71 @@ function looseCompareArrays(a: any[], b: any[]) { return equal } +/**+ * Order-insensitive comparison of two lists of items, where each item in `a`+ * must be matched by a distinct item in `b`.+ */+function looseCompareUnordered(+ a: any[],+ b: any[],+ compare: (x: any, y: any) => boolean,+): boolean {+ if (a.length !== b.length) return false+ const matched = new Array<boolean>(b.length).fill(false)+ for (let i = 0; i < a.length; i++) {+ let found = false+ for (let j = 0; j < b.length; j++) {+ if (!matched[j] && compare(a[i], b[j])) {+ matched[j] = found = true+ break+ }+ }+ if (!found) return false+ }+ return true+}++function looseCompareSets(a: Set<any>, b: Set<any>): boolean {+ if (a.size !== b.size) return false+ // fast path: identical members via SameValueZero+ let allShared = true+ for (const item of a) {+ if (!b.has(item)) {+ allShared = false+ break+ }+ }+ if (allShared) return true+ return looseCompareUnordered([...a], [...b], looseEqual)+}++function looseCompareMaps(a: Map<any, any>, b: Map<any, any>): boolean {+ if (a.size !== b.size) return false+ // fast path: identical keys via SameValueZero+ let allShared = true+ for (const key of a.keys()) {+ if (!b.has(key)) {+ allShared = false+ break+ }+ }+ if (allShared) {+ let valuesEqual = true+ for (const [key, value] of a) {+ if (!looseEqual(value, b.get(key))) {+ valuesEqual = false+ break+ }+ }+ if (valuesEqual) return true+ }+ return looseCompareUnordered(+ [...a],+ [...b],+ (x, y) => looseEqual(x[0], y[0]) && looseEqual(x[1], y[1]),+ )+}+ export function looseEqual(a: any, b: any): boolean { if (a === b) return true let aValidType = isDate(a)@@ -26,6 +91,16 @@ export function looseEqual(a: any, b: any): boolean { if (aValidType || bValidType) { return aValidType && bValidType ? looseCompareArrays(a, b) : false }+ aValidType = isMap(a)+ bValidType = isMap(b)+ if (aValidType || bValidType) {+ return aValidType && bValidType ? looseCompareMaps(a, b) : false+ }+ aValidType = isSet(a)+ bValidType = isSet(b)+ if (aValidType || bValidType) {+ return aValidType && bValidType ? looseCompareSets(a, b) : false+ } aValidType = isObject(a) bValidType = isObject(b) if (aValidType || bValidType) {
packages/runtime-dom/__tests__/directives/vModel.spec.tsindex 429163126..a94cb8e0d 100644@@ -1874,4 +1874,32 @@ describe('vModel', () => { await nextTick() expect(foo.checked).toEqual(false) })++ // #15320+ it('selects the matching option when values are maps', () => {+ const mapA = new Map([['id', 1]])+ const mapB = new Map([['id', 2]])+ const value = ref(mapB)+ const component = defineComponent(+ () => () =>+ withVModel(+ h(+ 'select',+ {+ 'onUpdate:modelValue': (val: Map<string, number>) =>+ (value.value = val),+ },+ [+ h('option', { value: mapA }, 'A'),+ h('option', { value: mapB }, 'B'),+ ],+ ),+ value.value,+ ),+ )++ render(h(component), root)++ expect(root.querySelector('select').selectedIndex).toBe(1)+ }) })packages/shared/__tests__/looseEqual.spec.tsindex 2dea58ce5..777f3cfad 100644@@ -233,4 +233,59 @@ describe('utils/looseEqual', () => { expect(looseEqual(arr1, arr5)).toBe(false) expect(looseEqual(arr5, arr1)).toBe(false) })++ test('compares maps correctly', () => {+ const map = new Map<any, any>([+ [{ id: 1 }, { value: '1' }],+ ['foo', 'bar'],+ ])++ expect(looseEqual(map, map)).toBe(true)+ expect(+ looseEqual(+ map,+ new Map<any, any>([+ ['foo', 'bar'],+ [{ id: '1' }, { value: 1 }],+ ]),+ ),+ ).toBe(true)+ expect(looseEqual(map, new Map([['foo', 'bar']]))).toBe(false)+ expect(looseEqual(new Map([['a', 1]]), new Map([['b', 2]]))).toBe(false)+ expect(+ looseEqual(+ new Map<any, any>([+ ['a', 1],+ ['b', 2],+ ]),+ new Map<any, any>([+ ['a', 2],+ ['b', 1],+ ]),+ ),+ ).toBe(false)+ expect(+ looseEqual(+ new Map<any, any>([+ [1, 'value'],+ ['1', 'value'],+ ]),+ new Map<any, any>([+ [1, 'value'],+ [2, 'value'],+ ]),+ ),+ ).toBe(false)+ })++ test('compares sets correctly', () => {+ const set = new Set<any>([{ id: 1 }, 'foo'])++ expect(looseEqual(set, set)).toBe(true)+ expect(looseEqual(set, new Set(['foo', { id: '1' }]))).toBe(true)+ expect(looseEqual(set, new Set(['foo']))).toBe(false)+ expect(looseEqual(new Set([1]), new Set([2]))).toBe(false)+ expect(looseEqual(new Set<any>([1, '1']), new Set<any>([1, 2]))).toBe(false)+ expect(looseEqual(new Set(), new Map())).toBe(false)+ }) })packages/shared/src/looseEqual.tsindex 9e7176721..d037b0a57 100644@@ -1,4 +1,4 @@-import { isArray, isDate, isObject, isSymbol } from './general'+import { isArray, isDate, isMap, isObject, isSet, isSymbol } from './general' function looseCompareArrays(a: any[], b: any[]) { if (a.length !== b.length) return false@@ -9,6 +9,27 @@ function looseCompareArrays(a: any[], b: any[]) { return equal } +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+}+ export function looseEqual(a: any, b: any): boolean { if (a === b) return true let aValidType = isDate(a)@@ -32,6 +53,16 @@ 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) {