rooklang 0.3.2 → 0.3.4

package/dist/codegen/calls.js

@@ -1,4 +1,6 @@
-import { typedArrayOf } from "../checker/types.js";
+import { elementOf, isChan } from "../checker/channel.js";
+import { isNullable, isQueue, isTopic, nonNull, topicElement, typedArrayOf, } from "../checker/types.js";
+import { goCaptures, goParams, goTarget } from "../goroutines.js";
 import { isYieldCall } from "../iterators.js";
 import { TYPED_ARRAYS, TYPED_ELEMENTS } from "../typed-arrays.js";
 import { hasOptionalLink } from "./analysis.js";
@@ -8,21 +10,50 @@ import { ARROW, BINARY, POSTFIX } from "./syntax.js";
 // checker found one expected becomes `new Uint8Array([...])`, and the conversions of Go between
 // text and its UTF-8 bytes use TextEncoder and TextDecoder, `[]byte(s)` and `string(data)`. In an
 // iterator, a generator, `yield(v)` yields: its value is `true`, since a generator that the loop
-// over it leaves is closed at that `yield` and goes no further, so `false` is never seen.
+// over it leaves is closed at that `yield` and goes no further, so `false` is never seen. Making
+// channels, queues and topics is here too, with what a topic needs where it is received or closed.
 export class CallEmitter extends ExpressionEmitter {
     call(node) {
         // After `?.` the arguments may not be evaluated at all.
         const conditional = node.optional || hasOptionalLink(node.callee);
         const args = this.withHoisting(this.hoist && !conditional, () => this.elements(node.arguments));
-        if (this.isBuiltinError(node.callee) && !node.optional)
-            return `new Error(${args})`;
+        // `error("load user", err)` wraps an error, with its message after this one (runtime/core.js).
+        if (this.isBuiltinError(node.callee) && !node.optional) {
+            return node.arguments.length > 1 ? `$$wrap(${args})` : `new Error(${args})`;
+        }
         if (this.isStringConversion(node.callee))
             return `new TextDecoder().decode(${args})`;
         const yielded = this.yielded(node);
         if (yielded !== null)
             return `(${yielded}, true)`;
+        // `close(t)` of a topic: it stops listening and sending.
+        const [argument] = node.arguments;
+        if (node.callee.kind === 'Identifier' &&
+            node.callee.name === 'close' &&
+            this.lookup('close') === undefined &&
+            argument?.kind !== 'SpreadElement' &&
+            argument !== undefined &&
+            this.isTopicValue(argument)) {
+            return `$$Topic.close(${args})`;
+        }
         return `${this.expression(node.callee, POSTFIX)}${node.optional ? '?.' : ''}(${args})`;
     }
+    /**
+     * `go f(x)`: the worker module has the function under the same name, a literal under the name
+     * given to it, after the local names it uses; the arguments are copied there. In the worker
+     * module a literal runs in the same worker, with copies of those names as its first parameters.
+     */
+    go(node) {
+        const { callee } = node.call;
+        const literal = callee.kind === 'FuncExpression' ? callee : null;
+        const captured = literal ? goCaptures(this.program, node) : [];
+        const args = [...captured.map((name) => this.name(name)), this.elements(node.call.arguments)];
+        // Without type checking, a callee that is neither fails when the call runs.
+        const fn = literal && this.inWorker
+            ? this.expression({ ...literal, params: [...goParams(literal, captured), ...literal.params] }, ARROW)
+            : JSON.stringify(goTarget(this.program, node));
+        return `$$go(${fn}, [${args.filter((arg) => arg !== '').join(', ')}])`;
+    }
     /** `yield v` for `yield(v)` in an iterator, `yield [k, v]` for `yield(k, v)`; else `null`. */
     yielded(node) {
         if (!this.fn.iterator || !isYieldCall(node) || this.lookup('yield') !== 'param')
@@ -37,7 +68,8 @@ export class CallEmitter extends ExpressionEmitter {
     yieldStatement(node) {
         const [only] = node.consequent.body;
         const { condition } = node;
-        if (node.alternate ||
+        if (node.init ||
+            node.alternate ||
             node.consequent.body.length !== 1 ||
             only?.kind !== 'ReturnStatement' ||
             only.values.length > 0 ||
@@ -105,12 +137,55 @@ export class CallEmitter extends ExpressionEmitter {
     /** `chan<number>(10)`: the channel keeps the zero value that a closed one gives. */
     chan(node) {
         const size = node.size ? this.expression(node.size, ARROW) : '0';
-        return `$$chan(${size}, ${this.zeroValue(node.element) ?? 'null'})`;
+        return `$$Channel.make(${size}, ${this.zeroValue(node.element) ?? 'null'})`;
     }
     /** `queue<number>(items)`: the queue copies the values, as `[...items]` would. */
     queue(node) {
         return `new $$Queue(${node.items ? this.expression(node.items, ARROW) : ''})`;
     }
+    /** Whether the checker found a topic here, or a `?topic T` in a case of `select`. */
+    isTopicValue(node) {
+        const type = this.options.types?.get(node);
+        return type !== undefined && isTopic(isNullable(type) ? nonNull(type) : type);
+    }
+    /**
+     * The channel that `<-x`, `for v in x` and a case of `select` receive from: a topic listens from
+     * the first of them on, into a channel of its own (src/runtime/topic.js).
+     */
+    receivedFrom(node) {
+        const channel = this.expression(node, ARROW);
+        return this.isTopicValue(node) ? `$$Topic.listen(${channel})` : channel;
+    }
+    /**
+     * The zero value that `<-x` gives if `x` is `Channel.EMPTY` or `Topic.EMPTY`, which are the same
+     * for all types; any other channel keeps its own. `null` when it is null.
+     */
+    receivedZero(node) {
+        const type = this.options.types?.get(node);
+        const channel = type && (isNullable(type) ? nonNull(type) : type);
+        if (channel && isChan(channel))
+            return zeroOf(elementOf(channel));
+        if (channel && isTopic(channel))
+            return zeroOf(topicElement(channel));
+        return 'null';
+    }
+    receive(node, withOk) {
+        const zero = this.receivedZero(node);
+        const args = zero !== 'null' ? `, ${withOk}, ${zero}` : withOk ? ', true' : '';
+        return `$$Channel.receive(${this.receivedFrom(node)}${args})`;
+    }
+    /** `ch <- v` waits until the channel takes the value; a topic sends and goes on. */
+    send(node) {
+        const channel = this.expression(node.channel, ARROW);
+        const value = this.expression(node.value, ARROW);
+        return this.isTopicValue(node.channel)
+            ? `$$Topic.publish(${channel}, ${value})`
+            : `await $$Channel.send(${channel}, ${value})`;
+    }
+    /** `topic<T>(name)`: a topic keeps the zero value that a closed one gives, as a channel does. */
+    topic(node) {
+        return `$$Topic.make(${this.expression(node.name, ARROW)}, ${this.zeroValue(node.element) ?? 'null'})`;
+    }
     /**
      * `chan(stream, size)`: the channel keeps the zero value of its values, as `chan<T>(size)` does,
      * from the type of the stream that the checker found; without it, null.
@@ -121,7 +196,7 @@ export class CallEmitter extends ExpressionEmitter {
         const type = this.options.types?.get(node);
         const channel = type?.kind === 'tuple' ? type.types[0] : undefined;
         const element = channel?.kind === 'object' ? channel.instanceOf?.args[0] : undefined;
-        return `$$fromStream(${stream}, ${size}, ${element ? zeroOf(element) : 'null'})`;
+        return `$$Channel.fromStream(${stream}, ${size}, ${element ? zeroOf(element) : 'null'})`;
     }
 }
 /** The zero value of a type, as zeroValue gives for a type as written. */
@@ -140,6 +215,12 @@ function zeroOf(type) {
             return 'false';
         case 'array':
             return '[]';
+        case 'object':
+            if (isQueue(type))
+                return 'new $$Queue()';
+            if (isChan(type))
+                return '$$Channel.EMPTY';
+            return isTopic(type) ? '$$Topic.EMPTY' : 'null';
         default:
             return 'null';
     }

package/dist/codegen/control-statements.d.ts

@@ -1,8 +1,14 @@
 import type * as ast from '../ast.ts';
 import { SimpleStatementEmitter } from './simple-statements.ts';
-/** if, for, switch and try. */
 export declare abstract class ControlStatementEmitter extends SimpleStatementEmitter {
     protected ifStatement(node: ast.IfStatement): string;
+    /**
+     * `if const v = f(); v > 0 { }` → `{ const v = f(); if (v > 0) { } }`: a block keeps the
+     * variables of the initializer to the statement, which `emit` writes.
+     */
+    private withInit;
+    /** `outer: for (...)`: the label goes on the loop itself, after what is hoisted before it. */
+    private labeled;
     protected loopBody(body: ast.BlockStatement): string;
     protected forStatement(node: ast.ForStatement): void;
     /** A statement inside a `for` header, without the `;`. */
@@ -12,8 +18,18 @@ export declare abstract class ControlStatementEmitter extends SimpleStatementEmi
      * `for i, x in xs` iterates `xs.entries()`, which gives the keys and values of a Map too.
      */
     protected forInStatement(node: ast.ForInStatement): void;
+    /** `[i, v]` of a loop over pairs; `_` leaves its place empty. */
+    private pair;
+    /**
+     * `for i, v in items` over an array or a typed array: a loop over the indexes, which runs faster
+     * than one over the pairs of `entries()`. The variables of the loop cannot be assigned, so `i` is
+     * the counter itself. The array is read once, as `entries()` reads it, into `$$items` unless it is
+     * a name that cannot change.
+     */
+    private indexLoop;
+    protected switchStatement(node: ast.SwitchStatement): void;
     /** Each `case` ends with an implicit `break`; a case with declarations gets its own block. */
-    protected switchStatement(node: ast.SwitchStatement, discriminant: ast.Expression): void;
+    private valueSwitch;
     /**
      * `select`: $$select gives the index of the case that went on and what it received, and a
      * switch runs the case; a `break` inside it leaves the select, as in Go. `default` is -1.
@@ -23,6 +39,6 @@ export declare abstract class ControlStatementEmitter extends SimpleStatementEmi
      * `switch { case cond: ... }` becomes an if/else chain. A `break` inside it must leave the
      * switch, not an enclosing loop, so then the chain gets a label to break to.
      */
-    protected taglessSwitch(node: ast.SwitchStatement): void;
+    private taglessSwitch;
     protected tryStatement(node: ast.TryStatement): string;
 }

package/dist/codegen/control-statements.js

@@ -1,12 +1,19 @@
 import { isChan } from "../checker/channel.js";
-import { isMap } from "../checker/iterables.js";
-import { containsBreak } from "../walk.js";
+import { asyncIterated, isMap } from "../checker/iterables.js";
+import { isTopic, typedArrayOf } from "../checker/types.js";
+import { declaredIn } from "../names.js";
+import { containsBreak } from "../breaks.js";
 import { declarationsOf, endsWithJump } from "./analysis.js";
 import { SimpleStatementEmitter } from "./simple-statements.js";
 import { ARROW, BINARY, POSTFIX } from "./syntax.js";
 /** if, for, switch and try. */
+/** Names that keep their value, so a loop over the indexes may read the array through them. */
+const FIXED = new Set(['const', 'import', 'loop']);
 export class ControlStatementEmitter extends SimpleStatementEmitter {
     ifStatement(node) {
+        const { init } = node;
+        if (init)
+            return this.withInit(init, () => this.line(this.ifStatement({ ...node, init: null })));
         let text = `if (${this.expression(node.condition, 0)}) ${this.blockStatement(node.consequent)}`;
         if (node.alternate?.kind === 'IfStatement') {
             // The condition of `else if` is evaluated only when the first one is false.
@@ -18,6 +25,20 @@ export class ControlStatementEmitter extends SimpleStatementEmitter {
         }
         return text;
     }
+    /**
+     * `if const v = f(); v > 0 { }` → `{ const v = f(); if (v > 0) { } }`: a block keeps the
+     * variables of the initializer to the statement, which `emit` writes.
+     */
+    withInit(init, emit) {
+        return this.block(() => this.withScope(declarationsOf([init]), () => {
+            this.statement(init);
+            this.withHoisting(true, emit);
+        }));
+    }
+    /** `outer: for (...)`: the label goes on the loop itself, after what is hoisted before it. */
+    labeled(node, text) {
+        return node.label ? `${this.label(node.label)}: ${text}` : text;
+    }
     loopBody(body) {
         return this.withBreakTarget(null, () => this.blockStatement(body));
     }
@@ -33,10 +54,10 @@ export class ControlStatementEmitter extends SimpleStatementEmitter {
                 node.update ? this.simpleStatement(node.update) : '',
             ]);
             if (node.init === null && node.update === null) {
-                this.line(`while (${condition || 'true'}) ${this.loopBody(node.body)}`);
+                this.line(this.labeled(node, `while (${condition || 'true'}) ${this.loopBody(node.body)}`));
                 return;
             }
-            this.line(`for (${init}; ${condition}; ${update}) ${this.loopBody(node.body)}`);
+            this.line(this.labeled(node, `for (${init}; ${condition}; ${update}) ${this.loopBody(node.body)}`));
         });
     }
     /** A statement inside a `for` header, without the `;`. */
@@ -53,7 +74,7 @@ export class ControlStatementEmitter extends SimpleStatementEmitter {
             case 'ExpressionStatement':
                 return this.expression(node.expression, 0);
             case 'SendStatement':
-                return `await $$send(${this.expression(node.channel, ARROW)}, ${this.expression(node.value, ARROW)})`;
+                return this.send(node);
         }
     }
     /**
@@ -68,9 +89,14 @@ export class ControlStatementEmitter extends SimpleStatementEmitter {
             const value = this.name(node.value.name);
             const iterable = this.options.types?.get(node.iterable);
             let head;
-            // A channel gives its values as they come, until it is closed.
-            if (iterable && isChan(iterable)) {
-                this.line(`for await (const ${value} of $$range(${this.expression(node.iterable, ARROW)})) ${this.loopBody(node.body)}`);
+            // An async iterable, such as a stream of Node, gives its values as their Promises do.
+            if (iterable && asyncIterated(iterable) !== null) {
+                this.line(this.labeled(node, `for await (const ${value} of ${this.expression(node.iterable, POSTFIX)}) ${this.loopBody(node.body)}`));
+                return;
+            }
+            // A channel gives its values as they come, until it is closed, and so does a topic.
+            if (iterable && (isChan(iterable) || isTopic(iterable))) {
+                this.line(this.labeled(node, `for await (const ${value} of $$Channel.range(${this.receivedFrom(node.iterable)})) ${this.loopBody(node.body)}`));
                 return;
             }
             // An iterator is a generator function: called, it gives a lazy JS iterator, of pairs if its
@@ -94,16 +120,70 @@ export class ControlStatementEmitter extends SimpleStatementEmitter {
                 }
                 head = `const ${value} of ${values}`;
             }
+            else if (iterable &&
+                (iterable.kind === 'array' || iterable.kind === 'string' || typedArrayOf(iterable) !== null)) {
+                // Without the index, the loop goes over the values.
+                if (node.key.name === '_' && node.value.name !== '_') {
+                    head = `const ${value} of ${this.expression(node.iterable, POSTFIX)}`;
+                }
+                else if (iterable.kind === 'string') {
+                    // A string has no entries(): its characters, as `for...of` gives them, are numbered.
+                    const pair = this.pair(node.key, node.value);
+                    head = `const ${pair} of Array.from(${this.expression(node.iterable, ARROW)}).entries()`;
+                }
+                else {
+                    this.indexLoop(node, node.key);
+                    return;
+                }
+            }
             else {
-                const key = node.key.name === '_' ? '' : this.name(node.key.name);
-                const pair = node.value.name === '_' ? `[${key}]` : `[${key}, ${value}]`;
-                head = `const ${pair} of ${this.expression(node.iterable, POSTFIX)}.entries()`;
+                head = `const ${this.pair(node.key, node.value)} of ${this.expression(node.iterable, POSTFIX)}.entries()`;
             }
-            this.line(`for (${head}) ${this.loopBody(node.body)}`);
+            this.line(this.labeled(node, `for (${head}) ${this.loopBody(node.body)}`));
         });
     }
+    /** `[i, v]` of a loop over pairs; `_` leaves its place empty. */
+    pair(key, value) {
+        const name = key.name === '_' ? '' : this.name(key.name);
+        return value.name === '_' ? `[${name}]` : `[${name}, ${this.name(value.name)}]`;
+    }
+    /**
+     * `for i, v in items` over an array or a typed array: a loop over the indexes, which runs faster
+     * than one over the pairs of `entries()`. The variables of the loop cannot be assigned, so `i` is
+     * the counter itself. The array is read once, as `entries()` reads it, into `$$items` unless it is
+     * a name that cannot change.
+     */
+    indexLoop(node, keyNode) {
+        const key = keyNode.name === '_' ? '$$i' : this.name(keyNode.name);
+        const value = node.value.name === '_' ? null : this.name(node.value.name);
+        const { iterable } = node;
+        const fixed = iterable.kind === 'Identifier' && FIXED.has(this.lookup(iterable.name) ?? 'let');
+        const items = fixed ? this.expression(iterable, POSTFIX) : '$$items';
+        const init = fixed ? '' : `, $$items = ${this.expression(iterable, ARROW)}`;
+        // A declaration of the same name in the body would clash with the element's in one block.
+        const hidden = declaredIn(node.body.body).some((name) => name === keyNode.name || name === node.value.name);
+        const body = this.withBreakTarget(null, () => this.block(() => {
+            if (value !== null)
+                this.line(`const ${value} = ${items}[${key}];`);
+            if (hidden)
+                this.line(this.blockStatement(node.body));
+            else
+                this.blockStatements(node.body.body);
+        }));
+        this.line(this.labeled(node, `for (let ${key} = 0${init}; ${key} < ${items}.length; ${key}++) ${body}`));
+    }
+    switchStatement(node) {
+        const { init, discriminant } = node;
+        if (init) {
+            this.line(this.withInit(init, () => this.switchStatement({ ...node, init: null })));
+        }
+        else if (discriminant === null)
+            this.taglessSwitch(node);
+        else
+            this.valueSwitch(node, discriminant);
+    }
     /** Each `case` ends with an implicit `break`; a case with declarations gets its own block. */
-    switchStatement(node, discriminant) {
+    valueSwitch(node, discriminant) {
         const head = `switch (${this.expression(discriminant, 0)})`;
         const body = this.withBreakTarget(null, () => this.block(() => {
             node.cases.forEach((switchCase, i) => {
@@ -130,7 +210,7 @@ export class ControlStatementEmitter extends SimpleStatementEmitter {
                 }
             });
         }));
-        this.line(`${head} ${body}`);
+        this.line(this.labeled(node, `${head} ${body}`));
     }
     /**
      * `select`: $$select gives the index of the case that went on and what it received, and a
@@ -141,7 +221,10 @@ export class ControlStatementEmitter extends SimpleStatementEmitter {
             if (operation === null)
                 return [];
             if (operation.kind === 'UnaryExpression') {
-                return [`{ channel: ${this.expression(operation.argument, ARROW)} }`];
+                const zero = this.receivedZero(operation.argument);
+                return [
+                    `{ channel: ${this.receivedFrom(operation.argument)}${zero !== 'null' ? `, zero: ${zero}` : ''} }`,
+                ];
             }
             const channel = this.expression(operation.channel, ARROW);
             return [`{ channel: ${channel}, value: ${this.expression(operation.value, ARROW)} }`];
@@ -149,7 +232,7 @@ export class ControlStatementEmitter extends SimpleStatementEmitter {
         const hasDefault = node.cases.some((selectCase) => selectCase.operation === null);
         let index = 0;
         const select = this.block(() => {
-            this.line(`const [$$case, $$received, $$ok] = await $$select([${operations.join(', ')}], ${hasDefault});`);
+            this.line(`const [$$case, $$received, $$ok] = await $$Channel.select([${operations.join(', ')}], ${hasDefault});`);
             const body = this.withBreakTarget(null, () => this.block(() => {
                 for (const { names, operation, body: statements } of node.cases) {
                     const label = operation === null ? 'default:' : `case ${index++}:`;
@@ -175,7 +258,7 @@ export class ControlStatementEmitter extends SimpleStatementEmitter {
             }));
             this.line(`switch ($$case) ${body}`);
         });
-        this.line(select);
+        this.line(this.labeled(node, select));
     }
     /**
      * `switch { case cond: ... }` becomes an if/else chain. A `break` inside it must leave the
@@ -184,9 +267,11 @@ export class ControlStatementEmitter extends SimpleStatementEmitter {
     taglessSwitch(node) {
         const cases = node.cases.filter((switchCase) => switchCase.tests.length > 0);
         const fallback = node.cases.find((switchCase) => switchCase.tests.length === 0);
-        const label = node.cases.some((switchCase) => containsBreak(switchCase.body))
-            ? `$$switch${++this.labels}`
-            : null;
+        const label = node.label
+            ? this.label(node.label)
+            : node.cases.some((switchCase) => containsBreak(switchCase.body))
+                ? `$$switch${++this.labels}`
+                : null;
         const text = this.withBreakTarget(label, () => {
             const caseBlock = (body) => this.block(() => this.blockStatements(body));
             const branches = cases.map((switchCase) => {

package/dist/codegen/decode.d.ts

@@ -0,0 +1,14 @@
+import type * as ast from '../ast.ts';
+import { CallEmitter } from './calls.ts';
+export declare abstract class DecodeEmitter extends CallEmitter {
+    /** The constants of the object types that decode checks against, by type, in order. */
+    private readonly decodeTypes;
+    /** `$$decodeJson(text, type)` for a string, `$$decode(value, type)` for a value from JS. */
+    protected decode(node: ast.DecodeExpression): string;
+    /** The constants of the object types, for the start of the module. */
+    protected decodeTypeLines(): string[];
+    /** A type as runtime/decode.js has it: `"string"`, `{ array: "number" }`, `$$typeUser`. */
+    private shape;
+    /** The constant of an object type, made the first time it is used. */
+    private objectType;
+}

package/dist/codegen/decode.js

@@ -0,0 +1,93 @@
+import { isText } from "../checker/json.js";
+import { memberNames, typeToString } from "../checker/types.js";
+import { CallEmitter } from "./calls.js";
+import { ARROW } from "./syntax.js";
+// `decode<User>(body)`: the type, which the checker found, becomes data that the runtime checks the
+// value against (runtime/decode.js). An object type is a constant of the module, `$$typeUser`,
+// written before its code (js.ts), so that types that refer to themselves or each other can do so,
+// and the value of each call is only its name: `$$decodeJson(body, $$typeUser)`.
+const IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+export class DecodeEmitter extends CallEmitter {
+    /** The constants of the object types that decode checks against, by type, in order. */
+    decodeTypes = new Map();
+    /** `$$decodeJson(text, type)` for a string, `$$decode(value, type)` for a value from JS. */
+    decode(node) {
+        const argument = this.expression(node.argument, ARROW);
+        const result = this.options.types?.get(node);
+        const type = result?.kind === 'tuple' ? result.types[0] : undefined;
+        // Without the types of the checker nothing is checked (runtime/decode.js).
+        if (type === undefined)
+            return `$$decode(${argument}, null)`;
+        const given = this.options.types?.get(node.argument);
+        const decode = given !== undefined && isText(given) ? '$$decodeJson' : '$$decode';
+        return `${decode}(${argument}, ${this.shape(type)})`;
+    }
+    /** The constants of the object types, for the start of the module. */
+    decodeTypeLines() {
+        return [...this.decodeTypes.values()].flatMap(({ lines }) => lines);
+    }
+    /** A type as runtime/decode.js has it: `"string"`, `{ array: "number" }`, `$$typeUser`. */
+    shape(type) {
+        switch (type.kind) {
+            case 'number':
+            case 'string':
+            case 'bool':
+            case 'any':
+                return `"${type.kind}"`;
+            case 'null':
+                return '{ literal: [null] }';
+            case 'literal':
+                return `{ literal: [${JSON.stringify(type.value)}] }`;
+            case 'nullable':
+                return `{ nullable: ${this.shape(type.type)} }`;
+            case 'array':
+                return `{ array: ${this.shape(type.element)} }`;
+            case 'union': {
+                // The literals of a union are one list, as `"admin" | "user"` reads.
+                const literals = type.types.flatMap((each) => each.kind === 'literal' ? [each.value] : []);
+                const others = type.types.filter((each) => each.kind !== 'literal');
+                const shapes = [
+                    ...(literals.length > 0 ? [`{ literal: [${literals.map(json).join(', ')}] }`] : []),
+                    ...others.map((each) => this.shape(each)),
+                ];
+                return shapes.length === 1 ? shapes[0] : `{ union: [${shapes.join(', ')}] }`;
+            }
+            case 'object':
+                return type.index && [...memberNames(type.members)].length === 0
+                    ? `{ record: ${this.shape(type.index)} }`
+                    : this.objectType(type);
+            // The checker lets no other type through.
+            default:
+                return '"any"';
+        }
+    }
+    /** The constant of an object type, made the first time it is used. */
+    objectType(type) {
+        const known = this.decodeTypes.get(type);
+        if (known)
+            return known.name;
+        // `$$type` itself is the function of the runtime that makes them.
+        const written = type.instanceOf?.template.name ?? type.name ?? 'Object';
+        const base = `$$type${written.replace(/[^\w$]/g, '')}`;
+        const taken = new Set([...this.decodeTypes.values()].map(({ name }) => name));
+        let name = base;
+        for (let i = 2; taken.has(name); i++)
+            name = `${base}${i}`;
+        const entry = { name, lines: [] };
+        // Registered before its fields, which may refer to it.
+        this.decodeTypes.set(type, entry);
+        const fields = [...memberNames(type.members)].flatMap((field) => {
+            const member = type.members.get(field);
+            const key = IDENTIFIER.test(field) ? field : json(field);
+            return member ? [`  ${key}: ${this.shape(member.type)},`] : [];
+        });
+        entry.lines =
+            fields.length === 0
+                ? [`const ${name} = $$type(${json(typeToString(type))}, () => ({}));`]
+                : [`const ${name} = $$type(${json(typeToString(type))}, () => ({`, ...fields, '}));'];
+        return name;
+    }
+}
+function json(value) {
+    return JSON.stringify(value);
+}

package/dist/codegen/emitter.d.ts

@@ -1,42 +1,8 @@
 import type * as ast from '../ast.ts';
-import type { Type } from '../checker/types.ts';
-import { type DecoratorSource } from '../decorators.ts';
-import type { InlinePackage } from '../inline-packages.ts';
-import { type ImportedComponent, type LocalizedPackage } from './imported.ts';
+import { type LocalizedPackage } from './imported.ts';
 import type { Root } from '../refs.ts';
-import type { StyleModule } from '../style-modules.ts';
 import type { BindingKind } from './analysis.ts';
-import type { RuntimeMode } from './runtime.ts';
-export interface JsOptions {
-    /** The Rook source, used to keep the blank lines between statements. */
-    source: string;
-    /** Replace `.rk` with `.js` in relative import paths, for output written next to the sources. */
-    rewriteImports: boolean;
-    /** Types from the checker, when it ran; without them the generated code is more general. */
-    types?: WeakMap<ast.Expression, Type> | undefined;
-    /** Decorators imported from other modules, by name: their code is inlined here. */
-    decorators?: ReadonlyMap<string, ImportedDecorator> | undefined;
-    /** Components imported from other modules, by name: called, or inlined when they are small. */
-    components?: ReadonlyMap<string, ImportedComponent> | undefined;
-    /** Components of the module that become functions, since inlining them adds too many lines. */
-    functions?: ReadonlySet<string> | undefined;
-    /** The CSS modules the module imports, by their paths as written. */
-    styleModules?: ReadonlyMap<string, StyleModule> | undefined;
-    /** For `go`: where the worker module is (`./app.worker.js`), or in it, the functions it runs. */
-    goroutines?: {
-        workerUrl: string;
-    } | {
-        targets: readonly string[];
-    } | undefined;
-    /** How the module gets the runtime it uses: imported, by default, or in it (runtime.ts). */
-    runtime?: RuntimeMode | undefined;
-}
-/** A decorator of another module, with the types of the expressions of that module. */
-export interface ImportedDecorator extends DecoratorSource {
-    types: WeakMap<ast.Expression, Type> | null;
-    /** The components of that module its code uses, which go with it into the components here. */
-    inline: InlinePackage | null;
-}
+import type { JsOptions } from './options.ts';
 /** How a function implements its `defer` statements. */
 export type DeferMode = 'none' | 'try' | 'stack' | 'effect';
 interface FunctionContext {
@@ -54,10 +20,11 @@ interface FunctionContext {
  * The base of the JS generator: the output buffer, scopes of declared names and the state of the
  * current function. The generator is split into layers, each adding to the previous one:
  *
- *     Emitter → ExpressionEmitter → CallEmitter → SimpleStatementEmitter → ControlStatementEmitter
- *       → ParallelLoopEmitter → StatementEmitter → UpdateEmitter → AttributeEmitter
- *       → CreationEmitter → ElementEmitter → ControlFlowEmitter → ComponentPropsEmitter
- *       → ComponentValueEmitter → EarlyReturnEmitter → RefEmitter
+ *     Emitter → ExpressionEmitter → CallEmitter → DecodeEmitter → TryEmitter
+ *       → SimpleStatementEmitter → ControlStatementEmitter → ParallelLoopEmitter
+ *       → StatementEmitter → UpdateEmitter → AttributeEmitter → CreationEmitter → ElementEmitter
+ *       → ControlFlowEmitter → ComponentPropsEmitter → ComponentValueEmitter
+ *       → EarlyReturnEmitter → RefEmitter
  *       → StyleEmitter → ComponentEmitter → WebComponentEmitter → FunctionEmitter → JsGenerator
  */
 export declare abstract class Emitter {
@@ -100,7 +67,7 @@ export declare abstract class Emitter {
     /** The decorators that components of the module apply, by name. */
     protected readonly appliedDecorators: Set<string>;
     /** Copies of the code of other modules: their positions are in the sources of those. */
-    private readonly foreign;
+    protected readonly foreign: WeakSet<ast.Node>;
     /** Components of other modules inlined here, by name, with what their packages bring. */
     protected readonly inlinedImports: Map<string, LocalizedPackage>;
     /** The components that decorators of other modules bring, by the names of the decorators. */
@@ -123,6 +90,8 @@ export declare abstract class Emitter {
     protected lookup(name: string): BindingKind | undefined;
     /** The JS name for a Rook name. */
     protected name(name: string): string;
+    /** Labels are names of their own in JS, which cannot be reserved words either. */
+    protected label(name: ast.Identifier): string;
     protected params(params: ast.Parameter[]): string;
     protected withFunction<T>(mode: DeferMode, params: ast.Parameter[], emit: () => T): T;
     protected withHoisting<T>(hoist: boolean, emit: () => T): T;

package/dist/codegen/emitter.js

@@ -9,10 +9,11 @@ import { JS_RESERVED, JS_UNDECLARABLE } from "./syntax.js";
  * The base of the JS generator: the output buffer, scopes of declared names and the state of the
  * current function. The generator is split into layers, each adding to the previous one:
  *
- *     Emitter → ExpressionEmitter → CallEmitter → SimpleStatementEmitter → ControlStatementEmitter
- *       → ParallelLoopEmitter → StatementEmitter → UpdateEmitter → AttributeEmitter
- *       → CreationEmitter → ElementEmitter → ControlFlowEmitter → ComponentPropsEmitter
- *       → ComponentValueEmitter → EarlyReturnEmitter → RefEmitter
+ *     Emitter → ExpressionEmitter → CallEmitter → DecodeEmitter → TryEmitter
+ *       → SimpleStatementEmitter → ControlStatementEmitter → ParallelLoopEmitter
+ *       → StatementEmitter → UpdateEmitter → AttributeEmitter → CreationEmitter → ElementEmitter
+ *       → ControlFlowEmitter → ComponentPropsEmitter → ComponentValueEmitter
+ *       → EarlyReturnEmitter → RefEmitter
  *       → StyleEmitter → ComponentEmitter → WebComponentEmitter → FunctionEmitter → JsGenerator
  */
 export class Emitter {
@@ -250,6 +251,10 @@ export class Emitter {
         const rename = JS_RESERVED.has(name) || (JS_UNDECLARABLE.has(name) && this.lookup(name) !== undefined);
         return rename ? `${name}$` : name;
     }
+    /** Labels are names of their own in JS, which cannot be reserved words either. */
+    label(name) {
+        return JS_RESERVED.has(name.name) ? `${name.name}$` : name.name;
+    }
     params(params) {
         // Several `_` parameters would be duplicate names in JS.
         const blanks = params.filter((param) => param.name.name === '_').length;

package/dist/codegen/expressions.d.ts

@@ -21,6 +21,15 @@ export declare abstract class ExpressionEmitter extends Emitter {
     protected abstract chan(node: ast.ChanExpression): string;
     protected abstract streamChan(node: ast.StreamChanExpression): string;
     protected abstract queue(node: ast.QueueExpression): string;
+    protected abstract topic(node: ast.TopicExpression): string;
+    /** `go f(x)`; implemented by CallEmitter. */
+    protected abstract go(node: ast.GoExpression): string;
+    /** `decode<T>(x)`; implemented by DecodeEmitter. */
+    protected abstract decode(node: ast.DecodeExpression): string;
+    /** `try x`, with the precedence of its code; implemented by TryEmitter. */
+    protected abstract tryValue(node: ast.TryExpression): [string, number];
+    /** `<-x` without its `await`; implemented by CallEmitter. */
+    protected abstract receive(node: ast.Expression, withOk: boolean): string;
     /** `<-ch` that gives `[value, ok]`, in `v, ok = <-ch`. */
     protected readonly commaOk: WeakSet<ast.Expression>;
     /** `items[i]` in a part of `go for`, which is `items[$$i]` there (parallel.ts). */