rooklang 0.0.0-stage → 0.3.0

package/dist/checker/types/params.js

@@ -0,0 +1,220 @@
+import { instanceMembers } from "./classes.js";
+import { arrayOf, func, nonNull, nullable, union } from "./constructors.js";
+import { instantiate } from "./generics.js";
+import { memberNames } from "./lazy.js";
+import { VOID, } from "./model.js";
+import { typesEqual } from "./relations.js";
+// Type parameters: substituting type arguments and inferring them from the arguments of a call.
+/** Whether a type mentions type parameters: any of them, or only those in `only`. */
+export function containsTypeParam(type, only = null, seen = new Set()) {
+    if (seen.has(type))
+        return false;
+    seen.add(type);
+    const contains = (each) => containsTypeParam(each, only, seen);
+    switch (type.kind) {
+        case 'param':
+            return only === null || only.has(type);
+        case 'object':
+            if (type.typeParams?.some((param) => only === null || only.has(param)))
+                return true;
+            if (type.instanceOf)
+                return type.instanceOf.args.some(contains);
+            // A named interface without parameters cannot use them; an object type literal might.
+            if (type.name !== null)
+                return false;
+            return [...type.members.values()].some((member) => contains(member.type));
+        case 'class':
+            return (type.args ?? []).some(contains);
+        case 'array':
+            return contains(type.element);
+        case 'nullable':
+            return contains(type.type);
+        case 'union':
+            return type.types.some(contains);
+        case 'function':
+            return [...type.params, ...type.results].some(contains);
+        case 'component':
+            return type.params.some((param) => contains(param.type));
+        default:
+            return false;
+    }
+}
+/** Replaces inferred type parameters; with `fallback`, also those that were not inferred. */
+export function substitute(type, bindings, fallback) {
+    switch (type.kind) {
+        case 'param':
+            return bindings.get(type) ?? fallback ?? type;
+        case 'array':
+            return arrayOf(substitute(type.element, bindings, fallback));
+        case 'nullable':
+            return nullable(substitute(type.type, bindings, fallback));
+        case 'union':
+            return union(type.types.map((member) => substitute(member, bindings, fallback)));
+        case 'class':
+            return type.args
+                ? { ...type, args: type.args.map((arg) => substitute(arg, bindings, fallback)) }
+                : type;
+        case 'object':
+            return substituteObject(type, bindings, fallback);
+        case 'function': {
+            // A generic method of a generic interface keeps its own parameters: `map<U>` of `Box<T>`.
+            // A default that uses the interface's parameters needs a parameter of its own:
+            // `then<TResult1 = T>` of `Promise<Response>` has the default Response.
+            const own = new Map(bindings);
+            const typeParams = type.typeParams
+                .filter((param) => !bindings.has(param))
+                .map((param) => {
+                if (!param.default || !containsTypeParam(param.default, new Set(bindings.keys()))) {
+                    return param;
+                }
+                const fresh = freshParam(param, substitute(param.default, bindings));
+                own.set(param, fresh);
+                return fresh;
+            });
+            const sub = (each) => substitute(each, own, fallback);
+            const result = func(type.params.map(sub), type.results.map(sub), {
+                required: type.required,
+                ...(type.rest ? { rest: sub(type.rest) } : {}),
+                typeParams,
+                ...(type.iterator ? { iterator: true } : {}),
+            });
+            if (type.overloads) {
+                result.overloads = type.overloads.map((overload) => sub(overload));
+            }
+            return result;
+        }
+        case 'component':
+            return {
+                kind: 'component',
+                params: type.params.map((param) => ({
+                    ...param,
+                    type: substitute(param.type, bindings, fallback),
+                })),
+            };
+        default:
+            return type;
+    }
+}
+const freshParams = new WeakMap();
+/** A copy of a type parameter with another default; the same copy for the same default. */
+function freshParam(param, fallback) {
+    let copies = freshParams.get(param);
+    if (!copies) {
+        copies = [];
+        freshParams.set(param, copies);
+    }
+    let copy = copies.find((each) => each.default && typesEqual(each.default, fallback));
+    if (!copy) {
+        copy = { ...param, default: fallback };
+        copies.push(copy);
+    }
+    return copy;
+}
+function substituteObject(type, bindings, fallback) {
+    const sub = (each) => substitute(each, bindings, fallback);
+    if (type.typeParams && type.typeParams.length > 0) {
+        return instantiate(type, type.typeParams.map(sub));
+    }
+    if (type.instanceOf) {
+        return instantiate(type.instanceOf.template, type.instanceOf.args.map(sub));
+    }
+    // A named interface without parameters cannot use them; an object type literal might.
+    if (type.name !== null || !containsTypeParam(type))
+        return type;
+    const members = new Map();
+    for (const [name, member] of type.members)
+        members.set(name, { ...member, type: sub(member.type) });
+    return { ...type, members, call: type.call && sub(type.call) };
+}
+const MAX_STRUCTURAL_DEPTH = 3;
+/** Infers type parameters in `param` from the argument type `arg`. */
+export function inferTypeParams(param, arg, bindings, depth = 0) {
+    if (!containsTypeParam(param))
+        return;
+    const infer = (p, a) => inferTypeParams(p, a, bindings, depth);
+    switch (param.kind) {
+        case 'param':
+            if (!bindings.has(param) && arg.kind !== 'unknown' && arg.kind !== 'never') {
+                bindings.set(param, arg);
+            }
+            break;
+        case 'array':
+            if (arg.kind === 'array')
+                infer(param.element, arg.element);
+            break;
+        case 'nullable':
+            infer(param.type, nonNull(arg));
+            break;
+        case 'union': {
+            // `T | PromiseLike<T>` from `Promise<string>`: a member with structure first, so that T is
+            // string, not the whole promise; then a bare parameter.
+            const members = param.types.filter((member) => containsTypeParam(member));
+            for (const member of members) {
+                if (member.kind === 'param')
+                    continue;
+                const trial = new Map(bindings);
+                inferTypeParams(member, arg, trial, depth);
+                if (trial.size > bindings.size) {
+                    for (const [key, value] of trial)
+                        bindings.set(key, value);
+                    return;
+                }
+            }
+            const bare = members.find((member) => member.kind === 'param');
+            if (bare)
+                infer(bare, arg);
+            break;
+        }
+        case 'class':
+            if (arg.kind === 'class' && arg.info === param.info && param.args && arg.args) {
+                param.args.forEach((each, i) => infer(each, arg.args[i]));
+            }
+            break;
+        case 'object': {
+            if (param.instanceOf &&
+                arg.kind === 'object' &&
+                arg.instanceOf?.template === param.instanceOf.template) {
+                param.instanceOf.args.forEach((each, i) => infer(each, arg.instanceOf.args[i]));
+                break;
+            }
+            // Structurally: `{ value T }` from `{ value number }`. Types refer to themselves, and the
+            // methods of generic interfaces give ever new instances (`then` of a promise gives a
+            // promise), so only a few levels deep, as in TypeScript.
+            if (depth >= MAX_STRUCTURAL_DEPTH)
+                break;
+            const members = arg.kind === 'object'
+                ? arg.members
+                : arg.kind === 'class'
+                    ? instanceMembers(arg.info)
+                    : null;
+            if (!members)
+                break;
+            for (const name of memberNames(param.members)) {
+                const found = members.get(name);
+                const member = found && param.members.get(name);
+                if (member)
+                    inferTypeParams(member.type, found.type, bindings, depth + 1);
+            }
+            break;
+        }
+        case 'function':
+            if (arg.kind === 'function') {
+                param.params.forEach((p, i) => {
+                    const a = arg.params[i];
+                    if (a)
+                        infer(p, a);
+                });
+                // A callback without a result gives void: `then(text => { ... })`.
+                if (arg.results.length === 0 && param.results.length === 1)
+                    infer(param.results[0], VOID);
+                param.results.forEach((r, i) => {
+                    const a = arg.results[i];
+                    if (a)
+                        infer(r, a);
+                });
+            }
+            break;
+        default:
+            break;
+    }
+}

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

