const wildcardType = createIntrinsicType(TypeFlags.Any, "any");

const errorType = createIntrinsicType(TypeFlags.Any, "error");

const unknownType = createIntrinsicType(TypeFlags.Unknown, "unknown");

const stringType = createIntrinsicType(TypeFlags.String, "string");

const numberType = createIntrinsicType(TypeFlags.Number, "number");

const bigintType = createIntrinsicType(TypeFlags.BigInt, "bigint");

const voidType = createIntrinsicType(TypeFlags.Void, "void");

const neverType = createIntrinsicType(TypeFlags.Never, "never");

const silentNeverType = createIntrinsicType(TypeFlags.Never, "never");

const implicitNeverType = createIntrinsicType(TypeFlags.Never, "never");

const nonPrimitiveType = createIntrinsicType(TypeFlags.NonPrimitive, "object");

const stringNumberSymbolType = getUnionType([stringType, numberType, esSymbolType]);

const anyFunctionType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);

// The anyFunctionType contains the anyFunctionType by definition. The flag is further propagated

// in getPropagatingFlagsOfTypes, and it is checked in inferFromTypes.

const noConstraintType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);

const circularConstraintType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);

return result;

}

const type = <IntrinsicType>createType(kind);

type.intrinsicName = intrinsicName;

type.objectFlags = objectFlags;

return type;

}

}

function createReverseMappedType(source: Type, target: MappedType, constraint: IndexType) {

// If any property contains context sensitive functions that have been skipped, the source type

// is incomplete and we can't infer a meaningful input type.

}

// For arrays and tuples we infer new arrays and tuples where the reverse mapping has been

// applied to the element type(s).

// not contain anyFunctionType when we come back to this argument for its second round

// of inference. Also, we exclude inferences for silentNeverType (which is used as a wildcard

// when constructing types from type parameters that had no inference candidates).

return;

}

const inference = getInferenceInfoForType(target);

const sourceLen = sourceSignatures.length;

const targetLen = targetSignatures.length;

const len = sourceLen < targetLen ? sourceLen : targetLen;

for (let i = 0; i < len; i++) {

inferFromSignature(getBaseSignature(sourceSignatures[sourceLen - len + i]), getBaseSignature(targetSignatures[targetLen - len + i]), skipParameters);

}

// returns a function type, we choose to defer processing. This narrowly permits function composition

// operators to flow inferences through return types, but otherwise processes calls right away. We

// use the resolvingSignature singleton to indicate that we deferred processing. This result will be

// from which we never make inferences).

if (checkMode & CheckMode.SkipGenericFunctions && !node.typeArguments && callSignatures.some(isGenericFunctionReturningFunction)) {

skippedGenericFunction(node, checkMode);

const signature = getResolvedSignature(node, /*candidatesOutArray*/ undefined, checkMode);

if (signature === resolvingSignature) {

// CheckMode.SkipGenericFunctions is enabled and this is a call to a generic function that

}

if (node.expression.kind === SyntaxKind.SuperKeyword) {

const returnType = getReturnTypeFromBody(node, checkMode);

const returnOnlySignature = createSignature(undefined, undefined, undefined, emptyArray, returnType, /*resolvedTypePredicate*/ undefined, 0, /*hasRestParameter*/ false, /*hasLiteralTypes*/ false);

const returnOnlyType = createAnonymousType(node.symbol, emptySymbols, [returnOnlySignature], emptyArray, undefined, undefined);

return links.contextFreeType = returnOnlyType;

}

return anyFunctionType;