rooklang 0.0.0-stage → 0.3.0

package/dist/checker/operators.js

@@ -0,0 +1,177 @@
+import { bigintBinary, bigintUnary } from "./bigint.js";
+import { ExpressionChecker } from "./expressions.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";
+// Unary, binary and conditional operators.
+export class OperatorChecker extends ExpressionChecker {
+    /** In the operation of a `select` case, a channel may be null: that case never goes on. */
+    inSelectCase = false;
+    checkUnary(node) {
+        // Only the channel of the case itself may be null, not one inside it.
+        const nullChannel = this.inSelectCase;
+        this.inSelectCase = false;
+        const type = this.checkValue(node.argument);
+        switch (node.operator) {
+            case 'typeof':
+                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);
+                }
+                return awaited(type);
+            case '<-': {
+                const channel = nullChannel && isNullable(type) ? nonNull(type) : type;
+                if (isChan(channel)) {
+                    if (chanDirection(channel) === 'send') {
+                        this.error(`"<-" cannot receive from ${typeToString(channel)}: it only sends; receive from a "chan T" or a "<-chan T"`, node.argument);
+                    }
+                    return received(elementOf(channel));
+                }
+                if (!isUntyped(type)) {
+                    this.error(`"<-" receives from a channel, not from ${typeToString(type)}`, node.argument);
+                }
+                return type.kind === 'any' ? ANY : UNKNOWN;
+            }
+            case '!':
+                this.expectBool(type, node.argument, '"!"');
+                return BOOL;
+            case '-':
+            case '+':
+            case '~': {
+                const bigint = bigintUnary(node.operator, type);
+                if (bigint) {
+                    if (bigint.error)
+                        this.error(bigint.error, node);
+                    return bigint.type;
+                }
+                if (!isNumeric(type)) {
+                    this.error(`"${node.operator}" needs a number, not ${typeToString(type)}`, node.argument);
+                }
+                return NUMBER;
+            }
+        }
+    }
+    expectBool(given, node, operator) {
+        const type = widenLiterals(given);
+        if (type.kind === 'bool' || type.kind === 'any' || type.kind === 'unknown')
+            return;
+        const hint = isNullable(type) ? ': compare it with null, e.g. "x != null"' : '';
+        this.error(`${operator} needs bool, not ${typeToString(type)}${hint}`, node);
+    }
+    checkBinary(node, expected) {
+        const { operator } = node;
+        if (operator === '&&' || operator === '||') {
+            this.expectBool(this.checkValue(node.left, BOOL), node.left, `"${operator}"`);
+            // `x != null && x.ok`: the right side runs only when the left side allows it.
+            const saved = this.flow;
+            this.flow = withNarrowing(saved, this.narrow(node.left, operator === '&&'));
+            this.expectBool(this.checkValue(node.right, BOOL), node.right, `"${operator}"`);
+            this.flow = saved;
+            return BOOL;
+        }
+        if (operator === '??') {
+            const left = this.checkValue(node.left, expected && nullable(expected));
+            const right = this.checkValue(node.right, expected ?? nonNull(left));
+            return this.binaryResult(operator, left, right, node);
+        }
+        const left = this.checkValue(node.left);
+        const right = this.checkValue(node.right, operator === '==' || operator === '!=' ? left : null);
+        return this.binaryResult(operator, left, right, node);
+    }
+    /** The type of `left <operator> right`, also used for compound assignments like `+=`. */
+    binaryResult(operator, givenLeft, givenRight, node) {
+        // Literals behave as their base types, except where they are compared.
+        const keepLiterals = operator === '==' || operator === '!=' || operator === '??';
+        const left = keepLiterals ? givenLeft : widenLiterals(givenLeft);
+        const right = keepLiterals ? givenRight : widenLiterals(givenRight);
+        const untyped = isUntyped(left) || isUntyped(right);
+        const nullHint = isNullable(left) || isNullable(right) ? ': a value may be null, check it first' : '';
+        const bigint = bigintBinary(operator, left, right);
+        if (bigint) {
+            if (bigint.error)
+                this.error(bigint.error, node);
+            return bigint.type;
+        }
+        switch (operator) {
+            case '+':
+                if (left.kind === 'number' && right.kind === 'number')
+                    return NUMBER;
+                if (left.kind === 'string' && right.kind === 'string')
+                    return STRING;
+                if (untyped)
+                    return left.kind === 'string' || right.kind === 'string' ? STRING : ANY;
+                this.error(`cannot add ${typeToString(left)} and ${typeToString(right)}` +
+                    (nullHint ||
+                        (left.kind === 'string' || right.kind === 'string'
+                            ? ': use a template string, e.g. `${a}${b}`'
+                            : '')), node);
+                return UNKNOWN;
+            case '-':
+            case '*':
+            case '/':
+            case '%':
+            case '**':
+            case '<<':
+            case '>>':
+            case '>>>':
+            case '&':
+            case '|':
+            case '^':
+                if (!isNumeric(left) || !isNumeric(right)) {
+                    this.error(`"${operator}" needs numbers, not ${typeToString(left)} and ${typeToString(right)}${nullHint}`, node);
+                }
+                return NUMBER;
+            case '<':
+            case '>':
+            case '<=':
+            case '>=': {
+                const ordered = untyped ||
+                    (left.kind === 'number' && right.kind === 'number') ||
+                    (left.kind === 'string' && right.kind === 'string');
+                if (!ordered) {
+                    this.error(`cannot compare ${typeToString(left)} and ${typeToString(right)} with "${operator}"${nullHint}`, node);
+                }
+                return BOOL;
+            }
+            case '==':
+            case '!=':
+                if (!isComparable(left, right)) {
+                    this.error(`cannot compare ${typeToString(left)} and ${typeToString(right)}`, node);
+                }
+                return BOOL;
+            case 'instanceof':
+                if (!instanceTypeOf(right) && !isUntyped(right)) {
+                    this.error(`the right side of instanceof must be a class, not ${typeToString(right)}`, node);
+                }
+                return BOOL;
+            case '&&':
+            case '||':
+                this.expectBool(left, node, `"${operator}"`);
+                return BOOL;
+            case '??': {
+                if (isUntyped(left))
+                    return left;
+                const base = nonNull(left);
+                if (isAssignable(right, base))
+                    return isNullable(right) ? nullable(base) : base;
+                return commonType(base, right);
+            }
+        }
+    }
+    checkConditional(node, expected) {
+        this.checkCondition(node.test);
+        const before = this.flow;
+        const whenTrue = this.narrow(node.test, true);
+        const whenFalse = this.narrow(node.test, false);
+        this.flow = withNarrowing(before, whenTrue);
+        const consequent = this.checkValue(node.consequent, expected);
+        this.flow = withNarrowing(before, whenFalse);
+        const alternate = this.checkValue(node.alternate, expected);
+        this.flow = before;
+        return commonType(consequent, alternate);
+    }
+}

