rooklang 0.3.2 → 0.3.4

package/dist/checker/try.js

@@ -0,0 +1,19 @@
+import { DecodeChecker } from "./decode.js";
+import { isErrorType } from "./error-results.js";
+import { ERROR } from "./types.js";
+// `try expr`: an exception in the expression, or a rejected Promise that an `await` in it waits
+// for, becomes an error, as if the expression returned it (codegen/try.ts): `try JSON.parse(text)`
+// gives `(any, error)`, `try save()` of a function without results gives the error alone, and of
+// `(User, error)` the exception is one more way to get that error.
+export class TryChecker extends DecodeChecker {
+    checkTryExpression(node) {
+        const type = this.checkExpression(node.argument, null);
+        if (type.kind === 'void' || isErrorType(type))
+            return ERROR;
+        if (type.kind !== 'tuple')
+            return { kind: 'tuple', types: [type, ERROR] };
+        return isErrorType(type.types.at(-1))
+            ? type
+            : { kind: 'tuple', types: [...type.types, ERROR] };
+    }
+}

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

@@ -1,5 +1,5 @@
 import { type ArrayType, type ClassInfo, type FunctionType, type LiteralType, type Member, type Type, type TypeParam } from './model.ts';
-export declare function arrayOf(element: Type): ArrayType;
+export declare function arrayOf(element: Type, positions?: Type[]): ArrayType;
 export declare function nullable(type: Type): Type;
 export declare function literal(value: string | number | boolean): LiteralType;
 /** The type that a literal belongs to: `"all"` → `string`. */

package/dist/checker/types/constructors.js

@@ -1,8 +1,8 @@
 import { BOOL, NEVER, NULL, NUMBER, STRING, } from "./model.js";
 import { typesEqual } from "./relations.js";
 // Making types: arrays, nullable types, literals, unions, functions, members, classes.
-export function arrayOf(element) {
-    return { kind: 'array', element };
+export function arrayOf(element, positions) {
+    return positions ? { kind: 'array', element, positions } : { kind: 'array', element };
 }
 export function nullable(type) {
     switch (type.kind) {

package/dist/checker/types/generics.js

@@ -43,7 +43,7 @@ export function instantiate(template, args) {
     }
     // The indexes and the values of a loop, substituted when first used: the template of a
     // `.d.ts` may get them after its instances.
-    for (const key of ['index', 'numberIndex', 'iterates']) {
+    for (const key of ['index', 'numberIndex', 'iterates', 'asyncIterates']) {
         let substituted;
         Object.defineProperty(instance, key, {
             enumerable: true,

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

@@ -0,0 +1,13 @@
+import { type ObjectType, type Type } from './model.ts';
+/** The values that `for` gives of a type it goes over at once, or null. */
+export declare function iteratedBy(type: Type): Type | null;
+/**
+ * Whether `source` fits `Iterable<T>` or another interface that `for` goes over: its values must
+ * fit. An array or a string, which have no members here, fits one whose members may be left out;
+ * an object goes on to the check of its members (null).
+ */
+export declare function iterableAssignable(source: Type, target: ObjectType, assuming: [Type, Type][]): boolean | null;
+/** `{ [string]: T }` accepts an object whose own index and fields are all `T`. */
+export declare function indexAssignable(source: Type, index: Type, assuming: [Type, Type][]): boolean;
+/** `ArrayLike<T>` from a `.d.ts` accepts an array, a string or a typed array of `T`. */
+export declare function numberIndexAssignable(source: Type, index: Type, assuming: [Type, Type][]): boolean;

package/dist/checker/types/iterables.js

@@ -0,0 +1,52 @@
+import { isNullable } from "./constructors.js";
+import { memberNames } from "./lazy.js";
+import { STRING } from "./model.js";
+import { assignable } from "./relations.js";
+// What types from a `.d.ts` that are gone over or indexed accept: `Iterable<T>` takes what `for`
+// goes over with values that fit, an array or a Set; `{ [string]: T }` an object of fields of `T`;
+// `ArrayLike<T>` an array, a string or a typed array.
+/** The values that `for` gives of a type it goes over at once, or null. */
+export function iteratedBy(type) {
+    if (type.kind === 'array')
+        return type.element;
+    if (type.kind === 'string')
+        return STRING;
+    return type.kind === 'object' ? (type.iterates ?? null) : null;
+}
+/**
+ * Whether `source` fits `Iterable<T>` or another interface that `for` goes over: its values must
+ * fit. An array or a string, which have no members here, fits one whose members may be left out;
+ * an object goes on to the check of its members (null).
+ */
+export function iterableAssignable(source, target, assuming) {
+    const values = iteratedBy(source);
+    if (values === null || !assignable(values, target.iterates, assuming))
+        return values === null ? null : false;
+    if (source.kind === 'object')
+        return null;
+    return [...memberNames(target.members)].every((name) => {
+        const member = target.members.get(name);
+        return !member || (!member.method && isNullable(member.type));
+    });
+}
+/** `{ [string]: T }` accepts an object whose own index and fields are all `T`. */
+export 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`. */
+export 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));
+}

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

@@ -22,6 +22,11 @@ export declare const UNKNOWN: SimpleType;
 export interface ArrayType {
     kind: 'array';
     element: Type;
+    /**
+     * The types by position of a tuple of a `.d.ts`, `[K, V]`, or of an array literal: only for
+     * inferring type parameters, since the array may change. `element` is the union of them.
+     */
+    positions?: Type[];
 }
 /** `?T`; the inner type itself is never nullable. */
 export interface NullableType {
@@ -66,6 +71,15 @@ export interface Member {
     visibility: Visibility;
     /** The class that declares the member, for visibility checks. */
     owner: ClassInfo | null;
+    /** `readonly id string`: only its value and the constructor of its class assign it. */
+    readonly?: true;
+    /**
+     * A getter, a setter or both, as in `get area() number`: the member is a value of its type, which
+     * a getter alone cannot be assigned and a setter alone cannot be read.
+     */
+    accessor?: 'get' | 'set' | 'both';
+    /** `abstract area() number`: a subclass that is not abstract implements it. */
+    abstract?: true;
 }
 /** Interfaces, object type literals and the types of object literals. */
 export interface ObjectType {
@@ -82,6 +96,8 @@ export interface ObjectType {
     numberIndex?: Type;
     /** What `for v in x` gives: the values of `[Symbol.iterator]()` in a `.d.ts`. */
     iterates?: Type;
+    /** What `for v in x` waits for: the values of `[Symbol.asyncIterator]()`, as of a Node stream. */
+    asyncIterates?: Type;
     /** A generic interface, `interface Box<T>`: its members use these parameters. */
     typeParams?: TypeParam[];
     /** `Box<number>`: the generic interface and the type arguments it was made from. */
@@ -105,6 +121,15 @@ export interface ClassInfo {
     /** Type arguments for a generic base class: the defaults of a class from a `.d.ts`. */
     superArgs?: Type[];
     ctorVisibility: Visibility;
+    /** `abstract class Shape`: `new` makes only instances of its subclasses. */
+    abstract?: boolean;
+    /**
+     * `data class Point`: its fields are data, and its instances go to other threads with their
+     * class. False for the other classes of Rook; not set for those of a `.d.ts`.
+     */
+    data?: boolean;
+    /** What `for v in x` waits for: the values of `[Symbol.asyncIterator]()` in a `.d.ts`. */
+    asyncIterates?: Type;
     instance: ClassType;
     value: ClassValueType;
 }

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.