@zzzen/pyright-internal 1.1.254

package/dist/analyzer/typeUtils.js

@@ -0,0 +1,2380 @@
+"use strict";
+/*
+ * typeUtils.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ * Author: Eric Traut
+ *
+ * Collection of functions that operate on Type objects.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGeneratorYieldType = exports.getDeclaredGeneratorReturnType = exports.synthesizeTypeVarForSelfCls = exports.derivesFromClassRecursive = exports.specializeForBaseClass = exports.buildTypeVarContext = exports.buildTypeVarContextFromSpecializedClass = exports.setTypeArgumentsRecursive = exports.specializeClassType = exports.getTypeVarArgumentsRecursive = exports.addTypeVarsToListIfUnique = exports.getClassFieldsRecursive = exports.getClassIterator = exports.getClassMemberIterator = exports.lookUpClassMember = exports.lookUpObjectMember = exports.getProtocolSymbols = exports.transformExpectedTypeForConstructor = exports.applySolvedTypeVars = exports.populateTypeVarContextForSelfType = exports.partiallySpecializeType = exports.isUnboundedTupleClass = exports.isTupleClass = exports.isMaybeDescriptorInstance = exports.isDescriptorInstance = exports.isProperty = exports.isEllipsisType = exports.getUnionSubtypeCount = exports.getLiteralTypeClassName = exports.containsLiteralType = exports.isLiteralTypeOrUnion = exports.isLiteralType = exports.getSpecializedTupleType = exports.getTypeVarScopeId = exports.transformPossibleRecursiveTypeAlias = exports.isTypeAliasRecursive = exports.isTypeAliasPlaceholder = exports.getTypeCondition = exports.addConditionToType = exports.stripLiteralValue = exports.getFullNameOfType = exports.derivesFromAnyOrUnknown = exports.isUnionableType = exports.preserveUnknown = exports.areTypesSame = exports.doForEachSubtype = exports.mapSubtypes = exports.isOptionalType = exports.getParameterListDetails = exports.ParameterSource = void 0;
+exports.convertParamSpecValueToType = exports.getDeclaringModulesForType = exports.computeMroLinearization = exports.requiresSpecialization = exports.requiresTypeArguments = exports.getGeneratorTypeArgs = exports.removeParamSpecVariadicsFromFunction = exports.removeParamSpecVariadicsFromSignature = exports.specializeTupleClass = exports.combineSameSizedTuples = exports.explodeGenericClass = exports.isPartlyUnknown = exports.containsUnknown = exports.getMembersForModule = exports.getMembersForClass = exports.convertToInstantiable = exports.convertToInstance = exports.isEffectivelyInstantiable = void 0;
+const collectionUtils_1 = require("../common/collectionUtils");
+const debug_1 = require("../common/debug");
+const symbol_1 = require("./symbol");
+const symbolNameUtils_1 = require("./symbolNameUtils");
+const symbolUtils_1 = require("./symbolUtils");
+const types_1 = require("./types");
+const typeVarContext_1 = require("./typeVarContext");
+var ParameterSource;
+(function (ParameterSource) {
+    ParameterSource[ParameterSource["PositionOnly"] = 0] = "PositionOnly";
+    ParameterSource[ParameterSource["PositionOrKeyword"] = 1] = "PositionOrKeyword";
+    ParameterSource[ParameterSource["KeywordOnly"] = 2] = "KeywordOnly";
+})(ParameterSource = exports.ParameterSource || (exports.ParameterSource = {}));
+// Examines the input parameters within a function signature and creates a
+// "virtual list" of parameters, stripping out any markers and expanding
+// any *args with unpacked tuples.
+function getParameterListDetails(type) {
+    const result = {
+        firstPositionOrKeywordIndex: 0,
+        positionParamCount: 0,
+        positionOnlyParamCount: 0,
+        params: [],
+        hasUnpackedVariadicTypeVar: false,
+        hasUnpackedTypedDict: false,
+    };
+    let positionOnlyIndex = type.details.parameters.findIndex((p) => p.category === 0 /* Simple */ && !p.name);
+    // Handle the old (pre Python 3.8) way of specifying positional-only
+    // parameters by naming them with "__".
+    if (positionOnlyIndex < 0) {
+        for (let i = 0; i < type.details.parameters.length; i++) {
+            const p = type.details.parameters[i];
+            if (p.category !== 0 /* Simple */) {
+                break;
+            }
+            if (!p.name) {
+                break;
+            }
+            if ((0, symbolNameUtils_1.isDunderName)(p.name) || !p.name.startsWith('__')) {
+                break;
+            }
+            positionOnlyIndex = i + 1;
+        }
+    }
+    if (positionOnlyIndex >= 0) {
+        result.firstPositionOrKeywordIndex = positionOnlyIndex;
+    }
+    for (let i = 0; i < positionOnlyIndex; i++) {
+        if (type.details.parameters[i].hasDefault) {
+            break;
+        }
+        result.positionOnlyParamCount++;
+    }
+    let sawKeywordOnlySeparator = false;
+    const addVirtualParameter = (param, index, typeOverride, defaultArgTypeOverride) => {
+        if (param.name) {
+            let source;
+            if (param.category === 1 /* VarArgList */) {
+                source = ParameterSource.PositionOnly;
+            }
+            else if (sawKeywordOnlySeparator) {
+                source = ParameterSource.KeywordOnly;
+            }
+            else if (positionOnlyIndex >= 0 && index < positionOnlyIndex) {
+                source = ParameterSource.PositionOnly;
+            }
+            else {
+                source = ParameterSource.PositionOrKeyword;
+            }
+            result.params.push({
+                param,
+                index,
+                type: typeOverride !== null && typeOverride !== void 0 ? typeOverride : types_1.FunctionType.getEffectiveParameterType(type, index),
+                defaultArgType: defaultArgTypeOverride,
+                source,
+            });
+        }
+    };
+    type.details.parameters.forEach((param, index) => {
+        var _a, _b;
+        if (param.category === 1 /* VarArgList */) {
+            // If this is an unpacked tuple, expand the entries.
+            const paramType = types_1.FunctionType.getEffectiveParameterType(type, index);
+            if (param.name && (0, types_1.isUnpackedClass)(paramType) && paramType.tupleTypeArguments) {
+                paramType.tupleTypeArguments.forEach((tupleArg, index) => {
+                    const category = (0, types_1.isVariadicTypeVar)(tupleArg.type) || tupleArg.isUnbounded
+                        ? 1 /* VarArgList */
+                        : 0 /* Simple */;
+                    if (category === 1 /* VarArgList */) {
+                        result.argsIndex = result.params.length;
+                    }
+                    if ((0, types_1.isVariadicTypeVar)(param.type)) {
+                        result.hasUnpackedVariadicTypeVar = true;
+                    }
+                    addVirtualParameter({
+                        category,
+                        name: `${param.name}[${index.toString()}]`,
+                        isNameSynthesized: true,
+                        type: tupleArg.type,
+                        hasDeclaredType: true,
+                    }, index, tupleArg.type);
+                });
+            }
+            else {
+                if (param.name && result.argsIndex === undefined) {
+                    result.argsIndex = result.params.length;
+                    if ((0, types_1.isVariadicTypeVar)(param.type)) {
+                        result.hasUnpackedVariadicTypeVar = true;
+                    }
+                }
+                // Normally, a VarArgList parameter (either named or as an unnamed separator)
+                // would signify the start of keyword-only parameters. However, we can construct
+                // callable signatures that defy this rule by using Callable and TypeVarTuples
+                // or unpacked tuples.
+                if (!sawKeywordOnlySeparator && (positionOnlyIndex < 0 || index >= positionOnlyIndex)) {
+                    result.firstKeywordOnlyIndex = result.params.length;
+                    if (param.name) {
+                        result.firstKeywordOnlyIndex++;
+                    }
+                    sawKeywordOnlySeparator = true;
+                }
+                addVirtualParameter(param, index);
+            }
+        }
+        else if (param.category === 2 /* VarArgDictionary */) {
+            sawKeywordOnlySeparator = true;
+            // Is this an unpacked TypedDict? If so, expand the entries.
+            if ((0, types_1.isClassInstance)(param.type) && (0, types_1.isUnpackedClass)(param.type) && param.type.details.typedDictEntries) {
+                if (result.firstKeywordOnlyIndex === undefined) {
+                    result.firstKeywordOnlyIndex = result.params.length;
+                }
+                param.type.details.typedDictEntries.forEach((entry, name) => {
+                    addVirtualParameter({
+                        category: 0 /* Simple */,
+                        name,
+                        type: entry.valueType,
+                        hasDeclaredType: true,
+                        hasDefault: !entry.isRequired,
+                    }, index, entry.valueType);
+                });
+                result.hasUnpackedTypedDict = true;
+            }
+            else if (param.name) {
+                if (result.kwargsIndex === undefined) {
+                    result.kwargsIndex = result.params.length;
+                }
+                if (result.firstKeywordOnlyIndex === undefined) {
+                    result.firstKeywordOnlyIndex = result.params.length;
+                }
+                addVirtualParameter(param, index);
+            }
+        }
+        else if (param.category === 0 /* Simple */) {
+            if (param.name && !sawKeywordOnlySeparator) {
+                result.positionParamCount++;
+            }
+            addVirtualParameter(param, index, 
+            /* typeOverride */ undefined, ((_a = type.specializedTypes) === null || _a === void 0 ? void 0 : _a.parameterDefaultArgs)
+                ? (_b = type.specializedTypes) === null || _b === void 0 ? void 0 : _b.parameterDefaultArgs[index]
+                : undefined);
+        }
+    });
+    return result;
+}
+exports.getParameterListDetails = getParameterListDetails;
+function isOptionalType(type) {
+    if ((0, types_1.isUnion)(type)) {
+        return (0, types_1.findSubtype)(type, (subtype) => (0, types_1.isNoneInstance)(subtype)) !== undefined;
+    }
+    return false;
+}
+exports.isOptionalType = isOptionalType;
+// Calls a callback for each subtype and combines the results
+// into a final type.
+function mapSubtypes(type, callback) {
+    if ((0, types_1.isUnion)(type)) {
+        const newSubtypes = [];
+        let typeChanged = false;
+        type.subtypes.forEach((subtype) => {
+            const transformedType = callback(subtype);
+            if (transformedType) {
+                if (transformedType !== subtype) {
+                    newSubtypes.push(addConditionToType(transformedType, getTypeCondition(type)));
+                    typeChanged = true;
+                }
+                else {
+                    newSubtypes.push(subtype);
+                }
+            }
+            else {
+                typeChanged = true;
+            }
+        });
+        if (!typeChanged) {
+            return type;
+        }
+        const newType = (0, types_1.combineTypes)(newSubtypes);
+        // Do our best to retain type aliases.
+        if (newType.category === 9 /* Union */) {
+            types_1.UnionType.addTypeAliasSource(newType, type);
+        }
+        return newType;
+    }
+    const transformedSubtype = callback(type);
+    if (!transformedSubtype) {
+        return types_1.NeverType.createNever();
+    }
+    return transformedSubtype;
+}
+exports.mapSubtypes = mapSubtypes;
+function doForEachSubtype(type, callback) {
+    if ((0, types_1.isUnion)(type)) {
+        type.subtypes.forEach((subtype, index) => {
+            callback(subtype, index);
+        });
+    }
+    else {
+        callback(type, 0);
+    }
+}
+exports.doForEachSubtype = doForEachSubtype;
+// Determines if all of the types in the array are the same.
+function areTypesSame(types, ignorePseudoGeneric) {
+    if (types.length < 2) {
+        return true;
+    }
+    for (let i = 1; i < types.length; i++) {
+        if (!(0, types_1.isTypeSame)(types[0], types[i], ignorePseudoGeneric)) {
+            return false;
+        }
+    }
+    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.
+function preserveUnknown(type1, type2) {
+    if ((0, types_1.isUnknown)(type1) && type1.isIncomplete) {
+        return type1;
+    }
+    else if ((0, types_1.isUnknown)(type2) && type2.isIncomplete) {
+        return type2;
+    }
+    else if ((0, types_1.isUnknown)(type1) || (0, types_1.isUnknown)(type2)) {
+        return types_1.UnknownType.create();
+    }
+    else {
+        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) {
+    let typeFlags = 2 /* Instance */ | 1 /* Instantiable */;
+    for (const subtype of subtypes) {
+        typeFlags &= subtype.flags;
+    }
+    // All subtypes need to be instantiable. Some types (like Any
+    // and None) are both instances and instantiable. It's OK to
+    // include some of these, but at least one subtype needs to
+    // be definitively instantiable (not an instance).
+    return (typeFlags & 1 /* Instantiable */) !== 0 && (typeFlags & 2 /* Instance */) === 0;
+}
+exports.isUnionableType = isUnionableType;
+function derivesFromAnyOrUnknown(type) {
+    let anyOrUnknown = false;
+    doForEachSubtype(type, (subtype) => {
+        if ((0, types_1.isAnyOrUnknown)(type)) {
+            anyOrUnknown = true;
+        }
+        else if ((0, types_1.isInstantiableClass)(subtype)) {
+            if (types_1.ClassType.hasUnknownBaseClass(subtype)) {
+                anyOrUnknown = true;
+            }
+        }
+        else if ((0, types_1.isClassInstance)(subtype)) {
+            if (types_1.ClassType.hasUnknownBaseClass(subtype)) {
+                anyOrUnknown = true;
+            }
+        }
+    });
+    return anyOrUnknown;
+}
+exports.derivesFromAnyOrUnknown = derivesFromAnyOrUnknown;
+function getFullNameOfType(type) {
+    var _a;
+    if ((_a = type.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.fullName) {
+        return type.typeAliasInfo.fullName;
+    }
+    switch (type.category) {
+        case 2 /* Any */:
+        case 1 /* Unknown */:
+            return 'typing.Any';
+        case 3 /* None */:
+            return 'builtins.None';
+        case 7 /* Class */:
+            return type.details.fullName;
+        case 5 /* Function */:
+            return type.details.fullName;
+        case 8 /* Module */:
+            return type.moduleName;
+        case 6 /* OverloadedFunction */:
+            return type.overloads[0].details.fullName;
+    }
+    return undefined;
+}
+exports.getFullNameOfType = getFullNameOfType;
+function stripLiteralValue(type) {
+    if ((0, types_1.isClass)(type)) {
+        if (type.literalValue !== undefined) {
+            type = types_1.ClassType.cloneWithLiteral(type, /* value */ undefined);
+        }
+        return type;
+    }
+    if ((0, types_1.isUnion)(type)) {
+        return mapSubtypes(type, (subtype) => {
+            return stripLiteralValue(subtype);
+        });
+    }
+    return type;
+}
+exports.stripLiteralValue = stripLiteralValue;
+function addConditionToType(type, condition) {
+    if (!condition) {
+        return type;
+    }
+    switch (type.category) {
+        case 0 /* Unbound */:
+        case 1 /* Unknown */:
+        case 2 /* Any */:
+        case 4 /* Never */:
+        case 8 /* Module */:
+        case 10 /* TypeVar */:
+            return type;
+        case 3 /* None */:
+        case 5 /* Function */:
+            return types_1.TypeBase.cloneForCondition(type, types_1.TypeCondition.combine(type.condition, condition));
+        case 6 /* OverloadedFunction */:
+            return types_1.OverloadedFunctionType.create(type.overloads.map((t) => addConditionToType(t, condition)));
+        case 7 /* Class */:
+            return types_1.TypeBase.cloneForCondition(type, types_1.TypeCondition.combine(type.condition, condition));
+        case 9 /* Union */:
+            return (0, types_1.combineTypes)(type.subtypes.map((t) => addConditionToType(t, condition)));
+    }
+}
+exports.addConditionToType = addConditionToType;
+function getTypeCondition(type) {
+    switch (type.category) {
+        case 0 /* Unbound */:
+        case 1 /* Unknown */:
+        case 2 /* Any */:
+        case 4 /* Never */:
+        case 8 /* Module */:
+        case 10 /* TypeVar */:
+        case 6 /* OverloadedFunction */:
+        case 9 /* Union */:
+            return undefined;
+        case 3 /* None */:
+        case 7 /* Class */:
+        case 5 /* Function */:
+            return type.condition;
+    }
+}
+exports.getTypeCondition = getTypeCondition;
+// Indicates whether the specified type is a recursive type alias
+// placeholder that has not yet been resolved.
+function isTypeAliasPlaceholder(type) {
+    if (!(0, types_1.isTypeVar)(type)) {
+        return false;
+    }
+    return !!type.details.recursiveTypeAliasName && !type.details.boundType;
+}
+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.
+function isTypeAliasRecursive(typeAliasPlaceholder, type) {
+    if (type.category !== 9 /* Union */) {
+        if (type === typeAliasPlaceholder) {
+            return true;
+        }
+        // Handle the specific case where the type alias directly refers to itself.
+        // In this case, the type will be unbound because it could not be resolved.
+        return ((0, types_1.isUnbound)(type) &&
+            type.typeAliasInfo &&
+            type.typeAliasInfo.name === typeAliasPlaceholder.details.recursiveTypeAliasName);
+    }
+    return (0, types_1.findSubtype)(type, (subtype) => (0, types_1.isTypeSame)(typeAliasPlaceholder, subtype)) !== undefined;
+}
+exports.isTypeAliasRecursive = isTypeAliasRecursive;
+function transformPossibleRecursiveTypeAlias(type) {
+    var _a;
+    if (type) {
+        if ((0, types_1.isTypeVar)(type) && type.details.recursiveTypeAliasName && type.details.boundType) {
+            const unspecializedType = types_1.TypeBase.isInstance(type)
+                ? convertToInstance(type.details.boundType)
+                : type.details.boundType;
+            if (!((_a = type.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.typeArguments) || !type.details.recursiveTypeParameters) {
+                return unspecializedType;
+            }
+            const typeVarContext = buildTypeVarContext(type.details.recursiveTypeParameters, type.typeAliasInfo.typeArguments, getTypeVarScopeId(type));
+            return applySolvedTypeVars(unspecializedType, typeVarContext);
+        }
+    }
+    return type;
+}
+exports.transformPossibleRecursiveTypeAlias = transformPossibleRecursiveTypeAlias;
+function getTypeVarScopeId(type) {
+    if ((0, types_1.isClass)(type)) {
+        return type.details.typeVarScopeId;
+    }
+    if ((0, types_1.isFunction)(type)) {
+        return type.details.typeVarScopeId;
+    }
+    if ((0, types_1.isTypeVar)(type)) {
+        return type.scopeId;
+    }
+    return undefined;
+}
+exports.getTypeVarScopeId = getTypeVarScopeId;
+// Determines whether the type derives from tuple. If so, it returns
+// the specialized tuple type.
+function getSpecializedTupleType(type) {
+    let classType;
+    if ((0, types_1.isInstantiableClass)(type)) {
+        classType = type;
+    }
+    else if ((0, types_1.isClassInstance)(type)) {
+        classType = types_1.ClassType.cloneAsInstantiable(type);
+    }
+    if (!classType) {
+        return undefined;
+    }
+    // See if this class derives from Tuple or tuple. If it does, we'll assume that it
+    // hasn't been overridden in a way that changes the behavior of the tuple class.
+    const tupleClass = classType.details.mro.find((mroClass) => (0, types_1.isInstantiableClass)(mroClass) && isTupleClass(mroClass));
+    if (!tupleClass || !(0, types_1.isInstantiableClass)(tupleClass)) {
+        return undefined;
+    }
+    if (types_1.ClassType.isSameGenericClass(classType, tupleClass)) {
+        return classType;
+    }
+    const typeVarContext = buildTypeVarContextFromSpecializedClass(classType);
+    return applySolvedTypeVars(tupleClass, typeVarContext);
+}
+exports.getSpecializedTupleType = getSpecializedTupleType;
+function isLiteralType(type) {
+    return types_1.TypeBase.isInstance(type) && type.literalValue !== undefined;
+}
+exports.isLiteralType = isLiteralType;
+function isLiteralTypeOrUnion(type) {
+    if ((0, types_1.isClassInstance)(type)) {
+        return type.literalValue !== undefined;
+    }
+    if ((0, types_1.isUnion)(type)) {
+        return !(0, types_1.findSubtype)(type, (subtype) => !(0, types_1.isClassInstance)(subtype) || subtype.literalValue === undefined);
+    }
+    return false;
+}
+exports.isLiteralTypeOrUnion = isLiteralTypeOrUnion;
+function containsLiteralType(type, includeTypeArgs = false, recursionCount = 0) {
+    var _a;
+    if (recursionCount > types_1.maxTypeRecursionCount) {
+        return false;
+    }
+    recursionCount++;
+    if ((0, types_1.isClassInstance)(type) && isLiteralType(type)) {
+        return true;
+    }
+    if (includeTypeArgs && (0, types_1.isClass)(type)) {
+        const typeArgs = ((_a = type.tupleTypeArguments) === null || _a === void 0 ? void 0 : _a.map((t) => t.type)) || type.typeArguments;
+        if (typeArgs) {
+            return typeArgs.some((typeArg) => containsLiteralType(typeArg, includeTypeArgs, recursionCount));
+        }
+    }
+    if ((0, types_1.isUnion)(type)) {
+        return type.subtypes.some((subtype) => containsLiteralType(subtype, includeTypeArgs, recursionCount));
+    }
+    if ((0, types_1.isOverloadedFunction)(type)) {
+        return type.overloads.some((overload) => containsLiteralType(overload, includeTypeArgs, recursionCount));
+    }
+    if ((0, types_1.isFunction)(type)) {
+        const returnType = types_1.FunctionType.getSpecializedReturnType(type);
+        if (returnType && containsLiteralType(returnType, includeTypeArgs, recursionCount)) {
+            return true;
+        }
+        for (let i = 0; i < type.details.parameters.length; i++) {
+            const paramType = types_1.FunctionType.getEffectiveParameterType(type, i);
+            if (containsLiteralType(paramType, includeTypeArgs, recursionCount)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+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,
+// it returns undefined.
+function getLiteralTypeClassName(type) {
+    if ((0, types_1.isClassInstance)(type)) {
+        if (type.literalValue !== undefined && types_1.ClassType.isBuiltIn(type)) {
+            return type.details.name;
+        }
+        return undefined;
+    }
+    if ((0, types_1.isUnion)(type)) {
+        let className;
+        let foundMismatch = false;
+        doForEachSubtype(type, (subtype) => {
+            const subtypeLiteralTypeName = getLiteralTypeClassName(subtype);
+            if (!subtypeLiteralTypeName) {
+                foundMismatch = true;
+            }
+            else if (!className) {
+                className = subtypeLiteralTypeName;
+            }
+        });
+        return foundMismatch ? undefined : className;
+    }
+    return undefined;
+}
+exports.getLiteralTypeClassName = getLiteralTypeClassName;
+function getUnionSubtypeCount(type) {
+    if ((0, types_1.isUnion)(type)) {
+        return type.subtypes.length;
+    }
+    return 1;
+}
+exports.getUnionSubtypeCount = getUnionSubtypeCount;
+function isEllipsisType(type) {
+    return (0, types_1.isAny)(type) && type.isEllipsis;
+}
+exports.isEllipsisType = isEllipsisType;
+function isProperty(type) {
+    return (0, types_1.isClassInstance)(type) && types_1.ClassType.isPropertyClass(type);
+}
+exports.isProperty = isProperty;
+function isDescriptorInstance(type, requireSetter = false) {
+    if ((0, types_1.isUnion)(type)) {
+        return type.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.subtypes.some((subtype) => isMaybeDescriptorInstance(subtype, requireSetter));
+    }
+    if (!(0, types_1.isClassInstance)(type)) {
+        return false;
+    }
+    if (!type.details.fields.has('__get__')) {
+        return false;
+    }
+    if (requireSetter && !type.details.fields.has('__set__')) {
+        return false;
+    }
+    return true;
+}
+exports.isMaybeDescriptorInstance = isMaybeDescriptorInstance;
+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.
+function isUnboundedTupleClass(type) {
+    return type.tupleTypeArguments && type.tupleTypeArguments.some((t) => t.isUnbounded);
+}
+exports.isUnboundedTupleClass = isUnboundedTupleClass;
+// Partially specializes a type within the context of a specified
+// (presumably specialized) class. Optionally specializes the `Self`
+// type variables, replacing them with selfClass.
+function partiallySpecializeType(type, contextClassType, selfClass, typeClassType) {
+    // If the context class is not specialized (or doesn't need specialization),
+    // then there's no need to do any more work.
+    if (types_1.ClassType.isUnspecialized(contextClassType)) {
+        return type;
+    }
+    // Partially specialize the type using the specialized class type vars.
+    const typeVarContext = buildTypeVarContextFromSpecializedClass(contextClassType, /* makeConcrete */ undefined);
+    if (selfClass) {
+        populateTypeVarContextForSelfType(typeVarContext, contextClassType, selfClass);
+    }
+    return applySolvedTypeVars(type, typeVarContext, 
+    /* unknownIfNotFound */ undefined, 
+    /* useNarrowBoundOnly */ undefined, 
+    /* eliminateUnsolvedInUnions */ undefined, typeClassType);
+}
+exports.partiallySpecializeType = partiallySpecializeType;
+function populateTypeVarContextForSelfType(typeVarContext, contextClassType, selfClass) {
+    const synthesizedSelfTypeVar = synthesizeTypeVarForSelfCls(contextClassType, /* isClsParam */ false);
+    typeVarContext.setTypeVarType(synthesizedSelfTypeVar, convertToInstance(selfClass));
+}
+exports.populateTypeVarContextForSelfType = populateTypeVarContextForSelfType;
+// Specializes a (potentially generic) type by substituting
+// type variables from a type var map.
+function applySolvedTypeVars(type, typeVarContext, unknownIfNotFound = false, useNarrowBoundOnly = false, eliminateUnsolvedInUnions = false, typeClassType) {
+    // Use a shortcut if the typeVarContext is empty and no transform is necessary.
+    if (typeVarContext.isEmpty() && !unknownIfNotFound && !eliminateUnsolvedInUnions) {
+        return type;
+    }
+    const transformer = new ApplySolvedTypeVarsTransformer(typeVarContext, unknownIfNotFound, useNarrowBoundOnly, eliminateUnsolvedInUnions, typeClassType);
+    return transformer.apply(type);
+}
+exports.applySolvedTypeVars = applySolvedTypeVars;
+// During bidirectional type inference for constructors, an "executed 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
+// class we are constructing. We'll replace these type variables with dummy
+// type variables that are scoped to the appropriate context.
+function transformExpectedTypeForConstructor(expectedType, typeVarContext, liveTypeVarScopes) {
+    const isTypeVarLive = (typeVar) => liveTypeVarScopes.some((scopeId) => typeVar.scopeId === scopeId);
+    // Handle "naked TypeVars" (i.e. the expectedType is a TypeVar itself)
+    // specially. Return undefined to indicate that it's an out-of-scope
+    // TypeVar.
+    if ((0, types_1.isTypeVar)(expectedType)) {
+        if (isTypeVarLive(expectedType)) {
+            return expectedType;
+        }
+        return undefined;
+    }
+    const transformer = new ExpectedConstructorTypeTransformer(typeVarContext, liveTypeVarScopes);
+    return transformer.apply(expectedType);
+}
+exports.transformExpectedTypeForConstructor = transformExpectedTypeForConstructor;
+// Given a protocol 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 appears
+// in a parent and a child, the child overrides the parent.
+function getProtocolSymbols(classType) {
+    const symbolMap = new Map();
+    if (types_1.ClassType.isProtocolClass(classType)) {
+        getProtocolSymbolsRecursive(classType, symbolMap);
+    }
+    return symbolMap;
+}
+exports.getProtocolSymbols = getProtocolSymbols;
+function getProtocolSymbolsRecursive(classType, symbolMap, recursionCount = 0) {
+    if (recursionCount > types_1.maxTypeRecursionCount) {
+        return;
+    }
+    classType.details.baseClasses.forEach((baseClass) => {
+        if ((0, types_1.isClass)(baseClass) && types_1.ClassType.isProtocolClass(baseClass)) {
+            getProtocolSymbolsRecursive(baseClass, symbolMap, recursionCount + 1);
+        }
+    });
+    classType.details.fields.forEach((symbol, name) => {
+        if (!symbol.isIgnoredForProtocolMatch()) {
+            symbolMap.set(name, {
+                symbol,
+                classType,
+                isInstanceMember: symbol.isInstanceMember(),
+                isClassMember: symbol.isClassMember(),
+                isClassVar: symbol.isClassVar(),
+                isTypeDeclared: symbol.hasTypedDeclarations(),
+                skippedUndeclaredType: false,
+            });
+        }
+    });
+}
+function lookUpObjectMember(objectType, memberName, flags = 0 /* Default */) {
+    if ((0, types_1.isClassInstance)(objectType)) {
+        return lookUpClassMember(objectType, memberName, flags);
+    }
+    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 /* Default */) {
+    var _a;
+    const memberItr = getClassMemberIterator(classType, memberName, flags);
+    return (_a = memberItr.next()) === null || _a === void 0 ? void 0 : _a.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/.
+// As it traverses the inheritance tree, it applies partial specialization
+// to the the base class and member. For example, if ClassA inherits from
+// ClassB[str] which inherits from Dict[_T1, int], a search for '__iter__'
+// would return a class type of Dict[str, int] and a symbolType of
+// (self) -> Iterator[str].
+function* getClassMemberIterator(classType, memberName, flags = 0 /* Default */) {
+    const declaredTypesOnly = (flags & 16 /* DeclaredTypesOnly */) !== 0;
+    let skippedUndeclaredType = false;
+    if ((0, types_1.isClass)(classType)) {
+        let classFlags = 0 /* Default */;
+        if (flags & 1 /* SkipOriginalClass */) {
+            classFlags = classFlags | 1 /* SkipOriginalClass */;
+        }
+        if (flags & 2 /* SkipBaseClasses */) {
+            classFlags = classFlags | 2 /* SkipBaseClasses */;
+        }
+        if (flags & 4 /* SkipObjectBaseClass */) {
+            classFlags = classFlags | 4 /* SkipObjectBaseClass */;
+        }
+        if (flags & 32 /* SkipTypeBaseClass */) {
+            classFlags = classFlags | 8 /* SkipTypeBaseClass */;
+        }
+        const classItr = getClassIterator(classType, classFlags);
+        for (const [mroClass, specializedMroClass] of classItr) {
+            if (!(0, types_1.isInstantiableClass)(mroClass)) {
+                if (!declaredTypesOnly) {
+                    // The class derives from an unknown type, so all bets are off
+                    // when trying to find a member. Return an unknown symbol.
+                    const cm = {
+                        symbol: symbol_1.Symbol.createWithType(0 /* None */, types_1.UnknownType.create()),
+                        isInstanceMember: false,
+                        isClassMember: true,
+                        isClassVar: false,
+                        classType: types_1.UnknownType.create(),
+                        isTypeDeclared: false,
+                        skippedUndeclaredType: false,
+                    };
+                    yield cm;
+                }
+                continue;
+            }
+            if (!(0, types_1.isInstantiableClass)(specializedMroClass)) {
+                continue;
+            }
+            const memberFields = specializedMroClass.details.fields;
+            // Look at instance members first if requested.
+            if ((flags & 8 /* SkipInstanceVariables */) === 0) {
+                const symbol = memberFields.get(memberName);
+                if (symbol && symbol.isInstanceMember()) {
+                    const hasDeclaredType = symbol.hasTypedDeclarations();
+                    if (!declaredTypesOnly || hasDeclaredType) {
+                        const cm = {
+                            symbol,
+                            isInstanceMember: true,
+                            isClassMember: symbol.isClassMember(),
+                            isClassVar: symbol.isClassVar(),
+                            classType: specializedMroClass,
+                            isTypeDeclared: hasDeclaredType,
+                            skippedUndeclaredType,
+                        };
+                        yield cm;
+                    }
+                    else {
+                        skippedUndeclaredType = true;
+                    }
+                }
+            }
+            // Next look at class members.
+            const symbol = memberFields.get(memberName);
+            if (symbol && symbol.isClassMember()) {
+                const hasDeclaredType = symbol.hasTypedDeclarations();
+                if (!declaredTypesOnly || hasDeclaredType) {
+                    let isInstanceMember = symbol.isInstanceMember();
+                    let isClassMember = true;
+                    // For data classes and typed dicts, variables that are declared
+                    // within the class are treated as instance variables. This distinction
+                    // is important in cases where a variable is a callable type because
+                    // we don't want to bind it to the instance like we would for a
+                    // class member.
+                    const isDataclass = types_1.ClassType.isDataClass(specializedMroClass);
+                    const isTypedDict = types_1.ClassType.isTypedDictClass(specializedMroClass);
+                    if (isDataclass || isTypedDict) {
+                        const decls = symbol.getDeclarations();
+                        if (decls.length > 0 && decls[0].type === 1 /* Variable */) {
+                            isInstanceMember = true;
+                            isClassMember = isDataclass;
+                        }
+                    }
+                    const cm = {
+                        symbol,
+                        isInstanceMember,
+                        isClassMember,
+                        isClassVar: symbol.isClassVar(),
+                        classType: specializedMroClass,
+                        isTypeDeclared: hasDeclaredType,
+                        skippedUndeclaredType,
+                    };
+                    yield cm;
+                }
+                else {
+                    skippedUndeclaredType = true;
+                }
+            }
+        }
+    }
+    else if ((0, types_1.isAnyOrUnknown)(classType)) {
+        // The class derives from an unknown type, so all bets are off
+        // when trying to find a member. Return an unknown symbol.
+        const cm = {
+            symbol: symbol_1.Symbol.createWithType(0 /* None */, types_1.UnknownType.create()),
+            isInstanceMember: false,
+            isClassMember: true,
+            isClassVar: false,
+            classType: types_1.UnknownType.create(),
+            isTypeDeclared: false,
+            skippedUndeclaredType: false,
+        };
+        yield cm;
+    }
+    return undefined;
+}
+exports.getClassMemberIterator = getClassMemberIterator;
+function* getClassIterator(classType, flags = 0 /* Default */) {
+    if ((0, types_1.isClass)(classType)) {
+        let skipMroEntry = (flags & 1 /* SkipOriginalClass */) !== 0;
+        for (const mroClass of classType.details.mro) {
+            if (skipMroEntry) {
+                skipMroEntry = false;
+                continue;
+            }
+            // If mroClass is an ancestor of classType, partially specialize
+            // it in the context of classType.
+            const specializedMroClass = partiallySpecializeType(mroClass, classType);
+            // Should we ignore members on the 'object' base class?
+            if (flags & 4 /* SkipObjectBaseClass */) {
+                if ((0, types_1.isInstantiableClass)(specializedMroClass)) {
+                    if (types_1.ClassType.isBuiltIn(specializedMroClass, 'object')) {
+                        break;
+                    }
+                }
+            }
+            // Should we ignore members on the 'type' base class?
+            if (flags & 8 /* SkipTypeBaseClass */) {
+                if ((0, types_1.isInstantiableClass)(specializedMroClass)) {
+                    if (types_1.ClassType.isBuiltIn(specializedMroClass, 'type')) {
+                        break;
+                    }
+                }
+            }
+            yield [mroClass, specializedMroClass];
+            if ((flags & 2 /* SkipBaseClasses */) !== 0) {
+                break;
+            }
+        }
+    }
+    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.
+    for (let i = classType.details.mro.length - 1; i >= 0; i--) {
+        const mroClass = partiallySpecializeType(classType.details.mro[i], classType);
+        // If this ancestor class is unknown, throw away all symbols
+        // found so far because they could be overridden by the unknown class.
+        if (!(0, types_1.isClass)(mroClass)) {
+            memberMap.clear();
+            continue;
+        }
+        mroClass.details.fields.forEach((symbol, name) => {
+            if (!symbol.isIgnoredForProtocolMatch() && symbol.hasTypedDeclarations()) {
+                memberMap.set(name, {
+                    classType: mroClass,
+                    symbol,
+                    isInstanceMember: symbol.isInstanceMember(),
+                    isClassMember: symbol.isClassMember(),
+                    isClassVar: symbol.isClassVar(),
+                    isTypeDeclared: true,
+                    skippedUndeclaredType: false,
+                });
+            }
+        });
+    }
+    return memberMap;
+}
+exports.getClassFieldsRecursive = getClassFieldsRecursive;
+// Combines two lists of type var types, maintaining the combined order
+// but removing any duplicates.
+function addTypeVarsToListIfUnique(list1, list2) {
+    for (const type2 of list2) {
+        if (!list1.find((type1) => (0, types_1.isTypeSame)(convertToInstance(type1), convertToInstance(type2)))) {
+            list1.push(type2);
+        }
+    }
+}
+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
+// Union[List[Dict[_T1, _T2]], _T1, _T3], the result would be
+// [_T1, _T2, _T3].
+function getTypeVarArgumentsRecursive(type, recursionCount = 0) {
+    var _a, _b;
+    if (recursionCount > types_1.maxTypeRecursionCount) {
+        return [];
+    }
+    recursionCount++;
+    const getTypeVarsFromClass = (classType) => {
+        const combinedList = [];
+        if (classType.typeArguments) {
+            classType.typeArguments.forEach((typeArg) => {
+                addTypeVarsToListIfUnique(combinedList, getTypeVarArgumentsRecursive(typeArg, recursionCount));
+            });
+        }
+        return combinedList;
+    };
+    if ((_a = type.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.typeArguments) {
+        const combinedList = [];
+        (_b = type.typeAliasInfo) === null || _b === void 0 ? void 0 : _b.typeArguments.forEach((typeArg) => {
+            addTypeVarsToListIfUnique(combinedList, getTypeVarArgumentsRecursive(typeArg, recursionCount));
+        });
+        return combinedList;
+    }
+    if ((0, types_1.isTypeVar)(type)) {
+        // Don't return any recursive type alias placeholders.
+        if (type.details.recursiveTypeAliasName) {
+            return [];
+        }
+        // Don't return any P.args or P.kwargs types.
+        if ((0, types_1.isParamSpec)(type) && type.paramSpecAccess) {
+            return [];
+        }
+        return [types_1.TypeBase.isInstantiable(type) ? types_1.TypeVarType.cloneAsInstance(type) : type];
+    }
+    if ((0, types_1.isClass)(type)) {
+        return getTypeVarsFromClass(type);
+    }
+    if ((0, types_1.isUnion)(type)) {
+        const combinedList = [];
+        doForEachSubtype(type, (subtype) => {
+            addTypeVarsToListIfUnique(combinedList, getTypeVarArgumentsRecursive(subtype, recursionCount));
+        });
+        return combinedList;
+    }
+    if ((0, types_1.isFunction)(type)) {
+        const combinedList = [];
+        for (let i = 0; i < type.details.parameters.length; i++) {
+            addTypeVarsToListIfUnique(combinedList, getTypeVarArgumentsRecursive(types_1.FunctionType.getEffectiveParameterType(type, i), recursionCount));
+        }
+        if (type.details.paramSpec) {
+            addTypeVarsToListIfUnique(combinedList, [type.details.paramSpec]);
+        }
+        const returnType = types_1.FunctionType.getSpecializedReturnType(type);
+        if (returnType) {
+            addTypeVarsToListIfUnique(combinedList, getTypeVarArgumentsRecursive(returnType, recursionCount));
+        }
+        return combinedList;
+    }
+    return [];
+}
+exports.getTypeVarArgumentsRecursive = getTypeVarArgumentsRecursive;
+// 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 typeParams = types_1.ClassType.getTypeParameters(type);
+    typeParams.forEach((typeParam) => {
+        typeVarContext.setTypeVarType(typeParam, types_1.UnknownType.create());
+    });
+    return applySolvedTypeVars(type, typeVarContext);
+}
+exports.specializeClassType = specializeClassType;
+// Recursively finds all of the type arguments and sets them
+// to the specified srcType.
+function setTypeArgumentsRecursive(destType, srcType, typeVarContext, recursionCount = 0) {
+    if (recursionCount > types_1.maxTypeRecursionCount) {
+        return;
+    }
+    recursionCount++;
+    if (typeVarContext.isLocked()) {
+        return;
+    }
+    switch (destType.category) {
+        case 9 /* Union */:
+            doForEachSubtype(destType, (subtype) => {
+                setTypeArgumentsRecursive(subtype, srcType, typeVarContext, recursionCount);
+            });
+            break;
+        case 7 /* Class */:
+            if (destType.typeArguments) {
+                destType.typeArguments.forEach((typeArg) => {
+                    setTypeArgumentsRecursive(typeArg, srcType, typeVarContext, recursionCount);
+                });
+            }
+            if (destType.tupleTypeArguments) {
+                destType.tupleTypeArguments.forEach((typeArg) => {
+                    setTypeArgumentsRecursive(typeArg.type, srcType, typeVarContext, recursionCount);
+                });
+            }
+            break;
+        case 5 /* Function */:
+            if (destType.specializedTypes) {
+                destType.specializedTypes.parameterTypes.forEach((paramType) => {
+                    setTypeArgumentsRecursive(paramType, srcType, typeVarContext, recursionCount);
+                });
+                if (destType.specializedTypes.returnType) {
+                    setTypeArgumentsRecursive(destType.specializedTypes.returnType, srcType, typeVarContext, recursionCount);
+                }
+            }
+            else {
+                destType.details.parameters.forEach((param) => {
+                    setTypeArgumentsRecursive(param.type, srcType, typeVarContext, recursionCount);
+                });
+                if (destType.details.declaredReturnType) {
+                    setTypeArgumentsRecursive(destType.details.declaredReturnType, srcType, typeVarContext, recursionCount);
+                }
+                if (destType.details.paramSpec) {
+                    // Fill in an empty signature for a ParamSpec if the source is Any or Unknown.
+                    if (!typeVarContext.hasTypeVar(destType.details.paramSpec) && (0, types_1.isAnyOrUnknown)(srcType)) {
+                        typeVarContext.setParamSpec(destType.details.paramSpec, {
+                            flags: 0 /* None */,
+                            parameters: types_1.FunctionType.getDefaultParameters(),
+                            typeVarScopeId: undefined,
+                            docString: undefined,
+                            paramSpec: undefined,
+                        });
+                    }
+                }
+            }
+            break;
+        case 6 /* OverloadedFunction */:
+            destType.overloads.forEach((subtype) => {
+                setTypeArgumentsRecursive(subtype, srcType, typeVarContext, recursionCount);
+            });
+            break;
+        case 10 /* TypeVar */:
+            if (!typeVarContext.hasTypeVar(destType)) {
+                typeVarContext.setTypeVarType(destType, srcType);
+            }
+            break;
+    }
+}
+exports.setTypeArgumentsRecursive = setTypeArgumentsRecursive;
+// 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, makeConcrete = true) {
+    const typeParameters = types_1.ClassType.getTypeParameters(classType);
+    let typeArguments = classType.typeArguments;
+    // If there are no type arguments, we can either use the type variables
+    // from the type parameters (keeping the type arguments generic) or
+    // fill in concrete types.
+    if (!typeArguments && !makeConcrete) {
+        typeArguments = typeParameters;
+    }
+    const typeVarContext = buildTypeVarContext(typeParameters, typeArguments, getTypeVarScopeId(classType));
+    if (types_1.ClassType.isTupleClass(classType) && classType.tupleTypeArguments && typeParameters.length >= 1) {
+        typeVarContext.setVariadicTypeVar(typeParameters[0], classType.tupleTypeArguments);
+    }
+    return typeVarContext;
+}
+exports.buildTypeVarContextFromSpecializedClass = buildTypeVarContextFromSpecializedClass;
+function buildTypeVarContext(typeParameters, typeArgs, typeVarScopeId) {
+    const typeVarContext = new typeVarContext_1.TypeVarContext(typeVarScopeId);
+    typeParameters.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 paramSpecEntries = [];
+                        const typeArgFunctionType = typeArgType;
+                        typeArgType.details.parameters.forEach((param, paramIndex) => {
+                            paramSpecEntries.push({
+                                category: param.category,
+                                name: param.name,
+                                hasDefault: !!param.hasDefault,
+                                isNameSynthesized: param.isNameSynthesized,
+                                type: types_1.FunctionType.getEffectiveParameterType(typeArgFunctionType, paramIndex),
+                            });
+                        });
+                        typeVarContext.setParamSpec(typeParam, {
+                            parameters: paramSpecEntries,
+                            typeVarScopeId: typeArgType.details.typeVarScopeId,
+                            flags: typeArgType.details.flags,
+                            docString: typeArgType.details.docString,
+                            paramSpec: typeArgType.details.paramSpec,
+                        });
+                    }
+                    else if ((0, types_1.isParamSpec)(typeArgType)) {
+                        typeVarContext.setParamSpec(typeParam, {
+                            flags: 0 /* None */,
+                            parameters: [],
+                            typeVarScopeId: undefined,
+                            docString: undefined,
+                            paramSpec: typeArgType,
+                        });
+                    }
+                    else if ((0, types_1.isAnyOrUnknown)(typeArgType)) {
+                        // Fill in an empty signature if the arg type is Any or Unknown.
+                        typeVarContext.setParamSpec(typeParam, {
+                            flags: 0 /* None */,
+                            parameters: types_1.FunctionType.getDefaultParameters(),
+                            typeVarScopeId: undefined,
+                            docString: undefined,
+                            paramSpec: undefined,
+                        });
+                    }
+                }
+            }
+            else {
+                if (index >= typeArgs.length) {
+                    typeArgType = types_1.AnyType.create();
+                }
+                else {
+                    typeArgType = typeArgs[index];
+                }
+                typeVarContext.setTypeVarType(typeParam, typeArgType, typeArgType, /* retainLiteral */ true);
+            }
+        }
+    });
+    return typeVarContext;
+}
+exports.buildTypeVarContext = buildTypeVarContext;
+// Determines the specialized base class type that srcType derives from.
+function specializeForBaseClass(srcType, baseClass) {
+    const typeParams = types_1.ClassType.getTypeParameters(baseClass);
+    // If there are no type parameters for the specified base class,
+    // no specialization is required.
+    if (typeParams.length === 0) {
+        return baseClass;
+    }
+    const typeVarContext = buildTypeVarContextFromSpecializedClass(srcType);
+    const specializedType = applySolvedTypeVars(baseClass, typeVarContext);
+    (0, debug_1.assert)((0, types_1.isInstantiableClass)(specializedType));
+    return specializedType;
+}
+exports.specializeForBaseClass = specializeForBaseClass;
+// 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.
+function derivesFromClassRecursive(classType, baseClassToFind, ignoreUnknown) {
+    if (types_1.ClassType.isSameGenericClass(classType, baseClassToFind)) {
+        return true;
+    }
+    for (const baseClass of classType.details.baseClasses) {
+        if ((0, types_1.isInstantiableClass)(baseClass)) {
+            if (derivesFromClassRecursive(baseClass, baseClassToFind, ignoreUnknown)) {
+                return true;
+            }
+        }
+        else if (!ignoreUnknown && (0, types_1.isAnyOrUnknown)(baseClass)) {
+            // If the base class is unknown, we have to make a conservative assumption.
+            return true;
+        }
+    }
+    return false;
+}
+exports.derivesFromClassRecursive = derivesFromClassRecursive;
+function synthesizeTypeVarForSelfCls(classType, isClsParam) {
+    var _a;
+    const selfType = types_1.TypeVarType.createInstance(`__type_of_self__`);
+    const scopeId = (_a = getTypeVarScopeId(classType)) !== null && _a !== void 0 ? _a : '';
+    selfType.details.isSynthesized = true;
+    selfType.details.isSynthesizedSelf = true;
+    selfType.nameWithScope = types_1.TypeVarType.makeNameWithScope(selfType.details.name, scopeId);
+    selfType.scopeId = scopeId;
+    const boundType = types_1.ClassType.cloneForSpecialization(classType, types_1.ClassType.getTypeParameters(classType), 
+    /* isTypeArgumentExplicit */ false, 
+    /* includeSubclasses */ true);
+    selfType.details.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) {
+    const returnType = types_1.FunctionType.getSpecializedReturnType(functionType);
+    if (returnType) {
+        const generatorTypeArgs = getGeneratorTypeArgs(returnType);
+        if (generatorTypeArgs) {
+            // The send type is the third type arg.
+            return generatorTypeArgs.length >= 3 ? generatorTypeArgs[2] : types_1.UnknownType.create();
+        }
+    }
+    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.
+function getGeneratorYieldType(declaredReturnType, isAsync) {
+    let isLegalGeneratorType = true;
+    const yieldType = mapSubtypes(declaredReturnType, (subtype) => {
+        if ((0, types_1.isAnyOrUnknown)(subtype)) {
+            return subtype;
+        }
+        if ((0, types_1.isClassInstance)(subtype)) {
+            const expectedClasses = [
+                ['AsyncIterable', 'Iterable'],
+                ['AsyncIterator', 'Iterator'],
+                ['AsyncGenerator', 'Generator'],
+                ['', 'AwaitableGenerator'],
+            ];
+            if (expectedClasses.some((classes) => types_1.ClassType.isBuiltIn(subtype, isAsync ? classes[0] : classes[1]))) {
+                return subtype.typeArguments && subtype.typeArguments.length >= 1
+                    ? subtype.typeArguments[0]
+                    : types_1.UnknownType.create();
+            }
+        }
+        isLegalGeneratorType = false;
+        return undefined;
+    });
+    return isLegalGeneratorType ? yieldType : undefined;
+}
+exports.getGeneratorYieldType = getGeneratorYieldType;
+function isEffectivelyInstantiable(type) {
+    if (types_1.TypeBase.isInstantiable(type)) {
+        return true;
+    }
+    // Handle the special case of 'type', which is instantiable.
+    if ((0, types_1.isClassInstance)(type) && types_1.ClassType.isBuiltIn(type, 'type')) {
+        return true;
+    }
+    if ((0, types_1.isUnion)(type)) {
+        return type.subtypes.every((subtype) => isEffectivelyInstantiable(subtype));
+    }
+    return false;
+}
+exports.isEffectivelyInstantiable = isEffectivelyInstantiable;
+function convertToInstance(type) {
+    let result = mapSubtypes(type, (subtype) => {
+        switch (subtype.category) {
+            case 7 /* Class */: {
+                // Handle Type[x] as a special case.
+                if (types_1.ClassType.isBuiltIn(subtype, 'Type')) {
+                    if (!subtype.typeArguments || subtype.typeArguments.length < 1) {
+                        return types_1.UnknownType.create();
+                    }
+                    else {
+                        return convertToInstantiable(subtype.typeArguments[0]);
+                    }
+                }
+                return types_1.ClassType.cloneAsInstance(subtype);
+            }
+            case 3 /* None */: {
+                return types_1.NoneType.createInstance();
+            }
+            case 5 /* Function */: {
+                if (types_1.TypeBase.isInstantiable(subtype)) {
+                    return types_1.FunctionType.cloneAsInstance(subtype);
+                }
+                break;
+            }
+            case 10 /* TypeVar */: {
+                if (types_1.TypeBase.isInstantiable(subtype)) {
+                    return types_1.TypeVarType.cloneAsInstance(subtype);
+                }
+                break;
+            }
+        }
+        return subtype;
+    });
+    // Copy over any type alias information.
+    if (type.typeAliasInfo && type !== result) {
+        result = types_1.TypeBase.cloneForTypeAlias(result, type.typeAliasInfo.name, type.typeAliasInfo.fullName, type.typeAliasInfo.typeVarScopeId, type.typeAliasInfo.typeParameters, type.typeAliasInfo.typeArguments);
+    }
+    return result;
+}
+exports.convertToInstance = convertToInstance;
+function convertToInstantiable(type) {
+    let result = mapSubtypes(type, (subtype) => {
+        switch (subtype.category) {
+            case 7 /* Class */: {
+                return types_1.ClassType.cloneAsInstantiable(subtype);
+            }
+            case 3 /* None */: {
+                return types_1.NoneType.createType();
+            }
+            case 5 /* Function */: {
+                return types_1.FunctionType.cloneAsInstantiable(subtype);
+            }
+            case 10 /* TypeVar */: {
+                return types_1.TypeVarType.cloneAsInstantiable(subtype);
+            }
+        }
+        return subtype;
+    });
+    // Copy over any type alias information.
+    if (type.typeAliasInfo && type !== result) {
+        result = types_1.TypeBase.cloneForTypeAlias(result, type.typeAliasInfo.name, type.typeAliasInfo.fullName, type.typeAliasInfo.typeVarScopeId, type.typeAliasInfo.typeParameters, type.typeAliasInfo.typeArguments);
+    }
+    return result;
+}
+exports.convertToInstantiable = convertToInstantiable;
+function getMembersForClass(classType, symbolTable, includeInstanceVars) {
+    for (let i = 0; i < classType.details.mro.length; i++) {
+        const mroClass = classType.details.mro[i];
+        if ((0, types_1.isInstantiableClass)(mroClass)) {
+            // Add any new member variables from this class.
+            const isClassTypedDict = types_1.ClassType.isTypedDictClass(mroClass);
+            mroClass.details.fields.forEach((symbol, name) => {
+                if (symbol.isClassMember() || (includeInstanceVars && symbol.isInstanceMember())) {
+                    if (!isClassTypedDict || !(0, symbolUtils_1.isTypedDictMemberAccessedThroughIndex)(symbol)) {
+                        if (!symbol.isInitVar()) {
+                            const existingSymbol = symbolTable.get(name);
+                            if (!existingSymbol) {
+                                symbolTable.set(name, symbol);
+                            }
+                            else if (!existingSymbol.hasTypedDeclarations() && symbol.hasTypedDeclarations()) {
+                                // If the existing symbol is unannotated but a parent class
+                                // has an annotation for the symbol, use the parent type instead.
+                                symbolTable.set(name, symbol);
+                            }
+                        }
+                    }
+                }
+            });
+        }
+    }
+    // Add members of the metaclass as well.
+    if (!includeInstanceVars) {
+        const metaclass = classType.details.effectiveMetaclass;
+        if (metaclass && (0, types_1.isInstantiableClass)(metaclass)) {
+            for (const mroClass of metaclass.details.mro) {
+                if ((0, types_1.isInstantiableClass)(mroClass)) {
+                    mroClass.details.fields.forEach((symbol, name) => {
+                        const existingSymbol = symbolTable.get(name);
+                        if (!existingSymbol) {
+                            symbolTable.set(name, symbol);
+                        }
+                        else if (!existingSymbol.hasTypedDeclarations() && symbol.hasTypedDeclarations()) {
+                            // If the existing symbol is unannotated but a parent class
+                            // has an annotation for the symbol, use the parent type instead.
+                            symbolTable.set(name, symbol);
+                        }
+                    });
+                }
+                else {
+                    break;
+                }
+            }
+        }
+    }
+}
+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
+    // loader fields.
+    if (moduleType.loaderFields) {
+        moduleType.loaderFields.forEach((symbol, name) => {
+            symbolTable.set(name, symbol);
+        });
+    }
+    moduleType.fields.forEach((symbol, name) => {
+        symbolTable.set(name, symbol);
+    });
+}
+exports.getMembersForModule = getMembersForModule;
+// Determines if the type is an Unknown or a union that contains an Unknown.
+// It does not look at type arguments.
+function containsUnknown(type) {
+    let foundUnknown = false;
+    doForEachSubtype(type, (subtype) => {
+        if ((0, types_1.isUnknown)(subtype)) {
+            foundUnknown = true;
+        }
+    });
+    return foundUnknown;
+}
+exports.containsUnknown = containsUnknown;
+// Determines if any part of the type contains "Unknown", including any type arguments.
+function isPartlyUnknown(type, allowUnknownTypeArgsForClasses = false, recursionCount = 0) {
+    var _a, _b;
+    if (recursionCount > types_1.maxTypeRecursionCount) {
+        return false;
+    }
+    recursionCount++;
+    if ((0, types_1.isUnknown)(type)) {
+        return true;
+    }
+    // If this is a generic type alias, see if any of its type arguments
+    // are either unspecified or are partially known.
+    if ((_a = type.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.typeArguments) {
+        if (type.typeAliasInfo.typeArguments.some((typeArg) => isPartlyUnknown(typeArg, allowUnknownTypeArgsForClasses, recursionCount))) {
+            return true;
+        }
+    }
+    // See if a union contains an unknown type.
+    if ((0, types_1.isUnion)(type)) {
+        return ((0, types_1.findSubtype)(type, (subtype) => isPartlyUnknown(subtype, allowUnknownTypeArgsForClasses, recursionCount)) !==
+            undefined);
+    }
+    // See if an object or class has an unknown type argument.
+    if ((0, types_1.isClass)(type)) {
+        if (types_1.TypeBase.isInstance(type)) {
+            allowUnknownTypeArgsForClasses = false;
+        }
+        if (!allowUnknownTypeArgsForClasses && !types_1.ClassType.isPseudoGenericClass(type)) {
+            const typeArgs = ((_b = type.tupleTypeArguments) === null || _b === void 0 ? void 0 : _b.map((t) => t.type)) || type.typeArguments;
+            if (typeArgs) {
+                for (const argType of typeArgs) {
+                    if (isPartlyUnknown(argType, allowUnknownTypeArgsForClasses, recursionCount)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    // See if a function has an unknown type.
+    if ((0, types_1.isOverloadedFunction)(type)) {
+        return type.overloads.some((overload) => {
+            return isPartlyUnknown(overload, false, recursionCount);
+        });
+    }
+    if ((0, types_1.isFunction)(type)) {
+        for (let i = 0; i < type.details.parameters.length; i++) {
+            // Ignore parameters such as "*" that have no name.
+            if (type.details.parameters[i].name) {
+                const paramType = types_1.FunctionType.getEffectiveParameterType(type, i);
+                if (isPartlyUnknown(paramType, /* allowUnknownTypeArgsForClasses */ false, recursionCount)) {
+                    return true;
+                }
+            }
+        }
+        if (type.details.declaredReturnType &&
+            !types_1.FunctionType.isParamSpecValue(type) &&
+            isPartlyUnknown(type.details.declaredReturnType, /* allowUnknownTypeArgsForClasses */ false, recursionCount)) {
+            return true;
+        }
+        return false;
+    }
+    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].
+function explodeGenericClass(classType) {
+    if (!classType.typeArguments || classType.typeArguments.length !== 1 || !(0, types_1.isUnion)(classType.typeArguments[0])) {
+        return classType;
+    }
+    return (0, types_1.combineTypes)(classType.typeArguments[0].subtypes.map((subtype) => {
+        return types_1.ClassType.cloneForSpecialization(classType, [subtype], /* isTypeArgumentExplicit */ true);
+    }));
+}
+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) {
+    if (!tupleType || !(0, types_1.isInstantiableClass)(tupleType) || isUnboundedTupleClass(tupleType)) {
+        return undefined;
+    }
+    let tupleEntries;
+    let isValid = true;
+    doForEachSubtype(type, (subtype) => {
+        if ((0, types_1.isClassInstance)(subtype)) {
+            let tupleClass;
+            if ((0, types_1.isClass)(subtype) && isTupleClass(subtype) && !isUnboundedTupleClass(subtype)) {
+                tupleClass = subtype;
+            }
+            if (!tupleClass) {
+                // Look in the mro list to see if this subtype derives from a
+                // tuple with a known size. This includes named tuples.
+                tupleClass = subtype.details.mro.find((mroClass) => (0, types_1.isClass)(mroClass) && isTupleClass(mroClass) && !isUnboundedTupleClass(mroClass));
+            }
+            if (tupleClass && (0, types_1.isClass)(tupleClass) && tupleClass.tupleTypeArguments) {
+                if (tupleEntries) {
+                    if (tupleEntries.length === tupleClass.tupleTypeArguments.length) {
+                        tupleClass.tupleTypeArguments.forEach((entry, index) => {
+                            tupleEntries[index].push(entry.type);
+                        });
+                    }
+                    else {
+                        isValid = false;
+                    }
+                }
+                else {
+                    tupleEntries = tupleClass.tupleTypeArguments.map((entry) => [entry.type]);
+                }
+            }
+            else {
+                isValid = false;
+            }
+        }
+        else {
+            isValid = false;
+        }
+    });
+    if (!isValid || !tupleEntries) {
+        return undefined;
+    }
+    return convertToInstance(specializeTupleClass(tupleType, tupleEntries.map((entry) => {
+        return { type: (0, types_1.combineTypes)(entry), isUnbounded: false };
+    })));
+}
+exports.combineSameSizedTuples = combineSameSizedTuples;
+// Tuples require special handling for specialization. This method computes
+// the "effective" type argument, which is a union of the variadic type
+// arguments. If stripLiterals is true, literal values are stripped when
+// computing the effective type args.
+function specializeTupleClass(classType, typeArgs, isTypeArgumentExplicit = true, stripLiterals = true, isUnpackedTuple = false) {
+    let combinedTupleType = (0, types_1.combineTypes)(typeArgs.map((t) => t.type));
+    if (stripLiterals) {
+        combinedTupleType = stripLiteralValue(combinedTupleType);
+    }
+    // An empty tuple has an effective type of Any.
+    if ((0, types_1.isNever)(combinedTupleType)) {
+        combinedTupleType = types_1.AnyType.create();
+    }
+    const clonedClassType = types_1.ClassType.cloneForSpecialization(classType, [combinedTupleType], isTypeArgumentExplicit, 
+    /* includeSubclasses */ undefined, typeArgs);
+    if (isUnpackedTuple) {
+        clonedClassType.isUnpacked = true;
+    }
+    return clonedClassType;
+}
+exports.specializeTupleClass = specializeTupleClass;
+// If the type is a function or overloaded function that has a paramSpec
+// associated with it and P.args and P.kwargs at the end of the signature,
+// it removes these parameters from the function.
+function removeParamSpecVariadicsFromSignature(type) {
+    if ((0, types_1.isFunction)(type)) {
+        return removeParamSpecVariadicsFromFunction(type);
+    }
+    const newOverloads = [];
+    let newTypeNeeded = false;
+    for (const overload of type.overloads) {
+        const newOverload = removeParamSpecVariadicsFromFunction(overload);
+        newOverloads.push(newOverload);
+        if (newOverload !== overload) {
+            newTypeNeeded = true;
+        }
+    }
+    return newTypeNeeded ? types_1.OverloadedFunctionType.create(newOverloads) : type;
+}
+exports.removeParamSpecVariadicsFromSignature = removeParamSpecVariadicsFromSignature;
+function removeParamSpecVariadicsFromFunction(type) {
+    const paramCount = type.details.parameters.length;
+    if (paramCount < 2) {
+        return type;
+    }
+    const argsParam = type.details.parameters[paramCount - 2];
+    const kwargsParam = type.details.parameters[paramCount - 1];
+    if (argsParam.category !== 1 /* VarArgList */ ||
+        kwargsParam.category !== 2 /* VarArgDictionary */ ||
+        !(0, types_1.isParamSpec)(argsParam.type) ||
+        !(0, types_1.isParamSpec)(kwargsParam.type) ||
+        !(0, types_1.isTypeSame)(argsParam.type, kwargsParam.type)) {
+        return type;
+    }
+    return types_1.FunctionType.cloneRemoveParamSpecVariadics(type, argsParam.type);
+}
+exports.removeParamSpecVariadicsFromFunction = removeParamSpecVariadicsFromFunction;
+function _expandVariadicUnpackedUnion(type) {
+    if ((0, types_1.isClassInstance)(type) && isTupleClass(type) && type.tupleTypeArguments && type.isUnpacked) {
+        return (0, types_1.combineTypes)(type.tupleTypeArguments.map((t) => t.type));
+    }
+    return type;
+}
+// If the declared return type for the function is a Generator or AsyncGenerator,
+// returns the type arguments for the type.
+function getGeneratorTypeArgs(returnType) {
+    var _a;
+    if ((0, types_1.isClassInstance)(returnType)) {
+        if (types_1.ClassType.isBuiltIn(returnType, ['Generator', 'AsyncGenerator'])) {
+            return returnType.typeArguments;
+        }
+        else if (types_1.ClassType.isBuiltIn(returnType, 'AwaitableGenerator')) {
+            // AwaitableGenerator has four type arguments, and the last 3
+            // correspond to the generator.
+            return (_a = returnType.typeArguments) === null || _a === void 0 ? void 0 : _a.slice(1);
+        }
+    }
+    return undefined;
+}
+exports.getGeneratorTypeArgs = getGeneratorTypeArgs;
+function requiresTypeArguments(classType) {
+    if (classType.details.typeParameters.length > 0) {
+        // If there are type parameters, type arguments are needed.
+        // The exception is if type parameters have been synthesized
+        // for classes that have untyped constructors.
+        return !classType.details.typeParameters[0].details.isSynthesized;
+    }
+    // There are a few built-in special classes that require
+    // type arguments even though typeParameters is empty.
+    if (types_1.ClassType.isSpecialBuiltIn(classType)) {
+        const specialClasses = [
+            'Tuple',
+            'Callable',
+            'Generic',
+            'Type',
+            'Optional',
+            'Union',
+            'Literal',
+            'Annotated',
+            'TypeGuard',
+            'StrictTypeGuard',
+        ];
+        if (specialClasses.some((t) => t === (classType.aliasName || classType.details.name))) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.requiresTypeArguments = requiresTypeArguments;
+function requiresSpecialization(type, ignorePseudoGeneric = false, ignoreSelf = false, recursionCount = 0) {
+    var _a;
+    if (recursionCount > types_1.maxTypeRecursionCount) {
+        return false;
+    }
+    recursionCount++;
+    switch (type.category) {
+        case 7 /* Class */: {
+            if (types_1.ClassType.isPseudoGenericClass(type) && ignorePseudoGeneric) {
+                return false;
+            }
+            if (type.typeArguments) {
+                return (type.typeArguments.find((typeArg) => requiresSpecialization(typeArg, ignorePseudoGeneric, ignoreSelf, recursionCount)) !== undefined);
+            }
+            return types_1.ClassType.getTypeParameters(type).length > 0;
+        }
+        case 5 /* Function */: {
+            if (type.details.paramSpec) {
+                return true;
+            }
+            for (let i = 0; i < type.details.parameters.length; i++) {
+                if (requiresSpecialization(types_1.FunctionType.getEffectiveParameterType(type, i), ignorePseudoGeneric, ignoreSelf, recursionCount)) {
+                    return true;
+                }
+            }
+            const declaredReturnType = type.specializedTypes && type.specializedTypes.returnType
+                ? type.specializedTypes.returnType
+                : type.details.declaredReturnType;
+            if (declaredReturnType) {
+                if (requiresSpecialization(declaredReturnType, ignorePseudoGeneric, ignoreSelf, recursionCount)) {
+                    return true;
+                }
+            }
+            else if (type.inferredReturnType) {
+                if (requiresSpecialization(type.inferredReturnType, ignorePseudoGeneric, ignoreSelf, recursionCount)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        case 6 /* OverloadedFunction */: {
+            return (type.overloads.find((overload) => requiresSpecialization(overload, ignorePseudoGeneric, ignoreSelf, recursionCount)) !== undefined);
+        }
+        case 9 /* Union */: {
+            return ((0, types_1.findSubtype)(type, (subtype) => requiresSpecialization(subtype, ignorePseudoGeneric, ignoreSelf, recursionCount)) !== undefined);
+        }
+        case 10 /* TypeVar */: {
+            // Most TypeVar types need to be specialized.
+            if (!type.details.recursiveTypeAliasName) {
+                if (type.details.isSynthesizedSelf && ignoreSelf) {
+                    return false;
+                }
+                return true;
+            }
+            // If this is a recursive type alias, it may need to be specialized
+            // if it has generic type arguments.
+            if ((_a = type.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.typeArguments) {
+                return type.typeAliasInfo.typeArguments.some((typeArg) => requiresSpecialization(typeArg, ignorePseudoGeneric, ignoreSelf, recursionCount));
+            }
+        }
+    }
+    return false;
+}
+exports.requiresSpecialization = requiresSpecialization;
+// 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
+// if an MRO was possible, false otherwise.
+function computeMroLinearization(classType) {
+    let isMroFound = true;
+    // Clear out any existing MRO information.
+    classType.details.mro = [];
+    const filteredBaseClasses = classType.details.baseClasses.filter((baseClass, index) => {
+        if ((0, types_1.isInstantiableClass)(baseClass)) {
+            // Generic has some special-case logic (see description of __mro_entries__
+            // in PEP 560) that we need to account for here.
+            if (types_1.ClassType.isBuiltIn(baseClass, 'Generic')) {
+                // If the class is a Protocol, the generic is ignored for the purposes
+                // of computing the MRO.
+                if (types_1.ClassType.isProtocolClass(classType)) {
+                    return false;
+                }
+                // If the class contains any specialized generic classes after
+                // the Generic base, the Generic base is ignored for purposes
+                // of computing the MRO.
+                if (classType.details.baseClasses.some((innerBaseClass, innerIndex) => {
+                    return (innerIndex > index &&
+                        (0, types_1.isInstantiableClass)(innerBaseClass) &&
+                        innerBaseClass.typeArguments &&
+                        innerBaseClass.isTypeArgumentExplicit);
+                })) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    });
+    // Construct the list of class lists that need to be merged.
+    const classListsToMerge = [];
+    filteredBaseClasses.forEach((baseClass, index) => {
+        if ((0, types_1.isInstantiableClass)(baseClass)) {
+            const typeVarContext = buildTypeVarContextFromSpecializedClass(baseClass, /* makeConcrete */ false);
+            classListsToMerge.push(baseClass.details.mro.map((mroClass) => {
+                return applySolvedTypeVars(mroClass, typeVarContext);
+            }));
+        }
+        else {
+            classListsToMerge.push([baseClass]);
+        }
+    });
+    classListsToMerge.push(filteredBaseClasses.map((baseClass) => {
+        const typeVarContext = buildTypeVarContextFromSpecializedClass(classType, /* makeConcrete */ false);
+        return applySolvedTypeVars(baseClass, typeVarContext);
+    }));
+    // The first class in the MRO is the class itself.
+    const typeVarContext = buildTypeVarContextFromSpecializedClass(classType, /* makeConcrete */ false);
+    classType.details.mro.push(applySolvedTypeVars(classType, typeVarContext));
+    // Helper function that returns true if the specified searchClass
+    // is found in the "tail" (i.e. in elements 1 through n) of any
+    // of the class lists.
+    const isInTail = (searchClass, classLists) => {
+        return classLists.some((classList) => {
+            return (classList.findIndex((value) => (0, types_1.isInstantiableClass)(value) && types_1.ClassType.isSameGenericClass(value, searchClass)) > 0);
+        });
+    };
+    const filterClass = (classToFilter, classLists) => {
+        for (let i = 0; i < classLists.length; i++) {
+            classLists[i] = classLists[i].filter((value) => !(0, types_1.isInstantiableClass)(value) || !types_1.ClassType.isSameGenericClass(value, classToFilter));
+        }
+    };
+    while (true) {
+        let foundValidHead = false;
+        let nonEmptyList = undefined;
+        for (let i = 0; i < classListsToMerge.length; i++) {
+            const classList = classListsToMerge[i];
+            if (classList.length > 0) {
+                if (nonEmptyList === undefined) {
+                    nonEmptyList = classList;
+                }
+                if (!(0, types_1.isInstantiableClass)(classList[0])) {
+                    foundValidHead = true;
+                    classType.details.mro.push(classList[0]);
+                    classList.shift();
+                    break;
+                }
+                else if (!isInTail(classList[0], classListsToMerge)) {
+                    foundValidHead = true;
+                    classType.details.mro.push(classList[0]);
+                    filterClass(classList[0], classListsToMerge);
+                    break;
+                }
+            }
+        }
+        // If all lists are empty, we are done.
+        if (!nonEmptyList) {
+            break;
+        }
+        // We made it all the way through the list of class lists without
+        // finding a valid head, but there is at least one list that's not
+        // yet empty. This means there's no valid MRO order.
+        if (!foundValidHead) {
+            isMroFound = false;
+            // Handle the situation by pull the head off the first empty list.
+            // This allows us to make forward progress.
+            if (!(0, types_1.isInstantiableClass)(nonEmptyList[0])) {
+                classType.details.mro.push(nonEmptyList[0]);
+                nonEmptyList.shift();
+            }
+            else {
+                classType.details.mro.push(nonEmptyList[0]);
+                filterClass(nonEmptyList[0], classListsToMerge);
+            }
+        }
+    }
+    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.
+function getDeclaringModulesForType(type) {
+    const moduleList = [];
+    addDeclaringModuleNamesForType(type, moduleList);
+    return moduleList;
+}
+exports.getDeclaringModulesForType = getDeclaringModulesForType;
+function addDeclaringModuleNamesForType(type, moduleList, recursionCount = 0) {
+    if (recursionCount > types_1.maxTypeRecursionCount) {
+        return;
+    }
+    recursionCount++;
+    const addIfUnique = (moduleName) => {
+        if (moduleName && !moduleList.some((n) => n === moduleName)) {
+            moduleList.push(moduleName);
+        }
+    };
+    switch (type.category) {
+        case 7 /* Class */: {
+            addIfUnique(type.details.moduleName);
+            break;
+        }
+        case 5 /* Function */: {
+            addIfUnique(type.details.moduleName);
+            break;
+        }
+        case 6 /* OverloadedFunction */: {
+            type.overloads.forEach((overload) => {
+                addDeclaringModuleNamesForType(overload, moduleList, recursionCount);
+            });
+            break;
+        }
+        case 9 /* Union */: {
+            doForEachSubtype(type, (subtype) => {
+                addDeclaringModuleNamesForType(subtype, moduleList, recursionCount);
+            });
+            break;
+        }
+        case 8 /* Module */: {
+            addIfUnique(type.moduleName);
+            break;
+        }
+    }
+}
+function convertParamSpecValueToType(paramSpecEntry, omitParamSpec = false) {
+    let hasParameters = paramSpecEntry.parameters.length > 0;
+    if (paramSpecEntry.parameters.length === 1) {
+        // If the ParamSpec has a position-only separator as its only parameter,
+        // treat it as though there are no parameters.
+        const onlyParam = paramSpecEntry.parameters[0];
+        if (onlyParam.category === 0 /* Simple */ && !onlyParam.name) {
+            hasParameters = false;
+        }
+    }
+    if (hasParameters || !paramSpecEntry.paramSpec || omitParamSpec) {
+        // Create a function type from the param spec entries.
+        const functionType = types_1.FunctionType.createInstance('', '', '', 65536 /* ParamSpecValue */ | paramSpecEntry.flags);
+        paramSpecEntry.parameters.forEach((entry) => {
+            types_1.FunctionType.addParameter(functionType, {
+                category: entry.category,
+                name: entry.name,
+                hasDefault: entry.hasDefault,
+                isNameSynthesized: entry.isNameSynthesized,
+                hasDeclaredType: true,
+                type: entry.type,
+            });
+        });
+        if (!omitParamSpec) {
+            functionType.details.paramSpec = paramSpecEntry.paramSpec;
+        }
+        functionType.details.docString = paramSpecEntry.docString;
+        return functionType;
+    }
+    return paramSpecEntry.paramSpec;
+}
+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();
+    }
+    apply(type, recursionCount = 0) {
+        var _a;
+        if (recursionCount > types_1.maxTypeRecursionCount) {
+            return type;
+        }
+        recursionCount++;
+        type = this._transformGenericTypeAlias(type, recursionCount);
+        // Shortcut the operation if possible.
+        if (!requiresSpecialization(type)) {
+            return type;
+        }
+        if ((0, types_1.isAnyOrUnknown)(type)) {
+            return type;
+        }
+        if ((0, types_1.isNoneInstance)(type)) {
+            return type;
+        }
+        if ((0, types_1.isTypeVar)(type)) {
+            // Handle recursive type aliases specially. In particular,
+            // we need to specialize type arguments for generic recursive
+            // type aliases.
+            if (type.details.recursiveTypeAliasName) {
+                if (!((_a = type.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.typeArguments)) {
+                    return type;
+                }
+                let requiresUpdate = false;
+                const typeArgs = type.typeAliasInfo.typeArguments.map((typeArg) => {
+                    const replacementType = this.apply(typeArg, recursionCount);
+                    if (replacementType !== typeArg) {
+                        requiresUpdate = true;
+                    }
+                    return replacementType;
+                });
+                if (requiresUpdate) {
+                    return types_1.TypeBase.cloneForTypeAlias(type, type.typeAliasInfo.name, type.typeAliasInfo.fullName, type.typeAliasInfo.typeVarScopeId, type.typeAliasInfo.typeParameters, typeArgs);
+                }
+                return type;
+            }
+            let replacementType = type;
+            // Recursively transform the results, but ensure that we don't replace the
+            // same type variable recursively by setting it in the
+            // _pendingTypeVarTransformations set.
+            const typeVarName = types_1.TypeVarType.getNameWithScope(type);
+            if (!this._pendingTypeVarTransformations.has(typeVarName)) {
+                replacementType = this.transformTypeVar(type);
+                if (!this._isTransformingTypeArg) {
+                    this._pendingTypeVarTransformations.add(typeVarName);
+                    replacementType = this.apply(replacementType, recursionCount);
+                    this._pendingTypeVarTransformations.delete(typeVarName);
+                }
+                // If we're transforming a variadic type variable that was in a union,
+                // expand the union types.
+                if ((0, types_1.isVariadicTypeVar)(type) && type.isVariadicInUnion) {
+                    replacementType = _expandVariadicUnpackedUnion(replacementType);
+                }
+            }
+            return replacementType;
+        }
+        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 ((0, types_1.isVariadicTypeVar)(subtype) && !(0, types_1.isVariadicTypeVar)(transformedType)) {
+                    const subtypesToCombine = [];
+                    doForEachSubtype(transformedType, (transformedSubtype) => {
+                        subtypesToCombine.push(_expandVariadicUnpackedUnion(transformedSubtype));
+                    });
+                    transformedType = (0, types_1.combineTypes)(subtypesToCombine);
+                }
+                if (this.transformUnionSubtype) {
+                    return this.transformUnionSubtype(subtype, transformedType);
+                }
+                return transformedType;
+            });
+            return !(0, types_1.isNever)(newUnionType) ? newUnionType : types_1.UnknownType.create();
+        }
+        if ((0, types_1.isClass)(type)) {
+            return this._transformTypeVarsInClassType(type, recursionCount);
+        }
+        if ((0, types_1.isFunction)(type)) {
+            return this._transformTypeVarsInFunctionType(type, recursionCount);
+        }
+        if ((0, types_1.isOverloadedFunction)(type)) {
+            let requiresUpdate = false;
+            // Specialize each of the functions in the overload.
+            const newOverloads = [];
+            type.overloads.forEach((entry) => {
+                const replacementType = this._transformTypeVarsInFunctionType(entry, recursionCount);
+                newOverloads.push(replacementType);
+                if (replacementType !== entry) {
+                    requiresUpdate = true;
+                }
+            });
+            // Construct a new overload with the specialized function types.
+            return requiresUpdate ? types_1.OverloadedFunctionType.create(newOverloads) : type;
+        }
+        return type;
+    }
+    transformTypeVar(typeVar) {
+        return typeVar;
+    }
+    transformVariadicTypeVar(paramSpec) {
+        return undefined;
+    }
+    transformParamSpec(paramSpec) {
+        return undefined;
+    }
+    transformUnionSubtype(preTransform, postTransform) {
+        return postTransform;
+    }
+    _transformGenericTypeAlias(type, recursionCount) {
+        if (!type.typeAliasInfo || !type.typeAliasInfo.typeParameters || !type.typeAliasInfo.typeArguments) {
+            return type;
+        }
+        let requiresUpdate = false;
+        const newTypeArgs = type.typeAliasInfo.typeArguments.map((typeArg) => {
+            const updatedType = this.apply(typeArg, recursionCount);
+            if (type !== updatedType) {
+                requiresUpdate = true;
+            }
+            return updatedType;
+        });
+        return requiresUpdate
+            ? types_1.TypeBase.cloneForTypeAlias(type, type.typeAliasInfo.name, type.typeAliasInfo.fullName, type.typeAliasInfo.typeVarScopeId, type.typeAliasInfo.typeParameters, newTypeArgs)
+            : type;
+    }
+    _transformTypeVarsInClassType(classType, recursionCount) {
+        // Handle the common case where the class has no type parameters.
+        if (types_1.ClassType.getTypeParameters(classType).length === 0 && !types_1.ClassType.isSpecialBuiltIn(classType)) {
+            return classType;
+        }
+        let newTypeArgs = [];
+        let newVariadicTypeArgs;
+        let specializationNeeded = false;
+        const typeParams = types_1.ClassType.getTypeParameters(classType);
+        const transformParamSpec = (paramSpec) => {
+            const paramSpecValue = this.transformParamSpec(paramSpec);
+            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.
+        if (classType.typeArguments) {
+            newTypeArgs = classType.typeArguments.map((oldTypeArgType) => {
+                if ((0, types_1.isTypeVar)(oldTypeArgType) && oldTypeArgType.details.isParamSpec) {
+                    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.isVariadicTypeVar)(oldTypeArgType) &&
+                        oldTypeArgType.isVariadicInUnion) {
+                        newTypeArgType = _expandVariadicUnpackedUnion(newTypeArgType);
+                    }
+                }
+                return newTypeArgType;
+            });
+        }
+        else {
+            typeParams.forEach((typeParam) => {
+                let replacementType = typeParam;
+                if (typeParam.details.isParamSpec) {
+                    replacementType = transformParamSpec(typeParam);
+                    if (replacementType !== typeParam) {
+                        specializationNeeded = true;
+                    }
+                }
+                else {
+                    const typeParamName = types_1.TypeVarType.getNameWithScope(typeParam);
+                    if (!this._pendingTypeVarTransformations.has(typeParamName)) {
+                        replacementType = this.transformTypeVar(typeParam);
+                        if (replacementType !== typeParam) {
+                            if (!this._isTransformingTypeArg) {
+                                this._pendingTypeVarTransformations.add(typeParamName);
+                                replacementType = this.apply(replacementType, recursionCount);
+                                this._pendingTypeVarTransformations.delete(typeParamName);
+                            }
+                            specializationNeeded = true;
+                        }
+                    }
+                }
+                newTypeArgs.push(replacementType);
+            });
+        }
+        if (types_1.ClassType.isTupleClass(classType)) {
+            if (classType.tupleTypeArguments) {
+                newVariadicTypeArgs = [];
+                classType.tupleTypeArguments.forEach((oldTypeArgType) => {
+                    const newTypeArgType = this.apply(oldTypeArgType.type, recursionCount);
+                    if (newTypeArgType !== oldTypeArgType.type) {
+                        specializationNeeded = true;
+                    }
+                    if ((0, types_1.isVariadicTypeVar)(oldTypeArgType.type) &&
+                        (0, types_1.isClassInstance)(newTypeArgType) &&
+                        isTupleClass(newTypeArgType) &&
+                        newTypeArgType.tupleTypeArguments) {
+                        (0, collectionUtils_1.appendArray)(newVariadicTypeArgs, newTypeArgType.tupleTypeArguments);
+                    }
+                    else {
+                        newVariadicTypeArgs.push({ type: newTypeArgType, isUnbounded: oldTypeArgType.isUnbounded });
+                    }
+                });
+            }
+            else if (typeParams.length > 0) {
+                newVariadicTypeArgs = this.transformVariadicTypeVar(typeParams[0]);
+                if (newVariadicTypeArgs) {
+                    specializationNeeded = true;
+                }
+            }
+        }
+        this._isTransformingTypeArg = wasTransformingTypeArg;
+        // If specialization wasn't needed, don't allocate a new class.
+        if (!specializationNeeded) {
+            return classType;
+        }
+        return types_1.ClassType.cloneForSpecialization(classType, newTypeArgs, 
+        /* isTypeArgumentExplicit */ true, 
+        /* includeSubclasses */ undefined, newVariadicTypeArgs);
+    }
+    _transformTypeVarsInFunctionType(sourceType, recursionCount) {
+        let functionType = sourceType;
+        // Handle functions with a parameter specification in a special manner.
+        if (functionType.details.paramSpec) {
+            const paramSpec = this.transformParamSpec(functionType.details.paramSpec);
+            if (paramSpec) {
+                functionType = types_1.FunctionType.cloneForParamSpec(functionType, paramSpec);
+            }
+        }
+        const declaredReturnType = types_1.FunctionType.getSpecializedReturnType(functionType);
+        const specializedReturnType = declaredReturnType ? this.apply(declaredReturnType, recursionCount) : undefined;
+        let typesRequiredSpecialization = declaredReturnType !== specializedReturnType;
+        const specializedParameters = {
+            parameterTypes: [],
+            returnType: specializedReturnType,
+        };
+        // Does this function end with *args: P.args, **args: P.kwargs? If so, we'll
+        // modify the function and replace these parameters with the signature captured
+        // by the ParamSpec.
+        if (functionType.details.parameters.length >= 2) {
+            const argsParam = functionType.details.parameters[functionType.details.parameters.length - 2];
+            const kwargsParam = functionType.details.parameters[functionType.details.parameters.length - 1];
+            const argsParamType = types_1.FunctionType.getEffectiveParameterType(functionType, functionType.details.parameters.length - 2);
+            const kwargsParamType = types_1.FunctionType.getEffectiveParameterType(functionType, functionType.details.parameters.length - 1);
+            if (argsParam.category === 1 /* VarArgList */ &&
+                kwargsParam.category === 2 /* VarArgDictionary */ &&
+                (0, types_1.isParamSpec)(argsParamType) &&
+                (0, types_1.isParamSpec)(kwargsParamType) &&
+                (0, types_1.isTypeSame)(argsParamType, kwargsParamType)) {
+                const paramSpecType = this.transformParamSpec(argsParamType);
+                if (paramSpecType) {
+                    if (paramSpecType.parameters.length > 0 ||
+                        paramSpecType.paramSpec === undefined ||
+                        !(0, types_1.isTypeSame)(argsParamType, paramSpecType.paramSpec)) {
+                        functionType = types_1.FunctionType.cloneForParamSpecApplication(functionType, paramSpecType);
+                    }
+                }
+            }
+        }
+        let variadicParamIndex;
+        let variadicTypesToUnpack;
+        const specializedDefaultArgs = [];
+        for (let i = 0; i < functionType.details.parameters.length; i++) {
+            const paramType = types_1.FunctionType.getEffectiveParameterType(functionType, i);
+            const specializedType = this.apply(paramType, recursionCount);
+            specializedParameters.parameterTypes.push(specializedType);
+            // Do we need to specialize the default argument type for this parameter?
+            let defaultArgType = types_1.FunctionType.getEffectiveParameterDefaultArgType(functionType, i);
+            if (defaultArgType) {
+                const specializedArgType = this.apply(defaultArgType, recursionCount);
+                if (specializedArgType !== defaultArgType) {
+                    defaultArgType = specializedArgType;
+                    typesRequiredSpecialization = true;
+                }
+            }
+            specializedDefaultArgs.push(defaultArgType);
+            if (variadicParamIndex === undefined &&
+                (0, types_1.isVariadicTypeVar)(paramType) &&
+                functionType.details.parameters[i].category === 1 /* VarArgList */) {
+                variadicParamIndex = i;
+                if ((0, types_1.isClassInstance)(specializedType) && isTupleClass(specializedType) && specializedType.isUnpacked) {
+                    variadicTypesToUnpack = specializedType.tupleTypeArguments;
+                }
+            }
+            if (paramType !== specializedType) {
+                typesRequiredSpecialization = true;
+            }
+        }
+        if (!typesRequiredSpecialization) {
+            return functionType;
+        }
+        let specializedInferredReturnType;
+        if (functionType.inferredReturnType) {
+            specializedInferredReturnType = this.apply(functionType.inferredReturnType, recursionCount);
+        }
+        if (specializedDefaultArgs.some((t) => t !== undefined)) {
+            specializedParameters.parameterDefaultArgs = specializedDefaultArgs;
+        }
+        // If there was no unpacked variadic type variable, we're done.
+        if (!variadicTypesToUnpack) {
+            return types_1.FunctionType.cloneForSpecialization(functionType, specializedParameters, specializedInferredReturnType);
+        }
+        // Unpack the tuple and synthesize a new function in the process.
+        const newFunctionType = types_1.FunctionType.createSynthesizedInstance('');
+        let insertKeywordOnlySeparator = false;
+        let swallowPositionOnlySeparator = false;
+        specializedParameters.parameterTypes.forEach((paramType, index) => {
+            if (index === variadicParamIndex) {
+                let sawUnboundedEntry = false;
+                // Unpack the tuple into individual parameters.
+                variadicTypesToUnpack.forEach((unpackedType) => {
+                    types_1.FunctionType.addParameter(newFunctionType, {
+                        category: unpackedType.isUnbounded ? 1 /* VarArgList */ : 0 /* Simple */,
+                        name: `__p${newFunctionType.details.parameters.length}`,
+                        isNameSynthesized: true,
+                        type: unpackedType.type,
+                        hasDeclaredType: true,
+                    });
+                    if (unpackedType.isUnbounded) {
+                        sawUnboundedEntry = true;
+                    }
+                });
+                if (sawUnboundedEntry) {
+                    swallowPositionOnlySeparator = true;
+                }
+                else {
+                    insertKeywordOnlySeparator = true;
+                }
+            }
+            else {
+                const param = { ...functionType.details.parameters[index] };
+                if (param.category === 1 /* VarArgList */ && !param.name) {
+                    insertKeywordOnlySeparator = false;
+                }
+                else if (param.category === 2 /* VarArgDictionary */) {
+                    insertKeywordOnlySeparator = false;
+                }
+                // Insert a keyword-only separator parameter if we previously
+                // unpacked a variadic TypeVar.
+                if (param.category === 0 /* Simple */ && param.name && insertKeywordOnlySeparator) {
+                    types_1.FunctionType.addParameter(newFunctionType, {
+                        category: 1 /* VarArgList */,
+                        type: types_1.UnknownType.create(),
+                    });
+                    insertKeywordOnlySeparator = false;
+                }
+                param.type = paramType;
+                if (param.name && param.isNameSynthesized) {
+                    param.name = `__p${newFunctionType.details.parameters.length}`;
+                }
+                if (param.category !== 0 /* Simple */ || param.name || !swallowPositionOnlySeparator) {
+                    types_1.FunctionType.addParameter(newFunctionType, param);
+                }
+            }
+        });
+        newFunctionType.details.declaredReturnType = specializedParameters.returnType;
+        return newFunctionType;
+    }
+}
+// Specializes a (potentially generic) type by substituting
+// type variables from a type var map.
+class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
+    constructor(_typeVarContext, _unknownIfNotFound = false, _useNarrowBoundOnly = false, _eliminateUnsolvedInUnions = false, _typeClassType) {
+        super();
+        this._typeVarContext = _typeVarContext;
+        this._unknownIfNotFound = _unknownIfNotFound;
+        this._useNarrowBoundOnly = _useNarrowBoundOnly;
+        this._eliminateUnsolvedInUnions = _eliminateUnsolvedInUnions;
+        this._typeClassType = _typeClassType;
+    }
+    transformTypeVar(typeVar) {
+        // If the type variable is unrelated to the scopes we're solving,
+        // don't transform that type variable.
+        if (typeVar.scopeId && this._typeVarContext.hasSolveForScope(typeVar.scopeId)) {
+            let replacement = this._typeVarContext.getTypeVarType(typeVar, this._useNarrowBoundOnly);
+            // If there was no narrow bound but there is a wide bound that
+            // contains literals, we'll use the wide bound even if "useNarrowBoundOnly"
+            // is specified.
+            if (!replacement && this._useNarrowBoundOnly) {
+                const wideType = this._typeVarContext.getTypeVarType(typeVar);
+                if (wideType) {
+                    if (containsLiteralType(wideType, /* includeTypeArgs */ true)) {
+                        replacement = wideType;
+                    }
+                }
+            }
+            if (replacement) {
+                if (types_1.TypeBase.isInstantiable(typeVar)) {
+                    if ((0, types_1.isAnyOrUnknown)(replacement) &&
+                        this._typeClassType &&
+                        (0, types_1.isInstantiableClass)(this._typeClassType)) {
+                        replacement = types_1.ClassType.cloneForSpecialization(types_1.ClassType.cloneAsInstance(this._typeClassType), [replacement], 
+                        /* isTypeArgumentExplicit */ true);
+                    }
+                    else {
+                        replacement = convertToInstantiable(replacement);
+                    }
+                }
+                return replacement;
+            }
+            // 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 Unknown.
+            if (this._unknownIfNotFound && !this._typeVarContext.hasSolveForScope(types_1.WildcardTypeVarScopeId)) {
+                return types_1.UnknownType.create();
+            }
+        }
+        return typeVar;
+    }
+    transformUnionSubtype(preTransform, postTransform) {
+        // 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._eliminateUnsolvedInUnions) {
+            if ((0, types_1.isTypeVar)(preTransform) &&
+                preTransform.scopeId !== undefined &&
+                this._typeVarContext.hasSolveForScope(preTransform.scopeId)) {
+                // 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
+                // be Unknown, which we want to eliminate.
+                if ((0, types_1.isUnknown)(postTransform) && this._unknownIfNotFound) {
+                    return undefined;
+                }
+            }
+        }
+        return postTransform;
+    }
+    transformVariadicTypeVar(typeVar) {
+        if (!typeVar.scopeId || !this._typeVarContext.hasSolveForScope(typeVar.scopeId)) {
+            return undefined;
+        }
+        return this._typeVarContext.getVariadicTypeVar(typeVar);
+    }
+    transformParamSpec(paramSpec) {
+        if (!paramSpec.scopeId || !this._typeVarContext.hasSolveForScope(paramSpec.scopeId)) {
+            return undefined;
+        }
+        const transformedParamSpec = this._typeVarContext.getParamSpec(paramSpec);
+        if (transformedParamSpec) {
+            return transformedParamSpec;
+        }
+        if (this._unknownIfNotFound && !this._typeVarContext.hasSolveForScope(types_1.WildcardTypeVarScopeId)) {
+            // Convert to the ParamSpec equivalent of "Unknown".
+            const paramSpecValue = {
+                flags: 0 /* None */,
+                parameters: types_1.FunctionType.getDefaultParameters(/* useUnknown */ true),
+                typeVarScopeId: undefined,
+                docString: undefined,
+                paramSpec: undefined,
+            };
+            return paramSpecValue;
+        }
+        return undefined;
+    }
+}
+class ExpectedConstructorTypeTransformer extends TypeVarTransformer {
+    constructor(_typeVarContext, _liveTypeVarScopes) {
+        super();
+        this._typeVarContext = _typeVarContext;
+        this._liveTypeVarScopes = _liveTypeVarScopes;
+        this.dummyScopeId = '__expected_type_scope_id';
+        this.dummyTypeVarPrefix = '__expected_type_';
+        this._typeVarContext.addSolveForScope(this.dummyScopeId);
+    }
+    _isTypeVarLive(typeVar) {
+        return this._liveTypeVarScopes.some((scopeId) => typeVar.scopeId === scopeId);
+    }
+    _createDummyTypeVar(prevTypeVar) {
+        // If we previously synthesized this dummy type var, just return it.
+        if (prevTypeVar.details.isSynthesized && prevTypeVar.details.name.startsWith(this.dummyTypeVarPrefix)) {
+            return prevTypeVar;
+        }
+        const isInstance = types_1.TypeBase.isInstance(prevTypeVar);
+        let newTypeVar = types_1.TypeVarType.createInstance(`__expected_type_${ExpectedConstructorTypeTransformer.synthesizedTypeVarIndexForExpectedType}`);
+        newTypeVar.details.isSynthesized = true;
+        newTypeVar.scopeId = this.dummyScopeId;
+        newTypeVar.nameWithScope = types_1.TypeVarType.makeNameWithScope(newTypeVar.details.name, this.dummyScopeId);
+        if (!isInstance) {
+            newTypeVar = convertToInstantiable(newTypeVar);
+        }
+        // If the original TypeVar was bound or constrained, make the replacement as well.
+        newTypeVar.details.boundType = prevTypeVar.details.boundType;
+        newTypeVar.details.constraints = prevTypeVar.details.constraints;
+        // Also copy the variance.
+        newTypeVar.details.variance = prevTypeVar.details.variance;
+        ExpectedConstructorTypeTransformer.synthesizedTypeVarIndexForExpectedType++;
+        return newTypeVar;
+    }
+    transformTypeVar(typeVar) {
+        // If the type variable is unrelated to the scopes we're solving,
+        // don't transform that type variable.
+        if (this._isTypeVarLive(typeVar)) {
+            return typeVar;
+        }
+        return this._createDummyTypeVar(typeVar);
+    }
+}
+ExpectedConstructorTypeTransformer.synthesizedTypeVarIndexForExpectedType = 1;
+//# sourceMappingURL=typeUtils.js.map