package/dist/checker/promise.d.ts

@@ -0,0 +1,17 @@
+import { type ObjectType, type Type } from './types.ts';
+/**
+ * `Promise<T>` where there are no TypeScript lib files (the playground): enough to wait for it
+ * and to pass it on. With the lib files, their `Promise` replaces it.
+ */
+export declare const PROMISE: ObjectType;
+/** `Promise<T>` of the global `Promise` type, for the results of an async function. */
+export declare function promiseOf(promise: Type | undefined, results: readonly Type[]): Type;
+/** Whether a type is a `Promise<T>` (or a `PromiseLike<T>` from the lib files). */
+export declare function isPromise(type: Type): type is ObjectType;
+/** What `await` gives: the value of a Promise; a value that is not a Promise is itself. */
+export declare function awaited(type: Type): Type;
+/**
+ * The results the body of an async function returns, from the results of its type: none for
+ * `Promise<void>`, several for a Promise of a tuple.
+ */
+export declare function awaitedResults(results: readonly Type[]): Type[];

package/dist/checker/promise.js

@@ -0,0 +1,49 @@
+import { ANY, func, instantiate, method, VOID } from "./types.js";
+// Promises: the type of what an async function returns, and what `await` gives.
+/**
+ * `Promise<T>` where there are no TypeScript lib files (the playground): enough to wait for it
+ * and to pass it on. With the lib files, their `Promise` replaces it.
+ */
+export const PROMISE = {
+    kind: 'object',
+    name: 'Promise',
+    members: new Map([
+        ['then', method(func([ANY, ANY], [ANY], { required: 1 }))],
+        ['catch', method(func([ANY], [ANY]))],
+        ['finally', method(func([ANY], [ANY]))],
+    ]),
+    call: null,
+    typeParams: [{ kind: 'param', name: 'T' }],
+};
+/** `Promise<T>` of the global `Promise` type, for the results of an async function. */
+export function promiseOf(promise, results) {
+    if (promise?.kind !== 'object' || promise.typeParams?.length !== 1)
+        return ANY;
+    const value = results.length === 0
+        ? VOID
+        : results.length === 1
+            ? results[0]
+            : { kind: 'tuple', types: [...results] };
+    return instantiate(promise, [value]);
+}
+/** Whether a type is a `Promise<T>` (or a `PromiseLike<T>` from the lib files). */
+export function isPromise(type) {
+    return (type.kind === 'object' &&
+        (type.instanceOf?.template.name === 'Promise' ||
+            type.instanceOf?.template.name === 'PromiseLike'));
+}
+/** What `await` gives: the value of a Promise; a value that is not a Promise is itself. */
+export function awaited(type) {
+    return isPromise(type) ? (type.instanceOf.args[0] ?? ANY) : type;
+}
+/**
+ * The results the body of an async function returns, from the results of its type: none for
+ * `Promise<void>`, several for a Promise of a tuple.
+ */
+export function awaitedResults(results) {
+    const [promise] = results;
+    if (promise === undefined)
+        return [];
+    const value = awaited(promise);
+    return value.kind === 'void' ? [] : value.kind === 'tuple' ? value.types : [value];
+}

