rooklang 0.3.2 → 0.3.4

package/dist/checker/assignments.d.ts

@@ -10,5 +10,12 @@ 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
+     * together with an error that is not null. Returns whether the null is checked here.
+     */
+    private nullWithError;
 }

package/dist/checker/assignments.js

@@ -1,6 +1,7 @@
+import { guardedByError, unpackedResults } from "./error-results.js";
 import { isUntyped, countValues, callName, isCall } from "./helpers.js";
 import { InitializerChecker } from "./initializers.js";
-import { BOOL, ANY, isAssignable, isNullable, nonNull, typeToString, UNKNOWN, } from "./types.js";
+import { BOOL, ANY, isAssignable, isNullable, nonNull, nullable, typeToString, UNKNOWN, } from "./types.js";
 // Where values go: assignments to variables, fields and elements, and `return`. Both unpack a call
 // that returns several values.
 export class AssignmentChecker extends InitializerChecker {
@@ -26,12 +27,15 @@ export class AssignmentChecker extends InitializerChecker {
             this.error(`${prefix} ${callName(value)} returns ${countValues(returned)}`, value);
             return Array(count).fill(UNKNOWN);
         }
+        // `return f()` passes the results on as they are; variables get the values before an error
+        // as nullable (error-results.ts).
+        const types = context === 'return' ? type.types : unpackedResults(type.types);
         if (declared) {
-            for (const element of type.types)
+            for (const element of types)
                 this.expectAssignable(element, declared, value);
-            return type.types.map(() => declared);
+            return types.map(() => declared);
         }
-        return type.types;
+        return types;
     }
     checkAssignment(node) {
         const { targets, values, operator } = node;
@@ -115,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': {
@@ -137,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)
@@ -187,11 +205,33 @@ export class AssignmentChecker extends InitializerChecker {
         if (values.length !== expected.length) {
             this.error(`wrong number of return values: expected ${expected.length}, got ${values.length}`, node);
         }
-        values.forEach((value, i) => {
+        const types = values.map((value, i) => this.checkValue(value, expected[i] ?? null));
+        types.forEach((type, i) => {
             const target = expected[i];
-            const type = this.checkValue(value, target ?? null);
-            if (target)
-                this.expectAssignable(type, target, value, ' in return');
+            if (!target)
+                return;
+            if (type.kind === 'null' && this.nullWithError(expected, types, values, i))
+                return;
+            this.expectAssignable(type, target, values[i], ' in return');
         });
     }
+    /**
+     * `return null, err` in a function of `(User, error)`: null takes the place of a value only
+     * together with an error that is not null. Returns whether the null is checked here.
+     */
+    nullWithError(expected, types, values, i) {
+        const last = expected.length - 1;
+        if (!guardedByError(expected).includes(i) || types.length !== expected.length)
+            return false;
+        const error = types[last];
+        const target = typeToString(expected[i]);
+        if (error.kind === 'null') {
+            this.error(`cannot return null with no error: make the result ${typeToString(nullable(expected[i]))} if the value may be null without an error`, values[i]);
+        }
+        else if (isNullable(error)) {
+            const name = values[last].kind === 'Identifier' ? values[last].name : 'err';
+            this.error(`null in place of ${target} needs an error that is not null: check it first, e.g. if ${name} != null { return null, ${name} }`, values[i]);
+        }
+        return true;
+    }
 }

package/dist/checker/base.d.ts

@@ -18,6 +18,8 @@ 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;
+    /** 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?: {
         isConstructor?: boolean;
         isComponent?: boolean;
@@ -94,7 +96,6 @@ export declare abstract class CheckerBase {
     constructor(program: ast.Program, options: CheckOptions);
     protected error(message: string, node: ast.NodeBase): void;
     protected expectAssignable(source: Type, target: Type, node: ast.NodeBase, context?: string): void;
-    protected nullError(node: ast.Expression): void;
     protected withScope<T>(check: () => T): T;
     protected withClass<T>(context: ClassContext | null, check: () => T): T;
     protected lookupValue(name: string): Binding | undefined;

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;
@@ -66,12 +66,6 @@ export class CheckerBase {
         }
         this.error(message, node);
     }
-    nullError(node) {
-        const name = node.kind === 'Identifier' ? node.name : null;
-        this.error(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);
-    }
     withScope(check) {
         const saved = this.scope;
         this.scope = new Scope(saved);

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;