let typeCount = 0;

let symbolCount = 0;

let enumCount = 0;

let instantiationDepth = 0;

let constraintDepth = 0;

let currentNode: Node | undefined;

if (!type || !mapper || mapper === identityMapper) {

return type;

}

// We have reached 50 recursive type instantiations and there is a very high likelyhood we're dealing

// with a combination of infinite generic types that perpetually generate new type identities. We stop

// the recursion here by yielding the error type.

error(currentNode, Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite);

return errorType;

}

instantiationDepth++;

const result = instantiateTypeWorker(type, mapper);

instantiationDepth--;

function checkExpression(node: Expression | QualifiedName, checkMode?: CheckMode, forceTuple?: boolean): Type {

const saveCurrentNode = currentNode;

currentNode = node;

const uninstantiatedType = checkExpressionWorker(node, checkMode, forceTuple);

const type = instantiateTypeWithSingleGenericCallSignature(node, uninstantiatedType, checkMode);

if (isConstEnumObjectType(type)) {

if (node) {

const saveCurrentNode = currentNode;

currentNode = node;

checkSourceElementWorker(node);

currentNode = saveCurrentNode;

}

function checkDeferredNode(node: Node) {

const saveCurrentNode = currentNode;

currentNode = node;

switch (node.kind) {

case SyntaxKind.FunctionExpression:

case SyntaxKind.ArrowFunction: