@effect/language-service 0.28.1 → 0.28.2

package/README.md

@@ -45,6 +45,7 @@ And you're done! You'll now be able to use a set of refactors and diagnostics th
 - Multiple versions of Effect in your project
 - Warn on leaking requirements in Effect services
 - Warn on Scope as requirement of a Layer
+- Warn on subsequent `Effect.provide` anti-pattern
 - Unnecessary usages of `Effect.gen` or `pipe()`
 - Warn when importing from a barrel file instead of from the module directly
 - Warn on usage of try/catch inside `Effect.gen` and family

package/cli.js

@@ -32291,6 +32291,110 @@ var missingStarInYieldEffectGen = createDiagnostic({
   })
 });
 
+// src/diagnostics/multipleEffectProvide.ts
+var multipleEffectProvide = createDiagnostic({
+  name: "multipleEffectProvide",
+  code: 18,
+  severity: "warning",
+  apply: fn("multipleEffectProvide.apply")(function* (sourceFile, report) {
+    const ts2 = yield* service2(TypeScriptApi);
+    const typeChecker = yield* service2(TypeCheckerApi);
+    const typeParser = yield* service2(TypeParser);
+    const effectModuleIdentifier = yield* pipe(
+      findImportedModuleIdentifierByPackageAndNameOrBarrel(
+        sourceFile,
+        "effect",
+        "Effect"
+      ),
+      map33((_) => _.text),
+      orElse14(() => succeed17("Effect"))
+    );
+    const layerModuleIdentifier = yield* pipe(
+      findImportedModuleIdentifierByPackageAndNameOrBarrel(
+        sourceFile,
+        "effect",
+        "Layer"
+      ),
+      map33((_) => _.text),
+      orElse14(() => succeed17("Layer"))
+    );
+    const parseEffectProvideLayer = (node) => {
+      if (ts2.isCallExpression(node) && ts2.isPropertyAccessExpression(node.expression) && ts2.isIdentifier(node.expression.name) && node.expression.name.text === "provide" && node.arguments.length > 0) {
+        const layer12 = node.arguments[0];
+        const type2 = typeChecker.getTypeAtLocation(layer12);
+        return pipe(
+          typeParser.importedEffectModule(node.expression.expression),
+          flatMap18(() => typeParser.layerType(type2, layer12)),
+          map33(() => ({ layer: layer12, node })),
+          orElse14(() => void_8)
+        );
+      }
+      return void_8;
+    };
+    const parsePipeCall = (node) => gen3(function* () {
+      const { args: args3 } = yield* typeParser.pipeCall(node);
+      let currentChunk = 0;
+      const previousLayers = [[]];
+      for (const pipeArg of args3) {
+        const parsedProvide = yield* parseEffectProvideLayer(pipeArg);
+        if (parsedProvide) {
+          previousLayers[currentChunk].push(parsedProvide);
+        } else {
+          currentChunk++;
+          previousLayers.push([]);
+        }
+      }
+      for (const chunk4 of previousLayers) {
+        if (chunk4.length < 2) continue;
+        report({
+          node: chunk4[0].node,
+          messageText: "Calling multiple subsequent times Effect.provide is an anti-pattern and can lead to service lifecycle issues. You should combine the layers and provide them once instead.",
+          fixes: [{
+            fixName: "multipleEffectProvide_fix",
+            description: "Combine into a single provide",
+            apply: gen3(function* () {
+              const changeTracker = yield* service2(ChangeTracker);
+              changeTracker.deleteRange(sourceFile, {
+                pos: chunk4[0].node.getStart(sourceFile),
+                end: chunk4[chunk4.length - 1].node.getEnd()
+              });
+              const newNode = ts2.factory.createCallExpression(
+                ts2.factory.createPropertyAccessExpression(
+                  ts2.factory.createIdentifier(effectModuleIdentifier),
+                  ts2.factory.createIdentifier("provide")
+                ),
+                void 0,
+                [ts2.factory.createCallExpression(
+                  ts2.factory.createPropertyAccessExpression(
+                    ts2.factory.createIdentifier(layerModuleIdentifier),
+                    ts2.factory.createIdentifier("mergeAll")
+                  ),
+                  void 0,
+                  chunk4.map((c) => c.layer)
+                )]
+              );
+              changeTracker.insertNodeAt(sourceFile, chunk4[0].node.getStart(sourceFile), newNode);
+            })
+          }]
+        });
+      }
+    });
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts2.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts2.forEachChild(node, appendNodeToVisit);
+      if (ts2.isCallExpression(node)) {
+        yield* pipe(parsePipeCall(node), ignore3);
+      }
+    }
+  })
+});
+
 // src/diagnostics/returnEffectInGen.ts
 var returnEffectInGen = createDiagnostic({
   name: "returnEffectInGen",
@@ -32752,7 +32856,8 @@ var diagnostics = [
   scopeInLayerEffect,
   effectInVoidSuccess,
   unnecessaryPipeChain,
-  strictBooleanExpressions
+  strictBooleanExpressions,
+  multipleEffectProvide
 ];
 
 // src/cli.ts