@zzzen/pyright-internal 1.1.254

package/dist/analyzer/types.js

@@ -0,0 +1,1844 @@
+"use strict";
+/*
+ * types.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ * Author: Eric Traut
+ *
+ * Representation of types used during type analysis within Python.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSameWithoutLiteralValue = exports.combineTypes = exports.findSubtype = exports.removeFromUnion = exports.removeNoneFromUnion = exports.removeUnbound = exports.removeIncompleteUnknownFromUnion = exports.removeUnknownFromUnion = exports.isTypeSame = exports.getTypeAliasInfo = exports.isOverloadedFunction = exports.isFunction = exports.isParamSpec = exports.isUnpacked = exports.isUnpackedClass = exports.isUnpackedVariadicTypeVar = exports.isVariadicTypeVar = exports.isTypeVar = exports.isModule = exports.isClassInstance = exports.isInstantiableClass = exports.isClass = exports.isPossiblyUnbound = exports.isUnion = exports.isUnbound = exports.isAnyOrUnknown = exports.isUnknown = exports.isAny = exports.isNoneTypeClass = exports.isNoneInstance = exports.isNever = exports.TypeVarType = exports.UnionType = exports.TypeCondition = exports.AnyType = exports.NeverType = exports.NoneType = exports.OverloadedFunctionType = exports.FunctionType = exports.ClassType = exports.ModuleType = exports.UnknownType = exports.UnboundType = exports.TypeBase = exports.maxTypeRecursionCount = exports.EnumLiteral = exports.WildcardTypeVarScopeId = void 0;
+const debug_1 = require("../common/debug");
+exports.WildcardTypeVarScopeId = '*';
+class EnumLiteral {
+    constructor(className, itemName, itemType) {
+        this.className = className;
+        this.itemName = itemName;
+        this.itemType = itemType;
+    }
+}
+exports.EnumLiteral = EnumLiteral;
+exports.maxTypeRecursionCount = 14;
+var TypeBase;
+(function (TypeBase) {
+    function isInstantiable(type) {
+        return (type.flags & 1 /* Instantiable */) !== 0;
+    }
+    TypeBase.isInstantiable = isInstantiable;
+    function isInstance(type) {
+        return (type.flags & 2 /* Instance */) !== 0;
+    }
+    TypeBase.isInstance = isInstance;
+    function isAnnotated(type) {
+        return (type.flags & 4 /* Annotated */) !== 0;
+    }
+    TypeBase.isAnnotated = isAnnotated;
+    function isSpecialForm(type) {
+        return (type.flags & 8 /* SpecialForm */) !== 0;
+    }
+    TypeBase.isSpecialForm = isSpecialForm;
+    function setSpecialForm(type) {
+        return (type.flags |= 8 /* SpecialForm */);
+    }
+    TypeBase.setSpecialForm = setSpecialForm;
+    function isAmbiguous(type) {
+        return !!type.isAmbiguous;
+    }
+    TypeBase.isAmbiguous = isAmbiguous;
+    function cloneType(type) {
+        return { ...type };
+    }
+    TypeBase.cloneType = cloneType;
+    function cloneTypeAsInstance(type) {
+        (0, debug_1.assert)(TypeBase.isInstantiable(type));
+        const newInstance = TypeBase.cloneType(type);
+        if (newInstance.instantiableNestingLevel === undefined) {
+            newInstance.flags &= ~1 /* Instantiable */;
+            newInstance.flags |= 2 /* Instance */;
+            delete newInstance.instantiableNestingLevel;
+        }
+        else {
+            if (newInstance.instantiableNestingLevel === 1) {
+                delete newInstance.instantiableNestingLevel;
+            }
+            else {
+                newInstance.instantiableNestingLevel--;
+            }
+        }
+        return newInstance;
+    }
+    TypeBase.cloneTypeAsInstance = cloneTypeAsInstance;
+    function cloneTypeAsInstantiable(type) {
+        const newInstance = TypeBase.cloneType(type);
+        if (TypeBase.isInstance(type)) {
+            newInstance.flags &= ~2 /* Instance */;
+            newInstance.flags |= 1 /* Instantiable */;
+        }
+        else {
+            newInstance.instantiableNestingLevel =
+                newInstance.instantiableNestingLevel === undefined ? 1 : newInstance.instantiableNestingLevel;
+        }
+        return newInstance;
+    }
+    TypeBase.cloneTypeAsInstantiable = cloneTypeAsInstantiable;
+    function cloneForTypeAlias(type, name, fullName, typeVarScopeId, typeParams, typeArgs) {
+        const typeClone = cloneType(type);
+        typeClone.typeAliasInfo = {
+            name,
+            fullName,
+            typeParameters: typeParams,
+            typeArguments: typeArgs,
+            typeVarScopeId,
+        };
+        return typeClone;
+    }
+    TypeBase.cloneForTypeAlias = cloneForTypeAlias;
+    function cloneForAnnotated(type) {
+        const typeClone = cloneType(type);
+        typeClone.flags |= 4 /* Annotated */;
+        return typeClone;
+    }
+    TypeBase.cloneForAnnotated = cloneForAnnotated;
+    function cloneForCondition(type, condition) {
+        // Handle the common case where there are no conditions. In this case,
+        // cloning isn't necessary.
+        if (type.condition === undefined && condition === undefined) {
+            return type;
+        }
+        const typeClone = cloneType(type);
+        typeClone.condition = condition;
+        return typeClone;
+    }
+    TypeBase.cloneForCondition = cloneForCondition;
+    function cloneForAmbiguousType(type) {
+        if (type.isAmbiguous) {
+            return type;
+        }
+        const typeClone = cloneType(type);
+        typeClone.isAmbiguous = true;
+        return typeClone;
+    }
+    TypeBase.cloneForAmbiguousType = cloneForAmbiguousType;
+})(TypeBase = exports.TypeBase || (exports.TypeBase = {}));
+var UnboundType;
+(function (UnboundType) {
+    const _instance = {
+        category: 0 /* Unbound */,
+        flags: 1 /* Instantiable */ | 2 /* Instance */,
+    };
+    function create() {
+        // All Unbound objects are the same, so use a shared instance.
+        return _instance;
+    }
+    UnboundType.create = create;
+})(UnboundType = exports.UnboundType || (exports.UnboundType = {}));
+var UnknownType;
+(function (UnknownType) {
+    const _instance = {
+        category: 1 /* Unknown */,
+        flags: 1 /* Instantiable */ | 2 /* Instance */,
+        isIncomplete: false,
+    };
+    const _incompleteInstance = {
+        category: 1 /* Unknown */,
+        flags: 1 /* Instantiable */ | 2 /* Instance */,
+        isIncomplete: true,
+    };
+    function create(isIncomplete = false) {
+        return isIncomplete ? _incompleteInstance : _instance;
+    }
+    UnknownType.create = create;
+})(UnknownType = exports.UnknownType || (exports.UnknownType = {}));
+var ModuleType;
+(function (ModuleType) {
+    function create(moduleName, filePath, symbolTable) {
+        const newModuleType = {
+            category: 8 /* Module */,
+            fields: symbolTable || new Map(),
+            loaderFields: new Map(),
+            flags: 1 /* Instantiable */ | 1 /* Instantiable */,
+            moduleName,
+            filePath,
+        };
+        return newModuleType;
+    }
+    ModuleType.create = create;
+    function getField(moduleType, name) {
+        // Always look for the symbol in the module's fields before consulting
+        // the loader fields. The loader runs before the module, so its values
+        // will be overwritten by the module.
+        let symbol = moduleType.fields.get(name);
+        if (moduleType.loaderFields) {
+            if (!symbol) {
+                symbol = moduleType.loaderFields.get(name);
+            }
+            else if (symbol.isExternallyHidden()) {
+                // If the symbol is hidden when accessed via the module but is
+                // also accessible through a loader field, use the latter so it
+                // isn't flagged as an error.
+                const loaderSymbol = moduleType.loaderFields.get(name);
+                if (loaderSymbol && !loaderSymbol.isExternallyHidden()) {
+                    symbol = loaderSymbol;
+                }
+            }
+        }
+        return symbol;
+    }
+    ModuleType.getField = getField;
+})(ModuleType = exports.ModuleType || (exports.ModuleType = {}));
+var ClassType;
+(function (ClassType) {
+    function createInstantiable(name, fullName, moduleName, filePath, flags, typeSourceId, declaredMetaclass, effectiveMetaclass, docString) {
+        const newClass = {
+            category: 7 /* Class */,
+            details: {
+                name,
+                fullName,
+                moduleName,
+                filePath,
+                flags,
+                typeSourceId,
+                baseClasses: [],
+                declaredMetaclass,
+                effectiveMetaclass,
+                mro: [],
+                fields: new Map(),
+                typeParameters: [],
+                docString,
+            },
+            flags: 1 /* Instantiable */,
+        };
+        return newClass;
+    }
+    ClassType.createInstantiable = createInstantiable;
+    function cloneAsInstance(type) {
+        if (TypeBase.isInstance(type)) {
+            return type;
+        }
+        const newInstance = TypeBase.cloneTypeAsInstance(type);
+        newInstance.flags &= ~8 /* SpecialForm */;
+        newInstance.includeSubclasses = true;
+        return newInstance;
+    }
+    ClassType.cloneAsInstance = cloneAsInstance;
+    function cloneAsInstantiable(objectType) {
+        return TypeBase.cloneTypeAsInstantiable(objectType);
+    }
+    ClassType.cloneAsInstantiable = cloneAsInstantiable;
+    function cloneForSpecialization(classType, typeArguments, isTypeArgumentExplicit, includeSubclasses = false, tupleTypeArguments, isEmptyContainer) {
+        const newClassType = TypeBase.cloneType(classType);
+        // Never should never appear as a type argument, so replace it with
+        newClassType.typeArguments = typeArguments
+            ? typeArguments.map((t) => (isNever(t) && !t.isNoReturn ? UnknownType.create() : t))
+            : undefined;
+        newClassType.isTypeArgumentExplicit = isTypeArgumentExplicit;
+        if (includeSubclasses) {
+            newClassType.includeSubclasses = true;
+        }
+        newClassType.tupleTypeArguments = tupleTypeArguments
+            ? tupleTypeArguments.map((t) => isNever(t.type) ? { type: UnknownType.create(), isUnbounded: t.isUnbounded } : t)
+            : undefined;
+        if (isEmptyContainer !== undefined) {
+            newClassType.isEmptyContainer = isEmptyContainer;
+        }
+        return newClassType;
+    }
+    ClassType.cloneForSpecialization = cloneForSpecialization;
+    function cloneWithLiteral(classType, value) {
+        const newClassType = TypeBase.cloneType(classType);
+        newClassType.literalValue = value;
+        return newClassType;
+    }
+    ClassType.cloneWithLiteral = cloneWithLiteral;
+    function cloneForTypingAlias(classType, aliasName) {
+        const newClassType = TypeBase.cloneType(classType);
+        newClassType.aliasName = aliasName;
+        return newClassType;
+    }
+    ClassType.cloneForTypingAlias = cloneForTypingAlias;
+    function cloneForNarrowedTypedDictEntries(classType, narrowedEntries) {
+        const newClassType = TypeBase.cloneType(classType);
+        newClassType.typedDictNarrowedEntries = narrowedEntries;
+        return newClassType;
+    }
+    ClassType.cloneForNarrowedTypedDictEntries = cloneForNarrowedTypedDictEntries;
+    function cloneWithNewTypeParameters(classType, typeParams) {
+        const newClassType = TypeBase.cloneType(classType);
+        newClassType.details = { ...newClassType.details };
+        newClassType.details.typeParameters = typeParams;
+        return newClassType;
+    }
+    ClassType.cloneWithNewTypeParameters = cloneWithNewTypeParameters;
+    function cloneForTypeGuard(classType, typeGuardType, isStrictTypeGuard) {
+        const newClassType = TypeBase.cloneType(classType);
+        newClassType.typeGuardType = typeGuardType;
+        newClassType.isStrictTypeGuard = isStrictTypeGuard;
+        return newClassType;
+    }
+    ClassType.cloneForTypeGuard = cloneForTypeGuard;
+    function cloneForSymbolTableUpdate(classType) {
+        const newClassType = TypeBase.cloneType(classType);
+        newClassType.details = { ...newClassType.details };
+        newClassType.details.fields = new Map(newClassType.details.fields);
+        newClassType.details.mro = [...newClassType.details.mro];
+        newClassType.details.mro[0] = cloneAsInstantiable(newClassType);
+        return newClassType;
+    }
+    ClassType.cloneForSymbolTableUpdate = cloneForSymbolTableUpdate;
+    function cloneForUnpacked(classType, isUnpacked = true) {
+        const newClassType = TypeBase.cloneType(classType);
+        newClassType.isUnpacked = isUnpacked;
+        return newClassType;
+    }
+    ClassType.cloneForUnpacked = cloneForUnpacked;
+    function isLiteralValueSame(type1, type2) {
+        if (type1.literalValue === undefined) {
+            return type2.literalValue === undefined;
+        }
+        else if (type2.literalValue === undefined) {
+            return false;
+        }
+        if (type1.literalValue instanceof EnumLiteral) {
+            if (type2.literalValue instanceof EnumLiteral) {
+                return type1.literalValue.itemName === type2.literalValue.itemName;
+            }
+            return false;
+        }
+        return type1.literalValue === type2.literalValue;
+    }
+    ClassType.isLiteralValueSame = isLiteralValueSame;
+    // Is the class generic but not specialized?
+    function isUnspecialized(classType) {
+        return classType.details.typeParameters.length > 0 && classType.typeArguments === undefined;
+    }
+    ClassType.isUnspecialized = isUnspecialized;
+    function isSpecialBuiltIn(classType, className) {
+        if (!(classType.details.flags & 2 /* SpecialBuiltIn */) && !classType.aliasName) {
+            return false;
+        }
+        if (className !== undefined) {
+            return classType.details.name === className;
+        }
+        return true;
+    }
+    ClassType.isSpecialBuiltIn = isSpecialBuiltIn;
+    function isBuiltIn(classType, className) {
+        if (!(classType.details.flags & 1 /* BuiltInClass */)) {
+            return false;
+        }
+        if (className !== undefined) {
+            const classArray = Array.isArray(className) ? className : [className];
+            return (classArray.some((name) => name === classType.details.name) ||
+                classArray.some((name) => name === classType.aliasName));
+        }
+        return true;
+    }
+    ClassType.isBuiltIn = isBuiltIn;
+    function derivesFromAnyOrUnknown(classType) {
+        return classType.details.mro.some((mroClass) => !isClass(mroClass));
+    }
+    ClassType.derivesFromAnyOrUnknown = derivesFromAnyOrUnknown;
+    function supportsAbstractMethods(classType) {
+        return !!(classType.details.flags & 512 /* SupportsAbstractMethods */);
+    }
+    ClassType.supportsAbstractMethods = supportsAbstractMethods;
+    function isDataClass(classType) {
+        return !!(classType.details.flags & 4 /* DataClass */);
+    }
+    ClassType.isDataClass = isDataClass;
+    function isSkipSynthesizedDataClassInit(classType) {
+        return !!(classType.details.flags & 16 /* SkipSynthesizedDataClassInit */);
+    }
+    ClassType.isSkipSynthesizedDataClassInit = isSkipSynthesizedDataClassInit;
+    function isSkipSynthesizedDataClassEq(classType) {
+        return !!(classType.details.flags & 32 /* SkipSynthesizedDataClassEq */);
+    }
+    ClassType.isSkipSynthesizedDataClassEq = isSkipSynthesizedDataClassEq;
+    function isFrozenDataClass(classType) {
+        return !!(classType.details.flags & 8 /* FrozenDataClass */);
+    }
+    ClassType.isFrozenDataClass = isFrozenDataClass;
+    function isSynthesizedDataclassOrder(classType) {
+        return !!(classType.details.flags & 64 /* SynthesizedDataClassOrder */);
+    }
+    ClassType.isSynthesizedDataclassOrder = isSynthesizedDataclassOrder;
+    function isDataClassKeywordOnlyParams(classType) {
+        return !!(classType.details.flags & 2097152 /* DataClassKeywordOnlyParams */);
+    }
+    ClassType.isDataClassKeywordOnlyParams = isDataClassKeywordOnlyParams;
+    function isGeneratedDataClassSlots(classType) {
+        return !!(classType.details.flags & 33554432 /* GenerateDataClassSlots */);
+    }
+    ClassType.isGeneratedDataClassSlots = isGeneratedDataClassSlots;
+    function isSynthesizeDataClassUnsafeHash(classType) {
+        return !!(classType.details.flags & 67108864 /* SynthesizeDataClassUnsafeHash */);
+    }
+    ClassType.isSynthesizeDataClassUnsafeHash = isSynthesizeDataClassUnsafeHash;
+    function isTypedDictClass(classType) {
+        return !!(classType.details.flags & 128 /* TypedDictClass */);
+    }
+    ClassType.isTypedDictClass = isTypedDictClass;
+    function isCanOmitDictValues(classType) {
+        return !!(classType.details.flags & 256 /* CanOmitDictValues */);
+    }
+    ClassType.isCanOmitDictValues = isCanOmitDictValues;
+    function isEnumClass(classType) {
+        return !!(classType.details.flags & 1048576 /* EnumClass */);
+    }
+    ClassType.isEnumClass = isEnumClass;
+    function isPropertyClass(classType) {
+        return !!(classType.details.flags & 2048 /* PropertyClass */);
+    }
+    ClassType.isPropertyClass = isPropertyClass;
+    function isClassProperty(classType) {
+        return !!(classType.details.flags & 4194304 /* ClassProperty */);
+    }
+    ClassType.isClassProperty = isClassProperty;
+    function isFinal(classType) {
+        return !!(classType.details.flags & 4096 /* Final */);
+    }
+    ClassType.isFinal = isFinal;
+    function isProtocolClass(classType) {
+        return !!(classType.details.flags & 8192 /* ProtocolClass */);
+    }
+    ClassType.isProtocolClass = isProtocolClass;
+    function isDefinedInStub(classType) {
+        return !!(classType.details.flags & 8388608 /* DefinedInStub */);
+    }
+    ClassType.isDefinedInStub = isDefinedInStub;
+    function isPseudoGenericClass(classType) {
+        return !!(classType.details.flags & 16384 /* PseudoGenericClass */);
+    }
+    ClassType.isPseudoGenericClass = isPseudoGenericClass;
+    function getDataClassEntries(classType) {
+        return classType.details.dataClassEntries || [];
+    }
+    ClassType.getDataClassEntries = getDataClassEntries;
+    function isRuntimeCheckable(classType) {
+        return !!(classType.details.flags & 32768 /* RuntimeCheckable */);
+    }
+    ClassType.isRuntimeCheckable = isRuntimeCheckable;
+    function isTypingExtensionClass(classType) {
+        return !!(classType.details.flags & 65536 /* TypingExtensionClass */);
+    }
+    ClassType.isTypingExtensionClass = isTypingExtensionClass;
+    function isPartiallyEvaluated(classType) {
+        return !!(classType.details.flags & 131072 /* PartiallyEvaluated */);
+    }
+    ClassType.isPartiallyEvaluated = isPartiallyEvaluated;
+    function hasCustomClassGetItem(classType) {
+        return !!(classType.details.flags & 262144 /* HasCustomClassGetItem */);
+    }
+    ClassType.hasCustomClassGetItem = hasCustomClassGetItem;
+    function isTupleClass(classType) {
+        return !!(classType.details.flags & 524288 /* TupleClass */);
+    }
+    ClassType.isTupleClass = isTupleClass;
+    function isReadOnlyInstanceVariables(classType) {
+        return !!(classType.details.flags & 16777216 /* ReadOnlyInstanceVariables */);
+    }
+    ClassType.isReadOnlyInstanceVariables = isReadOnlyInstanceVariables;
+    function getTypeParameters(classType) {
+        return classType.details.typeParameters;
+    }
+    ClassType.getTypeParameters = getTypeParameters;
+    function hasUnknownBaseClass(classType) {
+        return classType.details.mro.some((baseClass) => isAnyOrUnknown(baseClass));
+    }
+    ClassType.hasUnknownBaseClass = hasUnknownBaseClass;
+    // Similar to isPartiallyEvaluated except that it also looks at all of the
+    // classes in the MRO list for this class to see if any of them are still
+    // partially evaluated.
+    function isHierarchyPartiallyEvaluated(classType) {
+        return (ClassType.isPartiallyEvaluated(classType) ||
+            classType.details.mro.some((mroClass) => isClass(mroClass) && ClassType.isPartiallyEvaluated(mroClass)));
+    }
+    ClassType.isHierarchyPartiallyEvaluated = isHierarchyPartiallyEvaluated;
+    // Same as isSame except that it doesn't compare type arguments.
+    function isSameGenericClass(classType, type2, recursionCount = 0) {
+        if (recursionCount > exports.maxTypeRecursionCount) {
+            return true;
+        }
+        recursionCount++;
+        // If the class details match, it's definitely the same class.
+        if (classType.details === type2.details) {
+            return true;
+        }
+        // If either or both have aliases (e.g. List -> list), use the
+        // aliases for comparison purposes.
+        const class1Details = classType.details;
+        const class2Details = type2.details;
+        if (class1Details === class2Details) {
+            return true;
+        }
+        // Compare most of the details fields. We intentionally skip the isAbstractClass
+        // flag because it gets set dynamically.
+        if (class1Details.fullName !== class2Details.fullName ||
+            class1Details.flags !== class2Details.flags ||
+            class1Details.typeSourceId !== class2Details.typeSourceId ||
+            class1Details.baseClasses.length !== class2Details.baseClasses.length ||
+            class1Details.typeParameters.length !== class2Details.typeParameters.length) {
+            return false;
+        }
+        // Special-case NamedTuple and Tuple classes because we rewrite the base classes
+        // in these cases.
+        if (ClassType.isBuiltIn(classType, 'NamedTuple') && ClassType.isBuiltIn(type2, 'NamedTuple')) {
+            return true;
+        }
+        if (ClassType.isBuiltIn(classType, 'tuple') && ClassType.isBuiltIn(type2, 'tuple')) {
+            return true;
+        }
+        // Make sure the base classes match.
+        for (let i = 0; i < class1Details.baseClasses.length; i++) {
+            if (!isTypeSame(class1Details.baseClasses[i], class2Details.baseClasses[i], 
+            /* ignorePseudoGeneric */ true, 
+            /* ignoreTypeFlags */ undefined, recursionCount)) {
+                return false;
+            }
+        }
+        if (class1Details.declaredMetaclass || class2Details.declaredMetaclass) {
+            if (!class1Details.declaredMetaclass ||
+                !class2Details.declaredMetaclass ||
+                !isTypeSame(class1Details.declaredMetaclass, class2Details.declaredMetaclass, 
+                /* ignorePseudoGeneric */ true, 
+                /* ignoreTypeFlags */ undefined, recursionCount)) {
+                return false;
+            }
+        }
+        for (let i = 0; i < class1Details.typeParameters.length; i++) {
+            if (!isTypeSame(class1Details.typeParameters[i], class2Details.typeParameters[i], 
+            /* ignorePseudoGeneric */ true, 
+            /* ignoreTypeFlags */ undefined, recursionCount)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    ClassType.isSameGenericClass = isSameGenericClass;
+    // Determines whether this is a subclass (derived class)
+    // of the specified class. If the caller passes an empty
+    // array to inheritanceChain, it will be filled in by
+    // the call to include the chain of inherited classes starting
+    // with type2 and ending with this type.
+    function isDerivedFrom(subclassType, parentClassType, inheritanceChain) {
+        // Is it the exact same class?
+        if (isSameGenericClass(subclassType, parentClassType)) {
+            if (inheritanceChain) {
+                inheritanceChain.push(subclassType);
+            }
+            return true;
+        }
+        // Handle built-in types like 'dict' and 'list', which are all
+        // subclasses of object even though they are not explicitly declared
+        // that way.
+        if (isBuiltIn(subclassType) && isBuiltIn(parentClassType, 'object')) {
+            if (inheritanceChain) {
+                inheritanceChain.push(parentClassType);
+            }
+            return true;
+        }
+        for (const baseClass of subclassType.details.baseClasses) {
+            if (isInstantiableClass(baseClass)) {
+                if (isDerivedFrom(baseClass, parentClassType, inheritanceChain)) {
+                    if (inheritanceChain) {
+                        inheritanceChain.push(subclassType);
+                    }
+                    return true;
+                }
+            }
+            else if (isAnyOrUnknown(baseClass)) {
+                if (inheritanceChain) {
+                    inheritanceChain.push(UnknownType.create());
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+    ClassType.isDerivedFrom = isDerivedFrom;
+})(ClassType = exports.ClassType || (exports.ClassType = {}));
+var FunctionType;
+(function (FunctionType) {
+    function createInstance(name, fullName, moduleName, functionFlags, docString) {
+        return create(name, fullName, moduleName, functionFlags, 2 /* Instance */, docString);
+    }
+    FunctionType.createInstance = createInstance;
+    function createInstantiable(functionFlags, docString) {
+        return create('', '', '', functionFlags, 1 /* Instantiable */, docString);
+    }
+    FunctionType.createInstantiable = createInstantiable;
+    function createSynthesizedInstance(name, additionalFlags = 0 /* None */) {
+        return create(name, '', '', additionalFlags | 64 /* SynthesizedMethod */, 2 /* Instance */);
+    }
+    FunctionType.createSynthesizedInstance = createSynthesizedInstance;
+    function create(name, fullName, moduleName, functionFlags, typeFlags, docString) {
+        const newFunctionType = {
+            category: 5 /* Function */,
+            details: {
+                name,
+                fullName,
+                moduleName,
+                flags: functionFlags,
+                parameters: [],
+                docString,
+            },
+            flags: typeFlags,
+        };
+        return newFunctionType;
+    }
+    // Creates a deep copy of the function type, including a fresh
+    // version of _functionDetails.
+    function clone(type, stripFirstParam = false, boundToType, boundTypeVarScopeId) {
+        var _a;
+        const newFunction = create(type.details.name, type.details.fullName, type.details.moduleName, type.details.flags, type.flags, type.details.docString);
+        newFunction.details = { ...type.details };
+        newFunction.boundToType = boundToType;
+        newFunction.preBoundFlags = newFunction.details.flags;
+        if (stripFirstParam) {
+            if (type.details.parameters.length > 0 &&
+                type.details.parameters[0].category === 0 /* Simple */) {
+                if (type.details.parameters.length > 0 && !type.details.parameters[0].isTypeInferred) {
+                    // Stash away the effective type of the first parameter if it
+                    // wasn't synthesized.
+                    newFunction.strippedFirstParamType = getEffectiveParameterType(type, 0);
+                }
+                newFunction.details.parameters = type.details.parameters.slice(1);
+            }
+            else {
+                stripFirstParam = false;
+            }
+            // If we strip off the first parameter, this is no longer an
+            // instance method or class method.
+            newFunction.details.flags &= ~(1 /* ConstructorMethod */ | 2 /* ClassMethod */);
+            newFunction.details.flags |= 4 /* StaticMethod */;
+        }
+        if (type.typeAliasInfo !== undefined) {
+            newFunction.typeAliasInfo = type.typeAliasInfo;
+        }
+        if (type.specializedTypes) {
+            newFunction.specializedTypes = {
+                parameterTypes: stripFirstParam
+                    ? type.specializedTypes.parameterTypes.slice(1)
+                    : type.specializedTypes.parameterTypes,
+                parameterDefaultArgs: stripFirstParam
+                    ? (_a = type.specializedTypes.parameterDefaultArgs) === null || _a === void 0 ? void 0 : _a.slice(1)
+                    : type.specializedTypes.parameterDefaultArgs,
+                returnType: type.specializedTypes.returnType,
+            };
+        }
+        newFunction.inferredReturnType = type.inferredReturnType;
+        newFunction.boundTypeVarScopeId = boundTypeVarScopeId;
+        return newFunction;
+    }
+    FunctionType.clone = clone;
+    function cloneAsInstance(type) {
+        const newInstance = TypeBase.cloneTypeAsInstance(type);
+        newInstance.flags &= ~8 /* SpecialForm */;
+        return newInstance;
+    }
+    FunctionType.cloneAsInstance = cloneAsInstance;
+    function cloneAsInstantiable(type) {
+        const newInstance = TypeBase.cloneTypeAsInstantiable(type);
+        newInstance.flags &= ~8 /* SpecialForm */;
+        return newInstance;
+    }
+    FunctionType.cloneAsInstantiable = cloneAsInstantiable;
+    // Creates a shallow copy of the function type with new
+    // specialized types. The clone shares the _functionDetails
+    // with the object being cloned.
+    function cloneForSpecialization(type, specializedTypes, specializedInferredReturnType) {
+        const newFunction = create(type.details.name, type.details.fullName, type.details.moduleName, type.details.flags, type.flags, type.details.docString);
+        newFunction.details = type.details;
+        (0, debug_1.assert)(specializedTypes.parameterTypes.length === type.details.parameters.length);
+        if (specializedTypes.parameterDefaultArgs) {
+            (0, debug_1.assert)(specializedTypes.parameterDefaultArgs.length === type.details.parameters.length);
+        }
+        newFunction.specializedTypes = specializedTypes;
+        if (specializedInferredReturnType) {
+            newFunction.inferredReturnType = specializedInferredReturnType;
+        }
+        return newFunction;
+    }
+    FunctionType.cloneForSpecialization = cloneForSpecialization;
+    // Creates a new function based on the parameters of another function.
+    function cloneForParamSpec(type, paramSpecValue) {
+        const newFunction = create(type.details.name, type.details.fullName, type.details.moduleName, type.details.flags, type.flags, type.details.docString);
+        // Make a shallow clone of the details.
+        newFunction.details = { ...type.details };
+        // The clone should no longer have a parameter specification
+        // since we're replacing it.
+        delete newFunction.details.paramSpec;
+        if (paramSpecValue) {
+            newFunction.details.parameters = [
+                ...type.details.parameters,
+                ...paramSpecValue.parameters.map((specEntry) => {
+                    return {
+                        category: specEntry.category,
+                        name: specEntry.name,
+                        hasDefault: specEntry.hasDefault,
+                        isNameSynthesized: specEntry.isNameSynthesized,
+                        hasDeclaredType: true,
+                        type: specEntry.type,
+                    };
+                }),
+            ];
+            if (!newFunction.details.docString) {
+                newFunction.details.docString = paramSpecValue.docString;
+            }
+            newFunction.details.flags =
+                (paramSpecValue.flags &
+                    (2 /* ClassMethod */ |
+                        4 /* StaticMethod */ |
+                        1 /* ConstructorMethod */ |
+                        32768 /* SkipArgsKwargsCompatibilityCheck */)) |
+                    64 /* SynthesizedMethod */;
+            if (FunctionType.isParamSpecValue(type)) {
+                newFunction.details.flags |= 65536 /* ParamSpecValue */;
+            }
+            // Update the specialized parameter types as well.
+            if (type.specializedTypes) {
+                newFunction.specializedTypes = {
+                    parameterTypes: [...type.specializedTypes.parameterTypes],
+                    returnType: type.specializedTypes.returnType,
+                };
+                if (type.specializedTypes.parameterDefaultArgs) {
+                    newFunction.specializedTypes.parameterDefaultArgs = [...type.specializedTypes.parameterDefaultArgs];
+                }
+                paramSpecValue.parameters.forEach((paramInfo) => {
+                    newFunction.specializedTypes.parameterTypes.push(paramInfo.type);
+                    if (newFunction.specializedTypes.parameterDefaultArgs) {
+                        // Assume that the parameters introduced via paramSpec have no specialized
+                        // default arg types. Fall back on the original default arg type in this case.
+                        newFunction.specializedTypes.parameterDefaultArgs.push(undefined);
+                    }
+                });
+            }
+            newFunction.details.paramSpec = paramSpecValue.paramSpec;
+        }
+        return newFunction;
+    }
+    FunctionType.cloneForParamSpec = cloneForParamSpec;
+    function cloneWithNewFlags(type, flags) {
+        const newFunction = TypeBase.cloneType(type);
+        // Make a shallow clone of the details.
+        newFunction.details = { ...type.details };
+        newFunction.details.flags = flags;
+        return newFunction;
+    }
+    FunctionType.cloneWithNewFlags = cloneWithNewFlags;
+    function cloneForParamSpecApplication(type, paramSpecValue) {
+        const newFunction = TypeBase.cloneType(type);
+        // Make a shallow clone of the details.
+        newFunction.details = { ...type.details };
+        // Remove the last two parameters, which are the *args and **kwargs.
+        newFunction.details.parameters = newFunction.details.parameters.slice(0, newFunction.details.parameters.length - 2);
+        // If there is a position-only separator in the captured param spec signature,
+        // remove the position-only separator in the existing signature. Otherwise,
+        // we'll end up with redundant position-only separators.
+        if (paramSpecValue.parameters.some((entry) => entry.category === 0 /* Simple */ && !entry.name)) {
+            if (newFunction.details.parameters.length > 0) {
+                const lastParam = newFunction.details.parameters[newFunction.details.parameters.length - 1];
+                if (lastParam.category === 0 /* Simple */ && !lastParam.name) {
+                    newFunction.details.parameters.pop();
+                }
+            }
+        }
+        paramSpecValue.parameters.forEach((specEntry) => {
+            newFunction.details.parameters.push({
+                category: specEntry.category,
+                name: specEntry.name,
+                hasDefault: specEntry.hasDefault,
+                isNameSynthesized: specEntry.isNameSynthesized,
+                hasDeclaredType: true,
+                type: specEntry.type,
+            });
+        });
+        newFunction.details.paramSpec = paramSpecValue.paramSpec;
+        if (!newFunction.details.docString) {
+            newFunction.details.docString = paramSpecValue.docString;
+        }
+        return newFunction;
+    }
+    FunctionType.cloneForParamSpecApplication = cloneForParamSpecApplication;
+    function cloneRemoveParamSpecVariadics(type, paramSpec) {
+        const newFunction = create(type.details.name, type.details.fullName, type.details.moduleName, type.details.flags, type.flags, type.details.docString);
+        // Make a shallow clone of the details.
+        newFunction.details = { ...type.details };
+        // Remove the last two parameters, which are the *args and **kwargs.
+        newFunction.details.parameters = newFunction.details.parameters.slice(0, newFunction.details.parameters.length - 2);
+        if (type.specializedTypes) {
+            newFunction.specializedTypes = { ...type.specializedTypes };
+            newFunction.specializedTypes.parameterTypes = newFunction.specializedTypes.parameterTypes.slice(0, newFunction.specializedTypes.parameterTypes.length - 2);
+            if (newFunction.specializedTypes.parameterDefaultArgs) {
+                newFunction.specializedTypes.parameterDefaultArgs =
+                    newFunction.specializedTypes.parameterDefaultArgs.slice(0, newFunction.specializedTypes.parameterDefaultArgs.length - 2);
+            }
+        }
+        if (!newFunction.details.paramSpec) {
+            newFunction.details.paramSpec = paramSpec;
+        }
+        return newFunction;
+    }
+    FunctionType.cloneRemoveParamSpecVariadics = cloneRemoveParamSpecVariadics;
+    function addDefaultParameters(functionType, useUnknown = false) {
+        getDefaultParameters(useUnknown).forEach((param) => {
+            FunctionType.addParameter(functionType, param);
+        });
+    }
+    FunctionType.addDefaultParameters = addDefaultParameters;
+    function getDefaultParameters(useUnknown = false) {
+        return [
+            {
+                category: 1 /* VarArgList */,
+                name: 'args',
+                type: useUnknown ? UnknownType.create() : AnyType.create(),
+                hasDeclaredType: !useUnknown,
+            },
+            {
+                category: 2 /* VarArgDictionary */,
+                name: 'kwargs',
+                type: useUnknown ? UnknownType.create() : AnyType.create(),
+                hasDeclaredType: !useUnknown,
+            },
+        ];
+    }
+    FunctionType.getDefaultParameters = getDefaultParameters;
+    // Indicates whether the input signature consists of (*args: Any, **kwargs: Any).
+    function hasDefaultParameters(functionType) {
+        let sawArgs = false;
+        let sawKwargs = false;
+        for (let i = 0; i < functionType.details.parameters.length; i++) {
+            const param = functionType.details.parameters[i];
+            // Ignore nameless separator parameters.
+            if (!param.name) {
+                continue;
+            }
+            if (param.category === 0 /* Simple */) {
+                return false;
+            }
+            else if (param.category === 1 /* VarArgList */) {
+                sawArgs = true;
+            }
+            else if (param.category === 2 /* VarArgDictionary */) {
+                sawKwargs = true;
+            }
+            if (!isAnyOrUnknown(FunctionType.getEffectiveParameterType(functionType, i))) {
+                return false;
+            }
+        }
+        return sawArgs && sawKwargs;
+    }
+    FunctionType.hasDefaultParameters = hasDefaultParameters;
+    function isInstanceMethod(type) {
+        return ((type.details.flags &
+            (1 /* ConstructorMethod */ |
+                4 /* StaticMethod */ |
+                2 /* ClassMethod */)) ===
+            0);
+    }
+    FunctionType.isInstanceMethod = isInstanceMethod;
+    function isConstructorMethod(type) {
+        return (type.details.flags & 1 /* ConstructorMethod */) !== 0;
+    }
+    FunctionType.isConstructorMethod = isConstructorMethod;
+    function isStaticMethod(type) {
+        return (type.details.flags & 4 /* StaticMethod */) !== 0;
+    }
+    FunctionType.isStaticMethod = isStaticMethod;
+    function isClassMethod(type) {
+        return (type.details.flags & 2 /* ClassMethod */) !== 0;
+    }
+    FunctionType.isClassMethod = isClassMethod;
+    function isAbstractMethod(type) {
+        return (type.details.flags & 8 /* AbstractMethod */) !== 0;
+    }
+    FunctionType.isAbstractMethod = isAbstractMethod;
+    function isGenerator(type) {
+        return (type.details.flags & 16 /* Generator */) !== 0;
+    }
+    FunctionType.isGenerator = isGenerator;
+    function isSynthesizedMethod(type) {
+        return (type.details.flags & 64 /* SynthesizedMethod */) !== 0;
+    }
+    FunctionType.isSynthesizedMethod = isSynthesizedMethod;
+    function isSkipConstructorCheck(type) {
+        return (type.details.flags & 128 /* SkipConstructorCheck */) !== 0;
+    }
+    FunctionType.isSkipConstructorCheck = isSkipConstructorCheck;
+    function isOverloaded(type) {
+        return (type.details.flags & 256 /* Overloaded */) !== 0;
+    }
+    FunctionType.isOverloaded = isOverloaded;
+    function isDefaultParameterCheckDisabled(type) {
+        return (type.details.flags & 32 /* DisableDefaultChecks */) !== 0;
+    }
+    FunctionType.isDefaultParameterCheckDisabled = isDefaultParameterCheckDisabled;
+    function isAsync(type) {
+        return (type.details.flags & 512 /* Async */) !== 0;
+    }
+    FunctionType.isAsync = isAsync;
+    function isWrapReturnTypeInAwait(type) {
+        return (type.details.flags & 1024 /* WrapReturnTypeInAwait */) !== 0;
+    }
+    FunctionType.isWrapReturnTypeInAwait = isWrapReturnTypeInAwait;
+    function isStubDefinition(type) {
+        return (type.details.flags & 2048 /* StubDefinition */) !== 0;
+    }
+    FunctionType.isStubDefinition = isStubDefinition;
+    function isPyTypedDefinition(type) {
+        return (type.details.flags & 4096 /* PyTypedDefinition */) !== 0;
+    }
+    FunctionType.isPyTypedDefinition = isPyTypedDefinition;
+    function isFinal(type) {
+        return (type.details.flags & 8192 /* Final */) !== 0;
+    }
+    FunctionType.isFinal = isFinal;
+    function hasUnannotatedParams(type) {
+        return (type.details.flags & 16384 /* UnannotatedParams */) !== 0;
+    }
+    FunctionType.hasUnannotatedParams = hasUnannotatedParams;
+    function shouldSkipArgsKwargsCompatibilityCheck(type) {
+        return (type.details.flags & 32768 /* SkipArgsKwargsCompatibilityCheck */) !== 0;
+    }
+    FunctionType.shouldSkipArgsKwargsCompatibilityCheck = shouldSkipArgsKwargsCompatibilityCheck;
+    function isParamSpecValue(type) {
+        return (type.details.flags & 65536 /* ParamSpecValue */) !== 0;
+    }
+    FunctionType.isParamSpecValue = isParamSpecValue;
+    function isPartiallyEvaluated(type) {
+        return !!(type.details.flags & 131072 /* PartiallyEvaluated */);
+    }
+    FunctionType.isPartiallyEvaluated = isPartiallyEvaluated;
+    function getEffectiveParameterType(type, index) {
+        (0, debug_1.assert)(index < type.details.parameters.length, 'Parameter types array overflow');
+        if (type.specializedTypes && index < type.specializedTypes.parameterTypes.length) {
+            return type.specializedTypes.parameterTypes[index];
+        }
+        return type.details.parameters[index].type;
+    }
+    FunctionType.getEffectiveParameterType = getEffectiveParameterType;
+    function getEffectiveParameterDefaultArgType(type, index) {
+        var _a;
+        (0, debug_1.assert)(index < type.details.parameters.length, 'Parameter types array overflow');
+        if (((_a = type.specializedTypes) === null || _a === void 0 ? void 0 : _a.parameterDefaultArgs) && index < type.specializedTypes.parameterDefaultArgs.length) {
+            const defaultArgType = type.specializedTypes.parameterDefaultArgs[index];
+            if (defaultArgType) {
+                return defaultArgType;
+            }
+        }
+        return type.details.parameters[index].defaultType;
+    }
+    FunctionType.getEffectiveParameterDefaultArgType = getEffectiveParameterDefaultArgType;
+    function addParameter(type, param) {
+        type.details.parameters.push(param);
+    }
+    FunctionType.addParameter = addParameter;
+    function getSpecializedReturnType(type) {
+        return type.specializedTypes && type.specializedTypes.returnType
+            ? type.specializedTypes.returnType
+            : type.details.declaredReturnType;
+    }
+    FunctionType.getSpecializedReturnType = getSpecializedReturnType;
+})(FunctionType = exports.FunctionType || (exports.FunctionType = {}));
+var OverloadedFunctionType;
+(function (OverloadedFunctionType) {
+    function create(overloads) {
+        const newType = {
+            category: 6 /* OverloadedFunction */,
+            overloads,
+            flags: 2 /* Instance */,
+        };
+        return newType;
+    }
+    OverloadedFunctionType.create = create;
+    function addOverload(type, functionType) {
+        type.overloads.push(functionType);
+    }
+    OverloadedFunctionType.addOverload = addOverload;
+})(OverloadedFunctionType = exports.OverloadedFunctionType || (exports.OverloadedFunctionType = {}));
+var NoneType;
+(function (NoneType) {
+    const _noneInstance = {
+        category: 3 /* None */,
+        flags: 2 /* Instance */,
+    };
+    const _noneType = {
+        category: 3 /* None */,
+        flags: 1 /* Instantiable */,
+    };
+    function createInstance() {
+        return _noneInstance;
+    }
+    NoneType.createInstance = createInstance;
+    function createType() {
+        return _noneType;
+    }
+    NoneType.createType = createType;
+})(NoneType = exports.NoneType || (exports.NoneType = {}));
+var NeverType;
+(function (NeverType) {
+    const _neverInstance = {
+        category: 4 /* Never */,
+        flags: 2 /* Instance */ | 1 /* Instantiable */,
+        isNoReturn: false,
+    };
+    const _noReturnInstance = {
+        category: 4 /* Never */,
+        flags: 2 /* Instance */ | 1 /* Instantiable */,
+        isNoReturn: true,
+    };
+    function createNever() {
+        return _neverInstance;
+    }
+    NeverType.createNever = createNever;
+    function createNoReturn() {
+        return _noReturnInstance;
+    }
+    NeverType.createNoReturn = createNoReturn;
+})(NeverType = exports.NeverType || (exports.NeverType = {}));
+var AnyType;
+(function (AnyType) {
+    const _anyInstance = {
+        category: 2 /* Any */,
+        isEllipsis: false,
+        flags: 2 /* Instance */ | 1 /* Instantiable */,
+    };
+    const _ellipsisInstance = {
+        category: 2 /* Any */,
+        isEllipsis: true,
+        flags: 2 /* Instance */ | 1 /* Instantiable */,
+    };
+    function create(isEllipsis = false) {
+        return isEllipsis ? _ellipsisInstance : _anyInstance;
+    }
+    AnyType.create = create;
+})(AnyType = exports.AnyType || (exports.AnyType = {}));
+var TypeCondition;
+(function (TypeCondition) {
+    function combine(conditions1, conditions2) {
+        if (!conditions1) {
+            return conditions2;
+        }
+        if (!conditions2) {
+            return conditions1;
+        }
+        // Deduplicate the lists.
+        const combined = [...conditions1];
+        conditions2.forEach((c1) => {
+            if (!combined.some((c2) => _compare(c1, c2) === 0)) {
+                combined.push(c1);
+            }
+        });
+        // Always keep the conditions sorted for easier comparison.
+        return combined.sort(_compare);
+    }
+    TypeCondition.combine = combine;
+    function _compare(c1, c2) {
+        if (c1.typeVarName < c2.typeVarName) {
+            return -1;
+        }
+        else if (c1.typeVarName > c2.typeVarName) {
+            return 1;
+        }
+        if (c1.constraintIndex < c2.constraintIndex) {
+            return -1;
+        }
+        else if (c1.constraintIndex > c2.constraintIndex) {
+            return 1;
+        }
+        return 0;
+    }
+    function isSame(conditions1, conditions2) {
+        if (!conditions1) {
+            return !conditions2;
+        }
+        if (!conditions2 || conditions1.length !== conditions2.length) {
+            return false;
+        }
+        return (conditions1.find((c1, index) => c1.typeVarName !== conditions2[index].typeVarName ||
+            c1.constraintIndex !== conditions2[index].constraintIndex) === undefined);
+    }
+    TypeCondition.isSame = isSame;
+    // Determines if the two conditions can be used at the same time. If
+    // one constraint list contains a constraint for a type variable, and the
+    // same constraint is not in the other constraint list, the two are considered
+    // incompatible.
+    function isCompatible(conditions1, conditions2) {
+        if (!conditions1 || !conditions2) {
+            return true;
+        }
+        for (const c1 of conditions1) {
+            let foundTypeVarMatch = false;
+            const exactMatch = conditions2.find((c2) => {
+                if (c1.typeVarName === c2.typeVarName) {
+                    foundTypeVarMatch = true;
+                    return c1.constraintIndex === c2.constraintIndex;
+                }
+                return false;
+            });
+            if (foundTypeVarMatch && !exactMatch) {
+                return false;
+            }
+        }
+        return true;
+    }
+    TypeCondition.isCompatible = isCompatible;
+})(TypeCondition = exports.TypeCondition || (exports.TypeCondition = {}));
+var UnionType;
+(function (UnionType) {
+    function create() {
+        const newUnionType = {
+            category: 9 /* Union */,
+            subtypes: [],
+            flags: 2 /* Instance */ | 1 /* Instantiable */,
+        };
+        return newUnionType;
+    }
+    UnionType.create = create;
+    function addType(unionType, newType) {
+        // If we're adding a string literal or integer type, add it to the
+        // corresponding literal map to speed up some operations. It's not
+        // uncommon for unions to contain hundreds of literals.
+        if (isClassInstance(newType) && newType.literalValue !== undefined && newType.condition === undefined) {
+            if (ClassType.isBuiltIn(newType, 'str')) {
+                if (unionType.literalStrMap === undefined) {
+                    unionType.literalStrMap = new Map();
+                }
+                unionType.literalStrMap.set(newType.literalValue, newType);
+            }
+            else if (ClassType.isBuiltIn(newType, 'int')) {
+                if (unionType.literalIntMap === undefined) {
+                    unionType.literalIntMap = new Map();
+                }
+                unionType.literalIntMap.set(newType.literalValue, newType);
+            }
+        }
+        unionType.flags &= newType.flags;
+        unionType.subtypes.push(newType);
+    }
+    UnionType.addType = addType;
+    function containsType(unionType, subtype, recursionCount = 0) {
+        // Handle string literals as a special case because unions can sometimes
+        // contain hundreds of string literal types.
+        if (isClassInstance(subtype) && subtype.condition === undefined && subtype.literalValue !== undefined) {
+            if (ClassType.isBuiltIn(subtype, 'str') && unionType.literalStrMap !== undefined) {
+                return unionType.literalStrMap.has(subtype.literalValue);
+            }
+            else if (ClassType.isBuiltIn(subtype, 'int') && unionType.literalIntMap !== undefined) {
+                return unionType.literalIntMap.has(subtype.literalValue);
+            }
+        }
+        return (unionType.subtypes.find((t) => isTypeSame(t, subtype, 
+        /* ignorePseudoGeneric */ undefined, 
+        /* ignoreTypeFlags */ undefined, recursionCount)) !== undefined);
+    }
+    UnionType.containsType = containsType;
+    function addTypeAliasSource(unionType, typeAliasSource) {
+        if (typeAliasSource.category === 9 /* Union */) {
+            const sourcesToAdd = typeAliasSource.typeAliasInfo ? [typeAliasSource] : typeAliasSource.typeAliasSources;
+            if (sourcesToAdd) {
+                if (!unionType.typeAliasSources) {
+                    unionType.typeAliasSources = new Set();
+                }
+                sourcesToAdd.forEach((source) => {
+                    unionType.typeAliasSources.add(source);
+                });
+            }
+        }
+    }
+    UnionType.addTypeAliasSource = addTypeAliasSource;
+})(UnionType = exports.UnionType || (exports.UnionType = {}));
+var TypeVarType;
+(function (TypeVarType) {
+    function createInstance(name) {
+        return create(name, /* isParamSpec */ false, 2 /* Instance */);
+    }
+    TypeVarType.createInstance = createInstance;
+    function createInstantiable(name, isParamSpec = false) {
+        return create(name, isParamSpec, 1 /* Instantiable */);
+    }
+    TypeVarType.createInstantiable = createInstantiable;
+    function cloneAsInstance(type) {
+        (0, debug_1.assert)(TypeBase.isInstantiable(type));
+        const newInstance = TypeBase.cloneTypeAsInstance(type);
+        newInstance.flags &= ~8 /* SpecialForm */;
+        return newInstance;
+    }
+    TypeVarType.cloneAsInstance = cloneAsInstance;
+    function cloneAsInstantiable(type) {
+        const newInstance = TypeBase.cloneTypeAsInstantiable(type);
+        newInstance.flags &= ~8 /* SpecialForm */;
+        return newInstance;
+    }
+    TypeVarType.cloneAsInstantiable = cloneAsInstantiable;
+    function cloneForScopeId(type, scopeId, scopeName, scopeType) {
+        const newInstance = TypeBase.cloneType(type);
+        newInstance.nameWithScope = makeNameWithScope(type.details.name, scopeId);
+        newInstance.scopeId = scopeId;
+        newInstance.scopeName = scopeName;
+        newInstance.scopeType = scopeType;
+        return newInstance;
+    }
+    TypeVarType.cloneForScopeId = cloneForScopeId;
+    function cloneForUnpacked(type, isInUnion = false) {
+        (0, debug_1.assert)(type.details.isVariadic);
+        const newInstance = TypeBase.cloneType(type);
+        newInstance.isVariadicUnpacked = true;
+        newInstance.isVariadicInUnion = isInUnion;
+        return newInstance;
+    }
+    TypeVarType.cloneForUnpacked = cloneForUnpacked;
+    function cloneForPacked(type) {
+        (0, debug_1.assert)(type.details.isVariadic);
+        const newInstance = TypeBase.cloneType(type);
+        newInstance.isVariadicUnpacked = false;
+        newInstance.isVariadicInUnion = false;
+        return newInstance;
+    }
+    TypeVarType.cloneForPacked = cloneForPacked;
+    // Creates a "simplified" version of the TypeVar with invariance
+    // and no bound or constraints. ParamSpecs and variadics are left unmodified.
+    function cloneAsInvariant(type) {
+        if (type.details.isParamSpec || type.details.isVariadic) {
+            return type;
+        }
+        if (type.details.variance === 0 /* Invariant */) {
+            if (type.details.boundType === undefined && type.details.constraints.length === 0) {
+                return type;
+            }
+        }
+        const newInstance = TypeBase.cloneType(type);
+        newInstance.details = { ...newInstance.details };
+        newInstance.details.variance = 0 /* Invariant */;
+        newInstance.details.boundType = undefined;
+        newInstance.details.constraints = [];
+        return newInstance;
+    }
+    TypeVarType.cloneAsInvariant = cloneAsInvariant;
+    function cloneForParamSpecAccess(type, access) {
+        const newInstance = TypeBase.cloneType(type);
+        newInstance.paramSpecAccess = access;
+        return newInstance;
+    }
+    TypeVarType.cloneForParamSpecAccess = cloneForParamSpecAccess;
+    function cloneAsSpecializedSelf(type, specializedBoundType) {
+        (0, debug_1.assert)(type.details.isSynthesizedSelf);
+        const newInstance = TypeBase.cloneType(type);
+        newInstance.details = { ...newInstance.details };
+        newInstance.details.boundType = specializedBoundType;
+        return newInstance;
+    }
+    TypeVarType.cloneAsSpecializedSelf = cloneAsSpecializedSelf;
+    function makeNameWithScope(name, scopeId) {
+        return `${name}.${scopeId}`;
+    }
+    TypeVarType.makeNameWithScope = makeNameWithScope;
+    function create(name, isParamSpec, typeFlags) {
+        const newTypeVarType = {
+            category: 10 /* TypeVar */,
+            details: {
+                name,
+                constraints: [],
+                variance: 0 /* Invariant */,
+                isParamSpec,
+                isVariadic: false,
+                isSynthesized: false,
+            },
+            flags: typeFlags,
+        };
+        return newTypeVarType;
+    }
+    function addConstraint(typeVarType, constraintType) {
+        typeVarType.details.constraints.push(constraintType);
+    }
+    TypeVarType.addConstraint = addConstraint;
+    function getNameWithScope(typeVarType) {
+        // If there is no name with scope, fall back on the (unscoped) name.
+        return typeVarType.nameWithScope || typeVarType.details.name;
+    }
+    TypeVarType.getNameWithScope = getNameWithScope;
+    function getReadableName(typeVarType) {
+        if (typeVarType.scopeName) {
+            return `${typeVarType.details.name}@${typeVarType.scopeName}`;
+        }
+        return typeVarType.details.name;
+    }
+    TypeVarType.getReadableName = getReadableName;
+})(TypeVarType = exports.TypeVarType || (exports.TypeVarType = {}));
+function isNever(type) {
+    return type.category === 4 /* Never */;
+}
+exports.isNever = isNever;
+function isNoneInstance(type) {
+    return type.category === 3 /* None */ && TypeBase.isInstance(type);
+}
+exports.isNoneInstance = isNoneInstance;
+function isNoneTypeClass(type) {
+    return type.category === 3 /* None */ && TypeBase.isInstantiable(type);
+}
+exports.isNoneTypeClass = isNoneTypeClass;
+function isAny(type) {
+    return type.category === 2 /* Any */;
+}
+exports.isAny = isAny;
+function isUnknown(type) {
+    return type.category === 1 /* Unknown */;
+}
+exports.isUnknown = isUnknown;
+function isAnyOrUnknown(type) {
+    if (type.category === 2 /* Any */ || type.category === 1 /* Unknown */) {
+        return true;
+    }
+    if (isUnion(type)) {
+        return type.subtypes.find((subtype) => !isAnyOrUnknown(subtype)) === undefined;
+    }
+    return false;
+}
+exports.isAnyOrUnknown = isAnyOrUnknown;
+function isUnbound(type) {
+    return type.category === 0 /* Unbound */;
+}
+exports.isUnbound = isUnbound;
+function isUnion(type) {
+    return type.category === 9 /* Union */;
+}
+exports.isUnion = isUnion;
+function isPossiblyUnbound(type) {
+    if (isUnbound(type)) {
+        return true;
+    }
+    if (isUnion(type)) {
+        return type.subtypes.find((subtype) => isPossiblyUnbound(subtype)) !== undefined;
+    }
+    return false;
+}
+exports.isPossiblyUnbound = isPossiblyUnbound;
+function isClass(type) {
+    return type.category === 7 /* Class */;
+}
+exports.isClass = isClass;
+function isInstantiableClass(type) {
+    return type.category === 7 /* Class */ && TypeBase.isInstantiable(type);
+}
+exports.isInstantiableClass = isInstantiableClass;
+function isClassInstance(type) {
+    return type.category === 7 /* Class */ && TypeBase.isInstance(type);
+}
+exports.isClassInstance = isClassInstance;
+function isModule(type) {
+    return type.category === 8 /* Module */;
+}
+exports.isModule = isModule;
+function isTypeVar(type) {
+    return type.category === 10 /* TypeVar */;
+}
+exports.isTypeVar = isTypeVar;
+function isVariadicTypeVar(type) {
+    return type.category === 10 /* TypeVar */ && type.details.isVariadic;
+}
+exports.isVariadicTypeVar = isVariadicTypeVar;
+function isUnpackedVariadicTypeVar(type) {
+    if (isUnion(type) && type.subtypes.length === 1) {
+        type = type.subtypes[0];
+    }
+    return type.category === 10 /* TypeVar */ && type.details.isVariadic && !!type.isVariadicUnpacked;
+}
+exports.isUnpackedVariadicTypeVar = isUnpackedVariadicTypeVar;
+function isUnpackedClass(type) {
+    if (!isClass(type) || !type.isUnpacked) {
+        return false;
+    }
+    return true;
+}
+exports.isUnpackedClass = isUnpackedClass;
+function isUnpacked(type) {
+    return isUnpackedVariadicTypeVar(type) || isUnpackedClass(type);
+}
+exports.isUnpacked = isUnpacked;
+function isParamSpec(type) {
+    return type.category === 10 /* TypeVar */ && type.details.isParamSpec;
+}
+exports.isParamSpec = isParamSpec;
+function isFunction(type) {
+    return type.category === 5 /* Function */;
+}
+exports.isFunction = isFunction;
+function isOverloadedFunction(type) {
+    return type.category === 6 /* OverloadedFunction */;
+}
+exports.isOverloadedFunction = isOverloadedFunction;
+function getTypeAliasInfo(type) {
+    if (type.typeAliasInfo) {
+        return type.typeAliasInfo;
+    }
+    if (isTypeVar(type) &&
+        type.details.recursiveTypeAliasName &&
+        type.details.boundType &&
+        type.details.boundType.typeAliasInfo) {
+        return type.details.boundType.typeAliasInfo;
+    }
+    return undefined;
+}
+exports.getTypeAliasInfo = getTypeAliasInfo;
+// Determines whether two types are the same. If ignorePseudoGeneric is true,
+// type arguments for "pseudo-generic" classes (non-generic classes whose init
+// methods are not annotated and are therefore treated as generic) are ignored.
+function isTypeSame(type1, type2, ignorePseudoGeneric = false, ignoreTypeFlags = false, recursionCount = 0) {
+    var _a, _b;
+    if (type1 === type2) {
+        return true;
+    }
+    if (type1.category !== type2.category) {
+        return false;
+    }
+    if (!ignoreTypeFlags && type1.flags !== type2.flags) {
+        return false;
+    }
+    if (recursionCount > exports.maxTypeRecursionCount) {
+        return true;
+    }
+    recursionCount++;
+    switch (type1.category) {
+        case 7 /* Class */: {
+            const classType2 = type2;
+            // If the details are not the same it's not the same class.
+            if (!ClassType.isSameGenericClass(type1, classType2, recursionCount)) {
+                return false;
+            }
+            if (!TypeCondition.isSame(type1.condition, type2.condition)) {
+                return false;
+            }
+            if (!ignorePseudoGeneric || !ClassType.isPseudoGenericClass(type1)) {
+                // Make sure the type args match.
+                if (type1.tupleTypeArguments && classType2.tupleTypeArguments) {
+                    const type1TupleTypeArgs = type1.tupleTypeArguments || [];
+                    const type2TupleTypeArgs = classType2.tupleTypeArguments || [];
+                    if (type1TupleTypeArgs.length !== type2TupleTypeArgs.length) {
+                        return false;
+                    }
+                    for (let i = 0; i < type1TupleTypeArgs.length; i++) {
+                        if (!isTypeSame(type1TupleTypeArgs[i].type, type2TupleTypeArgs[i].type, ignorePseudoGeneric, 
+                        /* ignoreTypeFlags */ false, recursionCount)) {
+                            return false;
+                        }
+                        if (type1TupleTypeArgs[i].isUnbounded !== type2TupleTypeArgs[i].isUnbounded) {
+                            return false;
+                        }
+                    }
+                }
+                else {
+                    const type1TypeArgs = type1.typeArguments || [];
+                    const type2TypeArgs = classType2.typeArguments || [];
+                    const typeArgCount = Math.max(type1TypeArgs.length, type2TypeArgs.length);
+                    for (let i = 0; i < typeArgCount; i++) {
+                        // Assume that missing type args are "Any".
+                        const typeArg1 = i < type1TypeArgs.length ? type1TypeArgs[i] : AnyType.create();
+                        const typeArg2 = i < type2TypeArgs.length ? type2TypeArgs[i] : AnyType.create();
+                        if (!isTypeSame(typeArg1, typeArg2, ignorePseudoGeneric, 
+                        /* ignoreTypeFlags */ false, recursionCount)) {
+                            return false;
+                        }
+                    }
+                }
+            }
+            if (!ClassType.isLiteralValueSame(type1, classType2)) {
+                return false;
+            }
+            return true;
+        }
+        case 5 /* Function */: {
+            // Make sure the parameter counts match.
+            const functionType2 = type2;
+            const params1 = type1.details.parameters;
+            const params2 = functionType2.details.parameters;
+            if (params1.length !== params2.length) {
+                return false;
+            }
+            const positionalOnlyIndex1 = params1.findIndex((param) => param.category === 0 /* Simple */ && !param.name);
+            const positionalOnlyIndex2 = params2.findIndex((param) => param.category === 0 /* Simple */ && !param.name);
+            // Make sure the parameter details match.
+            for (let i = 0; i < params1.length; i++) {
+                const param1 = params1[i];
+                const param2 = params2[i];
+                if (param1.category !== param2.category) {
+                    return false;
+                }
+                const isName1Relevant = positionalOnlyIndex1 !== undefined && i >= positionalOnlyIndex1;
+                const isName2Relevant = positionalOnlyIndex2 !== undefined && i >= positionalOnlyIndex2;
+                if (isName1Relevant !== isName2Relevant) {
+                    return false;
+                }
+                if (isName1Relevant) {
+                    if (param1.name !== param2.name) {
+                        return false;
+                    }
+                }
+                const param1Type = FunctionType.getEffectiveParameterType(type1, i);
+                const param2Type = FunctionType.getEffectiveParameterType(functionType2, i);
+                if (!isTypeSame(param1Type, param2Type, ignorePseudoGeneric, 
+                /* ignoreTypeFlags */ false, recursionCount)) {
+                    return false;
+                }
+            }
+            // Make sure the return types match.
+            let return1Type = type1.details.declaredReturnType;
+            if (type1.specializedTypes && type1.specializedTypes.returnType) {
+                return1Type = type1.specializedTypes.returnType;
+            }
+            if (!return1Type && type1.inferredReturnType) {
+                return1Type = type1.inferredReturnType;
+            }
+            let return2Type = functionType2.details.declaredReturnType;
+            if (functionType2.specializedTypes && functionType2.specializedTypes.returnType) {
+                return2Type = functionType2.specializedTypes.returnType;
+            }
+            if (!return2Type && functionType2.inferredReturnType) {
+                return2Type = functionType2.inferredReturnType;
+            }
+            if (return1Type || return2Type) {
+                if (!return1Type ||
+                    !return2Type ||
+                    !isTypeSame(return1Type, return2Type, ignorePseudoGeneric, 
+                    /* ignoreTypeFlags */ false, recursionCount)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        case 6 /* OverloadedFunction */: {
+            // Make sure the overload counts match.
+            const functionType2 = type2;
+            if (type1.overloads.length !== functionType2.overloads.length) {
+                return false;
+            }
+            // We assume here that overloaded functions always appear
+            // in the same order from one analysis pass to another.
+            for (let i = 0; i < type1.overloads.length; i++) {
+                if (!isTypeSame(type1.overloads[i], functionType2.overloads[i], ignorePseudoGeneric, ignoreTypeFlags, recursionCount)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        case 9 /* Union */: {
+            const unionType2 = type2;
+            const subtypes1 = type1.subtypes;
+            const subtypes2 = unionType2.subtypes;
+            if (subtypes1.length !== subtypes2.length) {
+                return false;
+            }
+            // The types do not have a particular order, so we need to
+            // do the comparison in an order-independent manner.
+            return (findSubtype(type1, (subtype) => !UnionType.containsType(unionType2, subtype, recursionCount)) ===
+                undefined);
+        }
+        case 10 /* TypeVar */: {
+            const type2TypeVar = type2;
+            if (type1.scopeId !== type2TypeVar.scopeId) {
+                return false;
+            }
+            // Handle the case where this is a generic recursive type alias. Make
+            // sure that the type argument types match.
+            if (type1.details.recursiveTypeParameters && type2TypeVar.details.recursiveTypeParameters) {
+                const type1TypeArgs = ((_a = type1 === null || type1 === void 0 ? void 0 : type1.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.typeArguments) || [];
+                const type2TypeArgs = ((_b = type2 === null || type2 === void 0 ? void 0 : type2.typeAliasInfo) === null || _b === void 0 ? void 0 : _b.typeArguments) || [];
+                const typeArgCount = Math.max(type1TypeArgs.length, type2TypeArgs.length);
+                for (let i = 0; i < typeArgCount; i++) {
+                    // Assume that missing type args are "Any".
+                    const typeArg1 = i < type1TypeArgs.length ? type1TypeArgs[i] : AnyType.create();
+                    const typeArg2 = i < type2TypeArgs.length ? type2TypeArgs[i] : AnyType.create();
+                    if (!isTypeSame(typeArg1, typeArg2, ignorePseudoGeneric, 
+                    /* ignoreTypeFlags */ false, recursionCount)) {
+                        return false;
+                    }
+                }
+            }
+            if (type1.details === type2TypeVar.details) {
+                return true;
+            }
+            if (type1.details.name !== type2TypeVar.details.name ||
+                type1.details.isParamSpec !== type2TypeVar.details.isParamSpec ||
+                type1.details.isVariadic !== type2TypeVar.details.isVariadic ||
+                type1.details.isSynthesized !== type2TypeVar.details.isSynthesized ||
+                type1.details.variance !== type2TypeVar.details.variance ||
+                type1.scopeId !== type2TypeVar.scopeId) {
+                return false;
+            }
+            const boundType1 = type1.details.boundType;
+            const boundType2 = type2TypeVar.details.boundType;
+            if (boundType1) {
+                if (!boundType2 ||
+                    !isTypeSame(boundType1, boundType2, ignorePseudoGeneric, 
+                    /* ignoreTypeFlags */ false, recursionCount)) {
+                    return false;
+                }
+            }
+            else {
+                if (boundType2) {
+                    return false;
+                }
+            }
+            const constraints1 = type1.details.constraints;
+            const constraints2 = type2TypeVar.details.constraints;
+            if (constraints1.length !== constraints2.length) {
+                return false;
+            }
+            for (let i = 0; i < constraints1.length; i++) {
+                if (!isTypeSame(constraints1[i], constraints2[i], ignorePseudoGeneric, 
+                /* ignoreTypeFlags */ false, recursionCount)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        case 8 /* Module */: {
+            const type2Module = type2;
+            // Module types are the same if they share the same
+            // module symbol table.
+            if (type1.fields === type2Module.fields) {
+                return true;
+            }
+            // If both symbol tables are empty, we can also assume
+            // they're equal.
+            if (type1.fields.size === 0 && type2Module.fields.size === 0) {
+                return true;
+            }
+            return false;
+        }
+    }
+    return true;
+}
+exports.isTypeSame = isTypeSame;
+// If the type is a union, remove an "unknown" type from the union,
+// returning only the known types.
+function removeUnknownFromUnion(type) {
+    return removeFromUnion(type, (t) => isUnknown(t));
+}
+exports.removeUnknownFromUnion = removeUnknownFromUnion;
+function removeIncompleteUnknownFromUnion(type) {
+    return removeFromUnion(type, (t) => isUnknown(t) && t.isIncomplete);
+}
+exports.removeIncompleteUnknownFromUnion = removeIncompleteUnknownFromUnion;
+// If the type is a union, remove an "unbound" type from the union,
+// returning only the known types.
+function removeUnbound(type) {
+    if (isUnion(type)) {
+        return removeFromUnion(type, (t) => isUnbound(t));
+    }
+    if (isUnbound(type)) {
+        return UnknownType.create();
+    }
+    return type;
+}
+exports.removeUnbound = removeUnbound;
+// If the type is a union, remove an "None" type from the union,
+// returning only the known types.
+function removeNoneFromUnion(type) {
+    return removeFromUnion(type, (t) => isNoneInstance(t));
+}
+exports.removeNoneFromUnion = removeNoneFromUnion;
+function removeFromUnion(type, removeFilter) {
+    if (isUnion(type)) {
+        const remainingTypes = type.subtypes.filter((t) => !removeFilter(t));
+        if (remainingTypes.length < type.subtypes.length) {
+            const newType = combineTypes(remainingTypes);
+            if (isUnion(newType)) {
+                UnionType.addTypeAliasSource(newType, type);
+            }
+            return newType;
+        }
+    }
+    return type;
+}
+exports.removeFromUnion = removeFromUnion;
+function findSubtype(type, filter) {
+    if (isUnion(type)) {
+        return type.subtypes.find((subtype) => {
+            return filter(subtype);
+        });
+    }
+    return filter(type) ? type : undefined;
+}
+exports.findSubtype = findSubtype;
+// Combines multiple types into a single type. If the types are
+// the same, only one is returned. If they differ, they
+// are combined into a UnionType. NeverTypes are filtered out.
+// If no types remain in the end, a NeverType is returned.
+function combineTypes(subtypes, maxSubtypeCount) {
+    // Filter out any "Never" and "NoReturn" types.
+    let sawNoReturn = false;
+    if (subtypes.some((subtype) => subtype.category === 4 /* Never */))
+        subtypes = subtypes.filter((subtype) => {
+            if (subtype.category === 4 /* Never */ && subtype.isNoReturn) {
+                sawNoReturn = true;
+            }
+            return subtype.category !== 4 /* Never */;
+        });
+    if (subtypes.length === 0) {
+        return sawNoReturn ? NeverType.createNoReturn() : NeverType.createNever();
+    }
+    // Handle the common case where there is only one type.
+    // Also handle the common case where there are multiple copies of the same type.
+    let allSubtypesAreSame = true;
+    if (subtypes.length > 1) {
+        for (let index = 1; index < subtypes.length; index++) {
+            if (subtypes[index] !== subtypes[0]) {
+                allSubtypesAreSame = false;
+                break;
+            }
+        }
+    }
+    if (allSubtypesAreSame) {
+        return subtypes[0];
+    }
+    // Expand all union types.
+    let expandedTypes = [];
+    const typeAliasSources = new Set();
+    for (const subtype of subtypes) {
+        if (isUnion(subtype)) {
+            expandedTypes = expandedTypes.concat(subtype.subtypes);
+            if (subtype.typeAliasInfo) {
+                typeAliasSources.add(subtype);
+            }
+            else if (subtype.typeAliasSources) {
+                subtype.typeAliasSources.forEach((subtype) => {
+                    typeAliasSources.add(subtype);
+                });
+            }
+        }
+        else {
+            expandedTypes.push(subtype);
+        }
+    }
+    // Sort all of the literal and empty types to the end.
+    expandedTypes = expandedTypes.sort((type1, type2) => {
+        if ((isClassInstance(type1) && type1.literalValue !== undefined) ||
+            (isInstantiableClass(type1) && type1.literalValue !== undefined)) {
+            return 1;
+        }
+        else if ((isClassInstance(type2) && type2.literalValue !== undefined) ||
+            (isInstantiableClass(type2) && type2.literalValue !== undefined)) {
+            return -1;
+        }
+        if (isClassInstance(type1) && type1.isEmptyContainer) {
+            return 1;
+        }
+        else if (isClassInstance(type2) && type2.isEmptyContainer) {
+            return -1;
+        }
+        return 0;
+    });
+    // If removing all NoReturn types results in no remaining types,
+    // convert it to an unknown.
+    if (expandedTypes.length === 0) {
+        return UnknownType.create();
+    }
+    const newUnionType = UnionType.create();
+    if (typeAliasSources.size > 0) {
+        newUnionType.typeAliasSources = typeAliasSources;
+    }
+    let hitMaxSubtypeCount = false;
+    expandedTypes.forEach((subtype, index) => {
+        if (index === 0) {
+            UnionType.addType(newUnionType, subtype);
+        }
+        else {
+            if (maxSubtypeCount === undefined || newUnionType.subtypes.length < maxSubtypeCount) {
+                _addTypeIfUnique(newUnionType, subtype);
+            }
+            else {
+                hitMaxSubtypeCount = true;
+            }
+        }
+    });
+    if (hitMaxSubtypeCount) {
+        return AnyType.create();
+    }
+    // If only one type remains, convert it from a union to a simple type.
+    if (newUnionType.subtypes.length === 1) {
+        return newUnionType.subtypes[0];
+    }
+    return newUnionType;
+}
+exports.combineTypes = combineTypes;
+// Determines whether the dest type is the same as the source type with
+// the possible exception that the source type has a literal value when
+// the dest does not.
+function isSameWithoutLiteralValue(destType, srcType) {
+    // If it's the same with literals, great.
+    if (isTypeSame(destType, srcType)) {
+        return true;
+    }
+    if (isInstantiableClass(srcType) && srcType.literalValue !== undefined) {
+        // Strip the literal.
+        srcType = ClassType.cloneWithLiteral(srcType, /* value */ undefined);
+        return isTypeSame(destType, srcType);
+    }
+    if (isClassInstance(srcType) && srcType.literalValue !== undefined) {
+        // Strip the literal.
+        srcType = ClassType.cloneWithLiteral(srcType, /* value */ undefined);
+        return isTypeSame(destType, srcType);
+    }
+    return false;
+}
+exports.isSameWithoutLiteralValue = isSameWithoutLiteralValue;
+function _addTypeIfUnique(unionType, typeToAdd) {
+    // Handle the addition of a string literal in a special manner to
+    // avoid n^2 behavior in unions that contain hundreds of string
+    // literal types. Skip this for constrained types.
+    if (isClassInstance(typeToAdd) && typeToAdd.condition === undefined) {
+        if (ClassType.isBuiltIn(typeToAdd, 'str') &&
+            typeToAdd.literalValue !== undefined &&
+            unionType.literalStrMap !== undefined) {
+            if (!unionType.literalStrMap.has(typeToAdd.literalValue)) {
+                UnionType.addType(unionType, typeToAdd);
+            }
+            return;
+        }
+        else if (ClassType.isBuiltIn(typeToAdd, 'int') &&
+            typeToAdd.literalValue !== undefined &&
+            unionType.literalIntMap !== undefined) {
+            if (!unionType.literalIntMap.has(typeToAdd.literalValue)) {
+                UnionType.addType(unionType, typeToAdd);
+            }
+            return;
+        }
+    }
+    for (let i = 0; i < unionType.subtypes.length; i++) {
+        const type = unionType.subtypes[i];
+        // Does this type already exist in the types array?
+        if (isTypeSame(type, typeToAdd)) {
+            return;
+        }
+        // If the typeToAdd is a literal value and there's already
+        // a non-literal type that matches, don't add the literal value.
+        if (isClassInstance(type) && isClassInstance(typeToAdd)) {
+            if (isSameWithoutLiteralValue(type, typeToAdd)) {
+                if (type.literalValue === undefined) {
+                    return;
+                }
+            }
+            // If we're adding Literal[False] or Literal[True] to its
+            // opposite, combine them into a non-literal 'bool' type.
+            if (ClassType.isBuiltIn(type, 'bool') &&
+                !type.condition &&
+                ClassType.isBuiltIn(typeToAdd, 'bool') &&
+                !typeToAdd.condition) {
+                if (typeToAdd.literalValue !== undefined && !typeToAdd.literalValue === type.literalValue) {
+                    unionType.subtypes[i] = ClassType.cloneWithLiteral(type, /* value */ undefined);
+                    return;
+                }
+            }
+        }
+        // If the typeToAdd is an empty container and there's already
+        // non-empty container of the same type, don't add the empty container.
+        if (isClassInstance(typeToAdd) && typeToAdd.isEmptyContainer) {
+            if (isClassInstance(type) && ClassType.isSameGenericClass(type, typeToAdd)) {
+                return;
+            }
+        }
+    }
+    UnionType.addType(unionType, typeToAdd);
+}
+//# sourceMappingURL=types.js.map