@zzzen/pyright-internal 1.2.0-dev.20220703 → 1.2.0-dev.20220724

package/dist/analyzer/typeEvaluator.js

@@ -106,33 +106,31 @@ var MemberAccessFlags;
     MemberAccessFlags[MemberAccessFlags["SkipTypeBaseClass"] = 256] = "SkipTypeBaseClass";
 })(MemberAccessFlags || (MemberAccessFlags = {}));
 // Maps binary operators to the magic methods that implement them.
-// The boolean indicates whether the operators "chain" together.
 const binaryOperatorMap = {
-    [0 /* Add */]: ['__add__', '__radd__', false],
-    [33 /* Subtract */]: ['__sub__', '__rsub__', false],
-    [26 /* Multiply */]: ['__mul__', '__rmul__', false],
-    [13 /* FloorDivide */]: ['__floordiv__', '__rfloordiv__', false],
-    [10 /* Divide */]: ['__truediv__', '__rtruediv__', false],
-    [24 /* Mod */]: ['__mod__', '__rmod__', false],
-    [29 /* Power */]: ['__pow__', '__rpow__', false],
-    [22 /* MatrixMultiply */]: ['__matmul__', '__rmatmul__', false],
-    [3 /* BitwiseAnd */]: ['__and__', '__rand__', false],
-    [6 /* BitwiseOr */]: ['__or__', '__ror__', false],
-    [8 /* BitwiseXor */]: ['__xor__', '__rxor__', false],
-    [17 /* LeftShift */]: ['__lshift__', '__rlshift__', false],
-    [31 /* RightShift */]: ['__rshift__', '__rrshift__', false],
-    [12 /* Equals */]: ['__eq__', '__ne__', true],
-    [28 /* NotEquals */]: ['__ne__', '__eq__', true],
-    [20 /* LessThan */]: ['__lt__', '__ge__', true],
-    [21 /* LessThanOrEqual */]: ['__le__', '__gt__', true],
-    [15 /* GreaterThan */]: ['__gt__', '__le__', true],
-    [16 /* GreaterThanOrEqual */]: ['__ge__', '__lt__', true],
+    [0 /* Add */]: ['__add__', '__radd__'],
+    [33 /* Subtract */]: ['__sub__', '__rsub__'],
+    [26 /* Multiply */]: ['__mul__', '__rmul__'],
+    [13 /* FloorDivide */]: ['__floordiv__', '__rfloordiv__'],
+    [10 /* Divide */]: ['__truediv__', '__rtruediv__'],
+    [24 /* Mod */]: ['__mod__', '__rmod__'],
+    [29 /* Power */]: ['__pow__', '__rpow__'],
+    [22 /* MatrixMultiply */]: ['__matmul__', '__rmatmul__'],
+    [3 /* BitwiseAnd */]: ['__and__', '__rand__'],
+    [6 /* BitwiseOr */]: ['__or__', '__ror__'],
+    [8 /* BitwiseXor */]: ['__xor__', '__rxor__'],
+    [17 /* LeftShift */]: ['__lshift__', '__rlshift__'],
+    [31 /* RightShift */]: ['__rshift__', '__rrshift__'],
+    [12 /* Equals */]: ['__eq__', '__ne__'],
+    [28 /* NotEquals */]: ['__ne__', '__eq__'],
+    [20 /* LessThan */]: ['__lt__', '__ge__'],
+    [21 /* LessThanOrEqual */]: ['__le__', '__gt__'],
+    [15 /* GreaterThan */]: ['__gt__', '__le__'],
+    [16 /* GreaterThanOrEqual */]: ['__ge__', '__lt__'],
 };
-// Maps boolean operators to a boolean value indicating whether
-// the operators "chain" together with other comparison operators.
+// Map of operators that always return a bool result.
 const booleanOperatorMap = {
-    [36 /* And */]: false,
-    [37 /* Or */]: false,
+    [36 /* And */]: true,
+    [37 /* Or */]: true,
     [39 /* Is */]: true,
     [40 /* IsNot */]: true,
     [41 /* In */]: true,
@@ -182,6 +180,9 @@ const maxReturnTypeInferenceArgumentCount = 6;
 // when its parameters are unannotated? We want to keep this
 // pretty low because this can be very costly.
 const maxReturnTypeInferenceCodeFlowComplexity = 8;
+// What is the max number of return types cached per function
+// when using call-site inference?
+const maxCallSiteReturnTypeCacheSize = 8;
 // How many entries in a list, set, or dict should we examine
 // when inferring the type? We need to cut it off at some point
 // to avoid excessive computation.
@@ -209,7 +210,7 @@ const maxLiteralMathSubtypeCount = 64;
 // off code flow analysis at some point for code flow graphs that are too
 // complex. Otherwise we risk overflowing the stack or incurring extremely
 // long analysis times. This number has been tuned empirically.
-exports.maxCodeComplexity = 1024;
+exports.maxCodeComplexity = 768;
 function createTypeEvaluator(importLookup, evaluatorOptions) {
     const symbolResolutionStack = [];
     const typeCacheFlags = new Map();
@@ -231,6 +232,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     let functionObj;
     let tupleClassType;
     let boolClassType;
+    let intClassType;
     let strClassType;
     let dictClassType;
     let typedDictClassType;
@@ -279,6 +281,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return cachedType !== undefined;
     }
     function readTypeCache(node, flags) {
+        var _a, _b;
         let cachedType;
         // Should we use a temporary cache associated with a contextual
         // analysis of a function, contextualized based on call-site argument types?
@@ -295,8 +298,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (flags !== undefined) {
                 const expectedFlags = typeCacheFlags.get(node.id);
                 if (expectedFlags !== undefined && flags !== expectedFlags) {
-                    (0, debug_1.fail)(`Type cache flag mismatch for node type ${node.nodeType}: ` +
-                        `cached flags = ${expectedFlags}, access flags = ${flags}`);
+                    const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+                    const position = (0, positionUtils_1.convertOffsetToPosition)(node.start, fileInfo.lines);
+                    const message = `Type cache flag mismatch for node type ${node.nodeType} ` +
+                        `(parent ${(_b = (_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== null && _b !== void 0 ? _b : 'none'}): ` +
+                        `cached flags = ${expectedFlags}, access flags = ${flags}, ` +
+                        `file = {${fileInfo.filePath} [${position.line + 1}:${position.character + 1}]}`;
+                    if (evaluatorOptions.verifyTypeCacheEvaluatorFlags) {
+                        (0, debug_1.fail)(message);
+                    }
+                    else {
+                        console.log(message);
+                    }
                 }
             }
         }
@@ -424,9 +437,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // context. For example, if it's a subexpression of an argument expression,
     // the associated parameter type might inform the expected type.
     function getExpectedType(node) {
-        evaluateTypesForExpressionInContext(node);
+        // Scan up the parse tree to find the top-most expression node
+        // so we can evaluate the entire expression.
+        let topExpression = node;
         let curNode = node;
-        while (curNode !== undefined) {
+        while (curNode) {
+            if ((0, parseNodes_1.isExpressionNode)(curNode)) {
+                topExpression = curNode;
+            }
+            curNode = curNode.parent;
+        }
+        // Evaluate the expression. This will have the side effect of
+        // storing an expected type in the expected type cache.
+        evaluateTypesForExpressionInContext(topExpression);
+        // Look for the resulting expected type by scanning up the parse tree.
+        curNode = node;
+        while (curNode) {
             const expectedType = expectedTypeCache.get(curNode.id);
             if (expectedType) {
                 return {
@@ -434,6 +460,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     node: curNode,
                 };
             }
+            if (curNode === topExpression) {
+                break;
+            }
             curNode = curNode.parent;
         }
         return undefined;
@@ -452,6 +481,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             noneType = getTypeshedType(node, 'NoneType') || types_1.AnyType.create();
             tupleClassType = getBuiltInType(node, 'tuple');
             boolClassType = getBuiltInType(node, 'bool');
+            intClassType = getBuiltInType(node, 'int');
             strClassType = getBuiltInType(node, 'str');
             dictClassType = getBuiltInType(node, 'dict');
             typedDictClassType = getTypingType(node, '_TypedDict');
@@ -465,7 +495,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (printExpressionTypes) {
                 console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Cached ${printType(cachedType)}`);
             }
-            return { type: cachedType, node };
+            return { type: cachedType };
         }
         else {
             // Is it cached in the speculative type cache?
@@ -474,7 +504,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (printExpressionTypes) {
                     console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Speculative ${printType(speculativeCachedType)}`);
                 }
-                return { type: speculativeCachedType, node };
+                return { type: speculativeCachedType };
             }
         }
         if (printExpressionTypes) {
@@ -626,7 +656,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         getTypeOfExpression(node.child);
                     }
                 });
-                typeResult = { type: types_1.UnknownType.create(), node };
+                typeResult = { type: types_1.UnknownType.create() };
                 break;
             }
             default:
