rooklang 0.0.0-stage → 0.3.0

package/dist/checker/markup.d.ts

@@ -0,0 +1,28 @@
+import type * as ast from '../ast.ts';
+import { OperatorChecker } from './operators.ts';
+import { type Type } from './types.ts';
+export declare abstract class MarkupChecker extends OperatorChecker {
+    /** A tag that takes its component from a value; implemented by ComponentValueChecker. */
+    protected abstract checkValueTagUse(node: ast.ElementExpression, tag: ast.Identifier, value: ast.Expression): Type;
+    /** Whether the markup being checked is inside `<svg>`: its elements are SVG then. */
+    private inSvg;
+    /** The type of the element `<tag>` creates; outside markup, SVG only for SVG's own tags. */
+    protected elementOf(tag: string, svg?: boolean): Type;
+    protected checkElement(node: ast.ElementExpression): Type;
+    protected checkChildren(children: readonly ast.JsxChild[]): void;
+    protected checkAttribute(attribute: ast.JsxAttribute, tag: string, element: Type, svg?: boolean): void;
+    /**
+     * `bind:value={name}`: the element shows the variable, and what the user enters is written back
+     * to it. So the value must be something that can be assigned.
+     */
+    protected checkBinding(attribute: ast.JsxAttribute, tag: string, attributes: readonly (ast.JsxAttribute | ast.JsxSpreadAttribute)[]): void;
+    /** `onClick={...}`: code to run on the event, or a function that gets the event. */
+    protected checkEventAttribute(attribute: ast.JsxAttribute, event: Type): void;
+    /**
+     * The statements of `onClick={count++}`, with `event` declared when there is one. They run on
+     * the event, so in the initializer of a variable they can use it, as functions there can:
+     * `const button = <button onClick={button.remove()}>`.
+     */
+    protected checkEventHandler(handler: ast.EventHandler, event: Type | null): void;
+    private checkHandlerBody;
+}

package/dist/checker/markup.js

