rooklang 0.0.0-stage → 0.3.0

package/dist/checker/dom.js

@@ -0,0 +1,361 @@
+import { ANY, BOOL, func, method, NUMBER, nullable, property, STRING, } from "./types.js";
+// Types of the DOM for markup: what `<input>` creates and which attributes are properties. Only
+// the commonly used members are typed; the rest of the DOM is reached through `any`.
+const p = property;
+const m = (...args) => method(func(...args));
+function object(name, members) {
+    return { kind: 'object', name, members: new Map(Object.entries(members)), call: null };
+}
+const NODE_MEMBERS = {
+    nodeType: p(NUMBER),
+    nodeName: p(STRING),
+    textContent: p(nullable(STRING)),
+    parentNode: p(ANY),
+    parentElement: p(ANY),
+    childNodes: p(ANY),
+    firstChild: p(ANY),
+    lastChild: p(ANY),
+    nextSibling: p(ANY),
+    previousSibling: p(ANY),
+    isConnected: p(BOOL),
+    appendChild: m([ANY], [ANY]),
+    removeChild: m([ANY], [ANY]),
+    insertBefore: m([ANY, ANY], [ANY]),
+    replaceChild: m([ANY, ANY], [ANY]),
+    cloneNode: m([BOOL], [ANY], { required: 0 }),
+    contains: m([ANY], [BOOL]),
+    hasChildNodes: m([], [BOOL]),
+    addEventListener: m([STRING, ANY, ANY], [], { required: 2 }),
+    removeEventListener: m([STRING, ANY, ANY], [], { required: 2 }),
+    dispatchEvent: m([ANY], [BOOL]),
+};
+/** Members of nodes that have children: elements and fragments. */
+const PARENT_MEMBERS = {
+    append: m([], [], { rest: ANY }),
+    prepend: m([], [], { rest: ANY }),
+    replaceChildren: m([], [], { rest: ANY }),
+    querySelector: m([STRING], [ANY]),
+    querySelectorAll: m([STRING], [ANY]),
+    children: p(ANY),
+    firstElementChild: p(ANY),
+    lastElementChild: p(ANY),
+    childElementCount: p(NUMBER),
+};
+export const ELEMENT_MEMBERS = {
+    ...NODE_MEMBERS,
+    ...PARENT_MEMBERS,
+    // Unlike other nodes, an element always has text content.
+    textContent: p(STRING),
+    before: m([], [], { rest: ANY }),
+    after: m([], [], { rest: ANY }),
+    replaceWith: m([], [], { rest: ANY }),
+    remove: m([], []),
+    id: p(STRING),
+    className: p(STRING),
+    classList: p(ANY),
+    style: p(ANY),
+    dataset: p(ANY),
+    hidden: p(BOOL),
+    title: p(STRING),
+    lang: p(STRING),
+    dir: p(STRING),
+    tabIndex: p(NUMBER),
+    draggable: p(BOOL),
+    contentEditable: p(STRING),
+    innerHTML: p(STRING),
+    outerHTML: p(STRING),
+    innerText: p(STRING),
+    tagName: p(STRING),
+    offsetWidth: p(NUMBER),
+    offsetHeight: p(NUMBER),
+    offsetTop: p(NUMBER),
+    offsetLeft: p(NUMBER),
+    clientWidth: p(NUMBER),
+    clientHeight: p(NUMBER),
+    scrollWidth: p(NUMBER),
+    scrollHeight: p(NUMBER),
+    scrollTop: p(NUMBER),
+    scrollLeft: p(NUMBER),
+    focus: m([ANY], [], { required: 0 }),
+    blur: m([], []),
+    click: m([], []),
+    closest: m([STRING], [ANY]),
+    matches: m([STRING], [BOOL]),
+    getAttribute: m([STRING], [nullable(STRING)]),
+    setAttribute: m([STRING, ANY], []),
+    removeAttribute: m([STRING], []),
+    hasAttribute: m([STRING], [BOOL]),
+    toggleAttribute: m([STRING, BOOL], [BOOL], { required: 1 }),
+    getBoundingClientRect: m([], [ANY]),
+    scrollIntoView: m([ANY], [], { required: 0 }),
+    animate: m([ANY, ANY], [ANY], { required: 1 }),
+};
+const MEDIA_MEMBERS = {
+    src: p(STRING),
+    controls: p(BOOL),
+    autoplay: p(BOOL),
+    loop: p(BOOL),
+    muted: p(BOOL),
+    currentTime: p(NUMBER),
+    volume: p(NUMBER),
+    duration: p(NUMBER),
+    paused: p(BOOL),
+    play: m([], [ANY]),
+    pause: m([], []),
+};
+export const NODE = object('Node', NODE_MEMBERS);
+export const HTML_ELEMENT = object('HTMLElement', ELEMENT_MEMBERS);
+export const DOCUMENT_FRAGMENT = object('DocumentFragment', {
+    ...NODE_MEMBERS,
+    ...PARENT_MEMBERS,
+});
+/** Tags whose elements have members of their own, with the name of their type. */
+const SPECIFIC_ELEMENTS = {
+    a: [
+        'HTMLAnchorElement',
+        { href: p(STRING), target: p(STRING), rel: p(STRING), download: p(STRING) },
+    ],
+    button: [
+        'HTMLButtonElement',
+        { disabled: p(BOOL), type: p(STRING), name: p(STRING), value: p(STRING), form: p(ANY) },
+    ],
+    input: [
+        'HTMLInputElement',
+        {
+            value: p(STRING),
+            valueAsNumber: p(NUMBER),
+            checked: p(BOOL),
+            disabled: p(BOOL),
+            type: p(STRING),
+            name: p(STRING),
+            placeholder: p(STRING),
+            required: p(BOOL),
+            readOnly: p(BOOL),
+            autofocus: p(BOOL),
+            autocomplete: p(STRING),
+            min: p(STRING),
+            max: p(STRING),
+            step: p(STRING),
+            maxLength: p(NUMBER),
+            minLength: p(NUMBER),
+            pattern: p(STRING),
+            multiple: p(BOOL),
+            accept: p(STRING),
+            files: p(ANY),
+            form: p(ANY),
+            select: m([], []),
+            setCustomValidity: m([STRING], []),
+            checkValidity: m([], [BOOL]),
+        },
+    ],
+    textarea: [
+        'HTMLTextAreaElement',
+        {
+            value: p(STRING),
+            placeholder: p(STRING),
+            disabled: p(BOOL),
+            readOnly: p(BOOL),
+            required: p(BOOL),
+            rows: p(NUMBER),
+            cols: p(NUMBER),
+            maxLength: p(NUMBER),
+            name: p(STRING),
+            select: m([], []),
+        },
+    ],
+    select: [
+        'HTMLSelectElement',
+        {
+            value: p(STRING),
+            disabled: p(BOOL),
+            multiple: p(BOOL),
+            required: p(BOOL),
+            name: p(STRING),
+            selectedIndex: p(NUMBER),
+            options: p(ANY),
+        },
+    ],
+    option: [
+        'HTMLOptionElement',
+        {
+            value: p(STRING),
+            selected: p(BOOL),
+            disabled: p(BOOL),
+            label: p(STRING),
+            text: p(STRING),
+        },
+    ],
+    form: [
+        'HTMLFormElement',
+        {
+            action: p(STRING),
+            method: p(STRING),
+            noValidate: p(BOOL),
+            elements: p(ANY),
+            reset: m([], []),
+            submit: m([], []),
+            requestSubmit: m([ANY], [], { required: 0 }),
+            checkValidity: m([], [BOOL]),
+        },
+    ],
+    label: ['HTMLLabelElement', { htmlFor: p(STRING) }],
+    img: [
+        'HTMLImageElement',
+        {
+            src: p(STRING),
+            alt: p(STRING),
+            srcset: p(STRING),
+            loading: p(STRING),
+            width: p(NUMBER),
+            height: p(NUMBER),
+            naturalWidth: p(NUMBER),
+            naturalHeight: p(NUMBER),
+            complete: p(BOOL),
+        },
+    ],
+    li: ['HTMLLIElement', { value: p(NUMBER) }],
+    ol: ['HTMLOListElement', { start: p(NUMBER), reversed: p(BOOL) }],
+    canvas: [
+        'HTMLCanvasElement',
+        {
+            width: p(NUMBER),
+            height: p(NUMBER),
+            getContext: m([STRING, ANY], [ANY], { required: 1 }),
+            toDataURL: m([STRING], [STRING], { required: 0 }),
+        },
+    ],
+    video: ['HTMLVideoElement', { ...MEDIA_MEMBERS, width: p(NUMBER), height: p(NUMBER) }],
+    audio: ['HTMLAudioElement', MEDIA_MEMBERS],
+    iframe: ['HTMLIFrameElement', { src: p(STRING), allow: p(STRING) }],
+    progress: ['HTMLProgressElement', { value: p(NUMBER), max: p(NUMBER) }],
+    dialog: [
+        'HTMLDialogElement',
+        {
+            open: p(BOOL),
+            show: m([], []),
+            showModal: m([], []),
+            close: m([STRING], [], { required: 0 }),
+        },
+    ],
+    details: ['HTMLDetailsElement', { open: p(BOOL) }],
+    td: ['HTMLTableCellElement', { colSpan: p(NUMBER), rowSpan: p(NUMBER) }],
+    th: ['HTMLTableCellElement', { colSpan: p(NUMBER), rowSpan: p(NUMBER) }],
+};
+const elementTypes = new Map();
+for (const [tag, [name, members]] of Object.entries(SPECIFIC_ELEMENTS)) {
+    const existing = [...elementTypes.values()].find((type) => type.name === name);
+    elementTypes.set(tag, existing ?? object(name, { ...ELEMENT_MEMBERS, ...members }));
+}
+/** The type of the element `<tag>` creates. */
+export function elementType(tag) {
+    return elementTypes.get(tag) ?? HTML_ELEMENT;
+}
+/**
+ * The type of a component's `children`: the markup between its tags. At runtime it is a
+ * DocumentFragment, but only placing it as `{children}` is allowed.
+ */
+export const CONTENT = object('Content', {});
+/** DOM types that programs can name, e.g. `func render() HTMLLIElement`. */
+export const DOM_TYPES = new Map([
+    ['Node', NODE],
+    ['Content', CONTENT],
+    ['HTMLElement', HTML_ELEMENT],
+    ['Element', HTML_ELEMENT],
+    ['DocumentFragment', DOCUMENT_FRAGMENT],
+    ...[...elementTypes.values()].map((type) => [type.name ?? '', type]),
+]);
+/** HTML attribute names whose DOM property is spelled differently. */
+const PROPERTY_NAMES = {
+    class: 'className',
+    for: 'htmlFor',
+    tabindex: 'tabIndex',
+    readonly: 'readOnly',
+    maxlength: 'maxLength',
+    minlength: 'minLength',
+    colspan: 'colSpan',
+    rowspan: 'rowSpan',
+    contenteditable: 'contentEditable',
+    novalidate: 'noValidate',
+};
+/** Properties that cannot be assigned: attributes with these names go through setAttribute. */
+const READ_ONLY = new Set([
+    ...Object.keys(NODE_MEMBERS),
+    ...Object.keys(PARENT_MEMBERS),
+    'classList',
+    'dataset',
+    'tagName',
+    'offsetWidth',
+    'offsetHeight',
+    'offsetTop',
+    'offsetLeft',
+    'clientWidth',
+    'clientHeight',
+    'scrollWidth',
+    'scrollHeight',
+    'form',
+    'elements',
+    'options',
+    'naturalWidth',
+    'naturalHeight',
+    'complete',
+    'duration',
+    'paused',
+]);
+READ_ONLY.delete('textContent');
+/** The DOM property that an attribute sets, e.g. `class` → `className`; `null` for setAttribute. */
+export function domProperty(tag, attribute) {
+    const name = Object.hasOwn(PROPERTY_NAMES, attribute) ? PROPERTY_NAMES[attribute] : attribute;
+    if (READ_ONLY.has(name))
+        return null;
+    const member = elementType(tag).members.get(name);
+    return member && !member.method ? { name, type: member.type } : null;
+}
+const EVENT_MEMBERS = {
+    type: p(STRING),
+    target: p(ANY),
+    currentTarget: p(ANY),
+    preventDefault: m([], []),
+    stopPropagation: m([], []),
+    stopImmediatePropagation: m([], []),
+    defaultPrevented: p(BOOL),
+    bubbles: p(BOOL),
+    timeStamp: p(NUMBER),
+    // Keyboard events
+    key: p(STRING),
+    code: p(STRING),
+    repeat: p(BOOL),
+    altKey: p(BOOL),
+    ctrlKey: p(BOOL),
+    shiftKey: p(BOOL),
+    metaKey: p(BOOL),
+    // Mouse, pointer and wheel events
+    clientX: p(NUMBER),
+    clientY: p(NUMBER),
+    pageX: p(NUMBER),
+    pageY: p(NUMBER),
+    offsetX: p(NUMBER),
+    offsetY: p(NUMBER),
+    movementX: p(NUMBER),
+    movementY: p(NUMBER),
+    button: p(NUMBER),
+    buttons: p(NUMBER),
+    deltaX: p(NUMBER),
+    deltaY: p(NUMBER),
+    pointerId: p(NUMBER),
+    relatedTarget: p(ANY),
+    // Input events
+    data: p(nullable(STRING)),
+    inputType: p(STRING),
+    isComposing: p(BOOL),
+    // Other events
+    dataTransfer: p(ANY),
+    touches: p(ANY),
+    changedTouches: p(ANY),
+    detail: p(ANY),
+    submitter: p(ANY),
+};
+export const EVENT = object('Event', EVENT_MEMBERS);
+/** The `event` of a handler on an element: `currentTarget` is that element. */
+export function eventType(element) {
+    return object('Event', { ...EVENT_MEMBERS, currentTarget: p(element) });
+}

