fix(transformer): Properly distinguish scoped references in a generic context

Author: martinjlowm

src/transformer/genericDeclaration/genericDeclaration.ts

@@ -2,7 +2,7 @@ import * as ts from 'typescript';
 import { GetDescriptor } from '../descriptor/descriptor';
 import { TypescriptHelper } from '../descriptor/helper/helper';
 import { TypescriptCreator } from '../helper/creator';
-import { MockIdentifierGenericCircularReference, MockIdentifierGenericParameterIds, MockIdentifierGenericParameterValue } from '../mockIdentifier/mockIdentifier';
+import { MockIdentifierGenericParameterIds, MockIdentifierGenericParameterValue } from '../mockIdentifier/mockIdentifier';
 import { Scope } from '../scope/scope';
 import { IGenericDeclaration } from './genericDeclaration.interface';
 import { GenericDeclarationSupported } from './genericDeclarationSupported';
@@ -60,12 +60,14 @@ export function GenericDeclaration(scope: Scope): IGenericDeclaration {
         return genericDescriptor || ts.createNull();
       }
 
+      const ownerReference: ts.Identifier = ts.createIdentifier(uniqueName.replace('@', '_'));
+
       return ts.createNew(
         genericDescriptor ? TypescriptCreator.createFunctionExpression(
           ts.createBlock(
             [
               TypescriptCreator.createVariableStatement([
-                TypescriptCreator.createVariableDeclaration(MockIdentifierGenericCircularReference, ts.createIdentifier('this')),
+                TypescriptCreator.createVariableDeclaration(ownerReference, ts.createIdentifier('this')),
               ]),
               ts.createExpressionStatement(
                 ts.createCall(
@@ -90,7 +92,7 @@ export function GenericDeclaration(scope: Scope): IGenericDeclaration {
             ],
           ),
         ) : ts.createPropertyAccess(
-          MockIdentifierGenericCircularReference,
+          ownerReference,
           ts.createIdentifier('constructor'),
         ),
         undefined,
@@ -140,6 +142,8 @@ export function GenericDeclaration(scope: Scope): IGenericDeclaration {
       extensionDeclaration: GenericDeclarationSupported,
       extensionDeclarationKey: string,
       extension: ts.ExpressionWithTypeArguments): void {
+      const nextScope: Scope = scope.currentMockKey ? scope : new Scope(declarationKey);
+
       const extensionDeclarationTypeParameters: ts.NodeArray<ts.TypeParameterDeclaration> | undefined = extensionDeclaration.typeParameters;
 
       if (!extensionDeclarationTypeParameters?.length) {
@@ -167,8 +171,8 @@ export function GenericDeclaration(scope: Scope): IGenericDeclaration {
           }
         }
 
-        if (!typeParameterDeclaration || !scope.isBoundFor(extensionDeclarationKey)) {
-          genericValueDescriptor = GetDescriptor(genericNode, (new Scope(declarationKey)).bindFor(extensionDeclarationKey));
+        if (!typeParameterDeclaration || !nextScope.isBoundFor(extensionDeclarationKey)) {
+          genericValueDescriptor = GetDescriptor(genericNode, nextScope.bindFor(extensionDeclarationKey));
         }
 
         const genericParameter: GenericParameter = createGenericParameter(

src/transformer/mockIdentifier/mockIdentifier.ts

@@ -1,6 +1,5 @@
 import * as ts from 'typescript';
 
-export const MockIdentifierGenericCircularReference: ts.Identifier = ts.createIdentifier('that');
 export const MockIdentifierGenericParameter: ts.Identifier = ts.createIdentifier('t');
 export const MockIdentifierGenericParameterIds: ts.Identifier = ts.createIdentifier('i');
 export const MockIdentifierGenericParameterValue: ts.Identifier = ts.createIdentifier('w');

src/transformer/scope/scope.ts

@@ -3,24 +3,25 @@ import * as ts from 'typescript';
 export type InterfaceOrClassDeclaration = ts.InterfaceDeclaration | ts.ClassDeclaration;
 export class Scope {
   constructor(currentMockKey?: string) {
+    this._boundFor = new Set();
     this._currentMockKey = currentMockKey;
   }
 
   private readonly _currentMockKey: string | undefined;
-  private _boundFor: string | undefined;
+  private _boundFor: Set<string>;
 
   private _appendConstructorMarker(): string {
     return this._boundFor !== undefined ? '_C' : '';
   }
 
   public bindFor(key: string): this {
-    this._boundFor = key;
+    this._boundFor.add(key);
 
     return this;
   }
 
   public isBoundFor(key: string): boolean {
-    return this._boundFor === key;
+    return this._boundFor.has(key);
   }
 
   public get currentMockKey(): string | undefined {

test/transformer/descriptor/generic/extends.test.ts

@@ -245,23 +245,50 @@ describe('for generic', () => {
   });
 
   describe('with circular', () => {
-    interface A extends ClassWithGenerics<A> {
-      b: number;
+    interface GenericC<T> {
+      c: T;
+    }
+
+    interface GenericD<T> {
+      d: T;
+    }
+
+    interface GenericE<T> {
+      e: T;
+    }
+
+    // NOTE: A, A, B
+    interface A extends GenericC<A>, GenericD<A>, GenericE<B> {
+      a: number;
       B: B;
     }
-    interface B extends ClassWithGenerics<B> {
-      c: string;
+
+    // NOTE: B, A, A
+    interface B extends GenericC<B>, GenericD<A>, GenericE<A> {
+      b: string;
       A: A;
     }
 
     it('should avoid infinite extension', () => {
       const propertiesA: A = createMock<A>();
       const propertiesB: B = createMock<B>();
-      expect(propertiesA.a.a.a.b).toBe(0);
-      expect(propertiesA.b).toBe(0);
-      expect(propertiesB.a.a.a.c).toBe('');
-      expect(propertiesB.c).toBe('');
-      expect(propertiesB.A.B.A.a.b).toBe(0);
+
+      // NOTE: First generic reference becomes a new instance and the second
+      // reference becomes a call to the parent's constructor.
+      expect(propertiesA.c.c.c.a).toBe(0);
+      expect(propertiesB.c.c.c.b).toBe('');
+
+      expect(propertiesA.d.d.d.a).toBe(0);
+      expect(propertiesB.d.d.d.a).toBe(0);
+
+      expect(propertiesA.e.e.e.b).toBe('');
+      expect(propertiesB.e.e.e.a).toBe(0);
+
+      expect(propertiesA.e.e.e.A.a).toBe(0);
+      expect(propertiesB.e.e.e.B.b).toBe('');
+
+      expect(propertiesA.c.d.e.b).toBe('');
+      expect(propertiesB.c.d.e.b).toBe('');
     });
   });