@tsplc/compiler 0.0.0-stage → 0.2.0

package/src/frontend/exposure.ts

@@ -0,0 +1,147 @@
+import { runtimeSources } from "./module-graph.ts";
+import ts from "typescript";
+import { createHash } from "node:crypto";
+import { dirname } from "node:path";
+import { error, type Diagnostic } from "@tsplc/compiler/ir";
+
+/** Telemetry is sampled by its authored task and published read-only by the backend. */
+export const lowerExposure = (program: ts.Program, sdk: string) => {
+  const checker = program.getTypeChecker();
+  const sources = new Map<string, string>();
+  const diagnostics: Diagnostic[] = [];
+  const variables = new Map<string, { name: string; version: string }>();
+  const names = new Set<string>();
+  const symbol = (node: ts.Node) => {
+    let value = checker.getSymbolAtLocation(node);
+    while (value && value.flags & ts.SymbolFlags.Alias) value = checker.getAliasedSymbol(value);
+    return value;
+  };
+  for (const source of runtimeSources(program)) {
+    if (source.isDeclarationFile) continue;
+    const edits: { start: number; end: number; text: string }[] = [];
+    const extra: string[] = [];
+    const visit = (node: ts.Node): void => {
+      if (
+        !ts.isCallExpression(node) ||
+        symbol(node.expression)?.name !== "expose" ||
+        !symbol(node.expression)?.declarations?.some((value) =>
+          value.getSourceFile().fileName.startsWith(dirname(sdk) + "/"),
+        )
+      ) {
+        ts.forEachChild(node, visit);
+        return;
+      }
+      const fail = (message: string) => {
+        const start = node.getStart(source),
+          position = source.getLineAndCharacterOfPosition(start);
+        diagnostics.push(
+          error("PLC1014", message, {
+            file: source.fileName,
+            start,
+            end: node.end,
+            line: position.line + 1,
+            column: position.character + 1,
+          }),
+        );
+      };
+      const [label, values] = node.arguments;
+      if (
+        !label ||
+        !ts.isStringLiteral(label) ||
+        !/^[A-Za-z_][A-Za-z0-9_]*$/.test(label.text) ||
+        label.text === "__proto__" ||
+        !values ||
+        !ts.isObjectLiteralExpression(values) ||
+        !ts.isExpressionStatement(node.parent)
+      ) {
+        fail(
+          "expose requires a literal machine name and a flat telemetry object in a synchronous cyclic routine.",
+        );
+        return;
+      }
+      let owner: ts.Node | undefined = node.parent;
+      while (owner && !ts.isFunctionLike(owner)) owner = owner.parent;
+      if (
+        !owner ||
+        (ts.canHaveModifiers(owner) &&
+          ts.getModifiers(owner)?.some((value) => value.kind === ts.SyntaxKind.AsyncKeyword))
+      ) {
+        fail("Sample telemetry from a synchronous cyclic routine, outside async continuations.");
+        return;
+      }
+      if (names.has(label.text)) {
+        fail(`Duplicate machine exposure ${label.text}.`);
+        return;
+      }
+      names.add(label.text);
+      const fields: { name: string; type: string; value: string }[] = [];
+      for (const property of values.properties) {
+        if (
+          !ts.isPropertyAssignment(property) ||
+          !ts.isIdentifier(property.name) ||
+          ["contractVersion", "__proto__"].includes(property.name.text)
+        ) {
+          fail("Telemetry uses named scalar fields; contractVersion and __proto__ are reserved.");
+          return;
+        }
+        const value = property.initializer;
+        const type = checker.getTypeAtLocation(value);
+        let annotation: string | undefined;
+        if (type.flags & ts.TypeFlags.BooleanLike) annotation = "BOOL";
+        const declaration = symbol(
+          ts.isPropertyAccessExpression(value) ? value.name : value,
+        )?.valueDeclaration;
+        if (
+          declaration &&
+          (ts.isPropertySignature(declaration) ||
+            ts.isPropertyDeclaration(declaration) ||
+            ts.isVariableDeclaration(declaration) ||
+            ts.isParameter(declaration)) &&
+          declaration.type
+        ) {
+          const text = declaration.type.getText(declaration.getSourceFile());
+          if (/^(BOOL|SINT|USINT|BYTE|INT|UINT|WORD|DINT|UDINT|DWORD|STRING<\d+>)$/.test(text))
+            annotation = text;
+        }
+        if (!annotation) {
+          fail(
+            `Telemetry ${property.name.text} needs a concrete BOOL, integer up to 32 bits or bounded STRING annotation.`,
+          );
+          return;
+        }
+        fields.push({ name: property.name.text, type: annotation, value: value.getText(source) });
+      }
+      if (!fields.length) {
+        fail("Expose at least one telemetry field.");
+        return;
+      }
+      const name = `tsplcExposed_${label.text}`;
+      const record = `TsplcTelemetry_${label.text}`;
+      const version = createHash("sha256")
+        .update(
+          JSON.stringify({
+            abi: 1,
+            name: label.text,
+            fields: fields.map(({ name, type }) => ({ name, type })),
+          }),
+        )
+        .digest("hex");
+      extra.push(
+        `export interface ${record}{contractVersion:STRING<64>;${fields.map((field) => `${field.name}:${field.type}`).join(";")}}\nexport let ${name}:${record}=defaultValue<${record}>();`,
+      );
+      variables.set(`${source.fileName}:${name}`, { name: label.text, version });
+      edits.push({
+        start: node.getStart(source),
+        end: node.end,
+        text: `{${name}.contractVersion=${JSON.stringify(version)};${fields.map((field) => `${name}.${field.name}=${field.value};`).join("")}}`,
+      });
+    };
+    visit(source);
+    if (!edits.length) continue;
+    let text = source.text;
+    for (const edit of edits.sort((a, b) => b.start - a.start))
+      text = text.slice(0, edit.start) + edit.text + text.slice(edit.end);
+    sources.set(source.fileName, text + "\n" + extra.join("\n"));
+  }
+  return { sources, diagnostics, variables };
+};

