@effect/language-service 0.24.2 → 0.25.1

package/transform.js

@@ -80,9 +80,9 @@ var dual = function(arity, body) {
         if (arguments.length >= arity) {
           return body.apply(this, arguments);
         }
-        const args = arguments;
+        const args2 = arguments;
         return function(self) {
-          return body(self, ...args);
+          return body(self, ...args2);
         };
       };
   }
@@ -151,7 +151,6 @@ var getBugErrorMessage = (message) => `BUG: ${message} - please report an issue
 
 // node_modules/.pnpm/effect@3.16.12/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 {
   value;
   constructor(value) {
@@ -484,32 +483,32 @@ var redact = (u) => {
 };
 
 // node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/Pipeable.js
-var pipeArguments = (self, args) => {
-  switch (args.length) {
+var pipeArguments = (self, args2) => {
+  switch (args2.length) {
     case 0:
       return self;
     case 1:
-      return args[0](self);
+      return args2[0](self);
     case 2:
-      return args[1](args[0](self));
+      return args2[1](args2[0](self));
     case 3:
-      return args[2](args[1](args[0](self)));
+      return args2[2](args2[1](args2[0](self)));
     case 4:
-      return args[3](args[2](args[1](args[0](self))));
+      return args2[3](args2[2](args2[1](args2[0](self))));
     case 5:
-      return args[4](args[3](args[2](args[1](args[0](self)))));
+      return args2[4](args2[3](args2[2](args2[1](args2[0](self)))));
     case 6:
-      return args[5](args[4](args[3](args[2](args[1](args[0](self))))));
+      return args2[5](args2[4](args2[3](args2[2](args2[1](args2[0](self))))));
     case 7:
-      return args[6](args[5](args[4](args[3](args[2](args[1](args[0](self)))))));
+      return args2[6](args2[5](args2[4](args2[3](args2[2](args2[1](args2[0](self)))))));
     case 8:
-      return args[7](args[6](args[5](args[4](args[3](args[2](args[1](args[0](self))))))));
+      return args2[7](args2[6](args2[5](args2[4](args2[3](args2[2](args2[1](args2[0](self))))))));
     case 9:
-      return args[8](args[7](args[6](args[5](args[4](args[3](args[2](args[1](args[0](self)))))))));
+      return args2[8](args2[7](args2[6](args2[5](args2[4](args2[3](args2[2](args2[1](args2[0](self)))))))));
     default: {
       let ret = self;
-      for (let i = 0, len = args.length; i < len; i++) {
-        ret = args[i](ret);
+      for (let i = 0, len = args2.length; i < len; i++) {
+        ret = args2[i](ret);
       }
       return ret;
     }
@@ -833,181 +832,278 @@ var dedupeWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => {
 var dedupe = (self) => dedupeWith(self, equivalence());
 
 // src/core/Nano.ts
-function makeInternalSuccess(value) {
-  return { _tag: "Right", value };
-}
-function makeInternalDefect(value) {
-  return { _tag: "Defect", value };
-}
+var NanoTag = class {
+  constructor(key) {
+    this.key = key;
+  }
+};
+var Tag = (identifier) => new NanoTag(identifier);
+var evaluate = Symbol.for("Nano.evaluate");
+var contA = Symbol.for("Nano.contA");
+var contE = Symbol.for("Nano.contE");
+var contAll = Symbol.for("Nano.contAll");
+var NanoYield = Symbol.for("Nano.yield");
+var args = Symbol.for("Nano.args");
 var NanoDefectException = class {
   constructor(message) {
     this.message = message;
   }
   _tag = "@effect/language-service/NanoDefectException";
 };
-var NanoTag = class {
-  constructor(key) {
-    this.key = key;
+var PrimitiveProto = {
+  [Symbol.iterator]() {
+    return new SingleShotGen(new YieldWrap(this));
   }
 };
-var Tag = (identifier) => new NanoTag(identifier);
-var contextEmpty = { value: {} };
-function make2(run2) {
-  const nano = {
-    run: run2,
-    [Symbol.iterator]() {
-      return new SingleShotGen(new YieldWrap(this));
-    }
-  };
+var SucceedProto = {
+  ...PrimitiveProto,
+  _tag: "Success",
+  get value() {
+    return this[args];
+  },
+  [evaluate](fiber) {
+    const cont = fiber.getCont(contA);
+    return cont ? cont[contA](this[args], fiber) : fiber.yieldWith(this);
+  }
+};
+var succeed = (value) => {
+  const nano = Object.create(SucceedProto);
+  nano[args] = value;
   return nano;
-}
-var unsafeRun = (fa) => {
-  const program = provideService(internalNanoCache, {})(fa);
-  const result = program.run(contextEmpty);
-  switch (result._tag) {
-    case "Left":
-      return left2(result.value);
-    case "Defect":
-      return left2(new NanoDefectException(result.value));
-    case "Right":
-      return right2(result.value);
-  }
-};
-var run = (fa) => {
+};
+var FailureProto = {
+  ...PrimitiveProto,
+  _tag: "Failure",
+  get value() {
+    return this[args];
+  },
+  [evaluate](fiber) {
+    const cont = fiber.getCont(contE);
+    return cont ? cont[contE](this[args], fiber) : fiber.yieldWith(this);
+  }
+};
+var fail = (error) => {
+  const nano = Object.create(FailureProto);
+  nano[args] = error;
+  return nano;
+};
+var SuspendProto = {
+  ...PrimitiveProto,
+  [evaluate]() {
+    return this[args]();
+  }
+};
+var suspend = (fn2) => {
+  const nano = Object.create(SuspendProto);
+  nano[args] = fn2;
+  return nano;
+};
+var NanoFiber = class {
+  _stack = [];
+  _yielded = void 0;
+  _services = {};
+  _cache = {};
+  runLoop(nano) {
+    let current = nano;
+    while (true) {
+      current = current[evaluate](this);
+      if (current === NanoYield) {
+        return this._yielded;
+      }
+    }
+  }
+  getCont(symbol3) {
+    while (true) {
+      const op = this._stack.pop();
+      if (!op) return void 0;
+      const cont = op[contAll] && op[contAll](this);
+      if (cont) return { [symbol3]: cont };
+      if (op[symbol3]) return op;
+    }
+  }
+  yieldWith(value) {
+    this._yielded = value;
+    return NanoYield;
+  }
+};
+var unsafeRun = (nano) => {
+  const fiber = new NanoFiber();
+  const result = fiber.runLoop(nano);
+  if (result._tag === "Success") {
+    return right2(result.value);
+  }
+  return left2(result.value);
+};
+var run = (nano) => {
   try {
-    return unsafeRun(fa);
+    return unsafeRun(nano);
   } catch (e) {
     return left2(new NanoDefectException(e));
   }
 };
-var succeed = (value) => {
-  const nano = {
-    run: () => ({ _tag: "Right", value }),
-    [Symbol.iterator]() {
-      return new SingleShotGen(new YieldWrap(this));
-    }
-  };
+var OnSuccessProto = {
+  ...PrimitiveProto,
+  [evaluate](fiber) {
+    fiber._stack.push(this);
+    return this[args];
+  }
+};
+var flatMap2 = dual(2, (fa, f) => {
+  const nano = Object.create(OnSuccessProto);
+  nano[args] = fa;
+  nano[contA] = f;
   return nano;
+});
+var map3 = dual(2, (fa, f) => flatMap2(fa, (_) => succeed(f(_))));
+var SyncProto = {
+  ...PrimitiveProto,
+  [evaluate](fiber) {
+    const value = this[args]();
+    const cont = fiber.getCont(contA);
+    return cont ? cont[contA](value, fiber) : fiber.yieldWith(succeed(value));
+  }
 };
-var fail = (value) => {
-  const nano = {
-    run: () => ({ _tag: "Left", value }),
-    [Symbol.iterator]() {
-      return new SingleShotGen(new YieldWrap(this));
-    }
-  };
+var sync = (f) => {
+  const nano = Object.create(SyncProto);
+  nano[args] = f;
   return nano;
 };
-var sync = (value) => {
-  const nano = {
-    run: () => ({ _tag: "Right", value: value() }),
-    [Symbol.iterator]() {
-      return new SingleShotGen(new YieldWrap(this));
-    }
-  };
+var void_ = succeed(void 0);
+var FromIteratorProto = {
+  ...PrimitiveProto,
+  [contA](value, fiber) {
+    const state = this[args][0].next(value);
+    if (state.done) return succeed(state.value);
+    fiber._stack.push(this);
+    return yieldWrapGet(state.value);
+  },
+  [evaluate](fiber) {
+    return this[contA](this[args][1], fiber);
+  }
+};
+var unsafeFromIterator = (iterator, initial) => {
+  const nano = Object.create(FromIteratorProto);
+  nano[args] = [iterator, initial];
+  return nano;
+};
+var gen = (...args2) => suspend(() => unsafeFromIterator(args2[0]()));
+var fn = (_) => (body) => (...args2) => suspend(() => unsafeFromIterator(body(...args2)));
+var MatchProto = {
+  ...PrimitiveProto,
+  [evaluate](fiber) {
+    fiber._stack.push(this);
+    return this[args];
+  }
+};
+var match2 = (fa, opts) => {
+  const nano = Object.create(MatchProto);
+  nano[args] = fa;
+  nano[contA] = opts.onSuccess;
+  nano[contE] = opts.onFailure;
+  return nano;
+};
+var orElse2 = (f) => (fa) => {
+  const nano = Object.create(MatchProto);
+  nano[args] = fa;
+  nano[contE] = f;
   return nano;
 };
-var flatMap2 = dual(2, (fa, f) => make2((ctx) => {
-  const result = fa.run(ctx);
-  if (result._tag !== "Right") return result;
-  return f(result.value).run(ctx);
-}));
-var map3 = dual(2, (fa, f) => make2((ctx) => {
-  const result = fa.run(ctx);
-  if (result._tag !== "Right") return result;
-  return makeInternalSuccess(f(result.value));
-}));
-var orElse2 = (f) => (fa) => make2((ctx) => {
-  const result = fa.run(ctx);
-  if (result._tag === "Left") return f(result.value).run(ctx);
-  return result;
-});
 var firstSuccessOf = (arr) => arr.slice(1).reduce((arr2, fa) => orElse2(() => fa)(arr2), arr[0]);
-var service = (tag) => make2(
-  (ctx) => tag.key in ctx.value ? ctx.value[tag.key] : makeInternalDefect(`Cannot find service ${tag.key}`)
-);
-var provideService = (tag, value) => (fa) => make2((ctx) => {
-  return fa.run({
-    ...ctx,
-    value: {
-      ...ctx.value,
-      [tag.key]: makeInternalSuccess(value)
-    }
-  });
-});
-var gen = (...args) => make2((ctx) => {
-  const iterator = args[0]();
-  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(result.value);
+var ProvideServiceProto = {
+  ...PrimitiveProto,
+  [evaluate](fiber) {
+    const prevServices = fiber._services;
+    const [fa, tag, value] = this[args];
+    fiber._services = {
+      ...fiber._services,
+      [tag.key]: value
+    };
+    return match2(fa, {
+      onSuccess: (_) => {
+        fiber._services = prevServices;
+        return succeed(_);
+      },
+      onFailure: (_) => {
+        fiber._services = prevServices;
+        return fail(_);
+      }
+    });
   }
-  return makeInternalSuccess(state.value);
-});
-var fn = (_) => (body) => (...args) => make2((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(result.value);
+};
+var provideService = (tag, value) => (fa) => {
+  const nano = Object.create(ProvideServiceProto);
+  nano[args] = [fa, tag, value];
+  return nano;
+};
+var ServiceProto = {
+  ...PrimitiveProto,
+  [evaluate](fiber) {
+    const tag = this[args];
+    if (tag.key in fiber._services) {
+      const value = fiber._services[tag.key];
+      const cont2 = fiber.getCont(contA);
+      return cont2 ? cont2[contA](value, fiber) : fiber.yieldWith(succeed(value));
+    }
+    const cont = fiber.getCont(contE);
+    return cont ? cont[contE](tag, fiber) : fiber.yieldWith(fail(new NanoDefectException(`Service ${tag.key} not found`)));
   }
-  return makeInternalSuccess(state.value);
-});
-var option = (fa) => make2((ctx) => {
-  const result = fa.run(ctx);
-  switch (result._tag) {
-    case "Right":
-      return makeInternalSuccess(some2(result.value));
-    case "Left":
-      return makeInternalSuccess(none2());
-    case "Defect":
-      return result;
+};
+var service = (tag) => {
+  const nano = Object.create(ServiceProto);
+  nano[args] = tag;
+  return nano;
+};
+var CachedProto = {
+  ...PrimitiveProto,
+  [evaluate](fiber) {
+    const [fa, type, key] = this[args];
+    const cache = fiber._cache[type] || /* @__PURE__ */ new WeakMap();
+    fiber._cache[type] = cache;
+    const cached2 = cache.get(key);
+    if (cached2) return cached2;
+    return match2(fa, {
+      onSuccess: (_) => {
+        cache.set(key, succeed(_));
+        return succeed(_);
+      },
+      onFailure: (_) => {
+        cache.set(key, fail(_));
+        return fail(_);
+      }
+    });
   }
-});
-var successUndefined = makeInternalSuccess(void 0);
-var void_ = make2(() => successUndefined);
-var ignore = (fa) => make2((ctx) => {
-  fa.run(ctx);
-  return successUndefined;
-});
-var all = (...args) => make2((ctx) => {
-  const results = [];
-  for (const arg of args) {
-    const result = arg.run(ctx);
-    if (result._tag !== "Right") return result;
-    results.push(result.value);
-  }
-  return makeInternalSuccess(results);
-});
-var internalNanoCache = Tag(
-  "@effect/language-service/internalNanoCache"
-);
-function cachedBy(fa, key, lookupKey) {
-  return (...args) => make2((ctx) => {
-    const cacheObj = ctx.value[internalNanoCache.key];
-    let cache = cacheObj[key];
-    if (!cache) {
-      cache = /* @__PURE__ */ new Map();
-      cacheObj[key] = cache;
-    }
-    const lookup = lookupKey(...args);
-    const cached2 = cache.get(lookup);
-    if (cached2 !== void 0) {
-      return cached2;
-    }
-    const result = fa(...args).run(ctx);
-    cache.set(lookup, result);
-    return result;
-  });
+};
+function cachedBy(fa, type, lookupKey) {
+  return (...p) => {
+    const nano = Object.create(CachedProto);
+    nano[args] = [fa(...p), type, lookupKey(...p)];
+    return nano;
+  };
 }
+var option = (fa) => {
+  const nano = Object.create(MatchProto);
+  nano[args] = fa;
+  nano[contA] = (_) => succeed(some2(_));
+  nano[contE] = (_) => _ instanceof NanoDefectException ? fail(_) : succeed(none2());
+  return nano;
+};
+var ignore = (fa) => {
+  const nano = Object.create(MatchProto);
+  nano[args] = fa;
+  nano[contA] = (_) => void_;
+  nano[contE] = (_) => _ instanceof NanoDefectException ? fail(_) : void_;
+  return nano;
+};
+var all = fn("all")(
+  function* (...args2) {
+    const results = [];
+    for (const fa of args2) {
+      const result = yield* fa;
+      results.push(result);
+    }
+    return results;
+  }
+);
 
 // src/core/LanguageServicePluginOptions.ts
 var LanguageServicePluginOptions = Tag("PluginOptions");
@@ -1213,10 +1309,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 match2;
-    while ((match2 = regex.exec(sourceFile.text)) !== null) {
-      const nextLineCaptureGroup = match2[1];
-      const rulesCaptureGroup = match2[2];
+    let match3;
+    while ((match3 = regex.exec(sourceFile.text)) !== null) {
+      const nextLineCaptureGroup = match3[1];
+      const rulesCaptureGroup = match3[2];
       if (rulesCaptureGroup) {
         const trimmedRuleString = rulesCaptureGroup.trim();
         if (trimmedRuleString) {
@@ -1228,7 +1324,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(match2.index);
+                const node = findNodeWithLeadingCommentAtPosition(match3.index);
                 if (node) {
                   lineOverrides[ruleName] = lineOverrides[ruleName] || [];
                   lineOverrides[ruleName].unshift({
@@ -1240,7 +1336,7 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
               } else {
                 sectionOverrides[ruleName] = sectionOverrides[ruleName] || [];
                 sectionOverrides[ruleName].unshift({
-                  pos: match2.index,
+                  pos: match3.index,
                   level: ruleLevel
                 });
               }
@@ -1543,11 +1639,23 @@ var expectedAndRealType = fn("TypeCheckerApi.expectedAndRealType")(function* (so
   cache.expectedAndRealType.set(sourceFile, result);
   return result;
 });
+var unrollUnionMembers = (type) => {
+  const result = [];
+  let toTest = [type];
+  while (toTest.length > 0) {
+    const type2 = toTest.pop();
+    if (type2.isUnion()) {
+      toTest = toTest.concat(type2.types);
+    } else {
+      result.push(type2);
+    }
+  }
+  return result;
+};
 var appendToUniqueTypesMap = fn(
   "TypeCheckerApi.appendToUniqueTypesMap"
 )(
-  function* (memory, initialType, excludeNever) {
-    const ts = yield* service(TypeScriptApi);
+  function* (memory, initialType, shouldExclude) {
     const typeChecker = yield* service(TypeCheckerApi);
     const newIndexes = /* @__PURE__ */ new Set();
     const knownIndexes = /* @__PURE__ */ new Set();
@@ -1555,7 +1663,7 @@ var appendToUniqueTypesMap = fn(
     while (toTest.length > 0) {
       const type = toTest.pop();
       if (!type) break;
-      if (excludeNever && type.flags & ts.TypeFlags.Never) {
+      if (yield* shouldExclude(type)) {
         continue;
       }
       if (type.isUnion()) {
@@ -1946,10 +2054,10 @@ var TypeParserIssue = class _TypeParserIssue {
   _tag = "@effect/language-service/TypeParserIssue";
   static issue = fail(new _TypeParserIssue());
 };
-function make3(ts, typeChecker) {
-  function typeParserIssue(_message, _type, _node) {
-    return TypeParserIssue.issue;
-  }
+function typeParserIssue(_message, _type, _node) {
+  return TypeParserIssue.issue;
+}
+function make2(ts, typeChecker) {
   function covariantTypeArgument(type) {
     const signatures = type.getCallSignatures();
     if (signatures.length !== 1) {
@@ -2394,8 +2502,8 @@ function make3(ts, typeChecker) {
         return succeed({ node, subject: node.expression.expression, args: Array.from(node.arguments) });
       }
       if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "pipe" && node.arguments.length > 0) {
-        const [subject, ...args] = node.arguments;
-        return succeed({ node, subject, args });
+        const [subject, ...args2] = node.arguments;
+        return succeed({ node, subject, args: args2 });
       }
       return typeParserIssue("Node is not a pipe call", void 0, node);
     },
@@ -2487,6 +2595,53 @@ ${versions.map((version) => `- found ${version} at ${resolvedPackages[packageNam
   })
 });
 
