rooklang 0.0.0-stage → 0.3.0

package/dist/checker/helpers.d.ts

@@ -0,0 +1,35 @@
+import type * as ast from '../ast.ts';
+import { type FunctionType, type Type } from './types.ts';
+import type { Scope } from './context.ts';
+import { type Binding } from './context.ts';
+/** A binding as seen from a scope and its parents. */
+export declare function lookupIn(scope: Scope, name: string): Binding | undefined;
+/** Return and defer statements of a body, not counting those of nested functions. */
+export declare function ownStatements(body: ast.BlockStatement): ast.Statement[];
+/**
+ * Values that can be element children: text, numbers (literal types included), nodes (`node` is
+ * the type of a DOM node), lists of them, or null.
+ */
+export declare function isContent(given: Type, node: Type): boolean;
+/** Values that setAttribute accepts: text, numbers, bools, or null to leave it out. */
+export declare function isAttributeValue(type: Type): boolean;
+export declare function isUntyped(type: Type): boolean;
+export declare function isNumeric(type: Type): boolean;
+/**
+ * What `x instanceof C` makes `x`: an instance of a class, or of a constructor from a `.d.ts`,
+ * like `HTMLInputElement` (`declare var HTMLInputElement: { prototype: ...; new(): ... }`).
+ */
+export declare function instanceTypeOf(type: Type): Type | null;
+/** A function and its overloads, in the order they are declared. */
+export declare function signaturesOf(signature: FunctionType): FunctionType[];
+export declare function callSignature(type: Type): FunctionType | null;
+/** Whether the expected type has literal members: then a literal gets a literal type. */
+export declare function expectsLiteral(expected: Type | null): boolean;
+export declare function countValues(count: number): string;
+/** A call, or `await` of a call or of `go`: it may give several values. */
+export declare function isCall(node: ast.Expression): boolean;
+/** How to name an expression in messages: `divide()`, `stats.minMax()`, or `this expression`. */
+export declare function callName(node: ast.Expression): string;
+export declare function isSuperCall(statement: ast.Statement): boolean;
+/** `this.name = ...` at the top level of a constructor. */
+export declare function assignsField(body: ast.BlockStatement, name: string): boolean;

package/dist/checker/helpers.js

