@zzzen/pyright-internal 1.2.0-dev.20220717 → 1.2.0-dev.20220807

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,
@@ -219,7 +218,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     const asymmetricDescriptorAssignmentCache = new Set();
     const speculativeTypeTracker = new typeCache_1.SpeculativeTypeTracker();
     const suppressedNodeStack = [];
-    let functionRecursionMap = new Map();
+    let functionRecursionMap = new Set();
     let codeFlowAnalyzerCache = new Map();
     let typeCache = new Map();
     let effectiveTypeCache = new Map();
@@ -266,7 +265,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // circular references in complex data structures, so it fails
     // to clean up the objects if we don't help it out.
     function disposeEvaluator() {
-        functionRecursionMap = new Map();
+        functionRecursionMap = new Set();
         codeFlowAnalyzerCache = new Map();
         typeCache = new Map();
         effectiveTypeCache = new Map();
@@ -283,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?
@@ -299,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);
+                    }
                 }
             }
         }
@@ -428,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 {
@@ -438,6 +461,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     node: curNode,
                 };
             }
+            if (curNode === topExpression) {
+                break;
+            }
             curNode = curNode.parent;
         }
         return undefined;
@@ -470,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?
@@ -479,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) {
@@ -631,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:
@@ -683,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;
@@ -692,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;
     }
@@ -730,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;
@@ -769,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,
                 };
             }
         }
@@ -803,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,
@@ -1143,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,
             };
@@ -1157,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, 
@@ -1189,7 +1278,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if (memberInfo) {
             return {
-                node: errorNode,
                 type: memberInfo.type,
                 isIncomplete: !!memberInfo.isTypeIncomplete,
                 isAsymmetricDescriptor: memberInfo.isAsymmetricDescriptor,
@@ -1509,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) {
@@ -1884,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);
                 }
             }
         }
@@ -1904,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 */);
@@ -1950,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;
@@ -2077,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);
                     }
@@ -2164,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));
                 }
             }
@@ -2476,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);
@@ -2574,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,
                 };
@@ -2718,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).
@@ -3016,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,
             };
@@ -3076,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.
@@ -3112,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) {
@@ -3136,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 */);
@@ -3167,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);
@@ -3285,7 +3350,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     else {
                         const typeResult = getTypeOfMemberAccessWithBaseType(node, {
                             type: subtype,
-                            node,
                             isIncomplete: baseTypeResult.isIncomplete,
                         }, usage, 0 /* None */);
                         if (typeResult.isIncomplete) {
@@ -3317,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;
@@ -3387,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;
@@ -3444,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) {
@@ -4026,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),
@@ -4041,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)),
                     });
                 }
@@ -4202,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;
@@ -4299,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);
             }
@@ -4318,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)) {
@@ -4363,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
@@ -4384,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,
                         };
                     }
@@ -4426,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))),
                             };
                         }
@@ -4541,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,
         };
@@ -4569,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);
@@ -4618,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);
@@ -4628,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);
@@ -4651,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.
@@ -4728,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 = [];
@@ -4797,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.
@@ -4871,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;
     }
@@ -4882,21 +4943,21 @@ 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)) {
+        if (!(0, types_1.isTypeSame)(assertedType, arg0TypeResult.type, { treatAnySameAsUnknown: true })) {
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.assertTypeTypeMismatch().format({
                 expected: printType(assertedType),
                 received: printType(arg0TypeResult.type),
             }), node.arguments[0].valueExpression);
         }
-        return { node, type: arg0TypeResult.type };
+        return { type: arg0TypeResult.type };
     }
     function getTypeOfRevealType(node, expectedType) {
         let arg0Value;
@@ -4933,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;
@@ -4957,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;
@@ -5110,7 +5167,6 @@ 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,
@@ -5123,10 +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(),
-                    node,
-                };
+                return { type: types_1.UnknownType.create() };
             }
             const baseClasses = targetClassType.details.baseClasses;
             if (baseClasses.length > 0) {
@@ -5134,15 +5187,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if ((0, types_1.isInstantiableClass)(baseClassType)) {
                     return {
                         type: resultIsInstance ? types_1.ClassType.cloneAsInstance(baseClassType) : baseClassType,
-                        node,
                     };
                 }
             }
         }
