rooklang 0.0.0-stage → 0.3.0

package/dist/names.js

@@ -0,0 +1,267 @@
+import { forEachChild } from "./walk.js";
+// The names that code inside a node assigns, mentions or declares, and those it uses from outside.
+/** Names assigned anywhere inside `node`: `x = ...`, `x += ...`, `x++`. */
+export function assignedNames(node, names = new Set()) {
+    if (node.kind === 'AssignmentStatement') {
+        for (const target of node.targets)
+            if (target.kind === 'Identifier')
+                names.add(target.name);
+    }
+    else if (node.kind === 'IncDecStatement' && node.target.kind === 'Identifier') {
+        names.add(node.target.name);
+    }
+    else if (node.kind === 'JsxAttribute' &&
+        node.name.name.startsWith('bind:') &&
+        node.value?.kind === 'Identifier') {
+        // `bind:value={name}` writes what the user enters.
+        names.add(node.value.name);
+    }
+    forEachChild(node, (child) => assignedNames(child, names));
+    return names;
+}
+/** Whether an identifier with one of `names` occurs in `node`, whatever it refers to. */
+export function mentionsName(node, names) {
+    if (node.kind === 'Identifier')
+        return names.has(node.name);
+    let found = false;
+    forEachChild(node, (child) => {
+        found ||= mentionsName(child, names);
+    });
+    return found;
+}
+/** Every name declared inside `node`: parameters and all local declarations, nested ones too. */
+export function declaredNames(node) {
+    const names = new Set();
+    const visit = (node) => {
+        switch (node.kind) {
+            case 'Parameter':
+                names.add(node.name.name);
+                break;
+            case 'VariableDeclaration':
+            case 'SelectCase':
+                for (const name of node.names)
+                    names.add(name.name);
+                break;
+            case 'FuncDeclaration':
+            case 'ClassDeclaration':
+                names.add(node.name.name);
+                break;
+            case 'ForInStatement':
+                names.add(node.value.name);
+                if (node.key)
+                    names.add(node.key.name);
+                break;
+            case 'CatchClause':
+                if (node.param)
+                    names.add(node.param.name);
+                break;
+            case 'EventHandler':
+                names.add('event');
+                break;
+            default:
+                break;
+        }
+        forEachChild(node, visit);
+    };
+    forEachChild(node, visit);
+    return names;
+}
+/** Names a component or a decorator uses as values but does not declare: those come from the module. */
+export function freeNames(component) {
+    const used = new Set();
+    const declared = new Set(component.params.map((param) => param.name.name));
+    const visit = (node) => {
+        if (node === null)
+            return;
+        switch (node.kind) {
+            case 'Identifier':
+                used.add(node.name);
+                return;
+            case 'MemberExpression':
+                visit(node.object);
+                return;
+            case 'Property':
+                visit(node.value);
+                return;
+            case 'ElementExpression':
+                // Tags are not values: components are found by the generator itself.
+                node.attributes.forEach(visit);
+                node.children.forEach(visit);
+                return;
+            case 'JsxAttribute':
+                visit(node.value);
+                return;
+            case 'EventHandler':
+                declared.add('event');
+                node.body.forEach(visit);
+                return;
+            case 'VariableDeclaration':
+                for (const name of node.names)
+                    declared.add(name.name);
+                node.values.forEach(visit);
+                return;
+            case 'SelectCase':
+                for (const name of node.names)
+                    declared.add(name.name);
+                visit(node.operation);
+                node.body.forEach(visit);
+                return;
+            case 'FuncDeclaration':
+            case 'ClassDeclaration':
+                declared.add(node.name.name);
+                forEachChild(node, visit);
+                return;
+            case 'Parameter':
+                declared.add(node.name.name);
+                visit(node.defaultValue);
+                return;
+            case 'ForInStatement':
+                declared.add(node.value.name);
+                if (node.key)
+                    declared.add(node.key.name);
+                visit(node.iterable);
+                visit(node.body);
+                return;
+            case 'CatchClause':
+                if (node.param)
+                    declared.add(node.param.name);
+                visit(node.body);
+                return;
+            case 'TypeReference':
+            case 'ArrayType':
+            case 'NullableType':
+            case 'FuncType':
+            case 'ComponentType':
+            case 'ObjectType':
+            case 'UnionType':
+            case 'LiteralType':
+            case 'TypeParameter':
+                return;
+            default:
+                forEachChild(node, visit);
+        }
+    };
+    component.params.forEach(visit);
+    visit(component.body);
+    return new Set([...used].filter((name) => !declared.has(name)));
+}
+/** Names declared directly in a list of statements: they hide outer names in the whole block. */
+export function declaredIn(statements) {
+    return statements.flatMap((statement) => {
+        switch (statement.kind) {
+            case 'VariableDeclaration':
+                return statement.names.map((name) => name.name);
+            case 'FuncDeclaration':
+            case 'ClassDeclaration':
+                return [statement.name.name];
+            default:
+                return [];
+        }
+    });
+}
+/** Names declared at the top level of a module, imports included: what its code can use. */
+export function topLevelNames(program) {
+    const names = new Set(declaredIn(program.body));
+    for (const statement of program.body) {
+        if (statement.kind !== 'ImportDeclaration')
+            continue;
+        if (statement.defaultImport)
+            names.add(statement.defaultImport.name);
+        if (statement.namespaceImport)
+            names.add(statement.namespaceImport.name);
+        for (const specifier of statement.namedImports)
+            names.add(specifier.local.name);
+    }
+    return names;
+}
+/**
+ * Names used as values, as opposed to declared names, property names and types. A capitalized tag
+ * is a value unless `isComponent` says it names a component: `<Page />` with a variable `Page`.
+ */
+export function collectValueNames(node, names, isComponent = () => true) {
+    const visit = (child) => {
+        if (child)
+            collectValueNames(child, names, isComponent);
+    };
+    switch (node.kind) {
+        case 'Identifier':
+            names.add(node.name);
+            return;
+        case 'MemberExpression':
+            visit(node.object);
+            return;
+        case 'Property':
+            visit(node.value);
+            return;
+        case 'VariableDeclaration':
+            node.values.forEach(visit);
+            return;
+        case 'FuncDeclaration':
+        case 'MethodDeclaration':
+        case 'ConstructorDeclaration':
+        case 'FuncExpression':
+        case 'ArrowFunction':
+            visit(node.body);
+            return;
+        case 'ComponentDeclaration':
+            node.decorators.forEach(visit);
+            node.params.forEach(visit);
+            visit(node.body);
+            return;
+        case 'DecoratorDeclaration':
+            node.params.forEach(visit);
+            visit(node.body);
+            return;
+        case 'ElementExpression':
+            // Tags are not values, except those that take a component from one.
+            visit(node.value);
+            if (node.value === null && node.tag && /^[A-Z]/.test(node.tag.name)) {
+                if (!isComponent(node.tag.name))
+                    names.add(node.tag.name);
+            }
+            node.attributes.forEach(visit);
+            node.children.forEach(visit);
+            return;
+        case 'JsxAttribute':
+            visit(node.value);
+            return;
+        case 'Parameter':
+            visit(node.defaultValue);
+            return;
+        case 'ClassDeclaration':
+            visit(node.superClass);
+            node.members.forEach(visit);
+            return;
+        case 'FieldDeclaration':
+            visit(node.value);
+            return;
+        case 'ForInStatement':
+            visit(node.iterable);
+            visit(node.body);
+            return;
+        case 'CatchClause':
+            visit(node.body);
+            return;
+        case 'ImportDeclaration':
+        case 'InterfaceDeclaration':
+        case 'TypeAliasDeclaration':
+        case 'TypeReference':
+        case 'ArrayType':
+        case 'NullableType':
+        case 'FuncType':
+        case 'ComponentType':
+        case 'ObjectType':
+        case 'UnionType':
+        case 'LiteralType':
+        case 'TypeParameter':
+            return;
+        default:
+            forEachChild(node, visit);
+    }
+}
+/** The components that the code in `node` uses as values: `content: Intro`. */
+export function componentValues(node, isComponent) {
+    const values = new Set();
+    collectValueNames(node, values, isComponent);
+    return [...values].filter(isComponent);
+}

