Expose bindings in _: {} blocks

Signed-off-by: Matthew Maurer <[email protected]>

Author: maurer

src/lib.rs

@@ -741,7 +741,8 @@ macro_rules! stack_try_pin_init {
 /// the following modifications is expected:
 /// - Fields that you want to initialize in-place have to use `<-` instead of `:`.
 /// - You can use `_: { /* run any user-code here */ },` anywhere where you can place fields in
-///   order to run arbitrary code.
+///   order to run arbitrary code. Bindings present here will be visible to field initializers that
+///   follow.
 /// - In front of the initializer you can write `&this in` to have access to a [`NonNull<Self>`]
 ///   pointer named `this` inside of the initializer.
 /// - Using struct update syntax one can place `..Zeroable::init_zeroed()` at the very end of the

src/macros.rs

@@ -1290,7 +1290,7 @@ macro_rules! __init_internal {
         // arbitrary code block
         @munch_fields(_: { $($code:tt)* }, $($rest:tt)*),
     ) => {
-        { $($code)* }
+        $($code)*;
         $crate::__init_internal!(init_slot($($use_data)?):
             @data($data),
             @slot($slot),

tests/underscore.rs

@@ -1,7 +1,91 @@
-use pin_init::{try_init, Init};
+#![cfg_attr(not(RUSTC_LINT_REASONS_IS_STABLE), feature(lint_reasons))]
+use core::cell::Cell;
+use pin_init::*;
 
-pub struct Foo {
-    x: u64,
+#[derive(Debug)]
+struct Error;
+
+#[pin_data]
+#[derive(Debug)]
+struct Foo {
+    a: usize,
+    b: usize,
+}
+
+struct Bar;
+
+impl Bar {
+    fn new() -> Result<Self, Error> {
+        Ok(Self)
+    }
+    fn make_a(&self) -> usize {
+        10
+    }
+    fn make_b(&self) -> usize {
+        20
+    }
+}
+
+fn error(_bar: &Bar) -> Result<(), Error> {
+    Err(Error)
+}
+
+fn ok(_bar: &Bar) -> Result<(), Error> {
+    Ok(())
+}
+
+#[test]
+fn delay() {
+    let state = &Cell::new(3);
+    let init = pin_init!(Foo {
+        _: {
+            let x = state.get();
+            let y = x + 1;
+        },
+        a: x,
+        b: y,
+    });
+    state.set(42);
+    stack_pin_init!(let foo = init);
+    assert_eq!(foo.a, 42);
+    assert_eq!(foo.b, 43);
+}
+
+#[test]
+fn error_user() {
+    let bar = Bar;
+    stack_try_pin_init!(let foo = try_pin_init!(Foo {
+        _: { error(&bar)? },
+        a: 1,
+        b: 2,
+    }? Error));
+
+    assert!(foo.is_err());
+}
+
+#[test]
+fn ok_user() {
+    let bar = Bar;
+    stack_try_pin_init!(let foo = try_pin_init!(Foo {
+        _: { ok(&bar)? },
+        a: 1,
+        b: 2,
+    }? Error));
+
+    assert_eq!(foo.unwrap().a, 1);
+}
+
+#[test]
+fn split() {
+    stack_try_pin_init!(let foo = try_pin_init!(Foo {
+        _: { let bar = Bar::new()? },
+        a: bar.make_a(),
+        b: bar.make_b(),
+    }? Error));
+
+    let foo = foo.unwrap();
+    assert_eq!(foo.a, 10);
+    assert_eq!(foo.b, 20);
 }
 
 fn foo() -> bool {
@@ -13,19 +97,26 @@ fn bar() -> bool {
 }
 
 impl Foo {
-    pub fn new() -> impl Init<Self, ()> {
+    pub fn late_error_new() -> impl Init<Self, Error> {
         try_init!(Self {
             _: {
                 if foo() {
-                    return Err(());
+                    return Err(Error);
                 }
             },
-            x: 0,
+            a: 0,
             _: {
                 if bar() {
-                    return Err(());
+                    return Err(Error);
                 }
-            }
-        }? ())
+            },
+            b: 0,
+        }? Error)
     }
 }
+
+#[test]
+fn late_error() {
+    stack_try_pin_init!(let foo = Foo::late_error_new());
+    assert!(foo.is_err());
+}