rooklang 0.0.0-stage → 0.3.1

package/dist/parser/declarations.js

@@ -0,0 +1,238 @@
+import { ControlFlowParser } from "./control-flow.js";
+import { describe, FUNCTION_BODY } from "./syntax.js";
+// Imports and exports, functions and components with their parameters and results.
+export class DeclarationParser extends ControlFlowParser {
+    parseImport() {
+        const start = this.next().start;
+        if (!this.context.topLevel) {
+            this.error('imports are only allowed at the top level of a module', start, this.span(start).end);
+        }
+        let defaultImport = null;
+        let namespaceImport = null;
+        let namedImports = [];
+        if (!this.check('String')) {
+            const hasDefault = this.check('Identifier');
+            if (hasDefault)
+                defaultImport = this.parseIdentifier('import name');
+            if (!hasDefault || this.accept(',')) {
+                if (this.accept('*')) {
+                    this.expectWord('as');
+                    namespaceImport = this.parseIdentifier('namespace name');
+                }
+                else {
+                    this.expect('{', '"{", "*" or a name');
+                    namedImports = this.parseList('}', () => this.parseImportSpecifier());
+                }
+            }
+            this.expectWord('from');
+        }
+        const source = this.parseStringLiteral('module path');
+        const declaration = {
+            kind: 'ImportDeclaration',
+            defaultImport,
+            namespaceImport,
+            namedImports,
+            source,
+            ...this.span(start),
+        };
+        this.endStatement();
+        return declaration;
+    }
+    parseImportSpecifier() {
+        const token = this.peek();
+        const imported = this.parsePropertyName('import name');
+        let local = imported;
+        if (this.acceptWord('as')) {
+            local = this.parseIdentifier('import name');
+        }
+        else if (token.kind !== 'Identifier') {
+            this.error(`"${token.text}" is a keyword: rename it with "as"`, token.start, token.end);
+        }
+        return { kind: 'ImportSpecifier', imported, local, ...this.span(token.start) };
+    }
+    parseExport() {
+        const start = this.next().start;
+        if (!this.context.topLevel) {
+            this.error('"export" is only allowed at the top level of a module', start, this.span(start).end);
+        }
+        return (this.parseDeclaration(start, true) ??
+            this.fail(`expected a declaration after "export", found ${describe(this.peek())}`));
+    }
+    parseFuncDeclaration(start, exported) {
+        const async = this.accept('async');
+        this.expect('func');
+        const name = this.parseIdentifier('function name');
+        const typeParams = this.parseTypeParams();
+        const params = this.parseParams(false);
+        const results = this.parseResults();
+        const body = this.parseFunctionBody(async);
+        return {
+            kind: 'FuncDeclaration',
+            exported,
+            isPublic: false,
+            ...(async ? { async } : {}),
+            name,
+            typeParams,
+            params,
+            results,
+            body,
+            ...this.span(start),
+        };
+    }
+    /**
+     * `<T any, U Shape>` after a name; `<K, V any>` gives both the constraint, as in Go.
+     */
+    parseTypeParams() {
+        if (!this.check('<') || this.peek(1).kind !== 'Identifier')
+            return [];
+        this.next();
+        const params = [];
+        let pending = [];
+        const finish = (constraint) => {
+            for (const name of pending) {
+                params.push({
+                    kind: 'TypeParameter',
+                    name,
+                    constraint,
+                    start: name.start,
+                    end: constraint?.end ?? name.end,
+                });
+            }
+            pending = [];
+        };
+        do {
+            pending.push(this.parseIdentifier('type parameter name'));
+            if (!this.check(',') && !this.peek().kind.startsWith('>'))
+                finish(this.parseType());
+        } while (this.accept(','));
+        finish(null);
+        this.expectTypeClose('">" after the type parameters');
+        return params;
+    }
+    /**
+     * `(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.
+     */
+    parseParams(typesOptional, allowDefaults = false, allowRest = false) {
+        this.expect('(');
+        const params = [];
+        let untyped = 0;
+        while (!this.check(')')) {
+            if (this.check('...')) {
+                params.push(this.parseRestParam(allowRest));
+                break;
+            }
+            const name = this.parseIdentifier('parameter name');
+            const type = this.canStartType() ? this.parseType() : null;
+            const defaultValue = allowDefaults && this.accept('=') ? this.parseExpression() : null;
+            params.push({ kind: 'Parameter', name, type, defaultValue, ...this.span(name.start) });
+            if (type === null) {
+                untyped++;
+            }
+            else {
+                for (const param of params.slice(params.length - 1 - untyped))
+                    param.type = type;
+                untyped = 0;
+            }
+            if (!this.accept(','))
+                break;
+        }
+        this.expect(')');
+        if (untyped > 0 && !typesOptional) {
+            const param = params[params.length - untyped];
+            this.error(`missing type for parameter "${param.name.name}"`, param.start, param.end);
+        }
+        return params;
+    }
+    /** `...attrs`: the attributes that a component passes on to one of its elements. */
+    parseRestParam(allowed) {
+        const start = this.next().start;
+        const name = this.parseIdentifier('parameter name');
+        if (!allowed) {
+            this.error(`...${name.name} is only for components: it takes the attributes of an element`, start, name.end);
+        }
+        if (this.canStartType() || this.check('=')) {
+            const at = this.peek().start;
+            // After the error, the type and the default are read, so they are not reported again.
+            if (this.canStartType())
+                this.parseType();
+            if (this.accept('='))
+                this.parseExpression();
+            this.error(`...${name.name} has no type and no default: it gets the type of the element it is spread on`, at, this.span(at).end);
+        }
+        // After the error, the rest of the list is skipped up to the `)`.
+        if (this.check(',')) {
+            this.error(`...${name.name} is the last property of a component`, start, name.end);
+            while (!this.check(')') && !this.check('EOF'))
+                this.next();
+        }
+        return {
+            kind: 'Parameter',
+            name,
+            type: null,
+            defaultValue: null,
+            rest: true,
+            ...this.span(start),
+        };
+    }
+    /** Result types after a parameter list: nothing, `T`, or `(T1, T2)`. */
+    parseResults() {
+        if (this.accept('('))
+            return this.parseList(')', () => this.parseType());
+        // `{` after the parameters starts the body, so an object result type needs parentheses.
+        if (this.canStartType() && !this.check('{'))
+            return [this.parseType()];
+        return [];
+    }
+    /** `comp Name(properties) { ...; return <markup> }`, maybe after decorators. */
+    parseComponent(start, exported, htmlTag = null, decorators = []) {
+        this.requireMarkup('components are');
+        const keyword = this.expect('comp');
+        if (!this.context.topLevel) {
+            this.error('components can only be declared at the top level of a module', keyword.start, keyword.end);
+        }
+        const name = this.parseIdentifier('component name');
+        // A web component is used by its tag, so its name may start with a lowercase letter.
+        if (!htmlTag && !/^[A-Z]/.test(name.name)) {
+            this.error(`component names start with a capital letter, as in <${name.name.charAt(0).toUpperCase()}${name.name.slice(1)} />`, name.start, name.end);
+        }
+        const params = this.parseParams(false, true, true);
+        const body = this.withContext({ ...FUNCTION_BODY, inComponent: true }, () => this.parseComponentBody());
+        return {
+            kind: 'ComponentDeclaration',
+            exported,
+            name,
+            params,
+            body,
+            htmlTag,
+            decorators,
+            ...this.span(start),
+        };
+    }
+    /** Like a function body, but its own statements may also declare `state`, `ref` and `mount()`. */
+    parseComponentBody() {
+        const start = this.expect('{').start;
+        const body = [];
+        this.parseSeparated(() => this.check('}'), () => body.push(this.parseComponentStatement()));
+        this.expect('}');
+        return { kind: 'BlockStatement', body, ...this.span(start) };
+    }
+    /** A statement at the top level of a component or a decorator. */
+    parseComponentStatement() {
+        if (this.isStyleBlock()) {
+            const style = this.parseStyle();
+            this.endStatement();
+            return style;
+        }
+        if (this.isMountDeclaration() || this.isEffectDeclaration()) {
+            const statement = this.isMountDeclaration() ? this.parseMount() : this.parseEffect();
+            this.endStatement();
+            return statement;
+        }
+        if (!this.isStateDeclaration() && !this.isRefDeclaration())
+            return this.parseStatement();
+        const declaration = this.parseVariableDeclaration(this.peek().start, false);
+        this.endStatement();
+        return declaration;
+    }
+}

