@zzzen/pyright-internal 1.2.0-dev.20230521 → 1.2.0-dev.20230604

package/dist/analyzer/typeEvaluator.js

@@ -858,6 +858,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return typeResult;
     }
     function stripLiteralValue(type) {
+        var _a, _b, _c;
+        // Handle the not-uncommon case where the type is a union that consists
+        // only of literal str or literal int values.
+        if ((0, types_1.isUnion)(type) && type.subtypes.length > 0) {
+            if (((_a = type.literalStrMap) === null || _a === void 0 ? void 0 : _a.size) === type.subtypes.length ||
+                ((_b = type.literalIntMap) === null || _b === void 0 ? void 0 : _b.size) === type.subtypes.length ||
+                ((_c = type.literalEnumMap) === null || _c === void 0 ? void 0 : _c.size) === type.subtypes.length) {
+                return stripLiteralValue(type.subtypes[0]);
+            }
+        }
         return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
             if ((0, types_1.isClass)(subtype)) {
                 if (subtype.literalValue !== undefined) {
@@ -880,9 +890,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getTypeOfParameterAnnotation(paramTypeNode, paramCategory) {
         return getTypeOfAnnotation(paramTypeNode, {
             associateTypeVarsWithScope: true,
-            allowTypeVarTuple: paramCategory === 1 /* VarArgList */,
-            allowUnpackedTypedDict: paramCategory === 2 /* VarArgDictionary */,
-            allowUnpackedTuple: paramCategory === 1 /* VarArgList */,
+            allowTypeVarTuple: paramCategory === 1 /* ArgsList */,
+            allowUnpackedTypedDict: paramCategory === 2 /* KwargsDict */,
+            allowUnpackedTuple: paramCategory === 1 /* ArgsList */,
         });
     }
     function getTypeOfAnnotation(node, options) {
@@ -3338,7 +3348,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (baseType.details.isParamSpec) {
                     if (memberName === 'args') {
                         const paramNode = ParseTreeUtils.getEnclosingParameter(node);
-                        if (!paramNode || paramNode.category !== 1 /* VarArgList */) {
+                        if (!paramNode || paramNode.category !== 1 /* ArgsList */) {
                             addError(localize_1.Localizer.Diagnostic.paramSpecArgsUsage(), node);
                             return { type: types_1.UnknownType.create(isIncomplete), isIncomplete };
                         }
@@ -3346,7 +3356,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     if (memberName === 'kwargs') {
                         const paramNode = ParseTreeUtils.getEnclosingParameter(node);
-                        if (!paramNode || paramNode.category !== 2 /* VarArgDictionary */) {
+                        if (!paramNode || paramNode.category !== 2 /* KwargsDict */) {
                             addError(localize_1.Localizer.Diagnostic.paramSpecKwargsUsage(), node);
                             return { type: types_1.UnknownType.create(isIncomplete), isIncomplete };
                         }
@@ -5160,7 +5170,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);
@@ -5675,7 +5685,7 @@ 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, _b;
+        var _a, _b, _c;
         const returnTypes = [];
         const matchedOverloads = [];
         let isTypeIncomplete = false;
@@ -5764,19 +5774,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;
@@ -5799,7 +5812,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             effectiveReturnType = types_1.AnyType.create();
                         }
                         else {
-                            effectiveReturnType = types_1.UnknownType.createPossibleType(combinedTypes, possibleMatchInvolvesIncompleteUnknown);
+                            // If all of the return types are the same generic class,
+                            // replace the type arguments with Unknown. Otherwise return
+                            // an Unknown type that has associated "possible types" to aid
+                            // with completion suggestions.
+                            effectiveReturnType =
+                                (_c = (0, typeUtils_1.getCommonErasedType)(dedupedMatchResults)) !== null && _c !== void 0 ? _c : types_1.UnknownType.createPossibleType(combinedTypes, possibleMatchInvolvesIncompleteUnknown);
                         }
                     }
                     returnTypes.push(effectiveReturnType);
@@ -5840,6 +5858,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (matches.length < 2) {
             return matches;
         }
+        // If the relevance of some matches differs, filter out the ones that
+        // are lower relevance. This favors *args parameters in cases where
+        // a *args argument is used.
+        if (matches[0].matchResults.relevance !== matches[matches.length - 1].matchResults.relevance) {
+            matches = matches.filter((m) => m.matchResults.relevance === matches[0].matchResults.relevance);
+            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]];
@@ -5849,9 +5876,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return matches;
         }
         for (let i = 0; i < firstArgResults.length; i++) {
-            // If the arg is Any or Unknown, see if the corresponding
+            // If the arg contains Any or Unknown, see if the corresponding
             // parameter types differ in any way.
-            if ((0, types_1.isAnyOrUnknown)(firstArgResults[i].argType)) {
+            const anyOrUnknownInArg = (0, typeUtils_1.containsAnyOrUnknown)(firstArgResults[i].argType, /* recurse */ true);
+            if (anyOrUnknownInArg) {
                 const paramTypes = matches.map((match) => i < match.matchResults.argParams.length
                     ? match.matchResults.argParams[i].paramType
                     : types_1.UnknownType.create());
@@ -6487,6 +6515,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Build a map of parameters by name.
         const paramMap = new Map();
         paramDetails.params.forEach((paramInfo) => {
+            (0, debug_1.assert)(paramInfo !== undefined, 'paramInfo is undefined for param name map');
             const param = paramInfo.param;
             if (param.name && param.category === 0 /* Simple */) {
                 paramMap.set(param.name, {
@@ -6537,8 +6566,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (argList.some((arg) => arg.argumentCategory === 1 /* UnpackedList */)) {
             argList.forEach((arg) => {
                 if (arg.name) {
-                    const keywordParamIndex = paramDetails.params.findIndex((paramInfo) => paramInfo.param.name === arg.name.value &&
-                        paramInfo.param.category === 0 /* Simple */);
+                    const keywordParamIndex = paramDetails.params.findIndex((paramInfo) => {
+                        (0, debug_1.assert)(paramInfo, 'paramInfo entry is undefined fork kwargs check');
+                        return (paramInfo.param.name === arg.name.value &&
+                            paramInfo.param.category === 0 /* Simple */);
+                    });
                     // Is this a parameter that can be interpreted as either a keyword or a positional?
                     // If so, we'll treat it as a keyword parameter in this case because it's being
                     // targeted by a keyword argument.
@@ -6616,7 +6648,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             (0, debug_1.assert)(paramDetails.params[paramIndex], 'paramIndex params entry is undefined');
             const paramType = paramDetails.params[paramIndex].type;
             const paramName = paramDetails.params[paramIndex].param.name;
-            const isParamVariadic = paramDetails.params[paramIndex].param.category === 1 /* VarArgList */ &&
+            const isParamVariadic = paramDetails.params[paramIndex].param.category === 1 /* ArgsList */ &&
                 (0, types_1.isVariadicTypeVar)(paramType);
             if (argList[argIndex].argumentCategory === 1 /* UnpackedList */) {
                 let isArgCompatibleWithVariadic = false;
@@ -6677,7 +6709,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     listElementType =
                         (_e = (_d = getTypeOfIterator({ type: argType, isIncomplete: argTypeResult.isIncomplete }, 
                         /* isAsync */ false, argList[argIndex].valueExpression)) === null || _d === void 0 ? void 0 : _d.type) !== null && _e !== void 0 ? _e : types_1.UnknownType.create();
-                    if (paramDetails.params[paramIndex].param.category !== 1 /* VarArgList */) {
+                    if (paramDetails.params[paramIndex].param.category !== 1 /* ArgsList */) {
                         matchedUnpackedListOfUnknownLength = true;
                     }
                 }
@@ -6722,16 +6754,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     paramMap.has(paramName)) {
                     paramMap.get(paramName).argsReceived++;
                 }
-                if (advanceToNextArg ||
-                    paramDetails.params[paramIndex].param.category === 1 /* VarArgList */) {
+                if (advanceToNextArg || paramDetails.params[paramIndex].param.category === 1 /* ArgsList */) {
                     argIndex++;
                 }
                 if (isVariadicTypeVarFullyMatched ||
-                    paramDetails.params[paramIndex].param.category !== 1 /* VarArgList */) {
+                    paramDetails.params[paramIndex].param.category !== 1 /* ArgsList */) {
                     paramIndex++;
                 }
             }
-            else if (paramDetails.params[paramIndex].param.category === 1 /* VarArgList */) {
+            else if (paramDetails.params[paramIndex].param.category === 1 /* ArgsList */) {
                 trySetActive(argList[argIndex], paramDetails.params[paramIndex].param);
                 if (paramSpecArgList) {
                     paramSpecArgList.push(argList[argIndex]);
@@ -6747,7 +6778,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         effectiveParamType = paramType.tupleTypeArguments[0].type;
                     }
                     paramCategory = (0, types_1.isVariadicTypeVar)(effectiveParamType)
-                        ? 1 /* VarArgList */
+                        ? 1 /* ArgsList */
                         : 0 /* Simple */;
                     if (remainingArgCount <= remainingParamCount) {
                         if (remainingArgCount < remainingParamCount) {
@@ -6804,7 +6835,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let skippedArgsParam = false;
         if (positionalOnlyLimitIndex >= 0 &&
             paramIndex < positionalOnlyLimitIndex &&
-            paramDetails.params[paramIndex].param.category === 1 /* VarArgList */ &&
+            paramIndex < paramDetails.params.length &&
+            paramDetails.params[paramIndex].param.category === 1 /* ArgsList */ &&
             !(0, types_1.isParamSpec)(paramDetails.params[paramIndex].param.type)) {
             paramIndex++;
             skippedArgsParam = true;
@@ -6825,7 +6857,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // because it's permitted to pass zero arguments to *args.
                 argsRemainingCount--;
             }
-            const firstArgsParam = paramDetails.params.findIndex((paramInfo) => paramInfo.param.category === 1 /* VarArgList */ && !(0, types_1.isParamSpec)(paramInfo.param.type));
+            const firstArgsParam = paramDetails.params.findIndex((paramInfo) => paramInfo.param.category === 1 /* ArgsList */ && !(0, types_1.isParamSpec)(paramInfo.param.type));
             if (firstArgsParam >= paramIndex && firstArgsParam < positionalOnlyLimitIndex) {
                 // If there is another args parameter beyond the current param index,
                 // reduce the count by one because it's permitted to pass zero arguments
@@ -6887,7 +6919,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             else if (paramDetails.kwargsIndex !== undefined) {
                                 const paramType = paramDetails.params[paramDetails.kwargsIndex].type;
                                 validateArgTypeParams.push({
-                                    paramCategory: 2 /* VarArgDictionary */,
+                                    paramCategory: 2 /* KwargsDict */,
                                     paramType,
                                     requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                                     argument: {
@@ -6925,7 +6957,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         unpackedDictionaryArgType = types_1.AnyType.create();
                         if (typeResult.type.details.paramSpec) {
                             validateArgTypeParams.push({
-                                paramCategory: 2 /* VarArgDictionary */,
+                                paramCategory: 2 /* KwargsDict */,
                                 paramType: typeResult.type.details.paramSpec,
                                 requiresTypeVarMatching: false,
                                 argument: argList[argIndex],
@@ -7010,7 +7042,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             else {
                                 const paramType = paramDetails.params[paramDetails.kwargsIndex].type;
                                 validateArgTypeParams.push({
-                                    paramCategory: 2 /* VarArgDictionary */,
+                                    paramCategory: 2 /* KwargsDict */,
                                     paramType,
                                     requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                                     argument: argList[argIndex],
@@ -7054,7 +7086,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             }
                             if ((0, types_1.isParamSpec)(argType) && argType.paramSpecAccess === 'args') {
                                 validateArgTypeParams.push({
-                                    paramCategory: 1 /* VarArgList */,
+                                    paramCategory: 1 /* ArgsList */,
                                     paramType: typeResult.type.details.paramSpec,
                                     requiresTypeVarMatching: false,
                                     argument: argList[argIndex],
@@ -7157,6 +7189,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // already been matched, see if the type of that *args parameter is a variadic
             // type variable. If so, we'll preprocess those arguments and combine them
             // into a tuple.
+            (0, debug_1.assert)(paramDetails.argsIndex === undefined || paramDetails.argsIndex < paramDetails.params.length, 'paramDetails.argsIndex params entry is invalid');
             if (paramDetails.argsIndex !== undefined &&
                 paramDetails.argsIndex >= 0 &&
                 paramDetails.params[paramDetails.argsIndex].param.hasDeclaredType &&
@@ -7203,7 +7236,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             /* isUnpackedTuple */ true));
                         }
                         const combinedArg = {
-                            paramCategory: 1 /* VarArgList */,
+                            paramCategory: 1 /* ArgsList */,
                             paramType,
                             requiresTypeVarMatching: true,
                             argument: {
@@ -7253,6 +7286,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function validateFunctionArgumentTypesWithContext(errorNode, matchResults, typeVarContext, skipUnknownArgCheck = false, inferenceContext) {
         var _a;
         const type = matchResults.overload;
+        // 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) ||
@@ -7282,6 +7317,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             });
         }
         if (effectiveExpectedType) {
+            const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
             // Prepopulate the typeVarContext based on the specialized expected type if the
             // callee has a declared return type. This will allow us to more closely match
             // the expected type if possible.
@@ -7301,7 +7337,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, ParseTreeUtils.getTypeVarScopesForNode(errorNode));
+                    (0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, effectiveReturnType, effectiveExpectedType, tempTypeVarContext, liveTypeVarScopes, errorNode.start);
                     const genericReturnType = types_1.ClassType.cloneForSpecialization(effectiveReturnType, 
                     /* typeArguments */ undefined, 
                     /* isTypeArgumentExplicit */ false);
@@ -7317,6 +7353,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     });
                 }
             }
+            effectiveExpectedType = (0, typeUtils_1.transformExpectedType)(effectiveExpectedType, liveTypeVarScopes, errorNode.start);
             assignType(effectiveReturnType, effectiveExpectedType, 
             /* diag */ undefined, typeVarContext, 
             /* srcTypeVarContext */ undefined, effectiveFlags | 1024 /* PopulatingExpectedType */);
@@ -7328,7 +7365,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let isTypeIncomplete = matchResults.isTypeIncomplete;
         let argumentErrors = false;
         let specializedInitSelfType;
-        let anyOrUnknownArgument;
+        let accumulatedAnyOrUnknownArg;
         const typeCondition = (0, typeUtils_1.getTypeCondition)(type);
         if (type.boundTypeVarScopeId) {
             // If the function was bound to a class or object and was a constructor, a
@@ -7381,11 +7418,12 @@ 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();
+                signatureTracker.addSignature(type);
                 useSpeculativeMode(errorNode, () => {
                     matchResults.argParams.forEach((argParam) => {
                         if (!argParam.requiresTypeVarMatching) {
@@ -7413,17 +7451,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if (argResult.isTypeIncomplete) {
                             isTypeIncomplete = true;
                         }
-                        // If we skipped a overload arg during the first pass,
-                        // add another pass to ensure that we handle all of the
-                        // type variables.
+                        // If we skipped an overload arg or a bare type var during the first pass,
+                        // add another pass to ensure that we handle all of the type variables.
                         if (i === 0 && (argResult.skippedOverloadArg || argResult.skippedBareTypeVarExpectedType)) {
                             passCount++;
                         }
                     });
                 });
             }
-            // Lock the type var map so it cannot be modified and revalidate the
-            // arguments in a second pass.
+            // Lock the type var map so it cannot be modified when revalidating
+            // the arguments in a second pass.
             typeVarContext.lock();
         }
         let sawParamSpecArgs = false;
@@ -7431,6 +7468,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let condition = [];
         const argResults = [];
         const signatureTracker = new typeUtils_1.UniqueSignatureTracker();
+        signatureTracker.addSignature(type);
         matchResults.argParams.forEach((argParam) => {
             var _a;
             const argResult = validateArgType(argParam, typeVarContext, signatureTracker, { type, isIncomplete: matchResults.isTypeIncomplete }, {
@@ -7447,10 +7485,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (argResult.condition) {
                 condition = (_a = types_1.TypeCondition.combine(condition, argResult.condition)) !== null && _a !== void 0 ? _a : [];
             }
-            if ((0, types_1.isAnyOrUnknown)(argResult.argType)) {
-                anyOrUnknownArgument = anyOrUnknownArgument
-                    ? (0, typeUtils_1.preserveUnknown)(argResult.argType, anyOrUnknownArgument)
-                    : argResult.argType;
+            // Determine if the argument type contains an Any or Unknown. Accumulate
+            // these across all arguments.
+            const anyOrUnknownInArg = (0, typeUtils_1.containsAnyOrUnknown)(argResult.argType, /* recurs */ true);
+            if (anyOrUnknownInArg) {
+                accumulatedAnyOrUnknownArg = accumulatedAnyOrUnknownArg
+                    ? (0, typeUtils_1.preserveUnknown)(anyOrUnknownInArg, accumulatedAnyOrUnknownArg)
+                    : anyOrUnknownInArg;
             }
             if (type.details.paramSpec) {
                 if (argParam.argument.argumentCategory === 1 /* UnpackedList */) {
@@ -7511,21 +7552,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             type.details.typeVarScopeId === types_1.WildcardTypeVarScopeId) {
             eliminateUnsolvedInUnions = false;
         }
-        // In general, we want to replace in-scope TypeVars with Unknown
-        // if they were not solved. However, if the return type is a
-        // Callable, we'll leave the TypeVars unsolved because
-        // the call below to adjustCallableReturnType will "detach" these
-        // TypeVars from the scope of this function and "attach" them to
-        // the scope of the callable.
-        let unknownIfNotFound = !(0, types_1.isFunction)(returnType);
-        // We'll also leave TypeVars unsolved if the call is a recursive
+        // We'll leave TypeVars unsolved if the call is a recursive
         // call to a generic function.
-        const typeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
-        if (typeVarScopes.some((typeVarScope) => typeVarContext.hasSolveForScope(typeVarScope))) {
-            unknownIfNotFound = false;
-        }
+        const unknownIfNotFound = !ParseTreeUtils.getTypeVarScopesForNode(errorNode).some((typeVarScope) => typeVarContext.hasSolveForScope(typeVarScope));
         let specializedReturnType = (0, typeUtils_1.applySolvedTypeVars)(returnType, typeVarContext, {
             unknownIfNotFound,
+            unknownExemptTypeVars: getUnknownExemptTypeVarsForReturnType(type, returnType),
             useUnknownOverDefault: skipUnknownArgCheck,
             eliminateUnsolvedInUnions,
             applyInScopePlaceholders: true,
@@ -7570,7 +7602,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return {
             argumentErrors,
             argResults,
-            anyOrUnknownArgument,
+            anyOrUnknownArgument: accumulatedAnyOrUnknownArg,
             returnType: specializedReturnType,
             isTypeIncomplete,
             activeParam: matchResults.activeParam,
@@ -7578,6 +7610,32 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             overloadsUsedForCall: argumentErrors ? [] : [type],
         };
     }
+    // In general, all in-scope type variables left in a return type should be
+    // replaced with Unknown. However, if the return type is a callable that uses
+    // type vars that are found nowhere within the function's input parameters,
+    // we'll treat these as though they're scoped to the callable and leave them
+    // unsolved.
+    function getUnknownExemptTypeVarsForReturnType(functionType, returnType) {
+        if ((0, types_1.isFunction)(returnType) && !returnType.details.name) {
+            const returnTypeScopeId = returnType.details.typeVarScopeId;
+            // If one or more type vars found within the return type are scoped to
+            // the functionType but don't appear anywhere else within the functionType's
+            // input parameters, rescope them to the return type callable so they are
+            // not replaced with Unknown.
+            if (returnTypeScopeId && functionType.details.typeVarScopeId) {
+                let typeVarsInReturnType = (0, typeUtils_1.getTypeVarArgumentsRecursive)(returnType);
+                // Remove any type variables that appear in the function's input parameters.
+                functionType.details.parameters.forEach((param, index) => {
+                    if (param.hasDeclaredType) {
+                        const typeVarsInInputParam = (0, typeUtils_1.getTypeVarArgumentsRecursive)(param.type);
+                        typeVarsInReturnType = typeVarsInReturnType.filter((returnTypeVar) => !typeVarsInInputParam.some((inputTypeVar) => (0, types_1.isTypeSame)(returnTypeVar, inputTypeVar)));
+                    }
+                });
+                return typeVarsInReturnType;
+            }
+        }
+        return [];
+    }
     function adjustCallableReturnType(returnType) {
         // If the return type includes a generic Callable type, set the type var
         // scope to a wildcard to allow these type vars to be solved. This won't
@@ -7657,8 +7715,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (positionalIndexLimit < 0) {
             positionalIndexLimit = paramSpecParams.length;
         }
-        const argsParam = paramSpecParams.find((paramInfo) => paramInfo.category === 1 /* VarArgList */);
-        const kwargsParam = paramSpecParams.find((paramInfo) => paramInfo.category === 2 /* VarArgDictionary */);
+        const argsParam = paramSpecParams.find((paramInfo) => paramInfo.category === 1 /* ArgsList */);
+        const kwargsParam = paramSpecParams.find((paramInfo) => paramInfo.category === 2 /* KwargsDict */);
         const signatureTracker = new typeUtils_1.UniqueSignatureTracker();
         let sawUnpackedListArgument = false;
         let sawUnpackedDictArgument = false;
@@ -7704,7 +7762,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,
@@ -7718,7 +7776,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             else if (arg.argumentCategory === 1 /* UnpackedList */) {
                 sawUnpackedListArgument = true;
                 // See if there is an *args parameter.
-                const argsParam = paramSpecParams.find((param) => param.category === 1 /* VarArgList */ && param.name);
+                const argsParam = paramSpecParams.find((param) => param.category === 1 /* ArgsList */ && param.name);
                 if (argsParam && paramMap.has(argsParam.name)) {
                     // TODO - validate args type
                     paramMap.delete(argsParam.name);
@@ -7728,7 +7786,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 sawUnpackedDictArgument = true;
                 (0, debug_1.assert)(arg.argumentCategory === 2 /* UnpackedDictionary */);
                 // See if there is an *kwargs parameter.
-                const kwargsParam = paramSpecParams.find((param) => param.category === 2 /* VarArgDictionary */);
+                const kwargsParam = paramSpecParams.find((param) => param.category === 2 /* KwargsDict */);
                 if (kwargsParam && paramMap.has(kwargsParam.name)) {
                     // TODO - validate kwargs type
                     paramMap.delete(kwargsParam.name);
@@ -7856,7 +7914,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If we're assigning to a var arg dictionary with a TypeVar type,
         // strip literals before performing the assignment. This is used in
         // places like a dict constructor.
-        if (argParam.paramCategory === 2 /* VarArgDictionary */ && (0, types_1.isTypeVar)(argParam.paramType)) {
+        if (argParam.paramCategory === 2 /* KwargsDict */ && (0, types_1.isTypeVar)(argParam.paramType)) {
             argType = stripLiteralValue(argType);
         }
         // If there's a constraint filter, apply it to top-level type variables
@@ -7982,7 +8040,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
@@ -7994,7 +8052,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' &&
@@ -8685,7 +8743,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);
@@ -8947,7 +9005,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);
@@ -9168,7 +9226,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));
             });
         }
@@ -9236,22 +9296,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If we're speculatively evaluating the lambda, create another speculative
         // evaluation scope for the return expression and do not allow retention
         // of the cached types.
-        const inferLambdaReturnType = () => {
+        // 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
+        // doesn't know about that context.
+        useSpeculativeMode(isSpeculativeModeInUse(node) || (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete) ? node.expression : undefined, () => {
             const returnTypeResult = getTypeOfExpression(node.expression, 
             /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedReturnType));
             functionType.inferredReturnType = returnTypeResult.type;
             if (returnTypeResult.isIncomplete) {
                 isIncomplete = true;
             }
-        };
-        // 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
-        // doesn't know about that context.
-        useSpeculativeMode(isSpeculativeModeInUse(node) || (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete) ? node.expression : undefined, () => {
-            inferLambdaReturnType();
-        }, 
-        /* allowCacheRetention */ false);
+        }, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType);
         // Mark the function type as no longer being evaluated.
         functionType.details.flags &= ~131072 /* PartiallyEvaluated */;
         return { type: functionType, isIncomplete };
@@ -9260,13 +9316,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         var _a;
         let isIncomplete = false;
         let typeErrors = false;
+        // If any of the "for" clauses are marked async or any of the "if" clauses
+        // or the final expression contain an "await" operator anywhere within
+        // the expression, it is treated as an async generator.
         let isAsync = node.forIfNodes.some((comp) => {
             return ((comp.nodeType === 33 /* ListComprehensionFor */ && comp.isAsync) ||
                 (comp.nodeType === 34 /* ListComprehensionIf */ &&
-                    comp.testExpression.nodeType === 6 /* Await */));
+                    ParseTreeUtils.containsAwaitNode(comp.testExpression)));
         });
         let type = types_1.UnknownType.create();
-        if (node.expression.nodeType === 6 /* Await */) {
+        if (ParseTreeUtils.containsAwaitNode(node.expression)) {
             isAsync = true;
         }
         let expectedElementType;
@@ -9506,12 +9565,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     const paramName = `__p${index.toString()}`;
                     if ((0, types_1.isVariadicTypeVar)(entryType)) {
                         validateVariadicTypeVarIsUnpacked(entryType, entry.node);
-                        paramCategory = 1 /* VarArgList */;
+                        paramCategory = 1 /* ArgsList */;
                         noteSawUnpacked(entry);
                     }
                     else if (validateTypeArg(entry, { allowUnpackedTuples: true })) {
                         if ((0, types_1.isUnpackedClass)(entryType)) {
-                            paramCategory = 1 /* VarArgList */;
+                            paramCategory = 1 /* ArgsList */;
                             noteSawUnpacked(entry);
                         }
                     }
@@ -9704,7 +9763,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) {
@@ -10995,7 +11056,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);
@@ -11829,7 +11891,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);
@@ -11896,17 +11959,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             param.defaultValue.constType === 26 /* None */ &&
             !(0, typeUtils_1.isOptionalType)(type) &&
             !AnalyzerNodeInfo.getFileInfo(param).diagnosticRuleSet.strictParameterNoneValue) {
-            type = (0, types_1.combineTypes)([type, types_1.NoneType.createInstance()]);
-        }
-        else if ((0, types_1.isTypeVar)(type) && param.defaultValue && type.scopeType === 1 /* Function */) {
-            // Handle the case where a default argument type is provided when the
-            // parameter is annotated with a "raw" function-scoped type variable, as in:
-            //   "def foo(value: T = 3)"
-            // In this case, we need to include the default value type in a union.
-            const defaultArgType = getTypeOfExpression(param.defaultValue, 1 /* ConvertEllipsisToAny */, (0, typeUtils_1.makeInferenceContext)(type)).type;
-            if (!(0, types_1.isAny)(defaultArgType)) {
-                type = (0, types_1.combineTypes)([type, defaultArgType]);
-            }
+            return (0, types_1.combineTypes)([type, types_1.NoneType.createInstance()]);
         }
         return type;
     }
@@ -11990,7 +12043,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             case 0 /* Simple */: {
                 return type;
             }
-            case 1 /* VarArgList */: {
+            case 1 /* ArgsList */: {
                 if ((0, types_1.isTypeVar)(type) && type.paramSpecAccess) {
                     return type;
                 }
@@ -12003,7 +12056,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 return types_1.UnknownType.create();
             }
-            case 2 /* VarArgDictionary */: {
+            case 2 /* KwargsDict */: {
                 // Leave a ParamSpec alone.
                 if ((0, types_1.isTypeVar)(type) && type.paramSpecAccess) {
                     return type;
@@ -12961,9 +13014,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             getTypeOfAnnotation(annotationNode, {
                 isVariableAnnotation: ((_a = annotationNode.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 54 /* TypeAnnotation */,
                 allowUnpackedTuple: annotationParent.nodeType === 41 /* Parameter */ &&
-                    annotationParent.category === 1 /* VarArgList */,
+                    annotationParent.category === 1 /* ArgsList */,
                 allowUnpackedTypedDict: annotationParent.nodeType === 41 /* Parameter */ &&
-                    annotationParent.category === 2 /* VarArgDictionary */,
+                    annotationParent.category === 2 /* KwargsDict */,
             });
             return;
         }
@@ -13879,11 +13932,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // types, under the assumption that we're performing speculative evaluations.
     // If speculativeNode is undefined, speculative mode is not used. This is
     // useful in cases where we conditionally want to use speculative mode.
-    function useSpeculativeMode(speculativeNode, callback, allowCacheRetention = true) {
+    function useSpeculativeMode(speculativeNode, callback, dependentType) {
         if (!speculativeNode) {
             return callback();
         }
-        speculativeTypeTracker.enterSpeculativeContext(speculativeNode, allowCacheRetention);
+        speculativeTypeTracker.enterSpeculativeContext(speculativeNode, dependentType);
         try {
             const result = callback();
             speculativeTypeTracker.leaveSpeculativeContext();
@@ -15006,6 +15059,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) {
@@ -15358,10 +15412,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);
@@ -15409,6 +15463,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();
@@ -16638,7 +16706,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const srcPositionalsToPack = srcDetails.params.slice(destDetails.argsIndex, srcLastToPackIndex - suffixLength);
         const srcTupleTypes = [];
         srcPositionalsToPack.forEach((entry) => {
-            if (entry.param.category === 1 /* VarArgList */) {
+            if (entry.param.category === 1 /* ArgsList */) {
                 if ((0, types_1.isUnpackedVariadicTypeVar)(entry.type)) {
                     srcTupleTypes.push({ type: entry.type, isUnbounded: false });
                 }
@@ -16670,7 +16738,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 ...srcDetails.params.slice(0, destDetails.argsIndex),
                 {
                     param: {
-                        category: 1 /* VarArgList */,
+                        category: 1 /* ArgsList */,
                         name: '_arg_combined',
                         isNameSynthesized: true,
                         hasDeclaredType: true,
@@ -16682,9 +16750,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 },
                 ...srcDetails.params.slice(destDetails.argsIndex + srcPositionalsToPack.length, srcDetails.params.length),
             ];
-            const argsIndex = srcDetails.params.findIndex((param) => param.param.category === 1 /* VarArgList */);
+            const argsIndex = srcDetails.params.findIndex((param) => param.param.category === 1 /* ArgsList */);
             srcDetails.argsIndex = argsIndex >= 0 ? argsIndex : undefined;
-            const kwargsIndex = srcDetails.params.findIndex((param) => param.param.category === 2 /* VarArgDictionary */);
+            const kwargsIndex = srcDetails.params.findIndex((param) => param.param.category === 2 /* KwargsDict */);
             srcDetails.kwargsIndex = kwargsIndex >= 0 ? kwargsIndex : undefined;
             const firstKeywordOnlyIndex = srcDetails.params.findIndex((param) => param.source === parameterUtils_1.ParameterSource.KeywordOnly);
             srcDetails.firstKeywordOnlyIndex = firstKeywordOnlyIndex >= 0 ? firstKeywordOnlyIndex : undefined;
@@ -16722,8 +16790,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (destParamName && !(0, symbolNameUtils_1.isPrivateOrProtectedName)(destParamName) && !(0, symbolNameUtils_1.isPrivateOrProtectedName)(srcParamName)) {
                 const isDestPositionalOnly = destParam.source === parameterUtils_1.ParameterSource.PositionOnly;
                 if (!isDestPositionalOnly &&
-                    destParam.param.category !== 1 /* VarArgList */ &&
-                    srcParam.param.category !== 1 /* VarArgList */ &&
+                    destParam.param.category !== 1 /* ArgsList */ &&
+                    srcParam.param.category !== 1 /* ArgsList */ &&
                     destParamName !== srcParamName) {
                     diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.Localizer.DiagnosticAddendum.functionParamName().format({
                         srcName: srcParamName,
@@ -17019,7 +17087,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             matchedParamCount++;
                         }
                     }
-                    else if (!p.name && p.category === 0 /* Simple */ && remainingParams.length === 0) {
+                    else if ((0, types_1.isPositionOnlySeparator)(p) && remainingParams.length === 0) {
                         // Don't bother pushing a position-only separator if it
                         // is the first remaining param.
                     }
@@ -17142,7 +17210,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];
@@ -17239,25 +17307,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) {
@@ -17348,7 +17433,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     baseParam.category === 0 /* Simple */ &&
                     baseParam.name !== overrideParam.name) {
                     if (overrideParam.category === 0 /* Simple */) {
-                        if (enforceParamNames) {
+                        if (enforceParamNames && !baseParam.isNameSynthesized) {
                             if (overrideParamDetails.params[i].source === parameterUtils_1.ParameterSource.PositionOnly) {
                                 diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNamePositionOnly().format({
                                     index: i + 1,
@@ -17368,11 +17453,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 else if (i < overrideParamDetails.positionOnlyParamCount &&
                     i >= baseParamDetails.positionOnlyParamCount) {
-                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNamePositionOnly().format({
-                        index: i + 1,
-                        baseName: baseParam.name || '*',
-                    }));
-                    canOverride = false;
+                    if (!baseParam.isNameSynthesized) {
+                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNamePositionOnly().format({
+                            index: i + 1,
+                            baseName: baseParam.name || '*',
+                        }));
+                        canOverride = false;
+                    }
                 }
                 else {
                     const baseParamType = baseParamDetails.params[i].type;
@@ -17483,6 +17570,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 canOverride = false;
             }
         }
+        // Verify that one or the other method doesn't contain a ParamSpec.
+        if (baseMethod.details.paramSpec && !overrideMethod.details.paramSpec) {
+            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.paramSpecMissingInOverride());
+            canOverride = false;
+        }
         // Now check the return type.
         const baseReturnType = getFunctionEffectiveReturnType(baseMethod);
         const overrideReturnType = getFunctionEffectiveReturnType(overrideMethod);