@tsplc/compiler 0.0.0-stage → 0.1.0

package/ir/declarations.ts

@@ -0,0 +1,201 @@
+import type { SourceSpan } from "./diagnostics.ts";
+import {
+  standardBlocks,
+  type PlcModule,
+  type Variable,
+  type FunctionBlock,
+  type PlcFunction,
+} from "./model.ts";
+import { instancedBlock, type PlcType } from "./types.ts";
+import { layoutIssue, valueFits } from "./aggregates.ts";
+import { reject } from "./normalization-error.ts";
+
+// This index owns the module namespace and storage declarations. Routine
+// lowering may claim temporary identifiers, but cannot weaken admission rules.
+export class ModuleDeclarations {
+  private readonly ids = new Set<string>();
+  readonly types = new Map<string, PlcType>();
+  readonly globals = new Map<string, Variable>();
+  readonly blocks: Map<string, FunctionBlock>;
+  readonly signatures: Map<string, PlcFunction>;
+
+  constructor(module: PlcModule) {
+    for (const type of module.types) {
+      if (this.types.has(type.id)) reject(`Duplicate type ${type.id}.`);
+      this.types.set(type.id, type);
+    }
+    const invalidLayout = layoutIssue(this.types);
+    if (invalidLayout) reject(invalidLayout);
+    if (this.types.get("BOOL")?.kind !== "bool") reject("Missing canonical BOOL type.");
+
+    this.blocks = new Map(module.blocks.map((block) => [block.id, block]));
+    for (const item of module.variables) {
+      this.checkVariable(item, ["module", "instance", "input", "output", "constant"]);
+      this.globals.set(item.id, item);
+    }
+
+    this.signatures = new Map(module.functions.map((fn) => [fn.id, fn]));
+    for (const fn of module.functions) {
+      this.claimId(fn.id, fn.span);
+      if (
+        fn.owner &&
+        (!this.blocks.has(fn.owner.block) ||
+          this.blocks.get(fn.owner.block)?.standard ||
+          !["public", "private", "protected"].includes(fn.owner.access))
+      )
+        reject("Methods require a user block owner and a valid access modifier.", fn.span);
+      if (fn.result && !this.isValueType(fn.result))
+        reject("Unknown or non-value function result type.", fn.span);
+      for (const parameter of fn.parameters) {
+        this.checkVariable(parameter, ["parameter"], true);
+        if (parameter.mutable && !parameter.mode)
+          reject("Value parameters are readonly.", parameter.span);
+      }
+      for (const local of fn.locals) this.checkVariable(local, ["local"]);
+    }
+
+    for (const block of module.blocks) {
+      this.claimId(block.id, block.span);
+      for (const input of block.inputs) {
+        this.checkVariable(input, ["parameter"], true);
+        if (!input.mode && input.mutable) reject("Value block inputs are readonly.", input.span);
+      }
+      for (const output of block.outputs) this.checkVariable(output, ["blockOutput"]);
+      for (const state of block.state) this.checkVariable(state, ["field", "instance"]);
+      for (const local of block.locals) this.checkVariable(local, ["local"]);
+      for (const ports of [block.inputs, block.outputs]) {
+        if (new Set(ports.map((variable) => variable.name)).size !== ports.length)
+          reject(
+            "Block input and output names must each be unique within their schema.",
+            block.span,
+          );
+      }
+      const result = block.result ? this.types.get(block.result) : undefined;
+      if (
+        block.outputs.length
+          ? result?.kind !== "record" ||
+            !this.isValueType(result.id) ||
+            result.fields.length !== block.outputs.length ||
+            result.fields.some(
+              (field) =>
+                !block.outputs.some(
+                  (output) => output.name === field.name && output.type === field.type,
+                ),
+            )
+          : Boolean(block.result)
+      )
+        reject("Block output schema differs from its result record.", block.span);
+      if (block.standard) {
+        const expected = Object.hasOwn(standardBlocks, block.standard)
+          ? standardBlocks[block.standard]
+          : undefined;
+        const matches = (
+          variables: readonly Variable[],
+          schema: readonly (readonly [string, string, string])[],
+        ): boolean =>
+          variables.length === schema.length &&
+          schema.every(([name, , type]) =>
+            variables.some(
+              (variable) =>
+                variable.name === name &&
+                variable.type === type &&
+                !variable.mode &&
+                !variable.retain,
+            ),
+          );
+        if (
+          !expected ||
+          block.name !== block.standard ||
+          block.body.length ||
+          block.state.length ||
+          block.locals.length ||
+          !matches(block.inputs, expected.inputs) ||
+          !matches(block.outputs, expected.outputs) ||
+          block.outputs.some((output) =>
+            output.type === "BOOL"
+              ? output.initial?.kind !== "bool" || output.initial.value !== false
+              : output.initial?.kind !== "duration" || output.initial.nanoseconds !== "0",
+          )
+        )
+          reject("Invalid canonical standard block definition.", block.span);
+      }
+    }
+
+    for (const type of this.types.values())
+      if (type.kind === "block") {
+        const definition = this.blocks.get(type.block);
+        if (!definition || definition.result !== type.output)
+          reject("Block type differs from its definition.");
+      }
+  }
+
+  hasId(id: string): boolean {
+    return this.ids.has(id);
+  }
+
+  public claimId(id: string, span?: SourceSpan): void {
+    if (this.ids.has(id)) reject(`Duplicate symbol ${id}.`, span);
+    this.ids.add(id);
+  }
+
+  public isValueType(id: string, seen = new Set<string>()): boolean {
+    if (seen.has(id)) return true;
+    seen.add(id);
+    const type = this.types.get(id);
+    return Boolean(
+      type &&
+      type.kind !== "block" &&
+      (type.kind !== "record" ||
+        type.fields.every((field) => !field.mode && this.isValueType(field.type, seen))) &&
+      (type.kind !== "array" || this.isValueType(type.element, seen)),
+    );
+  }
+
+  private checkVariable(
+    item: Variable,
+    storage: readonly Variable["storage"][],
+    allowBorrow = false,
+  ): void {
+    this.claimId(item.id, item.span);
+    const type = this.types.get(item.type);
+    if (!type || !storage.includes(item.storage))
+      reject("Invalid storage type or class.", item.span);
+    if (
+      item.mode &&
+      (item.mode !== "inOut" || !allowBorrow || !item.mutable || item.storage !== "parameter")
+    )
+      reject("InOut belongs only on mutable parameters.", item.span);
+    const mutableState =
+      item.mutable ||
+      type.kind === "array" ||
+      (type.kind === "record" && type.fields.some((field) => !field.readonly));
+    if (
+      item.retain &&
+      !(item.storage === "instance" || (["module", "field"].includes(item.storage) && mutableState))
+    )
+      reject("Only mutable static state or block instances may retain.", item.span);
+    if (item.storage === "instance") {
+      const instanced = instancedBlock(item.type, this.types);
+      if (!instanced || !this.blocks.has(instanced.block) || item.initial || item.mode)
+        reject(
+          "Instances require a known static block and cannot have value initializers.",
+          item.span,
+        );
+    } else if (
+      !this.isValueType(item.type) &&
+      !(allowBorrow && item.mode === "inOut" && type.kind === "block")
+    )
+      reject("Block instances and reference schemas cannot be stored as values.", item.span);
+    if (item.storage === "parameter" && item.initial)
+      reject(
+        "Inputs are supplied at each invocation and cannot have stored initializers.",
+        item.span,
+      );
+    if (item.initial && !valueFits(item.initial, type, this.types))
+      reject("Initializer has the wrong type or is out of range.", item.span);
+    if (["module", "field", "constant", "blockOutput"].includes(item.storage) && !item.initial)
+      reject("Persistent storage requires initialization.", item.span);
+    if (["input", "constant", "blockOutput"].includes(item.storage) && item.mutable)
+      reject("Readonly storage marked mutable.", item.span);
+  }
+}