@@ -0,0 +1,6 @@
+import type { Type } from './model.ts';
+/** `[]byte`: a Uint8Array, of the lib files or the built-in one. */
+export declare function isBytes(type: Type): boolean;
+/** The name of a typed array, `[]float64` or `Float64Array`, or null for other types. */
+export declare function typedArrayOf(type: Type): string | null;
+export declare function typeToString(type: Type): string;

package/dist/checker/types/printing.js

@@ -0,0 +1,109 @@
+import { TYPED_ARRAYS, typedArrayName } from "../../typed-arrays.js";
+import { ERROR_CLASS } from "./classes.js";
+import { nullable } from "./constructors.js";
+// Types as text, for messages.
+/** How deep object types without a name are printed with their members. */
+const MAX_OBJECT_DEPTH = 3;
+/** How many members of an object type without a name are printed: `globalThis` has hundreds. */
+const MAX_OBJECT_MEMBERS = 8;
+let objectDepth = 0;
+/** `[]byte`: a Uint8Array, of the lib files or the built-in one. */
+export function isBytes(type) {
+    return typedArrayOf(type) === 'Uint8Array';
+}
+/** The name of a typed array, `[]float64` or `Float64Array`, or null for other types. */
+export function typedArrayOf(type) {
+    const name = type.kind === 'object' ? (type.instanceOf?.template.name ?? type.name) : null;
+    return name !== null && TYPED_ARRAYS.has(name) ? name : null;
+}
+export function typeToString(type) {
+    switch (type.kind) {
+        case 'number':
+        case 'bigint':
+        case 'string':
+        case 'bool':
+        case 'any':
+        case 'void':
+        case 'null':
+        case 'never':
+        case 'unknown':
+            return type.kind;
+        case 'array':
+            return `[]${grouped(type.element)}`;
+        case 'nullable':
+            if (type.type === ERROR_CLASS.instance)
+                return 'error';
+            return `?${grouped(type.type)}`;
+        case 'union':
+            return type.name ?? type.types.map(typeToString).join(' | ');
+        case 'literal':
+            return typeof type.value === 'string' ? JSON.stringify(type.value) : String(type.value);
+        case 'function': {
+            const params = type.params.map((param, i) => typeToString(i < type.required ? param : nullable(param)));
+            if (type.rest)
+                params.push(`...${typeToString(type.rest)}`);
+            return `func(${type.iterator ? 'yield ' : ''}${params.join(', ')})${resultsToString(type.results)}`;
+        }
+        // A property that may be left out is printed as nullable, as it is written in the type.
+        case 'component': {
+            const params = type.params.map((param) => `${param.name} ${typeToString(param.optional && param.name !== 'children' ? nullable(param.type) : param.type)}`);
+            return `comp(${params.join(', ')})`;
+        }
+        case 'object': {
+            const typed = typedArrayOf(type);
+            if (typed !== null)
+                return typedArrayName(typed);
+            // `chan T`, `chan<- T` and `<-chan T` are written with spaces, not as type arguments.
+            if (type.instanceOf &&
+                (type.name === 'chan' || type.name === 'chan<-' || type.name === '<-chan')) {
+                return `${type.name} ${typeToString(type.instanceOf.args[0])}`;
+            }
+            if (type.instanceOf && type.name !== null) {
+                return `${type.name}<${type.instanceOf.args.map(typeToString).join(', ')}>`;
+            }
+            if (type.name !== null)
+                return type.name;
+            // Types from a `.d.ts` may contain themselves without a name.
+            if (objectDepth >= MAX_OBJECT_DEPTH)
+                return '{ ... }';
+            objectDepth++;
+            try {
+                const members = [...type.members]
+                    .slice(0, MAX_OBJECT_MEMBERS)
+                    .map(([name, member]) => `${name} ${typeToString(member.type)}`);
+                if (type.members.size > MAX_OBJECT_MEMBERS)
+                    members.push('...');
+                if (type.numberIndex)
+                    members.unshift(`[number]: ${typeToString(type.numberIndex)}`);
+                if (type.index)
+                    members.unshift(`[string]: ${typeToString(type.index)}`);
+                return members.length === 0 ? '{}' : `{ ${members.join('; ')} }`;
+            }
+            finally {
+                objectDepth--;
+            }
+        }
+        case 'class':
+            return type.args
+                ? `${type.info.name}<${type.args.map(typeToString).join(', ')}>`
+                : type.info.name;
+        case 'classValue':
+            return `class ${type.info.name}`;
+        case 'tuple':
+            return `(${type.types.map(typeToString).join(', ')})`;
+        case 'param':
+            return type.name;
+    }
+}
+/** A union without a name needs parentheses after `[]` and `?`: `[](string | number)`. */
+function grouped(type) {
+    const text = typeToString(type);
+    return type.kind === 'union' && type.name === undefined ? `(${text})` : text;
+}
+function resultsToString(results) {
+    if (results.length === 0)
+        return '';
+    if (results.length === 1)
+        return ` ${typeToString(results[0])}`;
+    return ` (${results.map(typeToString).join(', ')})`;
+}

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

