rooklang 0.3.2 → 0.3.4

package/dist/parser/simple-statements.js

@@ -1,15 +1,13 @@
 import { ParserBase } from "./base.js";
-import { isAssignmentOperator, describe, plural } from "./syntax.js";
+import { cannotWait, isAssignmentOperator, describe, plural } from "./syntax.js";
 // Simple statements, which `for` headers allow too: declarations of variables, assignments, `i++`
 // and calls.
 export class SimpleStatementParser extends ParserBase {
-    /** `await`, `<-ch` and `ch <- v` wait: only in async functions and at the top level. */
+    /** `await`, `<-ch` and `select` wait: only in async functions and at the top level. */
     requireAsync(what, start, end) {
         if (this.context.inAsync)
             return;
-        this.error(this.context.inDefer
-            ? `"${what}" is not allowed inside "defer": deferred code runs when the function ends`
-            : `"${what}" is allowed only in async functions and at the top level of a module; mark the function, e.g. "async func load() { ... }"`, start, end);
+        this.error(cannotWait(what, this.context.inDefer), start, end);
     }
     /** `x := 1` is a common habit from Go. */
     rejectColonEquals() {
@@ -49,12 +47,15 @@ export class SimpleStatementParser extends ParserBase {
             this.checkArity(targets.length, values, start);
             return { kind: 'AssignmentStatement', operator, targets, values, ...this.span(start) };
         }
-        // `ch <- value`: the value goes into the channel.
+        // `ch <- value`: the value goes into the channel. A send to a channel waits, and one to a
+        // topic does not, so whether it may be here is for the checker, which knows the type.
         if (this.check('<-')) {
-            const arrow = this.next();
-            this.requireAsync('<-', arrow.start, arrow.end);
+            const { start: from, end } = this.next();
             const value = this.parseExpression();
-            return { kind: 'SendStatement', channel: first, value, ...this.span(start) };
+            const cannotWait = this.context.inAsync
+                ? {}
+                : { cannotWait: { inDefer: this.context.inDefer, start: from, end } };
+            return { kind: 'SendStatement', channel: first, value, ...cannotWait, ...this.span(start) };
         }
         if (this.check('++') || this.check('--')) {
             const operator = this.next().kind === '++' ? '++' : '--';
@@ -90,6 +91,12 @@ export class SimpleStatementParser extends ParserBase {
         // `chunks, failed = chan(res.body)`: the channel of a stream and that of its error.
         if (values.length === 1 && value?.kind === 'StreamChanExpression')
             return;
+        // `user, err = decode<User>(body)`: the value and the error.
+        if (values.length === 1 && value?.kind === 'DecodeExpression')
+            return;
+        // `data, err = try JSON.parse(text)`: the value and the error, as from a call.
+        if (values.length === 1 && value?.kind === 'TryExpression')
+            return;
         this.error(`assignment mismatch: ${plural(targets, 'variable')} but ${plural(values.length, 'value')}`, start, this.span(start).end);
     }
     /** `delete scores[name]`: removes a field, so the target is one. */

package/dist/parser/statements.d.ts

@@ -30,8 +30,5 @@ export declare abstract class StatementParser extends SimpleStatementParser {
     protected parseBlock(): ast.BlockStatement;
     protected parseFunctionBody(async?: boolean): ast.BlockStatement;
     /** An if/for/switch header, where `{` starts the block rather than an object literal. */
-    protected parseHeaderExpression(): ast.Expression;
-    protected parseReturn(): ast.ReturnStatement;
-    /** `}` + newline + `else`: the newline ends the `if`, so explain the error instead of failing. */
     protected checkSameLine(keyword: 'else' | 'catch' | 'finally'): void;
 }

package/dist/parser/statements.js

@@ -1,6 +1,6 @@
 import { SimpleStatementParser } from "./simple-statements.js";
 import { FOREIGN_KEYWORDS, FUNCTION_BODY, describe } from "./syntax.js";
-// Statements: blocks, `return`, `mount()`, and which statement a token starts.
+// Statements: blocks, `mount()`, and which statement a token starts.
 export class StatementParser extends SimpleStatementParser {
     parseStatements(isEnd) {
         const body = [];
@@ -62,13 +62,20 @@ export class StatementParser extends SimpleStatementParser {
                 return this.parseBreakOrContinue();
             case 'throw':
                 return this.parseThrow();
+            // `try f()` without a block is an expression.
             case 'try':
-                return this.parseTry();
+                if (this.peek(1).kind === '{')
+                    return this.parseTry();
+                break;
             case 'defer':
                 return this.parseDefer();
             default:
                 break;
         }
+        // `outer: for`; `x := 1` is reported as Go's declaration.
+        if (token.kind === 'Identifier' && this.peek(1).kind === ':' && this.peek(2).kind !== '=') {
+            return this.parseLabeled();
+        }
         const hint = token.kind === 'Identifier' ? FOREIGN_KEYWORDS.get(token.text) : undefined;
         if (hint !== undefined && this.peek(1).kind === 'Identifier') {
             this.fail(`"${token.text}" is not a Rook keyword: ${hint}`);
@@ -106,7 +113,10 @@ export class StatementParser extends SimpleStatementParser {
             const call = expression.kind === 'CallExpression' ||
                 expression.kind === 'NewExpression' ||
                 expression.kind === 'GoExpression';
-            if (!call && !awaited) {
+            if (expression.kind === 'TryExpression') {
+                this.error('try gives the error, which is dropped here: keep it, e.g. "const err = try save()", or catch it with try { } catch e { }', expression.start, expression.end);
+            }
+            else if (!call && !awaited) {
                 this.error('this expression does nothing: only function calls can be used as statements', expression.start, expression.end);
             }
         }
@@ -151,10 +161,17 @@ export class StatementParser extends SimpleStatementParser {
                 this.endStatement();
                 return declaration;
             }
-            default:
+            default: {
                 if (this.isDecoratorDeclaration())
                     return this.parseDecoratorDeclaration(start, exported);
-                return undefined;
+                // `data` and `abstract` are keywords only before `class`: elsewhere they are names.
+                let words = this.checkWord('abstract') ? 1 : 0;
+                if (this.peek(words).text === 'data')
+                    words++;
+                return words > 0 && this.peek(words).kind === 'class'
+                    ? this.parseClass(start, exported)
+                    : undefined;
+            }
         }
     }
     /** A statement ends with a newline or `;`, or right before the `}` that closes its block. */
@@ -237,26 +254,6 @@ export class StatementParser extends SimpleStatementParser {
         return this.withContext({ ...FUNCTION_BODY, inAsync: async }, () => this.parseBlock());
     }
     /** An if/for/switch header, where `{` starts the block rather than an object literal. */
-    parseHeaderExpression() {
-        return this.withContext({ noObjectLiteral: true }, () => this.parseExpression());
-    }
-    parseReturn() {
-        const start = this.next().start;
-        if (this.context.inGoFor) {
-            this.error('"return" cannot leave "go for": its body runs in workers; skip an element with "continue"', start, this.span(start).end);
-        }
-        else if (!this.context.inFunction) {
-            this.error('"return" outside of a function', start, this.span(start).end);
-        }
-        else if (this.context.inDefer) {
-            this.error('"return" is not allowed inside "defer"', start, this.span(start).end);
-        }
-        const values = this.check(';') || this.check('}') || this.check('EOF') ? [] : this.parseExpressionList();
-        const statement = { kind: 'ReturnStatement', values, ...this.span(start) };
-        this.endStatement();
-        return statement;
-    }
-    /** `}` + newline + `else`: the newline ends the `if`, so explain the error instead of failing. */
     checkSameLine(keyword) {
         if (this.isImplicitSemicolon() && this.peek(1).kind === keyword) {
             const token = this.peek(1);

package/dist/parser/syntax.d.ts

@@ -7,7 +7,7 @@ export declare const ASSIGNMENT_OPERATORS: ReadonlySet<string>;
 export declare function isBinaryOperator(kind: TokenKind): kind is ast.BinaryOperator;
 export declare function isUnaryOperator(kind: TokenKind): kind is ast.UnaryOperator;
 export declare function isAssignmentOperator(kind: TokenKind): kind is ast.AssignmentOperator;
-export declare const RESERVED: ReadonlySet<string>;
+export declare const VISIBILITIES: ReadonlySet<string>;
 export declare const MODIFIERS: ReadonlySet<string>;
 /** Words from JS that Rook spells differently. */
 export declare const FOREIGN_KEYWORDS: ReadonlyMap<string, string>;
@@ -33,6 +33,14 @@ export interface Context {
     inComponent: boolean;
     /** In the blocks of `{if ...}` and `{for ...}` inside markup, where elements are statements. */
     inMarkup: boolean;
+    /** The labels of the enclosing statements, innermost last, which `break` and `continue` name. */
+    labels: readonly Label[];
+}
+/** `outer: for`: `loop` tells `continue outer` from a label of a switch or select. */
+export interface Label {
+    name: string;
+    loop: boolean;
+    used: boolean;
 }
 export declare const FUNCTION_BODY: Partial<Context>;
 /** Thrown to abandon the current statement after its syntax error has been reported. */
@@ -49,3 +57,5 @@ export declare function cleanJsxText(text: string): string;
 /** In `on*` attributes, these are the handler itself rather than code to run. */
 export declare function isHandlerReference(node: ast.Expression): boolean;
 export declare function templateElement(token: StringToken): ast.TemplateElement;
+/** Why `what`, which waits, is not allowed where it is: not in an async function or in `defer`. */
+export declare function cannotWait(what: string, inDefer: boolean): string;

package/dist/parser/syntax.js

@@ -60,8 +60,13 @@ export function isUnaryOperator(kind) {
 export function isAssignmentOperator(kind) {
     return ASSIGNMENT_OPERATORS.has(kind);
 }
-export const RESERVED = new Set(['map']);
-export const MODIFIERS = new Set(['public', 'protected', 'private', 'static']);
+export const VISIBILITIES = new Set(['public', 'protected', 'private']);
+export const MODIFIERS = new Set([
+    ...VISIBILITIES,
+    'static',
+    'readonly',
+    'abstract',
+]);
 /** Words from JS that Rook spells differently. */
 export const FOREIGN_KEYWORDS = new Map([
     ['function', 'declare functions with "func"'],
@@ -106,6 +111,7 @@ export const FUNCTION_BODY = {
     inAsync: false,
     noObjectLiteral: false,
     inMarkup: false,
+    labels: [],
 };
 /** Thrown to abandon the current statement after its syntax error has been reported. */
 export class ParseError extends Error {
@@ -118,6 +124,8 @@ export function describe(token) {
             return token.text === '' ? 'newline' : '";"';
         case 'String':
             return 'string';
+        case 'RegExp':
+            return 'regular expression';
         case 'Number':
             return `number ${token.text}`;
         case 'BigInt':
@@ -171,3 +179,9 @@ export function templateElement(token) {
         end: token.end,
     };
 }
+/** Why `what`, which waits, is not allowed where it is: not in an async function or in `defer`. */
+export function cannotWait(what, inDefer) {
+    return inDefer
+        ? `"${what}" is not allowed inside "defer": deferred code runs when the function ends`
+        : `"${what}" is allowed only in async functions and at the top level of a module; mark the function, e.g. "async func load() { ... }"`;
+}

package/dist/parser/types.js

@@ -1,6 +1,6 @@
 import { ClassParser } from "./classes.js";
 import { describe } from "./syntax.js";
-// Types: `?T`, `[]T`, `queue T`, unions, literal types, function, component and object types, type arguments.
+// Types: `?T`, `[]T`, `queue T`, `topic T`, unions, literal types, function, component and object types, type arguments.
 /** `iterator: true` for the parameters of an iterator: one, named `yield`. */
 function iterator(names) {
     return names.length === 1 && names[0] === 'yield' ? { iterator: true } : {};
@@ -106,14 +106,19 @@ export class TypeParser extends ClassParser {
                 const members = this.parseTypeMembers();
                 return { kind: 'ObjectType', members, ...this.span(start) };
             }
-            // `queue number`: `queue` is a type of its own only before the type of its values, so that it
-            // stays a name elsewhere.
+            // `queue number` and `topic number`: `queue` and `topic` are types of their own only before
+            // the type of their values, so that they stay names elsewhere.
             default: {
                 if (this.checkWord('queue') && this.canStartType(1)) {
                     this.next();
                     const element = this.parsePrimaryType();
                     return { kind: 'QueueType', element, ...this.span(start) };
                 }
+                if (this.checkWord('topic') && this.canStartType(1)) {
+                    this.next();
+                    const element = this.parsePrimaryType();
+                    return { kind: 'TopicType', element, ...this.span(start) };
+                }
                 const name = this.parseIdentifier('type');
                 const typeArgs = this.parseTypeArgs();
                 return { kind: 'TypeReference', name, typeArgs, ...this.span(start) };

package/dist/project-modules.d.ts

@@ -0,0 +1,12 @@
+import type { Completion } from './checker/checker.ts';
+/** What a name is used as, and so where it is offered: decorators have a namespace of their own. */
+export type ExportSpace = 'value' | 'type' | 'tag' | 'decorator';
+export interface ExportedName {
+    name: string;
+    kind: Completion['kind'];
+    spaces: ExportSpace[];
+    /** The absolute path of the module. */
+    path: string;
+}
+/** The names exported by the other `.rk` modules of the package of `filename`. */
+export declare function projectExports(filename: string): ExportedName[];

package/dist/project-modules.js

@@ -0,0 +1,106 @@
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { markupFor } from "./config.js";
+import { parse } from "./parser/parser.js";
+/** Directories that hold no sources of the package. */
+const SKIPPED = new Set(['node_modules', 'dist', 'build', 'out', 'coverage']);
+/** A bound on the files read, for a file opened in a directory as big as the home directory. */
+const MAX_FILES = 5000;
+const parsed = new Map();
+/** The names exported by the other `.rk` modules of the package of `filename`. */
+export function projectExports(filename) {
+    const self = resolve(filename);
+    return rookFiles(packageRoot(self))
+        .filter((path) => path !== self)
+        .flatMap(exportsOf);
+}
+/** The directory of the nearest package.json above the file, or that of the file without one. */
+function packageRoot(filename) {
+    for (let dir = dirname(filename);; dir = dirname(dir)) {
+        if (exists(join(dir, 'package.json')))
+            return dir;
+        if (dirname(dir) === dir)
+            return dirname(filename);
+    }
+}
+function exists(path) {
+    try {
+        statSync(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function rookFiles(root) {
+    const files = [];
+    const visit = (dir) => {
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (files.length >= MAX_FILES)
+                return;
+            if (entry.name.startsWith('.'))
+                continue;
+            const path = join(dir, entry.name);
+            if (entry.isDirectory() && !SKIPPED.has(entry.name))
+                visit(path);
+            else if (entry.isFile() && entry.name.endsWith('.rk'))
+                files.push(path);
+        }
+    };
+    visit(root);
+    return files;
+}
+function exportsOf(path) {
+    let version;
+    try {
+        const stats = statSync(path);
+        version = `${stats.mtimeMs}:${stats.size}`;
+    }
+    catch {
+        return [];
+    }
+    const cached = parsed.get(path);
+    if (cached?.version === version)
+        return cached.names;
+    let names;
+    try {
+        const { program } = parse(readFileSync(path, 'utf8'), { markup: markupFor(path) });
+        names = program.body.flatMap((statement) => exported(statement, path));
+    }
+    catch {
+        names = [];
+    }
+    parsed.set(path, { version, names });
+    return names;
+}
+function exported(statement, path) {
+    const name = (node, kind, spaces) => ({ name: node.name, kind, spaces, path });
+    if (!('exported' in statement) || !statement.exported)
+        return [];
+    switch (statement.kind) {
+        case 'FuncDeclaration':
+            return [name(statement.name, 'function', ['value'])];
+        case 'ClassDeclaration':
+            return [name(statement.name, 'class', ['value', 'type'])];
+        case 'ComponentDeclaration':
+            return [name(statement.name, 'component', ['value', 'tag'])];
+        case 'DecoratorDeclaration':
+            return [name(statement.name, 'function', ['decorator'])];
+        case 'InterfaceDeclaration':
+        case 'TypeAliasDeclaration':
+            return [name(statement.name, 'type', ['type'])];
+        case 'VariableDeclaration': {
+            const kind = statement.keyword === 'const' ? 'constant' : 'variable';
+            return statement.names.map((each) => name(each, kind, ['value']));
+        }
+        default:
+            return [];
+    }
+}

package/dist/run-file.d.ts

@@ -0,0 +1,6 @@
+export interface RunOptions {
+    typeCheck: boolean;
+    markup: boolean | undefined;
+    watch: boolean;
+}
+export declare function runFile(file: string, options: RunOptions): void;

package/dist/run-file.js

@@ -0,0 +1,111 @@
+import { spawn } from 'node:child_process';
+import { existsSync, mkdtempSync, readFileSync, rmSync, statSync, unwatchFile, watchFile, } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { displayPath } from "./build.js";
+/** The signals that `rook run` gives to the program, or leaves to it, rather than ending at them. */
+const SIGNALS = ['SIGINT', 'SIGTERM', 'SIGHUP'];
+/** How often the files are looked at, and how long a program has to stop before it is killed. */
+const POLL_MS = 200;
+const KILL_MS = 2000;
+export function runFile(file, options) {
+    // The build rewrites the extensions of imports, not of these URLs: in the package they are .js.
+    const extension = import.meta.url.endsWith('.ts') ? '.ts' : '.js';
+    const loader = new URL(`./loader${extension}`, import.meta.url).href;
+    const run = fileURLToPath(new URL(`./run${extension}`, import.meta.url));
+    const watched = new Set();
+    let child = null;
+    let cache = '';
+    let restart = null;
+    let stopping = false;
+    let killer;
+    // The files of the run and the time each was changed when it was compiled.
+    const files = () => existsSync(join(cache, 'files'))
+        ? readFileSync(join(cache, 'files'), 'utf8')
+            .split('\n')
+            .filter(Boolean)
+            .map((line) => line.split('\t'))
+            .map(([path, time]) => [path, Number(time)])
+        : [];
+    // A file is compared with what was compiled, as it may change before it is watched.
+    const watch = ([path, compiled]) => {
+        if (!watched.has(path)) {
+            watched.add(path);
+            watchFile(path, { interval: POLL_MS }, (now, before) => {
+                if (now.mtimeMs !== before.mtimeMs)
+                    changed(path);
+            });
+        }
+        if (existsSync(path) && statSync(path).mtimeMs !== compiled)
+            changed(path);
+    };
+    const changed = (path) => {
+        if (stopping || restart !== null)
+            return;
+        restart = path;
+        if (child === null) {
+            start();
+            return;
+        }
+        child.kill('SIGTERM');
+        killer = setTimeout(() => child?.kill('SIGKILL'), KILL_MS);
+    };
+    const stop = () => {
+        stopping = true;
+        for (const path of watched)
+            unwatchFile(path);
+        unwatchFile(join(cache, 'files'));
+    };
+    const forward = (name) => {
+        // Without --watch Ctrl+C is the program's; with it, it ends the watching too.
+        if (name !== 'SIGINT')
+            child?.kill(name);
+        if (options.watch)
+            stop();
+        if (options.watch && child === null)
+            process.exitCode = 0;
+    };
+    const start = () => {
+        if (restart !== null)
+            console.error(`rook: ${displayPath(restart)} changed, running again`);
+        restart = null;
+        cache = mkdtempSync(join(tmpdir(), 'rook-run-'));
+        const args = ['--enable-source-maps', '--import', loader, run, file];
+        child = spawn(process.execPath, args, {
+            stdio: 'inherit',
+            env: {
+                ...process.env,
+                ROOK_RUN_CACHE: cache,
+                ...(options.typeCheck ? {} : { ROOK_NO_CHECK: '1' }),
+                ...(options.markup === undefined ? {} : { ROOK_MARKUP: options.markup ? '1' : '0' }),
+            },
+        });
+        // The files of the program are watched as it loads them.
+        if (options.watch) {
+            watchFile(join(cache, 'files'), { interval: POLL_MS }, () => files().forEach(watch));
+        }
+        child.on('close', (status, signal) => {
+            clearTimeout(killer);
+            if (options.watch)
+                files().forEach(watch);
+            unwatchFile(join(cache, 'files'));
+            rmSync(cache, { recursive: true, force: true });
+            child = null;
+            if (!options.watch || stopping) {
+                for (const name of SIGNALS)
+                    process.off(name, forward);
+                process.exitCode = status ?? (signal ? 1 : 0);
+            }
+            else if (restart !== null) {
+                start();
+            }
+            else {
+                console.error('rook: waiting for a change to run again');
+            }
+        });
+    };
+    for (const name of SIGNALS)
+        process.on(name, forward);
+    start();
+}