package/src/frontend/module-graph.ts

@@ -0,0 +1,63 @@
+import ts from "typescript";
+
+/** Runtime imports define execution; type-only imports provide layouts without allocating state. */
+export const runtimeSources = (program: ts.Program): readonly ts.SourceFile[] => {
+  const checker = program.getTypeChecker();
+  const visited = new Set<ts.SourceFile>();
+  // A block array allocates through its type, so its block's module runs even when type-imported.
+  const visitBlockArrays = (node: ts.Node): void => {
+    if (
+      ts.isTypeReferenceNode(node) &&
+      node.typeName.getText() === "FixedArray" &&
+      node.typeArguments?.[0] &&
+      ts.isTypeReferenceNode(node.typeArguments[0])
+    ) {
+      let symbol = checker.getSymbolAtLocation(node.typeArguments[0].typeName);
+      while (symbol && symbol.flags & ts.SymbolFlags.Alias)
+        symbol = checker.getAliasedSymbol(symbol);
+      const block = symbol?.declarations?.find(ts.isClassDeclaration);
+      if (block) visit(block.getSourceFile());
+    }
+    ts.forEachChild(node, visitBlockArrays);
+  };
+  const visit = (source: ts.SourceFile): void => {
+    if (visited.has(source)) return;
+    visited.add(source);
+    if (source.isDeclarationFile) return;
+    visitBlockArrays(source);
+    for (const statement of source.statements) {
+      if (ts.isImportDeclaration(statement)) {
+        if (statement.importClause?.isTypeOnly) continue;
+        const bindings = statement.importClause?.namedBindings;
+        if (
+          !statement.importClause?.name &&
+          bindings &&
+          ts.isNamedImports(bindings) &&
+          bindings.elements.every((value) => value.isTypeOnly)
+        )
+          continue;
+        const target = checker
+          .getSymbolAtLocation(statement.moduleSpecifier)
+          ?.declarations?.find(ts.isSourceFile);
+        if (target) visit(target);
+      }
+      if (ts.isExportDeclaration(statement) && statement.moduleSpecifier && !statement.isTypeOnly) {
+        if (
+          statement.exportClause &&
+          ts.isNamedExports(statement.exportClause) &&
+          statement.exportClause.elements.every((value) => value.isTypeOnly)
+        )
+          continue;
+        const target = checker
+          .getSymbolAtLocation(statement.moduleSpecifier)
+          ?.declarations?.find(ts.isSourceFile);
+        if (target) visit(target);
+      }
+    }
+  };
+  for (const file of program.getRootFileNames()) {
+    const source = program.getSourceFile(file);
+    if (source) visit(source);
+  }
+  return program.getSourceFiles().filter((source) => visited.has(source));
+};