@effect/language-service 0.55.2 → 0.55.4

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);
       }
@@ -2483,6 +2524,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
   const getSourceFilesDeclaringSymbolModule = (packageName) => cachedBy(
     fn("TypeParser.getSourceFilesDeclaringSymbolModule")(function* (symbol3) {
       const result = [];
+      if (!symbol3) return result;
       if (!symbol3.declarations) return yield* typeParserIssue("Symbol has no declarations", void 0, void 0);
       for (const sourceFile of symbol3.declarations) {
         if (!ts.isSourceFile(sourceFile)) continue;
@@ -2520,6 +2562,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
   const getSourceFilesDeclaringSymbolExportedUnderPackageModule = (packageName, memberName) => cachedBy(
     fn("TypeParser.getSourceFilesDeclaringSymbolUnderPackageExportedMember")(function* (symbol3) {
       const result = [];
+      if (!symbol3) return result;
       if (!symbol3.declarations) return yield* typeParserIssue("Symbol has no declarations", void 0, void 0);
       for (const declaration of symbol3.declarations) {
         const sourceFile = tsUtils.getSourceFileOfNode(declaration);
@@ -2741,14 +2784,14 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
   );
   const importedContextModule = cachedBy(
     fn("TypeParser.importedContextModule")(function* (node) {
+      if (!ts.isIdentifier(node)) {
+        return yield* typeParserIssue("Node is not an identifier", void 0, node);
+      }
       const type = typeChecker.getTypeAtLocation(node);
       const propertySymbol = typeChecker.getPropertyOfType(type, "Tag");
       if (!propertySymbol) {
         return yield* typeParserIssue("Type has no 'Tag' property", type, node);
       }
-      if (!ts.isIdentifier(node)) {
-        return yield* typeParserIssue("Node is not an identifier", type, node);
-      }
       const sourceFile = tsUtils.getSourceFileOfNode(node);
       if (!sourceFile) {
         return yield* typeParserIssue("Node is not in a source file", void 0, node);
@@ -2775,14 +2818,14 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
   );
   const importedDataModule = cachedBy(
     fn("TypeParser.importedDataModule")(function* (node) {
+      if (!ts.isIdentifier(node)) {
+        return yield* typeParserIssue("Node is not an expression", void 0, node);
+      }
       const type = typeChecker.getTypeAtLocation(node);
       const propertySymbol = typeChecker.getPropertyOfType(type, "TaggedError");
       if (!propertySymbol) {
         return yield* typeParserIssue("Type has no 'TaggedError' property", type, node);
       }
-      if (!ts.isIdentifier(node)) {
-        return yield* typeParserIssue("Node is not an expression", type, node);
-      }
       const sourceFile = tsUtils.getSourceFileOfNode(node);
       if (!sourceFile) {
         return yield* typeParserIssue("Node is not in a source file", void 0, node);
@@ -3566,6 +3609,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",
@@ -4327,9 +4467,10 @@ var leakingRequirements = createDiagnostic({
               (type) => {
                 let symbol3 = type.symbol;
                 if (symbol3 && symbol3.flags & ts.SymbolFlags.Alias) {
-                  symbol3 = typeChecker.getAliasedSymbol(symbol3);
+                  symbol3 = typeChecker.getAliasedSymbol(symbol3) || symbol3;
                 }
-                return !(symbol3.declarations || []).some((declaration) => {
+                if (!symbol3) return false;
+                return !(symbol3?.declarations || []).some((declaration) => {
                   const declarationSource = tsUtils.getSourceFileOfNode(declaration);
                   if (!declarationSource) return false;
                   return declarationSource.text.substring(declaration.pos, declaration.end).toLowerCase().indexOf(
@@ -5424,6 +5565,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);
@@ -5455,6 +5616,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",
@@ -5863,6 +6027,7 @@ var strictBooleanExpressions = createDiagnostic({
       for (const nodeToCheck of nodes) {
         if (!nodeToCheck) continue;
         if (!conditionChecks.has(nodeToCheck.parent)) continue;
+        if (!ts.isExpression(nodeToCheck)) continue;
         const nodeType = typeChecker.getTypeAtLocation(nodeToCheck);
         const constrainedType = typeChecker.getBaseConstraintOfType(nodeType);
         let typesToCheck = [constrainedType || nodeType];
@@ -6252,6 +6417,7 @@ var unsupportedServiceAccessors = createDiagnostic({
 
 // src/diagnostics.ts
 var diagnostics = [
+  anyUnknownInErrorContext,
   catchUnfailableEffect,
   classSelfMismatch,
   duplicatePackage,
@@ -6342,7 +6508,7 @@ function checkSourceFileWorker(tsInstance, program, sourceFile, compilerOptions,
       })
     ),
     getOrElse((e) => {
-      console.error(e);
+      console.error(e.message, "at", e.lastSpan);
       return [];
     }),
     map3(addDiagnostic)