Fix lambda contextual typing with keyword-only callables

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

@@ -15264,6 +15264,7 @@ export function createTypeEvaluator(
             // more sophisticated in the future, but it becomes very complex to handle
             // all of the permutations.
             let sawParamMismatch = false;
+            let sawLambdaArgsParam = false;
 
             node.d.params.forEach((param, index) => {
                 let paramType: Type | undefined;
@@ -15277,7 +15278,8 @@ export function createTypeEvaluator(
                         // from the expected parameter.
                         if (
                             expectedParam.param.category === param.d.category &&
-                            !param.d.name === !expectedParam.param.name
+                            !param.d.name === !expectedParam.param.name &&
+                            (expectedParam.kind !== ParamKind.Keyword || sawLambdaArgsParam)
                         ) {
                             paramType = expectedParam.type;
                         } else {
@@ -15348,6 +15350,10 @@ export function createTypeEvaluator(
                 );
 
                 FunctionType.addParam(functionType, functionParam);
+
+                if (param.d.category === ParamCategory.ArgsList) {
+                    sawLambdaArgsParam = true;
+                }
             });
 
             if (paramsArePositionOnly && functionType.shared.parameters.length > 0) {

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

@@ -1,7 +1,7 @@
 # This sample tests the case where a lambda is assigned to
 # a union type that contains multiple callables.
 
-from typing import Callable, Protocol, TypeVar
+from typing import Callable, Generic, Protocol, Self, TypeVar
 
 
 U1 = Callable[[int, str], bool] | Callable[[str], bool]
@@ -76,3 +76,38 @@ def accepts_u2(cb: U2) -> U2:
 def accepts_u3(u: U3):
     # This should generate an error.
     u(lambda v: v.lower())
+
+
+class KeywordOnlyCallable:
+    def __call__(self, *, kwarg: int) -> Self: ...
+
+
+keyword_only_union: Callable[[KeywordOnlyCallable], KeywordOnlyCallable] | KeywordOnlyCallable = lambda x: x
+
+
+class GenericKeywordOnlyCallable(Generic[T]):
+    def __call__(self, *, kwarg: T) -> Self: ...
+
+
+generic_keyword_only_union: (
+    Callable[[GenericKeywordOnlyCallable[int]], GenericKeywordOnlyCallable[int]] | GenericKeywordOnlyCallable[int]
+) = lambda x: x
+
+
+class KeywordOnlyCallback(Protocol):
+    def __call__(self, *, value: int) -> Self: ...
+
+
+protocol_keyword_only_union: Callable[[KeywordOnlyCallback], KeywordOnlyCallback] | KeywordOnlyCallback = lambda x: x
+
+ordinary_callable_union: Callable[[int], int] | Callable[[str], str] = lambda x: x
+
+
+class PositionalCallable:
+    def __call__(self, value: int) -> Self: ...
+
+
+positional_callable_union: Callable[[PositionalCallable], PositionalCallable] | PositionalCallable = lambda x: x
+
+# This should generate an error.
+keyword_only_callback: KeywordOnlyCallback = lambda x: x

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

@@ -726,7 +726,7 @@ test('Lambda3', () => {
 test('Lambda4', () => {
     const analysisResults = TestUtils.typeAnalyzeSampleFiles(['lambda4.py']);
 
-    TestUtils.validateResults(analysisResults, 2);
+    TestUtils.validateResults(analysisResults, 3);
 });
 
 test('Lambda5', () => {