@effect/language-service 0.56.0 → 0.57.1

package/README.md

@@ -72,6 +72,7 @@ And you're done! You'll now be able to use a set of refactors and diagnostics th
 - Warn when catch callbacks in `Effect.tryPromise`, `Effect.tryMap`, or `Effect.tryMapPromise` return `unknown` or `any` types
 - Warn when using `Effect.runSync`, `Effect.runPromise`, `Effect.runFork`, or `Effect.runCallback` inside an Effect
 - Warn when using `Schema.Union` with multiple `Schema.Literal` calls that can be simplified to a single `Schema.Literal` call
+- Warn when using `yield* Effect.fail()` with yieldable error types that can be yielded directly
 
 ### Completions
 
@@ -99,6 +100,11 @@ And you're done! You'll now be able to use a set of refactors and diagnostics th
 - Toggle between pipe styles `X.pipe(Y)` and `pipe(X, Y)`
 - Layer Magic: Automatically compose and build layers based on service dependencies
 
+### Codegens
+
+- Automatically adds type annotations to exported constants based on their initializer types using `// @effect-codegens annotate`
+- Automatically implements service accessors in `Effect.Service`, `Context.Tag` or `Effect.Tag` declarations using `// @effect-codegens accessors`
+
 ### Miscellaneous
 - Renaming a class name, will rename the identifier as well for TaggedError, TaggedClass, etc...
 - "Go to definition" for RpcClient will resolve to the Rpc definition

package/cli.js

@@ -32083,6 +32083,51 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     if (!symbol3) return typeParserIssue("Node has no symbol", void 0, givenNode);
     return isSymbolExportOfPackageModule(symbol3, packageName, memberName, isCorrectSourceFile);
   };
+  const findSymbolsMatchingPackageAndExportedName = (packageName, exportedSymbolName) => cachedBy(
+    fn2("TypeParser.findSymbolsMatchingPackageAndExportedName")(function* (_fromSourceFile) {
+      const result = [];
+      for (const sourceFile of program.getSourceFiles()) {
+        const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
+        if (!moduleSymbol) continue;
+        const symbol3 = typeChecker.tryGetMemberInModuleExports(exportedSymbolName, moduleSymbol);
+        if (!symbol3) continue;
+        const packageInfo = yield* getSourceFilePackageInfo(sourceFile);
+        if (!packageInfo || packageInfo.name.toLowerCase() !== packageName.toLowerCase()) continue;
+        result.push([symbol3, sourceFile]);
+      }
+      return result;
+    }),
+    `TypeParser.findSymbolsMatchingPackageAndExportedName(${packageName}, ${exportedSymbolName})`,
+    (sourceFile) => sourceFile
+  );
+  const isCauseTypeSourceFile = cachedBy(
+    fn2("TypeParser.isCauseTypeSourceFile")(function* (sourceFile) {
+      const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
+      if (!moduleSymbol) return yield* typeParserIssue("Node has no symbol", void 0, sourceFile);
+      const causeTypeSymbol = typeChecker.tryGetMemberInModuleExports("Cause", moduleSymbol);
+      if (!causeTypeSymbol) return yield* typeParserIssue("Cause type not found", void 0, sourceFile);
+      const type2 = typeChecker.getDeclaredTypeOfSymbol(causeTypeSymbol);
+      yield* pipeableType(type2, sourceFile);
+      return sourceFile;
+    }),
+    "TypeParser.isCauseTypeSourceFile",
+    (sourceFile) => sourceFile
+  );
+  const effectCauseYieldableErrorTypes = cachedBy(
+    fn2("TypeParser.effectCauseYieldableErrorTypes")(function* (fromSourceFile) {
+      const symbols = yield* findSymbolsMatchingPackageAndExportedName("effect", "YieldableError")(fromSourceFile);
+      const result = [];
+      for (const [symbol3, sourceFile] of symbols) {
+        const causeFile = yield* isCauseTypeSourceFile(sourceFile);
+        if (!causeFile) continue;
+        const type2 = typeChecker.getDeclaredTypeOfSymbol(symbol3);
+        result.push(type2);
+      }
+      return result;
+    }),
+    "TypeParser.effectCauseYieldableErrorTypes",
+    (fromSourceFile) => fromSourceFile
+  );
   function covariantTypeArgument(type2) {
     const signatures = typeChecker.getSignaturesOfType(type2, ts.SignatureKind.Call);
     if (signatures.length !== 1) {
@@ -33072,6 +33117,7 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     effectGen,
     effectFnUntracedGen,
     effectFnGen,
+    effectCauseYieldableErrorTypes,
     unnecessaryEffectGen: unnecessaryEffectGen2,
     effectSchemaType,
     contextTag,
@@ -33382,8 +33428,93 @@ var accessors = createCodegen({
   })
 });
 
