Fix lambda contextual typing with keyword-only callables

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

@@ -15264,20 +15264,35 @@ 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;
+            const positionOnlySeparatorIndex = node.d.params.findIndex(
+                (param) => param.d.category === ParamCategory.Simple && !param.d.name
+            );
 
             node.d.params.forEach((param, index) => {
                 let paramType: Type | undefined;
 
                 if (expectedParamDetails && !sawParamMismatch) {
                     if (index < expectedParamDetails.params.length) {
                         const expectedParam = expectedParamDetails.params[index];
+                        const isPositionOnlyParam =
+                            (positionOnlySeparatorIndex >= 0 && index < positionOnlySeparatorIndex) ||
+                            (positionOnlySeparatorIndex < 0 &&
+                                paramsArePositionOnly &&
+                                !!param.d.name &&
+                                isPrivateName(param.d.name.d.value));
+                        const isCompatibleKeywordParam =
+                            expectedParam.kind !== ParamKind.Keyword ||
+                            sawLambdaArgsParam ||
+                            (!isPositionOnlyParam && param.d.name?.d.value === expectedParam.param.name);
 
                         // If the parameter category matches and both of the parameters are
                         // either separators (/ or *) or not separators, copy the type
                         // from the expected parameter.
                         if (
                             expectedParam.param.category === param.d.category &&
-                            !param.d.name === !expectedParam.param.name
+                            !param.d.name === !expectedParam.param.name &&
+                            isCompatibleKeywordParam
                         ) {
                             paramType = expectedParam.type;
                         } else {
@@ -15348,6 +15363,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, assert_type
 
 
 U1 = Callable[[int, str], bool] | Callable[[str], bool]
@@ -76,3 +76,55 @@ 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
+
+
+class KeywordOnlyIntCallback(Protocol):
+    def __call__(self, *, value: int) -> int: ...
+
+
+same_name_keyword_only_callback: KeywordOnlyIntCallback = lambda value: assert_type(value, int)
+
+
+class VariadicKeywordOnlyCallback(Protocol):
+    def __call__(self, *args: object, value: int) -> int: ...
+
+
+variadic_keyword_only_callback: VariadicKeywordOnlyCallback = lambda *args, value: assert_type(value, int)
+
+# This should generate an error.
+position_only_keyword_callback: KeywordOnlyIntCallback = lambda value, /: value

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, 4);
 });
 
 test('Lambda5', () => {