rooklang 0.3.3 → 0.3.4

package/dist/checker/closing.js

@@ -0,0 +1,164 @@
+import { forEachChild } from "../walk.js";
+import { IteratorChecker } from "./iterators.js";
+/** What `Channel.x(ch)` and `Topic.x(t)` do with a channel without keeping it. */
+const OPERATIONS = new Set(['send', 'receive', 'range', 'stream', 'publish', 'listen', 'try']);
+const MESSAGES = {
+    chan: (name) => `"${name}" is never closed: close it when nothing more is sent, e.g. close(${name})`,
+    topic: (name) => `"${name}" is never closed, and a topic listens until it is closed: close it when it is no longer needed, e.g. close(${name}), in a component in the function that mount() returns`,
+    tick: (name) => `"${name}" is never closed, and a tick runs until it is closed: e.g. close(${name})`,
+    signal: (name) => `"${name}" is never closed, and it keeps the program running until it is: close it once the signal has come, e.g. close(${name})`,
+};
+export class ClosingChecker extends IteratorChecker {
+    /** The identifier that declares a binding of this module. */
+    declarations = new WeakMap();
+    /** What each name refers to: its declaration, or the name of a predeclared value. */
+    references = new Map();
+    declareValue(id, kind, type) {
+        const binding = super.declareValue(id, kind, type);
+        this.declarations.set(binding, id);
+        return binding;
+    }
+    checkIdentifier(node) {
+        const binding = this.lookupValue(node.name);
+        const declaration = binding && this.declarations.get(binding);
+        if (declaration)
+            this.references.set(node, declaration);
+        else if (binding && binding === this.globals.values.get(node.name)) {
+            this.references.set(node, node.name);
+        }
+        return super.checkIdentifier(node);
+    }
+    /** The functions declared in the module, by their names, which `use` looks arguments up in. */
+    functions = new Map();
+    checkClosing() {
+        const made = [];
+        const uses = new Map();
+        const collect = (node) => {
+            if (node.kind === 'FuncDeclaration')
+                this.functions.set(node.name, node);
+            forEachChild(node, collect);
+        };
+        const visit = (node, parent) => {
+            const what = node.kind === 'VariableDeclaration' && !node.exported && node.names.length === 1
+                ? node.values[0] && this.made(node.values[0])
+                : null;
+            if (node.kind === 'VariableDeclaration' && what)
+                made.push([node.names[0], what]);
+            const declaration = node.kind === 'Identifier' ? this.references.get(node) : undefined;
+            if (node.kind === 'Identifier' && typeof declaration === 'object' && parent) {
+                if (!uses.has(declaration)) {
+                    uses.set(declaration, { closed: false, escapes: false, passed: [] });
+                }
+                this.use(node, parent, uses.get(declaration));
+            }
+            forEachChild(node, (child) => visit(child, node));
+        };
+        collect(this.program);
+        visit(this.program, null);
+        // Whether a variable or a parameter is closed, goes where it is not seen, or neither.
+        const fate = (id, seen) => {
+            const found = uses.get(id);
+            if (!found || seen.has(id))
+                return 'none';
+            if (found.closed)
+                return 'closed';
+            seen.add(id);
+            let result = found.escapes ? 'escapes' : 'none';
+            for (const [fn, i] of found.passed) {
+                const param = fn.params[i];
+                const inner = param && !param.rest ? fate(param.name, seen) : 'escapes';
+                if (inner === 'closed')
+                    return 'closed';
+                if (inner === 'escapes')
+                    result = 'escapes';
+            }
+            return result;
+        };
+        for (const [name, what] of made) {
+            if (fate(name, new Set()) === 'none')
+                this.warn(MESSAGES[what](name.name), name);
+        }
+    }
+    /** `chan<T>()`, `topic<T>()`, `tick(ms)`, `signal(name)` and their `Channel.make` and the like. */
+    made(value) {
+        if (value.kind === 'ChanExpression')
+            return 'chan';
+        if (value.kind === 'TopicExpression')
+            return 'topic';
+        if (value.kind !== 'CallExpression')
+            return null;
+        const { callee } = value;
+        if (callee.kind === 'Identifier') {
+            const predeclared = this.references.get(callee);
+            return predeclared === 'tick' || predeclared === 'signal' ? predeclared : null;
+        }
+        const member = this.predeclaredMember(callee);
+        if (member === 'Channel.make')
+            return 'chan';
+        if (member === 'Channel.tick')
+            return 'tick';
+        if (member === 'Channel.signal')
+            return 'signal';
+        return member === 'Topic.make' ? 'topic' : null;
+    }
+    /** `Channel.close` and the like, as a name, when `Channel` is the predeclared one. */
+    predeclaredMember(node) {
+        if (node.kind !== 'MemberExpression' || node.object.kind !== 'Identifier')
+            return null;
+        const object = this.references.get(node.object);
+        return (object === 'Channel' || object === 'Topic') && node.property.kind === 'Identifier'
+            ? `${object}.${node.property.name}`
+            : null;
+    }
+    /** What the code around a name of a channel does with it. */
+    use(node, parent, found) {
+        switch (parent.kind) {
+            case 'CallExpression': {
+                const i = parent.arguments.indexOf(node);
+                if (i < 0)
+                    return;
+                const { callee } = parent;
+                const ref = callee.kind === 'Identifier' ? this.references.get(callee) : undefined;
+                const member = this.predeclaredMember(callee)?.split('.')[1];
+                if (ref === 'close' || member === 'close')
+                    found.closed = true;
+                else if (ref === 'stream' || (member !== undefined && OPERATIONS.has(member)))
+                    return;
+                else {
+                    const fn = callee.kind === 'FuncExpression'
+                        ? callee
+                        : typeof ref === 'object'
+                            ? this.functions.get(ref)
+                            : undefined;
+                    if (fn)
+                        found.passed.push([fn, i]);
+                    else
+                        found.escapes = true;
+                }
+                return;
+            }
+            // Sending to it, receiving from it, a loop over it, comparing and assigning it keep it here;
+            // sending it through a channel does not.
+            case 'SendStatement':
+                if (parent.value === node)
+                    found.escapes = true;
+                return;
+            case 'UnaryExpression':
+                if (parent.operator !== '<-')
+                    found.escapes = true;
+                return;
+            case 'ForInStatement':
+                return;
+            case 'BinaryExpression':
+                if (!['==', '!=', '===', '!=='].includes(parent.operator))
+                    found.escapes = true;
+                return;
+            case 'AssignmentStatement':
+                if (!parent.targets.includes(node))
+                    found.escapes = true;
+                return;
+            default:
+                found.escapes = true;
+        }
+    }
+}

