Backtestsvuerun-20261007-145226#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 the same way. Each adds explicit Map and Set branches to `looseEqual` that check size, then greedily match elements one-to-one using `looseEqual`. Neither falls through to the `String(a) === String(b)` path any more. Both reject Map vs Set, Map vs plain object, and Set vs array. Both are order-insensitive and compare elements loosely, so the issue's examples and the `v-model` `<select>` symptom are fixed by either. Correctness differences are small: - Patch B uses one `looseCompareCollections` for both types. For Maps it treats entries as `[key, value]` arrays and compares them with `looseEqual`. This is uniform and correct, but always quadratic. - Patch A pairs identical elements or keys first with `has()`, and only loosely matches the leftovers. That is cheaper in the common case where elements are reused by reference. - Patch A's Map logic pins an entry to its identical key when one exists. In pathological cases, such as keys `1` and `'1'` with swapped values, it can return false where B returns true. That is arguably the more intuitive result and is not a regression either way. - Placement differs: A puts the branches before the `isObject` check, matching the Date/Symbol/Array pattern the issue suggests. B nests them inside the object branch. Behaviour is equivalent. Tests: both add looseEqual cases and a `v-model` `<select>` test that would fail before the fix. - Patch A's coverage is broader: empty collections in both directions, value-only differences, object keys, one-to-one matching for Sets, nested Sets, Maps/Sets nested in objects and arrays, and several cross-type cases. - Patch A's `v-model` test covers both Map and Set, and also checks that selection updates after the model changes to a new, loosely equal instance. - Patch B's `v-model` test checks only the initial Map selection, though its unit tests include some good loose-matching cases. Scope and craft are comparable. B's shared helper is more compact; A's helpers are clearer per type and include the identity fast path. Overall, A is somewhat better on test thoroughness and on matching the existing code pattern, so A wins narrowly.
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 11s
Wall-clock time in the container
Full test suite
No new failures
3,693 passed · 6 skipped · 3,699 total
Contamination audit
Clean
No sign the agent saw the real fix
Patch size
174vs 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..8445266cf 100644@@ -953,6 +953,55 @@ describe('vModel', () => { expect(bar.checked).toEqual(true) }) + it('should select the matching option with Map/Set 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 mapValue = ref<any>(mapB)+ const setValue = ref<any>(setB)+ const component = defineComponent({+ render() {+ return [+ withVModel(+ h(+ 'select',+ {+ class: 'map',+ 'onUpdate:modelValue': (v: any) => (mapValue.value = v),+ },+ [h('option', { value: mapA }), h('option', { value: mapB })],+ ),+ mapValue.value,+ ),+ withVModel(+ h(+ 'select',+ {+ class: 'set',+ 'onUpdate:modelValue': (v: any) => (setValue.value = v),+ },+ [h('option', { value: setA }), h('option', { value: setB })],+ ),+ setValue.value,+ ),+ ]+ },+ })+ render(h(component), root)++ const mapSelect = root.querySelector('.map')+ const setSelect = root.querySelector('.set')+ expect(mapSelect.selectedIndex).toBe(1)+ expect(setSelect.selectedIndex).toBe(1)++ mapValue.value = new Map([['id', 1]])+ setValue.value = new Set([1])+ await nextTick()+ expect(mapSelect.selectedIndex).toBe(0)+ expect(setSelect.selectedIndex).toBe(0)+ })+ it('should work with single select', async () => { const component = defineComponent({ data() {packages/shared/__tests__/looseEqual.spec.tsindex 2dea58ce5..e1b946331 100644@@ -233,4 +233,83 @@ 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(), new Map())).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)+ // key order does not matter+ expect(+ looseEqual(+ new Map([+ ['a', 1],+ ['b', 2],+ ]),+ new Map([+ ['b', 2],+ ['a', 1],+ ]),+ ),+ ).toBe(true)+ // values and keys 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)+ expect(looseEqual(new Map([[{ k: 1 }, 1]]), new Map([[{ k: 1 }, 1]]))).toBe(+ true,+ )+ expect(looseEqual(new Map([[{ k: 1 }, 1]]), new Map([[{ k: 2 }, 1]]))).toBe(+ false,+ )+ // different types+ expect(looseEqual(new Map(), new Set())).toBe(false)+ expect(looseEqual(new Map(), {})).toBe(false)+ expect(looseEqual({}, new Map())).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(), new Set())).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)+ // order does not matter+ expect(looseEqual(new Set([1, 2]), new Set([2, 1]))).toBe(true)+ // elements 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 element can only be matched once+ expect(looseEqual(new Set([1, '1']), new Set([1, '2']))).toBe(false)+ expect(+ looseEqual(new Set([{ a: 1 }, { a: 1 }]), new Set([{ a: 1 }, { a: 2 }])),+ ).toBe(false)+ // nested+ expect(looseEqual(new Set([new Set([1])]), new Set([new Set([1])]))).toBe(+ true,+ )+ expect(looseEqual(new Set([new Set([1])]), new Set([new Set([2])]))).toBe(+ false,+ )+ // different types+ expect(looseEqual(new Set(), {})).toBe(false)+ expect(looseEqual([], new Set())).toBe(false)+ })++ test('compares Maps and Sets nested in objects and arrays', () => {+ expect(+ looseEqual({ m: new Map([['a', 1]]) }, { m: new Map([['a', 1]]) }),+ ).toBe(true)+ expect(+ looseEqual({ m: new Map([['a', 1]]) }, { m: new Map([['b', 1]]) }),+ ).toBe(false)+ expect(looseEqual([new Set([1])], [new Set([2])])).toBe(false)+ }) })packages/shared/src/looseEqual.tsindex 9e7176721..09b23c8dc 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,40 @@ function looseCompareArrays(a: any[], b: any[]) { return equal } +function looseCompareSets(a: Set<any>, b: Set<any>) {+ if (a.size !== b.size) return false+ // elements of b without an identical counterpart in a; each may be used to+ // loosely match at most one element of a+ const unmatched = [...b].filter(item => !a.has(item))+ for (const item of a) {+ if (b.has(item)) continue+ const index = unmatched.findIndex(other => looseEqual(item, other))+ if (index === -1) return false+ unmatched.splice(index, 1)+ }+ return true+}++function looseCompareMaps(a: Map<any, any>, b: Map<any, any>) {+ if (a.size !== b.size) return false+ // entries of b whose key has no identical counterpart in a; each may be used+ // to loosely match at most one entry of a+ const unmatched = [...b].filter(([key]) => !a.has(key))+ for (const [key, value] of a) {+ if (b.has(key)) {+ if (!looseEqual(value, b.get(key))) return false+ continue+ }+ const index = unmatched.findIndex(+ ([otherKey, otherValue]) =>+ looseEqual(key, otherKey) && looseEqual(value, otherValue),+ )+ if (index === -1) return false+ unmatched.splice(index, 1)+ }+ return true+}+ export function looseEqual(a: any, b: any): boolean { if (a === b) return true let aValidType = isDate(a)@@ -26,6 +60,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) {