@zzzen/pyright-internal 1.2.0-dev.20230108 → 1.2.0-dev.20230115

package/dist/analyzer/typeEvaluator.js

@@ -323,7 +323,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return cacheEntry.typeResult.type;
     }
-    function writeTypeCache(node, typeResult, flags, expectedType, allowSpeculativeCaching = false) {
+    function writeTypeCache(node, typeResult, flags, inferenceContext, allowSpeculativeCaching = false) {
         // Should we use a temporary cache associated with a contextual
         // analysis of a function, contextualized based on call-site argument types?
         const typeCacheToUse = returnTypeInferenceTypeCache && isNodeInReturnTypeInferenceContext(node)
@@ -336,16 +336,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (speculativeTypeTracker.isSpeculative(node)) {
             speculativeTypeTracker.trackEntry(typeCacheToUse, node.id);
             if (allowSpeculativeCaching && !typeResult.isIncomplete) {
-                speculativeTypeTracker.addSpeculativeType(node, typeResult, expectedType);
+                speculativeTypeTracker.addSpeculativeType(node, typeResult, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType);
             }
         }
     }
-    function deleteTypeCacheEntry(node) {
-        const typeCacheToUse = returnTypeInferenceTypeCache && isNodeInReturnTypeInferenceContext(node)
-            ? returnTypeInferenceTypeCache
-            : typeCache;
-        typeCacheToUse.delete(node.id);
-    }
     function setTypeForNode(node, type = types_1.UnknownType.create(), flags = 0 /* None */) {
         writeTypeCache(node, { type }, flags);
     }
@@ -492,8 +486,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             typedDictClassType = getTypingType(node, '_TypedDict');
         }
     }
