@fairfox/polly 0.3.0 → 0.3.1

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

@@ -727,10 +727,12 @@ import { Project, SyntaxKind, Node } from "ts-morph";
 
 class HandlerExtractor {
   project;
+  typeGuardCache;
   constructor(tsConfigPath) {
     this.project = new Project({
       tsConfigFilePath: tsConfigPath
     });
+    this.typeGuardCache = new WeakMap;
   }
   extractHandlers() {
     const handlers = [];
@@ -773,6 +775,10 @@ class HandlerExtractor {
         const mapHandlers = this.extractHandlerMapPattern(node, context, filePath);
         handlers.push(...mapHandlers);
       }
+      if (Node.isIfStatement(node)) {
+        const typeGuardHandlers = this.extractTypeGuardHandlers(node, context, filePath);
+        handlers.push(...typeGuardHandlers);
+      }
     });
     return handlers;
   }
@@ -983,6 +989,113 @@ class HandlerExtractor {
     } catch (error) {}
     return handlers;
   }
+  extractTypeGuardHandlers(ifNode, context, filePath) {
+    const handlers = [];
+    try {
+      const sourceFile = ifNode.getSourceFile();
+      let typeGuards = this.typeGuardCache.get(sourceFile);
+      if (!typeGuards) {
+        typeGuards = this.findTypePredicateFunctions(sourceFile);
+        this.typeGuardCache.set(sourceFile, typeGuards);
+      }
+      if (typeGuards.size === 0) {
+        return handlers;
+      }
+      let currentIf = ifNode;
+      while (currentIf) {
+        const handler = this.extractHandlerFromIfClause(currentIf, typeGuards, context, filePath);
+        if (handler) {
+          handlers.push(handler);
+        }
+        const elseStatement = currentIf.getElseStatement();
+        if (elseStatement && Node.isIfStatement(elseStatement)) {
+          currentIf = elseStatement;
+        } else {
+          break;
+        }
+      }
+    } catch (error) {}
+    return handlers;
+  }
+  extractHandlerFromIfClause(ifNode, typeGuards, context, filePath) {
+    try {
+      const condition = ifNode.getExpression();
+      if (!Node.isCallExpression(condition)) {
+        return null;
+      }
+      const funcExpr = condition.getExpression();
+      let funcName;
+      if (Node.isIdentifier(funcExpr)) {
+        funcName = funcExpr.getText();
+      }
+      if (!funcName || !typeGuards.has(funcName)) {
+        return null;
+      }
+      const messageType = typeGuards.get(funcName);
+      const line = ifNode.getStartLineNumber();
+      return {
+        messageType,
+        node: context,
+        assignments: [],
+        preconditions: [],
+        postconditions: [],
+        location: { file: filePath, line }
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+  findTypePredicateFunctions(sourceFile) {
+    const typeGuards = new Map;
+    sourceFile.forEachDescendant((node) => {
+      if (Node.isFunctionDeclaration(node) || Node.isFunctionExpression(node) || Node.isArrowFunction(node)) {
+        const returnType = node.getReturnType();
+        const returnTypeText = returnType.getText();
+        if (/is\s+\w+/.test(returnTypeText)) {
+          let functionName;
+          if (Node.isFunctionDeclaration(node)) {
+            functionName = node.getName();
+          } else if (Node.isFunctionExpression(node)) {
+            const parent = node.getParent();
+            if (Node.isVariableDeclaration(parent)) {
+              functionName = parent.getName();
+            }
+          } else if (Node.isArrowFunction(node)) {
+            const parent = node.getParent();
+            if (Node.isVariableDeclaration(parent)) {
+              functionName = parent.getName();
+            }
+          }
+          if (functionName) {
+            let messageType = null;
+            const typeMatch = returnTypeText.match(/is\s+(\w+)/);
+            if (typeMatch) {
+              const typeName = typeMatch[1];
+              messageType = this.extractMessageTypeFromTypeName(typeName);
+            }
+            if (!messageType) {
+              const body = node.getBody();
+              if (body) {
+                const bodyText = body.getText();
+                const typeValueMatch = bodyText.match(/\.type\s*===?\s*['"](\w+)['"]/);
+                if (typeValueMatch) {
+                  messageType = typeValueMatch[1];
+                }
+              }
+            }
+            if (messageType) {
+              typeGuards.set(functionName, messageType);
+            }
+          }
+        }
+      }
+    });
+    return typeGuards;
+  }
+  extractMessageTypeFromTypeName(typeName) {
+    const messageType = typeName.replace(/Message$/, "").replace(/Event$/, "").replace(/Request$/, "").replace(/Command$/, "").replace(/Query$/, "").toLowerCase();
+    return messageType;
+  }
   inferContext(filePath) {
     const path = filePath.toLowerCase();
     if (path.includes("/background/") || path.includes("\\background\\")) {
@@ -2175,4 +2288,4 @@ Stack trace:`, COLORS.gray));
   process.exit(1);
 });
 
-//# debugId=8C53367A419D15AA64756E2164756E21
+//# debugId=5E943FE5FB56B58764756E2164756E21