rooklang 0.0.0-stage → 0.3.0

package/dist/checker/calls.js

@@ -0,0 +1,210 @@
+import { isUntyped, signaturesOf, callSignature } from "./helpers.js";
+import { MemberChecker } from "./members.js";
+import { ANY, classInstance, constructorOf, containsTypeParam, func, hasUntypedBase, inferTypeParams, isAssignable, isSubclass, substitute, typeToString, UNKNOWN, VOID, } from "./types.js";
+// Calls and `new`: overloads, arguments, and the inference of type arguments.
+export class CallChecker extends MemberChecker {
+    checkCall(node, callee, expected = null) {
+        if (isUntyped(callee)) {
+            this.checkArgumentsLoosely(node.arguments);
+            return callee;
+        }
+        if (callee.kind === 'classValue') {
+            this.error(`use "new ${callee.info.name}(...)" to create a ${callee.info.name}`, node);
+            this.checkArgumentsLoosely(node.arguments);
+            return callee.info.instance;
+        }
+        const signature = callSignature(callee);
+        if (!signature) {
+            this.error(`${typeToString(callee)} cannot be called`, node.callee);
+            this.checkArgumentsLoosely(node.arguments);
+            return UNKNOWN;
+        }
+        const { results } = this.checkOverloads(signaturesOf(signature), node.arguments, node, expected);
+        if (results.length === 0)
+            return VOID;
+        if (results.length === 1)
+            return results[0];
+        return { kind: 'tuple', types: results };
+    }
+    checkSuperCall(node) {
+        const info = this.cls?.info;
+        if (!info || !this.fn?.isConstructor) {
+            this.error('"super(...)" can only be called in a constructor', node);
+            this.checkArgumentsLoosely(node.arguments);
+            return VOID;
+        }
+        if (!info.superClass) {
+            if (!hasUntypedBase(info))
+                this.error(`class "${info.name}" has no base class`, node);
+            this.checkArgumentsLoosely(node.arguments);
+            return VOID;
+        }
+        this.checkArguments(constructorOf(info.superClass).type, node.arguments, node);
+        return VOID;
+    }
+    checkNew(node, expected = null) {
+        const callee = this.checkValue(node.callee);
+        if (isUntyped(callee)) {
+            this.checkArgumentsLoosely(node.arguments);
+            return callee;
+        }
+        if (callee.kind === 'object' && callee.construct) {
+            const signatures = signaturesOf(callee.construct);
+            return this.checkOverloads(signatures, node.arguments, node, expected).results[0] ?? UNKNOWN;
+        }
+        if (callee.kind !== 'classValue') {
+            this.error(`${typeToString(callee)} is not a class`, node.callee);
+            this.checkArgumentsLoosely(node.arguments);
+            return UNKNOWN;
+        }
+        const { info } = callee;
+        this.ensureClassResolved(info);
+        const { type, owner } = constructorOf(info);
+        if (owner && owner.ctorVisibility !== 'public') {
+            const current = this.cls?.info;
+            const allowed = owner.ctorVisibility === 'private'
+                ? current === owner
+                : current !== undefined && isSubclass(current, owner);
+            if (!allowed) {
+                this.error(`the constructor of ${owner.name} is ${owner.ctorVisibility}`, node);
+            }
+        }
+        if (info.typeParams.length === 0) {
+            this.checkOverloads(signaturesOf(type), node.arguments, node, null);
+            return info.instance;
+        }
+        // `new Stack<number>()` is not valid syntax: the arguments come from the constructor
+        // arguments, or from the expected type, as in `let s Stack<number> = new Stack()`.
+        const instance = { kind: 'class', info, args: info.typeParams };
+        const signatures = signaturesOf(type).map((signature) => func(signature.params, [instance], {
+            required: signature.required,
+            ...(signature.rest ? { rest: signature.rest } : {}),
+            typeParams: [...new Set([...info.typeParams, ...signature.typeParams])],
+        }));
+        const { inferred } = this.checkOverloads(signatures, node.arguments, node, expected);
+        return classInstance(info, info.typeParams.map((param) => inferred.get(param) ?? UNKNOWN));
+    }
+    /**
+     * Checks a call of an overloaded function (from a `.d.ts`): the first signature that fits the
+     * arguments is used. Signatures that take this many arguments are tried first.
+     */
+    checkOverloads(signatures, args, node, expected) {
+        if (signatures.length === 1) {
+            const inferred = new Map();
+            const results = this.checkArguments(signatures[0], args, node, inferred, expected);
+            return { results, inferred };
+        }
+        const takes = (signature) => args.some((arg) => arg.kind === 'SpreadElement') ||
+            (args.length >= signature.required &&
+                (args.length <= signature.params.length || signature.rest !== null));
+        const ordered = [...signatures.filter(takes), ...signatures.filter((each) => !takes(each))];
+        const errors = this.diagnostics.length;
+        for (const signature of ordered) {
+            const inferred = new Map();
+            const results = this.checkArguments(signature, args, node, inferred, expected);
+            if (this.diagnostics.length === errors)
+                return { results, inferred };
+            this.diagnostics.length = errors;
+        }
+        // The same signature may be declared twice, as `fetch` by lib.dom and @types/node.
+        const listed = [...new Set(signatures.map(typeToString))];
+        this.error(`no overload fits these arguments: ${listed.join('; ')}`, node);
+        this.checkArgumentsLoosely(args);
+        const results = signatures[0].results.map((result) => substitute(result, new Map(), UNKNOWN));
+        return { results, inferred: new Map() };
+    }
+    checkArgumentsLoosely(args) {
+        for (const arg of args)
+            this.checkValue(arg.kind === 'SpreadElement' ? arg.argument : arg, ANY);
+    }
+    /**
+     * Checks call arguments against a signature and returns the result types. Type parameters are
+     * inferred into `inferred` from the arguments and then from the expected result.
+     */
+    checkArguments(signature, args, node, inferred = new Map(), expected = null) {
+        const hasSpread = args.some((arg) => arg.kind === 'SpreadElement');
+        if (!hasSpread) {
+            if (args.length < signature.required) {
+                this.error(`not enough arguments: expected ${signature.required}, got ${args.length}`, node);
+            }
+            else if (args.length > signature.params.length && signature.rest === null) {
+                this.error(`too many arguments: expected ${signature.params.length}, got ${args.length}`, args[signature.params.length]);
+            }
+        }
+        // Arrow functions without parameter types are checked last: their parameter types may depend
+        // on type parameters inferred from the other arguments (e.g. `reduce(f, initial)`).
+        const needsContext = (arg) => arg.kind === 'ArrowFunction' && arg.params.some((param) => param.type === null);
+        const inferring = this.inferring;
+        this.inferring = new Set(signature.typeParams);
+        const errors = this.diagnostics.length;
+        // What the other arguments leave open comes from the expected result, before those arrow
+        // functions: `const done Promise<number> = new Promise(resolve => ...)`.
+        const fromExpected = () => {
+            if (expected && signature.results.length === 1) {
+                inferTypeParams(signature.results[0], expected, inferred);
+            }
+        };
+        try {
+            this.checkArgumentList(signature, args, inferred, needsContext, fromExpected);
+        }
+        finally {
+            this.inferring = inferring;
+        }
+        fromExpected();
+        for (const param of signature.typeParams) {
+            if (!inferred.has(param) && param.default)
+                inferred.set(param, param.default);
+        }
+        // `let xs = empty()`: nothing says what T is. Not reported after errors in the arguments.
+        const unknown = signature.typeParams.filter((param) => !inferred.has(param) &&
+            signature.results.some((result) => containsTypeParam(result, new Set([param]))));
+        if (unknown.length > 0 && this.diagnostics.length === errors) {
+            this.error(`cannot infer ${unknown.map((param) => param.name).join(', ')}: declare the type of the result`, node);
+        }
+        for (const param of signature.typeParams) {
+            const type = inferred.get(param);
+            if (type && param.constraint && !isAssignable(type, param.constraint)) {
+                this.error(`${typeToString(type)} does not satisfy the constraint ${typeToString(param.constraint)} of ${param.name}`, node);
+            }
+        }
+        return signature.results.map((result) => substitute(result, inferred, UNKNOWN));
+    }
+    checkArgumentList(signature, args, inferred, needsContext, beforeContext) {
+        for (const contextPass of [false, true]) {
+            if (contextPass)
+                beforeContext?.();
+            args.forEach((arg, i) => {
+                if (needsContext(arg) !== contextPass)
+                    return;
+                if (arg.kind === 'SpreadElement') {
+                    const type = this.checkValue(arg.argument);
+                    if (isUntyped(type))
+                        return;
+                    if (type.kind !== 'array') {
+                        this.error(`cannot spread ${typeToString(type)}: it is not an array`, arg.argument);
+                    }
+                    else if (signature.rest === null) {
+                        this.error('a spread argument needs a "...rest" parameter', arg);
+                    }
+                    else {
+                        this.expectAssignable(type.element, signature.rest, arg.argument);
+                    }
+                    return;
+                }
+                const param = signature.params[i] ?? signature.rest;
+                if (!param) {
+                    this.checkValue(arg);
+                    return;
+                }
+                // An expected type with parameters that are not inferred yet would reject the argument:
+                // `[1, 2]` for `[]T` is checked on its own, and T is inferred from it.
+                const expected = substitute(param, inferred);
+                const type = this.checkValue(arg, arg.kind === 'ArrowFunction' || !containsTypeParam(expected, this.inferring)
+                    ? expected
+                    : null);
+                inferTypeParams(param, type, inferred);
+                this.expectAssignable(type, substitute(param, inferred), arg, ` in argument ${i + 1}`);
+            });
+        }
+    }
+}

