rooklang 0.0.0-stage → 0.3.1

package/dist/checker/control-flow.js

@@ -0,0 +1,237 @@
+import { assignedNames } from "../names.js";
+import { NARROWABLE } from "./context.js";
+import { narrowByTypeof, literalValue, withoutLiteral, withNarrowing, mergeFlows, leaves, } 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.
+export class ControlFlowChecker extends StatementChecker {
+    checkIf(node) {
+        this.checkCondition(node.condition);
+        const before = this.flow;
+        // Both are found from the flow before the `if`, not from the end of a branch.
+        const whenTrue = this.narrow(node.condition, true);
+        const whenFalse = this.narrow(node.condition, false);
+        this.flow = withNarrowing(before, whenTrue);
+        this.checkBlock(node.consequent.body);
+        const afterThen = this.flow;
+        this.flow = withNarrowing(before, whenFalse);
+        const { alternate } = node;
+        if (alternate?.kind === 'IfStatement')
+            this.checkIf(alternate);
+        else if (alternate)
+            this.checkBlock(alternate.body);
+        const afterElse = this.flow;
+        // A branch that always leaves (return, throw, break, continue) does not reach the code after
+        // the `if`, so `if x == null { return }` narrows `x` for the rest of the block.
+        const thenLeaves = leaves(node.consequent);
+        const elseLeaves = alternate !== null && leaves(alternate);
+        if (thenLeaves && !elseLeaves)
+            this.flow = afterElse;
+        else if (elseLeaves && !thenLeaves)
+            this.flow = afterThen;
+        else
+            this.flow = mergeFlows(afterThen, afterElse);
+    }
+    checkFor(node) {
+        this.withScope(() => {
+            if (node.init)
+                this.checkSimpleStatement(node.init);
+            // Variables assigned in the loop may change between iterations.
+            this.dropNarrowing(assignedNames(node));
+            const entry = this.flow;
+            if (node.condition)
+                this.checkCondition(node.condition);
+            this.flow = withNarrowing(entry, node.condition ? this.narrow(node.condition, true) : []);
+            this.checkBlock(node.body.body);
+            if (node.update)
+                this.checkSimpleStatement(node.update);
+            this.flow = entry;
+        });
+    }
+    checkSimpleStatement(node) {
+        this.checkStatement(node);
+    }
+    checkSwitch(node) {
+        const discriminant = node.discriminant ? this.checkValue(node.discriminant) : null;
+        this.dropNarrowing(assignedNames(node));
+        const entry = this.flow;
+        for (const switchCase of node.cases) {
+            this.flow = entry;
+            for (const test of switchCase.tests) {
+                if (discriminant === null) {
+                    this.checkCondition(test);
+                    continue;
+                }
+                const type = this.checkValue(test, discriminant);
+                if (!isComparable(type, discriminant)) {
+                    this.error(`cannot compare ${typeToString(discriminant)} with ${typeToString(type)}`, test);
+                }
+            }
+            const narrowing = discriminant === null
+                ? switchCase.tests.length === 1
+                    ? this.narrow(switchCase.tests[0], true)
+                    : []
+                : this.narrowCase(node, switchCase, entry);
+            this.flow = withNarrowing(entry, narrowing);
+            this.checkBlock(switchCase.body);
+        }
+        this.flow = entry;
+    }
+    /**
+     * `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)
+            return [];
+        const current = entry.get(binding) ?? binding.type;
+        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)))]];
+        }
+        let rest = current;
+        for (const other of node.cases) {
+            for (const test of other.tests) {
+                const value = literalValue(test);
+                if (value !== undefined)
+                    rest = withoutLiteral(rest, value);
+            }
+        }
+        return [[binding, rest]];
+    }
+    checkTry(node) {
+        this.dropNarrowing(assignedNames(node));
+        const entry = this.flow;
+        this.flow = new Map(entry);
+        this.checkBlock(node.block.body);
+        const { handler, finalizer } = node;
+        if (handler) {
+            this.flow = new Map(entry);
+            this.withScope(() => {
+                if (handler.param)
+                    this.declareValue(handler.param, 'catch', ANY);
+                this.checkStatementList(handler.body.body, false);
+            });
+        }
+        if (finalizer) {
+            this.flow = new Map(entry);
+            this.checkBlock(finalizer.body);
+        }
+        this.flow = entry;
+    }
+    checkCondition(node) {
+        const type = widenLiterals(this.checkValue(node, BOOL));
+        if (type.kind === 'bool' || type.kind === 'any' || type.kind === 'unknown')
+            return;
+        const hint = isNullable(type)
+            ? ': compare it with null, e.g. "x != null"'
+            : type.kind === 'number'
+                ? ': compare it, e.g. "n != 0"'
+                : type.kind === 'bigint'
+                    ? ': compare it, e.g. "n != 0n"'
+                    : type.kind === 'string'
+                        ? ': compare it, e.g. s != ""'
+                        : '';
+        this.error(`condition must be bool, not ${typeToString(type)}${hint}`, node);
+    }
+    /** Variables whose type is narrowed when `node` evaluates to `assumeTrue`. */
+    narrow(node, assumeTrue) {
+        if (node.kind === 'UnaryExpression' && node.operator === '!') {
+            return this.narrow(node.argument, !assumeTrue);
+        }
+        if (node.kind !== 'BinaryExpression')
+            return [];
+        const { operator, left, right } = node;
+        // `a && b` is true, or `a || b` is false: both sides hold, and the right one is narrowed in
+        // the flow that the left one gives.
+        if ((operator === '&&' && assumeTrue) || (operator === '||' && !assumeTrue)) {
+            const first = this.narrow(left, assumeTrue);
+            const saved = this.flow;
+            this.flow = withNarrowing(saved, first);
+            try {
+                return [...first, ...this.narrow(right, assumeTrue)];
+            }
+            finally {
+                this.flow = saved;
+            }
+        }
+        if (operator === '&&' || operator === '||')
+            return [];
+        // `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)]];
+        }
+        if (operator === 'instanceof')
+            return this.narrowInstanceof(left, right, assumeTrue);
+        if (operator !== '==' && operator !== '!=')
+            return [];
+        // Whether the comparison is found to give "equal".
+        const equal = (operator === '==') === assumeTrue;
+        // `typeof x == "string"`
+        const [check, tag] = left.kind === 'UnaryExpression' && left.operator === 'typeof'
+            ? [left, right]
+            : right.kind === 'UnaryExpression' && right.operator === 'typeof'
+                ? [right, left]
+                : [null, null];
+        if (check && tag?.kind === 'StringLiteral') {
+            const binding = this.narrowableBinding(check.argument);
+            if (!binding?.type)
+                return [];
+            const type = narrowByTypeof(this.flow.get(binding) ?? binding.type, tag.value, equal);
+            return type ? [[binding, 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)
+            return [];
+        const current = this.flow.get(binding) ?? binding.type;
+        if (!unionMembers(nonNull(current)).some((member) => member.kind === 'literal'))
+            return [];
+        return [[binding, 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 classType = this.typeOfChecked(right);
+        const instance = instanceTypeOf(classType);
+        if (!binding?.type || !instance)
+            return [];
+        const current = this.flow.get(binding) ?? binding.type;
+        const members = unionMembers(nonNull(current));
+        if (assumeTrue) {
+            const kept = members.filter((member) => isAssignable(member, instance));
+            return [[binding, 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)]];
+    }
+    narrowableBinding(node) {
+        if (node.kind !== 'Identifier')
+            return undefined;
+        const binding = this.lookupValue(node.name);
+        return binding && NARROWABLE.has(binding.kind) ? binding : undefined;
+    }
+    /** An assignment to a variable ends its narrowing. */
+    forget(target) {
+        const binding = this.narrowableBinding(target);
+        if (binding)
+            this.flow.delete(binding);
+    }
+    dropNarrowing(names) {
+        this.flow = new Map([...this.flow].filter(([binding]) => !names.has(binding.name)));
+    }
+}

package/dist/checker/declarations.d.ts

@@ -0,0 +1,26 @@
+import type * as ast from '../ast.ts';
+import { ImportChecker } from './imports.ts';
+import { type FunctionType, type ObjectType, type Type, type TypeParam } from './types.ts';
+export declare abstract class DeclarationChecker extends ImportChecker {
+    /**
+     * 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
+     * checked last, when every name of the list is known.
+     */
+    protected checkStatementList(statements: readonly ast.Statement[], topLevel: boolean): void;
+    protected declareStatements(statements: readonly ast.Statement[], topLevel: boolean): (() => void)[];
+    /** Members of an interface or object type: `name string; area() number`. */
+    protected fillMembers(object: ObjectType, members: readonly ast.TypeMember[]): void;
+    /** `[T any, U Shape]`: the parameters, with constraints resolved later by withTypeParams. */
+    protected createTypeParams(nodes: readonly ast.TypeParameter[]): TypeParam[];
+    /**
+     * Runs `check` in a scope where type parameters are types. With their declarations, it first
+     * resolves the constraints (`any` means none).
+     */
+    protected withTypeParams<T>(params: readonly TypeParam[], nodes: readonly ast.TypeParameter[] | null, check: () => T): T;
+    /** The type of a function; an async one returns a Promise of its results, and one whose
+     * parameter is `yield` is an iterator (iterators.ts). */
+    protected signature(params: readonly ast.Parameter[], results: readonly ast.TypeNode[], async?: boolean): FunctionType;
+    /** `Promise<...>` of the results of an async function, with the global `Promise` type. */
+    protected promiseOf(results: readonly Type[]): Type;
+}

package/dist/checker/declarations.js

@@ -0,0 +1,259 @@
+import { decorate, decoratorNames } from "../decorators.js";
+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 { 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 {
+    /**
+     * 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
+     * checked last, when every name of the list is known.
+     */
+    checkStatementList(statements, topLevel) {
+        const bodies = this.declareStatements(statements, topLevel);
+        for (const statement of statements)
+            this.checkStatement(statement);
+        for (const checkBody of bodies)
+            checkBody();
+    }
+    declareStatements(statements, topLevel) {
+        const classes = [];
+        const interfaces = [];
+        const functions = [];
+        const components = [];
+        const decorators = [];
+        for (const statement of statements) {
+            switch (statement.kind) {
+                case 'ImportDeclaration':
+                    this.declareImport(statement);
+                    break;
+                case 'ClassDeclaration': {
+                    const info = createClass(statement.name.name);
+                    info.typeParams = this.createTypeParams(statement.typeParams);
+                    this.declareType(statement.name, info.instance);
+                    this.declareValue(statement.name, 'class', info.value);
+                    classes.push([statement, info]);
+                    break;
+                }
+                case 'InterfaceDeclaration': {
+                    const object = {
+                        kind: 'object',
+                        name: statement.name.name,
+                        members: new Map(),
+                        call: null,
+                    };
+                    if (statement.typeParams.length > 0) {
+                        object.typeParams = this.createTypeParams(statement.typeParams);
+                    }
+                    this.declareType(statement.name, object);
+                    interfaces.push([statement, object]);
+                    break;
+                }
+                case 'TypeAliasDeclaration':
+                    this.declareType(statement.name, {
+                        kind: 'alias',
+                        node: statement,
+                        scope: this.scope,
+                        params: this.createTypeParams(statement.typeParams),
+                        resolved: null,
+                        resolving: false,
+                    });
+                    break;
+                case 'FuncDeclaration':
+                    functions.push([statement, this.declareValue(statement.name, 'function', null)]);
+                    break;
+                case 'ComponentDeclaration': {
+                    const info = {
+                        node: statement,
+                        props: new Map(),
+                        freeNames: null,
+                        isFunction: false,
+                        decorators: [],
+                        expanded: statement,
+                        result: null,
+                        root: null,
+                        inline: null,
+                        expressionTypes: null,
+                    };
+                    this.declareValue(statement.name, 'component', UNKNOWN).component = info;
+                    components.push(info);
+                    break;
+                }
+                case 'DecoratorDeclaration': {
+                    const name = statement.name.name;
+                    const info = {
+                        node: statement,
+                        params: [],
+                        members: new Map(),
+                        names: decoratorNames(statement),
+                        freeNames: null,
+                        wrapper: null,
+                        needed: [],
+                        moduleNames: [],
+                        expressionTypes: null,
+                        inline: null,
+                    };
+                    if (this.decorators.has(name)) {
+                        this.error(`the decorator @${name} is already declared`, statement.name);
+                    }
+                    else {
+                        this.decorators.set(name, info);
+                    }
+                    decorators.push(info);
+                    break;
+                }
+                case 'VariableDeclaration':
+                    // Top-level variables can be used in functions declared before them.
+                    if (topLevel) {
+                        for (const name of statement.names)
+                            this.declareValue(name, statement.keyword, null);
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+        for (const [node, object] of interfaces) {
+            this.withTypeParams(object.typeParams ?? [], node.typeParams, () => this.fillMembers(object, node.members));
+        }
+        for (const statement of statements) {
+            if (statement.kind !== 'TypeAliasDeclaration')
+                continue;
+            const entry = this.scope.types.get(statement.name.name);
+            if (entry?.kind === 'alias')
+                this.resolveAlias(entry);
+        }
+        for (const [node, binding] of functions) {
+            const typeParams = this.createTypeParams(node.typeParams);
+            binding.type = this.withTypeParams(typeParams, node.typeParams, () => ({
+                ...this.signature(node.params, node.results, node.async),
+                typeParams,
+            }));
+        }
+        for (const info of components)
+            this.resolveProps(info);
+        for (const info of decorators)
+            this.resolveDecoratorParams(info);
+        // Decorators of other modules use the names of those through hidden exports.
+        const sources = new Map([...this.decorators].map(([name, info]) => {
+            const moduleNames = this.importedDecorators.has(info) ? info.moduleNames : [];
+            return [name, { node: info.node, moduleNames }];
+        }));
+        for (const info of components) {
+            info.decorators = info.node.decorators.flatMap((use) => this.decorators.get(use.name.name) ?? []);
+            info.expanded = decorate(info.node, sources);
+        }
+        // The code of the decorators is part of the component: it may use components too.
+        const recursive = recursiveComponents(new Map(components.map((info) => [info.node.name.name, info.expanded])));
+        // A component used as a value is called by tags that take it from there.
+        const names = new Set(components.map((info) => info.node.name.name));
+        const values = new Set();
+        collectValueNames(this.program, values, (name) => names.has(name));
+        for (const info of components) {
+            // Other modules call an exported component, so it is a function in its own module too.
+            info.isFunction =
+                recursive.has(info.expanded) ||
+                    info.node.htmlTag !== null ||
+                    info.node.exported ||
+                    values.has(info.node.name.name);
+        }
+        for (const [node, info] of classes) {
+            this.unresolvedClasses.set(info, () => this.resolveClass(node, info));
+        }
+        for (const [, info] of classes)
+            this.ensureClassResolved(info);
+        const bodies = [];
+        for (const [node, binding] of functions) {
+            const type = binding.type;
+            // A nested `func` declaration is a JS `function`: it has no `this` of its own class.
+            bodies.push(() => this.withClass(null, () => this.checkFunction(node.params, type, type.results, node.body, { async: node.async })));
+        }
+        for (const [node, info] of classes)
+            bodies.push(() => this.checkClassBodies(node, info));
+        // Components use the types of the public members of decorators, and so do decorators that
+        // need them.
+        for (const info of this.orderByNeeds(decorators)) {
+            bodies.push(() => this.checkDecoratorBody(info));
+        }
+        for (const info of components)
+            bodies.push(() => this.checkComponentBody(info));
+        // The values of `style` are read once the markup exists: they see the whole body.
+        for (const style of statements.filter((node) => node.kind === 'StyleStatement')) {
+            bodies.push(() => this.checkStyle(style));
+        }
+        return bodies;
+    }
+    /** Members of an interface or object type: `name string; area() number`. */
+    fillMembers(object, members) {
+        for (const member of members) {
+            // `[string]: T`: the parser allows only string and number keys, which JS objects have.
+            if (member.kind === 'IndexSignature') {
+                object.index = this.resolveType(member.type);
+                continue;
+            }
+            if (object.members.has(member.name.name)) {
+                this.error(`duplicate member "${member.name.name}"`, member.name);
+            }
+            object.members.set(member.name.name, {
+                type: member.kind === 'PropertySignature'
+                    ? this.resolveType(member.type)
+                    : this.signature(member.params, member.results),
+                method: member.kind === 'MethodSignature',
+                visibility: 'public',
+                owner: null,
+            });
+        }
+    }
+    /** `[T any, U Shape]`: the parameters, with constraints resolved later by withTypeParams. */
+    createTypeParams(nodes) {
+        return nodes.map((node) => ({ kind: 'param', name: node.name.name, constraint: null }));
+    }
+    /**
+     * Runs `check` in a scope where type parameters are types. With their declarations, it first
+     * resolves the constraints (`any` means none).
+     */
+    withTypeParams(params, nodes, check) {
+        if (params.length === 0)
+            return check();
+        const saved = this.scope;
+        this.scope = new Scope(saved);
+        try {
+            for (const param of params)
+                this.scope.types.set(param.name, param);
+            nodes?.forEach((node, i) => {
+                if (!node.constraint)
+                    return;
+                const constraint = this.resolveType(node.constraint);
+                params[i].constraint = constraint.kind === 'any' ? null : constraint;
+            });
+            return check();
+        }
+        finally {
+            this.scope = saved;
+        }
+    }
+    /** The type of a function; an async one returns a Promise of its results, and one whose
+     * parameter is `yield` is an iterator (iterators.ts). */
+    signature(params, results, async = false) {
+        const types = results.map((result) => this.resolveType(result));
+        if (async) {
+            types.forEach((type, i) => {
+                if (!isPromise(type))
+                    return;
+                this.error(`an async function declares what its Promise gives: write "${typeToString(awaited(type))}", not "${typeToString(type)}"`, results[i]);
+                types[i] = awaited(type);
+            });
+        }
+        return func(params.map((param) => (param.type ? this.resolveType(param.type) : UNKNOWN)), async ? [this.promiseOf(types)] : types, { iterator: isIterator(params) });
+    }
+    /** `Promise<...>` of the results of an async function, with the global `Promise` type. */
+    promiseOf(results) {
+        const entry = this.globals.types.get('Promise') ?? this.options.library?.type('Promise');
+        return promiseOf(entry?.kind === 'alias' ? undefined : entry, results);
+    }
+}

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

@@ -0,0 +1,5 @@
+import type { DecoratorInfo } from './context.ts';
+import { DecoratorWrapperChecker } from './decorator-wrappers.ts';
+export declare abstract class DecoratorExportChecker extends DecoratorWrapperChecker {
+    protected checkExportedDecorator(info: DecoratorInfo): void;
+}

package/dist/checker/decorator-exports.js

@@ -0,0 +1,40 @@
+import { moduleNamesOf } from "../decorators.js";
+import { assignedNames, componentValues } from "../names.js";
+import { DecoratorWrapperChecker } from "./decorator-wrappers.js";
+// Exported decorators, `export dec visible() { ... }`. Other modules inline their code, which uses
+// the names of this module through hidden exports, `export { log as $$visible$log }`; so the code
+// must work from there.
+export class DecoratorExportChecker extends DecoratorWrapperChecker {
+    checkExportedDecorator(info) {
+        const { node } = info;
+        const name = node.name.name;
+        info.moduleNames = moduleNamesOf(node, this.program);
+        info.expressionTypes = this.checkedTypes;
+        // A module that applies it applies those it needs too, so it must be able to import them.
+        for (const needed of info.needed) {
+            const other = needed.node.name.name;
+            if (needed.node.exported)
+                continue;
+            this.error(`@${name} is exported, so @${other} that it needs must be exported too: export dec ${other}(...)`, node.needs.find((need) => need.name === other) ?? node.name);
+        }
+        // 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 (!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);
+        }
+        // Its code goes into components elsewhere with the components of this module that it uses.
+        info.inline = this.modulePackages().decorators.get(name) ?? null;
+        const [value] = componentValues(node, (other) => this.lookupValue(other)?.component !== undefined);
+        if (value !== undefined) {
+            this.error(`@${name} is exported, so its code cannot use the component ${value} of its module as a value yet: use it as a tag, <${value} />`, node.name);
+        }
+        else if (info.inline === null) {
+            this.error(`@${name} is exported, so its code goes into other modules with the components it uses: they cannot use components or decorators that this module imports yet, nor assign variables of this module`, node.name);
+        }
+        // The type of what its wrapper gives: the tags of its markup are names of this module.
+        if (info.wrapper)
+            info.wrapper.result = this.wrapperResult(info.wrapper, new Set());
+    }
+}

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

@@ -0,0 +1,28 @@
+import type * as ast from '../ast.ts';
+import type { DecoratorInfo, PublicMember } from './context.ts';
+import { DecoratorChecker } from './decorators.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`. */
+    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`. */
+    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.
+     */
+    protected checkDecoratorWrite(target: ast.Expression): boolean;
+    /** `get(@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. */
+    protected decoratorWithoutAt(node: ast.MemberExpression): boolean;
+}