[RFC] feature(transformer): Conditional typing

.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/extension/method/provider/provider.ts

@@ -1,3 +1,4 @@
+import { applyIdentityProperty } from '../../../utils/applyIdentityProperty';
 import { functionMethod } from './functionMethod';
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type Method = (name: string, value: any) => () => any;
@@ -45,6 +46,10 @@ export class Provider {
       return this._method(name, value());
     }
 
-    return this._method(name, value);
+    // FIXME: Do this smarter, it's a bit counter intuitive to return a new
+    // proxy every single time this function is called. It should probably mock
+    // based on name if that ends up being a string representing the type
+    // signature.
+    return applyIdentityProperty(this._method, name)(name, value);
   }
 }

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/conditionalType/conditionalType.ts

@@ -0,0 +1,100 @@
+import ts from 'typescript';
+import { MethodSignature, TypescriptCreator } from '../../helper/creator';
+import { Scope } from '../../scope/scope';
+import { ResolveSignatureElseBranch } from '../helper/branching';
+import { TypescriptHelper } from '../helper/helper';
+import { GetNullDescriptor } from '../null/null';
+import { GetTypeParameterDescriptor } from '../typeParameter/typeParameter';
+
+function isDeclarationWithTypeParameterChildren(node: ts.Node): node is ts.DeclarationWithTypeParameterChildren {
+  return ts.isFunctionLike(node) ||
+    ts.isClassLike(node) ||
+    ts.isInterfaceDeclaration(node) ||
+    ts.isTypeAliasDeclaration(node);
+}
+
+export function GetConditionalTypeDescriptor(node: ts.ConditionalTypeNode, scope: Scope): ts.Expression {
+  const parentNode: ts.Node = node.parent;
+  if (!isDeclarationWithTypeParameterChildren(parentNode)) {
+    return GetNullDescriptor();
+  }
+
+  const checkType: ts.TypeNode = node.checkType;
+  if (!ts.isTypeReferenceNode(checkType)) {
+    return GetNullDescriptor();
+  }
+
+  const typeName: ts.EntityName = checkType.typeName;
+  if (ts.isQualifiedName(typeName)) {
+    return GetNullDescriptor();
+  }
+
+  const declarations: readonly ts.TypeParameterDeclaration[] = ts.getEffectiveTypeParameterDeclarations(parentNode);
+
+  const declaration: ts.TypeParameterDeclaration | undefined = declarations.find(
+    (parameter: ts.TypeParameterDeclaration) => parameter.name.escapedText === typeName.escapedText,
+  );
+
+  if (!declaration) {
+    return GetNullDescriptor();
+  }
+
+  const statements: ts.Statement[] = [];
+
+  const genericValue: ts.CallExpression = GetTypeParameterDescriptor(declaration, scope);
+
+  const signatures: MethodSignature[] = ConstructSignatures(node);
+  const [signature]: MethodSignature[] = signatures;
+
+  const parameterIdentifier: ts.Identifier = TypescriptHelper.ExtractFirstIdentifier(signature.parameters[0].name);
+  const valueDeclaration: ts.VariableDeclaration = TypescriptCreator.createVariableDeclaration(
+    parameterIdentifier,
+    genericValue,
+  );
+
+  statements.push(
+    TypescriptCreator.createVariableStatement([
+      valueDeclaration,
+    ]),
+  );
+
+  const typeVariableMap: Map<ts.TypeNode, ts.StringLiteral | ts.Identifier> = new Map(
+    signatures.reduce((typeHashTuples: [ts.TypeNode, ts.StringLiteral][], s: MethodSignature) => {
+      const [parameter]: typeof s.parameters | [undefined] = s.parameters;
+      if (!parameter) {
+        return typeHashTuples;
+      }
+
+      if (ts.isFunctionLike(parameter.type)) {
+        typeHashTuples.push([
+          parameter.type,
+          ts.createStringLiteral(
+            TypescriptCreator.createSignatureHash(parameter.type),
+          ),
+        ]);
+      }
+
+      return typeHashTuples;
+    }, [] as [ts.TypeNode, ts.StringLiteral][]),
+  );
+
+  statements.push(ResolveSignatureElseBranch(typeVariableMap, signatures, signature, scope));
+
+  return TypescriptCreator.createIIFE(ts.createBlock(statements, true));
+}
+
+function ConstructSignatures(node: ts.ConditionalTypeNode, signatures: MethodSignature[] = []): MethodSignature[] {
+  if (ts.isConditionalTypeNode(node.trueType)) {
+    return ConstructSignatures(node.trueType, signatures);
+  }
+
+  signatures.push(TypescriptCreator.createMethodSignature([node.extendsType], node.trueType));
+
+  if (ts.isConditionalTypeNode(node.falseType)) {
+    return ConstructSignatures(node.falseType, signatures);
+  }
+
+  signatures.push(TypescriptCreator.createMethodSignature(undefined, node.falseType));
+
+  return signatures;
+}

src/transformer/descriptor/descriptor.ts

@@ -9,6 +9,7 @@ import { GetBooleanFalseDescriptor } from './boolean/booleanFalse';
 import { GetBooleanTrueDescriptor } from './boolean/booleanTrue';
 import { GetCallExpressionDescriptor } from './callExpression/callExpression';
 import { GetClassDeclarationDescriptor } from './class/classDeclaration';
+import { GetConditionalTypeDescriptor } from './conditionalType/conditionalType';
 import { GetConstructorTypeDescriptor } from './constructor/constructorType';
 import { GetEnumDeclarationDescriptor } from './enum/enumDeclaration';
 import { GetExpressionWithTypeArgumentsDescriptor } from './expression/expressionWithTypeArguments';
@@ -143,6 +144,8 @@ export function GetDescriptor(node: ts.Node, scope: Scope): ts.Expression {
       return GetUndefinedDescriptor();
     case ts.SyntaxKind.CallExpression:
       return GetCallExpressionDescriptor(node as ts.CallExpression, scope);
+    case ts.SyntaxKind.ConditionalType:
+      return GetConditionalTypeDescriptor(node as ts.ConditionalTypeNode, scope);
     default:
       TransformerLogger().typeNotSupported(ts.SyntaxKind[node.kind]);
       return GetNullDescriptor();

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);
+}