@zzzen/pyright-internal 1.2.0-dev.20240804 → 1.2.0-dev.20240818

package/dist/analyzer/typeUtils.js

@@ -8,9 +8,107 @@
  * Functions that operate on Type objects.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isTupleClass = exports.isTupleGradualForm = exports.isMaybeDescriptorInstance = exports.isDescriptorInstance = exports.isCallableType = exports.isProperty = exports.isEllipsisType = exports.getUnionSubtypeCount = exports.getLiteralTypeClassName = exports.containsLiteralType = exports.isLiteralTypeOrUnion = exports.isLiteralType = exports.getSpecializedTupleType = exports.selfSpecializeClass = exports.getUnknownTypeForCallable = exports.getUnknownForTypeVarTuple = exports.getUnknownForTypeVar = exports.specializeWithUnknownTypeArgs = exports.specializeWithDefaultTypeArgs = exports.getTypeVarScopeIds = exports.getTypeVarScopeId = exports.transformPossibleRecursiveTypeAlias = exports.isTypeAliasRecursive = exports.isTypeAliasPlaceholder = exports.getTypeCondition = exports.addConditionToType = exports.getFullNameOfType = exports.derivesFromAnyOrUnknown = exports.isUnionableType = exports.preserveUnknown = exports.areTypesSame = exports.doForEachSignature = exports.allSubtypes = exports.someSubtypes = exports.doForEachSubtype = exports.sortTypes = exports.cleanIncompleteUnknown = exports.mapSignatures = exports.mapSubtypes = exports.makeInferenceContext = exports.isTypeVarSame = exports.isIncompleteUnknown = exports.removeNoneFromUnion = exports.isNoneTypeClass = exports.isNoneInstance = exports.isOptionalType = exports.UniqueSignatureTracker = exports.AssignTypeFlags = exports.ClassIteratorFlags = exports.MemberAccessFlags = void 0;
-exports.combineVariances = exports.requiresSpecialization = exports.requiresTypeArgs = exports.getGeneratorTypeArgs = exports.specializeTupleClass = exports.combineTupleTypeArgs = exports.combineSameSizedTuples = exports.explodeGenericClass = exports.isPartlyUnknown = exports.containsAnyOrUnknown = exports.containsAnyRecursive = exports.getMembersForModule = exports.getMembersForClass = exports.convertToInstantiable = exports.convertToInstance = exports.isEffectivelyInstantiable = exports.isMetaclassInstance = exports.isInstantiableMetaclass = exports.getGeneratorYieldType = exports.getDeclaredGeneratorReturnType = exports.synthesizeTypeVarForSelfCls = exports.derivesFromClassRecursive = exports.derivesFromStdlibClass = exports.specializeForBaseClass = exports.buildSolution = exports.buildSolutionFromSpecializedClass = exports.setTypeArgsRecursive = exports.specializeClassType = exports.getTypeVarArgsRecursive = exports.addTypeVarsToListIfUnique = exports.getClassFieldsRecursive = exports.getClassIterator = exports.getClassMemberIterator = exports.lookUpClassMember = exports.lookUpObjectMember = exports.getContainerDepth = exports.getProtocolSymbolsRecursive = exports.getProtocolSymbols = exports.transformExpectedType = exports.validateTypeVarDefault = exports.applySourceContextTypeVarsToSignature = exports.applySourceContextTypeVars = exports.applySolvedTypeVars = exports.makeTypeVarsFree = exports.makeTypeVarsBound = exports.ensureSignaturesAreUnique = exports.addSolutionForSelfType = exports.partiallySpecializeType = exports.isTupleIndexUnambiguous = exports.isUnboundedTupleClass = void 0;
-exports.TypeVarTransformer = exports.simplifyFunctionToParamSpec = exports.convertTypeToParamSpecValue = exports.convertNodeToArg = exports.getDeclaringModulesForType = exports.computeMroLinearization = exports.isVarianceOfTypeArgCompatible = void 0;
+exports.TypeVarTransformer = exports.UniqueSignatureTracker = exports.AssignTypeFlags = exports.ClassIteratorFlags = exports.MemberAccessFlags = void 0;
+exports.isOptionalType = isOptionalType;
+exports.isNoneInstance = isNoneInstance;
+exports.isNoneTypeClass = isNoneTypeClass;
+exports.removeNoneFromUnion = removeNoneFromUnion;
+exports.isIncompleteUnknown = isIncompleteUnknown;
+exports.isTypeVarSame = isTypeVarSame;
+exports.makeInferenceContext = makeInferenceContext;
+exports.mapSubtypes = mapSubtypes;
+exports.mapSignatures = mapSignatures;
+exports.cleanIncompleteUnknown = cleanIncompleteUnknown;
+exports.sortTypes = sortTypes;
+exports.doForEachSubtype = doForEachSubtype;
+exports.someSubtypes = someSubtypes;
+exports.allSubtypes = allSubtypes;
+exports.doForEachSignature = doForEachSignature;
+exports.areTypesSame = areTypesSame;
+exports.preserveUnknown = preserveUnknown;
+exports.isUnionableType = isUnionableType;
+exports.derivesFromAnyOrUnknown = derivesFromAnyOrUnknown;
+exports.getFullNameOfType = getFullNameOfType;
+exports.addConditionToType = addConditionToType;
+exports.getTypeCondition = getTypeCondition;
+exports.isTypeAliasPlaceholder = isTypeAliasPlaceholder;
+exports.isTypeAliasRecursive = isTypeAliasRecursive;
+exports.transformPossibleRecursiveTypeAlias = transformPossibleRecursiveTypeAlias;
+exports.getTypeVarScopeId = getTypeVarScopeId;
+exports.getTypeVarScopeIds = getTypeVarScopeIds;
+exports.specializeWithDefaultTypeArgs = specializeWithDefaultTypeArgs;
+exports.specializeWithUnknownTypeArgs = specializeWithUnknownTypeArgs;
+exports.getUnknownForTypeVar = getUnknownForTypeVar;
+exports.getUnknownForTypeVarTuple = getUnknownForTypeVarTuple;
+exports.getUnknownTypeForCallable = getUnknownTypeForCallable;
+exports.selfSpecializeClass = selfSpecializeClass;
+exports.getSpecializedTupleType = getSpecializedTupleType;
+exports.isLiteralType = isLiteralType;
+exports.isLiteralTypeOrUnion = isLiteralTypeOrUnion;
+exports.containsLiteralType = containsLiteralType;
+exports.getLiteralTypeClassName = getLiteralTypeClassName;
+exports.getUnionSubtypeCount = getUnionSubtypeCount;
+exports.isEllipsisType = isEllipsisType;
+exports.isProperty = isProperty;
+exports.isCallableType = isCallableType;
+exports.isDescriptorInstance = isDescriptorInstance;
+exports.isMaybeDescriptorInstance = isMaybeDescriptorInstance;
+exports.isTupleGradualForm = isTupleGradualForm;
+exports.isTupleClass = isTupleClass;
+exports.isUnboundedTupleClass = isUnboundedTupleClass;
+exports.isTupleIndexUnambiguous = isTupleIndexUnambiguous;
+exports.partiallySpecializeType = partiallySpecializeType;
+exports.addSolutionForSelfType = addSolutionForSelfType;
+exports.ensureSignaturesAreUnique = ensureSignaturesAreUnique;
+exports.makeFunctionTypeVarsBound = makeFunctionTypeVarsBound;
+exports.makeTypeVarsBound = makeTypeVarsBound;
+exports.makeTypeVarsFree = makeTypeVarsFree;
+exports.applySolvedTypeVars = applySolvedTypeVars;
+exports.validateTypeVarDefault = validateTypeVarDefault;
+exports.transformExpectedType = transformExpectedType;
+exports.getProtocolSymbols = getProtocolSymbols;
+exports.getProtocolSymbolsRecursive = getProtocolSymbolsRecursive;
+exports.getContainerDepth = getContainerDepth;
+exports.lookUpObjectMember = lookUpObjectMember;
+exports.lookUpClassMember = lookUpClassMember;
+exports.getClassMemberIterator = getClassMemberIterator;
+exports.getClassIterator = getClassIterator;
+exports.getClassFieldsRecursive = getClassFieldsRecursive;
+exports.addTypeVarsToListIfUnique = addTypeVarsToListIfUnique;
+exports.getTypeVarArgsRecursive = getTypeVarArgsRecursive;
+exports.specializeClassType = specializeClassType;
+exports.buildSolutionFromSpecializedClass = buildSolutionFromSpecializedClass;
+exports.buildSolution = buildSolution;
+exports.specializeForBaseClass = specializeForBaseClass;
+exports.derivesFromStdlibClass = derivesFromStdlibClass;
+exports.derivesFromClassRecursive = derivesFromClassRecursive;
+exports.synthesizeTypeVarForSelfCls = synthesizeTypeVarForSelfCls;
+exports.getDeclaredGeneratorReturnType = getDeclaredGeneratorReturnType;
+exports.getGeneratorYieldType = getGeneratorYieldType;
+exports.isInstantiableMetaclass = isInstantiableMetaclass;
+exports.isMetaclassInstance = isMetaclassInstance;
+exports.isEffectivelyInstantiable = isEffectivelyInstantiable;
+exports.convertToInstance = convertToInstance;
+exports.convertToInstantiable = convertToInstantiable;
+exports.getMembersForClass = getMembersForClass;
+exports.getMembersForModule = getMembersForModule;
+exports.containsAnyRecursive = containsAnyRecursive;
+exports.containsAnyOrUnknown = containsAnyOrUnknown;
+exports.isPartlyUnknown = isPartlyUnknown;
+exports.explodeGenericClass = explodeGenericClass;
+exports.combineSameSizedTuples = combineSameSizedTuples;
+exports.combineTupleTypeArgs = combineTupleTypeArgs;
+exports.specializeTupleClass = specializeTupleClass;
+exports.getGeneratorTypeArgs = getGeneratorTypeArgs;
+exports.requiresTypeArgs = requiresTypeArgs;
+exports.requiresSpecialization = requiresSpecialization;
+exports.combineVariances = combineVariances;
+exports.isVarianceOfTypeArgCompatible = isVarianceOfTypeArgCompatible;
+exports.computeMroLinearization = computeMroLinearization;
+exports.getDeclaringModulesForType = getDeclaringModulesForType;
+exports.convertNodeToArg = convertNodeToArg;
+exports.convertTypeToParamSpecValue = convertTypeToParamSpecValue;
+exports.simplifyFunctionToParamSpec = simplifyFunctionToParamSpec;
 const collectionUtils_1 = require("../common/collectionUtils");
 const debug_1 = require("../common/debug");
 const constraintSolution_1 = require("./constraintSolution");
