rooklang 0.4.2 → 0.5.0

package/dist/checker/assignments.js

@@ -77,6 +77,7 @@ export class AssignmentChecker extends InitializerChecker {
     checkTarget(target) {
         if (this.checkDecoratorWrite(target) || this.checkSharedWrite(target))
             return UNKNOWN;
+        this.checkPropWrite(target);
         switch (target.kind) {
             case 'Identifier': {
                 if (target.name === '_')
@@ -192,7 +193,7 @@ export class AssignmentChecker extends InitializerChecker {
         }
         const expected = fn.results;
         if (values.length === 0) {
-            if (expected.length > 0) {
+            if (expected.length > 0 && !fn.mayEnd) {
                 this.error(`missing return values: expected ${countValues(expected.length)}`, node);
             }
             return;

package/dist/checker/base.d.ts

@@ -6,6 +6,8 @@ export declare abstract class CheckerBase {
     protected abstract checkClassBodies(node: ast.ClassDeclaration, info: ClassInfo): void;
     protected abstract ensureClassResolved(info: ClassInfo): void;
     protected abstract resolveClass(node: ast.ClassDeclaration, info: ClassInfo): void;
+    protected abstract typeEarly(node: ast.VariableDeclaration): void;
+    protected abstract resolveResults(results: readonly ast.TypeNode[]): Type[];
     protected abstract inferredType(type: Type, node: ast.Expression): Type;
     protected abstract resolveAlias(entry: AliasEntry): Type;
     protected abstract resolveType(node: ast.TypeNode): Type;
@@ -52,6 +54,7 @@ export declare abstract class CheckerBase {
     protected abstract wrappedType(info: ComponentInfo, own: Type, seen: Set<ComponentInfo>): Type;
     protected abstract checkDecoratorMember(node: ast.DecoratorMember): Type;
     protected abstract checkDecoratorWrite(target: ast.Expression): boolean;
+    protected abstract checkPropWrite(target: ast.Expression): void;
     protected abstract checkComponentUse(node: ast.ElementExpression, tag: ast.Identifier): Type;
     protected abstract checkRefDeclaration(node: ast.VariableDeclaration): void;
     protected abstract checkStyle(node: ast.StyleStatement): void;

package/dist/checker/base.js

@@ -7,7 +7,7 @@ import { explainMismatch, isAssignable, LazyMap, memberNames, nonNull, property,
 // shared state → declarations → class members → classes → resolution → initializers → assignments → statements → control flow →
 // tagged unions → functions → expressions → array literals → operators → markup → forwarding → component bindings → components → component values →
 // refs → styles → decorator wrappers → decorator exports → decorators → decorator includes → decorator members →
-// members → calls → goroutines → channels → signals → queues → topics → decode → try → bytes → loops → go for →
+// members → calls → tags → 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.

package/dist/checker/builtins.js

@@ -7,7 +7,7 @@ import { CHANNEL_OBJECT, TOPIC_OBJECT } from "./channel-objects.js";
 import { PROMISE } from "./promise.js";
 import { BUFFERS } from "./transfer.js";
 import { UNTYPED_CLASSES, UNTYPED_GLOBALS } from "./untyped-globals.js";
-import { ANY, arrayOf, BIGINT, BOOL, ERROR, ERROR_CLASS, func, method, NUMBER, nullable, property, STRING, topicOf, union, } from "./types.js";
+import { ANY, arrayOf, BIGINT, BOOL, ERROR, ERROR_CLASS, func, method, NEVER, nullable, NUMBER, property, STRING, topicOf, union, VOID, } 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) {
@@ -280,6 +280,10 @@ export const GLOBAL_TYPES = new Map([
     ['string', STRING],
     ['bool', BOOL],
     ['any', ANY],
+    // A function whose result is `never` does not end: it throws or exits, as `process.exit`.
+    ['never', NEVER],
+    // The value of `Promise<void>`; as the result of a function, `void` is no result.
+    ['void', VOID],
     ['error', ERROR],
     ['Error', ERROR_CLASS.instance],
     ...['Date', 'RegExp', 'Map', 'Set', 'URL', ...UNTYPED_CLASSES, ...BUFFERS].map((name) => [name, ANY]),

package/dist/checker/calls.d.ts

@@ -21,3 +21,5 @@ export declare abstract class CallChecker extends MemberChecker {
     protected checkArguments(signature: FunctionType, args: readonly (ast.Expression | ast.SpreadElement)[], node: ast.NodeBase, inferred?: Map<TypeParam, Type>, expected?: Type | null): Type[];
     protected checkArgumentList(signature: FunctionType, args: readonly (ast.Expression | ast.SpreadElement)[], inferred: Map<TypeParam, Type>, needsContext: (arg: ast.Expression | ast.SpreadElement) => boolean, beforeContext?: () => void): void;
 }
+/** The inferred type parameters, and the default, or unknown, of each of the others. */
+export declare function withDefaults(params: readonly TypeParam[], inferred: ReadonlyMap<TypeParam, Type>): Map<TypeParam, Type>;

package/dist/checker/calls.js

@@ -136,7 +136,10 @@ export class CallChecker extends MemberChecker {
         }
         // 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);
+        // So are object literals with such functions in their fields: `serve({ fetch: req => ... })`.
+        const needsContext = (arg) => (arg.kind === 'ArrowFunction' && arg.params.some((param) => param.type === null)) ||
+            (arg.kind === 'ObjectLiteral' &&
+                arg.properties.some((property) => property.kind === 'Property' && needsContext(property.value)));
         const inferring = this.inferring;
         this.inferring = new Set(signature.typeParams);
         const errors = this.diagnostics.length;
@@ -200,8 +203,11 @@ export class CallChecker extends MemberChecker {
                     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);
+                // `[1, 2]` for `[]T` is checked on its own, and T is inferred from it. An object literal
+                // checked last takes what is still open as its default, or unknown, as in TypeScript.
+                const expected = contextPass && arg.kind === 'ObjectLiteral'
+                    ? substitute(param, withDefaults(signature.typeParams, inferred))
+                    : substitute(param, inferred);
                 const type = this.checkValue(arg, arg.kind === 'ArrowFunction' || !containsTypeParam(expected, this.inferring)
                     ? expected
                     : null);
@@ -211,3 +217,12 @@ export class CallChecker extends MemberChecker {
         }
     }
 }
+/** The inferred type parameters, and the default, or unknown, of each of the others. */
+export function withDefaults(params, inferred) {
+    const bindings = new Map(inferred);
+    for (const param of params) {
+        if (!bindings.has(param))
+            bindings.set(param, param.default ?? UNKNOWN);
+    }
+    return bindings;
+}

package/dist/checker/classes.js

@@ -253,6 +253,14 @@ export class ClassChecker extends ClassMemberChecker {
                     break;
             }
         }
+        // `export { Rows } from "./rows.rk"`: the names of another module, as it exports them.
+        for (const kind of ['values', 'types', 'decorators', 'components']) {
+            for (const [name, value] of this.reexported[kind] ?? []) {
+                exports[kind].set(name, value);
+            }
+        }
+        for (const name of this.reexported.shared ?? [])
+            exports.shared.add(name);
         return { exports, declarations };
     }
 }

package/dist/checker/component-bindings.d.ts

@@ -4,4 +4,20 @@ import { ForwardingChecker } from './forwarding.ts';
 export declare abstract class ComponentBindingChecker extends ForwardingChecker {
     /** `bind:active={tab}` on a component; adds the name of the property to `given`. */
     protected checkPropBinding(attribute: ast.JsxAttribute, info: ComponentInfo, component: string, given: Set<string>): void;
+    /**
+     * The variable that `bind:` writes into. The item of `for row in rows` is one too: the component
+     * changes it in place, and a new value replaces it in `rows`, which must be a variable or a field.
+     */
+    private bindTarget;
+    /**
+     * `row.name = "x"` or `bind:value={row.name}` where `row` is a property that is not bound: the
+     * object is the parent's, which would change without its markup knowing.
+     */
+    protected checkPropWrite(target: ast.Expression): void;
+    /**
+     * `items.push(x)` or `seen.add(id)` where the property is not bound. Other methods are not
+     * reported: a method of a class or a function in a field may change nothing.
+     */
+    protected checkPropMutation(node: ast.CallExpression): void;
+    private propChanged;
 }

package/dist/checker/component-bindings.js

@@ -1,7 +1,8 @@
 import { attrsParam } from "../attrs.js";
+import { ARRAY_MUTATORS } from "../methods.js";
 import { ForwardingChecker } from "./forwarding.js";
 import { isUntyped } from "./helpers.js";
-import { isAssignable, typeToString } from "./types.js";
+import { isAssignable, nonNull, typeToString, UNKNOWN } from "./types.js";
 // Bound properties: `comp Tabs(bind active string)` may change `active`, and
 // `<Tabs bind:active={tab} />` writes those changes into the parent's `tab`, as `bind:value` of an
 // input does. The value goes both ways, so the variable and the property have the same type.
@@ -33,7 +34,7 @@ export class ComponentBindingChecker extends ForwardingChecker {
             this.error(`"bind:${name}" needs a variable or a field to write to`, value);
             return;
         }
-        const type = this.checkTarget(value);
+        const type = this.bindTarget(value, name);
         this.checkedTypes.set(value, type);
         if (!prop?.bind || isUntyped(type) || isUntyped(prop.type))
             return;
@@ -42,4 +43,66 @@ export class ComponentBindingChecker extends ForwardingChecker {
             this.error(`cannot bind ${typeToString(type)} to "${name}" of <${component}>, which is ${typeToString(prop.type)}`, value);
         }
     }
+    /**
+     * The variable that `bind:` writes into. The item of `for row in rows` is one too: the component
+     * changes it in place, and a new value replaces it in `rows`, which must be a variable or a field.
+     */
+    bindTarget(value, name) {
+        const binding = value.kind === 'Identifier' ? this.lookupValue(value.name) : undefined;
+        if (binding?.kind !== 'loop' || value.kind !== 'Identifier')
+            return this.checkTarget(value);
+        const list = binding.iterable;
+        if (list?.kind !== 'Identifier' && list?.kind !== 'MemberExpression') {
+            this.error(`"bind:${name}" of "${value.name}" needs a loop over a list in a variable or a field, e.g. for ${value.name} in items`, value);
+            return this.checkValue(value);
+        }
+        // Written as `rows[i] = value`, so `rows` must be one that can be changed here.
+        const at = { start: value.start, end: value.end };
+        this.checkTarget({
+            kind: 'IndexExpression',
+            object: list,
+            index: { kind: 'NumberLiteral', value: 0, raw: '0', ...at },
+            optional: false,
+            start: value.start,
+            end: value.end,
+        });
+        return this.checkValue(value);
+    }
+    /**
+     * `row.name = "x"` or `bind:value={row.name}` where `row` is a property that is not bound: the
+     * object is the parent's, which would change without its markup knowing.
+     */
+    checkPropWrite(target) {
+        if (target.kind === 'MemberExpression' || target.kind === 'IndexExpression') {
+            this.propChanged(target.object, target);
+        }
+    }
+    /**
+     * `items.push(x)` or `seen.add(id)` where the property is not bound. Other methods are not
+     * reported: a method of a class or a function in a field may change nothing.
+     */
+    checkPropMutation(node) {
+        const { callee } = node;
+        if (callee.kind !== 'MemberExpression')
+            return;
+        const object = nonNull(this.typeOfChecked(callee.object) ?? UNKNOWN);
+        const name = callee.property.name;
+        const collection = object.kind === 'object' ? (object.instanceOf?.template.name ?? object.name) : null;
+        const changes = object.kind === 'array'
+            ? ARRAY_MUTATORS.has(name)
+            : (collection === 'Map' || collection === 'Set') && COLLECTION_MUTATORS.has(name);
+        if (changes)
+            this.propChanged(callee.object, node);
+    }
+    propChanged(object, node) {
+        let root = object;
+        while (root.kind === 'MemberExpression' || root.kind === 'IndexExpression')
+            root = root.object;
+        if (root.kind !== 'Identifier' || !this.component || this.decorator)
+            return;
+        if (this.lookupValue(root.name)?.kind !== 'prop')
+            return;
+        this.error(`"${root.name}" is a property: changing it in place would not update the parent; declare it bound, e.g. comp ${this.component.node.name.name}(bind ${root.name} ...), and pass bind:${root.name}={...}`, node);
+    }
 }
+const COLLECTION_MUTATORS = new Set(['set', 'add', 'delete', 'clear']);

package/dist/checker/context.d.ts

@@ -110,6 +110,13 @@ export interface Binding {
      */
     guards?: Binding[];
     guardedBy?: Binding;
+    /**
+     * A constant of the module with a written type or a literal value: its type, known before its
+     * declaration is checked. The fields of classes, which are resolved first, may use it.
+     */
+    early?: Type;
+    /** The list that `for item in items` goes over, which `bind:item={item}` writes into. */
+    iterable?: ast.Expression;
 }
 export interface ComponentInfo {
     node: ast.ComponentDeclaration;
@@ -212,6 +219,11 @@ export interface FunctionContext {
     isComponent?: boolean;
     /** An async function, which may wait: `await`, `<-ch`, `for v in ch`. */
     isAsync?: boolean;
+    /**
+     * The function may end without a value, as in TypeScript: its result is `any`, or it is a
+     * callback whose result in a `.d.ts` is `void | T`, `onopen = () => { ... }`.
+     */
+    mayEnd?: boolean;
 }
 export interface ClassContext {
     info: ClassInfo;

package/dist/checker/declarations.d.ts

@@ -21,6 +21,8 @@ export declare abstract class DeclarationChecker extends SharedStateChecker {
     /** The type of a function; an async one returns a Promise of its results, and one whose
      * parameter is `yield` is an iterator (iterators.ts). */
     protected signature(params: readonly ast.Parameter[], results: readonly ast.TypeNode[], async?: boolean): FunctionType;
+    /** `...parts []any`: what each of the arguments it takes is, `any`. */
+    private restElement;
     /** `Promise<...>` of the results of an async function, with the global `Promise` type. */
     protected promiseOf(results: readonly Type[]): Type;
 }

package/dist/checker/declarations.js

@@ -5,7 +5,7 @@ import { recursiveComponents } from "../recursion.js";
 import { Scope } from "./context.js";
 import { SharedStateChecker } from "./shared-state.js";
 import { awaited, isPromise, promiseOf } from "./promise.js";
-import { createClass, func, typeToString, UNKNOWN, } from "./types.js";
+import { ANY, createClass, func, typeToString, UNKNOWN, } from "./types.js";
 // Declarations of a list of statements: imports, types, functions, components, decorators and
 // classes, declared before the statements are checked, so that they can refer to each other.
 export class DeclarationChecker extends SharedStateChecker {
@@ -32,6 +32,9 @@ export class DeclarationChecker extends SharedStateChecker {
                 case 'ImportDeclaration':
                     this.declareImport(statement);
                     break;
+                case 'ExportFromDeclaration':
+                    this.declareExportFrom(statement);
+                    break;
                 case 'ClassDeclaration': {
                     const info = createClass(statement.name.name);
                     info.data = statement.data;
@@ -130,6 +133,12 @@ export class DeclarationChecker extends SharedStateChecker {
             if (entry?.kind === 'alias')
                 this.resolveAlias(entry);
         }
+        if (topLevel) {
+            for (const statement of statements) {
+                if (statement.kind === 'VariableDeclaration')
+                    this.typeEarly(statement);
+            }
+        }
         for (const [node, binding] of functions) {
             const typeParams = this.createTypeParams(node.typeParams);
             binding.type = this.withTypeParams(typeParams, node.typeParams, () => ({
@@ -242,7 +251,7 @@ export class DeclarationChecker extends SharedStateChecker {
     /** The type of a function; an async one returns a Promise of its results, and one whose
      * parameter is `yield` is an iterator (iterators.ts). */
     signature(params, results, async = false) {
-        const types = results.map((result) => this.resolveType(result));
+        const types = this.resolveResults(results);
         if (async) {
             types.forEach((type, i) => {
                 if (!isPromise(type))
@@ -251,7 +260,33 @@ export class DeclarationChecker extends SharedStateChecker {
                 types[i] = awaited(type);
             });
         }
-        return func(params.map((param) => (param.type ? this.resolveType(param.type) : UNKNOWN)), async ? [this.promiseOf(types)] : types, { iterator: isIterator(params) });
+        const last = params.at(-1);
+        const rest = last?.rest ? this.restElement(last) : undefined;
+        const plain = rest === undefined ? params : params.slice(0, -1);
+        const firstDefault = plain.findIndex((param) => param.defaultValue !== null);
+        const required = firstDefault === -1 ? plain.length : firstDefault;
+        for (const param of plain.slice(required)) {
+            if (param.defaultValue === null) {
+                this.error(`"${param.name.name}" comes after a parameter with a default value, so it needs one too, e.g. ${param.name.name} = ...`, param);
+            }
+        }
+        return func(
+        // `times = 1` has the type of its value.
+        plain.map((param) => param.type
+            ? this.resolveType(param.type)
+            : param.defaultValue
+                ? this.inferredType(this.checkValue(param.defaultValue), param.defaultValue)
+                : UNKNOWN), async ? [this.promiseOf(types)] : types, { iterator: isIterator(params), required, ...(rest ? { rest } : {}) });
+    }
+    /** `...parts []any`: what each of the arguments it takes is, `any`. */
+    restElement(param) {
+        const type = param.type ? this.resolveType(param.type) : ANY;
+        if (type.kind === 'array')
+            return type.element;
+        if (type.kind !== 'any' && type.kind !== 'unknown') {
+            this.error(`...${param.name.name} takes the arguments in an array: write its type as one, e.g. ...${param.name.name} []${typeToString(type)}`, param.type ?? param);
+        }
+        return ANY;
     }
     /** `Promise<...>` of the results of an async function, with the global `Promise` type. */
     promiseOf(results) {

package/dist/checker/expressions.d.ts

@@ -16,6 +16,7 @@ export declare abstract class ExpressionChecker extends FunctionChecker {
     /** `[1, 2]`; implemented by ArrayLiteralChecker. */
     protected abstract checkArrayLiteral(node: ast.ArrayLiteral, expected: Type | null): Type;
     protected abstract checkTryExpression(node: ast.TryExpression): Type;
+    protected abstract checkTaggedTemplate(node: ast.TaggedTemplateExpression): Type;
     /** `[]byte("text")`; implemented by BytesChecker. */
     protected abstract checkConversion(node: ast.ConversionExpression): Type;
     protected abstract checkMake(node: ast.MakeExpression): Type;

package/dist/checker/expressions.js

@@ -89,6 +89,11 @@ export class ExpressionChecker extends FunctionChecker {
                 return this.checkNew(node, expected);
             case 'ElementExpression':
                 return this.checkElement(node);
+            // `user!`: taken not to be null, as in TypeScript.
+            case 'NonNullExpression':
+                return nonNull(this.checkExpression(node.expression, expected));
+            case 'TaggedTemplateExpression':
+                return this.checkTaggedTemplate(node);
             case 'DecoratorMember':
                 return this.checkDecoratorMember(node);
             case 'MemberExpression':
@@ -125,6 +130,9 @@ export class ExpressionChecker extends FunctionChecker {
             this.error(initializerError, node);
             return UNKNOWN;
         }
+        // The field of a class is set when an instance is made, after the constants of the module.
+        if (binding.type === null && binding.early && this.cls)
+            return binding.early;
         if (binding.type === null) {
             this.error(`"${node.name}" is used before its declaration`, node);
             return UNKNOWN;
@@ -154,11 +162,15 @@ export class ExpressionChecker extends FunctionChecker {
     }
     checkObjectLiteral(node, expected) {
         let target = expected ? nonNull(expected) : null;
+        // The objects of a union that no tag chooses from: fields take what they share from them.
+        let union = null;
         // `?(ScrollIntoViewOptions | bool)`: an object literal can only be the object type in it, or
         // the one that its tag chooses, `{ kind: "pickup" }` of `Pickup | Courier`.
         if (target?.kind === 'union') {
             const objects = target.types.filter((type) => type.kind === 'object' || type.kind === 'class');
             target = objects.length === 1 ? objects[0] : this.taggedMember(node, objects, target);
+            if (target === null)
+                union = objects;
         }
         const index = target?.kind === 'object' ? target.index : undefined;
         const targetMembers = target?.kind === 'object'
@@ -202,7 +214,11 @@ export class ExpressionChecker extends FunctionChecker {
             if (targetMembers && !expectedMember && target) {
                 this.error(`${typeToString(target)} has no field "${name}"`, property.key);
             }
-            let type = this.checkValue(property.value, expectedMember?.type ?? null);
+            const context = expectedMember?.type ?? (union && this.commonField(union, name));
+            // In JS `this` of a method is the object, not the class around it: it is not used.
+            let type = property.method
+                ? this.withClass(null, () => this.checkValue(property.value, context))
+                : this.checkValue(property.value, context);
             if (expectedMember) {
                 // Reported at the field; the literal then counts as having the expected field type.
                 this.expectAssignable(type, expectedMember.type, property.value, ` for field "${name}"`);

package/dist/checker/flow.d.ts

@@ -34,7 +34,7 @@ export declare function withoutAssigned(flow: Flow, names: ReadonlySet<string>,
 export declare function withNarrowing(flow: Flow, narrowing: Narrowing): Flow;
 /** Narrowing that holds after both branches: the places narrowed the same way in both. */
 export declare function mergeFlows(a: Flow, b: Flow): Flow;
-/** Go's terminating statements: execution never continues after them. */
+export declare function markNeverEnding(node: ast.Statement): void;
 export declare function isTerminating(node: ast.Statement): boolean;
 /** Whether execution never continues after the statement, counting `break` and `continue`. */
 export declare function leaves(node: ast.Statement): boolean;

package/dist/checker/flow.js

@@ -124,11 +124,21 @@ export function mergeFlows(a, b) {
     return result;
 }
 /** Go's terminating statements: execution never continues after them. */
+/**
+ * Statements that call a function whose result is `never`, `process.exit(1)`: the checker marks
+ * them, and they end a block as `throw` does.
+ */
+const neverEnding = new WeakSet();
+export function markNeverEnding(node) {
+    neverEnding.add(node);
+}
 export function isTerminating(node) {
     switch (node.kind) {
         case 'ReturnStatement':
         case 'ThrowStatement':
             return true;
+        case 'ExpressionStatement':
+            return neverEnding.has(node);
         case 'BlockStatement': {
             const last = node.body.at(-1);
             return last !== undefined && isTerminating(last);

package/dist/checker/functions.d.ts

@@ -13,6 +13,8 @@ export declare abstract class FunctionChecker extends TaggedUnionChecker {
         closure?: boolean;
         paramKind?: BindingKind;
         async?: boolean;
+        /** A callback whose result in a `.d.ts` is `void | T`: it may end without a value. */
+        mayEnd?: boolean;
         inspect?: (scope: Scope) => void;
     }): Type[];
     /** The body of `x => x * 2`. */

package/dist/checker/functions.js

@@ -3,7 +3,7 @@ import { isTerminating } from "./flow.js";
 import { isUntyped, callSignature } from "./helpers.js";
 import { awaitedResults, isPromise } from "./promise.js";
 import { TaggedUnionChecker } from "./tagged-unions.js";
-import { commonType, containsTypeParam, func, nonNull, UNKNOWN, } from "./types.js";
+import { ANY, arrayOf, commonType, containsTypeParam, func, isNullable, nonNull, UNKNOWN, } from "./types.js";
 // Bodies of functions, arrow functions and func literals, and the results they return.
 export class FunctionChecker extends TaggedUnionChecker {
     /**
@@ -25,18 +25,28 @@ export class FunctionChecker extends TaggedUnionChecker {
             isConstructor: options.isConstructor ?? false,
             isComponent: options.isComponent ?? false,
             isAsync: async,
+            mayEnd: options.mayEnd === true || (declared?.length === 1 && declared[0].kind === 'any'),
         };
         try {
             // A generic function: its type parameters are types in its body.
             for (const typeParam of type.typeParams)
                 this.scope.types.set(typeParam.name, typeParam);
-            params.forEach((param, i) => 
-            // A bound property of a component, `bind active string`, changes as its state does.
-            this.declareValue(param.name, param.bind ? 'state' : (options.paramKind ?? 'param'), type.params[i] ?? UNKNOWN));
+            params.forEach((param, i) => {
+                // `...parts []any` is the array of the arguments; `times = 1` sees the parameters before it.
+                const paramType = param.rest && type.rest ? arrayOf(type.rest) : (type.params[i] ?? UNKNOWN);
+                if (param.defaultValue && !options.isComponent) {
+                    this.expectAssignable(this.checkValue(param.defaultValue, paramType), paramType, param.defaultValue);
+                }
+                // A bound property of a component, `bind active string`, changes as its state does.
+                this.declareValue(param.name, param.bind ? 'state' : (options.paramKind ?? 'param'), paramType);
+            });
             if (body.kind === 'BlockStatement') {
                 this.checkStatementList(body.body, false);
                 options.inspect?.(this.scope);
-                if (declared && declared.length > 0 && !isTerminating(body)) {
+                if (declared?.length === 1 && declared[0].kind === 'never' && !isTerminating(body)) {
+                    this.error('a function whose result is never must not reach its end: throw, or call one that never returns, e.g. process.exit(1)', { start: body.end - 1, end: body.end });
+                }
+                else if (declared && declared.length > 0 && !this.fn.mayEnd && !isTerminating(body)) {
                     this.error('missing return at the end of the function', {
                         start: body.end - 1,
                         end: body.end,
@@ -101,7 +111,9 @@ export class FunctionChecker extends TaggedUnionChecker {
         const context = expected ? callSignature(nonNull(expected)) : null;
         // Callbacks passed to untyped JS functions get untyped parameters.
         const untypedContext = expected !== null && isUntyped(nonNull(expected));
-        const params = node.params.map((param, i) => {
+        const last = node.params.at(-1);
+        const plain = last?.rest ? node.params.slice(0, -1) : node.params;
+        const params = plain.map((param, i) => {
             if (param.type)
                 return this.resolveType(param.type);
             const fromContext = context ? (context.params[i] ?? context.rest) : null;
@@ -109,9 +121,19 @@ export class FunctionChecker extends TaggedUnionChecker {
                 return fromContext;
             if (untypedContext)
                 return nonNull(expected);
+            if (param.defaultValue)
+                return this.inferredType(this.checkValue(param.defaultValue), param.defaultValue);
             this.error(`cannot infer the type of parameter "${param.name.name}": add a type`, param);
             return UNKNOWN;
         });
+        // `(...parts) => ...` takes the rest of the context, or anything.
+        const restType = last?.rest
+            ? last.type
+                ? this.resolveType(last.type)
+                : arrayOf(context?.rest ?? ANY)
+            : null;
+        const rest = restType?.kind === 'array' ? restType.element : restType ? ANY : null;
+        const firstDefault = plain.findIndex((param) => param.defaultValue !== null);
         // Known result types from the context are checked; otherwise they are inferred. Those of an
         // async function must be a Promise.
         const contextResults = context &&
@@ -120,7 +142,10 @@ export class FunctionChecker extends TaggedUnionChecker {
             (!node.async || (context.results.length === 1 && isPromise(context.results[0])))
             ? context.results
             : null;
-        const type = func(params, []);
+        const type = func(params, [], {
+            required: firstDefault === -1 ? params.length : firstDefault,
+            ...(rest ? { rest } : {}),
+        });
         const checkBody = () => {
             const inferring = this.inferring;
             this.inferring = new Set();
@@ -128,6 +153,7 @@ export class FunctionChecker extends TaggedUnionChecker {
                 return this.checkFunction(node.params, type, contextResults, node.body, {
                     closure: true,
                     async: node.async,
+                    mayEnd: contextResults?.length === 1 && isNullable(contextResults[0]),
                 });
             }
             finally {

package/dist/checker/goroutines.d.ts

@@ -1,7 +1,7 @@
 import type * as ast from '../ast.ts';
-import { CallChecker } from './calls.ts';
+import { TagChecker } from './tags.ts';
 import { type Type } from './types.ts';
-export declare abstract class GoroutineChecker extends CallChecker {
+export declare abstract class GoroutineChecker extends TagChecker {
     /** The functions already checked for what their code reaches, so each is reported once. */
     private readonly reached;
     protected checkGo(node: ast.GoExpression): Type;

package/dist/checker/goroutines.js

@@ -1,7 +1,7 @@
 import { reach, recordCaptures } from "../goroutines.js";
 import { assignedNames, freeNames } from "../names.js";
 import { forEachChild } from "../walk.js";
-import { CallChecker } from "./calls.js";
+import { TagChecker } from "./tags.js";
 import { awaited } from "./promise.js";
 import { notCopied } from "./transfer.js";
 import { UNKNOWN } from "./types.js";
@@ -10,7 +10,7 @@ import { UNKNOWN } from "./types.js";
 // arguments and gives back a copy of the result, so both must be data that can be copied; and the
 // code of the function must not need what a worker does not have: the variables of the module and
 // a document.
-export class GoroutineChecker extends CallChecker {
+export class GoroutineChecker extends TagChecker {
     /** The functions already checked for what their code reaches, so each is reported once. */
     reached = new Set();
     checkGo(node) {

package/dist/checker/imports.d.ts

@@ -1,6 +1,16 @@
 import type * as ast from '../ast.ts';
 import { CheckerBase } from './base.ts';
+import type { ModuleExports } from './context.ts';
 export declare abstract class ImportChecker extends CheckerBase {
+    /** `export { Rows } from "./rows.rk"`: what this module exports of another, by name here. */
+    protected readonly reexported: ModuleExports;
+    /** The exports of the module that an import or an `export ... from` names. */
+    private exportsOf;
+    /**
+     * `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.
+     */
+    protected declareExportFrom(node: ast.ExportFromDeclaration): void;
     protected declareImport(node: ast.ImportDeclaration): void;
     /** `import { visible } from "./visible.rk"`: decorators have a namespace of their own. */
     private importDecorator;