@tsplc/compiler 0.2.10 → 0.2.11

package/backends/codesys/emit.ts

@@ -11,13 +11,12 @@ import type {
   Variable,
 } from "@tsplc/compiler/ir";
 import { defaultValue, instancedBlock, standardBlocks } from "@tsplc/compiler/ir";
-import { Names, pascalCase } from "./names.ts";
+import { planGlobalNames } from "./global-names.ts";
+import { Names } from "./names.ts";
 import { NumericLowering } from "./numeric.ts";
 import { type CodesysPlan, diagnostic, isCodesysPlan } from "./plan.ts";
-import { storageLayout } from "./storage.ts";
 import { accessedStorage } from "./task-access.ts";
 import { emitHttp, httpMethods, httpCertificateVerifier, opcuaServiceCapacity } from "./http.ts";
-import { CodesysTypes } from "./types.ts";
 import type { Publication } from "@tsplc/config";
 
 export interface SourceMapping {
@@ -59,7 +58,7 @@ export function emitCodesys(plan: CodesysPlan): CodesysBundle {
 // A bundle owns target names and source mappings. Per-routine declarations and
 // implementation lines stay local to emitRoutine, so they cannot leak between POUs.
 class CodesysEmitter {
-  private readonly names = new Names();
+  private readonly names;
   private networkName: string | undefined;
   private readonly rpcChannels: {
     path: string;
@@ -94,9 +93,10 @@ class CodesysEmitter {
     string,
     { names: Names; references: Map<string, string> }
   >();
-  private readonly targetTypes: CodesysTypes;
+  private readonly targetTypes;
   private readonly numeric: NumericLowering;
-  private readonly layout;
+  private readonly globals;
+  private readonly retainedVariables;
 
   constructor(private readonly plan: CodesysPlan) {
     const { core, options } = plan;
@@ -107,22 +107,18 @@ class CodesysEmitter {
       if (!fn.owner && [...accessedStorage(fn, core)].some((id) => persistent.has(id)))
         this.programRoutines.add(fn.id);
     }
-    for (const name of Object.values(options.programNames ?? {})) this.names.reserve(name);
-
-    this.typeMap = new Map(core.types.map((type) => [type.id, type]));
-    this.blocks = new Map(core.blocks.map((block) => [block.id, block]));
-    this.blockNames = new Map(
-      core.blocks.map((block) => [
-        block.id,
-        block.standard
-          ? standardBlocks[block.standard].native
-          : this.names.allocateObject("FB", block.name),
-      ]),
+    const { names, typeMap, blockNames, targetTypes, globals, retainedVariables } = planGlobalNames(
+      core,
+      options.programNames,
     );
-    for (const name of this.blockNames.values()) this.names.reserve(name);
-    this.targetTypes = new CodesysTypes(this.typeMap, this.names, this.blockNames);
+    this.names = names;
+    this.typeMap = typeMap;
+    this.blockNames = blockNames;
+    this.targetTypes = targetTypes;
+    this.globals = globals;
+    this.retainedVariables = retainedVariables;
+    this.blocks = new Map(core.blocks.map((block) => [block.id, block]));
     this.numeric = new NumericLowering(this.typeMap, (label) => this.names.allocate(label));
-    this.layout = storageLayout(core);
     this.objects.push(...this.targetTypes.objects);
   }
 
@@ -268,7 +264,7 @@ END_VAR
     let source = object.id.split(":")[0] ?? "";
     const program = core.programs.find((item) => item.id === object.id);
     if (program) source = program.entry.split(":")[0] ?? "";
-    const group = this.layout.globalLists.find((item) => item.id === object.id);
+    const group = this.globals.find((item) => item.id === object.id);
     if (group) {
       // Variable IDs are relative to tsconfig, unlike their diagnostic spans.
       source = group.variables[0]?.id.split(":")[0] ?? "";
@@ -290,24 +286,11 @@ END_VAR
 
   private emitGlobals(): void {
     const { options } = this.plan;
-    const { layout, names, references, mappings, targetTypes, typeMap, objects } = this;
-    const hasExports = (group: (typeof layout.globalLists)[number]) =>
-      group.variables.some((variable) => variable.exported && !variable.exposure);
-    for (const group of layout.globalLists) {
-      const splitByStorage = layout.globalLists.some(
-        (other) =>
-          other.module === group.module && other.storage !== group.storage && hasExports(other),
-      );
-      // Exported lists are the program's public interface; private storage stays generated.
-      const name = hasExports(group)
-        ? names.allocate(
-            pascalCase(splitByStorage ? `${group.module}-${group.storage}` : group.module),
-          )
-        : names.allocateObject("GVL", `${group.module}_${group.storage}`);
+    const { globals, references, mappings, targetTypes, typeMap, objects } = this;
+    for (const group of globals) {
+      const { name, fields } = group;
       const published = new Set(this.plan.publication[options.buildTarget]);
       const publish = group.variables.some((variable) => published.has(variable.id));
-      const fields = new Names();
-      for (const name of this.blockNames.values()) fields.reserve(name);
       const lines = [
         ...(publish ? ["{attribute 'linkalways'}"] : []),
         "{attribute 'qualified_only'}",
@@ -318,7 +301,7 @@ END_VAR
             : "VAR_GLOBAL",
       ];
       for (const item of group.variables) {
-        const field = fields.allocate(item.name);
+        const field = required(fields.get(item.id));
         references.set(item.id, `${name}.${field}`);
         if (published.has(item.id))
           lines.push(`    {attribute 'symbol' := '${item.exposure ? "read" : "readwrite"}'}`);
@@ -606,7 +589,7 @@ END_VAR`,
       blocks,
       blockFields,
       numeric,
-      layout,
+      retainedVariables,
     } = this;
     const block = "inputs" in fn ? fn : undefined;
     const method = "owner" in fn ? fn.owner : undefined;
@@ -998,11 +981,11 @@ END_VAR`,
       section("VAR_OUTPUT", block.outputs);
       section(
         "VAR",
-        block.state.filter((item) => !layout.retainedVariables.has(item.id)),
+        block.state.filter((item) => !retainedVariables.has(item.id)),
       );
       section(
         "VAR RETAIN",
-        block.state.filter((item) => layout.retainedVariables.has(item.id)),
+        block.state.filter((item) => retainedVariables.has(item.id)),
       );
     }
     if (declarations.length) {

package/backends/codesys/global-names.ts

@@ -0,0 +1,49 @@
+import { standardBlocks, type VerifiedCoreModule } from "@tsplc/compiler/ir";
+import { Names, pascalCase } from "./names.ts";
+import { storageLayout } from "./storage.ts";
+import { CodesysTypes } from "./types.ts";
+
+export const planGlobalNames = (
+  core: VerifiedCoreModule,
+  programNames: Readonly<Record<string, string>> = {},
+) => {
+  const names = new Names();
+  for (const name of Object.values(programNames)) names.reserve(name);
+
+  const typeMap = new Map(core.types.map((type) => [type.id, type]));
+  const blockNames = new Map(
+    core.blocks.map((block) => [
+      block.id,
+      block.standard
+        ? standardBlocks[block.standard].native
+        : names.allocateObject("FB", block.name),
+    ]),
+  );
+  for (const name of blockNames.values()) names.reserve(name);
+  const targetTypes = new CodesysTypes(typeMap, names, blockNames);
+
+  const { globalLists, retainedVariables } = storageLayout(core);
+  const hasExports = (group: (typeof globalLists)[number]) =>
+    group.variables.some((variable) => variable.exported && !variable.exposure);
+  const globals = globalLists.map((group) => {
+    const splitByStorage = globalLists.some(
+      (other) =>
+        other.module === group.module && other.storage !== group.storage && hasExports(other),
+    );
+    // Exported lists are the program's public interface. Private storage stays generated.
+    const name = hasExports(group)
+      ? names.allocate(
+          pascalCase(splitByStorage ? `${group.module}-${group.storage}` : group.module),
+        )
+      : names.allocateObject("GVL", `${group.module}_${group.storage}`);
+    const fields = new Names();
+    for (const name of blockNames.values()) fields.reserve(name);
+    return {
+      ...group,
+      name,
+      fields: new Map(group.variables.map((item) => [item.id, fields.allocate(item.name)])),
+    };
+  });
+
+  return { names, typeMap, blockNames, targetTypes, globals, retainedVariables };
+};

package/backends/codesys/plan.ts

@@ -17,7 +17,7 @@ import { iecSpelling, isStoragePath, resolveStoragePath, type StorageBinding } f
 import { isIecIdentifier } from "./names.ts";
 import { storageLayout } from "./storage.ts";
 import { validateHttpLayout, resolveHttpEndpoint, type HttpEndpoint } from "./http.ts";
-import { accessedStorage } from "./task-access.ts";
+import { accessedStorage, schedulePrograms, taskStorageOwnership } from "./task-access.ts";
 import { resolvePublication } from "./publication.ts";
 import type { Publication } from "@tsplc/config";
 
@@ -58,58 +58,12 @@ export function planCodesys(
       ),
     };
 
-  const backgroundTasks = new Map<string, Deployment["tasks"][number]>();
-  for (const program of core.programs) {
-    if (!program.background) continue;
-    const { priority, intervalNanoseconds } = program.background;
-    const name = `TsplcBackground_${priority}_${BigInt(intervalNanoseconds) / 1000000n}`;
-    const existing = backgroundTasks.get(name);
-    backgroundTasks.set(name, {
-      name,
-      priority,
-      intervalNanoseconds,
-      programs: [...(existing?.programs ?? []), program.name],
-    });
-  }
-  deployment = { tasks: [...deployment.tasks, ...backgroundTasks.values()] };
   const options = parsed.data;
   const diagnostics: Diagnostic[] = [];
   const report = (message: string, span?: SourceSpan): void => {
     diagnostics.push(diagnostic(message, span));
   };
-  const callerTasks = deployment.tasks;
-  for (const continuation of core.programs.filter((program) => program.continuation)) {
-    const scope = continuation.continuation!;
-    const root = core.variables.find(
-      (variable) => variable.name === scope.instance && variable.span.file === scope.file,
-    );
-    if (!root) {
-      report(`Missing continuation owner ${scope.instance}.`);
-      continue;
-    }
-    const owners = callerTasks.filter((task) =>
-      task.programs.some((name) => {
-        const program = core.programs.find((program) => program.name === name);
-        if (!program || program.background) return false;
-        const fn = core.functions.find((fn) => fn.id === program.entry);
-        return fn && accessedStorage(fn, core).has(root.id);
-      }),
-    );
-    if (owners.length !== 1) {
-      report(
-        `Continuation owner ${scope.instance} must belong to exactly one caller task.`,
-        root.span,
-      );
-      continue;
-    }
-    deployment = {
-      tasks: deployment.tasks.map((task) =>
-        task.name === owners[0]!.name
-          ? { ...task, programs: [...task.programs, continuation.name] }
-          : task,
-      ),
-    };
-  }
+  deployment = { tasks: schedulePrograms(core, deployment.tasks, report) };
   const http = new Map<string, HttpEndpoint>();
   for (const block of core.blocks)
     if (block.runtime?.kind === "http" || block.runtime?.kind === "rpc") {
@@ -314,21 +268,10 @@ function ioBits(type: PlcType | undefined): number {
 }
 
 function validateTasks(core: VerifiedCoreModule, deployment: Deployment, report: Report): void {
-  // One cyclic task owns each mutable storage root, including transitive calls
-  // and borrowed globals. Sharing state within an ordered task remains valid.
   const programs = new Map(core.programs.map((program) => [program.name, program]));
   const assignment = new Map<string, string>();
   const taskNames = new Set<string>();
-  const stateOwners = new Map<string, string>();
-  const globals = new Map(core.variables.map((item) => [item.id, item]));
-  const functions = new Map(core.functions.map((item) => [item.id, item]));
-  const blockRuntimes = new Map(
-    core.types.flatMap((type) =>
-      type.kind === "block"
-        ? [[type.id, core.blocks.find((block) => block.id === type.block)?.runtime?.kind] as const]
-        : [],
-    ),
-  );
+  const checkOwnership = taskStorageOwnership(core, report);
   for (const task of deployment.tasks) {
     if (!isIecIdentifier(task.name)) report(`Invalid task name ${task.name}.`);
     if (taskNames.has(task.name.toUpperCase())) report(`Duplicate task name ${task.name}.`);
@@ -351,35 +294,7 @@ function validateTasks(core: VerifiedCoreModule, deployment: Deployment, report:
       }
       if (assignment.has(name)) report(`Program ${name} must belong to exactly one task.`);
       assignment.set(name, task.name);
-      const fn = functions.get(program.entry);
-      if (!fn) throw new Error("Verified core has a missing entry.");
-      const host =
-        program.background &&
-        core.variables.find(
-          (item) =>
-            item.name === program.background?.worker &&
-            item.span.file === fn.span.file &&
-            blockRuntimes.get(item.type) === "backgroundHost",
-        );
-      for (const id of accessedStorage(fn, core, host ? host.id : undefined)) {
-        const item = globals.get(id);
-        if (!item || item.storage === "constant") continue;
-        if (blockRuntimes.get(item.type) === "mailbox") continue;
-        const ownsWorker =
-          program.background?.worker === item.name && item.span.file === fn.span.file;
-        if (program.background && (!ownsWorker || item.id === host?.id))
-          report(
-            `Background task ${program.name} accesses scan-owned storage ${item.name}; pass value snapshots through the mailbox.`,
-            item.span,
-          );
-        const owner = stateOwners.get(id);
-        if (owner && owner !== task.name)
-          report(
-            `Storage ${item.name} is shared across cyclic tasks ${owner} and ${task.name}.`,
-            item.span,
-          );
-        stateOwners.set(id, task.name);
-      }
+      checkOwnership(task.name, program);
     }
   }
   for (const name of programs.keys())

package/backends/codesys/task-access.ts

@@ -4,9 +4,86 @@ import type {
   CoreFunction,
   CorePath,
   CoreStatement,
+  PlcProgram,
+  SourceSpan,
+  Task,
   VerifiedCoreModule,
 } from "@tsplc/compiler/ir";
 
+type Report = (message: string, span?: SourceSpan) => void;
+
+export function schedulePrograms(
+  core: VerifiedCoreModule,
+  tasks: readonly Task[],
+  report: Report,
+): readonly Task[] {
+  const background = new Map<string, Task & { programs: string[] }>();
+  for (const program of core.programs) {
+    if (!program.background) continue;
+    const { priority, intervalNanoseconds } = program.background;
+    const name = `TsplcBackground_${priority}_${BigInt(intervalNanoseconds) / 1_000_000n}`;
+    const existing = background.get(name);
+    if (existing) {
+      existing.programs.push(program.name);
+      continue;
+    }
+    background.set(name, {
+      name,
+      priority,
+      intervalNanoseconds,
+      programs: [program.name],
+    });
+  }
+  return appendContinuations(core, [...tasks, ...background.values()], report);
+}
+
+/** The generated worker may enter its host, and only mailbox roots are shared between tasks. */
+export function taskStorageOwnership(
+  core: VerifiedCoreModule,
+  report: Report,
+): (task: string, program: PlcProgram) => void {
+  const owners = new Map<string, string>();
+  const globals = new Map(core.variables.map((item) => [item.id, item]));
+  const functions = new Map(core.functions.map((item) => [item.id, item]));
+  const blocks = new Map(core.blocks.map((block) => [block.id, block.runtime?.kind]));
+  const runtimes = new Map(
+    core.types.flatMap((type) =>
+      type.kind === "block" ? [[type.id, blocks.get(type.block)] as const] : [],
+    ),
+  );
+
+  return (task, program) => {
+    const fn = functions.get(program.entry);
+    if (!fn) throw new Error("Verified core has a missing entry.");
+    const worker = program.background?.worker;
+    const host =
+      worker &&
+      core.variables.find(
+        (item) =>
+          item.name === worker &&
+          item.span.file === fn.span.file &&
+          runtimes.get(item.type) === "backgroundHost",
+      );
+    for (const id of accessedStorage(fn, core, host ? host.id : undefined)) {
+      const item = globals.get(id);
+      if (!item || item.storage === "constant" || runtimes.get(item.type) === "mailbox") continue;
+      const ownsWorker = worker === item.name && item.span.file === fn.span.file;
+      if (program.background && (!ownsWorker || (host && item.id === host.id)))
+        report(
+          `Background task ${program.name} accesses scan-owned storage ${item.name}; pass value snapshots through the mailbox.`,
+          item.span,
+        );
+      const owner = owners.get(id);
+      if (owner && owner !== task)
+        report(
+          `Storage ${item.name} is shared across cyclic tasks ${owner} and ${task}.`,
+          item.span,
+        );
+      owners.set(id, task);
+    }
+  };
+}
+
 // 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(
@@ -116,3 +193,51 @@ export function accessedStorage(
   body(fn.body);
   return result;
 }
+
+/** Detached continuations run after their caller programs in the same cyclic task. */
+function appendContinuations(
+  core: VerifiedCoreModule,
+  tasks: readonly Task[],
+  report: Report,
+): readonly Task[] {
+  const continuations = core.programs.flatMap((program) =>
+    program.continuation ? [{ name: program.name, scope: program.continuation }] : [],
+  );
+  if (!continuations.length) return tasks;
+
+  const programs = new Map(core.programs.map((program) => [program.name, program]));
+  const functions = new Map(core.functions.map((routine) => [routine.id, routine]));
+  const placements = tasks.map((task): { task: Task; roots: Set<string>; additions: string[] } => {
+    const roots = new Set<string>();
+    for (const name of task.programs) {
+      const program = programs.get(name);
+      if (!program || program.background) continue;
+      const entry = functions.get(program.entry);
+      if (entry) for (const id of accessedStorage(entry, core)) roots.add(id);
+    }
+    return { task, roots, additions: [] };
+  });
+  for (const { name, scope } of continuations) {
+    const root = core.variables.find(
+      (variable) => variable.name === scope.instance && variable.span.file === scope.file,
+    );
+    if (!root) {
+      report(`Missing continuation owner ${scope.instance}.`);
+      continue;
+    }
+    const owners = placements.filter(({ roots }) => roots.has(root.id));
+    const [owner] = owners;
+    if (!owner || owners.length !== 1) {
+      report(
+        `Continuation owner ${scope.instance} must belong to exactly one caller task.`,
+        root.span,
+      );
+      continue;
+    }
+    owner.additions.push(name);
+  }
+  return placements.map(({ task, additions }) => ({
+    ...task,
+    programs: task.programs.concat(additions),
+  }));
+}

package/dist/cli.js

@@ -654,6 +654,13 @@ var askCredentials = async () => ({
   password: await askSecret("Controller password: ")
 });
 var progress = (message) => console.log(`  ${message}`);
+var timedProgress = () => {
+  const start = Date.now();
+  return (message) => {
+    const seconds = Math.round((Date.now() - start) / 1000);
+    progress(`${Math.floor(seconds / 60)}:${String(seconds % 60).padStart(2, "0")} ${message}`);
+  };
+};
 var connect = () => {
   const environment = z.object({
     TSPLC_AGENT_URL: z.url({
@@ -761,9 +768,11 @@ var deploy = async (agent, file, loaded, flags) => {
     throw new Error("A login is open; log out before deploying: tsplc logout");
   const target = !status.target || flags.select ? await selectTarget(agent) : status.target;
   console.log(`Building the release for ${target.host}…`);
+  const building = timedProgress();
   const { release, diagnostics } = await prepareRelease(file, loaded, flags);
   if (!release)
     return { diagnostics };
+  building("Built");
   if (flags.download && !await confirm("A full download stops the running application while it loads. Continue?", flags))
     throw new Error("Cancelled.");
   const credentials = await askCredentials();
@@ -773,12 +782,14 @@ var deploy = async (agent, file, loaded, flags) => {
     initializeUser: flags["initialize-user"] ?? false
   };
   console.log(release.manifest.server ? "Deploying the server and the program…" : "Deploying the program…");
+  const deploying = timedProgress();
+  deploying("Uploading");
   try {
-    return await agent.deploy(release, settings, progress);
+    return await agent.deploy(release, settings, deploying);
   } catch (error) {
     if (!(error instanceof AgentOperationError && error.downloadRequired) || !await confirm(`${error.message}. A full download stops the running application while it loads. Download now?`, flags))
       throw error;
-    return agent.deploy(release, { ...settings, download: true }, progress);
+    return agent.deploy(release, { ...settings, download: true }, timedProgress());
   }
 };
 var ensureLogin = async (agent) => {
@@ -1383,5 +1394,5 @@ try {
   }
 }
 
-//# debugId=4A2A7CEF65387D0264756E2164756E21
+//# debugId=3D22720924D3B22B64756E2164756E21
 //# sourceMappingURL=cli.js.map