From f11ae5714347f35892813b566d1a80cc4e51997b Mon Sep 17 00:00:00 2001
From: zhangyu96 <zhangyu96@MacintoshdeMacBook-Pro.local>
Date: Fri, 13 Aug 2021 18:21:02 +0800
Subject: [PATCH 1/6] feat(compiler-core): enhance the warning for v-once

---
 .../__tests__/transforms/vOnce.spec.ts        | 28 ++++++++++++++++++-
 packages/compiler-core/src/errors.ts          |  2 ++
 .../compiler-core/src/transforms/vOnce.ts     | 14 +++++++++-
 3 files changed, 42 insertions(+), 2 deletions(-)

diff --git a/packages/compiler-core/__tests__/transforms/vOnce.spec.ts b/packages/compiler-core/__tests__/transforms/vOnce.spec.ts
index 553ac1dfac4..ebe85091a79 100644
--- a/packages/compiler-core/__tests__/transforms/vOnce.spec.ts
+++ b/packages/compiler-core/__tests__/transforms/vOnce.spec.ts
@@ -4,7 +4,8 @@ import {
   NodeTypes,
   generate,
   CompilerOptions,
-  getBaseTransformPreset
+  getBaseTransformPreset,
+  ErrorCodes
 } from '../../src'
 import { RENDER_SLOT, SET_BLOCK_TRACKING } from '../../src/runtimeHelpers'
 
@@ -142,4 +143,29 @@ describe('compiler: v-once transform', () => {
       }
     })
   })
+
+  test('inside v-for w/ scope variables', () => {
+    const onError = jest.fn()
+    transformWithOnce(
+      `<div v-for="i in list"><div v-once>{{ i }}</div></div>`,
+      { onError }
+    )
+
+    expect(onError).toHaveBeenCalledTimes(1)
+    expect(onError).toHaveBeenCalledWith(
+      expect.objectContaining({
+        code: ErrorCodes.X_V_ONCE_INSIDE_FOR
+      })
+    )
+  })
+
+  test('inside v-for w/o scope variables', () => {
+    const onError = jest.fn()
+    transformWithOnce(
+      `<div v-for="i in list"><div v-once>{{ k }}</div></div>`,
+      { onError }
+    )
+
+    expect(onError).toHaveBeenCalledTimes(0)
+  })
 })
