@zzzen/pyright-internal 1.2.0-dev.20231008 → 1.2.0-dev.20231022

package/dist/analyzer/constraintSolver.js

@@ -21,6 +21,9 @@ const typeVarContext_1 = require("./typeVarContext");
 // many subtypes. For performance reasons, we need to cap this at some
 // point. This constant determines the cap.
 const maxSubtypeCountForTypeVarNarrowBound = 64;
+// This debugging switch enables logging of the TypeVarContext before and
+// after it is updated by the constraint solver.
+const logTypeVarContextUpdates = false;
 // Assigns the source type to the dest type var in the type var context. If an existing
 // type is already associated with that type var name, it attempts to either widen or
 // narrow the type (depending on the value of the isContravariant parameter). The goal is
@@ -28,7 +31,19 @@ const maxSubtypeCountForTypeVarNarrowBound = 64;
 // has been "locked", it simply validates that the srcType is compatible (with no attempt
 // to widen or narrow).
 function assignTypeToTypeVar(evaluator, destType, srcType, diag, typeVarContext, flags = 0 /* Default */, recursionCount = 0) {
+    if (logTypeVarContextUpdates) {
+        const indent = ' '.repeat(recursionCount * 2);
+        console.log(`${indent}`);
+        console.log(`${indent}assignTypeToTypeVar called with`);
+        console.log(`${indent}destType: ${evaluator.printType(destType)}`);
+        console.log(`${indent}srcType: ${evaluator.printType(srcType)}`);
+        console.log(`${indent}flags: ${flags}`);
+        console.log(`${indent}scopes: ${(typeVarContext.getSolveForScopes() || []).join(', ')}`);
+        console.log(`${indent}pre-call context #${typeVarContext.getId()}: `);
+        logTypeVarContext(evaluator, typeVarContext, indent);
+    }
     let isTypeVarInScope = true;
+    const isInvariant = (flags & 1 /* EnforceInvariance */) !== 0;
     const isContravariant = (flags & 2 /* ReverseTypeVarMatching */) !== 0;
     // If the TypeVar doesn't have a scope ID, then it's being used
     // outside of a valid TypeVar scope. This will be reported as a
@@ -51,7 +66,7 @@ function assignTypeToTypeVar(evaluator, destType, srcType, diag, typeVarContext,
         }
         // Never or NoReturn is always assignable to all type variables unless
         // we're enforcing invariance.
-        if ((0, types_1.isNever)(srcType) && (flags & 1 /* EnforceInvariance */) === 0) {
+        if ((0, types_1.isNever)(srcType) && !isInvariant) {
             return true;
         }
         // If we're in "ignore type var scope" mode, don't generate
@@ -103,144 +118,20 @@ function assignTypeToTypeVar(evaluator, destType, srcType, diag, typeVarContext,
         !srcType.typeArguments) {
         srcType = types_1.AnyType.create();
     }
-    const curEntry = typeVarContext.getPrimarySignature().getTypeVar(destType);
-    const curNarrowTypeBound = curEntry === null || curEntry === void 0 ? void 0 : curEntry.narrowBound;
-    let curWideTypeBound = curEntry === null || curEntry === void 0 ? void 0 : curEntry.wideBound;
-    if (!curWideTypeBound && !destType.details.isSynthesizedSelf) {
-        curWideTypeBound = destType.details.boundType;
-    }
     // Handle the constrained case. This case needs to be handled specially
     // because type narrowing isn't used in this case. For example, if the
     // source type is "Literal[1]" and the constraint list includes the type
     // "float", the resulting type is float.
     if (destType.details.constraints.length > 0) {
-        let constrainedType;
-        const concreteSrcType = evaluator.makeTopLevelTypeVarsConcrete(srcType);
-        if ((0, types_1.isTypeVar)(srcType)) {
-            if (evaluator.assignType(destType, concreteSrcType, 
-            /* diag */ undefined, new typeVarContext_1.TypeVarContext(destType.scopeId), 
-            /* srcTypeVarContext */ undefined, 0 /* Default */, recursionCount)) {
-                constrainedType = srcType;
-                // If the source and dest are both instantiables (type[T]), then
-                // we need to convert to an instance (T).
-                if (types_1.TypeBase.isInstantiable(srcType)) {
-                    constrainedType = (0, typeUtils_1.convertToInstance)(srcType, /* includeSubclasses */ false);
-                }
-            }
-        }
-        else {
-            let isCompatible = true;
-            // Subtypes that are not conditionally dependent on the dest type var
-            // must all map to the same constraint. For example, Union[str, bytes]
-            // cannot be assigned to AnyStr.
-            let unconditionalConstraintIndex;
-            // Find the narrowest constrained type that is compatible.
-            constrainedType = (0, typeUtils_1.mapSubtypes)(concreteSrcType, (srcSubtype) => {
-                let constrainedSubtype;
-                if ((0, types_1.isAnyOrUnknown)(srcSubtype)) {
-                    return srcSubtype;
-                }
-                let constraintIndexUsed;
-                destType.details.constraints.forEach((constraint, i) => {
-                    const adjustedConstraint = types_1.TypeBase.isInstantiable(destType)
-                        ? (0, typeUtils_1.convertToInstantiable)(constraint)
-                        : constraint;
-                    if (evaluator.assignType(adjustedConstraint, srcSubtype, 
-                    /* diag */ undefined, 
-                    /* destTypeVarContext */ undefined, 
-                    /* srcTypeVarContext */ undefined, 0 /* Default */, recursionCount)) {
-                        if (!constrainedSubtype ||
-                            evaluator.assignType(types_1.TypeBase.isInstantiable(destType)
-                                ? (0, typeUtils_1.convertToInstantiable)(constrainedSubtype)
-                                : constrainedSubtype, adjustedConstraint, 
-                            /* diag */ undefined, 
-                            /* destTypeVarContext */ undefined, 
-                            /* srcTypeVarContext */ undefined, 0 /* Default */, recursionCount)) {
-                            constrainedSubtype = (0, typeUtils_1.addConditionToType)(constraint, (0, typeUtils_1.getTypeCondition)(srcSubtype));
-                            constraintIndexUsed = i;
-                        }
-                    }
-                });
-                if (!constrainedSubtype) {
-                    // We found a source subtype that is not compatible with the dest.
-                    // This is OK if we're handling the contravariant case because only
-                    // one subtype needs to be assignable in that case.
-                    if (!isContravariant) {
-                        isCompatible = false;
-                    }
-                }
-                // If this subtype isn't conditional, make sure it maps to the same
-                // constraint index as previous unconditional subtypes.
-                if (constraintIndexUsed !== undefined && !(0, typeUtils_1.getTypeCondition)(srcSubtype)) {
-                    if (unconditionalConstraintIndex !== undefined &&
-                        unconditionalConstraintIndex !== constraintIndexUsed) {
-                        isCompatible = false;
-                    }
-                    unconditionalConstraintIndex = constraintIndexUsed;
-                }
-                return constrainedSubtype;
-            });
-            if ((0, types_1.isNever)(constrainedType) || !isCompatible) {
-                constrainedType = undefined;
-            }
-            // If the type is a union, see if the entire union is assignable to one
-            // of the constraints.
-            if (!constrainedType && (0, types_1.isUnion)(concreteSrcType)) {
-                constrainedType = destType.details.constraints.find((constraint) => {
-                    const adjustedConstraint = types_1.TypeBase.isInstantiable(destType)
-                        ? (0, typeUtils_1.convertToInstantiable)(constraint)
-                        : constraint;
-                    return evaluator.assignType(adjustedConstraint, concreteSrcType, 
-                    /* diag */ undefined, 
-                    /* destTypeVarContext */ undefined, 
-                    /* srcTypeVarContext */ undefined, 0 /* Default */, recursionCount);
-                });
-            }
-        }
-        // If there was no constrained type that was assignable
-        // or there were multiple types that were assignable and they
-        // are not conditional, it's an error.
-        if (!constrainedType) {
-            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeConstrainedTypeVar().format({
-                type: evaluator.printType(srcType),
-                name: destType.details.name,
-            }));
-            return false;
-        }
-        if (curNarrowTypeBound && !(0, types_1.isAnyOrUnknown)(curNarrowTypeBound)) {
-            if (!evaluator.assignType(curNarrowTypeBound, constrainedType, 
-            /* diag */ undefined, 
-            /* destTypeVarContext */ undefined, 
-            /* srcTypeVarContext */ undefined, 0 /* Default */, recursionCount)) {
-                // Handle the case where one of the constrained types is a wider
-                // version of another constrained type that was previously assigned
-                // to the type variable.
-                if (evaluator.assignType(constrainedType, curNarrowTypeBound, 
-                /* diag */ undefined, 
-                /* destTypeVarContext */ undefined, 
-                /* srcTypeVarContext */ undefined, 0 /* Default */, recursionCount)) {
-                    if (!typeVarContext.isLocked() && isTypeVarInScope) {
-                        updateTypeVarType(evaluator, typeVarContext, destType, constrainedType, curWideTypeBound);
-                    }
-                }
-                else {
-                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeConstrainedTypeVar().format({
-                        type: evaluator.printType(constrainedType),
-                        name: evaluator.printType(curNarrowTypeBound),
-                    }));
-                    return false;
-                }
-            }
-        }
-        else {
-            // Assign the type to the type var.
-            if (!typeVarContext.isLocked() && isTypeVarInScope) {
-                updateTypeVarType(evaluator, typeVarContext, destType, constrainedType, curWideTypeBound);
-            }
-        }
-        return true;
+        return assignTypeToConstrainedTypeVar(evaluator, destType, srcType, diag, typeVarContext, flags, isTypeVarInScope, recursionCount);
     }
     // Handle the unconstrained (but possibly bound) case.