package/dist/checker/refs.d.ts

@@ -0,0 +1,26 @@
+import type * as ast from '../ast.ts';
+import { type Root } from '../refs.ts';
+import { ComponentValueChecker } from './component-values.ts';
+import type { ComponentInfo } from './context.ts';
+export declare abstract class RefChecker extends ComponentValueChecker {
+    /** The refs of the body of the component or decorator being checked. */
+    private refs;
+    protected checkComponentBody(info: ComponentInfo): void;
+    /** `<Card ref={card} />` binds a ref, so no component has such a property. */
+    protected resolveProps(info: ComponentInfo): void;
+    /** Checks a body whose markup binds the refs it declares. */
+    protected withRefs<T>(body: ast.BlockStatement, check: () => T): T;
+    /** Bindings in markup that may be created more than once, and refs bound twice, are errors. */
+    private bindRefs;
+    /** `ref input` or `ref input HTMLElement`: without a type, it has that of its element. */
+    protected checkRefDeclaration(node: ast.VariableDeclaration): void;
+    /** `ref={input}`: the name of a ref, whose type the element must have. */
+    protected checkRefAttribute(attribute: ast.JsxAttribute, node: ast.ElementExpression): void;
+    /** The type of what an element or a use of a component creates, without checking it. */
+    private boundType;
+    /**
+     * The element at the top of what a component creates, which a ref to it creates in advance; or
+     * why it is not known.
+     */
+    protected rootOf(info: ComponentInfo, seen?: Set<ComponentInfo>): Root;
+}

