@fairfox/polly 0.3.2 → 0.3.6

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

@@ -738,6 +738,14 @@ class HandlerExtractor {
     const handlers = [];
     const messageTypes = new Set;
     const sourceFiles = this.project.getSourceFiles();
+    if (process.env.POLLY_DEBUG) {
+      console.log(`[DEBUG] Loaded ${sourceFiles.length} source files`);
+      if (sourceFiles.length <= 20) {
+        for (const sf of sourceFiles) {
+          console.log(`[DEBUG]   - ${sf.getFilePath()}`);
+        }
+      }
+    }
     for (const sourceFile of sourceFiles) {
       const fileHandlers = this.extractFromFile(sourceFile);
       handlers.push(...fileHandlers);
@@ -745,6 +753,9 @@ class HandlerExtractor {
         messageTypes.add(handler.messageType);
       }
     }
+    if (process.env.POLLY_DEBUG) {
+      console.log(`[DEBUG] Total handlers extracted: ${handlers.length}`);
+    }
     return {
       handlers,
       messageTypes
@@ -776,8 +787,12 @@ class HandlerExtractor {
         handlers.push(...mapHandlers);
       }
       if (Node.isIfStatement(node)) {
-        const typeGuardHandlers = this.extractTypeGuardHandlers(node, context, filePath);
-        handlers.push(...typeGuardHandlers);
+        const parent = node.getParent();
+        const isElseIf = parent && Node.isIfStatement(parent);
+        if (!isElseIf) {
+          const typeGuardHandlers = this.extractTypeGuardHandlers(node, context, filePath);
+          handlers.push(...typeGuardHandlers);
+        }
       }
     });
     return handlers;
@@ -998,14 +1013,23 @@ class HandlerExtractor {
         typeGuards = this.findTypePredicateFunctions(sourceFile);
         this.typeGuardCache.set(sourceFile, typeGuards);
       }