+// src/diagnostics/effectInVoidSuccess.ts
+var effectInVoidSuccess = createDiagnostic({
+  name: "effectInVoidSuccess",
+  code: 14,
+  severity: "warning",
+  apply: fn("effectInVoidSuccess.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
+    const checkForEffectInVoid = fn("effectInVoidSuccess.checkForEffectInVoid")(function* (node, expectedType, valueNode, realType) {
+      const expectedEffect = yield* typeParser.effectType(expectedType, node);
+      const realEffect = yield* typeParser.effectType(realType, valueNode);
+      if (expectedEffect.A.flags & ts.TypeFlags.Void) {
+        const voidValueTypes = unrollUnionMembers(realEffect.A);
+        const voidedEffect = yield* firstSuccessOf(
+          voidValueTypes.map((_) => map3(typeParser.strictEffectType(_, node), () => _))
+        );
+        return { voidedEffect };
+      }
+      return yield* fail(typeParserIssue("expectedEffect success is not void"));
+    });
+    const entries = yield* expectedAndRealType(sourceFile);
+    for (const [node, expectedType, valueNode, realType] of entries) {
+      if (expectedType !== realType) {
+        yield* pipe(
+          checkForEffectInVoid(
+            node,
+            expectedType,
+            valueNode,
+            realType
+          ),
+          map3(({ voidedEffect }) => {
+            report(
+              {
+                node,
+                messageText: `There is a nested '${typeChecker.typeToString(voidedEffect)}' in the 'void' success channel, beware that this could lead to nested Effect<Effect<...>> that won't be executed.`,
+                fixes: []
+              }
+            );
+          }),
+          ignore
+        );
+      }
+    }
+  })
+});
+
 // src/diagnostics/floatingEffect.ts
 var floatingEffect = createDiagnostic({
   name: "floatingEffect",
@@ -2756,7 +2911,18 @@ var leakingRequirements = createDiagnostic({
             );
             if (effectContextType) {
               effectMembers++;
-              const { allIndexes } = yield* appendToUniqueTypesMap(memory, effectContextType, true);
+              const { allIndexes } = yield* appendToUniqueTypesMap(
+                memory,
+                effectContextType,
+                (type) => {
+                  if (type.flags & ts.TypeFlags.Never) return succeed(true);
+                  return pipe(
+                    typeParser.scopeType(type, atLocation),
+                    map3(() => true),
+                    orElse2(() => succeed(false))
+                  );
+                }
+              );
               if (!sharedRequirementsKeys) {
                 sharedRequirementsKeys = allIndexes;
               } else {
@@ -3309,6 +3475,51 @@ Consider using "scoped" instead to get rid of the scope in the requirements.`,
   })
 });
 
+// src/diagnostics/tryCatchInEffectGen.ts
+var tryCatchInEffectGen = createDiagnostic({
+  name: "tryCatchInEffectGen",
+  code: 12,
+  severity: "suggestion",
+  apply: fn("tryCatchInEffectGen.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
+    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.isTryStatement(node)) {
+        const generatorOrRegularFunction = ts.findAncestor(
+          node,
+          (_) => ts.isFunctionExpression(_) || ts.isFunctionDeclaration(_) || ts.isMethodDeclaration(_) || ts.isArrowFunction(_) || ts.isGetAccessor(_) || ts.isFunctionLike(_)
+        );
+        if (!(generatorOrRegularFunction && "asteriskToken" in generatorOrRegularFunction && generatorOrRegularFunction.asteriskToken)) continue;
+        if (!generatorOrRegularFunction) continue;
+        if (generatorOrRegularFunction && generatorOrRegularFunction.parent) {
+          const effectGenNode = generatorOrRegularFunction.parent;
+          yield* pipe(
+            typeParser.effectGen(effectGenNode),
+            orElse2(() => typeParser.effectFnUntracedGen(effectGenNode)),
+            orElse2(() => typeParser.effectFnGen(effectGenNode)),
+            map3(() => {
+              report({
+                node,
+                messageText: "Avoid using try/catch inside Effect generators. Use Effect's error handling mechanisms instead (e.g., Effect.try, Effect.tryPromise, Effect.catchAll, Effect.catchTag).",
+                fixes: []
+              });
+            }),
+            ignore
+          );
+        }
+      }
+    }
+  })
+});
+
 // src/diagnostics/unnecessaryEffectGen.ts
 var unnecessaryEffectGen = createDiagnostic({
   name: "unnecessaryEffectGen",
@@ -3372,8 +3583,8 @@ var unnecessaryPipe = createDiagnostic({
       if (ts.isCallExpression(node)) {
         yield* pipe(
           typeParser.pipeCall(node),
-          map3(({ args, subject }) => {
-            if (args.length === 0) {
+          map3(({ args: args2, subject }) => {
+            if (args2.length === 0) {
               report({
                 node,
                 messageText: `This pipe call contains no arguments.`,
@@ -3410,8 +3621,10 @@ var diagnostics = [
   unnecessaryPipe,
   genericEffectServices,
   returnEffectInGen,
+  tryCatchInEffectGen,
   importFromBarrel,
-  scopeInLayerEffect
+  scopeInLayerEffect,
+  effectInVoidSuccess
 ];
 
 // src/transform.ts
@@ -3423,7 +3636,7 @@ function transform_default(program, pluginConfig, { addDiagnostic, ts: tsInstanc
         provideService(TypeScriptApi, tsInstance),
         provideService(TypeScriptProgram, program),
         provideService(TypeCheckerApi, program.getTypeChecker()),
-        provideService(TypeParser, make3(tsInstance, program.getTypeChecker())),
+        provideService(TypeParser, make2(tsInstance, program.getTypeChecker())),
         provideService(
           TypeCheckerApiCache,
           makeTypeCheckerApiCache()