rooklang 0.0.0-stage → 0.3.0

package/dist/typescript/library.d.ts

@@ -0,0 +1,23 @@
+import type * as TS from 'typescript';
+import type { Library } from '../checker/checker.ts';
+import { type Type } from '../checker/types.ts';
+import type { TypeConverter } from './convert.ts';
+export declare class LibraryTypes implements Library {
+    private readonly checker;
+    private readonly converter;
+    private readonly values;
+    private readonly types;
+    private readonly converted;
+    constructor(ts: typeof TS, program: TS.Program, converter: TypeConverter);
+    value(name: string): Type | undefined;
+    type(name: string): Type | undefined;
+    primitive(kind: 'string' | 'number' | 'bigint' | 'bool'): Type | undefined;
+    array(element: Type): Type | undefined;
+    /** The element of a tag; custom elements like `<app-card>` are HTMLElement. */
+    element(tag: string, svg?: boolean): Type | undefined;
+    event(name: string): Type | undefined;
+    names(of: 'value' | 'type' | 'tag'): Iterable<string>;
+    /** `Map[key]` of an interface that maps names to types. */
+    private entry;
+    private cached;
+}

package/dist/typescript/library.js

@@ -0,0 +1,81 @@
+import { instantiate } from "../checker/types.js";
+/** The interfaces of the lib files with the members of the primitive types. */
+const PRIMITIVE_TYPES = { string: 'String', number: 'Number', bigint: 'BigInt', bool: 'Boolean' };
+// Globals of TypeScript's lib files (the standard library and the DOM) and of the `@types`
+// packages, such as `process` from @types/node. Each name is converted when it is first used.
+export class LibraryTypes {
+    checker;
+    converter;
+    values = new Map();
+    types = new Map();
+    converted = new Map();
+    constructor(ts, program, converter) {
+        this.checker = program.getTypeChecker();
+        this.converter = converter;
+        // The scope of a script file is the global scope.
+        const lib = program.getSourceFile(ts.getDefaultLibFilePath(program.getCompilerOptions()));
+        if (!lib)
+            return;
+        for (const symbol of this.checker.getSymbolsInScope(lib, ts.SymbolFlags.Value)) {
+            this.values.set(symbol.name, symbol);
+        }
+        for (const symbol of this.checker.getSymbolsInScope(lib, ts.SymbolFlags.Type)) {
+            this.types.set(symbol.name, symbol);
+        }
+    }
+    value(name) {
+        return this.cached(`value ${name}`, () => {
+            const symbol = this.values.get(name);
+            return symbol && this.converter.valueType(symbol);
+        });
+    }
+    type(name) {
+        return this.cached(`type ${name}`, () => {
+            const symbol = this.types.get(name);
+            return symbol && this.converter.typeOf(symbol);
+        });
+    }
+    primitive(kind) {
+        return this.type(PRIMITIVE_TYPES[kind]);
+    }
+    array(element) {
+        const symbol = this.types.get('Array');
+        return symbol && instantiate(this.converter.arrayTemplate(symbol), [element]);
+    }
+    /** The element of a tag; custom elements like `<app-card>` are HTMLElement. */
+    element(tag, svg = false) {
+        if (svg) {
+            return this.cached(`svg ${tag}`, () => this.entry('SVGElementTagNameMap', tag) ?? this.type('SVGElement'));
+        }
+        return this.cached(`element ${tag}`, () => this.entry('HTMLElementTagNameMap', tag) ??
+            (tag.includes('-') ? this.type('HTMLElement') : undefined));
+    }
+    event(name) {
+        return this.cached(`event ${name}`, () => this.entry('HTMLElementEventMap', name));
+    }
+    names(of) {
+        if (of === 'value')
+            return this.values.keys();
+        if (of === 'type')
+            return this.types.keys();
+        const symbol = this.types.get('HTMLElementTagNameMap');
+        return symbol
+            ? this.checker
+                .getPropertiesOfType(this.checker.getDeclaredTypeOfSymbol(symbol))
+                .map((property) => property.name)
+            : [];
+    }
+    /** `Map[key]` of an interface that maps names to types. */
+    entry(map, key) {
+        const symbol = this.types.get(map);
+        if (!symbol)
+            return undefined;
+        const property = this.checker.getPropertyOfType(this.checker.getDeclaredTypeOfSymbol(symbol), key);
+        return property && this.converter.convert(this.checker.getTypeOfSymbol(property));
+    }
+    cached(key, compute) {
+        if (!this.converted.has(key))
+            this.converted.set(key, compute());
+        return this.converted.get(key);
+    }
+}

package/dist/vite.d.ts

