@zzzen/pyright-internal 1.2.0-dev.20230604 → 1.2.0-dev.20230618

package/dist/analyzer/typeUtils.js

@@ -9,7 +9,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.lookUpClassMember = exports.lookUpObjectMember = exports.getContainerDepth = exports.getProtocolSymbolsRecursive = exports.getProtocolSymbols = exports.transformExpectedType = exports.validateTypeVarDefault = exports.applyInScopePlaceholders = exports.applySourceContextTypeVarsToSignature = exports.applySourceContextTypeVars = exports.applySolvedTypeVars = exports.ensureFunctionSignaturesAreUnique = exports.populateTypeVarContextForSelfType = exports.partiallySpecializeType = exports.isUnboundedTupleClass = exports.isTupleClass = exports.isMaybeDescriptorInstance = exports.isDescriptorInstance = exports.isCallableType = exports.isProperty = exports.isEllipsisType = exports.getUnionSubtypeCount = exports.getLiteralTypeClassName = exports.containsLiteralType = exports.isLiteralTypeOrUnion = exports.isLiteralType = exports.getSpecializedTupleType = exports.getTypeVarScopeIds = 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.getCommonErasedType = exports.specializeTupleClass = exports.combineSameSizedTuples = exports.explodeGenericClass = exports.isPartlyUnknown = exports.containsAnyOrUnknown = exports.getMembersForModule = exports.getMembersForClass = exports.convertToInstantiable = exports.convertToInstance = exports.isEffectivelyInstantiable = exports.isMetaclassInstance = exports.isInstantiableMetaclass = exports.getGeneratorYieldType = exports.getDeclaredGeneratorReturnType = exports.synthesizeTypeVarForSelfCls = exports.derivesFromClassRecursive = exports.specializeForBaseClass = exports.buildTypeVarContext = exports.buildTypeVarContextFromSpecializedClass = exports.setTypeArgumentsRecursive = exports.specializeClassType = exports.isTypeVarLimitedToCallable = exports.getTypeVarArgumentsRecursive = exports.addTypeVarsToListIfUnique = exports.getClassFieldsRecursive = exports.getClassIterator = exports.getClassMemberIterator = 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.containsAnyOrUnknown = exports.getMembersForModule = exports.getMembersForClass = exports.convertToInstantiable = exports.convertToInstance = exports.isEffectivelyInstantiable = exports.isMetaclassInstance = exports.isInstantiableMetaclass = exports.getGeneratorYieldType = exports.getDeclaredGeneratorReturnType = exports.synthesizeTypeVarForSelfCls = exports.derivesFromClassRecursive = exports.specializeForBaseClass = exports.buildTypeVarContext = exports.buildTypeVarContextFromSpecializedClass = exports.setTypeArgumentsRecursive = exports.specializeClassType = exports.isTypeVarLimitedToCallable = exports.getTypeVarArgumentsRecursive = exports.addTypeVarsToListIfUnique = exports.getClassFieldsRecursive = exports.getClassIterator = exports.getClassMemberIterator = void 0;
 const collectionUtils_1 = require("../common/collectionUtils");
 const debug_1 = require("../common/debug");
 const symbol_1 = require("./symbol");
@@ -43,18 +43,14 @@ var ClassMemberLookupFlags;
 var ClassIteratorFlags;
 (function (ClassIteratorFlags) {
     ClassIteratorFlags[ClassIteratorFlags["Default"] = 0] = "Default";
-    // By default, the original (derived) class is searched along
-    // with its base classes. If this flag is set, the original
-    // class is skipped and only the base classes are searched.
-    ClassIteratorFlags[ClassIteratorFlags["SkipOriginalClass"] = 1] = "SkipOriginalClass";
     // By default, base classes are searched as well as the
     // original (derived) class. If this flag is set, no recursion
     // is performed.
-    ClassIteratorFlags[ClassIteratorFlags["SkipBaseClasses"] = 2] = "SkipBaseClasses";
+    ClassIteratorFlags[ClassIteratorFlags["SkipBaseClasses"] = 1] = "SkipBaseClasses";
     // Skip the 'object' base class in particular.
-    ClassIteratorFlags[ClassIteratorFlags["SkipObjectBaseClass"] = 4] = "SkipObjectBaseClass";
+    ClassIteratorFlags[ClassIteratorFlags["SkipObjectBaseClass"] = 2] = "SkipObjectBaseClass";
     // Skip the 'type' base class in particular.
-    ClassIteratorFlags[ClassIteratorFlags["SkipTypeBaseClass"] = 8] = "SkipTypeBaseClass";
+    ClassIteratorFlags[ClassIteratorFlags["SkipTypeBaseClass"] = 4] = "SkipTypeBaseClass";
 })(ClassIteratorFlags = exports.ClassIteratorFlags || (exports.ClassIteratorFlags = {}));
 var AssignTypeFlags;
 (function (AssignTypeFlags) {
@@ -100,22 +96,38 @@ var AssignTypeFlags;
     // employing narrowing or widening, and don't strip literals.
     AssignTypeFlags[AssignTypeFlags["PopulatingExpectedType"] = 1024] = "PopulatingExpectedType";
 })(AssignTypeFlags = exports.AssignTypeFlags || (exports.AssignTypeFlags = {}));
