Backtestsvuerun-20261001-022054#9239
the div which has the ref attribute inside the v-for, when I v-if toggle them, the ref value.length increase more and more
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 same root cause. When a v-for child has `:key`, it is compiled as a block, so buildProps skips NEED_PATCH. transformFor then turns it into a plain vnode inside a stable fragment (constant source like `i in 3`), leaving patchFlag 0. The child is therefore missing from dynamicChildren, so unmounting the v-if branch never clears its ref (or runs its vnode/directive unmount hooks). Both patches add NEED_PATCH at the point where transformFor demotes the child from block to vnode. On the reported scenario they are equally correct. Patch B is a small change confined to vFor.ts. It checks `childBlock.directives` plus a helper that scans the element's AST props for `ref` / `:ref` / `@vue:*` / `onVnode*`. Its runtime test reproduces the issue almost exactly: v-if wrapping a keyed constant v-for with element and component refs, toggled three times, asserting lengths stay at 3/0. That test fails before the fix and passes after. Its compiler test covers static ref, dynamic ref, directive and vnode hook. Patch A also fixes the issue. It threads new `needsPatch` and `isBlockRequired` fields through the VNodeCall AST and buildProps' return type, and reorders the `hasRef` detection. It also adds an adjacent behaviour change: stable v-for children with directives or before-update hooks plus children are now kept as blocks. That fixes a separate ordering concern, but it alters codegen for existing templates, widens the public AST interface, and touches more of buildProps' patch-flag logic, so it carries more regression risk. Patch A's new compiler tests live in transformElement.spec and rely on `parseWithForTransform` and `getVForChild` indexing into codegen internals, which is somewhat brittle. Its runtime tests are thorough, but none reproduces the issue's exact v-if toggle with a component ref. With correctness on the issue equivalent, Patch B wins on scope and risk: a targeted fix with a direct regression test.
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
12m 53s22 turns
Wall-clock time in the container
Full test suite
No new failures
3,653 passed · 6 skipped · 3,659 total
Contamination audit
Clean
No sign the agent saw the real fix
Patch size
87vs 338 merged
Changed lines, ours vs merged
The issue
View on GitHubVue version
3.2.47
Link to minimal reproduction
Steps to reproduce
if I click toggleVisible many times,
- the
refDivSingletoggle between null and div - the
refCompSingletoggle between null and {} - the
refDivArr.lengthincrease more and more <-- error here - the
refCompArr.lengthtoggle between 3 and 0
if I use ref function, it don't get null
<img width="532" alt="image" src="https://github.com/vuejs/core/assets/417448/b1a09a97-2c9f-4310-9430-27aa04b79863">
What is expected?
the refDivArr.length should toggle between 3 and 0, same as the refCompArr.length
What is actually happening?
the refDivArr.length increase more and more
System Info
_No response_
Any additional comments?
_No response_
The two patches
packages/compiler-core/__tests__/transforms/vFor.spec.tsindex 839d9d358..65b1a5615 100644@@ -1118,6 +1118,33 @@ describe('compiler: v-for', () => { expect(generate(root).code).toMatchSnapshot() }) + test('keyed v-for with constant source: ref/directive/vnode hook need patch', () => {+ for (const attr of [+ 'ref="foo"',+ ':ref="foo"',+ 'v-foo',+ '@vue:unmounted="foo"',+ ]) {+ const {+ node: { codegenNode },+ } = parseWithForTransform(`<div v-for="i in 3" :key="i" ${attr}/>`, {+ prefixIdentifiers: true,+ cacheHandlers: true,+ })+ const { innerVNodeCall } = assertSharedCodegen(+ codegenNode,+ true,+ false,+ false,+ )+ expect(innerVNodeCall).toMatchObject({+ tag: `"div"`,+ isBlock: false,+ patchFlag: PatchFlags.NEED_PATCH,+ })+ }+ })+ test('template v-for key w/ :key shorthand on div', () => { const { node: { codegenNode },packages/compiler-core/src/transforms/vFor.tsindex dcc31a9a9..eddd0e97d 100644@@ -37,6 +37,7 @@ import { findProp, injectProp, isSlotOutlet,+ isStaticExp, isTemplateNode, } from '../utils' import {@@ -206,6 +207,18 @@ export const transformFor: NodeTransform = createStructuralDirectiveTransform( helper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent)) } else { helper(getVNodeHelper(context.inSSR, childBlock.isComponent))+ // the child was compiled as a block (e.g. due to :key) so it may+ // lack NEED_PATCH; add it so the stable fragment tracks it in+ // dynamicChildren and refs/vnode hooks/directives are processed+ if (+ (!childBlock.patchFlag ||+ childBlock.patchFlag === PatchFlags.NEED_HYDRATION) &&+ (childBlock.directives ||+ hasRefOrVnodeHook(children[0] as PlainElementNode))+ ) {+ childBlock.patchFlag =+ (childBlock.patchFlag || 0) | PatchFlags.NEED_PATCH+ } } } @@ -391,3 +404,14 @@ function createParamsList( .slice(0, i + 1) .map((arg, i) => arg || createSimpleExpression(`_`.repeat(i + 1), false)) }++function hasRefOrVnodeHook(el: PlainElementNode): boolean {+ return el.props.some(p => {+ if (p.type === NodeTypes.ATTRIBUTE) return p.name === 'ref'+ if (!p.arg || !isStaticExp(p.arg)) return false+ const name = p.arg.content+ return p.name === 'on'+ ? name.startsWith('vue:')+ : p.name === 'bind' && (name === 'ref' || name.startsWith('onVnode'))+ })+}packages/vue/__tests__/index.spec.tsindex 79e48b775..c00b137df 100644@@ -329,6 +329,42 @@ describe('compiler + runtime integration', () => { expect(container.innerHTML).toBe(`<div>foo</div>`) }) + it('refs in keyed v-for with constant source inside v-if', async () => {+ const container = document.createElement('div')+ const isVisible = ref(true)+ const refDivArr = ref<any[]>([])+ const refCompArr = ref<any[]>([])+ const CompB = { template: `<div>test</div>` }+ createApp({+ components: { CompB },+ // match SFC compilation so the constant v-for source yields a+ // stable fragment+ compilerOptions: { prefixIdentifiers: true } as any,+ setup: () => ({ isVisible, refDivArr, refCompArr }),+ template:+ `<div v-if="isVisible">` ++ `<div v-for="(vv0, index0) in 3" :key="index0" ref="refDivArr">` ++ `<CompB ref="refCompArr"/>` ++ `</div>` ++ `</div>`,+ }).mount(container)++ for (let i = 0; i < 3; i++) {+ expect(refDivArr.value.length).toBe(3)+ expect(refCompArr.value.length).toBe(3)++ isVisible.value = false+ await nextTick()+ expect(refDivArr.value.length).toBe(0)+ expect(refCompArr.value.length).toBe(0)++ isVisible.value = true+ await nextTick()+ }+ expect(refDivArr.value.length).toBe(3)+ expect(refCompArr.value.length).toBe(3)+ })+ // #2413 it('EMPTY_ARR should not change', () => { const App = {
packages/compiler-core/__tests__/transforms/transformElement.spec.tsindex bf3510a05..8215ceedb 100644@@ -74,6 +74,12 @@ function parseWithBind(template: string, options?: CompilerOptions) { }) } +function getVForChild(+ node: ReturnType<typeof parseWithForTransform>['node'],+): VNodeCall {+ return node.codegenNode.children.arguments[1].returns as VNodeCall+}+ describe('compiler: element transform', () => { test('import + resolve component', () => { const { root } = parseWithElementTransform(`<Foo/>`)@@ -1028,6 +1034,105 @@ describe('compiler: element transform', () => { expect(node.patchFlag).toBe(PatchFlags.NEED_PATCH) }) + test('NEED_PATCH (stable v-for + static ref)', () => {+ const { node } = parseWithForTransform(+ `<div v-for="i in 3" :key="i" ref="foo" />`,+ { prefixIdentifiers: true },+ )+ const child = getVForChild(node)+ expect(child.isBlock).toBe(false)+ expect(child.patchFlag).toBe(PatchFlags.NEED_PATCH)+ })++ test('NEED_PATCH (stable v-for + custom directives)', () => {+ const { node } = parseWithForTransform(+ `<div v-for="i in 3" :key="i" v-dir />`,+ { prefixIdentifiers: true },+ )+ const child = getVForChild(node)+ expect(child.isBlock).toBe(false)+ expect(child.patchFlag).toBe(PatchFlags.NEED_PATCH)+ })++ test('NEED_PATCH (stable v-for + vnode hooks)', () => {+ const { node } = parseWithForTransform(+ `<div v-for="i in 3" :key="i" @vue:unmounted="foo" />`,+ {+ prefixIdentifiers: true,+ cacheHandlers: true,+ directiveTransforms: {+ bind: transformBind,+ on: transformOn,+ },+ },+ )+ const child = getVForChild(node)+ expect(child.isBlock).toBe(false)+ expect(child.patchFlag).toBe(PatchFlags.NEED_PATCH)+ })++ test('NEED_PATCH (stable v-for + setup-const function ref)', () => {+ const { node } = parseWithForTransform(+ `<div v-for="i in 3" :key="i" :ref="setRefFn" />`,+ {+ prefixIdentifiers: true,+ bindingMetadata: {+ setRefFn: BindingTypes.SETUP_CONST,+ },+ },+ )+ const child = getVForChild(node)+ expect(child.isBlock).toBe(false)+ expect(child.patchFlag).toBe(PatchFlags.NEED_PATCH)+ })++ test('preserve block for stable v-for + custom directive with children', () => {+ const { node } = parseWithForTransform(+ `<div v-for="i in 3" v-dir>{{ i }}</div>`,+ { prefixIdentifiers: true },+ )+ const child = getVForChild(node)+ expect(child.isBlock).toBe(true)+ expect(child.patchFlag).toBe(PatchFlags.TEXT)+ })++ test.each(['before-update', 'beforeUpdate'])(+ 'preserve block for stable v-for + @vue:%s vnode hook',+ hook => {+ const { node } = parseWithForTransform(+ `<div v-for="i in 3" @vue:${hook}="foo"><span /></div>`,+ {+ prefixIdentifiers: true,+ cacheHandlers: true,+ directiveTransforms: {+ bind: transformBind,+ on: transformOn,+ },+ },+ )+ const child = getVForChild(node)+ expect(child.isBlock).toBe(true)+ expect(child.patchFlag).toBeUndefined()+ },+ )++ test('does not add NEED_PATCH when another patch flag tracks the vnode', () => {+ const { node } = parseWithForTransform(+ `<div v-for="i in 3" :key="i" @vue:unmounted="foo">{{ i }}</div>`,+ {+ prefixIdentifiers: true,+ cacheHandlers: true,+ directiveTransforms: {+ bind: transformBind,+ on: transformOn,+ },+ },+ )+ const child = getVForChild(node)+ expect(child.isBlock).toBe(false)+ expect(child.patchFlag).toBe(PatchFlags.TEXT)+ })+ test('script setup inline mode template ref (binding exists)', () => { const { node } = parseWithElementTransform(`<input ref="input"/>`, { inline: true,packages/compiler-core/src/ast.tsindex e6da01edb..f67231539 100644@@ -330,6 +330,10 @@ export interface VNodeCall extends Node { patchFlag: PatchFlags | undefined dynamicProps: string | SimpleExpressionNode | undefined directives: DirectiveArguments | undefined+ /** Whether this vnode must be patched if a later transform makes it non-block. */+ needsPatch?: boolean+ /** Whether a later transform must preserve this vnode as a block. */+ isBlockRequired?: boolean isBlock: boolean disableTracking: boolean isComponent: booleanpackages/compiler-core/src/transforms/transformElement.tsindex 40f08d45b..b2024b329 100644@@ -102,6 +102,8 @@ export const transformElement: NodeTransform = (node, context) => { let vnodeDynamicProps: VNodeCall['dynamicProps'] let dynamicPropNames: string[] | undefined let vnodeDirectives: VNodeCall['directives']+ let needsPatch = false+ let isBlockRequired = false let shouldUseBlock = // dynamic component may resolve to plain elements@@ -127,6 +129,8 @@ export const transformElement: NodeTransform = (node, context) => { vnodeProps = propsBuildResult.props patchFlag = propsBuildResult.patchFlag dynamicPropNames = propsBuildResult.dynamicPropNames+ needsPatch = propsBuildResult.needsPatch+ isBlockRequired = propsBuildResult.isBlockRequired const directives = propsBuildResult.directives vnodeDirectives = directives && directives.length@@ -206,7 +210,7 @@ export const transformElement: NodeTransform = (node, context) => { vnodeDynamicProps = stringifyDynamicPropNames(dynamicPropNames) } - node.codegenNode = createVNodeCall(+ const vnodeCall = (node.codegenNode = createVNodeCall( context, vnodeTag, vnodeProps,@@ -218,7 +222,15 @@ export const transformElement: NodeTransform = (node, context) => { false /* disableTracking */, isComponent, node.loc,- )+ ))+ needsPatch =+ needsPatch && (patchFlag === 0 || patchFlag === PatchFlags.NEED_HYDRATION)+ if (needsPatch) {+ vnodeCall.needsPatch = true+ }+ if (isBlockRequired) {+ vnodeCall.isBlockRequired = true+ } } } @@ -382,6 +394,8 @@ export function buildProps( patchFlag: number dynamicPropNames: string[] shouldUseBlock: boolean+ needsPatch: boolean+ isBlockRequired: boolean } { const { tag, loc: elementLoc, children } = node let properties: ObjectExpression['properties'] = []@@ -389,6 +403,7 @@ export function buildProps( const runtimeDirectives: DirectiveNode[] = [] const hasChildren = children.length > 0 let shouldUseBlock = false+ let isBlockRequired = false // patchFlag analysis let patchFlag = 0@@ -444,6 +459,10 @@ export function buildProps( hasVnodeHook = true } + if (name === 'ref') {+ hasRef = true+ }+ if (isEventHandler && value.type === NodeTypes.JS_CALL_EXPRESSION) { // handler wrapped with internal helper e.g. withModifiers(fn) // extract the actual expression@@ -460,13 +479,15 @@ export function buildProps( return } - if (name === 'ref') {- hasRef = true- } else if (name === 'class') {+ if (name === 'class') { hasClassBinding = true } else if (name === 'style') { hasStyleBinding = true- } else if (name !== 'key' && !dynamicPropNames.includes(name)) {+ } else if (+ name !== 'ref' &&+ name !== 'key' &&+ !dynamicPropNames.includes(name)+ ) { dynamicPropNames.push(name) } @@ -573,14 +594,21 @@ export function buildProps( continue } + // #938: elements with dynamic keys should be forced into blocks+ if (isVBind && isStaticArgOf(arg, 'key')) {+ shouldUseBlock = true+ }+ // inline before-update hooks need to remain blocks so that they are+ // invoked before children if (- // #938: elements with dynamic keys should be forced into blocks- (isVBind && isStaticArgOf(arg, 'key')) ||- // inline before-update hooks need to force block so that it is invoked- // before children- (isVOn && hasChildren && isStaticArgOf(arg, 'vue:before-update'))+ isVOn &&+ hasChildren &&+ arg &&+ isStaticExp(arg) &&+ camelize(arg.content) === 'vue:beforeUpdate' ) { shouldUseBlock = true+ isBlockRequired = true } if (isVBind && isStaticArgOf(arg, 'ref')) {@@ -691,6 +719,7 @@ export function buildProps( // to ensure before-update gets called before children update if (hasChildren) { shouldUseBlock = true+ isBlockRequired = true } } }@@ -736,11 +765,10 @@ export function buildProps( patchFlag |= PatchFlags.NEED_HYDRATION } }- if (- !shouldUseBlock &&+ const needsPatch = (patchFlag === 0 || patchFlag === PatchFlags.NEED_HYDRATION) && (hasRef || hasVnodeHook || runtimeDirectives.length > 0)- ) {+ if (!shouldUseBlock && needsPatch) { patchFlag |= PatchFlags.NEED_PATCH } @@ -825,6 +853,8 @@ export function buildProps( patchFlag, dynamicPropNames, shouldUseBlock,+ needsPatch,+ isBlockRequired, } } packages/compiler-core/src/transforms/vFor.tsindex dcc31a9a9..ebf67d3d7 100644@@ -186,7 +186,9 @@ export const transformFor: NodeTransform = createStructuralDirectiveTransform( if (isTemplate && keyProperty) { injectProp(childBlock, keyProperty, context) }- if (childBlock.isBlock !== !isStableFragment) {+ const shouldUseBlock =+ !isStableFragment || childBlock.isBlockRequired === true+ if (childBlock.isBlock !== shouldUseBlock) { if (childBlock.isBlock) { // switch from block to vnode removeHelper(OPEN_BLOCK)@@ -200,12 +202,16 @@ export const transformFor: NodeTransform = createStructuralDirectiveTransform( ) } }- childBlock.isBlock = !isStableFragment+ childBlock.isBlock = shouldUseBlock if (childBlock.isBlock) { helper(OPEN_BLOCK) helper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent)) } else { helper(getVNodeHelper(context.inSSR, childBlock.isComponent))+ if (childBlock.needsPatch) {+ childBlock.patchFlag = ((childBlock.patchFlag ?? 0) |+ PatchFlags.NEED_PATCH) as PatchFlags+ } } } packages/vue/__tests__/index.spec.tsindex 79e48b775..98f00cf28 100644@@ -1,5 +1,19 @@+import { BindingTypes, type CompilerOptions } from '@vue/compiler-core'+import { compile } from '@vue/compiler-dom' import { EMPTY_ARR } from '@vue/shared'-import { createApp, nextTick, reactive, ref } from '../src'+import { type VNode, createApp, nextTick, reactive, ref } from '../src'+import * as Vue from '../src'+import type { InternalRenderFunction } from '../../runtime-core/src/component'++function compileToFunction(template: string, options?: CompilerOptions) {+ const { code } = compile(template, {+ hoistStatic: true,+ ...options,+ })+ const render = new Function('Vue', code)(Vue) as InternalRenderFunction+ render._rc = true+ return render+} describe('compiler + runtime integration', () => { it('should support runtime template compilation', () => {@@ -347,4 +361,149 @@ describe('compiler + runtime integration', () => { app.mount(root) expect(root.innerHTML).toBe('<div>60000000100000111</div>') })++ describe('stable v-for lifecycle', () => {+ test('clears static ref arrays on branch removal', async () => {+ const show = ref(true)+ const items = ref<HTMLElement[]>([])+ const app = createApp({+ setup: () => ({ items, show }),+ render: compileToFunction(+ `<template v-if="show"><div v-for="i in 3" :key="i" ref="items" /></template>`,+ { prefixIdentifiers: true },+ ),+ })+ const container = document.createElement('div')++ app.mount(container)+ expect(items.value).toHaveLength(3)++ show.value = false+ await nextTick()+ expect(items.value).toHaveLength(0)++ app.unmount()+ })++ test('calls setup-const function refs with null on branch removal', async () => {+ const show = ref(true)+ const values: (Element | null)[] = []+ const setRef = (value: Element | null) => values.push(value)+ const app = createApp({+ setup: () => ({ setRef, show }),+ render: compileToFunction(+ `<template v-if="show"><div v-for="i in 1" :ref="setRef" /></template>`,+ {+ prefixIdentifiers: true,+ bindingMetadata: {+ setRef: BindingTypes.SETUP_CONST,+ },+ },+ ),+ })+ const container = document.createElement('div')++ app.mount(container)+ expect(values).toHaveLength(1)+ expect(values[0]).toBeInstanceOf(HTMLDivElement)++ show.value = false+ await nextTick()+ expect(values).toHaveLength(2)+ expect(values[1]).toBeNull()++ app.unmount()+ })++ test('calls directive unmounted hooks on branch removal', async () => {+ const show = ref(true)+ const unmounted = vi.fn()+ const app = createApp({+ directives: { dir: { unmounted } },+ setup: () => ({ show }),+ render: compileToFunction(+ `<template v-if="show"><div v-for="i in 1" v-dir /></template>`,+ { prefixIdentifiers: true },+ ),+ })+ const container = document.createElement('div')++ app.mount(container)+ show.value = false+ await nextTick()+ expect(unmounted).toHaveBeenCalledOnce()++ app.unmount()+ })++ test('calls vnode unmounted hooks on branch removal', async () => {+ const show = ref(true)+ const onVnodeUnmounted = vi.fn()+ const app = createApp({+ setup: () => ({ onVnodeUnmounted, show }),+ render: compileToFunction(+ `<template v-if="show"><div v-for="i in 1" @vue:unmounted="onVnodeUnmounted" /></template>`,+ { prefixIdentifiers: true },+ ),+ })+ const container = document.createElement('div')++ app.mount(container)+ show.value = false+ await nextTick()+ expect(onVnodeUnmounted).toHaveBeenCalledOnce()++ app.unmount()+ })++ test('runs directive beforeUpdate before child updates', async () => {+ const value = ref('old')+ const observed: string[] = []+ const app = createApp({+ directives: {+ dir: {+ beforeUpdate(el: HTMLElement) {+ observed.push(el.textContent!)+ },+ },+ },+ setup: () => ({ value }),+ render: compileToFunction(+ `<div v-for="i in 1" v-dir>{{ value }}</div>`,+ { prefixIdentifiers: true },+ ),+ })+ const container = document.createElement('div')++ app.mount(container)+ value.value = 'new'+ await nextTick()+ expect(observed).toEqual(['old'])++ app.unmount()+ })++ test('runs vnode beforeUpdate before nested child updates', async () => {+ const value = ref('old')+ const observed: string[] = []+ const onVnodeBeforeUpdate = (vnode: VNode) => {+ observed.push((vnode.el as HTMLElement).textContent!)+ }+ const app = createApp({+ setup: () => ({ onVnodeBeforeUpdate, value }),+ render: compileToFunction(+ `<div v-for="i in 1" @vue:beforeUpdate="onVnodeBeforeUpdate"><span>{{ value }}</span></div>`,+ { prefixIdentifiers: true },+ ),+ })+ const container = document.createElement('div')++ app.mount(container)+ value.value = 'new'+ await nextTick()+ expect(observed).toEqual(['old'])++ app.unmount()+ })+ }) })
What the agent reported
I fixed the bug in the template compiler. The two new tests fail without the fix and pass with it, and the surrounding test suites all pass.
What was wrong: In an SFC, the reported template <div v-for="(vv0, index0) in 3" :key="index0" ref="refDivArr"> loops over a constant (3). That makes the compiler treat the list as fixed, and it got the item <div> wrong:
:keymakestransformElementcompile the item<div>in its tracked form, which skips the flag that marks it as having a ref (NEED_PATCH).vFor.tsthen turns the item back into a plain, untracked vnode because the list is fixed, but never adds that flag back.- With no flag, the item isn't registered with its parent. When the
v-ifhides the content, the runtime only unmounts registered nodes. So it never removes the<div>s fromrefDivArr, and each time they reappear 3 more get added (3, 6, 9…). Each<CompB>does get the flag, sorefCompArrbehaved correctly.
What I changed (packages/compiler-core/src/transforms/vFor.ts): in that same spot, the item now gets NEED_PATCH back when it has no other flag and has a ref (ref or :ref), a custom directive, or a vnode hook (@vue:*, :onVnode*). These are the cases where transformElement would normally add it. The review found that a vnode hook alone could leave the item untracked in the same way, so I included that case. A :ref bound to a constant now also gets the flag, which costs a little extra work but is still correct.
Tests added:
packages/compiler-core/__tests__/transforms/vFor.spec.ts: a test that checks<div v-for="i in 3" :key="i" X/>getsNEED_PATCHforref="foo",:ref="foo",v-fooand@vue:unmounted="foo". Without the fix it fails on the first case (patch flag missing). The loop stops at the first failure, so the other three were never seen failing on their own. For the vnode-hook case, I'm relying on the reviewer's reading of the code that the flag is 0 without the fix.packages/vue/__tests__/index.spec.ts: the exact template from the report, compiled at runtime. It togglesisVisiblethree times and checks thatrefDivArrandrefCompArrboth go 3 → 0 → 3. It setsprefixIdentifiers: true(cast withas anybecause the runtime compiler options type doesn't include it) so it compiles the way an SFC does. Without that option the bug doesn't occur and the test would pass even without the fix. Without the fix it fails withexpected 3 to be +0.
Evidence: with the fix removed, both tests fail (2 failed, 74 passed). With it, compiler-core, compiler-dom, compiler-sfc, compiler-ssr, runtime-core, server-renderer and the vue tests all pass: 133 files, 2797 tests, 1 skipped, no snapshot changes. Prettier and tsc --noEmit are clean. A first attempt at runtime-only tests copied the buggy compiler output by hand, so they could never pass; I removed them. No existing test was changed.
Requirements:
refDivArr.lengthshould switch between 3 and 0 instead of growing: done, covered by the vue test.refCompArr.lengthshould keep switching between 3 and 0: done, the same test checks it on every cycle.refDivSingle/refCompSingleswitching between null and the element: no change. The report says this already works, and those refs aren't in av-for, so the change doesn't touch them.- "If I use ref function, it don't get null": no change. It only describes how function refs behave in the reporter's screenshot, with no fix requested.
All changes are uncommitted in the working tree.