-        return {
-            type: types_1.UnknownType.create(),
-            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,
@@ -5152,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;
@@ -5173,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, () => {
@@ -5202,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;
         }
@@ -5806,8 +5855,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         const castToType = getTypeOfArgumentExpectingType(argList[0]).type;
                         const castFromType = getTypeOfArgument(argList[1]).type;
                         if ((0, types_1.isInstantiableClass)(castToType) && (0, types_1.isClassInstance)(castFromType)) {
-                            if ((0, types_1.isTypeSame)(castToType, types_1.ClassType.cloneAsInstantiable(castFromType), 
-                            /* ignorePseudoGeneric */ true)) {
+                            if ((0, types_1.isTypeSame)(castToType, types_1.ClassType.cloneAsInstantiable(castFromType), {
+                                ignorePseudoGeneric: true,
+                            })) {
                                 addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportUnnecessaryCast, diagnosticRules_1.DiagnosticRule.reportUnnecessaryCast, localize_1.Localizer.Diagnostic.unnecessaryCast().format({
                                     type: printType(castFromType),
                                 }), errorNode);
@@ -5861,7 +5911,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();
                                     });
@@ -5900,18 +5950,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)) {
@@ -6702,13 +6748,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 */,
@@ -6847,7 +6892,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 type.strippedFirstParamType.typeArguments.forEach((typeArg, index) => {
                     if (index < typeParams.length) {
                         const typeParam = typeParams[index];
-                        if (!(0, types_1.isTypeSame)(typeParam, typeArg, /* ignorePseudoGeneric */ true)) {
+                        if (!(0, types_1.isTypeSame)(typeParam, typeArg, { ignorePseudoGeneric: true })) {
                             typeVarContext.setTypeVarType(typeParams[index], typeArg);
                         }
                     }
@@ -7240,7 +7285,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
@@ -7427,9 +7472,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);
                         }
@@ -7466,9 +7509,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);
                     }
@@ -7558,80 +7599,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.
@@ -7746,14 +7713,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.
@@ -7832,16 +7799,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;
@@ -7850,10 +7808,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.
@@ -7930,15 +7888,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.
@@ -7984,7 +7942,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)) {
@@ -8037,7 +7995,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, 
@@ -8085,7 +8043,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;
@@ -8487,7 +8445,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (resultTypedDict) {
                     return {
                         type: resultTypedDict,
-                        node,
                         isIncomplete,
                     };
                 }
@@ -8525,7 +8482,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.
@@ -8542,8 +8499,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
@@ -8555,7 +8512,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 valueType = (0, types_1.combineTypes)(valueTypes);
             }
             else {
-                valueType = (0, typeUtils_1.areTypesSame)(valueTypes, /* ignorePseudoGeneric */ true) ? valueTypes[0] : fallbackType;
+                valueType = (0, typeUtils_1.areTypesSame)(valueTypes, { ignorePseudoGeneric: true }) ? valueTypes[0] : fallbackType;
             }
         }
         else {
@@ -8569,7 +8526,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;
@@ -8710,6 +8667,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const builtInClassName = node.nodeType === 31 /* List */ ? 'list' : 'set';
         expectedType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(expectedType);
         let isIncomplete = false;
+        let typeErrors = false;
         if (!(0, types_1.isClassInstance)(expectedType)) {
             return undefined;
         }
@@ -8739,6 +8697,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (entryTypeResult.isIncomplete) {
                 isIncomplete = true;
             }
+            if (entryTypeResult.typeErrors) {
+                typeErrors = true;
+            }
         });
         const isExpectedTypeListOrSet = (0, types_1.isClassInstance)(expectedType) && types_1.ClassType.isBuiltIn(expectedType, builtInClassName);
         const specializedEntryType = inferTypeArgFromExpectedType(expectedEntryType, entryTypes, 
@@ -8747,13 +8708,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return undefined;
         }
         const type = getBuiltInObject(node, builtInClassName, [specializedEntryType]);
