@effect/language-service 0.57.0 → 0.57.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect/language-service",
-  "version": "0.57.0",
+  "version": "0.57.1",
   "description": "A Language-Service Plugin to Refactor and Diagnostic effect-ts projects",
   "main": "index.cjs",
   "bin": {

package/transform.js

@@ -5897,6 +5897,11 @@ var runEffectInsideEffect = createDiagnostic({
   apply: fn("runEffectInsideEffect.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
+    const tsUtils = yield* service(TypeScriptUtils);
+    const parseEffectMethod = (node, methodName) => pipe(
+      typeParser.isNodeReferenceToEffectModuleApi(methodName)(node),
+      map4(() => ({ node, methodName }))
+    );
     const nodeToVisit = [];
     const appendNodeToVisit = (node) => {
       nodeToVisit.push(node);
@@ -5907,11 +5912,12 @@ var runEffectInsideEffect = createDiagnostic({
       const node = nodeToVisit.shift();
       ts.forEachChild(node, appendNodeToVisit);
       if (!ts.isCallExpression(node)) continue;
+      if (node.arguments.length === 0) continue;
       const isEffectRunCall = yield* pipe(
-        typeParser.isNodeReferenceToEffectModuleApi("runPromise")(node.expression),
-        orElse2(() => typeParser.isNodeReferenceToEffectModuleApi("runSync")(node.expression)),
-        orElse2(() => typeParser.isNodeReferenceToEffectModuleApi("runFork")(node.expression)),
-        orElse2(() => typeParser.isNodeReferenceToEffectModuleApi("runCallback")(node.expression)),
+        parseEffectMethod(node.expression, "runPromise"),
+        orElse2(() => parseEffectMethod(node.expression, "runSync")),
+        orElse2(() => parseEffectMethod(node.expression, "runFork")),
+        orElse2(() => parseEffectMethod(node.expression, "runCallback")),
         option
       );
       if (isNone2(isEffectRunCall)) continue;
@@ -5931,18 +5937,90 @@ var runEffectInsideEffect = createDiagnostic({
           orElse2(() => typeParser.effectFnGen(possiblyEffectGen)),
           option
         );
-        if (isSome2(isInEffectGen)) {
+        if (isSome2(isInEffectGen) && isInEffectGen.value.body.statements.length > 0) {
           const nodeText = sourceFile.text.substring(
             ts.getTokenPosOfNode(node.expression, sourceFile),
             node.expression.end
           );
-          const messageText = nodeIntroduceScope && nodeIntroduceScope !== isInEffectGen.value.generatorFunction ? `Using ${nodeText} inside an Effect is not recommended. The same runtime should generally be used instead to run child effects.
-Consider extracting the Runtime by using for example Effect.runtime and then use Runtime.run* with the extracted runtime instead.` : `Using ${nodeText} inside an Effect is not recommended. Effects inside generators can usually just be yielded.`;
-          report({
-            location: node.expression,
-            messageText,
-            fixes: []
-          });
+          if (nodeIntroduceScope && nodeIntroduceScope !== isInEffectGen.value.generatorFunction) {
+            const fixAddRuntime = gen(function* () {
+              const changeTracker = yield* service(ChangeTracker);
+              const runtimeModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, "effect", "Runtime") || "Runtime";
+              const effectModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, "effect", "Effect") || "Effect";
+              let runtimeIdentifier = void 0;
+              for (const statement of isInEffectGen.value.generatorFunction.body.statements) {
+                if (ts.isVariableStatement(statement) && statement.declarationList.declarations.length === 1) {
+                  const declaration = statement.declarationList.declarations[0];
+                  if (declaration.initializer && ts.isYieldExpression(declaration.initializer) && declaration.initializer.asteriskToken && declaration.initializer.expression) {
+                    const yieldedExpression = declaration.initializer.expression;
+                    if (ts.isCallExpression(yieldedExpression)) {
+                      const maybeEffectRuntime = yield* pipe(
+                        typeParser.isNodeReferenceToEffectModuleApi("runtime")(yieldedExpression.expression),
+                        option
+                      );
+                      if (isSome2(maybeEffectRuntime) && ts.isIdentifier(declaration.name)) {
+                        runtimeIdentifier = ts.idText(declaration.name);
+                      }
+                    }
+                  }
+                }
+              }
+              if (!runtimeIdentifier) {
+                changeTracker.insertNodeAt(
+                  sourceFile,
+                  isInEffectGen.value.body.statements[0].pos,
+                  ts.factory.createVariableStatement(
+                    void 0,
+                    ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(
+                      "effectRuntime",
+                      void 0,
+                      void 0,
+                      ts.factory.createYieldExpression(
+                        ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+                        ts.factory.createCallExpression(
+                          ts.factory.createPropertyAccessExpression(
+                            ts.factory.createIdentifier(effectModuleIdentifier),
+                            "runtime"
+                          ),
+                          [ts.factory.createTypeReferenceNode("never")],
+                          []
+                        )
+                      )
+                    )], ts.NodeFlags.Const)
+                  ),
+                  {
+                    prefix: "\n",
+                    suffix: "\n"
+                  }
+                );
+              }
+              changeTracker.deleteRange(sourceFile, {
+                pos: ts.getTokenPosOfNode(node.expression, sourceFile),
+                end: node.arguments[0].pos
+              });
+              changeTracker.insertText(
+                sourceFile,
+                node.arguments[0].pos,
+                `${runtimeModuleIdentifier}.${isEffectRunCall.value.methodName}(${runtimeIdentifier || "effectRuntime"}, `
+              );
+            });
+            report({
+              location: node.expression,
+              messageText: `Using ${nodeText} inside an Effect is not recommended. The same runtime should generally be used instead to run child effects.
+Consider extracting the Runtime by using for example Effect.runtime and then use Runtime.${isEffectRunCall.value.methodName} with the extracted runtime instead.`,
+              fixes: [{
+                fixName: "runEffectInsideEffect_fix",
+                description: "Use a runtime to run the Effect",
+                apply: fixAddRuntime
+              }]
+            });
+          } else {
+            report({
+              location: node.expression,
+              messageText: `Using ${nodeText} inside an Effect is not recommended. Effects inside generators can usually just be yielded.`,
+              fixes: []
+            });
+          }
         }
         currentParent = currentParent.parent;
       }