package/dist/checker/completion.d.ts

@@ -1,8 +1,8 @@
 import type * as ast from '../ast.ts';
-import { IteratorChecker } from './iterators.ts';
+import { ClosingChecker } from './closing.ts';
 import type { CompletionResult } from './context.ts';
 import { type Type } from './types.ts';
-export declare abstract class CompletionChecker extends IteratorChecker {
+export declare abstract class CompletionChecker extends ClosingChecker {
     protected completion: CompletionResult | null;
     private atCursor;
     /** The first check of the cursor counts: a component's body, for one, is checked for each use. */

package/dist/checker/completion.js

@@ -1,4 +1,4 @@
-import { IteratorChecker } from "./iterators.js";
+import { ClosingChecker } from "./closing.js";
 import { ARRAY_MEMBERS, ATTRIBUTE_NAMES, BIGINT_MEMBERS, BOOL_MEMBERS, EVENT_ATTRIBUTES, HTML_TAGS, NUMBER_MEMBERS, STRING_MEMBERS, } from "./completion-names.js";
 import { isSubclass, literalBase, memberNames, memberTypeOf, nonNull, typeToString, union, UNKNOWN, } from "./types.js";
 // Completion in editors (src/completion.ts): the editor writes the name `options.completion` where
@@ -12,7 +12,7 @@ const PRIMITIVE_MEMBERS = {
     bigint: BIGINT_MEMBERS,
     bool: BOOL_MEMBERS,
 };
-export class CompletionChecker extends IteratorChecker {
+export class CompletionChecker extends ClosingChecker {
     completion = null;
     atCursor(node) {
         return node.name === this.options.completion;

package/dist/checker/context.d.ts

@@ -64,6 +64,8 @@ export interface CheckResult {
     declarations: ModuleExports;
     /** Types of checked expressions, for code generation (e.g. how to insert element children). */
     types: WeakMap<ast.Expression, Type>;
+    /** The data classes that the module declares or imports, by their names here. */
+    dataClasses: Set<string>;
     /** With the `completion` option: what can be written at the cursor, if the check reached it. */
     completion?: CompletionResult;
 }
@@ -78,6 +80,17 @@ export interface Completion {
     kind: 'variable' | 'constant' | 'function' | 'class' | 'component' | 'type' | 'property' | 'method' | 'keyword' | 'tag' | 'attribute';
     /** The type, as Rook writes it. */
     detail?: string;
+    /** A name exported by another module of the package: choosing it imports it (auto-import.ts). */
+    import?: {
+        specifier: string;
+        edit: TextEdit;
+    };
+}
+/** A change of the text of a module: what is between the offsets becomes `text`. */
+export interface TextEdit {
+    start: number;
+    end: number;
+    text: string;
 }
 export type BindingKind = 'let' | 'const' | 'state' | 'derived' | 'ref' | 'param' | 'prop' | 'function' | 'class' | 'import' | 'loop' | 'catch' | 'builtin' | 'component';
 export interface Binding {

package/dist/checker/control-flow.d.ts

@@ -5,6 +5,11 @@ export declare abstract class ControlFlowChecker extends StatementChecker {
     protected checkIf(node: ast.IfStatement): void;
     protected checkFor(node: ast.ForStatement): void;
     protected checkSimpleStatement(node: ast.SimpleStatement): void;
+    /**
+     * `if const v = f(); v > 0 { }`: the variables of the initializer are in a scope of their own,
+     * around every branch. Returns whether `check` checked the statement inside it.
+     */
+    private checkWithInit;
     protected checkSwitch(node: ast.SwitchStatement): void;
     /**
      * `switch filter { case "all": ... default: ... }`: in a case the discriminant has the literals

package/dist/checker/control-flow.js

@@ -7,6 +7,8 @@ import { ANY, BOOL, isAssignable, isComparable, isNullable, isSubclass, literal,
 // if, for, switch and try, and how conditions narrow the types of variables in the branches.
 export class ControlFlowChecker extends StatementChecker {
     checkIf(node) {
+        if (this.checkWithInit(node.init, () => this.checkIf({ ...node, init: null })))
+            return;
         this.checkCondition(node.condition);
         const before = this.flow;
         // Both are found from the flow before the `if`, not from the end of a branch.
@@ -52,7 +54,22 @@ export class ControlFlowChecker extends StatementChecker {
     checkSimpleStatement(node) {
         this.checkStatement(node);
     }
+    /**
+     * `if const v = f(); v > 0 { }`: the variables of the initializer are in a scope of their own,
+     * around every branch. Returns whether `check` checked the statement inside it.
+     */
+    checkWithInit(init, check) {
+        if (init === null)
+            return false;
+        this.withScope(() => {
+            this.checkStatement(init);
+            check();
+        });
+        return true;
+    }
     checkSwitch(node) {
+        if (this.checkWithInit(node.init, () => this.checkSwitch({ ...node, init: null })))
+            return;
         const discriminant = node.discriminant ? this.checkValue(node.discriminant) : null;
         this.dropNarrowing(assignedNames(node));
         const entry = this.flow;

package/dist/checker/declarations.js

@@ -34,6 +34,7 @@ export class DeclarationChecker extends ImportChecker {
                     break;
                 case 'ClassDeclaration': {
                     const info = createClass(statement.name.name);
+                    info.data = statement.data;
                     info.typeParams = this.createTypeParams(statement.typeParams);
                     this.declareType(statement.name, info.instance);
                     this.declareValue(statement.name, 'class', info.value);

package/dist/checker/decode.d.ts

@@ -0,0 +1,8 @@
+import type * as ast from '../ast.ts';
+import { TopicChecker } from './topics.ts';
+import { type Type } from './types.ts';
+export declare abstract class DecodeChecker extends TopicChecker {
+    protected checkDecode(node: ast.DecodeExpression): Type;
+    /** Why decode cannot take a value of the type: it is neither JSON text nor a value from JS. */
+    private notDecodable;
+}

package/dist/checker/decode.js

@@ -0,0 +1,32 @@
+import { isUntyped } from "./helpers.js";
+import { TopicChecker } from "./topics.js";
+import { isText, notDecoded } from "./json.js";
+import { ERROR, typedArrayOf, typeToString } from "./types.js";
+// `decode<User>(body)`: the types are erased, so only the compiler knows what a User is. It writes
+// the type into the JS as data (codegen/decode.ts), and the runtime checks JSON text, or a value
+// from JS, against it when the program runs (runtime/decode.js). So the type must be one that JSON
+// can hold (json.ts). The argument is JSON text if it is a string, and a value from JS if it is any.
+export class DecodeChecker extends TopicChecker {
+    checkDecode(node) {
+        const type = this.resolveType(node.type);
+        const reason = notDecoded(type);
+        if (reason !== null)
+            this.error(`cannot decode ${typeToString(type)}: ${reason}`, node.type);
+        const argument = this.checkValue(node.argument);
+        if (!isUntyped(argument) && !isText(argument)) {
+            this.error(this.notDecodable(argument), node.argument);
+        }
+        return { kind: 'tuple', types: [type, ERROR] };
+    }
+    /** Why decode cannot take a value of the type: it is neither JSON text nor a value from JS. */
+    notDecodable(type) {
+        const prefix = `decode takes JSON text, a string, or a value of type any from JS, not ${typeToString(type)}`;
+        if (type.kind === 'nullable' && isText(type.type)) {
+            return `${prefix}: the text may be null, so check it first, e.g. "if text != null"`;
+        }
+        if (type.kind === 'object' && (typedArrayOf(type) === 'Uint8Array' || type.name === 'Buffer')) {
+            return `${prefix}: make the text of the bytes first, e.g. decode<User>(string(data))`;
+        }
+        return `${prefix}; its type is known already`;
+    }
+}

package/dist/checker/expressions.d.ts

@@ -11,6 +11,11 @@ export declare abstract class ExpressionChecker extends FunctionChecker {
     protected abstract checkChan(node: ast.ChanExpression): Type;
     protected abstract checkStreamChan(node: ast.StreamChanExpression): Type;
     protected abstract checkQueue(node: ast.QueueExpression): Type;
+    protected abstract checkTopic(node: ast.TopicExpression): Type;
+    protected abstract checkDecode(node: ast.DecodeExpression): Type;
+    /** `[1, 2]`; implemented by ArrayLiteralChecker. */
+    protected abstract checkArrayLiteral(node: ast.ArrayLiteral, expected: Type | null): Type;
+    protected abstract checkTryExpression(node: ast.TryExpression): Type;
     /** `[]byte("text")`; implemented by BytesChecker. */
     protected abstract checkConversion(node: ast.ConversionExpression): Type;
     protected abstract checkMake(node: ast.MakeExpression): Type;
@@ -24,7 +29,6 @@ export declare abstract class ExpressionChecker extends FunctionChecker {
     protected thisType(node: ast.NodeBase): Type;
     /** `super.method()`: the members of the base class. */
     protected superType(node: ast.NodeBase): Type;
-    protected checkArrayLiteral(node: ast.ArrayLiteral, expected: Type | null): Type;
     protected checkObjectLiteral(node: ast.ObjectLiteral, expected: Type | null): Type;
     /**
      * `value as Type`: the types must be related, one assignable to the other, as in TypeScript:

package/dist/checker/expressions.js

@@ -1,6 +1,6 @@
 import { FunctionChecker } from "./functions.js";
 import { expectsLiteral, callName, isUntyped } from "./helpers.js";
-import { ANY, BIGINT, arrayOf, BOOL, commonType, hasUntypedBase, instanceMembers, isAssignable, literal, NEVER, nonNull, NULL, nullable, NUMBER, STRING, typeToString, UNKNOWN, } from "./types.js";
+import { ANY, BIGINT, BOOL, hasUntypedBase, instanceMembers, isAssignable, literal, nonNull, NULL, nullable, NUMBER, STRING, typeToString, UNKNOWN, } from "./types.js";
 // Expressions: names, `this`, literals of arrays and objects; the operators are in operators.ts.
 export class ExpressionChecker extends FunctionChecker {
     /** The type of an expression that must be a single value (not `void` or several results). */
@@ -35,6 +35,9 @@ export class ExpressionChecker extends FunctionChecker {
                 return BIGINT;
             case 'StringLiteral':
                 return expectsLiteral(expected) ? literal(node.value) : STRING;
+            // A RegExp of lib.es5.d.ts; the playground, which has no lib files, does not know its members.
+            case 'RegExpLiteral':
+                return this.options.library?.type('RegExp') ?? ANY;
             case 'TemplateLiteral':
                 for (const expression of node.expressions)
                     this.checkValue(expression);
@@ -71,6 +74,12 @@ export class ExpressionChecker extends FunctionChecker {
                 return this.checkStreamChan(node);
             case 'QueueExpression':
                 return this.checkQueue(node);
+            case 'TopicExpression':
+                return this.checkTopic(node);
+            case 'DecodeExpression':
+                return this.checkDecode(node);
+            case 'TryExpression':
+                return this.checkTryExpression(node);
             case 'ConversionExpression':
                 return this.checkConversion(node);
             case 'MakeExpression':
@@ -104,7 +113,9 @@ export class ExpressionChecker extends FunctionChecker {
                 ? `"${node.name}" is a type, not a value`
                 : node.name === 'make'
                     ? 'make takes the type of a typed array first, e.g. make([]float64, n)'
-                    : `"${node.name}" is not defined`, node);
+                    : node.name === 'decode'
+                        ? 'decode takes the type first, e.g. decode<User>(body)'
+                        : `"${node.name}" is not defined`, node);
             return UNKNOWN;
         }
         // A component as a value: a tag can take it from there, `<section.content />`.
@@ -142,38 +153,6 @@ export class ExpressionChecker extends FunctionChecker {
         this.error(`class "${info.name}" has no base class`, node);
         return UNKNOWN;
     }
-    checkArrayLiteral(node, expected) {
-        const context = expected ? nonNull(expected) : null;
-        const expectedElement = context?.kind === 'array' ? context.element : context?.kind === 'any' ? ANY : null;
-        let element = expectedElement ?? NEVER;
-        for (const item of node.elements) {
-            let type;
-            if (item.kind === 'SpreadElement') {
-                const spread = this.checkValue(item.argument, expectedElement && arrayOf(expectedElement));
-                if (spread.kind === 'array')
-                    type = spread.element;
-                else if (spread.kind === 'any' || spread.kind === 'unknown')
-                    type = spread;
-                // JS spreads any iterable: a Set, a typed array, a `[]byte`.
-                else if (spread.kind === 'object' && spread.iterates)
-                    type = spread.iterates;
-                else {
-                    this.error(`cannot spread ${typeToString(spread)}: it is not an array or an iterable`, item.argument);
-                    type = UNKNOWN;
-                }
-            }
-            else {
-                type = this.checkValue(item, expectedElement);
-            }
-            if (expectedElement) {
-                this.expectAssignable(type, expectedElement, item.kind === 'SpreadElement' ? item.argument : item);
-            }
-            else {
-                element = commonType(element, type);
-            }
-        }
-        return arrayOf(element);
-    }
     checkObjectLiteral(node, expected) {
         let target = expected ? nonNull(expected) : null;
         // `?(ScrollIntoViewOptions | bool)`: an object literal can only be the object type in it.

package/dist/checker/flow.js

@@ -1,4 +1,4 @@
-import { containsBreak } from "../walk.js";
+import { containsBreak } from "../breaks.js";
 import { BIGINT, BOOL, isNullable, nonNull, NULL, NUMBER, STRING, typesEqual, union, unionMembers, } from "./types.js";
 // Control flow for the checker: how conditions narrow the types of variables, and which statements
 // execution never continues after.
@@ -96,18 +96,22 @@ export function isTerminating(node) {
         case 'IfStatement':
             return (node.alternate !== null && isTerminating(node.consequent) && isTerminating(node.alternate));
         case 'ForStatement':
-            return node.condition === null && !containsBreak(node.body.body);
+            return node.condition === null && !containsBreak(node.body.body, node.label ?? null);
         case 'SwitchStatement':
             return (node.cases.some((switchCase) => switchCase.tests.length === 0) &&
                 node.cases.every((switchCase) => {
                     const last = switchCase.body.at(-1);
-                    return last !== undefined && isTerminating(last) && !containsBreak(switchCase.body);
+                    return (last !== undefined &&
+                        isTerminating(last) &&
+                        !containsBreak(switchCase.body, node.label ?? null));
                 }));
         // A select runs one of its cases, waiting for one if there is no default.
         case 'SelectStatement':
             return node.cases.every((selectCase) => {
                 const last = selectCase.body.at(-1);
-                return last !== undefined && isTerminating(last) && !containsBreak(selectCase.body);
+                return (last !== undefined &&
+                    isTerminating(last) &&
+                    !containsBreak(selectCase.body, node.label ?? null));
             });
         case 'TryStatement':
             return ((isTerminating(node.block) && (!node.handler || isTerminating(node.handler.body))) ||

package/dist/checker/helpers.d.ts

@@ -26,7 +26,7 @@ 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. */
+/** A call, `decode<T>(x)`, `try`, 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;

package/dist/checker/helpers.js

@@ -123,12 +123,15 @@ export function countValues(count) {
         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. */
+/** A call, `decode<T>(x)`, `try`, 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';
+    // `return decode<User>(body)` and `return try f()` pass on the value and the error.
+    return (node.kind === 'CallExpression' ||
+        node.kind === 'DecodeExpression' ||
+        node.kind === 'TryExpression');
 }
 /** How to name an expression in messages: `divide()`, `stats.minMax()`, or `this expression`. */
 export function callName(node) {
@@ -139,6 +142,10 @@ export function callName(node) {
         return callName(node.call);
     if (node.kind === 'StreamChanExpression')
         return 'chan(stream)';
+    if (node.kind === 'DecodeExpression')
+        return 'decode';
+    if (node.kind === 'TryExpression')
+        return 'try';
     if (node.kind !== 'CallExpression')
         return 'this expression';
     const { callee } = node;

package/dist/checker/iterables.d.ts

@@ -1,5 +1,7 @@
-import type { ObjectType, Type } from './types.ts';
+import { type ObjectType, type 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;
+/** What `for v in x` waits for, of an async iterable that cannot be gone over at once, or null. */
+export declare function asyncIterated(type: Type): Type | null;

package/dist/checker/iterables.js

@@ -1,5 +1,8 @@
+import { bindParams, substitute } from "./types.js";
 // 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.
+// An async iterable, such as a stream of Node, gives the values that the Promises of
+// `[Symbol.asyncIterator]()` give, and the loop waits for them, as `for await` of JS.
 /** `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;
@@ -15,3 +18,13 @@ export function loopEntry(type) {
     // A typed array or a NodeList has positions, and `entries()`, as an array has.
     return numberIndex && type.members.has('entries') ? [{ kind: 'number' }, iterates] : null;
 }
+/** What `for v in x` waits for, of an async iterable that cannot be gone over at once, or null. */
+export function asyncIterated(type) {
+    if (type.kind === 'object')
+        return type.iterates ? null : (type.asyncIterates ?? null);
+    if (type.kind !== 'class' || !type.info.asyncIterates)
+        return null;
+    // TypeScript lists inherited members with the type arguments of the base class already.
+    const { info } = type;
+    return substitute(info.asyncIterates, bindParams(info.typeParams, type.args ?? info.typeParams));
+}

package/dist/checker/iterators.d.ts

@@ -8,6 +8,9 @@ export declare abstract class IteratorChecker extends GoForChecker {
     /** 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. */
+    /**
+     * Where `yield` is used in the body of an iterator: `nested` inside a function in it, or in `try`,
+     * which compiles to a function that runs its expression (codegen/try.ts).
+     */
     private checkYields;
 }

package/dist/checker/iterators.js

@@ -68,14 +68,21 @@ export class IteratorChecker extends GoForChecker {
         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);
+        if (node.body)
+            this.checkYields(node.body, false);
     }
-    /** Where `yield` is used in the body of an iterator; `nested` inside a function in it. */
+    /**
+     * Where `yield` is used in the body of an iterator: `nested` inside a function in it, or in `try`,
+     * which compiles to a function that runs its expression (codegen/try.ts).
+     */
     checkYields(node, nested) {
         if (isYieldCall(node)) {
-            if (nested) {
+            if (nested === 'function') {
                 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);
             }
+            else if (nested === 'try') {
+                this.error('yield cannot be in try, which compiles to a function: a JS generator yields only in its own body, so call yield outside of it', node.callee);
+            }
             for (const argument of node.arguments)
                 this.checkYields(argument, nested);
             return;
@@ -89,7 +96,8 @@ export class IteratorChecker extends GoForChecker {
             isIterator(node.params)) {
             return;
         }
-        const inner = nested || NESTED.has(node.kind);
+        const inner = nested ||
+            (NESTED.has(node.kind) ? 'function' : node.kind === 'TryExpression' ? 'try' : false);
         forEachChild(node, (child) => this.checkYields(child, inner));
     }
 }

package/dist/checker/json.d.ts

@@ -0,0 +1,5 @@
+import { type Type } from './types.ts';
+/** Why a value of the type cannot come from JSON, or null if it can. */
+export declare function notDecoded(type: Type, seen?: Set<Type>): string | null;
+/** Whether a value of the type is always a string: then decode reads it as JSON text. */
+export declare function isText(type: Type): boolean;