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

package/dist/analyzer/typeEvaluator.js

@@ -218,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();
@@ -265,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();
@@ -1884,11 +1884,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return (suppressedNodeStack.some((suppressedNode) => ParseTreeUtils.isNodeContainedWithin(node, suppressedNode)) ||
             speculativeTypeTracker.isSpeculative(node));
     }
-    function addDiagnostic(diagLevel, rule, message, node) {
+    function addDiagnostic(diagLevel, rule, message, node, range) {
         if (diagLevel === 'none') {
             return undefined;
         }
-        const diagnostic = addDiagnosticWithSuppressionCheck(diagLevel, message, node);
+        const diagnostic = addDiagnosticWithSuppressionCheck(diagLevel, message, node, range);
         if (diagnostic) {
             diagnostic.setRule(rule);
         }
@@ -1917,6 +1917,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeExpectedClass().format({ type: printType(type) }) + diag.getString(), node);
     }
     function assignTypeToNameNode(nameNode, type, isTypeIncomplete, ignoreEmptyContainers, srcExpression, allowAssignmentToFinalVar = false, expectedTypeDiagAddendum) {
+        var _a, _b;
         const nameValue = nameNode.value;
         const symbolWithScope = lookUpSymbolRecursive(nameNode, nameValue, /* honorCodeFlow */ false);
         if (!symbolWithScope) {
@@ -1954,7 +1955,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAssignmentMismatch().format({
                     sourceType: printType(type),
                     destType: printType(declaredType),
-                }) + diagAddendum.getString(), srcExpression !== null && srcExpression !== void 0 ? srcExpression : nameNode);
+                }) + diagAddendum.getString(), srcExpression !== null && srcExpression !== void 0 ? srcExpression : nameNode, (_b = (_a = diagAddendum.getEffectiveTextRange()) !== null && _a !== void 0 ? _a : srcExpression) !== null && _b !== void 0 ? _b : nameNode);
                 // Replace the assigned type with the (unnarrowed) declared type.
                 destType = declaredType;
             }
@@ -2856,7 +2857,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) {
@@ -3145,7 +3146,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return typeResult;
     }
     function getTypeOfMemberAccessWithBaseType(node, baseTypeResult, usage, flags) {
-        var _a;
+        var _a, _b;
         let baseType = baseTypeResult.type;
         const memberName = node.memberName.value;
         let diag = new diagnostic_1.DiagnosticAddendum();
@@ -3239,12 +3240,6 @@ 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.
                     const enumMemberResult = (0, enums_1.getTypeOfEnumMember)(evaluatorInterface, node, baseType, memberName, isIncomplete);
                     if (enumMemberResult) {
@@ -3421,7 +3416,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const [ruleSet, rule] = isFunctionRule
                     ? [fileInfo.diagnosticRuleSet.reportFunctionMemberAccess, diagnosticRules_1.DiagnosticRule.reportFunctionMemberAccess]
                     : [fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues];
-                addDiagnostic(ruleSet, rule, diagMessage.format({ name: memberName, type: printType(baseType) }) + diag.getString(), node.memberName);
+                addDiagnostic(ruleSet, rule, diagMessage.format({ name: memberName, type: printType(baseType) }) + diag.getString(), node.memberName, (_a = diag.getEffectiveTextRange()) !== null && _a !== void 0 ? _a : node.memberName);
             }
             // If this is member access on a function, use "Any" so if the
             // reportFunctionMemberAccess rule is disabled, we don't trigger
@@ -3442,7 +3437,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // It can also come up in cases like "isinstance(x, (list, dict))".
             if ((0, types_1.isInstantiableClass)(type)) {
                 const argNode = ParseTreeUtils.getParentNodeOfType(node, 1 /* Argument */);
-                if (argNode && ((_a = argNode === null || argNode === void 0 ? void 0 : argNode.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 9 /* Call */) {
+                if (argNode && ((_b = argNode === null || argNode === void 0 ? void 0 : argNode.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 9 /* Call */) {
                     skipPartialUnknownCheck = true;
                 }
             }
@@ -4951,7 +4946,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),
@@ -5442,7 +5437,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++;
@@ -5855,8 +5854,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);
@@ -6891,7 +6891,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);
                         }
                     }
@@ -7208,6 +7208,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return !reportedArgError;
     }
     function validateArgType(argParam, typeVarContext, functionType, skipUnknownCheck, skipOverloadArg, useNarrowBoundOnly, conditionFilter) {
+        var _a;
         let argType;
         let expectedTypeDiag;
         let isTypeIncomplete = false;
@@ -7381,7 +7382,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (expectedTypeDiag) {
                     diag = expectedTypeDiag;
                 }
-                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message + diag.getString(), argParam.errorNode);
+                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message + diag.getString(), argParam.errorNode, (_a = diag.getEffectiveTextRange()) !== null && _a !== void 0 ? _a : argParam.errorNode);
             }
             return { isCompatible: false, argType, isTypeIncomplete, condition };
         }
