@effect/language-service 0.18.0 → 0.20.0

package/transform.js

@@ -24,7 +24,7 @@ __export(transform_exports, {
 });
 module.exports = __toCommonJS(transform_exports);
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/Function.js
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Function.js
 var isFunction = (input) => typeof input === "function";
 var dual = function(arity, body) {
   if (typeof arity === "function") {
@@ -118,11 +118,11 @@ function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
   }
 }
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/internal/version.js
-var moduleVersion = "3.16.3";
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/internal/version.js
+var moduleVersion = "3.16.5";
 var getCurrentVersion = () => moduleVersion;
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/GlobalValue.js
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/GlobalValue.js
 var globalStoreId = `effect/GlobalValue/globalStoreId/${/* @__PURE__ */ getCurrentVersion()}`;
 var globalStore;
 var globalValue = (id, compute) => {
@@ -136,7 +136,7 @@ var globalValue = (id, compute) => {
   return globalStore.get(id);
 };
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/Predicate.js
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Predicate.js
 var isString = (input) => typeof input === "string";
 var isNumber = (input) => typeof input === "number";
 var isBoolean = (input) => typeof input === "boolean";
@@ -145,10 +145,10 @@ var isRecordOrArray = (input) => typeof input === "object" && input !== null;
 var isObject = (input) => isRecordOrArray(input) || isFunction2(input);
 var hasProperty = /* @__PURE__ */ dual(2, (self, property) => isObject(self) && property in self);
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/internal/errors.js
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/internal/errors.js
 var getBugErrorMessage = (message) => `BUG: ${message} - please report an issue at https://github.com/Effect-TS/effect/issues`;
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/Utils.js
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Utils.js
 var GenKindTypeId = /* @__PURE__ */ Symbol.for("effect/Gen/GenKind");
 var isGenKind = (u) => isObject(u) && GenKindTypeId in u;
 var GenKindImpl = class {
@@ -277,7 +277,7 @@ var internalCall = isNotOptimizedAway ? standard.effect_internal_function : forc
 var genConstructor = function* () {
 }.constructor;
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/Hash.js
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Hash.js
 var randomHashCache = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/Hash/randomHashCache"), () => /* @__PURE__ */ new WeakMap());
 var symbol = /* @__PURE__ */ Symbol.for("effect/Hash");
 var hash = (self) => {
@@ -376,7 +376,7 @@ var cached = function() {
   return hash2;
 };
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/Equal.js
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Equal.js
 var symbol2 = /* @__PURE__ */ Symbol.for("effect/Equal");
 function equals() {
   if (arguments.length === 1) {
@@ -429,7 +429,7 @@ function compareBoth(self, that) {
 }
 var isEqual = (u) => hasProperty(u, symbol2);
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/Inspectable.js
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Inspectable.js
 var NodeInspectSymbol = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
 var toJSON = (x) => {
   try {
@@ -481,7 +481,7 @@ var redact = (u) => {
   return u;
 };
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/Pipeable.js
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Pipeable.js
 var pipeArguments = (self, args) => {
   switch (args.length) {
     case 0:
@@ -514,10 +514,10 @@ var pipeArguments = (self, args) => {
   }
 };
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/internal/opCodes/effect.js
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/internal/opCodes/effect.js
 var OP_COMMIT = "Commit";
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/internal/effectable.js
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/internal/effectable.js
 var EffectTypeId = /* @__PURE__ */ Symbol.for("effect/Effect");
 var StreamTypeId = /* @__PURE__ */ Symbol.for("effect/Stream");
 var SinkTypeId = /* @__PURE__ */ Symbol.for("effect/Sink");
@@ -604,7 +604,7 @@ var StructuralCommitPrototype = {
   ...StructuralPrototype
 };
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/internal/option.js
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/internal/option.js
 var TypeId = /* @__PURE__ */ Symbol.for("effect/Option");
 var CommonProto = {
   ...EffectPrototype,
@@ -662,7 +662,7 @@ var some = (value) => {
   return a;
 };
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/internal/either.js
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/internal/either.js
 var TypeId2 = /* @__PURE__ */ Symbol.for("effect/Either");
 var CommonProto2 = {
   ...EffectPrototype,
@@ -724,7 +724,7 @@ var right = (right3) => {
   return a;
 };
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/Either.js
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Either.js
 var right2 = right;
 var left2 = left;
 var isLeft2 = isLeft;
@@ -732,17 +732,25 @@ var isRight2 = isRight;
 var map = /* @__PURE__ */ dual(2, (self, f) => isRight2(self) ? right2(f(self.right)) : left2(self.left));
 var getOrElse = /* @__PURE__ */ dual(2, (self, onLeft) => isLeft2(self) ? onLeft(self.left) : self.right);
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/Order.js
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Order.js
 var make = (compare) => (self, that) => self === that ? 0 : compare(self, that);
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/Option.js
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Option.js
 var none2 = () => none;
 var some2 = some;
 var isNone2 = isNone;
 var isSome2 = isSome;
+var match = /* @__PURE__ */ dual(2, (self, {
+  onNone,
+  onSome
+}) => isNone2(self) ? onNone() : onSome(self.value));
+var orElse = /* @__PURE__ */ dual(2, (self, that) => isNone2(self) ? that() : self);
+var fromNullable = (nullableValue) => nullableValue == null ? none2() : some2(nullableValue);
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/Array.js
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Array.js
 var fromIterable = (collection) => Array.isArray(collection) ? collection : Array.from(collection);
+var append = /* @__PURE__ */ dual(2, (self, last) => [...self, last]);
+var appendAll = /* @__PURE__ */ dual(2, (self, that) => fromIterable(self).concat(fromIterable(that)));
 var isArray = Array.isArray;
 var isEmptyArray = (self) => self.length === 0;
 var isEmptyReadonlyArray = isEmptyArray;
@@ -751,6 +759,7 @@ var sort = /* @__PURE__ */ dual(2, (self, O) => {
   out.sort(O);
   return out;
 });
+var empty = () => [];
 var map2 = /* @__PURE__ */ dual(2, (self, f) => self.map(f));
 var flatMap = /* @__PURE__ */ dual(2, (self, f) => {
   if (isEmptyReadonlyArray(self)) {
@@ -858,7 +867,7 @@ var map3 = dual(2, (fa, f) => make2((ctx) => {
   if (result._tag !== "Right") return result;
   return makeInternalSuccess(f(result.value));
 }));
-var orElse = (f) => (fa) => make2((ctx) => {
+var orElse2 = (f) => (fa) => make2((ctx) => {
   const result = fa.run(ctx);
   if (result._tag === "Left") return f(result.value).run(ctx);
   return result;
@@ -928,6 +937,27 @@ function parse(config) {
 var TypeScriptApi = Tag("TypeScriptApi");
 var TypeScriptProgram = Tag("TypeScriptProgram");
 var ChangeTracker = Tag("ChangeTracker");
+function parsePackageContentNameAndVersionFromScope(v) {
+  if (!isObject(v)) return;
+  if (!hasProperty(v, "packageJsonScope")) return;
+  if (!v.packageJsonScope) return;
+  const packageJsonScope = v.packageJsonScope;
+  if (!hasProperty(packageJsonScope, "contents")) return;
+  if (!hasProperty(packageJsonScope.contents, "packageJsonContent")) return;
+  const packageJsonContent = packageJsonScope.contents.packageJsonContent;
+  if (!hasProperty(packageJsonContent, "name")) return;
+  if (!hasProperty(packageJsonContent, "version")) return;
+  const { name, version } = packageJsonContent;
+  if (!isString(name)) return;
+  if (!isString(version)) return;
+  const hasEffectInPeerDependencies = hasProperty(packageJsonContent, "peerDependencies") && isObject(packageJsonContent.peerDependencies) && hasProperty(packageJsonContent.peerDependencies, "effect");
+  return {
+    name: name.toLowerCase(),
+    version: version.toLowerCase(),
+    hasEffectInPeerDependencies,
+    contents: packageJsonContent
+  };
+}
 
 // src/core/LSP.ts
 var RefactorNotApplicableError = class {
@@ -1063,10 +1093,10 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
     const sectionOverrides = {};
     const skippedRules = [];
     const regex = /@effect-diagnostics(-next-line)?((?:\s[a-zA-Z0-9/]+:(?:off|warning|error|message|suggestion|skip-file))+)?/gm;
-    let match;
-    while ((match = regex.exec(sourceFile.text)) !== null) {
-      const nextLineCaptureGroup = match[1];
-      const rulesCaptureGroup = match[2];
+    let match2;
+    while ((match2 = regex.exec(sourceFile.text)) !== null) {
+      const nextLineCaptureGroup = match2[1];
+      const rulesCaptureGroup = match2[2];
       if (rulesCaptureGroup) {
         const trimmedRuleString = rulesCaptureGroup.trim();
         if (trimmedRuleString) {
@@ -1078,7 +1108,7 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
               if (ruleLevel === "skip-file") skippedRules.push(ruleName);
               const isOverrideNextLine = nextLineCaptureGroup && nextLineCaptureGroup.trim().toLowerCase() === "-next-line";
               if (isOverrideNextLine) {
-                const node = findNodeWithLeadingCommentAtPosition(match.index);
+                const node = findNodeWithLeadingCommentAtPosition(match2.index);
                 if (node) {
                   lineOverrides[ruleName] = lineOverrides[ruleName] || [];
                   lineOverrides[ruleName].unshift({
@@ -1090,7 +1120,7 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
               } else {
                 sectionOverrides[ruleName] = sectionOverrides[ruleName] || [];
                 sectionOverrides[ruleName].unshift({
-                  pos: match.index,
+                  pos: match2.index,
                   level: ruleLevel
                 });
               }
@@ -1376,31 +1406,55 @@ var expectedAndRealType = fn("TypeCheckerApi.expectedAndRealType")(function* (so
   cache.expectedAndRealType.set(sourceFile, result);
   return result;
 });
+var appendToUniqueTypesMap = fn(
+  "TypeCheckerApi.appendToUniqueTypesMap"
+)(
+  function* (memory, initialType, excludeNever) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const newIndexes = /* @__PURE__ */ new Set();
+    const knownIndexes = /* @__PURE__ */ new Set();
+    let toTest = [initialType];
+    while (toTest.length > 0) {
+      const type = toTest.pop();
+      if (!type) break;
+      if (excludeNever && type.flags & ts.TypeFlags.Never) {
+        continue;
+      }
+      if (type.isUnion()) {
+        toTest = toTest.concat(type.types);
+      } else {
+        const foundMatch = [];
+        for (const [typeId, knownType] of memory.entries()) {
+          const areSame = typeChecker.isTypeAssignableTo(knownType, type) && typeChecker.isTypeAssignableTo(type, knownType);
+          if (areSame) {
+            foundMatch.push(typeId);
+            break;
+          }
+        }
+        if (foundMatch.length === 0) {
+          const newId = "t" + (memory.size + 1);
+          memory.set(newId, type);
+          newIndexes.add(newId);
+        } else {
+          knownIndexes.add(foundMatch[0]);
+        }
+      }
+    }
+    return {
+      newIndexes,
+      knownIndexes,
+      allIndexes: pipe(
+        fromIterable(newIndexes),
+        appendAll(fromIterable(knownIndexes))
+      )
+    };
+  }
+);
 
 // src/diagnostics/duplicatePackage.ts
 var checkedPackagesCache = /* @__PURE__ */ new Map();
 var programResolvedCacheSize = /* @__PURE__ */ new Map();
-function parsePackageContentNameAndVersion(v) {
-  if (!isObject(v)) return;
-  if (!hasProperty(v, "packageJsonScope")) return;
-  if (!v.packageJsonScope) return;
-  const packageJsonScope = v.packageJsonScope;
-  if (!hasProperty(packageJsonScope, "contents")) return;
-  if (!hasProperty(packageJsonScope.contents, "packageJsonContent")) return;
-  const packageJsonContent = packageJsonScope.contents.packageJsonContent;
-  if (!hasProperty(packageJsonContent, "name")) return;
-  if (!hasProperty(packageJsonContent, "version")) return;
-  const { name, version } = packageJsonContent;
-  if (!isString(name)) return;
-  if (!isString(version)) return;
-  const hasEffectInPeerDependencies = hasProperty(packageJsonContent, "peerDependencies") && isObject(packageJsonContent.peerDependencies) && hasProperty(packageJsonContent.peerDependencies, "effect");
-  return {
-    name: name.toLowerCase(),
-    version: version.toLowerCase(),
-    hasEffectInPeerDependencies,
-    contents: packageJsonContent
-  };
-}
 var duplicatePackage = createDiagnostic({
   name: "duplicatePackage",
   code: 6,
@@ -1417,7 +1471,7 @@ var duplicatePackage = createDiagnostic({
       const seenPackages = /* @__PURE__ */ new Set();
       resolvedPackages = {};
       program.getSourceFiles().map((_) => {
-        const packageInfo = parsePackageContentNameAndVersion(_);
+        const packageInfo = parsePackageContentNameAndVersionFromScope(_);
         if (!packageInfo) return;
         const packageNameAndVersion = packageInfo.name + "@" + packageInfo.version;
         if (seenPackages.has(packageNameAndVersion)) return;
@@ -1447,6 +1501,361 @@ If this is intended set the LSP config "allowedDuplicatedPackages" to ${JSON.str
   })
 });
 
+// src/core/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 getAncestorNodesInRange = fn("AST.getAncestorNodesInRange")(function* (sourceFile, textRange) {
+  const nodeAtPosition = yield* option(findNodeAtPosition(sourceFile, textRange.pos));
+  if (isNone2(nodeAtPosition)) return empty();
+  return yield* collectSelfAndAncestorNodesInRange(nodeAtPosition.value, textRange);
+});
+var NodeNotFoundError = class {
+  _tag = "@effect/language-service/NodeNotFoundError";
+};
+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 void 0;
+  }
+  const result = find(sourceFile);
+  if (!result) return yield* fail(new NodeNotFoundError());
+  return result;
+});
+var getCommentAtPosition = fn("TypeScriptApi.getCommentAtPosition")(function* (sourceFile, pos) {
+  const ts = yield* service(TypeScriptApi);
+  const token = yield* findNodeAtPosition(sourceFile, pos);
+  if (token === void 0 || token.kind === ts.SyntaxKind.JsxText || pos >= token.end - (ts.tokenToString(token.kind) || "").length) {
+    return yield* fail(new NodeNotFoundError());
+  }
+  const startPos = token.pos === 0 ? (ts.getShebang(sourceFile.text) || "").length : token.pos;
+  if (startPos === 0) return yield* fail(new NodeNotFoundError());
+  const result = ts.forEachTrailingCommentRange(sourceFile.text, startPos, isCommentInRange, pos) || ts.forEachLeadingCommentRange(sourceFile.text, startPos, isCommentInRange, pos);
+  if (!result) return yield* fail(new NodeNotFoundError());
+  return result;
+});
+function isCommentInRange(pos, end, kind, _nl, at) {
+  return at >= pos && at < end ? { pos, end, kind } : void 0;
+}
+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);
+    }
+    const generatorBody = visitor(node.body);
+    const effectGenCallExp = yield* createEffectGenCallExpression(effectModuleName, generatorBody);
+    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
+    );
+  }
+);
+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)
+      );
+    }
+    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 {
+  _tag = "@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 = fromNullable(importSpecifier.propertyName).pipe(
+            orElse(() => some2(importSpecifier.name))
+          );
+          if (yield* test(importSpecifier.name, statement.moduleSpecifier, importProperty)) {
+            return importSpecifier.name;
+          }
+        }
+      }
+    }
+    return yield* fail(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.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(node));
+      if (members.every(isSome2)) {
+        return some2(members.map((_) => isSome2(_) ? _.value : []).flat());
+      }
+    }
+    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 parseAccessedExpressionForCompletion = fn(
+  "AST.parseAccessedExpressionForCompletion"
+)(
+  function* (sourceFile, position) {
+    const ts = yield* service(TypeScriptApi);
+    const precedingToken = ts.findPrecedingToken(position, sourceFile, void 0, true);
+    if (!precedingToken) return yield* fail(new NodeNotFoundError());
+    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 yield* fail(new NodeNotFoundError());
+    }
+    return { accessedObject, outerNode, replacementSpan };
+  }
+);
+var parseDataForExtendsClassCompletion = fn(
+  "AST.parseDataForExtendsClassCompletion"
+)(function* (sourceFile, position) {
+  const ts = yield* service(TypeScriptApi);
+  const { accessedObject, outerNode, replacementSpan } = yield* parseAccessedExpressionForCompletion(
+    sourceFile,
+    position
+  );
+  if (!ts.isIdentifier(accessedObject)) return yield* fail(new NodeNotFoundError());
+  let classDeclaration = outerNode.parent;
+  while (ts.isExpressionWithTypeArguments(classDeclaration) || ts.isHeritageClause(classDeclaration)) {
+    if (!classDeclaration.parent) break;
+    classDeclaration = classDeclaration.parent;
+  }
+  if (!ts.isClassDeclaration(classDeclaration)) return yield* fail(new NodeNotFoundError());
+  if (!classDeclaration.name) return yield* fail(new NodeNotFoundError());
+  return {
+    accessedObject,
+    classDeclaration,
+    className: classDeclaration.name,
+    replacementSpan
+  };
+});
+var createEffectGenCallExpression = fn("AST.createEffectGenCallExpression")(function* (effectModuleIdentifierName, node) {
+  const ts = yield* service(TypeScriptApi);
+  const generator = ts.factory.createFunctionExpression(
+    void 0,
+    ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+    void 0,
+    [],
+    [],
+    void 0,
+    node
+    // NOTE(mattia): intended, to use same routine for both ConciseBody and Body
+  );
+  return ts.factory.createCallExpression(
+    ts.factory.createPropertyAccessExpression(
+      ts.factory.createIdentifier(effectModuleIdentifierName),
+      "gen"
+    ),
+    void 0,
+    [generator]
+  );
+});
+var createEffectGenCallExpressionWithBlock = fn(
+  "AST.createEffectGenCallExpressionWithBlock"
+)(function* (effectModuleIdentifierName, statement) {
+  const ts = yield* service(TypeScriptApi);
+  return yield* createEffectGenCallExpression(
+    effectModuleIdentifierName,
+    ts.factory.createBlock(Array.isArray(statement) ? statement : [statement], false)
+  );
+});
+var createReturnYieldStarStatement = fn("AST.createReturnYieldStarStatement")(
+  function* (expr) {
+    const ts = yield* service(TypeScriptApi);
+    return ts.factory.createReturnStatement(
+      ts.factory.createYieldExpression(
+        ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+        expr
+      )
+    );
+  }
+);
+var parsePipeCall = fn("AST.parsePipeCall")(
+  function* (node) {
+    const ts = yield* service(TypeScriptApi);
+    if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.name) && node.expression.name.text === "pipe") {
+      return { node, subject: node.expression.expression, args: node.arguments };
+    }
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "pipe" && node.arguments.length > 0) {
+      const [subject, ...args] = node.arguments;
+      return { node, subject, args };
+    }
+    return yield* fail(new NodeNotFoundError());
+  }
+);
+
 // src/utils/TypeParser.ts
 var TypeParserIssue = class {
   constructor(type, node, message) {
@@ -1466,6 +1875,13 @@ function covariantTypeArgument(type) {
   }
   return succeed(signatures[0].getReturnType());
 }
+function contravariantTypeArgument(type) {
+  const signatures = type.getCallSignatures();
+  if (signatures.length !== 1) {
+    return typeParserIssue("Contravariant type has no call signature", type);
+  }
+  return succeed(signatures[0].getTypeParameterAtPosition(0));
+}
 function invariantTypeArgument(type) {
   const signatures = type.getCallSignatures();
   if (signatures.length !== 1) {
@@ -1497,6 +1913,19 @@ var varianceStructCovariantType = fn("TypeParser.varianceStructCovariantType")(
     return yield* covariantTypeArgument(propertyType);
   }
 );
+var varianceStructContravariantType = fn(
+  "TypeParser.varianceStructContravariantType"
+)(
+  function* (type, atLocation, propertyName) {
+    const typeChecker = yield* service(TypeCheckerApi);
+    const propertySymbol = typeChecker.getPropertyOfType(type, propertyName);
+    if (!propertySymbol) {
+      return yield* typeParserIssue(`Type has no '${propertyName}' property`, type, atLocation);
+    }
+    const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
+    return yield* contravariantTypeArgument(propertyType);
+  }
+);
 var varianceStructInvariantType = fn("TypeParser.varianceStructInvariantType")(
   function* (type, atLocation, propertyName) {
     const typeChecker = yield* service(TypeCheckerApi);
@@ -1515,6 +1944,13 @@ var effectVarianceStruct = fn("TypeParser.effectVarianceStruct")(function* (type
     R: yield* varianceStructCovariantType(type, atLocation, "_R")
   };
 });
+var layerVarianceStruct = fn("TypeParser.layerVarianceStruct")(function* (type, atLocation) {
+  return {
+    ROut: yield* varianceStructContravariantType(type, atLocation, "_ROut"),
+    E: yield* varianceStructCovariantType(type, atLocation, "_E"),
+    RIn: yield* varianceStructCovariantType(type, atLocation, "_RIn")
+  };
+});
 var effectType = fn("TypeParser.effectType")(function* (type, atLocation) {
   const ts = yield* service(TypeScriptApi);
   const typeChecker = yield* service(TypeCheckerApi);
@@ -1535,6 +1971,26 @@ var effectType = fn("TypeParser.effectType")(function* (type, atLocation) {
   }
   return yield* typeParserIssue("Type has no effect variance struct", type, atLocation);
 });
+var layerType = fn("TypeParser.layerType")(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("LayerTypeId") - a.name.indexOf("LayerTypeId"));
+  for (const propertySymbol of propertiesSymbols) {
+    const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
+    const varianceArgs = yield* option(layerVarianceStruct(
+      propertyType,
+      atLocation
+    ));
+    if (isSome2(varianceArgs)) {
+      return varianceArgs.value;
+    }
+  }
+  return yield* typeParserIssue("Type has no layer variance struct", type, atLocation);
+});
 var fiberType = fn("TypeParser.fiberType")(function* (type, atLocation) {
   const typeChecker = yield* service(TypeCheckerApi);
   const awaitSymbol = typeChecker.getPropertyOfType(type, "await");
@@ -1700,19 +2156,68 @@ var effectFnGen = fn("TypeParser.effectFnGen")(function* (node) {
     functionStar: generatorFunction.getFirstToken()
   };
 });
-var returnYieldEffectBlock = fn("TypeParser.returnYieldEffectBlock")(function* (body) {
+var unnecessaryEffectGen = fn("TypeParser.unnecessaryEffectGen")(function* (node) {
   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;
+  const { body } = yield* effectGen(node);
+  if (body.statements.length !== 1) {
+    return yield* typeParserIssue(
+      "Generator body should have a single statement",
+      void 0,
+      node
+    );
+  }
+  let explicitReturn = false;
+  let nodeToCheck = body.statements[0];
+  while (nodeToCheck) {
+    if (ts.isReturnStatement(nodeToCheck) && nodeToCheck.expression) {
+      nodeToCheck = nodeToCheck.expression;
+      explicitReturn = true;
+      continue;
+    }
+    if (ts.isExpressionStatement(nodeToCheck)) {
+      nodeToCheck = nodeToCheck.expression;
+      continue;
+    }
+    if (ts.isYieldExpression(nodeToCheck) && nodeToCheck.asteriskToken && nodeToCheck.expression) {
+      const yieldedExpression = nodeToCheck.expression;
+      const type = typeChecker.getTypeAtLocation(yieldedExpression);
+      const { A: successType } = yield* effectType(type, yieldedExpression);
+      let replacementNode = succeed(yieldedExpression);
+      if (!explicitReturn && !(successType.flags & ts.TypeFlags.VoidLike)) {
+        replacementNode = pipe(
+          gen(function* () {
+            const effectIdentifier = pipe(
+              yield* option(
+                findImportedModuleIdentifierByPackageAndNameOrBarrel(node.getSourceFile(), "effect", "Effect")
+              ),
+              match({
+                onNone: () => "Effect",
+                onSome: (_) => _.text
+              })
+            );
+            return ts.factory.createCallExpression(
+              ts.factory.createPropertyAccessExpression(
+                ts.factory.createIdentifier(effectIdentifier),
+                "asVoid"
+              ),
+              void 0,
+              [
+                yieldedExpression
+              ]
+            );
+          }),
+          provideService(TypeScriptApi, ts)
+        );
+      }
+      return { node, body, yieldedExpression, replacementNode };
+    }
+    break;
   }
   return yield* typeParserIssue(
-    "Node is not a return statement with a yield expression",
+    "Not an handled node",
     void 0,
-    body
+    node
   );
 });
 var effectSchemaVarianceStruct = fn("TypeParser.effectSchemaVarianceStruct")(
@@ -1777,7 +2282,7 @@ var floatingEffect = createDiagnostic({
       if (isSome2(effect)) {
         const allowedFloatingEffects = yield* pipe(
           fiberType(type, node.expression),
-          orElse(() => effectSubtype(type, node.expression)),
+          orElse2(() => effectSubtype(type, node.expression)),
           option
         );
         if (isNone2(allowedFloatingEffects)) {
@@ -1829,7 +2334,7 @@ var missingEffectContext = createDiagnostic({
           valueNode,
           realType
         ),
-        orElse(() => succeed([]))
+        orElse2(() => succeed([]))
       );
       if (missingContext.length > 0) {
         effectDiagnostics.push(
@@ -1881,7 +2386,7 @@ var missingEffectError = createDiagnostic({
           valueNode,
           realType
         ),
-        orElse(() => succeed([]))
+        orElse2(() => succeed([]))
       );
       if (missingContext.length > 0) {
         effectDiagnostics.push(
@@ -1898,6 +2403,75 @@ var missingEffectError = createDiagnostic({
   })
 });
 
+// src/diagnostics/missingReturnYieldStar.ts
+var missingReturnYieldStar = createDiagnostic({
+  name: "missingReturnYieldStar",
+  code: 7,
+  apply: fn("missingReturnYieldStar.apply")(function* (sourceFile) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const effectDiagnostics = [];
+    const brokenYields = /* @__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);
+      if (ts.isYieldExpression(node) && node.expression && node.asteriskToken) {
+        const type = typeChecker.getTypeAtLocation(node.expression);
+        const maybeEffect = yield* option(effectType(type, node.expression));
+        if (isSome2(maybeEffect) && maybeEffect.value.A.flags & ts.TypeFlags.Never) {
+          const generatorFunctionOrReturnStatement = ts.findAncestor(
+            node,
+            (_) => ts.isFunctionExpression(_) || ts.isFunctionDeclaration(_) || ts.isMethodDeclaration(_) || ts.isReturnStatement(_)
+          );
+          if (generatorFunctionOrReturnStatement && !ts.isReturnStatement(generatorFunctionOrReturnStatement)) {
+            if (generatorFunctionOrReturnStatement && generatorFunctionOrReturnStatement.parent) {
+              const effectGenNode = generatorFunctionOrReturnStatement.parent;
+              const effectGenLike = yield* pipe(
+                effectGen(effectGenNode),
+                orElse2(() => effectFnUntracedGen(effectGenNode)),
+                orElse2(() => effectFnGen(effectGenNode)),
+                option
+              );
+              if (isSome2(effectGenLike)) {
+                brokenYields.add(node);
+              }
+            }
+          }
+        }
+      }
+    }
+    brokenYields.forEach((node) => {
+      const fix = node.expression ? [{
+        fixName: "missingReturnYieldStar_fix",
+        description: "Add return statement",
+        apply: gen(function* () {
+          const changeTracker = yield* service(ChangeTracker);
+          changeTracker.replaceNode(
+            sourceFile,
+            node,
+            ts.factory.createReturnStatement(
+              node
+            )
+          );
+        })
+      }] : [];
+      effectDiagnostics.push({
+        node,
+        category: ts.DiagnosticCategory.Error,
+        messageText: `Yielded Effect never completes, so it is best to use a 'return yield*' instead.`,
+        fixes: fix
+      });
+    });
+    return effectDiagnostics;
+  })
+});
+
 // src/diagnostics/missingStarInYieldEffectGen.ts
 var missingStarInYieldEffectGen = createDiagnostic({
   name: "missingStarInYieldEffectGen",
@@ -1925,8 +2499,8 @@ var missingStarInYieldEffectGen = createDiagnostic({
           const effectGenNode = functionStarNode.parent;
           const effectGenLike = yield* pipe(
             effectGen(effectGenNode),
-            orElse(() => effectFnUntracedGen(effectGenNode)),
-            orElse(() => effectFnGen(effectGenNode)),
+            orElse2(() => effectFnUntracedGen(effectGenNode)),
+            orElse2(() => effectFnGen(effectGenNode)),
             option
           );
           if (isSome2(effectGenLike)) {
@@ -1974,7 +2548,7 @@ var missingStarInYieldEffectGen = createDiagnostic({
 });
 
 // src/diagnostics/unnecessaryEffectGen.ts
-var unnecessaryEffectGen = createDiagnostic({
+var unnecessaryEffectGen2 = createDiagnostic({
   name: "unnecessaryEffectGen",
   code: 5,
   apply: fn("unnecessaryEffectGen.apply")(function* (sourceFile) {
@@ -1990,13 +2564,9 @@ var unnecessaryEffectGen = createDiagnostic({
     while (nodeToVisit.length > 0) {
       const node = nodeToVisit.shift();
       ts.forEachChild(node, appendNodeToVisit);
-      const maybeNode = yield* pipe(
-        effectGen(node),
-        flatMap2(({ body }) => returnYieldEffectBlock(body)),
-        option
-      );
+      const maybeNode = yield* option(unnecessaryEffectGen(node));
       if (isSome2(maybeNode)) {
-        unnecessaryGenerators.set(node, maybeNode.value);
+        unnecessaryGenerators.set(node, maybeNode.value.replacementNode);
       }
     }
     unnecessaryGenerators.forEach(
@@ -2011,7 +2581,7 @@ var unnecessaryEffectGen = createDiagnostic({
             const textChanges = yield* service(
               ChangeTracker
             );
-            textChanges.replaceNode(sourceFile, effectGenCall, yieldedResult);
+            textChanges.replaceNode(sourceFile, effectGenCall, yield* yieldedResult);
           })
         }]
       })
@@ -2027,7 +2597,8 @@ var diagnostics = [
   missingEffectError,
   floatingEffect,
   missingStarInYieldEffectGen,
-  unnecessaryEffectGen
+  unnecessaryEffectGen2,
+  missingReturnYieldStar
 ];
 
 // src/transform.ts