@effect/language-service 0.55.3 → 0.55.5

package/index.js

@@ -2722,6 +2722,7 @@ function make3(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;
@@ -2759,6 +2760,7 @@ function make3(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);
@@ -2980,14 +2982,14 @@ function make3(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);
@@ -3014,14 +3016,14 @@ function make3(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);
@@ -6342,6 +6344,19 @@ var removeEdgeInternal = (mutable, edgeIndex) => {
   mutable.edges.delete(edgeIndex);
   return true;
 };
+var hasEdge = (graph, source, target) => {
+  const adjacencyList = graph.adjacency.get(source);
+  if (adjacencyList === void 0) {
+    return false;
+  }
+  for (const edgeIndex of adjacencyList) {
+    const edge = graph.edges.get(edgeIndex);
+    if (edge !== void 0 && edge.target === target) {
+      return true;
+    }
+  }
+  return false;
+};
 var neighborsDirected = (graph, nodeIndex, direction) => {
   const adjacencyMap = direction === "incoming" ? graph.reverseAdjacency : graph.adjacency;
   const adjacencyList = adjacencyMap.get(nodeIndex);
@@ -7216,9 +7231,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(
@@ -8481,6 +8497,7 @@ var strictBooleanExpressions = createDiagnostic({
       for (const nodeToCheck of nodes2) {
         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];
@@ -14393,7 +14410,7 @@ var extractLayerGraph = fn("extractLayerGraph")(function* (node, opts) {
           }
         }
       }
-    } else {
+    } else if (ts.isExpression(node2)) {
       layerType = typeChecker.getTypeAtLocation(node2);
     }
     if (layerType) {
@@ -14505,7 +14522,7 @@ var extractLayerGraph = fn("extractLayerGraph")(function* (node, opts) {
       let symbol3 = typeChecker.getSymbolAtLocation(node2);
       if (symbol3) {
         if (symbol3.flags & ts.SymbolFlags.Alias) {
-          symbol3 = typeChecker.getAliasedSymbol(symbol3);
+          symbol3 = typeChecker.getAliasedSymbol(symbol3) || symbol3;
         }
         if (symbol3.declarations && symbol3.declarations.length === 1) {
           const declarationNode = getAdjustedNode2(symbol3.declarations[0]);
@@ -14668,7 +14685,9 @@ var extractOutlineGraph = fn("extractOutlineGraph")(function* (layerGraph) {
       for (const [providedType, providerNodeIndexes] of providers.entries()) {
         if (requiredType === providedType || typeChecker.isTypeAssignableTo(requiredType, providedType)) {
           for (const providerNodeIndex of providerNodeIndexes) {
-            addEdge(mutableGraph, nodeIndex, providerNodeIndex, {});
+            if (!hasEdge(mutableGraph, nodeIndex, providerNodeIndex)) {
+              addEdge(mutableGraph, nodeIndex, providerNodeIndex, {});
+            }
           }
         }
       }