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

package/dist/analyzer/types.js

@@ -8,36 +8,58 @@
  * 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.isSameWithoutLiteralValue = exports.combineTypes = exports.findSubtype = exports.removeFromUnion = void 0;
+exports.TypeVarType = exports.ParamSpecType = exports.TypeVarScopeType = exports.TypeVarKind = exports.Variance = exports.UnionType = exports.TypeCondition = exports.AnyType = exports.NeverType = exports.OverloadedType = exports.FunctionType = exports.FunctionTypeFlags = 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.isPositionOnlySeparator = isPositionOnlySeparator;
+exports.isKeywordOnlySeparator = isKeywordOnlySeparator;
+exports.isNever = isNever;
+exports.isAny = isAny;
+exports.isUnknown = isUnknown;
+exports.isAnyOrUnknown = isAnyOrUnknown;
+exports.isUnbound = isUnbound;
+exports.isUnion = isUnion;
+exports.isPossiblyUnbound = isPossiblyUnbound;
+exports.isClass = isClass;
+exports.isInstantiableClass = isInstantiableClass;
+exports.isClassInstance = isClassInstance;
+exports.isModule = isModule;
+exports.isTypeVar = isTypeVar;
+exports.isParamSpec = isParamSpec;
+exports.isTypeVarTuple = isTypeVarTuple;
+exports.isUnpackedTypeVarTuple = isUnpackedTypeVarTuple;
+exports.isUnpackedClass = isUnpackedClass;
+exports.isUnpacked = isUnpacked;
+exports.isFunction = isFunction;
+exports.isOverloaded = isOverloaded;
+exports.getTypeAliasInfo = getTypeAliasInfo;
+exports.isTypeSame = isTypeSame;
+exports.removeUnknownFromUnion = removeUnknownFromUnion;
+exports.removeUnbound = removeUnbound;
+exports.removeFromUnion = removeFromUnion;
+exports.findSubtype = findSubtype;
+exports.combineTypes = combineTypes;
+exports.isSameWithoutLiteralValue = isSameWithoutLiteralValue;
 const debug_1 = require("../common/debug");
 var TypeCategory;
 (function (TypeCategory) {
-    // Name is not bound to a value of any type.
+    // Name is not bound to a value of any type
     TypeCategory[TypeCategory["Unbound"] = 0] = "Unbound";
-    // Type exists but is not currently known by the
-    // type analyzer (e.g. there is no available typings file).
-    // Unknown types are treated the same as "Any" at analysis time.
+    // Implicit Any type
     TypeCategory[TypeCategory["Unknown"] = 1] = "Unknown";
-    // Type can be anything.
+    // Type can be anything
     TypeCategory[TypeCategory["Any"] = 2] = "Any";
-    // Used in type narrowing to indicate that all possible
-    // subtypes in a union have been eliminated, and execution
-    // should never get to this point.
+    // The bottom type, equivalent to an empty union
     TypeCategory[TypeCategory["Never"] = 3] = "Never";
-    // Callable type with typed input parameters and return parameter.
+    // Callable type
     TypeCategory[TypeCategory["Function"] = 4] = "Function";
-    // Functions defined with @overload decorator in stub files that
-    // have multiple function declarations for a common implementation.
-    TypeCategory[TypeCategory["OverloadedFunction"] = 5] = "OverloadedFunction";
-    // Class definition, including associated instance methods,
-    // class methods, static methods, properties, and variables.
+    // Functions defined with @overload decorator
+    TypeCategory[TypeCategory["Overloaded"] = 5] = "Overloaded";
+    // Class definition
     TypeCategory[TypeCategory["Class"] = 6] = "Class";
-    // Module instance.
+    // Module instance
     TypeCategory[TypeCategory["Module"] = 7] = "Module";
-    // Composite type (e.g. Number OR String).
+    // Union of two or more other types
     TypeCategory[TypeCategory["Union"] = 8] = "Union";
-    // Type variable (defined with TypeVar)
+    // Type variable
     TypeCategory[TypeCategory["TypeVar"] = 9] = "TypeVar";
 })(TypeCategory || (exports.TypeCategory = TypeCategory = {}));
 var TypeFlags;
