@effect/language-service 0.75.0 → 0.75.1

package/index.js

@@ -3102,6 +3102,7 @@ var externals = (graph, config = {}) => {
 };
 
 // src/core/Nano.ts
+var debugPerformance = false;
 var NanoTag = class {
   constructor(key) {
     this.key = key;
@@ -3199,7 +3200,6 @@ var NanoFiber = class {
   _yielded = void 0;
   _services = {};
   _cache = {};
-  _perf = false;
   _lastSpan = "";
   runLoop(nano) {
     let current = nano;
@@ -3230,7 +3230,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();
@@ -3438,6 +3438,21 @@ var all = fn("all")(
     return results;
   }
 );
+var getTimings = () => {
+  if (!debugPerformance) return [];
+  const result = [];
+  for (const key in timings) {
+    result.push([key, timings[key] / (timingsCount[key] || 1), timingsCount[key], timings[key]]);
+  }
+  result.sort((a, b) => b[3] - a[3]);
+  const lines = [];
+  for (const [name, avg, hits, total] of result) {
+    lines.push(
+      `${name.padEnd(75)} tot ${total.toFixed(2).padStart(10)}ms avg ${avg.toFixed(2).padStart(10)}ms ${hits.toString().padStart(10)} hits`
+    );
+  }
+  return lines;
+};
 
 // src/core/LanguageServicePluginOptions.ts
 var LanguageServicePluginOptions = Tag("PluginOptions");
@@ -4200,6 +4215,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* (refactors2, sourceFile, positionOrRange, refactorName) {
   const refactor = refactors2.find((refactor2) => refactorNameToFullyQualifiedName(refactor2.name) === refactorName);
   if (!refactor) {
@@ -4208,6 +4243,16 @@ var getEditsForRefactor = fn("LSP.getEditsForRefactor")(function* (refactors2, s
   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* fail3(new RefactorNotApplicableError());
+  }
+  return fixToRun;
+});
 var getCompletionsAtPosition = fn("LSP.getCompletionsAtPosition")(function* (completions2, sourceFile, position, options, formatCodeSettings) {
   let effectCompletions = [];
   for (const completion of completions2) {
@@ -4291,7 +4336,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();
@@ -5138,6 +5183,9 @@ function make7(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) {
@@ -5145,6 +5193,9 @@ function make7(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) {
@@ -5152,6 +5203,9 @@ function make7(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(
@@ -7145,25 +7199,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* fail3("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* fail3("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;
@@ -7300,7 +7356,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)) {
@@ -7980,7 +8036,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* fail3(
           new CodegenNotApplicableError(
@@ -8268,32 +8324,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,
+          map8((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,
+              map8((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) {
@@ -8472,20 +8534,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);
@@ -8506,7 +8569,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" });
                     }
                   }
                 }
@@ -8515,12 +8578,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
     );
@@ -8799,7 +8858,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(
@@ -8811,7 +8870,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(
@@ -8847,62 +8908,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)) {
@@ -9143,7 +9209,7 @@ var effectInVoidSuccess = createDiagnostic({
         );
         return { voidedEffect };
       }
-      return yield* fail3(typeParserIssue("expectedEffect success is not void"));
+      return yield* TypeParserIssue.issue;
     });
     const entries2 = typeCheckerUtils.expectedAndRealType(sourceFile);
     for (const [node, expectedType, valueNode, realType] of entries2) {
@@ -11000,73 +11066,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* fail3("node is not a call expression");
-      const expression = node.expression;
-      if (!ts.isPropertyAccessExpression(expression)) return yield* fail3("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* fail3("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* fail3("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;
+      }
+      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 { node, methodName };
-    });
-    const effectTrySimple = (node) => gen(function* () {
-      if (!ts.isCallExpression(node)) return yield* fail3("node is not a call expression");
+      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* fail3("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* fail3("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* fail3("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* fail3("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* fail3("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* fail3("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* fail3("inside a nested function scope");
+    );
+    for (const jsonCall of jsonCalls) {
+      const effectTryCall = findEnclosingEffectTry(jsonCall);
+      let match3;
+      if (effectTryCall) {
+        match3 = yield* pipe(
+          firstSuccessOf([
+            effectTrySimple(effectTryCall),
+            effectTryObject(effectTryCall)
+          ]),
+          option
+        );
+      } else {
+        match3 = 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 match3 = yield* pipe(
-        firstSuccessOf([
-          effectTrySimple(node),
-          effectTryObject(node),
-          jsonMethodInEffectGen(node)
-        ]),
-        option
-      );
       if (isSome2(match3)) {
         report({
-          location: match3.value.node,
+          location: match3.value,
           messageText: "Consider using Effect Schema for JSON operations instead of JSON.parse/JSON.stringify",
           fixes: []
         });
@@ -11710,19 +11802,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);
@@ -13237,36 +13334,38 @@ var middlewareAutoImportQuickfixes = fn("middlewareAutoImportQuickfixes")(functi
   const program = yield* service(TypeScriptProgram);
   const autoImportProvider = yield* getOrMakeAutoImportProvider(sourceFile);
   const changedCodeFixes = [];
-  const createImportAllChanges = (imports) => gen(function* () {
-    const newImports = [];
-    for (const importToAdd of imports) {
-      if (!importToAdd.exportName) return;
-      const fileName = ts.resolveModuleName(
-        importToAdd.moduleName,
-        sourceFile.fileName,
-        program.getCompilerOptions(),
-        program
+  const createImportAllChanges = fn("middlewareAutoImportQuickfixes.createImportAllChanges")(
+    function* (imports) {
+      const newImports = [];
+      for (const importToAdd of imports) {
+        if (!importToAdd.exportName) return;
+        const fileName = ts.resolveModuleName(
+          importToAdd.moduleName,
+          sourceFile.fileName,
+          program.getCompilerOptions(),
+          program
+        );
+        if (!fileName.resolvedModule) return;
+        const importKind = autoImportProvider.resolve(fileName.resolvedModule.resolvedFileName, importToAdd.exportName);
+        if (!importKind) return;
+        if (importKind.introducedPrefix) return;
+        newImports.push(importKind);
+      }
+      const formatContext = ts.formatting.getFormatContext(
+        formatOptions,
+        languageServiceHost
       );
-      if (!fileName.resolvedModule) return;
-      const importKind = autoImportProvider.resolve(fileName.resolvedModule.resolvedFileName, importToAdd.exportName);
-      if (!importKind) return;
-      if (importKind.introducedPrefix) return;
-      newImports.push(importKind);
+      const edits = ts.textChanges.ChangeTracker.with(
+        {
+          formatContext,
+          host: languageServiceHost,
+          preferences: preferences || {}
+        },
+        (changeTracker) => newImports.forEach((_) => addImport(ts, sourceFile, changeTracker, preferences, _))
+      );
+      return edits;
     }
-    const formatContext = ts.formatting.getFormatContext(
-      formatOptions,
-      languageServiceHost
-    );
-    const edits = ts.textChanges.ChangeTracker.with(
-      {
-        formatContext,
-        host: languageServiceHost,
-        preferences: preferences || {}
-      },
-      (changeTracker) => newImports.forEach((_) => addImport(ts, sourceFile, changeTracker, preferences, _))
-    );
-    return edits;
-  });
+  );
   for (const codeFix of codeFixes) {
     const textFileChanges = codeFix.changes;
     if (textFileChanges.length !== 1) {
@@ -18893,6 +18992,30 @@ var asyncAwaitToGenTryPromise = createRefactor({
   })
 });
 
+// src/refactors/debugPerformance.ts
+var debugPerformance2 = createRefactor({
+  name: "debugPerformance",
+  description: "Debug: LSP Performance",
+  apply: fn("debugPerformance.apply")(function* (sourceFile) {
+    const ts = yield* service(TypeScriptApi);
+    return {
+      kind: "refactor.rewrite.effect.debugPerformance",
+      description: "Debug: LSP Performance",
+      apply: pipe(
+        gen(function* () {
+          const changeTracker = yield* service(ChangeTracker);
+          changeTracker.insertText(
+            sourceFile,
+            0,
+            "/** \n" + getTimings().join("\n") + "\n */"
+          );
+        }),
+        provideService(TypeScriptApi, ts)
+      )
+    };
+  })
+});
+
 // src/refactors/effectGenToFn.ts
 var effectGenToFn = createRefactor({
   name: "effectGenToFn",
@@ -19765,7 +19888,7 @@ var togglePipeStyle = createRefactor({
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
     const tsUtils = yield* service(TypeScriptUtils);
-    const togglePipeStyle2 = (node) => gen(function* () {
+    const togglePipeStyleForNode = fn("togglePipeStyle.togglePipeStyleForNode")(function* (node) {
       const pipeCall = yield* typeParser.pipeCall(node);
       switch (pipeCall.kind) {
         case "pipe": {
@@ -19811,7 +19934,7 @@ var togglePipeStyle = createRefactor({
     });
     const ancestorNodes = tsUtils.getAncestorNodesInRange(sourceFile, textRange);
     return yield* pipe(
-      firstSuccessOf(ancestorNodes.map(togglePipeStyle2)),
+      firstSuccessOf(ancestorNodes.map(togglePipeStyleForNode)),
       orElse2(() => fail3(new RefactorNotApplicableError()))
     );
   })
@@ -20083,7 +20206,7 @@ var createUnsupportedNodeComment = (ts, sourceFile, node) => ts.addSyntheticTrai
   ts.SyntaxKind.MultiLineCommentTrivia,
   " Not supported conversion: " + node.getText(sourceFile) + " "
 );
-var processNode = (node, isVirtualTypeNode) => gen(function* () {
+var processNode = fn("SchemaGen.processNode")(function* (node, isVirtualTypeNode) {
   const { createApiCall, createApiPropertyAccess, entityNameToDataTypeName, sourceFile, supportedEffect, ts } = yield* service(
     SchemaGenContext
   );
@@ -20576,10 +20699,10 @@ var refactors = [
   effectGenToFn,
   togglePipeStyle,
   writeTagClassAccessors
-];
+].concat(debugPerformance ? [debugPerformance2] : []);
 
 // src/renames/keyStrings.ts
-var renameKeyStrings = (sourceFile, position, _findInStrings, _findInComments, _preferences, renameLocations) => gen(function* () {
+var renameKeyStrings = fn("renameKeyStrings")(function* (sourceFile, position, _findInStrings, _findInComments, _preferences, renameLocations) {
   const ts = yield* service(TypeScriptApi);
   const tsUtils = yield* service(TypeScriptUtils);
   const typeParser = yield* service(TypeParser);
@@ -20777,10 +20900,23 @@ var init = (modules) => {
       if (program) {
         const sourceFile = program.getSourceFile(fileName);
         if (sourceFile) {
+          if (!effectCodeFixesForFile.has(fileName)) {
+            runDiagnosticsAndCacheCodeFixes(fileName);
+          }
           return pipe(
             getApplicableRefactors(refactors, sourceFile, positionOrRange),
+            flatMap4(
+              (effectRefactors) => map8(
+                codeFixesToApplicableRefactor(
+                  effectCodeFixesForFile.get(fileName) || [],
+                  sourceFile,
+                  positionOrRange
+                ),
+                (effectCodefixes) => effectCodefixes.concat(effectRefactors)
+              )
+            ),
             runNano(program),
-            map((effectRefactors) => applicableRefactors.concat(effectRefactors)),
+            map((effectCodeActions) => applicableRefactors.concat(effectCodeActions)),
             getOrElse(() => applicableRefactors)
           );
         }
@@ -20794,11 +20930,16 @@ var init = (modules) => {
         if (sourceFile) {
           const result = pipe(
             gen(function* () {
-              const applicableRefactor = yield* getEditsForRefactor(
-                refactors,
-                sourceFile,
-                positionOrRange,
-                refactorName
+              const applicableRefactor = yield* pipe(
+                getEditsForRefactor(
+                  refactors,
+                  sourceFile,
+                  positionOrRange,
+                  refactorName
+                ),
+                orElse2(
+                  () => getEditsForCodeFixes(effectCodeFixesForFile.get(fileName) || [], positionOrRange, refactorName)
+                )
               );
               const formatContext = modules.typescript.formatting.getFormatContext(
                 formatOptions,