Backtestsvuerun-20261005-124535#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 B = our agent, Patch A = the merged fix.
Both patches fix the root cause the same way. Each adds explicit isMap/isSet branches to looseEqual. Each compares Map/Set contents as order-insensitive collections, with loose per-item matching that pairs each item with a distinct partner. For Maps, iterating yields [key, value] arrays, so keys and values are both compared loosely in either patch. Mismatched types (Map vs Set, Map vs plain object) return false in both. Patch A places the branches inside the generic object branch, after the isObject guard. Patch B places them before it. Both orderings are correct, so correctness is effectively equal. On craft, Patch B reuses the existing looseIndexOf helper from the same file, adds a strict indexOf fast path for primitive Set members, and explains in a comment why keys must be matched loosely (reactive Maps yield proxied keys). Patch A hand-rolls an equivalent loop with a Uint8Array and has no explanation. Both are acceptable. The deciding factor is tests, where Patch B is clearly stronger. It covers equal and unequal Maps and Sets, empty cases in both directions, order-insensitivity, loose comparison of values and keys, nested maps, distinct-element matching (sets with duplicate-looking objects), and cross-type comparisons including the '[object Map]' string that the old String() fallback would have matched. It also adds v-model select tests for both Map and Set, radio tests (one with object keys under a reactive model, exercising the proxy case), and SSR ssrRenderDynamicModel assertions. Patch A's looseEqual tests are reasonable but narrower, and it adds only a single Map select test with no Set integration coverage. Its `root.querySelector('select').selectedIndex` also lacks a null cast, which may trip type checking. All of Patch B's added tests target paths the bug affects and would fail before the fix, so the extra scope is relevant rather than churn.
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
7m 18s
Wall-clock time in the container
Full test suite
No new failures
3,695 passed · 6 skipped · 3,701 total
Contamination audit
Clean
No sign the agent saw the real fix
Patch size
207vs 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..fec09bdac 100644@@ -1432,6 +1432,97 @@ describe('vModel', () => { expect(input.selectedIndex).toBe(1) }) + it('should select the option whose Map value matches the model', () => {+ const mapA = new Map([['id', 1]])+ const mapB = new Map([['id', 2]])+ const { input } = mountSelectModel(mapB, value => value, false, [+ mapA,+ mapB,+ ])+ expect(input.selectedIndex).toBe(1)+ })++ it('should select the option whose Set value matches the model', () => {+ const setA = new Set([1])+ const setB = new Set([2])+ const { input } = mountSelectModel(new Set([2]), value => value, false, [+ setA,+ setB,+ ])+ expect(input.selectedIndex).toBe(1)+ })++ it('should not check a radio whose Map value differs from the model', () => {+ const component = defineComponent({+ data() {+ return { value: new Map([['id', 2]]) }+ },+ render() {+ return [+ withVModel(+ h('input', {+ type: 'radio',+ class: 'a',+ value: new Map([['id', 1]]),+ 'onUpdate:modelValue': setValue.bind(this),+ }),+ this.value,+ ),+ withVModel(+ h('input', {+ type: 'radio',+ class: 'b',+ value: new Map([['id', 2]]),+ 'onUpdate:modelValue': setValue.bind(this),+ }),+ this.value,+ ),+ ]+ },+ })+ render(h(component), root)+ const a = root.querySelector('.a') as HTMLInputElement+ const b = root.querySelector('.b') as HTMLInputElement+ expect(a.checked).toBe(false)+ expect(b.checked).toBe(true)+ })++ it('should check a radio whose Map value with object keys matches a reactive model', () => {+ const key = { id: 1 }+ const component = defineComponent({+ data() {+ return { value: new Map([[key, 'b']]) }+ },+ render() {+ return [+ withVModel(+ h('input', {+ type: 'radio',+ class: 'a',+ value: new Map([[key, 'a']]),+ 'onUpdate:modelValue': setValue.bind(this),+ }),+ this.value,+ ),+ withVModel(+ h('input', {+ type: 'radio',+ class: 'b',+ value: new Map([[key, 'b']]),+ 'onUpdate:modelValue': setValue.bind(this),+ }),+ this.value,+ ),+ ]+ },+ })+ render(h(component), root)+ const a = root.querySelector('.a') as HTMLInputElement+ const b = root.querySelector('.b') as HTMLInputElement+ expect(a.checked).toBe(false)+ expect(b.checked).toBe(true)+ })+ it('should resync when a multiple select becomes single during the pending update', async () => { const component = defineComponent({ data() {packages/server-renderer/__tests__/ssrVModelHelpers.spec.tsindex 7d00b9cb7..34affdad6 100644@@ -19,6 +19,17 @@ 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([['a', 1]]), new Map([['b', 2]])),+ ).toBe(``)+ expect(+ ssrRenderDynamicModel('radio', new Map([['a', 1]]), new Map([['a', 1]])),+ ).toBe(` checked`)+ expect(ssrRenderDynamicModel('radio', new Set([1]), new Set([2]))).toBe(``)+ expect(ssrRenderDynamicModel('radio', new Set([1]), new Set([1]))).toBe(+ ` checked`,+ ) }) test('ssrGetDynamicModelProps', () => {packages/shared/__tests__/looseEqual.spec.tsindex 2dea58ce5..1501d35cf 100644@@ -233,4 +233,78 @@ 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)+ // nested maps+ expect(+ looseEqual(+ new Map([['a', new Map([['b', 1]])]]),+ new Map([['a', new Map([['b', 2]])]]),+ ),+ ).toBe(false)+ // keys are compared loosely+ expect(+ looseEqual(new Map([[{ id: 1 }, 'x']]), new Map([[{ id: 1 }, 'x']])),+ ).toBe(true)+ expect(+ looseEqual(new Map([[{ id: 1 }, 'x']]), new Map([[{ id: 2 }, 'x']])),+ ).toBe(false)+ // maps are 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)+ expect(looseEqual(new Map(), '[object 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)+ // element 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)+ // each element must match a distinct element of the other set+ expect(+ looseEqual(new Set([{ a: 1 }, { a: 2 }]), new Set([{ a: 1 }, { a: 1 }])),+ ).toBe(false)+ expect(+ looseEqual(new Set([{ a: 1 }, { a: 1 }]), new Set([{ a: 1 }, { a: 2 }])),+ ).toBe(false)+ // sets are not equal to other types+ expect(looseEqual(new Set(), {})).toBe(false)+ expect(looseEqual({}, new Set())).toBe(false)+ expect(looseEqual(new Set([1]), [1])).toBe(false)+ expect(looseEqual(new Set(), '[object Set]')).toBe(false)+ }) })packages/shared/src/looseEqual.tsindex 9e7176721..5aff56527 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,25 @@ function looseCompareArrays(a: any[], b: any[]) { return equal } +// Maps are compared as collections of [key, value] entries so that keys are+// matched loosely too (e.g. a reactive Map yields proxied object keys that a+// raw Map's `has()` would not find)+function looseCompareCollections(+ a: Map<any, any> | Set<any>,+ b: Map<any, any> | Set<any>,+) {+ if (a.size !== b.size) return false+ // match each item of `a` to a distinct, loosely equal item of `b`+ const unmatched = Array.from(b)+ for (const value of a) {+ let index = unmatched.indexOf(value)+ if (index === -1) index = looseIndexOf(unmatched, value)+ 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 +45,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 ? looseCompareCollections(a, b) : false+ }+ aValidType = isSet(a)+ bValidType = isSet(b)+ if (aValidType || bValidType) {+ return aValidType && bValidType ? looseCompareCollections(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) {