@effect/language-service 0.69.2 → 0.70.0

package/package.json

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

package/transform.js

@@ -5645,7 +5645,7 @@ Instead, use tagged errors or custom errors with a discriminator property to get
 var globalErrorInEffectFailure = createDiagnostic({
   name: "globalErrorInEffectFailure",
   code: 35,
-  description: "Warns when Effect.fail is called with the global Error type",
+  description: "Warns when the global Error type is used in an Effect failure channel",
   severity: "warning",
   apply: fn("globalErrorInEffectFailure.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
@@ -5660,27 +5660,35 @@ var globalErrorInEffectFailure = createDiagnostic({
     while (nodeToVisit.length > 0) {
       const node = nodeToVisit.shift();
       ts.forEachChild(node, appendNodeToVisit);
-      if (ts.isCallExpression(node)) {
-        yield* pipe(
-          typeParser.isNodeReferenceToEffectModuleApi("fail")(node.expression),
-          flatMap2(() => {
-            if (node.arguments.length > 0) {
-              const failArgument = node.arguments[0];
-              const argumentType = typeCheckerUtils.getTypeAtLocation(failArgument);
-              if (argumentType && typeCheckerUtils.isGlobalErrorType(argumentType)) {
-                return sync(
-                  () => report({
-                    location: node,
-                    messageText: `Effect.fail is called with the global Error type. It's not recommended to use the global Error type in Effect failures as they can get merged together. Instead, use tagged errors or custom errors with a discriminator property to get properly type-checked errors.`,
-                    fixes: []
-                  })
-                );
+      if (ts.isNewExpression(node)) {
+        const newExpressionType = typeCheckerUtils.getTypeAtLocation(node);
+        if (!newExpressionType || !typeCheckerUtils.isGlobalErrorType(newExpressionType)) {
+          continue;
+        }
+        let current = node.parent;
+        while (current) {
+          const currentType = typeCheckerUtils.getTypeAtLocation(current);
+          if (currentType) {
+            const effectTypeResult = yield* pipe(
+              typeParser.effectType(currentType, current),
+              option
+            );
+            if (effectTypeResult._tag === "Some") {
+              const effectType = effectTypeResult.value;
+              const failureMembers = typeCheckerUtils.unrollUnionMembers(effectType.E);
+              const hasGlobalError = failureMembers.some((member) => typeCheckerUtils.isGlobalErrorType(member));
+              if (hasGlobalError) {
+                report({
+                  location: node,
+                  messageText: `The global Error type is used in an Effect failure channel. It's not recommended to use the global Error type in Effect failures as they can get merged together. Instead, use tagged errors or custom errors with a discriminator property to get properly type-checked errors.`,
+                  fixes: []
+                });
               }
+              break;
             }
-            return void_;
-          }),
-          ignore
-        );
+          }
+          current = current.parent;
+        }
       }
     }
   })
@@ -6269,9 +6277,29 @@ var missedPipeableOpportunity = createDiagnostic({
             transformations: flow2.transformations.slice(0, firstPipeableIndex)
           });
           const afterTransformations = flow2.transformations.slice(pipeableEndIndex);
+          const getOriginalSubjectNode = () => {
+            if (firstPipeableIndex === 0) {
+              return flow2.subject.node;
+            }
+            let current = flow2.node;
+            for (let i = flow2.transformations.length; i > firstPipeableIndex; i--) {
+              const t = flow2.transformations[i - 1];
+              if (t.kind === "call" && ts.isCallExpression(current) && current.arguments.length > 0) {
+                current = current.arguments[0];
+              } else {
+                return void 0;
+              }
+            }
+            return current;
+          };
+          const originalSubjectNode = getOriginalSubjectNode();
+          const subjectText = originalSubjectNode ? sourceFile.text.slice(
+            ts.getTokenPosOfNode(originalSubjectNode, sourceFile),
+            originalSubjectNode.end
+          ).trim() : "";
           report({
             location: flow2.node,
-            messageText: `Nested function calls can be converted to pipeable style for better readability.`,
+            messageText: `Nested function calls can be converted to pipeable style for better readability; consider using ${subjectText}.pipe(...) instead.`,
             fixes: [{
               fixName: "missedPipeableOpportunity_fix",
               description: "Convert to pipe style",