package/dist/checker/expressions.d.ts

@@ -0,0 +1,32 @@
+import type * as ast from '../ast.ts';
+import type { ComponentInfo } from './context.ts';
+import { FunctionChecker } from './functions.ts';
+import { type ComponentType, type Type } from './types.ts';
+export declare abstract class ExpressionChecker extends FunctionChecker {
+    /** The type of a component used as a value; implemented by ComponentValueChecker. */
+    protected abstract componentValue(info: ComponentInfo): ComponentType;
+    /** `go work(x)`: a Promise of the result; implemented by GoroutineChecker. */
+    protected abstract checkGo(node: ast.GoExpression): Type;
+    /** `chan<number>(10)`; implemented by ChannelChecker. */
+    protected abstract checkChan(node: ast.ChanExpression): Type;
+    /** `[]byte("text")`; implemented by BytesChecker. */
+    protected abstract checkConversion(node: ast.ConversionExpression): Type;
+    protected abstract checkMake(node: ast.MakeExpression): Type;
+    /** The type of an expression that must be a single value (not `void` or several results). */
+    protected checkValue(node: ast.Expression, expected?: Type | null): Type;
+    protected single(type: Type, node: ast.Expression): Type;
+    /** `expected` is the type the context wants, used to type literals and arrow functions. */
+    protected checkExpression(node: ast.Expression, expected: Type | null): Type;
+    protected computeType(node: ast.Expression, expected: Type | null): Type;
+    protected checkIdentifier(node: ast.Identifier): Type;
+    protected thisType(node: ast.NodeBase): Type;
+    /** `super.method()`: the members of the base class. */
+    protected superType(node: ast.NodeBase): Type;
+    protected checkArrayLiteral(node: ast.ArrayLiteral, expected: Type | null): Type;
+    protected checkObjectLiteral(node: ast.ObjectLiteral, expected: Type | null): Type;
+    /**
+     * `value as Type`: the types must be related, one assignable to the other, as in TypeScript:
+     * `element as HTMLInputElement`, `JSON.parse(text) as Config`, but not `count as string`.
+     */
+    private checkAs;
+}

