@zzzen/pyright-internal 1.2.0-dev.20220710 → 1.2.0-dev.20220731

package/dist/analyzer/typeEvaluator.js

@@ -55,6 +55,7 @@ const constraintSolver_1 = require("./constraintSolver");
 const constructorTransform_1 = require("./constructorTransform");
 const dataClasses_1 = require("./dataClasses");
 const declarationUtils_1 = require("./declarationUtils");
+const enums_1 = require("./enums");
 const functionTransform_1 = require("./functionTransform");
 const namedTuples_1 = require("./namedTuples");
 const ParseTreeUtils = __importStar(require("./parseTreeUtils"));
@@ -106,33 +107,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 +181,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 +211,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 +233,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     let functionObj;
     let tupleClassType;
     let boolClassType;
+    let intClassType;
     let strClassType;
     let dictClassType;
     let typedDictClassType;
@@ -279,6 +282,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 +299,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 +438,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 +461,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     node: curNode,
                 };
             }
+            if (curNode === topExpression) {
+                break;
+            }
             curNode = curNode.parent;
         }
         return undefined;
@@ -452,6 +482,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 +496,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 +505,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 +657,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 +709,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 +717,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 +755,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,30 +794,51 @@ 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 {
             // Evaluate the format string expressions in this context.
-            node.strings.forEach((str) => {
-                if (str.nodeType === 27 /* FormatString */) {
-                    str.expressions.forEach((expr) => {
-                        getTypeOfExpression(expr);
-                    });
+            let isLiteralString = true;
+            let isIncomplete = false;
+            node.strings.forEach((expr) => {
+                const typeResult = getTypeOfString(expr);
+                if (typeResult.isIncomplete) {
+                    isIncomplete = true;
+                }
+                let isExprLiteralString = false;
+                if ((0, types_1.isClassInstance)(typeResult.type)) {
+                    if (types_1.ClassType.isBuiltIn(typeResult.type, 'str') && typeResult.type.literalValue !== undefined) {
+                        isExprLiteralString = true;
+                    }
+                    else if (types_1.ClassType.isBuiltIn(typeResult === null || typeResult === void 0 ? void 0 : typeResult.type, 'LiteralString')) {
+                        isExprLiteralString = true;
+                    }
+                }
+                if (!isExprLiteralString) {
+                    isLiteralString = false;
                 }
             });
             const isBytes = (node.strings[0].token.flags & 32 /* Bytes */) !== 0;
             // 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'),
-                };
+                if (isLiteralString) {
+                    const literalStringType = getTypingType(node, 'LiteralString');
+                    if (literalStringType && (0, types_1.isInstantiableClass)(literalStringType)) {
+                        typeResult = { type: types_1.ClassType.cloneAsInstance(literalStringType) };
+                    }
+                }
+                if (!typeResult) {
+                    typeResult = {
+                        type: getBuiltInObject(node, isBytes ? 'bytes' : 'str'),
+                        isIncomplete,
+                    };
+                }
             }
             else {
                 typeResult = {
-                    node,
                     type: cloneBuiltinObjectWithLiteral(node, isBytes ? 'bytes' : 'str', node.strings.map((s) => s.value).join('')),
+                    isIncomplete,
                 };
             }
         }
@@ -798,19 +849,62 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let typeResult;
         // 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'),
-            };
+            let isLiteralString = true;
+            // If all of the format expressions are of type LiteralString, then
+            // the resulting formatted string is also LiteralString.
+            node.expressions.forEach((expr) => {
+                const exprType = getTypeOfExpression(expr).type;
+                if (!(0, types_1.isClassInstance)(exprType)) {
+                    isLiteralString = false;
+                    return;
+                }
+                if (types_1.ClassType.isBuiltIn(exprType, 'LiteralString')) {
+                    return;
+                }
+                if (types_1.ClassType.isBuiltIn(exprType, 'str') && exprType.literalValue !== undefined) {
+                    return;
+                }
+                isLiteralString = false;
+            });
+            if (!isBytes && isLiteralString) {
+                const literalStringType = getTypingType(node, 'LiteralString');
+                if (literalStringType && (0, types_1.isInstantiableClass)(literalStringType)) {
+                    typeResult = { type: types_1.ClassType.cloneAsInstance(literalStringType) };
+                }
+            }
+            if (!typeResult) {
+                typeResult = {
+                    type: getBuiltInObject(node, isBytes ? 'bytes' : 'str'),
+                };
+            }
         }
         else {
             typeResult = {
-                node,
                 type: cloneBuiltinObjectWithLiteral(node, isBytes ? 'bytes' : 'str', node.value),
             };
         }
         return typeResult;
     }
