@effect/language-service 0.28.0 → 0.28.2

package/index.js

@@ -2859,6 +2859,47 @@ function make3(ts, typeChecker) {
     "TypeParser.scopeType",
     (type) => type
   );
+  const promiseLike = cachedBy(
+    function(type, atLocation) {
+      const thenProperty = type.getProperty("then");
+      if (!thenProperty) return typeParserIssue("not a promise - missing then property", type, atLocation);
+      const thenType = typeChecker.getTypeOfSymbolAtLocation(thenProperty, atLocation);
+      if (!thenType) return typeParserIssue("not a promise - missing then property", type, 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 type2 = toTest.shift();
+          if (!type2) continue;
+          const callSignatures = type2.getCallSignatures();
+          callbackCallSignatures = callbackCallSignatures.concat(callSignatures);
+          if (type2.isUnion()) {
+            toTest = toTest.concat(type2.types);
+          }
+        }
+        for (const callableType of callbackCallSignatures) {
+          const callbackParameter = callableType.parameters[0];
+          if (!callbackParameter) {
+            continue;
+          }
+          const callbackParameterType = callableType.getTypeParameterAtPosition(0);
+          if (!callbackParameterType) {
+            continue;
+          }
+          return succeed({
+            type: callbackParameterType
+          });
+        }
+      }
+      return typeParserIssue("not a promise", type, atLocation);
+    },
+    "TypeParser.promiseLike",
+    (type) => type
+  );
   return {
     effectType,
     strictEffectType,
@@ -2874,7 +2915,8 @@ function make3(ts, typeChecker) {
     contextTag,
     pipeableType,
     pipeCall,
-    scopeType
+    scopeType,
+    promiseLike
   };
 }
 
@@ -3589,6 +3631,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 ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
+    const effectModuleIdentifier = yield* pipe(
+      findImportedModuleIdentifierByPackageAndNameOrBarrel(
+        sourceFile,
+        "effect",
+        "Effect"
+      ),
+      map4((_) => _.text),
+      orElse2(() => succeed("Effect"))
+    );
+    const layerModuleIdentifier = yield* pipe(
+      findImportedModuleIdentifierByPackageAndNameOrBarrel(
+        sourceFile,
+        "effect",
+        "Layer"
+      ),
+      map4((_) => _.text),
+      orElse2(() => succeed("Layer"))
+    );
+    const parseEffectProvideLayer = (node) => {
+      if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.name) && node.expression.name.text === "provide" && node.arguments.length > 0) {
+        const layer = node.arguments[0];
+        const type = typeChecker.getTypeAtLocation(layer);
+        return pipe(
+          typeParser.importedEffectModule(node.expression.expression),
+          flatMap2(() => typeParser.layerType(type, layer)),
+          map4(() => ({ layer, node })),
+          orElse2(() => void_)
+        );
+      }
+      return void_;
+    };
+    const parsePipeCall = (node) => gen(function* () {
+      const { args: args2 } = yield* typeParser.pipeCall(node);
+      let currentChunk = 0;
+      const previousLayers = [[]];
+      for (const pipeArg of args2) {
+        const parsedProvide = yield* parseEffectProvideLayer(pipeArg);
+        if (parsedProvide) {
+          previousLayers[currentChunk].push(parsedProvide);
+        } else {
+          currentChunk++;
+          previousLayers.push([]);
+        }
+      }
+      for (const chunk of previousLayers) {
+        if (chunk.length < 2) continue;
+        report({
+          node: chunk[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: gen(function* () {
+              const changeTracker = yield* service(ChangeTracker);
+              changeTracker.deleteRange(sourceFile, {
+                pos: chunk[0].node.getStart(sourceFile),
+                end: chunk[chunk.length - 1].node.getEnd()
+              });
+              const newNode = ts.factory.createCallExpression(
+                ts.factory.createPropertyAccessExpression(
+                  ts.factory.createIdentifier(effectModuleIdentifier),
+                  ts.factory.createIdentifier("provide")
+                ),
+                void 0,
+                [ts.factory.createCallExpression(
+                  ts.factory.createPropertyAccessExpression(
+                    ts.factory.createIdentifier(layerModuleIdentifier),
+                    ts.factory.createIdentifier("mergeAll")
+                  ),
+                  void 0,
+                  chunk.map((c) => c.layer)
+                )]
+              );
+              changeTracker.insertNodeAt(sourceFile, chunk[0].node.getStart(sourceFile), newNode);
+            })
+          }]
+        });
+      }
+    });
+    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)) {
+        yield* pipe(parsePipeCall(node), ignore);
+      }
+    }
+  })
+});
+
 // src/diagnostics/returnEffectInGen.ts
 var returnEffectInGen = createDiagnostic({
   name: "returnEffectInGen",
@@ -4050,7 +4196,8 @@ var diagnostics = [
   scopeInLayerEffect,
   effectInVoidSuccess,
   unnecessaryPipeChain,
-  strictBooleanExpressions
+  strictBooleanExpressions,
+  multipleEffectProvide
 ];
 
 // src/completions/effectDiagnosticsComment.ts
@@ -11083,6 +11230,273 @@ var wrapWithPipe = createRefactor({
   })
 });
 