package/dist/checker/channel.d.ts

@@ -0,0 +1,14 @@
+import { type ObjectType, type Type } from './types.ts';
+export type ChanDirection = 'both' | 'send' | 'receive';
+export declare const CHAN: ObjectType;
+export declare function chanOf(element: Type, direction?: ChanDirection): ObjectType;
+export declare function isChan(type: Type): type is ObjectType;
+/** Which way a channel type goes, or null for a type that is not a channel. */
+export declare function chanDirection(type: ObjectType): ChanDirection | null;
+/** The type of the values of a channel type. */
+export declare function elementOf(chan: ObjectType): Type;
+/**
+ * What `<-ch` gives: the value, or after `close` the zero value of its type, as in Go. A type
+ * without a zero value (an interface, a class) gives null then.
+ */
+export declare function received(element: Type): Type;

package/dist/checker/channel.js

@@ -0,0 +1,44 @@
+import { hasZeroValue, instantiate, nullable } from "./types.js";
+function template(name) {
+    return {
+        kind: 'object',
+        name,
+        members: new Map(),
+        call: null,
+        typeParams: [{ kind: 'param', name: 'T' }],
+    };
+}
+export const CHAN = template('chan');
+const TEMPLATES = {
+    both: CHAN,
+    send: template('chan<-'),
+    receive: template('<-chan'),
+};
+export function chanOf(element, direction = 'both') {
+    return instantiate(TEMPLATES[direction], [element]);
+}
+export function isChan(type) {
+    return type.kind === 'object' && chanDirection(type) !== null;
+}
+/** Which way a channel type goes, or null for a type that is not a channel. */
+export function chanDirection(type) {
+    const template = type.instanceOf?.template;
+    if (template === TEMPLATES.both)
+        return 'both';
+    if (template === TEMPLATES.send)
+        return 'send';
+    if (template === TEMPLATES.receive)
+        return 'receive';
+    return null;
+}
+/** The type of the values of a channel type. */
+export function elementOf(chan) {
+    return chan.instanceOf.args[0];
+}
+/**
+ * What `<-ch` gives: the value, or after `close` the zero value of its type, as in Go. A type
+ * without a zero value (an interface, a class) gives null then.
+ */
+export function received(element) {
+    return hasZeroValue(element) ? element : nullable(element);
+}