@@ -0,0 +1,162 @@
+import { forEachChild } from "../walk.js";
+import { CONTENT } from "./dom.js";
+import { isAssignable, nonNull, unionMembers, widenLiterals, } from "./types.js";
+import {} from "./context.js";
+// Functions that the layers of the checker use and that need no state of their own.
+// ─── Helpers ─────────────────────────────────────────────────────────────────────────────────────
+/** A binding as seen from a scope and its parents. */
+export function lookupIn(scope, name) {
+    for (let current = scope; current; current = current.parent) {
+        const binding = current.values.get(name);
+        if (binding)
+            return binding;
+    }
+    return undefined;
+}
+/** Return and defer statements of a body, not counting those of nested functions. */
+export function ownStatements(body) {
+    const found = [];
+    const visit = (node) => {
+        if (node.kind === 'ReturnStatement' || node.kind === 'DeferStatement')
+            found.push(node);
+        if (node.kind === 'FuncDeclaration' ||
+            node.kind === 'FuncExpression' ||
+            node.kind === 'ArrowFunction' ||
+            node.kind === 'ClassDeclaration' ||
+            node.kind === 'MountStatement' ||
+            node.kind === 'EffectStatement')
+            return;
+        forEachChild(node, visit);
+    };
+    forEachChild(body, visit);
+    return found;
+}
+/**
+ * Values that can be element children: text, numbers (literal types included), nodes (`node` is
+ * the type of a DOM node), lists of them, or null.
+ */
+export function isContent(given, node) {
+    if (given === CONTENT)
+        return true;
+    const type = widenLiterals(given);
+    switch (type.kind) {
+        case 'string':
+        case 'number':
+        case 'bigint':
+        case 'any':
+        case 'unknown':
+        case 'never':
+        case 'null':
+            return true;
+        case 'nullable':
+            return isContent(type.type, node);
+        case 'array':
+            return isContent(type.element, node);
+        case 'object':
+        case 'class':
+            return isAssignable(type, node);
+        case 'union':
+            return type.types.every((member) => isContent(member, node));
+        default:
+            return false;
+    }
+}
+/** Values that setAttribute accepts: text, numbers, bools, or null to leave it out. */
+export function isAttributeValue(type) {
+    const value = nonNull(type);
+    return (isUntyped(value) ||
+        value.kind === 'string' ||
+        value.kind === 'number' ||
+        value.kind === 'bigint' ||
+        value.kind === 'bool' ||
+        value.kind === 'null' ||
+        value.kind === 'never');
+}
+export function isUntyped(type) {
+    return type.kind === 'any' || type.kind === 'unknown';
+}
+export function isNumeric(type) {
+    return type.kind === 'number' || isUntyped(type);
+}
+/**
+ * What `x instanceof C` makes `x`: an instance of a class, or of a constructor from a `.d.ts`,
+ * like `HTMLInputElement` (`declare var HTMLInputElement: { prototype: ...; new(): ... }`).
+ */
+export function instanceTypeOf(type) {
+    if (type.kind === 'classValue')
+        return type.info.instance;
+    if (type.kind !== 'object')
+        return null;
+    const prototype = type.members.get('prototype');
+    if (prototype && !isUntyped(prototype.type))
+        return prototype.type;
+    return type.construct?.results[0] ?? null;
+}
+/** A function and its overloads, in the order they are declared. */
+export function signaturesOf(signature) {
+    return [signature, ...(signature.overloads ?? [])];
+}
+export function callSignature(type) {
+    if (type.kind === 'function')
+        return type;
+    if (type.kind === 'object')
+        return type.call;
+    if (type.kind === 'union') {
+        // A union of functions can be called when they all accept and give the same: `x.toString()`.
+        const signatures = type.types.map(callSignature);
+        const [first] = signatures;
+        const same = signatures.every((each) => each !== null &&
+            first !== null &&
+            first !== undefined &&
+            isAssignable(each, first) &&
+            isAssignable(first, each));
+        return same ? (first ?? null) : null;
+    }
+    return null;
+}
+/** Whether the expected type has literal members: then a literal gets a literal type. */
+export function expectsLiteral(expected) {
+    return (expected !== null && unionMembers(nonNull(expected)).some((type) => type.kind === 'literal'));
+}
+export function countValues(count) {
+    if (count === 0)
+        return 'no values';
+    return count === 1 ? '1 value' : `${count} values`;
+}
+/** A call, or `await` of a call or of `go`: it may give several values. */
+export function isCall(node) {
+    if (node.kind === 'UnaryExpression' && node.operator === 'await') {
+        return node.argument.kind === 'CallExpression' || node.argument.kind === 'GoExpression';
+    }
+    return node.kind === 'CallExpression';
+}
+/** How to name an expression in messages: `divide()`, `stats.minMax()`, or `this expression`. */
+export function callName(node) {
+    if (node.kind === 'UnaryExpression' && node.operator === 'await') {
+        return callName(node.argument);
+    }
+    if (node.kind === 'GoExpression')
+        return callName(node.call);
+    if (node.kind !== 'CallExpression')
+        return 'this expression';
+    const { callee } = node;
+    if (callee.kind === 'Identifier')
+        return `${callee.name}()`;
+    if (callee.kind === 'MemberExpression') {
+        const object = callee.object.kind === 'Identifier' ? `${callee.object.name}.` : '';
+        return `${object}${callee.property.name}()`;
+    }
+    return 'this call';
+}
+export function isSuperCall(statement) {
+    return (statement.kind === 'ExpressionStatement' &&
+        statement.expression.kind === 'CallExpression' &&
+        statement.expression.callee.kind === 'SuperExpression');
+}
+/** `this.name = ...` at the top level of a constructor. */
+export function assignsField(body, name) {
+    return body.body.some((statement) => statement.kind === 'AssignmentStatement' &&
+        statement.targets.some((target) => target.kind === 'MemberExpression' &&
+            target.object.kind === 'ThisExpression' &&
+            target.property.name === name));
+}

