rooklang 0.3.3 → 0.3.4

package/dist/checker/json.js

@@ -0,0 +1,92 @@
+import { isQueue, isTopic, memberNames, typedArrayOf, typeToString } from "./types.js";
+// What JSON can hold, for `decode<T>(x)` (decode.ts): numbers, strings, bool, null, literals,
+// arrays, unions and objects without methods. A string is JSON text to decode.
+/** Types that JSON has no way to hold, by name, with what to decode instead. */
+const NOT_IN_JSON = new Map([
+    ['Date', 'JSON has no Date: decode a string and make the Date from it, e.g. new Date(s)'],
+    ['Map', 'JSON has no Map: decode an object or an array of pairs and make the Map from it'],
+    ['Set', 'JSON has no Set: decode an array and make the Set from it, e.g. new Set(items)'],
+    ['RegExp', 'JSON has no RegExp: decode a string and make it with new RegExp(s)'],
+    ['Promise', 'a Promise cannot come from JSON'],
+    ['chan', 'a channel cannot come from JSON'],
+    ['chan<-', 'a channel cannot come from JSON'],
+    ['<-chan', 'a channel cannot come from JSON'],
+]);
+/** Why a value of the type cannot come from JSON, or null if it can. */
+export function notDecoded(type, seen = new Set()) {
+    if (seen.has(type))
+        return null;
+    seen.add(type);
+    const inner = (types) => {
+        for (const each of types) {
+            const reason = notDecoded(each, seen);
+            if (reason !== null)
+                return reason;
+        }
+        return null;
+    };
+    switch (type.kind) {
+        case 'number':
+        case 'string':
+        case 'bool':
+        case 'null':
+        case 'literal':
+        case 'any':
+        case 'unknown':
+            return null;
+        case 'bigint':
+            return 'JSON has no bigint: decode a string and make it with BigInt(s)';
+        case 'nullable':
+            return inner([type.type]);
+        case 'array':
+            return inner([type.element]);
+        case 'union':
+            return inner(type.types);
+        case 'param':
+            return `${type.name} is a type parameter: decode needs a type known when the program compiles`;
+        case 'function':
+            return 'a function cannot come from JSON';
+        case 'component':
+            return 'a component cannot come from JSON';
+        case 'classValue':
+            return `the class ${type.info.name} cannot come from JSON`;
+        case 'class':
+            return (NOT_IN_JSON.get(type.info.name) ??
+                `decode gives plain objects, without the methods of the class ${type.info.name}: decode an interface with its fields`);
+        case 'object': {
+            const name = type.instanceOf?.template.name ?? type.name;
+            const known = name === null ? undefined : NOT_IN_JSON.get(name);
+            if (known !== undefined)
+                return known;
+            if (isQueue(type))
+                return 'JSON has no queue: decode an array and make the queue from it';
+            if (isTopic(type))
+                return 'a topic cannot come from JSON';
+            if (typedArrayOf(type) !== null)
+                return `JSON has no ${typeToString(type)}`;
+            if (type.call || type.construct) {
+                return `${typeToString(type)} is a function and cannot come from JSON`;
+            }
+            const members = [...memberNames(type.members)].flatMap((name) => type.members.get(name) ?? []);
+            if (members.some((member) => member.method)) {
+                return `${typeToString(type)} has methods, and JSON gives only data: decode an interface with its fields`;
+            }
+            return inner([...members.map((member) => member.type), ...(type.index ? [type.index] : [])]);
+        }
+        default:
+            return `${typeToString(type)} cannot come from JSON`;
+    }
+}
+/** Whether a value of the type is always a string: then decode reads it as JSON text. */
+export function isText(type) {
+    switch (type.kind) {
+        case 'string':
+            return true;
+        case 'literal':
+            return typeof type.value === 'string';
+        case 'union':
+            return type.types.every(isText);
+        default:
+            return false;
+    }
+}

package/dist/checker/loops.js

@@ -1,10 +1,11 @@
 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";
