enhancement(types): Enable strictNullChecks and throw errors in unhandled situations (#301)

Author: martinjlowm

src/extension/extensionHandler.ts

@@ -18,13 +18,19 @@ export class ExtensionHandler<TMock> {
     extension: Extension<TMock, TMockedPropertyHandler>,
   ): TMockedPropertyHandler;
   public get<TPropName extends keyof TMock, TMockedPropertyHandler>(
-    extensionOrPropertyName: Function | TPropName,
+    extensionOrPropertyName: Extension<TMock, TMockedPropertyHandler> | TPropName,
     maybePropertyHandler?: AsMockedPropertyHandler<TMockedPropertyHandler, TMock, TPropName>,
   ): TMockedPropertyHandler {
     if (isFunction(extensionOrPropertyName)) {
       return extensionOrPropertyName(this._mock);
     }
 
+    if (!maybePropertyHandler) {
+      throw new Error(
+        `It looks like you are trying to get an extension for ${extensionOrPropertyName} without specifying the handler.`,
+      );
+    }
+
     return maybePropertyHandler(this._mock[extensionOrPropertyName], this._mock, extensionOrPropertyName);
   }
 }

src/options/options.ts

@@ -7,16 +7,15 @@ export interface TsAutoMockOptions {
   cacheBetweenTests: TsAutoMockCacheOptions;
 }
 
-let options: TsAutoMockOptions = null;
+let tsAutoMockOptions: TsAutoMockOptions = defaultOptions;
 
