rooklang 0.3.3 → 0.3.4

package/dist/checker/types/params.js

@@ -1,6 +1,7 @@
 import { instanceMembers } from "./classes.js";
 import { arrayOf, func, nonNull, nullable, union } from "./constructors.js";
 import { instantiate } from "./generics.js";
+import { iteratedBy } from "./iterables.js";
 import { memberNames } from "./lazy.js";
 import { VOID, } from "./model.js";
 import { typesEqual } from "./relations.js";
@@ -45,7 +46,7 @@ export function substitute(type, bindings, fallback) {
         case 'param':
             return bindings.get(type) ?? fallback ?? type;
         case 'array':
-            return arrayOf(substitute(type.element, bindings, fallback));
+            return arrayOf(substitute(type.element, bindings, fallback), type.positions?.map((each) => substitute(each, bindings, fallback)));
         case 'nullable':
             return nullable(substitute(type.type, bindings, fallback));
         case 'union':
@@ -127,6 +128,8 @@ function substituteObject(type, bindings, fallback) {
     return { ...type, members, call: type.call && sub(type.call) };
 }
 const MAX_STRUCTURAL_DEPTH = 3;
+/** The names of the templates of channel types (checker/channel.ts). */
+const CHANNELS = new Set(['chan', 'chan<-', '<-chan']);
 /** Infers type parameters in `param` from the argument type `arg`. */
 export function inferTypeParams(param, arg, bindings, depth = 0) {
     if (!containsTypeParam(param))
@@ -139,8 +142,15 @@ export function inferTypeParams(param, arg, bindings, depth = 0) {
             }
             break;
         case 'array':
-            if (arg.kind === 'array')
+            // `[K, V]` from `["a", 1]`: each by its position; else the union of K and V would take all.
+            if (arg.kind === 'array' &&
+                param.positions?.length === arg.positions?.length &&
+                arg.positions) {
+                param.positions.forEach((each, i) => infer(each, arg.positions[i]));
+            }
+            else if (arg.kind === 'array') {
                 infer(param.element, arg.element);
+            }
             break;
         case 'nullable':
             infer(param.type, nonNull(arg));
@@ -171,12 +181,21 @@ export function inferTypeParams(param, arg, bindings, depth = 0) {
             }
             break;
         case 'object': {
+            // A channel of one direction from any channel: `chan<- T` from a `chan number`.
             if (param.instanceOf &&
                 arg.kind === 'object' &&
-                arg.instanceOf?.template === param.instanceOf.template) {
+                (arg.instanceOf?.template === param.instanceOf.template ||
+                    (CHANNELS.has(param.instanceOf.template.name ?? '') &&
+                        CHANNELS.has(arg.instanceOf?.template.name ?? '')))) {
                 param.instanceOf.args.forEach((each, i) => infer(each, arg.instanceOf.args[i]));
                 break;
             }
+            // `Iterable<T>` from `[]number` or a `Set<number>`: T is what `for` gives of it.
+            const values = param.iterates && iteratedBy(arg);
+            if (values) {
+                infer(param.iterates, values);
+                break;
+            }
             // Structurally: `{ value T }` from `{ value number }`. Types refer to themselves, and the
             // methods of generic interfaces give ever new instances (`then` of a promise gives a
             // promise), so only a few levels deep, as in TypeScript.

package/dist/checker/types/printing.js

@@ -2,6 +2,7 @@ import { TYPED_ARRAYS, typedArrayName } from "../../typed-arrays.js";
 import { ERROR_CLASS } from "./classes.js";
 import { nullable } from "./constructors.js";
 import { isQueue, queueElement } from "./queue.js";
+import { isTopic, topicElement } from "./topic.js";
 // Types as text, for messages.
 /** How deep object types without a name are printed with their members. */
 const MAX_OBJECT_DEPTH = 3;
@@ -60,10 +61,10 @@ export function typeToString(type) {
                 return `${type.name} ${typeToString(type.instanceOf.args[0])}`;
             }
             // `queue (string | number)`: the parentheses that the type is written with.
-            if (isQueue(type)) {
-                const element = queueElement(type);
+            if (isQueue(type) || isTopic(type)) {
+                const element = isQueue(type) ? queueElement(type) : topicElement(type);
                 const text = typeToString(element);
-                return `queue ${element.kind === 'union' && !element.name ? `(${text})` : text}`;
+                return `${type.name} ${element.kind === 'union' && !element.name ? `(${text})` : text}`;
             }
             if (type.instanceOf && type.name !== null) {
                 return `${type.name}<${type.instanceOf.args.map(typeToString).join(', ')}>`;

package/dist/checker/types/relations.js

@@ -1,9 +1,10 @@
 import { instanceMembers, isSubclass, publicMembers } from "./classes.js";
-import { memberNames } from "./lazy.js";
 import { isNullable, literalBase, nonNull, union } from "./constructors.js";
 import { UNKNOWN, VOID, } from "./model.js";
+import { indexAssignable, iterableAssignable, numberIndexAssignable } from "./iterables.js";
 import { typedArrayOf, typeToString } from "./printing.js";
 import { isQueue, queueElement } from "./queue.js";
+import { isTopic, topicElement } from "./topic.js";
 // Relations between types: assignability, comparison, equality, common types.
 /** Whether a value of type `source` can be used where `target` is expected. */
 export function isAssignable(source, target) {
@@ -80,6 +81,15 @@ export function assignable(source, target, assuming) {
             if (isQueue(target)) {
                 return isQueue(source) && assignable(queueElement(source), queueElement(target), nested);
             }
+            // A topic both sends and receives, so its values are the same both ways, as a channel's;
+            // `topic any` is any topic, for `close(t)`.
+            if (isTopic(target)) {
+                const element = topicElement(target);
+                return (isTopic(source) &&
+                    (element.kind === 'any' ||
+                        (assignable(topicElement(source), element, nested) &&
+                            assignable(element, topicElement(source), nested))));
+            }
             // A channel both takes and gives values, so `chan number` is not a `chan ?number`, as in Go;
             // `chan any` is any channel, for `close(ch)`. A `chan T` is also a channel of one
             // direction, `chan<- T` or `<-chan T`, but not the other way round.
@@ -106,6 +116,10 @@ export function assignable(source, target, assuming) {
                 if (source.kind === 'function')
                     return target.members.size === 0;
             }
+            // `Iterable<T>`: what `for` gives of the value fits.
+            const iterable = target.iterates && iterableAssignable(source, target, nested);
+            if (iterable !== undefined && iterable !== null)
+                return iterable;
             if (target.index && !indexAssignable(source, target.index, nested))
                 return false;
             if (target.numberIndex && !numberIndexAssignable(source, target.numberIndex, nested)) {
@@ -115,33 +129,12 @@ export function assignable(source, target, assuming) {
         }
     }
 }
-/** `{ [string]: T }` accepts an object whose own index and fields are all `T`. */
 /** The templates of channel types by name (channel.ts): no other type can have these names. */
 const CHAN_NAMES = new Map([
     ['chan', 'both'],
     ['chan<-', 'send'],
     ['<-chan', 'receive'],
 ]);
-function indexAssignable(source, index, assuming) {
-    if (source.kind !== 'object')
-        return false;
-    if (source.index && !assignable(source.index, index, assuming))
-        return false;
-    return [...memberNames(source.members)].every((name) => {
-        const member = source.members.get(name);
-        return !member || member.method || assignable(member.type, index, assuming);
-    });
-}
-/** `ArrayLike<T>` from a `.d.ts` accepts an array, a string or a typed array of `T`. */
-function numberIndexAssignable(source, index, assuming) {
-    if (source.kind === 'array')
-        return assignable(source.element, index, assuming);
-    if (source.kind === 'string')
-        return assignable(source, index, assuming);
-    return (source.kind === 'object' &&
-        source.numberIndex !== undefined &&
-        assignable(source.numberIndex, index, assuming));
-}
 function functionAssignable(source, target, assuming) {
     // An iterator is a JS generator: it does not take the callback that a function of its shape does.
     if (Boolean(source.iterator) !== Boolean(target.iterator))
@@ -211,7 +204,7 @@ export function explainMismatch(source, target) {
     if (source.kind === 'class' && target.kind === 'class' && source.info === target.info) {
         return null;
     }
-    if (isQueue(target))
+    if (isQueue(target) || isTopic(target))
         return null;
     const members = target.kind === 'object'
         ? target.members
@@ -296,9 +289,10 @@ export function hasZeroValue(type) {
         case 'any':
         case 'unknown':
             return true;
-        // An empty queue, as `[]` is the zero value of an array.
+        // An empty queue, as `[]` is the zero value of an array; Channel.EMPTY and Topic.EMPTY, which
+        // are closed.
         case 'object':
-            return isQueue(type);
+            return isQueue(type) || isTopic(type) || CHAN_NAMES.has(type.instanceOf?.template.name ?? '');
         default:
             return false;
     }

package/dist/checker/types/topic.d.ts

@@ -0,0 +1,6 @@
+import type { ObjectType, Type } from './model.ts';
+export declare function topicOf(element: Type): ObjectType;
+/** Whether a type is `topic T`. */
+export declare function isTopic(type: Type): boolean;
+/** The type of the values of a topic type. */
+export declare function topicElement(topic: Type): Type;

package/dist/checker/types/topic.js

@@ -0,0 +1,23 @@
+import { instantiate } from "./generics.js";
+// `topic T`, made by `topic<T>(name)`: values that go to the other tabs of a site over a
+// BroadcastChannel. A topic type is an instance of a generic object without members, as a channel
+// type is, written and printed by its own syntax; only a topic of the same values is assignable to
+// it (relations.ts), since a topic both sends and receives them.
+const TOPIC = {
+    kind: 'object',
+    name: 'topic',
+    members: new Map(),
+    call: null,
+    typeParams: [{ kind: 'param', name: 'T' }],
+};
+export function topicOf(element) {
+    return instantiate(TOPIC, [element]);
+}
+/** Whether a type is `topic T`. */
+export function isTopic(type) {
+    return type.kind === 'object' && type.instanceOf?.template === TOPIC;
+}
+/** The type of the values of a topic type. */
+export function topicElement(topic) {
+    return topic.instanceOf.args[0];
+}

package/dist/checker/types.d.ts

@@ -4,7 +4,9 @@ export * from './types/lazy.ts';
 export * from './types/generics.ts';
 export * from './types/classes.ts';
 export * from './types/relations.ts';
+export * from './types/iterables.ts';
 export * from './types/params.ts';
 export * from './types/printing.ts';
 export * from './types/bytes.ts';
 export * from './types/queue.ts';
+export * from './types/topic.ts';

package/dist/checker/types.js

@@ -5,7 +5,9 @@ export * from "./types/lazy.js";
 export * from "./types/generics.js";
 export * from "./types/classes.js";
 export * from "./types/relations.js";
+export * from "./types/iterables.js";
 export * from "./types/params.js";
 export * from "./types/printing.js";
 export * from "./types/bytes.js";
 export * from "./types/queue.js";
+export * from "./types/topic.js";

package/dist/cli.js

@@ -1,9 +1,6 @@
 #!/usr/bin/env node
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync, } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { spawnSync } from 'node:child_process';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
 import { parseArgs } from 'node:util';
 import { build, displayPath } from "./build.js";
 import { CompileError, compileFile } from "./compile-file.js";
@@ -11,6 +8,7 @@ import { markupFor } from "./config.js";
 import { formatDiagnostic } from "./diagnostics.js";
 import { tokenize } from "./lexer/lexer.js";
 import { parse } from "./parser/parser.js";
+import { runFile } from "./run-file.js";
 import { SourceFile } from "./source.js";
 const { version } = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
 const HELP = `Rook ${version}
@@ -25,6 +23,8 @@ Options:
       --out-dir <dir>   build: write the .js files to <dir>, keeping the folder structure
                         (by default they go next to the .rk files)
       --stdout          build: print the JS of a single file instead of writing files
+      --no-source-map   build: do not write the source maps, app.js.map
+      --watch           run: run again when a file of the program changes
       --no-check        Skip type checking
       --markup          Turn markup and components on; by default they are on where the
                         package.json has "rook": { "markup": true }
@@ -41,6 +41,8 @@ function main() {
             'out-dir': { type: 'string' },
             stdout: { type: 'boolean' },
             'no-check': { type: 'boolean' },
+            'no-source-map': { type: 'boolean' },
+            watch: { type: 'boolean' },
             markup: { type: 'boolean' },
             'no-markup': { type: 'boolean' },
             help: { type: 'boolean', short: 'h' },
@@ -81,11 +83,16 @@ function main() {
                 process.stdout.write(compileFile(file, { rewriteImports: true, typeCheck, markup }).code);
             }
             else {
-                buildFiles(files, { outDir: values['out-dir'], typeCheck, markup });
+                buildFiles(files, {
+                    outDir: values['out-dir'],
+                    typeCheck,
+                    markup,
+                    sourceMap: !values['no-source-map'],
+                });
             }
             break;
         case 'run':
-            process.exitCode = runFile(file, typeCheck, markup);
+            runFile(file, { typeCheck, markup, watch: values.watch === true });
             break;
         case 'tokens':
             printTokens(new SourceFile(file, readFileSync(file, 'utf8')));
@@ -113,44 +120,19 @@ function buildFiles(entries, options) {
         const messages = errors.flatMap(({ file, diagnostics }) => diagnostics.map((diagnostic) => formatDiagnostic(file, diagnostic)));
         throw new CompileError(messages.join('\n\n'));
     }
-    for (const { source, output, code, declarations, worker } of outputs) {
-        const extra = `${declarations ? ' + .d.ts' : ''}${worker ? ' + .worker.js' : ''}`;
+    for (const { source, output, code, declarations, worker, maps = [] } of outputs) {
+        const extra = `${declarations ? ' + .d.ts' : ''}${worker ? ' + .worker.js' : ''}${maps.length > 0 ? ' + .js.map' : ''}`;
         mkdirSync(dirname(output), { recursive: true });
         writeFileSync(output, code);
         if (declarations)
             writeFileSync(declarations.output, declarations.code);
         if (worker)
             writeFileSync(worker.output, worker.code);
+        for (const map of maps)
+            writeFileSync(map.output, map.code);
         console.log(`${displayPath(source)} → ${displayPath(output)}${extra}`);
     }
 }
-/**
- * Runs a program in a process of its own that imports loader.ts first: so do the worker threads
- * of its goroutines, which do not share the hooks of the thread that registers them. They take
- * the compiled code from a directory of the run, removed after it.
- */
-function runFile(file, typeCheck, markup) {
-    // The build rewrites the extensions of imports, not of these URLs: in the package they are .js.
-    const extension = import.meta.url.endsWith('.ts') ? '.ts' : '.js';
-    const loader = new URL(`./loader${extension}`, import.meta.url).href;
-    const run = fileURLToPath(new URL(`./run${extension}`, import.meta.url));
-    const cache = mkdtempSync(join(tmpdir(), 'rook-run-'));
-    try {
-        const { status, signal } = spawnSync(process.execPath, ['--import', loader, run, file], {
-            stdio: 'inherit',
-            env: {
-                ...process.env,
-                ROOK_RUN_CACHE: cache,
-                ...(typeCheck ? {} : { ROOK_NO_CHECK: '1' }),
-                ...(markup === undefined ? {} : { ROOK_MARKUP: markup ? '1' : '0' }),
-            },
-        });
-        return status ?? (signal ? 1 : 0);
-    }
-    finally {
-        rmSync(cache, { recursive: true, force: true });
-    }
-}
 function printTokens(file) {
     const { tokens, diagnostics } = tokenize(file.text);
     for (const token of tokens) {

package/dist/codegen/calls.d.ts

@@ -2,6 +2,12 @@ import type * as ast from '../ast.ts';
 import { ExpressionEmitter } from './expressions.ts';
 export declare abstract class CallEmitter extends ExpressionEmitter {
     protected call(node: ast.CallExpression): string;
+    /**
+     * `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.
+     */
+    protected go(node: ast.GoExpression): string;
     /** `yield v` for `yield(v)` in an iterator, `yield [k, v]` for `yield(k, v)`; else `null`. */
     private yielded;
     protected expressionStatement(node: ast.Expression): string;
@@ -23,6 +29,23 @@ export declare abstract class CallEmitter extends ExpressionEmitter {
     protected chan(node: ast.ChanExpression): string;
     /** `queue<number>(items)`: the queue copies the values, as `[...items]` would. */
     protected queue(node: ast.QueueExpression): string;
+    /** Whether the checker found a topic here, or a `?topic T` in a case of `select`. */
+    protected isTopicValue(node: ast.Expression): boolean;
+    /**
+     * 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).
+     */
+    protected receivedFrom(node: ast.Expression): string;
+    /**
+     * 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.
+     */
+    protected receivedZero(node: ast.Expression): string;
+    protected receive(node: ast.Expression, withOk: boolean): string;
+    /** `ch <- v` waits until the channel takes the value; a topic sends and goes on. */
+    protected send(node: ast.SendStatement): string;
+    /** `topic<T>(name)`: a topic keeps the zero value that a closed one gives, as a channel does. */
+    protected topic(node: ast.TopicExpression): string;
     /**
      * `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.

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

@@ -2,6 +2,13 @@ import type * as ast from '../ast.ts';
 import { SimpleStatementEmitter } from './simple-statements.ts';
 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 `;`. */
@@ -20,8 +27,9 @@ export declare abstract class ControlStatementEmitter extends SimpleStatementEmi
      * 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.
@@ -31,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;
 }