@zzzen/pyright-internal 1.2.0-dev.20230423 → 1.2.0-dev.20230507

package/dist/analyzer/typeEvaluator.js

@@ -51,12 +51,13 @@ const AnalyzerNodeInfo = __importStar(require("./analyzerNodeInfo"));
 const codeFlowEngine_1 = require("./codeFlowEngine");
 const codeFlowTypes_1 = require("./codeFlowTypes");
 const constraintSolver_1 = require("./constraintSolver");
-const constructorTransform_1 = require("./constructorTransform");
+const constructors_1 = require("./constructors");
 const dataClasses_1 = require("./dataClasses");
 const declarationUtils_1 = require("./declarationUtils");
 const enums_1 = require("./enums");
 const functionTransform_1 = require("./functionTransform");
 const namedTuples_1 = require("./namedTuples");
+const operations_1 = require("./operations");
 const parameterUtils_1 = require("./parameterUtils");
 const ParseTreeUtils = __importStar(require("./parseTreeUtils"));
 const patternMatching_1 = require("./patternMatching");
@@ -68,75 +69,12 @@ const symbol_1 = require("./symbol");
 const symbolNameUtils_1 = require("./symbolNameUtils");
 const symbolUtils_1 = require("./symbolUtils");
 const typeCacheUtils_1 = require("./typeCacheUtils");
-const typedDicts_1 = require("./typedDicts");
 const typeEvaluatorTypes_1 = require("./typeEvaluatorTypes");
 const TypePrinter = __importStar(require("./typePrinter"));
-const types_1 = require("./types");
 const typeUtils_1 = require("./typeUtils");
 const typeVarContext_1 = require("./typeVarContext");
-var MemberAccessFlags;
-(function (MemberAccessFlags) {
-    MemberAccessFlags[MemberAccessFlags["None"] = 0] = "None";
-    // By default, member accesses are assumed to access the attributes
-    // of a class instance. By setting this flag, only attributes of
-    // the class are considered.
-    MemberAccessFlags[MemberAccessFlags["AccessClassMembersOnly"] = 1] = "AccessClassMembersOnly";
-    // By default, members of base classes are also searched.
-    // Set this flag to consider only the specified class' members.
-    MemberAccessFlags[MemberAccessFlags["SkipBaseClasses"] = 2] = "SkipBaseClasses";
-    // Do not include the "object" base class in the search.
-    MemberAccessFlags[MemberAccessFlags["SkipObjectBaseClass"] = 4] = "SkipObjectBaseClass";
-    // Consider writes to symbols flagged as ClassVars as an error.
-    MemberAccessFlags[MemberAccessFlags["DisallowClassVarWrites"] = 8] = "DisallowClassVarWrites";
-    // Normally __new__ is treated as a static method, but when
-    // it is invoked implicitly through a constructor call, it
-    // acts like a class method instead.
-    MemberAccessFlags[MemberAccessFlags["TreatConstructorAsClassMethod"] = 16] = "TreatConstructorAsClassMethod";
-    // By default, class member lookups start with the class itself
-    // and fall back on the metaclass if it's not found. This option
-    // skips the first check.
-    MemberAccessFlags[MemberAccessFlags["ConsiderMetaclassOnly"] = 32] = "ConsiderMetaclassOnly";
-    // If an attribute cannot be found when looking for instance
-    // members, normally an attribute access override method
-    // (__getattr__, etc.) may provide the missing attribute type.
-    // This disables this check.
-    MemberAccessFlags[MemberAccessFlags["SkipAttributeAccessOverride"] = 64] = "SkipAttributeAccessOverride";
-    // Do not include the class itself, only base classes.
-    MemberAccessFlags[MemberAccessFlags["SkipOriginalClass"] = 128] = "SkipOriginalClass";
-    // Do not include the "type" base class in the search.
-    MemberAccessFlags[MemberAccessFlags["SkipTypeBaseClass"] = 256] = "SkipTypeBaseClass";
-})(MemberAccessFlags || (MemberAccessFlags = {}));
-// Maps binary operators to the magic methods that implement them.
-const binaryOperatorMap = {
-    [0 /* Add */]: ['__add__', '__radd__'],
-    [33 /* Subtract */]: ['__sub__', '__rsub__'],
-    [26 /* Multiply */]: ['__mul__', '__rmul__'],
-    [13 /* FloorDivide */]: ['__floordiv__', '__rfloordiv__'],
-    [10 /* Divide */]: ['__truediv__', '__rtruediv__'],
-    [24 /* Mod */]: ['__mod__', '__rmod__'],
-    [29 /* Power */]: ['__pow__', '__rpow__'],
-    [22 /* MatrixMultiply */]: ['__matmul__', '__rmatmul__'],
-    [3 /* BitwiseAnd */]: ['__and__', '__rand__'],
-    [6 /* BitwiseOr */]: ['__or__', '__ror__'],
-    [8 /* BitwiseXor */]: ['__xor__', '__rxor__'],
-    [17 /* LeftShift */]: ['__lshift__', '__rlshift__'],
-    [31 /* RightShift */]: ['__rshift__', '__rrshift__'],
-    [12 /* Equals */]: ['__eq__', '__eq__'],
-    [28 /* NotEquals */]: ['__ne__', '__ne__'],
-    [20 /* LessThan */]: ['__lt__', '__gt__'],
-    [21 /* LessThanOrEqual */]: ['__le__', '__ge__'],
-    [15 /* GreaterThan */]: ['__gt__', '__lt__'],
-    [16 /* GreaterThanOrEqual */]: ['__ge__', '__le__'],
-};
-// Map of operators that always return a bool result.
-const booleanOperatorMap = {
-    [36 /* And */]: true,
-    [37 /* Or */]: true,
-    [39 /* Is */]: true,
-    [40 /* IsNot */]: true,
-    [41 /* In */]: true,
-    [42 /* NotIn */]: true,
-};
+const typedDicts_1 = require("./typedDicts");
+const types_1 = require("./types");
 // This table contains the names of several built-in types that
 // are not subscriptable at runtime on older versions of Python.
 // It lists the first version of Python where subscripting is
@@ -221,9 +159,6 @@ const maxRecursiveTypeAliasRecursionCount = 10;
 const verifyTypeCacheEvaluatorFlags = false;
 // This debugging option prints each expression and its evaluated type.
 const printExpressionTypes = false;
-// If the number of subtypes starts to explode when applying "literal math",
-// cut off the literal union and fall back to the non-literal supertype.
-const maxLiteralMathSubtypeCount = 64;
 // The following number is chosen somewhat arbitrarily. We need to cut
 // off code flow analysis at some point for code flow graphs that are too
 // complex. Otherwise we risk overflowing the stack or incurring extremely
@@ -243,7 +178,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     let cancellationToken;
     let isBasicTypesInitialized = false;
     let noneType;
-    let unionType;
     let objectType;
     let typeClassType;
     let functionObj;
@@ -352,7 +286,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If the entry is located within a part of the parse tree that is currently being
         // "speculatively" evaluated, track it so we delete the cached entry when we leave
         // this speculative context.
-        if (speculativeTypeTracker.isSpeculative(node)) {
+        if (isSpeculativeModeInUse(node)) {
             speculativeTypeTracker.trackEntry(typeCacheToUse, node.id);
             if (allowSpeculativeCaching) {
                 speculativeTypeTracker.addSpeculativeType(node, typeResult, incompleteGenerationCount, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType);
@@ -363,7 +297,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         writeTypeCache(node, { type }, flags);
     }
     function setAsymmetricDescriptorAssignment(node) {
-        if (speculativeTypeTracker.isSpeculative(/* node */ undefined)) {
+        if (isSpeculativeModeInUse(/* node */ undefined)) {
             return;
         }
         asymmetricDescriptorAssignmentCache.add(node.id);
@@ -596,15 +530,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 break;
             }
             case 55 /* UnaryOperation */: {
-                typeResult = getTypeOfUnaryOperation(node, inferenceContext);
+                typeResult = (0, operations_1.getTypeOfUnaryOperation)(evaluatorInterface, node, inferenceContext);
                 break;
             }
             case 7 /* BinaryOperation */: {
-                typeResult = getTypeOfBinaryOperation(node, inferenceContext, flags);
+                typeResult = (0, operations_1.getTypeOfBinaryOperation)(evaluatorInterface, node, inferenceContext, flags);
                 break;
             }
             case 5 /* AugmentedAssignment */: {
-                typeResult = getTypeOfAugmentedAssignment(node, inferenceContext);
+                typeResult = (0, operations_1.getTypeOfAugmentedAssignment)(evaluatorInterface, node, inferenceContext);
                 break;
             }
             case 31 /* List */:
@@ -621,7 +555,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 break;
             }
             case 51 /* Ternary */: {
-                typeResult = getTypeOfTernary(node, flags, inferenceContext);
+                typeResult = (0, operations_1.getTypeOfTernaryOperation)(evaluatorInterface, node, flags, inferenceContext);
                 break;
             }
             case 32 /* ListComprehension */: {
@@ -1996,7 +1930,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function isDiagnosticSuppressedForNode(node) {
         return (suppressedNodeStack.some((suppressedNode) => ParseTreeUtils.isNodeContainedWithin(node, suppressedNode)) ||
-            speculativeTypeTracker.isSpeculative(node));
+            isSpeculativeModeInUse(node));
     }
     function addDiagnostic(diagLevel, rule, message, node, range) {
         if (diagLevel === 'none') {
@@ -2658,7 +2592,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             else {
                                 let callResult;
                                 suppressDiagnostics(node.typeExpression, () => {
-                                    callResult = validateConstructorArguments(node.typeExpression, [], concreteSubtype, 
+                                    callResult = (0, constructors_1.validateConstructorArguments)(evaluatorInterface, node.typeExpression, [], concreteSubtype, 
                                     /* skipUnknownArgCheck */ false, 
                                     /* inferenceContext */ undefined);
                                 });
@@ -2736,7 +2670,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
     }
     function setSymbolAccessed(fileInfo, symbol, node) {
-        if (!speculativeTypeTracker.isSpeculative(node)) {
+        if (!isSpeculativeModeInUse(node)) {
             fileInfo.accessedSymbolSet.add(symbol.id);
         }
     }
@@ -3095,7 +3029,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                     container: enclosingScope.name.value,
                                 }), node);
                             }
-                            type = types_1.TypeVarType.cloneForScopeId(type, getScopeIdForNode(enclosingScope), enclosingScope.name.value, enclosingScope.nodeType === 28 /* Function */
+                            type = types_1.TypeVarType.cloneForScopeId(type, ParseTreeUtils.getScopeIdForNode(enclosingScope), enclosingScope.name.value, enclosingScope.nodeType === 28 /* Function */
                                 ? 1 /* Function */
                                 : 0 /* Class */);
                         }
@@ -3186,35 +3120,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return type;
     }
-    // Creates an ID that identifies this parse node in a way that will
-    // not change each time the file is parsed (unless, of course, the
-    // file contents change).
-    function getScopeIdForNode(node) {
-        let name = '';
-        if (node.nodeType === 10 /* Class */) {
-            name = node.name.value;
-        }
-        else if (node.nodeType === 28 /* Function */) {
-            name = node.name.value;
-        }
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-        return `${fileInfo.filePath}.${node.start.toString()}-${name}`;
-    }
-    // Walks up the parse tree and finds all scopes that can provide
-    // a context for a TypeVar and returns the scope ID for each.
-    function getTypeVarScopesForNode(node) {
-        const scopeIds = [];
-        let curNode = node;
-        while (curNode) {
-            curNode = ParseTreeUtils.getTypeVarScopeNode(curNode);
-            if (!curNode) {
-                break;
-            }
-            scopeIds.push(getScopeIdForNode(curNode));
-            curNode = curNode.parent;
-        }
-        return scopeIds;
-    }
     // Walks up the parse tree to find a function, class, or type alias
     // declaration that provides the context for a type variable.
     function findScopedTypeVar(node, type) {
@@ -5205,7 +5110,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         else {
             const tupleTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(tupleClassType));
-            if (!(0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, types_1.ClassType.cloneAsInstance(tupleClassType), inferenceContext.expectedType, tupleTypeVarContext, getTypeVarScopesForNode(node))) {
+            if (!(0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, types_1.ClassType.cloneAsInstance(tupleClassType), inferenceContext.expectedType, tupleTypeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node))) {
                 return undefined;
             }
             const specializedTuple = (0, typeUtils_1.applySolvedTypeVars)(tupleClassType, tupleTypeVarContext);
@@ -5364,7 +5269,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // Don't bother evaluating the arguments if we're speculatively evaluating the call
         // or the base type is incomplete.
-        if (!speculativeTypeTracker.isSpeculative(node) && !baseTypeResult.isIncomplete) {
+        if (!isSpeculativeModeInUse(node) && !baseTypeResult.isIncomplete) {
             // Touch all of the args so they're marked accessed even if there were errors.
             // We skip this if it's a TypeVar() call in the typing.pyi module because
             // this results in a cyclical type resolution problem whereby we try to
@@ -5432,7 +5337,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If one or more of the arguments are incomplete, use speculative mode
         // for the lambda evaluation because it may need to be reevaluated once
         // the arg types are complete.
-        let typeResult = isArgTypeIncomplete || speculativeTypeTracker.isSpeculative(node) || (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete)
+        let typeResult = isArgTypeIncomplete || isSpeculativeModeInUse(node) || (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete)
             ? useSpeculativeMode(node.leftExpression, getLambdaType)
             : getLambdaType();
         // If bidirectional type inference failed, use normal type inference instead.
@@ -5740,15 +5645,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     ? matchedOverloads[matchedOverloads.length - 1].typeVarContext.clone()
                     : typeVarContext;
                 const effectiveTypeVarContext = (_a = typeVarContextToClone === null || typeVarContextToClone === void 0 ? void 0 : typeVarContextToClone.clone()) !== null && _a !== void 0 ? _a : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overload));
-                effectiveTypeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(overload));
-                if (overload.details.constructorTypeVarScopeId) {
-                    effectiveTypeVarContext.addSolveForScope(overload.details.constructorTypeVarScopeId);
-                }
+                effectiveTypeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeIds)(overload));
                 effectiveTypeVarContext.unlock();
                 // Use speculative mode so we don't output any diagnostics or
                 // record any final types in the type cache.
                 const callResult = useSpeculativeMode(errorNode, () => {
-                    return validateFunctionArgumentTypesWithExpectedType(errorNode, matchResults, effectiveTypeVarContext, 
+                    return validateFunctionArgumentTypesWithContext(errorNode, matchResults, effectiveTypeVarContext, 
                     /* skipUnknownArgCheck */ true, inferenceContext);
                 });
                 if (callResult.isTypeIncomplete) {
@@ -5793,15 +5695,26 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 else {
                     // Eliminate any return types that are subsumed by other return types.
                     let dedupedMatchResults = [];
+                    let dedupedResultsIncludeAny = false;
                     possibleMatchResults.forEach((result) => {
                         let isSubtypeSubsumed = false;
                         for (let dedupedIndex = 0; dedupedIndex < dedupedMatchResults.length; dedupedIndex++) {
                             if (assignType(dedupedMatchResults[dedupedIndex], result.returnType)) {
-                                isSubtypeSubsumed = true;
+                                if (!(0, typeUtils_1.containsAnyOrUnknown)(dedupedMatchResults[dedupedIndex])) {
+                                    isSubtypeSubsumed = true;
+                                }
+                                else if (!(0, typeUtils_1.containsUnknown)(dedupedMatchResults[dedupedIndex])) {
+                                    dedupedResultsIncludeAny = true;
+                                }
                                 break;
                             }
                             else if (assignType(result.returnType, dedupedMatchResults[dedupedIndex])) {
-                                dedupedMatchResults[dedupedIndex] = types_1.NeverType.createNever();
+                                if (!(0, typeUtils_1.containsAnyOrUnknown)(result.returnType)) {
+                                    dedupedMatchResults[dedupedIndex] = types_1.NeverType.createNever();
+                                }
+                                else if (!(0, typeUtils_1.containsUnknown)(dedupedMatchResults[dedupedIndex])) {
+                                    dedupedResultsIncludeAny = true;
+                                }
                                 break;
                             }
                         }
@@ -5811,9 +5724,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     });
                     dedupedMatchResults = dedupedMatchResults.filter((t) => !(0, types_1.isNever)(t));
                     const combinedTypes = (0, types_1.combineTypes)(dedupedMatchResults);
-                    returnTypes.push(dedupedMatchResults.length > 1
-                        ? types_1.UnknownType.createPossibleType(combinedTypes, possibleMatchInvolvesIncompleteUnknown)
-                        : combinedTypes);
+                    let effectiveReturnType = combinedTypes;
+                    if (dedupedMatchResults.length > 1) {
+                        // If one or more of the deduped types is Any or contains Any,
+                        // we will assume that the person who defined the overload really
+                        // wanted Any rather than Unknown. In cases where the deduped types
+                        // simply contains conflicting results without an Any, we'll use
+                        // an UnknownType.
+                        if (dedupedResultsIncludeAny) {
+                            effectiveReturnType = types_1.AnyType.create();
+                        }
+                        else {
+                            effectiveReturnType = types_1.UnknownType.createPossibleType(combinedTypes, possibleMatchInvolvesIncompleteUnknown);
+                        }
+                    }
+                    returnTypes.push(effectiveReturnType);
                 }
             }
             if (!matchedOverload) {
@@ -5832,7 +5757,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const finalTypeVarContext = typeVarContext !== null && typeVarContext !== void 0 ? typeVarContext : matchedOverloads[0].typeVarContext;
         finalTypeVarContext.unlock();
         finalTypeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(matchedOverloads[0].overload));
-        const finalCallResult = validateFunctionArgumentTypesWithExpectedType(errorNode, matchedOverloads[0].matchResults, finalTypeVarContext, skipUnknownArgCheck, inferenceContext);
+        const finalCallResult = validateFunctionArgumentTypesWithContext(errorNode, matchedOverloads[0].matchResults, finalTypeVarContext, skipUnknownArgCheck, inferenceContext);
         if (finalCallResult.isTypeIncomplete) {
             isTypeIncomplete = true;
         }
@@ -5955,12 +5880,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return current.overloadIndex > previous.overloadIndex ? current : previous;
             });
             const effectiveTypeVarContext = typeVarContext !== null && typeVarContext !== void 0 ? typeVarContext : new typeVarContext_1.TypeVarContext();
