@effect/language-service 0.55.2 → 0.55.4

package/cli.js

@@ -30069,8 +30069,9 @@ var contAll = Symbol.for("Nano.contAll");
 var NanoYield = Symbol.for("Nano.yield");
 var args2 = Symbol.for("Nano.args");
 var NanoDefectException = class {
-  constructor(message) {
+  constructor(message, lastSpan) {
     this.message = message;
+    this.lastSpan = lastSpan;
   }
   _tag = "@effect/language-service/NanoDefectException";
 };
@@ -30128,6 +30129,7 @@ var NanoFiber = class {
   _services = {};
   _cache = {};
   _perf = false;
+  _lastSpan = "";
   runLoop(nano) {
     let current = nano;
     while (true) {
@@ -30158,17 +30160,21 @@ var WithSpanProto = {
   [evaluate2](fiber) {
     const [fa, name] = this[args2];
     if (!fiber._perf) return fa;
+    const previousSpan = fiber._lastSpan;
+    fiber._lastSpan = name;
     const start4 = performance.now();
     timingsCount[name] = (timingsCount[name] || 0) + 1;
     return match17(fa, {
       onSuccess: (_) => {
         const end5 = performance.now();
         timings[name] = (timings[name] || 0) + (end5 - start4);
+        fiber._lastSpan = previousSpan;
         return succeed17(_);
       },
       onFailure: (_) => {
         const end5 = performance.now();
         timings[name] = (timings[name] || 0) + (end5 - start4);
+        fiber._lastSpan = previousSpan;
         return fail18(_);
       }
     });
@@ -30179,19 +30185,16 @@ var withSpan6 = (name) => (fa) => {
   nano[args2] = [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 run9 = (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 OnSuccessProto2 = {
@@ -30298,7 +30301,7 @@ var ServiceProto = {
       return cont2 ? cont2[contA](value5, fiber) : fiber.yieldWith(succeed17(value5));
     }
     const cont = fiber.getCont(contE);
-    return cont ? cont[contE](tag4, fiber) : fiber.yieldWith(fail18(new NanoDefectException(`Service ${tag4.key} not found`)));
+    return cont ? cont[contE](tag4, fiber) : fiber.yieldWith(fail18(new NanoDefectException(`Service ${tag4.key} not found`, fiber._lastSpan)));
   }
 };
 var service2 = (tag4) => {
@@ -30877,6 +30880,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,
@@ -30897,7 +30924,9 @@ function makeTypeScriptUtils(ts) {
     createEffectGenCallExpressionWithBlock,
     createReturnYieldStarStatement,
     parseAccessedExpressionForCompletion,
-    getSourceFileOfNode
+    getSourceFileOfNode,
+    isOuterExpression,
+    skipOuterExpressions
   };
 }
 
@@ -31330,6 +31359,14 @@ var createDiagnosticExecutor = fn2("LSP.createCommentDirectivesProcessor")(
           result = node2;
           return;
         }
+        if (ts.isPropertyAssignment(node2)) {
+          const realStart = ts.getTokenPosOfNode(node2, sourceFile);
+          const starts = sourceFile.getLineStarts().filter((start4) => start4 >= node2.pos && start4 <= realStart);
+          if (starts.length > 0) {
+            result = node2;
+            return;
+          }
+        }
         if (result) return;
         if (node2.parent) find3(node2.parent);
       }
@@ -31941,6 +31978,7 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
   const getSourceFilesDeclaringSymbolModule = (packageName) => cachedBy(
     fn2("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;
@@ -31978,6 +32016,7 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
   const getSourceFilesDeclaringSymbolExportedUnderPackageModule = (packageName, memberName) => cachedBy(
     fn2("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);
@@ -32199,14 +32238,14 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
   );
   const importedContextModule = cachedBy(
     fn2("TypeParser.importedContextModule")(function* (node) {
+      if (!ts.isIdentifier(node)) {
+        return yield* typeParserIssue("Node is not an identifier", void 0, node);
+      }
       const type2 = typeChecker.getTypeAtLocation(node);
       const propertySymbol = typeChecker.getPropertyOfType(type2, "Tag");
       if (!propertySymbol) {
         return yield* typeParserIssue("Type has no 'Tag' property", type2, node);
       }
-      if (!ts.isIdentifier(node)) {
-        return yield* typeParserIssue("Node is not an identifier", type2, node);
-      }
       const sourceFile = tsUtils.getSourceFileOfNode(node);
       if (!sourceFile) {
         return yield* typeParserIssue("Node is not in a source file", void 0, node);
@@ -32233,14 +32272,14 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
   );
   const importedDataModule = cachedBy(
     fn2("TypeParser.importedDataModule")(function* (node) {
+      if (!ts.isIdentifier(node)) {
+        return yield* typeParserIssue("Node is not an expression", void 0, node);
+      }
       const type2 = typeChecker.getTypeAtLocation(node);
       const propertySymbol = typeChecker.getPropertyOfType(type2, "TaggedError");
       if (!propertySymbol) {
         return yield* typeParserIssue("Type has no 'TaggedError' property", type2, node);
       }
-      if (!ts.isIdentifier(node)) {
-        return yield* typeParserIssue("Node is not an expression", type2, node);
-      }
       const sourceFile = tsUtils.getSourceFileOfNode(node);
       if (!sourceFile) {
         return yield* typeParserIssue("Node is not in a source file", void 0, node);
@@ -33024,6 +33063,103 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
   };
 }
 
+// src/diagnostics/anyUnknownInErrorContext.ts
+var anyUnknownInErrorContext = createDiagnostic({
+  name: "anyUnknownInErrorContext",
+  code: 28,
+  severity: "off",
+  apply: fn2("anyUnknownInErrorContext.apply")(function* (sourceFile, report) {
+    const ts = yield* service2(TypeScriptApi);
+    const typeChecker = yield* service2(TypeCheckerApi);
+    const typeParser = yield* service2(TypeParser);
+    const isAnyOrUnknown = (type2) => (type2.flags & ts.TypeFlags.Any) > 0 || (type2.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 type3 = typeChecker.getTypeAtLocation(node.type);
+          const expectedEffect = yield* pipe(
+            typeParser.strictEffectType(type3, node.type),
+            orElse14(() => void_8)
+          );
+          if (expectedEffect) continue;
+        }
+      }
+      ts.forEachChild(node, appendNodeToVisit);
+      if (!ts.isExpression(node)) continue;
+      let type2 = typeChecker.getTypeAtLocation(node);
+      if (ts.isCallExpression(node)) {
+        const resolvedSignature = typeChecker.getResolvedSignature(node);
+        if (resolvedSignature) {
+          type2 = typeChecker.getReturnTypeOfSignature(resolvedSignature);
+        }
+      }
+      if (!type2) continue;
+      yield* pipe(
+        typeParser.strictEffectType(type2, node),
+        map34((effect3) => {
+          const { E, R } = effect3;
+          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: type2 });
+          }
+        }),
+        ignore3
+      );
+    }
+    for (const { messageText, node } of matchingNodes) {
+      report({
+        location: node,
+        messageText,
+        fixes: []
+      });
+    }
+  })
+});
+
 // src/diagnostics/catchUnfailableEffect.ts
 var catchUnfailableEffect = createDiagnostic({
   name: "catchUnfailableEffect",
@@ -33785,9 +33921,10 @@ var leakingRequirements = createDiagnostic({
               (type2) => {
                 let symbol3 = type2.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(
@@ -34882,6 +35019,26 @@ var overriddenSchemaConstructor = createDiagnostic({
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
     const typeChecker = yield* service2(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);
@@ -34913,6 +35070,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",
@@ -35321,6 +35481,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];
@@ -35710,6 +35871,7 @@ var unsupportedServiceAccessors = createDiagnostic({
 
 // src/diagnostics.ts
 var diagnostics = [
+  anyUnknownInErrorContext,
   catchUnfailableEffect,
   classSelfMismatch,
   duplicatePackage,