@effect/language-service 0.66.1 → 0.68.0

package/effect-lsp-patch-utils.js

@@ -4997,9 +4997,20 @@ var effectFnOpportunity = createDiagnostic({
       if (!traceName) return yield* TypeParserIssue.issue;
       const opportunity = yield* pipe(
         tryParseGenOpportunity(node),
-        orElse2(
-          () => succeed({ effectModuleName: sourceEffectModuleName, pipeArguments: [], generatorFunction: void 0 })
-        )
+        orElse2(() => {
+          if (ts.isArrowFunction(node) && !ts.isBlock(node.body)) {
+            return TypeParserIssue.issue;
+          }
+          const body = ts.isArrowFunction(node) ? node.body : node.body;
+          if (!body || !ts.isBlock(body) || body.statements.length <= 5) {
+            return TypeParserIssue.issue;
+          }
+          return succeed({
+            effectModuleName: sourceEffectModuleName,
+            pipeArguments: [],
+            generatorFunction: void 0
+          });
+        })
       );
       return {
         node,
@@ -5611,6 +5622,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",
@@ -5818,12 +5892,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: []
       });
     }
@@ -9034,6 +9114,7 @@ var unsupportedServiceAccessors = createDiagnostic({
 // src/diagnostics.ts
 var diagnostics = [
   anyUnknownInErrorContext,
+  instanceOfSchema,
   catchAllToMapError,
   catchUnfailableEffect,
   classSelfMismatch,