package/dist/checker/imports.d.ts

@@ -0,0 +1,7 @@
+import type * as ast from '../ast.ts';
+import { CheckerBase } from './base.ts';
+export declare abstract class ImportChecker extends CheckerBase {
+    protected declareImport(node: ast.ImportDeclaration): void;
+    /** `import { visible } from "./visible.rk"`: decorators have a namespace of their own. */
+    private importDecorator;
+}

package/dist/checker/imports.js

@@ -0,0 +1,83 @@
+import { CheckerBase } from "./base.js";
+import { ANY, LazyMap, memberNames, UNKNOWN } from "./types.js";
+// Imports: the names of other modules, typed by their exports (`importModule` for `.rk` modules,
+// `importDeclarations` for the rest), or untyped when nothing is known about them.
+export class ImportChecker extends CheckerBase {
+    declareImport(node) {
+        const specifier = node.source.value;
+        const isRook = specifier.endsWith('.rk');
+        const result = isRook
+            ? this.options.importModule?.(specifier)
+            : this.options.importDeclarations?.(specifier);
+        if (result && 'error' in result)
+            this.error(result.error, node.source);
+        const exports = result && 'exports' in result ? result.exports : null;
+        if (node.defaultImport && exports && !isRook) {
+            // `import fs from "node:fs"`: the default export of a module with types.
+            const value = exports.values.get('default');
+            const type = exports.types.get('default');
+            if (value === undefined && type === undefined) {
+                this.error(`"${specifier}" has no default export`, node.defaultImport);
+            }
+            this.declareValue(node.defaultImport, 'import', value ?? UNKNOWN);
+            if (type !== undefined)
+                this.declareType(node.defaultImport, type);
+        }
+        else if (node.defaultImport) {
+            if (exports) {
+                this.error('Rook modules have no default export: use import { ... }', node.defaultImport);
+            }
+            this.declareValue(node.defaultImport, 'import', exports ? UNKNOWN : ANY);
+            this.scope.types.set(node.defaultImport.name, ANY);
+        }
+        if (node.namespaceImport) {
+            const values = exports?.values;
+            const members = new LazyMap(() => (values ? memberNames(values) : []), (name) => {
+                const type = values?.get(name);
+                return type && { type, method: false, visibility: 'public', owner: null };
+            });
+            const type = exports ? { kind: 'object', name: specifier, members, call: null } : ANY;
+            this.declareValue(node.namespaceImport, 'import', type);
+        }
+        for (const specifierNode of node.namedImports) {
+            const name = specifierNode.imported.name;
+            if (!exports) {
+                this.declareValue(specifierNode.local, 'import', ANY);
+                this.scope.types.set(specifierNode.local.name, ANY);
+                continue;
+            }
+            const value = exports.values.get(name);
+            const type = exports.types.get(name);
+            const decorator = exports.decorators?.get(name);
+            const component = exports.components?.get(name);
+            const found = [value, type, decorator, component].some((each) => each !== undefined);
+            if (!found) {
+                this.error(`"${name}" is not exported by "${specifier}"`, specifierNode.imported);
+            }
+            if (value !== undefined)
+                this.declareValue(specifierNode.local, 'import', value);
+            if (type !== undefined)
+                this.declareType(specifierNode.local, type);
+            if (decorator !== undefined)
+                this.importDecorator(specifierNode, decorator);
+            if (component !== undefined) {
+                this.declareValue(specifierNode.local, 'component', UNKNOWN).component = component;
+            }
+        }
+    }
+    /** `import { visible } from "./visible.rk"`: decorators have a namespace of their own. */
+    importDecorator(node, info) {
+        const { imported, local } = node;
+        // After the error the decorator keeps its name, so its uses are not reported again.
+        if (local.name !== imported.name) {
+            this.error(`renaming decorators is not supported yet: import { ${imported.name} }`, local);
+        }
+        if (this.decorators.has(imported.name)) {
+            this.error(`the decorator @${imported.name} is already declared`, local);
+        }
+        else {
+            this.decorators.set(imported.name, info);
+            this.importedDecorators.add(info);
+        }
+    }
+}