package/dist/checker/refs.js

@@ -0,0 +1,136 @@
+import { componentRoot, isComponentUse, refBindings } from "../refs.js";
+import { ComponentValueChecker } from "./component-values.js";
+import { lookupIn } from "./helpers.js";
+import { UNKNOWN } from "./types.js";
+// Refs: `ref input` in the body of a component or a decorator, and `<input ref={input} />` in its
+// markup, which gives the ref its element and its type. The element is created where the ref is
+// declared, so the markup must create it exactly once.
+const OUT_OF = (flow) => `move the element out of {${flow}}, or into a component that has a ref of its own`;
+const IN_MARKUP = 'write the element in the markup the component returns';
+const REPEATED = {
+    for: 'inside {for}: the element is created for every item, so a ref cannot point to it; put the element into a component, and each copy gets its own ref',
+    if: `inside {if}: the element is created again when the branch changes, so a ref cannot point to it; ${OUT_OF('if')}`,
+    switch: `inside {switch}: the element is created again when the case changes, so a ref cannot point to it; ${OUT_OF('switch')}`,
+    expression: `inside an expression, which may create the element more than once; ${IN_MARKUP}`,
+    function: `inside a function, which may create the element more than once; ${IN_MARKUP}`,
+    block: `inside a block of the body, which may create the element more than once; ${IN_MARKUP}`,
+};
+export class RefChecker extends ComponentValueChecker {
+    /** The refs of the body of the component or decorator being checked. */
+    refs = null;
+    checkComponentBody(info) {
+        this.withRefs(info.node.body, () => super.checkComponentBody(info));
+        // Other modules find what <Card ref={card} /> creates here: the tags are names of this module.
+        info.root = this.rootOf(info);
+    }
+    /** `<Card ref={card} />` binds a ref, so no component has such a property. */
+    resolveProps(info) {
+        super.resolveProps(info);
+        const param = info.node.params.find((each) => each.name.name === 'ref');
+        if (param) {
+            this.error('a component cannot have the property "ref": ref={...} binds a ref', param.name);
+        }
+    }
+    /** Checks a body whose markup binds the refs it declares. */
+    withRefs(body, check) {
+        const saved = this.refs;
+        this.refs = this.bindRefs(body);
+        try {
+            return check();
+        }
+        finally {
+            this.refs = saved;
+        }
+    }
+    /** Bindings in markup that may be created more than once, and refs bound twice, are errors. */
+    bindRefs(body) {
+        const declared = new Set();
+        for (const statement of body.body) {
+            if (statement.kind !== 'VariableDeclaration' || statement.keyword !== 'ref')
+                continue;
+            for (const name of statement.names)
+                declared.add(name.name);
+        }
+        const bound = { targets: new Map(), mentioned: new Set() };
+        for (const { attribute, element, repeated } of refBindings(body)) {
+            const { value } = attribute;
+            // Other names are not refs of this body: checkRefAttribute reports them.
+            if (value?.kind !== 'Identifier' || !declared.has(value.name))
+                continue;
+            const { name } = value;
+            bound.mentioned.add(name);
+            if (repeated !== null) {
+                this.error(`ref={${name}} is ${REPEATED[repeated]}`, attribute);
+            }
+            else if (bound.targets.has(name)) {
+                this.error(`ref "${name}" is already bound to another element; a ref points to one element`, attribute);
+            }
+            else {
+                bound.targets.set(name, element);
+            }
+        }
+        return bound;
+    }
+    /** `ref input` or `ref input HTMLElement`: without a type, it has that of its element. */
+    checkRefDeclaration(node) {
+        const declared = node.type ? this.resolveType(node.type) : null;
+        for (const name of node.names) {
+            const target = this.refs?.targets.get(name.name);
+            if (!target && !this.refs?.mentioned.has(name.name)) {
+                this.error(`ref "${name.name}" is not bound to an element; add ref={${name.name}} to one, e.g. <div ref={${name.name}}>`, name);
+            }
+            this.declareValue(name, 'ref', declared ?? (target ? this.boundType(target) : UNKNOWN));
+        }
+    }
+    /** `ref={input}`: the name of a ref, whose type the element must have. */
+    checkRefAttribute(attribute, node) {
+        const { value } = attribute;
+        if (value?.kind !== 'Identifier') {
+            if (value && value.kind !== 'StringLiteral' && value.kind !== 'EventHandler') {
+                this.checkValue(value);
+            }
+            this.error('ref={...} takes the name of a ref, e.g. ref={input}', attribute);
+            return;
+        }
+        const binding = this.lookupValue(value.name);
+        if (binding?.kind !== 'ref') {
+            if (binding)
+                this.error(`"${value.name}" is not a ref; declare it with ref ${value.name}`, value);
+            else
+                this.checkValue(value);
+            return;
+        }
+        const type = binding.type ?? UNKNOWN;
+        this.checkedTypes.set(value, type);
+        this.expectAssignable(this.boundType(node), type, value, ` for ref "${value.name}"`);
+        if (!isComponentUse(node))
+            return;
+        const tag = node.tag.name;
+        const info = lookupIn(this.moduleScope, tag)?.component;
+        const root = info ? this.rootOf(info) : null;
+        if (typeof root === 'string')
+            this.error(`ref cannot point to <${tag}>: it ${root}`, attribute);
+    }
+    /** The type of what an element or a use of a component creates, without checking it. */
+    boundType(node) {
+        if (node.tag === null)
+            return this.dom.fragment;
+        if (!isComponentUse(node))
+            return this.elementOf(node.tag.name);
+        const info = lookupIn(this.moduleScope, node.tag.name)?.component;
+        return info ? this.componentResult(info, new Set()) : UNKNOWN;
+    }
+    /**
+     * The element at the top of what a component creates, which a ref to it creates in advance; or
+     * why it is not known.
+     */
+    rootOf(info, seen = new Set()) {
+        if (info.root)
+            return info.root;
+        seen.add(info);
+        return componentRoot(info.expanded, (tag) => {
+            const other = lookupIn(this.moduleScope, tag)?.component;
+            return other && !seen.has(other) ? this.rootOf(other, seen) : undefined;
+        });
+    }
+}

