@effect/language-service 0.68.0 → 0.69.1

package/package.json

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

package/transform.js

@@ -4851,6 +4851,104 @@ ${versions.map((version) => `- found ${version} at ${resolvedPackages[packageNam
   })
 });
 
+// src/diagnostics/effectFnIife.ts
+var effectFnIife = createDiagnostic({
+  name: "effectFnIife",
+  code: 46,
+  description: "Effect.fn or Effect.fnUntraced is called as an IIFE (Immediately Invoked Function Expression). Use Effect.gen instead.",
+  severity: "warning",
+  apply: fn("effectFnIife.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
+    const tsUtils = yield* service(TypeScriptUtils);
+    const sourceEffectModuleName = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+      sourceFile,
+      "effect",
+      "Effect"
+    ) || "Effect";
+    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.isCallExpression(node)) continue;
+      const innerCall = node.expression;
+      if (!ts.isCallExpression(innerCall)) continue;
+      const parsed = yield* pipe(
+        typeParser.effectFnGen(innerCall),
+        map4((result) => ({
+          kind: "fn",
+          effectModule: result.effectModule,
+          generatorFunction: result.generatorFunction,
+          pipeArguments: result.pipeArguments
+        })),
+        orElse2(
+          () => pipe(
+            typeParser.effectFnUntracedGen(innerCall),
+            map4((result) => ({
+              kind: "fnUntraced",
+              effectModule: result.effectModule,
+              generatorFunction: result.generatorFunction,
+              pipeArguments: result.pipeArguments
+            }))
+          )
+        ),
+        orElse2(
+          () => pipe(
+            typeParser.effectFn(innerCall),
+            map4((result) => ({
+              kind: "fn",
+              effectModule: result.effectModule,
+              generatorFunction: void 0,
+              pipeArguments: result.pipeArguments
+            }))
+          )
+        ),
+        option
+      );
+      if (isNone2(parsed)) continue;
+      const { effectModule, generatorFunction, kind, pipeArguments: pipeArguments2 } = parsed.value;
+      const effectModuleName = ts.isIdentifier(effectModule) ? ts.idText(effectModule) : sourceEffectModuleName;
+      const fixes = [];
+      if (generatorFunction && generatorFunction.parameters.length === 0) {
+        fixes.push({
+          fixName: "effectFnIife_toEffectGen",
+          description: "Convert to Effect.gen",
+          apply: gen(function* () {
+            const changeTracker = yield* service(ChangeTracker);
+            const effectGenCall = ts.factory.createCallExpression(
+              ts.factory.createPropertyAccessExpression(
+                ts.factory.createIdentifier(effectModuleName),
+                "gen"
+              ),
+              void 0,
+              [generatorFunction]
+            );
+            let replacementNode = effectGenCall;
+            if (pipeArguments2.length > 0) {
+              replacementNode = ts.factory.createCallExpression(
+                ts.factory.createPropertyAccessExpression(effectGenCall, "pipe"),
+                void 0,
+                [...pipeArguments2]
+              );
+            }
+            changeTracker.replaceNode(sourceFile, node, replacementNode);
+          })
+        });
+      }
+      report({
+        location: node,
+        messageText: `${effectModuleName}.${kind} returns a reusable function that can take arguments, but here it's called immediately. Use Effect.gen instead (optionally with Effect.withSpan for tracing).`,
+        fixes
+      });
+    }
+  })
+});
+
 // src/diagnostics/effectFnOpportunity.ts
 var effectFnOpportunity = createDiagnostic({
   name: "effectFnOpportunity",
@@ -5116,9 +5214,11 @@ var effectFnOpportunity = createDiagnostic({
         });
       }
       const pipeArgsSuffix = pipeArguments2.length > 0 ? ` Effect.fn also accepts the piped transformations as additional arguments.` : ``;
+      const suggestConsultingQuickFixes = ` Your editor quickfixes or the "effect-language-service" cli can show you how to convert to Effect.fn or Effect.fnUntraced.`;
+      const orFnUntraced = target.value.generatorFunction ? `, or Effect.fnUntraced` : ``;
       report({
         location: nameIdentifier ?? targetNode,
-        messageText: target.value.generatorFunction ? `This function could benefit from Effect.fn's automatic tracing and concise syntax, or Effect.fnUntraced to get just a more concise syntax.${pipeArgsSuffix}` : `This function could benefit from Effect.fn's automatic tracing and concise syntax.${pipeArgsSuffix}`,
+        messageText: `This function could benefit from Effect.fn's automatic tracing and concise syntax${orFnUntraced}.${pipeArgsSuffix}${suggestConsultingQuickFixes}`,
         fixes
       });
     }
@@ -9151,6 +9251,7 @@ var diagnostics = [
   globalErrorInEffectFailure,
   layerMergeAllWithDependencies,
   effectMapVoid,
+  effectFnIife,
   effectFnOpportunity,
   redundantSchemaTagIdentifier,
   schemaSyncInEffect,