rooklang 0.0.0-stage → 0.3.1

package/dist/parser/markup.js

@@ -0,0 +1,193 @@
+import { LiteralParser } from "./literals.js";
+import { describe, cleanJsxText, isHandlerReference } from "./syntax.js";
+// Markup: elements, attributes, event handlers and `{...}` in markup.
+export class MarkupParser extends LiteralParser {
+    /** `<tag attributes>children</tag>`, `<tag ... />` or a fragment `<>children</>`. */
+    parseJsxElement() {
+        // The code in markup runs again in update functions, which are not async.
+        return this.withContext({ inAsync: false }, () => this.parseMarkup());
+    }
+    parseMarkup() {
+        this.requireMarkup('markup is');
+        const start = this.expect('JsxTagOpen').start;
+        const tag = this.check('JsxTagEnd') ? null : this.parseJsxName('tag name');
+        const attributes = [];
+        while (tag && !this.check('JsxTagEnd') && !this.check('JsxSelfClose')) {
+            attributes.push(this.parseJsxAttribute());
+        }
+        const value = tag && this.tagValue(tag);
+        if (tag && this.accept('JsxSelfClose')) {
+            return {
+                kind: 'ElementExpression',
+                tag,
+                value,
+                attributes,
+                children: [],
+                ...this.span(start),
+            };
+        }
+        this.expect('JsxTagEnd', tag ? '">" or "/>"' : '">"');
+        const children = [];
+        while (!this.check('JsxCloseTagOpen')) {
+            const token = this.peek();
+            if (token.kind === 'JsxText') {
+                this.next();
+                const value = cleanJsxText(token.value);
+                if (value !== '')
+                    children.push({ kind: 'JsxText', value, start: token.start, end: token.end });
+            }
+            else if (token.kind === 'JsxTagOpen') {
+                children.push(this.parseJsxElement());
+            }
+            else if (token.kind === '{') {
+                const container = this.parseJsxExpressionContainer();
+                if (container)
+                    children.push(container);
+            }
+            else {
+                this.fail(`expected element content or a closing tag, found ${describe(token)}`);
+            }
+        }
+        // The closing tag must match the opening one.
+        const closeStart = this.expect('JsxCloseTagOpen').start;
+        const closing = this.check('JsxName') ? this.next().text : null;
+        if (closing !== (tag?.name ?? null)) {
+            this.failAt(`expected </${tag?.name ?? ''}> to close <${tag?.name ?? ''}>`, closeStart, this.span(closeStart).end);
+        }
+        this.expect('JsxTagEnd');
+        return { kind: 'ElementExpression', tag, value, attributes, children, ...this.span(start) };
+    }
+    /** `<section.content />`: a tag with a dot is the value `section.content`. */
+    tagValue(tag) {
+        const parts = tag.name.split('.');
+        if (parts.length === 1)
+            return null;
+        if (!parts.every((part) => /^[\p{ID_Start}$_][\p{ID_Continue}$]*$/u.test(part))) {
+            this.error(`"${tag.name}" is not a value: a tag with a dot is written like <section.content />`, tag.start, tag.end);
+            return null;
+        }
+        let end = tag.start - 1;
+        const identifier = (name) => {
+            const start = end + 1;
+            end = start + name.length;
+            return { kind: 'Identifier', name, start, end };
+        };
+        let value = identifier(parts[0]);
+        for (const part of parts.slice(1)) {
+            const property = identifier(part);
+            value = {
+                kind: 'MemberExpression',
+                object: value,
+                property,
+                optional: false,
+                start: tag.start,
+                end,
+            };
+        }
+        return value;
+    }
+    parseJsxName(what) {
+        const token = this.peek();
+        if (token.kind !== 'JsxName')
+            this.fail(`expected ${what}, found ${describe(token)}`);
+        this.next();
+        return { kind: 'Identifier', name: token.text, start: token.start, end: token.end };
+    }
+    parseJsxAttribute() {
+        const start = this.peek().start;
+        if (this.accept('{')) {
+            this.expect('...', '"..." (attributes in braces are spread: {...attrs})');
+            const argument = this.nested(() => this.parseExpression());
+            this.expect('}');
+            return { kind: 'JsxSpreadAttribute', argument, ...this.span(start) };
+        }
+        const name = this.parseJsxName('attribute name');
+        let value = null;
+        if (this.accept('=')) {
+            const token = this.peek();
+            if (token.kind === 'JsxString') {
+                this.next();
+                // Attribute strings have no escapes, so the JS literal is built from the value.
+                value = {
+                    kind: 'StringLiteral',
+                    value: token.value,
+                    raw: JSON.stringify(token.value),
+                    start: token.start,
+                    end: token.end,
+                };
+            }
+            else if (token.kind === '{') {
+                this.next();
+                value = /^on[A-Z]/.test(name.name)
+                    ? this.parseEventHandler()
+                    : this.nested(() => this.parseExpression());
+                this.expect('}');
+            }
+            else {
+                this.fail(`expected "..." or {...} after "${name.name}=", found ${describe(token)}`);
+            }
+        }
+        return { kind: 'JsxAttribute', name, value, ...this.span(start) };
+    }
+    /**
+     * The value of an `on*` attribute: a function is the handler itself; anything else is a list of
+     * statements to run on the event, e.g. `{count++}` or `{event.preventDefault(); send()}`.
+     */
+    parseEventHandler() {
+        const start = this.peek().start;
+        const body = [];
+        this.withContext({ noObjectLiteral: false, inFunction: true, inLoop: false, inBreakable: false }, () => {
+            do {
+                if (this.check('}'))
+                    break;
+                body.push(this.parseSimpleStatement());
+            } while (this.accept(';'));
+        });
+        const [only] = body;
+        if (body.length === 1 && only?.kind === 'ExpressionStatement') {
+            if (isHandlerReference(only.expression))
+                return only.expression;
+        }
+        for (const statement of body) {
+            if (statement.kind !== 'ExpressionStatement')
+                continue;
+            const { expression } = statement;
+            if (expression.kind !== 'CallExpression' && expression.kind !== 'NewExpression') {
+                this.error('this expression does nothing: only function calls can be used as statements', expression.start, expression.end);
+            }
+        }
+        return { kind: 'EventHandler', body, ...this.span(start) };
+    }
+    /**
+     * `{expression}` or `{if ...}` / `{for ...}` / `{switch ...}` among element children; `null` for
+     * `{}` or `{/* comment *\/}`.
+     */
+    parseJsxExpressionContainer() {
+        const start = this.expect('{').start;
+        if (this.accept('}'))
+            return null;
+        if (this.check('if') || this.check('for') || this.check('switch')) {
+            // `{for todo in todos { <li>{todo.title}</li> }}`: the blocks hold markup.
+            const statement = this.withContext({ inMarkup: true, noObjectLiteral: false }, () => this.parseOrdinaryStatement());
+            this.accept(';');
+            this.expect('}');
+            return { kind: 'JsxStatementContainer', statement, ...this.span(start) };
+        }
+        const expression = this.nested(() => this.parseExpression());
+        this.expect('}');
+        return { kind: 'JsxExpressionContainer', expression, ...this.span(start) };
+    }
+    parseStringLiteral(what = 'string') {
+        const token = this.peek();
+        if (token.kind !== 'String')
+            this.fail(`expected ${what}, found ${describe(token)}`);
+        this.next();
+        return {
+            kind: 'StringLiteral',
+            value: token.value,
+            raw: token.text,
+            start: token.start,
+            end: token.end,
+        };
+    }
+}

