@effect/language-service 0.21.3 → 0.21.5

package/index.js

@@ -1766,33 +1766,6 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
     const execute = fn("LSP.ruleExecutor")(function* (rule) {
       const ruleNameLowered = rule.name.toLowerCase();
       if (skippedRules.indexOf(ruleNameLowered) > -1) return [];
-      let modifiedDiagnostics = yield* rule.apply(sourceFile);
-      const newLevel = pluginOptions.diagnosticSeverity[ruleNameLowered];
-      if (newLevel) {
-        for (const emitted of modifiedDiagnostics) {
-          emitted.category = newLevel && newLevel in levelToDiagnosticCategory ? levelToDiagnosticCategory[newLevel] : emitted.category;
-        }
-      }
-      for (const emitted of modifiedDiagnostics.slice(0)) {
-        let newLevel2 = void 0;
-        if (!(ruleNameLowered in sectionOverrides || ruleNameLowered in lineOverrides)) continue;
-        const lineOverride = (lineOverrides[ruleNameLowered] || []).find(
-          (_) => _.pos < emitted.node.getStart(sourceFile) && _.end >= emitted.node.getEnd()
-        );
-        if (lineOverride) {
-          newLevel2 = lineOverride.level;
-        } else {
-          const sectionOverride = (sectionOverrides[ruleNameLowered] || []).find(
-            (_) => _.pos < emitted.node.getStart(sourceFile)
-          );
-          if (sectionOverride) newLevel2 = sectionOverride.level;
-        }
-        if (newLevel2 === "off") {
-          modifiedDiagnostics = modifiedDiagnostics.filter((_) => _ !== emitted);
-        } else {
-          emitted.category = newLevel2 && newLevel2 in levelToDiagnosticCategory ? levelToDiagnosticCategory[newLevel2] : emitted.category;
-        }
-      }
       const fixByDisableNextLine = (_) => ({
         fixName: rule.name + "_skipNextLine",
         description: "Disable " + rule.name + " for this line",
@@ -1825,11 +1798,34 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
           )
         )
       };
-      const rulesWithDisableFix = modifiedDiagnostics.map((diagnostic) => ({
-        ...diagnostic,
-        fixes: diagnostic.fixes.concat([fixByDisableNextLine(diagnostic), fixByDisableEntireFile])
-      }));
-      return rulesWithDisableFix;
+      let modifiedDiagnostics = [];
+      yield* rule.apply(sourceFile, (entry) => {
+        modifiedDiagnostics.push({
+          ...entry,
+          fixes: entry.fixes.concat([fixByDisableNextLine(entry), fixByDisableEntireFile])
+        });
+      });
+      if (!(ruleNameLowered in pluginOptions.diagnosticSeverity || ruleNameLowered in sectionOverrides || ruleNameLowered in lineOverrides)) return modifiedDiagnostics;
+      for (const emitted of modifiedDiagnostics.slice(0)) {
+        let newLevel = pluginOptions.diagnosticSeverity[ruleNameLowered];
+        const lineOverride = (lineOverrides[ruleNameLowered] || []).find(
+          (_) => _.pos < emitted.node.getStart(sourceFile) && _.end >= emitted.node.getEnd()
+        );
+        if (lineOverride) {
+          newLevel = lineOverride.level;
+        } else {
+          const sectionOverride = (sectionOverrides[ruleNameLowered] || []).find(
+            (_) => _.pos < emitted.node.getStart(sourceFile)
+          );
+          if (sectionOverride) newLevel = sectionOverride.level;
+        }
+        if (newLevel === "off") {
+          modifiedDiagnostics = modifiedDiagnostics.filter((_) => _ !== emitted);
+        } else {
+          emitted.category = newLevel && newLevel in levelToDiagnosticCategory ? levelToDiagnosticCategory[newLevel] : emitted.category;
+        }
+      }
+      return modifiedDiagnostics;
     });
     return { execute };
   }
@@ -2100,6 +2096,16 @@ function make4(ts, typeChecker) {
     "TypeParser.effectType",
     (type) => type
   );
