@zzzen/pyright-internal 1.2.0-dev.20230129 → 1.2.0-dev.20230212

package/dist/analyzer/typeEvaluator.js

@@ -254,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) {
@@ -333,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);
             }
         }
     }
@@ -494,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' : ''}`);
             }
@@ -502,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) {
@@ -614,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;
             }
@@ -1218,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)) {
@@ -1389,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({
@@ -1425,16 +1446,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             (0, types_1.isFunction)(methodType) &&
                             methodType.details.fullName === 'builtins.object.__init__';
                         const isSkipConstructor = !!methodType && (0, types_1.isFunction)(methodType) && types_1.FunctionType.isSkipConstructorCheck(methodType);
-                        // If there was no `__init__` or the only `__init__` that was found
-                        // was form the `object` class, see if we can find a better `__new__`
-                        // method.
-                        if (!methodType ||
-                            isObjectInit ||
-                            isSkipConstructor ||
-                            (methodType &&
-                                (0, types_1.isFunction)(methodType) &&
-                                (types_1.FunctionType.hasDefaultParameters(methodType) ||
-                                    methodType.details.parameters.length === 0))) {
+                        const isDefaultParams = methodType && (0, types_1.isFunction)(methodType) && types_1.FunctionType.hasDefaultParameters(methodType);
+                        // If there was no `__init__` or the only `__init__` that was found was from
+                        // the `object` class or accepts only default parameters(* args, ** kwargs),
+                        // see if we can find a better signature from the `__new__` method.
+                        if (!methodType || isObjectInit || isSkipConstructor || isDefaultParams) {
                             const constructorType = getBoundMethod(subtype, '__new__', 
                             /* recursionCount */ undefined, 
                             /* treatConstructorAsClassMember */ true);
@@ -2741,7 +2757,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);
                         }
@@ -2941,11 +2957,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
@@ -2972,6 +2990,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;
@@ -3349,7 +3371,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);
@@ -4429,15 +4451,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (!diag.isEmpty()) {
             addError(localize_1.Localizer.Diagnostic.typeNotSpecializable().format({ type: printType(baseType) }) + diag.getString(), node);
         }
+        const primarySignatureContext = typeVarContext.getPrimarySignature();
         const aliasTypeArgs = [];
         (_b = baseType.typeAliasInfo.typeParameters) === null || _b === void 0 ? void 0 : _b.forEach((typeParam) => {
             let typeVarType;
             if ((0, types_1.isParamSpec)(typeParam)) {
-                const paramSpecType = typeVarContext.getParamSpecType(typeParam);
+                const paramSpecType = primarySignatureContext.getParamSpecType(typeParam);
                 typeVarType = paramSpecType ? (0, typeUtils_1.convertParamSpecValueToType)(paramSpecType) : types_1.UnknownType.create();
             }
             else {
-                typeVarType = typeVarContext.getTypeVarType(typeParam);
+                typeVarType = primarySignatureContext.getTypeVarType(typeParam);
             }
             aliasTypeArgs.push(typeVarType || types_1.UnknownType.create());
         });
@@ -5412,17 +5435,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 +5482,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 +5506,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 +5565,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 +5630,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 +5640,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 +5658,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 +5686,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 +6147,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 +6196,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 +6473,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 +6519,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 +6578,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 +6624,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 +6910,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 +7029,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 +7038,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 +7085,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 +7209,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 +7356,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 +7379,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 +7496,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return {
             argumentErrors,
+            argResults,
             isArgumentAnyOrUnknown,
             returnType: specializedReturnType,
             isTypeIncomplete,
@@ -7457,8 +7522,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.
@@ -7478,8 +7543,30 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // Determines whether the specified argument list satisfies the function
     // signature bound to the specified ParamSpec. Return value indicates success.
     function validateFunctionArgumentsForParamSpec(errorNode, argList, paramSpec, destTypeVarContext, conditionFilter) {
+        const signatureContexts = destTypeVarContext.getSignatureContexts();
+        // Handle the common case where there is only one signature context.
+        if (signatureContexts.length === 1) {
+            return validateFunctionArgumentsForParamSpecSignature(errorNode, argList, paramSpec, signatureContexts[0], conditionFilter);
+        }
+        const filteredSignatureContexts = [];
+        signatureContexts.forEach((context) => {
+            // Use speculative mode to avoid emitting errors or caching types.
+            useSpeculativeMode(errorNode, () => {
+                if (validateFunctionArgumentsForParamSpecSignature(errorNode, argList, paramSpec, context, conditionFilter)) {
+                    filteredSignatureContexts.push(context);
+                }
+            });
+        });
+        // Copy back any compatible signature contexts if any were compatible.
+        if (filteredSignatureContexts.length > 0) {
+            destTypeVarContext.copySignatureContexts(filteredSignatureContexts);
+        }
+        // Evaluate non-speculatively to produce a final result and cache types.
+        return validateFunctionArgumentsForParamSpecSignature(errorNode, argList, paramSpec, filteredSignatureContexts.length > 0 ? filteredSignatureContexts[0] : signatureContexts[0], conditionFilter);
+    }
+    function validateFunctionArgumentsForParamSpecSignature(errorNode, argList, paramSpec, typeVarContext, conditionFilter) {
         var _a;
-        const paramSpecType = destTypeVarContext.getParamSpecType(paramSpec);
+        const paramSpecType = typeVarContext.getParamSpecType(paramSpec);
         if (!paramSpecType) {
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramSpecNotBound().format({ type: printType(paramSpec) }), ((_a = argList[0]) === null || _a === void 0 ? void 0 : _a.valueExpression) || errorNode);
             return false;
@@ -7541,7 +7628,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     positionalIndex++;
                 }
                 if (paramType) {
-                    if (!validateArgType({
+                    const argResult = validateArgType({
                         paramCategory: 0 /* Simple */,
                         paramType,
                         requiresTypeVarMatching: false,
@@ -7551,7 +7638,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     /* functionType */ undefined, 
                     /* skipUnknownArgCheck */ false, 
                     /* skipOverloadArg */ false, 
-                    /* useNarrowBoundOnly */ false, conditionFilter)) {
+                    /* useNarrowBoundOnly */ false, conditionFilter);
+                    if (!argResult.isCompatible) {
                         reportedArgError = true;
                     }
                 }
@@ -7578,17 +7666,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         if (!reportedArgError) {
-            destTypeVarContext.applySourceContextTypeVars(srcTypeVarContext);
+            typeVarContext.applySourceContextTypeVars(srcTypeVarContext);
         }
         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 +7686,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 +7705,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 +8959,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;
                 }
@@ -9496,7 +9594,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
@@ -9601,7 +9699,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
@@ -10699,6 +10797,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (isDeclaredTypeAlias(node.leftExpression)) {
             flags |=
                 128 /* ExpectingType */ |
+                    256 /* ExpectingTypeAnnotation */ |
                     8 /* EvaluateStringLiteralAsType */ |
                     32 /* DisallowParamSpec */ |
                     64 /* DisallowTypeVarTuple */ |
@@ -10997,14 +11096,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.
@@ -11350,24 +11456,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (!skipSynthesizedInit) {
                 const initSymbol = (0, typeUtils_1.lookUpClassMember)(classType, '__init__', 2 /* SkipBaseClasses */);
                 if (initSymbol) {
-                    const initSymbolType = getTypeOfMember(initSymbol);
-                    if ((0, types_1.isFunction)(initSymbolType)) {
-                        if (!types_1.FunctionType.isSynthesizedMethod(initSymbolType)) {
-                            hasExistingInitMethod = true;
-                        }
-                    }
-                    else {
-                        hasExistingInitMethod = true;
-                    }
+                    hasExistingInitMethod = true;
                 }
             }
             let skipSynthesizeHash = false;
             const hashSymbol = (0, typeUtils_1.lookUpClassMember)(classType, '__hash__', 2 /* SkipBaseClasses */);
             if (hashSymbol) {
-                const hashSymbolType = getTypeOfMember(hashSymbol);
-                if ((0, types_1.isFunction)(hashSymbolType) && !types_1.FunctionType.isSynthesizedMethod(hashSymbolType)) {
-                    skipSynthesizeHash = true;
-                }
+                skipSynthesizeHash = true;
             }
             (0, dataClasses_1.synthesizeDataClassMethods)(evaluatorInterface, node, classType, skipSynthesizedInit, hasExistingInitMethod, skipSynthesizeHash);
         }
@@ -11750,7 +11845,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, 
@@ -13177,6 +13272,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;
@@ -14683,9 +14786,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, () => {
@@ -14703,7 +14807,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).
@@ -14879,7 +14983,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         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
@@ -14901,6 +15005,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) {
@@ -14909,15 +15016,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),
                         });
                     }
                 }