-export function SetTsAutoMockOptions(_options: TsAutoMockOptions): void {
-  options = _options;
+export function SetTsAutoMockOptions(options: TsAutoMockOptions): void {
+  tsAutoMockOptions = {
+    ...defaultOptions,
+    ...options,
+  };
 }
 
 export function GetOptionByKey<T extends keyof TsAutoMockOptions>(optionKey: T): TsAutoMockOptions[T] {
-  if (options) {
-    return options.hasOwnProperty(optionKey) ? options[optionKey] : defaultOptions[optionKey];
-  }
-
-  return defaultOptions[optionKey];
+  return tsAutoMockOptions[optionKey];
 }

src/transformer/base/base.ts

@@ -9,11 +9,14 @@ import {
   isFunctionFromThisLibrary,
 } from '../matcher/matcher';
 
-export type Visitor = (node: ts.CallExpression, declaration: ts.FunctionDeclaration) => ts.Node;
+export type Visitor = (node: ts.CallExpression & { typeArguments: ts.NodeArray<ts.TypeNode> }, declaration: ts.FunctionDeclaration) => ts.Node;
 
 export function baseTransformer(visitor: Visitor, customFunctions: CustomFunction[]): (program: ts.Program, options?: TsAutoMockOptions) => ts.TransformerFactory<ts.SourceFile> {
   return (program: ts.Program, options?: TsAutoMockOptions): ts.TransformerFactory<ts.SourceFile> => {
-    SetTsAutoMockOptions(options);
+    if (options) {
+      SetTsAutoMockOptions(options);
+    }
+
     SetTypeChecker(program.getTypeChecker());
     SetProgram(program);
 
@@ -37,18 +40,35 @@ function visitNodeAndChildren(node: ts.Node, context: ts.TransformationContext,
   return ts.visitEachChild(visitNode(node, visitor, customFunctions), (childNode: ts.Node) => visitNodeAndChildren(childNode, context, visitor, customFunctions), context);
 }
 
+function isObjectWithProperty<T extends {}, K extends keyof T>(
+  obj: T,
+  key: K,
+): obj is T & Required<{ [key in K]: T[K] }> {
+  return typeof obj[key] !== 'undefined';
+}
+
 function visitNode(node: ts.Node, visitor: Visitor, customFunctions: CustomFunction[]): ts.Node {
   if (!ts.isCallExpression(node)) {
     return node;
   }
 
-  const signature: ts.Signature = TypescriptHelper.getSignatureOfCallExpression(node);
+  const signature: ts.Signature | undefined = TypescriptHelper.getSignatureOfCallExpression(node);
 
-  if (!isFunctionFromThisLibrary(signature, customFunctions)) {
+  if (!signature || !isFunctionFromThisLibrary(signature, customFunctions)) {
     return node;
   }
 
-  const nodeToMock: ts.TypeNode = node.typeArguments[0];
+  if (!isObjectWithProperty(node, 'typeArguments') || !node.typeArguments?.length) {
+    const mockFunction: string = node.getText();
+
+    throw new Error(
+      `It seems you've called \`${mockFunction}' without specifying a type argument to mock. ` +
+        `Please refer to the documentation on how to use \`${mockFunction}': ` +
+        'https://github.com/Typescript-TDD/ts-auto-mock#quick-overview'
+    );
+  }
+
+  const [nodeToMock]: ts.NodeArray<ts.TypeNode> = node.typeArguments;
 
   MockDefiner.instance.setFileNameFromNode(nodeToMock);
   MockDefiner.instance.setTsAutoMockImportIdentifier();

src/transformer/descriptor/descriptor.ts

@@ -63,6 +63,12 @@ export function GetDescriptor(node: ts.Node, scope: Scope): ts.Expression {
     case ts.SyntaxKind.Identifier:
       return GetIdentifierDescriptor(node as ts.Identifier, scope);
     case ts.SyntaxKind.ThisType:
+      if (!scope.currentMockKey) {
+        throw new Error(
+          `The transformer attempted to look up a mock factory call for \`${node.getText()}' without a mock key.`,
+        );
+      }
+
       return GetMockFactoryCallForThis(scope.currentMockKey);
     case ts.SyntaxKind.ImportSpecifier:
       return GetImportDescriptor(node as ts.ImportSpecifier, scope);

src/transformer/descriptor/helper/helper.ts

@@ -16,7 +16,14 @@ export namespace TypescriptHelper {
 
   export function GetDeclarationFromNode(node: ts.Node): ts.Declaration {
     const typeChecker: ts.TypeChecker = TypeChecker();
-    const symbol: ts.Symbol = typeChecker.getSymbolAtLocation(node);
+    const symbol: ts.Symbol | undefined = typeChecker.getSymbolAtLocation(node);
+
+    if (!symbol) {
+      throw new Error(
+        `The type checker failed to look up a symbol for \`${node.getText()}'. ` +
+          'Perhaps, the checker was searching an outdated source.',
+      );
+    }
 
     return GetDeclarationFromSymbol(symbol);
   }
@@ -56,11 +63,13 @@ export namespace TypescriptHelper {
   export function GetParameterOfNode(node: ts.EntityName): ts.NodeArray<ts.TypeParameterDeclaration> {
     const declaration: ts.Declaration = GetDeclarationFromNode(node);
 
-    return (declaration as Declaration).typeParameters;
+    const { typeParameters = ts.createNodeArray([]) }: Declaration = (declaration as Declaration);
+
+    return typeParameters;
   }
 
-  export function GetTypeParameterOwnerMock(declaration: ts.Declaration): ts.Declaration {
-    const typeDeclaration: ts.Declaration = ts.getTypeParameterOwner(declaration);
+  export function GetTypeParameterOwnerMock(declaration: ts.Declaration): ts.Declaration | undefined {
+    const typeDeclaration: ts.Declaration | undefined = ts.getTypeParameterOwner(declaration);
 
     // THIS IS TO FIX A MISSING IMPLEMENTATION IN TYPESCRIPT https://github.com/microsoft/TypeScript/blob/ba5e86f1406f39e89d56d4b32fd6ff8de09a0bf3/src/compiler/utilities.ts#L5138
     if (typeDeclaration && (typeDeclaration as Declaration).typeParameters) {
@@ -79,7 +88,14 @@ export namespace TypescriptHelper {
       return propertyName.text;
     }
 
-    const symbol: ts.Symbol = TypeChecker().getSymbolAtLocation(propertyName);
+    const symbol: ts.Symbol | undefined = TypeChecker().getSymbolAtLocation(propertyName);
+
+    if (!symbol) {
+      throw new Error(
+        `The type checker failed to look up symbol for property: ${propertyName.getText()}.`,
+      );
+    }
+
     return symbol.escapedName.toString();
   }
 
@@ -88,7 +104,7 @@ export namespace TypescriptHelper {
   }
 
 
-  export function getSignatureOfCallExpression(node: ts.CallExpression): ts.Signature {
+  export function getSignatureOfCallExpression(node: ts.CallExpression): ts.Signature | undefined {
     const typeChecker: ts.TypeChecker = TypeChecker();
 
     return typeChecker.getResolvedSignature(node);
@@ -109,9 +125,9 @@ export namespace TypescriptHelper {
 
   function GetDeclarationsForImport(node: ImportDeclaration): ts.Declaration[] {
     const typeChecker: ts.TypeChecker = TypeChecker();
-    const symbol: ts.Symbol = typeChecker.getSymbolAtLocation(node.name);
-    const originalSymbol: ts.Symbol = typeChecker.getAliasedSymbol(symbol);
+    const symbol: ts.Symbol | undefined = node.name && typeChecker.getSymbolAtLocation(node.name);
+    const originalSymbol: ts.Symbol | undefined = symbol && typeChecker.getAliasedSymbol(symbol);
 
-    return originalSymbol.declarations;
+    return originalSymbol?.declarations ?? [];
   }
 }

src/transformer/descriptor/indexedAccess/indexedAccess.ts

@@ -37,7 +37,14 @@ export function GetIndexedAccessTypeDescriptor(node: ts.IndexedAccessTypeNode, s
   }
 
   if (propertyName !== null) {
-    const propertySymbol: ts.Symbol = typeChecker.getPropertyOfType(typeChecker.getTypeFromTypeNode(node.objectType), propertyName);
+    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()}'.`,
+      );
+    }
+
     return GetDescriptor(TypescriptHelper.GetDeclarationFromSymbol(propertySymbol), scope);
   }
 

src/transformer/descriptor/mapped/mapped.ts

@@ -6,9 +6,15 @@ import { GetMockPropertiesFromDeclarations } from '../mock/mockProperties';
 import { GetTypes } from '../type/type';
 
 export function GetMappedDescriptor(node: ts.MappedTypeNode, scope: Scope): ts.Expression {
-  const typeParameter: ts.TypeNode = node.typeParameter.constraint;
+  const typeParameter: ts.TypeNode | undefined = node.typeParameter.constraint;
   const typeChecker: ts.TypeChecker = TypeChecker();
-  const types: ts.Node[] = GetTypes(ts.createNodeArray([typeParameter]), scope);
+
+  const parameters: ts.TypeNode[] = [];
+  if (typeParameter) {
+    parameters.push(typeParameter);
+  }
+
+  const types: ts.Node[] = GetTypes(ts.createNodeArray(parameters), scope);
 
   const properties: ts.PropertyDeclaration[] = types.reduce((acc: ts.PropertyDeclaration[], possibleType: ts.Node) => {
     if (ts.isLiteralTypeNode(possibleType)) {

src/transformer/descriptor/method/bodyReturnType.ts

@@ -8,11 +8,11 @@ export function GetReturnTypeFromBodyDescriptor(node: ts.ArrowFunction | ts.Func
 }
 
 export function GetReturnNodeFromBody(node: ts.FunctionLikeDeclaration): ts.Node {
-  let returnValue: ts.Node;
+  let returnValue: ts.Node | undefined;
 
-  const functionBody: ts.ConciseBody = node.body;
+  const functionBody: ts.ConciseBody | undefined = node.body;
 
-  if (ts.isBlock(functionBody)) {
+  if (functionBody && ts.isBlock(functionBody)) {
     const returnStatement: ts.ReturnStatement = GetReturnStatement(functionBody);
 
     if (returnStatement) {
@@ -24,6 +24,10 @@ export function GetReturnNodeFromBody(node: ts.FunctionLikeDeclaration): ts.Node
     returnValue = node.body;
   }
 
+  if (!returnValue) {
+    throw new Error(`Failed to determine the return value of ${node.getText()}.`);
+  }
+
   return returnValue;
 }
 

src/transformer/descriptor/method/functionType.ts

@@ -7,6 +7,10 @@ import { GetMethodDescriptor } from './method';
 export function GetFunctionTypeDescriptor(node: ts.FunctionTypeNode | ts.CallSignatureDeclaration | ts.ConstructSignatureDeclaration, scope: Scope): ts.Expression {
   const property: ts.PropertyName = PropertySignatureCache.instance.get();
 
+  if (!node.type) {
+    throw new Error(`No type was declared for ${node.getText()}.`);
+  }
+
   const returnValue: ts.Expression = GetDescriptor(node.type, scope);
 
   return GetMethodDescriptor(property, returnValue);

src/transformer/descriptor/method/methodDeclaration.ts

@@ -8,5 +8,11 @@ export function GetMethodDeclarationDescriptor(node: ts.MethodDeclaration | ts.F
   const returnTypeNode: ts.Node = GetFunctionReturnType(node);
   const returnType: ts.Expression = GetDescriptor(returnTypeNode, scope);
 
+  if (!node.name) {
+    throw new Error(
+      `The transformer couldn't determine the name of ${node.getText()}. Please report this incident.`,
+    );
+  }
+
   return GetMethodDescriptor(node.name, returnType);
 }