@tsplc/compiler 0.0.0-stage → 0.1.0

package/src/frontend/const-functions.ts

@@ -0,0 +1,153 @@
+import { runtimeSources } from "./module-graph.ts";
+import ts from "typescript";
+import { error, type Diagnostic } from "@tsplc/compiler/ir";
+
+/** Normalize static arrow bindings so all routine forms use the same PLC analysis. */
+export const lowerConstFunctions = (program: ts.Program) => {
+  const checker = program.getTypeChecker();
+  const printer = ts.createPrinter();
+  const sources = new Map<string, string>();
+  const diagnostics: Diagnostic[] = [];
+
+  for (const source of runtimeSources(program)) {
+    if (source.isDeclarationFile) continue;
+    const edits: { start: number; end: number; text: string }[] = [];
+    for (const statement of source.statements) {
+      const routines = ts.isClassDeclaration(statement)
+        ? statement.members.filter(ts.isMethodDeclaration)
+        : [statement];
+      for (const routine of routines) {
+        if (
+          (!ts.isFunctionDeclaration(routine) && !ts.isMethodDeclaration(routine)) ||
+          routine.type ||
+          !routine.body ||
+          !routine.modifiers?.some((item) => item.kind === ts.SyntaxKind.AsyncKeyword)
+        )
+          continue;
+        const signature = checker.getSignatureFromDeclaration(routine);
+        const result =
+          signature && checker.getAwaitedType(checker.getReturnTypeOfSignature(signature));
+        if (result && result.flags & ts.TypeFlags.Void) {
+          const position = routine.body.getStart(source);
+          edits.push({ start: position, end: position, text: ":Promise<void> " });
+        }
+      }
+    }
+    for (const statement of source.statements) {
+      if (
+        !ts.isVariableStatement(statement) ||
+        !statement.declarationList.declarations.some(
+          (declaration) => declaration.initializer && ts.isArrowFunction(declaration.initializer),
+        )
+      )
+        continue;
+
+      const declarations: ts.Statement[] = [];
+      for (const declaration of statement.declarationList.declarations) {
+        const arrow = declaration.initializer;
+        if (!arrow || !ts.isArrowFunction(arrow)) {
+          declarations.push(
+            ts.factory.updateVariableStatement(
+              statement,
+              statement.modifiers,
+              ts.factory.updateVariableDeclarationList(statement.declarationList, [declaration]),
+            ),
+          );
+          continue;
+        }
+        if (
+          !(statement.declarationList.flags & ts.NodeFlags.Const) ||
+          !ts.isIdentifier(declaration.name)
+        ) {
+          const start = declaration.getStart(source);
+          const position = source.getLineAndCharacterOfPosition(start);
+          diagnostics.push(
+            error(
+              "PLC1007",
+              "PLC routines require named const bindings; mutable function values are unsupported.",
+              {
+                file: source.fileName,
+                start,
+                end: declaration.end,
+                line: position.line + 1,
+                column: position.character + 1,
+              },
+            ),
+          );
+          continue;
+        }
+
+        const contextual =
+          declaration.type && ts.isFunctionTypeNode(declaration.type)
+            ? declaration.type
+            : undefined;
+        const signature = checker.getTypeAtLocation(declaration.name).getCallSignatures()[0];
+        const returnsVoid =
+          signature &&
+          Boolean(checker.getReturnTypeOfSignature(signature).flags & ts.TypeFlags.Void);
+        const inferredResult =
+          signature && checker.getAwaitedType(checker.getReturnTypeOfSignature(signature));
+        const asyncVoid =
+          arrow.modifiers?.some((item) => item.kind === ts.SyntaxKind.AsyncKeyword) &&
+          inferredResult &&
+          inferredResult.flags & ts.TypeFlags.Void;
+        const inferredType = asyncVoid
+          ? ts.factory.createTypeReferenceNode("Promise", [
+              ts.factory.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword),
+            ])
+          : undefined;
+        const result =
+          arrow.type ??
+          contextual?.type ??
+          (returnsVoid
+            ? ts.factory.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword)
+            : inferredType);
+        const parameters = arrow.parameters.map((parameter, index) =>
+          ts.factory.updateParameterDeclaration(
+            parameter,
+            parameter.modifiers,
+            parameter.dotDotDotToken,
+            parameter.name,
+            parameter.questionToken,
+            parameter.type ?? contextual?.parameters[index]?.type,
+            parameter.initializer,
+          ),
+        );
+        const body = ts.isBlock(arrow.body)
+          ? arrow.body
+          : ts.factory.createBlock(
+              [
+                result?.kind === ts.SyntaxKind.VoidKeyword
+                  ? ts.factory.createExpressionStatement(arrow.body)
+                  : ts.factory.createReturnStatement(arrow.body),
+              ],
+              true,
+            );
+        declarations.push(
+          ts.factory.createFunctionDeclaration(
+            [...(statement.modifiers ?? []), ...(arrow.modifiers ?? [])],
+            undefined,
+            declaration.name,
+            arrow.typeParameters ?? contextual?.typeParameters,
+            parameters,
+            result,
+            body,
+          ),
+        );
+      }
+      edits.push({
+        start: statement.getStart(source),
+        end: statement.end,
+        text: declarations
+          .map((declaration) => printer.printNode(ts.EmitHint.Unspecified, declaration, source))
+          .join("\n"),
+      });
+    }
+    if (!edits.length) continue;
+    let text = source.text;
+    for (const edit of edits.reverse())
+      text = text.slice(0, edit.start) + edit.text + text.slice(edit.end);
+    sources.set(source.fileName, text);
+  }
+  return { sources, diagnostics };
+};

