[RFC] feature(transformer): Add function overload support

.github/workflows/test.yml

@@ -9,14 +9,15 @@ jobs:
     strategy:
       matrix:
         node-version: [10.x]
+        feature: ['', 'transformOverloads']
 
     steps:
     - uses: actions/checkout@v2
     - name: Use Node.js ${{ matrix.node-version }}
       uses: actions/setup-node@v1
       with:
         node-version: ${{ matrix.node-version }}
-    - name: install ts auto mock and run test
+    - name: install ts auto mock and run test - ${{ matrix.feature }}
       run: |
         sudo apt-get update
         sudo apt-get install -y libgbm-dev
@@ -25,5 +26,4 @@ jobs:
         npm test
       env:
         CI: true
-
-
+        FEATURE: ${{ matrix.feature }}

config/karma/karma.config.base.js

@@ -6,11 +6,12 @@ module.exports = function(config, url) {
     const processService = ProcessService(process);
     const debug = processService.getArgument('DEBUG');
     const disableCache = processService.getArgument('DISABLECACHE');
+    const feature = processService.getArgument('FEATURE') || process.env.FEATURE;
 
     return {
         basePath: '',
         frameworks: ['jasmine'],
-        webpack: webpackConfig(debug, disableCache),
+        webpack: webpackConfig(debug, disableCache, feature),
         webpackMiddleware: {
             stats: 'errors-only'
         },

config/test/webpack.js

@@ -1,7 +1,8 @@
 const transformer = require('../../dist/transformer');
 const path = require('path');
+const webpack = require('webpack');
 
-module.exports = function (debug, disableCache) {
+module.exports = function (debug, disableCache, feature = '') {
     return {
         mode: "development",
         resolve: {
@@ -12,6 +13,11 @@ module.exports = function (debug, disableCache) {
                 ['ts-auto-mock/extension']: path.join(__dirname, '../../dist/extension'),
             }
         },
+        plugins: [
+          new webpack.DefinePlugin({
+            'process.env.FEATURE': `"${feature}"`,
+          }),
+        ],
         module: {
             rules: [
                 {
@@ -26,7 +32,8 @@ module.exports = function (debug, disableCache) {
                         getCustomTransformers: (program) => ({
                             before: [transformer.default(program, {
                                 debug: debug ? debug : false,
-                                cacheBetweenTests: disableCache !== 'true'
+                                cacheBetweenTests: disableCache !== 'true',
+                                features: [feature],
                             })]
                         })
                     }

src/extension/method/provider/functionMethod.ts

@@ -1,5 +1,5 @@
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function functionMethod(name: string, value: () => any): any {
+export function functionMethod(name: string, value: (...args: any[]) => any): any {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  return (): any => value();
+  return (...args: any[]): any => value(...args);
 }

src/merge/merge.ts

@@ -1,4 +1,4 @@
-import { merge} from 'lodash-es';
+import { merge } from 'lodash-es';
 import { DeepPartial } from '../partial/deepPartial';
 
 export class Merge {

src/options/default.ts

@@ -3,4 +3,5 @@ import { TsAutoMockOptions } from './options';
 export const defaultOptions: TsAutoMockOptions = {
   debug: false,
   cacheBetweenTests: true,
+  features: [],
 };

src/options/features.ts

@@ -0,0 +1,11 @@
+import { GetOptionByKey } from './options';
+
+interface Features {
+  transformOverloads: unknown;
+}
+
+export type TsAutoMockFeaturesOptions = Array<keyof Features>;
+
+export function GetTsAutoMockFeaturesOptions(): TsAutoMockFeaturesOptions {
+  return GetOptionByKey('features');
+}

src/options/options.ts

@@ -1,10 +1,12 @@
 import { TsAutoMockCacheOptions } from './cache';
 import { TsAutoMockDebugOptions } from './debug';
+import { TsAutoMockFeaturesOptions } from './features';
 import { defaultOptions } from './default';
 
 export interface TsAutoMockOptions {
   debug: TsAutoMockDebugOptions;
   cacheBetweenTests: TsAutoMockCacheOptions;
+  features: TsAutoMockFeaturesOptions;
 }
 
 let tsAutoMockOptions: TsAutoMockOptions = defaultOptions;

src/repository/repository.ts

@@ -1,4 +1,7 @@
-type Factory = Function;
+import { applyIdentityProperty } from '../utils/applyIdentityProperty';
+
+// eslint-disable-next-line
+type Factory = (...args: any[]) => any;
 
 export class Repository {
   private readonly _repository: { [key: string]: Factory };
@@ -15,7 +18,7 @@ export class Repository {
   }
 
   public registerFactory(key: string, factory: Factory): void {
-    this._repository[key] = factory;
+    this._repository[key] = applyIdentityProperty(factory, key);
   }
 
   public getFactory(key: string): Factory {

src/transformer/descriptor/helper/branching.ts

@@ -0,0 +1,118 @@
+import ts from 'typescript';
+import { MethodSignature } from '../../helper/creator';
+import { TypescriptHelper } from '../helper/helper';
+import { GetDescriptor } from '../descriptor';
+import { Scope } from '../../scope/scope';
+
+function CreateTypeEquality(typeVariableMap: Map<ts.TypeNode, ts.StringLiteral | ts.Identifier>, parameterType: ts.TypeNode | undefined, primaryDeclaration: ts.ParameterDeclaration): ts.Expression {
+  const declarationName: ts.Identifier = TypescriptHelper.ExtractFirstIdentifier(primaryDeclaration.name);
+
+  if (!parameterType) {
+    return ts.createPrefix(
+      ts.SyntaxKind.ExclamationToken,
+      ts.createPrefix(
+        ts.SyntaxKind.ExclamationToken,
+        declarationName,
+      ),
+    );
+  }
+
+  if (TypescriptHelper.IsLiteralOrPrimitive(parameterType)) {
+    return ts.createStrictEquality(
+      ts.createTypeOf(declarationName),
+      parameterType ? ts.createStringLiteral(parameterType.getText()) : ts.createVoidZero(),
+    );
+  }
+
+  if (typeVariableMap.has(parameterType)) {
+    // eslint-disable-next-line
+    const parameterIdentifier: ts.StringLiteral | ts.Identifier = typeVariableMap.get(parameterType)!;
+    return ts.createStrictEquality(
+      ts.createLogicalAnd(declarationName, ts.createPropertyAccess(declarationName, '__ident')),
+      parameterIdentifier,
+    );
+  }
+  return ts.createBinary(declarationName, ts.SyntaxKind.InstanceOfKeyword, ts.createIdentifier('Object'));
+}
+
+function CreateUnionTypeOfEquality(
+  typeVariableMap: Map<ts.TypeNode, ts.StringLiteral | ts.Identifier>,
+  signatureType: ts.TypeNode | undefined,
+  primaryDeclaration: ts.ParameterDeclaration,
+): ts.Expression {
+  const typeNodesAndVariableReferences: Array<ts.TypeNode> = [];
+
+  if (signatureType) {
+    if (ts.isTypeNode(signatureType) && ts.isUnionTypeNode(signatureType)) {
+      typeNodesAndVariableReferences.push(...signatureType.types);
+    } else {
+      typeNodesAndVariableReferences.push(signatureType);
+    }
+  }
+
+  const [firstType, ...remainingTypes]: Array<ts.TypeNode> = typeNodesAndVariableReferences;
+
+  return remainingTypes.reduce(
+    (prevStatement: ts.Expression, typeNode: ts.TypeNode) =>
+      ts.createLogicalOr(
+        prevStatement,
+        CreateTypeEquality(typeVariableMap, typeNode, primaryDeclaration),
+      ),
+    CreateTypeEquality(typeVariableMap, firstType, primaryDeclaration),
+  );
+}
+
+function ResolveParameterBranch(
+  typeVariableMap: Map<ts.TypeNode, ts.StringLiteral | ts.Identifier>,
+  declarations: ts.NodeArray<ts.ParameterDeclaration> | [undefined],
+  longedSignature: MethodSignature,
+  returnType: ts.TypeNode,
+  elseBranch: ts.Statement,
+  scope: Scope,
+): ts.Statement {
+  // NOTE: The strange signature here is to cover an empty list of declarations,
+  // then firstDeclaration will be undefined.
+  const [firstDeclaration, ...remainingDeclarations]: ts.NodeArray<ts.ParameterDeclaration> | [undefined] = declarations;
+
+  // TODO: These conditions quickly grow in size, but it should be possible to
+  // squeeze things together and optimize it with something like:
+  //
+  // const typeOf = function (left, right) { return typeof left === right; }
+  // const evaluate = (function(left, right) { return this._ = this._ || typeOf(left, right); }).bind({})
+  //
+  // if (evaluate(firstArg, 'boolean') && evaluate(secondArg, 'number') && ...) {
+  //   ...
+  // }
+  //
+  // `this._' acts as a cache, since the control flow may evaluate the same
+  // conditions multiple times.
+  const condition: ts.Expression = remainingDeclarations.reduce(
+    (prevStatement: ts.Expression, declaration: ts.ParameterDeclaration, index: number) =>
+      ts.createLogicalAnd(
+        prevStatement,
+        CreateUnionTypeOfEquality(typeVariableMap, declaration.type, longedSignature.parameters[index + 1]),
+      ),
+    CreateUnionTypeOfEquality(typeVariableMap, firstDeclaration?.type, longedSignature.parameters[0]),
+  );
+
+  return ts.createIf(condition, ts.createReturn(GetDescriptor(returnType, scope)), elseBranch);
+}
+
+export function ResolveSignatureElseBranch(
+  typeVariableMap: Map<ts.TypeNode, ts.StringLiteral | ts.Identifier>,
+  signatures: MethodSignature[],
+  longestParameterList: MethodSignature,
+  scope: Scope,
+): ts.Statement {
+  const [signature, ...remainingSignatures]: MethodSignature[] = signatures;
+
+  const indistinctSignatures: boolean = signatures.every((sig: ts.MethodSignature) => !sig.parameters?.length);
+  if (!remainingSignatures.length || indistinctSignatures) {
+    return ts.createReturn(GetDescriptor(signature.type, scope));
+  }
+
+  const elseBranch: ts.Statement = ResolveSignatureElseBranch(typeVariableMap, remainingSignatures, longestParameterList, scope);
+
+  const currentParameters: ts.NodeArray<ts.ParameterDeclaration> = signature.parameters || [];
+  return ResolveParameterBranch(typeVariableMap, currentParameters, longestParameterList, signature.type, elseBranch, scope);
+}

src/transformer/descriptor/helper/helper.ts

@@ -6,12 +6,38 @@ type Declaration = ts.InterfaceDeclaration | ts.ClassDeclaration | ts.TypeAliasD
 type ImportDeclaration = ts.ImportEqualsDeclaration | ts.ImportOrExportSpecifier | ts.ImportClause;
 
 export namespace TypescriptHelper {
-  export function IsLiteralOrPrimitive(typeNode: ts.Node): boolean {
-    return ts.isLiteralTypeNode(typeNode) ||
-            typeNode.kind === ts.SyntaxKind.StringKeyword ||
-            typeNode.kind === ts.SyntaxKind.BooleanKeyword ||
-            typeNode.kind === ts.SyntaxKind.NumberKeyword ||
-            typeNode.kind === ts.SyntaxKind.ArrayType;
+  export interface PrimitiveTypeNode extends ts.TypeNode {
+    kind: ts.SyntaxKind.LiteralType | ts.SyntaxKind.NumberKeyword | ts.SyntaxKind.ObjectKeyword | ts.SyntaxKind.BooleanKeyword | ts.SyntaxKind.StringKeyword | ts.SyntaxKind.ArrayType;
+  }
+
+  export function ExtractFirstIdentifier(bindingName: ts.BindingName): ts.Identifier {
+    let identifier: ts.BindingName = bindingName;
+    let saneSearchLimit: number = 10;
+
+    while (!ts.isIdentifier(identifier)) {
+      const [bindingElement]: Array<ts.BindingElement | undefined> = (identifier.elements as ts.NodeArray<ts.ArrayBindingElement>).filter(ts.isBindingElement);
+      if (!bindingElement || !--saneSearchLimit) {
+        throw new Error('Failed to find an identifier for the primary declaration!');
+      }
+
+      identifier = bindingElement.name;
+    }
+
+    return identifier;
+  }
+
+  export function IsLiteralOrPrimitive(typeNode: ts.Node): typeNode is PrimitiveTypeNode {
+    switch (typeNode.kind) {
+      case ts.SyntaxKind.LiteralType:
+      case ts.SyntaxKind.NumberKeyword:
+      case ts.SyntaxKind.ObjectKeyword:
+      case ts.SyntaxKind.BooleanKeyword:
+      case ts.SyntaxKind.StringKeyword:
+      case ts.SyntaxKind.ArrayType:
+        return true;
+    }
+
+    return false;
   }
 
   export function GetDeclarationFromNode(node: ts.Node): ts.Declaration {

src/transformer/descriptor/method/bodyReturnType.ts

@@ -7,21 +7,21 @@ export function GetReturnTypeFromBodyDescriptor(node: ts.ArrowFunction | ts.Func
   return GetDescriptor(GetReturnNodeFromBody(node), scope);
 }
 
-export function GetReturnNodeFromBody(node: ts.FunctionLikeDeclaration): ts.Node {
-  let returnValue: ts.Node | undefined;
+export function GetReturnNodeFromBody(node: ts.FunctionLikeDeclaration): ts.Expression {
+  let returnValue: ts.Expression | undefined;
 
   const functionBody: ts.ConciseBody | undefined = node.body;
 
   if (functionBody && ts.isBlock(functionBody)) {
-    const returnStatement: ts.ReturnStatement = GetReturnStatement(functionBody);
+    const returnStatement: ts.ReturnStatement | undefined = GetReturnStatement(functionBody);
 
     if (returnStatement) {
       returnValue = returnStatement.expression;
     } else {
       returnValue = GetNullDescriptor();
     }
   } else {
-    returnValue = node.body;
+    returnValue = functionBody;
   }
 
   if (!returnValue) {
@@ -31,6 +31,8 @@ export function GetReturnNodeFromBody(node: ts.FunctionLikeDeclaration): ts.Node
   return returnValue;
 }
 
-function GetReturnStatement(body: ts.FunctionBody): ts.ReturnStatement {
-  return body.statements.find((statement: ts.Statement) => statement.kind === ts.SyntaxKind.ReturnStatement) as ts.ReturnStatement;
+function GetReturnStatement(body: ts.FunctionBody): ts.ReturnStatement | undefined {
+  return body.statements.find(
+    (statement: ts.Statement): statement is ts.ReturnStatement => statement.kind === ts.SyntaxKind.ReturnStatement,
+  );
 }

src/transformer/descriptor/method/functionAssignment.ts

@@ -1,14 +1,26 @@
 import * as ts from 'typescript';
 import { Scope } from '../../scope/scope';
+import { TypescriptCreator } from '../../helper/creator';
 import { PropertySignatureCache } from '../property/cache';
-import { GetReturnTypeFromBodyDescriptor } from './bodyReturnType';
+import { GetReturnNodeFromBody } from './bodyReturnType';
 import { GetMethodDescriptor } from './method';
 
 type functionAssignment = ts.ArrowFunction | ts.FunctionExpression;
 
 export function GetFunctionAssignmentDescriptor(node: functionAssignment, scope: Scope): ts.Expression {
   const property: ts.PropertyName = PropertySignatureCache.instance.get();
-  const returnValue: ts.Expression = GetReturnTypeFromBodyDescriptor(node, scope);
+  const returnValue: ts.Expression = GetReturnNodeFromBody(node);
 
-  return GetMethodDescriptor(property, returnValue);
+  const returnType: ts.TypeNode = ts.createLiteralTypeNode(returnValue as ts.LiteralExpression);
+
+  return GetMethodDescriptor(
+    property,
+    [
+      TypescriptCreator.createMethodSignature(
+        undefined,
+        returnType,
+      ),
+    ],
+    scope,
+  );
 }