feat(transformer): Support circular interface extensions

Utilize constructors to support circular generics for instantiable types.

If the transformer experiences circular generics, the scope descriptor parameter
is now used to preserve a nested state to avoid looping descriptors forever. The
scope enables the generic descriptor to determine whether to emit a new instance
of the extension or to reuse the parent's constructor (which would emit an
instance of the same prototype), i.e.:

```
getFactory("@factory")([{
  i: ["@parameterId"],
  w: function () { return new function () { Object.assign(this, ɵRepository.ɵRepository.instance.getFactory("@factory")([{
    i: ["@parameterId"],
    w: function () { return new this.constructor; }
  }])); }; }
}])
```

Author: martinjlowm

src/transformer/descriptor/helper/helper.ts

@@ -60,10 +60,10 @@ export namespace TypescriptHelper {
     return declarations[0];
   }
 
-  export function GetParameterOfNode(node: ts.EntityName): ts.NodeArray<ts.TypeParameterDeclaration> {
+  export function GetParameterOfNode(node: ts.EntityName): ts.NodeArray<ts.TypeParameterDeclaration> | undefined {
     const declaration: ts.Declaration = GetDeclarationFromNode(node);
 
-    const { typeParameters = ts.createNodeArray([]) }: Declaration = (declaration as Declaration);
+    const { typeParameters }: Declaration = (declaration as Declaration);
 
     return typeParameters;
   }

src/transformer/genericDeclaration/genericDeclaration.ts

@@ -2,22 +2,34 @@ import * as ts from 'typescript';
 import { GetDescriptor } from '../descriptor/descriptor';
 import { TypescriptHelper } from '../descriptor/helper/helper';
 import { TypescriptCreator } from '../helper/creator';
-import { TransformerLogger } from '../logger/transformerLogger';
-import { MockDefiner } from '../mockDefiner/mockDefiner';
 import { MockIdentifierGenericParameterIds, MockIdentifierGenericParameterValue } from '../mockIdentifier/mockIdentifier';
 import { Scope } from '../scope/scope';
 import { IGenericDeclaration } from './genericDeclaration.interface';
 import { GenericDeclarationSupported } from './genericDeclarationSupported';
 import { GenericParameter } from './genericParameter';
 
+function isInstantiable(node: ts.Declaration | undefined): boolean {
+  let actualType: ts.Node | undefined = node;
+
+  if (!actualType) {
+    return false;
+  }
+
+  while (ts.isTypeAliasDeclaration(actualType)) {
+    actualType = actualType.type;
+  }
+
+  return !TypescriptHelper.IsLiteralOrPrimitive(actualType);
+}
+
 export function GenericDeclaration(scope: Scope): IGenericDeclaration {
   const generics: GenericParameter[] = [];
 
   function isGenericProvided<T extends ts.TypeReferenceNode | ts.ExpressionWithTypeArguments>(node: T, index: number): node is T & Required<ts.NodeWithTypeArguments> {
     return !!node.typeArguments && !!node.typeArguments[index];
   }
 
-  function getGenericNode(node: ts.TypeReferenceNode | ts.ExpressionWithTypeArguments, nodeDeclaration: ts.TypeParameterDeclaration, index: number): ts.Node {
+  function getGenericNode(node: ts.TypeReferenceNode | ts.ExpressionWithTypeArguments, nodeDeclaration: ts.TypeParameterDeclaration, index: number): ts.TypeNode {
     if (isGenericProvided(node, index)) {
       return node.typeArguments[index];
     }
@@ -40,11 +52,50 @@ export function GenericDeclaration(scope: Scope): IGenericDeclaration {
     }
   }
 
-  function createGenericParameter(ownerKey: string, nodeOwnerParameter: ts.TypeParameterDeclaration, genericDescriptor: ts.Expression): GenericParameter {
+  function createGenericParameter(ownerKey: string, nodeOwnerParameter: ts.TypeParameterDeclaration, genericDescriptor: ts.Expression | undefined, instantiable: boolean): GenericParameter {
     const uniqueName: string = ownerKey + nodeOwnerParameter.name.escapedText.toString();
-    const genericFunction: ts.FunctionExpression = TypescriptCreator.createFunctionExpression(ts.createBlock(
-      [ts.createReturn(genericDescriptor)],
-    ));
+
+    const genericValueDescriptor: ts.Expression = ((): ts.Expression => {
+      if (!instantiable) {
+        return genericDescriptor || ts.createNull();
+      }
+
+      return ts.createNew(
+        genericDescriptor ? TypescriptCreator.createFunctionExpression(
+          ts.createBlock(
+            [
+              ts.createExpressionStatement(
+                ts.createCall(
+                  ts.createPropertyAccess(
+                    ts.createIdentifier('Object'),
+                    ts.createIdentifier('assign'),
+                  ),
+                  undefined,
+                  [
+                    ts.createIdentifier('this'),
+                    genericDescriptor,
+                  ]
+                ),
+              ),
+            ],
+          ),
+        ) : ts.createPropertyAccess(
+          ts.createIdentifier('this'),
+          ts.createIdentifier('constructor'),
+        ),
+        undefined,
+        undefined,
+      );
+    })();
+
+    const genericFunction: ts.FunctionExpression =
+      TypescriptCreator.createFunctionExpression(
+        ts.createBlock([
+          ts.createReturn(
+            genericValueDescriptor,
+          ),
+        ]),
+      );
 
     return {
       ids: [uniqueName],
@@ -54,9 +105,9 @@ export function GenericDeclaration(scope: Scope): IGenericDeclaration {
 
   return {
     addFromTypeReferenceNode(node: ts.TypeReferenceNode, declarationKey: string): void {
-      const typeParameterDeclarations: ts.NodeArray<ts.TypeParameterDeclaration> = TypescriptHelper.GetParameterOfNode(node.typeName);
+      const typeParameterDeclarations: ts.NodeArray<ts.TypeParameterDeclaration> | undefined = TypescriptHelper.GetParameterOfNode(node.typeName);
 
-      if (!typeParameterDeclarations) {
+      if (!typeParameterDeclarations?.length) {
         return;
       }
 
@@ -66,7 +117,9 @@ export function GenericDeclaration(scope: Scope): IGenericDeclaration {
         const genericParameter: GenericParameter = createGenericParameter(
           declarationKey,
           typeParameterDeclarations[index],
-          GetDescriptor(genericNode, scope));
+          GetDescriptor(genericNode, scope),
+          false,
+        );
 
         generics.push(genericParameter);
       });
@@ -79,24 +132,18 @@ export function GenericDeclaration(scope: Scope): IGenericDeclaration {
       extension: ts.ExpressionWithTypeArguments): void {
       const extensionDeclarationTypeParameters: ts.NodeArray<ts.TypeParameterDeclaration> | undefined = extensionDeclaration.typeParameters;
 
-      if (!extensionDeclarationTypeParameters) {
+      if (!extensionDeclarationTypeParameters?.length) {
         return;
       }
 
       extensionDeclarationTypeParameters.reduce((acc: GenericParameter[], declaration: ts.TypeParameterDeclaration, index: number) => {
         const genericNode: ts.Node = getGenericNode(extension, declaration, index);
 
+        let typeParameterDeclaration: ts.Declaration | undefined;
+        let genericValueDescriptor: ts.Expression | undefined;
+
         if (ts.isTypeReferenceNode(genericNode)) {
-          const typeParameterDeclaration: ts.Declaration = TypescriptHelper.GetDeclarationFromNode(genericNode.typeName);
-
-          const isExtendingItself: boolean = MockDefiner.instance.getDeclarationKeyMap(typeParameterDeclaration) === declarationKey;
-          if (isExtendingItself) {
-            // FIXME: Currently, circular generics aren't supported. See
-            // https://github.com/Typescript-TDD/ts-auto-mock/pull/312 for more
-            // details.
-            TransformerLogger().circularGenericNotSupported(genericNode.getText());
-            return acc;
-          }
+          typeParameterDeclaration = TypescriptHelper.GetDeclarationFromNode(genericNode.typeName);
 
           if (ts.isTypeParameterDeclaration(typeParameterDeclaration)) {
             addGenericParameterToExisting(
@@ -110,10 +157,15 @@ export function GenericDeclaration(scope: Scope): IGenericDeclaration {
           }
         }
 
+        if (!typeParameterDeclaration || scope.currentMockKey !== declarationKey) {
+          genericValueDescriptor = GetDescriptor(genericNode, new Scope(declarationKey));
+        }
+
         const genericParameter: GenericParameter = createGenericParameter(
           extensionDeclarationKey,
-          extensionDeclarationTypeParameters[index],
-          GetDescriptor(genericNode, scope),
+          declaration,
+          genericValueDescriptor,
+          isInstantiable(typeParameterDeclaration),
         );
 
         acc.push(genericParameter);

src/transformer/logger/transformerLogger.ts

@@ -4,7 +4,6 @@ import { ILogger } from '../../logger/logger.interface';
 let logger: ILogger;
 
 export interface TransformerLogger {
-  circularGenericNotSupported(nodeName: string): void;
   unexpectedCreateMock(mockFileName: string, expectedFileName: string): void;
   typeNotSupported(type: string): void;
   typeOfFunctionCallNotFound(node: string): void;
@@ -15,12 +14,6 @@ export function TransformerLogger(): TransformerLogger {
   logger = logger || Logger('Transformer');
 
   return {
-    circularGenericNotSupported(nodeName: string): void {
-      logger.warning(
-        `Found a circular generic of \`${nodeName}' and such generics are currently not supported. ` +
-          'The generated mock will be incomplete.',
-      );
-    },
     unexpectedCreateMock(mockFileName: string, expectedFileName: string): void {
       logger.warning(`I\'ve found a mock creator but it comes from a different folder
             found: ${mockFileName}

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

@@ -248,11 +248,17 @@ describe('for generic', () => {
     interface A extends ClassWithGenerics<A> {
       b: number;
     }
+    interface B extends ClassWithGenerics<B> {
+      c: string;
+    }
 
     it('should avoid infinite extension', () => {
-      const properties: A = createMock<A>();
-      expect(properties.a).toBeDefined();
-      expect(properties.b).toBe(0);
+      const propertiesA: A = createMock<A>();
+      const propertiesB: B = createMock<B>();
+      expect(propertiesA.a.b).toBe(0);
+      expect(propertiesA.b).toBe(0);
+      expect(propertiesB.a.c).toBe('');
+      expect(propertiesB.c).toBe('');
     });
   });