+// src/codegens/annotate.ts
+var annotate3 = createCodegen({
+  name: "annotate",
+  apply: fn2("annotate.apply")(function* (sourceFile, textRange) {
+    const ts = yield* service2(TypeScriptApi);
+    const tsUtils = yield* service2(TypeScriptUtils);
+    const typeChecker = yield* service2(TypeCheckerApi);
+    const typeCheckerUtils = yield* service2(TypeCheckerUtils);
+    const parse6 = (node) => gen3(function* () {
+      let variableDeclarations = [];
+      const result = [];
+      if (ts.isVariableStatement(node)) {
+        variableDeclarations = [...variableDeclarations, ...node.declarationList.declarations];
+      } else if (ts.isVariableDeclarationList(node)) {
+        variableDeclarations = [...variableDeclarations, ...node.declarations];
+      } else if (ts.isVariableDeclaration(node)) {
+        variableDeclarations = [...variableDeclarations, node];
+      }
+      if (variableDeclarations.length === 0) {
+        return yield* fail18(new CodegenNotApplicableError("not a variable declaration"));
+      }
+      for (const variableDeclaration of variableDeclarations) {
+        if (!variableDeclaration.initializer) continue;
+        const initializerType = typeChecker.getTypeAtLocation(variableDeclaration.initializer);
+        const initializerTypeNode = fromNullable(typeCheckerUtils.typeToSimplifiedTypeNode(
+          initializerType,
+          node,
+          ts.NodeBuilderFlags.NoTruncation
+        )).pipe(
+          orElse(
+            () => fromNullable(typeCheckerUtils.typeToSimplifiedTypeNode(
+              initializerType,
+              void 0,
+              ts.NodeBuilderFlags.NoTruncation
+            ))
+          ),
+          getOrUndefined
+        );
+        if (!initializerTypeNode) continue;
+        const typeNodeString = typeChecker.typeToString(initializerType, void 0, ts.TypeFormatFlags.NoTruncation);
+        const hash3 = cyrb53(typeNodeString);
+        result.push({ variableDeclaration, initializerTypeNode, hash: hash3 });
+      }
+      if (result.length === 0) {
+        return yield* fail18(new CodegenNotApplicableError("no variable declarations with initializers"));
+      }
+      const hash2 = cyrb53(result.map((_) => _.hash).join("/"));
+      return {
+        hash: hash2,
+        result
+      };
+    });
+    const nodeAndCommentRange = tsUtils.findNodeWithLeadingCommentAtPosition(sourceFile, textRange.pos);
+    if (!nodeAndCommentRange) return yield* fail18(new CodegenNotApplicableError("no node and comment range"));
+    return yield* pipe(
+      parse6(nodeAndCommentRange.node),
+      map34(
+        (_) => ({
+          hash: _.hash,
+          description: "Annotate with type",
+          apply: gen3(function* () {
+            const changeTracker = yield* service2(ChangeTracker);
+            for (const { initializerTypeNode, variableDeclaration } of _.result) {
+              if (variableDeclaration.type) {
+                changeTracker.deleteRange(sourceFile, {
+                  pos: variableDeclaration.name.end,
+                  end: variableDeclaration.type.end
+                });
+              }
+              changeTracker.insertNodeAt(
+                sourceFile,
+                variableDeclaration.name.end,
+                initializerTypeNode,
+                {
+                  prefix: ": "
+                }
+              );
+            }
+          })
+        })
+      )
+    );
+  })
+});
+
 // src/codegens.ts
