[ty] Remove special casing for tuple addition (#19636)

crates/ty_python_semantic/resources/mdtest/assignment/augmented.md

@@ -13,7 +13,7 @@ reveal_type(x)  # revealed: int | float
 
 x = (1, 2)
 x += (3, 4)
-reveal_type(x)  # revealed: tuple[Literal[1], Literal[2], Literal[3], Literal[4]]
+reveal_type(x)  # revealed: tuple[Literal[1, 2, 3, 4], ...]
 ```
 
 ## Dunder methods

crates/ty_python_semantic/resources/mdtest/binary/tuples.md

@@ -3,14 +3,14 @@
 ## Concatenation for heterogeneous tuples
 
 ```py
-reveal_type((1, 2) + (3, 4))  # revealed: tuple[Literal[1], Literal[2], Literal[3], Literal[4]]
-reveal_type(() + (1, 2))  # revealed: tuple[Literal[1], Literal[2]]
-reveal_type((1, 2) + ())  # revealed: tuple[Literal[1], Literal[2]]
+reveal_type((1, 2) + (3, 4))  # revealed: tuple[Literal[1, 2, 3, 4], ...]
+reveal_type(() + (1, 2))  # revealed: tuple[Literal[1, 2], ...]
+reveal_type((1, 2) + ())  # revealed: tuple[Literal[1, 2], ...]
 reveal_type(() + ())  # revealed: tuple[()]
 
 def _(x: tuple[int, str], y: tuple[None, tuple[int]]):
-    reveal_type(x + y)  # revealed: tuple[int, str, None, tuple[int]]
-    reveal_type(y + x)  # revealed: tuple[None, tuple[int], int, str]
+    reveal_type(x + y)  # revealed: tuple[int | str | None | tuple[int], ...]
+    reveal_type(y + x)  # revealed: tuple[None | tuple[int] | int | str, ...]
 ```
 
 ## Concatenation for homogeneous tuples
@@ -19,10 +19,10 @@ def _(x: tuple[int, str], y: tuple[None, tuple[int]]):
 def _(x: tuple[int, ...], y: tuple[str, ...]):
     reveal_type(x + x)  # revealed: tuple[int, ...]
     reveal_type(x + y)  # revealed: tuple[int | str, ...]
-    reveal_type((1, 2) + x)  # revealed: tuple[Literal[1], Literal[2], *tuple[int, ...]]
-    reveal_type(x + (3, 4))  # revealed: tuple[*tuple[int, ...], Literal[3], Literal[4]]
-    reveal_type((1, 2) + x + (3, 4))  # revealed: tuple[Literal[1], Literal[2], *tuple[int, ...], Literal[3], Literal[4]]
-    reveal_type((1, 2) + y + (3, 4) + x)  # revealed: tuple[Literal[1], Literal[2], *tuple[int | str, ...]]
+    reveal_type((1, 2) + x)  # revealed: tuple[int, ...]
+    reveal_type(x + (3, 4))  # revealed: tuple[int, ...]
+    reveal_type((1, 2) + x + (3, 4))  # revealed: tuple[int, ...]
+    reveal_type((1, 2) + y + (3, 4) + x)  # revealed: tuple[int | str, ...]
 ```
 
 We get the same results even when we use a legacy type alias, even though this involves first
@@ -41,8 +41,8 @@ StrTuple = tuple[str, ...]
 def _(one_two: OneTwo, x: IntTuple, y: StrTuple, three_four: ThreeFour):
     reveal_type(x + x)  # revealed: tuple[int, ...]
     reveal_type(x + y)  # revealed: tuple[int | str, ...]
-    reveal_type(one_two + x)  # revealed: tuple[Literal[1], Literal[2], *tuple[int, ...]]
-    reveal_type(x + three_four)  # revealed: tuple[*tuple[int, ...], Literal[3], Literal[4]]
-    reveal_type(one_two + x + three_four)  # revealed: tuple[Literal[1], Literal[2], *tuple[int, ...], Literal[3], Literal[4]]
-    reveal_type(one_two + y + three_four + x)  # revealed: tuple[Literal[1], Literal[2], *tuple[int | str, ...]]
+    reveal_type(one_two + x)  # revealed: tuple[int, ...]
+    reveal_type(x + three_four)  # revealed: tuple[int, ...]
+    reveal_type(one_two + x + three_four)  # revealed: tuple[int, ...]
+    reveal_type(one_two + y + three_four + x)  # revealed: tuple[int | str, ...]
 ```

crates/ty_python_semantic/resources/mdtest/instance_layout_conflict.md

@@ -122,15 +122,14 @@ class A:
     __slots__ = ()
     __slots__ += ("a", "b")
 
-reveal_type(A.__slots__)  # revealed: tuple[Literal["a"], Literal["b"]]
+reveal_type(A.__slots__)  # revealed: tuple[Literal["a", "b"], ...]
 
 class B:
     __slots__ = ("c", "d")
 
-class C(  # error: [instance-layout-conflict]
-    A,
-    B,
-): ...
+# TODO: ideally this would trigger `[instance-layout-conflict]`
+# (but it's also not high-priority)
+class C(A, B): ...
 ```
 
 ## Explicitly annotated `__slots__`

crates/ty_python_semantic/resources/mdtest/subscript/tuple.md

@@ -240,9 +240,7 @@ def homogeneous(t: tuple[str, ...]) -> None:
     reveal_type(t[-3])  # revealed: str
     reveal_type(t[-4])  # revealed: str
 
-def mixed(s: tuple[str, ...]) -> None:
-    t = (1, 2, 3) + s + (8, 9, 10)
-
+def mixed(t: tuple[Literal[1], Literal[2], Literal[3], *tuple[str, ...], Literal[8], Literal[9], Literal[10]]) -> None:
     reveal_type(t[0])  # revealed: Literal[1]
     reveal_type(t[1])  # revealed: Literal[2]
     reveal_type(t[2])  # revealed: Literal[3]

crates/ty_python_semantic/src/types/infer.rs

@@ -7061,8 +7061,10 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
             // the result would then become Any or Unknown, respectively).
             (any @ Type::Dynamic(DynamicType::Any), _, _)
             | (_, any @ Type::Dynamic(DynamicType::Any), _) => Some(any),
+
             (unknown @ Type::Dynamic(DynamicType::Unknown), _, _)
             | (_, unknown @ Type::Dynamic(DynamicType::Unknown), _) => Some(unknown),
+
             (
                 todo @ Type::Dynamic(
                     DynamicType::Todo(_)
@@ -7083,6 +7085,7 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
                 ),
                 _,
             ) => Some(todo),
+
             (Type::Never, _, _) | (_, Type::Never, _) => Some(Type::Never),
 
             (Type::IntLiteral(n), Type::IntLiteral(m), ast::Operator::Add) => Some(
@@ -7235,13 +7238,6 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
                     op,
                 ),
 
-            (Type::Tuple(lhs), Type::Tuple(rhs), ast::Operator::Add) => {
-                Some(Type::tuple(TupleType::new(
-                    self.db(),
-                    lhs.tuple(self.db()).concat(self.db(), rhs.tuple(self.db())),
-                )))
-            }
-
             // We've handled all of the special cases that we support for literals, so we need to
             // fall back on looking for dunder methods on one of the operand types.
             (