rooklang 0.0.0-stage → 0.3.0

package/dist/checker/bigint.d.ts

@@ -0,0 +1,15 @@
+import type * as ast from '../ast.ts';
+import { type Member, type ObjectType, type Type } from './types.ts';
+/** What an operator gives for a bigint, and the error to report if it cannot take one. */
+export interface BigintResult {
+    type: Type;
+    error?: string;
+}
+/** `left <operator> right` when either side is a bigint, or `null` to check it as usual. */
+export declare function bigintBinary(operator: ast.BinaryOperator, left: Type, right: Type): BigintResult | null;
+/** `-b`, `~b` and `+b` of a bigint, or `null` when the value is not one. */
+export declare function bigintUnary(operator: '-' | '+' | '~', type: Type): BigintResult | null;
+/** The members of a bigint that the built-in types list; the lib files add the rest. */
+export declare function bigintMember(name: string): Member | undefined;
+/** `BigInt(x)` makes a bigint of a number, a string or a bool; `BigInt.asIntN(64, b)` wraps one. */
+export declare const BIGINT_OBJECT: ObjectType;

package/dist/checker/bigint.js

@@ -0,0 +1,85 @@
+import { isUntyped } from "./helpers.js";
+import { ANY, BIGINT, BOOL, func, method, NUMBER, STRING, typeToString, union, UNKNOWN, widenLiterals, } from "./types.js";
+const MIX_HINT = 'convert one of them, e.g. BigInt(n) or Number(b)';
+const isBigint = (type) => widenLiterals(type).kind === 'bigint';
+const isNumber = (type) => widenLiterals(type).kind === 'number';
+/** `left <operator> right` when either side is a bigint, or `null` to check it as usual. */
+export function bigintBinary(operator, left, right) {
+    if (!isBigint(left) && !isBigint(right))
+        return null;
+    const mixed = (isBigint(left) && isNumber(right)) || (isNumber(left) && isBigint(right));
+    const untyped = isUntyped(left) || isUntyped(right);
+    const both = isBigint(left) && isBigint(right);
+    switch (operator) {
+        case '>>>':
+            return { type: UNKNOWN, error: '">>>" does not work with bigint: use ">>"' };
+        case '+':
+        case '-':
+        case '*':
+        case '/':
+        case '%':
+        case '**':
+        case '<<':
+        case '>>':
+        case '&':
+        case '|':
+        case '^':
+            if (both)
+                return { type: BIGINT };
+            if (untyped)
+                return { type: operator === '+' ? ANY : BIGINT };
+            if (mixed) {
+                return {
+                    type: UNKNOWN,
+                    error: `cannot mix bigint and number in "${operator}": ${MIX_HINT}`,
+                };
+            }
+            return null;
+        case '<':
+        case '>':
+        case '<=':
+        case '>=':
+            return both || mixed || untyped ? { type: BOOL } : null;
+        case '==':
+        case '!=':
+            return mixed
+                ? {
+                    type: BOOL,
+                    error: `cannot compare ${typeToString(left)} and ${typeToString(right)} with "${operator}", it is always ${operator === '!='}: ${MIX_HINT}`,
+                }
+                : null;
+        default:
+            return null;
+    }
+}
+/** `-b`, `~b` and `+b` of a bigint, or `null` when the value is not one. */
+export function bigintUnary(operator, type) {
+    if (!isBigint(type))
+        return null;
+    return operator === '+'
+        ? { type: UNKNOWN, error: '"+" does not work with bigint: use Number(b)' }
+        : { type: BIGINT };
+}
+/** The members of a bigint that the built-in types list; the lib files add the rest. */
+export function bigintMember(name) {
+    switch (name) {
+        case 'toString':
+            return method(func([NUMBER], [STRING], { required: 0 }));
+        case 'toLocaleString':
+            return method(func([ANY, ANY], [STRING], { required: 0 }));
+        case 'valueOf':
+            return method(func([], [BIGINT]));
+        default:
+            return undefined;
+    }
+}
+/** `BigInt(x)` makes a bigint of a number, a string or a bool; `BigInt.asIntN(64, b)` wraps one. */
+export const BIGINT_OBJECT = {
+    kind: 'object',
+    name: 'BigInt',
+    members: new Map([
+        ['asIntN', method(func([NUMBER, BIGINT], [BIGINT]))],
+        ['asUintN', method(func([NUMBER, BIGINT], [BIGINT]))],
+    ]),
+    call: func([union([NUMBER, STRING, BOOL, BIGINT])], [BIGINT]),
+};

