@tsplc/compiler 0.0.0-stage → 0.2.0

package/src/frontend/types.ts

@@ -0,0 +1,578 @@
+import ts from "typescript";
+import { dirname, relative, resolve } from "node:path";
+import {
+  instancedBlock,
+  primitiveTypes,
+  parseInteger,
+  type PlcType,
+  type Field,
+  type MathHelper,
+} from "@tsplc/compiler/ir";
+
+export interface ResolvedType {
+  type: string;
+  io?: "input" | "output";
+  mode?: "inOut";
+}
+export type TypeArgument =
+  { kind: "type"; value: ResolvedType } | { kind: "integer"; value: number };
+export type TypeEnvironment = ReadonlyMap<ts.Symbol, TypeArgument>;
+export type Fail = (node: ts.Node, code: string, message: string) => never;
+
+// The PLC type of an unannotated numeric literal: `number` means DINT unless it is fractional.
+export const numericLiteralType = (text: string) =>
+  text.endsWith("n") ? "LINT" : /[.e]/i.test(text) && !/^[-]?0[xob]/i.test(text) ? "LREAL" : "DINT";
+
+// The statically named callee of `name(...)` or `namespace.name(...)`.
+export function calleeName(node: ts.Expression): ts.MemberName | undefined {
+  if (ts.isIdentifier(node)) return node;
+  return ts.isPropertyAccessExpression(node) ? node.name : undefined;
+}
+
+// This is the sole owner of TypeScript annotation substitution and PLC layouts.
+// The checker resolves declarations; it never supplies erased numeric widths.
+// Service records are the exception: `iec.*` schemas carry their widths as literal types.
+export class TypeResolver {
+  readonly types = new Map<string, PlcType>(primitiveTypes.map((type) => [type.id, type]));
+  readonly blockTypes = new Map<ts.Symbol, string>();
+  readonly standardTypes = new Map<string, string>();
+  readonly unions = new Set<string>();
+  private readonly active = new Set<string>();
+  constructor(
+    private readonly checker: ts.TypeChecker,
+    private readonly root: string,
+    private readonly sdk: string,
+    private readonly fail: Fail,
+    /** The service client's struct for a type naming a called procedure's record. */
+    private readonly serviceRecord?: (type: ts.Type) => ts.Symbol | undefined,
+  ) {}
+  symbol(node: ts.Node): ts.Symbol {
+    // An object shorthand has a property symbol and a separate value binding.
+    // PLC loads and intrinsic provenance must follow the value, including imports.
+    let symbol =
+      ts.isShorthandPropertyAssignment(node.parent) && node.parent.name === node
+        ? this.checker.getShorthandAssignmentValueSymbol(node.parent)
+        : this.checker.getSymbolAtLocation(node);
+    if (!symbol) this.fail(node, "PLC1002", "This name has no PLC declaration.");
+    while (symbol.flags & ts.SymbolFlags.Alias) symbol = this.checker.getAliasedSymbol(symbol);
+    return symbol;
+  }
+
+  /** Declared by TypeScript's default library, such as `Record` or `Object`. */
+  standardLibrary(symbol: ts.Symbol): boolean {
+    return Boolean(
+      symbol.declarations?.every(
+        (declaration) =>
+          dirname(declaration.getSourceFile().fileName) === dirname(ts.getDefaultLibFilePath({})),
+      ),
+    );
+  }
+
+  sdkName(node: ts.Node): string | undefined {
+    const symbol = this.symbol(node);
+    return symbol.declarations?.some((declaration) =>
+      declaration.getSourceFile().fileName.startsWith(`${dirname(this.sdk)}/`),
+    )
+      ? symbol.getName()
+      : undefined;
+  }
+
+  /** `min`, `max` or `clamp` from the SDK's `@tsplc/compiler/math`. */
+  mathHelper(node: ts.Node, name: string): MathHelper | undefined {
+    return resolve(node.getSourceFile().fileName) ===
+      resolve(dirname(this.sdk), "../stdlib/math.ts") &&
+      (name === "min" || name === "max" || name === "clamp")
+      ? name
+      : undefined;
+  }
+
+  id(node: ts.Node, name: string): string {
+    return `${relative(this.root, node.getSourceFile().fileName).replaceAll("\\", "/")}:${node.getStart()}:${name}`;
+  }
+
+  argument(node: ts.TypeNode, environment: TypeEnvironment): TypeArgument {
+    if (ts.isTypeReferenceNode(node)) {
+      const bound = environment.get(this.symbol(node.typeName));
+      if (bound && !node.typeArguments?.length) return bound;
+    }
+    // `(typeof table)["length"]` or `typeof table.length` has the literal type of an `as const` table.
+    const queried =
+      ts.isIndexedAccessTypeNode(node) || ts.isTypeQueryNode(node)
+        ? this.checker.getTypeFromTypeNode(node)
+        : undefined;
+    const text = queried?.isNumberLiteral()
+      ? String(queried.value)
+      : ts.isLiteralTypeNode(node) &&
+          (ts.isNumericLiteral(node.literal) || ts.isPrefixUnaryExpression(node.literal))
+        ? node.literal.getText()
+        : undefined;
+    if (text !== undefined) {
+      let value: bigint;
+      try {
+        value = parseInteger(text);
+      } catch {
+        this.fail(node, "PLC2001", "Layout arguments must be exact integer literals.");
+      }
+      if (value < -2147483648n || value > 2147483647n)
+        this.fail(node, "PLC2001", "Layout argument is outside signed DINT range.");
+      return { kind: "integer", value: Number(value) };
+    }
+    return { kind: "type", value: this.resolve(node, environment) };
+  }
+
+  bindings(
+    parameters: readonly ts.TypeParameterDeclaration[] | undefined,
+    arguments_: readonly ts.TypeNode[] | undefined,
+    outer: TypeEnvironment,
+    node: ts.Node,
+  ): Map<ts.Symbol, TypeArgument> {
+    const result = new Map(outer),
+      params = parameters ?? [],
+      args = arguments_ ?? [];
+    if (args.length > params.length)
+      this.fail(node, "PLC2001", "Too many concrete type arguments.");
+    params.forEach((parameter, index) => {
+      const argument = args[index] ?? parameter.default;
+      if (!argument)
+        this.fail(
+          node,
+          "PLC2001",
+          "Generic PLC declarations require explicit concrete type arguments.",
+        );
+      result.set(this.symbol(parameter.name), this.argument(argument, result));
+    });
+    return result;
+  }
+
+  resolve(node: ts.TypeNode, environment: TypeEnvironment = new Map()): ResolvedType {
+    if (node.kind === ts.SyntaxKind.BooleanKeyword) return { type: "BOOL" };
+    if (node.kind === ts.SyntaxKind.NumberKeyword) return { type: "DINT" };
+    if (node.kind === ts.SyntaxKind.StringKeyword) {
+      const id = "STRING<80>";
+      this.types.set(id, { id, kind: "string", capacity: 80, encoding: "utf8" });
+      return { type: id };
+    }
+    if (ts.isParenthesizedTypeNode(node)) return this.resolve(node.type, environment);
+    if (ts.isTypeLiteralNode(node)) {
+      // Environment keys are admitted, declared type parameters with concrete bindings.
+      const arguments_ = [...environment]
+        .map(
+          ([symbol, value]) =>
+            `${this.id(symbol.declarations![0]!, symbol.name)}=${this.key(value)}`,
+        )
+        .sort()
+        .join(",");
+      return this.record(
+        node,
+        `${this.id(node, "record")}${arguments_ ? `<${arguments_}>` : ""}`,
+        node.members,
+        environment,
+      );
+    }
+    if (ts.isUnionTypeNode(node)) return this.union(node, this.id(node, "Union"), environment);
+    if (ts.isIndexedAccessTypeNode(node)) {
+      const record = this.serviceRecord?.(this.checker.getTypeFromTypeNode(node));
+      if (record) return this.declaration(record, undefined, environment, node);
+    }
+    if (!ts.isTypeReferenceNode(node))
+      this.fail(
+        node,
+        "PLC2001",
+        "Use an explicit supported PLC type; optional and dynamic layouts are unsupported.",
+      );
+    const symbol = this.symbol(node.typeName),
+      bound = environment.get(symbol);
+    if (bound) {
+      if (bound.kind !== "type" || node.typeArguments?.length)
+        this.fail(node, "PLC2001", "An integer layout argument is not a storage type.");
+      return bound.value;
+    }
+    const official = this.sdkName(node.typeName);
+    const block =
+      this.blockTypes.get(symbol) ?? (official ? this.standardTypes.get(official) : undefined);
+    if (block) {
+      if (node.typeArguments?.length)
+        this.fail(
+          node,
+          "PLC2001",
+          "Function block classes are concrete and take no type arguments.",
+        );
+      return { type: block };
+    }
+    if (official === "InOut") {
+      if (node.typeArguments?.length !== 1)
+        this.fail(node, "PLC2001", "InOut requires one concrete value type.");
+      const inner = this.resolve(node.typeArguments[0]!, environment);
+      if (inner.io || !this.isValue(inner))
+        this.fail(node, "PLC2001", "InOut cannot nest or borrow a block instance.");
+      return { type: inner.type, mode: "inOut" };
+    }
+    if (official && this.types.has(official)) {
+      if (node.typeArguments?.length)
+        this.fail(node, "PLC2001", "Scalar types take no type arguments.");
+      return { type: official };
+    }
+    if (official === "Input" || official === "Output") {
+      if (node.typeArguments?.length !== 1)
+        this.fail(node, "PLC2001", "I/O types need exactly one PLC type argument.");
+      const inner = this.resolve(node.typeArguments[0]!, environment);
+      if (inner.io || inner.mode || this.hasReferences(inner.type))
+        this.fail(node, "PLC2001", "I/O type wrappers cannot be nested.");
+      return { type: inner.type, io: official === "Input" ? "input" : "output" };
+    }
+    if (official === "FixedArray") {
+      const args = node.typeArguments;
+      if (!args || args.length < 2 || args.length > 3)
+        this.fail(node, "PLC2001", "FixedArray needs element, length and optional lower bound.");
+      return this.fixedArray(
+        node,
+        this.resolve(args[0]!, environment),
+        this.argument(args[1]!, environment),
+        args[2] ? this.argument(args[2], environment) : { kind: "integer", value: 0 },
+      );
+    }
+    // TypeScript's own `Record`; its keys are a contiguous enum.
+    if (symbol.name === "Record" && this.standardLibrary(symbol)) {
+      const [key, value] = node.typeArguments ?? [];
+      const index =
+        key && ts.isTypeReferenceNode(key)
+          ? this.types.get(this.resolve(key, environment).type)
+          : undefined;
+      if (index?.kind !== "enum")
+        this.fail(
+          node,
+          "PLC2001",
+          "Record keys must be a numeric PLC enum; dynamic index signatures are unsupported.",
+        );
+      const values = index.members.map((member) => Number(member.value));
+      const lower = Math.min(...values);
+      if (Math.max(...values) - lower + 1 !== values.length)
+        this.fail(node, "PLC2001", "Record<Enum, T> needs enum member values without gaps.");
+      const element = this.resolve(value!, environment);
+      if (element.io || !this.isValue(element))
+        this.fail(node, "PLC2001", "Enum-keyed records need a plain value element.");
+      const id = `array<${element.type},${values.length},${lower},${index.id}>`;
+      this.types.set(id, {
+        id,
+        kind: "array",
+        element: element.type,
+        length: values.length,
+        lowerBound: lower,
+        index: index.id,
+      });
+      this.checkSize(id, node);
+      return { type: id };
+    }
+    if (official === "STRING" || official === "WSTRING") {
+      if (node.typeArguments?.length !== 1)
+        this.fail(node, "PLC2001", "Bounded strings require one capacity argument.");
+      const capacity = this.argument(node.typeArguments[0]!, environment);
+      if (capacity.kind !== "integer" || capacity.value < 1 || capacity.value > 65535)
+        this.fail(node, "PLC2001", "String capacity must be 1..65535.");
+      const id = `${official}<${capacity.value}>`;
+      this.types.set(id, {
+        id,
+        kind: "string",
+        capacity: capacity.value,
+        encoding: official === "STRING" ? "utf8" : "utf16",
+      });
+      return { type: id };
+    }
+    return this.declaration(symbol, node.typeArguments, environment, node);
+  }
+
+  fixedArray(
+    node: ts.Node,
+    element: ResolvedType,
+    length: TypeArgument,
+    lower: TypeArgument,
+  ): ResolvedType {
+    if (
+      element.io ||
+      !(this.isValue(element) || this.types.get(element.type)?.kind === "block") ||
+      length.kind !== "integer" ||
+      lower.kind !== "integer" ||
+      length.value < 1 ||
+      length.value > 1_000_000 ||
+      lower.value + length.value - 1 > 2147483647
+    )
+      this.fail(
+        node,
+        "PLC2001",
+        "Fixed arrays need a supported element, positive bounded length and signed DINT bounds.",
+      );
+    const id = `array<${element.type},${length.value},${lower.value}>`;
+    this.types.set(id, {
+      id,
+      kind: "array",
+      element: element.type,
+      length: length.value,
+      lowerBound: lower.value,
+    });
+    this.checkSize(id, node);
+    return { type: id };
+  }
+
+  private declaration(
+    symbol: ts.Symbol,
+    arguments_: readonly ts.TypeNode[] | undefined,
+    environment: TypeEnvironment,
+    node: ts.Node,
+  ): ResolvedType {
+    const declarations = symbol.declarations ?? [];
+    if (declarations.filter(ts.isInterfaceDeclaration).length > 1)
+      this.fail(
+        node,
+        "PLC2001",
+        "Interface declaration merging is unsupported; use one closed layout declaration.",
+      );
+    const declaration = declarations.find(
+      (item) =>
+        ts.isTypeAliasDeclaration(item) ||
+        ts.isInterfaceDeclaration(item) ||
+        ts.isEnumDeclaration(item),
+    );
+    if (!declaration)
+      this.fail(node, "PLC2001", "This type is not implemented by the PLC frontend.");
+    if (ts.isEnumDeclaration(declaration)) {
+      if (arguments_?.length) this.fail(node, "PLC2001", "Enums take no type arguments.");
+      return this.enumeration(declaration);
+    }
+    const bindings = this.bindings(declaration.typeParameters, arguments_, environment, node);
+    const suffix = (declaration.typeParameters ?? [])
+      .map((parameter) => this.key(bindings.get(this.symbol(parameter.name))!))
+      .join(",");
+    const id = `${this.id(declaration, declaration.name.text)}${suffix ? `<${suffix}>` : ""}`;
+    if (this.active.has(id))
+      this.fail(node, "PLC2001", "Recursive by-value PLC layouts are unsupported.");
+    if (this.types.has(id)) return { type: id };
+    if (this.active.size >= 64)
+      this.fail(
+        node,
+        "PLC2001",
+        "Type substitution exceeds 64 levels; recursive expansion is unsupported.",
+      );
+    this.active.add(id);
+    try {
+      if (ts.isTypeAliasDeclaration(declaration)) {
+        if (ts.isTypeLiteralNode(declaration.type))
+          return this.record(declaration, id, declaration.type.members, bindings);
+        if (ts.isUnionTypeNode(declaration.type)) return this.union(declaration.type, id, bindings);
+        return this.resolve(declaration.type, bindings);
+      }
+      const inherited: Field[] = [];
+      for (const heritage of declaration.heritageClauses ?? []) {
+        for (const base of heritage.types) {
+          const baseSymbol = this.symbol(base.expression);
+          const baseType = this.declaration(baseSymbol, base.typeArguments, bindings, base);
+          const layout = this.types.get(baseType.type);
+          if (layout?.kind !== "record")
+            this.fail(base, "PLC2001", "Inherited layout must be a record.");
+          inherited.push(...layout.fields);
+        }
+      }
+      return this.record(declaration, id, declaration.members, bindings, inherited);
+    } finally {
+      this.active.delete(id);
+    }
+  }
+  // Specialization identity includes I/O and InOut modes: equal value widths alone
+  // must not merge a readonly value parameter with a mutable borrowed input.
+  key(argument: TypeArgument): string {
+    if (argument.kind === "integer") return String(argument.value);
+    const { type, io, mode } = argument.value;
+    return `${type}${io ? `:${io}` : ""}${mode ? `:${mode}` : ""}`;
+  }
+
+  /**
+   * A discriminated union is one fixed layout: a `kind` enum plus the fields of every variant.
+   * TypeScript's narrowing guards which fields a branch can read; a literal's unset fields are zero.
+   */
+  private union(node: ts.UnionTypeNode, id: string, environment: TypeEnvironment): ResolvedType {
+    const fields = new Map<string, Field>();
+    const kinds: string[] = [];
+    for (const variant of node.types) {
+      const members = ts.isTypeLiteralNode(variant) ? variant.members : undefined;
+      const tag = members?.find(
+        (member) => ts.isPropertySignature(member) && member.name.getText() === "kind",
+      );
+      const literal =
+        tag && ts.isPropertySignature(tag) && tag.type && ts.isLiteralTypeNode(tag.type)
+          ? tag.type.literal
+          : undefined;
+      if (
+        !members ||
+        !literal ||
+        !ts.isStringLiteral(literal) ||
+        !/^[A-Za-z]\w*$/.test(literal.text)
+      )
+        this.fail(
+          variant,
+          "PLC2001",
+          'Union variants are object types with an identifier string literal `kind`, such as { kind: "idle" }.',
+        );
+      if (kinds.includes(literal.text)) this.fail(variant, "PLC2001", "Duplicate union kind.");
+      kinds.push(literal.text);
+      for (const field of this.fields(
+        members.filter((member) => member !== tag),
+        environment,
+      )) {
+        const existing = fields.get(field.name);
+        if (existing && existing.type !== field.type)
+          this.fail(
+            variant,
+            "PLC2001",
+            "Union variants may share a field only with the same type.",
+          );
+        fields.set(field.name, field);
+      }
+    }
+    const kindId = `${id}Kind`;
+    this.types.set(kindId, {
+      id: kindId,
+      kind: "enum",
+      base: "DINT",
+      members: kinds.map((name, value) => ({ name, value: String(value) })),
+    });
+    this.types.set(id, {
+      id,
+      kind: "record",
+      fields: [{ name: "kind", type: kindId, readonly: false }, ...fields.values()],
+    });
+    this.unions.add(id);
+    this.checkSize(id, node);
+    return { type: id };
+  }
+
+  private record(
+    node: ts.Node,
+    id: string,
+    members: readonly ts.TypeElement[],
+    environment: TypeEnvironment,
+    inherited: readonly Field[] = [],
+  ): ResolvedType {
+    const fields = this.fields(members, environment, inherited);
+    if (!fields.length) this.fail(node, "PLC2001", "PLC records require at least one field.");
+    this.types.set(id, { id, kind: "record", fields });
+    this.checkSize(id, node);
+    return { type: id };
+  }
+
+  private fields(
+    members: readonly ts.TypeElement[],
+    environment: TypeEnvironment,
+    inherited: readonly Field[] = [],
+  ): Field[] {
+    const fields = [...inherited],
+      names = new Set(fields.map((field) => field.name));
+    for (const member of members) {
+      if (
+        !ts.isPropertySignature(member) ||
+        !member.type ||
+        member.questionToken ||
+        !member.name ||
+        !ts.isIdentifier(member.name)
+      )
+        this.fail(
+          member,
+          "PLC2001",
+          "PLC records have named, required, explicitly typed fields; methods and index signatures are unsupported.",
+        );
+      if (names.has(member.name.text)) this.fail(member, "PLC2001", "Duplicate record field.");
+      const type = this.resolve(member.type, environment);
+      if (instancedBlock(type.type, this.types))
+        this.fail(
+          member,
+          "PLC2001",
+          "Block instances belong in module or private block fields, not value records.",
+        );
+      if (type.io)
+        this.fail(
+          member,
+          "PLC2001",
+          "Logical I/O wrappers belong on ambient bindings, not fields.",
+        );
+      fields.push({
+        name: member.name.text,
+        type: type.type,
+        ...(type.mode && { mode: type.mode }),
+        readonly: Boolean(
+          member.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ReadonlyKeyword),
+        ),
+      });
+      names.add(member.name.text);
+    }
+    return fields;
+  }
+
+  inputFields(node: ts.TypeNode): readonly Field[] {
+    if (ts.isTypeLiteralNode(node) && !node.members.length) return [];
+    const resolved = this.resolve(node),
+      type = this.types.get(resolved.type);
+    if (resolved.io || resolved.mode || type?.kind !== "record")
+      this.fail(node, "PLC2001", "Block inputs require one closed record schema.");
+    if (type.fields.some((field) => this.hasReferences(field.type)))
+      this.fail(node, "PLC2001", "InOut belongs directly on input fields, not nested records.");
+    return type.fields;
+  }
+
+  // A plain value layout: no InOut borrow, nested borrow schema or block instance.
+  isValue(resolved: ResolvedType): boolean {
+    return (
+      !resolved.mode &&
+      !this.hasReferences(resolved.type) &&
+      !instancedBlock(resolved.type, this.types)
+    );
+  }
+
+  hasReferences(id: string, seen = new Set<string>()): boolean {
+    if (seen.has(id)) return false;
+    seen.add(id);
+    const type = this.types.get(id);
+    return type?.kind === "record"
+      ? type.fields.some((field) => field.mode || this.hasReferences(field.type, seen))
+      : type?.kind === "array"
+        ? this.hasReferences(type.element, seen)
+        : false;
+  }
+
+  enumeration(node: ts.EnumDeclaration): ResolvedType {
+    const id = this.id(node, node.name.text);
+    if (this.types.has(id)) return { type: id };
+    if (!node.members.length) this.fail(node, "PLC2001", "PLC enums cannot be empty.");
+    const members = node.members.map((member) => {
+      if (!ts.isIdentifier(member.name))
+        this.fail(member, "PLC2001", "Enum members require identifier names.");
+      const value = this.checker.getConstantValue(member);
+      if (
+        typeof value !== "number" ||
+        !Number.isInteger(value) ||
+        value < -2147483648 ||
+        value > 2147483647
+      )
+        this.fail(member, "PLC2001", "PLC enum values must be compile-time DINT integers.");
+      return { name: member.name.text, value: String(value) };
+    });
+    if (new Set(members.map((member) => member.value)).size !== members.length)
+      this.fail(node, "PLC2001", "PLC enum members require distinct values.");
+    this.types.set(id, { id, kind: "enum", base: "DINT", members });
+    return { type: id };
+  }
+
+  private checkSize(id: string, node: ts.Node): void {
+    const count = (typeId: string, depth: number): number => {
+      if (depth > 64) this.fail(node, "PLC2001", "PLC layout nesting exceeds 64 levels.");
+      const type = this.types.get(typeId)!;
+      const size =
+        type.kind === "array"
+          ? type.length * count(type.element, depth + 1)
+          : type.kind === "record"
+            ? type.fields.reduce((total, field) => total + count(field.type, depth + 1), 0)
+            : 1;
+      if (size > 1_000_000)
+        this.fail(node, "PLC2001", "PLC layout exceeds one million scalar elements.");
+      return size;
+    };
+    count(id, 0);
+  }
+}