Squash some more bugs

Co-authored-by: Marc Mueller <30130371+cdce8p@users.noreply.github.com>
python · JukkaL · Apr 7, 2022 · Dec 24, 2021 · Dec 25, 2021 · Dec 26, 2021
commit ddfd34a346aa7edcb572467da10ce319ae31c97b
diff --git a/mypy/constraints.py b/mypy/constraints.py
@@ -467,6 +467,9 @@ def visit_instance(self, template: Instance) 
8000
-> List[Constraint]:
                                                           suffix.arg_kinds[len(prefix.arg_kinds):],
                                                           suffix.arg_names[len(prefix.arg_names):])
                             res.append(Constraint(mapped_arg.id, SUPERTYPE_OF, suffix))
+                        elif isinstance(suffix, ParamSpecType):
+                            res.append(Constraint(mapped_arg.id, SUPERTYPE_OF, suffix))
+
                 return res
             elif (self.direction == SUPERTYPE_OF and
                     instance.type.has_base(template.type.fullname)):
@@ -496,6 +499,8 @@ def visit_instance(self, template: Instance) -> List[Constraint]:
                                                           suffix.arg_kinds[len(prefix.arg_kinds):],
                                                           suffix.arg_names[len(prefix.arg_names):])
                             res.append(Constraint(template_arg.id, SUPERTYPE_OF, suffix))
