rooklang 0.0.0-stage → 0.3.0

package/dist/goroutines.js

@@ -0,0 +1,253 @@
+import { arrayName, isGoFor, loopParams, partFunction } from "./go-for.js";
+import { declaredNames, freeNames } from "./names.js";
+import { forEachChild } from "./walk.js";
+/** Every `go` expression and `go for` loop of the program, nested ones too. */
+export function goroutines(program) {
+    const found = [];
+    const visit = (node) => {
+        if (node.kind === 'GoExpression' || isGoFor(node))
+            found.push(node);
+        forEachChild(node, visit);
+    };
+    visit(program);
+    return found;
+}
+/**
+ * The names of the functions of the literals of `go` and of the `go for` loops in the worker
+ * module, numbered in the module as written. The worker module has the same nodes, and keeps them.
+ */
+const literalNames = new WeakMap();
+/** The programs whose literals have names. */
+const named = new WeakSet();
+/** The local names that a literal of `go` or a `go for` uses, as the checker finds them. */
+const captures = new WeakMap();
+/** A function literal of `go`, or a `go for`: code that becomes a function of the worker module. */
+function isLiteral(node) {
+    return node.kind === 'ForInStatement' || node.call.callee.kind === 'FuncExpression';
+}
+/**
+ * The function that a goroutine calls in the worker module: a name, or the name given to a
+ * function literal or a `go for`; anything else is reported by the checker.
+ */
+export function goTarget(program, node) {
+    if (node.kind === 'GoExpression' && node.call.callee.kind === 'Identifier') {
+        return node.call.callee.name;
+    }
+    if (!isLiteral(node))
+        return null;
+    if (!named.has(program) && !literalNames.has(node)) {
+        named.add(program);
+        goroutines(program)
+            .filter(isLiteral)
+            .forEach((each, i) => literalNames.set(each, `$$goroutine${i}`));
+    }
+    return literalNames.get(node) ?? null;
+}
+export function recordCaptures(node, names) {
+    captures.set(node, names);
+}
+/**
+ * The local names that the literal of a `go` or a `go for` gets first: those the checker found.
+ * Code that was not checked passes the names that the code uses and the declaration around it
+ * declares, but not the array of `go for`, which goes in parts.
+ */
+export function goCaptures(program, node) {
+    const recorded = captures.get(node);
+    if (recorded)
+        return recorded;
+    const literal = node.kind === 'ForInStatement'
+        ? { params: loopParams(node), body: node.body }
+        : node.call.callee;
+    const array = node.kind === 'ForInStatement' ? arrayName(node) : null;
+    const outer = program.body.find((each) => each.start <= node.start && node.end <= each.end);
+    const module = new Set(program.body.flatMap(declaredBy));
+    const local = outer
+        ? declaredNames({ kind: 'BlockStatement', body: [outer], start: outer.start, end: outer.end })
+        : new Set();
+    return [...freeNames(literal)].filter((name) => local.has(name) && !module.has(name) && name !== array);
+}
+/** Parameters for the local names that a literal of `go` gets first. */
+export function goParams(literal, names) {
+    const at = { start: literal.start, end: literal.start };
+    return names.map((name) => ({
+        kind: 'Parameter',
+        name: { kind: 'Identifier', name, ...at },
+        type: null,
+        defaultValue: null,
+        ...at,
+    }));
+}
+/**
+ * The functions of the literals of `go`, with the local names they use as their first parameters,
+ * and of the `go for` loops.
+ */
+function literalFunctions(program) {
+    return goroutines(program).flatMap((node) => {
+        if (node.kind === 'ForInStatement') {
+            return [partFunction(node, goTarget(program, node), goCaptures(program, node))];
+        }
+        const literal = node.call.callee;
+        if (literal.kind !== 'FuncExpression')
+            return [];
+        const at = { start: literal.start, end: literal.start };
+        const params = goParams(literal, goCaptures(program, node));
+        return [
+            {
+                kind: 'FuncDeclaration',
+                exported: false,
+                isPublic: false,
+                ...(literal.async ? { async: true } : {}),
+                name: { kind: 'Identifier', name: goTarget(program, node), ...at },
+                typeParams: [],
+                params: [...params, ...literal.params],
+                results: literal.results,
+                body: literal.body,
+                start: literal.start,
+                end: literal.end,
+            },
+        ];
+    });
+}
+/** What the code of the functions `names` reaches in the module, through the names it uses. */
+export function reach(program, names) {
+    const declarations = new Map();
+    const importsByName = new Map();
+    for (const statement of program.body) {
+        for (const name of declaredBy(statement))
+            declarations.set(name, statement);
+    }
+    const result = { statements: [], imports: new Map(), lets: [], markup: null };
+    const reached = new Set();
+    const queue = [...names];
+    const seen = new Set(queue);
+    for (const statement of program.body) {
+        if (statement.kind !== 'ImportDeclaration')
+            continue;
+        for (const name of importedNames(statement))
+            importsByName.set(name, statement);
+    }
+    for (let i = 0; i < queue.length; i++) {
+        const name = queue[i];
+        const imported = importsByName.get(name);
+        if (imported) {
+            const used = result.imports.get(imported) ?? new Set();
+            used.add(name);
+            result.imports.set(imported, used);
+            continue;
+        }
+        const statement = declarations.get(name);
+        if (!statement)
+            continue;
+        if (statement.kind === 'VariableDeclaration' && statement.keyword !== 'const') {
+            result.lets.push(name);
+            continue;
+        }
+        if (statement.kind === 'ComponentDeclaration' || statement.kind === 'DecoratorDeclaration') {
+            result.markup ??= `the ${statement.kind === 'ComponentDeclaration' ? 'component' : 'decorator'} "${name}"`;
+            continue;
+        }
+        if (reached.has(statement))
+            continue;
+        reached.add(statement);
+        if (hasMarkup(statement))
+            result.markup ??= `the markup in "${name}"`;
+        for (const used of usedNames(statement)) {
+            if (!seen.has(used)) {
+                seen.add(used);
+                queue.push(used);
+            }
+        }
+    }
+    result.statements = program.body.filter((statement) => reached.has(statement));
+    return result;
+}
+/**
+ * The program of the worker module: the imports and the declarations that the functions `targets`
+ * reach, unexported, since the worker module is only loaded by the worker.
+ */
+export function workerProgram(program, targets) {
+    const lifted = { ...program, body: [...program.body, ...literalFunctions(program)] };
+    const { statements, imports } = reach(lifted, targets);
+    const body = [];
+    for (const [statement, names] of imports) {
+        body.push({
+            ...statement,
+            defaultImport: statement.defaultImport && keep(statement.defaultImport, names),
+            namespaceImport: statement.namespaceImport && keep(statement.namespaceImport, names),
+            namedImports: statement.namedImports.filter((specifier) => names.has(specifier.local.name)),
+        });
+    }
+    for (const statement of statements) {
+        body.push('exported' in statement ? { ...statement, exported: false } : statement);
+    }
+    return { ...program, body };
+}
+function keep(name, names) {
+    return names.has(name.name) ? name : null;
+}
+function declaredBy(statement) {
+    switch (statement.kind) {
+        case 'VariableDeclaration':
+            return statement.names.map((name) => name.name);
+        case 'FuncDeclaration':
+        case 'ClassDeclaration':
+        case 'ComponentDeclaration':
+        case 'DecoratorDeclaration':
+            return [statement.name.name];
+        default:
+            return [];
+    }
+}
+function importedNames(statement) {
+    return [
+        ...(statement.defaultImport ? [statement.defaultImport.name] : []),
+        ...(statement.namespaceImport ? [statement.namespaceImport.name] : []),
+        ...statement.namedImports.map((specifier) => specifier.local.name),
+    ];
+}
+/** The names that the code of a top-level declaration uses; not those of members or keys. */
+function usedNames(statement) {
+    const block = (body) => ({
+        kind: 'BlockStatement',
+        body,
+        start: statement.start,
+        end: statement.end,
+    });
+    switch (statement.kind) {
+        case 'FuncDeclaration':
+            return freeNames(statement);
+        case 'VariableDeclaration':
+            return freeNames({ params: [], body: block([statement]) });
+        case 'ClassDeclaration': {
+            const names = new Set();
+            const add = (found) => found.forEach((name) => names.add(name));
+            if (statement.superClass) {
+                add(freeNames({ params: [], body: block([expression(statement.superClass)]) }));
+            }
+            for (const member of statement.members) {
+                if (member.kind === 'FieldDeclaration') {
+                    if (member.value)
+                        add(freeNames({ params: [], body: block([expression(member.value)]) }));
+                }
+                else {
+                    add(freeNames(member));
+                }
+            }
+            return names;
+        }
+        default:
+            return new Set();
+    }
+}
+function expression(node) {
+    return { kind: 'ExpressionStatement', expression: node, start: node.start, end: node.end };
+}
+function hasMarkup(node) {
+    if (node.kind === 'ElementExpression')
+        return true;
+    let found = false;
+    forEachChild(node, (child) => {
+        found ||= hasMarkup(child);
+    });
+    return found;
+}

