@effect/language-service 0.21.0 → 0.21.1

package/README.md

@@ -41,9 +41,9 @@ And you're done! You'll now be able to use a set of refactor and diagnostics tha
 - Better error readability when you're missing errors or service types in your Effect definitions
 - Floating Effects that are not yielded or run
 - Wrong usage of yield inside Effect.gen
-- Unnecessary usages of Effect.gen
 - Multiple versions of Effect in your project
 - Warn on leaking requirements in Effect services
+- Unnecessary usages of Effect.gen or pipe()
 
 ### Completions
 
@@ -75,6 +75,9 @@ Few options can be provided alongside the initialization of the Language Service
       {
         "name": "@effect/language-service",
         "diagnostics": true, // controls Effect diagnostics (default: true)
+        "diagnosticSeverity": { // allows to change per-rule default severity of the diagnostic in the whole project
+          "floatingEffect": "warning" // example for a rule, allowed values are off,error,warning,message,suggestion
+        },
         "quickinfo": true, // controls quickinfo over Effect (default: true)
         "completions": true, // controls Effect completions (default: true)
         "allowedDuplicatedPackages": [] // list of package names that has effect in peer dependencies and are allowed to be duplicated (default: [])

package/index.js

@@ -198,6 +198,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`;
@@ -1549,19 +1550,32 @@ 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/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)),
+      map3(([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,
+    allowedDuplicatedPackages: isObject(config) && hasProperty(config, "allowedDuplicatedPackages") && isArray(config.allowedDuplicatedPackages) && config.allowedDuplicatedPackages.every(isString) ? config.allowedDuplicatedPackages.map((_) => _.toLowerCase()) : []
+  };
+}
 
 // src/core/LSP.ts
 var RefactorNotApplicableError = class {
@@ -1666,6 +1680,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;
@@ -1749,24 +1764,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 = (_) => ({
@@ -1999,18 +2020,18 @@ function make4(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
   );
@@ -2148,105 +2169,107 @@ function make4(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),
+        map4((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),
+        map4((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
@@ -2254,7 +2277,7 @@ function make4(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
@@ -2262,21 +2285,23 @@ function make4(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),
+        map4((effectModule) => ({
+          node,
+          generatorFunction,
+          effectModule,
+          body: generatorFunction.body,
+          functionStar: generatorFunction.getFirstToken()
+        }))
+      );
+    },
     "TypeParser.effectFnGen",
     (node) => node
   );
@@ -2407,6 +2432,20 @@ function make4(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,
@@ -2418,7 +2457,8 @@ function make4(ts, typeChecker) {
     effectFnGen,
     unnecessaryEffectGen: unnecessaryEffectGen2,
     effectSchemaType,
-    contextTag
+    contextTag,
+    pipeCall
   };
 }
 
@@ -2797,18 +2837,6 @@ var completions = [
   effectDataClasses
 ];
 
-// src/core/LanguageServicePluginOptions.ts
-var LanguageServicePluginOptions = Tag("PluginOptions");
-function parse(config) {
-  return {
-    diagnostics: isObject(config) && hasProperty(config, "diagnostics") && isBoolean(config.diagnostics) ? config.diagnostics : true,
-    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,
-    allowedDuplicatedPackages: isObject(config) && hasProperty(config, "allowedDuplicatedPackages") && isArray(config.allowedDuplicatedPackages) && config.allowedDuplicatedPackages.every(isString) ? config.allowedDuplicatedPackages.map((_) => _.toLowerCase()) : []
-  };
-}
-
 // src/diagnostics/duplicatePackage.ts
 var checkedPackagesCache = /* @__PURE__ */ new Map();
 var programResolvedCacheSize = /* @__PURE__ */ new Map();
@@ -3311,6 +3339,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),
+          map4(({ 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: gen2(function* () {
+            const textChanges = yield* service(
+              ChangeTracker
+            );
+            textChanges.replaceNode(sourceFile, pipeSubject, pipeCall);
+          })
+        }]
+      })
+    );
+    return pipeDiagnostics;
+  })
+});
+
 // src/diagnostics.ts
 var diagnostics = [
   duplicatePackage,
@@ -3320,7 +3395,8 @@ var diagnostics = [
   missingStarInYieldEffectGen,
   unnecessaryEffectGen,
   missingReturnYieldStar,
-  leakingRequirements
+  leakingRequirements,
+  unnecessaryPipe
 ];
 
 // src/goto/effectRpcDefinition.ts
@@ -3537,7 +3613,7 @@ function processLayerGraphNode(ctx, node, pipedInGraphNode) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
-    const maybePipe = yield* option(parsePipeCall(node));
+    const maybePipe = yield* option(typeParser.pipeCall(node));
     if (isSome2(maybePipe)) {
       let graphNode = yield* processLayerGraphNode(ctx, maybePipe.value.subject, void 0);
       for (const entry of maybePipe.value.args) {
@@ -4078,8 +4154,8 @@ var effectGenToFn = createRefactor({
           continue;
         }
         const maybePipe = yield* pipe(
-          parsePipeCall(parent),
-          orElse3((e) => parent.parent ? parsePipeCall(parent.parent) : fail(e)),
+          typeParser.pipeCall(parent),
+          orElse3((e) => parent.parent ? typeParser.pipeCall(parent.parent) : fail(e)),
           option
         );
         if (isSome2(maybePipe) && maybePipe.value.subject === nodeToReplace2) {
@@ -5352,10 +5428,14 @@ var refactors = [
 // src/index.ts
 var LSP_INJECTED_URI = "@effect/language-service/injected";
 var init = (modules) => {
+  let languageServicePluginOptions = parse({});
+  function onConfigurationChanged(config) {
+    languageServicePluginOptions = parse(config);
+  }
   function create(info) {
     const languageService = info.languageService;
+    languageServicePluginOptions = parse(info.config);
     if (languageService[LSP_INJECTED_URI]) return languageService;
-    const languageServicePluginOptions = parse(info.config);
     const diagnosticsErrorCodes = diagnostics.map((diagnostic) => diagnostic.code);
     try {
       ;
@@ -5601,7 +5681,7 @@ var init = (modules) => {
     };
     return proxy;
   }
-  return { create };
+  return { create, onConfigurationChanged };
 };
 module.exports = init;
 //# sourceMappingURL=index.js.map