Revert "Don't use a heuristic for ParamSpec inference from arguments"

This reverts commit 9e768ae.

Author: A5rocks

mypy/constraints.py

@@ -228,13 +228,18 @@ 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]
                             )
                         )
-                        param_spec_arg_kinds.append(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_names.append(arg_names[actual] if arg_names else None)
                 else:
                     actual_type = mapper.expand_actual_type(

test-data/unit/check-parameter-specification.test

@@ -440,16 +440,13 @@ 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]?)" \
-                                            # E: Cannot infer type of lambda
+reveal_type(register(lambda x: f(x), x=1))  # N: Revealed type is "def (x: Literal[1]?)"
 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: Cannot infer type of lambda \
-                               # E: Argument 1 to "register" has incompatible type "Callable[[Any], None]"; expected "Callable[[NamedArg(int, 'y')], 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]"
 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']?)" \
-                                                       # E: Cannot infer type of lambda
+reveal_type(register(lambda x, y: g(x, y), 1, y="a"))  # N: Revealed type is "def (Literal[1]?, y: Literal['a']?)"
 [builtins fixtures/dict.pyi]
 
 [case testParamSpecInvalidCalls]
@@ -1681,7 +1678,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]
@@ -1736,7 +1733,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], NamedArg(int, 'y'), NamedArg(str, 'x')], 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], int, str], None]"
 [builtins fixtures/paramspec.pyi]
 
 [case testParamSpecApplyPosVsNamedOptional]
@@ -2161,7 +2158,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], NamedArg(int, 'backend')], Result]"
+    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_portal,
     backend=int(),
 )
@@ -2537,24 +2534,6 @@ class GenericWrapper(Generic[P]):
         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]
-
 [case testCallbackProtocolClassObjectParamSpec]
 from typing import Any, Callable, Protocol, Optional, Generic
 from typing_extensions import ParamSpec