@zzzen/pyright-internal 1.2.0-dev.20230205 → 1.2.0-dev.20230219

package/dist/analyzer/typeUtils.js

@@ -1354,8 +1354,8 @@ function setTypeArgumentsRecursive(destType, srcType, typeVarContext, recursionC
                     setTypeArgumentsRecursive(destType.details.declaredReturnType, srcType, typeVarContext, recursionCount);
                 }
                 if (destType.details.paramSpec) {
-                    // Fill in an empty signature for a ParamSpec if the source is Any or Unknown.
-                    if (!typeVarContext.hasTypeVar(destType.details.paramSpec) && (0, types_1.isAnyOrUnknown)(srcType)) {
+                    // Fill in an empty signature for a ParamSpec.
+                    if (!typeVarContext.getPrimarySignature().getTypeVar(destType.details.paramSpec)) {
                         const newFunction = types_1.FunctionType.createInstance('', '', '', 32768 /* SkipArgsKwargsCompatibilityCheck */ | 65536 /* ParamSpecValue */);
                         types_1.FunctionType.addDefaultParameters(newFunction);
                         typeVarContext.setTypeVarType(destType.details.paramSpec, newFunction);
@@ -1369,7 +1369,7 @@ function setTypeArgumentsRecursive(destType, srcType, typeVarContext, recursionC
             });
             break;
         case 10 /* TypeVar */:
-            if (!typeVarContext.hasTypeVar(destType)) {
+            if (!typeVarContext.getPrimarySignature().getTypeVar(destType)) {
                 typeVarContext.setTypeVarType(destType, srcType);
             }
             break;
@@ -2370,7 +2370,12 @@ class TypeVarTransformer {
             const newOverloads = [];
             type.overloads.forEach((entry) => {
                 const replacementType = this._transformTypeVarsInFunctionType(entry, recursionCount);
-                newOverloads.push(replacementType);
+                if ((0, types_1.isFunction)(replacementType)) {
+                    newOverloads.push(replacementType);
+                }
+                else {
+                    newOverloads.push(...replacementType.overloads);
+                }
                 if (replacementType !== entry) {
                     requiresUpdate = true;
                 }
@@ -2393,6 +2398,11 @@ class TypeVarTransformer {
     transformUnionSubtype(preTransform, postTransform, recursionCount) {
         return postTransform;
     }
+    doForEachSignatureContext(callback) {
+        // By default, simply return the result of the callback. Subclasses
+        // can override this method as they see fit.
+        return callback();
+    }
     _transformGenericTypeAlias(type, recursionCount) {
         if (!type.typeAliasInfo || !type.typeAliasInfo.typeParameters || !type.typeAliasInfo.typeArguments) {
             return type;
@@ -2511,148 +2521,156 @@ class TypeVarTransformer {
         /* 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, recursionCount);
-            if (paramSpec) {
-                functionType = types_1.FunctionType.cloneForParamSpec(functionType, paramSpec);
-            }
-        }
-        const declaredReturnType = types_1.FunctionType.getSpecializedReturnType(functionType);
-        const specializedReturnType = declaredReturnType ? this.apply(declaredReturnType, recursionCount) : undefined;
-        let typesRequiredSpecialization = declaredReturnType !== specializedReturnType;
-        const specializedParameters = {
-            parameterTypes: [],
-            returnType: specializedReturnType,
-        };
-        // Does this function end with *args: P.args, **args: P.kwargs? If so, we'll
-        // modify the function and replace these parameters with the signature captured
-        // by the ParamSpec.
-        if (functionType.details.parameters.length >= 2) {
-            const argsParam = functionType.details.parameters[functionType.details.parameters.length - 2];
-            const kwargsParam = functionType.details.parameters[functionType.details.parameters.length - 1];
-            const argsParamType = types_1.FunctionType.getEffectiveParameterType(functionType, functionType.details.parameters.length - 2);
-            const kwargsParamType = types_1.FunctionType.getEffectiveParameterType(functionType, functionType.details.parameters.length - 1);
-            if (argsParam.category === 1 /* VarArgList */ &&
-                kwargsParam.category === 2 /* VarArgDictionary */ &&
-                (0, types_1.isParamSpec)(argsParamType) &&
-                (0, types_1.isParamSpec)(kwargsParamType) &&
-                (0, types_1.isTypeSame)(argsParamType, kwargsParamType)) {
-                const paramSpecType = this.transformParamSpec(argsParamType, recursionCount);
-                if (paramSpecType) {
-                    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);
+        return this.doForEachSignatureContext(() => {
+            let functionType = sourceType;
+            // Handle functions with a parameter specification in a special manner.
+            if (functionType.details.paramSpec) {
+                const paramSpec = this.transformParamSpec(functionType.details.paramSpec, recursionCount);
+                if (paramSpec) {
+                    functionType = types_1.FunctionType.cloneForParamSpec(functionType, paramSpec);
+                }
+            }
+            const declaredReturnType = types_1.FunctionType.getSpecializedReturnType(functionType);
+            const specializedReturnType = declaredReturnType
+                ? this.apply(declaredReturnType, recursionCount)
+                : undefined;
+            let typesRequiredSpecialization = declaredReturnType !== specializedReturnType;
+            const specializedParameters = {
+                parameterTypes: [],
+                returnType: specializedReturnType,
+            };
+            // Does this function end with *args: P.args, **args: P.kwargs? If so, we'll
+            // modify the function and replace these parameters with the signature captured
+            // by the ParamSpec.
+            if (functionType.details.parameters.length >= 2) {
+                const argsParam = functionType.details.parameters[functionType.details.parameters.length - 2];
+                const kwargsParam = functionType.details.parameters[functionType.details.parameters.length - 1];
+                const argsParamType = types_1.FunctionType.getEffectiveParameterType(functionType, functionType.details.parameters.length - 2);
+                const kwargsParamType = types_1.FunctionType.getEffectiveParameterType(functionType, functionType.details.parameters.length - 1);
+                if (argsParam.category === 1 /* VarArgList */ &&
+                    kwargsParam.category === 2 /* VarArgDictionary */ &&
+                    (0, types_1.isParamSpec)(argsParamType) &&
+                    (0, types_1.isParamSpec)(kwargsParamType) &&
+                    (0, types_1.isTypeSame)(argsParamType, kwargsParamType)) {
+                    const paramSpecType = this.transformParamSpec(argsParamType, recursionCount);
+                    if (paramSpecType) {
+                        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);
+                        }
                     }
                 }
             }
-        }
-        let variadicParamIndex;
-        let variadicTypesToUnpack;
-        const specializedDefaultArgs = [];
-        const wasTransformingTypeArg = this._isTransformingTypeArg;
-        this._isTransformingTypeArg = true;
-        for (let i = 0; i < functionType.details.parameters.length; i++) {
-            const paramType = types_1.FunctionType.getEffectiveParameterType(functionType, i);
-            const specializedType = this.apply(paramType, recursionCount);
-            specializedParameters.parameterTypes.push(specializedType);
-            // Do we need to specialize the default argument type for this parameter?
-            let defaultArgType = types_1.FunctionType.getEffectiveParameterDefaultArgType(functionType, i);
-            if (defaultArgType) {
-                const specializedArgType = this.apply(defaultArgType, recursionCount);
-                if (specializedArgType !== defaultArgType) {
-                    defaultArgType = specializedArgType;
+            let variadicParamIndex;
+            let variadicTypesToUnpack;
+            const specializedDefaultArgs = [];
+            const wasTransformingTypeArg = this._isTransformingTypeArg;
+            this._isTransformingTypeArg = true;
+            for (let i = 0; i < functionType.details.parameters.length; i++) {
+                const paramType = types_1.FunctionType.getEffectiveParameterType(functionType, i);
+                const specializedType = this.apply(paramType, recursionCount);
+                specializedParameters.parameterTypes.push(specializedType);
+                // Do we need to specialize the default argument type for this parameter?
+                let defaultArgType = types_1.FunctionType.getEffectiveParameterDefaultArgType(functionType, i);
+                if (defaultArgType) {
+                    const specializedArgType = this.apply(defaultArgType, recursionCount);
+                    if (specializedArgType !== defaultArgType) {
+                        defaultArgType = specializedArgType;
+                        typesRequiredSpecialization = true;
+                    }
+                }
+                specializedDefaultArgs.push(defaultArgType);
+                if (variadicParamIndex === undefined &&
+                    (0, types_1.isVariadicTypeVar)(paramType) &&
+                    functionType.details.parameters[i].category === 1 /* VarArgList */) {
+                    variadicParamIndex = i;
+                    if ((0, types_1.isClassInstance)(specializedType) &&
+                        isTupleClass(specializedType) &&
+                        specializedType.isUnpacked) {
+                        variadicTypesToUnpack = specializedType.tupleTypeArguments;
+                    }
+                }
+                if (paramType !== specializedType) {
                     typesRequiredSpecialization = true;
                 }
             }
-            specializedDefaultArgs.push(defaultArgType);
-            if (variadicParamIndex === undefined &&
-                (0, types_1.isVariadicTypeVar)(paramType) &&
-                functionType.details.parameters[i].category === 1 /* VarArgList */) {
-                variadicParamIndex = i;
-                if ((0, types_1.isClassInstance)(specializedType) && isTupleClass(specializedType) && specializedType.isUnpacked) {
-                    variadicTypesToUnpack = specializedType.tupleTypeArguments;
+            let specializedInferredReturnType;
+            if (functionType.inferredReturnType) {
+                specializedInferredReturnType = this.apply(functionType.inferredReturnType, recursionCount);
+                if (specializedInferredReturnType !== functionType.inferredReturnType) {
+                    typesRequiredSpecialization = true;
                 }
             }
-            if (paramType !== specializedType) {
-                typesRequiredSpecialization = true;
-            }
-        }
-        let specializedInferredReturnType;
-        if (functionType.inferredReturnType) {
-            specializedInferredReturnType = this.apply(functionType.inferredReturnType, recursionCount);
-            if (specializedInferredReturnType !== functionType.inferredReturnType) {
-                typesRequiredSpecialization = true;
-            }
-        }
-        this._isTransformingTypeArg = wasTransformingTypeArg;
-        if (!typesRequiredSpecialization) {
-            return functionType;
-        }
-        if (specializedDefaultArgs.some((t) => t !== undefined)) {
-            specializedParameters.parameterDefaultArgs = specializedDefaultArgs;
-        }
-        // If there was no unpacked variadic type variable, we're done.
-        if (!variadicTypesToUnpack) {
-            return types_1.FunctionType.cloneForSpecialization(functionType, specializedParameters, specializedInferredReturnType);
-        }
-        // Unpack the tuple and synthesize a new function in the process.
-        const newFunctionType = types_1.FunctionType.createSynthesizedInstance('', functionType.details.flags);
-        let insertKeywordOnlySeparator = false;
-        let swallowPositionOnlySeparator = false;
-        specializedParameters.parameterTypes.forEach((paramType, index) => {
-            if (index === variadicParamIndex) {
-                let sawUnboundedEntry = false;
-                // Unpack the tuple into individual parameters.
-                variadicTypesToUnpack.forEach((unpackedType) => {
-                    types_1.FunctionType.addParameter(newFunctionType, {
-                        category: unpackedType.isUnbounded ? 1 /* VarArgList */ : 0 /* Simple */,
-                        name: `__p${newFunctionType.details.parameters.length}`,
-                        isNameSynthesized: true,
-                        type: unpackedType.type,
-                        hasDeclaredType: true,
+            this._isTransformingTypeArg = wasTransformingTypeArg;
+            if (!typesRequiredSpecialization) {
+                return functionType;
+            }
+            if (specializedDefaultArgs.some((t) => t !== undefined)) {
+                specializedParameters.parameterDefaultArgs = specializedDefaultArgs;
+            }
+            // If there was no unpacked variadic type variable, we're done.
+            if (!variadicTypesToUnpack) {
+                return types_1.FunctionType.cloneForSpecialization(functionType, specializedParameters, specializedInferredReturnType);
+            }
+            // Unpack the tuple and synthesize a new function in the process.
+            const newFunctionType = types_1.FunctionType.createSynthesizedInstance('', functionType.details.flags);
+            let insertKeywordOnlySeparator = false;
+            let swallowPositionOnlySeparator = false;
+            specializedParameters.parameterTypes.forEach((paramType, index) => {
+                if (index === variadicParamIndex) {
+                    let sawUnboundedEntry = false;
+                    // Unpack the tuple into individual parameters.
+                    variadicTypesToUnpack.forEach((unpackedType) => {
+                        types_1.FunctionType.addParameter(newFunctionType, {
+                            category: unpackedType.isUnbounded
+                                ? 1 /* VarArgList */
+                                : 0 /* Simple */,
+                            name: `__p${newFunctionType.details.parameters.length}`,
+                            isNameSynthesized: true,
+                            type: unpackedType.type,
+                            hasDeclaredType: true,
+                        });
+                        if (unpackedType.isUnbounded) {
+                            sawUnboundedEntry = true;
+                        }
                     });
-                    if (unpackedType.isUnbounded) {
-                        sawUnboundedEntry = true;
+                    if (sawUnboundedEntry) {
+                        swallowPositionOnlySeparator = true;
+                    }
+                    else {
+                        insertKeywordOnlySeparator = true;
                     }
-                });
-                if (sawUnboundedEntry) {
-                    swallowPositionOnlySeparator = true;
                 }
                 else {
-                    insertKeywordOnlySeparator = true;
-                }
-            }
-            else {
-                const param = { ...functionType.details.parameters[index] };
-                if (param.category === 1 /* VarArgList */ && !param.name) {
-                    insertKeywordOnlySeparator = false;
-                }
-                else if (param.category === 2 /* VarArgDictionary */) {
-                    insertKeywordOnlySeparator = false;
-                }
-                // Insert a keyword-only separator parameter if we previously
-                // unpacked a variadic TypeVar.
-                if (param.category === 0 /* Simple */ && param.name && insertKeywordOnlySeparator) {
-                    types_1.FunctionType.addParameter(newFunctionType, {
-                        category: 1 /* VarArgList */,
-                        type: types_1.UnknownType.create(),
-                    });
-                    insertKeywordOnlySeparator = false;
-                }
-                param.type = paramType;
-                if (param.name && param.isNameSynthesized) {
-                    param.name = `__p${newFunctionType.details.parameters.length}`;
-                }
-                if (param.category !== 0 /* Simple */ || param.name || !swallowPositionOnlySeparator) {
-                    types_1.FunctionType.addParameter(newFunctionType, param);
+                    const param = { ...functionType.details.parameters[index] };
+                    if (param.category === 1 /* VarArgList */ && !param.name) {
+                        insertKeywordOnlySeparator = false;
+                    }
+                    else if (param.category === 2 /* VarArgDictionary */) {
+                        insertKeywordOnlySeparator = false;
+                    }
+                    // Insert a keyword-only separator parameter if we previously
+                    // unpacked a variadic TypeVar.
+                    if (param.category === 0 /* Simple */ && param.name && insertKeywordOnlySeparator) {
+                        types_1.FunctionType.addParameter(newFunctionType, {
+                            category: 1 /* VarArgList */,
+                            type: types_1.UnknownType.create(),
+                        });
+                        insertKeywordOnlySeparator = false;
+                    }
+                    param.type = paramType;
+                    if (param.name && param.isNameSynthesized) {
+                        param.name = `__p${newFunctionType.details.parameters.length}`;
+                    }
+                    if (param.category !== 0 /* Simple */ || param.name || !swallowPositionOnlySeparator) {
+                        types_1.FunctionType.addParameter(newFunctionType, param);
+                    }
                 }
-            }
+            });
+            newFunctionType.details.declaredReturnType = specializedParameters.returnType;
+            return newFunctionType;
         });
-        newFunctionType.details.declaredReturnType = specializedParameters.returnType;
-        return newFunctionType;
     }
 }
 // For a TypeVar with a default type, validates whether the default type is using
@@ -2688,15 +2706,17 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         this._isSolvingDefaultType = false;
     }
     transformTypeVar(typeVar, recursionCount) {
+        var _a;
+        const signatureContext = this._typeVarContext.getSignatureContext((_a = this._activeTypeVarSignatureContextIndex) !== null && _a !== void 0 ? _a : 0);
         // 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._options.useNarrowBoundOnly);
+            let replacement = signatureContext.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._options.useNarrowBoundOnly) {
-                const wideType = this._typeVarContext.getTypeVarType(typeVar);
+                const wideType = signatureContext.getTypeVarType(typeVar);
                 if (wideType) {
                     if (containsLiteralType(wideType, /* includeTypeArgs */ true)) {
                         replacement = wideType;
@@ -2730,11 +2750,11 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         }
         // If we're solving a default type, handle type variables with no scope ID.
         if (this._isSolvingDefaultType && !typeVar.scopeId) {
-            const replacementEntry = this._typeVarContext
+            const replacementEntry = signatureContext
                 .getTypeVars()
                 .find((entry) => entry.typeVar.details.name === typeVar.details.name);
             if (replacementEntry) {
-                return this._typeVarContext.getTypeVarType(replacementEntry.typeVar);
+                return signatureContext.getTypeVarType(replacementEntry.typeVar);
             }
             if (typeVar.details.defaultType) {
                 return this.apply(typeVar.details.defaultType, recursionCount);
@@ -2743,11 +2763,11 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         }
         // If we're solving a default type, handle type variables with no scope ID.
         if (this._isSolvingDefaultType && !typeVar.scopeId) {
-            const replacementEntry = this._typeVarContext
+            const replacementEntry = signatureContext
                 .getTypeVars()
                 .find((entry) => entry.typeVar.details.name === typeVar.details.name);
             if (replacementEntry) {
-                return this._typeVarContext.getTypeVarType(replacementEntry.typeVar);
+                return signatureContext.getTypeVarType(replacementEntry.typeVar);
             }
             if (typeVar.details.defaultType) {
                 return this.apply(typeVar.details.defaultType, recursionCount);
@@ -2781,6 +2801,7 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         return postTransform;
     }
     transformTupleTypeVar(typeVar) {
+        var _a;
         if (!typeVar.scopeId || !this._typeVarContext.hasSolveForScope(typeVar.scopeId)) {
             const defaultType = typeVar.details.defaultType;
             if (defaultType && (0, types_1.isClassInstance)(defaultType) && defaultType.tupleTypeArguments) {
@@ -2788,16 +2809,19 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
             }
             return undefined;
         }
-        return this._typeVarContext.getTupleTypeVar(typeVar);
+        const signatureContext = this._typeVarContext.getSignatureContext((_a = this._activeTypeVarSignatureContextIndex) !== null && _a !== void 0 ? _a : 0);
+        return signatureContext.getTupleTypeVar(typeVar);
     }
     transformParamSpec(paramSpec, recursionCount) {
+        var _a;
+        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) {
-            const replacementEntry = this._typeVarContext
+            const replacementEntry = signatureContext
                 .getTypeVars()
                 .find((entry) => entry.typeVar.details.name === paramSpec.details.name);
             if (replacementEntry) {
-                return this._typeVarContext.getParamSpecType(replacementEntry.typeVar);
+                return signatureContext.getParamSpecType(replacementEntry.typeVar);
             }
             if (paramSpec.details.defaultType) {
                 return convertTypeToParamSpecValue(this.apply(paramSpec.details.defaultType, recursionCount));
@@ -2807,7 +2831,7 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         if (!paramSpec.scopeId || !this._typeVarContext.hasSolveForScope(paramSpec.scopeId)) {
             return undefined;
         }
-        const transformedParamSpec = this._typeVarContext.getParamSpecType(paramSpec);
+        const transformedParamSpec = signatureContext.getParamSpecType(paramSpec);
         if (transformedParamSpec) {
             return transformedParamSpec;
         }
@@ -2821,6 +2845,29 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         }
         return undefined;
     }
+    doForEachSignatureContext(callback) {
+        const signatureContexts = this._typeVarContext.getSignatureContexts();
+        // Handle the common case where there are not multiple signature contexts.
+        if (signatureContexts.length <= 1) {
+            return callback();
+        }
+        // Loop through all of the signature contexts in the type var context
+        // to create an overload type.
+        const overloadTypes = signatureContexts.map((_, index) => {
+            this._activeTypeVarSignatureContextIndex = index;
+            return callback();
+        });
+        this._activeTypeVarSignatureContextIndex = undefined;
+        const filteredOverloads = [];
+        doForEachSubtype((0, types_1.combineTypes)(overloadTypes), (subtype) => {
+            (0, debug_1.assert)((0, types_1.isFunction)(subtype));
+            filteredOverloads.push(subtype);
+        });
+        if (filteredOverloads.length === 1) {
+            return filteredOverloads[0];
+        }
+        return types_1.OverloadedFunctionType.create(filteredOverloads);
+    }
     _solveDefaultType(defaultType, recursionCount) {
         const wasSolvingDefaultType = this._isSolvingDefaultType;
         this._isSolvingDefaultType = true;