package/ir/diagnostics.ts

@@ -0,0 +1,43 @@
+export interface SourceSpan {
+  file: string;
+  start: number;
+  end: number;
+  line: number;
+  column: number;
+}
+
+export interface Diagnostic {
+  origin: "typescript" | "plc" | "config" | "backend" | "vendor";
+  code: string;
+  severity: "error" | "warning";
+  message: string;
+  span?: SourceSpan;
+  notes?: readonly string[];
+  related?: readonly { span: SourceSpan; message: string }[];
+}
+
+export function error(code: string, message: string, span?: SourceSpan): Diagnostic {
+  return { origin: "plc", code, severity: "error", message, ...(span && { span }) };
+}
+
+export function hasErrors(diagnostics: readonly Diagnostic[]): boolean {
+  return diagnostics.some((diagnostic) => diagnostic.severity === "error");
+}
+
+export function formatDiagnostic(diagnostic: Diagnostic, source?: string): string {
+  const { span } = diagnostic;
+  const location = span ? `${span.file}:${span.line}:${span.column}: ` : "";
+  let result = `${location}${diagnostic.code}: ${diagnostic.message}`;
+  if (source !== undefined && span) {
+    const line = source.split(/\r?\n/)[span.line - 1];
+    if (line !== undefined) {
+      const width = Math.max(1, Math.min(span.end - span.start, line.length - span.column + 2));
+      result += `\n${span.line} | ${line}\n${" ".repeat(String(span.line).length + 3 + span.column - 1)}${"^".repeat(width)}`;
+    }
+  }
+  for (const related of diagnostic.related ?? []) {
+    result += `\n  ${related.span.file}:${related.span.line}:${related.span.column}: ${related.message}`;
+  }
+  for (const note of diagnostic.notes ?? []) result += `\n  ${note}`;
+  return result;
+}