+    function stripLiteralValue(type) {
+        if ((0, types_1.isClass)(type)) {
+            if (type.literalValue !== undefined) {
+                type = types_1.ClassType.cloneWithLiteral(type, /* value */ undefined);
+            }
+            else if (types_1.ClassType.isBuiltIn(type, 'LiteralString')) {
+                // Handle "LiteralString" specially.
+                if (strClassType && (0, types_1.isInstantiableClass)(strClassType)) {
+                    type = types_1.ClassType.cloneAsInstance(strClassType);
+                }
+            }
+            return type;
+        }
+        if ((0, types_1.isUnion)(type)) {
+            return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
+                return stripLiteralValue(subtype);
+            });
+        }
+        return type;
+    }
     function getTypeOfParameterAnnotation(paramTypeNode, paramCategory) {
         return getTypeOfAnnotation(paramTypeNode, {
             associateTypeVarsWithScope: true,
@@ -1138,8 +1232,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         /* isAccessedThroughObject */ true, memberName, usage, diag, memberAccessFlags | 8 /* DisallowClassVarWrites */, bindToType);
         if (memberInfo) {
             return {
-                node: errorNode,
                 type: memberInfo.type,
+                classType: memberInfo.classType,
                 isIncomplete: !!memberInfo.isTypeIncomplete,
                 isAsymmetricDescriptor: memberInfo.isAsymmetricDescriptor,
             };
@@ -1152,7 +1246,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 +1278,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if (memberInfo) {
             return {
-                node: errorNode,
                 type: memberInfo.type,
                 isIncomplete: !!memberInfo.isTypeIncomplete,
                 isAsymmetricDescriptor: memberInfo.isAsymmetricDescriptor,
@@ -1272,10 +1365,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 +1568,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 +1597,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 +1620,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 +1655,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 +1708,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 +1861,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);
@@ -1866,7 +1973,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (types_1.TypeBase.isInstance(destType) &&
                     !(0, symbolNameUtils_1.isConstantName)(nameValue) &&
                     !(0, symbolUtils_1.isFinalVariable)(symbolWithScope.symbol)) {
-                    destType = (0, typeUtils_1.stripLiteralValue)(destType);
+                    destType = stripLiteralValue(destType);
                 }
             }
         }
@@ -1886,9 +1993,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 +2037,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;
@@ -2059,7 +2160,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         const removedEntries = sourceEntryTypes.splice(targetUnpackIndex, sourceEntryTypes.length - targetTypes.length + 1);
                         let combinedTypes = (0, types_1.combineTypes)(removedEntries);
                         if (target.nodeType === 31 /* List */) {
-                            combinedTypes = (0, typeUtils_1.stripLiteralValue)(combinedTypes);
+                            combinedTypes = stripLiteralValue(combinedTypes);
                         }
                         sourceEntryTypes.splice(targetUnpackIndex, 0, combinedTypes);
                     }
@@ -2146,7 +2247,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 +2558,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 +2614,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 +2623,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 +2656,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 +2799,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 +3097,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 +3156,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 +3192,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 +3216,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 */);
@@ -3139,23 +3246,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         baseType = types_1.ClassType.cloneAsInstance(strClassType);
                     }
                     // Handle the special case of 'name' and 'value' members within an enum.
-                    if (types_1.ClassType.isEnumClass(baseType)) {
-                        const literalValue = baseType.literalValue;
-                        if (literalValue instanceof types_1.EnumLiteral) {
-                            if (memberName === 'name' || memberName === '_name_') {
-                                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 };
-                            }
-                        }
+                    const enumMemberResult = (0, enums_1.getTypeOfEnumMember)(evaluatorInterface, node, baseType, memberName, isIncomplete);
+                    if (enumMemberResult) {
+                        return enumMemberResult;
                     }
                     const typeResult = getTypeOfObjectMember(node.memberName, baseType, memberName, usage, diag, 
                     /* memberAccessFlags */ undefined, baseTypeResult.bindToType);
@@ -3257,7 +3350,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     else {
                         const typeResult = getTypeOfMemberAccessWithBaseType(node, {
                             type: subtype,
-                            node,
                             isIncomplete: baseTypeResult.isIncomplete,
                         }, usage, 0 /* None */);
                         if (typeResult.isIncomplete) {
@@ -3289,7 +3381,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 +3451,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;
@@ -3416,7 +3508,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // because that case is used for super() calls where we want
                 // to leave the Self type generic (not specialized).
                 const selfClass = bindToType ? undefined : classType;
-                const typeResult = getTypeOfMemberInternal(errorNode, memberInfo, selfClass);
+                const typeResult = getTypeOfMemberInternal(memberInfo, selfClass);
                 if (typeResult) {
                     type = typeResult.type;
                     if (typeResult.isIncomplete) {
@@ -3701,7 +3793,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);
                         }
@@ -3998,7 +4090,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),
@@ -4013,7 +4104,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         node: errorNode,
                         type: (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, [], 
                         /* isTypeArgumentExplicit */ true, 
-                        /* stripLiterals */ true, 
                         /* isUnpackedTuple */ true)),
                     });
                 }
@@ -4174,9 +4264,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;
@@ -4271,11 +4361,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);
             }
@@ -4290,7 +4380,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             });
         }
-        return { type, node, isIncomplete };
+        return { type, isIncomplete };
     }
     function makeTupleObject(entryTypes, isUnspecifiedLength = false) {
         if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
@@ -4335,7 +4425,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
@@ -4356,11 +4446,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,
                         };
                     }
@@ -4398,7 +4487,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))),
                             };
                         }
@@ -4444,7 +4532,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (typeResult.isIncomplete) {
                     isPositionalIndexTypeIncomplete = true;
                 }
-                const iterableType = getTypeOfIterator(exprType, /* isAsync */ false, arg) || types_1.UnknownType.create();
+                const iterableType = getTypeOfIterator(exprType, /* isAsync */ false, arg.valueExpression) || types_1.UnknownType.create();
                 tupleEntries.push(iterableType);
             });
             positionalIndexType = makeTupleObject(tupleEntries, unpackedListArgs.length > 0);
