rooklang 0.0.0-stage → 0.3.1

package/dist/parser/classes.js

@@ -0,0 +1,164 @@
+import { isKeyword } from "../lexer/token.js";
+import { DecoratorParser } from "./decorators.js";
+import { MODIFIERS } from "./syntax.js";
+// Classes and their members, interfaces and `type` aliases.
+export class ClassParser extends DecoratorParser {
+    parseClass(start, exported) {
+        this.expect('class');
+        const name = this.parseIdentifier('class name');
+        const typeParams = this.parseTypeParams();
+        let superClass = null;
+        if (this.accept('extends')) {
+            superClass = this.withContext({ noObjectLiteral: true }, () => this.parsePostfix(this.parsePrimary()));
+        }
+        const interfaces = [];
+        if (this.acceptWord('implements')) {
+            do {
+                const interfaceName = this.parseIdentifier('interface name');
+                interfaces.push({
+                    kind: 'TypeReference',
+                    name: interfaceName,
+                    typeArgs: this.parseTypeArgs(),
+                    ...this.span(interfaceName.start),
+                });
+            } while (this.accept(','));
+        }
+        this.expect('{');
+        const members = [];
+        this.withContext({ topLevel: false, inAsync: false }, () => {
+            this.parseSeparated(() => this.check('}'), () => {
+                members.push(...this.parseClassMember());
+            });
+        });
+        this.expect('}');
+        return {
+            kind: 'ClassDeclaration',
+            exported,
+            name,
+            typeParams,
+            superClass,
+            implements: interfaces,
+            members,
+            ...this.span(start),
+        };
+    }
+    parseClassMember() {
+        const start = this.peek().start;
+        let visibility = null;
+        let isStatic = false;
+        // Modifiers are contextual: `static` is a modifier only when a member name follows it.
+        while (this.peek().kind === 'Identifier' && MODIFIERS.has(this.peek().text)) {
+            const following = this.peek(1);
+            if (following.kind !== 'Identifier' && !isKeyword(following.kind))
+                break;
+            const modifier = this.next();
+            if (modifier.text === 'static') {
+                if (isStatic)
+                    this.error('duplicate "static" modifier', modifier.start, modifier.end);
+                isStatic = true;
+            }
+            else {
+                if (visibility)
+                    this.error('duplicate visibility modifier', modifier.start, modifier.end);
+                visibility = modifier.text;
+            }
+        }
+        // `async load()`; a method named `async` is `async()`.
+        const asyncToken = this.check('async') && this.peek(1).kind !== '(' ? this.next() : null;
+        const async = asyncToken !== null;
+        if (this.checkWord('constructor') && this.peek(1).kind === '(') {
+            this.next();
+            if (isStatic)
+                this.error('constructors cannot be static', start, this.span(start).end);
+            if (async)
+                this.error('a constructor cannot be async', start, this.span(start).end);
+            const params = this.parseParams(false);
+            const resultsStart = this.peek().start;
+            if (this.parseResults().length > 0) {
+                this.error('constructors cannot have result types', resultsStart, this.span(start).end);
+            }
+            const body = this.parseFunctionBody();
+            return [
+                {
+                    kind: 'ConstructorDeclaration',
+                    visibility: visibility ?? 'public',
+                    params,
+                    body,
+                    ...this.span(start),
+                },
+            ];
+        }
+        const name = this.parsePropertyName('member name');
+        if (this.check('(')) {
+            const params = this.parseParams(false);
+            const results = this.parseResults();
+            const body = this.parseFunctionBody(async);
+            return [
+                {
+                    kind: 'MethodDeclaration',
+                    visibility: visibility ?? 'public',
+                    isStatic,
+                    ...(async ? { async } : {}),
+                    name,
+                    params,
+                    results,
+                    body,
+                    ...this.span(start),
+                },
+            ];
+        }
+        if (asyncToken)
+            this.error('only methods can be async', asyncToken.start, asyncToken.end);
+        // Fields: `name string`, `count = 0`, `x, y number`.
+        const names = [name];
+        while (this.accept(','))
+            names.push(this.parsePropertyName('field name'));
+        const type = this.canStartType() ? this.parseType() : null;
+        const value = this.accept('=') ? this.parseExpression() : null;
+        const span = this.span(start);
+        if (type === null && value === null) {
+            this.error(`field "${name.name}" needs a type or a value`, span.start, span.end);
+        }
+        else if (names.length > 1 && value !== null) {
+            this.error('a value can only be given to a single field', span.start, span.end);
+        }
+        this.endStatement();
+        return names.map((fieldName) => ({
+            kind: 'FieldDeclaration',
+            visibility: visibility ?? 'public',
+            isStatic,
+            name: fieldName,
+            type,
+            value,
+            ...span,
+        }));
+    }
+    parseInterface(start, exported) {
+        this.expect('interface');
+        const name = this.parseIdentifier('interface name');
+        const typeParams = this.parseTypeParams();
+        const members = this.parseTypeMembers();
+        return {
+            kind: 'InterfaceDeclaration',
+            exported,
+            name,
+            typeParams,
+            members,
+            ...this.span(start),
+        };
+    }
+    parseTypeAlias(start, exported) {
+        this.expect('type');
+        const name = this.parseIdentifier('type name');
+        const typeParams = this.parseTypeParams();
+        const type = this.parseType();
+        return {
+            kind: 'TypeAliasDeclaration',
+            exported,
+            name,
+            typeParams,
+            type,
+            ...this.span(start),
+        };
+    }
+}

