@effect/language-service 0.70.0 → 0.71.0

package/README.md

@@ -84,6 +84,7 @@ And you're done! You'll now be able to use a set of refactors and diagnostics th
 - Warn when `Effect.fn` or `Effect.fnUntraced` is used as an IIFE (Immediately Invoked Function Expression), suggesting `Effect.gen` instead
 - Suggest removing redundant identifier argument when it equals the tag value in `Schema.TaggedClass`, `Schema.TaggedError`, or `Schema.TaggedRequest`
 - Suggest using `Schema.is` instead of `instanceof` for Effect Schema types
+- Suggest using `Effect.void` instead of `Effect.succeed(undefined)` or `Effect.succeed(void 0)`
 
 ### Completions
 

package/cli.js

@@ -30214,7 +30214,7 @@ var runMain3 = runMain2;
 // package.json
 var package_default = {
   name: "@effect/language-service",
-  version: "0.70.0",
+  version: "0.71.0",
   packageManager: "pnpm@8.11.0",
   publishConfig: {
     access: "public",
@@ -36899,6 +36899,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: fn2("effectSucceedWithVoid.apply")(function* (sourceFile, report) {
+    const ts = yield* service2(TypeScriptApi);
+    const typeParser = yield* service2(TypeParser);
+    const tsUtils = yield* service2(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),
+          option5
+        );
+        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: gen3(function* () {
+                const changeTracker = yield* service2(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",
@@ -37042,8 +37093,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: []
                   });
                 }
@@ -37095,7 +37145,7 @@ var globalErrorInEffectFailure = createDiagnostic({
               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.`,
+                  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: []
                 });
               }
@@ -39769,6 +39819,7 @@ var diagnostics = [
   globalErrorInEffectFailure,
   layerMergeAllWithDependencies,
   effectMapVoid,
+  effectSucceedWithVoid,
   effectFnIife,
   effectFnOpportunity,
   redundantSchemaTagIdentifier,