rooklang 0.3.3 → 0.4.0

package/dist/checker/signals.js

@@ -0,0 +1,48 @@
+import { ChannelChecker, typeName } from "./channels.js";
+import { isUntyped } from "./helpers.js";
+import { isNullable, typeToString } from "./types.js";
+// Signals and cancellation as channels (runtime/signals.js): `signal("SIGTERM")` gets the signals
+// of the process, `done(request.signal)` the reason of an AbortSignal, and `abortSignal(stop)` is an
+// AbortSignal that aborts when the channel gets a value or is closed. Their types are in
+// builtins.ts; the names that signal() takes, the AbortSignal that done() takes and the type that
+// abortSignal() gives, from the library if it has one, are here.
+const SIGNAL = /^SIG[A-Z0-9]+$/;
+export class SignalChecker extends ChannelChecker {
+    checkCall(node, callee, expected = null) {
+        const result = super.checkCall(node, callee, expected);
+        const { callee: name } = node;
+        if (name.kind !== 'Identifier' ||
+            this.lookupValue(name.name) !== this.globals.values.get(name.name)) {
+            return result;
+        }
+        switch (name.name) {
+            case 'signal':
+                this.checkSignalNames(node);
+                return result;
+            case 'done': {
+                const [argument] = node.arguments;
+                const type = argument && argument.kind !== 'SpreadElement' && this.checkedTypes.get(argument);
+                if (argument && type && !isUntyped(type) && typeName(type) !== 'AbortSignal') {
+                    this.error(`done() takes an AbortSignal, such as request.signal, not ${typeToString(type)}${isNullable(type) ? ': check it for null first' : ''}`, argument);
+                }
+                return result;
+            }
+            // An AbortSignal of the library, for `fetch(url, { signal: abortSignal(stop) })`.
+            case 'abortSignal':
+                return this.options.library?.type('AbortSignal') ?? result;
+            default:
+                return result;
+        }
+    }
+    /** `signal("SIGINT", "SIGTERM")`: at least one name, and the names are those of signals. */
+    checkSignalNames(node) {
+        if (node.arguments.length === 0) {
+            this.error('signal() takes the signals to listen to, e.g. signal("SIGINT", "SIGTERM")', node);
+        }
+        for (const argument of node.arguments) {
+            if (argument.kind === 'StringLiteral' && !SIGNAL.test(argument.value)) {
+                this.error(`"${argument.value}" is not the name of a signal: they start with SIG, e.g. signal("SIGINT", "SIGTERM")`, argument);
+            }
+        }
+    }
+}

package/dist/checker/statements.d.ts

@@ -12,10 +12,11 @@ export declare abstract class StatementChecker extends AssignmentChecker {
      */
     protected checkEffect(node: ast.EffectStatement): void;
     /**
-     * `mount() { ... }`: a function that runs once the markup is in the document, like a handler.
-     * It may return the function that cleans up, or nothing.
+     * `mount { ... }`: a function that runs once the markup is in the document, like a handler. It
+     * cleans up with `defer`, as an effect does, so it returns nothing.
      */
     protected checkMount(node: ast.MountStatement): void;
+    private checkDeferring;
     /**
      * `delete scores[name]` removes a key of an object used as a map, `{ [string]: T }`, or a field
      * that may be missing, of type `?T`; values of type `any` are not checked.
@@ -30,4 +31,6 @@ export declare abstract class StatementChecker extends AssignmentChecker {
     private linkError;
     /** The types of the variables of a declaration: the written one, or those of their values. */
     private initializerTypes;
+    /** `derived total number { ... }`: the block runs like the body of a closure and returns the value. */
+    private derivedBlockType;
 }

package/dist/checker/statements.js

@@ -1,8 +1,10 @@
 import { guardedByError } from "./error-results.js";
 import { AssignmentChecker } from "./assignments.js";
+import { placeOf } from "./context.js";
+import { isTerminating } from "./flow.js";
 import { isUntyped, isNumeric, ownStatements } from "./helpers.js";
 import { func, hasZeroValue, isNullable, nonNull, nullable, typeToString, UNKNOWN, } from "./types.js";