@@ -678,7 +708,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const exprTypeResult = getTypeOfExpression(node.expression, flags, effectiveExpectedType);
         const typeResult = {
             type: getTypeOfAwaitable(exprTypeResult.type, node.expression),
-            node,
         };
         if (exprTypeResult.isIncomplete) {
             typeResult.isIncomplete = true;
@@ -687,26 +716,26 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function getTypeOfEllipsis(flags, typeResult, node) {
         if ((flags & 1 /* ConvertEllipsisToAny */) !== 0) {
-            typeResult = { type: types_1.AnyType.create(/* isEllipsis */ true), node };
+            typeResult = { type: types_1.AnyType.create(/* isEllipsis */ true) };
         }
         else if ((flags & 256 /* ConvertEllipsisToUnknown */) !== 0) {
-            typeResult = { type: types_1.UnknownType.create(), node };
+            typeResult = { type: types_1.UnknownType.create() };
         }
         else {
             const ellipsisType = getBuiltInObject(node, 'ellipsis') || types_1.AnyType.create();
-            typeResult = { type: ellipsisType, node };
+            typeResult = { type: ellipsisType };
         }
         return typeResult;
     }
     function getTypeOfNumber(node, typeResult) {
         if (node.isImaginary) {
-            typeResult = { node, type: getBuiltInObject(node, 'complex') };
+            typeResult = { type: getBuiltInObject(node, 'complex') };
         }
         else if (node.isInteger) {
-            typeResult = { node, type: cloneBuiltinObjectWithLiteral(node, 'int', node.value) };
+            typeResult = { type: cloneBuiltinObjectWithLiteral(node, 'int', node.value) };
         }
         else {
-            typeResult = { node, type: getBuiltInObject(node, 'float') };
+            typeResult = { type: getBuiltInObject(node, 'float') };
         }
         return typeResult;
     }
@@ -725,17 +754,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((flags & 128 /* TypeVarTupleDisallowed */) === 0 &&
             (0, types_1.isVariadicTypeVar)(iterType) &&
             !iterType.isVariadicUnpacked) {
-            typeResult = { type: types_1.TypeVarType.cloneForUnpacked(iterType), node };
+            typeResult = { type: types_1.TypeVarType.cloneForUnpacked(iterType) };
         }
         else {
             if ((flags & 2097152 /* AllowUnpackedTupleOrTypeVarTuple */) !== 0 &&
                 (0, types_1.isInstantiableClass)(iterType) &&
                 types_1.ClassType.isBuiltIn(iterType, 'tuple')) {
-                typeResult = { type: types_1.ClassType.cloneForUnpacked(iterType), node };
+                typeResult = { type: types_1.ClassType.cloneForUnpacked(iterType) };
             }
             else {
                 const type = (_a = getTypeOfIterator(iterType, /* isAsync */ false, node)) !== null && _a !== void 0 ? _a : types_1.UnknownType.create(!!iterTypeResult.isIncomplete);
-                typeResult = { type, unpackedType: iterType, node, isIncomplete: iterTypeResult.isIncomplete };
+                typeResult = { type, unpackedType: iterType, isIncomplete: iterTypeResult.isIncomplete };
             }
         }
         return typeResult;
@@ -764,7 +793,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (!typeResult) {
                 const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
                 addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.expectedTypeNotString(), node);
-                typeResult = { node, type: types_1.UnknownType.create() };
+                typeResult = { type: types_1.UnknownType.create() };
             }
         }
         else {
@@ -780,13 +809,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Don't create a literal type if it's an f-string.
             if (node.strings.some((str) => str.nodeType === 27 /* FormatString */)) {
                 typeResult = {
-                    node,
                     type: getBuiltInObject(node, isBytes ? 'bytes' : 'str'),
                 };
             }
             else {
                 typeResult = {
-                    node,
                     type: cloneBuiltinObjectWithLiteral(node, isBytes ? 'bytes' : 'str', node.strings.map((s) => s.value).join('')),
                 };
             }
@@ -799,13 +826,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Don't create a literal type if it's an f-string.
         if (node.nodeType === 27 /* FormatString */) {
             typeResult = {
-                node,
                 type: getBuiltInObject(node, isBytes ? 'bytes' : 'str'),
             };
         }
         else {
             typeResult = {
-                node,
                 type: cloneBuiltinObjectWithLiteral(node, isBytes ? 'bytes' : 'str', node.value),
             };
         }
@@ -915,7 +940,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const argList = [
             {
                 argumentCategory: 0 /* Simple */,
-                type: functionOrClassType,
+                typeResult: { type: functionOrClassType },
             },
         ];
         const returnType = validateCallArguments(node.expression, argList, decoratorTypeResult, 
@@ -1138,7 +1163,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         /* isAccessedThroughObject */ true, memberName, usage, diag, memberAccessFlags | 8 /* DisallowClassVarWrites */, bindToType);
         if (memberInfo) {
             return {
-                node: errorNode,
                 type: memberInfo.type,
                 isIncomplete: !!memberInfo.isTypeIncomplete,
                 isAsymmetricDescriptor: memberInfo.isAsymmetricDescriptor,
@@ -1152,7 +1176,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let memberInfo;
         if (types_1.ClassType.isPartiallyEvaluated(classType)) {
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.classDefinitionCycle().format({ name: classType.details.name }), errorNode);
-            return { node: errorNode, type: types_1.UnknownType.create() };
+            return { type: types_1.UnknownType.create() };
         }
         if ((memberAccessFlags & 32 /* ConsiderMetaclassOnly */) === 0) {
             memberInfo = getTypeOfClassMemberName(errorNode, classType, 
@@ -1184,7 +1208,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if (memberInfo) {
             return {
-                node: errorNode,
                 type: memberInfo.type,
                 isIncomplete: !!memberInfo.isTypeIncomplete,
                 isAsymmetricDescriptor: memberInfo.isAsymmetricDescriptor,
@@ -1230,7 +1253,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         function addFakeArg() {
             argList.push({
                 argumentCategory: previousCategory,
-                type: types_1.UnknownType.create(),
+                typeResult: { type: types_1.UnknownType.create() },
                 active: true,
             });
         }
@@ -1272,10 +1295,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 addOneFunctionToSignature(type);
             }
             else {
-                type.overloads.forEach((func) => {
-                    if (types_1.FunctionType.isOverloaded(func)) {
-                        addOneFunctionToSignature(func);
-                    }
+                types_1.OverloadedFunctionType.getOverloads(type).forEach((func) => {
+                    addOneFunctionToSignature(func);
                 });
             }
         }
@@ -1477,13 +1498,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return subtype;
             }
             if ((0, types_1.isClassInstance)(subtype)) {
-                const awaitReturnType = getSpecializedReturnType(subtype, '__await__', errorNode);
+                const awaitReturnType = getSpecializedReturnType(subtype, '__await__', [], errorNode);
                 if (awaitReturnType) {
                     if ((0, types_1.isAnyOrUnknown)(awaitReturnType)) {
                         return awaitReturnType;
                     }
                     if ((0, types_1.isClassInstance)(awaitReturnType)) {
-                        const iterReturnType = getSpecializedReturnType(awaitReturnType, '__iter__', errorNode);
+                        const iterReturnType = getSpecializedReturnType(awaitReturnType, '__iter__', [], errorNode);
                         if (iterReturnType) {
                             const generatorReturnType = getReturnTypeFromGenerator(awaitReturnType);
                             if (generatorReturnType) {
@@ -1506,6 +1527,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const iterMethodName = isAsync ? '__aiter__' : '__iter__';
         const nextMethodName = isAsync ? '__anext__' : '__next__';
         let isValidIterator = true;
+        type = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(type);
         type = makeTopLevelTypeVarsConcrete(type);
         if ((0, typeUtils_1.isOptionalType)(type)) {
             if (errorNode) {
@@ -1528,18 +1550,27 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         subtype.tupleTypeArguments.length === 0) {
                         return types_1.NeverType.createNever();
                     }
-                    iterReturnType = getSpecializedReturnType(subtype, iterMethodName, errorNode);
+                    iterReturnType = getSpecializedReturnType(subtype, iterMethodName, [], errorNode);
                 }
                 else if (types_1.TypeBase.isInstantiable(subtype) &&
                     subtype.details.effectiveMetaclass &&
                     (0, types_1.isInstantiableClass)(subtype.details.effectiveMetaclass)) {
-                    iterReturnType = getSpecializedReturnType(types_1.ClassType.cloneAsInstance(subtype.details.effectiveMetaclass), iterMethodName, errorNode, subtype);
+                    iterReturnType = getSpecializedReturnType(types_1.ClassType.cloneAsInstance(subtype.details.effectiveMetaclass), iterMethodName, [], errorNode, subtype);
                 }
                 if (!iterReturnType) {
                     // There was no __iter__. See if we can fall back to
                     // the __getitem__ method instead.
-                    if ((0, types_1.isClassInstance)(subtype)) {
-                        const getItemReturnType = getSpecializedReturnType(subtype, '__getitem__', errorNode);
+                    if (!isAsync && (0, types_1.isClassInstance)(subtype)) {
+                        const getItemReturnType = getSpecializedReturnType(subtype, '__getitem__', [
+                            {
+                                argumentCategory: 0 /* Simple */,
+                                typeResult: {
+                                    type: intClassType && (0, types_1.isInstantiableClass)(intClassType)
+                                        ? types_1.ClassType.cloneAsInstance(intClassType)
+                                        : types_1.UnknownType.create(),
+                                },
+                            },
+                        ], errorNode);
                         if (getItemReturnType) {
                             return getItemReturnType;
                         }
@@ -1554,7 +1585,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             return subtype;
                         }
                         if ((0, types_1.isClassInstance)(subtype)) {
-                            const nextReturnType = getSpecializedReturnType(subtype, nextMethodName, errorNode);
+                            const nextReturnType = getSpecializedReturnType(subtype, nextMethodName, [], errorNode);
                             if (!nextReturnType) {
                                 iterReturnTypeDiag.addMessage(localize_1.Localizer.Diagnostic.methodNotDefinedOnType().format({
                                     name: nextMethodName,
@@ -1607,12 +1638,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if ((0, types_1.isClass)(subtype)) {
                 let iterReturnType;
                 if (types_1.TypeBase.isInstance(subtype)) {
-                    iterReturnType = getSpecializedReturnType(subtype, iterMethodName, errorNode);
+                    iterReturnType = getSpecializedReturnType(subtype, iterMethodName, [], errorNode);
                 }
                 else if (types_1.TypeBase.isInstantiable(subtype) &&
                     subtype.details.effectiveMetaclass &&
                     (0, types_1.isInstantiableClass)(subtype.details.effectiveMetaclass)) {
-                    iterReturnType = getSpecializedReturnType(types_1.ClassType.cloneAsInstance(subtype.details.effectiveMetaclass), iterMethodName, errorNode, subtype);
+                    iterReturnType = getSpecializedReturnType(types_1.ClassType.cloneAsInstance(subtype.details.effectiveMetaclass), iterMethodName, [], errorNode, subtype);
                 }
                 if (iterReturnType) {
                     return makeTopLevelTypeVarsConcrete(iterReturnType);
@@ -1760,6 +1791,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             fileInfo.diagnosticSink.addUnusedCodeWithTextRange(localize_1.Localizer.Diagnostic.unreachableCode(), textRange);
         }
     }
+    function addUnreachableCode(node, textRange) {
+        if (!isDiagnosticSuppressedForNode(node)) {
+            const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+            fileInfo.diagnosticSink.addUnreachableCodeWithTextRange(localize_1.Localizer.Diagnostic.unreachableCode(), textRange);
+        }
+    }
     function addDeprecated(message, node) {
         if (!isDiagnosticSuppressedForNode(node)) {
             const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
@@ -1886,9 +1923,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, 
-        /* expectedType */ undefined, 
-        /* allowSpeculativeCaching */ false);
+        writeTypeCache(nameNode, destType, 0 /* None */, isTypeIncomplete);
     }
     function assignTypeToMemberAccessNode(target, type, isTypeIncomplete, srcExpr, expectedTypeDiagAddendum) {
         const baseTypeResult = getTypeOfExpression(target.leftExpression, 2 /* DoNotSpecialize */);
@@ -1932,12 +1967,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (setTypeResult.isAsymmetricDescriptor) {
             setAsymmetricDescriptorAssignment(target);
         }
-        writeTypeCache(target.memberName, type, 0 /* None */, isTypeIncomplete, 
-        /* expectedType */ undefined, 
-        /* allowSpeculativeCaching */ false);
-        writeTypeCache(target, type, 0 /* None */, isTypeIncomplete, 
-        /* expectedType */ undefined, 
-        /* allowSpeculativeCaching */ false);
+        writeTypeCache(target.memberName, type, 0 /* None */, isTypeIncomplete);
+        writeTypeCache(target, type, 0 /* None */, isTypeIncomplete);
     }
     function assignTypeToMemberVariable(node, srcType, isTypeIncomplete, isInstanceMember, srcExprNode) {
         const memberName = node.memberName.value;
@@ -2146,7 +2177,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
                     return (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, [], 
                     /* isTypeArgumentExplicit */ true, 
-                    /* stripLiterals */ true, 
                     /* isUnpackedTuple */ true));
                 }
             }
@@ -2458,7 +2488,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 break;
             }
             case 35 /* MemberAccess */: {
-                const baseTypeResult = getTypeOfExpression(node.leftExpression);
+                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);
@@ -2514,7 +2544,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return undefined;
     }
-    function getSpecializedReturnType(objType, memberName, errorNode, bindToClass) {
+    function getSpecializedReturnType(objType, memberName, argList, errorNode, bindToClass) {
         const classMember = (0, typeUtils_1.lookUpObjectMember)(objType, memberName, 8 /* SkipInstanceVariables */);
         if (!classMember) {
             return undefined;
@@ -2523,13 +2553,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, types_1.isAnyOrUnknown)(memberType)) {
             return memberType;
         }
-        if ((0, types_1.isFunction)(memberType)) {
+        if ((0, types_1.isFunction)(memberType) || (0, types_1.isOverloadedFunction)(memberType)) {
             const methodType = bindFunctionToClassOrObject(bindToClass || objType, memberType, classMember && (0, types_1.isInstantiableClass)(classMember.classType) ? classMember.classType : undefined, errorNode, 
             /* recursionCount */ undefined, 
             /* treatConstructorAsClassMember */ false, 
             /* firstParamType */ bindToClass);
             if (methodType) {
-                return getFunctionEffectiveReturnType(methodType);
+                if ((0, types_1.isOverloadedFunction)(methodType)) {
+                    if (errorNode) {
+                        const bestOverload = getBestOverloadForArguments(errorNode, methodType, argList);
+                        if (bestOverload) {
+                            return getFunctionEffectiveReturnType(bestOverload);
+                        }
+                    }
+                }
+                else {
+                    return getFunctionEffectiveReturnType(methodType);
+                }
             }
         }
         return undefined;
@@ -2546,7 +2586,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const containingFunction = ParseTreeUtils.getEnclosingFunction(node);
             if (containingFunction && ParseTreeUtils.isUnannotatedFunction(containingFunction)) {
                 return {
-                    node,
                     type: types_1.AnyType.create(),
                     isIncomplete: false,
                 };
@@ -2690,7 +2729,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, types_1.isTypeVar)(type) && !type.details.isSynthesized) {
             type = validateTypeVarUsage(node, type, flags);
         }
-        return { type, node, isIncomplete };
+        return { type, isIncomplete };
     }
     // Handles the case where a variable or parameter is defined in an outer
     // scope and captured by an inner scope (either a function or a lambda).
@@ -2988,7 +3027,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const baseTypeResult = getTypeOfExpression(node.leftExpression, baseTypeFlags);
         if ((0, typeUtils_1.isTypeAliasPlaceholder)(baseTypeResult.type)) {
             return {
-                node,
                 type: types_1.UnknownType.create(/* isIncomplete */ true),
                 isIncomplete: true,
             };
@@ -3048,7 +3086,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If the base type was incomplete and unbound, don't proceed
         // because false positive errors will be generated.
         if (baseTypeResult.isIncomplete && (0, types_1.isUnbound)(baseTypeResult.type)) {
-            return { type: types_1.UnknownType.create(/* isIncomplete */ true), node, isIncomplete: true };
+            return { type: types_1.UnknownType.create(/* isIncomplete */ true), isIncomplete: true };
         }
         // Handle the special case where the expression is an actual
         // UnionType special form.
@@ -3084,22 +3122,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         const paramNode = ParseTreeUtils.getEnclosingParameter(node);
                         if (!paramNode || paramNode.category !== 1 /* VarArgList */) {
                             addError(localize_1.Localizer.Diagnostic.paramSpecArgsUsage(), node);
-                            return { type: types_1.UnknownType.create(isIncomplete), node, isIncomplete };
+                            return { type: types_1.UnknownType.create(isIncomplete), isIncomplete };
                         }
-                        return { type: types_1.TypeVarType.cloneForParamSpecAccess(baseType, 'args'), node, isIncomplete };
+                        return { type: types_1.TypeVarType.cloneForParamSpecAccess(baseType, 'args'), isIncomplete };
                     }
                     if (memberName === 'kwargs') {
                         const paramNode = ParseTreeUtils.getEnclosingParameter(node);
                         if (!paramNode || paramNode.category !== 2 /* VarArgDictionary */) {
                             addError(localize_1.Localizer.Diagnostic.paramSpecKwargsUsage(), node);
-                            return { type: types_1.UnknownType.create(isIncomplete), node, isIncomplete };
+                            return { type: types_1.UnknownType.create(isIncomplete), isIncomplete };
                         }
-                        return { type: types_1.TypeVarType.cloneForParamSpecAccess(baseType, 'kwargs'), node, isIncomplete };
+                        return { type: types_1.TypeVarType.cloneForParamSpecAccess(baseType, 'kwargs'), isIncomplete };
                     }
                     if (!isIncomplete) {
                         addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramSpecUnknownMember().format({ name: memberName }), node);
                     }
-                    return { type: types_1.UnknownType.create(isIncomplete), node, isIncomplete };
+                    return { type: types_1.UnknownType.create(isIncomplete), isIncomplete };
                 }
                 if (flags & 64 /* ExpectingType */) {
                     if (!isIncomplete) {
@@ -3108,14 +3146,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             name: memberName,
                         }), node.leftExpression);
                     }
-                    return { type: types_1.UnknownType.create(isIncomplete), node, isIncomplete };
+                    return { type: types_1.UnknownType.create(isIncomplete), isIncomplete };
                 }
                 if (baseType.details.recursiveTypeAliasName) {
-                    return { type: types_1.UnknownType.create(/* isIncomplete */ true), node, isIncomplete: true };
+                    return { type: types_1.UnknownType.create(/* isIncomplete */ true), isIncomplete: true };
                 }
                 return getTypeOfMemberAccessWithBaseType(node, {
                     type: makeTopLevelTypeVarsConcrete(baseType),
-                    node,
                     bindToType: baseType,
                     isIncomplete,
                 }, usage, 0 /* None */);
@@ -3146,14 +3183,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 const strClass = getBuiltInType(node, 'str');
                                 if ((0, types_1.isInstantiableClass)(strClass)) {
                                     return {
-                                        node,
                                         type: types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneWithLiteral(strClass, literalValue.itemName)),
                                         isIncomplete,
                                     };
                                 }
                             }
                             else if (memberName === 'value' || memberName === '_value_') {
-                                return { node, type: literalValue.itemType, isIncomplete };
+                                return { type: literalValue.itemType, isIncomplete };
                             }
                         }
                     }
@@ -3257,7 +3293,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     else {
                         const typeResult = getTypeOfMemberAccessWithBaseType(node, {
                             type: subtype,
-                            node,
                             isIncomplete: baseTypeResult.isIncomplete,
                         }, usage, 0 /* None */);
                         if (typeResult.isIncomplete) {
@@ -3289,7 +3324,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         type = types_1.AnyType.create();
                     }
                     else {
-                        type = getTypeOfMemberAccessWithBaseType(node, { type: functionObj, node }, usage, flags).type;
+                        type = getTypeOfMemberAccessWithBaseType(node, { type: functionObj }, usage, flags).type;
                     }
                 }
                 break;
@@ -3359,7 +3394,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 /* ignoreEmptyContainers */ false);
             }
         }
-        return { type, node, isIncomplete, isAsymmetricDescriptor };
+        return { type, isIncomplete, isAsymmetricDescriptor };
     }
     function getTypeOfClassMemberName(errorNode, classType, isAccessedThroughObject, memberName, usage, diag, flags, bindToType) {
         var _a, _b;
@@ -3569,25 +3604,27 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             {
                                 // Provide "obj" argument.
                                 argumentCategory: 0 /* Simple */,
-                                type: types_1.ClassType.isClassProperty(lookupClass)
-                                    ? baseTypeClass
-                                    : isAccessedThroughObject
-                                        ? bindToType || types_1.ClassType.cloneAsInstance(baseTypeClass)
-                                        : types_1.NoneType.createInstance(),
+                                typeResult: {
+                                    type: types_1.ClassType.isClassProperty(lookupClass)
+                                        ? baseTypeClass
+                                        : isAccessedThroughObject
+                                            ? bindToType || types_1.ClassType.cloneAsInstance(baseTypeClass)
+                                            : types_1.NoneType.createInstance(),
+                                },
                             },
                         ];
                         if (usage.method === 'get') {
                             // Provide "objtype" argument.
                             argList.push({
                                 argumentCategory: 0 /* Simple */,
-                                type: baseTypeClass,
+                                typeResult: { type: baseTypeClass },
                             });
                         }
                         else if (usage.method === 'set') {
                             // Provide "value" argument.
                             argList.push({
                                 argumentCategory: 0 /* Simple */,
-                                type: (_a = usage.setType) !== null && _a !== void 0 ? _a : types_1.UnknownType.create(),
+                                typeResult: { type: (_a = usage.setType) !== null && _a !== void 0 ? _a : types_1.UnknownType.create() },
                             });
                         }
                         if (types_1.ClassType.isPropertyClass(lookupClass) &&
@@ -3699,7 +3736,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         isFinal = types_1.FunctionType.isFinal(concreteSubtype);
                     }
                     else {
-                        const impl = concreteSubtype.overloads.find((f) => !types_1.FunctionType.isOverloaded(f));
+                        const impl = types_1.OverloadedFunctionType.getImplementation(concreteSubtype);
                         if (impl) {
                             isFinal = types_1.FunctionType.isFinal(impl);
                         }
@@ -3821,55 +3858,57 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     // Applies the __getattr__, __setattr__ or __delattr__ method if present.
     function applyAttributeAccessOverride(classType, errorNode, usage, memberName) {
-        var _a, _b, _c, _d;
-        if (usage.method === 'get') {
+        var _a, _b, _c;
+        const getAttributeAccessMember = (name) => {
+            var _a;
             // See if the class has a "__getattribute__" or "__getattr__" method.
             // If so, arbitrary members are supported.
-            let getAttrType = (_a = getTypeOfClassMember(errorNode, classType, '__getattribute__', { method: 'get' }, 
+            return (_a = getTypeOfClassMember(errorNode, classType, name, { method: 'get' }, 
             /* diag */ undefined, 4 /* SkipObjectBaseClass */ | 64 /* SkipAttributeAccessOverride */)) === null || _a === void 0 ? void 0 : _a.type;
-            if (!getAttrType) {
-                getAttrType = (_b = getTypeOfClassMember(errorNode, classType, '__getattr__', { method: 'get' }, 
-                /* diag */ undefined, 4 /* SkipObjectBaseClass */ | 64 /* SkipAttributeAccessOverride */)) === null || _b === void 0 ? void 0 : _b.type;
-            }
-            // If it's an overload, it might be based on the member name. Create
-            // a literal str type based on the member name and find the best overload.
-            if (getAttrType && (0, types_1.isOverloadedFunction)(getAttrType)) {
-                let nameLiteralType = types_1.AnyType.create();
-                if (strClassType && (0, types_1.isInstantiableClass)(strClassType)) {
-                    nameLiteralType = types_1.ClassType.cloneWithLiteral(types_1.ClassType.cloneAsInstance(strClassType), memberName);
-                }
-                getAttrType = getBestOverloadForArguments(errorNode, getAttrType, [
-                    {
-                        argumentCategory: 0 /* Simple */,
-                        type: types_1.AnyType.create(),
-                    },
-                    {
-                        argumentCategory: 0 /* Simple */,
-                        type: nameLiteralType,
-                    },
-                ]);
-            }
-            if (getAttrType && (0, types_1.isFunction)(getAttrType)) {
-                return getFunctionEffectiveReturnType(getAttrType);
-            }
+        };
+        let accessMemberType;
+        if (usage.method === 'get') {
+            accessMemberType = (_a = getAttributeAccessMember('__getattribute__')) !== null && _a !== void 0 ? _a : getAttributeAccessMember('__getattr__');
         }
         else if (usage.method === 'set') {
-            const setAttrType = (_c = getTypeOfClassMember(errorNode, classType, '__setattr__', { method: 'get' }, 
-            /* diag */ undefined, 4 /* SkipObjectBaseClass */ | 64 /* SkipAttributeAccessOverride */)) === null || _c === void 0 ? void 0 : _c.type;
-            if (setAttrType) {
-                // The type doesn't matter for a set usage. We just need
-                // to return a defined type.
-                return types_1.AnyType.create();
-            }
+            accessMemberType = getAttributeAccessMember('__setattr__');
         }
         else {
             (0, debug_1.assert)(usage.method === 'del');
-            const delAttrType = (_d = getTypeOfClassMember(errorNode, classType, '__detattr__', { method: 'get' }, 
-            /* diag */ undefined, 4 /* SkipObjectBaseClass */ | 64 /* SkipAttributeAccessOverride */)) === null || _d === void 0 ? void 0 : _d.type;
-            if (delAttrType) {
-                // The type doesn't matter for a delete usage. We just need
-                // to return a defined type.
-                return types_1.AnyType.create();
+            accessMemberType = getAttributeAccessMember('__delattr__');
+        }
+        if (accessMemberType) {
+            let nameLiteralType = types_1.AnyType.create();
+            if (strClassType && (0, types_1.isInstantiableClass)(strClassType)) {
+                nameLiteralType = types_1.ClassType.cloneWithLiteral(types_1.ClassType.cloneAsInstance(strClassType), memberName);
+            }
+            const argList = [
+                {
+                    // Provide "self" argument.
+                    argumentCategory: 0 /* Simple */,
+                    typeResult: { type: types_1.ClassType.cloneAsInstance(classType) },
+                },
+                {
+                    // Provide "name" argument.
+                    argumentCategory: 0 /* Simple */,
+                    typeResult: { type: nameLiteralType },
+                },
+            ];
+            if (usage.method === 'set') {
+                argList.push({
+                    // Provide "value" argument.
+                    argumentCategory: 0 /* Simple */,
+                    typeResult: { type: (_b = usage.setType) !== null && _b !== void 0 ? _b : types_1.UnknownType.create() },
+                });
+            }
+            if ((0, types_1.isFunction)(accessMemberType) || (0, types_1.isOverloadedFunction)(accessMemberType)) {
+                const boundMethodType = bindFunctionToClassOrObject(classType, accessMemberType, classType, errorNode);
+                if (boundMethodType && ((0, types_1.isFunction)(boundMethodType) || (0, types_1.isOverloadedFunction)(boundMethodType))) {
+                    const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(boundMethodType));
+                    const callResult = validateCallArguments(errorNode, argList, { type: boundMethodType }, typeVarContext, 
+                    /* skipUnknownArgCheck */ true);
+                    return (_c = callResult.returnType) !== null && _c !== void 0 ? _c : types_1.UnknownType.create();
+                }
             }
         }
         return undefined;
@@ -3994,7 +4033,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                         const tupleObject = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, variadicTypes, 
                         /* isTypeArgumentExplicit */ true, 
-                        /* stripLiterals */ true, 
                         /* isUnpackedTuple */ true));
                         typeArgs = [
                             ...typeArgs.slice(0, variadicIndex),
@@ -4009,7 +4047,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         node: errorNode,
                         type: (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, [], 
                         /* isTypeArgumentExplicit */ true, 
-                        /* stripLiterals */ true, 
                         /* isUnpackedTuple */ true)),
                     });
                 }
