const indexedAccessTypes = createMap<IndexedAccessType>();

/**

* The apparent type of an indexed access T[K] is the type of T's string index signature, if any.

*/

function getApparentTypeOfIndexedAccess(type: IndexedAccessType) {

return getIndexTypeOfType(getApparentType(type.objectType), IndexKind.String) || type;

}

const t = type.flags & TypeFlags.TypeParameter ? getApparentTypeOfTypeParameter(<TypeParameter>type) :

type.flags & TypeFlags.IndexedAccess ? getApparentTypeOfIndexedAccess(<IndexedAccessType>type) :

type;

getObjectFlags(type) & ObjectFlags.Mapped ? getConstraintTypeFromMappedType(<MappedType>type) :

function createIndexedAccessType(objectType: Type, indexType: Type) {

function getIndexedAccessForMappedType(type: MappedType, indexType: Type, accessNode?: ElementAccessExpression | IndexedAccessTypeNode) {

const accessExpression = accessNode && accessNode.kind === SyntaxKind.ElementAccessExpression ? <ElementAccessExpression>accessNode : undefined;

if (accessExpression && isAssignmentTarget(accessExpression) && type.declaration.readonlyToken) {

error(accessExpression, Diagnostics.Index_signature_in_type_0_only_permits_reading, typeToString(type));

return unknownType;

}

const mapper = createUnaryTypeMapper(getTypeParameterFromMappedType(type), indexType);

const templateMapper = type.mapper ? combineTypeMappers(type.mapper, mapper) : mapper;

return addOptionality(instantiateType(getTemplateTypeFromMappedType(type), templateMapper), !!type.declaration.questionToken);

}

if (indexType.flags & TypeFlags.TypeParameter ||

objectType.flags & TypeFlags.TypeParameter && indexType.flags & TypeFlags.Index ||

isGenericMappedType(objectType)) {

// If either the object type or the index type are type parameters, or if the object type is a mapped

// type with a generic constraint, we are performing a higher-order index access where we cannot

// meaningfully access the properties of the object type. In those cases, we first check that the

// index type is assignable to 'keyof T' for the object type.

if (accessNode) {

const keyType = indexType.flags & TypeFlags.TypeParameter ? getConstraintOfTypeParameter(<TypeParameter>indexType) || emptyObjectType : indexType;

if (!isTypeAssignableTo(keyType, getIndexType(objectType))) {

error(accessNode, Diagnostics.Type_0_cannot_be_used_to_index_type_1, typeToString(indexType), typeToString(objectType));

return unknownType;

}

}

// If the object type is a mapped type { [P in K]: E }, we instantiate E using a mapper that substitutes

// the index type for P. For example, for an index access { [P in K]: Box<T[P]> }[X], we construct the

// type Box<T[X]>.

if (isGenericMappedType(objectType)) {

return getIndexedAccessForMappedType(<MappedType>objectType, indexType, accessNode);

// Otherwise we defer the operation by creating an indexed access type.

const id = objectType.id + "," + indexType.id;

return indexedAccessTypes[id] || (indexedAccessTypes[id] = createIndexedAccessType(objectType, indexType));

// Eagerly resolve the constraint type which forces an error if the constraint type circularly

// references itself through one or more type aliases.

getConstraintTypeFromMappedType(type);

// A source type { [P in keyof T]: X } is related to a target type T if X is related to T[P].

if (getObjectFlags(source) & ObjectFlags.Mapped && getConstraintTypeFromMappedType(<MappedType>source) === getIndexType(target)) {

if (!(<MappedType>source).declaration.questionToken) {

const templateType = getTemplateTypeFromMappedType(<MappedType>source);

const indexedAccessType = getIndexedAccessType(target, getTypeParameterFromMappedType(<MappedType>source));

if (result = isRelatedTo(templateType, indexedAccessType, reportErrors)) {

return result;

}

}

}

else {

// Given a type parameter K with a constraint keyof T, a type S is

// assignable to K if S is assignable to keyof T.

const constraint = getConstraintOfTypeParameter(<TypeParameter>target);

if (constraint && constraint.flags & TypeFlags.Index) {

if (result = isRelatedTo(source, constraint, reportErrors)) {

return result;

}

else if (target.flags & TypeFlags.IndexedAccess) {

// if we have indexed access types with identical index types, see if relationship holds for

// the two object types.

if (source.flags & TypeFlags.IndexedAccess && (<IndexedAccessType>source).indexType === (<IndexedAccessType>target).indexType) {

if (result = isRelatedTo((<IndexedAccessType>source).objectType, (<IndexedAccessType>target).objectType, reportErrors)) {

return result;

}

}

}

// A source type T is related to a target type { [P in keyof T]: X } if T[P] is related to X.

if (getObjectFlags(target) & ObjectFlags.Mapped && getConstraintTypeFromMappedType(<MappedType>target) === getIndexType(source)) {

const indexedAccessType = getIndexedAccessType(source, getTypeParameterFromMappedType(<MappedType>target));

const templateType = getTemplateTypeFromMappedType(<MappedType>target);

if (result = isRelatedTo(indexedAccessType, templateType, reportErrors)) {

return result;

}

else {

let constraint = getConstraintOfTypeParameter(<TypeParameter>source);

if (!constraint || constraint.flags & TypeFlags.Any) {

constraint = emptyObjectType;

}

// The constraint may need to be further instantiated with its 'this' type.

constraint = getTypeWithThisArgument(constraint, source);

// Report constraint errors only if the constraint is not the empty object type

const reportConstraintErrors = reportErrors && constraint !== emptyObjectType;

if (result = isRelatedTo(constraint, target, reportConstraintErrors)) {

errorInfo = saveErrorInfo;

return result;

}