rooklang 0.3.3 → 0.4.0

package/dist/source-map.js

@@ -0,0 +1,75 @@
+import { SourceFile } from "./source.js";
+const MARK = /([0-9a-z]+)/g;
+/** The mark of a place in the source, `<offset in base 36>`, which code cannot contain. */
+export function sourceMark(offset) {
+    return `${offset.toString(36)}`;
+}
+/** The code without its marks, and the source map of them. */
+export function withoutMarks(code, source, sourceName) {
+    const file = new SourceFile(sourceName, source);
+    const lines = [];
+    const segments = [];
+    // The previous segment, relative to which the next one is written.
+    let previous = { line: 0, column: 0 };
+    let started = false;
+    for (const text of code.split('\n')) {
+        const places = [];
+        let removed = 0;
+        const clean = text.replace(MARK, (mark, offset, index) => {
+            const { line, column } = file.position(parseInt(offset, 36));
+            places.push({ generated: index - removed, line: line - 1, column: column - 1 });
+            removed += mark.length;
+            return '';
+        });
+        if (places.length === 0 && started && clean.trim() !== '') {
+            places.push({ generated: 0, ...previous });
+        }
+        let generated = 0;
+        segments.push(places
+            .map((place) => {
+            const segment = vlq([
+                place.generated - generated,
+                // The index of the source, which is always the one.
+                0,
+                place.line - previous.line,
+                place.column - previous.column,
+            ]);
+            generated = place.generated;
+            previous = { line: place.line, column: place.column };
+            started = true;
+            return segment;
+        })
+            .join(','));
+        lines.push(clean);
+    }
+    return {
+        code: lines.join('\n'),
+        map: {
+            version: 3,
+            sources: [sourceName],
+            sourcesContent: [source],
+            names: [],
+            mappings: segments.join(';'),
+        },
+    };
+}
+/** The comment at the end of a module that tells where its source map is. */
+export function sourceMapComment(url) {
+    return `//# sourceMappingURL=${url}\n`;
+}
+const BASE64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+/** Numbers in base 64 VLQ: five bits a digit, the lowest first, and the sign in the lowest bit. */
+function vlq(numbers) {
+    let text = '';
+    for (const number of numbers) {
+        let value = number < 0 ? (-number << 1) | 1 : number << 1;
+        do {
+            let digit = value & 31;
+            value >>>= 5;
+            if (value > 0)
+                digit |= 32;
+            text += BASE64[digit];
+        } while (value > 0);
+    }
+    return text;
+}

package/dist/ts-types.js

@@ -1,6 +1,6 @@
 import { CONTENT } from "./checker/dom.js";
 import { guardedByError } from "./checker/error-results.js";