package/dist/parser/parser.d.ts

@@ -0,0 +1,14 @@
+import type * as ast from '../ast.ts';
+import type { Diagnostic } from '../diagnostics.ts';
+export interface ParseResult {
+    program: ast.Program;
+    /** Lexer and parser errors, sorted by position. */
+    diagnostics: Diagnostic[];
+}
+/**
+ * Parses a module. Markup and components are read unless `markup` is false: the entries of the
+ * compiler (src/config.ts) turn them off unless the package turns them on.
+ */
+export declare function parse(text: string, options?: {
+    markup?: boolean;
+}): ParseResult;

package/dist/parser/parser.js

@@ -0,0 +1,22 @@
+import { tokenize } from "../lexer/lexer.js";
+import { MarkupParser } from "./markup.js";
+// The parser of a module; its layers are listed in base.ts.
+class Parser extends MarkupParser {
+    parseProgram() {
+        const body = this.parseStatements(() => false);
+        return { kind: 'Program', body, start: 0, end: this.peek().end };
+    }
+}
+/**
+ * Parses a module. Markup and components are read unless `markup` is false: the entries of the
+ * compiler (src/config.ts) turn them off unless the package turns them on.
+ */
+export function parse(text, options = {}) {
+    const { tokens, diagnostics } = tokenize(text);
+    const parser = new Parser(tokens, options.markup ?? true);
+    const program = parser.parseProgram();
+    return {
+        program,
+        diagnostics: [...diagnostics, ...parser.diagnostics].sort((a, b) => a.start - b.start),
+    };
+}

