@fairfox/polly 0.85.2 → 0.87.0

package/dist/tools/verify/src/cli.js

@@ -504,150 +504,11 @@ var init_precondition_locality = __esm(() => {
 });
 
 // tools/verify/src/codegen/invariants.ts
-import { Node as Node3, Project as Project3 } from "ts-morph";
-
-class InvariantExtractor {
-  warnings = [];
-  extractInvariants(projectPath) {
-    const project = new Project3({
-      tsConfigFilePath: `${projectPath}/tsconfig.json`,
-      skipAddingFilesFromTsConfig: false
-    });
-    const invariants = [];
-    for (const sourceFile of project.getSourceFiles()) {
-      if (sourceFile.getFilePath().includes("node_modules") || sourceFile.getFilePath().includes(".test.") || sourceFile.getFilePath().includes(".spec.")) {
-        continue;
-      }
-      invariants.push(...this.extractFromSourceFile(sourceFile));
-    }
-    return {
-      invariants,
-      warnings: this.warnings
-    };
-  }
-  extractFromAnalysis(_analysis) {
-    return {
-      invariants: [],
-      warnings: []
-    };
-  }
-  extractFromSourceFile(sourceFile) {
-    const invariants = [];
-    sourceFile.forEachDescendant((node) => {
-      this.processNodeJSDocs(node, sourceFile, invariants);
-    });
-    return invariants;
-  }
-  processNodeJSDocs(node, sourceFile, invariants) {
-    const jsDocs = this.getJsDocComments(node);
-    for (const jsDoc of jsDocs) {
-      this.processJSDocTags(jsDoc, sourceFile, node, invariants);
-    }
-  }
-  processJSDocTags(jsDoc, sourceFile, node, invariants) {
-    for (const tag of jsDoc.getTags()) {
-      this.processJSDocTag(tag, sourceFile, node, invariants);
-    }
-  }
-  processJSDocTag(tag, sourceFile, node, invariants) {
-    const tagName = tag.getTagName();
-    const text = tag.getComment();
-    if (typeof text !== "string" || !text.trim()) {
-      return;
-    }
-    const trimmedText = text.trim();
-    if (tagName === "invariant") {
-      invariants.push(this.createInvariant(trimmedText, "invariant", sourceFile, node));
-    } else if (tagName === "ensures") {
-      invariants.push(this.createInvariant(trimmedText, "post-condition", sourceFile, node));
-    } else if (tagName === "requires") {
-      invariants.push(this.createInvariant(trimmedText, "pre-condition", sourceFile, node));
-    }
-  }
-  getJsDocComments(node) {
-    if (Node3.isJSDocable(node)) {
-      return node.getJsDocs();
-    }
+function describe(description) {
+  if (!description?.trim())
     return [];
-  }
-  createInvariant(expression, type, sourceFile, node) {
-    const description = this.extractDescription(node, expression);
-    const name = this.generateInvariantName(expression, type);
-    return {
-      name,
-      description,
-      expression,
-      location: {
-        file: sourceFile.getFilePath(),
-        line: node.getStartLineNumber()
-      }
-    };
-  }
-  extractDescription(node, expression) {
-    if (Node3.isJSDocable(node)) {
-      const jsDocs = node.getJsDocs();
-      for (const jsDoc of jsDocs) {
-        const desc = jsDoc.getDescription();
-        if (desc?.trim()) {
-          return desc.trim();
-        }
-      }
-    }
-    return `Invariant: ${expression}`;
-  }
-  generateInvariantName(expression, type) {
-    const fieldMatches = expression.match(/state\.(\w+)/g);
-    if (!fieldMatches || fieldMatches.length === 0) {
-      return this.generateGenericInvariantName(type);
-    }
-    const fieldName = fieldMatches[0]?.replace("state.", "");
-    const constraintSuffix = this.determineConstraintSuffix(expression);
-    const capitalizedField = fieldName.charAt(0).toUpperCase() + fieldName.slice(1);
-    const prefix = this.getInvariantPrefix(type);
-    return `${prefix}${capitalizedField}${constraintSuffix}`;
-  }
-  generateGenericInvariantName(type) {
-    const prefix = this.getInvariantPrefix(type);
-    return `${prefix}Invariant${Math.random().toString(36).substring(2, 7)}`;
-  }
-  determineConstraintSuffix(expression) {
-    if (expression.includes("<="))
-      return "MaxValue";
-    if (expression.includes(">="))
-      return "MinValue";
-    if (expression.includes("===") || expression.includes("=="))
-      return "Equals";
-    if (expression.includes("!==") || expression.includes("!="))
-      return "NotEquals";
-    if (expression.includes("<"))
-      return "LessThan";
-    if (expression.includes(">"))
-      return "GreaterThan";
-    return "Check";
-  }
-  getInvariantPrefix(type) {
-    if (type === "pre-condition")
-      return "Pre";
-    if (type === "post-condition")
-      return "Post";
-    return "";
-  }
-  validateExpression(expression) {
-    if (expression.includes("eval(")) {
-      return { valid: false, error: "eval() not allowed in invariants" };
-    }
-    const openParens = (expression.match(/\(/g) || []).length;
-    const closeParens = (expression.match(/\)/g) || []).length;
-    if (openParens !== closeParens) {
-      return { valid: false, error: "Unbalanced parentheses" };
-    }
-    const openBrackets = (expression.match(/\[/g) || []).length;
-    const closeBrackets = (expression.match(/\]/g) || []).length;
-    if (openBrackets !== closeBrackets) {
-      return { valid: false, error: "Unbalanced brackets" };
-    }
-    return { valid: true };
-  }
+  return description.split(`
+`).map((line) => `\\* ${line.trimEnd()}`);
 }
 
 class InvariantGenerator {
@@ -660,8 +521,8 @@ class InvariantGenerator {
   }
   generateSingleInvariant(invariant, tsExpressionToTLA) {
     const lines = [];
-    if (invariant.description) {
-      lines.push(`\\* ${invariant.description}`);
+    for (const line of describe(invariant.description)) {
+      lines.push(line);
     }
     const tlaExpr = tsExpressionToTLA(invariant.expression);
     lines.push(`${invariant.name} ==`);
@@ -673,7 +534,6 @@ class InvariantGenerator {
     return invariants.map((inv) => `INVARIANT ${inv.name}`);
   }
 }
-var init_invariants = () => {};
 
 // tools/verify/src/codegen/temporal.ts
 class TemporalPropertyGenerator {
@@ -773,8 +633,8 @@ class TemporalTLAGenerator {
   }
   generateSingleProperty(prop) {
     const lines = [];
-    if (prop.description) {
-      lines.push(`\\* ${prop.description}`);
+    for (const line of describe(prop.description)) {
+      lines.push(line);
     }
     switch (prop.type) {
       case "eventually":
@@ -829,6 +689,7 @@ class TemporalTLAGenerator {
 `);
   }
 }
+var init_temporal = () => {};
 
 // tools/verify/src/codegen/tla.ts
 var exports_tla = {};
@@ -890,6 +751,7 @@ async function generateSubsystemTLA(_subsystemName, subsystem, config, analysis)
     ...config,
     state: filteredState,
     messages: filteredMessages,
+    liveness: subsystem.liveness ?? config.liveness,
     subsystems: undefined
   };
   if (filteredConfig.tier2?.temporalConstraints) {
@@ -917,7 +779,7 @@ async function generateSubsystemTLA(_subsystemName, subsystem, config, analysis)
 }
 var TLAValidationError, TLAGenerator;
 var init_tla = __esm(() => {
-  init_invariants();
+  init_temporal();
   TLAValidationError = class TLAValidationError extends Error {
     report;
     constructor(message, report) {
@@ -932,6 +794,7 @@ var init_tla = __esm(() => {
     indent = 0;
     extractedInvariants = [];
     temporalProperties = [];
+    livenessPropertyNames = [];
     symmetrySets = [];
     resolvedActionNames = new Map;
     paramDomains = new Map;
@@ -970,10 +833,10 @@ var init_tla = __esm(() => {
         }
       }
       this.validateInputs(config, analysis);
-      this.extractInvariantsIfEnabled();
       this.generateTemporalPropertiesIfEnabled(analysis);
       this.lines = [];
       this.indent = 0;
+      this.livenessPropertyNames = [];
       const spec = this.generateSpec(config, analysis);
       const cfg = this.generateConfig(config);
       if (!this.hasValidators()) {
@@ -985,19 +848,6 @@ var init_tla = __esm(() => {
     hasValidators() {
       return !!(this.options?.validator || this.options?.sanyRunner || this.options?.roundTripValidator);
     }
-    extractInvariantsIfEnabled() {
-      if (this.options?.enableInvariants && this.options.projectPath) {
-        const extractor = new InvariantExtractor;
-        const result = extractor.extractInvariants(this.options.projectPath);
-        this.extractedInvariants = result.invariants;
-        if (result.warnings.length > 0 && process.env["POLLY_DEBUG"]) {
-          console.log("[DEBUG] Invariant extraction warnings:");
-          for (const warning of result.warnings) {
-            console.log(`  - ${warning}`);
-          }
-        }
-      }
-    }
     generateTemporalPropertiesIfEnabled(analysis) {
       if (this.options?.enableTemporalProperties) {
         const generator = new TemporalPropertyGenerator;
@@ -1129,11 +979,12 @@ var init_tla = __esm(() => {
       this.addActions(config, analysis);
       this.addRouteWithHandlers(config, analysis);
       this.addNext(config, analysis);
-      this.addSpec();
+      this.addSpec(config, analysis);
       this.addInvariants(config, analysis);
       if (this.temporalProperties.length > 0) {
         this.addTemporalProperties();
       }
+      this.addLivenessProperties(config, analysis);
       this.line("=============================================================================");
       return this.lines.join(`
 `);
@@ -1230,7 +1081,7 @@ var init_tla = __esm(() => {
       }
     }
     addTemporalPropertiesSection(lines) {
-      if (this.temporalProperties.length === 0)
+      if (this.temporalProperties.length === 0 && this.livenessPropertyNames.length === 0)
         return;
       lines.push("");
       lines.push("\\* Temporal properties to check");
@@ -1238,6 +1089,9 @@ var init_tla = __esm(() => {
       for (const prop of this.temporalProperties) {
         lines.push(`  ${prop.name}`);
       }
+      for (const name of this.livenessPropertyNames) {
+        lines.push(`  ${name}`);
+      }
     }
     addConstraintSection(lines) {
       lines.push("");
@@ -2742,6 +2596,7 @@ var init_tla = __esm(() => {
       this.line("      /\\ routingDepth < 5");
       this.line("      /\\ \\E target \\in msg.targets :");
       this.line('            /\\ IF target \\in Contexts /\\ ports[target] = "connected"');
+      this.line("                  /\\ ENABLED StateTransition(target, msg.msgType)");
       this.line("               THEN \\* Successful delivery - route AND invoke handler");
       this.line(`                    /\\ messages' = [messages EXCEPT ![msgIndex].status = "delivered",`);
       this.line("                                                   ![msgIndex].deliveredTo = target]");
@@ -2751,7 +2606,7 @@ var init_tla = __esm(() => {
       this.line("                    /\\ time' = time + 1");
       this.line("                    /\\ \\E p \\in PayloadType : payload' = p  \\* Non-deterministic payload");
       this.line("                    /\\ StateTransition(target, msg.msgType)");
-      this.line("               ELSE \\* Port not connected - message fails");
+      this.line("               ELSE \\* Port not connected, or the handler refused it");
       this.line(`                    /\\ messages' = [messages EXCEPT ![msgIndex].status = "failed"]`);
       this.line("                    /\\ pendingRequests' = [id \\in DOMAIN pendingRequests \\ {msg.id} |->");
       this.line("                                           pendingRequests[id]]");
@@ -2802,9 +2657,50 @@ var init_tla = __esm(() => {
       this.indent--;
       this.line("");
     }
-    addSpec() {
+    livenessEnabled(config) {
+      return config.liveness === true;
+    }
+    routingIsReachable(analysis) {
+      return analysis.handlers.some((h) => this.canRepresentAsTLAAction(h.messageType));
+    }
+    addSpec(config, analysis) {
       this.line("\\* Specification");
-      this.line("UserSpec == UserInit /\\ [][UserNext]_allVars /\\ WF_allVars(UserNext)");
+      const liveness = this.livenessEnabled(config) && this.routingIsReachable(analysis);
+      if (!liveness) {
+        this.line("UserSpec == UserInit /\\ [][UserNext]_allVars /\\ WF_allVars(UserNext)");
+        this.line("");
+        return;
+      }
+      this.line("UserSpec ==");
+      this.indent++;
+      this.line("/\\ UserInit");
+      this.line("/\\ [][UserNext]_allVars");
+      this.line("/\\ WF_allVars(UserNext)");
+      this.line("/\\ \\A i \\in 1..MaxMessages : WF_allVars(UserRouteMessage(i))");
+      this.indent--;
+      this.line("");
+    }
+    addLivenessProperties(config, analysis) {
+      if (!this.livenessEnabled(config) || !this.routingIsReachable(analysis))
+        return;
+      const name = "NoMessageStaysPending";
+      this.livenessPropertyNames.push(name);
+      this.line("\\* =============================================================================");
+      this.line("\\* Liveness (polly#171)");
+      this.line("\\* =============================================================================");
+      this.line("");
+      this.line("\\* Every message that reaches the router is eventually resolved.");
+      this.line("\\* A requires() that does not hold marks the message failed rather than");
+      this.line("\\* leaving it pending for ever, so this is checkable.");
+      this.line(`${name} ==`);
+      this.indent++;
+      this.line("\\A i \\in 1..MaxMessages :");
+      this.indent++;
+      this.line('(Len(messages) >= i /\\ messages[i].status = "pending")');
+      this.line("~> (Len(messages) >= i");
+      this.line('    /\\ messages[i].status \\in {"delivered", "failed", "timeout"})');
+      this.indent--;
+      this.indent--;
       this.line("");
     }
     addInvariants(config, _analysis) {
@@ -2827,7 +2723,7 @@ var init_tla = __esm(() => {
         this.addCapabilityInvariants(config.capabilities);
       }
       if (this.extractedInvariants.length > 0) {
-        this.line("\\* Extracted invariants from code annotations");
+        this.line("\\* Synthesised invariants");
         this.line("");
         const invGenerator = new InvariantGenerator;
         const tlaInvariants = invGenerator.generateTLAInvariants(this.extractedInvariants, (expr) => this.tsExpressionToTLA(expr, false));
@@ -3612,14 +3508,62 @@ var init_witness2 = __esm(() => {
   ];
 });
 
+// tools/verify/src/runner/container-name.ts
+function mintContainerName(kind) {
+  counter += 1;
+  const unique = crypto.randomUUID().slice(0, 8);
+  return `${CONTAINER_NAME_PREFIX}${sanitizeKind(kind)}-${process.pid}-${counter}-${unique}`;
+}
+function sanitizeKind(kind) {
+  const cleaned = kind.replace(/[^a-zA-Z0-9_.-]/g, "-");
+  return cleaned.length > 0 ? cleaned : "run";
+}
+var CONTAINER_NAME_PREFIX = "polly-tla-", counter = 0;
+
 // tools/verify/src/runner/docker.ts
 var exports_docker = {};
 __export(exports_docker, {
-  DockerRunner: () => DockerRunner
+  DockerRunner: () => DockerRunner,
+  removeContainer: () => removeContainer,
+  sweepOrphanedContainers: () => sweepOrphanedContainers,
+  sweepOrphanedContainersOnce: () => sweepOrphanedContainersOnce
 });
-import { spawn } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import * as fs3 from "node:fs";
 import * as path4 from "node:path";
+function removeContainer(name) {
+  try {
+    spawnSync("docker", ["rm", "-f", name], { timeout: 1e4, stdio: "ignore" });
+  } catch {}
+}
+function sweepOrphanedContainersOnce() {
+  if (swept)
+    return [];
+  swept = true;
+  return sweepOrphanedContainers();
+}
+function sweepOrphanedContainers() {
+  try {
+    const listed = spawnSync("docker", [
+      "ps",
+      "--all",
+      "--filter",
+      "status=created",
+      "--filter",
+      `name=${CONTAINER_NAME_PREFIX}`,
+      "--format",
+      "{{.Names}}"
+    ], { timeout: 1e4, encoding: "utf8" });
+    const names = (listed.stdout ?? "").split(`
+`).map((line) => line.trim()).filter((line) => line.startsWith(CONTAINER_NAME_PREFIX));
+    for (const name of names) {
+      removeContainer(name);
+    }
+    return names;
+  } catch {
+    return [];
+  }
+}
 
 class DockerRunner {
   IMAGE_NAME = "polly-tla:latest";
@@ -3671,9 +3615,13 @@ class DockerRunner {
     if (fs3.existsSync(statesDir)) {
       fs3.rmSync(statesDir, { recursive: true, force: true });
     }
+    const containerName = mintContainerName("tlc");
+    sweepOrphanedContainersOnce();
     const args = [
       "run",
       "--rm",
+      "--name",
+      containerName,
       "-v",
       `${specDir}:/work`,
       this.IMAGE_NAME,
@@ -3689,7 +3637,8 @@ class DockerRunner {
     }
     args.push(`${specName}.tla`);
     const result = await this.runCommand("docker", args, {
-      timeout: options?.timeout
+      timeout: options?.timeout,
+      containerName
     });
     return this.parseTLCOutput(result);
   }
@@ -3772,7 +3721,10 @@ class DockerRunner {
       });
       const timeoutValue = options?.timeout ?? 0;
       const timeout = timeoutValue > 0 ? setTimeout(() => {
-        proc.kill();
+        proc.kill("SIGKILL");
+        if (options?.containerName) {
+          removeContainer(options.containerName);
+        }
         reject(new Error(`Command timed out after ${Math.floor(timeoutValue / 1000)}s. TLC was still making progress. Consider increasing the timeout or setting timeout: 0 for no timeout.`));
       }, timeoutValue) : null;
       proc.on("close", (exitCode) => {
@@ -3837,7 +3789,7 @@ class DockerRunner {
     });
   }
 }
-var __dirname = "/Users/AJT/projects/polly/packages/polly/tools/verify/src/runner";
+var __dirname = "/Users/AJT/projects/polly/packages/polly/tools/verify/src/runner", swept = false;
 var init_docker = () => {};
 
 // tools/verify/src/cli.ts
@@ -5164,7 +5116,8 @@ import { Project as Project2 } from "ts-morph";
 import {
   Node as Node2,
   Project,
-  SyntaxKind
+  SyntaxKind,
+  VariableDeclarationKind
 } from "ts-morph";
 
 // tools/analysis/src/extract/relationships.ts
@@ -6550,16 +6503,116 @@ class HandlerExtractor {
       return;
     }
     if (this.isTranslatableInitializer(initializer)) {
-      assignments.push({ field, value: `EXPR:${initializer.getText()}` });
+      const captured = this.resolveSignalAliases(this.unwrapParentheses(initializer));
+      assignments.push({ field, value: `EXPR:${captured}` });
       return;
     }
-    if (process.env["POLLY_DEBUG"]) {
-      const on = signalName ? ` on ${signalName}.value` : "";
-      console.log(`[WARN] dropped object-literal property '${name}'${on} — initializer kind ${initializer.getKindName()} is not translatable to TLA+`);
-    }
+    const on = signalName ? ` on ${signalName}.value` : "";
+    console.log(`[WARN] dropped object-literal property '${name}'${on} — initializer \`${initializer.getText().replace(/\s+/g, " ").slice(0, 80)}\` (${initializer.getKindName()}) is not translatable to TLA+`);
+  }
+  resolveSignalAliases(initializer) {
+    const aliases = this.collectSignalAliases(initializer);
+    if (aliases.size === 0)
+      return initializer.getText();
+    const base = initializer.getStart();
+    const edits = [];
+    const visit = (node) => {
+      if (!Node2.isPropertyAccessExpression(node))
+        return;
+      const target = node.getExpression();
+      if (!Node2.isIdentifier(target))
+        return;
+      const signal = aliases.get(target.getText());
+      if (!signal)
+        return;
+      edits.push({
+        start: target.getStart() - base,
+        end: target.getEnd() - base,
+        text: `${signal}.value`
+      });
+    };
+    visit(initializer);
+    initializer.forEachDescendant(visit);
+    if (edits.length === 0)
+      return initializer.getText();
+    let text = initializer.getText();
+    for (const edit of edits.sort((a, b) => b.start - a.start)) {
+      text = text.slice(0, edit.start) + edit.text + text.slice(edit.end);
+    }
+    return text;
+  }
+  collectSignalAliases(node) {
+    const aliases = new Map;
+    const fn = node.getFirstAncestor((a) => Node2.isArrowFunction(a) || Node2.isFunctionExpression(a) || Node2.isFunctionDeclaration(a));
+    if (!fn)
+      return aliases;
+    const reassigned = this.collectReassignedIdentifiers(fn);
+    fn.forEachDescendant((inner) => {
+      if (!Node2.isVariableDeclaration(inner))
+        return;
+      const binding = this.readSignalAliasBinding(inner);
+      if (!binding)
+        return;
+      if (aliases.has(binding.signal))
+        return;
+      if (reassigned.has(binding.alias))
+        return;
+      aliases.set(binding.alias, binding.signal);
+    });
+    return aliases;
+  }
+  collectReassignedIdentifiers(fn) {
+    const reassigned = new Set;
+    fn.forEachDescendant((inner) => {
+      if (!Node2.isBinaryExpression(inner))
+        return;
+      if (inner.getOperatorToken().getText() !== "=")
+        return;
+      const left = inner.getLeft();
+      if (Node2.isIdentifier(left))
+        reassigned.add(left.getText());
+    });
+    return reassigned;
+  }
+  readSignalAliasBinding(decl) {
+    const list = decl.getParent();
+    if (!Node2.isVariableDeclarationList(list))
+      return null;
+    if (list.getDeclarationKind() !== VariableDeclarationKind.Const)
+      return null;
+    const nameNode = decl.getNameNode();
+    if (!Node2.isIdentifier(nameNode))
+      return null;
+    const init = decl.getInitializer();
+    if (!init || !Node2.isPropertyAccessExpression(init))
+      return null;
+    if (init.getName() !== "value")
+      return null;
+    const target = init.getExpression();
+    if (!Node2.isIdentifier(target))
+      return null;
+    return { alias: nameNode.getText(), signal: target.getText() };
   }
   isTranslatableInitializer(node) {
-    return Node2.isBinaryExpression(node) || Node2.isPropertyAccessExpression(node) || Node2.isElementAccessExpression(node) || Node2.isPrefixUnaryExpression(node) || Node2.isPostfixUnaryExpression(node) || Node2.isParenthesizedExpression(node);
+    const kindAllowed = Node2.isBinaryExpression(node) || Node2.isPropertyAccessExpression(node) || Node2.isElementAccessExpression(node) || Node2.isPrefixUnaryExpression(node) || Node2.isPostfixUnaryExpression(node) || Node2.isParenthesizedExpression(node) || Node2.isConditionalExpression(node);
+    if (!kindAllowed)
+      return false;
+    if (this.containsComment(node))
+      return false;
+    if (node.getFirstDescendantByKind(SyntaxKind.CallExpression))
+      return false;
+    return this.unwrapParentheses(node).getFirstDescendantByKind(SyntaxKind.ConditionalExpression) === undefined;
+  }
+  unwrapParentheses(node) {
+    let current = node;
+    while (Node2.isParenthesizedExpression(current)) {
+      current = current.getExpression();
+    }
+    return current;
+  }
+  containsComment(node) {
+    const text = node.getText();
+    return text.includes("//") || text.includes("/*");
   }
   extractPayloadPropertyParam(initializer) {
     if (!Node2.isPropertyAccessExpression(initializer))
@@ -9587,4 +9640,4 @@ main().catch((error) => {
   process.exit(1);
 });
 
-//# debugId=82348038946F09C064756E2164756E21
+//# debugId=D4D47405397BD18D64756E2164756E21