tests: internal: add tests for tuple struct support

Add initial tests to validate the basic functionality of tuple struct
support. Mainly, focusing on init syntax and pin data.

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

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

Author: mqqz

tests/tuple_struct.rs

@@ -0,0 +1,45 @@
+#![cfg_attr(USE_RUSTC_FEATURES, feature(lint_reasons))]
+#![cfg_attr(USE_RUSTC_FEATURES, feature(raw_ref_op))]
+#![cfg_attr(feature = "alloc", feature(allocator_api))]
+
+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(())
+        })
+    }
+}
+
+#[test]
+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::redundant_locals)]
+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]
+fn tuple_struct_constructor_form() {
+    stack_pin_init!(let foo = pin_init!(TupleStruct(11, 29)));
+    assert_eq!(foo.as_ref().get_ref().0, 11);
+    assert_eq!(foo.as_ref().get_ref().1, 29);
+}

tests/ui/compile-fail/init/no_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/no_tuple_shorthand.stderr

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

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/expand/tuple_struct.expanded.rs

@@ -0,0 +1,188 @@
+use pin_init::*;
+struct Foo([u8; 3], i32);
+/// Pin-projections of [`Foo`]
+#[allow(dead_code)]
+#[doc(hidden)]
+struct FooProjection<'__pin> {
+    _0: &'__pin mut [u8; 3],
+    _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; 3],
+            init: impl ::pin_init::Init<[u8; 3], 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; 3],
+        ) -> &'__slot mut [u8; 3] {
+            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 {}
+};
+fn main() {
+    let _ = {
+        struct __InitOk;
+        let __data = unsafe {
+            use ::pin_init::__internal::HasInitData;
+            Foo::__init_data()
+        };
+        let init = ::pin_init::__internal::InitData::make_closure::<
+            _,
+            __InitOk,
+            ::core::convert::Infallible,
+        >(
+            __data,
+            move |slot| {
+                {
+                    struct __InitOk;
+                    {
+                        #[allow(clippy::just_underscores_and_digits)]
+                        let _0 = [1, 2, 3];
+                        unsafe { ::core::ptr::write(&raw mut (*slot).0, _0) };
+                    }
+                    #[allow(unused_variables)]
+                    #[allow(clippy::just_underscores_and_digits)]
+                    let _0 = unsafe { &mut (*slot).0 };
+                    let ___0_guard = unsafe {
+                        ::pin_init::__internal::DropGuard::new(&raw mut (*slot).0)
+                    };
+                    {
+                        let init = 42;
+                        unsafe { ::pin_init::Init::__init(init, &raw mut (*slot).1)? };
+                    }
+                    #[allow(unused_variables)]
+                    #[allow(clippy::just_underscores_and_digits)]
+                    let _1 = unsafe { &mut (*slot).1 };
+                    let ___1_guard = unsafe {
+                        ::pin_init::__internal::DropGuard::new(&raw mut (*slot).1)
+                    };
+                    ::core::mem::forget(___0_guard);
+                    ::core::mem::forget(___1_guard);
+                    #[allow(unreachable_code, clippy::diverging_sub_expression)]
+                    let _ = || unsafe {
+                        ::core::ptr::write(
+                            slot,
+                            Foo {
+                                0: ::core::panicking::panic("explicit panic"),
+                                1: ::core::panicking::panic("explicit panic"),
+                            },
+                        )
+                    };
+                }
+                Ok(__InitOk)
+            },
+        );
+        let init = move |
+            slot,
+        | -> ::core::result::Result<(), ::core::convert::Infallible> {
+            init(slot).map(|__InitOk| ())
+        };
+        let init = unsafe {
+            ::pin_init::init_from_closure::<_, ::core::convert::Infallible>(init)
+        };
+        #[allow(
+            clippy::let_and_return,
+            reason = "some clippy versions warn about the let binding"
+        )] init
+    };
+}