@tsplc/compiler 0.0.0-stage → 0.1.0

package/backends/codesys/task-access.ts

@@ -0,0 +1,118 @@
+import { instancedBlock } from "@tsplc/compiler/ir";
+import type {
+  CoreExpression,
+  CoreFunction,
+  CorePath,
+  CoreStatement,
+  VerifiedCoreModule,
+} from "@tsplc/compiler/ir";
+
+// Follow both helper calls and instance updates. Borrow addresses count as storage
+// access, so scheduling cannot accidentally give one mutable record two owners.
+export function accessedStorage(
+  fn: CoreFunction,
+  core: VerifiedCoreModule,
+  scheduledHost?: string,
+): Set<string> {
+  // Only the generated entry's worker call may borrow its host. Ordinary calls
+  // reached through the async body still count as access to scan-owned storage.
+  const scheduledCall = fn.body.find(
+    (item) => item.kind === "invoke" && item.instance === scheduledHost,
+  );
+  const result = new Set<string>(),
+    seen = new Set<string>();
+  const functions = new Map(core.functions.map((item) => [item.id, item]));
+  const blocks = new Map(core.blocks.map((item) => [item.id, item]));
+  const types = new Map(core.types.map((item) => [item.id, item]));
+  const variables = new Map(
+    [
+      ...core.variables,
+      ...core.functions.flatMap((item) => [...item.parameters, ...item.locals]),
+      ...core.blocks.flatMap((item) => [
+        ...item.inputs,
+        ...item.outputs,
+        ...item.state,
+        ...item.locals,
+      ]),
+    ].map((item) => [item.id, item]),
+  );
+
+  const path = (segments: CorePath = []): void => {
+    segments.forEach((segment) => {
+      if (segment.kind === "index") expression(segment.value);
+    });
+  };
+
+  const expression = (value: CoreExpression): void => {
+    if (value.kind === "load") {
+      result.add(value.root);
+      path(value.path);
+    }
+    if (value.kind === "borrow") {
+      result.add(value.place.root);
+      path(value.place.path);
+    }
+    if (value.kind === "unary" || value.kind === "convert") expression(value.operand);
+    if (value.kind === "binary") {
+      expression(value.left);
+      expression(value.right);
+    }
+  };
+
+  const body = (items: readonly CoreStatement[]): void => {
+    for (const item of items) {
+      if (item.kind === "assign") {
+        result.add(item.root);
+        path(item.path);
+        expression(item.value);
+      }
+      if (item.kind === "if") {
+        expression(item.condition);
+        body(item.then);
+        body(item.else);
+      }
+      if (item.kind === "switch") {
+        expression(item.value);
+        for (const branch of item.cases) body(branch.body);
+        body(item.fallback);
+      }
+      if (item.kind === "for") {
+        if (item.dynamic) {
+          expression(item.dynamic.start);
+          expression(item.dynamic.limit);
+        }
+        result.add(item.counter);
+        body(item.body);
+      }
+      if (item.kind === "return" && item.value) expression(item.value);
+      if (item.kind === "invoke") {
+        if (item.instance && item !== scheduledCall) result.add(item.instance);
+        if (item.index) expression(item.index);
+        item.arguments.forEach(expression);
+        if (item.destination) result.add(item.destination);
+        const called = functions.get(item.function);
+        if (called && !seen.has(called.id)) {
+          seen.add(called.id);
+          body(called.body);
+        }
+      }
+      if (item.kind === "blockUpdate") {
+        result.add(item.instance);
+        if (item.index) expression(item.index);
+        Object.values(item.inputs).forEach(expression);
+        const variable = variables.get(item.instance);
+        if (!variable) throw new Error("Missing verified instance during task planning.");
+        const type = instancedBlock(variable.type, types);
+        const block = type && blocks.get(type.block);
+        if (block && !seen.has(block.id)) {
+          seen.add(block.id);
+          body(block.body);
+        }
+      }
+    }
+  };
+
+  seen.add(fn.id);
+  body(fn.body);
+  return result;
+}

package/backends/codesys/types.ts

