@zzzen/pyright-internal 1.2.0-dev.20230528 → 1.2.0-dev.20230611

package/dist/analyzer/typeEvaluator.js

@@ -651,6 +651,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             !(0, types_1.isAnyOrUnknown)(inferenceContext.expectedType) &&
             !(0, types_1.isNever)(inferenceContext.expectedType)) {
             expectedTypeCache.set(node.id, inferenceContext.expectedType);
+            // If this is a generic function and there is a signature tracker,
+            // make sure the signature is unique.
+            if (inferenceContext.signatureTracker && (0, types_1.isFunction)(typeResult.type)) {
+                typeResult.type = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(typeResult.type, inferenceContext.signatureTracker, node.start);
+            }
             if (!typeResult.isIncomplete && !typeResult.expectedTypeDiagAddendum) {
                 const diag = new diagnostic_1.DiagnosticAddendum();
                 // Make sure the resulting type is assignable to the expected type.
@@ -3093,10 +3098,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Is this a generic class that needs to be specialized?
         if ((0, types_1.isInstantiableClass)(type)) {
             if ((flags & 128 /* ExpectingType */) !== 0) {
-                if ((0, typeUtils_1.requiresTypeArguments)(type) && !type.typeArguments) {
-                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportMissingTypeArgument, diagnosticRules_1.DiagnosticRule.reportMissingTypeArgument, localize_1.Localizer.Diagnostic.typeArgsMissingForClass().format({
-                        name: type.aliasName || type.details.name,
-                    }), node);
+                if (!type.typeAliasInfo && (0, typeUtils_1.requiresTypeArguments)(type)) {
+                    if (!type.typeArguments || !type.isTypeArgumentExplicit) {
+                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportMissingTypeArgument, diagnosticRules_1.DiagnosticRule.reportMissingTypeArgument, localize_1.Localizer.Diagnostic.typeArgsMissingForClass().format({
+                            name: type.aliasName || type.details.name,
+                        }), node);
+                    }
                 }
             }
             if (!type.typeArguments) {
@@ -5130,7 +5137,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         let expectedTypeDiagAddendum;
         if (effectiveExpectedType) {
-            const result = getTypeOfTupleWithContext(node, (0, typeUtils_1.makeInferenceContext)(effectiveExpectedType));
+            const result = getTypeOfTupleWithContext(node, (0, typeUtils_1.makeInferenceContext)(effectiveExpectedType, 
+            /* isTypeIncomplete */ false, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.signatureTracker));
             if (result && !result.typeErrors) {
                 return result;
             }
@@ -5170,7 +5178,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         else {
             const tupleTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(tupleClassType));
-            if (!(0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, types_1.ClassType.cloneAsInstance(tupleClassType), inferenceContext.expectedType, tupleTypeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node))) {
+            if (!(0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, types_1.ClassType.cloneAsInstance(tupleClassType), inferenceContext.expectedType, tupleTypeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node), node.start)) {
                 return undefined;
             }
             const specializedTuple = (0, typeUtils_1.applySolvedTypeVars)(tupleClassType, tupleTypeVarContext);
@@ -5183,7 +5191,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         const entryTypeResults = node.expressions.map((expr, index) => getTypeOfExpression(expr, 
-        /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(index < expectedTypes.length ? expectedTypes[index] : undefined)));
+        /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(index < expectedTypes.length ? expectedTypes[index] : undefined, inferenceContext.isTypeIncomplete, inferenceContext.signatureTracker)));
         const isIncomplete = entryTypeResults.some((result) => result.isIncomplete);
         const type = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, buildTupleTypesList(entryTypeResults), 
         /* isTypeArgumentExplicit */ true));
@@ -5275,6 +5283,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return functionArg;
         });
         let typeResult = { type: types_1.UnknownType.create() };