@@ -0,0 +1,11 @@
+import type { Plugin } from 'vite';
+export interface RookPluginOptions {
+    /** Check types before generating code. Defaults to `true`. */
+    typeCheck?: boolean;
+    /**
+     * Markup and components, for every `.rk` file; by default as the package.json of the file
+     * says, `"rook": { "markup": true }`.
+     */
+    markup?: boolean;
+}
+export declare function rook(options?: RookPluginOptions): Plugin;

package/dist/vite.js

@@ -0,0 +1,86 @@
+import { readFileSync } from 'node:fs';
+import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import { formatDiagnostic } from "./diagnostics.js";
+import { compile } from "./index.js";
+import { SourceFile } from "./source.js";
+// A Vite plugin for Rook: `.rk` modules are compiled when Vite loads them, with type
+// checking, so `import { App } from "./app.rk"` works in a Vite project. Type errors stop the
+// build and show up in the browser overlay of the dev server. `app.rk.goroutines.js` is the
+// worker module of `go` in app.rk, which Vite bundles as a worker: it is not a file, and its
+// path has no query, since Vite drops the query of a worker's URL.
+const GOROUTINES = '.goroutines.js';
+export function rook(options = {}) {
+    const typeCheck = options.typeCheck ?? true;
+    let root = process.cwd();
+    return {
+        name: 'rooklang',
+        // Vite bundles workers with plugins of their own: the worker modules of `go` need this one too,
+        // and they are ES modules.
+        config(config) {
+            const plugins = config.worker?.plugins;
+            return {
+                worker: { format: 'es', plugins: () => [...(plugins?.() ?? []), rook(options)] },
+            };
+        },
+        configResolved(config) {
+            root = config.root;
+        },
+        resolveId(source, importer) {
+            const [path = source] = source.split('?');
+            if (!path.endsWith(`.rk${GOROUTINES}`))
+                return null;
+            if (!isAbsolute(path))
+                return resolve(dirname(importer ?? join(root, 'index.html')), path);
+            // `/app.rk.goroutines.js` from the dev server is a path in the root.
+            return path.startsWith(root) ? path : join(root, path);
+        },
+        load(id) {
+            const [path = id] = id.split('?');
+            if (!path.endsWith(`.rk${GOROUTINES}`))
+                return null;
+            return readFileSync(path.slice(0, -GOROUTINES.length), 'utf8');
+        },
+        transform(source, id) {
+            const [name = id, query] = id.split('?');
+            const worker = name.endsWith(`.rk${GOROUTINES}`);
+            const path = worker ? name.slice(0, -GOROUTINES.length) : name;
+            // `app.rk?raw` and the like are left to Vite; it adds queries of its own to workers.
+            if (!path.endsWith('.rk') || (query !== undefined && !worker))
+                return null;
+            // Imports keep `.rk`: Vite resolves them and gives them to this plugin again.
+            const result = compile(source, {
+                filename: path,
+                rewriteImports: false,
+                typeCheck,
+                markup: options.markup,
+                workerUrl: `./${basename(path)}${GOROUTINES}`,
+            });
+            const file = new SourceFile(relative(root, path), source);
+            // Vite counts columns from 0.
+            const loc = (start) => {
+                const { line, column } = file.position(start);
+                return { line, column: column - 1 };
+            };
+            for (const warning of result.warnings) {
+                this.warn({
+                    message: formatDiagnostic(file, warning, 'warning'),
+                    id,
+                    loc: loc(warning.start),
+                });
+            }
+            if (result.diagnostics.length > 0) {
+                this.error({
+                    message: result.diagnostics.map((d) => formatDiagnostic(file, d)).join('\n\n'),
+                    id,
+                    loc: loc(result.diagnostics[0].start),
+                });
+            }
+            // The code of imported decorators is inlined here, and their types are used: when an
+            // imported module changes, this one is compiled again.
+            for (const dependency of result.dependencies) {
+                this.addWatchFile(resolve(dirname(path), dependency));
+            }
+            return { code: worker ? (result.worker ?? '') : result.code, map: null };
+        },
+    };
+}

package/dist/walk-types.d.ts

@@ -0,0 +1,4 @@
+import type * as ast from './ast.ts';
+type TypeChildNode = ast.TypeNode | ast.TypeMember | ast.TypeParameter;
+export declare function forEachTypeChild(node: TypeChildNode, visit: (child: ast.Node) => void): void;
+export {};

package/dist/walk-types.js

