rooklang 0.0.0-stage → 0.3.1

package/dist/checker/types/constructors.js

@@ -0,0 +1,129 @@
+import { BOOL, NEVER, NULL, NUMBER, STRING, } from "./model.js";
+import { typesEqual } from "./relations.js";
+// Making types: arrays, nullable types, literals, unions, functions, members, classes.
+export function arrayOf(element) {
+    return { kind: 'array', element };
+}
+export function nullable(type) {
+    switch (type.kind) {
+        case 'nullable':
+        case 'null':
+        case 'any':
+        case 'unknown':
+            return type;
+        default:
+            return { kind: 'nullable', type };
+    }
+}
+export function literal(value) {
+    return { kind: 'literal', value };
+}
+/** The type that a literal belongs to: `"all"` → `string`. */
+export function literalBase(type) {
+    return typeof type.value === 'string' ? STRING : typeof type.value === 'number' ? NUMBER : BOOL;
+}
+/**
+ * A union of types, simplified: nested unions are flattened, repeats and `never` are dropped, a
+ * literal goes into its base type when that is a member (`"a" | string` → `string`), `true | false`
+ * is `bool`, `any` absorbs everything, and `null` makes the union nullable.
+ */
+export function union(types) {
+    let hasNull = false;
+    const members = [];
+    const add = (type) => {
+        switch (type.kind) {
+            case 'union':
+                type.types.forEach(add);
+                return;
+            case 'nullable':
+                hasNull = true;
+                add(type.type);
+                return;
+            case 'null':
+                hasNull = true;
+                return;
+            case 'never':
+                return;
+            default:
+                if (!members.some((member) => typesEqual(member, type)))
+                    members.push(type);
+        }
+    };
+    types.forEach(add);
+    const special = members.find((member) => member.kind === 'any' || member.kind === 'unknown');
+    if (special)
+        return special;
+    if (members.some((m) => m.kind === 'literal' && m.value === true) &&
+        members.some((m) => m.kind === 'literal' && m.value === false)) {
+        members.push(BOOL);
+    }
+    const kept = members.filter((member) => member.kind !== 'literal' ||
+        !members.some((other) => other.kind === literalBase(member).kind));
+    const result = kept.length === 0
+        ? hasNull
+            ? NULL
+            : NEVER
+        : kept.length === 1
+            ? kept[0]
+            : { kind: 'union', types: kept };
+    return hasNull ? nullable(result) : result;
+}
+/** The type a variable gets from a value: literals become their base types, `"a" | "b"` → `string`. */
+export function widenLiterals(type) {
+    switch (type.kind) {
+        case 'literal':
+            return literalBase(type);
+        case 'union':
+            return union(type.types.map(widenLiterals));
+        case 'nullable':
+            return nullable(widenLiterals(type.type));
+        default:
+            return type;
+    }
+}
+/** The members of a union, or the type itself. */
+export function unionMembers(type) {
+    return type.kind === 'union' ? type.types : [type];
+}
+export function nonNull(type) {
+    if (type.kind === 'nullable')
+        return type.type;
+    return type.kind === 'null' ? NEVER : type;
+}
+export function isNullable(type) {
+    return type.kind === 'nullable' || type.kind === 'null';
+}
+export function func(params, results, options = {}) {
+    return {
+        kind: 'function',
+        params,
+        required: options.required ?? params.length,
+        rest: options.rest ?? null,
+        results,
+        typeParams: options.typeParams ?? [],
+        ...(options.iterator ? { iterator: true } : {}),
+    };
+}
+export function property(type, owner = null) {
+    return { type, method: false, visibility: 'public', owner };
+}
+export function method(type, owner = null) {
+    return { type, method: true, visibility: 'public', owner };
+}
+export function createClass(name) {
+    const info = {
+        name,
+        superClass: null,
+        untypedBase: false,
+        members: new Map(),
+        statics: new Map(),
+        ctor: null,
+        typeParams: [],
+        ctorVisibility: 'public',
+        instance: undefined,
+        value: undefined,
+    };
+    info.instance = { kind: 'class', info };
+    info.value = { kind: 'classValue', info };
+    return info;
+}