-        return { type, node, isIncomplete };
+        return { type, isIncomplete, typeErrors };
     }
     // Attempts to infer the type of a list or set statement with no "expected type".
     function getTypeOfListOrSetInferred(node, hasExpectedType) {
         const builtInClassName = node.nodeType === 31 /* List */ ? 'list' : 'set';
         let isEmptyContainer = false;
         let isIncomplete = false;
+        let typeErrors = false;
         let entryTypes = [];
         node.entries.forEach((entry, index) => {
             let entryTypeResult;
@@ -8767,11 +8729,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (entryTypeResult.isIncomplete) {
                 isIncomplete = true;
             }
+            if (entryTypeResult.typeErrors) {
+                typeErrors = true;
+            }
             if (index < maxEntriesToUseForInference) {
                 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);
@@ -8784,7 +8749,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             else {
                 // Is the list or set homogeneous? If so, use stricter rules. Otherwise relax the rules.
-                inferredEntryType = (0, typeUtils_1.areTypesSame)(entryTypes, /* ignorePseudoGeneric */ true)
+                inferredEntryType = (0, typeUtils_1.areTypesSame)(entryTypes, { ignorePseudoGeneric: true })
                     ? entryTypes[0]
                     : inferredEntryType;
             }
@@ -8799,7 +8764,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             /* includeSubclasses */ undefined, 
             /* TupleTypeArguments */ undefined, isEmptyContainer))
             : types_1.UnknownType.create();
-        return { type, node, isIncomplete };
+        return { type, isIncomplete, typeErrors };
     }
     function inferTypeArgFromExpectedType(expectedType, entryTypes, isNarrowable) {
         let targetTypeVar;
@@ -8829,7 +8794,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.
@@ -8847,12 +8812,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         getTypeOfExpression(node.testExpression);
         const typesToCombine = [];
         let isIncomplete = false;
+        let typeErrors = false;
         if (isNodeReachable(node.ifExpression)) {
             const ifType = getTypeOfExpression(node.ifExpression, flags, expectedType);
             typesToCombine.push(ifType.type);
             if (ifType.isIncomplete) {
                 isIncomplete = true;
             }
+            if (ifType.typeErrors) {
+                typeErrors = true;
+            }
         }
         if (isNodeReachable(node.elseExpression)) {
             const elseType = getTypeOfExpression(node.elseExpression, flags, expectedType);
@@ -8860,8 +8829,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (elseType.isIncomplete) {
                 isIncomplete = true;
             }
+            if (elseType.typeErrors) {
+                typeErrors = true;
+            }
         }
-        return { type: (0, types_1.combineTypes)(typesToCombine), node, isIncomplete };
+        return { type: (0, types_1.combineTypes)(typesToCombine), isIncomplete, typeErrors };
     }
     function getTypeOfYield(node) {
         let expectedYieldType;
@@ -8891,7 +8863,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;
@@ -8914,7 +8886,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;
@@ -9033,14 +9005,18 @@ 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;
+        let typeErrors = false;
         const elementTypeResult = getElementTypeFromListComprehension(node);
         if (elementTypeResult.isIncomplete) {
             isIncomplete = true;
         }
+        if (elementTypeResult.typeErrors) {
+            typeErrors = true;
+        }
         const elementType = elementTypeResult.type;
         let isAsync = node.forIfNodes.some((comp) => {
             return ((comp.nodeType === 33 /* ListComprehensionFor */ && comp.isAsync) ||
@@ -9066,7 +9042,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 : [elementType, types_1.NoneType.createInstance(), types_1.NoneType.createInstance()], 
             /* isTypeArgumentExplicit */ true));
         }
-        return { type, node, isIncomplete };
+        return { type, isIncomplete, typeErrors };
     }
     function reportPossibleUnknownAssignment(diagLevel, rule, target, type, errorNode, ignoreEmptyContainers) {
         // Don't bother if the feature is disabled.
@@ -9103,7 +9079,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);
@@ -9123,6 +9099,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // as opposed to the entire list.
     function getElementTypeFromListComprehension(node, expectedValueOrElementType, expectedKeyType) {
         let isIncomplete = false;
+        let typeErrors = false;
         // "Execute" the list comprehensions from start to finish.
         for (const forIfNode of node.forIfNodes) {
             if (evaluateListComprehensionForIf(forIfNode)) {
@@ -9137,18 +9114,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (keyTypeResult.isIncomplete) {
                 isIncomplete = true;
             }
+            if (keyTypeResult.typeErrors) {
+                typeErrors = true;
+            }
             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);
             if (valueTypeResult.isIncomplete) {
                 isIncomplete = true;
             }
+            if (valueTypeResult.typeErrors) {
+                typeErrors = true;
+            }
             let valueType = valueTypeResult.type;
             if (!expectedValueOrElementType || !(0, typeUtils_1.containsLiteralType)(expectedValueOrElementType)) {
-                valueType = (0, typeUtils_1.stripLiteralValue)(valueType);
+                valueType = stripLiteralValue(valueType);
             }
             type = makeTupleObject([keyType, valueType]);
         }
@@ -9162,9 +9145,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (exprTypeResult.isIncomplete) {
                 isIncomplete = true;
             }
+            if (exprTypeResult.typeErrors) {
+                typeErrors = true;
+            }
             type = exprTypeResult.type;
         }
