@effect/language-service 0.50.0 → 0.51.1

package/index.js

@@ -7076,7 +7076,12 @@ var missedPipeableOpportunity = createDiagnostic({
                         "pipe"
                       ),
                       void 0,
-                      parentChain.filter(ts.isCallExpression).map((call) => call.expression)
+                      pipe(
+                        parentChain,
+                        filter(ts.isCallExpression),
+                        map4((call) => call.expression),
+                        reverse
+                      )
                     )
                   );
                 })
@@ -8077,6 +8082,50 @@ var strictBooleanExpressions = createDiagnostic({
   })
 });
 
+// src/diagnostics/strictEffectProvide.ts
+var strictEffectProvide = createDiagnostic({
+  name: "strictEffectProvide",
+  code: 27,
+  severity: "off",
+  apply: fn("strictEffectProvide.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
+    const parseEffectProvideWithLayer = (node) => gen(function* () {
+      if (!ts.isCallExpression(node) || !ts.isPropertyAccessExpression(node.expression) || !ts.isIdentifier(node.expression.name) || ts.idText(node.expression.name) !== "provide" || node.arguments.length === 0) {
+        return yield* typeParserIssue("Not an Effect.provide call");
+      }
+      yield* typeParser.importedEffectModule(node.expression.expression);
+      return yield* firstSuccessOf(
+        node.arguments.map((arg) => {
+          const argType = typeChecker.getTypeAtLocation(arg);
+          return typeParser.layerType(argType, arg);
+        })
+      );
+    });
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts.forEachChild(node, appendNodeToVisit);
+      if (ts.isCallExpression(node)) {
+        const layerCheck = yield* pipe(parseEffectProvideWithLayer(node), option);
+        if (isSome2(layerCheck)) {
+          report({
+            location: node,
+            messageText: "Effect.provide with a Layer should only be used at application entry points. If this is an entry point, you can safely disable this diagnostic. Otherwise, using Effect.provide may break scope lifetimes. Compose all layers at your entry point and provide them at once.",
+            fixes: []
+          });
+        }
+      }
+    }
+  })
+});
+
 // src/diagnostics/tryCatchInEffectGen.ts
 var tryCatchInEffectGen = createDiagnostic({
   name: "tryCatchInEffectGen",
@@ -8367,7 +8416,8 @@ var diagnostics = [
   unsupportedServiceAccessors,
   nonObjectEffectServiceType,
   deterministicKeys,
-  missedPipeableOpportunity
+  missedPipeableOpportunity,
+  strictEffectProvide
 ];
 
 // src/completions/effectDiagnosticsComment.ts
@@ -13885,11 +13935,20 @@ var extractLayerGraph = fn("extractLayerGraph")(function* (node, opts) {
 });
 var formatLayerGraph = fn("formatLayerGraph")(function* (layerGraph) {
   const tsUtils = yield* service(TypeScriptUtils);
+  const typeChecker = yield* service(TypeCheckerApi);
+  const ts = yield* service(TypeScriptApi);
   return toMermaid(layerGraph, {
     edgeLabel: (edge) => JSON.stringify(edge),
     nodeLabel: (graphNode) => {
       const sourceFile = tsUtils.getSourceFileOfNode(graphNode.node);
-      return sourceFile.text.substring(graphNode.node.pos, graphNode.node.end).trim();
+      let text = sourceFile.text.substring(graphNode.node.pos, graphNode.node.end).trim();
+      text += "\nprovides: " + graphNode.provides.map((_) => typeChecker.typeToString(_, void 0, ts.TypeFormatFlags.NoTruncation)).join(
+        ", "
+      );
+      text += "\nrequires: " + graphNode.requires.map((_) => typeChecker.typeToString(_, void 0, ts.TypeFormatFlags.NoTruncation)).join(
+        ", "
+      );
+      return text;
     }
   });
 });
@@ -13970,7 +14029,7 @@ var formatNestedLayerGraph = fn("formatNestedLayerGraph")(function* (layerGraph)
 var extractOutlineGraph = fn("extractOutlineGraph")(function* (layerGraph) {
   const typeChecker = yield* service(TypeCheckerApi);
   const mutableGraph = beginMutation3(directed());
-  const providers = /* @__PURE__ */ new WeakMap();
+  const providers = /* @__PURE__ */ new Map();
   const knownSymbols = /* @__PURE__ */ new WeakSet();
   const leafNodes = values2(externals(layerGraph, { direction: "outgoing" }));
   const dedupedLeafNodes = [];
@@ -13997,8 +14056,12 @@ var extractOutlineGraph = fn("extractOutlineGraph")(function* (layerGraph) {
   }
   for (const [nodeIndex, nodeInfo] of entries(nodes(mutableGraph))) {
     for (const requiredType of nodeInfo.requires) {
-      for (const providerNodeIndex of providers.get(requiredType) || []) {
-        addEdge(mutableGraph, nodeIndex, providerNodeIndex, {});
+      for (const [providedType, providerNodeIndexes] of providers.entries()) {
+        if (requiredType === providedType || typeChecker.isTypeAssignableTo(requiredType, providedType)) {
+          for (const providerNodeIndex of providerNodeIndexes) {
+            addEdge(mutableGraph, nodeIndex, providerNodeIndex, {});
+          }
+        }
       }
     }
   }
@@ -14085,7 +14148,8 @@ var walkLeavesMatching = (graph, predicate, config = {}) => {
 var extractProvidersAndRequirers = fn("extractProvidersAndRequirers")(
   function* (layerGraph) {
     const typeCheckerUtils = yield* service(TypeCheckerUtils);
-    const rootWalker = externals(layerGraph, { direction: "outgoing" });
+    const typeChecker = yield* service(TypeCheckerApi);
+    const rootWalker = externals(layerGraph, { direction: "incoming" });
     const rootNodes = fromIterable(values2(rootWalker));
     const rootNodeIndexes = fromIterable(indices(rootWalker));
     const result = [];
@@ -14096,7 +14160,9 @@ var extractProvidersAndRequirers = fn("extractProvidersAndRequirers")(
         for (const layerNode of values2(
           walkLeavesMatching(
             layerGraph,
-            (_) => (kind === "provided" ? _.provides : _.requires).indexOf(layerType) > -1,
+            (_) => (kind === "provided" ? _.provides : _.requires).some(
+              (_2) => _2 === layerType || typeChecker.isTypeAssignableTo(_2, layerType)
+            ),
             { start: rootNodeIndexes }
           )
         )) {