package/dist/parser/base.d.ts

@@ -0,0 +1,96 @@
+import type * as ast from '../ast.ts';
+import type { Diagnostic } from '../diagnostics.ts';
+import type { StringToken, Token, TokenKind } from '../lexer/token.ts';
+import { type Context } from './syntax.ts';
+export declare abstract class ParserBase {
+    protected abstract parseBreakOrContinue(): ast.BreakStatement | ast.ContinueStatement;
+    protected abstract parseDefer(): ast.DeferStatement;
+    protected abstract parseFor(): ast.ForStatement | ast.ForInStatement;
+    protected abstract parseGoFor(): ast.ForStatement | ast.ForInStatement;
+    protected abstract parseIf(): ast.IfStatement;
+    protected abstract parseSwitch(): ast.SwitchStatement;
+    protected abstract parseSelect(): ast.SelectStatement;
+    protected abstract parseThrow(): ast.ThrowStatement;
+    protected abstract parseTry(): ast.TryStatement;
+    protected abstract parseComponent(start: number, exported: boolean, htmlTag?: ast.HtmlTag | null, decorators?: ast.DecoratorUse[]): ast.ComponentDeclaration;
+    protected abstract parseDecorated(start: number, exported: boolean): ast.ComponentDeclaration;
+    protected abstract isDecoratorDeclaration(): boolean;
+    protected abstract parseDecoratorDeclaration(start: number, exported: boolean): ast.DecoratorDeclaration;
+    protected abstract isDecoratorMember(): boolean;
+    protected abstract parseExport(): ast.Statement;
+    protected abstract parseFuncDeclaration(start: number, exported: boolean): ast.FuncDeclaration;
+    protected abstract parseImport(): ast.ImportDeclaration;
+    protected abstract parseClass(start: number, exported: boolean): ast.ClassDeclaration;
+    protected abstract parseInterface(start: number, exported: boolean): ast.InterfaceDeclaration;
+    protected abstract parseTypeAlias(start: number, exported: boolean): ast.TypeAliasDeclaration;
+    protected abstract canStartType(): boolean;
+    protected abstract parseType(): ast.TypeNode;
+    protected abstract parseTypeArgs(): ast.TypeNode[];
+    protected abstract parseTypeMembers(): ast.TypeMember[];
+    protected abstract parseExpression(): ast.Expression;
+    protected abstract parsePostfix(expression: ast.Expression): ast.Expression;
+    protected abstract parsePrimary(): ast.Expression;
+    protected abstract isArrowFunctionAhead(): boolean;
+    protected abstract parseArguments(): (ast.Expression | ast.SpreadElement)[];
+    protected abstract parseArrayLiteral(): ast.ArrayLiteral;
+    protected abstract parseConversion(): ast.ConversionExpression;
+    protected abstract parseMake(): ast.MakeExpression;
+    protected abstract parseArrowFunction(async?: boolean): ast.ArrowFunction;
+    protected abstract parseFuncExpression(async?: boolean): ast.FuncExpression;
+    protected abstract parseIdentifier(what?: string): ast.Identifier;
+    protected abstract parseList<T>(close: TokenKind, parseItem: () => T): T[];
+    protected abstract parseNew(): ast.NewExpression;
+    protected abstract parseObjectLiteral(): ast.ObjectLiteral;
+    protected abstract parseParenthesized(): ast.Expression;
+    protected abstract parsePropertyName(what?: string): ast.Identifier;
+    protected abstract parseTemplate(first: StringToken): ast.TemplateLiteral;
+    protected abstract parseJsxElement(): ast.ElementExpression;
+    protected abstract parseStringLiteral(what?: string): ast.StringLiteral;
+    readonly diagnostics: Diagnostic[];
+    protected readonly tokens: Token[];
+    protected pos: number;
+    protected context: Context;
+    /** Expressions written in parentheses, which the tree itself does not record. */
+    protected readonly parenthesized: WeakSet<ast.Expression>;
+    /** Markup and components: the entries turn them off unless the package turns them on. */
+    protected readonly markup: boolean;
+    constructor(tokens: Token[], markup?: boolean);
+    /** Fails at markup, a component or a decorator when they are off, saying how to turn them on. */
+    protected requireMarkup(what: string): void;
+    protected peek(offset?: number): Token;
+    protected check(kind: TokenKind): boolean;
+    /** Whether the current token is the word `word`, e.g. the contextual keyword `from`. */
+    protected checkWord(word: string): boolean;
+    protected next(): Token;
+    protected accept(kind: TokenKind): boolean;
+    protected acceptWord(word: string): boolean;
+    protected expect(kind: TokenKind, what?: string): Token;
+    /**
+     * The `>` that closes type arguments or parameters. In `Box<Box<number>>` the lexer reads `>>`,
+     * so a token that starts with `>` is split: its first character closes these.
+     */
+    protected expectTypeClose(what: string): void;
+    protected expectWord(word: string): void;
+    protected isImplicitSemicolon(): boolean;
+    /** Start and end of a node that began at `start` and ends with the last consumed token. */
+    protected span(start: number): ast.NodeBase;
+    /** Reports an error unless one was already reported at the same position. */
+    protected error(message: string, start: number, end: number): void;
+    /** Reports an error at the current token and abandons the current statement. */
+    protected fail(message: string): never;
+    protected failAt(message: string, start: number, end: number): never;
+    /** Runs `parse` with some context flags changed. */
+    protected withContext<T>(changes: Partial<Context>, parse: () => T): T;
+    /** Inside brackets `{` starts an object literal again, even within an if/for/switch header. */
+    protected nested<T>(parse: () => T): T;
+    /**
+     * Parses items separated by newlines or `;` until `isEnd`. A syntax error abandons only the item
+     * it occurred in: the parser skips to the item's end and continues with the next one.
+     */
+    protected parseSeparated(isEnd: () => boolean, parseItem: () => void): void;
+    /**
+     * Skips the broken statement that began at token index `start`: up to the first `;` outside
+     * brackets, or up to a `}` that closes the enclosing block.
+     */
+    protected synchronize(start: number): void;
+}