package/src/frontend/cooperative.ts

@@ -0,0 +1,75 @@
+interface Parameter {
+  name: string;
+  type: string;
+  aggregate: boolean;
+}
+interface Worker {
+  start: string;
+  advance: string;
+  snapshot: string;
+  reset: string;
+  declaration: string;
+}
+
+/** A fixed call-site frame; callbacks and ordinary state stay in the caller task. */
+export const cooperativeSite = (
+  name: string,
+  parameters: readonly Parameter[],
+  worker: Worker,
+  inline: boolean,
+) => {
+  const prefix = inline ? name : "site";
+  const field = (label: string) => `${prefix}_${label}`;
+  const member = (label: string) => `this.${field(label)}`;
+  const method = (label: string) => (inline ? `${name}_${label}` : label);
+  const invoke = (label: string, args = "") => `this.${method(label)}(${args})`;
+  const copy = (value: string, aggregate: boolean) => (aggregate ? `copy(${value})` : value);
+  const faults = `${member("faults")}=tsplcAsyncWrapAdd<UDINT>(${member("faults")},1);${member("lastError")}=7;`;
+  const signature = parameters.map((parameter) => `${parameter.name}:${parameter.type}`).join(",");
+  const args = parameters.map((parameter) => parameter.name).join(",");
+  const queued = parameters.map((parameter) => member(`queued_${parameter.name}`)).join(",");
+  const fields = `private ${field("active")}:BOOL=false;private ${field("fresh")}:BOOL=false;private ${field("cancelled")}:BOOL=false;private ${field("queued")}:BOOL=false;private ${field("faults")}:UDINT=0;private ${field("lastError")}:UDINT=0;
+${parameters.map((parameter) => `private ${field(`queued_${parameter.name}`)}:${parameter.type}=defaultValue<${parameter.type}>();`).join("\n")}
+${worker.declaration}`;
+  const body = `${fields}
+public ${method("begin")}(${signature}):void{const accepted:BOOL=${worker.start}(${args});if(!accepted){${faults}return;}${member("active")}=true;${member("fresh")}=true;${member("cancelled")}=false;${worker.advance}({cancel:false});}
+public ${method("start")}(${signature}):void{if(${member("active")}){if(${member("cancelled")}&&!${member("queued")}){${parameters.map((parameter) => `${member(`queued_${parameter.name}`)}=${copy(parameter.name, parameter.aggregate)};`).join("")}${member("queued")}=true;}else{${faults}}return;}${invoke("begin", args)};}
+public ${method("cancel")}():void{${member("cancelled")}=true;${member("queued")}=false;}
+public ${method("poll")}():void{
+if(${member("faults")}>0&&tsplcPromiseDiagnostics.report(${member("lastError")},${member("faults")}))${member("faults")}=0;
+if(!${member("active")})return;
+if(${member("fresh")}&&!${member("cancelled")}){${member("fresh")}=false;return;}
+${worker.advance}({cancel:${member("cancelled")}});const state=${worker.snapshot}();if(!state.done)return;
+if(!${member("cancelled")}&&state.error!==0&&state.error!==1){${member("faults")}=tsplcAsyncWrapAdd<UDINT>(${member("faults")},1);${member("lastError")}=state.error;}
+${worker.reset}();${member("active")}=false;
+if(${member("queued")}){${member("queued")}=false;${invoke("begin", queued)};}
+}`;
+  return { body, start: method("start"), cancel: method("cancel"), poll: method("poll") };
+};
+
+/** A named task: the owner reads its state and result instead of attaching a callback. */
+export const taskSite = (
+  name: string,
+  parameters: readonly Parameter[],
+  worker: Worker,
+  inline: boolean,
+  value: { type: string; aggregate: boolean },
+) => {
+  const method = (label: string) => (inline ? `${name}_${label}` : label);
+  const cancelled = `this.${inline ? `${name}_cancelled` : "cancelled"}`;
+  const signature = parameters.map((parameter) => `${parameter.name}:${parameter.type}`).join(",");
+  const args = parameters.map((parameter) => parameter.name).join(",");
+  const result = value.aggregate ? "copy(state.result)" : "state.result";
+  const body = `private ${cancelled.slice(5)}:BOOL=false;
+${worker.declaration}
+public ${method("start")}(${signature}):BOOL{const accepted:BOOL=${worker.start}(${args});if(accepted){${cancelled}=false;${worker.advance}({cancel:false});}return accepted;}
+public ${method("cancel")}():BOOL{const state=${worker.snapshot}();if(!state.busy&&!state.done)return false;${cancelled}=true;return true;}
+public ${method("snapshot")}():{valid:BOOL;busy:BOOL;done:BOOL;cancelRequested:BOOL;error:UDINT;result:${value.type}}{const state=${worker.snapshot}();if(${cancelled}&&state.done)return {valid:true,busy:false,done:true,cancelRequested:false,error:1,result:defaultValue<${value.type}>()};return {valid:true,busy:state.busy,done:state.done,cancelRequested:${cancelled},error:state.error,result:${result}};}
+public ${method("reset")}():BOOL{const state=${worker.snapshot}();if(state.busy)return false;${worker.reset}();${cancelled}=false;return true;}
+public ${method("poll")}():void{${worker.advance}({cancel:${cancelled}});}`;
+  return {
+    body,
+    poll: method("poll"),
+    renames: new Map(["start", "cancel", "snapshot", "reset"].map((m) => [m, method(m)])),
+  };
+};

