@fairfox/polly 0.15.1 → 0.15.4

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

@@ -236664,6 +236664,7 @@ class HandlerExtractor {
   relationshipExtractor;
   analyzedFiles;
   packageRoot;
+  warnings;
   constructor(tsConfigPath) {
     this.project = new import_ts_morph4.Project({
       tsConfigFilePath: tsConfigPath
@@ -236671,8 +236672,27 @@ class HandlerExtractor {
     this.typeGuardCache = new WeakMap;
     this.relationshipExtractor = new RelationshipExtractor;
     this.analyzedFiles = new Set;
+    this.warnings = [];
     this.packageRoot = this.findPackageRoot(tsConfigPath);
   }
+  warnUnsupportedPattern(pattern, location2, suggestion) {
+    const exists = this.warnings.some((w) => w.pattern === pattern && w.location === location2);
+    if (!exists) {
+      this.warnings.push({
+        type: "unsupported_pattern",
+        pattern,
+        location: location2,
+        suggestion
+      });
+    }
+  }
+  getNodeLocation(node) {
+    const sourceFile = node.getSourceFile();
+    const lineAndCol = sourceFile.getLineAndColumnAtPos(node.getStart());
+    const filePath = sourceFile.getFilePath();
+    const relativePath = filePath.startsWith(this.packageRoot) ? filePath.substring(this.packageRoot.length + 1) : filePath;
+    return `${relativePath}:${lineAndCol.line}`;
+  }
   findPackageRoot(tsConfigPath) {
     let dir = tsConfigPath.substring(0, tsConfigPath.lastIndexOf("/"));
     while (dir.length > 1) {
@@ -236696,6 +236716,7 @@ class HandlerExtractor {
     const invalidMessageTypes = new Set;
     const stateConstraints = [];
     const verifiedStates = [];
+    this.warnings = [];
     const allSourceFiles = this.project.getSourceFiles();
     const entryPoints = allSourceFiles.filter((f) => this.isWithinPackage(f.getFilePath()));
     this.debugLogSourceFiles(allSourceFiles, entryPoints);
@@ -236730,7 +236751,8 @@ class HandlerExtractor {
       handlers,
       messageTypes,
       stateConstraints,
-      verifiedStates
+      verifiedStates,
+      warnings: this.warnings
     };
   }
   analyzeFileAndImports(sourceFile, handlers, messageTypes, invalidMessageTypes, stateConstraints, verifiedStates) {
@@ -236960,46 +236982,364 @@ class HandlerExtractor {
     if (!import_ts_morph4.Node.isPropertyAccessExpression(left))
       return;
     const fieldPath = this.getPropertyPath(left);
-    if (fieldPath.startsWith("state.")) {
-      const field = fieldPath.substring(6);
-      const value = this.extractValue(right);
-      if (value !== undefined) {
-        assignments.push({ field, value });
-      }
+    if (this.tryExtractStateFieldPattern(fieldPath, right, assignments))
       return;
-    }
-    const valueMatch = fieldPath.match(/\.value\.(.+)$/);
-    if (valueMatch?.[1]) {
-      const field = valueMatch[1];
-      const value = this.extractValue(right);
-      if (value !== undefined) {
-        assignments.push({ field, value });
-      }
+    if (this.tryExtractSignalNestedFieldPattern(fieldPath, right, assignments))
+      return;
+    if (this.tryExtractSignalObjectPattern(fieldPath, right, assignments))
+      return;
+    if (this.tryExtractSignalArrayPattern(fieldPath, right, assignments))
       return;
+    if (this.tryExtractSignalMethodPattern(fieldPath, right, assignments))
+      return;
+    if (this.tryExtractSetConstructorPattern(fieldPath, right, assignments))
+      return;
+    this.tryExtractMapConstructorPattern(fieldPath, right, assignments);
+  }
+  tryExtractStateFieldPattern(fieldPath, right, assignments) {
+    if (!fieldPath.startsWith("state."))
+      return false;
+    const field = fieldPath.substring(6);
+    const value = this.extractValue(right);
+    if (value !== undefined) {
+      assignments.push({ field, value });
     }
-    if (fieldPath.endsWith(".value") && import_ts_morph4.Node.isObjectLiteralExpression(right)) {
-      this.extractObjectLiteralAssignments(right, assignments);
+    return true;
+  }
+  tryExtractSignalNestedFieldPattern(fieldPath, right, assignments) {
+    const valueFieldMatch = fieldPath.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\.value\.(.+)$/);
+    if (!valueFieldMatch?.[1] || !valueFieldMatch?.[2])
+      return false;
+    const signalName = valueFieldMatch[1];
+    const fieldName = valueFieldMatch[2];
+    const value = this.extractValue(right);
+    if (value !== undefined) {
+      assignments.push({ field: `${signalName}_${fieldName}`, value });
     }
+    return true;
   }
-  extractObjectLiteralAssignments(objectLiteral, assignments) {
-    if (!import_ts_morph4.Node.isObjectLiteralExpression(objectLiteral))
+  tryExtractSignalObjectPattern(fieldPath, right, assignments) {
+    if (!fieldPath.endsWith(".value") || !import_ts_morph4.Node.isObjectLiteralExpression(right))
+      return false;
+    const signalName = fieldPath.slice(0, -6);
+    if (this.isSpreadUpdatePattern(right, fieldPath)) {
+      this.extractSpreadUpdateAssignments(right, assignments, signalName);
+    } else {
+      this.extractObjectLiteralAssignments(right, assignments, signalName);
+    }
+    return true;
+  }
+  isSpreadUpdatePattern(objectLiteral, fieldPath) {
+    const properties = objectLiteral.getProperties();
+    if (properties.length === 0)
+      return false;
+    const firstProp = properties[0];
+    if (!firstProp || !import_ts_morph4.Node.isSpreadAssignment(firstProp))
+      return false;
+    const spreadExpr = firstProp.getExpression();
+    if (!spreadExpr)
+      return false;
+    return this.getPropertyPath(spreadExpr) === fieldPath;
+  }
+  tryExtractSignalArrayPattern(fieldPath, right, assignments) {
+    if (!fieldPath.endsWith(".value") || !import_ts_morph4.Node.isArrayLiteralExpression(right))
+      return false;
+    const signalName = fieldPath.slice(0, -6);
+    const arrayAssignment = this.extractArraySpreadOperation(right, fieldPath, signalName);
+    if (arrayAssignment) {
+      assignments.push(arrayAssignment);
+    }
+    return true;
+  }
+  tryExtractSignalMethodPattern(fieldPath, right, assignments) {
+    if (!fieldPath.endsWith(".value") || !import_ts_morph4.Node.isCallExpression(right))
+      return false;
+    const signalName = fieldPath.slice(0, -6);
+    this.checkForMutatingCollectionMethods(right);
+    const methodAssignment = this.extractArrayMethodOperation(right, fieldPath, signalName);
+    if (methodAssignment) {
+      assignments.push(methodAssignment);
+    }
+    return true;
+  }
+  checkForMutatingCollectionMethods(callExpr) {
+    const expression = callExpr.getExpression();
+    if (!import_ts_morph4.Node.isPropertyAccessExpression(expression))
       return;
-    for (const prop of objectLiteral.getProperties()) {
-      if (import_ts_morph4.Node.isPropertyAssignment(prop)) {
-        const name = prop.getName();
-        const initializer = prop.getInitializer();
-        if (!name || !initializer)
-          continue;
-        const value = this.extractValue(initializer);
-        if (value !== undefined) {
-          assignments.push({ field: name, value });
+    const methodName = expression.getName();
+    const sourceExpr = expression.getExpression();
+    const setMethods = ["add", "delete", "clear"];
+    if (setMethods.includes(methodName)) {
+      const sourceText = sourceExpr.getText();
+      if (sourceText.includes("Set") || this.looksLikeSetOrMap(sourceExpr, "Set")) {
+        this.warnUnsupportedPattern(`set.${methodName}()`, this.getNodeLocation(callExpr), `Set.${methodName}() mutates in place. Use: new Set([...set, item]) for add, new Set([...set].filter(...)) for delete.`);
+      }
+    }
+    const mapMethods = ["set", "delete", "clear"];
+    if (mapMethods.includes(methodName)) {
+      const sourceText = sourceExpr.getText();
+      if (sourceText.includes("Map") || this.looksLikeSetOrMap(sourceExpr, "Map")) {
+        this.warnUnsupportedPattern(`map.${methodName}()`, this.getNodeLocation(callExpr), `Map.${methodName}() mutates in place. Use: new Map([...map, [key, value]]) for set, new Map([...map].filter(...)) for delete.`);
+      }
+    }
+  }
+  looksLikeSetOrMap(expr, collectionType) {
+    const text = expr.getText().toLowerCase();
+    return text.includes(collectionType.toLowerCase());
+  }
+  tryExtractSetConstructorPattern(fieldPath, right, assignments) {
+    if (!fieldPath.endsWith(".value") || !import_ts_morph4.Node.isNewExpression(right))
+      return false;
+    const constructorExpr = right.getExpression();
+    if (!import_ts_morph4.Node.isIdentifier(constructorExpr) || constructorExpr.getText() !== "Set")
+      return false;
+    const signalName = fieldPath.slice(0, -6);
+    const setAssignment = this.extractSetOperation(right, fieldPath, signalName);
+    if (setAssignment) {
+      assignments.push(setAssignment);
+    }
+    return true;
+  }
+  tryExtractMapConstructorPattern(fieldPath, right, assignments) {
+    if (!fieldPath.endsWith(".value") || !import_ts_morph4.Node.isNewExpression(right))
+      return false;
+    const constructorExpr = right.getExpression();
+    if (!import_ts_morph4.Node.isIdentifier(constructorExpr) || constructorExpr.getText() !== "Map")
+      return false;
+    const signalName = fieldPath.slice(0, -6);
+    const mapAssignment = this.extractMapOperation(right, fieldPath, signalName);
+    if (mapAssignment) {
+      assignments.push(mapAssignment);
+    }
+    return true;
+  }
+  extractSetOperation(newExpr, fieldPath, signalName) {
+    const args = newExpr.getArguments();
+    if (args.length === 0) {
+      return { field: signalName, value: "{}" };
+    }
+    const firstArg = args[0];
+    if (!firstArg)
+      return null;
+    if (import_ts_morph4.Node.isArrayLiteralExpression(firstArg)) {
+      return this.extractSetArrayOperation(firstArg, fieldPath, signalName);
+    }
+    if (import_ts_morph4.Node.isCallExpression(firstArg)) {
+      return this.extractSetMethodChainOperation(firstArg, fieldPath, signalName);
+    }
+    return null;
+  }
+  extractSetArrayOperation(arrayLiteral, fieldPath, signalName) {
+    const elements = arrayLiteral.getElements();
+    if (elements.length < 1)
+      return null;
+    const firstElement = elements[0];
+    const lastElement = elements[elements.length - 1];
+    if (firstElement && import_ts_morph4.Node.isSpreadElement(firstElement)) {
+      const spreadExpr = firstElement.getExpression();
+      if (spreadExpr && this.getPropertyPath(spreadExpr) === fieldPath) {
+        return { field: signalName, value: "@ \\union {payload}" };
+      }
+    }
+    if (lastElement && import_ts_morph4.Node.isSpreadElement(lastElement)) {
+      const spreadExpr = lastElement.getExpression();
+      if (spreadExpr && this.getPropertyPath(spreadExpr) === fieldPath) {
+        return { field: signalName, value: "{payload} \\union @" };
+      }
+    }
+    return null;
+  }
+  extractSetMethodChainOperation(callExpr, fieldPath, signalName) {
+    const expression = callExpr.getExpression();
+    if (!import_ts_morph4.Node.isPropertyAccessExpression(expression))
+      return null;
+    const methodName = expression.getName();
+    const sourceExpr = expression.getExpression();
+    if (methodName === "filter" && import_ts_morph4.Node.isArrayLiteralExpression(sourceExpr)) {
+      const elements = sourceExpr.getElements();
+      if (elements.length === 1) {
+        const spreadEl = elements[0];
+        if (spreadEl && import_ts_morph4.Node.isSpreadElement(spreadEl)) {
+          const spreadExpr = spreadEl.getExpression();
+          if (spreadExpr && this.getPropertyPath(spreadExpr) === fieldPath) {
+            return { field: signalName, value: "@ \\ {payload}" };
+          }
         }
       }
-      if (import_ts_morph4.Node.isShorthandPropertyAssignment(prop)) {
-        const name = prop.getName();
-        assignments.push({ field: name, value: "@" });
+    }
+    return null;
+  }
+  extractMapOperation(newExpr, fieldPath, signalName) {
+    const args = newExpr.getArguments();
+    if (args.length === 0) {
+      return { field: signalName, value: "<<>>" };
+    }
+    const firstArg = args[0];
+    if (!firstArg)
+      return null;
+    if (import_ts_morph4.Node.isArrayLiteralExpression(firstArg)) {
+      return this.extractMapArrayOperation(firstArg, fieldPath, signalName);
+    }
+    if (import_ts_morph4.Node.isCallExpression(firstArg)) {
+      return this.extractMapMethodChainOperation(firstArg, fieldPath, signalName);
+    }
+    return null;
+  }
+  extractMapArrayOperation(arrayLiteral, fieldPath, signalName) {
+    const elements = arrayLiteral.getElements();
+    if (elements.length < 1)
+      return null;
+    const firstElement = elements[0];
+    if (firstElement && import_ts_morph4.Node.isSpreadElement(firstElement)) {
+      const spreadExpr = firstElement.getExpression();
+      if (spreadExpr && this.getPropertyPath(spreadExpr) === fieldPath) {
+        return { field: signalName, value: "[@ EXCEPT ![payload.key] = payload.value]" };
+      }
+    }
+    return null;
+  }
+  extractMapMethodChainOperation(callExpr, fieldPath, signalName) {
+    const expression = callExpr.getExpression();
+    if (!import_ts_morph4.Node.isPropertyAccessExpression(expression))
+      return null;
+    const methodName = expression.getName();
+    const sourceExpr = expression.getExpression();
+    if (methodName === "filter" && import_ts_morph4.Node.isArrayLiteralExpression(sourceExpr)) {
+      const elements = sourceExpr.getElements();
+      if (elements.length === 1) {
+        const spreadEl = elements[0];
+        if (spreadEl && import_ts_morph4.Node.isSpreadElement(spreadEl)) {
+          const spreadExpr = spreadEl.getExpression();
+          if (spreadExpr && this.getPropertyPath(spreadExpr) === fieldPath) {
+            return { field: signalName, value: "[k \\in DOMAIN @ \\ {payload.key} |-> @[k]]" };
+          }
+        }
       }
     }
+    return null;
+  }
+  extractArrayMethodOperation(callExpr, fieldPath, signalName) {
+    const expression = callExpr.getExpression();
+    if (!import_ts_morph4.Node.isPropertyAccessExpression(expression))
+      return null;
+    const methodName = expression.getName();
+    const sourceExpr = expression.getExpression();
+    const sourcePath = this.getPropertyPath(sourceExpr);
+    if (sourcePath !== fieldPath)
+      return null;
+    switch (methodName) {
+      case "filter":
+        return { field: signalName, value: "SelectSeq(@, LAMBDA t: TRUE)" };
+      case "map":
+        return { field: signalName, value: "[i \\in DOMAIN @ |-> @[i]]" };
+      case "slice":
+        return { field: signalName, value: "SubSeq(@, 1, Len(@))" };
+      case "concat":
+        return { field: signalName, value: "@ \\o <<payload>>" };
+      case "reverse":
+        return { field: signalName, value: "[i \\in DOMAIN @ |-> @[Len(@) - i + 1]]" };
+      default:
+        this.warnUnsupportedArrayMethod(methodName, callExpr);
+        return null;
+    }
+  }
+  warnUnsupportedArrayMethod(methodName, node) {
+    const mutatingMethods = [
+      "push",
+      "pop",
+      "shift",
+      "unshift",
+      "splice",
+      "sort",
+      "fill",
+      "copyWithin"
+    ];
+    const queryMethods = [
+      "find",
+      "findIndex",
+      "reduce",
+      "reduceRight",
+      "some",
+      "every",
+      "includes",
+      "indexOf",
+      "lastIndexOf"
+    ];
+    const otherMethods = ["flat", "flatMap", "join", "toString", "toLocaleString"];
+    if (mutatingMethods.includes(methodName)) {
+      this.warnUnsupportedPattern(`array.${methodName}()`, this.getNodeLocation(node), `'${methodName}' mutates in place. Use spread syntax: [...arr, item] for append, arr.filter() for removal.`);
+    } else if (queryMethods.includes(methodName)) {
+      this.warnUnsupportedPattern(`array.${methodName}()`, this.getNodeLocation(node), `'${methodName}' returns a single value, not a new array. State assignment won't be extracted.`);
+    } else if (otherMethods.includes(methodName)) {
+      this.warnUnsupportedPattern(`array.${methodName}()`, this.getNodeLocation(node), `'${methodName}' is not supported for state extraction. Consider using map/filter instead.`);
+    }
+  }
+  extractSpreadUpdateAssignments(objectLiteral, assignments, signalName) {
+    for (const prop of objectLiteral.getProperties()) {
+      if (import_ts_morph4.Node.isSpreadAssignment(prop))
+        continue;
+      this.extractPropertyAssignment(prop, assignments, signalName);
+    }
+  }
+  extractArraySpreadOperation(arrayLiteral, fieldPath, signalName) {
+    const elements = arrayLiteral.getElements();
+    if (elements.length < 1)
+      return null;
+    return this.tryExtractAppendOperation(elements, fieldPath, signalName) ?? this.tryExtractPrependOperation(elements, fieldPath, signalName);
+  }
+  tryExtractAppendOperation(elements, fieldPath, signalName) {
+    const firstElement = elements[0];
+    if (!firstElement || !import_ts_morph4.Node.isSpreadElement(firstElement))
+      return null;
+    const spreadExpr = firstElement.getExpression();
+    if (!spreadExpr || this.getPropertyPath(spreadExpr) !== fieldPath)
+      return null;
+    if (elements.length === 2) {
+      return { field: signalName, value: "Append(@, payload)" };
+    }
+    const placeholders = Array(elements.length - 1).fill("payload").join(", ");
+    return { field: signalName, value: `@ \\o <<${placeholders}>>` };
+  }
+  tryExtractPrependOperation(elements, fieldPath, signalName) {
+    if (elements.length < 2)
+      return null;
+    const lastElement = elements[elements.length - 1];
+    if (!lastElement || !import_ts_morph4.Node.isSpreadElement(lastElement))
+      return null;
+    const spreadExpr = lastElement.getExpression();
+    if (!spreadExpr || this.getPropertyPath(spreadExpr) !== fieldPath)
+      return null;
+    if (elements.length === 2) {
+      return { field: signalName, value: "<<payload>> \\o @" };
+    }
+    const placeholders = Array(elements.length - 1).fill("payload").join(", ");
+    return { field: signalName, value: `<<${placeholders}>> \\o @` };
+  }
+  extractObjectLiteralAssignments(objectLiteral, assignments, signalName) {
+    if (!import_ts_morph4.Node.isObjectLiteralExpression(objectLiteral))
+      return;
+    for (const prop of objectLiteral.getProperties()) {
+      this.extractPropertyAssignment(prop, assignments, signalName);
+    }
+  }
+  extractPropertyAssignment(prop, assignments, signalName) {
+    if (import_ts_morph4.Node.isPropertyAssignment(prop)) {
+      const name = prop.getName();
+      const initializer = prop.getInitializer();
+      if (!name || !initializer)
+        return;
+      const value = this.extractValue(initializer);
+      if (value === undefined)
+        return;
+      const field = signalName ? `${signalName}_${name}` : name;
+      assignments.push({ field, value });
+      return;
+    }
+    if (import_ts_morph4.Node.isShorthandPropertyAssignment(prop)) {
+      const name = prop.getName();
+      const field = signalName ? `${signalName}_${name}` : name;
+      assignments.push({ field, value: "@" });
+    }
   }
   extractElementAccessAssignment(left, right, assignments) {
     if (!import_ts_morph4.Node.isElementAccessExpression(left))
@@ -238012,15 +238352,15 @@ class HandlerExtractor {
         if (path === `${varName}.value`) {
           const right = node.getRight();
           if (import_ts_morph4.Node.isObjectLiteralExpression(right)) {
-            this.extractObjectLiteralAssignments(right, mutations);
+            this.extractObjectLiteralAssignments(right, mutations, varName);
           }
           break;
         }
         const fieldPrefix = `${varName}.value.`;
         if (path.startsWith(fieldPrefix)) {
-          const field = path.substring(fieldPrefix.length);
+          const fieldName = path.substring(fieldPrefix.length);
           const value = this.extractValue(node.getRight());
-          mutations.push({ field, value: value ?? "@" });
+          mutations.push({ field: `${varName}_${fieldName}`, value: value ?? "@" });
           break;
         }
       }
@@ -241019,4 +241359,4 @@ export {
   generateTeachingMaterial
 };
 
-//# debugId=BF8AF6D2BE5271F864756E2164756E21
+//# debugId=5D30A66A660B187164756E2164756E21