rooklang 0.3.3 → 0.4.0

package/dist/checker/class-members.js

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

package/dist/checker/classes.d.ts

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

package/dist/checker/classes.js

@@ -1,9 +1,10 @@
 import { inlinePackages } from "../inline-packages.js";
-import { DeclarationChecker } from "./declarations.js";
+import { ClassMemberChecker } from "./class-members.js";
 import { isSuperCall, assignsField } from "./helpers.js";
+import { notCopied } from "./transfer.js";
 import { explainMismatch, findClassMember, hasZeroValue, isAssignable, isSubclass, typeToString, UNKNOWN, } from "./types.js";
 // Classes: their base class and members, method bodies, overrides and `implements`; and the declarations a module exports.
-export class ClassChecker extends DeclarationChecker {
+export class ClassChecker extends ClassMemberChecker {
     ensureClassResolved(info) {
         const resolve = this.unresolvedClasses.get(info);
         if (!resolve || this.resolvingClasses.has(info))
@@ -49,6 +50,9 @@ export class ClassChecker extends DeclarationChecker {
                 this.error(`cannot extend ${typeToString(base)}: it is not a class`, node.superClass);
             }
         }
+        if (node.data)
+            this.checkDataBase(node, info);
+        info.abstract = node.abstract === true;
         for (const member of node.members) {
             switch (member.kind) {
                 case 'FieldDeclaration': {
@@ -62,20 +66,31 @@ export class ClassChecker extends DeclarationChecker {
                         else
                             type = this.inferredType(valueType, value);
                     }
+                    // The fields of a data class are what goes to another thread.
+                    const reason = node.data && !member.isStatic ? notCopied(type) : null;
+                    if (reason !== null) {
+                        this.error(`the fields of a data class go to other threads as copies: ${reason}`, member.type ?? member.name);
+                    }
                     this.declareMember(info, member.isStatic, member.name, {
                         type,
                         method: false,
                         visibility: member.visibility,
                         owner: info,
+                        ...(member.readonly ? { readonly: true } : {}),
                     });
                     break;
                 }
                 case 'MethodDeclaration':
+                    if (member.accessor) {
+                        this.declareAccessor(info, member, member.accessor);
+                        break;
+                    }
                     this.declareMember(info, member.isStatic, member.name, {
                         type: this.signature(member.params, member.results, member.async),
                         method: true,
                         visibility: member.visibility,
                         owner: info,
+                        ...(member.abstract ? { abstract: true } : {}),
                     });
                     break;
                 case 'ConstructorDeclaration':
@@ -83,15 +98,20 @@ export class ClassChecker extends DeclarationChecker {
                         this.error('a class can have only one constructor', member);
                     info.ctor = this.signature(member.params, []);
                     info.ctorVisibility = member.visibility;
+                    this.declareParamProperties(member, info, info.ctor);
                     break;
             }
         }
     }
-    declareMember(info, isStatic, name, member) {
-        const members = isStatic ? info.statics : info.members;
-        if (members.has(name.name))
-            this.error(`duplicate member "${name.name}"`, name);
-        members.set(name.name, member);
+    /** A data class extends only a data class: its fields go with it, and its class is restored. */
+    checkDataBase(node, info) {
+        const base = info.superClass;
+        if (info.untypedBase) {
+            this.error('a data class cannot extend a class of JS: its copy in another thread could not get the class back', node.superClass);
+        }
+        else if (base && base.data !== true) {
+            this.error(`a data class extends only a data class: mark ${base.name} as one, e.g. data class ${base.name}`, node.superClass);
+        }
     }
     /** Method bodies and the checks that need every member of the class. */
     checkClassBodies(node, info) {
@@ -101,13 +121,18 @@ export class ClassChecker extends DeclarationChecker {
         let constructorNode = null;
         for (const member of node.members) {
             if (member.kind === 'MethodDeclaration') {
-                const type = (member.isStatic ? info.statics : info.members).get(member.name.name)?.type;
+                const { body } = member;
+                const type = member.accessor
+                    ? this.accessorSignatures.get(member)
+                    : (member.isStatic ? info.statics : info.members).get(member.name.name)?.type;
                 if (type?.kind !== 'function')
                     continue;
-                this.withClass({ info, isStatic: member.isStatic }, () => this.checkFunction(member.params, type, type.results, member.body, {
-                    async: member.async,
-                }));
+                if (body) {
+                    this.withClass({ info, isStatic: member.isStatic }, () => this.checkFunction(member.params, type, type.results, body, { async: member.async }));
+                }
                 this.checkOverride(info, member);
+                if (member.accessor)
+                    this.checkAccessorOverride(info, member.name, member.isStatic);
             }
             else if (member.kind === 'ConstructorDeclaration' && info.ctor) {
                 constructorNode = member;
@@ -119,9 +144,13 @@ export class ClassChecker extends DeclarationChecker {
                 }
             }
         }
+        this.checkAbstract(node, info);
         // Fields without a zero value must get one at once or in the constructor.
         for (const member of node.members) {
-            if (member.kind !== 'FieldDeclaration' || member.isStatic || member.value)
+            if (member.kind !== 'FieldDeclaration')
+                continue;
+            this.checkAccessorOverride(info, member.name, member.isStatic);
+            if (member.isStatic || member.value)
                 continue;
             const type = info.members.get(member.name.name)?.type;
             if (!type || hasZeroValue(type))
@@ -166,6 +195,7 @@ export class ClassChecker extends DeclarationChecker {
             types: new Map(),
             decorators: new Map(),
             components: new Map(),
+            shared: new Set(),
         };
         const declarations = { values: new Map(), types: new Map() };
         const valueOf = (name) => this.moduleScope.values.get(name)?.type ?? UNKNOWN;
@@ -188,6 +218,8 @@ export class ClassChecker extends DeclarationChecker {
                 case 'VariableDeclaration':
                     for (const name of statement.names) {
                         add(statement.exported, 'values', name.name, valueOf(name.name));
+                        if (statement.exported && statement.keyword === 'state')
+                            exports.shared.add(name.name);
                     }
                     break;
                 case 'ClassDeclaration':
@@ -201,7 +233,10 @@ export class ClassChecker extends DeclarationChecker {
                 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;
+                        const found = this.modulePackages().components.get(info.node.name.name) ?? null;
+                        // Code that reads state another module shares listens to it here, so it stays here.
+                        const shared = found?.moduleNames.some((name) => this.moduleScope.values.get(name)?.shared !== undefined);
+                        info.inline = shared ? null : found;
                         info.expressionTypes = this.checkedTypes;
                         exports.components.set(statement.name.name, info);
                     }

package/dist/checker/closing.d.ts

@@ -0,0 +1,21 @@
+import type * as ast from '../ast.ts';
+import type { Binding, BindingKind } from './context.ts';
+import { IteratorChecker } from './iterators.ts';
+import type { Type } from './types.ts';
+export declare abstract class ClosingChecker extends IteratorChecker {
+    /** The identifier that declares a binding of this module. */
+    private readonly declarations;
+    /** What each name refers to: its declaration, or the name of a predeclared value. */
+    private readonly references;
+    protected declareValue(id: ast.Identifier, kind: BindingKind, type: Type | null): Binding;
+    protected checkIdentifier(node: ast.Identifier): Type;
+    /** The functions declared in the module, by their names, which `use` looks arguments up in. */
+    private functions;
+    protected checkClosing(): void;
+    /** `chan<T>()`, `topic<T>()`, `tick(ms)`, `signal(name)` and their `Channel.make` and the like. */
+    private made;
+    /** `Channel.close` and the like, as a name, when `Channel` is the predeclared one. */
+    private predeclaredMember;
+    /** What the code around a name of a channel does with it. */
+    private use;
+}

package/dist/checker/closing.js

@@ -0,0 +1,164 @@
+import { forEachChild } from "../walk.js";
+import { IteratorChecker } from "./iterators.js";
+/** What `Channel.x(ch)` and `Topic.x(t)` do with a channel without keeping it. */
+const OPERATIONS = new Set(['send', 'receive', 'range', 'stream', 'publish', 'listen', 'try']);
+const MESSAGES = {
+    chan: (name) => `"${name}" is never closed: close it when nothing more is sent, e.g. close(${name})`,
+    topic: (name) => `"${name}" is never closed, and a topic listens until it is closed: close it when it is no longer needed, e.g. close(${name}); a component closes it with defer close(${name}) in mount`,
+    tick: (name) => `"${name}" is never closed, and a tick runs until it is closed: e.g. close(${name})`,
+    signal: (name) => `"${name}" is never closed, and it keeps the program running until it is: close it once the signal has come, e.g. close(${name})`,
+};
+export class ClosingChecker extends IteratorChecker {
+    /** The identifier that declares a binding of this module. */
+    declarations = new WeakMap();
+    /** What each name refers to: its declaration, or the name of a predeclared value. */
+    references = new Map();
+    declareValue(id, kind, type) {
+        const binding = super.declareValue(id, kind, type);
+        this.declarations.set(binding, id);
+        return binding;
+    }
+    checkIdentifier(node) {
+        const binding = this.lookupValue(node.name);
+        const declaration = binding && this.declarations.get(binding);
+        if (declaration)
+            this.references.set(node, declaration);
+        else if (binding && binding === this.globals.values.get(node.name)) {
+            this.references.set(node, node.name);
+        }
+        return super.checkIdentifier(node);
+    }
+    /** The functions declared in the module, by their names, which `use` looks arguments up in. */
+    functions = new Map();
+    checkClosing() {
+        const made = [];
+        const uses = new Map();
+        const collect = (node) => {
+            if (node.kind === 'FuncDeclaration')
+                this.functions.set(node.name, node);
+            forEachChild(node, collect);
+        };
+        const visit = (node, parent) => {
+            const what = node.kind === 'VariableDeclaration' && !node.exported && node.names.length === 1
+                ? node.values[0] && this.made(node.values[0])
+                : null;
+            if (node.kind === 'VariableDeclaration' && what)
+                made.push([node.names[0], what]);
+            const declaration = node.kind === 'Identifier' ? this.references.get(node) : undefined;
+            if (node.kind === 'Identifier' && typeof declaration === 'object' && parent) {
+                if (!uses.has(declaration)) {
+                    uses.set(declaration, { closed: false, escapes: false, passed: [] });
+                }
+                this.use(node, parent, uses.get(declaration));
+            }
+            forEachChild(node, (child) => visit(child, node));
+        };
+        collect(this.program);
+        visit(this.program, null);
+        // Whether a variable or a parameter is closed, goes where it is not seen, or neither.
+        const fate = (id, seen) => {
+            const found = uses.get(id);
+            if (!found || seen.has(id))
+                return 'none';
+            if (found.closed)
+                return 'closed';
+            seen.add(id);
+            let result = found.escapes ? 'escapes' : 'none';
+            for (const [fn, i] of found.passed) {
+                const param = fn.params[i];
+                const inner = param && !param.rest ? fate(param.name, seen) : 'escapes';
+                if (inner === 'closed')
+                    return 'closed';
+                if (inner === 'escapes')
+                    result = 'escapes';
+            }
+            return result;
+        };
+        for (const [name, what] of made) {
+            if (fate(name, new Set()) === 'none')
+                this.warn(MESSAGES[what](name.name), name);
+        }
+    }
+    /** `chan<T>()`, `topic<T>()`, `tick(ms)`, `signal(name)` and their `Channel.make` and the like. */
+    made(value) {
+        if (value.kind === 'ChanExpression')
+            return 'chan';
+        if (value.kind === 'TopicExpression')
+            return 'topic';
+        if (value.kind !== 'CallExpression')
+            return null;
+        const { callee } = value;
+        if (callee.kind === 'Identifier') {
+            const predeclared = this.references.get(callee);
+            return predeclared === 'tick' || predeclared === 'signal' ? predeclared : null;
+        }
+        const member = this.predeclaredMember(callee);
+        if (member === 'Channel.make')
+            return 'chan';
+        if (member === 'Channel.tick')
+            return 'tick';
+        if (member === 'Channel.signal')
+            return 'signal';
+        return member === 'Topic.make' ? 'topic' : null;
+    }
+    /** `Channel.close` and the like, as a name, when `Channel` is the predeclared one. */
+    predeclaredMember(node) {
+        if (node.kind !== 'MemberExpression' || node.object.kind !== 'Identifier')
+            return null;
+        const object = this.references.get(node.object);
+        return (object === 'Channel' || object === 'Topic') && node.property.kind === 'Identifier'
+            ? `${object}.${node.property.name}`
+            : null;
+    }
+    /** What the code around a name of a channel does with it. */
+    use(node, parent, found) {
+        switch (parent.kind) {
+            case 'CallExpression': {
+                const i = parent.arguments.indexOf(node);
+                if (i < 0)
+                    return;
+                const { callee } = parent;
+                const ref = callee.kind === 'Identifier' ? this.references.get(callee) : undefined;
+                const member = this.predeclaredMember(callee)?.split('.')[1];
+                if (ref === 'close' || member === 'close')
+                    found.closed = true;
+                else if (ref === 'stream' || (member !== undefined && OPERATIONS.has(member)))
+                    return;
+                else {
+                    const fn = callee.kind === 'FuncExpression'
+                        ? callee
+                        : typeof ref === 'object'
+                            ? this.functions.get(ref)
+                            : undefined;
+                    if (fn)
+                        found.passed.push([fn, i]);
+                    else
+                        found.escapes = true;
+                }
+                return;
+            }
+            // Sending to it, receiving from it, a loop over it, comparing and assigning it keep it here;
+            // sending it through a channel does not.
+            case 'SendStatement':
+                if (parent.value === node)
+                    found.escapes = true;
+                return;
+            case 'UnaryExpression':
+                if (parent.operator !== '<-')
+                    found.escapes = true;
+                return;
+            case 'ForInStatement':
+                return;
+            case 'BinaryExpression':
+                if (!['==', '!=', '===', '!=='].includes(parent.operator))
+                    found.escapes = true;
+                return;
+            case 'AssignmentStatement':
+                if (!parent.targets.includes(node))
+                    found.escapes = true;
+                return;
+            default:
+                found.escapes = true;
+        }
+    }
+}

package/dist/checker/completion.d.ts

@@ -1,8 +1,8 @@
 import type * as ast from '../ast.ts';
-import { IteratorChecker } from './iterators.ts';
-import type { CompletionResult } from './context.ts';
+import { ClosingChecker } from './closing.ts';
+import { type CompletionResult } from './context.ts';
 import { type Type } from './types.ts';
-export declare abstract class CompletionChecker extends IteratorChecker {
+export declare abstract class CompletionChecker extends ClosingChecker {
     protected completion: CompletionResult | null;
     private atCursor;
     /** The first check of the cursor counts: a component's body, for one, is checked for each use. */

package/dist/checker/completion.js

@@ -1,5 +1,6 @@
-import { IteratorChecker } from "./iterators.js";
+import { ClosingChecker } from "./closing.js";
 import { ARRAY_MEMBERS, ATTRIBUTE_NAMES, BIGINT_MEMBERS, BOOL_MEMBERS, EVENT_ATTRIBUTES, HTML_TAGS, NUMBER_MEMBERS, STRING_MEMBERS, } from "./completion-names.js";
+import { placeOf, } from "./context.js";
 import { isSubclass, literalBase, memberNames, memberTypeOf, nonNull, typeToString, union, UNKNOWN, } from "./types.js";
 // Completion in editors (src/completion.ts): the editor writes the name `options.completion` where
 // the cursor is, and this layer lists what can be written there when the check reaches that name:
@@ -12,7 +13,7 @@ const PRIMITIVE_MEMBERS = {
     bigint: BIGINT_MEMBERS,
     bool: BOOL_MEMBERS,
 };
-export class CompletionChecker extends IteratorChecker {
+export class CompletionChecker extends ClosingChecker {
     completion = null;
     atCursor(node) {
         return node.name === this.options.completion;
@@ -79,7 +80,7 @@ export class CompletionChecker extends IteratorChecker {
         if (component) {
             return { name, kind: 'component', detail: typeToString(this.componentValue(component)) };
         }
-        const type = binding.type && (this.flow.get(binding) ?? binding.type);
+        const type = binding.type && (this.flow.get(placeOf(binding)) ?? binding.type);
         const detail = type ? { detail: typeToString(type) } : {};
         if (kind === 'function' || type?.kind === 'function')
             return { name, kind: 'function', ...detail };

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

@@ -0,0 +1,7 @@
+import type * as ast from '../ast.ts';
+import type { ComponentInfo } from './context.ts';
+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;
+}

package/dist/checker/component-bindings.js

@@ -0,0 +1,45 @@
+import { attrsParam } from "../attrs.js";
+import { ForwardingChecker } from "./forwarding.js";
+import { isUntyped } from "./helpers.js";
+import { isAssignable, typeToString } 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.
+export class ComponentBindingChecker extends ForwardingChecker {
+    /** `bind:active={tab}` on a component; adds the name of the property to `given`. */
+    checkPropBinding(attribute, info, component, given) {
+        const name = attribute.name.name.slice('bind:'.length);
+        const prop = info.props.get(name);
+        const { value } = attribute;
+        if (given.has(name))
+            this.error(`duplicate property "${name}"`, attribute.name);
+        given.add(name);
+        if (!prop) {
+            this.error(attrsParam(info.node)
+                ? `${attribute.name.name} does not go through the attributes of <${component}>`
+                : `<${component}> has no property "${name}" to bind`, attribute.name);
+        }
+        else if (!prop.bind) {
+            this.error(`"${name}" of <${component}> is not bound: the component declares it with bind to change it, e.g. comp ${component}(bind ${name} ...)`, attribute.name);
+        }
+        if (value === null || value.kind === 'StringLiteral' || value.kind === 'EventHandler') {
+            this.error(`"bind:${name}" needs a variable in braces, e.g. bind:${name}={${name}}`, attribute);
+            return;
+        }
+        const bindable = (value.kind === 'Identifier' && value.name !== '_') ||
+            ((value.kind === 'MemberExpression' || value.kind === 'IndexExpression') && !value.optional);
+        if (!bindable) {
+            this.checkValue(value);
+            this.error(`"bind:${name}" needs a variable or a field to write to`, value);
+            return;
+        }
+        const type = this.checkTarget(value);
+        this.checkedTypes.set(value, type);
+        if (!prop?.bind || isUntyped(type) || isUntyped(prop.type))
+            return;
+        // The parent gives its value, and the component writes its own back.
+        if (!isAssignable(type, prop.type) || !isAssignable(prop.type, type)) {
+            this.error(`cannot bind ${typeToString(type)} to "${name}" of <${component}>, which is ${typeToString(prop.type)}`, value);
+        }
+    }
+}

package/dist/checker/component-values.js

@@ -1,6 +1,5 @@
 import { ComponentChecker } from "./components.js";
 import { isUntyped } from "./helpers.js";
-const upperFirst = (name) => name.charAt(0).toUpperCase() + name.slice(1);
 import { isNullable, typeToString, UNKNOWN, } from "./types.js";
 // Components as values: `content: Intro` has the type `comp()`, and a tag takes the component
 // from a value, `<section.content />`, or `<Page />` when `Page` is a variable. Such a tag passes
@@ -20,12 +19,8 @@ export class ComponentValueChecker extends ComponentChecker {
         const name = tag.name;
         if (isUntyped(type) || type.kind !== 'component') {
             if (isNullable(type)) {
-                // Only variables are narrowed, so a path goes into one first.
-                const variable = /^[A-Z]/.test(name) ? name : upperFirst(name.split('.').at(-1));
-                const show = `{if ${variable} != null { <${variable} /> }}`;
-                this.error(name === variable
-                    ? `<${name}> may be null: show it with {if}, e.g. ${show}`
-                    : `<${name}> may be null: put it into a variable and show it with {if}, e.g. const ${variable} = ${name}, then ${show}`, tag);
+                // A path of fields is narrowed like a variable: `{if page.other != null { <page.other /> }}`.
+                this.error(`<${name}> may be null: show it with {if}, e.g. {if ${name} != null { <${name} /> }}`, tag);
             }
             else if (!isUntyped(type)) {
                 this.error(`<${name}> is ${typeToString(type)}, not a component: give it a type like comp(title string)`, tag);
@@ -58,6 +53,14 @@ export class ComponentValueChecker extends ComponentChecker {
                 this.error(`ref cannot point to <${name}>: its component is a value, so its element is not known in advance`, attribute);
                 continue;
             }
+            // The type of the value does not say which properties are bound.
+            if (attributeName.startsWith('bind:')) {
+                const { value } = attribute;
+                if (value && value.kind !== 'EventHandler')
+                    this.checkValue(value);
+                this.error(`<${name}> takes its component from a value, so it cannot bind its properties; pass a function, e.g. onChange={...}`, attribute.name);
+                continue;
+            }
             if (given.has(attributeName)) {
                 this.error(`duplicate property "${attributeName}"`, attribute.name);
             }

package/dist/checker/components.d.ts

@@ -1,8 +1,8 @@
 import type * as ast from '../ast.ts';
 import type { ComponentInfo } from './context.ts';
-import { ForwardingChecker } from './forwarding.ts';
+import { ComponentBindingChecker } from './component-bindings.ts';
 import { type Type } from './types.ts';
-export declare abstract class ComponentChecker extends ForwardingChecker {
+export declare abstract class ComponentChecker extends ComponentBindingChecker {
     protected resolveProps(info: ComponentInfo): void;
     /** The body runs once where the component is used and must end with `return <markup>`. */
     protected checkComponentBody(info: ComponentInfo): void;

package/dist/checker/components.js

@@ -3,10 +3,11 @@ import { freeNames } from "../names.js";
 import { endlessRecursion } from "../recursion.js";
 import { CONTENT } from "./dom.js";
 import { lookupIn, ownStatements, isUntyped, callSignature } from "./helpers.js";
-import { ATTRIBUTES, ForwardingChecker } from "./forwarding.js";
+import { ComponentBindingChecker } from "./component-bindings.js";
+import { ATTRIBUTES } from "./forwarding.js";
 import { BOOL, func, hasZeroValue, isAssignable, isNullable, nonNull, spreadFields, typesEqual, typeToString, UNKNOWN, } from "./types.js";
 // Components: their bodies and uses, properties and spread, names they use from the module, recursion.
-export class ComponentChecker extends ForwardingChecker {
+export class ComponentChecker extends ComponentBindingChecker {
     resolveProps(info) {
         for (const param of info.node.params) {
             // `...attrs` takes the attributes that are not properties.
@@ -20,7 +21,7 @@ export class ComponentChecker extends ForwardingChecker {
             if (info.props.has(name))
                 this.error(`duplicate property "${name}"`, param.name);
             const optional = param.defaultValue !== null || isNullable(type) || name === 'children';
-            info.props.set(name, { type, optional });
+            info.props.set(name, { type, optional, ...(param.bind ? { bind: true } : {}) });
         }
     }
     /** The body runs once where the component is used and must end with `return <markup>`. */
@@ -96,6 +97,10 @@ export class ComponentChecker extends ForwardingChecker {
                 this.checkRefAttribute(attribute, node);
                 continue;
             }
+            if (name.startsWith('bind:')) {
+                this.checkPropBinding(attribute, info, tag.name, given);
+                continue;
+            }
             if (given.has(name))
                 this.error(`duplicate property "${name}"`, attribute.name);
             given.add(name);