rooklang 0.0.0-stage → 0.3.0

package/dist/codegen/element-helpers.d.ts

@@ -0,0 +1,12 @@
+import type * as ast from '../ast.ts';
+import { type Type } from '../checker/types.ts';
+/** What can be inside markup: children of an element, or statements of a markup block. */
+export type Content = ast.JsxChild | ast.Statement;
+export type ControlStatement = ast.JsxStatementContainer['statement'];
+/** `onClick` → `click`, `onKeyDown` → `keydown`; JSX spells `dblclick` as `onDoubleClick`. */
+export declare function eventName(attribute: string): string;
+/** How a child expression is appended: as is, spread, after a null check, or by $$append. */
+export declare function contentKind(node: ast.Expression, given: Type | undefined): 'value' | 'list' | 'nullable' | 'unknown';
+export declare function isPlainContent(type: Type): boolean;
+/** Whether a name is used inside a node, e.g. `event` in a handler. */
+export declare function mentions(node: ast.Node, name: string): boolean;

package/dist/codegen/element-helpers.js

@@ -0,0 +1,54 @@
+import { widenLiterals } from "../checker/types.js";
+import { forEachChild } from "../walk.js";
+/** `onClick` → `click`, `onKeyDown` → `keydown`; JSX spells `dblclick` as `onDoubleClick`. */
+export function eventName(attribute) {
+    return attribute === 'onDoubleClick' ? 'dblclick' : attribute.slice(2).toLowerCase();
+}
+/** How a child expression is appended: as is, spread, after a null check, or by $$append. */
+export function contentKind(node, given) {
+    // `"primary" | "ghost"` is text like `string`.
+    const type = given && widenLiterals(given);
+    if (type === undefined) {
+        // Without types only literals are known for sure.
+        return node.kind === 'StringLiteral' ||
+            node.kind === 'NumberLiteral' ||
+            node.kind === 'TemplateLiteral'
+            ? 'value'
+            : 'unknown';
+    }
+    switch (type.kind) {
+        case 'string':
+        case 'number':
+        case 'object':
+        case 'class':
+            return 'value';
+        case 'array':
+            return isPlainContent(type.element) ? 'list' : 'unknown';
+        case 'nullable':
+            return isPlainContent(type.type) ? 'nullable' : 'unknown';
+        default:
+            return 'unknown';
+    }
+}
+export function isPlainContent(type) {
+    return (type.kind === 'string' ||
+        type.kind === 'number' ||
+        type.kind === 'object' ||
+        type.kind === 'class');
+}
+/** Whether a name is used inside a node, e.g. `event` in a handler. */
+export function mentions(node, name) {
+    let found = false;
+    const visit = (child) => {
+        if (found)
+            return;
+        if (child.kind === 'Identifier' && child.name === name)
+            found = true;
+        else if (child.kind === 'MemberExpression')
+            visit(child.object);
+        else
+            forEachChild(child, visit);
+    };
+    visit(node);
+    return found;
+}

package/dist/codegen/elements.d.ts