+    const curEntry = typeVarContext.getPrimarySignature().getTypeVar(destType);
+    let curWideTypeBound = curEntry === null || curEntry === void 0 ? void 0 : curEntry.wideBound;
+    if (!curWideTypeBound && !destType.details.isSynthesizedSelf) {
+        curWideTypeBound = destType.details.boundType;
+    }
+    const curNarrowTypeBound = curEntry === null || curEntry === void 0 ? void 0 : curEntry.narrowBound;
     let newNarrowTypeBound = curNarrowTypeBound;
     let newWideTypeBound = curWideTypeBound;
     const diagAddendum = diag ? new diagnostic_1.DiagnosticAddendum() : undefined;
@@ -284,7 +175,7 @@ function assignTypeToTypeVar(evaluator, destType, srcType, diag, typeVarContext,
         // narrow type bound, wide type bound or both. Don't overwrite
         // an existing entry.
         if (!curEntry) {
-            if ((flags & 1 /* EnforceInvariance */) !== 0) {
+            if (isInvariant) {
                 newNarrowTypeBound = adjSrcType;
                 newWideTypeBound = adjSrcType;
             }
@@ -298,7 +189,7 @@ function assignTypeToTypeVar(evaluator, destType, srcType, diag, typeVarContext,
     }
     else if (isContravariant) {
         // Update the wide type bound.
-        if (!curWideTypeBound) {
+        if (!curWideTypeBound || (0, types_1.isTypeSame)(destType, curWideTypeBound)) {
             newWideTypeBound = adjSrcType;
         }
         else if (!(0, types_1.isTypeSame)(curWideTypeBound, adjSrcType, {}, recursionCount)) {
@@ -336,7 +227,7 @@ function assignTypeToTypeVar(evaluator, destType, srcType, diag, typeVarContext,
         }
     }
     else {
-        if (!curNarrowTypeBound) {
+        if (!curNarrowTypeBound || (0, types_1.isTypeSame)(destType, curNarrowTypeBound)) {
             // There was previously no narrow bound. We've now established one.
             newNarrowTypeBound = adjSrcType;
         }
@@ -462,6 +353,12 @@ function assignTypeToTypeVar(evaluator, destType, srcType, diag, typeVarContext,
     if (!typeVarContext.isLocked() && isTypeVarInScope) {
         updateTypeVarType(evaluator, typeVarContext, destType, newNarrowTypeBound, newWideTypeBound, (flags & (1024 /* PopulatingExpectedType */ | 128 /* RetainLiteralsForTypeVar */)) !== 0);
     }
+    if (logTypeVarContextUpdates) {
+        const indent = ' '.repeat(recursionCount * 2);
+        console.log(`${indent}`);
+        console.log(`${indent}post-call context #${typeVarContext.getId()}: `);
+        logTypeVarContext(evaluator, typeVarContext, indent);
+    }
     return true;
 }
 exports.assignTypeToTypeVar = assignTypeToTypeVar;
@@ -487,6 +384,136 @@ function updateTypeVarType(evaluator, typeVarContext, destType, narrowTypeBound,
     typeVarContext.setTypeVarType(destType, narrowTypeBound, narrowTypeBoundNoLiterals, wideTypeBound);
 }
 exports.updateTypeVarType = updateTypeVarType;
+function assignTypeToConstrainedTypeVar(evaluator, destType, srcType, diag, typeVarContext, flags, isTypeVarInScope, recursionCount) {
+    let constrainedType;
+    const concreteSrcType = evaluator.makeTopLevelTypeVarsConcrete(srcType);
+    const curEntry = typeVarContext.getPrimarySignature().getTypeVar(destType);
+    const curWideTypeBound = curEntry === null || curEntry === void 0 ? void 0 : curEntry.wideBound;
+    const curNarrowTypeBound = curEntry === null || curEntry === void 0 ? void 0 : curEntry.narrowBound;
+    if ((0, types_1.isTypeVar)(srcType)) {
+        if (evaluator.assignType(destType, concreteSrcType, 
+        /* diag */ undefined, new typeVarContext_1.TypeVarContext(destType.scopeId), 
+        /* srcTypeVarContext */ undefined, 0 /* Default */, recursionCount)) {
+            constrainedType = srcType;
+            // If the source and dest are both instantiables (type[T]), then
+            // we need to convert to an instance (T).
+            if (types_1.TypeBase.isInstantiable(srcType)) {
+                constrainedType = (0, typeUtils_1.convertToInstance)(srcType, /* includeSubclasses */ false);
+            }
+        }
+    }
+    else {
+        let isCompatible = true;
+        // Subtypes that are not conditionally dependent on the dest type var
+        // must all map to the same constraint. For example, Union[str, bytes]
+        // cannot be assigned to AnyStr.
+        let unconditionalConstraintIndex;
+        // Find the narrowest constrained type that is compatible.
+        constrainedType = (0, typeUtils_1.mapSubtypes)(concreteSrcType, (srcSubtype) => {
+            let constrainedSubtype;
+            if ((0, types_1.isAnyOrUnknown)(srcSubtype)) {
+                return srcSubtype;
+            }
+            let constraintIndexUsed;
+            destType.details.constraints.forEach((constraint, i) => {
+                const adjustedConstraint = types_1.TypeBase.isInstantiable(destType)
+                    ? (0, typeUtils_1.convertToInstantiable)(constraint)
+                    : constraint;
+                if (evaluator.assignType(adjustedConstraint, srcSubtype, 
+                /* diag */ undefined, 
+                /* destTypeVarContext */ undefined, 
+                /* srcTypeVarContext */ undefined, 0 /* Default */, recursionCount)) {
+                    if (!constrainedSubtype ||
+                        evaluator.assignType(types_1.TypeBase.isInstantiable(destType)
+                            ? (0, typeUtils_1.convertToInstantiable)(constrainedSubtype)
+                            : constrainedSubtype, adjustedConstraint, 
+                        /* diag */ undefined, 
+                        /* destTypeVarContext */ undefined, 
+                        /* srcTypeVarContext */ undefined, 0 /* Default */, recursionCount)) {
+                        constrainedSubtype = (0, typeUtils_1.addConditionToType)(constraint, (0, typeUtils_1.getTypeCondition)(srcSubtype));
+                        constraintIndexUsed = i;
+                    }
+                }
+            });
+            if (!constrainedSubtype) {
+                // We found a source subtype that is not compatible with the dest.
+                // This is OK if we're handling the contravariant case because only
+                // one subtype needs to be assignable in that case.
+                if ((flags & 2 /* ReverseTypeVarMatching */) === 0) {
+                    isCompatible = false;
+                }
+            }
+            // If this subtype isn't conditional, make sure it maps to the same
+            // constraint index as previous unconditional subtypes.
+            if (constraintIndexUsed !== undefined && !(0, typeUtils_1.getTypeCondition)(srcSubtype)) {
+                if (unconditionalConstraintIndex !== undefined &&
+                    unconditionalConstraintIndex !== constraintIndexUsed) {
+                    isCompatible = false;
+                }
+                unconditionalConstraintIndex = constraintIndexUsed;
+            }
+            return constrainedSubtype;
+        });
+        if ((0, types_1.isNever)(constrainedType) || !isCompatible) {
+            constrainedType = undefined;
+        }
+        // If the type is a union, see if the entire union is assignable to one
+        // of the constraints.
+        if (!constrainedType && (0, types_1.isUnion)(concreteSrcType)) {
+            constrainedType = destType.details.constraints.find((constraint) => {
+                const adjustedConstraint = types_1.TypeBase.isInstantiable(destType)
+                    ? (0, typeUtils_1.convertToInstantiable)(constraint)
+                    : constraint;
+                return evaluator.assignType(adjustedConstraint, concreteSrcType, 
+                /* diag */ undefined, 
+                /* destTypeVarContext */ undefined, 
+                /* srcTypeVarContext */ undefined, 0 /* Default */, recursionCount);
+            });
+        }
+    }
+    // If there was no constrained type that was assignable
+    // or there were multiple types that were assignable and they
+    // are not conditional, it's an error.
+    if (!constrainedType) {
+        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeConstrainedTypeVar().format({
+            type: evaluator.printType(srcType),
+            name: destType.details.name,
+        }));
+        return false;
+    }
+    if (curNarrowTypeBound && !(0, types_1.isAnyOrUnknown)(curNarrowTypeBound)) {
+        if (!evaluator.assignType(curNarrowTypeBound, constrainedType, 
+        /* diag */ undefined, 
+        /* destTypeVarContext */ undefined, 
+        /* srcTypeVarContext */ undefined, 0 /* Default */, recursionCount)) {
+            // Handle the case where one of the constrained types is a wider
+            // version of another constrained type that was previously assigned
+            // to the type variable.
+            if (evaluator.assignType(constrainedType, curNarrowTypeBound, 
+            /* diag */ undefined, 
+            /* destTypeVarContext */ undefined, 
+            /* srcTypeVarContext */ undefined, 0 /* Default */, recursionCount)) {
+                if (!typeVarContext.isLocked() && isTypeVarInScope) {
+                    updateTypeVarType(evaluator, typeVarContext, destType, constrainedType, curWideTypeBound);
+                }
+            }
+            else {
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeConstrainedTypeVar().format({
+                    type: evaluator.printType(constrainedType),
+                    name: evaluator.printType(curNarrowTypeBound),
+                }));
+                return false;
+            }
+        }
+    }
+    else {
+        // Assign the type to the type var.
+        if (!typeVarContext.isLocked() && isTypeVarInScope) {
+            updateTypeVarType(evaluator, typeVarContext, destType, constrainedType, curWideTypeBound);
+        }
+    }
+    return true;
+}
 function assignTypeToParamSpec(evaluator, destType, srcType, diag, typeVarContext, recursionCount = 0) {
     let isAssignable = true;
     typeVarContext.doForEachSignature((signatureContext) => {
@@ -503,7 +530,7 @@ function assignTypeToParamSpec(evaluator, destType, srcType, diag, typeVarContex
             }
             else {
                 if (!typeVarContext.isLocked() && typeVarContext.hasSolveForScope(destType.scopeId)) {
-                    typeVarContext.setTypeVarType(destType, (0, typeUtils_1.convertTypeToParamSpecValue)(srcType));
+                    signatureContext.setTypeVarType(destType, (0, typeUtils_1.convertTypeToParamSpecValue)(srcType));
                 }
                 return;
             }
@@ -517,42 +544,51 @@ function assignTypeToParamSpec(evaluator, destType, srcType, diag, typeVarContex
                     isNameSynthesized: p.isNameSynthesized,
                     hasDefault: !!p.hasDefault,
                     defaultValueExpression: p.defaultValueExpression,
+                    hasDeclaredType: p.hasDeclaredType,
                     type: types_1.FunctionType.getEffectiveParameterType(functionSrcType, index),
                 };
                 return param;
             });
+            const newFunction = types_1.FunctionType.createInstance('', '', '', srcType.details.flags | 65536 /* ParamSpecValue */);
+            parameters.forEach((param) => {
+                types_1.FunctionType.addParameter(newFunction, param);
+            });
+            newFunction.details.typeVarScopeId = srcType.details.typeVarScopeId;
+            newFunction.details.constructorTypeVarScopeId = srcType.details.constructorTypeVarScopeId;
+            newFunction.details.paramSpecTypeVarScopeId = srcType.details.paramSpecTypeVarScopeId;
+            newFunction.details.docString = srcType.details.docString;
+            newFunction.details.deprecatedMessage = srcType.details.deprecatedMessage;
+            newFunction.details.paramSpec = srcType.details.paramSpec;
+            let updateContextWithNewFunction = false;
             const existingType = signatureContext.getParamSpecType(destType);
             if (existingType) {
                 if ((0, types_1.isTypeSame)((_a = existingType.details.paramSpec) !== null && _a !== void 0 ? _a : types_1.NoneType.createInstance(), (_b = srcType.details.paramSpec) !== null && _b !== void 0 ? _b : types_1.NoneType.createInstance())) {
                     // Convert the remaining portion of the signature to a function
                     // for comparison purposes.
                     const existingFunction = (0, typeUtils_1.convertParamSpecValueToType)(existingType, /* omitParamSpec */ true);
-                    const assignedFunction = types_1.FunctionType.createInstance('', '', '', srcType.details.flags);
-                    parameters.forEach((param) => {
-                        types_1.FunctionType.addParameter(assignedFunction, param);
-                    });
-                    assignedFunction.details.typeVarScopeId = srcType.details.typeVarScopeId;
-                    if (evaluator.assignType(existingFunction, assignedFunction, 
+                    // Should we narrow the type?
+                    if (evaluator.assignType(existingFunction, newFunction, 
+                    /* diag */ undefined, 
+                    /* destTypeVarContext */ undefined, 
+                    /* srcTypeVarContext */ undefined, 32 /* SkipFunctionReturnTypeCheck */, recursionCount)) {
+                        updateContextWithNewFunction = true;
+                    }
+                    else if (evaluator.assignType(newFunction, existingFunction, 
                     /* diag */ undefined, 
                     /* destTypeVarContext */ undefined, 
                     /* srcTypeVarContext */ undefined, 32 /* SkipFunctionReturnTypeCheck */, recursionCount)) {
+                        // The existing function is already narrower than the new function, so
+                        // no need to narrow it further.
                         return;
                     }
                 }
             }
             else {
+                updateContextWithNewFunction = true;
+            }
+            if (updateContextWithNewFunction) {
                 if (!typeVarContext.isLocked() && typeVarContext.hasSolveForScope(destType.scopeId)) {
-                    const newFunction = types_1.FunctionType.createInstance('', '', '', srcType.details.flags);
-                    parameters.forEach((param) => {
-                        types_1.FunctionType.addParameter(newFunction, param);
-                    });
-                    newFunction.details.typeVarScopeId = srcType.details.typeVarScopeId;
-                    newFunction.details.constructorTypeVarScopeId = srcType.details.constructorTypeVarScopeId;
-                    newFunction.details.paramSpecTypeVarScopeId = srcType.details.paramSpecTypeVarScopeId;
-                    newFunction.details.docString = srcType.details.docString;
-                    newFunction.details.deprecatedMessage = srcType.details.deprecatedMessage;
-                    newFunction.details.paramSpec = srcType.details.paramSpec;
-                    typeVarContext.setTypeVarType(destType, newFunction);
+                    signatureContext.setTypeVarType(destType, newFunction);
                 }
                 return;
             }
@@ -566,6 +602,12 @@ function assignTypeToParamSpec(evaluator, destType, srcType, diag, typeVarContex
         }));
         isAssignable = false;
     });
+    if (logTypeVarContextUpdates) {
+        const indent = ' '.repeat(recursionCount * 2);
+        console.log(`${indent}`);
+        console.log(`${indent}post-call typeVarContext: `);
+        logTypeVarContext(evaluator, typeVarContext, indent);
+    }
     return isAssignable;
 }
 // In cases where the expected type is a specialized base class of the
@@ -628,6 +670,9 @@ function populateTypeVarContextBasedOnExpectedType(evaluator, type, expectedType
     const synthExpectedTypeArgs = types_1.ClassType.getTypeParameters(expectedType).map((typeParam, index) => {
         const typeVar = types_1.TypeVarType.createInstance(`__dest${index}`);
         typeVar.details.isSynthesized = true;
+        if (typeParam.details.isParamSpec) {
+            typeVar.details.isParamSpec = true;
+        }
         // Use invariance here so we set the narrow and wide values on the TypeVar.
         typeVar.details.declaredVariance = 2 /* Invariant */;
         typeVar.scopeId = expectedTypeScopeId;
@@ -636,11 +681,14 @@ function populateTypeVarContextBasedOnExpectedType(evaluator, type, expectedType
     const genericExpectedType = types_1.ClassType.cloneForSpecialization(expectedType, synthExpectedTypeArgs, 
     /* isTypeArgumentExplicit */ true);
     // For each type param in the target type, create a placeholder type variable.
-    const typeArgs = types_1.ClassType.getTypeParameters(type).map((_, index) => {
+    const typeArgs = types_1.ClassType.getTypeParameters(type).map((typeParam, index) => {
         const typeVar = types_1.TypeVarType.createInstance(`__source${index}`);
         typeVar.details.isSynthesized = true;
         typeVar.details.synthesizedIndex = index;
         typeVar.details.isExemptFromBoundCheck = true;
+        if (typeParam.details.isParamSpec) {
+            typeVar.details.isParamSpec = true;
+        }
         return types_1.TypeVarType.cloneAsInScopePlaceholder(typeVar);
     });
     const specializedType = types_1.ClassType.cloneForSpecialization(type, typeArgs, /* isTypeArgumentExplicit */ true);
@@ -654,21 +702,26 @@ function populateTypeVarContextBasedOnExpectedType(evaluator, type, expectedType
             const otherSubtypes = [];
             // If the resulting type is a union, try to find a matching type var and move
             // the remaining subtypes to the "otherSubtypes" array.
-            if (synthTypeVar && (0, types_1.isUnion)(synthTypeVar)) {
-                let foundSynthTypeVar;
-                synthTypeVar.subtypes.forEach((subtype) => {
-                    if ((0, types_1.isTypeVar)(subtype) &&
-                        subtype.details.isSynthesized &&
-                        subtype.details.synthesizedIndex !== undefined &&
-                        !foundSynthTypeVar) {
-                        foundSynthTypeVar = subtype;
-                    }
-                    else {
-                        otherSubtypes.push(subtype);
+            if (synthTypeVar) {
+                if (typeVar.details.isParamSpec && (0, types_1.isFunction)(synthTypeVar)) {
+                    synthTypeVar = (0, typeUtils_1.convertParamSpecValueToType)(synthTypeVar);
+                }
+                if ((0, types_1.isUnion)(synthTypeVar)) {
+                    let foundSynthTypeVar;
+                    synthTypeVar.subtypes.forEach((subtype) => {
+                        if ((0, types_1.isTypeVar)(subtype) &&
+                            subtype.details.isSynthesized &&
+                            subtype.details.synthesizedIndex !== undefined &&
+                            !foundSynthTypeVar) {
+                            foundSynthTypeVar = subtype;
+                        }
+                        else {
+                            otherSubtypes.push(subtype);
+                        }
+                    });
+                    if (foundSynthTypeVar) {
+                        synthTypeVar = foundSynthTypeVar;
                     }
-                });
-                if (foundSynthTypeVar) {
-                    synthTypeVar = foundSynthTypeVar;
                 }
             }
             // Is this one of the synthesized type vars we allocated above? If so,
@@ -762,4 +815,45 @@ function stripLiteralValueForUnpackedTuple(evaluator, type) {
     }
     return (0, typeUtils_1.specializeTupleClass)(type, tupleTypeArgs, /* isTypeArgumentExplicit */ true, /* isUnpackedTuple */ true);
 }
+// This function is used for debugging only. It dumps the current contents of
+// the TypeVarContext to the console.
+function logTypeVarContext(evaluator, typeVarContext, indent) {
+    const signatureContextCount = typeVarContext.getSignatureContexts().length;
+    if (signatureContextCount === 0) {
+        console.log(`${indent}  no signatures`);
+    }
+    else if (signatureContextCount === 1) {
+        logTypeVarSignatureContext(evaluator, typeVarContext.getSignatureContexts()[0], `${indent}  `);
+    }
+    else {
+        typeVarContext.doForEachSignatureContext((context, signatureIndex) => {
+            console.log(`${indent}  signature ${signatureIndex}`);
+            logTypeVarSignatureContext(evaluator, context, `${indent}    `);
+        });
+    }
+}
+function logTypeVarSignatureContext(evaluator, context, indent) {
+    let loggedConstraint = false;
+    context.getTypeVars().forEach((entry) => {
+        const typeVarName = `${indent}${entry.typeVar.details.name}`;
+        // Log the narrow and wide bounds.
+        if (entry.narrowBound && entry.wideBound && (0, types_1.isTypeSame)(entry.narrowBound, entry.wideBound)) {
+            console.log(`${typeVarName} = ${evaluator.printType(entry.narrowBound)}`);
+            loggedConstraint = true;
+        }
+        else {
+            if (entry.narrowBound) {
+                console.log(`${typeVarName} ≤ ${evaluator.printType(entry.narrowBound)}`);
+                loggedConstraint = true;
+            }
+            if (entry.wideBound) {
+                console.log(`${typeVarName} ≥ ${evaluator.printType(entry.wideBound)}`);
+                loggedConstraint = true;
+            }
+        }
+    });
+    if (!loggedConstraint) {
+        console.log(`${indent}no constraints`);
+    }
+}
 //# sourceMappingURL=constraintSolver.js.map