@vue/language-core 2.2.0 → 2.2.4

package/lib/codegen/{script/styleModulesType.js → style/modules.js}

@@ -1,34 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateStyleModulesType = generateStyleModulesType;
+exports.generateStyleModules = generateStyleModules;
+const codeFeatures_1 = require("../codeFeatures");
 const utils_1 = require("../utils");
-const index_1 = require("./index");
-const template_1 = require("./template");
-function* generateStyleModulesType(options, ctx) {
+const classProperty_1 = require("./classProperty");
+function* generateStyleModules(options) {
     const styles = options.sfc.styles.map((style, i) => [style, i]).filter(([style]) => style.module);
     if (!styles.length && !options.scriptSetupRanges?.useCssModule.length) {
         return;
     }
     yield `type __VLS_StyleModules = {${utils_1.newLine}`;
     for (const [style, i] of styles) {
-        const { name, offset } = style.module;
-        if (offset) {
+        if (style.module === true) {
+            yield `$style`;
+        }
+        else {
+            const { text, offset } = style.module;
             yield [
-                name,
+                text,
                 'main',
-                offset + 1,
-                index_1.codeFeatures.all
+                offset,
+                codeFeatures_1.codeFeatures.withoutHighlight
             ];
         }
-        else {
-            yield name;
-        }
-        yield `: Record<string, string> & ${ctx.localTypes.PrettifyLocal}<{}`;
+        yield `: Record<string, string> & __VLS_PrettifyGlobal<{}`;
         for (const className of style.classNames) {
-            yield* (0, template_1.generateCssClassProperty)(i, className.text, className.offset, 'string', false);
+            yield* (0, classProperty_1.generateClassProperty)(i, className.text, className.offset, 'string');
         }
         yield `>${utils_1.endOfLine}`;
     }
     yield `}${utils_1.endOfLine}`;
 }
-//# sourceMappingURL=styleModulesType.js.map
+//# sourceMappingURL=modules.js.map

package/lib/codegen/style/scopedClasses.d.ts

@@ -0,0 +1,4 @@
+import type { Code } from '../../types';
+import type { ScriptCodegenOptions } from '../script';
+import type { TemplateCodegenContext } from '../template/context';
+export declare function generateStyleScopedClasses(options: ScriptCodegenOptions, ctx: TemplateCodegenContext): Generator<Code>;

package/lib/codegen/style/scopedClasses.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateStyleScopedClasses = generateStyleScopedClasses;
+const utils_1 = require("../utils");
+const classProperty_1 = require("./classProperty");
+function* generateStyleScopedClasses(options, ctx) {
+    const option = options.vueCompilerOptions.experimentalResolveStyleCssClasses;
+    const styles = options.sfc.styles
+        .map((style, i) => [style, i])
+        .filter(([style]) => option === 'always' || (option === 'scoped' && style.scoped));
+    if (!styles.length) {
+        return;
+    }
+    const firstClasses = new Set();
+    yield `type __VLS_StyleScopedClasses = {}`;
+    for (const [style, i] of styles) {
+        for (const className of style.classNames) {
+            if (firstClasses.has(className.text)) {
+                ctx.scopedClasses.push({
+                    source: 'style_' + i,
+                    className: className.text.slice(1),
+                    offset: className.offset + 1
+                });
+                continue;
+            }
+            firstClasses.add(className.text);
+            yield* (0, classProperty_1.generateClassProperty)(i, className.text, className.offset, 'boolean');
+        }
+    }
+    yield utils_1.endOfLine;
+}
+//# sourceMappingURL=scopedClasses.js.map

package/lib/codegen/template/context.d.ts

@@ -3,38 +3,140 @@ import type { Code, VueCodeInformation } from '../../types';
 import { InlayHintInfo } from '../inlayHints';
 import type { TemplateCodegenOptions } from './index';
 export type TemplateCodegenContext = ReturnType<typeof createTemplateCodegenContext>;
+/**
+ * Creates and returns a Context object used for generating type-checkable TS code
+ * from the template section of a .vue file.
+ *
+ * ## Implementation Notes for supporting `@vue-ignore`, `@vue-expect-error`, and `@vue-skip` directives.
+ *
+ * Vue language tooling supports a number of directives for suppressing diagnostics within
+ * Vue templates (https://github.com/vuejs/language-tools/pull/3215)
+ *
+ * Here is an overview for how support for how @vue-expect-error is implemented within this file
+ * (@vue-expect-error is the most complicated directive to support due to its behavior of raising
+ * a diagnostic when it is annotating a piece of code that doesn't actually have any errors/warning/diagnostics).
+ *
+ * Given .vue code:
+ *
+ * ```vue
+ *   <script setup lang="ts">
+ *   defineProps<{
+ *     knownProp1: string;
+ *     knownProp2: string;
+ *     knownProp3: string;
+ *     knownProp4_will_trigger_unused_expect_error: string;
+ *   }>();
+ *   </script>
+ *
+ *   <template>
+ *     {{ knownProp1 }}
+ *     {{ error_unknownProp }} <!-- ERROR: Property 'error_unknownProp' does not exist on type [...] -->
+ *     {{ knownProp2 }}
+ *     <!-- @vue-expect-error This suppresses an Unknown Property Error -->
+ *     {{ suppressed_error_unknownProp }}
+ *     {{ knownProp3 }}
+ *     <!-- @vue-expect-error This will trigger Unused '@ts-expect-error' directive.ts(2578) -->
+ *     {{ knownProp4_will_trigger_unused_expect_error }}
+ *   </template>
+ * ```
+ *
+ * The above code should raise two diagnostics:
+ *
+ * 1. Property 'error_unknownProp' does not exist on type [...]
+ * 2. Unused '@ts-expect-error' directive.ts(2578) -- this is the bottom `@vue-expect-error` directive
+ *    that covers code that doesn't actually raise an error -- note that all `@vue-...` directives
+ *    will ultimately translate into `@ts-...` diagnostics.
+ *
+ * The above code will produce the following type-checkable TS code (note: omitting asterisks
+ * to prevent VSCode syntax double-greying out double-commented code).
+ *
+ * ```ts
+ *   ( __VLS_ctx.knownProp1 );
+ *   ( __VLS_ctx.error_unknownProp ); // ERROR: Property 'error_unknownProp' does not exist on type [...]
+ *   ( __VLS_ctx.knownProp2 );
+ *   // @vue-expect-error start
+ *   ( __VLS_ctx.suppressed_error_unknownProp );
+ *   // @ts-expect-error __VLS_TS_EXPECT_ERROR
+ *   ;
+ *   // @vue-expect-error end of INTERPOLATION
+ *   ( __VLS_ctx.knownProp3 );
+ *   // @vue-expect-error start
+ *   ( __VLS_ctx.knownProp4_will_trigger_unused_expect_error );
+ *   // @ts-expect-error __VLS_TS_EXPECT_ERROR
+ *   ;
+ *   // @vue-expect-error end of INTERPOLATION
+ * ```
+ *
+ * In the generated code, there are actually 3 diagnostic errors that'll be raised in the first
+ * pass on this generated code (but through cleverness described below, not all of them will be
+ * propagated back to the original .vue file):
+ *
+ * 1. Property 'error_unknownProp' does not exist on type [...]
+ * 2. Unused '@ts-expect-error' directive.ts(2578) from the 1st `@ts-expect-error __VLS_TS_EXPECT_ERROR`
+ * 3. Unused '@ts-expect-error' directive.ts(2578) from the 2nd `@ts-expect-error __VLS_TS_EXPECT_ERROR`
+ *
+ * Be sure to pay careful attention to the mixture of `@vue-expect-error` and `@ts-expect-error`;
+ * Within the TS file, the only "real" directives recognized by TS are going to be prefixed with `@ts-`;
+ * any `@vue-` prefixed directives in the comments are only for debugging purposes.
+ *
+ * As mentioned above, there are 3 diagnostics errors that'll be generated for the above code, but
+ * only 2 should be propagated back to the original .vue file.
+ *
+ * (The reason we structure things this way is somewhat complicated, but in short it allows us
+ * to lean on TS as much as possible to generate actual `unused @ts-expect-error directive` errors
+ * while covering a number of edge cases.)
+ *
+ * So, we need a way to dynamically decide whether each of the `@ts-expect-error __VLS_TS_EXPECT_ERROR`
+ * directives should be reported as an unused directive or not.
+ *
+ * To do this, we'll make use of the `shouldReport` callback that'll optionally be provided to the
+ * `verification` property of the `CodeInformation` object attached to the mapping between source .vue
+ * and generated .ts code. The `verification` property determines whether "verification" (which includes
+ * semantic diagnostics) should be performed on the generated .ts code, and `shouldReport`, if provided,
+ * can be used to determine whether a given diagnostic should be reported back "upwards" to the original
+ * .vue file or not.
+ *
+ * See the comments in the code below for how and where we use this hook to keep track of whether
+ * an error/diagnostic was encountered for a region of code covered by a `@vue-expect-error` directive,
+ * and additionally how we use that to determine whether to propagate diagnostics back upward.
+ */
 export declare function createTemplateCodegenContext(options: Pick<TemplateCodegenOptions, 'scriptSetupBindingNames' | 'edited'>): {
-    slots: {
-        name: string;
-        loc?: number;
-        tagRange: [number, number];
-        varName: string;
-        nodeLoc: any;
-    }[];
-    dynamicSlots: {
-        expVar: string;
-        varName: string;
-    }[];
     codeFeatures: {
         all: VueCodeInformation;
+        none: VueCodeInformation;
         verification: VueCodeInformation;
         completion: VueCodeInformation;
         additionalCompletion: VueCodeInformation;
+        withoutCompletion: VueCodeInformation;
         navigation: VueCodeInformation;
         navigationWithoutRename: VueCodeInformation;
         navigationAndCompletion: VueCodeInformation;
         navigationAndAdditionalCompletion: VueCodeInformation;
+        navigationAndVerification: VueCodeInformation;
         withoutNavigation: VueCodeInformation;
         withoutHighlight: VueCodeInformation;
+        withoutHighlightAndNavigation: VueCodeInformation;
         withoutHighlightAndCompletion: VueCodeInformation;
         withoutHighlightAndCompletionAndNavigation: VueCodeInformation;
     };
+    resolveCodeFeatures: (features: VueCodeInformation) => VueCodeInformation;
+    slots: {
+        name: string;
+        offset?: number;
+        tagRange: [number, number];
+        nodeLoc: any;
+        propsVar: string;
+    }[];
+    dynamicSlots: {
+        expVar: string;
+        propsVar: string;
+    }[];
+    dollarVars: Set<string>;
     accessExternalVariables: Map<string, Set<number>>;
     lastGenericComment: {
         content: string;
         offset: number;
     } | undefined;
-    hasSlotElements: Set<CompilerDOM.ElementNode>;
     blockConditions: string[];
     scopedClasses: {
         source: string;
@@ -43,22 +145,25 @@ export declare function createTemplateCodegenContext(options: Pick<TemplateCodeg
     }[];
     emptyClassOffsets: number[];
     inlayHints: InlayHintInfo[];
-    hasSlot: boolean;
     bindingAttrLocs: CompilerDOM.SourceLocation[];
     inheritedAttrVars: Set<string>;
-    templateRefs: Map<string, [varName: string, offset: number]>;
+    templateRefs: Map<string, {
+        typeExp: string;
+        offset: number;
+    }>;
     currentComponent: {
-        node: CompilerDOM.ElementNode;
         ctxVar: string;
         used: boolean;
     } | undefined;
-    singleRootElType: string | undefined;
-    singleRootNode: CompilerDOM.ElementNode | undefined;
+    singleRootElTypes: string[];
+    singleRootNodes: Set<CompilerDOM.ElementNode | null>;
     accessExternalVariable(name: string, offset?: number): void;
     hasLocalVariable: (name: string) => boolean;
     addLocalVariable: (name: string) => void;
     removeLocalVariable: (name: string) => void;
     getInternalVariable: () => string;
+    getHoistVariable: (originalVar: string) => string;
+    generateHoistVariables: () => Generator<string, void, unknown>;
     ignoreError: () => Generator<Code>;
     expectError: (prevNode: CompilerDOM.CommentNode) => Generator<Code>;
     resetDirectiveComments: (endStr: string) => Generator<Code>;

package/lib/codegen/template/context.js

@@ -1,101 +1,145 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTemplateCodegenContext = createTemplateCodegenContext;
+const codeFeatures_1 = require("../codeFeatures");
 const utils_1 = require("../utils");
-const _codeFeatures = {
-    all: {
-        verification: true,
-        completion: true,
-        semantic: true,
-        navigation: true,
-    },
-    verification: {
-        verification: true,
-    },
-    completion: {
-        completion: true,
-    },
-    additionalCompletion: {
-        completion: { isAdditional: true },
-    },
-    navigation: {
-        navigation: true,
-    },
-    navigationWithoutRename: {
-        navigation: {
-            shouldRename() {
-                return false;
-            },
-        },
-    },
-    navigationAndCompletion: {
-        navigation: true,
-        completion: true,
-    },
-    navigationAndAdditionalCompletion: {
-        navigation: true,
-        completion: { isAdditional: true },
-    },
-    withoutNavigation: {
-        verification: true,
-        completion: true,
-        semantic: true,
-    },
-    withoutHighlight: {
-        semantic: { shouldHighlight: () => false },
-        verification: true,
-        navigation: true,
-        completion: true,
-    },
-    withoutHighlightAndCompletion: {
-        semantic: { shouldHighlight: () => false },
-        verification: true,
-        navigation: true,
-    },
-    withoutHighlightAndCompletionAndNavigation: {
-        semantic: { shouldHighlight: () => false },
-        verification: true,
-    },
-};
+/**
+ * Creates and returns a Context object used for generating type-checkable TS code
+ * from the template section of a .vue file.
+ *
+ * ## Implementation Notes for supporting `@vue-ignore`, `@vue-expect-error`, and `@vue-skip` directives.
+ *
+ * Vue language tooling supports a number of directives for suppressing diagnostics within
+ * Vue templates (https://github.com/vuejs/language-tools/pull/3215)
+ *
+ * Here is an overview for how support for how @vue-expect-error is implemented within this file
+ * (@vue-expect-error is the most complicated directive to support due to its behavior of raising
+ * a diagnostic when it is annotating a piece of code that doesn't actually have any errors/warning/diagnostics).
+ *
+ * Given .vue code:
+ *
+ * ```vue
+ *   <script setup lang="ts">
+ *   defineProps<{
+ *     knownProp1: string;
+ *     knownProp2: string;
+ *     knownProp3: string;
+ *     knownProp4_will_trigger_unused_expect_error: string;
+ *   }>();
+ *   </script>
+ *
+ *   <template>
+ *     {{ knownProp1 }}
+ *     {{ error_unknownProp }} <!-- ERROR: Property 'error_unknownProp' does not exist on type [...] -->
+ *     {{ knownProp2 }}
+ *     <!-- @vue-expect-error This suppresses an Unknown Property Error -->
+ *     {{ suppressed_error_unknownProp }}
+ *     {{ knownProp3 }}
+ *     <!-- @vue-expect-error This will trigger Unused '@ts-expect-error' directive.ts(2578) -->
+ *     {{ knownProp4_will_trigger_unused_expect_error }}
+ *   </template>
+ * ```
+ *
+ * The above code should raise two diagnostics:
+ *
+ * 1. Property 'error_unknownProp' does not exist on type [...]
+ * 2. Unused '@ts-expect-error' directive.ts(2578) -- this is the bottom `@vue-expect-error` directive
+ *    that covers code that doesn't actually raise an error -- note that all `@vue-...` directives
+ *    will ultimately translate into `@ts-...` diagnostics.
+ *
+ * The above code will produce the following type-checkable TS code (note: omitting asterisks
+ * to prevent VSCode syntax double-greying out double-commented code).
+ *
+ * ```ts
+ *   ( __VLS_ctx.knownProp1 );
+ *   ( __VLS_ctx.error_unknownProp ); // ERROR: Property 'error_unknownProp' does not exist on type [...]
+ *   ( __VLS_ctx.knownProp2 );
+ *   // @vue-expect-error start
+ *   ( __VLS_ctx.suppressed_error_unknownProp );
+ *   // @ts-expect-error __VLS_TS_EXPECT_ERROR
+ *   ;
+ *   // @vue-expect-error end of INTERPOLATION
+ *   ( __VLS_ctx.knownProp3 );
+ *   // @vue-expect-error start
+ *   ( __VLS_ctx.knownProp4_will_trigger_unused_expect_error );
+ *   // @ts-expect-error __VLS_TS_EXPECT_ERROR
+ *   ;
+ *   // @vue-expect-error end of INTERPOLATION
+ * ```
+ *
+ * In the generated code, there are actually 3 diagnostic errors that'll be raised in the first
+ * pass on this generated code (but through cleverness described below, not all of them will be
+ * propagated back to the original .vue file):
+ *
+ * 1. Property 'error_unknownProp' does not exist on type [...]
+ * 2. Unused '@ts-expect-error' directive.ts(2578) from the 1st `@ts-expect-error __VLS_TS_EXPECT_ERROR`
+ * 3. Unused '@ts-expect-error' directive.ts(2578) from the 2nd `@ts-expect-error __VLS_TS_EXPECT_ERROR`
+ *
+ * Be sure to pay careful attention to the mixture of `@vue-expect-error` and `@ts-expect-error`;
+ * Within the TS file, the only "real" directives recognized by TS are going to be prefixed with `@ts-`;
+ * any `@vue-` prefixed directives in the comments are only for debugging purposes.
+ *
+ * As mentioned above, there are 3 diagnostics errors that'll be generated for the above code, but
+ * only 2 should be propagated back to the original .vue file.
+ *
+ * (The reason we structure things this way is somewhat complicated, but in short it allows us
+ * to lean on TS as much as possible to generate actual `unused @ts-expect-error directive` errors
+ * while covering a number of edge cases.)
+ *
+ * So, we need a way to dynamically decide whether each of the `@ts-expect-error __VLS_TS_EXPECT_ERROR`
+ * directives should be reported as an unused directive or not.
+ *
+ * To do this, we'll make use of the `shouldReport` callback that'll optionally be provided to the
+ * `verification` property of the `CodeInformation` object attached to the mapping between source .vue
+ * and generated .ts code. The `verification` property determines whether "verification" (which includes
+ * semantic diagnostics) should be performed on the generated .ts code, and `shouldReport`, if provided,
+ * can be used to determine whether a given diagnostic should be reported back "upwards" to the original
+ * .vue file or not.
+ *
+ * See the comments in the code below for how and where we use this hook to keep track of whether
+ * an error/diagnostic was encountered for a region of code covered by a `@vue-expect-error` directive,
+ * and additionally how we use that to determine whether to propagate diagnostics back upward.
+ */
 function createTemplateCodegenContext(options) {
     let ignoredError = false;
     let expectErrorToken;
     let lastGenericComment;
     let variableId = 0;
-    const codeFeatures = new Proxy(_codeFeatures, {
-        get(target, key) {
-            const data = target[key];
-            if (data.verification) {
-                if (ignoredError) {
-                    return {
-                        ...data,
-                        verification: false,
-                    };
-                }
-                if (expectErrorToken) {
-                    const token = expectErrorToken;
-                    if (typeof data.verification !== 'object' || !data.verification.shouldReport) {
-                        return {
-                            ...data,
-                            verification: {
-                                shouldReport: () => {
-                                    token.errors++;
-                                    return false;
-                                },
-                            },
-                        };
-                    }
-                }
+    function resolveCodeFeatures(features) {
+        if (features.verification) {
+            if (ignoredError) {
+                // We are currently in a region of code covered by a @vue-ignore directive, so don't
+                // even bother performing any type-checking: set verification to false.
+                return {
+                    ...features,
+                    verification: false,
+                };
             }
-            return data;
-        },
-    });
+            if (expectErrorToken) {
+                // We are currently in a region of code covered by a @vue-expect-error directive. We need to
+                // keep track of the number of errors encountered within this region so that we can know whether
+                // we will need to propagate an "unused ts-expect-error" diagnostic back to the original
+                // .vue file or not.
+                const token = expectErrorToken;
+                return {
+                    ...features,
+                    verification: {
+                        shouldReport: () => {
+                            token.errors++;
+                            return false;
+                        },
+                    },
+                };
+            }
+        }
+        return features;
+    }
+    const hoistVars = new Map();
     const localVars = new Map();
+    const dollarVars = new Set();
     const accessExternalVariables = new Map();
     const slots = [];
     const dynamicSlots = [];
-    const hasSlotElements = new Set();
-    ;
     const blockConditions = [];
     const scopedClasses = [];
     const emptyClassOffsets = [];
@@ -104,23 +148,28 @@ function createTemplateCodegenContext(options) {
     const inheritedAttrVars = new Set();
     const templateRefs = new Map();
     return {
+        codeFeatures: new Proxy(codeFeatures_1.codeFeatures, {
+            get(target, key) {
+                const data = target[key];
+                return resolveCodeFeatures(data);
+            },
+        }),
+        resolveCodeFeatures,
         slots,
         dynamicSlots,
-        codeFeatures,
+        dollarVars,
         accessExternalVariables,
         lastGenericComment,
-        hasSlotElements,
         blockConditions,
         scopedClasses,
         emptyClassOffsets,
         inlayHints,
-        hasSlot: false,
         bindingAttrLocs,
         inheritedAttrVars,
         templateRefs,
         currentComponent: undefined,
-        singleRootElType: undefined,
-        singleRootNode: undefined,
+        singleRootElTypes: [],
+        singleRootNodes: new Set(),
         accessExternalVariable(name, offset) {
             let arr = accessExternalVariables.get(name);
             if (!arr) {
@@ -142,6 +191,24 @@ function createTemplateCodegenContext(options) {
         getInternalVariable: () => {
             return `__VLS_${variableId++}`;
         },
+        getHoistVariable: (originalVar) => {
+            let name = hoistVars.get(originalVar);
+            if (name === undefined) {
+                hoistVars.set(originalVar, name = `__VLS_${variableId++}`);
+            }
+            return name;
+        },
+        generateHoistVariables: function* () {
+            // trick to avoid TS 4081 (#5186)
+            if (hoistVars.size) {
+                yield `// @ts-ignore${utils_1.newLine}`;
+                yield `var `;
+                for (const [originalVar, hoistVar] of hoistVars) {
+                    yield `${hoistVar} = ${originalVar}, `;
+                }
+                yield utils_1.endOfLine;
+            }
+        },
         ignoreError: function* () {
             if (!ignoredError) {
                 ignoredError = true;
@@ -162,6 +229,9 @@ function createTemplateCodegenContext(options) {
                 const token = expectErrorToken;
                 yield* (0, utils_1.wrapWith)(expectErrorToken.node.loc.start.offset, expectErrorToken.node.loc.end.offset, {
                     verification: {
+                        // If no errors/warnings/diagnostics were reported within the region of code covered
+                        // by the @vue-expect-error directive, then we should allow any `unused @ts-expect-error`
+                        // diagnostics to be reported upward.
                         shouldReport: () => token.errors === 0,
                     },
                 }, `// @ts-expect-error __VLS_TS_EXPECT_ERROR`);
@@ -193,8 +263,8 @@ function createTemplateCodegenContext(options) {
                             'template',
                             offset,
                             {
-                                ...codeFeatures.additionalCompletion,
-                                ...codeFeatures.withoutHighlightAndCompletionAndNavigation,
+                                ...codeFeatures_1.codeFeatures.additionalCompletion,
+                                ...codeFeatures_1.codeFeatures.withoutHighlightAndCompletionAndNavigation,
                             },
                         ];
                     }
@@ -203,7 +273,7 @@ function createTemplateCodegenContext(options) {
                             varName,
                             'template',
                             offset,
-                            codeFeatures.additionalCompletion,
+                            codeFeatures_1.codeFeatures.additionalCompletion,
                         ];
                     }
                     yield `,`;

package/lib/codegen/template/element.d.ts

@@ -2,5 +2,5 @@ import * as CompilerDOM from '@vue/compiler-dom';
 import type { Code } from '../../types';
 import type { TemplateCodegenContext } from './context';
 import type { TemplateCodegenOptions } from './index';
-export declare function generateComponent(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode): Generator<Code>;
+export declare function generateComponent(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, isVForChild: boolean): Generator<Code>;
 export declare function generateElement(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, isVForChild: boolean): Generator<Code>;