Prepare for GitHub Actions

Author: A5rocks

mypy/constraints.py

@@ -458,16 +458,17 @@ def visit_instance(self, template: Instance) -> List[Constraint]:
                                 mapped_arg, instance_arg, neg_op(self.direction)))
                     elif isinstance(tvar, ParamSpecType) and isinstance(mapped_arg, ParamSpecType):
                         suffix = get_proper_type(instance_arg)
+
+                        if isinstance(suffix, CallableType):
+                            prefix = mapped_arg.prefix
+                            from_concat = bool(prefix.arg_types) or suffix.from_concatenate
+                            suffix = suffix.copy_modified(from_concatenate=from_concat)
+
                         if isinstance(suffix, Parameters) or isinstance(suffix, CallableType):
                             # no such thing as variance for ParamSpecs
                             # TODO: is there a case I am missing?
                             # TODO: constraints between prefixes
                             prefix = mapped_arg.prefix
-
-                            if isinstance(suffix, CallableType):
-                                from_concatenate = bool(prefix.arg_types) or suffix.from_concatenate
-                                suffix = suffix.copy_modified(from_concatenate=from_concatenate)
-
                             suffix = suffix.copy_modified(
                                 suffix.arg_types[len(prefix.arg_types):],
                                 suffix.arg_kinds[len(prefix.arg_kinds):],
@@ -496,16 +497,18 @@ def visit_instance(self, template: Instance) -> List[Constraint]:
                     elif (isinstance(tvar, ParamSpecType) and
                           isinstance(template_arg, ParamSpecType)):
                         suffix = get_proper_type(mapped_arg)
+
+                        if isinstance(suffix, CallableType):
+                            prefix = template_arg.prefix
+                            from_concat = bool(prefix.arg_types) or suffix.from_concatenate
+                            suffix = suffix.copy_modified(from_concatenate=from_concat)
+
                         if isinstance(suffix, Parameters) or isinstance(suffix, CallableType):
                             # no such thing as variance for ParamSpecs
                             # TODO: is there a case I am missing?
                             # TODO: constraints between prefixes
                             prefix = template_arg.prefix
 
-                            if isinstance(suffix, CallableType):
-                                from_concatenate = bool(prefix.arg_types) or suffix.from_concatenate
-                                suffix = suffix.copy_modified(from_concatenate=from_concatenate)
-
                             suffix = suffix.copy_modified(
                                 suffix.arg_types[len(prefix.arg_types):],
                                 suffix.arg_kinds[len(prefix.arg_kinds):],

mypy/nodes.py

@@ -1034,7 +1034,8 @@ def deserialize(self, data: JsonDict) -> 'ClassDef':
         res = ClassDef(data['name'],
                        Block([]),
                        # https://github.com/python/mypy/issues/12257
-                       [cast(mypy.types.TypeVarLikeType, mypy.types.deserialize_type(v)) for v in data['type_vars']],
+                       [cast(mypy.types.TypeVarLikeType, mypy.types.deserialize_type(v))
+                        for v in data['type_vars']],
                        )
         res.fullname = data['fullname']
         return res

mypy/subtypes.py

@@ -1053,7 +1053,9 @@ def _incompatible(left_arg: Optional[FormalArgument],
         right_names = {name for name in right.arg_names if name is not None}
         left_only_names = set()
         for name, kind in zip(left.arg_names, left.arg_kinds):
-            if name is None or kind.is_star() or name in right_names or not strict_concatenate_check:
+            if (name is None or kind.is_star()
+                    or name in right_names
+                    or not strict_concatenate_check):
                 continue
             left_only_names.add(name)
 

mypy/types.py

@@ -1663,13 +1663,13 @@ def expand_param_spec(self,
                                       arg_kinds=c.arg_kinds,
                                       arg_names=c.arg_names,
                                       is_ellipsis_args=c.is_ellipsis_args,
-                                      variables=variables + self.variables)
+                                      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,
-                                      variables=variables + self.variables)
+                                      variables=[*variables, *self.variables])
 
     def __hash__(self) -> int:
         return hash((self.ret_type, self.is_type_obj(),

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

@@ -573,6 +573,7 @@ reveal_type(f(n))  # N: Revealed type is "def (builtins.int, builtins.bytes) ->
 [builtins fixtures/tuple.pyi]
 
 [case testParamSpecConcatenateNamedArgs]
+# flags: --strict-concatenate
 # this is one noticeable deviation from PEP but I believe it is for the better
 from typing_extensions import ParamSpec, Concatenate
 from typing import Callable, TypeVar
@@ -590,14 +591,39 @@ def f2(c: Callable[P, R]) -> Callable[Concatenate[int, P], R]:
 
     return result  # Rejected
 
+# reason for rejection:
+f2(lambda x: 42)(42, x=42)
+[builtins fixtures/tuple.pyi]
+[out]
+main:10: error: invalid syntax
+[out version>=3.8]
+main:17: error: Incompatible return value type (got "Callable[Concatenate[Arg(int, 'x'), P], R]", expected "Callable[Concatenate[int, P], R]")
+main:17: note: This may be because "result" has arguments named: "x"
+
+[case testNonStrictParamSpecConcatenateNamedArgs]
+# this is one noticeable deviation from PEP but I believe it is for the better
+from typing_extensions import ParamSpec, Concatenate
+from typing import Callable, TypeVar
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+def f1(c: Callable[P, R]) -> Callable[Concatenate[int, P], R]:
+    def result(x: int, /, *args: P.args, **kwargs: P.kwargs) -> R: ...
+
+    return result  # Accepted
+
+def f2(c: Callable[P, R]) -> Callable[Concatenate[int, P], R]:
+    def result(x: int, *args: P.args, **kwargs: P.kwargs) -> R: ...
+
+    return result  # Rejected -> Accepted
+
 # reason for rejection:
 f2(lambda x: 42)(42, x=42)
 [builtins fixtures/tuple.pyi]
 [out]
 main:9: error: invalid syntax
 [out version>=3.8]
-main:16: error: Incompatible return value type (got "Callable[Concatenate[Arg(int, 'x'), P], R]", expected "Callable[Concatenate[int, P], R]")
-main:16: note: This may be because "result" has arguments named: "x"
 
 [case testParamSpecConcatenateWithTypeVar]
 from typing_extensions import ParamSpec, Concatenate
@@ -840,7 +866,8 @@ class A:
         ...
 
 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]"
+# TODO: flakey, _P`4 alternates around.
+# 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: ...