package/dist/parser/control-flow.d.ts

@@ -0,0 +1,29 @@
+import type * as ast from '../ast.ts';
+import { StatementParser } from './statements.ts';
+export declare abstract class ControlFlowParser extends StatementParser {
+    protected parseIf(): ast.IfStatement;
+    protected parseFor(): ast.ForStatement | ast.ForInStatement;
+    /** The rest of a `for` statement that starts at `start`, after the keyword. */
+    private parseForAfter;
+    /** `for x in` or `for i, x in`. */
+    protected isForInHeader(): boolean;
+    /** `{` (infinite loop), `cond {`, or `init; cond; update {`. */
+    protected parseForHeader(): [
+        ast.SimpleStatement | null,
+        ast.Expression | null,
+        ast.SimpleStatement | null
+    ];
+    protected parseForIn(start: number, go?: boolean): ast.ForInStatement;
+    /** `go for i, v in items { }`: the parts of the array run as goroutines, and the loop waits. */
+    protected parseGoFor(): ast.ForStatement | ast.ForInStatement;
+    protected parseLoopBody(): ast.BlockStatement;
+    protected parseSwitch(): ast.SwitchStatement;
+    /** `select { case v = <-ch: ... case ch <- v: ... default: ... }`; it waits, as `await` does. */
+    protected parseSelect(): ast.SelectStatement;
+    /** `v = <-ch`, `v, ok = <-ch`, `<-ch` or `ch <- v`; the names are new variables of the case. */
+    private parseSelectOperation;
+    protected parseBreakOrContinue(): ast.BreakStatement | ast.ContinueStatement;
+    protected parseThrow(): ast.ThrowStatement;
+    protected parseTry(): ast.TryStatement;
+    protected parseDefer(): ast.DeferStatement;
+}

package/dist/parser/control-flow.js

