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

package/dist/analyzer/types.js

@@ -8,9 +8,10 @@
  * Representation of types used during type analysis within Python.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.removeUnbound = exports.removeUnknownFromUnion = exports.isTypeSame = exports.getTypeAliasInfo = exports.isOverloadedFunction = exports.isFunction = exports.isUnpacked = exports.isUnpackedClass = exports.isUnpackedTypeVarTuple = exports.isTypeVarTuple = exports.isParamSpec = exports.isTypeVar = exports.isModule = exports.isClassInstance = exports.isInstantiableClass = exports.isClass = exports.isPossiblyUnbound = exports.isUnion = exports.isUnbound = exports.isAnyOrUnknown = exports.isUnknown = exports.isAny = exports.isNever = exports.TypeVarType = exports.ParamSpecType = exports.TypeVarScopeType = exports.TypeVarKind = exports.Variance = exports.UnionType = exports.TypeCondition = exports.AnyType = exports.NeverType = exports.OverloadedFunctionType = exports.FunctionType = exports.FunctionTypeFlags = exports.isKeywordOnlySeparator = exports.isPositionOnlySeparator = exports.FunctionParam = exports.FunctionParamFlags = exports.ClassType = exports.ClassTypeFlags = exports.ModuleType = exports.UnknownType = exports.UnboundType = exports.TypeBase = exports.maxTypeRecursionCount = exports.EnumLiteral = exports.InScopePlaceholderScopeId = exports.TypeFlags = exports.TypeCategory = void 0;
+exports.removeUnbound = exports.removeUnknownFromUnion = exports.isTypeSame = exports.getTypeAliasInfo = exports.isOverloadedFunction = exports.isFunction = exports.isUnpacked = exports.isUnpackedClass = exports.isUnpackedTypeVarTuple = exports.isTypeVarTuple = exports.isParamSpec = exports.isTypeVar = exports.isModule = exports.isClassInstance = exports.isInstantiableClass = exports.isClass = exports.isPossiblyUnbound = exports.isUnion = exports.isUnbound = exports.isAnyOrUnknown = exports.isUnknown = exports.isAny = exports.isNever = exports.TypeVarType = exports.ParamSpecType = exports.TypeVarScopeType = exports.TypeVarKind = exports.Variance = exports.UnionType = exports.TypeCondition = exports.AnyType = exports.NeverType = exports.OverloadedFunctionType = exports.FunctionType = exports.FunctionTypeFlags = exports.isKeywordOnlySeparator = exports.isPositionOnlySeparator = exports.FunctionParam = exports.FunctionParamFlags = exports.ClassType = exports.ClassTypeFlags = exports.ModuleType = exports.UnknownType = exports.UnboundType = exports.TypeBase = exports.maxTypeRecursionCount = exports.EnumLiteral = exports.UnificationScopeId = exports.TypeFlags = exports.TypeCategory = void 0;
 exports.isSameWithoutLiteralValue = exports.combineTypes = exports.findSubtype = exports.removeFromUnion = void 0;
 const debug_1 = require("../common/debug");
+const typeUtils_1 = require("./typeUtils");
 var TypeCategory;
 (function (TypeCategory) {
     // Name is not bound to a value of any type.
@@ -54,7 +55,7 @@ var TypeFlags;
     // when comparing two types for equivalence.
     TypeFlags[TypeFlags["TypeCompatibilityMask"] = 3] = "TypeCompatibilityMask";
 })(TypeFlags || (exports.TypeFlags = TypeFlags = {}));
