@zzzen/pyright-internal 1.2.0-dev.20230430 → 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,10 +5645,7 @@ 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.
@@ -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) {
@@ -5955,10 +5880,7 @@ 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 validateFunctionArgumentTypesWithContext(errorNode, lastMatch, effectiveTypeVarContext, skipUnknownArgCheck, inferenceContext);
         };
@@ -6063,331 +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 = validateConstructorMethodWithContext(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);
-                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;
-                }
-                if (!callResult.argumentErrors) {
-                    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 = validateConstructorMethodWithContext(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 validateConstructorMethodWithContext(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));
-            typeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(constructorMethodType));
-            if ((0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, types_1.ClassType.cloneAsInstance(type), expectedSubType, typeVarContext, getTypeVarScopesForNode(errorNode))) {
-                const specializedConstructor = (0, typeUtils_1.applySolvedTypeVars)(constructorMethodType, typeVarContext);
-                let callResult;
-                useSpeculativeMode(errorNode, () => {
-                    callResult = validateCallArguments(errorNode, argList, { type: specializedConstructor }, typeVarContext.clone(), skipUnknownArgCheck);
-                });
-                if (!callResult.argumentErrors) {
-                    // Call validateCallArguments again, this time without speculative
-                    // mode, so any errors are reported.
-                    callResult = validateCallArguments(errorNode, argList, { type: specializedConstructor }, typeVarContext, skipUnknownArgCheck);
-                    if (callResult.isTypeIncomplete) {
-                        isTypeIncomplete = true;
-                    }
-                    if (callResult.argumentErrors) {
-                        argumentErrors = true;
-                    }
-                    overloadsUsedForCall.push(...callResult.overloadsUsedForCall);
-                    return applyExpectedSubtypeForConstructor(type, expectedSubType, inferenceContext, typeVarContext);
-                }
-            }
-            return undefined;
-        });
-        if ((0, types_1.isNever)(returnType)) {
-            return undefined;
-        }
-        return { returnType, isTypeIncomplete, argumentErrors, overloadsUsedForCall };
-    }
-    function applyExpectedSubtypeForConstructor(type, expectedSubtype, inferenceContext, typeVarContext) {
-        var _a;
-        const specializedType = (0, typeUtils_1.applySolvedTypeVars)(types_1.ClassType.cloneAsInstance(type), typeVarContext);
-        if (!assignType(expectedSubtype, specializedType, 
-        /* diag */ undefined, 
-        /* destTypeVarContext */ (_a = inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext) === null || _a === void 0 ? void 0 : _a.clone(), 
-        /* srcTypeVarContext */ undefined)) {
-            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, inferenceContext, 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
@@ -6420,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);
                             }
                         });
@@ -6449,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
@@ -6544,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
@@ -6643,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;
@@ -7485,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
@@ -7625,7 +7222,7 @@ 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);
@@ -7820,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;
             }
@@ -7843,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;
         }
@@ -7919,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);
                 }
             });
@@ -8120,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 */);
             }
         }
@@ -8188,7 +7783,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             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 };
                     }
@@ -8695,652 +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(fileInfo.diagnosticRuleSet.reportOptionalOperand, diagnosticRules_1.DiagnosticRule.reportOptionalOperand, localize_1.Localizer.Diagnostic.noneOperator().format({
-                        operator: ParseTreeUtils.printOperator(node.operator),
-                    }), node.leftExpression);
-                }
-                else {
-                    // If neither the LHS or RHS are unions, don't include a diagnostic addendum
-                    // because it will be redundant with the main diagnostic message. The addenda
-                    // are useful only if union expansion was used for one or both operands.
-                    let diagString = '';
-                    if ((0, types_1.isUnion)(makeTopLevelTypeVarsConcrete(leftType)) ||
-                        (0, types_1.isUnion)(makeTopLevelTypeVarsConcrete(rightType))) {
-                        diagString = diag.getString();
-                    }
-                    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),
-                    }) + diagString, 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.
@@ -9415,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.
@@ -9501,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);
@@ -9763,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);
@@ -9909,35 +8847,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return inferenceContext.expectedType;
     }
-    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;
-            }
-        }
-        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;
-            }
-        }
-        return { type: (0, types_1.combineTypes)(typesToCombine), isIncomplete, typeErrors };
-    }
     function getTypeOfYield(node) {
         let expectedYieldType;
         let sentType;
@@ -9990,7 +8899,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     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 */);
@@ -10096,19 +9005,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 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 };
@@ -10201,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);
             }
         }
@@ -10268,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);
             }
@@ -10341,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;
@@ -11035,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({
@@ -11256,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.
@@ -11365,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.
@@ -11408,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) {
@@ -11454,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.
@@ -11771,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 */);
                             });
                         }
                     }
@@ -11903,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) {
@@ -12342,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) {
@@ -14697,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();
@@ -14727,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) {
@@ -15156,7 +14065,7 @@ 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;
     }
@@ -15582,7 +14491,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 }
                             }
                             typesToCombine.push(type);
-                            if (speculativeTypeTracker.isSpeculative(decl.node)) {
+                            if (isSpeculativeModeInUse(decl.node)) {
                                 includesSpeculativeResult = true;
                             }
                         }
@@ -16644,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, 
@@ -16875,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;
                 }
@@ -17322,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
@@ -18840,7 +17652,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         getGetterTypeFromProperty,
         getTypeOfArgument,
         markNamesAccessed,
-        getScopeIdForNode,
         makeTopLevelTypeVarsConcrete,
         mapSubtypesExpandTypeVars,
         lookUpSymbolRecursive,
@@ -18855,6 +17666,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         getBuiltInType,
         getTypeOfMember,
         getTypeOfObjectMember,
+        getTypeOfClassMemberName,
         getBoundMethod,
         getTypeOfMagicMethodReturn,
         bindFunctionToClassOrObject,
@@ -18863,6 +17675,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         narrowConstrainedTypeVar,
         assignType,
         validateOverrideMethod,
+        validateCallArguments,
+        validateTypeArg,
         assignTypeToExpression,
         assignClassToSelf,
         getTypedDictClassType,
@@ -18889,6 +17703,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         getTypeCacheEntryCount,
         disposeEvaluator,
         useSpeculativeMode,
+        isSpeculativeModeInUse,
         setTypeForNode,
         checkForCancellation,
         printControlFlowGraph,