@effect/language-service 0.50.0 → 0.51.0

package/effect-lsp-patch-utils.js

@@ -771,6 +771,7 @@ var unsafeGet = /* @__PURE__ */ dual(2, (self, index) => {
 });
 var headNonEmpty = /* @__PURE__ */ unsafeGet(0);
 var tailNonEmpty = (self) => self.slice(1);
+var reverse = (self) => Array.from(self).reverse();
 var sort = /* @__PURE__ */ dual(2, (self, O) => {
   const out = Array.from(self);
   out.sort(O);
@@ -4320,7 +4321,12 @@ var missedPipeableOpportunity = createDiagnostic({
                         "pipe"
                       ),
                       void 0,
-                      parentChain.filter(ts.isCallExpression).map((call) => call.expression)
+                      pipe(
+                        parentChain,
+                        filter(ts.isCallExpression),
+                        map3((call) => call.expression),
+                        reverse
+                      )
                     )
                   );
                 })
@@ -5615,6 +5621,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",
@@ -5905,7 +5955,8 @@ var diagnostics = [
   unsupportedServiceAccessors,
   nonObjectEffectServiceType,
   deterministicKeys,
-  missedPipeableOpportunity
+  missedPipeableOpportunity,
+  strictEffectProvide
 ];
 
 // src/effect-lsp-patch-utils.ts