package/dist/parser/decorators.d.ts

@@ -0,0 +1,30 @@
+import type * as ast from '../ast.ts';
+import { DeclarationParser } from './declarations.ts';
+export declare abstract class DecoratorParser extends DeclarationParser {
+    /** `dec visible(margin string = "0px") { ... }`: `dec` is a keyword only here. */
+    protected isDecoratorDeclaration(): boolean;
+    protected parseDecoratorDeclaration(start: number, exported: boolean): ast.DecoratorDeclaration;
+    /** `needs cart, auth` after the parameters: `needs` is a keyword only here. */
+    protected parseNeeds(): ast.Identifier[];
+    /** Like the body of a component, but `state`, `const` and `func` may be `public`. */
+    protected parseDecoratorBody(): ast.BlockStatement;
+    /** `public` followed by a declaration; `public = 1` assigns a variable named `public`. */
+    protected isPublicModifier(): boolean;
+    protected parsePublicMember(): ast.VariableDeclaration | ast.FuncDeclaration;
+    /**
+     * The decorators before `comp`: `@html-tag` first, then the others in the order they apply.
+     * Each is on its own line or followed by the next one.
+     */
+    protected parseDecorated(start: number, exported: boolean): ast.ComponentDeclaration;
+    protected isHtmlTag(): boolean;
+    /** `@html-tag` or `@html-tag("app-page")`. */
+    protected parseHtmlTag(): ast.HtmlTag;
+    /** `@visible("300px")` or `@visible`: the arguments are positional, as in a call. */
+    protected parseDecoratorUse(): ast.DecoratorUse;
+    /** `@visible.show`: a member of a decorator; a statement may start with it. */
+    protected isDecoratorMember(): boolean;
+    protected parseDecoratorMember(): ast.DecoratorMember;
+    /** `get(@visible.shown)`: `get` is special only when its argument starts with `@`. */
+    protected isDecoratorGet(): boolean;
+    protected parseDecoratorGet(): ast.DecoratorGet;
+}

