@effect/language-service 0.28.0 → 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
@@ -65,6 +66,7 @@ And you're done! You'll now be able to use a set of refactors and diagnostics th
 - Transform an async function definition, into an Effect by using Effect.gen.
 - Transform an async function definition, into an Effect by using Effect.gen, and generating a tagged error for each promise call.
 - Transform a function returning an Effect.gen into a Effect.fn
+- Implement Service accessors in an `Effect.Service` or `Context.Tag` declaration
 - Function calls to pipe: Transform a set of function calls to a pipe() call.
 - Pipe to datafirst: Transform a pipe() call into a series of datafirst function calls (where available).
 - Toggle return type signature: With a single refactor, adds or removes type annotations from the definition.

package/cli.js

@@ -31471,6 +31471,47 @@ function make62(ts2, typeChecker) {
     "TypeParser.scopeType",
     (type2) => type2
   );
+  const promiseLike = cachedBy(
+    function(type2, atLocation) {
+      const thenProperty = type2.getProperty("then");
+      if (!thenProperty) return typeParserIssue("not a promise - missing then property", type2, atLocation);
+      const thenType = typeChecker.getTypeOfSymbolAtLocation(thenProperty, atLocation);
+      if (!thenType) return typeParserIssue("not a promise - missing then property", type2, atLocation);
+      for (const callSignature of thenType.getCallSignatures()) {
+        const parameter = callSignature.parameters[0];
+        if (!parameter) continue;
+        const parameterType = callSignature.getTypeParameterAtPosition(0);
+        if (!parameterType) continue;
+        let callbackCallSignatures = [];
+        let toTest = [parameterType];
+        while (toTest.length > 0) {
+          const type3 = toTest.shift();
+          if (!type3) continue;
+          const callSignatures = type3.getCallSignatures();
+          callbackCallSignatures = callbackCallSignatures.concat(callSignatures);
+          if (type3.isUnion()) {
+            toTest = toTest.concat(type3.types);
+          }
+        }
+        for (const callableType of callbackCallSignatures) {
+          const callbackParameter = callableType.parameters[0];
+          if (!callbackParameter) {
+            continue;
+          }
+          const callbackParameterType = callableType.getTypeParameterAtPosition(0);
+          if (!callbackParameterType) {
+            continue;
+          }
+          return succeed17({
+            type: callbackParameterType
+          });
+        }
+      }
+      return typeParserIssue("not a promise", type2, atLocation);
+    },
+    "TypeParser.promiseLike",
+    (type2) => type2
+  );
   return {
     effectType,
     strictEffectType,
@@ -31486,7 +31527,8 @@ function make62(ts2, typeChecker) {
     contextTag,
     pipeableType,
     pipeCall,
-    scopeType
+    scopeType,
+    promiseLike
   };
 }
 
@@ -32249,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",
@@ -32710,7 +32856,8 @@ var diagnostics = [
   scopeInLayerEffect,
   effectInVoidSuccess,
   unnecessaryPipeChain,
-  strictBooleanExpressions
+  strictBooleanExpressions,
+  multipleEffectProvide
 ];
 
 // src/cli.ts