package/dist/checker/channels.d.ts

@@ -0,0 +1,9 @@
+import type * as ast from '../ast.ts';
+import { GoroutineChecker } from './goroutines.ts';
+import { type Type } from './types.ts';
+export declare abstract class ChannelChecker extends GoroutineChecker {
+    protected checkChan(node: ast.ChanExpression): Type;
+    protected checkSend(node: ast.SendStatement): void;
+    protected checkCall(node: ast.CallExpression, callee: Type, expected?: Type | null): Type;
+    protected checkSelect(node: ast.SelectStatement): void;
+}

package/dist/checker/channels.js

@@ -0,0 +1,95 @@
+import { assignedNames } from "../names.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 { BOOL, isNullable, nonNull, NUMBER, typeToString } 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.
+/** What `transfer(x)` moves: a buffer, or a view whose buffer moves. */
+const MOVABLE = new Set(BUFFERS);
+function typeName(type) {
+    if (type.kind === 'class')
+        return type.info.name;
+    if (type.kind === 'object')
+        return type.instanceOf?.template.name ?? type.name;
+    return null;
+}
+export class ChannelChecker extends GoroutineChecker {
+    checkChan(node) {
+        const element = this.resolveType(node.element);
+        if (node.size)
+            this.expectAssignable(this.checkValue(node.size, NUMBER), NUMBER, node.size);
+        return chanOf(element);
+    }
+    checkSend(node) {
+        const nullChannel = this.inSelectCase;
+        this.inSelectCase = false;
+        const type = this.checkValue(node.channel);
+        const channel = nullChannel && isNullable(type) ? nonNull(type) : type;
+        if (!isChan(channel)) {
+            if (!isUntyped(channel)) {
+                this.error(`"<-" sends to a channel, not to ${typeToString(channel)}`, node.channel);
+            }
+            this.checkValue(node.value);
+            return;
+        }
+        const element = elementOf(channel);
+        if (chanDirection(channel) === 'receive') {
+            this.error(`"<-" cannot send to ${typeToString(channel)}: it only receives; send to a "chan T" or a "chan<- T"`, node.channel);
+        }
+        this.expectAssignable(this.checkValue(node.value, element), element, node.value);
+    }
+    // `close(ch)` takes any channel, but a channel is closed by its sender, so not a `<-chan T`;
+    // `cancel(task)` takes the Promise of `go`; `transfer(x)` takes what postMessage can move: a
+    // buffer, or a view of one.
+    checkCall(node, callee, expected = null) {
+        const result = super.checkCall(node, callee, expected);
+        const [argument] = node.arguments;
+        const type = argument && argument.kind !== 'SpreadElement' && this.checkedTypes.get(argument);
+        const builtin = node.callee.kind === 'Identifier' &&
+            this.lookupValue(node.callee.name) === this.globals.values.get(node.callee.name)
+            ? node.callee.name
+            : null;
+        if (!type || !argument)
+            return result;
+        if (builtin === 'close' && isChan(type) && chanDirection(type) === 'receive') {
+            this.error(`cannot close ${typeToString(type)}: it only receives, and a channel is closed by its sender`, argument);
+        }
+        if (builtin === 'cancel' && !isUntyped(type) && !isPromise(type)) {
+            this.error(`cancel() stops a goroutine: give it the Promise of "go", not ${typeToString(type)}, e.g. "const task = go work(x)" and "cancel(task)"`, argument);
+        }
+        if (builtin === 'transfer' && !isUntyped(type) && !MOVABLE.has(typeName(type) ?? '')) {
+            this.error(`transfer() moves an ArrayBuffer or a typed array to another thread, not ${typeToString(type)}; other values are copied`, argument);
+        }
+        return result;
+    }
+    checkSelect(node) {
+        this.dropNarrowing(assignedNames(node));
+        const entry = this.flow;
+        for (const { names, operation, body } of node.cases) {
+            this.flow = new Map(entry);
+            this.withScope(() => {
+                // A null channel turns its case off, as a nil channel does in Go.
+                this.inSelectCase = operation !== null;
+                if (operation?.kind === 'SendStatement') {
+                    this.checkSend(operation);
+                }
+                else if (operation) {
+                    // `case v, ok = <-ch:` declares the variables of the case.
+                    const value = this.checkExpression(operation, null);
+                    const [name, ok] = names;
+                    if (name)
+                        this.declareValue(name, 'const', value);
+                    if (ok)
+                        this.declareValue(ok, 'const', BOOL);
+                }
+                this.inSelectCase = false;
+                this.checkBlock(body);
+            });
+        }
+        this.flow = entry;
+    }
+}