package/src/frontend/elaborate/capture.ts

@@ -0,0 +1,138 @@
+/**
+ * Runs a program's setup code in Bun and prints the object graph it builds: every module binding,
+ * and every object, array, class instance and function reachable from them. The compiler runs
+ * this in a subprocess (graph.ts), so setup code never shares the compiler's process.
+ *
+ * Usage: bun capture.ts <request.json>
+ */
+import { plugin } from "bun";
+import { readFileSync, realpathSync } from "node:fs";
+import type { CaptureRequest, CapturedGraph, CapturedValue, CapturedNode } from "./graph.ts";
+
+const request: CaptureRequest = JSON.parse(readFileSync(process.argv[2]!, "utf8"));
+// Bun loads modules by their real path; the compiler may name them through a symlink.
+const real = new Map(request.files.map((file) => [realpathSync(file), file]));
+const runtime = new Set(real.keys());
+const exportName = "__tsplcCapture";
+
+/** Top-level bindings a module declares, so captured state can be traced back to its source. */
+const bindings = (source: string, names: CaptureRequest["bindings"][string]) =>
+  `${source}\n;export const ${exportName} = { values: { ${names.values
+    .map((name) => `${JSON.stringify(name)}: () => ${name}`)
+    .join(", ")} }, classes: { ${names.classes
+    .map((name) => `${JSON.stringify(name)}: ${name}`)
+    .join(", ")} }, functions: { ${names.functions
+    .map((name) => `${JSON.stringify(name)}: ${name}`)
+    .join(", ")} } };\n`;
+
+const servicePath = Symbol("tsplc service path");
+/** A service client: any property is a deeper procedure path, and its identity names that path. */
+const service = (path: readonly string[]): unknown =>
+  new Proxy(function serviceProcedure() {}, {
+    get: (_, key) => (key === servicePath ? path.join(".") : service([...path, String(key)])),
+    apply: () => {
+      throw new Error(`Setup code called the PLC service ${path.join(".")}.`);
+    },
+  });
+
+plugin({
+  name: "tsplc-capture",
+  setup(build) {
+    build.onLoad(
+      {
+        filter: new RegExp(
+          `^(${[...runtime].map((file) => file.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")})$`,
+        ),
+      },
+      ({ path }) => ({
+        contents: bindings(readFileSync(path, "utf8"), request.bindings[real.get(path)!]!),
+        loader: "ts",
+      }),
+    );
+    // Setup runs before the first scan, so the clock reads 0 there.
+    build.module("@tsplc/compiler/clock", () => ({
+      contents: "export const now = () => 0;",
+      loader: "js",
+    }));
+    build.module("@tsplc/compiler/async", () => ({
+      contents: `export const createServiceClient = () => globalThis.__tsplcService([]);
+        const unsupported = (name) => () => { throw new Error(name + " cannot run during PLC setup."); };
+        export const sleep = unsupported("sleep"), fetch = unsupported("fetch"), cancelAsync = unsupported("cancelAsync");`,
+      loader: "js",
+    }));
+  },
+});
+(globalThis as { __tsplcService?: unknown }).__tsplcService = service;
+
+const modules = new Map<string, Record<string, Record<string, unknown>>>();
+for (const file of [request.entry, ...request.files.filter((file) => file !== request.entry)]) {
+  const loaded = (await import(realpathSync(file))) as Record<string, unknown>;
+  modules.set(file, loaded[exportName] as Record<string, Record<string, unknown>>);
+}
+
+const classes = new Map<unknown, { file: string; name: string }>();
+const functions = new Map<unknown, { file: string; name: string }>();
+for (const [file, registry] of modules) {
+  for (const [name, value] of Object.entries(registry.classes!)) classes.set(value, { file, name });
+  for (const [name, value] of Object.entries(registry.functions!))
+    functions.set(value, { file, name });
+}
+
+const nodes: CapturedNode[] = [];
+const ids = new Map<object, number>();
+const capture = (value: unknown, where: string): CapturedValue => {
+  if (value === undefined) return { kind: "undefined" };
+  if (value === null) throw new Error(`${where}: null has no PLC value; use undefined.`);
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "string")
+    return { kind: typeof value, value } as CapturedValue;
+  if (typeof value === "bigint") return { kind: "bigint", value: String(value) };
+  if (typeof value !== "object" && typeof value !== "function")
+    throw new Error(`${where}: a ${typeof value} has no PLC value.`);
+  const known = ids.get(value);
+  if (known !== undefined) return { kind: "node", id: known };
+  const id = nodes.length;
+  ids.set(value, id);
+  nodes.push({ kind: "object", fields: {} });
+  if (typeof value === "function") {
+    const path = (value as { [servicePath]?: string })[servicePath];
+    const named = functions.get(value) ?? classes.get(value);
+    if (path !== undefined) nodes[id] = { kind: "service", path };
+    else if (named) nodes[id] = { kind: "function", ...named };
+    else
+      throw new Error(
+        `${where}: setup stored a function that is not a module-level function, so the PLC can't call it.`,
+      );
+    return { kind: "node", id };
+  }
+  if (Array.isArray(value)) {
+    nodes[id] = {
+      kind: "array",
+      items: value.map((item, index) => capture(item, `${where}[${index}]`)),
+    };
+    return { kind: "node", id };
+  }
+  const prototype = Object.getPrototypeOf(value);
+  const owner =
+    prototype === Object.prototype || prototype === null ? undefined : prototype.constructor;
+  const registered = owner && classes.get(owner);
+  if (owner && !registered)
+    throw new Error(`${where}: a ${owner.name} has no PLC layout; use a class from the program.`);
+  const fields: Record<string, CapturedValue> = {};
+  for (const [key, field] of Object.entries(value)) fields[key] = capture(field, `${where}.${key}`);
+  nodes[id] = registered ? { kind: "instance", ...registered, fields } : { kind: "object", fields };
+  return { kind: "node", id };
+};
+
+const graph: CapturedGraph = { nodes, bindings: [] };
+for (const [file, registry] of modules)
+  for (const [name, read] of Object.entries(registry.values!)) {
+    let value: unknown;
+    try {
+      value = (read as () => unknown)();
+    } catch {
+      continue; // A binding the module never initialized.
+    }
+    if (typeof value === "function" && (functions.has(value) || classes.has(value))) continue;
+    graph.bindings.push({ file, name, value: capture(value, name) });
+  }
+process.stdout.write(JSON.stringify(graph));

