@effect/language-service 0.55.2 → 0.55.3

package/index.js

@@ -909,8 +909,9 @@ var contAll = Symbol.for("Nano.contAll");
 var NanoYield = Symbol.for("Nano.yield");
 var args = Symbol.for("Nano.args");
 var NanoDefectException = class {
-  constructor(message) {
+  constructor(message, lastSpan) {
     this.message = message;
+    this.lastSpan = lastSpan;
   }
   _tag = "@effect/language-service/NanoDefectException";
 };
@@ -968,6 +969,7 @@ var NanoFiber = class {
   _services = {};
   _cache = {};
   _perf = false;
+  _lastSpan = "";
   runLoop(nano) {
     let current = nano;
     while (true) {
@@ -998,17 +1000,21 @@ var WithSpanProto = {
   [evaluate](fiber) {
     const [fa, name] = this[args];
     if (!fiber._perf) return fa;
+    const previousSpan = fiber._lastSpan;
+    fiber._lastSpan = name;
     const start = performance.now();
     timingsCount[name] = (timingsCount[name] || 0) + 1;
     return match(fa, {
       onSuccess: (_) => {
         const end = performance.now();
         timings[name] = (timings[name] || 0) + (end - start);
+        fiber._lastSpan = previousSpan;
         return succeed(_);
       },
       onFailure: (_) => {
         const end = performance.now();
         timings[name] = (timings[name] || 0) + (end - start);
+        fiber._lastSpan = previousSpan;
         return fail(_);
       }
     });
@@ -1019,19 +1025,16 @@ var withSpan = (name) => (fa) => {
   nano[args] = [fa, name];
   return nano;
 };
-var unsafeRun = (nano) => {
-  const fiber = new NanoFiber();
-  const result = fiber.runLoop(nano);
-  if (result._tag === "Success") {
-    return right2(result.value);
-  }
-  return left2(result.value);
-};
 var run = (nano) => {
+  const fiber = new NanoFiber();
   try {
-    return unsafeRun(nano);
+    const result = fiber.runLoop(nano);
+    if (result._tag === "Success") {
+      return right2(result.value);
+    }
+    return left2(result.value);
   } catch (e) {
-    return left2(new NanoDefectException(e));
+    return left2(new NanoDefectException(e, fiber._lastSpan));
   }
 };
 var OnSuccessProto = {
@@ -1138,7 +1141,7 @@ var ServiceProto = {
       return cont2 ? cont2[contA](value, fiber) : fiber.yieldWith(succeed(value));
     }
     const cont = fiber.getCont(contE);
-    return cont ? cont[contE](tag, fiber) : fiber.yieldWith(fail(new NanoDefectException(`Service ${tag.key} not found`)));
+    return cont ? cont[contE](tag, fiber) : fiber.yieldWith(fail(new NanoDefectException(`Service ${tag.key} not found`, fiber._lastSpan)));
   }
 };
 var service = (tag) => {
@@ -1818,6 +1821,30 @@ function makeTypeScriptUtils(ts) {
     }
     return node;
   }
+  function isOuterExpression(node, kinds = ts.OuterExpressionKinds.All) {
+    switch (node.kind) {
+      case ts.SyntaxKind.ParenthesizedExpression:
+        return (kinds & ts.OuterExpressionKinds.Parentheses) !== 0;
+      case ts.SyntaxKind.TypeAssertionExpression:
+      case ts.SyntaxKind.AsExpression:
+        return (kinds & ts.OuterExpressionKinds.TypeAssertions) !== 0;
+      case ts.SyntaxKind.SatisfiesExpression:
+        return (kinds & (ts.OuterExpressionKinds.TypeAssertions | ts.OuterExpressionKinds.Satisfies)) !== 0;
+      case ts.SyntaxKind.ExpressionWithTypeArguments:
+        return (kinds & ts.OuterExpressionKinds.ExpressionsWithTypeArguments) !== 0;
+      case ts.SyntaxKind.NonNullExpression:
+        return (kinds & ts.OuterExpressionKinds.NonNullAssertions) !== 0;
+      case ts.SyntaxKind.PartiallyEmittedExpression:
+        return (kinds & ts.OuterExpressionKinds.PartiallyEmittedExpressions) !== 0;
+    }
+    return false;
+  }
+  function skipOuterExpressions(node, kinds = ts.OuterExpressionKinds.All) {
+    while (isOuterExpression(node, kinds)) {
+      node = node.expression;
+    }
+    return node;
+  }
   return {
     findNodeAtPositionIncludingTrivia,
     parsePackageContentNameAndVersionFromScope,
@@ -1838,7 +1865,9 @@ function makeTypeScriptUtils(ts) {
     createEffectGenCallExpressionWithBlock,
     createReturnYieldStarStatement,
     parseAccessedExpressionForCompletion,
-    getSourceFileOfNode
+    getSourceFileOfNode,
+    isOuterExpression,
+    skipOuterExpressions
   };
 }
 
@@ -1938,6 +1967,14 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
           result = node2;
           return;
         }
+        if (ts.isPropertyAssignment(node2)) {
+          const realStart = ts.getTokenPosOfNode(node2, sourceFile);
+          const starts = sourceFile.getLineStarts().filter((start) => start >= node2.pos && start <= realStart);
+          if (starts.length > 0) {
+            result = node2;
+            return;
+          }
+        }
         if (result) return;
         if (node2.parent) find(node2.parent);
       }
@@ -4122,6 +4159,103 @@ var effectDataClasses = createCompletion({
   })
 });
 
+// src/diagnostics/anyUnknownInErrorContext.ts
+var anyUnknownInErrorContext = createDiagnostic({
+  name: "anyUnknownInErrorContext",
+  code: 28,
+  severity: "off",
+  apply: fn("anyUnknownInErrorContext.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
+    const isAnyOrUnknown = (type) => (type.flags & ts.TypeFlags.Any) > 0 || (type.flags & ts.TypeFlags.Unknown) > 0;
+    const matchingNodes = [];
+    const nodeToVisit = [sourceFile];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.pop();
+      if (ts.isTypeNode(node)) continue;
+      if (ts.isTypeAliasDeclaration(node)) continue;
+      if (ts.isInterfaceDeclaration(node)) continue;
+      if (ts.isAsExpression(node) && node.type && node.type.kind === ts.SyntaxKind.AnyKeyword) {
+        continue;
+      }
+      if (ts.isParameter(node) || ts.isPropertyDeclaration(node) || ts.isVariableDeclaration(node)) {
+        if (node.type) {
+          const type2 = typeChecker.getTypeAtLocation(node.type);
+          const expectedEffect = yield* pipe(
+            typeParser.strictEffectType(type2, node.type),
+            orElse2(() => void_)
+          );
+          if (expectedEffect) continue;
+        }
+      }
+      ts.forEachChild(node, appendNodeToVisit);
+      if (!ts.isExpression(node)) continue;
+      let type = typeChecker.getTypeAtLocation(node);
+      if (ts.isCallExpression(node)) {
+        const resolvedSignature = typeChecker.getResolvedSignature(node);
+        if (resolvedSignature) {
+          type = typeChecker.getReturnTypeOfSignature(resolvedSignature);
+        }
+      }
+      if (!type) continue;
+      yield* pipe(
+        typeParser.strictEffectType(type, node),
+        map5((effect) => {
+          const { E, R } = effect;
+          const hasAnyUnknownR = isAnyOrUnknown(R);
+          const hasAnyUnknownE = isAnyOrUnknown(E);
+          if (hasAnyUnknownR || hasAnyUnknownE) {
+            const channels = [];
+            if (hasAnyUnknownR) {
+              const typeName = R.flags & ts.TypeFlags.Any ? "any" : "unknown";
+              channels.push(`${typeName} in the requirements channel`);
+            }
+            if (hasAnyUnknownE) {
+              const typeName = E.flags & ts.TypeFlags.Any ? "any" : "unknown";
+              channels.push(`${typeName} in the error channel`);
+            }
+            const nodeStart = ts.getTokenPosOfNode(node, sourceFile);
+            const nodeEnd = node.end;
+            for (let i = matchingNodes.length - 1; i >= 0; i--) {
+              const existing = matchingNodes[i];
+              const existingStart = ts.getTokenPosOfNode(existing.node, sourceFile);
+              const existingEnd = existing.node.end;
+              if (existingStart <= nodeStart && existingEnd >= nodeEnd) {
+                matchingNodes.splice(i, 1);
+              }
+            }
+            const suggestions = [`This Effect has ${channels.join(" and ")} which is not recommended.`];
+            if (hasAnyUnknownR) {
+              suggestions.push(`Only service identifiers should appear in the requirements channel.`);
+            }
+            if (hasAnyUnknownE) {
+              suggestions.push(
+                `Having an unknown or any error type is not useful. Consider instead using specific error types baked by Data.TaggedError for example.`
+              );
+            }
+            channels.push(`If you plan to later on manually cast the type, you can safely disable this diagnostic.`);
+            const messageText = suggestions.join("\n");
+            matchingNodes.push({ messageText, node, type });
+          }
+        }),
+        ignore
+      );
+    }
+    for (const { messageText, node } of matchingNodes) {
+      report({
+        location: node,
+        messageText,
+        fixes: []
+      });
+    }
+  })
+});
+
 // src/diagnostics/catchUnfailableEffect.ts
 var catchUnfailableEffect = createDiagnostic({
   name: "catchUnfailableEffect",
@@ -7885,6 +8019,26 @@ var overriddenSchemaConstructor = createDiagnostic({
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
     const typeChecker = yield* service(TypeCheckerApi);
+    function isAllowedConstructor(node) {
+      if (node.body && node.body.statements.length === 1) {
+        const expressionStatement = node.body.statements[0];
+        if (ts.isExpressionStatement(expressionStatement)) {
+          const maybeCallSuper = expressionStatement.expression;
+          if (ts.isCallExpression(maybeCallSuper)) {
+            if (maybeCallSuper.expression.kind === ts.SyntaxKind.SuperKeyword) {
+              const expectedNames = node.parameters.map((_) => _.name).filter(ts.isIdentifier).map((_) => ts.idText(_));
+              if (expectedNames.length === 2 && expectedNames.length === node.parameters.length) {
+                const givenNames = maybeCallSuper.arguments.filter(ts.isIdentifier).map((_) => ts.idText(_));
+                if (givenNames.length === expectedNames.length && givenNames.every((name, index) => name === expectedNames[index])) {
+                  return true;
+                }
+              }
+            }
+          }
+        }
+      }
+      return false;
+    }
     const nodeToVisit = [];
     const appendNodeToVisit = (node) => {
       nodeToVisit.push(node);
@@ -7916,6 +8070,9 @@ var overriddenSchemaConstructor = createDiagnostic({
           const members = node.members;
           for (const member of members) {
             if (ts.isConstructorDeclaration(member)) {
+              if (isAllowedConstructor(member)) {
+                continue;
+              }
               const fixAsStaticNew = {
                 fixName: "overriddenSchemaConstructor_static",
                 description: "Rewrite using the static 'new' pattern",
@@ -8713,6 +8870,7 @@ var unsupportedServiceAccessors = createDiagnostic({
 
 // src/diagnostics.ts
 var diagnostics = [
+  anyUnknownInErrorContext,
   catchUnfailableEffect,
   classSelfMismatch,
   duplicatePackage,
@@ -9828,6 +9986,7 @@ function effectTypeArgs(sourceFile, position, quickInfo2) {
       const ts = yield* service(TypeScriptApi);
       const typeChecker = yield* service(TypeCheckerApi);
       const typeParser = yield* service(TypeParser);
+      const tsUtils = yield* service(TypeScriptUtils);
       const options = yield* service(LanguageServicePluginOptions);
       if (options.quickinfoEffectParameters === "never") return quickInfo2;
       function formatTypeForQuickInfo(channelType, channelName) {
@@ -9855,6 +10014,73 @@ function effectTypeArgs(sourceFile, position, quickInfo2) {
           text: "```ts\n/* " + title + " */\n" + formatTypeForQuickInfo(A, "Success") + "\n" + formatTypeForQuickInfo(E, "Failure") + "\n" + formatTypeForQuickInfo(R, "Requirements") + "\n```\n"
         }];
       }
+      function isRightSideOfPropertyAccess(node2) {
+        return node2.parent && ts.isPropertyAccessExpression(node2.parent) && node2.parent.name === node2;
+      }
+      function isArgumentExpressionOfElementAccess(node2) {
+        return node2.parent && ts.isElementAccessExpression(node2.parent) && node2.parent.argumentExpression === node2;
+      }
+      function isCalleeWorker(node2, pred, calleeSelector, includeElementAccess, skipPastOuterExpressions) {
+        let target = includeElementAccess ? climbPastPropertyOrElementAccess(node2) : climbPastPropertyAccess(node2);
+        if (skipPastOuterExpressions) {
+          target = tsUtils.skipOuterExpressions(target);
+        }
+        return !!target && !!target.parent && pred(target.parent) && calleeSelector(target.parent) === target;
+      }
+      function climbPastPropertyAccess(node2) {
+        return isRightSideOfPropertyAccess(node2) ? node2.parent : node2;
+      }
+      function climbPastPropertyOrElementAccess(node2) {
+        return isRightSideOfPropertyAccess(node2) || isArgumentExpressionOfElementAccess(node2) ? node2.parent : node2;
+      }
+      function selectExpressionOfCallOrNewExpressionOrDecorator(node2) {
+        return node2.expression;
+      }
+      function isCallExpressionTarget(node2, includeElementAccess = false, skipPastOuterExpressions = false) {
+        return isCalleeWorker(
+          node2,
+          ts.isCallExpression,
+          selectExpressionOfCallOrNewExpressionOrDecorator,
+          includeElementAccess,
+          skipPastOuterExpressions
+        );
+      }
+      function isNewExpressionTarget(node2, includeElementAccess = false, skipPastOuterExpressions = false) {
+        return isCalleeWorker(
+          node2,
+          ts.isNewExpression,
+          selectExpressionOfCallOrNewExpressionOrDecorator,
+          includeElementAccess,
+          skipPastOuterExpressions
+        );
+      }
+      function getSignatureForQuickInfo(location) {
+        if (location.parent && location.parent.kind === ts.SyntaxKind.PropertyAccessExpression) {
+          const right3 = location.parent.name;
+          if (right3 === location || right3 && right3.getFullWidth() === 0) {
+            location = location.parent;
+          }
+        }
+        let callExpressionLike;
+        if (ts.isCallOrNewExpression(location)) {
+          callExpressionLike = location;
+        } else if (isCallExpressionTarget(location) || isNewExpressionTarget(location)) {
+          callExpressionLike = location.parent;
+        }
+        if (callExpressionLike) {
+          const signature = typeChecker.getResolvedSignature(callExpressionLike);
+          if (signature) {
+            const returnType = typeChecker.getReturnTypeOfSignature(signature);
+            if (returnType) {
+              return {
+                callExpressionLike,
+                location,
+                returnType
+              };
+            }
+          }
+        }
+      }
       function getNodeForQuickInfo(node2) {
         if (ts.isNewExpression(node2.parent) && node2.pos === node2.parent.pos) {
           return node2.parent.expression;
@@ -9875,6 +10101,7 @@ function effectTypeArgs(sourceFile, position, quickInfo2) {
         if (ts.isToken(adjustedNode) && adjustedNode.kind === ts.SyntaxKind.YieldKeyword) {
           if (ts.isYieldExpression(adjustedNode.parent) && adjustedNode.parent.asteriskToken && adjustedNode.parent.expression) {
             return {
+              label: "Effect Type Parameters",
               type: typeChecker.getTypeAtLocation(adjustedNode.parent.expression),
               atLocation: adjustedNode.parent.expression,
               node: adjustedNode.parent,
@@ -9882,7 +10109,18 @@ function effectTypeArgs(sourceFile, position, quickInfo2) {
             };
           }
         }
+        const nodeSignature = getSignatureForQuickInfo(adjustedNode);
+        if (nodeSignature) {
+          return {
+            label: "Returned Effect Type Parameters",
+            type: nodeSignature.returnType,
+            atLocation: nodeSignature.location,
+            node: nodeSignature.callExpressionLike,
+            shouldTry: options.quickinfoEffectParameters === "always" && quickInfo2 ? true : quickInfo2 && ts.displayPartsToString(quickInfo2.displayParts).indexOf("...") > -1
+          };
+        }
         return {
+          label: "Effect Type Parameters",
           type: typeChecker.getTypeAtLocation(adjustedNode),
           atLocation: adjustedNode,
           node: adjustedNode,
@@ -9891,25 +10129,13 @@ function effectTypeArgs(sourceFile, position, quickInfo2) {
       }
       const data = getDataForQuickInfo();
       if (!(data && data.shouldTry)) return quickInfo2;
-      const { atLocation, node, type } = data;
+      const { atLocation, label, node, type } = data;
       const effectTypeArgsDocumentation = yield* pipe(
         typeParser.effectType(
           type,
           atLocation
         ),
-        map5((_) => makeSymbolDisplayParts("Effect Type Parameters", _.A, _.E, _.R)),
-        orElse2(() => {
-          const callSignatues = typeChecker.getSignaturesOfType(type, ts.SignatureKind.Call);
-          if (callSignatues.length !== 1) return succeed([]);
-          const returnType = typeChecker.getReturnTypeOfSignature(callSignatues[0]);
-          return pipe(
-            typeParser.effectType(
-              returnType,
-              atLocation
-            ),
-            map5((_) => makeSymbolDisplayParts("Returned Effect Type Parameters", _.A, _.E, _.R))
-          );
-        })
+        map5((_) => makeSymbolDisplayParts(label, _.A, _.E, _.R))
       );
       if (!quickInfo2) {
         const start = ts.getTokenPosOfNode(node, sourceFile);