package/dist/checker/expressions.js

@@ -0,0 +1,244 @@
+import { FunctionChecker } from "./functions.js";
+import { expectsLiteral, callName, isUntyped } from "./helpers.js";
+import { ANY, BIGINT, arrayOf, BOOL, commonType, hasUntypedBase, instanceMembers, isAssignable, literal, NEVER, nonNull, NULL, nullable, NUMBER, STRING, typeToString, UNKNOWN, } from "./types.js";
+// Expressions: names, `this`, literals of arrays and objects; the operators are in operators.ts.
+export class ExpressionChecker extends FunctionChecker {
+    /** The type of an expression that must be a single value (not `void` or several results). */
+    checkValue(node, expected = null) {
+        return this.single(this.checkExpression(node, expected), node);
+    }
+    single(type, node) {
+        if (type.kind === 'tuple') {
+            this.error(`${callName(node)} returns ${type.types.length} values: unpack them, e.g. "const a, b = ..."`, node);
+            return UNKNOWN;
+        }
+        if (type.kind === 'void') {
+            this.error(`${callName(node)} does not return a value`, node);
+            return UNKNOWN;
+        }
+        return type;
+    }
+    /** `expected` is the type the context wants, used to type literals and arrow functions. */
+    checkExpression(node, expected) {
+        const type = this.computeType(node, expected);
+        this.checkedTypes.set(node, type);
+        return type;
+    }
+    computeType(node, expected) {
+        switch (node.kind) {
+            case 'Identifier':
+                return this.checkIdentifier(node);
+            // A literal has a literal type only where one is expected: `filter = "all"`.
+            case 'NumberLiteral':
+                return expectsLiteral(expected) ? literal(node.value) : NUMBER;
+            case 'BigIntLiteral':
+                return BIGINT;
+            case 'StringLiteral':
+                return expectsLiteral(expected) ? literal(node.value) : STRING;
+            case 'TemplateLiteral':
+                for (const expression of node.expressions)
+                    this.checkValue(expression);
+                return STRING;
+            case 'BooleanLiteral':
+                return expectsLiteral(expected) ? literal(node.value) : BOOL;
+            case 'NullLiteral':
+                return NULL;
+            case 'ThisExpression':
+                return this.thisType(node);
+            case 'SuperExpression':
+                return this.superType(node);
+            case 'ArrayLiteral':
+                return this.checkArrayLiteral(node, expected);
+            case 'ObjectLiteral':
+                return this.checkObjectLiteral(node, expected);
+            case 'FuncExpression':
+                return this.checkFuncExpression(node);
+            case 'ArrowFunction':
+                return this.checkArrowFunction(node, expected);
+            case 'UnaryExpression':
+                return this.checkUnary(node);
+            case 'BinaryExpression':
+                return this.checkBinary(node, expected);
+            case 'ConditionalExpression':
+                return this.checkConditional(node, expected);
+            case 'AsExpression':
+                return this.checkAs(node);
+            case 'GoExpression':
+                return this.checkGo(node);
+            case 'ChanExpression':
+                return this.checkChan(node);
+            case 'ConversionExpression':
+                return this.checkConversion(node);
+            case 'MakeExpression':
+                return this.checkMake(node);
+            case 'NewExpression':
+                return this.checkNew(node, expected);
+            case 'ElementExpression':
+                return this.checkElement(node);
+            case 'DecoratorMember':
+                return this.checkDecoratorMember(node);
+            case 'DecoratorGet':
+                return this.checkDecoratorGet(node);
+            case 'MemberExpression':
+            case 'IndexExpression':
+            case 'CallExpression': {
+                const [type, shortCircuits] = this.checkChain(node, expected);
+                return shortCircuits && type.kind !== 'tuple' && type.kind !== 'void'
+                    ? nullable(type)
+                    : type;
+            }
+        }
+    }
+    checkIdentifier(node) {
+        if (node.name === '_') {
+            this.error('"_" cannot be used as a value', node);
+            return UNKNOWN;
+        }
+        const binding = this.lookupValue(node.name);
+        if (!binding) {
+            this.error(this.lookupType(node.name)
+                ? `"${node.name}" is a type, not a value`
+                : node.name === 'make'
+                    ? 'make takes the type of a typed array first, e.g. make([]float64, n)'
+                    : `"${node.name}" is not defined`, node);
+            return UNKNOWN;
+        }
+        // A component as a value: a tag can take it from there, `<section.content />`.
+        if (binding.component)
+            return this.componentValue(binding.component);
+        const initializerError = this.initializerError(binding);
+        if (initializerError !== null) {
+            this.error(initializerError, node);
+            return UNKNOWN;
+        }
+        if (binding.type === null) {
+            this.error(`"${node.name}" is used before its declaration`, node);
+            return UNKNOWN;
+        }
+        return this.flow.get(binding) ?? binding.type;
+    }
+    thisType(node) {
+        if (!this.cls) {
+            this.error('"this" can only be used inside a class', node);
+            return UNKNOWN;
+        }
+        return this.cls.isStatic ? this.cls.info.value : this.cls.info.instance;
+    }
+    /** `super.method()`: the members of the base class. */
+    superType(node) {
+        const info = this.cls?.info;
+        if (!info) {
+            this.error('"super" can only be used inside a class', node);
+            return UNKNOWN;
+        }
+        if (info.superClass)
+            return this.cls?.isStatic ? info.superClass.value : info.superClass.instance;
+        if (hasUntypedBase(info))
+            return ANY;
+        this.error(`class "${info.name}" has no base class`, node);
+        return UNKNOWN;
+    }
+    checkArrayLiteral(node, expected) {
+        const context = expected ? nonNull(expected) : null;
+        const expectedElement = context?.kind === 'array' ? context.element : context?.kind === 'any' ? ANY : null;
+        let element = expectedElement ?? NEVER;
+        for (const item of node.elements) {
+            let type;
+            if (item.kind === 'SpreadElement') {
+                const spread = this.checkValue(item.argument, expectedElement && arrayOf(expectedElement));
+                if (spread.kind === 'array')
+                    type = spread.element;
+                else if (spread.kind === 'any' || spread.kind === 'unknown')
+                    type = spread;
+                // JS spreads any iterable: a Set, a typed array, a `[]byte`.
+                else if (spread.kind === 'object' && spread.iterates)
+                    type = spread.iterates;
+                else {
+                    this.error(`cannot spread ${typeToString(spread)}: it is not an array or an iterable`, item.argument);
+                    type = UNKNOWN;
+                }
+            }
+            else {
+                type = this.checkValue(item, expectedElement);
+            }
+            if (expectedElement) {
+                this.expectAssignable(type, expectedElement, item.kind === 'SpreadElement' ? item.argument : item);
+            }
+            else {
+                element = commonType(element, type);
+            }
+        }
+        return arrayOf(element);
+    }
+    checkObjectLiteral(node, expected) {
+        let target = expected ? nonNull(expected) : null;
+        // `?(ScrollIntoViewOptions | bool)`: an object literal can only be the object type in it.
+        if (target?.kind === 'union') {
+            const objects = target.types.filter((type) => type.kind === 'object' || type.kind === 'class');
+            target = objects.length === 1 ? objects[0] : null;
+        }
+        const index = target?.kind === 'object' ? target.index : undefined;
+        const targetMembers = target?.kind === 'object'
+            ? target.members
+            : target?.kind === 'class'
+                ? instanceMembers(target.info)
+                : null;
+        const members = new Map();
+        const written = new Set();
+        let untyped = false;
+        for (const property of node.properties) {
+            if (property.kind === 'SpreadElement') {
+                const spread = this.checkValue(property.argument);
+                if (spread.kind === 'object') {
+                    for (const [name, member] of spread.members)
+                        members.set(name, member);
+                }
+                else if (spread.kind === 'class') {
+                    for (const [name, member] of instanceMembers(spread.info)) {
+                        if (member.visibility === 'public' && !member.method)
+                            members.set(name, member);
+                    }
+                }
+                else if (spread.kind === 'any' || spread.kind === 'unknown') {
+                    untyped = true;
+                }
+                else {
+                    this.error(`cannot spread ${typeToString(spread)} into an object`, property.argument);
+                }
+                continue;
+            }
+            const name = property.key.kind === 'Identifier' ? property.key.name : property.key.value;
+            // Fields may override those of a spread object, but not each other.
+            if (written.has(name))
+                this.error(`duplicate field "${name}"`, property.key);
+            written.add(name);
+            const expectedMember = targetMembers?.get(name) ??
+                (index && { type: index, method: false, visibility: 'public', owner: null });
+            // A field that the expected type does not have is most likely a typo.
+            if (targetMembers && !expectedMember && target) {
+                this.error(`${typeToString(target)} has no field "${name}"`, property.key);
+            }
+            let type = this.checkValue(property.value, expectedMember?.type ?? null);
+            if (expectedMember) {
+                // Reported at the field; the literal then counts as having the expected field type.
+                this.expectAssignable(type, expectedMember.type, property.value, ` for field "${name}"`);
+                type = expectedMember.type;
+            }
+            members.set(name, { type, method: false, visibility: 'public', owner: null });
+        }
+        return untyped ? ANY : { kind: 'object', name: null, members, call: null };
+    }
+    /**
+     * `value as Type`: the types must be related, one assignable to the other, as in TypeScript:
+     * `element as HTMLInputElement`, `JSON.parse(text) as Config`, but not `count as string`.
+     */
+    checkAs(node) {
+        const target = this.resolveType(node.type);
+        const source = this.checkValue(node.expression, target);
+        const related = isAssignable(source, target) || isAssignable(target, source);
+        if (!isUntyped(source) && !isUntyped(target) && !related) {
+            this.error(`cannot use ${typeToString(source)} as ${typeToString(target)}, even with "as": the types are not related`, node);
+        }
+        return target;
+    }
+}

