@tsplc/compiler 0.0.0-stage → 0.2.0

package/ir/model.ts

@@ -0,0 +1,268 @@
+import type { SourceSpan, Diagnostic } from "./diagnostics.ts";
+import type { PlcType, SymbolId, TypeId } from "./types.ts";
+
+export type Constant =
+  | { kind: "bool"; value: boolean }
+  | { kind: "integer"; value: string }
+  | { kind: "float"; value: number }
+  | { kind: "duration"; nanoseconds: string }
+  | { kind: "calendar"; value: string }
+  | { kind: "string"; value: string }
+  | { kind: "array"; items: readonly Constant[] }
+  | { kind: "record"; fields: Readonly<Record<string, Constant>> };
+
+export interface Variable {
+  id: SymbolId;
+  name: string;
+  type: TypeId;
+  storage:
+    | "module"
+    | "local"
+    | "parameter"
+    | "input"
+    | "output"
+    | "field"
+    | "instance"
+    | "constant"
+    | "blockOutput";
+  mutable: boolean;
+  retain: boolean;
+  exported?: true;
+  exposure?: { name: string; version: string };
+  mode?: "inOut";
+  initial?: Constant;
+  span: SourceSpan;
+}
+
+export interface Place {
+  root: SymbolId;
+  path: readonly ({ kind: "field"; name: string } | { kind: "index"; value: Expression })[];
+}
+
+export type BinaryOperator =
+  | "add"
+  | "subtract"
+  | "multiply"
+  | "divide"
+  | "remainder"
+  | "equal"
+  | "notEqual"
+  | "less"
+  | "lessEqual"
+  | "greater"
+  | "greaterEqual"
+  | "and"
+  | "or"
+  | "bitAnd"
+  | "bitOr"
+  | "bitXor"
+  | "shiftLeft"
+  | "shiftRight";
+
+export const comparisonOperators: ReadonlySet<BinaryOperator> = new Set([
+  "equal",
+  "notEqual",
+  "less",
+  "lessEqual",
+  "greater",
+  "greaterEqual",
+]);
+
+export type Expression = { type: TypeId; span: SourceSpan } & (
+  | { kind: "constant"; value: Constant }
+  | { kind: "load"; place: Place }
+  | {
+      kind: "unary";
+      operator: "not" | "negate" | "bitNot" | "timeToMilliseconds" | "clock";
+      operand: Expression;
+    }
+  | {
+      kind: "binary";
+      operator: BinaryOperator;
+      left: Expression;
+      right: Expression;
+      policy?: "wrap" | "saturate";
+    }
+  | {
+      kind: "call";
+      function: SymbolId;
+      instance?: SymbolId;
+      index?: Expression;
+      arguments: readonly Expression[];
+    }
+  | { kind: "conditional"; condition: Expression; then: Expression; else: Expression }
+  | { kind: "convert"; operand: Expression; policy: "exact" | "wrap" | "saturate" }
+  | { kind: "borrow"; place: Place }
+  | { kind: "length"; operand: Expression }
+  | { kind: "copy"; operand: Expression }
+  | { kind: "record"; fields: Readonly<Record<string, Expression>> }
+  | { kind: "array"; items: readonly Expression[] }
+);
+
+export type Statement = { span: SourceSpan } & (
+  | { kind: "assign"; destination: Place; value: Expression }
+  | { kind: "if"; condition: Expression; then: readonly Statement[]; else: readonly Statement[] }
+  | {
+      kind: "switch";
+      value: Expression;
+      cases: readonly { values: readonly Constant[]; body: readonly Statement[] }[];
+      fallback: readonly Statement[];
+    }
+  | {
+      kind: "for";
+      counter: SymbolId;
+      /** Existing storage remains observable after the loop exits. */
+      counterScope?: "existing";
+      start: Expression;
+      limit: Expression;
+      step: string;
+      exclusive?: true;
+      maxIterations: number;
+      body: readonly Statement[];
+    }
+  | {
+      kind: "invoke";
+      function: SymbolId;
+      instance?: SymbolId;
+      index?: Expression;
+      arguments: readonly Expression[];
+      destination?: Place;
+    }
+  | {
+      kind: "blockUpdate";
+      instance: SymbolId;
+      index?: Expression;
+      inputs: Readonly<Record<string, Expression>>;
+    }
+  | { kind: "return"; value?: Expression }
+  | { kind: "break" | "continue" }
+);
+
+export interface MethodOwner {
+  block: SymbolId;
+  access: "public" | "private" | "protected";
+}
+
+export interface PlcFunction {
+  owner?: MethodOwner;
+  id: SymbolId;
+  name: string;
+  parameters: readonly Variable[];
+  locals: readonly Variable[];
+  result?: TypeId;
+  /** A `@tsplc/compiler/math` helper, whose result range follows from its arguments' ranges. */
+  bounds?: MathHelper;
+  body: readonly Statement[];
+  span: SourceSpan;
+}
+export type MathHelper = "min" | "max" | "clamp";
+
+// Native vendor blocks under their TypeScript names. Ports are [name, native name, type];
+// every output starts FALSE or T#0s, matching the vendor library blocks.
+const timer = (input: string, output: string) =>
+  ({
+    inputs: [
+      [input, "IN", "BOOL"],
+      ["duration", "PT", "TIME"],
+    ],
+    outputs: [
+      [output, "Q", "BOOL"],
+      ["elapsed", "ET", "TIME"],
+    ],
+  }) as const;
+export const standardBlocks = {
+  OnDelayTimer: { native: "TON", ...timer("enabled", "done") },
+  OffDelayTimer: { native: "TOF", ...timer("enabled", "active") },
+  PulseTimer: { native: "TP", ...timer("start", "active") },
+  RisingEdge: {
+    native: "R_TRIG",
+    inputs: [["signal", "CLK", "BOOL"]],
+    outputs: [["rose", "Q", "BOOL"]],
+  },
+  FallingEdge: {
+    native: "F_TRIG",
+    inputs: [["signal", "CLK", "BOOL"]],
+    outputs: [["fell", "Q", "BOOL"]],
+  },
+  Blinker: {
+    native: "Util.BLINK",
+    inputs: [
+      ["enabled", "ENABLE", "BOOL"],
+      ["offTime", "TIMELOW", "TIME"],
+      ["onTime", "TIMEHIGH", "TIME"],
+    ],
+    outputs: [["on", "OUT", "BOOL"]],
+  },
+} as const;
+export type StandardBlock = keyof typeof standardBlocks;
+
+export interface FunctionBlock {
+  id: SymbolId;
+  name: string;
+  inputs: readonly Variable[];
+  outputs: readonly Variable[];
+  state: readonly Variable[];
+  locals: readonly Variable[];
+  body: readonly Statement[];
+  result?: TypeId;
+  standard?: StandardBlock;
+  runtime?:
+    | { kind: "mailbox" }
+    | { kind: "backgroundHost" }
+    | { kind: "rpc"; path: string }
+    | {
+        kind: "http";
+        url: string;
+        method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+        json: boolean;
+      };
+  span: SourceSpan;
+}
+
+export interface PlcProgram {
+  id: SymbolId;
+  name: string;
+  entry: SymbolId;
+  continuation?: { instance: string; file: string };
+  background?: { intervalNanoseconds: string; priority: number; mailbox: string; worker: string };
+}
+
+export interface PlcModule {
+  types: readonly PlcType[];
+  variables: readonly Variable[];
+  functions: readonly PlcFunction[];
+  blocks: readonly FunctionBlock[];
+  programs: readonly PlcProgram[];
+}
+
+export interface Task {
+  name: string;
+  intervalNanoseconds: string;
+  priority: number;
+  programs: readonly string[];
+}
+
+export interface Deployment {
+  tasks: readonly Task[];
+}
+
+export interface Artifact {
+  path: string;
+  content: string;
+}
+
+export interface GeneratedObject {
+  parent?: SymbolId;
+  sourcePath?: string;
+  id: SymbolId;
+  kind: "program" | "function" | "functionBlock" | "method" | "globalList" | "dataType";
+  name: string;
+  declaration: string;
+  implementation?: string;
+}
+
+export interface EmitResult {
+  artifacts: readonly Artifact[];
+  objects: readonly GeneratedObject[];
+  diagnostics: readonly Diagnostic[];
+}

package/ir/normalization-error.ts

@@ -0,0 +1,10 @@
+import { error, type Diagnostic, type SourceSpan } from "./diagnostics.ts";
+
+export class InvalidCore extends Error {
+  constructor(readonly diagnostic: Diagnostic) {
+    super(diagnostic.message);
+  }
+}
+export function reject(message: string, span?: SourceSpan): never {
+  throw new InvalidCore(error("PLC6001", message, span));
+}