package/dist/checker/resolution.d.ts

@@ -0,0 +1,23 @@
+import type * as ast from '../ast.ts';
+import { ClassChecker } from './classes.ts';
+import type { AliasEntry } from './context.ts';
+import { type Type } from './types.ts';
+export declare abstract class TypeResolver extends ClassChecker {
+    protected resolveType(node: ast.TypeNode): Type;
+    /** `comp(title string, children Content)`: properties of type `?T` and `children` may be left out. */
+    private resolveComponentType;
+    /**
+     * The typed array of `[]T` when `T` is `byte`, `float64` or another element of one, unless the
+     * program declares a type of that name: `Float64Array`.
+     */
+    private typedArrayClass;
+    /** A typed array of the lib files, with its default type argument, or the built-in one. */
+    protected typedArray(name: string): Type;
+    /** `[]byte`, a Uint8Array. */
+    protected bytes(): Type;
+    protected resolveTypeName(name: ast.Identifier, typeArgs?: readonly ast.TypeNode[]): Type;
+    protected resolveAlias(entry: AliasEntry): Type;
+    protected resolveAliasType(entry: AliasEntry): Type;
+    /** The type of a variable initialized with a value of type `type`. */
+    protected inferredType(type: Type, node: ast.Expression): Type;
+}

package/dist/checker/resolution.js

