@zzzen/pyright-internal 1.2.0-dev.20230416 → 1.2.0-dev.20230430

package/dist/analyzer/typeEvaluator.js

@@ -751,9 +751,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((flags & 1 /* ConvertEllipsisToAny */) !== 0) {
             typeResult = { type: types_1.AnyType.create(/* isEllipsis */ true) };
         }
-        else if ((flags & 512 /* ConvertEllipsisToUnknown */) !== 0) {
-            typeResult = { type: types_1.UnknownType.create() };
-        }
         else {
             const ellipsisType = getBuiltInObject(node, 'ellipsis') || types_1.AnyType.create();
             typeResult = { type: ellipsisType };
@@ -5751,7 +5748,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // Use speculative mode so we don't output any diagnostics or
                 // record any final types in the type cache.
                 const callResult = useSpeculativeMode(errorNode, () => {
-                    return validateFunctionArgumentTypesWithExpectedType(errorNode, matchResults, effectiveTypeVarContext, 
+                    return validateFunctionArgumentTypesWithContext(errorNode, matchResults, effectiveTypeVarContext, 
                     /* skipUnknownArgCheck */ true, inferenceContext);
                 });
                 if (callResult.isTypeIncomplete) {
@@ -5835,7 +5832,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const finalTypeVarContext = typeVarContext !== null && typeVarContext !== void 0 ? typeVarContext : matchedOverloads[0].typeVarContext;
         finalTypeVarContext.unlock();
         finalTypeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(matchedOverloads[0].overload));
-        const finalCallResult = validateFunctionArgumentTypesWithExpectedType(errorNode, matchedOverloads[0].matchResults, finalTypeVarContext, skipUnknownArgCheck, inferenceContext);
+        const finalCallResult = validateFunctionArgumentTypesWithContext(errorNode, matchedOverloads[0].matchResults, finalTypeVarContext, skipUnknownArgCheck, inferenceContext);
         if (finalCallResult.isTypeIncomplete) {
             isTypeIncomplete = true;
         }
@@ -5963,7 +5960,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 effectiveTypeVarContext.addSolveForScope(lastMatch.overload.details.constructorTypeVarScopeId);
             }
             effectiveTypeVarContext.unlock();
-            return validateFunctionArgumentTypesWithExpectedType(errorNode, lastMatch, effectiveTypeVarContext, skipUnknownArgCheck, inferenceContext);
+            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
@@ -6096,13 +6093,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // for each of the subtypes that comprise the expected type. If
             // one or more analyzes with no errors, use those results.
             if (inferenceContext) {
-                const expectedCallResult = validateConstructorMethodWithExpectedType(errorNode, argList, type, skipUnknownArgCheck, inferenceContext, initMethodType);
+                const expectedCallResult = validateConstructorMethodWithContext(errorNode, argList, type, skipUnknownArgCheck, inferenceContext, initMethodType);
                 if (expectedCallResult && !expectedCallResult.argumentErrors) {
                     returnType = expectedCallResult.returnType;
                     if (expectedCallResult.isTypeIncomplete) {
                         isTypeIncomplete = true;
                     }
-                    overloadsUsedForCall.push(...expectedCallResult.overloadsUsedForCall);
                 }
             }
             if (!returnType) {
@@ -6111,18 +6107,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(type));
                 typeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(initMethodType));
                 const callResult = validateCallArguments(errorNode, argList, { type: initMethodType }, typeVarContext, skipUnknownArgCheck);
