rooklang 0.4.2 → 0.5.0

package/dist/checker/imports.js

@@ -3,15 +3,82 @@ import { ANY, LazyMap, memberNames, UNKNOWN } from "./types.js";
 // Imports: the names of other modules, typed by their exports (`importModule` for `.rk` modules,
 // `importDeclarations` for the rest), or untyped when nothing is known about them.
 export class ImportChecker extends CheckerBase {
-    declareImport(node) {
-        const specifier = node.source.value;
-        const isRook = specifier.endsWith('.rk');
-        const result = isRook
+    /** `export { Rows } from "./rows.rk"`: what this module exports of another, by name here. */
+    reexported = {
+        values: new Map(),
+        types: new Map(),
+        decorators: new Map(),
+        components: new Map(),
+        shared: new Set(),
+    };
+    /** The exports of the module that an import or an `export ... from` names. */
+    exportsOf(source) {
+        const specifier = source.value;
+        const result = specifier.endsWith('.rk')
             ? this.options.importModule?.(specifier)
             : this.options.importDeclarations?.(specifier);
         if (result && 'error' in result)
-            this.error(result.error, node.source);
-        const exports = result && 'exports' in result ? result.exports : null;
+            this.error(result.error, source);
+        return result && 'exports' in result ? result.exports : null;
+    }
+    /**
+     * `export { Row, Rows } from "./rows.rk"`: the names go into the exports of this module, with
+     * what a component or a decorator brings. Without types of the module, nothing is known of them.
+     */
+    declareExportFrom(node) {
+        const exports = this.exportsOf(node.source);
+        if (!exports)
+            return;
+        const specifiers = node.specifiers ??
+            [
+                ...new Set([
+                    ...exports.values.keys(),
+                    ...exports.types.keys(),
+                    ...(exports.decorators?.keys() ?? []),
+                    ...(exports.components?.keys() ?? []),
+                ]),
+            ].map((name) => {
+                const id = { kind: 'Identifier', name, start: node.start, end: node.start };
+                return {
+                    kind: 'ImportSpecifier',
+                    imported: id,
+                    local: id,
+                    start: node.start,
+                    end: node.start,
+                };
+            });
+        const into = this.reexported;
+        for (const { imported, local } of specifiers) {
+            const name = imported.name;
+            const value = exports.values.get(name);
+            const type = exports.types.get(name);
+            const decorator = exports.decorators?.get(name);
+            const component = exports.components?.get(name);
+            if ([value, type, decorator, component].every((each) => each === undefined)) {
+                this.error(`"${name}" is not exported by "${node.source.value}"`, imported);
+                continue;
+            }
+            // Their code and the hidden names it uses keep the name they have in their module.
+            if ((decorator || component) && local.name !== name) {
+                this.error(`renaming ${component ? 'components' : 'decorators'} is not supported yet: export { ${name} }`, local);
+                continue;
+            }
+            if (value !== undefined)
+                into.values.set(local.name, value);
+            if (type !== undefined)
+                into.types.set(local.name, type);
+            if (decorator)
+                into.decorators.set(name, decorator);
+            if (component)
+                into.components.set(name, component);
+            if (exports.shared?.has(name))
+                into.shared.add(local.name);
+        }
+    }
+    declareImport(node) {
+        const specifier = node.source.value;
+        const isRook = specifier.endsWith('.rk');
+        const exports = this.exportsOf(node.source);
         if (node.defaultImport && exports && !isRook) {
             // `import fs from "node:fs"`: the default export of a module with types.
             const value = exports.values.get('default');

package/dist/checker/initializers.d.ts

@@ -1,6 +1,7 @@
 import type * as ast from '../ast.ts';
 import type { Binding } from './context.ts';
 import { TypeResolver } from './resolution.ts';
+import { type Type } from './types.ts';
 export declare abstract class InitializerChecker extends TypeResolver {
     /** Initializers being checked, the outermost first. */
     private readonly initializers;
@@ -16,7 +17,18 @@ export declare abstract class InitializerChecker extends TypeResolver {
     protected deferBody(body: ast.Node, check: () => void): boolean;
     /** The error for `binding` used in its own initializer, or `null` if this use is fine. */
     protected initializerError(binding: Binding): string | null;
+    /**
+     * `const { name, size: bytes, ...rest } = file`: the types of the fields, and of the rest, an
+     * object with the other fields. A method would lose its object, so it is not taken.
+     */
+    protected patternTypes(node: ast.VariableDeclaration): Type[];
     private lookupFrom;
     private saveState;
     private restoreState;
+    /**
+     * `const LIMIT = 5` or `const NAMES []string = ...` of the module: its type, before the
+     * statements are checked, for the fields of classes (Binding.early). Only a written type or a
+     * literal value, which reads no other names; what is reported here is reported again later.
+     */
+    protected typeEarly(node: ast.VariableDeclaration): void;
 }

package/dist/checker/initializers.js

@@ -1,5 +1,7 @@
 import { mentionsName } from "../names.js";
 import { TypeResolver } from "./resolution.js";
+import { isUntyped } from "./helpers.js";
+import { ANY, instanceMembers, isNullable, typeToString, UNKNOWN, } from "./types.js";
 export class InitializerChecker extends TypeResolver {
     /** Initializers being checked, the outermost first. */
     initializers = [];
@@ -71,6 +73,41 @@ export class InitializerChecker extends TypeResolver {
             ? `"${name}" is used in its own initializer: give it a type, e.g. ${declaration.keyword} ${name} func() = ...`
             : `"${name}" is used in its own initializer: write its type after the name`;
     }
+    /**
+     * `const { name, size: bytes, ...rest } = file`: the types of the fields, and of the rest, an
+     * object with the other fields. A method would lose its object, so it is not taken.
+     */
+    patternTypes(node) {
+        const { keys, rest } = node.pattern;
+        const value = node.values[0];
+        const object = this.checkValue(value);
+        if (isUntyped(object))
+            return node.names.map(() => ANY);
+        if (isNullable(object)) {
+            this.error(`cannot take the fields of ${typeToString(object)}: it may be null, check it first`, value);
+            return node.names.map(() => UNKNOWN);
+        }
+        const types = keys.map((key) => {
+            const name = key.kind === 'Identifier' ? key.name : key.value;
+            const member = this.findMember(object, name, key);
+            if (member === 'any')
+                return ANY;
+            if (member?.method) {
+                this.error(`"${name}" is a method: call it on the object, e.g. ${value.kind === 'Identifier' ? value.name : 'object'}.${name}()`, key);
+            }
+            return member?.type ?? UNKNOWN;
+        });
+        if (!rest)
+            return types;
+        const taken = new Set(keys.map((key) => (key.kind === 'Identifier' ? key.name : key.value)));
+        const all = object.kind === 'class'
+            ? instanceMembers(object.info)
+            : object.kind === 'object'
+                ? object.members
+                : new Map();
+        const members = new Map([...all].filter(([name, member]) => !taken.has(name) && !member.method && member.visibility === 'public'));
+        return [...types, { kind: 'object', name: null, members, call: null }];
+    }
     lookupFrom(scope, name) {
         for (; scope; scope = scope.parent) {
             const binding = scope.values.get(name);
@@ -101,4 +138,47 @@ export class InitializerChecker extends TypeResolver {
             decorator: this.decorator,
         } = state);
     }
+    /**
+     * `const LIMIT = 5` or `const NAMES []string = ...` of the module: its type, before the
+     * statements are checked, for the fields of classes (Binding.early). Only a written type or a
+     * literal value, which reads no other names; what is reported here is reported again later.
+     */
+    typeEarly(node) {
+        const [name] = node.names;
+        const [value] = node.values;
+        const binding = name && this.scope.values.get(name.name);
+        if (node.keyword !== 'const' || node.names.length !== 1 || !binding)
+            return;
+        if (!node.type && (node.values.length !== 1 || !value || !isLiteral(value)))
+            return;
+        const count = this.diagnostics.length;
+        try {
+            binding.early = node.type
+                ? this.resolveType(node.type)
+                : this.inferredType(this.checkValue(value), value);
+        }
+        finally {
+            this.diagnostics.length = count;
+        }
+    }
+}
+/** A value made of literals only: `5`, `"a"`, `-1`, `[1, 2]`, `{ retries: 3 }`. */
+function isLiteral(node) {
+    switch (node.kind) {
+        case 'NumberLiteral':
+        case 'StringLiteral':
+        case 'BooleanLiteral':
+            return true;
+        case 'TemplateLiteral':
+            return node.expressions.length === 0;
+        case 'UnaryExpression':
+            return node.operator === '-' && node.argument.kind === 'NumberLiteral';
+        case 'ArrayLiteral':
+            return (node.elements.length > 0 &&
+                node.elements.every((element) => element.kind !== 'SpreadElement' && isLiteral(element)));
+        case 'ObjectLiteral':
+            return node.properties.every((property) => property.kind === 'Property' && isLiteral(property.value));
+        default:
+            return false;
+    }
 }

package/dist/checker/loops.js

@@ -76,7 +76,9 @@ export class LoopChecker extends BytesChecker {
         this.withScope(() => {
             if (node.key)
                 this.declareValue(node.key, 'loop', key);
-            this.declareValue(node.value, 'loop', value);
+            const item = this.declareValue(node.value, 'loop', value);
+            if (iterable.kind === 'array')
+                item.iterable = node.iterable;
             if (node.withKey)
                 this.checkListKey(node.withKey);
             this.dropNarrowing(node.body);

package/dist/checker/members.js

@@ -17,6 +17,7 @@ export class MemberChecker extends DecoratorMemberChecker {
             let [callee, shortCircuits] = this.chainPart(node.callee);
             this.checkDecoratorMutation(node);
             this.checkSharedMutation(node);
+            this.checkPropMutation(node);
             if (isNullable(callee)) {
                 if (node.optional)
                     shortCircuits = true;

package/dist/checker/resolution.d.ts

@@ -15,6 +15,8 @@ export declare abstract class TypeResolver extends ClassChecker {
     protected typedArray(name: string): Type;
     /** `[]byte`, a Uint8Array. */
     protected bytes(): Type;
+    /** The results of a function: `void` alone, as in `close() void`, is no result. */
+    protected resolveResults(results: readonly ast.TypeNode[]): Type[];
     protected resolveTypeName(name: ast.Identifier, typeArgs?: readonly ast.TypeNode[]): Type;
     protected resolveAlias(entry: AliasEntry): Type;
     protected resolveAliasType(entry: AliasEntry): Type;

package/dist/checker/resolution.js

@@ -21,8 +21,14 @@ export class TypeResolver extends ClassChecker {
                 return topicOf(this.resolveType(node.element));
             case 'NullableType':
                 return nullable(this.resolveType(node.type));
-            case 'FuncType':
-                return func(node.params.map((param) => this.resolveType(param)), node.results.map((result) => this.resolveType(result)), { iterator: node.iterator === true });
+            case 'FuncType': {
+                // `func(string, ...[]any)`: the rest is an array of what each argument is.
+                const rest = node.rest ? this.resolveType(node.rest) : null;
+                return func(node.params.map((param) => this.resolveType(param)), this.resolveResults(node.results), {
+                    iterator: node.iterator === true,
+                    ...(rest ? { rest: rest.kind === 'array' ? rest.element : ANY } : {}),
+                });
+            }
             case 'ComponentType':
                 return this.resolveComponentType(node);
             case 'ObjectType': {
@@ -78,6 +84,11 @@ export class TypeResolver extends ClassChecker {
     bytes() {
         return this.typedArray('Uint8Array');
     }
+    /** The results of a function: `void` alone, as in `close() void`, is no result. */
+    resolveResults(results) {
+        const types = results.map((result) => this.resolveType(result));
+        return types.length === 1 && types[0].kind === 'void' ? [] : types;
+    }
     resolveTypeName(name, typeArgs = []) {
         const entry = this.lookupType(name.name);
         if (entry === undefined) {

package/dist/checker/statements.d.ts

@@ -24,6 +24,11 @@ export declare abstract class StatementChecker extends AssignmentChecker {
     private checkDelete;
     protected checkBlock(statements: readonly ast.Statement[]): void;
     protected checkVariableDeclaration(node: ast.VariableDeclaration): void;
+    /**
+     * `export const Rows = Inner` of a component, without a type: its .d.ts would lose the
+     * properties, and other modules import a component by its name, with `export { ... } from`.
+     */
+    private componentInConstant;
     /**
      * `const user, err = loadUser(id)` of `(User, error)`: `user` is not null once `err` is found to
      * be null. Variables of `let` may be assigned apart, so only constants are linked.

package/dist/checker/statements.js

@@ -1,7 +1,7 @@
 import { guardedByError } from "./error-results.js";
 import { AssignmentChecker } from "./assignments.js";
 import { placeOf } from "./context.js";
-import { isTerminating } from "./flow.js";
+import { isTerminating, markNeverEnding } from "./flow.js";
 import { isUntyped, isNumeric, ownStatements } from "./helpers.js";
 import { func, hasZeroValue, isNullable, nonNull, nullable, typeToString, UNKNOWN, } from "./types.js";
 // Statements: declarations of variables, blocks, `mount`, `effect`. Assignments and `return`
@@ -16,7 +16,8 @@ export class StatementChecker extends AssignmentChecker {
                 this.checkBlock(node.body);
                 break;
             case 'ExpressionStatement':
-                this.checkExpression(node.expression, null);
+                if (this.checkExpression(node.expression, null).kind === 'never')
+                    markNeverEnding(node);
                 break;
             case 'JsxElementStatement':
                 this.checkExpression(node.element, null);
@@ -75,6 +76,7 @@ export class StatementChecker extends AssignmentChecker {
                 this.checkEffect(node);
                 break;
             case 'ImportDeclaration':
+            case 'ExportFromDeclaration':
             case 'FuncDeclaration':
             case 'ComponentDeclaration':
             case 'DecoratorDeclaration':
@@ -181,8 +183,26 @@ export class StatementChecker extends AssignmentChecker {
             });
             if (node.keyword === 'const' && !declared)
                 this.linkError(node, bindings);
+            if (node.exported && !declared)
+                this.componentInConstant(node);
         });
     }
+    /**
+     * `export const Rows = Inner` of a component, without a type: its .d.ts would lose the
+     * properties, and other modules import a component by its name, with `export { ... } from`.
+     */
+    componentInConstant(node) {
+        const [value] = node.values;
+        const local = value?.kind === 'Identifier' ? value.name : null;
+        if (local === null || !this.lookupValue(local)?.component)
+            return;
+        const imported = this.program.body.flatMap((statement) => statement.kind === 'ImportDeclaration'
+            ? statement.namedImports
+                .filter((specifier) => specifier.local.name === local)
+                .map((specifier) => `export { ${specifier.imported.name} } from ${statement.source.raw}`)
+            : []);
+        this.error(`a component is exported by its name, not in a constant without a type: ${imported.length > 0 ? `write ${imported[0]}` : 'write export comp where it is declared'}, or give the constant a type, e.g. export const ${node.names[0].name} comp(title string) = ${local}`, node);
+    }
     /**
      * `const user, err = loadUser(id)` of `(User, error)`: `user` is not null once `err` is found to
      * be null. Variables of `let` may be assigned apart, so only constants are linked.
@@ -203,7 +223,10 @@ export class StatementChecker extends AssignmentChecker {
     initializerTypes(node, declared) {
         const { names, values } = node;
         let types;
-        if (node.body) {
+        if (node.pattern) {
+            types = this.patternTypes(node);
+        }
+        else if (node.body) {
             types = [this.derivedBlockType(names[0].name, node.body.body, declared)];
         }
         else if (values.length === 0) {

package/dist/checker/tagged-unions.d.ts

@@ -27,6 +27,12 @@ export declare abstract class TaggedUnionChecker extends ControlFlowChecker {
     /** `switch d.kind`: in a case the members with its tags, in `default` those of no case. */
     protected narrowCase(node: ast.SwitchStatement, switchCase: ast.SwitchCase): Narrowing;
     private narrowTag;
+    /**
+     * The type of a field in the objects of a union that no tag chooses from, when it is the same in
+     * each that has it: the literal takes it from the context, as `fetch: req => ...` of the options
+     * of `Bun.serve`. Functions only need the same parameters, which is what their literals take.
+     */
+    protected commonField(objects: readonly Type[], name: string): Type | null;
     /**
      * `{ kind: "pickup", shop: "Main st." }` where one of several objects is expected: the member
      * that a tag of the literal chooses, or `null` when no tag chooses one. A tag of no member is

package/dist/checker/tagged-unions.js

@@ -1,7 +1,8 @@
 import { placeOf } from "./context.js";
 import { ControlFlowChecker } from "./control-flow.js";
 import { literalValue, narrowByTag } from "./flow.js";
-import { findClassMember, memberTypeOf, nonNull, typeToString, unionMembers, UNKNOWN, } from "./types.js";
+import { callSignature } from "./helpers.js";
+import { findClassMember, memberTypeOf, nonNull, typesEqual, typeToString, unionMembers, UNKNOWN, } from "./types.js";
 export class TaggedUnionChecker extends ControlFlowChecker {
     /** The paths among the checked member expressions, with the types of their fields. */
     paths = new WeakMap();
@@ -103,6 +104,35 @@ export class TaggedUnionChecker extends ControlFlowChecker {
         const tags = owner && this.tagValues(unionMembers(nonNull(owner.type)), target.property.name);
         return owner && tags ? [[owner.place, narrowByTag(owner.type, tags, values, equal)]] : [];
     }
+    /**
+     * The type of a field in the objects of a union that no tag chooses from, when it is the same in
+     * each that has it: the literal takes it from the context, as `fetch: req => ...` of the options
+     * of `Bun.serve`. Functions only need the same parameters, which is what their literals take.
+     */
+    commonField(objects, name) {
+        const types = objects.flatMap((object) => {
+            const member = object.kind === 'object'
+                ? object.members.get(name)
+                : object.kind === 'class'
+                    ? findClassMember(object.info, name, false)
+                    : undefined;
+            return member ? [member.type] : [];
+        });
+        const [first] = types;
+        if (!first)
+            return null;
+        if (types.every((type) => typesEqual(type, first)))
+            return first;
+        const signature = callSignature(nonNull(first));
+        const sameParams = types.every((type) => {
+            const other = callSignature(nonNull(type));
+            return (signature &&
+                other &&
+                other.params.length === signature.params.length &&
+                other.params.every((param, i) => typesEqual(param, signature.params[i])));
+        });
+        return sameParams ? first : null;
+    }
     /**
      * `{ kind: "pickup", shop: "Main st." }` where one of several objects is expected: the member
      * that a tag of the literal chooses, or `null` when no tag chooses one. A tag of no member is

package/dist/checker/tags.d.ts

@@ -0,0 +1,6 @@
+import type * as ast from '../ast.ts';
+import { CallChecker } from './calls.ts';
+import { type Type } from './types.ts';
+export declare abstract class TagChecker extends CallChecker {
+    protected checkTaggedTemplate(node: ast.TaggedTemplateExpression): Type;
+}

package/dist/checker/tags.js

@@ -0,0 +1,44 @@
+import { CallChecker, withDefaults } from "./calls.js";
+import { callSignature, isUntyped, signaturesOf } from "./helpers.js";
+import { ANY, containsTypeParam, inferTypeParams, nonNull, substitute, typeToString, UNKNOWN, VOID, } from "./types.js";
+// Tagged templates, sql`select * from users where id = ${id}`: a call of the tag with the strings
+// of the template, a TemplateStringsArray, and its values, which are checked as the arguments that
+// follow the strings.
+export class TagChecker extends CallChecker {
+    checkTaggedTemplate(node) {
+        const tag = this.checkValue(node.tag);
+        const values = node.quasi.expressions;
+        const signature = isUntyped(tag) ? null : callSignature(nonNull(tag));
+        if (!signature) {
+            if (!isUntyped(tag)) {
+                this.error(`${typeToString(tag)} cannot be a tag: a tag is a function, e.g. func sql(parts TemplateStringsArray, ...values []any)`, node.tag);
+            }
+            for (const value of values)
+                this.checkValue(value);
+            return isUntyped(tag) ? ANY : UNKNOWN;
+        }
+        // Of overloads, the one that takes the strings of a template, as `sql` of postgres has.
+        const chosen = signaturesOf(signature).find(takesTemplate) ?? signature;
+        const inferred = new Map();
+        values.forEach((value, i) => {
+            const param = chosen.params[i + 1] ?? chosen.rest;
+            if (!param) {
+                this.error(`too many values for the tag: it takes ${chosen.params.length - 1} after the strings`, value);
+                this.checkValue(value);
+                return;
+            }
+            const type = this.checkValue(value, containsTypeParam(param) ? null : param);
+            inferTypeParams(param, type, inferred);
+            this.expectAssignable(type, substitute(param, inferred), value, ` in value ${i + 1}`);
+        });
+        const [result] = chosen.results;
+        return result ? substitute(result, withDefaults(chosen.typeParams, inferred)) : VOID;
+    }
+}
+/** Whether the first parameter takes the strings of a template: TemplateStringsArray or []string. */
+function takesTemplate(signature) {
+    const [first] = signature.params;
+    return (first !== undefined &&
+        ((first.kind === 'object' && first.name === 'TemplateStringsArray') ||
+            (first.kind === 'array' && first.element.kind === 'string')));
+}

package/dist/checker/types/constructors.js

@@ -94,10 +94,15 @@ export function isNullable(type) {
     return type.kind === 'nullable' || type.kind === 'null';
 }
 export function func(params, results, options = {}) {
+    let required = options.required ?? params.length;
+    // A parameter that takes `void` may be left out at the end, as in TypeScript: the `resolve()`
+    // of a `Promise<void>`.
+    while (required > 0 && takesVoid(params[required - 1]))
+        required--;
     return {
         kind: 'function',
         params,
-        required: options.required ?? params.length,
+        required,
         rest: options.rest ?? null,
         results,
         typeParams: options.typeParams ?? [],
@@ -127,3 +132,7 @@ export function createClass(name) {
     info.value = { kind: 'classValue', info };
     return info;
 }
+/** `void`, or a union with it: `void | PromiseLike<void>`. */
+function takesVoid(type) {
+    return type.kind === 'void' || (type.kind === 'union' && type.types.some(takesVoid));
+}

package/dist/checker/types/params.js

@@ -2,8 +2,8 @@ import { instanceMembers } from "./classes.js";
 import { arrayOf, func, nonNull, nullable, union } from "./constructors.js";
 import { instantiate } from "./generics.js";
 import { iteratedBy } from "./iterables.js";
-import { memberNames } from "./lazy.js";
-import { VOID, } from "./model.js";
+import { LazyMap, memberNames } from "./lazy.js";
+import { VOID } from "./model.js";
 import { typesEqual } from "./relations.js";
 // Type parameters: substituting type arguments and inferring them from the arguments of a call.
 /** Whether a type mentions type parameters: any of them, or only those in `only`. */
@@ -61,7 +61,8 @@ export function substitute(type, bindings, fallback) {
             // A generic method of a generic interface keeps its own parameters: `map<U>` of `Box<T>`.
             // A default that uses the interface's parameters needs a parameter of its own:
             // `then<TResult1 = T>` of `Promise<Response>` has the default Response.
-            const own = new Map(bindings);
+            // The same bindings, when no parameter needs a copy, so that substituteObject knows a cycle.
+            let own = bindings;
             const typeParams = type.typeParams
                 .filter((param) => !bindings.has(param))
                 .map((param) => {
@@ -69,6 +70,8 @@ export function substitute(type, bindings, fallback) {
                     return param;
                 }
                 const fresh = freshParam(param, substitute(param.default, bindings));
+                if (own === bindings)
+                    own = new Map(bindings);
                 own.set(param, fresh);
                 return fresh;
             });
@@ -122,11 +125,34 @@ function substituteObject(type, bindings, fallback) {
     // A named interface without parameters cannot use them; an object type literal might.
     if (type.name !== null || !containsTypeParam(type))
         return type;
-    const members = new Map();
-    for (const [name, member] of type.members)
-        members.set(name, { ...member, type: sub(member.type) });
-    return { ...type, members, call: type.call && sub(type.call) };
+    // Type literals of .d.ts files may refer to themselves, as the chains of Vitest do
+    // (`describe.concurrent.skip`): members are substituted when they are used, as in instantiate,
+    // and the same bindings give the same copy, so a member that comes back gets it.
+    let copies = fallback === undefined ? substituted.get(bindings) : undefined;
+    if (fallback === undefined && !copies) {
+        copies = new Map();
+        substituted.set(bindings, copies);
+    }
+    const copy = copies?.get(type);
+    if (copy)
+        return copy;
+    let call;
+    const result = {
+        ...type,
+        members: new LazyMap(() => memberNames(type.members), (name) => {
+            const member = type.members.get(name);
+            return member && { ...member, type: sub(member.type) };
+        }),
+    };
+    Object.defineProperty(result, 'call', {
+        enumerable: true,
+        get: () => (call === undefined ? (call = type.call && sub(type.call)) : call),
+    });
+    copies?.set(type, result);
+    return result;
 }
+/** The copies of object type literals, by the bindings they were made with. */
+const substituted = new WeakMap();
 const MAX_STRUCTURAL_DEPTH = 3;
 /** The names of the templates of channel types (checker/channel.ts). */
 const CHANNELS = new Set(['chan', 'chan<-', '<-chan']);

package/dist/checker/types/printing.js

@@ -8,6 +8,8 @@ import { isTopic, topicElement } from "./topic.js";
 const MAX_OBJECT_DEPTH = 3;
 /** How many members of an object type without a name are printed: `globalThis` has hundreds. */
 const MAX_OBJECT_MEMBERS = 8;
+/** How long an object type inside another one may be before it is printed as `{ ... }`. */
+const MAX_NESTED_LENGTH = 80;
 let objectDepth = 0;
 /** `[]byte`: a Uint8Array, of the lib files or the built-in one. */
 export function isBytes(type) {
@@ -85,7 +87,9 @@ export function typeToString(type) {
                     members.unshift(`[number]: ${typeToString(type.numberIndex)}`);
                 if (type.index)
                     members.unshift(`[string]: ${typeToString(type.index)}`);
-                return members.length === 0 ? '{}' : `{ ${members.join('; ')} }`;
+                const text = members.length === 0 ? '{}' : `{ ${members.join('; ')} }`;
+                // A long type inside another one, as the chains of Vitest, would fill the screen.
+                return objectDepth > 1 && text.length > MAX_NESTED_LENGTH ? '{ ... }' : text;
             }
             finally {
                 objectDepth--;

package/dist/checker/types/relations.js

@@ -187,7 +187,8 @@ function missingMember(source, members, assuming) {
     for (const [name, member] of members) {
         const found = own.get(name);
         if (!found) {
-            if (!member.method && isNullable(member.type))
+            // `unix?: never` of a `.d.ts` is a field that must be left out, as in the options of Bun.serve.
+            if (!member.method && (isNullable(member.type) || member.type.kind === 'void'))
                 continue;
             return { name, found: null, expected: member.type };
         }

package/dist/codegen/calls.d.ts

@@ -7,6 +7,8 @@ export declare abstract class CallEmitter extends ExpressionEmitter {
      * given to it, after the local names it uses; the arguments are copied there. In the worker
      * module a literal runs in the same worker, with copies of those names as its first parameters.
      */
+    protected objectLiteral(node: ast.ObjectLiteral): string;
+    protected taggedTemplate(node: ast.TaggedTemplateExpression): string;
     protected go(node: ast.GoExpression): string;
     /** `yield v` for `yield(v)` in an iterator, `yield [k, v]` for `yield(k, v)`; else `null`. */
     private yielded;

package/dist/codegen/calls.js

@@ -5,7 +5,7 @@ import { isYieldCall } from "../iterators.js";
 import { TYPED_ARRAYS, TYPED_ELEMENTS } from "../typed-arrays.js";
 import { hasOptionalLink } from "./analysis.js";
 import { ExpressionEmitter } from "./expressions.js";
-import { ARROW, BINARY, POSTFIX } from "./syntax.js";
+import { ARROW, BINARY, POSTFIX, PRIMARY } from "./syntax.js";
 // Calls, `new`, array literals and conversions. A `[]byte` is a Uint8Array: a literal where the
 // checker found one expected becomes `new Uint8Array([...])`, and the conversions of Go between
 // text and its UTF-8 bytes use TextEncoder and TextDecoder, `[]byte(s)` and `string(data)`. In an
@@ -43,6 +43,28 @@ export class CallEmitter extends ExpressionEmitter {
      * given to it, after the local names it uses; the arguments are copied there. In the worker
      * module a literal runs in the same worker, with copies of those names as its first parameters.
      */
+    objectLiteral(node) {
+        if (node.properties.length === 0)
+            return '{}';
+        const properties = node.properties.map((property) => {
+            if (property.kind === 'SpreadElement') {
+                return `...${this.expression(property.argument, ARROW)}`;
+            }
+            const key = property.key.kind === 'StringLiteral' ? property.key.raw : property.key.name;
+            // `fetch(req) { ... }`: a method of JS, whose `this` is the object.
+            if (property.method && property.value.kind === 'FuncExpression') {
+                const [params, body] = this.func(property.value.params, property.value.body);
+                return `${property.value.async ? 'async ' : ''}${key}(${params}) ${body}`;
+            }
+            const value = this.expression(property.value, ARROW);
+            // A renamed shorthand (`{ delete }` → `delete$`) must keep its key.
+            return property.shorthand && value === key ? key : `${key}: ${value}`;
+        });
+        return `{ ${properties.join(', ')} }`;
+    }
+    taggedTemplate(node) {
+        return `${this.expression(node.tag, POSTFIX)}${this.expression(node.quasi, PRIMARY)}`;
+    }
     go(node) {
         const { callee } = node.call;
         const literal = callee.kind === 'FuncExpression' ? callee : null;