@@ -4170,9 +4207,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, typeUtils_1.isTypeAliasPlaceholder)(baseTypeResult.type)) {
             const typeArgTypes = getTypeArgs(node, flags).map((t) => (0, typeUtils_1.convertToInstance)(t.type));
             const type = types_1.TypeBase.cloneForTypeAlias(baseTypeResult.type, baseTypeResult.type.details.recursiveTypeAliasName, '', baseTypeResult.type.details.recursiveTypeAliasScopeId, baseTypeResult.type.details.recursiveTypeParameters, typeArgTypes);
-            return { type, node };
+            return { type };
         }
-        let isIncomplete = false;
+        let isIncomplete = baseTypeResult.isIncomplete;
         const type = mapSubtypesExpandTypeVars(baseTypeResult.type, 
         /* conditionFilter */ undefined, (concreteSubtype, unexpandedSubtype) => {
             var _a;
@@ -4267,11 +4304,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if ((0, types_1.isNever)(concreteSubtype)) {
                 return types_1.UnknownType.create();
             }
-            if ((0, types_1.isNoneInstance)(concreteSubtype)) {
+            if ((0, types_1.isNoneInstance)(concreteSubtype) && !isIncomplete) {
                 addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportOptionalSubscript, diagnosticRules_1.DiagnosticRule.reportOptionalSubscript, localize_1.Localizer.Diagnostic.noneNotSubscriptable(), node.baseExpression);
                 return types_1.UnknownType.create();
             }
-            if (!(0, types_1.isUnbound)(concreteSubtype)) {
+            if (!(0, types_1.isUnbound)(concreteSubtype) && !isIncomplete) {
                 const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
                 addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeNotSubscriptable().format({ type: printType(concreteSubtype) }), node.baseExpression);
             }
@@ -4286,7 +4323,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             });
         }
-        return { type, node, isIncomplete };
+        return { type, isIncomplete };
     }
     function makeTupleObject(entryTypes, isUnspecifiedLength = false) {
         if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
@@ -4331,7 +4368,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 name: magicMethodName,
                 type: printType(baseType),
             }), node.baseExpression);
-            return { node, type: types_1.UnknownType.create() };
+            return { type: types_1.UnknownType.create() };
         }
         // Handle the special case where the object is a Tuple and
         // the index is a constant number (integer) or a slice with integer
@@ -4352,11 +4389,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const tupleType = (0, typeUtils_1.getSpecializedTupleType)(baseType);
                 if (tupleType && tupleType.tupleTypeArguments && !(0, typeUtils_1.isUnboundedTupleClass)(tupleType)) {
                     if (indexValue >= 0 && indexValue < tupleType.tupleTypeArguments.length) {
-                        return { node, type: tupleType.tupleTypeArguments[indexValue].type };
+                        return { type: tupleType.tupleTypeArguments[indexValue].type };
                     }
                     else if (indexValue < 0 && tupleType.tupleTypeArguments.length + indexValue >= 0) {
                         return {
-                            node,
                             type: tupleType.tupleTypeArguments[tupleType.tupleTypeArguments.length + indexValue].type,
                         };
                     }
@@ -4394,7 +4430,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             tupleClassType &&
                             (0, types_1.isInstantiableClass)(tupleClassType)) {
                             return {
-                                node,
                                 type: types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleClassType, tupleType.tupleTypeArguments.slice(startValue, endValue))),
                             };
                         }
@@ -4408,9 +4443,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const keywordArgs = node.items.filter((item) => item.argumentCategory === 0 /* Simple */ && !!item.name);
         const unpackedDictArgs = node.items.filter((item) => item.argumentCategory === 2 /* UnpackedDictionary */);
         let positionalIndexType;
+        let isPositionalIndexTypeIncomplete = false;
         if (positionalArgs.length === 1 && unpackedListArgs.length === 0 && !node.trailingComma) {
             // Handle the common case where there is a single positional argument.
-            positionalIndexType = getTypeOfExpression(positionalArgs[0].valueExpression).type;
+            const typeResult = getTypeOfExpression(positionalArgs[0].valueExpression);
+            positionalIndexType = typeResult.type;
+            if (typeResult.isIncomplete) {
+                isPositionalIndexTypeIncomplete = true;
+            }
         }
         else if (positionalArgs.length === 0 && unpackedListArgs.length === 0) {
             // Handle the case where there are no positionals provided but there are keywords.
@@ -4423,11 +4463,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Package up all of the positionals into a tuple.
             const tupleEntries = [];
             positionalArgs.forEach((arg) => {
-                tupleEntries.push(getTypeOfExpression(arg.valueExpression).type);
+                const typeResult = getTypeOfExpression(arg.valueExpression);
+                tupleEntries.push(typeResult.type);
+                if (typeResult.isIncomplete) {
+                    isPositionalIndexTypeIncomplete = true;
+                }
             });
             unpackedListArgs.forEach((arg) => {
-                const exprType = getTypeOfExpression(arg.valueExpression).type;
-                const iterableType = getTypeOfIterator(exprType, /* isAsync */ false, arg) || types_1.UnknownType.create();
+                const typeResult = getTypeOfExpression(arg.valueExpression);
+                const exprType = typeResult.type;
+                if (typeResult.isIncomplete) {
+                    isPositionalIndexTypeIncomplete = true;
+                }
+                const iterableType = getTypeOfIterator(exprType, /* isAsync */ false, arg.valueExpression) || types_1.UnknownType.create();
                 tupleEntries.push(iterableType);
             });
             positionalIndexType = makeTupleObject(tupleEntries, unpackedListArgs.length > 0);
@@ -4435,7 +4483,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let argList = [
             {
                 argumentCategory: 0 /* Simple */,
-                type: positionalIndexType,
+                typeResult: { type: positionalIndexType, isIncomplete: isPositionalIndexTypeIncomplete },
             },
         ];
         if (usage.method === 'set') {
@@ -4447,7 +4495,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             argList.push({
                 argumentCategory: 0 /* Simple */,
-                type: setType,
+                typeResult: { type: setType, isIncomplete: isPositionalIndexTypeIncomplete },
             });
         }
         keywordArgs.forEach((arg) => {
@@ -4469,32 +4517,33 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Speculatively attempt the call. We may need to replace the index
         // type with 'int', and we don't want to emit errors before we know
         // which type to use.
-        useSpeculativeMode(node, () => {
-            callResult = validateCallArguments(node, argList, { type: itemMethodType });
-            if (callResult.argumentErrors) {
-                // If the object supports "__index__" magic method, convert
-                // the index it to an int and try again.
-                if ((0, types_1.isClassInstance)(positionalIndexType) && keywordArgs.length === 0 && unpackedDictArgs.length === 0) {
-                    const altArgList = [...argList];
-                    altArgList[0] = { ...altArgList[0] };
-                    const indexMethod = getTypeOfObjectMember(node, positionalIndexType, '__index__');
-                    if (indexMethod) {
-                        const intType = getBuiltInObject(node, 'int');
-                        if ((0, types_1.isClassInstance)(intType)) {
-                            altArgList[0].type = intType;
+        if (keywordArgs.length === 0 && unpackedDictArgs.length === 0 && positionalArgs.length === 1) {
+            useSpeculativeMode(node, () => {
+                callResult = validateCallArguments(node, argList, { type: itemMethodType });
+                if (callResult.argumentErrors) {
+                    // If the object supports "__index__" magic method, convert
+                    // the index to an int and try again.
+                    if ((0, types_1.isClassInstance)(positionalIndexType)) {
+                        const altArgList = [...argList];
+                        altArgList[0] = { ...altArgList[0] };
+                        const indexMethod = getTypeOfObjectMember(node, positionalIndexType, '__index__');
+                        if (indexMethod) {
+                            const intType = getBuiltInObject(node, 'int');
+                            if ((0, types_1.isClassInstance)(intType)) {
+                                altArgList[0].typeResult = { type: intType };
+                            }
+                        }
+                        callResult = validateCallArguments(node, altArgList, { type: itemMethodType });
+                        // We were successful, so replace the arg list.
+                        if (!callResult.argumentErrors) {
+                            argList = altArgList;
                         }
-                    }
-                    callResult = validateCallArguments(node, altArgList, { type: itemMethodType });
-                    // We were successful, so replace the arg list.
-                    if (!callResult.argumentErrors) {
-                        argList = altArgList;
                     }
                 }
-            }
-        });
+            });
+        }
         callResult = validateCallArguments(node, argList, { type: itemMethodType });
         return {
-            node,
             type: (_c = callResult.returnType) !== null && _c !== void 0 ? _c : types_1.UnknownType.create(),
             isIncomplete: !!callResult.isTypeIncomplete,
         };
@@ -4522,10 +4571,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // treated as types. If it's an Annotated[a, b, c], only the first index
             // 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 */ |
-                    2 /* DoNotSpecialize */ |
-                    131072 /* ClassVarDisallowed */);
+                typeResult = {
+                    ...getTypeOfExpression(expr, 32 /* ParamSpecDisallowed */ |
+                        128 /* TypeVarTupleDisallowed */ |
+                        2 /* DoNotSpecialize */ |
+                        131072 /* ClassVarDisallowed */),
+                    node: expr,
+                };
             }
             else {
                 typeResult = getTypeArg(expr, adjFlags);
@@ -4571,7 +4623,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let typeResult;
         let adjustedFlags = flags |
             64 /* ExpectingType */ |
-            1024 /* ExpectingTypeAnnotation */ |
             1 /* ConvertEllipsisToAny */ |
             8 /* EvaluateStringLiteralAsType */;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
@@ -4581,14 +4632,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (node.nodeType === 31 /* List */) {
             typeResult = {
                 type: types_1.UnknownType.create(),
-                typeList: node.entries.map((entry) => getTypeOfExpression(entry, adjustedFlags)),
+                typeList: node.entries.map((entry) => {
+                    return { ...getTypeOfExpression(entry, adjustedFlags), node: entry };
+                }),
                 node,
             };
             // Set the node's type so it isn't reevaluated later.
             setTypeForNode(node, types_1.UnknownType.create());
         }
         else {
-            typeResult = getTypeOfExpression(node, adjustedFlags);
+            typeResult = { ...getTypeOfExpression(node, adjustedFlags), node };
             // "Protocol" is not allowed as a type argument.
             if ((0, types_1.isClass)(typeResult.type) && types_1.ClassType.isBuiltIn(typeResult.type, 'Protocol')) {
                 addError(localize_1.Localizer.Diagnostic.protocolNotAllowedInTypeArgument(), node);
@@ -4604,7 +4657,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function getTypeOfTuple(node, expectedType, flags) {
         if ((flags & 64 /* ExpectingType */) !== 0 && node.expressions.length === 0 && !expectedType) {
-            return { type: makeTupleObject([]), node, isEmptyTupleShorthand: true };
+            return { type: makeTupleObject([]), isEmptyTupleShorthand: true };
         }
         // If the expected type is a union, recursively call for each of the subtypes
         // to find one that matches.
@@ -4681,20 +4734,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         const entryTypeResults = node.expressions.map((expr, index) => getTypeOfExpression(expr, 
         /* flags */ undefined, index < expectedTypes.length ? expectedTypes[index] : undefined));
-        const expectedTypesContainLiterals = expectedTypes.some((type) => (0, typeUtils_1.isLiteralTypeOrUnion)(type));
         const type = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, buildTupleTypesList(entryTypeResults), 
-        /* isTypeArgumentExplicit */ true, 
-        /* stripLiterals */ !expectedTypesContainLiterals));
-        return { type, node };
+        /* isTypeArgumentExplicit */ true));
+        return { type };
     }
     function getTypeOfTupleInferred(node) {
         const entryTypeResults = node.expressions.map((expr) => getTypeOfExpression(expr));
         const isIncomplete = entryTypeResults.some((result) => result.isIncomplete);
         if (!tupleClassType || !(0, types_1.isInstantiableClass)(tupleClassType)) {
-            return { type: types_1.UnknownType.create(), node };
+            return { type: types_1.UnknownType.create() };
         }
         const type = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, buildTupleTypesList(entryTypeResults)));
-        return { type, node, isIncomplete };
+        return { type, isIncomplete };
     }
     function buildTupleTypesList(entryTypeResults) {
         const entryTypes = [];
@@ -4750,7 +4801,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             };
             return functionArg;
         });
-        let typeResult = { node, type: types_1.UnknownType.create() };
+        let typeResult = { type: types_1.UnknownType.create() };
         if (!(0, typeUtils_1.isTypeAliasPlaceholder)(baseTypeResult.type)) {
             if (node.leftExpression.nodeType === 38 /* Name */ && node.leftExpression.value === 'super') {
                 // Handle the built-in "super" call specially.
@@ -4824,7 +4875,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if ((flags & 1024 /* ExpectingTypeAnnotation */) !== 0) {
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAnnotationCall(), node);
-            typeResult = { node, type: types_1.UnknownType.create() };
+            typeResult = { type: types_1.UnknownType.create() };
         }
         return typeResult;
     }