@@ -4513,7 +4601,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         callResult = validateCallArguments(node, argList, { type: itemMethodType });
         return {
-            node,
             type: (_c = callResult.returnType) !== null && _c !== void 0 ? _c : types_1.UnknownType.create(),
             isIncomplete: !!callResult.isTypeIncomplete,
         };
@@ -4541,10 +4628,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);
@@ -4590,7 +4680,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let typeResult;
         let adjustedFlags = flags |
             64 /* ExpectingType */ |
-            1024 /* ExpectingTypeAnnotation */ |
             1 /* ConvertEllipsisToAny */ |
             8 /* EvaluateStringLiteralAsType */;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
@@ -4600,14 +4689,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);
@@ -4623,7 +4714,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.
@@ -4700,20 +4791,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 = [];
@@ -4769,7 +4858,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.
@@ -4843,7 +4932,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;
     }
@@ -4854,12 +4943,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)) {
@@ -4868,7 +4957,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;
@@ -4905,7 +4994,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;
@@ -4929,11 +5018,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;
@@ -5082,11 +5167,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,
                 };
             }
         }
@@ -5096,11 +5179,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) {
@@ -5108,17 +5187,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,
@@ -5128,6 +5201,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;
@@ -5149,11 +5223,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, () => {
@@ -5178,24 +5256,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;
         }
@@ -5210,15 +5283,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);
@@ -5255,17 +5326,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);
@@ -5841,7 +5910,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                         if ((0, types_1.isClassInstance)(subtype) ||
                                             ((0, types_1.isTypeVar)(subtype) && types_1.TypeBase.isInstance(subtype)) ||
                                             (0, types_1.isNoneInstance)(subtype)) {
-                                            return (0, typeUtils_1.convertToInstantiable)((0, typeUtils_1.stripLiteralValue)(subtype));
+                                            return (0, typeUtils_1.convertToInstantiable)(stripLiteralValue(subtype));
                                         }
                                         return types_1.AnyType.create();
                                     });
@@ -5880,18 +5949,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeNotIntantiable().format({ type: className }), errorNode);
                                 return types_1.AnyType.create();
                             }
-                            if (className === 'Enum' ||
-                                className === 'IntEnum' ||
-                                className === 'StrEnum' ||
-                                className === 'Flag' ||
-                                className === 'IntFlag') {
-                                return createEnumType(errorNode, expandedSubtype, argList);
+                            if ((0, enums_1.isKnownEnumType)(className)) {
+                                return (0, enums_1.createEnumType)(errorNode, expandedSubtype, argList);
                             }
                             if (className === 'TypedDict') {
                                 return (0, typedDicts_1.createTypedDictType)(evaluatorInterface, errorNode, expandedSubtype, argList);
                             }
                             if (className === 'auto' && argList.length === 0) {
-                                return getBuiltInObject(errorNode, 'int');
+                                return (0, enums_1.getEnumAutoValueType)(evaluatorInterface, errorNode);
                             }
                         }
                         if (types_1.ClassType.supportsAbstractMethods(expandedSubtype)) {
@@ -6682,13 +6747,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 reportedArgError = true;
                             }
                             return {
-                                type: (0, typeUtils_1.stripLiteralValue)(argType),
+                                type: stripLiteralValue(argType),
                                 isUnbounded: argParam.argument.argumentCategory === 1 /* UnpackedList */,
                             };
                         });
                         const specializedTuple = types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeTupleClass)(tupleClassType, tupleTypeArgs, 
                         /* isTypeArgumentExplicit */ true, 
-                        /* stripLiterals */ true, 
                         /* isUnpackedTuple */ true));
                         const combinedArg = {
                             paramCategory: 1 /* VarArgList */,
@@ -7220,7 +7284,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // strip literals before performing the assignment. This is used in
         // places like a dict constructor.
         if (argParam.paramCategory === 2 /* VarArgDictionary */ && (0, types_1.isTypeVar)(argParam.paramType)) {
-            argType = (0, typeUtils_1.stripLiteralValue)(argType);
+            argType = stripLiteralValue(argType);
         }
         // If there's a constraint filter, apply it to top-level type variables
         // if appropriate. This doesn't properly handle non-top-level constrained
@@ -7407,9 +7471,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         addError(localize_1.Localizer.Diagnostic.typeVarBoundAndConstrained(), argList[i].valueExpression || errorNode);
                     }
                     else {
-                        const argType = (_b = (_a = argList[i].typeResult) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : 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);
                         }
@@ -7446,9 +7508,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     addError(localize_1.Localizer.Diagnostic.typeVarBoundAndConstrained(), argList[i].valueExpression || errorNode);
                 }
                 else {
-                    const argType = (_e = (_d = argList[i].typeResult) === null || _d === void 0 ? void 0 : _d.type) !== null && _e !== void 0 ? _e : 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);
                     }
@@ -7538,80 +7598,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         nameParts.push(moduleName);
         return nameParts.reverse().join('.');
     }
