// caps union types at 1000 unique object types.

const estimatedCount = (count / (len - i)) * len;

if (estimatedCount > 1000000) {

error(currentNode, Diagnostics.Expression_produces_a_union_type_that_is_too_complex_to_represent);

return false;

}

function checkCrossProductUnion(types: readonly Type[]) {

const size = getCrossProductUnionSize(types);

if (size >= 100000) {

error(currentNode, Diagnostics.Expression_produces_a_union_type_that_is_too_complex_to_represent);

return false;

}

// 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;

}

reportIncompatibleStack();

}

if (overflow) {

const diag = error(errorNode || currentNode, Diagnostics.Excessive_stack_depth_comparing_types_0_and_1, typeToString(source), typeToString(target));

if (errorOutputContainer) {

(errorOutputContainer.errors || (errorOutputContainer.errors = [])).push(diag);

}

function traceUnionsOrIntersectionsTooLarge(source: Type, target: Type): void {

return;

}

}

if (expandingFlags === ExpandingFlags.Both) {

sourceId: source.id,

sourceIdStack: sourceStack.map(t => t.id),

targetId: target.id,

}

function structuredTypeRelatedTo(source: Type, target: Type, reportErrors: boolean, intersectionState: IntersectionState): Ternary {

const result = structuredTypeRelatedToWorker(source, target, reportErrors, intersectionState);

return result;

}

numCombinations *= countTypes(getTypeOfSymbol(sourceProperty));

if (numCombinations > 25) {

// We've reached the complexity limit.

return Ternary.False;

}

}

function getVariancesWorker<TCache extends { variances?: VarianceFlags[] }>(typeParameters: readonly TypeParameter[] = emptyArray, cache: TCache, createMarkerType: (input: TCache, param: TypeParameter, marker: Type) => Type): VarianceFlags[] {

let variances = cache.variances;

if (!variances) {

// The emptyArray singleton is used to signal a recursive invocation.

cache.variances = emptyArray;

variances = [];

variances.push(variance);

}

cache.variances = variances;

}

return variances;

}

if (flowDepth === 2000) {

// We have made 2000 recursive invocations. To avoid overflowing the call stack we report an error

// and disable further control flow analysis in the containing function or module body.

flowAnalysisDisabled = true;

reportFlowControlError(reference);

return errorType;

}

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

const saveCurrentNode = currentNode;

currentNode = node;

instantiationCount = 0;

checkConstEnumAccess(node, type);

}

currentNode = saveCurrentNode;

return type;

}

}

function checkVariableDeclaration(node: VariableDeclaration) {

checkGrammarVariableDeclaration(node);

checkVariableLikeDeclaration(node);

}

function checkBindingElement(node: BindingElement) {

}

function checkDeferredNode(node: Node) {

const saveCurrentNode = currentNode;

currentNode = node;

instantiationCount = 0;

break;

}

currentNode = saveCurrentNode;

}

function checkSourceFile(node: SourceFile) {

performance.mark("beforeCheck");

checkSourceFileWorker(node);

performance.mark("afterCheck");

performance.measure("Check", "beforeCheck", "afterCheck");

}

function unusedIsError(kind: UnusedKind, isAmbient: boolean): boolean {

sourceFiles: sourceFileOrBundle.sourceFiles.map(file => relativeToBuildInfo(getNormalizedAbsolutePath(file.fileName, host.getCurrentDirectory())))

};

}

emitJsFileOrBundle(sourceFileOrBundle, jsFilePath, sourceMapFilePath, relativeToBuildInfo);

emitDeclarationFileOrBundle(sourceFileOrBundle, declarationFilePath, declarationMapPath, relativeToBuildInfo);

emitBuildInfo(bundleBuildInfo, buildInfoPath);

if (!emitSkipped && emittedFilesList) {

if (!emitOnlyDtsFiles) {

}

export function createSourceFile(fileName: string, sourceText: string, languageVersion: ScriptTarget, setParentNodes = false, scriptKind?: ScriptKind): SourceFile {

performance.mark("beforeParse");

let result: SourceFile;

performance.mark("afterParse");

performance.measure("Parse", "beforeParse", "afterParse");

return result;

}