@tsplc/compiler 0.0.0-stage → 0.1.0

package/ir/routine.ts

@@ -0,0 +1,826 @@
+import type { SourceSpan } from "./diagnostics.ts";
+import type {
+  Variable,
+  Expression,
+  Statement,
+  Place,
+  PlcFunction,
+  FunctionBlock,
+} from "./model.ts";
+import type {
+  CoreExpression,
+  CoreStatement,
+  CorePath,
+  CoreFunction,
+  CoreFunctionBlock,
+} from "./core-model.ts";
+import {
+  fold,
+  interval,
+  loopBounds,
+  narrowRanges,
+  valueRange,
+  type IntegerInterval,
+} from "./scalars.ts";
+import { instancedBlock, integerRange } from "./types.ts";
+import { aggregate, expressionIssue, placeType, valueFits } from "./aggregates.ts";
+import { reject } from "./normalization-error.ts";
+import type { ModuleDeclarations } from "./declarations.ts";
+
+type Flow = "fallthrough" | "return" | "loop" | "mixed";
+interface BodyResult {
+  body: CoreStatement[];
+  initialized: Set<string>;
+  flow: Flow;
+}
+
+// Only paths that reach the next statement participate in a join. A local is
+// definitely initialized when every such path initialized it; branches that
+// return or leave the loop do not constrain it.
+function join(
+  branches: readonly BodyResult[],
+  initialized: Set<string>,
+): { flow: Flow; initialized: Set<string> } {
+  const falling = branches.filter((branch) => branch.flow === "fallthrough");
+  if (falling.length)
+    return {
+      flow: "fallthrough",
+      initialized: new Set(
+        [...falling[0]!.initialized].filter((id) =>
+          falling.every((branch) => branch.initialized.has(id)),
+        ),
+      ),
+    };
+  const flow = branches[0]!.flow;
+  return { flow: branches.every((branch) => branch.flow === flow) ? flow : "mixed", initialized };
+}
+
+// All mutable lowering state belongs to one invocation of one authored routine.
+// sourceScope admits authored places; scope additionally contains captured temps.
+export class RoutineNormalizer {
+  private readonly fn: PlcFunction;
+
+  private readonly block: FunctionBlock | undefined;
+  private readonly owner: FunctionBlock | undefined;
+
+  private readonly scope: Map<string, Variable>;
+
+  private readonly sourceScope: Map<string, Variable>;
+
+  private readonly locals: Variable[];
+
+  private readonly ranges = new Map<string, IntegerInterval>();
+
+  private readonly counters = new Set<string>();
+
+  private readonly callees = new Set<string>();
+
+  private temporaryCount = 0;
+
+  constructor(
+    routine: PlcFunction | FunctionBlock,
+    private readonly declarations: ModuleDeclarations,
+  ) {
+    this.block = "inputs" in routine ? routine : undefined;
+    this.owner =
+      this.block ??
+      ("owner" in routine && routine.owner
+        ? declarations.blocks.get(routine.owner.block)
+        : undefined);
+    const parameters = "parameters" in routine ? routine.parameters : routine.inputs;
+    this.fn = {
+      id: routine.id,
+      name: routine.name,
+      ...("owner" in routine && routine.owner && { owner: routine.owner }),
+      parameters,
+      locals: routine.locals,
+      body: routine.body,
+      span: routine.span,
+      ...(routine.result && { result: routine.result }),
+    };
+    this.scope = new Map(declarations.globals);
+    for (const item of [
+      ...parameters,
+      ...(this.owner ? [...this.owner.state, ...this.owner.outputs] : []),
+      ...routine.locals,
+    ])
+      this.scope.set(item.id, item);
+    this.sourceScope = new Map(this.scope);
+    this.locals = [...routine.locals];
+  }
+
+  normalize(): { routine: CoreFunction | CoreFunctionBlock; callees: ReadonlySet<string> } {
+    if (this.block?.standard)
+      return { routine: { ...this.block, body: [] }, callees: this.callees };
+    const normalized = this.body(this.fn.body, new Set(this.fn.parameters.map((item) => item.id)));
+    if (this.fn.result && normalized.flow !== "return")
+      reject("A typed helper must return on every path.", this.fn.span);
+    const routine = this.block
+      ? { ...this.block, locals: this.locals, body: normalized.body }
+      : { ...this.fn, locals: this.locals, body: normalized.body };
+    return { routine, callees: this.callees };
+  }
+
+  private temporary(type: string, span: SourceSpan): Variable {
+    let id: string;
+    do {
+      id = `${this.fn.id}:temporary:${this.temporaryCount++}`;
+    } while (this.declarations.hasId(id));
+    this.declarations.claimId(id);
+    const item: Variable = {
+      id,
+      name: `temporary_${this.temporaryCount}`,
+      type,
+      storage: "local",
+      mutable: true,
+      retain: false,
+      span,
+    };
+    this.scope.set(id, item);
+    this.locals.push(item);
+    return item;
+  }
+
+  private load(variable: Variable, span: SourceSpan): CoreExpression {
+    return { kind: "load", root: variable.id, type: variable.type, span };
+  }
+
+  private verifyCall(
+    id: string,
+    arguments_: readonly Expression[],
+    span: SourceSpan,
+    instance?: string,
+  ): PlcFunction {
+    const called = this.declarations.signatures.get(id);
+    if (!called || called.parameters.length !== arguments_.length)
+      reject("Unknown helper or wrong argument count.", span);
+    if (called.owner) {
+      if (instance) {
+        const variable = this.sourceScope.get(instance);
+        const type = variable && instancedBlock(variable.type, this.declarations.types);
+        if (
+          (variable?.storage !== "instance" && variable?.mode !== "inOut") ||
+          type?.block !== called.owner.block
+        )
+          reject("Method calls require a matching static block instance.", span);
+      } else if (this.owner?.id !== called.owner.block)
+        reject("An implicit method call requires its owning block scope.", span);
+      if (called.owner.access !== "public" && this.owner?.id !== called.owner.block)
+        reject("Private and protected methods require their owning block scope.", span);
+    } else if (instance) reject("Ordinary functions cannot have an instance receiver.", span);
+    this.callees.add(id);
+    arguments_.forEach((argument, index) => {
+      if (argument.type !== called.parameters[index]?.type)
+        reject("Helper argument has the wrong PLC type.", argument.span);
+    });
+    return called;
+  }
+
+  private expression(
+    value: Expression,
+    initialized: Set<string>,
+    output: CoreStatement[],
+    allowAggregateLoad = false,
+  ): CoreExpression {
+    const type = this.declarations.types.get(value.type);
+    if (!type || !this.declarations.isValueType(value.type))
+      reject("Unknown or non-value expression type.", value.span);
+    if (value.kind === "borrow")
+      reject("Borrowed places are only valid in block update arguments.", value.span);
+    const common = { type: value.type, span: value.span };
+    if (value.kind === "length") {
+      const array = this.declarations.types.get(value.operand.type);
+      if (array?.kind !== "array" || value.type !== "DINT")
+        reject("Length requires a fixed array and DINT result.", value.span);
+      if (value.operand.kind === "load") {
+        const source = this.sourceScope.get(value.operand.place.root),
+          checked = placeType(
+            value.operand.place,
+            this.declarations.types,
+            this.sourceScope,
+            this.ranges,
+          );
+        if (
+          !source ||
+          checked.issue ||
+          checked.type !== value.operand.type ||
+          (source.storage === "local" && !initialized.has(source.id))
+        )
+          reject(checked.issue ?? "Invalid array receiver.", value.span);
+        this.normalizePath(value.operand.place, initialized, output);
+      } else this.expression(value.operand, initialized, output, true);
+      return {
+        ...common,
+        kind: "constant",
+        value: { kind: "integer", value: String(array.length) },
+      };
+    }
+    if (value.kind === "conditional") {
+      if (
+        value.condition.type !== "BOOL" ||
+        value.then.type !== value.type ||
+        value.else.type !== value.type
+      )
+        reject("Invalid conditional types.", value.span);
+      const condition = this.expression(value.condition, initialized, output),
+        result = this.temporary(value.type, value.span);
+      const branch = (operand: Expression): CoreStatement[] => {
+        const statements: CoreStatement[] = [];
+        const evaluated = this.expression(operand, new Set(initialized), statements);
+        statements.push({ kind: "assign", root: result.id, value: evaluated, span: value.span });
+        return statements;
+      };
+      output.push({
+        kind: "if",
+        condition,
+        // biome-ignore lint/suspicious/noThenProperty: PLC branch data is an array, not a thenable callback.
+        then: branch(value.then),
+        else: branch(value.else),
+        span: value.span,
+      });
+      initialized.add(result.id);
+      return this.load(result, value.span);
+    }
+    if (value.kind === "call") {
+      const called = this.verifyCall(value.function, value.arguments, value.span, value.instance);
+      if (called.result !== value.type)
+        reject("Expression call requires a matching result type.", value.span);
+      const index =
+        value.instance &&
+        this.instanceIndex(value.instance, value.index, initialized, output, value.span);
+      const arguments_ = this.arguments(called.parameters, value.arguments, initialized, output);
+      const result = this.temporary(value.type, value.span);
+      output.push({
+        kind: "invoke",
+        function: value.function,
+        ...(value.instance && { instance: value.instance }),
+        ...(index && { index }),
+        arguments: arguments_,
+        destination: result.id,
+        span: value.span,
+      });
+      initialized.add(result.id);
+      return this.load(result, value.span);
+    }
+    const issue = expressionIssue(value, this.declarations.types, this.scope, this.ranges);
+    if (issue) reject(issue, value.span);
+    switch (value.kind) {
+      case "copy":
+        return this.expression(value.operand, initialized, output, true);
+      case "record":
+      case "array": {
+        const result = this.temporary(value.type, value.span);
+        if (value.kind === "record") {
+          for (const [name, operand] of Object.entries(value.fields))
+            output.push({
+              kind: "assign",
+              root: result.id,
+              path: [{ kind: "field", name }],
+              value: this.expression(operand, initialized, output),
+              span: operand.span,
+            });
+        } else {
+          const array = this.declarations.types.get(value.type)!;
+          if (array.kind !== "array") reject("Invalid array construction.", value.span);
+          value.items.forEach((operand, index) => {
+            output.push({
+              kind: "assign",
+              root: result.id,
+              path: [
+                {
+                  kind: "index",
+                  value: {
+                    kind: "constant",
+                    type: "DINT",
+                    value: { kind: "integer", value: String(array.lowerBound + index) },
+                    span: operand.span,
+                  },
+                },
+              ],
+              value: this.expression(operand, initialized, output),
+              span: operand.span,
+            });
+          });
+        }
+        initialized.add(result.id);
+        return this.load(result, value.span);
+      }
+      case "constant": {
+        if (!aggregate(type)) return { ...common, kind: "constant", value: value.value };
+        const result = this.temporary(value.type, value.span);
+        output.push({
+          kind: "assign",
+          root: result.id,
+          value: { ...common, kind: "constant", value: value.value },
+          span: value.span,
+        });
+        initialized.add(result.id);
+        return this.load(result, value.span);
+      }
+      case "load": {
+        const source = this.sourceScope.get(value.place.root),
+          checked = placeType(value.place, this.declarations.types, this.sourceScope, this.ranges);
+        if (!source || checked.issue || checked.type !== value.type)
+          reject(checked.issue ?? "Invalid PLC load.", value.span);
+        if (aggregate(type) && !allowAggregateLoad)
+          reject("Aggregate loads require explicit copy or a readonly value argument.", value.span);
+        if (source.storage === "local" && !initialized.has(source.id))
+          reject("Local read before initialization.", value.span);
+        // The virtual .out view is not a vendor record value. Snapshot its
+        // declared fields, rather than copying the whole FB instance.
+        const first = value.place.path[0];
+        if (
+          source.storage === "instance" &&
+          value.place.path.length === 1 &&
+          first?.kind === "field" &&
+          first.name === "out" &&
+          type.kind === "record"
+        ) {
+          const result = this.temporary(value.type, value.span);
+          for (const field of type.fields) {
+            const selected: Expression = {
+              kind: "load",
+              type: field.type,
+              place: {
+                root: source.id,
+                path: [...value.place.path, { kind: "field", name: field.name }],
+              },
+              span: value.span,
+            };
+            const captured = this.expression(selected, initialized, output, true);
+            output.push({
+              kind: "assign",
+              root: result.id,
+              path: [{ kind: "field", name: field.name }],
+              value: captured,
+              span: value.span,
+            });
+          }
+          initialized.add(result.id);
+          return this.load(result, value.span);
+        }
+        const path = this.normalizePath(value.place, initialized, output);
+        if (source.storage === "constant" && source.initial && !path.length)
+          return { ...common, kind: "constant", value: source.initial };
+        // Capture now, before a later operand can invoke an effectful helper.
+        const result = this.temporary(value.type, value.span);
+        output.push({
+          kind: "assign",
+          root: result.id,
+          value: { ...common, kind: "load", root: source.id, ...(path.length && { path }) },
+          span: value.span,
+        });
+        const bound = interval(value, this.declarations.types, this.scope, this.ranges);
+        if (bound) this.ranges.set(result.id, bound);
+        initialized.add(result.id);
+        return this.load(result, value.span);
+      }
+      case "unary": {
+        const operand = this.expression(value.operand, initialized, output),
+          constant = fold(value, this.scope, this.declarations.types);
+        return constant
+          ? { ...common, kind: "constant", value: constant }
+          : { ...common, kind: "unary", operator: value.operator, operand };
+      }
+      case "convert": {
+        const operand = this.expression(value.operand, initialized, output),
+          constant = fold(value, this.scope, this.declarations.types);
+        if (value.type === value.operand.type) return operand;
+        return constant
+          ? { ...common, kind: "constant", value: constant }
+          : { ...common, kind: "convert", operand, policy: value.policy };
+      }
+      case "binary": {
+        const left = this.expression(value.left, initialized, output);
+        if (value.operator === "and" || value.operator === "or") {
+          const result = this.temporary("BOOL", value.span),
+            branch: CoreStatement[] = [];
+          output.push({ kind: "assign", root: result.id, value: left, span: value.span });
+          const right = this.expression(value.right, new Set(initialized), branch);
+          branch.push({ kind: "assign", root: result.id, value: right, span: value.span });
+          const condition: CoreExpression =
+            value.operator === "and"
+              ? this.load(result, value.span)
+              : {
+                  kind: "unary",
+                  operator: "not",
+                  operand: this.load(result, value.span),
+                  type: "BOOL",
+                  span: value.span,
+                };
+          output.push({
+            kind: "if",
+            condition,
+            // biome-ignore lint/suspicious/noThenProperty: PLC branch data is an array, not a thenable callback.
+            then: branch,
+            else: [],
+            span: value.span,
+          });
+          initialized.add(result.id);
+          return this.load(result, value.span);
+        }
+        const right = this.expression(value.right, initialized, output),
+          constant = fold(value, this.scope, this.declarations.types);
+        if (constant) return { ...common, kind: "constant", value: constant };
+        return {
+          ...common,
+          kind: "binary",
+          operator: value.operator,
+          left,
+          right,
+          ...(value.policy && { policy: value.policy }),
+        };
+      }
+    }
+  }
+
+  private normalizePath(place: Place, initialized: Set<string>, output: CoreStatement[]): CorePath {
+    // An index is evaluated and captured once, before later arguments can change
+    // its source storage. The resulting path denotes that selected cell.
+    return place.path.map((segment) =>
+      segment.kind === "field"
+        ? segment
+        : { kind: "index", value: this.expression(segment.value, initialized, output) },
+    );
+  }
+
+  private destination(
+    place: Place,
+    type: string,
+    initialized: Set<string>,
+    span: SourceSpan,
+  ): Variable {
+    const target = this.sourceScope.get(place.root),
+      initializing =
+        target?.storage === "local" && !initialized.has(place.root) && !place.path.length;
+    const checked = placeType(
+      place,
+      this.declarations.types,
+      this.sourceScope,
+      this.ranges,
+      !initializing,
+    );
+    if (!target || checked.issue || checked.type !== type || this.counters.has(place.root))
+      reject(checked.issue ?? "Invalid assignment destination.", span);
+    if (place.path.length && target.storage === "local" && !initialized.has(target.id))
+      reject("Initialize the whole aggregate before assigning fields.", span);
+    return target;
+  }
+
+  private instanceIndex(
+    instance: string,
+    index: Expression | undefined,
+    initialized: Set<string>,
+    output: CoreStatement[],
+    span: SourceSpan,
+  ): CoreExpression | undefined {
+    if (!index) return undefined;
+    const checked = placeType(
+      { root: instance, path: [{ kind: "index", value: index }] },
+      this.declarations.types,
+      this.sourceScope,
+      this.ranges,
+    );
+    if (checked.issue) reject(checked.issue, span);
+    return this.expression(index, initialized, output);
+  }
+
+  private blockUpdate(
+    item: Extract<Statement, { kind: "blockUpdate" }>,
+    initialized: Set<string>,
+    output: CoreStatement[],
+  ): void {
+    const instance = this.sourceScope.get(item.instance),
+      type = instance && instancedBlock(instance.type, this.declarations.types);
+    const called = type && this.declarations.blocks.get(type.block);
+    if ((instance?.storage !== "instance" && instance?.mode !== "inOut") || !called)
+      reject("Updates require a statically allocated block instance.", item.span);
+    const index = this.instanceIndex(item.instance, item.index, initialized, output, item.span);
+    const keys = Object.keys(item.inputs);
+    if (
+      keys.length !== called.inputs.length ||
+      called.inputs.some((input) => !Object.hasOwn(item.inputs, input.name))
+    )
+      reject("Block update must supply every named input exactly once.", item.span);
+    this.callees.add(called.id);
+    const arguments_ = this.arguments(
+      keys.map((name) => called.inputs.find((input) => input.name === name)!),
+      keys.map((name) => item.inputs[name]!),
+      initialized,
+      output,
+    );
+    const inputs = Object.fromEntries(keys.map((name, index) => [name, arguments_[index]!]));
+    output.push({
+      kind: "blockUpdate",
+      instance: instance.id,
+      ...(index && { index }),
+      inputs,
+      span: item.span,
+    });
+  }
+
+  private arguments(
+    parameters: readonly Variable[],
+    values: readonly Expression[],
+    initialized: Set<string>,
+    output: CoreStatement[],
+  ): CoreExpression[] {
+    const arguments_: CoreExpression[] = [];
+    for (const [index, value] of values.entries()) {
+      const input = parameters[index]!;
+      if (value.type !== input.type)
+        reject("Block input differs from its concrete PLC type.", value.span);
+      const block = this.declarations.types.get(value.type)?.kind === "block";
+      if (input.mode === "inOut" && value.kind !== "borrow") {
+        // A value with no writable address reaches the callee through a temporary.
+        if (block) reject("Pass a block instance by name.", value.span);
+        const temporary = this.temporary(value.type, value.span);
+        output.push({
+          kind: "assign",
+          root: temporary.id,
+          value: this.expression(value, initialized, output),
+          span: value.span,
+        });
+        initialized.add(temporary.id);
+        arguments_.push({
+          kind: "borrow",
+          type: value.type,
+          place: { root: temporary.id, path: [] },
+          span: value.span,
+        });
+      } else if (input.mode === "inOut" && value.kind === "borrow") {
+        const root = this.sourceScope.get(value.place.root),
+          checked = placeType(
+            value.place,
+            this.declarations.types,
+            this.sourceScope,
+            this.ranges,
+            !block,
+          );
+        if (
+          !root ||
+          checked.issue ||
+          checked.type !== value.type ||
+          (!block && !this.declarations.isValueType(value.type)) ||
+          this.counters.has(root.id) ||
+          (root.storage === "local" && !initialized.has(root.id))
+        )
+          reject(
+            checked.issue ?? "Borrow requires initialized mutable value storage of the exact type.",
+            value.span,
+          );
+        arguments_.push({
+          kind: "borrow",
+          type: value.type,
+          place: {
+            root: value.place.root,
+            path: this.normalizePath(value.place, initialized, output),
+          },
+          span: value.span,
+        });
+      } else {
+        if (value.kind === "borrow")
+          reject("Readonly value inputs cannot receive borrowed references.", value.span);
+        arguments_.push(this.expression(value, initialized, output, true));
+      }
+    }
+    return arguments_;
+  }
+
+  private body(
+    statements: readonly Statement[],
+    initialized: Set<string>,
+    inLoop = false,
+  ): BodyResult {
+    const output: CoreStatement[] = [];
+    let flow: Flow = "fallthrough";
+    for (const item of statements) {
+      if (flow !== "fallthrough") break;
+      switch (item.kind) {
+        case "assign": {
+          this.destination(item.destination, item.value.type, initialized, item.span);
+          const path = this.normalizePath(item.destination, initialized, output);
+          // A const is assigned once, so its initializer's range holds wherever it is read.
+          const bound =
+            !path.length &&
+            this.scope.get(item.destination.root)?.mutable === false &&
+            valueRange(
+              item.value,
+              this.declarations.types,
+              this.scope,
+              this.ranges,
+              this.declarations.signatures,
+            );
+          const value = this.expression(item.value, initialized, output);
+          if (bound) this.ranges.set(item.destination.root, bound);
+          if (!path.length) initialized.add(item.destination.root);
+          output.push({
+            kind: "assign",
+            root: item.destination.root,
+            ...(path.length && { path }),
+            value,
+            span: item.span,
+          });
+          break;
+        }
+        case "blockUpdate": {
+          this.blockUpdate(item, initialized, output);
+          break;
+        }
+        case "invoke": {
+          const called = this.verifyCall(item.function, item.arguments, item.span, item.instance);
+          if (item.destination) {
+            if (item.destination.path.length || !called.result)
+              reject("Invalid helper destination.", item.span);
+            this.destination(item.destination, called.result, initialized, item.span);
+          }
+          const index =
+            item.instance &&
+            this.instanceIndex(item.instance, item.index, initialized, output, item.span);
+          // Each argument snapshots its reads before the next argument can invoke
+          // a helper that mutates shared state.
+          const arguments_ = this.arguments(called.parameters, item.arguments, initialized, output);
+          output.push({
+            kind: "invoke",
+            function: item.function,
+            ...(item.instance && { instance: item.instance }),
+            ...(index && { index }),
+            arguments: arguments_,
+            span: item.span,
+            ...(item.destination && { destination: item.destination.root }),
+          });
+          if (item.destination) initialized.add(item.destination.root);
+          break;
+        }
+        case "if": {
+          if (item.condition.type !== "BOOL") reject("Conditions require BOOL.", item.span);
+          const condition = this.expression(item.condition, initialized, output);
+          const originalRanges = new Map(this.ranges);
+          const branch = (statements: readonly Statement[], truth: boolean) => {
+            this.ranges.clear();
+            for (const [root, range] of narrowRanges(
+              item.condition,
+              truth,
+              this.declarations.types,
+              this.sourceScope,
+              originalRanges,
+            ))
+              this.ranges.set(root, range);
+            try {
+              return this.body(statements, new Set(initialized), inLoop);
+            } finally {
+              this.ranges.clear();
+              for (const [root, range] of originalRanges) this.ranges.set(root, range);
+            }
+          };
+          const yes = branch(item.then, true),
+            no = branch(item.else, false);
+          ({ flow, initialized } = join([yes, no], initialized));
+          output.push({
+            kind: "if",
+            condition,
+            // biome-ignore lint/suspicious/noThenProperty: PLC branch data is an array, not a thenable callback.
+            then: yes.body,
+            else: no.body,
+            span: item.span,
+          });
+          break;
+        }
+        case "switch": {
+          const value = this.expression(item.value, initialized, output),
+            seen = new Set<string>();
+          const branches = item.cases.map((branch) => {
+            for (const constant of branch.values) {
+              if (
+                !valueFits(
+                  constant,
+                  this.declarations.types.get(item.value.type)!,
+                  this.declarations.types,
+                )
+              )
+                reject("Invalid case constant.", item.span);
+              const key = JSON.stringify(constant);
+              if (seen.has(key)) reject("Duplicate case constant.", item.span);
+              seen.add(key);
+            }
+            return {
+              values: branch.values,
+              result: this.body(branch.body, new Set(initialized), inLoop),
+            };
+          });
+          const fallback = this.body(item.fallback, new Set(initialized), inLoop);
+          ({ flow, initialized } = join(
+            [...branches.map((branch) => branch.result), fallback],
+            initialized,
+          ));
+          output.push({
+            kind: "switch",
+            value,
+            cases: branches.map((branch) => ({ values: branch.values, body: branch.result.body })),
+            fallback: fallback.body,
+            span: item.span,
+          });
+          break;
+        }
+        case "for": {
+          const counter = this.sourceScope.get(item.counter);
+          const counterType = counter && this.declarations.types.get(counter.type);
+          if (
+            !counter ||
+            !(item.counterScope === "existing"
+              ? ["local", "module", "field"].includes(counter.storage)
+              : counter.storage === "local") ||
+            !counter.mutable ||
+            counterType?.kind !== "integer" ||
+            this.counters.has(counter.id) ||
+            item.start.type !== counter.type ||
+            item.limit.type !== counter.type ||
+            !/^(-?[1-9][0-9]*)$/.test(item.step)
+          )
+            reject("Invalid bounded loop.", item.span);
+          const start = fold(item.start, this.scope, this.declarations.types);
+          const limit = fold(item.limit, this.scope, this.declarations.types);
+          const startRange = interval(
+            item.start,
+            this.declarations.types,
+            this.sourceScope,
+            this.ranges,
+          );
+          const limitRange = interval(
+            item.limit,
+            this.declarations.types,
+            this.sourceScope,
+            this.ranges,
+          );
+          if (!startRange || !limitRange)
+            reject("Loop bounds require finite integer ranges.", item.span);
+          const step = BigInt(item.step);
+          const proof = loopBounds(startRange, limitRange, step, item.exclusive);
+          const dynamic = start?.kind !== "integer" || limit?.kind !== "integer";
+          const first = proof.first,
+            last = proof.last,
+            count = proof.count;
+          if (
+            count > 1_000_000n ||
+            Number(count) !== item.maxIterations ||
+            !Number.isSafeInteger(item.maxIterations)
+          )
+            reject("Loop iteration proof differs from its bounds.", item.span);
+          if (item.counterScope === "existing") {
+            const terminal = dynamic
+              ? (step > 0n ? proof.range[1] : proof.range[0]) + step
+              : first + count * step;
+            const [minimum, maximum] = integerRange(counterType);
+            if (count > 0n && (terminal < minimum || terminal > maximum))
+              reject("The existing loop counter overflows on termination.", item.span);
+          }
+          const evaluatedStart = this.expression(item.start, initialized, output);
+          const evaluatedLimit = this.expression(item.limit, initialized, output);
+          initialized.add(counter.id);
+          this.counters.add(counter.id);
+          this.ranges.set(counter.id, proof.range);
+          const nested = this.body(item.body, new Set(initialized), true);
+          this.counters.delete(counter.id);
+          this.ranges.delete(counter.id);
+          if (item.counterScope !== "existing") initialized.delete(counter.id);
+          output.push({
+            kind: "for",
+            counter: counter.id,
+            ...(item.counterScope && { counterScope: item.counterScope }),
+            start: { kind: "integer", value: String(first) },
+            limit: { kind: "integer", value: String(last) },
+            ...(dynamic && {
+              dynamic: {
+                start: evaluatedStart,
+                limit: evaluatedLimit,
+                ...(item.exclusive && { exclusive: item.exclusive }),
+              },
+            }),
+            step: item.step,
+            maxIterations: item.maxIterations,
+            body: nested.body,
+            span: item.span,
+          });
+          break;
+        }
+        case "return": {
+          if (item.value?.type !== this.fn.result)
+            reject("Return differs from the function signature.", item.span);
+          const value = item.value && this.expression(item.value, initialized, output);
+          output.push({ kind: "return", span: item.span, ...(value && { value }) });
+          flow = "return";
+          break;
+        }
+        case "break":
+        case "continue":
+          if (!inLoop) reject("Loop control appears outside a bounded loop.", item.span);
+          output.push({ kind: item.kind, span: item.span });
+          flow = "loop";
+          break;
+        default:
+          reject("Unknown PLC statement.");
+      }
+    }
+    return { body: output, initialized, flow };
+  }
+}