package/dist/parser/base.js

@@ -0,0 +1,202 @@
+import { STATEMENT_KEYWORDS, BRACKETS, ParseError, describe } from "./syntax.js";
+// The parser is a chain of layers, one per area: base → simple statements → statements → control
+// flow → declarations → decorators → classes → types → expressions → literals → markup → Parser
+// (parser.ts). Statements, expressions and markup contain each other, so methods of later layers
+// that earlier ones call are declared here as abstract.
+//
+// This layer reads tokens, reports errors and recovers from them.
+export class ParserBase {
+    diagnostics = [];
+    tokens;
+    pos = 0;
+    context = {
+        topLevel: true,
+        inFunction: false,
+        inLoop: false,
+        inBreakable: false,
+        inDefer: false,
+        inGoFor: false,
+        // Modules are ES modules: `await` works at their top level.
+        inAsync: true,
+        noObjectLiteral: false,
+        inComponent: false,
+        inMarkup: false,
+    };
+    /** Expressions written in parentheses, which the tree itself does not record. */
+    parenthesized = new WeakSet();
+    /** Markup and components: the entries turn them off unless the package turns them on. */
+    markup;
+    constructor(tokens, markup = true) {
+        this.tokens = tokens;
+        this.markup = markup;
+    }
+    /** Fails at markup, a component or a decorator when they are off, saying how to turn them on. */
+    requireMarkup(what) {
+        if (this.markup)
+            return;
+        this.fail(`${what} off: turn on markup and components with "rook": { "markup": true } in package.json, or with --markup`);
+    }
+    peek(offset = 0) {
+        return this.tokens[Math.min(this.pos + offset, this.tokens.length - 1)];
+    }
+    check(kind) {
+        return this.peek().kind === kind;
+    }
+    /** Whether the current token is the word `word`, e.g. the contextual keyword `from`. */
+    checkWord(word) {
+        const token = this.peek();
+        return token.kind === 'Identifier' && token.text === word;
+    }
+    next() {
+        const token = this.peek();
+        if (token.kind !== 'EOF')
+            this.pos++;
+        return token;
+    }
+    accept(kind) {
+        if (!this.check(kind))
+            return false;
+        this.next();
+        return true;
+    }
+    acceptWord(word) {
+        if (!this.checkWord(word))
+            return false;
+        this.next();
+        return true;
+    }
+    expect(kind, what = `"${kind}"`) {
+        if (this.check(kind))
+            return this.next();
+        return this.fail(`expected ${what}, found ${describe(this.peek())}`);
+    }
+    /**
+     * The `>` that closes type arguments or parameters. In `Box<Box<number>>` the lexer reads `>>`,
+     * so a token that starts with `>` is split: its first character closes these.
+     */
+    expectTypeClose(what) {
+        const token = this.peek();
+        if (token.kind === '>') {
+            this.next();
+            return;
+        }
+        if (token.kind.startsWith('>')) {
+            const rest = token.kind.slice(1);
+            this.tokens[this.pos] = {
+                ...token,
+                kind: rest,
+                text: token.text.slice(1),
+                start: token.start + 1,
+            };
+            return;
+        }
+        this.fail(`expected ${what}, found ${describe(token)}`);
+    }
+    expectWord(word) {
+        if (!this.acceptWord(word))
+            this.fail(`expected "${word}", found ${describe(this.peek())}`);
+    }
+    isImplicitSemicolon() {
+        const token = this.peek();
+        return token.kind === ';' && token.text === '';
+    }
+    /** Start and end of a node that began at `start` and ends with the last consumed token. */
+    span(start) {
+        return { start, end: this.tokens[this.pos - 1]?.end ?? start };
+    }
+    /** Reports an error unless one was already reported at the same position. */
+    error(message, start, end) {
+        if (this.diagnostics.some((d) => d.start === start))
+            return;
+        this.diagnostics.push({ message, start, end });
+    }
+    /** Reports an error at the current token and abandons the current statement. */
+    fail(message) {
+        const token = this.peek();
+        return this.failAt(message, token.start, token.end);
+    }
+    failAt(message, start, end) {
+        this.error(message, start, end);
+        throw new ParseError(message);
+    }
+    /** Runs `parse` with some context flags changed. */
+    withContext(changes, parse) {
+        const saved = this.context;
+        this.context = { ...saved, ...changes };
+        try {
+            return parse();
+        }
+        finally {
+            this.context = saved;
+        }
+    }
+    /** Inside brackets `{` starts an object literal again, even within an if/for/switch header. */
+    nested(parse) {
+        return this.withContext({ noObjectLiteral: false }, parse);
+    }
+    /**
+     * Parses items separated by newlines or `;` until `isEnd`. A syntax error abandons only the item
+     * it occurred in: the parser skips to the item's end and continues with the next one.
+     */
+    parseSeparated(isEnd, parseItem) {
+        while (!isEnd() && !this.check('EOF')) {
+            if (this.accept(';'))
+                continue;
+            const start = this.pos;
+            try {
+                parseItem();
+            }
+            catch (error) {
+                if (!(error instanceof ParseError))
+                    throw error;
+                this.synchronize(start);
+                if (this.pos === start)
+                    this.next();
+            }
+        }
+    }
+    /**
+     * Skips the broken statement that began at token index `start`: up to the first `;` outside
+     * brackets, or up to a `}` that closes the enclosing block.
+     */
+    synchronize(start) {
+        this.pos = start;
+        // The `;` inside a `for` header do not end the statement.
+        const explicitSemicolonEnds = this.peek().kind !== 'for';
+        const open = [];
+        while (true) {
+            const token = this.next();
+            const kind = token.kind;
+            if (kind === 'EOF')
+                return;
+            if (kind === ';') {
+                if (open.length === 0 && (token.text === '' || explicitSemicolonEnds))
+                    return;
+                // A newline before a statement keyword: probably an unclosed bracket on the line above.
+                if (token.text === '' && STATEMENT_KEYWORDS.has(this.peek().kind))
+                    return;
+            }
+            else if (kind === '(' || kind === '[' || kind === '{' || kind === 'TemplateHead') {
+                open.push(kind);
+            }
+            else if (kind === 'TemplateMiddle') {
+                // Closes one substitution and opens the next one.
+            }
+            else {
+                const opening = BRACKETS[kind];
+                if (opening !== undefined) {
+                    const index = open.lastIndexOf(opening);
+                    if (index !== -1)
+                        open.length = index;
+                    else if (kind === '}') {
+                        // A `}` without a matching `{` closes the enclosing block: leave it to the block.
+                        this.pos--;
+                        return;
+                    }
+                }
+            }
+            if (this.check('}') && !open.includes('{'))
+                return;
+        }
+    }
+}

package/dist/parser/classes.d.ts

@@ -0,0 +1,8 @@
+import type * as ast from '../ast.ts';
+import { DecoratorParser } from './decorators.ts';
+export declare abstract class ClassParser extends DecoratorParser {
+    protected parseClass(start: number, exported: boolean): ast.ClassDeclaration;
+    protected parseClassMember(): ast.ClassMember[];
+    protected parseInterface(start: number, exported: boolean): ast.InterfaceDeclaration;
+    protected parseTypeAlias(start: number, exported: boolean): ast.TypeAliasDeclaration;
+}