@effect/language-service 0.81.0 → 0.82.0

package/README.md

@@ -10,7 +10,9 @@ This package implements a TypeScript language service plugin that allows additio
 2. Inside your tsconfig.json, you should add the plugin configuration as follows:
 ```jsonc
 {
-  "$schema": "https://raw.githubusercontent.com/Effect-TS/language-service/refs/heads/main/schema.json",
+  "$schema": "./node_modules/@effect/language-service/schema.json",
+  // or from Github (may drift from your local installation)
+  // "$schema": ""https://raw.githubusercontent.com/Effect-TS/language-service/refs/heads/main/schema.json",
   "compilerOptions": {
     "plugins": [
       // ... other LSPs (if any) and as last
@@ -54,6 +56,7 @@ Some diagnostics are off by default or have a default severity of suggestion, bu
     <tr><td><code>anyUnknownInErrorContext</code></td><td>➖</td><td></td><td>Detects 'any' or 'unknown' types in Effect error or requirements channels</td><td>✓</td><td>✓</td></tr>
     <tr><td><code>classSelfMismatch</code></td><td>❌</td><td>🔧</td><td>Ensures Self type parameter matches the class name in Service/Tag/Schema classes</td><td>✓</td><td>✓</td></tr>
     <tr><td><code>duplicatePackage</code></td><td>⚠️</td><td></td><td>Detects when multiple versions of the same Effect package are loaded</td><td>✓</td><td>✓</td></tr>
+    <tr><td><code>effectFnImplicitAny</code></td><td>❌</td><td></td><td>Mirrors noImplicitAny for unannotated Effect.fn and Effect.fnUntraced callback parameters when no outer contextual function type exists</td><td>✓</td><td>✓</td></tr>
     <tr><td><code>floatingEffect</code></td><td>❌</td><td></td><td>Ensures Effects are yielded or assigned to variables, not left floating</td><td>✓</td><td>✓</td></tr>
     <tr><td><code>genericEffectServices</code></td><td>⚠️</td><td></td><td>Prevents services with type parameters that cannot be discriminated at runtime</td><td>✓</td><td>✓</td></tr>
     <tr><td><code>missingEffectContext</code></td><td>❌</td><td></td><td>Reports missing service requirements in Effect context channel</td><td>✓</td><td>✓</td></tr>

package/cli.js

@@ -25719,7 +25719,7 @@ var runWith2 = (command, config) => {
 // package.json
 var package_default = {
   name: "@effect/language-service",
-  version: "0.81.0",
+  version: "0.82.0",
   publishConfig: {
     access: "public",
     directory: "dist"
@@ -32076,6 +32076,7 @@ var classSelfMismatch = createDiagnostic({
       if (ts.isClassDeclaration(node) && node.name && node.heritageClauses) {
         const result3 = yield* pipe(
           typeParser.extendsEffectService(node),
+          orElse5(() => typeParser.extendsServiceMapService(node)),
           orElse5(() => typeParser.extendsContextTag(node)),
           orElse5(() => typeParser.extendsEffectTag(node)),
           orElse5(() => typeParser.extendsSchemaClass(node)),
@@ -32451,6 +32452,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: fn3("effectFnImplicitAny.apply")(function* (sourceFile, report) {
+    const ts = yield* service2(TypeScriptApi);
+    const program = yield* service2(TypeScriptProgram);
+    const typeChecker = yield* service2(TypeCheckerApi);
+    const typeParser = yield* service2(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),
+        map12((result3) => ({
+          call: result3.node,
+          fn: result3.regularFunction
+        })),
+        orElse5(
+          () => pipe(
+            typeParser.effectFnGen(node),
+            map12((result3) => ({
+              call: result3.node,
+              fn: result3.generatorFunction
+            }))
+          )
+        ),
+        orElse5(
+          () => pipe(
+            typeParser.effectFnUntracedGen(node),
+            map12((result3) => ({
+              call: result3.node,
+              fn: result3.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",
@@ -33985,6 +34069,24 @@ var leakingRequirements = createDiagnostic({
     const typeCheckerUtils = yield* service2(TypeCheckerUtils);
     const typeParser = yield* service2(TypeParser);
     const tsUtils = yield* service2(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((range2) => {
+          const commentText = sourceFile2.text.slice(range2.pos, range2.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(
       fn3("leakingServices.checkServiceLeaking")(
         function* (service3, atLocation) {
@@ -34066,8 +34168,12 @@ var leakingRequirements = createDiagnostic({
       (_, service3) => service3
     );
     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.
@@ -34076,7 +34182,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: []
@@ -37328,6 +37434,7 @@ var diagnostics = [
   catchUnfailableEffect,
   classSelfMismatch,
   duplicatePackage,
+  effectFnImplicitAny,
   effectGenUsesAdapter,
   missingEffectContext,
   missingEffectError,
@@ -37411,6 +37518,8 @@ var formatDiagnosticForJson = (diagnostic, tsInstance) => {
   const diagnosticName = Object.values(diagnostics).find((_) => _.code === diagnostic.code)?.name ?? `effect(${diagnostic.code})`;
   return {
     file: diagnostic.file.fileName,
+    start: diagnostic.start,
+    length: diagnostic.length ?? 0,
     line: line + 1,
     column: character + 1,
     endLine: endLine + 1,
@@ -40722,6 +40831,27 @@ var metadata_default = {
         diagnostics: []
       }
     },
+    {
+      name: "effectFnImplicitAny",
+      group: "correctness",
+      description: "Mirrors noImplicitAny for unannotated Effect.fn and Effect.fnUntraced callback parameters when no outer contextual function type exists",
+      defaultSeverity: "error",
+      fixable: false,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      preview: {
+        sourceText: 'import * as Effect from "effect/Effect"\n\nexport const preview = Effect.fn("preview")((input) => Effect.succeed(input))\n',
+        diagnostics: [
+          {
+            start: 86,
+            end: 91,
+            text: "Parameter 'input' implicitly has an 'any' type in Effect.fn/Effect.fnUntraced. Add an explicit type annotation or provide a contextual function type.    effect(effectFnImplicitAny)"
+          }
+        ]
+      }
+    },
     {
       name: "floatingEffect",
       group: "correctness",
@@ -41171,7 +41301,7 @@ var metadata_default = {
           {
             start: 212,
             end: 217,
-            text: "Methods of this Service require `FileSystem` from every caller.\n\nThis leaks implementation details into the service's public type \u2014 callers shouldn't need to know *how* the service works internally, only *what* it provides.\n\nResolve these dependencies at Layer creation and provide them to each method, so the service's type reflects its purpose, not its implementation.\n\nTo 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 `FileSystem` interface), not to this service.\n\nMore info and examples at https://effect.website/docs/requirements-management/layers/#avoiding-requirement-leakage    effect(leakingRequirements)"
+            text: "Methods of this Service require `FileSystem` from every caller.\n\nThis leaks implementation details into the service's public type \u2014 callers shouldn't need to know *how* the service works internally, only *what* it provides.\n\nResolve these dependencies at Layer creation and provide them to each method, so the service's type reflects its purpose, not its implementation.\n\nTo 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 `FileSystem` interface), or to this service by adding a `@effect-expect-leaking FileSystem` JSDoc.\n\nMore info and examples at https://effect.website/docs/requirements-management/layers/#avoiding-requirement-leakage    effect(leakingRequirements)"
           }
         ]
       }