Add UI tests for #[splat] with const generics, complex types, and where clauses

Author: Ajay-singh1

tests/ui/splat/splat-const-fn-tuple-generic.rs

@@ -0,0 +1,36 @@
+//@ run-pass
+//! Test using `#[splat]` on tuple arguments of const functions with generics.
+//! This fills the FIXME in splat-generics-everywhere.rs:
+//! "add const fn generics tests"
+
+#![allow(incomplete_features)]
+#![feature(splat)]
+
+// Generic type in first position
+const fn const_generic_first<T: Copy>(#[splat] _: (T, u32)) {}
+
+// Generic type in second position
+const fn const_generic_second<T: Copy>(#[splat] _: (u32, T)) {}
+
+// Multiple generic types
+const fn const_generic_both<T: Copy, U: Copy>(#[splat] _: (T, U)) {}
+
+// Generic with extra non-splatted arg
+const fn const_generic_extra<T: Copy>(#[splat] _: (T, u32), _extra: i32) {}
+
+fn main() {
+    const_generic_first(1i8, 2u32);
+    const_generic_first(true, 2u32);
+    const_generic_first(1u64, 2u32);
+
+    const_generic_second(1u32, 2i8);
+    const_generic_second(1u32, true);
+    const_generic_second(1u32, 2u64);
+
+    const_generic_both(1u32, 2i8);
+    const_generic_both(true, 2u64);
+    const_generic_both(1i8, false);
+
+    const_generic_extra(1i8, 2u32, 42i32);
+    const_generic_extra(true, 2u32, 42i32);
+}

tests/ui/splat/splat-generics-complex-types.rs

@@ -0,0 +1,28 @@
+//@ run-pass
+//! Test using `#[splat]` on tuples with complex generic types inside the splatted tuple.
+//! This fills the FIXME in splat-generics-everywhere.rs:
+//! "also add generics inside the splatted tuple"
+
+#![allow(incomplete_features)]
+#![feature(splat)]
+
+// Vec<T> and Option<U> inside splatted tuple
+fn nested_generic<T, U>(#[splat] _: (Vec<T>, Option<U>)) {}
+
+// Box<T> inside splatted tuple
+fn box_generic<T>(#[splat] _: (Box<T>, u32)) {}
+
+// Multiple complex generics
+fn multi_generic<T, U, V>(#[splat] _: (Vec<T>, Option<U>, Box<V>)) {}
+
+fn main() {
+    nested_generic(vec![1u32, 2u32], Some(2i8));
+    nested_generic(vec![1, 2, 3], None::<i8>);
+    nested_generic::<u32, &str>(vec![], Some("hello"));
+
+    box_generic(Box::new(1u32), 42u32);
+    box_generic(Box::new("hello"), 1u32);
+
+    multi_generic(vec![1u32], Some(2i8), Box::new(3.0f64));
+    multi_generic::<u32, i8, &str>(vec![], None::<i8>, Box::new("hello"));
+}

tests/ui/splat/splat-where-clause.rs

@@ -0,0 +1,31 @@
+//@ run-pass
+//! Test using `#[splat]` on tuple arguments with where clause bounds.
+
+#![allow(incomplete_features)]
+#![feature(splat)]
+#![feature(tuple_trait)]
+
+fn where_splat<T>(#[splat] _t: T) where T: std::marker::Tuple {}
+
+fn where_splat_with_extra<T>(#[splat] _t: T, _extra: u32) where T: std::marker::Tuple {}
+
+fn main() {
+    // empty tuple
+    where_splat();
+
+    // single element
+    where_splat(1u32);
+    where_splat(1);
+
+    // two elements
+    where_splat(1u32, 2i8);
+    where_splat(1, 2);
+
+    // three elements
+    where_splat(1u32, 2i8, 3.0f64);
+    where_splat(1, 2, 3.0);
+
+    // with extra non-splatted arg
+    where_splat_with_extra(1u32, 2i8, 42u32);
+    where_splat_with_extra(1, 2, 42);
+}