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

package/dist/analyzer/typeEvaluator.js

@@ -180,7 +180,11 @@ const maxReturnTypeInferenceArgumentCount = 6;
 // we will analyze to determine the return type of a function
 // when its parameters are unannotated? We want to keep this
 // pretty low because this can be very costly.
-const maxReturnTypeInferenceCodeFlowComplexity = 8;
+const maxReturnTypeInferenceCodeFlowComplexity = 32;
+// What is the max complexity of the code flow graph for
+// call-site type inference? This is very expensive, so we
+// want to keep this very low.
+const maxReturnCallSiteTypeInferenceCodeFlowComplexity = 8;
 // What is the max number of return types cached per function
 // when using call-site inference?
 const maxCallSiteReturnTypeCacheSize = 8;
@@ -695,6 +699,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         /* allowSpeculativeCaching */ true);
         if (expectedType && !(0, types_1.isAnyOrUnknown)(expectedType) && !(0, types_1.isNever)(expectedType)) {
             expectedTypeCache.set(node.id, expectedType);
+            if (!typeResult.isIncomplete && !typeResult.expectedTypeDiagAddendum) {
+                const diag = new diagnostic_1.DiagnosticAddendum();
+                if (!assignType(expectedType, typeResult.type, diag)) {
+                    typeResult.expectedTypeDiagAddendum = diag;
+                    diag.addTextRange(node);
+                }
+            }
         }
         if (printExpressionTypes) {
             printExpressionSpaceCount--;
@@ -1884,11 +1895,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 +1928,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 +1966,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;
             }
@@ -3145,7 +3157,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();
@@ -3415,7 +3427,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
@@ -3436,7 +3448,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;
                 }
             }
@@ -3852,7 +3864,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
                 if (enforceTargetType) {
-                    let effectiveType = concreteSubtype;
+                    let effectiveType = subtype;
                     // If the code is patching a method (defined on the class)
                     // with an object-level function, strip the "self" parameter
                     // off the original type. This is sometimes done for test
@@ -4731,19 +4743,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             });
             effectiveExpectedType = matchingSubtype;
         }
+        let expectedTypeDiagAddendum;
         if (effectiveExpectedType) {
             const result = getTypeOfTupleExpected(node, effectiveExpectedType);
-            if (result) {
+            if (result && !result.typeErrors) {
                 return result;
             }
+            expectedTypeDiagAddendum = result === null || result === void 0 ? void 0 : result.expectedTypeDiagAddendum;
         }
-        const resultType = getTypeOfTupleInferred(node);
+        const typeResult = getTypeOfTupleInferred(node);
         // If there was an expected type of Any, replace the resulting type
         // with Any rather than return a type with unknowns.
         if (expectedTypeContainsAny) {
-            resultType.type = types_1.AnyType.create();
+            typeResult.type = types_1.AnyType.create();
         }
-        return resultType;
+        return { ...typeResult, expectedTypeDiagAddendum };
     }
     function getTypeOfTupleExpected(node, expectedType) {
         expectedType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(expectedType);
@@ -4787,7 +4801,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         /* flags */ undefined, index < expectedTypes.length ? expectedTypes[index] : undefined));
         const type = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, buildTupleTypesList(entryTypeResults), 
         /* isTypeArgumentExplicit */ true));
