@effect/language-service 0.5.1 → 0.6.1

package/index.js

@@ -115,6 +115,7 @@ var globalValue = (id, compute) => {
 };
 
 // node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Predicate.js
+var isBoolean = (input) => typeof input === "boolean";
 var isFunction2 = isFunction;
 var isRecordOrArray = (input) => typeof input === "object" && input !== null;
 var isObject = (input) => isRecordOrArray(input) || isFunction2(input);
@@ -814,12 +815,14 @@ function effectGen(ts, typeChecker) {
     if (!ts.isPropertyAccessExpression(node.expression)) return yield* none2();
     const propertyAccess = node.expression;
     if (propertyAccess.name.text !== "gen") return yield* none2();
-    return yield* importedEffectModule(ts, typeChecker)(propertyAccess.expression).pipe(
-      map(() => ({
-        body: generatorFunction.body,
-        functionStar: generatorFunction.getFirstToken()
-      }))
-    );
+    const effectModule = yield* importedEffectModule(ts, typeChecker)(propertyAccess.expression);
+    return {
+      node,
+      effectModule,
+      generatorFunction,
+      body: generatorFunction.body,
+      functionStar: generatorFunction.getFirstToken()
+    };
   });
 }
 function effectFnUntracedGen(ts, typeChecker) {
@@ -832,12 +835,14 @@ function effectFnUntracedGen(ts, typeChecker) {
     if (!ts.isPropertyAccessExpression(node.expression)) return yield* none2();
     const propertyAccess = node.expression;
     if (propertyAccess.name.text !== "fnUntraced") return yield* none2();
-    return yield* importedEffectModule(ts, typeChecker)(propertyAccess.expression).pipe(
-      map(() => ({
-        body: generatorFunction.body,
-        functionStar: generatorFunction.getFirstToken()
-      }))
-    );
+    const effectModule = yield* importedEffectModule(ts, typeChecker)(propertyAccess.expression);
+    return {
+      node,
+      effectModule,
+      generatorFunction,
+      body: generatorFunction.body,
+      functionStar: generatorFunction.getFirstToken()
+    };
   });
 }
 function effectFnGen(ts, typeChecker) {
@@ -851,71 +856,16 @@ function effectFnGen(ts, typeChecker) {
     if (!ts.isPropertyAccessExpression(expressionToTest)) return yield* none2();
     const propertyAccess = expressionToTest;
     if (propertyAccess.name.text !== "fn") return yield* none2();
-    return yield* importedEffectModule(ts, typeChecker)(propertyAccess.expression).pipe(
-      map(() => ({
-        body: generatorFunction.body,
-        functionStar: generatorFunction.getFirstToken()
-      }))
-    );
+    const effectModule = yield* importedEffectModule(ts, typeChecker)(propertyAccess.expression);
+    return {
+      node,
+      generatorFunction,
+      effectModule,
+      body: generatorFunction.body,
+      functionStar: generatorFunction.getFirstToken()
+    };
   });
 }
