function isConditionalTypeAlwaysTrueDisregardingInferTypes(type: ConditionalType) {

const extendsInferParamMapper = type.root.inferTypeParameters && createTypeMapper(type.root.inferTypeParameters, map(type.root.inferTypeParameters, () => wildcardType));

const checkType = type.checkType;

const extendsType = type.extendsType;

return isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(instantiateType(extendsType, extendsInferParamMapper)));

}

isDistributive: !!(checkType.flags & TypeFlags.TypeParameter),

// Check if the conditional is always true or always false but still deferred for distribution purposes

const skipTrue = !isTypeAssignableTo(getPermissiveInstantiation(c.checkType), getPermissiveInstantiation(c.extendsType));

const skipFalse = !skipTrue && isConditionalTypeAlwaysTrueDisregardingInferTypes(c);

// Instantiate with a replacement mapper if the conditional is distributive, replacing the check type with a clone of itself,

// this way {x: string | number, y: string | number} -> (T extends T ? { x: T, y: T } : never) appropriately _fails_ when

// T = string | number (since that will end up distributing and producing `{x: string, y: string} | {x: number, y: number}`,

// to which `{x: string | number, y: string | number}` isn't assignable)

let distributionMapper: TypeMapper | undefined;

const checkVar = getActualTypeVariable(c.root.checkType);

if (c.root.isDistributive && checkVar.flags & TypeFlags.TypeParameter) {

const newParam = cloneTypeParameter(checkVar);

distributionMapper = prependTypeMapping(checkVar, newParam, c.mapper);

newParam.mapper = distributionMapper;

}

// TODO: Find a nice way to include potential conditional type breakdowns in error output, if they seem good (they usually don't)

const expanding = isDeeplyNestedType(target, targetStack, targetDepth);

let localResult: Ternary | undefined = expanding ? Ternary.Maybe : undefined;

if (skipTrue || expanding || (localResult = isRelatedTo(source, distributionMapper ? instantiateType(getTypeFromTypeNode(c.root.node.trueType), distributionMapper) : getTrueTypeFromConditionalType(c), RecursionFlags.Target, /*reportErrors*/ false))) {

if (!skipFalse && !expanding) {

localResult = (localResult || Ternary.Maybe) & isRelatedTo(source, distributionMapper ? instantiateType(getTypeFromTypeNode(c.root.node.falseType), distributionMapper) : getFalseTypeFromConditionalType(c), RecursionFlags.Target, /*reportErrors*/ false);

}

}

if (localResult) {

resetErrorInfo(saveErrorInfo);

return localResult;