@fairfox/polly 0.14.1 → 0.15.0

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

@@ -3419,21 +3419,45 @@ class HandlerExtractor {
     const messageTypes = new Set;
     const invalidMessageTypes = new Set;
     const stateConstraints = [];
+    const verifiedStates = [];
     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);
+      this.analyzeFileAndImports(entryPoint, handlers, messageTypes, invalidMessageTypes, stateConstraints, verifiedStates);
+    }
+    if (verifiedStates.length > 0) {
+      if (process.env["POLLY_DEBUG"]) {
+        console.log(`[DEBUG] Found ${verifiedStates.length} verified state(s), scanning for mutating functions...`);
+      }
+      for (const filePath of this.analyzedFiles) {
+        const sourceFile = this.project.getSourceFile(filePath);
+        if (!sourceFile)
+          continue;
+        const mutatingHandlers = this.findStateMutatingFunctions(sourceFile, verifiedStates);
+        for (const handler of mutatingHandlers) {
+          const exists = handlers.some((h) => h.messageType === handler.messageType && h.location.file === handler.location.file);
+          if (!exists) {
+            handlers.push(handler);
+            if (this.isValidTLAIdentifier(handler.messageType)) {
+              messageTypes.add(handler.messageType);
+            } else {
+              invalidMessageTypes.add(handler.messageType);
+            }
+          }
+        }
+      }
     }
     this.debugLogExtractionResults(handlers.length, invalidMessageTypes.size);
     this.debugLogAnalysisStats(allSourceFiles.length, entryPoints.length);
     return {
       handlers,
       messageTypes,
-      stateConstraints
+      stateConstraints,
+      verifiedStates
     };
   }
