@effect/language-service 0.21.0 → 0.21.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect/language-service",
-  "version": "0.21.0",
+  "version": "0.21.2",
   "description": "A Language-Service Plugin to Refactor and Diagnostic effect-ts projects",
   "main": "index.cjs",
   "repository": {

package/transform.js

@@ -144,6 +144,7 @@ var isFunction2 = isFunction;
 var isRecordOrArray = (input) => typeof input === "object" && input !== null;
 var isObject = (input) => isRecordOrArray(input) || isFunction2(input);
 var hasProperty = /* @__PURE__ */ dual(2, (self, property) => isObject(self) && property in self);
+var isRecord = (input) => isRecordOrArray(input) && !Array.isArray(input);
 
 // node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/internal/errors.js
 var getBugErrorMessage = (message) => `BUG: ${message} - please report an issue at https://github.com/Effect-TS/effect/issues`;
@@ -975,9 +976,23 @@ function cachedBy(fa, key, lookupKey) {
 
 // src/core/LanguageServicePluginOptions.ts
 var LanguageServicePluginOptions = Tag("PluginOptions");
+function parseDiagnosticSeverity(config) {
+  if (!isRecord(config)) return {};
+  return Object.fromEntries(
+    pipe(
+      Object.entries(config),
+      filter(([key, value]) => isString(key) && isString(value)),
+      map2(([key, value]) => [String(key).toLowerCase(), String(value).toLowerCase()]),
+      filter(
+        ([_, value]) => value === "off" || value === "error" || value === "warning" || value === "message" || value === "suggestion"
+      )
+    )
+  );
+}
 function parse(config) {
   return {
     diagnostics: isObject(config) && hasProperty(config, "diagnostics") && isBoolean(config.diagnostics) ? config.diagnostics : true,
+    diagnosticSeverity: isObject(config) && hasProperty(config, "diagnosticSeverity") && isRecord(config.diagnosticSeverity) ? parseDiagnosticSeverity(config.diagnosticSeverity) : {},
     quickinfo: isObject(config) && hasProperty(config, "quickinfo") && isBoolean(config.quickinfo) ? config.quickinfo : true,
     completions: isObject(config) && hasProperty(config, "completions") && isBoolean(config.completions) ? config.completions : true,
     goto: isObject(config) && hasProperty(config, "goto") && isBoolean(config.goto) ? config.goto : true,
@@ -1108,6 +1123,7 @@ var getCompletionsAtPosition = fn("LSP.getCompletionsAtPosition")(function* (com
 var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
   function* (sourceFile) {
     const ts = yield* service(TypeScriptApi);
+    const pluginOptions = yield* service(LanguageServicePluginOptions);
     function findNodeWithLeadingCommentAtPosition(position) {
       const sourceText = sourceFile.text;
       let result;
@@ -1191,24 +1207,30 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
       const ruleNameLowered = rule.name.toLowerCase();
       if (skippedRules.indexOf(ruleNameLowered) > -1) return [];
       let modifiedDiagnostics = yield* rule.apply(sourceFile);
+      const newLevel = pluginOptions.diagnosticSeverity[ruleNameLowered];
+      if (newLevel) {
+        for (const emitted of modifiedDiagnostics) {
+          emitted.category = newLevel && newLevel in levelToDiagnosticCategory ? levelToDiagnosticCategory[newLevel] : emitted.category;
+        }
+      }
       for (const emitted of modifiedDiagnostics.slice(0)) {
-        let newLevel = void 0;
+        let newLevel2 = void 0;
         if (!(ruleNameLowered in sectionOverrides || ruleNameLowered in lineOverrides)) continue;
         const lineOverride = (lineOverrides[ruleNameLowered] || []).find(
           (_) => _.pos < emitted.node.getStart(sourceFile) && _.end >= emitted.node.getEnd()
         );
         if (lineOverride) {
-          newLevel = lineOverride.level;
+          newLevel2 = lineOverride.level;
         } else {
           const sectionOverride = (sectionOverrides[ruleNameLowered] || []).find(
             (_) => _.pos < emitted.node.getStart(sourceFile)
           );
-          if (sectionOverride) newLevel = sectionOverride.level;
+          if (sectionOverride) newLevel2 = sectionOverride.level;
         }
-        if (newLevel === "off") {
+        if (newLevel2 === "off") {
           modifiedDiagnostics = modifiedDiagnostics.filter((_) => _ !== emitted);
         } else {
-          emitted.category = newLevel && newLevel in levelToDiagnosticCategory ? levelToDiagnosticCategory[newLevel] : emitted.category;
+          emitted.category = newLevel2 && newLevel2 in levelToDiagnosticCategory ? levelToDiagnosticCategory[newLevel2] : emitted.category;
         }
       }
       const fixByDisableNextLine = (_) => ({
@@ -1845,19 +1867,6 @@ var createReturnYieldStarStatement = fn("AST.createReturnYieldStarStatement")(
     );
   }
 );
-var parsePipeCall = fn("AST.parsePipeCall")(
-  function* (node) {
-    const ts = yield* service(TypeScriptApi);
-    if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.name) && node.expression.name.text === "pipe") {
-      return { node, subject: node.expression.expression, args: node.arguments };
-    }
-    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "pipe" && node.arguments.length > 0) {
-      const [subject, ...args] = node.arguments;
-      return { node, subject, args };
-    }
-    return yield* fail(new NodeNotFoundError());
-  }
-);
 
 // src/core/TypeParser.ts
 var TypeParser = Tag("@effect/language-service/TypeParser");
@@ -1891,18 +1900,18 @@ function make3(ts, typeChecker) {
     return succeed(signatures[0].getReturnType());
   }
   const pipeableType = cachedBy(
-    fn("TypeParser.pipeableType")(function* (type, atLocation) {
+    function(type, atLocation) {
       const pipeSymbol = typeChecker.getPropertyOfType(type, "pipe");
       if (!pipeSymbol) {
-        return yield* typeParserIssue("Type has no 'pipe' property", type, atLocation);
+        return typeParserIssue("Type has no 'pipe' property", type, atLocation);
       }
       const pipeType = typeChecker.getTypeOfSymbolAtLocation(pipeSymbol, atLocation);
       const signatures = pipeType.getCallSignatures();
       if (signatures.length === 0) {
-        return yield* typeParserIssue("'pipe' property is not callable", type, atLocation);
+        return typeParserIssue("'pipe' property is not callable", type, atLocation);
       }
-      return type;
-    }),
+      return succeed(type);
+    },
     "TypeParser.pipeableType",
     (type) => type
   );
@@ -2040,105 +2049,107 @@ function make3(ts, typeChecker) {
     (node) => node
   );
   const effectGen = cachedBy(
-    fn("TypeParser.effectGen")(function* (node) {
+    function(node) {
       if (!ts.isCallExpression(node)) {
-        return yield* typeParserIssue("Node is not a call expression", void 0, node);
+        return typeParserIssue("Node is not a call expression", void 0, node);
       }
       if (node.arguments.length === 0) {
-        return yield* typeParserIssue("Node has no arguments", void 0, node);
+        return typeParserIssue("Node has no arguments", void 0, node);
       }
       const generatorFunction = node.arguments[0];
       if (!ts.isFunctionExpression(generatorFunction)) {
-        return yield* typeParserIssue("Node is not a function expression", void 0, node);
+        return typeParserIssue("Node is not a function expression", void 0, node);
       }
       if (generatorFunction.asteriskToken === void 0) {
-        return yield* typeParserIssue("Node is not a generator function", void 0, node);
+        return typeParserIssue("Node is not a generator function", void 0, node);
       }
       if (!ts.isPropertyAccessExpression(node.expression)) {
-        return yield* typeParserIssue("Node is not a property access expression", void 0, node);
+        return typeParserIssue("Node is not a property access expression", void 0, node);
       }
       const propertyAccess = node.expression;
       if (propertyAccess.name.text !== "gen") {
-        return yield* typeParserIssue("Call expression name is not 'gen'", void 0, node);
+        return typeParserIssue("Call expression name is not 'gen'", void 0, node);
       }
-      const effectModule = yield* importedEffectModule(propertyAccess.expression);
-      return {
-        node,
-        effectModule,
-        generatorFunction,
-        body: generatorFunction.body,
-        functionStar: generatorFunction.getFirstToken()
-      };
-    }),
+      return pipe(
+        importedEffectModule(propertyAccess.expression),
+        map3((effectModule) => ({
+          node,
+          effectModule,
+          generatorFunction,
+          body: generatorFunction.body,
+          functionStar: generatorFunction.getFirstToken()
+        }))
+      );
+    },
     "TypeParser.effectGen",
     (node) => node
   );
   const effectFnUntracedGen = cachedBy(
-    fn("TypeParser.effectFnUntracedGen")(
-      function* (node) {
-        if (!ts.isCallExpression(node)) {
-          return yield* typeParserIssue("Node is not a call expression", void 0, node);
-        }
-        if (node.arguments.length === 0) {
-          return yield* typeParserIssue("Node has no arguments", void 0, node);
-        }
-        const generatorFunction = node.arguments[0];
-        if (!ts.isFunctionExpression(generatorFunction)) {
-          return yield* typeParserIssue("Node is not a function expression", void 0, node);
-        }
-        if (generatorFunction.asteriskToken === void 0) {
-          return yield* typeParserIssue(
-            "Node is not a generator function",
-            void 0,
-            node
-          );
-        }
-        if (!ts.isPropertyAccessExpression(node.expression)) {
-          return yield* typeParserIssue(
-            "Node is not a property access expression",
-            void 0,
-            node
-          );
-        }
-        const propertyAccess = node.expression;
-        if (propertyAccess.name.text !== "fnUntraced") {
-          return yield* typeParserIssue(
-            "Call expression name is not 'fnUntraced'",
-            void 0,
-            node
-          );
-        }
-        const effectModule = yield* importedEffectModule(propertyAccess.expression);
-        return {
+    function(node) {
+      if (!ts.isCallExpression(node)) {
+        return typeParserIssue("Node is not a call expression", void 0, node);
+      }
+      if (node.arguments.length === 0) {
+        return typeParserIssue("Node has no arguments", void 0, node);
+      }
+      const generatorFunction = node.arguments[0];
+      if (!ts.isFunctionExpression(generatorFunction)) {
+        return typeParserIssue("Node is not a function expression", void 0, node);
+      }
+      if (generatorFunction.asteriskToken === void 0) {
+        return typeParserIssue(
+          "Node is not a generator function",
+          void 0,
+          node
+        );
+      }
+      if (!ts.isPropertyAccessExpression(node.expression)) {
+        return typeParserIssue(
+          "Node is not a property access expression",
+          void 0,
+          node
+        );
+      }
+      const propertyAccess = node.expression;
+      if (propertyAccess.name.text !== "fnUntraced") {
+        return typeParserIssue(
+          "Call expression name is not 'fnUntraced'",
+          void 0,
+          node
+        );
+      }
+      return pipe(
+        importedEffectModule(propertyAccess.expression),
+        map3((effectModule) => ({
           node,
           effectModule,
           generatorFunction,
           body: generatorFunction.body,
           functionStar: generatorFunction.getFirstToken()
-        };
-      }
-    ),
+        }))
+      );
+    },
     "TypeParser.effectFnUntracedGen",
     (node) => node
   );
   const effectFnGen = cachedBy(
-    fn("TypeParser.effectFnGen")(function* (node) {
+    function(node) {
       if (!ts.isCallExpression(node)) {
-        return yield* typeParserIssue("Node is not a call expression", void 0, node);
+        return typeParserIssue("Node is not a call expression", void 0, node);
       }
       if (node.arguments.length === 0) {
-        return yield* typeParserIssue("Node has no arguments", void 0, node);
+        return typeParserIssue("Node has no arguments", void 0, node);
       }
       const generatorFunction = node.arguments[0];
       if (!ts.isFunctionExpression(generatorFunction)) {
-        return yield* typeParserIssue(
+        return typeParserIssue(
           "Node is not a function expression",
           void 0,
           node
         );
       }
       if (generatorFunction.asteriskToken === void 0) {
-        return yield* typeParserIssue(
+        return typeParserIssue(
           "Node is not a generator function",
           void 0,
           node
@@ -2146,7 +2157,7 @@ function make3(ts, typeChecker) {
       }
       const expressionToTest = ts.isCallExpression(node.expression) ? node.expression.expression : node.expression;
       if (!ts.isPropertyAccessExpression(expressionToTest)) {
-        return yield* typeParserIssue(
+        return typeParserIssue(
           "Node is not a property access expression",
           void 0,
           node
@@ -2154,21 +2165,23 @@ function make3(ts, typeChecker) {
       }
       const propertyAccess = expressionToTest;
       if (propertyAccess.name.text !== "fn") {
-        return yield* typeParserIssue(
+        return typeParserIssue(
           "Call expression name is not 'fn'",
           void 0,
           node
         );
       }
-      const effectModule = yield* importedEffectModule(propertyAccess.expression);
-      return {
-        node,
-        generatorFunction,
-        effectModule,
-        body: generatorFunction.body,
-        functionStar: generatorFunction.getFirstToken()
-      };
-    }),
+      return pipe(
+        importedEffectModule(propertyAccess.expression),
+        map3((effectModule) => ({
+          node,
+          generatorFunction,
+          effectModule,
+          body: generatorFunction.body,
+          functionStar: generatorFunction.getFirstToken()
+        }))
+      );
+    },
     "TypeParser.effectFnGen",
     (node) => node
   );
@@ -2299,6 +2312,20 @@ function make3(ts, typeChecker) {
     "TypeParser.contextTag",
     (type) => type
   );
+  const pipeCall = cachedBy(
+    function(node) {
+      if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.name) && node.expression.name.text === "pipe") {
+        return succeed({ node, subject: node.expression.expression, args: Array.from(node.arguments) });
+      }
+      if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "pipe" && node.arguments.length > 0) {
+        const [subject, ...args] = node.arguments;
+        return succeed({ node, subject, args });
+      }
+      return typeParserIssue("Node is not a pipe call", void 0, node);
+    },
+    "TypeParser.pipeCall",
+    (node) => node
+  );
   return {
     effectType,
     layerType,
@@ -2310,7 +2337,8 @@ function make3(ts, typeChecker) {
     effectFnGen,
     unnecessaryEffectGen: unnecessaryEffectGen2,
     effectSchemaType,
-    contextTag
+    contextTag,
+    pipeCall
   };
 }
 
@@ -2816,6 +2844,53 @@ var unnecessaryEffectGen = createDiagnostic({
   })
 });
 
+// src/diagnostics/unnecessaryPipe.ts
+var unnecessaryPipe = createDiagnostic({
+  name: "unnecessaryPipe",
+  code: 9,
+  apply: fn("unnecessaryPipe.apply")(function* (sourceFile) {
+    const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
+    const pipeDiagnostics = [];
+    const unnecessaryPipes = /* @__PURE__ */ new Map();
+    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)) {
+        yield* pipe(
+          typeParser.pipeCall(node),
+          map3(({ args, subject }) => args.length === 0 ? unnecessaryPipes.set(node, subject) : void 0),
+          ignore
+        );
+      }
+    }
+    unnecessaryPipes.forEach(
+      (pipeCall, pipeSubject) => pipeDiagnostics.push({
+        node: pipeCall,
+        category: ts.DiagnosticCategory.Suggestion,
+        messageText: `This pipe call contains no arguments.`,
+        fixes: [{
+          fixName: "unnecessaryPipe_fix",
+          description: "Remove the pipe call",
+          apply: gen(function* () {
+            const textChanges = yield* service(
+              ChangeTracker
+            );
+            textChanges.replaceNode(sourceFile, pipeSubject, pipeCall);
+          })
+        }]
+      })
+    );
+    return pipeDiagnostics;
+  })
+});
+
 // src/diagnostics.ts
 var diagnostics = [
   duplicatePackage,
@@ -2825,7 +2900,8 @@ var diagnostics = [
   missingStarInYieldEffectGen,
   unnecessaryEffectGen,
   missingReturnYieldStar,
-  leakingRequirements
+  leakingRequirements,
+  unnecessaryPipe
 ];
 
 // src/transform.ts