change blanket impls for [Pin]Init and add one for Result<T, E>

Remove the error from the blanket implementations `impl<T, E> Init<T, E>
for T` (and also for `PinInit`). Add implementations for `Result<T, E>`.

This allows one to easily construct (un)conditional failing
initializers. It also improves the compatibility with APIs that do not
use pin-init, because users can supply a `Result<T, E>` to a  function
taking an `impl PinInit<T, E>`.

Suggested-by: Alice Ryhl <[email protected]>
Signed-off-by: Benno Lossin <[email protected]>

Author: BennoLossin

CHANGELOG.md

@@ -13,13 +13,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `MaybeZeroable` derive macro to try to derive `Zeroable`, but not error if not all fields
   implement it.
 - `unsafe fn cast_[pin_]init()` functions to unsafely change the initialized type of an initializer
+- `impl<T, E> [Pin]Init<T, E> for Result<T, E>`, so results are now (pin-)initializers
 
 ### Changed
 
 - `InPlaceInit` now only exists when the `alloc` or `std` features are enabled
 - added support for visibility in `Zeroable` derive macro
 - added support for `union`s in `Zeroable` derive macro
 - renamed the crate from `pinned-init` to `pin-init` and `pinned-init-macro` to `pin-init-internal`
+- blanket impls of `Init` and `PinInit` from `impl<T, E> [Pin]Init<T, E> for T` to
+  `impl<T> [Pin]Init<T> for T`
 
 ### Fixed
 

src/lib.rs

@@ -1391,8 +1391,8 @@ where
 }
 
 // SAFETY: the `__init` function always returns `Ok(())` and initializes every field of `slot`.
-unsafe impl<T, E> Init<T, E> for T {
-    unsafe fn __init(self, slot: *mut T) -> Result<(), E> {
+unsafe impl<T> Init<T> for T {
+    unsafe fn __init(self, slot: *mut T) -> Result<(), Infallible> {
         // SAFETY: `slot` is valid for writes by the safety requirements of this function.
         unsafe { slot.write(self) };
         Ok(())
@@ -1401,14 +1401,36 @@ unsafe impl<T, E> Init<T, E> for T {
 
 // SAFETY: the `__pinned_init` function always returns `Ok(())` and initializes every field of
 // `slot`. Additionally, all pinning invariants of `T` are upheld.
-unsafe impl<T, E> PinInit<T, E> for T {
-    unsafe fn __pinned_init(self, slot: *mut T) -> Result<(), E> {
+unsafe impl<T> PinInit<T> for T {
+    unsafe fn __pinned_init(self, slot: *mut T) -> Result<(), Infallible> {
         // SAFETY: `slot` is valid for writes by the safety requirements of this function.
         unsafe { slot.write(self) };
         Ok(())
     }
 }
 
+// SAFETY: when the `__init` function returns with
+// - `Ok(())`, `slot` was initialized and all pinned invariants of `T` are upheld.
+// - `Err(err)`, slot was not written to.
+unsafe impl<T, E> Init<T, E> for Result<T, E> {
+    unsafe fn __init(self, slot: *mut T) -> Result<(), E> {
+        // SAFETY: `slot` is valid for writes by the safety requirements of this function.
+        unsafe { slot.write(self?) };
+        Ok(())
+    }
+}
+
+// SAFETY: when the `__pinned_init` function returns with
+// - `Ok(())`, `slot` was initialized and all pinned invariants of `T` are upheld.
+// - `Err(err)`, slot was not written to.
+unsafe impl<T, E> PinInit<T, E> for Result<T, E> {
+    unsafe fn __pinned_init(self, slot: *mut T) -> Result<(), E> {
+        // SAFETY: `slot` is valid for writes by the safety requirements of this function.
+        unsafe { slot.write(self?) };
+        Ok(())
+    }
+}
+
 /// Smart pointer containing uninitialized memory and that can write a value.
 pub trait InPlaceWrite<T> {
     /// The type `Self` turns into when the contents are initialized.

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

@@ -10,5 +10,7 @@ error[E0277]: the trait bound `impl pin_init::PinInit<Bar>: Init<Bar>` is not sa
    | |______the trait `Init<Bar>` is not implemented for `impl pin_init::PinInit<Bar>`
    |        required by a bound introduced by this call
    |
-   = help: the trait `Init<T, E>` is implemented for `ChainInit<I, F, T, E>`
+   = help: the following other types implement trait `Init<T, E>`:
+             ChainInit<I, F, T, E>
+             Result<T, E>
    = note: this error originates in the macro `$crate::__init_internal` which comes from the expansion of the macro `init` (in Nightly builds, run with -Z macro-backtrace for more info)

tests/ui/compile-fail/pin_data/missing_pin.stderr

@@ -8,7 +8,7 @@ error[E0277]: the trait bound `impl PinInit<usize>: Init<usize, _>` is not satis
    | |__________^ the trait `Init<usize, _>` is not implemented for `impl PinInit<usize>`
    |
    = help: the trait `Init<usize, _>` is not implemented for `impl PinInit<usize>`
-           but trait `Init<impl PinInit<usize>, _>` is implemented for it
+           but trait `Init<impl PinInit<usize>, Infallible>` is implemented for it
    = help: for that trait implementation, expected `impl PinInit<usize>`, found `usize`
 note: required by a bound in `__ThePinData::a`
   --> tests/ui/compile-fail/pin_data/missing_pin.rs:4:1