@zzzen/pyright-internal 1.2.0-dev.20221218 → 1.2.0-dev.20230101

package/dist/analyzer/typeUtils.js

@@ -8,8 +8,8 @@
  * Collection of functions that operate on Type objects.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-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.containsType = exports.isLiteralTypeOrUnion = exports.isLiteralType = exports.getSpecializedTupleType = exports.getTypeVarScopeId = exports.transformPossibleRecursiveTypeAlias = exports.isTypeAliasRecursive = exports.isTypeAliasPlaceholder = exports.getTypeCondition = exports.addConditionToType = exports.getFullNameOfType = exports.derivesFromAnyOrUnknown = exports.isUnionableType = exports.preserveUnknown = exports.areTypesSame = exports.doForEachSubtype = exports.sortTypes = exports.mapSubtypes = exports.isIncompleteUnknown = exports.isOptionalType = exports.getParameterListDetails = exports.ParameterSource = exports.AssignTypeFlags = exports.ClassIteratorFlags = exports.ClassMemberLookupFlags = void 0;
-exports.convertParamSpecValueToType = exports.getDeclaringModulesForType = exports.computeMroLinearization = exports.isVarianceOfTypeArgumentCompatible = 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 = exports.getGeneratorYieldType = exports.getDeclaredGeneratorReturnType = exports.synthesizeTypeVarForSelfCls = exports.derivesFromClassRecursive = exports.specializeForBaseClass = void 0;
+exports.setTypeArgumentsRecursive = exports.specializeClassType = exports.isTypeVarLimitedToCallable = exports.getTypeVarArgumentsRecursive = exports.addTypeVarsToListIfUnique = exports.getClassFieldsRecursive = exports.getClassIterator = exports.getClassMemberIterator = exports.lookUpClassMember = exports.lookUpObjectMember = exports.getProtocolSymbols = exports.transformExpectedTypeForConstructor = exports.validateTypeVarDefault = 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.containsType = exports.isLiteralTypeOrUnion = exports.isLiteralType = exports.getSpecializedTupleType = exports.getTypeVarScopeId = exports.transformPossibleRecursiveTypeAlias = exports.isTypeAliasRecursive = exports.isTypeAliasPlaceholder = exports.getTypeCondition = exports.addConditionToType = exports.getFullNameOfType = exports.derivesFromAnyOrUnknown = exports.isUnionableType = exports.preserveUnknown = exports.areTypesSame = exports.doForEachSubtype = exports.sortTypes = exports.mapSubtypes = exports.isIncompleteUnknown = exports.isOptionalType = exports.getParameterListDetails = exports.ParameterSource = exports.AssignTypeFlags = exports.ClassIteratorFlags = exports.ClassMemberLookupFlags = void 0;
+exports.convertParamSpecValueToType = exports.convertTypeToParamSpecValue = exports.getDeclaringModulesForType = exports.computeMroLinearization = exports.isVarianceOfTypeArgumentCompatible = 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 = exports.getGeneratorYieldType = exports.getDeclaredGeneratorReturnType = exports.synthesizeTypeVarForSelfCls = exports.derivesFromClassRecursive = exports.specializeForBaseClass = exports.buildTypeVarContext = exports.buildTypeVarContextFromSpecializedClass = void 0;
 const collectionUtils_1 = require("../common/collectionUtils");
 const debug_1 = require("../common/debug");
 const symbol_1 = require("./symbol");
@@ -66,9 +66,10 @@ var AssignTypeFlags;
     // the types are contravariant. Perform type var matching
     // on dest type vars rather than source type var.
     AssignTypeFlags[AssignTypeFlags["ReverseTypeVarMatching"] = 2] = "ReverseTypeVarMatching";
-    // Normally invariant and contravariant TypeVars cannot be
-    // narrowed. This overrides the standard behavior.
-    AssignTypeFlags[AssignTypeFlags["AllowTypeVarNarrowing"] = 4] = "AllowTypeVarNarrowing";
+    // We're comparing type compatibility of two distinct recursive types.
+    // This has the potential of recursing infinitely. This flag allows us
+    // to detect the recursion after the first level of checking.
+    AssignTypeFlags[AssignTypeFlags["SkipRecursiveTypeCheck"] = 4] = "SkipRecursiveTypeCheck";
     // Normally type vars are treated as variables that need to
     // be "solved". If this flag is set, they are treated as types
     // that must match. It is used for overload consistency checking.
