@zzzen/pyright-internal 1.2.0-dev.20240728 → 1.2.0-dev.20240811

package/dist/analyzer/typeUtils.js

@@ -8,15 +8,112 @@
  * 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.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.buildTypeVarContext = exports.buildTypeVarContextFromSpecializedClass = 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.replaceTypeVarsWithAny = exports.validateTypeVarDefault = exports.applyInScopePlaceholders = exports.applySourceContextTypeVarsToSignature = exports.applySourceContextTypeVars = exports.applySolvedTypeVars = exports.updateTypeWithExternalTypeVars = exports.updateTypeWithInternalTypeVars = exports.ensureFunctionSignaturesAreUnique = exports.populateTypeVarContextForSelfType = exports.partiallySpecializeType = exports.isTupleIndexUnambiguous = exports.isUnboundedTupleClass = void 0;
-exports.convertParamSpecValueToType = exports.setTypeVarType = exports.convertTypeToParamSpecValue = exports.convertNodeToArg = exports.getDeclaringModulesForType = exports.computeMroLinearization = exports.isVarianceOfTypeArgCompatible = exports.combineVariances = exports.requiresSpecialization = 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.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");
 const symbol_1 = require("./symbol");
 const symbolUtils_1 = require("./symbolUtils");
 const types_1 = require("./types");