-            effectiveTypeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(lastMatch.overload));
-            if (lastMatch.overload.details.constructorTypeVarScopeId) {
-                effectiveTypeVarContext.addSolveForScope(lastMatch.overload.details.constructorTypeVarScopeId);
-            }
+            effectiveTypeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeIds)(lastMatch.overload));
             effectiveTypeVarContext.unlock();
-            return validateFunctionArgumentTypesWithExpectedType(errorNode, lastMatch, effectiveTypeVarContext, skipUnknownArgCheck, inferenceContext);
+            return validateFunctionArgumentTypesWithContext(errorNode, lastMatch, effectiveTypeVarContext, skipUnknownArgCheck, inferenceContext);
         };
         // If there is only one possible arg/param match among the overloads,
         // use the normal type matching mechanism because it is faster and
@@ -6063,325 +5985,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         });
         return newExpandedArgTypes;
     }
-    // Tries to match the arguments of a call to the constructor for a class.
-    // If successful, it returns the resulting (specialized) object type that
-    // is allocated by the constructor. If unsuccessful, it records diagnostic
-    // information and returns undefined.
-    function validateConstructorArguments(errorNode, argList, type, skipUnknownArgCheck, inferenceContext) {
-        var _a;
-        let validatedTypes = false;
-        let returnType;
-        let reportedErrors = false;
-        let isTypeIncomplete = false;
-        let usedMetaclassCallMethod = false;
-        const overloadsUsedForCall = [];
-        // Create a helper function that determines whether we should skip argument
-        // validation for either __init__ or __new__. This is required for certain
-        // synthesized constructor types, namely NamedTuples.
-        const skipConstructorCheck = (type) => {
-            return (0, types_1.isFunction)(type) && types_1.FunctionType.isSkipConstructorCheck(type);
-        };
-        // Validate __init__
-        // We validate __init__ before __new__ because the former typically has
-        // more specific type annotations, and we want to evaluate the arguments
-        // in the context of these types. The __new__ method often uses generic
-        // vargs and kwargs.
-        const initMethodType = (_a = getTypeOfObjectMember(errorNode, types_1.ClassType.cloneAsInstance(type), '__init__', { method: 'get' }, 
-        /* diag */ undefined, 4 /* SkipObjectBaseClass */ | 64 /* SkipAttributeAccessOverride */)) === null || _a === void 0 ? void 0 : _a.type;
-        if (initMethodType && !skipConstructorCheck(initMethodType)) {
-            // If there is an expected type, analyze the constructor call
-            // for each of the subtypes that comprise the expected type. If
-            // one or more analyzes with no errors, use those results.
-            if (inferenceContext) {
-                const expectedCallResult = validateConstructorMethodWithExpectedType(errorNode, argList, type, skipUnknownArgCheck, inferenceContext, initMethodType);
-                if (expectedCallResult && !expectedCallResult.argumentErrors) {
-                    returnType = expectedCallResult.returnType;
-                    if (expectedCallResult.isTypeIncomplete) {
-                        isTypeIncomplete = true;
-                    }
-                }
-            }
-            if (!returnType) {
-                const typeVarContext = type.typeArguments
-                    ? (0, typeUtils_1.buildTypeVarContextFromSpecializedClass)(type, /* makeConcrete */ false)
-                    : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(type));
-                typeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(initMethodType));
-                const callResult = validateCallArguments(errorNode, argList, { type: initMethodType }, typeVarContext, skipUnknownArgCheck);
-                if (!callResult.argumentErrors) {
-                    let adjustedClassType = type;
-                    if (callResult.specializedInitSelfType &&
-                        (0, types_1.isClassInstance)(callResult.specializedInitSelfType) &&
-                        types_1.ClassType.isSameGenericClass(callResult.specializedInitSelfType, type)) {
-                        adjustedClassType = types_1.ClassType.cloneAsInstantiable(callResult.specializedInitSelfType);
-                    }
-                    returnType = applyExpectedTypeForConstructor(adjustedClassType, 
-                    /* inferenceContext */ undefined, typeVarContext);
-                    if (callResult.isTypeIncomplete) {
-                        isTypeIncomplete = true;
-                    }
-                    overloadsUsedForCall.push(...callResult.overloadsUsedForCall);
-                }
-                else {
-                    reportedErrors = true;
-                }
-            }
-            validatedTypes = true;
-            skipUnknownArgCheck = true;
-        }
-        // Validate __new__
-        // Don't report errors for __new__ if __init__ already generated errors. They're
-        // probably going to be entirely redundant anyway.
-        if (!reportedErrors) {
-            const metaclass = type.details.effectiveMetaclass;
-            let constructorMethodInfo;
-            // See if there's a custom `__call__` method on the metaclass. If so, we'll
-            // use that rather than the `__new__` method on the class.
-            if (metaclass && (0, types_1.isInstantiableClass)(metaclass) && !types_1.ClassType.isSameGenericClass(metaclass, type)) {
-                constructorMethodInfo = getTypeOfClassMemberName(errorNode, metaclass, 
-                /* isAccessedThroughObject */ true, '__call__', { method: 'get' }, 
-                /* diag */ undefined, 32 /* ConsiderMetaclassOnly */ |
-                    256 /* SkipTypeBaseClass */ |
-                    64 /* SkipAttributeAccessOverride */, type);
-                if (constructorMethodInfo) {
-                    usedMetaclassCallMethod = true;
-                }
-            }
-            if (!constructorMethodInfo) {
-                constructorMethodInfo = getTypeOfClassMemberName(errorNode, type, 
-                /* isAccessedThroughObject */ false, '__new__', { method: 'get' }, 
-                /* diag */ undefined, 1 /* AccessClassMembersOnly */ |
-                    4 /* SkipObjectBaseClass */ |
-                    16 /* TreatConstructorAsClassMethod */, type);
-            }
-            if (constructorMethodInfo && !skipConstructorCheck(constructorMethodInfo.type)) {
-                const constructorMethodType = constructorMethodInfo.type;
-                let newReturnType;
-                // If there is an expected type that was not applied above when
-                // handling the __init__ method, try to apply it with the __new__ method.
-                if (inferenceContext && !returnType) {
-                    const expectedCallResult = validateConstructorMethodWithExpectedType(errorNode, argList, type, skipUnknownArgCheck, inferenceContext, constructorMethodType);
-                    if (expectedCallResult && !expectedCallResult.argumentErrors) {
-                        newReturnType = expectedCallResult.returnType;
-                        returnType = newReturnType;
-                        if (expectedCallResult.isTypeIncomplete) {
-                            isTypeIncomplete = true;
-                        }
-                    }
-                }
-                const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(type));
-                if (type.typeAliasInfo) {
-                    typeVarContext.addSolveForScope(type.typeAliasInfo.typeVarScopeId);
-                }
-                typeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(constructorMethodType));
-                // Skip the unknown argument check if we've already checked for __init__.
-                let callResult;
-                if ((0, constructorTransform_1.hasConstructorTransform)(type)) {
-                    // Use speculative mode if we're going to later apply
-                    // a constructor transform. This allows us to use bidirectional
-                    // type inference for arguments in the transform.
-                    callResult = useSpeculativeMode(errorNode, () => {
-                        return validateCallArguments(errorNode, argList, constructorMethodInfo, typeVarContext, skipUnknownArgCheck);
-                    });
-                }
-                else {
-                    callResult = validateCallArguments(errorNode, argList, constructorMethodInfo, typeVarContext, skipUnknownArgCheck);
-                }
-                if (callResult.isTypeIncomplete) {
-                    isTypeIncomplete = true;
-                }
-                if (callResult.argumentErrors) {
-                    reportedErrors = true;
-                }
-                else if (!newReturnType) {
-                    newReturnType = callResult.returnType;
-                    if (overloadsUsedForCall.length === 0) {
-                        overloadsUsedForCall.push(...callResult.overloadsUsedForCall);
-                    }
-                    // If the constructor returned an object whose type matches the class of
-                    // the original type being constructed, use the return type in case it was
-                    // specialized. If it doesn't match, we'll fall back on the assumption that
-                    // the constructed type is an instance of the class type. We need to do this
-                    // in cases where we're inferring the return type based on a call to
-                    // super().__new__().
-                    if (newReturnType) {
-                        if ((0, types_1.isClassInstance)(newReturnType) && types_1.ClassType.isSameGenericClass(newReturnType, type)) {
-                            // If the specialized return type derived from the __init__
-                            // method is "better" than the return type provided by the
-                            // __new__ method (where "better" means that the type arguments
-                            // are all known), stick with the __init__ result.
-                            if ((!(0, typeUtils_1.isPartlyUnknown)(newReturnType) && !(0, typeUtils_1.requiresSpecialization)(newReturnType)) ||
-                                returnType === undefined) {
-                                // Special-case the 'tuple' type specialization to use
-                                // the homogenous arbitrary-length form.
-                                if ((0, types_1.isClassInstance)(newReturnType) &&
-                                    types_1.ClassType.isTupleClass(newReturnType) &&
-                                    !newReturnType.tupleTypeArguments &&
-                                    newReturnType.typeArguments &&
-                                    newReturnType.typeArguments.length === 1) {
-                                    newReturnType = (0, typeUtils_1.specializeTupleClass)(newReturnType, [
-                                        { type: newReturnType.typeArguments[0], isUnbounded: true },
-                                    ]);
-                                }
-                                returnType = newReturnType;
-                            }
-                        }
-                        else if (!returnType && !(0, types_1.isUnknown)(newReturnType)) {
-                            returnType = newReturnType;
-                        }
-                    }
-                }
-                if (!returnType) {
-                    returnType = applyExpectedTypeForConstructor(type, inferenceContext, typeVarContext);
-                }
-                else if ((0, types_1.isClassInstance)(returnType) && (0, typeUtils_1.isTupleClass)(returnType) && !returnType.tupleTypeArguments) {
-                    returnType = applyExpectedTypeForTupleConstructor(returnType, inferenceContext);
-                }
-                validatedTypes = true;
-            }
-        }
-        // If we weren't able to validate the args, analyze the expressions
-        // here to mark symbols as referenced and report expression-level errors.
-        if (!validatedTypes) {
-            argList.forEach((arg) => {
-                if (arg.valueExpression && !speculativeTypeTracker.isSpeculative(arg.valueExpression)) {
-                    getTypeOfExpression(arg.valueExpression);
-                }
-            });
-        }
-        if (!validatedTypes && argList.some((arg) => arg.argumentCategory === 0 /* Simple */)) {
-            // Suppress this error if the class was instantiated from a custom
-            // metaclass because it's likely that it's a false positive. Also
-            // suppress the error if the class's metaclass has a __call__ method.
-            const isCustomMetaclass = !!type.details.effectiveMetaclass &&
-                (0, types_1.isInstantiableClass)(type.details.effectiveMetaclass) &&
-                !types_1.ClassType.isBuiltIn(type.details.effectiveMetaclass);
-            if (!isCustomMetaclass && !usedMetaclassCallMethod) {
-                const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
-                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.constructorNoArgs().format({ type: type.aliasName || type.details.name }), errorNode);
-            }
-        }
-        if (!returnType) {
-            // There was no __init__ or __new__ method or we couldn't match the provided
-            // arguments to them.
-            if (!inferenceContext && type.typeArguments) {
-                // If there was no expected type but the type was already specialized,
-                // assume that we're constructing an instance of the specialized type.
-                returnType = (0, typeUtils_1.convertToInstance)(type);
-            }
-            else {
-                // Do our best to specialize the instantiated class based on the expected
-                // type if provided.
-                const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(type));
-                if (inferenceContext) {
-                    (0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, types_1.ClassType.cloneAsInstance(type), inferenceContext.expectedType, typeVarContext, getTypeVarScopesForNode(errorNode));
-                }
-                returnType = applyExpectedTypeForConstructor(type, inferenceContext, typeVarContext);
-            }
-        }
-        if (!reportedErrors) {
-            const transformed = (0, constructorTransform_1.applyConstructorTransform)(evaluatorInterface, errorNode, argList, type, {
-                argumentErrors: reportedErrors,
-                returnType,
-                isTypeIncomplete,
-            });
-            returnType = transformed.returnType;
-            if (transformed.isTypeIncomplete) {
-                isTypeIncomplete = true;
-            }
-            if (transformed.argumentErrors) {
-                reportedErrors = true;
-            }
-        }
-        const result = {
-            argumentErrors: reportedErrors,
-            returnType,
-            isTypeIncomplete,
-            overloadsUsedForCall,
-        };
-        return result;
-    }
-    // For a constructor call that targets a generic class and an "expected type"
-    // (i.e. bidirectional inference), this function attempts to infer the correct
-    // specialized return type for the constructor.
-    function validateConstructorMethodWithExpectedType(errorNode, argList, type, skipUnknownArgCheck, inferenceContext, constructorMethodType) {
-        let isTypeIncomplete = false;
-        let argumentErrors = false;
-        const overloadsUsedForCall = [];
-        const returnType = (0, typeUtils_1.mapSubtypes)(inferenceContext.expectedType, (expectedSubType) => {
-            expectedSubType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(expectedSubType);
-            const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(type));
-            if ((0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, types_1.ClassType.cloneAsInstance(type), expectedSubType, typeVarContext, getTypeVarScopesForNode(errorNode))) {
-                let callResult;
-                useSpeculativeMode(errorNode, () => {
-                    callResult = validateCallArguments(errorNode, argList, { type: constructorMethodType }, typeVarContext.clone(), skipUnknownArgCheck);
-                });
-                if (!callResult.argumentErrors) {
-                    // Call validateCallArguments again, this time without speculative
-                    // mode, so any errors are reported.
-                    callResult = validateCallArguments(errorNode, argList, { type: constructorMethodType }, typeVarContext, skipUnknownArgCheck);
-                    if (callResult.isTypeIncomplete) {
-                        isTypeIncomplete = true;
-                    }
-                    if (callResult.argumentErrors) {
-                        argumentErrors = true;
-                    }
-                    overloadsUsedForCall.push(...callResult.overloadsUsedForCall);
-                    return applyExpectedSubtypeForConstructor(type, expectedSubType, typeVarContext);
-                }
-            }
-            return undefined;
-        });
-        if ((0, types_1.isNever)(returnType)) {
-            return undefined;
-        }
-        return { returnType, isTypeIncomplete, argumentErrors, overloadsUsedForCall };
-    }
-    function applyExpectedSubtypeForConstructor(type, expectedSubtype, typeVarContext) {
-        const specializedType = (0, typeUtils_1.applySolvedTypeVars)(types_1.ClassType.cloneAsInstance(type), typeVarContext);
-        if (!assignType(expectedSubtype, specializedType)) {
-            return undefined;
-        }
-        // If the expected type is "Any", transform it to an Any.
-        if ((0, types_1.isAny)(expectedSubtype)) {
-            return expectedSubtype;
-        }
-        return specializedType;
-    }
-    // Handles the case where a constructor is a generic type and the type
-    // arguments are not specified but can be provided by the expected type.
-    function applyExpectedTypeForConstructor(type, inferenceContext, typeVarContext) {
-        let unsolvedTypeVarsAreUnknown = true;
-        if (inferenceContext) {
-            const specializedExpectedType = (0, typeUtils_1.mapSubtypes)(inferenceContext.expectedType, (expectedSubtype) => {
-                return applyExpectedSubtypeForConstructor(type, expectedSubtype, typeVarContext);
-            });
-            if (!(0, types_1.isNever)(specializedExpectedType)) {
-                return specializedExpectedType;
-            }
-            // If the expected type didn't provide TypeVar values, remaining
-            // unsolved TypeVars should be considered Unknown unless they were
-            // provided explicitly in the constructor call.
-            if (type.typeArguments) {
-                unsolvedTypeVarsAreUnknown = false;
-            }
-        }
-        const specializedType = (0, typeUtils_1.applySolvedTypeVars)(type, typeVarContext, {
-            unknownIfNotFound: unsolvedTypeVarsAreUnknown,
-        });
-        return types_1.ClassType.cloneAsInstance(specializedType);
-    }
-    // Similar to applyExpectedTypeForConstructor, this function handles the
-    // special case of the tuple class.
-    function applyExpectedTypeForTupleConstructor(type, inferenceContext) {
-        let specializedType = type;
-        if (inferenceContext &&
-            (0, types_1.isClassInstance)(inferenceContext.expectedType) &&
-            (0, typeUtils_1.isTupleClass)(inferenceContext.expectedType) &&
-            inferenceContext.expectedType.tupleTypeArguments) {
-            specializedType = (0, typeUtils_1.specializeTupleClass)(type, inferenceContext.expectedType.tupleTypeArguments);
-        }
-        return specializedType;
-    }
     // Validates that the arguments can be assigned to the call's parameter
     // list, specializes the call based on arg types, and returns the
     // specialized type of the return value. If it detects an error along
@@ -6414,7 +6017,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     // to be done again once it is complete.
                     if (!callTypeResult.isIncomplete) {
                         argList.forEach((arg) => {
-                            if (arg.valueExpression && !speculativeTypeTracker.isSpeculative(arg.valueExpression)) {
+                            if (arg.valueExpression && !isSpeculativeModeInUse(arg.valueExpression)) {
                                 getTypeOfArgument(arg);
                             }
                         });
@@ -6443,7 +6046,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     let effectiveTypeVarContext = typeVarContext;
                     if (!effectiveTypeVarContext) {
                         // If a typeVarContext wasn't provided by the caller, allocate one here.
-                        effectiveTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(expandedSubtype));
+                        effectiveTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeIds)(expandedSubtype));
                         // There are certain cases, such as with super().__new__(cls) calls where
                         // the call is a constructor but the proper TypeVar scope has been lost.
                         // We'll add a wildcard TypeVar scope here. This is a bit of a hack and
