@effect/language-service 0.8.0 → 0.9.0

package/index.js

@@ -954,6 +954,18 @@ var sort = /* @__PURE__ */ dual(2, (self, O) => {
 });
 var empty = () => [];
 var map2 = /* @__PURE__ */ dual(2, (self, f) => self.map(f));
+var filterMap = /* @__PURE__ */ dual(2, (self, f) => {
+  const as = fromIterable(self);
+  const out = [];
+  for (let i = 0; i < as.length; i++) {
+    const o = f(as[i], i);
+    if (isSome2(o)) {
+      out.push(o.value);
+    }
+  }
+  return out;
+});
+var getSomes = /* @__PURE__ */ filterMap(identity);
 var filter = /* @__PURE__ */ dual(2, (self, predicate) => {
   const as = fromIterable(self);
   const out = [];
@@ -2659,8 +2671,6 @@ var TaggedError = (tag) => {
 };
 
 // src/core/Nano.ts
-var NanoInterruptedException = class extends TaggedError("NanoInterruptedException") {
-};
 var NanoDefectException = class extends TaggedError("NanoDefectException") {
 };
 var NanoTag = class {
@@ -2691,40 +2701,44 @@ var Nano = class {
     return new SingleShotGen(new YieldWrap(this));
   }
 };
-var run = (fa) => pipe(
-  try_({
-    try: () => fa.run(contextEmpty),
-    catch: (error) => new NanoDefectException({ value: error })
-  }),
-  flatMap((_) => _),
-  flatMap((_) => _)
-);
-var succeed = (value) => new Nano(() => right2(right2(value)));
-var fail3 = (value) => new Nano(() => right2(left2(value)));
-var sync = (value) => new Nano(() => right2(right2(value())));
+var run = (fa) => {
+  try {
+    const result = fa.run(contextEmpty);
+    switch (result._tag) {
+      case "Left":
+        return left2(result.left);
+      case "Defect":
+        return left2(new NanoDefectException({ message: result.defect }));
+      case "Right":
+        return right2(result.right);
+    }
+  } catch (e) {
+    return left2(new NanoDefectException({ message: e }));
+  }
+};
+var succeed = (value) => new Nano(() => ({ _tag: "Right", right: value }));
+var fail3 = (value) => new Nano(() => ({ _tag: "Left", left: value }));
+var sync = (value) => new Nano(() => ({ _tag: "Right", right: value() }));
 var flatMap4 = dual(2, (fa, f) => new Nano((ctx) => {
   const result = fa.run(ctx);
-  if (isLeft2(result)) return result;
-  if (isLeft2(result.right)) return result;
-  return f(result.right.right).run(ctx);
+  if (result._tag !== "Right") return result;
+  return f(result.right).run(ctx);
 }));
 var map7 = dual(2, (fa, f) => new Nano((ctx) => {
   const result = fa.run(ctx);
-  if (isLeft2(result)) return result;
-  if (isLeft2(result.right)) return result;
-  return right2(right2(f(result.right.right)));
+  if (result._tag !== "Right") return result;
+  return { _tag: "Right", right: f(result.right) };
 }));
 var orElse3 = (f) => (fa) => new Nano((ctx) => {
   const result = fa.run(ctx);
-  if (isLeft2(result)) return result;
-  if (isLeft2(result.right)) return f().run(ctx);
+  if (result._tag === "Left") return f().run(ctx);
   return result;
 });
 var firstSuccessOf = (arr) => reduce(arr.slice(1), arr[0], (arr2, fa) => orElse3(() => fa)(arr2));
 var service = (tag) => new Nano(
   (ctx) => contextGet(ctx, tag).pipe(match2({
-    onNone: () => left2(new NanoDefectException({ value: `Cannot find service ${tag.key}` })),
-    onSome: (value) => right2(right2(value))
+    onNone: () => ({ _tag: "Defect", defect: `Cannot find service ${tag.key}` }),
+    onSome: (value) => ({ _tag: "Right", right: value })
   }))
 );
 var provideService = (tag, value) => (fa) => new Nano((ctx) => {
@@ -2736,25 +2750,36 @@ var gen2 = (...args) => new Nano((ctx) => {
   while (!state.done) {
     const current = isGenKind(state.value) ? state.value.value : yieldWrapGet(state.value);
     const result = current.run(ctx);
-    if (isLeft2(result)) {
+    if (result._tag !== "Right") {
       return result;
     }
-    const inner = result.right;
-    if (isLeft2(inner)) {
+    state = iterator.next(result.right);
+  }
+  return { _tag: "Right", right: state.value };
+});
+var fn = (_) => (body) => (...args) => new Nano((ctx) => {
+  const iterator = body(...args);
+  let state = iterator.next();
+  while (!state.done) {
+    const current = isGenKind(state.value) ? state.value.value : yieldWrapGet(state.value);
+    const result = current.run(ctx);
+    if (result._tag !== "Right") {
       return result;
     }
-    state = iterator.next(inner.right);
+    state = iterator.next(result.right);
   }
-  return right2(right2(state.value));
+  return { _tag: "Right", right: state.value };
 });
 var option = (fa) => new Nano((ctx) => {
-  return match(fa.run(ctx), {
-    onLeft: (cause) => left2(cause),
-    onRight: match({
-      onLeft: () => right2(right2(none2())),
-      onRight: (value) => right2(right2(some2(value)))
-    })
-  });
+  const result = fa.run(ctx);
+  switch (result._tag) {
+    case "Right":
+      return { _tag: "Right", right: some2(result.right) };
+    case "Left":
+      return { _tag: "Right", right: none2() };
+    case "Defect":
+      return result;
+  }
 });
 
 // src/core/LSP.ts
@@ -2766,214 +2791,684 @@ function createRefactor(definition) {
 function createDiagnostic(definition) {
   return definition;
 }
+function createCompletion(definition) {
+  return definition;
+}
 var PluginOptions = Tag("PluginOptions");
 var SourceFileNotFoundError = class extends TaggedError("SourceFileNotFoundError") {
 };
-function getSemanticDiagnostics(diagnostics2, sourceFile) {
-  return gen2(function* () {
-    const effectDiagnostics = [];
-    for (const diagnostic of diagnostics2) {
-      const result = yield* option(diagnostic.apply(sourceFile));
-      if (isSome2(result)) {
-        effectDiagnostics.push(...result.value.map((_) => ({
-          file: sourceFile,
-          start: _.node.getStart(sourceFile),
-          length: _.node.getEnd() - _.node.getStart(sourceFile),
-          messageText: _.messageText,
-          category: _.category,
-          code: diagnostic.code,
-          source: "effect"
-        })));
-      }
+var getSemanticDiagnostics = fn("LSP.getSemanticDiagnostics")(function* (diagnostics2, sourceFile) {
+  const effectDiagnostics = [];
+  for (const diagnostic of diagnostics2) {
+    const result = yield* option(diagnostic.apply(sourceFile));
+    if (isSome2(result)) {
+      effectDiagnostics.push(...result.value.map((_) => ({
+        file: sourceFile,
+        start: _.node.getStart(sourceFile),
+        length: _.node.getEnd() - _.node.getStart(sourceFile),
+        messageText: _.messageText,
+        category: _.category,
+        code: diagnostic.code,
+        source: "effect"
+      })));
+    }
+  }
+  return effectDiagnostics;
+});
+var getCodeFixesAtPosition = fn("LSP.getCodeFixesAtPosition")(function* (diagnostics2, sourceFile, start, end, errorCodes) {
+  const runnableDiagnostics = diagnostics2.filter((_) => errorCodes.indexOf(_.code) > -1);
+  const applicableFixes = [];
+  for (const diagnostic of runnableDiagnostics) {
+    const result = yield* option(diagnostic.apply(sourceFile));
+    if (isSome2(result)) {
+      applicableFixes.push(
+        ...pipe(
+          result.value,
+          filter(
+            (_) => _.node.getStart(sourceFile) === start && _.node.getEnd() === end
+          ),
+          map2((_) => _.fix),
+          getSomes
+        )
+      );
     }
-    return effectDiagnostics;
-  });
-}
-function getApplicableRefactors(refactors2, sourceFile, positionOrRange) {
-  return gen2(function* () {
-    const textRange = typeof positionOrRange === "number" ? { pos: positionOrRange, end: positionOrRange } : positionOrRange;
-    const effectRefactors = [];
-    for (const refactor of refactors2) {
-      const result = yield* option(refactor.apply(sourceFile, textRange));
-      if (isSome2(result)) {
-        effectRefactors.push({
+  }
+  return applicableFixes;
+});
+var getApplicableRefactors = fn("LSP.getApplicableRefactors")(function* (refactors2, sourceFile, positionOrRange) {
+  const textRange = typeof positionOrRange === "number" ? { pos: positionOrRange, end: positionOrRange } : positionOrRange;
+  const effectRefactors = [];
+  for (const refactor of refactors2) {
+    const result = yield* option(refactor.apply(sourceFile, textRange));
+    if (isSome2(result)) {
+      effectRefactors.push({
+        name: refactor.name,
+        description: refactor.description,
+        actions: [{
           name: refactor.name,
-          description: refactor.description,
-          actions: [{
-            name: refactor.name,
-            description: result.value.description,
-            kind: result.value.kind
-          }]
-        });
-      }
-    }
-    return effectRefactors;
-  });
-}
-function getEditsForRefactor(refactors2, sourceFile, positionOrRange, refactorName) {
-  return gen2(function* () {
-    const refactor = refactors2.find((refactor2) => refactor2.name === refactorName);
-    if (!refactor) {
-      return yield* fail3(new RefactorNotApplicableError());
+          description: result.value.description,
+          kind: result.value.kind
+        }]
+      });
     }
-    const textRange = typeof positionOrRange === "number" ? { pos: positionOrRange, end: positionOrRange } : positionOrRange;
-    return yield* refactor.apply(sourceFile, textRange);
-  });
-}
+  }
+  return effectRefactors;
+});
+var getEditsForRefactor = fn("LSP.getEditsForRefactor")(function* (refactors2, sourceFile, positionOrRange, refactorName) {
+  const refactor = refactors2.find((refactor2) => refactor2.name === refactorName);
+  if (!refactor) {
+    return yield* fail3(new RefactorNotApplicableError());
+  }
+  const textRange = typeof positionOrRange === "number" ? { pos: positionOrRange, end: positionOrRange } : positionOrRange;
+  return yield* refactor.apply(sourceFile, textRange);
+});
+var getCompletionsAtPosition = fn("LSP.getCompletionsAtPosition")(function* (completions2, sourceFile, position, options, formatCodeSettings) {
+  const effectCompletions = [];
+  for (const completion of completions2) {
+    const result = yield* completion.apply(sourceFile, position, options, formatCodeSettings);
+    effectCompletions.push(
+      ...result.map((_) => ({ sortText: "11", ..._ }))
+    );
+  }
+  return effectCompletions;
+});
 
 // src/utils/TypeScriptApi.ts
 var TypeScriptApi = Tag("TypeScriptApi");
 var ChangeTracker = Tag("ChangeTracker");
 
-// src/utils/TypeCheckerApi.ts
-var TypeCheckerApi = Tag("TypeChecker");
-var deterministicTypeOrder = gen2(function* () {
-  const typeChecker = yield* service(TypeCheckerApi);
-  return make2((a, b) => {
-    const aName = typeChecker.typeToString(a);
-    const bName = typeChecker.typeToString(b);
-    if (aName < bName) return -1;
-    if (aName > bName) return 1;
-    return 0;
-  });
-});
-function getMissingTypeEntriesInTargetType(realType, expectedType) {
-  return gen2(function* () {
-    const typeChecker = yield* service(TypeCheckerApi);
-    const result = [];
-    const toTest = [realType];
-    while (toTest.length > 0) {
-      const type = toTest.pop();
-      if (!type) return result;
-      if (type.isUnion()) {
-        toTest.push(...type.types);
-      } else {
-        const assignable = typeChecker.isTypeAssignableTo(type, expectedType);
-        if (!assignable) {
-          result.push(type);
-        }
+// src/utils/AST.ts
+function collectSelfAndAncestorNodesInRange(node, textRange) {
+  return sync(() => {
+    let result = empty();
+    let parent = node;
+    while (parent) {
+      if (parent.end >= textRange.end) {
+        result = pipe(result, append(parent));
       }
+      parent = parent.parent;
     }
     return result;
   });
 }
-var CannotFindAncestorConvertibleDeclarationError = class extends TaggedError("CannotFindAncestorConvertibleDeclarationError") {
+var getAncestorNodesInRange = fn("AST.getAncestorNodesInRange")(function* (sourceFile, textRange) {
+  const ts = yield* service(TypeScriptApi);
+  const precedingToken = ts.findPrecedingToken(textRange.pos, sourceFile);
+  if (!precedingToken) return empty();
+  return yield* collectSelfAndAncestorNodesInRange(precedingToken, textRange);
+});
+var NodeNotFoundError = class extends TaggedError("@effect/language-service/NodeNotFoundError") {
 };
-function getAncestorConvertibleDeclaration(node) {
-  return gen2(function* () {
-    const ts = yield* service(TypeScriptApi);
-    let current = node;
-    while (current) {
-      if (ts.isFunctionDeclaration(current) || ts.isFunctionExpression(current) || ts.isArrowFunction(current) || ts.isMethodDeclaration(current)) {
-        return current;
-      }
-      current = current.parent;
+var findNodeAtPosition = fn("AST.findNodeAtPosition")(function* (sourceFile, position) {
+  const ts = yield* service(TypeScriptApi);
+  function find(node) {
+    if (position >= node.getStart() && position < node.getEnd()) {
+      return ts.forEachChild(node, find) || node;
     }
-    return yield* fail3(new CannotFindAncestorConvertibleDeclarationError({ node }));
-  });
+    return void 0;
+  }
+  const result = find(sourceFile);
+  if (!result) return yield* fail3(new NodeNotFoundError());
+  return result;
+});
+var collectDescendantsAndAncestorsInRange = fn(
+  "AST.collectDescendantsAndAncestorsInRange"
+)(function* (sourceFile, textRange) {
+  const nodeAtPosition = yield* option(findNodeAtPosition(sourceFile, textRange.pos));
+  if (isNone2(nodeAtPosition)) return empty();
+  return yield* collectSelfAndAncestorNodesInRange(nodeAtPosition.value, textRange);
+});
+function toTextRange(positionOrRange) {
+  return typeof positionOrRange === "number" ? { end: positionOrRange, pos: positionOrRange } : positionOrRange;
 }
-var CannotInferReturnTypeFromEmptyBody = class extends TaggedError("CannotInferReturnTypeFromEmptyBody") {
-};
-var CannotInferReturnType = class extends TaggedError("CannotInferReturnType") {
-};
-function getInferredReturnType(declaration) {
-  return gen2(function* () {
-    const typeChecker = yield* service(TypeCheckerApi);
-    if (!declaration.body) {
-      return yield* fail3(
-        new CannotInferReturnTypeFromEmptyBody({ declaration })
-      );
-    }
-    let returnType;
-    if (typeChecker.isImplementationOfOverload(declaration)) {
-      const signatures = typeChecker.getTypeAtLocation(declaration).getCallSignatures();
-      if (signatures.length > 1) {
-        returnType = typeChecker.getUnionType(
-          signatures.map((s) => s.getReturnType()).filter((_) => !!_)
+function isNodeInRange(textRange) {
+  return (node) => node.pos <= textRange.pos && node.end >= textRange.end;
+}
+var transformAsyncAwaitToEffectGen = fn("AST.transformAsyncAwaitToEffectGen")(
+  function* (node, effectModuleName, onAwait) {
+    const ts = yield* service(TypeScriptApi);
+    function visitor(_) {
+      if (ts.isAwaitExpression(_)) {
+        const expression = ts.visitEachChild(_.expression, visitor, ts.nullTransformationContext);
+        return ts.factory.createYieldExpression(
+          ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+          onAwait(expression)
         );
       }
+      return ts.visitEachChild(_, visitor, ts.nullTransformationContext);
     }
-    if (!returnType) {
-      const signature = typeChecker.getSignatureFromDeclaration(declaration);
-      if (signature) {
-        const typePredicate = typeChecker.getTypePredicateOfSignature(signature);
-        if (typePredicate && typePredicate.type) {
-          return typePredicate.type;
-        } else {
-          returnType = typeChecker.getReturnTypeOfSignature(signature);
-        }
-      }
-    }
-    if (!returnType) {
-      return yield* fail3(
-        new CannotInferReturnType({ declaration })
+    const generatorBody = visitor(node.body);
+    const generator = ts.factory.createFunctionExpression(
+      void 0,
+      ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+      void 0,
+      [],
+      [],
+      void 0,
+      generatorBody
+      // NOTE(mattia): intended, to use same routine for both ConciseBody and Body
+    );
+    const effectGenCallExp = ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(
+        ts.factory.createIdentifier(effectModuleName),
+        "gen"
+      ),
+      void 0,
+      [generator]
+    );
+    let currentFlags = ts.getCombinedModifierFlags(node);
+    currentFlags &= ~ts.ModifierFlags.Async;
+    const newModifiers = ts.factory.createModifiersFromModifierFlags(currentFlags);
+    if (ts.isArrowFunction(node)) {
+      return ts.factory.createArrowFunction(
+        newModifiers,
+        node.typeParameters,
+        node.parameters,
+        void 0,
+        node.equalsGreaterThanToken,
+        effectGenCallExp
       );
     }
-    return returnType;
-  });
-}
-function expectedAndRealType(node) {
-  return gen2(function* () {
-    const typeChecker = yield* service(TypeCheckerApi);
-    const ts = yield* service(TypeScriptApi);
-    if (ts.isVariableDeclaration(node) && node.initializer) {
-      const expectedType = typeChecker.getTypeAtLocation(node.name);
-      const realType = typeChecker.getTypeAtLocation(node.initializer);
-      return [[node.name, expectedType, node.initializer, realType]];
+    const newBody = ts.factory.createBlock([
+      ts.factory.createReturnStatement(effectGenCallExp)
+    ]);
+    if (ts.isFunctionDeclaration(node)) {
+      return ts.factory.createFunctionDeclaration(
+        newModifiers,
+        node.asteriskToken,
+        node.name,
+        node.typeParameters,
+        node.parameters,
+        void 0,
+        newBody
+      );
     }
-    if (ts.isCallExpression(node)) {
-      const resolvedSignature = typeChecker.getResolvedSignature(node);
-      if (resolvedSignature) {
-        return resolvedSignature.getParameters().map((parameter, index) => {
-          const expectedType = typeChecker.getTypeOfSymbolAtLocation(parameter, node);
-          const realType = typeChecker.getTypeAtLocation(node.arguments[index]);
-          return [node.arguments[index], expectedType, node.arguments[index], realType];
-        });
-      }
+    return ts.factory.createFunctionExpression(
+      newModifiers,
+      node.asteriskToken,
+      node.name,
+      node.typeParameters,
+      node.parameters,
+      void 0,
+      newBody
+    );
+  }
+);
+var addReturnTypeAnnotation = fn("AST.addReturnTypeAnnotation")(function* (sourceFile, declaration, typeNode) {
+  const ts = yield* service(TypeScriptApi);
+  const changes = yield* service(ChangeTracker);
+  const closeParen = ts.findChildOfKind(declaration, ts.SyntaxKind.CloseParenToken, sourceFile);
+  const needParens = ts.isArrowFunction(declaration) && closeParen === void 0;
+  const endNode = needParens ? declaration.parameters[0] : closeParen;
+  if (endNode) {
+    if (needParens) {
+      changes.insertNodeBefore(
+        sourceFile,
+        endNode,
+        ts.factory.createToken(ts.SyntaxKind.OpenParenToken)
+      );
+      changes.insertNodeAfter(
+        sourceFile,
+        endNode,
+        ts.factory.createToken(ts.SyntaxKind.CloseParenToken)
+      );
     }
-    if (ts.isIdentifier(node) || ts.isStringLiteral(node) || ts.isNumericLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
-      const parent = node.parent;
-      if (ts.isObjectLiteralElement(parent)) {
-        if (ts.isObjectLiteralExpression(parent.parent) && parent.name === node) {
-          const type = typeChecker.getContextualType(parent.parent);
-          if (type) {
-            const symbol3 = typeChecker.getPropertyOfType(type, node.text);
-            if (symbol3) {
-              const expectedType = typeChecker.getTypeOfSymbolAtLocation(symbol3, node);
-              const realType = typeChecker.getTypeAtLocation(node);
-              return [[node, expectedType, node, realType]];
-            }
+    changes.insertNodeAt(sourceFile, endNode.end, typeNode, { prefix: ": " });
+  }
+});
+var removeReturnTypeAnnotation = fn("AST.removeReturnTypeAnnotation")(function* (sourceFile, declaration) {
+  const ts = yield* service(TypeScriptApi);
+  const changes = yield* service(ChangeTracker);
+  const closeParen = ts.findChildOfKind(declaration, ts.SyntaxKind.CloseParenToken, sourceFile);
+  const needParens = ts.isArrowFunction(declaration) && closeParen === void 0;
+  const endNode = needParens ? declaration.parameters[0] : closeParen;
+  if (endNode && declaration.type) {
+    changes.deleteRange(sourceFile, { pos: endNode.end, end: declaration.type.end });
+  }
+});
+var ImportModuleIdentifierNotFoundError = class extends TaggedError("@effect/language-service/ImportModuleIdentifierNotFoundError") {
+};
+var findImportedModuleIdentifier = fn("AST.findImportedModuleIdentifier")(
+  function* (sourceFile, test) {
+    const ts = yield* service(TypeScriptApi);
+    for (const statement of sourceFile.statements) {
+      if (!ts.isImportDeclaration(statement)) continue;
+      const importClause = statement.importClause;
+      if (!importClause) continue;
+      const namedBindings = importClause.namedBindings;
+      if (!namedBindings) continue;
+      if (ts.isNamespaceImport(namedBindings)) {
+        if (yield* test(namedBindings.name, statement.moduleSpecifier, none2())) {
+          return namedBindings.name;
+        }
+      } else if (ts.isNamedImports(namedBindings)) {
+        for (const importSpecifier of namedBindings.elements) {
+          const importProperty = fromNullable2(importSpecifier.propertyName).pipe(
+            orElse2(() => some2(importSpecifier.name))
+          );
+          if (yield* test(importSpecifier.name, statement.moduleSpecifier, importProperty)) {
+            return importSpecifier.name;
           }
         }
       }
     }
-    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
-      const expectedType = typeChecker.getTypeAtLocation(node.left);
-      const realType = typeChecker.getTypeAtLocation(node.right);
-      return [[node.left, expectedType, node.right, realType]];
+    return yield* fail3(new ImportModuleIdentifierNotFoundError());
+  }
+);
+function findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, packageName, moduleName) {
+  return findImportedModuleIdentifier(
+    sourceFile,
+    fn(
+      "AST.findImportedModuleIdentifierByPackageAndNameOrBarrel.findImportedModuleIdentifier"
+    )(function* (_, fromModule, importProperty) {
+      const ts = yield* service(TypeScriptApi);
+      if (isNone2(importProperty) && ts.isStringLiteral(fromModule) && fromModule.text === packageName + "/" + moduleName) {
+        return true;
+      }
+      if (isSome2(importProperty) && ts.isIdentifier(importProperty.value) && importProperty.value.text === moduleName && ts.isStringLiteral(fromModule) && fromModule.text === packageName) {
+        return true;
+      }
+      return false;
+    })
+  );
+}
+var simplifyTypeNode = fn("AST.simplifyTypeNode")(function* (typeNode) {
+  const ts = yield* service(TypeScriptApi);
+  function collectCallable(typeNode2) {
+    if (ts.isParenthesizedTypeNode(typeNode2)) return collectCallable(typeNode2.type);
+    if (ts.isFunctionTypeNode(typeNode2)) {
+      return some2([
+        ts.factory.createCallSignature(typeNode2.typeParameters, typeNode2.parameters, typeNode2.type)
+      ]);
     }
-    if (ts.isReturnStatement(node) && node.expression) {
-      const parentDeclaration = yield* option(getAncestorConvertibleDeclaration(node));
-      if (isSome2(parentDeclaration)) {
-        const expectedType = yield* option(getInferredReturnType(parentDeclaration.value));
-        const realType = typeChecker.getTypeAtLocation(node.expression);
-        if (isSome2(expectedType)) return [[node, expectedType.value, node, realType]];
+    if (ts.isTypeLiteralNode(typeNode2)) {
+      const allCallSignatures = typeNode2.members.every(ts.isCallSignatureDeclaration);
+      if (allCallSignatures) {
+        return some2(typeNode2.members);
       }
     }
-    if (ts.isArrowFunction(node) && ts.isExpression(node.body)) {
-      const body = node.body;
-      const expectedType = typeChecker.getContextualType(body);
-      const realType = typeChecker.getTypeAtLocation(body);
-      if (expectedType) return [[body, expectedType, body, realType]];
+    if (ts.isIntersectionTypeNode(typeNode2)) {
+      const members = typeNode2.types.map((node) => collectCallable(node));
+      if (members.every(isSome2)) {
+        return some2(members.map((_) => isSome2(_) ? _.value : []).flat());
+      }
     }
-    if (ts.isSatisfiesExpression(node)) {
+    return none2();
+  }
+  const callSignatures = collectCallable(typeNode);
+  if (isSome2(callSignatures) && callSignatures.value.length > 1) {
+    return ts.factory.createTypeLiteralNode(callSignatures.value);
+  }
+  return typeNode;
+});
+var tryPreserveDeclarationSemantics = fn("AST.tryPreserveDeclarationSemantics")(
+  function* (nodeToReplace, node) {
+    const ts = yield* service(TypeScriptApi);
+    if (!ts.isExpression(node)) return node;
+    if (ts.isFunctionDeclaration(nodeToReplace)) {
+      if (!nodeToReplace.name) return node;
+      return ts.factory.createVariableStatement(
+        nodeToReplace.modifiers,
+        ts.factory.createVariableDeclarationList(
+          [ts.factory.createVariableDeclaration(
+            nodeToReplace.name,
+            void 0,
+            void 0,
+            node
+          )],
+          ts.NodeFlags.Const
+        )
+      );
+    } else if (ts.isMethodDeclaration(nodeToReplace)) {
+      return ts.factory.createPropertyDeclaration(
+        nodeToReplace.modifiers,
+        nodeToReplace.name,
+        void 0,
+        void 0,
+        node
+      );
+    }
+    return node;
+  }
+);
+var parseDataForExtendsClassCompletion = fn(
+  "AST.parseDataForExtendsClassCompletion"
+)(function* (sourceFile, position) {
+  const ts = yield* service(TypeScriptApi);
+  const precedingToken = ts.findPrecedingToken(position, sourceFile, void 0, true);
+  if (!precedingToken) return none2();
+  let accessedObject = precedingToken;
+  let replacementSpan = ts.createTextSpan(position, 0);
+  let outerNode = precedingToken;
+  if (ts.isIdentifier(precedingToken) && precedingToken.parent && ts.isPropertyAccessExpression(precedingToken.parent)) {
+    replacementSpan = ts.createTextSpan(
+      precedingToken.parent.getStart(sourceFile),
+      precedingToken.end - precedingToken.parent.getStart(sourceFile)
+    );
+    accessedObject = precedingToken.parent.expression;
+    outerNode = precedingToken.parent;
+  } else if (ts.isToken(precedingToken) && precedingToken.kind === ts.SyntaxKind.DotToken && ts.isPropertyAccessExpression(precedingToken.parent)) {
+    replacementSpan = ts.createTextSpan(
+      precedingToken.parent.getStart(sourceFile),
+      precedingToken.end - precedingToken.parent.getStart(sourceFile)
+    );
+    accessedObject = precedingToken.parent.expression;
+    outerNode = precedingToken.parent;
+  } else if (ts.isIdentifier(precedingToken) && precedingToken.parent) {
+    replacementSpan = ts.createTextSpan(
+      precedingToken.getStart(sourceFile),
+      precedingToken.end - precedingToken.getStart(sourceFile)
+    );
+    accessedObject = precedingToken;
+    outerNode = precedingToken;
+  } else {
+    return none2();
+  }
+  if (!ts.isIdentifier(accessedObject)) return none2();
+  let classDeclaration = outerNode.parent;
+  while (ts.isExpressionWithTypeArguments(classDeclaration) || ts.isHeritageClause(classDeclaration)) {
+    if (!classDeclaration.parent) break;
+    classDeclaration = classDeclaration.parent;
+  }
+  if (!ts.isClassDeclaration(classDeclaration)) return none2();
+  if (!classDeclaration.name) return none2();
+  return some2(
+    { accessedObject, classDeclaration, className: classDeclaration.name, replacementSpan }
+  );
+});
+
+// src/completions/contextSelfInClasses.ts
+var contextSelfInClasses = createCompletion({
+  name: "effect/contextSelfInClasses",
+  apply: fn("contextSelfInClasses")(function* (sourceFile, position) {
+    const ts = yield* service(TypeScriptApi);
+    const maybeInfos = yield* parseDataForExtendsClassCompletion(sourceFile, position);
+    if (isNone2(maybeInfos)) return [];
+    const { accessedObject, className, replacementSpan } = maybeInfos.value;
+    const contextName = yield* option(
+      findImportedModuleIdentifierByPackageAndNameOrBarrel(
+        sourceFile,
+        "effect",
+        "Context"
+      )
+    );
+    const contextIdentifier = match2(contextName, {
+      onNone: () => "Context",
+      onSome: (_) => _.text
+    });
+    if (contextIdentifier !== accessedObject.text) return [];
+    const name = className.text;
+    return [{
+      name: `Tag("${name}")`,
+      kind: ts.ScriptElementKind.constElement,
+      insertText: `${contextIdentifier}.Tag("${name}")<${name}, ${"${0}"}>(){}`,
+      replacementSpan,
+      isSnippet: true
+    }];
+  })
+});
+
+// src/completions/effectSchemaSelfInClasses.ts
+var effectSchemaSelfInClasses = createCompletion({
+  name: "effect/effectSchemaSelfInClasses",
+  apply: fn("effectSchemaSelfInClasses")(function* (sourceFile, position) {
+    const ts = yield* service(TypeScriptApi);
+    const maybeInfos = yield* parseDataForExtendsClassCompletion(sourceFile, position);
+    if (isNone2(maybeInfos)) return [];
+    const { accessedObject, className, replacementSpan } = maybeInfos.value;
+    const effectSchemaName = yield* option(
+      findImportedModuleIdentifierByPackageAndNameOrBarrel(
+        sourceFile,
+        "effect",
+        "Schema"
+      )
+    );
+    const schemaIdentifier = match2(effectSchemaName, {
+      onNone: () => "Schema",
+      onSome: (_) => _.text
+    });
+    if (schemaIdentifier !== accessedObject.text) return [];
+    const name = className.text;
+    return [{
+      name: `Class<${name}>`,
+      kind: ts.ScriptElementKind.constElement,
+      insertText: `${schemaIdentifier}.Class<${name}>("${name}")({${"${0}"}}){}`,
+      replacementSpan,
+      isSnippet: true
+    }, {
+      name: `TaggedError<${name}>`,
+      kind: ts.ScriptElementKind.constElement,
+      insertText: `${schemaIdentifier}.TaggedError<${name}>("${name}")("${name}", {${"${0}"}}){}`,
+      replacementSpan,
+      isSnippet: true
+    }, {
+      name: `TaggedClass<${name}>`,
+      kind: ts.ScriptElementKind.constElement,
+      insertText: `${schemaIdentifier}.TaggedClass<${name}>("${name}")("${name}", {${"${0}"}}){}`,
+      replacementSpan,
+      isSnippet: true
+    }, {
+      name: `TaggedRequest<${name}>`,
+      kind: ts.ScriptElementKind.constElement,
+      insertText: `${schemaIdentifier}.TaggedRequest<${name}>("${name}")("${name}", {${"${0}"}}){}`,
+      replacementSpan,
+      isSnippet: true
+    }];
+  })
+});
+
+// src/completions/effectSelfInClasses.ts
+var effectSelfInClasses = createCompletion({
+  name: "effect/effectSelfInClasses",
+  apply: fn("effectSelfInClasses")(function* (sourceFile, position) {
+    const ts = yield* service(TypeScriptApi);
+    const maybeInfos = yield* parseDataForExtendsClassCompletion(sourceFile, position);
+    if (isNone2(maybeInfos)) return [];
+    const { accessedObject, className, replacementSpan } = maybeInfos.value;
+    const effectName = yield* option(
+      findImportedModuleIdentifierByPackageAndNameOrBarrel(
+        sourceFile,
+        "effect",
+        "Effect"
+      )
+    );
+    const effectIdentifier = match2(effectName, {
+      onNone: () => "Effect",
+      onSome: (_) => _.text
+    });
+    if (effectIdentifier !== accessedObject.text) return [];
+    const name = className.text;
+    return [{
+      name: `Service<${name}>`,
+      kind: ts.ScriptElementKind.constElement,
+      insertText: `${effectIdentifier}.Service<${name}>()("${name}", {${"${0}"}}){}`,
+      replacementSpan,
+      isSnippet: true
+    }];
+  })
+});
+
+// src/completions.ts
+var completions = [effectSchemaSelfInClasses, effectSelfInClasses, contextSelfInClasses];
+
+// src/utils/TypeCheckerApi.ts
+var TypeCheckerApi = Tag("TypeChecker");
+var TypeCheckerApiCache = Tag("TypeCheckerApiCache");
+function makeTypeCheckerApiCache() {
+  return {
+    expectedAndRealType: /* @__PURE__ */ new WeakMap()
+  };
+}
+var deterministicTypeOrder = gen2(function* () {
+  const typeChecker = yield* service(TypeCheckerApi);
+  return make2((a, b) => {
+    const aName = typeChecker.typeToString(a);
+    const bName = typeChecker.typeToString(b);
+    if (aName < bName) return -1;
+    if (aName > bName) return 1;
+    return 0;
+  });
+});
+var getMissingTypeEntriesInTargetType = fn(
+  "TypeCheckerApi.getMissingTypeEntriesInTargetType"
+)(
+  function* (realType, expectedType) {
+    const typeChecker = yield* service(TypeCheckerApi);
+    const result = [];
+    const toTest = [realType];
+    while (toTest.length > 0) {
+      const type = toTest.pop();
+      if (!type) return result;
+      if (type.isUnion()) {
+        toTest.push(...type.types);
+      } else {
+        const assignable = typeChecker.isTypeAssignableTo(type, expectedType);
+        if (!assignable) {
+          result.push(type);
+        }
+      }
+    }
+    return result;
+  }
+);
+var CannotFindAncestorConvertibleDeclarationError = class extends TaggedError("CannotFindAncestorConvertibleDeclarationError") {
+};
+var getAncestorConvertibleDeclaration = fn(
+  "TypeCheckerApi.getAncestorConvertibleDeclaration"
+)(function* (node) {
+  const ts = yield* service(TypeScriptApi);
+  let current = node;
+  while (current) {
+    if (ts.isFunctionDeclaration(current) || ts.isFunctionExpression(current) || ts.isArrowFunction(current) || ts.isMethodDeclaration(current)) {
+      return current;
+    }
+    current = current.parent;
+  }
+  return yield* fail3(new CannotFindAncestorConvertibleDeclarationError({ node }));
+});
+var CannotInferReturnTypeFromEmptyBody = class extends TaggedError("CannotInferReturnTypeFromEmptyBody") {
+};
+var CannotInferReturnType = class extends TaggedError("CannotInferReturnType") {
+};
+var getInferredReturnType = fn("TypeCheckerApi.getInferredReturnType")(function* (declaration) {
+  const typeChecker = yield* service(TypeCheckerApi);
+  if (!declaration.body) {
+    return yield* fail3(
+      new CannotInferReturnTypeFromEmptyBody({ declaration })
+    );
+  }
+  let returnType;
+  if (typeChecker.isImplementationOfOverload(declaration)) {
+    const signatures = typeChecker.getTypeAtLocation(declaration).getCallSignatures();
+    if (signatures.length > 1) {
+      returnType = typeChecker.getUnionType(
+        signatures.map((s) => s.getReturnType()).filter((_) => !!_)
+      );
+    }
+  }
+  if (!returnType) {
+    const signature = typeChecker.getSignatureFromDeclaration(declaration);
+    if (signature) {
+      const typePredicate = typeChecker.getTypePredicateOfSignature(signature);
+      if (typePredicate && typePredicate.type) {
+        return typePredicate.type;
+      } else {
+        returnType = typeChecker.getReturnTypeOfSignature(signature);
+      }
+    }
+  }
+  if (!returnType) {
+    return yield* fail3(
+      new CannotInferReturnType({ declaration })
+    );
+  }
+  return returnType;
+});
+var expectedAndRealType = fn("TypeCheckerApi.expectedAndRealType")(function* (sourceFile) {
+  const cache = yield* service(TypeCheckerApiCache);
+  const resultCached = cache.expectedAndRealType.get(sourceFile);
+  if (resultCached) return resultCached;
+  const typeChecker = yield* service(TypeCheckerApi);
+  const ts = yield* service(TypeScriptApi);
+  const result = [];
+  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.isVariableDeclaration(node) && node.initializer) {
+      const expectedType = typeChecker.getTypeAtLocation(node.name);
+      const realType = typeChecker.getTypeAtLocation(node.initializer);
+      result.push([node.name, expectedType, node.initializer, realType]);
+      continue;
+    } else if (ts.isCallExpression(node)) {
+      const resolvedSignature = typeChecker.getResolvedSignature(node);
+      if (resolvedSignature) {
+        resolvedSignature.getParameters().map((parameter, index) => {
+          const expectedType = typeChecker.getTypeOfSymbolAtLocation(parameter, node);
+          const realType = typeChecker.getTypeAtLocation(node.arguments[index]);
+          result.push([
+            node.arguments[index],
+            expectedType,
+            node.arguments[index],
+            realType
+          ]);
+        });
+        continue;
+      }
+    } else if (ts.isIdentifier(node) || ts.isStringLiteral(node) || ts.isNumericLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+      const parent = node.parent;
+      if (ts.isObjectLiteralElement(parent)) {
+        if (ts.isObjectLiteralExpression(parent.parent) && parent.name === node) {
+          const type = typeChecker.getContextualType(parent.parent);
+          if (type) {
+            const symbol3 = typeChecker.getPropertyOfType(type, node.text);
+            if (symbol3) {
+              const expectedType = typeChecker.getTypeOfSymbolAtLocation(symbol3, node);
+              const realType = typeChecker.getTypeAtLocation(node);
+              result.push([node, expectedType, node, realType]);
+              continue;
+            }
+          }
+        }
+      }
+    } else if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+      const expectedType = typeChecker.getTypeAtLocation(node.left);
+      const realType = typeChecker.getTypeAtLocation(node.right);
+      result.push([node.left, expectedType, node.right, realType]);
+      continue;
+    } else if (ts.isReturnStatement(node) && node.expression) {
+      const parentDeclaration = yield* option(getAncestorConvertibleDeclaration(node));
+      if (isSome2(parentDeclaration)) {
+        const expectedType = yield* option(getInferredReturnType(parentDeclaration.value));
+        const realType = typeChecker.getTypeAtLocation(node.expression);
+        if (isSome2(expectedType)) {
+          result.push([node, expectedType.value, node, realType]);
+          continue;
+        }
+      }
+    } else if (ts.isArrowFunction(node) && ts.isExpression(node.body)) {
+      const body = node.body;
+      const expectedType = typeChecker.getContextualType(body);
+      const realType = typeChecker.getTypeAtLocation(body);
+      if (expectedType) {
+        result.push([body, expectedType, body, realType]);
+        continue;
+      }
+    } else if (ts.isSatisfiesExpression(node)) {
       const expectedType = typeChecker.getTypeAtLocation(node.type);
       const realType = typeChecker.getTypeAtLocation(node.expression);
-      return [[node.expression, expectedType, node.expression, realType]];
+      result.push([node.expression, expectedType, node.expression, realType]);
+      continue;
     }
-    return [];
-  });
-}
+  }
+  cache.expectedAndRealType.set(sourceFile, result);
+  return result;
+});
 
 // src/utils/TypeParser.ts
 var TypeParserIssue = class extends TaggedError("@effect/language-service/TypeParserIssue") {
@@ -2988,23 +3483,21 @@ function covariantTypeArgument(type) {
   }
   return succeed(signatures[0].getReturnType());
 }
-function pipeableType(type, atLocation) {
-  return gen2(function* () {
-    const typeChecker = yield* service(TypeCheckerApi);
-    const pipeSymbol = typeChecker.getPropertyOfType(type, "pipe");
-    if (!pipeSymbol) {
-      return yield* typeParserIssue("Type has no 'pipe' property", type, atLocation);
-    }
-    const pipeType = typeChecker.getTypeOfSymbolAtLocation(pipeSymbol, atLocation);
-    const signatures = pipeType.getCallSignatures();
-    if (signatures.length === 0) {
-      return yield* typeParserIssue("'pipe' property is not callable", type, atLocation);
-    }
-    return type;
-  });
-}
-function varianceStructCovariantType(type, atLocation, propertyName) {
-  return gen2(function* () {
+var pipeableType = fn("TypeParser.pipeableType")(function* (type, atLocation) {
+  const typeChecker = yield* service(TypeCheckerApi);
+  const pipeSymbol = typeChecker.getPropertyOfType(type, "pipe");
+  if (!pipeSymbol) {
+    return yield* typeParserIssue("Type has no 'pipe' property", type, atLocation);
+  }
+  const pipeType = typeChecker.getTypeOfSymbolAtLocation(pipeSymbol, atLocation);
+  const signatures = pipeType.getCallSignatures();
+  if (signatures.length === 0) {
+    return yield* typeParserIssue("'pipe' property is not callable", type, atLocation);
+  }
+  return type;
+});
+var varianceStructCovariantType = fn("TypeParser.varianceStructCovariantType")(
+  function* (type, atLocation, propertyName) {
     const typeChecker = yield* service(TypeCheckerApi);
     const propertySymbol = typeChecker.getPropertyOfType(type, propertyName);
     if (!propertySymbol) {
@@ -3012,82 +3505,108 @@ function varianceStructCovariantType(type, atLocation, propertyName) {
     }
     const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
     return yield* covariantTypeArgument(propertyType);
-  });
-}
-function effectVarianceStruct(type, atLocation) {
-  return gen2(function* () {
-    return {
-      A: yield* varianceStructCovariantType(type, atLocation, "_A"),
-      E: yield* varianceStructCovariantType(type, atLocation, "_E"),
-      R: yield* varianceStructCovariantType(type, atLocation, "_R")
-    };
-  });
-}
-function effectType(type, atLocation) {
-  return gen2(function* () {
-    const typeChecker = yield* service(TypeCheckerApi);
-    yield* pipeableType(type, atLocation);
-    for (const propertySymbol of typeChecker.getPropertiesOfType(type)) {
-      const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
-      const varianceArgs = yield* option(effectVarianceStruct(
-        propertyType,
-        atLocation
-      ));
-      if (isSome2(varianceArgs)) {
-        return varianceArgs.value;
-      }
-    }
-    return yield* typeParserIssue("Type has no effect variance struct", type, atLocation);
-  });
-}
-function fiberType(type, atLocation) {
-  return gen2(function* () {
-    const typeChecker = yield* service(TypeCheckerApi);
-    const awaitSymbol = typeChecker.getPropertyOfType(type, "await");
-    const pollSymbol = typeChecker.getPropertyOfType(type, "poll");
-    if (!awaitSymbol || !pollSymbol) {
-      return yield* typeParserIssue(
-        "Type is not a fiber because it does not have 'await' or 'poll' property",
-        type,
-        atLocation
-      );
-    }
-    return yield* effectType(type, atLocation);
-  });
-}
-function effectSubtype(type, atLocation) {
-  return gen2(function* () {
-    const typeChecker = yield* service(TypeCheckerApi);
-    const tagSymbol = typeChecker.getPropertyOfType(type, "_tag");
-    if (!tagSymbol) {
-      return yield* typeParserIssue(
-        "Type is not a subtype of effect because it does not have '_tag' property",
-        type,
-        atLocation
-      );
-    }
-    return yield* effectType(type, atLocation);
-  });
-}
-function importedEffectModule(node) {
-  return gen2(function* () {
-    const ts = yield* service(TypeScriptApi);
-    const typeChecker = yield* service(TypeCheckerApi);
-    const type = typeChecker.getTypeAtLocation(node);
-    const propertySymbol = typeChecker.getPropertyOfType(type, "never");
-    if (!propertySymbol) {
-      return yield* typeParserIssue("Type has no 'never' property", type, node);
-    }
-    if (!ts.isExpression(node)) {
-      return yield* typeParserIssue("Node is not an expression", type, node);
+  }
+);
+var effectVarianceStruct = fn("TypeParser.effectVarianceStruct")(function* (type, atLocation) {
+  return {
+    A: yield* varianceStructCovariantType(type, atLocation, "_A"),
+    E: yield* varianceStructCovariantType(type, atLocation, "_E"),
+    R: yield* varianceStructCovariantType(type, atLocation, "_R")
+  };
+});
+var effectType = fn("TypeParser.effectType")(function* (type, atLocation) {
+  const ts = yield* service(TypeScriptApi);
+  const typeChecker = yield* service(TypeCheckerApi);
+  yield* pipeableType(type, atLocation);
+  const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
+    (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional)
+  );
+  propertiesSymbols.sort((a, b) => b.name.indexOf("EffectTypeId") - a.name.indexOf("EffectTypeId"));
+  for (const propertySymbol of propertiesSymbols) {
+    const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
+    const varianceArgs = yield* option(effectVarianceStruct(
+      propertyType,
+      atLocation
+    ));
+    if (isSome2(varianceArgs)) {
+      return varianceArgs.value;
     }
-    const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, node);
-    yield* effectType(propertyType, node);
-    return node;
-  });
-}
-function effectGen(node) {
-  return gen2(function* () {
+  }
+  return yield* typeParserIssue("Type has no effect variance struct", type, atLocation);
+});
+var fiberType = fn("TypeParser.fiberType")(function* (type, atLocation) {
+  const typeChecker = yield* service(TypeCheckerApi);
+  const awaitSymbol = typeChecker.getPropertyOfType(type, "await");
+  const pollSymbol = typeChecker.getPropertyOfType(type, "poll");
+  if (!awaitSymbol || !pollSymbol) {
+    return yield* typeParserIssue(
+      "Type is not a fiber because it does not have 'await' or 'poll' property",
+      type,
+      atLocation
+    );
+  }
+  return yield* effectType(type, atLocation);
+});
+var effectSubtype = fn("TypeParser.effectSubtype")(function* (type, atLocation) {
+  const typeChecker = yield* service(TypeCheckerApi);
+  const tagSymbol = typeChecker.getPropertyOfType(type, "_tag");
+  if (!tagSymbol) {
+    return yield* typeParserIssue(
+      "Type is not a subtype of effect because it does not have '_tag' property",
+      type,
+      atLocation
+    );
+  }
+  return yield* effectType(type, atLocation);
+});
+var importedEffectModule = fn("TypeParser.importedEffectModule")(function* (node) {
+  const ts = yield* service(TypeScriptApi);
+  const typeChecker = yield* service(TypeCheckerApi);
+  const type = typeChecker.getTypeAtLocation(node);
+  const propertySymbol = typeChecker.getPropertyOfType(type, "never");
+  if (!propertySymbol) {
+    return yield* typeParserIssue("Type has no 'never' property", type, node);
+  }
+  if (!ts.isExpression(node)) {
+    return yield* typeParserIssue("Node is not an expression", type, node);
+  }
+  const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, node);
+  yield* effectType(propertyType, node);
+  return node;
+});
+var effectGen = fn("TypeParser.effectGen")(function* (node) {
+  const ts = yield* service(TypeScriptApi);
+  if (!ts.isCallExpression(node)) {
+    return yield* typeParserIssue("Node is not a call expression", void 0, node);
+  }
+  if (node.arguments.length === 0) {
+    return yield* typeParserIssue("Node has no arguments", void 0, node);
+  }
+  const generatorFunction = node.arguments[0];
+  if (!ts.isFunctionExpression(generatorFunction)) {
+    return yield* typeParserIssue("Node is not a function expression", void 0, node);
+  }
+  if (generatorFunction.asteriskToken === void 0) {
+    return yield* typeParserIssue("Node is not a generator function", void 0, node);
+  }
+  if (!ts.isPropertyAccessExpression(node.expression)) {
+    return yield* typeParserIssue("Node is not a property access expression", void 0, node);
+  }
+  const propertyAccess = node.expression;
+  if (propertyAccess.name.text !== "gen") {
+    return yield* typeParserIssue("Call expression name is not 'gen'", void 0, node);
+  }
+  const effectModule = yield* importedEffectModule(propertyAccess.expression);
+  return {
+    node,
+    effectModule,
+    generatorFunction,
+    body: generatorFunction.body,
+    functionStar: generatorFunction.getFirstToken()
+  };
+});
+var effectFnUntracedGen = fn("TypeParser.effectFnUntracedGen")(
+  function* (node) {
     const ts = yield* service(TypeScriptApi);
     if (!ts.isCallExpression(node)) {
       return yield* typeParserIssue("Node is not a call expression", void 0, node);
@@ -3100,14 +3619,26 @@ function effectGen(node) {
       return yield* typeParserIssue("Node is not a function expression", void 0, node);
     }
     if (generatorFunction.asteriskToken === void 0) {
-      return yield* typeParserIssue("Node is not a generator function", void 0, node);
+      return yield* typeParserIssue(
+        "Node is not a generator function",
+        void 0,
+        node
+      );
     }
     if (!ts.isPropertyAccessExpression(node.expression)) {
-      return yield* typeParserIssue("Node is not a property access expression", void 0, node);
+      return yield* typeParserIssue(
+        "Node is not a property access expression",
+        void 0,
+        node
+      );
     }
     const propertyAccess = node.expression;
-    if (propertyAccess.name.text !== "gen") {
-      return yield* typeParserIssue("Call expression name is not 'gen'", void 0, node);
+    if (propertyAccess.name.text !== "fnUntraced") {
+      return yield* typeParserIssue(
+        "Call expression name is not 'fnUntraced'",
+        void 0,
+        node
+      );
     }
     const effectModule = yield* importedEffectModule(propertyAccess.expression);
     return {
@@ -3117,127 +3648,77 @@ function effectGen(node) {
       body: generatorFunction.body,
       functionStar: generatorFunction.getFirstToken()
     };
-  });
-}
-function effectFnUntracedGen(node) {
-  return gen2(function* () {
-    const ts = yield* service(TypeScriptApi);
-    if (!ts.isCallExpression(node)) {
-      return yield* typeParserIssue("Node is not a call expression", void 0, node);
-    }
-    if (node.arguments.length === 0) {
-      return yield* typeParserIssue("Node has no arguments", void 0, node);
-    }
-    const generatorFunction = node.arguments[0];
-    if (!ts.isFunctionExpression(generatorFunction)) {
-      return yield* typeParserIssue("Node is not a function expression", void 0, node);
-    }
-    if (generatorFunction.asteriskToken === void 0) {
-      return yield* typeParserIssue(
-        "Node is not a generator function",
-        void 0,
-        node
-      );
-    }
-    if (!ts.isPropertyAccessExpression(node.expression)) {
-      return yield* typeParserIssue(
-        "Node is not a property access expression",
-        void 0,
-        node
-      );
-    }
-    const propertyAccess = node.expression;
-    if (propertyAccess.name.text !== "fnUntraced") {
-      return yield* typeParserIssue(
-        "Call expression name is not 'fnUntraced'",
-        void 0,
-        node
-      );
-    }
-    const effectModule = yield* importedEffectModule(propertyAccess.expression);
-    return {
-      node,
-      effectModule,
-      generatorFunction,
-      body: generatorFunction.body,
-      functionStar: generatorFunction.getFirstToken()
-    };
-  });
-}
-function effectFnGen(node) {
-  return gen2(function* () {
-    const ts = yield* service(TypeScriptApi);
-    if (!ts.isCallExpression(node)) {
-      return yield* typeParserIssue("Node is not a call expression", void 0, node);
-    }
-    if (node.arguments.length === 0) {
-      return yield* typeParserIssue("Node has no arguments", void 0, node);
-    }
-    const generatorFunction = node.arguments[0];
-    if (!ts.isFunctionExpression(generatorFunction)) {
-      return yield* typeParserIssue(
-        "Node is not a function expression",
-        void 0,
-        node
-      );
-    }
-    if (generatorFunction.asteriskToken === void 0) {
-      return yield* typeParserIssue(
-        "Node is not a generator function",
-        void 0,
-        node
-      );
-    }
-    const expressionToTest = ts.isCallExpression(node.expression) ? node.expression.expression : node.expression;
-    if (!ts.isPropertyAccessExpression(expressionToTest)) {
-      return yield* typeParserIssue(
-        "Node is not a property access expression",
-        void 0,
-        node
-      );
-    }
-    const propertyAccess = expressionToTest;
-    if (propertyAccess.name.text !== "fn") {
-      return yield* typeParserIssue(
-        "Call expression name is not 'fn'",
-        void 0,
-        node
-      );
-    }
-    const effectModule = yield* importedEffectModule(propertyAccess.expression);
-    return {
-      node,
-      generatorFunction,
-      effectModule,
-      body: generatorFunction.body,
-      functionStar: generatorFunction.getFirstToken()
-    };
-  });
-}
-function returnYieldEffectBlock(body) {
-  return gen2(function* () {
-    const ts = yield* service(TypeScriptApi);
-    const typeChecker = yield* service(TypeCheckerApi);
-    if (!ts.isBlock(body)) return yield* typeParserIssue("Node is not a block", void 0, body);
-    if (body.statements.length === 1 && ts.isReturnStatement(body.statements[0]) && body.statements[0].expression && ts.isYieldExpression(body.statements[0].expression) && body.statements[0].expression.expression) {
-      const nodeToCheck = body.statements[0].expression.expression;
-      const type = typeChecker.getTypeAtLocation(nodeToCheck);
-      yield* effectType(type, nodeToCheck);
-      return nodeToCheck;
-    }
+  }
+);
+var effectFnGen = fn("TypeParser.effectFnGen")(function* (node) {
+  const ts = yield* service(TypeScriptApi);
+  if (!ts.isCallExpression(node)) {
+    return yield* typeParserIssue("Node is not a call expression", void 0, node);
+  }
+  if (node.arguments.length === 0) {
+    return yield* typeParserIssue("Node has no arguments", void 0, node);
+  }
+  const generatorFunction = node.arguments[0];
+  if (!ts.isFunctionExpression(generatorFunction)) {
     return yield* typeParserIssue(
-      "Node is not a return statement with a yield expression",
+      "Node is not a function expression",
       void 0,
-      body
+      node
     );
-  });
-}
+  }
+  if (generatorFunction.asteriskToken === void 0) {
+    return yield* typeParserIssue(
+      "Node is not a generator function",
+      void 0,
+      node
+    );
+  }
+  const expressionToTest = ts.isCallExpression(node.expression) ? node.expression.expression : node.expression;
+  if (!ts.isPropertyAccessExpression(expressionToTest)) {
+    return yield* typeParserIssue(
+      "Node is not a property access expression",
+      void 0,
+      node
+    );
+  }
+  const propertyAccess = expressionToTest;
+  if (propertyAccess.name.text !== "fn") {
+    return yield* typeParserIssue(
+      "Call expression name is not 'fn'",
+      void 0,
+      node
+    );
+  }
+  const effectModule = yield* importedEffectModule(propertyAccess.expression);
+  return {
+    node,
+    generatorFunction,
+    effectModule,
+    body: generatorFunction.body,
+    functionStar: generatorFunction.getFirstToken()
+  };
+});
+var returnYieldEffectBlock = fn("TypeParser.returnYieldEffectBlock")(function* (body) {
+  const ts = yield* service(TypeScriptApi);
+  const typeChecker = yield* service(TypeCheckerApi);
+  if (ts.isBlock(body) && body.statements.length === 1 && ts.isReturnStatement(body.statements[0]) && body.statements[0].expression && ts.isYieldExpression(body.statements[0].expression) && body.statements[0].expression.expression) {
+    const nodeToCheck = body.statements[0].expression.expression;
+    const type = typeChecker.getTypeAtLocation(nodeToCheck);
+    yield* effectType(type, nodeToCheck);
+    return nodeToCheck;
+  }
+  return yield* typeParserIssue(
+    "Node is not a return statement with a yield expression",
+    void 0,
+    body
+  );
+});
 
 // src/diagnostics/floatingEffect.ts
 var floatingEffect = createDiagnostic({
   name: "effect/floatingEffect",
   code: 3,
-  apply: (sourceFile) => gen2(function* () {
+  apply: fn("floatingEffect.apply")(function* (sourceFile) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
     function isFloatingExpression(node) {
@@ -3270,7 +3751,8 @@ var floatingEffect = createDiagnostic({
           effectDiagnostics.push({
             node,
             category: ts.DiagnosticCategory.Error,
-            messageText: `Effect must be yielded or assigned to a variable.`
+            messageText: `Effect must be yielded or assigned to a variable.`,
+            fix: none2()
           });
         }
       }
@@ -3283,57 +3765,48 @@ var floatingEffect = createDiagnostic({
 var missingEffectContext = createDiagnostic({
   name: "effect/missingEffectContext",
   code: 1,
-  apply: (sourceFile) => gen2(function* () {
+  apply: fn("missingEffectContext.apply")(function* (sourceFile) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeOrder = yield* deterministicTypeOrder;
-    function checkForMissingContextTypes(node, expectedType, valueNode, realType) {
-      return gen2(function* () {
-        const expectedEffect = yield* effectType(
-          expectedType,
-          node
-        );
-        const realEffect = yield* effectType(
-          realType,
-          valueNode
-        );
-        return yield* getMissingTypeEntriesInTargetType(
-          realEffect.R,
-          expectedEffect.R
-        );
-      });
-    }
+    const checkForMissingContextTypes = fn(
+      "missingEffectContext.apply.checkForMissingContextTypes"
+    )(function* (node, expectedType, valueNode, realType) {
+      const expectedEffect = yield* effectType(
+        expectedType,
+        node
+      );
+      const realEffect = yield* effectType(
+        realType,
+        valueNode
+      );
+      return yield* getMissingTypeEntriesInTargetType(
+        realEffect.R,
+        expectedEffect.R
+      );
+    });
     const effectDiagnostics = [];
     const sortTypes = sort(typeOrder);
-    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 entries = yield* expectedAndRealType(node);
-      for (const [node2, expectedType, valueNode, realType] of entries) {
-        const missingContext = yield* pipe(
-          checkForMissingContextTypes(
-            node2,
-            expectedType,
-            valueNode,
-            realType
-          ),
-          orElse3(() => succeed([]))
+    const entries = yield* expectedAndRealType(sourceFile);
+    for (const [node, expectedType, valueNode, realType] of entries) {
+      const missingContext = yield* pipe(
+        checkForMissingContextTypes(
+          node,
+          expectedType,
+          valueNode,
+          realType
+        ),
+        orElse3(() => succeed([]))
+      );
+      if (missingContext.length > 0) {
+        effectDiagnostics.push(
+          {
+            node,
+            category: ts.DiagnosticCategory.Error,
+            messageText: `Missing '${sortTypes(missingContext).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect context.`,
+            fix: none2()
+          }
         );
-        if (missingContext.length > 0) {
-          effectDiagnostics.push(
-            {
-              node: node2,
-              category: ts.DiagnosticCategory.Error,
-              messageText: `Missing '${sortTypes(missingContext).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect context.`
-            }
-          );
-        }
       }
     }
     return effectDiagnostics;
@@ -3344,410 +3817,187 @@ var missingEffectContext = createDiagnostic({
 var missingEffectError = createDiagnostic({
   name: "effect/missingEffectError",
   code: 1,
-  apply: (sourceFile) => gen2(function* () {
+  apply: fn("missingEffectError.apply")(function* (sourceFile) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeOrder = yield* deterministicTypeOrder;
-    function checkForMissingErrorTypes(node, expectedType, valueNode, realType) {
-      return gen2(function* () {
+    const checkForMissingErrorTypes = fn("missingEffectError.apply.checkForMissingErrorTypes")(
+      function* (node, expectedType, valueNode, realType) {
         const expectedEffect = yield* effectType(
           expectedType,
           node
         );
         const realEffect = yield* effectType(
-          realType,
-          valueNode
-        );
-        return yield* getMissingTypeEntriesInTargetType(
-          realEffect.E,
-          expectedEffect.E
-        );
-      });
-    }
-    const effectDiagnostics = [];
-    const sortTypes = sort(typeOrder);
-    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 entries = yield* expectedAndRealType(node);
-      for (const [node2, expectedType, valueNode, realType] of entries) {
-        const missingContext = yield* pipe(
-          checkForMissingErrorTypes(
-            node2,
-            expectedType,
-            valueNode,
-            realType
-          ),
-          orElse3(() => succeed([]))
-        );
-        if (missingContext.length > 0) {
-          effectDiagnostics.push(
-            {
-              node: node2,
-              category: ts.DiagnosticCategory.Error,
-              messageText: `Missing '${sortTypes(missingContext).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect errors.`
-            }
-          );
-        }
-      }
-    }
-    return effectDiagnostics;
-  })
-});
-
-// src/diagnostics/missingStarInYieldEffectGen.ts
-var missingStarInYieldEffectGen = createDiagnostic({
-  name: "effect/missingStarInYieldEffectGen",
-  code: 4,
-  apply: (sourceFile) => gen2(function* () {
-    const ts = yield* service(TypeScriptApi);
-    const typeChecker = yield* service(TypeCheckerApi);
-    const effectDiagnostics = [];
-    const brokenGenerators = /* @__PURE__ */ new Set();
-    const brokenYields = /* @__PURE__ */ new Set();
-    const nodeToVisit = [];
-    const appendNodeToVisit = (functionStarNode) => (node) => {
-      nodeToVisit.push([node, functionStarNode]);
-      return void 0;
-    };
-    ts.forEachChild(sourceFile, appendNodeToVisit(void 0));
-    while (nodeToVisit.length > 0) {
-      const [node, functionStarNode] = nodeToVisit.shift();
-      if (functionStarNode && ts.isYieldExpression(node) && node.expression && node.asteriskToken === void 0) {
-        const type = typeChecker.getTypeAtLocation(node.expression);
-        const effect = yield* option(effectType(type, node.expression));
-        if (isSome2(effect)) {
-          brokenGenerators.add(functionStarNode);
-          brokenYields.add(node);
-        }
-      }
-      const effectGenLike = yield* pipe(
-        effectGen(node),
-        orElse3(() => effectFnUntracedGen(node)),
-        orElse3(() => effectFnGen(node)),
-        option
-      );
-      if (isSome2(effectGenLike)) {
-        ts.forEachChild(
-          effectGenLike.value.body,
-          appendNodeToVisit(effectGenLike.value.functionStar)
-        );
-      } else if ((ts.isFunctionExpression(node) || ts.isMethodDeclaration(node)) && node.asteriskToken !== void 0) {
-        ts.forEachChild(node, appendNodeToVisit(void 0));
-      } else {
-        ts.forEachChild(node, appendNodeToVisit(functionStarNode));
-      }
-    }
-    brokenGenerators.forEach(
-      (node) => effectDiagnostics.push({
-        node,
-        category: ts.DiagnosticCategory.Error,
-        messageText: `Seems like you used yield instead of yield* inside this Effect.gen.`
-      })
-    );
-    brokenYields.forEach(
-      (node) => effectDiagnostics.push({
-        node,
-        category: ts.DiagnosticCategory.Error,
-        messageText: `When yielding Effects inside Effect.gen, you should use yield* instead of yield.`
-      })
-    );
-    return effectDiagnostics;
-  })
-});
-
-// src/diagnostics/unnecessaryEffectGen.ts
-var unnecessaryEffectGen = createDiagnostic({
-  name: "effect/unnecessaryEffectGen",
-  code: 5,
-  apply: (sourceFile) => gen2(function* () {
-    const ts = yield* service(TypeScriptApi);
-    const effectDiagnostics = [];
-    const brokenGenerators = /* @__PURE__ */ new Set();
-    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 maybeUnnecessaryGen = yield* pipe(
-        effectGen(node),
-        flatMap4(({ body }) => returnYieldEffectBlock(body)),
-        option
-      );
-      if (isSome2(maybeUnnecessaryGen)) {
-        brokenGenerators.add(node);
-      }
-    }
-    brokenGenerators.forEach(
-      (node) => effectDiagnostics.push({
-        node,
-        category: ts.DiagnosticCategory.Suggestion,
-        messageText: `This Effect.gen is useless here because it only contains a single return statement.`
-      })
-    );
-    return effectDiagnostics;
-  })
-});
-
-// src/diagnostics.ts
-var diagnostics = [
-  missingEffectContext,
-  missingEffectError,
-  floatingEffect,
-  missingStarInYieldEffectGen,
-  unnecessaryEffectGen
-];
-
-// src/utils/AST.ts
-function collectSelfAndAncestorNodesInRange(node, textRange) {
-  return sync(() => {
-    let result = empty();
-    let parent = node;
-    while (parent) {
-      if (parent.end >= textRange.end) {
-        result = pipe(result, append(parent));
-      }
-      parent = parent.parent;
-    }
-    return result;
-  });
-}
-function getAncestorNodesInRange(sourceFile, textRange) {
-  return gen2(function* () {
-    const ts = yield* service(TypeScriptApi);
-    const precedingToken = ts.findPrecedingToken(textRange.pos, sourceFile);
-    if (!precedingToken) return empty();
-    return yield* collectSelfAndAncestorNodesInRange(precedingToken, textRange);
-  });
-}
-var NodeNotFoundError = class extends TaggedError("@effect/language-service/NodeNotFoundError") {
-};
-function findNodeAtPosition(sourceFile, position) {
-  return gen2(function* () {
-    const ts = yield* service(TypeScriptApi);
-    function find(node) {
-      if (position >= node.getStart() && position < node.getEnd()) {
-        return ts.forEachChild(node, find) || node;
-      }
-      return void 0;
-    }
-    const result = find(sourceFile);
-    if (!result) return yield* fail3(new NodeNotFoundError());
-    return result;
-  });
-}
-function collectDescendantsAndAncestorsInRange(sourceFile, textRange) {
-  return gen2(function* () {
-    const nodeAtPosition = yield* option(findNodeAtPosition(sourceFile, textRange.pos));
-    if (isNone2(nodeAtPosition)) return empty();
-    return yield* collectSelfAndAncestorNodesInRange(nodeAtPosition.value, textRange);
-  });
-}
-function toTextRange(positionOrRange) {
-  return typeof positionOrRange === "number" ? { end: positionOrRange, pos: positionOrRange } : positionOrRange;
-}
-function isNodeInRange(textRange) {
-  return (node) => node.pos <= textRange.pos && node.end >= textRange.end;
-}
-function transformAsyncAwaitToEffectGen(node, effectModuleName, onAwait) {
-  return gen2(function* () {
-    const ts = yield* service(TypeScriptApi);
-    function visitor(_) {
-      if (ts.isAwaitExpression(_)) {
-        const expression = ts.visitEachChild(_.expression, visitor, ts.nullTransformationContext);
-        return ts.factory.createYieldExpression(
-          ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
-          onAwait(expression)
-        );
-      }
-      return ts.visitEachChild(_, visitor, ts.nullTransformationContext);
-    }
-    const generatorBody = visitor(node.body);
-    const generator = ts.factory.createFunctionExpression(
-      void 0,
-      ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
-      void 0,
-      [],
-      [],
-      void 0,
-      generatorBody
-      // NOTE(mattia): intended, to use same routine for both ConciseBody and Body
-    );
-    const effectGenCallExp = ts.factory.createCallExpression(
-      ts.factory.createPropertyAccessExpression(
-        ts.factory.createIdentifier(effectModuleName),
-        "gen"
-      ),
-      void 0,
-      [generator]
-    );
-    let currentFlags = ts.getCombinedModifierFlags(node);
-    currentFlags &= ~ts.ModifierFlags.Async;
-    const newModifiers = ts.factory.createModifiersFromModifierFlags(currentFlags);
-    if (ts.isArrowFunction(node)) {
-      return ts.factory.createArrowFunction(
-        newModifiers,
-        node.typeParameters,
-        node.parameters,
-        void 0,
-        node.equalsGreaterThanToken,
-        effectGenCallExp
-      );
-    }
-    const newBody = ts.factory.createBlock([
-      ts.factory.createReturnStatement(effectGenCallExp)
-    ]);
-    if (ts.isFunctionDeclaration(node)) {
-      return ts.factory.createFunctionDeclaration(
-        newModifiers,
-        node.asteriskToken,
-        node.name,
-        node.typeParameters,
-        node.parameters,
-        void 0,
-        newBody
-      );
-    }
-    return ts.factory.createFunctionExpression(
-      newModifiers,
-      node.asteriskToken,
-      node.name,
-      node.typeParameters,
-      node.parameters,
-      void 0,
-      newBody
-    );
-  });
-}
-function addReturnTypeAnnotation(sourceFile, declaration, typeNode) {
-  return gen2(function* () {
-    const ts = yield* service(TypeScriptApi);
-    const changes = yield* service(ChangeTracker);
-    const closeParen = ts.findChildOfKind(declaration, ts.SyntaxKind.CloseParenToken, sourceFile);
-    const needParens = ts.isArrowFunction(declaration) && closeParen === void 0;
-    const endNode = needParens ? declaration.parameters[0] : closeParen;
-    if (endNode) {
-      if (needParens) {
-        changes.insertNodeBefore(
-          sourceFile,
-          endNode,
-          ts.factory.createToken(ts.SyntaxKind.OpenParenToken)
+          realType,
+          valueNode
         );
-        changes.insertNodeAfter(
-          sourceFile,
-          endNode,
-          ts.factory.createToken(ts.SyntaxKind.CloseParenToken)
+        return yield* getMissingTypeEntriesInTargetType(
+          realEffect.E,
+          expectedEffect.E
+        );
+      }
+    );
+    const effectDiagnostics = [];
+    const sortTypes = sort(typeOrder);
+    const entries = yield* expectedAndRealType(sourceFile);
+    for (const [node, expectedType, valueNode, realType] of entries) {
+      const missingContext = yield* pipe(
+        checkForMissingErrorTypes(
+          node,
+          expectedType,
+          valueNode,
+          realType
+        ),
+        orElse3(() => succeed([]))
+      );
+      if (missingContext.length > 0) {
+        effectDiagnostics.push(
+          {
+            node,
+            category: ts.DiagnosticCategory.Error,
+            messageText: `Missing '${sortTypes(missingContext).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect errors.`,
+            fix: none2()
+          }
         );
       }
-      changes.insertNodeAt(sourceFile, endNode.end, typeNode, { prefix: ": " });
-    }
-  });
-}
-function removeReturnTypeAnnotation(sourceFile, declaration) {
-  return gen2(function* () {
-    const ts = yield* service(TypeScriptApi);
-    const changes = yield* service(ChangeTracker);
-    const closeParen = ts.findChildOfKind(declaration, ts.SyntaxKind.CloseParenToken, sourceFile);
-    const needParens = ts.isArrowFunction(declaration) && closeParen === void 0;
-    const endNode = needParens ? declaration.parameters[0] : closeParen;
-    if (endNode && declaration.type) {
-      changes.deleteRange(sourceFile, { pos: endNode.end, end: declaration.type.end });
     }
-  });
-}
-var ImportModuleIdentifierNotFoundError = class extends TaggedError("@effect/language-service/ImportModuleIdentifierNotFoundError") {
-};
-function findImportedModuleIdentifier(sourceFile, test) {
-  return gen2(function* () {
+    return effectDiagnostics;
+  })
+});
+
+// src/diagnostics/missingStarInYieldEffectGen.ts
+var missingStarInYieldEffectGen = createDiagnostic({
+  name: "effect/missingStarInYieldEffectGen",
+  code: 4,
+  apply: fn("missingStarInYieldEffectGen.apply")(function* (sourceFile) {
     const ts = yield* service(TypeScriptApi);
-    for (const statement of sourceFile.statements) {
-      if (!ts.isImportDeclaration(statement)) continue;
-      const importClause = statement.importClause;
-      if (!importClause) continue;
-      const namedBindings = importClause.namedBindings;
-      if (!namedBindings) continue;
-      if (ts.isNamespaceImport(namedBindings)) {
-        if (yield* test(namedBindings.name)) return namedBindings.name;
-      } else if (ts.isNamedImports(namedBindings)) {
-        for (const importSpecifier of namedBindings.elements) {
-          if (yield* test(importSpecifier.name)) return importSpecifier.name;
+    const typeChecker = yield* service(TypeCheckerApi);
+    const effectDiagnostics = [];
+    const brokenGenerators = /* @__PURE__ */ new Set();
+    const brokenYields = /* @__PURE__ */ new Set();
+    const nodeToVisit = [];
+    const appendNodeToVisit = (functionStarNode) => (node) => {
+      nodeToVisit.push([node, functionStarNode]);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit(void 0));
+    while (nodeToVisit.length > 0) {
+      const [node, functionStarNode] = nodeToVisit.shift();
+      if (functionStarNode && ts.isYieldExpression(node) && node.expression && node.asteriskToken === void 0) {
+        const type = typeChecker.getTypeAtLocation(node.expression);
+        const effect = yield* option(effectType(type, node.expression));
+        if (isSome2(effect)) {
+          brokenGenerators.add(functionStarNode);
+          brokenYields.add(node);
         }
       }
-    }
-    return yield* fail3(new ImportModuleIdentifierNotFoundError());
-  });
-}
-function simplifyTypeNode(typeNode) {
-  function collectCallable(ts, typeNode2) {
-    if (ts.isParenthesizedTypeNode(typeNode2)) return collectCallable(ts, typeNode2.type);
-    if (ts.isFunctionTypeNode(typeNode2)) {
-      return some2([
-        ts.factory.createCallSignature(typeNode2.typeParameters, typeNode2.parameters, typeNode2.type)
-      ]);
-    }
-    if (ts.isTypeLiteralNode(typeNode2)) {
-      const allCallSignatures = typeNode2.members.every(ts.isCallSignatureDeclaration);
-      if (allCallSignatures) {
-        return some2(typeNode2.members);
-      }
-    }
-    if (ts.isIntersectionTypeNode(typeNode2)) {
-      const members = typeNode2.types.map((node) => collectCallable(ts, node));
-      if (members.every(isSome2)) {
-        return some2(members.map((_) => isSome2(_) ? _.value : []).flat());
+      const effectGenLike = yield* pipe(
+        effectGen(node),
+        orElse3(() => effectFnUntracedGen(node)),
+        orElse3(() => effectFnGen(node)),
+        option
+      );
+      if (isSome2(effectGenLike)) {
+        ts.forEachChild(
+          effectGenLike.value.body,
+          appendNodeToVisit(effectGenLike.value.functionStar)
+        );
+      } else if ((ts.isFunctionExpression(node) || ts.isMethodDeclaration(node)) && node.asteriskToken !== void 0) {
+        ts.forEachChild(node, appendNodeToVisit(void 0));
+      } else {
+        ts.forEachChild(node, appendNodeToVisit(functionStarNode));
       }
     }
-    return none2();
-  }
-  return gen2(function* () {
-    const ts = yield* service(TypeScriptApi);
-    const callSignatures = collectCallable(ts, typeNode);
-    if (isSome2(callSignatures) && callSignatures.value.length > 1) {
-      return ts.factory.createTypeLiteralNode(callSignatures.value);
-    }
-    return typeNode;
-  });
-}
-function tryPreserveDeclarationSemantics(nodeToReplace, node) {
-  return gen2(function* () {
+    brokenGenerators.forEach(
+      (node) => effectDiagnostics.push({
+        node,
+        category: ts.DiagnosticCategory.Error,
+        messageText: `Seems like you used yield instead of yield* inside this Effect.gen.`,
+        fix: none2()
+      })
+    );
+    brokenYields.forEach((node) => {
+      const fix = node.expression ? some2({
+        fixName: "missingStarInYieldEffectGen_fix",
+        description: "Replace yield with yield*",
+        apply: gen2(function* () {
+          const changeTracker = yield* service(ChangeTracker);
+          changeTracker.replaceNode(
+            sourceFile,
+            node,
+            ts.factory.createYieldExpression(
+              ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+              node.expression
+            )
+          );
+        })
+      }) : none2();
+      effectDiagnostics.push({
+        node,
+        category: ts.DiagnosticCategory.Error,
+        messageText: `When yielding Effects inside Effect.gen, you should use yield* instead of yield.`,
+        fix
+      });
+    });
+    return effectDiagnostics;
+  })
+});
+
+// src/diagnostics/unnecessaryEffectGen.ts
+var unnecessaryEffectGen = createDiagnostic({
+  name: "effect/unnecessaryEffectGen",
+  code: 5,
+  apply: fn("unnecessaryEffectGen.apply")(function* (sourceFile) {
     const ts = yield* service(TypeScriptApi);
-    if (!ts.isExpression(node)) return node;
-    if (ts.isFunctionDeclaration(nodeToReplace)) {
-      if (!nodeToReplace.name) return node;
-      return ts.factory.createVariableStatement(
-        nodeToReplace.modifiers,
-        ts.factory.createVariableDeclarationList(
-          [ts.factory.createVariableDeclaration(
-            nodeToReplace.name,
-            void 0,
-            void 0,
-            node
-          )],
-          ts.NodeFlags.Const
-        )
-      );
-    } else if (ts.isMethodDeclaration(nodeToReplace)) {
-      return ts.factory.createPropertyDeclaration(
-        nodeToReplace.modifiers,
-        nodeToReplace.name,
-        void 0,
-        void 0,
-        node
+    const effectDiagnostics = [];
+    const unnecessaryGenerators = /* @__PURE__ */ new Map();
+    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 maybeUnnecessaryGen = yield* pipe(
+        effectGen(node),
+        flatMap4(({ body }) => returnYieldEffectBlock(body)),
+        option
       );
+      if (isSome2(maybeUnnecessaryGen)) {
+        unnecessaryGenerators.set(node, maybeUnnecessaryGen.value);
+      }
     }
-    return node;
-  });
-}
+    unnecessaryGenerators.forEach(
+      (body, node) => effectDiagnostics.push({
+        node,
+        category: ts.DiagnosticCategory.Suggestion,
+        messageText: `This Effect.gen is useless here because it only contains a single return statement.`,
+        fix: some2({
+          fixName: "unnecessaryEffectGen_fix",
+          description: "Remove the Effect.gen, and keep the body",
+          apply: gen2(function* () {
+            const textChanges = yield* service(
+              ChangeTracker
+            );
+            textChanges.replaceNode(sourceFile, node, body);
+          })
+        })
+      })
+    );
+    return effectDiagnostics;
+  })
+});
+
+// src/diagnostics.ts
+var diagnostics = [
+  missingEffectContext,
+  missingEffectError,
+  floatingEffect,
+  missingStarInYieldEffectGen,
+  unnecessaryEffectGen
+];
 
 // src/quickinfo.ts
 var SymbolDisplayPartEq = make(
@@ -4427,12 +4677,89 @@ var init = (modules) => {
     const languageService = info.languageService;
     const pluginOptions = {
       diagnostics: info.config && "diagnostics" in info.config && typeof info.config.diagnostics === "boolean" ? info.config.diagnostics : true,
-      quickinfo: info.config && "quickinfo" in info.config && typeof info.config.quickinfo === "boolean" ? info.config.quickinfo : true
+      quickinfo: info.config && "quickinfo" in info.config && typeof info.config.quickinfo === "boolean" ? info.config.quickinfo : true,
+      completions: info.config && "completions" in info.config && typeof info.config.completions === "boolean" ? info.config.completions : true
     };
     const proxy = /* @__PURE__ */ Object.create(null);
-    for (const k of Object.keys(info.languageService)) {
+    for (const k of Object.keys(languageService)) {
       proxy[k] = (...args) => languageService[k].apply(languageService, args);
     }
+    const diagnosticsErrorCodes = diagnostics.map((diagnostic) => diagnostic.code);
+    try {
+      ;
+      modules.typescript.codefix.registerCodeFix({
+        errorCodes: diagnosticsErrorCodes,
+        getCodeActions: () => void 0
+      });
+    } catch (_) {
+    }
+    proxy.getSupportedCodeFixes = (...args) => languageService.getSupportedCodeFixes(...args).concat(
+      diagnosticsErrorCodes.map((_) => "" + _)
+    );
+    proxy.getCodeFixesAtPosition = (fileName, start, end, errorCodes, formatOptions, preferences, ...args) => {
+      const applicableCodeFixes = languageService.getCodeFixesAtPosition(
+        fileName,
+        start,
+        end,
+        errorCodes,
+        formatOptions,
+        preferences,
+        ...args
+      );
+      const program = languageService.getProgram();
+      if (program) {
+        const sourceFile = program.getSourceFile(fileName);
+        if (sourceFile) {
+          return pipe(
+            gen2(function* () {
+              const effectCodeFixes = [];
+              const applicableFixes = yield* getCodeFixesAtPosition(
+                diagnostics,
+                sourceFile,
+                start,
+                end,
+                errorCodes
+              );
+              const formatContext = modules.typescript.formatting.getFormatContext(
+                formatOptions,
+                info.languageServiceHost
+              );
+              for (const applicableFix of applicableFixes) {
+                const changes = modules.typescript.textChanges.ChangeTracker.with(
+                  {
+                    formatContext,
+                    host: info.languageServiceHost,
+                    preferences: preferences || {}
+                  },
+                  (changeTracker) => pipe(
+                    applicableFix.apply,
+                    provideService(ChangeTracker, changeTracker),
+                    run
+                  )
+                );
+                effectCodeFixes.push({
+                  fixName: applicableFix.fixName,
+                  description: applicableFix.description,
+                  changes
+                });
+              }
+              return effectCodeFixes;
+            }),
+            provideService(TypeCheckerApi, program.getTypeChecker()),
+            provideService(
+              TypeCheckerApiCache,
+              makeTypeCheckerApiCache()
+            ),
+            provideService(TypeScriptApi, modules.typescript),
+            provideService(PluginOptions, pluginOptions),
+            run,
+            Either_exports.map((effectCodeFixes) => applicableCodeFixes.concat(effectCodeFixes)),
+            Either_exports.getOrElse(() => applicableCodeFixes)
+          );
+        }
+      }
+      return applicableCodeFixes;
+    };
     proxy.getSemanticDiagnostics = (fileName, ...args) => {
       const applicableDiagnostics = languageService.getSemanticDiagnostics(fileName, ...args);
       const program = languageService.getProgram();
@@ -4441,8 +4768,12 @@ var init = (modules) => {
         if (sourceFile) {
           return pipe(
             getSemanticDiagnostics(diagnostics, sourceFile),
-            provideService(TypeScriptApi, modules.typescript),
             provideService(TypeCheckerApi, program.getTypeChecker()),
+            provideService(
+              TypeCheckerApiCache,
+              makeTypeCheckerApiCache()
+            ),
+            provideService(TypeScriptApi, modules.typescript),
             provideService(PluginOptions, pluginOptions),
             run,
             Either_exports.map((effectDiagnostics) => effectDiagnostics.concat(applicableDiagnostics)),
@@ -4461,8 +4792,12 @@ var init = (modules) => {
         if (sourceFile) {
           return pipe(
             getApplicableRefactors(refactors, sourceFile, positionOrRange),
-            provideService(TypeScriptApi, modules.typescript),
             provideService(TypeCheckerApi, program.getTypeChecker()),
+            provideService(
+              TypeCheckerApiCache,
+              makeTypeCheckerApiCache()
+            ),
+            provideService(TypeScriptApi, modules.typescript),
             provideService(PluginOptions, pluginOptions),
             run,
             Either_exports.map((effectRefactors) => applicableRefactors.concat(effectRefactors)),
@@ -4503,8 +4838,12 @@ var init = (modules) => {
               );
               return { edits };
             }),
-            provideService(TypeScriptApi, modules.typescript),
             provideService(TypeCheckerApi, program.getTypeChecker()),
+            provideService(
+              TypeCheckerApiCache,
+              makeTypeCheckerApiCache()
+            ),
+            provideService(TypeScriptApi, modules.typescript),
             provideService(PluginOptions, pluginOptions),
             run
           );
@@ -4535,8 +4874,9 @@ var init = (modules) => {
                 position,
                 dedupedTagsQuickInfo
               ),
-              provideService(TypeScriptApi, modules.typescript),
               provideService(TypeCheckerApi, program.getTypeChecker()),
+              provideService(TypeScriptApi, modules.typescript),
+              provideService(PluginOptions, pluginOptions),
               run,
               Either_exports.getOrElse(() => dedupedTagsQuickInfo)
             );
@@ -4546,6 +4886,53 @@ var init = (modules) => {
       }
       return quickInfo;
     };
+    proxy.getCompletionsAtPosition = (fileName, position, options, formattingSettings, ...args) => {
+      const applicableCompletions = languageService.getCompletionsAtPosition(
+        fileName,
+        position,
+        options,
+        formattingSettings,
+        ...args
+      );
+      if (pluginOptions.completions) {
+        const program = languageService.getProgram();
+        if (program) {
+          const sourceFile = program.getSourceFile(fileName);
+          if (sourceFile) {
+            return pipe(
+              getCompletionsAtPosition(
+                completions,
+                sourceFile,
+                position,
+                options,
+                formattingSettings
+              ),
+              provideService(TypeCheckerApi, program.getTypeChecker()),
+              provideService(
+                TypeCheckerApiCache,
+                makeTypeCheckerApiCache()
+              ),
+              provideService(TypeScriptApi, modules.typescript),
+              provideService(PluginOptions, pluginOptions),
+              run,
+              Either_exports.map(
+                (effectCompletions) => applicableCompletions ? {
+                  ...applicableCompletions,
+                  entries: effectCompletions.concat(applicableCompletions.entries)
+                } : effectCompletions.length > 0 ? {
+                  entries: effectCompletions,
+                  isGlobalCompletion: false,
+                  isMemberCompletion: false,
+                  isNewIdentifierLocation: false
+                } : void 0
+              ),
+              Either_exports.getOrElse(() => applicableCompletions)
+            );
+          }
+        }
+      }
+      return applicableCompletions;
+    };
     return proxy;
   }
   return { create };