package/src/frontend/elaborate/graph.ts

@@ -0,0 +1,94 @@
+import ts from "typescript";
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+/** What capture.ts needs: the program's runtime files and the bindings each declares. */
+export interface CaptureRequest {
+  entry: string;
+  files: string[];
+  bindings: Record<string, { values: string[]; classes: string[]; functions: string[] }>;
+}
+
+export type CapturedValue =
+  | { kind: "undefined" }
+  | { kind: "number"; value: number }
+  | { kind: "boolean"; value: boolean }
+  | { kind: "string"; value: string }
+  | { kind: "bigint"; value: string }
+  | { kind: "node"; id: number };
+
+export type CapturedNode =
+  | { kind: "object"; fields: Record<string, CapturedValue> }
+  | { kind: "instance"; file: string; name: string; fields: Record<string, CapturedValue> }
+  | { kind: "array"; items: CapturedValue[] }
+  | { kind: "function"; file: string; name: string }
+  | { kind: "service"; path: string };
+
+export interface CapturedGraph {
+  nodes: CapturedNode[];
+  /** Every module-level value binding, in module evaluation order. */
+  bindings: { file: string; name: string; value: CapturedValue }[];
+}
+
+const names = (source: ts.SourceFile) => {
+  const found: CaptureRequest["bindings"][string] = { values: [], classes: [], functions: [] };
+  const bind = (name: ts.BindingName): void => {
+    if (ts.isIdentifier(name)) found.values.push(name.text);
+    else
+      for (const element of name.elements) if (!ts.isOmittedExpression(element)) bind(element.name);
+  };
+  for (const statement of source.statements) {
+    if (ts.isVariableStatement(statement))
+      for (const declaration of statement.declarationList.declarations) bind(declaration.name);
+    else if (ts.isClassDeclaration(statement) && statement.name)
+      found.classes.push(statement.name.text);
+    else if (ts.isFunctionDeclaration(statement) && statement.name && statement.body)
+      found.functions.push(statement.name.text);
+  }
+  // Arrow functions bound to consts are functions too: a stored callback names its binding.
+  for (const statement of source.statements)
+    if (ts.isVariableStatement(statement))
+      for (const declaration of statement.declarationList.declarations)
+        if (
+          ts.isIdentifier(declaration.name) &&
+          declaration.initializer &&
+          (ts.isArrowFunction(declaration.initializer) ||
+            ts.isFunctionExpression(declaration.initializer))
+        ) {
+          found.values = found.values.filter((name) => name !== declaration.name.getText());
+          found.functions.push(declaration.name.text);
+        }
+  return found;
+};
+
+/** Runs the program's setup in a Bun subprocess and returns the object graph it built. */
+export const captureGraph = (entry: string, sources: readonly ts.SourceFile[]): CapturedGraph => {
+  const files = sources.filter((source) => !source.isDeclarationFile);
+  const request: CaptureRequest = {
+    entry,
+    files: files.map((source) => source.fileName),
+    bindings: Object.fromEntries(files.map((source) => [source.fileName, names(source)])),
+  };
+  const directory = mkdtempSync(join(tmpdir(), "tsplc-capture-"));
+  try {
+    const file = join(directory, "request.json");
+    writeFileSync(file, JSON.stringify(request));
+    // The source tree runs capture.ts; a built package ships it beside the bundle.
+    const script = ["./capture.ts", "./elaborate-capture.js"]
+      .map((path) => fileURLToPath(new URL(path, import.meta.url)))
+      .find((path) => existsSync(path));
+    if (!script) throw new Error("The elaboration capture script is missing from this build.");
+    const result = spawnSync(process.execPath, [script, file], {
+      encoding: "utf8",
+      maxBuffer: 256 * 1024 * 1024,
+    });
+    if (result.status !== 0)
+      throw new Error(`Running the program's setup failed:\n${result.stderr.trim()}`);
+    return JSON.parse(result.stdout) as CapturedGraph;
+  } finally {
+    rmSync(directory, { recursive: true, force: true });
+  }
+};