package/dist/parser/decorators.js

@@ -0,0 +1,176 @@
+import { DeclarationParser } from "./declarations.js";
+import { describe, FUNCTION_BODY } from "./syntax.js";
+// Decorators: their declarations `dec name(...) { ... }`, the decorators written before `comp`
+// (`@html-tag` and `@visible("300px")`), and the access to their members, `get(@visible.shown)`
+// and `@visible.show()`.
+export class DecoratorParser extends DeclarationParser {
+    /** `dec visible(margin string = "0px") { ... }`: `dec` is a keyword only here. */
+    isDecoratorDeclaration() {
+        return this.checkWord('dec') && this.peek(1).kind === 'Identifier';
+    }
+    parseDecoratorDeclaration(start, exported) {
+        this.requireMarkup('decorators are');
+        const keyword = this.next();
+        if (!this.context.topLevel) {
+            this.error('decorators can only be declared at the top level of a module', keyword.start, keyword.end);
+        }
+        const name = this.parseIdentifier('decorator name');
+        const params = this.parseParams(false, true);
+        const needs = this.parseNeeds();
+        const body = this.withContext({ ...FUNCTION_BODY, inComponent: true }, () => this.parseDecoratorBody());
+        return {
+            kind: 'DecoratorDeclaration',
+            exported,
+            name,
+            params,
+            needs,
+            body,
+            ...this.span(start),
+        };
+    }
+    /** `needs cart, auth` after the parameters: `needs` is a keyword only here. */
+    parseNeeds() {
+        if (!this.checkWord('needs'))
+            return [];
+        if (this.peek(1).kind !== 'Identifier') {
+            this.fail('"needs" is followed by the decorators this one uses, e.g. needs cart');
+        }
+        this.next();
+        const needs = [this.parseIdentifier('decorator name')];
+        while (this.accept(','))
+            needs.push(this.parseIdentifier('decorator name'));
+        return needs;
+    }
+    /** Like the body of a component, but `state`, `const` and `func` may be `public`. */
+    parseDecoratorBody() {
+        const start = this.expect('{').start;
+        const body = [];
+        this.parseSeparated(() => this.check('}'), () => {
+            if (this.isPublicModifier())
+                body.push(this.parsePublicMember());
+            else
+                body.push(this.parseComponentStatement());
+        });
+        this.expect('}');
+        return { kind: 'BlockStatement', body, ...this.span(start) };
+    }
+    /** `public` followed by a declaration; `public = 1` assigns a variable named `public`. */
+    isPublicModifier() {
+        const next = this.peek(1).kind;
+        return (this.checkWord('public') &&
+            (next === 'Identifier' ||
+                next === 'let' ||
+                next === 'const' ||
+                next === 'func' ||
+                next === 'async'));
+    }
+    parsePublicMember() {
+        const modifier = this.next();
+        if (this.check('func') || this.check('async')) {
+            const declaration = this.parseFuncDeclaration(modifier.start, false);
+            declaration.isPublic = true;
+            return declaration;
+        }
+        if (!this.check('const') && !this.check('let') && !this.isStateDeclaration()) {
+            this.fail(`only state, derived, const and func can be public, not ${describe(this.peek())}`);
+        }
+        const declaration = this.parseVariableDeclaration(modifier.start, false);
+        this.endStatement();
+        if (declaration.keyword === 'let') {
+            this.error('a decorator has no "public let": a value that changes and is read outside is a state, one that does not change is a const', modifier.start, declaration.end);
+        }
+        declaration.isPublic = true;
+        return declaration;
+    }
+    /**
+     * The decorators before `comp`: `@html-tag` first, then the others in the order they apply.
+     * Each is on its own line or followed by the next one.
+     */
+    parseDecorated(start, exported) {
+        this.requireMarkup('decorators are');
+        let htmlTag = null;
+        const decorators = [];
+        while (this.check('@')) {
+            if (this.isHtmlTag()) {
+                const node = this.parseHtmlTag();
+                if (htmlTag) {
+                    this.error('@html-tag is written once', node.start, node.end);
+                }
+                else if (decorators.length > 0) {
+                    this.error('@html-tag must be the first decorator: the element is built from what the others give', node.start, node.end);
+                }
+                htmlTag ??= node;
+            }
+            else {
+                decorators.push(this.parseDecoratorUse());
+            }
+            // A line break after the decorator inserted a semicolon.
+            if (this.isImplicitSemicolon())
+                this.next();
+        }
+        const isExported = this.accept('export') || exported;
+        if (!this.check('comp')) {
+            this.fail(`decorators are written before a component, as in @${decorators[0]?.name.name ?? 'html-tag'} comp MainPage() { ... }`);
+        }
+        return this.parseComponent(start, isExported, htmlTag, decorators);
+    }
+    isHtmlTag() {
+        return (this.peek(1).kind === 'Identifier' &&
+            this.peek(1).text === 'html' &&
+            this.peek(2).kind === '-' &&
+            this.peek(3).kind === 'Identifier' &&
+            this.peek(3).text === 'tag');
+    }
+    /** `@html-tag` or `@html-tag("app-page")`. */
+    parseHtmlTag() {
+        const at = this.expect('@');
+        this.next();
+        this.next();
+        this.next();
+        let name = null;
+        if (this.accept('(')) {
+            name = this.parseStringLiteral('tag name');
+            this.expect(')');
+        }
+        return { kind: 'HtmlTag', name, ...this.span(at.start) };
+    }
+    /** `@visible("300px")` or `@visible`: the arguments are positional, as in a call. */
+    parseDecoratorUse() {
+        const at = this.expect('@');
+        const name = this.parseIdentifier('decorator name');
+        const args = this.check('(') ? this.parseArguments() : [];
+        const spread = args.find((arg) => arg.kind === 'SpreadElement');
+        if (spread) {
+            this.error('arguments of a decorator cannot be spread', spread.start, spread.end);
+        }
+        return {
+            kind: 'DecoratorUse',
+            name,
+            arguments: args.filter((arg) => arg.kind !== 'SpreadElement'),
+            ...this.span(at.start),
+        };
+    }
+    /** `@visible.show`: a member of a decorator; a statement may start with it. */
+    isDecoratorMember() {
+        return this.check('@') && this.peek(1).kind === 'Identifier' && this.peek(2).kind === '.';
+    }
+    parseDecoratorMember() {
+        this.requireMarkup('decorators are');
+        const at = this.expect('@');
+        const decorator = this.parseIdentifier('decorator name');
+        this.expect('.', '"." and a member, e.g. @visible.show()');
+        const member = this.parsePropertyName('member name');
+        return { kind: 'DecoratorMember', decorator, member, ...this.span(at.start) };
+    }
+    /** `get(@visible.shown)`: `get` is special only when its argument starts with `@`. */
+    isDecoratorGet() {
+        return this.checkWord('get') && this.peek(1).kind === '(' && this.peek(2).kind === '@';
+    }
+    parseDecoratorGet() {
+        const start = this.next().start;
+        this.expect('(');
+        const target = this.parseDecoratorMember();
+        this.expect(')', '")": get takes one member of a decorator, e.g. get(@visible.shown)');
+        return { kind: 'DecoratorGet', target, ...this.span(start) };
+    }
+}

package/dist/parser/expressions.d.ts

@@ -0,0 +1,15 @@
+import type * as ast from '../ast.ts';
+import { TypeParser } from './types.ts';
+export declare abstract class ExpressionParser extends TypeParser {
+    protected parseExpression(): ast.Expression;
+    /** Precedence climbing: parses operators that bind at least as tight as `minPrecedence`. */
+    protected parseBinary(minPrecedence: number): ast.Expression;
+    /** Rejects combinations that JS forbids without parentheses, since the output must be valid JS. */
+    protected makeBinary(operator: ast.BinaryOperator, left: ast.Expression, right: ast.Expression): ast.BinaryExpression;
+    protected parseUnary(): ast.Expression;
+    /** `make([]float64` starts a `make`: an array literal is not followed by a name. */
+    private isMake;
+    /** Member access, indexing and calls: `a.b`, `a?.b`, `a[i]`, `a?.[i]`, `f(x)`, `f?.(x)`. */
+    protected parsePostfix(expression: ast.Expression): ast.Expression;
+    protected parsePrimary(): ast.Expression;
+}