@@ -0,0 +1,178 @@
+import { instancedBlock } from "@tsplc/compiler/ir";
+import type { Constant, GeneratedObject, PlcType } from "@tsplc/compiler/ir";
+import { Names } from "./names.ts";
+import { scalarLiteral } from "./numeric.ts";
+
+export class CodesysTypes {
+  readonly objects: GeneratedObject[] = [];
+  private readonly names = new Map<string, string>();
+  private readonly fields = new Map<string, Map<string, string>>();
+
+  constructor(
+    private readonly types: ReadonlyMap<string, PlcType>,
+    names: Names,
+    blockNames: ReadonlyMap<string, string>,
+  ) {
+    // Register every type and member name before following layout dependencies.
+    for (const type of types.values()) {
+      if (type.kind === "block") {
+        const name = blockNames.get(type.block);
+        if (!name) throw new Error("Missing verified block name");
+        this.names.set(type.id, name);
+      }
+      if (["record", "array", "enum", "string"].includes(type.kind)) {
+        const label = type.id.split(":").at(-1)!;
+        if (type.kind === "record" || type.kind === "enum") {
+          const prefix = type.kind === "record" ? "ST" : "E";
+          this.names.set(type.id, names.allocateObject(prefix, label));
+        } else this.names.set(type.id, names.allocate(`T_${label}`));
+      }
+      if (type.kind === "record" || type.kind === "enum") {
+        const names = new Names(),
+          fields = new Map<string, string>();
+        for (const member of type.kind === "record" ? type.fields : type.members) {
+          fields.set(member.name, names.allocate(member.name, true));
+        }
+        this.fields.set(type.id, fields);
+      }
+    }
+
+    // A block array is declared in place: a function block cannot be a data type's element.
+    for (const type of types.values())
+      if (type.kind === "array" && instancedBlock(type.id, types))
+        this.names.set(
+          type.id,
+          `ARRAY[${type.lowerBound}..${type.lowerBound + type.length - 1}] OF ${this.name(type.element)}`,
+        );
+
+    // Verified layouts are acyclic. Emit child DUTs first, then their containing DUT.
+    const emitted = new Set<string>();
+    const emit = (type: PlcType): void => {
+      if (instancedBlock(type.id, types) || !this.names.has(type.id) || emitted.has(type.id))
+        return;
+      if (type.kind === "array") emit(this.type(type.element));
+      if (type.kind === "record") {
+        for (const field of type.fields) emit(this.type(field.type));
+      }
+      emitted.add(type.id);
+      const name = this.name(type.id);
+      let declaration: string;
+      if (type.kind === "record") {
+        const fields = type.fields
+          .map((field) => `    ${this.field(type.id, field.name)} : ${this.name(field.type)};`)
+          .join("\n");
+        declaration = `TYPE ${name} :
+STRUCT
+${fields}
+END_STRUCT
+END_TYPE
+`;
+      } else if (type.kind === "array") {
+        declaration = `TYPE ${name} : ARRAY[${type.lowerBound}..${type.lowerBound + type.length - 1}] OF ${this.name(type.element)};
+END_TYPE
+`;
+      } else if (type.kind === "string") {
+        declaration = `TYPE ${name} : ${type.encoding === "utf8" ? "STRING" : "WSTRING"}(${type.capacity});
+END_TYPE
+`;
+      } else if (type.kind === "enum") {
+        const members = type.members
+          .map((member) => `    ${this.field(type.id, member.name)} := ${member.value}`)
+          .join(",\n");
+        declaration = `{attribute 'qualified_only'}
+{attribute 'strict'}
+TYPE ${name} : (
+${members}
+) DINT;
+END_TYPE
+`;
+      } else throw new Error("Unsupported verified data type");
+      this.objects.push({ id: type.id, kind: "dataType", name, declaration });
+    };
+    for (const type of types.values()) emit(type);
+  }
+
+  private type(id: string): PlcType {
+    const type = this.types.get(id);
+    if (!type) throw new Error("Missing verified type");
+    return type;
+  }
+
+  name(id: string): string {
+    return this.names.get(id) ?? id;
+  }
+
+  field(id: string, name: string): string {
+    const field = this.fields.get(id)?.get(name);
+    if (!field) throw new Error("Missing verified field");
+    return field;
+  }
+
+  declarationInitializer(value: Constant, id: string): string {
+    const type = this.type(id);
+    // Our DUT fields have no custom initializers. CODESYS initializes their
+    // numbers/BOOL/strings to zero/false/empty, including nested arrays/records.
+    // Keep explicit nonzero enum members and signed floating zero: omission must
+    // not change the initial value selected by PLC semantics.
+    if ((type.kind === "record" || type.kind === "array") && this.isZero(value)) return "";
+    return ` := ${this.literal(value, id)}`;
+  }
+
+  private isZero(value: Constant): boolean {
+    if (value.kind === "bool") return !value.value;
+    if (value.kind === "integer") return value.value === "0";
+    if (value.kind === "float") return Object.is(value.value, 0);
+    if (value.kind === "string") return value.value === "";
+    if (value.kind === "array") return value.items.every((item) => this.isZero(item));
+    if (value.kind === "record")
+      return Object.values(value.fields).every((item) => this.isZero(item));
+    // Time/calendar values remain explicit without relying on target defaults.
+    return false;
+  }
+
+  literal(value: Constant, id: string): string {
+    const type = this.type(id);
+    if (type.kind === "enum" && value.kind === "integer") {
+      const member = type.members.find((member) => member.value === value.value);
+      if (!member) throw new Error("Missing verified enum member");
+      return `${this.name(id)}.${this.field(id, member.name)}`;
+    }
+    if (type.kind === "string" && value.kind === "string") {
+      const wide = type.encoding === "utf16",
+        quote = wide ? '"' : "'";
+      let text = "";
+      for (const char of value.value) {
+        const code = char.charCodeAt(0);
+        if (char === "$") text += "$$";
+        else if (char === quote) text += `$${char}`;
+        else if (code < 32 || code === 127)
+          text += `$${code
+            .toString(16)
+            .toUpperCase()
+            .padStart(wide ? 4 : 2, "0")}`;
+        else text += char;
+      }
+      return `${quote}${text}${quote}`;
+    }
+    if (type.kind === "array" && value.kind === "array") {
+      return `[${value.items.map((item) => this.literal(item, type.element)).join(", ")}]`;
+    }
+    if (type.kind === "record" && value.kind === "record") {
+      const fields = type.fields.map((field) => {
+        const initial = value.fields[field.name];
+        if (!initial) throw new Error("Missing verified record initializer");
+        return `${this.field(id, field.name)} := ${this.literal(initial, field.type)}`;
+      });
+      return `(${fields.join(", ")})`;
+    }
+    if (type.kind === "duration" && value.kind === "duration") {
+      return `T#${BigInt(value.nanoseconds) / 1_000_000n}ms`;
+    }
+    if (type.kind === "calendar" && value.kind === "calendar") {
+      if (type.domain === "date") return `D#${value.value}`;
+      if (type.domain === "timeOfDay") return `TOD#${value.value}`;
+      return `DT#${value.value.replace("T", "-")}`;
+    }
+    return scalarLiteral(value, id);
+  }
+}

