return getObjectFlags(type) & ObjectFlags.Mapped && isGenericIndexType(getConstraintTypeFromMappedType(<MappedType>type));

const transformed = getTransformedIndexedAccessType(type);

if (transformed) {

return transformed;

}

const transformed = getTransformedIndexedAccessType(<IndexedAccessType>t);

if (transformed) {

return getBaseConstraint(transformed);

}

if (isGenericMappedType(t)) {

return emptyObjectType;

}

function isGenericObjectType(type: Type): boolean {

return type.flags & TypeFlags.TypeVariable ? true :

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

type.flags & TypeFlags.UnionOrIntersection ? forEach((<UnionOrIntersectionType>type).types, isGenericObjectType) :

false;

}

function isGenericIndexType(type: Type): boolean {

return type.flags & (TypeFlags.TypeVariable | TypeFlags.Index) ? true :

type.flags & TypeFlags.UnionOrIntersection ? forEach((<UnionOrIntersectionType>type).types, isGenericIndexType) :

false;

}

// Return true if the given type is a non-generic object type with a string index signature and no

// other members.

function isStringIndexOnlyType(type: Type) {

if (type.flags & TypeFlags.Object && !isGenericMappedType(type)) {

const t = resolveStructuredTypeMembers(<ObjectType>type);

return t.properties.length === 0 &&

t.callSignatures.length === 0 && t.constructSignatures.length === 0 &&

t.stringIndexInfo && !t.numberIndexInfo;

}

return false;

}

// Given an indexed access type T[K], if T is an intersection containing one or more generic types and one or

// more object types with only a string index signature, e.g. '(U & V & { [x: string]: D })[K]', return a

// transformed type of the form '(U & V)[K] | D'. This allows us to properly reason about higher order indexed

// access types with default property values as expressed by D.

function getTransformedIndexedAccessType(type: IndexedAccessType): Type {

const objectType = type.objectType;

if (objectType.flags & TypeFlags.Intersection && isGenericObjectType(objectType) && some((<IntersectionType>objectType).types, isStringIndexOnlyType)) {

const regularTypes: Type[] = [];

const stringIndexTypes: Type[] = [];

for (const t of (<IntersectionType>objectType).types) {

if (isStringIndexOnlyType(t)) {

stringIndexTypes.push(getIndexTypeOfType(t, IndexKind.String));

}

else {

regularTypes.push(t);

}

}

return getUnionType([

getIndexedAccessType(getIntersectionType(regularTypes), type.indexType),

getIntersectionType(stringIndexTypes)

]);

}

return undefined;

}

function getIndexedAccessType(objectType: Type, indexType: Type, accessNode?: ElementAccessExpression | IndexedAccessTypeNode): Type {

// If the object type is a mapped type { [P in K]: E }, where K is generic, 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, if the index type is generic, or if the object type is generic and doesn't originate in an

// expression, we are performing a higher-order index access where we cannot meaningfully access the properties

// of the object type. Note that for a generic T and a non-generic K, we eagerly resolve T[K] if it originates

// in an expression. This is to preserve backwards compatibility. For example, an element access 'this["foo"]'

// has always been resolved eagerly using the constraint type of 'this' at the given location.

if (isGenericIndexType(indexType) || !(accessNode && accessNode.kind === SyntaxKind.ElementAccessExpression) && isGenericObjectType(objectType)) {

// Defer the operation by creating an indexed access type.

createInferenceContext(mapper.signature, mapper.flags | InferenceFlags.NoDefault, mapper.compareTypes, mapper.inferences) :

compareTypes: TypeComparer): Ternary {

source = instantiateSignatureInContextOf(source, target, /*contextualMapper*/ undefined, compareTypes);

if (isGenericMappedType(source)) {

// A generic mapped type { [P in K]: T } is related to an index signature { [x: string]: U }

// if T is related to U.

return kind === IndexKind.String && isRelatedTo(getTemplateTypeFromMappedType(<MappedType>source), targetInfo.type, reportErrors);

}

function createInferenceContext(signature: Signature, flags: InferenceFlags, compareTypes?: TypeComparer, baseInferences?: InferenceInfo[]): InferenceContext {

context.compareTypes = compareTypes || compareTypesAssignable;

function isPossiblyAssignableTo(source: Type, target: Type) {

const properties = getPropertiesOfObjectType(target);

for (const targetProp of properties) {

if (!(targetProp.flags & (SymbolFlags.Optional | SymbolFlags.Prototype))) {

const sourceProp = getPropertyOfObjectType(source, targetProp.escapedName);

if (!sourceProp) {

return false;

}

}

}

return true;

}

// Infer from the members of source and target only if the two types are possibly related. We check

// in both directions because we may be inferring for a co-variant or a contra-variant position.

if (isPossiblyAssignableTo(source, target) || isPossiblyAssignableTo(target, source)) {

inferFromProperties(source, target);

inferFromSignatures(source, target, SignatureKind.Call);

inferFromSignatures(source, target, SignatureKind.Construct);

inferFromIndexTypes(source, target);

}

if (!context.compareTypes(inferredType, getTypeWithThisArgument(instantiatedConstraint, inferredType))) {

function instantiateSignatureInContextOf(signature: Signature, contextualSignature: Signature, contextualMapper?: TypeMapper, compareTypes?: TypeComparer): Signature {

const context = createInferenceContext(signature, InferenceFlags.InferUnionTypes, compareTypes);