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

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"));
@@ -217,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();
@@ -264,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();
@@ -798,23 +799,46 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         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 = {
-                    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 = {
                     type: cloneBuiltinObjectWithLiteral(node, isBytes ? 'bytes' : 'str', node.strings.map((s) => s.value).join('')),
+                    isIncomplete,
                 };
             }
         }
@@ -825,9 +849,34 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let typeResult;
         // Don't create a literal type if it's an f-string.
         if (node.nodeType === 27 /* FormatString */) {
-            typeResult = {
-                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 = {
@@ -836,6 +885,26 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         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,
@@ -1164,6 +1233,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (memberInfo) {
             return {
                 type: memberInfo.type,
+                classType: memberInfo.classType,
                 isIncomplete: !!memberInfo.isTypeIncomplete,
                 isAsymmetricDescriptor: memberInfo.isAsymmetricDescriptor,
             };
@@ -1903,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);
                 }
             }
         }
@@ -2090,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);
                     }
@@ -2786,7 +2856,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // cannot be used in this location.
     function validateTypeVarUsage(node, type, flags) {
         var _a;
-        if (types_1.TypeBase.isInstantiable(type) && !(0, typeUtils_1.isTypeAliasPlaceholder)(type)) {
+        if (types_1.TypeBase.isInstantiable(type) && !type.scopeId && !(0, typeUtils_1.isTypeAliasPlaceholder)(type)) {
             const scopedTypeVarInfo = findScopedTypeVar(node, type);
             type = scopedTypeVarInfo.type;
             if ((flags & 2048 /* DisallowTypeVarsWithScopeId */) !== 0 && type.scopeId !== undefined) {
@@ -3169,29 +3239,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
                 else {
-                    // Handle the special case of LiteralString.
-                    if (types_1.ClassType.isBuiltIn(baseType, 'LiteralString') &&
-                        strClassType &&
-                        (0, types_1.isInstantiableClass)(strClassType)) {
-                        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 {
-                                        type: types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneWithLiteral(strClass, literalValue.itemName)),
-                                        isIncomplete,
-                                    };
-                                }
-                            }
-                            else if (memberName === 'value' || memberName === '_value_') {
-                                return { 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);
@@ -3451,7 +3502,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) {
@@ -4894,7 +4945,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             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),
@@ -5385,7 +5436,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Is this a union type? If so, we can expand it.
             const argType = contextFreeArgTypes[indexToExpand];
             if ((0, types_1.isUnion)(argType)) {
-                unionToExpand = argType;
+                unionToExpand = makeTopLevelTypeVarsConcrete(argType);
+                break;
+            }
+            else if ((0, types_1.isTypeVar)(argType) && argType.details.constraints.length > 1) {
+                unionToExpand = makeTopLevelTypeVarsConcrete(argType);
                 break;
             }
             indexToExpand++;
@@ -5798,8 +5853,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);
@@ -5853,7 +5909,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();
                                     });
@@ -5892,18 +5948,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)) {
@@ -6694,7 +6746,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 reportedArgError = true;
                             }
                             return {
-                                type: (0, typeUtils_1.stripLiteralValue)(argType),
+                                type: stripLiteralValue(argType),
                                 isUnbounded: argParam.argument.argumentCategory === 1 /* UnpackedList */,
                             };
                         });
@@ -6838,7 +6890,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);
                         }
                     }