@@ -7677,7 +7678,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 {
@@ -8349,12 +8352,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);
             }
@@ -8440,7 +8437,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 isIncomplete = true;
             }
             if (types_1.ClassType.isTypedDictClass(expectedType)) {
-                const resultTypedDict = (0, typedDicts_1.assignToTypedDict)(evaluatorInterface, expectedType, keyTypes, valueTypes, expectedDiagAddendum);
+                const resultTypedDict = (0, typedDicts_1.assignToTypedDict)(evaluatorInterface, expectedType, keyTypes, valueTypes, 
+                // Don't overwrite existing expectedDiagAddendum messages if they were
+                // already provided by getKeyValueTypesFromDictionary.
+                (expectedDiagAddendum === null || expectedDiagAddendum === void 0 ? void 0 : expectedDiagAddendum.isEmpty()) ? expectedDiagAddendum : undefined);
                 if (resultTypedDict) {
                     return {
                         type: resultTypedDict,
@@ -8474,8 +8474,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // and Iterable use covariant value types, so they can be narrowed.
         const isValueTypeInvariant = (0, types_1.isClassInstance)(expectedType) &&
             (types_1.ClassType.isBuiltIn(expectedType, 'dict') || types_1.ClassType.isBuiltIn(expectedType, 'MutableMapping'));
-        const specializedKeyType = inferTypeArgFromExpectedType(expectedKeyType, keyTypes, /* isNarrowable */ false);
-        const specializedValueType = inferTypeArgFromExpectedType(expectedValueType, valueTypes, 
+        const specializedKeyType = inferTypeArgFromExpectedType(expectedKeyType, keyTypes.map((result) => result.type), 
+        /* isNarrowable */ false);
+        const specializedValueType = inferTypeArgFromExpectedType(expectedValueType, valueTypes.map((result) => result.type), 
         /* isNarrowable */ !isValueTypeInvariant);
         if (!specializedKeyType || !specializedValueType) {
             return undefined;
@@ -8489,17 +8490,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const fallbackType = hasExpectedType ? types_1.AnyType.create() : types_1.UnknownType.create();
         let keyType = fallbackType;
         let valueType = fallbackType;
-        let keyTypes = [];
-        let valueTypes = [];
+        const keyTypeResults = [];
+        const valueTypeResults = [];
         let isEmptyContainer = false;
         let isIncomplete = false;
         // Infer the key and value types if possible.
-        if (getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, /* forceStrictInference */ hasExpectedType)) {
+        if (getKeyAndValueTypesFromDictionary(node, keyTypeResults, valueTypeResults, 
+        /* forceStrictInference */ hasExpectedType)) {
             isIncomplete = true;
         }
         // Strip any literal values.
-        keyTypes = keyTypes.map((t) => stripLiteralValue(t));
-        valueTypes = valueTypes.map((t) => stripLiteralValue(t));
+        const keyTypes = keyTypeResults.map((t) => stripLiteralValue(t.type));
+        const valueTypes = valueTypeResults.map((t) => stripLiteralValue(t.type));
         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
@@ -8511,7 +8513,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 {
@@ -8561,8 +8563,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     isIncomplete = true;
                 }
                 if (forceStrictInference || index < maxEntriesToUseForInference) {
-                    keyTypes.push(keyType);
-                    valueTypes.push(valueType);
+                    keyTypes.push({ node: entryNode.keyExpression, type: keyType });
+                    valueTypes.push({ node: entryNode.valueExpression, type: valueType });
                 }
                 addUnknown = false;
             }
@@ -8575,6 +8577,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({ node: entryNode, type: types_1.ClassType.cloneWithLiteral(strObject, name) });
+                                valueTypes.push({ node: entryNode, type: 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
@@ -8594,8 +8611,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             const typeArgs = specializedMapping.typeArguments;
                             if (typeArgs && typeArgs.length >= 2) {
                                 if (forceStrictInference || index < maxEntriesToUseForInference) {
-                                    keyTypes.push(typeArgs[0]);
-                                    valueTypes.push(typeArgs[1]);
+                                    keyTypes.push({ node: entryNode, type: typeArgs[0] });
+                                    valueTypes.push({ node: entryNode, type: typeArgs[1] });
                                 }
                                 addUnknown = false;
                             }
@@ -8618,8 +8635,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     const typeArgs = (_a = dictEntryType.tupleTypeArguments) === null || _a === void 0 ? void 0 : _a.map((t) => t.type);
                     if (typeArgs && typeArgs.length === 2) {
                         if (forceStrictInference || index < maxEntriesToUseForInference) {
-                            keyTypes.push(typeArgs[0]);
-                            valueTypes.push(typeArgs[1]);
+                            keyTypes.push({ node: entryNode, type: typeArgs[0] });
+                            valueTypes.push({ node: entryNode, type: typeArgs[1] });
                         }
                         addUnknown = false;
                     }
@@ -8627,8 +8644,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             if (addUnknown) {
                 if (forceStrictInference || index < maxEntriesToUseForInference) {
-                    keyTypes.push(types_1.UnknownType.create());
-                    valueTypes.push(types_1.UnknownType.create());
+                    keyTypes.push({ node: entryNode, type: types_1.UnknownType.create() });
+                    valueTypes.push({ node: entryNode, type: types_1.UnknownType.create() });
                 }
             }
         });
@@ -8666,6 +8683,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;
         }
@@ -8695,6 +8713,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, 
@@ -8703,13 +8724,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;
@@ -8723,6 +8745,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (entryTypeResult.isIncomplete) {
                 isIncomplete = true;
             }
+            if (entryTypeResult.typeErrors) {
+                typeErrors = true;
+            }
             if (index < maxEntriesToUseForInference) {
                 entryTypes.push(entryTypeResult.type);
             }
@@ -8740,7 +8765,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;
             }
@@ -8755,7 +8780,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;
@@ -8803,12 +8828,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);
@@ -8816,8 +8845,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;
@@ -8993,10 +9025,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) ||
@@ -9022,7 +9058,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.
@@ -9079,6 +9115,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)) {
@@ -9093,6 +9130,9 @@ 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 = stripLiteralValue(keyType);
@@ -9102,6 +9142,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (valueTypeResult.isIncomplete) {
                 isIncomplete = true;
             }
+            if (valueTypeResult.typeErrors) {
+                typeErrors = true;
+            }
             let valueType = valueTypeResult.type;
             if (!expectedValueOrElementType || !(0, typeUtils_1.containsLiteralType)(expectedValueOrElementType)) {
                 valueType = stripLiteralValue(valueType);
@@ -9118,9 +9161,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
@@ -9972,6 +10018,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;
         }
@@ -11810,7 +11862,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             isIncomplete = true;
         }
         else {
-            functionRecursionMap.set(node.id, true);
+            functionRecursionMap.add(node.id);
             try {
                 let functionDecl;
                 const decl = AnalyzerNodeInfo.getDeclaration(node);
@@ -14906,9 +14958,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;
                 }
             }
@@ -15306,9 +15356,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
@@ -15337,9 +15385,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);
                     }
@@ -15351,11 +15397,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;
@@ -15586,9 +15642,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);
@@ -16264,9 +16318,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;
                     }
@@ -16664,9 +16716,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);
@@ -17005,6 +17055,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         removeFalsinessFromType,
         verifyRaiseExceptionType,
         verifyDeleteExpression,
+        validateOverloadedFunctionArguments,
         isAfterNodeReachable,
         isNodeReachable,
         isAsymmetricDescriptorAssignment,