@effect/language-service 0.56.0 → 0.57.1

package/effect-lsp-patch-utils.js

@@ -90,6 +90,8 @@ var dual = function(arity, body) {
   }
 };
 var identity = (a) => a;
+var constant = (value) => () => value;
+var constUndefined = /* @__PURE__ */ constant(void 0);
 function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
   switch (arguments.length) {
     case 1:
@@ -738,8 +740,10 @@ var none2 = () => none;
 var some2 = some;
 var isNone2 = isNone;
 var isSome2 = isSome;
+var getOrElse2 = /* @__PURE__ */ dual(2, (self, onNone) => isNone2(self) ? onNone() : self.value);
 var orElse = /* @__PURE__ */ dual(2, (self, that) => isNone2(self) ? that() : self);
 var fromNullable = (nullableValue) => nullableValue == null ? none2() : some2(nullableValue);
+var getOrUndefined = /* @__PURE__ */ getOrElse2(constUndefined);
 
 // node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/Record.js
 var map2 = /* @__PURE__ */ dual(2, (self, f) => {
@@ -2601,6 +2605,51 @@ function make2(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) {
@@ -3590,6 +3639,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     effectGen,
     effectFnUntracedGen,
     effectFnGen,
+    effectCauseYieldableErrorTypes,
     unnecessaryEffectGen: unnecessaryEffectGen2,
     effectSchemaType,
     contextTag,
@@ -5508,8 +5558,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),
+      map4(
+        (_) => ({
+          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/diagnostics/outdatedEffectCodegen.ts
 var outdatedEffectCodegen = createDiagnostic({
@@ -5766,6 +5901,11 @@ var runEffectInsideEffect = createDiagnostic({
   apply: fn("runEffectInsideEffect.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
+    const tsUtils = yield* service(TypeScriptUtils);
+    const parseEffectMethod = (node, methodName) => pipe(
+      typeParser.isNodeReferenceToEffectModuleApi(methodName)(node),
+      map4(() => ({ node, methodName }))
+    );
     const nodeToVisit = [];
     const appendNodeToVisit = (node) => {
       nodeToVisit.push(node);
@@ -5776,11 +5916,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),
-        orElse2(() => typeParser.isNodeReferenceToEffectModuleApi("runSync")(node.expression)),
-        orElse2(() => typeParser.isNodeReferenceToEffectModuleApi("runFork")(node.expression)),
-        orElse2(() => typeParser.isNodeReferenceToEffectModuleApi("runCallback")(node.expression)),
+        parseEffectMethod(node.expression, "runPromise"),
+        orElse2(() => parseEffectMethod(node.expression, "runSync")),
+        orElse2(() => parseEffectMethod(node.expression, "runFork")),
+        orElse2(() => parseEffectMethod(node.expression, "runCallback")),
         option
       );
       if (isNone2(isEffectRunCall)) continue;
@@ -5800,18 +5941,90 @@ var runEffectInsideEffect = createDiagnostic({
           orElse2(() => typeParser.effectFnGen(possiblyEffectGen)),
           option
         );
-        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 = gen(function* () {
+              const changeTracker = yield* service(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),
+                        option
+                      );
+                      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;
       }
@@ -6241,6 +6454,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),
+          map4(() => {
+            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",
@@ -6428,6 +6701,7 @@ var diagnostics = [
   floatingEffect,
   missingStarInYieldEffectGen,
   unnecessaryEffectGen,
+  unnecessaryFailYieldableError,
   missingReturnYieldStar,
   leakingRequirements,
   unnecessaryPipe,