package/dist/checker/flow.d.ts

@@ -0,0 +1,18 @@
+import type * as ast from '../ast.ts';
+import type { Flow, Narrowing } from './context.ts';
+import { type Type } from './types.ts';
+/** What `typeof` gives for every value of a type, or `null` when it may give several things. */
+export declare function typeofTag(type: Type): string | null;
+/** The type after `typeof x == tag` is found true (`matches`) or false. */
+export declare function narrowByTypeof(type: Type, tag: string, matches: boolean): Type | null;
+/** `"all"`, `42` or `true` written in the code: its value, or `undefined` for other expressions. */
+export declare function literalValue(node: ast.Expression): string | number | boolean | undefined;
+/** A type without one literal value: what is left after `x != "all"`. */
+export declare function withoutLiteral(type: Type, value: string | number | boolean): Type;
+export declare function withNarrowing(flow: Flow, narrowing: Narrowing): Flow;
+/** Narrowing that holds after both branches: the variables narrowed the same way in both. */
+export declare function mergeFlows(a: Flow, b: Flow): Flow;
+/** Go's terminating statements: execution never continues after them. */
+export declare function isTerminating(node: ast.Statement): boolean;
+/** Whether execution never continues after the statement, counting `break` and `continue`. */
+export declare function leaves(node: ast.Statement): boolean;