diff --git a/packages/compiler-core/src/errors.ts b/packages/compiler-core/src/errors.ts
index 09ec7290135..9d0d6f9e1a6 100644
--- a/packages/compiler-core/src/errors.ts
+++ b/packages/compiler-core/src/errors.ts
@@ -76,6 +76,7 @@ export const enum ErrorCodes {
   X_V_FOR_NO_EXPRESSION,
   X_V_FOR_MALFORMED_EXPRESSION,
   X_V_FOR_TEMPLATE_KEY_PLACEMENT,
+  X_V_ONCE_INSIDE_FOR,
   X_V_BIND_NO_EXPRESSION,
   X_V_ON_NO_EXPRESSION,
   X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET,
@@ -148,6 +149,7 @@ export const errorMessages: Record<ErrorCodes, string> = {
   [ErrorCodes.X_V_IF_NO_EXPRESSION]: `v-if/v-else-if is missing expression.`,
   [ErrorCodes.X_V_IF_SAME_KEY]: `v-if/else branches must use unique keys.`,
   [ErrorCodes.X_V_ELSE_NO_ADJACENT_IF]: `v-else/v-else-if has no adjacent v-if.`,
+  [ErrorCodes.X_V_ONCE_INSIDE_FOR]: `v-for scope variables cannot be used inside nested template with v-once.`,
   [ErrorCodes.X_V_FOR_NO_EXPRESSION]: `v-for is missing expression.`,
   [ErrorCodes.X_V_FOR_MALFORMED_EXPRESSION]: `v-for has invalid expression.`,
   [ErrorCodes.X_V_FOR_TEMPLATE_KEY_PLACEMENT]: `<template v-for> key should be placed on the <template> tag.`,
diff --git a/packages/compiler-core/src/transforms/vOnce.ts b/packages/compiler-core/src/transforms/vOnce.ts
index 1b58c6763b6..b0009e70cb4 100644
--- a/packages/compiler-core/src/transforms/vOnce.ts
+++ b/packages/compiler-core/src/transforms/vOnce.ts
@@ -1,7 +1,8 @@
 import { NodeTransform } from '../transform'
-import { findDir } from '../utils'
+import { findDir, hasScopeRef } from '../utils'
 import { ElementNode, ForNode, IfNode, NodeTypes } from '../ast'
 import { SET_BLOCK_TRACKING } from '../runtimeHelpers'
+import { createCompilerError, ErrorCodes } from '@vue/compiler-core'
 
 const seen = new WeakSet()
 
@@ -10,6 +11,17 @@ export const transformOnce: NodeTransform = (node, context) => {
     if (seen.has(node) || context.inVOnce) {
       return
     }
+
+    if (
+      context.scopes.vFor > 0 &&
+      context.parent!.type !== NodeTypes.FOR &&
+      hasScopeRef(node, context.identifiers)
+    ) {
+      context.onError(
+        createCompilerError(ErrorCodes.X_V_ONCE_INSIDE_FOR, node.loc)
+      )
+    }
+
     seen.add(node)
     context.inVOnce = true
     context.helper(SET_BLOCK_TRACKING)

From 0c0ca307e6f78c273ae79d8aa0e532cef8f04baf Mon Sep 17 00:00:00 2001
From: zhangyu96 <zhangyu96@MacintoshdeMacBook-Pro.local>
Date: Fri, 13 Aug 2021 19:16:27 +0800
Subject: [PATCH 2/6] update

---
 packages/compiler-core/__tests__/transforms/vOnce.spec.ts | 4 ++--
 packages/compiler-core/src/transforms/vOnce.ts            | 1 +
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/packages/compiler-core/__tests__/transforms/vOnce.spec.ts b/packages/compiler-core/__tests__/transforms/vOnce.spec.ts
index ebe85091a79..b172037acfe 100644
--- a/packages/compiler-core/__tests__/transforms/vOnce.spec.ts
+++ b/packages/compiler-core/__tests__/transforms/vOnce.spec.ts
@@ -148,7 +148,7 @@ describe('compiler: v-once transform', () => {
     const onError = jest.fn()
     transformWithOnce(
       `<div v-for="i in list"><div v-once>{{ i }}</div></div>`,
-      { onError }
+      { onError, prefixIdentifiers: true }
     )
 
     expect(onError).toHaveBeenCalledTimes(1)
@@ -163,7 +163,7 @@ describe('compiler: v-once transform', () => {
     const onError = jest.fn()
     transformWithOnce(
       `<div v-for="i in list"><div v-once>{{ k }}</div></div>`,
-      { onError }
+      { onError, prefixIdentifiers: true }
     )
 
     expect(onError).toHaveBeenCalledTimes(0)
diff --git a/packages/compiler-core/src/transforms/vOnce.ts b/packages/compiler-core/src/transforms/vOnce.ts
index b0009e70cb4..77d56351cc3 100644
--- a/packages/compiler-core/src/transforms/vOnce.ts
+++ b/packages/compiler-core/src/transforms/vOnce.ts
@@ -13,6 +13,7 @@ export const transformOnce: NodeTransform = (node, context) => {
     }
 
     if (
+      context.prefixIdentifiers &&
       context.scopes.vFor > 0 &&
       context.parent!.type !== NodeTypes.FOR &&
       hasScopeRef(node, context.identifiers)

From e15a0c24d4f1dc11a8f2aefc2b31318a47e48142 Mon Sep 17 00:00:00 2001
From: zhangyu96 <zhangyu96@MacintoshdeMacBook-Pro.local>
Date: Tue, 17 Aug 2021 19:04:04 +0800
Subject: [PATCH 3/6] simplify

---
 .../__tests__/transforms/vOnce.spec.ts           | 16 +++-------------
 packages/compiler-core/src/errors.ts             |  2 +-
 packages/compiler-core/src/transforms/vOnce.ts   |  6 +++---
 3 files changed, 7 insertions(+), 17 deletions(-)

diff --git a/packages/compiler-core/__tests__/transforms/vOnce.spec.ts b/packages/compiler-core/__tests__/transforms/vOnce.spec.ts
index b172037acfe..ae95d8d22a0 100644
--- a/packages/compiler-core/__tests__/transforms/vOnce.spec.ts
+++ b/packages/compiler-core/__tests__/transforms/vOnce.spec.ts
@@ -144,11 +144,11 @@ describe('compiler: v-once transform', () => {
     })
   })
 
-  test('inside v-for w/ scope variables', () => {
+  test('inside v-for is illegal', () => {
     const onError = jest.fn()
     transformWithOnce(
-      `<div v-for="i in list"><div v-once>{{ i }}</div></div>`,
-      { onError, prefixIdentifiers: true }
+      `<div v-for="i in list"><div v-once /></div>`,
+      { onError }
     )
 
     expect(onError).toHaveBeenCalledTimes(1)
@@ -158,14 +158,4 @@ describe('compiler: v-once transform', () => {
       })
     )
   })
-
-  test('inside v-for w/o scope variables', () => {
-    const onError = jest.fn()
-    transformWithOnce(
-      `<div v-for="i in list"><div v-once>{{ k }}</div></div>`,
-      { onError, prefixIdentifiers: true }
-    )
-
-    expect(onError).toHaveBeenCalledTimes(0)
-  })
 })
diff --git a/packages/compiler-core/src/errors.ts b/packages/compiler-core/src/errors.ts
index 9d0d6f9e1a6..712007df9e8 100644
--- a/packages/compiler-core/src/errors.ts
+++ b/packages/compiler-core/src/errors.ts
@@ -149,7 +149,7 @@ export const errorMessages: Record<ErrorCodes, string> = {
   [ErrorCodes.X_V_IF_NO_EXPRESSION]: `v-if/v-else-if is missing expression.`,
   [ErrorCodes.X_V_IF_SAME_KEY]: `v-if/else branches must use unique keys.`,
   [ErrorCodes.X_V_ELSE_NO_ADJACENT_IF]: `v-else/v-else-if has no adjacent v-if.`,
-  [ErrorCodes.X_V_ONCE_INSIDE_FOR]: `v-for scope variables cannot be used inside nested template with v-once.`,
+  [ErrorCodes.X_V_ONCE_INSIDE_FOR]: `Element with v-once cannot be used inside v-for.`,
   [ErrorCodes.X_V_FOR_NO_EXPRESSION]: `v-for is missing expression.`,
   [ErrorCodes.X_V_FOR_MALFORMED_EXPRESSION]: `v-for has invalid expression.`,
   [ErrorCodes.X_V_FOR_TEMPLATE_KEY_PLACEMENT]: `<template v-for> key should be placed on the <template> tag.`,
diff --git a/packages/compiler-core/src/transforms/vOnce.ts b/packages/compiler-core/src/transforms/vOnce.ts
index 77d56351cc3..cb4abe6cd8e 100644
--- a/packages/compiler-core/src/transforms/vOnce.ts
+++ b/packages/compiler-core/src/transforms/vOnce.ts
@@ -1,5 +1,5 @@
 import { NodeTransform } from '../transform'
-import { findDir, hasScopeRef } from '../utils'
+import { findDir } from '../utils'
 import { ElementNode, ForNode, IfNode, NodeTypes } from '../ast'
 import { SET_BLOCK_TRACKING } from '../runtimeHelpers'
 import { createCompilerError, ErrorCodes } from '@vue/compiler-core'
@@ -15,8 +15,8 @@ export const transformOnce: NodeTransform = (node, context) => {
     if (
       context.prefixIdentifiers &&
       context.scopes.vFor > 0 &&
-      context.parent!.type !== NodeTypes.FOR &&
-      hasScopeRef(node, context.identifiers)
+      // element with both v-for and v-once is legal
+      context.parent!.type !== NodeTypes.FOR
     ) {
       context.onError(
         createCompilerError(ErrorCodes.X_V_ONCE_INSIDE_FOR, node.loc)

From dbb82561acf7a1f51e5f8f24ff1d5ef8840849ae Mon Sep 17 00:00:00 2001
From: zhangyu96 <zhangyu96@MacintoshdeMacBook-Pro.local>
Date: Tue, 17 Aug 2021 19:43:25 +0800
Subject: [PATCH 4/6] update

---
 packages/compiler-core/__tests__/transforms/vOnce.spec.ts | 7 +++----
 packages/compiler-core/src/transforms/vOnce.ts            | 7 +------
 2 files changed, 4 insertions(+), 10 deletions(-)

diff --git a/packages/compiler-core/__tests__/transforms/vOnce.spec.ts b/packages/compiler-core/__tests__/transforms/vOnce.spec.ts
index ae95d8d22a0..d6ef84e21a0 100644
--- a/packages/compiler-core/__tests__/transforms/vOnce.spec.ts
+++ b/packages/compiler-core/__tests__/transforms/vOnce.spec.ts
@@ -146,10 +146,9 @@ describe('compiler: v-once transform', () => {
 
   test('inside v-for is illegal', () => {
     const onError = jest.fn()
-    transformWithOnce(
-      `<div v-for="i in list"><div v-once /></div>`,
-      { onError }
-    )
+    transformWithOnce(`<div v-for="i in list"><div v-once /></div>`, {
+      onError
+    })
 
     expect(onError).toHaveBeenCalledTimes(1)
     expect(onError).toHaveBeenCalledWith(
diff --git a/packages/compiler-core/src/transforms/vOnce.ts b/packages/compiler-core/src/transforms/vOnce.ts
index cb4abe6cd8e..c366751e68a 100644
--- a/packages/compiler-core/src/transforms/vOnce.ts
+++ b/packages/compiler-core/src/transforms/vOnce.ts
@@ -12,12 +12,7 @@ export const transformOnce: NodeTransform = (node, context) => {
       return
     }
 
-    if (
-      context.prefixIdentifiers &&
-      context.scopes.vFor > 0 &&
-      // element with both v-for and v-once is legal
-      context.parent!.type !== NodeTypes.FOR
-    ) {
+    if (context.scopes.vFor > 0) {
       context.onError(
         createCompilerError(ErrorCodes.X_V_ONCE_INSIDE_FOR, node.loc)
       )

From 3caae9829845e73f0d4804eaf7d5df3dc765ebc7 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 17 Aug 2021 12:13:54 -0400
Subject: [PATCH 5/6] Update errors.ts

---
 packages/compiler-core/src/errors.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/compiler-core/src/errors.ts b/packages/compiler-core/src/errors.ts
index 712007df9e8..63b0a6e9e49 100644
--- a/packages/compiler-core/src/errors.ts
+++ b/packages/compiler-core/src/errors.ts
@@ -149,7 +149,7 @@ export const errorMessages: Record<ErrorCodes, string> = {
   [ErrorCodes.X_V_IF_NO_EXPRESSION]: `v-if/v-else-if is missing expression.`,
   [ErrorCodes.X_V_IF_SAME_KEY]: `v-if/else branches must use unique keys.`,
   [ErrorCodes.X_V_ELSE_NO_ADJACENT_IF]: `v-else/v-else-if has no adjacent v-if.`,
-  [ErrorCodes.X_V_ONCE_INSIDE_FOR]: `Element with v-once cannot be used inside v-for.`,
+  [ErrorCodes.X_V_ONCE_INSIDE_FOR]: `v-once cannot be used inside v-for.`,
   [ErrorCodes.X_V_FOR_NO_EXPRESSION]: `v-for is missing expression.`,
   [ErrorCodes.X_V_FOR_MALFORMED_EXPRESSION]: `v-for has invalid expression.`,
   [ErrorCodes.X_V_FOR_TEMPLATE_KEY_PLACEMENT]: `<template v-for> key should be placed on the <template> tag.`,

From 0577893fc2459d67fc5f2d16da1758a296be76e1 Mon Sep 17 00:00:00 2001
From: zhangyu96 <zhangyu96@MacintoshdeMacBook-Pro.local>
Date: Wed, 18 Aug 2021 11:31:54 +0800
Subject: [PATCH 6/6] update

---
 .../__tests__/transforms/vMemo.spec.ts        | 113 +++++----
 .../__tests__/transforms/vOnce.spec.ts        | 236 +++++++++---------
 packages/compiler-core/src/errors.ts          |   2 +
 .../compiler-core/src/transforms/vMemo.ts     |   8 +
 .../compiler-core/src/transforms/vOnce.ts     |   2 +-
 5 files changed, 197 insertions(+), 164 deletions(-)

diff --git a/packages/compiler-core/__tests__/transforms/vMemo.spec.ts b/packages/compiler-core/__tests__/transforms/vMemo.spec.ts
index 1b259f7ca68..887d60239dc 100644
--- a/packages/compiler-core/__tests__/transforms/vMemo.spec.ts
+++ b/packages/compiler-core/__tests__/transforms/vMemo.spec.ts
@@ -1,56 +1,75 @@
-import { baseCompile } from '../../src'
-
-describe('compiler: v-memo transform', () => {
-  function compile(content: string) {
-    return baseCompile(`<div>${content}</div>`, {
-      mode: 'module',
-      prefixIdentifiers: true
-    }).code
-  }
-
-  test('on root element', () => {
-    expect(
-      baseCompile(`<div v-memo="[x]"></div>`, {
-        mode: 'module',
-        prefixIdentifiers: true
-      }).code
-    ).toMatchSnapshot()
-  })
+import { baseCompile, CompilerOptions, ErrorCodes } from '../../src'
 
-  test('on normal element', () => {
-    expect(compile(`<div v-memo="[x]"></div>`)).toMatchSnapshot()
-  })
+function compile(content: string, options: CompilerOptions = {}) {
+  return baseCompile(`<div>${content}</div>`, {
+    mode: 'module',
+    prefixIdentifiers: true,
+    ...options
+  }).code
+}
 
-  test('on component', () => {
-    expect(compile(`<Comp v-memo="[x]"></Comp>`)).toMatchSnapshot()
-  })
+describe('compiler: v-memo', () => {
+  describe('transform', () => {
+    test('on root element', () => {
+      expect(
+        baseCompile(`<div v-memo="[x]"></div>`, {
+          mode: 'module',
+          prefixIdentifiers: true
+        }).code
+      ).toMatchSnapshot()
+    })
 
-  test('on v-if', () => {
-    expect(
-      compile(
-        `<div v-if="ok" v-memo="[x]"><span>foo</span>bar</div>
-        <Comp v-else v-memo="[x]"></Comp>`
-      )
-    ).toMatchSnapshot()
-  })
+    test('on normal element', () => {
+      expect(compile(`<div v-memo="[x]"></div>`)).toMatchSnapshot()
+    })
 
-  test('on v-for', () => {
-    expect(
-      compile(
-        `<div v-for="{ x, y } in list" :key="x" v-memo="[x, y === z]">
-          <span>foobar</span>
-        </div>`
-      )
-    ).toMatchSnapshot()
+    test('on component', () => {
+      expect(compile(`<Comp v-memo="[x]"></Comp>`)).toMatchSnapshot()
+    })
+
+    test('on v-if', () => {
+      expect(
+        compile(
+          `<div v-if="ok" v-memo="[x]"><span>foo</span>bar</div>
+          <Comp v-else v-memo="[x]"></Comp>`
+        )
+      ).toMatchSnapshot()
+    })
+
+    test('on v-for', () => {
+      expect(
+        compile(
+          `<div v-for="{ x, y } in list" :key="x" v-memo="[x, y === z]">
+            <span>foobar</span>
+          </div>`
+        )
+      ).toMatchSnapshot()
+    })
+
+    test('on template v-for', () => {
+      expect(
+        compile(
+          `<template v-for="{ x, y } in list" :key="x" v-memo="[x, y === z]">
+            <span>foobar</span>
+          </template>`
+        )
+      ).toMatchSnapshot()
+    })
   })
 
-  test('on template v-for', () => {
-    expect(
-      compile(
-        `<template v-for="{ x, y } in list" :key="x" v-memo="[x, y === z]">
-          <span>foobar</span>
-        </template>`
+  describe('errors', () => {
+    test('inside v-for', () => {
+      const onError = jest.fn()
+      compile(`<div v-for="i in list"><div v-memo="[i]" /></div>`, {
+        onError
+      })
+
+      expect(onError).toHaveBeenCalledTimes(1)
+      expect(onError).toHaveBeenCalledWith(
+        expect.objectContaining({
+          code: ErrorCodes.X_V_MEMO_INSIDE_FOR
+        })
       )
-    ).toMatchSnapshot()
+    })
   })
 })
diff --git a/packages/compiler-core/__tests__/transforms/vOnce.spec.ts b/packages/compiler-core/__tests__/transforms/vOnce.spec.ts
index d6ef84e21a0..3dba263387d 100644
--- a/packages/compiler-core/__tests__/transforms/vOnce.spec.ts
+++ b/packages/compiler-core/__tests__/transforms/vOnce.spec.ts
@@ -20,141 +20,145 @@ function transformWithOnce(template: string, options: CompilerOptions = {}) {
   return ast
 }
 
-describe('compiler: v-once transform', () => {
-  test('as root node', () => {
-    const root = transformWithOnce(`<div :id="foo" v-once />`)
-    expect(root.cached).toBe(1)
-    expect(root.helpers).toContain(SET_BLOCK_TRACKING)
-    expect(root.codegenNode).toMatchObject({
-      type: NodeTypes.JS_CACHE_EXPRESSION,
-      index: 0,
-      value: {
-        type: NodeTypes.VNODE_CALL,
-        tag: `"div"`
-      }
+describe('compiler: v-once', () => {
+  describe('transform', () => {
+    test('as root node', () => {
+      const root = transformWithOnce(`<div :id="foo" v-once />`)
+      expect(root.cached).toBe(1)
+      expect(root.helpers).toContain(SET_BLOCK_TRACKING)
+      expect(root.codegenNode).toMatchObject({
+        type: NodeTypes.JS_CACHE_EXPRESSION,
+        index: 0,
+        value: {
+          type: NodeTypes.VNODE_CALL,
+          tag: `"div"`
+        }
+      })
+      expect(generate(root).code).toMatchSnapshot()
     })
-    expect(generate(root).code).toMatchSnapshot()
-  })
 
-  test('on nested plain element', () => {
-    const root = transformWithOnce(`<div><div :id="foo" v-once /></div>`)
-    expect(root.cached).toBe(1)
-    expect(root.helpers).toContain(SET_BLOCK_TRACKING)
-    expect((root.children[0] as any).children[0].codegenNode).toMatchObject({
-      type: NodeTypes.JS_CACHE_EXPRESSION,
-      index: 0,
-      value: {
-        type: NodeTypes.VNODE_CALL,
-        tag: `"div"`
-      }
+    test('on nested plain element', () => {
+      const root = transformWithOnce(`<div><div :id="foo" v-once /></div>`)
+      expect(root.cached).toBe(1)
+      expect(root.helpers).toContain(SET_BLOCK_TRACKING)
+      expect((root.children[0] as any).children[0].codegenNode).toMatchObject({
+        type: NodeTypes.JS_CACHE_EXPRESSION,
+        index: 0,
+        value: {
+          type: NodeTypes.VNODE_CALL,
+          tag: `"div"`
+        }
+      })
+      expect(generate(root).code).toMatchSnapshot()
     })
-    expect(generate(root).code).toMatchSnapshot()
-  })
 
-  test('on component', () => {
-    const root = transformWithOnce(`<div><Comp :id="foo" v-once /></div>`)
-    expect(root.cached).toBe(1)
-    expect(root.helpers).toContain(SET_BLOCK_TRACKING)
-    expect((root.children[0] as any).children[0].codegenNode).toMatchObject({
-      type: NodeTypes.JS_CACHE_EXPRESSION,
-      index: 0,
-      value: {
-        type: NodeTypes.VNODE_CALL,
-        tag: `_component_Comp`
-      }
+    test('on component', () => {
+      const root = transformWithOnce(`<div><Comp :id="foo" v-once /></div>`)
+      expect(root.cached).toBe(1)
+      expect(root.helpers).toContain(SET_BLOCK_TRACKING)
+      expect((root.children[0] as any).children[0].codegenNode).toMatchObject({
+        type: NodeTypes.JS_CACHE_EXPRESSION,
+        index: 0,
+        value: {
+          type: NodeTypes.VNODE_CALL,
+          tag: `_component_Comp`
+        }
+      })
+      expect(generate(root).code).toMatchSnapshot()
     })
-    expect(generate(root).code).toMatchSnapshot()
-  })
 
-  test('on slot outlet', () => {
-    const root = transformWithOnce(`<div><slot v-once /></div>`)
-    expect(root.cached).toBe(1)
-    expect(root.helpers).toContain(SET_BLOCK_TRACKING)
-    expect((root.children[0] as any).children[0].codegenNode).toMatchObject({
-      type: NodeTypes.JS_CACHE_EXPRESSION,
-      index: 0,
-      value: {
-        type: NodeTypes.JS_CALL_EXPRESSION,
-        callee: RENDER_SLOT
-      }
+    test('on slot outlet', () => {
+      const root = transformWithOnce(`<div><slot v-once /></div>`)
+      expect(root.cached).toBe(1)
+      expect(root.helpers).toContain(SET_BLOCK_TRACKING)
+      expect((root.children[0] as any).children[0].codegenNode).toMatchObject({
+        type: NodeTypes.JS_CACHE_EXPRESSION,
+        index: 0,
+        value: {
+          type: NodeTypes.JS_CALL_EXPRESSION,
+          callee: RENDER_SLOT
+        }
+      })
+      expect(generate(root).code).toMatchSnapshot()
     })
-    expect(generate(root).code).toMatchSnapshot()
-  })
-
-  // v-once inside v-once should not be cached
-  test('inside v-once', () => {
-    const root = transformWithOnce(`<div v-once><div v-once/></div>`)
-    expect(root.cached).not.toBe(2)
-    expect(root.cached).toBe(1)
-  })
 
-  // cached nodes should be ignored by hoistStatic transform
-  test('with hoistStatic: true', () => {
-    const root = transformWithOnce(`<div><div v-once /></div>`, {
-      hoistStatic: true
+    // v-once inside v-once should not be cached
+    test('inside v-once', () => {
+      const root = transformWithOnce(`<div v-once><div v-once/></div>`)
+      expect(root.cached).not.toBe(2)
+      expect(root.cached).toBe(1)
     })
-    expect(root.cached).toBe(1)
-    expect(root.helpers).toContain(SET_BLOCK_TRACKING)
-    expect(root.hoists.length).toBe(0)
-    expect((root.children[0] as any).children[0].codegenNode).toMatchObject({
-      type: NodeTypes.JS_CACHE_EXPRESSION,
-      index: 0,
-      value: {
-        type: NodeTypes.VNODE_CALL,
-        tag: `"div"`
-      }
-    })
-    expect(generate(root).code).toMatchSnapshot()
-  })
 
-  test('with v-if/else', () => {
-    const root = transformWithOnce(`<div v-if="BOOLEAN" v-once /><p v-else/>`)
-    expect(root.cached).toBe(1)
-    expect(root.helpers).toContain(SET_BLOCK_TRACKING)
-    expect(root.children[0]).toMatchObject({
-      type: NodeTypes.IF,
-      // should cache the entire v-if/else-if/else expression, not just a single branch
-      codegenNode: {
+    // cached nodes should be ignored by hoistStatic transform
+    test('with hoistStatic: true', () => {
+      const root = transformWithOnce(`<div><div v-once /></div>`, {
+        hoistStatic: true
+      })
+      expect(root.cached).toBe(1)
+      expect(root.helpers).toContain(SET_BLOCK_TRACKING)
+      expect(root.hoists.length).toBe(0)
+      expect((root.children[0] as any).children[0].codegenNode).toMatchObject({
         type: NodeTypes.JS_CACHE_EXPRESSION,
+        index: 0,
         value: {
-          type: NodeTypes.JS_CONDITIONAL_EXPRESSION,
-          consequent: {
-            type: NodeTypes.VNODE_CALL,
-            tag: `"div"`
-          },
-          alternate: {
-            type: NodeTypes.VNODE_CALL,
-            tag: `"p"`
-          }
+          type: NodeTypes.VNODE_CALL,
+          tag: `"div"`
         }
-      }
+      })
+      expect(generate(root).code).toMatchSnapshot()
     })
-  })
 
-  test('with v-for', () => {
-    const root = transformWithOnce(`<div v-for="i in list" v-once />`)
-    expect(root.cached).toBe(1)
-    expect(root.helpers).toContain(SET_BLOCK_TRACKING)
-    expect(root.children[0]).toMatchObject({
-      type: NodeTypes.FOR,
-      // should cache the entire v-for expression, not just a single branch
-      codegenNode: {
-        type: NodeTypes.JS_CACHE_EXPRESSION
-      }
+    test('with v-if/else', () => {
+      const root = transformWithOnce(`<div v-if="BOOLEAN" v-once /><p v-else/>`)
+      expect(root.cached).toBe(1)
+      expect(root.helpers).toContain(SET_BLOCK_TRACKING)
+      expect(root.children[0]).toMatchObject({
+        type: NodeTypes.IF,
+        // should cache the entire v-if/else-if/else expression, not just a single branch
+        codegenNode: {
+          type: NodeTypes.JS_CACHE_EXPRESSION,
+          value: {
+            type: NodeTypes.JS_CONDITIONAL_EXPRESSION,
+            consequent: {
+              type: NodeTypes.VNODE_CALL,
+              tag: `"div"`
+            },
+            alternate: {
+              type: NodeTypes.VNODE_CALL,
+              tag: `"p"`
+            }
+          }
+        }
+      })
     })
-  })
 
-  test('inside v-for is illegal', () => {
-    const onError = jest.fn()
-    transformWithOnce(`<div v-for="i in list"><div v-once /></div>`, {
-      onError
+    test('with v-for', () => {
+      const root = transformWithOnce(`<div v-for="i in list" v-once />`)
+      expect(root.cached).toBe(1)
+      expect(root.helpers).toContain(SET_BLOCK_TRACKING)
+      expect(root.children[0]).toMatchObject({
+        type: NodeTypes.FOR,
+        // should cache the entire v-for expression, not just a single branch
+        codegenNode: {
+          type: NodeTypes.JS_CACHE_EXPRESSION
+        }
+      })
     })
+  })
 
-    expect(onError).toHaveBeenCalledTimes(1)
-    expect(onError).toHaveBeenCalledWith(
-      expect.objectContaining({
-        code: ErrorCodes.X_V_ONCE_INSIDE_FOR
+  describe('errors', () => {
+    test('inside v-for', () => {
+      const onError = jest.fn()
+      transformWithOnce(`<div v-for="i in list"><div v-once /></div>`, {
+        onError
       })
-    )
+
+      expect(onError).toHaveBeenCalledTimes(1)
+      expect(onError).toHaveBeenCalledWith(
+        expect.objectContaining({
+          code: ErrorCodes.X_V_ONCE_INSIDE_FOR
+        })
+      )
+    })
   })
 })
diff --git a/packages/compiler-core/src/errors.ts b/packages/compiler-core/src/errors.ts
index 712007df9e8..5fccc357148 100644
--- a/packages/compiler-core/src/errors.ts
+++ b/packages/compiler-core/src/errors.ts
@@ -77,6 +77,7 @@ export const enum ErrorCodes {
   X_V_FOR_MALFORMED_EXPRESSION,
   X_V_FOR_TEMPLATE_KEY_PLACEMENT,
   X_V_ONCE_INSIDE_FOR,
+  X_V_MEMO_INSIDE_FOR,
   X_V_BIND_NO_EXPRESSION,
   X_V_ON_NO_EXPRESSION,
   X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET,
@@ -150,6 +151,7 @@ export const errorMessages: Record<ErrorCodes, string> = {
   [ErrorCodes.X_V_IF_SAME_KEY]: `v-if/else branches must use unique keys.`,
   [ErrorCodes.X_V_ELSE_NO_ADJACENT_IF]: `v-else/v-else-if has no adjacent v-if.`,
   [ErrorCodes.X_V_ONCE_INSIDE_FOR]: `Element with v-once cannot be used inside v-for.`,
+  [ErrorCodes.X_V_MEMO_INSIDE_FOR]: `v-memo cannot be used inside v-for.`,
   [ErrorCodes.X_V_FOR_NO_EXPRESSION]: `v-for is missing expression.`,
   [ErrorCodes.X_V_FOR_MALFORMED_EXPRESSION]: `v-for has invalid expression.`,
   [ErrorCodes.X_V_FOR_TEMPLATE_KEY_PLACEMENT]: `<template v-for> key should be placed on the <template> tag.`,
diff --git a/packages/compiler-core/src/transforms/vMemo.ts b/packages/compiler-core/src/transforms/vMemo.ts
index 4e150875d98..1ac38d0c1b9 100644
--- a/packages/compiler-core/src/transforms/vMemo.ts
+++ b/packages/compiler-core/src/transforms/vMemo.ts
@@ -9,6 +9,7 @@ import {
   PlainElementNode
 } from '../ast'
 import { WITH_MEMO } from '../runtimeHelpers'
+import { createCompilerError, ErrorCodes } from '../errors'
 
 const seen = new WeakSet()
 
@@ -18,6 +19,13 @@ export const transformMemo: NodeTransform = (node, context) => {
     if (!dir || seen.has(node)) {
       return
     }
+
+    if (context.scopes.vFor > 0) {
+      context.onError(
+        createCompilerError(ErrorCodes.X_V_MEMO_INSIDE_FOR, node.loc)
+      )
+    }
+
     seen.add(node)
     return () => {
       const codegenNode =
diff --git a/packages/compiler-core/src/transforms/vOnce.ts b/packages/compiler-core/src/transforms/vOnce.ts
index c366751e68a..01dda349b2a 100644
--- a/packages/compiler-core/src/transforms/vOnce.ts
+++ b/packages/compiler-core/src/transforms/vOnce.ts
@@ -2,7 +2,7 @@ import { NodeTransform } from '../transform'
 import { findDir } from '../utils'
 import { ElementNode, ForNode, IfNode, NodeTypes } from '../ast'
 import { SET_BLOCK_TRACKING } from '../runtimeHelpers'
-import { createCompilerError, ErrorCodes } from '@vue/compiler-core'
+import { createCompilerError, ErrorCodes } from '../errors'
 
 const seen = new WeakSet()