replace one hack with another

Author: randolf-scholz

mypy/checkexpr.py

@@ -2108,6 +2108,19 @@ def infer_function_type_arguments(
                     formal_to_actual,
                     context=self.argument_infer_context(),
                 )
+                # HACK: convert "Literal?" constraints to their non-literal versions.
+                inner_constraints = [
+                    Constraint(
+                        c.original_type_var,
+                        c.op,
+                        (
+                            c.target.copy_modified(last_known_value=None)
+                            if isinstance(c.target, Instance)
+                            else c.target
+                        ),
+                    )
+                    for c in inner_constraints
+                ]
 
                 # compute the outer solution
                 outer_constraints = self.infer_constraints_from_context(callee_type, context)
@@ -2131,9 +2144,10 @@ def infer_function_type_arguments(
                 # NOTE: The order of constraints is important here!
                 #  solve(outer + inner) and solve(inner + outer) may yield different results.
                 #  we need to use outer first.
+                joint_constraints = outer_constraints + inner_constraints
                 joint_solution = solve_constraints(
                     callee_type.variables,
-                    outer_constraints + inner_constraints,
+                    joint_constraints,
                     strict=self.chk.in_checked_function(),
                     allow_polymorphic=False,
                 )
@@ -2152,10 +2166,6 @@ def infer_function_type_arguments(
                     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 (  # HACK to fix testLiteralAndGenericWithUnion
-                        isinstance(outer_ret_type, UnionType)
-                        and any(is_subtype(val, joint_ret_type) for val in outer_ret_type.items)
-                    )
                 ):
                     use_joint = False
                 else:

mypy/constraints.py

@@ -77,11 +77,13 @@ class Constraint:
     """
 
     type_var: TypeVarId
+    original_type_var: TypeVarLikeType
     op = 0  # SUBTYPE_OF or SUPERTYPE_OF
     target: Type
 
     def __init__(self, type_var: TypeVarLikeType, op: int, target: Type) -> None:
         self.type_var = type_var.id
+        self.original_type_var = type_var
         self.op = op
         # TODO: should we add "assert not isinstance(target, UnpackType)"?
         # UnpackType is a synthetic type, and is never valid as a constraint target.

test-data/unit/check-generics.test

@@ -2998,7 +2998,7 @@ def lift(f: F[T]) -> F[Optional[T]]: ...
 def g(x: T) -> T:
     return x
 
-reveal_type(lift(g))  # N: Revealed type is "def [T] (Union[T`1, None]) -> Union[T`1, None]"
+reveal_type(lift(g))  # N: Revealed type is "__main__.F[Union[T`-1, None]]"
 [builtins fixtures/list.pyi]
 
 [case testInferenceAgainstGenericSplitOrder]
@@ -3198,11 +3198,11 @@ def dec(f: Callable[P, Callable[[T], S]]) -> Callable[Concatenate[T, P], S]: ...
 def id() -> Callable[[U], U]: ...
 def either(x: U) -> Callable[[U], U]: ...
 def pair(x: U) -> Callable[[V], Tuple[V, U]]: ...
-reveal_type(dec(id))  # N: Revealed type is "def [T] (T`3) -> T`3"
-reveal_type(dec(either))  # N: Revealed type is "def [T] (T`6, x: T`6) -> T`6"
-reveal_type(dec(pair))  # N: Revealed type is "def [T, U] (T`9, x: U`-1) -> tuple[T`9, U`-1]"
+reveal_type(dec(id))  # N: Revealed type is "def (U`-1) -> U`-1"
+reveal_type(dec(either))  # N: Revealed type is "def [T] (T`7, x: T`7) -> T`7"
+reveal_type(dec(pair))  # N: Revealed type is "def [T, U] (T`10, x: U`-1) -> tuple[T`10, U`-1]"
 # This is counter-intuitive but looks correct, dec matches itself only if P can be empty
-reveal_type(dec(dec))  # N: Revealed type is "def [T, S] (T`13, f: def () -> def (T`13) -> S`14) -> S`14"
+reveal_type(dec(dec))  # N: Revealed type is "def [T, S] (T`14, f: def () -> def (T`14) -> S`15) -> S`15"
 [builtins fixtures/list.pyi]
 
 [case testInferenceAgainstGenericParamSpecVsParamSpec]

test-data/unit/check-varargs.test

@@ -629,9 +629,9 @@ from typing import TypeVar
 T = TypeVar('T')
 
 def f(*args: T) -> T: ...
-reveal_type(f(*(1, None)))  # N: Revealed type is "Union[Literal[1]?, None]"
-reveal_type(f(1, *(None, 1)))  # N: Revealed type is "Union[Literal[1]?, None]"
-reveal_type(f(1, *(1, None)))  # N: Revealed type is "Union[Literal[1]?, None]"
+reveal_type(f(*(1, None)))  # N: Revealed type is "Union[builtins.int, None]"
+reveal_type(f(1, *(None, 1)))  # N: Revealed type is "Union[builtins.int, None]"
+reveal_type(f(1, *(1, None)))  # N: Revealed type is "Union[builtins.int, None]"
 [builtins fixtures/tuple.pyi]