rooklang 0.3.3 → 0.4.0

package/dist/parser/declarations.js

@@ -1,7 +1,7 @@
-import { ControlFlowParser } from "./control-flow.js";
+import { ParamParser } from "./params.js";
 import { describe, FUNCTION_BODY } from "./syntax.js";
-// Imports and exports, functions and components with their parameters and results.
-export class DeclarationParser extends ControlFlowParser {
+// Imports and exports, functions and components.
+export class DeclarationParser extends ParamParser {
     parseImport() {
         const start = this.next().start;
         if (!this.context.topLevel) {
@@ -50,6 +50,16 @@ export class DeclarationParser extends ControlFlowParser {
         }
         return { kind: 'ImportSpecifier', imported, local, ...this.span(token.start) };
     }
+    /** `state items []Item = []` at the top level of a module: state its components share. */
+    parseDeclaration(start, exported) {
+        if (!this.context.topLevel || !this.checkWord('state') || this.peek(1).kind !== 'Identifier') {
+            return super.parseDeclaration(start, exported);
+        }
+        this.requireMarkup('state of a module is');
+        const declaration = this.parseVariableDeclaration(start, exported);
+        this.endStatement();
+        return declaration;
+    }
     parseExport() {
         const start = this.next().start;
         if (!this.context.topLevel) {
@@ -109,81 +119,6 @@ export class DeclarationParser extends ControlFlowParser {
         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');
@@ -209,7 +144,7 @@ export class DeclarationParser extends ControlFlowParser {
             ...this.span(start),
         };
     }
-    /** Like a function body, but its own statements may also declare `state`, `ref` and `mount()`. */
+    /** Like a function body, but its own statements may also declare `state`, `ref` and `mount`. */
     parseComponentBody() {
         const start = this.expect('{').start;
         const body = [];

package/dist/parser/decorators.d.ts

@@ -6,6 +6,10 @@ export declare abstract class DecoratorParser extends DeclarationParser {
     protected parseDecoratorDeclaration(start: number, exported: boolean): ast.DecoratorDeclaration;
     /** `needs cart, auth` after the parameters: `needs` is a keyword only here. */
     protected parseNeeds(): ast.Identifier[];
+    /** `includes visible(margin), cart` after `needs`: `includes` is a keyword only here. */
+    protected parseIncludes(): ast.DecoratorUse[];
+    /** `visible(margin)` or `cart`: like a decorator before `comp`, without the `@`. */
+    protected parseIncluded(): ast.DecoratorUse;
     /** 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`. */
@@ -24,7 +28,7 @@ export declare abstract class DecoratorParser extends DeclarationParser {
     /** `@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 `@`. */
+    /** `get(@visible.shown)`, the old way to read a member: reported, and read as the member. */
     protected isDecoratorGet(): boolean;
-    protected parseDecoratorGet(): ast.DecoratorGet;
+    protected parseDecoratorGet(): ast.DecoratorMember;
 }

package/dist/parser/decorators.js

@@ -1,8 +1,8 @@
 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()`.
+// (`@html-tag` and `@visible("300px")`), and the access to their members, `@visible.shown` and
+// `@visible.show()`.
 export class DecoratorParser extends DeclarationParser {
     /** `dec visible(margin string = "0px") { ... }`: `dec` is a keyword only here. */
     isDecoratorDeclaration() {
@@ -17,6 +17,7 @@ export class DecoratorParser extends DeclarationParser {
         const name = this.parseIdentifier('decorator name');
         const params = this.parseParams(false, true);
         const needs = this.parseNeeds();
+        const includes = this.parseIncludes();
         const body = this.withContext({ ...FUNCTION_BODY, inComponent: true }, () => this.parseDecoratorBody());
         return {
             kind: 'DecoratorDeclaration',
@@ -24,6 +25,7 @@ export class DecoratorParser extends DeclarationParser {
             name,
             params,
             needs,
+            includes,
             body,
             ...this.span(start),
         };
@@ -41,6 +43,34 @@ export class DecoratorParser extends DeclarationParser {
             needs.push(this.parseIdentifier('decorator name'));
         return needs;
     }
+    /** `includes visible(margin), cart` after `needs`: `includes` is a keyword only here. */
+    parseIncludes() {
+        if (!this.checkWord('includes'))
+            return [];
+        if (this.peek(1).kind !== 'Identifier') {
+            this.fail('"includes" is followed by the decorators this one applies, e.g. includes cart');
+        }
+        this.next();
+        const includes = [this.parseIncluded()];
+        while (this.accept(','))
+            includes.push(this.parseIncluded());
+        return includes;
+    }
+    /** `visible(margin)` or `cart`: like a decorator before `comp`, without the `@`. */
+    parseIncluded() {
+        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(name.start),
+        };
+    }
     /** Like the body of a component, but `state`, `const` and `func` may be `public`. */
     parseDecoratorBody() {
         const start = this.expect('{').start;
@@ -71,8 +101,11 @@ export class DecoratorParser extends DeclarationParser {
             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())}`);
+        if (!this.check('const') &&
+            !this.check('let') &&
+            !this.isStateDeclaration() &&
+            !this.isRefDeclaration()) {
+            this.fail(`only state, derived, const, ref and func can be public, not ${describe(this.peek())}`);
         }
         const declaration = this.parseVariableDeclaration(modifier.start, false);
         this.endStatement();
@@ -137,18 +170,7 @@ export class DecoratorParser extends DeclarationParser {
     /** `@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),
-        };
+        return { ...this.parseIncluded(), ...this.span(at.start) };
     }
     /** `@visible.show`: a member of a decorator; a statement may start with it. */
     isDecoratorMember() {
@@ -162,7 +184,7 @@ export class DecoratorParser extends DeclarationParser {
         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 `@`. */
+    /** `get(@visible.shown)`, the old way to read a member: reported, and read as the member. */
     isDecoratorGet() {
         return this.checkWord('get') && this.peek(1).kind === '(' && this.peek(2).kind === '@';
     }
@@ -170,7 +192,9 @@ export class DecoratorParser extends DeclarationParser {
         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) };
+        const { decorator, member } = target;
+        this.expect(')');
+        this.error(`read a member of a decorator without get: @${decorator.name}.${member.name}`, start, this.span(start).end);
+        return target;
     }
 }

package/dist/parser/expressions.js

@@ -1,4 +1,4 @@
-import { BINARY_PRECEDENCE, isBinaryOperator, isUnaryOperator, RESERVED, describe, } from "./syntax.js";
+import { BINARY_PRECEDENCE, isBinaryOperator, isUnaryOperator, describe } from "./syntax.js";
 import { TypeParser } from "./types.js";
 // Expressions: operators with their precedence, member access, calls and indexing.
 export class ExpressionParser extends TypeParser {
@@ -71,6 +71,12 @@ export class ExpressionParser extends TypeParser {
         if (token.kind === '++' || token.kind === '--') {
             this.fail(`"${token.kind}" must follow the variable: "i${token.kind}"`);
         }
+        // `try` takes the whole expression after it, as `try { }` takes its block.
+        if (token.kind === 'try') {
+            this.next();
+            const argument = this.parseExpression();
+            return { kind: 'TryExpression', argument, start: token.start, end: argument.end };
+        }
         if (token.kind === 'go') {
             this.next();
             if (this.check('for')) {
@@ -181,6 +187,16 @@ export class ExpressionParser extends TypeParser {
                     if (queue)
                         return queue;
                 }
+                if (this.checkWord('topic') && this.peek(1).kind === '<') {
+                    const topic = this.parseTopic();
+                    if (topic)
+                        return topic;
+                }
+                if (this.checkWord('decode') && this.peek(1).kind === '<') {
+                    const decode = this.parseDecode();
+                    if (decode)
+                        return decode;
+                }
                 this.next();
                 return { kind: 'Identifier', name: token.text, start, end };
             case 'Number':
@@ -191,6 +207,16 @@ export class ExpressionParser extends TypeParser {
                 return { kind: 'BigIntLiteral', raw: token.text, start, end };
             case 'String':
                 return this.parseStringLiteral();
+            case 'RegExp': {
+                const { value } = this.next();
+                return {
+                    kind: 'RegExpLiteral',
+                    pattern: value,
+                    flags: token.text.slice(value.length + 2),
+                    start,
+                    end,
+                };
+            }
             case 'Template':
             case 'TemplateHead':
                 return this.parseTemplate(token);
@@ -254,8 +280,6 @@ export class ExpressionParser extends TypeParser {
             case '@':
                 return this.parseDecoratorMember();
             default:
-                if (RESERVED.has(token.kind))
-                    this.fail(`"${token.text}" is reserved for future use`);
                 return this.fail(`expected expression, found ${describe(token)}`);
         }
     }

package/dist/parser/jumps.d.ts

@@ -0,0 +1,11 @@
+import type * as ast from '../ast.ts';
+import { ControlFlowParser } from './control-flow.ts';
+export declare abstract class JumpParser extends ControlFlowParser {
+    /** `outer: for`, `outer: switch` or `outer: select`: the statements that break can leave. */
+    protected parseLabeled(): ast.Statement;
+    protected parseReturn(): ast.ReturnStatement;
+    /** `}` + newline + `else`: the newline ends the `if`, so explain the error instead of failing. */
+    protected parseBreakOrContinue(): ast.BreakStatement | ast.ContinueStatement;
+    /** `break outer` leaves an enclosing statement with that label; `continue outer`, a loop. */
+    private checkLabel;
+}

package/dist/parser/jumps.js

@@ -0,0 +1,77 @@
+import { ControlFlowParser } from "./control-flow.js";
+// The statements that jump, `return`, `break` and `continue`, and the labels that `break` and
+// `continue` name: `outer: for ... { for ... { continue outer } }`.
+export class JumpParser extends ControlFlowParser {
+    /** `outer: for`, `outer: switch` or `outer: select`: the statements that break can leave. */
+    parseLabeled() {
+        const label = this.parseIdentifier('label');
+        this.expect(':');
+        const goFor = this.check('go') && this.peek(1).kind === 'for';
+        const loop = this.check('for');
+        if (goFor || (!loop && !this.check('switch') && !this.checkWord('select'))) {
+            this.error(goFor
+                ? '"go for" cannot have a label: its parts run at once in workers, which break and continue cannot leave'
+                : 'a label goes before for, switch or select: only they can be left with break, e.g. outer: for ...', label.start, label.end);
+            return this.parseStatement();
+        }
+        if (this.context.labels.some((each) => each.name === label.name)) {
+            this.error(`label "${label.name}" is already used by an enclosing statement`, label.start, label.end);
+        }
+        const entry = { name: label.name, loop, used: false };
+        const statement = this.withContext({ labels: [...this.context.labels, entry] }, () => this.parseStatement());
+        if (!entry.used) {
+            this.error(`label "${label.name}" is not used: leave the statement with "break ${label.name}" or remove the label`, label.start, label.end);
+        }
+        return { ...statement, label, start: label.start };
+    }
+    parseReturn() {
+        const start = this.next().start;
+        if (this.context.inGoFor) {
+            this.error('"return" cannot leave "go for": its body runs in workers; skip an element with "continue"', start, this.span(start).end);
+        }
+        else if (!this.context.inFunction) {
+            this.error('"return" outside of a function', start, this.span(start).end);
+        }
+        else if (this.context.inDefer) {
+            this.error('"return" is not allowed inside "defer"', start, this.span(start).end);
+        }
+        const values = this.check(';') || this.check('}') || this.check('EOF') ? [] : this.parseExpressionList();
+        const statement = { kind: 'ReturnStatement', values, ...this.span(start) };
+        this.endStatement();
+        return statement;
+    }
+    /** `}` + newline + `else`: the newline ends the `if`, so explain the error instead of failing. */
+    parseBreakOrContinue() {
+        const token = this.next();
+        const word = token.kind === 'break' ? 'break' : 'continue';
+        const label = this.check('Identifier') ? this.parseIdentifier('label') : null;
+        const span = { start: token.start, end: label?.end ?? token.end };
+        if (label)
+            this.checkLabel(word, label);
+        else if (word === 'continue' && !this.context.inLoop) {
+            this.error('"continue" outside of a loop', token.start, token.end);
+        }
+        else if (word === 'break' && !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);
+        }
+        this.endStatement();
+        const kind = word === 'break' ? 'BreakStatement' : 'ContinueStatement';
+        return { kind, ...(label ? { label } : {}), ...span };
+    }
+    /** `break outer` leaves an enclosing statement with that label; `continue outer`, a loop. */
+    checkLabel(word, label) {
+        const entry = this.context.labels.findLast((each) => each.name === label.name);
+        if (!entry) {
+            this.error(this.context.inGoFor
+                ? `"${word} ${label.name}" cannot leave "go for": its parts run at once in workers`
+                : `label "${label.name}" is not defined: put it before an enclosing loop, e.g. ${label.name}: for ...`, label.start, label.end);
+            return;
+        }
+        entry.used = true;
+        if (word === 'continue' && !entry.loop) {
+            this.error(`"continue ${label.name}" needs a loop, and ${label.name} labels a switch or select: leave it with "break ${label.name}"`, label.start, label.end);
+        }
+    }
+}

package/dist/parser/literals.d.ts

@@ -19,6 +19,15 @@ export declare abstract class LiteralParser extends ExpressionParser {
      * that has no type and `(` after it is a comparison: then this gives null and reads nothing.
      */
     protected parseQueue(): ast.QueueExpression | null;
+    /** `topic<CartEvent>("cart")`; `topic < n` is a comparison, as `queue < n` is. */
+    protected parseTopic(): ast.TopicExpression | null;
+    /** `decode<User>(body)`; `decode < n` is a comparison, as `topic < n` is. */
+    protected parseDecode(): ast.DecodeExpression | null;
+    /**
+     * `<T>(` after `queue`, `topic` or `decode`: the type, with `(` read. Without `(` after the
+     * type, gives null and reads nothing, so that `queue < n` stays a comparison.
+     */
+    private parseMadeType;
     /** `chan(stream)` or `chan(stream, size)`, after `chan`. */
     protected parseStreamChan(start: number): ast.StreamChanExpression;
     /** `[]byte("text")`: a type, then its value in parentheses. */

package/dist/parser/literals.js

@@ -133,18 +133,60 @@ export class LiteralParser extends ExpressionParser {
      * that has no type and `(` after it is a comparison: then this gives null and reads nothing.
      */
     parseQueue() {
+        const start = this.peek().start;
+        const element = this.parseMadeType();
+        if (!element)
+            return null;
+        const items = this.check(')') ? null : this.nested(() => this.parseExpression());
+        this.accept(',');
+        this.expect(')', '")": a queue takes its first values as one array, e.g. queue<number>([1, 2])');
+        return { kind: 'QueueExpression', element, items, ...this.span(start) };
+    }
+    /** `topic<CartEvent>("cart")`; `topic < n` is a comparison, as `queue < n` is. */
+    parseTopic() {
+        const start = this.peek().start;
+        const element = this.parseMadeType();
+        if (!element)
+            return null;
+        if (this.check(')')) {
+            this.fail('a topic takes its name, the same in every tab, e.g. topic<CartEvent>("cart")');
+        }
+        const name = this.nested(() => this.parseExpression());
+        this.accept(',');
+        this.expect(')', '")": a topic takes only its name, e.g. topic<CartEvent>("cart")');
+        return { kind: 'TopicExpression', element, name, ...this.span(start) };
+    }
+    /** `decode<User>(body)`; `decode < n` is a comparison, as `topic < n` is. */
+    parseDecode() {
+        const start = this.peek().start;
+        const type = this.parseMadeType();
+        if (!type)
+            return null;
+        if (this.check(')')) {
+            this.fail('decode takes JSON text or a value from JS, e.g. decode<User>(body)');
+        }
+        const argument = this.nested(() => this.parseExpression());
+        this.accept(',');
+        this.expect(')', '")": decode takes one argument, e.g. decode<User>(body)');
+        return { kind: 'DecodeExpression', type, argument, ...this.span(start) };
+    }
+    /**
+     * `<T>(` after `queue`, `topic` or `decode`: the type, with `(` read. Without `(` after the
+     * type, gives null and reads nothing, so that `queue < n` stays a comparison.
+     */
+    parseMadeType() {
         const { pos } = this;
         // Closing the type may split a `>>` token, and errors are reported as the type is read.
         const tokens = this.tokens.slice(pos);
         const reported = this.diagnostics.length;
-        const start = this.next().start;
         let element;
+        this.next();
         try {
             this.expect('<');
             element = this.parseType();
             this.expectTypeClose('">" after the type of the values');
             if (!this.check('('))
-                throw new ParseError('not a queue');
+                throw new ParseError('not a call');
         }
         catch (error) {
             if (!(error instanceof ParseError))
@@ -155,10 +197,7 @@ export class LiteralParser extends ExpressionParser {
             return null;
         }
         this.next();
-        const items = this.check(')') ? null : this.nested(() => this.parseExpression());
-        this.accept(',');
-        this.expect(')', '")": a queue takes its first values as one array, e.g. queue<number>([1, 2])');
-        return { kind: 'QueueExpression', element, items, ...this.span(start) };
+        return element;
     }
     /** `chan(stream)` or `chan(stream, size)`, after `chan`. */
     parseStreamChan(start) {

package/dist/parser/markup.js

@@ -136,7 +136,7 @@ export class MarkupParser extends LiteralParser {
     parseEventHandler() {
         const start = this.peek().start;
         const body = [];
-        this.withContext({ noObjectLiteral: false, inFunction: true, inLoop: false, inBreakable: false }, () => {
+        this.withContext({ noObjectLiteral: false, inFunction: true, inLoop: false, inBreakable: false, labels: [] }, () => {
             do {
                 if (this.check('}'))
                     break;

package/dist/parser/params.d.ts

@@ -0,0 +1,21 @@
+import type * as ast from '../ast.ts';
+import { JumpParser } from './jumps.ts';
+export declare abstract class ParamParser extends JumpParser {
+    /**
+     * `(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. The parameters of a constructor can be
+     * properties: `(private name string)`.
+     */
+    protected parseParams(typesOptional: boolean, allowDefaults?: boolean, allowRest?: boolean, allowProperties?: boolean): ast.Parameter[];
+    /** `private`, `readonly` or both before a parameter that is a property of its class. */
+    private parsePropertyModifiers;
+    /**
+     * `bind` before a property of a component, `bind active string`. Followed by a name and then
+     * not by `,` or `)`, so a parameter named bind, `(bind Mode)`, stays one.
+     */
+    private parseBindModifier;
+    /** `...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[];
+}