@@ -0,0 +1,56 @@
+export function forEachTypeChild(node, visit) {
+    const each = (nodes) => {
+        for (const child of nodes)
+            visit(child);
+    };
+    const optional = (child) => {
+        if (child)
+            visit(child);
+    };
+    switch (node.kind) {
+        case 'TypeReference':
+            visit(node.name);
+            each(node.typeArgs);
+            break;
+        case 'TypeParameter':
+            visit(node.name);
+            optional(node.constraint);
+            break;
+        case 'ArrayType':
+        case 'ChanType':
+            visit(node.element);
+            break;
+        case 'NullableType':
+            visit(node.type);
+            break;
+        case 'FuncType':
+            each(node.params);
+            each(node.results);
+            break;
+        case 'ComponentType':
+            each(node.params);
+            break;
+        case 'ObjectType':
+            each(node.members);
+            break;
+        case 'UnionType':
+            each(node.types);
+            break;
+        case 'LiteralType':
+            visit(node.value);
+            break;
+        case 'PropertySignature':
+            visit(node.name);
+            visit(node.type);
+            break;
+        case 'IndexSignature':
+            visit(node.key);
+            visit(node.type);
+            break;
+        case 'MethodSignature':
+            visit(node.name);
+            each(node.params);
+            each(node.results);
+            break;
+    }
+}

package/dist/walk.d.ts

@@ -0,0 +1,5 @@
+import type * as ast from './ast.ts';
+/** Calls `visit` for each direct child of `node`, in source order. */
+export declare function forEachChild(node: ast.Node, visit: (child: ast.Node) => void): void;
+/** Whether a `break` in these statements leaves the enclosing loop or switch. */
+export declare function containsBreak(statements: readonly ast.Statement[]): boolean;

package/dist/walk.js