@@ -4835,12 +4886,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             node.arguments[0].argumentCategory !== 0 /* Simple */ ||
             node.arguments[1].name !== undefined) {
             addError(localize_1.Localizer.Diagnostic.assertTypeArgs(), node);
-            return { node, type: types_1.UnknownType.create() };
+            return { type: types_1.UnknownType.create() };
         }
         const arg0TypeResult = getTypeOfExpression(node.arguments[0].valueExpression, 
         /* flags */ undefined, expectedType);
         if (arg0TypeResult.isIncomplete) {
-            return { node, type: types_1.UnknownType.create(/* isIncomplete */ true), isIncomplete: true };
+            return { type: types_1.UnknownType.create(/* isIncomplete */ true), isIncomplete: true };
         }
         const assertedType = (0, typeUtils_1.convertToInstance)(getTypeOfArgumentExpectingType(node.arguments[1]).type);
         if (!(0, types_1.isTypeSame)(assertedType, arg0TypeResult.type)) {
@@ -4849,7 +4900,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 received: printType(arg0TypeResult.type),
             }), node.arguments[0].valueExpression);
         }
-        return { node, type: arg0TypeResult.type };
+        return { type: arg0TypeResult.type };
     }
     function getTypeOfRevealType(node, expectedType) {
         let arg0Value;
@@ -4886,7 +4937,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         });
         if (!arg0Value) {
             addError(localize_1.Localizer.Diagnostic.revealTypeArgs(), node);
-            return { node, type: types_1.UnknownType.create() };
+            return { type: types_1.UnknownType.create() };
         }
         const typeResult = getTypeOfExpression(arg0Value, /* flags */ undefined, expectedType);
         const type = typeResult.type;
@@ -4910,11 +4961,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         addInformation(localize_1.Localizer.DiagnosticAddendum.typeOfSymbol().format({ name: exprString, type: typeString }), node.arguments[0]);
-        return {
-            node,
-            type,
-            isIncomplete: typeResult.isIncomplete,
-        };
+        return { type, isIncomplete: typeResult.isIncomplete };
     }
     function getTypeOfRevealLocals(node) {
         let curNode = node;
@@ -5063,11 +5110,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     type: resultIsInstance
                         ? types_1.ClassType.cloneAsInstance(lookupResults.classType)
                         : lookupResults.classType,
-                    node,
                     bindToType: resultIsInstance && bindToType && (0, types_1.isInstantiableClass)(bindToType)
                         ? types_1.ClassType.cloneAsInstance(bindToType)
                         : bindToType,
-                    isSuperCall: true,
                 };
             }
         }
@@ -5077,11 +5122,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // If the class derives from one or more unknown classes,
             // return unknown here to prevent spurious errors.
             if (targetClassType.details.mro.some((mroBase) => (0, types_1.isAnyOrUnknown)(mroBase))) {
-                return {
-                    type: types_1.UnknownType.create(),
-                    isSuperCall: true,
-                    node,
-                };
+                return { type: types_1.UnknownType.create() };
             }
             const baseClasses = targetClassType.details.baseClasses;
             if (baseClasses.length > 0) {
@@ -5089,17 +5130,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if ((0, types_1.isInstantiableClass)(baseClassType)) {
                     return {
                         type: resultIsInstance ? types_1.ClassType.cloneAsInstance(baseClassType) : baseClassType,
-                        isSuperCall: true,
-                        node,
                     };
                 }
             }
         }
-        return {
-            type: types_1.UnknownType.create(),
-            isSuperCall: true,
-            node,
-        };
+        return { type: types_1.UnknownType.create() };
     }
     // Attempts to find an overloaded function for each set of argument
     // types in the expandedArgTypes list. If an argument type is undefined,
@@ -5109,6 +5144,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // (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) {
+        var _a;
         const returnTypes = [];
         const matchedOverloads = [];
         let isTypeIncomplete = false;
@@ -5130,11 +5166,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         return argParamCopy;
                     });
                 }
-                // Clone the typeVarContext so we don't modify the original.
-                const effectiveTypeVarContext = typeVarContext
-                    ? typeVarContext.clone()
-                    : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overload));
+                // Clone the typeVarContext so we don't modify the original. If this is
+                // not the first time through the loop, clone the type var context
+                // from the previous successful match.
+                const typeVarContextToClone = matchedOverloads.length > 0
+                    ? matchedOverloads[matchedOverloads.length - 1].typeVarContext.clone()
+                    : typeVarContext;
+                const effectiveTypeVarContext = (_a = typeVarContextToClone === null || typeVarContextToClone === void 0 ? void 0 : typeVarContextToClone.clone()) !== null && _a !== void 0 ? _a : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overload));
                 effectiveTypeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(overload));
+                effectiveTypeVarContext.unlock();
                 // Use speculative mode so we don't output any diagnostics or
                 // record any final types in the type cache.
                 const callResult = useSpeculativeMode(errorNode, () => {
@@ -5159,24 +5199,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return { argumentErrors: true, isTypeIncomplete };
             }
         }
-        // We found a match for all of the expanded argument lists.
-        // Run through them again to populate the original typeVarContext.
+        // We found a match for all of the expanded argument lists. Copy the
+        // resulting type var context back into the caller's type var context.
+        // Use the type var context from the last matched overload because it
+        // includes the type var solutions for all earlier matched overloads.
         if (typeVarContext) {
-            for (let expandedTypesIndex = 0; expandedTypesIndex < expandedArgTypes.length; expandedTypesIndex++) {
-                const overload = matchedOverloads[expandedTypesIndex].overload;
-                const matchResults = matchedOverloads[expandedTypesIndex].matchResults;
-                useSpeculativeMode(errorNode, () => {
-                    typeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(overload));
-                    typeVarContext.unlock();
-                    return validateFunctionArgumentTypesWithExpectedType(errorNode, matchResults, typeVarContext, 
-                    /* skipUnknownArgCheck */ true, expectedType);
-                });
-            }
+            typeVarContext.copyFromClone(matchedOverloads[matchedOverloads.length - 1].typeVarContext);
         }
         // And run through the first expanded argument list one more time to
         // populate the type cache.
-        matchedOverloads[0].typeVarContext.unlock();
-        const finalCallResult = validateFunctionArgumentTypesWithExpectedType(errorNode, matchedOverloads[0].matchResults, matchedOverloads[0].typeVarContext, skipUnknownArgCheck, expectedType);
+        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);
         if (finalCallResult.isTypeIncomplete) {
             isTypeIncomplete = true;
         }
@@ -5191,15 +5226,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let overloadIndex = 0;
         let matches = [];
         // Create a list of potential overload matches based on arguments.
