fix(compiler-core): using v-once inside template with v-if error

packages/compiler-core/__tests__/transforms/__snapshots__/vIf.spec.ts.snap

@@ -86,6 +86,25 @@ return function render(_ctx, _cache) {
 }"
 `;
 
+exports[`compiler: v-if > codegen > template v-if w/ v-once 1`] = `
+"const _Vue = Vue
+
+return function render(_ctx, _cache) {
+  with (_ctx) {
+    const { setBlockTracking: _setBlockTracking, openBlock: _openBlock, createElementBlock: _createElementBlock, createCommentVNode: _createCommentVNode } = _Vue
+
+    return true
+      ? _cache[0] || (
+          _setBlockTracking(-1),
+          (_cache[0] = (_openBlock(), _createElementBlock("p", { key: 0 }, "foo"))).cacheIndex = 0,
+          _setBlockTracking(1),
+          _cache[0]
+        )
+      : _createCommentVNode("v-if", true)
+  }
+}"
+`;
+
 exports[`compiler: v-if > codegen > v-if + v-else 1`] = `
 "const _Vue = Vue
 

packages/compiler-core/__tests__/transforms/vIf.spec.ts

@@ -1,6 +1,7 @@
 import { baseParse as parse } from '../../src/parser'
 import { transform } from '../../src/transform'
 import { transformIf } from '../../src/transforms/vIf'
+import { transformOnce } from '../../src/transforms/vOnce'
 import { transformElement } from '../../src/transforms/transformElement'
 import { transformSlotOutlet } from '../../src/transforms/transformSlotOutlet'
 import {
@@ -35,7 +36,12 @@ function parseWithIfTransform(
 ) {
   const ast = parse(template, options)
   transform(ast, {
-    nodeTransforms: [transformIf, transformSlotOutlet, transformElement],
+    nodeTransforms: [
+      transformOnce,
+      transformIf,
+      transformSlotOutlet,
+      transformElement,
+    ],
     ...options,
   })
   if (!options.onError) {
@@ -425,6 +431,19 @@ describe('compiler: v-if', () => {
       expect(generate(root).code).toMatchSnapshot()
     })
 
+    test('template v-if w/ v-once', () => {
+      const {
+        root,
+        node: { codegenNode },
+      } = parseWithIfTransform(
+        `<template v-if="true"><p v-once>foo</p></template>`,
+      )
+      expect(codegenNode.consequent).toMatchObject({
+        type: NodeTypes.JS_CACHE_EXPRESSION,
+      })
+      expect(generate(root).code).toMatchSnapshot()
+    })
+
     test('v-if on <slot/>', () => {
       const {
         root,

packages/compiler-core/src/transforms/vIf.ts

@@ -31,7 +31,12 @@ import { ErrorCodes, createCompilerError } from '../errors'
 import { processExpression } from './transformExpression'
 import { validateBrowserExpression } from '../validateExpression'
 import { CREATE_COMMENT, FRAGMENT } from '../runtimeHelpers'
-import { findDir, findProp, getMemoedVNodeCall, injectProp } from '../utils'
+import {
+  findDir,
+  findProp,
+  getMemoedOrOnceVNodeCall,
+  injectProp,
+} from '../utils'
 import { PatchFlagNames, PatchFlags } from '@vue/shared'
 
 export const transformIf: NodeTransform = createStructuralDirectiveTransform(
@@ -294,7 +299,7 @@ function createChildrenCodegenNode(
     const ret = (firstChild as ElementNode).codegenNode as
       | BlockCodegenNode
       | MemoExpression
-    const vnodeCall = getMemoedVNodeCall(ret)
+    const vnodeCall = getMemoedOrOnceVNodeCall(ret)
     // Change createVNode to createBlock.
     if (vnodeCall.type === NodeTypes.VNODE_CALL) {
       convertToBlock(vnodeCall, context)

packages/compiler-core/src/utils.ts

@@ -553,13 +553,16 @@ export function hasScopeRef(
   }
 }
 
-export function getMemoedVNodeCall(
-  node: BlockCodegenNode | MemoExpression,
+export function getMemoedOrOnceVNodeCall(
+  node: BlockCodegenNode | MemoExpression | CacheExpression,
 ): VNodeCall | RenderSlotCall {
   if (node.type === NodeTypes.JS_CALL_EXPRESSION && node.callee === WITH_MEMO) {
     return node.arguments[1].returns as VNodeCall
   } else {
-    return node
+    // #7752
+    return node.type === NodeTypes.JS_CACHE_EXPRESSION
+      ? (node.value as VNodeCall)
+      : (node as VNodeCall)
   }
 }