+import { asyncIterated, isMap, loopEntry } from "./iterables.js";
+import { ANY, isNullable, isTopic, NUMBER, STRING, topicElement, 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)`.
+// values), channels and async iterables, such as the streams of Node, 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);
@@ -26,6 +27,16 @@ export class LoopChecker extends BytesChecker {
                 this.error(`${typeToString(iterable)} has no keys: loop over its values, e.g. "for value in items"`, node.key);
             }
         }
+        else if (asyncIterated(iterable) !== null) {
+            // `for await` of JS: each value waits for the Promise of next().
+            value = asyncIterated(iterable);
+            if (this.fn && !this.fn.isAsync) {
+                this.error(`"for ... in" ${typeToString(iterable)} 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(`${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);
         }
@@ -41,6 +52,15 @@ export class LoopChecker extends BytesChecker {
             if (node.key)
                 this.error('a channel has no keys: write "for value in ch"', node.key);
         }
+        else if (isTopic(iterable)) {
+            // Each value waits for another tab to send one, until the topic is closed.
+            value = topicElement(iterable);
+            if (this.fn && !this.fn.isAsync) {
+                this.error('"for ... in" a topic 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 topic has no keys: write "for value in t"', node.key);
+        }
         else if (iterable.kind === 'string') {
             value = STRING;
         }

package/dist/checker/members.js

@@ -39,6 +39,13 @@ export class MemberChecker extends DecoratorMemberChecker {
         }
         if (node.kind === 'MemberExpression') {
             const member = this.findMember(object, node.property.name, node.property);
+            const { name } = node.property;
+            if (member !== 'any' && member?.accessor === 'set') {
+                this.error(`cannot read "${name}": it has a setter and no getter`, node.property);
+            }
+            else if (member !== 'any' && member?.abstract && node.object.kind === 'SuperExpression') {
+                this.error(`super.${name} is abstract in ${member.owner?.name ?? 'the base class'}: it has no code to run`, node.property);
+            }
             return [member === 'any' ? ANY : (member?.type ?? UNKNOWN), shortCircuits];
         }
         const keyed = this.keyedIndex(object, node.index);

package/dist/checker/operators.d.ts

@@ -1,7 +1,7 @@
 import type * as ast from '../ast.ts';
-import { ExpressionChecker } from './expressions.ts';
+import { ArrayLiteralChecker } from './array-literals.ts';
 import { type Type } from './types.ts';
-export declare abstract class OperatorChecker extends ExpressionChecker {
+export declare abstract class OperatorChecker extends ArrayLiteralChecker {
     /** In the operation of a `select` case, a channel may be null: that case never goes on. */
     protected inSelectCase: boolean;
     protected checkUnary(node: ast.UnaryExpression): Type;

package/dist/checker/operators.js

@@ -1,12 +1,12 @@
 import { bigintBinary, bigintUnary } from "./bigint.js";
-import { ExpressionChecker } from "./expressions.js";
+import { ArrayLiteralChecker } from "./array-literals.js";
 import { withNarrowing } from "./flow.js";
 import { isUntyped, isNumeric, instanceTypeOf } from "./helpers.js";
 import { chanDirection, elementOf, isChan, received } from "./channel.js";
 import { awaited } from "./promise.js";
-import { ANY, BOOL, commonType, isAssignable, isComparable, isNullable, nonNull, nullable, NUMBER, STRING, typeToString, UNKNOWN, widenLiterals, } from "./types.js";
+import { ANY, BOOL, commonType, isAssignable, isComparable, isNullable, isTopic, nonNull, nullable, NUMBER, STRING, topicElement, typeToString, UNKNOWN, widenLiterals, } from "./types.js";
 // Unary, binary and conditional operators.
-export class OperatorChecker extends ExpressionChecker {
+export class OperatorChecker extends ArrayLiteralChecker {
     /** In the operation of a `select` case, a channel may be null: that case never goes on. */
     inSelectCase = false;
     checkUnary(node) {
@@ -19,8 +19,8 @@ export class OperatorChecker extends ExpressionChecker {
                 return STRING;
             // What the Promise gives; the results of an async function are unpacked from it.
             case 'await':
-                if (isChan(type)) {
-                    this.error('"await" does not wait for a channel: receive from it, e.g. "<-ch"', node);
+                if (isChan(type) || isTopic(type)) {
+                    this.error(`"await" does not wait for a ${isChan(type) ? 'channel' : 'topic'}: receive from it, e.g. "<-ch"`, node);
                 }
                 return awaited(type);
             case '<-': {
@@ -31,6 +31,8 @@ export class OperatorChecker extends ExpressionChecker {
                     }
                     return received(elementOf(channel));
                 }
+                if (isTopic(channel))
+                    return received(topicElement(channel));
                 if (!isUntyped(type)) {
                     this.error(`"<-" receives from a channel, not from ${typeToString(type)}`, node.argument);
                 }

package/dist/checker/queues.d.ts

@@ -1,6 +1,6 @@
 import type * as ast from '../ast.ts';
-import { ChannelChecker } from './channels.ts';
+import { SignalChecker } from './signals.ts';
 import { type Type } from './types.ts';
-export declare abstract class QueueChecker extends ChannelChecker {
+export declare abstract class QueueChecker extends SignalChecker {
     protected checkQueue(node: ast.QueueExpression): Type;
 }

package/dist/checker/queues.js

@@ -1,9 +1,9 @@
-import { ChannelChecker } from "./channels.js";
+import { SignalChecker } from "./signals.js";
 import { isUntyped } from "./helpers.js";
 import { arrayOf, queueOf, typeToString } from "./types.js";
 // Queues: `queue<number>()` makes an empty one, `queue<number>(items)` one with the values of an
 // array or of another iterable. The members of `queue T` are in types/queue.ts.
-export class QueueChecker extends ChannelChecker {
+export class QueueChecker extends SignalChecker {
     checkQueue(node) {
         const element = this.resolveType(node.element);
         if (node.items) {

package/dist/checker/resolution.js

@@ -2,7 +2,7 @@ import { holdsBigInts, TYPED_ELEMENTS } from "../typed-arrays.js";
 import { chanOf } from "./channel.js";
 import { ClassChecker } from "./classes.js";
 import { CONTENT } from "./dom.js";
-import { ANY, arrayOf, BIGINT, bindParams, builtInTypedArray, classInstance, func, instantiate, isAssignable, isNullable, literal, nullable, NUMBER, queueOf, substitute, typeToString, union, UNKNOWN, } from "./types.js";
+import { ANY, arrayOf, BIGINT, bindParams, builtInTypedArray, classInstance, func, instantiate, isAssignable, isNullable, literal, nullable, NUMBER, queueOf, topicOf, substitute, typeToString, union, UNKNOWN, } from "./types.js";
 // Type annotations as types: names, aliases, generics with their arguments; and the type a variable gets from its value.
 export class TypeResolver extends ClassChecker {
     resolveType(node) {
@@ -17,6 +17,8 @@ export class TypeResolver extends ClassChecker {
                 return chanOf(this.resolveType(node.element), node.direction);
             case 'QueueType':
                 return queueOf(this.resolveType(node.element));
+            case 'TopicType':
+                return topicOf(this.resolveType(node.element));
             case 'NullableType':
                 return nullable(this.resolveType(node.type));
             case 'FuncType':
@@ -81,8 +83,8 @@ export class TypeResolver extends ClassChecker {
         if (entry === undefined) {
             this.error(this.lookupValue(name.name)
                 ? `"${name.name}" is a value, not a type`
-                : name.name === 'queue'
-                    ? 'a queue type is written with the type of its values after it, e.g. "queue number"'
+                : name.name === 'queue' || name.name === 'topic'
+                    ? `a ${name.name} type is written with the type of its values after it, e.g. "${name.name} number"`
                     : `unknown type "${name.name}"`, name);
             return UNKNOWN;
         }

package/dist/checker/signals.d.ts

@@ -0,0 +1,8 @@
+import type * as ast from '../ast.ts';
+import { ChannelChecker } from './channels.ts';
+import { type Type } from './types.ts';
+export declare abstract class SignalChecker extends ChannelChecker {
+    protected checkCall(node: ast.CallExpression, callee: Type, expected?: Type | null): Type;
+    /** `signal("SIGINT", "SIGTERM")`: at least one name, and the names are those of signals. */
+    private checkSignalNames;
+}

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