Removed direct implementors of [Pin]Init

Author: y86-dev

rust/kernel/init.rs

@@ -336,7 +336,7 @@ macro_rules! pin_init {
         let init = move |slot: *mut $ty| -> ::core::result::Result<(), _> {
             init(slot).map(|__InitOk| ())
         };
-        let init: $crate::init::PinInitClosure<_, $t $(<$($generics),*>)?, _> = unsafe { $crate::init::PinInitClosure::from_closure(init) };
+        let init = unsafe { $crate::init::pin_init_from_closure::<$t $(<$($generics),*>)?, _>(init) };
         init
     }}
 }
@@ -509,7 +509,7 @@ macro_rules! init {
         let init = move |slot: *mut $t $(<$($generics),*>)?| -> ::core::result::Result<(), _> {
             init(slot).map(|__InitOk| ())
         };
-        let init: $crate::init::InitClosure<_, $t $(<$($generics),*>)?, _> = unsafe { $crate::init::InitClosure::from_closure(init) };
+        let init = unsafe { $crate::init::init_from_closure::<$t $(<$($generics),*>)?, _>(init) };
         init
     }}
 }
@@ -569,27 +569,39 @@ pub unsafe trait Init<T, E = Infallible>: PinInit<T, E> {
 
 type Invariant<T> = PhantomData<fn(T) -> T>;
 
-/// A closure initializer.
-pub struct InitClosure<F, T, E>(F, Invariant<(T, E)>);
+struct InitClosure<F, T, E>(F, Invariant<(T, E)>);
 
-impl<T, E, F> InitClosure<F, T, E>
-where
-    F: FnOnce(*mut T) -> Result<(), E>,
-{
-    /// Creates a new Init from the given closure
-    ///
-    /// # Safety
-    ///
-    /// The closure
-    /// - returns `Ok(())` iff it initialized every field of slot,
-    /// - returns `Err(err)` iff it encountered an error and then cleaned slot, this means:
-    ///     - slot can be deallocated without UB ocurring,
-    ///     - slot does not need to be dropped,
-    ///     - slot is not partially initialized.
-    /// - slot may move after initialization
-    pub const unsafe fn from_closure(f: F) -> Self {
-        Self(f, PhantomData)
-    }
+/// Creates a new Init from the given closure
+///
+/// # Safety
+///
+/// The closure
+/// - returns `Ok(())` iff it initialized every field of slot,
+/// - returns `Err(err)` iff it encountered an error and then cleaned slot, this means:
+///     - slot can be deallocated without UB ocurring,
+///     - slot does not need to be dropped,
+///     - slot is not partially initialized.
+/// - slot may move after initialization
+pub const unsafe fn init_from_closure<T, E>(
+    f: impl FnOnce(*mut T) -> Result<(), E>,
+) -> impl Init<T, E> {
+    InitClosure(f, PhantomData)
+}
+/// Creates a new PinInit from the given closure
+///
+/// # Safety
+///
+/// The closure
+/// - returns `Ok(())` iff it initialized every field of slot,
+/// - returns `Err(err)` iff it encountered an error and then cleaned slot, this means:
+///     - slot can be deallocated without UB ocurring,
+///     - slot does not need to be dropped,
+///     - slot is not partially initialized.
+/// - may assume that the slot does not move if `T: !Unpin`
+pub const unsafe fn pin_init_from_closure<T, E>(
+    f: impl FnOnce(*mut T) -> Result<(), E>,
+) -> impl PinInit<T, E> {
+    InitClosure(f, PhantomData)
 }
 
 unsafe impl<T, F, E> PinInit<T, E> for InitClosure<F, T, E>
@@ -610,37 +622,6 @@ where
     }
 }
 
-/// A closure initializer for pinned data.
-pub struct PinInitClosure<F, T, E>(F, Invariant<(T, E)>);
-
-impl<T, E, F> PinInitClosure<F, T, E>
-where
-    F: FnOnce(*mut T) -> Result<(), E>,
-{
-    /// Creates a new Init from the given closure
-    ///
-    /// # Safety
-    ///
-    /// The closure
-    /// - returns `Ok(())` iff it initialized every field of slot,
-    /// - returns `Err(err)` iff it encountered an error and then cleaned slot, this means:
-    ///     - slot can be deallocated without UB ocurring,
-    ///     - slot does not need to be dropped,
-    ///     - slot is not partially initialized.
-    pub const unsafe fn from_closure(f: F) -> Self {
-        Self(f, PhantomData)
-    }
-}
-
-unsafe impl<T, F, E> PinInit<T, E> for PinInitClosure<F, T, E>
-where
-    F: FnOnce(*mut T) -> Result<(), E>,
-{
-    unsafe fn __pinned_init(self, slot: *mut T) -> Result<(), E> {
-        (self.0)(slot)
-    }
-}
-
 /// Trait facilitating pinned destruction.
 ///
 /// Use [`pinned_drop`] to implement this trait safely:
@@ -756,7 +737,7 @@ pub unsafe trait Zeroable {}
 /// Create a new zeroed T
 pub fn zeroed<T: Zeroable + Unpin>() -> impl Init<T> {
     unsafe {
-        InitClosure::from_closure(|slot: *mut T| {
+        init_from_closure(|slot: *mut T| {
             slot.write_bytes(0, 1);
             Ok(())
         })
@@ -765,13 +746,13 @@ pub fn zeroed<T: Zeroable + Unpin>() -> impl Init<T> {
 
 /// An initializer that leaves the memory uninitialized.
 pub fn uninit<T>() -> impl Init<MaybeUninit<T>> {
-    unsafe { InitClosure::from_closure(|_| Ok(())) }
+    unsafe { init_from_closure(|_| Ok(())) }
 }
 
 /// Convert a value into an initializer
 pub fn from_value<T>(value: T) -> impl Init<T> {
     unsafe {
-        InitClosure::from_closure(move |slot: *mut T| {
+        init_from_closure(move |slot: *mut T| {
             slot.write(value);
             Ok(())
         })