package/dist/checker/builtins.d.ts

@@ -0,0 +1,9 @@
+import { type Member, type Type } from './types.ts';
+export declare function stringMember(name: string): Member | undefined;
+export declare function numberMember(name: string): Member | undefined;
+export declare function boolMember(name: string): Member | undefined;
+export declare function arrayMember(element: Type, name: string): Member | undefined;
+export declare const GLOBAL_VALUES: ReadonlyMap<string, Type>;
+/** Built-in types that a library from TypeScript's lib files replaces: untyped ones and the DOM. */
+export declare const LIBRARY_TYPES: ReadonlySet<string>;
+export declare const GLOBAL_TYPES: ReadonlyMap<string, Type>;

package/dist/checker/builtins.js

@@ -0,0 +1,307 @@
+import { holdsBigInts, TYPED_ELEMENTS } from "../typed-arrays.js";
+import { BIGINT_OBJECT } from "./bigint.js";
+import { DOM_TYPES, EVENT } from "./dom.js";
+import { SVG_TYPES } from "./dom-svg.js";
+import { chanOf } from "./channel.js";
+import { PROMISE } from "./promise.js";
+import { BUFFERS } from "./transfer.js";
+import { ANY, arrayOf, BIGINT, BOOL, ERROR, ERROR_CLASS, func, method, NUMBER, nullable, property, STRING, } from "./types.js";
+// Types of the JS standard library that Rook programs use most. Anything not listed here
+// can still be reached through the untyped globals below.
+function object(name, members, call) {
+    return { kind: 'object', name, members: new Map(Object.entries(members)), call: call ?? null };
+}
+const numberToNumber = method(func([NUMBER], [NUMBER]));
+export function stringMember(name) {
+    switch (name) {
+        case 'length':
+            return property(NUMBER);
+        case 'at':
+            return method(func([NUMBER], [nullable(STRING)]));
+        case 'charAt':
+            return method(func([NUMBER], [STRING]));
+        case 'charCodeAt':
+            return method(func([NUMBER], [NUMBER]));
+        case 'codePointAt':
+            return method(func([NUMBER], [nullable(NUMBER)]));
+        case 'indexOf':
+        case 'lastIndexOf':
+            return method(func([STRING, NUMBER], [NUMBER], { required: 1 }));
+        case 'includes':
+        case 'startsWith':
+        case 'endsWith':
+            return method(func([STRING, NUMBER], [BOOL], { required: 1 }));
+        case 'slice':
+        case 'substring':
+            return method(func([NUMBER, NUMBER], [STRING], { required: 0 }));
+        case 'toUpperCase':
+        case 'toLowerCase':
+        case 'trim':
+        case 'trimStart':
+        case 'trimEnd':
+        case 'normalize':
+        case 'toString':
+            return method(func([], [STRING]));
+        case 'split':
+            return method(func([ANY, NUMBER], [arrayOf(STRING)], { required: 0 }));
+        case 'replace':
+        case 'replaceAll':
+            return method(func([ANY, ANY], [STRING]));
+        case 'repeat':
+            return method(func([NUMBER], [STRING]));
+        case 'padStart':
+        case 'padEnd':
+            return method(func([NUMBER, STRING], [STRING], { required: 1 }));
+        case 'concat':
+            return method(func([], [STRING], { rest: STRING }));
+        case 'localeCompare':
+            return method(func([STRING], [NUMBER]));
+        case 'match':
+            return method(func([ANY], [ANY]));
+        default:
+            return undefined;
+    }
+}
+export function numberMember(name) {
+    switch (name) {
+        case 'toFixed':
+        case 'toPrecision':
+        case 'toString':
+            return method(func([NUMBER], [STRING], { required: 0 }));
+        case 'toLocaleString':
+            return method(func([], [STRING]));
+        default:
+            return undefined;
+    }
+}
+export function boolMember(name) {
+    return name === 'toString' ? method(func([], [STRING])) : undefined;
+}
+export function arrayMember(element, name) {
+    const array = arrayOf(element);
+    const U = { kind: 'param', name: 'U' };
+    /** `func(value T, index number) R`; callbacks may declare fewer parameters. */
+    const callback = (result) => func([element, NUMBER], [result]);
+    switch (name) {
+        case 'length':
+            return property(NUMBER);
+        case 'push':
+        case 'unshift':
+            return method(func([], [NUMBER], { rest: element }));
+        case 'pop':
+        case 'shift':
+            return method(func([], [nullable(element)]));
+        case 'at':
+            return method(func([NUMBER], [nullable(element)]));
+        case 'indexOf':
+        case 'lastIndexOf':
+            return method(func([element], [NUMBER]));
+        case 'includes':
+            return method(func([element], [BOOL]));
+        case 'join':
+            return method(func([STRING], [STRING], { required: 0 }));
+        case 'slice':
+            return method(func([NUMBER, NUMBER], [array], { required: 0 }));
+        case 'splice':
+            return method(func([NUMBER, NUMBER], [array], { required: 1, rest: element }));
+        case 'concat':
+            return method(func([], [array], { rest: array }));
+        case 'reverse':
+            return method(func([], [array]));
+        case 'fill':
+            return method(func([element], [array]));
+        case 'sort':
+            return method(func([func([element, element], [NUMBER])], [array], { required: 0 }));
+        case 'map':
+            return method(func([callback(U)], [arrayOf(U)], { typeParams: [U] }));
+        case 'flatMap':
+            return method(func([callback(arrayOf(U))], [arrayOf(U)], { typeParams: [U] }));
+        case 'filter':
+            return method(func([callback(BOOL)], [array]));
+        case 'find':
+        case 'findLast':
+            return method(func([callback(BOOL)], [nullable(element)]));
+        case 'findIndex':
+        case 'findLastIndex':
+            return method(func([callback(BOOL)], [NUMBER]));
+        case 'some':
+        case 'every':
+            return method(func([callback(BOOL)], [BOOL]));
+        case 'forEach':
+            return method(func([func([element, NUMBER], [])], []));
+        case 'reduce':
+            return method(func([func([U, element, NUMBER], [U]), U], [U], { typeParams: [U] }));
+        case 'entries':
+        case 'keys':
+        case 'values':
+            return method(func([], [ANY]));
+        case 'toString':
+            return method(func([], [STRING]));
+        default:
+            return undefined;
+    }
+}
+const log = method(func([], [], { rest: ANY }));
+const console = object('console', {
+    log,
+    error: log,
+    warn: log,
+    info: log,
+    debug: log,
+});
+const math = object('Math', {
+    PI: property(NUMBER),
+    E: property(NUMBER),
+    LN2: property(NUMBER),
+    LN10: property(NUMBER),
+    SQRT2: property(NUMBER),
+    abs: numberToNumber,
+    floor: numberToNumber,
+    ceil: numberToNumber,
+    round: numberToNumber,
+    trunc: numberToNumber,
+    sign: numberToNumber,
+    sqrt: numberToNumber,
+    cbrt: numberToNumber,
+    exp: numberToNumber,
+    log: numberToNumber,
+    log2: numberToNumber,
+    log10: numberToNumber,
+    sin: numberToNumber,
+    cos: numberToNumber,
+    tan: numberToNumber,
+    asin: numberToNumber,
+    acos: numberToNumber,
+    atan: numberToNumber,
+    pow: method(func([NUMBER, NUMBER], [NUMBER])),
+    atan2: method(func([NUMBER, NUMBER], [NUMBER])),
+    min: method(func([], [NUMBER], { rest: NUMBER })),
+    max: method(func([], [NUMBER], { rest: NUMBER })),
+    hypot: method(func([], [NUMBER], { rest: NUMBER })),
+    random: method(func([], [NUMBER])),
+});
+const json = object('JSON', {
+    parse: method(func([STRING], [ANY])),
+    stringify: method(func([ANY], [STRING], { rest: ANY })),
+});
+const numberObject = object('Number', {
+    isNaN: method(func([ANY], [BOOL])),
+    isInteger: method(func([ANY], [BOOL])),
+    isFinite: method(func([ANY], [BOOL])),
+    isSafeInteger: method(func([ANY], [BOOL])),
+    parseFloat: method(func([STRING], [NUMBER])),
+    parseInt: method(func([STRING, NUMBER], [NUMBER], { required: 1 })),
+    MAX_SAFE_INTEGER: property(NUMBER),
+    MIN_SAFE_INTEGER: property(NUMBER),
+    MAX_VALUE: property(NUMBER),
+    MIN_VALUE: property(NUMBER),
+    EPSILON: property(NUMBER),
+    POSITIVE_INFINITY: property(NUMBER),
+    NEGATIVE_INFINITY: property(NUMBER),
+    NaN: property(NUMBER),
+}, func([ANY], [NUMBER]));
+const stringObject = object('String', { fromCharCode: method(func([], [STRING], { rest: NUMBER })) }, func([ANY], [STRING]));
+const booleanObject = object('Boolean', {}, func([ANY], [BOOL]));
+const timer = func([func([], []), NUMBER], [ANY], { required: 1, rest: ANY });
+/** JS globals that are available without types: everything about them is `any`. */
+const MOVED = { kind: 'param', name: 'T' };
+const UNTYPED_GLOBALS = [
+    'Object',
+    'Array',
+    'Date',
+    'RegExp',
+    'Map',
+    'Set',
+    'WeakMap',
+    'WeakSet',
+    'Promise',
+    'Symbol',
+    'Reflect',
+    'Proxy',
+    'Intl',
+    'globalThis',
+    'process',
+    'Buffer',
+    'URL',
+    'URLSearchParams',
+    'TextEncoder',
+    'TextDecoder',
+    'AbortController',
+    'fetch',
+    'structuredClone',
+    'queueMicrotask',
+    'window',
+    'document',
+    'navigator',
+    'location',
+    'localStorage',
+    'sessionStorage',
+    'crypto',
+    'performance',
+];
+export const GLOBAL_VALUES = new Map([
+    ['console', console],
+    ['Math', math],
+    ['JSON', json],
+    ['Number', numberObject],
+    ['BigInt', BIGINT_OBJECT],
+    ['String', stringObject],
+    ['Boolean', booleanObject],
+    ['parseInt', func([STRING, NUMBER], [NUMBER], { required: 1 })],
+    ['parseFloat', func([STRING], [NUMBER])],
+    ['isNaN', func([NUMBER], [BOOL])],
+    ['isFinite', func([NUMBER], [BOOL])],
+    ...['encodeURIComponent', 'decodeURIComponent', 'encodeURI', 'decodeURI'].map((name) => [name, func([STRING], [STRING])]),
+    ['setTimeout', timer],
+    ['setInterval', timer],
+    ['clearTimeout', func([ANY], [])],
+    ['clearInterval', func([ANY], [])],
+    ['NaN', NUMBER],
+    ['Infinity', NUMBER],
+    ['Error', ERROR_CLASS.value],
+    // `error("message")` creates an Error, so the result is never null.
+    ['error', func([STRING], [ERROR_CLASS.instance])],
+    // `close(ch)`: the channel takes no more values (a `<-chan T` cannot be closed: channels.ts).
+    ['close', func([chanOf(ANY)], [])],
+    // `transfer(buffer)`: the buffer moves to the thread it goes to (what it takes: channels.ts).
+    ['transfer', func([MOVED], [MOVED], { typeParams: [MOVED] })],
+    // Channels of time, as in Go: the time once after `ms`, or every `ms` until `close(ticks)`.
+    ['after', func([NUMBER], [chanOf(NUMBER, 'receive')])],
+    ['tick', func([NUMBER], [chanOf(NUMBER)])],
+    // `cancel(task)` stops a goroutine: it takes the Promise of `go` (channels.ts).
+    ['cancel', func([ANY], [])],
+    ...[...UNTYPED_GLOBALS, ...BUFFERS].map((name) => [name, ANY]),
+]);
+/** Built-in types that a library from TypeScript's lib files replaces: untyped ones and the DOM. */
+export const LIBRARY_TYPES = new Set([
+    'Date',
+    'RegExp',
+    'Map',
+    'Set',
+    'Promise',
+    'URL',
+    'Event',
+    ...BUFFERS,
+    ...[...DOM_TYPES.keys()].filter((name) => name !== 'Content'),
+    ...SVG_TYPES.keys(),
+]);
+export const GLOBAL_TYPES = new Map([
+    ['number', NUMBER],
+    // A number from 0 to 255; `[]byte` is a Uint8Array, and `[]float64` a Float64Array
+    // (typed-arrays.ts). The ranges of the elements are not checked.
+    ...[...TYPED_ELEMENTS].map(([name, array]) => [
+        name,
+        holdsBigInts(array) ? BIGINT : NUMBER,
+    ]),
+    ['bigint', BIGINT],
+    ['string', STRING],
+    ['bool', BOOL],
+    ['any', ANY],
+    ['error', ERROR],
+    ['Error', ERROR_CLASS.instance],
+    ...['Date', 'RegExp', 'Map', 'Set', 'URL', ...BUFFERS].map((name) => [name, ANY]),
+    ['Promise', PROMISE],
+    ...DOM_TYPES,
+    ...SVG_TYPES,
+    ['Event', EVENT],
+]);