-    // Creates a new custom enum class with named values.
-    function createEnumType(errorNode, enumClass, argList) {
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
-        let className = 'enum';
-        if (argList.length === 0) {
-            return undefined;
-        }
-        else {
-            const nameArg = argList[0];
-            if (nameArg.argumentCategory === 0 /* Simple */ &&
-                nameArg.valueExpression &&
-                nameArg.valueExpression.nodeType === 48 /* StringList */) {
-                className = nameArg.valueExpression.strings.map((s) => s.value).join('');
-            }
-            else {
-                return undefined;
-            }
-        }
-        const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.filePath, 1048576 /* EnumClass */, ParseTreeUtils.getTypeSourceId(errorNode), 
-        /* declaredMetaclass */ undefined, enumClass.details.effectiveMetaclass);
-        classType.details.baseClasses.push(enumClass);
-        (0, typeUtils_1.computeMroLinearization)(classType);
-        const classFields = classType.details.fields;
-        classFields.set('__class__', symbol_1.Symbol.createWithType(4 /* ClassMember */ | 64 /* IgnoredForProtocolMatch */, classType));
-        if (argList.length < 2) {
-            return undefined;
-        }
-        else {
-            const entriesArg = argList[1];
-            if (entriesArg.argumentCategory !== 0 /* Simple */ ||
-                !entriesArg.valueExpression ||
-                entriesArg.valueExpression.nodeType !== 48 /* StringList */) {
-                // Technically, the Enum constructor supports a bunch of different
-                // ways to specify the items: space-delimited string, a string
-                // iterator, an iterator of name/value tuples, and a dictionary
-                // of name/value pairs. We support only the simple space-delimited
-                // string here. For users who are interested in type checking, we
-                // recommend using the more standard class declaration syntax.
-                return undefined;
-            }
-            else {
-                const entries = entriesArg.valueExpression.strings
-                    .map((s) => s.value)
-                    .join('')
-                    .split(' ');
-                entries.forEach((entryName) => {
-                    entryName = entryName.trim();
-                    if (entryName) {
-                        const entryType = types_1.UnknownType.create();
-                        const newSymbol = symbol_1.Symbol.createWithType(4 /* ClassMember */, entryType);
-                        // We need to associate the declaration with a parse node.
-                        // In this case it's just part of a string literal value.
-                        // The definition provider won't necessarily take the
-                        // user to the exact spot in the string, but it's close enough.
-                        const stringNode = entriesArg.valueExpression;
-                        (0, debug_1.assert)(stringNode.nodeType === 48 /* StringList */);
-                        const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
-                        const declaration = {
-                            type: 1 /* Variable */,
-                            node: stringNode,
-                            isRuntimeTypeExpression: true,
-                            path: fileInfo.filePath,
-                            range: (0, positionUtils_1.convertOffsetsToRange)(stringNode.start, textRange_1.TextRange.getEnd(stringNode), fileInfo.lines),
-                            moduleName: fileInfo.moduleName,
-                            isInExceptSuite: false,
-                        };
-                        newSymbol.addDeclaration(declaration);
-                        classFields.set(entryName, newSymbol);
-                    }
-                });
-            }
-        }
-        return classType;
-    }
     // Implements the semantics of the NewType call as documented
     // in the Python specification: The static type checker will treat
     // the new type as if it were a subclass of the original type.
@@ -7726,14 +7712,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.
@@ -7812,16 +7798,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;
@@ -7830,10 +7807,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.
@@ -7910,15 +7887,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.
@@ -7964,7 +7941,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)) {
@@ -8017,7 +7994,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, 
@@ -8065,7 +8042,7 @@ 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;
@@ -8467,7 +8444,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (resultTypedDict) {
                     return {
                         type: resultTypedDict,
-                        node,
                         isIncomplete,
                     };
                 }
@@ -8505,7 +8481,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.
@@ -8522,8 +8498,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             isIncomplete = true;
         }
         // Strip any literal values.
-        keyTypes = keyTypes.map((t) => (0, typeUtils_1.stripLiteralValue)(t));
-        valueTypes = valueTypes.map((t) => (0, typeUtils_1.stripLiteralValue)(t));
+        keyTypes = keyTypes.map((t) => stripLiteralValue(t));
+        valueTypes = valueTypes.map((t) => stripLiteralValue(t));
         keyType = keyTypes.length > 0 ? (0, types_1.combineTypes)(keyTypes) : fallbackType;
         // If the value type differs and we're not using "strict inference mode",
         // we need to back off because we can't properly represent the mappings
@@ -8549,7 +8525,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;
@@ -8727,7 +8703,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) {
@@ -8751,7 +8727,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 entryTypes.push(entryTypeResult.type);
             }
         });
