@zzzen/pyright-internal 1.2.0-dev.20230430 → 1.2.0-dev.20230514

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);
@@ -512,7 +446,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
     }
     function getTypeOfExpression(node, flags = 0 /* None */, inferenceContext) {
-        var _a, _b;
+        var _a;
         // Is this type already cached?
         const cacheEntry = readTypeCacheEntry(node);
         if (cacheEntry &&
@@ -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 */: {
@@ -712,6 +646,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         writeTypeCache(node, typeResult, flags, inferenceContext, /* allowSpeculativeCaching */ true);
+        // If there was an expected type, make sure that the result type is compatible.
         if (inferenceContext &&
             !(0, types_1.isAnyOrUnknown)(inferenceContext.expectedType) &&
             !(0, types_1.isNever)(inferenceContext.expectedType)) {
@@ -719,9 +654,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (!typeResult.isIncomplete && !typeResult.expectedTypeDiagAddendum) {
                 const diag = new diagnostic_1.DiagnosticAddendum();
                 // Make sure the resulting type is assignable to the expected type.
-                // Use the "solve for scopes" of the associated typeVarContext if
-                // it is provided.
-                if (!assignType(inferenceContext.expectedType, typeResult.type, diag, new typeVarContext_1.TypeVarContext((_b = inferenceContext.typeVarContext) === null || _b === void 0 ? void 0 : _b.getSolveForScopes()))) {
+                if (!assignType(inferenceContext.expectedType, typeResult.type, diag)) {
                     typeResult.typeErrors = true;
                     typeResult.expectedTypeDiagAddendum = diag;
                     diag.addTextRange(node);
@@ -1451,12 +1384,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         const isObjectInit = !!methodType &&
                             (0, types_1.isFunction)(methodType) &&
                             methodType.details.fullName === 'builtins.object.__init__';
-                        const isSkipConstructor = !!methodType && (0, types_1.isFunction)(methodType) && types_1.FunctionType.isSkipConstructorCheck(methodType);
                         const isDefaultParams = methodType && (0, types_1.isFunction)(methodType) && types_1.FunctionType.hasDefaultParameters(methodType);
                         // If there was no `__init__` or the only `__init__` that was found was from
                         // the `object` class or accepts only default parameters(* args, ** kwargs),
                         // see if we can find a better signature from the `__new__` method.
-                        if (!methodType || isObjectInit || isSkipConstructor || isDefaultParams) {
+                        if (!methodType || isObjectInit || isDefaultParams) {
                             const constructorType = getBoundMethod(subtype, '__new__', 
                             /* recursionCount */ undefined, 
                             /* treatConstructorAsClassMember */ true);
@@ -1600,8 +1532,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if ((0, types_1.isClassInstance)(declaredType)) {
                     const setterInfo = (0, typeUtils_1.lookUpClassMember)(declaredType, '__set__');
                     const setter = setterInfo ? getTypeOfMember(setterInfo) : undefined;
-                    if (setter && (0, types_1.isFunction)(setter) && setter.details.parameters.length >= 3) {
+                    if (setterInfo && setter && (0, types_1.isFunction)(setter) && setter.details.parameters.length >= 3) {
                         declaredType = setter.details.parameters[2].type;
+                        if ((0, types_1.isClass)(setterInfo.classType)) {
+                            const typeVarMap = (0, typeUtils_1.buildTypeVarContextFromSpecializedClass)(setterInfo.classType);
+                            declaredType = (0, typeUtils_1.applySolvedTypeVars)(declaredType, typeVarMap);
+                        }
                         if ((0, types_1.isAnyOrUnknown)(declaredType)) {
                             return undefined;
                         }
@@ -1996,7 +1932,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') {
@@ -2087,7 +2023,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             else {
                 // Constrain the resulting type to match the declared type.
-                destType = narrowTypeBasedOnAssignment(declaredType, type);
+                destType = narrowTypeBasedOnAssignment(nameNode, declaredType, type);
             }
         }
         else {
@@ -2604,7 +2540,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             // is a enum because the annotated type in an enum doesn't reflect
                             // the type of the symbol.
                             if (!(0, types_1.isClassInstance)(type) || !types_1.ClassType.isEnumClass(type)) {
-                                type = narrowTypeBasedOnAssignment(annotationType, type);
+                                type = narrowTypeBasedOnAssignment(target, annotationType, type);
                             }
                         }
                     }
@@ -2658,7 +2594,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 +2672,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
     }
     function setSymbolAccessed(fileInfo, symbol, node) {
-        if (!speculativeTypeTracker.isSpeculative(node)) {
+        if (!isSpeculativeModeInUse(node)) {
             fileInfo.accessedSymbolSet.add(symbol.id);
         }
     }
@@ -3095,7 +3031,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 +3122,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) {
@@ -3294,6 +3201,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             container: typeAliasNode.name.value,
                         }), node);
                     }
+                    else {
+                        // If this is a TypeAliasType call, the recursiveTypeParameters will already
+                        // be populated, and we need to verify that the type parameter is in the
+                        // list of allowed type parameters.
+                        const allowedTypeParams = leftType.details.recursiveTypeParameters;
+                        if (allowedTypeParams) {
+                            if (!allowedTypeParams.some((param) => param.details.name === type.details.name)) {
+                                // Return the original type.
+                                return { type, isRescoped: false, foundInterveningClass: false };
+                            }
+                        }
+                    }
                     return {
                         type: types_1.TypeVarType.cloneForScopeId(type, leftType.details.recursiveTypeAliasScopeId, leftType.details.recursiveTypeAliasName, 2 /* TypeAlias */),
                         isRescoped: false,
@@ -4063,16 +3982,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // If this function is an instance member (e.g. a lambda that was
                 // assigned to an instance variable), don't perform any binding.
                 if (!isAccessedThroughObject || (memberInfo && !memberInfo.isInstanceMember)) {
-                    // Skip binding if the class appears to be a metaclass (i.e. a subclass of
-                    // `type`) because the first parameter of instance methods in a metaclass
-                    // are not `self` instances.
-                    const isMetaclass = !isAccessedThroughObject &&
-                        (0, types_1.isClass)(baseTypeClass) &&
-                        (flags & 16 /* TreatConstructorAsClassMethod */) === 0 &&
-                        baseTypeClass.details.mro.some((mroType) => (0, types_1.isClass)(mroType) && types_1.ClassType.isBuiltIn(mroType, 'type'));
-                    if (isMetaclass) {
-                        return concreteSubtype;
-                    }
                     return bindFunctionToClassOrObject(isAccessedThroughObject ? types_1.ClassType.cloneAsInstance(baseTypeClass) : baseTypeClass, concreteSubtype, memberInfo && (0, types_1.isInstantiableClass)(memberInfo.classType) ? memberInfo.classType : undefined, errorNode, 
                     /* recursionCount */ undefined, treatConstructorAsClassMember, bindToType);
                 }
@@ -5154,7 +5063,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 if (!matchingSubtype) {
                     const subtypeResult = useSpeculativeMode(node, () => {
-                        return getTypeOfTupleWithContext(node, (0, typeUtils_1.makeInferenceContext)(subtype, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
+                        return getTypeOfTupleWithContext(node, (0, typeUtils_1.makeInferenceContext)(subtype));
                     });
                     if (subtypeResult && assignType(subtype, subtypeResult.type)) {
                         matchingSubtype = subtype;
@@ -5165,7 +5074,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         let expectedTypeDiagAddendum;
         if (effectiveExpectedType) {
-            const result = getTypeOfTupleWithContext(node, (0, typeUtils_1.makeInferenceContext)(effectiveExpectedType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
+            const result = getTypeOfTupleWithContext(node, (0, typeUtils_1.makeInferenceContext)(effectiveExpectedType));
             if (result && !result.typeErrors) {
                 return result;
             }
@@ -5205,7 +5114,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);
@@ -5341,6 +5250,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             else {
+                // Check for an attempt to invoke an abstract static or class method.
+                if ((0, types_1.isFunction)(baseTypeResult.type) &&
+                    baseTypeResult.type.boundToType &&
+                    (0, types_1.isInstantiableClass)(baseTypeResult.type.boundToType) &&
+                    !baseTypeResult.type.boundToType.includeSubclasses) {
+                    if (types_1.FunctionType.isAbstractMethod(baseTypeResult.type)) {
+                        if (types_1.FunctionType.isStaticMethod(baseTypeResult.type) ||
+                            types_1.FunctionType.isClassMethod(baseTypeResult.type)) {
+                            addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.abstractMethodInvocation().format({
+                                method: baseTypeResult.type.details.name,
+                            }), node.leftExpression);
+                        }
+                    }
+                }
                 const callResult = validateCallArguments(node, argList, baseTypeResult, 
                 /* typeVarContext */ undefined, 
                 /* skipUnknownArgCheck */ false, inferenceContext);
@@ -5364,7 +5287,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 +5355,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 +5663,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 +5713,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 +5742,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 +5898,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 +6003,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 +6035,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 +6064,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 +6159,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
@@ -6572,13 +6187,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 return types_1.AnyType.create();
                             }
                             if (className === 'TypeVar') {
-                                return createTypeVarType(errorNode, argList);
+                                return createTypeVarType(errorNode, expandedSubtype, argList);
                             }
                             if (className === 'TypeVarTuple') {
-                                return createTypeVarTupleType(errorNode, argList);
+                                return createTypeVarTupleType(errorNode, expandedSubtype, argList);
                             }
                             if (className === 'ParamSpec') {
-                                return createParamSpecType(errorNode, argList);
+                                return createParamSpecType(errorNode, expandedSubtype, argList);
+                            }
+                            if (className === 'TypeAliasType') {
+                                const newTypeAlias = createTypeAliasType(errorNode, argList);
+                                if (newTypeAlias) {
+                                    return newTypeAlias;
+                                }
                             }
                             if (className === 'NamedTuple') {
                                 return (0, namedTuples_1.createNamedTupleType)(evaluatorInterface, errorNode, argList, 
@@ -6643,7 +6264,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 +7106,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
@@ -7618,18 +7239,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Prepopulate the typeVarContext based on the specialized expected type if the
             // callee has a declared return type. This will allow us to more closely match
             // the expected type if possible.
-            // If the return type is not the same as the expected type but is
-            // assignable to the expected type, determine which type arguments
-            // are needed to match the expected type.
-            if ((0, types_1.isClassInstance)(effectiveReturnType) &&
-                (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));
-                const genericReturnType = types_1.ClassType.cloneForSpecialization(effectiveReturnType, 
-                /* typeArguments */ undefined, 
-                /* isTypeArgumentExplicit */ false);
-                effectiveExpectedType = (0, typeUtils_1.applySolvedTypeVars)(genericReturnType, tempTypeVarContext);
+            // Determine which type arguments are needed to match the expected type.
+            if ((0, types_1.isClassInstance)(effectiveReturnType)) {
+                // If the return type is a class and the expected type is a union that contains
+                // that class, see if we can eliminate the other subtypes in the union.
+                if ((0, types_1.isUnion)(effectiveExpectedType)) {
+                    const filteredType = (0, typeUtils_1.mapSubtypes)(effectiveExpectedType, (subtype) => {
+                        return (0, types_1.isClassInstance)(subtype) && types_1.ClassType.isSameGenericClass(effectiveReturnType, subtype)
+                            ? subtype
+                            : undefined;
+                    });
+                    if ((0, types_1.isClassInstance)(filteredType)) {
+                        effectiveExpectedType = filteredType;
+                    }
+                }
+                if ((0, types_1.isClassInstance)(effectiveExpectedType) && !(0, types_1.isTypeSame)(effectiveReturnType, effectiveExpectedType)) {
+                    const tempTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(effectiveReturnType));
+                    (0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, effectiveReturnType, effectiveExpectedType, tempTypeVarContext, ParseTreeUtils.getTypeVarScopesForNode(errorNode));
+                    const genericReturnType = types_1.ClassType.cloneForSpecialization(effectiveReturnType, 
+                    /* typeArguments */ undefined, 
+                    /* isTypeArgumentExplicit */ false);
+                    effectiveExpectedType = (0, typeUtils_1.applySolvedTypeVars)(genericReturnType, tempTypeVarContext);
+                }
             }
             else if ((0, types_1.isFunction)(effectiveReturnType)) {
                 // If the return type is a callable and the expected type is a union that
@@ -7739,7 +7370,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         // If we skipped a overload arg during the first pass,
                         // add another pass to ensure that we handle all of the
                         // type variables.
-                        if (i === 0 && argResult.skippedOverloadArg) {
+                        if (i === 0 && (argResult.skippedOverloadArg || argResult.skippedBareTypeVarExpectedType)) {
                             passCount++;
                         }
                     });
@@ -7820,7 +7451,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (!typeVarScopeNode) {
                 break;
             }
-            const typeVarScopeId = getScopeIdForNode(typeVarScopeNode);
+            const typeVarScopeId = ParseTreeUtils.getScopeIdForNode(typeVarScopeNode);
             if (typeVarContext.hasSolveForScope(typeVarScopeId)) {
                 eliminateUnsolvedInUnions = false;
             }
@@ -7843,15 +7474,17 @@ 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;
         }
-        let specializedReturnType = (0, typeUtils_1.addConditionToType)((0, typeUtils_1.applySolvedTypeVars)(returnType, typeVarContext, {
+        let specializedReturnType = (0, typeUtils_1.applySolvedTypeVars)(returnType, typeVarContext, {
             unknownIfNotFound,
             useUnknownOverDefault: skipUnknownArgCheck,
             eliminateUnsolvedInUnions,
-        }), typeCondition);
+            applyInScopePlaceholders: true,
+        });
+        specializedReturnType = (0, typeUtils_1.addConditionToType)(specializedReturnType, typeCondition);
         // If the final return type is an unpacked tuple, turn it into a normal (unpacked) tuple.
         if ((0, types_1.isUnpackedClass)(specializedReturnType)) {
             specializedReturnType = types_1.ClassType.cloneForUnpacked(specializedReturnType, /* isUnpackedTuple */ false);
@@ -7919,7 +7552,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);
                 }
             });
@@ -7962,6 +7595,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramSpecNotBound().format({ type: printType(paramSpec) }), ((_a = argList[0]) === null || _a === void 0 ? void 0 : _a.valueExpression) || errorNode);
             return false;
         }
+        const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
         const srcTypeVarContext = new typeVarContext_1.TypeVarContext(paramSpecType.details.typeVarScopeId);
         let reportedArgError = false;
         // Build a map of all named parameters.
@@ -8024,7 +7658,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (paramType) {
                     const argResult = validateArgType({
                         paramCategory: 0 /* Simple */,
-                        paramType,
+                        paramType: (0, typeUtils_1.transformExpectedType)(paramType, liveTypeVarScopes),
                         requiresTypeVarMatching: false,
                         argument: arg,
                         errorNode: arg.valueExpression || errorNode,
@@ -8075,7 +7709,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         if (!reportedArgError) {
-            typeVarContext.applySourceContextTypeVars(srcTypeVarContext);
+            (0, typeUtils_1.applySourceContextTypeVarsToSignature)(typeVarContext, srcTypeVarContext);
         }
         return !reportedArgError;
     }
@@ -8086,14 +7720,26 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let isTypeIncomplete = !!(typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete);
         let isCompatible = true;
         const functionName = typeResult === null || typeResult === void 0 ? void 0 : typeResult.type.details.name;
+        let skippedBareTypeVarExpectedType = false;
         if (argParam.argument.valueExpression) {
             let expectedType;
-            if (!options.skipBareTypeVarExpectedType ||
-                !(0, types_1.isTypeVar)(argParam.paramType) ||
-                argParam.paramType.scopeId !== (typeResult === null || typeResult === void 0 ? void 0 : typeResult.type.details.typeVarScopeId)) {
-                expectedType = (0, typeUtils_1.applySolvedTypeVars)(argParam.paramType, typeVarContext, {
-                    useNarrowBoundOnly: !!options.useNarrowBoundOnly,
-                });
+            const isBareTypeVarExpectedType = (0, types_1.isTypeVar)(argParam.paramType) && argParam.paramType.scopeId === (typeResult === null || typeResult === void 0 ? void 0 : typeResult.type.details.typeVarScopeId);
+            if (!options.skipBareTypeVarExpectedType || !isBareTypeVarExpectedType) {
+                expectedType = argParam.paramType;
+                // If the parameter type is a function with a ParamSpec, don't apply
+                // the solved TypeVars if the typeVarContext has more than one signature.
+                // This will expand the ParamSpec into an overload, which will cause problems.
+                const skipApplySolvedTypeVars = (0, types_1.isFunction)(argParam.paramType) &&
+                    !!argParam.paramType.details.paramSpec &&
+                    typeVarContext.getSignatureContexts().length > 1;
+                if (!skipApplySolvedTypeVars) {
+                    expectedType = (0, typeUtils_1.applySolvedTypeVars)(expectedType, typeVarContext, {
+                        useNarrowBoundOnly: !!options.useNarrowBoundOnly,
+                    });
+                }
+            }
+            else {
+                skippedBareTypeVarExpectedType = true;
             }
             // If the expected type is unknown, don't use an expected type. Instead,
             // use default rules for evaluating the expression type.
@@ -8110,19 +7756,32 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         32 /* DisallowParamSpec */ |
                         64 /* DisallowTypeVarTuple */
                     : 0 /* None */;
-                const exprTypeResult = getTypeOfExpression(argParam.argument.valueExpression, flags, (0, typeUtils_1.makeInferenceContext)(expectedType, typeVarContext, !!(typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete)));
+                const exprTypeResult = getTypeOfExpression(argParam.argument.valueExpression, flags, (0, typeUtils_1.makeInferenceContext)(expectedType, !!(typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete)));
                 argType = exprTypeResult.type;
+                // If the type includes multiple instances of a generic function
+                // signature, force the type arguments for the duplicates to have
+                // unique names.
+                argType = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(argType, signatureTracker);
                 if (exprTypeResult.isIncomplete) {
                     isTypeIncomplete = true;
                 }
                 if (exprTypeResult.typeErrors) {
                     isCompatible = false;
                 }
+                else if (expectedType && (0, typeUtils_1.requiresSpecialization)(expectedType)) {
+                    // Assign the argument type back to the expected type to assign
+                    // values to any in-scope placeholder type variables.
+                    const typeVarContextClone = typeVarContext.clone();
+                    if (assignType(expectedType, argType, /* diag */ undefined, typeVarContextClone)) {
+                        typeVarContext.copyFromClone(typeVarContextClone);
+                    }
+                    else {
+                        isCompatible = false;
+                    }
+                }
                 expectedTypeDiag = exprTypeResult.expectedTypeDiagAddendum;
             }
-            if (argParam.argument &&
-                argParam.argument.name &&
-                !speculativeTypeTracker.isSpeculative(argParam.errorNode)) {
+            if (argParam.argument && argParam.argument.name && !isSpeculativeModeInUse(argParam.errorNode)) {
                 writeTypeCache(argParam.argument.name, { type: expectedType !== null && expectedType !== void 0 ? expectedType : argType, isIncomplete: isTypeIncomplete }, 0 /* None */);
             }
         }
@@ -8148,10 +7807,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
-        // If the type includes multiple instances of a generic function
-        // signature, force the type arguments for the duplicates to have
-        // unique names.
-        argType = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(argType, signatureTracker);
         // If we're assigning to a var arg dictionary with a TypeVar type,
         // strip literals before performing the assignment. This is used in
         // places like a dict constructor.
@@ -8183,14 +7838,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // an overloaded callback protocol.
         if (options.skipOverloadArg) {
             if ((0, types_1.isOverloadedFunction)(argType)) {
-                return { isCompatible, argType, isTypeIncomplete, skippedOverloadArg: true, condition };
+                return {
+                    isCompatible,
+                    argType,
+                    isTypeIncomplete,
+                    skippedOverloadArg: true,
+                    skippedBareTypeVarExpectedType,
+                    condition,
+                };
             }
             const concreteParamType = makeTopLevelTypeVarsConcrete(argParam.paramType);
             if ((0, types_1.isFunction)(concreteParamType) || (0, types_1.isOverloadedFunction)(concreteParamType)) {
                 if ((0, types_1.isInstantiableClass)(argType)) {
-                    const constructor = createFunctionFromConstructor(argType);
+                    const constructor = (0, constructors_1.createFunctionFromConstructor)(evaluatorInterface, argType);
                     if (constructor && (0, types_1.isOverloadedFunction)(constructor)) {
-                        return { isCompatible, argType, isTypeIncomplete, skippedOverloadArg: true, condition };
+                        return {
+                            isCompatible,
+                            argType,
+                            isTypeIncomplete,
+                            skippedOverloadArg: true,
+                            skippedBareTypeVarExpectedType,
+                            condition,
+                        };
                     }
                 }
                 if ((0, types_1.isClassInstance)(argType)) {
@@ -8198,7 +7867,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (callMember) {
                         const memberType = getTypeOfMember(callMember);
                         if ((0, types_1.isOverloadedFunction)(memberType)) {
-                            return { isCompatible, argType, isTypeIncomplete, skippedOverloadArg: true, condition };
+                            return {
+                                isCompatible,
+                                argType,
+                                isTypeIncomplete,
+                                skippedOverloadArg: true,
+                                skippedBareTypeVarExpectedType,
+                                condition,
+                            };
                         }
                     }
                 }
@@ -8255,7 +7931,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message + diag.getString(), argParam.errorNode, (_a = diag.getEffectiveTextRange()) !== null && _a !== void 0 ? _a : argParam.errorNode);
             }
-            return { isCompatible: false, argType, isTypeIncomplete, condition };
+            return { isCompatible: false, argType, isTypeIncomplete, skippedBareTypeVarExpectedType, condition };
         }
         if (!options.skipUnknownArgCheck) {
             const simplifiedType = (0, types_1.removeUnbound)(argType);
@@ -8311,9 +7987,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
-        return { isCompatible, argType, isTypeIncomplete, condition };
+        return { isCompatible, argType, isTypeIncomplete, skippedBareTypeVarExpectedType, condition };
     }
-    function createTypeVarType(errorNode, argList) {
+    function createTypeVarType(errorNode, classType, argList) {
         var _a, _b, _c, _d, _e, _f, _g;
         let typeVarName = '';
         let firstConstraintArg;
@@ -8386,8 +8062,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 else if (paramName === 'default') {
                     defaultValueNode = argList[i].valueExpression;
-                    const argType = (_d = (_c = argList[i].typeResult) === null || _c === void 0 ? void 0 : _c.type) !== null && _d !== void 0 ? _d : getTypeOfExpressionExpectingType(argList[i].valueExpression).type;
+                    const argType = (_d = (_c = argList[i].typeResult) === null || _c === void 0 ? void 0 : _c.type) !== null && _d !== void 0 ? _d : getTypeOfExpressionExpectingType(defaultValueNode, {
+                        allowTypeVarsWithoutScopeId: true,
+                    }).type;
                     typeVar.details.defaultType = (0, typeUtils_1.convertToInstance)(argType);
+                    const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
+                    if (!fileInfo.isStubFile &&
+                        fileInfo.executionEnvironment.pythonVersion < pythonVersion_1.PythonVersion.V3_13 &&
+                        classType.details.moduleName !== 'typing_extensions') {
+                        addError(localize_1.Localizer.Diagnostic.typeVarDefaultIllegal(), defaultValueNode);
+                    }
                 }
                 else {
                     addError(localize_1.Localizer.Diagnostic.typeVarUnknownParam().format({ name: paramName }), ((_e = argList[i].node) === null || _e === void 0 ? void 0 : _e.name) || argList[i].valueExpression || errorNode);
@@ -8433,7 +8117,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return typeVar;
     }
-    function createTypeVarTupleType(errorNode, argList) {
+    function createTypeVarTupleType(errorNode, classType, argList) {
         var _a, _b;
         let typeVarName = '';
         if (argList.length === 0) {
@@ -8459,6 +8143,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (expr) {
                         typeVar.details.defaultType = getTypeVarTupleDefaultType(expr);
                     }
+                    const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
+                    if (!fileInfo.isStubFile &&
+                        fileInfo.executionEnvironment.pythonVersion < pythonVersion_1.PythonVersion.V3_13 &&
+                        classType.details.moduleName !== 'typing_extensions') {
+                        addError(localize_1.Localizer.Diagnostic.typeVarDefaultIllegal(), expr);
+                    }
                 }
                 else {
                     addError(localize_1.Localizer.Diagnostic.typeVarTupleUnknownParam().format({ name: ((_a = argList[i].name) === null || _a === void 0 ? void 0 : _a.value) || '?' }), ((_b = argList[i].node) === null || _b === void 0 ? void 0 : _b.name) || argList[i].valueExpression || errorNode);
@@ -8468,7 +8158,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return typeVar;
     }
     function getTypeVarTupleDefaultType(node) {
-        const argType = getTypeOfExpressionExpectingType(node, { allowUnpackedTuple: true }).type;
+        const argType = getTypeOfExpressionExpectingType(node, {
+            allowUnpackedTuple: true,
+            allowTypeVarsWithoutScopeId: true,
+        }).type;
         const isUnpackedTuple = (0, types_1.isClass)(argType) && (0, typeUtils_1.isTupleClass)(argType) && argType.isUnpacked;
         const isUnpackedTypeVarTuple = (0, types_1.isUnpackedVariadicTypeVar)(argType);
         if (!isUnpackedTuple && !isUnpackedTypeVarTuple) {
@@ -8477,7 +8170,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return (0, typeUtils_1.convertToInstance)(argType);
     }
-    function createParamSpecType(errorNode, argList) {
+    function createParamSpecType(errorNode, classType, argList) {
         if (argList.length === 0) {
             addError(localize_1.Localizer.Diagnostic.paramSpecFirstArg(), errorNode);
             return undefined;
@@ -8501,6 +8194,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (expr) {
                         paramSpec.details.defaultType = getParamSpecDefaultType(expr);
                     }
+                    const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
+                    if (!fileInfo.isStubFile &&
+                        fileInfo.executionEnvironment.pythonVersion < pythonVersion_1.PythonVersion.V3_13 &&
+                        classType.details.moduleName !== 'typing_extensions') {
+                        addError(localize_1.Localizer.Diagnostic.typeVarDefaultIllegal(), expr);
+                    }
                 }
                 else {
                     addError(localize_1.Localizer.Diagnostic.paramSpecUnknownParam().format({ name: paramName }), paramNameNode || argList[i].valueExpression || errorNode);
@@ -8522,7 +8221,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if (node.nodeType === 31 /* List */) {
             node.entries.forEach((paramExpr, index) => {
-                const typeResult = getTypeOfExpressionExpectingType(paramExpr);
+                const typeResult = getTypeOfExpressionExpectingType(paramExpr, { allowTypeVarsWithoutScopeId: true });
                 types_1.FunctionType.addParameter(functionType, {
                     category: 0 /* Simple */,
                     name: `__p${index}`,
@@ -8537,7 +8236,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return functionType;
         }
         else {
-            const typeResult = getTypeOfExpressionExpectingType(node, { allowParamSpec: true });
+            const typeResult = getTypeOfExpressionExpectingType(node, {
+                allowParamSpec: true,
+                allowTypeVarsWithoutScopeId: true,
+            });
             if (typeResult.typeErrors) {
                 return undefined;
             }
@@ -8549,6 +8251,91 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramSpecDefaultNotTuple(), node);
         return undefined;
     }
+    // Handles a call to TypeAliasType(). This special form allows a caller to programmatically
+    // create a type alias as defined in PEP 695. If one or more of the arguments is incorrect,
+    // it returns undefined so the normal constructor evaluation can be performed (and type errors
+    // emitted).
+    function createTypeAliasType(errorNode, argList) {
+        if (errorNode.nodeType !== 9 /* Call */ || !errorNode.parent || argList.length < 2) {
+            return undefined;
+        }
+        if (errorNode.parent.nodeType !== 3 /* Assignment */ ||
+            errorNode.parent.rightExpression !== errorNode ||
+            errorNode.parent.leftExpression.nodeType !== 38 /* Name */) {
+            addError(localize_1.Localizer.Diagnostic.typeAliasTypeMustBeAssigned(), errorNode);
+            return undefined;
+        }
+        const nameNode = errorNode.parent.leftExpression;
+        const firstArg = argList[0];
+        if (firstArg.valueExpression && firstArg.valueExpression.nodeType === 48 /* StringList */) {
+            const typeAliasName = firstArg.valueExpression.strings.map((s) => s.value).join('');
+            if (typeAliasName !== nameNode.value) {
+                addError(localize_1.Localizer.Diagnostic.typeAliasTypeNameMismatch(), firstArg.valueExpression);
+            }
+        }
+        else {
+            addError(localize_1.Localizer.Diagnostic.typeAliasTypeNameArg(), firstArg.valueExpression || errorNode);
+            return undefined;
+        }
+        let valueExpr;
+        let typeParamsExpr;
+        // Parse the remaining parameters.
+        for (let i = 1; i < argList.length; i++) {
+            const paramNameNode = argList[i].name;
+            const paramName = paramNameNode ? paramNameNode.value : undefined;
+            if (paramName) {
+                if (paramName === 'type_params' && !typeParamsExpr) {
+                    typeParamsExpr = argList[i].valueExpression;
+                }
+                else if (paramName === 'value' && !valueExpr) {
+                    valueExpr = argList[i].valueExpression;
+                }
+                else {
+                    return undefined;
+                }
+            }
+            else if (i === 1) {
+                valueExpr = argList[i].valueExpression;
+            }
+            else {
+                return undefined;
+            }
+        }
+        // The value expression is not optional, so bail if it's not present.
+        if (!valueExpr) {
+            return undefined;
+        }
+        let typeParameters;
+        if (typeParamsExpr) {
+            if (typeParamsExpr.nodeType !== 52 /* Tuple */) {
+                addError(localize_1.Localizer.Diagnostic.typeAliasTypeParamInvalid(), typeParamsExpr);
+                return undefined;
+            }
+            typeParameters = [];
+            let isTypeParamListValid = true;
+            typeParamsExpr.expressions.map((expr) => {
+                let entryType = getTypeOfExpression(expr, 128 /* ExpectingType */).type;
+                if ((0, types_1.isTypeVar)(entryType)) {
+                    if (entryType.scopeId) {
+                        isTypeParamListValid = false;
+                    }
+                    else {
+                        entryType = types_1.TypeVarType.cloneForScopeId(entryType, ParseTreeUtils.getScopeIdForNode(nameNode), nameNode.value, 2 /* TypeAlias */);
+                    }
+                    typeParameters.push(entryType);
+                }
+                else {
+                    isTypeParamListValid = false;
+                }
+            });
+            if (!isTypeParamListValid) {
+                addError(localize_1.Localizer.Diagnostic.typeAliasTypeParamInvalid(), typeParamsExpr);
+                return undefined;
+            }
+        }
+        return getTypeOfTypeAliasCommon(nameNode, nameNode, valueExpr, 
+        /* typeParamNodes */ undefined, () => typeParameters);
+    }
     function getBooleanValue(node) {
         if (node.nodeType === 11 /* Constant */) {
             if (node.constType === 15 /* False */) {
@@ -8595,19 +8382,30 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.newTypeBadName(), (_a = argList[0].node) !== null && _a !== void 0 ? _a : errorNode);
             return undefined;
         }
-        const baseClass = getTypeOfArgumentExpectingType(argList[1]).type;
-        if ((0, types_1.isInstantiableClass)(baseClass)) {
-            if (types_1.ClassType.isProtocolClass(baseClass)) {
-                addError(localize_1.Localizer.Diagnostic.newTypeProtocolClass(), argList[1].node || errorNode);
-            }
-            else if (baseClass.literalValue !== undefined) {
-                addError(localize_1.Localizer.Diagnostic.newTypeLiteral(), argList[1].node || errorNode);
+        let baseClass = getTypeOfArgumentExpectingType(argList[1]).type;
+        let isBaseClassAny = false;
+        if ((0, types_1.isAnyOrUnknown)(baseClass)) {
+            if (objectType && (0, types_1.isClassInstance)(objectType)) {
+                baseClass = types_1.ClassType.cloneAsInstantiable(objectType);
             }
-            const classFlags = baseClass.details.flags & ~(1 /* BuiltInClass */ | 2 /* SpecialBuiltIn */);
-            const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.filePath, classFlags, ParseTreeUtils.getTypeSourceId(errorNode), 
-            /* declaredMetaclass */ undefined, baseClass.details.effectiveMetaclass);
-            classType.details.baseClasses.push(baseClass);
-            (0, typeUtils_1.computeMroLinearization)(classType);
+            isBaseClassAny = true;
+        }
+        if (!(0, types_1.isInstantiableClass)(baseClass)) {
+            addError(localize_1.Localizer.Diagnostic.newTypeNotAClass(), argList[1].node || errorNode);
+            return undefined;
+        }
+        if (types_1.ClassType.isProtocolClass(baseClass)) {
+            addError(localize_1.Localizer.Diagnostic.newTypeProtocolClass(), argList[1].node || errorNode);
+        }
+        else if (baseClass.literalValue !== undefined) {
+            addError(localize_1.Localizer.Diagnostic.newTypeLiteral(), argList[1].node || errorNode);
+        }
+        const classFlags = baseClass.details.flags & ~(1 /* BuiltInClass */ | 2 /* SpecialBuiltIn */);
+        const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.filePath, classFlags, ParseTreeUtils.getTypeSourceId(errorNode), 
+        /* declaredMetaclass */ undefined, baseClass.details.effectiveMetaclass);
+        classType.details.baseClasses.push(isBaseClassAny ? types_1.AnyType.create() : baseClass);
+        (0, typeUtils_1.computeMroLinearization)(classType);
+        if (!isBaseClassAny) {
             // Synthesize an __init__ method that accepts only the specified type.
             const initType = types_1.FunctionType.createSynthesizedInstance('__init__');
             types_1.FunctionType.addParameter(initType, {
@@ -8635,12 +8433,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             types_1.FunctionType.addDefaultParameters(newType);
             newType.details.declaredReturnType = types_1.ClassType.cloneAsInstance(classType);
             classType.details.fields.set('__new__', symbol_1.Symbol.createWithType(4 /* ClassMember */, newType));
-            return classType;
         }
-        if (!(0, types_1.isAnyOrUnknown)(baseClass)) {
-            addError(localize_1.Localizer.Diagnostic.newTypeNotAClass(), argList[1].node || errorNode);
-        }
-        return undefined;
+        return classType;
     }
     // Implements the semantics of the multi-parameter variant of the "type" call.
     function createType(errorNode, argList) {
@@ -8695,652 +8489,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 +8563,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.
@@ -9439,7 +8576,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return;
                 }
                 const subtypeResult = useSpeculativeMode(node, () => {
-                    return getTypeOfDictionaryWithContext(node, (0, typeUtils_1.makeInferenceContext)(subtype, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
+                    return getTypeOfDictionaryWithContext(node, (0, typeUtils_1.makeInferenceContext)(subtype));
                 });
                 if (subtypeResult && assignType(subtype, subtypeResult.type)) {
                     // If this is the first result we're seeing or it's the first result
@@ -9455,7 +8592,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let expectedTypeDiagAddendum = undefined;
         if (effectiveExpectedType) {
             expectedTypeDiagAddendum = new diagnostic_1.DiagnosticAddendum();
-            const result = getTypeOfDictionaryWithContext(node, (0, typeUtils_1.makeInferenceContext)(effectiveExpectedType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext), expectedTypeDiagAddendum);
+            const result = getTypeOfDictionaryWithContext(node, (0, typeUtils_1.makeInferenceContext)(effectiveExpectedType), expectedTypeDiagAddendum);
             if (result) {
                 return result;
             }
@@ -9501,7 +8638,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);
@@ -9512,7 +8649,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const expectedValueType = specializedDict.typeArguments[1];
         // Infer the key and value types if possible.
         if (getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, 
-        /* forceStrictInference */ true, expectedKeyType, expectedValueType, undefined, expectedDiagAddendum, inferenceContext)) {
+        /* forceStrictInference */ true, expectedKeyType, expectedValueType, undefined, expectedDiagAddendum)) {
             isIncomplete = true;
         }
         // Dict and MutableMapping types have invariant value types, so they
@@ -9521,9 +8658,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const isValueTypeInvariant = (0, types_1.isClassInstance)(inferenceContext.expectedType) &&
             (types_1.ClassType.isBuiltIn(inferenceContext.expectedType, 'dict') ||
                 types_1.ClassType.isBuiltIn(inferenceContext.expectedType, 'MutableMapping'));
-        const specializedKeyType = inferTypeArgFromExpectedType((0, typeUtils_1.makeInferenceContext)(expectedKeyType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext), keyTypes.map((result) => result.type), 
+        const specializedKeyType = inferTypeArgFromExpectedEntryType((0, typeUtils_1.makeInferenceContext)(expectedKeyType), keyTypes.map((result) => result.type), 
         /* isNarrowable */ false);
-        const specializedValueType = inferTypeArgFromExpectedType((0, typeUtils_1.makeInferenceContext)(expectedValueType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext), valueTypes.map((result) => result.type), !isValueTypeInvariant);
+        const specializedValueType = inferTypeArgFromExpectedEntryType((0, typeUtils_1.makeInferenceContext)(expectedValueType), valueTypes.map((result) => result.type), !isValueTypeInvariant);
         if (!specializedKeyType || !specializedValueType) {
             return undefined;
         }
@@ -9580,7 +8717,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return { type, isIncomplete };
     }
-    function getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, forceStrictInference, expectedKeyType, expectedValueType, expectedTypedDictEntries, expectedDiagAddendum, inferenceContext) {
+    function getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, forceStrictInference, expectedKeyType, expectedValueType, expectedTypedDictEntries, expectedDiagAddendum) {
         let isIncomplete = false;
         // Infer the key and value types if possible.
         node.entries.forEach((entryNode, index) => {
@@ -9588,7 +8725,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             let addUnknown = true;
             if (entryNode.nodeType === 17 /* DictionaryKeyEntry */) {
                 const keyTypeResult = getTypeOfExpression(entryNode.keyExpression, 
-                /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedKeyType !== null && expectedKeyType !== void 0 ? expectedKeyType : (forceStrictInference ? types_1.NeverType.createNever() : undefined), inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
+                /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedKeyType !== null && expectedKeyType !== void 0 ? expectedKeyType : (forceStrictInference ? types_1.NeverType.createNever() : undefined)));
                 if (keyTypeResult.isIncomplete) {
                     isIncomplete = true;
                 }
@@ -9607,12 +8744,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     expectedTypedDictEntries.has(keyType.literalValue)) {
                     const effectiveValueType = expectedTypedDictEntries.get(keyType.literalValue).valueType;
                     valueTypeResult = getTypeOfExpression(entryNode.valueExpression, 
-                    /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(effectiveValueType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
+                    /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(effectiveValueType));
                 }
                 else {
                     const effectiveValueType = expectedValueType !== null && expectedValueType !== void 0 ? expectedValueType : (forceStrictInference ? types_1.NeverType.createNever() : undefined);
                     valueTypeResult = getTypeOfExpression(entryNode.valueExpression, 
-                    /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(effectiveValueType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
+                    /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(effectiveValueType));
                 }
                 if (expectedDiagAddendum && valueTypeResult.expectedTypeDiagAddendum) {
                     expectedDiagAddendum.addAddendum(valueTypeResult.expectedTypeDiagAddendum);
@@ -9636,7 +8773,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
                 const unexpandedTypeResult = getTypeOfExpression(entryNode.expandExpression, 
-                /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
+                /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedType));
                 if (unexpandedTypeResult.isIncomplete) {
                     isIncomplete = true;
                 }
@@ -9723,7 +8860,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return;
                 }
                 const subtypeResult = useSpeculativeMode(node, () => {
-                    return getTypeOfListOrSetWithContext(node, (0, typeUtils_1.makeInferenceContext)(subtype, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
+                    return getTypeOfListOrSetWithContext(node, (0, typeUtils_1.makeInferenceContext)(subtype));
                 });
                 if (subtypeResult && assignType(subtype, subtypeResult.type)) {
                     // If this is the first result we're seeing or it's the first result
@@ -9738,7 +8875,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         let expectedTypeDiagAddendum;
         if (effectiveExpectedType) {
-            const result = getTypeOfListOrSetWithContext(node, (0, typeUtils_1.makeInferenceContext)(effectiveExpectedType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
+            const result = getTypeOfListOrSetWithContext(node, (0, typeUtils_1.makeInferenceContext)(effectiveExpectedType));
             if (result && !result.typeErrors) {
                 return result;
             }
@@ -9763,7 +8900,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);
@@ -9780,7 +8917,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             else {
                 entryTypeResult = getTypeOfExpression(entry, 
-                /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedEntryType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
+                /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedEntryType));
             }
             entryTypes.push(entryTypeResult.type);
             if (entryTypeResult.isIncomplete) {
@@ -9798,7 +8935,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         });
         const isTypeInvariant = (0, types_1.isClassInstance)(inferenceContext.expectedType) &&
             types_1.ClassType.isBuiltIn(inferenceContext.expectedType, builtInClassName);
-        const specializedEntryType = inferTypeArgFromExpectedType((0, typeUtils_1.makeInferenceContext)(expectedEntryType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext), entryTypes, !isTypeInvariant);
+        const specializedEntryType = inferTypeArgFromExpectedEntryType((0, typeUtils_1.makeInferenceContext)(expectedEntryType), entryTypes, !isTypeInvariant);
         if (!specializedEntryType) {
             return { type: types_1.UnknownType.create(), isIncomplete, typeErrors: true, expectedTypeDiagAddendum };
         }
@@ -9881,17 +9018,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message + diag.getString(), entry);
         }
     }
-    function inferTypeArgFromExpectedType(inferenceContext, entryTypes, isNarrowable) {
-        var _a;
+    function inferTypeArgFromExpectedEntryType(inferenceContext, entryTypes, isNarrowable) {
         // If the expected type is Any, the resulting type becomes Any.
         if ((0, types_1.isAnyOrUnknown)(inferenceContext.expectedType)) {
             return inferenceContext.expectedType;
         }
-        const typeVarContext = (_a = inferenceContext.typeVarContext) === null || _a === void 0 ? void 0 : _a.clone();
+        const typeVarContext = new typeVarContext_1.TypeVarContext();
+        const expectedType = inferenceContext.expectedType;
         let isCompatible = true;
         entryTypes.forEach((entryType) => {
-            if (isCompatible &&
-                !assignType(inferenceContext.expectedType, entryType, /* diag */ undefined, typeVarContext)) {
+            if (isCompatible && !assignType(expectedType, entryType, /* diag */ undefined, typeVarContext)) {
                 isCompatible = false;
             }
         });
@@ -9904,39 +9040,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 ? combinedTypes
                 : stripLiteralValue(combinedTypes);
         }
-        if (typeVarContext) {
-            return (0, typeUtils_1.applySolvedTypeVars)(inferenceContext.expectedType, typeVarContext);
-        }
-        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 };
+        return (0, typeUtils_1.applySolvedTypeVars)(inferenceContext.expectedType, typeVarContext, { applyInScopePlaceholders: true });
     }
     function getTypeOfYield(node) {
         let expectedYieldType;
@@ -9990,7 +9094,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 */);
@@ -10079,36 +9183,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 type: types_1.UnknownType.create(),
             });
         }
-        let expectedReturnType = expectedFunctionType
+        const expectedReturnType = expectedFunctionType
             ? getFunctionEffectiveReturnType(expectedFunctionType)
             : undefined;
-        if (expectedReturnType && (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext)) {
-            expectedReturnType = (0, typeUtils_1.applySolvedTypeVars)(expectedReturnType, inferenceContext.typeVarContext);
-        }
         // If we're speculatively evaluating the lambda, create another speculative
         // evaluation scope for the return expression and do not allow retention
         // of the cached types.
         const inferLambdaReturnType = () => {
             const returnTypeResult = getTypeOfExpression(node.expression, 
-            /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedReturnType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
+            /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedReturnType));
             functionType.inferredReturnType = returnTypeResult.type;
             if (returnTypeResult.isIncomplete) {
                 isIncomplete = true;
             }
         };
-        if (speculativeTypeTracker.isSpeculative(node) || (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete)) {
-            // We need to set allowCacheRetention to false because we don't want to
-            // cache the type of the lambda return expression because it depends on
-            // the parameter types that we set above, and the speculative type cache
-            // doesn't know about that context.
-            useSpeculativeMode(node.expression, () => {
-                inferLambdaReturnType();
-            }, 
-            /* allowCacheRetention */ false);
-        }
-        else {
+        // We need to set allowCacheRetention to false because we don't want to
+        // cache the type of the lambda return expression because it depends on
+        // the parameter types that we set above, and the speculative type cache
+        // doesn't know about that context.
+        useSpeculativeMode(isSpeculativeModeInUse(node) || (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete) ? node.expression : undefined, () => {
             inferLambdaReturnType();
-        }
+        }, 
+        /* allowCacheRetention */ false);
         // Mark the function type as no longer being evaluated.
         functionType.details.flags &= ~131072 /* PartiallyEvaluated */;
         return { type: functionType, isIncomplete };
@@ -10201,7 +9297,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 +9364,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 +9437,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,14 +10131,14 @@ 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({
                 names: boundTypeVars.map((t) => `${t.details.name}`).join(', '),
             }), errorNode);
         }
-        return types_1.TypeBase.cloneForTypeAlias(type, name.value, `${fileInfo.moduleName}.${name.value}`, typeAliasScopeId, typeParameters.length > 0 ? typeParameters : undefined);
+        return types_1.TypeBase.cloneForTypeAlias(type, name.value, ParseTreeUtils.getClassFullName(name, fileInfo.moduleName, name.value), typeAliasScopeId, typeParameters.length > 0 ? typeParameters : undefined);
     }
     function createSpecialBuiltInClass(node, assignedName, aliasMapEntry) {
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
@@ -11256,7 +10352,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.
@@ -11286,7 +10382,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (assignType(declaredType, srcType)) {
                         // Narrow the resulting type if possible.
                         if (!(0, types_1.isAnyOrUnknown)(srcType)) {
-                            srcType = narrowTypeBasedOnAssignment(declaredType, srcType);
+                            srcType = narrowTypeBasedOnAssignment(node, declaredType, srcType);
                         }
                     }
                 }
@@ -11356,59 +10452,67 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // variables since they use normal variable assignment syntax.
     function getTypeOfTypeAlias(node) {
         var _a;
-        const cachedType = readTypeCache(node.name, 0 /* None */);
+        return getTypeOfTypeAliasCommon(node, node.name, node.expression, (_a = node.typeParameters) === null || _a === void 0 ? void 0 : _a.parameters, () => {
+            let typeParameters = [];
+            if (node.typeParameters) {
+                typeParameters = evaluateTypeParameterList(node.typeParameters);
+            }
+            return typeParameters;
+        });
+    }
+    // This function is common to the handling of "type" statements and explicit
+    // calls to the TypeAliasType constructor.
+    function getTypeOfTypeAliasCommon(declNode, nameNode, valueNode, typeParamNodes, getTypeParamCallback) {
+        const cachedType = readTypeCache(nameNode, 0 /* None */);
         if (cachedType) {
             return cachedType;
         }
         // Synthesize a type variable that represents the type alias while we're
         // evaluating it. This allows us to handle recursive definitions.
-        const typeAliasTypeVar = types_1.TypeVarType.createInstantiable(`__type_alias_${node.name.value}`);
+        const typeAliasTypeVar = types_1.TypeVarType.createInstantiable(`__type_alias_${nameNode.value}`);
         typeAliasTypeVar.details.isSynthesized = true;
-        typeAliasTypeVar.details.recursiveTypeAliasName = node.name.value;
-        const scopeId = getScopeIdForNode(node.name);
+        typeAliasTypeVar.details.recursiveTypeAliasName = nameNode.value;
+        const scopeId = ParseTreeUtils.getScopeIdForNode(nameNode);
         typeAliasTypeVar.details.recursiveTypeAliasScopeId = scopeId;
         typeAliasTypeVar.scopeId = scopeId;
         // Write the type to the type cache. It will be replaced below.
-        writeTypeCache(node.name, { type: typeAliasTypeVar }, /* flags */ undefined);
+        writeTypeCache(nameNode, { type: typeAliasTypeVar }, /* flags */ undefined);
         // Set a partial type to handle recursive (self-referential) type aliases.
-        const scope = ScopeUtils.getScopeForNode(node);
-        const typeAliasSymbol = scope === null || scope === void 0 ? void 0 : scope.lookUpSymbolRecursive(node.name.value);
-        const typeAliasDecl = AnalyzerNodeInfo.getDeclaration(node);
+        const scope = ScopeUtils.getScopeForNode(declNode);
+        const typeAliasSymbol = scope === null || scope === void 0 ? void 0 : scope.lookUpSymbolRecursive(nameNode.value);
+        const typeAliasDecl = AnalyzerNodeInfo.getDeclaration(declNode);
         if (typeAliasDecl && typeAliasSymbol) {
             setSymbolResolutionPartialType(typeAliasSymbol.symbol, typeAliasDecl, typeAliasTypeVar);
         }
-        let typeParameters = [];
-        if (node.typeParameters) {
-            typeParameters = evaluateTypeParameterList(node.typeParameters);
-            typeAliasTypeVar.details.recursiveTypeParameters = typeParameters;
-        }
-        if (!isLegalTypeAliasExpressionForm(node.expression)) {
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasIllegalExpressionForm(), node.expression);
+        const typeParameters = getTypeParamCallback();
+        typeAliasTypeVar.details.recursiveTypeParameters = typeParameters;
+        if (!isLegalTypeAliasExpressionForm(valueNode)) {
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(valueNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasIllegalExpressionForm(), valueNode);
         }
-        const aliasTypeResult = getTypeOfExpressionExpectingType(node.expression);
+        const aliasTypeResult = getTypeOfExpressionExpectingType(valueNode, { allowForwardReference: true });
         let isIncomplete = false;
         let aliasType = aliasTypeResult.type;
         if (aliasTypeResult.isIncomplete) {
             isIncomplete = true;
         }
-        aliasType = transformTypeForTypeAlias(aliasType, node.name, node.expression, typeParameters, (_a = node.typeParameters) === null || _a === void 0 ? void 0 : _a.parameters);
+        aliasType = transformTypeForTypeAlias(aliasType, nameNode, valueNode, typeParameters, typeParamNodes);
         if ((0, typeUtils_1.isTypeAliasRecursive)(typeAliasTypeVar, aliasType)) {
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasIsRecursiveDirect().format({
-                name: node.name.value,
-            }), node.expression);
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(valueNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasIsRecursiveDirect().format({
+                name: nameNode.value,
+            }), valueNode);
             aliasType = types_1.UnknownType.create();
         }
         // Set the resulting type to the boundType of the original type alias
         // to support recursive type aliases.
         typeAliasTypeVar.details.boundType = aliasType;
-        writeTypeCache(node.name, { type: aliasType, isIncomplete }, 0 /* None */);
+        writeTypeCache(nameNode, { type: aliasType, isIncomplete }, 0 /* None */);
         return aliasType;
     }
     function evaluateTypesForAugmentedAssignment(node) {
         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 +10558,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 +10875,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 +11007,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) {
@@ -12106,7 +11205,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     decoratorCallType.details.builtInName === 'dataclass_transform') {
                     originalClassType.details.classDataClassTransform = (0, dataClasses_1.validateDataClassTransformDecorator)(evaluatorInterface, decoratorNode.expression);
                 }
-                else if (decoratorCallType.details.name === 'deprecated') {
+                else if (decoratorCallType.details.builtInName === 'deprecated') {
                     originalClassType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
                     return inputClassType;
                 }
@@ -12342,10 +11441,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) {
@@ -12931,7 +12030,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     undecoratedType.details.decoratorDataClassBehaviors = (0, dataClasses_1.validateDataClassTransformDecorator)(evaluatorInterface, decoratorNode.expression);
                     return inputFunctionType;
                 }
-                if (decoratorCallType.details.name === 'deprecated') {
+                if (decoratorCallType.details.builtInName === 'deprecated') {
                     undecoratedType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
                     return inputFunctionType;
                 }
@@ -14549,8 +13648,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function getTypeOfExpressionExpectingType(node, options) {
         let flags = 128 /* ExpectingType */ | 8 /* EvaluateStringLiteralAsType */ | 131072 /* DisallowClassVar */;
+        if (!(options === null || options === void 0 ? void 0 : options.allowTypeVarsWithoutScopeId)) {
+            flags |= 4096 /* DisallowTypeVarsWithoutScopeId */;
+        }
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-        if (fileInfo.isStubFile) {
+        if (fileInfo.isStubFile || (options === null || options === void 0 ? void 0 : options.allowForwardReference)) {
             flags |= 4 /* AllowForwardReferences */;
         }
         else {
@@ -14697,10 +13799,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 +13833,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 +14268,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 +14694,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 }
                             }
                             typesToCombine.push(type);
-                            if (speculativeTypeTracker.isSpeculative(decl.node)) {
+                            if (isSpeculativeModeInUse(decl.node)) {
                                 includesSpeculativeResult = true;
                             }
                         }
@@ -16644,11 +15756,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 +15982,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 +16429,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
@@ -18028,7 +17043,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // Apply any solved source TypeVars to the dest TypeVar solutions. This
         // allows for higher-order functions to accept generic callbacks.
-        destTypeVarContext.applySourceContextTypeVars(srcTypeVarContext);
+        (0, typeUtils_1.applySourceContextTypeVars)(destTypeVarContext, srcTypeVarContext);
         return canAssign;
     }
     // If the declaredType contains type arguments that are "Any" and
@@ -18036,7 +17051,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // replace that type argument in the assigned type. This function assumes
     // that the caller has already verified that the assignedType is assignable
     // to the declaredType.
-    function replaceTypeArgsWithAny(declaredType, assignedType, recursionCount = 0) {
+    function replaceTypeArgsWithAny(node, declaredType, assignedType, recursionCount = 0) {
         if (recursionCount > types_1.maxTypeRecursionCount) {
             return undefined;
         }
@@ -18051,7 +17066,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(assignedType));
             (0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, types_1.ClassType.cloneForSpecialization(assignedType, 
             /* typeArguments */ undefined, 
-            /* isTypeArgumentExplicit */ false), declaredType, typeVarContext, []);
+            /* isTypeArgumentExplicit */ false), declaredType, typeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node));
             let replacedTypeArg = false;
             const newTypeArgs = assignedType.typeArguments.map((typeArg, index) => {
                 const typeParam = assignedType.details.typeParameters[index];
@@ -18063,7 +17078,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     else if ((0, types_1.isClassInstance)(expectedTypeArgType) && (0, types_1.isClassInstance)(typeArg)) {
                         // Recursively replace Any in the type argument.
-                        const recursiveReplacement = replaceTypeArgsWithAny(expectedTypeArgType, typeArg, recursionCount);
+                        const recursiveReplacement = replaceTypeArgsWithAny(node, expectedTypeArgType, typeArg, recursionCount);
                         if (recursiveReplacement) {
                             replacedTypeArg = true;
                             return recursiveReplacement;
@@ -18080,7 +17095,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     // When a value is assigned to a variable with a declared type,
     // we may be able to narrow the type based on the assignment.
-    function narrowTypeBasedOnAssignment(declaredType, assignedType) {
+    function narrowTypeBasedOnAssignment(node, declaredType, assignedType) {
         const narrowedType = (0, typeUtils_1.mapSubtypes)(assignedType, (assignedSubtype) => {
             const narrowedSubtype = (0, typeUtils_1.mapSubtypes)(declaredType, (declaredSubtype) => {
                 // We can't narrow "Any".
@@ -18091,13 +17106,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     // If the source is generic and has unspecified type arguments,
                     // see if we can determine then based on the declared type.
                     if ((0, types_1.isInstantiableClass)(declaredSubtype) && (0, types_1.isInstantiableClass)(assignedSubtype)) {
-                        const result = replaceTypeArgsWithAny(declaredSubtype, assignedSubtype);
+                        const result = replaceTypeArgsWithAny(node, declaredSubtype, assignedSubtype);
                         if (result) {
                             assignedSubtype = result;
                         }
                     }
                     else if ((0, types_1.isClassInstance)(declaredSubtype) && (0, types_1.isClassInstance)(assignedSubtype)) {
-                        const result = replaceTypeArgsWithAny(types_1.ClassType.cloneAsInstantiable(declaredSubtype), types_1.ClassType.cloneAsInstantiable(assignedSubtype));
+                        const result = replaceTypeArgsWithAny(node, types_1.ClassType.cloneAsInstantiable(declaredSubtype), types_1.ClassType.cloneAsInstantiable(assignedSubtype));
                         if (result) {
                             assignedSubtype = types_1.ClassType.cloneAsInstance(result);
                         }
@@ -18562,6 +17577,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return types_1.FunctionType.clone(memberType, /* stripFirstParam */ true);
             }
             if (types_1.FunctionType.isInstanceMethod(memberType)) {
+                // If the baseType is a metaclass, don't specialize the function.
+                if ((0, typeUtils_1.isInstantiableMetaclass)(baseType)) {
+                    return memberType;
+                }
                 const baseObj = (0, types_1.isClassInstance)(baseType)
                     ? baseType
                     : types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeClassType)(baseType));
@@ -18802,6 +17821,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function printControlFlowGraph(flowNode, reference, callName, logger) {
         return codeFlowEngine.printControlFlowGraph(flowNode, reference, callName, logger);
     }
+    function printTypeVarContext(typeVarContext) {
+        const contexts = typeVarContext.getSignatureContexts();
+        contexts.forEach((context, index) => {
+            if (contexts.length > 1) {
+                console.log(`Signature context ${index + 1}:`);
+            }
+            context.getTypeVars().forEach((typeVarEntry) => {
+                const type = context.getTypeVarType(typeVarEntry.typeVar);
+                console.log(`  ${typeVarEntry.typeVar.details.name}: ${type ? printType(type) : '<none>'}`);
+            });
+        });
+    }
     const evaluatorInterface = {
         runWithCancellationToken,
         getType,
@@ -18840,7 +17871,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         getGetterTypeFromProperty,
         getTypeOfArgument,
         markNamesAccessed,
-        getScopeIdForNode,
         makeTopLevelTypeVarsConcrete,
         mapSubtypesExpandTypeVars,
         lookUpSymbolRecursive,
@@ -18855,6 +17885,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         getBuiltInType,
         getTypeOfMember,
         getTypeOfObjectMember,
+        getTypeOfClassMemberName,
         getBoundMethod,
         getTypeOfMagicMethodReturn,
         bindFunctionToClassOrObject,
@@ -18863,6 +17894,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         narrowConstrainedTypeVar,
         assignType,
         validateOverrideMethod,
+        validateCallArguments,
+        validateTypeArg,
         assignTypeToExpression,
         assignClassToSelf,
         getTypedDictClassType,
@@ -18889,9 +17922,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         getTypeCacheEntryCount,
         disposeEvaluator,
         useSpeculativeMode,
+        isSpeculativeModeInUse,
         setTypeForNode,
         checkForCancellation,
         printControlFlowGraph,
+        printTypeVarContext,
     };
     const codeFlowEngine = (0, codeFlowEngine_1.getCodeFlowEngine)(evaluatorInterface, speculativeTypeTracker);
     return evaluatorInterface;