fix(indexedAccessType): ensure compiler doesn't break for unsupported indexed access type

Author: uittorio

src/transformer/descriptor/indexedAccess/indexedAccess.ts

@@ -40,9 +40,10 @@ export function GetIndexedAccessTypeDescriptor(node: ts.IndexedAccessTypeNode, s
     const propertySymbol: ts.Symbol | undefined = typeChecker.getPropertyOfType(typeChecker.getTypeFromTypeNode(node.objectType), propertyName);
 
     if (!propertySymbol) {
-      throw new Error(
-        `The type checker failed to look up symbol for property: \`${propertyName}' of \`${node.getText()}'.`,
-      );
+      // FIXME: Currently not all IndexedAccessType transformation are supported.
+      // See https://github.com/Typescript-TDD/ts-auto-mock/issues/201 for more details.
+      TransformerLogger().indexedAccessTypeFailed(propertyName, node.getText());
+      return GetNullDescriptor();
     }
 
     return GetDescriptor(TypescriptHelper.GetDeclarationFromSymbol(propertySymbol), scope);

src/transformer/logger/transformerLogger.ts

@@ -8,6 +8,7 @@ export interface TransformerLogger {
   unexpectedCreateMock(mockFileName: string, expectedFileName: string): void;
   typeNotSupported(type: string): void;
   typeOfFunctionCallNotFound(node: string): void;
+  indexedAccessTypeFailed(propertyName: string, nodeText: string): void;
 }
 
 export function TransformerLogger(): TransformerLogger {
@@ -31,5 +32,8 @@ export function TransformerLogger(): TransformerLogger {
     typeOfFunctionCallNotFound(node: string): void {
       logger.warning(`Cannot find type of function call: ${node} - it will convert to null`);
     },
+    indexedAccessTypeFailed(propertyName: string, nodeText: string ): void {
+      logger.warning(`IndexedAccessType transformation failed: cannot find property ${propertyName} of - ${nodeText}`);
+    },
   };
 }

test/transformer/descriptor/indexedAccess/indexedAccess.test.ts

@@ -60,4 +60,17 @@ describe('indexedAccess', () => {
     expect(mock.c.a.b).toEqual(0);
     expect(mock.c.b).toEqual('');
   });
+
+  it('should not break the compiler for unsupported generic', () => {
+    interface StandardInterface {
+      prop: string;
+    }
+    interface WithKeyGeneric<U extends keyof StandardInterface> {
+      test(): StandardInterface[U];
+    }
+
+    const type: WithKeyGeneric<'prop'> = createMock<WithKeyGeneric<'prop'>>();
+
+    expect(type.test()).toBeNull();
+  });
 });

ui/src/views/types-not-supported.mdx

@@ -95,3 +95,39 @@ circle `A` over and over, and result in an infinite nested tree of declaration
 references. The intended behavior is to have the first back-reference stored
 elsewhere in the generated output and let it reference itself, making the
 runtime a lazy-evaluated sequence of getters.
+
+## Indexed access type with generics
+```ts
+interface StandardInterface {
+    prop: string;
+}
+
+interface WithKeyGeneric<U extends keyof StandardInterface> {
+    test(): StandardInterface[U];
+}
+
+const type = createMock<WithKeyGeneric<'prop'>>();
+
+expect(type.test()).toBe(''); // it will be null
+```
+
+These are discussed here:
+[link](https://github.com/Typescript-TDD/ts-auto-mock/issues/201).
+Indexed access type it's a though feature to handle correctly.
+There are few difference scenarios:
+- From MappedTypes
+```ts
+type Test = {[key in keyof A]: A[key]};
+```
+- From Generics -> example above
+- From literal
+```ts
+interface StandardInterface {
+    prop: string;
+}
+
+type Hello = StandardInterface['prop'];
+```
+
+
+