Function unionOrIntersectionRelatedTo

test/fixtures/snapshot/typescript.js:65266–65300

(source, target, reportErrors, intersectionState)

                return prop.valueDeclaration && container.valueDeclaration && prop.valueDeclaration.parent === container.valueDeclaration;
            }
            function unionOrIntersectionRelatedTo(source, target, reportErrors, intersectionState) {
                // Note that these checks are specifically ordered to produce correct results. In particular,
                // we need to deconstruct unions before intersections (because unions are always at the top),
                // and we need to handle "each" relations before "some" relations for the same kind of type.
                if (source.flags & 1048576 /* TypeFlags.Union */) {
                    return relation === comparableRelation ?
                        someTypeRelatedToType(source, target, reportErrors && !(source.flags & 131068 /* TypeFlags.Primitive */), intersectionState) :
                        eachTypeRelatedToType(source, target, reportErrors && !(source.flags & 131068 /* TypeFlags.Primitive */), intersectionState);
                }
                if (target.flags & 1048576 /* TypeFlags.Union */) {
                    return typeRelatedToSomeType(getRegularTypeOfObjectLiteral(source), target, reportErrors && !(source.flags & 131068 /* TypeFlags.Primitive */) && !(target.flags & 131068 /* TypeFlags.Primitive */));
                }
                if (target.flags & 2097152 /* TypeFlags.Intersection */) {
                    return typeRelatedToEachType(getRegularTypeOfObjectLiteral(source), target, reportErrors, 2 /* IntersectionState.Target */);
                }
                // Source is an intersection. For the comparable relation, if the target is a primitive type we hoist the
                // constraints of all non-primitive types in the source into a new intersection. We do this because the
                // intersection may further constrain the constraints of the non-primitive types. For example, given a type
                // parameter 'T extends 1 | 2', the intersection 'T & 1' should be reduced to '1' such that it doesn't
                // appear to be comparable to '2'.
                if (relation === comparableRelation && target.flags & 131068 /* TypeFlags.Primitive */) {
                    var constraints = ts.sameMap(source.types, getBaseConstraintOrType);
                    if (constraints !== source.types) {
                        source = getIntersectionType(constraints);
                        if (!(source.flags & 2097152 /* TypeFlags.Intersection */)) {
                            return isRelatedTo(source, target, 1 /* RecursionFlags.Source */, /*reportErrors*/ false);
                        }
                    }
                }
                // Check to see if any constituents of the intersection are immediately related to the target.
                // Don't report errors though. Elaborating on whether a source constituent is related to the target is
                // not actually useful and leads to some confusing error messages. Instead, we rely on the caller
                // checking whether the full intersection viewed as an object is related to the target.
                return someTypeRelatedToType(source, target, /*reportErrors*/ false, 1 /* IntersectionState.Source */);
            }
            function eachTypeRelatedToSomeType(source, target) {
                var result = -1 /* Ternary.True */;
                var sourceTypes = source.types;