@effect/language-service 0.21.7 → 0.21.8

package/index.js

@@ -3619,41 +3619,82 @@ function dedupeJsDocs(quickInfo2) {
 }
 
 // src/quickinfo/effectTypeArgs.ts
-function formatTypeForQuickInfo(channelType, channelName) {
-  return gen2(function* () {
-    const ts = yield* service(TypeScriptApi);
-    const typeChecker = yield* service(TypeCheckerApi);
-    const stringRepresentation = typeChecker.typeToString(
-      channelType,
-      void 0,
-      ts.TypeFormatFlags.NoTruncation
-    );
-    return `type ${channelName} = ${stringRepresentation}`;
-  });
-}
 function effectTypeArgs(sourceFile, position, quickInfo2) {
   return pipe(
     gen2(function* () {
       const ts = yield* service(TypeScriptApi);
       const typeChecker = yield* service(TypeCheckerApi);
       const typeParser = yield* service(TypeParser);
-      const maybeNode = pipe(
-        yield* getAncestorNodesInRange(sourceFile, toTextRange(position)),
-        head
-      );
-      if (isNone2(maybeNode)) return quickInfo2;
-      const node = maybeNode.value;
-      const hasTruncationHappened = quickInfo2 && ts.displayPartsToString(quickInfo2.displayParts).indexOf("...") > -1;
-      const nodeForType = !quickInfo2 && ts.isYieldExpression(node) && node.asteriskToken && node.expression ? node.expression : hasTruncationHappened ? node : void 0;
-      if (!nodeForType) return quickInfo2;
-      const effectType = yield* typeParser.effectType(
-        typeChecker.getTypeAtLocation(nodeForType),
-        nodeForType
+      function formatTypeForQuickInfo(channelType, channelName) {
+        const stringRepresentation = typeChecker.typeToString(
+          channelType,
+          void 0,
+          ts.TypeFormatFlags.NoTruncation
+        );
+        return `type ${channelName} = ${stringRepresentation}`;
+      }
+      function makeSymbolDisplayParts(title, A, E, R) {
+        return [{
+          kind: "text",
+          text: "```ts\n/* " + title + " */\n" + formatTypeForQuickInfo(A, "Success") + "\n" + formatTypeForQuickInfo(E, "Failure") + "\n" + formatTypeForQuickInfo(R, "Requirements") + "\n```\n"
+        }];
+      }
+      function getNodeForQuickInfo(node2) {
+        if (ts.isNewExpression(node2.parent) && node2.pos === node2.parent.pos) {
+          return node2.parent.expression;
+        }
+        if (ts.isNamedTupleMember(node2.parent) && node2.pos === node2.parent.pos) {
+          return node2.parent;
+        }
+        if (ts.isJsxNamespacedName(node2.parent)) {
+          return node2.parent;
+        }
+        return node2;
+      }
+      function getDataForQuickInfo() {
+        if (!("getTouchingPropertyName" in ts && typeof ts.getTouchingPropertyName === "function")) return;
+        const touchingNode = ts.getTouchingPropertyName(sourceFile, position);
+        if (touchingNode === sourceFile) return;
+        const adjustedNode = getNodeForQuickInfo(touchingNode);
+        if (ts.isToken(adjustedNode) && adjustedNode.kind === ts.SyntaxKind.YieldKeyword) {
+          if (ts.isYieldExpression(adjustedNode.parent) && adjustedNode.parent.asteriskToken && adjustedNode.parent.expression) {
+            return {
+              type: typeChecker.getTypeAtLocation(adjustedNode.parent.expression),
+              atLocation: adjustedNode.parent.expression,
+              node: adjustedNode.parent,
+              shouldTry: true
+            };
+          }
+        }
+        return {
+          type: typeChecker.getTypeAtLocation(adjustedNode),
+          atLocation: adjustedNode,
+          node: adjustedNode,
+          shouldTry: quickInfo2 && ts.displayPartsToString(quickInfo2.displayParts).indexOf("...") > -1
+        };
+      }
+      const data = getDataForQuickInfo();
+      if (!(data && data.shouldTry)) return quickInfo2;
+      const { atLocation, node, type } = data;
+      const effectTypeArgsDocumentation = yield* pipe(
+        typeParser.effectType(
+          type,
+          atLocation
+        ),
+        map4((_) => makeSymbolDisplayParts("Effect Type Parameters", _.A, _.E, _.R)),
+        orElse3(() => {
+          const callSignatues = type.getCallSignatures();
+          if (callSignatues.length !== 1) return succeed([]);
+          const returnType = callSignatues[0].getReturnType();
+          return pipe(
+            typeParser.effectType(
+              returnType,
+              atLocation
+            ),
+            map4((_) => makeSymbolDisplayParts("Returned Effect Type Parameters", _.A, _.E, _.R))
+          );
+        })
       );
-      const effectTypeArgsDocumentation = [{
-        kind: "text",
-        text: "```ts\n/* Effect Type Parameters */\n" + (yield* formatTypeForQuickInfo(effectType.A, "Success")) + "\n" + (yield* formatTypeForQuickInfo(effectType.E, "Failure")) + "\n" + (yield* formatTypeForQuickInfo(effectType.R, "Requirements")) + "\n```\n"
-      }];
       if (!quickInfo2) {
         const start = node.getStart();
         const end = node.getEnd();