-        type.overloads.forEach((overload) => {
+        types_1.OverloadedFunctionType.getOverloads(type).forEach((overload) => {
             useSpeculativeMode(errorNode, () => {
-                if (types_1.FunctionType.isOverloaded(overload)) {
-                    const matchResults = matchFunctionArgumentsToParameters(errorNode, argList, overload, overloadIndex);
-                    if (!matchResults.argumentErrors) {
-                        matches.push(matchResults);
-                    }
-                    overloadIndex++;
+                const matchResults = matchFunctionArgumentsToParameters(errorNode, argList, overload, overloadIndex);
+                if (!matchResults.argumentErrors) {
+                    matches.push(matchResults);
                 }
+                overloadIndex++;
             });
         });
         matches = sortOverloadsByBestMatch(matches);
@@ -5236,17 +5269,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // cache or record any diagnostics at this stage.
         useSpeculativeMode(errorNode, () => {
             let overloadIndex = 0;
-            type.overloads.forEach((overload) => {
+            types_1.OverloadedFunctionType.getOverloads(type).forEach((overload) => {
                 // Consider only the functions that have the @overload decorator,
                 // not the final function that omits the overload. This is the
                 // intended behavior according to PEP 484.
-                if (types_1.FunctionType.isOverloaded(overload)) {
-                    const matchResults = matchFunctionArgumentsToParameters(errorNode, argList, overload, overloadIndex);
-                    if (!matchResults.argumentErrors) {
-                        filteredMatchResults.push(matchResults);
-                    }
-                    overloadIndex++;
+                const matchResults = matchFunctionArgumentsToParameters(errorNode, argList, overload, overloadIndex);
+                if (!matchResults.argumentErrors) {
+                    filteredMatchResults.push(matchResults);
                 }
+                overloadIndex++;
             });
         });
         filteredMatchResults = sortOverloadsByBestMatch(filteredMatchResults);
@@ -5301,8 +5332,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     // the expectedType. We'll use this to determine whether we need to do
                     // union expansion.
                     contextFreeArgTypes = argList.map((arg) => {
-                        if (arg.type) {
-                            return arg.type;
+                        if (arg.typeResult) {
+                            return arg.typeResult.type;
                         }
                         if (arg.valueExpression) {
                             const valueExpressionNode = arg.valueExpression;
@@ -6204,7 +6235,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const funcArg = listElementType
                     ? {
                         argumentCategory: 0 /* Simple */,
-                        type: listElementType,
+                        typeResult: { type: listElementType, isIncomplete: argTypeResult.isIncomplete },
                     }
                     : undefined;
                 if (funcArg && argTypeResult.isIncomplete) {
@@ -6369,7 +6400,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                         requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                                         argument: {
                                             argumentCategory: 0 /* Simple */,
-                                            type: entry.valueType,
+                                            typeResult: { type: entry.valueType },
                                         },
                                         errorNode: argList[argIndex].valueExpression || errorNode,
                                         paramName: name,
@@ -6384,7 +6415,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                     requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                                     argument: {
                                         argumentCategory: 0 /* Simple */,
-                                        type: entry.valueType,
+                                        typeResult: { type: entry.valueType },
                                     },
                                     errorNode: argList[argIndex].valueExpression || errorNode,
                                     paramName: name,
@@ -6574,7 +6605,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                             argument: {
                                 argumentCategory: 0 /* Simple */,
-                                type: unpackedDictionaryArgType,
+                                typeResult: { type: unpackedDictionaryArgType },
                             },
                             errorNode: (_b = (_a = argList.find((arg) => arg.argumentCategory === 2 /* UnpackedDictionary */)) === null || _a === void 0 ? void 0 : _a.valueExpression) !== null && _b !== void 0 ? _b : errorNode,
                             paramName: param.name,
@@ -6621,7 +6652,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                     requiresTypeVarMatching: true,
                                     argument: {
                                         argumentCategory: 0 /* Simple */,
-                                        type: defaultArgType,
+                                        typeResult: { type: defaultArgType },
                                     },
                                     errorNode: errorNode,
                                     paramName: param.name,
@@ -6669,13 +6700,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         });
                         const specializedTuple = types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleClassType, tupleTypeArgs, 
                         /* isTypeArgumentExplicit */ true, 
-                        /* stripLiterals */ true, 
                         /* isUnpackedTuple */ true));
                         const combinedArg = {
                             paramCategory: 1 /* VarArgList */,
                             paramType,
                             requiresTypeVarMatching: true,
-                            argument: { argumentCategory: 0 /* Simple */, type: specializedTuple },
+                            argument: {
+                                argumentCategory: 0 /* Simple */,
+                                typeResult: { type: specializedTuple },
+                            },
                             errorNode,
                             paramName: paramDetails.params[paramDetails.argsIndex].param.name,
                             isParamNameSynthesized: paramDetails.params[paramDetails.argsIndex].param.isNameSynthesized,
@@ -7177,7 +7210,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (argParam.argType) {
                 argType = argParam.argType;
             }
-            else if (argParam.expectingType && !argParam.argument.type && argParam.argument.valueExpression) {
+            else if (argParam.expectingType && !argParam.argument.typeResult && argParam.argument.valueExpression) {
                 const argTypeResult = getTypeOfExpression(argParam.argument.valueExpression, 8 /* EvaluateStringLiteralAsType */ |
                     32 /* ParamSpecDisallowed */ |
                     128 /* TypeVarTupleDisallowed */);
@@ -7356,7 +7389,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return { isCompatible, argType, isTypeIncomplete, condition };
     }
     function createTypeVarType(errorNode, argList) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e;
         let typeVarName = '';
         let firstConstraintArg;
         if (argList.length === 0) {
@@ -7385,9 +7418,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         addError(localize_1.Localizer.Diagnostic.typeVarBoundAndConstrained(), argList[i].valueExpression || errorNode);
                     }
                     else {
-                        const argType = (_a = argList[i].type) !== null && _a !== void 0 ? _a : getTypeOfExpressionExpectingType(argList[i].valueExpression, 
-                        /* allowFinal */ undefined, 
-                        /* allowRequired */ undefined).type;
+                        const argType = (_b = (_a = argList[i].typeResult) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : getTypeOfExpressionExpectingType(argList[i].valueExpression).type;
                         if ((0, typeUtils_1.requiresSpecialization)(argType, /* ignorePseudoGeneric */ true)) {
                             addError(localize_1.Localizer.Diagnostic.typeVarGeneric(), argList[i].valueExpression || errorNode);
                         }
@@ -7396,26 +7427,26 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 else if (paramName === 'covariant') {
                     if (argList[i].valueExpression && getBooleanValue(argList[i].valueExpression)) {
-                        if (typeVar.details.declaredVariance === 3 /* Contravariant */) {
+                        if (typeVar.details.declaredVariance === 4 /* Contravariant */) {
                             addError(localize_1.Localizer.Diagnostic.typeVarVariance(), argList[i].valueExpression);
                         }
                         else {
-                            typeVar.details.declaredVariance = 2 /* Covariant */;
+                            typeVar.details.declaredVariance = 3 /* Covariant */;
                         }
                     }
                 }
                 else if (paramName === 'contravariant') {
                     if (argList[i].valueExpression && getBooleanValue(argList[i].valueExpression)) {
-                        if (typeVar.details.declaredVariance === 2 /* Covariant */) {
+                        if (typeVar.details.declaredVariance === 3 /* Covariant */) {
                             addError(localize_1.Localizer.Diagnostic.typeVarVariance(), argList[i].valueExpression);
                         }
                         else {
-                            typeVar.details.declaredVariance = 3 /* Contravariant */;
+                            typeVar.details.declaredVariance = 4 /* Contravariant */;
                         }
                     }
                 }
                 else {
-                    addError(localize_1.Localizer.Diagnostic.typeVarUnknownParam().format({ name: paramName }), ((_b = argList[i].node) === null || _b === void 0 ? void 0 : _b.name) || argList[i].valueExpression || errorNode);
+                    addError(localize_1.Localizer.Diagnostic.typeVarUnknownParam().format({ name: paramName }), ((_c = argList[i].node) === null || _c === void 0 ? void 0 : _c.name) || argList[i].valueExpression || errorNode);
                 }
                 paramNameMap.set(paramName, paramName);
             }
@@ -7424,9 +7455,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     addError(localize_1.Localizer.Diagnostic.typeVarBoundAndConstrained(), argList[i].valueExpression || errorNode);
                 }
                 else {
-                    const argType = (_c = argList[i].type) !== null && _c !== void 0 ? _c : getTypeOfExpressionExpectingType(argList[i].valueExpression, 
-                    /* allowFinal */ undefined, 
-                    /* allowRequired */ undefined).type;
+                    const argType = (_e = (_d = argList[i].typeResult) === null || _d === void 0 ? void 0 : _d.type) !== null && _e !== void 0 ? _e : getTypeOfExpressionExpectingType(argList[i].valueExpression).type;
                     if ((0, typeUtils_1.requiresSpecialization)(argType, /* ignorePseudoGeneric */ true)) {
                         addError(localize_1.Localizer.Diagnostic.typeVarGeneric(), argList[i].valueExpression || errorNode);
                     }
@@ -7704,14 +7733,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (!type) {
             return undefined;
         }
-        return { type, node };
+        return { type };
     }
     function getTypeOfUnaryOperation(node, expectedType) {
         const exprTypeResult = getTypeOfExpression(node.expression);
         let exprType = makeTopLevelTypeVarsConcrete(exprTypeResult.type);
         const isIncomplete = exprTypeResult.isIncomplete;
         if ((0, types_1.isNever)(exprType)) {
-            return { node, type: types_1.NeverType.createNever(), isIncomplete };
+            return { type: types_1.NeverType.createNever(), isIncomplete };
         }
         // Map unary operators to magic functions. Note that the bitwise
         // invert has two magic functions that are aliases of each other.
@@ -7790,16 +7819,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
-        return { type, node, isIncomplete };
-    }
-    function operatorSupportsComparisonChaining(op) {
-        if (binaryOperatorMap[op] && binaryOperatorMap[op][2]) {
-            return true;
-        }
-        if (booleanOperatorMap[op]) {
-            return true;
-        }
-        return false;
+        return { type, isIncomplete };
     }
     function getTypeOfBinaryOperation(node, expectedType, flags) {
         const leftExpression = node.leftExpression;
@@ -7808,10 +7828,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If this is a comparison and the left expression is also a comparison,
         // we need to change the behavior to accommodate python's "chained
         // comparisons" feature.
-        if (operatorSupportsComparisonChaining(node.operator)) {
+        if (ParseTreeUtils.operatorSupportsChaining(node.operator)) {
             if (rightExpression.nodeType === 7 /* BinaryOperation */ &&
                 !rightExpression.parenthesized &&
-                operatorSupportsComparisonChaining(rightExpression.operator)) {
+                ParseTreeUtils.operatorSupportsChaining(rightExpression.operator)) {
                 // Evaluate the right expression so it is type checked.
                 getTypeOfBinaryOperation(rightExpression, expectedType, flags);
                 // Use the left side of the right expression for comparison purposes.
@@ -7888,15 +7908,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         addError(localize_1.Localizer.Diagnostic.unionSyntaxIllegal(), node, node.operatorToken);
                     }
                 }
-                if (!validateTypeArg(leftTypeResult, { allowVariadicTypeVar: true, allowUnpackedTuples: true }) ||
-                    !validateTypeArg(rightTypeResult, { allowVariadicTypeVar: true, allowUnpackedTuples: true })) {
-                    return { type: types_1.UnknownType.create(), node };
+                if (!validateTypeArg({ ...leftTypeResult, node: leftExpression }, { allowVariadicTypeVar: true, allowUnpackedTuples: true }) ||
+                    !validateTypeArg({ ...rightTypeResult, node: rightExpression }, { allowVariadicTypeVar: true, allowUnpackedTuples: true })) {
+                    return { type: types_1.UnknownType.create() };
                 }
                 const newUnion = (0, types_1.combineTypes)([adjustedLeftType, adjustedRightType]);
                 if ((0, types_1.isUnion)(newUnion)) {
                     types_1.TypeBase.setSpecialForm(newUnion);
                 }
-                return { type: newUnion, node };
+                return { type: newUnion };
             }
         }
         // Optional checks apply to all operations except for boolean operations.
@@ -7919,7 +7939,7 @@ 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, leftType, rightType, node, expectedType, diag, isLiteralMathAllowed);
+        let type = validateBinaryOperation(node.operator, { type: leftType, isIncomplete: leftTypeResult.isIncomplete }, { type: rightType, isIncomplete: rightTypeResult.isIncomplete }, node, expectedType, diag, isLiteralMathAllowed);
         if (!diag.isEmpty() || !type) {
             if (!isIncomplete) {
                 const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
@@ -7942,7 +7962,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             type = types_1.UnknownType.create();
         }
-        return { type, node, isIncomplete };
+        return { type, isIncomplete };
     }
     function customMetaclassSupportsMethod(type, methodName) {
         if (!(0, types_1.isInstantiableClass)(type)) {
@@ -7995,7 +8015,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const rightType = rightTypeResult.type;
         const isIncomplete = !!rightTypeResult.isIncomplete || !!leftTypeResult.isIncomplete;
         if ((0, types_1.isNever)(leftType) || (0, types_1.isNever)(rightType)) {
-            typeResult = { node, type: types_1.NeverType.createNever(), isIncomplete };
+            typeResult = { type: types_1.NeverType.createNever(), isIncomplete };
         }
         else {
             type = mapSubtypesExpandTypeVars(leftType, 
@@ -8005,14 +8025,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         return (0, typeUtils_1.preserveUnknown)(leftSubtypeUnexpanded, rightSubtypeUnexpanded);
                     }
                     const magicMethodName = operatorMap[node.operator][0];
-                    let returnType = getTypeOfMagicMethodReturn(leftSubtypeUnexpanded, [rightSubtypeUnexpanded], magicMethodName, node, expectedType);
+                    let returnType = getTypeOfMagicMethodReturn(leftSubtypeUnexpanded, [{ type: rightSubtypeUnexpanded, isIncomplete: rightTypeResult.isIncomplete }], magicMethodName, node, expectedType);
                     if (!returnType && leftSubtypeUnexpanded !== leftSubtypeExpanded) {
                         // Try with the expanded left type.
-                        returnType = getTypeOfMagicMethodReturn(leftSubtypeExpanded, [rightSubtypeUnexpanded], magicMethodName, node, expectedType);
+                        returnType = getTypeOfMagicMethodReturn(leftSubtypeExpanded, [{ type: rightSubtypeUnexpanded, isIncomplete: rightTypeResult.isIncomplete }], magicMethodName, node, expectedType);
                     }
                     if (!returnType && rightSubtypeUnexpanded !== rightSubtypeExpanded) {
                         // Try with the expanded left and right type.
-                        returnType = getTypeOfMagicMethodReturn(leftSubtypeExpanded, [rightSubtypeExpanded], magicMethodName, node, expectedType);
+                        returnType = getTypeOfMagicMethodReturn(leftSubtypeExpanded, [{ type: rightSubtypeExpanded, isIncomplete: rightTypeResult.isIncomplete }], magicMethodName, node, expectedType);
                     }
                     if (!returnType) {
                         // If the LHS class didn't support the magic method for augmented
@@ -8025,7 +8045,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             !rightTypeResult.isIncomplete &&
                             (0, typeUtils_1.getUnionSubtypeCount)(leftType) * (0, typeUtils_1.getUnionSubtypeCount)(rightType) <
                                 maxLiteralMathSubtypeCount;
-                        returnType = validateBinaryOperation(binaryOperator, leftSubtypeUnexpanded, rightSubtypeUnexpanded, node, expectedType, diag, isLiteralMathAllowed);
+                        returnType = validateBinaryOperation(binaryOperator, { type: leftSubtypeUnexpanded, isIncomplete: leftTypeResult.isIncomplete }, { type: rightSubtypeUnexpanded, isIncomplete: rightTypeResult.isIncomplete }, node, expectedType, diag, isLiteralMathAllowed);
                     }
                     return returnType;
                 });
@@ -8043,12 +8063,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 type = types_1.UnknownType.create();
             }
-            typeResult = { node, type, isIncomplete };
+            typeResult = { type, isIncomplete };
         }
         assignTypeToExpression(node.destExpression, typeResult.type, !!typeResult.isIncomplete, node.rightExpression);
         return typeResult;
     }
-    function validateBinaryOperation(operator, leftType, rightType, errorNode, expectedType, diag, isLiteralMathAllowed) {
+    function validateBinaryOperation(operator, leftTypeResult, rightTypeResult, errorNode, expectedType, diag, isLiteralMathAllowed) {
+        const leftType = leftTypeResult.type;
+        const rightType = rightTypeResult.type;
         let type;
         let concreteLeftType = makeTopLevelTypeVarsConcrete(leftType);
         if (booleanOperatorMap[operator] !== undefined) {
@@ -8098,7 +8120,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if ((0, types_1.isAnyOrUnknown)(leftSubtype) || (0, types_1.isAnyOrUnknown)(rightSubtypeUnexpanded)) {
                             return (0, typeUtils_1.preserveUnknown)(leftSubtype, rightSubtypeExpanded);
                         }
-                        let returnType = getTypeOfMagicMethodReturn(rightSubtypeExpanded, [leftSubtype], '__contains__', errorNode, 
+                        let returnType = getTypeOfMagicMethodReturn(rightSubtypeExpanded, [{ type: leftSubtype, isIncomplete: leftTypeResult.isIncomplete }], '__contains__', errorNode, 
                         /* expectedType */ undefined);
                         if (!returnType) {
                             // If __contains__ was not supported, fall back
@@ -8255,26 +8277,31 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             ]));
                         }
                         const magicMethodName = binaryOperatorMap[operator][0];
-                        let resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(leftSubtypeUnexpanded), [rightSubtypeUnexpanded], magicMethodName, errorNode, expectedType);
+                        let resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(leftSubtypeUnexpanded), [{ type: rightSubtypeUnexpanded, isIncomplete: rightTypeResult.isIncomplete }], magicMethodName, errorNode, expectedType);
                         if (!resultType && leftSubtypeUnexpanded !== leftSubtypeExpanded) {
                             // Try the expanded left type.
-                            resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(leftSubtypeExpanded), [rightSubtypeUnexpanded], magicMethodName, errorNode, expectedType);
+                            resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(leftSubtypeExpanded), [{ type: rightSubtypeUnexpanded, isIncomplete: rightTypeResult.isIncomplete }], magicMethodName, errorNode, expectedType);
                         }
                         if (!resultType && rightSubtypeUnexpanded !== rightSubtypeExpanded) {
                             // Try the expanded left and right type.
-                            resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(leftSubtypeExpanded), [rightSubtypeExpanded], magicMethodName, errorNode, expectedType);
+                            resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(leftSubtypeExpanded), [{ type: rightSubtypeExpanded, isIncomplete: rightTypeResult.isIncomplete }], magicMethodName, errorNode, expectedType);
                         }
                         if (!resultType) {
                             // Try the alternate form (swapping right and left).
                             const altMagicMethodName = binaryOperatorMap[operator][1];
-                            resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(rightSubtypeUnexpanded), [leftSubtypeUnexpanded], altMagicMethodName, errorNode, expectedType);
+                            resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(rightSubtypeUnexpanded), [{ type: leftSubtypeUnexpanded, isIncomplete: leftTypeResult.isIncomplete }], altMagicMethodName, errorNode, expectedType);
                             if (!resultType && rightSubtypeUnexpanded !== rightSubtypeExpanded) {
                                 // Try the expanded right type.
-                                resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(rightSubtypeExpanded), [leftSubtypeUnexpanded], altMagicMethodName, errorNode, expectedType);
+                                resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(rightSubtypeExpanded), [
+                                    {
+                                        type: leftSubtypeUnexpanded,
+                                        isIncomplete: leftTypeResult.isIncomplete,
+                                    },
+                                ], altMagicMethodName, errorNode, expectedType);
                             }
                             if (!resultType && leftSubtypeUnexpanded !== leftSubtypeExpanded) {
                                 // Try the expanded right and left type.
-                                resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(rightSubtypeExpanded), [leftSubtypeExpanded], altMagicMethodName, errorNode, expectedType);
+                                resultType = getTypeOfMagicMethodReturn(convertFunctionToObject(rightSubtypeExpanded), [{ type: leftSubtypeExpanded, isIncomplete: leftTypeResult.isIncomplete }], altMagicMethodName, errorNode, expectedType);
                             }
                         }
                         if (!resultType) {
@@ -8322,7 +8349,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const functionArgs = args.map((arg) => {
                     return {
                         argumentCategory: 0 /* Simple */,
-                        type: arg,
+                        typeResult: arg,
                     };
                 });
                 let callResult;
@@ -8438,7 +8465,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (resultTypedDict) {
                     return {
                         type: resultTypedDict,
-                        node,
                         isIncomplete,
                     };
                 }
@@ -8476,7 +8502,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return undefined;
         }
         const type = getBuiltInObject(node, 'dict', [specializedKeyType, specializedValueType]);
-        return { type, node, isIncomplete };
+        return { type, isIncomplete };
     }
     // Attempts to infer the type of a dictionary statement. If hasExpectedType
     // is true, strict inference is used for the subexpressions.
@@ -8520,7 +8546,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             /* includeSubclasses */ undefined, 
             /* TupleTypeArguments */ undefined, isEmptyContainer))
             : types_1.UnknownType.create();
-        return { type, node, isIncomplete };
+        return { type, isIncomplete };
     }
     function getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, forceStrictInference, expectedKeyType, expectedValueType, expectedTypedDictEntries, expectedDiagAddendum) {
         let isIncomplete = false;
@@ -8698,7 +8724,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return undefined;
         }
         const type = getBuiltInObject(node, builtInClassName, [specializedEntryType]);
-        return { type, node, isIncomplete };
+        return { type, isIncomplete };
     }
     // Attempts to infer the type of a list or set statement with no "expected type".
     function getTypeOfListOrSetInferred(node, hasExpectedType) {
@@ -8750,7 +8776,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             /* includeSubclasses */ undefined, 
             /* TupleTypeArguments */ undefined, isEmptyContainer))
             : types_1.UnknownType.create();
-        return { type, node, isIncomplete };
+        return { type, isIncomplete };
     }
     function inferTypeArgFromExpectedType(expectedType, entryTypes, isNarrowable) {
         let targetTypeVar;
@@ -8812,7 +8838,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 isIncomplete = true;
             }
         }
-        return { type: (0, types_1.combineTypes)(typesToCombine), node, isIncomplete };
+        return { type: (0, types_1.combineTypes)(typesToCombine), isIncomplete };
     }
     function getTypeOfYield(node) {
         let expectedYieldType;
@@ -8842,7 +8868,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 isIncomplete = true;
             }
         }
-        return { type: sentType || types_1.UnknownType.create(), node, isIncomplete };
+        return { type: sentType || types_1.UnknownType.create(), isIncomplete };
     }
     function getTypeOfYieldFrom(node) {
         var _a;
@@ -8865,7 +8891,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 returnedType = generatorTypeArgs.length >= 2 ? generatorTypeArgs[2] : types_1.UnknownType.create();
             }
         }
-        return { type: returnedType || types_1.UnknownType.create(), node };
+        return { type: returnedType || types_1.UnknownType.create() };
     }
     function getTypeOfLambda(node, expectedType) {
         let isIncomplete = false;
@@ -8984,7 +9010,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // Mark the function type as no longer being evaluated.
         functionType.details.flags &= ~131072 /* PartiallyEvaluated */;
-        return { type: functionType, node, isIncomplete };
+        return { type: functionType, isIncomplete };
     }
     function getTypeOfListComprehension(node, expectedType) {
         let isIncomplete = false;
@@ -9017,7 +9043,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 : [elementType, types_1.NoneType.createInstance(), types_1.NoneType.createInstance()], 
             /* isTypeArgumentExplicit */ true));
         }
-        return { type, node, isIncomplete };
+        return { type, isIncomplete };
     }
     function reportPossibleUnknownAssignment(diagLevel, rule, target, type, errorNode, ignoreEmptyContainers) {
         // Don't bother if the feature is disabled.
@@ -9115,20 +9141,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             type = exprTypeResult.type;
         }
-        return { type, node, isIncomplete };
+        return { type, isIncomplete };
     }
     function getTypeOfSlice(node) {
-        // Evaluate the expressions to report errors and record symbol references.
-        if (node.startValue) {
-            getTypeOfExpression(node.startValue);
-        }
-        if (node.endValue) {
-            getTypeOfExpression(node.endValue);
-        }
-        if (node.stepValue) {
-            getTypeOfExpression(node.stepValue);
+        // Evaluate the expressions to report errors and record symbol
+        // references. We can skip this if we're executing speculatively.
+        if (!speculativeTypeTracker.isSpeculative(node)) {
+            if (node.startValue) {
+                getTypeOfExpression(node.startValue);
+            }
+            if (node.endValue) {
+                getTypeOfExpression(node.endValue);
+            }
+            if (node.stepValue) {
+                getTypeOfExpression(node.stepValue);
+            }
         }
-        return { type: getBuiltInObject(node, 'slice'), node };
+        return { type: getBuiltInObject(node, 'slice') };
     }
     // Verifies that a type argument's type is not disallowed.
     function validateTypeArg(argResult, options) {
@@ -9733,8 +9762,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 });
             }
-            returnType = (0, typeUtils_1.specializeTupleClass)(classType, tupleTypeArgTypes, typeArgs !== undefined, 
-            /* stripLiterals */ false);
+            returnType = (0, typeUtils_1.specializeTupleClass)(classType, tupleTypeArgTypes, typeArgs !== undefined);
         }
         else {
             returnType = types_1.ClassType.cloneForSpecialization(classType, typeArgTypes, typeArgs !== undefined);
@@ -10622,6 +10650,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         const effectiveMetaclass = computeEffectiveMetaclass(classType, node.name);
+        // Clear the "partially constructed" flag.
+        classType.details.flags &= ~131072 /* PartiallyEvaluated */;
         // Now determine the decorated type of the class.
         let decoratedType = classType;
         let foundUnknown = false;
@@ -10658,8 +10688,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             (0, dataClasses_1.applyDataClassDefaultBehaviors)(classType, dataClassBehaviors);
             (0, dataClasses_1.applyDataClassClassBehaviorOverrides)(evaluatorInterface, classType, initSubclassArgs);
         }