+  const strictEffectType = cachedBy(
+    fn("TypeParser.strictEffectType")(function* (type, atLocation) {
+      if (type.symbol.name !== "Effect" || type.aliasSymbol) {
+        return yield* typeParserIssue("Type name should be Effect with no alias symbol", type, atLocation);
+      }
+      return yield* effectType(type, atLocation);
+    }),
+    "TypeParser.strictEffectType",
+    (type) => type
+  );
   const layerType = cachedBy(
     fn("TypeParser.layerType")(function* (type, atLocation) {
       yield* pipeableType(type, atLocation);
@@ -2451,6 +2457,7 @@ function make4(ts, typeChecker) {
   );
   return {
     effectType,
+    strictEffectType,
     layerType,
     fiberType,
     effectSubtype,
@@ -2537,6 +2544,7 @@ var getMissingTypeEntriesInTargetType = fn(
   "TypeCheckerApi.getMissingTypeEntriesInTargetType"
 )(
   function* (realType, expectedType) {
+    if (realType === expectedType) return [];
     const typeChecker = yield* service(TypeCheckerApi);
     const result = [];
     let toTest = [realType];
@@ -2846,12 +2854,11 @@ var programResolvedCacheSize = /* @__PURE__ */ new Map();
 var duplicatePackage = createDiagnostic({
   name: "duplicatePackage",
   code: 6,
-  apply: fn("duplicatePackage.apply")(function* (sourceFile) {
+  apply: fn("duplicatePackage.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const program = yield* service(TypeScriptProgram);
     const options = yield* service(LanguageServicePluginOptions);
-    const effectDiagnostics = [];
-    if (sourceFile.statements.length < 1) return [];
+    if (sourceFile.statements.length < 1) return;
     let resolvedPackages = checkedPackagesCache.get(sourceFile.fileName) || {};
     const newResolvedModuleSize = hasProperty(program, "resolvedModules") && hasProperty(program.resolvedModules, "size") && isNumber(program.resolvedModules.size) ? program.resolvedModules.size : 0;
     const oldResolvedSize = programResolvedCacheSize.get(sourceFile.fileName) || -1;
@@ -2875,7 +2882,7 @@ var duplicatePackage = createDiagnostic({
     for (const packageName of Object.keys(resolvedPackages)) {
       if (Object.keys(resolvedPackages[packageName]).length > 1) {
         const versions = Object.keys(resolvedPackages[packageName]);
-        effectDiagnostics.push({
+        report({
           node: sourceFile.statements[0],
           category: ts.DiagnosticCategory.Warning,
           messageText: `Package ${packageName} is referenced multiple times with different versions (${versions.join(", ")}) and may cause unexpected type errors.
@@ -2887,7 +2894,6 @@ ${versions.map((version) => `- found ${version} at ${resolvedPackages[packageNam
         });
       }
     }
-    return effectDiagnostics;
   })
 });
 
@@ -2895,7 +2901,7 @@ ${versions.map((version) => `- found ${version} at ${resolvedPackages[packageNam
 var floatingEffect = createDiagnostic({
   name: "floatingEffect",
   code: 3,
-  apply: fn("floatingEffect.apply")(function* (sourceFile) {
+  apply: fn("floatingEffect.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
@@ -2906,7 +2912,6 @@ var floatingEffect = createDiagnostic({
       if (ts.isBinaryExpression(expression) && expression.operatorToken && (expression.operatorToken.kind === ts.SyntaxKind.EqualsToken || expression.operatorToken.kind === ts.SyntaxKind.QuestionQuestionEqualsToken || expression.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandEqualsToken || expression.operatorToken.kind === ts.SyntaxKind.BarBarEqualsToken)) return false;
       return true;
     }
-    const effectDiagnostics = [];
     const nodeToVisit = [];
     const appendNodeToVisit = (node) => {
       nodeToVisit.push(node);
@@ -2926,7 +2931,7 @@ var floatingEffect = createDiagnostic({
           option
         );
         if (isNone2(allowedFloatingEffects)) {
-          effectDiagnostics.push({
+          report({
             node,
             category: ts.DiagnosticCategory.Error,
             messageText: `Effect must be yielded or assigned to a variable.`,
@@ -2935,7 +2940,52 @@ var floatingEffect = createDiagnostic({
         }
       }
     }
-    return effectDiagnostics;
+  })
+});
+
+// src/diagnostics/genericEffectServices.ts
+var genericEffectServices = createDiagnostic({
+  name: "genericEffectServices",
+  code: 10,
+  apply: fn("genericEffectServices.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      const typesToCheck = [];
+      if (ts.isClassDeclaration(node) && node.name && node.typeParameters && node.heritageClauses) {
+        const classSym = typeChecker.getSymbolAtLocation(node.name);
+        if (classSym) {
+          const type = typeChecker.getTypeOfSymbol(classSym);
+          typesToCheck.push([type, node.name]);
+        }
+      } else {
+        ts.forEachChild(node, appendNodeToVisit);
+        continue;
+      }
+      for (const [type, reportAt] of typesToCheck) {
+        yield* pipe(
+          typeParser.contextTag(type, node),
+          map4(() => {
+            report({
+              node: reportAt,
+              category: ts.DiagnosticCategory.Warning,
+              messageText: `Effect Services with type parameters are not supported because they cannot be properly discriminated at runtime, which may cause unexpected behavior.`,
+              fixes: []
+            });
+          }),
+          orElse3(() => sync(() => ts.forEachChild(node, appendNodeToVisit))),
+          ignore
+        );
+      }
+    }
   })
 });
 
@@ -2943,12 +2993,11 @@ var floatingEffect = createDiagnostic({
 var leakingRequirements = createDiagnostic({
   name: "leakingRequirements",
   code: 8,
-  apply: fn("leakingRequirements.apply")(function* (sourceFile) {
+  apply: fn("leakingRequirements.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
     const typeOrder = yield* deterministicTypeOrder;
-    const effectDiagnostics = [];
     const parseLeakedRequirements = cachedBy(
       fn("leakingServices.checkServiceLeaking")(
         function* (service2, atLocation) {
@@ -2999,7 +3048,7 @@ var leakingRequirements = createDiagnostic({
     );
     function reportLeakingRequirements(node, requirements) {
       if (requirements.length === 0) return;
-      effectDiagnostics.push({
+      report({
         node,
         category: ts.DiagnosticCategory.Warning,
         messageText: `This Service is leaking the ${requirements.map((_) => typeChecker.typeToString(_)).join(" | ")} requirement`,
@@ -3017,7 +3066,7 @@ var leakingRequirements = createDiagnostic({
       const typesToCheck = [];
       if (ts.isCallExpression(node)) {
         typesToCheck.push([typeChecker.getTypeAtLocation(node), node]);
-      } else if (ts.isClassDeclaration(node) && node.name) {
+      } else if (ts.isClassDeclaration(node) && node.name && node.heritageClauses) {
         const classSym = typeChecker.getSymbolAtLocation(node.name);
         if (classSym) {
           const type = typeChecker.getTypeOfSymbol(classSym);
@@ -3041,7 +3090,6 @@ var leakingRequirements = createDiagnostic({
         );
       }
     }
-    return effectDiagnostics;
   })
 });
 
@@ -3049,28 +3097,23 @@ var leakingRequirements = createDiagnostic({
 var missingEffectContext = createDiagnostic({
   name: "missingEffectContext",
   code: 1,
-  apply: fn("missingEffectContext.apply")(function* (sourceFile) {
+  apply: fn("missingEffectContext.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
     const typeOrder = yield* deterministicTypeOrder;
-    const checkForMissingContextTypes = fn(
-      "missingEffectContext.apply.checkForMissingContextTypes"
-    )(function* (node, expectedType, valueNode, realType) {
-      const expectedEffect = yield* typeParser.effectType(
-        expectedType,
-        node
-      );
-      const realEffect = yield* typeParser.effectType(
-        realType,
-        valueNode
-      );
-      return yield* getMissingTypeEntriesInTargetType(
-        realEffect.R,
-        expectedEffect.R
-      );
-    });
-    const effectDiagnostics = [];
+    const checkForMissingContextTypes = (node, expectedType, valueNode, realType) => pipe(
+      all2(
+        typeParser.effectType(expectedType, node),
+        typeParser.effectType(realType, valueNode)
+      ),
+      flatMap3(
+        ([expectedEffect, realEffect]) => getMissingTypeEntriesInTargetType(
+          realEffect.R,
+          expectedEffect.R
+        )
+      )
+    );
     const sortTypes = sort(typeOrder);
     const entries = yield* expectedAndRealType(sourceFile);
     for (const [node, expectedType, valueNode, realType] of entries) {
@@ -3084,7 +3127,7 @@ var missingEffectContext = createDiagnostic({
         orElse3(() => succeed([]))
       );
       if (missingContext.length > 0) {
-        effectDiagnostics.push(
+        report(
           {
             node,
             category: ts.DiagnosticCategory.Error,
@@ -3094,7 +3137,6 @@ var missingEffectContext = createDiagnostic({
         );
       }
     }
-    return effectDiagnostics;
   })
 });
 
@@ -3102,28 +3144,23 @@ var missingEffectContext = createDiagnostic({
 var missingEffectError = createDiagnostic({
   name: "missingEffectError",
   code: 1,
-  apply: fn("missingEffectError.apply")(function* (sourceFile) {
+  apply: fn("missingEffectError.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
     const typeOrder = yield* deterministicTypeOrder;
-    const checkForMissingErrorTypes = fn("missingEffectError.apply.checkForMissingErrorTypes")(
-      function* (node, expectedType, valueNode, realType) {
-        const expectedEffect = yield* typeParser.effectType(
-          expectedType,
-          node
-        );
-        const realEffect = yield* typeParser.effectType(
-          realType,
-          valueNode
-        );
-        return yield* getMissingTypeEntriesInTargetType(
+    const checkForMissingErrorTypes = (node, expectedType, valueNode, realType) => pipe(
+      all2(
+        typeParser.effectType(expectedType, node),
+        typeParser.effectType(realType, valueNode)
+      ),
+      flatMap3(
+        ([expectedEffect, realEffect]) => getMissingTypeEntriesInTargetType(
           realEffect.E,
           expectedEffect.E
-        );
-      }
+        )
+      )
     );
-    const effectDiagnostics = [];
     const sortTypes = sort(typeOrder);
     const entries = yield* expectedAndRealType(sourceFile);
     for (const [node, expectedType, valueNode, realType] of entries) {
@@ -3137,7 +3174,7 @@ var missingEffectError = createDiagnostic({
         orElse3(() => succeed([]))
       );
       if (missingContext.length > 0) {
-        effectDiagnostics.push(
+        report(
           {
             node,
             category: ts.DiagnosticCategory.Error,
@@ -3147,7 +3184,6 @@ var missingEffectError = createDiagnostic({
         );
       }
     }
-    return effectDiagnostics;
   })
 });
 
@@ -3155,12 +3191,10 @@ var missingEffectError = createDiagnostic({
 var missingReturnYieldStar = createDiagnostic({
   name: "missingReturnYieldStar",
   code: 7,
-  apply: fn("missingReturnYieldStar.apply")(function* (sourceFile) {
+  apply: fn("missingReturnYieldStar.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
-    const effectDiagnostics = [];
-    const brokenYields = /* @__PURE__ */ new Set();
     const nodeToVisit = [];
     const appendNodeToVisit = (node) => {
       nodeToVisit.push(node);
@@ -3188,36 +3222,32 @@ var missingReturnYieldStar = createDiagnostic({
                 option
               );
               if (isSome2(effectGenLike)) {
-                brokenYields.add(node);
+                const fix = node.expression ? [{
+                  fixName: "missingReturnYieldStar_fix",
+                  description: "Add return statement",
+                  apply: gen2(function* () {
+                    const changeTracker = yield* service(ChangeTracker);
+                    changeTracker.replaceNode(
+                      sourceFile,
+                      node,
+                      ts.factory.createReturnStatement(
+                        node
+                      )
+                    );
+                  })
+                }] : [];
+                report({
+                  node,
+                  category: ts.DiagnosticCategory.Error,
+                  messageText: `Yielded Effect never succeeds, so it is best to use a 'return yield*' instead.`,
+                  fixes: fix
+                });
               }
             }
           }
         }
       }
     }
-    brokenYields.forEach((node) => {
-      const fix = node.expression ? [{
-        fixName: "missingReturnYieldStar_fix",
-        description: "Add return statement",
-        apply: gen2(function* () {
-          const changeTracker = yield* service(ChangeTracker);
-          changeTracker.replaceNode(
-            sourceFile,
-            node,
-            ts.factory.createReturnStatement(
-              node
-            )
-          );
-        })
-      }] : [];
-      effectDiagnostics.push({
-        node,
-        category: ts.DiagnosticCategory.Error,
-        messageText: `Yielded Effect never succeeds, so it is best to use a 'return yield*' instead.`,
-        fixes: fix
-      });
-    });
-    return effectDiagnostics;
   })
 });
 
@@ -3225,10 +3255,9 @@ var missingReturnYieldStar = createDiagnostic({
 var missingStarInYieldEffectGen = createDiagnostic({
   name: "missingStarInYieldEffectGen",
   code: 4,
-  apply: fn("missingStarInYieldEffectGen.apply")(function* (sourceFile) {
+  apply: fn("missingStarInYieldEffectGen.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
-    const effectDiagnostics = [];
     const brokenGenerators = /* @__PURE__ */ new Set();
     const brokenYields = /* @__PURE__ */ new Set();
     const nodeToVisit = [];
@@ -3263,7 +3292,7 @@ var missingStarInYieldEffectGen = createDiagnostic({
       }
     }
     brokenGenerators.forEach(
-      (node) => effectDiagnostics.push({
+      (node) => report({
         node,
         category: ts.DiagnosticCategory.Error,
         messageText: `Seems like you used yield instead of yield* inside this Effect.gen.`,
@@ -3286,14 +3315,78 @@ var missingStarInYieldEffectGen = createDiagnostic({
           );
         })
       }] : [];
-      effectDiagnostics.push({
+      report({
         node,
         category: ts.DiagnosticCategory.Error,
         messageText: `When yielding Effects inside Effect.gen, you should use yield* instead of yield.`,
         fixes: fix
       });
     });
-    return effectDiagnostics;
+  })
+});
+
+// src/diagnostics/returnEffectInGen.ts
+var returnEffectInGen = createDiagnostic({
+  name: "returnEffectInGen",
+  code: 11,
+  apply: fn("returnEffectInGen.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts.forEachChild(node, appendNodeToVisit);
+      if (ts.isReturnStatement(node) && node.expression) {
+        if (ts.isYieldExpression(node.expression)) continue;
+        const generatorOrRegularFunction = ts.findAncestor(
+          node,
+          (_) => ts.isFunctionExpression(_) || ts.isFunctionDeclaration(_) || ts.isMethodDeclaration(_) || ts.isArrowFunction(_) || ts.isGetAccessor(_)
+        );
+        if (!(generatorOrRegularFunction && "asteriskToken" in generatorOrRegularFunction && generatorOrRegularFunction.asteriskToken)) continue;
+        const type = typeChecker.getTypeAtLocation(node.expression);
+        const maybeEffect = yield* option(typeParser.strictEffectType(type, node.expression));
+        if (isSome2(maybeEffect)) {
+          if (generatorOrRegularFunction && generatorOrRegularFunction.parent) {
+            const effectGenNode = generatorOrRegularFunction.parent;
+            yield* pipe(
+              typeParser.effectGen(effectGenNode),
+              orElse3(() => typeParser.effectFnUntracedGen(effectGenNode)),
+              orElse3(() => typeParser.effectFnGen(effectGenNode)),
+              map4(() => {
+                const fix = node.expression ? [{
+                  fixName: "returnEffectInGen_fix",
+                  description: "Add yield* statement",
+                  apply: gen2(function* () {
+                    const changeTracker = yield* service(ChangeTracker);
+                    changeTracker.replaceNode(
+                      sourceFile,
+                      node.expression,
+                      ts.factory.createYieldExpression(
+                        ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+                        node.expression
+                      )
+                    );
+                  })
+                }] : [];
+                report({
+                  node,
+                  category: ts.DiagnosticCategory.Suggestion,
+                  messageText: `You are returning an Effect-able type inside a generator function, and will result in nested Effect<Effect<...>>. Maybe you wanted to return yield* instead? Nested Effect-able types may be intended if you plan to later manually flatten or unwrap this Effect.`,
+                  fixes: fix
+                });
+              }),
+              ignore
+            );
+          }
+        }
+      }
+    }
   })
 });
 
@@ -3301,11 +3394,9 @@ var missingStarInYieldEffectGen = createDiagnostic({
 var unnecessaryEffectGen = createDiagnostic({
   name: "unnecessaryEffectGen",
   code: 5,
-  apply: fn("unnecessaryEffectGen.apply")(function* (sourceFile) {
+  apply: fn("unnecessaryEffectGen.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
-    const effectDiagnostics = [];
-    const unnecessaryGenerators = /* @__PURE__ */ new Map();
     const nodeToVisit = [];
     const appendNodeToVisit = (node) => {
       nodeToVisit.push(node);
@@ -3318,29 +3409,27 @@ var unnecessaryEffectGen = createDiagnostic({
       if (ts.isCallExpression(node)) {
         yield* pipe(
           typeParser.unnecessaryEffectGen(node),
-          map4(({ replacementNode }) => unnecessaryGenerators.set(node, replacementNode)),
+          map4(
+            ({ replacementNode }) => report({
+              node,
+              category: ts.DiagnosticCategory.Suggestion,
+              messageText: `This Effect.gen contains a single return statement.`,
+              fixes: [{
+                fixName: "unnecessaryEffectGen_fix",
+                description: "Remove the Effect.gen, and keep the body",
+                apply: gen2(function* () {
+                  const textChanges = yield* service(
+                    ChangeTracker
+                  );
+                  textChanges.replaceNode(sourceFile, node, yield* replacementNode);
+                })
+              }]
+            })
+          ),
           ignore
         );
       }
     }
-    unnecessaryGenerators.forEach(
-      (yieldedResult, effectGenCall) => effectDiagnostics.push({
-        node: effectGenCall,
-        category: ts.DiagnosticCategory.Suggestion,
-        messageText: `This Effect.gen contains a single return statement.`,
-        fixes: [{
-          fixName: "unnecessaryEffectGen_fix",
-          description: "Remove the Effect.gen, and keep the body",
-          apply: gen2(function* () {
-            const textChanges = yield* service(
-              ChangeTracker
-            );
-            textChanges.replaceNode(sourceFile, effectGenCall, yield* yieldedResult);
-          })
-        }]
-      })
-    );
-    return effectDiagnostics;
   })
 });
 
@@ -3348,11 +3437,9 @@ var unnecessaryEffectGen = createDiagnostic({
 var unnecessaryPipe = createDiagnostic({
   name: "unnecessaryPipe",
   code: 9,
-  apply: fn("unnecessaryPipe.apply")(function* (sourceFile) {
+  apply: fn("unnecessaryPipe.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
-    const pipeDiagnostics = [];
-    const unnecessaryPipes = /* @__PURE__ */ new Map();
     const nodeToVisit = [];
     const appendNodeToVisit = (node) => {
       nodeToVisit.push(node);
@@ -3365,29 +3452,29 @@ var unnecessaryPipe = createDiagnostic({
       if (ts.isCallExpression(node)) {
         yield* pipe(
           typeParser.pipeCall(node),
-          map4(({ args, subject }) => args.length === 0 ? unnecessaryPipes.set(node, subject) : void 0),
+          map4(({ args, subject }) => {
+            if (args.length === 0) {
+              report({
+                node,
+                category: ts.DiagnosticCategory.Suggestion,
+                messageText: `This pipe call contains no arguments.`,
+                fixes: [{
+                  fixName: "unnecessaryPipe_fix",
+                  description: "Remove the pipe call",
+                  apply: gen2(function* () {
+                    const textChanges = yield* service(
+                      ChangeTracker
+                    );
+                    textChanges.replaceNode(sourceFile, node, subject);
+                  })
+                }]
+              });
+            }
+          }),
           ignore
         );
       }
     }
-    unnecessaryPipes.forEach(
-      (pipeCall, pipeSubject) => pipeDiagnostics.push({
-        node: pipeCall,
-        category: ts.DiagnosticCategory.Suggestion,
-        messageText: `This pipe call contains no arguments.`,
-        fixes: [{
-          fixName: "unnecessaryPipe_fix",
-          description: "Remove the pipe call",
-          apply: gen2(function* () {
-            const textChanges = yield* service(
-              ChangeTracker
-            );
-            textChanges.replaceNode(sourceFile, pipeSubject, pipeCall);
-          })
-        }]
-      })
-    );
-    return pipeDiagnostics;
   })
 });
 
@@ -3401,7 +3488,9 @@ var diagnostics = [
   unnecessaryEffectGen,
   missingReturnYieldStar,
   leakingRequirements,
-  unnecessaryPipe
+  unnecessaryPipe,
+  genericEffectServices,
+  returnEffectInGen
 ];
 
 // src/goto/effectRpcDefinition.ts