rooklang 0.3.2 → 0.3.4

package/dist/checker/classes.js

@@ -1,9 +1,10 @@
 import { inlinePackages } from "../inline-packages.js";
-import { DeclarationChecker } from "./declarations.js";
+import { ClassMemberChecker } from "./class-members.js";
 import { isSuperCall, assignsField } from "./helpers.js";
+import { notCopied } from "./transfer.js";
 import { explainMismatch, findClassMember, hasZeroValue, isAssignable, isSubclass, typeToString, UNKNOWN, } from "./types.js";
 // Classes: their base class and members, method bodies, overrides and `implements`; and the declarations a module exports.
-export class ClassChecker extends DeclarationChecker {
+export class ClassChecker extends ClassMemberChecker {
     ensureClassResolved(info) {
         const resolve = this.unresolvedClasses.get(info);
         if (!resolve || this.resolvingClasses.has(info))
@@ -49,6 +50,9 @@ export class ClassChecker extends DeclarationChecker {
                 this.error(`cannot extend ${typeToString(base)}: it is not a class`, node.superClass);
             }
         }
+        if (node.data)
+            this.checkDataBase(node, info);
+        info.abstract = node.abstract === true;
         for (const member of node.members) {
             switch (member.kind) {
                 case 'FieldDeclaration': {
@@ -62,20 +66,31 @@ export class ClassChecker extends DeclarationChecker {
                         else
                             type = this.inferredType(valueType, value);
                     }
+                    // The fields of a data class are what goes to another thread.
+                    const reason = node.data && !member.isStatic ? notCopied(type) : null;
+                    if (reason !== null) {
+                        this.error(`the fields of a data class go to other threads as copies: ${reason}`, member.type ?? member.name);
+                    }
                     this.declareMember(info, member.isStatic, member.name, {
                         type,
                         method: false,
                         visibility: member.visibility,
                         owner: info,
+                        ...(member.readonly ? { readonly: true } : {}),
                     });
                     break;
                 }
                 case 'MethodDeclaration':
+                    if (member.accessor) {
+                        this.declareAccessor(info, member, member.accessor);
+                        break;
+                    }
                     this.declareMember(info, member.isStatic, member.name, {
                         type: this.signature(member.params, member.results, member.async),
                         method: true,
                         visibility: member.visibility,
                         owner: info,
+                        ...(member.abstract ? { abstract: true } : {}),
                     });
                     break;
                 case 'ConstructorDeclaration':
@@ -83,15 +98,20 @@ export class ClassChecker extends DeclarationChecker {
                         this.error('a class can have only one constructor', member);
                     info.ctor = this.signature(member.params, []);
                     info.ctorVisibility = member.visibility;
+                    this.declareParamProperties(member, info, info.ctor);
                     break;
             }
         }
     }
-    declareMember(info, isStatic, name, member) {
-        const members = isStatic ? info.statics : info.members;
-        if (members.has(name.name))
-            this.error(`duplicate member "${name.name}"`, name);
-        members.set(name.name, member);
+    /** A data class extends only a data class: its fields go with it, and its class is restored. */
+    checkDataBase(node, info) {
+        const base = info.superClass;
+        if (info.untypedBase) {
+            this.error('a data class cannot extend a class of JS: its copy in another thread could not get the class back', node.superClass);
+        }
+        else if (base && base.data !== true) {
+            this.error(`a data class extends only a data class: mark ${base.name} as one, e.g. data class ${base.name}`, node.superClass);
+        }
     }
     /** Method bodies and the checks that need every member of the class. */
     checkClassBodies(node, info) {
@@ -101,13 +121,18 @@ export class ClassChecker extends DeclarationChecker {
         let constructorNode = null;
         for (const member of node.members) {
             if (member.kind === 'MethodDeclaration') {
-                const type = (member.isStatic ? info.statics : info.members).get(member.name.name)?.type;
+                const { body } = member;
+                const type = member.accessor
+                    ? this.accessorSignatures.get(member)
+                    : (member.isStatic ? info.statics : info.members).get(member.name.name)?.type;
                 if (type?.kind !== 'function')
                     continue;
-                this.withClass({ info, isStatic: member.isStatic }, () => this.checkFunction(member.params, type, type.results, member.body, {
-                    async: member.async,
-                }));
+                if (body) {
+                    this.withClass({ info, isStatic: member.isStatic }, () => this.checkFunction(member.params, type, type.results, body, { async: member.async }));
+                }
                 this.checkOverride(info, member);
+                if (member.accessor)
+                    this.checkAccessorOverride(info, member.name, member.isStatic);
             }
             else if (member.kind === 'ConstructorDeclaration' && info.ctor) {
                 constructorNode = member;
@@ -119,9 +144,13 @@ export class ClassChecker extends DeclarationChecker {
                 }
             }
         }
+        this.checkAbstract(node, info);
         // Fields without a zero value must get one at once or in the constructor.
         for (const member of node.members) {
-            if (member.kind !== 'FieldDeclaration' || member.isStatic || member.value)
+            if (member.kind !== 'FieldDeclaration')
+                continue;
+            this.checkAccessorOverride(info, member.name, member.isStatic);
+            if (member.isStatic || member.value)
                 continue;
             const type = info.members.get(member.name.name)?.type;
             if (!type || hasZeroValue(type))

package/dist/checker/closing.d.ts

@@ -0,0 +1,21 @@
+import type * as ast from '../ast.ts';
+import type { Binding, BindingKind } from './context.ts';
+import { IteratorChecker } from './iterators.ts';
+import type { Type } from './types.ts';
+export declare abstract class ClosingChecker extends IteratorChecker {
+    /** The identifier that declares a binding of this module. */
+    private readonly declarations;
+    /** What each name refers to: its declaration, or the name of a predeclared value. */
+    private readonly references;
+    protected declareValue(id: ast.Identifier, kind: BindingKind, type: Type | null): Binding;
+    protected checkIdentifier(node: ast.Identifier): Type;
+    /** The functions declared in the module, by their names, which `use` looks arguments up in. */
+    private functions;
+    protected checkClosing(): void;
+    /** `chan<T>()`, `topic<T>()`, `tick(ms)`, `signal(name)` and their `Channel.make` and the like. */
+    private made;
+    /** `Channel.close` and the like, as a name, when `Channel` is the predeclared one. */
+    private predeclaredMember;
+    /** What the code around a name of a channel does with it. */
+    private use;
+}

package/dist/checker/closing.js

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

package/dist/checker/completion.d.ts

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

package/dist/checker/completion.js

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

package/dist/checker/context.d.ts

@@ -64,6 +64,8 @@ export interface CheckResult {
     declarations: ModuleExports;
     /** Types of checked expressions, for code generation (e.g. how to insert element children). */
     types: WeakMap<ast.Expression, Type>;
+    /** The data classes that the module declares or imports, by their names here. */
+    dataClasses: Set<string>;
     /** With the `completion` option: what can be written at the cursor, if the check reached it. */
     completion?: CompletionResult;
 }
@@ -78,6 +80,17 @@ export interface Completion {
     kind: 'variable' | 'constant' | 'function' | 'class' | 'component' | 'type' | 'property' | 'method' | 'keyword' | 'tag' | 'attribute';
     /** The type, as Rook writes it. */
     detail?: string;
+    /** A name exported by another module of the package: choosing it imports it (auto-import.ts). */
+    import?: {
+        specifier: string;
+        edit: TextEdit;
+    };
+}
+/** A change of the text of a module: what is between the offsets becomes `text`. */
+export interface TextEdit {
+    start: number;
+    end: number;
+    text: string;
 }
 export type BindingKind = 'let' | 'const' | 'state' | 'derived' | 'ref' | 'param' | 'prop' | 'function' | 'class' | 'import' | 'loop' | 'catch' | 'builtin' | 'component';
 export interface Binding {
@@ -87,6 +100,12 @@ export interface Binding {
     type: Type | null;
     /** For components, which exist only at compile time and are used as tags. */
     component?: ComponentInfo;
+    /**
+     * `const user, err = loadUser(id)` of `(User, error)`: the error has the values that are not null
+     * once it is null, and each of them has the error (error-results.ts).
+     */
+    guards?: Binding[];
+    guardedBy?: Binding;
 }
 export interface ComponentInfo {
     node: ast.ComponentDeclaration;

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

@@ -5,6 +5,11 @@ export declare abstract class ControlFlowChecker extends StatementChecker {
     protected checkIf(node: ast.IfStatement): void;
     protected checkFor(node: ast.ForStatement): void;
     protected checkSimpleStatement(node: ast.SimpleStatement): void;
+    /**
+     * `if const v = f(); v > 0 { }`: the variables of the initializer are in a scope of their own,
+     * around every branch. Returns whether `check` checked the statement inside it.
+     */
+    private checkWithInit;
     protected checkSwitch(node: ast.SwitchStatement): void;
     /**
      * `switch filter { case "all": ... default: ... }`: in a case the discriminant has the literals
@@ -17,6 +22,7 @@ export declare abstract class ControlFlowChecker extends StatementChecker {
     protected narrow(node: ast.Expression, assumeTrue: boolean): Narrowing;
     /** `x instanceof Date`: an instance of the class when true, the rest of a union when false. */
     protected narrowInstanceof(left: ast.Expression, right: ast.Expression, assumeTrue: boolean): Narrowing;
+    protected nullError(node: ast.Expression): void;
     protected narrowableBinding(node: ast.Expression): Binding | undefined;
     /** An assignment to a variable ends its narrowing. */
     protected forget(target: ast.Expression): void;

package/dist/checker/control-flow.js

@@ -7,6 +7,8 @@ import { ANY, BOOL, isAssignable, isComparable, isNullable, isSubclass, literal,
 // if, for, switch and try, and how conditions narrow the types of variables in the branches.
 export class ControlFlowChecker extends StatementChecker {
     checkIf(node) {
+        if (this.checkWithInit(node.init, () => this.checkIf({ ...node, init: null })))
+            return;
         this.checkCondition(node.condition);
         const before = this.flow;
         // Both are found from the flow before the `if`, not from the end of a branch.
@@ -52,7 +54,22 @@ export class ControlFlowChecker extends StatementChecker {
     checkSimpleStatement(node) {
         this.checkStatement(node);
     }
+    /**
+     * `if const v = f(); v > 0 { }`: the variables of the initializer are in a scope of their own,
+     * around every branch. Returns whether `check` checked the statement inside it.
+     */
+    checkWithInit(init, check) {
+        if (init === null)
+            return false;
+        this.withScope(() => {
+            this.checkStatement(init);
+            check();
+        });
+        return true;
+    }
     checkSwitch(node) {
+        if (this.checkWithInit(node.init, () => this.checkSwitch({ ...node, init: null })))
+            return;
         const discriminant = node.discriminant ? this.checkValue(node.discriminant) : null;
         this.dropNarrowing(assignedNames(node));
         const entry = this.flow;
@@ -170,6 +187,14 @@ export class ControlFlowChecker extends StatementChecker {
             if (binding?.type)
                 return [[binding, nonNull(this.flow.get(binding) ?? binding.type)]];
         }
+        // `err == null` when true, `err != null` when false: the values returned with `err` are not
+        // null (error-results.ts).
+        if ((operator === '==' && assumeTrue) || (operator === '!=' && !assumeTrue)) {
+            const target = right.kind === 'NullLiteral' ? left : left.kind === 'NullLiteral' ? right : null;
+            const guards = target ? this.narrowableBinding(target)?.guards : undefined;
+            if (guards)
+                return guards.map((value) => [value, nonNull(this.flow.get(value) ?? value.type)]);
+        }
         if (operator === 'instanceof')
             return this.narrowInstanceof(left, right, assumeTrue);
         if (operator !== '==' && operator !== '!=')
@@ -219,6 +244,15 @@ export class ControlFlowChecker extends StatementChecker {
             : !isAssignable(member, instance));
         return [[binding, union(isNullable(current) ? [...kept, NULL] : kept)]];
     }
+    nullError(node) {
+        const name = node.kind === 'Identifier' ? node.name : null;
+        const error = name !== null ? this.lookupValue(name)?.guardedBy?.name : undefined;
+        this.error(error !== undefined
+            ? `"${name}" may be null until "${error}" is checked: e.g. if ${error} != null { return }`
+            : name !== null
+                ? `"${name}" may be null: check it with "if ${name} != null" or use "?."`
+                : 'this value may be null: check it for null or use "?."', node);
+    }
     narrowableBinding(node) {
         if (node.kind !== 'Identifier')
             return undefined;

package/dist/checker/declarations.js

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

package/dist/checker/decode.d.ts

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

package/dist/checker/decode.js

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

package/dist/checker/error-results.d.ts

@@ -0,0 +1,6 @@
+import { type Type } from './types.ts';
+export declare function isErrorType(type: Type): boolean;
+/** Positions of the results that may be null only together with an error: all before it. */
+export declare function guardedByError(results: readonly Type[]): number[];
+/** The types of the unpacked results: those before the error may be null. */
+export declare function unpackedResults(results: readonly Type[]): Type[];

package/dist/checker/error-results.js

@@ -0,0 +1,31 @@
+import { ERROR, isNullable, nullable, typesEqual } from "./types.js";
+// Values returned with an error: in `(User, error)` the function may return `null, err` instead of
+// a User, as long as the error is not null. So where the results are unpacked, the values before
+// the error may be null, and they are not null once the error is found to be null. A result that
+// is nullable itself, as in `(?User, error)`, may be null without an error too.
+export function isErrorType(type) {
+    return typesEqual(type, ERROR);
+}
+/** Positions of the results that may be null only together with an error: all before it. */
+export function guardedByError(results) {
+    if (results.length < 2 || !isErrorType(results.at(-1)))
+        return [];
+    return results.flatMap((type, i) => (i < results.length - 1 && canBeGuarded(type) ? [i] : []));
+}
+/** The types of the unpacked results: those before the error may be null. */
+export function unpackedResults(results) {
+    const guarded = guardedByError(results);
+    return results.map((type, i) => (guarded.includes(i) ? nullable(type) : type));
+}
+function canBeGuarded(type) {
+    switch (type.kind) {
+        case 'any':
+        case 'unknown':
+        case 'void':
+        case 'never':
+        case 'null':
+            return false;
+        default:
+            return !isNullable(type);
+    }
+}

package/dist/checker/expressions.d.ts

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

package/dist/checker/expressions.js

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