-        return { type, node, isIncomplete };
+        return { type, isIncomplete, typeErrors };
     }
     function getTypeOfSlice(node) {
         // Evaluate the expressions to report errors and record symbol
@@ -9180,7 +9166,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) {
@@ -9785,8 +9771,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);
@@ -9880,49 +9865,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;
@@ -10212,7 +10154,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.
@@ -10316,6 +10258,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 */);
@@ -10629,13 +10574,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();
@@ -11169,7 +11117,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;
@@ -11252,9 +11199,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) {
@@ -11543,7 +11490,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) {
@@ -11573,8 +11520,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();
             }
@@ -11889,12 +11835,12 @@ 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;
         }
         else {
-            functionRecursionMap.set(node.id, true);
+            functionRecursionMap.add(node.id);
             try {
                 let functionDecl;
                 const decl = AnalyzerNodeInfo.getDeclaration(node);
@@ -12328,6 +12274,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) {
@@ -12388,62 +12351,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.
@@ -12452,154 +12359,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);
-            }
-            return;
-        }
-        else if (parent.nodeType === 14 /* Del */) {
-            verifyDeleteExpression(lastContextualExpression);
+            getTypeOfAnnotation(annotationNode);
             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.
@@ -12627,24 +12615,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
@@ -12759,7 +12746,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 {
@@ -12772,11 +12759,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;
         }
@@ -13685,7 +13672,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);
@@ -13816,7 +13803,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);
@@ -14041,13 +14028,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);
@@ -14168,17 +14157,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);
@@ -14433,7 +14411,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) {
@@ -14442,7 +14420,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,
                 };