-var codegens = [accessors];
+var codegens = [accessors, annotate3];
 
 // src/cli/codegen.ts
 var NoFilesToCodegenError = class extends TaggedError("NoFilesToCodegenError") {
@@ -35397,6 +35528,11 @@ var runEffectInsideEffect = createDiagnostic({
   apply: fn2("runEffectInsideEffect.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
+    const tsUtils = yield* service2(TypeScriptUtils);
+    const parseEffectMethod = (node, methodName) => pipe(
+      typeParser.isNodeReferenceToEffectModuleApi(methodName)(node),
+      map34(() => ({ node, methodName }))
+    );
     const nodeToVisit = [];
     const appendNodeToVisit = (node) => {
       nodeToVisit.push(node);
@@ -35407,11 +35543,12 @@ var runEffectInsideEffect = createDiagnostic({
       const node = nodeToVisit.shift();
       ts.forEachChild(node, appendNodeToVisit);
       if (!ts.isCallExpression(node)) continue;
+      if (node.arguments.length === 0) continue;
       const isEffectRunCall = yield* pipe(
-        typeParser.isNodeReferenceToEffectModuleApi("runPromise")(node.expression),
-        orElse14(() => typeParser.isNodeReferenceToEffectModuleApi("runSync")(node.expression)),
-        orElse14(() => typeParser.isNodeReferenceToEffectModuleApi("runFork")(node.expression)),
-        orElse14(() => typeParser.isNodeReferenceToEffectModuleApi("runCallback")(node.expression)),
+        parseEffectMethod(node.expression, "runPromise"),
+        orElse14(() => parseEffectMethod(node.expression, "runSync")),
+        orElse14(() => parseEffectMethod(node.expression, "runFork")),
+        orElse14(() => parseEffectMethod(node.expression, "runCallback")),
         option4
       );
       if (isNone2(isEffectRunCall)) continue;
@@ -35431,18 +35568,90 @@ var runEffectInsideEffect = createDiagnostic({
           orElse14(() => typeParser.effectFnGen(possiblyEffectGen)),
           option4
         );
-        if (isSome2(isInEffectGen)) {
+        if (isSome2(isInEffectGen) && isInEffectGen.value.body.statements.length > 0) {
           const nodeText = sourceFile.text.substring(
             ts.getTokenPosOfNode(node.expression, sourceFile),
             node.expression.end
           );
-          const messageText = nodeIntroduceScope && nodeIntroduceScope !== isInEffectGen.value.generatorFunction ? `Using ${nodeText} inside an Effect is not recommended. The same runtime should generally be used instead to run child effects.
-Consider extracting the Runtime by using for example Effect.runtime and then use Runtime.run* with the extracted runtime instead.` : `Using ${nodeText} inside an Effect is not recommended. Effects inside generators can usually just be yielded.`;
-          report({
-            location: node.expression,
-            messageText,
-            fixes: []
-          });
+          if (nodeIntroduceScope && nodeIntroduceScope !== isInEffectGen.value.generatorFunction) {
+            const fixAddRuntime = gen3(function* () {
+              const changeTracker = yield* service2(ChangeTracker);
+              const runtimeModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, "effect", "Runtime") || "Runtime";
+              const effectModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, "effect", "Effect") || "Effect";
+              let runtimeIdentifier = void 0;
+              for (const statement of isInEffectGen.value.generatorFunction.body.statements) {
+                if (ts.isVariableStatement(statement) && statement.declarationList.declarations.length === 1) {
+                  const declaration = statement.declarationList.declarations[0];
+                  if (declaration.initializer && ts.isYieldExpression(declaration.initializer) && declaration.initializer.asteriskToken && declaration.initializer.expression) {
+                    const yieldedExpression = declaration.initializer.expression;
+                    if (ts.isCallExpression(yieldedExpression)) {
+                      const maybeEffectRuntime = yield* pipe(
+                        typeParser.isNodeReferenceToEffectModuleApi("runtime")(yieldedExpression.expression),
+                        option4
+                      );
+                      if (isSome2(maybeEffectRuntime) && ts.isIdentifier(declaration.name)) {
+                        runtimeIdentifier = ts.idText(declaration.name);
+                      }
+                    }
+                  }
+                }
+              }
+              if (!runtimeIdentifier) {
+                changeTracker.insertNodeAt(
+                  sourceFile,
+                  isInEffectGen.value.body.statements[0].pos,
+                  ts.factory.createVariableStatement(
+                    void 0,
+                    ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(
+                      "effectRuntime",
+                      void 0,
+                      void 0,
+                      ts.factory.createYieldExpression(
+                        ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+                        ts.factory.createCallExpression(
+                          ts.factory.createPropertyAccessExpression(
+                            ts.factory.createIdentifier(effectModuleIdentifier),
+                            "runtime"
+                          ),
+                          [ts.factory.createTypeReferenceNode("never")],
+                          []
+                        )
+                      )
+                    )], ts.NodeFlags.Const)
+                  ),
+                  {
+                    prefix: "\n",
+                    suffix: "\n"
+                  }
+                );
+              }
+              changeTracker.deleteRange(sourceFile, {
+                pos: ts.getTokenPosOfNode(node.expression, sourceFile),
+                end: node.arguments[0].pos
+              });
+              changeTracker.insertText(
+                sourceFile,
+                node.arguments[0].pos,
+                `${runtimeModuleIdentifier}.${isEffectRunCall.value.methodName}(${runtimeIdentifier || "effectRuntime"}, `
+              );
+            });
+            report({
+              location: node.expression,
+              messageText: `Using ${nodeText} inside an Effect is not recommended. The same runtime should generally be used instead to run child effects.
+Consider extracting the Runtime by using for example Effect.runtime and then use Runtime.${isEffectRunCall.value.methodName} with the extracted runtime instead.`,
+              fixes: [{
+                fixName: "runEffectInsideEffect_fix",
+                description: "Use a runtime to run the Effect",
+                apply: fixAddRuntime
+              }]
+            });
+          } else {
+            report({
+              location: node.expression,
+              messageText: `Using ${nodeText} inside an Effect is not recommended. Effects inside generators can usually just be yielded.`,
+              fixes: []
+            });
+          }
         }
         currentParent = currentParent.parent;
       }
@@ -35872,6 +36081,66 @@ var unnecessaryEffectGen = createDiagnostic({
   })
 });
 
+// src/diagnostics/unnecessaryFailYieldableError.ts
+var unnecessaryFailYieldableError = createDiagnostic({
+  name: "unnecessaryFailYieldableError",
+  code: 29,
+  severity: "suggestion",
+  apply: fn2("unnecessaryFailYieldableError.apply")(function* (sourceFile, report) {
+    const ts = yield* service2(TypeScriptApi);
+    const typeParser = yield* service2(TypeParser);
+    const typeChecker = yield* service2(TypeCheckerApi);
+    const yieldableErrorTypes = yield* pipe(
+      typeParser.effectCauseYieldableErrorTypes(sourceFile),
+      orElse14(() => succeed17([]))
+    );
+    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.isYieldExpression(node) && node.asteriskToken && node.expression && ts.isCallExpression(node.expression)) {
+        const callExpression = node.expression;
+        yield* pipe(
+          typeParser.isNodeReferenceToEffectModuleApi("fail")(callExpression.expression),
+          map34(() => {
+            if (callExpression.arguments.length > 0) {
+              const failArgument = callExpression.arguments[0];
+              const argumentType = typeChecker.getTypeAtLocation(failArgument);
+              const isYieldableError = yieldableErrorTypes.some(
+                (yieldableType) => typeChecker.isTypeAssignableTo(argumentType, yieldableType)
+              );
+              if (isYieldableError) {
+                report({
+                  location: node,
+                  messageText: `This Effect.fail call uses a yieldable error type as argument. You can yield* the error directly instead.`,
+                  fixes: [{
+                    fixName: "unnecessaryFailYieldableError_fix",
+                    description: "Replace yield* Effect.fail with yield*",
+                    apply: gen3(function* () {
+                      const changeTracker = yield* service2(ChangeTracker);
+                      changeTracker.replaceNode(
+                        sourceFile,
+                        callExpression,
+                        failArgument
+                      );
+                    })
+                  }]
+                });
+              }
+            }
+          }),
+          ignore3
+        );
+      }
+    }
+  })
+});
+
 // src/diagnostics/unnecessaryPipe.ts
 var unnecessaryPipe = createDiagnostic({
   name: "unnecessaryPipe",
@@ -36059,6 +36328,7 @@ var diagnostics = [
   floatingEffect,
   missingStarInYieldEffectGen,
   unnecessaryEffectGen,
+  unnecessaryFailYieldableError,
   missingReturnYieldStar,
   leakingRequirements,
   unnecessaryPipe,