Merge pull request #4309 from RalfJung/both-borrows-tests

move tests that are identical between SB and TB to shared files

Author: RalfJung

src/tools/miri/tests/pass/stacked-borrows/2phase.rs renamed to src/tools/miri/tests/pass/both_borrows/2phase.rs

@@ -1,5 +1,5 @@
-// FIXME: this miscompiles with optimizations, see <https://github.com/rust-lang/rust/issues/132898>.
-//@compile-flags: -Zmir-opt-level=0
+//@revisions: stack tree
+//@[tree]compile-flags: -Zmiri-tree-borrows
 
 trait S: Sized {
     fn tpb(&mut self, _s: Self) {}
@@ -31,9 +31,9 @@ fn two_phase3(b: bool) {
     ));
 }
 
-#[allow(unreachable_code)]
 fn two_phase_raw() {
     let x: &mut Vec<i32> = &mut vec![];
+    #[allow(unreachable_code)] // The `push` itself never gets reached.
     x.push({
         // Unfortunately this does not trigger the problem of creating a
         // raw ponter from a pointer that had a two-phase borrow derived from
@@ -59,52 +59,12 @@ fn two_phase_overlapping2() {
     x.add_assign(x + *l);
 }
 
-fn with_interior_mutability() {
-    use std::cell::Cell;
-
-    trait Thing: Sized {
-        fn do_the_thing(&mut self, _s: i32) {}
-    }
-
-    impl<T> Thing for Cell<T> {}
-
-    let mut x = Cell::new(1);
-    let l = &x;
-
-    x.do_the_thing({
-        x.set(3);
-        l.set(4);
-        x.get() + l.get()
-    });
-}
-
-// This one really shouldn't be accepted, but since we treat 2phase as raw, we do accept it.
-// Tree Borrows rejects it.
-fn aliasing_violation() {
-    struct Foo(u64);
-    impl Foo {
-        fn add(&mut self, n: u64) -> u64 {
-            self.0 + n
-        }
-    }
-
-    let mut f = Foo(0);
-    let alias = &mut f.0 as *mut u64;
-    let res = f.add(unsafe {
-        *alias = 42;
-        0
-    });
-    assert_eq!(res, 42);
-}
-
 fn main() {
     two_phase1();
     two_phase2();
     two_phase3(false);
     two_phase3(true);
     two_phase_raw();
-    with_interior_mutability();
     two_phase_overlapping1();
     two_phase_overlapping2();
-    aliasing_violation();
 }

src/tools/miri/tests/pass/stacked-borrows/stacked-borrows.rs renamed to src/tools/miri/tests/pass/both_borrows/basic_aliasing_model.rs

@@ -1,14 +1,15 @@
+//@revisions: stack tree
+//@[tree]compile-flags: -Zmiri-tree-borrows
 #![feature(allocator_api)]
 use std::ptr;
 
-// Test various stacked-borrows-related things.
+// Test various aliasing-model-related things.
 fn main() {
     read_does_not_invalidate1();
     read_does_not_invalidate2();
     mut_raw_then_mut_shr();
     mut_shr_then_mut_raw();
     mut_raw_mut();
-    mut_raw_mut2();
     partially_invalidate_mut();
     drop_after_sharing();
     // direct_mut_to_const_raw();
@@ -97,18 +98,6 @@ fn mut_raw_mut() {
     assert_eq!(x, 4);
 }
 
-// A variant of `mut_raw_mut` that does *not* get accepted by Tree Borrows.
-// It's kind of an accident that we accept it in Stacked Borrows...
-fn mut_raw_mut2() {
-    unsafe {
-        let mut root = 0;
-        let to = &mut root as *mut i32;
-        *to = 0;
-        let _val = root;
-        *to = 0;
-    }
-}
-
 fn partially_invalidate_mut() {
     let data = &mut (0u8, 0u8);
     let reborrow = &mut *data as *mut (u8, u8);
@@ -124,15 +113,6 @@ fn drop_after_sharing() {
     let _len = x.len();
 }
 
-// Make sure that coercing &mut T to *const T produces a writeable pointer.
-// TODO: This is currently disabled, waiting on a decision on <https://github.com/rust-lang/rust/issues/56604>
-/*fn direct_mut_to_const_raw() {
-    let x = &mut 0;
-    let y: *const i32 = x;
-    unsafe { *(y as *mut i32) = 1; }
-    assert_eq!(*x, 1);
-}*/
-
 // Make sure that we can create two raw pointers from a mutable reference and use them both.
 fn two_raw() {
     unsafe {
@@ -178,7 +158,7 @@ fn disjoint_mutable_subborrows() {
     let b = unsafe { borrow_field_b(ptr) };
     b.push(4);
     a.push_str(" world");
-    eprintln!("{:?} {:?}", a, b);
+    assert_eq!(format!("{:?} {:?}", a, b), r#""hello world" [0, 1, 2, 4]"#);
 }
 
 fn raw_ref_to_part() {
@@ -243,7 +223,7 @@ fn not_unpin_not_protected() {
     pub struct NotUnpin(#[allow(dead_code)] i32, PhantomPinned);
 
     fn inner(x: &mut NotUnpin, f: fn(&mut NotUnpin)) {
-        // `f` may mutate, but it may not deallocate!
+        // `f` is allowed to deallocate `x`.
         f(x)
     }
 

src/tools/miri/tests/pass/tree_borrows/interior_mutability.rs renamed to src/tools/miri/tests/pass/both_borrows/interior_mutability.rs

@@ -1,5 +1,7 @@
-//@compile-flags: -Zmiri-tree-borrows
+//@revisions: stack tree
+//@[tree]compile-flags: -Zmiri-tree-borrows
 #![allow(dangerous_implicit_autorefs)]
+
 use std::cell::{Cell, Ref, RefCell, RefMut, UnsafeCell};
 use std::mem::{self, MaybeUninit};
 
@@ -14,6 +16,7 @@ fn main() {
     ref_protector();
     ref_mut_protector();
     rust_issue_68303();
+    two_phase();
 }
 
 fn aliasing_mut_and_shr() {
@@ -101,13 +104,15 @@ fn unsafe_cell_invalidate() {
     let raw1 = &mut x as *mut _;
     let ref1 = unsafe { &mut *raw1 };
     let raw2 = ref1 as *mut _;
-    // Now the borrow tree is:
+    // Now the borrow stack is: raw1, ref2, raw2.
+    //
+    // For TB, the tree is
     //
     // Act x
     // Res `- raw1
     // Res    `- ref1, raw2
     //
-    // So using raw1 invalidates raw2.
+    // Either way, using raw1 invalidates raw2.
     f(unsafe { mem::transmute(raw2) }, raw1);
 }
 
@@ -179,3 +184,27 @@ fn rust_issue_68303() {
     assert!(optional.is_some());
     *handle = true;
 }
+
+fn two_phase() {
+    use std::cell::Cell;
+
+    trait Thing: Sized {
+        fn do_the_thing(&mut self, _s: i32) {}
+    }
+
+    impl<T> Thing for Cell<T> {}
+
+    let mut x = Cell::new(1);
+    let l = &x;
+
+    x.do_the_thing({
+        // In TB terms:
+        // Several Foreign accesses (both Reads and Writes) to the location
+        // being reborrowed. Reserved + unprotected + interior mut
+        // makes the pointer immune to everything as long as all accesses
+        // are child accesses to its parent pointer x.
+        x.set(3);
+        l.set(4);
+        x.get() + l.get()
+    });
+}

src/tools/miri/tests/pass/stacked-borrows/interior_mutability.rs

@@ -1,5 +1,5 @@
 warning: integer-to-pointer cast
-  --> tests/pass/stacked-borrows/issue-miri-2389.rs:LL:CC
+  --> tests/pass/stacked_borrows/issue-miri-2389.rs:LL:CC
    |
 LL |         let wildcard = &root0 as *const Cell<i32> as usize as *const Cell<i32>;
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ integer-to-pointer cast
@@ -10,5 +10,5 @@ LL |         let wildcard = &root0 as *const Cell<i32> as usize as *const Cell<i
    = help: you can then set `MIRIFLAGS=-Zmiri-strict-provenance` to ensure you are not relying on `with_exposed_provenance` semantics
    = help: alternatively, `MIRIFLAGS=-Zmiri-permissive-provenance` disables this warning
    = note: BACKTRACE:
-   = note: inside `main` at tests/pass/stacked-borrows/issue-miri-2389.rs:LL:CC
+   = note: inside `main` at tests/pass/stacked_borrows/issue-miri-2389.rs:LL:CC