remove untested code

Author: AlexWaygood

crates/ty_python_semantic/resources/mdtest/call/function.md

@@ -702,8 +702,7 @@ A union of heterogeneous tuples provided to a variadic parameter:
 # - <https://github.com/pydata/xarray/blob/3572f4e70f2b12ef9935c1f8c3c1b74045d2a092/xarray/tests/test_groupby.py#L3058-L3059>
 
 def f2(a: str, b: bool): ...
-def f3(a=None, b=None, c=None, d=None, e=None): ...
-def f4(coinflip: bool):
+def f3(coinflip: bool):
     if coinflip:
         args = "foo", True
     else:
@@ -723,19 +722,21 @@ def f4(coinflip: bool):
     # error: [invalid-argument-type] "Argument to function `f2` is incorrect: Expected `bool`, found `Literal[True] | tuple[Literal[True]]`"
     f2(*other_args)
 
+def f4(a=None, b=None, c=None, d=None, e=None): ...
+
 my_args = (("a", "b"), ("c", "d"), ("e", "f"))
 
 for tup in my_args:
-    f3(*tup, e=None)  # fine
+    f4(*tup, e=None)  # fine
 
 my_other_args = (
     ("a", "b", "c", "d", "e"),
     ("f", "g", "h", "i", "k"),
 )
 
 for tup in my_other_args:
-    # error: [parameter-already-assigned] "Multiple values provided for parameter `e` of function `f3`"
-    f3(*tup, e=None)
+    # error: [parameter-already-assigned] "Multiple values provided for parameter `e` of function `f4`"
+    f4(*tup, e=None)
 ```
 
 ### Mixed argument and parameter containing variadic

crates/ty_python_semantic/src/types/tuple.rs

@@ -1586,33 +1586,9 @@ impl<'db> TupleSpecBuilder<'db> {
                 self
             }
 
-            (
-                TupleSpecBuilder::Variable {
-                    prefix: prefix1,
-                    variable: variable1,
-                    suffix: suffix1,
-                },
-                Tuple::Variable(VariableLengthTuple {
-                    prefix: prefix2,
-                    variable: variable2,
-                    suffix: suffix2,
-                }),
-            ) if prefix1.len() == prefix2.len() && suffix1.len() == suffix2.len() => {
-                TupleSpecBuilder::Variable {
-                    prefix: prefix1
-                        .iter()
-                        .zip(prefix2)
-                        .map(|(elem1, elem2)| UnionType::from_elements(db, [elem1, elem2]))
-                        .collect(),
-                    variable: UnionType::from_elements(db, [variable1, variable2]),
-                    suffix: suffix1
-                        .iter()
-                        .zip(suffix2)
-                        .map(|(elem1, elem2)| UnionType::from_elements(db, [elem1, elem2]))
-                        .collect(),
-                }
-            }
-
+            // We *could* have a branch here where both `self` and `other` are mixed tuples
+            // with same-length prefixes and same-length suffixes. But it's hard to think of
+            // a test where this would actually lead to more precise inference.
             _ => {
                 let unioned =
                     UnionType::from_elements(db, self.all_elements().chain(other.all_elements()));