@effect/language-service 0.81.0 → 0.82.0

package/effect-lsp-patch-utils.js

@@ -5549,6 +5549,7 @@ var classSelfMismatch = createDiagnostic({
       if (ts.isClassDeclaration(node) && node.name && node.heritageClauses) {
         const result = yield* pipe(
           typeParser.extendsEffectService(node),
+          orElse2(() => typeParser.extendsServiceMapService(node)),
           orElse2(() => typeParser.extendsContextTag(node)),
           orElse2(() => typeParser.extendsEffectTag(node)),
           orElse2(() => typeParser.extendsSchemaClass(node)),
@@ -5924,6 +5925,89 @@ var effectFnIife = createDiagnostic({
   })
 });
 
+// src/diagnostics/effectFnImplicitAny.ts
+var getParameterName = (typescript, name) => {
+  if (typescript.isIdentifier(name)) {
+    return typescript.idText(name);
+  }
+  return "parameter";
+};
+var hasOuterContextualFunctionType = (typescript, typeChecker, node) => {
+  const contextualType = typeChecker.getContextualType(node);
+  if (!contextualType) {
+    return false;
+  }
+  return typeChecker.getSignaturesOfType(contextualType, typescript.SignatureKind.Call).length > 0;
+};
+var effectFnImplicitAny = createDiagnostic({
+  name: "effectFnImplicitAny",
+  code: 54,
+  description: "Mirrors noImplicitAny for unannotated Effect.fn and Effect.fnUntraced callback parameters when no outer contextual function type exists",
+  group: "correctness",
+  severity: "error",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
+  apply: fn("effectFnImplicitAny.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const program = yield* service(TypeScriptProgram);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
+    const noImplicitAny = program.getCompilerOptions().noImplicitAny ?? program.getCompilerOptions().strict ?? false;
+    if (!noImplicitAny) {
+      return;
+    }
+    const nodeToVisit = [sourceFile];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.pop();
+      ts.forEachChild(node, appendNodeToVisit);
+      const parsed = yield* pipe(
+        typeParser.effectFn(node),
+        map4((result) => ({
+          call: result.node,
+          fn: result.regularFunction
+        })),
+        orElse2(
+          () => pipe(
+            typeParser.effectFnGen(node),
+            map4((result) => ({
+              call: result.node,
+              fn: result.generatorFunction
+            }))
+          )
+        ),
+        orElse2(
+          () => pipe(
+            typeParser.effectFnUntracedGen(node),
+            map4((result) => ({
+              call: result.node,
+              fn: result.generatorFunction
+            }))
+          )
+        ),
+        orUndefined
+      );
+      if (!parsed || hasOuterContextualFunctionType(ts, typeChecker, parsed.call)) {
+        continue;
+      }
+      for (const parameter of parsed.fn.parameters) {
+        if (parameter.type || parameter.initializer) {
+          continue;
+        }
+        const parameterName = getParameterName(ts, parameter.name);
+        report({
+          location: parameter.name,
+          messageText: `Parameter '${parameterName}' implicitly has an 'any' type in Effect.fn/Effect.fnUntraced. Add an explicit type annotation or provide a contextual function type.`,
+          fixes: []
+        });
+      }
+    }
+  })
+});
+
 // src/diagnostics/effectFnOpportunity.ts
 var effectFnOpportunity = createDiagnostic({
   name: "effectFnOpportunity",
@@ -7458,6 +7542,24 @@ var leakingRequirements = createDiagnostic({
     const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const typeParser = yield* service(TypeParser);
     const tsUtils = yield* service(TypeScriptUtils);
+    const isExpectedLeakingServiceSuppressed = (leakedServiceName, startNode) => {
+      const sourceFile2 = tsUtils.getSourceFileOfNode(startNode);
+      if (!sourceFile2) return false;
+      return !!ts.findAncestor(startNode, (current) => {
+        const ranges = ts.getLeadingCommentRanges(sourceFile2.text, current.pos) ?? [];
+        const isSuppressed = ranges.some((range) => {
+          const commentText = sourceFile2.text.slice(range.pos, range.end);
+          return commentText.split("\n").filter((line) => line.includes("@effect-expect-leaking")).some((line) => {
+            const markerIndex = line.indexOf("@effect-expect-leaking");
+            return markerIndex !== -1 && line.slice(markerIndex + "@effect-expect-leaking".length).includes(leakedServiceName);
+          });
+        });
+        if (isSuppressed) {
+          return true;
+        }
+        return ts.isClassDeclaration(current) || ts.isVariableStatement(current) || ts.isExpressionStatement(current) || ts.isStatement(current) ? "quit" : false;
+      });
+    };
     const parseLeakedRequirements = cachedBy(
       fn("leakingServices.checkServiceLeaking")(
         function* (service2, atLocation) {
@@ -7539,8 +7641,12 @@ var leakingRequirements = createDiagnostic({
       (_, service2) => service2
     );
     function reportLeakingRequirements(node, requirements) {
-      if (requirements.length === 0) return;
-      const requirementsStr = requirements.map((_) => typeChecker.typeToString(_)).join(" | ");
+      const filteredRequirements = requirements.filter(
+        (requirement) => !isExpectedLeakingServiceSuppressed(typeChecker.typeToString(requirement), node)
+      );
+      if (filteredRequirements.length === 0) return;
+      const requirementsStr = filteredRequirements.map((_) => typeChecker.typeToString(_)).join(" | ");
+      const firstStr = typeChecker.typeToString(filteredRequirements[0]);
       report({
         location: node,
         messageText: `Methods of this Service require \`${requirementsStr}\` from every caller.
@@ -7549,7 +7655,7 @@ This leaks implementation details into the service's public type \u2014 callers
 
 Resolve these dependencies at Layer creation and provide them to each method, so the service's type reflects its purpose, not its implementation.
 
-To suppress this diagnostic for specific dependency types that are intentionally passed through (e.g., HttpServerRequest), add \`@effect-leakable-service\` JSDoc to their interface declarations (e.g., the \`${typeChecker.typeToString(requirements[0])}\` interface), not to this service.
+To suppress this diagnostic for specific dependency types that are intentionally passed through (e.g., HttpServerRequest), add \`@effect-leakable-service\` JSDoc to their interface declarations (e.g., the \`${firstStr}\` interface), or to this service by adding a \`@effect-expect-leaking ${firstStr}\` JSDoc.
 
 More info and examples at https://effect.website/docs/requirements-management/layers/#avoiding-requirement-leakage`,
         fixes: []
@@ -11870,6 +11976,7 @@ var diagnostics = [
   catchUnfailableEffect,
   classSelfMismatch,
   duplicatePackage,
+  effectFnImplicitAny,
   effectGenUsesAdapter,
   missingEffectContext,
   missingEffectError,