-const typeVarContext_1 = require("./typeVarContext");
 const typeWalker_1 = require("./typeWalker");
 var MemberAccessFlags;
 (function (MemberAccessFlags) {
@@ -79,19 +176,19 @@ 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.
     AssignTypeFlags[AssignTypeFlags["SkipRecursiveTypeCheck"] = 4] = "SkipRecursiveTypeCheck";
-    // Normally type vars are treated as variables that need to
-    // be "solved". If this flag is set, they are treated as types
-    // that must match. It is used for overload consistency checking.
-    AssignTypeFlags[AssignTypeFlags["SkipSolveTypeVars"] = 8] = "SkipSolveTypeVars";
+    // During TypeVar solving for a function call, this flag is set if
+    // this is the first of multiple passes. It adjusts certain heuristics
+    // for constraint solving.
+    AssignTypeFlags[AssignTypeFlags["ArgAssignmentFirstPass"] = 8] = "ArgAssignmentFirstPass";
     // If the dest is not Any but the src is Any, treat it
     // as incompatible. Also, treat all source TypeVars as their
     // concrete counterparts. This option is used for validating
@@ -111,14 +208,11 @@ var AssignTypeFlags;
     // because overloads can provide explicit type annotations for self
     // or cls.
     AssignTypeFlags[AssignTypeFlags["SkipSelfClsTypeCheck"] = 512] = "SkipSelfClsTypeCheck";
-    // If an assignment is made to a TypeVar that is out of scope,
-    // do not generate an error. This is used for populating the
-    // typeVarContext when handling contravariant parameters in a callable.
-    AssignTypeFlags[AssignTypeFlags["IgnoreTypeVarScope"] = 1024] = "IgnoreTypeVarScope";
-    // We're initially populating the typeVarContext with an expected type,
+    // 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";
@@ -187,25 +281,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.
@@ -214,7 +303,7 @@ function isTypeVarSame(type1, type2) {
         return true;
     }
     // If this isn't a bound TypeVar, return false.
-    if ((0, types_1.isParamSpec)(type1) || (0, types_1.isTypeVarTuple)(type1) || !type1.shared.boundType) {
+    if ((0, types_1.isParamSpec)(type1) || (0, types_1.isTypeVarTuple)(type1) || !types_1.TypeVarType.hasBound(type1)) {
         return false;
     }
     // If the second type isn't a union, return false.
@@ -236,14 +325,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.
@@ -267,17 +354,17 @@ function mapSubtypes(type, callback, options) {
                 for (i++; i < subtypes.length; i++) {
                     accumulateSubtype(callback(subtypes[i]));
                 }
-                const newType = (0, types_1.combineTypes)(typesToCombine, {
+                let newType = (0, types_1.combineTypes)(typesToCombine, {
                     skipElideRedundantLiterals: options === null || options === void 0 ? void 0 : options.skipElideRedundantLiterals,
                 });
                 if (options === null || options === void 0 ? void 0 : options.retainTypeAlias) {
                     if ((_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo) {
-                        types_1.TypeBase.setTypeAliasInfo(newType, type.props.typeAliasInfo);
+                        newType = types_1.TypeBase.cloneForTypeAlias(newType, type.props.typeAliasInfo);
                     }
                 }
                 else {
                     // Do our best to retain type aliases.
-                    if (newType.category === 8 /* TypeCategory.Union */) {
+                    if ((0, types_1.isUnion)(newType)) {
                         types_1.UnionType.addTypeAliasSource(newType, type);
                     }
                 }
@@ -292,7 +379,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) {
@@ -301,7 +387,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;
@@ -314,12 +400,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) {
@@ -328,9 +414,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
@@ -384,14 +469,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) {
@@ -422,7 +505,7 @@ function compareTypes(a, b, recursionCount = 0) {
                 if (aParam.category !== bParam.category) {
                     return bParam.category - aParam.category;
                 }
-                const typeComparison = compareTypes(types_1.FunctionType.getEffectiveParamType(a, i), types_1.FunctionType.getEffectiveParamType(bFunc, i));
+                const typeComparison = compareTypes(types_1.FunctionType.getParamType(a, i), types_1.FunctionType.getParamType(bFunc, i));
                 if (typeComparison !== 0) {
                     return typeComparison;
                 }
@@ -441,15 +524,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;
                 }
@@ -541,7 +626,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) => {
@@ -552,7 +636,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) => {
@@ -563,18 +646,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) {
@@ -587,7 +668,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.
@@ -605,7 +685,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) {
@@ -619,7 +698,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) => {
@@ -639,7 +717,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) {
@@ -655,19 +732,26 @@ 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) {
         return type;
     }
     if (skipSelfCondition) {
-        condition = condition.filter((c) => !c.typeVar.shared.isSynthesizedSelf);
+        condition = condition.filter((c) => !types_1.TypeVarType.isSelf(c.typeVar));
         if (condition.length === 0) {
             return type;
         }
@@ -682,15 +766,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) {
@@ -700,7 +783,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 */:
@@ -708,13 +791,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.
@@ -733,7 +814,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) {
@@ -745,21 +825,20 @@ function transformPossibleRecursiveTypeAlias(type) {
             if (!(aliasInfo === null || aliasInfo === void 0 ? void 0 : aliasInfo.typeArgs) || !type.shared.recursiveAlias.typeParams) {
                 return unspecializedType;
             }
-            const typeVarContext = buildTypeVarContext(type.shared.recursiveAlias.typeParams, aliasInfo.typeArgs, getTypeVarScopeId(type));
-            return applySolvedTypeVars(unspecializedType, typeVarContext);
+            const solution = buildSolution(type.shared.recursiveAlias.typeParams, aliasInfo.typeArgs);
+            return applySolvedTypeVars(unspecializedType, solution);
         }
         if ((0, types_1.isUnion)(type) && type.priv.includesRecursiveTypeAlias) {
             let newType = mapSubtypes(type, (subtype) => transformPossibleRecursiveTypeAlias(subtype));
             if (newType !== type && aliasInfo) {
                 // Copy the type alias information if present.
-                newType = types_1.TypeBase.cloneForTypeAlias(newType, aliasInfo.name, aliasInfo.fullName, aliasInfo.moduleName, aliasInfo.fileUri, aliasInfo.typeVarScopeId, aliasInfo.isPep695Syntax, aliasInfo.typeParams, aliasInfo.typeArgs);
+                newType = types_1.TypeBase.cloneForTypeAlias(newType, aliasInfo);
             }
             return newType;
         }
     }
     return type;
 }
-exports.transformPossibleRecursiveTypeAlias = transformPossibleRecursiveTypeAlias;
 function getTypeVarScopeId(type) {
     if ((0, types_1.isClass)(type)) {
         return type.shared.typeVarScopeId;
@@ -772,7 +851,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) {
@@ -785,13 +863,9 @@ function getTypeVarScopeIds(type) {
         if (type.priv.constructorTypeVarScopeId) {
             scopeIds.push(type.priv.constructorTypeVarScopeId);
         }
-        if (type.priv.higherOrderTypeVarScopeIds) {
-            scopeIds.push(...type.priv.higherOrderTypeVarScopeIds);
-        }
     }
     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).
@@ -803,7 +877,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) {
@@ -818,7 +891,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)) {
@@ -829,14 +901,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));
 }
-exports.getUnknownForTypeVarTuple = getUnknownForTypeVarTuple;
 // Returns the equivalent of "Callable[..., Unknown]".
 function getUnknownTypeForCallable() {
     const newFunction = types_1.FunctionType.createSynthesizedInstance('', 32768 /* FunctionTypeFlags.GradualCallableForm */);
@@ -844,7 +914,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.
@@ -856,11 +925,10 @@ function selfSpecializeClass(type, options) {
         return type;
     }
     const typeParams = type.shared.typeParams.map((typeParam) => {
-        return (options === null || options === void 0 ? void 0 : options.useInternalTypeVars) ? types_1.TypeVarType.cloneWithInternalScopeId(typeParam) : typeParam;
+        return (options === null || options === void 0 ? void 0 : options.useBoundTypeVars) ? types_1.TypeVarType.cloneAsBound(typeParam) : typeParam;
     });
     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) {
@@ -883,14 +951,12 @@ function getSpecializedTupleType(type) {
     if (types_1.ClassType.isSameGenericClass(classType, tupleClass)) {
         return classType;
     }
-    const typeVarContext = buildTypeVarContextFromSpecializedClass(classType);
-    return applySolvedTypeVars(tupleClass, typeVarContext);
+    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)) {
@@ -911,7 +977,6 @@ function isLiteralTypeOrUnion(type, allowNone = false) {
     }
     return false;
 }
-exports.isLiteralTypeOrUnion = isLiteralTypeOrUnion;
 function containsLiteralType(type, includeTypeArgs = false) {
     class ContainsLiteralTypeWalker extends typeWalker_1.TypeWalker {
         constructor(_includeTypeArgs) {
@@ -935,7 +1000,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,
@@ -963,24 +1027,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)) {
@@ -998,14 +1058,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));
@@ -1021,7 +1079,6 @@ function isMaybeDescriptorInstance(type, requireSetter = false) {
     }
     return true;
 }
-exports.isMaybeDescriptorInstance = isMaybeDescriptorInstance;
 function isTupleGradualForm(type) {
     return ((0, types_1.isClassInstance)(type) &&
         isTupleClass(type) &&
@@ -1030,11 +1087,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.
@@ -1042,7 +1097,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) {
@@ -1058,7 +1112,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.
@@ -1069,11 +1122,11 @@ function partiallySpecializeType(type, contextClassType, typeClassType, selfClas
         return type;
     }
     // Partially specialize the type using the specialized class type vars.
-    const typeVarContext = buildTypeVarContextFromSpecializedClass(contextClassType);
+    const solution = buildSolutionFromSpecializedClass(contextClassType);
     if (selfClass) {
-        populateTypeVarContextForSelfType(typeVarContext, contextClassType, selfClass);
+        addSolutionForSelfType(solution, contextClassType, selfClass);
     }
-    let result = applySolvedTypeVars(type, typeVarContext, { typeClassType });
+    let result = applySolvedTypeVars(type, solution, { typeClassType });
     // If this is a property, we may need to partially specialize the
     // access methods associated with it.
     if ((0, types_1.isClass)(result)) {
@@ -1095,8 +1148,7 @@ function partiallySpecializeType(type, contextClassType, typeClassType, selfClas
     }
     return result;
 }
-exports.partiallySpecializeType = partiallySpecializeType;
-function populateTypeVarContextForSelfType(typeVarContext, contextClassType, selfClass) {
+function addSolutionForSelfType(solution, contextClassType, selfClass) {
     const synthesizedSelfTypeVar = synthesizeTypeVarForSelfCls(contextClassType, /* isClsParam */ false);
     const selfInstance = convertToInstance(selfClass);
     // We can't call stripLiteralValue here because that method requires the type evaluator.
@@ -1109,89 +1161,32 @@ function populateTypeVarContextForSelfType(typeVarContext, contextClassType, sel
         }
         return subtype;
     });
-    if (!(0, types_1.isTypeSame)(synthesizedSelfTypeVar, selfWithoutLiteral)) {
-        setTypeVarType(typeVarContext, synthesizedSelfTypeVar, selfInstance, selfWithoutLiteral);
-    }
+    solution.setType(synthesizedSelfTypeVar, selfWithoutLiteral);
 }
-exports.populateTypeVarContextForSelfType = populateTypeVarContextForSelfType;
 // Looks for duplicate function types within the type and ensures that
 // if they are generic, they have unique type variables.
-function ensureFunctionSignaturesAreUnique(type, signatureTracker, expressionOffset) {
+function ensureSignaturesAreUnique(type, signatureTracker, expressionOffset) {
     const transformer = new UniqueFunctionSignatureTransformer(signatureTracker, expressionOffset);
     return transformer.apply(type, 0);
 }
-exports.ensureFunctionSignaturesAreUnique = ensureFunctionSignaturesAreUnique;
-function updateTypeWithInternalTypeVars(type, scopeIds) {
-    const transformer = new InternalScopeUpdateTransform(scopeIds);
+function makeTypeVarsBound(type, scopeIds) {
+    const transformer = new BoundTypeVarTransform(scopeIds);
     return transformer.apply(type, 0);
 }
-exports.updateTypeWithInternalTypeVars = updateTypeWithInternalTypeVars;
-function updateTypeWithExternalTypeVars(type, scopeIds) {
-    const transformer = new ExternalScopeUpdateTransform(scopeIds);
+function makeTypeVarsFree(type, scopeIds) {
+    const transformer = new FreeTypeVarTransform(scopeIds);
     return transformer.apply(type, 0);
 }
-exports.updateTypeWithExternalTypeVars = updateTypeWithExternalTypeVars;
 // Specializes a (potentially generic) type by substituting
 // type variables from a type var map.
-function applySolvedTypeVars(type, typeVarContext, options = {}) {
-    // Use a shortcut if the typeVarContext is empty and no transform is necessary.
-    if (typeVarContext.isEmpty() &&
-        !options.unknownIfNotFound &&
-        !options.eliminateUnsolvedInUnions &&
-        !options.applyInScopePlaceholders) {
+function applySolvedTypeVars(type, solution, options = {}) {
+    // Use a shortcut if constraints is empty and no transform is necessary.
+    if (solution.isEmpty() && !options.replaceUnsolved) {
         return type;
     }
-    if (options.applyInScopePlaceholders) {
-        applyInScopePlaceholders(typeVarContext);
-    }
-    const transformer = new ApplySolvedTypeVarsTransformer(typeVarContext, 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, srcContext) {
-    if (srcContext.isEmpty()) {
-        return;
-    }
-    destContext.doForEachSolutionSet((solutionSet) => {
-        applySourceContextTypeVarsToSignature(solutionSet, srcContext);
-    });
-}
-exports.applySourceContextTypeVars = applySourceContextTypeVars;
-function applySourceContextTypeVarsToSignature(solutionSet, srcContext) {
-    solutionSet.getTypeVars().forEach((entry) => {
-        const newLowerBound = entry.lowerBound ? applySolvedTypeVars(entry.lowerBound, srcContext) : undefined;
-        const newLowerBoundNoLiterals = entry.lowerBoundNoLiterals
-            ? applySolvedTypeVars(entry.lowerBoundNoLiterals, srcContext)
-            : undefined;
-        const newUpperBound = entry.upperBound ? applySolvedTypeVars(entry.upperBound, srcContext) : undefined;
-        solutionSet.setTypeVarType(entry.typeVar, newLowerBound, newLowerBoundNoLiterals, newUpperBound);
-    });
-}
-exports.applySourceContextTypeVarsToSignature = applySourceContextTypeVarsToSignature;
-// If the TypeVarContext contains any type variables whose types depend on
-// in-scope placeholders used for bidirectional type inference, replace those
-// with the solved type associated with those in-scope placeholders.
-function applyInScopePlaceholders(typeVarContext) {
-    typeVarContext.doForEachSolutionSet((solutionSet) => {
-        solutionSet.getTypeVars().forEach((entry) => {
-            const typeVar = entry.typeVar;
-            if (!typeVar.priv.isInScopePlaceholder) {
-                const newLowerBound = entry.lowerBound
-                    ? applyInScopePlaceholdersToType(entry.lowerBound, solutionSet)
-                    : undefined;
-                const newLowerBoundNoLiterals = entry.lowerBoundNoLiterals
-                    ? applyInScopePlaceholdersToType(entry.lowerBoundNoLiterals, solutionSet)
-                    : undefined;
-                const newUpperBound = entry.upperBound
-                    ? applyInScopePlaceholdersToType(entry.upperBound, solutionSet)
-                    : undefined;
-                solutionSet.setTypeVarType(entry.typeVar, newLowerBound, newLowerBoundNoLiterals, newUpperBound);
-            }
-        });
-    });
-}
-exports.applyInScopePlaceholders = applyInScopePlaceholders;
 // 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) {
@@ -1202,12 +1197,6 @@ function validateTypeVarDefault(typeVar, liveTypeParams, invalidTypeVars) {
         validator.apply(typeVar.shared.defaultType, 0);
     }
 }
-exports.validateTypeVarDefault = validateTypeVarDefault;
-function replaceTypeVarsWithAny(type) {
-    const transformer = new TypeVarAnyReplacer();
-    return transformer.apply(type, 0);
-}
-exports.replaceTypeVarsWithAny = replaceTypeVarsWithAny;
 // 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
@@ -1217,7 +1206,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
@@ -1229,7 +1217,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;
@@ -1254,7 +1241,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) {
@@ -1287,14 +1273,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) {
@@ -1318,7 +1302,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/.
@@ -1454,7 +1437,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;
@@ -1499,7 +1481,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.
@@ -1529,7 +1510,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) {
@@ -1542,7 +1522,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
@@ -1593,7 +1572,7 @@ function getTypeVarArgsRecursive(type, recursionCount = 0) {
     if ((0, types_1.isFunction)(type)) {
         const combinedList = [];
         for (let i = 0; i < type.shared.parameters.length; i++) {
-            addTypeVarsToListIfUnique(combinedList, getTypeVarArgsRecursive(types_1.FunctionType.getEffectiveParamType(type, i), recursionCount));
+            addTypeVarsToListIfUnique(combinedList, getTypeVarArgsRecursive(types_1.FunctionType.getParamType(type, i), recursionCount));
         }
         const returnType = types_1.FunctionType.getEffectiveReturnType(type);
         if (returnType) {
@@ -1603,82 +1582,21 @@ 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) {
-    const typeVarContext = new typeVarContext_1.TypeVarContext(getTypeVarScopeId(type));
+    const solution = new constraintSolution_1.ConstraintSolution();
     const typeParams = types_1.ClassType.getTypeParams(type);
     typeParams.forEach((typeParam) => {
-        setTypeVarType(typeVarContext, typeParam, applySolvedTypeVars(typeParam.shared.defaultType, typeVarContext));
+        solution.setType(typeParam, applySolvedTypeVars(typeParam.shared.defaultType, solution));
     });
-    return applySolvedTypeVars(type, typeVarContext);
+    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, typeVarContext, recursionCount = 0) {
-    if (recursionCount > types_1.maxTypeRecursionCount) {
-        return;
-    }
-    recursionCount++;
-    if (typeVarContext.isLocked()) {
-        return;
-    }
-    switch (destType.category) {
-        case 8 /* TypeCategory.Union */:
-            doForEachSubtype(destType, (subtype) => {
-                setTypeArgsRecursive(subtype, srcType, typeVarContext, recursionCount);
-            });
-            break;
-        case 6 /* TypeCategory.Class */:
-            if (destType.priv.typeArgs) {
-                destType.priv.typeArgs.forEach((typeArg) => {
-                    setTypeArgsRecursive(typeArg, srcType, typeVarContext, recursionCount);
-                });
-            }
-            if (destType.priv.tupleTypeArgs) {
-                destType.priv.tupleTypeArgs.forEach((typeArg) => {
-                    setTypeArgsRecursive(typeArg.type, srcType, typeVarContext, recursionCount);
-                });
-            }
-            break;
-        case 4 /* TypeCategory.Function */:
-            if (destType.priv.specializedTypes) {
-                destType.priv.specializedTypes.parameterTypes.forEach((paramType) => {
-                    setTypeArgsRecursive(paramType, srcType, typeVarContext, recursionCount);
-                });
-                if (destType.priv.specializedTypes.returnType) {
-                    setTypeArgsRecursive(destType.priv.specializedTypes.returnType, srcType, typeVarContext, recursionCount);
-                }
-            }
-            else {
-                destType.shared.parameters.forEach((param) => {
-                    setTypeArgsRecursive(param.type, srcType, typeVarContext, recursionCount);
-                });
-                if (destType.shared.declaredReturnType) {
-                    setTypeArgsRecursive(destType.shared.declaredReturnType, srcType, typeVarContext, recursionCount);
-                }
-            }
-            break;
-        case 5 /* TypeCategory.OverloadedFunction */:
-            destType.priv.overloads.forEach((subtype) => {
-                setTypeArgsRecursive(subtype, srcType, typeVarContext, recursionCount);
-            });
-            break;
-        case 9 /* TypeCategory.TypeVar */:
-            if (!typeVarContext.getMainSolutionSet().getTypeVar(destType)) {
-                setTypeVarType(typeVarContext, 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
 // _T1 with str and _T2 with int.
-function buildTypeVarContextFromSpecializedClass(classType) {
+function buildSolutionFromSpecializedClass(classType) {
     const typeParams = types_1.ClassType.getTypeParams(classType);
     let typeArgs;
     if (classType.priv.tupleTypeArgs) {
@@ -1690,45 +1608,20 @@ function buildTypeVarContextFromSpecializedClass(classType) {
     else {
         typeArgs = classType.priv.typeArgs;
     }
-    return buildTypeVarContext(typeParams, typeArgs, getTypeVarScopeId(classType));
+    return buildSolution(typeParams, typeArgs);
 }
-exports.buildTypeVarContextFromSpecializedClass = buildTypeVarContextFromSpecializedClass;
-function buildTypeVarContext(typeParams, typeArgs, typeVarScopeId) {
-    const typeVarContext = new typeVarContext_1.TypeVarContext(typeVarScopeId);
+function buildSolution(typeParams, typeArgs) {
+    const solution = new constraintSolution_1.ConstraintSolution();
+    if (!typeArgs) {
+        return solution;
+    }
     typeParams.forEach((typeParam, index) => {
-        let typeArgType;
-        if (typeArgs) {
-            if ((0, types_1.isParamSpec)(typeParam)) {
-                if (index < typeArgs.length) {
-                    typeArgType = typeArgs[index];
-                    if ((0, types_1.isFunction)(typeArgType) && types_1.FunctionType.isParamSpecValue(typeArgType)) {
-                        const parameters = [];
-                        const typeArgFunctionType = typeArgType;
-                        typeArgType.shared.parameters.forEach((param, paramIndex) => {
-                            parameters.push(types_1.FunctionParam.create(param.category, types_1.FunctionType.getEffectiveParamType(typeArgFunctionType, paramIndex), param.flags & types_1.FunctionParamFlags.NameSynthesized, param.name, param.defaultType));
-                        });
-                        setTypeVarType(typeVarContext, typeParam, typeArgType);
-                    }
-                    else if ((0, types_1.isParamSpec)(typeArgType) || (0, types_1.isAnyOrUnknown)(typeArgType)) {
-                        setTypeVarType(typeVarContext, typeParam, typeArgType);
-                    }
-                }
-            }
-            else {
-                if (index >= typeArgs.length) {
-                    typeArgType = types_1.AnyType.create();
-                }
-                else {
-                    typeArgType = typeArgs[index];
-                }
-                setTypeVarType(typeVarContext, typeParam, typeArgType, 
-                /* lowerBoundNoLiterals */ undefined, typeArgType);
-            }
+        if (index < typeArgs.length) {
+            solution.setType(typeParam, typeArgs[index]);
         }
     });
-    return typeVarContext;
+    return solution;
 }
-exports.buildTypeVarContext = buildTypeVarContext;
 // Determines the specialized base class type that srcType derives from.
 function specializeForBaseClass(srcType, baseClass) {
     const typeParams = types_1.ClassType.getTypeParams(baseClass);
@@ -1737,16 +1630,14 @@ function specializeForBaseClass(srcType, baseClass) {
     if (typeParams.length === 0) {
         return baseClass;
     }
-    const typeVarContext = buildTypeVarContextFromSpecializedClass(srcType);
-    const specializedType = applySolvedTypeVars(baseClass, typeVarContext);
+    const solution = buildSolutionFromSpecializedClass(srcType);
+    const specializedType = applySolvedTypeVars(baseClass, solution);
     (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.
@@ -1767,7 +1658,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__`);
@@ -1783,7 +1673,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) {
@@ -1797,7 +1686,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.
@@ -1825,17 +1713,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;
@@ -1859,7 +1744,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.
@@ -1921,7 +1805,7 @@ function convertToInstance(type, includeSubclasses = true) {
     // Copy over any type alias information.
     const aliasInfo = (_b = type.props) === null || _b === void 0 ? void 0 : _b.typeAliasInfo;
     if (aliasInfo && type !== result) {
-        result = types_1.TypeBase.cloneForTypeAlias(result, aliasInfo.name, aliasInfo.fullName, aliasInfo.moduleName, aliasInfo.fileUri, aliasInfo.typeVarScopeId, aliasInfo.isPep695Syntax, aliasInfo.typeParams, aliasInfo.typeArgs);
+        result = types_1.TypeBase.cloneForTypeAlias(result, aliasInfo);
     }
     if (type !== result && includeSubclasses) {
         // Cache the converted value for next time.
@@ -1932,7 +1816,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.
@@ -1962,7 +1845,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)) {
@@ -2012,7 +1894,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
@@ -2026,7 +1907,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 {
@@ -2050,7 +1930,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
@@ -2091,7 +1970,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
@@ -2138,8 +2016,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);
         });
     }
@@ -2147,7 +2025,7 @@ function isPartlyUnknown(type, recursionCount = 0) {
         for (let i = 0; i < type.shared.parameters.length; i++) {
             // Ignore parameters such as "*" that have no name.
             if (type.shared.parameters[i].name) {
-                const paramType = types_1.FunctionType.getEffectiveParamType(type, i);
+                const paramType = types_1.FunctionType.getParamType(type, i);
                 if (isPartlyUnknown(paramType, recursionCount)) {
                     return true;
                 }
@@ -2162,7 +2040,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].
@@ -2174,7 +2051,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) {
@@ -2224,7 +2100,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)) {
@@ -2234,7 +2109,6 @@ 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.
@@ -2246,8 +2120,7 @@ function specializeTupleClass(classType, typeArgs, isTypeArgExplicit = true, isU
     }
     return clonedClassType;
 }
-exports.specializeTupleClass = specializeTupleClass;
-function _expandVariadicUnpackedUnion(type) {
+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));
     }
@@ -2269,7 +2142,6 @@ function getGeneratorTypeArgs(returnType) {
     }
     return undefined;
 }
-exports.getGeneratorTypeArgs = getGeneratorTypeArgs;
 function requiresTypeArgs(classType) {
     if (classType.shared.typeParams.length > 0) {
         const firstTypeParam = classType.shared.typeParams[0];
@@ -2307,7 +2179,6 @@ function requiresTypeArgs(classType) {
     }
     return false;
 }
-exports.requiresTypeArgs = requiresTypeArgs;
 function requiresSpecialization(type, options, recursionCount = 0) {
     var _a;
     if (recursionCount > types_1.maxTypeRecursionCount) {
@@ -2328,7 +2199,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.
@@ -2350,7 +2220,7 @@ function _requiresSpecialization(type, options, recursionCount = 0) {
         }
         case 4 /* TypeCategory.Function */: {
             for (let i = 0; i < type.shared.parameters.length; i++) {
-                if (requiresSpecialization(types_1.FunctionType.getEffectiveParamType(type, i), options, recursionCount)) {
+                if (requiresSpecialization(types_1.FunctionType.getParamType(type, i), options, recursionCount)) {
                     return true;
                 }
             }
@@ -2369,8 +2239,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));
@@ -2378,7 +2256,7 @@ function _requiresSpecialization(type, options, recursionCount = 0) {
         case 9 /* TypeCategory.TypeVar */: {
             // Most TypeVar types need to be specialized.
             if (!type.shared.recursiveAlias) {
-                if (type.shared.isSynthesizedSelf && (options === null || options === void 0 ? void 0 : options.ignoreSelf)) {
+                if (types_1.TypeVarType.isSelf(type) && (options === null || options === void 0 ? void 0 : options.ignoreSelf)) {
                     return false;
                 }
                 return true;
@@ -2405,7 +2283,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) {
@@ -2454,7 +2331,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
@@ -2492,9 +2368,9 @@ function computeMroLinearization(classType) {
     const classListsToMerge = [];
     filteredBaseClasses.forEach((baseClass) => {
         if ((0, types_1.isInstantiableClass)(baseClass)) {
-            const typeVarContext = buildTypeVarContextFromSpecializedClass(baseClass);
+            const solution = buildSolutionFromSpecializedClass(baseClass);
             classListsToMerge.push(baseClass.shared.mro.map((mroClass) => {
-                return applySolvedTypeVars(mroClass, typeVarContext);
+                return applySolvedTypeVars(mroClass, solution);
             }));
         }
         else {
@@ -2502,12 +2378,12 @@ function computeMroLinearization(classType) {
         }
     });
     classListsToMerge.push(filteredBaseClasses.map((baseClass) => {
-        const typeVarContext = buildTypeVarContextFromSpecializedClass(classType);
-        return applySolvedTypeVars(baseClass, typeVarContext);
+        const solution = buildSolutionFromSpecializedClass(classType);
+        return applySolvedTypeVars(baseClass, solution);
     }));
     // The first class in the MRO is the class itself.
-    const typeVarContext = buildTypeVarContextFromSpecializedClass(classType);
-    let specializedClassType = applySolvedTypeVars(classType, typeVarContext);
+    const solution = buildSolutionFromSpecializedClass(classType);
+    let specializedClassType = applySolvedTypeVars(classType, solution);
     if (!(0, types_1.isClass)(specializedClassType) && !(0, types_1.isAnyOrUnknown)(specializedClassType)) {
         specializedClassType = types_1.UnknownType.create();
     }
@@ -2584,7 +2460,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.
@@ -2593,7 +2468,6 @@ function getDeclaringModulesForType(type) {
     addDeclaringModuleNamesForType(type, moduleList);
     return moduleList;
 }
-exports.getDeclaringModulesForType = getDeclaringModulesForType;
 function convertNodeToArg(node) {
     return {
         argCategory: node.d.argCategory,
@@ -2601,7 +2475,6 @@ function convertNodeToArg(node) {
         valueExpression: node.d.valueExpr,
     };
 }
-exports.convertNodeToArg = convertNodeToArg;
 function addDeclaringModuleNamesForType(type, moduleList, recursionCount = 0) {
     if (recursionCount > types_1.maxTypeRecursionCount) {
         return;
@@ -2621,10 +2494,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 */: {
@@ -2650,41 +2528,24 @@ function convertTypeToParamSpecValue(type) {
         return newFunction;
     }
     if ((0, types_1.isFunction)(type)) {
+        // If it's already a ParamSpecValue, return it as is.
+        if (types_1.FunctionType.isParamSpecValue(type)) {
+            return type;
+        }
         const newFunction = types_1.FunctionType.createInstance('', '', '', type.shared.flags | 65536 /* FunctionTypeFlags.ParamSpecValue */, type.shared.docString);
         newFunction.shared.deprecatedMessage = type.shared.deprecatedMessage;
         type.shared.parameters.forEach((param, index) => {
-            types_1.FunctionType.addParam(newFunction, types_1.FunctionParam.create(param.category, types_1.FunctionType.getEffectiveParamType(type, index), param.flags & types_1.FunctionParamFlags.NameSynthesized, param.name, param.defaultType));
+            types_1.FunctionType.addParam(newFunction, types_1.FunctionParam.create(param.category, types_1.FunctionType.getParamType(type, index), param.flags, param.name, types_1.FunctionType.getParamDefaultType(type, index)));
         });
-        if (type.priv.higherOrderTypeVarScopeIds) {
-            newFunction.priv.higherOrderTypeVarScopeIds = [...type.priv.higherOrderTypeVarScopeIds];
-            newFunction.shared.typeVarScopeId = newFunction.priv.higherOrderTypeVarScopeIds.pop();
-        }
+        newFunction.shared.typeVarScopeId = type.shared.typeVarScopeId;
         newFunction.priv.constructorTypeVarScopeId = type.priv.constructorTypeVarScopeId;
         return newFunction;
     }
     return types_1.ParamSpecType.getUnknown();
 }
-exports.convertTypeToParamSpecValue = convertTypeToParamSpecValue;
-// This function calls the setTypeVarType method on the TypeVarContext after
-// converting the parameters for use with a ParamSpec.
-function setTypeVarType(typeVarContext, typeVar, lowerBound, lowerBoundNoLiterals, upperBound) {
-    if ((0, types_1.isParamSpec)(typeVar)) {
-        if (lowerBound) {
-            lowerBound = convertTypeToParamSpecValue(lowerBound);
-        }
-        if (lowerBoundNoLiterals) {
-            lowerBoundNoLiterals = convertTypeToParamSpecValue(lowerBoundNoLiterals);
-        }
-        if (upperBound) {
-            lowerBound = convertTypeToParamSpecValue(upperBound);
-        }
-    }
-    typeVarContext.setTypeVarType(typeVar, lowerBound, lowerBoundNoLiterals, upperBound);
-}
-exports.setTypeVarType = setTypeVarType;
 // Converts a FunctionType into a ParamSpec if it consists only of
 // (* args: P.args, ** kwargs: P.kwargs). Otherwise returns the original type.
-function convertParamSpecValueToType(type) {
+function simplifyFunctionToParamSpec(type) {
     const paramSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(type);
     const withoutParamSpec = types_1.FunctionType.cloneRemoveParamSpecArgsKwargs(type);
     let hasParams = withoutParamSpec.shared.parameters.length > 0;
@@ -2700,31 +2561,18 @@ function convertParamSpecValueToType(type) {
     if (!hasParams && paramSpec) {
         return paramSpec;
     }
-    // Create a function type from the param spec entries.
-    const functionType = types_1.FunctionType.createInstance('', '', '', 65536 /* FunctionTypeFlags.ParamSpecValue */ | withoutParamSpec.shared.flags);
-    types_1.FunctionType.addHigherOrderTypeVarScopeIds(functionType, withoutParamSpec.shared.typeVarScopeId);
-    types_1.FunctionType.addHigherOrderTypeVarScopeIds(functionType, withoutParamSpec.priv.higherOrderTypeVarScopeIds);
-    functionType.priv.constructorTypeVarScopeId = withoutParamSpec.priv.constructorTypeVarScopeId;
-    withoutParamSpec.shared.parameters.forEach((entry, index) => {
-        types_1.FunctionType.addParam(functionType, types_1.FunctionParam.create(entry.category, types_1.FunctionType.getEffectiveParamType(withoutParamSpec, index), (entry.flags & types_1.FunctionParamFlags.NameSynthesized) | types_1.FunctionParamFlags.TypeDeclared, entry.name, entry.defaultType));
-    });
-    if (paramSpec) {
-        types_1.FunctionType.addParamSpecVariadics(functionType, paramSpec);
-    }
-    functionType.shared.docString = withoutParamSpec.shared.docString;
-    functionType.shared.deprecatedMessage = withoutParamSpec.shared.deprecatedMessage;
-    functionType.shared.methodClass = withoutParamSpec.shared.methodClass;
-    return functionType;
+    return type;
 }
-exports.convertParamSpecValueToType = convertParamSpecValueToType;
 // Recursively walks a type and calls a callback for each TypeVar, allowing
 // it to be replaced with something else.
 class TypeVarTransformer {
     constructor() {
-        this._isTransformingTypeArg = false;
         this._pendingTypeVarTransformations = new Set();
         this._pendingFunctionTransformations = [];
     }
+    get pendingTypeVarTransformations() {
+        return this._pendingTypeVarTransformations;
+    }
     apply(type, recursionCount) {
         var _a, _b, _c;
         if (recursionCount > types_1.maxTypeRecursionCount) {
@@ -2765,7 +2613,7 @@ class TypeVarTransformer {
                     return replacementType;
                 });
                 if (requiresUpdate) {
-                    return types_1.TypeBase.cloneForTypeAlias(type, aliasInfo.name, aliasInfo.fullName, aliasInfo.moduleName, aliasInfo.fileUri, aliasInfo.typeVarScopeId, aliasInfo.isPep695Syntax, aliasInfo.typeParams, typeArgs);
+                    return types_1.TypeBase.cloneForTypeAlias(type, { ...aliasInfo, typeArgs });
                 }
                 return type;
             }
@@ -2774,43 +2622,36 @@ class TypeVarTransformer {
             // type variables in the same scope recursively by setting it the scope in the
             // _pendingTypeVarTransformations set.
             if (!this._isTypeVarScopePending(type.priv.scopeId)) {
-                if ((0, types_1.isParamSpec)(type)) {
-                    let paramSpecWithoutAccess = type;
-                    if ((0, types_1.isParamSpec)(type) && type.priv.paramSpecAccess) {
-                        paramSpecWithoutAccess = types_1.TypeVarType.cloneForParamSpecAccess(type, /* access */ undefined);
+                let paramSpecAccess;
+                // If this is a ParamSpec with a ".args" or ".kwargs" access, strip
+                // it off for now. We'll add it back later if appropriate.
+                if ((0, types_1.isParamSpec)(type) && type.priv.paramSpecAccess) {
+                    paramSpecAccess = type.priv.paramSpecAccess;
+                    type = types_1.TypeVarType.cloneForParamSpecAccess(type, /* access */ undefined);
+                }
+                replacementType = (_c = this.transformTypeVar(type, recursionCount)) !== null && _c !== void 0 ? _c : type;
+                if ((0, types_1.isParamSpec)(type) && replacementType !== type) {
+                    replacementType = simplifyFunctionToParamSpec(convertTypeToParamSpecValue(replacementType));
+                }
+                // If the original type was a ParamSpec with a ".args" or ".kwargs" access,
+                // preserve that information in the transformed type.
+                if (paramSpecAccess) {
+                    if ((0, types_1.isParamSpec)(replacementType)) {
+                        replacementType = types_1.TypeVarType.cloneForParamSpecAccess(replacementType, paramSpecAccess);
                     }
-                    const paramSpecValue = this.transformParamSpec(paramSpecWithoutAccess, recursionCount);
-                    if (paramSpecValue) {
-                        const paramSpecType = convertParamSpecValueToType(paramSpecValue);
-                        if (type.priv.paramSpecAccess) {
-                            if ((0, types_1.isParamSpec)(paramSpecType)) {
-                                replacementType = types_1.TypeVarType.cloneForParamSpecAccess(paramSpecType, type.priv.paramSpecAccess);
-                            }
-                            else {
-                                replacementType = types_1.UnknownType.create();
-                            }
-                        }
-                        else {
-                            replacementType = paramSpecType;
-                        }
+                    else {
+                        replacementType = types_1.UnknownType.create();
                     }
                 }
-                else {
-                    replacementType = (_c = this.transformTypeVar(type, recursionCount)) !== null && _c !== void 0 ? _c : type;
-                    if (!this._isTransformingTypeArg) {
-                        if (type.priv.scopeId) {
-                            this._pendingTypeVarTransformations.add(type.priv.scopeId);
-                        }
-                        replacementType = this.apply(replacementType, recursionCount);
-                        if (type.priv.scopeId) {
-                            this._pendingTypeVarTransformations.delete(type.priv.scopeId);
-                        }
-                    }
-                    // If we're transforming a variadic type variable that was in a union,
-                    // expand the union types.
-                    if ((0, types_1.isTypeVarTuple)(type) && type.priv.isVariadicInUnion) {
-                        replacementType = _expandVariadicUnpackedUnion(replacementType);
-                    }
+                // If we're transforming a TypeVarTuple that was in a union,
+                // expand the union types.
+                if ((0, types_1.isTypeVarTuple)(type) && type.priv.isInUnion) {
+                    replacementType = _expandUnpackedTypeVarTupleUnion(replacementType);
+                }
+                if (type.priv.scopeId) {
+                    this._pendingTypeVarTransformations.add(type.priv.scopeId);
+                    replacementType = this.apply(replacementType, recursionCount);
+                    this._pendingTypeVarTransformations.delete(type.priv.scopeId);
                 }
             }
             return replacementType;
@@ -2818,12 +2659,12 @@ class TypeVarTransformer {
         if ((0, types_1.isUnion)(type)) {
             const newUnionType = mapSubtypes(type, (subtype) => {
                 let transformedType = this.apply(subtype, recursionCount);
-                // If we're transforming a variadic type variable within a union,
-                // combine the individual types within the variadic type variable.
+                // If we're transforming a TypeVarTuple within a union,
+                // combine the individual types within the TypeVarTuple.
                 if ((0, types_1.isTypeVarTuple)(subtype) && !(0, types_1.isTypeVarTuple)(transformedType)) {
                     const subtypesToCombine = [];
                     doForEachSubtype(transformedType, (transformedSubtype) => {
-                        subtypesToCombine.push(_expandVariadicUnpackedUnion(transformedSubtype));
+                        subtypesToCombine.push(_expandUnpackedTypeVarTupleUnion(transformedSubtype));
                     });
                     transformedType = (0, types_1.combineTypes)(subtypesToCombine);
                 }
@@ -2847,7 +2688,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;
@@ -2855,22 +2696,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;
     }
@@ -2880,13 +2730,10 @@ class TypeVarTransformer {
     transformTupleTypeVar(paramSpec, recursionCount) {
         return undefined;
     }
-    transformParamSpec(paramSpec, recursionCount) {
-        return undefined;
-    }
     transformUnionSubtype(preTransform, postTransform, recursionCount) {
         return postTransform;
     }
-    doForEachSolutionSet(callback) {
+    doForEachConstraintSet(callback) {
         // By default, simply return the result of the callback. Subclasses
         // can override this method as they see fit.
         return callback();
@@ -2905,15 +2752,14 @@ class TypeVarTransformer {
             }
             return updatedType;
         });
-        return requiresUpdate
-            ? types_1.TypeBase.cloneForTypeAlias(type, aliasInfo.name, aliasInfo.fullName, aliasInfo.moduleName, aliasInfo.fileUri, aliasInfo.typeVarScopeId, aliasInfo.isPep695Syntax, aliasInfo.typeParams, newTypeArgs)
-            : type;
+        return requiresUpdate ? types_1.TypeBase.cloneForTypeAlias(type, { ...aliasInfo, typeArgs: newTypeArgs }) : type;
     }
     transformConditionalType(type, recursionCount) {
         // By default, do not perform any transform.
         return type;
     }
     transformTypeVarsInClassType(classType, recursionCount) {
+        var _a;
         const typeParams = types_1.ClassType.getTypeParams(classType);
         // Handle the common case where the class has no type parameters.
         if (typeParams.length === 0 &&
@@ -2924,18 +2770,6 @@ class TypeVarTransformer {
         let newTypeArgs;
         let newTupleTypeArgs;
         let specializationNeeded = false;
-        const transformParamSpec = (paramSpec) => {
-            const paramSpecValue = this.transformParamSpec(paramSpec, recursionCount);
-            if (paramSpecValue) {
-                specializationNeeded = true;
-                return convertParamSpecValueToType(paramSpecValue);
-            }
-            else {
-                return paramSpec;
-            }
-        };
-        const wasTransformingTypeArg = this._isTransformingTypeArg;
-        this._isTransformingTypeArg = true;
         // If type args were previously provided, specialize them.
         // Handle tuples specially.
         if (types_1.ClassType.isTupleClass(classType)) {
@@ -2987,52 +2821,20 @@ class TypeVarTransformer {
             }
         }
         if (!newTypeArgs) {
-            if (classType.priv.typeArgs) {
-                newTypeArgs = classType.priv.typeArgs.map((oldTypeArgType) => {
-                    if ((0, types_1.isParamSpec)(oldTypeArgType)) {
-                        return transformParamSpec(oldTypeArgType);
-                    }
-                    let newTypeArgType = this.apply(oldTypeArgType, recursionCount);
-                    if (newTypeArgType !== oldTypeArgType) {
-                        specializationNeeded = true;
-                        // If this was a variadic type variable that was part of a union
-                        // (e.g. Union[Unpack[Vs]]), expand the subtypes into a union here.
-                        if ((0, types_1.isTypeVar)(oldTypeArgType) &&
-                            (0, types_1.isTypeVarTuple)(oldTypeArgType) &&
-                            oldTypeArgType.priv.isVariadicInUnion) {
-                            newTypeArgType = _expandVariadicUnpackedUnion(newTypeArgType);
-                        }
-                    }
-                    return newTypeArgType;
-                });
-            }
-            else {
-                newTypeArgs = [];
-                typeParams.forEach((typeParam) => {
-                    let replacementType = typeParam;
-                    if ((0, types_1.isParamSpec)(typeParam)) {
-                        replacementType = transformParamSpec(typeParam);
-                        if (replacementType !== typeParam) {
-                            specializationNeeded = true;
-                        }
-                    }
-                    else {
-                        if (!this._isTypeVarScopePending(typeParam.priv.scopeId)) {
-                            const transformedType = this.transformTypeVar(typeParam, recursionCount);
-                            replacementType = transformedType !== null && transformedType !== void 0 ? transformedType : typeParam;
-                            if (replacementType !== typeParam) {
-                                specializationNeeded = true;
-                            }
-                            else if (transformedType !== undefined && !classType.priv.typeArgs) {
-                                specializationNeeded = true;
-                            }
-                        }
+            const typeArgs = (_a = classType.priv.typeArgs) !== null && _a !== void 0 ? _a : typeParams;
+            newTypeArgs = typeArgs.map((oldTypeArgType) => {
+                let newTypeArgType = this.apply(oldTypeArgType, recursionCount);
+                if (newTypeArgType !== oldTypeArgType) {
+                    specializationNeeded = true;
+                    // If this was a TypeVarTuple that was part of a union
+                    // (e.g. Union[Unpack[Vs]]), expand the subtypes into a union here.
+                    if ((0, types_1.isTypeVar)(oldTypeArgType) && (0, types_1.isTypeVarTuple)(oldTypeArgType) && oldTypeArgType.priv.isInUnion) {
+                        newTypeArgType = _expandUnpackedTypeVarTupleUnion(newTypeArgType);
                     }
-                    newTypeArgs.push(replacementType);
-                });
-            }
+                }
+                return newTypeArgType;
+            });
         }
-        this._isTransformingTypeArg = wasTransformingTypeArg;
         // If specialization wasn't needed, don't allocate a new class.
         if (!specializationNeeded) {
             return classType;
@@ -3042,7 +2844,7 @@ class TypeVarTransformer {
         /* includeSubclasses */ undefined, newTupleTypeArgs);
     }
     transformTypeVarsInFunctionType(sourceType, recursionCount) {
-        return this.doForEachSolutionSet(() => {
+        return this.doForEachConstraintSet(() => {
             let functionType = sourceType;
             const declaredReturnType = types_1.FunctionType.getEffectiveReturnType(functionType);
             const specializedReturnType = declaredReturnType
@@ -3051,32 +2853,31 @@ class TypeVarTransformer {
             let typesRequiredSpecialization = declaredReturnType !== specializedReturnType;
             const specializedParams = {
                 parameterTypes: [],
-                parameterDefaultArgs: undefined,
+                parameterDefaultTypes: undefined,
                 returnType: specializedReturnType,
             };
             const paramSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(functionType);
             if (paramSpec) {
-                const paramSpecType = this.transformParamSpec(paramSpec, recursionCount);
+                const paramSpecType = this.transformTypeVar(paramSpec, recursionCount);
                 if (paramSpecType) {
-                    const transformedParamSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(paramSpecType);
-                    if (paramSpecType.shared.parameters.length > 0 ||
+                    const paramSpecValue = convertTypeToParamSpecValue(paramSpecType);
+                    const transformedParamSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(paramSpecValue);
+                    if (paramSpecValue.shared.parameters.length > 0 ||
                         !transformedParamSpec ||
                         !(0, types_1.isTypeSame)(paramSpec, transformedParamSpec)) {
-                        functionType = types_1.FunctionType.applyParamSpecValue(functionType, paramSpecType);
+                        functionType = types_1.FunctionType.applyParamSpecValue(functionType, paramSpecValue);
                     }
                 }
             }
             let variadicParamIndex;
             let variadicTypesToUnpack;
             const specializedDefaultArgs = [];
-            const wasTransformingTypeArg = this._isTransformingTypeArg;
-            this._isTransformingTypeArg = true;
             for (let i = 0; i < functionType.shared.parameters.length; i++) {
-                const paramType = types_1.FunctionType.getEffectiveParamType(functionType, i);
+                const paramType = types_1.FunctionType.getParamType(functionType, i);
                 const specializedType = this.apply(paramType, recursionCount);
                 specializedParams.parameterTypes.push(specializedType);
                 // Do we need to specialize the default argument type for this parameter?
-                let defaultArgType = types_1.FunctionType.getEffectiveParamDefaultArgType(functionType, i);
+                let defaultArgType = types_1.FunctionType.getParamDefaultType(functionType, i);
                 if (defaultArgType) {
                     const specializedArgType = this.apply(defaultArgType, recursionCount);
                     if (specializedArgType !== defaultArgType) {
@@ -3121,12 +2922,11 @@ class TypeVarTransformer {
                     functionType.priv.strippedFirstParamType = newStrippedType;
                 }
             }
-            this._isTransformingTypeArg = wasTransformingTypeArg;
             if (!typesRequiredSpecialization) {
                 return functionType;
             }
             if (specializedDefaultArgs.some((t) => t !== undefined)) {
-                specializedParams.parameterDefaultArgs = specializedDefaultArgs;
+                specializedParams.parameterDefaultTypes = specializedDefaultArgs;
             }
             // If there was no unpacked variadic type variable, we're done.
             if (!variadicTypesToUnpack) {
@@ -3158,7 +2958,7 @@ class TypeVarTransformer {
                     }
                 }
                 else {
-                    const param = { ...functionType.shared.parameters[index] };
+                    const param = functionType.shared.parameters[index];
                     if ((0, types_1.isKeywordOnlySeparator)(param)) {
                         insertKeywordOnlySeparator = false;
                     }
@@ -3166,17 +2966,15 @@ class TypeVarTransformer {
                         insertKeywordOnlySeparator = false;
                     }
                     // Insert a keyword-only separator parameter if we previously
-                    // unpacked a variadic TypeVar.
+                    // unpacked a TypeVarTuple.
                     if (param.category === 0 /* ParamCategory.Simple */ && param.name && insertKeywordOnlySeparator) {
                         types_1.FunctionType.addKeywordOnlyParamSeparator(newFunctionType);
                         insertKeywordOnlySeparator = false;
                     }
-                    param.type = paramType;
-                    if (param.name && types_1.FunctionParam.isNameSynthesized(param)) {
-                        param.name = `__p${newFunctionType.shared.parameters.length}`;
-                    }
                     if (param.category !== 0 /* ParamCategory.Simple */ || param.name || !swallowPositionOnlySeparator) {
-                        types_1.FunctionType.addParam(newFunctionType, param);
+                        types_1.FunctionType.addParam(newFunctionType, types_1.FunctionParam.create(param.category, paramType, param.flags, param.name && types_1.FunctionParam.isNameSynthesized(param)
+                            ? `__p${newFunctionType.shared.parameters.length}`
+                            : param.name, types_1.FunctionType.getParamDefaultType(functionType, index)));
                     }
                 }
             });
@@ -3188,18 +2986,7 @@ class TypeVarTransformer {
         return !!typeVarScopeId && this._pendingTypeVarTransformations.has(typeVarScopeId);
     }
 }
-// Converts all type variables to Any.
-class TypeVarAnyReplacer extends TypeVarTransformer {
-    constructor() {
-        super();
-    }
-    transformTypeVar(typeVar) {
-        return types_1.AnyType.create();
-    }
-    transformParamSpec(paramSpec) {
-        return types_1.ParamSpecType.getUnknown();
-    }
-}
+exports.TypeVarTransformer = TypeVarTransformer;
 // For a TypeVar with a default type, validates whether the default type is using
 // any other TypeVars that are not currently in scope.
 class TypeVarDefaultValidator extends TypeVarTransformer {
@@ -3210,18 +2997,11 @@ class TypeVarDefaultValidator extends TypeVarTransformer {
     }
     transformTypeVar(typeVar) {
         const replacementType = this._liveTypeParams.find((param) => param.shared.name === typeVar.shared.name);
-        if (!replacementType || (0, types_1.isParamSpec)(replacementType)) {
+        if (!replacementType || (0, types_1.isParamSpec)(replacementType) !== (0, types_1.isParamSpec)(typeVar)) {
             this._invalidTypeVars.add(typeVar.shared.name);
         }
         return types_1.UnknownType.create();
     }
-    transformParamSpec(paramSpec) {
-        const replacementType = this._liveTypeParams.find((param) => param.shared.name === paramSpec.shared.name);
-        if (!replacementType || !(0, types_1.isParamSpec)(replacementType)) {
-            this._invalidTypeVars.add(paramSpec.shared.name);
-        }
-        return undefined;
-    }
 }
 class UniqueFunctionSignatureTransformer extends TypeVarTransformer {
     constructor(_signatureTracker, _expressionOffset) {
@@ -3250,26 +3030,27 @@ class UniqueFunctionSignatureTransformer extends TypeVarTransformer {
                 offsetIndex = existingSignature.expressionOffsets.length;
             }
             if (offsetIndex > 0) {
-                const typeVarContext = new typeVarContext_1.TypeVarContext(getTypeVarScopeIds(sourceType));
+                const solution = new constraintSolution_1.ConstraintSolution();
                 // Create new type variables with the same scope but with
                 // different (unique) names.
                 sourceType.shared.typeParams.forEach((typeParam) => {
                     if (typeParam.priv.scopeType === 1 /* TypeVarScopeType.Function */) {
                         const replacement = types_1.TypeVarType.cloneForNewName(typeParam, `${typeParam.shared.name}(${offsetIndex})`);
-                        setTypeVarType(typeVarContext, typeParam, replacement);
+                        solution.setType(typeParam, replacement);
                     }
                 });
-                updatedSourceType = applySolvedTypeVars(sourceType, typeVarContext);
-                (0, debug_1.assert)((0, types_1.isFunction)(updatedSourceType) || (0, types_1.isOverloadedFunction)(updatedSourceType));
+                updatedSourceType = applySolvedTypeVars(sourceType, solution);
+                (0, debug_1.assert)((0, types_1.isFunction)(updatedSourceType) || (0, types_1.isOverloaded)(updatedSourceType));
             }
         }
         this._signatureTracker.addSignature(sourceType, this._expressionOffset);
         return updatedSourceType;
     }
 }
-// Replaces the TypeVars within a type with their corresponding "internal"
-// types if they are in one of the specified scopes.
-class InternalScopeUpdateTransform extends TypeVarTransformer {
+// Replaces the free type vars within a type with their corresponding bound
+// type vars if they are in one of the specified scopes. If undefined is
+// passed for the scopeIds list, all free type vars are replaced.
+class BoundTypeVarTransform extends TypeVarTransformer {
     constructor(_scopeIds) {
         super();
         this._scopeIds = _scopeIds;
@@ -3280,35 +3061,30 @@ class InternalScopeUpdateTransform extends TypeVarTransformer {
         }
         return undefined;
     }
-    transformParamSpec(paramSpec) {
-        if (this._isTypeVarInScope(paramSpec)) {
-            return convertTypeToParamSpecValue(this._replaceTypeVar(paramSpec));
-        }
-        return undefined;
-    }
     _isTypeVarInScope(typeVar) {
-        return typeVar.priv.scopeId !== undefined && this._scopeIds.includes(typeVar.priv.scopeId);
+        if (!typeVar.priv.scopeId) {
+            return false;
+        }
+        // If no scopeIds were specified, transform all Type Vars.
+        if (!this._scopeIds) {
+            return true;
+        }
+        return this._scopeIds.includes(typeVar.priv.scopeId);
     }
     _replaceTypeVar(typeVar) {
-        return types_1.TypeVarType.cloneWithInternalScopeId(typeVar);
+        return types_1.TypeVarType.cloneAsBound(typeVar);
     }
 }
-// Replaces the internal TypeVars within a type with their corresponding
-// "external" types.
-class ExternalScopeUpdateTransform extends TypeVarTransformer {
+// Replaces the bound type vars within a type with their corresponding
+// free type vars.
+class FreeTypeVarTransform extends TypeVarTransformer {
     constructor(_scopeIds) {
         super();
         this._scopeIds = _scopeIds;
     }
     transformTypeVar(typeVar) {
-        if (typeVar.priv.externalTypeVar && this._isTypeVarInScope(typeVar.priv.externalTypeVar)) {
-            return typeVar.priv.externalTypeVar;
-        }
-        return undefined;
-    }
-    transformParamSpec(paramSpec) {
-        if (paramSpec.priv.externalTypeVar && this._isTypeVarInScope(paramSpec.priv.externalTypeVar)) {
-            return convertTypeToParamSpecValue(paramSpec.priv.externalTypeVar);
+        if (typeVar.priv.freeTypeVar && this._isTypeVarInScope(typeVar.priv.freeTypeVar)) {
+            return typeVar.priv.freeTypeVar;
         }
         return undefined;
     }
@@ -3322,144 +3098,120 @@ class ExternalScopeUpdateTransform extends TypeVarTransformer {
 // Specializes a (potentially generic) type by substituting
 // type variables from a type var map.
 class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
-    constructor(_typeVarContext, _options) {
+    constructor(_solution, _options) {
         super();
-        this._typeVarContext = _typeVarContext;
+        this._solution = _solution;
         this._options = _options;
         this._isSolvingDefaultType = false;
     }
     transformTypeVar(typeVar, recursionCount) {
-        var _a, _b;
-        const solutionSet = this._typeVarContext.getSolutionSet((_a = this._activeSolutionSetIndex) !== null && _a !== void 0 ? _a : 0);
-        // If the type variable is unrelated to the scopes we're solving,
-        // don't transform that type variable.
-        if (typeVar.priv.scopeId && this._typeVarContext.hasSolveForScope(typeVar.priv.scopeId)) {
-            let replacement = solutionSet.getTypeVarType(typeVar, !!this._options.useLowerBoundOnly);
-            // If there was no lower bound but there is an upper bound that
-            // contains literals or a TypeVar, we'll use the upper bound even if
-            // "useLowerBoundOnly" is specified.
-            if (!replacement && this._options.useLowerBoundOnly) {
-                const wideType = solutionSet.getTypeVarType(typeVar);
-                if (wideType) {
-                    if ((0, types_1.isTypeVar)(wideType) || containsLiteralType(wideType, /* includeTypeArgs */ true)) {
-                        replacement = wideType;
-                    }
-                }
-            }
+        var _a, _b, _c;
+        const solutionSet = this._solution.getSolutionSet((_a = this._activeConstraintSetIndex) !== null && _a !== void 0 ? _a : 0);
+        // If we're solving a default type, handle type variables with no scope ID.
+        if (this._isSolvingDefaultType && !typeVar.priv.scopeId) {
+            const replacement = this._getReplacementForDefaultByName(typeVar, solutionSet);
             if (replacement) {
-                if (types_1.TypeBase.isInstantiable(typeVar)) {
-                    if ((0, types_1.isAnyOrUnknown)(replacement) &&
-                        this._options.typeClassType &&
-                        (0, types_1.isInstantiableClass)(this._options.typeClassType)) {
-                        replacement = types_1.ClassType.specialize(types_1.ClassType.cloneAsInstance(this._options.typeClassType), [
-                            replacement,
-                        ]);
-                    }
-                    else {
-                        replacement = convertToInstantiable(replacement, /* includeSubclasses */ false);
-                    }
+                return replacement;
+            }
+            if (typeVar.shared.isDefaultExplicit) {
+                return this.apply(typeVar.shared.defaultType, recursionCount);
+            }
+            return types_1.UnknownType.create();
+        }
+        if (!this._shouldReplaceTypeVar(typeVar)) {
+            return undefined;
+        }
+        let replacement = solutionSet.getType(typeVar);
+        if (replacement) {
+            // No more processing is needed for ParamSpecs.
+            if ((0, types_1.isParamSpec)(typeVar)) {
+                return replacement;
+            }
+            if (types_1.TypeBase.isInstantiable(typeVar)) {
+                if ((0, types_1.isAnyOrUnknown)(replacement) &&
+                    this._options.typeClassType &&
+                    (0, types_1.isInstantiableClass)(this._options.typeClassType)) {
+                    replacement = types_1.ClassType.specialize(types_1.ClassType.cloneAsInstance(this._options.typeClassType), [
+                        replacement,
+                    ]);
                 }
                 else {
-                    // If the TypeVar is not instantiable (i.e. not a type[T]), then
-                    // it represents an instance of a type. If the replacement includes
-                    // a generic class that has not been specialized, specialize it
-                    // now with default type arguments.
-                    replacement = mapSubtypes(replacement, (subtype) => {
-                        if ((0, types_1.isClassInstance)(subtype)) {
-                            // If the includeSubclasses wasn't set, force it to be set by
-                            // converting to/from an instantiable.
-                            if (!subtype.priv.includeSubclasses) {
-                                subtype = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneAsInstantiable(subtype));
-                            }
-                            if (subtype.shared.typeParams && !subtype.priv.typeArgs) {
-                                if (this._options.unknownIfNotFound) {
-                                    return this._options.useUnknownOverDefault
-                                        ? specializeWithUnknownTypeArgs(subtype, this._options.tupleClassType)
-                                        : specializeWithDefaultTypeArgs(subtype);
-                                }
+                    replacement = convertToInstantiable(replacement, /* includeSubclasses */ false);
+                }
+            }
+            else {
+                // If the TypeVar is not instantiable (i.e. not a type[T]), then
+                // it represents an instance of a type. If the replacement includes
+                // a generic class that has not been specialized, specialize it
+                // now with default type arguments.
+                replacement = mapSubtypes(replacement, (subtype) => {
+                    if ((0, types_1.isClassInstance)(subtype)) {
+                        // If the includeSubclasses wasn't set, force it to be set by
+                        // converting to/from an instantiable.
+                        if (!subtype.priv.includeSubclasses) {
+                            subtype = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneAsInstantiable(subtype));
+                        }
+                        if (subtype.shared.typeParams && !subtype.priv.typeArgs) {
+                            if (this._options.replaceUnsolved) {
+                                return this._options.replaceUnsolved.useUnknown
+                                    ? specializeWithUnknownTypeArgs(subtype, this._options.replaceUnsolved.tupleClassType)
+                                    : specializeWithDefaultTypeArgs(subtype);
                             }
                         }
-                        return subtype;
-                    });
-                }
-                if ((0, types_1.isTypeVarTuple)(replacement) && (0, types_1.isTypeVarTuple)(typeVar) && typeVar.priv.isVariadicUnpacked) {
-                    return types_1.TypeVarType.cloneForUnpacked(replacement, typeVar.priv.isVariadicInUnion);
-                }
-                // If this isn't a variadic typeVar, combine all of the tuple
-                // type args into a common type.
-                if (!(0, types_1.isTypeVarTuple)(typeVar) &&
-                    (0, types_1.isClassInstance)(replacement) &&
-                    replacement.priv.tupleTypeArgs &&
-                    replacement.priv.isUnpacked) {
-                    replacement = combineTupleTypeArgs(replacement.priv.tupleTypeArgs);
-                }
-                if (!(0, types_1.isTypeVar)(replacement) ||
-                    !replacement.priv.isInScopePlaceholder ||
-                    !this._options.unknownIfNotFound) {
-                    return replacement;
-                }
+                    }
+                    return subtype;
+                });
             }
-            // If this typeVar is in scope for what we're solving but the type
-            // var map doesn't contain any entry for it, replace with the
-            // default or Unknown.
-            let useDefaultOrUnknown = false;
-            if (this._options.unknownIfNotFound) {
-                const exemptTypeVars = (_b = this._options.unknownExemptTypeVars) !== null && _b !== void 0 ? _b : [];
-                const typeVarInstance = types_1.TypeBase.isInstance(typeVar) ? typeVar : types_1.TypeVarType.cloneAsInstance(typeVar);
-                if (!exemptTypeVars.some((t) => (0, types_1.isTypeSame)(t, typeVarInstance))) {
-                    useDefaultOrUnknown = true;
-                }
+            if ((0, types_1.isTypeVarTuple)(replacement) && (0, types_1.isTypeVarTuple)(typeVar) && typeVar.priv.isUnpacked) {
+                return types_1.TypeVarType.cloneForUnpacked(replacement, typeVar.priv.isInUnion);
             }
-            else if (this._options.applyInScopePlaceholders && typeVar.priv.isInScopePlaceholder) {
-                useDefaultOrUnknown = true;
+            // If this isn't a TypeVarTuple, combine all of the tuple
+            // type args into a common type.
+            if (!(0, types_1.isTypeVarTuple)(typeVar) &&
+                (0, types_1.isClassInstance)(replacement) &&
+                replacement.priv.tupleTypeArgs &&
+                replacement.priv.isUnpacked) {
+                replacement = combineTupleTypeArgs(replacement.priv.tupleTypeArgs);
             }
-            if (useDefaultOrUnknown) {
-                // Use the default value if there is one.
-                if (typeVar.shared.isDefaultExplicit && !this._options.useUnknownOverDefault) {
-                    return this._solveDefaultType(typeVar, recursionCount);
-                }
-                return getUnknownForTypeVar(typeVar, this._options.tupleClassType);
+            if (!(0, types_1.isTypeVar)(replacement) || !types_1.TypeVarType.isUnification(replacement) || !this._options.replaceUnsolved) {
+                return replacement;
             }
         }
-        // If we're solving a default type, handle type variables with no scope ID.
-        if (this._isSolvingDefaultType && !typeVar.priv.scopeId) {
-            const replacementEntry = solutionSet
-                .getTypeVars()
-                .find((entry) => entry.typeVar.shared.name === typeVar.shared.name);
-            if (replacementEntry) {
-                return solutionSet.getTypeVarType(replacementEntry.typeVar);
-            }
-            if (typeVar.shared.isDefaultExplicit) {
-                return this.apply(typeVar.shared.defaultType, recursionCount);
-            }
-            return types_1.UnknownType.create();
+        if (!this._shouldReplaceUnsolvedTypeVar(typeVar)) {
+            return undefined;
         }
-        return undefined;
+        // Use the default value if there is one.
+        if (typeVar.shared.isDefaultExplicit && !((_b = this._options.replaceUnsolved) === null || _b === void 0 ? void 0 : _b.useUnknown)) {
+            return this._solveDefaultType(typeVar, recursionCount);
+        }
+        return getUnknownForTypeVar(typeVar, (_c = this._options.replaceUnsolved) === null || _c === void 0 ? void 0 : _c.tupleClassType);
     }
     transformUnionSubtype(preTransform, postTransform) {
-        var _a;
+        var _a, _b;
         // If a union contains unsolved TypeVars within scope, eliminate them
         // unless this results in an empty union. This elimination is needed
         // in cases where TypeVars can go unsolved due to unions in parameter
         // annotations, like this:
         //   def test(x: Union[str, T]) -> Union[str, T]
-        if (this._options.eliminateUnsolvedInUnions) {
+        if ((_a = this._options.replaceUnsolved) === null || _a === void 0 ? void 0 : _a.eliminateUnsolvedInUnions) {
             if ((0, types_1.isTypeVar)(preTransform) &&
-                preTransform.priv.scopeId !== undefined &&
-                this._typeVarContext.hasSolveForScope(preTransform.priv.scopeId)) {
-                const solutionSet = this._typeVarContext.getSolutionSet((_a = this._activeSolutionSetIndex) !== null && _a !== void 0 ? _a : 0);
-                const typeVarType = solutionSet.getTypeVarType(preTransform);
+                this._shouldReplaceTypeVar(preTransform) &&
+                this._shouldReplaceUnsolvedTypeVar(preTransform)) {
+                const solutionSet = this._solution.getSolutionSet((_b = this._activeConstraintSetIndex) !== null && _b !== void 0 ? _b : 0);
+                const typeVarType = solutionSet.getType(preTransform);
                 // Did the TypeVar remain unsolved?
-                if (!typeVarType || ((0, types_1.isTypeVar)(typeVarType) && typeVarType.priv.isInScopePlaceholder)) {
+                if (!typeVarType || ((0, types_1.isTypeVar)(typeVarType) && types_1.TypeVarType.isUnification(typeVarType))) {
                     // If the TypeVar was not transformed, then it was unsolved,
                     // and we'll eliminate it.
                     if (preTransform === postTransform) {
                         return undefined;
                     }
-                    // If unknownIfNotFound is true, the postTransform type will
+                    // If useDefaultForUnsolved or useUnknownForUnsolved is true, the postTransform type will
                     // be Unknown, which we want to eliminate.
-                    if ((0, types_1.isUnknown)(postTransform) && this._options.unknownIfNotFound) {
-                        return undefined;
+                    if (this._options.replaceUnsolved) {
+                        if ((0, types_1.isUnknown)(postTransform)) {
+                            return undefined;
+                        }
                     }
                 }
             }
@@ -3468,84 +3220,41 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
     }
     transformTupleTypeVar(typeVar) {
         var _a;
-        if (!typeVar.priv.scopeId || !this._typeVarContext.hasSolveForScope(typeVar.priv.scopeId)) {
+        if (!this._shouldReplaceTypeVar(typeVar)) {
             const defaultType = typeVar.shared.defaultType;
             if (typeVar.shared.isDefaultExplicit && (0, types_1.isClassInstance)(defaultType) && defaultType.priv.tupleTypeArgs) {
                 return defaultType.priv.tupleTypeArgs;
             }
             return undefined;
         }
-        const solutionSet = this._typeVarContext.getSolutionSet((_a = this._activeSolutionSetIndex) !== null && _a !== void 0 ? _a : 0);
-        const value = solutionSet.getTypeVarType(typeVar);
+        const solutionSet = this._solution.getSolutionSet((_a = this._activeConstraintSetIndex) !== null && _a !== void 0 ? _a : 0);
+        const value = solutionSet.getType(typeVar);
         if (value && (0, types_1.isClassInstance)(value) && value.priv.tupleTypeArgs && (0, types_1.isUnpackedClass)(value)) {
             return value.priv.tupleTypeArgs;
         }
         return undefined;
     }
-    transformParamSpec(paramSpec, recursionCount) {
-        var _a, _b;
-        const solutionSet = this._typeVarContext.getSolutionSet((_a = this._activeSolutionSetIndex) !== null && _a !== void 0 ? _a : 0);
-        // If we're solving a default type, handle param specs with no scope ID.
-        if (this._isSolvingDefaultType && !paramSpec.priv.scopeId) {
-            const replacementEntry = solutionSet
-                .getTypeVars()
-                .find((entry) => entry.typeVar.shared.name === paramSpec.shared.name);
-            if (replacementEntry && (0, types_1.isParamSpec)(replacementEntry.typeVar)) {
-                return solutionSet.getTypeVarType(replacementEntry.typeVar);
-            }
-            if (paramSpec.shared.isDefaultExplicit) {
-                return convertTypeToParamSpecValue(this.apply(paramSpec.shared.defaultType, recursionCount));
-            }
-            return types_1.ParamSpecType.getUnknown();
-        }
-        if (!paramSpec.priv.scopeId || !this._typeVarContext.hasSolveForScope(paramSpec.priv.scopeId)) {
-            return undefined;
-        }
-        const transformedParamSpec = solutionSet.getTypeVarType(paramSpec);
-        if (transformedParamSpec) {
-            return transformedParamSpec;
-        }
-        let useDefaultOrUnknown = false;
-        if (this._options.unknownIfNotFound) {
-            const exemptTypeVars = (_b = this._options.unknownExemptTypeVars) !== null && _b !== void 0 ? _b : [];
-            if (!exemptTypeVars.some((t) => (0, types_1.isTypeSame)(t, paramSpec, { ignoreTypeFlags: true }))) {
-                useDefaultOrUnknown = true;
-            }
-        }
-        else if (this._options.applyInScopePlaceholders && paramSpec.priv.isInScopePlaceholder) {
-            useDefaultOrUnknown = true;
-        }
-        if (useDefaultOrUnknown) {
-            // Use the default value if there is one.
-            if (paramSpec.shared.isDefaultExplicit && !this._options.useUnknownOverDefault) {
-                return convertTypeToParamSpecValue(this._solveDefaultType(paramSpec, recursionCount));
-            }
-            // Convert to the ParamSpec equivalent of "Unknown".
-            return types_1.ParamSpecType.getUnknown();
-        }
-        return undefined;
-    }
     transformConditionalType(type, recursionCount) {
         var _a, _b, _c, _d;
         if (!((_a = type.props) === null || _a === void 0 ? void 0 : _a.condition)) {
             return type;
         }
-        const solutionSet = this._typeVarContext.getSolutionSet((_b = this._activeSolutionSetIndex) !== null && _b !== void 0 ? _b : 0);
+        const solutionSet = this._solution.getSolutionSet((_b = this._activeConstraintSetIndex) !== null && _b !== void 0 ? _b : 0);
         for (const condition of type.props.condition) {
             // This doesn't apply to bound type variables.
-            if (condition.typeVar.shared.constraints.length === 0) {
+            if (!types_1.TypeVarType.hasConstraints(condition.typeVar)) {
                 continue;
             }
-            const conditionTypeVar = (_d = (_c = condition.typeVar.priv) === null || _c === void 0 ? void 0 : _c.externalTypeVar) !== null && _d !== void 0 ? _d : condition.typeVar;
-            const typeVarEntry = solutionSet.getTypeVar(conditionTypeVar);
-            if (!typeVarEntry || condition.constraintIndex >= typeVarEntry.typeVar.shared.constraints.length) {
+            const conditionTypeVar = (_d = (_c = condition.typeVar.priv) === null || _c === void 0 ? void 0 : _c.freeTypeVar) !== null && _d !== void 0 ? _d : condition.typeVar;
+            const replacement = solutionSet.getType(conditionTypeVar);
+            if (!replacement || condition.constraintIndex >= conditionTypeVar.shared.constraints.length) {
                 continue;
             }
-            const value = solutionSet.getTypeVarType(typeVarEntry.typeVar);
+            const value = solutionSet.getType(conditionTypeVar);
             if (!value) {
                 continue;
             }
-            const constraintType = typeVarEntry.typeVar.shared.constraints[condition.constraintIndex];
+            const constraintType = conditionTypeVar.shared.constraints[condition.constraintIndex];
             // If this violates the constraint, substitute a Never type.
             if (!(0, types_1.isTypeSame)(constraintType, value)) {
                 return types_1.NeverType.createNever();
@@ -3553,19 +3262,19 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         }
         return type;
     }
-    doForEachSolutionSet(callback) {
-        const solutionSet = this._typeVarContext.getSolutionSets();
+    doForEachConstraintSet(callback) {
+        const solutionSets = this._solution.getSolutionSets();
         // Handle the common case where there are not multiple signature contexts.
-        if (solutionSet.length <= 1) {
+        if (solutionSets.length <= 1) {
             return callback();
         }
         // Loop through all of the signature contexts in the type var context
         // to create an overload type.
-        const overloadTypes = solutionSet.map((_, index) => {
-            this._activeSolutionSetIndex = index;
+        const overloadTypes = solutionSets.map((_, index) => {
+            this._activeConstraintSetIndex = index;
             return callback();
         });
-        this._activeSolutionSetIndex = undefined;
+        this._activeConstraintSetIndex = undefined;
         const filteredOverloads = [];
         doForEachSubtype((0, types_1.combineTypes)(overloadTypes), (subtype) => {
             (0, debug_1.assert)((0, types_1.isFunction)(subtype));
@@ -3575,7 +3284,51 @@ 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
+    // look it up by name in the solution set. This is a bit hacky because there
+    // could be multiple typeVars with the same name, but we'll assume that this
+    // won't happen.
+    _getReplacementForDefaultByName(typeVar, solutionSet) {
+        let replacementValue;
+        const partialScopeId = `${typeVar.shared.name}.`;
+        solutionSet.doForEachTypeVar((value, typeVarId) => {
+            if (typeVarId.startsWith(partialScopeId)) {
+                replacementValue = value;
+            }
+        });
+        return replacementValue;
+    }
+    _shouldReplaceTypeVar(typeVar) {
+        if (!typeVar.priv.scopeId || types_1.TypeVarType.isBound(typeVar)) {
+            return false;
+        }
+        return true;
+    }
+    _shouldReplaceUnsolvedTypeVar(typeVar) {
+        var _a;
+        // Never replace nested TypeVars with unknown.
+        if (this.pendingTypeVarTransformations.size > 0) {
+            return false;
+        }
+        if (!typeVar.priv.scopeId) {
+            return false;
+        }
+        if (!this._options.replaceUnsolved) {
+            return false;
+        }
+        if (!this._options.replaceUnsolved.scopeIds.includes(typeVar.priv.scopeId)) {
+            return false;
+        }
+        const exemptTypeVars = (_a = this._options.replaceUnsolved) === null || _a === void 0 ? void 0 : _a.unsolvedExemptTypeVars;
+        if (exemptTypeVars) {
+            if (exemptTypeVars.some((t) => (0, types_1.isTypeSame)(t, typeVar, { ignoreTypeFlags: true }))) {
+                return false;
+            }
+        }
+        return true;
     }
     _solveDefaultType(typeVar, recursionCount) {
         const defaultType = typeVar.shared.defaultType;
@@ -3594,46 +3347,12 @@ class ExpectedTypeTransformer extends TypeVarTransformer {
     }
     transformTypeVar(typeVar) {
         if (!this._isTypeVarLive(typeVar)) {
-            return types_1.TypeVarType.cloneAsInScopePlaceholder(typeVar, this._usageOffset);
-        }
-        return undefined;
-    }
-    transformParamSpec(paramSpec) {
-        if (!this._isTypeVarLive(paramSpec)) {
-            return convertTypeToParamSpecValue(types_1.TypeVarType.cloneAsInScopePlaceholder(paramSpec, this._usageOffset));
+            return types_1.TypeVarType.cloneAsUnificationVar(typeVar, this._usageOffset);
         }
         return undefined;
     }
     _isTypeVarLive(typeVar) {
-        return this._liveTypeVarScopes.some((scopeId) => { var _a; return typeVar.priv.scopeId === scopeId || ((_a = typeVar.priv.externalTypeVar) === null || _a === void 0 ? void 0 : _a.priv.scopeId) === scopeId; });
-    }
-}
-class InScopePlaceholderTransformer extends TypeVarTransformer {
-    constructor(_solutionSet) {
-        super();
-        this._solutionSet = _solutionSet;
+        return this._liveTypeVarScopes.some((scopeId) => { var _a; return typeVar.priv.scopeId === scopeId || ((_a = typeVar.priv.freeTypeVar) === null || _a === void 0 ? void 0 : _a.priv.scopeId) === scopeId; });
     }
-    transformTypeVar(typeVar) {
-        var _a;
-        if (typeVar.priv.isInScopePlaceholder) {
-            return (_a = this._solutionSet.getTypeVarType(typeVar)) !== null && _a !== void 0 ? _a : typeVar;
-        }
-        return undefined;
-    }
-    transformParamSpec(paramSpec) {
-        if (paramSpec.priv.isInScopePlaceholder) {
-            return this._solutionSet.getTypeVarType(paramSpec);
-        }
-        return undefined;
-    }
-}
-function applyInScopePlaceholdersToType(type, solutionSet) {
-    // Handle the common case where there are no in-scope placeholders.
-    // No more work is required in this case.
-    if (!solutionSet.getTypeVars().some((entry) => entry.typeVar.priv.isInScopePlaceholder)) {
-        return type;
-    }
-    const transformer = new InScopePlaceholderTransformer(solutionSet);
-    return transformer.apply(type, 0);
 }
 //# sourceMappingURL=typeUtils.js.map