rooklang 0.3.3 → 0.4.0

package/dist/build.js

@@ -1,6 +1,7 @@
 import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
-import { dirname, join, relative, resolve, sep } from 'node:path';
+import { basename, dirname, join, relative, resolve, sep } from 'node:path';
 import { compile } from "./index.js";
+import { sourceMapComment } from "./source-map.js";
 import { SourceFile } from "./source.js";
 /**
  * Compiles `.rk` files and directories (recursively), together with every `.rk` file they
@@ -47,6 +48,8 @@ export function build(entries, options = {}) {
                 code: result.code,
                 declarations: result.declarations,
                 worker: result.worker,
+                map: result.map,
+                workerMap: result.workerMap,
             });
         }
         for (const specifier of result.dependencies) {
@@ -62,15 +65,33 @@ export function build(entries, options = {}) {
         return { outputs: [], errors, warnings };
     // The output keeps the folder structure below the given directories and all the files.
     const root = commonDirectory(queue, directories);
-    const outputs = compiled.map(({ source, code, declarations: types, worker }) => {
+    const outputs = compiled.map((each) => {
+        const { source, declarations: types } = each;
         const target = options.outDir ? join(resolve(options.outDir), relative(root, source)) : source;
         const base = target.replace(/\.rk$/, '');
+        const maps = [];
+        // The code ends with where its map is, and the map says where the source is, from there.
+        const mapped = (code, output, map) => {
+            if (options.sourceMap === false || map === undefined)
+                return code;
+            const sources = [relative(dirname(output), source).split(sep).join('/')];
+            maps.push({
+                output: `${output}.map`,
+                code: JSON.stringify({ ...map, file: basename(output), sources }),
+            });
+            return `${code}${sourceMapComment(`${basename(output)}.map`)}`;
+        };
+        const code = mapped(each.code, `${base}.js`, each.map);
+        const worker = each.worker === undefined
+            ? undefined
+            : mapped(each.worker, `${base}.worker.js`, each.workerMap);
         return {
             source,
             output: `${base}.js`,
             code,
             ...(types === undefined ? {} : { declarations: { output: `${base}.d.ts`, code: types } }),
             ...(worker === undefined ? {} : { worker: { output: `${base}.worker.js`, code: worker } }),
+            ...(maps.length > 0 ? { maps } : {}),
         };
     });
     return { outputs, errors, warnings };

package/dist/checker/array-literals.d.ts

@@ -0,0 +1,6 @@
+import type * as ast from '../ast.ts';
+import { ExpressionChecker } from './expressions.ts';
+import { type Type } from './types.ts';
+export declare abstract class ArrayLiteralChecker extends ExpressionChecker {
+    protected checkArrayLiteral(node: ast.ArrayLiteral, expected: Type | null): Type;
+}

package/dist/checker/array-literals.js

@@ -0,0 +1,59 @@
+import { ExpressionChecker } from "./expressions.js";
+import { ANY, arrayOf, commonType, NEVER, nonNull, typeToString, UNKNOWN, } from "./types.js";
+// Array literals: the type of their elements is the expected one, or the common type of all of
+// them, `[1, null]` is a `[]?number`. A literal without spreads also keeps the types of its
+// elements by position, so that a call infers `K` and `V` of a tuple `[K, V]` of a `.d.ts` from
+// `["a", 1]`: `new Map([["a", 1]])` is a `Map<string, number>` (types/params.ts).
+export class ArrayLiteralChecker extends ExpressionChecker {
+    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;
+        const positions = [];
+        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);
+                positions.push(type);
+            }
+            if (expectedElement) {
+                this.expectAssignable(type, expectedElement, item.kind === 'SpreadElement' ? item.argument : item);
+            }
+            else {
+                element = commonElement(element, type);
+            }
+        }
+        return positions.length === node.elements.length && positions.length > 0
+            ? arrayOf(element, positions)
+            : arrayOf(element);
+    }
+}
+/**
+ * The common type of the elements so far and the next one; of arrays with positions, by position,
+ * so that `[["a", 1], ["b", "x"]]` gives a `V` of `number | string`.
+ */
+function commonElement(element, next) {
+    const common = commonType(element, next);
+    if (common.kind !== 'array' ||
+        element.kind !== 'array' ||
+        next.kind !== 'array' ||
+        element.positions?.length !== next.positions?.length ||
+        !element.positions) {
+        return common;
+    }
+    return arrayOf(common.element, element.positions.map((each, i) => commonType(each, next.positions[i])));
+}