+                        elif isinstance(suffix, ParamSpecType):
+                            res.append(Constraint(template_arg.id, SUPERTYPE_OF, suffix))
                 return res
             if (template.type.is_protocol and self.direction == SUPERTYPE_OF and
                     # We avoid infinite recursion for structural subtypes by checking
@@ -586,27 +591,32 @@ def visit_callable_type(self, template: CallableType) -> List[Constraint]:
                         # Negate direction due to function argument type contravariance.
                         res.extend(infer_constraints(t, a, neg_op(self.direction)))
             else:
-                # TODO: Direction
-                # TODO: check the prefixes match
-                prefix = param_spec.prefix
-                prefix_len = len(prefix.arg_types)
-                res.append(Constraint(param_spec.id,
-                                      SUBTYPE_OF,
-                                      cactual.copy_modified(
-                                        arg_types=cactual.arg_types[prefix_len:],
-                                        arg_kinds=cactual.arg_kinds[prefix_len:],
-                                        arg_names=cactual.arg_names[prefix_len:],
-                                        ret_type=NoneType())))
-                # compare prefixes
-                cactual_prefix = cactual.copy_modified(
-                    arg_types=cactual.arg_types[:prefix_len],
-                    arg_kinds=cactual.arg_kinds[:prefix_len],
-                    arg_names=cactual.arg_names[:prefix_len])
-
-                # TODO: see above "FIX" comments for param_spec is None case
-                # TODO: this assume positional arguments
-                for t, a in zip(prefix.arg_types, cactual_prefix.arg_types):
-                    res.extend(infer_constraints(t, a, neg_op(self.direction)))
+                # sometimes, it appears we try to get constraints between two paramspec callables?
+                cactual_ps = cactual.param_spec()
+                if cactual_ps:
+                    res.append(Constraint(param_spec.id, SUBTYPE_OF, cactual_ps))
+                else:
+                    # TODO: Direction
+                    # TODO: check the prefixes match
+                    prefix = param_spec.prefix
+                    prefix_len = len(prefix.arg_types)
+                    res.append(Constraint(param_spec.id,
+                                          SUBTYPE_OF,
+                                          cactual.copy_modified(
+                                            arg_types=cactual.arg_types[prefix_len:],
+                                            arg_kinds=cactual.arg_kinds[prefix_len:],
+                                            arg_names=cactual.arg_names[prefix_len:],
+                                            ret_type=NoneType())))
+                    # compare prefixes
+                    cactual_prefix = cactual.copy_modified(
+                        arg_types=cactual.arg_types[:prefix_len],
+                        arg_kinds=cactual.arg_kinds[:prefix_len],
+                        arg_names=cactual.arg_names[:prefix_len])
+
+                    # TODO: see above "FIX" comments for param_spec is None case
+                    # TODO: this assume positional arguments
+                    for t, a in zip(prefix.arg_types, cactual_prefix.arg_types):
+                        res.extend(infer_constraints(t, a, neg_op(self.direction)))
 
             template_ret_type, cactual_ret_type = template.ret_type, cactual.ret_type
             if template.type_guard is not None:

diff --git a/mypy/nodes.py b/mypy/nodes.py
@@ -1031,18 +1031,10 @@ def serialize(self) -> JsonDict:
     @classmethod
     def deserialize(self, data: JsonDict) -> 'ClassDef':
         assert data['.class'] == 'ClassDef'
-
-        tvs_ = [mypy.types.deserialize_type(v) for v in data['type_vars']]
-        tvs = []
-        for tv in tvs_:
-            # mypy tells me to expand `tv`, which isn't necessary I believe?
-            assert isinstance(tv, mypy.types.TypeVarLikeType)  # type: ignore[misc]
-            tvs.append(tv)
-
         res = ClassDef(data['name'],
                        Block([]),
                        # https://github.com/python/mypy/issues/12257
-                       tvs,
+                       [cast(mypy.types.TypeVarLikeType, mypy.types.deserialize_type(v)) for v in data['type_vars']],
                        )
         res.fullname = data['fullname']
         return res

diff --git a/mypy/types.py b/mypy/types.py
@@ -1653,16 +1653,23 @@ def param_spec(self) -> Optional[ParamSpecType]:
     def expand_param_spec(self,
                           c: Union['CallableType', Parameters],
                           no_prefix: bool = False) -> 'CallableType':
+        if isinstance(c, CallableType):
+            variables = c.variables
+        else:
+            variables = []
+
         if no_prefix:
             return self.copy_modified(arg_types=c.arg_types,
                                       arg_kinds=c.arg_kinds,
                                       arg_names=c.arg_names,
-                                      is_ellipsis_args=c.is_ellipsis_args)
+                                      is_ellipsis_args=c.is_ellipsis_args,
+                                      variables=variables + self.variables)
         else:
             return self.copy_modified(arg_types=self.arg_types[:-2] + c.arg_types,
                                       arg_kinds=self.arg_kinds[:-2] + c.arg_kinds,
                                       arg_names=self.arg_names[:-2] + c.arg_names,
-                                      is_ellipsis_args=c.is_ellipsis_args)
+                                      is_ellipsis_args=c.is_ellipsis_args,
+                                      variables=variables + self.variables)
 
     def __hash__(self) -> int:
         return hash((self.ret_type, self.is_type_obj(),

diff --git a/test-data/unit/check-parameter-specification.test b/test-data/unit/check-parameter-specification.test
@@ -817,3 +817,68 @@ reveal_type(A().func(f, 42))  # N: Revealed type is "builtins.int*"
 # TODO: this should reveal `int`
 reveal_type(A().func(lambda x: x + x, 42))  # N: Revealed type is "Any"
 [builtins fixtures/tuple.pyi]
+
+[case testParamSpecConstraintOnOtherParamSpec]
+from typing import Callable, TypeVar, Any, Generic
+from typing_extensions import ParamSpec
+
+CallableT = TypeVar("CallableT", bound=Callable[..., Any])
+_P = ParamSpec("_P")
+_R_co = TypeVar("_R_co", covariant=True)
+
+def simple_decorator(callable: CallableT) -> CallableT:
+    ...
+
+class Job(Generic[_P, _R_co]):
+    def __init__(self, target: Callable[_P, _R_co]) -> None:
+        ...
+
+
+class A:
+    @simple_decorator
+    def func(self, action: Job[_P, None]) -> Job[_P, None]:
+        ...
+
+reveal_type(A.func)  # N: Revealed type is "def [_P] (self: __main__.A, action: __main__.Job[_P`-1, None]) -> __main__.Job[_P`-1, None]"
+reveal_type(A().func)  # N: Revealed type is "def [_P] (action: __main__.Job[_P`4, None]) -> __main__.Job[_P`4, None]"
+reveal_type(A().func(Job(lambda x: x)))  # N: Revealed type is "__main__.Job[def (x: Any), None]"
+
+def f(x: int, y: int) -> None: ...
+reveal_type(A().func(Job(f)))  # N: Revealed type is "__main__.Job[def (x: builtins.int, y: builtins.int), None]"
+[builtins fixtures/tuple.pyi]
+
+[case testConstraintBetweenParamSpecFunctions1]
+from typing import Callable, TypeVar, Any, Generic
+from typing_extensions import ParamSpec
+
+_P = ParamSpec("_P")
+_R_co = TypeVar("_R_co", covariant=True)
+
+def simple_decorator(callable: Callable[_P, _R_co]) -> Callable[_P, _R_co]: ...
+class Job(Generic[_P]): ...
+
+
+@simple_decorator
+def func(action: Job[_P], /) -> Callable[_P, None]:
+    ...
+
+reveal_type(func)  # N: Revealed type is "def [_P] (__main__.Job[_P`-1]) -> def (*_P.args, **_P.kwargs)"
+[builtins fixtures/tuple.pyi]
+
+[case test
6DD9
ConstraintBetweenParamSpecFunctions2]
+from typing import Callable, TypeVar, Any, Generic
+from typing_extensions import ParamSpec
+
+CallableT = TypeVar("CallableT", bound=Callable[..., Any])
+_P = ParamSpec("_P")
+
+def simple_decorator(callable: CallableT) -> CallableT: ...
+class Job(Generic[_P]): ...
+
+
+@simple_decorator
+def func(action: Job[_P], /) -> Callable[_P, None]:
+    ...
+
+reveal_type(func)  # N: Revealed type is "def [_P] (__main__.Job[_P`-1]) -> def (*_P.args, **_P.kwargs)"
+[builtins fixtures/tuple.pyi]