@effect/language-service 0.23.5 → 0.24.1

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "@effect/language-service",
-  "version": "0.23.5",
+  "version": "0.24.1",
   "description": "A Language-Service Plugin to Refactor and Diagnostic effect-ts projects",
   "main": "index.cjs",
+  "bin": {
+    "effect-language-service": "cli.js"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/Effect-TS/language-service.git"

package/transform.js

@@ -24,7 +24,7 @@ __export(transform_exports, {
 });
 module.exports = __toCommonJS(transform_exports);
 
-// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Function.js
+// node_modules/.pnpm/effect@3.16.12/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.5/node_modules/effect/dist/esm/internal/version.js
-var moduleVersion = "3.16.5";
+// node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/internal/version.js
+var moduleVersion = "3.16.12";
 var getCurrentVersion = () => moduleVersion;
 
-// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/GlobalValue.js
+// node_modules/.pnpm/effect@3.16.12/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.5/node_modules/effect/dist/esm/Predicate.js
+// node_modules/.pnpm/effect@3.16.12/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";
@@ -146,10 +146,10 @@ var isObject = (input) => isRecordOrArray(input) || isFunction2(input);
 var hasProperty = /* @__PURE__ */ dual(2, (self, property) => isObject(self) && property in self);
 var isRecord = (input) => isRecordOrArray(input) && !Array.isArray(input);
 
-// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/internal/errors.js
+// node_modules/.pnpm/effect@3.16.12/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.5/node_modules/effect/dist/esm/Utils.js
+// 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 {
@@ -278,7 +278,7 @@ var internalCall = isNotOptimizedAway ? standard.effect_internal_function : forc
 var genConstructor = function* () {
 }.constructor;
 
-// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Hash.js
+// node_modules/.pnpm/effect@3.16.12/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) => {
@@ -377,7 +377,7 @@ var cached = function() {
   return hash2;
 };
 
-// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Equal.js
+// node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/Equal.js
 var symbol2 = /* @__PURE__ */ Symbol.for("effect/Equal");
 function equals() {
   if (arguments.length === 1) {
@@ -431,7 +431,7 @@ function compareBoth(self, that) {
 var isEqual = (u) => hasProperty(u, symbol2);
 var equivalence = () => equals;
 
-// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Inspectable.js
+// node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/Inspectable.js
 var NodeInspectSymbol = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
 var toJSON = (x) => {
   try {
@@ -483,7 +483,7 @@ var redact = (u) => {
   return u;
 };
 
-// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Pipeable.js
+// node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/Pipeable.js
 var pipeArguments = (self, args) => {
   switch (args.length) {
     case 0:
@@ -516,10 +516,10 @@ var pipeArguments = (self, args) => {
   }
 };
 
-// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/internal/opCodes/effect.js
+// node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/internal/opCodes/effect.js
 var OP_COMMIT = "Commit";
 
-// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/internal/effectable.js
+// node_modules/.pnpm/effect@3.16.12/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");
@@ -606,7 +606,7 @@ var StructuralCommitPrototype = {
   ...StructuralPrototype
 };
 
-// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/internal/option.js
+// node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/internal/option.js
 var TypeId = /* @__PURE__ */ Symbol.for("effect/Option");
 var CommonProto = {
   ...EffectPrototype,
@@ -664,7 +664,7 @@ var some = (value) => {
   return a;
 };
 
-// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/internal/either.js
+// node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/internal/either.js
 var TypeId2 = /* @__PURE__ */ Symbol.for("effect/Either");
 var CommonProto2 = {
   ...EffectPrototype,
@@ -726,7 +726,7 @@ var right = (right3) => {
   return a;
 };
 
-// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Either.js
+// node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/Either.js
 var right2 = right;
 var left2 = left;
 var isLeft2 = isLeft;
@@ -734,13 +734,14 @@ 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.5/node_modules/effect/dist/esm/internal/array.js
+// node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/internal/array.js
 var isNonEmptyArray = (self) => self.length > 0;
 
-// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Order.js
+// node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/Order.js
 var make = (compare) => (self, that) => self === that ? 0 : compare(self, that);
+var string2 = /* @__PURE__ */ make((self, that) => self < that ? -1 : 1);
 
-// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Option.js
+// node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/Option.js
 var none2 = () => none;
 var some2 = some;
 var isNone2 = isNone;
@@ -752,7 +753,7 @@ var match = /* @__PURE__ */ dual(2, (self, {
 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.5/node_modules/effect/dist/esm/Array.js
+// node_modules/.pnpm/effect@3.16.12/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)));
@@ -921,6 +922,7 @@ var orElse2 = (f) => (fa) => make2((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}`)
 );
@@ -2027,22 +2029,16 @@ function make3(ts, typeChecker) {
   );
   const effectType = cachedBy(
     fn("TypeParser.effectType")(function* (type, atLocation) {
-      yield* pipeableType(type, atLocation);
+      let result = typeParserIssue("Type has no effect variance struct", type, atLocation);
       const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
-        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional)
+        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration && ts.isPropertySignature(_.valueDeclaration) && ts.isComputedPropertyName(_.valueDeclaration.name)
       );
       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;
-        }
+        result = pipe(result, orElse2(() => effectVarianceStruct(propertyType, atLocation)));
       }
-      return yield* typeParserIssue("Type has no effect variance struct", type, atLocation);
+      return yield* result;
     }),
     "TypeParser.effectType",
     (type) => type
@@ -2061,7 +2057,7 @@ function make3(ts, typeChecker) {
     fn("TypeParser.layerType")(function* (type, atLocation) {
       yield* pipeableType(type, atLocation);
       const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
-        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional)
+        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration && ts.isPropertySignature(_.valueDeclaration) && ts.isComputedPropertyName(_.valueDeclaration.name)
       );
       propertiesSymbols.sort((a, b) => b.name.indexOf("LayerTypeId") - a.name.indexOf("LayerTypeId"));
       for (const propertySymbol of propertiesSymbols) {
@@ -2345,7 +2341,7 @@ function make3(ts, typeChecker) {
       const ast = typeChecker.getPropertyOfType(type, "ast");
       if (!ast) return yield* typeParserIssue("Has no 'ast' property", type, atLocation);
       const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
-        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional)
+        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration && ts.isPropertySignature(_.valueDeclaration) && ts.isComputedPropertyName(_.valueDeclaration.name)
       );
       propertiesSymbols.sort((a, b) => b.name.indexOf("TypeId") - a.name.indexOf("TypeId"));
       for (const propertySymbol of propertiesSymbols) {
@@ -2374,7 +2370,7 @@ function make3(ts, typeChecker) {
     fn("TypeParser.contextTag")(function* (type, atLocation) {
       yield* pipeableType(type, atLocation);
       const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
-        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional)
+        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration && ts.isPropertySignature(_.valueDeclaration) && ts.isComputedPropertyName(_.valueDeclaration.name)
       );
       propertiesSymbols.sort((a, b) => b.name.indexOf("TypeId") - a.name.indexOf("TypeId"));
       for (const propertySymbol of propertiesSymbols) {
@@ -2406,6 +2402,25 @@ function make3(ts, typeChecker) {
     "TypeParser.pipeCall",
     (node) => node
   );
+  const scopeType = cachedBy(
+    fn("TypeParser.scopeType")(function* (type, atLocation) {
+      yield* pipeableType(type, atLocation);
+      const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
+        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration && ts.isPropertySignature(_.valueDeclaration) && ts.isComputedPropertyName(_.valueDeclaration.name)
+      );
+      propertiesSymbols.sort((a, b) => b.name.indexOf("ScopeTypeId") - a.name.indexOf("ScopeTypeId"));
+      for (const propertySymbol of propertiesSymbols) {
+        const computedPropertyExpression = propertySymbol.valueDeclaration.name;
+        const symbol3 = typeChecker.getSymbolAtLocation(computedPropertyExpression.expression);
+        if (symbol3 && symbol3.name === "ScopeTypeId") {
+          return type;
+        }
+      }
+      return yield* typeParserIssue("Type has no scope type id", type, atLocation);
+    }),
+    "TypeParser.scopeType",
+    (type) => type
+  );
   return {
     effectType,
     strictEffectType,
@@ -2419,7 +2434,8 @@ function make3(ts, typeChecker) {
     unnecessaryEffectGen: unnecessaryEffectGen2,
     effectSchemaType,
     contextTag,
-    pipeCall
+    pipeCall,
+    scopeType
   };
 }
 
@@ -2860,18 +2876,39 @@ var missingEffectError = createDiagnostic({
   code: 1,
   severity: "error",
   apply: fn("missingEffectError.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
     const typeOrder = yield* deterministicTypeOrder;
+    const effectModuleIdentifier = yield* pipe(
+      findImportedModuleIdentifierByPackageAndNameOrBarrel(
+        sourceFile,
+        "effect",
+        "Effect"
+      ),
+      map3((_) => _.text),
+      orElse2(() => succeed("Effect"))
+    );
+    const createDieMessage = (message) => ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(
+        ts.factory.createIdentifier(effectModuleIdentifier),
+        "dieMessage"
+      ),
+      void 0,
+      [ts.factory.createStringLiteral(message)]
+    );
     const checkForMissingErrorTypes = (node, expectedType, valueNode, realType) => pipe(
       all(
         typeParser.effectType(expectedType, node),
         typeParser.effectType(realType, valueNode)
       ),
       flatMap2(
-        ([expectedEffect, realEffect]) => getMissingTypeEntriesInTargetType(
-          realEffect.E,
-          expectedEffect.E
+        ([expectedEffect, realEffect]) => pipe(
+          getMissingTypeEntriesInTargetType(
+            realEffect.E,
+            expectedEffect.E
+          ),
+          map3((missingErrorTypes) => ({ missingErrorTypes, expectedErrorType: expectedEffect.E }))
         )
       )
     );
@@ -2886,15 +2923,79 @@ var missingEffectError = createDiagnostic({
             valueNode,
             realType
           ),
-          map3(
-            (missingTypes) => missingTypes.length > 0 ? report(
+          map3((result) => {
+            if (result.missingErrorTypes.length === 0) return;
+            const fixes = [];
+            if (ts.isExpression(valueNode) && result.expectedErrorType.flags & ts.TypeFlags.Never) {
+              fixes.push({
+                fixName: "missingEffectError_catchAll",
+                description: "Catch all errors with Effect.catchAll",
+                apply: gen(function* () {
+                  const changeTracker = yield* service(ChangeTracker);
+                  changeTracker.insertText(sourceFile, valueNode.getStart(), effectModuleIdentifier + ".catchAll(");
+                  changeTracker.insertText(sourceFile, valueNode.getEnd(), ", () => ");
+                  changeTracker.insertNodeAt(
+                    sourceFile,
+                    valueNode.getEnd(),
+                    createDieMessage("TODO: catchAll not implemented")
+                  );
+                  changeTracker.insertText(sourceFile, valueNode.getEnd(), ")");
+                })
+              });
+            }
+            if (ts.isExpression(valueNode)) {
+              const propertyAssignments = pipe(
+                result.missingErrorTypes,
+                map2((_) => typeChecker.getPropertyOfType(_, "_tag")),
+                filter((_) => !!_),
+                map2((_) => typeChecker.getTypeOfSymbolAtLocation(_, valueNode)),
+                filter((_) => !!(_.flags & ts.TypeFlags.Literal)),
+                map2((_) => typeChecker.typeToTypeNode(_, void 0, ts.NodeBuilderFlags.NoTruncation)),
+                filter((_) => !!_ && ts.isLiteralTypeNode(_)),
+                map2((_) => _.literal),
+                filter((_) => ts.isLiteralExpression(_)),
+                map2((_) => _.text),
+                sort(string2),
+                map2(
+                  (_) => ts.factory.createPropertyAssignment(
+                    ts.factory.createIdentifier(_),
+                    ts.factory.createArrowFunction(
+                      void 0,
+                      void 0,
+                      [],
+                      void 0,
+                      void 0,
+                      createDieMessage(`TODO: catchTags() not implemented for ${_}`)
+                    )
+                  )
+                )
+              );
+              if (propertyAssignments.length === result.missingErrorTypes.length) {
+                fixes.push({
+                  fixName: "missingEffectError_tagged",
+                  description: "Catch unexpected errors with Effect.catchTag",
+                  apply: gen(function* () {
+                    const changeTracker = yield* service(ChangeTracker);
+                    changeTracker.insertText(sourceFile, valueNode.getStart(), effectModuleIdentifier + ".catchTags(");
+                    changeTracker.insertText(sourceFile, valueNode.getEnd(), ", ");
+                    changeTracker.insertNodeAt(
+                      sourceFile,
+                      valueNode.getEnd(),
+                      ts.factory.createObjectLiteralExpression(propertyAssignments)
+                    );
+                    changeTracker.insertText(sourceFile, valueNode.getEnd(), ")");
+                  })
+                });
+              }
+            }
+            report(
               {
                 node,
-                messageText: `Missing '${sortTypes(missingTypes).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect errors.`,
-                fixes: []
+                messageText: `Missing '${sortTypes(result.missingErrorTypes).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect errors.`,
+                fixes
               }
-            ) : void 0
-          ),
+            );
+          }),
           ignore
         );
       }
@@ -3106,6 +3207,108 @@ Nested Effect-able types may be intended if you plan to later manually flatten o
   })
 });
 
+// src/diagnostics/scopeInLayerEffect.ts
+var scopeInLayerEffect = createDiagnostic({
+  name: "scopeInLayerEffect",
+  code: 13,
+  severity: "warning",
+  apply: fn("scopeInLayerEffect.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
+    const layerModuleIdentifier = yield* pipe(
+      findImportedModuleIdentifierByPackageAndNameOrBarrel(
+        sourceFile,
+        "effect",
+        "Layer"
+      ),
+      map3((_) => _.text),
+      orElse2(() => succeed("Layer"))
+    );
+    function parseLayerEffectApiCall(node) {
+      if (!ts.isCallExpression(node)) return;
+      const expression = node.expression;
+      if (!ts.isPropertyAccessExpression(expression)) return;
+      const calledModule = expression.expression;
+      if (!(ts.isIdentifier(calledModule) && calledModule.text === layerModuleIdentifier)) return;
+      const methodIdentifier = expression.name;
+      if (!(ts.isIdentifier(methodIdentifier) && methodIdentifier.text.toLowerCase().startsWith("effect"))) return;
+      return { methodIdentifier };
+    }
+    const reportIfLayerRequireScope = (type, node, methodIdentifier) => {
+      let toCheck = [type];
+      const entries = [];
+      while (toCheck.length > 0) {
+        const type2 = toCheck.pop();
+        if (type2.isUnion()) {
+          toCheck = toCheck.concat(type2.types);
+        } else {
+          entries.push(type2);
+        }
+      }
+      return pipe(
+        firstSuccessOf(entries.map((type2) => typeParser.scopeType(type2, node))),
+        map3(
+          () => report({
+            node,
+            messageText: `Seems like you are constructing a layer with a scope in the requirements.
+Consider using "scoped" instead to get ride of the scope in the requirements.`,
+            fixes: methodIdentifier ? [{
+              fixName: "scopeInLayerEffect_scoped",
+              description: "Use scoped for Layer creation",
+              apply: gen(function* () {
+                const changeTracker = yield* service(ChangeTracker);
+                changeTracker.replaceNode(
+                  sourceFile,
+                  methodIdentifier,
+                  ts.factory.createIdentifier("scoped")
+                );
+              })
+            }] : []
+          })
+        ),
+        ignore
+      );
+    };
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      const layerEffectApiCall = parseLayerEffectApiCall(node);
+      if (layerEffectApiCall) {
+        const type = typeChecker.getTypeAtLocation(node);
+        yield* pipe(
+          typeParser.layerType(type, node),
+          flatMap2(({ RIn }) => reportIfLayerRequireScope(RIn, node, layerEffectApiCall.methodIdentifier)),
+          ignore
+        );
+        continue;
+      }
+      if (ts.isClassDeclaration(node) && node.name && node.heritageClauses) {
+        const classSym = typeChecker.getSymbolAtLocation(node.name);
+        if (classSym) {
+          const classType = typeChecker.getTypeOfSymbol(classSym);
+          const defaultLayer = typeChecker.getPropertyOfType(classType, "Default");
+          if (defaultLayer) {
+            const type = typeChecker.getTypeOfSymbolAtLocation(defaultLayer, node);
+            yield* pipe(
+              typeParser.layerType(type, node),
+              flatMap2(({ RIn }) => reportIfLayerRequireScope(RIn, node, void 0)),
+              ignore
+            );
+            continue;
+          }
+        }
+      }
+      ts.forEachChild(node, appendNodeToVisit);
+    }
+  })
+});
+
 // src/diagnostics/unnecessaryEffectGen.ts
 var unnecessaryEffectGen = createDiagnostic({
   name: "unnecessaryEffectGen",
@@ -3207,7 +3410,8 @@ var diagnostics = [
   unnecessaryPipe,
   genericEffectServices,
   returnEffectInGen,
-  importFromBarrel
+  importFromBarrel,
+  scopeInLayerEffect
 ];
 
 // src/transform.ts