-        return { type };
+        // Copy any expected type diag addenda for precision error reporting.
+        let expectedTypeDiagAddendum;
+        if (entryTypeResults.some((result) => result.expectedTypeDiagAddendum)) {
+            expectedTypeDiagAddendum = new diagnostic_1.DiagnosticAddendum();
+            entryTypeResults.forEach((result) => {
+                if (result.expectedTypeDiagAddendum) {
+                    expectedTypeDiagAddendum.addAddendum(result.expectedTypeDiagAddendum);
+                }
+            });
+        }
+        return { type, expectedTypeDiagAddendum };
     }
     function getTypeOfTupleInferred(node) {
         const entryTypeResults = node.expressions.map((expr) => getTypeOfExpression(expr));
@@ -5810,8 +5834,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         // the call is a constructor but the proper TypeVar scope has been lost.
                         // We'll add a wildcard TypeVar scope here. This is a bit of a hack and
                         // we may need to revisit this in the future.
-                        if (!effectiveTypeVarContext.getSolveForScopes() &&
-                            types_1.FunctionType.isConstructorMethod(expandedSubtype)) {
+                        if (types_1.FunctionType.isConstructorMethod(expandedSubtype)) {
                             effectiveTypeVarContext.addSolveForScope(types_1.WildcardTypeVarScopeId);
                         }
                     }
@@ -6802,12 +6825,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // types of each argument expression and validates that the resulting type is
     // compatible with the declared type of the corresponding parameter.
     function validateFunctionArgumentTypesWithExpectedType(errorNode, matchResults, typeVarContext, skipUnknownArgCheck = false, expectedType) {
+        var _a;
         const type = matchResults.overload;
         if (!expectedType ||
             (0, types_1.isAnyOrUnknown)(expectedType) ||
             (0, types_1.isNever)(expectedType) ||
             (0, typeUtils_1.requiresSpecialization)(expectedType) ||
-            !type.details.declaredReturnType) {
+            !type.details.declaredReturnType ||
+            !(0, typeUtils_1.requiresSpecialization)((_a = types_1.FunctionType.getSpecializedReturnType(type)) !== null && _a !== void 0 ? _a : types_1.UnknownType.create())) {
             return validateFunctionArgumentTypes(errorNode, matchResults, typeVarContext, skipUnknownArgCheck);
         }
         const effectiveReturnType = getFunctionEffectiveReturnType(type);
@@ -7207,6 +7232,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;
@@ -7380,7 +7406,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 };
         }
@@ -8435,7 +8461,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,
@@ -8469,8 +8498,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;
@@ -8484,17 +8514,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
@@ -8556,8 +8587,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;
             }
@@ -8578,8 +8609,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         /* allowNarrowed */ true);
                         tdEntries.forEach((entry, name) => {
                             if (entry.isRequired || entry.isProvided) {
-                                keyTypes.push(types_1.ClassType.cloneWithLiteral(strObject, name));
-                                valueTypes.push(entry.valueType);
+                                keyTypes.push({ node: entryNode, type: types_1.ClassType.cloneWithLiteral(strObject, name) });
+                                valueTypes.push({ node: entryNode, type: entry.valueType });
                             }
                         });
                         addUnknown = false;
@@ -8604,8 +8635,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;
                             }
@@ -8628,8 +8659,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;
                     }
@@ -8637,8 +8668,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() });
                 }
             }
         });
@@ -8662,13 +8693,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             });
             effectiveExpectedType = matchingSubtype;
         }
+        let expectedTypeDiagAddendum;
         if (effectiveExpectedType) {
             const result = getTypeOfListOrSetExpected(node, effectiveExpectedType);
-            if (result) {
+            if (result && !result.typeErrors) {
                 return result;
             }
+            expectedTypeDiagAddendum = result === null || result === void 0 ? void 0 : result.expectedTypeDiagAddendum;
         }
-        return getTypeOfListOrSetInferred(node, /* hasExpectedType */ expectedType !== undefined);
+        const typeResult = getTypeOfListOrSetInferred(node, /* hasExpectedType */ expectedType !== undefined);
+        return { ...typeResult, expectedTypeDiagAddendum };
     }
     // Attempts to determine the type of a list or set statement based on an expected type.
     // Returns undefined if that type cannot be honored.
@@ -8694,6 +8728,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         const expectedEntryType = specializedListOrSet.typeArguments[0];
         const entryTypes = [];