@@ -0,0 +1,315 @@
+import { forEachTypeChild } from "./walk-types.js";
+/** Calls `visit` for each direct child of `node`, in source order. */
+export function forEachChild(node, visit) {
+    const each = (nodes) => {
+        for (const child of nodes)
+            visit(child);
+    };
+    const optional = (child) => {
+        if (child)
+            visit(child);
+    };
+    switch (node.kind) {
+        case 'Program':
+        case 'BlockStatement':
+            each(node.body);
+            break;
+        case 'ImportDeclaration':
+            optional(node.defaultImport);
+            optional(node.namespaceImport);
+            each(node.namedImports);
+            visit(node.source);
+            break;
+        case 'ImportSpecifier':
+            visit(node.imported);
+            if (node.local !== node.imported)
+                visit(node.local);
+            break;
+        case 'FuncDeclaration':
+        case 'MethodDeclaration':
+            visit(node.name);
+            each(node.params);
+            each(node.results);
+            visit(node.body);
+            break;
+        case 'Parameter':
+            visit(node.name);
+            optional(node.type);
+            optional(node.defaultValue);
+            break;
+        case 'ComponentDeclaration':
+            visit(node.name);
+            each(node.decorators);
+            each(node.params);
+            visit(node.body);
+            break;
+        case 'DecoratorDeclaration':
+            // The names after `needs` are other decorators', not values in scope.
+            visit(node.name);
+            each(node.params);
+            visit(node.body);
+            break;
+        case 'DecoratorUse':
+            // The name is the decorator's, not a value in scope.
+            each(node.arguments);
+            break;
+        case 'DecoratorGet':
+            visit(node.target);
+            break;
+        case 'VariableDeclaration':
+            each(node.names);
+            optional(node.type);
+            each(node.values);
+            break;
+        case 'ClassDeclaration':
+            visit(node.name);
+            optional(node.superClass);
+            each(node.implements);
+            each(node.members);
+            break;
+        case 'FieldDeclaration':
+            visit(node.name);
+            optional(node.type);
+            optional(node.value);
+            break;
+        case 'ConstructorDeclaration':
+            each(node.params);
+            visit(node.body);
+            break;
+        case 'InterfaceDeclaration':
+            visit(node.name);
+            each(node.members);
+            break;
+        case 'TypeAliasDeclaration':
+            visit(node.name);
+            visit(node.type);
+            break;
+        case 'ExpressionStatement':
+            visit(node.expression);
+            break;
+        case 'AssignmentStatement':
+            each(node.targets);
+            each(node.values);
+            break;
+        case 'IncDecStatement':
+        case 'DeleteStatement':
+            visit(node.target);
+            break;
+        case 'SendStatement':
+            visit(node.channel);
+            visit(node.value);
+            break;
+        case 'ChanExpression':
+            visit(node.element);
+            optional(node.size);
+            break;
+        case 'MakeExpression':
+            visit(node.type);
+            visit(node.length);
+            break;
+        case 'ConversionExpression':
+            visit(node.type);
+            visit(node.argument);
+            break;
+        case 'ReturnStatement':
+            each(node.values);
+            break;
+        case 'IfStatement':
+            visit(node.condition);
+            visit(node.consequent);
+            optional(node.alternate);
+            break;
+        case 'ForStatement':
+            optional(node.init);
+            optional(node.condition);
+            optional(node.update);
+            visit(node.body);
+            break;
+        case 'ForInStatement':
+            optional(node.key);
+            visit(node.value);
+            visit(node.iterable);
+            visit(node.body);
+            break;
+        case 'SwitchStatement':
+            optional(node.discriminant);
+            each(node.cases);
+            break;
+        case 'SwitchCase':
+            each(node.tests);
+            each(node.body);
+            break;
+        case 'SelectStatement':
+            each(node.cases);
+            break;
+        case 'SelectCase':
+            each(node.names);
+            optional(node.operation);
+            each(node.body);
+            break;
+        case 'ThrowStatement':
+            visit(node.argument);
+            break;
+        case 'TryStatement':
+            visit(node.block);
+            optional(node.handler);
+            optional(node.finalizer);
+            break;
+        case 'CatchClause':
+            optional(node.param);
+            visit(node.body);
+            break;
+        case 'DeferStatement':
+        case 'MountStatement':
+        case 'EffectStatement':
+            visit(node.body);
+            break;
+        case 'StyleStatement':
+            each(node.parts);
+            break;
+        case 'TemplateLiteral':
+            node.quasis.forEach((quasi, i) => {
+                visit(quasi);
+                optional(node.expressions[i] ?? null);
+            });
+            break;
+        case 'ArrayLiteral':
+            each(node.elements);
+            break;
+        case 'ObjectLiteral':
+            each(node.properties);
+            break;
+        case 'Property':
+            visit(node.key);
+            visit(node.value);
+            break;
+        case 'SpreadElement':
+            visit(node.argument);
+            break;
+        case 'FuncExpression':
+            each(node.params);
+            each(node.results);
+            visit(node.body);
+            break;
+        case 'ArrowFunction':
+            each(node.params);
+            visit(node.body);
+            break;
+        case 'UnaryExpression':
+            visit(node.argument);
+            break;
+        case 'GoExpression':
+            visit(node.call);
+            break;
+        case 'BinaryExpression':
+            visit(node.left);
+            visit(node.right);
+            break;
+        case 'AsExpression':
+            visit(node.expression);
+            visit(node.type);
+            break;
+        case 'ConditionalExpression':
+            visit(node.test);
+            visit(node.consequent);
+            visit(node.alternate);
+            break;
+        case 'CallExpression':
+        case 'NewExpression':
+            visit(node.callee);
+            each(node.arguments);
+            break;
+        case 'MemberExpression':
+            visit(node.object);
+            visit(node.property);
+            break;
+        case 'IndexExpression':
+            visit(node.object);
+            visit(node.index);
+            break;
+        case 'ElementExpression':
+            optional(node.tag);
+            optional(node.value);
+            each(node.attributes);
+            each(node.children);
+            break;
+        case 'JsxExpressionContainer':
+            visit(node.expression);
+            break;
+        case 'JsxStatementContainer':
+            visit(node.statement);
+            break;
+        case 'JsxElementStatement':
+            visit(node.element);
+            break;
+        case 'JsxAttribute':
+            visit(node.name);
+            optional(node.value);
+            break;
+        case 'JsxSpreadAttribute':
+            visit(node.argument);
+            break;
+        case 'EventHandler':
+            each(node.body);
+            break;
+        case 'TypeReference':
+        case 'TypeParameter':
+        case 'ArrayType':
+        case 'ChanType':
+        case 'NullableType':
+        case 'FuncType':
+        case 'ComponentType':
+        case 'ObjectType':
+        case 'UnionType':
+        case 'LiteralType':
+        case 'PropertySignature':
+        case 'IndexSignature':
+        case 'MethodSignature':
+            forEachTypeChild(node, visit);
+            break;
+        // Its names belong to the decorator, not to any scope.
+        case 'DecoratorMember':
+            break;
+        case 'BreakStatement':
+        case 'ContinueStatement':
+        case 'JsxText':
+        case 'CssText':
+        case 'Identifier':
+        case 'NumberLiteral':
+        case 'BigIntLiteral':
+        case 'StringLiteral':
+        case 'TemplateElement':
+        case 'BooleanLiteral':
+        case 'NullLiteral':
+        case 'ThisExpression':
+        case 'SuperExpression':
+            break;
+    }
+}
+/** Whether a `break` in these statements leaves the enclosing loop or switch. */
+export function containsBreak(statements) {
+    let found = false;
+    const visit = (node) => {
+        switch (node.kind) {
+            case 'BreakStatement':
+                found = true;
+                return;
+            // A `break` inside these belongs to them.
+            case 'ForStatement':
+            case 'ForInStatement':
+            case 'SwitchStatement':
+            case 'SelectStatement':
+            case 'FuncDeclaration':
+            case 'FuncExpression':
+            case 'ArrowFunction':
+            case 'ClassDeclaration':
+            case 'MountStatement':
+            case 'EffectStatement':
+                return;
+            default:
+                forEachChild(node, visit);
+        }
+    };
+    statements.forEach(visit);
+    return found;
+}