package/dist/checker/initializers.d.ts

@@ -0,0 +1,22 @@
+import type * as ast from '../ast.ts';
+import type { Binding } from './context.ts';
+import { TypeResolver } from './resolution.ts';
+export declare abstract class InitializerChecker extends TypeResolver {
+    /** Initializers being checked, the outermost first. */
+    private readonly initializers;
+    /**
+     * Checks the initializer of `bindings` with `check`, which gives them their types, and then the
+     * function bodies in it that waited for those types.
+     */
+    protected checkInitializer(declaration: ast.VariableDeclaration, bindings: readonly Binding[], check: () => void): void;
+    /**
+     * Defers `check`, the check of a function body, if the body mentions a variable that is being
+     * initialized and has no type yet. Returns whether it was deferred.
+     */
+    protected deferBody(body: ast.Node, check: () => void): boolean;
+    /** The error for `binding` used in its own initializer, or `null` if this use is fine. */
+    protected initializerError(binding: Binding): string | null;
+    private lookupFrom;
+    private saveState;
+    private restoreState;
+}

package/dist/checker/initializers.js

@@ -0,0 +1,104 @@
+import { mentionsName } from "../names.js";
+import { TypeResolver } from "./resolution.js";
+export class InitializerChecker extends TypeResolver {
+    /** Initializers being checked, the outermost first. */
+    initializers = [];
+    /**
+     * Checks the initializer of `bindings` with `check`, which gives them their types, and then the
+     * function bodies in it that waited for those types.
+     */
+    checkInitializer(declaration, bindings, check) {
+        const initializer = {
+            declaration,
+            bindings: new Set(bindings),
+            scope: this.scope,
+            fn: this.fn,
+            deferred: [],
+        };
+        this.initializers.push(initializer);
+        try {
+            check();
+        }
+        finally {
+            this.initializers.pop();
+        }
+        for (const body of initializer.deferred)
+            body();
+    }
+    /**
+     * Defers `check`, the check of a function body, if the body mentions a variable that is being
+     * initialized and has no type yet. Returns whether it was deferred.
+     */
+    deferBody(body, check) {
+        // The outermost initializer ends last: then every variable the body may use has its type.
+        const initializer = this.initializers.find((candidate) => {
+            const untyped = [...candidate.bindings].filter((binding) => binding.type === null);
+            return untyped.length > 0 && mentionsName(body, new Set(untyped.map(({ name }) => name)));
+        });
+        if (!initializer)
+            return false;
+        const state = this.saveState();
+        initializer.deferred.push(() => {
+            const current = this.saveState();
+            this.restoreState(state);
+            try {
+                check();
+            }
+            finally {
+                this.restoreState(current);
+            }
+        });
+        return true;
+    }
+    /** The error for `binding` used in its own initializer, or `null` if this use is fine. */
+    initializerError(binding) {
+        const initializer = this.initializers.find((candidate) => candidate.bindings.has(binding));
+        if (!initializer)
+            return null;
+        const { name } = binding;
+        if (initializer.fn === this.fn) {
+            const outer = this.lookupFrom(initializer.scope.parent, name);
+            return outer
+                ? `"${name}" here is the new variable, which has no value yet; give it another name to use the outer "${name}"`
+                : `"${name}" is used in its own initializer, before it has a value`;
+        }
+        if (binding.type !== null)
+            return null;
+        const { declaration } = initializer;
+        const value = declaration.values[declaration.names.findIndex((id) => id.name === name)];
+        const isFunction = value?.kind === 'ArrowFunction' || value?.kind === 'FuncExpression';
+        return isFunction
+            ? `"${name}" is used in its own initializer: give it a type, e.g. ${declaration.keyword} ${name} func() = ...`
+            : `"${name}" is used in its own initializer: write its type after the name`;
+    }
+    lookupFrom(scope, name) {
+        for (; scope; scope = scope.parent) {
+            const binding = scope.values.get(name);
+            if (binding)
+                return binding;
+        }
+        return undefined;
+    }
+    saveState() {
+        return {
+            scope: this.scope,
+            flow: new Map(this.flow),
+            fn: this.fn,
+            cls: this.cls,
+            inferring: this.inferring,
+            component: this.component,
+            decorator: this.decorator,
+        };
+    }
+    restoreState(state) {
+        ({
+            scope: this.scope,
+            flow: this.flow,
+            fn: this.fn,
+            cls: this.cls,
+            inferring: this.inferring,
+            component: this.component,
+            decorator: this.decorator,
+        } = state);
+    }
+}

