function getAssignmentReducedType(declaredType: UnionType, assignedType: Type) {

if (declaredType !== assignedType) {

const reducedType = filterType(declaredType, t => typeMaybeAssignableTo(assignedType, t));

return reducedType;

}

}

const visitedFlowStart = visitedFlowCount;

const result = getTypeFromFlowType(getTypeAtFlowNode(reference.flowNode));

visitedFlowCount = visitedFlowStart;

return declaredType;

}

return result;

function getTypeAtFlowCondition(flow: FlowCondition): FlowType {

const flowType = getTypeAtFlowNode(flow.antecedent);

let type = getTypeFromFlowType(flowType);

// If we have an antecedent type (meaning we're reachable in some way), we first

// attempt to narrow the antecedent type. If that produces the never type, and if

// the antecedent type is incomplete (i.e. a transient type in a loop), then we

// narrow that.

const assumeTrue = (flow.flags & FlowFlags.TrueCondition) !== 0;

type = narrowType(type, flow.expression, assumeTrue);

type = narrowType(declaredType, flow.expression, assumeTrue);

}

}

}

if (assumeTrue) {

const narrowedType = filterType(type, t => areTypesComparable(t, valueType));

}

return isUnitType(valueType) ? filterType(type, t => t !== valueType) : type;

}

const clauseTypes = switchTypes.slice(clauseStart, clauseEnd);

const hasDefaultClause = clauseStart === clauseEnd || contains(clauseTypes, neverType);

const discriminantType = getUnionType(clauseTypes);

if (!hasDefaultClause) {

return caseType;

}

const defaultType = filterType(type, t => !(isUnitType(t) && contains(switchTypes, t)));

}

function narrowTypeByInstanceof(type: Type, expr: BinaryExpression, assumeTrue: boolean): Type {

// the candidate type. If one or more constituents remain, return a union of those.

if (type.flags & TypeFlags.Union) {

const assignableType = filterType(type, t => isTypeInstanceOf(t, candidate));

return assignableType;

}

}

// the native Promise<T> type by the caller.

type = checkAwaitedType(type, func, Diagnostics.Return_expression_in_async_function_does_not_have_a_valid_callable_then_member);

}

hasReturnOfTypeNever = true;

}

else if (!contains(aggregatedTypes, type)) {

const hasExplicitReturn = func.flags & NodeFlags.HasExplicitReturn;

error(func.type, Diagnostics.A_function_returning_never_cannot_have_a_reachable_end_point);

}

else if (returnType && !hasExplicitReturn) {

// Now that we've removed all the StringLike types, if no constituents remain, then the entire

// arrayOrStringType was a string.

return stringType;

}

}

if (func) {

const signature = getSignatureFromDeclaration(func);

const returnType = getReturnTypeOfSignature(signature);

const exprType = node.expression ? checkExpressionCached(node.expression) : undefinedType;

if (func.asteriskToken) {