@@ -7231,7 +7283,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
@@ -7545,80 +7597,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.
@@ -7698,7 +7676,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         /* declaredMetaclass */ undefined, arg1Type.details.effectiveMetaclass);
         arg1Type.tupleTypeArguments.forEach((typeArg) => {
             const specializedType = makeTopLevelTypeVarsConcrete(typeArg.type);
-            if ((0, types_1.isInstantiableClass)(specializedType) || (0, types_1.isAnyOrUnknown)(specializedType)) {
+            if ((0, types_1.isInstantiableClass)(specializedType) ||
+                (0, types_1.isAnyOrUnknown)(specializedType) ||
+                ((0, types_1.isClassInstance)(specializedType) && types_1.ClassType.isBuiltIn(specializedType, 'type'))) {
                 classType.details.baseClasses.push(specializedType);
             }
             else {
@@ -8370,12 +8350,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if ((0, types_1.isAnyOrUnknown)(subtype)) {
                 return subtype;
             }
-            if ((0, types_1.isClassInstance)(subtype) &&
-                types_1.ClassType.isBuiltIn(subtype, 'LiteralString') &&
-                strClassType &&
-                (0, types_1.isInstantiableClass)(strClassType)) {
-                return handleSubtype(types_1.ClassType.cloneAsInstance(strClassType));
-            }
             if ((0, types_1.isClassInstance)(subtype) || (0, types_1.isInstantiableClass)(subtype) || (0, types_1.isTypeVar)(subtype)) {
                 return handleSubtype(subtype);
             }
@@ -8519,8 +8493,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
@@ -8532,7 +8506,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 {
@@ -8596,6 +8570,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if ((0, types_1.isAnyOrUnknown)(unexpandedType)) {
                     addUnknown = false;
                 }
+                else if ((0, types_1.isClassInstance)(unexpandedType) && types_1.ClassType.isTypedDictClass(unexpandedType)) {
+                    // Handle dictionary expansion for a TypedDict.
+                    if (strClassType && (0, types_1.isInstantiableClass)(strClassType)) {
+                        const strObject = types_1.ClassType.cloneAsInstance(strClassType);
+                        const tdEntries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluatorInterface, unexpandedType, 
+                        /* allowNarrowed */ true);
+                        tdEntries.forEach((entry, name) => {
+                            if (entry.isRequired || entry.isProvided) {
+                                keyTypes.push(types_1.ClassType.cloneWithLiteral(strObject, name));
+                                valueTypes.push(entry.valueType);
+                            }
+                        });
+                        addUnknown = false;
+                    }
+                }
                 else {
                     // Verify that the type supports the `keys` and `__getitem__` methods.
                     // This protocol is defined in the _typeshed stub. If we can't find
@@ -8687,6 +8676,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;
         }
@@ -8716,6 +8706,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, 
@@ -8724,13 +8717,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return undefined;
         }
         const type = getBuiltInObject(node, builtInClassName, [specializedEntryType]);
-        return { type, 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;
@@ -8744,11 +8738,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);
@@ -8761,7 +8758,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;
             }
@@ -8776,7 +8773,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             /* includeSubclasses */ undefined, 
             /* TupleTypeArguments */ undefined, isEmptyContainer))
             : types_1.UnknownType.create();
-        return { type, isIncomplete };
+        return { type, isIncomplete, typeErrors };
     }
     function inferTypeArgFromExpectedType(expectedType, entryTypes, isNarrowable) {
         let targetTypeVar;
@@ -8806,7 +8803,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.
@@ -8824,12 +8821,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);
@@ -8837,8 +8838,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (elseType.isIncomplete) {
                 isIncomplete = true;
             }
+            if (elseType.typeErrors) {
+                typeErrors = true;
+            }
         }
-        return { type: (0, types_1.combineTypes)(typesToCombine), isIncomplete };
+        return { type: (0, types_1.combineTypes)(typesToCombine), isIncomplete, typeErrors };
     }
     function getTypeOfYield(node) {
         let expectedYieldType;
@@ -9014,10 +9018,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     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) ||
@@ -9043,7 +9051,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 : [elementType, types_1.NoneType.createInstance(), types_1.NoneType.createInstance()], 
             /* isTypeArgumentExplicit */ true));
         }
-        return { type, isIncomplete };
+        return { type, isIncomplete, typeErrors };
     }
     function reportPossibleUnknownAssignment(diagLevel, rule, target, type, errorNode, ignoreEmptyContainers) {
         // Don't bother if the feature is disabled.
@@ -9080,7 +9088,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);
@@ -9100,6 +9108,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)) {
@@ -9114,18 +9123,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]);
         }
@@ -9139,9 +9154,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (exprTypeResult.isIncomplete) {
                 isIncomplete = true;
             }
+            if (exprTypeResult.typeErrors) {
+                typeErrors = true;
+            }
             type = exprTypeResult.type;
         }
-        return { type, isIncomplete };
+        return { type, isIncomplete, typeErrors };
     }
     function getTypeOfSlice(node) {
         // Evaluate the expressions to report errors and record symbol
@@ -9856,49 +9874,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;
@@ -10036,6 +10011,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return cachedType;
             }
             const specialType = createSpecialBuiltInClass(node, assignedName, aliasMapEntry);