@@ -14928,14 +15035,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
@@ -14960,12 +15072,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);
@@ -15868,7 +15975,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 srcType.details.isSynthesizedSelf &&
                 srcType.details.boundType &&
                 destType.details.isSynthesizedSelf &&
-                destType.details.boundType) {
+                destType.details.boundType &&
+                types_1.TypeBase.isInstance(srcType) === types_1.TypeBase.isInstance(destType)) {
                 if ((flags & 2 /* ReverseTypeVarMatching */) === 0 && destTypeVarContext) {
                     (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, destType, srcType, diag, destTypeVarContext, originalFlags, recursionCount);
                 }
@@ -16183,7 +16291,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         if ((0, types_1.isFunction)(destType)) {
-            let srcFunction;
             let concreteSrcType = makeTopLevelTypeVarsConcrete(srcType);
             if ((0, types_1.isClassInstance)(concreteSrcType)) {
                 const boundMethod = getBoundMethod(concreteSrcType, '__call__', recursionCount);
@@ -16198,33 +16305,45 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     concreteSrcType = constructor;
                 }
             }
+            if ((0, types_1.isAnyOrUnknown)(concreteSrcType)) {
+                return (flags & 16 /* OverloadOverlapCheck */) === 0;
+            }
             if ((0, types_1.isOverloadedFunction)(concreteSrcType)) {
-                // Overloads are not compatible with ParamSpec.
-                if (destType.details.paramSpec) {
-                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.paramSpecOverload());
-                    return false;
-                }
-                // Find first overloaded function that matches the parameters.
-                // We don't want to pollute the current typeVarContext, so we'll
-                // make a copy of the existing one if it's specified.
+                // Find all of the overloaded functions that match the parameters.
                 const overloads = types_1.OverloadedFunctionType.getOverloads(concreteSrcType);
-                const overloadIndex = overloads.findIndex((overload) => {
-                    return assignType(destType, overload, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext === null || destTypeVarContext === void 0 ? void 0 : destTypeVarContext.clone(), srcTypeVarContext === null || srcTypeVarContext === void 0 ? void 0 : srcTypeVarContext.clone(), flags, recursionCount);
+                const filteredOverloads = [];
+                const destTypeVarSignatures = [];
+                const srcTypeVarSignatures = [];
+                overloads.forEach((overload) => {
+                    var _a;
+                    const overloadScopeId = (_a = (0, typeUtils_1.getTypeVarScopeId)(overload)) !== null && _a !== void 0 ? _a : '';
+                    const destTypeVarContextClone = destTypeVarContext === null || destTypeVarContext === void 0 ? void 0 : destTypeVarContext.cloneWithSignatureSource(overloadScopeId);
+                    const srcTypeVarContextClone = srcTypeVarContext === null || srcTypeVarContext === void 0 ? void 0 : srcTypeVarContext.cloneWithSignatureSource(overloadScopeId);
+                    if (assignType(destType, overload, 
+                    /* diag */ undefined, destTypeVarContextClone, srcTypeVarContextClone, flags, recursionCount)) {
+                        filteredOverloads.push(overload);
+                        if (destTypeVarContextClone) {
+                            destTypeVarSignatures.push(...destTypeVarContextClone.getSignatureContexts());
+                        }
+                        if (srcTypeVarContextClone) {
+                            srcTypeVarSignatures.push(...srcTypeVarContextClone.getSignatureContexts());
+                        }
+                    }
                 });
-                if (overloadIndex < 0) {
+                if (filteredOverloads.length === 0) {
                     diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.noOverloadAssignable().format({ type: printType(destType) }));
                     return false;
                 }
-                srcFunction = overloads[overloadIndex];
-            }
-            else if ((0, types_1.isFunction)(concreteSrcType)) {
-                srcFunction = concreteSrcType;
-            }
-            else if ((0, types_1.isAnyOrUnknown)(concreteSrcType)) {
-                return (flags & 16 /* OverloadOverlapCheck */) === 0;
+                if (destTypeVarContext) {
+                    destTypeVarContext.copySignatureContexts(destTypeVarSignatures);
+                }
+                if (srcTypeVarContext) {
+                    srcTypeVarContext.copySignatureContexts(srcTypeVarSignatures);
+                }
+                return true;
             }
-            if (srcFunction) {
-                if (assignFunction(destType, srcFunction, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext !== null && destTypeVarContext !== void 0 ? destTypeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(destType)), srcTypeVarContext !== null && srcTypeVarContext !== void 0 ? srcTypeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(srcFunction)), flags, recursionCount)) {
+            if ((0, types_1.isFunction)(concreteSrcType)) {
+                if (assignFunction(destType, concreteSrcType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext !== null && destTypeVarContext !== void 0 ? destTypeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(destType)), srcTypeVarContext !== null && srcTypeVarContext !== void 0 ? srcTypeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(concreteSrcType)), flags, recursionCount)) {
                     return true;
                 }
             }