@@ -6538,7 +6141,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             const className = expandedSubtype.aliasName || expandedSubtype.details.name;
                             if (className === 'type') {
                                 // Validate the constructor arguments.
-                                validateConstructorArguments(errorNode, argList, expandedSubtype, skipUnknownArgCheck, inferenceContext);
+                                (0, constructors_1.validateConstructorArguments)(evaluatorInterface, errorNode, argList, expandedSubtype, skipUnknownArgCheck, inferenceContext);
                                 // Handle the 'type' call specially.
                                 if (argList.length === 1) {
                                     // The one-parameter form of "type" returns the class
@@ -6637,7 +6240,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             }), errorNode);
                         }
                         // Assume this is a call to the constructor.
-                        const constructorResult = validateConstructorArguments(errorNode, argList, expandedSubtype, skipUnknownArgCheck, inferenceContext);
+                        const constructorResult = (0, constructors_1.validateConstructorArguments)(evaluatorInterface, errorNode, argList, expandedSubtype, skipUnknownArgCheck, inferenceContext);
                         overloadsUsedForCall.push(...constructorResult.overloadsUsedForCall);
                         if (constructorResult.argumentErrors) {
                             argumentErrors = true;
@@ -7479,7 +7082,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If we're in speculative mode and an arg/param mismatch has already been reported, don't
         // bother doing the extra work here. This occurs frequently when attempting to find the
         // correct overload.
-        if (!reportedArgError || !speculativeTypeTracker.isSpeculative(undefined)) {
+        if (!reportedArgError || !isSpeculativeModeInUse(undefined)) {
             // If there are arguments that map to a variadic *args parameter that hasn't
             // already been matched, see if the type of that *args parameter is a variadic
             // type variable. If so, we'll preprocess those arguments and combine them
@@ -7577,13 +7180,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // After having matched arguments with parameters, this function evaluates the
     // types of each argument expression and validates that the resulting type is
     // compatible with the declared type of the corresponding parameter.
-    function validateFunctionArgumentTypesWithExpectedType(errorNode, matchResults, typeVarContext, skipUnknownArgCheck = false, inferenceContext) {
+    function validateFunctionArgumentTypesWithContext(errorNode, matchResults, typeVarContext, skipUnknownArgCheck = false, inferenceContext) {
         var _a;
         const type = matchResults.overload;
         if (!inferenceContext ||
             (0, types_1.isAnyOrUnknown)(inferenceContext.expectedType) ||
             (0, types_1.isNever)(inferenceContext.expectedType) ||
-            (0, typeUtils_1.requiresSpecialization)(inferenceContext.expectedType) ||
             !type.details.declaredReturnType ||
             !(0, typeUtils_1.requiresSpecialization)((_a = types_1.FunctionType.getSpecializedReturnType(type)) !== null && _a !== void 0 ? _a : types_1.UnknownType.create())) {
             return validateFunctionArgumentTypes(errorNode, matchResults, typeVarContext, skipUnknownArgCheck);
@@ -7598,17 +7200,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // We may or may not be able to make use of the expected type. We'll evaluate
         // speculatively to see if using the expected type works.
         if ((0, types_1.isUnion)(inferenceContext.expectedType)) {
-            let speculativeResults;
             useSpeculativeMode(errorNode, () => {
                 const typeVarContextCopy = typeVarContext.clone();
                 assignType(effectiveReturnType, effectiveExpectedType, 
                 /* diag */ undefined, typeVarContextCopy, 
                 /* srcTypeVarContext */ undefined, effectiveFlags | 1024 /* PopulatingExpectedType */);
-                speculativeResults = validateFunctionArgumentTypes(errorNode, matchResults, typeVarContextCopy, skipUnknownArgCheck);
+                const speculativeResults = validateFunctionArgumentTypes(errorNode, matchResults, typeVarContextCopy, skipUnknownArgCheck);
+                if (speculativeResults === null || speculativeResults === void 0 ? void 0 : speculativeResults.argumentErrors) {
+                    effectiveExpectedType = undefined;
+                }
             });
-            if (speculativeResults && speculativeResults.argumentErrors) {
-                effectiveExpectedType = undefined;
-            }
         }
         if (effectiveExpectedType) {
             // Prepopulate the typeVarContext based on the specialized expected type if the
@@ -7621,12 +7222,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 (0, types_1.isClassInstance)(effectiveExpectedType) &&
                 !types_1.ClassType.isSameGenericClass(effectiveReturnType, effectiveExpectedType)) {
                 const tempTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(effectiveReturnType));
-                (0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, effectiveReturnType, effectiveExpectedType, tempTypeVarContext, getTypeVarScopesForNode(errorNode));
+                (0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, effectiveReturnType, effectiveExpectedType, tempTypeVarContext, ParseTreeUtils.getTypeVarScopesForNode(errorNode));
                 const genericReturnType = types_1.ClassType.cloneForSpecialization(effectiveReturnType, 
                 /* typeArguments */ undefined, 
                 /* isTypeArgumentExplicit */ false);
                 effectiveExpectedType = (0, typeUtils_1.applySolvedTypeVars)(genericReturnType, tempTypeVarContext);
             }
+            else if ((0, types_1.isFunction)(effectiveReturnType)) {
+                // If the return type is a callable and the expected type is a union that
+                // includes one or more non-callables, filter those out.
+                if ((0, types_1.isUnion)(effectiveExpectedType)) {
+                    effectiveExpectedType = (0, typeUtils_1.mapSubtypes)(effectiveExpectedType, (subtype) => {
+                        return (0, typeUtils_1.isCallableType)(subtype) ? subtype : undefined;
+                    });
+                }
+            }
             assignType(effectiveReturnType, effectiveExpectedType, 
             /* diag */ undefined, typeVarContext, 
             /* srcTypeVarContext */ undefined, effectiveFlags | 1024 /* PopulatingExpectedType */);
@@ -7705,12 +7315,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         // is an overload function, skip it during the first pass
                         // because the selection of the proper overload may depend
                         // on type arguments supplied by other function arguments.
-                        // Set useNarrowBoundOnly to true the first time through
-                        // the loop if we're going to go through the loop multiple
-                        // times.
-                        const argResult = validateArgType(argParam, typeVarContext, signatureTracker, { type, isIncomplete: matchResults.isTypeIncomplete }, skipUnknownArgCheck, 
-                        /* skipOverloadArg */ i === 0, 
-                        /* isFirstPass */ passCount > 1 && i === 0, typeCondition);
+                        // We set useNarrowBoundOnly to true if this is the first
+                        // (but not only) pass through the parameter list because a wide
+                        // bound on a TypeVar (if a narrow bound has not yet been
+                        // established) will unnecessarily constrain the expected type.
+                        // If the param type is a "bare" TypeVar, don't use it as an
+                        // expected type during the first pass. This causes problems for
+                        // cases where the the call expression result can influence the
+                        // type of the TypeVar, such as in the expression "min(1, max(2, 0.5))".
+                        const argResult = validateArgType(argParam, typeVarContext, signatureTracker, { type, isIncomplete: matchResults.isTypeIncomplete }, {
+                            skipUnknownArgCheck,
+                            skipOverloadArg: i === 0,
+                            skipBareTypeVarExpectedType: i === 0,
+                            useNarrowBoundOnly: passCount > 1 && i === 0,
+                            conditionFilter: typeCondition,
+                        });
                         if (argResult.isTypeIncomplete) {
                             isTypeIncomplete = true;
                         }
@@ -7734,9 +7353,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const signatureTracker = new typeUtils_1.UniqueSignatureTracker();
         matchResults.argParams.forEach((argParam) => {
             var _a;
-            const argResult = validateArgType(argParam, typeVarContext, signatureTracker, { type, isIncomplete: matchResults.isTypeIncomplete }, skipUnknownArgCheck, 
-            /* skipOverloadArg */ false, 
-            /* isFirstPass */ false, typeCondition);
+            const argResult = validateArgType(argParam, typeVarContext, signatureTracker, { type, isIncomplete: matchResults.isTypeIncomplete }, {
+                skipUnknownArgCheck,
+                conditionFilter: typeCondition,
+            });
             argResults.push(argResult);
             if (!argResult.isCompatible) {
                 argumentErrors = true;
@@ -7797,7 +7417,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (!typeVarScopeNode) {
                 break;
             }
-            const typeVarScopeId = getScopeIdForNode(typeVarScopeNode);
+            const typeVarScopeId = ParseTreeUtils.getScopeIdForNode(typeVarScopeNode);
             if (typeVarContext.hasSolveForScope(typeVarScopeId)) {
                 eliminateUnsolvedInUnions = false;
             }
@@ -7820,7 +7440,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let unknownIfNotFound = !(0, types_1.isFunction)(returnType);
         // We'll also leave TypeVars unsolved if the call is a recursive
         // call to a generic function.
-        const typeVarScopes = getTypeVarScopesForNode(errorNode);
+        const typeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
         if (typeVarScopes.some((typeVarScope) => typeVarContext.hasSolveForScope(typeVarScope))) {
             unknownIfNotFound = false;
         }
@@ -7896,7 +7516,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Evaluate types of all args. This will ensure that referenced symbols are
             // not reported as unaccessed.
             argList.forEach((arg) => {
-                if (arg.valueExpression && !speculativeTypeTracker.isSpeculative(arg.valueExpression)) {
+                if (arg.valueExpression && !isSpeculativeModeInUse(arg.valueExpression)) {
                     getTypeOfExpression(arg.valueExpression);
                 }
             });
@@ -7906,7 +7526,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 overloadsUsedForCall: [],
             };
         }
-        return validateFunctionArgumentTypesWithExpectedType(errorNode, matchResults, typeVarContext, skipUnknownArgCheck, inferenceContext);
+        return validateFunctionArgumentTypesWithContext(errorNode, matchResults, typeVarContext, skipUnknownArgCheck, inferenceContext);
     }
     // Determines whether the specified argument list satisfies the function
     // signature bound to the specified ParamSpec. Return value indicates success.
@@ -8006,10 +7626,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         argument: arg,
                         errorNode: arg.valueExpression || errorNode,
                     }, srcTypeVarContext, signatureTracker, 
-                    /* functionType */ undefined, 
-                    /* skipUnknownArgCheck */ false, 
-                    /* skipOverloadArg */ false, 
-                    /* isFirstPass */ false, conditionFilter);
+                    /* functionType */ undefined, { conditionFilter });
                     if (!argResult.isCompatible) {
                         reportedArgError = true;
                     }
@@ -8059,7 +7676,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return !reportedArgError;
     }
-    function validateArgType(argParam, typeVarContext, signatureTracker, typeResult, skipUnknownCheck, skipOverloadArg, isFirstPass, conditionFilter) {
+    function validateArgType(argParam, typeVarContext, signatureTracker, typeResult, options) {
         var _a;
         let argType;
         let expectedTypeDiag;
@@ -8067,19 +7684,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let isCompatible = true;
         const functionName = typeResult === null || typeResult === void 0 ? void 0 : typeResult.type.details.name;
         if (argParam.argument.valueExpression) {
-            // If the param type is a "bare" TypeVar, don't use it as an expected
-            // type during the first pass. This causes problems for cases where the the
-            // call expression result can influence the type of the TypeVar, such as in
-            // the expression "min(1, max(2, 0.5))". We set useNarrowBoundOnly
-            // to true if this is the first pass through the parameter list because
-            // a wide bound on a TypeVar (if a narrow bound has not yet been established)
-            // will unnecessarily constrain the expected type.
             let expectedType;
-            if (!isFirstPass ||
+            if (!options.skipBareTypeVarExpectedType ||
                 !(0, types_1.isTypeVar)(argParam.paramType) ||
                 argParam.paramType.scopeId !== (typeResult === null || typeResult === void 0 ? void 0 : typeResult.type.details.typeVarScopeId)) {
                 expectedType = (0, typeUtils_1.applySolvedTypeVars)(argParam.paramType, typeVarContext, {
-                    useNarrowBoundOnly: isFirstPass,
+                    useNarrowBoundOnly: !!options.useNarrowBoundOnly,
                 });
             }
             // If the expected type is unknown, don't use an expected type. Instead,
@@ -8107,9 +7717,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 expectedTypeDiag = exprTypeResult.expectedTypeDiagAddendum;
             }
-            if (argParam.argument &&
-                argParam.argument.name &&
-                !speculativeTypeTracker.isSpeculative(argParam.errorNode)) {
+            if (argParam.argument && argParam.argument.name && !isSpeculativeModeInUse(argParam.errorNode)) {
                 writeTypeCache(argParam.argument.name, { type: expectedType !== null && expectedType !== void 0 ? expectedType : argType, isIncomplete: isTypeIncomplete }, 0 /* None */);
             }
         }
@@ -8148,8 +7756,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If there's a constraint filter, apply it to top-level type variables
         // if appropriate. This doesn't properly handle non-top-level constrained
         // type variables.
-        if (conditionFilter) {
-            argType = mapSubtypesExpandTypeVars(argType, conditionFilter, (expandedSubtype) => {
+        if (options.conditionFilter) {
+            argType = mapSubtypesExpandTypeVars(argType, options.conditionFilter, (expandedSubtype) => {
                 return expandedSubtype;
             });
         }
@@ -8168,14 +7776,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If we are asked to skip overload arguments, determine whether the argument
         // is an explicit overload type, an overloaded class constructor, or a
         // an overloaded callback protocol.
-        if (skipOverloadArg) {
+        if (options.skipOverloadArg) {
             if ((0, types_1.isOverloadedFunction)(argType)) {
                 return { isCompatible, argType, isTypeIncomplete, skippedOverloadArg: true, condition };
             }
             const concreteParamType = makeTopLevelTypeVarsConcrete(argParam.paramType);
             if ((0, types_1.isFunction)(concreteParamType) || (0, types_1.isOverloadedFunction)(concreteParamType)) {
                 if ((0, types_1.isInstantiableClass)(argType)) {
-                    const constructor = createFunctionFromConstructor(argType);
+                    const constructor = (0, constructors_1.createFunctionFromConstructor)(evaluatorInterface, argType);
                     if (constructor && (0, types_1.isOverloadedFunction)(constructor)) {
                         return { isCompatible, argType, isTypeIncomplete, skippedOverloadArg: true, condition };
                     }
@@ -8244,7 +7852,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             return { isCompatible: false, argType, isTypeIncomplete, condition };
         }
-        if (!skipUnknownCheck) {
+        if (!options.skipUnknownArgCheck) {
             const simplifiedType = (0, types_1.removeUnbound)(argType);
             const fileInfo = AnalyzerNodeInfo.getFileInfo(argParam.errorNode);
             const getDiagAddendum = () => {
@@ -8682,644 +8290,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return { type };
     }
-    function getTypeOfUnaryOperation(node, inferenceContext) {
-        const exprTypeResult = getTypeOfExpression(node.expression);
-        let exprType = makeTopLevelTypeVarsConcrete(exprTypeResult.type);
-        const isIncomplete = exprTypeResult.isIncomplete;
-        if ((0, types_1.isNever)(exprType)) {
-            return { type: types_1.NeverType.createNever(), isIncomplete };
-        }
-        // Map unary operators to magic functions. Note that the bitwise
-        // invert has two magic functions that are aliases of each other.
-        const unaryOperatorMap = {
-            [0 /* Add */]: '__pos__',
-            [33 /* Subtract */]: '__neg__',
-            [5 /* BitwiseInvert */]: '__invert__',
-        };
-        let type;
-        if (node.operator !== 38 /* Not */) {
-            if ((0, typeUtils_1.isOptionalType)(exprType)) {
-                addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportOptionalOperand, diagnosticRules_1.DiagnosticRule.reportOptionalOperand, localize_1.Localizer.Diagnostic.noneOperator().format({
-                    operator: ParseTreeUtils.printOperator(node.operator),
-                }), node.expression);
-                exprType = (0, types_1.removeNoneFromUnion)(exprType);
-            }
-        }
-        // Handle certain operations on certain literal types
-        // using special-case math. Do not apply this if the input type
-        // is incomplete because we may be evaluating an expression within
-        // a loop, so the literal value may change each time.
-        if (!exprTypeResult.isIncomplete) {
-            const literalClassName = (0, typeUtils_1.getLiteralTypeClassName)(exprType);
-            if (literalClassName === 'int') {
-                if (node.operator === 0 /* Add */) {
-                    type = exprType;
-                }
-                else if (node.operator === 33 /* Subtract */) {
-                    type = (0, typeUtils_1.mapSubtypes)(exprType, (subtype) => {
-                        const classSubtype = subtype;
-                        return types_1.ClassType.cloneWithLiteral(classSubtype, -classSubtype.literalValue);
-                    });
-                }
-            }
-            else if (literalClassName === 'bool') {
-                if (node.operator === 38 /* Not */) {
-                    type = (0, typeUtils_1.mapSubtypes)(exprType, (subtype) => {
-                        const classSubtype = subtype;
-                        return types_1.ClassType.cloneWithLiteral(classSubtype, !classSubtype.literalValue);
-                    });
-                }
-            }
-        }
-        if (!type) {
-            // __not__ always returns a boolean.
-            if (node.operator === 38 /* Not */) {
-                type = getBuiltInObject(node, 'bool');
-                if (!type) {
-                    type = types_1.UnknownType.create();
-                }
-            }
-            else {
-                if ((0, types_1.isAnyOrUnknown)(exprType)) {
-                    type = exprType;
-                }
-                else {
-                    const magicMethodName = unaryOperatorMap[node.operator];
-                    type = getTypeOfMagicMethodReturn(exprType, [], magicMethodName, node, inferenceContext);
-                }
-                if (!type) {
-                    const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-                    if (inferenceContext) {
-                        addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeNotSupportUnaryOperatorBidirectional().format({
-                            operator: ParseTreeUtils.printOperator(node.operator),
-                            type: printType(exprType),
-                            expectedType: printType(inferenceContext.expectedType),
-                        }), node);
-                    }
-                    else {
-                        addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeNotSupportUnaryOperator().format({
-                            operator: ParseTreeUtils.printOperator(node.operator),
-                            type: printType(exprType),
-                        }), node);
-                    }
-                    type = types_1.UnknownType.create();
-                }
-            }
-        }
-        return { type, isIncomplete };
-    }
-    function getTypeOfBinaryOperation(node, inferenceContext, flags) {
-        const leftExpression = node.leftExpression;
-        let rightExpression = node.rightExpression;
-        let isIncomplete = false;
-        let typeErrors = false;
-        // If this is a comparison and the left expression is also a comparison,
-        // we need to change the behavior to accommodate python's "chained
-        // comparisons" feature.
-        if (ParseTreeUtils.operatorSupportsChaining(node.operator)) {
-            if (rightExpression.nodeType === 7 /* BinaryOperation */ &&
-                !rightExpression.parenthesized &&
-                ParseTreeUtils.operatorSupportsChaining(rightExpression.operator)) {
-                // Evaluate the right expression so it is type checked.
-                getTypeOfBinaryOperation(rightExpression, inferenceContext, flags);
-                // Use the left side of the right expression for comparison purposes.
-                rightExpression = rightExpression.leftExpression;
-            }
-        }
-        // For most binary operations, the "expected type" is applied to the output
-        // of the magic method for that operation. However, the "or" and "and" operators
-        // have no magic method, so we apply the expected type directly to both operands.
-        let expectedOperandType = node.operator === 37 /* Or */ || node.operator === 36 /* And */
-            ? inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType
-            : undefined;
-        // Handle the very special case where the expected type is a list
-        // and the operator is a multiply. This comes up in the common case
-        // of "x: List[Optional[X]] = [None] * y" where y is an integer literal.
-        let expectedLeftOperandType;
-        if (node.operator === 26 /* Multiply */ &&
-            inferenceContext &&
-            (0, types_1.isClassInstance)(inferenceContext.expectedType) &&
-            types_1.ClassType.isBuiltIn(inferenceContext.expectedType, 'list') &&
-            inferenceContext.expectedType.typeArguments &&
-            inferenceContext.expectedType.typeArguments.length >= 1 &&
-            node.leftExpression.nodeType === 31 /* List */) {
-            expectedLeftOperandType = inferenceContext.expectedType;
-        }
-        const effectiveExpectedType = expectedOperandType !== null && expectedOperandType !== void 0 ? expectedOperandType : expectedLeftOperandType;
-        const leftTypeResult = getTypeOfExpression(leftExpression, flags, (0, typeUtils_1.makeInferenceContext)(effectiveExpectedType));
-        let leftType = leftTypeResult.type;
-        if (!expectedOperandType) {
-            if (node.operator === 37 /* Or */ || node.operator === 36 /* And */) {
-                // For "or" and "and", use the type of the left operand. This allows us to
-                // infer a better type for expressions like `x or []`.
-                expectedOperandType = leftType;
-            }
-            else if (node.operator === 0 /* Add */ && node.rightExpression.nodeType === 31 /* List */) {
-                // For the "+" operator , use this technique only if the right operand is
-                // a list expression. This heuristic handles the common case of `my_list + [0]`.
-                expectedOperandType = leftType;
-            }
-            else if (node.operator === 6 /* BitwiseOr */) {
-                // If this is a bitwise or ("|"), use the type of the left operand. This allows
-                // us to support the case where a TypedDict is being updated with a dict expression.
-                if ((0, types_1.isClassInstance)(leftType) && types_1.ClassType.isTypedDictClass(leftType)) {
-                    expectedOperandType = leftType;
-                }
-            }
-        }
-        const rightTypeResult = getTypeOfExpression(rightExpression, flags, (0, typeUtils_1.makeInferenceContext)(expectedOperandType));
-        let rightType = rightTypeResult.type;
-        if (leftTypeResult.isIncomplete || rightTypeResult.isIncomplete) {
-            isIncomplete = true;
-        }
-        // Is this a "|" operator used in a context where it is supposed to be
-        // interpreted as a union operator?
-        if (node.operator === 6 /* BitwiseOr */ &&
-            !customMetaclassSupportsMethod(leftType, '__or__') &&
-            !customMetaclassSupportsMethod(rightType, '__ror__')) {
-            let adjustedRightType = rightType;
-            let adjustedLeftType = leftType;
-            if (!(0, types_1.isNoneInstance)(leftType) && (0, types_1.isNoneInstance)(rightType)) {
-                // Handle the special case where "None" is being added to the union
-                // with something else. Even though "None" will normally be interpreted
-                // as the None singleton object in contexts where a type annotation isn't
-                // assumed, we'll allow it here.
-                adjustedRightType = types_1.NoneType.createType();
-            }
-            else if (!(0, types_1.isNoneInstance)(rightType) && (0, types_1.isNoneInstance)(leftType)) {
-                adjustedLeftType = types_1.NoneType.createType();
-            }
-            if ((0, typeUtils_1.isUnionableType)([adjustedLeftType, adjustedRightType])) {
-                const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-                const unionNotationSupported = fileInfo.isStubFile ||
-                    (flags & 4 /* AllowForwardReferences */) !== 0 ||
-                    fileInfo.executionEnvironment.pythonVersion >= pythonVersion_1.PythonVersion.V3_10;
-                if (!unionNotationSupported) {
-                    // If the left type is Any, we can't say for sure whether this
-                    // is an illegal syntax or a valid application of the "|" operator.
-                    if (!(0, types_1.isAnyOrUnknown)(adjustedLeftType)) {
-                        addError(localize_1.Localizer.Diagnostic.unionSyntaxIllegal(), node, node.operatorToken);
-                    }
-                }
-                if (!validateTypeArg({ ...leftTypeResult, node: leftExpression }, { allowVariadicTypeVar: true, allowUnpackedTuples: true }) ||
-                    !validateTypeArg({ ...rightTypeResult, node: rightExpression }, { allowVariadicTypeVar: true, allowUnpackedTuples: true })) {
-                    return { type: types_1.UnknownType.create() };
-                }
-                const newUnion = (0, types_1.combineTypes)([adjustedLeftType, adjustedRightType]);
-                if ((0, types_1.isUnion)(newUnion)) {
-                    types_1.TypeBase.setSpecialForm(newUnion);
-                }
-                // Check for "stringified" forward reference type expressions. The "|" operator
-                // doesn't support these except in certain circumstances. Notably, it can't be used
-                // with other strings or with types that are not specialized using an index form.
-                if (!fileInfo.isStubFile) {
-                    let stringNode;
-                    let otherNode;
-                    let otherType;
-                    if (leftExpression.nodeType === 48 /* StringList */) {
-                        stringNode = leftExpression;
-                        otherNode = rightExpression;
-                        otherType = rightType;
-                    }
-                    else if (rightExpression.nodeType === 48 /* StringList */) {
-                        stringNode = rightExpression;
-                        otherNode = leftExpression;
-                        otherType = leftType;
-                    }
-                    if (stringNode && otherNode && otherType) {
-                        let isAllowed = true;
-                        if ((0, types_1.isClass)(otherType)) {
-                            if (!otherType.isTypeArgumentExplicit || (0, types_1.isClassInstance)(otherType)) {
-                                isAllowed = false;
-                            }
-                        }
-                        if (!isAllowed) {
-                            addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.unionForwardReferenceNotAllowed(), stringNode);
-                        }
-                    }
-                }
-                return { type: newUnion };
-            }
-        }
-        // Optional checks apply to all operations except for boolean operations.
-        let isLeftOptionalType = false;
-        if (booleanOperatorMap[node.operator] === undefined) {
-            // None is a valid operand for == and != even if the type stub says otherwise.
-            if (node.operator === 12 /* Equals */ || node.operator === 28 /* NotEquals */) {
-                leftType = (0, types_1.removeNoneFromUnion)(leftType);
-            }
-            else {
-                isLeftOptionalType = (0, typeUtils_1.isOptionalType)(leftType);
-            }
-            // None is a valid operand for == and != even if the type stub says otherwise.
-            if (node.operator === 12 /* Equals */ || node.operator === 28 /* NotEquals */) {
-                rightType = (0, types_1.removeNoneFromUnion)(rightType);
-            }
-        }
-        const diag = new diagnostic_1.DiagnosticAddendum();
-        // Don't use literal math if either of the operation is within a loop
-        // because the literal values may change each time.
-        const isLiteralMathAllowed = !ParseTreeUtils.isWithinLoop(node);
-        // Don't special-case tuple __add__ if the left type is a union. This
-        // can result in an infinite loop if we keep creating new tuple types
-        // within a loop construct using __add__.
-        const isTupleAddAllowed = !(0, types_1.isUnion)(leftType);
-        let type = validateBinaryOperation(node.operator, { type: leftType, isIncomplete: leftTypeResult.isIncomplete }, { type: rightType, isIncomplete: rightTypeResult.isIncomplete }, node, inferenceContext, diag, { isLiteralMathAllowed, isTupleAddAllowed });
-        if (!diag.isEmpty() || !type) {
-            typeErrors = true;
-            if (!isIncomplete) {
-                const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-                if (isLeftOptionalType && diag.getMessages().length === 1) {
-                    // If the left was an optional type and there is just one diagnostic,
-                    // assume that it was due to a "None" not being supported. Report
-                    // this as a reportOptionalOperand diagnostic rather than a
-                    // reportGeneralTypeIssues diagnostic.
-                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportOptionalOperand, diagnosticRules_1.DiagnosticRule.reportOptionalOperand, localize_1.Localizer.Diagnostic.noneOperator().format({
-                        operator: ParseTreeUtils.printOperator(node.operator),
-                    }), node.leftExpression);
-                }
-                else {
-                    addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeNotSupportBinaryOperator().format({
-                        operator: ParseTreeUtils.printOperator(node.operator),
-                        leftType: printType(leftType),
-                        rightType: printType(rightType),
-                    }) + diag.getString(), node);
-                }
-            }
-            type = types_1.UnknownType.create();
-        }
-        return { type, isIncomplete, typeErrors };
-    }
-    function customMetaclassSupportsMethod(type, methodName) {
-        if (!(0, types_1.isInstantiableClass)(type)) {
-            return false;
-        }
-        const metaclass = type.details.effectiveMetaclass;
-        if (!metaclass || !(0, types_1.isInstantiableClass)(metaclass)) {
-            return false;
-        }
-        if (types_1.ClassType.isBuiltIn(metaclass, 'type')) {
-            return false;
-        }
-        const memberInfo = (0, typeUtils_1.lookUpClassMember)(metaclass, methodName);
-        if (!memberInfo) {
-            return false;
-        }
-        if ((0, types_1.isInstantiableClass)(memberInfo.classType) && types_1.ClassType.isBuiltIn(memberInfo.classType, 'type')) {
-            return false;
-        }
-        return true;
-    }
-    function getTypeOfAugmentedAssignment(node, inferenceContext) {
-        const operatorMap = {
-            [1 /* AddEqual */]: ['__iadd__', 0 /* Add */],
-            [34 /* SubtractEqual */]: ['__isub__', 33 /* Subtract */],
-            [27 /* MultiplyEqual */]: ['__imul__', 26 /* Multiply */],
-            [14 /* FloorDivideEqual */]: ['__ifloordiv__', 13 /* FloorDivide */],
-            [11 /* DivideEqual */]: ['__itruediv__', 10 /* Divide */],
-            [25 /* ModEqual */]: ['__imod__', 24 /* Mod */],
-            [30 /* PowerEqual */]: ['__ipow__', 29 /* Power */],
-            [23 /* MatrixMultiplyEqual */]: ['__imatmul__', 22 /* MatrixMultiply */],
-            [4 /* BitwiseAndEqual */]: ['__iand__', 3 /* BitwiseAnd */],
-            [7 /* BitwiseOrEqual */]: ['__ior__', 6 /* BitwiseOr */],
-            [9 /* BitwiseXorEqual */]: ['__ixor__', 8 /* BitwiseXor */],
-            [18 /* LeftShiftEqual */]: ['__ilshift__', 17 /* LeftShift */],
-            [32 /* RightShiftEqual */]: ['__irshift__', 31 /* RightShift */],
-        };
-        let type;
-        let typeResult;
-        const diag = new diagnostic_1.DiagnosticAddendum();
-        const leftTypeResult = getTypeOfExpression(node.leftExpression);
-        const leftType = leftTypeResult.type;
-        let expectedOperandType;
-        if (node.operator === 7 /* BitwiseOrEqual */) {
-            // If this is a bitwise or ("|="), use the type of the left operand. This allows
-            // us to support the case where a TypedDict is being updated with a dict expression.
-            expectedOperandType = leftType;
-        }
-        const rightTypeResult = getTypeOfExpression(node.rightExpression, 
-        /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedOperandType));
-        const rightType = rightTypeResult.type;
-        const isIncomplete = !!rightTypeResult.isIncomplete || !!leftTypeResult.isIncomplete;
-        if ((0, types_1.isNever)(leftType) || (0, types_1.isNever)(rightType)) {
-            typeResult = { type: types_1.NeverType.createNever(), isIncomplete };
-        }
-        else {
-            type = mapSubtypesExpandTypeVars(leftType, 
-            /* conditionFilter */ undefined, (leftSubtypeExpanded, leftSubtypeUnexpanded) => {
-                return mapSubtypesExpandTypeVars(rightType, (0, typeUtils_1.getTypeCondition)(leftSubtypeExpanded), (rightSubtypeExpanded, rightSubtypeUnexpanded) => {
-                    if ((0, types_1.isAnyOrUnknown)(leftSubtypeUnexpanded) || (0, types_1.isAnyOrUnknown)(rightSubtypeUnexpanded)) {
-                        return (0, typeUtils_1.preserveUnknown)(leftSubtypeUnexpanded, rightSubtypeUnexpanded);
-                    }
-                    const magicMethodName = operatorMap[node.operator][0];
-                    let returnType = getTypeOfMagicMethodReturn(leftSubtypeUnexpanded, [{ type: rightSubtypeUnexpanded, isIncomplete: rightTypeResult.isIncomplete }], magicMethodName, node, inferenceContext);
-                    if (!returnType && leftSubtypeUnexpanded !== leftSubtypeExpanded) {
-                        // Try with the expanded left type.
-                        returnType = getTypeOfMagicMethodReturn(leftSubtypeExpanded, [{ type: rightSubtypeUnexpanded, isIncomplete: rightTypeResult.isIncomplete }], magicMethodName, node, inferenceContext);
-                    }
-                    if (!returnType && rightSubtypeUnexpanded !== rightSubtypeExpanded) {
-                        // Try with the expanded left and right type.
-                        returnType = getTypeOfMagicMethodReturn(leftSubtypeExpanded, [{ type: rightSubtypeExpanded, isIncomplete: rightTypeResult.isIncomplete }], magicMethodName, node, inferenceContext);
-                    }
-                    if (!returnType) {
-                        // If the LHS class didn't support the magic method for augmented
-                        // assignment, fall back on the normal binary expression evaluator.
-                        const binaryOperator = operatorMap[node.operator][1];
-                        // Don't use literal math if either of the operation is within a loop
-                        // because the literal values may change each time.
-                        const isLiteralMathAllowed = !ParseTreeUtils.isWithinLoop(node) &&
-                            (0, typeUtils_1.getUnionSubtypeCount)(leftType) * (0, typeUtils_1.getUnionSubtypeCount)(rightType) <
-                                maxLiteralMathSubtypeCount;
-                        // Don't special-case tuple __add__ if the left type is a union. This
-                        // can result in an infinite loop if we keep creating new tuple types
-                        // within a loop construct using __add__.
-                        const isTupleAddAllowed = !(0, types_1.isUnion)(leftType);
-                        returnType = validateBinaryOperation(binaryOperator, { type: leftSubtypeUnexpanded, isIncomplete: leftTypeResult.isIncomplete }, { type: rightSubtypeUnexpanded, isIncomplete: rightTypeResult.isIncomplete }, node, inferenceContext, diag, { isLiteralMathAllowed, isTupleAddAllowed });
-                    }
-                    return returnType;
-                });
-            });
-            // If the LHS class didn't support the magic method for augmented
-            // assignment, fall back on the normal binary expression evaluator.
-            if (!diag.isEmpty() || !type || (0, types_1.isNever)(type)) {
-                if (!isIncomplete) {
-                    const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-                    addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeNotSupportBinaryOperator().format({
-                        operator: ParseTreeUtils.printOperator(node.operator),
-                        leftType: printType(leftType),
-                        rightType: printType(rightType),
-                    }) + diag.getString(), node);
-                }
-                type = types_1.UnknownType.create();
-            }
-            typeResult = { type, isIncomplete };
-        }
-        assignTypeToExpression(node.destExpression, typeResult.type, !!typeResult.isIncomplete, node.rightExpression);
-        return typeResult;
-    }
-    function validateBinaryOperation(operator, leftTypeResult, rightTypeResult, errorNode, inferenceContext, diag, options) {
-        const leftType = leftTypeResult.type;
-        const rightType = rightTypeResult.type;
-        let type;
-        let concreteLeftType = makeTopLevelTypeVarsConcrete(leftType);
-        if (booleanOperatorMap[operator] !== undefined) {
-            // If it's an AND or OR, we need to handle short-circuiting by
-            // eliminating any known-truthy or known-falsy types.
-            if (operator === 36 /* And */) {
-                // If the LHS evaluates to falsy, the And expression will
-                // always return the type of the left-hand side.
-                if (!canBeTruthy(concreteLeftType)) {
-                    return leftType;
-                }
-                // If the LHS evaluates to truthy, the And expression will
-                // always return the type of the right-hand side.
-                if (!canBeFalsy(concreteLeftType)) {
-                    return rightType;
-                }
-                concreteLeftType = removeTruthinessFromType(concreteLeftType);
-                if ((0, types_1.isNever)(rightType)) {
-                    return concreteLeftType;
-                }
-            }
-            else if (operator === 37 /* Or */) {
-                // If the LHS evaluates to truthy, the Or expression will
-                // always return the type of the left-hand side.
-                if (!canBeFalsy(concreteLeftType)) {
-                    return leftType;
-                }
-                // If the LHS evaluates to falsy, the Or expression will
-                // always return the type of the right-hand side.
-                if (!canBeTruthy(concreteLeftType)) {
-                    return rightType;
-                }
-                concreteLeftType = removeFalsinessFromType(concreteLeftType);
-                if ((0, types_1.isNever)(rightType)) {
-                    return concreteLeftType;
-                }
-            }
-            if ((0, types_1.isNever)(leftType) || (0, types_1.isNever)(rightType)) {
-                return types_1.NeverType.createNever();
-            }
-            // The "in" and "not in" operators make use of the __contains__
-            // magic method.
-            if (operator === 41 /* In */ || operator === 42 /* NotIn */) {
-                type = mapSubtypesExpandTypeVars(rightType, 
-                /* conditionFilter */ undefined, (rightSubtypeExpanded, rightSubtypeUnexpanded) => {
-                    return mapSubtypesExpandTypeVars(concreteLeftType, (0, typeUtils_1.getTypeCondition)(rightSubtypeExpanded), (leftSubtype) => {
-                        var _a;
-                        if ((0, types_1.isAnyOrUnknown)(leftSubtype) || (0, types_1.isAnyOrUnknown)(rightSubtypeUnexpanded)) {
-                            return (0, typeUtils_1.preserveUnknown)(leftSubtype, rightSubtypeExpanded);
-                        }
-                        let returnType = getTypeOfMagicMethodReturn(rightSubtypeExpanded, [{ type: leftSubtype, isIncomplete: leftTypeResult.isIncomplete }], '__contains__', errorNode, 
-                        /* inferenceContext */ undefined);
-                        if (!returnType) {
-                            // If __contains__ was not supported, fall back
-                            // on an iterable.
-                            const iteratorType = (_a = getTypeOfIterator({ type: rightSubtypeExpanded, isIncomplete: rightTypeResult.isIncomplete }, 
-                            /* isAsync */ false, 
-                            /* errorNode */ undefined)) === null || _a === void 0 ? void 0 : _a.type;
-                            if (iteratorType && assignType(iteratorType, leftSubtype)) {
-                                returnType = getBuiltInObject(errorNode, 'bool');
-                            }
-                        }
-                        if (!returnType) {
-                            diag.addMessage(localize_1.Localizer.Diagnostic.typeNotSupportBinaryOperator().format({
-                                operator: ParseTreeUtils.printOperator(operator),
-                                leftType: printType(leftSubtype),
-                                rightType: printType(rightSubtypeExpanded),
-                            }));
-                        }
-                        return returnType;
-                    });
-                });
-                // Assume that a bool is returned even if the type is unknown
-                if (type && !(0, types_1.isNever)(type)) {
-                    type = getBuiltInObject(errorNode, 'bool');
-                }
-            }
-            else {
-                type = mapSubtypesExpandTypeVars(concreteLeftType, 
-                /* conditionFilter */ undefined, (leftSubtypeExpanded, leftSubtypeUnexpanded) => {
-                    return mapSubtypesExpandTypeVars(rightType, (0, typeUtils_1.getTypeCondition)(leftSubtypeExpanded), (rightSubtypeExpanded, rightSubtypeUnexpanded) => {
-                        // If the operator is an AND or OR, we need to combine the two types.
-                        if (operator === 36 /* And */ || operator === 37 /* Or */) {
-                            return (0, types_1.combineTypes)([leftSubtypeUnexpanded, rightSubtypeUnexpanded]);
-                        }
-                        // The other boolean operators always return a bool value.
-                        return getBuiltInObject(errorNode, 'bool');
-                    });
-                });
-            }
-        }
-        else if (binaryOperatorMap[operator]) {
-            if ((0, types_1.isNever)(leftType) || (0, types_1.isNever)(rightType)) {
-                return types_1.NeverType.createNever();
-            }
-            // Handle certain operations on certain homogenous literal types
-            // using special-case math. For example, Literal[1, 2] + Literal[3, 4]
-            // should result in Literal[4, 5, 6].
-            if (options.isLiteralMathAllowed) {
-                const leftLiteralClassName = (0, typeUtils_1.getLiteralTypeClassName)(leftType);
-                if (leftLiteralClassName && !(0, typeUtils_1.getTypeCondition)(leftType)) {
-                    const rightLiteralClassName = (0, typeUtils_1.getLiteralTypeClassName)(rightType);
-                    if (leftLiteralClassName === rightLiteralClassName &&
-                        !(0, typeUtils_1.getTypeCondition)(rightType) &&
-                        (0, typeUtils_1.getUnionSubtypeCount)(leftType) * (0, typeUtils_1.getUnionSubtypeCount)(rightType) < maxLiteralMathSubtypeCount) {
-                        if (leftLiteralClassName === 'str' || leftLiteralClassName === 'bytes') {
-                            if (operator === 0 /* Add */) {
-                                type = (0, typeUtils_1.mapSubtypes)(leftType, (leftSubtype) => {
-                                    return (0, typeUtils_1.mapSubtypes)(rightType, (rightSubtype) => {
-                                        const leftClassSubtype = leftSubtype;
-                                        const rightClassSubtype = rightSubtype;
-                                        return types_1.ClassType.cloneWithLiteral(leftClassSubtype, (leftClassSubtype.literalValue +
-                                            rightClassSubtype.literalValue));
-                                    });
-                                });
-                            }
-                        }
-                        else if (leftLiteralClassName === 'int') {
-                            if (operator === 0 /* Add */ ||
-                                operator === 33 /* Subtract */ ||
-                                operator === 26 /* Multiply */ ||
-                                operator === 13 /* FloorDivide */ ||
-                                operator === 24 /* Mod */) {
-                                let isValidResult = true;
-                                type = (0, typeUtils_1.mapSubtypes)(leftType, (leftSubtype) => {
-                                    return (0, typeUtils_1.mapSubtypes)(rightType, (rightSubtype) => {
-                                        try {
-                                            const leftClassSubtype = leftSubtype;
-                                            const rightClassSubtype = rightSubtype;
-                                            const leftLiteralValue = BigInt(leftClassSubtype.literalValue);
-                                            const rightLiteralValue = BigInt(rightClassSubtype.literalValue);
-                                            let newValue;
-                                            if (operator === 0 /* Add */) {
-                                                newValue = leftLiteralValue + rightLiteralValue;
-                                            }
-                                            else if (operator === 33 /* Subtract */) {
-                                                newValue = leftLiteralValue - rightLiteralValue;
-                                            }
-                                            else if (operator === 26 /* Multiply */) {
-                                                newValue = leftLiteralValue * rightLiteralValue;
-                                            }
-                                            else if (operator === 13 /* FloorDivide */) {
-                                                if (rightLiteralValue !== BigInt(0)) {
-                                                    newValue = leftLiteralValue / rightLiteralValue;
-                                                }
-                                            }
-                                            else if (operator === 24 /* Mod */) {
-                                                if (rightLiteralValue !== BigInt(0)) {
-                                                    newValue = leftLiteralValue % rightLiteralValue;
-                                                }
-                                            }
-                                            if (newValue === undefined) {
-                                                isValidResult = false;
-                                                return undefined;
-                                            }
-                                            else if (typeof newValue === 'number' && isNaN(newValue)) {
-                                                isValidResult = false;
-                                                return undefined;
-                                            }
-                                            else {
-                                                // Convert back to a simple number if it fits. Leave as a bigint
-                                                // if it doesn't.
-                                                if (newValue >= Number.MIN_SAFE_INTEGER &&
-                                                    newValue <= Number.MAX_SAFE_INTEGER) {
-                                                    newValue = Number(newValue);
-                                                }
-                                                return types_1.ClassType.cloneWithLiteral(leftClassSubtype, newValue);
-                                            }
-                                        }
-                                        catch {
-                                            isValidResult = false;
-                                            return undefined;
-                                        }
-                                    });
-                                });
-                                if (!isValidResult) {
-                                    type = undefined;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            if (!type) {
-                type = mapSubtypesExpandTypeVars(leftType, 
-                /* conditionFilter */ undefined, (leftSubtypeExpanded, leftSubtypeUnexpanded) => {
-                    return mapSubtypesExpandTypeVars(rightType, (0, typeUtils_1.getTypeCondition)(leftSubtypeExpanded), (rightSubtypeExpanded, rightSubtypeUnexpanded) => {
-                        if ((0, types_1.isAnyOrUnknown)(leftSubtypeUnexpanded) || (0, types_1.isAnyOrUnknown)(rightSubtypeUnexpanded)) {
-                            return (0, typeUtils_1.preserveUnknown)(leftSubtypeUnexpanded, rightSubtypeUnexpanded);
-                        }
-                        // Special-case __add__ for tuples when the types for both tuples are known.
-                        if (options.isTupleAddAllowed &&
-                            operator === 0 /* Add */ &&
-                            (0, types_1.isClassInstance)(leftSubtypeExpanded) &&
-                            (0, typeUtils_1.isTupleClass)(leftSubtypeExpanded) &&
-                            leftSubtypeExpanded.tupleTypeArguments &&
-                            !(0, typeUtils_1.isUnboundedTupleClass)(leftSubtypeExpanded) &&
-                            (0, types_1.isClassInstance)(rightSubtypeExpanded) &&
-                            (0, typeUtils_1.isTupleClass)(rightSubtypeExpanded) &&
-                            rightSubtypeExpanded.tupleTypeArguments &&
-                            !(0, typeUtils_1.isUnboundedTupleClass)(rightSubtypeExpanded) &&
-                            tupleClassType &&
-                            (0, types_1.isInstantiableClass)(tupleClassType)) {
-                            return types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleClassType, [
-                                ...leftSubtypeExpanded.tupleTypeArguments,
-                                ...rightSubtypeExpanded.tupleTypeArguments,
-                            ]));
-                        }
-                        const magicMethodName = binaryOperatorMap[operator][0];
-                        let resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(leftSubtypeUnexpanded), [{ type: rightSubtypeUnexpanded, isIncomplete: rightTypeResult.isIncomplete }], magicMethodName, errorNode, inferenceContext);
-                        if (!resultType && leftSubtypeUnexpanded !== leftSubtypeExpanded) {
-                            // Try the expanded left type.
-                            resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(leftSubtypeExpanded), [{ type: rightSubtypeUnexpanded, isIncomplete: rightTypeResult.isIncomplete }], magicMethodName, errorNode, inferenceContext);
-                        }
-                        if (!resultType && rightSubtypeUnexpanded !== rightSubtypeExpanded) {
-                            // Try the expanded left and right type.
-                            resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(leftSubtypeExpanded), [{ type: rightSubtypeExpanded, isIncomplete: rightTypeResult.isIncomplete }], magicMethodName, errorNode, inferenceContext);
-                        }
-                        if (!resultType) {
-                            // Try the alternate form (swapping right and left).
-                            const altMagicMethodName = binaryOperatorMap[operator][1];
-                            resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(rightSubtypeUnexpanded), [{ type: leftSubtypeUnexpanded, isIncomplete: leftTypeResult.isIncomplete }], altMagicMethodName, errorNode, inferenceContext);
-                            if (!resultType && rightSubtypeUnexpanded !== rightSubtypeExpanded) {
-                                // Try the expanded right type.
-                                resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(rightSubtypeExpanded), [
-                                    {
-                                        type: leftSubtypeUnexpanded,
-                                        isIncomplete: leftTypeResult.isIncomplete,
-                                    },
-                                ], altMagicMethodName, errorNode, inferenceContext);
-                            }
-                            if (!resultType && leftSubtypeUnexpanded !== leftSubtypeExpanded) {
-                                // Try the expanded right and left type.
-                                resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(rightSubtypeExpanded), [{ type: leftSubtypeExpanded, isIncomplete: leftTypeResult.isIncomplete }], altMagicMethodName, errorNode, inferenceContext);
-                            }
-                        }
-                        if (!resultType) {
-                            if (inferenceContext) {
-                                diag.addMessage(localize_1.Localizer.Diagnostic.typeNotSupportBinaryOperatorBidirectional().format({
-                                    operator: ParseTreeUtils.printOperator(operator),
-                                    leftType: printType(leftSubtypeExpanded),
-                                    rightType: printType(rightSubtypeExpanded),
-                                    expectedType: printType(inferenceContext.expectedType),
-                                }));
-                            }
-                            else {
-                                diag.addMessage(localize_1.Localizer.Diagnostic.typeNotSupportBinaryOperator().format({
-                                    operator: ParseTreeUtils.printOperator(operator),
-                                    leftType: printType(leftSubtypeExpanded),
-                                    rightType: printType(rightSubtypeExpanded),
-                                }));
-                            }
-                        }
-                        return resultType;
-                    });
-                });
-            }
-        }
-        return type && (0, types_1.isNever)(type) ? undefined : type;
-    }
     function getTypeOfMagicMethodReturn(objType, args, magicMethodName, errorNode, inferenceContext) {
         let magicMethodSupported = true;
         // Create a helper lambda for object subtypes.
@@ -9394,17 +8364,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return returnType;
     }
-    // All functions in Python derive from object, so they inherit all
-    // of the capabilities of an object. This function converts a function
-    // to an object instance.
-    function convertFunctionToObject(type) {
-        if ((0, types_1.isFunction)(type) || (0, types_1.isOverloadedFunction)(type)) {
-            if (objectType) {
-                return objectType;
-            }
-        }
-        return type;
-    }
     function getTypeOfDictionary(node, inferenceContext) {
         // If the expected type is a union, analyze for each of the subtypes
         // to find one that matches.
@@ -9480,7 +8439,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return undefined;
         }
         const dictTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(builtInDict));
-        if (!(0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, builtInDict, inferenceContext.expectedType, dictTypeVarContext, getTypeVarScopesForNode(node))) {
+        if (!(0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, builtInDict, inferenceContext.expectedType, dictTypeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node))) {
             return undefined;
         }
         const specializedDict = (0, typeUtils_1.applySolvedTypeVars)(types_1.ClassType.cloneAsInstantiable(builtInDict), dictTypeVarContext);
@@ -9491,7 +8450,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const expectedValueType = specializedDict.typeArguments[1];
         // Infer the key and value types if possible.
         if (getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, 
-        /* forceStrictInference */ true, expectedKeyType, expectedValueType, undefined, expectedDiagAddendum)) {
+        /* forceStrictInference */ true, expectedKeyType, expectedValueType, undefined, expectedDiagAddendum, inferenceContext)) {
             isIncomplete = true;
         }
         // Dict and MutableMapping types have invariant value types, so they
