rooklang 0.3.3 → 0.4.0

package/dist/parser/params.js

@@ -0,0 +1,143 @@
+import { JumpParser } from "./jumps.js";
+import { VISIBILITIES } from "./syntax.js";
+// The parameters of functions, constructors and components, with their modifiers, and the results
+// of functions.
+export class ParamParser extends JumpParser {
+    /**
+     * `(a, b number, c string)`. Names without a type take the type of the next typed name, as in
+     * Go; only arrow functions may leave types out entirely. The parameters of a constructor can be
+     * properties: `(private name string)`.
+     */
+    parseParams(typesOptional, allowDefaults = false, allowRest = false, allowProperties = false) {
+        this.expect('(');
+        const params = [];
+        let untyped = 0;
+        while (!this.check(')')) {
+            if (this.check('...')) {
+                params.push(this.parseRestParam(allowRest));
+                break;
+            }
+            const paramStart = this.peek().start;
+            const property = this.parsePropertyModifiers(allowProperties);
+            const bind = this.parseBindModifier(allowRest);
+            const name = this.parseIdentifier('parameter name');
+            const type = this.canStartType() ? this.parseType() : null;
+            const defaultValue = allowDefaults && this.accept('=') ? this.parseExpression() : null;
+            if (bind && name.name === 'children') {
+                this.error('children cannot be bound: it is the content between the tags', paramStart, name.end);
+            }
+            params.push({
+                kind: 'Parameter',
+                name,
+                type,
+                defaultValue,
+                ...(property ? { property } : {}),
+                ...(bind ? { bind: true } : {}),
+                ...this.span(paramStart),
+            });
+            if (type === null) {
+                untyped++;
+            }
+            else {
+                for (const param of params.slice(params.length - 1 - untyped))
+                    param.type = type;
+                untyped = 0;
+            }
+            if (!this.accept(','))
+                break;
+        }
+        this.expect(')');
+        if (untyped > 0 && !typesOptional) {
+            const param = params[params.length - untyped];
+            this.error(`missing type for parameter "${param.name.name}"`, param.start, param.end);
+        }
+        return params;
+    }
+    /** `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 } : {}) };
+    }
+    /**
+     * `bind` before a property of a component, `bind active string`. Followed by a name and then
+     * not by `,` or `)`, so a parameter named bind, `(bind Mode)`, stays one.
+     */
+    parseBindModifier(allowed) {
+        const after = this.peek(2).kind;
+        if (!this.checkWord('bind') ||
+            this.peek(1).kind !== 'Identifier' ||
+            after === ',' ||
+            after === ')') {
+            return false;
+        }
+        const modifier = this.next();
+        if (!allowed) {
+            this.error('only the properties of components can be bound, e.g. comp Tabs(bind active string)', modifier.start, modifier.end);
+        }
+        return true;
+    }
+    /** `...attrs`: the attributes that a component passes on to one of its elements. */
+    parseRestParam(allowed) {
+        const start = this.next().start;
+        const name = this.parseIdentifier('parameter name');
+        if (!allowed) {
+            this.error(`...${name.name} is only for components: it takes the attributes of an element`, start, name.end);
+        }
+        if (this.canStartType() || this.check('=')) {
+            const at = this.peek().start;
+            // After the error, the type and the default are read, so they are not reported again.
+            if (this.canStartType())
+                this.parseType();
+            if (this.accept('='))
+                this.parseExpression();
+            this.error(`...${name.name} has no type and no default: it gets the type of the element it is spread on`, at, this.span(at).end);
+        }
+        // After the error, the rest of the list is skipped up to the `)`.
+        if (this.check(',')) {
+            this.error(`...${name.name} is the last property of a component`, start, name.end);
+            while (!this.check(')') && !this.check('EOF'))
+                this.next();
+        }
+        return {
+            kind: 'Parameter',
+            name,
+            type: null,
+            defaultValue: null,
+            rest: true,
+            ...this.span(start),
+        };
+    }
+    /** Result types after a parameter list: nothing, `T`, or `(T1, T2)`. */
+    parseResults() {
+        if (this.accept('('))
+            return this.parseList(')', () => this.parseType());
+        // `{` after the parameters starts the body, so an object result type needs parentheses.
+        if (this.canStartType() && !this.check('{'))
+            return [this.parseType()];
+        return [];
+    }
+}

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;
@@ -18,5 +18,6 @@ export declare abstract class SimpleStatementParser extends ParserBase {
     protected parseExpressionList(): ast.Expression[];
     /** `ref input` is one name, and the markup gives its element. */
     private checkRef;
+    private parseDerivedBlock;
     protected parseVariableDeclaration(start: number, exported: boolean): ast.VariableDeclaration;
 }

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 === '++' ? '++' : '--';
@@ -66,7 +67,6 @@ export class SimpleStatementParser extends ParserBase {
     checkAssignable(target) {
         // Members of decorators are read-only outside them: the checker explains it.
         const assignable = target.kind === 'Identifier' ||
-            target.kind === 'DecoratorGet' ||
             target.kind === 'DecoratorMember' ||
             ((target.kind === 'MemberExpression' || target.kind === 'IndexExpression') &&
                 !target.optional);
@@ -90,6 +90,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. */
@@ -118,6 +124,17 @@ export class SimpleStatementParser extends ParserBase {
             this.error(`ref declares one name, e.g. ref ${name}`, start, end);
         }
     }
+    parseDerivedBlock() {
+        const body = this.parseFunctionBody();
+        return {
+            kind: 'FuncExpression',
+            params: [],
+            results: [],
+            body,
+            start: body.start,
+            end: body.end,
+        };
+    }
     parseVariableDeclaration(start, exported) {
         const token = this.next();
         const keyword = token.kind === 'const'
@@ -128,16 +145,21 @@ export class SimpleStatementParser extends ParserBase {
         const names = [this.parseIdentifier('variable name')];
         while (this.accept(','))
             names.push(this.parseIdentifier('variable name'));
-        const type = this.canStartType() ? this.parseType() : null;
-        const values = this.accept('=') ? this.parseExpressionList() : [];
+        // `derived summary {` starts the block that computes it, as `{` after the parameters of a
+        // function starts its body: an object type goes in parentheses.
+        const block = () => keyword === 'derived' && this.check('{');
+        const type = !block() && this.canStartType() ? this.parseType() : null;
+        const body = block() ? this.parseDerivedBlock() : null;
+        const values = body === null && this.accept('=') ? this.parseExpressionList() : [];
         const { end } = this.span(start);
         if (keyword === 'ref') {
             this.checkRef(names, values.length > 0, start, end);
         }
-        else if (keyword === 'derived' && (names.length !== 1 || values.length !== 1)) {
-            this.error('derived is one name and the expression it is computed from, e.g. derived double = count * 2', start, end);
+        else if (keyword === 'derived' &&
+            (names.length !== 1 || values.length + Number(!!body) !== 1)) {
+            this.error('derived is one name and the expression it is computed from, e.g. derived double = count * 2, or a block that returns it: derived total number { ... return sum }', start, end);
         }
-        else if (values.length === 0 && type === null) {
+        else if (values.length === 0 && type === null && body === null) {
             this.error(`"${names[0].name}" needs a type or a value`, start, end);
         }
         else if (values.length === 0 && keyword === 'const') {
@@ -152,6 +174,7 @@ export class SimpleStatementParser extends ParserBase {
             names,
             type,
             values,
+            body,
             start,
             end,
         };

package/dist/parser/statements.d.ts

@@ -21,17 +21,17 @@ export declare abstract class StatementParser extends SimpleStatementParser {
     protected parseStyle(): ast.StyleStatement;
     /** `effect {`: like `state`, a keyword only at the start of a statement in a component. */
     protected isEffectDeclaration(): boolean;
-    /** `mount() {`: like `state`, a keyword only at the start of a statement in a component. */
+    /**
+     * `mount {`: like `state`, a keyword only at the start of a statement in a component. The old
+     * form `mount() {` is recognized too, so that parseMount can say how to write it now.
+     */
     protected isMountDeclaration(): boolean;
-    /** `mount() { ... }`; its body is a function that runs later, so `return` is its own. */
+    /** `mount { ... }`; its body is a function that runs later, so `return` is its own. */
     protected parseMount(): ast.MountStatement;
     /** `effect { ... }`: its body runs again later, so `return` and `defer` are its own. */
     protected parseEffect(): ast.EffectStatement;
     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}`);
@@ -88,14 +95,16 @@ export class StatementParser extends SimpleStatementParser {
         const misplaced = this.isStateDeclaration() || this.isRefDeclaration()
             ? this.peek().text
             : this.isMountDeclaration()
-                ? 'mount()'
+                ? 'mount'
                 : this.isEffectDeclaration()
                     ? 'effect'
                     : null;
         if (misplaced !== null) {
             this.fail(this.context.inComponent
                 ? `${misplaced} is declared at the top level of a component, not inside blocks or functions`
-                : `${misplaced} can only be declared inside a component`);
+                : misplaced === 'state'
+                    ? 'state can only be declared inside a component or at the top level of a module'
+                    : `${misplaced} can only be declared inside a component`);
         }
         const statement = this.parseSimpleStatement();
         if (statement.kind === 'ExpressionStatement') {
@@ -106,7 +115,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);
             }
         }
@@ -123,7 +135,7 @@ export class StatementParser extends SimpleStatementParser {
                 return this.parseFuncDeclaration(start, exported);
             case 'async':
                 if (this.peek(1).kind === 'comp') {
-                    this.fail('a component cannot be async: load the data in mount() or in an async func');
+                    this.fail('a component cannot be async: load the data in mount or in an async func');
                 }
                 if (this.peek(1).kind !== 'func' || this.peek(2).kind !== 'Identifier')
                     return undefined;
@@ -151,10 +163,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. */
@@ -206,18 +225,23 @@ export class StatementParser extends SimpleStatementParser {
     isEffectDeclaration() {
         return this.checkWord('effect') && this.peek(1).kind === '{';
     }
-    /** `mount() {`: like `state`, a keyword only at the start of a statement in a component. */
+    /**
+     * `mount {`: like `state`, a keyword only at the start of a statement in a component. The old
+     * form `mount() {` is recognized too, so that parseMount can say how to write it now.
+     */
     isMountDeclaration() {
         return (this.checkWord('mount') &&
-            this.peek(1).kind === '(' &&
-            this.peek(2).kind === ')' &&
-            this.peek(3).kind === '{');
+            (this.peek(1).kind === '{' ||
+                (this.peek(1).kind === '(' && this.peek(2).kind === ')' && this.peek(3).kind === '{')));
     }
-    /** `mount() { ... }`; its body is a function that runs later, so `return` is its own. */
+    /** `mount { ... }`; its body is a function that runs later, so `return` is its own. */
     parseMount() {
         const { start } = this.next();
-        this.expect('(');
-        this.expect(')');
+        if (this.check('(')) {
+            const open = this.next();
+            const close = this.next();
+            this.error('mount has no parentheses, like effect: write mount { ... }', open.start, close.end);
+        }
         const body = this.withContext({ ...FUNCTION_BODY, inComponent: true }, () => this.parseBlock());
         return { kind: 'MountStatement', body, ...this.span(start) };
     }
@@ -237,26 +261,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[];