package/dist/checker/iterables.d.ts

@@ -0,0 +1,5 @@
+import type { ObjectType, Type } from './types.ts';
+/** `Map<K, V>` or `ReadonlyMap<K, V>`: `for key, value in m`, and `for value in m` for the values. */
+export declare function isMap(type: Type): boolean;
+/** The key and the value of `for key, value in x`: of a Map, or of an array-like with positions. */
+export declare function loopEntry(type: ObjectType): [Type, Type] | null;

package/dist/checker/iterables.js

@@ -0,0 +1,17 @@
+// What `for ... in` goes over besides arrays, strings and channels: the iterables of the lib files,
+// whose values come from `[Symbol.iterator]()`. A Map gives its keys and values, as a map in Go.
+/** `Map<K, V>` or `ReadonlyMap<K, V>`: `for key, value in m`, and `for value in m` for the values. */
+export function isMap(type) {
+    const name = type.kind === 'object' ? (type.instanceOf?.template.name ?? type.name) : null;
+    return name === 'Map' || name === 'ReadonlyMap';
+}
+/** The key and the value of `for key, value in x`: of a Map, or of an array-like with positions. */
+export function loopEntry(type) {
+    const { iterates, numberIndex, instanceOf } = type;
+    if (!iterates)
+        return null;
+    if (isMap(type))
+        return instanceOf ? [instanceOf.args[0], instanceOf.args[1]] : null;
+    // A typed array or a NodeList has positions, and `entries()`, as an array has.
+    return numberIndex && type.members.has('entries') ? [{ kind: 'number' }, iterates] : null;
+}

package/dist/checker/iterators.d.ts

@@ -0,0 +1,13 @@
+import type * as ast from '../ast.ts';
+import { GoForChecker } from './go-for.ts';
+import { type Type } from './types.ts';
+export declare abstract class IteratorChecker extends GoForChecker {
+    protected checkCall(node: ast.CallExpression, callee: Type, expected?: Type | null): Type;
+    /** `Generator<T>` of the lib files, or `Generator<[K, V]>` for a yield of two values. */
+    private generatorOf;
+    /** The rules of iterators in the whole program; Checker.run calls it. */
+    protected checkIterators(): void;
+    private checkIterator;
+    /** Where `yield` is used in the body of an iterator; `nested` inside a function in it. */
+    private checkYields;
+}

package/dist/checker/iterators.js

