1 check remaining

Author: randolf-scholz

mypy/checkexpr.py

@@ -2344,6 +2344,18 @@ def infer_function_type_arguments(
                         # Otherwise, we use joint.
                         combined_solution.append(joint_tp)
 
+                # if the outer solution is more concrete than the joint solution, use the outer solution (2 step)
+                if all(
+                    (joint_tp is None and outer_tp is None)
+                    or (
+                        (joint_tp is not None and outer_tp is not None)
+                        and is_subtype(outer_tp, joint_tp)
+                    )
+                    for outer_tp, joint_tp in zip(outer_solution[0], target_solution[0])
+                ):
+                    use_joint = False
+                    use_outer = True
+
                 _num = arg_pass_nums
                 _c0 = constraints
                 _c1 = extra_constraints
@@ -2362,22 +2374,9 @@ def infer_function_type_arguments(
                 _s2 = inner_solution[0]
                 _s3 = joint_solution[0]
                 _s4 = reverse_joint_solution[0]
-                _s5 = combined_solution
-
+                _t0 = target_solution[0]
                 _u0 = use_inner, use_outer, use_joint
 
-                # if the outer solution is more concrete than the joint solution, use the outer solution (2 step)
-                if all(
-                    (joint_tp is None and outer_tp is None)
-                    or (
-                        (joint_tp is not None and outer_tp is not None)
-                        and is_subtype(outer_tp, joint_tp)
-                    )
-                    for outer_tp, joint_tp in zip(outer_solution[0], target_solution[0])
-                ):
-                    use_joint = False
-                    use_outer = True
-
                 if use_joint:
                     new_inferred_args = target_solution[0]
                     # inferred_args = [

test-data/unit/check-generics.test

@@ -2929,8 +2929,8 @@ def mix(fs: List[Callable[[S], T]]) -> Callable[[S], List[T]]:
 def id(__x: U) -> U:
     ...
 fs = [id, id, id]
-reveal_type(mix(fs))  # N: Revealed type is "def [S] (S`23) -> builtins.list[S`23]"
-reveal_type(mix([id, id, id]))  # N: Revealed type is "def [S] (S`25) -> builtins.list[S`25]"
+reveal_type(mix(fs))  # N: Revealed type is "def [S] (S`35) -> builtins.list[S`35]"
+reveal_type(mix([id, id, id]))  # N: Revealed type is "def [S] (S`37) -> builtins.list[S`37]"
 [builtins fixtures/list.pyi]
 
 [case testInferenceAgainstGenericCurry]

test-data/unit/check-recursive-types.test

@@ -285,21 +285,33 @@ if isinstance(b[0], Sequence):
 [case testRecursiveAliasWithRecursiveInstance]
 from typing import Sequence, Union, TypeVar
 
-class A: ...
 T = TypeVar("T")
 Nested = Sequence[Union[T, Nested[T]]]
+def join(a: T, b: T) -> T: ...
+
+class A: ...
 class B(Sequence[B]): ...
 
 a: Nested[A]
 aa: Nested[A]
 b: B
+
 a = b  # OK
+reveal_type(a)  # N: Revealed type is "__main__.B"
+
 a = [[b]]  # OK
+reveal_type(a)  # N: Revealed type is "builtins.list[builtins.list[__main__.B]]"
+
 b = aa  # E: Incompatible types in assignment (expression has type "Nested[A]", variable has type "B")
+reveal_type(b)  # N: Revealed type is "__main__.B"
+
+reveal_type(join(a, b))  # N: Revealed type is "typing.Sequence[typing.Sequence[__main__.B]]"
+reveal_type(join(b, a))  # N: Revealed type is "typing.Sequence[typing.Sequence[__main__.B]]"
+
+def test(a: Nested[A], b: B) -> None:
+     reveal_type(join(a, b))  # N: Revealed type is "typing.Sequence[Union[__main__.A, typing.Sequence[Union[__main__.A, ...]]]]"
+     reveal_type(join(b, a))  # N: Revealed type is "typing.Sequence[Union[__main__.A, typing.Sequence[Union[__main__.A, ...]]]]"
 
-def join(a: T, b: T) -> T: ...
-reveal_type(join(a, b))  # N: Revealed type is "typing.Sequence[Union[__main__.A, typing.Sequence[Union[__main__.A, ...]]]]"
-reveal_type(join(b, a))  # N: Revealed type is "typing.Sequence[Union[__main__.A, typing.Sequence[Union[__main__.A, ...]]]]"
 [builtins fixtures/isinstancelist.pyi]
 
 [case testRecursiveAliasWithRecursiveInstanceInference]