add pre_rfc examples

Author: BennoLossin

tests/ui/compile-fail/pre_rfc.rs

@@ -0,0 +1,78 @@
+#![allow(clippy::disallowed_names)]
+
+use std::mem::MaybeUninit;
+
+use field_projection::compat::{HasFields, p, start_proj};
+
+#[derive(HasFields)]
+struct Foo {
+    field: usize,
+    bar: Bar,
+}
+
+#[derive(HasFields)]
+struct Bar {
+    x: u32,
+}
+
+// Very simple first example with type annotations.
+fn example1(mut foo: &mut MaybeUninit<Foo>) -> usize {
+    fn validate(_: &MaybeUninit<usize>) {}
+
+    start_proj!(mut foo);
+    let field: &MaybeUninit<usize> = p!(@foo->field);
+    // we are allowed to share-project `field` again:
+    validate(p!(@foo->field));
+    let mut bar: &mut MaybeUninit<Bar> = p!(@mut foo->bar);
+    start_proj!(mut bar);
+    let x: &mut MaybeUninit<u32> = p!(@mut bar->x);
+    x.write(42);
+    unsafe { field.assume_init_read() }
+}
+
+// Exclusive projections are exclusive, so this doesn't compile.
+fn example2(mut foo: &mut MaybeUninit<Foo>) {
+    start_proj!(mut foo);
+    let a = p!(@mut foo->field);
+    //      ------------------- first exclusive projection occurs here
+    let b = p!(@mut foo->field);
+    //      ^^^^^^^^^^^^^^^^^^^ second exclusive projection occurs here
+    MaybeUninit::write(a, 42);
+    //                 - first projection later used here
+}
+
+// When a value is being projected in any way, it must not be accessed normally.
+fn example3(foo: &mut MaybeUninit<Foo>) -> usize {
+    start_proj!(foo);
+    let field = p!(@foo->field);
+    //          --------------- shared projection occurs here
+    let value = Foo {
+        field: 42,
+        bar: Bar { x: 72 },
+    };
+    MaybeUninit::write(foo, value);
+    //^^^^^^^^^^^^^^^^^^^^^^^^^^^^ projected value used here
+    unsafe { field.assume_init_read() }
+    //       ----- shared projection used here
+}
+
+fn example3_allowed_in_exp_impl(foo: &mut MaybeUninit<Foo>) -> usize {
+    start_proj!(foo);
+    let field = p!(@foo->field);
+    let _ = unsafe { foo.assume_init_read() };
+    unsafe { field.assume_init_read() }
+}
+
+fn move_projections<'a>(foo: &'a mut MaybeUninit<Foo>) -> &'a mut MaybeUninit<Bar> {
+    start_proj!(move foo);
+    p!(@move mut foo->bar)
+}
+
+fn move_projections_motivation<'a>(mut foo: &'a mut MaybeUninit<Foo>) -> &'a mut MaybeUninit<Bar> {
+    start_proj!(mut foo);
+    //------------------ `foo` is borrowed here
+    p!(@mut foo->bar)
+    // ^^^^^^^^^^^^^ returns a value referencing data owned by the current function
+}
+
+fn main() {}

tests/ui/compile-fail/pre_rfc.stderr

@@ -0,0 +1,62 @@
+error[E0599]: no function or associated item named `project_move_mut` found for struct `ProjectedField` in the current scope
+  --> tests/ui/compile-fail/pre_rfc.rs:68:5
+   |
+68 |     p!(@move mut foo->bar)
+   |     ^^^^^^^^^^^^^^^^^^^^^^ function or associated item not found in `ProjectedField<_, _>`
+   |
+note: if you're trying to build a new `ProjectedField<_, _>`, consider using `ProjectedField::<P, F>::__new` which returns `ProjectedField<_, _>`
+  --> src/compat.rs
+   |
+   |     pub unsafe fn __new() -> Self {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: there is a method `project_move` with a similar name, but with different arguments
+  --> src/compat.rs
+   |
+   | /     pub unsafe fn project_move<'a>(self, raw: *const P) -> <P as Project<F>>::Output<'a>
+   | |     where
+   | |         P: Project<F>,
+   | |______________________^
+   = note: this error originates in the macro `p` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+warning: unused variable: `b`
+  --> tests/ui/compile-fail/pre_rfc.rs:38:9
+   |
+38 |     let b = p!(@mut foo->field);
+   |         ^ help: if this is intentional, prefix it with an underscore: `_b`
+   |
+   = note: `#[warn(unused_variables)]` on by default
+
+error[E0499]: cannot borrow value as mutable more than once at a time
+  --> tests/ui/compile-fail/pre_rfc.rs:38:13
+   |
+36 |     let a = p!(@mut foo->field);
+   |             ------------------- first mutable borrow occurs here
+37 |     //      ------------------- first exclusive projection occurs here
+38 |     let b = p!(@mut foo->field);
+   |             ^^^^^^^^^^^^^^^^^^^ second mutable borrow occurs here
+39 |     //      ^^^^^^^^^^^^^^^^^^^ second exclusive projection occurs here
+40 |     MaybeUninit::write(a, 42);
+   |                        - first borrow later used here
+   |
+   = note: this error originates in the macro `p` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0502]: cannot borrow `*foo` as mutable because it is also borrowed as immutable
+  --> tests/ui/compile-fail/pre_rfc.rs:53:5
+   |
+46 |     start_proj!(foo);
+   |     ---------------- immutable borrow occurs here
+...
+53 |     MaybeUninit::write(foo, value);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable borrow occurs here
+54 |     //^^^^^^^^^^^^^^^^^^^^^^^^^^^^ projected value used here
+55 |     unsafe { field.assume_init_read() }
+   |              ----- immutable borrow later used here
+
+error[E0515]: cannot return value referencing function parameter `foo`
+  --> tests/ui/compile-fail/pre_rfc.rs:74:8
+   |
+72 |     start_proj!(mut foo);
+   |     -------------------- `foo` is borrowed here
+73 |     //------------------ `foo` is borrowed here
+74 |     p!(@mut foo->bar)
+   |        ^^^^^^^^^^^^^ returns a value referencing data owned by the current function