@@ -0,0 +1,95 @@
+import { isIterator, isYieldCall } from "../iterators.js";
+import { forEachChild } from "../walk.js";
+import { GoForChecker } from "./go-for.js";
+import { ANY, arrayOf, instantiate, typeToString, union, UNKNOWN, VOID, } from "./types.js";
+// Iterators, `func(yield func(T) bool)`, as in Go 1.23 (src/iterators.ts). They compile to JS
+// generators, so they keep to what a generator can do: `yield` is only called, in the body of the
+// iterator itself and not in a function inside it; the iterator is not async and returns nothing;
+// and it is not called with a function, as Go allows, but gone over with `for ... in`. Called
+// without arguments, it gives what a generator function gives: a lazy JS iterator, with `take`,
+// `map`, `filter` and the like.
+const NESTED = new Set([
+    'FuncDeclaration',
+    'FuncExpression',
+    'ArrowFunction',
+    'ClassDeclaration',
+]);
+export class IteratorChecker extends GoForChecker {
+    checkCall(node, callee, expected = null) {
+        if (callee.kind !== 'function' || !callee.iterator) {
+            return super.checkCall(node, callee, expected);
+        }
+        if (node.arguments.length === 0)
+            return this.generatorOf(callee);
+        this.error(`${typeToString(callee)} is an iterator, gone over with "for": e.g. "for value in items"; it compiles to a JS generator, which takes no function, and seq() gives it`, node);
+        return UNKNOWN;
+    }
+    /** `Generator<T>` of the lib files, or `Generator<[K, V]>` for a yield of two values. */
+    generatorOf(iterator) {
+        const generator = this.options.library?.type('Generator');
+        const yieldType = iterator.params[0];
+        const taken = yieldType?.kind === 'function' ? yieldType.params : [];
+        const value = taken.length === 1 ? taken[0] : arrayOf(union(taken));
+        if (generator?.kind !== 'object' || generator.typeParams?.length !== 3)
+            return ANY;
+        return instantiate(generator, [value, VOID, ANY]);
+    }
+    /** The rules of iterators in the whole program; Checker.run calls it. */
+    checkIterators() {
+        const visit = (node) => {
+            if (node.kind === 'FuncDeclaration' ||
+                node.kind === 'FuncExpression' ||
+                node.kind === 'MethodDeclaration') {
+                if (isIterator(node.params))
+                    this.checkIterator(node);
+            }
+            else if (node.kind === 'ArrowFunction' && isIterator(node.params)) {
+                this.error('an iterator is written with func, not as an arrow function: JS has no arrow generators, e.g. func(yield func(number) bool) { ... }', node);
+            }
+            forEachChild(node, visit);
+        };
+        visit(this.program);
+    }
+    checkIterator(node) {
+        const param = node.params[0];
+        const type = param.type;
+        if (node.async) {
+            this.error('an iterator cannot be async: it compiles to a JS generator, which yields at once; wait where it is gone over instead', node);
+        }
+        if (node.results.length > 0) {
+            this.error('an iterator returns nothing: it gives its values to yield', node.results[0]);
+        }
+        const result = type?.kind === 'FuncType' && type.results.length === 1 ? type.results[0] : null;
+        const yieldsBool = type?.kind === 'FuncType' &&
+            type.params.length >= 1 &&
+            type.params.length <= 2 &&
+            result?.kind === 'TypeReference' &&
+            result.name.name === 'bool';
+        if (!yieldsBool) {
+            this.error('the yield of an iterator is func(T) bool or func(K, V) bool, e.g. func(yield func(number) bool)', type ?? param);
+        }
+        this.checkYields(node.body, false);
+    }
+    /** Where `yield` is used in the body of an iterator; `nested` inside a function in it. */
+    checkYields(node, nested) {
+        if (isYieldCall(node)) {
+            if (nested) {
+                this.error('yield is called in a function inside the iterator: a JS generator yields only in its own body, so loop there, e.g. for x in items { if !yield(x) { return } }', node.callee);
+            }
+            for (const argument of node.arguments)
+                this.checkYields(argument, nested);
+            return;
+        }
+        if (node.kind === 'Identifier' && node.name === 'yield') {
+            this.error('an iterator only calls yield, e.g. "if !yield(v) { return }": it compiles to a JS generator, where yield is not a value', node);
+            return;
+        }
+        // An iterator inside has its own yield, checked on its own.
+        if ((node.kind === 'FuncExpression' || node.kind === 'FuncDeclaration') &&
+            isIterator(node.params)) {
+            return;
+        }
+        const inner = nested || NESTED.has(node.kind);
+        forEachChild(node, (child) => this.checkYields(child, inner));
+    }
+}

package/dist/checker/loops.d.ts