package/dist/parser/simple-statements.d.ts

@@ -0,0 +1,22 @@
+import type * as ast from '../ast.ts';
+import { ParserBase } from './base.ts';
+export declare abstract class SimpleStatementParser extends ParserBase {
+    /** `await`, `<-ch` and `ch <- v` wait: only in async functions and at the top level. */
+    protected requireAsync(what: string, start: number, end: number): void;
+    /** `x := 1` is a common habit from Go. */
+    protected rejectColonEquals(): void;
+    /** Statements allowed in `for` headers: declarations, assignments, `i++` and expressions. */
+    protected parseSimpleStatement(): ast.SimpleStatement;
+    protected checkAssignable(target: ast.Expression): void;
+    /**
+     * `a, b = 1, 2, 3`: the counts must match, unless a single call returns all the values, or
+     * `await` of a call or of `go` gives them. `v, ok = <-ch` tells whether the channel is closed.
+     */
+    protected checkArity(targets: number, values: ast.Expression[], start: number): void;
+    /** `delete scores[name]`: removes a field, so the target is one. */
+    private parseDelete;
+    protected parseExpressionList(): ast.Expression[];
+    /** `ref input` is one name, and the markup gives its element. */
+    private checkRef;
+    protected parseVariableDeclaration(start: number, exported: boolean): ast.VariableDeclaration;
+}

package/dist/parser/simple-statements.js

