@effect/language-service 0.69.2 → 0.71.0

package/index.js

@@ -8958,6 +8958,57 @@ var effectMapVoid = createDiagnostic({
   })
 });
 
+// src/diagnostics/effectSucceedWithVoid.ts
+var effectSucceedWithVoid = createDiagnostic({
+  name: "effectSucceedWithVoid",
+  code: 47,
+  description: "Suggests using Effect.void instead of Effect.succeed(undefined) or Effect.succeed(void 0)",
+  severity: "suggestion",
+  apply: fn("effectSucceedWithVoid.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
+    const tsUtils = yield* service(TypeScriptUtils);
+    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)) {
+        const isSucceedCall = yield* pipe(
+          typeParser.isNodeReferenceToEffectModuleApi("succeed")(node.expression),
+          option
+        );
+        if (isSome2(isSucceedCall)) {
+          const argument = node.arguments[0];
+          if (!argument) continue;
+          if (!tsUtils.isVoidExpression(argument)) continue;
+          report({
+            location: node,
+            messageText: "Effect.void can be used instead of Effect.succeed(undefined) or Effect.succeed(void 0)",
+            fixes: [{
+              fixName: "effectSucceedWithVoid_fix",
+              description: "Replace with Effect.void",
+              apply: gen(function* () {
+                const changeTracker = yield* service(ChangeTracker);
+                const effectModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, "effect", "Effect") || "Effect";
+                const newNode = ts.factory.createPropertyAccessExpression(
+                  ts.factory.createIdentifier(effectModuleIdentifier),
+                  ts.factory.createIdentifier("void")
+                );
+                changeTracker.replaceNode(sourceFile, node, newNode);
+              })
+            }]
+          });
+        }
+      }
+    }
+  })
+});
+
 // src/diagnostics/floatingEffect.ts
 var floatingEffect = createDiagnostic({
   name: "floatingEffect",
@@ -9101,8 +9152,7 @@ var globalErrorInEffectCatch = createDiagnostic({
                   );
                   report({
                     location: node.expression,
-                    messageText: `The 'catch' callback in ${nodeText} returns 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.`,
+                    messageText: `The 'catch' callback in ${nodeText} returns global 'Error', which loses type safety as untagged errors merge together. Consider using a tagged error and optionally wrapping the original in a 'cause' property.`,
                     fixes: []
                   });
                 }
@@ -9119,7 +9169,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);
@@ -9134,27 +9184,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),
-          flatMap4(() => {
-            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: `Global 'Error' loses type safety as untagged errors merge together in the Effect failure channel. Consider using a tagged error and optionally wrapping the original in a 'cause' property.`,
+                  fixes: []
+                });
               }
+              break;
             }
-            return void_;
-          }),
-          ignore
-        );
+          }
+          current = current.parent;
+        }
       }
     }
   })
@@ -9743,9 +9801,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",
@@ -11800,6 +11878,7 @@ var diagnostics = [
   globalErrorInEffectFailure,
   layerMergeAllWithDependencies,
   effectMapVoid,
+  effectSucceedWithVoid,
   effectFnIife,
   effectFnOpportunity,
   redundantSchemaTagIdentifier,