@zzzen/pyright-internal 1.2.0-dev.20230122 → 1.2.0-dev.20230205

package/dist/analyzer/typeEvaluator.js

@@ -205,6 +205,10 @@ const maxOverloadUnionExpansionCount = 64;
 // Maximum number of recursive function return type inference attempts
 // that can be concurrently pending before we give up.
 const maxInferFunctionReturnRecursionCount = 12;
+// In certain loops, it's possible to construct arbitrarily-deep containers
+// (tuples, lists, sets, or dicts) which can lead to infinite type analysis.
+// This limits the depth.
+const maxInferredContainerDepth = 8;
 // Maximum recursion amount when comparing two recursive type aliases.
 // Increasing this can greatly increase the time required to evaluate
 // two recursive type aliases that have the same definition. Decreasing
@@ -250,6 +254,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     let dictClassType;
     let typedDictClassType;
     let printExpressionSpaceCount = 0;
+    let incompleteGenerationCount = 0;
     const returnTypeInferenceContextStack = [];
     let returnTypeInferenceTypeCache;
     function runWithCancellationToken(token, callback) {
@@ -329,14 +334,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const typeCacheToUse = returnTypeInferenceTypeCache && isNodeInReturnTypeInferenceContext(node)
             ? returnTypeInferenceTypeCache
             : typeCache;
-        typeCacheToUse.set(node.id, { typeResult, flags });
+        if (!typeResult.isIncomplete) {
+            incompleteGenerationCount++;
+        }
+        else {
+            const oldValue = typeCacheToUse.get(node.id);
+            if (oldValue !== undefined && !(0, types_1.isTypeSame)(typeResult.type, oldValue.typeResult.type)) {
+                incompleteGenerationCount++;
+            }
+        }
+        typeCacheToUse.set(node.id, { typeResult, flags, incompleteGenerationCount: incompleteGenerationCount });
         // If the entry is located within a part of the parse tree that is currently being
         // "speculatively" evaluated, track it so we delete the cached entry when we leave
         // this speculative context.
         if (speculativeTypeTracker.isSpeculative(node)) {
             speculativeTypeTracker.trackEntry(typeCacheToUse, node.id);
-            if (allowSpeculativeCaching && !typeResult.isIncomplete) {
-                speculativeTypeTracker.addSpeculativeType(node, typeResult, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType);
+            if (allowSpeculativeCaching) {
+                speculativeTypeTracker.addSpeculativeType(node, typeResult, incompleteGenerationCount, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType);
             }
         }
     }
@@ -490,7 +504,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         var _a, _b;
         // Is this type already cached?
         const cacheEntry = readTypeCacheEntry(node);
-        if (cacheEntry && !cacheEntry.typeResult.isIncomplete) {
+        if (cacheEntry &&
+            (!cacheEntry.typeResult.isIncomplete || cacheEntry.incompleteGenerationCount === incompleteGenerationCount)) {
             if (printExpressionTypes) {
                 console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Cached ${printType(cacheEntry.typeResult.type)} ${cacheEntry.typeResult.typeErrors ? ' Errors' : ''}`);
             }
@@ -498,12 +513,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         else {
             // Is it cached in the speculative type cache?
-            const cachedTypeResult = speculativeTypeTracker.getSpeculativeType(node, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType);
-            if (cachedTypeResult) {
+            const cacheEntry = speculativeTypeTracker.getSpeculativeType(node, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType);
+            if (cacheEntry &&
+                (!cacheEntry.typeResult.isIncomplete ||
+                    cacheEntry.incompleteGenerationCount === incompleteGenerationCount)) {
                 if (printExpressionTypes) {
-                    console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Speculative ${printType(cachedTypeResult.type)}`);
+                    console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Speculative ${printType(cacheEntry.typeResult.type)}`);
                 }
-                return cachedTypeResult;
+                return cacheEntry.typeResult;
             }
         }
         if (printExpressionTypes) {
@@ -610,16 +627,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             case 3 /* Assignment */: {
                 typeResult = getTypeOfExpression(node.rightExpression);
-                assignTypeToExpression(node.leftExpression, typeResult.type, 
-                /* isTypeIncomplete */ false, node.rightExpression, 
+                assignTypeToExpression(node.leftExpression, typeResult.type, !!typeResult.isIncomplete, node.rightExpression, 
                 /* ignoreEmptyContainers */ true, 
                 /* allowAssignmentToFinalVar */ true);
                 break;
             }
             case 4 /* AssignmentExpression */: {
                 typeResult = getTypeOfExpression(node.rightExpression);
-                assignTypeToExpression(node.name, typeResult.type, 
-                /* isTypeIncomplete */ false, node.rightExpression, 
+                assignTypeToExpression(node.name, typeResult.type, !!typeResult.isIncomplete, node.rightExpression, 
                 /* ignoreEmptyContainers */ true);
                 break;
             }
@@ -1214,6 +1229,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (types_1.ClassType.isBuiltIn(concreteSubtype, 'bool')) {
                     return types_1.ClassType.cloneWithLiteral(concreteSubtype, /* value */ false);
                 }
+                // If the object is an int, str or bytes, narrow to a literal type.
+                // This is slightly unsafe in that someone could subclass `int`, `str`
+                // or `bytes` and override the `__bool__` method to change its behavior,
+                // but this is extremely unlikely (and ill advised).
+                if (types_1.ClassType.isBuiltIn(concreteSubtype, 'int')) {
+                    return types_1.ClassType.cloneWithLiteral(concreteSubtype, /* value */ 0);
+                }
+                else if (types_1.ClassType.isBuiltIn(concreteSubtype, ['str', 'bytes'])) {
+                    return types_1.ClassType.cloneWithLiteral(concreteSubtype, /* value */ '');
+                }
             }
             // If it's possible for the type to be falsy, include it.
             if (canBeFalsy(subtype)) {
@@ -1385,7 +1410,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         function addOneFunctionToSignature(type) {
             let callResult;
             useSpeculativeMode(callNode, () => {
-                callResult = validateFunctionArguments(exprNode, argList, type, new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(type)), 
+                callResult = validateFunctionArguments(exprNode, argList, { type }, new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(type)), 
                 /* skipUnknownArgCheck */ true);
             });
             signatures.push({
@@ -2737,7 +2762,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (methodType) {
                 if ((0, types_1.isOverloadedFunction)(methodType)) {
                     if (errorNode) {
-                        const bestOverload = getBestOverloadForArguments(errorNode, methodType, argList);
+                        const bestOverload = getBestOverloadForArguments(errorNode, { type: methodType, isIncomplete: memberTypeResult.isIncomplete }, argList);
                         if (bestOverload) {
                             return getFunctionEffectiveReturnType(bestOverload);
                         }
@@ -2937,11 +2962,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // Handles the case where a variable or parameter is defined in an outer
     // scope and captured by an inner scope (either a function or a lambda).
     function getCodeFlowTypeForCapturedVariable(node, symbolWithScope, effectiveType) {
-        // This function applies only to variables and parameters, not to other
+        // This function applies only to variables, parameters, and imports, not to other
         // types of symbols.
         if (!symbolWithScope.symbol
             .getDeclarations()
-            .every((decl) => decl.type === 1 /* Variable */ || decl.type === 2 /* Parameter */)) {
+            .every((decl) => decl.type === 1 /* Variable */ ||
+            decl.type === 2 /* Parameter */ ||
+            decl.type === 8 /* Alias */)) {
             return undefined;
         }
         // If the symbol is a variable captured by an inner function
@@ -2968,6 +2995,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if (decl.type === 2 /* Parameter */) {
                             return true;
                         }
+                        // Assume alias declarations are also always safe to narrow.
+                        if (decl.type === 8 /* Alias */) {
+                            return true;
+                        }
                         const declCodeFlowNode = AnalyzerNodeInfo.getFlowNode(decl.node);
                         if (!declCodeFlowNode) {
                             return false;
@@ -3345,7 +3376,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const getTypeOfNoneBase = (subtype) => {
             if (noneType && (0, types_1.isInstantiableClass)(noneType)) {
                 if (types_1.TypeBase.isInstance(subtype)) {
-                    return getTypeOfObjectMember(node.memberName, noneType, memberName, usage, diag);
+                    return getTypeOfObjectMember(node.memberName, types_1.ClassType.cloneAsInstance(noneType), memberName, usage, diag);
                 }
                 else {
                     return getTypeOfClassMember(node.memberName, noneType, memberName, usage, diag);
@@ -5001,12 +5032,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return { type: types_1.UnknownType.create() };
         }
         const type = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, buildTupleTypesList(entryTypeResults)));
-        // In certain loops, it's possible to construct arbitrarily-deep tuples
-        // which can lead to infinite type analysis. Prevent this by detecting
-        // the condition.
         if (isIncomplete) {
-            const maxInferredTupleDepth = 8;
-            if ((0, typeUtils_1.getTupleDepth)(type) > maxInferredTupleDepth) {
+            if ((0, typeUtils_1.getContainerDepth)(type) > maxInferredContainerDepth) {
                 return { type: types_1.UnknownType.create() };
             }
         }
@@ -5412,17 +5439,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // (one for each argument) will be undefined. On subsequent calls, this
     // list will grow to include union expansions.
     function validateOverloadsWithExpandedTypes(errorNode, expandedArgTypes, argParamMatches, typeVarContext, skipUnknownArgCheck, inferenceContext) {
-        var _a;
+        var _a, _b;
         const returnTypes = [];
         const matchedOverloads = [];
         let isTypeIncomplete = false;
-        const overloadsUsedForCall = [];
+        let overloadsUsedForCall = [];
         let isDefinitiveMatchFound = false;
         for (let expandedTypesIndex = 0; expandedTypesIndex < expandedArgTypes.length; expandedTypesIndex++) {
             let matchedOverload;
             const argTypeOverride = expandedArgTypes[expandedTypesIndex];
             const hasArgTypeOverride = argTypeOverride.some((a) => a !== undefined);
-            const possibleMatchResults = [];
+            let possibleMatchResults = [];
             isDefinitiveMatchFound = false;
             for (let overloadIndex = 0; overloadIndex < argParamMatches.length; overloadIndex++) {
                 const overload = argParamMatches[overloadIndex].overload;
@@ -5459,13 +5486,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (!callResult.argumentErrors && callResult.returnType) {
                     overloadsUsedForCall.push(overload);
                     matchedOverload = overload;
-                    matchedOverloads.push({
+                    const matchedOverloadInfo = {
                         overload: matchedOverload,
                         matchResults,
                         typeVarContext: effectiveTypeVarContext,
-                    });
+                        returnType: callResult.returnType,
+                        argResults: (_b = callResult.argResults) !== null && _b !== void 0 ? _b : [],
+                    };
+                    matchedOverloads.push(matchedOverloadInfo);
                     if (callResult.isArgumentAnyOrUnknown) {
-                        possibleMatchResults.push(callResult.returnType);
+                        possibleMatchResults.push(matchedOverloadInfo);
                     }
                     else {
                         returnTypes.push(callResult.returnType);
@@ -5480,27 +5510,35 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Unknown, but include the "possible types" to allow for completion
             // suggestions.
             if (!isDefinitiveMatchFound) {
-                // Eliminate any return types that are subsumed by other return types.
-                let dedupedMatchResults = [];
-                possibleMatchResults.forEach((subtype) => {
-                    let isSubtypeSubsumed = false;
-                    for (let dedupedIndex = 0; dedupedIndex < dedupedMatchResults.length; dedupedIndex++) {
-                        if (assignType(dedupedMatchResults[dedupedIndex], subtype)) {
-                            isSubtypeSubsumed = true;
-                            break;
+                possibleMatchResults = filterOverloadMatchesForAnyArgs(possibleMatchResults);
+                // Did the filtering produce a single result? If so, we're done.
+                if (possibleMatchResults.length === 1) {
+                    overloadsUsedForCall = [possibleMatchResults[0].overload];
+                    returnTypes.push(possibleMatchResults[0].returnType);
+                }
+                else {
+                    // Eliminate any return types that are subsumed by other return types.
+                    let dedupedMatchResults = [];
+                    possibleMatchResults.forEach((result) => {
+                        let isSubtypeSubsumed = false;
+                        for (let dedupedIndex = 0; dedupedIndex < dedupedMatchResults.length; dedupedIndex++) {
+                            if (assignType(dedupedMatchResults[dedupedIndex], result.returnType)) {
+                                isSubtypeSubsumed = true;
+                                break;
+                            }
+                            else if (assignType(result.returnType, dedupedMatchResults[dedupedIndex])) {
+                                dedupedMatchResults[dedupedIndex] = types_1.NeverType.createNever();
+                                break;
+                            }
                         }
-                        else if (assignType(subtype, dedupedMatchResults[dedupedIndex])) {
-                            dedupedMatchResults[dedupedIndex] = types_1.NeverType.createNever();
-                            break;
+                        if (!isSubtypeSubsumed) {
+                            dedupedMatchResults.push(result.returnType);
                         }
-                    }
-                    if (!isSubtypeSubsumed) {
-                        dedupedMatchResults.push(subtype);
-                    }
-                });
-                dedupedMatchResults = dedupedMatchResults.filter((t) => !(0, types_1.isNever)(t));
-                const combinedTypes = (0, types_1.combineTypes)(dedupedMatchResults);
-                returnTypes.push(dedupedMatchResults.length > 1 ? types_1.UnknownType.createPossibleType(combinedTypes) : combinedTypes);
+                    });
+                    dedupedMatchResults = dedupedMatchResults.filter((t) => !(0, types_1.isNever)(t));
+                    const combinedTypes = (0, types_1.combineTypes)(dedupedMatchResults);
+                    returnTypes.push(dedupedMatchResults.length > 1 ? types_1.UnknownType.createPossibleType(combinedTypes) : combinedTypes);
+                }
             }
             if (!matchedOverload) {
                 return { argumentErrors: true, isTypeIncomplete, overloadsUsedForCall };
@@ -5531,13 +5569,41 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             overloadsUsedForCall,
         };
     }
-    function getBestOverloadForArguments(errorNode, type, argList) {
+    // This function determines whether multiple incompatible overloads match
+    // due to an Any or Unknown argument type.
+    function filterOverloadMatchesForAnyArgs(matches) {
+        if (matches.length < 2) {
+            return matches;
+        }
+        // If all of the return types match, select the first one.
+        if ((0, typeUtils_1.areTypesSame)(matches.map((match) => match.returnType), { treatAnySameAsUnknown: true })) {
+            return [matches[0]];
+        }
+        const firstArgResults = matches[0].argResults;
+        if (!firstArgResults) {
+            return matches;
+        }
+        for (let i = 0; i < firstArgResults.length; i++) {
+            // If the arg is Any or Unknown, see if the corresponding
+            // parameter types differ in any way.
+            if ((0, types_1.isAnyOrUnknown)(firstArgResults[i].argType)) {
+                const paramTypes = matches.map((match) => i < match.matchResults.argParams.length
+                    ? match.matchResults.argParams[i].paramType
+                    : types_1.UnknownType.create());
+                if (!(0, typeUtils_1.areTypesSame)(paramTypes, { treatAnySameAsUnknown: true })) {
+                    return matches;
+                }
+            }
+        }
+        return [matches[0]];
+    }
+    function getBestOverloadForArguments(errorNode, typeResult, argList) {
         let overloadIndex = 0;
         let matches = [];
         // Create a list of potential overload matches based on arguments.
-        types_1.OverloadedFunctionType.getOverloads(type).forEach((overload) => {
+        types_1.OverloadedFunctionType.getOverloads(typeResult.type).forEach((overload) => {
             useSpeculativeMode(errorNode, () => {
-                const matchResults = matchFunctionArgumentsToParameters(errorNode, argList, overload, overloadIndex);
+                const matchResults = matchFunctionArgumentsToParameters(errorNode, argList, { type: overload, isIncomplete: typeResult.isIncomplete }, overloadIndex);
                 if (!matchResults.argumentErrors) {
                     matches.push(matchResults);
                 }
@@ -5568,7 +5634,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return a.overloadIndex - b.overloadIndex;
         });
     }
-    function validateOverloadedFunctionArguments(errorNode, argList, type, typeVarContext, skipUnknownArgCheck, inferenceContext) {
+    function validateOverloadedFunctionArguments(errorNode, argList, typeResult, typeVarContext, skipUnknownArgCheck, inferenceContext) {
         let filteredMatchResults = [];
         let contextFreeArgTypes;
         // Start by evaluating the types of the arguments without any expected
@@ -5578,11 +5644,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // cache or record any diagnostics at this stage.
         useSpeculativeMode(errorNode, () => {
             let overloadIndex = 0;
-            types_1.OverloadedFunctionType.getOverloads(type).forEach((overload) => {
+            types_1.OverloadedFunctionType.getOverloads(typeResult.type).forEach((overload) => {
                 // Consider only the functions that have the @overload decorator,
                 // not the final function that omits the overload. This is the
                 // intended behavior according to PEP 484.
-                const matchResults = matchFunctionArgumentsToParameters(errorNode, argList, overload, overloadIndex);
+                const matchResults = matchFunctionArgumentsToParameters(errorNode, argList, { type: overload, isIncomplete: typeResult.isIncomplete }, overloadIndex);
                 if (!matchResults.argumentErrors) {
                     filteredMatchResults.push(matchResults);
                 }
@@ -5596,7 +5662,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Skip the error message if we're in speculative mode because it's very
             // expensive, and we're going to suppress the diagnostic anyway.
             if (!isDiagnosticSuppressedForNode(errorNode)) {
-                const functionName = type.overloads[0].details.name || '<anonymous function>';
+                const functionName = typeResult.type.overloads[0].details.name || '<anonymous function>';
                 const diagAddendum = new diagnostic_1.DiagnosticAddendum();
                 const argTypes = argList.map((t) => printType(getTypeOfArgument(t).type));
                 diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.argumentTypes().format({ types: argTypes.join(', ') }));
@@ -5624,7 +5690,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return evaluateUsingLastMatchingOverload(/* skipUnknownArgCheck */ false);
         }
         let expandedArgTypes = [argList.map((arg) => undefined)];
-        let isTypeIncomplete = false;
+        let isTypeIncomplete = !!typeResult.isIncomplete;
         while (true) {
             const callResult = validateOverloadsWithExpandedTypes(errorNode, expandedArgTypes, filteredMatchResults, typeVarContext, skipUnknownArgCheck, inferenceContext);
             if (callResult.isTypeIncomplete) {
@@ -6085,7 +6151,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             effectiveTypeVarContext.addSolveForScope(types_1.WildcardTypeVarScopeId);
                         }
                     }
-                    const functionResult = validateFunctionArguments(errorNode, argList, expandedSubtype, effectiveTypeVarContext, skipUnknownArgCheck, inferenceContext);
+                    const functionResult = validateFunctionArguments(errorNode, argList, { type: expandedSubtype, isIncomplete: callTypeResult.isIncomplete }, effectiveTypeVarContext, skipUnknownArgCheck, inferenceContext);
                     if (functionResult.isTypeIncomplete) {
                         isTypeIncomplete = true;
                     }
@@ -6134,7 +6200,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                         return (0, typeUtils_1.convertToInstance)(castToType);
                     }
-                    const functionResult = validateOverloadedFunctionArguments(errorNode, argList, expandedSubtype, typeVarContext, skipUnknownArgCheck, inferenceContext);
+                    const functionResult = validateOverloadedFunctionArguments(errorNode, argList, { type: expandedSubtype, isIncomplete: callTypeResult.isIncomplete }, typeVarContext, skipUnknownArgCheck, inferenceContext);
                     overloadsUsedForCall.push(...functionResult.overloadsUsedForCall);
                     if (functionResult.isTypeIncomplete) {
                         isTypeIncomplete = true;
@@ -6411,13 +6477,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // function. This matching is done based on positions and keywords. Type evaluation and
     // validation is left to the caller.
     // This logic is based on PEP 3102: https://www.python.org/dev/peps/pep-3102/
-    function matchFunctionArgumentsToParameters(errorNode, argList, type, overloadIndex) {
+    function matchFunctionArgumentsToParameters(errorNode, argList, typeResult, overloadIndex) {
         var _a, _b, _c, _d, _e;
-        const paramDetails = (0, typeUtils_1.getParameterListDetails)(type);
+        const paramDetails = (0, typeUtils_1.getParameterListDetails)(typeResult.type);
         let argIndex = 0;
         let matchedUnpackedListOfUnknownLength = false;
         let reportedArgError = false;
-        let isTypeIncomplete = false;
+        let isTypeIncomplete = !!typeResult.isIncomplete;
         let isVariadicTypeVarFullyMatched = false;
         // Expand any unpacked tuples in the arg list.
         argList = expandArgList(argList);
@@ -6457,8 +6523,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // Does this function define the param spec, or is it an inner
                 // function nested within another function that defines the param
                 // spec? We need to handle these two cases differently.
-                if (varArgListParam.type.scopeId === type.details.typeVarScopeId ||
-                    varArgListParam.type.scopeId === type.details.constructorTypeVarScopeId) {
+                if (varArgListParam.type.scopeId === typeResult.type.details.typeVarScopeId ||
+                    varArgListParam.type.scopeId === typeResult.type.details.constructorTypeVarScopeId) {
                     paramSpecArgList = [];
                     paramSpecTarget = types_1.TypeVarType.cloneForParamSpecAccess(varArgListParam.type, /* access */ undefined);
                 }
@@ -6516,7 +6582,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const remainingArgCount = positionalArgCount - argIndex;
             const remainingParamCount = positionParamLimitIndex - paramIndex - 1;
             if (paramIndex >= positionParamLimitIndex) {
-                if (!type.details.paramSpec) {
+                if (!typeResult.type.details.paramSpec) {
                     let tooManyPositionals = false;
                     if (foundUnpackedListArg && argList[argIndex].argumentCategory === 1 /* UnpackedList */) {
                         // If this is an unpacked iterable, we will conservatively assume that it
@@ -6562,7 +6628,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // with a ParamSpec and a Concatenate operator. PEP 612 indicates that
                 // all positional parameters specified in the Concatenate must be
                 // filled explicitly.
-                if (type.details.paramSpec && paramIndex < positionParamLimitIndex) {
+                if (typeResult.type.details.paramSpec && paramIndex < positionParamLimitIndex) {
                     addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, positionParamLimitIndex === 1
                         ? localize_1.Localizer.Diagnostic.argPositionalExpectedOne()
                         : localize_1.Localizer.Diagnostic.argPositionalExpectedCount().format({
@@ -6848,10 +6914,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     else if ((0, types_1.isParamSpec)(argType) && argType.paramSpecAccess === 'kwargs') {
                         unpackedDictionaryArgType = types_1.AnyType.create();
-                        if (type.details.paramSpec) {
+                        if (typeResult.type.details.paramSpec) {
                             validateArgTypeParams.push({
                                 paramCategory: 2 /* VarArgDictionary */,
-                                paramType: type.details.paramSpec,
+                                paramType: typeResult.type.details.paramSpec,
                                 requiresTypeVarMatching: false,
                                 argument: argList[argIndex],
                                 errorNode: argList[argIndex].valueExpression || errorNode,
@@ -6967,7 +7033,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     else if (argList[argIndex].argumentCategory === 1 /* UnpackedList */) {
                         // Handle the case where a *args: P.args is passed as an argument to
                         // a function that accepts a ParamSpec.
-                        if (type.details.paramSpec) {
+                        if (typeResult.type.details.paramSpec) {
                             const argTypeResult = getTypeOfArgument(argList[argIndex]);
                             const argType = argTypeResult.type;
                             if (argTypeResult.isIncomplete) {
@@ -6976,7 +7042,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             if ((0, types_1.isParamSpec)(argType) && argType.paramSpecAccess === 'args') {
                                 validateArgTypeParams.push({
                                     paramCategory: 1 /* VarArgList */,
-                                    paramType: type.details.paramSpec,
+                                    paramType: typeResult.type.details.paramSpec,
                                     requiresTypeVarMatching: false,
                                     argument: argList[argIndex],
                                     errorNode: argList[argIndex].valueExpression || errorNode,
@@ -7023,7 +7089,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // but have not yet received them. If we received a dictionary argument
             // (i.e. an arg starting with a "**"), we will assume that all parameters
             // are matched.
-            if (!unpackedDictionaryArgType && !types_1.FunctionType.isDefaultParameterCheckDisabled(type)) {
+            if (!unpackedDictionaryArgType && !types_1.FunctionType.isDefaultParameterCheckDisabled(typeResult.type)) {
                 const unassignedParams = [...paramMap.keys()].filter((name) => {
                     const entry = paramMap.get(name);
                     return !entry || entry.argsReceived < entry.argsNeeded;
@@ -7147,12 +7213,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             relevance--;
         }
         // Special-case the builtin isinstance and issubclass functions.
-        if (['isinstance', 'issubclass'].some((name) => name === type.details.builtInName) &&
+        if (['isinstance', 'issubclass'].some((name) => name === typeResult.type.details.builtInName) &&
             validateArgTypeParams.length === 2) {
             validateArgTypeParams[1].expectingType = true;
         }
         return {
-            overload: type,
+            overload: typeResult.type,
             overloadIndex,
             argumentErrors: reportedArgError,
             isTypeIncomplete,
@@ -7294,7 +7360,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             // Set useNarrowBoundOnly to true the first time through
                             // the loop if we're going to go through the loop multiple
                             // times.
-                            const argResult = validateArgType(argParam, typeVarContext, type, skipUnknownArgCheck, 
+                            const argResult = validateArgType(argParam, typeVarContext, { type, isIncomplete: matchResults.isTypeIncomplete }, skipUnknownArgCheck, 
                             /* skipOverloadArg */ i === 0, 
                             /* useNarrowBoundOnly */ passCount > 1 && i === 0, typeCondition);
                             if (argResult.isTypeIncomplete) {
@@ -7317,11 +7383,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let sawParamSpecArgs = false;
         let sawParamSpecKwargs = false;
         let condition = [];
+        const argResults = [];
         matchResults.argParams.forEach((argParam) => {
             var _a;
-            const argResult = validateArgType(argParam, typeVarContext, type, skipUnknownArgCheck, 
+            const argResult = validateArgType(argParam, typeVarContext, { type, isIncomplete: matchResults.isTypeIncomplete }, skipUnknownArgCheck, 
             /* skipOverloadArg */ false, 
             /* useNarrowBoundOnly */ false, typeCondition);
+            argResults.push(argResult);
             if (!argResult.isCompatible) {
                 argumentErrors = true;
             }
@@ -7432,6 +7500,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return {
             argumentErrors,
+            argResults,
             isArgumentAnyOrUnknown,
             returnType: specializedReturnType,
             isTypeIncomplete,
@@ -7457,8 +7526,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // Tries to assign the call arguments to the function parameter
     // list and reports any mismatches in types or counts. Returns the
     // specialized return type of the call.
-    function validateFunctionArguments(errorNode, argList, type, typeVarContext, skipUnknownArgCheck = false, inferenceContext) {
-        const matchResults = matchFunctionArgumentsToParameters(errorNode, argList, type, 0);
+    function validateFunctionArguments(errorNode, argList, typeResult, typeVarContext, skipUnknownArgCheck = false, inferenceContext) {
+        const matchResults = matchFunctionArgumentsToParameters(errorNode, argList, typeResult, 0);
         if (matchResults.argumentErrors) {
             // Evaluate types of all args. This will ensure that referenced symbols are
             // not reported as unaccessed.
@@ -7582,13 +7651,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return !reportedArgError;
     }
-    function validateArgType(argParam, typeVarContext, functionType, skipUnknownCheck, skipOverloadArg, useNarrowBoundOnly, conditionFilter) {
+    function validateArgType(argParam, typeVarContext, typeResult, skipUnknownCheck, skipOverloadArg, useNarrowBoundOnly, conditionFilter) {
         var _a;
         let argType;
         let expectedTypeDiag;
-        let isTypeIncomplete = false;
+        let isTypeIncomplete = !!(typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete);
         let isCompatible = true;
-        const functionName = functionType === null || functionType === void 0 ? void 0 : functionType.details.name;
+        const functionName = typeResult === null || typeResult === void 0 ? void 0 : typeResult.type.details.name;
         if (argParam.argument.valueExpression) {
             // If the param type is a "bare" TypeVar, don't use it as an expected
             // type. This causes problems for cases where the the call expression
@@ -7598,7 +7667,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // a wide bound on a TypeVar (if a narrow bound has not yet been established)
             // will unnecessarily constrain the expected type.
             let expectedType;
-            if (!(0, types_1.isTypeVar)(argParam.paramType) || argParam.paramType.scopeId !== (functionType === null || functionType === void 0 ? void 0 : functionType.details.typeVarScopeId)) {
+            if (!(0, types_1.isTypeVar)(argParam.paramType) ||
+                argParam.paramType.scopeId !== (typeResult === null || typeResult === void 0 ? void 0 : typeResult.type.details.typeVarScopeId)) {
                 expectedType = (0, typeUtils_1.applySolvedTypeVars)(argParam.paramType, typeVarContext, { useNarrowBoundOnly });
             }
             // If the expected type is unknown, don't use an expected type. Instead,
@@ -7616,7 +7686,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         32 /* DisallowParamSpec */ |
                         64 /* DisallowTypeVarTuple */
                     : 0 /* None */;
-                const exprTypeResult = getTypeOfExpression(argParam.argument.valueExpression, flags, (0, typeUtils_1.makeInferenceContext)(expectedType, typeVarContext));
+                const exprTypeResult = getTypeOfExpression(argParam.argument.valueExpression, flags, (0, typeUtils_1.makeInferenceContext)(expectedType, typeVarContext, !!(typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete)));
                 argType = exprTypeResult.type;
                 if (exprTypeResult.isIncomplete) {
                     isTypeIncomplete = true;
@@ -8870,6 +8940,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     /* typeVarContext */ undefined, 
                     /* skipUnknownArgCheck */ true, inferenceContext);
                 });
+                // If there were errors with the expected type, try
+                // to evaluate without the expected type.
+                if (callResult.argumentErrors && inferenceContext) {
+                    useSpeculativeMode(errorNode, () => {
+                        callResult = validateCallArguments(errorNode, functionArgs, { type: magicMethodType }, 
+                        /* typeVarContext */ undefined, 
+                        /* skipUnknownArgCheck */ true);
+                    });
+                }
                 if (callResult.argumentErrors) {
                     magicMethodSupported = false;
                 }
@@ -9064,6 +9143,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             /* includeSubclasses */ undefined, 
             /* TupleTypeArguments */ undefined, isEmptyContainer))
             : types_1.UnknownType.create();
+        if (isIncomplete) {
+            if ((0, typeUtils_1.getContainerDepth)(type) > maxInferredContainerDepth) {
+                return { type: types_1.UnknownType.create() };
+            }
+        }
         return { type, isIncomplete };
     }
     function getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, forceStrictInference, expectedKeyType, expectedValueType, expectedTypedDictEntries, expectedDiagAddendum) {
@@ -9346,6 +9430,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             /* includeSubclasses */ undefined, 
             /* TupleTypeArguments */ undefined, isEmptyContainer))
             : types_1.UnknownType.create();
+        if (isIncomplete) {
+            if ((0, typeUtils_1.getContainerDepth)(type) > maxInferredContainerDepth) {
+                return { type: types_1.UnknownType.create() };
+            }
+        }
         return { type, isIncomplete, typeErrors };
     }
     function verifySetEntryOrDictKeyIsHashable(entry, type, isDictKey) {
@@ -9486,7 +9575,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return { type: returnedType || types_1.UnknownType.create() };
     }
     function getTypeOfLambda(node, inferenceContext) {
-        let isIncomplete = false;
+        let isIncomplete = !!(inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete);
         const functionType = types_1.FunctionType.createInstance('', '', '', 131072 /* PartiallyEvaluated */);
         functionType.details.typeVarScopeId = getScopeIdForNode(node);
         // Pre-cache the incomplete function type in case the evaluation of the
@@ -9591,7 +9680,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 isIncomplete = true;
             }
         };
-        if (speculativeTypeTracker.isSpeculative(node)) {
+        if (speculativeTypeTracker.isSpeculative(node) || (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete)) {
             // We need to set allowCacheRetention to false because we don't want to
             // cache the type of the lambda return expression because it depends on
             // the parameter types that we set above, and the speculative type cache
@@ -10987,14 +11076,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         node.arguments.forEach((arg) => {
             // Ignore unpacked arguments.
-            if (arg.argumentCategory !== 0 /* Simple */) {
+            if (arg.argumentCategory === 2 /* UnpackedDictionary */) {
                 // Evaluate the expression's type so symbols are marked accessed
                 // and errors are reported.
                 getTypeOfExpression(arg.valueExpression);
                 return;
             }
             if (!arg.name) {
-                let argType = getTypeOfExpression(arg.valueExpression, exprFlags).type;
+                let argType;
+                if (arg.argumentCategory === 1 /* UnpackedList */) {
+                    getTypeOfExpression(arg.valueExpression);
+                    argType = types_1.UnknownType.create();
+                }
+                else {
+                    argType = getTypeOfExpression(arg.valueExpression, exprFlags).type;
+                }
                 // In some stub files, classes are conditionally defined (e.g. based
                 // on platform type). We'll assume that the conditional logic is correct
                 // and strip off the "unbound" union.
@@ -11740,7 +11836,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                         argument: arg,
                                         errorNode: (_b = arg.valueExpression) !== null && _b !== void 0 ? _b : errorNode,
                                     };
-                                    validateArgType(argParam, new typeVarContext_1.TypeVarContext(), newMethodType, 
+                                    validateArgType(argParam, new typeVarContext_1.TypeVarContext(), { type: newMethodType }, 
                                     /* skipUnknownCheck */ true, 
                                     /* skipOverloadArg */ true, 
                                     /* useNarrowBoundOnly */ false, 
@@ -13167,6 +13263,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 getTypeOfClass(node.parent);
                 return;
             }
+            if (node.parent.nodeType === 23 /* ImportFromAs */) {
+                evaluateTypesForImportFromAs(node.parent);
+                return;
+            }
+            if (node.parent.nodeType === 21 /* ImportAs */) {
+                evaluateTypesForImportAs(node.parent);
+                return;
+            }
             if (node.parent.nodeType === 77 /* TypeAlias */ && node.parent.name === node) {
                 getTypeOfTypeAlias(node.parent);
                 return;
@@ -14673,9 +14777,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             })) === null || _a === void 0 ? void 0 : _a.type;
         }
         if (resolvedDecl.type === 1 /* Variable */ && resolvedDecl.inferredTypeSource) {
+            const isTypeAlias = (0, declarationUtils_1.isExplicitTypeAliasDeclaration)(resolvedDecl) || isPossibleTypeAliasOrTypedDict(resolvedDecl);
             // If this is a type alias, evaluate types for the entire assignment
             // statement rather than just the RHS of the assignment.
-            const typeSource = resolvedDecl.typeAliasName && resolvedDecl.inferredTypeSource.parent
+            const typeSource = isTypeAlias && resolvedDecl.inferredTypeSource.parent
                 ? resolvedDecl.inferredTypeSource.parent
                 : resolvedDecl.inferredTypeSource;
             let inferredType = (_b = evaluateTypeForSubnode(resolvedDecl.node, () => {
@@ -14693,7 +14798,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     inferredType = enumMemberType;
                 }
             }
-            if (inferredType && resolvedDecl.typeAliasName) {
+            if (inferredType && isTypeAlias && resolvedDecl.typeAliasName) {
                 // If this was a speculative type alias, it becomes a real type alias only
                 // in the event that its inferred type is instantiable or explicitly Any
                 // (but not an ellipsis).
@@ -14856,9 +14961,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             });
         }
+        else {
+            // Handle the case where there are multiple imports — one of them in
+            // a try block and one or more in except blocks. In this case, we'll
+            // use the one in the try block rather than the excepts.
+            if (decls.length > 1 && decls.every((decl) => decl.type === 8 /* Alias */)) {
+                const nonExceptDecls = decls.filter((decl) => decl.type === 8 /* Alias */ && !decl.isInExceptSuite);
+                if (nonExceptDecls.length === 1) {
+                    declIndexToConsider = decls.findIndex((decl) => decl === nonExceptDecls[0]);
+                }
+            }
+        }
         let sawExplicitTypeAlias = false;
         decls.forEach((decl, index) => {
-            var _a, _b;
+            var _a, _b, _c;
             let considerDecl = declIndexToConsider === undefined || index === declIndexToConsider;
             // If we have already seen an explicit type alias, do not consider
             // additional decls. This can happen if multiple TypeAlias declarations
@@ -14880,6 +14996,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             if (considerDecl) {
+                const resolvedDecl = (_a = resolveAliasDeclaration(decl, 
+                /* resolveLocalNames */ true, 
+                /* allowExternallyHiddenAccess */ AnalyzerNodeInfo.getFileInfo(decl.node).isStubFile)) !== null && _a !== void 0 ? _a : decl;
                 const isExplicitTypeAlias = (0, declarationUtils_1.isExplicitTypeAliasDeclaration)(decl);
                 const isTypeAlias = isExplicitTypeAlias || isPossibleTypeAliasOrTypedDict(decl);
                 if (isExplicitTypeAlias) {
@@ -14888,15 +15007,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // If this is a type alias, evaluate it outside of the recursive symbol
                 // resolution check so we can evaluate the full assignment statement.
                 if (isTypeAlias &&
-                    decl.type === 1 /* Variable */ &&
-                    ((_b = (_a = decl.inferredTypeSource) === null || _a === void 0 ? void 0 : _a.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 3 /* Assignment */) {
-                    evaluateTypesForAssignmentStatement(decl.inferredTypeSource.parent);
-                    if (decl.typeAliasAnnotation) {
+                    resolvedDecl.type === 1 /* Variable */ &&
+                    ((_c = (_b = resolvedDecl.inferredTypeSource) === null || _b === void 0 ? void 0 : _b.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 3 /* Assignment */) {
+                    evaluateTypesForAssignmentStatement(resolvedDecl.inferredTypeSource.parent);
+                    if (resolvedDecl.typeAliasAnnotation) {
                         // Mark "TypeAlias" declaration as accessed.
-                        getTypeOfAnnotation(decl.typeAliasAnnotation, {
+                        getTypeOfAnnotation(resolvedDecl.typeAliasAnnotation, {
                             isVariableAnnotation: true,
-                            allowFinal: ParseTreeUtils.isFinalAllowedForAssignmentTarget(decl.node),
-                            allowClassVar: ParseTreeUtils.isClassVarAllowedForAssignmentTarget(decl.node),
+                            allowFinal: ParseTreeUtils.isFinalAllowedForAssignmentTarget(resolvedDecl.node),
+                            allowClassVar: ParseTreeUtils.isClassVarAllowedForAssignmentTarget(resolvedDecl.node),
                         });
                     }
                 }
@@ -14907,14 +15026,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             isIncomplete = true;
                         }
                         if (type) {
-                            if (decl.type === 1 /* Variable */) {
-                                includesVariableDecl = true;
-                                let isConstant = decl.type === 1 /* Variable */ && !!decl.isConstant;
+                            if (resolvedDecl.type === 1 /* Variable */) {
+                                // Exempt typing.pyi, which uses variables to define some
+                                // special forms like Any.
+                                const fileInfo = AnalyzerNodeInfo.getFileInfo(resolvedDecl.node);
+                                if (!fileInfo.isTypingStubFile) {
+                                    includesVariableDecl = true;
+                                }
+                                let isConstant = resolvedDecl.type === 1 /* Variable */ && !!resolvedDecl.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) &&
-                                    (0, enums_1.isDeclInEnumClass)(evaluatorInterface, decl)) {
+                                    (0, enums_1.isDeclInEnumClass)(evaluatorInterface, resolvedDecl)) {
                                     isConstant = true;
                                 }
                                 // If the symbol is constant, we can retain the literal
@@ -14939,12 +15063,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
                 else {
-                    // If this resolves to a class decl, we can use a partially-evaluated
-                    // version of the class type.
-                    const resolvedDecl = resolveAliasDeclaration(decl, 
-                    /* resolveLocalNames */ true, 
-                    /* allowExternallyHiddenAccess */ AnalyzerNodeInfo.getFileInfo(decl.node).isStubFile);
-                    if ((resolvedDecl === null || resolvedDecl === void 0 ? void 0 : resolvedDecl.type) === 6 /* Class */) {
+                    if (resolvedDecl.type === 6 /* Class */) {
                         const classTypeInfo = getTypeOfClass(resolvedDecl.node);
                         if (classTypeInfo === null || classTypeInfo === void 0 ? void 0 : classTypeInfo.decoratedType) {
                             typesToCombine.push(classTypeInfo.decoratedType);
@@ -16211,7 +16330,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, types_1.isOverloadedFunction)(destType)) {
             const overloadDiag = diag === null || diag === void 0 ? void 0 : diag.createAddendum();
             // All overloads in the dest must be assignable.
-            const isAssignable = types_1.OverloadedFunctionType.getOverloads(destType).every((destOverload) => {
+            const destOverloads = types_1.OverloadedFunctionType.getOverloads(destType);
+            // If the source is also an overload with the same number of overloads,
+            // there's a good chance that there's a one-to-one mapping. Try this
+            // first before using an n^2 algorithm.
+            if ((0, types_1.isOverloadedFunction)(srcType)) {
+                const srcOverloads = types_1.OverloadedFunctionType.getOverloads(srcType);
+                if (destOverloads.length === srcOverloads.length) {
+                    if (destOverloads.every((destOverload, index) => {
+                        const srcOverload = srcOverloads[index];
+                        return assignType(destOverload, srcOverload, 
+                        /* diag */ undefined, destTypeVarContext !== null && destTypeVarContext !== void 0 ? destTypeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(destOverload)), srcTypeVarContext, flags, recursionCount);
+                    })) {
+                        return true;
+                    }
+                }
+            }
+            const isAssignable = destOverloads.every((destOverload) => {
                 if (destTypeVarContext) {
                     destTypeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(destOverload));
                 }
@@ -16228,10 +16363,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             return true;
         }
-        if ((0, types_1.isClassInstance)(destType) && types_1.ClassType.isBuiltIn(destType, 'object')) {
-            if ((flags & 1 /* EnforceInvariance */) === 0) {
-                // All types (including None, Module, OverloadedFunction) derive from object.
-                return true;
+        if ((0, types_1.isClass)(destType) && types_1.ClassType.isBuiltIn(destType, 'object')) {
+            if (((0, types_1.isInstantiableClass)(destType) && types_1.TypeBase.isInstantiable(srcType)) || (0, types_1.isClassInstance)(destType)) {
+                if ((flags & 1 /* EnforceInvariance */) === 0) {
+                    // All types (including None, Module, OverloadedFunction) derive from object.
+                    return true;
+                }
             }
         }
         // Are we trying to assign None to a protocol?