package/ir/domains.ts

@@ -0,0 +1,96 @@
+import { comparisonOperators, type Constant, type Expression } from "./model.ts";
+import type { PlcType } from "./types.ts";
+
+export function durationLiteral(text: string, scaleNanoseconds: bigint): Constant | undefined {
+  const clean = text.replaceAll("_", "").replace(/^(-?)\./, (_, sign: string) => `${sign}0.`);
+  const match = /^(-?)(\d+)(?:\.(\d*))?(?:e([+-]?\d+))?$/i.exec(clean);
+  if (!match) return undefined;
+  const fraction = match[3] ?? "",
+    exponent = Number(match[4] ?? 0) - fraction.length;
+  if (!Number.isSafeInteger(exponent) || Math.abs(exponent) > 400) return undefined;
+  let value = BigInt(match[2]! + fraction) * scaleNanoseconds;
+  if (exponent >= 0) value *= 10n ** BigInt(exponent);
+  else {
+    const divisor = 10n ** BigInt(-exponent);
+    if (value % divisor) return undefined;
+    value /= divisor;
+  }
+  if (match[1]) value = -value;
+  return validDuration(value) ? { kind: "duration", nanoseconds: String(value) } : undefined;
+}
+// TIME stores unsigned 32-bit milliseconds.
+function validDuration(nanoseconds: bigint): boolean {
+  return (
+    nanoseconds >= 0n && nanoseconds <= 4_294_967_295_000_000n && nanoseconds % 1_000_000n === 0n
+  );
+}
+function validDate(text: string): boolean {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(text);
+  if (!match) return false;
+  const year = Number(match[1]),
+    month = Number(match[2]),
+    day = Number(match[3]);
+  const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+  const length = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month - 1];
+  return Boolean(
+    length && day >= 1 && day <= length && text >= "1970-01-01" && text <= "2106-02-07",
+  );
+}
+function validClock(text: string, milliseconds: boolean): boolean {
+  const match = (
+    milliseconds ? /^(\d{2}):(\d{2}):(\d{2})\.(\d{3})$/ : /^(\d{2}):(\d{2}):(\d{2})$/
+  ).exec(text);
+  return Boolean(match && Number(match[1]) < 24 && Number(match[2]) < 60 && Number(match[3]) < 60);
+}
+export function calendarLiteral(
+  domain: Extract<PlcType, { kind: "calendar" }>["domain"],
+  text: string,
+): Constant | undefined {
+  if (domain === "date") return validDate(text) ? { kind: "calendar", value: text } : undefined;
+  if (domain === "timeOfDay") {
+    const canonical = /^\d{2}:\d{2}:\d{2}$/.test(text) ? `${text}.000` : text;
+    return validClock(canonical, true) ? { kind: "calendar", value: canonical } : undefined;
+  }
+  return text.length === 19 &&
+    text[10] === "T" &&
+    validDate(text.slice(0, 10)) &&
+    validClock(text.slice(11), false) &&
+    text <= "2106-02-07T06:28:15"
+    ? { kind: "calendar", value: text }
+    : undefined;
+}
+export function domainConstantFits(value: Constant, type: PlcType): boolean {
+  if (type.kind === "duration")
+    return (
+      value.kind === "duration" &&
+      /^(?:0|[1-9][0-9]*)$/.test(value.nanoseconds) &&
+      validDuration(BigInt(value.nanoseconds))
+    );
+  if (type.kind === "calendar" && value.kind === "calendar") {
+    const parsed = calendarLiteral(type.domain, value.value);
+    return parsed?.kind === "calendar" && parsed.value === value.value;
+  }
+  return false;
+}
+export function domainIssue(
+  value: Expression,
+  types: ReadonlyMap<string, PlcType>,
+): string | undefined {
+  const type = types.get(value.type);
+  if (value.kind === "constant")
+    return type && domainConstantFits(value.value, type)
+      ? undefined
+      : "Invalid TIME/calendar constant.";
+  if (value.kind === "load" || value.kind === "call" || value.kind === "conditional")
+    return undefined;
+  if (value.kind === "binary" && comparisonOperators.has(value.operator)) {
+    const left = types.get(value.left.type);
+    return value.type === "BOOL" &&
+      left &&
+      ["duration", "calendar"].includes(left.kind) &&
+      value.left.type === value.right.type
+      ? undefined
+      : "Time comparisons require matching domains.";
+  }
+  return "TIME and calendar domains permit storage, typed copies and comparisons; implicit numeric arithmetic is unsupported.";
+}

