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

package/dist/analyzer/typeEvaluator.js

@@ -55,6 +55,7 @@ const constraintSolver_1 = require("./constraintSolver");
 const constructorTransform_1 = require("./constructorTransform");
 const dataClasses_1 = require("./dataClasses");
 const declarationUtils_1 = require("./declarationUtils");
+const enums_1 = require("./enums");
 const functionTransform_1 = require("./functionTransform");
 const namedTuples_1 = require("./namedTuples");
 const ParseTreeUtils = __importStar(require("./parseTreeUtils"));
@@ -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);
                     }
@@ -3176,22 +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 {
-                                        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 +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) {
@@ -5853,7 +5910,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                         if ((0, types_1.isClassInstance)(subtype) ||
                                             ((0, types_1.isTypeVar)(subtype) && types_1.TypeBase.isInstance(subtype)) ||
                                             (0, types_1.isNoneInstance)(subtype)) {
-                                            return (0, typeUtils_1.convertToInstantiable)((0, typeUtils_1.stripLiteralValue)(subtype));
+                                            return (0, typeUtils_1.convertToInstantiable)(stripLiteralValue(subtype));
                                         }
                                         return types_1.AnyType.create();
                                     });
@@ -5892,18 +5949,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeNotIntantiable().format({ type: className }), errorNode);
                                 return types_1.AnyType.create();
                             }
-                            if (className === 'Enum' ||
-                                className === 'IntEnum' ||
-                                className === 'StrEnum' ||
-                                className === 'Flag' ||
-                                className === 'IntFlag') {
-                                return createEnumType(errorNode, expandedSubtype, argList);
+                            if ((0, enums_1.isKnownEnumType)(className)) {
+                                return (0, enums_1.createEnumType)(errorNode, expandedSubtype, argList);
                             }
                             if (className === 'TypedDict') {
                                 return (0, typedDicts_1.createTypedDictType)(evaluatorInterface, errorNode, expandedSubtype, argList);
                             }
                             if (className === 'auto' && argList.length === 0) {
-                                return getBuiltInObject(errorNode, 'int');
+                                return (0, enums_1.getEnumAutoValueType)(evaluatorInterface, errorNode);
                             }
                         }
                         if (types_1.ClassType.supportsAbstractMethods(expandedSubtype)) {
@@ -6694,7 +6747,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 reportedArgError = true;
                             }
                             return {
-                                type: (0, typeUtils_1.stripLiteralValue)(argType),
+                                type: stripLiteralValue(argType),
                                 isUnbounded: argParam.argument.argumentCategory === 1 /* UnpackedList */,
                             };
                         });
@@ -7231,7 +7284,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // strip literals before performing the assignment. This is used in
         // places like a dict constructor.
         if (argParam.paramCategory === 2 /* VarArgDictionary */ && (0, types_1.isTypeVar)(argParam.paramType)) {
-            argType = (0, typeUtils_1.stripLiteralValue)(argType);
+            argType = stripLiteralValue(argType);
         }
         // If there's a constraint filter, apply it to top-level type variables
         // if appropriate. This doesn't properly handle non-top-level constrained
@@ -7545,80 +7598,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         nameParts.push(moduleName);
         return nameParts.reverse().join('.');
     }