package/dist/checker/types/generics.d.ts

@@ -0,0 +1,20 @@
+import { type ClassInfo, type ClassType, type Member, type ObjectType, type Type, type TypeParam } from './model.ts';
+/** Bindings of type parameters to type arguments. */
+export declare function bindParams(params: readonly TypeParam[], args: readonly Type[]): Map<TypeParam, Type>;
+export declare const instances: WeakMap<ObjectType, {
+    args: Type[];
+    instance: ObjectType;
+}[]>;
+/**
+ * `Box<number>` from `interface Box<T>`. Instances are cached, so that a type that refers to itself
+ * (`interface Node<T> { next ?Node<T> }`) gets the same instance back; arguments that are the
+ * parameters themselves give the generic interface.
+ */
+export declare function instantiate(template: ObjectType, args: readonly Type[]): ObjectType;
+/** An instance of a class with type arguments; a class without parameters has one instance. */
+export declare function classInstance(info: ClassInfo, args: readonly Type[]): ClassType;
+/**
+ * The type of a member as seen on an instance: `Stack<number>.items` is `[]number`. A member of a
+ * generic base class gets the arguments that the subclass gives it.
+ */
+export declare function memberTypeOf(object: Type, member: Member): Type;

package/dist/checker/types/generics.js

@@ -0,0 +1,75 @@
+import { LazyMap, memberNames } from "./lazy.js";
+import { UNKNOWN, } from "./model.js";
+import { substitute } from "./params.js";
+import { typesEqual } from "./relations.js";
+// Generic interfaces and classes with type arguments.
+/** Bindings of type parameters to type arguments. */
+export function bindParams(params, args) {
+    return new Map(params.map((param, i) => [param, args[i] ?? UNKNOWN]));
+}
+export const instances = new WeakMap();
+/**
+ * `Box<number>` from `interface Box<T>`. Instances are cached, so that a type that refers to itself
+ * (`interface Node<T> { next ?Node<T> }`) gets the same instance back; arguments that are the
+ * parameters themselves give the generic interface.
+ */
+export function instantiate(template, args) {
+    const params = template.typeParams ?? [];
+    if (params.every((param, i) => args[i] === param))
+        return template;
+    let cached = instances.get(template);
+    if (!cached) {
+        cached = [];
+        instances.set(template, cached);
+    }
+    const found = cached.find((entry) => entry.args.every((arg, i) => typesEqual(arg, args[i])));
+    if (found)
+        return found.instance;
+    const bindings = bindParams(params, args);
+    // Members are substituted when they are used: a template from a `.d.ts` may still be filling
+    // its own members, and large interfaces are mostly not used whole.
+    const instance = {
+        kind: 'object',
+        name: template.name,
+        members: new LazyMap(() => memberNames(template.members), (name) => {
+            const member = template.members.get(name);
+            return member && { ...member, type: substitute(member.type, bindings) };
+        }),
+        call: template.call && substitute(template.call, bindings),
+        instanceOf: { template, args: [...args] },
+    };
+    if (template.construct) {
+        instance.construct = substitute(template.construct, bindings);
+    }
+    // The indexes and the values of a loop, substituted when first used: the template of a
+    // `.d.ts` may get them after its instances.
+    for (const key of ['index', 'numberIndex', 'iterates']) {
+        let substituted;
+        Object.defineProperty(instance, key, {
+            enumerable: true,
+            get: () => (substituted ??= template[key] && substitute(template[key], bindings)),
+        });
+    }
+    cached.push({ args: [...args], instance });
+    return instance;
+}
+/** An instance of a class with type arguments; a class without parameters has one instance. */
+export function classInstance(info, args) {
+    return info.typeParams.length === 0 ? info.instance : { kind: 'class', info, args: [...args] };
+}
+/**
+ * The type of a member as seen on an instance: `Stack<number>.items` is `[]number`. A member of a
+ * generic base class gets the arguments that the subclass gives it.
+ */
+export function memberTypeOf(object, member) {
+    if (object.kind !== 'class' || !member.owner)
+        return member.type;
+    let info = object.info;
+    let bindings = bindParams(info.typeParams, object.args ?? info.typeParams);
+    while (info !== member.owner && info.superClass) {
+        const args = (info.superArgs ?? []).map((arg) => substitute(arg, bindings));
+        info = info.superClass;
+        bindings = bindParams(info.typeParams, args.length > 0 ? args : info.typeParams);
+    }
+    return substitute(member.type, bindings);
+}

