enhancement(transformer): Add warning for overloads with non literal inputs

Author: martinjlowm

src/transformer/descriptor/method/method.ts

@@ -4,6 +4,7 @@ import { TypescriptCreator } from '../../helper/creator';
 import { MockDefiner } from '../../mockDefiner/mockDefiner';
 import { ModuleName } from '../../mockDefiner/modules/moduleName';
 import { TypescriptHelper } from '../helper/helper';
+import { TransformerLogger } from '../../logger/transformerLogger';
 
 export interface MethodSignature {
   parameters?: ts.ParameterDeclaration[];
@@ -60,6 +61,7 @@ function CreateTypeEquality(signatureType: ts.TypeNode | undefined, primaryDecla
     );
   } else {
     // FIXME: Support `instanceof Class`, falls back to Object for now. The fallback causes undefined behavior!
+    TransformerLogger().overloadNonLiteralParameterNotSupported(signatureType.getText());
     return ts.createBinary(identifier, ts.SyntaxKind.InstanceOfKeyword, ts.createIdentifier('Object'));
   }
 }

src/transformer/logger/transformerLogger.ts

@@ -4,25 +4,29 @@ import { ILogger } from '../../logger/logger.interface';
 let logger: ILogger;
 
 export interface TransformerLogger {
-  unexpectedCreateMock(mockFileName: string, expectedFileName: string): void;
+  overloadNonLiteralParameterNotSupported(type: string): void;
   typeNotSupported(type: string): void;
   typeOfFunctionCallNotFound(node: string): void;
+  unexpectedCreateMock(mockFileName: string, expectedFileName: string): void;
 }
 
 export function TransformerLogger(): TransformerLogger {
   logger = logger || Logger('Transformer');
 
   return {
-    unexpectedCreateMock(mockFileName: string, expectedFileName: string): void {
-      logger.warning(`I\'ve found a mock creator but it comes from a different folder
-            found: ${mockFileName}
-            expected: ${expectedFileName}`);
+    overloadNonLiteralParameterNotSupported(type: string): void {
+      logger.warning(`Non-literal \`${type}' is not supported - falling back to \`instanceof Object' in the conditional typing`);
     },
     typeNotSupported(type: string): void {
       logger.warning(`Not supported type: ${type} - it will convert to null`);
     },
     typeOfFunctionCallNotFound(node: string): void {
       logger.warning(`Cannot find type of function call: ${node} - it will convert to null`);
     },
+    unexpectedCreateMock(mockFileName: string, expectedFileName: string): void {
+      logger.warning(`I\'ve found a mock creator but it comes from a different folder
+            found: ${mockFileName}
+            expected: ${expectedFileName}`);
+    },
   };
 }