@@ -0,0 +1,232 @@
+import { StatementParser } from "./statements.js";
+// if, for, switch, break and continue, throw, try and defer.
+export class ControlFlowParser extends StatementParser {
+    parseIf() {
+        const start = this.next().start;
+        const condition = this.parseHeaderExpression();
+        const consequent = this.parseBlock();
+        let alternate = null;
+        this.checkSameLine('else');
+        if (this.accept('else')) {
+            alternate = this.check('if') ? this.parseIf() : this.parseBlock();
+        }
+        return { kind: 'IfStatement', condition, consequent, alternate, ...this.span(start) };
+    }
+    parseFor() {
+        return this.parseForAfter(this.next().start);
+    }
+    /** The rest of a `for` statement that starts at `start`, after the keyword. */
+    parseForAfter(start) {
+        if (this.isForInHeader())
+            return this.parseForIn(start);
+        const [init, condition, update] = this.withContext({ noObjectLiteral: true }, () => this.parseForHeader());
+        const body = this.parseLoopBody();
+        return { kind: 'ForStatement', init, condition, update, body, ...this.span(start) };
+    }
+    /** `for x in` or `for i, x in`. */
+    isForInHeader() {
+        if (!this.check('Identifier'))
+            return false;
+        if (this.peek(1).kind === 'in')
+            return true;
+        return (this.peek(1).kind === ',' && this.peek(2).kind === 'Identifier' && this.peek(3).kind === 'in');
+    }
+    /** `{` (infinite loop), `cond {`, or `init; cond; update {`. */
+    parseForHeader() {
+        if (this.check('{'))
+            return [null, null, null];
+        const init = this.check(';') ? null : this.parseSimpleStatement();
+        if (init?.kind === 'ExpressionStatement' && this.check('{')) {
+            return [null, init.expression, null];
+        }
+        this.expect(';', '";" or "{"');
+        const condition = this.check(';') ? null : this.parseExpression();
+        this.expect(';');
+        const update = this.check('{') ? null : this.parseSimpleStatement();
+        return [init, condition, update];
+    }
+    parseForIn(start, go = false) {
+        let key = null;
+        let value = this.parseIdentifier('loop variable');
+        if (this.accept(',')) {
+            key = value;
+            value = this.parseIdentifier('loop variable');
+        }
+        this.expect('in');
+        const iterable = this.parseHeaderExpression();
+        if (!go) {
+            const body = this.parseLoopBody();
+            return { kind: 'ForInStatement', key, value, iterable, body, ...this.span(start) };
+        }
+        // The parts run at once in workers: nothing can leave the loop but `continue`.
+        const body = this.withContext({ inLoop: true, inBreakable: false, inGoFor: true }, () => this.parseBlock());
+        return { kind: 'ForInStatement', key, value, iterable, body, go, ...this.span(start) };
+    }
+    /** `go for i, v in items { }`: the parts of the array run as goroutines, and the loop waits. */
+    parseGoFor() {
+        const start = this.next().start;
+        const keyword = this.next();
+        this.requireAsync('go for', start, keyword.end);
+        if (this.isForInHeader())
+            return this.parseForIn(start, true);
+        this.error('"go for" goes over an array: write "go for i, v in items { ... }"', start, keyword.end);
+        return this.parseForAfter(start);
+    }
+    parseLoopBody() {
+        return this.withContext({ inLoop: true, inBreakable: true }, () => this.parseBlock());
+    }
+    parseSwitch() {
+        const start = this.next().start;
+        const discriminant = this.check('{') ? null : this.parseHeaderExpression();
+        this.expect('{');
+        const cases = [];
+        let hasDefault = false;
+        while (!this.check('}') && !this.check('EOF')) {
+            if (this.accept(';'))
+                continue;
+            const caseStart = this.peek().start;
+            let tests = [];
+            if (this.accept('default')) {
+                if (hasDefault) {
+                    this.error('multiple "default" cases in switch', caseStart, this.span(caseStart).end);
+                }
+                hasDefault = true;
+            }
+            else {
+                this.expect('case', '"case", "default" or "}"');
+                tests = this.parseExpressionList();
+            }
+            this.expect(':');
+            const body = this.withContext({ topLevel: false, inBreakable: true }, () => this.parseStatements(() => this.check('case') || this.check('default') || this.check('}')));
+            cases.push({ kind: 'SwitchCase', tests, body, ...this.span(caseStart) });
+        }
+        this.expect('}');
+        return { kind: 'SwitchStatement', discriminant, cases, ...this.span(start) };
+    }
+    /** `select { case v = <-ch: ... case ch <- v: ... default: ... }`; it waits, as `await` does. */
+    parseSelect() {
+        const keyword = this.next();
+        this.requireAsync('select', keyword.start, keyword.end);
+        this.expect('{');
+        const cases = [];
+        let hasDefault = false;
+        while (!this.check('}') && !this.check('EOF')) {
+            if (this.accept(';'))
+                continue;
+            const caseStart = this.peek().start;
+            let names = [];
+            let operation = null;
+            if (this.accept('default')) {
+                if (hasDefault) {
+                    this.error('multiple "default" cases in select', caseStart, this.span(caseStart).end);
+                }
+                hasDefault = true;
+            }
+            else {
+                this.expect('case', '"case", "default" or "}"');
+                [names, operation] = this.parseSelectOperation();
+            }
+            this.expect(':');
+            const body = this.withContext({ topLevel: false, inBreakable: true }, () => this.parseStatements(() => this.check('case') || this.check('default') || this.check('}')));
+            cases.push({ kind: 'SelectCase', names, operation, body, ...this.span(caseStart) });
+        }
+        this.expect('}');
+        return { kind: 'SelectStatement', cases, ...this.span(keyword.start) };
+    }
+    /** `v = <-ch`, `v, ok = <-ch`, `<-ch` or `ch <- v`; the names are new variables of the case. */
+    parseSelectOperation() {
+        const start = this.peek().start;
+        const names = [];
+        if (this.check('Identifier') && (this.peek(1).kind === '=' || this.peek(1).kind === ',')) {
+            do
+                names.push(this.parseIdentifier());
+            while (this.accept(','));
+            this.expect('=');
+            if (names.length > 2) {
+                this.error('a receive gives at most two values: "case v, ok = <-ch:"', start, this.span(start).end);
+            }
+        }
+        const first = this.parseExpression();
+        if (names.length === 0 && this.check('<-')) {
+            this.next();
+            const value = this.parseExpression();
+            return [names, { kind: 'SendStatement', channel: first, value, ...this.span(start) }];
+        }
+        if (first.kind !== 'UnaryExpression' || first.operator !== '<-') {
+            return this.failAt('a case of select receives, "case v = <-ch:", or sends, "case ch <- v:"', first.start, first.end);
+        }
+        return [names, first];
+    }
+    parseBreakOrContinue() {
+        const token = this.next();
+        let statement;
+        if (token.kind === 'break') {
+            if (!this.context.inBreakable) {
+                this.error(this.context.inGoFor
+                    ? '"break" cannot stop "go for": its parts run at once in workers; skip an element with "continue"'
+                    : '"break" outside of a loop or switch', token.start, token.end);
+            }
+            statement = { kind: 'BreakStatement', start: token.start, end: token.end };
+        }
+        else {
+            if (!this.context.inLoop)
+                this.error('"continue" outside of a loop', token.start, token.end);
+            statement = { kind: 'ContinueStatement', start: token.start, end: token.end };
+        }
+        this.endStatement();
+        return statement;
+    }
+    parseThrow() {
+        const start = this.next().start;
+        const argument = this.parseExpression();
+        const statement = { kind: 'ThrowStatement', argument, ...this.span(start) };
+        this.endStatement();
+        return statement;
+    }
+    parseTry() {
+        const start = this.next().start;
+        const block = this.parseBlock();
+        let handler = null;
+        let finalizer = null;
+        this.checkSameLine('catch');
+        if (this.check('catch')) {
+            const catchStart = this.next().start;
+            if (this.check('('))
+                this.fail('write "catch e {" without parentheses');
+            const param = this.check('Identifier') ? this.parseIdentifier() : null;
+            const body = this.parseBlock();
+            handler = { kind: 'CatchClause', param, body, ...this.span(catchStart) };
+        }
+        this.checkSameLine('finally');
+        if (this.accept('finally'))
+            finalizer = this.parseBlock();
+        if (handler === null && finalizer === null) {
+            this.error('"try" needs a "catch" or "finally" block', start, block.start);
+        }
+        return { kind: 'TryStatement', block, handler, finalizer, ...this.span(start) };
+    }
+    parseDefer() {
+        const start = this.next().start;
+        if (!this.context.inFunction) {
+            this.error('"defer" outside of a function', start, this.span(start).end);
+        }
+        else if (this.context.inGoFor) {
+            this.error('"defer" cannot be used in the body of "go for": it runs in workers, apart from the function; defer it before the loop', start, this.span(start).end);
+        }
+        if (this.check('{')) {
+            const body = this.withContext({ inDefer: true, inAsync: false, inLoop: false, inBreakable: false }, () => this.parseBlock());
+            return { kind: 'DeferStatement', body, ...this.span(start) };
+        }
+        const call = this.withContext({ inDefer: true, inAsync: false }, () => this.parseExpression());
+        if (call.kind !== 'CallExpression') {
+            this.failAt('"defer" needs a function call or a block', call.start, call.end);
+        }
+        const statement = {
+            kind: 'DeferStatement',
+            body: call,
+            ...this.span(start),
+        };
+        this.endStatement();
+        return statement;
+    }
+}