package/dist/checker/checker.d.ts

@@ -0,0 +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 declare function check(program: ast.Program, options?: CheckOptions): CheckResult;

package/dist/checker/checker.js

@@ -0,0 +1,22 @@
+import { CompletionChecker } from "./completion.js";
+// The type checker of a module; its layers are listed in base.ts.
+class Checker extends CompletionChecker {
+    run() {
+        this.checkStatementList(this.program.body, true);
+        this.checkEndlessRecursion();
+        this.checkIterators();
+        this.checkHtmlTags();
+        this.diagnostics.sort((a, b) => a.start - b.start);
+        this.warnings.sort((a, b) => a.start - b.start);
+        return {
+            diagnostics: this.diagnostics,
+            warnings: this.warnings,
+            ...this.collectDeclarations(),
+            types: this.checkedTypes,
+            ...(this.completion ? { completion: this.completion } : {}),
+        };
+    }
+}
+export function check(program, options = {}) {
+    return new Checker(program, options).run();
+}

package/dist/checker/classes.d.ts

@@ -0,0 +1,24 @@
+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 {
+    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;
+    /** 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;
+    protected checkOverride(info: ClassInfo, method: ast.MethodDeclaration): void;
+    private packages;
+    /** What other modules need to inline the exported components and decorators of this one. */
+    protected modulePackages(): ModulePackages;
+    /** The top-level declarations, and those of them that are exported. */
+    protected collectDeclarations(): {
+        exports: ModuleExports;
+        declarations: ModuleExports;
+    };
+}