-    // Creates a new custom enum class with named values.
-    function createEnumType(errorNode, enumClass, argList) {
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
-        let className = 'enum';
-        if (argList.length === 0) {
-            return undefined;
-        }
-        else {
-            const nameArg = argList[0];
-            if (nameArg.argumentCategory === 0 /* Simple */ &&
-                nameArg.valueExpression &&
-                nameArg.valueExpression.nodeType === 48 /* StringList */) {
-                className = nameArg.valueExpression.strings.map((s) => s.value).join('');
-            }
-            else {
-                return undefined;
-            }
-        }
-        const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.filePath, 1048576 /* EnumClass */, ParseTreeUtils.getTypeSourceId(errorNode), 
-        /* declaredMetaclass */ undefined, enumClass.details.effectiveMetaclass);
-        classType.details.baseClasses.push(enumClass);
-        (0, typeUtils_1.computeMroLinearization)(classType);
-        const classFields = classType.details.fields;
-        classFields.set('__class__', symbol_1.Symbol.createWithType(4 /* ClassMember */ | 64 /* IgnoredForProtocolMatch */, classType));
-        if (argList.length < 2) {
-            return undefined;
-        }
-        else {
-            const entriesArg = argList[1];
-            if (entriesArg.argumentCategory !== 0 /* Simple */ ||
-                !entriesArg.valueExpression ||
-                entriesArg.valueExpression.nodeType !== 48 /* StringList */) {
-                // Technically, the Enum constructor supports a bunch of different
-                // ways to specify the items: space-delimited string, a string
-                // iterator, an iterator of name/value tuples, and a dictionary
-                // of name/value pairs. We support only the simple space-delimited
-                // string here. For users who are interested in type checking, we
-                // recommend using the more standard class declaration syntax.
-                return undefined;
-            }
-            else {
-                const entries = entriesArg.valueExpression.strings
-                    .map((s) => s.value)
-                    .join('')
-                    .split(' ');
-                entries.forEach((entryName) => {
-                    entryName = entryName.trim();
-                    if (entryName) {
-                        const entryType = types_1.UnknownType.create();
-                        const newSymbol = symbol_1.Symbol.createWithType(4 /* ClassMember */, entryType);
-                        // We need to associate the declaration with a parse node.
-                        // In this case it's just part of a string literal value.
-                        // The definition provider won't necessarily take the
-                        // user to the exact spot in the string, but it's close enough.
-                        const stringNode = entriesArg.valueExpression;
-                        (0, debug_1.assert)(stringNode.nodeType === 48 /* StringList */);
-                        const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
-                        const declaration = {
-                            type: 1 /* Variable */,
-                            node: stringNode,
-                            isRuntimeTypeExpression: true,
-                            path: fileInfo.filePath,
-                            range: (0, positionUtils_1.convertOffsetsToRange)(stringNode.start, textRange_1.TextRange.getEnd(stringNode), fileInfo.lines),
-                            moduleName: fileInfo.moduleName,
-                            isInExceptSuite: false,
-                        };
-                        newSymbol.addDeclaration(declaration);
-                        classFields.set(entryName, newSymbol);
-                    }
-                });
-            }
-        }
-        return classType;
-    }
     // Implements the semantics of the NewType call as documented
     // in the Python specification: The static type checker will treat
     // the new type as if it were a subclass of the original type.
@@ -8519,8 +8498,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             isIncomplete = true;
         }
         // Strip any literal values.
-        keyTypes = keyTypes.map((t) => (0, typeUtils_1.stripLiteralValue)(t));
-        valueTypes = valueTypes.map((t) => (0, typeUtils_1.stripLiteralValue)(t));
+        keyTypes = keyTypes.map((t) => stripLiteralValue(t));
+        valueTypes = valueTypes.map((t) => stripLiteralValue(t));
         keyType = keyTypes.length > 0 ? (0, types_1.combineTypes)(keyTypes) : fallbackType;
         // If the value type differs and we're not using "strict inference mode",
         // we need to back off because we can't properly represent the mappings
@@ -8748,7 +8727,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 entryTypes.push(entryTypeResult.type);
             }
         });
-        entryTypes = entryTypes.map((t) => (0, typeUtils_1.stripLiteralValue)(t));
+        entryTypes = entryTypes.map((t) => stripLiteralValue(t));
         let inferredEntryType = hasExpectedType ? types_1.AnyType.create() : types_1.UnknownType.create();
         if (entryTypes.length > 0) {
             const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
@@ -8806,7 +8785,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (useSynthesizedTypeVar) {
             typeVarContext.setTypeVarType(targetTypeVar, isNarrowable ? undefined : expectedType, expectedType);
         }
-        if (entryTypes.every((entryType) => assignType(targetTypeVar, (0, typeUtils_1.stripLiteralValue)(entryType), /* diag */ undefined, typeVarContext))) {
+        if (entryTypes.every((entryType) => assignType(targetTypeVar, stripLiteralValue(entryType), /* diag */ undefined, typeVarContext))) {
             return (0, typeUtils_1.applySolvedTypeVars)(targetTypeVar, typeVarContext);
         }
         // Allocate a fresh typeVarContext before we try again with literals not stripped.
@@ -9080,7 +9059,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (iterableTypeResult.isIncomplete) {
                 isIncomplete = true;
             }
-            const iterableType = (0, typeUtils_1.stripLiteralValue)(iterableTypeResult.type);
+            const iterableType = stripLiteralValue(iterableTypeResult.type);
             const itemType = (_a = getTypeOfIterator(iterableType, !!node.isAsync, node.iterableExpression)) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
             const targetExpr = node.targetExpression;
             assignTypeToExpression(targetExpr, itemType, !!iterableTypeResult.isIncomplete, node.iterableExpression);
@@ -9116,7 +9095,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             let keyType = keyTypeResult.type;
             if (!expectedKeyType || !(0, typeUtils_1.containsLiteralType)(expectedKeyType)) {
-                keyType = (0, typeUtils_1.stripLiteralValue)(keyType);
+                keyType = stripLiteralValue(keyType);
             }
             const valueTypeResult = getTypeOfExpression(node.expression.valueExpression, 
             /* flags */ undefined, expectedValueOrElementType);
@@ -9125,7 +9104,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             let valueType = valueTypeResult.type;
             if (!expectedValueOrElementType || !(0, typeUtils_1.containsLiteralType)(expectedValueOrElementType)) {
-                valueType = (0, typeUtils_1.stripLiteralValue)(valueType);
+                valueType = stripLiteralValue(valueType);
             }
             type = makeTupleObject([keyType, valueType]);
         }
@@ -9856,49 +9835,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return createSpecialType(classType, typeArgs, /* paramLimit */ undefined, /* allowParamSpec */ true);
     }
