@fairfox/polly 0.18.0 → 0.20.0

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

@@ -1784,12 +1784,13 @@ class HandlerExtractor {
     const stateConstraints = [];
     const globalStateConstraints = [];
     const verifiedStates = [];
+    const resources = [];
     this.warnings = [];
     const allSourceFiles = this.project.getSourceFiles();
     const entryPoints = allSourceFiles.filter((f) => this.isWithinPackage(f.getFilePath()));
     this.debugLogSourceFiles(allSourceFiles, entryPoints);
     for (const entryPoint of entryPoints) {
-      this.analyzeFileAndImports(entryPoint, handlers, messageTypes, invalidMessageTypes, stateConstraints, globalStateConstraints, verifiedStates);
+      this.analyzeFileAndImports(entryPoint, handlers, messageTypes, invalidMessageTypes, stateConstraints, globalStateConstraints, verifiedStates, resources);
     }
     if (verifiedStates.length > 0) {
       if (process.env["POLLY_DEBUG"]) {
@@ -1821,10 +1822,11 @@ class HandlerExtractor {
       stateConstraints,
       globalStateConstraints,
       verifiedStates,
+      resources,
       warnings: this.warnings
     };
   }
-  analyzeFileAndImports(sourceFile, handlers, messageTypes, invalidMessageTypes, stateConstraints, globalStateConstraints, verifiedStates) {
+  analyzeFileAndImports(sourceFile, handlers, messageTypes, invalidMessageTypes, stateConstraints, globalStateConstraints, verifiedStates, resources) {
     const filePath = sourceFile.getFilePath();
     if (this.analyzedFiles.has(filePath)) {
       return;
@@ -1842,6 +1844,20 @@ class HandlerExtractor {
     globalStateConstraints.push(...fileGlobalConstraints);
     const fileVerifiedStates = this.extractVerifiedStatesFromFile(sourceFile);
     verifiedStates.push(...fileVerifiedStates);
+    const fileResources = this.extractResourcesFromFile(sourceFile, filePath);
+    for (const resource of fileResources) {
+      resources.push(resource);
+      const context = this.inferContext(filePath);
+      const syntheticHandlers = this.createResourceHandlers(resource, context);
+      for (const handler of syntheticHandlers) {
+        handlers.push(handler);
+        if (this.isValidTLAIdentifier(handler.messageType)) {
+          messageTypes.add(handler.messageType);
+        } else {
+          invalidMessageTypes.add(handler.messageType);
+        }
+      }
+    }
     const importDeclarations = sourceFile.getImportDeclarations();
     for (const importDecl of importDeclarations) {
       const importedFile = importDecl.getModuleSpecifierSourceFile();
@@ -1853,7 +1869,7 @@ class HandlerExtractor {
           }
           continue;
         }
-        this.analyzeFileAndImports(importedFile, handlers, messageTypes, invalidMessageTypes, stateConstraints, globalStateConstraints, verifiedStates);
+        this.analyzeFileAndImports(importedFile, handlers, messageTypes, invalidMessageTypes, stateConstraints, globalStateConstraints, verifiedStates, resources);
       } else if (process.env["POLLY_DEBUG"]) {
         const specifier = importDecl.getModuleSpecifierValue();
         if (!specifier.startsWith("node:") && !this.isNodeModuleImport(specifier)) {
@@ -2212,7 +2228,9 @@ class HandlerExtractor {
       return;
     if (this.tryExtractSetConstructorPattern(fieldPath, right, assignments))
       return;
-    this.tryExtractMapConstructorPattern(fieldPath, right, assignments);
+    if (this.tryExtractMapConstructorPattern(fieldPath, right, assignments))
+      return;
+    this.tryExtractSignalDirectValuePattern(fieldPath, right, assignments);
   }
   tryExtractStateFieldPattern(fieldPath, right, assignments) {
     if (!fieldPath.startsWith("state."))
@@ -2331,6 +2349,25 @@ class HandlerExtractor {
     }
     return true;
   }
+  tryExtractSignalDirectValuePattern(fieldPath, right, assignments) {
+    if (!fieldPath.endsWith(".value"))
+      return false;
+    const signalName = fieldPath.slice(0, -6);
+    const literalValue = this.extractValue(right);
+    if (literalValue !== undefined) {
+      assignments.push({ field: signalName, value: literalValue });
+      return true;
+    }
+    if (Node4.isPropertyAccessExpression(right)) {
+      const rightPath = this.getPropertyPath(right);
+      const parts = rightPath.split(".");
+      if (parts.length === 2 && parts[0] !== undefined && parts[1] !== undefined && this.currentFunctionParams.includes(parts[0])) {
+        assignments.push({ field: signalName, value: `param:${parts[1]}` });
+        return true;
+      }
+    }
+    return false;
+  }
   extractSetOperation(newExpr, fieldPath, signalName) {
     const args = newExpr.getArguments();
     if (args.length === 0) {
@@ -2447,11 +2484,11 @@ class HandlerExtractor {
       return null;
     switch (methodName) {
       case "filter":
-        return { field: signalName, value: "SelectSeq(@, LAMBDA t: TRUE)" };
+        return { field: signalName, value: "NDET:FILTER" };
       case "map":
-        return { field: signalName, value: "[i \\in DOMAIN @ |-> @[i]]" };
+        return { field: signalName, value: "NDET:MAP" };
       case "slice":
-        return { field: signalName, value: "SubSeq(@, 1, Len(@))" };
+        return { field: signalName, value: "NDET:FILTER" };
       case "concat":
         return { field: signalName, value: "@ \\o <<payload>>" };
       case "reverse":
@@ -3722,6 +3759,125 @@ class HandlerExtractor {
     }
     return name || funcName;
   }
+  extractResourcesFromFile(sourceFile, filePath) {
+    const resources = [];
+    sourceFile.forEachDescendant((node) => {
+      if (!Node4.isCallExpression(node))
+        return;
+      const resource = this.extractResourcePattern(node, filePath);
+      if (resource) {
+        resources.push(resource);
+      }
+    });
+    return resources;
+  }
+  extractResourcePattern(node, filePath) {
+    const expression = node.getExpression();
+    if (!Node4.isIdentifier(expression))
+      return null;
+    if (expression.getText() !== "$resource")
+      return null;
+    const args = node.getArguments();
+    if (args.length < 2)
+      return null;
+    const nameArg = args[0];
+    if (!nameArg || !Node4.isStringLiteral(nameArg))
+      return null;
+    const name = nameArg.getLiteralValue();
+    const optionsArg = args[1];
+    if (!optionsArg || !Node4.isObjectLiteralExpression(optionsArg))
+      return null;
+    const sourceSignals = this.extractResourceSourceReads(optionsArg);
+    const variableName = this.getVariableNameFromParent(node) || name;
+    if (process.env["POLLY_DEBUG"]) {
+      console.log(`[DEBUG] Found $resource: ${variableName} (name: "${name}") with source signals: [${sourceSignals.join(", ")}]`);
+    }
+    return {
+      name,
+      variableName,
+      filePath,
+      line: node.getStartLineNumber(),
+      sourceSignals
+    };
+  }
+  extractResourceSourceReads(optionsObj) {
+    const signals = [];
+    const sourceProp = optionsObj.getProperty("source");
+    if (!sourceProp || !Node4.isPropertyAssignment(sourceProp))
+      return signals;
+    const sourceInit = sourceProp.getInitializer();
+    if (!sourceInit)
+      return signals;
+    sourceInit.forEachDescendant((node) => {
+      if (!Node4.isPropertyAccessExpression(node))
+        return;
+      const text = node.getText();
+      const match = text.match(/^(\w+)\.value(?:\.(\w+))?$/);
+      if (match) {
+        const signalName = match[1];
+        const fieldName = match[2];
+        if (fieldName) {
+          signals.push(`${signalName}_${fieldName}`);
+        } else {
+          signals.push(signalName);
+        }
+      }
+    });
+    return signals;
+  }
+  createResourceHandlers(resource, context) {
+    const { name, filePath, line } = resource;
+    const location = { file: filePath, line };
+    const fetchStart = {
+      messageType: `${name}_FetchStart`,
+      node: context,
+      assignments: [
+        { field: `${name}_status`, value: "loading" },
+        { field: `${name}_error`, value: false }
+      ],
+      preconditions: [
+        {
+          expression: `${name}_status !== "loading"`,
+          location: { line, column: 0 }
+        }
+      ],
+      postconditions: [],
+      location
+    };
+    const fetchSuccess = {
+      messageType: `${name}_FetchSuccess`,
+      node: context,
+      assignments: [
+        { field: `${name}_status`, value: "success" },
+        { field: `${name}_error`, value: false }
+      ],
+      preconditions: [
+        {
+          expression: `${name}_status === "loading"`,
+          location: { line, column: 0 }
+        }
+      ],
+      postconditions: [],
+      location
+    };
+    const fetchError = {
+      messageType: `${name}_FetchError`,
+      node: context,
+      assignments: [
+        { field: `${name}_status`, value: "error" },
+        { field: `${name}_error`, value: true }
+      ],
+      preconditions: [
+        {
+          expression: `${name}_status === "loading"`,
+          location: { line, column: 0 }
+        }
+      ],
+      postconditions: [],
+      location
+    };
+    return [fetchStart, fetchSuccess, fetchError];
+  }
 }
 
 // tools/analysis/src/extract/integrations.ts
@@ -6052,4 +6208,4 @@ main().catch((_error) => {
   process.exit(1);
 });
 
-//# debugId=345DE519CB00B03D64756E2164756E21
+//# debugId=877A170E241AB38F64756E2164756E21