package/dist/checker/classes.js

@@ -0,0 +1,223 @@
+import { inlinePackages } from "../inline-packages.js";
+import { DeclarationChecker } from "./declarations.js";
+import { isSuperCall, assignsField } from "./helpers.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 {
+    ensureClassResolved(info) {
+        const resolve = this.unresolvedClasses.get(info);
+        if (!resolve || this.resolvingClasses.has(info))
+            return;
+        this.resolvingClasses.add(info);
+        try {
+            resolve();
+        }
+        finally {
+            this.resolvingClasses.delete(info);
+            this.unresolvedClasses.delete(info);
+        }
+    }
+    /** Resolves the base class and the types of all members (but does not check method bodies). */
+    resolveClass(node, info) {
+        this.withTypeParams(info.typeParams, node.typeParams, () => this.resolveClassMembers(node, info));
+    }
+    resolveClassMembers(node, info) {
+        if (node.superClass) {
+            const base = this.checkValue(node.superClass);
+            const baseParams = base.kind === 'classValue' ? base.info.typeParams : [];
+            if (base.kind === 'classValue' && baseParams.some((param) => !param.default)) {
+                // The base is a value, as in JS, so it has no type arguments: `extends Stack<number>` cannot be written.
+                this.error(`cannot extend the generic class "${base.info.name}": generic base classes are not supported`, node.superClass);
+                info.untypedBase = true;
+            }
+            else if (base.kind === 'classValue') {
+                this.ensureClassResolved(base.info);
+                if (this.resolvingClasses.has(base.info) || isSubclass(base.info, info)) {
+                    this.error(`class "${info.name}" cannot extend itself`, node.superClass);
+                }
+                else {
+                    info.superClass = base.info;
+                    // A generic class from a `.d.ts` whose parameters all have defaults.
+                    if (baseParams.length > 0)
+                        info.superArgs = baseParams.map((param) => param.default);
+                }
+            }
+            else if (base.kind === 'any') {
+                info.untypedBase = true;
+            }
+            else if (base.kind !== 'unknown') {
+                this.error(`cannot extend ${typeToString(base)}: it is not a class`, node.superClass);
+            }
+        }
+        for (const member of node.members) {
+            switch (member.kind) {
+                case 'FieldDeclaration': {
+                    const declared = member.type ? this.resolveType(member.type) : null;
+                    let type = declared ?? UNKNOWN;
+                    const { value } = member;
+                    if (value) {
+                        const valueType = this.withClass({ info, isStatic: member.isStatic }, () => this.checkValue(value, declared));
+                        if (declared)
+                            this.expectAssignable(valueType, declared, value);
+                        else
+                            type = this.inferredType(valueType, value);
+                    }
+                    this.declareMember(info, member.isStatic, member.name, {
+                        type,
+                        method: false,
+                        visibility: member.visibility,
+                        owner: info,
+                    });
+                    break;
+                }
+                case 'MethodDeclaration':
+                    this.declareMember(info, member.isStatic, member.name, {
+                        type: this.signature(member.params, member.results, member.async),
+                        method: true,
+                        visibility: member.visibility,
+                        owner: info,
+                    });
+                    break;
+                case 'ConstructorDeclaration':
+                    if (info.ctor)
+                        this.error('a class can have only one constructor', member);
+                    info.ctor = this.signature(member.params, []);
+                    info.ctorVisibility = member.visibility;
+                    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);
+    }
+    /** Method bodies and the checks that need every member of the class. */
+    checkClassBodies(node, info) {
+        this.withTypeParams(info.typeParams, null, () => this.checkClassMembers(node, info));
+    }
+    checkClassMembers(node, info) {
+        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;
+                if (type?.kind !== 'function')
+                    continue;
+                this.withClass({ info, isStatic: member.isStatic }, () => this.checkFunction(member.params, type, type.results, member.body, {
+                    async: member.async,
+                }));
+                this.checkOverride(info, member);
+            }
+            else if (member.kind === 'ConstructorDeclaration' && info.ctor) {
+                constructorNode = member;
+                const type = info.ctor;
+                this.withClass({ info, isStatic: false }, () => this.checkFunction(member.params, type, [], member.body, { isConstructor: true }));
+                const derived = info.superClass !== null || info.untypedBase;
+                if (derived && !member.body.body.some(isSuperCall)) {
+                    this.error('the constructor of a derived class must call super(...)', member);
+                }
+            }
+        }
+        // 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)
+                continue;
+            const type = info.members.get(member.name.name)?.type;
+            if (!type || hasZeroValue(type))
+                continue;
+            if (constructorNode && assignsField(constructorNode.body, member.name.name))
+                continue;
+            this.error(`field "${member.name.name}" needs a value: ${typeToString(type)} has no zero value, ` +
+                'so initialize it here or assign it in the constructor', member.name);
+        }
+        for (const reference of node.implements) {
+            const target = this.resolveTypeName(reference.name, reference.typeArgs);
+            if (target.kind === 'unknown')
+                continue;
+            if (target.kind !== 'object' && target.kind !== 'class') {
+                this.error(`cannot implement ${typeToString(target)}: it is not an interface`, reference);
+            }
+            else if (!isAssignable(info.instance, target)) {
+                const reason = explainMismatch(info.instance, target);
+                this.error(`class "${info.name}" does not implement ${typeToString(target)}${reason ? `: ${reason}` : ''}`, reference);
+            }
+        }
+    }
+    checkOverride(info, method) {
+        if (!info.superClass)
+            return;
+        const base = findClassMember(info.superClass, method.name.name, method.isStatic);
+        const own = (method.isStatic ? info.statics : info.members).get(method.name.name);
+        if (!base || !own || isAssignable(own.type, base.type))
+            return;
+        this.error(`"${method.name.name}" overrides ${base.owner?.name ?? info.superClass.name}.${method.name.name} ` +
+            `with an incompatible type: ${typeToString(own.type)} instead of ${typeToString(base.type)}`, method.name);
+    }
+    packages = null;
+    /** What other modules need to inline the exported components and decorators of this one. */
+    modulePackages() {
+        return (this.packages ??= inlinePackages(this.program));
+    }
+    /** The top-level declarations, and those of them that are exported. */
+    collectDeclarations() {
+        const exports = {
+            values: new Map(),
+            types: new Map(),
+            decorators: new Map(),
+            components: new Map(),
+        };
+        const declarations = { values: new Map(), types: new Map() };
+        const valueOf = (name) => this.moduleScope.values.get(name)?.type ?? UNKNOWN;
+        const typeOf = (name) => {
+            const entry = this.moduleScope.types.get(name);
+            if (!entry)
+                return UNKNOWN;
+            return entry.kind === 'alias' ? this.resolveAlias(entry) : entry;
+        };
+        const add = (exported, kind, name, type) => {
+            declarations[kind].set(name, type);
+            if (exported)
+                exports[kind].set(name, type);
+        };
+        for (const statement of this.program.body) {
+            switch (statement.kind) {
+                case 'FuncDeclaration':
+                    add(statement.exported, 'values', statement.name.name, valueOf(statement.name.name));
+                    break;
+                case 'VariableDeclaration':
+                    for (const name of statement.names) {
+                        add(statement.exported, 'values', name.name, valueOf(name.name));
+                    }
+                    break;
+                case 'ClassDeclaration':
+                    add(statement.exported, 'values', statement.name.name, valueOf(statement.name.name));
+                    add(statement.exported, 'types', statement.name.name, typeOf(statement.name.name));
+                    break;
+                case 'InterfaceDeclaration':
+                case 'TypeAliasDeclaration':
+                    add(statement.exported, 'types', statement.name.name, typeOf(statement.name.name));
+                    break;
+                case 'ComponentDeclaration': {
+                    const info = this.moduleScope.values.get(statement.name.name)?.component;
+                    if (statement.exported && info?.node === statement) {
+                        info.inline = this.modulePackages().components.get(info.node.name.name) ?? null;
+                        info.expressionTypes = this.checkedTypes;
+                        exports.components.set(statement.name.name, info);
+                    }
+                    break;
+                }
+                case 'DecoratorDeclaration': {
+                    const info = this.decorators.get(statement.name.name);
+                    if (statement.exported && info?.node === statement) {
+                        exports.decorators.set(statement.name.name, info);
+                    }
+                    break;
+                }
+                default:
+                    break;
+            }
+        }
+        return { exports, declarations };
+    }
+}

package/dist/checker/completion-names.d.ts

@@ -0,0 +1,11 @@
+export declare const STRING_MEMBERS: string[];
+export declare const NUMBER_MEMBERS: string[];
+export declare const BOOL_MEMBERS: string[];
+export declare const BIGINT_MEMBERS: string[];
+export declare const ARRAY_MEMBERS: string[];
+/** HTML tags, for completion without TypeScript's `HTMLElementTagNameMap`. */
+export declare const HTML_TAGS: string[];
+/** Event attributes as programs write them: `on` and the event in camel case. */
+export declare const EVENT_ATTRIBUTES: string[];
+/** DOM properties that attributes spell differently. */
+export declare const ATTRIBUTE_NAMES: ReadonlyMap<string, string>;