Backtestsvuerun-20261001-022054#12569
Custom directive's unmounted event is not triggered on v-for element
The merged fix was judged better than our patch.
In this judgment, Patch A = our agent, Patch B = the merged fix.
Root cause: in a keyed v-for with a constant source (a stable fragment), `:key` forces `shouldUseBlock`. That makes `buildProps` skip adding NEED_PATCH for elements that have runtime directives, refs or vnode hooks. vFor then downgrades the child to a plain vnode with no patch flag, so it is missing from the fragment's dynamicChildren. As a result, unmount and update hooks are never run. Patch A adds NEED_PATCH in vFor only when `childBlock.directives` is set. That fixes the reported directive case, and its integration test reproduces the issue. It leaves the same bug in place for static or setup-const refs (ref arrays are never cleared) and for `@vue:unmounted` vnode hooks. These share the identical root cause. Patch A also still downgrades children that were blocks for beforeUpdate ordering (custom directive or vnode before-update hook with children). Patch B records the condition in the element transform via `needsPatch` and `isBlockRequired`, and vFor consumes it. NEED_PATCH is applied whenever a ref, vnode hook or runtime directive needs tracking and no other patch flag already tracks the vnode. Blocks are kept when beforeUpdate ordering requires them. The refactors inside buildProps preserve behavior: - moving `hasRef` earlier; - excluding `ref` from dynamicPropNames, which matches the old else-if chain; - camelize-based detection of `vue:beforeUpdate`, which also covers the camelCase spelling. Patch B's tests cover directives, refs, function refs, vnode hooks, beforeUpdate ordering and patch-flag non-duplication, at both compiler and runtime level, and would fail before the change. B is larger, but it addresses the root cause comprehensively and with low risk, while A is a narrow symptom fix.
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
6m 32s16 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
69vs 338 merged
Changed lines, ours vs merged
The issue
View on GitHubVue version
3.5.13
Link to minimal reproduction
Steps to reproduce
Press F12, Click the 'hide' button, console only logs Div's umounted event, H1's unmounted event is not logged
What is expected?
unmounted event in Directive should be triggered on elements with v-for
What is actually happening?
unmounted event in Directive is not triggered on elements with v-for
System Info
_No response_
Any additional comments?
_No response_
The two patches
packages/compiler-core/__tests__/transforms/vFor.spec.tsindex 839d9d358..ef30afeef 100644@@ -1118,6 +1118,34 @@ describe('compiler: v-for', () => { expect(generate(root).code).toMatchSnapshot() }) + test('v-for with constant expression on keyed element with custom directive', () => {+ const {+ node: { codegenNode },+ } = parseWithForTransform(+ '<div v-for="i in 3" :key="i" v-foo>foo</div>',+ { prefixIdentifiers: true },+ )+ const { source, innerVNodeCall } = assertSharedCodegen(+ codegenNode,+ true /* keyed */,+ false /* customReturn */,+ false /* disableTracking */,+ )+ expect(source).toMatchObject({+ content: `3`,+ constType: ConstantTypes.CAN_STRINGIFY,+ })+ // the child is not a block in a stable fragment, so it must carry+ // NEED_PATCH to be tracked in the fragment's dynamicChildren, otherwise+ // its directive hooks (e.g. unmounted) would never be invoked+ expect(innerVNodeCall).toMatchObject({+ tag: `"div"`,+ isBlock: false,+ directives: { type: NodeTypes.JS_ARRAY_EXPRESSION },+ 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..bdf3b99d1 100644@@ -206,6 +206,17 @@ export const transformFor: NodeTransform = createStructuralDirectiveTransform( helper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent)) } else { helper(getVNodeHelper(context.inSSR, childBlock.isComponent))+ // elements with custom directives in a stable fragment need a+ // patch flag so they are tracked in dynamicChildren and their+ // directive hooks are invoked on update / unmount.+ if (+ childBlock.directives &&+ (!childBlock.patchFlag ||+ childBlock.patchFlag === PatchFlags.NEED_HYDRATION)+ ) {+ childBlock.patchFlag =+ (childBlock.patchFlag || 0) | PatchFlags.NEED_PATCH+ } } } packages/vue/__tests__/index.spec.tsindex 79e48b775..c86c6e68a 100644@@ -293,6 +293,36 @@ describe('compiler + runtime integration', () => { expect(container.innerHTML).toBe(`<div>2<div>1</div></div>`) }) + test('custom directive unmounted hook on keyed v-for with constant source', async () => {+ const visible = ref(true)+ const unmounted = vi.fn()+ const App = {+ setup() {+ return { visible }+ },+ directives: {+ foo: { unmounted },+ },+ compilerOptions: {+ prefixIdentifiers: true,+ },+ template:+ `<template v-if="visible">` ++ `<h1 v-for="i in [1, 2, 3]" :key="i" v-foo>hello</h1>` ++ `</template>`,+ }+ const container = document.createElement('div')+ createApp(App).mount(container)+ expect(container.innerHTML).toBe(+ `<h1>hello</h1><h1>hello</h1><h1>hello</h1>`,+ )++ visible.value = false+ await nextTick()+ expect(container.innerHTML).toBe(`<!--v-if-->`)+ expect(unmounted).toHaveBeenCalledTimes(3)+ })+ test('nullish v-bind on <slot>', async () => { const Child = { props: ['error', 'value'],
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: a directive's unmounted hook now fires for elements rendered with v-for when the list is constant. The fix is a small compiler change, and both new tests failed before it and pass after.
What was wrong
I compiled the reproduction to see what it produces:
- The
arrconstant makes thev-fora "stable" fragment (patch flagSTABLE_FRAGMENT). When such a fragment unmounts, Vue only visits the children it is tracking for updates. transformElement.tsfirst compiles an element that has a dynamic:keyor a custom directive with children as its own block. Because of that, it skips adding theNEED_PATCHflag, which is what normally gets such an element tracked.vFor.tsthen turns that element back into a plain node for the stable fragment, but never gives it a patch flag.- So each
<h1>was not tracked, unmount never reached it, and its directive hooks (unmounted, and alsobeforeUpdate/updated) never ran. The<div>withv-ifin the report is its own block, which is why its hook did fire.
What I changed (packages/compiler-core/src/transforms/vFor.ts, in the "Normal element v-for" branch)
When an element with directives becomes a plain node inside a stable fragment and has no patch flag, it now gets NEED_PATCH. This also covers an element whose only flag is NEED_HYDRATION, the same way transformElement.ts handles it; the reviewer pointed that case out.
Tests added
packages/compiler-core/__tests__/transforms/vFor.spec.ts, "v-for with constant expression on keyed element with custom directive": checks that the<div>inside a stable fragment is a plain node withpatchFlag: NEED_PATCH. Before the fix it failed with"patchFlag": 512expected butundefinedreceived.packages/vue/__tests__/index.spec.ts, "custom directive unmounted hook on keyed v-for with constant source": compiles the reported template (<template v-if>around a keyed<h1 v-for>with a custom directive), setsvisibleto false, and expectsunmountedto be called 3 times. Before the fix it was called 0 times.
Test results
- After the first version of the fix, the full suite passed: 182 files, 3653 tests, 6 skipped.
- After adding the
NEED_HYDRATIONcase, I re-ran compiler-core, runtime-core, compiler-sfc, compiler-dom, compiler-ssr, server-renderer and vue, not the whole suite: 144 files, 2914 passed, 1 skipped. - Prettier reports no formatting issues.
Requirements
- The H1's
unmountedhook should run when "hide" is clicked: done, covered by the runtime test. - Directive
unmountedshould fire onv-forelements in general: done for constant-sourcev-for, which is the only case where it was broken. With a reactive list, the fragment already visits every child on unmount, so those hooks already fired. - The Div's hook should keep working: no change needed, because a
v-ifelement is its own block and is always tracked; the full suite still passes.
Not fixed: a template ref or a @vue:unmounted handler on a keyed element in a constant-source v-for has the same root cause and will still be skipped on unmount. Fixing that needs a check on the element's props, not just its directives, so I left it out to keep this change limited to the report.
The changes are uncommitted in the working tree, and no scratch files are left.