prevent incorrect specializations in SpecializationBuilder::infer

Author: mtshiba

crates/ty_python_semantic/resources/mdtest/bidirectional.md

@@ -1,4 +1,4 @@
-# Bidirectional Type Inference
+# Bidirectional type inference
 
 ty partially supports bidirectional type inference. This is a mechanism for inferring the type of an
 expression "from the outside in". Normally, type inference proceeds "from the inside out". That is,
@@ -46,6 +46,13 @@ def _(l: list[int] | None = None):
     l2: list[int] = l or list()
     # TODO: should be `list[int]`
     reveal_type(l2)  # revealed: (list[int] & ~AlwaysFalsy) | list[Unknown]
+
+def f[T](x: T, cond: bool) -> T | list[T]:
+    return x if cond else [x]
+
+# TODO: no error
+# error: [invalid-assignment] "Object of type `Literal[1] | list[Literal[1]]` is not assignable to `int | list[int]`"
+l5: int | list[int] = f(1, True)
 ```
 
 ```py
@@ -123,4 +130,10 @@ reveal_type(f("a"))  # revealed: list[str]
 
 async def g() -> list[int]:
     return list1(1)
+
+def h[T](x: T, cond: bool) -> T | list[T]:
+    return i(x, cond)
+
+def i[T](x: T, cond: bool) -> T | list[T]:
+    return x if cond else [x]
 ```

crates/ty_python_semantic/resources/mdtest/generics/legacy/functions.md

@@ -323,6 +323,10 @@ def union_param(x: T | None) -> T:
 reveal_type(union_param("a"))  # revealed: Literal["a"]
 reveal_type(union_param(1))  # revealed: Literal[1]
 reveal_type(union_param(None))  # revealed: Unknown
+
+def _(x: int | None):
+    # TODO: should be `int`
+    reveal_type(union_param(x))  # revealed: Unknown
 ```
 
 ```py

crates/ty_python_semantic/resources/mdtest/generics/pep695/functions.md

@@ -286,6 +286,10 @@ def union_param[T](x: T | None) -> T:
 reveal_type(union_param("a"))  # revealed: Literal["a"]
 reveal_type(union_param(1))  # revealed: Literal[1]
 reveal_type(union_param(None))  # revealed: Unknown
+
+def _(x: int | None):
+    # TODO: should be `int`
+    reveal_type(union_param(x))  # revealed: Unknown
 ```
 
 ```py

crates/ty_python_semantic/src/types/generics.rs

@@ -1088,6 +1088,11 @@ impl<'db> SpecializationBuilder<'db> {
         }
 
         match (formal, actual) {
+            (Type::Union(_), Type::Union(_)) => {
+                // TODO: We need to infer specializations appropriately.
+                // e.g.
+                // `formal: list[T] | T | U, actual: V | int | list[V]` => `T = V, U = int`
+            }
             (Type::Union(formal), _) => {
                 // TODO: We haven't implemented a full unification solver yet. If typevars appear
                 // in multiple union elements, we ideally want to express that _only one_ of them