rooklang 0.3.4 → 0.4.0

package/dist/checker/decorators.js

@@ -1,5 +1,6 @@
 import { freeNames } from "../names.js";
 import { forEachChild } from "../walk.js";
+import { withIncluded, } from "./context.js";
 import { DecoratorExportChecker } from "./decorator-exports.js";
 import { lookupIn, ownStatements } from "./helpers.js";
 import { func, UNKNOWN } from "./types.js";
@@ -42,7 +43,9 @@ export class DecoratorChecker extends DecoratorExportChecker {
             needed.add(name);
         }
     }
-    /** Decorators after the ones they need. A cycle of needs is an error: none can be first. */
+    /**
+     * Decorators after the ones they need or include. A cycle is an error: none can be first.
+     */
     orderByNeeds(decorators) {
         const order = [];
         const path = [];
@@ -51,13 +54,17 @@ export class DecoratorChecker extends DecoratorExportChecker {
                 return;
             const at = path.indexOf(info);
             if (at >= 0) {
-                const cycle = path.slice(at).map((each) => `@${each.node.name.name}`);
-                const steps = cycle.map((name, i) => `${name} needs ${cycle[(i + 1) % cycle.length]}`);
-                this.error(`decorators cannot need each other: ${steps.join(', ')}; remove one of the needs`, info.node.name);
+                const cycle = path.slice(at);
+                const steps = cycle.map((each, i) => {
+                    const next = cycle[(i + 1) % cycle.length];
+                    const how = each.included.includes(next) ? 'includes' : 'needs';
+                    return `@${each.node.name.name} ${how} @${next.node.name.name}`;
+                });
+                this.error(`decorators cannot need or include each other: ${steps.join(', ')}; remove one of them`, info.node.name);
                 return;
             }
             path.push(info);
-            for (const needed of info.needed)
+            for (const needed of [...info.needed, ...info.included])
                 visit(needed);
             path.pop();
             order.push(info);
@@ -112,8 +119,7 @@ export class DecoratorChecker extends DecoratorExportChecker {
             }
             else if (statement.kind === 'VariableDeclaration' &&
                 statement.isPublic &&
-                statement.keyword !== 'let' &&
-                statement.keyword !== 'ref') {
+                statement.keyword !== 'let') {
                 for (const name of statement.names)
                     add(name, statement.keyword);
             }
@@ -121,10 +127,16 @@ export class DecoratorChecker extends DecoratorExportChecker {
     }
     /**
      * The decorators before `comp`: they exist, are applied once and below the ones they need, get
-     * valid arguments, and their wrappers get what they can take.
+     * valid arguments, and their wrappers get what they can take. Those that a decorator includes
+     * are applied with it, above it.
      */
     checkDecoratorUses(info) {
-        const applied = new Set();
+        // The decorator that each one is applied with, for those that another includes.
+        const applied = new Map();
+        const props = info.node.params.map((param) => [
+            param.name,
+            info.props.get(param.name.name)?.type ?? UNKNOWN,
+        ]);
         for (const use of info.node.decorators) {
             const name = use.name.name;
             const decorator = this.decorators.get(name);
@@ -132,23 +144,39 @@ export class DecoratorChecker extends DecoratorExportChecker {
                 this.error(`unknown decorator @${name}`, use.name);
                 continue;
             }
-            if (applied.has(decorator))
-                this.error(`@${name} is applied twice: apply it once`, use);
-            // The body of a decorator may read the state of those it needs right away.
-            for (const needed of decorator.needed) {
-                if (applied.has(needed))
-                    continue;
-                const other = needed.node.name.name;
-                this.error(`@${name} needs @${other} above it: @${other} @${name} comp ...`, use);
+            for (const each of withIncluded([decorator])) {
+                const via = each === decorator ? null : name;
+                this.checkApplied(each, via, applied, use);
+                applied.set(each, via);
+                this.checkInlinedNames(use, each, info);
             }
-            applied.add(decorator);
-            this.checkDecoratorArguments(use, decorator, info);
-            this.checkInlinedNames(use, decorator, info);
+            this.checkDecoratorArguments(use, decorator, props);
         }
         this.checkWrappedTypes(info);
     }
-    /** Arguments are positional and see the properties of the component, as its body does. */
-    checkDecoratorArguments(use, decorator, info) {
+    /** Applied once, below the ones it needs; `via` is the decorator that includes it. */
+    checkApplied(decorator, via, applied, use) {
+        const name = decorator.node.name.name;
+        const where = (other) => (other === null ? '' : ` (it is in @${other})`);
+        if (applied.has(decorator)) {
+            const before = applied.get(decorator) ?? null;
+            this.error(before === null && via === null
+                ? `@${name} is applied twice: apply it once`
+                : `@${name} is applied twice${where(via ?? before)}: apply it once`, use);
+        }
+        // The body of a decorator may read the state of those it needs right away.
+        for (const needed of decorator.needed) {
+            if (applied.has(needed))
+                continue;
+            const other = needed.node.name.name;
+            this.error(`@${name}${where(via)} needs @${other} above it: @${other} @${via ?? name} comp ...`, use);
+        }
+    }
+    /**
+     * Arguments are positional and see `params`: the properties of the component, as its body does,
+     * or the parameters of the decorator that includes this one.
+     */
+    checkDecoratorArguments(use, decorator, scope) {
         const name = use.name.name;
         const { params } = decorator.node;
         const extra = use.arguments[params.length];
@@ -157,9 +185,8 @@ export class DecoratorChecker extends DecoratorExportChecker {
             this.error(params.length === 0 ? `@${name} takes no arguments` : `@${name} takes ${count}`, extra);
         }
         this.withScope(() => {
-            for (const param of info.node.params) {
-                this.declareValue(param.name, 'prop', info.props.get(param.name.name)?.type ?? UNKNOWN);
-            }
+            for (const [param, type] of scope)
+                this.declareValue(param, 'prop', type);
             params.forEach((param, i) => {
                 const type = decorator.params[i] ?? UNKNOWN;
                 const arg = use.arguments[i];

package/dist/checker/expressions.d.ts

@@ -1,5 +1,5 @@
 import type * as ast from '../ast.ts';
-import type { ComponentInfo } from './context.ts';
+import { type ComponentInfo } from './context.ts';
 import { FunctionChecker } from './functions.ts';
 import { type ComponentType, type Type } from './types.ts';
 export declare abstract class ExpressionChecker extends FunctionChecker {

package/dist/checker/expressions.js

@@ -1,3 +1,4 @@
+import { placeOf } from "./context.js";
 import { FunctionChecker } from "./functions.js";
 import { expectsLiteral, callName, isUntyped } from "./helpers.js";
 import { ANY, BIGINT, BOOL, hasUntypedBase, instanceMembers, isAssignable, literal, nonNull, NULL, nullable, NUMBER, STRING, typeToString, UNKNOWN, } from "./types.js";
@@ -90,8 +91,6 @@ export class ExpressionChecker extends FunctionChecker {
                 return this.checkElement(node);
             case 'DecoratorMember':
                 return this.checkDecoratorMember(node);
-            case 'DecoratorGet':
-                return this.checkDecoratorGet(node);
             case 'MemberExpression':
             case 'IndexExpression':
             case 'CallExpression': {
@@ -130,7 +129,7 @@ export class ExpressionChecker extends FunctionChecker {
             this.error(`"${node.name}" is used before its declaration`, node);
             return UNKNOWN;
         }
-        return this.flow.get(binding) ?? binding.type;
+        return this.flow.get(placeOf(binding)) ?? binding.type;
     }
     thisType(node) {
         if (!this.cls) {
@@ -155,10 +154,11 @@ export class ExpressionChecker extends FunctionChecker {
     }
     checkObjectLiteral(node, expected) {
         let target = expected ? nonNull(expected) : null;
-        // `?(ScrollIntoViewOptions | bool)`: an object literal can only be the object type in it.
+        // `?(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] : null;
+            target = objects.length === 1 ? objects[0] : this.taggedMember(node, objects, target);
         }
         const index = target?.kind === 'object' ? target.index : undefined;
         const targetMembers = target?.kind === 'object'
@@ -168,7 +168,8 @@ export class ExpressionChecker extends FunctionChecker {
                 : null;
         const members = new Map();
         const written = new Set();
-        let untyped = false;
+        // A tag of no member is reported once, not again where the literal is used.
+        let untyped = target?.kind === 'unknown';
         for (const property of node.properties) {
             if (property.kind === 'SpreadElement') {
                 const spread = this.checkValue(property.argument);

package/dist/checker/flow.d.ts

@@ -1,6 +1,6 @@
 import type * as ast from '../ast.ts';
-import type { Flow, Narrowing } from './context.ts';
-import { type Type } from './types.ts';
+import type { Binding, Flow, Narrowing, Place } from './context.ts';
+import { type LiteralType, type Type } from './types.ts';
 /** What `typeof` gives for every value of a type, or `null` when it may give several things. */
 export declare function typeofTag(type: Type): string | null;
 /** The type after `typeof x == tag` is found true (`matches`) or false. */
@@ -9,8 +9,30 @@ export declare function narrowByTypeof(type: Type, tag: string, matches: boolean
 export declare function literalValue(node: ast.Expression): string | number | boolean | undefined;
 /** A type without one literal value: what is left after `x != "all"`. */
 export declare function withoutLiteral(type: Type, value: string | number | boolean): Type;
+/**
+ * A union after a comparison of its tag, a field with literal types in each member: `tags` has the
+ * values the tag may have in each member, `values` those it is compared with. When `equal`, the
+ * members whose tag may be one of the values remain; otherwise those whose tag may be another one.
+ */
+export declare function narrowByTag(type: Type, tags: readonly (readonly LiteralType['value'][])[], values: readonly LiteralType['value'][], equal: boolean): Type;
+/**
+ * Whether `field` is a tag of what `place` was declared as: then an assignment to it may change
+ * the member of the union that the place was narrowed to.
+ */
+export type IsTag = (place: Place, field: string) => boolean;
+/**
+ * Whether an assignment to the fields `written` of a variable ends the narrowing of `place`, a
+ * path of the same variable or the variable itself (the empty path): it writes the path, its
+ * start or a tag of it. `"delivery.kind"` ends the narrowing of `"delivery"`, which may come from
+ * that tag; `"delivery.floor"` does not.
+ */
+export declare function overwrites(written: string, place: Place, isTag: IsTag): boolean;
+/** Ends the narrowing that an assignment to `binding` or to its fields `written` changes. */
+export declare function forgetWritten(flow: Flow, binding: Binding, written: string, isTag: IsTag): void;
+/** The flow without what assignments to the variables `names` and the paths `paths` change. */
+export declare function withoutAssigned(flow: Flow, names: ReadonlySet<string>, paths: ReadonlySet<string>, isTag: IsTag): Flow;
 export declare function withNarrowing(flow: Flow, narrowing: Narrowing): Flow;
-/** Narrowing that holds after both branches: the variables narrowed the same way in both. */
+/** 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 isTerminating(node: ast.Statement): boolean;

package/dist/checker/flow.js

@@ -1,7 +1,7 @@
 import { containsBreak } from "../breaks.js";
 import { BIGINT, BOOL, isNullable, nonNull, NULL, NUMBER, STRING, typesEqual, union, unionMembers, } from "./types.js";
-// Control flow for the checker: how conditions narrow the types of variables, and which statements
-// execution never continues after.
+// Control flow for the checker: how conditions narrow the types of variables and paths, and which
+// statements execution never continues after.
 /** What a value of unknown type is after `typeof x == tag`. */
 const PRIMITIVE_TAGS = new Map([
     ['string', STRING],
@@ -67,19 +67,59 @@ export function withoutLiteral(type, value) {
     const kept = unionMembers(nonNull(type)).filter((member) => !(member.kind === 'literal' && member.value === value));
     return union(isNullable(type) ? [...kept, NULL] : kept);
 }
+/**
+ * A union after a comparison of its tag, a field with literal types in each member: `tags` has the
+ * values the tag may have in each member, `values` those it is compared with. When `equal`, the
+ * members whose tag may be one of the values remain; otherwise those whose tag may be another one.
+ */
+export function narrowByTag(type, tags, values, equal) {
+    const kept = unionMembers(nonNull(type)).filter((_, i) => {
+        const tag = tags[i] ?? [];
+        return equal
+            ? tag.some((value) => values.includes(value))
+            : !tag.every((value) => values.includes(value));
+    });
+    return union(!equal && isNullable(type) ? [...kept, NULL] : kept);
+}
+/**
+ * Whether an assignment to the fields `written` of a variable ends the narrowing of `place`, a
+ * path of the same variable or the variable itself (the empty path): it writes the path, its
+ * start or a tag of it. `"delivery.kind"` ends the narrowing of `"delivery"`, which may come from
+ * that tag; `"delivery.floor"` does not.
+ */
+export function overwrites(written, place, isTag) {
+    const { path } = place;
+    if (written === '' || written === path || path.startsWith(`${written}.`))
+        return true;
+    const field = path === '' ? written : written.startsWith(`${path}.`) ? written.slice(path.length + 1) : null;
+    return field !== null && !field.includes('.') && isTag(place, field);
+}
+/** Ends the narrowing that an assignment to `binding` or to its fields `written` changes. */
+export function forgetWritten(flow, binding, written, isTag) {
+    for (const place of flow.keys()) {
+        if (place.binding === binding && overwrites(written, place, isTag))
+            flow.delete(place);
+    }
+}
+/** The flow without what assignments to the variables `names` and the paths `paths` change. */
+export function withoutAssigned(flow, names, paths, isTag) {
+    const written = [...paths].map((path) => path.split('.'));
+    return new Map([...flow].filter(([place]) => !names.has(place.binding.name) &&
+        !written.some(([root, ...fields]) => root === place.binding.name && overwrites(fields.join('.'), place, isTag))));
+}
 export function withNarrowing(flow, narrowing) {
     const result = new Map(flow);
-    for (const [binding, type] of narrowing)
-        result.set(binding, type);
+    for (const [place, type] of narrowing)
+        result.set(place, type);
     return result;
 }
-/** Narrowing that holds after both branches: the variables narrowed the same way in both. */
+/** Narrowing that holds after both branches: the places narrowed the same way in both. */
 export function mergeFlows(a, b) {
     const result = new Map();
-    for (const [binding, type] of a) {
-        const other = b.get(binding);
+    for (const [place, type] of a) {
+        const other = b.get(place);
         if (other && typesEqual(type, other))
-            result.set(binding, type);
+            result.set(place, type);
     }
     return result;
 }

package/dist/checker/functions.d.ts

@@ -1,8 +1,8 @@
 import type * as ast from '../ast.ts';
 import { type BindingKind, Scope, type Flow } from './context.ts';
-import { ControlFlowChecker } from './control-flow.ts';
+import { TaggedUnionChecker } from './tagged-unions.ts';
 import { type FunctionType, type Type } from './types.ts';
-export declare abstract class FunctionChecker extends ControlFlowChecker {
+export declare abstract class FunctionChecker extends TaggedUnionChecker {
     /**
      * Checks a function body and returns its result types: the declared ones, or those inferred from
      * the `return` statements when `results` is `null`.

package/dist/checker/functions.js

@@ -1,11 +1,11 @@
 import { Scope } from "./context.js";
-import { ControlFlowChecker } from "./control-flow.js";
 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";
 // Bodies of functions, arrow functions and func literals, and the results they return.
-export class FunctionChecker extends ControlFlowChecker {
+export class FunctionChecker extends TaggedUnionChecker {
     /**
      * Checks a function body and returns its result types: the declared ones, or those inferred from
      * the `return` statements when `results` is `null`.
@@ -30,7 +30,9 @@ export class FunctionChecker extends ControlFlowChecker {
             // 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) => this.declareValue(param.name, options.paramKind ?? 'param', type.params[i] ?? UNKNOWN));
+            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));
             if (body.kind === 'BlockStatement') {
                 this.checkStatementList(body.body, false);
                 options.inspect?.(this.scope);
@@ -87,9 +89,11 @@ export class FunctionChecker extends ControlFlowChecker {
     }
     stableFlow() {
         const flow = new Map();
-        for (const [binding, type] of this.flow) {
+        // A path keeps its narrowing when its variable does, like `user.boss` of a constant `user`.
+        for (const [place, type] of this.flow) {
+            const { binding } = place;
             if (binding.kind === 'const' || !this.assigned.has(binding.name))
-                flow.set(binding, type);
+                flow.set(place, type);
         }
         return flow;
     }

package/dist/checker/helpers.d.ts

@@ -11,7 +11,10 @@ export declare function ownStatements(body: ast.BlockStatement): ast.Statement[]
  * the type of a DOM node), lists of them, or null.
  */
 export declare function isContent(given: Type, node: Type): boolean;
-/** Values that setAttribute accepts: text, numbers, bools, or null to leave it out. */
+/**
+ * Values that setAttribute accepts: text, numbers, bools, or null to leave it out. A literal is
+ * one of them, and so is a union of such, `type Status "shown" | "aborted"`.
+ */
 export declare function isAttributeValue(type: Type): boolean;
 export declare function isUntyped(type: Type): boolean;
 export declare function isNumeric(type: Type): boolean;

package/dist/checker/helpers.js

@@ -61,7 +61,10 @@ export function isContent(given, node) {
             return false;
     }
 }
-/** Values that setAttribute accepts: text, numbers, bools, or null to leave it out. */
+/**
+ * Values that setAttribute accepts: text, numbers, bools, or null to leave it out. A literal is
+ * one of them, and so is a union of such, `type Status "shown" | "aborted"`.
+ */
 export function isAttributeValue(type) {
     const value = nonNull(type);
     return (isUntyped(value) ||
@@ -69,8 +72,10 @@ export function isAttributeValue(type) {
         value.kind === 'number' ||
         value.kind === 'bigint' ||
         value.kind === 'bool' ||
+        value.kind === 'literal' ||
         value.kind === 'null' ||
-        value.kind === 'never');
+        value.kind === 'never' ||
+        (value.kind === 'union' && value.types.every(isAttributeValue)));
 }
 export function isUntyped(type) {
     return type.kind === 'any' || type.kind === 'unknown';

package/dist/checker/imports.js

@@ -54,8 +54,11 @@ export class ImportChecker extends CheckerBase {
             if (!found) {
                 this.error(`"${name}" is not exported by "${specifier}"`, specifierNode.imported);
             }
-            if (value !== undefined)
-                this.declareValue(specifierNode.local, 'import', value);
+            if (value !== undefined) {
+                const binding = this.declareValue(specifierNode.local, 'import', value);
+                if (exports.shared?.has(name))
+                    binding.shared = specifier;
+            }
             if (type !== undefined)
                 this.declareType(specifierNode.local, type);
             if (decorator !== undefined)

package/dist/checker/loops.d.ts

@@ -2,6 +2,8 @@ import type * as ast from '../ast.ts';
 import { BytesChecker } from './bytes.ts';
 export declare abstract class LoopChecker extends BytesChecker {
     protected checkForIn(node: ast.ForInStatement): void;
+    /** `with key todo.id`: a string or a number, by which the blocks of the list are found again. */
+    private checkListKey;
     /**
      * The key and the value of a loop over an iterator: what its `yield` takes. Of two, one variable
      * gets the second, as with a Map; of one, there is no key.

package/dist/checker/loops.js

@@ -1,4 +1,3 @@
-import { assignedNames } from "../names.js";
 import { BytesChecker } from "./bytes.js";
 import { chanDirection, elementOf, isChan } from "./channel.js";
 import { asyncIterated, isMap, loopEntry } from "./iterables.js";
@@ -78,13 +77,22 @@ export class LoopChecker extends BytesChecker {
             if (node.key)
                 this.declareValue(node.key, 'loop', key);
             this.declareValue(node.value, 'loop', value);
-            this.dropNarrowing(assignedNames(node.body));
+            if (node.withKey)
+                this.checkListKey(node.withKey);
+            this.dropNarrowing(node.body);
             const entry = this.flow;
             this.flow = new Map(entry);
             this.checkBlock(node.body.body);
             this.flow = entry;
         });
     }
+    /** `with key todo.id`: a string or a number, by which the blocks of the list are found again. */
+    checkListKey(key) {
+        const type = this.checkValue(key);
+        if (!isListKey(type)) {
+            this.error(`the key of a list must be a string or a number, not ${typeToString(type)}: e.g. "with key todo.id"`, key);
+        }
+    }
     /**
      * The key and the value of a loop over an iterator: what its `yield` takes. Of two, one variable
      * gets the second, as with a Map; of one, there is no key.
@@ -100,3 +108,20 @@ export class LoopChecker extends BytesChecker {
         return [UNKNOWN, taken[0] ?? UNKNOWN];
     }
 }
+/** A key of a list: a string, a number, a literal of one or a union of them. */
+function isListKey(type) {
+    switch (type.kind) {
+        case 'string':
+        case 'number':
+        case 'bigint':
+        case 'any':
+        case 'unknown':
+            return true;
+        case 'literal':
+            return typeof type.value !== 'boolean';
+        case 'union':
+            return type.types.every(isListKey);
+        default:
+            return false;
+    }
+}

package/dist/checker/markup.js

@@ -4,8 +4,10 @@ import { domProperty, elementType } from "./dom.js";
 import { svgElementType } from "./dom-svg.js";
 import { isContent, isAttributeValue, isUntyped } from "./helpers.js";
 import { OperatorChecker } from "./operators.js";
-import { BOOL, func, STRING, typeToString } from "./types.js";
+import { arrayOf, BOOL, func, nullable, STRING, typeToString } from "./types.js";
 // Markup: elements, their children and attributes, `bind:` and event handlers.
+/** The type of a list of classes, `class={[styles.tab, active ? styles.active : null]}`. */
+const CLASS_LIST = arrayOf(nullable(STRING));
 export class MarkupChecker extends OperatorChecker {
     /** Whether the markup being checked is inside `<svg>`: its elements are SVG then. */
     inSvg = false;
@@ -98,7 +100,17 @@ export class MarkupChecker extends OperatorChecker {
         }
         if (value?.kind === 'EventHandler')
             return;
-        const valueType = value === null ? BOOL : value.kind === 'StringLiteral' ? STRING : this.checkValue(value);
+        const list = name === 'class' && value?.kind === 'ArrayLiteral' ? CLASS_LIST : null;
+        const valueType = value === null
+            ? BOOL
+            : value.kind === 'StringLiteral'
+                ? STRING
+                : this.checkValue(value, list);
+        // `class={[styles.tab, active ? styles.active : null]}`: the classes that are not null.
+        if (name === 'class' && valueType.kind === 'array') {
+            this.expectAssignable(valueType, CLASS_LIST, value, ' for attribute "class"');
+            return;
+        }
         if (name === 'style') {
             if (!isUntyped(valueType) && valueType.kind !== 'string' && valueType.kind !== 'object') {
                 this.error(`style must be a string or an object, not ${typeToString(valueType)}`, attribute);

package/dist/checker/members.js

@@ -16,6 +16,7 @@ export class MemberChecker extends DecoratorMemberChecker {
                 return [this.checkSuperCall(node), false];
             let [callee, shortCircuits] = this.chainPart(node.callee);
             this.checkDecoratorMutation(node);
+            this.checkSharedMutation(node);
             if (isNullable(callee)) {
                 if (node.optional)
                     shortCircuits = true;
@@ -46,7 +47,8 @@ export class MemberChecker extends DecoratorMemberChecker {
             else if (member !== 'any' && member?.abstract && node.object.kind === 'SuperExpression') {
                 this.error(`super.${name} is abstract in ${member.owner?.name ?? 'the base class'}: it has no code to run`, node.property);
             }
-            return [member === 'any' ? ANY : (member?.type ?? UNKNOWN), shortCircuits];
+            const type = member === 'any' ? ANY : (member?.type ?? UNKNOWN);
+            return [this.pathType(node, object, type), shortCircuits];
         }
         const keyed = this.keyedIndex(object, node.index);
         if (keyed)

package/dist/checker/shared-state.d.ts

@@ -0,0 +1,11 @@
+import type * as ast from '../ast.ts';
+import { ImportChecker } from './imports.ts';
+export declare abstract class SharedStateChecker extends ImportChecker {
+    /** `items = []` or `items[0].done = true` in a module that imported `items`. */
+    protected checkSharedWrite(target: ast.Expression): boolean;
+    /** `items.push(x)`: a method that changes state that another module shares. */
+    protected checkSharedMutation(node: ast.CallExpression): void;
+    /** The import that a target writes into, `items` of `items[0].done`, if it is shared state. */
+    private importedShared;
+    private sharedError;
+}

package/dist/checker/shared-state.js

@@ -0,0 +1,37 @@
+import { mayChange } from "../methods.js";
+import { ImportChecker } from "./imports.js";
+// State shared by components: `state items []Item = []` at the top level of a module. Its module
+// changes it anywhere; other modules import it to read, and change it only by calling a function
+// of its module, so that the module keeps its data consistent, as a decorator keeps its state.
+export class SharedStateChecker extends ImportChecker {
+    /** `items = []` or `items[0].done = true` in a module that imported `items`. */
+    checkSharedWrite(target) {
+        const shared = this.importedShared(target);
+        if (shared)
+            this.sharedError(shared, target);
+        return shared !== null;
+    }
+    /** `items.push(x)`: a method that changes state that another module shares. */
+    checkSharedMutation(node) {
+        const { callee } = node;
+        if (callee.kind !== 'MemberExpression')
+            return;
+        const shared = this.importedShared(callee.object);
+        if (shared && mayChange(this.typeOfChecked(callee.object), callee.property.name)) {
+            this.sharedError(shared, node);
+        }
+    }
+    /** The import that a target writes into, `items` of `items[0].done`, if it is shared state. */
+    importedShared(target) {
+        let root = target;
+        while (root.kind === 'MemberExpression' || root.kind === 'IndexExpression')
+            root = root.object;
+        if (root.kind !== 'Identifier')
+            return null;
+        const binding = this.lookupValue(root.name);
+        return binding?.shared ? binding : null;
+    }
+    sharedError(binding, node) {
+        this.error(`"${binding.name}" is state of "${binding.shared}", which is read-only here; change it with a function that "${binding.shared}" exports`, node);
+    }
+}

package/dist/checker/statements.d.ts

@@ -12,10 +12,11 @@ export declare abstract class StatementChecker extends AssignmentChecker {
      */
     protected checkEffect(node: ast.EffectStatement): void;
     /**
-     * `mount() { ... }`: a function that runs once the markup is in the document, like a handler.
-     * It may return the function that cleans up, or nothing.
+     * `mount { ... }`: a function that runs once the markup is in the document, like a handler. It
+     * cleans up with `defer`, as an effect does, so it returns nothing.
      */
     protected checkMount(node: ast.MountStatement): void;
+    private checkDeferring;
     /**
      * `delete scores[name]` removes a key of an object used as a map, `{ [string]: T }`, or a field
      * that may be missing, of type `?T`; values of type `any` are not checked.
@@ -30,4 +31,6 @@ export declare abstract class StatementChecker extends AssignmentChecker {
     private linkError;
     /** The types of the variables of a declaration: the written one, or those of their values. */
     private initializerTypes;
+    /** `derived total number { ... }`: the block runs like the body of a closure and returns the value. */
+    private derivedBlockType;
 }