@effect/language-service 0.53.3 → 0.54.0

package/README.md

@@ -69,6 +69,7 @@ And you're done! You'll now be able to use a set of refactors and diagnostics th
 - Warn when `@effect-diagnostics-next-line` comments have no effect (i.e., they don't suppress any diagnostic)
 - Detect nested function calls that can be converted to pipeable style for better readability
 - Warn when using catch functions (`catchAll`, `catch`, `catchIf`, `catchSome`, `catchTag`, `catchTags`) on effects that never fail
+- Warn when catch callbacks in `Effect.tryPromise`, `Effect.tryMap`, or `Effect.tryMapPromise` return `unknown` or `any` types
 
 ### Completions
 

package/cli.js

@@ -35288,6 +35288,63 @@ var tryCatchInEffectGen = createDiagnostic({
   })
 });
 
+// src/diagnostics/unknownInEffectCatch.ts
+var unknownInEffectCatch = createDiagnostic({
+  name: "unknownInEffectCatch",
+  code: 31,
+  severity: "warning",
+  apply: fn2("unknownInEffectCatch.apply")(function* (sourceFile, report) {
+    const ts = yield* service2(TypeScriptApi);
+    const typeParser = yield* service2(TypeParser);
+    const typeChecker = yield* service2(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),
+          orElse14(() => typeParser.isNodeReferenceToEffectModuleApi("try")(node.expression)),
+          orElse14(() => typeParser.isNodeReferenceToEffectModuleApi("tryMap")(node.expression)),
+          orElse14(() => typeParser.isNodeReferenceToEffectModuleApi("tryMapPromise")(node.expression)),
+          orElse14(() => void_8)
+        );
+        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",
@@ -35535,7 +35592,8 @@ var diagnostics = [
   nonObjectEffectServiceType,
   deterministicKeys,
   missedPipeableOpportunity,
-  strictEffectProvide
+  strictEffectProvide,
+  unknownInEffectCatch
 ];
 
 // src/cli/diagnostics.ts
@@ -35794,7 +35852,7 @@ var getPatchesForModule = fn("getPatchesForModule")(
         sourceFile.text,
         insertCheckSourceFilePosition.value.position,
         insertCheckSourceFilePosition.value.position,
-        `effectLspPatchUtils().checkSourceFileWorker(${moduleName === "typescript" ? "module.exports" : "effectLspTypeScriptApis()"}, host, node, compilerOptions, diagnostics.add)
+        `effectLspPatchUtils().checkSourceFileWorker(${moduleName === "typescript" ? "module.exports" : "effectLspTypeScriptApis()"}, host, node, compilerOptions, diagnostics.add, "${moduleName}")
 `,
         "\n",
         version