rooklang 0.3.3 → 0.4.0

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

@@ -1,6 +1,10 @@
 import type * as ast from './ast.ts';
 /** Names assigned anywhere inside `node`: `x = ...`, `x += ...`, `x++`. */
 export declare function assignedNames(node: ast.Node, names?: Set<string>): Set<string>;
+/** `order.delivery.kind`: the variable and the fields of a path, or `null` for other expressions. */
+export declare function pathOf(node: ast.Expression): string[] | null;
+/** Paths of fields assigned anywhere inside `node`, e.g. `order.delivery` of `order.delivery = d`. */
+export declare function assignedPaths(node: ast.Node, paths?: Set<string>): Set<string>;
 /** Whether an identifier with one of `names` occurs in `node`, whatever it refers to. */
 export declare function mentionsName(node: ast.Node, names: ReadonlySet<string>): boolean;
 /** Every name declared inside `node`: parameters and all local declarations, nested ones too. */

package/dist/names.js

@@ -19,6 +19,30 @@ export function assignedNames(node, names = new Set()) {
     forEachChild(node, (child) => assignedNames(child, names));
     return names;
 }
+/** `order.delivery.kind`: the variable and the fields of a path, or `null` for other expressions. */
+export function pathOf(node) {
+    if (node.kind === 'Identifier')
+        return [node.name];
+    if (node.kind !== 'MemberExpression' || node.optional)
+        return null;
+    const object = pathOf(node.object);
+    return object && [...object, node.property.name];
+}
+/** Paths of fields assigned anywhere inside `node`, e.g. `order.delivery` of `order.delivery = d`. */
+export function assignedPaths(node, paths = new Set()) {
+    const targets = node.kind === 'AssignmentStatement'
+        ? node.targets
+        : node.kind === 'IncDecStatement'
+            ? [node.target]
+            : [];
+    for (const target of targets) {
+        const path = pathOf(target);
+        if (path && path.length > 1)
+            paths.add(path.join('.'));
+    }
+    forEachChild(node, (child) => assignedPaths(child, paths));
+    return paths;
+}
 /** Whether an identifier with one of `names` occurs in `node`, whatever it refers to. */
 export function mentionsName(node, names) {
     if (node.kind === 'Identifier')
@@ -99,6 +123,7 @@ export function freeNames(component) {
                 for (const name of node.names)
                     declared.add(name.name);
                 node.values.forEach(visit);
+                visit(node.body);
                 return;
             case 'SelectCase':
                 for (const name of node.names)
@@ -120,6 +145,8 @@ export function freeNames(component) {
                 if (node.key)
                     declared.add(node.key.name);
                 visit(node.iterable);
+                if (node.withKey)
+                    visit(node.withKey);
                 visit(node.body);
                 return;
             case 'CatchClause':
@@ -195,6 +222,7 @@ export function collectValueNames(node, names, isComponent = () => true) {
             return;
         case 'VariableDeclaration':
             node.values.forEach(visit);
+            visit(node.body);
             return;
         case 'FuncDeclaration':
         case 'MethodDeclaration':
@@ -237,6 +265,7 @@ export function collectValueNames(node, names, isComponent = () => true) {
             return;
         case 'ForInStatement':
             visit(node.iterable);
+            visit(node.withKey ?? null);
             visit(node.body);
             return;
         case 'CatchClause':

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;
@@ -23,6 +25,7 @@ export declare abstract class ParserBase {
     protected abstract parseClass(start: number, exported: boolean): ast.ClassDeclaration;
     protected abstract parseInterface(start: number, exported: boolean): ast.InterfaceDeclaration;
     protected abstract parseTypeAlias(start: number, exported: boolean): ast.TypeAliasDeclaration;
+    protected abstract parseFunctionBody(async?: boolean): ast.BlockStatement;
     protected abstract canStartType(offset?: number): boolean;
     protected abstract parseType(): ast.TypeNode;
     protected abstract parseTypeArgs(): ast.TypeNode[];
@@ -37,6 +40,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 → params → 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;
@@ -14,6 +17,11 @@ export declare abstract class ControlFlowParser extends StatementParser {
         ast.SimpleStatement | null
     ];
     protected parseForIn(start: number, go?: boolean): ast.ForInStatement;
+    /**
+     * `with key todo.id` after the items of a `{for}` in markup: its blocks are found again by the
+     * key instead of the item. `with` and `key` are words only here, not keywords.
+     */
+    private parseWithKey;
     /** `go for i, v in items { }`: the parts of the array run as goroutines, and the loop waits. */
     protected parseGoFor(): ast.ForStatement | ast.ForInStatement;
     protected parseLoopBody(): ast.BlockStatement;
@@ -22,7 +30,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);
@@ -54,13 +69,39 @@ export class ControlFlowParser extends StatementParser {
         }
         this.expect('in');
         const iterable = this.parseHeaderExpression();
+        const withKey = this.parseWithKey(go);
+        const keyed = withKey ? { withKey } : {};
         if (!go) {
             const body = this.parseLoopBody();
-            return { kind: 'ForInStatement', key, value, iterable, body, ...this.span(start) };
+            return { kind: 'ForInStatement', key, value, iterable, ...keyed, 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());
-        return { kind: 'ForInStatement', key, value, iterable, body, go, ...this.span(start) };
+        const body = this.withContext({ inLoop: true, inBreakable: false, inGoFor: true, labels: [] }, () => this.parseBlock());
+        return {
+            kind: 'ForInStatement',
+            key,
+            value,
+            iterable,
+            ...keyed,
+            body,
+            go,
+            ...this.span(start),
+        };
+    }
+    /**
+     * `with key todo.id` after the items of a `{for}` in markup: its blocks are found again by the
+     * key instead of the item. `with` and `key` are words only here, not keywords.
+     */
+    parseWithKey(go) {
+        if (!this.checkWord('with'))
+            return null;
+        const start = this.next().start;
+        this.expectWord('key');
+        const key = this.parseHeaderExpression();
+        if (go || !this.context.inMarkup) {
+            this.error('"with key" finds again the blocks of a {for} in markup, and this loop has none: remove it', start, key.end);
+        }
+        return key;
     }
     /** `go for i, v in items { }`: the parts of the array run as goroutines, and the loop waits. */
     parseGoFor() {
@@ -77,6 +118,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 +143,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 +199,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 +237,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,26 +1,19 @@
 import type * as ast from '../ast.ts';
-import { ControlFlowParser } from './control-flow.ts';
-export declare abstract class DeclarationParser extends ControlFlowParser {
+import { ParamParser } from './params.ts';
+export declare abstract class DeclarationParser extends ParamParser {
     protected parseImport(): ast.ImportDeclaration;
     protected parseImportSpecifier(): ast.ImportSpecifier;
+    /** `state items []Item = []` at the top level of a module: state its components share. */
+    protected parseDeclaration(start: number, exported: boolean): ast.Statement | undefined;
     protected parseExport(): ast.Statement;
     protected parseFuncDeclaration(start: number, exported: boolean): ast.FuncDeclaration;
     /**
      * `<T any, U Shape>` after a name; `<K, V any>` gives both the constraint, as in Go.
      */
     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.
-     */
-    protected parseParams(typesOptional: boolean, allowDefaults?: boolean, allowRest?: boolean): ast.Parameter[];
-    /** `...attrs`: the attributes that a component passes on to one of its elements. */
-    private parseRestParam;
-    /** Result types after a parameter list: nothing, `T`, or `(T1, T2)`. */
-    protected parseResults(): ast.TypeNode[];
     /** `comp Name(properties) { ...; return <markup> }`, maybe after decorators. */
     protected parseComponent(start: number, exported: boolean, htmlTag?: ast.HtmlTag | null, decorators?: ast.DecoratorUse[]): ast.ComponentDeclaration;
-    /** Like a function body, but its own statements may also declare `state`, `ref` and `mount()`. */
+    /** Like a function body, but its own statements may also declare `state`, `ref` and `mount`. */
     protected parseComponentBody(): ast.BlockStatement;
     /** A statement at the top level of a component or a decorator. */
     protected parseComponentStatement(): ast.Statement;