@@ -0,0 +1,220 @@
+import { childrenInSvg, isSvgElement } from "../svg.js";
+import { Scope } from "./context.js";
+import { domProperty, elementType } from "./dom.js";
+import { svgElementType } from "./dom-svg.js";
+import { isContent, isAttributeValue, isUntyped } from "./helpers.js";
+import { OperatorChecker } from "./operators.js";
+import { BOOL, func, STRING, typeToString } from "./types.js";
+// Markup: elements, their children and attributes, `bind:` and event handlers.
+export class MarkupChecker extends OperatorChecker {
+    /** Whether the markup being checked is inside `<svg>`: its elements are SVG then. */
+    inSvg = false;
+    /** The type of the element `<tag>` creates; outside markup, SVG only for SVG's own tags. */
+    elementOf(tag, svg = isSvgElement(tag, false)) {
+        const type = this.options.library?.element(tag, svg);
+        return type ?? (svg ? svgElementType(tag) : elementType(tag));
+    }
+    checkElement(node) {
+        if (node.tag && node.value)
+            return this.checkValueTagUse(node, node.tag, node.value);
+        if (node.tag && /^[A-Z]/.test(node.tag.name)) {
+            const binding = this.lookupValue(node.tag.name);
+            // `<Page />` with a variable `Page` takes the component from its value.
+            return binding && !binding.component
+                ? this.checkValueTagUse(node, node.tag, node.tag)
+                : this.checkComponentUse(node, node.tag);
+        }
+        const tag = node.tag?.name ?? null;
+        const svg = tag !== null && isSvgElement(tag, this.inSvg);
+        const type = tag === null ? this.dom.fragment : this.elementOf(tag, svg);
+        for (const attribute of node.attributes) {
+            if (attribute.kind === 'JsxSpreadAttribute') {
+                const spread = this.checkValue(attribute.argument);
+                if (!isUntyped(spread) && spread.kind !== 'object') {
+                    this.error(`cannot spread ${typeToString(spread)} into attributes`, attribute.argument);
+                }
+            }
+            else if (attribute.name.name === 'ref') {
+                this.checkRefAttribute(attribute, node);
+            }
+            else if (tag !== null && attribute.name.name.startsWith('bind:')) {
+                this.checkBinding(attribute, tag, node.attributes);
+            }
+            else if (tag !== null) {
+                this.checkAttribute(attribute, tag, type, svg);
+            }
+        }
+        for (const attribute of node.attributes) {
+            if (attribute.kind !== 'JsxAttribute' || !attribute.name.name.startsWith('bind:'))
+                continue;
+            const property = attribute.name.name.slice('bind:'.length);
+            const plain = node.attributes.some((other) => other.kind === 'JsxAttribute' && other.name.name === property);
+            if (plain) {
+                this.error(`"${property}" and "bind:${property}" set the same property: keep one of them`, attribute.name);
+            }
+        }
+        const saved = this.inSvg;
+        this.inSvg = childrenInSvg(tag, svg, saved);
+        try {
+            this.checkChildren(node.children);
+        }
+        finally {
+            this.inSvg = saved;
+        }
+        return type;
+    }
+    checkChildren(children) {
+        for (const child of children) {
+            if (child.kind === 'JsxText')
+                continue;
+            if (child.kind === 'JsxStatementContainer') {
+                // Checked like any if/for/switch, so conditions narrow types in the blocks.
+                this.checkStatement(child.statement);
+                continue;
+            }
+            if (child.kind === 'ElementExpression') {
+                this.checkExpression(child, null);
+                continue;
+            }
+            const content = this.checkValue(child.expression);
+            if (!isContent(content, this.dom.node)) {
+                this.error(`cannot use ${typeToString(content)} as element content` +
+                    (content.kind === 'bool' ? ': use a condition, e.g. {ok ? <b>yes</b> : null}' : ''), child.expression);
+            }
+        }
+    }
+    checkAttribute(attribute, tag, element, svg = false) {
+        const name = attribute.name.name;
+        const { value } = attribute;
+        // `<app-card count={3} />`: a property of a web component of this module.
+        const webProperty = this.webComponentProperty(tag, name);
+        if (webProperty) {
+            this.checkProp(attribute, webProperty, tag);
+            return;
+        }
+        if (/^on[A-Z]/.test(name)) {
+            this.checkEventAttribute(attribute, this.eventOf(name, element));
+            return;
+        }
+        if (value?.kind === 'EventHandler')
+            return;
+        const valueType = value === null ? BOOL : value.kind === 'StringLiteral' ? STRING : this.checkValue(value);
+        if (name === 'style') {
+            if (!isUntyped(valueType) && valueType.kind !== 'string' && valueType.kind !== 'object') {
+                this.error(`style must be a string or an object, not ${typeToString(valueType)}`, attribute);
+            }
+            return;
+        }
+        // `<a download>` without a value sets an empty attribute, whatever the property type is.
+        if (value === null)
+            return;
+        // SVG attributes are set with setAttribute: their properties are objects.
+        const property = svg ? null : domProperty(tag, name);
+        if (property) {
+            this.expectAssignable(valueType, property.type, value, ` for attribute "${name}"`);
+        }
+        else if (!isAttributeValue(valueType)) {
+            this.error(`attribute "${name}" needs a string, number or bool, not ${typeToString(valueType)}`, value);
+        }
+    }
+    /**
+     * `bind:value={name}`: the element shows the variable, and what the user enters is written back
+     * to it. So the value must be something that can be assigned.
+     */
+    checkBinding(attribute, tag, attributes) {
+        const name = attribute.name.name;
+        const property = name.slice('bind:'.length);
+        const { value } = attribute;
+        if (property !== 'value' && property !== 'checked') {
+            this.error(`unknown binding "${name}": use bind:value or bind:checked`, attribute.name);
+            return;
+        }
+        const tags = property === 'value' ? ['input', 'textarea', 'select'] : ['input'];
+        if (!tags.includes(tag)) {
+            this.error(property === 'value'
+                ? 'bind:value works with <input>, <textarea> and <select>'
+                : 'bind:checked works with <input>', attribute.name);
+        }
+        if (value === null || value.kind === 'StringLiteral' || value.kind === 'EventHandler') {
+            this.error(`"${name}" needs a variable in braces, e.g. ${name}={title}`, attribute);
+            return;
+        }
+        const bindable = (value.kind === 'Identifier' && value.name !== '_') ||
+            ((value.kind === 'MemberExpression' || value.kind === 'IndexExpression') && !value.optional);
+        if (!bindable) {
+            this.checkValue(value);
+            this.error(`"${name}" needs a variable or a field to write to`, value);
+            return;
+        }
+        const type = this.checkTarget(value);
+        this.checkedTypes.set(value, type);
+        if (isUntyped(type))
+            return;
+        if (property === 'checked' && type.kind !== 'bool') {
+            this.error(`bind:checked needs a bool, not ${typeToString(type)}`, value);
+        }
+        else if (property === 'value' && type.kind === 'number' && tag === 'input') {
+            // A number is read with valueAsNumber, which only number and range inputs have.
+            const typeAttribute = attributes.find((other) => other.kind === 'JsxAttribute' && other.name.name === 'type')?.value;
+            const inputType = typeAttribute?.kind === 'StringLiteral' ? typeAttribute.value : null;
+            if (inputType !== 'number' && inputType !== 'range') {
+                this.error('a number can be bound to <input type="number"> or <input type="range">', attribute.name);
+            }
+        }
+        else if (property === 'value' &&
+            type.kind !== 'string' &&
+            !(type.kind === 'number' && tag === 'input')) {
+            const allowed = tag === 'input' ? 'a string or a number' : 'a string';
+            this.error(`bind:value needs ${allowed}, not ${typeToString(type)}`, value);
+        }
+    }
+    /** `onClick={...}`: code to run on the event, or a function that gets the event. */
+    checkEventAttribute(attribute, event) {
+        const name = attribute.name.name;
+        const { value } = attribute;
+        if (value === null || value.kind === 'StringLiteral') {
+            this.error(`"${name}" needs code or a function in braces, e.g. ${name}={save()}`, attribute);
+        }
+        else if (value.kind === 'EventHandler') {
+            this.checkEventHandler(value, event);
+        }
+        else {
+            const handler = func([event], []);
+            const type = this.checkValue(value, handler);
+            this.expectAssignable(type, handler, value, ` as the "${name}" handler`);
+        }
+    }
+    /**
+     * The statements of `onClick={count++}`, with `event` declared when there is one. They run on
+     * the event, so in the initializer of a variable they can use it, as functions there can:
+     * `const button = <button onClick={button.remove()}>`.
+     */
+    checkEventHandler(handler, event) {
+        const checkBody = () => this.checkHandlerBody(handler, event);
+        if (!this.deferBody(handler, checkBody))
+            checkBody();
+    }
+    checkHandlerBody(handler, event) {
+        const saved = { scope: this.scope, flow: this.flow, fn: this.fn };
+        this.scope = new Scope(this.scope);
+        this.flow = this.stableFlow();
+        this.fn = { results: [], returns: [], isConstructor: false };
+        try {
+            const name = {
+                kind: 'Identifier',
+                name: 'event',
+                start: handler.start,
+                end: handler.start,
+            };
+            if (event)
+                this.declareValue(name, 'param', event);
+            for (const statement of handler.body)
+                this.checkStatement(statement);
+        }
+        finally {
+            this.scope = saved.scope;
+            this.flow = saved.flow;
+            this.fn = saved.fn;
+        }
+    }
+}

