Backtestsvuerun-20261009-161443#15320

Issue #15320 Merged fix PR #15328 Run 9 Oct 2026 · run-20261009-161443 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.

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

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+219 −1
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) { 
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) {