@effect/language-service 0.55.5 → 0.57.0

package/index.js

@@ -2799,6 +2799,51 @@ function make3(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(
+    fn("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(
+    fn("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 type = typeChecker.getDeclaredTypeOfSymbol(causeTypeSymbol);
+      yield* pipeableType(type, sourceFile);
+      return sourceFile;
+    }),
+    "TypeParser.isCauseTypeSourceFile",
+    (sourceFile) => sourceFile
+  );
+  const effectCauseYieldableErrorTypes = cachedBy(
+    fn("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 type = typeChecker.getDeclaredTypeOfSymbol(symbol3);
+        result.push(type);
+      }
+      return result;
+    }),
+    "TypeParser.effectCauseYieldableErrorTypes",
+    (fromSourceFile) => fromSourceFile
+  );
   function covariantTypeArgument(type) {
     const signatures = typeChecker.getSignaturesOfType(type, ts.SignatureKind.Call);
     if (signatures.length !== 1) {
@@ -3788,6 +3833,7 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     effectGen,
     effectFnUntracedGen,
     effectFnGen,
+    effectCauseYieldableErrorTypes,
     unnecessaryEffectGen: unnecessaryEffectGen2,
     effectSchemaType,
     contextTag,
@@ -4098,8 +4144,93 @@ var accessors = createCodegen({
   })
 });
 
+// src/codegens/annotate.ts
+var annotate = createCodegen({
+  name: "annotate",
+  apply: fn("annotate.apply")(function* (sourceFile, textRange) {
+    const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
+    const parse3 = (node) => gen(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* fail(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* fail(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* fail(new CodegenNotApplicableError("no node and comment range"));
+    return yield* pipe(
+      parse3(nodeAndCommentRange.node),
+      map5(
+        (_) => ({
+          hash: _.hash,
+          description: "Annotate with type",
+          apply: gen(function* () {
+            const changeTracker = yield* service(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, annotate];
 
 // src/completions/effectCodegensComment.ts
 var effectCodegensComment = createCompletion({
@@ -8711,6 +8842,66 @@ var unnecessaryEffectGen = createDiagnostic({
   })
 });
 
+// src/diagnostics/unnecessaryFailYieldableError.ts
+var unnecessaryFailYieldableError = createDiagnostic({
+  name: "unnecessaryFailYieldableError",
+  code: 29,
+  severity: "suggestion",
+  apply: fn("unnecessaryFailYieldableError.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const yieldableErrorTypes = yield* pipe(
+      typeParser.effectCauseYieldableErrorTypes(sourceFile),
+      orElse2(() => succeed([]))
+    );
+    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),
+          map5(() => {
+            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: gen(function* () {
+                      const changeTracker = yield* service(ChangeTracker);
+                      changeTracker.replaceNode(
+                        sourceFile,
+                        callExpression,
+                        failArgument
+                      );
+                    })
+                  }]
+                });
+              }
+            }
+          }),
+          ignore
+        );
+      }
+    }
+  })
+});
+
 // src/diagnostics/unnecessaryPipe.ts
 var unnecessaryPipe = createDiagnostic({
   name: "unnecessaryPipe",
@@ -8898,6 +9089,7 @@ var diagnostics = [
   floatingEffect,
   missingStarInYieldEffectGen,
   unnecessaryEffectGen,
+  unnecessaryFailYieldableError,
   missingReturnYieldStar,
   leakingRequirements,
   unnecessaryPipe,