package/dist/parser/declarations.d.ts

@@ -0,0 +1,27 @@
+import type * as ast from '../ast.ts';
+import { ControlFlowParser } from './control-flow.ts';
+export declare abstract class DeclarationParser extends ControlFlowParser {
+    protected parseImport(): ast.ImportDeclaration;
+    protected parseImportSpecifier(): ast.ImportSpecifier;
+    protected parseExport(): ast.Statement;
+    protected parseFuncDeclaration(start: number, exported: boolean): ast.FuncDeclaration;
+    /**
+     * `<T any, U Shape>` after a name; `<K, V any>` gives both the constraint, as in Go.
+     */
+    protected parseTypeParams(): ast.TypeParameter[];
+    /**
+     * `(a, b number, c string)`. Names without a type take the type of the next typed name, as in
+     * Go; only arrow functions may leave types out entirely.
+     */
+    protected parseParams(typesOptional: boolean, allowDefaults?: boolean, allowRest?: boolean): ast.Parameter[];
+    /** `...attrs`: the attributes that a component passes on to one of its elements. */
+    private parseRestParam;
+    /** Result types after a parameter list: nothing, `T`, or `(T1, T2)`. */
+    protected parseResults(): ast.TypeNode[];
+    /** `comp Name(properties) { ...; return <markup> }`, maybe after decorators. */
+    protected parseComponent(start: number, exported: boolean, htmlTag?: ast.HtmlTag | null, decorators?: ast.DecoratorUse[]): ast.ComponentDeclaration;
+    /** Like a function body, but its own statements may also declare `state`, `ref` and `mount()`. */
+    protected parseComponentBody(): ast.BlockStatement;
+    /** A statement at the top level of a component or a decorator. */
+    protected parseComponentStatement(): ast.Statement;
+}