package/dist/checker/types/lazy.d.ts

@@ -0,0 +1,30 @@
+/**
+ * A map whose keys are known up front and whose values are computed when first read. Members of
+ * types from `.d.ts` files use it: `@types/node` has thousands of them, and few are ever used.
+ */
+export declare class LazyMap<V> extends Map<string, V> {
+    private names;
+    private complete;
+    private filling;
+    private readonly listNames;
+    private readonly compute;
+    constructor(listNames: () => Iterable<string>, compute: (name: string) => V | undefined);
+    private known;
+    /** The names, without computing the values. */
+    knownNames(): Iterable<string>;
+    /** Computes every value, keeping the order of the names. */
+    private fill;
+    get(name: string): V | undefined;
+    has(name: string): boolean;
+    set(name: string, value: V): this;
+    delete(name: string): boolean;
+    clear(): void;
+    get size(): number;
+    keys(): MapIterator<string>;
+    values(): MapIterator<V>;
+    entries(): MapIterator<[string, V]>;
+    forEach(callback: (value: V, key: string, map: Map<string, V>) => void): void;
+    [Symbol.iterator](): MapIterator<[string, V]>;
+}
+/** The names of a map of members, without computing a lazy one. */
+export declare function memberNames<V>(map: Map<string, V>): Iterable<string>;

package/dist/checker/types/lazy.js