-import { ERROR_CLASS, isQueue, memberNames, queueElement, } from "./checker/types.js";
+import { ERROR_CLASS, isQueue, isTopic, memberNames, queueElement, } from "./checker/types.js";
 // Types of the checker in TypeScript syntax, for declaration files (declarations.ts).
 /** A nullable property may be left out of an object: `name?: string | null`. */
 export function property(name, type) {
@@ -108,6 +108,9 @@ function objectType(type) {
     if (type.name === 'chan' || type.name === 'chan<-' || type.name === '<-chan') {
         return `{ readonly $$chan: string }`;
     }
+    // A topic is an object with its name, and so is it for TypeScript code.
+    if (isTopic(type))
+        return `{ readonly $$topic: string }`;
     // A queue is an instance of $$Queue of the runtime (src/runtime/queue.js): TypeScript code uses its
     // members.
     if (isQueue(type)) {

package/dist/typescript/convert-objects.d.ts

@@ -17,7 +17,8 @@ export declare abstract class ObjectConverter extends ConverterBase {
     protected object(type: TS.Type, name: string | null, typeParams?: TypeParam[]): ObjectType;
     /**
      * What `for v in x` gives: the `value` of what `next()` of `[Symbol.iterator]()` returns while
-     * it is not `done`. Found when it is first needed, as most types are never looped over.
+     * it is not `done`, or of what its Promise gives for `[Symbol.asyncIterator]()`. Found when it is
+     * first needed, as most types are never looped over.
      */
     private iterates;
     protected member(type: TS.Type, name: string, owner: ClassInfo | null): Member | undefined;

package/dist/typescript/convert-objects.js

@@ -9,10 +9,13 @@ export class ObjectConverter extends ConverterBase {
             const [element] = checker.getTypeArguments(type);
             return arrayOf(element ? this.convert(element) : ANY);
         }
-        // A tuple is an array of any of its elements: `[string, number]` is `[](string | number)`.
+        // A tuple is an array of any of its elements: `[string, number]` is `[](string | number)`,
+        // which keeps them by position too, to infer the type parameters of `[K, V]`.
         if (checker.isTupleType(type)) {
-            const elements = checker.getTypeArguments(type);
-            return arrayOf(elements.length > 0 ? union(elements.map((each) => this.convert(each))) : ANY);
+            const elements = checker
+                .getTypeArguments(type)
+                .map((each) => this.convert(each));
+            return elements.length > 0 ? arrayOf(union(elements), elements) : arrayOf(ANY);
         }
         if (type.objectFlags & ObjectFlags.Reference) {
             const reference = type;
@@ -116,23 +119,26 @@ export class ObjectConverter extends ConverterBase {
             object.index = this.convert(index);
         if (numberIndex && numberIndex !== index)
             object.numberIndex = this.convert(numberIndex);
-        this.iterates(object, type);
+        this.iterates(object, type, 'iterates');
+        this.iterates(object, type, 'asyncIterates');
         return object;
     }
     /**
      * What `for v in x` gives: the `value` of what `next()` of `[Symbol.iterator]()` returns while
-     * it is not `done`. Found when it is first needed, as most types are never looped over.
+     * it is not `done`, or of what its Promise gives for `[Symbol.asyncIterator]()`. Found when it is
+     * first needed, as most types are never looped over.
      */
-    iterates(object, type) {
+    iterates(object, type, key) {
         const { checker } = this;
+        const prefix = key === 'iterates' ? '__@iterator@' : '__@asyncIterator@';
         const iterator = type
             .getProperties()
-            .find((property) => String(property.escapedName).startsWith('__@iterator@'));
+            .find((property) => String(property.escapedName).startsWith(prefix));
         if (!iterator)
             return;
         let found;
         let done = false;
-        Object.defineProperty(object, 'iterates', {
+        Object.defineProperty(object, key, {
             enumerable: true,
             get: () => {
                 if (done)
@@ -143,7 +149,8 @@ export class ObjectConverter extends ConverterBase {
                     .getCallSignatures()[0]
                     ?.getReturnType()
                     .getProperty('next');
-                const result = next && checker.getTypeOfSymbol(next).getCallSignatures()[0]?.getReturnType();
+                const returned = next && checker.getTypeOfSymbol(next).getCallSignatures()[0]?.getReturnType();
+                const result = returned && key === 'asyncIterates' ? checker.getAwaitedType(returned) : returned;
                 const results = result?.isUnion() ? result.types : result ? [result] : [];
                 const yielded = results.find((each) => {
                     const flag = each.getProperty('done');
@@ -240,6 +247,8 @@ export class ObjectConverter extends ConverterBase {
         if (base)
             info.superClass = this.classInfo(base.symbol);
         info.ctor = this.signatures(checker.getSignaturesOfType(statics, SignatureKind.Construct));
+        // A stream of Node is a class, gone over with `for await` in JS.
+        this.iterates(info, instance, 'asyncIterates');
         return info;
     }
 }

package/dist/vite.js

@@ -1,5 +1,5 @@
 import { readFileSync } from 'node:fs';
-import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import { basename, dirname, extname, isAbsolute, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { RUNTIME_MODULE } from "./runtime-module.js";
 import { formatDiagnostic } from "./diagnostics.js";
@@ -12,6 +12,8 @@ import { SourceFile } from "./source.js";
 // path has no query, since Vite drops the query of a worker's URL. The compiled code imports the
 // runtime, "rooklang/runtime", of the plugin's own package.
 const GOROUTINES = '.goroutines.js';
+/** The loader of `.rk` files of `rook run`, next to this file: .ts in src, .js in the package. */
+const LOADER = new URL(`./loader${extname(fileURLToPath(import.meta.url))}`, import.meta.url).href;
 export function rook(options = {}) {
     const typeCheck = options.typeCheck ?? true;
     let root = process.cwd();
@@ -46,7 +48,7 @@ export function rook(options = {}) {
                 return null;
             return readFileSync(path.slice(0, -GOROUTINES.length), 'utf8');
         },
-        transform(source, id) {
+        transform(source, id, transformOptions) {
             const [name = id, query] = id.split('?');
             const worker = name.endsWith(`.rk${GOROUTINES}`);
             const path = worker ? name.slice(0, -GOROUTINES.length) : name;
@@ -59,7 +61,11 @@ export function rook(options = {}) {
                 rewriteImports: false,
                 typeCheck,
                 markup: options.markup,
-                workerUrl: `./${basename(path)}${GOROUTINES}`,
+                // In Node, as under Vitest, a worker thread loads the module itself, `app.rk?goroutines`,
+                // with the loader of `rook run`, which it imports first: it has no Vite.
+                ...(transformOptions?.ssr === true
+                    ? { workerUrl: `./${basename(path)}?goroutines`, nodeLoader: LOADER }
+                    : { workerUrl: `./${basename(path)}${GOROUTINES}` }),
             });
             const file = new SourceFile(relative(root, path), source);
             // Vite counts columns from 0.
@@ -86,7 +92,9 @@ export function rook(options = {}) {
             for (const dependency of result.dependencies) {
                 this.addWatchFile(resolve(dirname(path), dependency));
             }
-            return { code: worker ? (result.worker ?? '') : result.code, map: null };
+            return worker
+                ? { code: result.worker ?? '', map: result.workerMap ?? null }
+                : { code: result.code, map: result.map ?? null };
         },
     };
 }

package/dist/walk-types.js

@@ -19,6 +19,7 @@ export function forEachTypeChild(node, visit) {
         case 'ArrayType':
         case 'ChanType':
         case 'QueueType':
+        case 'TopicType':
             visit(node.element);
             break;
         case 'NullableType':

package/dist/walk.d.ts

@@ -1,5 +1,3 @@
 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

@@ -30,7 +30,7 @@ export function forEachChild(node, visit) {
             visit(node.name);
             each(node.params);
             each(node.results);
-            visit(node.body);
+            optional(node.body);
             break;
         case 'Parameter':
             visit(node.name);
@@ -47,19 +47,18 @@ export function forEachChild(node, visit) {
             // The names after `needs` are other decorators', not values in scope.
             visit(node.name);
             each(node.params);
+            each(node.includes);
             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);
+            optional(node.body);
             break;
         case 'ClassDeclaration':
             visit(node.name);
@@ -111,11 +110,16 @@ export function forEachChild(node, visit) {
             visit(node.element);
             optional(node.items);
             break;
+        case 'TopicExpression':
+            visit(node.element);
+            visit(node.name);
+            break;
         case 'MakeExpression':
             visit(node.type);
             visit(node.length);
             break;
         case 'ConversionExpression':
+        case 'DecodeExpression':
             visit(node.type);
             visit(node.argument);
             break;
@@ -123,6 +127,7 @@ export function forEachChild(node, visit) {
             each(node.values);
             break;
         case 'IfStatement':
+            optional(node.init);
             visit(node.condition);
             visit(node.consequent);
             optional(node.alternate);
@@ -137,9 +142,11 @@ export function forEachChild(node, visit) {
             optional(node.key);
             visit(node.value);
             visit(node.iterable);
+            optional(node.withKey ?? null);
             visit(node.body);
             break;
         case 'SwitchStatement':
+            optional(node.init);
             optional(node.discriminant);
             each(node.cases);
             break;
@@ -204,6 +211,7 @@ export function forEachChild(node, visit) {
             visit(node.body);
             break;
         case 'UnaryExpression':
+        case 'TryExpression':
             visit(node.argument);
             break;
         case 'GoExpression':
@@ -265,6 +273,7 @@ export function forEachChild(node, visit) {
         case 'ArrayType':
         case 'ChanType':
         case 'QueueType':
+        case 'TopicType':
         case 'NullableType':
         case 'FuncType':
         case 'ComponentType':
@@ -287,6 +296,7 @@ export function forEachChild(node, visit) {
         case 'NumberLiteral':
         case 'BigIntLiteral':
         case 'StringLiteral':
+        case 'RegExpLiteral':
         case 'TemplateElement':
         case 'BooleanLiteral':
         case 'NullLiteral':
@@ -295,30 +305,3 @@ export function forEachChild(node, visit) {
             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;
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rooklang",
-  "version": "0.3.3",
+  "version": "0.4.0",
   "description": "A language with JavaScript semantics, Go-style syntax, goroutines on real threads and static types that compiles to readable JavaScript",
   "keywords": [
     "rooklang",
@@ -57,7 +57,7 @@
   "scripts": {
     "rook": "node src/cli.ts",
     "site:dev": "vite",
-    "site:build": "vite build",
+    "site:build": "vite build && node scripts/prerender.ts",
     "site": "npm run site:build && node src/cli.ts run site/server.rk",
     "site:images": "node scripts/og-image.ts",
     "vscode:build": "node scripts/build-vscode.ts",

package/src/runtime/chan.js

@@ -1,10 +1,11 @@
 // Channels: sending, receiving and closing, here or in the thread that made the channel
 // (threads.js), and the queues of a channel. Receiving from a closed channel gives
-// the zero value of its type, as in Go.
+// the zero value of its type, as in Go. Channel.EMPTY is closed and belongs to no thread: a send to
+// it goes nowhere, and receiving gives the zero value that the code that receives passes.
 
 import { $$Queue } from './queue.js';
 import { $$commit, $$lock, $$select, $$try, $$unlock, $$unwait } from './select.js';
-import { $$adopt, $$ask, $$ownerOf, $$post, $$registry, $$stopped } from './threads.js';
+import { $$adopt, $$ask, $$isEmpty, $$ownerOf, $$post, $$registry, $$stopped } from './threads.js';
 
 $$registry().handle ??= { message: $$message, pump: $$pump };
 
@@ -32,6 +33,9 @@ export function $$chan(size, zero) {
 // that made the channel.
 export function $$send(channel, value) {
   const id = channel.$$chan;
+
+  if ($$isEmpty(id)) return Promise.resolve();
+
   const owner = $$ownerOf(id);
 
   if (owner !== $$registry().key) return $$ask(owner, { op: 'send', channel: id, value });
@@ -41,11 +45,12 @@ export function $$send(channel, value) {
   );
 }
 
-export function $$receive(channel, withOk = false) {
+export function $$receive(channel, withOk = false, zero = null) {
   const id = channel.$$chan;
   const owner = $$ownerOf(id);
-  const received =
-    owner !== $$registry().key
+  const received = $$isEmpty(id)
+    ? Promise.resolve([zero, false])
+    : owner !== $$registry().key
       ? $$ask(owner, { op: 'receive', channel: id })
       : new Promise((resolve, reject) => $$wait(id, 'receivers', { done: resolve, fail: reject }));
 
@@ -55,6 +60,9 @@ export function $$receive(channel, withOk = false) {
 // Closing a channel of another thread fails this one if it was closed already, as a panic would.
 export function $$close(channel) {
   const id = channel.$$chan;
+
+  if ($$isEmpty(id)) return;
+
   const owner = $$ownerOf(id);
 
   if (owner === $$registry().key) return $$closeHere(id);
@@ -70,6 +78,8 @@ export function $$closeHere(id) {
 
   if (state.closed) throw new Error('close of a closed channel');
   state.closed = true;
+  // What made the channel stops with it, as signal() does (signals.js).
+  state.onClose?.();
   $$pump(id);
 }
 

package/src/runtime/channel.js

@@ -0,0 +1,28 @@
+// `Channel`: what Rook code and the code compiled from it do with channels, by name. The functions
+// themselves are in chan.js, select.js, signals.js, streams.js and timers.js.
+
+import { $$chan, $$close, $$range, $$receive, $$send } from './chan.js';
+import { $$select, $$try } from './select.js';
+import { $$abortSignal, $$done, $$signal } from './signals.js';
+import { $$fromStream, $$stream } from './streams.js';
+import { $$after, $$tick } from './timers.js';
+
+export const $$Channel = Object.freeze({
+  // The zero value of channel types: closed, and the same in every thread (threads.js).
+  EMPTY: Object.freeze({ $$chan: 'empty', size: 0, zero: null }),
+  make: $$chan,
+  send: $$send,
+  receive: $$receive,
+  close: $$close,
+  range: $$range,
+  select: $$select,
+  // [] for a send and [value, ok] for a receive that goes on at once, else null.
+  try: (channel, send, value) => $$try(channel.$$chan, send, value),
+  fromStream: $$fromStream,
+  stream: $$stream,
+  after: $$after,
+  tick: $$tick,
+  signal: $$signal,
+  done: $$done,
+  abortSignal: $$abortSignal,
+});

package/src/runtime/classes.js

@@ -0,0 +1,32 @@
+// Data classes: `data class Point` registers its class with an id of its own, the name and a hash
+// of its code, the same in a module and in its worker module, which has a copy of the class. A copy
+// of a value that goes to another thread loses the class of its instances (structuredClone); the
+// thread that sends lists them with their ids (threads.js), and the one that gets the copy gives
+// them their class again.
+
+function registry() {
+  return (globalThis[Symbol.for('rook.classes')] ??= { byId: new Map(), ids: new WeakMap() });
+}
+
+export function $$dataClass(cls, id) {
+  const { byId, ids } = registry();
+
+  byId.set(id, cls.prototype);
+  ids.set(cls.prototype, id);
+}
+
+/** The id of the data class of an instance, or undefined. */
+export function $$classOf(value) {
+  return registry().ids.get(Object.getPrototypeOf(value));
+}
+
+/** Gives the copies of instances their classes back: `[object, id]` pairs of a copied message. */
+export function $$reclass(instances) {
+  const { byId } = registry();
+
+  for (const [object, id] of instances) {
+    const prototype = byId.get(id);
+
+    if (prototype) Object.setPrototypeOf(object, prototype);
+  }
+}

package/src/runtime/core.js

@@ -1,4 +1,5 @@
-// What the code of any module may need: `for` over a value of unknown type, and `defer`.
+// What the code of any module may need: `for` over a value of unknown type, `defer`, and wrapped
+// errors.
 
 // `for v in x` over an untyped value: a Map gives its values, as a typed one does.
 export function $$values(iterable) {
@@ -21,3 +22,11 @@ export function $$runDeferred(deferred) {
 
   if (failure) throw failure.error;
 }
+
+// `error("load user", err)`: an error whose message ends with that of its cause, as `%w` of Go
+// gives "load user: not found", and whose `cause` is the error itself, for code that looks at it.
+export function $$wrap(message, cause) {
+  const reason = cause instanceof Error ? cause.message : String(cause);
+
+  return new Error(`${message}: ${reason}`, { cause });
+}