@@ -9500,10 +8459,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const isValueTypeInvariant = (0, types_1.isClassInstance)(inferenceContext.expectedType) &&
             (types_1.ClassType.isBuiltIn(inferenceContext.expectedType, 'dict') ||
                 types_1.ClassType.isBuiltIn(inferenceContext.expectedType, 'MutableMapping'));
-        const specializedKeyType = inferTypeArgFromExpectedType(expectedKeyType, keyTypes.map((result) => result.type), 
+        const specializedKeyType = inferTypeArgFromExpectedType((0, typeUtils_1.makeInferenceContext)(expectedKeyType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext), keyTypes.map((result) => result.type), 
         /* isNarrowable */ false);
-        const specializedValueType = inferTypeArgFromExpectedType(expectedValueType, valueTypes.map((result) => result.type), 
-        /* isNarrowable */ !isValueTypeInvariant);
+        const specializedValueType = inferTypeArgFromExpectedType((0, typeUtils_1.makeInferenceContext)(expectedValueType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext), valueTypes.map((result) => result.type), !isValueTypeInvariant);
         if (!specializedKeyType || !specializedValueType) {
             return undefined;
         }
@@ -9560,7 +8518,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return { type, isIncomplete };
     }
-    function getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, forceStrictInference, expectedKeyType, expectedValueType, expectedTypedDictEntries, expectedDiagAddendum) {
+    function getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, forceStrictInference, expectedKeyType, expectedValueType, expectedTypedDictEntries, expectedDiagAddendum, inferenceContext) {
         let isIncomplete = false;
         // Infer the key and value types if possible.
         node.entries.forEach((entryNode, index) => {
@@ -9568,7 +8526,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             let addUnknown = true;
             if (entryNode.nodeType === 17 /* DictionaryKeyEntry */) {
                 const keyTypeResult = getTypeOfExpression(entryNode.keyExpression, 
-                /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedKeyType !== null && expectedKeyType !== void 0 ? expectedKeyType : (forceStrictInference ? types_1.NeverType.createNever() : undefined)));
+                /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedKeyType !== null && expectedKeyType !== void 0 ? expectedKeyType : (forceStrictInference ? types_1.NeverType.createNever() : undefined), inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
                 if (keyTypeResult.isIncomplete) {
                     isIncomplete = true;
                 }
@@ -9587,12 +8545,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     expectedTypedDictEntries.has(keyType.literalValue)) {
                     const effectiveValueType = expectedTypedDictEntries.get(keyType.literalValue).valueType;
                     valueTypeResult = getTypeOfExpression(entryNode.valueExpression, 
-                    /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(effectiveValueType));
+                    /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(effectiveValueType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
                 }
                 else {
                     const effectiveValueType = expectedValueType !== null && expectedValueType !== void 0 ? expectedValueType : (forceStrictInference ? types_1.NeverType.createNever() : undefined);
                     valueTypeResult = getTypeOfExpression(entryNode.valueExpression, 
-                    /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(effectiveValueType));
+                    /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(effectiveValueType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
                 }
                 if (expectedDiagAddendum && valueTypeResult.expectedTypeDiagAddendum) {
                     expectedDiagAddendum.addAddendum(valueTypeResult.expectedTypeDiagAddendum);
@@ -9616,7 +8574,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
                 const unexpandedTypeResult = getTypeOfExpression(entryNode.expandExpression, 
-                /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedType));
+                /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
                 if (unexpandedTypeResult.isIncomplete) {
                     isIncomplete = true;
                 }
@@ -9743,7 +8701,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return undefined;
         }
         const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(builtInListOrSet));
-        if (!(0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, builtInListOrSet, inferenceContext.expectedType, typeVarContext, getTypeVarScopesForNode(node))) {
+        if (!(0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, builtInListOrSet, inferenceContext.expectedType, typeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node))) {
             return undefined;
         }
         const specializedListOrSet = (0, typeUtils_1.applySolvedTypeVars)(types_1.ClassType.cloneAsInstantiable(builtInListOrSet), typeVarContext);
@@ -9776,10 +8734,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 verifySetEntryOrDictKeyIsHashable(entry, entryTypeResult.type, /* isDictKey */ false);
             }
         });
