@effect/language-service 0.67.0 → 0.69.0

package/effect-lsp-patch-utils.js

@@ -4855,6 +4855,104 @@ ${versions.map((version) => `- found ${version} at ${resolvedPackages[packageNam
   })
 });
 
+// src/diagnostics/effectFnIife.ts
+var effectFnIife = createDiagnostic({
+  name: "effectFnIife",
+  code: 46,
+  description: "Effect.fn or Effect.fnUntraced is called as an IIFE (Immediately Invoked Function Expression). Use Effect.gen instead.",
+  severity: "warning",
+  apply: fn("effectFnIife.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
+    const tsUtils = yield* service(TypeScriptUtils);
+    const sourceEffectModuleName = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+      sourceFile,
+      "effect",
+      "Effect"
+    ) || "Effect";
+    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)) continue;
+      const innerCall = node.expression;
+      if (!ts.isCallExpression(innerCall)) continue;
+      const parsed = yield* pipe(
+        typeParser.effectFnGen(innerCall),
+        map4((result) => ({
+          kind: "fn",
+          effectModule: result.effectModule,
+          generatorFunction: result.generatorFunction,
+          pipeArguments: result.pipeArguments
+        })),
+        orElse2(
+          () => pipe(
+            typeParser.effectFnUntracedGen(innerCall),
+            map4((result) => ({
+              kind: "fnUntraced",
+              effectModule: result.effectModule,
+              generatorFunction: result.generatorFunction,
+              pipeArguments: result.pipeArguments
+            }))
+          )
+        ),
+        orElse2(
+          () => pipe(
+            typeParser.effectFn(innerCall),
+            map4((result) => ({
+              kind: "fn",
+              effectModule: result.effectModule,
+              generatorFunction: void 0,
+              pipeArguments: result.pipeArguments
+            }))
+          )
+        ),
+        option
+      );
+      if (isNone2(parsed)) continue;
+      const { effectModule, generatorFunction, kind, pipeArguments: pipeArguments2 } = parsed.value;
+      const effectModuleName = ts.isIdentifier(effectModule) ? ts.idText(effectModule) : sourceEffectModuleName;
+      const fixes = [];
+      if (generatorFunction && generatorFunction.parameters.length === 0) {
+        fixes.push({
+          fixName: "effectFnIife_toEffectGen",
+          description: "Convert to Effect.gen",
+          apply: gen(function* () {
+            const changeTracker = yield* service(ChangeTracker);
+            const effectGenCall = ts.factory.createCallExpression(
+              ts.factory.createPropertyAccessExpression(
+                ts.factory.createIdentifier(effectModuleName),
+                "gen"
+              ),
+              void 0,
+              [generatorFunction]
+            );
+            let replacementNode = effectGenCall;
+            if (pipeArguments2.length > 0) {
+              replacementNode = ts.factory.createCallExpression(
+                ts.factory.createPropertyAccessExpression(effectGenCall, "pipe"),
+                void 0,
+                [...pipeArguments2]
+              );
+            }
+            changeTracker.replaceNode(sourceFile, node, replacementNode);
+          })
+        });
+      }
+      report({
+        location: node,
+        messageText: `${effectModuleName}.${kind} returns a reusable function that can take arguments, but here it's called immediately. Use Effect.gen instead (optionally with Effect.withSpan for tracing).`,
+        fixes
+      });
+    }
+  })
+});
+
 // src/diagnostics/effectFnOpportunity.ts
 var effectFnOpportunity = createDiagnostic({
   name: "effectFnOpportunity",
@@ -5622,6 +5720,69 @@ var importFromBarrel = createDiagnostic({
   })
 });
 
+// src/diagnostics/instanceOfSchema.ts
+var instanceOfSchema = createDiagnostic({
+  name: "instanceOfSchema",
+  code: 45,
+  description: "Suggests using Schema.is instead of instanceof for Effect Schema types",
+  severity: "off",
+  apply: fn("instanceOfSchema.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.InstanceOfKeyword) {
+        const leftExpr = node.left;
+        const rightExpr = node.right;
+        const rightType = typeCheckerUtils.getTypeAtLocation(rightExpr);
+        if (!rightType) {
+          ts.forEachChild(node, appendNodeToVisit);
+          continue;
+        }
+        const isSchemaType = yield* pipe(
+          typeParser.effectSchemaType(rightType, rightExpr),
+          option
+        );
+        if (isSchemaType._tag === "Some") {
+          report({
+            location: node,
+            messageText: "Consider using Schema.is instead of instanceof for Effect Schema types.",
+            fixes: [{
+              fixName: "instanceOfSchema_fix",
+              description: "Replace with Schema.is",
+              apply: gen(function* () {
+                const changeTracker = yield* service(ChangeTracker);
+                const schemaIsCall = ts.factory.createCallExpression(
+                  ts.factory.createPropertyAccessExpression(
+                    ts.factory.createIdentifier("Schema"),
+                    "is"
+                  ),
+                  void 0,
+                  [rightExpr]
+                );
+                const fullCall = ts.factory.createCallExpression(
+                  schemaIsCall,
+                  void 0,
+                  [leftExpr]
+                );
+                changeTracker.replaceNode(sourceFile, node, fullCall);
+              })
+            }]
+          });
+        }
+      }
+      ts.forEachChild(node, appendNodeToVisit);
+    }
+  })
+});
+
 // src/diagnostics/layerMergeAllWithDependencies.ts
 var layerMergeAllWithDependencies = createDiagnostic({
   name: "layerMergeAllWithDependencies",
@@ -5829,12 +5990,18 @@ var leakingRequirements = createDiagnostic({
     );
     function reportLeakingRequirements(node, requirements) {
       if (requirements.length === 0) return;
+      const requirementsStr = requirements.map((_) => typeChecker.typeToString(_)).join(" | ");
       report({
         location: node,
-        messageText: `This Service is leaking the ${requirements.map((_) => typeChecker.typeToString(_)).join(" | ")} requirement.
-If these requirements cannot be cached and are expected to be provided per method invocation (e.g. HttpServerRequest), you can either safely disable this diagnostic for this line through quickfixes or mark the service declaration with a JSDoc @effect-leakable-service.
-Services should usually be collected in the layer creation body, and then provided at each method that requires them.
-More info at https://effect.website/docs/requirements-management/layers/#avoiding-requirement-leakage`,
+        messageText: `Methods of this Service require \`${requirementsStr}\` from every caller.
+
+This 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.
+
+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.
+
+More info and examples at https://effect.website/docs/requirements-management/layers/#avoiding-requirement-leakage`,
         fixes: []
       });
     }
@@ -9045,6 +9212,7 @@ var unsupportedServiceAccessors = createDiagnostic({
 // src/diagnostics.ts
 var diagnostics = [
   anyUnknownInErrorContext,
+  instanceOfSchema,
   catchAllToMapError,
   catchUnfailableEffect,
   classSelfMismatch,
@@ -9085,6 +9253,7 @@ var diagnostics = [
   globalErrorInEffectFailure,
   layerMergeAllWithDependencies,
   effectMapVoid,
+  effectFnIife,
   effectFnOpportunity,
   redundantSchemaTagIdentifier,
   schemaSyncInEffect,