Fixed false negative when a keyword parameter in a child class method overrides a method with a **kwargs in the parent and the type is incompatible. This addresses #10815. (#10866)

Author: erictraut

packages/pyright-internal/src/analyzer/typeEvaluator.ts

@@ -27885,6 +27885,28 @@ export function createTypeEvaluator(
                             );
                             canOverride = false;
                         }
+                    } else {
+                        // Base has a **kwargs; ensure the added keyword-only parameter's
+                        // type is compatible with the base's **kwargs value type.
+                        const baseKwargsType = baseParamDetails.params[baseParamDetails.kwargsIndex].type;
+                        if (
+                            !assignType(
+                                paramInfo.type,
+                                baseKwargsType,
+                                diag?.createAddendum(),
+                                constraints,
+                                AssignTypeFlags.Default
+                            )
+                        ) {
+                            diag?.addMessage(
+                                LocAddendum.overrideParamKeywordType().format({
+                                    name: paramInfo.param.name ?? '?',
+                                    baseType: printType(baseKwargsType),
+                                    overrideType: printType(paramInfo.type),
+                                })
+                            );
+                            canOverride = false;
+                        }
                     }
                 }
             });

packages/pyright-internal/src/tests/samples/methodOverride1.py

@@ -146,6 +146,8 @@ def __my_method46__(self, x: int) -> None: ...
 
     def __my_method47__(self, x: int) -> None: ...
 
+    def my_method48(self, /, **kwargs: object) -> None: ...
+
 
 T_ChildClass = TypeVar("T_ChildClass", bound="ChildClass")
 
@@ -311,6 +313,10 @@ def __my_method46__(self, y: int) -> None: ...
     # This should generate an error because of a type mismatch.
     def __my_method47__(self, y: str) -> None: ...
 
+    # This should generate an error because the keyword-only parameter "x: int"
+    # is not compatible with the base method's "**kwargs: object".
+    def my_method48(self, /, *, x: int = 3, **kwargs: object) -> None: ...
+
 
 class A:
     def test(self, t: Sequence[int]) -> Sequence[str]: ...

packages/pyright-internal/src/tests/typeEvaluator3.test.ts

@@ -946,7 +946,7 @@ test('MethodOverride1', () => {
 
     configOptions.diagnosticRuleSet.reportIncompatibleMethodOverride = 'error';
     analysisResults = TestUtils.typeAnalyzeSampleFiles(['methodOverride1.py'], configOptions);
-    TestUtils.validateResults(analysisResults, 42);
+    TestUtils.validateResults(analysisResults, 43);
 });
 
 test('MethodOverride2', () => {