-        const isExpectedTypeListOrSet = (0, types_1.isClassInstance)(inferenceContext.expectedType) &&
+        const isTypeInvariant = (0, types_1.isClassInstance)(inferenceContext.expectedType) &&
             types_1.ClassType.isBuiltIn(inferenceContext.expectedType, builtInClassName);
-        const specializedEntryType = inferTypeArgFromExpectedType(expectedEntryType, entryTypes, 
-        /* isNarrowable */ !isExpectedTypeListOrSet);
+        const specializedEntryType = inferTypeArgFromExpectedType((0, typeUtils_1.makeInferenceContext)(expectedEntryType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext), entryTypes, !isTypeInvariant);
         if (!specializedEntryType) {
             return { type: types_1.UnknownType.create(), isIncomplete, typeErrors: true, expectedTypeDiagAddendum };
         }
@@ -9862,77 +8819,33 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message + diag.getString(), entry);
         }
     }
-    function inferTypeArgFromExpectedType(expectedType, entryTypes, isNarrowable) {
-        let targetTypeVar;
-        let useSynthesizedTypeVar = false;
-        // If the expected type is a TypeVar, use it as a target to find
-        // a common (narrowest) type among the entry types.
-        if ((0, types_1.isTypeVar)(expectedType)) {
-            if (expectedType.details.isParamSpec || expectedType.details.isVariadic) {
-                return undefined;
-            }
-            targetTypeVar = expectedType;
-        }
-        else {
-            // Synthesize a temporary bound type var. We will attempt to assign all list
-            // entries to this type var, possibly narrowing the type in the process.
-            targetTypeVar = types_1.TypeVarType.createInstance('__typeArg');
-            targetTypeVar.details.isSynthesized = true;
-            targetTypeVar.details.boundType = makeTopLevelTypeVarsConcrete(expectedType);
-            // Use a dummy scope ID. It needs to be a non-empty string.
-            targetTypeVar.scopeId = '__typeArgScopeId';
-            useSynthesizedTypeVar = true;
-        }
-        // First, try to assign entries with their literal values stripped.
-        // The only time we don't want to strip them is if the expected
-        // type explicitly includes literals.
-        let typeVarContext = new typeVarContext_1.TypeVarContext(targetTypeVar.scopeId);
-        if (useSynthesizedTypeVar) {
-            typeVarContext.setTypeVarType(targetTypeVar, isNarrowable ? undefined : expectedType, 
-            /* narrowBoundNoLiterals */ undefined, expectedType);
-        }
-        if (entryTypes.every((entryType) => assignType(targetTypeVar, stripLiteralValue(entryType), /* diag */ undefined, typeVarContext))) {
-            return (0, typeUtils_1.applySolvedTypeVars)(targetTypeVar, typeVarContext);
-        }
-        // Allocate a fresh typeVarContext before we try again with literals not stripped.
-        typeVarContext = new typeVarContext_1.TypeVarContext(targetTypeVar.scopeId);
-        if (useSynthesizedTypeVar) {
-            typeVarContext.setTypeVarType(targetTypeVar, isNarrowable ? undefined : expectedType, 
-            /* narrowBoundNoLiterals */ undefined, expectedType);
-        }
-        if (entryTypes.every((entryType) => assignType(targetTypeVar, entryType, /* diag */ undefined, typeVarContext))) {
-            return (0, typeUtils_1.applySolvedTypeVars)(targetTypeVar, typeVarContext);
+    function inferTypeArgFromExpectedType(inferenceContext, entryTypes, isNarrowable) {
+        var _a;
+        // If the expected type is Any, the resulting type becomes Any.
+        if ((0, types_1.isAnyOrUnknown)(inferenceContext.expectedType)) {
+            return inferenceContext.expectedType;
         }
-        return undefined;
-    }
-    function getTypeOfTernary(node, flags, inferenceContext) {
-        getTypeOfExpression(node.testExpression);
-        const typesToCombine = [];
-        let isIncomplete = false;
-        let typeErrors = false;
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-        const constExprValue = (0, staticExpressions_1.evaluateStaticBoolExpression)(node.testExpression, fileInfo.executionEnvironment, fileInfo.definedConstants);
-        if (constExprValue !== false && isNodeReachable(node.ifExpression)) {
-            const ifType = getTypeOfExpression(node.ifExpression, flags, inferenceContext);
-            typesToCombine.push(ifType.type);
-            if (ifType.isIncomplete) {
-                isIncomplete = true;
-            }
-            if (ifType.typeErrors) {
-                typeErrors = true;
+        const typeVarContext = (_a = inferenceContext.typeVarContext) === null || _a === void 0 ? void 0 : _a.clone();
+        let isCompatible = true;
+        entryTypes.forEach((entryType) => {
+            if (isCompatible &&
+                !assignType(inferenceContext.expectedType, entryType, /* diag */ undefined, typeVarContext)) {
+                isCompatible = false;
             }
+        });
+        if (!isCompatible) {
+            return undefined;
         }
-        if (constExprValue !== true && isNodeReachable(node.elseExpression)) {
-            const elseType = getTypeOfExpression(node.elseExpression, flags, inferenceContext);
-            typesToCombine.push(elseType.type);
-            if (elseType.isIncomplete) {
-                isIncomplete = true;
-            }
-            if (elseType.typeErrors) {
-                typeErrors = true;
-            }
+        if (isNarrowable && entryTypes.length > 0) {
+            const combinedTypes = (0, types_1.combineTypes)(entryTypes);
+            return (0, typeUtils_1.containsLiteralType)(inferenceContext.expectedType)
+                ? combinedTypes
+                : stripLiteralValue(combinedTypes);
         }
-        return { type: (0, types_1.combineTypes)(typesToCombine), isIncomplete, typeErrors };
+        if (typeVarContext) {
+            return (0, typeUtils_1.applySolvedTypeVars)(inferenceContext.expectedType, typeVarContext);
+        }
+        return inferenceContext.expectedType;
     }
     function getTypeOfYield(node) {
         let expectedYieldType;
@@ -9962,33 +8875,31 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return { type: sentType || types_1.UnknownType.create(), isIncomplete };
     }
     function getTypeOfYieldFrom(node) {
-        var _a, _b;
         const yieldFromTypeResult = getTypeOfExpression(node.expression);
         const yieldFromType = yieldFromTypeResult.type;
-        let generatorTypeArgs = (0, typeUtils_1.getGeneratorTypeArgs)(yieldFromType);
-        let returnedType;
-        // Is the expression a Generator type?
-        if (generatorTypeArgs) {
-            returnedType = generatorTypeArgs.length >= 2 ? generatorTypeArgs[2] : types_1.UnknownType.create();
-        }
-        else if ((0, types_1.isClassInstance)(yieldFromType) && types_1.ClassType.isBuiltIn(yieldFromType, 'Coroutine')) {
+        const returnedType = (0, typeUtils_1.mapSubtypes)(yieldFromType, (yieldFromSubtype) => {
+            var _a, _b;
+            // Is the expression a Generator type?
+            let generatorTypeArgs = (0, typeUtils_1.getGeneratorTypeArgs)(yieldFromSubtype);
+            if (generatorTypeArgs) {
+                return generatorTypeArgs.length >= 2 ? generatorTypeArgs[2] : types_1.UnknownType.create();
+            }
             // Handle old-style (pre-await) Coroutines as a special case.
-            returnedType = types_1.UnknownType.create();
-        }
-        else {
+            if ((0, types_1.isClassInstance)(yieldFromSubtype) && types_1.ClassType.isBuiltIn(yieldFromSubtype, 'Coroutine')) {
+                return types_1.UnknownType.create();
+            }
+            // Handle simple iterables.
             const iterableType = (_b = (_a = getTypeOfIterable(yieldFromTypeResult, /* isAsync */ false, node)) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
             // Does the iterable return a Generator?
             generatorTypeArgs = (0, typeUtils_1.getGeneratorTypeArgs)(iterableType);
-            if (generatorTypeArgs) {
-                returnedType = generatorTypeArgs.length >= 2 ? generatorTypeArgs[2] : types_1.UnknownType.create();
-            }
-        }
-        return { type: returnedType || types_1.UnknownType.create() };
+            return generatorTypeArgs && generatorTypeArgs.length >= 2 ? generatorTypeArgs[2] : types_1.UnknownType.create();
+        });
+        return { type: returnedType };
     }
     function getTypeOfLambda(node, inferenceContext) {
         let isIncomplete = !!(inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete);
         const functionType = types_1.FunctionType.createInstance('', '', '', 131072 /* PartiallyEvaluated */);
-        functionType.details.typeVarScopeId = getScopeIdForNode(node);
+        functionType.details.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(node);
         // Pre-cache the incomplete function type in case the evaluation of the
         // lambda depends on itself.
         writeTypeCache(node, { type: functionType, isIncomplete: true }, 0 /* None */);
@@ -10077,33 +8988,31 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 type: types_1.UnknownType.create(),
             });
         }
-        const expectedReturnType = expectedFunctionType
+        let expectedReturnType = expectedFunctionType
             ? getFunctionEffectiveReturnType(expectedFunctionType)
             : undefined;
+        if (expectedReturnType && (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext)) {
+            expectedReturnType = (0, typeUtils_1.applySolvedTypeVars)(expectedReturnType, inferenceContext.typeVarContext);
+        }
         // If we're speculatively evaluating the lambda, create another speculative
         // evaluation scope for the return expression and do not allow retention
         // of the cached types.
         const inferLambdaReturnType = () => {
             const returnTypeResult = getTypeOfExpression(node.expression, 
-            /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedReturnType));
+            /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedReturnType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
             functionType.inferredReturnType = returnTypeResult.type;
             if (returnTypeResult.isIncomplete) {
                 isIncomplete = true;
             }
         };
-        if (speculativeTypeTracker.isSpeculative(node) || (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete)) {
-            // We need to set allowCacheRetention to false because we don't want to
-            // cache the type of the lambda return expression because it depends on
-            // the parameter types that we set above, and the speculative type cache
-            // doesn't know about that context.
-            useSpeculativeMode(node.expression, () => {
-                inferLambdaReturnType();
-            }, 
-            /* allowCacheRetention */ false);
-        }
-        else {
+        // We need to set allowCacheRetention to false because we don't want to
+        // cache the type of the lambda return expression because it depends on
+        // the parameter types that we set above, and the speculative type cache
+        // doesn't know about that context.
+        useSpeculativeMode(isSpeculativeModeInUse(node) || (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete) ? node.expression : undefined, () => {
             inferLambdaReturnType();
-        }
+        }, 
+        /* allowCacheRetention */ false);
         // Mark the function type as no longer being evaluated.
         functionType.details.flags &= ~131072 /* PartiallyEvaluated */;
         return { type: functionType, isIncomplete };
@@ -10196,7 +9105,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Evaluate the test expression to validate it and mark symbols
             // as referenced. Don't bother doing this if we're in speculative
             // mode because it doesn't affect the element type.
-            if (!speculativeTypeTracker.isSpeculative(node.testExpression)) {
+            if (!isSpeculativeModeInUse(node.testExpression)) {
                 getTypeOfExpression(node.testExpression);
             }
         }
@@ -10263,7 +9172,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getTypeOfSlice(node) {
         // Evaluate the expressions to report errors and record symbol
         // references. We can skip this if we're executing speculatively.
-        if (!speculativeTypeTracker.isSpeculative(node)) {
+        if (!isSpeculativeModeInUse(node)) {
             if (node.startValue) {
                 getTypeOfExpression(node.startValue);
             }
@@ -10336,7 +9245,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const functionType = types_1.FunctionType.createInstantiable(0 /* None */);
         types_1.TypeBase.setSpecialForm(functionType);
         functionType.details.declaredReturnType = types_1.UnknownType.create();
-        functionType.details.typeVarScopeId = getScopeIdForNode(errorNode);
+        functionType.details.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(errorNode);
         if (typeArgs && typeArgs.length > 0) {
             if (typeArgs[0].typeList) {
                 const typeList = typeArgs[0].typeList;
@@ -11030,7 +9939,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }), errorNode);
         }
         const fileInfo = AnalyzerNodeInfo.getFileInfo(name);
-        const typeAliasScopeId = getScopeIdForNode(name);
+        const typeAliasScopeId = ParseTreeUtils.getScopeIdForNode(name);
         const boundTypeVars = typeParameters.filter((typeVar) => typeVar.scopeId !== typeAliasScopeId && typeVar.scopeType === 0 /* Class */);
         if (boundTypeVars.length > 0) {
             addError(localize_1.Localizer.Diagnostic.genericTypeAliasBoundTypeVar().format({
@@ -11251,7 +10160,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     typeAliasTypeVar = types_1.TypeVarType.createInstantiable(`__type_alias_${typeAliasNameNode.value}`);
                     typeAliasTypeVar.details.isSynthesized = true;
                     typeAliasTypeVar.details.recursiveTypeAliasName = typeAliasNameNode.value;
-                    const scopeId = getScopeIdForNode(typeAliasNameNode);
+                    const scopeId = ParseTreeUtils.getScopeIdForNode(typeAliasNameNode);
                     typeAliasTypeVar.details.recursiveTypeAliasScopeId = scopeId;
                     typeAliasTypeVar.scopeId = scopeId;
                     // Write the type back to the type cache. It will be replaced below.
@@ -11360,7 +10269,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const typeAliasTypeVar = types_1.TypeVarType.createInstantiable(`__type_alias_${node.name.value}`);
         typeAliasTypeVar.details.isSynthesized = true;
         typeAliasTypeVar.details.recursiveTypeAliasName = node.name.value;
-        const scopeId = getScopeIdForNode(node.name);
+        const scopeId = ParseTreeUtils.getScopeIdForNode(node.name);
         typeAliasTypeVar.details.recursiveTypeAliasScopeId = scopeId;
         typeAliasTypeVar.scopeId = scopeId;
         // Write the type to the type cache. It will be replaced below.
@@ -11403,7 +10312,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (isTypeCached(node)) {
             return;
         }
-        const destTypeResult = getTypeOfAugmentedAssignment(node, /* inferenceContext */ undefined);
+        const destTypeResult = (0, operations_1.getTypeOfAugmentedAssignment)(evaluatorInterface, node, /* inferenceContext */ undefined);
         writeTypeCache(node, destTypeResult, 0 /* None */);
     }
     function getPseudoGenericTypeVarName(paramName) {
@@ -11449,7 +10358,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         /* typeSourceId */ 0, 
         /* declaredMetaclass */ undefined, 
         /* effectiveMetaclass */ undefined, ParseTreeUtils.getDocString(node.suite.statements));
-        classType.details.typeVarScopeId = getScopeIdForNode(node);
+        classType.details.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(node);
         // Some classes refer to themselves within type arguments used within
         // base classes. We'll register the partially-constructed class type
         // to allow these to be resolved.
@@ -11766,9 +10675,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             classType.details.typeParameters = genericParams.map((param) => {
                                 const typeVar = types_1.TypeVarType.createInstance(getPseudoGenericTypeVarName(param.name.value));
                                 typeVar.details.isSynthesized = true;
-                                typeVar.scopeId = getScopeIdForNode(initDeclNode);
+                                typeVar.scopeId = ParseTreeUtils.getScopeIdForNode(initDeclNode);
                                 typeVar.details.boundType = types_1.UnknownType.create();
-                                return types_1.TypeVarType.cloneForScopeId(typeVar, getScopeIdForNode(node), node.name.value, 0 /* Class */);
+                                return types_1.TypeVarType.cloneForScopeId(typeVar, ParseTreeUtils.getScopeIdForNode(node), node.name.value, 0 /* Class */);
                             });
                         }
                     }
@@ -11898,11 +10807,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         writeTypeCache(node.name, { type: classType }, 0 /* None */);
         // Update the decorated class type.
         writeTypeCache(node, { type: decoratedType }, 0 /* None */);
-        // Stash away a reference to the UnionType class if we encounter it.
-        // There's no easy way to otherwise reference it.
-        if (types_1.ClassType.isBuiltIn(classType, 'UnionType')) {
-            unionType = types_1.ClassType.cloneAsInstance(classType);
-        }
         // Validate that arguments passed to `__init_subclass__` are of the correct type.
         // Defer this if the metaclass calculation is deferred.
         if (!isMetaclassDeferred) {
@@ -12257,11 +11161,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                         argument: arg,
                                         errorNode: (_b = arg.valueExpression) !== null && _b !== void 0 ? _b : errorNode,
                                     };
-                                    validateArgType(argParam, new typeVarContext_1.TypeVarContext(), signatureTracker, { type: newMethodType }, 
-                                    /* skipUnknownCheck */ true, 
-                                    /* skipOverloadArg */ true, 
-                                    /* useNarrowBoundOnly */ false, 
-                                    /* conditionFilter */ undefined);
+                                    validateArgType(argParam, new typeVarContext_1.TypeVarContext(), signatureTracker, { type: newMethodType }, { skipUnknownArgCheck: true, skipOverloadArg: true });
                                     paramMap.delete(arg.name.value);
                                 }
                                 else {
@@ -12341,10 +11241,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             functionFlags |= 512 /* Async */;
         }
         const functionType = types_1.FunctionType.createInstance(node.name.value, getFunctionFullName(node, fileInfo.moduleName, node.name.value), fileInfo.moduleName, functionFlags | 131072 /* PartiallyEvaluated */, ParseTreeUtils.getDocString(node.suite.statements));
-        functionType.details.typeVarScopeId = getScopeIdForNode(node);
+        functionType.details.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(node);
         if (node.name.value === '__init__' || node.name.value === '__new__') {
             if (containingClassNode) {
-                functionType.details.constructorTypeVarScopeId = getScopeIdForNode(containingClassNode);
+                functionType.details.constructorTypeVarScopeId = ParseTreeUtils.getScopeIdForNode(containingClassNode);
             }
         }
         if (fileInfo.isBuiltInStubFile || fileInfo.isTypingStubFile || fileInfo.isTypingExtensionsStubFile) {
@@ -13681,9 +12581,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         (0, debug_1.assert)(aliasDecl.type === 8 /* Alias */);
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         // Try to resolve the alias while honoring external visibility.
-        const resolvedAliasInfo = resolveAliasDeclarationWithInfo(aliasDecl, 
-        /* resolveLocalNames */ true, 
-        /* allowExternallyHiddenAccess */ fileInfo.isStubFile);
+        const resolvedAliasInfo = resolveAliasDeclarationWithInfo(aliasDecl, /* resolveLocalNames */ true, {
+            allowExternallyHiddenAccess: fileInfo.isStubFile,
+        });
         if (!resolvedAliasInfo) {
             return undefined;
         }
@@ -14696,10 +13596,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             throw e;
         }
     }
-    // Disables recording of errors and warnings and disables
-    // any caching of types, under the assumption that we're
-    // performing speculative evaluations.
+    // Disables recording of errors and warnings and disables any caching of
+    // types, under the assumption that we're performing speculative evaluations.
+    // If speculativeNode is undefined, speculative mode is not used. This is
+    // useful in cases where we conditionally want to use speculative mode.
     function useSpeculativeMode(speculativeNode, callback, allowCacheRetention = true) {
+        if (!speculativeNode) {
+            return callback();
+        }
         speculativeTypeTracker.enterSpeculativeContext(speculativeNode, allowCacheRetention);
         try {
             const result = callback();
@@ -14726,6 +13630,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             throw e;
         }
     }
+    // Indicates whether the specified node is within a context that
+    // is currently being evaluated speculative. If node is undefined,
+    // returns true if any node is being evaluated speculatively.
+    function isSpeculativeModeInUse(node) {
+        return speculativeTypeTracker.isSpeculative(node);
+    }
     function getDeclarationFromFunctionNamedParameter(type, paramName) {
         if ((0, types_1.isFunction)(type)) {
             if (type.details.declaration) {
@@ -15155,15 +14065,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 (0, debug_1.assert)(scopeNode.nodeType === 77 /* TypeAlias */);
                 scopeType = 2 /* TypeAlias */;
             }
-            typeVar = types_1.TypeVarType.cloneForScopeId(typeVar, getScopeIdForNode(scopeNode.nodeType === 77 /* TypeAlias */ ? scopeNode.name : scopeNode), scopeNode.name.value, scopeType);
+            typeVar = types_1.TypeVarType.cloneForScopeId(typeVar, ParseTreeUtils.getScopeIdForNode(scopeNode.nodeType === 77 /* TypeAlias */ ? scopeNode.name : scopeNode), scopeNode.name.value, scopeType);
         }
         return typeVar;
     }
     function getInferredTypeOfDeclaration(symbol, decl) {
         var _a, _b, _c;
-        const resolvedDecl = resolveAliasDeclaration(decl, 
-        /* resolveLocalNames */ true, 
-        /* allowExternallyHiddenAccess */ AnalyzerNodeInfo.getFileInfo(decl.node).isStubFile);
+        const resolvedDecl = resolveAliasDeclaration(decl, /* resolveLocalNames */ true, {
+            allowExternallyHiddenAccess: AnalyzerNodeInfo.getFileInfo(decl.node).isStubFile,
+        });
         // We couldn't resolve the alias. Substitute an unknown
         // type in this case.
         if (!resolvedDecl) {
@@ -15395,12 +14305,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // associated with that symbol. It does this recursively if necessary. If a symbol
     // lookup fails, undefined is returned. If resolveLocalNames is true, the method
     // resolves aliases through local renames ("as" clauses found in import statements).
-    function resolveAliasDeclaration(declaration, resolveLocalNames, allowExternallyHiddenAccess = false) {
-        var _a;
-        return (_a = (0, declarationUtils_1.resolveAliasDeclaration)(importLookup, declaration, resolveLocalNames, allowExternallyHiddenAccess)) === null || _a === void 0 ? void 0 : _a.declaration;
+    function resolveAliasDeclaration(declaration, resolveLocalNames, options) {
+        var _a, _b, _c;
+        return (_c = (0, declarationUtils_1.resolveAliasDeclaration)(importLookup, declaration, {
+            resolveLocalNames,
+            allowExternallyHiddenAccess: (_a = options === null || options === void 0 ? void 0 : options.allowExternallyHiddenAccess) !== null && _a !== void 0 ? _a : false,
+            skipFileNeededCheck: (_b = options === null || options === void 0 ? void 0 : options.skipFileNeededCheck) !== null && _b !== void 0 ? _b : false,
+        })) === null || _c === void 0 ? void 0 : _c.declaration;
     }
-    function resolveAliasDeclarationWithInfo(declaration, resolveLocalNames, allowExternallyHiddenAccess = false) {
-        return (0, declarationUtils_1.resolveAliasDeclaration)(importLookup, declaration, resolveLocalNames, allowExternallyHiddenAccess);
+    function resolveAliasDeclarationWithInfo(declaration, resolveLocalNames, options) {
+        var _a, _b;
+        return (0, declarationUtils_1.resolveAliasDeclaration)(importLookup, declaration, {
+            resolveLocalNames,
+            allowExternallyHiddenAccess: (_a = options === null || options === void 0 ? void 0 : options.allowExternallyHiddenAccess) !== null && _a !== void 0 ? _a : false,
+            skipFileNeededCheck: (_b = options === null || options === void 0 ? void 0 : options.skipFileNeededCheck) !== null && _b !== void 0 ? _b : false,
+        });
     }
     // Returns the type of the symbol. If the type is explicitly declared, that type
     // is returned. If not, the type is inferred from assignments to the symbol. All
@@ -15523,9 +14442,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             if (considerDecl) {
-                const resolvedDecl = (_a = resolveAliasDeclaration(decl, 
-                /* resolveLocalNames */ true, 
-                /* allowExternallyHiddenAccess */ AnalyzerNodeInfo.getFileInfo(decl.node).isStubFile)) !== null && _a !== void 0 ? _a : decl;
+                const resolvedDecl = (_a = resolveAliasDeclaration(decl, /* resolveLocalNames */ true, {
+                    allowExternallyHiddenAccess: AnalyzerNodeInfo.getFileInfo(decl.node).isStubFile,
+                })) !== null && _a !== void 0 ? _a : decl;
                 const isExplicitTypeAlias = isExplicitTypeAliasDeclaration(resolvedDecl);
                 const isTypeAlias = isExplicitTypeAlias || isPossibleTypeAliasOrTypedDict(resolvedDecl);
                 if (isExplicitTypeAlias) {
@@ -15572,7 +14491,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 }
                             }
                             typesToCombine.push(type);
-                            if (speculativeTypeTracker.isSpeculative(decl.node)) {
+                            if (isSpeculativeModeInUse(decl.node)) {
                                 includesSpeculativeResult = true;
                             }
                         }
@@ -16239,6 +15158,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // specified inheritance chain, taking into account its type arguments.
     function assignClassWithTypeArgs(destType, srcType, inheritanceChain, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
         let curSrcType = srcType;
+        let prevSrcType;
         let curDestTypeVarContext = destTypeVarContext;
         let effectiveFlags = flags;
         inferTypeParameterVarianceForClass(destType);
@@ -16268,7 +15188,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // If this isn't the first time through the loop, specialize
             // for the next ancestor in the chain.
             if (ancestorIndex < inheritanceChain.length - 1) {
-                curSrcType = (0, typeUtils_1.specializeForBaseClass)(curSrcType, ancestorType);
+                // If the curSrcType is a NamedTuple and the ancestorType is a tuple,
+                // we need to handle this as a special case because the NamedTuple may
+                // include typeParams from its parent class.
+                let effectiveCurSrcType = curSrcType;
+                if (types_1.ClassType.isBuiltIn(curSrcType, 'NamedTuple') &&
+                    types_1.ClassType.isBuiltIn(ancestorType, 'tuple') &&
+                    prevSrcType) {
+                    effectiveCurSrcType = prevSrcType;
+                }
+                curSrcType = (0, typeUtils_1.specializeForBaseClass)(effectiveCurSrcType, ancestorType);
             }
             // Handle built-in types that support arbitrary numbers
             // of type parameters like Tuple.
@@ -16291,6 +15220,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Allocate a new type var map for the next time through the loop.
             curDestTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(ancestorType));
             effectiveFlags &= ~8 /* SkipSolveTypeVars */;
+            prevSrcType = curSrcType;
         }
         if (destType.typeArguments) {
             // If the dest type is specialized, make sure the specialized source
@@ -16623,11 +15553,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             return true;
         }
-        // Handle the special case where the expression is an actual
-        // UnionType special form.
-        if ((0, types_1.isUnion)(srcType) && types_1.TypeBase.isSpecialForm(srcType)) {
-            srcType = unionType || objectType || types_1.AnyType.create();
-        }
         if ((0, types_1.isUnion)(destType)) {
             if ((0, types_1.isUnion)(srcType)) {
                 if (assignFromUnionType(destType, srcType, 
@@ -16854,7 +15779,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             // If it's a class, use the constructor for type compatibility checking.
             if ((0, types_1.isInstantiableClass)(concreteSrcType) && concreteSrcType.literalValue === undefined) {
-                const constructor = createFunctionFromConstructor(concreteSrcType, recursionCount);
+                const constructor = (0, constructors_1.createFunctionFromConstructor)(evaluatorInterface, concreteSrcType, recursionCount);
                 if (constructor) {
                     concreteSrcType = constructor;
                 }
@@ -17301,98 +16226,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             });
         });
     }
-    // Synthesize a function that represents the constructor for this class
-    // taking into consideration the __init__ and __new__ methods.
-    function createFunctionFromConstructor(classType, recursionCount = 0) {
-        // Use the __init__ method if available. It's usually more detailed.
-        const initInfo = (0, typeUtils_1.lookUpClassMember)(classType, '__init__', 8 /* SkipInstanceVariables */ | 4 /* SkipObjectBaseClass */);
-        if (initInfo) {
-            const initType = getTypeOfMember(initInfo);
-            const objectType = types_1.ClassType.cloneAsInstance(classType);
-            const convertInitToConstructor = (initSubtype) => {
-                let constructorFunction = bindFunctionToClassOrObject(objectType, initSubtype, 
-                /* memberClass */ undefined, 
-                /* errorNode */ undefined, recursionCount);
-                if (constructorFunction) {
-                    constructorFunction = types_1.FunctionType.clone(constructorFunction);
-                    constructorFunction.details.declaredReturnType = objectType;
-                    if (constructorFunction.specializedTypes) {
-                        constructorFunction.specializedTypes.returnType = objectType;
-                    }
-                    if (!constructorFunction.details.docString && classType.details.docString) {
-                        constructorFunction.details.docString = classType.details.docString;
-                    }
-                    constructorFunction.details.flags &= ~4 /* StaticMethod */;
-                }
-                return constructorFunction;
-            };
-            if ((0, types_1.isFunction)(initType)) {
-                return convertInitToConstructor(initType);
-            }
-            else if ((0, types_1.isOverloadedFunction)(initType)) {
-                const initOverloads = [];
-                initType.overloads.forEach((overload) => {
-                    const converted = convertInitToConstructor(overload);
-                    if (converted) {
-                        initOverloads.push(converted);
-                    }
-                });
-                if (initOverloads.length === 0) {
-                    return undefined;
-                }
-                else if (initOverloads.length === 1) {
-                    return initOverloads[0];
-                }
-                return types_1.OverloadedFunctionType.create(initOverloads);
-            }
-        }
-        // Fall back on the __new__ method if __init__ isn't available.
-        const newInfo = (0, typeUtils_1.lookUpClassMember)(classType, '__new__', 8 /* SkipInstanceVariables */ | 4 /* SkipObjectBaseClass */);
-        if (newInfo) {
-            const newType = getTypeOfMember(newInfo);
-            const convertNewToConstructor = (newSubtype) => {
-                let constructorFunction = bindFunctionToClassOrObject(classType, newSubtype, 
-                /* memberClass */ undefined, 
-                /* errorNode */ undefined, recursionCount, 
-                /* treatConstructorAsClassMember */ true);
-                if (constructorFunction) {
-                    constructorFunction = types_1.FunctionType.clone(constructorFunction);
-                    if (!constructorFunction.details.docString && classType.details.docString) {
-                        constructorFunction.details.docString = classType.details.docString;
-                    }
-                    constructorFunction.details.flags &= ~(4 /* StaticMethod */ | 1 /* ConstructorMethod */);
-                }
-                return constructorFunction;
-            };
-            if ((0, types_1.isFunction)(newType)) {
-                return convertNewToConstructor(newType);
-            }
-            else if ((0, types_1.isOverloadedFunction)(newType)) {
-                const newOverloads = [];
-                newType.overloads.forEach((overload) => {
-                    const converted = convertNewToConstructor(overload);
-                    if (converted) {
-                        newOverloads.push(converted);
-                    }
-                });
-                if (newOverloads.length === 0) {
-                    return undefined;
-                }
-                else if (newOverloads.length === 1) {
-                    return newOverloads[0];
-                }
-                return types_1.OverloadedFunctionType.create(newOverloads);
-            }
-        }
-        // Return a generic constructor.
-        const constructorFunction = types_1.FunctionType.createSynthesizedInstance('__new__', 0 /* None */);
-        constructorFunction.details.declaredReturnType = types_1.ClassType.cloneAsInstance(classType);
-        types_1.FunctionType.addDefaultParameters(constructorFunction);
-        if (!constructorFunction.details.docString && classType.details.docString) {
-            constructorFunction.details.docString = classType.details.docString;
-        }
-        return constructorFunction;
-    }
     // If the class is a protocol and it has a `__call__` method but no other methods
     // or attributes that would be incompatible with a function, this method returns
     // the signature of the call implied by the `__call__` method. Otherwise it returns
@@ -17784,7 +16617,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             const srcParamType = srcParamInfo.type;
                             if (!destParamInfo) {
                                 if (destParamDetails.kwargsIndex === undefined && !srcParamInfo.param.hasDefault) {
-                                    if (paramDiag) {
+                                    if (paramDiag && srcParamDetails.firstKeywordOnlyIndex !== undefined) {
                                         paramDiag.addMessage(localize_1.Localizer.DiagnosticAddendum.namedParamMissingInDest().format({
                                             name: srcParamInfo.param.name,
                                         }));
@@ -18153,213 +16986,224 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const baseParamDetails = (0, parameterUtils_1.getParameterListDetails)(baseMethod);
         const overrideParamDetails = (0, parameterUtils_1.getParameterListDetails)(overrideMethod);
         let canOverride = true;
-        // Verify that we're not overriding a static, class or instance method with
-        // an incompatible type.
-        if (types_1.FunctionType.isStaticMethod(baseMethod)) {
-            if (!types_1.FunctionType.isStaticMethod(overrideMethod)) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideNotStaticMethod());
-                canOverride = false;
-            }
-        }
-        else if (types_1.FunctionType.isClassMethod(baseMethod)) {
-            if (!types_1.FunctionType.isClassMethod(overrideMethod)) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideNotClassMethod());
-                canOverride = false;
-            }
-        }
-        if (types_1.FunctionType.isInstanceMethod(baseMethod)) {
-            if (!types_1.FunctionType.isInstanceMethod(overrideMethod)) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideNotInstanceMethod());
-                canOverride = false;
-            }
-        }
-        // Verify that the positional param count matches exactly or that the override
-        // adds only params that preserve the original signature.
-        let foundParamCountMismatch = false;
-        if (overrideParamDetails.positionParamCount < baseParamDetails.positionParamCount) {
-            if (overrideParamDetails.argsIndex === undefined) {
-                foundParamCountMismatch = true;
-            }
-            else {
-                const overrideArgsType = overrideParamDetails.params[overrideParamDetails.argsIndex].type;
-                for (let i = overrideParamDetails.positionParamCount; i < baseParamDetails.positionParamCount; i++) {
-                    if (!assignType(overrideArgsType, baseParamDetails.params[i].type, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(baseMethod)), 8 /* SkipSolveTypeVars */)) {
-                        localize_1.Localizer.DiagnosticAddendum.overrideParamType().format({
-                            index: i + 1,
-                            baseType: printType(baseParamDetails.params[i].type),
-                            overrideType: printType(overrideArgsType),
-                        });
-                        canOverride = false;
-                    }
+        if (!types_1.FunctionType.shouldSkipArgsKwargsCompatibilityCheck(baseMethod) &&
+            !types_1.FunctionType.shouldSkipArgsKwargsCompatibilityCheck(overrideMethod)) {
+            // Verify that we're not overriding a static, class or instance method with
+            // an incompatible type.
+            if (types_1.FunctionType.isStaticMethod(baseMethod)) {
+                if (!types_1.FunctionType.isStaticMethod(overrideMethod)) {
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideNotStaticMethod());
+                    canOverride = false;
                 }
             }
-        }
-        else if (overrideParamDetails.positionParamCount > baseParamDetails.positionParamCount) {
-            // Verify that all of the override parameters that extend the
-            // signature are either *args, **kwargs or parameters with
-            // default values.
-            for (let i = baseParamDetails.positionParamCount; i < overrideParamDetails.positionParamCount; i++) {
-                const overrideParam = overrideParamDetails.params[i].param;
-                if (overrideParam.category === 0 /* Simple */ &&
-                    overrideParam.name &&
-                    !overrideParam.hasDefault) {
-                    foundParamCountMismatch = true;
+            else if (types_1.FunctionType.isClassMethod(baseMethod)) {
+                if (!types_1.FunctionType.isClassMethod(overrideMethod)) {
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideNotClassMethod());
+                    canOverride = false;
                 }
             }
-        }
-        if (foundParamCountMismatch) {
-            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overridePositionalParamCount().format({
-                baseCount: baseParamDetails.params.length,
-                overrideCount: overrideParamDetails.params.length,
-            }));
-            canOverride = false;
-        }
-        const positionalParamCount = Math.min(baseParamDetails.positionParamCount, overrideParamDetails.positionParamCount);
-        for (let i = 0; i < positionalParamCount; i++) {
-            // If the first parameter is a "self" or "cls" parameter, skip the
-            // test because these are allowed to violate the Liskov substitution
-            // principle.
-            if (i === 0) {
-                if (types_1.FunctionType.isInstanceMethod(overrideMethod) ||
-                    types_1.FunctionType.isClassMethod(overrideMethod) ||
-                    types_1.FunctionType.isConstructorMethod(overrideMethod)) {
-                    continue;
+            if (types_1.FunctionType.isInstanceMethod(baseMethod)) {
+                if (!types_1.FunctionType.isInstanceMethod(overrideMethod)) {
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideNotInstanceMethod());
+                    canOverride = false;
                 }
             }
-            const baseParam = baseParamDetails.params[i].param;
-            const overrideParam = overrideParamDetails.params[i].param;
-            if (i >= baseParamDetails.positionOnlyParamCount &&
-                !(0, symbolNameUtils_1.isPrivateOrProtectedName)(baseParam.name || '') &&
-                baseParamDetails.params[i].source !== parameterUtils_1.ParameterSource.PositionOnly &&
-                baseParam.category === 0 /* Simple */ &&
-                baseParam.name !== overrideParam.name) {
-                if (overrideParam.category === 0 /* Simple */) {
-                    if (enforceParamNames) {
-                        if (overrideParamDetails.params[i].source === parameterUtils_1.ParameterSource.PositionOnly) {
-                            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNamePositionOnly().format({
-                                index: i + 1,
-                                baseName: baseParam.name || '*',
-                            }));
-                        }
-                        else {
-                            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamName().format({
+            // Verify that the positional param count matches exactly or that the override
+            // adds only params that preserve the original signature.
+            let foundParamCountMismatch = false;
+            if (overrideParamDetails.positionParamCount < baseParamDetails.positionParamCount) {
+                if (overrideParamDetails.argsIndex === undefined) {
+                    foundParamCountMismatch = true;
+                }
+                else {
+                    const overrideArgsType = overrideParamDetails.params[overrideParamDetails.argsIndex].type;
+                    for (let i = overrideParamDetails.positionParamCount; i < baseParamDetails.positionParamCount; i++) {
+                        if (!assignType(overrideArgsType, baseParamDetails.params[i].type, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(baseMethod)), 8 /* SkipSolveTypeVars */)) {
+                            localize_1.Localizer.DiagnosticAddendum.overrideParamType().format({
                                 index: i + 1,
-                                baseName: baseParam.name || '*',
-                                overrideName: overrideParam.name || '*',
-                            }));
+                                baseType: printType(baseParamDetails.params[i].type),
+                                overrideType: printType(overrideArgsType),
+                            });
+                            canOverride = false;
                         }
-                        canOverride = false;
                     }
                 }
             }
-            else if (i < overrideParamDetails.positionOnlyParamCount &&
-                i >= baseParamDetails.positionOnlyParamCount) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNamePositionOnly().format({
-                    index: i + 1,
-                    baseName: baseParam.name || '*',
+            else if (overrideParamDetails.positionParamCount > baseParamDetails.positionParamCount) {
+                // Verify that all of the override parameters that extend the
+                // signature are either *args, **kwargs or parameters with
+                // default values.
+                for (let i = baseParamDetails.positionParamCount; i < overrideParamDetails.positionParamCount; i++) {
+                    const overrideParam = overrideParamDetails.params[i].param;
+                    if (overrideParam.category === 0 /* Simple */ &&
+                        overrideParam.name &&
+                        !overrideParam.hasDefault) {
+                        foundParamCountMismatch = true;
+                    }
+                }
+            }
+            if (foundParamCountMismatch) {
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overridePositionalParamCount().format({
+                    baseCount: baseParamDetails.params.length,
+                    overrideCount: overrideParamDetails.params.length,
                 }));
                 canOverride = false;
             }
-            else {
-                const baseParamType = baseParamDetails.params[i].type;
-                const overrideParamType = overrideParamDetails.params[i].type;
-                const baseIsSynthesizedTypeVar = (0, types_1.isTypeVar)(baseParamType) && baseParamType.details.isSynthesized;
-                const overrideIsSynthesizedTypeVar = (0, types_1.isTypeVar)(overrideParamType) && overrideParamType.details.isSynthesized;
-                if (!baseIsSynthesizedTypeVar && !overrideIsSynthesizedTypeVar) {
-                    if (baseParam.category !== overrideParam.category ||
-                        !assignType(overrideParamType, baseParamType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(baseMethod)), 8 /* SkipSolveTypeVars */)) {
-                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamType().format({
-                            index: i + 1,
-                            baseType: printType(baseParamType),
-                            overrideType: printType(overrideParamType),
-                        }));
-                        canOverride = false;
+            const positionalParamCount = Math.min(baseParamDetails.positionParamCount, overrideParamDetails.positionParamCount);
+            for (let i = 0; i < positionalParamCount; i++) {
+                // If the first parameter is a "self" or "cls" parameter, skip the
+                // test because these are allowed to violate the Liskov substitution
+                // principle.
+                if (i === 0) {
+                    if (types_1.FunctionType.isInstanceMethod(overrideMethod) ||
+                        types_1.FunctionType.isClassMethod(overrideMethod) ||
+                        types_1.FunctionType.isConstructorMethod(overrideMethod)) {
+                        continue;
                     }
                 }
-                if (baseParamDetails.params[i].param.hasDefault && !overrideParamDetails.params[i].param.hasDefault) {
-                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNoDefault().format({
+                const baseParam = baseParamDetails.params[i].param;
+                const overrideParam = overrideParamDetails.params[i].param;
+                if (i >= baseParamDetails.positionOnlyParamCount &&
+                    !(0, symbolNameUtils_1.isPrivateOrProtectedName)(baseParam.name || '') &&
+                    baseParamDetails.params[i].source !== parameterUtils_1.ParameterSource.PositionOnly &&
+                    baseParam.category === 0 /* Simple */ &&
+                    baseParam.name !== overrideParam.name) {
+                    if (overrideParam.category === 0 /* Simple */) {
+                        if (enforceParamNames) {
+                            if (overrideParamDetails.params[i].source === parameterUtils_1.ParameterSource.PositionOnly) {
+                                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNamePositionOnly().format({
+                                    index: i + 1,
+                                    baseName: baseParam.name || '*',
+                                }));
+                            }
+                            else {
+                                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamName().format({
+                                    index: i + 1,
+                                    baseName: baseParam.name || '*',
+                                    overrideName: overrideParam.name || '*',
+                                }));
+                            }
+                            canOverride = false;
+                        }
+                    }
+                }
+                else if (i < overrideParamDetails.positionOnlyParamCount &&
+                    i >= baseParamDetails.positionOnlyParamCount) {
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNamePositionOnly().format({
                         index: i + 1,
+                        baseName: baseParam.name || '*',
                     }));
                     canOverride = false;
                 }
-            }
-        }
-        // Check for a *args match.
-        if (baseParamDetails.argsIndex !== undefined) {
-            if (overrideParamDetails.argsIndex === undefined) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNameMissing().format({
-                    name: (_a = baseParamDetails.params[baseParamDetails.argsIndex].param.name) !== null && _a !== void 0 ? _a : '?',
-                }));
-                canOverride = false;
-            }
-            else {
-                const overrideParamType = overrideParamDetails.params[overrideParamDetails.argsIndex].type;
-                const baseParamType = baseParamDetails.params[baseParamDetails.argsIndex].type;
-                if (!assignType(overrideParamType, baseParamType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), 
-                /* srcTypeVarContext */ undefined, 8 /* SkipSolveTypeVars */)) {
-                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamKeywordType().format({
-                        name: (_b = overrideParamDetails.params[overrideParamDetails.argsIndex].param.name) !== null && _b !== void 0 ? _b : '?',
-                        baseType: printType(baseParamType),
-                        overrideType: printType(overrideParamType),
-                    }));
-                    canOverride = false;
+                else {
+                    const baseParamType = baseParamDetails.params[i].type;
+                    const overrideParamType = overrideParamDetails.params[i].type;
+                    const baseIsSynthesizedTypeVar = (0, types_1.isTypeVar)(baseParamType) && baseParamType.details.isSynthesized;
+                    const overrideIsSynthesizedTypeVar = (0, types_1.isTypeVar)(overrideParamType) && overrideParamType.details.isSynthesized;
+                    if (!baseIsSynthesizedTypeVar && !overrideIsSynthesizedTypeVar) {
+                        if (baseParam.category !== overrideParam.category ||
+                            !assignType(overrideParamType, baseParamType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(baseMethod)), 8 /* SkipSolveTypeVars */)) {
+                            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamType().format({
+                                index: i + 1,
+                                baseType: printType(baseParamType),
+                                overrideType: printType(overrideParamType),
+                            }));
+                            canOverride = false;
+                        }
+                    }
+                    if (baseParamDetails.params[i].param.hasDefault &&
+                        !overrideParamDetails.params[i].param.hasDefault) {
+                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNoDefault().format({
+                            index: i + 1,
+                        }));
+                        canOverride = false;
+                    }
                 }
             }
-        }
-        // Now check any keyword-only parameters.
-        const baseKwOnlyParams = baseParamDetails.params.filter((paramInfo) => paramInfo.source === parameterUtils_1.ParameterSource.KeywordOnly &&
-            paramInfo.param.category === 0 /* Simple */);
-        const overrideWkOnlyParams = overrideParamDetails.params.filter((paramInfo) => paramInfo.source === parameterUtils_1.ParameterSource.KeywordOnly &&
-            paramInfo.param.category === 0 /* Simple */);
-        baseKwOnlyParams.forEach((paramInfo) => {
-            var _a, _b, _c;
-            const overrideParamInfo = overrideWkOnlyParams.find((pi) => paramInfo.param.name === pi.param.name);
-            if (!overrideParamInfo && overrideParamDetails.kwargsIndex === undefined) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNameMissing().format({
-                    name: (_a = paramInfo.param.name) !== null && _a !== void 0 ? _a : '?',
-                }));
-                canOverride = false;
-            }
-            else {
-                let targetParamType = overrideParamInfo === null || overrideParamInfo === void 0 ? void 0 : overrideParamInfo.type;
-                if (!targetParamType) {
-                    targetParamType = overrideParamDetails.params[overrideParamDetails.kwargsIndex].type;
-                }
-                if (!assignType(targetParamType, paramInfo.type, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), 
-                /* srcTypeVarContext */ undefined, 8 /* SkipSolveTypeVars */)) {
-                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamKeywordType().format({
-                        name: (_b = paramInfo.param.name) !== null && _b !== void 0 ? _b : '?',
-                        baseType: printType(paramInfo.type),
-                        overrideType: printType(targetParamType),
+            // Check for a *args match.
+            if (baseParamDetails.argsIndex !== undefined) {
+                if (overrideParamDetails.argsIndex === undefined) {
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNameMissing().format({
+                        name: (_a = baseParamDetails.params[baseParamDetails.argsIndex].param.name) !== null && _a !== void 0 ? _a : '?',
                     }));
                     canOverride = false;
                 }
-                if (overrideParamInfo) {
-                    if (paramInfo.param.hasDefault && !overrideParamInfo.param.hasDefault) {
-                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamKeywordNoDefault().format({
-                            name: (_c = overrideParamInfo.param.name) !== null && _c !== void 0 ? _c : '?',
+                else {
+                    const overrideParamType = overrideParamDetails.params[overrideParamDetails.argsIndex].type;
+                    const baseParamType = baseParamDetails.params[baseParamDetails.argsIndex].type;
+                    if (!assignType(overrideParamType, baseParamType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), 
+                    /* srcTypeVarContext */ undefined, 8 /* SkipSolveTypeVars */)) {
+                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamKeywordType().format({
+                            name: (_b = overrideParamDetails.params[overrideParamDetails.argsIndex].param.name) !== null && _b !== void 0 ? _b : '?',
+                            baseType: printType(baseParamType),
+                            overrideType: printType(overrideParamType),
                         }));
                         canOverride = false;
                     }
                 }
             }
-        });
-        // Verify that any keyword-only parameters added by the overload are compatible
-        // with the **kwargs in the base.
-        overrideWkOnlyParams.forEach((paramInfo) => {
-            var _a;
-            const baseParamInfo = baseKwOnlyParams.find((pi) => paramInfo.param.name === pi.param.name);
-            if (!baseParamInfo) {
-                if (baseParamDetails.kwargsIndex === undefined) {
-                    if (!paramInfo.param.hasDefault) {
-                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNameExtra().format({
-                            name: (_a = paramInfo.param.name) !== null && _a !== void 0 ? _a : '?',
+            // Now check any keyword-only parameters.
+            const baseKwOnlyParams = baseParamDetails.params.filter((paramInfo) => paramInfo.source === parameterUtils_1.ParameterSource.KeywordOnly &&
+                paramInfo.param.category === 0 /* Simple */);
+            const overrideWkOnlyParams = overrideParamDetails.params.filter((paramInfo) => paramInfo.source === parameterUtils_1.ParameterSource.KeywordOnly &&
+                paramInfo.param.category === 0 /* Simple */);
+            baseKwOnlyParams.forEach((paramInfo) => {
+                var _a, _b, _c;
+                const overrideParamInfo = overrideWkOnlyParams.find((pi) => paramInfo.param.name === pi.param.name);
+                if (!overrideParamInfo && overrideParamDetails.kwargsIndex === undefined) {
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNameMissing().format({
+                        name: (_a = paramInfo.param.name) !== null && _a !== void 0 ? _a : '?',
+                    }));
+                    canOverride = false;
+                }
+                else {
+                    let targetParamType = overrideParamInfo === null || overrideParamInfo === void 0 ? void 0 : overrideParamInfo.type;
+                    if (!targetParamType) {
+                        targetParamType = overrideParamDetails.params[overrideParamDetails.kwargsIndex].type;
+                    }
+                    if (!assignType(targetParamType, paramInfo.type, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), 
+                    /* srcTypeVarContext */ undefined, 8 /* SkipSolveTypeVars */)) {
+                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamKeywordType().format({
+                            name: (_b = paramInfo.param.name) !== null && _b !== void 0 ? _b : '?',
+                            baseType: printType(paramInfo.type),
+                            overrideType: printType(targetParamType),
                         }));
                         canOverride = false;
                     }
+                    if (overrideParamInfo) {
+                        if (paramInfo.param.hasDefault && !overrideParamInfo.param.hasDefault) {
+                            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamKeywordNoDefault().format({
+                                name: (_c = overrideParamInfo.param.name) !== null && _c !== void 0 ? _c : '?',
+                            }));
+                            canOverride = false;
+                        }
+                    }
                 }
+            });
+            // Verify that any keyword-only parameters added by the overload are compatible
+            // with the **kwargs in the base.
+            overrideWkOnlyParams.forEach((paramInfo) => {
+                var _a;
+                const baseParamInfo = baseKwOnlyParams.find((pi) => paramInfo.param.name === pi.param.name);
+                if (!baseParamInfo) {
+                    if (baseParamDetails.kwargsIndex === undefined) {
+                        if (!paramInfo.param.hasDefault) {
+                            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNameExtra().format({
+                                name: (_a = paramInfo.param.name) !== null && _a !== void 0 ? _a : '?',
+                            }));
+                            canOverride = false;
+                        }
+                    }
+                }
+            });
+            // Verify that if the base method has a **kwargs parameter, the override does too.
+            if (baseParamDetails.kwargsIndex !== undefined && overrideParamDetails.kwargsIndex === undefined) {
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.kwargsParamMissing().format({
+                    paramName: baseParamDetails.params[baseParamDetails.kwargsIndex].param.name,
+                }));
+                canOverride = false;
             }
-        });
+        }
         // Now check the return type.
         const baseReturnType = getFunctionEffectiveReturnType(baseMethod);
         const overrideReturnType = getFunctionEffectiveReturnType(overrideMethod);
@@ -18808,7 +17652,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         getGetterTypeFromProperty,
         getTypeOfArgument,
         markNamesAccessed,
-        getScopeIdForNode,
         makeTopLevelTypeVarsConcrete,
         mapSubtypesExpandTypeVars,
         lookUpSymbolRecursive,
@@ -18823,6 +17666,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         getBuiltInType,
         getTypeOfMember,
         getTypeOfObjectMember,
+        getTypeOfClassMemberName,
         getBoundMethod,
         getTypeOfMagicMethodReturn,
         bindFunctionToClassOrObject,
@@ -18831,6 +17675,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         narrowConstrainedTypeVar,
         assignType,
         validateOverrideMethod,
+        validateCallArguments,
+        validateTypeArg,
         assignTypeToExpression,
         assignClassToSelf,
         getTypedDictClassType,
@@ -18857,6 +17703,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         getTypeCacheEntryCount,
         disposeEvaluator,
         useSpeculativeMode,
+        isSpeculativeModeInUse,
         setTypeForNode,
         checkForCancellation,
         printControlFlowGraph,