rooklang 0.3.3 → 0.4.0

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 = {
@@ -64,6 +66,8 @@ export interface CheckResult {
     declarations: ModuleExports;
     /** Types of checked expressions, for code generation (e.g. how to insert element children). */
     types: WeakMap<ast.Expression, Type>;
+    /** The data classes that the module declares or imports, by their names here. */
+    dataClasses: Set<string>;
     /** With the `completion` option: what can be written at the cursor, if the check reached it. */
     completion?: CompletionResult;
 }
@@ -78,6 +82,17 @@ export interface Completion {
     kind: 'variable' | 'constant' | 'function' | 'class' | 'component' | 'type' | 'property' | 'method' | 'keyword' | 'tag' | 'attribute';
     /** The type, as Rook writes it. */
     detail?: string;
+    /** A name exported by another module of the package: choosing it imports it (auto-import.ts). */
+    import?: {
+        specifier: string;
+        edit: TextEdit;
+    };
+}
+/** A change of the text of a module: what is between the offsets becomes `text`. */
+export interface TextEdit {
+    start: number;
+    end: number;
+    text: string;
 }
 export type BindingKind = 'let' | 'const' | 'state' | 'derived' | 'ref' | 'param' | 'prop' | 'function' | 'class' | 'import' | 'loop' | 'catch' | 'builtin' | 'component';
 export interface Binding {
@@ -87,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).
@@ -100,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;
@@ -147,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.
@@ -157,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';
@@ -192,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,25 +1,31 @@
 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;
     protected checkFor(node: ast.ForStatement): void;
     protected checkSimpleStatement(node: ast.SimpleStatement): void;
+    /**
+     * `if const v = f(); v > 0 { }`: the variables of the initializer are in a scope of their own,
+     * around every branch. Returns whether `check` checked the statement inside it.
+     */
+    private checkWithInit;
     protected checkSwitch(node: ast.SwitchStatement): void;
     /**
      * `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,12 +1,15 @@
-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 })))
+            return;
         this.checkCondition(node.condition);
         const before = this.flow;
         // Both are found from the flow before the `if`, not from the end of a branch.
@@ -37,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);
@@ -52,9 +55,24 @@ export class ControlFlowChecker extends StatementChecker {
     checkSimpleStatement(node) {
         this.checkStatement(node);
     }
+    /**
+     * `if const v = f(); v > 0 { }`: the variables of the initializer are in a scope of their own,
+     * around every branch. Returns whether `check` checked the statement inside it.
+     */
+    checkWithInit(init, check) {
+        if (init === null)
+            return false;
+        this.withScope(() => {
+            this.checkStatement(init);
+            check();
+        });
+        return true;
+    }
     checkSwitch(node) {
+        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;
@@ -72,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);
         }
@@ -82,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) {
@@ -103,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);
@@ -140,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);
@@ -166,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);
@@ -191,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;
@@ -242,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
@@ -34,6 +34,7 @@ export class DeclarationChecker extends ImportChecker {
                     break;
                 case 'ClassDeclaration': {
                     const info = createClass(statement.name.name);
+                    info.data = statement.data;
                     info.typeParams = this.createTypeParams(statement.typeParams);
                     this.declareType(statement.name, info.instance);
                     this.declareValue(statement.name, 'class', info.value);
@@ -94,6 +95,7 @@ export class DeclarationChecker extends ImportChecker {
                         freeNames: null,
                         wrapper: null,
                         needed: [],
+                        included: [],
                         moduleNames: [],
                         expressionTypes: null,
                         inline: null,

package/dist/checker/decode.d.ts

@@ -0,0 +1,8 @@
+import type * as ast from '../ast.ts';
+import { TopicChecker } from './topics.ts';
+import { type Type } from './types.ts';
+export declare abstract class DecodeChecker extends TopicChecker {
+    protected checkDecode(node: ast.DecodeExpression): Type;
+    /** Why decode cannot take a value of the type: it is neither JSON text nor a value from JS. */
+    private notDecodable;
+}

package/dist/checker/decode.js

@@ -0,0 +1,32 @@
+import { isUntyped } from "./helpers.js";
+import { TopicChecker } from "./topics.js";
+import { isText, notDecoded } from "./json.js";
+import { ERROR, typedArrayOf, typeToString } from "./types.js";
+// `decode<User>(body)`: the types are erased, so only the compiler knows what a User is. It writes
+// the type into the JS as data (codegen/decode.ts), and the runtime checks JSON text, or a value
+// from JS, against it when the program runs (runtime/decode.js). So the type must be one that JSON
+// can hold (json.ts). The argument is JSON text if it is a string, and a value from JS if it is any.
+export class DecodeChecker extends TopicChecker {
+    checkDecode(node) {
+        const type = this.resolveType(node.type);
+        const reason = notDecoded(type);
+        if (reason !== null)
+            this.error(`cannot decode ${typeToString(type)}: ${reason}`, node.type);
+        const argument = this.checkValue(node.argument);
+        if (!isUntyped(argument) && !isText(argument)) {
+            this.error(this.notDecodable(argument), node.argument);
+        }
+        return { kind: 'tuple', types: [type, ERROR] };
+    }
+    /** Why decode cannot take a value of the type: it is neither JSON text nor a value from JS. */
+    notDecodable(type) {
+        const prefix = `decode takes JSON text, a string, or a value of type any from JS, not ${typeToString(type)}`;
+        if (type.kind === 'nullable' && isText(type.type)) {
+            return `${prefix}: the text may be null, so check it first, e.g. "if text != null"`;
+        }
+        if (type.kind === 'object' && (typedArrayOf(type) === 'Uint8Array' || type.name === 'Buffer')) {
+            return `${prefix}: make the text of the bytes first, e.g. decode<User>(string(data))`;
+        }
+        return `${prefix}; its type is known already`;
+    }
+}

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. */