tests: internal: add tests for new tuple struct support

Tests include:
  - `tests/tuple_struct.rs`
  - `tests/ui/compile-fail/tuple_{duplicate,invalid,missing}_field.rs`
  - `tests/ui/compile-fail/tuple_shorthand.rs`
  - `tests/ui/expand/pin_{data,init}`

Signed-off-by: Mohamad Alsadhan <mo@sdhn.cc>

Author: mqqz

tests/tuple_struct.rs

@@ -0,0 +1,67 @@
+#![cfg_attr(USE_RUSTC_FEATURES, feature(lint_reasons))]
+
+use core::ptr;
+
+use pin_init::*;
+
+#[pin_data]
+struct TupleStruct(#[pin] i32, i32);
+
+fn init_i32(value: i32) -> impl PinInit<i32> {
+    // SAFETY: The closure always initializes `slot` with a valid `i32` value.
+    unsafe {
+        pin_init_from_closure(move |slot| {
+            // SAFETY: `slot` is provided by the initialization framework and valid for write.
+            ptr::write(slot, value);
+            Ok(())
+        })
+    }
+}
+
+fn init_i32_unpinned(value: i32) -> impl Init<i32> {
+    // SAFETY: The closure always initializes `slot` with a valid `i32` value.
+    unsafe {
+        init_from_closure(move |slot| {
+            // SAFETY: `slot` is provided by the initialization framework and valid for write.
+            ptr::write(slot, value);
+            Ok(())
+        })
+    }
+}
+
+#[test]
+#[allow(clippy::just_underscores_and_digits)]
+fn tuple_struct_values() {
+    stack_pin_init!(let foo = pin_init!(TupleStruct { 0: 42, 1: 24 }));
+    assert_eq!(foo.as_ref().get_ref().0, 42);
+    assert_eq!(foo.as_ref().get_ref().1, 24);
+}
+
+#[test]
+#[allow(clippy::just_underscores_and_digits)]
+fn tuple_struct_init_arrow_and_projection() {
+    stack_pin_init!(let foo = pin_init!(TupleStruct { 0 <- init_i32(7), 1: 13 }));
+    let mut foo = foo;
+    let projected = foo.as_mut().project();
+    assert_eq!(*projected._0.as_ref().get_ref(), 7);
+    assert_eq!(*projected._1, 13);
+}
+
+#[test]
+#[allow(clippy::just_underscores_and_digits)]
+fn tuple_struct_constructor_form() {
+    stack_pin_init!(let foo = pin_init!(TupleStruct(<- init_i32(11), 29)));
+    assert_eq!(foo.as_ref().get_ref().0, 11);
+    assert_eq!(foo.as_ref().get_ref().1, 29);
+}
+
+#[pin_data]
+struct Triple(i32, i32, i32);
+
+#[test]
+fn tuple_struct_constructor_form_mixed_middle_init() {
+    stack_pin_init!(let triple = pin_init!(Triple(1, <- init_i32_unpinned(2), 3)));
+    assert_eq!(triple.as_ref().get_ref().0, 1);
+    assert_eq!(triple.as_ref().get_ref().1, 2);
+    assert_eq!(triple.as_ref().get_ref().2, 3);
+}

tests/ui/compile-fail/init/tuple_duplicate_field.rs

@@ -0,0 +1,8 @@
+use pin_init::*;
+
+#[pin_data]
+struct Tuple(#[pin] i32, i32);
+
+fn main() {
+    let _ = pin_init!(Tuple { 0: 1, 0: 2, 1: 3 });
+}

tests/ui/compile-fail/init/tuple_duplicate_field.stderr

@@ -0,0 +1,8 @@
+error[E0062]: field `0` specified more than once
+ --> tests/ui/compile-fail/init/tuple_duplicate_field.rs:7:37
+  |
+7 |     let _ = pin_init!(Tuple { 0: 1, 0: 2, 1: 3 });
+  |             ------------------------^------------
+  |             |                       |
+  |             |                       used more than once
+  |             first use of `0`

tests/ui/compile-fail/init/tuple_invalid_field.rs

@@ -0,0 +1,8 @@
+use pin_init::*;
+
+#[pin_data]
+struct Tuple(#[pin] i32, i32);
+
+fn main() {
+    let _ = pin_init!(Tuple { 0: 1, 1: 2, 2: 3 });
+}

tests/ui/compile-fail/init/tuple_invalid_field.stderr

@@ -0,0 +1,33 @@
+error[E0609]: no field `2` on type `Tuple`
+ --> tests/ui/compile-fail/init/tuple_invalid_field.rs:7:43
+  |
+7 |     let _ = pin_init!(Tuple { 0: 1, 1: 2, 2: 3 });
+  |                                           ^ unknown field
+  |
+  = note: available fields are: `0`, `1`
+
+error[E0599]: no method named `__project_2` found for struct `__ThePinData` in the current scope
+ --> tests/ui/compile-fail/init/tuple_invalid_field.rs:7:13
+  |
+3 | #[pin_data]
+  | ----------- method `__project_2` not found for this struct
+...
+7 |     let _ = pin_init!(Tuple { 0: 1, 1: 2, 2: 3 });
+  |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  |
+  = note: this error originates in the macro `pin_init` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0560]: struct `Tuple` has no field named `2`
+ --> tests/ui/compile-fail/init/tuple_invalid_field.rs:7:43
+  |
+4 | struct Tuple(#[pin] i32, i32);
+  |        ----- `Tuple` defined here
+...
+7 |     let _ = pin_init!(Tuple { 0: 1, 1: 2, 2: 3 });
+  |                                           ^ field does not exist
+  |
+help: `Tuple` is a tuple struct, use the appropriate syntax
+  |
+7 -     let _ = pin_init!(Tuple { 0: 1, 1: 2, 2: 3 });
+7 +     let _ = Tuple(/* i32 */, /* i32 */);
+  |

tests/ui/compile-fail/init/tuple_missing_field.rs

@@ -0,0 +1,9 @@
+use pin_init::*;
+
+#[pin_data]
+struct Tuple(#[pin] i32, i32);
+
+fn main() {
+    let _ = pin_init!(Tuple { 0: 1 });
+    let _ = init!(Tuple { 0: 1 });
+}

tests/ui/compile-fail/init/tuple_missing_field.stderr

@@ -0,0 +1,11 @@
+error[E0063]: missing field `1` in initializer of `Tuple`
+ --> tests/ui/compile-fail/init/tuple_missing_field.rs:7:23
+  |
+7 |     let _ = pin_init!(Tuple { 0: 1 });
+  |                       ^^^^^ missing `1`
+
+error[E0063]: missing field `1` in initializer of `Tuple`
+ --> tests/ui/compile-fail/init/tuple_missing_field.rs:8:19
+  |
+8 |     let _ = init!(Tuple { 0: 1 });
+  |                   ^^^^^ missing `1`

tests/ui/compile-fail/init/tuple_shorthand.rs

@@ -0,0 +1,8 @@
+use pin_init::*;
+
+#[pin_data]
+struct Tuple(#[pin] i32, i32);
+
+fn main() {
+    let _ = pin_init!(Tuple { 0, 1: 24 });
+}

tests/ui/compile-fail/init/tuple_shorthand.stderr

@@ -0,0 +1,5 @@
+error: expected `<-` or `:`
+ --> tests/ui/compile-fail/init/tuple_shorthand.rs:7:32
+  |
+7 |     let _ = pin_init!(Tuple { 0, 1: 24 });
+  |                                ^

tests/ui/expand/pin-data.struct_tuple.expanded.rs

@@ -0,0 +1,121 @@
+use pin_init::*;
+struct Foo([u8; 1024 * 1024], i32);
+/// Pin-projections of [`Foo`]
+#[allow(dead_code)]
+#[doc(hidden)]
+struct FooProjection<'__pin> {
+    _0: &'__pin mut [u8; 1024 * 1024],
+    _1: ::core::pin::Pin<&'__pin mut i32>,
+    ___pin_phantom_data: ::core::marker::PhantomData<&'__pin mut ()>,
+}
+impl Foo {
+    /// Pin-projects all fields of `Self`.
+    ///
+    /// These fields are structurally pinned:
+    /// - index `1`
+    ///
+    /// These fields are **not** structurally pinned:
+    /// - index `0`
+    #[inline]
+    fn project<'__pin>(
+        self: ::core::pin::Pin<&'__pin mut Self>,
+    ) -> FooProjection<'__pin> {
+        let this = unsafe { ::core::pin::Pin::get_unchecked_mut(self) };
+        FooProjection {
+            _0: &mut this.0,
+            _1: unsafe { ::core::pin::Pin::new_unchecked(&mut this.1) },
+            ___pin_phantom_data: ::core::marker::PhantomData,
+        }
+    }
+}
+const _: () = {
+    #[doc(hidden)]
+    struct __ThePinData {
+        __phantom: ::core::marker::PhantomData<fn(Foo) -> Foo>,
+    }
+    impl ::core::clone::Clone for __ThePinData {
+        fn clone(&self) -> Self {
+            *self
+        }
+    }
+    impl ::core::marker::Copy for __ThePinData {}
+    #[allow(dead_code)]
+    #[expect(clippy::missing_safety_doc)]
+    impl __ThePinData {
+        /// # Safety
+        ///
+        /// - `slot` is a valid pointer to uninitialized memory.
+        /// - the caller does not touch `slot` when `Err` is returned, they are only permitted
+        ///   to deallocate.
+        unsafe fn _0<E>(
+            self,
+            slot: *mut [u8; 1024 * 1024],
+            init: impl ::pin_init::Init<[u8; 1024 * 1024], E>,
+        ) -> ::core::result::Result<(), E> {
+            unsafe { ::pin_init::Init::__init(init, slot) }
+        }
+        /// # Safety
+        ///
+        /// `slot` points at the field index `0` inside of `Foo`, which is pinned.
+        unsafe fn __project_0<'__slot>(
+            self,
+            slot: &'__slot mut [u8; 1024 * 1024],
+        ) -> &'__slot mut [u8; 1024 * 1024] {
+            slot
+        }
+        /// # Safety
+        ///
+        /// - `slot` is a valid pointer to uninitialized memory.
+        /// - the caller does not touch `slot` when `Err` is returned, they are only permitted
+        ///   to deallocate.
+        /// - `slot` will not move until it is dropped, i.e. it will be pinned.
+        unsafe fn _1<E>(
+            self,
+            slot: *mut i32,
+            init: impl ::pin_init::PinInit<i32, E>,
+        ) -> ::core::result::Result<(), E> {
+            unsafe { ::pin_init::PinInit::__pinned_init(init, slot) }
+        }
+        /// # Safety
+        ///
+        /// `slot` points at the field index `1` inside of `Foo`, which is pinned.
+        unsafe fn __project_1<'__slot>(
+            self,
+            slot: &'__slot mut i32,
+        ) -> ::core::pin::Pin<&'__slot mut i32> {
+            unsafe { ::core::pin::Pin::new_unchecked(slot) }
+        }
+    }
+    unsafe impl ::pin_init::__internal::HasPinData for Foo {
+        type PinData = __ThePinData;
+        unsafe fn __pin_data() -> Self::PinData {
+            __ThePinData {
+                __phantom: ::core::marker::PhantomData,
+            }
+        }
+    }
+    unsafe impl ::pin_init::__internal::PinData for __ThePinData {
+        type Datee = Foo;
+    }
+    #[allow(dead_code)]
+    struct __Unpin<'__pin> {
+        __phantom_pin: ::core::marker::PhantomData<fn(&'__pin ()) -> &'__pin ()>,
+        __phantom: ::core::marker::PhantomData<fn(Foo) -> Foo>,
+        _1: i32,
+    }
+    #[doc(hidden)]
+    impl<'__pin> ::core::marker::Unpin for Foo
+    where
+        __Unpin<'__pin>: ::core::marker::Unpin,
+    {}
+    trait MustNotImplDrop {}
+    #[expect(drop_bounds)]
+    impl<T: ::core::ops::Drop + ?::core::marker::Sized> MustNotImplDrop for T {}
+    impl MustNotImplDrop for Foo {}
+    #[expect(non_camel_case_types)]
+    trait UselessPinnedDropImpl_you_need_to_specify_PinnedDrop {}
+    impl<
+        T: ::pin_init::PinnedDrop + ?::core::marker::Sized,
+    > UselessPinnedDropImpl_you_need_to_specify_PinnedDrop for T {}
+    impl UselessPinnedDropImpl_you_need_to_specify_PinnedDrop for Foo {}
+};