rooklang 0.4.1 → 0.5.0

package/dist/parser/simple-statements.js

@@ -96,6 +96,10 @@ export class SimpleStatementParser extends ParserBase {
         // `data, err = try JSON.parse(text)`: the value and the error, as from a call.
         if (values.length === 1 && value?.kind === 'TryExpression')
             return;
+        if (values.length === 1 && value?.kind === 'ConditionalExpression') {
+            this.error('a conditional expression gives one value, not the results of a call: unpack them in the branches of if/else, e.g. if ok { a, err = two() } else { a, err = other() }', start, this.span(start).end);
+            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. */
@@ -135,6 +139,49 @@ export class SimpleStatementParser extends ParserBase {
             end: body.end,
         };
     }
+    /** `const { name, size: bytes, ...rest } = file`: fields of an object, one level deep. */
+    parseDestructuring(start, exported, keyword) {
+        const names = [];
+        const keys = [];
+        let rest = false;
+        this.expect('{');
+        this.parseList('}', () => {
+            if (rest)
+                this.fail('...rest is the last name: it gets the other fields');
+            if (this.accept('...')) {
+                rest = true;
+                names.push(this.parseIdentifier('variable name'));
+                return;
+            }
+            const token = this.peek();
+            const key = this.check('String') ? this.parseStringLiteral() : this.parsePropertyName();
+            if (this.accept(':')) {
+                names.push(this.parseIdentifier('variable name'));
+            }
+            else if (key.kind === 'Identifier' && token.kind === 'Identifier') {
+                names.push({ ...key });
+            }
+            else {
+                const shown = token.kind === 'String' ? token.text : `"${token.text}"`;
+                this.fail(`${shown} needs a name to take its value, e.g. { ${token.text}: name }`);
+            }
+            keys.push(key);
+        });
+        this.expect('=', '"=" and the object: a pattern takes its fields from a value');
+        const value = this.parseExpression();
+        return {
+            kind: 'VariableDeclaration',
+            exported,
+            keyword,
+            isPublic: false,
+            names,
+            type: null,
+            values: [value],
+            body: null,
+            pattern: { keys, rest },
+            ...this.span(start),
+        };
+    }
     parseVariableDeclaration(start, exported) {
         const token = this.next();
         const keyword = token.kind === 'const'
@@ -142,6 +189,9 @@ export class SimpleStatementParser extends ParserBase {
             : token.text === 'state' || token.text === 'derived' || token.text === 'ref'
                 ? token.text
                 : 'let';
+        if (this.check('{') && (keyword === 'const' || keyword === 'let')) {
+            return this.parseDestructuring(start, exported, keyword);
+        }
         const names = [this.parseIdentifier('variable name')];
         while (this.accept(','))
             names.push(this.parseIdentifier('variable name'));

package/dist/parser/statements.js

@@ -158,14 +158,15 @@ export class StatementParser extends SimpleStatementParser {
                 return this.parseDecorated(start, exported);
             case 'interface':
                 return this.parseInterface(start, exported);
-            case 'type': {
-                const declaration = this.parseTypeAlias(start, exported);
-                this.endStatement();
-                return declaration;
-            }
             default: {
                 if (this.isDecoratorDeclaration())
                     return this.parseDecoratorDeclaration(start, exported);
+                // `type` is a keyword only before the name of a type: `const type = blob.type` is a name.
+                if (this.checkWord('type') && this.peek(1).kind === 'Identifier') {
+                    const declaration = this.parseTypeAlias(start, exported);
+                    this.endStatement();
+                    return declaration;
+                }
                 // `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')
@@ -178,8 +179,9 @@ export class StatementParser extends SimpleStatementParser {
     }
     /** A statement ends with a newline or `;`, or right before the `}` that closes its block. */
     endStatement() {
-        if (this.accept(';') || this.check('}') || this.check('EOF'))
+        if (this.accept(';') || this.check('}') || this.check('EOF') || this.afterTypeArguments()) {
             return;
+        }
         const token = this.peek();
         if (token.kind === '++' || token.kind === '--') {
             this.fail(`"${token.kind}" is a statement and cannot be used inside an expression`);

package/dist/parser/syntax.js

@@ -83,7 +83,6 @@ export const STATEMENT_KEYWORDS = new Set([
     'const',
     'class',
     'interface',
-    'type',
     'return',
     'if',
     'for',

package/dist/parser/types.d.ts

@@ -13,10 +13,6 @@ export declare abstract class TypeParser extends ClassParser {
      * names, which only document them.
      */
     protected parseParenthesizedType(): ast.TypeNode;
-    /** The type of a parameter of a function type, after its name if it has one, kept in `names`. */
-    private parseParamType;
-    /** `paths []string` in `(paths []string) => Shape`: a name before the type of a parameter. */
-    private startsNamedParam;
     /** `{ name string; x, y number; area() number }`, separated by newlines, `;` or `,`. */
     protected parseTypeMembers(): ast.TypeMember[];
     protected parseTypeMember(): ast.TypeMember[];

package/dist/parser/types.js

@@ -78,9 +78,17 @@ export class TypeParser extends ClassParser {
                 this.next();
                 this.expect('(');
                 const names = [];
-                const params = this.parseList(')', () => this.parseParamType(names));
+                const params = this.groupParams(this.parseList(')', () => this.parseParamType(names)), names);
+                const rest = this.restOf(params, names);
                 const results = this.parseResults();
-                return { kind: 'FuncType', params, results, ...iterator(names), ...this.span(start) };
+                return {
+                    kind: 'FuncType',
+                    params,
+                    ...(rest ? { rest } : {}),
+                    results,
+                    ...iterator(names),
+                    ...this.span(start),
+                };
             }
             // `chan T`, `chan<- T` that only sends, `<-chan T` that only receives.
             case 'chan': {
@@ -133,7 +141,7 @@ export class TypeParser extends ClassParser {
     parseParenthesizedType() {
         const start = this.next().start;
         const names = [];
-        const params = this.parseList(')', () => this.parseParamType(names));
+        const params = this.groupParams(this.parseList(')', () => this.parseParamType(names)), names);
         if (this.accept('=>')) {
             const result = this.parseType();
             const voids = result.kind === 'TypeReference' && result.name.name === 'void';
@@ -156,39 +164,16 @@ export class TypeParser extends ClassParser {
             end: start,
         });
     }
-    /** The type of a parameter of a function type, after its name if it has one, kept in `names`. */
-    parseParamType(names) {
-        names.push(this.check('Identifier') && this.startsNamedParam() ? this.next().text : '');
-        return this.parseType();
-    }
-    /** `paths []string` in `(paths []string) => Shape`: a name before the type of a parameter. */
-    startsNamedParam() {
-        const next = this.peek(1);
-        switch (next.kind) {
-            case 'Identifier':
-            case '?':
-            case '{':
-            case '(':
-            case 'func':
-            case 'chan':
-            case '<-':
-            case 'String':
-            case 'Number':
-                return true;
-            // `x []number` is named.
-            case '[':
-                return this.peek(2).kind === ']';
-            default:
-                return false;
-        }
-    }
     /** `{ name string; x, y number; area() number }`, separated by newlines, `;` or `,`. */
     parseTypeMembers() {
         this.expect('{');
         const members = [];
         this.parseSeparated(() => this.check('}'), () => {
             members.push(...this.parseTypeMember());
-            if (!this.accept(',') && !this.accept(';') && !this.check('}')) {
+            if (!this.accept(',') &&
+                !this.accept(';') &&
+                !this.check('}') &&
+                !this.afterTypeArguments()) {
                 this.fail(`expected newline, ";" or "}" after member, found ${describe(this.peek())}`);
             }
         });
@@ -210,8 +195,8 @@ export class TypeParser extends ClassParser {
         }
         const name = this.parsePropertyName('member name');
         if (this.check('(')) {
-            const params = this.parseParams(false);
-            const results = this.parseResults();
+            const params = this.parseParams(false, { rest: 'typed' });
+            const results = this.parseResults(true);
             return [{ kind: 'MethodSignature', name, params, results, ...this.span(start) }];
         }
         // `x, y number` declares several properties of the same type.

package/dist/project-modules.js

@@ -7,6 +7,8 @@ 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 modules being read, for `export ... from` that go round in a cycle. */
+const reading = new Set();
 /** The names exported by the other `.rk` modules of the package of `filename`. */
 export function projectExports(filename) {
     const self = resolve(filename);
@@ -69,7 +71,10 @@ function exportsOf(path) {
     const cached = parsed.get(path);
     if (cached?.version === version)
         return cached.names;
+    if (reading.has(path))
+        return [];
     let names;
+    reading.add(path);
     try {
         const { program } = parse(readFileSync(path, 'utf8'), { markup: markupFor(path) });
         names = program.body.flatMap((statement) => exported(statement, path));
@@ -77,11 +82,16 @@ function exportsOf(path) {
     catch {
         names = [];
     }
+    finally {
+        reading.delete(path);
+    }
     parsed.set(path, { version, names });
     return names;
 }
 function exported(statement, path) {
     const name = (node, kind, spaces) => ({ name: node.name, kind, spaces, path });
+    if (statement.kind === 'ExportFromDeclaration')
+        return reexported(statement, path);
     if (!('exported' in statement) || !statement.exported)
         return [];
     switch (statement.kind) {
@@ -104,3 +114,14 @@ function exported(statement, path) {
             return [];
     }
 }
+/** `export { Rows } from "./rows.rk"`: the names of that module, as this one exports them. */
+function reexported(statement, path) {
+    if (!statement.source.value.endsWith('.rk'))
+        return [];
+    const names = exportsOf(resolve(dirname(path), statement.source.value));
+    if (!statement.specifiers)
+        return names.map((each) => ({ ...each, path }));
+    return statement.specifiers.flatMap(({ imported, local }) => names
+        .filter((each) => each.name === imported.name)
+        .map((each) => ({ ...each, name: local.name, path })));
+}

package/dist/reexports.d.ts

@@ -0,0 +1,4 @@
+import type * as ast from './ast.ts';
+import type { ImportResult } from './checker/checker.ts';
+/** The JS names that each `export { ... } from` passes on, `name` or `name as other`. */
+export declare function reexportedNames(program: ast.Program, importModule: ((specifier: string) => ImportResult) | undefined): Map<ast.ExportFromDeclaration, string[]>;

package/dist/reexports.js

@@ -0,0 +1,56 @@
+import { packageExports } from "./codegen/imported.js";
+import { listenersName } from "./codegen/shared.js";
+import { decoratedName } from "./decorators.js";
+// `export { Rows } from "./rows.rk"` in JS: a component or a decorator goes with the hidden names
+// that the modules using it import from where they import it (codegen/imported.ts), and state with
+// its listeners. `export *` passes them all on by itself.
+/** The JS names that each `export { ... } from` passes on, `name` or `name as other`. */
+export function reexportedNames(program, importModule) {
+    const found = new Map();
+    for (const statement of program.body) {
+        if (statement.kind !== 'ExportFromDeclaration' || !statement.specifiers)
+            continue;
+        const result = statement.source.value.endsWith('.rk')
+            ? importModule?.(statement.source.value)
+            : undefined;
+        const exports = result && 'exports' in result ? result.exports : undefined;
+        const names = [];
+        const add = (name, as = name) => names.push(name === as ? name : `${name} as ${as}`);
+        for (const { imported, local } of statement.specifiers) {
+            const name = imported.name;
+            // Without the types of the module, the name is passed on as it is written.
+            if (!exports) {
+                add(name, local.name);
+                continue;
+            }
+            const component = exports.components?.get(name);
+            const decorator = exports.decorators?.get(name);
+            if (exports.values.has(name))
+                add(name, local.name);
+            if (exports.shared?.has(name))
+                add(listenersName(name), listenersName(local.name));
+            if (component) {
+                add(`$$${name}`);
+                for (const hidden of packageNames(name, component.inline))
+                    add(hidden);
+            }
+            if (decorator) {
+                for (const used of decorator.moduleNames)
+                    add(decoratedName(name, used));
+                for (const hidden of packageNames(name, decorator.inline))
+                    add(hidden);
+            }
+        }
+        found.set(statement, [...new Set(names)]);
+    }
+    return found;
+}
+/** The hidden names that inlining the component or decorator `root` imports from its module. */
+function packageNames(root, inline) {
+    if (!inline)
+        return [];
+    return [
+        ...packageExports(new Map([[root, inline]]), (name) => name).keys(),
+        ...[...inline.functions.keys()].map((other) => `$$${other}`),
+    ];
+}

package/dist/typescript/importer.d.ts

@@ -14,6 +14,8 @@ export declare class DeclarationImporter {
     private readonly shared;
     private libraryTypes;
     private readonly results;
+    /** The paths of each tsconfig.json, by its path. */
+    private readonly configPaths;
     /** The exports of the module `specifier` imported from the file `fromFile`. */
     import(fromFile: string, specifier: string): ImportResult;
     /**
@@ -23,6 +25,8 @@ export declare class DeclarationImporter {
     library(fromFile: string): Library | undefined;
     private loadTypeScript;
     private resolve;
+    /** `paths` of the nearest tsconfig.json, `@/lib/*`, which imports of the file may use. */
+    private pathsFor;
     private addTypeRoots;
     private options;
     /**

package/dist/typescript/importer.js

@@ -1,6 +1,6 @@
 import { existsSync, readdirSync } from 'node:fs';
 import { createRequire } from 'node:module';
-import { dirname, join } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { TypeConverter } from "./convert.js";
 import { LibraryTypes } from "./library.js";
 // Types of imports that are not `.rk` modules: npm packages, `node:` modules and `.ts` files.
@@ -22,6 +22,8 @@ export class DeclarationImporter {
     shared = new Map();
     libraryTypes;
     results = new Map();
+    /** The paths of each tsconfig.json, by its path. */
+    configPaths = new Map();
     /** The exports of the module `specifier` imported from the file `fromFile`. */
     import(fromFile, specifier) {
         const key = `${dirname(fromFile)}\0${specifier}`;
@@ -65,7 +67,8 @@ export class DeclarationImporter {
     }
     resolve(ts, fromFile, specifier) {
         this.addTypeRoots(fromFile);
-        const { resolvedModule } = ts.resolveModuleName(specifier, fromFile, this.options(ts), ts.sys);
+        const options = { ...this.options(ts), ...this.pathsFor(ts, fromFile) };
+        const { resolvedModule } = ts.resolveModuleName(specifier, fromFile, options, ts.sys);
         if (resolvedModule) {
             const file = resolvedModule.resolvedFileName;
             // A JS file without declarations next to it.
@@ -78,7 +81,9 @@ export class DeclarationImporter {
             const { program, converter } = this.current(ts);
             const source = program.getSourceFile(file);
             const module = source && program.getTypeChecker().getSymbolAtLocation(source);
-            return module ? { exports: converter.moduleExports(module) } : undefined;
+            if (module)
+                return { exports: converter.moduleExports(module) };
+            // `@types/bun` only refers to `bun-types`, whose `declare module "bun"` declares the module.
         }
         // `node:fs`, `fs`: modules declared with `declare module "..."`, as in @types/node.
         const { program, converter } = this.current(ts);
@@ -89,6 +94,25 @@ export class DeclarationImporter {
             .find((module) => module.name === name);
         return ambient ? { exports: converter.moduleExports(ambient) } : undefined;
     }
+    /** `paths` of the nearest tsconfig.json, `@/lib/*`, which imports of the file may use. */
+    pathsFor(ts, fromFile) {
+        const config = ts.findConfigFile(dirname(fromFile), (path) => ts.sys.fileExists(path));
+        if (!config)
+            return {};
+        let options = this.configPaths.get(config);
+        if (!options) {
+            const { config: json } = ts.readConfigFile(config, (path) => ts.sys.readFile(path));
+            const compilerOptions = json?.compilerOptions;
+            options = compilerOptions?.paths
+                ? {
+                    paths: compilerOptions.paths,
+                    baseUrl: resolve(dirname(config), compilerOptions.baseUrl ?? '.'),
+                }
+                : {};
+            this.configPaths.set(config, options);
+        }
+        return options;
+    }
     addTypeRoots(fromFile) {
         for (let directory = dirname(fromFile);; directory = dirname(directory)) {
             const types = join(directory, 'node_modules', '@types');

package/dist/typescript/library.js

@@ -16,8 +16,11 @@ export class LibraryTypes {
         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);
+        // `declare global { export import Bun = BunModule }` of bun-types is an alias of a module.
+        for (const symbol of this.checker.getSymbolsInScope(lib, ts.SymbolFlags.Value | ts.SymbolFlags.Alias)) {
+            const value = symbol.flags & ts.SymbolFlags.Alias ? this.checker.getAliasedSymbol(symbol) : symbol;
+            if (value.flags & ts.SymbolFlags.Value)
+                this.values.set(symbol.name, value);
         }
         for (const symbol of this.checker.getSymbolsInScope(lib, ts.SymbolFlags.Type)) {
             this.types.set(symbol.name, symbol);

package/dist/walk.js

@@ -14,6 +14,11 @@ export function forEachChild(node, visit) {
         case 'BlockStatement':
             each(node.body);
             break;
+        case 'ExportFromDeclaration':
+            if (node.specifiers)
+                each(node.specifiers);
+            visit(node.source);
+            break;
         case 'ImportDeclaration':
             optional(node.defaultImport);
             optional(node.namespaceImport);
@@ -182,6 +187,13 @@ export function forEachChild(node, visit) {
         case 'StyleStatement':
             each(node.parts);
             break;
+        case 'NonNullExpression':
+            visit(node.expression);
+            break;
+        case 'TaggedTemplateExpression':
+            visit(node.tag);
+            visit(node.quasi);
+            break;
         case 'TemplateLiteral':
             node.quasis.forEach((quasi, i) => {
                 visit(quasi);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rooklang",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "A language with JavaScript semantics, Go-style syntax, goroutines on real threads and static types that compiles to readable JavaScript",
   "keywords": [
     "rooklang",
@@ -60,7 +60,9 @@
   },
   "files": [
     "dist",
-    "src/runtime/*.js"
+    "src/runtime/*.js",
+    "CHANGELOG.md",
+    "CHANGELOG.ru.md"
   ],
   "scripts": {
     "rook": "node src/cli.ts",