return t.flags & TypeFlags.StringLike ? globalStringType :

t.flags & TypeFlags.NumberLike ? globalNumberType :

t.flags & TypeFlags.BooleanLike ? globalBooleanType :

t.flags & TypeFlags.NonPrimitive ? globalObjectType :

t;

}

}

function createAsyncIterableType(iteratedType: Type): Type {

}

function createAsyncIterableIteratorType(iteratedType: Type): Type {

}

function createIterableType(iteratedType: Type): Type {

}

function createIterableIteratorType(iteratedType: Type): Type {

}

function createArrayType(elementType: Type): ObjectType {

if ((globalStringType === source && stringType === target) ||

(globalNumberType === source && numberType === target) ||

(globalBooleanType === source && booleanType === target) ||

reportError(Diagnostics._0_is_a_primitive_but_1_is_a_wrapper_object_Prefer_using_0_when_possible, targetType, sourceType);

}

}

return false;

}

if (!globalESSymbol) {

// Already errored when we tried to look up the symbol

return false;

function createPromiseType(promisedType: Type): Type {

// creates a `Promise<T>` type where `T` is the promisedType argument

if (globalPromiseType !== emptyGenericType) {

// if the promised type is itself a promise, get the underlying type; otherwise, fallback to the promised type

promisedType = getAwaitedType(promisedType) || emptyObjectType;

return typeAsPromise.promisedTypeOfPromise;

}

return typeAsPromise.promisedTypeOfPromise = (<GenericType>promise).typeArguments[0];

}

if (returnType === unknownType) {

return unknownType;

}

if (globalPromiseType !== emptyGenericType && !isReferenceToType(returnType, globalPromiseType)) {

// The promise type was not a valid type reference to the global promise type, so we

// report an error and return the unknown type.

return unknownType;

}

if (globalPromiseConstructorLikeType === emptyObjectType) {

// If we couldn't resolve the global PromiseConstructorLike type we cannot verify

// compatibility with __awaiter.

// As an optimization, if the type is instantiated directly using the

// globalAsyncIterableType (AsyncIterable<T>) or globalAsyncIterableIteratorType

// (AsyncIterableIterator<T>), then just grab its type argument.

return typeAsAsyncIterable.iteratedTypeOfAsyncIterable = (<GenericType>type).typeArguments[0];

}

if (allowIterables) {

return typeAsAsyncIterable.iteratedTypeOfAsyncIterable = (<GenericType>type).typeArguments[0];

}

}

// As an optimization, if the type is instantiated directly using the

// globalAsyncIteratorType (AsyncIterator<number>), then just grab its type argument.

return typeAsAsyncIterator.iteratedTypeOfAsyncIterator = (<GenericType>type).typeArguments[0];

}

// As an optimization, if the type is instantiated directly using the

// globalIterableType (Iterable<T>) or globalIterableIteratorType (IterableIterator<T>),

// then just grab its type argument.

return typeAsIterable.iteratedTypeOfIterable = (<GenericType>type).typeArguments[0];

}

// As an optimization, if the type is instantiated directly using the globalIteratorType (Iterator<number>),

// then just grab its type argument.

return typeAsIterator.iteratedTypeOfIterator = (<GenericType>type).typeArguments[0];

}

function getTypeReferenceSerializationKind(typeName: EntityName, location?: Node): TypeReferenceSerializationKind {

// Resolve the symbol as a value to ensure the type can be reached at runtime during emit.

const valueSymbol = resolveEntityName(typeName, SymbolFlags.Value, /*ignoreErrors*/ true, /*dontResolveAlias*/ false, location);

if (globalPromiseSymbol && valueSymbol === globalPromiseSymbol) {

return TypeReferenceSerializationKind.Promise;

}