@effect/language-service 0.25.1 → 0.27.0

package/README.md

@@ -47,6 +47,7 @@ And you're done! You'll now be able to use a set of refactors and diagnostics th
 - Unnecessary usages of `Effect.gen` or `pipe()`
 - Warn when importing from a barrel file instead of from the module directly
 - Warn on usage of try/catch inside `Effect.gen` and family
+- Detect unnecessary pipe chains like `X.pipe(Y).pipe(Z)`
 
 ### Completions
 
@@ -67,6 +68,7 @@ And you're done! You'll now be able to use a set of refactors and diagnostics th
 - Toggle return type signature: With a single refactor, adds or removes type annotations from the definition.
 - Remove unnecessary `Effect.gen` definitions that contains a single `yield` statement.
 - Wrap an `Effect` expression with `Effect.gen`
+- Toggle between pipe styles `X.pipe(Y)` and `pipe(X, Y)`
 
 ### Miscellaneous
 - "Go to definition" for RpcClient will resolve to the Rpc definition
@@ -119,8 +121,9 @@ Your `tsconfig.json` should look like this:
 
 To get diagnostics you need to install `ts-patch` which will make it possible to run `tspc`.
 
-Running `tspc` in your project will now also run the plugin and give you the diagnostics at compile time.
-Effect diagnostics will be shown only after standard TypeScript diagnostics have been satisfied.
+Running `tspc` in your project will now also run the plugin and give you the error diagnostics at compile time.
+Effect error diagnostics will be shown only after standard TypeScript diagnostics have been satisfied.
+Beware that setting noEmit will completely skip the effect diagnostics.
 
 ```ts
 $ npx tspc

package/cli.js

@@ -31428,11 +31428,16 @@ function make62(ts2, typeChecker) {
   const pipeCall = cachedBy(
     function(node) {
       if (ts2.isCallExpression(node) && ts2.isPropertyAccessExpression(node.expression) && ts2.isIdentifier(node.expression.name) && node.expression.name.text === "pipe") {
-        return succeed17({ node, subject: node.expression.expression, args: Array.from(node.arguments) });
+        return succeed17({
+          node,
+          subject: node.expression.expression,
+          args: Array.from(node.arguments),
+          kind: "pipeable"
+        });
       }
       if (ts2.isCallExpression(node) && ts2.isIdentifier(node.expression) && node.expression.text === "pipe" && node.arguments.length > 0) {
         const [subject, ...args3] = node.arguments;
-        return succeed17({ node, subject, args: args3 });
+        return succeed17({ node, subject, args: args3, kind: "pipe" });
       }
       return typeParserIssue("Node is not a pipe call", void 0, node);
     },
@@ -31471,6 +31476,7 @@ function make62(ts2, typeChecker) {
     unnecessaryEffectGen: unnecessaryEffectGen2,
     effectSchemaType,
     contextTag,
+    pipeableType,
     pipeCall,
     scopeType
   };
@@ -32404,10 +32410,77 @@ Consider using "scoped" instead to get rid of the scope in the requirements.`,
   })
 });
 