-exports.InScopePlaceholderScopeId = '-';
+exports.UnificationScopeId = '-';
 class EnumLiteral {
     constructor(classFullName, className, itemName, itemType) {
         this.classFullName = classFullName;
@@ -186,19 +187,9 @@ var TypeBase;
         return newInstance;
     }
     TypeBase.cloneTypeAsInstantiable = cloneTypeAsInstantiable;
-    function cloneForTypeAlias(type, name, fullName, moduleName, fileUri, typeVarScopeId, isPep695Syntax, typeParams, typeArgs) {
+    function cloneForTypeAlias(type, aliasInfo) {
         const typeClone = cloneType(type);
-        TypeBase.setTypeAliasInfo(typeClone, {
-            name,
-            fullName,
-            moduleName,
-            fileUri,
-            typeVarScopeId,
-            isPep695Syntax,
-            typeParams: typeParams,
-            usageVariance: undefined,
-            typeArgs: typeArgs,
-        });
+        TypeBase.setTypeAliasInfo(typeClone, aliasInfo);
         return typeClone;
     }
     TypeBase.cloneForTypeAlias = cloneForTypeAlias;
@@ -395,8 +386,7 @@ var ClassTypeFlags;
     // class is generic, and therefore supports standard subscripting
     // semantics.
     ClassTypeFlags[ClassTypeFlags["HasCustomClassGetItem"] = 16384] = "HasCustomClassGetItem";
-    // The tuple class uses a variadic type parameter and requires
-    // special-case handling of its type arguments.
+    // The tuple class requires special-case handling for its type arguments.
     ClassTypeFlags[ClassTypeFlags["TupleClass"] = 32768] = "TupleClass";
     // The class has a metaclass of EnumMeta or derives from
     // a class that has this metaclass.
@@ -969,7 +959,7 @@ var FunctionParamFlags;
 var FunctionParam;
 (function (FunctionParam) {
     function create(category, type, flags = FunctionParamFlags.None, name, defaultType) {
-        return { category, type, flags, name, defaultType };
+        return { category, flags, name, _type: type, _defaultType: defaultType };
     }
     FunctionParam.create = create;
     function isNameSynthesized(param) {
@@ -1092,14 +1082,16 @@ var FunctionType;
     }
     // Creates a deep copy of the function type, including a fresh
     // version of _functionDetails.
-    function clone(type, stripFirstParam = false, boundToType, boundTypeVarScopeId) {
+    function clone(type, stripFirstParam = false, boundToType) {
         var _a, _b;
         const newFunction = TypeBase.cloneType(type);
         newFunction.shared = { ...type.shared };
         newFunction.priv.preBoundFlags = newFunction.shared.flags;
         newFunction.priv.boundToType = boundToType;
-        if (boundTypeVarScopeId) {
-            newFunction.priv.constructorTypeVarScopeId = boundTypeVarScopeId;
+        if (boundToType) {
+            if (type.shared.name === '__new__' || type.shared.name === '__init__') {
+                newFunction.priv.constructorTypeVarScopeId = (0, typeUtils_1.getTypeVarScopeId)(boundToType);
+            }
         }
         if (stripFirstParam) {
             if (type.shared.parameters.length > 0) {
@@ -1107,7 +1099,7 @@ var FunctionType;
                     if (type.shared.parameters.length > 0 && !FunctionParam.isTypeInferred(type.shared.parameters[0])) {
                         // Stash away the effective type of the first parameter if it
                         // wasn't synthesized.
-                        newFunction.priv.strippedFirstParamType = getEffectiveParamType(type, 0);
+                        newFunction.priv.strippedFirstParamType = getParamType(type, 0);
                     }
                     newFunction.shared.parameters = type.shared.parameters.slice(1);
                 }
@@ -1128,9 +1120,9 @@ var FunctionType;
                 parameterTypes: stripFirstParam
                     ? type.priv.specializedTypes.parameterTypes.slice(1)
                     : type.priv.specializedTypes.parameterTypes,
-                parameterDefaultArgs: stripFirstParam
-                    ? (_b = type.priv.specializedTypes.parameterDefaultArgs) === null || _b === void 0 ? void 0 : _b.slice(1)
-                    : type.priv.specializedTypes.parameterDefaultArgs,
+                parameterDefaultTypes: stripFirstParam
+                    ? (_b = type.priv.specializedTypes.parameterDefaultTypes) === null || _b === void 0 ? void 0 : _b.slice(1)
+                    : type.priv.specializedTypes.parameterDefaultTypes,
                 returnType: type.priv.specializedTypes.returnType,
             };
         }
@@ -1165,8 +1157,8 @@ var FunctionType;
     function specialize(type, specializedTypes, specializedInferredReturnType) {
         const newFunction = TypeBase.cloneType(type);
         (0, debug_1.assert)(specializedTypes.parameterTypes.length === type.shared.parameters.length);
-        if (specializedTypes.parameterDefaultArgs) {
-            (0, debug_1.assert)(specializedTypes.parameterDefaultArgs.length === type.shared.parameters.length);
+        if (specializedTypes.parameterDefaultTypes) {
+            (0, debug_1.assert)(specializedTypes.parameterDefaultTypes.length === type.shared.parameters.length);
         }
         newFunction.priv.specializedTypes = specializedTypes;
         newFunction.priv.inferredReturnType = specializedInferredReturnType;
@@ -1185,8 +1177,8 @@ var FunctionType;
         const prevParams = Array.from(newFunction.shared.parameters);
         newFunction.shared.parameters = [
             ...prevParams,
-            ...paramSpecValue.shared.parameters.map((param) => {
-                return FunctionParam.create(param.category, param.type, (param.flags & FunctionParamFlags.NameSynthesized) | FunctionParamFlags.TypeDeclared, param.name, param.defaultType);
+            ...paramSpecValue.shared.parameters.map((param, index) => {
+                return FunctionParam.create(param.category, FunctionType.getParamType(paramSpecValue, index), (param.flags & FunctionParamFlags.NameSynthesized) | FunctionParamFlags.TypeDeclared, param.name, FunctionType.getParamDefaultType(paramSpecValue, index));
             }),
         ];
         if (newFunction.shared.docString === undefined) {
@@ -1216,16 +1208,14 @@ var FunctionType;
         // Update the specialized parameter types as well.
         const specializedTypes = newFunction.priv.specializedTypes;
         if (specializedTypes) {
-            paramSpecValue.shared.parameters.forEach((paramInfo) => {
+            paramSpecValue.shared.parameters.forEach((_, index) => {
                 var _a;
-                specializedTypes.parameterTypes.push(paramInfo.type);
-                // Assume that the parameters introduced via paramSpec have no specialized
-                // default arg types. Fall back on the original default arg type in this case.
-                (_a = specializedTypes.parameterDefaultArgs) === null || _a === void 0 ? void 0 : _a.push(undefined);
+                specializedTypes.parameterTypes.push(FunctionType.getParamType(paramSpecValue, index));
+                if (specializedTypes.parameterDefaultTypes) {
+                    (_a = specializedTypes.parameterDefaultTypes) === null || _a === void 0 ? void 0 : _a.push(FunctionType.getParamDefaultType(paramSpecValue, index));
+                }
             });
         }
-        FunctionType.addHigherOrderTypeVarScopeIds(newFunction, paramSpecValue.shared.typeVarScopeId);
-        FunctionType.addHigherOrderTypeVarScopeIds(newFunction, paramSpecValue.priv.higherOrderTypeVarScopeIds);
         newFunction.priv.constructorTypeVarScopeId = paramSpecValue.priv.constructorTypeVarScopeId;
         if (!newFunction.shared.methodClass && paramSpecValue.shared.methodClass) {
             newFunction.shared.methodClass = paramSpecValue.shared.methodClass;
@@ -1248,7 +1238,6 @@ var FunctionType;
         newFunction.shared.typeVarScopeId = newScopeId;
         newFunction.priv.constructorTypeVarScopeId = newConstructorScopeId;
         newFunction.shared.typeParams = typeParams;
-        FunctionType.addHigherOrderTypeVarScopeIds(newFunction, typeParams.map((t) => { var _a, _b; return (_b = (_a = t.priv.externalTypeVar) === null || _a === void 0 ? void 0 : _a.priv.scopeId) !== null && _b !== void 0 ? _b : t.priv.scopeId; }));
         return newFunction;
     }
     FunctionType.cloneWithNewTypeVarScopeId = cloneWithNewTypeVarScopeId;
@@ -1282,8 +1271,8 @@ var FunctionType;
         if (argsParam.category !== 1 /* ParamCategory.ArgsList */ || kwargsParam.category !== 2 /* ParamCategory.KwargsDict */) {
             return type;
         }
-        const argsType = FunctionType.getEffectiveParamType(type, paramCount - 2);
-        const kwargsType = FunctionType.getEffectiveParamType(type, paramCount - 1);
+        const argsType = FunctionType.getParamType(type, paramCount - 2);
+        const kwargsType = FunctionType.getParamType(type, paramCount - 1);
         if (!isParamSpec(argsType) || !isParamSpec(kwargsType) || !isTypeSame(argsType, kwargsType)) {
             return type;
         }
@@ -1304,9 +1293,9 @@ var FunctionType;
         if (type.priv.specializedTypes) {
             newFunction.priv.specializedTypes = { ...type.priv.specializedTypes };
             newFunction.priv.specializedTypes.parameterTypes = newFunction.priv.specializedTypes.parameterTypes.slice(0, newFunction.priv.specializedTypes.parameterTypes.length - paramsToDrop);
-            if (newFunction.priv.specializedTypes.parameterDefaultArgs) {
-                newFunction.priv.specializedTypes.parameterDefaultArgs =
-                    newFunction.priv.specializedTypes.parameterDefaultArgs.slice(0, newFunction.priv.specializedTypes.parameterDefaultArgs.length - paramsToDrop);
+            if (newFunction.priv.specializedTypes.parameterDefaultTypes) {
+                newFunction.priv.specializedTypes.parameterDefaultTypes =
+                    newFunction.priv.specializedTypes.parameterDefaultTypes.slice(0, newFunction.priv.specializedTypes.parameterDefaultTypes.length - paramsToDrop);
             }
         }
         if (type.priv.inferredReturnType) {
@@ -1323,14 +1312,16 @@ var FunctionType;
             return undefined;
         }
         const secondLastParam = params[params.length - 2];
+        const secondLastParamType = FunctionType.getParamType(type, params.length - 2);
         const lastParam = params[params.length - 1];
+        const lastParamType = FunctionType.getParamType(type, params.length - 1);
         if (secondLastParam.category === 1 /* ParamCategory.ArgsList */ &&
-            isParamSpec(secondLastParam.type) &&
-            secondLastParam.type.priv.paramSpecAccess === 'args' &&
+            isParamSpec(secondLastParamType) &&
+            secondLastParamType.priv.paramSpecAccess === 'args' &&
             lastParam.category === 2 /* ParamCategory.KwargsDict */ &&
-            isParamSpec(lastParam.type) &&
-            lastParam.type.priv.paramSpecAccess === 'kwargs') {
-            return TypeVarType.cloneForParamSpecAccess(secondLastParam.type, /* access */ undefined);
+            isParamSpec(lastParamType) &&
+            lastParamType.priv.paramSpecAccess === 'kwargs') {
+            return TypeVarType.cloneForParamSpecAccess(secondLastParamType, /* access */ undefined);
         }
         return undefined;
     }
@@ -1346,27 +1337,6 @@ var FunctionType;
         });
     }
     FunctionType.addDefaultParams = addDefaultParams;
-    function addHigherOrderTypeVarScopeIds(functionType, scopeIds) {
-        if (!scopeIds) {
-            return;
-        }
-        if (!Array.isArray(scopeIds)) {
-            scopeIds = [scopeIds];
-        }
-        if (!functionType.priv.higherOrderTypeVarScopeIds) {
-            functionType.priv.higherOrderTypeVarScopeIds = [];
-        }
-        // Add the scope IDs to the function if they're unique.
-        scopeIds.forEach((scopeId) => {
-            if (!scopeId || scopeId === functionType.shared.typeVarScopeId) {
-                return;
-            }
-            if (!functionType.priv.higherOrderTypeVarScopeIds.some((id) => id === scopeId)) {
-                functionType.priv.higherOrderTypeVarScopeIds.push(scopeId);
-            }
-        });
-    }
-    FunctionType.addHigherOrderTypeVarScopeIds = addHigherOrderTypeVarScopeIds;
     function getDefaultParams(useUnknown = false) {
         return [
             FunctionParam.create(1 /* ParamCategory.ArgsList */, useUnknown ? UnknownType.create() : AnyType.create(), useUnknown ? FunctionParamFlags.None : FunctionParamFlags.TypeDeclared, 'args'),
@@ -1393,7 +1363,7 @@ var FunctionType;
             else if (param.category === 2 /* ParamCategory.KwargsDict */) {
                 sawKwargs = true;
             }
-            if (!isAnyOrUnknown(FunctionType.getEffectiveParamType(functionType, i))) {
+            if (!isAnyOrUnknown(FunctionType.getParamType(functionType, i))) {
                 return false;
             }
         }
@@ -1491,31 +1461,35 @@ var FunctionType;
         return true;
     }
     FunctionType.isBuiltIn = isBuiltIn;
-    function getEffectiveParamType(type, index) {
+    function getDeclaredParamType(type, index) {
+        return type.shared.parameters[index]._type;
+    }
+    FunctionType.getDeclaredParamType = getDeclaredParamType;
+    function getParamType(type, index) {
         (0, debug_1.assert)(index < type.shared.parameters.length, 'Parameter types array overflow');
         if (type.priv.specializedTypes && index < type.priv.specializedTypes.parameterTypes.length) {
             return type.priv.specializedTypes.parameterTypes[index];
         }
-        return type.shared.parameters[index].type;
+        return type.shared.parameters[index]._type;
     }
-    FunctionType.getEffectiveParamType = getEffectiveParamType;
-    function getEffectiveParamDefaultArgType(type, index) {
+    FunctionType.getParamType = getParamType;
+    function getParamDefaultType(type, index) {
         var _a;
         (0, debug_1.assert)(index < type.shared.parameters.length, 'Parameter types array overflow');
-        if (((_a = type.priv.specializedTypes) === null || _a === void 0 ? void 0 : _a.parameterDefaultArgs) &&
-            index < type.priv.specializedTypes.parameterDefaultArgs.length) {
-            const defaultArgType = type.priv.specializedTypes.parameterDefaultArgs[index];
+        if (((_a = type.priv.specializedTypes) === null || _a === void 0 ? void 0 : _a.parameterDefaultTypes) &&
+            index < type.priv.specializedTypes.parameterDefaultTypes.length) {
+            const defaultArgType = type.priv.specializedTypes.parameterDefaultTypes[index];
             if (defaultArgType) {
                 return defaultArgType;
             }
         }
-        return type.shared.parameters[index].defaultType;
+        return type.shared.parameters[index]._defaultType;
     }
-    FunctionType.getEffectiveParamDefaultArgType = getEffectiveParamDefaultArgType;
+    FunctionType.getParamDefaultType = getParamDefaultType;
     function addParam(type, param) {
         type.shared.parameters.push(param);
         if (type.priv.specializedTypes) {
-            type.priv.specializedTypes.parameterTypes.push(param.type);
+            type.priv.specializedTypes.parameterTypes.push(param._type);
         }
     }
     FunctionType.addParam = addParam;
@@ -1895,8 +1869,8 @@ var TypeVarType;
         if ((_b = newInstance.props) === null || _b === void 0 ? void 0 : _b.specialForm) {
             TypeBase.setSpecialForm(newInstance, undefined);
         }
-        if (newInstance.priv.externalTypeVar) {
-            newInstance.priv.externalTypeVar = TypeVarType.cloneAsInstance(newInstance.priv.externalTypeVar);
+        if (newInstance.priv.freeTypeVar) {
+            newInstance.priv.freeTypeVar = TypeVarType.cloneAsInstance(newInstance.priv.freeTypeVar);
         }
         return newInstance;
     }
@@ -1907,8 +1881,8 @@ var TypeVarType;
             return type.cached.typeBaseInstantiableType;
         }
         const newInstance = TypeBase.cloneTypeAsInstantiable(type, /* cache */ true);
-        if (newInstance.priv.externalTypeVar) {
-            newInstance.priv.externalTypeVar = TypeVarType.cloneAsInstantiable(newInstance.priv.externalTypeVar);
+        if (newInstance.priv.freeTypeVar) {
+            newInstance.priv.freeTypeVar = TypeVarType.cloneAsInstantiable(newInstance.priv.freeTypeVar);
         }
         return newInstance;
     }
@@ -1934,26 +1908,26 @@ var TypeVarType;
     TypeVarType.cloneForScopeId = cloneForScopeId;
     function cloneForUnpacked(type, isInUnion = false) {
         const newInstance = TypeBase.cloneType(type);
-        newInstance.priv.isVariadicUnpacked = true;
-        newInstance.priv.isVariadicInUnion = isInUnion;
-        if (newInstance.priv.externalTypeVar) {
-            newInstance.priv.externalTypeVar = TypeVarType.cloneForUnpacked(newInstance.priv.externalTypeVar, isInUnion);
+        newInstance.priv.isUnpacked = true;
+        newInstance.priv.isInUnion = isInUnion;
+        if (newInstance.priv.freeTypeVar) {
+            newInstance.priv.freeTypeVar = TypeVarType.cloneForUnpacked(newInstance.priv.freeTypeVar, isInUnion);
         }
         return newInstance;
     }
     TypeVarType.cloneForUnpacked = cloneForUnpacked;
     function cloneForPacked(type) {
         const newInstance = TypeBase.cloneType(type);
-        newInstance.priv.isVariadicUnpacked = false;
-        newInstance.priv.isVariadicInUnion = false;
-        if (newInstance.priv.externalTypeVar) {
-            newInstance.priv.externalTypeVar = TypeVarType.cloneForPacked(newInstance.priv.externalTypeVar);
+        newInstance.priv.isUnpacked = false;
+        newInstance.priv.isInUnion = false;
+        if (newInstance.priv.freeTypeVar) {
+            newInstance.priv.freeTypeVar = TypeVarType.cloneForPacked(newInstance.priv.freeTypeVar);
         }
         return newInstance;
     }
     TypeVarType.cloneForPacked = cloneForPacked;
     // Creates a "simplified" version of the TypeVar with invariance
-    // and no bound or constraints. ParamSpecs and variadics are left
+    // and no bound or constraints. ParamSpecs and TypeVarTuples are left
     // unmodified. So are auto-variant type variables.
     function cloneAsInvariant(type) {
         if (isParamSpec(type) || isTypeVarTuple(type)) {
@@ -1963,7 +1937,7 @@ var TypeVarType;
             return type;
         }
         if (type.shared.declaredVariance === 2 /* Variance.Invariant */) {
-            if (type.shared.boundType === undefined && type.shared.constraints.length === 0) {
+            if (!TypeVarType.hasBound(type) && !TypeVarType.hasConstraints(type)) {
                 return type;
             }
         }
@@ -1982,15 +1956,15 @@ var TypeVarType;
     }
     TypeVarType.cloneForParamSpecAccess = cloneForParamSpecAccess;
     function cloneAsSpecializedSelf(type, specializedBoundType) {
-        (0, debug_1.assert)(type.shared.isSynthesizedSelf);
+        (0, debug_1.assert)(TypeVarType.isSelf(type));
         const newInstance = TypeBase.cloneType(type);
         newInstance.shared = { ...newInstance.shared };
         newInstance.shared.boundType = specializedBoundType;
         return newInstance;
     }
     TypeVarType.cloneAsSpecializedSelf = cloneAsSpecializedSelf;
-    function cloneAsInScopePlaceholder(type, usageOffset) {
-        if (type.priv.isInScopePlaceholder) {
+    function cloneAsUnificationVar(type, usageOffset) {
+        if (TypeVarType.isUnification(type)) {
             return type;
         }
         // If the caller specified a usage offset, append it to the TypeVar
@@ -2002,36 +1976,47 @@ var TypeVarType;
             newNameWithScope = `${type.priv.nameWithScope}-${usageOffset}`;
         }
         const newInstance = TypeBase.cloneType(type);
-        newInstance.priv.isInScopePlaceholder = true;
-        newInstance.priv.scopeId = exports.InScopePlaceholderScopeId;
+        newInstance.priv.isUnificationVar = true;
+        newInstance.priv.scopeId = exports.UnificationScopeId;
         newInstance.priv.nameWithScope = newNameWithScope;
         return newInstance;
     }
-    TypeVarType.cloneAsInScopePlaceholder = cloneAsInScopePlaceholder;
+    TypeVarType.cloneAsUnificationVar = cloneAsUnificationVar;
     function makeNameWithScope(name, scopeId) {
         return `${name}.${scopeId}`;
     }
     TypeVarType.makeNameWithScope = makeNameWithScope;
-    function makeInternalScopeId(scopeId) {
+    function makeBoundScopeId(scopeId) {
         if (!scopeId) {
             return undefined;
         }
+        // Append an asterisk to denote a bound scope.
         return `${scopeId}*`;
     }
-    TypeVarType.makeInternalScopeId = makeInternalScopeId;
-    function cloneWithInternalScopeId(type) {
-        if (type.priv.scopeId === undefined || type.priv.externalTypeVar) {
+    TypeVarType.makeBoundScopeId = makeBoundScopeId;
+    function cloneAsBound(type) {
+        if (type.priv.scopeId === undefined || type.priv.freeTypeVar) {
             return type;
         }
-        const clone = TypeVarType.cloneForScopeId(type, TypeVarType.makeInternalScopeId(type.priv.scopeId), type.priv.scopeName, type.priv.scopeType);
-        clone.priv.externalTypeVar = type;
+        const clone = TypeVarType.cloneForScopeId(type, TypeVarType.makeBoundScopeId(type.priv.scopeId), type.priv.scopeName, type.priv.scopeType);
+        clone.priv.freeTypeVar = type;
         return clone;
     }
-    TypeVarType.cloneWithInternalScopeId = cloneWithInternalScopeId;
-    function hasInternalScopeId(type) {
-        return !!type.priv.externalTypeVar;
-    }
-    TypeVarType.hasInternalScopeId = hasInternalScopeId;
+    TypeVarType.cloneAsBound = cloneAsBound;
+    // Indicates that the type var is a "free" or unbound type var. Free
+    // type variables can be solved whereas bound type vars are already bound
+    // to a value.
+    function isBound(type) {
+        // If the type var has an associated free type var, then it's
+        // considered bound. If it has no associated free var, then it's
+        // considered free.
+        return !!type.priv.freeTypeVar;
+    }
+    TypeVarType.isBound = isBound;
+    function isUnification(type) {
+        return type.priv.isUnificationVar;
+    }
+    TypeVarType.isUnification = isUnification;
     function create(name, kind, typeFlags) {
         const newTypeVarType = {
             category: 9 /* TypeCategory.TypeVar */,
@@ -2092,6 +2077,18 @@ var TypeVarType;
         return !!type.shared.recursiveAlias && !type.shared.boundType;
     }
     TypeVarType.isTypeAliasPlaceholder = isTypeAliasPlaceholder;
+    function isSelf(type) {
+        return !!type.shared.isSynthesizedSelf;
+    }
+    TypeVarType.isSelf = isSelf;
+    function hasConstraints(type) {
+        return type.shared.constraints.length > 0;
+    }
+    TypeVarType.hasConstraints = hasConstraints;
+    function hasBound(type) {
+        return !!type.shared.boundType;
+    }
+    TypeVarType.hasBound = hasBound;
 })(TypeVarType || (exports.TypeVarType = TypeVarType = {}));
 function isNever(type) {
     return type.category === 3 /* TypeCategory.Never */;
@@ -2162,7 +2159,7 @@ function isTypeVarTuple(type) {
 }
 exports.isTypeVarTuple = isTypeVarTuple;
 function isUnpackedTypeVarTuple(type) {
-    return isTypeVarTuple(type) && !!type.priv.isVariadicUnpacked && !type.priv.isVariadicInUnion;
+    return isTypeVarTuple(type) && !!type.priv.isUnpacked && !type.priv.isInUnion;
 }
 exports.isUnpackedTypeVarTuple = isUnpackedTypeVarTuple;
 function isUnpackedClass(type) {
@@ -2315,8 +2312,8 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
                 else if (isKeywordOnlySeparator(param1) && isKeywordOnlySeparator(param2)) {
                     continue;
                 }
-                const param1Type = FunctionType.getEffectiveParamType(type1, i);
-                const param2Type = FunctionType.getEffectiveParamType(functionType2, i);
+                const param1Type = FunctionType.getParamType(type1, i);
+                const param2Type = FunctionType.getParamType(functionType2, i);
                 if (!isTypeSame(param1Type, param2Type, { ...options, ignoreTypeFlags: false }, recursionCount)) {
                     return false;
                 }
@@ -2393,7 +2390,7 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
                 }
             }
             if (isTypeVarTuple(type1) && isTypeVarTuple(type2TypeVar)) {
-                if (!type1.priv.isVariadicInUnion !== !type2TypeVar.priv.isVariadicInUnion) {
+                if (!type1.priv.isInUnion !== !type2TypeVar.priv.isInUnion) {
                     return false;
                 }
             }