@zzzen/pyright-internal 1.2.0-dev.20230326 → 1.2.0-dev.20230409

package/dist/analyzer/typeUtils.js

@@ -5,15 +5,14 @@
  * Licensed under the MIT license.
  * Author: Eric Traut
  *
- * Collection of functions that operate on Type objects.
+ * Functions that operate on Type objects.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isTypeVarLimitedToCallable = exports.getTypeVarArgumentsRecursive = exports.addTypeVarsToListIfUnique = exports.getClassFieldsRecursive = exports.getClassIterator = exports.getClassMemberIterator = exports.lookUpClassMember = exports.lookUpObjectMember = exports.getContainerDepth = 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.makeInferenceContext = 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.combineVariances = 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.isMetaclassInstance = exports.getGeneratorYieldType = exports.getDeclaredGeneratorReturnType = exports.synthesizeTypeVarForSelfCls = exports.derivesFromClassRecursive = exports.specializeForBaseClass = exports.buildTypeVarContext = exports.buildTypeVarContextFromSpecializedClass = exports.setTypeArgumentsRecursive = exports.specializeClassType = void 0;
+exports.getTypeVarArgumentsRecursive = exports.addTypeVarsToListIfUnique = exports.getClassFieldsRecursive = exports.getClassIterator = exports.getClassMemberIterator = exports.lookUpClassMember = exports.lookUpObjectMember = exports.getContainerDepth = exports.getProtocolSymbols = exports.transformExpectedTypeForConstructor = exports.validateTypeVarDefault = exports.applySolvedTypeVars = exports.ensureFunctionSignaturesAreUnique = 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.makeInferenceContext = exports.isTypeVarSame = exports.isIncompleteUnknown = exports.isOptionalType = exports.UniqueSignatureTracker = exports.AssignTypeFlags = exports.ClassIteratorFlags = exports.ClassMemberLookupFlags = void 0;
+exports.convertParamSpecValueToType = exports.convertTypeToParamSpecValue = exports.getDeclaringModulesForType = exports.computeMroLinearization = exports.isVarianceOfTypeArgumentCompatible = exports.combineVariances = 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.isMetaclassInstance = exports.getGeneratorYieldType = exports.getDeclaredGeneratorReturnType = exports.synthesizeTypeVarForSelfCls = exports.derivesFromClassRecursive = exports.specializeForBaseClass = exports.buildTypeVarContext = exports.buildTypeVarContextFromSpecializedClass = exports.setTypeArgumentsRecursive = exports.specializeClassType = exports.isTypeVarLimitedToCallable = 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");
@@ -100,185 +99,26 @@ var AssignTypeFlags;
     // employing narrowing or widening, and don't strip literals.
     AssignTypeFlags[AssignTypeFlags["PopulatingExpectedType"] = 1024] = "PopulatingExpectedType";
 })(AssignTypeFlags = exports.AssignTypeFlags || (exports.AssignTypeFlags = {}));