package/ir/index.ts

@@ -0,0 +1,7 @@
+export * from "./diagnostics.ts";
+export * from "./types.ts";
+export * from "./model.ts";
+export * from "./core.ts";
+export * from "./scalars.ts";
+export * from "./aggregates.ts";
+export * from "./domains.ts";

package/ir/link.ts

@@ -0,0 +1,176 @@
+import type { PlcModule } from "./model.ts";
+import type { CoreFunction, CoreFunctionBlock, CoreStatement } from "./core-model.ts";
+import type { ModuleDeclarations } from "./declarations.ts";
+import { reject } from "./normalization-error.ts";
+import { instancedBlock } from "./types.ts";
+
+// Validate the complete authored call graph before pruning unreachable code.
+// Static instances keep their child layouts even when a child has no scan call.
+export function linkModule(
+  module: PlcModule,
+  declarations: ModuleDeclarations,
+  functions: CoreFunction[],
+  normalizedBlocks: CoreFunctionBlock[],
+  edges: ReadonlyMap<string, ReadonlySet<string>>,
+) {
+  const { signatures, blocks, types } = declarations;
+  const names = new Set<string>(),
+    entries = new Set<string>();
+  for (const program of module.programs) {
+    declarations.claimId(program.id);
+    const entry = signatures.get(program.entry);
+    if (!entry || entry.owner || entry.parameters.length || entry.result)
+      reject("Program entry must be a parameterless void helper.");
+    if (names.has(program.name)) reject(`Duplicate program ${program.name}.`);
+    names.add(program.name);
+    entries.add(program.entry);
+  }
+  if (!module.programs.length) reject("At least one program is required.");
+
+  // Authored execution cycles are invalid even in unreachable routines. Static
+  // allocation has its own cycle check because it does not depend on scan calls.
+  const visited = new Set<string>(),
+    active = new Set<string>();
+  const visit = (id: string): void => {
+    if (active.has(id)) reject("Recursive scan calls are prohibited.", signatures.get(id)?.span);
+    if (visited.has(id)) return;
+    active.add(id);
+    for (const child of edges.get(id) ?? []) {
+      if (entries.has(child))
+        reject("Program entries cannot be called as ordinary helpers.", signatures.get(id)?.span);
+      visit(child);
+    }
+    active.delete(id);
+    visited.add(id);
+  };
+  for (const fn of [...functions, ...normalizedBlocks]) visit(fn.id);
+
+  // A bounded loop can only reconstruct its counter if called helpers leave
+  // that storage alone. Include transitive calls, not just direct assignments.
+  const routines = new Map([...functions, ...normalizedBlocks].map((fn) => [fn.id, fn]));
+  const variables = new Map(
+    [
+      ...module.variables,
+      ...functions.flatMap((fn) => [...fn.parameters, ...fn.locals]),
+      ...normalizedBlocks.flatMap((block) => [
+        ...block.inputs,
+        ...block.outputs,
+        ...block.state,
+        ...block.locals,
+      ]),
+    ].map((variable) => [variable.id, variable]),
+  );
+  const calledRoutine = (item: CoreStatement): string | undefined => {
+    if (item.kind === "invoke") return item.function;
+    if (item.kind !== "blockUpdate") return undefined;
+    const variable = variables.get(item.instance);
+    return variable && instancedBlock(variable.type, types)?.block;
+  };
+  const nestedBodies = (item: CoreStatement): readonly (readonly CoreStatement[])[] => {
+    if (item.kind === "for") return [item.body];
+    if (item.kind === "if") return [item.then, item.else];
+    if (item.kind === "switch") return [...item.cases.map((branch) => branch.body), item.fallback];
+    return [];
+  };
+  const writes = new Map<string, Set<string>>();
+  const routineWrites = (id: string): Set<string> => {
+    const cached = writes.get(id);
+    if (cached) return cached;
+    const result = new Set<string>();
+    const inspect = (body: readonly CoreStatement[]) => {
+      for (const item of body) {
+        if (item.kind === "assign") result.add(item.root);
+        if (item.kind === "for") result.add(item.counter);
+        if (item.kind === "invoke") {
+          if (item.destination) result.add(item.destination);
+          for (const argument of item.arguments)
+            if (argument.kind === "borrow") result.add(argument.place.root);
+        }
+        if (item.kind === "blockUpdate")
+          for (const input of Object.values(item.inputs))
+            if (input.kind === "borrow") result.add(input.place.root);
+        for (const nested of nestedBodies(item)) inspect(nested);
+      }
+    };
+    inspect(routines.get(id)!.body);
+    for (const child of edges.get(id) ?? [])
+      for (const root of routineWrites(child)) result.add(root);
+    writes.set(id, result);
+    return result;
+  };
+  const checkCalls = (body: readonly CoreStatement[], counters: ReadonlySet<string>) => {
+    for (const item of body) {
+      const called = calledRoutine(item);
+      if (called && [...counters].some((counter) => routineWrites(called).has(counter)))
+        reject("A called routine may mutate an active loop counter.", item.span);
+      const nestedCounters = item.kind === "for" ? new Set([...counters, item.counter]) : counters;
+      for (const nested of nestedBodies(item)) checkCalls(nested, nestedCounters);
+    }
+  };
+  for (const routine of routines.values()) checkCalls(routine.body, new Set());
+
+  // Only after the complete graph is valid may emission discard unused helpers.
+  const reachable = new Set<string>();
+  const link = (id: string): void => {
+    if (reachable.has(id)) return;
+    reachable.add(id);
+    for (const child of edges.get(id) ?? []) link(child);
+    const owner = signatures.get(id)?.owner;
+    if (owner) link(owner.block);
+    for (const method of functions.filter((fn) => fn.owner?.block === id)) link(method.id);
+    for (const instance of blocks
+      .get(id)
+      ?.state.filter((variable) => variable.storage === "instance") ?? []) {
+      const type = instancedBlock(instance.type, types);
+      if (type) link(type.block);
+    }
+  };
+  for (const entry of entries) link(entry);
+  for (const variable of module.variables) {
+    const type = instancedBlock(variable.type, types);
+    if (type) link(type.block);
+  }
+  const linkedFunctions = functions.filter((fn) => reachable.has(fn.id)),
+    linkedBlocks = normalizedBlocks.filter((block) => reachable.has(block.id));
+
+  // Admission has already validated every referenced type; these lookups are
+  // closed over the declaration registry, including dependencies kept by DUTs.
+  const usedTypes = new Set<string>();
+  const useType = (id: string): void => {
+    if (usedTypes.has(id)) return;
+    usedTypes.add(id);
+    const type = types.get(id)!;
+    if (type.kind === "record") {
+      for (const field of type.fields) useType(field.type);
+    }
+    if (type.kind === "array") {
+      useType(type.element);
+      if (type.index) useType(type.index);
+    }
+    if (type.kind === "enum") useType(type.base);
+    if (type.kind === "block" && type.output) useType(type.output);
+  };
+  // Primitive definitions also support backend-generated numeric helpers.
+  types.forEach((type) => {
+    if (["bool", "integer", "bits", "float", "duration", "calendar"].includes(type.kind))
+      useType(type.id);
+  });
+  for (const variable of module.variables) useType(variable.type);
+  for (const fn of linkedFunctions) {
+    if (fn.result) useType(fn.result);
+    for (const variable of [...fn.parameters, ...fn.locals]) useType(variable.type);
+  }
+  for (const block of linkedBlocks) {
+    if (block.result) useType(block.result);
+    for (const variable of [...block.inputs, ...block.outputs, ...block.state, ...block.locals]) {
+      useType(variable.type);
+    }
+  }
+  return {
+    types: module.types.filter((type) => usedTypes.has(type.id)),
+    variables: module.variables,
+    functions: linkedFunctions,
+    blocks: linkedBlocks,
+    programs: module.programs,
+  };
+}