@effect/language-service 0.21.6 → 0.21.8

package/index.js

@@ -3051,7 +3051,9 @@ var leakingRequirements = createDiagnostic({
       report({
         node,
         category: ts.DiagnosticCategory.Warning,
-        messageText: `This Service is leaking the ${requirements.map((_) => typeChecker.typeToString(_)).join(" | ")} requirement`,
+        messageText: `This Service is leaking the ${requirements.map((_) => typeChecker.typeToString(_)).join(" | ")} requirement.
+If these requirements cannot be cached and are expected to be provided per method invocation (e.g. HttpServerRequest), you can safely disable this diagnostic for this line through quickfixes.
+More info at https://effect.website/docs/requirements-management/layers/#avoiding-requirement-leakage`,
         fixes: []
       });
     }
@@ -3064,7 +3066,7 @@ var leakingRequirements = createDiagnostic({
     while (nodeToVisit.length > 0) {
       const node = nodeToVisit.shift();
       const typesToCheck = [];
-      if (ts.isCallExpression(node)) {
+      if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.name) && node.expression.name.text === "GenericTag") {
         typesToCheck.push([typeChecker.getTypeAtLocation(node), node]);
       } else if (ts.isClassDeclaration(node) && node.name && node.heritageClauses) {
         const classSym = typeChecker.getSymbolAtLocation(node.name);
@@ -3377,7 +3379,9 @@ var returnEffectInGen = createDiagnostic({
                 report({
                   node,
                   category: ts.DiagnosticCategory.Suggestion,
-                  messageText: `You are returning an Effect-able type inside a generator function, and will result in nested Effect<Effect<...>>. Maybe you wanted to return yield* instead? Nested Effect-able types may be intended if you plan to later manually flatten or unwrap this Effect.`,
+                  messageText: `You are returning an Effect-able type inside a generator function, and will result in nested Effect<Effect<...>>.
+Maybe you wanted to return yield* instead?
+Nested Effect-able types may be intended if you plan to later manually flatten or unwrap this Effect, if so you can safely disable this diagnostic for this line through quickfixes.`,
                   fixes: fix
                 });
               }),
@@ -3615,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();