const silentNeverType = createIntrinsicType(TypeFlags.Never, "never");

const nonInferrableType = createIntrinsicType(TypeFlags.Never, "never", ObjectFlags.NonInferrableType);

const implicitNeverType = createIntrinsicType(TypeFlags.Never, "never");

const nonPrimitiveType = createIntrinsicType(TypeFlags.NonPrimitive, "object");

const stringNumberSymbolType = getUnionType([stringType, numberType, esSymbolType]);

const keyofConstraintType = keyofStringsOnly ? stringType : stringNumberSymbolType;

// on empty arrays are possible without implicit any errors and new element types can be inferred without

// type mismatch errors.

const resultType = getObjectFlags(evolvedType) & ObjectFlags.EvolvingArray && isEvolvingArrayOperationTarget(reference) ? autoArrayType : finalizeEvolvingArrayType(evolvedType);

return declaredType;

}

return resultType;

if (key) {

const id = getFlowNodeId(flow);

if (flowAssignmentKeys[id] === key) {

return flowAssignmentTypes[id];

}

}

// Assignments only narrow the computed type if the declared type is a union type. Thus, we

// only need to evaluate the assigned type if the declared type is a union type.

if (isMatchingReference(reference, node)) {

if (getAssignmentTargetKind(node) === AssignmentKind.Compound) {

return createFlowType(getBaseTypeOfLiteralType(getTypeFromFlowType(flowType)), isIncomplete(flowType));

}

if (declaredType === autoType || declaredType === autoArrayType) {

// reference 'x.y.z', we may be at an assignment to 'x.y' or 'x'. In that case,

// return the declared type.

if (containsMatchingReference(reference, node)) {

// A matching dotted name might also be an expando property on a function *expression*,

// in which case we continue control flow analysis back to the function's declaration

if (isVariableDeclaration(node) && (isInJSFile(node) || isVarConst(node))) {

const init = getDeclaredExpandoInitializer(node);

if (init && (init.kind === SyntaxKind.FunctionExpression || init.kind === SyntaxKind.ArrowFunction)) {

}

}

return declaredType;

return narrowedType === type ? flowType : createFlowType(narrowedType, isIncomplete(flowType));

}

if (getReturnTypeOfSignature(signature).flags & TypeFlags.Never) {

}

}

return undefined;