rooklang 0.3.3 → 0.4.0

package/dist/checker/decorator-members.js

@@ -1,27 +1,14 @@
 import { ARRAY_MUTATORS } from "../methods.js";
-import { DecoratorChecker } from "./decorators.js";
+import { withIncluded } from "./context.js";
+import { DecoratorIncludeChecker } from "./decorator-includes.js";
 import { nonNull, UNKNOWN } from "./types.js";
 // The public members of decorators, in the components they are applied to: `@visible.show()` calls
-// a function, `get(@visible.shown)` reads state or a constant, and none of them can be changed
-// outside the decorator.
-export class DecoratorMemberChecker extends DecoratorChecker {
-    /** `@visible.show`: a public function; state and constants are read with `get`. */
+// a function, `@visible.shown` reads state or a constant, and none of them can be changed outside
+// the decorator.
+export class DecoratorMemberChecker extends DecoratorIncludeChecker {
+    /** `@visible.shown` or `@visible.show`: public state, a constant or a function. */
     checkDecoratorMember(node) {
-        const member = this.findDecoratorMember(node);
-        if (member && member.kind !== 'func') {
-            const { decorator, member: name } = node;
-            this.error(`read "${name.name}" of @${decorator.name} with get(@${decorator.name}.${name.name})`, node);
-        }
-        return member?.type ?? UNKNOWN;
-    }
-    /** `get(@visible.shown)`: public state or a constant. */
-    checkDecoratorGet(node) {
-        const member = this.findDecoratorMember(node.target);
-        if (member?.kind === 'func') {
-            const { decorator, member: name } = node.target;
-            this.error(`"${name.name}" of @${decorator.name} is a function: call it, @${decorator.name}.${name.name}()`, node);
-        }
-        return member?.type ?? UNKNOWN;
+        return this.findDecoratorMember(node)?.type ?? UNKNOWN;
     }
     /**
      * A public member of a decorator applied to the component being checked, or of one that the
@@ -38,6 +25,13 @@ export class DecoratorMemberChecker extends DecoratorChecker {
             return null;
         }
         const info = component.decorators.find((decorator) => decorator.node.name.name === name);
+        // `@cart.count` of the `cart` that `@shop` includes is `@shop.count`.
+        const via = component.decorators.find((decorator) => withIncluded(decorator.included).some((each) => each.node.name.name === name));
+        if (!info && via) {
+            const combined = via.node.name.name;
+            this.error(`"${member}" of @${name} comes through @${combined}: write @${combined}.${member}`, node);
+            return null;
+        }
         if (!info) {
             this.error(this.decorators.has(name)
                 ? `@${name} is not applied to ${component.node.name.name}: write @${name} before comp`
@@ -46,7 +40,7 @@ export class DecoratorMemberChecker extends DecoratorChecker {
         }
         return this.publicMember(node, info);
     }
-    /** `get(@cart.count)` in `dec cartBadge() needs cart`. */
+    /** `@cart.count` in `dec cartBadge() needs cart`. */
     neededMember(node, decorator) {
         const name = node.decorator.name;
         const current = decorator.name.name;
@@ -54,8 +48,9 @@ export class DecoratorMemberChecker extends DecoratorChecker {
             this.error(`inside @${name} its members are used by their names: ${node.member.name}`, node);
             return null;
         }
-        if (!decorator.needs.some((need) => need.name === name)) {
-            this.error(`@${current} can use @${name} only if it needs it: write "needs ${name}" after its parameters`, node.decorator);
+        const uses = [...decorator.needs, ...decorator.includes.map((use) => use.name)];
+        if (!uses.some((used) => used.name === name)) {
+            this.error(`@${current} can use @${name} only if it needs or includes it: write "needs ${name}" after its parameters`, node.decorator);
             return null;
         }
         const info = this.decorators.get(name);
@@ -74,18 +69,22 @@ export class DecoratorMemberChecker extends DecoratorChecker {
         return found ?? null;
     }
     /**
-     * Members of a decorator are read-only outside it: `get(@cart.count) = 0`, `get(@cart.items)[0]
-     * = x`. Returns whether `target` is one of them.
+     * Members of a decorator are read-only outside it: `@cart.count = 0`, `@cart.items[0] = x`.
+     * Returns whether `target` is one of them.
      */
     checkDecoratorWrite(target) {
         const root = decoratorRoot(target);
         if (!root)
             return false;
-        if (this.findDecoratorMember(root))
+        const member = this.findDecoratorMember(root);
+        // A ref always points to its element, but the element is the page's: `@framed.box.title = x`.
+        if (member?.kind === 'ref' && target !== root)
+            return false;
+        if (member)
             this.readOnlyError(root, target);
         return true;
     }
-    /** `get(@cart.items).push(x)`: a method that changes the array. */
+    /** `@cart.items.push(x)`: a method that changes the array. */
     checkDecoratorMutation(node) {
         const { callee } = node;
         if (callee.kind !== 'MemberExpression')
@@ -118,17 +117,15 @@ export class DecoratorMemberChecker extends DecoratorChecker {
         const member = node.property.name;
         this.error(info.members.get(member)?.kind === 'func'
             ? `"${name}" is not defined; to call a function of @${name} write @${name}.${member}()`
-            : `"${name}" is not defined; to read public state of @${name} write get(@${name}.${member})`, object);
+            : `"${name}" is not defined; to read public state of @${name} write @${name}.${member}`, object);
         return true;
     }
 }
-/** The member of a decorator that `get(@cart.items)[0].done` starts with, if any. */
+/** The member of a decorator that `@cart.items[0].done` starts with, if any. */
 function decoratorRoot(node) {
     switch (node.kind) {
         case 'DecoratorMember':
             return node;
-        case 'DecoratorGet':
-            return node.target;
         case 'MemberExpression':
         case 'IndexExpression':
             return decoratorRoot(node.object);

package/dist/checker/decorator-wrappers.d.ts

@@ -1,4 +1,4 @@
-import type { ComponentInfo, DecoratorInfo } from './context.ts';
+import { type ComponentInfo, type DecoratorInfo } from './context.ts';
 import { StyleChecker } from './styles.ts';
 import { type Type } from './types.ts';
 type WrapperInfo = NonNullable<DecoratorInfo['wrapper']>;

package/dist/checker/decorator-wrappers.js

@@ -1,4 +1,5 @@
 import { decoratorNames, wrapperBody, wrapperOf } from "../decorators.js";
+import { withIncluded } from "./context.js";
 import { isUntyped, ownStatements } from "./helpers.js";
 import { StyleChecker } from "./styles.js";
 import { isAssignable, typeToString, UNKNOWN } from "./types.js";
@@ -78,7 +79,7 @@ export class DecoratorWrapperChecker extends StyleChecker {
         }
     }
     wrappedType(info, own, seen) {
-        return info.decorators.reduceRight((type, decorator) => (decorator.wrapper ? this.wrapperResult(decorator.wrapper, seen) : type), own);
+        return withIncluded(info.decorators).reduceRight((type, decorator) => (decorator.wrapper ? this.wrapperResult(decorator.wrapper, seen) : type), own);
     }
     /** What a wrapper gives, found without checking it again, like the markup of a component. */
     wrapperResult(wrapper, seen) {
@@ -96,7 +97,7 @@ export class DecoratorWrapperChecker extends StyleChecker {
     checkWrappedTypes(info) {
         let type = this.ownResult(info, new Set());
         let source = null;
-        for (const decorator of [...info.decorators].reverse()) {
+        for (const decorator of withIncluded(info.decorators).reverse()) {
             const { wrapper } = decorator;
             if (!wrapper)
                 continue;

package/dist/checker/decorators.d.ts

@@ -1,11 +1,14 @@
 import type * as ast from '../ast.ts';
-import type { ComponentInfo, DecoratorInfo, Scope } from './context.ts';
+import { type ComponentInfo, type DecoratorInfo, type Scope } from './context.ts';
 import { DecoratorExportChecker } from './decorator-exports.ts';
+import { type Type } from './types.ts';
 export declare abstract class DecoratorChecker extends DecoratorExportChecker {
     protected resolveDecoratorParams(info: DecoratorInfo): void;
     /** `needs cart, auth`: other decorators, each once. */
     protected checkNeedsDeclaration(info: DecoratorInfo): void;
-    /** 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.
+     */
     protected orderByNeeds(decorators: readonly DecoratorInfo[]): DecoratorInfo[];
     /**
      * The body is checked once, by itself: it does not see the components it is applied to. Its
@@ -15,11 +18,17 @@ export declare abstract class DecoratorChecker extends DecoratorExportChecker {
     protected collectMembers(info: DecoratorInfo, scope: Scope): void;
     /**
      * 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.
      */
     protected checkDecoratorUses(info: ComponentInfo): void;
-    /** Arguments are positional and see the properties of the component, as its body does. */
-    protected checkDecoratorArguments(use: ast.DecoratorUse, decorator: DecoratorInfo, info: ComponentInfo): void;
+    /** Applied once, below the ones it needs; `via` is the decorator that includes it. */
+    private checkApplied;
+    /**
+     * 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.
+     */
+    protected checkDecoratorArguments(use: ast.DecoratorUse, decorator: DecoratorInfo, scope: readonly [ast.Identifier, Type][]): void;
     /**
      * The code of the decorator and its arguments go into the component's body, so the names of the
      * module they use must not be hidden there by the component's declarations.

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 {
@@ -11,6 +11,11 @@ export declare abstract class ExpressionChecker extends FunctionChecker {
     protected abstract checkChan(node: ast.ChanExpression): Type;
     protected abstract checkStreamChan(node: ast.StreamChanExpression): Type;
     protected abstract checkQueue(node: ast.QueueExpression): Type;
+    protected abstract checkTopic(node: ast.TopicExpression): Type;
+    protected abstract checkDecode(node: ast.DecodeExpression): Type;
+    /** `[1, 2]`; implemented by ArrayLiteralChecker. */
+    protected abstract checkArrayLiteral(node: ast.ArrayLiteral, expected: Type | null): Type;
+    protected abstract checkTryExpression(node: ast.TryExpression): Type;
     /** `[]byte("text")`; implemented by BytesChecker. */
     protected abstract checkConversion(node: ast.ConversionExpression): Type;
     protected abstract checkMake(node: ast.MakeExpression): Type;
@@ -24,7 +29,6 @@ export declare abstract class ExpressionChecker extends FunctionChecker {
     protected thisType(node: ast.NodeBase): Type;
     /** `super.method()`: the members of the base class. */
     protected superType(node: ast.NodeBase): Type;
-    protected checkArrayLiteral(node: ast.ArrayLiteral, expected: Type | null): Type;
     protected checkObjectLiteral(node: ast.ObjectLiteral, expected: Type | null): Type;
     /**
      * `value as Type`: the types must be related, one assignable to the other, as in TypeScript:

package/dist/checker/expressions.js

@@ -1,6 +1,7 @@
+import { placeOf } from "./context.js";
 import { FunctionChecker } from "./functions.js";
 import { expectsLiteral, callName, isUntyped } from "./helpers.js";
-import { ANY, BIGINT, arrayOf, BOOL, commonType, hasUntypedBase, instanceMembers, isAssignable, literal, NEVER, nonNull, NULL, nullable, NUMBER, STRING, typeToString, UNKNOWN, } from "./types.js";
+import { ANY, BIGINT, BOOL, hasUntypedBase, instanceMembers, isAssignable, literal, nonNull, NULL, nullable, NUMBER, STRING, typeToString, UNKNOWN, } from "./types.js";
 // Expressions: names, `this`, literals of arrays and objects; the operators are in operators.ts.
 export class ExpressionChecker extends FunctionChecker {
     /** The type of an expression that must be a single value (not `void` or several results). */
@@ -35,6 +36,9 @@ export class ExpressionChecker extends FunctionChecker {
                 return BIGINT;
             case 'StringLiteral':
                 return expectsLiteral(expected) ? literal(node.value) : STRING;
+            // A RegExp of lib.es5.d.ts; the playground, which has no lib files, does not know its members.
+            case 'RegExpLiteral':
+                return this.options.library?.type('RegExp') ?? ANY;
             case 'TemplateLiteral':
                 for (const expression of node.expressions)
                     this.checkValue(expression);
@@ -71,6 +75,12 @@ export class ExpressionChecker extends FunctionChecker {
                 return this.checkStreamChan(node);
             case 'QueueExpression':
                 return this.checkQueue(node);
+            case 'TopicExpression':
+                return this.checkTopic(node);
+            case 'DecodeExpression':
+                return this.checkDecode(node);
+            case 'TryExpression':
+                return this.checkTryExpression(node);
             case 'ConversionExpression':
                 return this.checkConversion(node);
             case 'MakeExpression':
@@ -81,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': {
@@ -104,7 +112,9 @@ export class ExpressionChecker extends FunctionChecker {
                 ? `"${node.name}" is a type, not a value`
                 : node.name === 'make'
                     ? 'make takes the type of a typed array first, e.g. make([]float64, n)'
-                    : `"${node.name}" is not defined`, node);
+                    : node.name === 'decode'
+                        ? 'decode takes the type first, e.g. decode<User>(body)'
+                        : `"${node.name}" is not defined`, node);
             return UNKNOWN;
         }
         // A component as a value: a tag can take it from there, `<section.content />`.
@@ -119,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) {
@@ -142,44 +152,13 @@ export class ExpressionChecker extends FunctionChecker {
         this.error(`class "${info.name}" has no base class`, node);
         return UNKNOWN;
     }
-    checkArrayLiteral(node, expected) {
-        const context = expected ? nonNull(expected) : null;
-        const expectedElement = context?.kind === 'array' ? context.element : context?.kind === 'any' ? ANY : null;
-        let element = expectedElement ?? NEVER;
-        for (const item of node.elements) {
-            let type;
-            if (item.kind === 'SpreadElement') {
-                const spread = this.checkValue(item.argument, expectedElement && arrayOf(expectedElement));
-                if (spread.kind === 'array')
-                    type = spread.element;
-                else if (spread.kind === 'any' || spread.kind === 'unknown')
-                    type = spread;
-                // JS spreads any iterable: a Set, a typed array, a `[]byte`.
-                else if (spread.kind === 'object' && spread.iterates)
-                    type = spread.iterates;
-                else {
-                    this.error(`cannot spread ${typeToString(spread)}: it is not an array or an iterable`, item.argument);
-                    type = UNKNOWN;
-                }
-            }
-            else {
-                type = this.checkValue(item, expectedElement);
-            }
-            if (expectedElement) {
-                this.expectAssignable(type, expectedElement, item.kind === 'SpreadElement' ? item.argument : item);
-            }
-            else {
-                element = commonType(element, type);
-            }
-        }
-        return arrayOf(element);
-    }
     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'
@@ -189,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 "../walk.js";
+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;
 }
@@ -96,18 +136,22 @@ export function isTerminating(node) {
         case 'IfStatement':
             return (node.alternate !== null && isTerminating(node.consequent) && isTerminating(node.alternate));
         case 'ForStatement':
-            return node.condition === null && !containsBreak(node.body.body);
+            return node.condition === null && !containsBreak(node.body.body, node.label ?? null);
         case 'SwitchStatement':
             return (node.cases.some((switchCase) => switchCase.tests.length === 0) &&
                 node.cases.every((switchCase) => {
                     const last = switchCase.body.at(-1);
-                    return last !== undefined && isTerminating(last) && !containsBreak(switchCase.body);
+                    return (last !== undefined &&
+                        isTerminating(last) &&
+                        !containsBreak(switchCase.body, node.label ?? null));
                 }));
         // A select runs one of its cases, waiting for one if there is no default.
         case 'SelectStatement':
             return node.cases.every((selectCase) => {
                 const last = selectCase.body.at(-1);
-                return last !== undefined && isTerminating(last) && !containsBreak(selectCase.body);
+                return (last !== undefined &&
+                    isTerminating(last) &&
+                    !containsBreak(selectCase.body, node.label ?? null));
             });
         case 'TryStatement':
             return ((isTerminating(node.block) && (!node.handler || isTerminating(node.handler.body))) ||

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`.