rooklang 0.3.3 → 0.3.4

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;

package/dist/parser/simple-statements.js

@@ -1,15 +1,13 @@
 import { ParserBase } from "./base.js";
-import { isAssignmentOperator, describe, plural } from "./syntax.js";
+import { cannotWait, isAssignmentOperator, describe, plural } from "./syntax.js";
 // Simple statements, which `for` headers allow too: declarations of variables, assignments, `i++`
 // and calls.
 export class SimpleStatementParser extends ParserBase {
-    /** `await`, `<-ch` and `ch <- v` wait: only in async functions and at the top level. */
+    /** `await`, `<-ch` and `select` wait: only in async functions and at the top level. */
     requireAsync(what, start, end) {
         if (this.context.inAsync)
             return;
-        this.error(this.context.inDefer
-            ? `"${what}" is not allowed inside "defer": deferred code runs when the function ends`
-            : `"${what}" is allowed only in async functions and at the top level of a module; mark the function, e.g. "async func load() { ... }"`, start, end);
+        this.error(cannotWait(what, this.context.inDefer), start, end);
     }
     /** `x := 1` is a common habit from Go. */
     rejectColonEquals() {
@@ -49,12 +47,15 @@ export class SimpleStatementParser extends ParserBase {
             this.checkArity(targets.length, values, start);
             return { kind: 'AssignmentStatement', operator, targets, values, ...this.span(start) };
         }
-        // `ch <- value`: the value goes into the channel.
+        // `ch <- value`: the value goes into the channel. A send to a channel waits, and one to a
+        // topic does not, so whether it may be here is for the checker, which knows the type.
         if (this.check('<-')) {
-            const arrow = this.next();
-            this.requireAsync('<-', arrow.start, arrow.end);
+            const { start: from, end } = this.next();
             const value = this.parseExpression();
-            return { kind: 'SendStatement', channel: first, value, ...this.span(start) };
+            const cannotWait = this.context.inAsync
+                ? {}
+                : { cannotWait: { inDefer: this.context.inDefer, start: from, end } };
+            return { kind: 'SendStatement', channel: first, value, ...cannotWait, ...this.span(start) };
         }
         if (this.check('++') || this.check('--')) {
             const operator = this.next().kind === '++' ? '++' : '--';
@@ -90,6 +91,12 @@ export class SimpleStatementParser extends ParserBase {
         // `chunks, failed = chan(res.body)`: the channel of a stream and that of its error.
         if (values.length === 1 && value?.kind === 'StreamChanExpression')
             return;
+        // `user, err = decode<User>(body)`: the value and the error.
+        if (values.length === 1 && value?.kind === 'DecodeExpression')
+            return;
+        // `data, err = try JSON.parse(text)`: the value and the error, as from a call.
+        if (values.length === 1 && value?.kind === 'TryExpression')
+            return;
         this.error(`assignment mismatch: ${plural(targets, 'variable')} but ${plural(values.length, 'value')}`, start, this.span(start).end);
     }
     /** `delete scores[name]`: removes a field, so the target is one. */

package/dist/parser/statements.d.ts

@@ -30,8 +30,5 @@ export declare abstract class StatementParser extends SimpleStatementParser {
     protected parseBlock(): ast.BlockStatement;
     protected parseFunctionBody(async?: boolean): ast.BlockStatement;
     /** An if/for/switch header, where `{` starts the block rather than an object literal. */
-    protected parseHeaderExpression(): ast.Expression;
-    protected parseReturn(): ast.ReturnStatement;
-    /** `}` + newline + `else`: the newline ends the `if`, so explain the error instead of failing. */
     protected checkSameLine(keyword: 'else' | 'catch' | 'finally'): void;
 }

package/dist/parser/statements.js

@@ -1,6 +1,6 @@
 import { SimpleStatementParser } from "./simple-statements.js";
 import { FOREIGN_KEYWORDS, FUNCTION_BODY, describe } from "./syntax.js";
-// Statements: blocks, `return`, `mount()`, and which statement a token starts.
+// Statements: blocks, `mount()`, and which statement a token starts.
 export class StatementParser extends SimpleStatementParser {
     parseStatements(isEnd) {
         const body = [];
@@ -62,13 +62,20 @@ export class StatementParser extends SimpleStatementParser {
                 return this.parseBreakOrContinue();
             case 'throw':
                 return this.parseThrow();
+            // `try f()` without a block is an expression.
             case 'try':
-                return this.parseTry();
+                if (this.peek(1).kind === '{')
+                    return this.parseTry();
+                break;
             case 'defer':
                 return this.parseDefer();
             default:
                 break;
         }
+        // `outer: for`; `x := 1` is reported as Go's declaration.
+        if (token.kind === 'Identifier' && this.peek(1).kind === ':' && this.peek(2).kind !== '=') {
+            return this.parseLabeled();
+        }
         const hint = token.kind === 'Identifier' ? FOREIGN_KEYWORDS.get(token.text) : undefined;
         if (hint !== undefined && this.peek(1).kind === 'Identifier') {
             this.fail(`"${token.text}" is not a Rook keyword: ${hint}`);
@@ -106,7 +113,10 @@ export class StatementParser extends SimpleStatementParser {
             const call = expression.kind === 'CallExpression' ||
                 expression.kind === 'NewExpression' ||
                 expression.kind === 'GoExpression';
-            if (!call && !awaited) {
+            if (expression.kind === 'TryExpression') {
+                this.error('try gives the error, which is dropped here: keep it, e.g. "const err = try save()", or catch it with try { } catch e { }', expression.start, expression.end);
+            }
+            else if (!call && !awaited) {
                 this.error('this expression does nothing: only function calls can be used as statements', expression.start, expression.end);
             }
         }
@@ -151,10 +161,17 @@ export class StatementParser extends SimpleStatementParser {
                 this.endStatement();
                 return declaration;
             }
-            default:
+            default: {
                 if (this.isDecoratorDeclaration())
                     return this.parseDecoratorDeclaration(start, exported);
-                return undefined;
+                // `data` and `abstract` are keywords only before `class`: elsewhere they are names.
+                let words = this.checkWord('abstract') ? 1 : 0;
+                if (this.peek(words).text === 'data')
+                    words++;
+                return words > 0 && this.peek(words).kind === 'class'
+                    ? this.parseClass(start, exported)
+                    : undefined;
+            }
         }
     }
     /** A statement ends with a newline or `;`, or right before the `}` that closes its block. */
@@ -237,26 +254,6 @@ export class StatementParser extends SimpleStatementParser {
         return this.withContext({ ...FUNCTION_BODY, inAsync: async }, () => this.parseBlock());
     }
     /** An if/for/switch header, where `{` starts the block rather than an object literal. */
-    parseHeaderExpression() {
-        return this.withContext({ noObjectLiteral: true }, () => this.parseExpression());
-    }
-    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. */
     checkSameLine(keyword) {
         if (this.isImplicitSemicolon() && this.peek(1).kind === keyword) {
             const token = this.peek(1);

package/dist/parser/syntax.d.ts

@@ -7,7 +7,7 @@ export declare const ASSIGNMENT_OPERATORS: ReadonlySet<string>;
 export declare function isBinaryOperator(kind: TokenKind): kind is ast.BinaryOperator;
 export declare function isUnaryOperator(kind: TokenKind): kind is ast.UnaryOperator;
 export declare function isAssignmentOperator(kind: TokenKind): kind is ast.AssignmentOperator;
-export declare const RESERVED: ReadonlySet<string>;
+export declare const VISIBILITIES: ReadonlySet<string>;
 export declare const MODIFIERS: ReadonlySet<string>;
 /** Words from JS that Rook spells differently. */
 export declare const FOREIGN_KEYWORDS: ReadonlyMap<string, string>;
@@ -33,6 +33,14 @@ export interface Context {
     inComponent: boolean;
     /** In the blocks of `{if ...}` and `{for ...}` inside markup, where elements are statements. */
     inMarkup: boolean;
+    /** The labels of the enclosing statements, innermost last, which `break` and `continue` name. */
+    labels: readonly Label[];
+}
+/** `outer: for`: `loop` tells `continue outer` from a label of a switch or select. */
+export interface Label {
+    name: string;
+    loop: boolean;
+    used: boolean;
 }
 export declare const FUNCTION_BODY: Partial<Context>;
 /** Thrown to abandon the current statement after its syntax error has been reported. */
@@ -49,3 +57,5 @@ export declare function cleanJsxText(text: string): string;
 /** In `on*` attributes, these are the handler itself rather than code to run. */
 export declare function isHandlerReference(node: ast.Expression): boolean;
 export declare function templateElement(token: StringToken): ast.TemplateElement;
+/** Why `what`, which waits, is not allowed where it is: not in an async function or in `defer`. */
+export declare function cannotWait(what: string, inDefer: boolean): string;

package/dist/parser/syntax.js

@@ -60,8 +60,13 @@ export function isUnaryOperator(kind) {
 export function isAssignmentOperator(kind) {
     return ASSIGNMENT_OPERATORS.has(kind);
 }
-export const RESERVED = new Set(['map']);
-export const MODIFIERS = new Set(['public', 'protected', 'private', 'static']);
+export const VISIBILITIES = new Set(['public', 'protected', 'private']);
+export const MODIFIERS = new Set([
+    ...VISIBILITIES,
+    'static',
+    'readonly',
+    'abstract',
+]);
 /** Words from JS that Rook spells differently. */
 export const FOREIGN_KEYWORDS = new Map([
     ['function', 'declare functions with "func"'],
@@ -106,6 +111,7 @@ export const FUNCTION_BODY = {
     inAsync: false,
     noObjectLiteral: false,
     inMarkup: false,
+    labels: [],
 };
 /** Thrown to abandon the current statement after its syntax error has been reported. */
 export class ParseError extends Error {
@@ -118,6 +124,8 @@ export function describe(token) {
             return token.text === '' ? 'newline' : '";"';
         case 'String':
             return 'string';
+        case 'RegExp':
+            return 'regular expression';
         case 'Number':
             return `number ${token.text}`;
         case 'BigInt':
@@ -171,3 +179,9 @@ export function templateElement(token) {
         end: token.end,
     };
 }
+/** Why `what`, which waits, is not allowed where it is: not in an async function or in `defer`. */
+export function cannotWait(what, inDefer) {
+    return inDefer
+        ? `"${what}" is not allowed inside "defer": deferred code runs when the function ends`
+        : `"${what}" is allowed only in async functions and at the top level of a module; mark the function, e.g. "async func load() { ... }"`;
+}

package/dist/parser/types.js

@@ -1,6 +1,6 @@
 import { ClassParser } from "./classes.js";
 import { describe } from "./syntax.js";
-// Types: `?T`, `[]T`, `queue T`, unions, literal types, function, component and object types, type arguments.
+// Types: `?T`, `[]T`, `queue T`, `topic T`, unions, literal types, function, component and object types, type arguments.
 /** `iterator: true` for the parameters of an iterator: one, named `yield`. */
 function iterator(names) {
     return names.length === 1 && names[0] === 'yield' ? { iterator: true } : {};
@@ -106,14 +106,19 @@ export class TypeParser extends ClassParser {
                 const members = this.parseTypeMembers();
                 return { kind: 'ObjectType', members, ...this.span(start) };
             }
-            // `queue number`: `queue` is a type of its own only before the type of its values, so that it
-            // stays a name elsewhere.
+            // `queue number` and `topic number`: `queue` and `topic` are types of their own only before
+            // the type of their values, so that they stay names elsewhere.
             default: {
                 if (this.checkWord('queue') && this.canStartType(1)) {
                     this.next();
                     const element = this.parsePrimaryType();
                     return { kind: 'QueueType', element, ...this.span(start) };
                 }
+                if (this.checkWord('topic') && this.canStartType(1)) {
+                    this.next();
+                    const element = this.parsePrimaryType();
+                    return { kind: 'TopicType', element, ...this.span(start) };
+                }
                 const name = this.parseIdentifier('type');
                 const typeArgs = this.parseTypeArgs();
                 return { kind: 'TypeReference', name, typeArgs, ...this.span(start) };

package/dist/project-modules.d.ts

@@ -0,0 +1,12 @@
+import type { Completion } from './checker/checker.ts';
+/** What a name is used as, and so where it is offered: decorators have a namespace of their own. */
+export type ExportSpace = 'value' | 'type' | 'tag' | 'decorator';
+export interface ExportedName {
+    name: string;
+    kind: Completion['kind'];
+    spaces: ExportSpace[];
+    /** The absolute path of the module. */
+    path: string;
+}
+/** The names exported by the other `.rk` modules of the package of `filename`. */
+export declare function projectExports(filename: string): ExportedName[];