-        entryTypes = entryTypes.map((t) => (0, typeUtils_1.stripLiteralValue)(t));
+        entryTypes = entryTypes.map((t) => stripLiteralValue(t));
         let inferredEntryType = hasExpectedType ? types_1.AnyType.create() : types_1.UnknownType.create();
         if (entryTypes.length > 0) {
             const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
@@ -8779,7 +8755,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;
@@ -8809,7 +8785,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (useSynthesizedTypeVar) {
             typeVarContext.setTypeVarType(targetTypeVar, isNarrowable ? undefined : expectedType, expectedType);
         }
-        if (entryTypes.every((entryType) => assignType(targetTypeVar, (0, typeUtils_1.stripLiteralValue)(entryType), /* diag */ undefined, typeVarContext))) {
+        if (entryTypes.every((entryType) => assignType(targetTypeVar, stripLiteralValue(entryType), /* diag */ undefined, typeVarContext))) {
             return (0, typeUtils_1.applySolvedTypeVars)(targetTypeVar, typeVarContext);
         }
         // Allocate a fresh typeVarContext before we try again with literals not stripped.
@@ -8841,7 +8817,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;
@@ -8871,7 +8847,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;
@@ -8894,7 +8870,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;
@@ -9013,7 +8989,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;
@@ -9046,7 +9022,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.
@@ -9083,7 +9059,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (iterableTypeResult.isIncomplete) {
                 isIncomplete = true;
             }
-            const iterableType = (0, typeUtils_1.stripLiteralValue)(iterableTypeResult.type);
+            const iterableType = stripLiteralValue(iterableTypeResult.type);
             const itemType = (_a = getTypeOfIterator(iterableType, !!node.isAsync, node.iterableExpression)) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
             const targetExpr = node.targetExpression;
             assignTypeToExpression(targetExpr, itemType, !!iterableTypeResult.isIncomplete, node.iterableExpression);
@@ -9119,7 +9095,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             let keyType = keyTypeResult.type;
             if (!expectedKeyType || !(0, typeUtils_1.containsLiteralType)(expectedKeyType)) {
-                keyType = (0, typeUtils_1.stripLiteralValue)(keyType);
+                keyType = stripLiteralValue(keyType);
             }
             const valueTypeResult = getTypeOfExpression(node.expression.valueExpression, 
             /* flags */ undefined, expectedValueOrElementType);
@@ -9128,7 +9104,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             let valueType = valueTypeResult.type;
             if (!expectedValueOrElementType || !(0, typeUtils_1.containsLiteralType)(expectedValueOrElementType)) {
-                valueType = (0, typeUtils_1.stripLiteralValue)(valueType);
+                valueType = stripLiteralValue(valueType);
             }
             type = makeTupleObject([keyType, valueType]);
         }
@@ -9144,7 +9120,7 @@ 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
@@ -9160,7 +9136,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 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) {
@@ -9765,8 +9741,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);
@@ -9860,49 +9835,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return createSpecialType(classType, typeArgs, /* paramLimit */ undefined, /* allowParamSpec */ true);
     }