@@ -0,0 +1,71 @@
+import type * as ast from '../ast.ts';
+import { CreationEmitter } from './creation.ts';
+import { type Content, type ControlStatement } from './element-helpers.ts';
+import type { Live, Source } from './reactive.ts';
+export type { ControlStatement } from './element-helpers.ts';
+/**
+ * Markup: `<a href="/">Link {name}</a>` becomes statements that create the element. When the
+ * expression is evaluated exactly once they go before the statement that contains it; otherwise
+ * the element is created inside a function that is called right away.
+ *
+ * Markup that a component creates once (what it returns, and elements declared at the top level
+ * of its body) is live: parts that read state are updated when the state changes. `live` is where
+ * their updates go. `{if ...}`, `{switch ...}` and `{for ...}` become plain JS control flow that
+ * appends elements, unless they depend on state; see ControlFlowEmitter.
+ */
+export declare abstract class ElementEmitter extends CreationEmitter {
+    /** A tag that takes its component from a value; implemented by ComponentValueEmitter. */
+    protected abstract valueTag(node: ast.ElementExpression, value: ast.Expression, live: Live | null): string;
+    /** Inlines a component; implemented by ComponentEmitter. */
+    protected abstract expand(node: ast.ElementExpression, component: ast.ComponentDeclaration, live: Live | null): string;
+    /**
+     * The element a ref created for markup to fill in; not `created` when it may be missing, as
+     * `$$root` of a function. Implemented by RefEmitter.
+     */
+    protected abstract presetElement(node: ast.ElementExpression): {
+        name: string;
+        created: boolean;
+    } | null;
+    /** The class of the style an element belongs to; implemented by StyleEmitter. */
+    protected abstract scopeOf(node: ast.ElementExpression): string | null;
+    /** Control flow in live markup that depends on state; implemented by ControlFlowEmitter. */
+    protected abstract liveControl(statement: ControlStatement, live: Live, sources: ReadonlySet<Source>): string;
+    protected element(node: ast.ElementExpression): string;
+    protected elementDeclaration(declaration: string, node: ast.ElementExpression): void;
+    /** Where the updates of `const x = <markup>` go: markup at the top level of a component is live. */
+    protected declaredLive(node: ast.ElementExpression): Live | null;
+    protected elementStatement(node: ast.JsxElementStatement): void;
+    /** A number for a generated name: `$$li1`, `$$updateCount2`, ... */
+    protected nextId(): number;
+    /** Writes the code for an element or a component and returns the variable with the result. */
+    protected create(node: ast.ElementExpression, live: Live | null): string;
+    protected componentOf(node: ast.ElementExpression): ast.ComponentDeclaration | undefined;
+    /** `section.content` of `<section.content />`, or `Page` of `<Page />` with a variable `Page`. */
+    protected tagValue(node: ast.ElementExpression): ast.Expression | null;
+    /** Markup that creates an element or a fragment, not a component. */
+    protected isElement(node: ast.ElementExpression): boolean;
+    /**
+     * Writes the statements that create the element and returns the name of its variable.
+     * `declaration` is `const link` for `const link = <a>`; otherwise a temporary name is used.
+     */
+    protected build(node: ast.ElementExpression, declaration: string | null, live: Live | null): string;
+    /**
+     * Children are appended in order; consecutive ones that need no checks go into one `append`.
+     * Values whose type allows null, or is not known, are checked before they are appended. The
+     * statements of markup blocks are handled here too.
+     */
+    protected children(element: string, children: readonly Content[], live: Live | null): void;
+    protected withContentTarget<T>(element: string, emit: () => T): T;
+    /**
+     * `{value}` that depends on state. Text becomes a text node whose data is replaced; other
+     * content is kept by the $$content helper, which replaces its nodes. Returns what to append.
+     */
+    protected liveChild(expression: ast.Expression, live: Live, sources: ReadonlySet<Source>): string;
+    /**
+     * `const` in a markup block. When its value depends on state, it is computed again on updates,
+     * before the parts that read it.
+     */
+    protected blockConst(node: ast.VariableDeclaration, live: Live | null): void;
+    /** The expression if it can be repeated, otherwise a temporary that holds its value. */
+    protected once(node: ast.Expression): string;
+}

package/dist/codegen/elements.js

