rooklang 0.3.4 → 0.4.1

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);

package/dist/checker/context.d.ts

@@ -11,6 +11,8 @@ export interface ModuleExports {
     decorators?: Map<string, DecoratorInfo>;
     /** `export comp`: components are used as tags, not as values. */
     components?: Map<string, ComponentInfo>;
+    /** `export state`: other modules read it, and change it only with the functions of its module. */
+    shared?: Set<string>;
 }
 /** What `importModule` found: the module's exports, an error for the import, or nothing (untyped). */
 export type ImportResult = {
@@ -100,6 +102,8 @@ export interface Binding {
     type: Type | null;
     /** For components, which exist only at compile time and are used as tags. */
     component?: ComponentInfo;
+    /** State of another module, `state items` there, which is read-only here: its module's path. */
+    shared?: string;
     /**
      * `const user, err = loadUser(id)` of `(User, error)`: the error has the values that are not null
      * once it is null, and each of them has the error (error-results.ts).
@@ -113,6 +117,7 @@ export interface ComponentInfo {
     props: Map<string, {
         type: Type;
         optional: boolean;
+        bind?: true;
     }>;
     /** Names from the module that the component's code uses, computed when first needed. */
     freeNames: Set<string> | null;
@@ -160,6 +165,8 @@ export interface DecoratorInfo {
     } | null;
     /** The decorators after `needs` that exist; they are applied above it. */
     needed: DecoratorInfo[];
+    /** The decorators after `includes` that exist: applied with it, above its own body. */
+    included: DecoratorInfo[];
     /**
      * For an exported decorator: the names of its module that its code uses, which other modules get
      * through hidden exports, and the types of its expressions, for the code generator there.
@@ -170,9 +177,15 @@ export interface DecoratorInfo {
     inline: InlinePackage | null;
 }
 export interface PublicMember {
-    kind: 'state' | 'derived' | 'const' | 'func';
+    kind: 'state' | 'derived' | 'const' | 'ref' | 'func';
     type: Type;
 }
+/**
+ * The decorators applied with those they include, which come before them: `@shop` of
+ * `dec shop() includes visible, cart` gives visible, cart, shop. A cycle of includes is reported
+ * where the decorators are declared; here it stops.
+ */
+export declare function withIncluded(decorators: readonly DecoratorInfo[], seen?: ReadonlySet<DecoratorInfo>): DecoratorInfo[];
 /** A `type` alias, resolved when first used. */
 export interface AliasEntry {
     kind: 'alias';
@@ -205,11 +218,21 @@ export interface ClassContext {
     isStatic: boolean;
 }
 /**
- * Types of variables narrowed by the code before the current point, e.g. `?User` → `User`
- * after `if user == null { return }`.
+ * A variable, or a path of data fields from it that is narrowed like one: `order.delivery` is the
+ * binding of `order` with the path `"delivery"`. The path of the variable itself is empty.
+ */
+export interface Place {
+    binding: Binding;
+    path: string;
+}
+/** The same object for the same variable and path, so that it is a key of a `Flow`. */
+export declare function placeOf(binding: Binding, path?: string): Place;
+/**
+ * Types of variables and paths narrowed by the code before the current point, e.g. `?User` →
+ * `User` after `if user == null { return }`.
  */
-export type Flow = Map<Binding, Type>;
-export type Narrowing = [Binding, Type][];
+export type Flow = Map<Place, Type>;
+export type Narrowing = [Place, Type][];
 export declare const NARROWABLE: ReadonlySet<BindingKind>;
 /** Built-in globals. With a library, the untyped ones and the DOM types come from it instead. */
 export declare function globalScope(library: Library | undefined): Scope;

package/dist/checker/context.js

@@ -1,5 +1,13 @@
 import { GLOBAL_TYPES, GLOBAL_VALUES, LIBRARY_TYPES } from "./builtins.js";
 import {} from "./types.js";
+/**
+ * The decorators applied with those they include, which come before them: `@shop` of
+ * `dec shop() includes visible, cart` gives visible, cart, shop. A cycle of includes is reported
+ * where the decorators are declared; here it stops.
+ */
+export function withIncluded(decorators, seen = new Set()) {
+    return decorators.flatMap((each) => seen.has(each) ? [] : [...withIncluded(each.included, new Set([...seen, each])), each]);
+}
 export class Scope {
     parent;
     values = new Map();
@@ -8,6 +16,21 @@ export class Scope {
         this.parent = parent;
     }
 }
+const places = new WeakMap();
+/** The same object for the same variable and path, so that it is a key of a `Flow`. */
+export function placeOf(binding, path = '') {
+    let byPath = places.get(binding);
+    if (!byPath) {
+        byPath = new Map();
+        places.set(binding, byPath);
+    }
+    let place = byPath.get(path);
+    if (!place) {
+        place = { binding, path };
+        byPath.set(path, place);
+    }
+    return place;
+}
 export const NARROWABLE = new Set([
     'let',
     'const',

package/dist/checker/control-flow.d.ts

@@ -1,5 +1,5 @@
 import type * as ast from '../ast.ts';
-import { type Binding, type Flow, type Narrowing } from './context.ts';
+import { type Binding, type Narrowing } from './context.ts';
 import { StatementChecker } from './statements.ts';
 export declare abstract class ControlFlowChecker extends StatementChecker {
     protected checkIf(node: ast.IfStatement): void;
@@ -15,16 +15,17 @@ export declare abstract class ControlFlowChecker extends StatementChecker {
      * `switch filter { case "all": ... default: ... }`: in a case the discriminant has the literals
      * of its tests, in `default` the literals of no case.
      */
-    protected narrowCase(node: ast.SwitchStatement, switchCase: ast.SwitchCase, entry: Flow): Narrowing;
+    protected narrowCase(node: ast.SwitchStatement, switchCase: ast.SwitchCase): Narrowing;
     protected checkTry(node: ast.TryStatement): void;
     protected checkCondition(node: ast.Expression): void;
-    /** Variables whose type is narrowed when `node` evaluates to `assumeTrue`. */
+    /** Variables and paths whose type is narrowed when `node` evaluates to `assumeTrue`. */
     protected narrow(node: ast.Expression, assumeTrue: boolean): Narrowing;
     /** `x instanceof Date`: an instance of the class when true, the rest of a union when false. */
     protected narrowInstanceof(left: ast.Expression, right: ast.Expression, assumeTrue: boolean): Narrowing;
     protected nullError(node: ast.Expression): void;
     protected narrowableBinding(node: ast.Expression): Binding | undefined;
-    /** An assignment to a variable ends its narrowing. */
+    /** An assignment to a variable ends its narrowing; one to a path, that of the paths it changes. */
     protected forget(target: ast.Expression): void;
-    protected dropNarrowing(names: ReadonlySet<string>): void;
+    /** Ends the narrowing of what `node` assigns: before a loop, or a statement with several ways. */
+    protected dropNarrowing(node: ast.Node): void;
 }

package/dist/checker/control-flow.js

@@ -1,10 +1,11 @@
-import { assignedNames } from "../names.js";
-import { NARROWABLE } from "./context.js";
-import { narrowByTypeof, literalValue, withoutLiteral, withNarrowing, mergeFlows, leaves, } from "./flow.js";
+import { assignedNames, assignedPaths, pathOf } from "../names.js";
+import { NARROWABLE, placeOf } from "./context.js";
+import { narrowByTypeof, literalValue, withoutLiteral, withNarrowing, mergeFlows, leaves, forgetWritten, withoutAssigned, } from "./flow.js";
 import { instanceTypeOf } from "./helpers.js";
 import { StatementChecker } from "./statements.js";
 import { ANY, BOOL, isAssignable, isComparable, isNullable, isSubclass, literal, nonNull, NULL, typeToString, union, unionMembers, widenLiterals, } from "./types.js";
-// if, for, switch and try, and how conditions narrow the types of variables in the branches.
+// if, for, switch and try, and how conditions narrow the types of variables and paths in the
+// branches.
 export class ControlFlowChecker extends StatementChecker {
     checkIf(node) {
         if (this.checkWithInit(node.init, () => this.checkIf({ ...node, init: null })))
@@ -39,8 +40,8 @@ export class ControlFlowChecker extends StatementChecker {
         this.withScope(() => {
             if (node.init)
                 this.checkSimpleStatement(node.init);
-            // Variables assigned in the loop may change between iterations.
-            this.dropNarrowing(assignedNames(node));
+            // Variables and paths assigned in the loop may change between iterations.
+            this.dropNarrowing(node);
             const entry = this.flow;
             if (node.condition)
                 this.checkCondition(node.condition);
@@ -71,7 +72,7 @@ export class ControlFlowChecker extends StatementChecker {
         if (this.checkWithInit(node.init, () => this.checkSwitch({ ...node, init: null })))
             return;
         const discriminant = node.discriminant ? this.checkValue(node.discriminant) : null;
-        this.dropNarrowing(assignedNames(node));
+        this.dropNarrowing(node);
         const entry = this.flow;
         for (const switchCase of node.cases) {
             this.flow = entry;
@@ -89,7 +90,7 @@ export class ControlFlowChecker extends StatementChecker {
                 ? switchCase.tests.length === 1
                     ? this.narrow(switchCase.tests[0], true)
                     : []
-                : this.narrowCase(node, switchCase, entry);
+                : this.narrowCase(node, switchCase);
             this.flow = withNarrowing(entry, narrowing);
             this.checkBlock(switchCase.body);
         }
@@ -99,18 +100,18 @@ export class ControlFlowChecker extends StatementChecker {
      * `switch filter { case "all": ... default: ... }`: in a case the discriminant has the literals
      * of its tests, in `default` the literals of no case.
      */
-    narrowCase(node, switchCase, entry) {
-        const binding = node.discriminant ? this.narrowableBinding(node.discriminant) : undefined;
-        if (!binding?.type)
+    narrowCase(node, switchCase) {
+        const target = node.discriminant ? this.narrowable(node.discriminant) : undefined;
+        if (!target)
             return [];
-        const current = entry.get(binding) ?? binding.type;
+        const { place, type: current } = target;
         if (!unionMembers(nonNull(current)).some((member) => member.kind === 'literal'))
             return [];
         if (switchCase.tests.length > 0) {
             const values = switchCase.tests.map(literalValue);
             if (values.some((value) => value === undefined))
                 return [];
-            return [[binding, union(values.map((value) => literal(value)))]];
+            return [[place, union(values.map((value) => literal(value)))]];
         }
         let rest = current;
         for (const other of node.cases) {
@@ -120,10 +121,10 @@ export class ControlFlowChecker extends StatementChecker {
                     rest = withoutLiteral(rest, value);
             }
         }
-        return [[binding, rest]];
+        return [[place, rest]];
     }
     checkTry(node) {
-        this.dropNarrowing(assignedNames(node));
+        this.dropNarrowing(node);
         const entry = this.flow;
         this.flow = new Map(entry);
         this.checkBlock(node.block.body);
@@ -157,7 +158,7 @@ export class ControlFlowChecker extends StatementChecker {
                         : '';
         this.error(`condition must be bool, not ${typeToString(type)}${hint}`, node);
     }
-    /** Variables whose type is narrowed when `node` evaluates to `assumeTrue`. */
+    /** Variables and paths whose type is narrowed when `node` evaluates to `assumeTrue`. */
     narrow(node, assumeTrue) {
         if (node.kind === 'UnaryExpression' && node.operator === '!') {
             return this.narrow(node.argument, !assumeTrue);
@@ -183,17 +184,21 @@ export class ControlFlowChecker extends StatementChecker {
         // `x != null` when true, `x == null` when false: `x` is not null.
         if ((operator === '!=' && assumeTrue) || (operator === '==' && !assumeTrue)) {
             const target = right.kind === 'NullLiteral' ? left : left.kind === 'NullLiteral' ? right : null;
-            const binding = target ? this.narrowableBinding(target) : undefined;
-            if (binding?.type)
-                return [[binding, nonNull(this.flow.get(binding) ?? binding.type)]];
+            const found = target ? this.narrowable(target) : undefined;
+            if (found)
+                return [[found.place, nonNull(found.type)]];
         }
         // `err == null` when true, `err != null` when false: the values returned with `err` are not
         // null (error-results.ts).
         if ((operator === '==' && assumeTrue) || (operator === '!=' && !assumeTrue)) {
             const target = right.kind === 'NullLiteral' ? left : left.kind === 'NullLiteral' ? right : null;
             const guards = target ? this.narrowableBinding(target)?.guards : undefined;
-            if (guards)
-                return guards.map((value) => [value, nonNull(this.flow.get(value) ?? value.type)]);
+            if (guards) {
+                return guards.map((value) => {
+                    const place = placeOf(value);
+                    return [place, nonNull(this.flow.get(place) ?? value.type)];
+                });
+            }
         }
         if (operator === 'instanceof')
             return this.narrowInstanceof(left, right, assumeTrue);
@@ -208,41 +213,41 @@ export class ControlFlowChecker extends StatementChecker {
                 ? [right, left]
                 : [null, null];
         if (check && tag?.kind === 'StringLiteral') {
-            const binding = this.narrowableBinding(check.argument);
-            if (!binding?.type)
+            const found = this.narrowable(check.argument);
+            if (!found)
                 return [];
-            const type = narrowByTypeof(this.flow.get(binding) ?? binding.type, tag.value, equal);
-            return type ? [[binding, type]] : [];
+            const type = narrowByTypeof(found.type, tag.value, equal);
+            return type ? [[found.place, type]] : [];
         }
         // `filter == "all"`: narrows a type with literals in it.
         const value = literalValue(right) ?? literalValue(left);
         const target = literalValue(right) !== undefined ? left : right;
-        const binding = value === undefined ? undefined : this.narrowableBinding(target);
-        if (value === undefined || !binding?.type)
+        const found = value === undefined ? undefined : this.narrowable(target);
+        if (value === undefined || !found)
             return [];
-        const current = this.flow.get(binding) ?? binding.type;
+        const { place, type: current } = found;
         if (!unionMembers(nonNull(current)).some((member) => member.kind === 'literal'))
             return [];
-        return [[binding, equal ? literal(value) : withoutLiteral(current, value)]];
+        return [[place, equal ? literal(value) : withoutLiteral(current, value)]];
     }
     /** `x instanceof Date`: an instance of the class when true, the rest of a union when false. */
     narrowInstanceof(left, right, assumeTrue) {
-        const binding = this.narrowableBinding(left);
+        const found = this.narrowable(left);
         const classType = this.typeOfChecked(right);
         const instance = instanceTypeOf(classType);
-        if (!binding?.type || !instance)
+        if (!found || !instance)
             return [];
-        const current = this.flow.get(binding) ?? binding.type;
+        const { place, type: current } = found;
         const members = unionMembers(nonNull(current));
         if (assumeTrue) {
             const kept = members.filter((member) => isAssignable(member, instance));
-            return [[binding, kept.length > 0 ? union(kept) : instance]];
+            return [[place, kept.length > 0 ? union(kept) : instance]];
         }
         // A class keeps what is not its subclass; a DOM interface what is not assignable to it.
         const kept = members.filter((member) => classType.kind === 'classValue'
             ? !(member.kind === 'class' && isSubclass(member.info, classType.info))
             : !isAssignable(member, instance));
-        return [[binding, union(isNullable(current) ? [...kept, NULL] : kept)]];
+        return [[place, union(isNullable(current) ? [...kept, NULL] : kept)]];
     }
     nullError(node) {
         const name = node.kind === 'Identifier' ? node.name : null;
@@ -259,13 +264,16 @@ export class ControlFlowChecker extends StatementChecker {
         const binding = this.lookupValue(node.name);
         return binding && NARROWABLE.has(binding.kind) ? binding : undefined;
     }
-    /** An assignment to a variable ends its narrowing. */
+    /** An assignment to a variable ends its narrowing; one to a path, that of the paths it changes. */
     forget(target) {
-        const binding = this.narrowableBinding(target);
-        if (binding)
-            this.flow.delete(binding);
+        const path = pathOf(target);
+        const binding = path ? this.lookupValue(path[0]) : undefined;
+        if (path && binding && NARROWABLE.has(binding.kind)) {
+            forgetWritten(this.flow, binding, path.slice(1).join('.'), (place, field) => this.isTagOf(place, field));
+        }
     }
-    dropNarrowing(names) {
-        this.flow = new Map([...this.flow].filter(([binding]) => !names.has(binding.name)));
+    /** Ends the narrowing of what `node` assigns: before a loop, or a statement with several ways. */
+    dropNarrowing(node) {
+        this.flow = withoutAssigned(this.flow, assignedNames(node), assignedPaths(node), (place, field) => this.isTagOf(place, field));
     }
 }

package/dist/checker/declarations.d.ts

@@ -1,7 +1,7 @@
 import type * as ast from '../ast.ts';
-import { ImportChecker } from './imports.ts';
+import { SharedStateChecker } from './shared-state.ts';
 import { type FunctionType, type ObjectType, type Type, type TypeParam } from './types.ts';
-export declare abstract class DeclarationChecker extends ImportChecker {
+export declare abstract class DeclarationChecker extends SharedStateChecker {
     /**
      * Declares the names of a statement list first (so functions, classes and types can be used
      * before their declaration), then checks the statements in order. Function and method bodies are

package/dist/checker/declarations.js

@@ -3,12 +3,12 @@ import { isIterator } from "../iterators.js";
 import { collectValueNames } from "../names.js";
 import { recursiveComponents } from "../recursion.js";
 import { Scope } from "./context.js";
-import { ImportChecker } from "./imports.js";
+import { SharedStateChecker } from "./shared-state.js";
 import { awaited, isPromise, promiseOf } from "./promise.js";
 import { createClass, func, typeToString, UNKNOWN, } from "./types.js";
 // Declarations of a list of statements: imports, types, functions, components, decorators and
 // classes, declared before the statements are checked, so that they can refer to each other.
-export class DeclarationChecker extends ImportChecker {
+export class DeclarationChecker extends SharedStateChecker {
     /**
      * Declares the names of a statement list first (so functions, classes and types can be used
      * before their declaration), then checks the statements in order. Function and method bodies are
@@ -95,6 +95,7 @@ export class DeclarationChecker extends ImportChecker {
                         freeNames: null,
                         wrapper: null,
                         needed: [],
+                        included: [],
                         moduleNames: [],
                         expressionTypes: null,
                         inline: null,

package/dist/checker/decorator-exports.js

@@ -20,6 +20,10 @@ export class DecoratorExportChecker extends DecoratorWrapperChecker {
         // Other modules can read the variables of this one, but not assign them.
         const assigned = assignedNames(node.body);
         for (const used of info.moduleNames) {
+            if (this.moduleScope.values.get(used)?.kind === 'state') {
+                this.error(`@${name} is exported, so its code cannot read "${used}", state of its module, yet: read it in a component of the module and pass it to @${name} as an argument`, node.name);
+                continue;
+            }
             if (!assigned.has(used))
                 continue;
             this.error(`@${name} is exported, so it cannot change "${used}" of its module: other modules can only read it; change it in a function of the module`, node.name);

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

@@ -0,0 +1,9 @@
+import type { DecoratorInfo } from './context.ts';
+import { DecoratorChecker } from './decorators.ts';
+export declare abstract class DecoratorIncludeChecker extends DecoratorChecker {
+    protected resolveDecoratorParams(info: DecoratorInfo): void;
+    /** The decorators it includes are checked before it: see orderByNeeds. */
+    protected checkDecoratorBody(info: DecoratorInfo): void;
+    /** The public members of the decorators it includes become its own; each name comes once. */
+    private addIncludedMembers;
+}

package/dist/checker/decorator-includes.js

@@ -0,0 +1,71 @@
+import { DecoratorChecker } from "./decorators.js";
+import { UNKNOWN } from "./types.js";
+// Decorators that include others, `dec shop(margin string) includes visible(margin), cart { ... }`:
+// those are applied with it, above its own body, their arguments see its parameters, and their
+// public members are its own for the component, `@shop.count`.
+export class DecoratorIncludeChecker extends DecoratorChecker {
+    resolveDecoratorParams(info) {
+        super.resolveDecoratorParams(info);
+        const { node } = info;
+        const current = node.name.name;
+        const included = new Set();
+        for (const use of node.includes) {
+            const name = use.name.name;
+            const other = this.decorators.get(name);
+            if (name === current)
+                this.error(`@${name} cannot include itself`, use.name);
+            else if (included.has(name))
+                this.error(`@${name} is included twice: name it once`, use.name);
+            else if (node.needs.some((need) => need.name === name)) {
+                this.error(`@${current} both needs and includes @${name}: includes is enough`, use.name);
+            }
+            else if (!other)
+                this.error(`unknown decorator @${name}`, use.name);
+            else
+                info.included.push(other);
+            included.add(name);
+        }
+    }
+    /** The decorators it includes are checked before it: see orderByNeeds. */
+    checkDecoratorBody(info) {
+        super.checkDecoratorBody(info);
+        const { node } = info;
+        const params = node.params.map((param, i) => [
+            param.name,
+            info.params[i] ?? UNKNOWN,
+        ]);
+        for (const use of node.includes) {
+            const included = this.decorators.get(use.name.name);
+            if (included)
+                this.checkDecoratorArguments(use, included, params);
+        }
+        this.addIncludedMembers(info);
+        // A module that applies it would need the code of those it includes too.
+        if (node.exported && node.includes.length > 0) {
+            const names = node.includes.map((use) => `@${use.name.name}`).join(' ');
+            this.error(`@${node.name.name} is exported, so it cannot include decorators yet: apply them before it, e.g. ${names} @${node.name.name} comp ...`, node.includes[0]);
+        }
+    }
+    /** The public members of the decorators it includes become its own; each name comes once. */
+    addIncludedMembers(info) {
+        const current = info.node.name.name;
+        const from = new Map();
+        for (const included of info.included) {
+            const name = included.node.name.name;
+            const use = info.node.includes.find((each) => each.name.name === name);
+            for (const [member, found] of included.members) {
+                const other = from.get(member);
+                if (other !== undefined) {
+                    this.error(`@${current} gets "${member}" from both @${other} and @${name}: rename one of them`, use);
+                }
+                else if (info.members.has(member)) {
+                    this.error(`@${current} declares "${member}", which it also gets from @${name}: rename one of them`, use);
+                }
+                else {
+                    info.members.set(member, found);
+                    from.set(member, name);
+                }
+            }
+        }
+    }
+}

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

@@ -1,26 +1,24 @@
 import type * as ast from '../ast.ts';
-import type { DecoratorInfo, PublicMember } from './context.ts';
-import { DecoratorChecker } from './decorators.ts';
+import { type DecoratorInfo, type PublicMember } from './context.ts';
+import { DecoratorIncludeChecker } from './decorator-includes.ts';
 import { type Type } from './types.ts';
-export declare abstract class DecoratorMemberChecker extends DecoratorChecker {
-    /** `@visible.show`: a public function; state and constants are read with `get`. */
+export declare abstract class DecoratorMemberChecker extends DecoratorIncludeChecker {
+    /** `@visible.shown` or `@visible.show`: public state, a constant or a function. */
     protected checkDecoratorMember(node: ast.DecoratorMember): Type;
-    /** `get(@visible.shown)`: public state or a constant. */
-    protected checkDecoratorGet(node: ast.DecoratorGet): Type;
     /**
      * A public member of a decorator applied to the component being checked, or of one that the
      * decorator being checked needs.
      */
     protected findDecoratorMember(node: ast.DecoratorMember): PublicMember | null;
-    /** `get(@cart.count)` in `dec cartBadge() needs cart`. */
+    /** `@cart.count` in `dec cartBadge() needs cart`. */
     protected neededMember(node: ast.DecoratorMember, decorator: ast.DecoratorDeclaration): PublicMember | null;
     protected publicMember(node: ast.DecoratorMember, info: DecoratorInfo): PublicMember | 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.
      */
     protected checkDecoratorWrite(target: ast.Expression): boolean;
-    /** `get(@cart.items).push(x)`: a method that changes the array. */
+    /** `@cart.items.push(x)`: a method that changes the array. */
     protected checkDecoratorMutation(node: ast.CallExpression): void;
     protected readOnlyError(member: ast.DecoratorMember, node: ast.NodeBase): void;
     /** `card.count` without `@`: `card` is not a value, but a decorator may have that name. */