-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;
+class UniqueSignatureTracker {
+    constructor() {
+        this.signaturesSeen = [];
     }
-    for (let i = 0; i < positionOnlyIndex; i++) {
-        if (type.details.parameters[i].hasDefault) {
-            break;
-        }
-        result.positionOnlyParamCount++;
+    findSignature(signature) {
+        return this.signaturesSeen.find((s) => {
+            return (0, types_1.isTypeSame)(signature, s.type);
+        });
     }
-    let sawKeywordOnlySeparator = false;
-    const addVirtualParameter = (param, index, typeOverride, defaultArgTypeOverride, sourceOverride) => {
-        if (param.name) {
-            let source;
-            if (sourceOverride !== undefined) {
-                source = sourceOverride;
-            }
-            else 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) {
-                const addToPositionalOnly = index < result.positionOnlyParamCount;
-                paramType.tupleTypeArguments.forEach((tupleArg, tupleIndex) => {
-                    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}[${tupleIndex.toString()}]`,
-                        isNameSynthesized: true,
-                        type: tupleArg.type,
-                        hasDeclaredType: true,
-                    }, index, tupleArg.type, 
-                    /* defaultArgTypeOverride */ undefined, ParameterSource.PositionOnly);
-                    if (category === 0 /* Simple */) {
-                        result.positionParamCount++;
-                    }
-                    if (tupleIndex > 0 && addToPositionalOnly) {
-                        result.positionOnlyParamCount++;
-                    }
-                });
-                // 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;
-                    sawKeywordOnlySeparator = true;
-                }
-            }
-            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;
-            const paramType = types_1.FunctionType.getEffectiveParameterType(type, index);
-            // Is this an unpacked TypedDict? If so, expand the entries.
-            if ((0, types_1.isClassInstance)(paramType) && (0, types_1.isUnpackedClass)(paramType) && paramType.details.typedDictEntries) {
-                if (result.firstKeywordOnlyIndex === undefined) {
-                    result.firstKeywordOnlyIndex = result.params.length;
-                }
-                const typedDictType = paramType;
-                paramType.details.typedDictEntries.forEach((entry, name) => {
-                    const specializedParamType = partiallySpecializeType(entry.valueType, typedDictType);
-                    addVirtualParameter({
-                        category: 0 /* Simple */,
-                        name,
-                        type: specializedParamType,
-                        hasDeclaredType: true,
-                        hasDefault: !entry.isRequired,
-                    }, index, specializedParamType);
-                });
-                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);
-            }
+    addSignature(signature) {
+        const existingSignature = this.findSignature(signature);
+        if (existingSignature) {
+            existingSignature.count++;
         }
-        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);
+        else {
+            this.signaturesSeen.push({ type: signature, count: 1 });
         }
-    });
-    return result;
+    }
 }
-exports.getParameterListDetails = getParameterListDetails;
+exports.UniqueSignatureTracker = UniqueSignatureTracker;
 function isOptionalType(type) {
     if ((0, types_1.isUnion)(type)) {
         return (0, types_1.findSubtype)(type, (subtype) => (0, types_1.isNoneInstance)(subtype)) !== undefined;
@@ -290,6 +130,36 @@ function isIncompleteUnknown(type) {
     return (0, types_1.isUnknown)(type) && type.isIncomplete;
 }
 exports.isIncompleteUnknown = isIncompleteUnknown;
+// Similar to isTypeSame except that type1 is a TypeVar and type2
+// can be either a TypeVar of the same type or a union that includes
+// conditional types associated with that bound TypeVar.
+function isTypeVarSame(type1, type2) {
+    if ((0, types_1.isTypeSame)(type1, type2)) {
+        return true;
+    }
+    // If this isn't a bound TypeVar, return false.
+    if (type1.details.isParamSpec || type1.details.isVariadic || !type1.details.boundType) {
+        return false;
+    }
+    // If the second type isn't a union, return false.
+    if (!(0, types_1.isUnion)(type2)) {
+        return false;
+    }
+    let isCompatible = true;
+    doForEachSubtype(type2, (subtype) => {
+        if (!isCompatible) {
+            return;
+        }
+        if (!(0, types_1.isTypeSame)(type1, subtype)) {
+            const conditions = getTypeCondition(subtype);
+            if (!conditions || !conditions.some((condition) => condition.typeVarName === type1.nameWithScope)) {
+                isCompatible = false;
+            }
+        }
+    });
+    return isCompatible;
+}
+exports.isTypeVarSame = isTypeVarSame;
 function makeInferenceContext(expectedType, typeVarContext, isTypeIncomplete) {
     if (!expectedType) {
         return undefined;
@@ -837,6 +707,13 @@ function populateTypeVarContextForSelfType(typeVarContext, contextClassType, sel
     typeVarContext.setTypeVarType(synthesizedSelfTypeVar, convertToInstance(selfClass));
 }
 exports.populateTypeVarContextForSelfType = populateTypeVarContextForSelfType;
+// Looks for duplicate function types within the type and ensures that
+// if they are generic, they have unique type variables.
+function ensureFunctionSignaturesAreUnique(type, signatureTracker) {
+    const transformer = new UniqueFunctionSignatureTransformer(signatureTracker);
+    return transformer.apply(type, 0);
+}
+exports.ensureFunctionSignaturesAreUnique = ensureFunctionSignaturesAreUnique;
 // Specializes a (potentially generic) type by substituting
 // type variables from a type var map.
 function applySolvedTypeVars(type, typeVarContext, options = {}) {
@@ -1597,11 +1474,13 @@ function convertToInstance(type, includeSubclasses = true) {
     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);
     }
-    // Cache the converted value for next time.
-    if (!type.cached) {
-        type.cached = {};
+    if (type !== result) {
+        // Cache the converted value for next time.
+        if (!type.cached) {
+            type.cached = {};
+        }
+        type.cached.instanceType = result;
     }
-    type.cached.instanceType = result;
     return result;
 }
 exports.convertToInstance = convertToInstance;
@@ -2323,7 +2202,7 @@ class TypeVarTransformer {
             return type;
         }
         recursionCount++;
-        type = this._transformGenericTypeAlias(type, recursionCount);
+        type = this.transformGenericTypeAlias(type, recursionCount);
         // Shortcut the operation if possible.
         if (!requiresSpecialization(type)) {
             return type;
@@ -2405,7 +2284,7 @@ class TypeVarTransformer {
             return !(0, types_1.isNever)(newUnionType) ? newUnionType : types_1.UnknownType.create();
         }
         if ((0, types_1.isClass)(type)) {
-            return this._transformTypeVarsInClassType(type, recursionCount);
+            return this.transformTypeVarsInClassType(type, recursionCount);
         }
         if ((0, types_1.isFunction)(type)) {
             // Prevent recursion.
@@ -2413,7 +2292,7 @@ class TypeVarTransformer {
                 return type;
             }
             this._pendingFunctionTransformations.push(type);
-            const result = this._transformTypeVarsInFunctionType(type, recursionCount);
+            const result = this.transformTypeVarsInFunctionType(type, recursionCount);
             this._pendingFunctionTransformations.pop();
             return result;
         }
@@ -2427,7 +2306,7 @@ class TypeVarTransformer {
             // Specialize each of the functions in the overload.
             const newOverloads = [];
             type.overloads.forEach((entry) => {
-                const replacementType = this._transformTypeVarsInFunctionType(entry, recursionCount);
+                const replacementType = this.transformTypeVarsInFunctionType(entry, recursionCount);
                 if ((0, types_1.isFunction)(replacementType)) {
                     newOverloads.push(replacementType);
                 }
@@ -2445,7 +2324,7 @@ class TypeVarTransformer {
         return type;
     }
     transformTypeVar(typeVar, recursionCount) {
-        return typeVar;
+        return undefined;
     }
     transformTupleTypeVar(paramSpec, recursionCount) {
         return undefined;
@@ -2461,7 +2340,7 @@ class TypeVarTransformer {
         // can override this method as they see fit.
         return callback();
     }
-    _transformGenericTypeAlias(type, recursionCount) {
+    transformGenericTypeAlias(type, recursionCount) {
         if (!type.typeAliasInfo || !type.typeAliasInfo.typeParameters || !type.typeAliasInfo.typeArguments) {
             return type;
         }
@@ -2477,12 +2356,12 @@ class TypeVarTransformer {
             ? types_1.TypeBase.cloneForTypeAlias(type, type.typeAliasInfo.name, type.typeAliasInfo.fullName, type.typeAliasInfo.typeVarScopeId, type.typeAliasInfo.typeParameters, newTypeArgs)
             : type;
     }
-    _transformTypeVarsInClassType(classType, recursionCount) {
+    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 newTypeArgs;
         let newTupleTypeArgs;
         let specializationNeeded = false;
         const typeParams = types_1.ClassType.getTypeParameters(classType);
@@ -2499,50 +2378,7 @@ class TypeVarTransformer {
         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)) {
-                        const transformedType = this.transformTypeVar(typeParam, recursionCount);
-                        replacementType = transformedType !== null && transformedType !== void 0 ? transformedType : typeParam;
-                        if (replacementType !== typeParam) {
-                            specializationNeeded = true;
-                        }
-                        else if (transformedType !== undefined && !classType.typeArguments) {
-                            specializationNeeded = true;
-                        }
-                    }
-                }
-                newTypeArgs.push(replacementType);
-            });
-        }
+        // Handle tuples specially.
         if (types_1.ClassType.isTupleClass(classType)) {
             if (classType.tupleTypeArguments) {
                 newTupleTypeArgs = [];
@@ -2568,6 +2404,66 @@ class TypeVarTransformer {
                     specializationNeeded = true;
                 }
             }
+            // If this is an empty tuple, don't recompute the non-tuple type argument.
+            if (newTupleTypeArgs && newTupleTypeArgs.length > 0) {
+                // Combine the tuple type args into a single non-tuple type argument.
+                newTypeArgs = [
+                    (0, types_1.combineTypes)(newTupleTypeArgs.map((t) => {
+                        if ((0, types_1.isTypeVar)(t.type) && (0, types_1.isUnpackedVariadicTypeVar)(t.type)) {
+                            // Treat the unpacked TypeVarTuple as a union.
+                            return types_1.TypeVarType.cloneForUnpacked(t.type, /* isInUnion */ true);
+                        }
+                        return t.type;
+                    })),
+                ];
+            }
+        }
+        if (!newTypeArgs) {
+            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 {
+                newTypeArgs = [];
+                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)) {
+                            const transformedType = this.transformTypeVar(typeParam, recursionCount);
+                            replacementType = transformedType !== null && transformedType !== void 0 ? transformedType : typeParam;
+                            if (replacementType !== typeParam) {
+                                specializationNeeded = true;
+                            }
+                            else if (transformedType !== undefined && !classType.typeArguments) {
+                                specializationNeeded = true;
+                            }
+                        }
+                    }
+                    newTypeArgs.push(replacementType);
+                });
+            }
         }
         this._isTransformingTypeArg = wasTransformingTypeArg;
         // If specialization wasn't needed, don't allocate a new class.
@@ -2578,7 +2474,7 @@ class TypeVarTransformer {
         /* isTypeArgumentExplicit */ true, 
         /* includeSubclasses */ undefined, newTupleTypeArgs);
     }
-    _transformTypeVarsInFunctionType(sourceType, recursionCount) {
+    transformTypeVarsInFunctionType(sourceType, recursionCount) {
         return this.doForEachSignatureContext(() => {
             let functionType = sourceType;
             // Handle functions with a parameter specification in a special manner.
@@ -2754,6 +2650,32 @@ class TypeVarDefaultValidator extends TypeVarTransformer {
         return undefined;
     }
 }
+class UniqueFunctionSignatureTransformer extends TypeVarTransformer {
+    constructor(_signatureTracker) {
+        super();
+        this._signatureTracker = _signatureTracker;
+    }
+    transformTypeVarsInFunctionType(sourceType, recursionCount) {
+        // If this function is not generic, there's no need to check for uniqueness.
+        if (sourceType.details.typeParameters.length === 0) {
+            return super.transformTypeVarsInFunctionType(sourceType, recursionCount);
+        }
+        let updatedSourceType = sourceType;
+        const existingSignature = this._signatureTracker.findSignature(sourceType);
+        if (existingSignature) {
+            const typeVarContext = new typeVarContext_1.TypeVarContext(getTypeVarScopeId(sourceType));
+            // Create new type variables with the same scope but with
+            // different (unique) names.
+            sourceType.details.typeParameters.forEach((typeParam) => {
+                const replacement = types_1.TypeVarType.cloneForNewName(typeParam, `${typeParam.details.name}(${existingSignature.count})`);
+                typeVarContext.setTypeVarType(typeParam, replacement);
+                updatedSourceType = applySolvedTypeVars(sourceType, typeVarContext);
+            });
+        }
+        this._signatureTracker.addSignature(sourceType);
+        return updatedSourceType;
+    }
+}
 // Specializes a (potentially generic) type by substituting
 // type variables from a type var map.
 class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {