const checkType = (type as ConditionalType).checkType;

const constraint = getLowerBoundOfKeyType(checkType);

if (constraint !== checkType) {

}

}

return type;

const simplified = getSimplifiedType(type.checkType, /*writing*/ false);

const constraint = simplified === type.checkType ? getConstraintOfType(simplified) : simplified;

if (constraint && constraint !== type.checkType) {

if (!(instantiated.flags & TypeFlags.Never)) {

type.resolvedConstraintOfDistributive = instantiated;

return instantiated;

return isGenericType(type) || checkTuples && isTupleType(type) && some(getElementTypes(type), isGenericType);

}

let result;

let extraTypes: Type[] | undefined;

let tailCount = 0;

// possible (the wildcard type is assignable to and from all types). If those are not related,

// then no instantiations will be and we can just return the false branch type.

if (!(inferredExtendsType.flags & TypeFlags.AnyOrUnknown) && (checkType.flags & TypeFlags.Any || !isTypeAssignableTo(getPermissiveInstantiation(checkType), getPermissiveInstantiation(inferredExtendsType)))) {

(extraTypes || (extraTypes = [])).push(instantiateType(getTypeFromTypeNode(root.node.trueType), combinedMapper || mapper));

}

// If falseType is an immediately nested conditional type that isn't distributive or has an

aliasSymbol,

aliasTypeArguments,

};

if (outerTypeParameters) {

root.instantiations = new Map<string, Type>();

root.instantiations.set(getTypeListId(outerTypeParameters), links.resolvedType);

return result;

}

const root = type.root;

if (root.outerTypeParameters) {

// We are instantiating a conditional type that has one or more type parameters in scope. Apply the

// mapper to the type parameters to produce the effective list of type arguments, and compute the

// instantiation cache key from the type IDs of the type arguments.

const typeArguments = map(root.outerTypeParameters, t => getMappedType(t, mapper));

let result = root.instantiations!.get(id);

if (!result) {

const newMapper = createTypeMapper(root.outerTypeParameters, typeArguments);

// distributive conditional type T extends U ? X : Y is instantiated with A | B for T, the

// result is (A extends U ? X : Y) | (B extends U ? X : Y).

result = distributionType && checkType !== distributionType && distributionType.flags & (TypeFlags.Union | TypeFlags.Never) ?

root.instantiations!.set(id, result);

}

return result;

return getIndexedAccessType(instantiateType((type as IndexedAccessType).objectType, mapper), instantiateType((type as IndexedAccessType).indexType, mapper), (type as IndexedAccessType).accessFlags, /*accessNode*/ undefined, newAliasSymbol, newAliasTypeArguments);

}

if (flags & TypeFlags.Conditional) {

}

if (flags & TypeFlags.Substitution) {

const newBaseType = instantiateType((type as SubstitutionType).baseType, mapper);

}

}

}

// when `O` is a conditional (`never` is trivially assignable to `O`, as is `O`!).

const defaultConstraint = getDefaultConstraintOfConditionalType(source as ConditionalType);

if (defaultConstraint) {

if (result = isRelatedTo(defaultConstraint, target, RecursionFlags.Source, reportErrors)) {

return result;

}

}

}

else {

// An empty object type is related to any mapped type that includes a '?' modifier.