test: test scopeId support

packages/compiler-core/src/compile.ts

@@ -17,28 +17,33 @@ import { transformOnce } from './transforms/vOnce'
 import { transformModel } from './transforms/vModel'
 import { defaultOnError, createCompilerError, ErrorCodes } from './errors'
 
-// we name it `baseCompile` so that higher order compilers like @vue/compiler-dom
-// can export `compile` while re-exporting everything else.
+// we name it `baseCompile` so that higher order compilers like
+// @vue/compiler-dom can export `compile` while re-exporting everything else.
 export function baseCompile(
   template: string | RootNode,
   options: CompilerOptions = {}
 ): CodegenResult {
+  const onError = options.onError || defaultOnError
+  const isModuleMode = options.mode === 'module'
   /* istanbul ignore if */
   if (__BROWSER__) {
-    const onError = options.onError || defaultOnError
     if (options.prefixIdentifiers === true) {
       onError(createCompilerError(ErrorCodes.X_PREFIX_ID_NOT_SUPPORTED))
-    } else if (options.mode === 'module') {
+    } else if (isModuleMode) {
       onError(createCompilerError(ErrorCodes.X_MODULE_MODE_NOT_SUPPORTED))
     }
   }
 
-  const ast = isString(template) ? parse(template, options) : template
-
   const prefixIdentifiers =
-    !__BROWSER__ &&
-    (options.prefixIdentifiers === true || options.mode === 'module')
+    !__BROWSER__ && (options.prefixIdentifiers === true || isModuleMode)
+  if (!prefixIdentifiers && options.cacheHandlers) {
+    onError(createCompilerError(ErrorCodes.X_CACHE_HANDLER_NOT_SUPPORTED))
+  }
+  if (options.scopeId && !isModuleMode) {
+    onError(createCompilerError(ErrorCodes.X_SCOPE_ID_NOT_SUPPORTED))
+  }
 
+  const ast = isString(template) ? parse(template, options) : template
   transform(ast, {
     ...options,
     prefixIdentifiers,

packages/compiler-core/src/errors.ts

@@ -86,6 +86,8 @@ export const enum ErrorCodes {
   // generic errors
   X_PREFIX_ID_NOT_SUPPORTED,
   X_MODULE_MODE_NOT_SUPPORTED,
+  X_CACHE_HANDLER_NOT_SUPPORTED,
+  X_SCOPE_ID_NOT_SUPPORTED,
 
   // Special value for higher-order compilers to pick up the last code
   // to avoid collision of error codes. This should always be kept as the last
@@ -177,5 +179,7 @@ export const errorMessages: { [code: number]: string } = {
 
   // generic errors
   [ErrorCodes.X_PREFIX_ID_NOT_SUPPORTED]: `"prefixIdentifiers" option is not supported in this build of compiler.`,
-  [ErrorCodes.X_MODULE_MODE_NOT_SUPPORTED]: `ES module mode is not supported in this build of compiler.`
+  [ErrorCodes.X_MODULE_MODE_NOT_SUPPORTED]: `ES module mode is not supported in this build of compiler.`,
+  [ErrorCodes.X_CACHE_HANDLER_NOT_SUPPORTED]: `"cacheHandlers" option is only supported when the "prefixIdentifiers" option is enabled.`,
+  [ErrorCodes.X_SCOPE_ID_NOT_SUPPORTED]: `"scopeId" option is only supported in module mode.`
 }

packages/compiler-core/src/options.ts

@@ -28,17 +28,21 @@ export interface TransformOptions {
   directiveTransforms?: { [name: string]: DirectiveTransform }
   isBuiltInComponent?: (tag: string) => symbol | void
   // Transform expressions like {{ foo }} to `_ctx.foo`.
-  // Default: mode === 'module'
+  // - This is force-enabled in module mode, since modules are by default strict
+  //   and cannot use `with`
+  // - Default: mode === 'module'
   prefixIdentifiers?: boolean
   // Hoist static VNodes and props objects to `_hoisted_x` constants
-  // Default: false
+  // - Default: false
   hoistStatic?: boolean
   // Cache v-on handlers to avoid creating new inline functions on each render,
   // also avoids the need for dynamically patching the handlers by wrapping it.
   // e.g `@click="foo"` by default is compiled to `{ onClick: foo }`. With this
   // option it's compiled to:
   // `{ onClick: _cache[0] || (_cache[0] = e => _ctx.foo(e)) }`
-  // Default: false
+  // - Requires "prefixIdentifiers" to be enabled because it relies on scope
+  //   analysis to determine if a handler is safe to cache.
+  // - Default: false
   cacheHandlers?: boolean
   onError?: (error: CompilerError) => void
 }
@@ -49,18 +53,20 @@ export interface CodegenOptions {
   // - Function mode will generate a single `const { helpers... } = Vue`
   //   statement and return the render function. It is meant to be used with
   //   `new Function(code)()` to generate a render function at runtime.
-  // Default: 'function'
+  // - Default: 'function'
   mode?: 'module' | 'function'
   // Prefix suitable identifiers with _ctx.
   // If this option is false, the generated code will be wrapped in a
   // `with (this) { ... }` block.
-  // Default: false
+  // - This is force-enabled in module mode, since modules are by default strict
+  //   and cannot use `with`
+  // - Default: mode === 'module'
   prefixIdentifiers?: boolean
   // Generate source map?
-  // Default: false
+  // - Default: false
   sourceMap?: boolean
   // Filename for source map generation.
-  // Default: `template.vue.html`
+  // - Default: `template.vue.html`
   filename?: string
   // SFC scoped styles ID
   scopeId?: string | null