Don't use a heuristic for ParamSpec inference from arguments

The fallout is worse lambda inference, but this is more correct

Author: A5rocks

Diff for: mypy/constraints.py

@@ -228,18 +228,13 @@ def infer_constraints_for_callable(
                 if param_spec and callee.arg_kinds[i] in (ARG_STAR, ARG_STAR2):
                     # If actual arguments are mapped to ParamSpec type, we can't infer individual
                     # constraints, instead store them and infer single constraint at the end.
-                    # It is impossible to map actual kind to formal kind, so use some heuristic.
-                    # This inference is used as a fallback, so relying on heuristic should be OK.
                     if not incomplete_star_mapping:
                         param_spec_arg_types.append(
                             mapper.expand_actual_type(
                                 actual_arg_type, arg_kinds[actual], None, arg_kinds[actual]
                             )
                         )
-                        actual_kind = arg_kinds[actual]
-                        param_spec_arg_kinds.append(
-                            ARG_POS if actual_kind not in (ARG_STAR, ARG_STAR2) else actual_kind
-                        )
+                        param_spec_arg_kinds.append(arg_kinds[actual])
                         param_spec_arg_names.append(arg_names[actual] if arg_names else None)
                 else:
                     actual_type = mapper.expand_actual_type(

Diff for: test-data/unit/check-parameter-specification.test

@@ -439,13 +439,16 @@ def f(x: int) -> None: pass
 def g(x: int, y: str) -> None: pass
 
 reveal_type(register(lambda: f(1)))  # N: Revealed type is "def ()"
-reveal_type(register(lambda x: f(x), x=1))  # N: Revealed type is "def (x: Literal[1]?)"
+reveal_type(register(lambda x: f(x), x=1))  # N: Revealed type is "def (*, x: Literal[1]?)" \
+                                            # E: Cannot infer type of lambda
 register(lambda x: f(x))  # E: Cannot infer type of lambda \
                           # E: Argument 1 to "register" has incompatible type "Callable[[Any], None]"; expected "Callable[[], None]"
-register(lambda x: f(x), y=1)  # E: Argument 1 to "register" has incompatible type "Callable[[Arg(int, 'x')], None]"; expected "Callable[[Arg(int, 'y')], None]"
+register(lambda x: f(x), y=1)  # E: Cannot infer type of lambda \
+                               # E: Argument 1 to "register" has incompatible type "Callable[[Any], None]"; expected "Callable[[NamedArg(int, 'y')], None]"
 reveal_type(register(lambda x: f(x), 1))  # N: Revealed type is "def (Literal[1]?)"
 reveal_type(register(lambda x, y: g(x, y), 1, "a"))  # N: Revealed type is "def (Literal[1]?, Literal['a']?)"
-reveal_type(register(lambda x, y: g(x, y), 1, y="a"))  # N: Revealed type is "def (Literal[1]?, y: Literal['a']?)"
+reveal_type(register(lambda x, y: g(x, y), 1, y="a"))  # N: Revealed type is "def (Literal[1]?, *, y: Literal['a']?)" \
+                                                       # E: Cannot infer type of lambda
 [builtins fixtures/dict.pyi]
 
 [case testParamSpecInvalidCalls]
@@ -1677,7 +1680,7 @@ class Foo(Generic[P]):
 def test(*args: P.args, **kwargs: P.kwargs) -> Foo[P]: ...
 
 reveal_type(test(1, 2))  # N: Revealed type is "__main__.Foo[[Literal[1]?, Literal[2]?]]"
-reveal_type(test(x=1, y=2))  # N: Revealed type is "__main__.Foo[[x: Literal[1]?, y: Literal[2]?]]"
+reveal_type(test(x=1, y=2))  # N: Revealed type is "__main__.Foo[[*, x: Literal[1]?, y: Literal[2]?]]"
 ints = [1, 2, 3]
 reveal_type(test(*ints))  # N: Revealed type is "__main__.Foo[[*builtins.int]]"
 [builtins fixtures/paramspec.pyi]
@@ -1732,7 +1735,7 @@ apply(apply, test2, 42, "yes")
 apply(apply, test2, "no", 42)  # E: Argument 1 to "apply" has incompatible type "Callable[[Callable[P, T], **P], None]"; expected "Callable[[Callable[[int, str], None], str, int], None]"
 apply(apply, test2, x=42, y="yes")
 apply(apply, test2, y="yes", x=42)
-apply(apply, test2, y=42, x="no")  # E: Argument 1 to "apply" has incompatible type "Callable[[Callable[P, T], **P], None]"; expected "Callable[[Callable[[int, str], None], int, str], None]"
+apply(apply, test2, y=42, x="no")  # E: Argument 1 to "apply" has incompatible type "Callable[[Callable[P, T], **P], None]"; expected "Callable[[Callable[[int, str], None], NamedArg(int, 'y'), NamedArg(str, 'x')], None]"
 [builtins fixtures/paramspec.pyi]
 
 [case testParamSpecApplyPosVsNamedOptional]
@@ -2157,7 +2160,7 @@ reveal_type(submit(  # N: Revealed type is "__main__.Result"
     backend="asyncio",
 ))
 submit(
-    run,  # E: Argument 1 to "submit" has incompatible type "Callable[[Callable[[], R], VarArg(object), DefaultNamedArg(str, 'backend')], R]"; expected "Callable[[Callable[[], Result], int], Result]"
+    run,  # E: Argument 1 to "submit" has incompatible type "Callable[[Callable[[], R], VarArg(object), DefaultNamedArg(str, 'backend')], R]"; expected "Callable[[Callable[[], Result], NamedArg(int, 'backend')], Result]"
     run_portal,
     backend=int(),
 )
@@ -2532,3 +2535,21 @@ class GenericWrapper(Generic[P]):
         def contains(c: Callable[P, None], *args: P.args, **kwargs: P.kwargs) -> None: ...
         def inherits(*args: P.args, **kwargs: P.kwargs) -> None: ...
 [builtins fixtures/paramspec.pyi]
+
+[case testParamSpecInferenceFromArgs]
+from typing_extensions import ParamSpec
+from typing import Any, Callable, Union
+
+P = ParamSpec("P")
+
+def into(f: Callable[P, None], *args: P.args, **kwargs: P.kwargs) -> None:
+    return None
+
+class C:
+    def f(self, y: bool = False, *, x: int = 42) -> None:
+        return None
+
+ex: Union[C, Any] = C()
+
+into(ex.f, x=-1)
+[builtins fixtures/paramspec.pyi]