@effect/language-service 0.70.0 → 0.71.1

package/effect-lsp-patch-utils.js

@@ -22,7 +22,8 @@ var effect_lsp_patch_utils_exports = {};
 __export(effect_lsp_patch_utils_exports, {
   appendMetadataRelationError: () => appendMetadataRelationError,
   checkSourceFileWorker: () => checkSourceFileWorker,
-  clearSourceFileEffectMetadata: () => clearSourceFileEffectMetadata
+  clearSourceFileEffectMetadata: () => clearSourceFileEffectMetadata,
+  extractDiagnosticsForExitStatus: () => extractDiagnosticsForExitStatus
 });
 module.exports = __toCommonJS(effect_lsp_patch_utils_exports);
 
@@ -1224,6 +1225,8 @@ var defaults = {
     skipLeadingPath: ["src/"]
   }],
   extendedKeyDetection: false,
+  ignoreEffectWarningsInTscExitCode: false,
+  ignoreEffectSuggestionsInTscExitCode: true,
   pipeableMinArgCount: 2,
   effectFn: ["span"],
   layerGraphFollowDepth: 0,
@@ -1249,6 +1252,8 @@ function parse(config) {
     diagnosticsName: isObject(config) && hasProperty(config, "diagnosticsName") && isBoolean(config.diagnosticsName) ? config.diagnosticsName : defaults.diagnosticsName,
     missingDiagnosticNextLine: isObject(config) && hasProperty(config, "missingDiagnosticNextLine") && isString(config.missingDiagnosticNextLine) && isValidSeverityLevel(config.missingDiagnosticNextLine) ? config.missingDiagnosticNextLine : defaults.missingDiagnosticNextLine,
     includeSuggestionsInTsc: isObject(config) && hasProperty(config, "includeSuggestionsInTsc") && isBoolean(config.includeSuggestionsInTsc) ? config.includeSuggestionsInTsc : defaults.includeSuggestionsInTsc,
+    ignoreEffectWarningsInTscExitCode: isObject(config) && hasProperty(config, "ignoreEffectWarningsInTscExitCode") && isBoolean(config.ignoreEffectWarningsInTscExitCode) ? config.ignoreEffectWarningsInTscExitCode : defaults.ignoreEffectWarningsInTscExitCode,
+    ignoreEffectSuggestionsInTscExitCode: isObject(config) && hasProperty(config, "ignoreEffectSuggestionsInTscExitCode") && isBoolean(config.ignoreEffectSuggestionsInTscExitCode) ? config.ignoreEffectSuggestionsInTscExitCode : defaults.ignoreEffectSuggestionsInTscExitCode,
     quickinfo: isObject(config) && hasProperty(config, "quickinfo") && isBoolean(config.quickinfo) ? config.quickinfo : defaults.quickinfo,
     quickinfoEffectParameters: isObject(config) && hasProperty(config, "quickinfoEffectParameters") && isString(config.quickinfoEffectParameters) && ["always", "never", "whentruncated"].includes(config.quickinfoEffectParameters.toLowerCase()) ? config.quickinfoEffectParameters.toLowerCase() : defaults.quickinfoEffectParameters,
     quickinfoMaximumLength: isObject(config) && hasProperty(config, "quickinfoMaximumLength") && isNumber(config.quickinfoMaximumLength) ? config.quickinfoMaximumLength : defaults.quickinfoMaximumLength,
@@ -5488,6 +5493,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",
@@ -5631,8 +5687,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: []
                   });
                 }
@@ -5684,7 +5739,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: []
                 });
               }
@@ -9391,6 +9446,7 @@ var diagnostics = [
   globalErrorInEffectFailure,
   layerMergeAllWithDependencies,
   effectMapVoid,
+  effectSucceedWithVoid,
   effectFnIife,
   effectFnOpportunity,
   redundantSchemaTagIdentifier,
@@ -9460,10 +9516,29 @@ function checkSourceFileWorker(tsInstance, program, sourceFile, compilerOptions,
     map3(addDiagnostic)
   );
 }
+function extractDiagnosticsForExitStatus(tsInstance, program, diagnostics2, _moduleName) {
+  const options = extractEffectLspOptions(program.getCompilerOptions());
+  const parsedOptions = parse(options);
+  let newDiagnostics = diagnostics2;
+  if (parsedOptions.ignoreEffectSuggestionsInTscExitCode) {
+    newDiagnostics = filter(
+      newDiagnostics,
+      (_) => !(_.source === "effect" && _.category === tsInstance.DiagnosticCategory.Message)
+    );
+  }
+  if (parsedOptions.ignoreEffectWarningsInTscExitCode) {
+    newDiagnostics = filter(
+      newDiagnostics,
+      (_) => !(_.source === "effect" && _.category === tsInstance.DiagnosticCategory.Warning)
+    );
+  }
+  return newDiagnostics;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   appendMetadataRelationError,
   checkSourceFileWorker,
-  clearSourceFileEffectMetadata
+  clearSourceFileEffectMetadata,
+  extractDiagnosticsForExitStatus
 });
 //# sourceMappingURL=effect-lsp-patch-utils.js.map