-        // Clear the "partially constructed" flag.
-        classType.details.flags &= ~131072 /* PartiallyEvaluated */;
         // Run any class hooks that depend on this class.
         runClassTypeHooks(classType);
         // Synthesize TypedDict methods.
@@ -10742,6 +10770,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (!objectType || !(0, types_1.isClassInstance)(objectType)) {
             return;
         }
+        // Presumptively mark the variance inference as complete. This
+        // prevents potential recursion.
+        classType.details.requiresVarianceInference = false;
+        // Presumptively mark the computed variance to "in progress". We'll
+        // replace this below once the variance has been inferred.
+        classType.details.typeParameters.forEach((param) => {
+            if (param.details.declaredVariance === 0 /* Auto */) {
+                param.computedVariance = 1 /* Unknown */;
+            }
+        });
         // Replace all of the type parameters with invariant TypeVars.
         const updatedTypeParams = classType.details.typeParameters.map((typeParam) => types_1.TypeVarType.cloneAsInvariant(typeParam));
         const updatedClassType = types_1.ClassType.cloneWithNewTypeParameters(classType, updatedTypeParams);
@@ -10775,15 +10813,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const isDestSubtypeOfSrc = assignClassToSelf(srcType, destType);
             let inferredVariance;
             if (isDestSubtypeOfSrc) {
-                inferredVariance = 2 /* Covariant */;
+                inferredVariance = 3 /* Covariant */;
             }
             else {
                 const isSrcSubtypeOfDest = assignClassToSelf(destType, srcType);
                 if (isSrcSubtypeOfDest) {
-                    inferredVariance = 3 /* Contravariant */;
+                    inferredVariance = 4 /* Contravariant */;
                 }
                 else {
-                    inferredVariance = 1 /* Invariant */;
+                    inferredVariance = 2 /* Invariant */;
                 }
             }
             // We assume here that we don't need to clone the type var object
@@ -10791,8 +10829,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // class scope.
             classType.details.typeParameters[paramIndex].computedVariance = inferredVariance;
         });
-        // Note that variance inference is complete.
-        classType.details.requiresVarianceInference = false;
     }
     function evaluateTypeParameterList(node) {
         const paramTypes = [];
@@ -11513,8 +11549,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
                     return types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleClassType, [{ type, isUnbounded: !(0, types_1.isVariadicTypeVar)(type) }], 
-                    /* isTypeArgumentExplicit */ true, 
-                    /* stripLiterals */ true));
+                    /* isTypeArgumentExplicit */ true));
                 }
                 return types_1.UnknownType.create();
             }
@@ -12070,7 +12105,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     // For "async while", an implicit "await" is performed.
                     if (isAsync) {
-                        memberReturnType = getTypeOfAwaitable(memberReturnType, node);
+                        memberReturnType = getTypeOfAwaitable(memberReturnType, node.expression);
                     }
                     return memberReturnType;
                 }
@@ -12268,6 +12303,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         assignTypeToNameNode(symbolNameNode, symbolType, /* isIncomplete */ false, /* ignoreEmptyContainers */ false);
         writeTypeCache(node, symbolType, 0 /* None */, /* isIncomplete */ false);
     }
