@effect/language-service 0.53.2 → 0.54.0

package/index.js

@@ -8291,6 +8291,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",
@@ -8538,7 +8595,8 @@ var diagnostics = [
   nonObjectEffectServiceType,
   deterministicKeys,
   missedPipeableOpportunity,
-  strictEffectProvide
+  strictEffectProvide,
+  unknownInEffectCatch
 ];
 
 // src/completions/effectDiagnosticsComment.ts