@@ -98,10 +99,6 @@ var AssignTypeFlags;
     // so TypeVars should match the specified type exactly rather than
     // employing narrowing or widening, and don't strip literals.
     AssignTypeFlags[AssignTypeFlags["PopulatingExpectedType"] = 1024] = "PopulatingExpectedType";
-    // We're comparing type compatibility of two distinct recursive types.
-    // This has the potential of recursing infinitely. This flag allows us
-    // to detect the recursion after the first level of checking.
-    AssignTypeFlags[AssignTypeFlags["SkipRecursiveTypeCheck"] = 2048] = "SkipRecursiveTypeCheck";
 })(AssignTypeFlags = exports.AssignTypeFlags || (exports.AssignTypeFlags = {}));
 var ParameterSource;
 (function (ParameterSource) {
@@ -825,10 +822,7 @@ function partiallySpecializeType(type, contextClassType, selfClass, typeClassTyp
     if (selfClass) {
         populateTypeVarContextForSelfType(typeVarContext, contextClassType, selfClass);
     }
-    return applySolvedTypeVars(type, typeVarContext, 
-    /* unknownIfNotFound */ undefined, 
-    /* useNarrowBoundOnly */ undefined, 
-    /* eliminateUnsolvedInUnions */ undefined, typeClassType);
+    return applySolvedTypeVars(type, typeVarContext, { typeClassType });
 }
 exports.partiallySpecializeType = partiallySpecializeType;
 function populateTypeVarContextForSelfType(typeVarContext, contextClassType, selfClass) {
@@ -838,15 +832,26 @@ function populateTypeVarContextForSelfType(typeVarContext, contextClassType, sel
 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) {
+function applySolvedTypeVars(type, typeVarContext, options = {}) {
     // Use a shortcut if the typeVarContext is empty and no transform is necessary.
-    if (typeVarContext.isEmpty() && !unknownIfNotFound && !eliminateUnsolvedInUnions) {
+    if (typeVarContext.isEmpty() && !options.unknownIfNotFound && !options.eliminateUnsolvedInUnions) {
         return type;
     }
-    const transformer = new ApplySolvedTypeVarsTransformer(typeVarContext, unknownIfNotFound, useNarrowBoundOnly, eliminateUnsolvedInUnions, typeClassType);
-    return transformer.apply(type);
+    const transformer = new ApplySolvedTypeVarsTransformer(typeVarContext, options);
+    return transformer.apply(type, 0);
 }
 exports.applySolvedTypeVars = applySolvedTypeVars;
+// Validates that a default type associated with a TypeVar does not refer to
+// other TypeVars or ParamSpecs that are out of scope.
+function validateTypeVarDefault(typeVar, liveTypeParams, invalidTypeVars) {
+    // If there is no default type or the default type is concrete, there's
+    // no need to do any more work here.
+    if (typeVar.details.defaultType && requiresSpecialization(typeVar.details.defaultType)) {
+        const validator = new TypeVarDefaultValidator(liveTypeParams, invalidTypeVars);
+        validator.apply(typeVar.details.defaultType, 0);
+    }
+}
+exports.validateTypeVarDefault = validateTypeVarDefault;
 // 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
@@ -864,7 +869,7 @@ function transformExpectedTypeForConstructor(expectedType, liveTypeVarScopes) {
         return undefined;
     }
     const transformer = new ExpectedConstructorTypeTransformer(liveTypeVarScopes);
-    return transformer.apply(expectedType);
+    return transformer.apply(expectedType, 0);
 }
 exports.transformExpectedTypeForConstructor = transformExpectedTypeForConstructor;
 // Given a protocol class, this function returns a set of all the
@@ -1128,15 +1133,6 @@ function getTypeVarArgumentsRecursive(type, recursionCount = 0) {
         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) => {
@@ -1156,7 +1152,14 @@ function getTypeVarArgumentsRecursive(type, recursionCount = 0) {
         return [types_1.TypeBase.isInstantiable(type) ? types_1.TypeVarType.cloneAsInstance(type) : type];
     }
     if ((0, types_1.isClass)(type)) {
-        return getTypeVarsFromClass(type);
+        const combinedList = [];
+        const typeArgs = type.tupleTypeArguments ? type.tupleTypeArguments.map((e) => e.type) : type.typeArguments;
+        if (typeArgs) {
+            typeArgs.forEach((typeArg) => {
+                addTypeVarsToListIfUnique(combinedList, getTypeVarArgumentsRecursive(typeArg, recursionCount));
+            });
+        }
+        return combinedList;
     }
     if ((0, types_1.isUnion)(type)) {
         const combinedList = [];
@@ -1182,6 +1185,79 @@ function getTypeVarArgumentsRecursive(type, recursionCount = 0) {
     return [];
 }
 exports.getTypeVarArgumentsRecursive = getTypeVarArgumentsRecursive;
+// Determines if the type variable appears within the type and only within
+// a particular Callable within that type.
+function isTypeVarLimitedToCallable(type, typeVar) {
+    const info = getTypeVarWithinTypeInfoRecursive(type, typeVar);
+    return info.isTypeVarUsed && info.isUsedInCallable;
+}
+exports.isTypeVarLimitedToCallable = isTypeVarLimitedToCallable;
+function getTypeVarWithinTypeInfoRecursive(type, typeVar, recursionCount = 0) {
+    if (recursionCount > types_1.maxTypeRecursionCount) {
+        return { isTypeVarUsed: false, isUsedInCallable: false };
+    }
+    recursionCount++;
+    let typeVarUsedCount = 0;
+    let usedInCallableCount = 0;
+    if ((0, types_1.isTypeVar)(type)) {
+        // Ignore P.args or P.kwargs types.
+        if (!(0, types_1.isParamSpec)(type) || !type.paramSpecAccess) {
+            if ((0, types_1.isTypeSame)(typeVar, convertToInstance(type))) {
+                typeVarUsedCount++;
+            }
+        }
+    }
+    else if ((0, types_1.isClass)(type)) {
+        if (type.typeArguments) {
+            type.typeArguments.forEach((typeArg) => {
+                const subResult = getTypeVarWithinTypeInfoRecursive(typeArg, typeVar, recursionCount);
+                if (subResult.isTypeVarUsed) {
+                    typeVarUsedCount++;
+                }
+                if (subResult.isUsedInCallable) {
+                    usedInCallableCount++;
+                }
+            });
+        }
+    }
+    else if ((0, types_1.isUnion)(type)) {
+        doForEachSubtype(type, (subtype) => {
+            const subResult = getTypeVarWithinTypeInfoRecursive(subtype, typeVar, recursionCount);
+            if (subResult.isTypeVarUsed) {
+                typeVarUsedCount++;
+            }
+            if (subResult.isUsedInCallable) {
+                usedInCallableCount++;
+            }
+        });
+    }
+    else if ((0, types_1.isFunction)(type)) {
+        for (let i = 0; i < type.details.parameters.length; i++) {
+            if (getTypeVarWithinTypeInfoRecursive(types_1.FunctionType.getEffectiveParameterType(type, i), typeVar, recursionCount).isTypeVarUsed) {
+                typeVarUsedCount++;
+            }
+        }
+        if (type.details.paramSpec) {
+            if ((0, types_1.isTypeSame)(typeVar, convertToInstance(type.details.paramSpec))) {
+                typeVarUsedCount++;
+            }
+        }
+        const returnType = types_1.FunctionType.getSpecializedReturnType(type);
+        if (returnType) {
+            if (getTypeVarWithinTypeInfoRecursive(returnType, typeVar, recursionCount).isTypeVarUsed) {
+                typeVarUsedCount++;
+            }
+        }
+        if (typeVarUsedCount > 0) {
+            typeVarUsedCount = 1;
+            usedInCallableCount = 1;
+        }
+    }
+    return {
+        isTypeVarUsed: typeVarUsedCount > 0,
+        isUsedInCallable: usedInCallableCount === 1 && typeVarUsedCount === 1,
+    };
+}
 // Creates a specialized version of the class, filling in any unspecified
 // type arguments with Unknown.
 function specializeClassType(type) {
@@ -1240,13 +1316,9 @@ function setTypeArgumentsRecursive(destType, srcType, typeVarContext, recursionC
                 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,
-                        });
+                        const newFunction = types_1.FunctionType.createInstance('', '', '', 32768 /* SkipArgsKwargsCompatibilityCheck */ | 65536 /* ParamSpecValue */);
+                        types_1.FunctionType.addDefaultParameters(newFunction);
+                        typeVarContext.setTypeVarType(destType.details.paramSpec, newFunction);
                     }
                 }
             }
@@ -1279,7 +1351,7 @@ function buildTypeVarContextFromSpecializedClass(classType, makeConcrete = true)
     }
     const typeVarContext = buildTypeVarContext(typeParameters, typeArguments, getTypeVarScopeId(classType));
     if (types_1.ClassType.isTupleClass(classType) && classType.tupleTypeArguments && typeParameters.length >= 1) {
-        typeVarContext.setVariadicTypeVar(typeParameters[0], classType.tupleTypeArguments);
+        typeVarContext.setTupleTypeVar(typeParameters[0], classType.tupleTypeArguments);
     }
     return typeVarContext;
 }
@@ -1293,10 +1365,10 @@ function buildTypeVarContext(typeParameters, typeArgs, typeVarScopeId) {
                 if (index < typeArgs.length) {
                     typeArgType = typeArgs[index];
                     if ((0, types_1.isFunction)(typeArgType) && types_1.FunctionType.isParamSpecValue(typeArgType)) {
-                        const paramSpecEntries = [];
+                        const parameters = [];
                         const typeArgFunctionType = typeArgType;
                         typeArgType.details.parameters.forEach((param, paramIndex) => {
-                            paramSpecEntries.push({
+                            parameters.push({
                                 category: param.category,
                                 name: param.name,
                                 hasDefault: !!param.hasDefault,
@@ -1305,32 +1377,10 @@ function buildTypeVarContext(typeParameters, typeArgs, typeVarScopeId) {
                                 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,
-                        });
+                        typeVarContext.setTypeVarType(typeParam, convertTypeToParamSpecValue(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: 32768 /* SkipArgsKwargsCompatibilityCheck */,
-                            parameters: types_1.FunctionType.getDefaultParameters(),
-                            typeVarScopeId: undefined,
-                            docString: undefined,
-                            paramSpec: undefined,
-                        });
+                    else if ((0, types_1.isParamSpec)(typeArgType) || (0, types_1.isAnyOrUnknown)(typeArgType)) {
+                        typeVarContext.setTypeVarType(typeParam, convertTypeToParamSpecValue(typeArgType));
                     }
                 }
             }
@@ -1341,7 +1391,8 @@ function buildTypeVarContext(typeParameters, typeArgs, typeVarScopeId) {
                 else {
                     typeArgType = typeArgs[index];
                 }
-                typeVarContext.setTypeVarType(typeParam, typeArgType, typeArgType, /* retainLiteral */ true);
+                typeVarContext.setTypeVarType(typeParam, typeArgType, 
+                /* narrowBoundNoLiterals */ undefined, typeArgType);
             }
         }
     });
@@ -2095,20 +2146,48 @@ function addDeclaringModuleNamesForType(type, moduleList, recursionCount = 0) {
         }
     }
 }
-function convertParamSpecValueToType(paramSpecEntry, omitParamSpec = false) {
-    let hasParameters = paramSpecEntry.parameters.length > 0;
-    if (paramSpecEntry.parameters.length === 1) {
+function convertTypeToParamSpecValue(type) {
+    if ((0, types_1.isParamSpec)(type)) {
+        const newFunction = types_1.FunctionType.createInstance('', '', '', 65536 /* ParamSpecValue */);
+        newFunction.details.paramSpec = type;
+        newFunction.details.typeVarScopeId = getTypeVarScopeId(type);
+        return newFunction;
+    }
+    if ((0, types_1.isFunction)(type)) {
+        const newFunction = types_1.FunctionType.createInstance('', '', '', type.details.flags | 65536 /* ParamSpecValue */, type.details.docString);
+        type.details.parameters.forEach((param, index) => {
+            types_1.FunctionType.addParameter(newFunction, {
+                category: param.category,
+                name: param.name,
+                hasDefault: param.hasDefault,
+                defaultValueExpression: param.defaultValueExpression,
+                isNameSynthesized: param.isNameSynthesized,
+                type: types_1.FunctionType.getEffectiveParameterType(type, index),
+            });
+        });
+        newFunction.details.typeVarScopeId = getTypeVarScopeId(type);
+        newFunction.details.paramSpec = type.details.paramSpec;
+        return newFunction;
+    }
+    const newFunction = types_1.FunctionType.createInstance('', '', '', 65536 /* ParamSpecValue */ | 32768 /* SkipArgsKwargsCompatibilityCheck */);
+    types_1.FunctionType.addDefaultParameters(newFunction);
+    return newFunction;
+}
+exports.convertTypeToParamSpecValue = convertTypeToParamSpecValue;
+function convertParamSpecValueToType(paramSpecValue, omitParamSpec = false) {
+    let hasParameters = paramSpecValue.details.parameters.length > 0;
+    if (paramSpecValue.details.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];
+        const onlyParam = paramSpecValue.details.parameters[0];
         if (onlyParam.category === 0 /* Simple */ && !onlyParam.name) {
             hasParameters = false;
         }
     }
-    if (hasParameters || !paramSpecEntry.paramSpec || omitParamSpec) {
+    if (hasParameters || !paramSpecValue.details.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) => {
+        const functionType = types_1.FunctionType.createInstance('', '', '', 65536 /* ParamSpecValue */ | paramSpecValue.details.flags);
+        paramSpecValue.details.parameters.forEach((entry) => {
             types_1.FunctionType.addParameter(functionType, {
                 category: entry.category,
                 name: entry.name,
@@ -2120,12 +2199,12 @@ function convertParamSpecValueToType(paramSpecEntry, omitParamSpec = false) {
             });
         });
         if (!omitParamSpec) {
-            functionType.details.paramSpec = paramSpecEntry.paramSpec;
+            functionType.details.paramSpec = paramSpecValue.details.paramSpec;
         }
-        functionType.details.docString = paramSpecEntry.docString;
+        functionType.details.docString = paramSpecValue.details.docString;
         return functionType;
     }
-    return paramSpecEntry.paramSpec;
+    return paramSpecValue.details.paramSpec;
 }
 exports.convertParamSpecValueToType = convertParamSpecValueToType;
 // Recursively walks a type and calls a callback for each TypeVar, allowing
@@ -2135,7 +2214,7 @@ class TypeVarTransformer {
         this._isTransformingTypeArg = false;
         this._pendingTypeVarTransformations = new Set();
     }
-    apply(type, recursionCount = 0) {
+    apply(type, recursionCount) {
         var _a, _b;
         if (recursionCount > types_1.maxTypeRecursionCount) {
             return type;
@@ -2179,16 +2258,26 @@ class TypeVarTransformer {
             // _pendingTypeVarTransformations set.
             const typeVarName = types_1.TypeVarType.getNameWithScope(type);
             if (!this._pendingTypeVarTransformations.has(typeVarName)) {
-                replacementType = (_b = this.transformTypeVar(type)) !== null && _b !== void 0 ? _b : type;
-                if (!this._isTransformingTypeArg) {
-                    this._pendingTypeVarTransformations.add(typeVarName);
-                    replacementType = this.apply(replacementType, recursionCount);
-                    this._pendingTypeVarTransformations.delete(typeVarName);
+                if (type.details.isParamSpec) {
+                    if (!type.paramSpecAccess) {
+                        const paramSpecValue = this.transformParamSpec(type, recursionCount);
+                        if (paramSpecValue) {
+                            replacementType = convertParamSpecValueToType(paramSpecValue);
+                        }
+                    }
                 }
-                // 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);
+                else {
+                    replacementType = (_b = this.transformTypeVar(type, recursionCount)) !== null && _b !== void 0 ? _b : 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;
@@ -2206,7 +2295,7 @@ class TypeVarTransformer {
                     transformedType = (0, types_1.combineTypes)(subtypesToCombine);
                 }
                 if (this.transformUnionSubtype) {
-                    return this.transformUnionSubtype(subtype, transformedType);
+                    return this.transformUnionSubtype(subtype, transformedType, recursionCount);
                 }
                 return transformedType;
             });
@@ -2234,16 +2323,16 @@ class TypeVarTransformer {
         }
         return type;
     }
-    transformTypeVar(typeVar) {
+    transformTypeVar(typeVar, recursionCount) {
         return typeVar;
     }
-    transformVariadicTypeVar(paramSpec) {
+    transformTupleTypeVar(paramSpec, recursionCount) {
         return undefined;
     }
-    transformParamSpec(paramSpec) {
+    transformParamSpec(paramSpec, recursionCount) {
         return undefined;
     }
-    transformUnionSubtype(preTransform, postTransform) {
+    transformUnionSubtype(preTransform, postTransform, recursionCount) {
         return postTransform;
     }
     _transformGenericTypeAlias(type, recursionCount) {
@@ -2268,11 +2357,11 @@ class TypeVarTransformer {
             return classType;
         }
         let newTypeArgs = [];
-        let newVariadicTypeArgs;
+        let newTupleTypeArgs;
         let specializationNeeded = false;
         const typeParams = types_1.ClassType.getTypeParameters(classType);
         const transformParamSpec = (paramSpec) => {
-            const paramSpecValue = this.transformParamSpec(paramSpec);
+            const paramSpecValue = this.transformParamSpec(paramSpec, recursionCount);
             if (paramSpecValue) {
                 specializationNeeded = true;
                 return convertParamSpecValueToType(paramSpecValue);
@@ -2315,7 +2404,7 @@ class TypeVarTransformer {
                 else {
                     const typeParamName = types_1.TypeVarType.getNameWithScope(typeParam);
                     if (!this._pendingTypeVarTransformations.has(typeParamName)) {
-                        const transformedType = this.transformTypeVar(typeParam);
+                        const transformedType = this.transformTypeVar(typeParam, recursionCount);
                         replacementType = transformedType !== null && transformedType !== void 0 ? transformedType : typeParam;
                         if (replacementType !== typeParam) {
                             specializationNeeded = true;
@@ -2330,7 +2419,7 @@ class TypeVarTransformer {
         }
         if (types_1.ClassType.isTupleClass(classType)) {
             if (classType.tupleTypeArguments) {
-                newVariadicTypeArgs = [];
+                newTupleTypeArgs = [];
                 classType.tupleTypeArguments.forEach((oldTypeArgType) => {
                     const newTypeArgType = this.apply(oldTypeArgType.type, recursionCount);
                     if (newTypeArgType !== oldTypeArgType.type) {
@@ -2340,16 +2429,16 @@ class TypeVarTransformer {
                         (0, types_1.isClassInstance)(newTypeArgType) &&
                         isTupleClass(newTypeArgType) &&
                         newTypeArgType.tupleTypeArguments) {
-                        (0, collectionUtils_1.appendArray)(newVariadicTypeArgs, newTypeArgType.tupleTypeArguments);
+                        (0, collectionUtils_1.appendArray)(newTupleTypeArgs, newTypeArgType.tupleTypeArguments);
                     }
                     else {
-                        newVariadicTypeArgs.push({ type: newTypeArgType, isUnbounded: oldTypeArgType.isUnbounded });
+                        newTupleTypeArgs.push({ type: newTypeArgType, isUnbounded: oldTypeArgType.isUnbounded });
                     }
                 });
             }
             else if (typeParams.length > 0) {
-                newVariadicTypeArgs = this.transformVariadicTypeVar(typeParams[0]);
-                if (newVariadicTypeArgs) {
+                newTupleTypeArgs = this.transformTupleTypeVar(typeParams[0], recursionCount);
+                if (newTupleTypeArgs) {
                     specializationNeeded = true;
                 }
             }
@@ -2361,13 +2450,13 @@ class TypeVarTransformer {
         }
         return types_1.ClassType.cloneForSpecialization(classType, newTypeArgs, 
         /* isTypeArgumentExplicit */ true, 
-        /* includeSubclasses */ undefined, newVariadicTypeArgs);
+        /* includeSubclasses */ undefined, newTupleTypeArgs);
     }
     _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);
+            const paramSpec = this.transformParamSpec(functionType.details.paramSpec, recursionCount);
             if (paramSpec) {
                 functionType = types_1.FunctionType.cloneForParamSpec(functionType, paramSpec);
             }
@@ -2392,11 +2481,11 @@ class TypeVarTransformer {
                 (0, types_1.isParamSpec)(argsParamType) &&
                 (0, types_1.isParamSpec)(kwargsParamType) &&
                 (0, types_1.isTypeSame)(argsParamType, kwargsParamType)) {
-                const paramSpecType = this.transformParamSpec(argsParamType);
+                const paramSpecType = this.transformParamSpec(argsParamType, recursionCount);
                 if (paramSpecType) {
-                    if (paramSpecType.parameters.length > 0 ||
-                        paramSpecType.paramSpec === undefined ||
-                        !(0, types_1.isTypeSame)(argsParamType, paramSpecType.paramSpec)) {
+                    if (paramSpecType.details.parameters.length > 0 ||
+                        paramSpecType.details.paramSpec === undefined ||
+                        !(0, types_1.isTypeSame)(argsParamType, paramSpecType.details.paramSpec)) {
                         functionType = types_1.FunctionType.cloneForParamSpecApplication(functionType, paramSpecType);
                     }
                 }
@@ -2508,26 +2597,47 @@ class TypeVarTransformer {
         return newFunctionType;
     }
 }
+// For a TypeVar with a default type, validates whether the default type is using
+// any other TypeVars that are not currently in scope.
+class TypeVarDefaultValidator extends TypeVarTransformer {
+    constructor(_liveTypeParams, _invalidTypeVars) {
+        super();
+        this._liveTypeParams = _liveTypeParams;
+        this._invalidTypeVars = _invalidTypeVars;
+    }
+    transformTypeVar(typeVar) {
+        const replacementType = this._liveTypeParams.find((param) => param.details.name === typeVar.details.name);
+        if (!replacementType || (0, types_1.isParamSpec)(replacementType)) {
+            this._invalidTypeVars.add(typeVar.details.name);
+        }
+        return types_1.UnknownType.create();
+    }
+    transformParamSpec(paramSpec) {
+        const replacementType = this._liveTypeParams.find((param) => param.details.name === paramSpec.details.name);
+        if (!replacementType || !(0, types_1.isParamSpec)(replacementType)) {
+            this._invalidTypeVars.add(paramSpec.details.name);
+        }
+        return undefined;
+    }
+}
 // 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) {
+    constructor(_typeVarContext, _options) {
         super();
         this._typeVarContext = _typeVarContext;
-        this._unknownIfNotFound = _unknownIfNotFound;
-        this._useNarrowBoundOnly = _useNarrowBoundOnly;
-        this._eliminateUnsolvedInUnions = _eliminateUnsolvedInUnions;
-        this._typeClassType = _typeClassType;
+        this._options = _options;
+        this._isSolvingDefaultType = false;
     }
-    transformTypeVar(typeVar) {
+    transformTypeVar(typeVar, recursionCount) {
         // 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);
+            let replacement = this._typeVarContext.getTypeVarType(typeVar, !!this._options.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) {
+            if (!replacement && !!this._options.useNarrowBoundOnly) {
                 const wideType = this._typeVarContext.getTypeVarType(typeVar);
                 if (wideType) {
                     if (containsLiteralType(wideType, /* includeTypeArgs */ true)) {
@@ -2538,9 +2648,9 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
             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], 
+                        this._options.typeClassType &&
+                        (0, types_1.isInstantiableClass)(this._options.typeClassType)) {
+                        replacement = types_1.ClassType.cloneForSpecialization(types_1.ClassType.cloneAsInstance(this._options.typeClassType), [replacement], 
                         /* isTypeArgumentExplicit */ true);
                     }
                     else {
@@ -2552,13 +2662,40 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
             // If this typeVar is in scope for what we're solving but the type
             // var map doesn't contain any entry for it, replace with the
             // default or Unknown.
-            if (this._unknownIfNotFound && !this._typeVarContext.hasSolveForScope(types_1.WildcardTypeVarScopeId)) {
+            if (this._options.unknownIfNotFound && !this._typeVarContext.hasSolveForScope(types_1.WildcardTypeVarScopeId)) {
+                // Use the default value if there is one.
                 if (typeVar.details.defaultType) {
-                    return typeVar.details.defaultType;
+                    return this._solveDefaultType(typeVar.details.defaultType, recursionCount);
                 }
                 return types_1.UnknownType.create();
             }
         }
+        // If we're solving a default type, handle type variables with no scope ID.
+        if (this._isSolvingDefaultType && !typeVar.scopeId) {
+            const replacementEntry = this._typeVarContext
+                .getTypeVars()
+                .find((entry) => entry.typeVar.details.name === typeVar.details.name);
+            if (replacementEntry) {
+                return this._typeVarContext.getTypeVarType(replacementEntry.typeVar);
+            }
+            if (typeVar.details.defaultType) {
+                return this.apply(typeVar.details.defaultType, recursionCount);
+            }
+            return types_1.UnknownType.create();
+        }
+        // If we're solving a default type, handle type variables with no scope ID.
+        if (this._isSolvingDefaultType && !typeVar.scopeId) {
+            const replacementEntry = this._typeVarContext
+                .getTypeVars()
+                .find((entry) => entry.typeVar.details.name === typeVar.details.name);
+            if (replacementEntry) {
+                return this._typeVarContext.getTypeVarType(replacementEntry.typeVar);
+            }
+            if (typeVar.details.defaultType) {
+                return this.apply(typeVar.details.defaultType, recursionCount);
+            }
+            return types_1.UnknownType.create();
+        }
         return undefined;
     }
     transformUnionSubtype(preTransform, postTransform) {
@@ -2567,7 +2704,7 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         // 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 (this._options.eliminateUnsolvedInUnions) {
             if ((0, types_1.isTypeVar)(preTransform) &&
                 preTransform.scopeId !== undefined &&
                 this._typeVarContext.hasSolveForScope(preTransform.scopeId)) {
@@ -2578,56 +2715,66 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
                 }
                 // If _unknownIfNotFound is true, the postTransform type will
                 // be Unknown, which we want to eliminate.
-                if ((0, types_1.isUnknown)(postTransform) && this._unknownIfNotFound) {
+                if ((0, types_1.isUnknown)(postTransform) && this._options.unknownIfNotFound) {
                     return undefined;
                 }
             }
         }
         return postTransform;
     }
-    transformVariadicTypeVar(typeVar) {
+    transformTupleTypeVar(typeVar) {
         if (!typeVar.scopeId || !this._typeVarContext.hasSolveForScope(typeVar.scopeId)) {
-            if (typeVar.details.defaultType &&
-                (0, types_1.isClassInstance)(typeVar.details.defaultType) &&
-                typeVar.details.defaultType.tupleTypeArguments) {
-                return typeVar.details.defaultType.tupleTypeArguments;
+            const defaultType = typeVar.details.defaultType;
+            if (defaultType && (0, types_1.isClassInstance)(defaultType) && defaultType.tupleTypeArguments) {
+                return defaultType.tupleTypeArguments;
             }
             return undefined;
         }
-        return this._typeVarContext.getVariadicTypeVar(typeVar);
+        return this._typeVarContext.getTupleTypeVar(typeVar);
     }
-    transformParamSpec(paramSpec) {
+    transformParamSpec(paramSpec, recursionCount) {
+        // If we're solving a default type, handle param specs with no scope ID.
+        if (this._isSolvingDefaultType && !paramSpec.scopeId) {
+            const replacementEntry = this._typeVarContext
+                .getTypeVars()
+                .find((entry) => entry.typeVar.details.name === paramSpec.details.name);
+            if (replacementEntry) {
+                return this._typeVarContext.getParamSpecType(replacementEntry.typeVar);
+            }
+            if (paramSpec.details.defaultType) {
+                return convertTypeToParamSpecValue(this.apply(paramSpec.details.defaultType, recursionCount));
+            }
+            return this._getUnknownParamSpec();
+        }
         if (!paramSpec.scopeId || !this._typeVarContext.hasSolveForScope(paramSpec.scopeId)) {
             return undefined;
         }
-        const transformedParamSpec = this._typeVarContext.getParamSpec(paramSpec);
+        const transformedParamSpec = this._typeVarContext.getParamSpecType(paramSpec);
         if (transformedParamSpec) {
             return transformedParamSpec;
         }
-        if (this._unknownIfNotFound && !this._typeVarContext.hasSolveForScope(types_1.WildcardTypeVarScopeId)) {
+        if (this._options.unknownIfNotFound && !this._typeVarContext.hasSolveForScope(types_1.WildcardTypeVarScopeId)) {
             // Use the default value if there is one.
-            if (paramSpec.details.defaultType && (0, types_1.isFunction)(paramSpec.details.defaultType)) {
-                const funcType = paramSpec.details.defaultType;
-                return {
-                    flags: funcType.details.flags,
-                    parameters: funcType.details.parameters,
-                    typeVarScopeId: funcType.details.typeVarScopeId,
-                    docString: funcType.details.docString,
-                    paramSpec: funcType.details.paramSpec,
-                };
+            if (paramSpec.details.defaultType) {
+                return convertTypeToParamSpecValue(this._solveDefaultType(paramSpec.details.defaultType, recursionCount));
             }
             // Convert to the ParamSpec equivalent of "Unknown".
-            const paramSpecValue = {
-                flags: 32768 /* SkipArgsKwargsCompatibilityCheck */,
-                parameters: types_1.FunctionType.getDefaultParameters(/* useUnknown */ true),
-                typeVarScopeId: undefined,
-                docString: undefined,
-                paramSpec: undefined,
-            };
-            return paramSpecValue;
+            return this._getUnknownParamSpec();
         }
         return undefined;
     }
+    _solveDefaultType(defaultType, recursionCount) {
+        const wasSolvingDefaultType = this._isSolvingDefaultType;
+        this._isSolvingDefaultType = true;
+        const result = this.apply(defaultType, recursionCount);
+        this._isSolvingDefaultType = wasSolvingDefaultType;
+        return result;
+    }
+    _getUnknownParamSpec() {
+        const paramSpecValue = types_1.FunctionType.createInstance('', '', '', 65536 /* ParamSpecValue */ | 32768 /* SkipArgsKwargsCompatibilityCheck */);
+        types_1.FunctionType.addDefaultParameters(paramSpecValue);
+        return paramSpecValue;
+    }
 }
 class ExpectedConstructorTypeTransformer extends TypeVarTransformer {
     constructor(_liveTypeVarScopes) {