+            // Handle 'LiteralString' specially because we want it to act as
+            // though it derives from 'str'.
+            if (assignedName === 'LiteralString') {
+                specialType.details.baseClasses.push(strClassType !== null && strClassType !== void 0 ? strClassType : types_1.AnyType.create());
+                (0, typeUtils_1.computeMroLinearization)(specialType);
+            }
             writeTypeCache(node, specialType, 0 /* None */, /* isIncomplete */ false);
             return specialType;
         }
@@ -10188,7 +10169,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.
@@ -10292,6 +10273,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 */);
@@ -10605,13 +10589,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();
@@ -11145,7 +11132,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;
@@ -11228,9 +11214,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) {
@@ -11519,7 +11505,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) {
@@ -11864,12 +11850,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);
@@ -12482,6 +12468,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // 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;
                 }
@@ -12637,24 +12630,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
@@ -13695,7 +13687,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);
@@ -13826,7 +13818,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);
@@ -14051,13 +14043,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);
@@ -14178,17 +14172,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);
@@ -14443,7 +14426,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) {
@@ -14631,7 +14614,7 @@ 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, 
                         /* isUnpackedTuple */ true));
@@ -14968,9 +14951,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;
                 }
             }
@@ -15191,7 +15172,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;
@@ -15204,15 +15185,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)) {
@@ -15365,9 +15349,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
@@ -15396,9 +15378,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);
                     }
@@ -15410,11 +15390,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // For all remaining source subtypes, attempt to find a dest subtype
             // whose primary type matches.
             if (!isIncompatible) {
-                [...remainingSrcSubtypes].forEach((srcSubtype) => {
-                    const destTypeIndex = remainingDestSubtypes.findIndex((destSubtype) => (0, types_1.isClass)(srcSubtype) &&
-                        (0, types_1.isClass)(destSubtype) &&
-                        types_1.TypeBase.isInstance(srcSubtype) === types_1.TypeBase.isInstance(destSubtype) &&
-                        types_1.ClassType.isSameGenericClass(srcSubtype, destSubtype));
+                (0, typeUtils_1.sortTypes)(remainingSrcSubtypes).forEach((srcSubtype) => {
+                    const destTypeIndex = remainingDestSubtypes.findIndex((destSubtype) => {
+                        if ((0, types_1.isClass)(srcSubtype) &&
+                            (0, types_1.isClass)(destSubtype) &&
+                            types_1.TypeBase.isInstance(srcSubtype) === types_1.TypeBase.isInstance(destSubtype) &&
+                            types_1.ClassType.isSameGenericClass(srcSubtype, destSubtype)) {
+                            return true;
+                        }
+                        if ((0, types_1.isFunction)(srcSubtype) || (0, types_1.isOverloadedFunction)(srcSubtype)) {
+                            if ((0, types_1.isFunction)(destSubtype) || (0, types_1.isOverloadedFunction)(destSubtype)) {
+                                return true;
+                            }
+                        }
+                        return false;
+                    });
                     if (destTypeIndex >= 0) {
                         if (!assignType(remainingDestSubtypes[destTypeIndex], srcSubtype, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
                             isIncompatible = true;
@@ -15600,7 +15590,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             // 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))) {
+                            if ((0, types_1.isTypeSame)(subtype, stripLiteralValue(srcType))) {
                                 typeVarContextScore = Number.POSITIVE_INFINITY;
                             }
                             if (bestTypeVarContextScore === undefined ||
@@ -15645,9 +15635,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);
@@ -16323,9 +16311,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;
                     }
@@ -16723,9 +16709,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);
@@ -16937,9 +16921,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();
@@ -16953,11 +16934,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 &&
@@ -17062,10 +17043,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         evaluateTypeOfParameter,
         canBeTruthy,
         canBeFalsy,
+        stripLiteralValue,
         removeTruthinessFromType,
         removeFalsinessFromType,
         verifyRaiseExceptionType,
         verifyDeleteExpression,
+        validateOverloadedFunctionArguments,
         isAfterNodeReachable,
         isNodeReachable,
         isAsymmetricDescriptorAssignment,