change join behavior between literal and last_known_value

Author: randolf-scholz

mypy/join.py

@@ -277,7 +277,7 @@ def visit_union_type(self, t: UnionType) -> ProperType:
         elif isinstance(self.s, LiteralType):
             # E.g.  join("x", "y" | "z") -> "x" | "y" | "z"
             #   and join(1, "y" | "z") -> object
-            return mypy.typeops.make_simplified_union(join_types(self.s, x) for x in t.items)
+            return mypy.typeops.make_simplified_union([join_types(self.s, x) for x in t.items])
         else:
             return mypy.typeops.make_simplified_union([self.s, t])
 
@@ -637,8 +637,8 @@ def visit_literal_type(self, t: LiteralType) -> ProperType:
                 return mypy.typeops.make_simplified_union([self.s, t])
             return join_types(self.s.fallback, t.fallback)
         elif isinstance(self.s, Instance) and self.s.last_known_value == t:
-            # E.g. Literal["x"], Literal["x"]? -> Literal["x"]
-            return t
+            # E.g. Literal["x"], Literal["x"]? -> Literal["x"]?
+            return self.s
         else:
             # E.g. Literal["x"], Literal["y"]? -> str
             return join_types(self.s, t.fallback)

mypy/solve.py

@@ -319,7 +319,8 @@ def solve_one(lowers: Iterable[Type], uppers: Iterable[Type]) -> Type | None:
     elif top is None:
         candidate = bottom
     elif is_subtype(bottom, top):
-        candidate = bottom
+        # Need to meet in case like Literal["x"]? <: T <: Literal["x"]
+        candidate = meet_types(bottom, top)
     else:
         candidate = None
     return candidate

mypy/test/testtypes.py

@@ -1068,11 +1068,11 @@ def test_mixed_literal_types(self) -> None:
 
         # other operand is the same literal
         # "x" , "x"  -> "x"
-        # "x" , "x"? -> "x"
-        # "x"?, "x"  -> "x"
+        # "x" , "x"? -> "x"?
+        # "x"?, "x"  -> "x"?
         # "x"?, "x"? -> "x"?
         self.assert_join(str1, str1, str1)
-        self.assert_join(str1, str1_inst, str1)
+        self.assert_join(str1, str1_inst, str1_inst)
         self.assert_join(str1_inst, str1_inst, str1_inst)
 
         # other operand is a different literal

test-data/unit/check-literal.test

@@ -2980,18 +2980,29 @@ z: Type[Literal[1, 2]]  # E: Type[...] can't contain "Union[Literal[...], Litera
 [case testJoinLiteralAndInstance]
 from typing import Generic, TypeVar, Literal
 
-T = TypeVar("T")
+T_co = TypeVar("T_co", covariant=True)
+T = TypeVar("T", covariant=False, contravariant=False)
+S = TypeVar("S", covariant=False, contravariant=False)
 
-class A(Generic[T]): ...
+class A_inv(Generic[T]): ...
+class A_co(Generic[T_co]): ...
 
-def f(a: A[T], t: T) -> T: ...
-def g(a: T, t: A[T]) -> T: ...
+def check_inv(obj: A_inv[Literal[1]]) -> None:
+    def f(a: A_inv[S], t: S) -> S: ...
+    def g(a: S, t: A_inv[S]) -> S: ...
 
-def check(obj: A[Literal[1]]) -> None:
     reveal_type(f(obj, 1))  # N: Revealed type is "Literal[1]"
-    reveal_type(f(obj, ''))  # E: Cannot infer value of type parameter "T" of "f" \
-                             # N: Revealed type is "Any"
+    reveal_type(f(obj, '')) # E: Cannot infer value of type parameter "S" of "f" \
+                            # N: Revealed type is "Any"
     reveal_type(g(1, obj))  # N: Revealed type is "Literal[1]"
-    reveal_type(g('', obj))  # E: Cannot infer value of type parameter "T" of "g" \
-                             # N: Revealed type is "Any"
-[builtins fixtures/tuple.pyi]
+    reveal_type(g('', obj)) # E: Cannot infer value of type parameter "S" of "g" \
+                            # N: Revealed type is "Any"
+
+def check_co(obj: A_co[Literal[1]]) -> None:
+    def f(a: A_co[S], t: S) -> S: ...
+    def g(a: S, t: A_co[S]) -> S: ...
+
+    reveal_type(f(obj, 1))   # N: Revealed type is "builtins.int"
+    reveal_type(f(obj, ''))  # N: Revealed type is "builtins.object"
+    reveal_type(g(1, obj))   # N: Revealed type is "builtins.int"
+    reveal_type(g('', obj))  # N: Revealed type is "builtins.object"