rooklang 0.3.3 → 0.3.4

package/dist/lexer/base.d.ts

@@ -10,6 +10,8 @@ export declare abstract class LexerBase {
     constructor(text: string);
     /** Skips whitespace and comments; returns whether a line break was skipped. */
     protected skipTrivia(): boolean;
+    /** After a value `/` divides; elsewhere it starts a regular expression, as in JS. */
+    protected lastEndsValue(): boolean;
     protected lastEndsStatement(): boolean;
     /**
      * Unlike Go, a line starting with `.` / `?.` continues a method chain, and a line starting with

package/dist/lexer/base.js

@@ -1,4 +1,4 @@
-import { ENDS_STATEMENT, isDigit } from "./tables.js";
+import { ENDS_STATEMENT, ENDS_VALUE, isDigit } from "./tables.js";
 // The lexer is a chain of layers: base → literals → markup → style → Lexer (lexer.ts). This layer
 // keeps the position and the modes (code, markup tags, markup content, CSS), skips spaces and
 // comments, and inserts semicolons at the ends of lines.
@@ -48,6 +48,11 @@ export class LexerBase {
         }
         return sawNewline;
     }
+    /** After a value `/` divides; elsewhere it starts a regular expression, as in JS. */
+    lastEndsValue() {
+        const last = this.tokens.at(-1);
+        return last !== undefined && ENDS_VALUE.has(last.kind);
+    }
     lastEndsStatement() {
         const last = this.tokens.at(-1);
         return last !== undefined && ENDS_STATEMENT.has(last.kind);

package/dist/lexer/lexer.js

@@ -71,6 +71,9 @@ class Lexer extends StyleLexer {
             this.push('}', start, start + 1);
             this.modes.pop();
         }
+        else if (c === '/' && !this.lastEndsValue()) {
+            this.scanRegExp(start);
+        }
         else if (c === '<' && this.startsElement()) {
             this.push('JsxTagOpen', start, start + 1);
             this.modes.push({ kind: 'tag', start });

package/dist/lexer/literals.d.ts

@@ -1,6 +1,11 @@
 import { LexerBase } from './base.ts';
 import { type CharTest } from './tables.ts';
 export declare abstract class LiteralLexer extends LexerBase {
+    /**
+     * `/ab+c/gi`: the pattern goes up to a `/` that is not escaped or inside `[...]`, on one line,
+     * as in JS. JS checks the pattern when it loads the module, so an invalid one is an error here.
+     */
+    protected scanRegExp(start: number): void;
     protected scanNumber(start: number): void;
     /** Consumes digits and `_` separators starting at `pos`; returns the end offset. */
     protected scanDigits(pos: number, isValid: CharTest): number;

package/dist/lexer/literals.js

@@ -1,7 +1,57 @@
 import { LexerBase } from "./base.js";
 import { IDENTIFIER, SIMPLE_ESCAPES, isDigit, isHexDigit, isOctalDigit, isBinaryDigit, } from "./tables.js";
-// Numbers, strings, template strings and escapes.
+// Numbers, strings, template strings, regular expressions and escapes.
+/** The flags of a regular expression, each at most once. */
+const FLAGS = /^(?!.*(.).*\1)[dgimsuvy]*$/;
 export class LiteralLexer extends LexerBase {
+    /**
+     * `/ab+c/gi`: the pattern goes up to a `/` that is not escaped or inside `[...]`, on one line,
+     * as in JS. JS checks the pattern when it loads the module, so an invalid one is an error here.
+     */
+    scanRegExp(start) {
+        const t = this.text;
+        let pos = start + 1;
+        let inClass = false;
+        while (pos < t.length && t[pos] !== '\n' && (inClass || t[pos] !== '/')) {
+            if (t[pos] === '\\' && t[pos + 1] !== '\n')
+                pos++;
+            else if (t[pos] === '[')
+                inClass = true;
+            else if (t[pos] === ']')
+                inClass = false;
+            pos++;
+        }
+        const pattern = t.slice(start + 1, pos);
+        if (t[pos] !== '/') {
+            this.error('unterminated regular expression: end it with "/"', start, pos);
+            this.tokens.push({
+                kind: 'RegExp',
+                text: t.slice(start, pos),
+                value: pattern,
+                start,
+                end: pos,
+            });
+            this.pos = pos;
+            return;
+        }
+        IDENTIFIER.lastIndex = pos + 1;
+        const flags = IDENTIFIER.exec(t)?.[0] ?? '';
+        const end = pos + 1 + flags.length;
+        this.tokens.push({ kind: 'RegExp', text: t.slice(start, end), value: pattern, start, end });
+        this.pos = end;
+        if (!FLAGS.test(flags) || (flags.includes('u') && flags.includes('v'))) {
+            this.error(`invalid flags "${flags}" of a regular expression: each of d, g, i, m, s, u, v and y goes once, and not u with v`, pos + 1, end);
+            return;
+        }
+        try {
+            new RegExp(pattern, flags);
+        }
+        catch (error) {
+            // "Invalid regular expression: /(/: Unterminated group" → "unterminated group".
+            const reason = error.message.replace(/^.*: /, '');
+            this.error(`invalid regular expression: ${reason.charAt(0).toLowerCase()}${reason.slice(1)}`, start, end);
+        }
+    }
     scanNumber(start) {
         const t = this.text;
         let pos = start;

package/dist/lexer/markup.js

@@ -1,14 +1,13 @@
 import { LiteralLexer } from "./literals.js";
-import { ENDS_VALUE, JSX_NAME, decodeEntities } from "./tables.js";
+import { JSX_NAME, decodeEntities } from "./tables.js";
 // Markup: where an element starts, tags with their attributes, and text content.
 export class MarkupLexer extends LiteralLexer {
     /** `<` starts markup where a value is expected and is "less than" after a value. */
     startsElement() {
-        const last = this.tokens.at(-1);
-        if (last && ENDS_VALUE.has(last.kind))
+        if (this.lastEndsValue())
             return false;
         // `chan<number>(10)` makes a channel: its `<` opens the type of the values.
-        if (last?.kind === 'chan')
+        if (this.tokens.at(-1)?.kind === 'chan')
             return false;
         const next = this.text[this.pos + 1];
         return next === '>' || (next !== undefined && /^[\p{ID_Start}$_]$/u.test(next));

package/dist/lexer/tables.js

@@ -8,6 +8,7 @@ export const ENDS_STATEMENT = new Set([
     'Number',
     'BigInt',
     'String',
+    'RegExp',
     'Template',
     'TemplateTail',
     'true',
@@ -34,6 +35,7 @@ export const ENDS_VALUE = new Set([
     'Number',
     'BigInt',
     'String',
+    'RegExp',
     'Template',
     'TemplateTail',
     'true',

package/dist/lexer/token.d.ts

@@ -1,4 +1,4 @@
-export declare const KEYWORDS: readonly ["func", "comp", "go", "chan", "return", "let", "const", "type", "interface", "class", "extends", "new", "this", "super", "if", "else", "for", "in", "break", "continue", "switch", "case", "default", "defer", "try", "catch", "finally", "throw", "import", "export", "null", "true", "false", "typeof", "instanceof", "async", "await", "map"];
+export declare const KEYWORDS: readonly ["func", "comp", "go", "chan", "return", "let", "const", "type", "interface", "class", "extends", "new", "this", "super", "if", "else", "for", "in", "break", "continue", "switch", "case", "default", "defer", "try", "catch", "finally", "throw", "import", "export", "null", "true", "false", "typeof", "instanceof", "async", "await"];
 export declare const PUNCTUATORS: readonly ["{", "}", "(", ")", "[", "]", ";", ",", ":", ".", "...", "?", "?.", "??", "=>", "=", "+=", "-=", "*=", "/=", "%=", "**=", "&=", "|=", "^=", "<<=", ">>=", ">>>=", "&&=", "||=", "??=", "==", "!=", "<", "<-", ">", "<=", ">=", "+", "-", "*", "/", "%", "**", "++", "--", "&", "|", "^", "~", "<<", ">>", ">>>", "&&", "||", "!", "@"];
 export type Keyword = (typeof KEYWORDS)[number];
 export type Punctuator = (typeof PUNCTUATORS)[number];
@@ -7,9 +7,10 @@ export type Punctuator = (typeof PUNCTUATORS)[number];
  * substitutions: `a${x}b${y}c` becomes TemplateHead("a") x TemplateMiddle("b") y TemplateTail("c"),
  * and a template without substitutions is a single Template token. In markup, JsxText is the text
  * between tags and JsxString an attribute value in quotes; both have HTML entities decoded. CssText is
- * the raw text of a `style { ... }` block between the values from code.
+ * the raw text of a `style { ... }` block between the values from code. RegExp is `/ab+c/g`, whose
+ * value is the pattern as it is written, without the slashes and the flags.
  */
-export type StringKind = 'String' | 'Template' | 'TemplateHead' | 'TemplateMiddle' | 'TemplateTail' | 'JsxText' | 'JsxString' | 'CssText';
+export type StringKind = 'String' | 'Template' | 'TemplateHead' | 'TemplateMiddle' | 'TemplateTail' | 'JsxText' | 'JsxString' | 'CssText' | 'RegExp';
 /**
  * Tokens of markup such as `<a href="/">text</a>`: JsxTagOpen `<`, JsxCloseTagOpen `</`, JsxName
  * (tag and attribute names, which may contain `-` and `:`), JsxTagEnd `>` and JsxSelfClose `/>`.

package/dist/lexer/token.js

@@ -36,8 +36,6 @@ export const KEYWORDS = [
     'instanceof',
     'async',
     'await',
-    // Reserved for future use.
-    'map',
 ];
 export const PUNCTUATORS = [
     '{',

package/dist/loader.js

@@ -1,10 +1,11 @@
 import { createHash } from 'node:crypto';
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { appendFileSync, existsSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { createRequire, registerHooks } from 'node:module';
-import { extname, join } from 'node:path';
+import { dirname, extname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { isMainThread } from 'node:worker_threads';
 import { RUNTIME_MODULE } from "./runtime-module.js";
+import { sourceMapComment } from "./source-map.js";
 // `rook run` imports this module first (`node --import`): Node then imports `.rk` files,
 // compiled when they load, and `app.rk?goroutines` is the worker module of `go` in app.rk.
 // The worker threads of `go` import it too, since they get the `--import` of the process. The main
@@ -13,7 +14,10 @@ import { RUNTIME_MODULE } from "./runtime-module.js";
 // there: compiling again, with the types, would take each of them as long. So a worker does not
 // even load the compiler, which takes ~80 ms, unless a module is missing from the cache; the hooks
 // are synchronous, so it is loaded with require(). ROOK_NO_CHECK turns type checking off, and
-// ROOK_MARKUP, 1 or 0, markup and components on or off for every file.
+// ROOK_MARKUP, 1 or 0, markup and components on or off for every file. The code has its source map
+// in it, and the process runs with --enable-source-maps, so stack traces show the lines of .rk.
+// The main thread lists the files it compiles, and those they read, in `files` of the directory of
+// the run, with the time each was changed, for `rook run --watch` (run-file.ts).
 const typeCheck = process.env['ROOK_NO_CHECK'] === undefined;
 const markupSetting = process.env['ROOK_MARKUP'];
 const markup = markupSetting === undefined ? undefined : markupSetting === '1';
@@ -45,19 +49,37 @@ registerHooks({
         const { displayPath } = require(`./build${extension}`);
         const { compileFile } = require(`./compile-file${extension}`);
         const path = displayPath(fileURLToPath(moduleUrl));
+        if (isMainThread && cache)
+            list([resolve(path)]);
         const result = compileFile(path, {
             rewriteImports: false,
             typeCheck,
             markup,
             quiet: !isMainThread,
         });
+        const code = withMap(result.code, result.map);
+        const worker = result.worker === undefined ? undefined : withMap(result.worker, result.workerMap);
         if (isMainThread && cache) {
-            writeFileSync(cached(moduleUrl), result.code);
-            if (result.worker !== undefined) {
-                writeFileSync(cached(`${moduleUrl}?goroutines`), result.worker);
-            }
+            // The CSS modules it imports; the .rk modules are listed when they are loaded.
+            const read = result.dependencies.map((each) => resolve(dirname(path), each));
+            list(read.filter((each) => existsSync(each)));
+            writeFileSync(cached(moduleUrl), code);
+            if (worker !== undefined)
+                writeFileSync(cached(`${moduleUrl}?goroutines`), worker);
         }
-        const source = search === '?goroutines' ? (result.worker ?? '') : result.code;
+        const source = search === '?goroutines' ? (worker ?? '') : code;
         return { format: 'module', source, shortCircuit: true };
     },
 });
+/** The code with its source map in it. */
+function withMap(code, map) {
+    if (map === undefined || code === '')
+        return code;
+    const data = Buffer.from(JSON.stringify(map)).toString('base64');
+    return `${code}${sourceMapComment(`data:application/json;base64,${data}`)}`;
+}
+/** Adds files to the list of the run: a line of the path and the time it was changed. */
+function list(paths) {
+    const lines = paths.map((path) => `${path}\t${statSync(path).mtimeMs}\n`);
+    appendFileSync(join(cache, 'files'), lines.join(''));
+}

package/dist/parser/base.d.ts

@@ -4,6 +4,8 @@ import type { StringToken, Token, TokenKind } from '../lexer/token.ts';
 import { type Context } from './syntax.ts';
 export declare abstract class ParserBase {
     protected abstract parseBreakOrContinue(): ast.BreakStatement | ast.ContinueStatement;
+    protected abstract parseLabeled(): ast.Statement;
+    protected abstract parseReturn(): ast.ReturnStatement;
     protected abstract parseDefer(): ast.DeferStatement;
     protected abstract parseFor(): ast.ForStatement | ast.ForInStatement;
     protected abstract parseGoFor(): ast.ForStatement | ast.ForInStatement;
@@ -37,6 +39,8 @@ export declare abstract class ParserBase {
     protected abstract parseMake(): ast.MakeExpression;
     protected abstract parseStreamChan(start: number): ast.StreamChanExpression;
     protected abstract parseQueue(): ast.QueueExpression | null;
+    protected abstract parseTopic(): ast.TopicExpression | null;
+    protected abstract parseDecode(): ast.DecodeExpression | null;
     protected abstract parseArrowFunction(async?: boolean): ast.ArrowFunction;
     protected abstract parseFuncExpression(async?: boolean): ast.FuncExpression;
     protected abstract parseIdentifier(what?: string): ast.Identifier;

package/dist/parser/base.js

@@ -1,6 +1,6 @@
 import { STATEMENT_KEYWORDS, BRACKETS, ParseError, describe } from "./syntax.js";
 // The parser is a chain of layers, one per area: base → simple statements → statements → control
-// flow → declarations → decorators → classes → types → expressions → literals → markup → Parser
+// flow → jumps → declarations → decorators → classes → types → expressions → literals → markup → Parser
 // (parser.ts). Statements, expressions and markup contain each other, so methods of later layers
 // that earlier ones call are declared here as abstract.
 //
@@ -21,6 +21,7 @@ export class ParserBase {
         noObjectLiteral: false,
         inComponent: false,
         inMarkup: false,
+        labels: [],
     };
     /** Expressions written in parentheses, which the tree itself does not record. */
     parenthesized = new WeakSet();

package/dist/parser/classes.d.ts

@@ -3,6 +3,8 @@ import { DecoratorParser } from './decorators.ts';
 export declare abstract class ClassParser extends DecoratorParser {
     protected parseClass(start: number, exported: boolean): ast.ClassDeclaration;
     protected parseClassMember(): ast.ClassMember[];
+    /** A method, a getter or a setter, after its name; an abstract one has no body. */
+    private parseMethod;
     protected parseInterface(start: number, exported: boolean): ast.InterfaceDeclaration;
     protected parseTypeAlias(start: number, exported: boolean): ast.TypeAliasDeclaration;
 }

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)`. */