@effect/language-service 0.68.0 → 0.69.1

package/README.md

@@ -81,6 +81,7 @@ And you're done! You'll now be able to use a set of refactors and diagnostics th
 - Warn when using `Effect.fail` with the global `Error` type, recommending tagged errors
 - Warn when `Layer.mergeAll` contains layers with interdependencies (where one layer provides a service that another layer in the same call requires)
 - Suggest using `Effect.fn` for functions that return `Effect.gen` for better tracing and concise syntax
+- Warn when `Effect.fn` or `Effect.fnUntraced` is used as an IIFE (Immediately Invoked Function Expression), suggesting `Effect.gen` instead
 - Suggest removing redundant identifier argument when it equals the tag value in `Schema.TaggedClass`, `Schema.TaggedError`, or `Schema.TaggedRequest`
 - Suggest using `Schema.is` instead of `instanceof` for Effect Schema types
 

package/cli.js

@@ -30214,7 +30214,7 @@ var runMain3 = runMain2;
 // package.json
 var package_default = {
   name: "@effect/language-service",
-  version: "0.68.0",
+  version: "0.69.1",
   packageManager: "pnpm@8.11.0",
   publishConfig: {
     access: "public",
@@ -36266,6 +36266,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: fn2("effectFnIife.apply")(function* (sourceFile, report) {
+    const ts = yield* service2(TypeScriptApi);
+    const typeParser = yield* service2(TypeParser);
+    const tsUtils = yield* service2(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),
+        map34((result) => ({
+          kind: "fn",
+          effectModule: result.effectModule,
+          generatorFunction: result.generatorFunction,
+          pipeArguments: result.pipeArguments
+        })),
+        orElse15(
+          () => pipe(
+            typeParser.effectFnUntracedGen(innerCall),
+            map34((result) => ({
+              kind: "fnUntraced",
+              effectModule: result.effectModule,
+              generatorFunction: result.generatorFunction,
+              pipeArguments: result.pipeArguments
+            }))
+          )
+        ),
+        orElse15(
+          () => pipe(
+            typeParser.effectFn(innerCall),
+            map34((result) => ({
+              kind: "fn",
+              effectModule: result.effectModule,
+              generatorFunction: void 0,
+              pipeArguments: result.pipeArguments
+            }))
+          )
+        ),
+        option5
+      );
+      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: gen3(function* () {
+            const changeTracker = yield* service2(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",
@@ -36531,9 +36629,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
       });
     }
@@ -39533,6 +39633,7 @@ var diagnostics = [
   globalErrorInEffectFailure,
   layerMergeAllWithDependencies,
   effectMapVoid,
+  effectFnIife,
   effectFnOpportunity,
   redundantSchemaTagIdentifier,
   schemaSyncInEffect,