@effect/language-service 0.49.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);
@@ -1197,7 +1198,8 @@ var defaults = {
     pattern: "default",
     skipLeadingPath: ["src/"]
   }],
-  extendedKeyDetection: false
+  extendedKeyDetection: false,
+  pipeableMinArgCount: 1
 };
 function parseKeyPatterns(patterns) {
   const result = [];
@@ -1232,7 +1234,8 @@ function parse(config) {
     renames: isObject(config) && hasProperty(config, "renames") && isBoolean(config.renames) ? config.renames : defaults.renames,
     noExternal: isObject(config) && hasProperty(config, "noExternal") && isBoolean(config.noExternal) ? config.noExternal : defaults.noExternal,
     keyPatterns: isObject(config) && hasProperty(config, "keyPatterns") && isArray(config.keyPatterns) ? parseKeyPatterns(config.keyPatterns) : defaults.keyPatterns,
-    extendedKeyDetection: isObject(config) && hasProperty(config, "extendedKeyDetection") && isBoolean(config.extendedKeyDetection) ? config.extendedKeyDetection : defaults.extendedKeyDetection
+    extendedKeyDetection: isObject(config) && hasProperty(config, "extendedKeyDetection") && isBoolean(config.extendedKeyDetection) ? config.extendedKeyDetection : defaults.extendedKeyDetection,
+    pipeableMinArgCount: isObject(config) && hasProperty(config, "pipeableMinArgCount") && isNumber(config.pipeableMinArgCount) ? config.pipeableMinArgCount : defaults.pipeableMinArgCount
   };
 }
 
@@ -4271,6 +4274,74 @@ More info at https://effect.website/docs/requirements-management/layers/#avoidin
   })
 });
 
+// src/diagnostics/missedPipeableOpportunity.ts
+var missedPipeableOpportunity = createDiagnostic({
+  name: "missedPipeableOpportunity",
+  code: 26,
+  severity: "off",
+  apply: fn("missedPipeableOpportunity.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
+    const options = yield* service(LanguageServicePluginOptions);
+    const nodeToVisit = [sourceFile];
+    const prependNodeToVisit = (node) => {
+      nodeToVisit.unshift(node);
+      return void 0;
+    };
+    const callChainNodes = /* @__PURE__ */ new WeakMap();
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      if (ts.isCallExpression(node) && node.arguments.length === 1 && node.parent) {
+        const parentChain = callChainNodes.get(node.parent) || [];
+        callChainNodes.set(node, parentChain.concat(node));
+      } else if (node.parent && callChainNodes.has(node.parent) && ts.isExpression(node)) {
+        const parentChain = callChainNodes.get(node.parent) || [];
+        const originalParentChain = parentChain.slice();
+        parentChain.push(node);
+        while (parentChain.length > options.pipeableMinArgCount) {
+          const subject = parentChain.pop();
+          const resultType = typeChecker.getTypeAtLocation(subject);
+          const pipeableType = yield* pipe(typeParser.pipeableType(resultType, subject), orElse2(() => void_));
+          if (pipeableType) {
+            report({
+              location: parentChain[0],
+              messageText: `Nested function calls can be converted to pipeable style for better readability.`,
+              fixes: [{
+                fixName: "missedPipeableOpportunity_fix",
+                description: "Convert to pipe style",
+                apply: gen(function* () {
+                  const changeTracker = yield* service(ChangeTracker);
+                  changeTracker.replaceNode(
+                    sourceFile,
+                    parentChain[0],
+                    ts.factory.createCallExpression(
+                      ts.factory.createPropertyAccessExpression(
+                        subject,
+                        "pipe"
+                      ),
+                      void 0,
+                      pipe(
+                        parentChain,
+                        filter(ts.isCallExpression),
+                        map3((call) => call.expression),
+                        reverse
+                      )
+                    )
+                  );
+                })
+              }]
+            });
+            originalParentChain.forEach((node2) => callChainNodes.delete(node2));
+            break;
+          }
+        }
+      }
+      ts.forEachChild(node, prependNodeToVisit);
+    }
+  })
+});
+
 // src/diagnostics/missingEffectContext.ts
 var missingEffectContext = createDiagnostic({
   name: "missingEffectContext",
@@ -5550,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",
@@ -5839,7 +5954,9 @@ var diagnostics = [
   overriddenSchemaConstructor,
   unsupportedServiceAccessors,
   nonObjectEffectServiceType,
-  deterministicKeys
+  deterministicKeys,
+  missedPipeableOpportunity,
+  strictEffectProvide
 ];
 
 // src/effect-lsp-patch-utils.ts