-    function transformTypeForPossibleEnumClass(node, getValueType) {
-        var _a, _b, _c, _d;
-        // If the node is within a class that derives from the metaclass
-        // "EnumMeta", we need to treat assignments differently.
-        const enclosingClassNode = ParseTreeUtils.getEnclosingClass(node, /* stopAtFunction */ true);
-        if (enclosingClassNode) {
-            const enumClassInfo = getTypeOfClass(enclosingClassNode);
-            if (enumClassInfo && types_1.ClassType.isEnumClass(enumClassInfo.classType)) {
-                // In ".py" files, the transform applies only to members that are
-                // assigned within the class. In stub files, it applies to most variables
-                // even if they are not assigned. This unfortunate convention means
-                // there is no way in a stub to specify both enum members and instance
-                // variables used within each enum instance. Unless/until there is
-                // a change to this convention and all type checkers and stubs adopt
-                // it, we're stuck with this limitation.
-                let isMemberOfEnumeration = (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 3 /* Assignment */ && node.parent.leftExpression === node) ||
-                    (((_b = node.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 54 /* TypeAnnotation */ &&
-                        node.parent.valueExpression === node &&
-                        ((_c = node.parent.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 3 /* Assignment */) ||
-                    (AnalyzerNodeInfo.getFileInfo(node).isStubFile &&
-                        ((_d = node.parent) === null || _d === void 0 ? void 0 : _d.nodeType) === 54 /* TypeAnnotation */ &&
-                        node.parent.valueExpression === node);
-                // The spec specifically excludes names that start and end with a single underscore.
-                // This also includes dunder names.
-                if ((0, symbolNameUtils_1.isSingleDunderName)(node.value)) {
-                    isMemberOfEnumeration = false;
-                }
-                // Specifically exclude "value" and "name". These are reserved by the enum metaclass.
-                if (node.value === 'name' || node.value === 'value') {
-                    isMemberOfEnumeration = false;
-                }
-                const valueType = getValueType();
-                // The spec excludes descriptors.
-                if ((0, types_1.isClassInstance)(valueType) && valueType.details.fields.get('__get__')) {
-                    isMemberOfEnumeration = false;
-                }
-                if (isMemberOfEnumeration) {
-                    return types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneWithLiteral(enumClassInfo.classType, new types_1.EnumLiteral(enumClassInfo.classType.details.name, node.value, valueType)));
-                }
-            }
-        }
-        return undefined;
-    }
     function transformTypeForTypeAlias(type, name, errorNode, typeParameters) {
         if (!types_1.TypeBase.isInstantiable(type)) {
             return type;
@@ -10188,7 +10124,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 rightHandType = srcType;
                 if (node.leftExpression.nodeType === 38 /* Name */ && !node.typeAnnotationComment) {
                     rightHandType =
-                        transformTypeForPossibleEnumClass(node.leftExpression, () => rightHandType) || rightHandType;
+                        (0, enums_1.transformTypeForPossibleEnumClass)(evaluatorInterface, node.leftExpression, () => rightHandType) || rightHandType;
                 }
                 if (typeAliasNameNode) {
                     // Clear out the temporary types we wrote above.
@@ -10292,6 +10228,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const destTypeResult = getTypeOfAugmentedAssignment(node, /* expectedType */ undefined);
         writeTypeCache(node, destTypeResult.type, 0 /* None */, !!destTypeResult.isIncomplete);
     }
+    function getPseudoGenericTypeVarName(paramName) {
+        return `__type_of_${paramName}`;
+    }
     function getTypeOfClass(node) {
         // Is this type already cached?
         const cachedClassType = readTypeCache(node.name, 0 /* None */);
@@ -10605,13 +10544,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     const initParams = initDeclNode.parameters;
                     if (initParams.length > 1 &&
                         !initParams.some((param, index) => !!ParseTreeUtils.getTypeAnnotationForParameter(initDeclNode, index))) {
-                        const genericParams = initParams.filter((param, index) => index > 0 && param.name && param.category === 0 /* Simple */);
+                        const genericParams = initParams.filter((param, index) => index > 0 &&
+                            param.name &&
+                            param.category === 0 /* Simple */ &&
+                            !param.defaultValue);
                         if (genericParams.length > 0) {
                             classType.details.flags |= 16384 /* PseudoGenericClass */;
                             // Create a type parameter for each simple, named parameter
                             // in the __init__ method.
                             classType.details.typeParameters = genericParams.map((param) => {
-                                const typeVar = types_1.TypeVarType.createInstance(`__type_of_${param.name.value}`);
+                                const typeVar = types_1.TypeVarType.createInstance(getPseudoGenericTypeVarName(param.name.value));
                                 typeVar.details.isSynthesized = true;
                                 typeVar.scopeId = getScopeIdForNode(initDeclNode);
                                 typeVar.details.boundType = types_1.UnknownType.create();
@@ -11145,7 +11087,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             types_1.ClassType.isPseudoGenericClass(containingClassType) &&
             node.name.value === '__init__';
         const paramTypes = [];
-        let typeParamIndex = 0;
         // Determine if the first parameter should be skipped for comment-based
         // function annotations.
         let firstCommentAnnotationIndex = 0;
@@ -11228,9 +11169,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             if (!annotatedType && addGenericParamTypes) {
-                if (index > 0 && param.category === 0 /* Simple */ && param.name) {
-                    annotatedType = containingClassType.details.typeParameters[typeParamIndex];
-                    typeParamIndex++;
+                if (index > 0 && param.category === 0 /* Simple */ && param.name && !param.defaultValue) {
+                    const typeParamName = getPseudoGenericTypeVarName(param.name.value);
+                    annotatedType = containingClassType.details.typeParameters.find((param) => param.details.name === typeParamName);
                 }
             }
             if (annotatedType) {
@@ -11519,7 +11460,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // more restrictive (narrower) than intended.
                 if (!(0, types_1.isClassInstance)(defaultValueType) ||
                     !types_1.ClassType.isBuiltIn(defaultValueType, ['tuple', 'list', 'set', 'dict'])) {
-                    inferredParamType = (0, typeUtils_1.stripLiteralValue)(defaultValueType);
+                    inferredParamType = stripLiteralValue(defaultValueType);
                 }
             }
             if (inferredParamType) {
@@ -11864,7 +11805,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (inferredReturnType) {
             return { type: inferredReturnType, isIncomplete };
         }
-        if (functionRecursionMap.has(node.id) && functionRecursionMap.size < maxInferFunctionReturnRecursionCount) {
+        if (functionRecursionMap.has(node.id) || functionRecursionMap.size >= maxInferFunctionReturnRecursionCount) {
             inferredReturnType = types_1.UnknownType.create();
             isIncomplete = true;
         }
@@ -12482,6 +12423,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 +12585,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return;
         }
         const containingClassNode = ParseTreeUtils.getEnclosingClass(functionNode, /* stopAtFunction */ true);
-        if (containingClassNode) {
-            const classInfo = getTypeOfClass(containingClassNode);
-            if (classInfo) {
-                // See if the function is a method in a child class. We may be able to
-                // infer the type of the parameter from a method of the same name in
-                // a parent class if it has an annotated type.
-                const functionFlags = getFunctionFlagsFromDecorators(functionNode, /* isInClass */ true);
-                const inferredParamType = inferParameterType(functionNode, functionFlags, paramIndex, classInfo.classType);
-                if (inferredParamType) {
-                    writeTypeCache(node.name, transformVariadicParamType(node, node.category, inferredParamType), 0 /* None */, 
-                    /* isIncomplete */ false);
-                    return;
-                }
+        const classInfo = containingClassNode ? getTypeOfClass(containingClassNode) : undefined;
+        if (classInfo &&
+            types_1.ClassType.isPseudoGenericClass(classInfo === null || classInfo === void 0 ? void 0 : classInfo.classType) &&
+            functionNode.name.value === '__init__') {
+            const typeParamName = getPseudoGenericTypeVarName(node.name.value);
+            const paramType = classInfo.classType.details.typeParameters.find((param) => param.details.name === typeParamName);
+            if (paramType) {
+                writeTypeCache(node.name, paramType, 0 /* None */, /* isIncomplete */ false);
+                return;
             }
         }
-        // We weren't able to infer the input parameter type. Set its
-        // type to unknown.
-        writeTypeCache(node.name, transformVariadicParamType(node, node.category, types_1.UnknownType.create()), 0 /* None */, 
+        // See if the function is a method in a child class. We may be able to
+        // infer the type of the parameter from a method of the same name in
+        // a parent class if it has an annotated type.
+        const functionFlags = getFunctionFlagsFromDecorators(functionNode, /* isInClass */ true);
+        const inferredParamType = inferParameterType(functionNode, functionFlags, paramIndex, classInfo === null || classInfo === void 0 ? void 0 : classInfo.classType);
+        writeTypeCache(node.name, transformVariadicParamType(node, node.category, inferredParamType !== null && inferredParamType !== void 0 ? inferredParamType : types_1.UnknownType.create()), 0 /* None */, 
         /* isIncomplete */ false);
     }
     // Evaluates the types that are assigned within the statement that contains
@@ -13695,7 +13642,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         // Apply enum transform if appropriate.
                         if (declaration.node.nodeType === 38 /* Name */) {
                             declaredType =
-                                transformTypeForPossibleEnumClass(declaration.node, () => declaredType) || declaredType;
+                                (0, enums_1.transformTypeForPossibleEnumClass)(evaluatorInterface, declaration.node, () => declaredType) || declaredType;
                         }
                         if (typeAliasNode && typeAliasNode.valueExpression.nodeType === 38 /* Name */) {
                             declaredType = transformTypeForTypeAlias(declaredType, typeAliasNode.valueExpression, declaration.node);
@@ -13826,7 +13773,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             })) === null || _b === void 0 ? void 0 : _b.type;
             if (inferredType && resolvedDecl.node.nodeType === 38 /* Name */) {
                 // See if this is an enum member. If so, we need to handle it as a special case.
-                const enumMemberType = transformTypeForPossibleEnumClass(resolvedDecl.node, () => {
+                const enumMemberType = (0, enums_1.transformTypeForPossibleEnumClass)(evaluatorInterface, resolvedDecl.node, () => {
                     var _a, _b;
                     return ((_b = (_a = evaluateTypeForSubnode(resolvedDecl.inferredTypeSource, () => {
                         evaluateTypesForStatement(resolvedDecl.inferredTypeSource);
@@ -14051,13 +13998,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 let isConstant = decl.type === 1 /* Variable */ && !!decl.isConstant;
                                 // Treat enum values declared within an enum class as though they are const even
                                 // though they may not be named as such.
-                                if ((0, types_1.isClassInstance)(type) && types_1.ClassType.isEnumClass(type) && isDeclInEnumClass(decl)) {
+                                if ((0, types_1.isClassInstance)(type) &&
+                                    types_1.ClassType.isEnumClass(type) &&
+                                    (0, enums_1.isDeclInEnumClass)(evaluatorInterface, decl)) {
                                     isConstant = true;
                                 }
                                 // If the symbol is constant, we can retain the literal
                                 // value. Otherwise, strip literal values to widen the type.
                                 if (types_1.TypeBase.isInstance(type) && !isExplicitTypeAlias && !isConstant && !isFinalVar) {
-                                    type = (0, typeUtils_1.stripLiteralValue)(type);
+                                    type = stripLiteralValue(type);
                                 }
                             }
                             typesToCombine.push(type);
@@ -14178,17 +14127,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return undefined;
     }
-    function isDeclInEnumClass(decl) {
-        const classNode = ParseTreeUtils.getEnclosingClass(decl.node, /* stopAtFunction */ true);
-        if (!classNode) {
-            return false;
-        }
-        const classInfo = getTypeOfClass(classNode);
-        if (!classInfo) {
-            return false;
-        }
-        return types_1.ClassType.isEnumClass(classInfo.classType);
-    }
     function inferReturnTypeIfNecessary(type) {
         if ((0, types_1.isFunction)(type)) {
             getFunctionEffectiveReturnType(type);
@@ -14443,7 +14381,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return types_1.UnknownType.create();
     }
-    function getTypeOfMemberInternal(node, member, selfClass) {
+    function getTypeOfMemberInternal(member, selfClass) {
         if ((0, types_1.isInstantiableClass)(member.classType)) {
             const typeResult = getEffectiveTypeOfSymbolForUsage(member.symbol);
             if (typeResult) {
@@ -14631,7 +14569,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));
@@ -15191,7 +15129,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
             }
-            const concreteSrcType = makeTopLevelTypeVarsConcrete(srcType);
+            let concreteSrcType = makeTopLevelTypeVarsConcrete(srcType);
             if ((0, types_1.isClass)(concreteSrcType) && types_1.TypeBase.isInstance(concreteSrcType)) {
                 if (destType.literalValue !== undefined) {
                     const srcLiteral = concreteSrcType.literalValue;
@@ -15204,15 +15142,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
                 // Handle LiteralString special form.
-                if (types_1.ClassType.isBuiltIn(destType, 'LiteralString') && types_1.ClassType.isBuiltIn(concreteSrcType, 'str')) {
-                    if (concreteSrcType.literalValue !== undefined) {
+                if (types_1.ClassType.isBuiltIn(destType, 'LiteralString')) {
+                    if (types_1.ClassType.isBuiltIn(concreteSrcType, 'str') && concreteSrcType.literalValue !== undefined) {
+                        return true;
+                    }
+                    else if (types_1.ClassType.isBuiltIn(concreteSrcType, 'LiteralString')) {
                         return true;
                     }
                 }
                 else if (types_1.ClassType.isBuiltIn(concreteSrcType, 'LiteralString') &&
-                    types_1.ClassType.isBuiltIn(destType, 'str') &&
-                    destType.literalValue === undefined) {
-                    return true;
+                    strClassType &&
+                    (0, types_1.isInstantiableClass)(strClassType)) {
+                    concreteSrcType = types_1.ClassType.cloneAsInstance(strClassType);
                 }
                 if (!assignClass(types_1.ClassType.cloneAsInstantiable(destType), types_1.ClassType.cloneAsInstantiable(concreteSrcType), diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount, 
                 /* reportErrorsUsingObjType */ true)) {
@@ -15600,7 +15541,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 ||
@@ -16937,9 +16878,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (firstParamType && memberType.details.parameters.length > 0) {
             const memberTypeFirstParam = memberType.details.parameters[0];
             const memberTypeFirstParamType = types_1.FunctionType.getEffectiveParameterType(memberType, 0);
-            // If the type has a literal associated with it, strip it now. This
-            // is needed to handle generic functions in the enum.Flag class.
-            const nonLiteralFirstParamType = (0, typeUtils_1.stripLiteralValue)(firstParamType);
             // Fill out the typeVarContext for the "self" or "cls" parameter.
             typeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(memberType));
             const diag = new diagnostic_1.DiagnosticAddendum();
@@ -16953,11 +16891,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // Instead, we'll assume it's assignable.
                 if (!typeVarContext.isLocked()) {
                     typeVarContext.setTypeVarType(memberTypeFirstParamType, types_1.TypeBase.isInstantiable(memberTypeFirstParamType)
-                        ? (0, typeUtils_1.convertToInstance)(nonLiteralFirstParamType)
-                        : nonLiteralFirstParamType);
+                        ? (0, typeUtils_1.convertToInstance)(firstParamType)
+                        : firstParamType);
                 }
             }
-            else if (!assignType(memberTypeFirstParamType, nonLiteralFirstParamType, diag, typeVarContext, 
+            else if (!assignType(memberTypeFirstParamType, firstParamType, diag, typeVarContext, 
             /* srcTypeVarContext */ undefined, 0 /* Default */, recursionCount)) {
                 if (memberTypeFirstParam.name &&
                     !memberTypeFirstParam.isNameSynthesized &&
@@ -17062,6 +17000,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         evaluateTypeOfParameter,
         canBeTruthy,
         canBeFalsy,
+        stripLiteralValue,
         removeTruthinessFromType,
         removeFalsinessFromType,
         verifyRaiseExceptionType,