wording in test comments

Author: Vanille-N

tests/fail/tree_borrows/children-can-alias.rs

@@ -41,13 +41,16 @@ unsafe fn raw_children_of_unique_can_alias(x: Unique<u8>) {
     let child2 = x.as_ptr();
     // Under `-Zmiri-unique-is-unique`, `Unique` accidentally offers more guarantees
     // than `&mut`. Not because it responds differently to accesses but because
-    // there is no way to obtain a copy with the same tag.
+    // there is no easy way to obtain a copy with the same tag.
     //
-    // The closest attempt (and one that works without `-Zmiri-unique-is-unique`)
-    // is two calls to `as_ptr` that return cousin pointers, not writeable
-    // interchangeably.
-    // This is an unexpected consequence of retagging all `Unique` and we
-    // should find a way to make `Unique` no more strict than `&mut`.
+    // The closest (non-hack) attempt is two calls to `as_ptr`.
+    // - Without `-Zmiri-unique-is-unique`, independent `as_ptr` calls return pointers
+    //   with the same tag that can thus be used interchangeably.
+    // - With the current implementation of `-Zmiri-unique-is-unique`, they return cousin
+    //   tags with permissions that do not tolerate aliasing.
+    // Eventually we should make such aliasing allowed in some situations
+    // (e.g. when there is no protector), which will probably involve
+    // introducing a new kind of permission.
     child1.write(1);
     child2.write(2);
     //~[uniq]^ ERROR: /write access through .* is forbidden/

tests/pass/tree_borrows/unique.rs

@@ -25,20 +25,16 @@ fn main() {
         // and uninitialized permissions.
         let uniq = Unique::new_unchecked(raw);
 
-        // The usage of `-Zmiri-unique-is-unique` disturbs the internal
-        // structure of the tree: pointers that used to have the same tag
-        // under `-Zmiri-tree-borrows` are now cousins under
-        // `-Zmiri-tree-borrows -Zmiri-unique-is-unique`.
+        // With `-Zmiri-unique-is-unique`, `Unique::as_ptr` (which is called by
+        // `Vec::as_ptr`) generates pointers with a fresh tag, so to name the actual
+        // `base` pointer we care about we have to walk up the tree a bit.
         //
-        // This is an unintended consequence of the way we currently
-        // retag `Unique`, and we should look for a way to make these return
-        // the same pointer. In the meantime we hardcode the distance at which
-        // we expect the nearest common ancestor to be (which is the tag of
-        // the actual root `Unique` pointer) and name that.
+        // We care about naming this specific parent tag because it is the one
+        // that stays `Active` during the entire execution, unlike the leaves
+        // that will be invalidated the next time `as_ptr` is called.
         //
         // (We name it twice so that we have an indicator in the output of
         // whether we got the distance correct:
-        //
         // If the output shows
         //
         //    |- <XYZ: uniq>
@@ -50,6 +46,10 @@ fn main() {
         //
         //    '- <XYZ: uniq, uniq>
         // )
+        //
+        // Ultimately we want pointers obtained through independent
+        // calls of `as_ptr` to be able to alias, which will probably involve
+        // a new permission that allows aliasing when there is no protector.
         let nth_parent = if cfg!(uniq) { 2 } else { 0 };
         name!(uniq.as_ptr()=>nth_parent, "uniq");
         name!(uniq.as_ptr()=>nth_parent, "uniq");

tests/pass/tree_borrows/vec_unique.rs

@@ -17,31 +17,31 @@ fn main() {
         let base = vec![0u8, 1];
         let alloc_id = alloc_id!(base.as_ptr());
 
-        // The usage of `-Zmiri-unique-is-unique` disturbs the internal
-        // structure of the tree: pointers that used to have the same tag
-        // under `-Zmiri-tree-borrows` are now cousins under
-        // `-Zmiri-tree-borrows -Zmiri-unique-is-unique`.
+        // With `-Zmiri-unique-is-unique`, `Unique::as_ptr` (which is called by
+        // `Vec::as_ptr`) generates pointers with a fresh tag, so to name the actual
+        // `base` pointer we care about we have to walk up the tree a bit.
         //
-        // This is an unintended consequence of the way we currently
-        // retag `Unique`, and we should look for a way to make these return
-        // the same pointer. In the meantime we hardcode the distance at which
-        // we expect the nearest common ancestor to be (which is the tag of
-        // the actual root `Unique` pointer) and name that.
+        // We care about naming this specific parent tag because it is the one
+        // that stays `Active` during the entire execution, unlike the leaves
+        // that will be invalidated the next time `as_ptr` is called.
         //
         // (We name it twice so that we have an indicator in the output of
         // whether we got the distance correct:
-        //
         // If the output shows
         //
-        //    |- <XYZ: base.as_ptr()>
-        //    '- <XYZ: base.as_ptr()>
+        //    |- <XYZ: uniq>
+        //    '- <XYZ: uniq>
         //
         // then `nth_parent` is not big enough.
         // The correct value for `nth_parent` should be the minimum
         // integer for which the output shows
         //
-        //    '- <XYZ: base.as_ptr(), base.as_ptr()>
+        //    '- <XYZ: uniq, uniq>
         // )
+        //
+        // Ultimately we want pointers obtained through independent
+        // calls of `as_ptr` to be able to alias, which will probably involve
+        // a new permission that allows aliasing when there is no protector.
         let nth_parent = if cfg!(uniq) { 2 } else { 0 };
         name!(base.as_ptr()=>nth_parent);
         name!(base.as_ptr()=>nth_parent);