fix(core): Allow TestBed.configureTestingModule to work with recursive cycle of standalone components.

JeanMeche · JeanMeche · commit dde14981c982 · 2023-03-18T21:48:21.000+01:00
When having a recursive circle of imports on standalone components, `queueTypesFromModulesArrayRecur` triggered a `Maximum call stack size exceeded` error. This commit fixes this. Fixes #49469
diff --git a/packages/core/test/acceptance/standalone_spec.ts b/packages/core/test/acceptance/standalone_spec.ts
@@ -910,5 +910,39 @@ describe('standalone components, directives, and pipes', () => {
 
       expect(isStandalone(Module)).toBeFalse();
     });
+
+    it('should render a recursive cycle of standalone components', () => {
+      @Component({
+        selector: 'cmp-a',
+        standalone: true,
+        template: '<ng-template [ngIf]="false"><cmp-c></cmp-c></ng-template>A',
+        imports: [forwardRef(() => StandaloneCmpC)],
+      })
+      class StandaloneCmpA {
+      }
+
+      @Component({
+        selector: 'cmp-b',
+        standalone: true,
+        template: '(<cmp-a></cmp-a>)B',
+        imports: [StandaloneCmpA],
+      })
+      class StandaloneCmpB {
+      }
+
+      @Component({
+        selector: 'cmp-c',
+        standalone: true,
+        template: '(<cmp-b></cmp-b>)C',
+        imports: [StandaloneCmpB],
+      })
+      class StandaloneCmpC {
+      }
+
+      TestBed.configureTestingModule({imports: [StandaloneCmpC]});
+      const fixture = TestBed.createComponent(StandaloneCmpC);
+      fixture.detectChanges();
+      expect(fixture.nativeElement.textContent).toBe('((A)B)C');
+    });
   });
 });
diff --git a/packages/core/testing/src/test_bed_compiler.ts b/packages/core/testing/src/test_bed_compiler.ts
@@ -580,20 +580,21 @@ export class TestBedCompiler {
   }
 
   private queueTypesFromModulesArray(arr: any[]): void {
-    // Because we may encounter the same NgModule while processing the imports and exports of an
-    // NgModule tree, we cache them in this set so we can skip ones that have already been seen
-    // encountered. In some test setups, this caching resulted in 10X runtime improvement.
-    const processedNgModuleDefs = new Set();
+    // Because we may encounter the same NgModule or a standalone Component while processing
+    // the dependencies of an NgModule or a standalone Component, we cache them in this set so we
+    // can skip ones that have already been seen encountered. In some test setups, this caching
+    // resulted in 10X runtime improvement.
+    const processedDefs = new Set();
     const queueTypesFromModulesArrayRecur = (arr: any[]): void => {
       for (const value of arr) {
         if (Array.isArray(value)) {
           queueTypesFromModulesArrayRecur(value);
         } else if (hasNgModuleDef(value)) {
           const def = value.&#629;mod;
-          if (processedNgModuleDefs.has(def)) {
+          if (processedDefs.has(def)) {
             continue;
           }
-          processedNgModuleDefs.add(def);
+          processedDefs.add(def);
           // Look through declarations, imports, and exports, and queue
           // everything found there.
           this.queueTypeArray(maybeUnwrapFn(def.declarations), value);
@@ -604,6 +605,12 @@ export class TestBedCompiler {
         } else if (isStandaloneComponent(value)) {
           this.queueType(value, null);
           const def = getComponentDef(value);
+
+          if (processedDefs.has(def)) {
+            continue;
+          }
+          processedDefs.add(def);
+
           const dependencies = maybeUnwrapFn(def.dependencies ?? []);
           dependencies.forEach((dependency) => {
             // Note: in AOT, the `dependencies` might also contain regular
