@effect/language-service 0.70.0 → 0.71.1

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
 
@@ -140,6 +141,8 @@ Few options can be provided alongside the initialization of the Language Service
         "diagnosticsName": true, // controls whether to include the rule name in diagnostic messages (default: true)
         "missingDiagnosticNextLine": "warning", // controls the severity of warnings for unused @effect-diagnostics-next-line comments (default: "warning", allowed values: off,error,warning,message,suggestion)
         "includeSuggestionsInTsc": true, // when enabled with effect-language-service patch enabled, diagnostics with "suggestion" severity will be reported as "message" in TSC with "[suggestion]" prefix; useful to help steer LLM output (default: true)
+        "ignoreEffectWarningsInTscExitCode": false, // if set to true, effect-related warnings won't change the exit code of tsc, meaning that tsc will compile fine even if effect warnings are emitted (default: false)
+        "ignoreEffectSuggestionsInTscExitCode": true, // if set to true, effect-related suggestions won't change the exit code of tsc (default: true)
         "quickinfo": true, // controls Effect quickinfo (default: true)
         "quickinfoEffectParameters": "whenTruncated", // (default: "whenTruncated") controls when to display effect type parameters always,never,whenTruncated
         "quickinfoMaximumLength": -1, // controls how long can be the types in the quickinfo hover (helps with very long type to improve perfs, defaults to -1 for no truncation, can be any number eg. 1000 and TS will try to fit as much as possible in that budget, higher number means more info.)

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.1",
   packageManager: "pnpm@8.11.0",
   publishConfig: {
     access: "public",
@@ -32038,6 +32038,8 @@ var defaults = {
     skipLeadingPath: ["src/"]
   }],
   extendedKeyDetection: false,
+  ignoreEffectWarningsInTscExitCode: false,
+  ignoreEffectSuggestionsInTscExitCode: true,
   pipeableMinArgCount: 2,
   effectFn: ["span"],
   layerGraphFollowDepth: 0,