+    function evaluateTypesForTypeAnnotationNode(node) {
+        var _a;
+        // If this node is part of an assignment statement, use specialized
+        // logic that performs bidirectional inference and assignment
+        // type narrowing.
+        if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 3 /* Assignment */) {
+            evaluateTypesForAssignmentStatement(node.parent);
+        }
+        else {
+            const annotationType = getTypeOfAnnotation(node.typeAnnotation, {
+                isVariableAnnotation: true,
+                allowFinal: ParseTreeUtils.isFinalAllowedForAssignmentTarget(node.valueExpression),
+                allowClassVar: ParseTreeUtils.isClassVarAllowedForAssignmentTarget(node.valueExpression),
+            });
+            writeTypeCache(node.valueExpression, annotationType, 0 /* None */, /* isIncomplete */ false);
+        }
+    }
     function getAliasedSymbolTypeForName(node, name) {
         const symbolWithScope = lookUpSymbolRecursive(node, name, /* honorCodeFlow */ true);
         if (!symbolWithScope) {
@@ -12328,62 +12380,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // allows for bidirectional type evaluation.
     function evaluateTypesForExpressionInContext(node) {
         var _a, _b, _c, _d, _e;
-        let lastContextualExpression = node;
-        let curNode = node;
-        function isContextual(node) {
-            var _a, _b, _c, _d, _e;
-            // Parameters are contextual only for lambdas.
-            if (node.nodeType === 41 /* Parameter */ && ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 30 /* Lambda */) {
-                return true;
-            }
-            // Arguments are contextual only for call and index nodes.
-            if (node.nodeType === 1 /* Argument */ &&
-                (((_b = node.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 9 /* Call */ || ((_c = node.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 24 /* Index */)) {
-                return true;
-            }
-            // All nodes within a type annotation need to be evaluated
-            // contextually so we pass the "type expected" flag to
-            // the evaluator.
-            if (((_d = node.parent) === null || _d === void 0 ? void 0 : _d.nodeType) === 54 /* TypeAnnotation */) {
-                return true;
-            }
-            if (((_e = node.parent) === null || _e === void 0 ? void 0 : _e.nodeType) === 41 /* Parameter */ &&
-                (node === node.parent.typeAnnotation || node === node.parent.typeAnnotationComment)) {
-                return true;
-            }
-            // The | operator is contextual in cases where it is used to describe a
-            // union in type annotations.
-            if (node.nodeType === 7 /* BinaryOperation */ && node.operator === 6 /* BitwiseOr */) {
-                return true;
-            }
-            return (node.nodeType === 9 /* Call */ ||
-                node.nodeType === 24 /* Index */ ||
-                node.nodeType === 15 /* Dictionary */ ||
-                node.nodeType === 27 /* FormatString */ ||
-                node.nodeType === 31 /* List */ ||
-                node.nodeType === 30 /* Lambda */ ||
-                node.nodeType === 35 /* MemberAccess */ ||
-                node.nodeType === 45 /* Set */ ||
-                node.nodeType === 49 /* String */ ||
-                node.nodeType === 48 /* StringList */ ||
-                node.nodeType === 52 /* Tuple */ ||
-                node.nodeType === 56 /* Unpack */ ||
-                node.nodeType === 17 /* DictionaryKeyEntry */ ||
-                node.nodeType === 16 /* DictionaryExpandEntry */ ||
-                node.nodeType === 32 /* ListComprehension */ ||
-                node.nodeType === 33 /* ListComprehensionFor */ ||
-                node.nodeType === 34 /* ListComprehensionIf */ ||
-                node.nodeType === 65 /* PatternSequence */ ||
-                node.nodeType === 67 /* PatternLiteral */ ||
-                node.nodeType === 68 /* PatternClass */ ||
-                node.nodeType === 74 /* PatternClassArgument */ ||
-                node.nodeType === 66 /* PatternAs */ ||
-                node.nodeType === 69 /* PatternCapture */ ||
-                node.nodeType === 70 /* PatternMapping */ ||
-                node.nodeType === 73 /* PatternValue */ ||
-                node.nodeType === 71 /* PatternMappingKeyEntry */ ||
-                node.nodeType === 72 /* PatternMappingExpandEntry */);
-        }
         // Check for a couple of special cases where the node is a NameNode but
         // is technically not part of an expression. We'll handle these here so
         // callers don't need to include special-case logic.
@@ -12392,154 +12388,228 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 getTypeOfFunction(node.parent);
                 return;
             }
-            else if (node.parent.nodeType === 10 /* Class */ && node.parent.name === node) {
+            if (node.parent.nodeType === 10 /* Class */ && node.parent.name === node) {
                 getTypeOfClass(node.parent);
                 return;
             }
-            else if (node.parent.nodeType === 77 /* TypeAlias */ && node.parent.name === node) {
+            if (node.parent.nodeType === 77 /* TypeAlias */ && node.parent.name === node) {
                 getTypeOfTypeAlias(node.parent);
                 return;
             }
-            else if (node.parent.nodeType === 29 /* Global */ ||
-                node.parent.nodeType === 39 /* Nonlocal */) {
+            if (node.parent.nodeType === 29 /* Global */ || node.parent.nodeType === 39 /* Nonlocal */) {
                 // For global and nonlocal statements, allow forward references so
                 // we don't use code flow during symbol lookups.
                 getTypeOfExpression(node, 4 /* AllowForwardReferences */);
                 return;
             }
+            if (node.parent.nodeType === 37 /* ModuleName */) {
+                // A name within a module name isn't an expression,
+                // so there's nothing we can evaluate here.
+                return;
+            }
         }
-        // Scan up the parse tree until we find a non-expression (while
-        // looking for contextual expressions in the process).
-        while (curNode) {
-            const isNodeContextual = isContextual(curNode);
-            if (!isNodeContextual && !(0, parseNodes_1.isExpressionNode)(curNode)) {
-                break;
+        // If the expression is part of a type annotation, we need to evaluate
+        // it with special evaluation flags.
+        const annotationNode = ParseTreeUtils.getParentAnnotationNode(node);
+        if (annotationNode) {
+            // Annotations need to be evaluated with specialized evaluation flags.
+            const annotationParent = annotationNode.parent;
+            (0, debug_1.assert)(annotationParent !== undefined);
+            if (annotationParent.nodeType === 3 /* Assignment */) {
+                if (annotationNode === annotationParent.typeAnnotationComment) {
+                    getTypeOfAnnotation(annotationNode, {
+                        isVariableAnnotation: true,
+                        allowFinal: ParseTreeUtils.isFinalAllowedForAssignmentTarget(annotationParent.leftExpression),
+                        allowClassVar: ParseTreeUtils.isClassVarAllowedForAssignmentTarget(annotationParent.leftExpression),
+                    });
+                }
+                else {
+                    evaluateTypesForAssignmentStatement(annotationParent);
+                }
+                return;
             }
-            if (isNodeContextual) {
-                lastContextualExpression = curNode;
+            if (annotationParent.nodeType === 54 /* TypeAnnotation */) {
+                evaluateTypesForTypeAnnotationNode(annotationParent);
+                return;
             }
-            curNode = curNode.parent;
-        }
-        const parent = lastContextualExpression.parent;
-        if (parent.nodeType === 3 /* Assignment */) {
-            if (lastContextualExpression === parent.typeAnnotationComment) {
-                getTypeOfAnnotation(lastContextualExpression, {
-                    isVariableAnnotation: true,
-                    allowFinal: ParseTreeUtils.isFinalAllowedForAssignmentTarget(parent.leftExpression),
-                    allowClassVar: ParseTreeUtils.isClassVarAllowedForAssignmentTarget(parent.leftExpression),
+            if (annotationParent.nodeType === 28 /* Function */ &&
+                annotationNode === annotationParent.returnTypeAnnotation) {
+                getTypeOfAnnotation(annotationNode, {
+                    associateTypeVarsWithScope: true,
+                    disallowRecursiveTypeAlias: true,
                 });
+                return;
             }
-            else {
-                evaluateTypesForAssignmentStatement(parent);
-            }
+            getTypeOfAnnotation(annotationNode);
             return;
         }
-        else if (parent.nodeType === 14 /* Del */) {
-            verifyDeleteExpression(lastContextualExpression);
-            return;
-        }
-        // If this is the name node within a type parameter list, see if it's a type alias
-        // definition. If so, we need to evaluate the type alias contextually.
-        if (parent.nodeType === 75 /* TypeParameter */ && lastContextualExpression === parent.name) {
-            if (((_a = parent.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 76 /* TypeParameterList */ &&
-                ((_b = parent.parent.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 77 /* TypeAlias */) {
-                getTypeOfTypeAlias(parent.parent.parent);
+        // See if the expression is part of a pattern used in a case statement.
+        const possibleCaseNode = ParseTreeUtils.getParentNodeOfType(node, 64 /* Case */);
+        if (possibleCaseNode) {
+            const caseNode = possibleCaseNode;
+            if (ParseTreeUtils.isNodeContainedWithin(node, caseNode.pattern)) {
+                evaluateTypesForCaseStatement(caseNode);
                 return;
             }
         }
-        if (parent.nodeType === 75 /* TypeParameter */) {
-            getTypeOfExpression(parent.name);
-            return;
-        }
-        if (parent.nodeType === 77 /* TypeAlias */) {
-            getTypeOfTypeAlias(parent);
-            return;
-        }
-        if (parent.nodeType === 5 /* AugmentedAssignment */) {
-            evaluateTypesForAugmentedAssignment(parent);
-            return;
-        }
-        if (parent.nodeType === 13 /* Decorator */) {
-            if (((_c = parent.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 10 /* Class */) {
-                getTypeOfClass(parent.parent);
+        // Scan up the parse tree until we find a node that doesn't
+        // require any context to be evaluated.
+        let nodeToEvaluate = node;
+        let flags = 0 /* None */;
+        while (true) {
+            // If we're within an argument node in a call or index expression, skip
+            // all of the nodes between because the entire argument expression
+            // needs to be evaluated contextually.
+            const argumentNode = ParseTreeUtils.getParentNodeOfType(nodeToEvaluate, 1 /* Argument */);
+            if (argumentNode && argumentNode !== nodeToEvaluate) {
+                (0, debug_1.assert)(argumentNode.parent !== undefined);
+                if (argumentNode.parent.nodeType === 9 /* Call */ ||
+                    argumentNode.parent.nodeType === 24 /* Index */) {
+                    nodeToEvaluate = argumentNode.parent;
+                    continue;
+                }
             }
-            else if (((_d = parent.parent) === null || _d === void 0 ? void 0 : _d.nodeType) === 28 /* Function */) {
-                getTypeOfFunction(parent.parent);
+            let parent = nodeToEvaluate.parent;
+            if (!parent) {
+                break;
             }
-            return;
-        }
-        const evaluateTypeAnnotationExpression = (node) => {
-            const annotationParent = node.parent;
-            if ((annotationParent === null || annotationParent === void 0 ? void 0 : annotationParent.nodeType) === 3 /* Assignment */ && annotationParent.leftExpression === parent) {
-                evaluateTypesForAssignmentStatement(annotationParent);
+            // If this is the target of an assignment expression, evaluate the
+            // assignment expression node instead.
+            if (parent.nodeType === 4 /* AssignmentExpression */ && nodeToEvaluate === parent.name) {
+                nodeToEvaluate = parent;
+                continue;
+            }
+            // The left expression of a call or member access expression is not contextual.
+            if (parent.nodeType === 9 /* Call */ || parent.nodeType === 35 /* MemberAccess */) {
+                if (nodeToEvaluate === parent.leftExpression) {
+                    flags = 2 /* DoNotSpecialize */;
+                    break;
+                }
+            }
+            else if (parent.nodeType === 24 /* Index */) {
+                // The base expression of an index expression is not contextual.
+                if (nodeToEvaluate === parent.baseExpression) {
+                    flags = 2 /* DoNotSpecialize */;
+                    break;
+                }
             }
             else {
-                const annotationType = getTypeOfAnnotation(node.typeAnnotation, {
-                    isVariableAnnotation: true,
-                    allowFinal: ParseTreeUtils.isFinalAllowedForAssignmentTarget(node.valueExpression),
-                    allowClassVar: ParseTreeUtils.isClassVarAllowedForAssignmentTarget(node.valueExpression),
-                });
-                writeTypeCache(node.valueExpression, annotationType, 0 /* None */, /* isIncomplete */ false);
+                // 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 (parent.nodeType === 64 /* Case */ && lastContextualExpression !== parent.guardExpression) {
-            evaluateTypesForCaseStatement(parent);
-            return;
-        }
-        if (parent.nodeType === 54 /* TypeAnnotation */) {
-            evaluateTypeAnnotationExpression(parent);
-            return;
-        }
-        if (parent.nodeType === 41 /* Parameter */ && lastContextualExpression !== parent.defaultValue) {
-            evaluateTypeOfParameter(parent);
-            return;
+            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"
+                // node types that we can skip over to get to a known
+                // expression node.
+                if (parent.nodeType === 17 /* DictionaryKeyEntry */ ||
+                    parent.nodeType === 16 /* DictionaryExpandEntry */ ||
+                    parent.nodeType === 33 /* ListComprehensionFor */ ||
+                    parent.nodeType === 34 /* ListComprehensionIf */) {
+                    (0, debug_1.assert)(parent.parent !== undefined && (0, parseNodes_1.isExpressionNode)(parent.parent));
+                    parent = parent.parent;
+                }
+                else if (parent.nodeType === 41 /* Parameter */) {
+                    (0, debug_1.assert)(parent.parent !== undefined);
+                    // Parameters are contextual for lambdas.
+                    if (parent.parent.nodeType === 30 /* Lambda */) {
+                        parent = parent.parent;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                else {
+                    break;
+                }
+            }
+            nodeToEvaluate = parent;
         }
-        if (parent.nodeType === 28 /* Function */) {
-            if (lastContextualExpression === parent.returnTypeAnnotation) {
-                getTypeOfAnnotation(lastContextualExpression, {
-                    associateTypeVarsWithScope: true,
-                    disallowRecursiveTypeAlias: true,
-                });
+        const parent = nodeToEvaluate.parent;
+        (0, debug_1.assert)(parent !== undefined);
+        switch (parent.nodeType) {
+            case 14 /* Del */: {
+                verifyDeleteExpression(nodeToEvaluate);
+                return;
+            }
+            case 75 /* TypeParameter */: {
+                // If this is the name node within a type parameter list, see if it's a type alias
+                // definition. If so, we need to evaluate the type alias contextually.
+                if (nodeToEvaluate === parent.name &&
+                    ((_a = parent.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 76 /* TypeParameterList */ &&
+                    ((_b = parent.parent.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 77 /* TypeAlias */) {
+                    getTypeOfTypeAlias(parent.parent.parent);
+                    return;
+                }
+                break;
+            }
+            case 77 /* TypeAlias */: {
+                getTypeOfTypeAlias(parent);
+                return;
+            }
+            case 13 /* Decorator */: {
+                if (((_c = parent.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 10 /* Class */) {
+                    getTypeOfClass(parent.parent);
+                }
+                else if (((_d = parent.parent) === null || _d === void 0 ? void 0 : _d.nodeType) === 28 /* Function */) {
+                    getTypeOfFunction(parent.parent);
+                }
+                return;
+            }
+            case 41 /* Parameter */: {
+                if (nodeToEvaluate !== parent.defaultValue) {
+                    evaluateTypeOfParameter(parent);
+                    return;
+                }
+                break;
+            }
+            case 1 /* Argument */: {
+                if (nodeToEvaluate === parent.name) {
+                    // A name used to specify a named parameter in an argument isn't an
+                    // expression, so there's nothing we can evaluate here.
+                    return;
+                }
+                if (((_e = parent.parent) === null || _e === void 0 ? void 0 : _e.nodeType) === 10 /* Class */) {
+                    // A class argument must be evaluated in the context of the class declaration.
+                    getTypeOfClass(parent.parent);
+                    return;
+                }
+                break;
+            }
+            case 44 /* Return */: {
+                // Return expressions must be evaluated in the context of the expected return type.
+                if (parent.returnExpression) {
+                    const enclosingFunctionNode = ParseTreeUtils.getEnclosingFunction(node);
+                    const declaredReturnType = enclosingFunctionNode
+                        ? getFunctionDeclaredReturnType(enclosingFunctionNode)
+                        : undefined;
+                    getTypeOfExpression(parent.returnExpression, 0 /* None */, declaredReturnType);
+                    return;
+                }
+                break;
+            }
+            case 54 /* TypeAnnotation */: {
+                evaluateTypesForTypeAnnotationNode(parent);
+                return;
+            }
+            case 3 /* Assignment */: {
+                evaluateTypesForAssignmentStatement(parent);
                 return;
             }
         }
-        if (parent.nodeType === 37 /* ModuleName */) {
-            // A name within a module name isn't an expression,
-            // so there's nothing we can evaluate here.
-            return;
-        }
-        if (parent.nodeType === 1 /* Argument */ && lastContextualExpression === parent.name) {
-            // A name used to specify a named parameter in an argument isn't an
-            // expression, so there's nothing we can evaluate here.
-            return;
-        }
-        // A class argument must be evaluated in the context of the class declaration.
-        if (parent.nodeType === 1 /* Argument */ && ((_e = parent.parent) === null || _e === void 0 ? void 0 : _e.nodeType) === 10 /* Class */) {
-            getTypeOfClass(parent.parent);
-            return;
-        }
-        if (parent.nodeType === 44 /* Return */ && parent.returnExpression) {
-            const enclosingFunctionNode = ParseTreeUtils.getEnclosingFunction(node);
-            const declaredReturnType = enclosingFunctionNode
-                ? getFunctionDeclaredReturnType(enclosingFunctionNode)
-                : undefined;
-            getTypeOfExpression(parent.returnExpression, 0 /* None */, declaredReturnType);
-            return;
-        }
-        // If the parent is an expression, we'll evaluate it to provide
-        // the context for its child. If it's not, we'll evaluate the
-        // child directly without any context.
-        const nodeToEvaluate = (0, parseNodes_1.isExpressionNode)(parent) && parent.nodeType !== 0 /* Error */
-            ? parent
-            : lastContextualExpression;
         if (nodeToEvaluate.nodeType === 54 /* TypeAnnotation */) {
-            evaluateTypeAnnotationExpression(nodeToEvaluate);
-        }
-        else {
-            const fileInfo = AnalyzerNodeInfo.getFileInfo(nodeToEvaluate);
-            const flags = fileInfo.isStubFile ? 4 /* AllowForwardReferences */ : 0 /* None */;
-            getTypeOfExpression(nodeToEvaluate, flags);
+            evaluateTypesForTypeAnnotationNode(nodeToEvaluate);
+            return;
         }
+        getTypeOfExpression(nodeToEvaluate, flags);
     }
     function evaluateTypeOfParameter(node) {
         // If this parameter has no name, we have nothing to do.
@@ -12699,7 +12769,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // doing additional work.
         let subnodeType = readTypeCache(subnode, /* flags */ undefined);
         if (subnodeType) {
-            return { node: subnode, type: subnodeType };
+            return { type: subnodeType };
         }
         const oldIncompleteCache = incompleteTypeCache;
         try {
@@ -12712,11 +12782,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             callback();
             subnodeType = readTypeCache(subnode, /* flags */ undefined);
             if (subnodeType) {
-                return { node: subnode, type: subnodeType };
+                return { type: subnodeType };
             }
             subnodeType = incompleteTypeCache.get(subnode.id);
             if (subnodeType) {
-                return { node: subnode, type: subnodeType, isIncomplete: true };
+                return { type: subnodeType, isIncomplete: true };
             }
             incompleteTypeCache = oldIncompleteCache;
         }
@@ -13061,8 +13131,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return specializedClass;
     }
     function getTypeOfArgument(arg) {
-        if (arg.type) {
-            return { type: arg.type };
+        if (arg.typeResult) {
+            return { type: arg.typeResult.type, isIncomplete: arg.typeResult.isIncomplete };
         }
         if (!arg.valueExpression) {
             // We shouldn't ever get here, but just in case.
@@ -13077,8 +13147,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // and therefore follows the normal rules of types (e.g. they
     // can be forward-declared in stubs, etc.).
     function getTypeOfArgumentExpectingType(arg) {
-        if (arg.type) {
-            return { type: arg.type };
+        if (arg.typeResult) {
+            return { type: arg.typeResult.type, isIncomplete: arg.typeResult.isIncomplete };
         }
         // If there was no defined type provided, there should always
         // be a value expression from which we can retrieve the type.
@@ -13336,7 +13406,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         else if (node.parent &&
             node.parent.nodeType === 35 /* MemberAccess */ &&
             node === node.parent.memberName) {
-            let baseType = getTypeOfExpression(node.parent.leftExpression, 2 /* DoNotSpecialize */).type;
+            let baseType = getType(node.parent.leftExpression);
             if (baseType) {
                 baseType = makeTopLevelTypeVarsConcrete(baseType);
                 const memberName = node.parent.memberName.value;
@@ -13411,7 +13481,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const argNode = node.parent;
             const paramName = node.value;
             if (argNode.parent && argNode.parent.nodeType === 9 /* Call */) {
-                const baseType = getTypeOfExpression(argNode.parent.leftExpression, 2 /* DoNotSpecialize */).type;
+                const baseType = getType(argNode.parent.leftExpression);
                 if (baseType) {
                     if ((0, types_1.isFunction)(baseType) && baseType.details.declaration) {
                         const paramDecl = getDeclarationFromFunctionNamedParameter(baseType, paramName);
@@ -14252,9 +14322,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (returnTypeInferenceContextStack.length >= maxReturnTypeInferenceStackSize) {
             return undefined;
         }
+        const paramTypes = [];
+        let isResultFromCache = false;
         // Suppress diagnostics because we don't want to generate errors.
         suppressDiagnostics(functionNode, () => {
-            var _a;
+            var _a, _b;
             // Allocate a new temporary type cache for the context of just
             // this function so we can analyze it separately without polluting
             // the main type cache.
@@ -14297,13 +14369,26 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if (!paramType) {
                             paramType = types_1.UnknownType.create();
                         }
+                        paramTypes.push(paramType);
                         writeTypeCache(param.name, paramType, 0 /* None */, /* isIncomplete */ false);
                     }
                 });
                 // Don't bother trying to determine the contextual return
                 // type if none of the argument types are known.
                 if (!allArgTypesAreUnknown) {
-                    contextualReturnType = (_a = inferFunctionReturnType(functionNode, types_1.FunctionType.isAbstractMethod(type))) === null || _a === void 0 ? void 0 : _a.type;
+                    // See if the return type is already cached. If so, skip the
+                    // inference step, which is potentially very expensive.
+                    const cacheEntry = (_a = functionType.functionType.callSiteReturnTypeCache) === null || _a === void 0 ? void 0 : _a.find((entry) => {
+                        return (entry.paramTypes.length === paramTypes.length &&
+                            entry.paramTypes.every((t, i) => (0, types_1.isTypeSame)(t, paramTypes[i])));
+                    });
+                    if (cacheEntry) {
+                        contextualReturnType = cacheEntry.returnType;
+                        isResultFromCache = true;
+                    }
+                    else {
+                        contextualReturnType = (_b = inferFunctionReturnType(functionNode, types_1.FunctionType.isAbstractMethod(type))) === null || _b === void 0 ? void 0 : _b.type;
+                    }
                 }
             }
             finally {
@@ -14317,6 +14402,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (types_1.FunctionType.isWrapReturnTypeInAwait(type) && !(0, types_1.isNever)(contextualReturnType)) {
                 contextualReturnType = createAwaitableReturnType(functionNode, contextualReturnType, !!((_a = type.details.declaration) === null || _a === void 0 ? void 0 : _a.isGenerator));
             }
+            if (!isResultFromCache) {
+                // Cache the resulting type.
+                if (!functionType.functionType.callSiteReturnTypeCache) {
+                    functionType.functionType.callSiteReturnTypeCache = [];
+                }
+                if (functionType.functionType.callSiteReturnTypeCache.length >= maxCallSiteReturnTypeCacheSize) {
+                    functionType.functionType.callSiteReturnTypeCache =
+                        functionType.functionType.callSiteReturnTypeCache.slice(1);
+                }
+                functionType.functionType.callSiteReturnTypeCache.push({
+                    paramTypes,
+                    returnType: contextualReturnType,
+                });
+            }
             return contextualReturnType;
         }
         return undefined;
@@ -14353,7 +14452,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // prior to specializing.
                 inferReturnTypeIfNecessary(typeResult.type);
                 return {
-                    node,
                     type: (0, typeUtils_1.partiallySpecializeType)(typeResult.type, member.classType, selfClass),
                     isIncomplete: !!typeResult.isIncomplete,
                 };
@@ -14536,7 +14634,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             return { type: (0, typeUtils_1.stripLiteralValue)(typeArg.type), isUnbounded: false };
                         }), 
                         /* isTypeArgumentExplicit */ true, 
-                        /* stripLiterals */ true, 
                         /* isUnpackedTuple */ true));
                         srcTypeArgs.splice(destVariadicIndex, 0, {
                             type: variadicTuple,
@@ -14702,7 +14799,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const destTypeArg = destArgIndex >= 0 ? destTypeArgs[destArgIndex] : types_1.UnknownType.create();
                 const destTypeParam = destArgIndex < destTypeParams.length ? destTypeParams[destArgIndex] : undefined;
                 const assignmentDiag = new diagnostic_1.DiagnosticAddendum();
-                if (!destTypeParam || types_1.TypeVarType.getVariance(destTypeParam) === 2 /* Covariant */) {
+                if (!destTypeParam || types_1.TypeVarType.getVariance(destTypeParam) === 3 /* Covariant */) {
                     if (!assignType(destTypeArg, srcTypeArg, assignmentDiag, destTypeVarContext, srcTypeVarContext, flags | 128 /* RetainLiteralsForTypeVar */, recursionCount)) {
                         if (diag) {
                             if (destTypeParam) {
@@ -14719,7 +14816,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         return false;
                     }
                 }
-                else if (types_1.TypeVarType.getVariance(destTypeParam) === 3 /* Contravariant */) {
+                else if (types_1.TypeVarType.getVariance(destTypeParam) === 4 /* Contravariant */) {
                     if (!assignType(srcTypeArg, destTypeArg, assignmentDiag, srcTypeVarContext, destTypeVarContext, (flags ^ 2 /* ReverseTypeVarMatching */) | 128 /* RetainLiteralsForTypeVar */, recursionCount)) {
                         if (diag) {
                             const childDiag = diag.createAddendum();
@@ -15200,11 +15297,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // Find first overloaded function that matches the parameters.
                 // We don't want to pollute the current typeVarContext, so we'll
                 // make a copy of the existing one if it's specified.
-                const overloads = concreteSrcType.overloads;
+                const overloads = types_1.OverloadedFunctionType.getOverloads(concreteSrcType);
                 const overloadIndex = overloads.findIndex((overload) => {
-                    if (!types_1.FunctionType.isOverloaded(overload)) {
-                        return false;
-                    }
                     return assignType(destType, overload, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext === null || destTypeVarContext === void 0 ? void 0 : destTypeVarContext.clone(), srcTypeVarContext === null || srcTypeVarContext === void 0 ? void 0 : srcTypeVarContext.clone(), flags, recursionCount);
                 });
                 if (overloadIndex < 0) {
@@ -15228,10 +15322,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, types_1.isOverloadedFunction)(destType)) {
             const overloadDiag = diag === null || diag === void 0 ? void 0 : diag.createAddendum();
             // All overloads in the dest must be assignable.
-            const isAssignable = destType.overloads.every((destOverload) => {
-                if (!types_1.FunctionType.isOverloaded(destOverload)) {
-                    return true;
-                }
+            const isAssignable = types_1.OverloadedFunctionType.getOverloads(destType).every((destOverload) => {
                 if (destTypeVarContext) {
                     destTypeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(destOverload));
                 }
@@ -15363,6 +15454,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // For union sources, all of the types need to be assignable to the dest.
         let isIncompatible = false;
+        // Sort the subtypes so we have a deterministic order for unions.
         (0, typeUtils_1.doForEachSubtype)(srcType, (subtype, subtypeIndex) => {
             if (isIncompatible) {
                 return;
@@ -15387,7 +15479,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     isIncompatible = true;
                 }
             }
-        });
+        }, 
+        /* sortSubtypes */ true);
         if (isIncompatible) {
             diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format({
                 sourceType: printType(srcType),
@@ -15402,6 +15495,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // matches for types like `tuple[Any]` and `tuple[int]` from being considered
     // proper subtypes of each other.
     function isProperSubtype(destType, srcType, recursionCount) {
+        // Shortcut the check if either type is Any or Unknown.
+        if ((0, types_1.isAnyOrUnknown)(destType) || (0, types_1.isAnyOrUnknown)(srcType)) {
+            return true;
+        }
+        // Shortcut the check if either type is a class whose hierarchy contains an unknown type.
+        if ((0, types_1.isClass)(destType) && destType.details.mro.some((mro) => (0, types_1.isAnyOrUnknown)(mro))) {
+            return true;
+        }
+        if ((0, types_1.isClass)(srcType) && srcType.details.mro.some((mro) => (0, types_1.isAnyOrUnknown)(mro))) {
+            return true;
+        }
         return (assignType(destType, srcType, 
         /* diag */ undefined, 
         /* destTypeVarContext */ undefined, 
@@ -15453,54 +15557,69 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // For union destinations, we just need to match one of the types.
         const diagAddendum = diag ? new diagnostic_1.DiagnosticAddendum() : undefined;
         let foundMatch = false;
-        // Run through all subtypes in the union. Don't stop at the first
-        // match we find because we may need to match TypeVars in other
-        // subtypes. We special-case "None" so we can handle Optional[T]
-        // without matching the None to the type var.
-        if ((0, types_1.isNoneInstance)(srcType) && (0, typeUtils_1.isOptionalType)(destType)) {
-            foundMatch = true;
+        // Does the union contain any type variables that need to be solved?
+        // If so, we need to use a slower path.
+        if (!(0, typeUtils_1.requiresSpecialization)(destType)) {
+            for (const subtype of destType.subtypes) {
+                if (assignType(subtype, srcType, diagAddendum === null || diagAddendum === void 0 ? void 0 : diagAddendum.createAddendum(), 
+                /* destTypeVarContextClone */ undefined, 
+                /* srcTypeVarContextClone */ undefined, flags, recursionCount)) {
+                    foundMatch = true;
+                    break;
+                }
+            }
         }
         else {
-            let bestDestTypeVarContext;
-            let bestSrcTypeVarContext;
-            let bestTypeVarContextScore;
-            // If the srcType is a literal, try to use the fast-path lookup
-            // in case the destType is a union with hundreds of literals.
-            if ((0, types_1.isClassInstance)(srcType) &&
-                (0, typeUtils_1.isLiteralType)(srcType) &&
-                types_1.UnionType.containsType(destType, srcType, recursionCount)) {
-                return true;
+            // Run through all subtypes in the union. Don't stop at the first
+            // match we find because we may need to match TypeVars in other
+            // subtypes. We special-case "None" so we can handle Optional[T]
+            // without matching the None to the type var.
+            if ((0, types_1.isNoneInstance)(srcType) && (0, typeUtils_1.isOptionalType)(destType)) {
+                foundMatch = true;
             }
-            (0, typeUtils_1.doForEachSubtype)(destType, (subtype) => {
-                // Make a temporary clone of the typeVarContext. We don't want to modify
-                // the original typeVarContext until we find the "optimal" typeVar mapping.
-                const destTypeVarContextClone = destTypeVarContext === null || destTypeVarContext === void 0 ? void 0 : destTypeVarContext.clone();
-                const srcTypeVarContextClone = srcTypeVarContext === null || srcTypeVarContext === void 0 ? void 0 : srcTypeVarContext.clone();
-                if (assignType(subtype, srcType, diagAddendum === null || diagAddendum === void 0 ? void 0 : diagAddendum.createAddendum(), destTypeVarContextClone, srcTypeVarContextClone, flags, recursionCount)) {
-                    foundMatch = true;
-                    if (destTypeVarContextClone) {
-                        // Ask the typeVarContext to compute a "score" for the current
-                        // contents of the table.
-                        let typeVarContextScore = destTypeVarContextClone.getScore();
-                        // If the type matches exactly, prefer it over other types.
-                        if ((0, types_1.isTypeSame)(subtype, (0, typeUtils_1.stripLiteralValue)(srcType))) {
-                            typeVarContextScore = Number.POSITIVE_INFINITY;
-                        }
-                        if (bestTypeVarContextScore === undefined || bestTypeVarContextScore <= typeVarContextScore) {
-                            // We found a typeVar mapping with a higher score than before.
-                            bestTypeVarContextScore = typeVarContextScore;
-                            bestDestTypeVarContext = destTypeVarContextClone;
-                            bestSrcTypeVarContext = srcTypeVarContextClone;
+            else {
+                let bestDestTypeVarContext;
+                let bestSrcTypeVarContext;
+                let bestTypeVarContextScore;
+                // If the srcType is a literal, try to use the fast-path lookup
+                // in case the destType is a union with hundreds of literals.
+                if ((0, types_1.isClassInstance)(srcType) &&
+                    (0, typeUtils_1.isLiteralType)(srcType) &&
+                    types_1.UnionType.containsType(destType, srcType, recursionCount)) {
+                    return true;
+                }
+                (0, typeUtils_1.doForEachSubtype)(destType, (subtype) => {
+                    // Make a temporary clone of the typeVarContext. We don't want to modify
+                    // the original typeVarContext until we find the "optimal" typeVar mapping.
+                    const destTypeVarContextClone = destTypeVarContext === null || destTypeVarContext === void 0 ? void 0 : destTypeVarContext.clone();
+                    const srcTypeVarContextClone = srcTypeVarContext === null || srcTypeVarContext === void 0 ? void 0 : srcTypeVarContext.clone();
+                    if (assignType(subtype, srcType, diagAddendum === null || diagAddendum === void 0 ? void 0 : diagAddendum.createAddendum(), destTypeVarContextClone, srcTypeVarContextClone, flags, recursionCount)) {
+                        foundMatch = true;
+                        if (destTypeVarContextClone) {
+                            // Ask the typeVarContext to compute a "score" for the current
+                            // contents of the table.
+                            let typeVarContextScore = destTypeVarContextClone.getScore();
+                            // If the type matches exactly, prefer it over other types.
+                            if ((0, types_1.isTypeSame)(subtype, (0, typeUtils_1.stripLiteralValue)(srcType))) {
+                                typeVarContextScore = Number.POSITIVE_INFINITY;
+                            }
+                            if (bestTypeVarContextScore === undefined ||
+                                bestTypeVarContextScore <= typeVarContextScore) {
+                                // We found a typeVar mapping with a higher score than before.
+                                bestTypeVarContextScore = typeVarContextScore;
+                                bestDestTypeVarContext = destTypeVarContextClone;
+                                bestSrcTypeVarContext = srcTypeVarContextClone;
+                            }
                         }
                     }
+                });
+                // If we found a winning type var mapping, copy it back to typeVarContext.
+                if (destTypeVarContext && bestDestTypeVarContext) {
+                    destTypeVarContext.copyFromClone(bestDestTypeVarContext);
+                }
+                if (srcTypeVarContext && bestSrcTypeVarContext) {
+                    srcTypeVarContext.copyFromClone(bestSrcTypeVarContext);
                 }
-            });
-            // If we found a winning type var mapping, copy it back to typeVarContext.
-            if (destTypeVarContext && bestDestTypeVarContext) {
-                destTypeVarContext.copyFromClone(bestDestTypeVarContext);
-            }
-            if (srcTypeVarContext && bestSrcTypeVarContext) {
-                srcTypeVarContext.copyFromClone(bestSrcTypeVarContext);
             }
         }
         // If the source is a constrained TypeVar, see if we can assign all of the
@@ -15788,7 +15907,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
                 srcPositionalsType = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, srcTupleTypes, 
                 /* isTypeArgumentExplicit */ true, 
-                /* stripLiterals */ true, 
                 /* isUnpackedTuple */ true));
             }
             else {
@@ -15974,13 +16092,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
                 if (!(0, types_1.isUnpacked)(destArgsType)) {
                     destArgsType = types_1.ClassType.cloneForUnpacked(types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleClassType, [{ type: destArgsType, isUnbounded: true }], 
-                    /* isTypeArgumentExplicit */ true, 
-                    /* stripLiterals */ true)));
+                    /* isTypeArgumentExplicit */ true)));
                 }
                 if (!(0, types_1.isUnpacked)(srcArgsType)) {
                     srcArgsType = types_1.ClassType.cloneForUnpacked(types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleClassType, [{ type: srcArgsType, isUnbounded: true }], 
-                    /* isTypeArgumentExplicit */ true, 
-                    /* stripLiterals */ true)));
+                    /* isTypeArgumentExplicit */ true)));
                 }
             }
             if (!assignFunctionParameter(destArgsType, srcArgsType, destParamDetails.params[destParamDetails.argsIndex].index, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
@@ -16351,22 +16467,41 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return narrowedType;
     }
     function validateOverrideMethod(baseMethod, overrideMethod, diag, enforceParamNames = true) {
-        var _a, _b;
-        // If we're overriding an overloaded method, uses the implementation.
-        if ((0, types_1.isOverloadedFunction)(baseMethod)) {
-            const implementation = baseMethod.overloads.find((overload) => !types_1.FunctionType.isOverloaded(overload));
-            // If the overloaded method doesn't have an implementation, skip the check.
-            if (!implementation) {
-                return true;
-            }
-            baseMethod = implementation;
-        }
         // If we're overriding a non-method with a method, report it as an error.
         // This occurs when a non-property overrides a property.
-        if (!(0, types_1.isFunction)(baseMethod)) {
+        if (!(0, types_1.isFunction)(baseMethod) && !(0, types_1.isOverloadedFunction)(baseMethod)) {
             diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideType().format({ type: printType(baseMethod) }));
             return false;
         }
+        if ((0, types_1.isFunction)(baseMethod)) {
+            // Handle the easy case - a simple function overriding another simple function.
+            if ((0, types_1.isFunction)(overrideMethod)) {
+                return validateOverrideMethodInternal(baseMethod, overrideMethod, diag, enforceParamNames);
+            }
+            // For an overload overriding a base method, at least one overload
+            // must be compatible with the base method.
+            if (types_1.OverloadedFunctionType.getOverloads(overrideMethod).some((overrideOverload) => {
+                return validateOverrideMethodInternal(baseMethod, overrideOverload, 
+                /* diag */ undefined, enforceParamNames);
+            })) {
+                return true;
+            }
+            // Or the implementation must be compatible.
+            const overrideImplementation = types_1.OverloadedFunctionType.getImplementation(overrideMethod);
+            if (overrideImplementation) {
+                if (validateOverrideMethodInternal(baseMethod, overrideImplementation, 
+                /* diag */ undefined, enforceParamNames)) {
+                    return true;
+                }
+            }
+            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideNoOverloadMatches());
+            return false;
+        }
+        // TODO - need to implement the case where the base method is overloaded
+        return true;
+    }
+    function validateOverrideMethodInternal(baseMethod, overrideMethod, diag, enforceParamNames) {
+        var _a, _b;
         const baseParamDetails = (0, typeUtils_1.getParameterListDetails)(baseMethod);
         const overrideParamDetails = (0, typeUtils_1.getParameterListDetails)(overrideMethod);
         let canOverride = true;
@@ -16374,19 +16509,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // an incompatible type.
         if (types_1.FunctionType.isStaticMethod(baseMethod)) {
             if (!types_1.FunctionType.isStaticMethod(overrideMethod)) {
-                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideNotStaticMethod());
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideNotStaticMethod());
                 canOverride = false;
             }
         }
         else if (types_1.FunctionType.isClassMethod(baseMethod)) {
             if (!types_1.FunctionType.isClassMethod(overrideMethod)) {
-                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideNotClassMethod());
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideNotClassMethod());
                 canOverride = false;
             }
         }
         if (types_1.FunctionType.isInstanceMethod(baseMethod)) {
             if (!types_1.FunctionType.isInstanceMethod(overrideMethod)) {
-                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideNotInstanceMethod());
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideNotInstanceMethod());
                 canOverride = false;
             }
         }
@@ -16411,7 +16546,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         if (foundParamCountMismatch) {
-            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overridePositionalParamCount().format({
+            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overridePositionalParamCount().format({
                 baseCount: baseParamDetails.params.length,
                 overrideCount: overrideParamDetails.params.length,
             }));
@@ -16438,13 +16573,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (overrideParam.category === 0 /* Simple */) {
                     if (enforceParamNames) {
                         if (overrideParamDetails.params[i].source === typeUtils_1.ParameterSource.PositionOnly) {
-                            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNamePositionOnly().format({
+                            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNamePositionOnly().format({
                                 index: i + 1,
                                 baseName: baseParam.name || '*',
                             }));
                         }
                         else {
-                            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamName().format({
+                            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamName().format({
                                 index: i + 1,
                                 baseName: baseParam.name || '*',
                                 overrideName: overrideParam.name || '*',
@@ -16456,7 +16591,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             else if (i < overrideParamDetails.positionOnlyParamCount &&
                 i >= baseParamDetails.positionOnlyParamCount) {
-                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNamePositionOnly().format({
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNamePositionOnly().format({
                     index: i + 1,
                     baseName: baseParam.name || '*',
                 }));
@@ -16469,8 +16604,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const overrideIsSynthesizedTypeVar = (0, types_1.isTypeVar)(overrideParamType) && overrideParamType.details.isSynthesized;
                 if (!baseIsSynthesizedTypeVar && !overrideIsSynthesizedTypeVar) {
                     if (baseParam.category !== overrideParam.category ||
-                        !assignType(overrideParamType, baseParamType, diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(baseMethod)), 8 /* SkipSolveTypeVars */)) {
-                        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamType().format({
+                        !assignType(overrideParamType, baseParamType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(baseMethod)), 8 /* SkipSolveTypeVars */)) {
+                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamType().format({
                             index: i + 1,
                             baseType: printType(baseParamType),
                             overrideType: printType(overrideParamType),
@@ -16479,7 +16614,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
                 if (baseParamDetails.params[i].param.hasDefault && !overrideParamDetails.params[i].param.hasDefault) {
-                    diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNoDefault().format({
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNoDefault().format({
                         index: i + 1,
                     }));
                     canOverride = false;
@@ -16489,7 +16624,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Check for a *args match.
         if (baseParamDetails.argsIndex !== undefined) {
             if (overrideParamDetails.argsIndex === undefined) {
-                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNameMissing().format({
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNameMissing().format({
                     name: (_a = baseParamDetails.params[baseParamDetails.argsIndex].param.name) !== null && _a !== void 0 ? _a : '?',
                 }));
                 canOverride = false;
@@ -16497,9 +16632,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             else {
                 const overrideParamType = overrideParamDetails.params[overrideParamDetails.argsIndex].type;
                 const baseParamType = baseParamDetails.params[baseParamDetails.argsIndex].type;
-                if (!assignType(overrideParamType, baseParamType, diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), 
+                if (!assignType(overrideParamType, baseParamType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), 
                 /* srcTypeVarContext */ undefined, 8 /* SkipSolveTypeVars */)) {
-                    diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamKeywordType().format({
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamKeywordType().format({
                         name: (_b = overrideParamDetails.params[overrideParamDetails.argsIndex].param.name) !== null && _b !== void 0 ? _b : '?',
                         baseType: printType(baseParamType),
                         overrideType: printType(overrideParamType),
@@ -16517,7 +16652,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             var _a, _b, _c;
             const overrideParamInfo = overrideWkOnlyParams.find((pi) => paramInfo.param.name === pi.param.name);
             if (!overrideParamInfo && overrideParamDetails.kwargsIndex === undefined) {
-                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNameMissing().format({
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNameMissing().format({
                     name: (_a = paramInfo.param.name) !== null && _a !== void 0 ? _a : '?',
                 }));
                 canOverride = false;
@@ -16527,9 +16662,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (!targetParamType) {
                     targetParamType = overrideParamDetails.params[overrideParamDetails.kwargsIndex].type;
                 }
-                if (!assignType(targetParamType, paramInfo.type, diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), 
+                if (!assignType(targetParamType, paramInfo.type, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), 
                 /* srcTypeVarContext */ undefined, 8 /* SkipSolveTypeVars */)) {
-                    diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamKeywordType().format({
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamKeywordType().format({
                         name: (_b = paramInfo.param.name) !== null && _b !== void 0 ? _b : '?',
                         baseType: printType(paramInfo.type),
                         overrideType: printType(targetParamType),
@@ -16538,7 +16673,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 if (overrideParamInfo) {
                     if (paramInfo.param.hasDefault && !overrideParamInfo.param.hasDefault) {
-                        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamKeywordNoDefault().format({
+                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamKeywordNoDefault().format({
                             name: (_c = overrideParamInfo.param.name) !== null && _c !== void 0 ? _c : '?',
                         }));
                         canOverride = false;
@@ -16554,7 +16689,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (!baseParamInfo) {
                 if (baseParamDetails.kwargsIndex === undefined) {
                     if (!paramInfo.param.hasDefault) {
-                        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNameExtra().format({
+                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNameExtra().format({
                             name: (_a = paramInfo.param.name) !== null && _a !== void 0 ? _a : '?',
                         }));
                         canOverride = false;
@@ -16565,9 +16700,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Now check the return type.
         const baseReturnType = getFunctionEffectiveReturnType(baseMethod);
         const overrideReturnType = getFunctionEffectiveReturnType(overrideMethod);
-        if (!assignType(baseReturnType, overrideReturnType, diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(baseMethod)), 
+        if (!assignType(baseReturnType, overrideReturnType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(baseMethod)), 
         /* srcTypeVarContext */ undefined, 8 /* SkipSolveTypeVars */)) {
-            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideReturnType().format({
+            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideReturnType().format({
                 baseType: printType(baseReturnType),
                 overrideType: printType(overrideReturnType),
             }));
@@ -16982,6 +17117,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         addWarning,
         addInformation,
         addUnusedCode,
+        addUnreachableCode,
         addDeprecated,
         addDiagnostic,
         addDiagnosticForTextRange,