@effect/language-service 0.69.2 → 0.70.0

package/README.md

@@ -78,7 +78,7 @@ And you're done! You'll now be able to use a set of refactors and diagnostics th
 - Warn when using `Schema.Union` with multiple `Schema.Literal` calls that can be simplified to a single `Schema.Literal` call
 - Suggest using `Schema.TaggedStruct` instead of `Schema.Struct` when a `_tag` field with `Schema.Literal` is present to make the tag optional in the constructor
 - Warn when using `yield* Effect.fail()` with yieldable error types that can be yielded directly
-- Warn when using `Effect.fail` with the global `Error` type, recommending tagged errors
+- Warn when the global `Error` type is used in an Effect failure channel, recommending tagged errors
 - Warn when `Layer.mergeAll` contains layers with interdependencies (where one layer provides a service that another layer in the same call requires)
 - Suggest using `Effect.fn` for functions that return `Effect.gen` for better tracing and concise syntax
 - Warn when `Effect.fn` or `Effect.fnUntraced` is used as an IIFE (Immediately Invoked Function Expression), suggesting `Effect.gen` instead

package/cli.js

@@ -30214,7 +30214,7 @@ var runMain3 = runMain2;
 // package.json
 var package_default = {
   name: "@effect/language-service",
-  version: "0.69.2",
+  version: "0.70.0",
   packageManager: "pnpm@8.11.0",
   publishConfig: {
     access: "public",
@@ -37060,7 +37060,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: fn2("globalErrorInEffectFailure.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
@@ -37075,27 +37075,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),
-          flatMap18(() => {
-            if (node.arguments.length > 0) {
-              const failArgument = node.arguments[0];
-              const argumentType = typeCheckerUtils.getTypeAtLocation(failArgument);
-              if (argumentType && typeCheckerUtils.isGlobalErrorType(argumentType)) {
-                return sync11(
-                  () => 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),
+              option5
+            );
+            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_8;
-          }),
-          ignore3
-        );
+          }
+          current = current.parent;
+        }
       }
     }
   })
@@ -37684,9 +37692,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",