@effect/language-service 0.6.0 → 0.6.1

package/index.js

@@ -866,63 +866,6 @@ function effectFnGen(ts, typeChecker) {
     };
   });
 }
-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({
@@ -1060,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);
@@ -1148,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,
@@ -1224,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) {
@@ -1305,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) {
@@ -1326,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({
@@ -1583,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,
@@ -1631,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++;
@@ -1650,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,
@@ -1707,7 +1747,7 @@ var effectGenToFn = createRefactor({
           nodeToReplace = node.parent.parent.parent;
         }
         while (nodeToReplace) {
-          if (ts.isArrowFunction(nodeToReplace) || ts.isFunctionDeclaration(nodeToReplace)) {
+          if (ts.isArrowFunction(nodeToReplace) || ts.isFunctionDeclaration(nodeToReplace) || ts.isMethodDeclaration(nodeToReplace)) {
             return { ...effectGen2, pipeArgs, nodeToReplace };
           }
           if (ts.isConciseBody(nodeToReplace) || ts.isReturnStatement(nodeToReplace)) {
@@ -1728,7 +1768,7 @@ var effectGenToFn = createRefactor({
         kind: "refactor.rewrite.effect.effectGenToFn",
         description: "Convert to Effect.fn",
         apply: (changeTracker) => {
-          const effectFn = nodeToReplace.name ? ts.factory.createCallExpression(
+          const effectFn = nodeToReplace.name && ts.isIdentifier(nodeToReplace.name) ? ts.factory.createCallExpression(
             ts.factory.createPropertyAccessExpression(
               effectModule,
               "fn"
@@ -1752,27 +1792,11 @@ var effectGenToFn = createRefactor({
               generatorFunction.body
             )].concat(pipeArgs)
           );
-          if (!ts.isArrowFunction(nodeToReplace) && nodeToReplace.name) {
-            const variableDeclaration = ts.factory.createVariableStatement(
-              nodeToReplace.modifiers,
-              ts.factory.createVariableDeclarationList(
-                [ts.factory.createVariableDeclaration(
-                  nodeToReplace.name,
-                  void 0,
-                  void 0,
-                  effectFnCallWithGenerator
-                )],
-                ts.NodeFlags.Const
-              )
-            );
-            changeTracker.replaceNode(
-              sourceFile,
-              nodeToReplace,
-              variableDeclaration
-            );
-          } else {
-            changeTracker.replaceNode(sourceFile, nodeToReplace, effectFnCallWithGenerator);
-          }
+          changeTracker.replaceNode(
+            sourceFile,
+            nodeToReplace,
+            tryPreserveDeclarationSemantics(ts)(nodeToReplace, effectFnCallWithGenerator)
+          );
         }
       })
     )
@@ -1948,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)
+          );
+        }
+      };
+    });
   }
 });