rooklang 0.3.2 → 0.3.4

package/dist/parser/classes.js

@@ -1,9 +1,11 @@
 import { isKeyword } from "../lexer/token.js";
 import { DecoratorParser } from "./decorators.js";
-import { MODIFIERS } from "./syntax.js";
+import { MODIFIERS, VISIBILITIES } from "./syntax.js";
 // Classes and their members, interfaces and `type` aliases.
 export class ClassParser extends DecoratorParser {
     parseClass(start, exported) {
+        const abstract = this.acceptWord('abstract');
+        const data = this.acceptWord('data');
         this.expect('class');
         const name = this.parseIdentifier('class name');
         const typeParams = this.parseTypeParams();
@@ -34,6 +36,8 @@ export class ClassParser extends DecoratorParser {
         return {
             kind: 'ClassDeclaration',
             exported,
+            data,
+            ...(abstract ? { abstract } : {}),
             name,
             typeParams,
             superClass,
@@ -45,24 +49,26 @@ export class ClassParser extends DecoratorParser {
     parseClassMember() {
         const start = this.peek().start;
         let visibility = null;
-        let isStatic = false;
+        const modifiers = new Map();
         // 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 (VISIBILITIES.has(modifier.text)) {
                 if (visibility)
                     this.error('duplicate visibility modifier', modifier.start, modifier.end);
                 visibility = modifier.text;
             }
+            else {
+                if (modifiers.has(modifier.text)) {
+                    this.error(`duplicate "${modifier.text}" modifier`, modifier.start, modifier.end);
+                }
+                modifiers.set(modifier.text, modifier);
+            }
         }
+        const isStatic = modifiers.has('static');
         // `async load()`; a method named `async` is `async()`.
         const asyncToken = this.check('async') && this.peek(1).kind !== '(' ? this.next() : null;
         const async = asyncToken !== null;
@@ -72,7 +78,12 @@ export class ClassParser extends DecoratorParser {
                 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);
+            for (const word of ['readonly', 'abstract']) {
+                const modifier = modifiers.get(word);
+                if (modifier)
+                    this.error(`a constructor cannot be ${word}`, modifier.start, modifier.end);
+            }
+            const params = this.parseParams(false, false, false, true);
             const resultsStart = this.peek().start;
             if (this.parseResults().length > 0) {
                 this.error('constructors cannot have result types', resultsStart, this.span(start).end);
@@ -88,27 +99,24 @@ export class ClassParser extends DecoratorParser {
                 },
             ];
         }
+        // `get area()`; a method named `get` is `get()`, a field `get string`.
+        const accessorToken = (this.checkWord('get') || this.checkWord('set')) &&
+            isName(this.peek(1)) &&
+            this.peek(2).kind === '('
+            ? this.next()
+            : null;
         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),
-                },
+                this.parseMethod(start, name, visibility ?? 'public', modifiers, asyncToken, accessorToken),
             ];
         }
         if (asyncToken)
             this.error('only methods can be async', asyncToken.start, asyncToken.end);
+        const abstract = modifiers.get('abstract');
+        if (abstract) {
+            this.error('only methods can be abstract: for a field, declare an abstract getter, e.g. abstract get name() string', abstract.start, abstract.end);
+        }
         // Fields: `name string`, `count = 0`, `x, y number`.
         const names = [name];
         while (this.accept(','))
@@ -127,12 +135,65 @@ export class ClassParser extends DecoratorParser {
             kind: 'FieldDeclaration',
             visibility: visibility ?? 'public',
             isStatic,
+            ...(modifiers.has('readonly') ? { readonly: true } : {}),
             name: fieldName,
             type,
             value,
             ...span,
         }));
     }