package/dist/checker/members.d.ts

@@ -0,0 +1,29 @@
+import type * as ast from '../ast.ts';
+import { DecoratorMemberChecker } from './decorator-members.ts';
+import { type Member, type Type } from './types.ts';
+export declare abstract class MemberChecker extends DecoratorMemberChecker {
+    /**
+     * Member access, indexing and calls. Returns the type and whether an optional link (`?.`)
+     * may short-circuit the chain: `a?.b.c()` is null as a whole when `a` is null.
+     */
+    /** `expected` is for the result of a call: it can give type arguments, as in `let xs []number = empty()`. */
+    protected checkChain(node: ast.MemberExpression | ast.IndexExpression | ast.CallExpression, expected?: Type | null): [Type, boolean];
+    protected chainPart(node: ast.Expression): [Type, boolean];
+    /** The value of an object that must not be null, e.g. before a member assignment. */
+    protected nonNullValue(node: ast.Expression): Type;
+    /**
+     * `object[key]` with a key that is not a position: on an untyped value (`data[name]`), or on
+     * an object with `[key: string]: T` from a `.d.ts`. `null` for arrays and strings.
+     */
+    protected keyedIndex(object: Type, index: ast.Expression): Type | null;
+    /**
+     * `styles["is-active"]`, or `styles[kind]` with `kind "primary" | "ghost"`: the fields of an
+     * object by keys whose values are known. `null` when they are not.
+     */
+    private fieldsByKey;
+    protected expectIndex(node: ast.Expression): void;
+    /** The member `name` of a value of type `object`; `'any'` for untyped values. */
+    protected findMember(object: Type, name: string, node: ast.NodeBase): Member | 'any' | undefined;
+    /** The public member `name` of a type, without reporting anything; for members of unions. */
+    protected memberOf(type: Type, name: string): Member | 'any' | undefined;
+}