-function expectedAndRealType(ts, typeChecker) {
-  return (node) => {
-    if (ts.isVariableDeclaration(node) && node.initializer) {
-      const expectedType = typeChecker.getTypeAtLocation(node.name);
-      const realType = typeChecker.getTypeAtLocation(node.initializer);
-      return [[node.name, expectedType, node.initializer, realType]];
-    }
-    if (ts.isCallExpression(node)) {
-      const resolvedSignature = typeChecker.getResolvedSignature(node);
-      if (resolvedSignature) {
-        return resolvedSignature.getParameters().map((parameter, index) => {
-          const expectedType = typeChecker.getTypeOfSymbolAtLocation(parameter, node);
-          const realType = typeChecker.getTypeAtLocation(node.arguments[index]);
-          return [node.arguments[index], expectedType, node.arguments[index], realType];
-        });
-      }
-    }
-    if (ts.isIdentifier(node) || ts.isStringLiteral(node) || ts.isNumericLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
-      const parent = node.parent;
-      if (ts.isObjectLiteralElement(parent)) {
-        if (ts.isObjectLiteralExpression(parent.parent) && parent.name === node) {
-          const type = typeChecker.getContextualType(parent.parent);
-          if (type) {
-            const symbol3 = typeChecker.getPropertyOfType(type, node.text);
-            if (symbol3) {
-              const expectedType = typeChecker.getTypeOfSymbolAtLocation(symbol3, node);
-              const realType = typeChecker.getTypeAtLocation(node);
-              return [[node, expectedType, node, realType]];
-            }
-          }
-        }
-      }
-    }
-    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
-      const expectedType = typeChecker.getTypeAtLocation(node.left);
-      const realType = typeChecker.getTypeAtLocation(node.right);
-      return [[node.left, expectedType, node.right, realType]];
-    }
-    if (ts.isReturnStatement(node) && node.expression) {
-      const expectedType = typeChecker.getContextualType(node.expression);
-      const realType = typeChecker.getTypeAtLocation(node.expression);
-      if (expectedType) return [[node, expectedType, node, realType]];
-    }
-    if (ts.isArrowFunction(node) && ts.isExpression(node.body)) {
-      const body = node.body;
-      const expectedType = typeChecker.getContextualType(body);
-      const realType = typeChecker.getTypeAtLocation(body);
-      if (expectedType) return [[body, expectedType, body, realType]];
-    }
-    if (ts.isSatisfiesExpression(node)) {
-      const expectedType = typeChecker.getTypeAtLocation(node.type);
-      const realType = typeChecker.getTypeAtLocation(node.expression);
-      return [[node.expression, expectedType, node.expression, realType]];
-    }
-    return [];
-  };
-}
 
 // src/diagnostics/floatingEffect.ts
 var floatingEffect = createDiagnostic({
@@ -958,6 +908,25 @@ var floatingEffect = createDiagnostic({
 // node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/array.js
 var isNonEmptyArray = (self) => self.length > 0;
 
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Iterable.js
+var findFirst = /* @__PURE__ */ dual(2, (self, f) => {
+  let i = 0;
+  for (const a of self) {
+    const o = f(a, i);
+    if (isBoolean(o)) {
+      if (o) {
+        return some2(a);
+      }
+    } else {
+      if (isSome2(o)) {
+        return o;
+      }
+    }
+    i++;
+  }
+  return none2();
+});
+
 // node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Array.js
 var fromIterable = (collection) => Array.isArray(collection) ? collection : Array.from(collection);
 var append = /* @__PURE__ */ dual(2, (self, last) => [...self, last]);
@@ -979,6 +948,7 @@ var unsafeGet = /* @__PURE__ */ dual(2, (self, index) => {
 var head = /* @__PURE__ */ get(0);
 var headNonEmpty = /* @__PURE__ */ unsafeGet(0);
 var tailNonEmpty = (self) => self.slice(1);
+var findFirst2 = findFirst;
 var sort = /* @__PURE__ */ dual(2, (self, O) => {
   const out = Array.from(self);
   out.sort(O);
@@ -1033,71 +1003,8 @@ function toTextRange(positionOrRange) {
 function isNodeInRange(textRange) {
   return (node) => node.pos <= textRange.pos && node.end >= textRange.end;
 }
-function findModuleNamedBindings(ts) {
-  return (sourceFile, moduleName) => fromNullable(ts.forEachChild(sourceFile, (node) => {
-    if (!ts.isImportDeclaration(node)) return;
-    const moduleSpecifier = node.moduleSpecifier;
-    if (!ts.isStringLiteral(moduleSpecifier)) return;
-    if (moduleSpecifier.text !== moduleName) return;
-    const importClause = node.importClause;
-    if (!importClause) return;
-    const namedBindings = importClause.namedBindings;
-    if (!namedBindings) return;
-    return namedBindings;
-  }));
-}
-function findModuleNamespaceImportIdentifierName(ts) {
-  return (sourceFile, moduleName) => pipe(
-    findModuleNamedBindings(ts)(sourceFile, moduleName),
-    map(
-      (namedBindings) => {
-        if (!ts.isNamespaceImport(namedBindings)) return;
-        return namedBindings.name.text;
-      }
-    ),
-    flatMap(fromNullable)
-  );
-}
-function findModuleNamedImportIdentifierName(ts) {
-  return (sourceFile, moduleName, namedImport) => pipe(
-    findModuleNamedBindings(ts)(sourceFile, moduleName),
-    map((namedBindings) => {
-      if (!ts.isNamedImports(namedBindings)) return;
-      for (const importSpecifier of namedBindings.elements) {
-        if (importSpecifier.propertyName?.getText() === namedImport) {
-          return importSpecifier.name?.escapedText || importSpecifier.propertyName?.getText();
-        }
-      }
-    }),
-    flatMap(fromNullable)
-  );
-}
-function findModuleImportIdentifierNameViaTypeChecker(ts, typeChecker) {
-  return (sourceFile, importName) => {
-    return fromNullable(ts.forEachChild(sourceFile, (node) => {
-      if (!ts.isImportDeclaration(node)) return;
-      if (!node.importClause) return;
-      const namedBindings = node.importClause.namedBindings;
-      if (!namedBindings) return;
-      if (ts.isNamespaceImport(namedBindings)) {
-        const symbol3 = typeChecker.getTypeAtLocation(namedBindings).getSymbol();
-        if (!symbol3 || !symbol3.exports) return;
-        if (!symbol3.exports.has(importName)) return;
-        return namedBindings.name.escapedText;
-      }
-      if (ts.isNamedImports(namedBindings)) {
-        for (const importSpecifier of namedBindings.elements) {
-          const symbol3 = typeChecker.getTypeAtLocation(importSpecifier).getSymbol();
-          if (!symbol3 || !symbol3.exports) return;
-          if (!symbol3.exports.has(importName)) return;
-          return importSpecifier.name?.escapedText || importSpecifier.propertyName?.getText();
-        }
-      }
-    }));
-  };
-}
 function transformAsyncAwaitToEffectGen(ts) {
-  return (node, effectName, onAwait) => {
+  return (node, effectModuleName, onAwait) => {
     function visitor(_) {
       if (ts.isAwaitExpression(_)) {
         const expression = ts.visitEachChild(_.expression, visitor, ts.nullTransformationContext);
@@ -1121,7 +1028,7 @@ function transformAsyncAwaitToEffectGen(ts) {
     );
     const effectGenCallExp = ts.factory.createCallExpression(
       ts.factory.createPropertyAccessExpression(
-        ts.factory.createIdentifier(effectName),
+        ts.factory.createIdentifier(effectModuleName),
         "gen"
       ),
       void 0,
@@ -1197,17 +1104,24 @@ function removeReturnTypeAnnotation(ts, changes) {
     }
   };
 }
-function getEffectModuleIdentifier(ts, typeChecker) {
-  return (sourceFile) => pipe(
-    findModuleNamespaceImportIdentifierName(ts)(sourceFile, "effect/Effect"),
-    orElse(() => findModuleNamedImportIdentifierName(ts)(sourceFile, "effect", "Effect")),
-    orElse(
-      () => findModuleImportIdentifierNameViaTypeChecker(ts, typeChecker)(sourceFile, "Effect")
-    ),
-    getOrElse(
-      () => "Effect"
-    )
-  );
+function findImportedModuleIdentifier(ts) {
+  return (test) => (sourceFile) => {
+    for (const statement of sourceFile.statements) {
+      if (!ts.isImportDeclaration(statement)) continue;
+      const importClause = statement.importClause;
+      if (!importClause) continue;
+      const namedBindings = importClause.namedBindings;
+      if (!namedBindings) continue;
+      if (ts.isNamespaceImport(namedBindings)) {
+        if (test(namedBindings.name)) return some2(namedBindings.name);
+      } else if (ts.isNamedImports(namedBindings)) {
+        for (const importSpecifier of namedBindings.elements) {
+          if (test(importSpecifier.name)) return some2(importSpecifier.name);
+        }
+      }
+    }
+    return none2();
+  };
 }
 function simplifyTypeNode(ts) {
   function collectCallable(typeNode) {
@@ -1278,6 +1192,35 @@ function deterministicTypeOrder(ts, typeChecker) {
     return 0;
   });
 }
+function tryPreserveDeclarationSemantics(ts) {
+  return (nodeToReplace, node) => {
+    if (!ts.isExpression(node)) return node;
+    if (ts.isFunctionDeclaration(nodeToReplace)) {
+      if (!nodeToReplace.name) return node;
+      return ts.factory.createVariableStatement(
+        nodeToReplace.modifiers,
+        ts.factory.createVariableDeclarationList(
+          [ts.factory.createVariableDeclaration(
+            nodeToReplace.name,
+            void 0,
+            void 0,
+            node
+          )],
+          ts.NodeFlags.Const
+        )
+      );
+    } else if (ts.isMethodDeclaration(nodeToReplace)) {
+      return ts.factory.createPropertyDeclaration(
+        nodeToReplace.modifiers,
+        nodeToReplace.name,
+        void 0,
+        void 0,
+        node
+      );
+    }
+    return node;
+  };
+}
 
 // src/utils/TypeCheckerApi.ts
 function getMissingTypeEntriesInTargetType(ts, typeChecker) {
@@ -1299,6 +1242,110 @@ function getMissingTypeEntriesInTargetType(ts, typeChecker) {
     return result;
   };
 }
+function getInferredReturnType(ts, typeChecker) {
+  function isConvertibleDeclaration(node) {
+    switch (node.kind) {
+      case ts.SyntaxKind.FunctionDeclaration:
+      case ts.SyntaxKind.FunctionExpression:
+      case ts.SyntaxKind.ArrowFunction:
+      case ts.SyntaxKind.MethodDeclaration:
+        return true;
+      default:
+        return false;
+    }
+  }
+  return (node) => {
+    let declaration = node;
+    while (declaration && !isConvertibleDeclaration(declaration)) {
+      declaration = declaration.parent;
+    }
+    if (!isConvertibleDeclaration(declaration)) return none2();
+    if (!declaration || !declaration.body) {
+      return none2();
+    }
+    let returnType;
+    if (typeChecker.isImplementationOfOverload(declaration)) {
+      const signatures = typeChecker.getTypeAtLocation(declaration).getCallSignatures();
+      if (signatures.length > 1) {
+        returnType = typeChecker.getUnionType(
+          signatures.map((s) => s.getReturnType()).filter((_) => !!_)
+        );
+      }
+    }
+    if (!returnType) {
+      const signature = typeChecker.getSignatureFromDeclaration(declaration);
+      if (signature) {
+        const typePredicate = typeChecker.getTypePredicateOfSignature(signature);
+        if (typePredicate && typePredicate.type) {
+          return some2(typePredicate.type);
+        } else {
+          returnType = typeChecker.getReturnTypeOfSignature(signature);
+        }
+      }
+    }
+    if (!returnType) {
+      return none2();
+    }
+    return some2(returnType);
+  };
+}
+function expectedAndRealType(ts, typeChecker) {
+  return (node) => {
+    if (ts.isVariableDeclaration(node) && node.initializer) {
+      const expectedType = typeChecker.getTypeAtLocation(node.name);
+      const realType = typeChecker.getTypeAtLocation(node.initializer);
+      return [[node.name, expectedType, node.initializer, realType]];
+    }
+    if (ts.isCallExpression(node)) {
+      const resolvedSignature = typeChecker.getResolvedSignature(node);
+      if (resolvedSignature) {
+        return resolvedSignature.getParameters().map((parameter, index) => {
+          const expectedType = typeChecker.getTypeOfSymbolAtLocation(parameter, node);
+          const realType = typeChecker.getTypeAtLocation(node.arguments[index]);
+          return [node.arguments[index], expectedType, node.arguments[index], realType];
+        });
+      }
+    }
+    if (ts.isIdentifier(node) || ts.isStringLiteral(node) || ts.isNumericLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+      const parent = node.parent;
+      if (ts.isObjectLiteralElement(parent)) {
+        if (ts.isObjectLiteralExpression(parent.parent) && parent.name === node) {
+          const type = typeChecker.getContextualType(parent.parent);
+          if (type) {
+            const symbol3 = typeChecker.getPropertyOfType(type, node.text);
+            if (symbol3) {
+              const expectedType = typeChecker.getTypeOfSymbolAtLocation(symbol3, node);
+              const realType = typeChecker.getTypeAtLocation(node);
+              return [[node, expectedType, node, realType]];
+            }
+          }
+        }
+      }
+    }
+    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+      const expectedType = typeChecker.getTypeAtLocation(node.left);
+      const realType = typeChecker.getTypeAtLocation(node.right);
+      return [[node.left, expectedType, node.right, realType]];
+    }
+    if (ts.isReturnStatement(node) && node.expression) {
+      const expectedType = getOrUndefined(getInferredReturnType(ts, typeChecker)(node));
+      const realType = typeChecker.getTypeAtLocation(node.expression);
+      if (expectedType) return [[node, expectedType, node, realType]];
+    }
+    if (ts.isArrowFunction(node) && ts.isExpression(node.body)) {
+      const body = node.body;
+      const expectedType = typeChecker.getContextualType(body);
+      const realType = typeChecker.getTypeAtLocation(body);
+      if (expectedType) return [[body, expectedType, body, realType]];
+    }
+    if (ts.isSatisfiesExpression(node)) {
+      const expectedType = typeChecker.getTypeAtLocation(node.type);
+      const realType = typeChecker.getTypeAtLocation(node.expression);
+      return [[node.expression, expectedType, node.expression, realType]];
+    }
+    return [];
+  };
+}
 
 // src/diagnostics/missingEffectContext.ts
 var missingEffectContext = createDiagnostic({
@@ -1544,7 +1591,9 @@ var asyncAwaitToGen = createRefactor({
   description: "Convert to Effect.gen",
   apply: (ts, program) => (sourceFile, textRange) => pipe(
     getNodesContainingRange(ts)(sourceFile, textRange),
-    filter(ts.isFunctionDeclaration),
+    filter(
+      (node) => ts.isFunctionDeclaration(node) || ts.isArrowFunction(node) || ts.isFunctionExpression(node)
+    ),
     filter((node) => !!node.body),
     filter(
       (node) => !!(ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Async)
@@ -1554,15 +1603,25 @@ var asyncAwaitToGen = createRefactor({
       kind: "refactor.rewrite.effect.asyncAwaitToGen",
       description: "Rewrite to Effect.gen",
       apply: (changeTracker) => {
-        const effectName = getEffectModuleIdentifier(ts, program.getTypeChecker())(sourceFile);
+        const isImportedEffectModule = importedEffectModule(
+          ts,
+          program.getTypeChecker()
+        );
+        const effectModuleIdentifierName = pipe(
+          findImportedModuleIdentifier(ts)(
+            (node2) => isSome2(isImportedEffectModule(node2))
+          )(sourceFile),
+          map((node2) => node2.text),
+          getOrElse(() => "Effect")
+        );
         const newDeclaration = transformAsyncAwaitToEffectGen(
           ts
         )(
           node,
-          effectName,
+          effectModuleIdentifierName,
           (expression) => ts.factory.createCallExpression(
             ts.factory.createPropertyAccessExpression(
-              ts.factory.createIdentifier(effectName),
+              ts.factory.createIdentifier(effectModuleIdentifierName),
               "promise"
             ),
             void 0,
@@ -1590,7 +1649,9 @@ var asyncAwaitToGenTryPromise = createRefactor({
   description: "Convert to Effect.gen with failures",
   apply: (ts, program) => (sourceFile, textRange) => pipe(
     getNodesContainingRange(ts)(sourceFile, textRange),
-    filter(ts.isFunctionDeclaration),
+    filter(
+      (node) => ts.isFunctionDeclaration(node) || ts.isArrowFunction(node) || ts.isFunctionExpression(node)
+    ),
     filter((node) => !!node.body),
     filter(
       (node) => !!(ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Async)
@@ -1600,7 +1661,17 @@ var asyncAwaitToGenTryPromise = createRefactor({
       kind: "refactor.rewrite.effect.asyncAwaitToGenTryPromise",
       description: "Rewrite to Effect.gen with failures",
       apply: (changeTracker) => {
-        const effectName = getEffectModuleIdentifier(ts, program.getTypeChecker())(sourceFile);
+        const isImportedEffectModule = importedEffectModule(
+          ts,
+          program.getTypeChecker()
+        );
+        const effectModuleIdentifierName = pipe(
+          findImportedModuleIdentifier(ts)(
+            (node2) => isSome2(isImportedEffectModule(node2))
+          )(sourceFile),
+          map((node2) => node2.text),
+          getOrElse(() => "Effect")
+        );
         let errorCount = 0;
         function createErrorADT() {
           errorCount++;
@@ -1619,10 +1690,10 @@ var asyncAwaitToGenTryPromise = createRefactor({
           ts
         )(
           node,
-          effectName,
+          effectModuleIdentifierName,
           (expression) => ts.factory.createCallExpression(
             ts.factory.createPropertyAccessExpression(
-              ts.factory.createIdentifier(effectName),
+              ts.factory.createIdentifier(effectModuleIdentifierName),
               "tryPromise"
             ),
             void 0,
@@ -1660,6 +1731,78 @@ var asyncAwaitToGenTryPromise = createRefactor({
   )
 });
 
+// src/refactors/effectGenToFn.ts
+var effectGenToFn = createRefactor({
+  name: "effect/effectGenToFn",
+  description: "Convert to Effect.fn",
+  apply: (ts, program) => (sourceFile, textRange) => pipe(
+    getNodesContainingRange(ts)(sourceFile, textRange),
+    findFirst2(
+      (node) => gen(function* () {
+        const effectGen2 = yield* effectGen(ts, program.getTypeChecker())(node);
+        let pipeArgs = ts.factory.createNodeArray([]);
+        let nodeToReplace = node.parent;
+        if (ts.isPropertyAccessExpression(node.parent) && node.parent.name.text === "pipe" && ts.isCallExpression(node.parent.parent)) {
+          pipeArgs = node.parent.parent.arguments;
+          nodeToReplace = node.parent.parent.parent;
+        }
+        while (nodeToReplace) {
+          if (ts.isArrowFunction(nodeToReplace) || ts.isFunctionDeclaration(nodeToReplace) || ts.isMethodDeclaration(nodeToReplace)) {
+            return { ...effectGen2, pipeArgs, nodeToReplace };
+          }
+          if (ts.isConciseBody(nodeToReplace) || ts.isReturnStatement(nodeToReplace)) {
+            nodeToReplace = nodeToReplace.parent;
+            continue;
+          }
+          if (ts.isBlock(nodeToReplace) && nodeToReplace.statements.length === 1) {
+            nodeToReplace = nodeToReplace.parent;
+            continue;
+          }
+          break;
+        }
+        return yield* none2();
+      })
+    ),
+    map(
+      ({ effectModule, generatorFunction, nodeToReplace, pipeArgs }) => ({
+        kind: "refactor.rewrite.effect.effectGenToFn",
+        description: "Convert to Effect.fn",
+        apply: (changeTracker) => {
+          const effectFn = nodeToReplace.name && ts.isIdentifier(nodeToReplace.name) ? ts.factory.createCallExpression(
+            ts.factory.createPropertyAccessExpression(
+              effectModule,
+              "fn"
+            ),
+            void 0,
+            [ts.factory.createStringLiteral(nodeToReplace.name.text)]
+          ) : ts.factory.createPropertyAccessExpression(
+            effectModule,
+            "fn"
+          );
+          const effectFnCallWithGenerator = ts.factory.createCallExpression(
+            effectFn,
+            void 0,
+            [ts.factory.createFunctionExpression(
+              void 0,
+              ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+              void 0,
+              nodeToReplace.typeParameters,
+              nodeToReplace.parameters,
+              nodeToReplace.type,
+              generatorFunction.body
+            )].concat(pipeArgs)
+          );
+          changeTracker.replaceNode(
+            sourceFile,
+            nodeToReplace,
+            tryPreserveDeclarationSemantics(ts)(nodeToReplace, effectFnCallWithGenerator)
+          );
+        }
+      })
+    )
+  )
+});
+
 // src/refactors/functionToArrow.ts
 var functionToArrow = createRefactor({
   name: "effect/functionToArrow",
@@ -1829,47 +1972,38 @@ var toggleReturnTypeAnnotation = createRefactor({
   name: "effect/toggleReturnTypeAnnotation",
   description: "Toggle return type annotation",
   apply: (ts, program) => (sourceFile, textRange) => {
-    function isConvertibleDeclaration(node) {
-      switch (node.kind) {
-        case ts.SyntaxKind.FunctionDeclaration:
-        case ts.SyntaxKind.FunctionExpression:
-        case ts.SyntaxKind.ArrowFunction:
-        case ts.SyntaxKind.MethodDeclaration:
-          return true;
-        default:
-          return false;
-      }
-    }
-    return pipe(
-      getNodesContainingRange(ts)(sourceFile, textRange),
-      filter(isConvertibleDeclaration),
-      head,
-      map(
-        (node) => ({
+    return gen(function* () {
+      const typeChecker = program.getTypeChecker();
+      const node = yield* pipe(
+        getNodesContainingRange(ts)(sourceFile, textRange),
+        filter(
+          (node2) => ts.isFunctionDeclaration(node2) || ts.isFunctionExpression(node2) || ts.isArrowFunction(node2) || ts.isMethodDeclaration(node2)
+        ),
+        head
+      );
+      if (node.type) {
+        return {
           kind: "refactor.rewrite.effect.toggleReturnTypeAnnotation",
           description: "Toggle return type annotation",
-          apply: (changeTracker) => {
-            const typeChecker = program.getTypeChecker();
-            if (node.type) {
-              removeReturnTypeAnnotation(ts, changeTracker)(sourceFile, node);
-              return;
-            }
-            const callableType = typeChecker.getTypeAtLocation(node);
-            const returnTypes = callableType.getCallSignatures().map((s) => s.getReturnType());
-            const returnTypeNodes = returnTypes.map(
-              (type) => typeChecker.typeToTypeNode(type, node, ts.NodeBuilderFlags.NoTruncation)
-            ).filter((node2) => !!node2);
-            if (returnTypeNodes.length === 0) return;
-            const returnTypeNode = returnTypeNodes.length === 1 ? returnTypeNodes[0] : ts.factory.createUnionTypeNode(returnTypeNodes);
-            addReturnTypeAnnotation(ts, changeTracker)(
-              sourceFile,
-              node,
-              simplifyTypeNode(ts)(returnTypeNode)
-            );
-          }
-        })
-      )
-    );
+          apply: (changeTracker) => removeReturnTypeAnnotation(ts, changeTracker)(sourceFile, node)
+        };
+      }
+      const returnType = yield* getInferredReturnType(ts, typeChecker)(node);
+      const returnTypeNode = yield* fromNullable(
+        typeChecker.typeToTypeNode(returnType, node, ts.NodeBuilderFlags.NoTruncation)
+      );
+      return {
+        kind: "refactor.rewrite.effect.toggleReturnTypeAnnotation",
+        description: "Toggle return type annotation",
+        apply: (changeTracker) => {
+          addReturnTypeAnnotation(ts, changeTracker)(
+            sourceFile,
+            node,
+            simplifyTypeNode(ts)(returnTypeNode)
+          );
+        }
+      };
+    });
   }
 });
 
@@ -1953,7 +2087,8 @@ var refactors = {
   toggleLazyConst,
   toggleReturnTypeAnnotation,
   toggleTypeAnnotation,
-  wrapWithPipe
+  wrapWithPipe,
+  effectGenToFn
 };
 
 // src/index.ts