@@ -0,0 +1,16 @@
+import { type Type } from './model.ts';
+/** Whether a value of type `source` can be used where `target` is expected. */
+export declare function isAssignable(source: Type, target: Type): boolean;
+export declare function assignable(source: Type, target: Type, assuming: [Type, Type][]): boolean;
+/** Why `source` is not assignable to an object or class `target`, e.g. `missing field "y"`. */
+export declare function explainMismatch(source: Type, target: Type): string | null;
+/**
+ * Can values of these types be compared with `==`? Literals must be able to be equal:
+ * `filter == "activ"` is an error when `filter` is `"all" | "active"`.
+ */
+export declare function isComparable(a: Type, b: Type): boolean;
+/** A type that both can be used as, e.g. for array elements: one of them, or their union. */
+export declare function commonType(a: Type, b: Type): Type;
+export declare function typesEqual(a: Type, b: Type): boolean;
+/** Types that a variable can have without an initial value: `0`, `""`, `false`, `[]`, `null`. */
+export declare function hasZeroValue(type: Type): boolean;

package/dist/checker/types/relations.js

@@ -0,0 +1,294 @@
+import { instanceMembers, isSubclass, publicMembers } from "./classes.js";
+import { memberNames } from "./lazy.js";
+import { isNullable, literalBase, nonNull, union } from "./constructors.js";
+import { UNKNOWN, VOID, } from "./model.js";
+import { typedArrayOf, typeToString } from "./printing.js";
+// Relations between types: assignability, comparison, equality, common types.
+/** Whether a value of type `source` can be used where `target` is expected. */
+export function isAssignable(source, target) {
+    return assignable(source, target, []);
+}
+export function assignable(source, target, assuming) {
+    if (source === target)
+        return true;
+    if (source.kind === 'any' || source.kind === 'unknown' || source.kind === 'never')
+        return true;
+    if (target.kind === 'any' || target.kind === 'unknown')
+        return true;
+    if (target.kind === 'nullable') {
+        if (source.kind === 'null')
+            return true;
+        return assignable(nonNull(source), target.type, assuming);
+    }
+    if (source.kind === 'nullable' || source.kind === 'null')
+        return false;
+    // A union can be used where each of its members can; a union accepts what one member accepts.
+    if (source.kind === 'union')
+        return source.types.every((type) => assignable(type, target, assuming));
+    if (target.kind === 'union')
+        return target.types.some((type) => assignable(source, type, assuming));
+    if (target.kind === 'literal')
+        return source.kind === 'literal' && source.value === target.value;
+    if (source.kind === 'literal')
+        return assignable(literalBase(source), target, assuming);
+    // Recursive types (e.g. `next ?Node`): assume the pair matches while checking it.
+    if (assuming.some(([s, t]) => s === source && t === target))
+        return true;
+    const nested = [...assuming, [source, target]];
+    // Inside a generic function, `T Shape` can be used as a `Shape`.
+    if (source.kind === 'param' && source !== target) {
+        return source.constraint ? assignable(source.constraint, target, nested) : false;
+    }
+    switch (target.kind) {
+        case 'number':
+        case 'bigint':
+        case 'string':
+        case 'bool':
+        case 'void':
+            return source.kind === target.kind;
+        case 'null':
+        case 'never':
+        case 'param':
+            return false;
+        case 'array':
+            return source.kind === 'array' && assignable(source.element, target.element, nested);
+        case 'tuple':
+            return (source.kind === 'tuple' &&
+                source.types.length === target.types.length &&
+                source.types.every((type, i) => assignable(type, target.types[i], nested)));
+        case 'function':
+            return source.kind === 'function' && functionAssignable(source, target, nested);
+        case 'component':
+            return source.kind === 'component' && componentAssignable(source, target, nested);
+        case 'classValue':
+            return source.kind === 'classValue' && isSubclass(source.info, target.info);
+        case 'class': {
+            if (source.kind === 'class' && source.info === target.info && target.args) {
+                return (source.args ?? []).every((arg, i) => assignable(arg, target.args[i], nested));
+            }
+            if (source.kind === 'class' && isSubclass(source.info, target.info))
+                return true;
+            // Private and protected members make a class nominal, as in TypeScript.
+            const members = instanceMembers(target.info);
+            if ([...members.values()].some((member) => member.visibility !== 'public'))
+                return false;
+            return missingMember(source, members, nested) === null;
+        }
+        case 'object': {
+            // A channel both takes and gives values, so `chan number` is not a `chan ?number`, as in Go;
+            // `chan any` is any channel, for `close(ch)`. A `chan T` is also a channel of one
+            // direction, `chan<- T` or `<-chan T`, but not the other way round.
+            const direction = target.instanceOf
+                ? CHAN_NAMES.get(target.instanceOf.template.name ?? '')
+                : undefined;
+            if (target.instanceOf && direction !== undefined) {
+                const element = target.instanceOf.args[0];
+                const from = source.kind === 'object' && source.instanceOf
+                    ? CHAN_NAMES.get(source.instanceOf.template.name ?? '')
+                    : undefined;
+                return (source.kind === 'object' &&
+                    from !== undefined &&
+                    (from === direction || from === 'both' || element.kind === 'any') &&
+                    (element.kind === 'any' ||
+                        (assignable(source.instanceOf.args[0], element, nested) &&
+                            assignable(element, source.instanceOf.args[0], nested))));
+            }
+            // A callable interface from a `.d.ts`: `interface Listener { (event: Event): void }`.
+            if (target.call) {
+                const call = source.kind === 'function' ? source : source.kind === 'object' ? source.call : null;
+                if (!call || !functionAssignable(call, target.call, nested))
+                    return false;
+                if (source.kind === 'function')
+                    return target.members.size === 0;
+            }
+            if (target.index && !indexAssignable(source, target.index, nested))
+                return false;
+            if (target.numberIndex && !numberIndexAssignable(source, target.numberIndex, nested)) {
+                return false;
+            }
+            return missingMember(source, target.members, nested) === null;
+        }
+    }
+}
+/** `{ [string]: T }` accepts an object whose own index and fields are all `T`. */
+/** The templates of channel types by name (channel.ts): no other type can have these names. */
+const CHAN_NAMES = new Map([
+    ['chan', 'both'],
+    ['chan<-', 'send'],
+    ['<-chan', 'receive'],
+]);
+function indexAssignable(source, index, assuming) {
+    if (source.kind !== 'object')
+        return false;
+    if (source.index && !assignable(source.index, index, assuming))
+        return false;
+    return [...memberNames(source.members)].every((name) => {
+        const member = source.members.get(name);
+        return !member || member.method || assignable(member.type, index, assuming);
+    });
+}
+/** `ArrayLike<T>` from a `.d.ts` accepts an array, a string or a typed array of `T`. */
+function numberIndexAssignable(source, index, assuming) {
+    if (source.kind === 'array')
+        return assignable(source.element, index, assuming);
+    if (source.kind === 'string')
+        return assignable(source, index, assuming);
+    return (source.kind === 'object' &&
+        source.numberIndex !== undefined &&
+        assignable(source.numberIndex, index, assuming));
+}
+function functionAssignable(source, target, assuming) {
+    // An iterator is a JS generator: it does not take the callback that a function of its shape does.
+    if (Boolean(source.iterator) !== Boolean(target.iterator))
+        return false;
+    if (source.typeParams.length > 0 || target.typeParams.length > 0)
+        return true;
+    // A function may ignore parameters it is given, but not require more than it gets.
+    if (source.required > target.params.length && target.rest === null)
+        return false;
+    const shared = Math.min(source.params.length, target.params.length);
+    for (let i = 0; i < shared; i++) {
+        if (!assignable(target.params[i], source.params[i], assuming))
+            return false;
+    }
+    // A callback that returns something can be used where nothing is expected.
+    if (target.results.length === 0)
+        return true;
+    // And one that returns nothing where `void` may be returned, as `TResult | PromiseLike<TResult>`
+    // of `then` once TResult is void.
+    if (source.results.length === 0 && target.results.length === 1) {
+        return assignable(VOID, target.results[0], assuming);
+    }
+    return (source.results.length === target.results.length &&
+        source.results.every((type, i) => assignable(type, target.results[i], assuming)));
+}
+/**
+ * A tag passes the properties of `target` by position, so `source` must have the same names in
+ * the same order, and may have more only if they can be left out. A property with a default
+ * value takes a nullable one: null gives it the default value.
+ */
+function componentAssignable(source, target, assuming) {
+    return (source.params.every((param, i) => i < target.params.length || param.optional) &&
+        target.params.every((expected, i) => {
+            const param = source.params[i];
+            if (!param || param.name !== expected.name || (expected.optional && !param.optional)) {
+                return false;
+            }
+            return (assignable(expected.type, param.type, assuming) ||
+                (param.optional && assignable(nonNull(expected.type), param.type, assuming)));
+        }));
+}
+/**
+ * The first member of `members` that `source` lacks or has with an incompatible type, or `null`
+ * if there is none. Properties with a nullable type may be missing.
+ */
+function missingMember(source, members, assuming) {
+    const own = publicMembers(source);
+    if (own === null)
+        return { name: '', found: null, expected: UNKNOWN };
+    for (const [name, member] of members) {
+        const found = own.get(name);
+        if (!found) {
+            if (!member.method && isNullable(member.type))
+                continue;
+            return { name, found: null, expected: member.type };
+        }
+        if (!assignable(found.type, member.type, assuming)) {
+            return { name, found: found.type, expected: member.type };
+        }
+    }
+    return null;
+}
+/** Why `source` is not assignable to an object or class `target`, e.g. `missing field "y"`. */
+export function explainMismatch(source, target) {
+    // `Stack<number>` and `Stack<string>`: the type arguments already say what differs.
+    if (source.kind === 'class' && target.kind === 'class' && source.info === target.info) {
+        return null;
+    }
+    const members = target.kind === 'object'
+        ? target.members
+        : target.kind === 'class'
+            ? instanceMembers(target.info)
+            : null;
+    if (members === null || publicMembers(source) === null)
+        return null;
+    const missing = missingMember(source, members, []);
+    if (missing === null)
+        return null;
+    if (missing.found === null)
+        return `missing "${missing.name}"`;
+    return `"${missing.name}" is ${typeToString(missing.found)}, not ${typeToString(missing.expected)}`;
+}
+/**
+ * Can values of these types be compared with `==`? Literals must be able to be equal:
+ * `filter == "activ"` is an error when `filter` is `"all" | "active"`.
+ */
+export function isComparable(a, b) {
+    if (a.kind === 'null' || b.kind === 'null')
+        return true;
+    const x = nonNull(a);
+    const y = nonNull(b);
+    if (x.kind === 'union')
+        return x.types.some((type) => isComparable(type, y));
+    if (y.kind === 'union')
+        return y.types.some((type) => isComparable(x, type));
+    return isAssignable(x, y) || isAssignable(y, x);
+}
+/** A type that both can be used as, e.g. for array elements: one of them, or their union. */
+export function commonType(a, b) {
+    if (isAssignable(b, a))
+        return a.kind === 'never' ? b : a;
+    if (isAssignable(a, b))
+        return b;
+    return union([a, b]);
+}
+export function typesEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a.kind === 'array' && b.kind === 'array')
+        return typesEqual(a.element, b.element);
+    if (a.kind === 'nullable' && b.kind === 'nullable')
+        return typesEqual(a.type, b.type);
+    if (a.kind === 'literal' && b.kind === 'literal')
+        return a.value === b.value;
+    if (a.kind === 'class' && b.kind === 'class') {
+        return (a.info === b.info && (a.args ?? []).every((arg, i) => typesEqual(arg, b.args?.[i] ?? arg)));
+    }
+    if (a.kind === 'object' && b.kind === 'object' && a.instanceOf && b.instanceOf) {
+        return (a.instanceOf.template === b.instanceOf.template &&
+            a.instanceOf.args.every((arg, i) => typesEqual(arg, b.instanceOf.args[i])));
+    }
+    if (a.kind === 'component' && b.kind === 'component') {
+        return (a.params.length === b.params.length &&
+            a.params.every((param, i) => {
+                const other = b.params[i];
+                return (param.name === other.name &&
+                    param.optional === other.optional &&
+                    typesEqual(param.type, other.type));
+            }));
+    }
+    if (a.kind === 'union' && b.kind === 'union') {
+        return (a.types.length === b.types.length &&
+            a.types.every((type) => b.types.some((other) => typesEqual(type, other))));
+    }
+    return false;
+}
+/** Types that a variable can have without an initial value: `0`, `""`, `false`, `[]`, `null`. */
+export function hasZeroValue(type) {
+    if (typedArrayOf(type) !== null)
+        return true;
+    switch (type.kind) {
+        case 'number':
+        case 'bigint':
+        case 'string':
+        case 'bool':
+        case 'array':
+        case 'nullable':
+        case 'null':
+        case 'any':
+        case 'unknown':
+            return true;
+        default:
+            return false;
+    }
+}

package/dist/checker/types.d.ts

@@ -0,0 +1,9 @@
+export * from './types/model.ts';
+export * from './types/constructors.ts';
+export * from './types/lazy.ts';
+export * from './types/generics.ts';
+export * from './types/classes.ts';
+export * from './types/relations.ts';
+export * from './types/params.ts';
+export * from './types/printing.ts';
+export * from './types/bytes.ts';

package/dist/checker/types.js

@@ -0,0 +1,10 @@
+// The types of the checker, by topic in src/checker/types/.
+export * from "./types/model.js";
+export * from "./types/constructors.js";
+export * from "./types/lazy.js";
+export * from "./types/generics.js";
+export * from "./types/classes.js";
+export * from "./types/relations.js";
+export * from "./types/params.js";
+export * from "./types/printing.js";
+export * from "./types/bytes.js";

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};