@@ -14622,10 +14599,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,
@@ -14960,9 +14936,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 (0, typeUtils_1.isTupleClass)(srcType) &&
                 srcType.tupleTypeArguments &&
                 srcType.tupleTypeArguments.length === 1) {
-                if ((0, types_1.isTypeSame)(destType, srcType.tupleTypeArguments[0].type, 
-                /* ignorePseudoGeneric */ undefined, 
-                /* ignoreTypeFlags */ undefined, recursionCount)) {
+                if ((0, types_1.isTypeSame)(destType, srcType.tupleTypeArguments[0].type, {}, recursionCount)) {
                     return true;
                 }
             }
@@ -15183,7 +15157,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;
@@ -15196,15 +15170,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)) {
@@ -15357,9 +15334,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function assignFromUnionType(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
         // Start by checking for an exact match. This is needed to handle unions
         // that contain recursive type aliases.
-        if ((0, types_1.isTypeSame)(srcType, destType, 
-        /* ignorePseudoGeneric */ undefined, 
-        /* ignoreTypeFlags */ undefined, recursionCount)) {
+        if ((0, types_1.isTypeSame)(srcType, destType, {}, recursionCount)) {
             return true;
         }
         // Handle the case where the source and dest are both unions. Try
@@ -15388,9 +15363,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     remainingDestSubtypes.push(destSubtype);
                 }
                 else {
-                    const srcTypeIndex = remainingSrcSubtypes.findIndex((srcSubtype) => (0, types_1.isTypeSame)(srcSubtype, destSubtype, 
-                    /* ignorePseudoGeneric */ undefined, 
-                    /* ignoreTypeFlags */ undefined, recursionCount));
+                    const srcTypeIndex = remainingSrcSubtypes.findIndex((srcSubtype) => (0, types_1.isTypeSame)(srcSubtype, destSubtype, {}, recursionCount));
                     if (srcTypeIndex >= 0) {
                         remainingSrcSubtypes.splice(srcTypeIndex, 1);
                     }
@@ -15549,54 +15522,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
@@ -15622,9 +15610,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // The srcType is assignable only if all of its subtypes are assignable.
         return !(0, types_1.findSubtype)(srcType, (srcSubtype) => {
             var _a;
-            if ((0, types_1.isTypeSame)(destType, srcSubtype, 
-            /* ignorePseudoGeneric */ true, 
-            /* ignoreTypeFlags */ undefined, recursionCount)) {
+            if ((0, types_1.isTypeSame)(destType, srcSubtype, { ignorePseudoGeneric: true }, recursionCount)) {
                 return false;
             }
             const destTypeVarName = types_1.TypeVarType.getNameWithScope(destType);
@@ -15884,7 +15870,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 {
@@ -16070,13 +16055,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)) {
@@ -16303,9 +16286,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     // If there are any remaining parameters or the source doesn't include the
                     // dest param spec itself, it is not assignable in this case.
                     if (!srcParamSpec ||
-                        !(0, types_1.isTypeSame)(srcParamSpec, destParamSpec, 
-                        /* ignorePseudoGeneric */ false, 
-                        /* ignoreTypeFlags */ true) ||
+                        !(0, types_1.isTypeSame)(srcParamSpec, destParamSpec, { ignoreTypeFlags: true }) ||
                         remainingParams.length > 0) {
                         canAssign = false;
                     }
@@ -16703,9 +16684,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         let effectiveSrcType = srcType;
         if ((0, types_1.isTypeVar)(srcType)) {
-            if ((0, types_1.isTypeSame)(srcType, destType, 
-            /* ignorePseudoGeneric */ undefined, 
-            /* ignoreTypeFlags */ undefined, recursionCount)) {
+            if ((0, types_1.isTypeSame)(srcType, destType, {}, recursionCount)) {
                 return srcType;
             }
             effectiveSrcType = makeTopLevelTypeVarsConcrete(srcType);
@@ -16917,9 +16896,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();
@@ -16933,11 +16909,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 &&
@@ -17042,6 +17018,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         evaluateTypeOfParameter,
         canBeTruthy,
         canBeFalsy,
+        stripLiteralValue,
         removeTruthinessFromType,
         removeFalsinessFromType,
         verifyRaiseExceptionType,