@@ -0,0 +1,156 @@
+import { ParserBase } from "./base.js";
+import { isAssignmentOperator, describe, plural } from "./syntax.js";
+// Simple statements, which `for` headers allow too: declarations of variables, assignments, `i++`
+// and calls.
+export class SimpleStatementParser extends ParserBase {
+    /** `await`, `<-ch` and `ch <- v` wait: only in async functions and at the top level. */
+    requireAsync(what, start, end) {
+        if (this.context.inAsync)
+            return;
+        this.error(this.context.inDefer
+            ? `"${what}" is not allowed inside "defer": deferred code runs when the function ends`
+            : `"${what}" is allowed only in async functions and at the top level of a module; mark the function, e.g. "async func load() { ... }"`, start, end);
+    }
+    /** `x := 1` is a common habit from Go. */
+    rejectColonEquals() {
+        const colon = this.peek();
+        const equals = this.peek(1);
+        if (colon.kind === ':' && equals.kind === '=' && equals.start === colon.end) {
+            this.fail('":=" is not supported: declare variables with "let" or "const"');
+        }
+    }
+    /** Statements allowed in `for` headers: declarations, assignments, `i++` and expressions. */
+    parseSimpleStatement() {
+        const start = this.peek().start;
+        // `delete` is a keyword only at the start of a statement, followed by what it removes.
+        if (this.checkWord('delete') && ['Identifier', 'this'].includes(this.peek(1).kind)) {
+            return this.parseDelete();
+        }
+        if (this.check('let') || this.check('const'))
+            return this.parseVariableDeclaration(start, false);
+        const first = this.parseExpression();
+        this.rejectColonEquals();
+        if (this.check(',') || isAssignmentOperator(this.peek().kind)) {
+            const targets = [first];
+            while (this.accept(','))
+                targets.push(this.parseExpression());
+            this.rejectColonEquals();
+            const operator = this.peek().kind;
+            if (!isAssignmentOperator(operator)) {
+                return this.fail(`expected "=", found ${describe(this.peek())}`);
+            }
+            this.next();
+            if (operator !== '=' && targets.length > 1) {
+                this.error(`"${operator}" works with a single variable`, start, this.span(start).end);
+            }
+            for (const target of targets)
+                this.checkAssignable(target);
+            const values = this.parseExpressionList();
+            this.checkArity(targets.length, values, start);
+            return { kind: 'AssignmentStatement', operator, targets, values, ...this.span(start) };
+        }
+        // `ch <- value`: the value goes into the channel.
+        if (this.check('<-')) {
+            const arrow = this.next();
+            this.requireAsync('<-', arrow.start, arrow.end);
+            const value = this.parseExpression();
+            return { kind: 'SendStatement', channel: first, value, ...this.span(start) };
+        }
+        if (this.check('++') || this.check('--')) {
+            const operator = this.next().kind === '++' ? '++' : '--';
+            this.checkAssignable(first);
+            return { kind: 'IncDecStatement', operator, target: first, ...this.span(start) };
+        }
+        return { kind: 'ExpressionStatement', expression: first, ...this.span(start) };
+    }
+    checkAssignable(target) {
+        // Members of decorators are read-only outside them: the checker explains it.
+        const assignable = target.kind === 'Identifier' ||
+            target.kind === 'DecoratorGet' ||
+            target.kind === 'DecoratorMember' ||
+            ((target.kind === 'MemberExpression' || target.kind === 'IndexExpression') &&
+                !target.optional);
+        if (!assignable)
+            this.error('cannot assign to this expression', target.start, target.end);
+    }
+    /**
+     * `a, b = 1, 2, 3`: the counts must match, unless a single call returns all the values, or
+     * `await` of a call or of `go` gives them. `v, ok = <-ch` tells whether the channel is closed.
+     */
+    checkArity(targets, values, start) {
+        if (values.length === 0 || values.length === targets)
+            return;
+        const [value] = values;
+        if (targets === 2 && value?.kind === 'UnaryExpression' && value.operator === '<-')
+            return;
+        const awaited = value?.kind === 'UnaryExpression' && value.operator === 'await' ? value.argument : value;
+        const call = awaited?.kind === 'GoExpression' ? awaited.call : awaited;
+        if (values.length === 1 && call?.kind === 'CallExpression')
+            return;
+        this.error(`assignment mismatch: ${plural(targets, 'variable')} but ${plural(values.length, 'value')}`, start, this.span(start).end);
+    }
+    /** `delete scores[name]`: removes a field, so the target is one. */
+    parseDelete() {
+        const { start } = this.next();
+        const target = this.parseExpression();
+        const field = (target.kind === 'MemberExpression' || target.kind === 'IndexExpression') && !target.optional;
+        if (!field) {
+            this.error('delete removes a field: delete obj.key or delete obj[key]', start, target.end);
+        }
+        return { kind: 'DeleteStatement', target, ...this.span(start) };
+    }
+    parseExpressionList() {
+        const expressions = [this.parseExpression()];
+        while (this.accept(','))
+            expressions.push(this.parseExpression());
+        return expressions;
+    }
+    /** `ref input` is one name, and the markup gives its element. */
+    checkRef(names, valued, start, end) {
+        const name = names[0].name;
+        if (valued) {
+            this.error(`ref "${name}" gets its element from the markup, not from a value: write ref ${name} and <div ref={${name}}>`, start, end);
+        }
+        else if (names.length > 1) {
+            this.error(`ref declares one name, e.g. ref ${name}`, start, end);
+        }
+    }
+    parseVariableDeclaration(start, exported) {
+        const token = this.next();
+        const keyword = token.kind === 'const'
+            ? 'const'
+            : token.text === 'state' || token.text === 'derived' || token.text === 'ref'
+                ? token.text
+                : 'let';
+        const names = [this.parseIdentifier('variable name')];
+        while (this.accept(','))
+            names.push(this.parseIdentifier('variable name'));
+        const type = this.canStartType() ? this.parseType() : null;
+        const values = this.accept('=') ? this.parseExpressionList() : [];
+        const { end } = this.span(start);
+        if (keyword === 'ref') {
+            this.checkRef(names, values.length > 0, start, end);
+        }
+        else if (keyword === 'derived' && (names.length !== 1 || values.length !== 1)) {
+            this.error('derived is one name and the expression it is computed from, e.g. derived double = count * 2', start, end);
+        }
+        else if (values.length === 0 && type === null) {
+            this.error(`"${names[0].name}" needs a type or a value`, start, end);
+        }
+        else if (values.length === 0 && keyword === 'const') {
+            this.error('constants need a value', start, end);
+        }
+        this.checkArity(names.length, values, start);
+        return {
+            kind: 'VariableDeclaration',
+            exported,
+            isPublic: false,
+            keyword,
+            names,
+            type,
+            values,
+            start,
+            end,
+        };
+    }
+}