@@ -0,0 +1,10 @@
+import type * as ast from '../ast.ts';
+import { BytesChecker } from './bytes.ts';
+export declare abstract class LoopChecker extends BytesChecker {
+    protected checkForIn(node: ast.ForInStatement): void;
+    /**
+     * The key and the value of a loop over an iterator: what its `yield` takes. Of two, one variable
+     * gets the second, as with a Map; of one, there is no key.
+     */
+    private yielded;
+}

package/dist/checker/loops.js

@@ -0,0 +1,82 @@
+import { assignedNames } from "../names.js";
+import { BytesChecker } from "./bytes.js";
+import { chanDirection, elementOf, isChan } from "./channel.js";
+import { isMap, loopEntry } from "./iterables.js";
+import { ANY, isNullable, NUMBER, STRING, typeToString, UNKNOWN, } from "./types.js";
+// `for ... in`: over arrays, strings, the iterables of the lib files (a Map gives its keys and
+// values), channels, which wait for their values, and iterators, `func(yield func(T) bool)`.
+export class LoopChecker extends BytesChecker {
+    checkForIn(node) {
+        const iterable = this.checkValue(node.iterable);
+        let value = UNKNOWN;
+        let key = NUMBER;
+        if (isNullable(iterable)) {
+            this.nullError(node.iterable);
+        }
+        else if (iterable.kind === 'array') {
+            value = iterable.element;
+        }
+        else if (iterable.kind === 'object' && iterable.iterates) {
+            // A Map gives its keys and values; one variable gets the values, as with an array.
+            const entry = loopEntry(iterable);
+            value = isMap(iterable) && entry ? entry[1] : iterable.iterates;
+            if (entry)
+                key = entry[0];
+            else if (node.key) {
+                this.error(`${typeToString(iterable)} has no keys: loop over its values, e.g. "for value in items"`, node.key);
+            }
+        }
+        else if (iterable.kind === 'function' && iterable.iterator) {
+            [key, value] = this.yielded(iterable, node);
+        }
+        else if (isChan(iterable)) {
+            // Each value waits for the channel, until it is closed.
+            value = elementOf(iterable);
+            if (chanDirection(iterable) === 'send') {
+                this.error(`"for ... in" cannot receive from ${typeToString(iterable)}: it only sends; receive from a "chan T" or a "<-chan T"`, node.iterable);
+            }
+            if (this.fn && !this.fn.isAsync) {
+                this.error('"for ... in" a channel waits for its values, so it is allowed only in async functions and at the top level of a module', node.iterable);
+            }
+            if (node.key)
+                this.error('a channel has no keys: write "for value in ch"', node.key);
+        }
+        else if (iterable.kind === 'string') {
+            value = STRING;
+        }
+        else if (iterable.kind === 'any') {
+            value = ANY;
+            key = ANY;
+        }
+        else if (iterable.kind === 'function') {
+            this.error(`cannot iterate over ${typeToString(iterable)}: an iterator names its parameter yield, e.g. func(yield func(number) bool)`, node.iterable);
+        }
+        else if (iterable.kind !== 'unknown') {
+            this.error(`cannot iterate over ${typeToString(iterable)}`, node.iterable);
+        }
+        this.withScope(() => {
+            if (node.key)
+                this.declareValue(node.key, 'loop', key);
+            this.declareValue(node.value, 'loop', value);
+            this.dropNarrowing(assignedNames(node.body));
+            const entry = this.flow;
+            this.flow = new Map(entry);
+            this.checkBlock(node.body.body);
+            this.flow = entry;
+        });
+    }
+    /**
+     * The key and the value of a loop over an iterator: what its `yield` takes. Of two, one variable
+     * gets the second, as with a Map; of one, there is no key.
+     */
+    yielded(iterator, node) {
+        const yieldType = iterator.params[0];
+        const taken = yieldType?.kind === 'function' ? yieldType.params : [];
+        if (taken.length === 2)
+            return [taken[0], taken[1]];
+        if (node.key) {
+            this.error(`${typeToString(iterator)} yields one value, without a key: write "for value in ..."`, node.key);
+        }
+        return [UNKNOWN, taken[0] ?? UNKNOWN];
+    }
+}