Function getUnionType

test/fixtures/snapshot/typescript.js:61285–61355

(types, unionReduction, aliasSymbol, aliasTypeArguments, origin)

        // circularly reference themselves and therefore cannot be subtype reduced during their declaration.
        // For example, "type Item = string | (() => Item" is a named type that circularly references itself.
        function getUnionType(types, unionReduction, aliasSymbol, aliasTypeArguments, origin) {
            if (unionReduction === void 0) { unionReduction = 1 /* UnionReduction.Literal */; }
            if (types.length === 0) {
                return neverType;
            }
            if (types.length === 1) {
                return types[0];
            }
            var typeSet = [];
            var includes = addTypesToUnion(typeSet, 0, types);
            if (unionReduction !== 0 /* UnionReduction.None */) {
                if (includes & 3 /* TypeFlags.AnyOrUnknown */) {
                    return includes & 1 /* TypeFlags.Any */ ?
                        includes & 8388608 /* TypeFlags.IncludesWildcard */ ? wildcardType : anyType :
                        includes & 65536 /* TypeFlags.Null */ || containsType(typeSet, unknownType) ? unknownType : nonNullUnknownType;
                }
                if (exactOptionalPropertyTypes && includes & 32768 /* TypeFlags.Undefined */) {
                    var missingIndex = ts.binarySearch(typeSet, missingType, getTypeId, ts.compareValues);
                    if (missingIndex >= 0 && containsType(typeSet, undefinedType)) {
                        ts.orderedRemoveItemAt(typeSet, missingIndex);
                    }
                }
                if (includes & (2944 /* TypeFlags.Literal */ | 8192 /* TypeFlags.UniqueESSymbol */ | 134217728 /* TypeFlags.TemplateLiteral */ | 268435456 /* TypeFlags.StringMapping */) || includes & 16384 /* TypeFlags.Void */ && includes & 32768 /* TypeFlags.Undefined */) {
                    removeRedundantLiteralTypes(typeSet, includes, !!(unionReduction & 2 /* UnionReduction.Subtype */));
                }
                if (includes & 128 /* TypeFlags.StringLiteral */ && includes & 134217728 /* TypeFlags.TemplateLiteral */) {
                    removeStringLiteralsMatchedByTemplateLiterals(typeSet);
                }
                if (unionReduction === 2 /* UnionReduction.Subtype */) {
                    typeSet = removeSubtypes(typeSet, !!(includes & 524288 /* TypeFlags.Object */));
                    if (!typeSet) {
                        return errorType;
                    }
                }
                if (typeSet.length === 0) {
                    return includes & 65536 /* TypeFlags.Null */ ? includes & 4194304 /* TypeFlags.IncludesNonWideningType */ ? nullType : nullWideningType :
                        includes & 32768 /* TypeFlags.Undefined */ ? includes & 4194304 /* TypeFlags.IncludesNonWideningType */ ? undefinedType : undefinedWideningType :
                            neverType;
                }
            }
            if (!origin && includes & 1048576 /* TypeFlags.Union */) {
                var namedUnions = [];
                addNamedUnions(namedUnions, types);
                var reducedTypes = [];
                var _loop_17 = function (t) {
                    if (!ts.some(namedUnions, function (union) { return containsType(union.types, t); })) {
                        reducedTypes.push(t);
                    }
                };
                for (var _i = 0, typeSet_1 = typeSet; _i < typeSet_1.length; _i++) {
                    var t = typeSet_1[_i];
                    _loop_17(t);
                }
                if (!aliasSymbol && namedUnions.length === 1 && reducedTypes.length === 0) {
                    return namedUnions[0];
                }
                // We create a denormalized origin type only when the union was created from one or more named unions
                // (unions with alias symbols or origins) and when there is no overlap between those named unions.