package/backends/codesys/vendor.ts

@@ -0,0 +1,108 @@
+import type { Diagnostic, EmitResult } from "@tsplc/compiler/ir";
+import { CodesysCompilerError } from "@tsplc/build";
+import type { SourceMapping } from "./emit.ts";
+
+type MappedBundle = Pick<EmitResult, "objects"> & { mappings: readonly SourceMapping[] };
+
+/** Map verified vendor locations; preserve raw context for everything else. */
+export function diagnoseCodesys(cause: unknown, bundle: MappedBundle): readonly Diagnostic[] {
+  const notes: string[] = [];
+  let current = cause;
+  while (current instanceof Error) {
+    if (current instanceof CodesysCompilerError && current.diagnostics.length) {
+      return current.diagnostics.map((item) => {
+        // Observed in CODESYS 3.5 SP22. position itself is an opaque vendor value.
+        const location =
+          item.positionText &&
+          /^Line ([1-9][0-9]*)(?:, Column ([1-9][0-9]*))? \((Decl|Impl)\)$/.exec(item.positionText);
+        const identity = item.object;
+        let objectPath: string | undefined;
+        if (identity && identity.path.at(-1) === identity.name) {
+          const relative = identity.applicationPath;
+          if (
+            Array.isArray(relative) &&
+            relative.length > 0 &&
+            relative.every((part) => typeof part === "string") &&
+            identity.isApplicationChild === (relative.length === 1) &&
+            identity.path.length > relative.length &&
+            identity.path.slice(-relative.length).every((part, index) => part === relative[index])
+          ) {
+            objectPath = relative.join("/");
+          } else if (
+            relative === undefined &&
+            identity.isApplicationChild === true &&
+            identity.path.length >= 2
+          ) {
+            // A verified immediate Application parent proves the root identity.
+            objectPath = identity.name;
+          }
+        }
+        const objects = objectPath
+          ? bundle.objects.flatMap((object) => {
+              const declaration =
+                object.sourcePath ??
+                (object.implementation === undefined
+                  ? `${object.name}.st`
+                  : `${object.name}/declaration.st`);
+              const nativePath = (
+                object.kind === "method"
+                  ? declaration.replace(/\/methods\/([^/]+\/declaration\.st)$/, "/$1")
+                  : declaration
+              ).replace(object.implementation === undefined ? /\.st$/ : /\/declaration\.st$/, "");
+              return object.name === identity?.name && nativePath === objectPath
+                ? [{ object, declaration }]
+                : [];
+            })
+          : [];
+        const match = objects.length === 1 ? objects[0] : undefined;
+        const section = location?.[3] === "Decl" ? "declaration" : "implementation";
+        const path =
+          section === "declaration"
+            ? match?.declaration
+            : match?.object.implementation !== undefined
+              ? match.declaration.replace(/declaration\.st$/, "implementation.st")
+              : undefined;
+        const mappings =
+          location && path
+            ? bundle.mappings.filter(
+                (mapping) => mapping.path === path && mapping.line === Number(location[1]),
+              )
+            : [];
+        const mapping = mappings.length === 1 ? mappings[0] : undefined;
+        return {
+          origin: "vendor",
+          code: "PLC8001",
+          severity: "error",
+          message: item.text,
+          ...(mapping && { span: mapping.span }),
+          notes: [
+            ...notes,
+            ...(location && path
+              ? [
+                  "Generated ST: " +
+                    path +
+                    ":" +
+                    location[1] +
+                    (location[2] ? `:${location[2]}` : ""),
+                ]
+              : []),
+            `CODESYS diagnostic: ${JSON.stringify(item)}`,
+          ],
+        };
+      });
+    }
+    notes.push(current.message);
+    if (current.cause === undefined) break;
+    current = current.cause;
+    if (!(current instanceof Error)) notes.push(String(current));
+  }
+  return [
+    {
+      origin: "vendor",
+      code: "PLC8001",
+      severity: "error",
+      message: cause instanceof Error ? cause.message : String(cause),
+      ...(notes.length > 1 && { notes: notes.slice(1) }),
+    },
+  ];
+}