+    /** A method, a getter or a setter, after its name; an abstract one has no body. */
+    parseMethod(start, name, visibility, modifiers, asyncToken, accessorToken) {
+        const isStatic = modifiers.has('static');
+        const readonly = modifiers.get('readonly');
+        const abstract = modifiers.get('abstract');
+        const accessor = accessorToken?.text;
+        const async = asyncToken !== null;
+        if (readonly) {
+            this.error('only fields can be readonly: a method cannot be assigned anyway', readonly.start, readonly.end);
+        }
+        if (abstract && isStatic) {
+            this.error('a static method cannot be abstract', abstract.start, abstract.end);
+        }
+        else if (abstract && visibility === 'private') {
+            this.error('an abstract method cannot be private: the subclasses that implement it could not see it', abstract.start, abstract.end);
+        }
+        if (accessor && asyncToken) {
+            this.error(`a ${accessor}ter cannot be async`, asyncToken.start, asyncToken.end);
+        }
+        const params = this.parseParams(false);
+        const results = this.parseResults();
+        const header = this.span(start);
+        if (accessor === 'get' && (params.length > 0 || results.length !== 1)) {
+            this.error('a getter takes nothing and returns one value, e.g. get area() number', header.start, header.end);
+        }
+        else if (accessor === 'set' && (params.length !== 1 || results.length > 0)) {
+            this.error('a setter takes one value and returns nothing, e.g. set area(v number)', header.start, header.end);
+        }
+        let body = null;
+        if (!abstract)
+            body = this.parseFunctionBody(async);
+        else if (this.check('{')) {
+            const block = this.parseFunctionBody(async);
+            this.error('an abstract method has no body: the subclasses implement it', block.start, block.end);
+        }
+        else {
+            this.endStatement();
+        }
+        return {
+            kind: 'MethodDeclaration',
+            visibility,
+            isStatic,
+            ...(async ? { async } : {}),
+            ...(accessor ? { accessor } : {}),
+            ...(abstract ? { abstract: true } : {}),
+            name,
+            params,
+            results,
+            body,
+            ...this.span(start),
+        };
+    }
     parseInterface(start, exported) {
         this.expect('interface');
         const name = this.parseIdentifier('interface name');
@@ -162,3 +223,7 @@ export class ClassParser extends DecoratorParser {
         };
     }
 }
+/** A member name: keywords can be names after `.` and in classes. */
+function isName(token) {
+    return token.kind === 'Identifier' || isKeyword(token.kind);
+}

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