-  analyzeFileAndImports(sourceFile, handlers, messageTypes, invalidMessageTypes, stateConstraints) {
+  analyzeFileAndImports(sourceFile, handlers, messageTypes, invalidMessageTypes, stateConstraints, verifiedStates) {
     const filePath = sourceFile.getFilePath();
     if (this.analyzedFiles.has(filePath)) {
       return;
@@ -3447,6 +3471,8 @@ class HandlerExtractor {
     this.categorizeHandlerMessageTypes(fileHandlers, messageTypes, invalidMessageTypes);
     const fileConstraints = this.extractStateConstraintsFromFile(sourceFile);
     stateConstraints.push(...fileConstraints);
+    const fileVerifiedStates = this.extractVerifiedStatesFromFile(sourceFile);
+    verifiedStates.push(...fileVerifiedStates);
     const importDeclarations = sourceFile.getImportDeclarations();
     for (const importDecl of importDeclarations) {
       const importedFile = importDecl.getModuleSpecifierSourceFile();
@@ -3458,7 +3484,7 @@ class HandlerExtractor {
           }
           continue;
         }
-        this.analyzeFileAndImports(importedFile, handlers, messageTypes, invalidMessageTypes, stateConstraints);
+        this.analyzeFileAndImports(importedFile, handlers, messageTypes, invalidMessageTypes, stateConstraints, verifiedStates);
       } else if (process.env["POLLY_DEBUG"]) {
         const specifier = importDecl.getModuleSpecifierValue();
         if (!specifier.startsWith("node:") && !this.isNodeModuleImport(specifier)) {
@@ -3667,7 +3693,7 @@ class HandlerExtractor {
       return;
     }
     const valueMatch = fieldPath.match(/\.value\.(.+)$/);
-    if (valueMatch && valueMatch[1]) {
+    if (valueMatch?.[1]) {
       const field = valueMatch[1];
       const value = this.extractValue(right);
       if (value !== undefined) {
@@ -3725,7 +3751,7 @@ class HandlerExtractor {
       return fieldPath.substring(6);
     }
     const valueMatch = fieldPath.match(/\.value\.(.+)$/);
-    if (valueMatch && valueMatch[1]) {
+    if (valueMatch?.[1]) {
       return valueMatch[1];
     }
     return null;
@@ -4533,6 +4559,205 @@ class HandlerExtractor {
     }
     return results;
   }
+  extractVerifiedStatesFromFile(sourceFile) {
+    const verifiedStates = [];
+    const filePath = sourceFile.getFilePath();
+    sourceFile.forEachDescendant((node) => {
+      if (!Node2.isCallExpression(node))
+        return;
+      const stateInfo = this.recognizeVerifiedStateCall(node, filePath);
+      if (stateInfo) {
+        verifiedStates.push(stateInfo);
+      }
+    });
+    return verifiedStates;
+  }
+  recognizeVerifiedStateCall(node, filePath) {
+    if (!Node2.isCallExpression(node))
+      return null;
+    const expression = node.getExpression();
+    if (!Node2.isIdentifier(expression))
+      return null;
+    const funcName = expression.getText();
+    if (!["$sharedState", "$syncedState", "$persistedState"].includes(funcName)) {
+      return null;
+    }
+    const args = node.getArguments();
+    if (args.length < 2)
+      return null;
+    const optionsArg = args[2];
+    if (!optionsArg || !this.hasVerifyTrue(optionsArg))
+      return null;
+    const keyArg = args[0];
+    if (!keyArg || !Node2.isStringLiteral(keyArg))
+      return null;
+    const key = keyArg.getLiteralValue();
+    const variableName = this.getVariableNameFromParent(node) || key;
+    const initialValueArg = args[1];
+    const fields = initialValueArg ? this.extractFieldNames(initialValueArg) : [];
+    if (process.env["POLLY_DEBUG"]) {
+      console.log(`[DEBUG] Found verified state: ${variableName} (key: "${key}") with fields: [${fields.join(", ")}]`);
+    }
+    return {
+      key,
+      variableName,
+      filePath,
+      line: node.getStartLineNumber(),
+      fields
+    };
+  }
+  hasVerifyTrue(optionsNode) {
+    if (!Node2.isObjectLiteralExpression(optionsNode))
+      return false;
+    for (const prop of optionsNode.getProperties()) {
+      if (!Node2.isPropertyAssignment(prop))
+        continue;
+      const name = prop.getName();
+      if (name !== "verify")
+        continue;
+      const initializer = prop.getInitializer();
+      if (initializer && initializer.getKind() === SyntaxKind.TrueKeyword) {
+        return true;
+      }
+    }
+    return false;
+  }
+  getVariableNameFromParent(node) {
+    const parent = node.getParent();
+    if (Node2.isVariableDeclaration(parent)) {
+      return parent.getName();
+    }
+    return null;
+  }
+  extractFieldNames(node) {
+    const fields = [];
+    if (Node2.isObjectLiteralExpression(node)) {
+      for (const prop of node.getProperties()) {
+        if (Node2.isPropertyAssignment(prop) || Node2.isShorthandPropertyAssignment(prop)) {
+          fields.push(prop.getName());
+        }
+      }
+    } else if (Node2.isIdentifier(node)) {
+      const definitions = node.getDefinitionNodes();
+      for (const def of definitions) {
+        if (Node2.isVariableDeclaration(def)) {
+          const initializer = def.getInitializer();
+          if (initializer && Node2.isObjectLiteralExpression(initializer)) {
+            return this.extractFieldNames(initializer);
+          }
+        }
+      }
+    }
+    return fields;
+  }
+  findStateMutatingFunctions(sourceFile, verifiedStates) {
+    const handlers = [];
+    const stateVarNames = new Set(verifiedStates.map((s) => s.variableName));
+    const filePath = sourceFile.getFilePath();
+    const context = this.inferContext(filePath);
+    for (const func of sourceFile.getFunctions()) {
+      if (!func.isExported())
+        continue;
+      const funcName = func.getName();
+      if (!funcName)
+        continue;
+      const assignments = this.findStateMutationsInFunction(func, stateVarNames);
+      if (assignments.length === 0)
+        continue;
+      const preconditions = [];
+      const postconditions = [];
+      this.extractVerificationConditions(func, preconditions, postconditions);
+      const messageType = this.functionNameToMessageType(funcName);
+      if (process.env["POLLY_DEBUG"]) {
+        console.log(`[DEBUG] Found state-mutating function: ${funcName} → ${messageType} ` + `(${assignments.length} assignments, ${preconditions.length} preconditions, ${postconditions.length} postconditions)`);
+      }
+      handlers.push({
+        messageType,
+        node: context,
+        assignments,
+        preconditions,
+        postconditions,
+        location: {
+          file: filePath,
+          line: func.getStartLineNumber()
+        }
+      });
+    }
+    for (const varStmt of sourceFile.getVariableStatements()) {
+      if (!varStmt.isExported())
+        continue;
+      for (const decl of varStmt.getDeclarations()) {
+        const initializer = decl.getInitializer();
+        if (!initializer)
+          continue;
+        if (!Node2.isArrowFunction(initializer) && !Node2.isFunctionExpression(initializer))
+          continue;
+        const funcName = decl.getName();
+        if (!funcName)
+          continue;
+        const assignments = this.findStateMutationsInFunction(initializer, stateVarNames);
+        if (assignments.length === 0)
+          continue;
+        const preconditions = [];
+        const postconditions = [];
+        this.extractVerificationConditions(initializer, preconditions, postconditions);
+        const messageType = this.functionNameToMessageType(funcName);
+        if (process.env["POLLY_DEBUG"]) {
+          console.log(`[DEBUG] Found state-mutating arrow function: ${funcName} → ${messageType}`);
+        }
+        handlers.push({
+          messageType,
+          node: context,
+          assignments,
+          preconditions,
+          postconditions,
+          location: {
+            file: filePath,
+            line: decl.getStartLineNumber()
+          }
+        });
+      }
+    }
+    return handlers;
+  }
+  findStateMutationsInFunction(func, stateVarNames) {
+    const mutations = [];
+    func.forEachDescendant((node) => {
+      if (!Node2.isBinaryExpression(node))
+        return;
+      const operator = node.getOperatorToken().getText();
+      if (operator !== "=")
+        return;
+      const left = node.getLeft();
+      if (!Node2.isPropertyAccessExpression(left))
+        return;
+      const path2 = this.getPropertyPath(left);
+      for (const varName of stateVarNames) {
+        if (path2 === `${varName}.value`) {
+          const right = node.getRight();
+          if (Node2.isObjectLiteralExpression(right)) {
+            this.extractObjectLiteralAssignments(right, mutations);
+          }
+          break;
+        }
+        const fieldPrefix = `${varName}.value.`;
+        if (path2.startsWith(fieldPrefix)) {
+          const field = path2.substring(fieldPrefix.length);
+          const value = this.extractValue(node.getRight());
+          mutations.push({ field, value: value ?? "@" });
+          break;
+        }
+      }
+    });
+    return mutations;
+  }
+  functionNameToMessageType(funcName) {
+    let name = funcName.replace(/^handle/, "").replace(/^on/, "").replace(/^set/, "Set").replace(/^update/, "Update").replace(/^do/, "");
+    if (name.length > 0) {
+      name = name.charAt(0).toUpperCase() + name.slice(1);
+    }
+    return name || funcName;
+  }
 }
 
 // tools/analysis/src/extract/types.ts
@@ -5434,4 +5659,4 @@ main().catch((error) => {
   process.exit(1);
 });
 
-//# debugId=6B12EC08F58C418A64756E2164756E21
+//# debugId=B1C82DC4E0975F9164756E2164756E21