+                let adjustedClassType = type;
+                if (callResult.specializedInitSelfType &&
+                    (0, types_1.isClassInstance)(callResult.specializedInitSelfType) &&
+                    types_1.ClassType.isSameGenericClass(callResult.specializedInitSelfType, type)) {
+                    adjustedClassType = types_1.ClassType.cloneAsInstantiable(callResult.specializedInitSelfType);
+                }
+                returnType = applyExpectedTypeForConstructor(adjustedClassType, 
+                /* inferenceContext */ undefined, typeVarContext);
+                if (callResult.isTypeIncomplete) {
+                    isTypeIncomplete = true;
+                }
                 if (!callResult.argumentErrors) {
-                    let adjustedClassType = type;
-                    if (callResult.specializedInitSelfType &&
-                        (0, types_1.isClassInstance)(callResult.specializedInitSelfType) &&
-                        types_1.ClassType.isSameGenericClass(callResult.specializedInitSelfType, type)) {
-                        adjustedClassType = types_1.ClassType.cloneAsInstantiable(callResult.specializedInitSelfType);
-                    }
-                    returnType = applyExpectedTypeForConstructor(adjustedClassType, 
-                    /* inferenceContext */ undefined, typeVarContext);
-                    if (callResult.isTypeIncomplete) {
-                        isTypeIncomplete = true;
-                    }
                     overloadsUsedForCall.push(...callResult.overloadsUsedForCall);
                 }
                 else {
@@ -6163,7 +6159,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // If there is an expected type that was not applied above when
                 // handling the __init__ method, try to apply it with the __new__ method.
                 if (inferenceContext && !returnType) {
-                    const expectedCallResult = validateConstructorMethodWithExpectedType(errorNode, argList, type, skipUnknownArgCheck, inferenceContext, constructorMethodType);
+                    const expectedCallResult = validateConstructorMethodWithContext(errorNode, argList, type, skipUnknownArgCheck, inferenceContext, constructorMethodType);
                     if (expectedCallResult && !expectedCallResult.argumentErrors) {
                         newReturnType = expectedCallResult.returnType;
                         returnType = newReturnType;
@@ -6198,6 +6194,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 else if (!newReturnType) {
                     newReturnType = callResult.returnType;
+                    if (overloadsUsedForCall.length === 0) {
+                        overloadsUsedForCall.push(...callResult.overloadsUsedForCall);
+                    }
                     // If the constructor returned an object whose type matches the class of
                     // the original type being constructed, use the return type in case it was
                     // specialized. If it doesn't match, we'll fall back on the assumption that
@@ -6304,22 +6303,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // For a constructor call that targets a generic class and an "expected type"
     // (i.e. bidirectional inference), this function attempts to infer the correct
     // specialized return type for the constructor.
-    function validateConstructorMethodWithExpectedType(errorNode, argList, type, skipUnknownArgCheck, inferenceContext, constructorMethodType) {
+    function validateConstructorMethodWithContext(errorNode, argList, type, skipUnknownArgCheck, inferenceContext, constructorMethodType) {
         let isTypeIncomplete = false;
         let argumentErrors = false;
         const overloadsUsedForCall = [];
         const returnType = (0, typeUtils_1.mapSubtypes)(inferenceContext.expectedType, (expectedSubType) => {
             expectedSubType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(expectedSubType);
             const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(type));
+            typeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(constructorMethodType));
             if ((0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, types_1.ClassType.cloneAsInstance(type), expectedSubType, typeVarContext, getTypeVarScopesForNode(errorNode))) {
+                const specializedConstructor = (0, typeUtils_1.applySolvedTypeVars)(constructorMethodType, typeVarContext);
                 let callResult;
                 useSpeculativeMode(errorNode, () => {
-                    callResult = validateCallArguments(errorNode, argList, { type: constructorMethodType }, typeVarContext.clone(), skipUnknownArgCheck);
+                    callResult = validateCallArguments(errorNode, argList, { type: specializedConstructor }, typeVarContext.clone(), skipUnknownArgCheck);
                 });
                 if (!callResult.argumentErrors) {
                     // Call validateCallArguments again, this time without speculative
                     // mode, so any errors are reported.
-                    callResult = validateCallArguments(errorNode, argList, { type: constructorMethodType }, typeVarContext, skipUnknownArgCheck);
+                    callResult = validateCallArguments(errorNode, argList, { type: specializedConstructor }, typeVarContext, skipUnknownArgCheck);
                     if (callResult.isTypeIncomplete) {
                         isTypeIncomplete = true;
                     }
@@ -6327,7 +6328,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         argumentErrors = true;
                     }
                     overloadsUsedForCall.push(...callResult.overloadsUsedForCall);
-                    return applyExpectedSubtypeForConstructor(type, expectedSubType, typeVarContext);
+                    return applyExpectedSubtypeForConstructor(type, expectedSubType, inferenceContext, typeVarContext);
                 }
             }
             return undefined;
@@ -6337,9 +6338,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return { returnType, isTypeIncomplete, argumentErrors, overloadsUsedForCall };
     }
-    function applyExpectedSubtypeForConstructor(type, expectedSubtype, typeVarContext) {
+    function applyExpectedSubtypeForConstructor(type, expectedSubtype, inferenceContext, typeVarContext) {
+        var _a;
         const specializedType = (0, typeUtils_1.applySolvedTypeVars)(types_1.ClassType.cloneAsInstance(type), typeVarContext);
-        if (!assignType(expectedSubtype, specializedType)) {
+        if (!assignType(expectedSubtype, specializedType, 
+        /* diag */ undefined, 
+        /* destTypeVarContext */ (_a = inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext) === null || _a === void 0 ? void 0 : _a.clone(), 
+        /* srcTypeVarContext */ undefined)) {
             return undefined;
         }
         // If the expected type is "Any", transform it to an Any.
@@ -6354,7 +6359,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let unsolvedTypeVarsAreUnknown = true;
         if (inferenceContext) {
             const specializedExpectedType = (0, typeUtils_1.mapSubtypes)(inferenceContext.expectedType, (expectedSubtype) => {
-                return applyExpectedSubtypeForConstructor(type, expectedSubtype, typeVarContext);
+                return applyExpectedSubtypeForConstructor(type, expectedSubtype, inferenceContext, typeVarContext);
             });
             if (!(0, types_1.isNever)(specializedExpectedType)) {
                 return specializedExpectedType;
@@ -7578,13 +7583,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // After having matched arguments with parameters, this function evaluates the
     // types of each argument expression and validates that the resulting type is
     // compatible with the declared type of the corresponding parameter.
-    function validateFunctionArgumentTypesWithExpectedType(errorNode, matchResults, typeVarContext, skipUnknownArgCheck = false, inferenceContext) {
+    function validateFunctionArgumentTypesWithContext(errorNode, matchResults, typeVarContext, skipUnknownArgCheck = false, inferenceContext) {
         var _a;
         const type = matchResults.overload;
         if (!inferenceContext ||
             (0, types_1.isAnyOrUnknown)(inferenceContext.expectedType) ||
             (0, types_1.isNever)(inferenceContext.expectedType) ||
-            (0, typeUtils_1.requiresSpecialization)(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);
@@ -7599,17 +7603,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // We may or may not be able to make use of the expected type. We'll evaluate
         // speculatively to see if using the expected type works.
         if ((0, types_1.isUnion)(inferenceContext.expectedType)) {
-            let speculativeResults;
             useSpeculativeMode(errorNode, () => {
                 const typeVarContextCopy = typeVarContext.clone();
                 assignType(effectiveReturnType, effectiveExpectedType, 
                 /* diag */ undefined, typeVarContextCopy, 
                 /* srcTypeVarContext */ undefined, effectiveFlags | 1024 /* PopulatingExpectedType */);
-                speculativeResults = validateFunctionArgumentTypes(errorNode, matchResults, typeVarContextCopy, skipUnknownArgCheck);
+                const speculativeResults = validateFunctionArgumentTypes(errorNode, matchResults, typeVarContextCopy, skipUnknownArgCheck);
+                if (speculativeResults === null || speculativeResults === void 0 ? void 0 : speculativeResults.argumentErrors) {
+                    effectiveExpectedType = undefined;
+                }
             });
-            if (speculativeResults && speculativeResults.argumentErrors) {
-                effectiveExpectedType = undefined;
-            }
         }
         if (effectiveExpectedType) {
             // Prepopulate the typeVarContext based on the specialized expected type if the
@@ -7628,6 +7631,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 /* isTypeArgumentExplicit */ false);
                 effectiveExpectedType = (0, typeUtils_1.applySolvedTypeVars)(genericReturnType, tempTypeVarContext);
             }
+            else if ((0, types_1.isFunction)(effectiveReturnType)) {
+                // If the return type is a callable and the expected type is a union that
+                // includes one or more non-callables, filter those out.
+                if ((0, types_1.isUnion)(effectiveExpectedType)) {
+                    effectiveExpectedType = (0, typeUtils_1.mapSubtypes)(effectiveExpectedType, (subtype) => {
+                        return (0, typeUtils_1.isCallableType)(subtype) ? subtype : undefined;
+                    });
+                }
+            }
             assignType(effectiveReturnType, effectiveExpectedType, 
             /* diag */ undefined, typeVarContext, 
             /* srcTypeVarContext */ undefined, effectiveFlags | 1024 /* PopulatingExpectedType */);
@@ -7706,12 +7718,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         // is an overload function, skip it during the first pass
                         // because the selection of the proper overload may depend
                         // on type arguments supplied by other function arguments.
-                        // Set useNarrowBoundOnly to true the first time through
-                        // the loop if we're going to go through the loop multiple
-                        // times.
-                        const argResult = validateArgType(argParam, typeVarContext, signatureTracker, { type, isIncomplete: matchResults.isTypeIncomplete }, skipUnknownArgCheck, 
-                        /* skipOverloadArg */ i === 0, 
-                        /* isFirstPass */ passCount > 1 && i === 0, typeCondition);
+                        // We set useNarrowBoundOnly to true if this is the first
+                        // (but not only) pass through the parameter list because a wide
+                        // bound on a TypeVar (if a narrow bound has not yet been
+                        // established) will unnecessarily constrain the expected type.
+                        // If the param type is a "bare" TypeVar, don't use it as an
+                        // expected type during the first pass. This causes problems for
+                        // cases where the the call expression result can influence the
+                        // type of the TypeVar, such as in the expression "min(1, max(2, 0.5))".
+                        const argResult = validateArgType(argParam, typeVarContext, signatureTracker, { type, isIncomplete: matchResults.isTypeIncomplete }, {
+                            skipUnknownArgCheck,
+                            skipOverloadArg: i === 0,
+                            skipBareTypeVarExpectedType: i === 0,
+                            useNarrowBoundOnly: passCount > 1 && i === 0,
+                            conditionFilter: typeCondition,
+                        });
                         if (argResult.isTypeIncomplete) {
                             isTypeIncomplete = true;
                         }
@@ -7735,9 +7756,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const signatureTracker = new typeUtils_1.UniqueSignatureTracker();
         matchResults.argParams.forEach((argParam) => {
             var _a;
-            const argResult = validateArgType(argParam, typeVarContext, signatureTracker, { type, isIncomplete: matchResults.isTypeIncomplete }, skipUnknownArgCheck, 
-            /* skipOverloadArg */ false, 
-            /* isFirstPass */ false, typeCondition);
+            const argResult = validateArgType(argParam, typeVarContext, signatureTracker, { type, isIncomplete: matchResults.isTypeIncomplete }, {
+                skipUnknownArgCheck,
+                conditionFilter: typeCondition,
+            });
             argResults.push(argResult);
             if (!argResult.isCompatible) {
                 argumentErrors = true;
@@ -7907,7 +7929,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 overloadsUsedForCall: [],
             };
         }
-        return validateFunctionArgumentTypesWithExpectedType(errorNode, matchResults, typeVarContext, skipUnknownArgCheck, inferenceContext);
+        return validateFunctionArgumentTypesWithContext(errorNode, matchResults, typeVarContext, skipUnknownArgCheck, inferenceContext);
     }
     // Determines whether the specified argument list satisfies the function
     // signature bound to the specified ParamSpec. Return value indicates success.
@@ -7958,6 +7980,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const argsParam = paramSpecParams.find((paramInfo) => paramInfo.category === 1 /* VarArgList */);
         const kwargsParam = paramSpecParams.find((paramInfo) => paramInfo.category === 2 /* VarArgDictionary */);
         const signatureTracker = new typeUtils_1.UniqueSignatureTracker();
+        let sawUnpackedListArgument = false;
+        let sawUnpackedDictArgument = false;
         argList.forEach((arg) => {
             var _a;
             if (arg.argumentCategory === 0 /* Simple */) {
@@ -8005,18 +8029,30 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         argument: arg,
                         errorNode: arg.valueExpression || errorNode,
                     }, srcTypeVarContext, signatureTracker, 
-                    /* functionType */ undefined, 
-                    /* skipUnknownArgCheck */ false, 
-                    /* skipOverloadArg */ false, 
-                    /* isFirstPass */ false, conditionFilter);
+                    /* functionType */ undefined, { conditionFilter });
                     if (!argResult.isCompatible) {
                         reportedArgError = true;
                     }
                 }
             }
+            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);
+                if (argsParam && paramMap.has(argsParam.name)) {
+                    // TODO - validate args type
+                    paramMap.delete(argsParam.name);
+                }
+            }
             else {
-                // TODO - handle *args and **kwargs
-                paramMap.clear();
+                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 */);
+                if (kwargsParam && paramMap.has(kwargsParam.name)) {
+                    // TODO - validate kwargs type
+                    paramMap.delete(kwargsParam.name);
+                }
             }
         });
         // Report any missing parameters.
@@ -8027,7 +8063,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const paramInfo = paramMap.get(name);
                 return paramInfo.category === 0 /* Simple */ && !paramInfo.hasDefault;
             });
-            if (unassignedParams.length > 0 && !paramSpecType.details.paramSpec) {
+            if (unassignedParams.length > 0 &&
+                !paramSpecType.details.paramSpec &&
+                !sawUnpackedListArgument &&
+                !sawUnpackedDictArgument) {
                 const missingParamNames = unassignedParams.map((p) => `"${p}"`).join(', ');
                 addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, unassignedParams.length === 1
                     ? localize_1.Localizer.Diagnostic.argMissingForParam().format({ name: missingParamNames })
@@ -8040,7 +8079,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return !reportedArgError;
     }
-    function validateArgType(argParam, typeVarContext, signatureTracker, typeResult, skipUnknownCheck, skipOverloadArg, isFirstPass, conditionFilter) {
+    function validateArgType(argParam, typeVarContext, signatureTracker, typeResult, options) {
         var _a;
         let argType;
         let expectedTypeDiag;
@@ -8048,19 +8087,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let isCompatible = true;
         const functionName = typeResult === null || typeResult === void 0 ? void 0 : typeResult.type.details.name;
         if (argParam.argument.valueExpression) {
-            // If the param type is a "bare" TypeVar, don't use it as an expected
-            // type during the first pass. This causes problems for cases where the the
-            // call expression result can influence the type of the TypeVar, such as in
-            // the expression "min(1, max(2, 0.5))". We set useNarrowBoundOnly
-            // to true if this is the first pass through the parameter list because
-            // a wide bound on a TypeVar (if a narrow bound has not yet been established)
-            // will unnecessarily constrain the expected type.
             let expectedType;
-            if (!isFirstPass ||
+            if (!options.skipBareTypeVarExpectedType ||
                 !(0, types_1.isTypeVar)(argParam.paramType) ||
                 argParam.paramType.scopeId !== (typeResult === null || typeResult === void 0 ? void 0 : typeResult.type.details.typeVarScopeId)) {
                 expectedType = (0, typeUtils_1.applySolvedTypeVars)(argParam.paramType, typeVarContext, {
-                    useNarrowBoundOnly: isFirstPass,
+                    useNarrowBoundOnly: !!options.useNarrowBoundOnly,
                 });
             }
             // If the expected type is unknown, don't use an expected type. Instead,
@@ -8129,8 +8161,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If there's a constraint filter, apply it to top-level type variables
         // if appropriate. This doesn't properly handle non-top-level constrained
         // type variables.
-        if (conditionFilter) {
-            argType = mapSubtypesExpandTypeVars(argType, conditionFilter, (expandedSubtype) => {
+        if (options.conditionFilter) {
+            argType = mapSubtypesExpandTypeVars(argType, options.conditionFilter, (expandedSubtype) => {
                 return expandedSubtype;
             });
         }
@@ -8149,7 +8181,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If we are asked to skip overload arguments, determine whether the argument
         // is an explicit overload type, an overloaded class constructor, or a
         // an overloaded callback protocol.
-        if (skipOverloadArg) {
+        if (options.skipOverloadArg) {
             if ((0, types_1.isOverloadedFunction)(argType)) {
                 return { isCompatible, argType, isTypeIncomplete, skippedOverloadArg: true, condition };
             }
@@ -8225,7 +8257,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             return { isCompatible: false, argType, isTypeIncomplete, condition };
         }
-        if (!skipUnknownCheck) {
+        if (!options.skipUnknownArgCheck) {
             const simplifiedType = (0, types_1.removeUnbound)(argType);
             const fileInfo = AnalyzerNodeInfo.getFileInfo(argParam.errorNode);
             const getDiagAddendum = () => {
@@ -8915,16 +8947,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     // assume that it was due to a "None" not being supported. Report
                     // this as a reportOptionalOperand diagnostic rather than a
                     // reportGeneralTypeIssues diagnostic.
-                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportOptionalOperand, diagnosticRules_1.DiagnosticRule.reportOptionalOperand, localize_1.Localizer.Diagnostic.noneOperator().format({
+                    addDiagnostic(fileInfo.diagnosticRuleSet.reportOptionalOperand, diagnosticRules_1.DiagnosticRule.reportOptionalOperand, localize_1.Localizer.Diagnostic.noneOperator().format({
                         operator: ParseTreeUtils.printOperator(node.operator),
                     }), node.leftExpression);
                 }
                 else {
+                    // If neither the LHS or RHS are unions, don't include a diagnostic addendum
+                    // because it will be redundant with the main diagnostic message. The addenda
+                    // are useful only if union expansion was used for one or both operands.
+                    let diagString = '';
+                    if ((0, types_1.isUnion)(makeTopLevelTypeVarsConcrete(leftType)) ||
+                        (0, types_1.isUnion)(makeTopLevelTypeVarsConcrete(rightType))) {
+                        diagString = diag.getString();
+                    }
                     addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeNotSupportBinaryOperator().format({
                         operator: ParseTreeUtils.printOperator(node.operator),
                         leftType: printType(leftType),
                         rightType: printType(rightType),
-                    }) + diag.getString(), node);
+                    }) + diagString, node);
                 }
             }
             type = types_1.UnknownType.create();
@@ -9472,7 +9512,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const expectedValueType = specializedDict.typeArguments[1];
         // Infer the key and value types if possible.
         if (getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, 
-        /* forceStrictInference */ true, expectedKeyType, expectedValueType, undefined, expectedDiagAddendum)) {
+        /* forceStrictInference */ true, expectedKeyType, expectedValueType, undefined, expectedDiagAddendum, inferenceContext)) {
             isIncomplete = true;
         }
         // Dict and MutableMapping types have invariant value types, so they
@@ -9481,10 +9521,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const isValueTypeInvariant = (0, types_1.isClassInstance)(inferenceContext.expectedType) &&
             (types_1.ClassType.isBuiltIn(inferenceContext.expectedType, 'dict') ||
                 types_1.ClassType.isBuiltIn(inferenceContext.expectedType, 'MutableMapping'));
-        const specializedKeyType = inferTypeArgFromExpectedType(expectedKeyType, keyTypes.map((result) => result.type), 
+        const specializedKeyType = inferTypeArgFromExpectedType((0, typeUtils_1.makeInferenceContext)(expectedKeyType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext), keyTypes.map((result) => result.type), 
         /* isNarrowable */ false);
-        const specializedValueType = inferTypeArgFromExpectedType(expectedValueType, valueTypes.map((result) => result.type), 
-        /* isNarrowable */ !isValueTypeInvariant);
+        const specializedValueType = inferTypeArgFromExpectedType((0, typeUtils_1.makeInferenceContext)(expectedValueType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext), valueTypes.map((result) => result.type), !isValueTypeInvariant);
         if (!specializedKeyType || !specializedValueType) {
             return undefined;
         }
@@ -9541,7 +9580,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return { type, isIncomplete };
     }
-    function getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, forceStrictInference, expectedKeyType, expectedValueType, expectedTypedDictEntries, expectedDiagAddendum) {
+    function getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, forceStrictInference, expectedKeyType, expectedValueType, expectedTypedDictEntries, expectedDiagAddendum, inferenceContext) {
         let isIncomplete = false;
         // Infer the key and value types if possible.
         node.entries.forEach((entryNode, index) => {
@@ -9549,7 +9588,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             let addUnknown = true;
             if (entryNode.nodeType === 17 /* DictionaryKeyEntry */) {
                 const keyTypeResult = getTypeOfExpression(entryNode.keyExpression, 
-                /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedKeyType !== null && expectedKeyType !== void 0 ? expectedKeyType : (forceStrictInference ? types_1.NeverType.createNever() : undefined)));
+                /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedKeyType !== null && expectedKeyType !== void 0 ? expectedKeyType : (forceStrictInference ? types_1.NeverType.createNever() : undefined), inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
                 if (keyTypeResult.isIncomplete) {
                     isIncomplete = true;
                 }
@@ -9568,12 +9607,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     expectedTypedDictEntries.has(keyType.literalValue)) {
                     const effectiveValueType = expectedTypedDictEntries.get(keyType.literalValue).valueType;
                     valueTypeResult = getTypeOfExpression(entryNode.valueExpression, 
-                    /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(effectiveValueType));
+                    /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(effectiveValueType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
                 }
                 else {
                     const effectiveValueType = expectedValueType !== null && expectedValueType !== void 0 ? expectedValueType : (forceStrictInference ? types_1.NeverType.createNever() : undefined);
                     valueTypeResult = getTypeOfExpression(entryNode.valueExpression, 
-                    /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(effectiveValueType));
+                    /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(effectiveValueType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
                 }
                 if (expectedDiagAddendum && valueTypeResult.expectedTypeDiagAddendum) {
                     expectedDiagAddendum.addAddendum(valueTypeResult.expectedTypeDiagAddendum);
@@ -9597,7 +9636,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
                 const unexpandedTypeResult = getTypeOfExpression(entryNode.expandExpression, 
-                /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedType));
+                /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
                 if (unexpandedTypeResult.isIncomplete) {
                     isIncomplete = true;
                 }
@@ -9757,10 +9796,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 verifySetEntryOrDictKeyIsHashable(entry, entryTypeResult.type, /* isDictKey */ false);
             }
         });
-        const isExpectedTypeListOrSet = (0, types_1.isClassInstance)(inferenceContext.expectedType) &&
+        const isTypeInvariant = (0, types_1.isClassInstance)(inferenceContext.expectedType) &&
             types_1.ClassType.isBuiltIn(inferenceContext.expectedType, builtInClassName);
-        const specializedEntryType = inferTypeArgFromExpectedType(expectedEntryType, entryTypes, 
-        /* isNarrowable */ !isExpectedTypeListOrSet);
+        const specializedEntryType = inferTypeArgFromExpectedType((0, typeUtils_1.makeInferenceContext)(expectedEntryType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext), entryTypes, !isTypeInvariant);
         if (!specializedEntryType) {
             return { type: types_1.UnknownType.create(), isIncomplete, typeErrors: true, expectedTypeDiagAddendum };
         }
@@ -9843,48 +9881,33 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message + diag.getString(), entry);
         }
     }
-    function inferTypeArgFromExpectedType(expectedType, entryTypes, isNarrowable) {
-        let targetTypeVar;
-        let useSynthesizedTypeVar = false;
-        // If the expected type is a TypeVar, use it as a target to find
-        // a common (narrowest) type among the entry types.
-        if ((0, types_1.isTypeVar)(expectedType)) {
-            if (expectedType.details.isParamSpec || expectedType.details.isVariadic) {
-                return undefined;
+    function inferTypeArgFromExpectedType(inferenceContext, entryTypes, isNarrowable) {
+        var _a;
+        // If the expected type is Any, the resulting type becomes Any.
+        if ((0, types_1.isAnyOrUnknown)(inferenceContext.expectedType)) {
+            return inferenceContext.expectedType;
+        }
+        const typeVarContext = (_a = inferenceContext.typeVarContext) === null || _a === void 0 ? void 0 : _a.clone();
+        let isCompatible = true;
+        entryTypes.forEach((entryType) => {
+            if (isCompatible &&
+                !assignType(inferenceContext.expectedType, entryType, /* diag */ undefined, typeVarContext)) {
+                isCompatible = false;
             }
-            targetTypeVar = expectedType;
+        });
+        if (!isCompatible) {
+            return undefined;
         }
-        else {
-            // Synthesize a temporary bound type var. We will attempt to assign all list
-            // entries to this type var, possibly narrowing the type in the process.
-            targetTypeVar = types_1.TypeVarType.createInstance('__typeArg');
-            targetTypeVar.details.isSynthesized = true;
-            targetTypeVar.details.boundType = makeTopLevelTypeVarsConcrete(expectedType);
-            // Use a dummy scope ID. It needs to be a non-empty string.
-            targetTypeVar.scopeId = '__typeArgScopeId';
-            useSynthesizedTypeVar = true;
-        }
-        // First, try to assign entries with their literal values stripped.
-        // The only time we don't want to strip them is if the expected
-        // type explicitly includes literals.
-        let typeVarContext = new typeVarContext_1.TypeVarContext(targetTypeVar.scopeId);
-        if (useSynthesizedTypeVar) {
-            typeVarContext.setTypeVarType(targetTypeVar, isNarrowable ? undefined : expectedType, 
-            /* narrowBoundNoLiterals */ undefined, expectedType);
-        }
-        if (entryTypes.every((entryType) => assignType(targetTypeVar, stripLiteralValue(entryType), /* diag */ undefined, typeVarContext))) {
-            return (0, typeUtils_1.applySolvedTypeVars)(targetTypeVar, typeVarContext);
-        }
-        // Allocate a fresh typeVarContext before we try again with literals not stripped.
-        typeVarContext = new typeVarContext_1.TypeVarContext(targetTypeVar.scopeId);
-        if (useSynthesizedTypeVar) {
-            typeVarContext.setTypeVarType(targetTypeVar, isNarrowable ? undefined : expectedType, 
-            /* narrowBoundNoLiterals */ undefined, expectedType);
-        }
-        if (entryTypes.every((entryType) => assignType(targetTypeVar, entryType, /* diag */ undefined, typeVarContext))) {
-            return (0, typeUtils_1.applySolvedTypeVars)(targetTypeVar, typeVarContext);
+        if (isNarrowable && entryTypes.length > 0) {
+            const combinedTypes = (0, types_1.combineTypes)(entryTypes);
+            return (0, typeUtils_1.containsLiteralType)(inferenceContext.expectedType)
+                ? combinedTypes
+                : stripLiteralValue(combinedTypes);
         }
-        return undefined;
+        if (typeVarContext) {
+            return (0, typeUtils_1.applySolvedTypeVars)(inferenceContext.expectedType, typeVarContext);
+        }
+        return inferenceContext.expectedType;
     }
     function getTypeOfTernary(node, flags, inferenceContext) {
         getTypeOfExpression(node.testExpression);
@@ -9943,28 +9966,26 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return { type: sentType || types_1.UnknownType.create(), isIncomplete };
     }
     function getTypeOfYieldFrom(node) {
-        var _a, _b;
         const yieldFromTypeResult = getTypeOfExpression(node.expression);
         const yieldFromType = yieldFromTypeResult.type;
-        let generatorTypeArgs = (0, typeUtils_1.getGeneratorTypeArgs)(yieldFromType);
-        let returnedType;
-        // Is the expression a Generator type?
-        if (generatorTypeArgs) {
-            returnedType = generatorTypeArgs.length >= 2 ? generatorTypeArgs[2] : types_1.UnknownType.create();
-        }
-        else if ((0, types_1.isClassInstance)(yieldFromType) && types_1.ClassType.isBuiltIn(yieldFromType, 'Coroutine')) {
+        const returnedType = (0, typeUtils_1.mapSubtypes)(yieldFromType, (yieldFromSubtype) => {
+            var _a, _b;
+            // Is the expression a Generator type?
+            let generatorTypeArgs = (0, typeUtils_1.getGeneratorTypeArgs)(yieldFromSubtype);
+            if (generatorTypeArgs) {
+                return generatorTypeArgs.length >= 2 ? generatorTypeArgs[2] : types_1.UnknownType.create();
+            }
             // Handle old-style (pre-await) Coroutines as a special case.
-            returnedType = types_1.UnknownType.create();
-        }
-        else {
+            if ((0, types_1.isClassInstance)(yieldFromSubtype) && types_1.ClassType.isBuiltIn(yieldFromSubtype, 'Coroutine')) {
+                return types_1.UnknownType.create();
+            }
+            // Handle simple iterables.
             const iterableType = (_b = (_a = getTypeOfIterable(yieldFromTypeResult, /* isAsync */ false, node)) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
             // Does the iterable return a Generator?
             generatorTypeArgs = (0, typeUtils_1.getGeneratorTypeArgs)(iterableType);
-            if (generatorTypeArgs) {
-                returnedType = generatorTypeArgs.length >= 2 ? generatorTypeArgs[2] : types_1.UnknownType.create();
-            }
-        }
-        return { type: returnedType || types_1.UnknownType.create() };
+            return generatorTypeArgs && generatorTypeArgs.length >= 2 ? generatorTypeArgs[2] : types_1.UnknownType.create();
+        });
+        return { type: returnedType };
     }
     function getTypeOfLambda(node, inferenceContext) {
         let isIncomplete = !!(inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete);
@@ -10058,15 +10079,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 type: types_1.UnknownType.create(),
             });
         }
-        const expectedReturnType = expectedFunctionType
+        let expectedReturnType = expectedFunctionType
             ? getFunctionEffectiveReturnType(expectedFunctionType)
             : undefined;
+        if (expectedReturnType && (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext)) {
+            expectedReturnType = (0, typeUtils_1.applySolvedTypeVars)(expectedReturnType, inferenceContext.typeVarContext);
+        }
         // 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 = () => {
             const returnTypeResult = getTypeOfExpression(node.expression, 
-            /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedReturnType));
+            /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedReturnType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
             functionType.inferredReturnType = returnTypeResult.type;
             if (returnTypeResult.isIncomplete) {
                 isIncomplete = true;
@@ -11169,7 +11193,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let flags = 0 /* None */;
         if (fileInfo.isStubFile) {
             // An assignment of ellipsis means "Any" within a type stub file.
-            flags |= 512 /* ConvertEllipsisToUnknown */;
+            flags |= 1 /* ConvertEllipsisToAny */;
         }
         if (node.rightExpression.nodeType === 38 /* Name */ ||
             node.rightExpression.nodeType === 35 /* MemberAccess */) {
@@ -12238,11 +12262,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                         argument: arg,
                                         errorNode: (_b = arg.valueExpression) !== null && _b !== void 0 ? _b : errorNode,
                                     };
-                                    validateArgType(argParam, new typeVarContext_1.TypeVarContext(), signatureTracker, { type: newMethodType }, 
-                                    /* skipUnknownCheck */ true, 
-                                    /* skipOverloadArg */ true, 
-                                    /* useNarrowBoundOnly */ false, 
-                                    /* conditionFilter */ undefined);
+                                    validateArgType(argParam, new typeVarContext_1.TypeVarContext(), signatureTracker, { type: newMethodType }, { skipUnknownArgCheck: true, skipOverloadArg: true });
                                     paramMap.delete(arg.name.value);
                                 }
                                 else {
@@ -13232,11 +13252,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (functionDecl === null || functionDecl === void 0 ? void 0 : functionDecl.isGenerator) {
                         const inferredYieldTypes = [];
                         let useAwaitableGenerator = false;
+                        let isYieldResultUsed = false;
                         if (functionDecl.yieldStatements) {
                             functionDecl.yieldStatements.forEach((yieldNode) => {
-                                var _a;
+                                var _a, _b;
                                 if (isNodeReachable(yieldNode)) {
                                     if (yieldNode.nodeType === 61 /* YieldFrom */) {
+                                        isYieldResultUsed = true;
                                         const iteratorTypeResult = getTypeOfExpression(yieldNode.expression);
                                         if ((0, types_1.isClassInstance)(iteratorTypeResult.type) &&
                                             types_1.ClassType.isBuiltIn(iteratorTypeResult.type, 'Coroutine')) {
@@ -13251,6 +13273,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                         }
                                     }
                                     else {
+                                        // If the yield expression is not by itself in a statement list,
+                                        // assume that its result is consumed.
+                                        if (((_b = yieldNode === null || yieldNode === void 0 ? void 0 : yieldNode.parent) === null || _b === void 0 ? void 0 : _b.nodeType) !== 47 /* StatementList */) {
+                                            isYieldResultUsed = true;
+                                        }
                                         if (yieldNode.expression) {
                                             const yieldType = getTypeOfExpression(yieldNode.expression).type;
                                             inferredYieldTypes.push(yieldType !== null && yieldType !== void 0 ? yieldType : types_1.UnknownType.create());
@@ -13271,10 +13298,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         const generatorType = getTypingType(node, useAwaitableGenerator ? 'AwaitableGenerator' : 'Generator');
                         if (generatorType && (0, types_1.isInstantiableClass)(generatorType)) {
                             const typeArgs = [];
+                            // The "send type" for the generator (the second type argument) is
+                            // not generally inferrable, but we can assume that it's Any
+                            // if the function never uses the value and Unknown if it does.
+                            // This eliminates any "partially unknown" errors in strict mode
+                            // in the common case.
+                            const sendType = isYieldResultUsed ? types_1.UnknownType.create() : types_1.AnyType.create();
+                            typeArgs.push(inferredYieldType, sendType, (0, types_1.isNever)(inferredReturnType) ? types_1.NoneType.createInstance() : inferredReturnType);
                             if (useAwaitableGenerator) {
                                 typeArgs.push(types_1.AnyType.create());
                             }
-                            typeArgs.push(inferredYieldType, types_1.NoneType.createInstance(), (0, types_1.isNever)(inferredReturnType) ? types_1.NoneType.createInstance() : inferredReturnType);
                             inferredReturnType = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(generatorType, typeArgs, 
                             /* isTypeArgumentExplicit */ true));
                         }
@@ -13649,9 +13682,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         (0, debug_1.assert)(aliasDecl.type === 8 /* Alias */);
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         // Try to resolve the alias while honoring external visibility.
-        const resolvedAliasInfo = resolveAliasDeclarationWithInfo(aliasDecl, 
-        /* resolveLocalNames */ true, 
-        /* allowExternallyHiddenAccess */ fileInfo.isStubFile);
+        const resolvedAliasInfo = resolveAliasDeclarationWithInfo(aliasDecl, /* resolveLocalNames */ true, {
+            allowExternallyHiddenAccess: fileInfo.isStubFile,
+        });
         if (!resolvedAliasInfo) {
             return undefined;
         }
@@ -15129,9 +15162,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function getInferredTypeOfDeclaration(symbol, decl) {
         var _a, _b, _c;
-        const resolvedDecl = resolveAliasDeclaration(decl, 
-        /* resolveLocalNames */ true, 
-        /* allowExternallyHiddenAccess */ AnalyzerNodeInfo.getFileInfo(decl.node).isStubFile);
+        const resolvedDecl = resolveAliasDeclaration(decl, /* resolveLocalNames */ true, {
+            allowExternallyHiddenAccess: AnalyzerNodeInfo.getFileInfo(decl.node).isStubFile,
+        });
         // We couldn't resolve the alias. Substitute an unknown
         // type in this case.
         if (!resolvedDecl) {
@@ -15363,12 +15396,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // associated with that symbol. It does this recursively if necessary. If a symbol
     // lookup fails, undefined is returned. If resolveLocalNames is true, the method
     // resolves aliases through local renames ("as" clauses found in import statements).
-    function resolveAliasDeclaration(declaration, resolveLocalNames, allowExternallyHiddenAccess = false) {
-        var _a;
-        return (_a = (0, declarationUtils_1.resolveAliasDeclaration)(importLookup, declaration, resolveLocalNames, allowExternallyHiddenAccess)) === null || _a === void 0 ? void 0 : _a.declaration;
+    function resolveAliasDeclaration(declaration, resolveLocalNames, options) {
+        var _a, _b, _c;
+        return (_c = (0, declarationUtils_1.resolveAliasDeclaration)(importLookup, declaration, {
+            resolveLocalNames,
+            allowExternallyHiddenAccess: (_a = options === null || options === void 0 ? void 0 : options.allowExternallyHiddenAccess) !== null && _a !== void 0 ? _a : false,
+            skipFileNeededCheck: (_b = options === null || options === void 0 ? void 0 : options.skipFileNeededCheck) !== null && _b !== void 0 ? _b : false,
+        })) === null || _c === void 0 ? void 0 : _c.declaration;
     }
-    function resolveAliasDeclarationWithInfo(declaration, resolveLocalNames, allowExternallyHiddenAccess = false) {
-        return (0, declarationUtils_1.resolveAliasDeclaration)(importLookup, declaration, resolveLocalNames, allowExternallyHiddenAccess);
+    function resolveAliasDeclarationWithInfo(declaration, resolveLocalNames, options) {
+        var _a, _b;
+        return (0, declarationUtils_1.resolveAliasDeclaration)(importLookup, declaration, {
+            resolveLocalNames,
+            allowExternallyHiddenAccess: (_a = options === null || options === void 0 ? void 0 : options.allowExternallyHiddenAccess) !== null && _a !== void 0 ? _a : false,
+            skipFileNeededCheck: (_b = options === null || options === void 0 ? void 0 : options.skipFileNeededCheck) !== null && _b !== void 0 ? _b : false,
+        });
     }
     // Returns the type of the symbol. If the type is explicitly declared, that type
     // is returned. If not, the type is inferred from assignments to the symbol. All
@@ -15491,11 +15533,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             if (considerDecl) {
-                const resolvedDecl = (_a = resolveAliasDeclaration(decl, 
-                /* resolveLocalNames */ true, 
-                /* allowExternallyHiddenAccess */ AnalyzerNodeInfo.getFileInfo(decl.node).isStubFile)) !== null && _a !== void 0 ? _a : decl;
-                const isExplicitTypeAlias = isExplicitTypeAliasDeclaration(decl);
-                const isTypeAlias = isExplicitTypeAlias || isPossibleTypeAliasOrTypedDict(decl);
+                const resolvedDecl = (_a = resolveAliasDeclaration(decl, /* resolveLocalNames */ true, {
+                    allowExternallyHiddenAccess: AnalyzerNodeInfo.getFileInfo(decl.node).isStubFile,
+                })) !== null && _a !== void 0 ? _a : decl;
+                const isExplicitTypeAlias = isExplicitTypeAliasDeclaration(resolvedDecl);
+                const isTypeAlias = isExplicitTypeAlias || isPossibleTypeAliasOrTypedDict(resolvedDecl);
                 if (isExplicitTypeAlias) {
                     sawExplicitTypeAlias = true;
                 }
@@ -16207,6 +16249,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // specified inheritance chain, taking into account its type arguments.
     function assignClassWithTypeArgs(destType, srcType, inheritanceChain, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
         let curSrcType = srcType;
+        let prevSrcType;
         let curDestTypeVarContext = destTypeVarContext;
         let effectiveFlags = flags;
         inferTypeParameterVarianceForClass(destType);
@@ -16236,7 +16279,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // If this isn't the first time through the loop, specialize
             // for the next ancestor in the chain.
             if (ancestorIndex < inheritanceChain.length - 1) {
-                curSrcType = (0, typeUtils_1.specializeForBaseClass)(curSrcType, ancestorType);
+                // If the curSrcType is a NamedTuple and the ancestorType is a tuple,
+                // we need to handle this as a special case because the NamedTuple may
+                // include typeParams from its parent class.
+                let effectiveCurSrcType = curSrcType;
+                if (types_1.ClassType.isBuiltIn(curSrcType, 'NamedTuple') &&
+                    types_1.ClassType.isBuiltIn(ancestorType, 'tuple') &&
+                    prevSrcType) {
+                    effectiveCurSrcType = prevSrcType;
+                }
+                curSrcType = (0, typeUtils_1.specializeForBaseClass)(effectiveCurSrcType, ancestorType);
             }
             // Handle built-in types that support arbitrary numbers
             // of type parameters like Tuple.
@@ -16259,6 +16311,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Allocate a new type var map for the next time through the loop.
             curDestTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(ancestorType));
             effectiveFlags &= ~8 /* SkipSolveTypeVars */;
+            prevSrcType = curSrcType;
         }
         if (destType.typeArguments) {
             // If the dest type is specialized, make sure the specialized source
@@ -17752,7 +17805,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             const srcParamType = srcParamInfo.type;
                             if (!destParamInfo) {
                                 if (destParamDetails.kwargsIndex === undefined && !srcParamInfo.param.hasDefault) {
-                                    if (paramDiag) {
+                                    if (paramDiag && srcParamDetails.firstKeywordOnlyIndex !== undefined) {
                                         paramDiag.addMessage(localize_1.Localizer.DiagnosticAddendum.namedParamMissingInDest().format({
                                             name: srcParamInfo.param.name,
                                         }));
@@ -18121,213 +18174,224 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const baseParamDetails = (0, parameterUtils_1.getParameterListDetails)(baseMethod);
         const overrideParamDetails = (0, parameterUtils_1.getParameterListDetails)(overrideMethod);
         let canOverride = true;
-        // Verify that we're not overriding a static, class or instance method with
-        // an incompatible type.
-        if (types_1.FunctionType.isStaticMethod(baseMethod)) {
-            if (!types_1.FunctionType.isStaticMethod(overrideMethod)) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideNotStaticMethod());
-                canOverride = false;
-            }
-        }
-        else if (types_1.FunctionType.isClassMethod(baseMethod)) {
-            if (!types_1.FunctionType.isClassMethod(overrideMethod)) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideNotClassMethod());
-                canOverride = false;
-            }
-        }
-        if (types_1.FunctionType.isInstanceMethod(baseMethod)) {
-            if (!types_1.FunctionType.isInstanceMethod(overrideMethod)) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideNotInstanceMethod());
-                canOverride = false;
-            }
-        }
-        // Verify that the positional param count matches exactly or that the override
-        // adds only params that preserve the original signature.
-        let foundParamCountMismatch = false;
-        if (overrideParamDetails.positionParamCount < baseParamDetails.positionParamCount) {
-            if (overrideParamDetails.argsIndex === undefined) {
-                foundParamCountMismatch = true;
-            }
-            else {
-                const overrideArgsType = overrideParamDetails.params[overrideParamDetails.argsIndex].type;
-                for (let i = overrideParamDetails.positionParamCount; i < baseParamDetails.positionParamCount; i++) {
-                    if (!assignType(overrideArgsType, baseParamDetails.params[i].type, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(baseMethod)), 8 /* SkipSolveTypeVars */)) {
-                        localize_1.Localizer.DiagnosticAddendum.overrideParamType().format({
-                            index: i + 1,
-                            baseType: printType(baseParamDetails.params[i].type),
-                            overrideType: printType(overrideArgsType),
-                        });
-                        canOverride = false;
-                    }
+        if (!types_1.FunctionType.shouldSkipArgsKwargsCompatibilityCheck(baseMethod) &&
+            !types_1.FunctionType.shouldSkipArgsKwargsCompatibilityCheck(overrideMethod)) {
+            // Verify that we're not overriding a static, class or instance method with
+            // an incompatible type.
+            if (types_1.FunctionType.isStaticMethod(baseMethod)) {
+                if (!types_1.FunctionType.isStaticMethod(overrideMethod)) {
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideNotStaticMethod());
+                    canOverride = false;
                 }
             }
-        }
-        else if (overrideParamDetails.positionParamCount > baseParamDetails.positionParamCount) {
-            // Verify that all of the override parameters that extend the
-            // signature are either *args, **kwargs or parameters with
-            // default values.
-            for (let i = baseParamDetails.positionParamCount; i < overrideParamDetails.positionParamCount; i++) {
-                const overrideParam = overrideParamDetails.params[i].param;
-                if (overrideParam.category === 0 /* Simple */ &&
-                    overrideParam.name &&
-                    !overrideParam.hasDefault) {
-                    foundParamCountMismatch = true;
+            else if (types_1.FunctionType.isClassMethod(baseMethod)) {
+                if (!types_1.FunctionType.isClassMethod(overrideMethod)) {
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideNotClassMethod());
+                    canOverride = false;
                 }
             }
-        }
-        if (foundParamCountMismatch) {
-            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overridePositionalParamCount().format({
-                baseCount: baseParamDetails.params.length,
-                overrideCount: overrideParamDetails.params.length,
-            }));
-            canOverride = false;
-        }
-        const positionalParamCount = Math.min(baseParamDetails.positionParamCount, overrideParamDetails.positionParamCount);
-        for (let i = 0; i < positionalParamCount; i++) {
-            // If the first parameter is a "self" or "cls" parameter, skip the
-            // test because these are allowed to violate the Liskov substitution
-            // principle.
-            if (i === 0) {
-                if (types_1.FunctionType.isInstanceMethod(overrideMethod) ||
-                    types_1.FunctionType.isClassMethod(overrideMethod) ||
-                    types_1.FunctionType.isConstructorMethod(overrideMethod)) {
-                    continue;
+            if (types_1.FunctionType.isInstanceMethod(baseMethod)) {
+                if (!types_1.FunctionType.isInstanceMethod(overrideMethod)) {
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideNotInstanceMethod());
+                    canOverride = false;
                 }
             }
-            const baseParam = baseParamDetails.params[i].param;
-            const overrideParam = overrideParamDetails.params[i].param;
-            if (i >= baseParamDetails.positionOnlyParamCount &&
-                !(0, symbolNameUtils_1.isPrivateOrProtectedName)(baseParam.name || '') &&
-                baseParamDetails.params[i].source !== parameterUtils_1.ParameterSource.PositionOnly &&
-                baseParam.category === 0 /* Simple */ &&
-                baseParam.name !== overrideParam.name) {
-                if (overrideParam.category === 0 /* Simple */) {
-                    if (enforceParamNames) {
-                        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,
-                                baseName: baseParam.name || '*',
-                            }));
-                        }
-                        else {
-                            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamName().format({
+            // Verify that the positional param count matches exactly or that the override
+            // adds only params that preserve the original signature.
+            let foundParamCountMismatch = false;
+            if (overrideParamDetails.positionParamCount < baseParamDetails.positionParamCount) {
+                if (overrideParamDetails.argsIndex === undefined) {
+                    foundParamCountMismatch = true;
+                }
+                else {
+                    const overrideArgsType = overrideParamDetails.params[overrideParamDetails.argsIndex].type;
+                    for (let i = overrideParamDetails.positionParamCount; i < baseParamDetails.positionParamCount; i++) {
+                        if (!assignType(overrideArgsType, baseParamDetails.params[i].type, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(baseMethod)), 8 /* SkipSolveTypeVars */)) {
+                            localize_1.Localizer.DiagnosticAddendum.overrideParamType().format({
                                 index: i + 1,
-                                baseName: baseParam.name || '*',
-                                overrideName: overrideParam.name || '*',
-                            }));
+                                baseType: printType(baseParamDetails.params[i].type),
+                                overrideType: printType(overrideArgsType),
+                            });
+                            canOverride = false;
                         }
-                        canOverride = false;
                     }
                 }
             }
-            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 || '*',
+            else if (overrideParamDetails.positionParamCount > baseParamDetails.positionParamCount) {
+                // Verify that all of the override parameters that extend the
+                // signature are either *args, **kwargs or parameters with
+                // default values.
+                for (let i = baseParamDetails.positionParamCount; i < overrideParamDetails.positionParamCount; i++) {
+                    const overrideParam = overrideParamDetails.params[i].param;
+                    if (overrideParam.category === 0 /* Simple */ &&
+                        overrideParam.name &&
+                        !overrideParam.hasDefault) {
+                        foundParamCountMismatch = true;
+                    }
+                }
+            }
+            if (foundParamCountMismatch) {
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overridePositionalParamCount().format({
+                    baseCount: baseParamDetails.params.length,
+                    overrideCount: overrideParamDetails.params.length,
                 }));
                 canOverride = false;
             }
-            else {
-                const baseParamType = baseParamDetails.params[i].type;
-                const overrideParamType = overrideParamDetails.params[i].type;
-                const baseIsSynthesizedTypeVar = (0, types_1.isTypeVar)(baseParamType) && baseParamType.details.isSynthesized;
-                const overrideIsSynthesizedTypeVar = (0, types_1.isTypeVar)(overrideParamType) && overrideParamType.details.isSynthesized;
-                if (!baseIsSynthesizedTypeVar && !overrideIsSynthesizedTypeVar) {
-                    if (baseParam.category !== overrideParam.category ||
-                        !assignType(overrideParamType, baseParamType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(baseMethod)), 8 /* SkipSolveTypeVars */)) {
-                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamType().format({
-                            index: i + 1,
-                            baseType: printType(baseParamType),
-                            overrideType: printType(overrideParamType),
-                        }));
-                        canOverride = false;
+            const positionalParamCount = Math.min(baseParamDetails.positionParamCount, overrideParamDetails.positionParamCount);
+            for (let i = 0; i < positionalParamCount; i++) {
+                // If the first parameter is a "self" or "cls" parameter, skip the
+                // test because these are allowed to violate the Liskov substitution
+                // principle.
+                if (i === 0) {
+                    if (types_1.FunctionType.isInstanceMethod(overrideMethod) ||
+                        types_1.FunctionType.isClassMethod(overrideMethod) ||
+                        types_1.FunctionType.isConstructorMethod(overrideMethod)) {
+                        continue;
                     }
                 }
-                if (baseParamDetails.params[i].param.hasDefault && !overrideParamDetails.params[i].param.hasDefault) {
-                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNoDefault().format({
+                const baseParam = baseParamDetails.params[i].param;
+                const overrideParam = overrideParamDetails.params[i].param;
+                if (i >= baseParamDetails.positionOnlyParamCount &&
+                    !(0, symbolNameUtils_1.isPrivateOrProtectedName)(baseParam.name || '') &&
+                    baseParamDetails.params[i].source !== parameterUtils_1.ParameterSource.PositionOnly &&
+                    baseParam.category === 0 /* Simple */ &&
+                    baseParam.name !== overrideParam.name) {
+                    if (overrideParam.category === 0 /* Simple */) {
+                        if (enforceParamNames) {
+                            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,
+                                    baseName: baseParam.name || '*',
+                                }));
+                            }
+                            else {
+                                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamName().format({
+                                    index: i + 1,
+                                    baseName: baseParam.name || '*',
+                                    overrideName: overrideParam.name || '*',
+                                }));
+                            }
+                            canOverride = false;
+                        }
+                    }
+                }
+                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;
                 }
-            }
-        }
-        // Check for a *args match.
-        if (baseParamDetails.argsIndex !== undefined) {
-            if (overrideParamDetails.argsIndex === undefined) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNameMissing().format({
-                    name: (_a = baseParamDetails.params[baseParamDetails.argsIndex].param.name) !== null && _a !== void 0 ? _a : '?',
-                }));
-                canOverride = false;
-            }
-            else {
-                const overrideParamType = overrideParamDetails.params[overrideParamDetails.argsIndex].type;
-                const baseParamType = baseParamDetails.params[baseParamDetails.argsIndex].type;
-                if (!assignType(overrideParamType, baseParamType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), 
-                /* srcTypeVarContext */ undefined, 8 /* SkipSolveTypeVars */)) {
-                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamKeywordType().format({
-                        name: (_b = overrideParamDetails.params[overrideParamDetails.argsIndex].param.name) !== null && _b !== void 0 ? _b : '?',
-                        baseType: printType(baseParamType),
-                        overrideType: printType(overrideParamType),
-                    }));
-                    canOverride = false;
+                else {
+                    const baseParamType = baseParamDetails.params[i].type;
+                    const overrideParamType = overrideParamDetails.params[i].type;
+                    const baseIsSynthesizedTypeVar = (0, types_1.isTypeVar)(baseParamType) && baseParamType.details.isSynthesized;
+                    const overrideIsSynthesizedTypeVar = (0, types_1.isTypeVar)(overrideParamType) && overrideParamType.details.isSynthesized;
+                    if (!baseIsSynthesizedTypeVar && !overrideIsSynthesizedTypeVar) {
+                        if (baseParam.category !== overrideParam.category ||
+                            !assignType(overrideParamType, baseParamType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(baseMethod)), 8 /* SkipSolveTypeVars */)) {
+                            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamType().format({
+                                index: i + 1,
+                                baseType: printType(baseParamType),
+                                overrideType: printType(overrideParamType),
+                            }));
+                            canOverride = false;
+                        }
+                    }
+                    if (baseParamDetails.params[i].param.hasDefault &&
+                        !overrideParamDetails.params[i].param.hasDefault) {
+                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNoDefault().format({
+                            index: i + 1,
+                        }));
+                        canOverride = false;
+                    }
                 }
             }
-        }
-        // Now check any keyword-only parameters.
-        const baseKwOnlyParams = baseParamDetails.params.filter((paramInfo) => paramInfo.source === parameterUtils_1.ParameterSource.KeywordOnly &&
-            paramInfo.param.category === 0 /* Simple */);
-        const overrideWkOnlyParams = overrideParamDetails.params.filter((paramInfo) => paramInfo.source === parameterUtils_1.ParameterSource.KeywordOnly &&
-            paramInfo.param.category === 0 /* Simple */);
-        baseKwOnlyParams.forEach((paramInfo) => {
-            var _a, _b, _c;
-            const overrideParamInfo = overrideWkOnlyParams.find((pi) => paramInfo.param.name === pi.param.name);
-            if (!overrideParamInfo && overrideParamDetails.kwargsIndex === undefined) {
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNameMissing().format({
-                    name: (_a = paramInfo.param.name) !== null && _a !== void 0 ? _a : '?',
-                }));
-                canOverride = false;
-            }
-            else {
-                let targetParamType = overrideParamInfo === null || overrideParamInfo === void 0 ? void 0 : overrideParamInfo.type;
-                if (!targetParamType) {
-                    targetParamType = overrideParamDetails.params[overrideParamDetails.kwargsIndex].type;
-                }
-                if (!assignType(targetParamType, paramInfo.type, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), 
-                /* srcTypeVarContext */ undefined, 8 /* SkipSolveTypeVars */)) {
-                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamKeywordType().format({
-                        name: (_b = paramInfo.param.name) !== null && _b !== void 0 ? _b : '?',
-                        baseType: printType(paramInfo.type),
-                        overrideType: printType(targetParamType),
+            // Check for a *args match.
+            if (baseParamDetails.argsIndex !== undefined) {
+                if (overrideParamDetails.argsIndex === undefined) {
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNameMissing().format({
+                        name: (_a = baseParamDetails.params[baseParamDetails.argsIndex].param.name) !== null && _a !== void 0 ? _a : '?',
                     }));
                     canOverride = false;
                 }
-                if (overrideParamInfo) {
-                    if (paramInfo.param.hasDefault && !overrideParamInfo.param.hasDefault) {
-                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamKeywordNoDefault().format({
-                            name: (_c = overrideParamInfo.param.name) !== null && _c !== void 0 ? _c : '?',
+                else {
+                    const overrideParamType = overrideParamDetails.params[overrideParamDetails.argsIndex].type;
+                    const baseParamType = baseParamDetails.params[baseParamDetails.argsIndex].type;
+                    if (!assignType(overrideParamType, baseParamType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), 
+                    /* srcTypeVarContext */ undefined, 8 /* SkipSolveTypeVars */)) {
+                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamKeywordType().format({
+                            name: (_b = overrideParamDetails.params[overrideParamDetails.argsIndex].param.name) !== null && _b !== void 0 ? _b : '?',
+                            baseType: printType(baseParamType),
+                            overrideType: printType(overrideParamType),
                         }));
                         canOverride = false;
                     }
                 }
             }
-        });
-        // Verify that any keyword-only parameters added by the overload are compatible
-        // with the **kwargs in the base.
-        overrideWkOnlyParams.forEach((paramInfo) => {
-            var _a;
-            const baseParamInfo = baseKwOnlyParams.find((pi) => paramInfo.param.name === pi.param.name);
-            if (!baseParamInfo) {
-                if (baseParamDetails.kwargsIndex === undefined) {
-                    if (!paramInfo.param.hasDefault) {
-                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNameExtra().format({
-                            name: (_a = paramInfo.param.name) !== null && _a !== void 0 ? _a : '?',
+            // Now check any keyword-only parameters.
+            const baseKwOnlyParams = baseParamDetails.params.filter((paramInfo) => paramInfo.source === parameterUtils_1.ParameterSource.KeywordOnly &&
+                paramInfo.param.category === 0 /* Simple */);
+            const overrideWkOnlyParams = overrideParamDetails.params.filter((paramInfo) => paramInfo.source === parameterUtils_1.ParameterSource.KeywordOnly &&
+                paramInfo.param.category === 0 /* Simple */);
+            baseKwOnlyParams.forEach((paramInfo) => {
+                var _a, _b, _c;
+                const overrideParamInfo = overrideWkOnlyParams.find((pi) => paramInfo.param.name === pi.param.name);
+                if (!overrideParamInfo && overrideParamDetails.kwargsIndex === undefined) {
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNameMissing().format({
+                        name: (_a = paramInfo.param.name) !== null && _a !== void 0 ? _a : '?',
+                    }));
+                    canOverride = false;
+                }
+                else {
+                    let targetParamType = overrideParamInfo === null || overrideParamInfo === void 0 ? void 0 : overrideParamInfo.type;
+                    if (!targetParamType) {
+                        targetParamType = overrideParamDetails.params[overrideParamDetails.kwargsIndex].type;
+                    }
+                    if (!assignType(targetParamType, paramInfo.type, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), 
+                    /* srcTypeVarContext */ undefined, 8 /* SkipSolveTypeVars */)) {
+                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamKeywordType().format({
+                            name: (_b = paramInfo.param.name) !== null && _b !== void 0 ? _b : '?',
+                            baseType: printType(paramInfo.type),
+                            overrideType: printType(targetParamType),
                         }));
                         canOverride = false;
                     }
+                    if (overrideParamInfo) {
+                        if (paramInfo.param.hasDefault && !overrideParamInfo.param.hasDefault) {
+                            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamKeywordNoDefault().format({
+                                name: (_c = overrideParamInfo.param.name) !== null && _c !== void 0 ? _c : '?',
+                            }));
+                            canOverride = false;
+                        }
+                    }
                 }
+            });
+            // Verify that any keyword-only parameters added by the overload are compatible
+            // with the **kwargs in the base.
+            overrideWkOnlyParams.forEach((paramInfo) => {
+                var _a;
+                const baseParamInfo = baseKwOnlyParams.find((pi) => paramInfo.param.name === pi.param.name);
+                if (!baseParamInfo) {
+                    if (baseParamDetails.kwargsIndex === undefined) {
+                        if (!paramInfo.param.hasDefault) {
+                            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNameExtra().format({
+                                name: (_a = paramInfo.param.name) !== null && _a !== void 0 ? _a : '?',
+                            }));
+                            canOverride = false;
+                        }
+                    }
+                }
+            });
+            // Verify that if the base method has a **kwargs parameter, the override does too.
+            if (baseParamDetails.kwargsIndex !== undefined && overrideParamDetails.kwargsIndex === undefined) {
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.kwargsParamMissing().format({
+                    paramName: baseParamDetails.params[baseParamDetails.kwargsIndex].param.name,
+                }));
+                canOverride = false;
             }
-        });
+        }
         // Now check the return type.
         const baseReturnType = getFunctionEffectiveReturnType(baseMethod);
         const overrideReturnType = getFunctionEffectiveReturnType(overrideMethod);