@effect/language-service 0.68.0 → 0.69.0

package/index.js

@@ -8325,6 +8325,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),
+        map8((result) => ({
+          kind: "fn",
+          effectModule: result.effectModule,
+          generatorFunction: result.generatorFunction,
+          pipeArguments: result.pipeArguments
+        })),
+        orElse2(
+          () => pipe(
+            typeParser.effectFnUntracedGen(innerCall),
+            map8((result) => ({
+              kind: "fnUntraced",
+              effectModule: result.effectModule,
+              generatorFunction: result.generatorFunction,
+              pipeArguments: result.pipeArguments
+            }))
+          )
+        ),
+        orElse2(
+          () => pipe(
+            typeParser.effectFn(innerCall),
+            map8((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",
@@ -11592,6 +11690,7 @@ var diagnostics = [
   globalErrorInEffectFailure,
   layerMergeAllWithDependencies,
   effectMapVoid,
+  effectFnIife,
   effectFnOpportunity,
   redundantSchemaTagIdentifier,
   schemaSyncInEffect,