package/dist/html-tag.d.ts

@@ -0,0 +1,21 @@
+import type * as ast from './ast.ts';
+/** `mainPage` and `MainPage` → `main-page`, `HTMLView` → `html-view`. */
+export declare function kebabCase(name: string): string;
+/** The tag of a web component: given by `@html-tag("app-page")`, or its name in kebab case. */
+export declare function htmlTagName(component: ast.ComponentDeclaration): string;
+/** The attribute of a property: `itemCount` → `item-count` (attributes do not keep case). */
+export declare function attributeName(property: string): string;
+/** Why HTML does not accept a name of a custom element, or `null` if it does. */
+export declare function tagNameProblem(tag: string): string | null;
+/**
+ * Properties of HTMLElement that a web component's properties would replace, breaking the
+ * element: `id`, `style`, `hidden`...
+ */
+export declare const RESERVED_PROPERTIES: ReadonlySet<string>;
+/** How an attribute sets a property: as text, as a number, or by its presence. */
+export type AttributeKind = 'string' | 'number' | 'bool';
+/**
+ * The attribute kind of a property by its type: `string`, `?number`, `"s" | "m"` have attributes;
+ * arrays, objects and functions are set only as JS properties (`null`).
+ */
+export declare function attributeKind(type: ast.TypeNode | null, aliases: ReadonlyMap<string, ast.TypeNode>, seen?: Set<string>): AttributeKind | null;

package/dist/html-tag.js

@@ -0,0 +1,103 @@
+// Web components from `@html-tag` components: their tags, attributes and the names they cannot use.
+/** `mainPage` and `MainPage` → `main-page`, `HTMLView` → `html-view`. */
+export function kebabCase(name) {
+    return name
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')
+        .toLowerCase();
+}
+/** The tag of a web component: given by `@html-tag("app-page")`, or its name in kebab case. */
+export function htmlTagName(component) {
+    return component.htmlTag?.name?.value ?? kebabCase(component.name.name);
+}
+/** The attribute of a property: `itemCount` → `item-count` (attributes do not keep case). */
+export function attributeName(property) {
+    return kebabCase(property);
+}
+const RESERVED_TAGS = new Set([
+    'annotation-xml',
+    'color-profile',
+    'font-face',
+    'font-face-src',
+    'font-face-uri',
+    'font-face-format',
+    'font-face-name',
+    'missing-glyph',
+]);
+/** Why HTML does not accept a name of a custom element, or `null` if it does. */
+export function tagNameProblem(tag) {
+    if (!/^[a-z][a-z0-9._-]*$/.test(tag)) {
+        return 'it must start with a lowercase letter and have only lowercase letters, digits, "-", "." and "_"';
+    }
+    if (!tag.includes('-'))
+        return 'it must have a hyphen';
+    if (RESERVED_TAGS.has(tag))
+        return 'HTML reserves this name';
+    return null;
+}
+/**
+ * Properties of HTMLElement that a web component's properties would replace, breaking the
+ * element: `id`, `style`, `hidden`...
+ */
+export const RESERVED_PROPERTIES = new Set([
+    'id',
+    'className',
+    'classList',
+    'style',
+    'slot',
+    'hidden',
+    'dir',
+    'lang',
+    'tabIndex',
+    'part',
+    'dataset',
+    'attributes',
+    'shadowRoot',
+    'innerHTML',
+    'outerHTML',
+    'innerText',
+    'textContent',
+    'tagName',
+    'localName',
+    'nodeName',
+    'nodeType',
+    'isConnected',
+    'ownerDocument',
+    'parentNode',
+    'parentElement',
+    'childNodes',
+    'firstChild',
+    'lastChild',
+]);
+/**
+ * The attribute kind of a property by its type: `string`, `?number`, `"s" | "m"` have attributes;
+ * arrays, objects and functions are set only as JS properties (`null`).
+ */
+export function attributeKind(type, aliases, seen = new Set()) {
+    if (type === null)
+        return null;
+    switch (type.kind) {
+        case 'NullableType':
+            return attributeKind(type.type, aliases, seen);
+        case 'LiteralType':
+            return type.value.kind === 'StringLiteral'
+                ? 'string'
+                : type.value.kind === 'NumberLiteral'
+                    ? 'number'
+                    : 'bool';
+        case 'UnionType': {
+            const kinds = new Set(type.types.map((member) => attributeKind(member, aliases, seen)));
+            const [kind] = kinds;
+            return kinds.size === 1 && kind !== undefined ? kind : null;
+        }
+        case 'TypeReference': {
+            const name = type.name.name;
+            const alias = aliases.get(name);
+            if (alias && !seen.has(name))
+                return attributeKind(alias, aliases, seen.add(name));
+            return name === 'string' || name === 'number' || name === 'bool' ? name : null;
+        }
+        default:
+            return null;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+import { type CompileResult } from './compile.ts';
+import { type CompletionList } from './completion.ts';
+export type { CompileResult } from './compile.ts';
+export type { Completion, CompletionList } from './completion.ts';
+export type { Diagnostic } from './diagnostics.ts';
+export { formatDiagnostic } from './diagnostics.ts';
+export { SourceFile } from './source.ts';
+export interface CompileOptions {
+    /** Path of the source file; needed to check the types of imports. */
+    filename?: string;
+    /**
+     * Replace `.rk` with `.js` in relative import paths, for output written next to the sources.
+     * Defaults to `true`.
+     */
+    rewriteImports?: boolean;
+    /** Check types before generating code. Defaults to `true`. */
+    typeCheck?: boolean;
+    /** Also print a TypeScript declaration file (`.d.ts`); needs type checking. */
+    declarations?: boolean;
+    /** Where the worker module of `go` is, relative to the module; see workerUrl() in compile.ts. */
+    workerUrl?: string;
+    /** Markup and components; by default as the package.json of the file says (src/config.ts). */
+    markup?: boolean;
+}
+export declare function compile(source: string, options?: CompileOptions): CompileResult;
+/**
+ * What can be written at `offset` in a module, for editors: names, members, types, tags and
+ * attributes. The imports are read from disk, like those of `compile`.
+ */
+export declare function complete(source: string, offset: number, options?: {
+    filename?: string;
+    markup?: boolean;
+}): CompletionList;

package/dist/index.js

@@ -0,0 +1,55 @@
+import { compileModule, workerUrl, } from "./compile.js";
+import { completeModule } from "./completion.js";
+import { markupFor } from "./config.js";
+import { loadModuleExports } from "./modules.js";
+import { readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { importDeclarations, libraryFor } from "./typescript/importer.js";
+export { formatDiagnostic } from "./diagnostics.js";
+export { SourceFile } from "./source.js";
+export function compile(source, options = {}) {
+    const { filename } = options;
+    const rewriteImports = options.rewriteImports ?? true;
+    const markup = options.markup ?? markupFor(filename);
+    return compileModule(source, {
+        ...filesOf(filename, options.typeCheck ?? true, options.markup),
+        markup,
+        rewriteImports,
+        workerUrl: options.workerUrl ?? workerUrl(filename ?? 'main.rk', rewriteImports),
+        typeCheck: options.typeCheck ?? true,
+        declarations: options.declarations ?? false,
+    });
+}
+/**
+ * What can be written at `offset` in a module, for editors: names, members, types, tags and
+ * attributes. The imports are read from disk, like those of `compile`.
+ */
+export function complete(source, offset, options = {}) {
+    return completeModule(source, offset, {
+        ...filesOf(options.filename, true, options.markup),
+        markup: options.markup ?? markupFor(options.filename),
+    });
+}
+/** Reading what a module imports: other modules, declarations, CSS modules and the library. */
+function filesOf(filename, typeCheck, markup) {
+    return {
+        importModule: filename
+            ? (specifier) => loadModuleExports(filename, specifier, markup)
+            : undefined,
+        importDeclarations: filename
+            ? (specifier) => importDeclarations(filename, specifier)
+            : undefined,
+        readStyleModule: filename ? (specifier) => readNear(filename, specifier) : undefined,
+        // Without a file name, `@types` packages are looked up from the current directory.
+        library: typeCheck ? libraryFor(filename ?? join(process.cwd(), 'main.rk')) : undefined,
+    };
+}
+/** A file next to `filename`, or null if it cannot be read. */
+function readNear(filename, specifier) {
+    try {
+        return readFileSync(resolve(dirname(filename), specifier), 'utf8');
+    }
+    catch {
+        return null;
+    }
+}

package/dist/inline-packages.d.ts

@@ -0,0 +1,32 @@
+import type * as ast from './ast.ts';
+import { type DecoratorSource } from './decorators.ts';
+export interface InlinePackage {
+    /** The exported component first, then the components of its module it reaches: inlined too. */
+    components: Map<string, ast.ComponentDeclaration>;
+    /** Reached components that are functions in their module (recursive, web or exported): called. */
+    functions: Map<string, ast.ComponentDeclaration>;
+    /** The decorators of the module applied to them, with the names of the module their code uses. */
+    decorators: Map<string, DecoratorSource>;
+    /** The names of the module that the components' own code uses. */
+    moduleNames: string[];
+    /** Names the code uses that the module does not declare: they must mean the same elsewhere. */
+    globals: string[];
+}
+/** The packages that a module exports for others. */
+export interface ModulePackages {
+    /** By exported component; a component that cannot be inlined has none. */
+    components: Map<string, InlinePackage>;
+    /**
+     * By exported decorator: the components its code uses, which go with it into the components it
+     * is applied to. Null when they cannot go elsewhere.
+     */
+    decorators: Map<string, InlinePackage | null>;
+}
+/**
+ * The packages of the exported components and decorators of a module. A component that is
+ * recursive or a web component cannot be inlined, and neither can one that reaches components or
+ * decorators the module imports: those would bring the names of a third module. Nor can code that
+ * uses a component of the module as a value, which is the function in the module, or that assigns
+ * a variable of the module: another module could only read it.
+ */
+export declare function inlinePackages(program: ast.Program): ModulePackages;

package/dist/inline-packages.js

@@ -0,0 +1,129 @@
+import { decorate, moduleNamesOf } from "./decorators.js";
+import { assignedNames, componentValues, freeNames, topLevelNames } from "./names.js";
+import { recursiveComponents } from "./recursion.js";
+import { forEachChild } from "./walk.js";
+/**
+ * The packages of the exported components and decorators of a module. A component that is
+ * recursive or a web component cannot be inlined, and neither can one that reaches components or
+ * decorators the module imports: those would bring the names of a third module. Nor can code that
+ * uses a component of the module as a value, which is the function in the module, or that assigns
+ * a variable of the module: another module could only read it.
+ */
+export function inlinePackages(program) {
+    const components = new Map();
+    const decorators = new Map();
+    for (const statement of program.body) {
+        if (statement.kind === 'ComponentDeclaration')
+            components.set(statement.name.name, statement);
+        if (statement.kind === 'DecoratorDeclaration')
+            decorators.set(statement.name.name, statement);
+    }
+    const sources = new Map([...decorators].map(([name, node]) => [
+        name,
+        { node, moduleNames: moduleNamesOf(node, program) },
+    ]));
+    const expanded = new Map([...components].map(([name, node]) => [name, decorate(node, sources)]));
+    const recursive = recursiveComponents(expanded);
+    const isFunction = (name) => {
+        const node = components.get(name);
+        return node.htmlTag !== null || node.exported || recursive.has(expanded.get(name));
+    };
+    const topLevel = topLevelNames(program);
+    const usesComponentValues = (node) => componentValues(node, (name) => components.has(name)).length > 0;
+    const assignsModuleNames = (node) => {
+        const assigned = assignedNames(node);
+        return [...freeNames(node)].some((name) => topLevel.has(name) && assigned.has(name));
+    };
+    /** The package of a component, or of the tags in the code of a decorator. */
+    const build = (root, tags) => {
+        const found = {
+            components: new Map(),
+            functions: new Map(),
+            decorators: new Map(),
+            moduleNames: [],
+            globals: [],
+        };
+        const own = new Set();
+        const globals = new Set();
+        const sort = (names, mine) => {
+            for (const used of names) {
+                if (!topLevel.has(used))
+                    globals.add(used);
+                else if (mine)
+                    own.add(used);
+            }
+        };
+        // A component of the module is called or inlined; one the module imports cannot go anywhere.
+        const take = (tag) => {
+            if (!components.has(tag))
+                return !topLevel.has(tag);
+            if (!isFunction(tag))
+                return visit(tag);
+            found.functions.set(tag, components.get(tag));
+            return true;
+        };
+        const visit = (current) => {
+            if (found.components.has(current))
+                return true;
+            const component = components.get(current);
+            found.components.set(current, component);
+            if (usesComponentValues(expanded.get(current)))
+                return false;
+            if (assignsModuleNames(expanded.get(current)))
+                return false;
+            for (const use of component.decorators) {
+                const source = sources.get(use.name.name);
+                if (!source)
+                    return false;
+                found.decorators.set(use.name.name, source);
+                sort(freeNames(source.node), false);
+            }
+            sort(freeNames(withArguments(component)), true);
+            return [...tagsIn(expanded.get(current))].every(take);
+        };
+        if (!(root === null ? [...tags].every(take) : visit(root)))
+            return null;
+        found.moduleNames = [...own].sort();
+        found.globals = [...globals].sort();
+        return found;
+    };
+    const packages = { components: new Map(), decorators: new Map() };
+    for (const [name, node] of components) {
+        if (!node.exported || node.htmlTag || recursive.has(expanded.get(name)))
+            continue;
+        const found = build(name, []);
+        if (found)
+            packages.components.set(name, found);
+    }
+    for (const [name, node] of decorators) {
+        if (!node.exported)
+            continue;
+        packages.decorators.set(name, usesComponentValues(node) ? null : build(null, tagsIn(node.body)));
+    }
+    return packages;
+}
+/** The component's own code with the arguments of its decorators, which are its code too. */
+function withArguments(component) {
+    const statements = component.decorators.flatMap((use) => use.arguments.map((expression) => ({
+        kind: 'ExpressionStatement',
+        expression,
+        start: use.start,
+        end: use.end,
+    })));
+    return {
+        params: component.params,
+        body: { ...component.body, body: [...statements, ...component.body.body] },
+    };
+}
+/** The names of components in the markup: tags with a capital letter. */
+function tagsIn(node) {
+    const tags = new Set();
+    const visit = (child) => {
+        if (child.kind === 'ElementExpression' && child.tag && /^[A-Z]/.test(child.tag.name)) {
+            tags.add(child.tag.name);
+        }
+        forEachChild(child, visit);
+    };
+    visit(node);
+    return tags;
+}

package/dist/iterators.d.ts

@@ -0,0 +1,10 @@
+import type * as ast from './ast.ts';
+/** Whether a function with these parameters is an iterator. */
+export declare function isIterator(params: readonly ast.Parameter[]): boolean;
+/** `yield(v)` or `yield(k, v)`: a call of the parameter of an iterator. */
+export declare function isYieldCall(node: ast.Node): node is ast.CallExpression;
+/**
+ * Whether a body uses `this` of the code around it. A func literal is an arrow function, which
+ * has it; an iterator literal becomes a generator function, which needs it bound.
+ */
+export declare function usesThis(node: ast.Node): boolean;

package/dist/iterators.js

@@ -0,0 +1,33 @@
+import { forEachChild } from "./walk.js";
+// Iterators, as in Go 1.23: a function whose one parameter is `yield`, `func(yield func(T) bool)`.
+// It compiles to a JS generator: `yield(v)` yields `v`, and when the loop that goes over it stops,
+// the generator is closed, so the iterator returns there, with its `defer`s run. The checker
+// (src/checker/iterators.ts) and the code generator both tell iterators by this parameter.
+/** Whether a function with these parameters is an iterator. */
+export function isIterator(params) {
+    return params.length === 1 && params[0].name.name === 'yield';
+}
+/** `yield(v)` or `yield(k, v)`: a call of the parameter of an iterator. */
+export function isYieldCall(node) {
+    return (node.kind === 'CallExpression' &&
+        node.callee.kind === 'Identifier' &&
+        node.callee.name === 'yield');
+}
+/**
+ * Whether a body uses `this` of the code around it. A func literal is an arrow function, which
+ * has it; an iterator literal becomes a generator function, which needs it bound.
+ */
+export function usesThis(node) {
+    if (node.kind === 'ThisExpression')
+        return true;
+    if (node.kind === 'FuncDeclaration' ||
+        node.kind === 'ClassDeclaration' ||
+        (node.kind === 'FuncExpression' && isIterator(node.params))) {
+        return false;
+    }
+    let found = false;
+    forEachChild(node, (child) => {
+        found ||= usesThis(child);
+    });
+    return found;
+}