+        const expectedTypeDiagAddendum = new diagnostic_1.DiagnosticAddendum();
         node.entries.forEach((entry) => {
             let entryTypeResult;
             if (entry.nodeType === 32 /* ListComprehension */) {
@@ -8709,15 +8744,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (entryTypeResult.typeErrors) {
                 typeErrors = true;
             }
+            if (entryTypeResult.expectedTypeDiagAddendum) {
+                expectedTypeDiagAddendum.addAddendum(entryTypeResult.expectedTypeDiagAddendum);
+            }
         });
         const isExpectedTypeListOrSet = (0, types_1.isClassInstance)(expectedType) && types_1.ClassType.isBuiltIn(expectedType, builtInClassName);
         const specializedEntryType = inferTypeArgFromExpectedType(expectedEntryType, entryTypes, 
         /* isNarrowable */ !isExpectedTypeListOrSet);
         if (!specializedEntryType) {
-            return undefined;
+            return { type: types_1.UnknownType.create(), isIncomplete, typeErrors: true, expectedTypeDiagAddendum };
         }
         const type = getBuiltInObject(node, builtInClassName, [specializedEntryType]);
-        return { type, isIncomplete, typeErrors };
+        return { type, isIncomplete, typeErrors, expectedTypeDiagAddendum };
     }
     // Attempts to infer the type of a list or set statement with no "expected type".
     function getTypeOfListOrSetInferred(node, hasExpectedType) {
@@ -10355,6 +10393,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         node.arguments.forEach((arg) => {
             // Ignore unpacked arguments.
             if (arg.argumentCategory !== 0 /* Simple */) {
+                // Evaluate the expression's type so symbols are marked accessed
+                // and errors are reported.
+                getTypeOfExpression(arg.valueExpression);
                 return;
             }
             if (!arg.name) {
@@ -10622,7 +10663,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (metaclassNode) {
             const metaclassType = getTypeOfExpression(metaclassNode, exprFlags).type;
             if ((0, types_1.isInstantiableClass)(metaclassType) || (0, types_1.isUnknown)(metaclassType)) {
-                if ((0, typeUtils_1.requiresSpecialization)(metaclassType)) {
+                if ((0, typeUtils_1.requiresSpecialization)(metaclassType, /* ignorePseudoGeneric */ true)) {
                     addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.metaclassIsGeneric(), metaclassNode);
                 }
                 classType.details.declaredMetaclass = metaclassType;
@@ -10688,25 +10729,29 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // See if there's already a non-synthesized __init__ method.
             // We shouldn't override it.
             if (!skipSynthesizedInit) {
-                const initSymbol = (0, typeUtils_1.lookUpClassMember)(classType, '__init__', 2 /* SkipBaseClasses */);
+                const initSymbol = (0, typeUtils_1.lookUpClassMember)(classType, '__init__', 4 /* SkipObjectBaseClass */);
                 if (initSymbol) {
-                    const initSymbolType = getTypeOfMember(initSymbol);
-                    if ((0, types_1.isFunction)(initSymbolType)) {
-                        if (!types_1.FunctionType.isSynthesizedMethod(initSymbolType)) {
+                    if (!(0, types_1.isClass)(initSymbol.classType) || !types_1.ClassType.isBuiltIn(initSymbol.classType, 'NamedTuple')) {
+                        const initSymbolType = getTypeOfMember(initSymbol);
+                        if ((0, types_1.isFunction)(initSymbolType)) {
+                            if (!types_1.FunctionType.isSynthesizedMethod(initSymbolType)) {
+                                hasExistingInitMethod = true;
+                            }
+                        }
+                        else {
                             hasExistingInitMethod = true;
                         }
                     }
-                    else {
-                        hasExistingInitMethod = true;
-                    }
                 }
             }
             let skipSynthesizeHash = false;
-            const hashSymbol = (0, typeUtils_1.lookUpClassMember)(classType, '__hash__', 2 /* SkipBaseClasses */);
+            const hashSymbol = (0, typeUtils_1.lookUpClassMember)(classType, '__hash__', 4 /* SkipObjectBaseClass */);
             if (hashSymbol) {
-                const hashSymbolType = getTypeOfMember(hashSymbol);
-                if ((0, types_1.isFunction)(hashSymbolType) && !types_1.FunctionType.isSynthesizedMethod(hashSymbolType)) {
-                    skipSynthesizeHash = true;
+                if (!(0, types_1.isClass)(hashSymbol.classType) || !types_1.ClassType.isBuiltIn(hashSymbol.classType, 'NamedTuple')) {
+                    const hashSymbolType = getTypeOfMember(hashSymbol);
+                    if ((0, types_1.isFunction)(hashSymbolType) && !types_1.FunctionType.isSynthesizedMethod(hashSymbolType)) {
+                        skipSynthesizeHash = true;
+                    }
                 }
             }
             (0, dataClasses_1.synthesizeDataClassMethods)(evaluatorInterface, node, classType, skipSynthesizedInit, hasExistingInitMethod, skipSynthesizeHash);
@@ -14276,7 +14321,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         const functionNode = type.details.declaration.node;
         const codeFlowComplexity = AnalyzerNodeInfo.getCodeFlowComplexity(functionNode);
-        if (codeFlowComplexity >= maxReturnTypeInferenceCodeFlowComplexity) {
+        if (codeFlowComplexity >= maxReturnCallSiteTypeInferenceCodeFlowComplexity) {
             return undefined;
         }
         // If an arg hasn't been matched to a specific named parameter,
@@ -14592,16 +14637,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If the source is unbounded, expand the unbounded argument to try
         // to make the source and dest arg counts match.
         if (srcUnboundedIndex >= 0) {
-            const requiredSrcArgCount = destVariadicIndex >= 0 || destUnboundedIndex >= 0 ? destTypeArgs.length - 1 : destTypeArgs.length;
             const typeToReplicate = srcTypeArgs.length > 0 ? srcTypeArgs[srcUnboundedIndex].type : types_1.AnyType.create();
-            while (srcTypeArgs.length < requiredSrcArgCount) {
-                srcTypeArgs.splice(srcUnboundedIndex, 0, { type: typeToReplicate, isUnbounded: false });
+            while (srcTypeArgs.length < destTypeArgs.length) {
+                srcTypeArgs.splice(srcUnboundedIndex, 0, { type: typeToReplicate, isUnbounded: true });
             }
         }
-        if (destVariadicIndex >= 0 && srcUnboundedIndex >= 0) {
-            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeVarTupleRequiresKnownLength());
-            return false;
-        }
         // If the dest is unbounded or contains a variadic, determine which
         // source args map to the unbounded or variadic arg.
         if (destUnboundedIndex >= 0 || destVariadicIndex >= 0) {
@@ -14614,7 +14654,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: stripLiteralValue(typeArg.type), isUnbounded: false };
+                            return { type: stripLiteralValue(typeArg.type), isUnbounded: typeArg.isUnbounded };
                         }), 
                         /* isTypeArgumentExplicit */ true, 
                         /* isUnpackedTuple */ true));
@@ -14672,13 +14712,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // specified inheritance chain, taking into account its type arguments.
     function assignClassWithTypeArgs(destType, srcType, inheritanceChain, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
         let curSrcType = srcType;
-        let curTypeVarContext = destTypeVarContext !== null && destTypeVarContext !== void 0 ? destTypeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(destType));
+        let curTypeVarContext = destTypeVarContext;
         let effectiveFlags = flags;
         inferTypeParameterVarianceForClass(destType);
-        // If we're using a private typeVarContext, don't skip solving type vars.
+        effectiveFlags |= 8 /* SkipSolveTypeVars */;
         if (!destTypeVarContext) {
+            curTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(destType));
             effectiveFlags &= ~8 /* SkipSolveTypeVars */;
         }
+        else {
+            // If we're using the caller's type var context, don't solve the
+            // type vars in this pass. We'll do this after we're done looping
+            // through the inheritance chain.
+            effectiveFlags |= 8 /* SkipSolveTypeVars */;
+        }
         for (let ancestorIndex = inheritanceChain.length - 1; ancestorIndex >= 0; ancestorIndex--) {
             const ancestorType = inheritanceChain[ancestorIndex];
             // If we've hit an "unknown", all bets are off, and we need to assume
@@ -14846,22 +14893,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, types_1.isUnion)(srcType) && srcType.subtypes.length === 1 && (0, types_1.isVariadicTypeVar)(srcType.subtypes[0])) {
             srcType = srcType.subtypes[0];
         }
-        if (destType === srcType) {
-            // If the dest type is a TypeVar and a typeVarContext was provided, we may
-            // need to assign the TypeVar to itself under certain circumstances.
-            // This is needed for cases where generic class A[T] calls its own
-            // constructor with an argument of type T.
-            if ((0, types_1.isTypeVar)(destType) &&
-                !destType.details.isParamSpec &&
-                !destType.details.isVariadic &&
-                destType.scopeType === 0 /* Class */ &&
-                destTypeVarContext &&
-                !destTypeVarContext.isLocked() &&
-                destTypeVarContext.hasSolveForScope(destType.scopeId) &&
-                !destTypeVarContext.getTypeVar(destType) &&
-                (flags & (8 /* SkipSolveTypeVars */ | 2 /* ReverseTypeVarMatching */)) === 0) {
-                destTypeVarContext.setTypeVarType(destType, srcType);
-            }
+        // Handle the case where the dest and src types are the same object.
+        // We can normally shortcut this and say that they are compatible,
+        // but if the type includes TypeVars, we need to go through
+        // the rest of the logic.
+        if (destType === srcType && !(0, typeUtils_1.requiresSpecialization)(destType)) {
             return true;
         }
         if (recursionCount > types_1.maxTypeRecursionCount) {
@@ -14917,13 +14953,26 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Before performing any other checks, see if the dest type is a
         // TypeVar that we are attempting to match.
         if ((0, types_1.isTypeVar)(destType)) {
+            if ((0, types_1.isTypeSame)(destType, srcType)) {
+                if (destType.scopeId && (destTypeVarContext === null || destTypeVarContext === void 0 ? void 0 : destTypeVarContext.hasSolveForScope(destType.scopeId))) {
+                    return (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, destType, srcType, diag, destTypeVarContext, flags, recursionCount);
+                }
+                return true;
+            }
             // If the dest is a constrained or bound type variable and all of the
             // types in the source are conditioned on that same type variable
             // and have compatible types, we'll consider it assignable.
             if (assignConditionalTypeToTypeVar(destType, srcType, recursionCount)) {
                 return true;
             }
-            if ((0, types_1.isTypeSame)(destType, srcType)) {
+            // If the source is a conditional type associated with a bound TypeVar
+            // and the bound TypeVar matches the condition, the types are compatible.
+            const destTypeVar = destType;
+            if (types_1.TypeBase.isInstantiable(destType) === types_1.TypeBase.isInstantiable(srcType) &&
+                srcType.condition &&
+                srcType.condition.some((cond) => {
+                    return !cond.isConstrainedTypeVar && cond.typeVarName === destTypeVar.nameWithScope;
+                })) {
                 return true;
             }
             if ((0, types_1.isUnion)(srcType)) {
@@ -15445,7 +15494,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // For union sources, all of the types need to be assignable to the dest.
         let isIncompatible = false;
         // Sort the subtypes so we have a deterministic order for unions.
-        (0, typeUtils_1.doForEachSubtype)(srcType, (subtype, subtypeIndex) => {
+        (0, typeUtils_1.doForEachSubtype)(srcType, (subtype, subtypeIndex, allSubtypes) => {
             if (isIncompatible) {
                 return;
             }
@@ -15455,7 +15504,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // Determine if the current subtype is subsumed by another subtype
                 // in the same union. If so, we can ignore this.
                 let isSubtypeSubsumed = false;
-                (0, typeUtils_1.doForEachSubtype)(srcType, (innerSubtype, innerSubtypeIndex) => {
+                allSubtypes.forEach((innerSubtype, innerSubtypeIndex) => {
                     if (isSubtypeSubsumed || subtypeIndex === innerSubtypeIndex || (0, types_1.isAnyOrUnknown)(innerSubtype)) {
                         return;
                     }
@@ -15796,7 +15845,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let specializedDestType = destType;
         let reverseMatchingFailed = false;
         if ((flags & 2 /* ReverseTypeVarMatching */) === 0) {
-            specializedDestType = (0, typeUtils_1.applySolvedTypeVars)(destType, destTypeVarContext);
+            specializedDestType = (0, typeUtils_1.applySolvedTypeVars)(destType, destTypeVarContext, 
+            /* unknownIfNotFound */ undefined, 
+            /* useNarrowBoundOnly */ true);
             if ((0, typeUtils_1.requiresSpecialization)(specializedDestType)) {
                 reverseMatchingFailed = !assignType(specializedSrcType, specializedDestType, 
                 /* diag */ undefined, srcTypeVarContext, destTypeVarContext, (flags ^ 2 /* ReverseTypeVarMatching */) |
@@ -15806,7 +15857,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         else {
-            specializedSrcType = (0, typeUtils_1.applySolvedTypeVars)(srcType, srcTypeVarContext);
+            specializedSrcType = (0, typeUtils_1.applySolvedTypeVars)(srcType, srcTypeVarContext, 
+            /* unknownIfNotFound */ undefined, 
+            /* useNarrowBoundOnly */ true);
             if ((0, typeUtils_1.requiresSpecialization)(specializedSrcType)) {
                 reverseMatchingFailed = !assignType(specializedSrcType, specializedDestType, 
                 /* diag */ undefined, srcTypeVarContext, destTypeVarContext, (flags ^ 2 /* ReverseTypeVarMatching */) |