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

package/dist/analyzer/typeEvaluator.js

@@ -282,16 +282,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         effectiveTypeCache = new Map();
         expectedTypeCache = new Map();
     }
-    function isTypeCached(node) {
-        let cachedType;
-        if (returnTypeInferenceTypeCache && isNodeInReturnTypeInferenceContext(node)) {
-            cachedType = returnTypeInferenceTypeCache.get(node.id);
-        }
-        else {
-            cachedType = typeCache.get(node.id);
-        }
-        return cachedType !== undefined && !cachedType.isIncomplete;
-    }
     function readTypeCacheEntry(node) {
         // Should we use a temporary cache associated with a contextual
         // analysis of a function, contextualized based on call-site argument types?
@@ -302,10 +292,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return typeCache.get(node.id);
         }
     }
+    function isTypeCached(node) {
+        const cachedEntry = readTypeCacheEntry(node);
+        return cachedEntry !== undefined && !cachedEntry.typeResult.isIncomplete;
+    }
     function readTypeCache(node, flags) {
         var _a, _b;
         const cacheEntry = readTypeCacheEntry(node);
-        if (!cacheEntry || cacheEntry.isIncomplete) {
+        if (!cacheEntry || cacheEntry.typeResult.isIncomplete) {
             return undefined;
         }
         if (evaluatorOptions.verifyTypeCacheEvaluatorFlags || verifyTypeCacheEvaluatorFlags) {
@@ -327,33 +321,27 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
-        return cacheEntry.type;
+        return cacheEntry.typeResult.type;
     }
-    function writeTypeCache(node, type, flags, isIncomplete, 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)
             ? returnTypeInferenceTypeCache
             : typeCache;
-        typeCacheToUse.set(node.id, { type, isIncomplete, flags });
+        typeCacheToUse.set(node.id, { typeResult, flags });
         // If the entry is located within a part of the parse tree that is currently being
         // "speculatively" evaluated, track it so we delete the cached entry when we leave
         // this speculative context.
         if (speculativeTypeTracker.isSpeculative(node)) {
             speculativeTypeTracker.trackEntry(typeCacheToUse, node.id);
-            if (allowSpeculativeCaching) {
-                speculativeTypeTracker.addSpeculativeType(node, { type, isIncomplete }, expectedType);
+            if (allowSpeculativeCaching && !typeResult.isIncomplete) {
+                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, /* isIncomplete */ false);
+        writeTypeCache(node, { type }, flags);
     }
     function setAsymmetricDescriptorAssignment(node) {
         if (speculativeTypeTracker.isSpeculative(/* node */ undefined)) {
@@ -435,6 +423,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             evaluateTypesForExpressionInContext(node);
         })) === null || _a === void 0 ? void 0 : _a.type;
     }
+    function getTypeResult(node) {
+        return evaluateTypeForSubnode(node, () => {
+            evaluateTypesForExpressionInContext(node);
+        });
+    }
     // Reads the type of the node from the cache.
     function getCachedType(node) {
         return readTypeCache(node, 0 /* None */);
@@ -493,24 +486,24 @@ 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 cachedType = readTypeCache(node, flags);
-        if (cachedType) {
+        const cacheEntry = readTypeCacheEntry(node);
+        if (cacheEntry && !cacheEntry.typeResult.isIncomplete) {
             if (printExpressionTypes) {
-                console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Cached ${printType(cachedType)}`);
+                console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Cached ${printType(cacheEntry.typeResult.type)} ${cacheEntry.typeResult.typeErrors ? ' Errors' : ''}`);
             }
-            return { type: cachedType };
+            return cacheEntry.typeResult;
         }
         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)}`);
                 }
-                return { type: cachedTypeResult.type, isIncomplete: cachedTypeResult.isIncomplete };
+                return cachedTypeResult;
             }
         }
         if (printExpressionTypes) {
@@ -521,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);
@@ -543,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 */: {
@@ -573,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 */: {
@@ -594,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 */: {
@@ -637,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;
             }
@@ -666,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();
@@ -695,13 +690,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 typeResult.type.details.illegalRecursionDetected = true;
             }
         }
-        writeTypeCache(node, typeResult.type, flags, !!typeResult.isIncomplete, 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);
                 }
@@ -713,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),
         };
@@ -730,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 {
@@ -751,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) };
@@ -791,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) {
@@ -941,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 */;
@@ -2087,7 +2088,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (!isTypeIncomplete) {
             reportPossibleUnknownAssignment(fileInfo.diagnosticRuleSet.reportUnknownVariableType, diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, nameNode, destType, nameNode, ignoreEmptyContainers);
         }
-        writeTypeCache(nameNode, destType, 0 /* None */, isTypeIncomplete);
+        writeTypeCache(nameNode, { type: destType, isIncomplete: isTypeIncomplete }, 0 /* None */);
     }
     function assignTypeToMemberAccessNode(target, type, isTypeIncomplete, srcExpr, expectedTypeDiagAddendum) {
         const baseTypeResult = getTypeOfExpression(target.leftExpression, 2 /* DoNotSpecialize */);
@@ -2131,8 +2132,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (setTypeResult.isAsymmetricDescriptor) {
             setAsymmetricDescriptorAssignment(target);
         }
-        writeTypeCache(target.memberName, type, 0 /* None */, isTypeIncomplete);
-        writeTypeCache(target, type, 0 /* None */, isTypeIncomplete);
+        writeTypeCache(target.memberName, { type, isIncomplete: isTypeIncomplete }, 0 /* None */);
+        writeTypeCache(target, { type, isIncomplete: isTypeIncomplete }, 0 /* None */);
     }
     function assignTypeToMemberVariable(node, srcType, isTypeIncomplete, isInstanceMember, srcExprNode) {
         const memberName = node.memberName.value;
@@ -2307,7 +2308,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const targetType = typeList.length === 0 ? types_1.UnknownType.create() : (0, types_1.combineTypes)(typeList);
             assignTypeToExpression(expr, targetType, isTypeIncomplete, srcExpr, /* ignoreEmptyContainers */ true);
         });
-        writeTypeCache(target, type, 0 /* None */, isTypeIncomplete);
+        writeTypeCache(target, { type, isIncomplete: isTypeIncomplete }, 0 /* None */);
     }
     // Replaces all of the top-level TypeVars (as opposed to TypeVars
     // used as type arguments in other types) with their concrete form.
@@ -2534,7 +2535,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     setErrorNode: srcExpr,
                     setExpectedTypeDiag: expectedTypeDiagAddendum,
                 }, 0 /* None */);
-                writeTypeCache(target, type, 0 /* None */, isTypeIncomplete);
+                writeTypeCache(target, { type, isIncomplete: isTypeIncomplete }, 0 /* None */);
                 break;
             }
             case 31 /* List */:
@@ -2615,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({
@@ -2657,14 +2658,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             case 35 /* MemberAccess */: {
                 const baseTypeResult = getTypeOfExpression(node.leftExpression, 2 /* DoNotSpecialize */);
                 const memberType = getTypeOfMemberAccessWithBaseType(node, baseTypeResult, { method: 'del' }, 0 /* None */);
-                writeTypeCache(node.memberName, memberType.type, 0 /* None */, /* isIncomplete */ false);
-                writeTypeCache(node, memberType.type, 0 /* None */, /* isIncomplete */ false);
+                writeTypeCache(node.memberName, { type: memberType.type }, 0 /* None */);
+                writeTypeCache(node, { type: memberType.type }, 0 /* None */);
                 break;
             }
             case 24 /* Index */: {
                 const baseTypeResult = getTypeOfExpression(node.baseExpression, 2 /* DoNotSpecialize */);
                 getTypeOfIndexWithBaseType(node, baseTypeResult, { method: 'del' }, 0 /* None */);
-                writeTypeCache(node, types_1.UnboundType.create(), 0 /* None */, /* isIncomplete */ false);
+                writeTypeCache(node, { type: types_1.UnboundType.create() }, 0 /* None */);
                 break;
             }
             case 52 /* Tuple */: {
@@ -2766,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) {
@@ -2832,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;
@@ -2852,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);
@@ -2889,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();
             }
@@ -2897,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.
@@ -2917,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);
                 }
@@ -3037,7 +3038,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if (enclosingScope) {
                             // If the enclosing scope is using type parameter syntax, traditional
                             // type variables can't be used in this context.
-                            if (enclosingScope.typeParameters) {
+                            if (enclosingScope.typeParameters &&
+                                !enclosingScope.typeParameters.parameters.some((param) => param.name.value === type.details.name)) {
                                 addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeParameterNotDeclared().format({
                                     name: type.details.name,
                                     container: enclosingScope.name.value,
@@ -3090,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,
@@ -3102,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 &&
@@ -3256,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 */ |
@@ -3273,8 +3275,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const typeResult = getTypeOfMemberAccessWithBaseType(node, baseTypeResult, { method: 'get' }, flags | 2 /* DoNotSpecialize */);
         if ((0, codeFlowTypes_1.isCodeFlowSupportedForReference)(node)) {
             // Before performing code flow analysis, update the cache to prevent recursion.
-            writeTypeCache(node, typeResult.type, flags, /* isIncomplete */ true);
-            writeTypeCache(node.memberName, typeResult.type, flags, /* isIncomplete */ true);
+            writeTypeCache(node, { ...typeResult, isIncomplete: true }, flags);
+            writeTypeCache(node.memberName, { ...typeResult, isIncomplete: true }, flags);
             // If the type is initially unbound, see if there's a parent class that
             // potentially initialized the value.
             let typeAtStart = typeResult.type;
@@ -3297,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;
@@ -3307,14 +3309,12 @@ 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;
         }
         // Cache the type information in the member name node.
-        writeTypeCache(node.memberName, typeResult.type, flags, !!typeResult.isIncomplete);
+        writeTypeCache(node.memberName, typeResult, flags);
         return typeResult;
     }
     function getTypeOfMemberAccessWithBaseType(node, baseTypeResult, usage, flags) {
@@ -3382,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),
@@ -3687,7 +3687,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             // Don't include variables within typed dict classes.
-            if (types_1.ClassType.isTypedDictClass(classType)) {
+            if ((0, types_1.isClass)(memberInfo.classType) && types_1.ClassType.isTypedDictClass(memberInfo.classType)) {
                 const typedDecls = memberInfo.symbol.getTypedDeclarations();
                 if (typedDecls.length > 0 && typedDecls[0].type === 1 /* Variable */) {
                     diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.memberUnknown().format({ name: memberName }));
@@ -4142,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) {
@@ -4193,12 +4193,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             });
             if (baseTypeSupportsIndexNarrowing) {
                 // Before performing code flow analysis, update the cache to prevent recursion.
-                writeTypeCache(node, indexTypeResult.type, flags, /* isIncomplete */ false);
+                writeTypeCache(node, indexTypeResult, flags);
                 // See if we can refine the type based on code flow analysis.
                 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;
@@ -4206,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;
@@ -4455,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),
@@ -4791,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 */;
         }
@@ -4812,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,
                 };
             }
@@ -4862,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);
@@ -4886,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);
@@ -4895,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;
@@ -4922,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;
             }
@@ -4936,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)) {
@@ -4946,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);
@@ -4962,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);
@@ -4975,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));
@@ -5042,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) => {
@@ -5064,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 */ &&
@@ -5088,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;
                 }
@@ -5126,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 ||
@@ -5142,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 };
         }
@@ -5155,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;
@@ -5192,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 });
@@ -5396,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];
@@ -5434,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,
@@ -5485,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
@@ -5500,16 +5504,17 @@ 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;
         }
         return {
-            argumentErrors: false,
+            argumentErrors: finalCallResult.argumentErrors,
             isArgumentAnyOrUnknown: finalCallResult.isArgumentAnyOrUnknown,
             returnType: (0, types_1.combineTypes)(returnTypes),
             isTypeIncomplete,
             specializedInitSelfType: finalCallResult.specializedInitSelfType,
+            overloadsUsedForCall,
         };
     }
     function getBestOverloadForArguments(errorNode, type, argList) {
@@ -5549,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
@@ -5583,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.
@@ -5596,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
@@ -5607,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;
             }
@@ -5619,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) {
@@ -5649,9 +5654,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Replace the result with an unknown type since we don't know
             // what overload should have been used.
             result.returnType = types_1.UnknownType.create();
-            return result;
+            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
@@ -5703,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.
@@ -5727,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) {
@@ -5750,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;
@@ -5791,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) {
@@ -5807,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
@@ -5849,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;
             }
@@ -5881,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);
@@ -5890,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) {
@@ -5910,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))) {
@@ -5927,16 +5941,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 useSpeculativeMode(errorNode, () => {
                     callResult = validateCallArguments(errorNode, argList, { type: constructorMethodType }, typeVarContext.clone(), skipUnknownArgCheck);
                 });
-                if (!(callResult === null || callResult === void 0 ? void 0 : callResult.argumentErrors)) {
+                if (!callResult.argumentErrors) {
                     // Call validateCallArguments again, this time without speculative
                     // mode, so any errors are reported.
-                    const callResult = validateCallArguments(errorNode, argList, { type: constructorMethodType }, typeVarContext, skipUnknownArgCheck);
+                    callResult = validateCallArguments(errorNode, argList, { type: constructorMethodType }, typeVarContext, skipUnknownArgCheck);
                     if (callResult.isTypeIncomplete) {
                         isTypeIncomplete = true;
                     }
                     if (callResult.argumentErrors) {
                         argumentErrors = true;
                     }
+                    overloadsUsedForCall.push(...callResult.overloadsUsedForCall);
                     return applyExpectedSubtypeForConstructor(type, expectedSubType, typeVarContext);
                 }
             }
@@ -5945,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);
@@ -5960,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)) {
@@ -5983,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;
     }
@@ -5997,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)) {
@@ -6011,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) => {
@@ -6055,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;
                     }
@@ -6103,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;
                     }
@@ -6139,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
@@ -6235,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;
                         }
@@ -6275,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;
                             }
@@ -6307,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;
                     }
@@ -6325,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.
@@ -7130,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 */;
@@ -7150,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();
@@ -7372,6 +7394,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         let specializedReturnType = (0, typeUtils_1.addConditionToType)((0, typeUtils_1.applySolvedTypeVars)(returnType, typeVarContext, {
             unknownIfNotFound,
+            useUnknownOverDefault: skipUnknownArgCheck,
             eliminateUnsolvedInUnions,
         }), typeCondition);
         // If the final return type is an unpacked tuple, turn it into a normal (unpacked) tuple.
@@ -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, expectedType || argType, 0 /* None */, isTypeIncomplete);
+                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;
@@ -7997,7 +8021,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             });
             // Update the type cache so we don't attempt to re-evaluate this node.
             // The type doesn't matter, so use Any.
-            writeTypeCache(node, types_1.AnyType.create(), /* flags */ undefined, /* isIncomplete */ false);
+            writeTypeCache(node, { type: types_1.AnyType.create() }, /* flags */ undefined);
             return functionType;
         }
         else {
@@ -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 */) {
@@ -8297,10 +8324,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             else if (node.operator === 6 /* BitwiseOr */) {
                 // If this is a bitwise or ("|"), use the type of the left operand. This allows
                 // us to support the case where a TypedDict is being updated with a dict expression.
-                expectedOperandType = leftType;
+                if ((0, types_1.isClassInstance)(leftType) && types_1.ClassType.isTypedDictClass(leftType)) {
+                    expectedOperandType = leftType;
+                }
             }
         }
-        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;
@@ -8394,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);
@@ -8439,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 */],
@@ -8466,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)) {
@@ -8480,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
@@ -8500,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;
                 });
@@ -8523,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;
@@ -8577,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.
@@ -8624,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);
@@ -8688,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);
@@ -8716,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 &&
@@ -8733,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), [
@@ -8753,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 {
@@ -8784,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) => {
@@ -8812,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;
@@ -8860,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
@@ -8889,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, 
@@ -8918,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);
@@ -8937,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);
@@ -8954,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), 
@@ -9019,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;
                 }
@@ -9033,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);
@@ -9136,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
@@ -9164,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);
@@ -9189,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);
@@ -9205,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) {
@@ -9221,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) {
@@ -9344,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;
@@ -9360,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;
@@ -9394,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;
             }
@@ -9425,16 +9469,16 @@ 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);
         // Pre-cache the incomplete function type in case the evaluation of the
         // lambda depends on itself.
-        writeTypeCache(node, functionType, 0 /* None */, /* isIncomplete */ true);
+        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);
                 }
@@ -9468,8 +9512,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 paramType = types_1.FunctionType.getEffectiveParameterType(expectedFunctionType, index);
             }
             if (param.name) {
-                writeTypeCache(param.name, transformVariadicParamType(node, param.category, paramType), 0 /* None */, 
-                /* isIncomplete */ false);
+                writeTypeCache(param.name, { type: transformVariadicParamType(node, param.category, paramType) }, 0 /* None */);
             }
             if (param.defaultValue) {
                 // Evaluate the default value if it's present.
@@ -9525,13 +9568,18 @@ 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();
             }, 
@@ -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;
@@ -10559,7 +10609,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 specialType.details.baseClasses.push(strClassType !== null && strClassType !== void 0 ? strClassType : types_1.AnyType.create());
                 (0, typeUtils_1.computeMroLinearization)(specialType);
             }
-            writeTypeCache(node, specialType, 0 /* None */, /* isIncomplete */ false);
+            writeTypeCache(node, { type: specialType }, 0 /* None */);
             return specialType;
         }
         return undefined;
@@ -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?
@@ -10639,7 +10689,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (fileInfo.isTypingStubFile || fileInfo.isTypingExtensionsStubFile) {
                 rightHandType = handleTypingStubAssignment(node);
                 if (rightHandType) {
-                    writeTypeCache(node.rightExpression, rightHandType, 0 /* None */, /* isIncomplete */ false);
+                    writeTypeCache(node.rightExpression, { type: rightHandType }, 0 /* None */);
                 }
             }
             if (!rightHandType) {
@@ -10677,17 +10727,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     typeAliasTypeVar.details.recursiveTypeAliasScopeId = scopeId;
                     typeAliasTypeVar.scopeId = scopeId;
                     // Write the type back to the type cache. It will be replaced below.
-                    writeTypeCache(node, typeAliasTypeVar, /* flags */ undefined, /* isIncomplete */ false);
-                    writeTypeCache(node.leftExpression, typeAliasTypeVar, 
-                    /* flags */ undefined, 
-                    /* isIncomplete */ false);
+                    writeTypeCache(node, { type: typeAliasTypeVar }, /* flags */ undefined);
+                    writeTypeCache(node.leftExpression, { type: typeAliasTypeVar }, /* flags */ undefined);
                     if (node.leftExpression.nodeType === 54 /* TypeAnnotation */) {
-                        writeTypeCache(node.leftExpression.valueExpression, typeAliasTypeVar, 
-                        /* flags */ undefined, 
-                        /* isIncomplete */ false);
+                        writeTypeCache(node.leftExpression.valueExpression, { type: typeAliasTypeVar }, 
+                        /* 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) {
@@ -10717,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 ||
@@ -10753,7 +10794,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         assignTypeToExpression(node.leftExpression, rightHandType, isIncomplete, node.rightExpression, 
         /* ignoreEmptyContainers */ true, 
         /* allowAssignmentToFinalVar */ true, expectedTypeDiagAddendum);
-        writeTypeCache(node, rightHandType, 0 /* None */, isIncomplete);
+        writeTypeCache(node, { type: rightHandType, isIncomplete }, 0 /* None */);
     }
     function isPossibleTypeAliasOrTypedDict(decl) {
         var _a;
@@ -10800,7 +10841,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         typeAliasTypeVar.details.recursiveTypeAliasScopeId = scopeId;
         typeAliasTypeVar.scopeId = scopeId;
         // Write the type to the type cache. It will be replaced below.
-        writeTypeCache(node.name, typeAliasTypeVar, /* flags */ undefined, /* isIncomplete */ false);
+        writeTypeCache(node.name, { type: typeAliasTypeVar }, /* flags */ undefined);
         // Set a partial type to handle recursive (self-referential) type aliases.
         const scope = ScopeUtils.getScopeForNode(node);
         const typeAliasSymbol = scope === null || scope === void 0 ? void 0 : scope.lookUpSymbolRecursive(node.name.value);
@@ -10822,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({
@@ -10839,15 +10878,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 name: node.name.value,
             }), node.name);
         }
-        writeTypeCache(node.name, aliasType, 0 /* None */, isIncomplete);
+        writeTypeCache(node.name, { type: aliasType, isIncomplete }, 0 /* None */);
         return aliasType;
     }
     function evaluateTypesForAugmentedAssignment(node) {
         if (readTypeCache(node, 0 /* None */)) {
             return;
         }
-        const destTypeResult = getTypeOfAugmentedAssignment(node, /* expectedType */ undefined);
-        writeTypeCache(node, destTypeResult.type, 0 /* None */, !!destTypeResult.isIncomplete);
+        const destTypeResult = getTypeOfAugmentedAssignment(node, /* inferenceContext */ undefined);
+        writeTypeCache(node, destTypeResult, 0 /* None */);
     }
     function getPseudoGenericTypeVarName(paramName) {
         return `__type_of_${paramName}`;
@@ -10906,8 +10945,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             setSymbolResolutionPartialType(classSymbol, classDecl, classType);
         }
         classType.details.flags |= 131072 /* PartiallyEvaluated */;
-        writeTypeCache(node, classType, /* flags */ undefined, /* isIncomplete */ false);
-        writeTypeCache(node.name, classType, /* flags */ undefined, /* isIncomplete */ false);
+        writeTypeCache(node, { type: classType }, /* flags */ undefined);
+        writeTypeCache(node.name, { type: classType }, /* flags */ undefined);
         // Keep a list of unique type parameters that are used in the
         // base class arguments.
         let typeParameters = [];
@@ -10920,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 */ |
@@ -11330,9 +11369,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         // Update the undecorated class type.
-        writeTypeCache(node.name, classType, 0 /* None */, /* isIncomplete */ false);
+        writeTypeCache(node.name, { type: classType }, 0 /* None */);
         // Update the decorated class type.
-        writeTypeCache(node, decoratedType, 0 /* None */, /* isIncomplete */ false);
+        writeTypeCache(node, { type: decoratedType }, 0 /* None */);
         // Stash away a reference to the UnionType class if we encounter it.
         // There's no easy way to otherwise reference it.
         if (types_1.ClassType.isBuiltIn(classType, 'UnionType')) {
@@ -11345,7 +11384,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // parameters and updates the scope of the type parameter referred to in the
     // default type expression.
     function validateTypeParameterDefault(errorNode, typeParam, otherLiveTypeParams) {
-        if (!typeParam.details.defaultType) {
+        if (!typeParam.details.defaultType &&
+            !typeParam.details.isSynthesized &&
+            !typeParam.details.isSynthesizedSelf) {
             const typeVarWithDefault = otherLiveTypeParams.find((param) => param.details.defaultType);
             if (typeVarWithDefault) {
                 addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarWithoutDefault().format({
@@ -11444,7 +11485,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (!typeOfParam || !(0, types_1.isTypeVar)(typeOfParam)) {
                 return;
             }
-            writeTypeCache(param.name, typeOfParam, 0 /* None */, /* isIncomplete */ false);
+            writeTypeCache(param.name, { type: typeOfParam }, 0 /* None */);
             paramTypes.push(typeOfParam);
         });
         return paramTypes;
@@ -11526,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);
@@ -11534,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') {
@@ -11543,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
@@ -11569,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.
@@ -11603,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)) {
@@ -11743,8 +11807,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (functionDecl && functionSymbol) {
             setSymbolResolutionPartialType(functionSymbol.symbol, functionDecl, functionType);
         }
-        writeTypeCache(node, functionType, /* flags */ undefined, /* isIncomplete */ false);
-        writeTypeCache(node.name, functionType, /* flags */ undefined, /* isIncomplete */ false);
+        writeTypeCache(node, { type: functionType }, /* flags */ undefined);
+        writeTypeCache(node.name, { type: functionType }, /* flags */ undefined);
         // Is this an "__init__" method within a pseudo-generic class? If so,
         // we'll add generic types to the constructor's parameters.
         const addGenericParamTypes = containingClassType &&
@@ -11853,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
@@ -11954,7 +12018,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if ((0, types_1.isUnknown)(paramType)) {
                     functionType.details.flags |= 16384 /* UnannotatedParams */;
                 }
-                writeTypeCache(paramNameNode, paramType, 0 /* None */, /* isIncomplete */ false);
+                writeTypeCache(paramNameNode, { type: paramType }, 0 /* None */);
             }
         });
         // If the function ends in P.args and P.kwargs parameters, make it exempt from
@@ -12059,8 +12123,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             decoratedType = addOverloadsToFunctionType(node, decoratedType);
         }
-        writeTypeCache(node.name, functionType, 0 /* None */, /* isIncomplete */ false);
-        writeTypeCache(node, decoratedType, 0 /* None */, /* isIncomplete */ false);
+        writeTypeCache(node.name, { type: functionType }, 0 /* None */);
+        writeTypeCache(node, { type: decoratedType }, 0 /* None */);
         return { functionType, decoratedType };
     }
     // If the declared return type of a function contains type variables that
@@ -12111,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]);
             }
@@ -12311,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.
@@ -12344,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) {
@@ -12640,7 +12717,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                     }
                 }
-                writeTypeCache(node.suite, inferredReturnType, 0 /* None */, isIncomplete);
+                writeTypeCache(node.suite, { type: inferredReturnType, isIncomplete }, 0 /* None */);
             }
             finally {
                 functionRecursionMap.delete(node.id);
@@ -12683,7 +12760,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const iteratorTypeResult = getTypeOfExpression(node.iterableExpression);
         const iteratedType = (_b = (_a = getTypeOfIterator(iteratorTypeResult, !!node.isAsync, node.iterableExpression)) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
         assignTypeToExpression(node.targetExpression, iteratedType, !!iteratorTypeResult.isIncomplete, node.targetExpression);
-        writeTypeCache(node, iteratedType, 0 /* None */, !!iteratorTypeResult.isIncomplete);
+        writeTypeCache(node, { type: iteratedType, isIncomplete: !!iteratorTypeResult.isIncomplete }, 0 /* None */);
     }
     function evaluateTypesForExceptStatement(node) {
         // This should be called only if the except node has a target exception.
@@ -12733,7 +12810,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (node.name) {
             assignTypeToExpression(node.name, targetType, /* isIncomplete */ false, node.name);
         }
-        writeTypeCache(node, targetType, 0 /* None */, /* isIncomplete */ false);
+        writeTypeCache(node, { type: targetType }, 0 /* None */);
     }
     function evaluateTypesForWithStatement(node) {
         if (readTypeCache(node, 0 /* None */)) {
@@ -12757,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) {
@@ -12767,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());
                     }
                 }
@@ -12787,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;
                 }
@@ -12798,7 +12875,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (node.target) {
             assignTypeToExpression(node.target, scopedType, !!exprTypeResult.isIncomplete, node.target);
         }
-        writeTypeCache(node, scopedType, 0 /* None */, !!exprTypeResult.isIncomplete);
+        writeTypeCache(node, { type: scopedType, isIncomplete: !!exprTypeResult.isIncomplete }, 0 /* None */);
     }
     function evaluateTypesForImportAs(node) {
         var _a;
@@ -12830,7 +12907,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         assignTypeToNameNode(symbolNameNode, symbolType, /* isIncomplete */ false, /* ignoreEmptyContainers */ false);
-        writeTypeCache(node, symbolType, 0 /* None */, /* isIncomplete */ false);
+        writeTypeCache(node, { type: symbolType }, 0 /* None */);
     }
     function evaluateTypesForImportFromAs(node) {
         var _a;
@@ -12887,7 +12964,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         assignTypeToNameNode(aliasNode, symbolType, /* isIncomplete */ false, /* ignoreEmptyContainers */ false);
-        writeTypeCache(node, symbolType, 0 /* None */, /* isIncomplete */ false);
+        writeTypeCache(node, { type: symbolType }, 0 /* None */);
     }
     function evaluateTypesForMatchStatement(node) {
         if (readTypeCache(node, 0 /* None */)) {
@@ -12902,7 +12979,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 /* isPositiveTest */ false);
             }
         }
-        writeTypeCache(node, subjectType, 0 /* None */, !!subjectTypeResult.isIncomplete);
+        writeTypeCache(node, { type: subjectType, isIncomplete: !!subjectTypeResult.isIncomplete }, 0 /* None */);
     }
     function evaluateTypesForCaseStatement(node) {
         if (readTypeCache(node, 0 /* None */)) {
@@ -12936,7 +13013,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         subjectType = (0, patternMatching_1.narrowTypeBasedOnPattern)(evaluatorInterface, subjectType, node.pattern, 
         /* isPositiveTest */ true);
         (0, patternMatching_1.assignTypeToPatternTargets)(evaluatorInterface, subjectType, !!subjectTypeResult.isIncomplete, subjectIsObject, node.pattern);
-        writeTypeCache(node, subjectType, 0 /* None */, !!subjectTypeResult.isIncomplete);
+        writeTypeCache(node, { type: subjectType, isIncomplete: !!subjectTypeResult.isIncomplete }, 0 /* None */);
     }
     function evaluateTypesForImportFrom(node) {
         if (readTypeCache(node, 0 /* None */)) {
@@ -12958,7 +13035,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         assignTypeToNameNode(symbolNameNode, symbolType, /* isIncomplete */ false, /* ignoreEmptyContainers */ false);
-        writeTypeCache(node, symbolType, 0 /* None */, /* isIncomplete */ false);
+        writeTypeCache(node, { type: symbolType }, 0 /* None */);
     }
     function evaluateTypesForTypeAnnotationNode(node) {
         var _a;
@@ -12974,7 +13051,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 allowFinal: ParseTreeUtils.isFinalAllowedForAssignmentTarget(node.valueExpression),
                 allowClassVar: ParseTreeUtils.isClassVarAllowedForAssignmentTarget(node.valueExpression),
             });
-            writeTypeCache(node.valueExpression, annotationType, 0 /* None */, /* isIncomplete */ false);
+            writeTypeCache(node.valueExpression, { type: annotationType }, 0 /* None */);
         }
     }
     function getAliasedSymbolTypeForName(node, name) {
@@ -13171,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"
@@ -13269,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;
@@ -13311,7 +13376,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const param = functionNode.parameters[paramIndex];
             const annotatedType = getTypeOfParameterAnnotation(typeAnnotation, functionNode.parameters[paramIndex].category);
             const adjType = transformVariadicParamType(node, node.category, adjustParameterAnnotatedType(param, annotatedType));
-            writeTypeCache(node.name, adjType, 0 /* None */, /* isIncomplete */ false);
+            writeTypeCache(node.name, { type: adjType }, 0 /* None */);
             return;
         }
         const containingClassNode = ParseTreeUtils.getEnclosingClass(functionNode, /* stopAtFunction */ true);
@@ -13322,7 +13387,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const typeParamName = getPseudoGenericTypeVarName(node.name.value);
             const paramType = classInfo.classType.details.typeParameters.find((param) => param.details.name === typeParamName);
             if (paramType) {
-                writeTypeCache(node.name, paramType, 0 /* None */, /* isIncomplete */ false);
+                writeTypeCache(node.name, { type: paramType }, 0 /* None */);
                 return;
             }
         }
@@ -13331,8 +13396,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // a parent class if it has an annotated type.
         const functionFlags = getFunctionFlagsFromDecorators(functionNode, /* isInClass */ true);
         const inferredParamType = inferParameterType(functionNode, functionFlags, paramIndex, classInfo === null || classInfo === void 0 ? void 0 : classInfo.classType);
-        writeTypeCache(node.name, transformVariadicParamType(node, node.category, inferredParamType !== null && inferredParamType !== void 0 ? inferredParamType : types_1.UnknownType.create()), 0 /* None */, 
-        /* isIncomplete */ false);
+        writeTypeCache(node.name, { type: transformVariadicParamType(node, node.category, inferredParamType !== null && inferredParamType !== void 0 ? inferredParamType : types_1.UnknownType.create()) }, 0 /* None */);
     }
     // Evaluates the types that are assigned within the statement that contains
     // the specified parse node. In some cases, a broader statement may need to
@@ -13445,13 +13509,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If the type cache is already populated with a complete type,
         // don't bother doing additional work.
         let cacheEntry = readTypeCacheEntry(subnode);
-        if (cacheEntry && !cacheEntry.isIncomplete) {
-            return { type: cacheEntry.type };
+        if (cacheEntry && !cacheEntry.typeResult.isIncomplete) {
+            return cacheEntry.typeResult;
         }
         callback();
         cacheEntry = readTypeCacheEntry(subnode);
         if (cacheEntry) {
-            return { type: cacheEntry.type, isIncomplete: cacheEntry.isIncomplete };
+            return cacheEntry.typeResult;
         }
         return undefined;
     }
@@ -13848,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 */;
@@ -13859,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);
     }
@@ -14381,8 +14443,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // Cache the value before we evaluate the bound or the default type in
         // case it refers to itself in a circular manner.
-        writeTypeCache(node, typeVar, /* flags */ undefined, /* isIncomplete */ false);
-        writeTypeCache(node.name, typeVar, /* flags */ undefined, /* isIncomplete */ false);
+        writeTypeCache(node, { type: typeVar }, /* flags */ undefined);
+        writeTypeCache(node.name, { type: typeVar }, /* flags */ undefined);
         if (node.boundExpression) {
             if (node.boundExpression.nodeType === 52 /* Tuple */) {
                 const constraints = node.boundExpression.expressions.map((constraint) => {
@@ -14684,7 +14746,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return getEffectiveTypeOfSymbolForUsage(symbol).type;
     }
     function getEffectiveTypeOfSymbolForUsage(symbol, usageNode, useLastDecl = false) {
-        var _a;
+        var _a, _b;
         // If there's a declared type, it takes precedence over inferred types.
         if (symbol.hasTypedDeclarations()) {
             const declaredType = getDeclaredTypeOfSymbol(symbol, usageNode);
@@ -14708,7 +14770,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // Look in the cache to see if we've computed this already.
         let cacheEntries = effectiveTypeCache.get(symbol.id);
-        let evaluationAttempts = 0;
         const usageNodeId = usageNode ? usageNode.id : undefined;
         const effectiveTypeCacheKey = `${usageNodeId === undefined ? '.' : usageNodeId.toString()}${useLastDecl ? '*' : ''}`;
         if (cacheEntries) {
@@ -14717,7 +14778,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (!result.isIncomplete) {
                     return result;
                 }
-                evaluationAttempts = ((_a = result.evaluationAttempts) !== null && _a !== void 0 ? _a : 0) + 1;
             }
         }
         // Infer the type.
@@ -14845,20 +14905,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     isIncomplete = true;
                     // Note that at least one decl could not be evaluated because
-                    // it was already in the process of being evaluated. Don't set
-                    // this flag if we've already attempted the type evaluation
-                    // many times because this probably means there's a cyclical
-                    // dependency that cannot be broken.
-                    if (evaluationAttempts < maxEffectiveTypeEvaluationAttempts) {
-                        sawPendingEvaluation = true;
-                    }
+                    // it was already in the process of being evaluated.
+                    sawPendingEvaluation = true;
                 }
             }
         });
         if (typesToCombine.length > 0) {
+            // How many times have we already attempted to evaluate this declaration already?
+            const evaluationAttempts = ((_b = (_a = cacheEntries === null || cacheEntries === void 0 ? void 0 : cacheEntries.get(effectiveTypeCacheKey)) === null || _a === void 0 ? void 0 : _a.evaluationAttempts) !== null && _b !== void 0 ? _b : 0) + 1;
+            // Ignore the pending evaluation flag if we've already attempted the
+            // type evaluation many times because this probably means there's a
+            // cyclical dependency that cannot be broken.
+            isIncomplete = sawPendingEvaluation && evaluationAttempts < maxEffectiveTypeEvaluationAttempts;
             const result = {
                 type: (0, types_1.combineTypes)(typesToCombine),
-                isIncomplete: sawPendingEvaluation,
+                isIncomplete,
                 includesVariableDecl,
                 includesIllegalTypeAliasDecl: !decls.every((decl) => (0, declarationUtils_1.isPossibleTypeAliasDeclaration)(decl)),
                 isRecursiveDefinition: false,
@@ -14880,7 +14941,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             includesVariableDecl,
             includesIllegalTypeAliasDecl: !decls.every((decl) => (0, declarationUtils_1.isPossibleTypeAliasDeclaration)(decl)),
             isRecursiveDefinition: false,
-            evaluationAttempts,
         };
     }
     function getDeclaredTypeOfSymbol(symbol, usageNode) {
@@ -15139,7 +15199,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             paramType = types_1.UnknownType.create();
                         }
                         paramTypes.push(paramType);
-                        writeTypeCache(param.name, paramType, 0 /* None */, /* isIncomplete */ false);
+                        writeTypeCache(param.name, { type: paramType }, 0 /* None */);
                     }
                 });
                 // Don't bother trying to determine the contextual return
@@ -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.
@@ -16658,6 +16723,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (destDetails.argsIndex === undefined) {
             return;
         }
+        // If the *args parameter isn't an unpacked TypeVarTuple or tuple,
+        // we have nothing to do.
+        if (!(0, types_1.isUnpacked)(destDetails.params[destDetails.argsIndex].type)) {
+            return;
+        }
         // If the source doesn't have enough positional parameters, we have nothing to do.
         if (srcDetails.params.length < destDetails.argsIndex) {
             return;
@@ -16891,9 +16961,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // The converse situation is OK.
         if (!types_1.FunctionType.shouldSkipArgsKwargsCompatibilityCheck(destType) &&
             srcParamDetails.argsIndex === undefined &&
+            srcType.details.paramSpec === undefined &&
             destParamDetails.argsIndex !== undefined &&
-            !destParamDetails.hasUnpackedVariadicTypeVar &&
-            !targetIncludesParamSpec) {
+            !destParamDetails.hasUnpackedVariadicTypeVar) {
             diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.Localizer.DiagnosticAddendum.argsParamMissing().format({
                 paramName: (_h = destParamDetails.params[destParamDetails.argsIndex].param.name) !== null && _h !== void 0 ? _h : '',
             }));
@@ -17848,6 +17918,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     const evaluatorInterface = {
         runWithCancellationToken,
         getType,
+        getTypeResult,
         getCachedType,
         getTypeOfExpression,
         getTypeOfAnnotation,