package/dist/checker/bytes.d.ts

@@ -0,0 +1,11 @@
+import type * as ast from '../ast.ts';
+import { ChannelChecker } from './channels.ts';
+import { type Type } from './types.ts';
+export declare abstract class BytesChecker extends ChannelChecker {
+    protected checkArrayLiteral(node: ast.ArrayLiteral, expected: Type | null): Type;
+    private isElements;
+    /** `make([]float64, n)`: a typed array of `n` zeros. */
+    protected checkMake(node: ast.MakeExpression): Type;
+    protected checkConversion(node: ast.ConversionExpression): Type;
+    protected checkChain(node: ast.MemberExpression | ast.IndexExpression | ast.CallExpression, expected?: Type | null): [Type, boolean];
+}

package/dist/checker/bytes.js

@@ -0,0 +1,72 @@
+import { ChannelChecker } from "./channels.js";
+import { isUntyped } from "./helpers.js";
+import { holdsBigInts } from "../typed-arrays.js";
+import { BIGINT, isBytes, nonNull, NUMBER, STRING, typedArrayOf, typeToString, UNKNOWN, } from "./types.js";
+// `[]byte`, a Uint8Array, and the other typed arrays, `[]float64`: an array literal where one is
+// expected, `let data []byte = [1, 2]`; and the conversions of Go between text and its UTF-8
+// bytes, `[]byte("rook")` and `string(data)`.
+export class BytesChecker extends ChannelChecker {
+    checkArrayLiteral(node, expected) {
+        const typed = expected && nonNull(expected);
+        const name = typed && typedArrayOf(typed);
+        if (!typed || name === null)
+            return super.checkArrayLiteral(node, expected);
+        const element = holdsBigInts(name) ? BIGINT : NUMBER;
+        for (const item of node.elements) {
+            if (item.kind === 'SpreadElement') {
+                const spread = this.checkValue(item.argument, typed);
+                if (typedArrayOf(spread) !== name && !this.isElements(spread, element)) {
+                    this.error(`cannot spread ${typeToString(spread)} into ${typeToString(typed)}`, item.argument);
+                }
+            }
+            else {
+                this.expectAssignable(this.checkValue(item, element), element, item);
+            }
+        }
+        return typed;
+    }
+    isElements(type, element) {
+        return isUntyped(type) || (type.kind === 'array' && type.element.kind === element.kind);
+    }
+    /** `make([]float64, n)`: a typed array of `n` zeros. */
+    checkMake(node) {
+        const type = this.resolveType(node.type);
+        this.expectAssignable(this.checkValue(node.length, NUMBER), NUMBER, node.length);
+        if (typedArrayOf(type) === null) {
+            this.error(`make makes a typed array, e.g. make([]float64, n), not ${typeToString(type)}; a list starts empty and grows, e.g. let names []string = []`, node.type);
+        }
+        return type;
+    }
+    checkConversion(node) {
+        const type = this.resolveType(node.type);
+        const argument = this.checkValue(node.argument, STRING);
+        if (!isBytes(type)) {
+            this.error(`cannot convert to ${typeToString(type)}: only []byte("text") and string(bytes) convert between types; for other values call a function, e.g. Number(s)`, node.type);
+            return UNKNOWN;
+        }
+        if (!isUntyped(argument) && argument.kind !== 'string' && argument.kind !== 'literal') {
+            this.error(`[]byte(...) gives the UTF-8 bytes of a string, not of ${typeToString(argument)}; bytes are written as a list, e.g. let data []byte = [1, 2]`, node.argument);
+        }
+        return type;
+    }
+    // `string(data)`: `string` is a type, so a call of it is the conversion, unless the program has
+    // a value of that name.
+    checkChain(node, expected = null) {
+        if (node.kind !== 'CallExpression' ||
+            node.callee.kind !== 'Identifier' ||
+            node.callee.name !== 'string' ||
+            this.lookupValue('string') !== undefined) {
+            return super.checkChain(node, expected);
+        }
+        const [argument, ...rest] = node.arguments;
+        if (!argument || argument.kind === 'SpreadElement' || rest.length > 0) {
+            this.error('string(...) takes one []byte, e.g. string(data)', node);
+            return [STRING, false];
+        }
+        const type = this.checkValue(argument, this.bytes());
+        if (!isBytes(type) && !isUntyped(type)) {
+            this.error(`string(...) turns []byte into text, not ${typeToString(type)}; for other values use String(x) or a template string, e.g. \`\${x}\``, argument);
+        }
+        return [STRING, false];
+    }
+}