@@ -0,0 +1,92 @@
+/**
+ * A map whose keys are known up front and whose values are computed when first read. Members of
+ * types from `.d.ts` files use it: `@types/node` has thousands of them, and few are ever used.
+ */
+export class LazyMap extends Map {
+    names = null;
+    complete = false;
+    filling = false;
+    listNames;
+    compute;
+    constructor(listNames, compute) {
+        super();
+        this.listNames = listNames;
+        this.compute = compute;
+    }
+    known() {
+        this.names ??= new Set(this.listNames());
+        return this.names;
+    }
+    /** The names, without computing the values. */
+    knownNames() {
+        return this.known();
+    }
+    /** Computes every value, keeping the order of the names. */
+    fill() {
+        if (this.complete || this.filling)
+            return;
+        this.filling = true;
+        const values = [...this.known()].map((name) => [name, this.get(name)]);
+        this.complete = true;
+        this.filling = false;
+        super.clear();
+        for (const [name, value] of values)
+            if (value !== undefined)
+                super.set(name, value);
+    }
+    get(name) {
+        if (super.has(name))
+            return super.get(name);
+        if (this.complete || !this.known().has(name))
+            return undefined;
+        const value = this.compute(name);
+        if (value === undefined)
+            this.names.delete(name);
+        else
+            super.set(name, value);
+        return value;
+    }
+    has(name) {
+        return this.get(name) !== undefined;
+    }
+    set(name, value) {
+        this.known().add(name);
+        return super.set(name, value);
+    }
+    delete(name) {
+        const known = this.known().delete(name);
+        return super.delete(name) || known;
+    }
+    clear() {
+        this.names = new Set();
+        this.complete = true;
+        super.clear();
+    }
+    get size() {
+        this.fill();
+        return super.size;
+    }
+    keys() {
+        this.fill();
+        return super.keys();
+    }
+    values() {
+        this.fill();
+        return super.values();
+    }
+    entries() {
+        this.fill();
+        return super.entries();
+    }
+    forEach(callback) {
+        this.fill();
+        super.forEach(callback);
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+}
+/** The names of a map of members, without computing a lazy one. */
+export function memberNames(map) {
+    return map instanceof LazyMap ? map.knownNames() : map.keys();
+}

package/dist/checker/types/model.d.ts

@@ -0,0 +1,149 @@
+import type { Visibility } from '../../ast.ts';
+/** Types as the checker sees them, after names and aliases have been resolved. */
+export type Type = SimpleType | ArrayType | NullableType | FunctionType | ComponentType | ObjectType | ClassType | ClassValueType | TupleType | TypeParam | UnionType | LiteralType;
+export interface SimpleType {
+    kind: 'number' | 'bigint' | 'string' | 'bool' | 'any' | 'void' | 'null' | 'never' | 'unknown';
+}
+export declare const NUMBER: SimpleType;
+/** Whole numbers of any size, `10n`; they do not mix with numbers. */
+export declare const BIGINT: SimpleType;
+export declare const STRING: SimpleType;
+export declare const BOOL: SimpleType;
+/** Values from JS: anything goes, nothing is checked. */
+export declare const ANY: SimpleType;
+/** What a call to a function without results gives. */
+export declare const VOID: SimpleType;
+/** The type of the `null` literal. */
+export declare const NULL: SimpleType;
+/** Element type of an empty array literal: assignable to every type. */
+export declare const NEVER: SimpleType;
+/** The type of an expression that already has an error: accepted everywhere to avoid follow-up errors. */
+export declare const UNKNOWN: SimpleType;
+export interface ArrayType {
+    kind: 'array';
+    element: Type;
+}
+/** `?T`; the inner type itself is never nullable. */
+export interface NullableType {
+    kind: 'nullable';
+    type: Type;
+}
+export interface FunctionType {
+    kind: 'function';
+    params: Type[];
+    /** How many parameters must be passed; the others may be left out (builtins only). */
+    required: number;
+    /** Element type of a trailing `...rest` parameter (builtins only). */
+    rest: Type | null;
+    results: Type[];
+    /** Type parameters inferred from the arguments of each call, e.g. `map` or `func first<T any>`. */
+    typeParams: TypeParam[];
+    /** The other signatures of an overloaded function from a `.d.ts`; a call uses the first that fits. */
+    overloads?: FunctionType[];
+    /**
+     * `func(yield func(T) bool)`, a function with a `yield` parameter: an iterator, as in Go 1.23. It
+     * compiles to a JS generator, and `for v in f` goes over what it yields.
+     */
+    iterator?: boolean;
+}
+/**
+ * `comp(title string, kind ?Kind)`: a component as a value, which a tag uses,
+ * `<section.content />`. A tag passes the properties in this order.
+ */
+export interface ComponentType {
+    kind: 'component';
+    params: ComponentParam[];
+}
+export interface ComponentParam {
+    name: string;
+    type: Type;
+    /** May be left out: the type is nullable, the property has a default value, or is `children`. */
+    optional: boolean;
+}
+export interface Member {
+    type: Type;
+    method: boolean;
+    visibility: Visibility;
+    /** The class that declares the member, for visibility checks. */
+    owner: ClassInfo | null;
+}
+/** Interfaces, object type literals and the types of object literals. */
+export interface ObjectType {
+    kind: 'object';
+    name: string | null;
+    members: Map<string, Member>;
+    /** For callable builtins like `Number(x)`. */
+    call: FunctionType | null;
+    /** `new` on a value of this type, as with `declare var Foo: { new(): Foo }` in a `.d.ts`. */
+    construct?: FunctionType;
+    /** `[key: string]: T` in a `.d.ts`: the type of members that are not listed. */
+    index?: Type;
+    /** `[index: number]: T` in a `.d.ts`: what `x[i]` gives, as with typed arrays. */
+    numberIndex?: Type;
+    /** What `for v in x` gives: the values of `[Symbol.iterator]()` in a `.d.ts`. */
+    iterates?: Type;
+    /** A generic interface, `interface Box<T>`: its members use these parameters. */
+    typeParams?: TypeParam[];
+    /** `Box<number>`: the generic interface and the type arguments it was made from. */
+    instanceOf?: {
+        template: ObjectType;
+        args: Type[];
+    };
+}
+export interface ClassInfo {
+    name: string;
+    superClass: ClassInfo | null;
+    /** Extends a JS class whose members are unknown. */
+    untypedBase: boolean;
+    /** Own instance members; inherited ones are found through `superClass`. */
+    members: Map<string, Member>;
+    statics: Map<string, Member>;
+    /** Own constructor; `null` means it is inherited (or empty). */
+    ctor: FunctionType | null;
+    /** `class Stack<T>`: members use these parameters, instances give them arguments. */
+    typeParams: TypeParam[];
+    /** Type arguments for a generic base class: the defaults of a class from a `.d.ts`. */
+    superArgs?: Type[];
+    ctorVisibility: Visibility;
+    instance: ClassType;
+    value: ClassValueType;
+}
+/** An instance of a class; `args` are the type arguments of a generic class: `Stack<number>`. */
+export interface ClassType {
+    kind: 'class';
+    info: ClassInfo;
+    args?: Type[];
+}
+/** The class itself: its constructor and static members. */
+export interface ClassValueType {
+    kind: 'classValue';
+    info: ClassInfo;
+}
+/** Several results of a call; only allowed where they are unpacked into variables. */
+export interface TupleType {
+    kind: 'tuple';
+    types: Type[];
+}
+export interface TypeParam {
+    kind: 'param';
+    name: string;
+    /** `T Shape`: what the argument must be, and what a value of type `T` can do. */
+    constraint?: Type | null;
+    /** Used when no argument is given: `T = string` in a `.d.ts`. */
+    default?: Type;
+}
+/**
+ * `string | number`: at least two members, none of them nullable, a union or `any` (see `union`).
+ * A union that may also be null is wrapped in `NullableType`: `?(string | number)`.
+ */
+export interface UnionType {
+    kind: 'union';
+    types: Type[];
+    /** The `type` alias it was declared with, for messages: `Filter`. */
+    name?: string;
+}
+/** `"all"`, `42`, `true`: a type with a single value. */
+export interface LiteralType {
+    kind: 'literal';
+    value: string | number | boolean;
+}

package/dist/checker/types/model.js

@@ -0,0 +1,15 @@
+export const NUMBER = { kind: 'number' };
+/** Whole numbers of any size, `10n`; they do not mix with numbers. */
+export const BIGINT = { kind: 'bigint' };
+export const STRING = { kind: 'string' };
+export const BOOL = { kind: 'bool' };
+/** Values from JS: anything goes, nothing is checked. */
+export const ANY = { kind: 'any' };
+/** What a call to a function without results gives. */
+export const VOID = { kind: 'void' };
+/** The type of the `null` literal. */
+export const NULL = { kind: 'null' };
+/** Element type of an empty array literal: assignable to every type. */
+export const NEVER = { kind: 'never' };
+/** The type of an expression that already has an error: accepted everywhere to avoid follow-up errors. */
+export const UNKNOWN = { kind: 'unknown' };

package/dist/checker/types/params.d.ts

@@ -0,0 +1,7 @@
+import { type Type, type TypeParam } from './model.ts';
+/** Whether a type mentions type parameters: any of them, or only those in `only`. */
+export declare function containsTypeParam(type: Type, only?: ReadonlySet<TypeParam> | null, seen?: Set<Type>): boolean;
+/** Replaces inferred type parameters; with `fallback`, also those that were not inferred. */
+export declare function substitute(type: Type, bindings: Map<TypeParam, Type>, fallback?: Type): Type;
+/** Infers type parameters in `param` from the argument type `arg`. */
+export declare function inferTypeParams(param: Type, arg: Type, bindings: Map<TypeParam, Type>, depth?: number): void;