rooklang 0.4.2 → 0.5.0

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.2",
+  "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",