@@ -79,11 +177,11 @@ var AssignTypeFlags;
     AssignTypeFlags[AssignTypeFlags["Default"] = 0] = "Default";
     // Require invariance with respect to class matching? Normally
     // subclasses are allowed.
-    AssignTypeFlags[AssignTypeFlags["EnforceInvariance"] = 1] = "EnforceInvariance";
+    AssignTypeFlags[AssignTypeFlags["Invariant"] = 1] = "Invariant";
     // The caller has swapped the source and dest types because
     // the types are contravariant. Perform type var matching
     // on dest type vars rather than source type var.
-    AssignTypeFlags[AssignTypeFlags["ReverseTypeVarMatching"] = 2] = "ReverseTypeVarMatching";
+    AssignTypeFlags[AssignTypeFlags["Contravariant"] = 2] = "Contravariant";
     // We're comparing type compatibility of two distinct recursive types.
     // This has the potential of recursing infinitely. This flag allows us
     // to detect the recursion after the first level of checking.
@@ -113,8 +211,9 @@ var AssignTypeFlags;
     AssignTypeFlags[AssignTypeFlags["SkipSelfClsTypeCheck"] = 512] = "SkipSelfClsTypeCheck";
     // We're initially populating the constraints with an expected type,
     // so TypeVars should match the specified type exactly rather than
-    // employing narrowing or widening, and don't strip literals.
-    AssignTypeFlags[AssignTypeFlags["PopulatingExpectedType"] = 2048] = "PopulatingExpectedType";
+    // employing narrowing or widening. The variance context determines
+    // whether the upper bound, lower bound, or both are established.
+    AssignTypeFlags[AssignTypeFlags["PopulateExpectedType"] = 2048] = "PopulateExpectedType";
     // Used with PopulatingExpectedType, this flag indicates that a TypeVar
     // constraint that is Unknown should be ignored.
     AssignTypeFlags[AssignTypeFlags["SkipPopulateUnknownExpectedType"] = 4096] = "SkipPopulateUnknownExpectedType";
@@ -183,25 +282,20 @@ function isOptionalType(type) {
     }
     return false;
 }
-exports.isOptionalType = isOptionalType;
 function isNoneInstance(type) {
     return (0, types_1.isClassInstance)(type) && types_1.ClassType.isBuiltIn(type, 'NoneType');
 }
-exports.isNoneInstance = isNoneInstance;
 function isNoneTypeClass(type) {
     return (0, types_1.isInstantiableClass)(type) && types_1.ClassType.isBuiltIn(type, 'NoneType');
 }
-exports.isNoneTypeClass = isNoneTypeClass;
 // If the type is a union, remove an "None" type from the union,
 // returning only the known types.
 function removeNoneFromUnion(type) {
     return (0, types_1.removeFromUnion)(type, (t) => isNoneInstance(t));
 }
-exports.removeNoneFromUnion = removeNoneFromUnion;
 function isIncompleteUnknown(type) {
     return (0, types_1.isUnknown)(type) && type.priv.isIncomplete;
 }
-exports.isIncompleteUnknown = isIncompleteUnknown;
 // Similar to isTypeSame except that type1 is a TypeVar and type2
 // can be either a TypeVar of the same type or a union that includes
 // conditional types associated with that bound TypeVar.
@@ -232,14 +326,12 @@ function isTypeVarSame(type1, type2) {
     });
     return isCompatible;
 }
-exports.isTypeVarSame = isTypeVarSame;
 function makeInferenceContext(expectedType, isTypeIncomplete, returnTypeOverride) {
     if (!expectedType) {
         return undefined;
     }
     return { expectedType, isTypeIncomplete, returnTypeOverride };
 }
-exports.makeInferenceContext = makeInferenceContext;
 // Calls a callback for each subtype and combines the results
 // into a final type. It performs no memory allocations if the
 // transformed type is the same as the original.
@@ -288,7 +380,6 @@ function mapSubtypes(type, callback, options) {
     }
     return transformedSubtype;
 }
