rooklang 0.3.3 → 0.3.4

package/dist/checker/assignments.js

@@ -119,6 +119,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 +147,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.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 →
+// declarations → class members → classes → resolution → initializers → assignments → statements → control flow →
+// functions → expressions → array literals → 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.
+// 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 { 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,19 +227,28 @@ 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], [])],
+    ['Channel', CHANNEL_OBJECT],
+    ['Topic', TOPIC_OBJECT],
     ...[...UNTYPED_GLOBALS, ...BUFFERS].map((name) => [name, ANY]),
 ]);
 /** Built-in types that a library from TypeScript's lib files replaces: untyped ones and the DOM. */

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,18 @@
 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 +51,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);
@@ -114,6 +124,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;
+}

package/dist/checker/class-members.js

@@ -0,0 +1,105 @@
+import { DeclarationChecker } from "./declarations.js";
+import { notCopied } from "./transfer.js";
+import { findClassMember, isAssignable, typeToString, UNKNOWN, } from "./types.js";
+// The members of classes that are more than a field or a method: getters and setters, the
+// properties of constructor parameters, abstract methods; ClassChecker declares and checks them.
+export class ClassMemberChecker extends DeclarationChecker {
+    /** The signatures of getters and setters: their members have the type of the value. */
+    accessorSignatures = new Map();
+    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);
+    }
+    /** `get area() number` and `set area(v number)` make one member, of the type of the value. */
+    declareAccessor(info, node, accessor) {
+        const signature = this.signature(node.params, node.results);
+        const type = (accessor === 'get' ? signature.results[0] : signature.params[0]) ?? UNKNOWN;
+        const members = node.isStatic ? info.statics : info.members;
+        const other = members.get(node.name.name);
+        this.accessorSignatures.set(node, signature);
+        if (other?.owner === info &&
+            (other.accessor === 'get' || other.accessor === 'set') &&
+            other.accessor !== accessor) {
+            const [getter, setter] = accessor === 'get' ? [type, other.type] : [other.type, type];
+            if (!isAssignable(getter, setter) || !isAssignable(setter, getter)) {
+                this.error(`the getter and the setter of "${node.name.name}" have different types: ` +
+                    `${typeToString(getter)} and ${typeToString(setter)}`, node.name);
+            }
+            members.set(node.name.name, { ...other, type: getter, accessor: 'both' });
+            return;
+        }
+        this.declareMember(info, node.isStatic, node.name, {
+            type,
+            method: false,
+            visibility: node.visibility,
+            owner: info,
+            accessor,
+            ...(node.abstract ? { abstract: true } : {}),
+        });
+    }
+    /** `constructor(private name string)`: the parameters that are properties of the class too. */
+    declareParamProperties(node, info, ctor) {
+        node.params.forEach((param, i) => {
+            if (!param.property)
+                return;
+            const type = ctor.params[i] ?? UNKNOWN;
+            const reason = info.data === true ? notCopied(type) : null;
+            if (reason !== null) {
+                this.error(`the fields of a data class go to other threads as copies: ${reason}`, param.type ?? param.name);
+            }
+            this.declareMember(info, false, param.name, {
+                type,
+                method: false,
+                visibility: param.property.visibility,
+                owner: info,
+                ...(param.property.readonly ? { readonly: true } : {}),
+            });
+        });
+    }
+    /**
+     * Only an abstract class has abstract methods, and a class that is not abstract implements
+     * those of its bases.
+     */
+    checkAbstract(node, info) {
+        if (node.abstract)
+            return;
+        for (const member of node.members) {
+            if (member.kind !== 'MethodDeclaration' || !member.abstract)
+                continue;
+            this.error(`"${member.name.name}" is abstract, so its class must be too: abstract class ${info.name}`, member.name);
+        }
+        const missing = new Set();
+        for (let base = info.superClass; base; base = base.superClass) {
+            for (const [name, member] of base.members) {
+                const found = member.abstract ? findClassMember(info, name, false) : undefined;
+                if (found?.abstract)
+                    missing.add(`${found.owner?.name ?? base.name}.${name}`);
+            }
+        }
+        if (missing.size === 0)
+            return;
+        this.error(`class "${info.name}" does not implement ${[...missing].join(', ')}: implement ` +
+            `${missing.size === 1 ? 'it' : 'them'} or make the class abstract, e.g. abstract class ${info.name}`, node.name);
+    }
+    /**
+     * 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.
+     */
+    checkAccessorOverride(info, name, isStatic) {
+        const own = (isStatic ? info.statics : info.members).get(name.name);
+        const base = info.superClass && findClassMember(info.superClass, name.name, isStatic);
+        // Only the classes of Rook have `data` set: lib.dom declares many accessors as fields.
+        if (!own || !base || own.method || base.method || base.owner?.data === undefined)
+            return;
+        if (own.accessor && !base.accessor) {
+            this.error(`"${name.name}" is a field in ${base.owner.name}, which would hide a getter or setter ` +
+                'here: the field is set on each instance; override it with a field', name);
+        }
+        else if (!own.accessor && base.accessor) {
+            this.error(`"${name.name}" is a getter or setter in ${base.owner.name}, which a field here would ` +
+                'hide: override it with a getter or setter', name);
+        }
+    }
+}

package/dist/checker/classes.d.ts

@@ -1,14 +1,15 @@
 import type * as ast from '../ast.ts';
 import { type ModulePackages } from '../inline-packages.ts';
 import type { ModuleExports } from './context.ts';
-import { DeclarationChecker } from './declarations.ts';
-import { type ClassInfo, type Member } from './types.ts';
-export declare abstract class ClassChecker extends DeclarationChecker {
+import { ClassMemberChecker } from './class-members.ts';
+import { type ClassInfo } from './types.ts';
+export declare abstract class ClassChecker extends ClassMemberChecker {
     protected ensureClassResolved(info: ClassInfo): void;
     /** Resolves the base class and the types of all members (but does not check method bodies). */
     protected resolveClass(node: ast.ClassDeclaration, info: ClassInfo): void;
     protected resolveClassMembers(node: ast.ClassDeclaration, info: ClassInfo): void;
-    protected declareMember(info: ClassInfo, isStatic: boolean, name: ast.Identifier, member: Member): void;
+    /** A data class extends only a data class: its fields go with it, and its class is restored. */
+    private checkDataBase;
     /** Method bodies and the checks that need every member of the class. */
     protected checkClassBodies(node: ast.ClassDeclaration, info: ClassInfo): void;
     protected checkClassMembers(node: ast.ClassDeclaration, info: ClassInfo): void;

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