package/dist/parser/statements.d.ts

@@ -0,0 +1,37 @@
+import type * as ast from '../ast.ts';
+import { SimpleStatementParser } from './simple-statements.ts';
+export declare abstract class StatementParser extends SimpleStatementParser {
+    protected parseStatements(isEnd: () => boolean): ast.Statement[];
+    protected parseStatement(): ast.Statement;
+    protected parseOrdinaryStatement(): ast.Statement;
+    /** Parses a declaration if the current token starts one, otherwise returns `undefined`. */
+    protected parseDeclaration(start: number, exported: boolean): ast.Statement | undefined;
+    /** A statement ends with a newline or `;`, or right before the `}` that closes its block. */
+    protected endStatement(): void;
+    /**
+     * `state count = 0` or `derived double = count * 2`: `state` and `derived` are keywords only at
+     * the start of a statement in a component.
+     */
+    protected isStateDeclaration(): boolean;
+    /** `ref input`: like `state`, a keyword only at the start of a statement in a component. */
+    protected isRefDeclaration(): boolean;
+    /** `style {`: the lexer reads the block as CSS where it starts a statement. */
+    protected isStyleBlock(): boolean;
+    /** `style { ... }`: CSS text and, in the values of declarations, `{expression}`. */
+    protected parseStyle(): ast.StyleStatement;
+    /** `effect {`: like `state`, a keyword only at the start of a statement in a component. */
+    protected isEffectDeclaration(): boolean;
+    /** `mount() {`: like `state`, a keyword only at the start of a statement in a component. */
+    protected isMountDeclaration(): boolean;
+    /** `mount() { ... }`; its body is a function that runs later, so `return` is its own. */
+    protected parseMount(): ast.MountStatement;
+    /** `effect { ... }`: its body runs again later, so `return` and `defer` are its own. */
+    protected parseEffect(): ast.EffectStatement;
+    protected parseBlock(): ast.BlockStatement;
+    protected parseFunctionBody(async?: boolean): ast.BlockStatement;
+    /** An if/for/switch header, where `{` starts the block rather than an object literal. */
+    protected parseHeaderExpression(): ast.Expression;
+    protected parseReturn(): ast.ReturnStatement;
+    /** `}` + newline + `else`: the newline ends the `if`, so explain the error instead of failing. */
+    protected checkSameLine(keyword: 'else' | 'catch' | 'finally'): void;
+}