+// Tracks whether a function signature has been seen before within
+// an expression. For example, in the expression "foo(foo, foo)", the
+// signature for "foo" will be seen three times at three different
+// file offsets. If the signature is generic, we need to create unique
+// type variables for each instance because they are independent of
+// each other.
 class UniqueSignatureTracker {
     constructor() {
-        this.signaturesSeen = [];
+        this._signaturesSeen = [];
     }
     findSignature(signature) {
-        return this.signaturesSeen.find((s) => {
-            return (0, types_1.isTypeSame)(signature, s.type);
+        // Use the associated overload type if this is a function associated with an overload.
+        let effectiveSignature = signature;
+        if ((0, types_1.isFunction)(signature) && signature.overloaded) {
+            effectiveSignature = signature.overloaded;
+        }
+        return this._signaturesSeen.find((s) => {
+            return (0, types_1.isTypeSame)(effectiveSignature, s.type);
         });
     }
-    addSignature(signature) {
-        const existingSignature = this.findSignature(signature);
+    addSignature(signature, offset) {
+        var _a;
+        // If this function is part of a broader overload, use the overload instead.
+        const effectiveSignature = (_a = signature.overloaded) !== null && _a !== void 0 ? _a : signature;
+        const existingSignature = this.findSignature(effectiveSignature);
         if (existingSignature) {
-            existingSignature.count++;
+            if (!existingSignature.expressionOffsets.some((o) => o === offset)) {
+                existingSignature.expressionOffsets.push(offset);
+            }
         }
         else {
-            this.signaturesSeen.push({ type: signature, count: 1 });
+            this._signaturesSeen.push({ type: effectiveSignature, expressionOffsets: [offset] });
         }
     }
 }
@@ -161,11 +173,11 @@ function isTypeVarSame(type1, type2) {
     return isCompatible;
 }
 exports.isTypeVarSame = isTypeVarSame;
-function makeInferenceContext(expectedType, isTypeIncomplete) {
+function makeInferenceContext(expectedType, isTypeIncomplete, signatureTracker) {
     if (!expectedType) {
         return undefined;
     }
-    return { expectedType, isTypeIncomplete };
+    return { expectedType, isTypeIncomplete, signatureTracker };
 }
 exports.makeInferenceContext = makeInferenceContext;
 // Calls a callback for each subtype and combines the results
@@ -712,7 +724,7 @@ function partiallySpecializeType(type, contextClassType, selfClass, typeClassTyp
         return type;
     }
     // Partially specialize the type using the specialized class type vars.
-    const typeVarContext = buildTypeVarContextFromSpecializedClass(contextClassType, /* makeConcrete */ undefined);
+    const typeVarContext = buildTypeVarContextFromSpecializedClass(contextClassType);
     if (selfClass) {
         populateTypeVarContextForSelfType(typeVarContext, contextClassType, selfClass);
     }
@@ -726,8 +738,8 @@ function populateTypeVarContextForSelfType(typeVarContext, contextClassType, sel
 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);
+function ensureFunctionSignaturesAreUnique(type, signatureTracker, expressionOffset) {
+    const transformer = new UniqueFunctionSignatureTransformer(signatureTracker, expressionOffset);
     return transformer.apply(type, 0);
 }
 exports.ensureFunctionSignaturesAreUnique = ensureFunctionSignaturesAreUnique;
@@ -895,18 +907,18 @@ function getContainerDepth(type, recursionCount = 0) {
     return 1 + maxChildDepth;
 }
 exports.getContainerDepth = getContainerDepth;
-function lookUpObjectMember(objectType, memberName, flags = 0 /* Default */) {
+function lookUpObjectMember(objectType, memberName, flags = 0 /* Default */, skipMroClass) {
     if ((0, types_1.isClassInstance)(objectType)) {
-        return lookUpClassMember(objectType, memberName, flags);
+        return lookUpClassMember(objectType, memberName, flags, skipMroClass);
     }
     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 */) {
+function lookUpClassMember(classType, memberName, flags = 0 /* Default */, skipMroClass) {
     var _a;
-    const memberItr = getClassMemberIterator(classType, memberName, flags);
+    const memberItr = getClassMemberIterator(classType, memberName, flags, skipMroClass);
     return (_a = memberItr.next()) === null || _a === void 0 ? void 0 : _a.value;
 }
 exports.lookUpClassMember = lookUpClassMember;
@@ -918,24 +930,28 @@ exports.lookUpClassMember = lookUpClassMember;
 // 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 */) {
+// If skipMroClass is defined, all MRO classes up to and including that class
+// are skipped.
+function* getClassMemberIterator(classType, memberName, flags = 0 /* Default */, skipMroClass) {
     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 ((0, types_1.isClass)(classType)) {
+                skipMroClass = classType;
+            }
         }
         if (flags & 2 /* SkipBaseClasses */) {
-            classFlags = classFlags | 2 /* SkipBaseClasses */;
+            classFlags = classFlags | 1 /* SkipBaseClasses */;
         }
         if (flags & 4 /* SkipObjectBaseClass */) {
-            classFlags = classFlags | 4 /* SkipObjectBaseClass */;
+            classFlags = classFlags | 2 /* SkipObjectBaseClass */;
         }
         if (flags & 32 /* SkipTypeBaseClass */) {
-            classFlags = classFlags | 8 /* SkipTypeBaseClass */;
+            classFlags = classFlags | 4 /* SkipTypeBaseClass */;
         }
-        const classItr = getClassIterator(classType, classFlags);
+        const classItr = getClassIterator(classType, classFlags, skipMroClass);
         for (const [mroClass, specializedMroClass] of classItr) {
             if (!(0, types_1.isInstantiableClass)(mroClass)) {
                 if (!declaredTypesOnly) {
@@ -1035,19 +1051,28 @@ function* getClassMemberIterator(classType, memberName, flags = 0 /* Default */)
     return undefined;
 }
 exports.getClassMemberIterator = getClassMemberIterator;
-function* getClassIterator(classType, flags = 0 /* Default */) {
+function* getClassIterator(classType, flags = 0 /* Default */, skipMroClass) {
     if ((0, types_1.isClass)(classType)) {
-        let skipMroEntry = (flags & 1 /* SkipOriginalClass */) !== 0;
+        let foundSkipMroClass = skipMroClass === undefined;
         for (const mroClass of classType.details.mro) {
-            if (skipMroEntry) {
-                skipMroEntry = false;
-                continue;
+            // Are we still searching fro teh skipMroClass?
+            if (!foundSkipMroClass && skipMroClass) {
+                if (!(0, types_1.isClass)(mroClass)) {
+                    foundSkipMroClass = true;
+                }
+                else if (types_1.ClassType.isSameGenericClass(mroClass, skipMroClass)) {
+                    foundSkipMroClass = true;
+                    continue;
+                }
+                else {
+                    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 (flags & 2 /* SkipObjectBaseClass */) {
                 if ((0, types_1.isInstantiableClass)(specializedMroClass)) {
                     if (types_1.ClassType.isBuiltIn(specializedMroClass, 'object')) {
                         break;
@@ -1055,7 +1080,7 @@ function* getClassIterator(classType, flags = 0 /* Default */) {
                 }
             }
             // Should we ignore members on the 'type' base class?
-            if (flags & 8 /* SkipTypeBaseClass */) {
+            if (flags & 4 /* SkipTypeBaseClass */) {
                 if ((0, types_1.isInstantiableClass)(specializedMroClass)) {
                     if (types_1.ClassType.isBuiltIn(specializedMroClass, 'type')) {
                         break;
@@ -1063,7 +1088,7 @@ function* getClassIterator(classType, flags = 0 /* Default */) {
                 }
             }
             yield [mroClass, specializedMroClass];
-            if ((flags & 2 /* SkipBaseClasses */) !== 0) {
+            if ((flags & 1 /* SkipBaseClasses */) !== 0) {
                 break;
             }
         }
@@ -1328,16 +1353,9 @@ exports.setTypeArgumentsRecursive = setTypeArgumentsRecursive;
 // 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) {
+function buildTypeVarContextFromSpecializedClass(classType) {
     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));
+    const typeVarContext = buildTypeVarContext(typeParameters, classType.typeArguments, getTypeVarScopeId(classType));
     if (types_1.ClassType.isTupleClass(classType) && classType.tupleTypeArguments && typeParameters.length >= 1) {
         typeVarContext.setTupleTypeVar(typeParameters[0], classType.tupleTypeArguments);
     }
@@ -1349,7 +1367,7 @@ function buildTypeVarContext(typeParameters, typeArgs, typeVarScopeId) {
     typeParameters.forEach((typeParam, index) => {
         let typeArgType;
         if (typeArgs) {
-            if ((0, types_1.isParamSpec)(typeParam)) {
+            if (typeParam.details.isParamSpec) {
                 if (index < typeArgs.length) {
                     typeArgType = typeArgs[index];
                     if ((0, types_1.isFunction)(typeArgType) && types_1.FunctionType.isParamSpecValue(typeArgType)) {
@@ -1692,27 +1710,71 @@ function containsAnyOrUnknown(type, recurse) {
 }
 exports.containsAnyOrUnknown = containsAnyOrUnknown;
 // Determines if any part of the type contains "Unknown", including any type arguments.
-function isPartlyUnknown(type, allowUnknownTypeArgsForClasses = false) {
-    class PartlyUnknownWalker extends typeWalker_1.TypeWalker {
-        constructor(_allowUnknownTypeArgsForClasses) {
-            super();
-            this._allowUnknownTypeArgsForClasses = _allowUnknownTypeArgsForClasses;
-            this.isPartlyUnknown = false;
+// This function does not use the TypeWalker because it is called very frequently,
+// and allocating a memory walker object for every call significantly increases
+// peak memory usage.
+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;
         }
-        visitUnknown(type) {
-            this.isPartlyUnknown = true;
-            // No need to keep walking.
-            this.cancelWalk();
+    }
+    // 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;
+                    }
+                }
+            }
         }
-        visitClass(type) {
-            if (!this._allowUnknownTypeArgsForClasses || !types_1.TypeBase.isInstantiable(type)) {
-                super.visitClass(type);
+        return false;
+    }
+    // See if a function has an unknown type.
+    if ((0, types_1.isOverloadedFunction)(type)) {
+        return types_1.OverloadedFunctionType.getOverloads(type).some((overload) => {
+            return isPartlyUnknown(overload, /* allowUnknownTypeArgsForClasses */ 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;
     }
-    const walker = new PartlyUnknownWalker(allowUnknownTypeArgsForClasses);
-    walker.walk(type);
-    return walker.isPartlyUnknown;
+    return false;
 }
 exports.isPartlyUnknown = isPartlyUnknown;
 // If the specified type is a generic class with a single type argument
@@ -1800,31 +1862,6 @@ function specializeTupleClass(classType, typeArgs, isTypeArgumentExplicit = true
     return clonedClassType;
 }
 exports.specializeTupleClass = specializeTupleClass;
-// If the array contains two or more class types that are all the same
-// generic type, return the common "erased" type — a type that
-// replaces all of the type arguments with Unknown.
-function getCommonErasedType(types) {
-    if (types.length < 2) {
-        return undefined;
-    }
-    if (!(0, types_1.isClass)(types[0])) {
-        return undefined;
-    }
-    for (let i = 1; i < types.length; i++) {
-        const candidate = types[i];
-        if (!(0, types_1.isClass)(candidate) ||
-            types_1.TypeBase.isInstance(candidate) !== types_1.TypeBase.isInstance(types[0]) ||
-            !types_1.ClassType.isSameGenericClass(types[0], candidate)) {
-            return undefined;
-        }
-    }
-    if (isTupleClass(types[0])) {
-        return specializeTupleClass(types[0], [{ type: types_1.UnknownType.create(), isUnbounded: true }]);
-    }
-    return types_1.ClassType.cloneForSpecialization(types[0], types[0].details.typeParameters.map((t) => types_1.UnknownType.create()), 
-    /* isTypeArgumentExplicit */ true);
-}
-exports.getCommonErasedType = getCommonErasedType;
 // 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.
@@ -2101,7 +2138,7 @@ function computeMroLinearization(classType) {
     const classListsToMerge = [];
     filteredBaseClasses.forEach((baseClass) => {
         if ((0, types_1.isInstantiableClass)(baseClass)) {
-            const typeVarContext = buildTypeVarContextFromSpecializedClass(baseClass, /* makeConcrete */ false);
+            const typeVarContext = buildTypeVarContextFromSpecializedClass(baseClass);
             classListsToMerge.push(baseClass.details.mro.map((mroClass) => {
                 return applySolvedTypeVars(mroClass, typeVarContext);
             }));
@@ -2111,11 +2148,11 @@ function computeMroLinearization(classType) {
         }
     });
     classListsToMerge.push(filteredBaseClasses.map((baseClass) => {
-        const typeVarContext = buildTypeVarContextFromSpecializedClass(classType, /* makeConcrete */ false);
+        const typeVarContext = buildTypeVarContextFromSpecializedClass(classType);
         return applySolvedTypeVars(baseClass, typeVarContext);
     }));
     // The first class in the MRO is the class itself.
-    const typeVarContext = buildTypeVarContextFromSpecializedClass(classType, /* makeConcrete */ false);
+    const typeVarContext = buildTypeVarContextFromSpecializedClass(classType);
     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
@@ -2758,9 +2795,18 @@ class TypeVarDefaultValidator extends TypeVarTransformer {
     }
 }
 class UniqueFunctionSignatureTransformer extends TypeVarTransformer {
-    constructor(_signatureTracker) {
+    constructor(_signatureTracker, _expressionOffset) {
         super();
         this._signatureTracker = _signatureTracker;
+        this._expressionOffset = _expressionOffset;
+    }
+    transformGenericTypeAlias(type, recursionCount) {
+        // Don't transform type aliases.
+        return type;
+    }
+    transformTypeVarsInClassType(classType, recursionCount) {
+        // Don't transform classes.
+        return classType;
     }
     transformTypeVarsInFunctionType(sourceType, recursionCount) {
         // If this function is not generic, there's no need to check for uniqueness.
@@ -2771,19 +2817,25 @@ class UniqueFunctionSignatureTransformer extends TypeVarTransformer {
         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) => {
-                let replacement = types_1.TypeVarType.cloneForNewName(typeParam, `${typeParam.details.name}(${existingSignature.count})`);
-                if (replacement.details.isParamSpec) {
-                    replacement = convertTypeToParamSpecValue(replacement);
-                }
-                typeVarContext.setTypeVarType(typeParam, replacement);
-            });
-            updatedSourceType = applySolvedTypeVars(sourceType, typeVarContext);
-            (0, debug_1.assert)((0, types_1.isFunction)(updatedSourceType) || (0, types_1.isOverloadedFunction)(updatedSourceType));
+            let offsetIndex = existingSignature.expressionOffsets.findIndex((offset) => offset === this._expressionOffset);
+            if (offsetIndex < 0) {
+                offsetIndex = existingSignature.expressionOffsets.length;
+            }
+            if (offsetIndex > 0) {
+                // Create new type variables with the same scope but with
+                // different (unique) names.
+                sourceType.details.typeParameters.forEach((typeParam) => {
+                    let replacement = types_1.TypeVarType.cloneForNewName(typeParam, `${typeParam.details.name}(${offsetIndex})`);
+                    if (replacement.details.isParamSpec) {
+                        replacement = convertTypeToParamSpecValue(replacement);
+                    }
+                    typeVarContext.setTypeVarType(typeParam, replacement);
+                });
+                updatedSourceType = applySolvedTypeVars(sourceType, typeVarContext);
+                (0, debug_1.assert)((0, types_1.isFunction)(updatedSourceType) || (0, types_1.isOverloadedFunction)(updatedSourceType));
+            }
         }
-        this._signatureTracker.addSignature(sourceType);
+        this._signatureTracker.addSignature(sourceType, this._expressionOffset);
         return updatedSourceType;
     }
 }
@@ -2921,7 +2973,7 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         return signatureContext.getTupleTypeVar(typeVar);
     }
     transformParamSpec(paramSpec, recursionCount) {
-        var _a;
+        var _a, _b;
         const signatureContext = this._typeVarContext.getSignatureContext((_a = this._activeTypeVarSignatureContextIndex) !== null && _a !== void 0 ? _a : 0);
         // If we're solving a default type, handle param specs with no scope ID.
         if (this._isSolvingDefaultType && !paramSpec.scopeId) {
@@ -2945,7 +2997,10 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         }
         let useDefaultOrUnknown = false;
         if (this._options.unknownIfNotFound && !this._typeVarContext.hasSolveForScope(types_1.WildcardTypeVarScopeId)) {
-            useDefaultOrUnknown = true;
+            const exemptTypeVars = (_b = this._options.unknownExemptTypeVars) !== null && _b !== void 0 ? _b : [];
+            if (!exemptTypeVars.some((t) => (0, types_1.isTypeSame)(t, paramSpec, { ignoreTypeFlags: true }))) {
+                useDefaultOrUnknown = true;
+            }
         }
         else if (this._options.applyInScopePlaceholders && paramSpec.isInScopePlaceholder) {
             useDefaultOrUnknown = true;