@@ -0,0 +1,293 @@
+import { widenLiterals } from "../checker/types.js";
+import { constantAttributes } from "../refs.js";
+import { hasClass } from "../styles.js";
+import { childrenInSvg, isSvgElement } from "../svg.js";
+import { isSimple } from "./analysis.js";
+import { CreationEmitter } from "./creation.js";
+import { contentKind } from "./element-helpers.js";
+import { ARROW, arrayPattern } from "./syntax.js";
+/**
+ * Markup: `<a href="/">Link {name}</a>` becomes statements that create the element. When the
+ * expression is evaluated exactly once they go before the statement that contains it; otherwise
+ * the element is created inside a function that is called right away.
+ *
+ * Markup that a component creates once (what it returns, and elements declared at the top level
+ * of its body) is live: parts that read state are updated when the state changes. `live` is where
+ * their updates go. `{if ...}`, `{switch ...}` and `{for ...}` become plain JS control flow that
+ * appends elements, unless they depend on state; see ControlFlowEmitter.
+ */
+export class ElementEmitter extends CreationEmitter {
+    element(node) {
+        if (this.hoist)
+            return this.create(node, null);
+        const body = this.withHoisting(true, () => this.block(() => this.line(`return ${this.create(node, null)};`)));
+        return `(() => ${body})()`;
+    }
+    elementDeclaration(declaration, node) {
+        const live = this.declaredLive(node);
+        const component = this.componentOf(node);
+        const value = this.tagValue(node);
+        if (component)
+            this.line(`${declaration} = ${this.expand(node, component, live)};`);
+        else if (value)
+            this.line(`${declaration} = ${this.valueTag(node, value, live)};`);
+        else
+            this.build(node, declaration, live);
+    }
+    /** Where the updates of `const x = <markup>` go: markup at the top level of a component is live. */
+    declaredLive(node) {
+        return this.reactive?.topLevel.has(node) ? this.reactive : null;
+    }
+    elementStatement(node) {
+        if (this.contentTarget === null)
+            throw new Error('an element statement outside of markup');
+        const element = this.create(node.element, null);
+        this.line(`${this.contentTarget}.append(${element});`);
+    }
+    /** A number for a generated name: `$$li1`, `$$updateCount2`, ... */
+    nextId() {
+        return ++this.elementCount;
+    }
+    /** Writes the code for an element or a component and returns the variable with the result. */
+    create(node, live) {
+        const component = this.componentOf(node);
+        const value = this.tagValue(node);
+        if (component)
+            return this.expand(node, component, live);
+        return value ? this.valueTag(node, value, live) : this.build(node, null, live);
+    }
+    componentOf(node) {
+        return node.tag && node.value === null ? this.componentNamed(node.tag.name) : undefined;
+    }
+    /** `section.content` of `<section.content />`, or `Page` of `<Page />` with a variable `Page`. */
+    tagValue(node) {
+        if (node.value || !node.tag || !/^[A-Z]/.test(node.tag.name))
+            return node.value;
+        return this.componentNamed(node.tag.name) ? null : node.tag;
+    }
+    /** Markup that creates an element or a fragment, not a component. */
+    isElement(node) {
+        return !this.componentOf(node) && !this.tagValue(node);
+    }
+    /**
+     * Writes the statements that create the element and returns the name of its variable.
+     * `declaration` is `const link` for `const link = <a>`; otherwise a temporary name is used.
+     */
+    build(node, declaration, live) {
+        const tag = node.tag?.name ?? null;
+        const svg = tag !== null && isSvgElement(tag, this.inSvg);
+        const preset = this.presetElement(node);
+        // A ref created the element with its constant attributes, so the markup only fills it in.
+        const created = preset?.created ? preset.name : null;
+        const name = created ?? declaration?.split(' ').at(-1) ?? this.elementName(tag);
+        // Set by a ref, or by the helper that creates the element.
+        const covered = new Set(created ? constantAttributes(node) : []);
+        const scope = tag === null ? null : this.scopeOf(node);
+        // A spread may set the class: the class of the style is added after it, so that both stay.
+        const spread = node.attributes.some((attribute) => attribute.kind === 'JsxSpreadAttribute');
+        const scopeClass = scope && !created && !hasClass(node) ? scope : null;
+        let scoped = false;
+        if (created === null) {
+            const target = declaration ?? `const ${name}`;
+            if (tag === null) {
+                this.line(`${target} = document.createDocumentFragment();`);
+            }
+            else if (preset) {
+                this.createdElements++;
+                this.line(`${target} = ${preset.name} ?? ${this.createElement(tag, svg)};`);
+            }
+            else {
+                const creation = this.createWith(target, name, tag, svg, node.attributes, live, scope, spread ? null : scopeClass);
+                for (const attribute of creation.covered)
+                    covered.add(attribute);
+                scoped = creation.scoped;
+            }
+        }
+        // Bindings go last: `valueAsNumber` needs the `type` attribute to be set.
+        const bindings = [];
+        for (const attribute of node.attributes) {
+            if (covered.has(attribute))
+                continue;
+            if (attribute.kind === 'JsxAttribute' && attribute.name.name === 'ref')
+                continue;
+            if (attribute.kind === 'JsxAttribute' && attribute.name.name.startsWith('bind:')) {
+                bindings.push(attribute);
+            }
+            else {
+                this.attribute(name, tag, attribute, live, svg, scope);
+            }
+        }
+        // Without a class attribute the element still gets the class of its style; a ref has set it.
+        if (scopeClass !== null && !scoped) {
+            if (spread)
+                this.line(`${name}.classList.add(${JSON.stringify(scopeClass)});`);
+            else
+                this.scopeClass(name, scopeClass, svg);
+        }
+        if (tag !== null) {
+            for (const attribute of bindings)
+                this.binding(name, tag, attribute, live);
+        }
+        const inSvg = this.inSvg;
+        this.inSvg = childrenInSvg(tag, svg, inSvg);
+        try {
+            this.children(name, node.children, live);
+        }
+        finally {
+            this.inSvg = inSvg;
+        }
+        if (created !== null && declaration)
+            this.line(`${declaration} = ${created};`);
+        return name;
+    }
+    /**
+     * Children are appended in order; consecutive ones that need no checks go into one `append`.
+     * Values whose type allows null, or is not known, are checked before they are appended. The
+     * statements of markup blocks are handled here too.
+     */
+    children(element, children, live) {
+        let pending = [];
+        let pendingCalls = false;
+        const flush = () => {
+            if (pending.length > 0)
+                this.line(`${element}.append(${pending.join(', ')});`);
+            pending = [];
+            pendingCalls = false;
+        };
+        for (const child of children) {
+            switch (child.kind) {
+                case 'JsxText':
+                    pending.push(JSON.stringify(child.value));
+                    break;
+                case 'ElementExpression':
+                case 'JsxElementStatement': {
+                    // A child element is created before the append; earlier calls must still run first.
+                    if (pendingCalls)
+                        flush();
+                    const node = child.kind === 'ElementExpression' ? child : child.element;
+                    pending.push(this.create(node, live));
+                    break;
+                }
+                case 'JsxStatementContainer':
+                case 'IfStatement':
+                case 'ForStatement':
+                case 'ForInStatement':
+                case 'SwitchStatement': {
+                    const statement = child.kind === 'JsxStatementContainer' ? child.statement : child;
+                    const sources = live?.dependencies(statement);
+                    if (live && sources && sources.size > 0) {
+                        if (pendingCalls)
+                            flush();
+                        pending.push(this.liveControl(statement, live, sources));
+                    }
+                    else {
+                        // Nothing in it changes: plain control flow that appends the elements.
+                        flush();
+                        this.withContentTarget(element, () => this.statement(statement));
+                    }
+                    break;
+                }
+                case 'VariableDeclaration':
+                    flush();
+                    this.blockConst(child, live);
+                    break;
+                case 'JsxExpressionContainer': {
+                    const { expression } = child;
+                    const sources = live?.dependencies(expression);
+                    if (live && sources && sources.size > 0) {
+                        if (pendingCalls)
+                            flush();
+                        pending.push(this.liveChild(expression, live, sources));
+                        break;
+                    }
+                    switch (contentKind(expression, this.typeOf(expression))) {
+                        case 'value':
+                            pending.push(this.expression(expression, ARROW));
+                            pendingCalls ||= !isSimple(expression);
+                            break;
+                        case 'list':
+                            pending.push(`...${this.expression(expression, ARROW)}`);
+                            pendingCalls ||= !isSimple(expression);
+                            break;
+                        case 'nullable': {
+                            flush();
+                            const text = this.once(expression);
+                            this.line(`if (${text} != null) ${element}.append(${text});`);
+                            break;
+                        }
+                        case 'unknown':
+                            flush();
+                            this.helpers.add('append');
+                            this.line(`$$append(${element}, ${this.expression(expression, ARROW)});`);
+                            break;
+                    }
+                    break;
+                }
+                default:
+                    // The parser allows no other statements in markup.
+                    flush();
+                    this.statement(child);
+            }
+        }
+        flush();
+    }
+    withContentTarget(element, emit) {
+        const saved = this.contentTarget;
+        this.contentTarget = element;
+        try {
+            return emit();
+        }
+        finally {
+            this.contentTarget = saved;
+        }
+    }
+    /**
+     * `{value}` that depends on state. Text becomes a text node whose data is replaced; other
+     * content is kept by the $$content helper, which replaces its nodes. Returns what to append.
+     */
+    liveChild(expression, live, sources) {
+        const type = this.typeOf(expression);
+        const kind = type && widenLiterals(type).kind;
+        const id = this.nextId();
+        if (kind === 'string' || kind === 'number') {
+            const text = this.liveExpression(expression);
+            const node = `$$text${id}`;
+            this.line(`const ${node} = document.createTextNode(${text});`);
+            live.depend(sources, `${node}.data = ${text};`);
+            return node;
+        }
+        const name = `$$content${id}`;
+        const update = `$$updateContent${id}`;
+        this.helpers.add('content');
+        this.line(`const [${name}, ${update}] = $$content(${this.liveFunction(expression)});`);
+        live.depend(sources, `${update}();`);
+        return name;
+    }
+    /**
+     * `const` in a markup block. When its value depends on state, it is computed again on updates,
+     * before the parts that read it.
+     */
+    blockConst(node, live) {
+        const sources = live?.dependencies(node);
+        const names = node.names.map((name) => (name.name === '_' ? '' : this.name(name.name)));
+        if (!live || !sources || sources.size === 0 || names.every((name) => name === '')) {
+            this.statement(node);
+            return;
+        }
+        const values = node.values.map((value) => this.liveExpression(value));
+        const assignments = values.length === names.length
+            ? names.flatMap((name, i) => (name === '' ? [] : [`${name} = ${values[i]}`]))
+            : [`${arrayPattern(names)} = ${values[0]}`];
+        this.line(`let ${assignments.join(', ')};`);
+        for (const assignment of assignments)
+            live.depend(sources, `${assignment};`);
+    }
+    /** The expression if it can be repeated, otherwise a temporary that holds its value. */
+    once(node) {
+        if (isSimple(node))
+            return this.expression(node, ARROW);
+        const temp = this.temp();
+        this.line(`const ${temp} = ${this.expression(node, ARROW)};`);
+        return temp;
+    }
+}

package/dist/codegen/emitter.d.ts

@@ -0,0 +1,135 @@
+import type * as ast from '../ast.ts';
+import type { Type } from '../checker/types.ts';
+import { type DecoratorSource } from '../decorators.ts';
+import type { InlinePackage } from '../inline-packages.ts';
+import { type ImportedComponent, type LocalizedPackage } from './imported.ts';
+import type { Root } from '../refs.ts';
+import type { StyleModule } from '../style-modules.ts';
+import type { BindingKind } from './analysis.ts';
+import type { Helper } from './helpers.ts';
+export interface JsOptions {
+    /** The Rook source, used to keep the blank lines between statements. */
+    source: string;
+    /** Replace `.rk` with `.js` in relative import paths, for output written next to the sources. */
+    rewriteImports: boolean;
+    /** Types from the checker, when it ran; without them the generated code is more general. */
+    types?: WeakMap<ast.Expression, Type> | undefined;
+    /** Decorators imported from other modules, by name: their code is inlined here. */
+    decorators?: ReadonlyMap<string, ImportedDecorator> | undefined;
+    /** Components imported from other modules, by name: called, or inlined when they are small. */
+    components?: ReadonlyMap<string, ImportedComponent> | undefined;
+    /** Components of the module that become functions, since inlining them adds too many lines. */
+    functions?: ReadonlySet<string> | undefined;
+    /** The CSS modules the module imports, by their paths as written. */
+    styleModules?: ReadonlyMap<string, StyleModule> | undefined;
+    /** Create elements with their attributes by a helper, $$element; see creation.ts. */
+    elementHelper?: boolean | undefined;
+    /** For `go`: where the worker module is (`./app.worker.js`), or in it, the functions it runs. */
+    goroutines?: {
+        workerUrl: string;
+    } | {
+        targets: readonly string[];
+    } | undefined;
+}
+/** A decorator of another module, with the types of the expressions of that module. */
+export interface ImportedDecorator extends DecoratorSource {
+    types: WeakMap<ast.Expression, Type> | null;
+    /** The components of that module its code uses, which go with it into the components here. */
+    inline: InlinePackage | null;
+}
+/** How a function implements its `defer` statements. */
+export type DeferMode = 'none' | 'try' | 'stack' | 'effect';
+interface FunctionContext {
+    deferMode: DeferMode;
+    /** Where `defer` puts its closures in 'stack' and 'effect' modes. */
+    deferList: string;
+    /** Counter for `$$0`, `$$1`, ... temporaries. */
+    temps: number;
+    /** Innermost last: `null` for loops and switches, a label for a switch compiled to if/else. */
+    breakTargets: (string | null)[];
+    /** An iterator, `func(yield func(T) bool)`: a generator, where `yield(v)` yields. */
+    iterator?: boolean;
+}
+/**
+ * The base of the JS generator: the output buffer, scopes of declared names and the state of the
+ * current function. The generator is split into layers, each adding to the previous one:
+ *
+ *     Emitter → ExpressionEmitter → CallEmitter → SimpleStatementEmitter → ControlStatementEmitter
+ *       → ParallelLoopEmitter → StatementEmitter → UpdateEmitter → AttributeEmitter
+ *       → CreationEmitter → ElementEmitter → ControlFlowEmitter → ComponentPropsEmitter
+ *       → ComponentValueEmitter → EarlyReturnEmitter → RefEmitter
+ *       → StyleEmitter → ComponentEmitter → WebComponentEmitter → FunctionEmitter → JsGenerator
+ */
+export declare abstract class Emitter {
+    protected readonly program: ast.Program;
+    protected readonly options: JsOptions;
+    protected lines: string[];
+    private level;
+    private readonly scopes;
+    protected fn: FunctionContext;
+    /** Helpers that the module must define, such as $$runDeferred. */
+    protected readonly helpers: Set<Helper>;
+    /**
+     * Whether code for the current expression may be written before the statement that contains it.
+     * Elements use this to be created in statements of their own; it is off where an expression is
+     * not always evaluated exactly once (branches of `?:`, loop conditions and so on).
+     */
+    protected hoist: boolean;
+    /** Top-level `type` aliases, to find the zero value of `let id ID`. */
+    protected readonly typeAliases: Map<string, ast.TypeNode>;
+    /** Names that are assigned somewhere in the module; others keep their value. */
+    protected readonly assigned: Set<string>;
+    /** Names used as values; imports used only as types are dropped. */
+    protected readonly valueNames: Set<string>;
+    /** Components of the module with their decorators applied, inlined where they are used. */
+    protected readonly components: Map<string, ast.ComponentDeclaration>;
+    /**
+     * Components that become functions: recursive ones cannot be inlined, and web components
+     * (`@html-tag`) create their markup in the element's class.
+     */
+    protected readonly functionComponents: ReadonlySet<ast.ComponentDeclaration>;
+    /** Web components of the module by their tags: `<app-card count={3} />` sets their properties. */
+    protected readonly webComponents: Map<string, ast.ComponentDeclaration>;
+    /** The JS functions of components of other modules: `$$Card`, imported from their modules. */
+    protected readonly functionNames: Map<ast.ComponentDeclaration, string>;
+    /** For those, the element at the top of what they create, found in their modules. */
+    protected readonly importedRoots: Map<ast.ComponentDeclaration, Root>;
+    /** The inlined copies of each component and the lines they take, to choose functions (js.ts). */
+    readonly inlined: Map<string, {
+        copies: number;
+        lines: number;
+    }>;
+    /** The decorators that components of the module apply, by name. */
+    protected readonly appliedDecorators: Set<string>;
+    /** Copies of the code of other modules: their positions are in the sources of those. */
+    private readonly foreign;
+    /** Components of other modules inlined here, by name, with what their packages bring. */
+    protected readonly inlinedImports: Map<string, LocalizedPackage>;
+    /** The components that decorators of other modules bring, by the names of the decorators. */
+    protected readonly decoratorImports: Map<string, LocalizedPackage>;
+    /** Components a package brings: they have no function here, so they are always inlined. */
+    readonly alwaysInlined: Set<string>;
+    constructor(program: ast.Program, options: JsOptions);
+    protected indent(): string;
+    /** Writes a line at the current indentation. Later lines of `text` are already indented. */
+    protected line(text: string): void;
+    protected blankLine(): void;
+    /** Returns the lines written by `emit`, one level deeper than the current one. */
+    protected capture(emit: () => void): string[];
+    /** Renders the lines written by `emit` as a `{ ... }` block, for use inside a line. */
+    protected block(emit: () => void): string;
+    protected blankLineBetween(previous: ast.Node, next: ast.Node): boolean;
+    /** A component of the module as it is inlined: with its decorators applied. */
+    protected applied(component: ast.ComponentDeclaration): ast.ComponentDeclaration;
+    protected withScope<T>(bindings: Iterable<[string, BindingKind]>, emit: () => T): T;
+    protected lookup(name: string): BindingKind | undefined;
+    /** The JS name for a Rook name. */
+    protected name(name: string): string;
+    protected params(params: ast.Parameter[]): string;
+    protected withFunction<T>(mode: DeferMode, params: ast.Parameter[], emit: () => T): T;
+    protected withHoisting<T>(hoist: boolean, emit: () => T): T;
+    /** A fresh temporary name: `$$0`, `$$1`, ... */
+    protected temp(): string;
+    protected withBreakTarget<T>(label: string | null, emit: () => T): T;
+}
+export {};