@@ -2,6 +2,9 @@ import type * as ast from '../ast.ts';
 import { StatementParser } from './statements.ts';
 export declare abstract class ControlFlowParser extends StatementParser {
     protected parseIf(): ast.IfStatement;
+    protected parseHeaderExpression(): ast.Expression;
+    /** `const v, err = f();` before the condition of `if` or the value of `switch`. */
+    private parseHeaderInit;
     protected parseFor(): ast.ForStatement | ast.ForInStatement;
     /** The rest of a `for` statement that starts at `start`, after the keyword. */
     private parseForAfter;
@@ -22,7 +25,6 @@ export declare abstract class ControlFlowParser extends StatementParser {
     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

@@ -1,8 +1,9 @@
 import { StatementParser } from "./statements.js";
-// if, for, switch, break and continue, throw, try and defer.
+// if, for, switch, select, throw, try and defer.
 export class ControlFlowParser extends StatementParser {
     parseIf() {
         const start = this.next().start;
+        const init = this.parseHeaderInit('if');
         const condition = this.parseHeaderExpression();
         const consequent = this.parseBlock();
         let alternate = null;
@@ -10,7 +11,21 @@ export class ControlFlowParser extends StatementParser {
         if (this.accept('else')) {
             alternate = this.check('if') ? this.parseIf() : this.parseBlock();
         }
-        return { kind: 'IfStatement', condition, consequent, alternate, ...this.span(start) };
+        return { kind: 'IfStatement', init, condition, consequent, alternate, ...this.span(start) };
+    }
+    parseHeaderExpression() {
+        return this.withContext({ noObjectLiteral: true }, () => this.parseExpression());
+    }
+    /** `const v, err = f();` before the condition of `if` or the value of `switch`. */
+    parseHeaderInit(keyword) {
+        if (!this.check('const') && !this.check('let'))
+            return null;
+        const init = this.withContext({ noObjectLiteral: true }, () => this.parseVariableDeclaration(this.peek().start, false));
+        if (this.context.inMarkup) {
+            this.error(`the ${keyword} of markup has no initializer: declare the variable before the markup`, init.start, init.end);
+        }
+        this.expect(';', `";" after the initializer of ${keyword}`);
+        return init;
     }
     parseFor() {
         return this.parseForAfter(this.next().start);
@@ -59,7 +74,7 @@ export class ControlFlowParser extends StatementParser {
             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());
+        const body = this.withContext({ inLoop: true, inBreakable: false, inGoFor: true, labels: [] }, () => 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. */
@@ -77,6 +92,7 @@ export class ControlFlowParser extends StatementParser {
     }
     parseSwitch() {
         const start = this.next().start;
+        const init = this.parseHeaderInit('switch');
         const discriminant = this.check('{') ? null : this.parseHeaderExpression();
         this.expect('{');
         const cases = [];
@@ -101,7 +117,7 @@ export class ControlFlowParser extends StatementParser {
             cases.push({ kind: 'SwitchCase', tests, body, ...this.span(caseStart) });
         }
         this.expect('}');
-        return { kind: 'SwitchStatement', discriminant, cases, ...this.span(start) };
+        return { kind: 'SwitchStatement', init, discriminant, cases, ...this.span(start) };
     }
     /** `select { case v = <-ch: ... case ch <- v: ... default: ... }`; it waits, as `await` does. */
     parseSelect() {
@@ -157,25 +173,6 @@ export class ControlFlowParser extends StatementParser {
         }
         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();
@@ -214,7 +211,7 @@ export class ControlFlowParser extends StatementParser {
             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());
+            const body = this.withContext({ inDefer: true, inAsync: false, inLoop: false, inBreakable: false, labels: [] }, () => this.parseBlock());
             return { kind: 'DeferStatement', body, ...this.span(start) };
         }
         const call = this.withContext({ inDefer: true, inAsync: false }, () => this.parseExpression());

package/dist/parser/declarations.d.ts

@@ -1,6 +1,6 @@
 import type * as ast from '../ast.ts';
-import { ControlFlowParser } from './control-flow.ts';
-export declare abstract class DeclarationParser extends ControlFlowParser {
+import { JumpParser } from './jumps.ts';
+export declare abstract class DeclarationParser extends JumpParser {
     protected parseImport(): ast.ImportDeclaration;
     protected parseImportSpecifier(): ast.ImportSpecifier;
     protected parseExport(): ast.Statement;
@@ -11,9 +11,12 @@ export declare abstract class DeclarationParser extends ControlFlowParser {
     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.
+     * 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): ast.Parameter[];
+    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;
     /** `...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)`. */

package/dist/parser/declarations.js

@@ -1,7 +1,7 @@
-import { ControlFlowParser } from "./control-flow.js";
-import { describe, FUNCTION_BODY } from "./syntax.js";
+import { JumpParser } from "./jumps.js";
+import { describe, FUNCTION_BODY, VISIBILITIES } from "./syntax.js";
 // Imports and exports, functions and components with their parameters and results.
-export class DeclarationParser extends ControlFlowParser {
+export class DeclarationParser extends JumpParser {
     parseImport() {
         const start = this.next().start;
         if (!this.context.topLevel) {
@@ -111,9 +111,10 @@ export class DeclarationParser extends ControlFlowParser {
     }
     /**
      * `(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.
+     * Go; only arrow functions may leave types out entirely. The parameters of a constructor can be
+     * properties: `(private name string)`.
      */
-    parseParams(typesOptional, allowDefaults = false, allowRest = false) {
+    parseParams(typesOptional, allowDefaults = false, allowRest = false, allowProperties = false) {
         this.expect('(');
         const params = [];
         let untyped = 0;
@@ -122,10 +123,19 @@ export class DeclarationParser extends ControlFlowParser {
                 params.push(this.parseRestParam(allowRest));
                 break;
             }
+            const paramStart = this.peek().start;
+            const property = this.parsePropertyModifiers(allowProperties);
             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) });
+            params.push({
+                kind: 'Parameter',
+                name,
+                type,
+                defaultValue,
+                ...(property ? { property } : {}),
+                ...this.span(paramStart),
+            });
             if (type === null) {
                 untyped++;
             }
@@ -144,6 +154,35 @@ export class DeclarationParser extends ControlFlowParser {
         }
         return params;
     }
+    /** `private`, `readonly` or both before a parameter that is a property of its class. */
+    parsePropertyModifiers(allowed) {
+        let visibility = null;
+        let readonly = false;
+        const start = this.peek().start;
+        // Elsewhere `readonly number` is a parameter named readonly, and `private x number` an error.
+        while (this.check('Identifier') &&
+            (VISIBILITIES.has(this.peek().text) || this.peek().text === 'readonly') &&
+            this.peek(1).kind === 'Identifier' &&
+            (allowed || this.peek(2).kind === 'Identifier')) {
+            const modifier = this.next();
+            if (modifier.text === 'readonly') {
+                if (readonly)
+                    this.error('duplicate "readonly" modifier', modifier.start, modifier.end);
+                readonly = true;
+            }
+            else {
+                if (visibility)
+                    this.error('duplicate visibility modifier', modifier.start, modifier.end);
+                visibility = modifier.text;
+            }
+        }
+        if (visibility === null && !readonly)
+            return null;
+        if (!allowed) {
+            this.error('only the parameters of a constructor can be properties, e.g. constructor(private name string)', start, this.span(start).end);
+        }
+        return { visibility: visibility ?? 'public', ...(readonly ? { readonly: true } : {}) };
+    }
     /** `...attrs`: the attributes that a component passes on to one of its elements. */
     parseRestParam(allowed) {
         const start = this.next().start;

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/simple-statements.d.ts

@@ -1,7 +1,7 @@
 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. */
+    /** `await`, `<-ch` and `select` 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;