@effect/language-service 0.74.0 → 0.75.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect/language-service",
-  "version": "0.74.0",
+  "version": "0.75.1",
   "description": "A Language-Service Plugin to Refactor and Diagnostic effect-ts projects",
   "main": "index.cjs",
   "bin": {

package/transform.js

@@ -849,6 +849,7 @@ var dedupe = (self) => dedupeWith(self, equivalence());
 var join = /* @__PURE__ */ dual(2, (self, sep) => fromIterable(self).join(sep));
 
 // src/core/Nano.ts
+var debugPerformance = false;
 var NanoTag = class {
   constructor(key) {
     this.key = key;
@@ -946,7 +947,6 @@ var NanoFiber = class {
   _yielded = void 0;
   _services = {};
   _cache = {};
-  _perf = false;
   _lastSpan = "";
   runLoop(nano) {
     let current = nano;
@@ -977,7 +977,7 @@ var WithSpanProto = {
   ...PrimitiveProto,
   [evaluate](fiber) {
     const [fa, name] = this[args];
-    if (!fiber._perf) return fa;
+    if (!debugPerformance) return fa;
     const previousSpan = fiber._lastSpan;
     fiber._lastSpan = name;
     const start = performance.now();
@@ -1920,6 +1920,26 @@ var getApplicableRefactors = fn("LSP.getApplicableRefactors")(function* (refacto
   }
   return effectRefactors;
 });
+function codeFixNameToFullyQualifiedName(name) {
+  return `@effect/language-service/codefixes/${name}`;
+}
+var codeFixesToApplicableRefactor = fn("LSP.codeFixesToApplicableRefactor")(function* (codeFixes, sourceFile, positionOrRange) {
+  const effectRefactors = [];
+  const range = typeof positionOrRange === "number" ? { pos: positionOrRange, end: positionOrRange } : positionOrRange;
+  const inRangeCodeFixes = codeFixes.filter((_) => _.start <= range.pos && _.end >= range.end);
+  for (const codeFix of inRangeCodeFixes) {
+    effectRefactors.push({
+      name: codeFixNameToFullyQualifiedName(codeFix.fixName),
+      description: "Quick Fix: " + codeFix.description,
+      actions: [{
+        name: codeFixNameToFullyQualifiedName(codeFix.fixName),
+        description: "Quick Fix: " + codeFix.description,
+        kind: "refactor.rewrite.codeFixEffect." + codeFix.fixName
+      }]
+    });
+  }
+  return effectRefactors;
+});
 var getEditsForRefactor = fn("LSP.getEditsForRefactor")(function* (refactors, sourceFile, positionOrRange, refactorName) {
   const refactor = refactors.find((refactor2) => refactorNameToFullyQualifiedName(refactor2.name) === refactorName);
   if (!refactor) {
@@ -1928,6 +1948,16 @@ var getEditsForRefactor = fn("LSP.getEditsForRefactor")(function* (refactors, so
   const textRange = typeof positionOrRange === "number" ? { pos: positionOrRange, end: positionOrRange } : positionOrRange;
   return yield* refactor.apply(sourceFile, textRange);
 });
+var getEditsForCodeFixes = fn("LSP.getEditsForCodeFixes")(function* (codeFixes, positionOrRange, refactorName) {
+  const textRange = typeof positionOrRange === "number" ? { pos: positionOrRange, end: positionOrRange } : positionOrRange;
+  const fixToRun = codeFixes.find(
+    (_) => codeFixNameToFullyQualifiedName(_.fixName) === refactorName && _.start <= textRange.pos && _.end >= textRange.end
+  );
+  if (!fixToRun) {
+    return yield* fail(new RefactorNotApplicableError());
+  }
+  return fixToRun;
+});
 var getCompletionsAtPosition = fn("LSP.getCompletionsAtPosition")(function* (completions, sourceFile, position, options, formatCodeSettings) {
   let effectCompletions = [];
   for (const completion of completions) {
@@ -2011,7 +2041,7 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
       message: ts.DiagnosticCategory.Message,
       suggestion: ts.DiagnosticCategory.Suggestion
     };
-    const execute = (rule) => gen(function* () {
+    const execute = fn("LSP.execute")(function* (rule) {
       const diagnostics2 = [];
       const codeFixes = [];
       const ruleNameLowered = rule.name.toLowerCase();
@@ -2792,6 +2822,9 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     if (signatures.length !== 1) {
       return typeParserIssue("Covariant type has no call signature", type);
     }
+    if (signatures[0].typeParameters && signatures[0].typeParameters.length > 0) {
+      return typeParserIssue("Invariant type should not have type parameters", type);
+    }
     return succeed(typeChecker.getReturnTypeOfSignature(signatures[0]));
   }
   function contravariantTypeArgument(type) {
@@ -2799,6 +2832,9 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     if (signatures.length !== 1) {
       return typeParserIssue("Contravariant type has no call signature", type);
     }
+    if (signatures[0].typeParameters && signatures[0].typeParameters.length > 0) {
+      return typeParserIssue("Invariant type should not have type parameters", type);
+    }
     return succeed(typeCheckerUtils.getTypeParameterAtPosition(signatures[0], 0));
   }
   function invariantTypeArgument(type) {
@@ -2806,6 +2842,9 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     if (signatures.length !== 1) {
       return typeParserIssue("Invariant type has no call signature", type);
     }
+    if (signatures[0].typeParameters && signatures[0].typeParameters.length > 0) {
+      return typeParserIssue("Invariant type should not have type parameters", type);
+    }
     return succeed(typeChecker.getReturnTypeOfSignature(signatures[0]));
   }
   const pipeableType = cachedBy(
@@ -4693,32 +4732,38 @@ var catchAllToMapError = createDiagnostic({
       return void 0;
     };
     const getEffectFailCallInfo = (body) => {
-      return gen(function* () {
-        if (ts.isCallExpression(body)) {
-          const isFailCall = yield* pipe(
-            typeParser.isNodeReferenceToEffectModuleApi("fail")(body.expression),
-            orUndefined
-          );
-          if (isFailCall && body.arguments.length >= 1) {
-            return { failCall: body, failArg: body.arguments[0] };
-          }
-        }
-        if (ts.isBlock(body)) {
-          const statements = body.statements;
-          if (statements.length === 1) {
-            const stmt = statements[0];
-            if (ts.isReturnStatement(stmt) && stmt.expression && ts.isCallExpression(stmt.expression)) {
-              const isFailCall = yield* pipe(
-                typeParser.isNodeReferenceToEffectModuleApi("fail")(stmt.expression.expression),
-                orUndefined
-              );
-              if (isFailCall && stmt.expression.arguments.length >= 1) {
-                return { failCall: stmt.expression, failArg: stmt.expression.arguments[0] };
-              }
+      if (ts.isCallExpression(body)) {
+        return pipe(
+          typeParser.isNodeReferenceToEffectModuleApi("fail")(body.expression),
+          orUndefined,
+          map4((isFailCall) => {
+            if (isFailCall && body.arguments.length >= 1) {
+              return { failCall: body, failArg: body.arguments[0] };
             }
+            return void 0;
+          })
+        );
+      }
+      if (ts.isBlock(body)) {
+        const statements = body.statements;
+        if (statements.length === 1) {
+          const stmt = statements[0];
+          if (ts.isReturnStatement(stmt) && stmt.expression && ts.isCallExpression(stmt.expression)) {
+            const callExpr = stmt.expression;
+            return pipe(
+              typeParser.isNodeReferenceToEffectModuleApi("fail")(callExpr.expression),
+              orUndefined,
+              map4((isFailCall) => {
+                if (isFailCall && callExpr.arguments.length >= 1) {
+                  return { failCall: callExpr, failArg: callExpr.arguments[0] };
+                }
+                return void 0;
+              })
+            );
           }
         }
-      });
+      }
+      return void_;
     };
     const flows = yield* typeParser.pipingFlows(true)(sourceFile);
     for (const flow2 of flows) {
@@ -4963,20 +5008,21 @@ var deterministicKeys = createDiagnostic({
     const typeScriptUtils = yield* service(TypeScriptUtils);
     const options = yield* service(LanguageServicePluginOptions);
     const parseExtendsCustom = cachedBy(
-      fn("parseExtendsCustom")(function* (classDeclaration) {
+      (classDeclaration) => {
         if (!options.extendedKeyDetection) {
-          return yield* typeParserIssue("Extended key detection is disabled", void 0, classDeclaration);
+          return TypeParserIssue.issue;
         }
         if (!classDeclaration.name) {
-          return yield* typeParserIssue("Class has no name", void 0, classDeclaration);
+          return TypeParserIssue.issue;
         }
         if (!ts.isIdentifier(classDeclaration.name)) {
-          return yield* typeParserIssue("Class name is not an identifier", void 0, classDeclaration);
+          return TypeParserIssue.issue;
         }
         const heritageClauses = classDeclaration.heritageClauses;
         if (!heritageClauses) {
-          return yield* typeParserIssue("Class has no heritage clauses", void 0, classDeclaration);
+          return TypeParserIssue.issue;
         }
+        const className = classDeclaration.name;
         const nodeToVisit2 = [...classDeclaration.heritageClauses];
         const appendNodeToVisit2 = (node) => {
           nodeToVisit2.push(node);
@@ -4997,7 +5043,7 @@ var deterministicKeys = createDiagnostic({
                     const parameterSourceFile = typeScriptUtils.getSourceFileOfNode(declaration);
                     const paramText = parameterSourceFile.text.substring(declaration.pos, declaration.end);
                     if (paramText.toLowerCase().includes("@effect-identifier")) {
-                      return { className: classDeclaration.name, keyStringLiteral: arg, target: "custom" };
+                      return succeed({ className, keyStringLiteral: arg, target: "custom" });
                     }
                   }
                 }
@@ -5006,12 +5052,8 @@ var deterministicKeys = createDiagnostic({
           }
           ts.forEachChild(node, appendNodeToVisit2);
         }
-        return yield* typeParserIssue(
-          "Class does not extend any custom pattern",
-          void 0,
-          classDeclaration
-        );
-      }),
+        return TypeParserIssue.issue;
+      },
       "deterministicKeys.parseExtendsCustom",
       (classDeclaration) => classDeclaration
     );
@@ -5290,7 +5332,7 @@ var effectFnOpportunity = createDiagnostic({
       }
       return false;
     };
-    const tryExtractWithSpanExpression = (expr) => gen(function* () {
+    const tryExtractWithSpanExpression = fn("effectFnOpportunity.tryExtractWithSpanExpression")(function* (expr) {
       if (!ts.isCallExpression(expr)) return void 0;
       const callee = expr.expression;
       const isWithSpan = yield* pipe(
@@ -5302,7 +5344,9 @@ var effectFnOpportunity = createDiagnostic({
       if (expr.arguments.length === 0) return void 0;
       return expr.arguments[0];
     });
-    const tryParseGenOpportunity = (fnNode) => gen(function* () {
+    const tryParseGenOpportunity = fn(
+      "effectFnOpportunity.tryParseGenOpportunity"
+    )(function* (fnNode) {
       const bodyExpression = getBodyExpression(fnNode);
       if (!bodyExpression) return yield* TypeParserIssue.issue;
       const { pipeArguments: pipeArguments2, subject } = yield* pipe(
@@ -5338,62 +5382,67 @@ var effectFnOpportunity = createDiagnostic({
         orElse2(() => succeed(false))
       );
     };
-    const parseEffectFnOpportunityTarget = (node) => gen(function* () {
+    const parseEffectFnOpportunityTargetGen = fn("effectFnOpportunity.parseEffectFnOpportunityTarget")(
+      function* (node, returnType, traceName, nameIdentifier) {
+        if (yield* isInsideEffectFn(node)) {
+          return yield* TypeParserIssue.issue;
+        }
+        const unionMembers = typeCheckerUtils.unrollUnionMembers(returnType);
+        yield* all(...unionMembers.map((member) => typeParser.strictEffectType(member, node)));
+        const opportunity = yield* pipe(
+          tryParseGenOpportunity(node),
+          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,
+              explicitTraceExpression: void 0
+            });
+          })
+        );
+        return {
+          node,
+          nameIdentifier,
+          effectModuleName: opportunity.effectModuleName,
+          inferredTraceName: traceName,
+          explicitTraceExpression: opportunity.explicitTraceExpression,
+          pipeArguments: opportunity.pipeArguments,
+          generatorFunction: opportunity.generatorFunction,
+          hasParamsInPipeArgs: areParametersReferencedIn(node, opportunity.pipeArguments)
+        };
+      }
+    );
+    const parseEffectFnOpportunityTarget = (node) => {
       if (!ts.isFunctionExpression(node) && !ts.isArrowFunction(node) && !ts.isFunctionDeclaration(node)) {
-        return yield* TypeParserIssue.issue;
+        return TypeParserIssue.issue;
       }
       if ((ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node)) && node.asteriskToken) {
-        return yield* TypeParserIssue.issue;
+        return TypeParserIssue.issue;
       }
       if (ts.isFunctionExpression(node) && node.name) {
-        return yield* TypeParserIssue.issue;
+        return TypeParserIssue.issue;
       }
       if (node.type) {
-        return yield* TypeParserIssue.issue;
-      }
-      if (yield* isInsideEffectFn(node)) {
-        return yield* TypeParserIssue.issue;
+        return TypeParserIssue.issue;
       }
       const functionType = typeChecker.getTypeAtLocation(node);
-      if (!functionType) return yield* TypeParserIssue.issue;
+      if (!functionType) return TypeParserIssue.issue;
       const callSignatures = typeChecker.getSignaturesOfType(functionType, ts.SignatureKind.Call);
-      if (callSignatures.length !== 1) return yield* TypeParserIssue.issue;
+      if (callSignatures.length !== 1) return TypeParserIssue.issue;
       const signature = callSignatures[0];
       const returnType = typeChecker.getReturnTypeOfSignature(signature);
-      const unionMembers = typeCheckerUtils.unrollUnionMembers(returnType);
-      yield* all(...unionMembers.map((member) => typeParser.strictEffectType(member, node)));
       const nameIdentifier = getNameIdentifier(node);
       const traceName = nameIdentifier ? ts.isIdentifier(nameIdentifier) ? ts.idText(nameIdentifier) : nameIdentifier.text : void 0;
-      if (!traceName) return yield* TypeParserIssue.issue;
-      const opportunity = yield* pipe(
-        tryParseGenOpportunity(node),
-        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,
-            explicitTraceExpression: void 0
-          });
-        })
-      );
-      return {
-        node,
-        nameIdentifier,
-        effectModuleName: opportunity.effectModuleName,
-        inferredTraceName: traceName,
-        explicitTraceExpression: opportunity.explicitTraceExpression,
-        pipeArguments: opportunity.pipeArguments,
-        generatorFunction: opportunity.generatorFunction,
-        hasParamsInPipeArgs: areParametersReferencedIn(node, opportunity.pipeArguments)
-      };
-    });
+      if (!traceName) return TypeParserIssue.issue;
+      return parseEffectFnOpportunityTargetGen(node, returnType, traceName, nameIdentifier);
+    };
     const getFunctionBodyBlock = (node) => {
       if (ts.isArrowFunction(node)) {
         if (ts.isBlock(node.body)) {
@@ -5634,7 +5683,7 @@ var effectInVoidSuccess = createDiagnostic({
         );
         return { voidedEffect };
       }
-      return yield* fail(typeParserIssue("expectedEffect success is not void"));
+      return yield* TypeParserIssue.issue;
     });
     const entries = typeCheckerUtils.expectedAndRealType(sourceFile);
     for (const [node, expectedType, valueNode, realType] of entries) {
@@ -7446,25 +7495,27 @@ var generate = fn("writeTagClassAccessors.generate")(function* (sourceFile, serv
       return succeed(typeNode);
     })
   );
-  const proxySignature = (signature, atLocation2, className2) => gen(function* () {
-    const signatureDeclaration = typeChecker.signatureToSignatureDeclaration(
-      signature,
-      ts.SyntaxKind.FunctionType,
-      atLocation2,
-      ts.NodeBuilderFlags.NoTruncation
-    );
-    if (!signatureDeclaration) return yield* fail("error generating signature");
-    const returnType = yield* generateReturnType(
-      typeChecker.getReturnTypeOfSignature(signature),
-      atLocation2,
-      className2
-    );
-    return ts.factory.createFunctionTypeNode(
-      signatureDeclaration.typeParameters,
-      signatureDeclaration.parameters,
-      returnType
-    );
-  });
+  const proxySignature = fn("writeTagClassAccessors.proxySignature")(
+    function* (signature, atLocation2, className2) {
+      const signatureDeclaration = typeChecker.signatureToSignatureDeclaration(
+        signature,
+        ts.SyntaxKind.FunctionType,
+        atLocation2,
+        ts.NodeBuilderFlags.NoTruncation
+      );
+      if (!signatureDeclaration) return yield* fail("error generating signature");
+      const returnType = yield* generateReturnType(
+        typeChecker.getReturnTypeOfSignature(signature),
+        atLocation2,
+        className2
+      );
+      return ts.factory.createFunctionTypeNode(
+        signatureDeclaration.typeParameters,
+        signatureDeclaration.parameters,
+        returnType
+      );
+    }
+  );
   for (const { property, propertyType } of involvedMembers) {
     const callSignatures = [];
     let propertyDeclaration = void 0;
@@ -7601,7 +7652,7 @@ var annotate = createCodegen({
     const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeCheckerUtils = yield* service(TypeCheckerUtils);
-    const parse3 = (node) => gen(function* () {
+    const parse3 = fn("annotate.parse")(function* (node) {
       let variableDeclarations = [];
       const result = [];
       if (ts.isVariableStatement(node)) {
@@ -8281,7 +8332,7 @@ var typeToSchema = createCodegen({
         new CodegenNotApplicableError("the typeToSchema codegen can be used only once per file")
       );
     }
-    const parse3 = (node) => gen(function* () {
+    const parse3 = fn("typeToSchema.parse")(function* (node) {
       if (!ts.isTypeAliasDeclaration(node)) {
         return yield* fail(
           new CodegenNotApplicableError(
@@ -8558,73 +8609,99 @@ var preferSchemaOverJson = createDiagnostic({
   apply: fn("preferSchemaOverJson.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
-    const parseJsonMethod = (node) => gen(function* () {
-      if (!ts.isCallExpression(node)) return yield* fail("node is not a call expression");
-      const expression = node.expression;
-      if (!ts.isPropertyAccessExpression(expression)) return yield* fail("expression is not a property access");
-      const objectExpr = expression.expression;
-      const methodName = ts.idText(expression.name);
-      if (!ts.isIdentifier(objectExpr) || ts.idText(objectExpr) !== "JSON") {
-        return yield* fail("object is not JSON");
+    const isJsonCall = (node) => ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression) && ts.idText(node.expression.expression) === "JSON" && (ts.idText(node.expression.name) === "parse" || ts.idText(node.expression.name) === "stringify");
+    const findEnclosingEffectTry = (jsonCall) => {
+      const parent = jsonCall.parent;
+      let lazy;
+      if (ts.isArrowFunction(parent) && parent.body === jsonCall && parent.parameters.length === 0 && (!parent.typeParameters || parent.typeParameters.length === 0)) {
+        lazy = parent;
+      }
+      if (!lazy && ts.isReturnStatement(parent) && parent.expression === jsonCall) {
+        const block = parent.parent;
+        if (ts.isBlock(block) && block.statements.length === 1) {
+          const fn2 = block.parent;
+          if ((ts.isArrowFunction(fn2) || ts.isFunctionExpression(fn2)) && fn2.parameters.length === 0 && (!fn2.typeParameters || fn2.typeParameters.length === 0)) {
+            lazy = fn2;
+          }
+        }
       }
-      if (methodName !== "parse" && methodName !== "stringify") {
-        return yield* fail("method is not parse or stringify");
+      if (!lazy) return void 0;
+      const lazyParent = lazy.parent;
+      if (ts.isCallExpression(lazyParent) && lazyParent.arguments.length > 0 && lazyParent.arguments[0] === lazy) {
+        return lazyParent;
       }
-      return { node, methodName };
-    });
-    const effectTrySimple = (node) => gen(function* () {
-      if (!ts.isCallExpression(node)) return yield* fail("node is not a call expression");
+      if (ts.isPropertyAssignment(lazyParent) && ts.isIdentifier(lazyParent.name) && ts.idText(lazyParent.name) === "try") {
+        const objLiteral = lazyParent.parent;
+        if (ts.isObjectLiteralExpression(objLiteral)) {
+          const callExpr = objLiteral.parent;
+          if (ts.isCallExpression(callExpr) && callExpr.arguments.length > 0 && callExpr.arguments[0] === objLiteral) {
+            return callExpr;
+          }
+        }
+      }
+      return void 0;
+    };
+    const jsonCalls = [];
+    const collectJsonCalls = (node) => {
+      if (isJsonCall(node)) {
+        jsonCalls.push(node);
+      }
+      ts.forEachChild(node, collectJsonCalls);
+    };
+    ts.forEachChild(sourceFile, collectJsonCalls);
+    if (jsonCalls.length === 0) return;
+    const effectTrySimple = fn("preferSchemaOverJson.effectTrySimple")(function* (node) {
       yield* typeParser.isNodeReferenceToEffectModuleApi("try")(node.expression);
-      if (node.arguments.length === 0) return yield* fail("Effect.try has no arguments");
+      if (node.arguments.length === 0) return yield* TypeParserIssue.issue;
       const lazyFn = yield* typeParser.lazyExpression(node.arguments[0]);
-      const jsonMethod = yield* parseJsonMethod(lazyFn.expression);
-      return { node: jsonMethod.node, methodName: jsonMethod.methodName };
+      if (!isJsonCall(lazyFn.expression)) return yield* TypeParserIssue.issue;
+      return lazyFn.expression;
     });
-    const effectTryObject = (node) => gen(function* () {
-      if (!ts.isCallExpression(node)) return yield* fail("node is not a call expression");
+    const effectTryObject = fn("preferSchemaOverJson.effectTryObject")(function* (node) {
       yield* typeParser.isNodeReferenceToEffectModuleApi("try")(node.expression);
-      if (node.arguments.length === 0) return yield* fail("Effect.try has no arguments");
+      if (node.arguments.length === 0) return yield* TypeParserIssue.issue;
       const arg = node.arguments[0];
-      if (!ts.isObjectLiteralExpression(arg)) return yield* fail("argument is not an object literal");
+      if (!ts.isObjectLiteralExpression(arg)) return yield* TypeParserIssue.issue;
       const tryProp = arg.properties.find(
         (p) => ts.isPropertyAssignment(p) && ts.isIdentifier(p.name) && ts.idText(p.name) === "try"
       );
-      if (!tryProp) return yield* fail("object has no 'try' property");
+      if (!tryProp) return yield* TypeParserIssue.issue;
       const lazyFn = yield* typeParser.lazyExpression(tryProp.initializer);
-      const jsonMethod = yield* parseJsonMethod(lazyFn.expression);
-      return { node: jsonMethod.node, methodName: jsonMethod.methodName };
+      if (!isJsonCall(lazyFn.expression)) return yield* TypeParserIssue.issue;
+      return lazyFn.expression;
     });
-    const jsonMethodInEffectGen = (node) => gen(function* () {
-      const jsonMethod = yield* parseJsonMethod(node);
-      const { effectGen, scopeNode } = yield* typeParser.findEnclosingScopes(node);
-      if (!effectGen || effectGen.body.statements.length === 0) {
-        return yield* fail("not inside an Effect generator");
+    const jsonMethodInEffectGen = fn("preferSchemaOverJson.jsonMethodInEffectGen")(
+      function* (jsonCall) {
+        const { effectGen, scopeNode } = yield* typeParser.findEnclosingScopes(jsonCall);
+        if (!effectGen || effectGen.body.statements.length === 0) {
+          return yield* TypeParserIssue.issue;
+        }
+        if (scopeNode && scopeNode !== effectGen.generatorFunction) {
+          return yield* TypeParserIssue.issue;
+        }
+        return jsonCall;
       }
-      if (scopeNode && scopeNode !== effectGen.generatorFunction) {
-        return yield* fail("inside a nested function scope");
+    );
+    for (const jsonCall of jsonCalls) {
+      const effectTryCall = findEnclosingEffectTry(jsonCall);
+      let match2;
+      if (effectTryCall) {
+        match2 = yield* pipe(
+          firstSuccessOf([
+            effectTrySimple(effectTryCall),
+            effectTryObject(effectTryCall)
+          ]),
+          option
+        );
+      } else {
+        match2 = yield* pipe(
+          jsonMethodInEffectGen(jsonCall),
+          option
+        );
       }
-      return { node: jsonMethod.node, methodName: jsonMethod.methodName };
-    });
-    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);
-      const match2 = yield* pipe(
-        firstSuccessOf([
-          effectTrySimple(node),
-          effectTryObject(node),
-          jsonMethodInEffectGen(node)
-        ]),
-        option
-      );
       if (isSome2(match2)) {
         report({
-          location: match2.value.node,
+          location: match2.value,
           messageText: "Consider using Effect Schema for JSON operations instead of JSON.parse/JSON.stringify",
           fixes: []
         });
@@ -9268,19 +9345,24 @@ var strictEffectProvide = createDiagnostic({
     const ts = yield* service(TypeScriptApi);
     const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const typeParser = yield* service(TypeParser);
-    const parseEffectProvideWithLayer = (node) => gen(function* () {
+    const parseEffectProvideWithLayerGen = fn("strictEffectProvide.parseEffectProvideWithLayer")(
+      function* (node) {
+        yield* typeParser.isNodeReferenceToEffectModuleApi("provide")(node.expression);
+        return yield* firstSuccessOf(
+          node.arguments.map((arg) => {
+            const argType = typeCheckerUtils.getTypeAtLocation(arg);
+            if (!argType) return typeParserIssue("Could not get argument type");
+            return typeParser.layerType(argType, arg);
+          })
+        );
+      }
+    );
+    const parseEffectProvideWithLayer = (node) => {
       if (!ts.isCallExpression(node) || node.arguments.length === 0) {
-        return yield* typeParserIssue("Not an Effect.provide call");
-      }
-      yield* typeParser.isNodeReferenceToEffectModuleApi("provide")(node.expression);
-      return yield* firstSuccessOf(
-        node.arguments.map((arg) => {
-          const argType = typeCheckerUtils.getTypeAtLocation(arg);
-          if (!argType) return typeParserIssue("Could not get argument type");
-          return typeParser.layerType(argType, arg);
-        })
-      );
-    });
+        return TypeParserIssue.issue;
+      }
+      return parseEffectProvideWithLayerGen(node);
+    };
     const nodeToVisit = [];
     const appendNodeToVisit = (node) => {
       nodeToVisit.push(node);