@@ -16265,10 +16384,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?
@@ -17189,8 +17310,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const effectiveSrcTypeVarContext = (flags & 2 /* ReverseTypeVarMatching */) === 0 ? srcTypeVarContext : destTypeVarContext;
         // If the target function was generic and we solved some of the type variables
         // in that generic type, assign them back to the destination typeVar.
-        effectiveSrcTypeVarContext.getTypeVars().forEach((typeVarEntry) => {
-            assignType(typeVarEntry.typeVar, effectiveSrcTypeVarContext.getTypeVarType(typeVarEntry.typeVar), 
+        const typeVarSignatureContext = effectiveSrcTypeVarContext.getPrimarySignature();
+        typeVarSignatureContext.getTypeVars().forEach((typeVarEntry) => {
+            assignType(typeVarEntry.typeVar, typeVarSignatureContext.getTypeVarType(typeVarEntry.typeVar), 
             /* diag */ undefined, destTypeVarContext, srcTypeVarContext, 0 /* Default */, recursionCount);
         });
         // Are we assigning to a function with a ParamSpec?
@@ -17345,7 +17467,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             let replacedTypeArg = false;
             const newTypeArgs = assignedType.typeArguments.map((typeArg, index) => {
                 const typeParam = assignedType.details.typeParameters[index];
-                const expectedTypeArgType = typeVarContext.getTypeVarType(typeParam);
+                const expectedTypeArgType = typeVarContext.getPrimarySignature().getTypeVarType(typeParam);
                 if (expectedTypeArgType) {
                     if ((0, types_1.isAny)(expectedTypeArgType) || (0, types_1.isAnyOrUnknown)(typeArg)) {
                         replacedTypeArg = true;
@@ -17945,8 +18067,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function printObjectTypeForClass(type) {
         return TypePrinter.printObjectTypeForClass(type, evaluatorOptions.printTypeFlags, getFunctionEffectiveReturnType);
     }
-    function printFunctionParts(type) {
-        return TypePrinter.printFunctionParts(type, evaluatorOptions.printTypeFlags, getFunctionEffectiveReturnType);
+    function printFunctionParts(type, extraFlags) {
+        const flags = extraFlags ? evaluatorOptions.printTypeFlags | extraFlags : evaluatorOptions.printTypeFlags;
+        return TypePrinter.printFunctionParts(type, flags, getFunctionEffectiveReturnType);
     }
     function printType(type, options) {
         let flags = evaluatorOptions.printTypeFlags;