@@ -0,0 +1,173 @@
+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, 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) {
+        switch (node.kind) {
+            case 'TypeReference':
+                return this.resolveTypeName(node.name, node.typeArgs);
+            case 'ArrayType': {
+                const typed = this.typedArrayClass(node.element);
+                return typed === null ? arrayOf(this.resolveType(node.element)) : this.typedArray(typed);
+            }
+            case 'ChanType':
+                return chanOf(this.resolveType(node.element), node.direction);
+            case 'NullableType':
+                return nullable(this.resolveType(node.type));
+            case 'FuncType':
+                return func(node.params.map((param) => this.resolveType(param)), node.results.map((result) => this.resolveType(result)), { iterator: node.iterator === true });
+            case 'ComponentType':
+                return this.resolveComponentType(node);
+            case 'ObjectType': {
+                const object = { kind: 'object', name: null, members: new Map(), call: null };
+                this.fillMembers(object, node.members);
+                return object;
+            }
+            case 'UnionType':
+                return union(node.types.map((type) => this.resolveType(type)));
+            case 'LiteralType':
+                return literal(node.value.value);
+        }
+    }
+    /** `comp(title string, children Content)`: properties of type `?T` and `children` may be left out. */
+    resolveComponentType(node) {
+        const params = [];
+        for (const param of node.params) {
+            const name = param.name.name;
+            const type = param.type ? this.resolveType(param.type) : UNKNOWN;
+            if (name === 'children' && type !== CONTENT && type.kind !== 'unknown') {
+                this.error('the "children" property has the type Content', param.type ?? param);
+            }
+            if (params.some((other) => other.name === name)) {
+                this.error(`duplicate property "${name}"`, param.name);
+            }
+            params.push({ name, type, optional: isNullable(type) || name === 'children' });
+        }
+        return { kind: 'component', params };
+    }
+    /**
+     * The typed array of `[]T` when `T` is `byte`, `float64` or another element of one, unless the
+     * program declares a type of that name: `Float64Array`.
+     */
+    typedArrayClass(node) {
+        if (node.kind !== 'TypeReference' || node.typeArgs.length > 0)
+            return null;
+        const typed = TYPED_ELEMENTS.get(node.name.name);
+        if (typed === undefined)
+            return null;
+        return this.lookupType(node.name.name) === (holdsBigInts(typed) ? BIGINT : NUMBER)
+            ? typed
+            : null;
+    }
+    /** A typed array of the lib files, with its default type argument, or the built-in one. */
+    typedArray(name) {
+        const library = this.options.library?.type(name);
+        if (library?.kind === 'object' && library.typeParams) {
+            return instantiate(library, library.typeParams.map((param) => param.default ?? ANY));
+        }
+        return library ?? builtInTypedArray(name);
+    }
+    /** `[]byte`, a Uint8Array. */
+    bytes() {
+        return this.typedArray('Uint8Array');
+    }
+    resolveTypeName(name, typeArgs = []) {
+        const entry = this.lookupType(name.name);
+        if (entry === undefined) {
+            this.error(this.lookupValue(name.name)
+                ? `"${name.name}" is a value, not a type`
+                : `unknown type "${name.name}"`, name);
+            return UNKNOWN;
+        }
+        const args = typeArgs.map((arg) => this.resolveType(arg));
+        const type = entry.kind === 'alias' ? this.resolveAlias(entry) : entry;
+        const params = entry.kind === 'alias'
+            ? entry.params
+            : type.kind === 'object'
+                ? (type.typeParams ?? [])
+                : type.kind === 'class'
+                    ? type.info.typeParams
+                    : [];
+        if (params.length === 0) {
+            if (args.length > 0)
+                this.error(`"${name.name}" is not generic`, typeArgs[0]);
+            return type;
+        }
+        // Parameters with defaults (from a `.d.ts`) may be left out: `Buffer` is `Buffer<ArrayBufferLike>`.
+        const required = params.filter((param) => !param.default).length;
+        if (args.length >= required && args.length < params.length) {
+            args.push(...params.slice(args.length).map((param) => param.default));
+        }
+        if (args.length !== params.length) {
+            this.error(args.length === 0
+                ? `"${name.name}" needs type arguments: ${name.name}<${params.map((param) => param.name).join(', ')}>`
+                : `"${name.name}" takes ${params.length} type argument${params.length === 1 ? '' : 's'}, got ${args.length}`, name);
+            return UNKNOWN;
+        }
+        params.forEach((param, i) => {
+            if (param.constraint && !isAssignable(args[i], param.constraint)) {
+                this.error(`${typeToString(args[i])} does not satisfy the constraint ${typeToString(param.constraint)} of ${param.name}`, typeArgs[i]);
+            }
+        });
+        if (type.kind === 'class')
+            return classInstance(type.info, args);
+        if (type.kind === 'object' && type.typeParams)
+            return instantiate(type, args);
+        return substitute(type, bindParams(params, args));
+    }
+    resolveAlias(entry) {
+        if (entry.resolved)
+            return entry.resolved;
+        const { node } = entry;
+        if (entry.resolving) {
+            this.error(`type "${node.name.name}" refers to itself`, node.name);
+            return UNKNOWN;
+        }
+        const saved = this.scope;
+        this.scope = entry.scope;
+        try {
+            return this.withTypeParams(entry.params, node.typeParams, () => this.resolveAliasType(entry));
+        }
+        finally {
+            entry.resolving = false;
+            this.scope = saved;
+        }
+    }
+    resolveAliasType(entry) {
+        const { node } = entry;
+        if (node.type.kind === 'ObjectType') {
+            // Registered before its members, so that they can refer to the type itself.
+            const object = {
+                kind: 'object',
+                name: node.name.name,
+                members: new Map(),
+                call: null,
+            };
+            if (entry.params.length > 0)
+                object.typeParams = entry.params;
+            entry.resolved = object;
+            this.fillMembers(object, node.type.members);
+            return object;
+        }
+        entry.resolving = true;
+        const resolved = this.resolveType(node.type);
+        // A union keeps the alias name for messages: `cannot use "activ" as Filter`.
+        entry.resolved = resolved.kind === 'union' ? { ...resolved, name: node.name.name } : resolved;
+        return entry.resolved;
+    }
+    /** The type of a variable initialized with a value of type `type`. */
+    inferredType(type, node) {
+        if (type.kind === 'null') {
+            this.error('cannot infer a type from null: declare it, e.g. "let x ?User = null"', node);
+            return UNKNOWN;
+        }
+        if (type.kind === 'array' && type.element.kind === 'never') {
+            this.error('cannot infer the type of an empty array: declare it, e.g. "let xs []number"', node);
+            return UNKNOWN;
+        }
+        return type;
+    }
+}

package/dist/checker/statements.d.ts

@@ -0,0 +1,28 @@
+import type * as ast from '../ast.ts';
+import { AssignmentChecker } from './assignments.ts';
+export declare abstract class StatementChecker extends AssignmentChecker {
+    /** `ch <- value`; implemented by ChannelChecker. */
+    protected abstract checkSend(node: ast.SendStatement): void;
+    /** `select { ... }`; implemented by ChannelChecker. */
+    protected abstract checkSelect(node: ast.SelectStatement): void;
+    protected checkStatement(node: ast.Statement): void;
+    /**
+     * `effect { ... }`: runs once the markup is created and again when what it reads changes, like
+     * a handler. It cleans up with `defer`, so it returns nothing.
+     */
+    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.
+     */
+    protected checkMount(node: ast.MountStatement): void;
+    /**
+     * `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.
+     */
+    private checkDelete;
+    protected checkBlock(statements: readonly ast.Statement[]): void;
+    protected checkVariableDeclaration(node: ast.VariableDeclaration): void;
+    /** The types of the variables of a declaration: the written one, or those of their values. */
+    private initializerTypes;
+}