enhancement(transformer): Support overloads on interfaces

Author: martinjlowm

src/transformer/descriptor/method/functionReturnType.ts

@@ -1,14 +1,16 @@
 import * as ts from 'typescript';
 import { GetReturnNodeFromBody } from './bodyReturnType';
 
-export function GetFunctionReturnType(node: ts.FunctionLikeDeclaration): ts.Node {
-  let returnType: ts.Node;
+export function GetFunctionReturnType(node: ts.SignatureDeclaration): ts.Node {
+  if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+    return GetReturnNodeFromBody(node);
+  }
 
-  if (node.type) {
-    returnType = node.type;
-  } else {
-    returnType = GetReturnNodeFromBody(node);
+  if (!node.type) {
+    throw new Error(
+      `The transformer couldn't determine the type of ${node.getText()}. Did you declare its type?`,
+    );
   }
 
-  return returnType;
+  return node.type;
 }

src/transformer/descriptor/method/method.ts

@@ -1,4 +1,6 @@
 import ts from 'typescript';
+import { GetTsAutoMockOverloadOptions, TsAutoMockOverloadOptions } from '../../../options/overload';
+import { GetClassDeclarationDescriptor } from '../class/classDeclaration';
 import { TypescriptCreator } from '../../helper/creator';
 import { MockDefiner } from '../../mockDefiner/mockDefiner';
 import { ModuleName } from '../../mockDefiner/modules/moduleName';
@@ -9,7 +11,7 @@ export interface MethodSignature {
   returnValue: ts.Expression;
 }
 
-export function GetMethodDescriptor(propertyName: ts.PropertyName, methodSignatures: MethodSignature[]): ts.Expression {
+export function GetMethodDescriptor(propertyName: ts.PropertyName, methodSignatures: MethodSignature[]): ts.CallExpression {
   const providerGetMethod: ts.PropertyAccessExpression = CreateProviderGetMethod();
 
   const propertyNameString: string = TypescriptHelper.GetStringPropertyName(propertyName);
@@ -97,12 +99,13 @@ function ResolveParameterBranch(declarations: ts.ParameterDeclaration[], allDecl
     CreateUnionTypeOfEquality(firstDeclaration.type, allDeclarations[0]),
   );
 
-
   return ts.createIf(condition, ts.createReturn(returnValue), elseBranch);
 }
 
-function ResolveSignatureElseBranch(signatures: MethodSignature[], longestParameterList: ts.ParameterDeclaration[]): ts.Statement {
-  const [signature, ...remainingSignatures]: MethodSignature[] = signatures;
+export function ResolveSignatureElseBranch(signatures: MethodSignature[], longestParameterList: ts.ParameterDeclaration[]): ts.Statement {
+  const transformOverloadsOption: TsAutoMockOverloadOptions = GetTsAutoMockOverloadOptions();
+
+  const [signature, ...remainingSignatures]: MethodSignature[] = signatures.filter((_: unknown, i: number) => transformOverloadsOption || i === 0);
 
   if (remainingSignatures.length) {
     const elseBranch: ts.Statement = ResolveSignatureElseBranch(remainingSignatures, longestParameterList);

src/transformer/descriptor/method/methodDeclaration.ts

@@ -17,16 +17,7 @@ export function GetMethodDeclarationDescriptor(node: ts.MethodDeclaration | ts.F
     methodDeclarations.push(node);
   }
 
-  const methodSignatures: MethodSignature[] = methodDeclarations.map(
-    (declaration: ts.MethodDeclaration | ts.FunctionDeclaration) => {
-      const returnTypeNode: ts.Node = GetFunctionReturnType(declaration);
-
-      return {
-        parameters: declaration.parameters.map((parameter: ts.ParameterDeclaration) => parameter),
-        returnValue: GetDescriptor(returnTypeNode, scope),
-      };
-    }
-  );
+  const methodSignatures: MethodSignature[] = methodDeclarations.map((declaration: ts.MethodDeclaration | ts.FunctionDeclaration) => ReshapeCallableDeclaration(declaration, scope));
 
   if (!node.name) {
     throw new Error(
@@ -36,3 +27,12 @@ export function GetMethodDeclarationDescriptor(node: ts.MethodDeclaration | ts.F
 
   return GetMethodDescriptor(node.name, methodSignatures);
 }
+
+export function ReshapeCallableDeclaration(declaration: ts.SignatureDeclaration, scope: Scope): MethodSignature {
+  const returnTypeNode: ts.Node = GetFunctionReturnType(declaration);
+
+  return {
+    parameters: declaration.parameters.map((parameter: ts.ParameterDeclaration) => parameter),
+    returnValue: GetDescriptor(returnTypeNode, scope),
+  };
+}

src/transformer/descriptor/mock/mockCall.ts

@@ -1,27 +1,35 @@
 import * as ts from 'typescript';
 import { TypescriptCreator } from '../../helper/creator';
 import { MockIdentifierInternalValues, MockIdentifierObjectReturnValue } from '../../mockIdentifier/mockIdentifier';
+import { GetMethodDescriptor, MethodSignature } from '../method/method';
 import { GetMockMarkerProperty, Property } from './mockMarker';
 import { PropertyAssignments } from './mockPropertiesAssignments';
 
-export function GetMockCall(properties: PropertyAssignments, signature: ts.Expression | null): ts.CallExpression {
+export function GetMockCall(properties: PropertyAssignments, signatures: MethodSignature[]): ts.CallExpression {
   const mockObjectReturnValueName: ts.Identifier = MockIdentifierObjectReturnValue;
+
+  if (signatures.length) {
+    // FIXME: It'd probably be wise to extract the name of the callable
+    // signature and fallback to `new` or smth if there is none.
+    return GetMethodDescriptor(ts.createStringLiteral('new'), signatures);
+  }
+
   const statements: ts.Statement[] = [
     TypescriptCreator.createVariableStatement([
       TypescriptCreator.createVariableDeclaration(MockIdentifierInternalValues, ts.createObjectLiteral()),
-      TypescriptCreator.createVariableDeclaration(mockObjectReturnValueName, signature || ts.createObjectLiteral(properties.literals)),
+      TypescriptCreator.createVariableDeclaration(mockObjectReturnValueName, ts.createObjectLiteral(properties.literals)),
     ]),
   ];
 
-  if (signature) {
-    let literalProperty: ts.PropertyAssignment;
-    let index: number = 0;
+  // if (signatures[0]) {
+  //   let literalProperty: ts.PropertyAssignment;
+  //   let index: number = 0;
 
-    // tslint:disable-next-line:no-conditional-assignment
-    while ((literalProperty = properties.literals[index++])) {
-      statements.push(AssignLiteralPropertyTo(mockObjectReturnValueName, literalProperty));
-    }
-  }
+  //   // tslint:disable-next-line:no-conditional-assignment
+  //   while ((literalProperty = properties.literals[index++])) {
+  //     statements.push(AssignLiteralPropertyTo(mockObjectReturnValueName, literalProperty));
+  //   }
+  // }
 
   if (properties.lazy.length) {
     const addPropertiesToUniqueVariable: ts.ExpressionStatement = AssignPropertiesTo(properties.lazy, mockObjectReturnValueName);
@@ -30,24 +38,24 @@ export function GetMockCall(properties: PropertyAssignments, signature: ts.Expre
 
   const addMockMarkerToUniqueVariable: ts.ExpressionStatement = AssignMockMarkerPropertyTo(mockObjectReturnValueName);
   statements.push(addMockMarkerToUniqueVariable);
-
   statements.push(ts.createReturn(mockObjectReturnValueName));
 
   const functionBlock: ts.Block = ts.createBlock(statements);
   const functionExpression: ts.FunctionExpression = TypescriptCreator.createFunctionExpression(functionBlock);
   const IFFEFunction: ts.ParenthesizedExpression = ts.createParen(functionExpression);
+
   return ts.createCall(IFFEFunction, [], []);
 }
 
-function AssignVariableTo(variable: ts.Expression, expression: ts.Expression): ts.ExpressionStatement {
-  const binaryExpression: ts.BinaryExpression = ts.createBinary(variable, ts.SyntaxKind.EqualsToken, expression);
-  return ts.createExpressionStatement(binaryExpression);
-}
+// function AssignVariableTo(variable: ts.Expression, expression: ts.Expression): ts.ExpressionStatement {
+//   const binaryExpression: ts.BinaryExpression = ts.createBinary(variable, ts.SyntaxKind.EqualsToken, expression);
+//   return ts.createExpressionStatement(binaryExpression);
+// }
 
-function AssignLiteralPropertyTo(mockObjectReturnValueName: ts.Identifier, literalProperty: ts.PropertyAssignment): ts.ExpressionStatement {
-  const propertyAccess: ts.ElementAccessExpression = ts.createElementAccess(mockObjectReturnValueName, literalProperty.name as ts.StringLiteral);
-  return AssignVariableTo(propertyAccess, literalProperty.initializer);
-}
+// function AssignLiteralPropertyTo(mockObjectReturnValueName: ts.Identifier, literalProperty: ts.PropertyAssignment): ts.ExpressionStatement {
+//   const propertyAccess: ts.ElementAccessExpression = ts.createElementAccess(mockObjectReturnValueName, literalProperty.name as ts.StringLiteral);
+//   return AssignVariableTo(propertyAccess, literalProperty.initializer);
+// }
 
 function AssignMockMarkerPropertyTo(identifier: ts.Identifier): ts.ExpressionStatement {
   const mockMarkerProperty: Property = GetMockMarkerProperty();

src/transformer/descriptor/mock/mockProperties.ts

@@ -1,7 +1,8 @@
 import * as ts from 'typescript';
 import { Scope } from '../../scope/scope';
-import { GetDescriptor } from '../descriptor';
 import { IsTypescriptType } from '../tsLibs/typecriptLibs';
+import { MethodSignature } from '../method/method';
+import { ReshapeCallableDeclaration } from '../method/methodDeclaration';
 import { GetMockCall } from './mockCall';
 import { GetMockPropertiesAssignments, PropertyAssignments } from './mockPropertiesAssignments';
 import { PropertyLike } from './propertyLike';
@@ -34,6 +35,7 @@ export function GetMockPropertiesFromDeclarations(list: ReadonlyArray<PropertyLi
 
   const accessorDeclaration: PropertyAssignments = GetMockPropertiesAssignments(propertiesFilter, scope);
 
-  const signaturesDescriptor: ts.Expression | null = signatures.length ? GetDescriptor(signatures[0], scope) : null;
-  return GetMockCall(accessorDeclaration, signaturesDescriptor);
+  const methodSignatures: MethodSignature[] = signatures.map((declaration: ts.CallSignatureDeclaration | ts.ConstructSignatureDeclaration) => ReshapeCallableDeclaration(declaration, scope));
+
+  return GetMockCall(accessorDeclaration, methodSignatures);
 }