@@ -54,13 +76,16 @@ var TypeFlags;
     // when comparing two types for equivalence.
     TypeFlags[TypeFlags["TypeCompatibilityMask"] = 3] = "TypeCompatibilityMask";
 })(TypeFlags || (exports.TypeFlags = TypeFlags = {}));
-exports.InScopePlaceholderScopeId = '-';
+exports.UnificationScopeId = '-';
+// Information about an enum member that can be used within a Literal
+// type annotation.
 class EnumLiteral {
-    constructor(classFullName, className, itemName, itemType) {
+    constructor(classFullName, className, itemName, itemType, isReprEnum) {
         this.classFullName = classFullName;
         this.className = className;
         this.itemName = itemName;
         this.itemType = itemType;
+        this.isReprEnum = isReprEnum;
     }
     getName() {
         return `${this.classFullName}.${this.itemName}`;
@@ -186,19 +211,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 +410,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.
@@ -668,8 +682,9 @@ var ClassType;
         }
         if (className !== undefined) {
             const classArray = Array.isArray(className) ? className : [className];
-            return (classArray.some((name) => name === classType.shared.name) ||
-                classArray.some((name) => name === classType.priv.aliasName));
+            return classArray.some((name) => name === classType.shared.name ||
+                name === classType.shared.fullName ||
+                name === classType.priv.aliasName);
         }
         return true;
     }
@@ -969,7 +984,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) {
@@ -989,12 +1004,10 @@ function isPositionOnlySeparator(param) {
     // A simple parameter with no name is treated as a "/" separator.
     return param.category === 0 /* ParamCategory.Simple */ && !param.name;
 }
-exports.isPositionOnlySeparator = isPositionOnlySeparator;
 function isKeywordOnlySeparator(param) {
     // An *args parameter with no name is treated as a "*" separator.
     return param.category === 1 /* ParamCategory.ArgsList */ && !param.name;
 }
-exports.isKeywordOnlySeparator = isKeywordOnlySeparator;
 var FunctionTypeFlags;
 (function (FunctionTypeFlags) {
     FunctionTypeFlags[FunctionTypeFlags["None"] = 0] = "None";
@@ -1092,14 +1105,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 = boundToType.shared.typeVarScopeId;
+            }
         }
         if (stripFirstParam) {
             if (type.shared.parameters.length > 0) {
@@ -1107,7 +1122,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 +1143,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 +1180,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 +1200,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 +1231,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 +1261,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 +1294,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 +1316,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 +1335,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 +1360,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 +1386,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;
             }
         }
@@ -1486,36 +1479,40 @@ var FunctionType;
         }
         if (name !== undefined) {
             const functionArray = Array.isArray(name) ? name : [name];
-            return functionArray.some((name) => name === type.shared.name);
+            return functionArray.some((name) => name === type.shared.name || name === type.shared.fullName);
         }
         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;
@@ -1542,40 +1539,41 @@ var FunctionType;
     }
     FunctionType.getEffectiveReturnType = getEffectiveReturnType;
 })(FunctionType || (exports.FunctionType = FunctionType = {}));
