Backtestsvuerun-20261002-115633#15320

Issue #15320 Merged fix PR #15328 Run 2 Oct 2026 · run-20261002-115633 vuejs/core

looseEqual() reports Map and Set instances with different contents as equal

Better

Our patch was judged better than the merged fix.

In this judgment, Patch A = our agent, Patch B = the merged fix.

The two fixes are algorithmically almost identical. Each adds `isMap`/`isSet` branches that send matching types to an order-insensitive `looseCompareCollections`. That helper checks `size`, then requires each item in `a` to loosely match a distinct, not-yet-matched item in `b`. Map entries are compared as `[key, value]` arrays through `looseEqual`, so keys and values are both compared loosely. Both fix the root cause: Maps and Sets were falling through to `Object.keys`/`String()`. Both also handle mixed-type cases (Map vs Set, Map vs object) by returning false.

Placement differs slightly. A puts the checks before the generic object branch, mirroring the Date/Symbol/Array pattern the issue suggested. B nests them inside the object branch after both values are confirmed to be objects. Both behave the same.

The real difference is test strength. A's `looseEqual` tests cover:
- empty vs non-empty in both directions
- same key with a different value, and different key with the same value
- key-order insensitivity
- loose comparison of values and object keys
- the distinct-match requirement, with duplicate-looking elements in both directions, which is exactly the property the matched-array logic exists for
- nested Map inside Set
- several cross-type comparisons

A's `v-model` test also goes further. It checks the initial selection, then reactive updates to new structurally equal Maps and Sets, and a no-match case (`selectedIndex -1`). This exercises the user-facing symptom thoroughly.

B's tests are correct and would fail before the fix. However, they are thinner: there is no explicit distinct-matching test, and only the initial render is checked in the `v-model` test.

A also has a minor craft nit: it splits an import across multiple lines even though the import would fit on one. With equivalent correctness, A wins on tests.

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

8m 16s

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

166vs 116 merged

Changed lines, ours vs merged

Vue 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

Our patch+165 −1
packages/runtime-dom/__tests__/directives/vModel.spec.tsindex 429163126..46725f37e 100644@@ -1009,6 +1009,59 @@ describe('vModel', () => {     expect(bar.selected).toEqual(true)   }) +  it('single select should match Map/Set option values by content', async () => {+    const mapA = new Map([['id', 1]])+    const mapB = new Map([['id', 2]])+    const setA = new Set([1])+    const setB = new Set([2])+    const component = defineComponent({+      data() {+        return { value: mapB as any }+      },+      render() {+        return [+          withVModel(+            h(+              'select',+              {+                value: null,+                'onUpdate:modelValue': setValue.bind(this),+              },+              [+                h('option', { value: mapA }),+                h('option', { value: mapB }),+                h('option', { value: setA }),+                h('option', { value: setB }),+              ],+            ),+            this.value,+          ),+        ]+      },+    })+    render(h(component), root)++    const input = root.querySelector('select')+    const data = root._vnode.component.data+    expect(input.selectedIndex).toEqual(1)++    data.value = new Map([['id', 1]])+    await nextTick()+    expect(input.selectedIndex).toEqual(0)++    data.value = setB+    await nextTick()+    expect(input.selectedIndex).toEqual(3)++    data.value = new Set([1])+    await nextTick()+    expect(input.selectedIndex).toEqual(2)++    data.value = new Map([['id', 3]])+    await nextTick()+    expect(input.selectedIndex).toEqual(-1)+  })+   it('multiple select (model is Array)', async () => {     const component = defineComponent({       data() {packages/shared/__tests__/looseEqual.spec.tsindex 2dea58ce5..2c0b4bb44 100644@@ -233,4 +233,76 @@ describe('utils/looseEqual', () => {     expect(looseEqual(arr1, arr5)).toBe(false)     expect(looseEqual(arr5, arr1)).toBe(false)   })++  test('compares Maps correctly', () => {+    expect(looseEqual(new Map(), new Map())).toBe(true)+    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([['b', 1]]))).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)+    const objKeyMap1 = new Map([[{ k: 1 }, 1]])+    const objKeyMap2 = new Map([[{ k: 1 }, 1]])+    const objKeyMap3 = new Map([[{ k: 2 }, 1]])+    expect(looseEqual(objKeyMap1, objKeyMap2)).toBe(true)+    expect(looseEqual(objKeyMap1, objKeyMap3)).toBe(false)+    // different types+    expect(looseEqual(new Map(), {})).toBe(false)+    expect(looseEqual({}, new Map())).toBe(false)+    expect(looseEqual(new Map(), [])).toBe(false)+    expect(looseEqual(new Map(), new Set())).toBe(false)+    expect(looseEqual(new Map([['a', 1]]), { a: 1 })).toBe(false)+  })++  test('compares Sets correctly', () => {+    expect(looseEqual(new Set(), new Set())).toBe(true)+    expect(looseEqual(new Set([1, 2]), new Set([1, 2]))).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([1, 2]), new Set([1, 3]))).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)+    // each element must match a distinct element+    expect(+      looseEqual(new Set([{ a: 1 }, { a: 1 }]), new Set([{ a: 1 }, { b: 2 }])),+    ).toBe(false)+    expect(+      looseEqual(new Set([{ a: 1 }, { b: 2 }]), new Set([{ a: 1 }, { a: 1 }])),+    ).toBe(false)+    // nested collections+    const nestedSet1 = new Set([new Map([['a', 1]])])+    const nestedSet2 = new Set([new Map([['a', 1]])])+    const nestedSet3 = new Set([new Map([['a', 2]])])+    expect(looseEqual(nestedSet1, nestedSet2)).toBe(true)+    expect(looseEqual(nestedSet1, nestedSet3)).toBe(false)+    // different types+    expect(looseEqual(new Set(), {})).toBe(false)+    expect(looseEqual(new Set(), [])).toBe(false)+    expect(looseEqual([], new Set())).toBe(false)+  }) })packages/shared/src/looseEqual.tsindex 9e7176721..8194d4d81 100644@@ -1,4 +1,11 @@-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 +16,28 @@ function looseCompareArrays(a: any[], b: any[]) {   return equal } +// Order-insensitive comparison of Map entries / Set values. Each item in `a`+// must loosely match a distinct, not-yet-matched item in `b`.+function looseCompareCollections(+  a: Map<any, any> | Set<any>,+  b: Map<any, any> | Set<any>,+) {+  if (a.size !== b.size) return false+  const bItems: any[] = Array.from(b)+  const matched: boolean[] = new Array(bItems.length).fill(false)+  for (const item of a) {+    let found = false+    for (let i = 0; i < bItems.length; i++) {+      if (!matched[i] && looseEqual(item, bItems[i])) {+        matched[i] = found = true+        break+      }+    }+    if (!found) return false+  }+  return true+}+ export function looseEqual(a: any, b: any): boolean {   if (a === b) return true   let aValidType = isDate(a)@@ -26,6 +55,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) { 
Merged fix · PR #15328+115 −1
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) {