@effect/language-service 0.55.1 → 0.55.3

package/effect-lsp-patch-utils.js

@@ -872,8 +872,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";
 };
@@ -931,6 +932,7 @@ var NanoFiber = class {
   _services = {};
   _cache = {};
   _perf = false;
+  _lastSpan = "";
   runLoop(nano) {
     let current = nano;
     while (true) {
@@ -961,17 +963,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(_);
       }
     });
@@ -984,6 +990,7 @@ var withSpan = (name) => (fa) => {
 };
 var unsafeRun = (nano) => {
   const fiber = new NanoFiber();
+  globalThis.currentFiber = fiber;
   const result = fiber.runLoop(nano);
   if (result._tag === "Success") {
     return right2(result.value);
@@ -1094,7 +1101,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) => {
@@ -1762,6 +1769,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,
@@ -1782,7 +1813,9 @@ function makeTypeScriptUtils(ts) {
     createEffectGenCallExpressionWithBlock,
     createReturnYieldStarStatement,
     parseAccessedExpressionForCompletion,
-    getSourceFileOfNode
+    getSourceFileOfNode,
+    isOuterExpression,
+    skipOuterExpressions
   };
 }
 
@@ -1867,6 +1900,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);
       }
@@ -3566,6 +3607,103 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
   };
 }
 
+// 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),
+        map4((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",
@@ -4414,8 +4552,20 @@ var missedPipeableOpportunity = createDiagnostic({
     while (nodeToVisit.length > 0) {
       const node = nodeToVisit.shift();
       if (ts.isCallExpression(node) && node.arguments.length === 1) {
-        const parentChain = callChainNodes.get(node) || [];
-        callChainNodes.set(node.arguments[0], parentChain.concat(node));
+        const isPipeCall = yield* pipe(typeParser.pipeCall(node), orElse2(() => void_));
+        if (!isPipeCall) {
+          const resolvedSignature = typeChecker.getResolvedSignature(node);
+          if (resolvedSignature) {
+            const returnType = typeChecker.getReturnTypeOfSignature(resolvedSignature);
+            if (returnType) {
+              const callSignatures = typeChecker.getSignaturesOfType(returnType, ts.SignatureKind.Call);
+              if (callSignatures.length === 0) {
+                const parentChain = callChainNodes.get(node) || [];
+                callChainNodes.set(node.arguments[0], parentChain.concat(node));
+              }
+            }
+          }
+        }
       } else if (callChainNodes.has(node) && ts.isExpression(node)) {
         const parentChain = (callChainNodes.get(node) || []).slice();
         const originalParentChain = parentChain.slice();
@@ -5412,6 +5562,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);
@@ -5443,6 +5613,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",
@@ -6240,6 +6413,7 @@ var unsupportedServiceAccessors = createDiagnostic({
 
 // src/diagnostics.ts
 var diagnostics = [
+  anyUnknownInErrorContext,
   catchUnfailableEffect,
   classSelfMismatch,
   duplicatePackage,
@@ -6330,7 +6504,7 @@ function checkSourceFileWorker(tsInstance, program, sourceFile, compilerOptions,
       })
     ),
     getOrElse((e) => {
-      console.error(e);
+      console.error(e.message, "at", e.lastSpan);
       return [];
     }),
     map3(addDiagnostic)