-    function getTypeOfExpression(node, flags = 0 /* None */, expectedType) {
-        var _a;
+    function getTypeOfExpression(node, flags = 0 /* None */, inferenceContext) {
+        var _a, _b;
         // Is this type already cached?
         const cacheEntry = readTypeCacheEntry(node);
         if (cacheEntry && !cacheEntry.typeResult.isIncomplete) {
@@ -504,7 +498,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         else {
             // Is it cached in the speculative type cache?
-            const cachedTypeResult = speculativeTypeTracker.getSpeculativeType(node, expectedType);
+            const cachedTypeResult = speculativeTypeTracker.getSpeculativeType(node, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType);
             if (cachedTypeResult) {
                 if (printExpressionTypes) {
                     console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Speculative ${printType(cachedTypeResult.type)}`);
@@ -520,14 +514,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // the cancellation check. If the operation is canceled, an exception
         // will be thrown at this point.
         checkForCancellation();
-        expectedType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(expectedType);
+        if (inferenceContext) {
+            inferenceContext.expectedType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(inferenceContext.expectedType);
+        }
         // If we haven't already fetched some core type definitions from the
         // typeshed stubs, do so here. It would be better to fetch this when it's
         // needed in assignType, but we don't have access to the parse tree
         // at that point.
         initializedBasicTypes(node);
         let typeResult;
-        let reportExpectingTypeErrors = (flags & 64 /* ExpectingType */) !== 0;
+        let reportExpectingTypeErrors = (flags & 128 /* ExpectingType */) !== 0;
         switch (node.nodeType) {
             case 38 /* Name */: {
                 typeResult = getTypeOfName(node, flags);
@@ -542,11 +538,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 break;
             }
             case 9 /* Call */: {
-                typeResult = getTypeOfCall(node, expectedType, flags);
+                typeResult = getTypeOfCall(node, inferenceContext, flags);
                 break;
             }
             case 52 /* Tuple */: {
-                typeResult = getTypeOfTuple(node, expectedType, flags);
+                typeResult = getTypeOfTuple(node, inferenceContext, flags);
                 break;
             }
             case 11 /* Constant */: {
@@ -572,20 +568,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 break;
             }
             case 55 /* UnaryOperation */: {
-                typeResult = getTypeOfUnaryOperation(node, expectedType);
+                typeResult = getTypeOfUnaryOperation(node, inferenceContext);
                 break;
             }
             case 7 /* BinaryOperation */: {
-                typeResult = getTypeOfBinaryOperation(node, expectedType, flags);
+                typeResult = getTypeOfBinaryOperation(node, inferenceContext, flags);
                 break;
             }
             case 5 /* AugmentedAssignment */: {
-                typeResult = getTypeOfAugmentedAssignment(node, expectedType);
+                typeResult = getTypeOfAugmentedAssignment(node, inferenceContext);
                 break;
             }
             case 31 /* List */:
             case 45 /* Set */: {
-                typeResult = getTypeOfListOrSet(node, expectedType);
+                typeResult = getTypeOfListOrSet(node, inferenceContext);
                 break;
             }
             case 46 /* Slice */: {
@@ -593,23 +589,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 break;
             }
             case 6 /* Await */: {
-                typeResult = getTypeOfAwaitOperator(node, flags, expectedType);
+                typeResult = getTypeOfAwaitOperator(node, flags, inferenceContext);
                 break;
             }
             case 51 /* Ternary */: {
-                typeResult = getTypeOfTernary(node, flags, expectedType);
+                typeResult = getTypeOfTernary(node, flags, inferenceContext);
                 break;
             }
             case 32 /* ListComprehension */: {
-                typeResult = getTypeOfListComprehension(node, expectedType);
+                typeResult = getTypeOfListComprehension(node, inferenceContext);
                 break;
             }
             case 15 /* Dictionary */: {
-                typeResult = getTypeOfDictionary(node, expectedType);
+                typeResult = getTypeOfDictionary(node, inferenceContext);
                 break;
             }
             case 30 /* Lambda */: {
-                typeResult = getTypeOfLambda(node, expectedType);
+                typeResult = getTypeOfLambda(node, inferenceContext);
                 break;
             }
             case 3 /* Assignment */: {
@@ -636,15 +632,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 break;
             }
             case 56 /* Unpack */: {
-                typeResult = getTypeOfUnpackOperator(node, flags, expectedType);
+                typeResult = getTypeOfUnpackOperator(node, flags, inferenceContext);
                 break;
             }
             case 54 /* TypeAnnotation */: {
-                typeResult = getTypeOfExpression(node.typeAnnotation, 64 /* ExpectingType */ |
-                    1024 /* ExpectingTypeAnnotation */ |
+                typeResult = getTypeOfExpression(node.typeAnnotation, 128 /* ExpectingType */ |
+                    256 /* ExpectingTypeAnnotation */ |
                     8 /* EvaluateStringLiteralAsType */ |
-                    32 /* ParamSpecDisallowed */ |
-                    128 /* TypeVarTupleDisallowed */ |
+                    32 /* DisallowParamSpec */ |
+                    64 /* DisallowTypeVarTuple */ |
                     32768 /* VariableTypeAnnotation */);
                 break;
             }
@@ -665,14 +661,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 break;
             }
             default:
-                (0, debug_1.assertNever)(node);
+                (0, debug_1.assertNever)(node, `Illegal node type: ${node.nodeType}`);
         }
         if (!typeResult) {
             // We shouldn't get here. If we do, report an error.
             (0, debug_1.fail)(`Unhandled expression type '${ParseTreeUtils.printExpression(node)}'`);
         }
         if (reportExpectingTypeErrors && !typeResult.isIncomplete) {
-            if (flags & 128 /* TypeVarTupleDisallowed */) {
+            if (flags & 64 /* DisallowTypeVarTuple */) {
                 if ((0, types_1.isVariadicTypeVar)(typeResult.type) && !typeResult.type.isVariadicInUnion) {
                     addError(localize_1.Localizer.Diagnostic.typeVarTupleContext(), node);
                     typeResult.type = types_1.UnknownType.create();
@@ -694,12 +690,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 typeResult.type.details.illegalRecursionDetected = true;
             }
         }
-        writeTypeCache(node, typeResult, flags, expectedType, /* allowSpeculativeCaching */ true);
-        if (expectedType && !(0, types_1.isAnyOrUnknown)(expectedType) && !(0, types_1.isNever)(expectedType)) {
-            expectedTypeCache.set(node.id, expectedType);
+        writeTypeCache(node, typeResult, flags, inferenceContext, /* allowSpeculativeCaching */ true);
+        if (inferenceContext &&
+            !(0, types_1.isAnyOrUnknown)(inferenceContext.expectedType) &&
+            !(0, types_1.isNever)(inferenceContext.expectedType)) {
+            expectedTypeCache.set(node.id, inferenceContext.expectedType);
             if (!typeResult.isIncomplete && !typeResult.expectedTypeDiagAddendum) {
                 const diag = new diagnostic_1.DiagnosticAddendum();
-                if (!assignType(expectedType, typeResult.type, diag)) {
+                // 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()))) {
+                    typeResult.typeErrors = true;
                     typeResult.expectedTypeDiagAddendum = diag;
                     diag.addTextRange(node);
                 }
@@ -711,11 +713,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return typeResult;
     }
-    function getTypeOfAwaitOperator(node, flags, expectedType) {
-        const effectiveExpectedType = expectedType
-            ? createAwaitableReturnType(node, expectedType, /* isGenerator */ false)
+    function getTypeOfAwaitOperator(node, flags, inferenceContext) {
+        const effectiveExpectedType = inferenceContext
+            ? createAwaitableReturnType(node, inferenceContext.expectedType, /* isGenerator */ false)
             : undefined;
-        const exprTypeResult = getTypeOfExpression(node.expression, flags, effectiveExpectedType);
+        const exprTypeResult = getTypeOfExpression(node.expression, flags, (0, typeUtils_1.makeInferenceContext)(effectiveExpectedType));
         const typeResult = {
             type: getTypeOfAwaitable(exprTypeResult.type, node.expression),
         };
@@ -728,7 +730,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((flags & 1 /* ConvertEllipsisToAny */) !== 0) {
             typeResult = { type: types_1.AnyType.create(/* isEllipsis */ true) };
         }
-        else if ((flags & 256 /* ConvertEllipsisToUnknown */) !== 0) {
+        else if ((flags & 512 /* ConvertEllipsisToUnknown */) !== 0) {
             typeResult = { type: types_1.UnknownType.create() };
         }
         else {
@@ -749,19 +751,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return typeResult;
     }
-    function getTypeOfUnpackOperator(node, flags, expectedType) {
+    function getTypeOfUnpackOperator(node, flags, inferenceContext) {
         var _a;
         let typeResult;
         let iterExpectedType;
-        if (expectedType) {
+        if (inferenceContext) {
             const iterableType = getBuiltInType(node, 'Iterable');
             if (iterableType && (0, types_1.isInstantiableClass)(iterableType)) {
-                iterExpectedType = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(iterableType, [expectedType], /* isTypeArgumentExplicit */ true));
+                iterExpectedType = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(iterableType, [inferenceContext.expectedType], 
+                /* isTypeArgumentExplicit */ true));
             }
         }
-        const iterTypeResult = getTypeOfExpression(node.expression, flags, iterExpectedType);
+        const iterTypeResult = getTypeOfExpression(node.expression, flags, (0, typeUtils_1.makeInferenceContext)(iterExpectedType));
         const iterType = iterTypeResult.type;
-        if ((flags & 128 /* TypeVarTupleDisallowed */) === 0 &&
+        if ((flags & 64 /* DisallowTypeVarTuple */) === 0 &&
             (0, types_1.isVariadicTypeVar)(iterType) &&
             !iterType.isVariadicUnpacked) {
             typeResult = { type: types_1.TypeVarType.cloneForUnpacked(iterType) };
@@ -789,7 +792,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getTypeOfStringList(node, flags, isExpectingType) {
         let typeResult;
         if (isExpectingType) {
-            let updatedFlags = flags | 4 /* AllowForwardReferences */ | 64 /* ExpectingType */;
+            let updatedFlags = flags | 4 /* AllowForwardReferences */ | 128 /* ExpectingType */;
             // In most cases, annotations within a string are not parsed by the interpreter.
             // There are a few exceptions (e.g. the "bound" value for a TypeVar constructor).
             if ((flags & 4194304 /* InterpreterParsesStringLiteral */) === 0) {
@@ -939,27 +942,27 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return specialType;
             }
         }
-        let evaluatorFlags = 64 /* ExpectingType */ |
-            1024 /* ExpectingTypeAnnotation */ |
+        let evaluatorFlags = 128 /* ExpectingType */ |
+            256 /* ExpectingTypeAnnotation */ |
             1 /* ConvertEllipsisToAny */ |
             8 /* EvaluateStringLiteralAsType */;
         if (options === null || options === void 0 ? void 0 : options.isVariableAnnotation) {
             evaluatorFlags |= 32768 /* VariableTypeAnnotation */;
         }
         if (!(options === null || options === void 0 ? void 0 : options.allowFinal)) {
-            evaluatorFlags |= 16 /* FinalDisallowed */;
+            evaluatorFlags |= 16 /* DisallowFinal */;
         }
         if (!(options === null || options === void 0 ? void 0 : options.allowClassVar)) {
-            evaluatorFlags |= 131072 /* ClassVarDisallowed */;
+            evaluatorFlags |= 131072 /* DisallowClassVar */;
         }
         if (!(options === null || options === void 0 ? void 0 : options.allowTypeVarTuple)) {
-            evaluatorFlags |= 128 /* TypeVarTupleDisallowed */;
+            evaluatorFlags |= 64 /* DisallowTypeVarTuple */;
         }
         else {
             evaluatorFlags |= 2097152 /* AllowUnpackedTupleOrTypeVarTuple */;
         }
         if (!(options === null || options === void 0 ? void 0 : options.allowParamSpec)) {
-            evaluatorFlags |= 32 /* ParamSpecDisallowed */;
+            evaluatorFlags |= 32 /* DisallowParamSpec */;
         }
         if (options === null || options === void 0 ? void 0 : options.associateTypeVarsWithScope) {
             evaluatorFlags |= 8192 /* AssociateTypeVarsWithCurrentScope */;
@@ -2613,7 +2616,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 suppressDiagnostics(node.typeExpression, () => {
                                     callResult = validateConstructorArguments(node.typeExpression, [], concreteSubtype, 
                                     /* skipUnknownArgCheck */ false, 
-                                    /* expectedType */ undefined);
+                                    /* inferenceContext */ undefined);
                                 });
                                 if (callResult && callResult.argumentErrors) {
                                     diagAddendum.addMessage(localize_1.Localizer.Diagnostic.exceptionTypeNotInstantiable().format({
@@ -2764,14 +2767,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         else {
             // Look for the scope that contains the value definition and
             // see if it has a declared type.
-            let symbolWithScope = lookUpSymbolRecursive(node, name, !allowForwardReferences, allowForwardReferences && (flags & 1024 /* ExpectingTypeAnnotation */) !== 0);
+            let symbolWithScope = lookUpSymbolRecursive(node, name, !allowForwardReferences, allowForwardReferences && (flags & 256 /* ExpectingTypeAnnotation */) !== 0);
             if (!symbolWithScope) {
                 // If the node is part of a "from X import Y as Z" statement and the node
                 // is the "Y" (non-aliased) name, we need to look up the alias symbol
                 // since the non-aliased name is not in the symbol table.
                 const alias = getAliasFromImport(node);
                 if (alias) {
-                    symbolWithScope = lookUpSymbolRecursive(alias, alias.value, !allowForwardReferences, allowForwardReferences && (flags & 1024 /* ExpectingTypeAnnotation */) !== 0);
+                    symbolWithScope = lookUpSymbolRecursive(alias, alias.value, !allowForwardReferences, allowForwardReferences && (flags & 256 /* ExpectingTypeAnnotation */) !== 0);
                 }
             }
             if (symbolWithScope) {
@@ -2830,7 +2833,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     const codeFlowTypeResult = getFlowTypeOfReference(node, symbol.id, typeAtStart, 
                     /* startNode */ undefined, {
-                        skipConditionalNarrowing: (flags & 1024 /* ExpectingTypeAnnotation */) !== 0,
+                        skipConditionalNarrowing: (flags & 256 /* ExpectingTypeAnnotation */) !== 0,
                     });
                     if (codeFlowTypeResult.type) {
                         type = codeFlowTypeResult.type;
@@ -2850,7 +2853,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 // Detect, report, and fill in missing type arguments if appropriate.
                 type = reportMissingTypeArguments(node, type, flags);
-                if ((flags & 1024 /* ExpectingTypeAnnotation */) !== 0) {
+                if ((flags & 256 /* ExpectingTypeAnnotation */) !== 0) {
                     // Verify that the name does not refer to a (non type alias) variable.
                     if (effectiveTypeInfo.includesVariableDecl && !type.typeAliasInfo) {
                         let isAllowedTypeForVariable = (0, types_1.isTypeVar)(type) || (0, typeUtils_1.isTypeAliasPlaceholder)(type);
@@ -2887,7 +2890,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         if ((0, types_1.isParamSpec)(type)) {
-            if (flags & 32 /* ParamSpecDisallowed */) {
+            if (flags & 32 /* DisallowParamSpec */) {
                 addError(localize_1.Localizer.Diagnostic.paramSpecContext(), node);
                 type = types_1.UnknownType.create();
             }
@@ -2895,7 +2898,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, types_1.isTypeVar)(type) &&
             !type.details.isParamSpec &&
             !type.isVariadicInUnion &&
-            (flags & 64 /* ExpectingType */) === 0 &&
+            (flags & 128 /* ExpectingType */) === 0 &&
             type.details.name === name) {
             // Handle the special case of a PEP 604 union. These can appear within
             // an implied type alias where we are not expecting a type.
@@ -2915,8 +2918,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
-        if ((flags & 64 /* ExpectingType */) !== 0) {
-            if ((flags & 512 /* AllowGenericClassType */) === 0) {
+        if ((flags & 128 /* ExpectingType */) !== 0) {
+            if ((flags & 1024 /* AllowGenericClassType */) === 0) {
                 if ((0, types_1.isInstantiableClass)(type) && types_1.ClassType.isBuiltIn(type, 'Generic')) {
                     addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.genericNotAllowed(), node);
                 }
@@ -3089,7 +3092,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // Is this a generic class that needs to be specialized?
         if ((0, types_1.isInstantiableClass)(type)) {
-            if ((flags & 64 /* ExpectingType */) !== 0) {
+            if ((flags & 128 /* ExpectingType */) !== 0) {
                 if ((0, typeUtils_1.requiresTypeArguments)(type) && !type.typeArguments) {
                     addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportMissingTypeArgument, diagnosticRules_1.DiagnosticRule.reportMissingTypeArgument, localize_1.Localizer.Diagnostic.typeArgsMissingForClass().format({
                         name: type.aliasName || type.details.name,
@@ -3101,7 +3104,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         // Is this a generic type alias that needs to be specialized?
-        if ((flags & 64 /* ExpectingType */) !== 0 &&
+        if ((flags & 128 /* ExpectingType */) !== 0 &&
             type.typeAliasInfo &&
             type.typeAliasInfo.typeParameters &&
             type.typeAliasInfo.typeParameters.length > 0 &&
@@ -3255,7 +3258,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getTypeOfMemberAccess(node, flags) {
         const baseTypeFlags = 2 /* DoNotSpecialize */ |
             (flags &
-                (1024 /* ExpectingTypeAnnotation */ |
+                (256 /* ExpectingTypeAnnotation */ |
                     32768 /* VariableTypeAnnotation */ |
                     4 /* AllowForwardReferences */ |
                     524288 /* NotParsedByInterpreter */ |
@@ -3296,7 +3299,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const codeFlowTypeResult = getFlowTypeOfReference(node, symbol_1.indeterminateSymbolId, typeAtStart, 
             /* startNode */ undefined, {
                 isTypeAtStartIncomplete,
-                skipConditionalNarrowing: (flags & 1024 /* ExpectingTypeAnnotation */) !== 0,
+                skipConditionalNarrowing: (flags & 256 /* ExpectingTypeAnnotation */) !== 0,
             });
             if (codeFlowTypeResult.type) {
                 typeResult.type = codeFlowTypeResult.type;
@@ -3306,8 +3309,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             // Detect, report, and fill in missing type arguments if appropriate.
             typeResult.type = reportMissingTypeArguments(node, typeResult.type, flags);
-            deleteTypeCacheEntry(node);
-            deleteTypeCacheEntry(node.memberName);
         }
         if (baseTypeResult.isIncomplete) {
             typeResult.isIncomplete = true;
@@ -3381,7 +3382,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     return { type: types_1.UnknownType.create(isIncomplete), isIncomplete };
                 }
-                if (flags & 64 /* ExpectingType */) {
+                if (flags & 128 /* ExpectingType */) {
                     if (!isIncomplete) {
                         addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarNoMember().format({
                             type: printType(baseType),
@@ -4141,7 +4142,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If this is meant to be a type and the base expression is a string expression,
         // emit an error because this will generate a runtime exception in Python versions
         // less than 3.10.
-        if (flags & 64 /* ExpectingType */) {
+        if (flags & 128 /* ExpectingType */) {
             if (node.baseExpression.nodeType === 48 /* StringList */) {
                 const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
                 if (!fileInfo.isStubFile && fileInfo.executionEnvironment.pythonVersion < pythonVersion_1.PythonVersion.V3_10) {
@@ -4197,7 +4198,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const codeFlowTypeResult = getFlowTypeOfReference(node, symbol_1.indeterminateSymbolId, indexTypeResult.type, 
                 /* startNode */ undefined, {
                     isTypeAtStartIncomplete: !!baseTypeResult.isIncomplete || !!indexTypeResult.isIncomplete,
-                    skipConditionalNarrowing: (flags & 1024 /* ExpectingTypeAnnotation */) !== 0,
+                    skipConditionalNarrowing: (flags & 256 /* ExpectingTypeAnnotation */) !== 0,
                 });
                 if (codeFlowTypeResult.type) {
                     indexTypeResult.type = codeFlowTypeResult.type;
@@ -4205,14 +4206,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (codeFlowTypeResult.isIncomplete) {
                     indexTypeResult.isIncomplete = true;
                 }
-                deleteTypeCacheEntry(node);
             }
         }
         if (baseTypeResult.isIncomplete) {
             indexTypeResult.isIncomplete = true;
         }
         // Handle "Required" and "NotRequired" specially.
-        if ((flags & 1048576 /* RequiredAllowed */) !== 0) {
+        if ((flags & 1048576 /* AllowRequired */) !== 0) {
             if ((0, types_1.isInstantiableClass)(baseTypeResult.type)) {
                 if (types_1.ClassType.isBuiltIn(baseTypeResult.type, 'Required')) {
                     indexTypeResult.isRequired = true;
@@ -4454,7 +4454,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if ((0, types_1.isAnyOrUnknown)(concreteSubtype)) {
                 return concreteSubtype;
             }
-            if (flags & 64 /* ExpectingType */) {
+            if (flags & 128 /* ExpectingType */) {
                 if ((0, types_1.isTypeVar)(unexpandedSubtype)) {
                     addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarNotSubscriptable().format({
                         type: printType(unexpandedSubtype),
@@ -4790,16 +4790,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const typeArgs = [];
         let adjFlags = flags;
         if (isFinalAnnotation || isClassVarAnnotation) {
-            adjFlags |= 131072 /* ClassVarDisallowed */ | 16 /* FinalDisallowed */;
+            adjFlags |= 131072 /* DisallowClassVar */ | 16 /* DisallowFinal */;
         }
         else {
             adjFlags &= ~(2 /* DoNotSpecialize */ |
-                32 /* ParamSpecDisallowed */ |
-                128 /* TypeVarTupleDisallowed */ |
-                1048576 /* RequiredAllowed */ |
+                32 /* DisallowParamSpec */ |
+                64 /* DisallowTypeVarTuple */ |
+                1048576 /* AllowRequired */ |
                 16384 /* EnforceTypeVarVarianceConsistency */);
             if (!isAnnotatedClass) {
-                adjFlags |= 131072 /* ClassVarDisallowed */ | 16 /* FinalDisallowed */;
+                adjFlags |= 131072 /* DisallowClassVar */ | 16 /* DisallowFinal */;
             }
             adjFlags |= 2097152 /* AllowUnpackedTupleOrTypeVarTuple */;
         }
@@ -4811,10 +4811,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // should be treated as a type. The others can be regular (non-type) objects.
             if (hasCustomClassGetItem || (isAnnotatedClass && argIndex > 0)) {
                 typeResult = {
-                    ...getTypeOfExpression(expr, 32 /* ParamSpecDisallowed */ |
-                        128 /* TypeVarTupleDisallowed */ |
+                    ...getTypeOfExpression(expr, 32 /* DisallowParamSpec */ |
+                        64 /* DisallowTypeVarTuple */ |
                         2 /* DoNotSpecialize */ |
-                        131072 /* ClassVarDisallowed */),
+                        131072 /* DisallowClassVar */),
                     node: expr,
                 };
             }
@@ -4861,7 +4861,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getTypeArg(node, flags) {
         let typeResult;
         let adjustedFlags = flags |
-            64 /* ExpectingType */ |
+            128 /* ExpectingType */ |
             1 /* ConvertEllipsisToAny */ |
             8 /* EvaluateStringLiteralAsType */;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
@@ -4885,7 +4885,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if ((0, types_1.isClass)(typeResult.type) && types_1.ClassType.isBuiltIn(typeResult.type, 'Protocol')) {
                 addError(localize_1.Localizer.Diagnostic.protocolNotAllowedInTypeArgument(), node);
             }
-            if ((flags & 131072 /* ClassVarDisallowed */) !== 0) {
+            if ((flags & 131072 /* DisallowClassVar */) !== 0) {
                 // "ClassVar" is not allowed as a type argument.
                 if ((0, types_1.isClass)(typeResult.type) && types_1.ClassType.isBuiltIn(typeResult.type, 'ClassVar')) {
                     addError(localize_1.Localizer.Diagnostic.classVarNotAllowed(), node);
@@ -4894,23 +4894,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return typeResult;
     }
-    function getTypeOfTuple(node, expectedType, flags) {
-        if ((flags & 64 /* ExpectingType */) !== 0 && node.expressions.length === 0 && !expectedType) {
+    function getTypeOfTuple(node, inferenceContext, flags) {
+        if ((flags & 128 /* ExpectingType */) !== 0 && node.expressions.length === 0 && !inferenceContext) {
             return { type: makeTupleObject([]), isEmptyTupleShorthand: true };
         }
         // If the expected type is a union, recursively call for each of the subtypes
         // to find one that matches.
-        let effectiveExpectedType = expectedType;
-        let expectedTypeContainsAny = expectedType && (0, types_1.isAny)(expectedType);
-        if (expectedType && (0, types_1.isUnion)(expectedType)) {
+        let effectiveExpectedType = inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType;
+        let expectedTypeContainsAny = inferenceContext && (0, types_1.isAny)(inferenceContext.expectedType);
+        if (inferenceContext && (0, types_1.isUnion)(inferenceContext.expectedType)) {
             let matchingSubtype;
-            (0, typeUtils_1.doForEachSubtype)(expectedType, (subtype) => {
+            (0, typeUtils_1.doForEachSubtype)(inferenceContext.expectedType, (subtype) => {
                 if ((0, types_1.isAny)(subtype)) {
                     expectedTypeContainsAny = true;
                 }
                 if (!matchingSubtype) {
                     const subtypeResult = useSpeculativeMode(node, () => {
-                        return getTypeOfTupleExpected(node, subtype);
+                        return getTypeOfTupleWithContext(node, (0, typeUtils_1.makeInferenceContext)(subtype, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
                     });
                     if (subtypeResult && assignType(subtype, subtypeResult.type)) {
                         matchingSubtype = subtype;
@@ -4921,7 +4921,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         let expectedTypeDiagAddendum;
         if (effectiveExpectedType) {
-            const result = getTypeOfTupleExpected(node, effectiveExpectedType);
+            const result = getTypeOfTupleWithContext(node, (0, typeUtils_1.makeInferenceContext)(effectiveExpectedType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
             if (result && !result.typeErrors) {
                 return result;
             }
@@ -4935,9 +4935,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return { ...typeResult, expectedTypeDiagAddendum };
     }
-    function getTypeOfTupleExpected(node, expectedType) {
-        expectedType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(expectedType);
-        if (!(0, types_1.isClassInstance)(expectedType)) {
+    function getTypeOfTupleWithContext(node, inferenceContext) {
+        inferenceContext.expectedType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(inferenceContext.expectedType);
+        if (!(0, types_1.isClassInstance)(inferenceContext.expectedType)) {
             return undefined;
         }
         if (!tupleClassType || !(0, types_1.isInstantiableClass)(tupleClassType)) {
@@ -4945,9 +4945,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // Build an array of expected types.
         let expectedTypes = [];
-        if ((0, typeUtils_1.isTupleClass)(expectedType) && expectedType.tupleTypeArguments) {
-            expectedTypes = expectedType.tupleTypeArguments.map((t) => (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(t.type));
-            const unboundedIndex = expectedType.tupleTypeArguments.findIndex((t) => t.isUnbounded);
+        if ((0, typeUtils_1.isTupleClass)(inferenceContext.expectedType) && inferenceContext.expectedType.tupleTypeArguments) {
+            expectedTypes = inferenceContext.expectedType.tupleTypeArguments.map((t) => (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(t.type));
+            const unboundedIndex = inferenceContext.expectedType.tupleTypeArguments.findIndex((t) => t.isUnbounded);
             if (unboundedIndex >= 0) {
                 if (expectedTypes.length > node.expressions.length) {
                     expectedTypes.splice(unboundedIndex, 1);
@@ -4961,7 +4961,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), expectedType, tupleTypeVarContext, getTypeVarScopesForNode(node))) {
+            if (!(0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, types_1.ClassType.cloneAsInstance(tupleClassType), inferenceContext.expectedType, tupleTypeVarContext, getTypeVarScopesForNode(node))) {
                 return undefined;
             }
             const specializedTuple = (0, typeUtils_1.applySolvedTypeVars)(tupleClassType, tupleTypeVarContext);
@@ -4974,7 +4974,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         const entryTypeResults = node.expressions.map((expr, index) => getTypeOfExpression(expr, 
-        /* flags */ undefined, index < expectedTypes.length ? expectedTypes[index] : undefined));
+        /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(index < expectedTypes.length ? expectedTypes[index] : undefined)));
         const isIncomplete = entryTypeResults.some((result) => result.isIncomplete);
         const type = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, buildTupleTypesList(entryTypeResults), 
         /* isTypeArgumentExplicit */ true));
@@ -5041,7 +5041,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return entryTypes;
     }
-    function getTypeOfCall(node, expectedType, flags) {
+    function getTypeOfCall(node, inferenceContext, flags) {
         var _a;
         const baseTypeResult = getTypeOfExpression(node.leftExpression, 2 /* DoNotSpecialize */);
         const argList = node.arguments.map((arg) => {
@@ -5063,15 +5063,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 node.leftExpression.nodeType === 38 /* Name */ &&
                 node.leftExpression.value === 'reveal_type') {
                 // Handle the implicit "reveal_type" call.
-                typeResult = getTypeOfRevealType(node, expectedType);
+                typeResult = getTypeOfRevealType(node, inferenceContext);
             }
             else if ((0, types_1.isFunction)(baseTypeResult.type) && baseTypeResult.type.details.builtInName === 'reveal_type') {
                 // Handle the "typing.reveal_type" call.
-                typeResult = getTypeOfRevealType(node, expectedType);
+                typeResult = getTypeOfRevealType(node, inferenceContext);
             }
             else if ((0, types_1.isFunction)(baseTypeResult.type) && baseTypeResult.type.details.builtInName === 'assert_type') {
                 // Handle the "typing.assert_type" call.
-                typeResult = getTypeOfAssertType(node, expectedType);
+                typeResult = getTypeOfAssertType(node, inferenceContext);
             }
             else if ((0, types_1.isAnyOrUnknown)(baseTypeResult.type) &&
                 node.leftExpression.nodeType === 38 /* Name */ &&
@@ -5087,11 +5087,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             else {
                 const callResult = validateCallArguments(node, argList, baseTypeResult, 
                 /* typeVarContext */ undefined, 
-                /* skipUnknownArgCheck */ false, expectedType);
+                /* skipUnknownArgCheck */ false, inferenceContext);
                 typeResult.type = (_a = callResult.returnType) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
                 if (callResult.argumentErrors) {
                     typeResult.typeErrors = true;
                 }
+                else {
+                    typeResult.overloadsUsedForCall = callResult.overloadsUsedForCall;
+                }
                 if (callResult.isTypeIncomplete) {
                     typeResult.isIncomplete = true;
                 }
@@ -5125,13 +5128,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 });
             }
         }
-        if ((flags & 1024 /* ExpectingTypeAnnotation */) !== 0) {
+        if ((flags & 256 /* ExpectingTypeAnnotation */) !== 0) {
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAnnotationCall(), node);
             typeResult = { type: types_1.UnknownType.create() };
         }
         return typeResult;
     }
-    function getTypeOfAssertType(node, expectedType) {
+    function getTypeOfAssertType(node, inferenceContext) {
         if (node.arguments.length !== 2 ||
             node.arguments[0].argumentCategory !== 0 /* Simple */ ||
             node.arguments[0].name !== undefined ||
@@ -5141,7 +5144,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return { type: types_1.UnknownType.create() };
         }
         const arg0TypeResult = getTypeOfExpression(node.arguments[0].valueExpression, 
-        /* flags */ undefined, expectedType);
+        /* flags */ undefined, inferenceContext);
         if (arg0TypeResult.isIncomplete) {
             return { type: types_1.UnknownType.create(/* isIncomplete */ true), isIncomplete: true };
         }
@@ -5154,7 +5157,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return { type: arg0TypeResult.type };
     }
-    function getTypeOfRevealType(node, expectedType) {
+    function getTypeOfRevealType(node, inferenceContext) {
         let arg0Value;
         let expectedRevealTypeNode;
         let expectedRevealType;
@@ -5191,7 +5194,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             addError(localize_1.Localizer.Diagnostic.revealTypeArgs(), node);
             return { type: types_1.UnknownType.create() };
         }
-        const typeResult = getTypeOfExpression(arg0Value, /* flags */ undefined, expectedType);
+        const typeResult = getTypeOfExpression(arg0Value, /* flags */ undefined, inferenceContext);
         const type = typeResult.type;
         const exprString = ParseTreeUtils.printExpression(arg0Value);
         const typeString = printType(type, { expandTypeAlias: true });
@@ -5395,11 +5398,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // there will be only one argument list in expandedArgTypes, and all entries
     // (one for each argument) will be undefined. On subsequent calls, this
     // list will grow to include union expansions.
-    function validateOverloadsWithExpandedTypes(errorNode, expandedArgTypes, argParamMatches, typeVarContext, skipUnknownArgCheck, expectedType) {
+    function validateOverloadsWithExpandedTypes(errorNode, expandedArgTypes, argParamMatches, typeVarContext, skipUnknownArgCheck, inferenceContext) {
         var _a;
         const returnTypes = [];
         const matchedOverloads = [];
         let isTypeIncomplete = false;
+        const overloadsUsedForCall = [];
         for (let expandedTypesIndex = 0; expandedTypesIndex < expandedArgTypes.length; expandedTypesIndex++) {
             let matchedOverload;
             const argTypeOverride = expandedArgTypes[expandedTypesIndex];
@@ -5433,12 +5437,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // record any final types in the type cache.
                 const callResult = useSpeculativeMode(errorNode, () => {
                     return validateFunctionArgumentTypesWithExpectedType(errorNode, matchResults, effectiveTypeVarContext, 
-                    /* skipUnknownArgCheck */ true, expectedType);
+                    /* skipUnknownArgCheck */ true, inferenceContext);
                 });
                 if (callResult.isTypeIncomplete) {
                     isTypeIncomplete = true;
                 }
                 if (!callResult.argumentErrors && callResult.returnType) {
+                    overloadsUsedForCall.push(overload);
                     matchedOverload = overload;
                     matchedOverloads.push({
                         overload: matchedOverload,
@@ -5484,7 +5489,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 returnTypes.push(dedupedMatchResults.length > 1 ? types_1.UnknownType.createPossibleType(combinedTypes) : combinedTypes);
             }
             if (!matchedOverload) {
-                return { argumentErrors: true, isTypeIncomplete };
+                return { argumentErrors: true, isTypeIncomplete, overloadsUsedForCall };
             }
         }
         // We found a match for all of the expanded argument lists. Copy the
@@ -5499,7 +5504,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const finalTypeVarContext = typeVarContext !== null && typeVarContext !== void 0 ? typeVarContext : matchedOverloads[0].typeVarContext;
         finalTypeVarContext.unlock();
         finalTypeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(matchedOverloads[0].overload));
-        const finalCallResult = validateFunctionArgumentTypesWithExpectedType(errorNode, matchedOverloads[0].matchResults, finalTypeVarContext, skipUnknownArgCheck, expectedType);
+        const finalCallResult = validateFunctionArgumentTypesWithExpectedType(errorNode, matchedOverloads[0].matchResults, finalTypeVarContext, skipUnknownArgCheck, inferenceContext);
         if (finalCallResult.isTypeIncomplete) {
             isTypeIncomplete = true;
         }
@@ -5509,6 +5514,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             returnType: (0, types_1.combineTypes)(returnTypes),
             isTypeIncomplete,
             specializedInitSelfType: finalCallResult.specializedInitSelfType,
+            overloadsUsedForCall,
         };
     }
     function getBestOverloadForArguments(errorNode, type, argList) {
@@ -5548,7 +5554,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return a.overloadIndex - b.overloadIndex;
         });
     }
-    function validateOverloadedFunctionArguments(errorNode, argList, type, typeVarContext, skipUnknownArgCheck, expectedType) {
+    function validateOverloadedFunctionArguments(errorNode, argList, type, typeVarContext, skipUnknownArgCheck, inferenceContext) {
         let filteredMatchResults = [];
         let contextFreeArgTypes;
         // Start by evaluating the types of the arguments without any expected
@@ -5582,7 +5588,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.argumentTypes().format({ types: argTypes.join(', ') }));
                 addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.noOverload().format({ name: functionName }) + diagAddendum.getString(), errorNode);
             }
-            return { argumentErrors: true, isTypeIncomplete: false };
+            return { argumentErrors: true, isTypeIncomplete: false, overloadsUsedForCall: [] };
         }
         // Create a helper lambda that evaluates the overload that matches
         // the arg/param lists.
@@ -5595,7 +5601,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const effectiveTypeVarContext = typeVarContext !== null && typeVarContext !== void 0 ? typeVarContext : new typeVarContext_1.TypeVarContext();
             effectiveTypeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(lastMatch.overload));
             effectiveTypeVarContext.unlock();
-            return validateFunctionArgumentTypesWithExpectedType(errorNode, lastMatch, effectiveTypeVarContext, skipUnknownArgCheck, expectedType);
+            return validateFunctionArgumentTypesWithExpectedType(errorNode, lastMatch, effectiveTypeVarContext, skipUnknownArgCheck, inferenceContext);
         };
         // If there is only one possible arg/param match among the overloads,
         // use the normal type matching mechanism because it is faster and
@@ -5606,7 +5612,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let expandedArgTypes = [argList.map((arg) => undefined)];
         let isTypeIncomplete = false;
         while (true) {
-            const callResult = validateOverloadsWithExpandedTypes(errorNode, expandedArgTypes, filteredMatchResults, typeVarContext, skipUnknownArgCheck, expectedType);
+            const callResult = validateOverloadsWithExpandedTypes(errorNode, expandedArgTypes, filteredMatchResults, typeVarContext, skipUnknownArgCheck, inferenceContext);
             if (callResult.isTypeIncomplete) {
                 isTypeIncomplete = true;
             }
@@ -5618,7 +5624,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (!contextFreeArgTypes) {
                 useSpeculativeMode(errorNode, () => {
                     // Evaluate the types of each argument expression without regard to
-                    // the expectedType. We'll use this to determine whether we need to do
+                    // the context. We'll use this to determine whether we need to do
                     // union expansion.
                     contextFreeArgTypes = argList.map((arg) => {
                         if (arg.typeResult) {
@@ -5650,7 +5656,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             result.returnType = types_1.UnknownType.create();
             return { ...result, argumentErrors: true };
         }
-        return { argumentErrors: true, isTypeIncomplete: false };
+        return { argumentErrors: true, isTypeIncomplete: false, overloadsUsedForCall: [] };
     }
     // Replaces each item in the expandedArgTypes with n items where n is
     // the number of subtypes in a union. The contextFreeArgTypes parameter
@@ -5702,13 +5708,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // 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, expectedType) {
+    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.
@@ -5726,13 +5733,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // 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 (expectedType) {
-                const expectedCallResult = validateConstructorMethodWithExpectedType(errorNode, argList, type, skipUnknownArgCheck, expectedType, initMethodType);
+            if (inferenceContext) {
+                const expectedCallResult = validateConstructorMethodWithExpectedType(errorNode, argList, type, skipUnknownArgCheck, inferenceContext, initMethodType);
                 if (expectedCallResult) {
                     returnType = expectedCallResult.returnType;
                     if (expectedCallResult.isTypeIncomplete) {
                         isTypeIncomplete = true;
                     }
+                    overloadsUsedForCall.push(...expectedCallResult.overloadsUsedForCall);
                 }
             }
             if (!returnType) {
@@ -5749,10 +5757,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         adjustedClassType = types_1.ClassType.cloneAsInstantiable(callResult.specializedInitSelfType);
                     }
                     returnType = applyExpectedTypeForConstructor(adjustedClassType, 
-                    /* expectedType */ undefined, typeVarContext);
+                    /* inferenceContext */ undefined, typeVarContext);
                     if (callResult.isTypeIncomplete) {
                         isTypeIncomplete = true;
                     }
+                    overloadsUsedForCall.push(...callResult.overloadsUsedForCall);
                 }
                 else {
                     reportedErrors = true;
@@ -5790,8 +5799,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const constructorMethodType = constructorMethodInfo.type;
                 // 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 (expectedType && !returnType) {
-                    const expectedCallResult = validateConstructorMethodWithExpectedType(errorNode, argList, type, skipUnknownArgCheck, expectedType, constructorMethodType);
+                if (inferenceContext && !returnType) {
+                    const expectedCallResult = validateConstructorMethodWithExpectedType(errorNode, argList, type, skipUnknownArgCheck, inferenceContext, constructorMethodType);
                     if (expectedCallResult) {
                         returnType = expectedCallResult.returnType;
                         if (expectedCallResult.isTypeIncomplete) {
@@ -5806,14 +5815,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 typeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(constructorMethodType));
                 // Skip the unknown argument check if we've already checked for __init__.
                 const callResult = validateCallArguments(errorNode, argList, constructorMethodInfo, typeVarContext, skipUnknownArgCheck);
+                if (callResult.isTypeIncomplete) {
+                    isTypeIncomplete = true;
+                }
                 if (callResult.argumentErrors) {
                     reportedErrors = true;
                 }
                 else {
                     let newReturnType = callResult.returnType;
-                    if (callResult.isTypeIncomplete) {
-                        isTypeIncomplete = true;
-                    }
                     // 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
@@ -5848,10 +5857,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
                 if (!returnType) {
-                    returnType = applyExpectedTypeForConstructor(type, expectedType, typeVarContext);
+                    returnType = applyExpectedTypeForConstructor(type, inferenceContext, typeVarContext);
                 }
                 else if ((0, types_1.isClassInstance)(returnType) && (0, typeUtils_1.isTupleClass)(returnType) && !returnType.tupleTypeArguments) {
-                    returnType = applyExpectedTypeForTupleConstructor(returnType, expectedType);
+                    returnType = applyExpectedTypeForTupleConstructor(returnType, inferenceContext);
                 }
                 validatedTypes = true;
             }
@@ -5880,7 +5889,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (!returnType) {
             // There was no __init__ or __new__ method or we couldn't match the provided
             // arguments to them.
-            if (!expectedType && type.typeArguments) {
+            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);
@@ -5889,10 +5898,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // 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 (expectedType) {
-                    (0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, types_1.ClassType.cloneAsInstance(type), expectedType, typeVarContext, getTypeVarScopesForNode(errorNode));
+                if (inferenceContext) {
+                    (0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, types_1.ClassType.cloneAsInstance(type), inferenceContext.expectedType, typeVarContext, getTypeVarScopesForNode(errorNode));
                 }
-                returnType = applyExpectedTypeForConstructor(type, expectedType, typeVarContext);
+                returnType = applyExpectedTypeForConstructor(type, inferenceContext, typeVarContext);
             }
         }
         if (!reportedErrors) {
@@ -5909,16 +5918,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 reportedErrors = true;
             }
         }
-        const result = { argumentErrors: reportedErrors, returnType, isTypeIncomplete };
+        const result = {
+            argumentErrors: reportedErrors,
+            returnType,
+            isTypeIncomplete,
+            overloadsUsedForCall,
+        };
         return result;
     }
     // For a constructor call that targets a generic class and an "expected type"
     // (i.e. bidirectional inference), this function attempts to infer the correct
     // specialized return type for the constructor.
-    function validateConstructorMethodWithExpectedType(errorNode, argList, type, skipUnknownArgCheck, expectedType, constructorMethodType) {
+    function validateConstructorMethodWithExpectedType(errorNode, argList, type, skipUnknownArgCheck, inferenceContext, constructorMethodType) {
         let isTypeIncomplete = false;
         let argumentErrors = false;
-        const returnType = (0, typeUtils_1.mapSubtypes)(expectedType, (expectedSubType) => {
+        const overloadsUsedForCall = [];
+        const returnType = (0, typeUtils_1.mapSubtypes)(inferenceContext.expectedType, (expectedSubType) => {
             expectedSubType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(expectedSubType);
             const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(type));
             if ((0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, types_1.ClassType.cloneAsInstance(type), expectedSubType, typeVarContext, getTypeVarScopesForNode(errorNode))) {
@@ -5936,6 +5951,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (callResult.argumentErrors) {
                         argumentErrors = true;
                     }
+                    overloadsUsedForCall.push(...callResult.overloadsUsedForCall);
                     return applyExpectedSubtypeForConstructor(type, expectedSubType, typeVarContext);
                 }
             }
@@ -5944,7 +5960,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, types_1.isNever)(returnType)) {
             return undefined;
         }
-        return { returnType, isTypeIncomplete, argumentErrors };
+        return { returnType, isTypeIncomplete, argumentErrors, overloadsUsedForCall };
     }
     function applyExpectedSubtypeForConstructor(type, expectedSubtype, typeVarContext) {
         const specializedType = (0, typeUtils_1.applySolvedTypeVars)(types_1.ClassType.cloneAsInstance(type), typeVarContext);
@@ -5959,10 +5975,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     // 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, expectedType, typeVarContext) {
+    function applyExpectedTypeForConstructor(type, inferenceContext, typeVarContext) {
         let unsolvedTypeVarsAreUnknown = true;
-        if (expectedType) {
-            const specializedExpectedType = (0, typeUtils_1.mapSubtypes)(expectedType, (expectedSubtype) => {
+        if (inferenceContext) {
+            const specializedExpectedType = (0, typeUtils_1.mapSubtypes)(inferenceContext.expectedType, (expectedSubtype) => {
                 return applyExpectedSubtypeForConstructor(type, expectedSubtype, typeVarContext);
             });
             if (!(0, types_1.isNever)(specializedExpectedType)) {
@@ -5982,13 +5998,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     // Similar to applyExpectedTypeForConstructor, this function handles the
     // special case of the tuple class.
-    function applyExpectedTypeForTupleConstructor(type, expectedType) {
+    function applyExpectedTypeForTupleConstructor(type, inferenceContext) {
         let specializedType = type;
-        if (expectedType &&
-            (0, types_1.isClassInstance)(expectedType) &&
-            (0, typeUtils_1.isTupleClass)(expectedType) &&
-            expectedType.tupleTypeArguments) {
-            specializedType = (0, typeUtils_1.specializeTupleClass)(type, expectedType.tupleTypeArguments);
+        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;
     }
@@ -5996,12 +6012,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // list, specializes the call based on arg types, and returns the
     // specialized type of the return value. If it detects an error along
     // the way, it emits a diagnostic and sets argumentErrors to true.
-    function validateCallArguments(errorNode, argList, callTypeResult, typeVarContext, skipUnknownArgCheck = false, expectedType, recursionCount = 0) {
+    function validateCallArguments(errorNode, argList, callTypeResult, typeVarContext, skipUnknownArgCheck = false, inferenceContext, recursionCount = 0) {
         let argumentErrors = false;
         let isTypeIncomplete = false;
         let specializedInitSelfType;
+        const overloadsUsedForCall = [];
         if (recursionCount > types_1.maxTypeRecursionCount) {
-            return { returnType: types_1.UnknownType.create(), argumentErrors: true };
+            return { returnType: types_1.UnknownType.create(), argumentErrors: true, overloadsUsedForCall };
         }
         recursionCount++;
         if (types_1.TypeBase.isSpecialForm(callTypeResult.type)) {
@@ -6010,7 +6027,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 expression: ParseTreeUtils.printExpression(exprNode),
                 type: printType(callTypeResult.type, { expandTypeAlias: true }),
             }), exprNode);
-            return { returnType: types_1.UnknownType.create(), argumentErrors: true };
+            return { returnType: types_1.UnknownType.create(), argumentErrors: true, overloadsUsedForCall };
         }
         const returnType = mapSubtypesExpandTypeVars(callTypeResult.type, 
         /* conditionFilter */ undefined, (expandedSubtype, unexpandedSubtype) => {
@@ -6054,10 +6071,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             effectiveTypeVarContext.addSolveForScope(types_1.WildcardTypeVarScopeId);
                         }
                     }
-                    const functionResult = validateFunctionArguments(errorNode, argList, expandedSubtype, effectiveTypeVarContext, skipUnknownArgCheck, expectedType);
+                    const functionResult = validateFunctionArguments(errorNode, argList, expandedSubtype, effectiveTypeVarContext, skipUnknownArgCheck, inferenceContext);
                     if (functionResult.isTypeIncomplete) {
                         isTypeIncomplete = true;
                     }
+                    overloadsUsedForCall.push(...functionResult.overloadsUsedForCall);
                     if (functionResult.argumentErrors) {
                         argumentErrors = true;
                     }
@@ -6102,7 +6120,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                         return (0, typeUtils_1.convertToInstance)(castToType);
                     }
-                    const functionResult = validateOverloadedFunctionArguments(errorNode, argList, expandedSubtype, typeVarContext, skipUnknownArgCheck, expectedType);
+                    const functionResult = validateOverloadedFunctionArguments(errorNode, argList, expandedSubtype, typeVarContext, skipUnknownArgCheck, inferenceContext);
+                    overloadsUsedForCall.push(...functionResult.overloadsUsedForCall);
                     if (functionResult.isTypeIncomplete) {
                         isTypeIncomplete = true;
                     }
@@ -6138,7 +6157,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             const className = expandedSubtype.aliasName || expandedSubtype.details.name;
                             if (className === 'type') {
                                 // Validate the constructor arguments.
-                                validateConstructorArguments(errorNode, argList, expandedSubtype, skipUnknownArgCheck, expectedType);
+                                validateConstructorArguments(errorNode, argList, expandedSubtype, skipUnknownArgCheck, inferenceContext);
                                 // Handle the 'type' call specially.
                                 if (argList.length === 1) {
                                     // The one-parameter form of "type" returns the class
@@ -6234,7 +6253,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             }), errorNode);
                         }
                         // Assume this is a call to the constructor.
-                        const constructorResult = validateConstructorArguments(errorNode, argList, expandedSubtype, skipUnknownArgCheck, expectedType);
+                        const constructorResult = validateConstructorArguments(errorNode, argList, expandedSubtype, skipUnknownArgCheck, inferenceContext);
+                        overloadsUsedForCall.push(...constructorResult.overloadsUsedForCall);
                         if (constructorResult.argumentErrors) {
                             argumentErrors = true;
                         }
@@ -6274,7 +6294,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     else {
                         const memberType = (_d = getTypeOfObjectMember(errorNode, expandedSubtype, '__call__')) === null || _d === void 0 ? void 0 : _d.type;
                         if (memberType) {
-                            const functionResult = validateCallArguments(errorNode, argList, { type: memberType }, typeVarContext, skipUnknownArgCheck, expectedType, recursionCount);
+                            const functionResult = validateCallArguments(errorNode, argList, { type: memberType }, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
+                            overloadsUsedForCall.push(...functionResult.overloadsUsedForCall);
                             if (functionResult.argumentErrors) {
                                 argumentErrors = true;
                             }
@@ -6306,7 +6327,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // need to handle recursive type aliases.
                 case 10 /* TypeVar */: {
                     expandedSubtype = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(expandedSubtype);
-                    const callResult = validateCallArguments(errorNode, argList, { type: expandedSubtype }, typeVarContext, skipUnknownArgCheck, expectedType, recursionCount);
+                    const callResult = validateCallArguments(errorNode, argList, { type: expandedSubtype }, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
+                    overloadsUsedForCall.push(...callResult.overloadsUsedForCall);
                     if (callResult.argumentErrors) {
                         argumentErrors = true;
                     }
@@ -6324,6 +6346,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             returnType: (0, types_1.isNever)(returnType) && !returnType.isNoReturn ? undefined : returnType,
             isTypeIncomplete,
             specializedInitSelfType,
+            overloadsUsedForCall,
         };
     }
     // Expands any unpacked tuples within an argument list.
@@ -7129,19 +7152,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // After having matched arguments with parameters, this function evaluates the
     // types of each argument expression and validates that the resulting type is
     // compatible with the declared type of the corresponding parameter.
-    function validateFunctionArgumentTypesWithExpectedType(errorNode, matchResults, typeVarContext, skipUnknownArgCheck = false, expectedType) {
+    function validateFunctionArgumentTypesWithExpectedType(errorNode, matchResults, typeVarContext, skipUnknownArgCheck = false, inferenceContext) {
         var _a;
         const type = matchResults.overload;
-        if (!expectedType ||
-            (0, types_1.isAnyOrUnknown)(expectedType) ||
-            (0, types_1.isNever)(expectedType) ||
-            (0, typeUtils_1.requiresSpecialization)(expectedType) ||
+        if (!inferenceContext ||
+            (0, types_1.isAnyOrUnknown)(inferenceContext.expectedType) ||
+            (0, types_1.isNever)(inferenceContext.expectedType) ||
+            (0, typeUtils_1.requiresSpecialization)(inferenceContext.expectedType) ||
             !type.details.declaredReturnType ||
             !(0, typeUtils_1.requiresSpecialization)((_a = types_1.FunctionType.getSpecializedReturnType(type)) !== null && _a !== void 0 ? _a : types_1.UnknownType.create())) {
             return validateFunctionArgumentTypes(errorNode, matchResults, typeVarContext, skipUnknownArgCheck);
         }
         const effectiveReturnType = getFunctionEffectiveReturnType(type);
-        let effectiveExpectedType = expectedType;
+        let effectiveExpectedType = inferenceContext.expectedType;
         let effectiveFlags = 0 /* Default */;
         if ((0, typeUtils_1.containsLiteralType)(effectiveExpectedType, /* includeTypeArgs */ true)) {
             effectiveFlags |= 128 /* RetainLiteralsForTypeVar */;
@@ -7149,7 +7172,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If the expected type is a union, we don't know which type is expected.
         // We may or may not be able to make use of the expected type. We'll evaluate
         // speculatively to see if using the expected type works.
-        if ((0, types_1.isUnion)(expectedType)) {
+        if ((0, types_1.isUnion)(inferenceContext.expectedType)) {
             let speculativeResults;
             useSpeculativeMode(errorNode, () => {
                 const typeVarContextCopy = typeVarContext.clone();
@@ -7400,6 +7423,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             isTypeIncomplete,
             activeParam: matchResults.activeParam,
             specializedInitSelfType,
+            overloadsUsedForCall: argumentErrors ? [] : [type],
         };
     }
     function adjustCallableReturnType(type) {
@@ -7419,7 +7443,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // Tries to assign the call arguments to the function parameter
     // list and reports any mismatches in types or counts. Returns the
     // specialized return type of the call.
-    function validateFunctionArguments(errorNode, argList, type, typeVarContext, skipUnknownArgCheck = false, expectedType) {
+    function validateFunctionArguments(errorNode, argList, type, typeVarContext, skipUnknownArgCheck = false, inferenceContext) {
         const matchResults = matchFunctionArgumentsToParameters(errorNode, argList, type, 0);
         if (matchResults.argumentErrors) {
             // Evaluate types of all args. This will ensure that referenced symbols are
@@ -7432,9 +7456,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return {
                 argumentErrors: true,
                 activeParam: matchResults.activeParam,
+                overloadsUsedForCall: [],
             };
         }
-        return validateFunctionArgumentTypesWithExpectedType(errorNode, matchResults, typeVarContext, skipUnknownArgCheck, expectedType);
+        return validateFunctionArgumentTypesWithExpectedType(errorNode, matchResults, typeVarContext, skipUnknownArgCheck, inferenceContext);
     }
     // Determines whether the specified argument list satisfies the function
     // signature bound to the specified ParamSpec. Return value indicates success.
@@ -7558,11 +7583,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // to true if this is the first pass through the parameter list because
             // a wide bound on a TypeVar (if a narrow bound has not yet been established)
             // will unnecessarily constrain the expected type.
-            let expectedType = (0, types_1.isTypeVar)(argParam.paramType) &&
-                functionType !== undefined &&
-                argParam.paramType.scopeId === functionType.details.typeVarScopeId
-                ? undefined
-                : (0, typeUtils_1.applySolvedTypeVars)(argParam.paramType, typeVarContext, { useNarrowBoundOnly });
+            let expectedType;
+            if (!(0, types_1.isTypeVar)(argParam.paramType) || argParam.paramType.scopeId !== (functionType === null || functionType === void 0 ? void 0 : functionType.details.typeVarScopeId)) {
+                expectedType = (0, typeUtils_1.applySolvedTypeVars)(argParam.paramType, typeVarContext, { useNarrowBoundOnly });
+            }
             // If the expected type is unknown, don't use an expected type. Instead,
             // use default rules for evaluating the expression type.
             if (expectedType && (0, types_1.isUnknown)(expectedType)) {
@@ -7575,10 +7599,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             else {
                 const flags = argParam.expectingType
                     ? 8 /* EvaluateStringLiteralAsType */ |
-                        32 /* ParamSpecDisallowed */ |
-                        128 /* TypeVarTupleDisallowed */
+                        32 /* DisallowParamSpec */ |
+                        64 /* DisallowTypeVarTuple */
                     : 0 /* None */;
-                const exprTypeResult = getTypeOfExpression(argParam.argument.valueExpression, flags, expectedType);
+                const exprTypeResult = getTypeOfExpression(argParam.argument.valueExpression, flags, (0, typeUtils_1.makeInferenceContext)(expectedType, typeVarContext));
                 argType = exprTypeResult.type;
                 if (exprTypeResult.isIncomplete) {
                     isTypeIncomplete = true;
@@ -7591,7 +7615,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (argParam.argument &&
                 argParam.argument.name &&
                 !speculativeTypeTracker.isSpeculative(argParam.errorNode)) {
-                writeTypeCache(argParam.argument.name, { type: expectedType || argType, isIncomplete: isTypeIncomplete }, 0 /* None */);
+                writeTypeCache(argParam.argument.name, { type: expectedType !== null && expectedType !== void 0 ? expectedType : argType, isIncomplete: isTypeIncomplete }, 0 /* None */);
             }
         }
         else {
@@ -7601,8 +7625,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             else if (argParam.expectingType && !argParam.argument.typeResult && argParam.argument.valueExpression) {
                 const argTypeResult = getTypeOfExpression(argParam.argument.valueExpression, 8 /* EvaluateStringLiteralAsType */ |
-                    32 /* ParamSpecDisallowed */ |
-                    128 /* TypeVarTupleDisallowed */);
+                    32 /* DisallowParamSpec */ |
+                    64 /* DisallowTypeVarTuple */);
                 argType = argTypeResult.type;
                 if (argTypeResult.isIncomplete) {
                     isTypeIncomplete = true;
@@ -8139,7 +8163,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getTypeOfConstant(node, flags) {
         let type;
         if (node.constType === 26 /* None */) {
-            type = (flags & 64 /* ExpectingType */) !== 0 ? types_1.NoneType.createType() : types_1.NoneType.createInstance();
+            type = (flags & 128 /* ExpectingType */) !== 0 ? types_1.NoneType.createType() : types_1.NoneType.createInstance();
         }
         else if (node.constType === 33 /* True */ ||
             node.constType === 15 /* False */ ||
@@ -8161,7 +8185,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return { type };
     }
-    function getTypeOfUnaryOperation(node, expectedType) {
+    function getTypeOfUnaryOperation(node, inferenceContext) {
         const exprTypeResult = getTypeOfExpression(node.expression);
         let exprType = makeTopLevelTypeVarsConcrete(exprTypeResult.type);
         const isIncomplete = exprTypeResult.isIncomplete;
@@ -8224,15 +8248,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 else {
                     const magicMethodName = unaryOperatorMap[node.operator];
-                    type = getTypeOfMagicMethodReturn(exprType, [], magicMethodName, node, expectedType);
+                    type = getTypeOfMagicMethodReturn(exprType, [], magicMethodName, node, inferenceContext);
                 }
                 if (!type) {
                     const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-                    if (expectedType) {
+                    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(expectedType),
+                            expectedType: printType(inferenceContext.expectedType),
                         }), node);
                     }
                     else {
@@ -8247,7 +8271,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return { type, isIncomplete };
     }
-    function getTypeOfBinaryOperation(node, expectedType, flags) {
+    function getTypeOfBinaryOperation(node, inferenceContext, flags) {
         const leftExpression = node.leftExpression;
         let rightExpression = node.rightExpression;
         let isIncomplete = false;
@@ -8259,7 +8283,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 !rightExpression.parenthesized &&
                 ParseTreeUtils.operatorSupportsChaining(rightExpression.operator)) {
                 // Evaluate the right expression so it is type checked.
-                getTypeOfBinaryOperation(rightExpression, expectedType, flags);
+                getTypeOfBinaryOperation(rightExpression, inferenceContext, flags);
                 // Use the left side of the right expression for comparison purposes.
                 rightExpression = rightExpression.leftExpression;
             }
@@ -8267,21 +8291,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // 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 */ ? expectedType : undefined;
+        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 */ &&
-            expectedType &&
-            (0, types_1.isClassInstance)(expectedType) &&
-            types_1.ClassType.isBuiltIn(expectedType, 'list') &&
-            expectedType.typeArguments &&
-            expectedType.typeArguments.length >= 1 &&
+            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 = expectedType;
+            expectedLeftOperandType = inferenceContext.expectedType;
         }
-        const leftTypeResult = getTypeOfExpression(leftExpression, flags, expectedOperandType || expectedLeftOperandType);
+        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 */) {
@@ -8302,7 +8329,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
-        const rightTypeResult = getTypeOfExpression(rightExpression, flags, expectedOperandType);
+        const rightTypeResult = getTypeOfExpression(rightExpression, flags, (0, typeUtils_1.makeInferenceContext)(expectedOperandType));
         let rightType = rightTypeResult.type;
         if (leftTypeResult.isIncomplete || rightTypeResult.isIncomplete) {
             isIncomplete = true;
@@ -8396,7 +8423,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // incomplete because we may be evaluating types within a loop,
         // so the literal values may change each time.
         const isLiteralMathAllowed = !ParseTreeUtils.isWithinLoop(node);
-        let type = validateBinaryOperation(node.operator, { type: leftType, isIncomplete: leftTypeResult.isIncomplete }, { type: rightType, isIncomplete: rightTypeResult.isIncomplete }, node, expectedType, diag, isLiteralMathAllowed);
+        // 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) {
             if (!isIncomplete) {
                 const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
@@ -8441,7 +8472,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return true;
     }
-    function getTypeOfAugmentedAssignment(node, expectedType) {
+    function getTypeOfAugmentedAssignment(node, inferenceContext) {
         const operatorMap = {
             [1 /* AddEqual */]: ['__iadd__', 0 /* Add */],
             [34 /* SubtractEqual */]: ['__isub__', 33 /* Subtract */],
@@ -8468,7 +8499,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // us to support the case where a TypedDict is being updated with a dict expression.
             expectedOperandType = leftType;
         }
-        const rightTypeResult = getTypeOfExpression(node.rightExpression, /* flags */ undefined, expectedOperandType);
+        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)) {
@@ -8482,14 +8514,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         return (0, typeUtils_1.preserveUnknown)(leftSubtypeUnexpanded, rightSubtypeUnexpanded);
                     }
                     const magicMethodName = operatorMap[node.operator][0];
-                    let returnType = getTypeOfMagicMethodReturn(leftSubtypeUnexpanded, [{ type: rightSubtypeUnexpanded, isIncomplete: rightTypeResult.isIncomplete }], magicMethodName, node, expectedType);
+                    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, expectedType);
+                        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, expectedType);
+                        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
@@ -8502,7 +8534,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             !rightTypeResult.isIncomplete &&
                             (0, typeUtils_1.getUnionSubtypeCount)(leftType) * (0, typeUtils_1.getUnionSubtypeCount)(rightType) <
                                 maxLiteralMathSubtypeCount;
-                        returnType = validateBinaryOperation(binaryOperator, { type: leftSubtypeUnexpanded, isIncomplete: leftTypeResult.isIncomplete }, { type: rightSubtypeUnexpanded, isIncomplete: rightTypeResult.isIncomplete }, node, expectedType, diag, isLiteralMathAllowed);
+                        // 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;
                 });
@@ -8525,7 +8561,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         assignTypeToExpression(node.destExpression, typeResult.type, !!typeResult.isIncomplete, node.rightExpression);
         return typeResult;
     }
-    function validateBinaryOperation(operator, leftTypeResult, rightTypeResult, errorNode, expectedType, diag, isLiteralMathAllowed) {
+    function validateBinaryOperation(operator, leftTypeResult, rightTypeResult, errorNode, inferenceContext, diag, options) {
         const leftType = leftTypeResult.type;
         const rightType = rightTypeResult.type;
         let type;
@@ -8579,7 +8615,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             return (0, typeUtils_1.preserveUnknown)(leftSubtype, rightSubtypeExpanded);
                         }
                         let returnType = getTypeOfMagicMethodReturn(rightSubtypeExpanded, [{ type: leftSubtype, isIncomplete: leftTypeResult.isIncomplete }], '__contains__', errorNode, 
-                        /* expectedType */ undefined);
+                        /* inferenceContext */ undefined);
                         if (!returnType) {
                             // If __contains__ was not supported, fall back
                             // on an iterable.
@@ -8626,7 +8662,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // 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 (isLiteralMathAllowed) {
+            if (options.isLiteralMathAllowed) {
                 const leftLiteralClassName = (0, typeUtils_1.getLiteralTypeClassName)(leftType);
                 if (leftLiteralClassName && !(0, typeUtils_1.getTypeCondition)(leftType)) {
                     const rightLiteralClassName = (0, typeUtils_1.getLiteralTypeClassName)(rightType);
@@ -8690,7 +8726,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                             else {
                                                 // Convert back to a simple number if it fits. Leave as a bigint
                                                 // if it doesn't.
-                                                if (newValue === BigInt(Number(newValue))) {
+                                                if (newValue >= Number.MIN_SAFE_INTEGER &&
+                                                    newValue <= Number.MAX_SAFE_INTEGER) {
                                                     newValue = Number(newValue);
                                                 }
                                                 return types_1.ClassType.cloneWithLiteral(leftClassSubtype, newValue);
@@ -8718,7 +8755,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             return (0, typeUtils_1.preserveUnknown)(leftSubtypeUnexpanded, rightSubtypeUnexpanded);
                         }
                         // Special-case __add__ for tuples when the types for both tuples are known.
-                        if (operator === 0 /* Add */ &&
+                        if (options.isTupleAddAllowed &&
+                            operator === 0 /* Add */ &&
                             (0, types_1.isClassInstance)(leftSubtypeExpanded) &&
                             (0, typeUtils_1.isTupleClass)(leftSubtypeExpanded) &&
                             leftSubtypeExpanded.tupleTypeArguments &&
@@ -8735,19 +8773,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             ]));
                         }
                         const magicMethodName = binaryOperatorMap[operator][0];
-                        let resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(leftSubtypeUnexpanded), [{ type: rightSubtypeUnexpanded, isIncomplete: rightTypeResult.isIncomplete }], magicMethodName, errorNode, expectedType);
+                        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, expectedType);
+                            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, expectedType);
+                            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, expectedType);
+                            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), [
@@ -8755,20 +8793,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                         type: leftSubtypeUnexpanded,
                                         isIncomplete: leftTypeResult.isIncomplete,
                                     },
-                                ], altMagicMethodName, errorNode, expectedType);
+                                ], 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, expectedType);
+                                resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(rightSubtypeExpanded), [{ type: leftSubtypeExpanded, isIncomplete: leftTypeResult.isIncomplete }], altMagicMethodName, errorNode, inferenceContext);
                             }
                         }
                         if (!resultType) {
-                            if (expectedType) {
+                            if (inferenceContext) {
                                 diag.addMessage(localize_1.Localizer.Diagnostic.typeNotSupportBinaryOperatorBidirectional().format({
                                     operator: ParseTreeUtils.printOperator(operator),
                                     leftType: printType(leftSubtypeExpanded),
                                     rightType: printType(rightSubtypeExpanded),
-                                    expectedType: printType(expectedType),
+                                    expectedType: printType(inferenceContext.expectedType),
                                 }));
                             }
                             else {
@@ -8786,7 +8824,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return type && (0, types_1.isNever)(type) ? undefined : type;
     }
-    function getTypeOfMagicMethodReturn(objType, args, magicMethodName, errorNode, expectedType) {
+    function getTypeOfMagicMethodReturn(objType, args, magicMethodName, errorNode, inferenceContext) {
         let magicMethodSupported = true;
         // Create a helper lambda for object subtypes.
         const handleSubtype = (subtype) => {
@@ -8814,7 +8852,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 useSpeculativeMode(errorNode, () => {
                     callResult = validateCallArguments(errorNode, functionArgs, { type: magicMethodType }, 
                     /* typeVarContext */ undefined, 
-                    /* skipUnknownArgCheck */ true, expectedType);
+                    /* skipUnknownArgCheck */ true, inferenceContext);
                 });
                 if (callResult.argumentErrors) {
                     magicMethodSupported = false;
@@ -8862,20 +8900,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return type;
     }
-    function getTypeOfDictionary(node, expectedType) {
+    function getTypeOfDictionary(node, inferenceContext) {
         // If the expected type is a union, analyze for each of the subtypes
         // to find one that matches.
-        let effectiveExpectedType = expectedType;
-        if (expectedType && (0, types_1.isUnion)(expectedType)) {
+        let effectiveExpectedType = inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType;
+        if (inferenceContext && (0, types_1.isUnion)(inferenceContext.expectedType)) {
             let matchingSubtype;
             let matchingSubtypeResult;
-            (0, typeUtils_1.doForEachSubtype)(expectedType, (subtype) => {
+            (0, typeUtils_1.doForEachSubtype)(inferenceContext.expectedType, (subtype) => {
                 // Use shortcut if we've already found a match.
                 if (matchingSubtypeResult && !matchingSubtypeResult.typeErrors) {
                     return;
                 }
                 const subtypeResult = useSpeculativeMode(node, () => {
-                    return getTypeOfDictionaryExpected(node, subtype);
+                    return getTypeOfDictionaryWithContext(node, (0, typeUtils_1.makeInferenceContext)(subtype, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
                 });
                 if (subtypeResult && assignType(subtype, subtypeResult.type)) {
                     // If this is the first result we're seeing or it's the first result
@@ -8891,28 +8929,26 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let expectedTypeDiagAddendum = undefined;
         if (effectiveExpectedType) {
             expectedTypeDiagAddendum = new diagnostic_1.DiagnosticAddendum();
-            const result = getTypeOfDictionaryExpected(node, effectiveExpectedType, expectedTypeDiagAddendum);
+            const result = getTypeOfDictionaryWithContext(node, (0, typeUtils_1.makeInferenceContext)(effectiveExpectedType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext), expectedTypeDiagAddendum);
             if (result) {
                 return result;
             }
         }
-        const result = getTypeOfDictionaryInferred(node, /* hasExpectedType */ !!expectedType);
+        const result = getTypeOfDictionaryInferred(node, /* hasExpectedType */ !!inferenceContext);
         return { ...result, expectedTypeDiagAddendum };
     }
-    // Attempts to infer the type of a dictionary statement. If an expectedType
-    // is provided, the resulting type must be compatible with the expected type.
-    // If this isn't possible, undefined is returned.
-    function getTypeOfDictionaryExpected(node, expectedType, expectedDiagAddendum) {
-        expectedType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(expectedType);
-        if (!(0, types_1.isClassInstance)(expectedType)) {
+    function getTypeOfDictionaryWithContext(node, inferenceContext, expectedDiagAddendum) {
+        inferenceContext.expectedType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(inferenceContext.expectedType);
+        const concreteExpectedType = makeTopLevelTypeVarsConcrete(inferenceContext.expectedType);
+        if (!(0, types_1.isClassInstance)(concreteExpectedType)) {
             return undefined;
         }
         const keyTypes = [];
         const valueTypes = [];
         let isIncomplete = false;
         // Handle TypedDict's as a special case.
-        if (types_1.ClassType.isTypedDictClass(expectedType)) {
-            const expectedTypedDictEntries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluatorInterface, expectedType);
+        if (types_1.ClassType.isTypedDictClass(concreteExpectedType)) {
+            const expectedTypedDictEntries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluatorInterface, concreteExpectedType);
             // Infer the key and value types if possible.
             if (getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, 
             /* forceStrictInference */ true, 
@@ -8920,8 +8956,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             /* expectedValueType */ undefined, expectedTypedDictEntries, expectedDiagAddendum)) {
                 isIncomplete = true;
             }
-            if (types_1.ClassType.isTypedDictClass(expectedType)) {
-                const resultTypedDict = (0, typedDicts_1.assignToTypedDict)(evaluatorInterface, expectedType, keyTypes, valueTypes, 
+            if (types_1.ClassType.isTypedDictClass(concreteExpectedType)) {
+                const resultTypedDict = (0, typedDicts_1.assignToTypedDict)(evaluatorInterface, concreteExpectedType, keyTypes, valueTypes, 
                 // Don't overwrite existing expectedDiagAddendum messages if they were
                 // already provided by getKeyValueTypesFromDictionary.
                 (expectedDiagAddendum === null || expectedDiagAddendum === void 0 ? void 0 : expectedDiagAddendum.isEmpty()) ? expectedDiagAddendum : undefined);
@@ -8939,7 +8975,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, expectedType, dictTypeVarContext, getTypeVarScopesForNode(node))) {
+        if (!(0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, builtInDict, inferenceContext.expectedType, dictTypeVarContext, getTypeVarScopesForNode(node))) {
             return undefined;
         }
         const specializedDict = (0, typeUtils_1.applySolvedTypeVars)(types_1.ClassType.cloneAsInstantiable(builtInDict), dictTypeVarContext);
@@ -8956,8 +8992,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Dict and MutableMapping types have invariant value types, so they
         // cannot be narrowed further. Other super-types like Mapping, Collection,
         // and Iterable use covariant value types, so they can be narrowed.
-        const isValueTypeInvariant = (0, types_1.isClassInstance)(expectedType) &&
-            (types_1.ClassType.isBuiltIn(expectedType, 'dict') || types_1.ClassType.isBuiltIn(expectedType, 'MutableMapping'));
+        const isValueTypeInvariant = (0, types_1.isClassInstance)(inferenceContext.expectedType) &&
+            (types_1.ClassType.isBuiltIn(inferenceContext.expectedType, 'dict') ||
+                types_1.ClassType.isBuiltIn(inferenceContext.expectedType, 'MutableMapping'));
         const specializedKeyType = inferTypeArgFromExpectedType(expectedKeyType, keyTypes.map((result) => result.type), 
         /* isNarrowable */ false);
         const specializedValueType = inferTypeArgFromExpectedType(expectedValueType, valueTypes.map((result) => result.type), 
@@ -9021,7 +9058,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             let addUnknown = true;
             if (entryNode.nodeType === 17 /* DictionaryKeyEntry */) {
                 const keyTypeResult = getTypeOfExpression(entryNode.keyExpression, 
-                /* flags */ undefined, expectedKeyType !== null && expectedKeyType !== void 0 ? expectedKeyType : (forceStrictInference ? types_1.NeverType.createNever() : undefined));
+                /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedKeyType !== null && expectedKeyType !== void 0 ? expectedKeyType : (forceStrictInference ? types_1.NeverType.createNever() : undefined)));
                 if (keyTypeResult.isIncomplete) {
                     isIncomplete = true;
                 }
@@ -9035,12 +9072,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     types_1.ClassType.isBuiltIn(keyType, 'str') &&
                     (0, typeUtils_1.isLiteralType)(keyType) &&
                     expectedTypedDictEntries.has(keyType.literalValue)) {
+                    const effectiveValueType = expectedTypedDictEntries.get(keyType.literalValue).valueType;
                     valueTypeResult = getTypeOfExpression(entryNode.valueExpression, 
-                    /* flags */ undefined, expectedTypedDictEntries.get(keyType.literalValue).valueType);
+                    /* 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, expectedValueType !== null && expectedValueType !== void 0 ? expectedValueType : (forceStrictInference ? types_1.NeverType.createNever() : undefined));
+                    /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(effectiveValueType));
                 }
                 if (expectedDiagAddendum && valueTypeResult.expectedTypeDiagAddendum) {
                     expectedDiagAddendum.addAddendum(valueTypeResult.expectedTypeDiagAddendum);
@@ -9138,20 +9177,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         });
         return isIncomplete;
     }
-    function getTypeOfListOrSet(node, expectedType) {
+    function getTypeOfListOrSet(node, inferenceContext) {
         // If the expected type is a union, recursively call for each of the subtypes
         // to find one that matches.
-        let effectiveExpectedType = expectedType;
-        if (expectedType && (0, types_1.isUnion)(expectedType)) {
+        let effectiveExpectedType = inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType;
+        if (inferenceContext && (0, types_1.isUnion)(inferenceContext.expectedType)) {
             let matchingSubtype;
             let matchingSubtypeResult;
-            (0, typeUtils_1.doForEachSubtype)(expectedType, (subtype) => {
+            (0, typeUtils_1.doForEachSubtype)(inferenceContext.expectedType, (subtype) => {
                 // Use shortcut if we've already found a match.
                 if (matchingSubtypeResult && !matchingSubtypeResult.typeErrors) {
                     return;
                 }
                 const subtypeResult = useSpeculativeMode(node, () => {
-                    return getTypeOfListOrSetExpected(node, subtype);
+                    return getTypeOfListOrSetWithContext(node, (0, typeUtils_1.makeInferenceContext)(subtype, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
                 });
                 if (subtypeResult && assignType(subtype, subtypeResult.type)) {
                     // If this is the first result we're seeing or it's the first result
@@ -9166,24 +9205,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         let expectedTypeDiagAddendum;
         if (effectiveExpectedType) {
-            const result = getTypeOfListOrSetExpected(node, effectiveExpectedType);
+            const result = getTypeOfListOrSetWithContext(node, (0, typeUtils_1.makeInferenceContext)(effectiveExpectedType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
             if (result && !result.typeErrors) {
                 return result;
             }
             expectedTypeDiagAddendum = result === null || result === void 0 ? void 0 : result.expectedTypeDiagAddendum;
         }
-        const typeResult = getTypeOfListOrSetInferred(node, /* hasExpectedType */ expectedType !== undefined);
+        const typeResult = getTypeOfListOrSetInferred(node, /* hasExpectedType */ inferenceContext !== undefined);
         return { ...typeResult, expectedTypeDiagAddendum };
     }
     // Attempts to determine the type of a list or set statement based on an expected type.
     // Returns undefined if that type cannot be honored.
-    function getTypeOfListOrSetExpected(node, expectedType) {
+    function getTypeOfListOrSetWithContext(node, inferenceContext) {
         const builtInClassName = node.nodeType === 31 /* List */ ? 'list' : 'set';
-        expectedType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(expectedType);
+        inferenceContext.expectedType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(inferenceContext.expectedType);
         let isIncomplete = false;
         let typeErrors = false;
         const verifyHashable = node.nodeType === 45 /* Set */;
-        if (!(0, types_1.isClassInstance)(expectedType)) {
+        if (!(0, types_1.isClassInstance)(inferenceContext.expectedType)) {
             return undefined;
         }
         const builtInListOrSet = getBuiltInObject(node, builtInClassName);
@@ -9191,7 +9230,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, expectedType, typeVarContext, getTypeVarScopesForNode(node))) {
+        if (!(0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, builtInListOrSet, inferenceContext.expectedType, typeVarContext, getTypeVarScopesForNode(node))) {
             return undefined;
         }
         const specializedListOrSet = (0, typeUtils_1.applySolvedTypeVars)(types_1.ClassType.cloneAsInstantiable(builtInListOrSet), typeVarContext);
@@ -9207,7 +9246,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 entryTypeResult = getElementTypeFromListComprehension(entry, expectedEntryType);
             }
             else {
-                entryTypeResult = getTypeOfExpression(entry, /* flags */ undefined, expectedEntryType);
+                entryTypeResult = getTypeOfExpression(entry, 
+                /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedEntryType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
             }
             entryTypes.push(entryTypeResult.type);
             if (entryTypeResult.isIncomplete) {
@@ -9223,7 +9263,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 verifySetEntryOrDictKeyIsHashable(entry, entryTypeResult.type, /* isDictKey */ false);
             }
         });
-        const isExpectedTypeListOrSet = (0, types_1.isClassInstance)(expectedType) && types_1.ClassType.isBuiltIn(expectedType, builtInClassName);
+        const isExpectedTypeListOrSet = (0, types_1.isClassInstance)(inferenceContext.expectedType) &&
+            types_1.ClassType.isBuiltIn(inferenceContext.expectedType, builtInClassName);
         const specializedEntryType = inferTypeArgFromExpectedType(expectedEntryType, entryTypes, 
         /* isNarrowable */ !isExpectedTypeListOrSet);
         if (!specializedEntryType) {
@@ -9346,13 +9387,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return undefined;
     }
-    function getTypeOfTernary(node, flags, expectedType) {
+    function getTypeOfTernary(node, flags, inferenceContext) {
         getTypeOfExpression(node.testExpression);
         const typesToCombine = [];
         let isIncomplete = false;
         let typeErrors = false;
         if (isNodeReachable(node.ifExpression)) {
-            const ifType = getTypeOfExpression(node.ifExpression, flags, expectedType);
+            const ifType = getTypeOfExpression(node.ifExpression, flags, inferenceContext);
             typesToCombine.push(ifType.type);
             if (ifType.isIncomplete) {
                 isIncomplete = true;
@@ -9362,7 +9403,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         if (isNodeReachable(node.elseExpression)) {
-            const elseType = getTypeOfExpression(node.elseExpression, flags, expectedType);
+            const elseType = getTypeOfExpression(node.elseExpression, flags, inferenceContext);
             typesToCombine.push(elseType.type);
             if (elseType.isIncomplete) {
                 isIncomplete = true;
@@ -9396,7 +9437,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         if (node.expression) {
-            const exprResult = getTypeOfExpression(node.expression, /* flags */ undefined, expectedYieldType);
+            const exprResult = getTypeOfExpression(node.expression, 
+            /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedYieldType));
             if (exprResult.isIncomplete) {
                 isIncomplete = true;
             }
@@ -9427,7 +9469,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return { type: returnedType || types_1.UnknownType.create() };
     }
-    function getTypeOfLambda(node, expectedType) {
+    function getTypeOfLambda(node, inferenceContext) {
         let isIncomplete = false;
         const functionType = types_1.FunctionType.createInstance('', '', '', 131072 /* PartiallyEvaluated */);
         functionType.details.typeVarScopeId = getScopeIdForNode(node);
@@ -9435,8 +9477,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // lambda depends on itself.
         writeTypeCache(node, { type: functionType, isIncomplete: true }, 0 /* None */);
         let expectedFunctionTypes = [];
-        if (expectedType) {
-            (0, typeUtils_1.mapSubtypes)(expectedType, (subtype) => {
+        if (inferenceContext) {
+            (0, typeUtils_1.mapSubtypes)(inferenceContext.expectedType, (subtype) => {
                 if ((0, types_1.isFunction)(subtype)) {
                     expectedFunctionTypes.push(subtype);
                 }
@@ -9526,16 +9568,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // evaluation scope for the return expression and do not allow retention
         // of the cached types.
         const inferLambdaReturnType = () => {
-            const returnTypeResult = getTypeOfExpression(node.expression, /* flags */ undefined, expectedReturnType);
+            const returnTypeResult = getTypeOfExpression(node.expression, 
+            /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedReturnType));
             functionType.inferredReturnType = returnTypeResult.type;
             if (returnTypeResult.isIncomplete) {
                 isIncomplete = true;
             }
         };
         if (speculativeTypeTracker.isSpeculative(node)) {
+            // 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 {
             inferLambdaReturnType();
@@ -9544,7 +9592,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         functionType.details.flags &= ~131072 /* PartiallyEvaluated */;
         return { type: functionType, isIncomplete };
     }
-    function getTypeOfListComprehension(node, expectedType) {
+    function getTypeOfListComprehension(node, inferenceContext) {
         var _a;
         let isIncomplete = false;
         let typeErrors = false;
@@ -9558,8 +9606,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             isAsync = true;
         }
         let expectedElementType;
-        if (expectedType) {
-            expectedElementType = (_a = getTypeOfIterator({ type: expectedType }, isAsync, /* errorNode */ undefined)) === null || _a === void 0 ? void 0 : _a.type;
+        if (inferenceContext) {
+            expectedElementType = (_a = getTypeOfIterator({ type: inferenceContext.expectedType }, isAsync, 
+            /* errorNode */ undefined)) === null || _a === void 0 ? void 0 : _a.type;
         }
         const elementTypeResult = getElementTypeFromListComprehension(node, expectedElementType);
         if (elementTypeResult.isIncomplete) {
@@ -9572,9 +9621,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Handle the special case where a generator function (e.g. `(await x for x in y)`)
         // is expected to be an AsyncGenerator.
         if (!isAsync &&
-            expectedType &&
-            (0, types_1.isClassInstance)(expectedType) &&
-            types_1.ClassType.isBuiltIn(expectedType, 'AsyncGenerator')) {
+            inferenceContext &&
+            (0, types_1.isClassInstance)(inferenceContext.expectedType) &&
+            types_1.ClassType.isBuiltIn(inferenceContext.expectedType, 'AsyncGenerator')) {
             isAsync = true;
         }
         const builtInIteratorType = getTypingType(node, isAsync ? 'AsyncGenerator' : 'Generator');
@@ -9652,7 +9701,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (node.expression.nodeType === 17 /* DictionaryKeyEntry */) {
             // Create a tuple with the key/value types.
             const keyTypeResult = getTypeOfExpression(node.expression.keyExpression, 
-            /* flags */ undefined, expectedKeyType);
+            /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedKeyType));
             if (keyTypeResult.isIncomplete) {
                 isIncomplete = true;
             }
@@ -9664,7 +9713,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 keyType = stripLiteralValue(keyType);
             }
             const valueTypeResult = getTypeOfExpression(node.expression.valueExpression, 
-            /* flags */ undefined, expectedValueOrElementType);
+            /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedValueOrElementType));
             if (valueTypeResult.isIncomplete) {
                 isIncomplete = true;
             }
@@ -9679,11 +9728,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         else if (node.expression.nodeType === 16 /* DictionaryExpandEntry */) {
             // The parser should have reported an error in this case because it's not allowed.
-            getTypeOfExpression(node.expression.expandExpression, /* flags */ undefined, expectedValueOrElementType);
+            getTypeOfExpression(node.expression.expandExpression, 
+            /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedValueOrElementType));
         }
         else if ((0, parseNodes_1.isExpressionNode)(node)) {
             const exprTypeResult = getTypeOfExpression(node.expression, 
-            /* flags */ undefined, expectedValueOrElementType);
+            /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedValueOrElementType));
             if (exprTypeResult.isIncomplete) {
                 isIncomplete = true;
             }
@@ -9885,7 +9935,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // If no type arguments are provided, the resulting type
             // depends on whether we're evaluating a type annotation or
             // we're in some other context.
-            if ((flags & 1024 /* ExpectingTypeAnnotation */) !== 0) {
+            if ((flags & 256 /* ExpectingTypeAnnotation */) !== 0) {
                 addError(localize_1.Localizer.Diagnostic.optionalExtraArgs(), errorNode);
                 return types_1.UnknownType.create();
             }
@@ -10009,7 +10059,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // Creates a ClassVar type.
     function createClassVarType(classType, errorNode, typeArgs, flags) {
         var _a;
-        if (flags & 131072 /* ClassVarDisallowed */) {
+        if (flags & 131072 /* DisallowClassVar */) {
             addError(localize_1.Localizer.Diagnostic.classVarNotAllowed(), errorNode);
             return types_1.AnyType.create();
         }
@@ -10042,7 +10092,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // depends on whether we're evaluating a type annotation or
         // we're in some other context.
         if (!typeArgs) {
-            if ((flags & 1024 /* ExpectingTypeAnnotation */) !== 0) {
+            if ((flags & 256 /* ExpectingTypeAnnotation */) !== 0) {
                 addError(localize_1.Localizer.Diagnostic.typeGuardArgCount(), errorNode);
             }
             return classType;
@@ -10103,7 +10153,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If no type arguments are provided, the resulting type
         // depends on whether we're evaluating a type annotation or
         // we're in some other context.
-        if (!typeArgs && (flags & 1024 /* ExpectingTypeAnnotation */) === 0) {
+        if (!typeArgs && (flags & 256 /* ExpectingTypeAnnotation */) === 0) {
             return classType;
         }
         if (!typeArgs || typeArgs.length !== 1) {
@@ -10124,7 +10174,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 isUsageLegal = true;
             }
         }
-        if ((flags & 1048576 /* RequiredAllowed */) !== 0) {
+        if ((flags & 1048576 /* AllowRequired */) !== 0) {
             isUsageLegal = true;
         }
         if (!isUsageLegal) {
@@ -10139,7 +10189,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If no type arguments are provided, the resulting type
         // depends on whether we're evaluating a type annotation or
         // we're in some other context.
-        if (!typeArgs && (flags & 1024 /* ExpectingTypeAnnotation */) === 0) {
+        if (!typeArgs && (flags & 256 /* ExpectingTypeAnnotation */) === 0) {
             return classType;
         }
         if (!typeArgs || typeArgs.length !== 1) {
@@ -10173,7 +10223,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     // Creates a "Final" type.
     function createFinalType(classType, errorNode, typeArgs, flags) {
-        if (flags & 16 /* FinalDisallowed */) {
+        if (flags & 16 /* DisallowFinal */) {
             addError(localize_1.Localizer.Diagnostic.finalContext(), errorNode);
             return types_1.AnyType.create();
         }
@@ -10330,7 +10380,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // If no type arguments are provided, the resulting type
             // depends on whether we're evaluating a type annotation or
             // we're in some other context.
-            if ((flags & 1024 /* ExpectingTypeAnnotation */) !== 0) {
+            if ((flags & 256 /* ExpectingTypeAnnotation */) !== 0) {
                 addError(localize_1.Localizer.Diagnostic.unionTypeArgCount(), errorNode);
                 return types_1.NeverType.createNever();
             }
@@ -10381,7 +10431,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // If no type arguments are provided, the resulting type
             // depends on whether we're evaluating a type annotation or
             // we're in some other context.
-            if ((flags & (1024 /* ExpectingTypeAnnotation */ | 262144 /* DisallowNakedGeneric */)) !== 0) {
+            if ((flags & (256 /* ExpectingTypeAnnotation */ | 262144 /* DisallowNakedGeneric */)) !== 0) {
                 addError(localize_1.Localizer.Diagnostic.genericTypeArgMissing(), errorNode);
             }
             return classType;
@@ -10611,7 +10661,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let flags = 0 /* None */;
         if (fileInfo.isStubFile) {
             // An assignment of ellipsis means "Any" within a type stub file.
-            flags |= 256 /* ConvertEllipsisToUnknown */;
+            flags |= 512 /* ConvertEllipsisToUnknown */;
         }
         if (node.rightExpression.nodeType === 38 /* Name */ ||
             node.rightExpression.nodeType === 35 /* MemberAccess */) {
@@ -10622,11 +10672,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if (isDeclaredTypeAlias(node.leftExpression)) {
             flags |=
-                64 /* ExpectingType */ |
+                128 /* ExpectingType */ |
                     8 /* EvaluateStringLiteralAsType */ |
-                    32 /* ParamSpecDisallowed */ |
-                    128 /* TypeVarTupleDisallowed */ |
-                    131072 /* ClassVarDisallowed */;
+                    32 /* DisallowParamSpec */ |
+                    64 /* DisallowTypeVarTuple */ |
+                    131072 /* DisallowClassVar */;
             flags &= ~2 /* DoNotSpecialize */;
         }
         // Is this type already cached?
@@ -10684,7 +10734,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         /* flags */ undefined);
                     }
                 }
-                const srcTypeResult = getTypeOfExpression(node.rightExpression, flags, declaredType);
+                const srcTypeResult = getTypeOfExpression(node.rightExpression, flags, (0, typeUtils_1.makeInferenceContext)(declaredType));
                 let srcType = srcTypeResult.type;
                 expectedTypeDiagAddendum = srcTypeResult.expectedTypeDiagAddendum;
                 if (srcTypeResult.isIncomplete) {
@@ -10714,12 +10764,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         (0, enums_1.transformTypeForPossibleEnumClass)(evaluatorInterface, node.leftExpression, () => rightHandType) || rightHandType;
                 }
                 if (typeAliasNameNode) {
-                    // Clear out the temporary types we wrote above.
-                    deleteTypeCacheEntry(node);
-                    deleteTypeCacheEntry(node.leftExpression);
-                    if (node.leftExpression.nodeType === 54 /* TypeAnnotation */) {
-                        deleteTypeCacheEntry(node.leftExpression.valueExpression);
-                    }
                     // If this was a speculative type alias, it becomes a real type alias
                     // only if the evaluated type is an instantiable type.
                     if (!isSpeculativeTypeAlias ||
@@ -10819,8 +10863,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (aliasTypeResult.isIncomplete) {
             isIncomplete = true;
         }
-        // Clear the temporary type we wrote above.
-        deleteTypeCacheEntry(node.name);
         aliasType = transformTypeForTypeAlias(aliasType, node.name, node.expression, typeParameters, (_a = node.typeParameters) === null || _a === void 0 ? void 0 : _a.parameters);
         if ((0, typeUtils_1.isTypeAliasRecursive)(typeAliasTypeVar, aliasType)) {
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasIsRecursiveDirect().format({
@@ -10843,7 +10885,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (readTypeCache(node, 0 /* None */)) {
             return;
         }
-        const destTypeResult = getTypeOfAugmentedAssignment(node, /* expectedType */ undefined);
+        const destTypeResult = getTypeOfAugmentedAssignment(node, /* inferenceContext */ undefined);
         writeTypeCache(node, destTypeResult, 0 /* None */);
     }
     function getPseudoGenericTypeVarName(paramName) {
@@ -10917,8 +10959,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let protocolTypeParameters;
         const initSubclassArgs = [];
         let metaclassNode;
-        let exprFlags = 64 /* ExpectingType */ |
-            512 /* AllowGenericClassType */ |
+        let exprFlags = 128 /* ExpectingType */ |
+            1024 /* AllowGenericClassType */ |
             262144 /* DisallowNakedGeneric */ |
             2048 /* DisallowTypeVarsWithScopeId */ |
             8192 /* AssociateTypeVarsWithCurrentScope */ |
@@ -11525,6 +11567,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     originalClassType.details.classDataClassTransform = (0, dataClasses_1.validateDataClassTransformDecorator)(evaluatorInterface, decoratorNode.expression);
                 }
             }
+            if ((0, types_1.isOverloadedFunction)(decoratorCallType)) {
+                if (decoratorCallType.overloads.length > 0 &&
+                    decoratorCallType.overloads[0].details.builtInName === 'deprecated') {
+                    originalClassType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
+                    return inputClassType;
+                }
+            }
         }
         if ((0, types_1.isOverloadedFunction)(decoratorType)) {
             const dataclassBehaviors = (0, dataClasses_1.getDataclassDecoratorBehaviors)(decoratorType);
@@ -11533,6 +11582,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 /* callNode */ undefined);
                 return inputClassType;
             }
+            if (decoratorType.overloads.length > 0 && decoratorType.overloads[0].details.builtInName === 'deprecated') {
+                originalClassType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
+                return inputClassType;
+            }
         }
         else if ((0, types_1.isFunction)(decoratorType)) {
             if (decoratorType.details.builtInName === 'final') {
@@ -11542,7 +11595,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // dependency between builtins, typing and _typeshed stubs.
                 return inputClassType;
             }
-            else if (decoratorType.details.builtInName === 'runtime_checkable') {
+            if (decoratorType.details.builtInName === 'runtime_checkable') {
                 originalClassType.details.flags |= 32768 /* RuntimeCheckable */;
                 // Don't call getTypeOfDecorator for runtime_checkable. It appears
                 // frequently in stubs, and it's a waste of time to validate its
@@ -11568,6 +11621,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return getTypeOfDecorator(decoratorNode, inputClassType);
     }
+    // Given a @typing.deprecated decorator node, returns either '' or a custom
+    // deprecation message if one is provided.
+    function getCustomDeprecationMessage(decorator) {
+        if (decorator.expression.nodeType === 9 /* Call */ &&
+            decorator.expression.arguments.length > 0 &&
+            decorator.expression.arguments[0].argumentCategory === 0 /* Simple */ &&
+            decorator.expression.arguments[0].valueExpression.nodeType === 48 /* StringList */ &&
+            decorator.expression.arguments[0].valueExpression.strings.length === 1) {
+            return decorator.expression.arguments[0].valueExpression.strings[0].value;
+        }
+        return '';
+    }
     // Runs any registered "callback hooks" that depend on the specified class type.
     // This allows us to complete any work that requires dependent classes to be
     // completed.
@@ -11602,7 +11667,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (initSubclassMethodType) {
                 validateCallArguments(errorNode, argList, { type: initSubclassMethodType }, 
                 /* typeVarContext */ undefined, 
-                /* skipUnknownArgCheck */ false, types_1.NoneType.createInstance());
+                /* skipUnknownArgCheck */ false, (0, typeUtils_1.makeInferenceContext)(types_1.NoneType.createInstance()));
             }
         }
         else if (classType.details.effectiveMetaclass && (0, types_1.isClass)(classType.details.effectiveMetaclass)) {
@@ -11852,7 +11917,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             let defaultValueType;
             if (param.defaultValue) {
-                defaultValueType = getTypeOfExpression(param.defaultValue, 1 /* ConvertEllipsisToAny */, annotatedType).type;
+                defaultValueType = getTypeOfExpression(param.defaultValue, 1 /* ConvertEllipsisToAny */, (0, typeUtils_1.makeInferenceContext)(annotatedType)).type;
             }
             if (annotatedType) {
                 // If there was both a type annotation and a default value, verify
@@ -12110,7 +12175,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // parameter is annotated with a "raw" function-scoped type variable, as in:
             //   "def foo(value: T = 3)"
             // In this case, we need to include the default value type in a union.
-            const defaultArgType = getTypeOfExpression(param.defaultValue, 1 /* ConvertEllipsisToAny */, type).type;
+            const defaultArgType = getTypeOfExpression(param.defaultValue, 1 /* ConvertEllipsisToAny */, (0, typeUtils_1.makeInferenceContext)(type)).type;
             if (!(0, types_1.isAny)(defaultArgType)) {
                 type = (0, types_1.combineTypes)([type, defaultArgType]);
             }
@@ -12310,6 +12375,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return inputFunctionType;
                 }
             }
+            if ((0, types_1.isOverloadedFunction)(decoratorCallType)) {
+                if (decoratorCallType.overloads.length > 0 &&
+                    decoratorCallType.overloads[0].details.builtInName === 'deprecated') {
+                    undecoratedType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
+                    return inputFunctionType;
+                }
+            }
         }
         let returnType = getTypeOfDecorator(decoratorNode, inputFunctionType);
         // Check for some built-in decorator types with known semantics.
@@ -12343,6 +12415,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
+        else if ((0, types_1.isOverloadedFunction)(decoratorType)) {
+            if (decoratorType.overloads.length > 0 && decoratorType.overloads[0].details.builtInName === 'deprecated') {
+                undecoratedType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
+                return inputFunctionType;
+            }
+        }
         else if ((0, types_1.isInstantiableClass)(decoratorType)) {
             if (types_1.ClassType.isBuiltIn(decoratorType)) {
                 switch (decoratorType.details.name) {
@@ -12756,7 +12834,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const additionalHelp = new diagnostic_1.DiagnosticAddendum();
             if ((0, types_1.isClass)(subtype)) {
                 let enterType = getTypeOfMagicMethodReturn(subtype, [], enterMethodName, node.expression, 
-                /* expectedType */ undefined);
+                /* inferenceContext */ undefined);
                 if (enterType) {
                     // For "async while", an implicit "await" is performed.
                     if (isAsync) {
@@ -12766,7 +12844,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 if (!isAsync) {
                     if (getTypeOfMagicMethodReturn(subtype, [], '__aenter__', node.expression, 
-                    /* expectedType */ undefined)) {
+                    /* inferenceContext */ undefined)) {
                         additionalHelp.addMessage(localize_1.Localizer.DiagnosticAddendum.asyncHelp());
                     }
                 }
@@ -12786,7 +12864,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if ((0, types_1.isClass)(subtype)) {
                 const anyArg = { type: types_1.AnyType.create() };
                 const exitType = getTypeOfMagicMethodReturn(subtype, [anyArg, anyArg, anyArg], exitMethodName, node.expression, 
-                /* expectedType */ undefined);
+                /* inferenceContext */ undefined);
                 if (exitType) {
                     return;
                 }
@@ -13170,18 +13248,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 nodeToEvaluate = parent;
                 continue;
             }
-            else {
-                // Check for expression types that are always contextual.
-                if (nodeToEvaluate.nodeType !== 15 /* Dictionary */ &&
-                    nodeToEvaluate.nodeType !== 31 /* List */ &&
-                    nodeToEvaluate.nodeType !== 30 /* Lambda */ &&
-                    nodeToEvaluate.nodeType !== 45 /* Set */ &&
-                    nodeToEvaluate.nodeType !== 52 /* Tuple */ &&
-                    nodeToEvaluate.nodeType !== 56 /* Unpack */ &&
-                    nodeToEvaluate.nodeType !== 32 /* ListComprehension */) {
-                    break;
-                }
-            }
             if (!(0, parseNodes_1.isExpressionNode)(parent)) {
                 // If we've hit a non-expression node, we generally want to
                 // stop. However, there are a few special "pass through"
@@ -13268,7 +13334,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     const declaredReturnType = enclosingFunctionNode
                         ? getFunctionDeclaredReturnType(enclosingFunctionNode)
                         : undefined;
-                    getTypeOfExpression(parent.returnExpression, 0 /* None */, declaredReturnType);
+                    getTypeOfExpression(parent.returnExpression, 0 /* None */, (0, typeUtils_1.makeInferenceContext)(declaredReturnType));
                     return;
                 }
                 break;
@@ -13444,16 +13510,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // don't bother doing additional work.
         let cacheEntry = readTypeCacheEntry(subnode);
         if (cacheEntry && !cacheEntry.typeResult.isIncomplete) {
-            return { type: cacheEntry.typeResult.type };
+            return cacheEntry.typeResult;
         }
         callback();
         cacheEntry = readTypeCacheEntry(subnode);
         if (cacheEntry) {
-            return {
-                type: cacheEntry.typeResult.type,
-                isIncomplete: cacheEntry.typeResult.isIncomplete,
-                expectedTypeDiagAddendum: cacheEntry.typeResult.expectedTypeDiagAddendum,
-            };
+            return cacheEntry.typeResult;
         }
         return undefined;
     }
@@ -13850,9 +13912,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return getTypeOfExpressionExpectingType(arg.valueExpression);
     }
     function getTypeOfExpressionExpectingType(node, options) {
-        let flags = 64 /* ExpectingType */ |
-            8 /* EvaluateStringLiteralAsType */ |
-            131072 /* ClassVarDisallowed */;
+        let flags = 128 /* ExpectingType */ | 8 /* EvaluateStringLiteralAsType */ | 131072 /* DisallowClassVar */;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         if (fileInfo.isStubFile) {
             flags |= 4 /* AllowForwardReferences */;
@@ -13861,19 +13921,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             flags |= 4194304 /* InterpreterParsesStringLiteral */;
         }
         if (!(options === null || options === void 0 ? void 0 : options.allowFinal)) {
-            flags |= 16 /* FinalDisallowed */;
+            flags |= 16 /* DisallowFinal */;
         }
         if (options === null || options === void 0 ? void 0 : options.allowRequired) {
-            flags |= 1048576 /* RequiredAllowed */ | 1024 /* ExpectingTypeAnnotation */;
+            flags |= 1048576 /* AllowRequired */ | 256 /* ExpectingTypeAnnotation */;
         }
         if (options === null || options === void 0 ? void 0 : options.allowUnpackedTuple) {
             flags |= 2097152 /* AllowUnpackedTupleOrTypeVarTuple */;
         }
         else {
-            flags |= 128 /* TypeVarTupleDisallowed */;
+            flags |= 64 /* DisallowTypeVarTuple */;
         }
         if (!(options === null || options === void 0 ? void 0 : options.allowParamSpec)) {
-            flags |= 32 /* ParamSpecDisallowed */;
+            flags |= 32 /* DisallowParamSpec */;
         }
         return getTypeOfExpression(node, flags);
     }
@@ -14004,8 +14064,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // Disables recording of errors and warnings and disables
     // any caching of types, under the assumption that we're
     // performing speculative evaluations.
-    function useSpeculativeMode(speculativeNode, callback) {
-        speculativeTypeTracker.enterSpeculativeContext(speculativeNode);
+    function useSpeculativeMode(speculativeNode, callback, allowCacheRetention = true) {
+        speculativeTypeTracker.enterSpeculativeContext(speculativeNode, allowCacheRetention);
         try {
             const result = callback();
             speculativeTypeTracker.leaveSpeculativeContext();
@@ -16225,6 +16285,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                     });
                 }
+                else if (remainingSrcSubtypes.length === 0) {
+                    // If we've assigned all of the source subtypes but one or more dest
+                    // TypeVars have gone unmatched, treat this as success.
+                    return true;
+                }
                 else {
                     // Try to assign a union of the remaining source types to
                     // the first destination TypeVar.