package/dist/checker/members.js

@@ -0,0 +1,233 @@
+import { bigintMember } from "./bigint.js";
+import { boolMember, numberMember, stringMember } from "./builtins.js";
+import { DecoratorMemberChecker } from "./decorator-members.js";
+import { isUntyped, isNumeric } from "./helpers.js";
+import { ANY, findClassMember, hasUntypedBase, isComparable, isNullable, isSubclass, literal, literalBase, memberNames, memberTypeOf, nonNull, NUMBER, property, STRING, typeToString, union, unionMembers, UNKNOWN, } from "./types.js";
+// Member access and indexing, with `?.` chains.
+export class MemberChecker extends DecoratorMemberChecker {
+    /**
+     * Member access, indexing and calls. Returns the type and whether an optional link (`?.`)
+     * may short-circuit the chain: `a?.b.c()` is null as a whole when `a` is null.
+     */
+    /** `expected` is for the result of a call: it can give type arguments, as in `let xs []number = empty()`. */
+    checkChain(node, expected = null) {
+        if (node.kind === 'CallExpression') {
+            if (node.callee.kind === 'SuperExpression')
+                return [this.checkSuperCall(node), false];
+            let [callee, shortCircuits] = this.chainPart(node.callee);
+            this.checkDecoratorMutation(node);
+            if (isNullable(callee)) {
+                if (node.optional)
+                    shortCircuits = true;
+                else
+                    this.nullError(node.callee);
+                callee = nonNull(callee);
+            }
+            return [this.checkCall(node, callee, expected), shortCircuits];
+        }
+        if (node.kind === 'MemberExpression' && this.decoratorWithoutAt(node))
+            return [UNKNOWN, false];
+        let [object, shortCircuits] = node.object.kind === 'SuperExpression'
+            ? [this.superType(node.object), false]
+            : this.chainPart(node.object);
+        if (isNullable(object)) {
+            if (node.optional)
+                shortCircuits = true;
+            else
+                this.nullError(node.object);
+            object = nonNull(object);
+        }
+        if (node.kind === 'MemberExpression') {
+            const member = this.findMember(object, node.property.name, node.property);
+            return [member === 'any' ? ANY : (member?.type ?? UNKNOWN), shortCircuits];
+        }
+        const keyed = this.keyedIndex(object, node.index);
+        if (keyed)
+            return [keyed, shortCircuits];
+        this.expectIndex(node.index);
+        if (object.kind === 'array')
+            return [object.element, shortCircuits];
+        if (object.kind === 'string')
+            return [STRING, shortCircuits];
+        if (object.kind === 'object' && object.numberIndex)
+            return [object.numberIndex, shortCircuits];
+        this.error(`cannot index ${typeToString(object)}`, node);
+        return [UNKNOWN, shortCircuits];
+    }
+    chainPart(node) {
+        if (node.kind === 'MemberExpression' ||
+            node.kind === 'IndexExpression' ||
+            node.kind === 'CallExpression') {
+            const [type, shortCircuits] = this.checkChain(node);
+            return [this.single(type, node), shortCircuits];
+        }
+        return [this.checkValue(node), false];
+    }
+    /** The value of an object that must not be null, e.g. before a member assignment. */
+    nonNullValue(node) {
+        const [type] = this.chainPart(node);
+        if (isNullable(type))
+            this.nullError(node);
+        return nonNull(type);
+    }
+    /**
+     * `object[key]` with a key that is not a position: on an untyped value (`data[name]`), or on
+     * an object with `[key: string]: T` from a `.d.ts`. `null` for arrays and strings.
+     */
+    keyedIndex(object, index) {
+        if (object.kind === 'object' && !object.index && !object.numberIndex) {
+            return this.fieldsByKey(object, index);
+        }
+        const type = isUntyped(object) ? object : object.kind === 'object' ? object.index : undefined;
+        if (!type)
+            return null;
+        const key = this.checkValue(index);
+        if (!isUntyped(key) && !isComparable(key, STRING) && !isNumeric(key)) {
+            this.error(`a key must be a string or a number, not ${typeToString(key)}`, index);
+        }
+        return type;
+    }
+    /**
+     * `styles["is-active"]`, or `styles[kind]` with `kind "primary" | "ghost"`: the fields of an
+     * object by keys whose values are known. `null` when they are not.
+     */
+    fieldsByKey(object, index) {
+        const names = [...memberNames(object.members)].filter((name) => object.members.get(name)?.method === false);
+        if (names.length === 0)
+            return null;
+        // A string literal gets a literal type where one of the names is expected.
+        const key = this.checkValue(index, union(names.map((name) => literal(name))));
+        const keys = unionMembers(key);
+        if (!keys.every((each) => each.kind === 'literal' && typeof each.value === 'string')) {
+            return null;
+        }
+        return union(keys.map((each) => {
+            const member = this.findMember(object, String(each.value), index);
+            return member === 'any' ? ANY : (member?.type ?? UNKNOWN);
+        }));
+    }
+    expectIndex(node) {
+        const type = this.checkValue(node, NUMBER);
+        if (!isNumeric(type))
+            this.error(`index must be a number, not ${typeToString(type)}`, node);
+    }
+    /** The member `name` of a value of type `object`; `'any'` for untyped values. */
+    findMember(object, name, node) {
+        let member;
+        switch (object.kind) {
+            case 'any':
+            case 'unknown':
+            case 'never':
+                return 'any';
+            case 'literal':
+                return this.findMember(literalBase(object), name, node);
+            case 'param':
+                // A value of a type parameter has the members of its constraint.
+                if (object.constraint)
+                    return this.findMember(object.constraint, name, node);
+                this.error(`${object.name} has no member "${name}": give the type parameter a constraint, e.g. [${object.name} Shape]`, node);
+                return undefined;
+            case 'union': {
+                // A member of a union is one that every type in it has.
+                const found = object.types.map((type) => this.memberOf(type, name));
+                if (found.includes('any'))
+                    return 'any';
+                const members = found.filter((each) => each !== undefined);
+                if (members.length < found.length) {
+                    this.error(`${typeToString(object)} has no member "${name}" in every type: narrow it with typeof or instanceof`, node);
+                    return undefined;
+                }
+                return {
+                    type: union(members.map((each) => each.type)),
+                    method: members.every((each) => each.method),
+                    visibility: 'public',
+                    owner: null,
+                };
+            }
+            case 'number':
+                member = numberMember(name) ?? this.primitiveMember('number', name);
+                break;
+            case 'bigint':
+                member = bigintMember(name) ?? this.primitiveMember('bigint', name);
+                break;
+            case 'string':
+                member = stringMember(name) ?? this.primitiveMember('string', name);
+                break;
+            case 'bool':
+                member = boolMember(name) ?? this.primitiveMember('bool', name);
+                break;
+            case 'array':
+                member = this.arrayMemberOf(object.element, name);
+                break;
+            case 'object':
+                member = object.members.get(name) ?? (object.index && property(object.index));
+                break;
+            case 'class':
+                this.ensureClassResolved(object.info);
+                member = findClassMember(object.info, name, false);
+                if (!member && hasUntypedBase(object.info))
+                    return 'any';
+                if (member && object.args)
+                    member = { ...member, type: memberTypeOf(object, member) };
+                break;
+            case 'classValue':
+                this.ensureClassResolved(object.info);
+                member = findClassMember(object.info, name, true);
+                if (!member && hasUntypedBase(object.info))
+                    return 'any';
+                break;
+            default:
+                break;
+        }
+        if (!member) {
+            this.error(`${typeToString(object)} has no member "${name}"`, node);
+            return undefined;
+        }
+        const { owner, visibility } = member;
+        if (owner && visibility !== 'public') {
+            const current = this.cls?.info;
+            const allowed = visibility === 'private'
+                ? current === owner
+                : current !== undefined && isSubclass(current, owner);
+            if (!allowed)
+                this.error(`"${name}" is ${visibility} in ${owner.name}`, node);
+        }
+        return member;
+    }
+    /** The public member `name` of a type, without reporting anything; for members of unions. */
+    memberOf(type, name) {
+        switch (type.kind) {
+            case 'any':
+            case 'unknown':
+            case 'never':
+                return 'any';
+            case 'literal':
+                return this.memberOf(literalBase(type), name);
+            case 'param':
+                return type.constraint ? this.memberOf(type.constraint, name) : undefined;
+            case 'number':
+                return numberMember(name) ?? this.primitiveMember('number', name);
+            case 'bigint':
+                return bigintMember(name) ?? this.primitiveMember('bigint', name);
+            case 'string':
+                return stringMember(name) ?? this.primitiveMember('string', name);
+            case 'bool':
+                return boolMember(name) ?? this.primitiveMember('bool', name);
+            case 'array':
+                return this.arrayMemberOf(type.element, name);
+            case 'object':
+                return type.members.get(name) ?? (type.index && property(type.index));
+            case 'class': {
+                this.ensureClassResolved(type.info);
+                const member = findClassMember(type.info, name, false);
+                if (!member && hasUntypedBase(type.info))
+                    return 'any';
+                if (member?.visibility !== 'public')
+                    return undefined;
+                return type.args ? { ...member, type: memberTypeOf(type, member) } : member;
+            }
+            default:
+                return undefined;
+        }
+    }
+}

package/dist/checker/operators.d.ts

@@ -0,0 +1,13 @@
+import type * as ast from '../ast.ts';
+import { ExpressionChecker } from './expressions.ts';
+import { type Type } from './types.ts';
+export declare abstract class OperatorChecker extends ExpressionChecker {
+    /** In the operation of a `select` case, a channel may be null: that case never goes on. */
+    protected inSelectCase: boolean;
+    protected checkUnary(node: ast.UnaryExpression): Type;
+    protected expectBool(given: Type, node: ast.NodeBase, operator: string): void;
+    protected checkBinary(node: ast.BinaryExpression, expected: Type | null): Type;
+    /** The type of `left <operator> right`, also used for compound assignments like `+=`. */
+    protected binaryResult(operator: ast.BinaryOperator, givenLeft: Type, givenRight: Type, node: ast.NodeBase): Type;
+    protected checkConditional(node: ast.ConditionalExpression, expected: Type | null): Type;
+}