@fairfox/polly 0.12.4 → 0.13.1

package/dist/tools/teach/src/index.js

@@ -236860,17 +236860,25 @@ class HandlerExtractor {
     const assignments = [];
     const preconditions = [];
     const postconditions = [];
+    let actualHandler = null;
     if (import_ts_morph4.Node.isArrowFunction(handlerArg) || import_ts_morph4.Node.isFunctionExpression(handlerArg)) {
-      this.extractAssignments(handlerArg, assignments);
-      this.extractVerificationConditions(handlerArg, preconditions, postconditions);
-      this.checkAsyncMutations(handlerArg, messageType);
+      actualHandler = handlerArg;
+    } else if (import_ts_morph4.Node.isIdentifier(handlerArg)) {
+      actualHandler = this.resolveFunctionReference(handlerArg);
+    }
+    if (actualHandler) {
+      this.extractAssignments(actualHandler, assignments);
+      this.extractVerificationConditions(actualHandler, preconditions, postconditions);
+      if (import_ts_morph4.Node.isArrowFunction(actualHandler) || import_ts_morph4.Node.isFunctionExpression(actualHandler)) {
+        this.checkAsyncMutations(actualHandler, messageType);
+      }
     }
     const line = callExpr.getStartLineNumber();
     const sourceFile = callExpr.getSourceFile();
     const handlerName = `${messageType}_handler`;
     let relationships;
-    if (import_ts_morph4.Node.isArrowFunction(handlerArg) || import_ts_morph4.Node.isFunctionExpression(handlerArg)) {
-      const detectedRelationships = this.relationshipExtractor.extractFromHandler(handlerArg, sourceFile, handlerName);
+    if (actualHandler) {
+      const detectedRelationships = this.relationshipExtractor.extractFromHandler(actualHandler, sourceFile, handlerName);
       if (detectedRelationships.length > 0) {
         relationships = detectedRelationships;
       }
@@ -236974,11 +236982,24 @@ class HandlerExtractor {
       }
     }
   }
+  getUnaryOperatorText(operator) {
+    if (typeof operator === "number") {
+      if (operator === import_ts_morph4.SyntaxKind.PlusPlusToken)
+        return "++";
+      if (operator === import_ts_morph4.SyntaxKind.MinusMinusToken)
+        return "--";
+      return null;
+    }
+    if (operator && typeof operator === "object" && "getText" in operator) {
+      return operator.getText();
+    }
+    return null;
+  }
   extractUnaryExpressionAssignment(node, assignments) {
     if (!import_ts_morph4.Node.isPostfixUnaryExpression(node) && !import_ts_morph4.Node.isPrefixUnaryExpression(node))
       return;
     const operator = node.getOperatorToken();
-    const operatorText = operator.toString();
+    const operatorText = this.getUnaryOperatorText(operator);
     if (operatorText !== "++" && operatorText !== "--")
       return;
     const operand = node.getOperand();
@@ -237070,7 +237091,7 @@ class HandlerExtractor {
   }
   extractVerificationConditions(funcNode, preconditions, postconditions) {
     const body = funcNode.getBody();
-    const statements = import_ts_morph4.Node.isBlock(body) ? body.getStatements() : [body];
+    const statements = import_ts_morph4.Node.isBlock(body) ? body.getStatements() : body ? [body] : [];
     for (const statement of statements) {
       this.processStatementForConditions(statement, preconditions, postconditions);
     }
@@ -237190,10 +237211,14 @@ class HandlerExtractor {
     const handlers = [];
     try {
       const initializer = varDecl.getInitializer();
-      if (!this.isHandlerMapInitializer(initializer, varDecl)) {
+      if (!initializer) {
+        return handlers;
+      }
+      const objectLiteral = this.getHandlerMapObject(initializer, varDecl);
+      if (!objectLiteral) {
         return handlers;
       }
-      const properties = initializer.getProperties();
+      const properties = objectLiteral.getProperties();
       for (const prop of properties) {
         const handler = this.extractHandlerFromProperty(prop, context, filePath);
         if (handler) {
@@ -237203,12 +237228,16 @@ class HandlerExtractor {
     } catch (_error) {}
     return handlers;
   }
-  isHandlerMapInitializer(initializer, varDecl) {
-    if (!initializer || !import_ts_morph4.Node.isObjectLiteralExpression(initializer)) {
-      return false;
+  getHandlerMapObject(initializer, varDecl) {
+    if (import_ts_morph4.Node.isObjectLiteralExpression(initializer)) {
+      if (this.isHandlerMapName(varDecl.getName())) {
+        return initializer;
+      }
     }
-    const varName = varDecl.getName().toLowerCase();
-    return /(handler|listener|callback|event)s?/.test(varName);
+    return null;
+  }
+  isHandlerMapName(varName) {
+    return /(handler|listener|callback|event)s?/.test(varName.toLowerCase());
   }
   extractHandlerFromProperty(prop, context, filePath) {
     if (!import_ts_morph4.Node.isPropertyAssignment(prop)) {
@@ -237219,13 +237248,29 @@ class HandlerExtractor {
     if (!messageType) {
       return null;
     }
+    const value = prop.getInitializer();
+    const assignments = [];
+    const preconditions = [];
+    const postconditions = [];
+    if (value) {
+      if (import_ts_morph4.Node.isArrowFunction(value) || import_ts_morph4.Node.isFunctionExpression(value)) {
+        this.extractAssignments(value, assignments);
+        this.extractVerificationConditions(value, preconditions, postconditions);
+      } else if (import_ts_morph4.Node.isIdentifier(value)) {
+        const referencedFunction = this.resolveFunctionReference(value);
+        if (referencedFunction) {
+          this.extractAssignments(referencedFunction, assignments);
+          this.extractVerificationConditions(referencedFunction, preconditions, postconditions);
+        }
+      }
+    }
     const line = prop.getStartLineNumber();
     return {
       messageType,
       node: context,
-      assignments: [],
-      preconditions: [],
-      postconditions: [],
+      assignments,
+      preconditions,
+      postconditions,
       location: { file: filePath, line }
     };
   }
@@ -237238,6 +237283,26 @@ class HandlerExtractor {
     }
     return null;
   }
+  resolveFunctionReference(identifier) {
+    if (!import_ts_morph4.Node.isIdentifier(identifier)) {
+      return null;
+    }
+    try {
+      const definitions = identifier.getDefinitionNodes();
+      for (const def of definitions) {
+        if (import_ts_morph4.Node.isFunctionDeclaration(def)) {
+          return def;
+        }
+        if (import_ts_morph4.Node.isVariableDeclaration(def)) {
+          const initializer = def.getInitializer();
+          if (initializer && (import_ts_morph4.Node.isArrowFunction(initializer) || import_ts_morph4.Node.isFunctionExpression(initializer))) {
+            return initializer;
+          }
+        }
+      }
+    } catch (_error) {}
+    return null;
+  }
   extractTypeGuardHandlers(ifNode, context, filePath) {
     const handlers = [];
     try {
@@ -240688,4 +240753,4 @@ export {
   generateTeachingMaterial
 };
 
-//# debugId=966AF45575F8C7D664756E2164756E21
+//# debugId=555FA35403EDF64764756E2164756E21