added testContextFreeConcatInvariantType and testInContextConcatInvariantType

Author: randolf-scholz

mypy/checkexpr.py

@@ -121,6 +121,7 @@
 from mypy.subtypes import (
     find_member,
     is_equivalent,
+    is_proper_subtype,
     is_same_type,
     is_subtype,
     non_method_protocol_members,
@@ -2167,7 +2168,10 @@ def infer_function_type_arguments(
                     # joint constraints failed to produce a complete solution
                     None in joint_solution[0]
                     # If the outer solution is more concrete than the joint solution, prefer the outer solution.
-                    or is_subtype(outer_ret_type, joint_ret_type)
+                    or (
+                        is_subtype(outer_ret_type, joint_ret_type)
+                        and not is_proper_subtype(joint_ret_type, outer_ret_type)
+                    )
                 ):
                     use_joint = False
                 else:

test-data/unit/check-generics.test

@@ -3657,3 +3657,43 @@ t2.foo = [B()]
 t2.foo = [C()]
 t2.foo = [1]  # E: Value of type variable "T" of "foo" of "Test" cannot be "int"
 [builtins fixtures/property.pyi]
+
+[case testContextFreeConcatInvariantType]
+from typing import Iterable, Iterator, TypeVar, Generic, Union
+
+T = TypeVar("T")
+S = TypeVar("S")
+
+class Vec(Generic[T]):
+    def getitem(self, i: int) -> T: ...            # ensure invariance of T
+    def setitem(self, i: int, v: T) -> None: ...   # ensure invariance of T
+    def __iter__(self) -> Iterator[T]: ...
+    def __add__(self, other: "Vec[S]") -> "Vec[Union[T, S]]": ...
+
+mix: Vec[Union[int, str]]
+strings: Vec[str]
+mix = mix + strings
+mix = strings + mix
+reveal_type(mix + strings)  # N: Revealed type is "__main__.Vec[Union[builtins.int, builtins.str]]"
+reveal_type(strings + mix)  # N: Revealed type is "__main__.Vec[Union[builtins.str, builtins.int]]"
+[builtins fixtures/list.pyi]
+
+
+[case testInContextConcatInvariantType]
+# https://github.com/python/mypy/issues/3933#issuecomment-2272804302
+from typing import Iterable, Iterator, TypeVar, Generic, Union
+
+T = TypeVar("T")
+S = TypeVar("S")
+
+class Vec(Generic[T]):
+    def getitem(self, i: int) -> T: ...            # ensure invariance of T
+    def setitem(self, i: int, v: T) -> None: ...   # ensure invariance of T
+    def __iter__(self) -> Iterator[T]: ...
+    def __add__(self, other: "Vec[S]") -> "Vec[Union[T, S]]": ...
+
+def identity_on_iterable(arg: Iterable[T]) -> Iterable[T]: return arg
+x: Vec[str]
+y: Vec[None]
+reveal_type( identity_on_iterable(y + x) )  # N: Revealed type is "typing.Iterable[Union[None, builtins.str]]"
+reveal_type( identity_on_iterable(x + y) )  # N: Revealed type is "typing.Iterable[Union[builtins.str, None]]"