-var OverloadedFunctionType;
-(function (OverloadedFunctionType) {
-    function create(overloads) {
+var OverloadedType;
+(function (OverloadedType) {
+    function create(overloads, implementation) {
         const newType = {
-            category: 5 /* TypeCategory.OverloadedFunction */,
+            category: 5 /* TypeCategory.Overloaded */,
             flags: 2 /* TypeFlags.Instance */,
             props: undefined,
             cached: undefined,
             shared: undefined,
             priv: {
-                overloads: [],
+                _overloads: [],
+                _implementation: implementation,
             },
         };
         overloads.forEach((overload) => {
-            OverloadedFunctionType.addOverload(newType, overload);
+            OverloadedType.addOverload(newType, overload);
         });
         return newType;
     }
-    OverloadedFunctionType.create = create;
+    OverloadedType.create = create;
     // Adds a new overload or an implementation.
     function addOverload(type, functionType) {
         functionType.priv.overloaded = type;
-        type.priv.overloads.push(functionType);
+        type.priv._overloads.push(functionType);
     }
-    OverloadedFunctionType.addOverload = addOverload;
+    OverloadedType.addOverload = addOverload;
     function getOverloads(type) {
-        return type.priv.overloads.filter((func) => FunctionType.isOverloaded(func));
+        return type.priv._overloads;
     }
-    OverloadedFunctionType.getOverloads = getOverloads;
+    OverloadedType.getOverloads = getOverloads;
     function getImplementation(type) {
-        return type.priv.overloads.find((func) => !FunctionType.isOverloaded(func));
+        return type.priv._implementation;
     }
-    OverloadedFunctionType.getImplementation = getImplementation;
-})(OverloadedFunctionType || (exports.OverloadedFunctionType = OverloadedFunctionType = {}));
+    OverloadedType.getImplementation = getImplementation;
+})(OverloadedType || (exports.OverloadedType = OverloadedType = {}));
 var NeverType;
 (function (NeverType) {
     const _neverInstance = {
@@ -1895,8 +1893,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 +1905,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 +1932,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 +1961,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 +1980,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 +2000,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,19 +2101,28 @@ 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 */;
 }
-exports.isNever = isNever;
 function isAny(type) {
     return type.category === 2 /* TypeCategory.Any */;
 }
-exports.isAny = isAny;
 function isUnknown(type) {
     return type.category === 1 /* TypeCategory.Unknown */;
 }
-exports.isUnknown = isUnknown;
 function isAnyOrUnknown(type) {
     if (type.category === 2 /* TypeCategory.Any */ || type.category === 1 /* TypeCategory.Unknown */) {
         return true;
@@ -2114,15 +2132,12 @@ function isAnyOrUnknown(type) {
     }
     return false;
 }
-exports.isAnyOrUnknown = isAnyOrUnknown;
 function isUnbound(type) {
     return type.category === 0 /* TypeCategory.Unbound */;
 }
-exports.isUnbound = isUnbound;
 function isUnion(type) {
     return type.category === 8 /* TypeCategory.Union */;
 }
-exports.isUnion = isUnion;
 function isPossiblyUnbound(type) {
     if (isUnbound(type)) {
         return true;
@@ -2132,58 +2147,45 @@ function isPossiblyUnbound(type) {
     }
     return false;
 }
-exports.isPossiblyUnbound = isPossiblyUnbound;
 function isClass(type) {
     return type.category === 6 /* TypeCategory.Class */;
 }
-exports.isClass = isClass;
 function isInstantiableClass(type) {
     return type.category === 6 /* TypeCategory.Class */ && TypeBase.isInstantiable(type);
 }
-exports.isInstantiableClass = isInstantiableClass;
 function isClassInstance(type) {
     return type.category === 6 /* TypeCategory.Class */ && TypeBase.isInstance(type);
 }
-exports.isClassInstance = isClassInstance;
 function isModule(type) {
     return type.category === 7 /* TypeCategory.Module */;
 }
-exports.isModule = isModule;
 function isTypeVar(type) {
     return type.category === 9 /* TypeCategory.TypeVar */;
 }
-exports.isTypeVar = isTypeVar;
 function isParamSpec(type) {
     return type.category === 9 /* TypeCategory.TypeVar */ && type.shared.kind === TypeVarKind.ParamSpec;
 }
-exports.isParamSpec = isParamSpec;
 function isTypeVarTuple(type) {
     return type.category === 9 /* TypeCategory.TypeVar */ && type.shared.kind === TypeVarKind.TypeVarTuple;
 }
-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) {
     if (!isClass(type) || !type.priv.isUnpacked) {
         return false;
     }
     return true;
 }
-exports.isUnpackedClass = isUnpackedClass;
 function isUnpacked(type) {
     return isUnpackedTypeVarTuple(type) || isUnpackedClass(type);
 }
-exports.isUnpacked = isUnpacked;
 function isFunction(type) {
     return type.category === 4 /* TypeCategory.Function */;
 }
-exports.isFunction = isFunction;
-function isOverloadedFunction(type) {
-    return type.category === 5 /* TypeCategory.OverloadedFunction */;
+function isOverloaded(type) {
+    return type.category === 5 /* TypeCategory.Overloaded */;
 }
-exports.isOverloadedFunction = isOverloadedFunction;
 function getTypeAliasInfo(type) {
     var _a, _b;
     if ((_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo) {
@@ -2197,7 +2199,6 @@ function getTypeAliasInfo(type) {
     }
     return undefined;
 }
-exports.getTypeAliasInfo = getTypeAliasInfo;
 // Determines whether two types are the same. If ignorePseudoGeneric is true,
 // type arguments for "pseudo-generic" classes (non-generic classes whose init
 // methods are not annotated and are therefore treated as generic) are ignored.
@@ -2315,8 +2316,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;
                 }
@@ -2345,16 +2346,16 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
             }
             return true;
         }
-        case 5 /* TypeCategory.OverloadedFunction */: {
+        case 5 /* TypeCategory.Overloaded */: {
             // Make sure the overload counts match.
             const functionType2 = type2;
-            if (type1.priv.overloads.length !== functionType2.priv.overloads.length) {
+            if (type1.priv._overloads.length !== functionType2.priv._overloads.length) {
                 return false;
             }
             // We assume here that overloaded functions always appear
             // in the same order from one analysis pass to another.
-            for (let i = 0; i < type1.priv.overloads.length; i++) {
-                if (!isTypeSame(type1.priv.overloads[i], functionType2.priv.overloads[i], options, recursionCount)) {
+            for (let i = 0; i < type1.priv._overloads.length; i++) {
+                if (!isTypeSame(type1.priv._overloads[i], functionType2.priv._overloads[i], options, recursionCount)) {
                     return false;
                 }
             }
@@ -2393,7 +2394,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;
                 }
             }
@@ -2458,13 +2459,11 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
     }
     return true;
 }
-exports.isTypeSame = isTypeSame;
 // If the type is a union, remove an "unknown" type from the union,
 // returning only the known types.
 function removeUnknownFromUnion(type) {
     return removeFromUnion(type, (t) => isUnknown(t));
 }
-exports.removeUnknownFromUnion = removeUnknownFromUnion;
 // If the type is a union, remove an "unbound" type from the union,
 // returning only the known types.
 function removeUnbound(type) {
@@ -2476,7 +2475,6 @@ function removeUnbound(type) {
     }
     return type;
 }
-exports.removeUnbound = removeUnbound;
 function removeFromUnion(type, removeFilter) {
     if (isUnion(type)) {
         const remainingTypes = type.priv.subtypes.filter((t) => !removeFilter(t));
@@ -2490,7 +2488,6 @@ function removeFromUnion(type, removeFilter) {
     }
     return type;
 }
-exports.removeFromUnion = removeFromUnion;
 function findSubtype(type, filter) {
     if (isUnion(type)) {
         return type.priv.subtypes.find((subtype) => {
@@ -2499,7 +2496,6 @@ function findSubtype(type, filter) {
     }
     return filter(type) ? type : undefined;
 }
-exports.findSubtype = findSubtype;
 // Combines multiple types into a single type. If the types are
 // the same, only one is returned. If they differ, they
 // are combined into a UnionType. NeverTypes are filtered out.
@@ -2604,7 +2600,6 @@ function combineTypes(subtypes, options) {
     }
     return newUnionType;
 }
-exports.combineTypes = combineTypes;
 // Determines whether the dest type is the same as the source type with
 // the possible exception that the source type has a literal value when
 // the dest does not.
@@ -2625,7 +2620,6 @@ function isSameWithoutLiteralValue(destType, srcType) {
     }
     return false;
 }
-exports.isSameWithoutLiteralValue = isSameWithoutLiteralValue;
 function _addTypeIfUnique(unionType, typeToAdd, elideRedundantLiterals) {
     var _a, _b, _c;
     // Handle the addition of a string literal in a special manner to