+        // If the inference context has an associated signature tracker, make sure
+        // the base type of this call is not the same as one of the tracked signatures.
+        // This is important for nested generic calls (e.g. "foo(foo(x))").
+        if (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.signatureTracker) {
+            baseTypeResult.type = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(baseTypeResult.type, inferenceContext.signatureTracker, node.leftExpression.start);
+        }
         if (!(0, typeUtils_1.isTypeAliasPlaceholder)(baseTypeResult.type)) {
             if (node.leftExpression.nodeType === 38 /* Name */ && node.leftExpression.value === 'super') {
                 // Handle the built-in "super" call specially.
@@ -5774,19 +5788,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         let isSubtypeSubsumed = false;
                         for (let dedupedIndex = 0; dedupedIndex < dedupedMatchResults.length; dedupedIndex++) {
                             if (assignType(dedupedMatchResults[dedupedIndex], result.returnType)) {
-                                if (!(0, typeUtils_1.containsAnyOrUnknown)(dedupedMatchResults[dedupedIndex])) {
+                                const anyOrUnknown = (0, typeUtils_1.containsAnyOrUnknown)(dedupedMatchResults[dedupedIndex], 
+                                /* recurse */ false);
+                                if (!anyOrUnknown) {
                                     isSubtypeSubsumed = true;
                                 }
-                                else if (!(0, typeUtils_1.containsUnknown)(dedupedMatchResults[dedupedIndex])) {
+                                else if ((0, types_1.isAny)(anyOrUnknown)) {
                                     dedupedResultsIncludeAny = true;
                                 }
                                 break;
                             }
                             else if (assignType(result.returnType, dedupedMatchResults[dedupedIndex])) {
-                                if (!(0, typeUtils_1.containsAnyOrUnknown)(result.returnType)) {
+                                const anyOrUnknown = (0, typeUtils_1.containsAnyOrUnknown)(result.returnType, /* recurse */ false);
+                                if (!anyOrUnknown) {
                                     dedupedMatchResults[dedupedIndex] = types_1.NeverType.createNever();
                                 }
-                                else if (!(0, typeUtils_1.containsUnknown)(dedupedMatchResults[dedupedIndex])) {
+                                else if ((0, types_1.isAny)(anyOrUnknown)) {
                                     dedupedResultsIncludeAny = true;
                                 }
                                 break;
@@ -5875,6 +5892,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getBestOverloadForArguments(errorNode, typeResult, argList) {
         let overloadIndex = 0;
         let matches = [];
+        const signatureTracker = new typeUtils_1.UniqueSignatureTracker();
         // Create a list of potential overload matches based on arguments.
         types_1.OverloadedFunctionType.getOverloads(typeResult.type).forEach((overload) => {
             useSpeculativeMode(errorNode, () => {
@@ -5890,7 +5908,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         matches.forEach((match, matchIndex) => {
             if (winningOverloadIndex === undefined) {
                 useSpeculativeMode(errorNode, () => {
-                    const callResult = validateFunctionArgumentTypes(errorNode, match, new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(match.overload)), 
+                    const callResult = validateFunctionArgumentTypes(errorNode, match, new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(match.overload)), signatureTracker, 
                     /* skipUnknownArgCheck */ true);
                     if (callResult && !callResult.argumentErrors) {
                         winningOverloadIndex = matchIndex;
@@ -5945,9 +5963,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             return { argumentErrors: true, isTypeIncomplete: false, overloadsUsedForCall: [] };
         }
-        // Create a helper lambda that evaluates the overload that matches
+        // Create a helper function that evaluates the overload that matches
         // the arg/param lists.
-        const evaluateUsingLastMatchingOverload = (skipUnknownArgCheck) => {
+        function evaluateUsingLastMatchingOverload(skipUnknownArgCheck) {
             // Find the match with the largest overload index (i.e. the last overload
             // that was in the overload list).
             const lastMatch = filteredMatchResults.reduce((previous, current) => {
@@ -5957,7 +5975,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             effectiveTypeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeIds)(lastMatch.overload));
             effectiveTypeVarContext.unlock();
             return validateFunctionArgumentTypesWithContext(errorNode, lastMatch, effectiveTypeVarContext, skipUnknownArgCheck, inferenceContext);
-        };
+        }
         // If there is only one possible arg/param match among the overloads,
         // use the normal type matching mechanism because it is faster and
         // will provide a clearer error message.
@@ -6449,7 +6467,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const combinedArgType = (0, typeUtils_1.combineSameSizedTuples)(makeTopLevelTypeVarsConcrete(argType), tupleClassType);
                 if ((0, types_1.isClassInstance)(combinedArgType) && (0, typeUtils_1.isTupleClass)(combinedArgType)) {
                     const tupleTypeArgs = (_a = combinedArgType.tupleTypeArguments) !== null && _a !== void 0 ? _a : [];
-                    if (tupleTypeArgs.length !== 1) {
+                    if (tupleTypeArgs.length !== 1 || !tupleTypeArgs[0].isUnbounded) {
                         for (const tupleTypeArg of tupleTypeArgs) {
                             if (tupleTypeArg.isUnbounded) {
                                 expandedArgList.push({
@@ -7092,7 +7110,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (paramIndex >= paramDetails.firstPositionOrKeywordIndex &&
                         param.category === 0 /* Simple */ &&
                         param.name &&
-                        !param.hasDefault &&
                         paramMap.has(param.name) &&
                         paramMap.get(param.name).argsReceived === 0) {
                         const paramType = paramDetails.params[paramIndex].type;
@@ -7266,16 +7283,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // types of each argument expression and validates that the resulting type is
     // compatible with the declared type of the corresponding parameter.
     function validateFunctionArgumentTypesWithContext(errorNode, matchResults, typeVarContext, skipUnknownArgCheck = false, inferenceContext) {
-        var _a;
+        var _a, _b;
         const type = matchResults.overload;
+        const signatureTracker = (_a = inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.signatureTracker) !== null && _a !== void 0 ? _a : new typeUtils_1.UniqueSignatureTracker();
+        matchResults.overload = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(matchResults.overload, signatureTracker, errorNode.start);
         // Can we safely ignore the inference context (either because it's not provided
         // or will have no effect)? If so, we can eliminate a bunch of extra work.
         if (!inferenceContext ||
             (0, types_1.isAnyOrUnknown)(inferenceContext.expectedType) ||
             (0, types_1.isNever)(inferenceContext.expectedType) ||
             !type.details.declaredReturnType ||
-            !(0, typeUtils_1.requiresSpecialization)((_a = types_1.FunctionType.getSpecializedReturnType(type)) !== null && _a !== void 0 ? _a : types_1.UnknownType.create())) {
-            return validateFunctionArgumentTypes(errorNode, matchResults, typeVarContext, skipUnknownArgCheck);
+            !(0, typeUtils_1.requiresSpecialization)((_b = types_1.FunctionType.getSpecializedReturnType(type)) !== null && _b !== void 0 ? _b : types_1.UnknownType.create())) {
+            return validateFunctionArgumentTypes(errorNode, matchResults, typeVarContext, signatureTracker, skipUnknownArgCheck);
         }
         const effectiveReturnType = getFunctionEffectiveReturnType(type);
         let effectiveExpectedType = inferenceContext.expectedType;
@@ -7292,7 +7311,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 assignType(effectiveReturnType, effectiveExpectedType, 
                 /* diag */ undefined, typeVarContextCopy, 
                 /* srcTypeVarContext */ undefined, effectiveFlags | 1024 /* PopulatingExpectedType */);
-                const speculativeResults = validateFunctionArgumentTypes(errorNode, matchResults, typeVarContextCopy, skipUnknownArgCheck);
+                const speculativeResults = validateFunctionArgumentTypes(errorNode, matchResults, typeVarContextCopy, signatureTracker, skipUnknownArgCheck);
                 if (speculativeResults === null || speculativeResults === void 0 ? void 0 : speculativeResults.argumentErrors) {
                     effectiveExpectedType = undefined;
                 }
@@ -7319,7 +7338,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 if ((0, types_1.isClassInstance)(effectiveExpectedType) && !(0, types_1.isTypeSame)(effectiveReturnType, effectiveExpectedType)) {
                     const tempTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(effectiveReturnType));
-                    (0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, effectiveReturnType, effectiveExpectedType, tempTypeVarContext, liveTypeVarScopes);
+                    (0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, effectiveReturnType, effectiveExpectedType, tempTypeVarContext, liveTypeVarScopes, errorNode.start);
                     const genericReturnType = types_1.ClassType.cloneForSpecialization(effectiveReturnType, 
                     /* typeArguments */ undefined, 
                     /* isTypeArgumentExplicit */ false);
@@ -7335,14 +7354,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     });
                 }
             }
-            effectiveExpectedType = (0, typeUtils_1.transformExpectedType)(effectiveExpectedType, liveTypeVarScopes);
+            effectiveExpectedType = (0, typeUtils_1.transformExpectedType)(effectiveExpectedType, liveTypeVarScopes, errorNode.start);
             assignType(effectiveReturnType, effectiveExpectedType, 
             /* diag */ undefined, typeVarContext, 
             /* srcTypeVarContext */ undefined, effectiveFlags | 1024 /* PopulatingExpectedType */);
         }
-        return validateFunctionArgumentTypes(errorNode, matchResults, typeVarContext, skipUnknownArgCheck);
+        return validateFunctionArgumentTypes(errorNode, matchResults, typeVarContext, signatureTracker, skipUnknownArgCheck);
     }
-    function validateFunctionArgumentTypes(errorNode, matchResults, typeVarContext, skipUnknownArgCheck = false) {
+    function validateFunctionArgumentTypes(errorNode, matchResults, typeVarContext, signatureTracker, skipUnknownArgCheck = false) {
         const type = matchResults.overload;
         let isTypeIncomplete = matchResults.isTypeIncomplete;
         let argumentErrors = false;
@@ -7400,11 +7419,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // example of this is the built-in "map" method whose first parameter is
             // a lambda and second parameter indicates what type the lambda should accept.
             // In practice, we will limit the number of passes to 2 because it can get
-            // very expensive to go beyond this, and we don't see generally see cases
+            // very expensive to go beyond this, and we don't generally see cases
             // where more than two passes are needed.
             let passCount = Math.min(typeVarMatchingCount, 2);
             for (let i = 0; i < passCount; i++) {
-                const signatureTracker = new typeUtils_1.UniqueSignatureTracker();
                 useSpeculativeMode(errorNode, () => {
                     matchResults.argParams.forEach((argParam) => {
                         if (!argParam.requiresTypeVarMatching) {
@@ -7448,7 +7466,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let sawParamSpecKwargs = false;
         let condition = [];
         const argResults = [];
-        const signatureTracker = new typeUtils_1.UniqueSignatureTracker();
         matchResults.argParams.forEach((argParam) => {
             var _a;
             const argResult = validateArgType(argParam, typeVarContext, signatureTracker, { type, isIncomplete: matchResults.isTypeIncomplete }, {
@@ -7739,7 +7756,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (paramType) {
                     const argResult = validateArgType({
                         paramCategory: 0 /* Simple */,
-                        paramType: (0, typeUtils_1.transformExpectedType)(paramType, liveTypeVarScopes),
+                        paramType: (0, typeUtils_1.transformExpectedType)(paramType, liveTypeVarScopes, /* usageOffset */ undefined),
                         requiresTypeVarMatching: false,
                         argument: arg,
                         errorNode: arg.valueExpression || errorNode,
@@ -7837,12 +7854,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         32 /* DisallowParamSpec */ |
                         64 /* DisallowTypeVarTuple */
                     : 0 /* None */;
-                const exprTypeResult = getTypeOfExpression(argParam.argument.valueExpression, flags, (0, typeUtils_1.makeInferenceContext)(expectedType, !!(typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete)));
+                const exprTypeResult = getTypeOfExpression(argParam.argument.valueExpression, flags, (0, typeUtils_1.makeInferenceContext)(expectedType, !!(typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete), signatureTracker));
                 argType = exprTypeResult.type;
                 // If the type includes multiple instances of a generic function
                 // signature, force the type arguments for the duplicates to have
                 // unique names.
-                argType = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(argType, signatureTracker);
+                argType = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(argType, signatureTracker, argParam.argument.valueExpression.start);
                 if (exprTypeResult.isIncomplete) {
                     isTypeIncomplete = true;
                 }
@@ -8017,7 +8034,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (!options.skipUnknownArgCheck) {
             const simplifiedType = (0, types_1.removeUnbound)(argType);
             const fileInfo = AnalyzerNodeInfo.getFileInfo(argParam.errorNode);
-            const getDiagAddendum = () => {
+            function getDiagAddendum() {
                 const diagAddendum = new diagnostic_1.DiagnosticAddendum();
                 if (argParam.paramName) {
                     diagAddendum.addMessage((functionName
@@ -8029,7 +8046,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         diagAddendum.getString());
                 }
                 return diagAddendum;
-            };
+            }
             // Do not check for unknown types if the expected type is "Any".
             // Don't print types if reportUnknownArgumentType is disabled for performance.
             if (fileInfo.diagnosticRuleSet.reportUnknownArgumentType !== 'none' &&
@@ -8720,7 +8737,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return undefined;
         }
         const dictTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(builtInDict));
-        if (!(0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, builtInDict, inferenceContext.expectedType, dictTypeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node))) {
+        if (!(0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, builtInDict, inferenceContext.expectedType, dictTypeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node), node.start)) {
             return undefined;
         }
         const specializedDict = (0, typeUtils_1.applySolvedTypeVars)(types_1.ClassType.cloneAsInstantiable(builtInDict), dictTypeVarContext);
@@ -8982,7 +8999,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return undefined;
         }
         const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(builtInListOrSet));
-        if (!(0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, builtInListOrSet, inferenceContext.expectedType, typeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node))) {
+        if (!(0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, builtInListOrSet, inferenceContext.expectedType, typeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node), node.start)) {
             return undefined;
         }
         const specializedListOrSet = (0, typeUtils_1.applySolvedTypeVars)(types_1.ClassType.cloneAsInstantiable(builtInListOrSet), typeVarContext);
@@ -9203,7 +9220,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             expectedFunctionTypes = expectedFunctionTypes.filter((functionType) => {
                 const functionParamCount = functionType.details.parameters.filter((param) => !!param.name && !param.hasDefault).length;
                 const hasVarArgs = functionType.details.parameters.some((param) => !!param.name && param.category !== 0 /* Simple */);
+                const hasParamSpec = !!functionType.details.paramSpec;
                 return (hasVarArgs ||
+                    hasParamSpec ||
                     (functionParamCount >= minLambdaParamCount && functionParamCount <= maxLambdaParamCount));
             });
         }
@@ -9265,10 +9284,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 type: types_1.UnknownType.create(),
             });
         }
-        // Handle the case where the expected type contains a ParamSpec.
-        if (expectedFunctionType === null || expectedFunctionType === void 0 ? void 0 : expectedFunctionType.details.paramSpec) {
-            functionType.details.paramSpec = expectedFunctionType.details.paramSpec;
-        }
         const expectedReturnType = expectedFunctionType
             ? getFunctionEffectiveReturnType(expectedFunctionType)
             : undefined;
@@ -9742,7 +9757,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     let isLiteralType = true;
                     (0, typeUtils_1.doForEachSubtype)(exprType.type, (subtype) => {
                         if (!(0, types_1.isInstantiableClass)(subtype) || subtype.literalValue === undefined) {
-                            isLiteralType = false;
+                            if (!(0, types_1.isNoneTypeClass)(subtype)) {
+                                isLiteralType = false;
+                            }
                         }
                     });
                     if (isLiteralType) {
@@ -10695,7 +10712,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let protocolTypeParameters;
         const initSubclassArgs = [];
         let metaclassNode;
-        let isMetaclassDeferred = false;
         let exprFlags = 128 /* ExpectingType */ |
             1024 /* AllowGenericClassType */ |
             262144 /* DisallowNakedGeneric */ |
@@ -10750,7 +10766,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 dependency: argType,
                                 callback: () => completeClassTypeDeferred(classType, node, node.name),
                             });
-                            isMetaclassDeferred = true;
                         }
                         if (types_1.ClassType.isBuiltIn(argType, 'Protocol')) {
                             if (!fileInfo.isStubFile &&
@@ -11033,7 +11048,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         for (let i = node.decorators.length - 1; i >= 0; i--) {
             const decorator = node.decorators[i];
             const newDecoratedType = applyClassDecorator(decoratedType, classType, decorator);
-            if ((0, typeUtils_1.containsUnknown)(newDecoratedType)) {
+            const unknownOrAny = (0, typeUtils_1.containsAnyOrUnknown)(newDecoratedType, /* recurse */ false);
+            if (unknownOrAny && (0, types_1.isUnknown)(unknownOrAny)) {
                 // Report this error only on the first unknown type.
                 if (!foundUnknown) {
                     addDiagnostic(fileInfo.diagnosticRuleSet.reportUntypedClassDecorator, diagnosticRules_1.DiagnosticRule.reportUntypedClassDecorator, localize_1.Localizer.Diagnostic.classDecoratorTypeUnknown(), node.decorators[i].expression);
@@ -11120,11 +11136,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         writeTypeCache(node.name, { type: classType }, 0 /* None */);
         // Update the decorated class type.
         writeTypeCache(node, { type: decoratedType }, 0 /* None */);
-        // Validate that arguments passed to `__init_subclass__` are of the correct type.
-        // Defer this if the metaclass calculation is deferred.
-        if (!isMetaclassDeferred) {
-            validateInitSubclassArgs(node, classType);
-        }
         return { classType, decoratedType };
     }
     // Determines whether the type parameters has a default that refers to another
@@ -11414,7 +11425,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // Recompute the effective metaclass.
         computeEffectiveMetaclass(type, errorNode);
-        validateInitSubclassArgs(node, type);
     }
     function validateInitSubclassArgs(node, classType) {
         // Collect arguments that will be passed to the `__init_subclass__`
@@ -11867,7 +11877,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         for (let i = node.decorators.length - 1; i >= 0; i--) {
             const decorator = node.decorators[i];
             const newDecoratedType = applyFunctionDecorator(decoratedType, functionType, decorator, node);
-            if ((0, typeUtils_1.containsUnknown)(newDecoratedType)) {
+            const unknownOrAny = (0, typeUtils_1.containsAnyOrUnknown)(newDecoratedType, /* recurse */ false);
+            if (unknownOrAny && (0, types_1.isUnknown)(unknownOrAny)) {
                 // Report this error only on the first unknown type.
                 if (!foundUnknown) {
                     addDiagnostic(fileInfo.diagnosticRuleSet.reportUntypedFunctionDecorator, diagnosticRules_1.DiagnosticRule.reportUntypedFunctionDecorator, localize_1.Localizer.Diagnostic.functionDecoratorTypeUnknown(), node.decorators[i].expression);
@@ -14000,7 +14011,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return undefined;
     }
     function getDeclarationsForNameNode(node, skipUnreachableCode = true) {
-        var _a;
+        var _a, _b, _c;
         if (skipUnreachableCode && AnalyzerNodeInfo.isCodeUnreachable(node)) {
             return undefined;
         }
@@ -14101,7 +14112,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // the corresponding named parameter can be determined from the context.
             const argNode = node.parent;
             const paramName = node.value;
-            if (argNode.parent && argNode.parent.nodeType === 9 /* Call */) {
+            if (((_a = argNode.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 9 /* Call */) {
                 const baseType = getType(argNode.parent.leftExpression);
                 if (baseType) {
                     if ((0, types_1.isFunction)(baseType) && baseType.details.declaration) {
@@ -14119,8 +14130,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         });
                     }
                     else if ((0, types_1.isInstantiableClass)(baseType)) {
-                        const initMethodType = (_a = getTypeOfObjectMember(argNode.parent.leftExpression, types_1.ClassType.cloneAsInstance(baseType), '__init__', { method: 'get' }, 
-                        /* diag */ undefined, 4 /* SkipObjectBaseClass */)) === null || _a === void 0 ? void 0 : _a.type;
+                        const initMethodType = (_b = getTypeOfObjectMember(argNode.parent.leftExpression, types_1.ClassType.cloneAsInstance(baseType), '__init__', { method: 'get' }, 
+                        /* diag */ undefined, 4 /* SkipObjectBaseClass */)) === null || _b === void 0 ? void 0 : _b.type;
                         if (initMethodType && (0, types_1.isFunction)(initMethodType)) {
                             const paramDecl = getDeclarationFromFunctionNamedParameter(initMethodType, paramName);
                             if (paramDecl) {
@@ -14136,6 +14147,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
             }
+            else if (((_c = argNode.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 10 /* Class */) {
+                const classTypeResult = getTypeOfClass(argNode.parent);
+                // Validate the init subclass args for this class so we can properly
+                // evaluate its custom keyword parameters.
+                if (classTypeResult) {
+                    validateInitSubclassArgs(argNode.parent, classTypeResult.classType);
+                }
+            }
         }
         else {
             const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
@@ -15034,6 +15053,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             types_1.FunctionType.hasUnannotatedParams(type) &&
             !types_1.FunctionType.isStubDefinition(type) &&
             !types_1.FunctionType.isPyTypedDefinition(type) &&
+            !types_1.FunctionType.isWrapReturnTypeInAwait(type) &&
             args) {
             const contextualReturnType = getFunctionInferredReturnTypeUsingArguments(type, args);
             if (contextualReturnType) {
@@ -15386,10 +15406,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         });
         return isAssignable;
     }
-    function assignTupleTypeArgs(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
-        var _a, _b;
-        const destTypeArgs = [...((_a = destType.tupleTypeArguments) !== null && _a !== void 0 ? _a : [])];
-        const srcTypeArgs = [...((_b = srcType.tupleTypeArguments) !== null && _b !== void 0 ? _b : [])];
+    // Adjusts the source type arguments list to match the length of the
+    // dest type arguments list if the dest list contains an unbounded
+    // or variadic entry.
+    function adjustSourceTupleTypeArgs(destTypeArgs, srcTypeArgs) {
         const destVariadicIndex = destTypeArgs.findIndex((t) => (0, types_1.isVariadicTypeVar)(t.type));
         const destUnboundedIndex = destTypeArgs.findIndex((t) => t.isUnbounded);
         const srcUnboundedIndex = srcTypeArgs.findIndex((t) => t.isUnbounded);
@@ -15437,6 +15457,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
+    }
+    function assignTupleTypeArgs(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
+        var _a, _b;
+        const destTypeArgs = [...((_a = destType.tupleTypeArguments) !== null && _a !== void 0 ? _a : [])];
+        const srcTypeArgs = [...((_b = srcType.tupleTypeArguments) !== null && _b !== void 0 ? _b : [])];
+        let srcUnboundedIndex;
+        if (flags & 2 /* ReverseTypeVarMatching */) {
+            adjustSourceTupleTypeArgs(srcTypeArgs, destTypeArgs);
+            srcUnboundedIndex = destTypeArgs.findIndex((t) => t.isUnbounded);
+        }
+        else {
+            adjustSourceTupleTypeArgs(destTypeArgs, srcTypeArgs);
+            srcUnboundedIndex = srcTypeArgs.findIndex((t) => t.isUnbounded);
+        }
         if (srcTypeArgs.length === destTypeArgs.length) {
             for (let argIndex = 0; argIndex < srcTypeArgs.length; argIndex++) {
                 const entryDiag = diag === null || diag === void 0 ? void 0 : diag.createAddendum();
@@ -15703,6 +15737,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             (transformedSrcType !== srcType && (0, types_1.isUnion)(transformedSrcType))) {
             // Use a smaller recursive limit in this case to prevent runaway recursion.
             if (recursionCount > maxRecursiveTypeAliasRecursionCount) {
+                // Add a special case for when the source is a str, which is itself
+                // a recursive type (since it derives from Sequence[str]).
+                if ((0, types_1.isClassInstance)(srcType) && types_1.ClassType.isBuiltIn(srcType, 'str') && (0, types_1.isUnion)(transformedDestType)) {
+                    return transformedDestType.subtypes.some((subtype) => (0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, ['object', 'str']));
+                }
                 return true;
             }
         }
@@ -17170,7 +17209,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(assignedType));
             (0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, types_1.ClassType.cloneForSpecialization(assignedType, 
             /* typeArguments */ undefined, 
-            /* isTypeArgumentExplicit */ false), declaredType, typeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node));
+            /* isTypeArgumentExplicit */ false), declaredType, typeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node), node.start);
             let replacedTypeArg = false;
             const newTypeArgs = assignedType.typeArguments.map((typeArg, index) => {
                 const typeParam = assignedType.details.typeParameters[index];
@@ -17267,25 +17306,42 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return validateOverrideMethodInternal(baseMethod, overrideMethod, diag, enforceParamNames);
             }
             // For an overload overriding a base method, at least one overload
-            // must be compatible with the base method.
-            if (types_1.OverloadedFunctionType.getOverloads(overrideMethod).some((overrideOverload) => {
+            // or the implementation must be compatible with the base method.
+            if (overrideMethod.overloads.some((overrideOverload) => {
                 return validateOverrideMethodInternal(baseMethod, overrideOverload, 
                 /* diag */ undefined, enforceParamNames);
             })) {
                 return true;
             }
-            // Or the implementation must be compatible.
-            const overrideImplementation = types_1.OverloadedFunctionType.getImplementation(overrideMethod);
-            if (overrideImplementation) {
-                if (validateOverrideMethodInternal(baseMethod, overrideImplementation, 
-                /* diag */ undefined, enforceParamNames)) {
-                    return true;
-                }
-            }
             diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideNoOverloadMatches());
             return false;
         }
-        // TODO - need to implement the case where the base method is overloaded
+        // For a non-overloaded method overriding an overloaded method, the
+        // override must match all of the overloads.
+        if ((0, types_1.isFunction)(overrideMethod)) {
+            return types_1.OverloadedFunctionType.getOverloads(baseMethod).every((overload) => validateOverrideMethodInternal(overload, overrideMethod, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), enforceParamNames));
+        }
+        // For an overloaded method overriding an overloaded method, the overrides
+        // must all match and be in the correct order. It is OK if the base method
+        // has additional overloads that are not present in the override.
+        let previousMatchIndex = -1;
+        let overrideOverloadIndex = 0;
+        for (const overrideOverload of types_1.OverloadedFunctionType.getOverloads(overrideMethod)) {
+            const matchIndex = types_1.OverloadedFunctionType.getOverloads(baseMethod).findIndex((baseOverload) => {
+                return validateOverrideMethodInternal(baseOverload, overrideOverload, 
+                /* diag */ undefined, enforceParamNames);
+            });
+            if (matchIndex < 0) {
+                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideOverloadNoMatch().format({ index: overrideOverloadIndex }));
+                return false;
+            }
+            if (matchIndex < previousMatchIndex) {
+                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideOverloadOrder());
+                return false;
+            }
+            previousMatchIndex = matchIndex;
+            overrideOverloadIndex++;
+        }
         return true;
     }
     function validateOverrideMethodInternal(baseMethod, overrideMethod, diag, enforceParamNames) {
@@ -17971,6 +18027,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         verifyRaiseExceptionType,
         verifyDeleteExpression,
         validateOverloadedFunctionArguments,
+        validateInitSubclassArgs,
         isAfterNodeReachable,
         isNodeReachable,
         isAsymmetricDescriptorAssignment: isAsymmetricAccessorAssignment,
@@ -18018,6 +18075,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         getBuiltInObject,
         getTypingType,
         verifyTypeArgumentsAssignable,
+        reportMissingTypeArguments,
         inferReturnTypeIfNecessary,
         inferTypeParameterVarianceForClass,
         isFinalVariable,