@@ -32063,6 +32065,8 @@ function parse4(config2) {
     diagnosticsName: isObject(config2) && hasProperty(config2, "diagnosticsName") && isBoolean(config2.diagnosticsName) ? config2.diagnosticsName : defaults.diagnosticsName,
     missingDiagnosticNextLine: isObject(config2) && hasProperty(config2, "missingDiagnosticNextLine") && isString(config2.missingDiagnosticNextLine) && isValidSeverityLevel(config2.missingDiagnosticNextLine) ? config2.missingDiagnosticNextLine : defaults.missingDiagnosticNextLine,
     includeSuggestionsInTsc: isObject(config2) && hasProperty(config2, "includeSuggestionsInTsc") && isBoolean(config2.includeSuggestionsInTsc) ? config2.includeSuggestionsInTsc : defaults.includeSuggestionsInTsc,
+    ignoreEffectWarningsInTscExitCode: isObject(config2) && hasProperty(config2, "ignoreEffectWarningsInTscExitCode") && isBoolean(config2.ignoreEffectWarningsInTscExitCode) ? config2.ignoreEffectWarningsInTscExitCode : defaults.ignoreEffectWarningsInTscExitCode,
+    ignoreEffectSuggestionsInTscExitCode: isObject(config2) && hasProperty(config2, "ignoreEffectSuggestionsInTscExitCode") && isBoolean(config2.ignoreEffectSuggestionsInTscExitCode) ? config2.ignoreEffectSuggestionsInTscExitCode : defaults.ignoreEffectSuggestionsInTscExitCode,
     quickinfo: isObject(config2) && hasProperty(config2, "quickinfo") && isBoolean(config2.quickinfo) ? config2.quickinfo : defaults.quickinfo,
     quickinfoEffectParameters: isObject(config2) && hasProperty(config2, "quickinfoEffectParameters") && isString(config2.quickinfoEffectParameters) && ["always", "never", "whentruncated"].includes(config2.quickinfoEffectParameters.toLowerCase()) ? config2.quickinfoEffectParameters.toLowerCase() : defaults.quickinfoEffectParameters,
     quickinfoMaximumLength: isObject(config2) && hasProperty(config2, "quickinfoMaximumLength") && isNumber(config2.quickinfoMaximumLength) ? config2.quickinfoMaximumLength : defaults.quickinfoMaximumLength,
@@ -36899,6 +36903,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 +37097,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 +37149,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 +39823,7 @@ var diagnostics = [
   globalErrorInEffectFailure,
   layerMergeAllWithDependencies,
   effectMapVoid,
+  effectSucceedWithVoid,
   effectFnIife,
   effectFnOpportunity,
   redundantSchemaTagIdentifier,
@@ -41455,6 +41510,8 @@ var getPatchesForModule = fn("getPatchesForModule")(
     let insertCheckSourceFilePosition = none2();
     let insertSkipPrecedingCommentDirectivePosition = none2();
     let insertAppendMetadataRelationErrorPosition = none2();
+    let insertExtractDiagnosticsForExitStatusPosition = none2();
+    let replacedBindingExtractDiagnosticsForExitStatus = none2();
     let nodesToCheck = [];
     function findNodeAtPositionIncludingTrivia(sourceFile2, position) {
       function find3(node) {
@@ -41483,6 +41540,7 @@ var getPatchesForModule = fn("getPatchesForModule")(
     if (!pushFunctionDeclarationNode("checkSourceFileWorker")) requiresFullScan = true;
     if (!pushFunctionDeclarationNode("markPrecedingCommentDirectiveLine")) requiresFullScan = true;
     if (!pushFunctionDeclarationNode("reportRelationError")) requiresFullScan = true;
+    if (!pushFunctionDeclarationNode("emitFilesAndReportErrorsAndGetExitStatus")) requiresFullScan = true;
     if (requiresFullScan) nodesToCheck = [sourceFile];
     while (nodesToCheck.length > 0) {
       const node = nodesToCheck.shift();
@@ -41517,6 +41575,29 @@ var getPatchesForModule = fn("getPatchesForModule")(
             });
           }
         }
+      } else if (ts.isCallExpression(node)) {
+        const callee = node.expression;
+        if (ts.isIdentifier(callee) && ts.idText(callee) === "emitFilesAndReportErrors") {
+          const parentVariableDeclaration = ts.findAncestor(node, ts.isVariableDeclaration);
+          if (parentVariableDeclaration) {
+            const parentVariableStatement = ts.findAncestor(parentVariableDeclaration, ts.isVariableStatement);
+            if (parentVariableStatement) {
+              const parentBlock = parentVariableStatement.parent;
+              if (ts.isBlock(parentBlock)) {
+                const parentFunctionDeclaration = parentBlock.parent;
+                if (ts.isFunctionDeclaration(parentFunctionDeclaration) && parentFunctionDeclaration.name && ts.isIdentifier(parentFunctionDeclaration.name) && ts.idText(parentFunctionDeclaration.name) === "emitFilesAndReportErrorsAndGetExitStatus") {
+                  insertExtractDiagnosticsForExitStatusPosition = some2({
+                    position: parentVariableStatement.end
+                  });
+                  replacedBindingExtractDiagnosticsForExitStatus = some2({
+                    pos: parentVariableDeclaration.name.pos,
+                    end: parentVariableDeclaration.name.end
+                  });
+                }
+              }
+            }
+          }
+        }
       }
       ts.forEachChild(node, (child) => {
         nodesToCheck.push(child);
@@ -41571,9 +41652,7 @@ var getPatchesForModule = fn("getPatchesForModule")(
       )
     );
     if (isNone2(insertSkipPrecedingCommentDirectivePosition)) {
-      return yield* fail7(
-        new UnableToFindPositionToPatchError({ positionToFind: "skip preceding comment directive" })
-      );
+      return yield* new UnableToFindPositionToPatchError({ positionToFind: "skip preceding comment directive" });
     }
     patches.push(
       yield* makeEffectLspPatchChange(
@@ -41585,6 +41664,33 @@ var getPatchesForModule = fn("getPatchesForModule")(
         version
       )
     );
+    if (isNone2(insertExtractDiagnosticsForExitStatusPosition)) {
+      return yield* new UnableToFindPositionToPatchError({ positionToFind: "extractDiagnosticsForExitStatus" });
+    }
+    if (isNone2(replacedBindingExtractDiagnosticsForExitStatus)) {
+      return yield* new UnableToFindPositionToPatchError({ positionToFind: "extractDiagnosticsForExitStatus-binding" });
+    }
+    patches.push(
+      yield* makeEffectLspPatchChange(
+        sourceFile.text,
+        replacedBindingExtractDiagnosticsForExitStatus.value.pos,
+        replacedBindingExtractDiagnosticsForExitStatus.value.end,
+        ` { emitResult, diagnostics: tscDiagnostics }`,
+        " ",
+        version
+      )
+    );
+    patches.push(
+      yield* makeEffectLspPatchChange(
+        sourceFile.text,
+        insertExtractDiagnosticsForExitStatusPosition.value.position,
+        insertExtractDiagnosticsForExitStatusPosition.value.position,
+        `const diagnostics = effectLspPatchUtils().extractDiagnosticsForExitStatus(${moduleName === "typescript" ? "module.exports" : "effectLspTypeScriptApis()"}, program, tscDiagnostics, "${moduleName}")
+`,
+        "\n",
+        version
+      )
+    );
     let eofPos = sourceFile.text.lastIndexOf("// src/") - 1;
     if (eofPos < 0) eofPos = sourceFile.text.length;
     if (moduleName !== "typescript") {