-      if (typeGuards.size === 0) {
-        return handlers;
+      if (process.env.POLLY_DEBUG) {
+        console.log(`[DEBUG] File: ${sourceFile.getBaseName()}`);
+        console.log(`[DEBUG] Local type guards found: ${typeGuards.size}`);
+        if (typeGuards.size > 0) {
+          for (const [name, type] of typeGuards.entries()) {
+            console.log(`[DEBUG]   - ${name} → ${type}`);
+          }
+        }
       }
       let currentIf = ifNode;
       while (currentIf) {
         const handler = this.extractHandlerFromIfClause(currentIf, typeGuards, context, filePath);
         if (handler) {
           handlers.push(handler);
+          if (process.env.POLLY_DEBUG) {
+            console.log(`[DEBUG] Found handler: ${handler.messageType} at line ${handler.location.line}`);
+          }
         }
         const elseStatement = currentIf.getElseStatement();
         if (elseStatement && Node.isIfStatement(elseStatement)) {
@@ -1014,7 +1038,11 @@ class HandlerExtractor {
           break;
         }
       }
-    } catch (error) {}
+    } catch (error) {
+      if (process.env.POLLY_DEBUG) {
+        console.log(`[DEBUG] Error in extractTypeGuardHandlers: ${error}`);
+      }
+    }
     return handlers;
   }
   extractHandlerFromIfClause(ifNode, typeGuards, context, filePath) {
@@ -1028,13 +1056,25 @@ class HandlerExtractor {
       if (Node.isIdentifier(funcExpr)) {
         funcName = funcExpr.getText();
       }
+      if (process.env.POLLY_DEBUG && funcName) {
+        console.log(`[DEBUG] Processing if condition with function: ${funcName}`);
+      }
       let messageType = undefined;
       if (funcName && typeGuards.has(funcName)) {
         messageType = typeGuards.get(funcName);
+        if (process.env.POLLY_DEBUG) {
+          console.log(`[DEBUG] Found in local type guards: ${funcName} → ${messageType}`);
+        }
       } else if (Node.isIdentifier(funcExpr)) {
+        if (process.env.POLLY_DEBUG) {
+          console.log(`[DEBUG] Not found locally, trying import resolution for: ${funcName}`);
+        }
         messageType = this.resolveImportedTypeGuard(funcExpr);
       }
       if (!messageType) {
+        if (process.env.POLLY_DEBUG && funcName) {
+          console.log(`[DEBUG] Could not resolve message type for: ${funcName}`);
+        }
         return null;
       }
       const line = ifNode.getStartLineNumber();
@@ -1054,9 +1094,8 @@ class HandlerExtractor {
     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)) {
+        const returnTypeNode = node.getReturnTypeNode();
+        if (returnTypeNode && Node.isTypePredicate(returnTypeNode)) {
           let functionName;
           if (Node.isFunctionDeclaration(node)) {
             functionName = node.getName();
@@ -1072,10 +1111,10 @@ class HandlerExtractor {
             }
           }
           if (functionName) {
+            const typeNode = returnTypeNode.getTypeNode();
             let messageType = null;
-            const typeMatch = returnTypeText.match(/is\s+(\w+)/);
-            if (typeMatch) {
-              const typeName = typeMatch[1];
+            if (typeNode) {
+              const typeName = typeNode.getText();
               messageType = this.extractMessageTypeFromTypeName(typeName);
             }
             if (!messageType) {
@@ -1099,29 +1138,55 @@ class HandlerExtractor {
   }
   resolveImportedTypeGuard(identifier) {
     try {
+      const funcName = identifier.getText();
       const definitions = identifier.getDefinitionNodes();
+      if (definitions.length === 0) {
+        if (process.env.POLLY_DEBUG) {
+          console.log(`[DEBUG] No definitions found for imported function: ${funcName}`);
+        }
+        return null;
+      }
       for (const def of definitions) {
         if (Node.isFunctionDeclaration(def) || Node.isFunctionExpression(def) || Node.isArrowFunction(def)) {
-          const returnType = def.getReturnType();
-          const returnTypeText = returnType.getText();
-          if (/is\s+\w+/.test(returnTypeText)) {
-            const typeMatch = returnTypeText.match(/is\s+(\w+)/);
-            if (typeMatch) {
-              const typeName = typeMatch[1];
-              return this.extractMessageTypeFromTypeName(typeName);
+          const returnTypeNode = def.getReturnTypeNode();
+          if (process.env.POLLY_DEBUG) {
+            const returnType = def.getReturnType().getText();
+            console.log(`[DEBUG] Function ${funcName} return type (resolved): ${returnType}`);
+            console.log(`[DEBUG] Has return type node: ${!!returnTypeNode}`);
+            console.log(`[DEBUG] Is type predicate node: ${returnTypeNode && Node.isTypePredicate(returnTypeNode)}`);
+          }
+          if (returnTypeNode && Node.isTypePredicate(returnTypeNode)) {
+            const typeNode = returnTypeNode.getTypeNode();
+            if (typeNode) {
+              const typeName = typeNode.getText();
+              const messageType = this.extractMessageTypeFromTypeName(typeName);
+              if (messageType) {
+                if (process.env.POLLY_DEBUG) {
+                  console.log(`[DEBUG] Resolved ${funcName} → ${messageType} (from AST type predicate)`);
+                }
+                return messageType;
+              }
             }
-            const body = def.getBody();
-            if (body) {
-              const bodyText = body.getText();
-              const typeValueMatch = bodyText.match(/\.type\s*===?\s*['"](\w+)['"]/);
-              if (typeValueMatch) {
-                return typeValueMatch[1];
+          }
+          const body = def.getBody();
+          if (body) {
+            const bodyText = body.getText();
+            const typeValueMatch = bodyText.match(/\.type\s*===?\s*['"](\w+)['"]/);
+            if (typeValueMatch) {
+              const messageType = typeValueMatch[1];
+              if (process.env.POLLY_DEBUG) {
+                console.log(`[DEBUG] Resolved ${funcName} → ${messageType} (from body)`);
               }
+              return messageType;
             }
           }
         }
       }
-    } catch (error) {}
+    } catch (error) {
+      if (process.env.POLLY_DEBUG) {
+        console.log(`[DEBUG] Error resolving imported type guard: ${error}`);
+      }
+    }
     return null;
   }
   extractMessageTypeFromTypeName(typeName) {
@@ -2320,4 +2385,4 @@ Stack trace:`, COLORS.gray));
   process.exit(1);
 });
 
-//# debugId=45501E6F6BA7319064756E2164756E21
+//# debugId=EE34F5E282168E7C64756E2164756E21