package/dist/checker/assignments.d.ts

@@ -2,6 +2,8 @@ import type * as ast from '../ast.ts';
 import { InitializerChecker } from './initializers.ts';
 import { type Type } from './types.ts';
 export declare abstract class AssignmentChecker extends InitializerChecker {
+    /** The name of the `derived` whose block is being checked: it computes, so it changes no state. */
+    protected derivedBlock: string | null;
     /**
      * `a, b = f()` or `return f()`: the call must return exactly `count` values. Returns their
      * types.
@@ -10,6 +12,8 @@ export declare abstract class AssignmentChecker extends InitializerChecker {
     protected checkAssignment(node: ast.AssignmentStatement): void;
     /** The type a value assigned to `target` must have. */
     protected checkTarget(target: ast.Expression): Type;
+    /** `this.id = id` in the constructor of the class that has the readonly field `id`. */
+    private initializes;
     protected checkReturn(node: ast.ReturnStatement): void;
     /**
      * `return null, err` in a function of `(User, error)`: null takes the place of a value only

package/dist/checker/assignments.js

@@ -1,3 +1,4 @@
+import { placeOf } from "./context.js";
 import { guardedByError, unpackedResults } from "./error-results.js";
 import { isUntyped, countValues, callName, isCall } from "./helpers.js";
 import { InitializerChecker } from "./initializers.js";
@@ -5,6 +6,8 @@ import { BOOL, ANY, isAssignable, isNullable, nonNull, nullable, typeToString, U
 // Where values go: assignments to variables, fields and elements, and `return`. Both unpack a call
 // that returns several values.
 export class AssignmentChecker extends InitializerChecker {
+    /** The name of the `derived` whose block is being checked: it computes, so it changes no state. */
+    derivedBlock = null;
     /**
      * `a, b = f()` or `return f()`: the call must return exactly `count` values. Returns their
      * types.
@@ -66,13 +69,13 @@ export class AssignmentChecker extends InitializerChecker {
             const binding = this.narrowableBinding(target);
             const declared = binding?.type;
             if (binding && declared && isNullable(declared) && !isNullable(valueTypes[i] ?? UNKNOWN)) {
-                this.flow.set(binding, nonNull(declared));
+                this.flow.set(placeOf(binding), nonNull(declared));
             }
         });
     }
     /** The type a value assigned to `target` must have. */
     checkTarget(target) {
-        if (this.checkDecoratorWrite(target))
+        if (this.checkDecoratorWrite(target) || this.checkSharedWrite(target))
             return UNKNOWN;
         switch (target.kind) {
             case 'Identifier': {
@@ -92,13 +95,16 @@ export class AssignmentChecker extends InitializerChecker {
                 else if (binding.kind === 'ref') {
                     this.error(`cannot assign to "${target.name}": a ref always points to its element`, target);
                 }
+                else if (binding.kind === 'state' && this.derivedBlock !== null) {
+                    this.error(`derived "${this.derivedBlock}" cannot change the state "${target.name}": change it in an event handler or an effect`, target);
+                }
                 else if (binding.kind === 'loop') {
                     this.error(`cannot assign to loop variable "${target.name}"`, target);
                 }
                 else if (binding.kind === 'prop') {
                     this.error(this.decorator
                         ? `cannot assign to "${target.name}": parameters of a decorator are read-only`
-                        : `cannot assign to "${target.name}": component properties are read-only; to change the parent's state, pass a function`, target);
+                        : `cannot assign to "${target.name}": component properties are read-only; to change it, declare it with bind, e.g. comp ${this.component?.node.name.name ?? 'Tabs'}(bind ${target.name} ...)`, target);
                 }
                 else if (binding.kind !== 'let' &&
                     binding.kind !== 'state' &&
@@ -119,6 +125,12 @@ export class AssignmentChecker extends InitializerChecker {
                     this.error(`cannot assign to method "${target.property.name}"`, target);
                     return UNKNOWN;
                 }
+                if (member.accessor === 'get') {
+                    this.error(`cannot assign to "${target.property.name}": it has a getter and no setter`, target);
+                }
+                else if (member.readonly && !this.initializes(target, member)) {
+                    this.error(`cannot assign to "${target.property.name}": it is readonly, so only the constructor of ${member.owner?.name ?? 'its class'} assigns it`, target);
+                }
                 return member.type;
             }
             case 'IndexExpression': {
@@ -141,6 +153,14 @@ export class AssignmentChecker extends InitializerChecker {
                 return UNKNOWN;
         }
     }
+    /** `this.id = id` in the constructor of the class that has the readonly field `id`. */
+    initializes(target, member) {
+        return (target.object.kind === 'ThisExpression' &&
+            this.fn?.isConstructor === true &&
+            this.cls !== null &&
+            !this.cls.isStatic &&
+            this.cls.info === member.owner);
+    }
     checkReturn(node) {
         const fn = this.fn;
         if (!fn)

package/dist/checker/base.d.ts

@@ -1,6 +1,6 @@
 import type * as ast from '../ast.ts';
 import type { Diagnostic } from '../diagnostics.ts';
-import { type CheckOptions, type BindingKind, type Binding, type ComponentInfo, type DecoratorInfo, type AliasEntry, Scope, type FunctionContext, type ClassContext, type Flow } from './context.ts';
+import { type CheckOptions, type BindingKind, type Binding, type ComponentInfo, type DecoratorInfo, type AliasEntry, Scope, type FunctionContext, type ClassContext, type Flow, type Place } from './context.ts';
 import { type ClassInfo, type FunctionType, type Member, type Type, type TypeParam } from './types.ts';
 export declare abstract class CheckerBase {
     protected abstract checkClassBodies(node: ast.ClassDeclaration, info: ClassInfo): void;
@@ -18,6 +18,13 @@ export declare abstract class CheckerBase {
     protected abstract checkTry(node: ast.TryStatement): void;
     protected abstract forget(target: ast.Expression): void;
     protected abstract narrowableBinding(node: ast.Expression): Binding | undefined;
+    /** A variable or a path of data fields that conditions narrow, with its type at this point. */
+    protected abstract narrowable(node: ast.Expression): {
+        place: Place;
+        type: Type;
+    } | undefined;
+    /** Whether an assignment to `field` of `place` may change the member of a union it is. */
+    protected abstract isTagOf(place: Place, field: string): boolean;
     /** The error for a value that may be null where it must not be. */
     protected abstract nullError(node: ast.Expression): void;
     protected abstract checkFunction(params: readonly ast.Parameter[], type: FunctionType, results: Type[] | null, body: ast.BlockStatement | ast.Expression, options?: {
@@ -44,7 +51,6 @@ export declare abstract class CheckerBase {
     protected abstract orderByNeeds(decorators: readonly DecoratorInfo[]): DecoratorInfo[];
     protected abstract wrappedType(info: ComponentInfo, own: Type, seen: Set<ComponentInfo>): Type;
     protected abstract checkDecoratorMember(node: ast.DecoratorMember): Type;
-    protected abstract checkDecoratorGet(node: ast.DecoratorGet): Type;
     protected abstract checkDecoratorWrite(target: ast.Expression): boolean;
     protected abstract checkComponentUse(node: ast.ElementExpression, tag: ast.Identifier): Type;
     protected abstract checkRefDeclaration(node: ast.VariableDeclaration): void;

package/dist/checker/base.js

@@ -4,13 +4,13 @@ import { Scope, globalScope, } from "./context.js";
 import { DOCUMENT_FRAGMENT, eventType, HTML_ELEMENT, NODE } from "./dom.js";
 import { explainMismatch, isAssignable, LazyMap, memberNames, nonNull, property, typeToString, UNKNOWN, } from "./types.js";
 // The type checker is a chain of layers, one per area, like the code generator: base → imports →
-// declarations → classes → resolution → initializers → assignments → statements → control flow →
-// functions → expressions → operators → markup → forwarding → components → component values →
-// refs → styles → decorator wrappers → decorator exports → decorators → decorator members →
-// members → calls → goroutines → channels → queues → bytes → loops → go for → iterators →
-// completion → Checker (checker.ts). Statements, expressions and markup check each other
-// recursively, so methods of later layers that earlier ones call are declared here as abstract.
-// This layer has the state of a check, diagnostics, scopes and names, and the DOM types.
+// shared state → declarations → class members → classes → resolution → initializers → assignments → statements → control flow →
+// tagged unions → functions → expressions → array literals → operators → markup → forwarding → component bindings → components → component values →
+// refs → styles → decorator wrappers → decorator exports → decorators → decorator includes → decorator members →
+// members → calls → goroutines → channels → signals → queues → topics → decode → try → bytes → loops → go for →
+// iterators → closing → completion → Checker (checker.ts). Statements, expressions and markup
+// check each other recursively, so methods of later layers that earlier ones call are declared
+// here as abstract. This layer has the state of a check, diagnostics, scopes and names, and the DOM types.
 export class CheckerBase {
     program;
     options;

package/dist/checker/builtins.js

@@ -3,10 +3,11 @@ import { BIGINT_OBJECT } from "./bigint.js";
 import { DOM_TYPES, EVENT } from "./dom.js";
 import { SVG_TYPES } from "./dom-svg.js";
 import { chanOf } from "./channel.js";
+import { CHANNEL_OBJECT, TOPIC_OBJECT } from "./channel-objects.js";
 import { PROMISE } from "./promise.js";
 import { BUFFERS } from "./transfer.js";
-import { UNTYPED_GLOBALS } from "./untyped-globals.js";
-import { ANY, arrayOf, BIGINT, BOOL, ERROR, ERROR_CLASS, func, method, NUMBER, nullable, property, STRING, } from "./types.js";
+import { UNTYPED_CLASSES, UNTYPED_GLOBALS } from "./untyped-globals.js";
+import { ANY, arrayOf, BIGINT, BOOL, ERROR, ERROR_CLASS, func, method, NUMBER, nullable, property, STRING, topicOf, union, } from "./types.js";
 // Types of the JS standard library that Rook programs use most. Anything not listed here
 // can still be reached through the untyped globals below.
 function object(name, members, call) {
@@ -226,20 +227,32 @@ export const GLOBAL_VALUES = new Map([
     ['NaN', NUMBER],
     ['Infinity', NUMBER],
     ['Error', ERROR_CLASS.value],
-    // `error("message")` creates an Error, so the result is never null.
-    ['error', func([STRING], [ERROR_CLASS.instance])],
-    // `close(ch)`: the channel takes no more values (a `<-chan T` cannot be closed: channels.ts).
-    ['close', func([chanOf(ANY)], [])],
+    // `error("message")` creates an Error, so the result is never null; `error("load user", err)`
+    // wraps an error that is not null.
+    ['error', func([STRING, ERROR_CLASS.instance], [ERROR_CLASS.instance], { required: 1 })],
+    // `close(ch)`: the channel takes no more values (a `<-chan T` cannot be closed: channels.ts);
+    // `close(t)`: the topic stops listening and sending.
+    ['close', func([union([chanOf(ANY), topicOf(ANY)])], [])],
     // `transfer(buffer)`: the buffer moves to the thread it goes to (what it takes: channels.ts).
     ['transfer', func([MOVED], [MOVED], { typeParams: [MOVED] })],
     // Channels of time, as in Go: the time once after `ms`, or every `ms` until `close(ticks)`.
     ['after', func([NUMBER], [chanOf(NUMBER, 'receive')])],
     ['tick', func([NUMBER], [chanOf(NUMBER)])],
+    // Signals of the process, until `close(stop)`; an AbortSignal as a channel, and a channel as one
+    // (what they take and give: signals.ts).
+    ['signal', func([], [chanOf(STRING)], { rest: STRING })],
+    ['done', func([ANY], [chanOf(ANY, 'receive')])],
+    ['abortSignal', func([chanOf(ANY, 'receive')], [ANY])],
     // `stream(ch)`: a ReadableStream of the values of a channel (its type: channels.ts).
     ['stream', func([chanOf(ANY, 'receive')], [ANY])],
     // `cancel(task)` stops a goroutine: it takes the Promise of `go` (channels.ts).
     ['cancel', func([ANY], [])],
-    ...[...UNTYPED_GLOBALS, ...BUFFERS].map((name) => [name, ANY]),
+    ['Channel', CHANNEL_OBJECT],
+    ['Topic', TOPIC_OBJECT],
+    ...[...UNTYPED_GLOBALS, ...UNTYPED_CLASSES, ...BUFFERS].map((name) => [
+        name,
+        ANY,
+    ]),
 ]);
 /** Built-in types that a library from TypeScript's lib files replaces: untyped ones and the DOM. */
 export const LIBRARY_TYPES = new Set([
@@ -250,6 +263,7 @@ export const LIBRARY_TYPES = new Set([
     'Promise',
     'URL',
     'Event',
+    ...UNTYPED_CLASSES,
     ...BUFFERS,
     ...[...DOM_TYPES.keys()].filter((name) => name !== 'Content'),
     ...SVG_TYPES.keys(),
@@ -268,7 +282,7 @@ export const GLOBAL_TYPES = new Map([
     ['any', ANY],
     ['error', ERROR],
     ['Error', ERROR_CLASS.instance],
-    ...['Date', 'RegExp', 'Map', 'Set', 'URL', ...BUFFERS].map((name) => [name, ANY]),
+    ...['Date', 'RegExp', 'Map', 'Set', 'URL', ...UNTYPED_CLASSES, ...BUFFERS].map((name) => [name, ANY]),
     ['Promise', PROMISE],
     ...DOM_TYPES,
     ...SVG_TYPES,

package/dist/checker/bytes.d.ts

@@ -1,7 +1,7 @@
 import type * as ast from '../ast.ts';
-import { QueueChecker } from './queues.ts';
+import { TryChecker } from './try.ts';
 import { type Type } from './types.ts';
-export declare abstract class BytesChecker extends QueueChecker {
+export declare abstract class BytesChecker extends TryChecker {
     protected checkArrayLiteral(node: ast.ArrayLiteral, expected: Type | null): Type;
     private isElements;
     /** `make([]float64, n)`: a typed array of `n` zeros. */

package/dist/checker/bytes.js

@@ -1,11 +1,11 @@
-import { QueueChecker } from "./queues.js";
+import { TryChecker } from "./try.js";
 import { isUntyped } from "./helpers.js";
 import { holdsBigInts } from "../typed-arrays.js";
 import { BIGINT, isBytes, nonNull, NUMBER, STRING, typedArrayOf, typeToString, UNKNOWN, } from "./types.js";
 // `[]byte`, a Uint8Array, and the other typed arrays, `[]float64`: an array literal where one is
 // expected, `let data []byte = [1, 2]`; and the conversions of Go between text and its UTF-8
 // bytes, `[]byte("rook")` and `string(data)`.
-export class BytesChecker extends QueueChecker {
+export class BytesChecker extends TryChecker {
     checkArrayLiteral(node, expected) {
         const typed = expected && nonNull(expected);
         const name = typed && typedArrayOf(typed);

package/dist/checker/calls.js

@@ -59,6 +59,9 @@ export class CallChecker extends MemberChecker {
         }
         const { info } = callee;
         this.ensureClassResolved(info);
+        if (info.abstract) {
+            this.error(`cannot create an instance of the abstract class "${info.name}": create one of a class that extends it`, node);
+        }
         const { type, owner } = constructorOf(info);
         if (owner && owner.ctorVisibility !== 'public') {
             const current = this.cls?.info;

package/dist/checker/channel-objects.d.ts

@@ -0,0 +1,3 @@
+import { type ObjectType } from './types.ts';
+export declare const CHANNEL_OBJECT: ObjectType;
+export declare const TOPIC_OBJECT: ObjectType;

package/dist/checker/channel-objects.js

@@ -0,0 +1,40 @@
+import { chanOf } from "./channel.js";
+import { PROMISE } from "./promise.js";
+import { ANY, arrayOf, BOOL, ERROR, func, instantiate, method, nullable, NUMBER, property, STRING, topicOf, VOID, } from "./types.js";
+// `Channel` and `Topic`: what `<-`, `close` and the rest compile to, by name, for code that needs
+// them as functions. `Channel.EMPTY` and `Topic.EMPTY` are the zero values of their types: closed,
+// and a `chan any` and a `topic any`, so that they go where a channel or topic of any values is
+// expected (src/runtime/channel.js, src/runtime/topic.js).
+const T = { kind: 'param', name: 'T' };
+function generic(params, results) {
+    return method(func(params, results, { typeParams: [T] }));
+}
+function object(name, members) {
+    return { kind: 'object', name, members: new Map(Object.entries(members)), call: null };
+}
+export const CHANNEL_OBJECT = object('Channel', {
+    EMPTY: property(chanOf(ANY)),
+    make: generic([NUMBER, T], [chanOf(T)]),
+    send: generic([chanOf(T, 'send'), T], [instantiate(PROMISE, [VOID])]),
+    // The zero value of its type after close; null from Channel.EMPTY.
+    receive: generic([chanOf(T, 'receive')], [instantiate(PROMISE, [nullable(T)])]),
+    close: method(func([chanOf(ANY)], [])),
+    // An async iterator of the values, for `for await` of JS.
+    range: generic([chanOf(T, 'receive')], [ANY]),
+    select: method(func([arrayOf(ANY), BOOL], [instantiate(PROMISE, [arrayOf(ANY)])])),
+    try: method(func([chanOf(ANY), BOOL, ANY], [nullable(arrayOf(ANY))], { required: 2 })),
+    fromStream: method(func([ANY, NUMBER, ANY], [chanOf(ANY), chanOf(ERROR, 'receive')])),
+    stream: generic([chanOf(T, 'receive')], [ANY]),
+    after: method(func([NUMBER], [chanOf(NUMBER, 'receive')])),
+    tick: method(func([NUMBER], [chanOf(NUMBER)])),
+    signal: method(func([], [chanOf(STRING)], { rest: STRING })),
+    done: method(func([ANY], [chanOf(ANY, 'receive')])),
+    abortSignal: method(func([chanOf(ANY, 'receive')], [ANY])),
+});
+export const TOPIC_OBJECT = object('Topic', {
+    EMPTY: property(topicOf(ANY)),
+    make: generic([STRING, T], [topicOf(T)]),
+    publish: generic([topicOf(T), T], []),
+    listen: generic([topicOf(T)], [chanOf(T, 'receive')]),
+    close: method(func([topicOf(ANY)], [])),
+});

package/dist/checker/channels.d.ts

@@ -1,6 +1,7 @@
 import type * as ast from '../ast.ts';
 import { GoroutineChecker } from './goroutines.ts';
 import { type Type } from './types.ts';
+export declare function typeName(type: Type): string | null;
 export declare abstract class ChannelChecker extends GoroutineChecker {
     protected checkChan(node: ast.ChanExpression): Type;
     protected checkStreamChan(node: ast.StreamChanExpression): Type;

package/dist/checker/channels.js

@@ -1,17 +1,17 @@
-import { assignedNames } from "../names.js";
+import { cannotWait } from "../parser/syntax.js";
 import { chanDirection, chanOf, elementOf, isChan } from "./channel.js";
 import { GoroutineChecker } from "./goroutines.js";
 import { isUntyped } from "./helpers.js";
 import { isPromise } from "./promise.js";
 import { BUFFERS } from "./transfer.js";
-import { ANY, BOOL, ERROR, instantiate, isNullable, nonNull, NUMBER, typeToString, typedArrayOf, UNKNOWN, } from "./types.js";
+import { ANY, BOOL, ERROR, instantiate, isNullable, isTopic, nonNull, NUMBER, topicElement, typeToString, typedArrayOf, UNKNOWN, } from "./types.js";
 // Channels: `chan<number>(10)` makes one, `ch <- v` sends a value, `<-ch` receives one (in
 // operators.ts), `for v in ch` receives them until it is closed (in control-flow.ts), and
 // `select` waits for the first of several. `transfer(x)` moves a buffer to another thread.
 // `chan(stream)` receives the chunks of a ReadableStream, and `stream(ch)` reads a channel.
 /** What `transfer(x)` moves: a buffer, or a view whose buffer moves. */
 const MOVABLE = new Set(BUFFERS);
-function typeName(type) {
+export function typeName(type) {
     if (type.kind === 'class')
         return type.info.name;
     if (type.kind === 'object')
@@ -50,11 +50,20 @@ export class ChannelChecker extends GoroutineChecker {
             this.expectAssignable(this.checkValue(node.size, NUMBER), NUMBER, node.size);
         return { kind: 'tuple', types: [chanOf(element), chanOf(ERROR, 'receive')] };
     }
+    // A send to a channel waits until the channel takes the value, and one to a topic waits for
+    // nobody, so only the first needs an async function.
     checkSend(node) {
         const nullChannel = this.inSelectCase;
         this.inSelectCase = false;
         const type = this.checkValue(node.channel);
         const channel = nullChannel && isNullable(type) ? nonNull(type) : type;
+        if (isTopic(channel)) {
+            const element = topicElement(channel);
+            this.expectAssignable(this.checkValue(node.value, element), element, node.value);
+            return;
+        }
+        if (node.cannotWait)
+            this.error(cannotWait('<-', node.cannotWait.inDefer), node.cannotWait);
         if (!isChan(channel)) {
             if (!isUntyped(channel)) {
                 this.error(`"<-" sends to a channel, not to ${typeToString(channel)}`, node.channel);
@@ -105,7 +114,7 @@ export class ChannelChecker extends GoroutineChecker {
             : ANY;
     }
     checkSelect(node) {
-        this.dropNarrowing(assignedNames(node));
+        this.dropNarrowing(node);
         const entry = this.flow;
         for (const { names, operation, body } of node.cases) {
             this.flow = new Map(entry);
@@ -114,6 +123,10 @@ export class ChannelChecker extends GoroutineChecker {
                 this.inSelectCase = operation !== null;
                 if (operation?.kind === 'SendStatement') {
                     this.checkSend(operation);
+                    const channel = this.checkedTypes.get(operation.channel);
+                    if (channel && isTopic(isNullable(channel) ? nonNull(channel) : channel)) {
+                        this.error('a send to a topic waits for nobody, so it is not a case of "select": send it before the select, e.g. "cart <- event"', operation.channel);
+                    }
                 }
                 else if (operation) {
                     // `case v, ok = <-ch:` declares the variables of the case.

package/dist/checker/checker.d.ts

@@ -1,4 +1,4 @@
 import type * as ast from '../ast.ts';
 import type { CheckOptions, CheckResult } from './context.ts';
-export type { CheckOptions, CheckResult, Completion, CompletionContext, CompletionResult, ImportResult, Library, ModuleExports, } from './context.ts';
+export type { CheckOptions, CheckResult, Completion, CompletionContext, CompletionResult, ImportResult, Library, ModuleExports, TextEdit, } from './context.ts';
 export declare function check(program: ast.Program, options?: CheckOptions): CheckResult;

package/dist/checker/checker.js

@@ -6,6 +6,7 @@ class Checker extends CompletionChecker {
         this.checkEndlessRecursion();
         this.checkIterators();
         this.checkHtmlTags();
+        this.checkClosing();
         this.diagnostics.sort((a, b) => a.start - b.start);
         this.warnings.sort((a, b) => a.start - b.start);
         return {
@@ -13,9 +14,27 @@ class Checker extends CompletionChecker {
             warnings: this.warnings,
             ...this.collectDeclarations(),
             types: this.checkedTypes,
+            dataClasses: this.dataClasses(),
             ...(this.completion ? { completion: this.completion } : {}),
         };
     }
+    /** The names of the module that are data classes: its own, and those it imports. */
+    dataClasses() {
+        const names = new Set();
+        for (const statement of this.program.body) {
+            const declared = statement.kind === 'ClassDeclaration'
+                ? [statement.name.name]
+                : statement.kind === 'ImportDeclaration'
+                    ? statement.namedImports.map((specifier) => specifier.local.name)
+                    : [];
+            for (const name of declared) {
+                const type = this.lookupValue(name)?.type;
+                if (type?.kind === 'classValue' && type.info.data === true)
+                    names.add(name);
+            }
+        }
+        return names;
+    }
 }
 export function check(program, options = {}) {
     return new Checker(program, options).run();

package/dist/checker/class-members.d.ts

@@ -0,0 +1,22 @@
+import type * as ast from '../ast.ts';
+import { DeclarationChecker } from './declarations.ts';
+import { type ClassInfo, type FunctionType, type Member } from './types.ts';
+export declare abstract class ClassMemberChecker extends DeclarationChecker {
+    /** The signatures of getters and setters: their members have the type of the value. */
+    protected readonly accessorSignatures: Map<ast.MethodDeclaration, FunctionType>;
+    protected declareMember(info: ClassInfo, isStatic: boolean, name: ast.Identifier, member: Member): void;
+    /** `get area() number` and `set area(v number)` make one member, of the type of the value. */
+    protected declareAccessor(info: ClassInfo, node: ast.MethodDeclaration, accessor: 'get' | 'set'): void;
+    /** `constructor(private name string)`: the parameters that are properties of the class too. */
+    protected declareParamProperties(node: ast.ConstructorDeclaration, info: ClassInfo, ctor: FunctionType): void;
+    /**
+     * Only an abstract class has abstract methods, and a class that is not abstract implements
+     * those of its bases.
+     */
+    protected checkAbstract(node: ast.ClassDeclaration, info: ClassInfo): void;
+    /**
+     * In JS a field is set on each instance and so hides a getter or setter of the prototype: a
+     * field and an accessor of the same name in a class and its base would not work together.
+     */
+    protected checkAccessorOverride(info: ClassInfo, name: ast.Identifier, isStatic: boolean): void;
+}