-// Statements: declarations of variables, blocks, `mount()`, `effect`. Assignments and `return`
+// Statements: declarations of variables, blocks, `mount`, `effect`. Assignments and `return`
 // are in assignments.ts.
 export class StatementChecker extends AssignmentChecker {
     checkStatement(node) {
@@ -92,30 +94,22 @@ export class StatementChecker extends AssignmentChecker {
      * a handler. It cleans up with `defer`, so it returns nothing.
      */
     checkEffect(node) {
-        for (const statement of ownStatements(node.body)) {
-            if (statement.kind === 'ReturnStatement' && statement.values.length > 0) {
-                this.error('an effect returns nothing; clean up with defer, e.g. defer clearInterval(timer)', statement.values[0]);
-            }
-        }
-        this.checkFunction([], func([], []), null, node.body, { closure: true });
+        this.checkDeferring(node.body, 'an effect');
     }
     /**
-     * `mount() { ... }`: a function that runs once the markup is in the document, like a handler.
-     * It may return the function that cleans up, or nothing.
+     * `mount { ... }`: a function that runs once the markup is in the document, like a handler. It
+     * cleans up with `defer`, as an effect does, so it returns nothing.
      */
     checkMount(node) {
-        const results = this.checkFunction([], func([], []), null, node.body, { closure: true });
-        if (results.length === 0)
-            return;
-        const result = results.length === 1 ? nonNull(results[0]) : null;
-        const cleans = result !== null &&
-            (isUntyped(result) ||
-                result.kind === 'never' ||
-                (result.kind === 'function' && result.required === 0));
-        if (!cleans) {
-            const returned = results.length === 1 ? typeToString(results[0]) : `${results.length} values`;
-            this.error(`mount() returns the function that cleans up, e.g. return () => clearInterval(timer), not ${returned}`, { start: node.start, end: node.start + 'mount'.length });
+        this.checkDeferring(node.body, 'mount');
+    }
+    checkDeferring(body, what) {
+        for (const statement of ownStatements(body)) {
+            if (statement.kind === 'ReturnStatement' && statement.values.length > 0) {
+                this.error(`${what} returns nothing; clean up with defer, e.g. defer clearInterval(timer)`, statement.values[0]);
+            }
         }
+        this.checkFunction([], func([], []), null, body, { closure: true });
     }
     /**
      * `delete scores[name]` removes a key of an object used as a map, `{ [string]: T }`, or a field
@@ -133,6 +127,8 @@ export class StatementChecker extends AssignmentChecker {
                 : null;
         if (target.kind === 'IndexExpression')
             this.checkValue(target.index);
+        // `delete user.boss` makes the field null again.
+        this.forget(target);
         if (isUntyped(object))
             return;
         if (object.kind === 'array') {
@@ -180,7 +176,7 @@ export class StatementChecker extends AssignmentChecker {
                 binding.type = type;
                 const value = values.length === names.length ? values[i] : undefined;
                 if (value && isNullable(type) && !isNullable(this.typeOfChecked(value))) {
-                    this.flow.set(binding, nonNull(type));
+                    this.flow.set(placeOf(binding), nonNull(type));
                 }
             });
             if (node.keyword === 'const' && !declared)
@@ -207,7 +203,10 @@ export class StatementChecker extends AssignmentChecker {
     initializerTypes(node, declared) {
         const { names, values } = node;
         let types;
-        if (values.length === 0) {
+        if (node.body) {
+            types = [this.derivedBlockType(names[0].name, node.body.body, declared)];
+        }
+        else if (values.length === 0) {
             if (declared && !hasZeroValue(declared) && declared.kind !== 'unknown') {
                 const type = typeToString(declared);
                 this.error(`${type} has no zero value: give "${names[0].name}" a value or make it nullable with ${typeToString(nullable(declared))}`, node.type ?? node);
@@ -228,4 +227,34 @@ export class StatementChecker extends AssignmentChecker {
         }
         return types;
     }
+    /** `derived total number { ... }`: the block runs like the body of a closure and returns the value. */
+    derivedBlockType(name, body, declared) {
+        const ends = isTerminating(body);
+        if (!ends) {
+            this.error(`derived "${name}" must return its value at the end of the block, e.g. return total`, {
+                start: body.end - 1,
+                end: body.end,
+            });
+        }
+        const saved = this.derivedBlock;
+        const results = declared ? [declared] : null;
+        this.derivedBlock = name;
+        try {
+            const types = this.checkFunction([], func([], results ?? []), results, body, {
+                closure: true,
+            });
+            if (types.length === 1)
+                return types[0];
+            // A block that does not end with a return is reported above.
+            if (ends) {
+                this.error(types.length === 0
+                    ? `derived "${name}" returns no value: return it, e.g. return total`
+                    : `derived "${name}" is one value, but its block returns ${types.length}`, body);
+            }
+            return UNKNOWN;
+        }
+        finally {
+            this.derivedBlock = saved;
+        }
+    }
 }

package/dist/checker/tagged-unions.d.ts

@@ -0,0 +1,37 @@
+import type * as ast from '../ast.ts';
+import { type Narrowing, type Place } from './context.ts';
+import { ControlFlowChecker } from './control-flow.ts';
+import { type LiteralType, type Member, type Type } from './types.ts';
+type Value = LiteralType['value'];
+export declare abstract class TaggedUnionChecker extends ControlFlowChecker {
+    /** The paths among the checked member expressions, with the types of their fields. */
+    private readonly paths;
+    /** The types of the fields of the paths, before narrowing: what their tags are found in. */
+    private readonly declared;
+    protected isTagOf(place: Place, field: string): boolean;
+    protected narrowable(node: ast.Expression): {
+        place: Place;
+        type: Type;
+    } | undefined;
+    /**
+     * The type of `object.field` read by `node`, which is `type` unless the expression is a path
+     * narrowed here. Getters and methods are not paths: they may give another value each time.
+     */
+    protected pathType(node: ast.MemberExpression, object: Type, type: Type): Type;
+    /** The field `name` of an object or a class instance, unless it is a method or an accessor. */
+    protected dataField(type: Type, name: string): Member | undefined;
+    /** The values of the tag `name` in each member of a union; `null` when `name` is not a tag. */
+    protected tagValues(members: readonly Type[], name: string): Value[][] | null;
+    /** `d.kind == "courier"` narrows `d` too: the members with this tag, or the others. */
+    protected narrow(node: ast.Expression, assumeTrue: boolean): Narrowing;
+    /** `switch d.kind`: in a case the members with its tags, in `default` those of no case. */
+    protected narrowCase(node: ast.SwitchStatement, switchCase: ast.SwitchCase): Narrowing;
+    private narrowTag;
+    /**
+     * `{ kind: "pickup", shop: "Main st." }` where one of several objects is expected: the member
+     * that a tag of the literal chooses, or `null` when no tag chooses one. A tag of no member is
+     * reported, and the literal then gets `UNKNOWN`, so that it is not reported again.
+     */
+    protected taggedMember(node: ast.ObjectLiteral, objects: readonly Type[], union: Type): Type | null;
+}
+export {};

package/dist/checker/tagged-unions.js

@@ -0,0 +1,132 @@
+import { placeOf } from "./context.js";
+import { ControlFlowChecker } from "./control-flow.js";
+import { literalValue, narrowByTag } from "./flow.js";
+import { findClassMember, memberTypeOf, nonNull, typeToString, unionMembers, UNKNOWN, } from "./types.js";
+export class TaggedUnionChecker extends ControlFlowChecker {
+    /** The paths among the checked member expressions, with the types of their fields. */
+    paths = new WeakMap();
+    /** The types of the fields of the paths, before narrowing: what their tags are found in. */
+    declared = new WeakMap();
+    isTagOf(place, field) {
+        const type = place.path === '' ? place.binding.type : this.declared.get(place);
+        return type != null && this.tagValues(unionMembers(nonNull(type)), field) !== null;
+    }
+    narrowable(node) {
+        if (node.kind === 'Identifier') {
+            const binding = this.narrowableBinding(node);
+            if (!binding?.type)
+                return undefined;
+            const place = placeOf(binding);
+            return { place, type: this.flow.get(place) ?? binding.type };
+        }
+        const path = node.kind === 'MemberExpression' ? this.paths.get(node) : undefined;
+        return path && { place: path.place, type: this.flow.get(path.place) ?? path.type };
+    }
+    /**
+     * The type of `object.field` read by `node`, which is `type` unless the expression is a path
+     * narrowed here. Getters and methods are not paths: they may give another value each time.
+     */
+    pathType(node, object, type) {
+        const parent = node.optional ? undefined : this.narrowable(node.object)?.place;
+        const { name } = node.property;
+        if (!parent || !unionMembers(object).every((member) => this.dataField(member, name))) {
+            this.paths.delete(node);
+            return type;
+        }
+        const place = placeOf(parent.binding, parent.path === '' ? name : `${parent.path}.${name}`);
+        this.paths.set(node, { place, type });
+        this.declared.set(place, type);
+        return this.flow.get(place) ?? type;
+    }
+    /** The field `name` of an object or a class instance, unless it is a method or an accessor. */
+    dataField(type, name) {
+        let member;
+        if (type.kind === 'object') {
+            member = type.members.get(name);
+        }
+        else if (type.kind === 'class') {
+            this.ensureClassResolved(type.info);
+            member = findClassMember(type.info, name, false);
+            if (member && type.args)
+                member = { ...member, type: memberTypeOf(type, member) };
+        }
+        return member && !member.method && member.accessor === undefined ? member : undefined;
+    }
+    /** The values of the tag `name` in each member of a union; `null` when `name` is not a tag. */
+    tagValues(members, name) {
+        if (members.length < 2)
+            return null;
+        const tags = [];
+        for (const member of members) {
+            const field = this.dataField(member, name);
+            const types = field ? unionMembers(field.type) : [];
+            if (!types.every((type) => type.kind === 'literal'))
+                return null;
+            if (types.length === 0)
+                return null;
+            tags.push(types.map((type) => type.value));
+        }
+        return tags;
+    }
+    /** `d.kind == "courier"` narrows `d` too: the members with this tag, or the others. */
+    narrow(node, assumeTrue) {
+        const narrowing = super.narrow(node, assumeTrue);
+        if (node.kind !== 'BinaryExpression')
+            return narrowing;
+        if (node.operator !== '==' && node.operator !== '!=')
+            return narrowing;
+        const right = literalValue(node.right);
+        const value = right ?? literalValue(node.left);
+        if (value === undefined)
+            return narrowing;
+        const target = right !== undefined ? node.left : node.right;
+        const equal = (node.operator === '==') === assumeTrue;
+        return [...narrowing, ...this.narrowTag(target, [value], equal)];
+    }
+    /** `switch d.kind`: in a case the members with its tags, in `default` those of no case. */
+    narrowCase(node, switchCase) {
+        const narrowing = super.narrowCase(node, switchCase);
+        if (!node.discriminant)
+            return narrowing;
+        const isDefault = switchCase.tests.length === 0;
+        const tests = isDefault ? node.cases.flatMap((each) => each.tests) : switchCase.tests;
+        const values = tests.map(literalValue);
+        if (!isDefault && values.includes(undefined))
+            return narrowing;
+        const known = values.filter((value) => value !== undefined);
+        return [...narrowing, ...this.narrowTag(node.discriminant, known, !isDefault)];
+    }
+    narrowTag(target, values, equal) {
+        if (target.kind !== 'MemberExpression' || target.optional)
+            return [];
+        const owner = this.narrowable(target.object);
+        const tags = owner && this.tagValues(unionMembers(nonNull(owner.type)), target.property.name);
+        return owner && tags ? [[owner.place, narrowByTag(owner.type, tags, values, equal)]] : [];
+    }
+    /**
+     * `{ kind: "pickup", shop: "Main st." }` where one of several objects is expected: the member
+     * that a tag of the literal chooses, or `null` when no tag chooses one. A tag of no member is
+     * reported, and the literal then gets `UNKNOWN`, so that it is not reported again.
+     */
+    taggedMember(node, objects, union) {
+        for (const property of node.properties) {
+            if (property.kind === 'SpreadElement')
+                continue;
+            const name = property.key.kind === 'Identifier' ? property.key.name : property.key.value;
+            const value = literalValue(property.value);
+            const tags = value === undefined ? null : this.tagValues(objects, name);
+            if (value === undefined || !tags)
+                continue;
+            const chosen = objects.filter((_, i) => tags[i].includes(value));
+            if (chosen.length === 1)
+                return chosen[0];
+            if (chosen.length > 1)
+                continue;
+            const known = [...new Set(tags.flat())].map((each) => JSON.stringify(each));
+            const choices = known.length > 1 ? `${known.slice(0, -1).join(', ')} or ${known.at(-1)}` : known[0];
+            this.error(`${JSON.stringify(value)} is not a kind of ${typeToString(union)}: write ${choices}`, property.value);
+            return UNKNOWN;
+        }
+        return null;
+    }
+}

package/dist/checker/topics.d.ts

@@ -0,0 +1,6 @@
+import type * as ast from '../ast.ts';
+import { QueueChecker } from './queues.ts';
+import { type Type } from './types.ts';
+export declare abstract class TopicChecker extends QueueChecker {
+    protected checkTopic(node: ast.TopicExpression): Type;
+}

package/dist/checker/topics.js

@@ -0,0 +1,17 @@
+import { QueueChecker } from "./queues.js";
+import { notBroadcast } from "./transfer.js";
+import { STRING, topicOf } from "./types.js";
+// Topics: `topic<T>(name)` makes one, and its values go to the other tabs of the site as copies,
+// so they must be data without channels. `t <- v` sends (channels.ts), `<-t` receives
+// (operators.ts) and `for v in t` receives them until it is closed (loops.ts).
+export class TopicChecker extends QueueChecker {
+    checkTopic(node) {
+        const element = this.resolveType(node.element);
+        const reason = notBroadcast(element);
+        if (reason !== null) {
+            this.error(`the values of a topic go to other tabs as copies: ${reason}`, node.element);
+        }
+        this.expectAssignable(this.checkValue(node.name, STRING), STRING, node.name);
+        return topicOf(element);
+    }
+}

package/dist/checker/transfer.d.ts

@@ -2,4 +2,6 @@ import { type Type } from './types.ts';
 /** Buffers and their views: copied whole, or moved by `transfer(x)` (channels.ts). */
 export declare const BUFFERS: readonly string[];
 /** Why a value of the type cannot be copied to a worker, or null if it can. */
-export declare function notCopied(type: Type, seen?: Set<Type>): string | null;
+export declare function notCopied(type: Type, seen?: Set<Type>, tab?: boolean): string | null;
+/** Why a value of the type cannot go to another tab through a topic, or null if it can. */
+export declare function notBroadcast(type: Type): string | null;

package/dist/checker/transfer.js

@@ -1,6 +1,7 @@
 import { isQueue, memberNames, queueElement, typeToString } from "./types.js";
 // What can go to a worker and back: a worker gets a copy of each value (the structured clone of
-// postMessage), and a copy has the data of a value but not its methods.
+// postMessage), and a copy has the data of a value but not its methods. What goes to another tab
+// through a topic is a copy as well, and it cannot hold a channel.
 /** Buffers and their views: copied whole, or moved by `transfer(x)` (channels.ts). */
 export const BUFFERS = [
     'ArrayBuffer',
@@ -23,6 +24,8 @@ const COPIED = new Set([
     'chan',
     'chan<-',
     '<-chan',
+    // A topic is copied as its name, and the other thread listens to it on its own.
+    'topic',
     'Map',
     'Set',
     'Date',
@@ -35,13 +38,13 @@ const COPIED = new Set([
     ...BUFFERS,
 ]);
 /** Why a value of the type cannot be copied to a worker, or null if it can. */
-export function notCopied(type, seen = new Set()) {
+export function notCopied(type, seen = new Set(), tab = false) {
     if (seen.has(type))
         return null;
     seen.add(type);
     const inner = (types) => {
         for (const each of types) {
-            const reason = notCopied(each, seen);
+            const reason = notCopied(each, seen, tab);
             if (reason !== null)
                 return reason;
         }
@@ -61,15 +64,28 @@ export function notCopied(type, seen = new Set()) {
             return 'a component cannot be copied';
         case 'classValue':
             return `the class ${type.info.name} cannot be copied`;
+        // A data class goes with its class (runtime/classes.js), but not to another tab, which may not
+        // have it.
         case 'class':
-            return type.info.name === 'Error'
-                ? null
+            if (type.info.name === 'Error')
+                return null;
+            if (type.info.data === true) {
+                return tab
+                    ? `${typeToString(type)} cannot go to another tab, which may not have its class: send an object of an interface`
+                    : inner(type.args ?? []);
+            }
+            return type.info.data === false && !tab
+                ? `a copy of ${typeToString(type)} would lose its class and methods: mark it to keep them, e.g. data class ${type.info.name}`
                 : `a copy of ${typeToString(type)} would lose its class and methods`;
         case 'object': {
             // A queue goes as its values, and the other thread makes a queue of them (src/runtime/threads.js).
             if (isQueue(type))
                 return inner([queueElement(type)]);
             const name = type.instanceOf?.template.name ?? type.name;
+            // The id of a channel means something only to the workers of the tab that made it.
+            if (tab && (name === 'chan' || name === 'chan<-' || name === '<-chan')) {
+                return `${typeToString(type)} cannot go to another tab: a channel works only within one`;
+            }
             if (name !== null && COPIED.has(name))
                 return inner(type.instanceOf?.args ?? []);
             if (type.call || type.construct)
@@ -84,3 +100,7 @@ export function notCopied(type, seen = new Set()) {
             return null;
     }
 }
+/** Why a value of the type cannot go to another tab through a topic, or null if it can. */
+export function notBroadcast(type) {
+    return notCopied(type, new Set(), true);
+}

package/dist/checker/try.d.ts

@@ -0,0 +1,6 @@
+import type * as ast from '../ast.ts';
+import { DecodeChecker } from './decode.ts';
+import { type Type } from './types.ts';
+export declare abstract class TryChecker extends DecodeChecker {
+    protected checkTryExpression(node: ast.TryExpression): Type;
+}

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;
 }