@effect/language-service 0.53.2 → 0.54.0

package/effect-lsp-patch-utils.js

@@ -5830,6 +5830,63 @@ var tryCatchInEffectGen = createDiagnostic({
   })
 });
 
+// src/diagnostics/unknownInEffectCatch.ts
+var unknownInEffectCatch = createDiagnostic({
+  name: "unknownInEffectCatch",
+  code: 31,
+  severity: "warning",
+  apply: fn("unknownInEffectCatch.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
+    const typeChecker = yield* service(TypeCheckerApi);
+    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 isEffectWithCatch = yield* pipe(
+          typeParser.isNodeReferenceToEffectModuleApi("tryPromise")(node.expression),
+          orElse2(() => typeParser.isNodeReferenceToEffectModuleApi("try")(node.expression)),
+          orElse2(() => typeParser.isNodeReferenceToEffectModuleApi("tryMap")(node.expression)),
+          orElse2(() => typeParser.isNodeReferenceToEffectModuleApi("tryMapPromise")(node.expression)),
+          orElse2(() => void_)
+        );
+        if (isEffectWithCatch) {
+          const signature = typeChecker.getResolvedSignature(node);
+          if (signature) {
+            const objectType = typeChecker.getParameterType(signature, 0);
+            const catchFunctionSymbol = typeChecker.getPropertyOfType(objectType, "catch");
+            if (catchFunctionSymbol) {
+              const catchFunctionType = typeChecker.getTypeOfSymbolAtLocation(catchFunctionSymbol, node);
+              const signatures = typeChecker.getSignaturesOfType(catchFunctionType, ts.SignatureKind.Call);
+              if (signatures.length > 0) {
+                const returnType = typeChecker.getReturnTypeOfSignature(signatures[0]);
+                if (returnType && (returnType.flags & ts.TypeFlags.Unknown || returnType.flags & ts.TypeFlags.Any)) {
+                  const nodeText = sourceFile.text.substring(
+                    ts.getTokenPosOfNode(node.expression, sourceFile),
+                    node.expression.end
+                  );
+                  report({
+                    location: node.expression,
+                    messageText: `The 'catch' callback in ${nodeText} returns 'unknown'. The catch callback should be used to provide typed errors.
+Consider wrapping unknown errors into Effect's Data.TaggedError for example, or narrow down the type to the specific error raised.`,
+                    fixes: []
+                  });
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  })
+});
+
 // src/diagnostics/unnecessaryEffectGen.ts
 var unnecessaryEffectGen = createDiagnostic({
   name: "unnecessaryEffectGen",
@@ -6077,7 +6134,8 @@ var diagnostics = [
   nonObjectEffectServiceType,
   deterministicKeys,
   missedPipeableOpportunity,
-  strictEffectProvide
+  strictEffectProvide,
+  unknownInEffectCatch
 ];
 
 // src/effect-lsp-patch-utils.ts
@@ -6101,10 +6159,13 @@ function appendMetadataRelationError(tsInstance, errorNode, source, target) {
     ]);
   }
 }
-function checkSourceFileWorker(tsInstance, program, sourceFile, compilerOptions, addDiagnostic) {
+function checkSourceFileWorker(tsInstance, program, sourceFile, compilerOptions, addDiagnostic, moduleName) {
   const pluginOptions = extractEffectLspOptions(compilerOptions);
   if (!pluginOptions) return;
-  const parsedOptions = parse(pluginOptions);
+  const parsedOptions = {
+    ...parse(pluginOptions),
+    diagnosticsName: true
+  };
   pipe(
     getSemanticDiagnosticsWithCodeFixes(diagnostics, sourceFile),
     nanoLayer3,
@@ -6121,17 +6182,13 @@ function checkSourceFileWorker(tsInstance, program, sourceFile, compilerOptions,
     map((_) => _.diagnostics),
     map(
       filter(
-        (_) => _.category === tsInstance.DiagnosticCategory.Error || _.category === tsInstance.DiagnosticCategory.Warning || parsedOptions.reportSuggestionsAsWarningsInTsc && (_.category === tsInstance.DiagnosticCategory.Suggestion || _.category === tsInstance.DiagnosticCategory.Message)
+        (_) => _.category === tsInstance.DiagnosticCategory.Error || _.category === tsInstance.DiagnosticCategory.Warning || moduleName === "tsc" && parsedOptions.reportSuggestionsAsWarningsInTsc && (_.category === tsInstance.DiagnosticCategory.Suggestion || _.category === tsInstance.DiagnosticCategory.Message)
       )
     ),
     map(
       map3((_) => {
-        if (parsedOptions.reportSuggestionsAsWarningsInTsc && (_.category === tsInstance.DiagnosticCategory.Suggestion || _.category === tsInstance.DiagnosticCategory.Message)) {
-          return {
-            ..._,
-            category: tsInstance.DiagnosticCategory.Warning,
-            messageText: typeof _.messageText === "string" ? `[suggestion] ${_.messageText}` : _.messageText
-          };
+        if (moduleName === "tsc" && parsedOptions.reportSuggestionsAsWarningsInTsc && _.category === tsInstance.DiagnosticCategory.Suggestion) {
+          return { ..._, category: tsInstance.DiagnosticCategory.Message };
         }
         return _;
       })