-exports.mapSubtypes = mapSubtypes;
 // Iterates over each signature in a function or overload, allowing the
 // caller to replace one or more signatures with new ones.
 function mapSignatures(type, callback) {
@@ -297,7 +388,7 @@ function mapSignatures(type, callback) {
     }
     const newSignatures = [];
     let changeMade = false;
-    types_1.OverloadedFunctionType.getOverloads(type).forEach((overload, index) => {
+    types_1.OverloadedType.getOverloads(type).forEach((overload, index) => {
         const newOverload = callback(overload);
         if (newOverload !== overload) {
             changeMade = true;
@@ -310,12 +401,12 @@ function mapSignatures(type, callback) {
         return undefined;
     }
     // Add the unmodified implementation if it's present.
-    const implementation = types_1.OverloadedFunctionType.getImplementation(type);
-    if (implementation) {
-        const newImplementation = callback(implementation);
+    const implementation = types_1.OverloadedType.getImplementation(type);
+    let newImplementation = implementation;
+    if (implementation && (0, types_1.isFunction)(implementation)) {
+        newImplementation = callback(implementation);
         if (newImplementation) {
             changeMade = true;
-            newSignatures.push(newImplementation);
         }
     }
     if (!changeMade) {
@@ -324,9 +415,8 @@ function mapSignatures(type, callback) {
     if (newSignatures.length === 1) {
         return newSignatures[0];
     }
-    return types_1.OverloadedFunctionType.create(newSignatures);
+    return types_1.OverloadedType.create(newSignatures, newImplementation);
 }
-exports.mapSignatures = mapSignatures;
 // The code flow engine uses a special form of the UnknownType (with the
 // isIncomplete flag set) to distinguish between an unknown that was generated
 // in a loop because it was temporarily incomplete versus an unknown that is
@@ -380,14 +470,12 @@ function cleanIncompleteUnknown(type, recursionCount = 0) {
     // If we eliminated everything, don't return a Never.
     return (0, types_1.isNever)(result) ? type : result;
 }
-exports.cleanIncompleteUnknown = cleanIncompleteUnknown;
 // Sorts types into a deterministic order.
 function sortTypes(types) {
     return types.slice(0).sort((a, b) => {
         return compareTypes(a, b);
     });
 }
-exports.sortTypes = sortTypes;
 function compareTypes(a, b, recursionCount = 0) {
     var _a, _b;
     if (recursionCount > types_1.maxTypeRecursionCount) {
@@ -437,15 +525,17 @@ function compareTypes(a, b, recursionCount = 0) {
             }
             return 0;
         }
-        case 5 /* TypeCategory.OverloadedFunction */: {
+        case 5 /* TypeCategory.Overloaded */: {
             const bOver = b;
-            const aOverloadCount = a.priv.overloads.length;
-            const bOverloadCount = bOver.priv.overloads.length;
+            const aOverloads = types_1.OverloadedType.getOverloads(a);
+            const bOverloads = types_1.OverloadedType.getOverloads(bOver);
+            const aOverloadCount = aOverloads.length;
+            const bOverloadCount = bOverloads.length;
             if (aOverloadCount !== bOverloadCount) {
                 return bOverloadCount - aOverloadCount;
             }
             for (let i = 0; i < aOverloadCount; i++) {
-                const typeComparison = compareTypes(a.priv.overloads[i], bOver.priv.overloads[i]);
+                const typeComparison = compareTypes(aOverloads[i], bOverloads[i]);
                 if (typeComparison !== 0) {
                     return typeComparison;
                 }
@@ -537,7 +627,6 @@ function doForEachSubtype(type, callback, sortSubtypes = false) {
         callback(type, 0, [type]);
     }
 }
-exports.doForEachSubtype = doForEachSubtype;
 function someSubtypes(type, callback) {
     if ((0, types_1.isUnion)(type)) {
         return type.priv.subtypes.some((subtype) => {
@@ -548,7 +637,6 @@ function someSubtypes(type, callback) {
         return callback(type);
     }
 }
-exports.someSubtypes = someSubtypes;
 function allSubtypes(type, callback) {
     if ((0, types_1.isUnion)(type)) {
         return type.priv.subtypes.every((subtype) => {
@@ -559,18 +647,16 @@ function allSubtypes(type, callback) {
         return callback(type);
     }
 }
-exports.allSubtypes = allSubtypes;
 function doForEachSignature(type, callback) {
     if ((0, types_1.isFunction)(type)) {
         callback(type, 0);
     }
     else {
-        types_1.OverloadedFunctionType.getOverloads(type).forEach((overload, index) => {
+        types_1.OverloadedType.getOverloads(type).forEach((overload, index) => {
             callback(overload, index);
         });
     }
 }
-exports.doForEachSignature = doForEachSignature;
 // Determines if all of the types in the array are the same.
 function areTypesSame(types, options) {
     if (types.length < 2) {
@@ -583,7 +669,6 @@ function areTypesSame(types, options) {
     }
     return true;
 }
-exports.areTypesSame = areTypesSame;
 // If either type is "Unknown" (versus Any), propagate the Unknown. Preserve
 // the incomplete flag on the unknown if present. The caller should verify that
 // one or the other type is Unknown or Any.
@@ -601,7 +686,6 @@ function preserveUnknown(type1, type2) {
         return types_1.AnyType.create();
     }
 }
-exports.preserveUnknown = preserveUnknown;
 // Determines whether the specified type is a type that can be
 // combined with other types for a union.
 function isUnionableType(subtypes) {
@@ -615,7 +699,6 @@ function isUnionableType(subtypes) {
     // be definitively instantiable (not an instance).
     return (typeFlags & 1 /* TypeFlags.Instantiable */) !== 0 && (typeFlags & 2 /* TypeFlags.Instance */) === 0;
 }
-exports.isUnionableType = isUnionableType;
 function derivesFromAnyOrUnknown(type) {
     let anyOrUnknown = false;
     doForEachSubtype(type, (subtype) => {
@@ -635,7 +718,6 @@ function derivesFromAnyOrUnknown(type) {
     });
     return anyOrUnknown;
 }
-exports.derivesFromAnyOrUnknown = derivesFromAnyOrUnknown;
 function getFullNameOfType(type) {
     var _a, _b;
     if ((_b = (_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo) === null || _b === void 0 ? void 0 : _b.fullName) {
@@ -651,12 +733,19 @@ function getFullNameOfType(type) {
             return type.shared.fullName;
         case 7 /* TypeCategory.Module */:
             return type.priv.moduleName;
-        case 5 /* TypeCategory.OverloadedFunction */:
-            return type.priv.overloads[0].shared.fullName;
+        case 5 /* TypeCategory.Overloaded */: {
+            const overloads = types_1.OverloadedType.getOverloads(type);
+            if (overloads.length > 0) {
+                return overloads[0].shared.fullName;
+            }
+            const impl = types_1.OverloadedType.getImplementation(type);
+            if (impl && (0, types_1.isFunction)(impl)) {
+                return impl.shared.fullName;
+            }
+        }
     }
     return undefined;
 }
-exports.getFullNameOfType = getFullNameOfType;
 function addConditionToType(type, condition, skipSelfCondition = false) {
     var _a, _b;
     if (!condition) {
@@ -678,15 +767,14 @@ function addConditionToType(type, condition, skipSelfCondition = false) {
             return type;
         case 4 /* TypeCategory.Function */:
             return types_1.TypeBase.cloneForCondition(type, types_1.TypeCondition.combine((_a = type.props) === null || _a === void 0 ? void 0 : _a.condition, condition));
-        case 5 /* TypeCategory.OverloadedFunction */:
-            return types_1.OverloadedFunctionType.create(type.priv.overloads.map((t) => addConditionToType(t, condition)));
+        case 5 /* TypeCategory.Overloaded */:
+            return types_1.OverloadedType.create(types_1.OverloadedType.getOverloads(type).map((t) => addConditionToType(t, condition)));
         case 6 /* TypeCategory.Class */:
             return types_1.TypeBase.cloneForCondition(type, types_1.TypeCondition.combine((_b = type.props) === null || _b === void 0 ? void 0 : _b.condition, condition));
         case 8 /* TypeCategory.Union */:
             return (0, types_1.combineTypes)(type.priv.subtypes.map((t) => addConditionToType(t, condition)));
     }
 }
-exports.addConditionToType = addConditionToType;
 function getTypeCondition(type) {
     var _a;
     switch (type.category) {
@@ -696,7 +784,7 @@ function getTypeCondition(type) {
         case 3 /* TypeCategory.Never */:
         case 7 /* TypeCategory.Module */:
         case 9 /* TypeCategory.TypeVar */:
-        case 5 /* TypeCategory.OverloadedFunction */:
+        case 5 /* TypeCategory.Overloaded */:
         case 8 /* TypeCategory.Union */:
             return undefined;
         case 6 /* TypeCategory.Class */:
@@ -704,13 +792,11 @@ function getTypeCondition(type) {
             return (_a = type.props) === null || _a === void 0 ? void 0 : _a.condition;
     }
 }
-exports.getTypeCondition = getTypeCondition;
 // Indicates whether the specified type is a recursive type alias
 // placeholder that has not yet been resolved.
 function isTypeAliasPlaceholder(type) {
     return (0, types_1.isTypeVar)(type) && types_1.TypeVarType.isTypeAliasPlaceholder(type);
 }
-exports.isTypeAliasPlaceholder = isTypeAliasPlaceholder;
 // Determines whether the type alias placeholder is used directly
 // within the specified type. It's OK if it's used indirectly as
 // a type argument.
@@ -729,7 +815,6 @@ function isTypeAliasRecursive(typeAliasPlaceholder, type) {
     return ((0, types_1.findSubtype)(type, (subtype) => (0, types_1.isTypeVar)(subtype) && subtype.shared === typeAliasPlaceholder.shared) !==
         undefined);
 }
-exports.isTypeAliasRecursive = isTypeAliasRecursive;
 function transformPossibleRecursiveTypeAlias(type) {
     var _a, _b;
     if (type) {
@@ -755,7 +840,6 @@ function transformPossibleRecursiveTypeAlias(type) {
     }
     return type;
 }
-exports.transformPossibleRecursiveTypeAlias = transformPossibleRecursiveTypeAlias;
 function getTypeVarScopeId(type) {
     if ((0, types_1.isClass)(type)) {
         return type.shared.typeVarScopeId;
@@ -768,7 +852,6 @@ function getTypeVarScopeId(type) {
     }
     return undefined;
 }
-exports.getTypeVarScopeId = getTypeVarScopeId;
 // This is similar to getTypeVarScopeId except that it includes
 // the secondary scope IDs for functions.
 function getTypeVarScopeIds(type) {
@@ -784,7 +867,6 @@ function getTypeVarScopeIds(type) {
     }
     return scopeIds;
 }
-exports.getTypeVarScopeIds = getTypeVarScopeIds;
 // If the class type is generic and does not already have type arguments
 // specified, specialize it with default type arguments (Unknown or the
 // default type if provided).
@@ -796,7 +878,6 @@ function specializeWithDefaultTypeArgs(type) {
     /* isTypeArgExplicit */ false, 
     /* includeSubclasses */ type.priv.includeSubclasses);
 }
-exports.specializeWithDefaultTypeArgs = specializeWithDefaultTypeArgs;
 // Specializes the class with "Unknown" type args (or the equivalent for ParamSpecs
 // or TypeVarTuples).
 function specializeWithUnknownTypeArgs(type, tupleClassType) {
@@ -811,7 +892,6 @@ function specializeWithUnknownTypeArgs(type, tupleClassType) {
     /* isTypeArgExplicit */ false, 
     /* includeSubclasses */ type.priv.includeSubclasses);
 }
-exports.specializeWithUnknownTypeArgs = specializeWithUnknownTypeArgs;
 // Returns "Unknown" for simple TypeVars or the equivalent for a ParamSpec.
 function getUnknownForTypeVar(typeVar, tupleClassType) {
     if ((0, types_1.isParamSpec)(typeVar)) {
@@ -822,14 +902,12 @@ function getUnknownForTypeVar(typeVar, tupleClassType) {
     }
     return types_1.UnknownType.create();
 }
-exports.getUnknownForTypeVar = getUnknownForTypeVar;
 function getUnknownForTypeVarTuple(tupleClassType) {
     (0, debug_1.assert)((0, types_1.isInstantiableClass)(tupleClassType) && types_1.ClassType.isBuiltIn(tupleClassType, 'tuple'));
     return types_1.ClassType.cloneAsInstance(specializeTupleClass(tupleClassType, [{ type: types_1.UnknownType.create(), isUnbounded: true }], 
     /* isTypeArgExplicit */ true, 
-    /* isUnpackedTuple */ true));
+    /* isUnpacked */ true));
 }
-exports.getUnknownForTypeVarTuple = getUnknownForTypeVarTuple;
 // Returns the equivalent of "Callable[..., Unknown]".
 function getUnknownTypeForCallable() {
     const newFunction = types_1.FunctionType.createSynthesizedInstance('', 32768 /* FunctionTypeFlags.GradualCallableForm */);
@@ -837,7 +915,6 @@ function getUnknownTypeForCallable() {
     newFunction.shared.declaredReturnType = types_1.UnknownType.create();
     return newFunction;
 }
-exports.getUnknownTypeForCallable = getUnknownTypeForCallable;
 // If the class is generic and not already specialized, this function
 // "self specializes" the class, filling in its own type parameters
 // as type arguments.
@@ -853,7 +930,6 @@ function selfSpecializeClass(type, options) {
     });
     return types_1.ClassType.specialize(type, typeParams);
 }
-exports.selfSpecializeClass = selfSpecializeClass;
 // Determines whether the type derives from tuple. If so, it returns
 // the specialized tuple type.
 function getSpecializedTupleType(type) {
@@ -879,11 +955,9 @@ function getSpecializedTupleType(type) {
     const solution = buildSolutionFromSpecializedClass(classType);
     return applySolvedTypeVars(tupleClass, solution);
 }
-exports.getSpecializedTupleType = getSpecializedTupleType;
 function isLiteralType(type) {
     return types_1.TypeBase.isInstance(type) && type.priv.literalValue !== undefined;
 }
-exports.isLiteralType = isLiteralType;
 function isLiteralTypeOrUnion(type, allowNone = false) {
     if ((0, types_1.isClassInstance)(type)) {
         if (allowNone && isNoneInstance(type)) {
@@ -904,7 +978,6 @@ function isLiteralTypeOrUnion(type, allowNone = false) {
     }
     return false;
 }
-exports.isLiteralTypeOrUnion = isLiteralTypeOrUnion;
 function containsLiteralType(type, includeTypeArgs = false) {
     class ContainsLiteralTypeWalker extends typeWalker_1.TypeWalker {
         constructor(_includeTypeArgs) {
@@ -928,7 +1001,6 @@ function containsLiteralType(type, includeTypeArgs = false) {
     walker.walk(type);
     return walker.foundLiteral;
 }
-exports.containsLiteralType = containsLiteralType;
 // If all of the subtypes are literals with the same built-in class (e.g.
 // all 'int' or all 'str'), this function returns the name of that type. If
 // some of the subtypes are not literals or the literal classes don't match,
@@ -956,24 +1028,20 @@ function getLiteralTypeClassName(type) {
     }
     return undefined;
 }
-exports.getLiteralTypeClassName = getLiteralTypeClassName;
 function getUnionSubtypeCount(type) {
     if ((0, types_1.isUnion)(type)) {
         return type.priv.subtypes.length;
     }
     return 1;
 }
-exports.getUnionSubtypeCount = getUnionSubtypeCount;
 function isEllipsisType(type) {
     return (0, types_1.isAny)(type) && type.priv.isEllipsis;
 }
-exports.isEllipsisType = isEllipsisType;
 function isProperty(type) {
     return (0, types_1.isClassInstance)(type) && types_1.ClassType.isPropertyClass(type);
 }
-exports.isProperty = isProperty;
 function isCallableType(type) {
-    if ((0, types_1.isFunction)(type) || (0, types_1.isOverloadedFunction)(type) || (0, types_1.isAnyOrUnknown)(type)) {
+    if ((0, types_1.isFunction)(type) || (0, types_1.isOverloaded)(type) || (0, types_1.isAnyOrUnknown)(type)) {
         return true;
     }
     if (isEffectivelyInstantiable(type)) {
@@ -991,14 +1059,12 @@ function isCallableType(type) {
     }
     return false;
 }
-exports.isCallableType = isCallableType;
 function isDescriptorInstance(type, requireSetter = false) {
     if ((0, types_1.isUnion)(type)) {
         return type.priv.subtypes.every((subtype) => isMaybeDescriptorInstance(subtype, requireSetter));
     }
     return isMaybeDescriptorInstance(type, requireSetter);
 }
-exports.isDescriptorInstance = isDescriptorInstance;
 function isMaybeDescriptorInstance(type, requireSetter = false) {
     if ((0, types_1.isUnion)(type)) {
         return type.priv.subtypes.some((subtype) => isMaybeDescriptorInstance(subtype, requireSetter));
@@ -1014,7 +1080,6 @@ function isMaybeDescriptorInstance(type, requireSetter = false) {
     }
     return true;
 }
-exports.isMaybeDescriptorInstance = isMaybeDescriptorInstance;
 function isTupleGradualForm(type) {
     return ((0, types_1.isClassInstance)(type) &&
         isTupleClass(type) &&
@@ -1023,11 +1088,9 @@ function isTupleGradualForm(type) {
         (0, types_1.isAnyOrUnknown)(type.priv.tupleTypeArgs[0].type) &&
         type.priv.tupleTypeArgs[0].isUnbounded);
 }
-exports.isTupleGradualForm = isTupleGradualForm;
 function isTupleClass(type) {
     return types_1.ClassType.isBuiltIn(type, 'tuple');
 }
-exports.isTupleClass = isTupleClass;
 // Indicates whether the type is a tuple class of
 // the form tuple[x, ...] where the number of elements
 // in the tuple is unknown.
@@ -1035,7 +1098,6 @@ function isUnboundedTupleClass(type) {
     var _a;
     return (_a = type.priv.tupleTypeArgs) === null || _a === void 0 ? void 0 : _a.some((t) => t.isUnbounded || (0, types_1.isUnpackedTypeVarTuple)(t.type));
 }
-exports.isUnboundedTupleClass = isUnboundedTupleClass;
 // Indicates whether the specified index is within range and its type is unambiguous
 // in that it doesn't involve any element ranges that are of indeterminate length.
 function isTupleIndexUnambiguous(type, index) {
@@ -1051,7 +1113,6 @@ function isTupleIndexUnambiguous(type, index) {
     const upperIndexLimit = unboundedIndex < 0 ? type.priv.tupleTypeArgs.length : unboundedIndex;
     return index < upperIndexLimit;
 }
-exports.isTupleIndexUnambiguous = isTupleIndexUnambiguous;
 // Partially specializes a type within the context of a specified
 // (presumably specialized) class. Optionally specializes the `Self`
 // type variables, replacing them with selfClass.
@@ -1088,7 +1149,6 @@ function partiallySpecializeType(type, contextClassType, typeClassType, selfClas
     }
     return result;
 }
-exports.partiallySpecializeType = partiallySpecializeType;
 function addSolutionForSelfType(solution, contextClassType, selfClass) {
     const synthesizedSelfTypeVar = synthesizeTypeVarForSelfCls(contextClassType, /* isClsParam */ false);
     const selfInstance = convertToInstance(selfClass);
@@ -1104,24 +1164,30 @@ function addSolutionForSelfType(solution, contextClassType, selfClass) {
     });
     solution.setType(synthesizedSelfTypeVar, selfWithoutLiteral);
 }
-exports.addSolutionForSelfType = addSolutionForSelfType;
 // Looks for duplicate function types within the type and ensures that
 // if they are generic, they have unique type variables.
 function ensureSignaturesAreUnique(type, signatureTracker, expressionOffset) {
     const transformer = new UniqueFunctionSignatureTransformer(signatureTracker, expressionOffset);
     return transformer.apply(type, 0);
 }
-exports.ensureSignaturesAreUnique = ensureSignaturesAreUnique;
+function makeFunctionTypeVarsBound(type) {
+    const scopeIds = [];
+    doForEachSignature(type, (signature) => {
+        const localScopeId = getTypeVarScopeId(signature);
+        if (localScopeId) {
+            scopeIds.push(localScopeId);
+        }
+    });
+    return makeTypeVarsBound(type, scopeIds);
+}
 function makeTypeVarsBound(type, scopeIds) {
     const transformer = new BoundTypeVarTransform(scopeIds);
     return transformer.apply(type, 0);
 }
-exports.makeTypeVarsBound = makeTypeVarsBound;
 function makeTypeVarsFree(type, scopeIds) {
     const transformer = new FreeTypeVarTransform(scopeIds);
     return transformer.apply(type, 0);
 }
-exports.makeTypeVarsFree = makeTypeVarsFree;
 // Specializes a (potentially generic) type by substituting
 // type variables from a type var map.
 function applySolvedTypeVars(type, solution, options = {}) {
@@ -1132,28 +1198,6 @@ function applySolvedTypeVars(type, solution, options = {}) {
     const transformer = new ApplySolvedTypeVarsTransformer(solution, options);
     return transformer.apply(type, 0);
 }
-exports.applySolvedTypeVars = applySolvedTypeVars;
-// Applies solved TypeVars from one context to this context.
-function applySourceContextTypeVars(destContext, srcSolution) {
-    if (srcSolution.isEmpty()) {
-        return;
-    }
-    destContext.doForEachConstraintSet((set) => {
-        applySourceContextTypeVarsToSignature(set, srcSolution);
-    });
-}
-exports.applySourceContextTypeVars = applySourceContextTypeVars;
-function applySourceContextTypeVarsToSignature(set, srcSolution) {
-    set.getTypeVars().forEach((entry) => {
-        const newLowerBound = entry.lowerBound ? applySolvedTypeVars(entry.lowerBound, srcSolution) : undefined;
-        const newLowerBoundNoLiterals = entry.lowerBoundNoLiterals
-            ? applySolvedTypeVars(entry.lowerBoundNoLiterals, srcSolution)
-            : undefined;
-        const newUpperBound = entry.upperBound ? applySolvedTypeVars(entry.upperBound, srcSolution) : undefined;
-        set.setBounds(entry.typeVar, newLowerBound, newLowerBoundNoLiterals, newUpperBound);
-    });
-}
-exports.applySourceContextTypeVarsToSignature = applySourceContextTypeVarsToSignature;
 // Validates that a default type associated with a TypeVar does not refer to
 // other TypeVars or ParamSpecs that are out of scope.
 function validateTypeVarDefault(typeVar, liveTypeParams, invalidTypeVars) {
@@ -1164,7 +1208,6 @@ function validateTypeVarDefault(typeVar, liveTypeParams, invalidTypeVars) {
         validator.apply(typeVar.shared.defaultType, 0);
     }
 }
-exports.validateTypeVarDefault = validateTypeVarDefault;
 // During bidirectional type inference for constructors, an "expected type"
 // is used to prepopulate the type var map. This is problematic when the
 // expected type uses TypeVars that are not part of the context of the
@@ -1174,7 +1217,6 @@ function transformExpectedType(expectedType, liveTypeVarScopes, usageOffset) {
     const transformer = new ExpectedTypeTransformer(liveTypeVarScopes, usageOffset);
     return transformer.apply(expectedType, 0);
 }
-exports.transformExpectedType = transformExpectedType;
 // Given a protocol class (or abstract class), this function returns
 // a set of all the symbols (indexed by symbol name) that are part of
 // that protocol and its protocol parent classes. If a same-named symbol
@@ -1186,7 +1228,6 @@ function getProtocolSymbols(classType) {
     }
     return symbolMap;
 }
-exports.getProtocolSymbols = getProtocolSymbols;
 function getProtocolSymbolsRecursive(classType, symbolMap, classFlags = 512 /* ClassTypeFlags.ProtocolClass */, recursionCount = 0) {
     if (recursionCount > types_1.maxTypeRecursionCount) {
         return;
@@ -1211,7 +1252,6 @@ function getProtocolSymbolsRecursive(classType, symbolMap, classFlags = 512 /* C
         }
     });
 }
-exports.getProtocolSymbolsRecursive = getProtocolSymbolsRecursive;
 // Determines the maximum depth of a tuple, list, set or dictionary.
 // For example, if the type is tuple[tuple[tuple[int]]], its depth would be 3.
 function getContainerDepth(type, recursionCount = 0) {
@@ -1244,14 +1284,12 @@ function getContainerDepth(type, recursionCount = 0) {
     }
     return 1 + maxChildDepth;
 }
-exports.getContainerDepth = getContainerDepth;
 function lookUpObjectMember(objectType, memberName, flags = 0 /* MemberAccessFlags.Default */, skipMroClass) {
     if ((0, types_1.isClassInstance)(objectType)) {
         return lookUpClassMember(objectType, memberName, flags, skipMroClass);
     }
     return undefined;
 }
-exports.lookUpObjectMember = lookUpObjectMember;
 // Looks up a member in a class using the multiple-inheritance rules
 // defined by Python.
 function lookUpClassMember(classType, memberName, flags = 0 /* MemberAccessFlags.Default */, skipMroClass) {
@@ -1275,7 +1313,6 @@ function lookUpClassMember(classType, memberName, flags = 0 /* MemberAccessFlags
     const memberItr = getClassMemberIterator(classType, memberName, flags, skipMroClass);
     return (_b = memberItr.next()) === null || _b === void 0 ? void 0 : _b.value;
 }
-exports.lookUpClassMember = lookUpClassMember;
 // Iterates members in a class matching memberName using the multiple-inheritance rules.
 // For more details, see this note on method resolution
 // order: https://www.python.org/download/releases/2.3/mro/.
@@ -1411,7 +1448,6 @@ function* getClassMemberIterator(classType, memberName, flags = 0 /* MemberAcces
     }
     return undefined;
 }
-exports.getClassMemberIterator = getClassMemberIterator;
 function* getClassIterator(classType, flags = 0 /* ClassIteratorFlags.Default */, skipMroClass) {
     if ((0, types_1.isClass)(classType)) {
         let foundSkipMroClass = skipMroClass === undefined;
@@ -1456,7 +1492,6 @@ function* getClassIterator(classType, flags = 0 /* ClassIteratorFlags.Default */
     }
     return undefined;
 }
-exports.getClassIterator = getClassIterator;
 function getClassFieldsRecursive(classType) {
     const memberMap = new Map();
     // Evaluate the types of members from the end of the MRO to the beginning.
@@ -1486,7 +1521,6 @@ function getClassFieldsRecursive(classType) {
     });
     return memberMap;
 }
-exports.getClassFieldsRecursive = getClassFieldsRecursive;
 // Combines two lists of type var types, maintaining the combined order
 // but removing any duplicates.
 function addTypeVarsToListIfUnique(list1, list2, typeVarScopeId) {
@@ -1499,7 +1533,6 @@ function addTypeVarsToListIfUnique(list1, list2, typeVarScopeId) {
         }
     }
 }
-exports.addTypeVarsToListIfUnique = addTypeVarsToListIfUnique;
 // Walks the type recursively (in a depth-first manner), finds all
 // type variables that are referenced, and returns an ordered list
 // of unique type variables. For example, if the type is
@@ -1560,7 +1593,6 @@ function getTypeVarArgsRecursive(type, recursionCount = 0) {
     }
     return [];
 }
-exports.getTypeVarArgsRecursive = getTypeVarArgsRecursive;
 // Creates a specialized version of the class, filling in any unspecified
 // type arguments with Unknown.
 function specializeClassType(type) {
@@ -1571,66 +1603,6 @@ function specializeClassType(type) {
     });
     return applySolvedTypeVars(type, solution);
 }
-exports.specializeClassType = specializeClassType;
-// Recursively finds all of the type arguments and sets them
-// to the specified srcType.
-function setTypeArgsRecursive(destType, srcType, constraints, recursionCount = 0) {
-    if (recursionCount > types_1.maxTypeRecursionCount) {
-        return;
-    }
-    recursionCount++;
-    if (constraints.isLocked()) {
-        return;
-    }
-    switch (destType.category) {
-        case 8 /* TypeCategory.Union */:
-            doForEachSubtype(destType, (subtype) => {
-                setTypeArgsRecursive(subtype, srcType, constraints, recursionCount);
-            });
-            break;
-        case 6 /* TypeCategory.Class */:
-            if (destType.priv.typeArgs) {
-                destType.priv.typeArgs.forEach((typeArg) => {
-                    setTypeArgsRecursive(typeArg, srcType, constraints, recursionCount);
-                });
-            }
-            if (destType.priv.tupleTypeArgs) {
-                destType.priv.tupleTypeArgs.forEach((typeArg) => {
-                    setTypeArgsRecursive(typeArg.type, srcType, constraints, recursionCount);
-                });
-            }
-            break;
-        case 4 /* TypeCategory.Function */:
-            if (destType.priv.specializedTypes) {
-                destType.priv.specializedTypes.parameterTypes.forEach((paramType) => {
-                    setTypeArgsRecursive(paramType, srcType, constraints, recursionCount);
-                });
-                if (destType.priv.specializedTypes.returnType) {
-                    setTypeArgsRecursive(destType.priv.specializedTypes.returnType, srcType, constraints, recursionCount);
-                }
-            }
-            else {
-                destType.shared.parameters.forEach((_, index) => {
-                    setTypeArgsRecursive(types_1.FunctionType.getParamType(destType, index), srcType, constraints, recursionCount);
-                });
-                if (destType.shared.declaredReturnType) {
-                    setTypeArgsRecursive(destType.shared.declaredReturnType, srcType, constraints, recursionCount);
-                }
-            }
-            break;
-        case 5 /* TypeCategory.OverloadedFunction */:
-            destType.priv.overloads.forEach((subtype) => {
-                setTypeArgsRecursive(subtype, srcType, constraints, recursionCount);
-            });
-            break;
-        case 9 /* TypeCategory.TypeVar */:
-            if (!constraints.getMainConstraintSet().getTypeVar(destType)) {
-                constraints.setBounds(destType, srcType);
-            }
-            break;
-    }
-}
-exports.setTypeArgsRecursive = setTypeArgsRecursive;
 // Builds a mapping between type parameters and their specialized
 // types. For example, if the generic type is Dict[_T1, _T2] and the
 // specialized type is Dict[str, int], it returns a map that associates
@@ -1641,7 +1613,7 @@ function buildSolutionFromSpecializedClass(classType) {
     if (classType.priv.tupleTypeArgs) {
         typeArgs = [
             convertToInstance(specializeTupleClass(classType, classType.priv.tupleTypeArgs, classType.priv.isTypeArgExplicit, 
-            /* isUnpackedTuple */ true)),
+            /* isUnpacked */ true)),
         ];
     }
     else {
@@ -1649,7 +1621,6 @@ function buildSolutionFromSpecializedClass(classType) {
     }
     return buildSolution(typeParams, typeArgs);
 }
-exports.buildSolutionFromSpecializedClass = buildSolutionFromSpecializedClass;
 function buildSolution(typeParams, typeArgs) {
     const solution = new constraintSolution_1.ConstraintSolution();
     if (!typeArgs) {
@@ -1662,7 +1633,6 @@ function buildSolution(typeParams, typeArgs) {
     });
     return solution;
 }
-exports.buildSolution = buildSolution;
 // Determines the specialized base class type that srcType derives from.
 function specializeForBaseClass(srcType, baseClass) {
     const typeParams = types_1.ClassType.getTypeParams(baseClass);
@@ -1676,11 +1646,9 @@ function specializeForBaseClass(srcType, baseClass) {
     (0, debug_1.assert)((0, types_1.isInstantiableClass)(specializedType));
     return specializedType;
 }
-exports.specializeForBaseClass = specializeForBaseClass;
 function derivesFromStdlibClass(classType, className) {
     return classType.shared.mro.some((mroClass) => (0, types_1.isClass)(mroClass) && types_1.ClassType.isBuiltIn(mroClass, className));
 }
-exports.derivesFromStdlibClass = derivesFromStdlibClass;
 // If ignoreUnknown is true, an unknown base class is ignored when
 // checking for derivation. If ignoreUnknown is false, a return value
 // of true is assumed.
@@ -1701,7 +1669,6 @@ function derivesFromClassRecursive(classType, baseClassToFind, ignoreUnknown) {
     }
     return false;
 }
-exports.derivesFromClassRecursive = derivesFromClassRecursive;
 function synthesizeTypeVarForSelfCls(classType, isClsParam) {
     var _a;
     const selfType = types_1.TypeVarType.createInstance(`__type_of_self__`);
@@ -1717,7 +1684,6 @@ function synthesizeTypeVarForSelfCls(classType, isClsParam) {
     selfType.shared.boundType = types_1.ClassType.cloneAsInstance(boundType);
     return isClsParam ? types_1.TypeVarType.cloneAsInstantiable(selfType) : selfType;
 }
-exports.synthesizeTypeVarForSelfCls = synthesizeTypeVarForSelfCls;
 // Returns the declared "return" type (the type returned from a return statement)
 // if it was declared, or undefined otherwise.
 function getDeclaredGeneratorReturnType(functionType) {
@@ -1731,7 +1697,6 @@ function getDeclaredGeneratorReturnType(functionType) {
     }
     return undefined;
 }
-exports.getDeclaredGeneratorReturnType = getDeclaredGeneratorReturnType;
 // If the declared return type is a Generator, Iterable, Iterator or the async
 // counterparts, returns the yield type. If the type is invalid for a generator,
 // returns undefined.
@@ -1759,17 +1724,14 @@ function getGeneratorYieldType(declaredReturnType, isAsync) {
     });
     return isLegalGeneratorType ? yieldType : undefined;
 }
-exports.getGeneratorYieldType = getGeneratorYieldType;
 function isInstantiableMetaclass(type) {
     return ((0, types_1.isInstantiableClass)(type) &&
         type.shared.mro.some((mroClass) => (0, types_1.isClass)(mroClass) && types_1.ClassType.isBuiltIn(mroClass, 'type')));
 }
-exports.isInstantiableMetaclass = isInstantiableMetaclass;
 function isMetaclassInstance(type) {
     return ((0, types_1.isClassInstance)(type) &&
         type.shared.mro.some((mroClass) => (0, types_1.isClass)(mroClass) && types_1.ClassType.isBuiltIn(mroClass, 'type')));
 }
-exports.isMetaclassInstance = isMetaclassInstance;
 function isEffectivelyInstantiable(type, options, recursionCount = 0) {
     if (recursionCount > types_1.maxTypeRecursionCount) {
         return false;
@@ -1793,7 +1755,6 @@ function isEffectivelyInstantiable(type, options, recursionCount = 0) {
     }
     return false;
 }
-exports.isEffectivelyInstantiable = isEffectivelyInstantiable;
 function convertToInstance(type, includeSubclasses = true) {
     var _a, _b;
     // See if we've already performed this conversion and cached it.
@@ -1866,7 +1827,6 @@ function convertToInstance(type, includeSubclasses = true) {
     }
     return result;
 }
-exports.convertToInstance = convertToInstance;
 function convertToInstantiable(type, includeSubclasses = true) {
     var _a;
     // See if we've already performed this conversion and cached it.
@@ -1896,7 +1856,6 @@ function convertToInstantiable(type, includeSubclasses = true) {
     }
     return result;
 }
-exports.convertToInstantiable = convertToInstantiable;
 function getMembersForClass(classType, symbolTable, includeInstanceVars) {
     classType.shared.mro.forEach((mroClass) => {
         if ((0, types_1.isInstantiableClass)(mroClass)) {
@@ -1946,7 +1905,6 @@ function getMembersForClass(classType, symbolTable, includeInstanceVars) {
         }
     }
 }
-exports.getMembersForClass = getMembersForClass;
 function getMembersForModule(moduleType, symbolTable) {
     // Start with the loader fields. If there are any symbols of the
     // same name defined within the module, they will overwrite the
@@ -1960,7 +1918,6 @@ function getMembersForModule(moduleType, symbolTable) {
         symbolTable.set(name, symbol);
     });
 }
-exports.getMembersForModule = getMembersForModule;
 // Determines if the type contains an Any recursively.
 function containsAnyRecursive(type, includeUnknown = true) {
     class AnyWalker extends typeWalker_1.TypeWalker {
@@ -1984,7 +1941,6 @@ function containsAnyRecursive(type, includeUnknown = true) {
     walker.walk(type);
     return walker.foundAny;
 }
-exports.containsAnyRecursive = containsAnyRecursive;
 // Determines if the type contains an Any or Unknown type. If so,
 // it returns the Any or Unknown type. Unknowns are preferred over
 // Any if both are present. If recurse is true, it will recurse
@@ -2025,7 +1981,6 @@ function containsAnyOrUnknown(type, recurse) {
     walker.walk(type);
     return walker.anyOrUnknownType;
 }
-exports.containsAnyOrUnknown = containsAnyOrUnknown;
 // Determines if any part of the type contains "Unknown", including any type arguments.
 // This function does not use the TypeWalker because it is called very frequently,
 // and allocating a memory walker object for every call significantly increases
@@ -2072,8 +2027,8 @@ function isPartlyUnknown(type, recursionCount = 0) {
         return false;
     }
     // See if a function has an unknown type.
-    if ((0, types_1.isOverloadedFunction)(type)) {
-        return types_1.OverloadedFunctionType.getOverloads(type).some((overload) => {
+    if ((0, types_1.isOverloaded)(type)) {
+        return types_1.OverloadedType.getOverloads(type).some((overload) => {
             return isPartlyUnknown(overload, recursionCount);
         });
     }
@@ -2096,7 +2051,6 @@ function isPartlyUnknown(type, recursionCount = 0) {
     }
     return false;
 }
-exports.isPartlyUnknown = isPartlyUnknown;
 // If the specified type is a generic class with a single type argument
 // that is a union, it "explodes" the class into a union of classes with
 // each element of the union - e.g. Foo[A | B] becomes Foo[A] | Foo[B].
@@ -2108,7 +2062,6 @@ function explodeGenericClass(classType) {
         return types_1.ClassType.specialize(classType, [subtype]);
     }));
 }
-exports.explodeGenericClass = explodeGenericClass;
 // If the type is a union of same-sized tuples, these are combined into
 // a single tuple with that size. Otherwise, returns undefined.
 function combineSameSizedTuples(type, tupleType) {
@@ -2158,7 +2111,6 @@ function combineSameSizedTuples(type, tupleType) {
         return { type: (0, types_1.combineTypes)(entry), isUnbounded: false };
     })));
 }
-exports.combineSameSizedTuples = combineSameSizedTuples;
 function combineTupleTypeArgs(typeArgs) {
     return (0, types_1.combineTypes)(typeArgs.map((t) => {
         if ((0, types_1.isTypeVar)(t.type) && (0, types_1.isUnpackedTypeVarTuple)(t.type)) {
@@ -2168,19 +2120,17 @@ function combineTupleTypeArgs(typeArgs) {
         return t.type;
     }));
 }
-exports.combineTupleTypeArgs = combineTupleTypeArgs;
 // Tuples require special handling for specialization. This method computes
 // the "effective" type argument, which is a union of the variadic type
 // arguments.
-function specializeTupleClass(classType, typeArgs, isTypeArgExplicit = true, isUnpackedTuple = false) {
+function specializeTupleClass(classType, typeArgs, isTypeArgExplicit = true, isUnpacked = false) {
     const clonedClassType = types_1.ClassType.specialize(classType, [combineTupleTypeArgs(typeArgs)], isTypeArgExplicit, 
     /* includeSubclasses */ undefined, typeArgs);
-    if (isUnpackedTuple) {
+    if (isUnpacked) {
         clonedClassType.priv.isUnpacked = true;
     }
     return clonedClassType;
 }
-exports.specializeTupleClass = specializeTupleClass;
 function _expandUnpackedTypeVarTupleUnion(type) {
     if ((0, types_1.isClassInstance)(type) && isTupleClass(type) && type.priv.tupleTypeArgs && type.priv.isUnpacked) {
         return (0, types_1.combineTypes)(type.priv.tupleTypeArgs.map((t) => t.type));
@@ -2203,7 +2153,6 @@ function getGeneratorTypeArgs(returnType) {
     }
     return undefined;
 }
-exports.getGeneratorTypeArgs = getGeneratorTypeArgs;
 function requiresTypeArgs(classType) {
     if (classType.shared.typeParams.length > 0) {
         const firstTypeParam = classType.shared.typeParams[0];
@@ -2241,7 +2190,6 @@ function requiresTypeArgs(classType) {
     }
     return false;
 }
-exports.requiresTypeArgs = requiresTypeArgs;
 function requiresSpecialization(type, options, recursionCount = 0) {
     var _a;
     if (recursionCount > types_1.maxTypeRecursionCount) {
@@ -2262,7 +2210,6 @@ function requiresSpecialization(type, options, recursionCount = 0) {
     }
     return result;
 }
-exports.requiresSpecialization = requiresSpecialization;
 function _requiresSpecialization(type, options, recursionCount = 0) {
     var _a, _b;
     // If the type is conditioned on a TypeVar, it may need to be specialized.
@@ -2303,8 +2250,16 @@ function _requiresSpecialization(type, options, recursionCount = 0) {
             }
             return false;
         }
-        case 5 /* TypeCategory.OverloadedFunction */: {
-            return type.priv.overloads.some((overload) => requiresSpecialization(overload, options, recursionCount));
+        case 5 /* TypeCategory.Overloaded */: {
+            const overloads = types_1.OverloadedType.getOverloads(type);
+            if (overloads.some((overload) => requiresSpecialization(overload, options, recursionCount))) {
+                return true;
+            }
+            const impl = types_1.OverloadedType.getImplementation(type);
+            if (impl) {
+                return requiresSpecialization(impl, options, recursionCount);
+            }
+            return false;
         }
         case 8 /* TypeCategory.Union */: {
             return type.priv.subtypes.some((subtype) => requiresSpecialization(subtype, options, recursionCount));
@@ -2339,7 +2294,6 @@ function combineVariances(variance1, variance2) {
     }
     return variance1;
 }
-exports.combineVariances = combineVariances;
 // Determines if the variance of the type argument for a generic class is compatible
 // With the declared variance of the corresponding type parameter.
 function isVarianceOfTypeArgCompatible(type, typeParamVariance) {
@@ -2388,7 +2342,6 @@ function isVarianceOfTypeArgCompatible(type, typeParamVariance) {
     }
     return true;
 }
-exports.isVarianceOfTypeArgCompatible = isVarianceOfTypeArgCompatible;
 // Computes the method resolution ordering for a class whose base classes
 // have already been filled in. The algorithm for computing MRO is described
 // here: https://www.python.org/download/releases/2.3/mro/. It returns true
@@ -2518,7 +2471,6 @@ function computeMroLinearization(classType) {
     }
     return isMroFound;
 }
-exports.computeMroLinearization = computeMroLinearization;
 // Returns zero or more unique module names that point to the place(s)
 // where the type is declared. Unions, for example, can result in more
 // than one result. Type arguments are not included.
@@ -2527,7 +2479,6 @@ function getDeclaringModulesForType(type) {
     addDeclaringModuleNamesForType(type, moduleList);
     return moduleList;
 }
-exports.getDeclaringModulesForType = getDeclaringModulesForType;
 function convertNodeToArg(node) {
     return {
         argCategory: node.d.argCategory,
@@ -2535,7 +2486,6 @@ function convertNodeToArg(node) {
         valueExpression: node.d.valueExpr,
     };
 }
-exports.convertNodeToArg = convertNodeToArg;
 function addDeclaringModuleNamesForType(type, moduleList, recursionCount = 0) {
     if (recursionCount > types_1.maxTypeRecursionCount) {
         return;
@@ -2555,10 +2505,15 @@ function addDeclaringModuleNamesForType(type, moduleList, recursionCount = 0) {
             addIfUnique(type.shared.moduleName);
             break;
         }
-        case 5 /* TypeCategory.OverloadedFunction */: {
-            type.priv.overloads.forEach((overload) => {
+        case 5 /* TypeCategory.Overloaded */: {
+            const overloads = types_1.OverloadedType.getOverloads(type);
+            overloads.forEach((overload) => {
                 addDeclaringModuleNamesForType(overload, moduleList, recursionCount);
             });
+            const impl = types_1.OverloadedType.getImplementation(type);
+            if (impl) {
+                addDeclaringModuleNamesForType(impl, moduleList, recursionCount);
+            }
             break;
         }
         case 8 /* TypeCategory.Union */: {
@@ -2599,7 +2554,6 @@ function convertTypeToParamSpecValue(type) {
     }
     return types_1.ParamSpecType.getUnknown();
 }
-exports.convertTypeToParamSpecValue = convertTypeToParamSpecValue;
 // Converts a FunctionType into a ParamSpec if it consists only of
 // (* args: P.args, ** kwargs: P.kwargs). Otherwise returns the original type.
 function simplifyFunctionToParamSpec(type) {
@@ -2620,7 +2574,6 @@ function simplifyFunctionToParamSpec(type) {
     }
     return type;
 }
-exports.simplifyFunctionToParamSpec = simplifyFunctionToParamSpec;
 // Recursively walks a type and calls a callback for each TypeVar, allowing
 // it to be replaced with something else.
 class TypeVarTransformer {
@@ -2746,7 +2699,7 @@ class TypeVarTransformer {
             this._pendingFunctionTransformations.pop();
             return result;
         }
-        if ((0, types_1.isOverloadedFunction)(type)) {
+        if ((0, types_1.isOverloaded)(type)) {
             // Prevent recursion.
             if (this._pendingFunctionTransformations.some((t) => t === type)) {
                 return type;
@@ -2754,22 +2707,31 @@ class TypeVarTransformer {
             this._pendingFunctionTransformations.push(type);
             let requiresUpdate = false;
             // Specialize each of the functions in the overload.
+            const overloads = types_1.OverloadedType.getOverloads(type);
             const newOverloads = [];
-            type.priv.overloads.forEach((entry) => {
+            overloads.forEach((entry) => {
                 const replacementType = this.transformTypeVarsInFunctionType(entry, recursionCount);
                 if ((0, types_1.isFunction)(replacementType)) {
                     newOverloads.push(replacementType);
                 }
                 else {
-                    (0, collectionUtils_1.appendArray)(newOverloads, replacementType.priv.overloads);
+                    (0, collectionUtils_1.appendArray)(newOverloads, types_1.OverloadedType.getOverloads(replacementType));
                 }
                 if (replacementType !== entry) {
                     requiresUpdate = true;
                 }
             });
+            const impl = types_1.OverloadedType.getImplementation(type);
+            let newImpl = impl;
+            if (impl) {
+                newImpl = this.apply(impl, recursionCount);
+                if (newImpl !== impl) {
+                    requiresUpdate = true;
+                }
+            }
             this._pendingFunctionTransformations.pop();
             // Construct a new overload with the specialized function types.
-            return requiresUpdate ? types_1.OverloadedFunctionType.create(newOverloads) : type;
+            return requiresUpdate ? types_1.OverloadedType.create(newOverloads, newImpl) : type;
         }
         return type;
     }
@@ -3089,7 +3051,7 @@ class UniqueFunctionSignatureTransformer extends TypeVarTransformer {
                     }
                 });
                 updatedSourceType = applySolvedTypeVars(sourceType, solution);
-                (0, debug_1.assert)((0, types_1.isFunction)(updatedSourceType) || (0, types_1.isOverloadedFunction)(updatedSourceType));
+                (0, debug_1.assert)((0, types_1.isFunction)(updatedSourceType) || (0, types_1.isOverloaded)(updatedSourceType));
             }
         }
         this._signatureTracker.addSignature(sourceType, this._expressionOffset);
@@ -3333,7 +3295,7 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         if (filteredOverloads.length === 1) {
             return filteredOverloads[0];
         }
-        return types_1.OverloadedFunctionType.create(filteredOverloads);
+        return types_1.OverloadedType.create(filteredOverloads);
     }
     // Handle the case where we need the default replacement value for a typeVar
     // that has no scope and therefore doesn't have an assigned scopeID. We'll