-    function transformTypeForPossibleEnumClass(node, getValueType) {
-        var _a, _b, _c, _d;
-        // If the node is within a class that derives from the metaclass
-        // "EnumMeta", we need to treat assignments differently.
-        const enclosingClassNode = ParseTreeUtils.getEnclosingClass(node, /* stopAtFunction */ true);
-        if (enclosingClassNode) {
-            const enumClassInfo = getTypeOfClass(enclosingClassNode);
-            if (enumClassInfo && types_1.ClassType.isEnumClass(enumClassInfo.classType)) {
-                // In ".py" files, the transform applies only to members that are
-                // assigned within the class. In stub files, it applies to most variables
-                // even if they are not assigned. This unfortunate convention means
-                // there is no way in a stub to specify both enum members and instance
-                // variables used within each enum instance. Unless/until there is
-                // a change to this convention and all type checkers and stubs adopt
-                // it, we're stuck with this limitation.
-                let isMemberOfEnumeration = (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 3 /* Assignment */ && node.parent.leftExpression === node) ||
-                    (((_b = node.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 54 /* TypeAnnotation */ &&
-                        node.parent.valueExpression === node &&
-                        ((_c = node.parent.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 3 /* Assignment */) ||
-                    (AnalyzerNodeInfo.getFileInfo(node).isStubFile &&
-                        ((_d = node.parent) === null || _d === void 0 ? void 0 : _d.nodeType) === 54 /* TypeAnnotation */ &&
-                        node.parent.valueExpression === node);
-                // The spec specifically excludes names that start and end with a single underscore.
-                // This also includes dunder names.
-                if ((0, symbolNameUtils_1.isSingleDunderName)(node.value)) {
-                    isMemberOfEnumeration = false;
-                }
-                // Specifically exclude "value" and "name". These are reserved by the enum metaclass.
-                if (node.value === 'name' || node.value === 'value') {
-                    isMemberOfEnumeration = false;
-                }
-                const valueType = getValueType();
-                // The spec excludes descriptors.
-                if ((0, types_1.isClassInstance)(valueType) && valueType.details.fields.get('__get__')) {
-                    isMemberOfEnumeration = false;
-                }
-                if (isMemberOfEnumeration) {
-                    return types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneWithLiteral(enumClassInfo.classType, new types_1.EnumLiteral(enumClassInfo.classType.details.name, node.value, valueType)));
-                }
-            }
-        }
-        return undefined;
-    }
     function transformTypeForTypeAlias(type, name, errorNode, typeParameters) {
         if (!types_1.TypeBase.isInstantiable(type)) {
             return type;
@@ -10192,7 +10124,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 rightHandType = srcType;
                 if (node.leftExpression.nodeType === 38 /* Name */ && !node.typeAnnotationComment) {
                     rightHandType =
-                        transformTypeForPossibleEnumClass(node.leftExpression, () => rightHandType) || rightHandType;
+                        (0, enums_1.transformTypeForPossibleEnumClass)(evaluatorInterface, node.leftExpression, () => rightHandType) || rightHandType;
                 }
                 if (typeAliasNameNode) {
                     // Clear out the temporary types we wrote above.
@@ -10296,6 +10228,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const destTypeResult = getTypeOfAugmentedAssignment(node, /* expectedType */ undefined);
         writeTypeCache(node, destTypeResult.type, 0 /* None */, !!destTypeResult.isIncomplete);
     }
+    function getPseudoGenericTypeVarName(paramName) {
+        return `__type_of_${paramName}`;
+    }
     function getTypeOfClass(node) {
         // Is this type already cached?
         const cachedClassType = readTypeCache(node.name, 0 /* None */);
@@ -10609,13 +10544,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     const initParams = initDeclNode.parameters;
                     if (initParams.length > 1 &&
                         !initParams.some((param, index) => !!ParseTreeUtils.getTypeAnnotationForParameter(initDeclNode, index))) {
-                        const genericParams = initParams.filter((param, index) => index > 0 && param.name && param.category === 0 /* Simple */);
+                        const genericParams = initParams.filter((param, index) => index > 0 &&
+                            param.name &&
+                            param.category === 0 /* Simple */ &&
+                            !param.defaultValue);
                         if (genericParams.length > 0) {
                             classType.details.flags |= 16384 /* PseudoGenericClass */;
                             // Create a type parameter for each simple, named parameter
                             // in the __init__ method.
                             classType.details.typeParameters = genericParams.map((param) => {
-                                const typeVar = types_1.TypeVarType.createInstance(`__type_of_${param.name.value}`);
+                                const typeVar = types_1.TypeVarType.createInstance(getPseudoGenericTypeVarName(param.name.value));
                                 typeVar.details.isSynthesized = true;
                                 typeVar.scopeId = getScopeIdForNode(initDeclNode);
                                 typeVar.details.boundType = types_1.UnknownType.create();
@@ -11149,7 +11087,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             types_1.ClassType.isPseudoGenericClass(containingClassType) &&
             node.name.value === '__init__';
         const paramTypes = [];
-        let typeParamIndex = 0;
         // Determine if the first parameter should be skipped for comment-based
         // function annotations.
         let firstCommentAnnotationIndex = 0;
@@ -11232,9 +11169,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             if (!annotatedType && addGenericParamTypes) {
-                if (index > 0 && param.category === 0 /* Simple */ && param.name) {
-                    annotatedType = containingClassType.details.typeParameters[typeParamIndex];
-                    typeParamIndex++;
+                if (index > 0 && param.category === 0 /* Simple */ && param.name && !param.defaultValue) {
+                    const typeParamName = getPseudoGenericTypeVarName(param.name.value);
+                    annotatedType = containingClassType.details.typeParameters.find((param) => param.details.name === typeParamName);
                 }
             }
             if (annotatedType) {
@@ -11523,7 +11460,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // more restrictive (narrower) than intended.
                 if (!(0, types_1.isClassInstance)(defaultValueType) ||
                     !types_1.ClassType.isBuiltIn(defaultValueType, ['tuple', 'list', 'set', 'dict'])) {
-                    inferredParamType = (0, typeUtils_1.stripLiteralValue)(defaultValueType);
+                    inferredParamType = stripLiteralValue(defaultValueType);
                 }
             }
             if (inferredParamType) {
@@ -11553,8 +11490,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();
             }
@@ -11869,7 +11805,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (inferredReturnType) {
             return { type: inferredReturnType, isIncomplete };
         }
-        if (functionRecursionMap.has(node.id) && functionRecursionMap.size < maxInferFunctionReturnRecursionCount) {
+        if (functionRecursionMap.has(node.id) || functionRecursionMap.size >= maxInferFunctionReturnRecursionCount) {
             inferredReturnType = types_1.UnknownType.create();
             isIncomplete = true;
         }
@@ -12110,7 +12046,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;
                 }
@@ -12308,6 +12244,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) {
@@ -12368,62 +12321,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.
@@ -12432,154 +12329,235 @@ 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) {
+                    // Handle the special case where the LHS is a call to super().
+                    if (nodeToEvaluate.nodeType === 9 /* Call */ &&
+                        nodeToEvaluate.leftExpression.nodeType === 38 /* Name */ &&
+                        nodeToEvaluate.leftExpression.value === 'super') {
+                        nodeToEvaluate = parent;
+                        continue;
+                    }
+                    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.
@@ -12607,24 +12585,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return;
         }
         const containingClassNode = ParseTreeUtils.getEnclosingClass(functionNode, /* stopAtFunction */ true);
-        if (containingClassNode) {
-            const classInfo = getTypeOfClass(containingClassNode);
-            if (classInfo) {
-                // See if the function is a method in a child class. We may be able to
-                // infer the type of the parameter from a method of the same name in
-                // a parent class if it has an annotated type.
-                const functionFlags = getFunctionFlagsFromDecorators(functionNode, /* isInClass */ true);
-                const inferredParamType = inferParameterType(functionNode, functionFlags, paramIndex, classInfo.classType);
-                if (inferredParamType) {
-                    writeTypeCache(node.name, transformVariadicParamType(node, node.category, inferredParamType), 0 /* None */, 
-                    /* isIncomplete */ false);
-                    return;
-                }
+        const classInfo = containingClassNode ? getTypeOfClass(containingClassNode) : undefined;
+        if (classInfo &&
+            types_1.ClassType.isPseudoGenericClass(classInfo === null || classInfo === void 0 ? void 0 : classInfo.classType) &&
+            functionNode.name.value === '__init__') {
+            const typeParamName = getPseudoGenericTypeVarName(node.name.value);
+            const paramType = classInfo.classType.details.typeParameters.find((param) => param.details.name === typeParamName);
+            if (paramType) {
+                writeTypeCache(node.name, paramType, 0 /* None */, /* isIncomplete */ false);
+                return;
             }
         }
-        // We weren't able to infer the input parameter type. Set its
-        // type to unknown.
-        writeTypeCache(node.name, transformVariadicParamType(node, node.category, types_1.UnknownType.create()), 0 /* None */, 
+        // See if the function is a method in a child class. We may be able to
+        // infer the type of the parameter from a method of the same name in
+        // a parent class if it has an annotated type.
+        const functionFlags = getFunctionFlagsFromDecorators(functionNode, /* isInClass */ true);
+        const inferredParamType = inferParameterType(functionNode, functionFlags, paramIndex, classInfo === null || classInfo === void 0 ? void 0 : classInfo.classType);
+        writeTypeCache(node.name, transformVariadicParamType(node, node.category, inferredParamType !== null && inferredParamType !== void 0 ? inferredParamType : types_1.UnknownType.create()), 0 /* None */, 
         /* isIncomplete */ false);
     }
     // Evaluates the types that are assigned within the statement that contains
@@ -12739,7 +12716,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 {
@@ -12752,11 +12729,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;
         }
@@ -13376,7 +13353,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;
@@ -13451,7 +13428,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);
@@ -13665,7 +13642,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         // Apply enum transform if appropriate.
                         if (declaration.node.nodeType === 38 /* Name */) {
                             declaredType =
-                                transformTypeForPossibleEnumClass(declaration.node, () => declaredType) || declaredType;
+                                (0, enums_1.transformTypeForPossibleEnumClass)(evaluatorInterface, declaration.node, () => declaredType) || declaredType;
                         }
                         if (typeAliasNode && typeAliasNode.valueExpression.nodeType === 38 /* Name */) {
                             declaredType = transformTypeForTypeAlias(declaredType, typeAliasNode.valueExpression, declaration.node);
@@ -13796,7 +13773,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             })) === null || _b === void 0 ? void 0 : _b.type;
             if (inferredType && resolvedDecl.node.nodeType === 38 /* Name */) {
                 // See if this is an enum member. If so, we need to handle it as a special case.
-                const enumMemberType = transformTypeForPossibleEnumClass(resolvedDecl.node, () => {
+                const enumMemberType = (0, enums_1.transformTypeForPossibleEnumClass)(evaluatorInterface, resolvedDecl.node, () => {
                     var _a, _b;
                     return ((_b = (_a = evaluateTypeForSubnode(resolvedDecl.inferredTypeSource, () => {
                         evaluateTypesForStatement(resolvedDecl.inferredTypeSource);
@@ -14021,13 +13998,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 let isConstant = decl.type === 1 /* Variable */ && !!decl.isConstant;
                                 // Treat enum values declared within an enum class as though they are const even
                                 // though they may not be named as such.
-                                if ((0, types_1.isClassInstance)(type) && types_1.ClassType.isEnumClass(type) && isDeclInEnumClass(decl)) {
+                                if ((0, types_1.isClassInstance)(type) &&
+                                    types_1.ClassType.isEnumClass(type) &&
+                                    (0, enums_1.isDeclInEnumClass)(evaluatorInterface, decl)) {
                                     isConstant = true;
                                 }
                                 // If the symbol is constant, we can retain the literal
                                 // value. Otherwise, strip literal values to widen the type.
                                 if (types_1.TypeBase.isInstance(type) && !isExplicitTypeAlias && !isConstant && !isFinalVar) {
-                                    type = (0, typeUtils_1.stripLiteralValue)(type);
+                                    type = stripLiteralValue(type);
                                 }
                             }
                             typesToCombine.push(type);
@@ -14148,17 +14127,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return undefined;
     }
-    function isDeclInEnumClass(decl) {
-        const classNode = ParseTreeUtils.getEnclosingClass(decl.node, /* stopAtFunction */ true);
-        if (!classNode) {
-            return false;
-        }
-        const classInfo = getTypeOfClass(classNode);
-        if (!classInfo) {
-            return false;
-        }
-        return types_1.ClassType.isEnumClass(classInfo.classType);
-    }
     function inferReturnTypeIfNecessary(type) {
         if ((0, types_1.isFunction)(type)) {
             getFunctionEffectiveReturnType(type);
@@ -14292,9 +14260,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.
@@ -14337,13 +14307,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 {
@@ -14357,6 +14340,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;
@@ -14384,7 +14381,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return types_1.UnknownType.create();
     }
-    function getTypeOfMemberInternal(node, member, selfClass) {
+    function getTypeOfMemberInternal(member, selfClass) {
         if ((0, types_1.isInstantiableClass)(member.classType)) {
             const typeResult = getEffectiveTypeOfSymbolForUsage(member.symbol);
             if (typeResult) {
@@ -14393,7 +14390,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,
                 };
@@ -14573,10 +14569,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         const removedArgs = srcTypeArgs.splice(destVariadicIndex, srcArgsToCapture);
                         // Package up the remaining type arguments into a tuple object.
                         const variadicTuple = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, removedArgs.map((typeArg) => {
-                            return { type: (0, typeUtils_1.stripLiteralValue)(typeArg.type), isUnbounded: false };
+                            return { type: stripLiteralValue(typeArg.type), isUnbounded: false };
                         }), 
                         /* isTypeArgumentExplicit */ true, 
-                        /* stripLiterals */ true, 
                         /* isUnpackedTuple */ true));
                         srcTypeArgs.splice(destVariadicIndex, 0, {
                             type: variadicTuple,
@@ -15134,7 +15129,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
             }
-            const concreteSrcType = makeTopLevelTypeVarsConcrete(srcType);
+            let concreteSrcType = makeTopLevelTypeVarsConcrete(srcType);
             if ((0, types_1.isClass)(concreteSrcType) && types_1.TypeBase.isInstance(concreteSrcType)) {
                 if (destType.literalValue !== undefined) {
                     const srcLiteral = concreteSrcType.literalValue;
@@ -15147,15 +15142,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
                 // Handle LiteralString special form.
-                if (types_1.ClassType.isBuiltIn(destType, 'LiteralString') && types_1.ClassType.isBuiltIn(concreteSrcType, 'str')) {
-                    if (concreteSrcType.literalValue !== undefined) {
+                if (types_1.ClassType.isBuiltIn(destType, 'LiteralString')) {
+                    if (types_1.ClassType.isBuiltIn(concreteSrcType, 'str') && concreteSrcType.literalValue !== undefined) {
+                        return true;
+                    }
+                    else if (types_1.ClassType.isBuiltIn(concreteSrcType, 'LiteralString')) {
                         return true;
                     }
                 }
                 else if (types_1.ClassType.isBuiltIn(concreteSrcType, 'LiteralString') &&
-                    types_1.ClassType.isBuiltIn(destType, 'str') &&
-                    destType.literalValue === undefined) {
-                    return true;
+                    strClassType &&
+                    (0, types_1.isInstantiableClass)(strClassType)) {
+                    concreteSrcType = types_1.ClassType.cloneAsInstance(strClassType);
                 }
                 if (!assignClass(types_1.ClassType.cloneAsInstantiable(destType), types_1.ClassType.cloneAsInstantiable(concreteSrcType), diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount, 
                 /* reportErrorsUsingObjType */ true)) {
@@ -15240,11 +15238,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) {
@@ -15268,10 +15263,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));
                 }
@@ -15403,6 +15395,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;
@@ -15427,7 +15420,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),
@@ -15504,54 +15498,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, 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
@@ -15839,7 +15848,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 {
@@ -16025,13 +16033,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)) {
@@ -16402,22 +16408,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;
@@ -16425,19 +16450,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;
             }
         }
@@ -16462,7 +16487,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,
             }));
@@ -16489,13 +16514,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 || '*',
@@ -16507,7 +16532,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 || '*',
                 }));
@@ -16520,8 +16545,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),
@@ -16530,7 +16555,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;
@@ -16540,7 +16565,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;
@@ -16548,9 +16573,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),
@@ -16568,7 +16593,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;
@@ -16578,9 +16603,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),
@@ -16589,7 +16614,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;
@@ -16605,7 +16630,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;
@@ -16616,9 +16641,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),
             }));
@@ -16853,9 +16878,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (firstParamType && memberType.details.parameters.length > 0) {
             const memberTypeFirstParam = memberType.details.parameters[0];
             const memberTypeFirstParamType = types_1.FunctionType.getEffectiveParameterType(memberType, 0);
-            // If the type has a literal associated with it, strip it now. This
-            // is needed to handle generic functions in the enum.Flag class.
-            const nonLiteralFirstParamType = (0, typeUtils_1.stripLiteralValue)(firstParamType);
             // Fill out the typeVarContext for the "self" or "cls" parameter.
             typeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(memberType));
             const diag = new diagnostic_1.DiagnosticAddendum();
@@ -16869,11 +16891,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // Instead, we'll assume it's assignable.
                 if (!typeVarContext.isLocked()) {
                     typeVarContext.setTypeVarType(memberTypeFirstParamType, types_1.TypeBase.isInstantiable(memberTypeFirstParamType)
-                        ? (0, typeUtils_1.convertToInstance)(nonLiteralFirstParamType)
-                        : nonLiteralFirstParamType);
+                        ? (0, typeUtils_1.convertToInstance)(firstParamType)
+                        : firstParamType);
                 }
             }
-            else if (!assignType(memberTypeFirstParamType, nonLiteralFirstParamType, diag, typeVarContext, 
+            else if (!assignType(memberTypeFirstParamType, firstParamType, diag, typeVarContext, 
             /* srcTypeVarContext */ undefined, 0 /* Default */, recursionCount)) {
                 if (memberTypeFirstParam.name &&
                     !memberTypeFirstParam.isNameSynthesized &&
@@ -16978,6 +17000,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         evaluateTypeOfParameter,
         canBeTruthy,
         canBeFalsy,
+        stripLiteralValue,
         removeTruthinessFromType,
         removeFalsinessFromType,
         verifyRaiseExceptionType,
@@ -17033,6 +17056,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         addWarning,
         addInformation,
         addUnusedCode,
+        addUnreachableCode,
         addDeprecated,
         addDiagnostic,
         addDiagnosticForTextRange,