+// src/refactors/writeTagClassAccessors.ts
+var writeTagClassAccessors = createRefactor({
+  name: "writeTagClassAccessors",
+  description: "Implement Service accessors",
+  apply: fn("writeTagClassAccessors.apply")(function* (sourceFile, textRange) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
+    const effectIdentifier = pipe(
+      yield* option(
+        findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, "effect", "Effect")
+      ),
+      match({
+        onNone: () => "Effect",
+        onSome: (_) => _.text
+      })
+    );
+    const createConstantProperty = (className, propertyName, type) => ts.factory.createPropertyDeclaration(
+      [ts.factory.createModifier(ts.SyntaxKind.StaticKeyword)],
+      propertyName,
+      void 0,
+      type,
+      ts.factory.createCallExpression(
+        ts.factory.createPropertyAccessExpression(
+          ts.factory.createIdentifier(effectIdentifier),
+          "andThen"
+        ),
+        void 0,
+        [
+          ts.factory.createIdentifier(className.text),
+          ts.factory.createArrowFunction(
+            void 0,
+            void 0,
+            [ts.factory.createParameterDeclaration(
+              void 0,
+              void 0,
+              "_"
+            )],
+            void 0,
+            void 0,
+            ts.factory.createPropertyAccessExpression(
+              ts.factory.createIdentifier("_"),
+              propertyName
+            )
+          )
+        ]
+      )
+    );
+    const createFunctionProperty = (className, propertyName, type, forceAny) => {
+      const arrowBody = ts.factory.createCallExpression(
+        ts.factory.createPropertyAccessExpression(
+          ts.factory.createIdentifier(effectIdentifier),
+          "andThen"
+        ),
+        void 0,
+        [
+          ts.factory.createIdentifier(className.text),
+          ts.factory.createArrowFunction(
+            void 0,
+            void 0,
+            [ts.factory.createParameterDeclaration(
+              void 0,
+              void 0,
+              "_",
+              void 0,
+              forceAny ? ts.factory.createTypeReferenceNode("any") : void 0
+            )],
+            void 0,
+            void 0,
+            ts.factory.createCallExpression(
+              ts.factory.createPropertyAccessExpression(
+                ts.factory.createIdentifier("_"),
+                propertyName
+              ),
+              void 0,
+              [
+                ts.factory.createSpreadElement(ts.factory.createIdentifier("args"))
+              ]
+            )
+          )
+        ]
+      );
+      return ts.factory.createPropertyDeclaration(
+        [ts.factory.createModifier(ts.SyntaxKind.StaticKeyword)],
+        propertyName,
+        void 0,
+        type,
+        ts.factory.createArrowFunction(
+          void 0,
+          void 0,
+          [ts.factory.createParameterDeclaration(
+            void 0,
+            ts.factory.createToken(ts.SyntaxKind.DotDotDotToken),
+            "args",
+            void 0,
+            forceAny ? ts.factory.createArrayTypeNode(ts.factory.createTypeReferenceNode("any")) : void 0
+          )],
+          void 0,
+          void 0,
+          forceAny ? ts.factory.createAsExpression(arrowBody, ts.factory.createTypeReferenceNode("any")) : arrowBody
+        )
+      );
+    };
+    const generateReturnType = (type, atLocation, className) => pipe(
+      typeParser.effectType(type, atLocation),
+      flatMap2((returnedEffect) => {
+        const contextType = returnedEffect.R.flags & ts.TypeFlags.Never ? ts.factory.createTypeReferenceNode(className.text) : ts.factory.createUnionTypeNode(
+          [
+            ts.factory.createTypeReferenceNode(className.text),
+            typeChecker.typeToTypeNode(returnedEffect.R, atLocation, ts.NodeBuilderFlags.NoTruncation)
+          ]
+        );
+        const successType = typeChecker.typeToTypeNode(
+          returnedEffect.A,
+          atLocation,
+          ts.NodeBuilderFlags.NoTruncation
+        );
+        if (!successType) return fail("error generating success type");
+        const failureType = typeChecker.typeToTypeNode(
+          returnedEffect.E,
+          atLocation,
+          ts.NodeBuilderFlags.NoTruncation
+        );
+        if (!failureType) return fail("error generating failure type");
+        const typeNode = ts.factory.createTypeReferenceNode(
+          ts.factory.createQualifiedName(
+            ts.factory.createIdentifier(effectIdentifier),
+            ts.factory.createIdentifier("Effect")
+          ),
+          [successType, failureType, contextType]
+        );
+        return succeed(typeNode);
+      }),
+      orElse2(
+        () => pipe(
+          typeParser.promiseLike(type, atLocation),
+          flatMap2(({ type: type2 }) => {
+            const successType = typeChecker.typeToTypeNode(
+              type2,
+              atLocation,
+              ts.NodeBuilderFlags.NoTruncation
+            );
+            if (!successType) return fail("error generating success type");
+            return succeed(ts.factory.createTypeReferenceNode(
+              ts.factory.createQualifiedName(
+                ts.factory.createIdentifier(effectIdentifier),
+                ts.factory.createIdentifier("Effect")
+              ),
+              [
+                successType,
+                ts.factory.createTypeReferenceNode(
+                  ts.factory.createQualifiedName(
+                    ts.factory.createIdentifier("Cause"),
+                    ts.factory.createIdentifier("UnknownException")
+                  )
+                ),
+                ts.factory.createTypeReferenceNode(className.text)
+              ]
+            ));
+          })
+        )
+      ),
+      orElse2(() => {
+        const successType = typeChecker.typeToTypeNode(type, atLocation, ts.NodeBuilderFlags.NoTruncation);
+        if (!successType) return fail("error generating success type");
+        const typeNode = ts.factory.createTypeReferenceNode(
+          ts.factory.createQualifiedName(
+            ts.factory.createIdentifier(effectIdentifier),
+            ts.factory.createIdentifier("Effect")
+          ),
+          [
+            successType,
+            ts.factory.createTypeReferenceNode("never"),
+            ts.factory.createTypeReferenceNode(className.text)
+          ]
+        );
+        return succeed(typeNode);
+      })
+    );
+    const proxySignature = (signature, atLocation, className) => gen(function* () {
+      const signatureDeclaration = typeChecker.signatureToSignatureDeclaration(
+        signature,
+        ts.SyntaxKind.FunctionType,
+        atLocation,
+        ts.NodeBuilderFlags.NoTruncation
+      );
+      if (!signatureDeclaration) return yield* fail("error generating signature");
+      const returnType = yield* generateReturnType(signature.getReturnType(), atLocation, className);
+      return ts.factory.createFunctionTypeNode(
+        signatureDeclaration.typeParameters,
+        signatureDeclaration.parameters,
+        returnType
+      );
+    });
+    const writeAccessors = fn("writeTagClassAccessors.writeAccessors")(
+      function* (service2, className, atLocation) {
+        const changeTracker = yield* service(ChangeTracker);
+        const insertLocation = atLocation.members.length > 0 ? atLocation.members[0].pos : atLocation.getEnd() - 1;
+        for (const property of typeChecker.getPropertiesOfType(service2)) {
+          const servicePropertyType = typeChecker.getTypeOfSymbolAtLocation(property, atLocation);
+          const callSignatures = [];
+          let propertyDeclaration = void 0;
+          for (const signature of servicePropertyType.getCallSignatures()) {
+            yield* pipe(
+              proxySignature(signature, atLocation, className),
+              map4((sig) => {
+                callSignatures.push(sig);
+              }),
+              ignore
+            );
+          }
+          if (callSignatures.length === 0) {
+            yield* pipe(
+              generateReturnType(servicePropertyType, atLocation, className),
+              map4((type) => {
+                propertyDeclaration = createConstantProperty(className, property.getName(), type);
+              }),
+              ignore
+            );
+          } else {
+            const allSignatures = ts.factory.createIntersectionTypeNode(callSignatures);
+            const type = yield* simplifyTypeNode(allSignatures);
+            propertyDeclaration = createFunctionProperty(className, property.getName(), type, callSignatures.length > 1);
+          }
+          if (propertyDeclaration) {
+            const oldProperty = atLocation.members.filter(ts.isPropertyDeclaration).find((p) => {
+              const symbol3 = typeChecker.getSymbolAtLocation(p.name);
+              return symbol3?.getName() === property.getName();
+            });
+            if (oldProperty) {
+              changeTracker.deleteRange(sourceFile, {
+                pos: oldProperty.getStart(sourceFile),
+                end: oldProperty.getEnd()
+              });
+              changeTracker.insertNodeAt(sourceFile, oldProperty.getStart(sourceFile), propertyDeclaration);
+            } else {
+              changeTracker.insertNodeAt(sourceFile, insertLocation, propertyDeclaration, { suffix: "\n" });
+            }
+          }
+        }
+      }
+    );
+    const writeTagClassAccessors2 = (node) => gen(function* () {
+      if (!ts.isClassDeclaration(node)) return yield* fail(new RefactorNotApplicableError());
+      if (!node.name) return yield* fail(new RefactorNotApplicableError());
+      const classSym = typeChecker.getSymbolAtLocation(node.name);
+      if (!classSym) return yield* fail(new RefactorNotApplicableError());
+      const type = typeChecker.getTypeOfSymbol(classSym);
+      const { Service } = yield* pipe(
+        typeParser.contextTag(type, node),
+        orElse2(() => fail(new RefactorNotApplicableError()))
+      );
+      return {
+        kind: "refactor.rewrite.effect.writeTagClassAccessors",
+        description: "Implement Service accessors",
+        apply: pipe(
+          writeAccessors(Service, node.name, node),
+          provideService(TypeCheckerApi, typeChecker),
+          provideService(TypeScriptApi, ts)
+        )
+      };
+    });
+    const parentNodes = yield* getAncestorNodesInRange(sourceFile, textRange);
+    return yield* firstSuccessOf(parentNodes.map(writeTagClassAccessors2));
+  })
+});
+
 // src/refactors.ts
 var refactors = [
   asyncAwaitToGen,
@@ -11100,7 +11514,8 @@ var refactors = [
   wrapWithEffectGen,
   wrapWithPipe,
   effectGenToFn,
-  togglePipeStyle
+  togglePipeStyle,
+  writeTagClassAccessors
 ];
 
 // src/index.ts