package/dist/checker/calls.d.ts

@@ -0,0 +1,23 @@
+import type * as ast from '../ast.ts';
+import { MemberChecker } from './members.ts';
+import { type FunctionType, type Type, type TypeParam } from './types.ts';
+export declare abstract class CallChecker extends MemberChecker {
+    protected checkCall(node: ast.CallExpression, callee: Type, expected?: Type | null): Type;
+    protected checkSuperCall(node: ast.CallExpression): Type;
+    protected checkNew(node: ast.NewExpression, expected?: Type | null): Type;
+    /**
+     * Checks a call of an overloaded function (from a `.d.ts`): the first signature that fits the
+     * arguments is used. Signatures that take this many arguments are tried first.
+     */
+    protected checkOverloads(signatures: readonly FunctionType[], args: readonly (ast.Expression | ast.SpreadElement)[], node: ast.NodeBase, expected: Type | null): {
+        results: Type[];
+        inferred: Map<TypeParam, Type>;
+    };
+    protected checkArgumentsLoosely(args: readonly (ast.Expression | ast.SpreadElement)[]): void;
+    /**
+     * Checks call arguments against a signature and returns the result types. Type parameters are
+     * inferred into `inferred` from the arguments and then from the expected result.
+     */
+    protected checkArguments(signature: FunctionType, args: readonly (ast.Expression | ast.SpreadElement)[], node: ast.NodeBase, inferred?: Map<TypeParam, Type>, expected?: Type | null): Type[];
+    protected checkArgumentList(signature: FunctionType, args: readonly (ast.Expression | ast.SpreadElement)[], inferred: Map<TypeParam, Type>, needsContext: (arg: ast.Expression | ast.SpreadElement) => boolean, beforeContext?: () => void): void;
+}