+// src/diagnostics/strictBooleanExpressions.ts
+var strictBooleanExpressions = createDiagnostic({
+  name: "strictBooleanExpressions",
+  code: 17,
+  severity: "off",
+  apply: fn("strictBooleanExpressions.apply")(function* (sourceFile, report) {
+    const ts2 = yield* service2(TypeScriptApi);
+    const typeChecker = yield* service2(TypeCheckerApi);
+    const conditionChecks = /* @__PURE__ */ new WeakMap();
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts2.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts2.forEachChild(node, appendNodeToVisit);
+      const nodes = [];
+      if (ts2.isIfStatement(node)) {
+        conditionChecks.set(node, true);
+        nodes.push(node.expression);
+      } else if (ts2.isWhileStatement(node)) {
+        conditionChecks.set(node, true);
+        nodes.push(node.expression);
+      } else if (ts2.isConditionalExpression(node)) {
+        conditionChecks.set(node, true);
+        nodes.push(node.condition);
+      } else if (ts2.isPrefixUnaryExpression(node) && node.operator === ts2.SyntaxKind.ExclamationToken) {
+        conditionChecks.set(node, true);
+        nodes.push(node.operand);
+      } else if (ts2.isBinaryExpression(node) && node.operatorToken.kind === ts2.SyntaxKind.BarBarToken) {
+        if (conditionChecks.has(node.parent)) conditionChecks.set(node, true);
+        nodes.push(node.left);
+        nodes.push(node.right);
+      } else if (ts2.isBinaryExpression(node) && node.operatorToken.kind === ts2.SyntaxKind.AmpersandAmpersandToken) {
+        if (conditionChecks.has(node.parent)) conditionChecks.set(node, true);
+        nodes.push(node.left);
+        nodes.push(node.right);
+      }
+      for (const nodeToCheck of nodes) {
+        if (!nodeToCheck) continue;
+        if (!conditionChecks.has(nodeToCheck.parent)) continue;
+        const nodeType = typeChecker.getTypeAtLocation(nodeToCheck);
+        const constrainedType = typeChecker.getBaseConstraintOfType(nodeType);
+        let typesToCheck = [constrainedType || nodeType];
+        while (typesToCheck.length > 0) {
+          const type2 = typesToCheck.pop();
+          if (type2.isUnion()) {
+            typesToCheck = typesToCheck.concat(type2.types);
+            continue;
+          }
+          if (type2.flags & ts2.TypeFlags.Boolean) continue;
+          if (type2.flags & ts2.TypeFlags.Never) continue;
+          if (type2.flags & ts2.TypeFlags.BooleanLiteral) continue;
+          const typeName = typeChecker.typeToString(type2);
+          report({
+            node: nodeToCheck,
+            messageText: `Unexpected \`${typeName}\` type in condition, expected strictly a boolean instead.`,
+            fixes: []
+          });
+        }
+      }
+    }
+  })
+});
+
 // src/diagnostics/tryCatchInEffectGen.ts
 var tryCatchInEffectGen = createDiagnostic({
   name: "tryCatchInEffectGen",
-  code: 12,
+  code: 15,
   severity: "suggestion",
   apply: fn("tryCatchInEffectGen.apply")(function* (sourceFile, report) {
     const ts2 = yield* service2(TypeScriptApi);
@@ -32537,6 +32610,80 @@ var unnecessaryPipe = createDiagnostic({
   })
 });
 
+// src/diagnostics/unnecessaryPipeChain.ts
+var unnecessaryPipeChain = createDiagnostic({
+  name: "unnecessaryPipeChain",
+  code: 16,
+  severity: "suggestion",
+  apply: fn("unnecessaryPipeChain.apply")(function* (sourceFile, report) {
+    const ts2 = yield* service2(TypeScriptApi);
+    const typeParser = yield* service2(TypeParser);
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts2.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts2.forEachChild(node, appendNodeToVisit);
+      if (ts2.isCallExpression(node)) {
+        yield* pipe(
+          typeParser.pipeCall(node),
+          flatMap18(
+            (pipeCall) => map33(typeParser.pipeCall(pipeCall.subject), (innerCall) => ({ pipeCall, innerCall }))
+          ),
+          map33(({ innerCall, pipeCall }) => {
+            report({
+              node,
+              messageText: `Chained pipe calls can be simplified to a single pipe call`,
+              fixes: [{
+                fixName: "unnecessaryPipeChain_fix",
+                description: "Rewrite as single pipe call",
+                apply: gen3(function* () {
+                  const changeTracker = yield* service2(
+                    ChangeTracker
+                  );
+                  switch (innerCall.kind) {
+                    case "pipe": {
+                      changeTracker.replaceNode(
+                        sourceFile,
+                        node,
+                        ts2.factory.createCallExpression(
+                          ts2.factory.createIdentifier("pipe"),
+                          void 0,
+                          [innerCall.subject, ...innerCall.args, ...pipeCall.args]
+                        )
+                      );
+                      break;
+                    }
+                    case "pipeable": {
+                      changeTracker.replaceNode(
+                        sourceFile,
+                        node,
+                        ts2.factory.createCallExpression(
+                          ts2.factory.createPropertyAccessExpression(
+                            innerCall.subject,
+                            "pipe"
+                          ),
+                          void 0,
+                          [...innerCall.args, ...pipeCall.args]
+                        )
+                      );
+                      break;
+                    }
+                  }
+                })
+              }]
+            });
+          }),
+          ignore3
+        );
+      }
+    }
+  })
+});
+
 // src/diagnostics.ts
 var diagnostics = [
   duplicatePackage,
@@ -32553,7 +32700,9 @@ var diagnostics = [
   tryCatchInEffectGen,
   importFromBarrel,
   scopeInLayerEffect,
-  effectInVoidSuccess
+  effectInVoidSuccess,
+  unnecessaryPipeChain,
+  strictBooleanExpressions
 ];
 
 // src/cli.ts