Start adding more comprehensive tests

Author: aapoalas

tests/ui/reborrow/custom_marker.rs

@@ -1,34 +1,17 @@
 #![feature(reborrow)]
-use std::ops::{CoerceShared, Reborrow};
+use std::ops::{Reborrow};
 use std::marker::PhantomData;
 
 #[derive(Debug)]
 struct CustomMarker<'a>(PhantomData<&'a ()>);
-#[derive(Debug, Clone, Copy)]
-struct CustomMarkerRef<'a>(PhantomData<&'a ()>);
 impl<'a> Reborrow for CustomMarker<'a> {}
-impl<'a> CoerceShared<CustomMarkerRef<'a>> for CustomMarker<'a> {}
-
 
 fn method<'a>(_a: CustomMarker<'a>) -> &'a () {
     &()
 }
 
-fn method_two<'a>(_a: CustomMarkerRef<'a>) -> &'a () {
-    &()
-}
-
 fn main() {
     let a = CustomMarker(PhantomData);
-    // let b = method(a);
-    // let c = method(a); // should invalidate b
-    let c = method_two(a); // should invalidate b
-    println!("{c:?} {a:?}");
+    let _ = method(a);
+    let _ = method(a);
 }
-
-// fn main_using_normal_references() {
-//     let a = &mut ();
-//     let b = method(a);
-//     let _ = method(a);
-//     eprintln!("{b}");
-// }

tests/ui/reborrow/custom_marker_coerce_shared.rs

@@ -0,0 +1,22 @@
+#![feature(reborrow)]
+use std::ops::{CoerceShared, Reborrow};
+use std::marker::PhantomData;
+
+#[derive(Debug)]
+struct CustomMarker<'a>(PhantomData<&'a ()>);
+impl<'a> Reborrow for CustomMarker<'a> {}
+#[derive(Debug, Clone, Copy)]
+struct CustomMarkerRef<'a>(PhantomData<&'a ()>);
+impl<'a> CoerceShared<CustomMarkerRef<'a>> for CustomMarker<'a> {}
+
+
+fn method<'a>(_a: CustomMarkerRef<'a>) -> &'a () {
+    &()
+}
+
+fn main() {
+    let a = CustomMarker(PhantomData);
+    let b = method(a);
+    let c = method(a);
+    let _ = (b, c);
+}

tests/ui/reborrow/custom_marker_coerce_shared_copy.rs

@@ -0,0 +1,22 @@
+#![feature(reborrow)]
+use std::ops::{CoerceShared, Reborrow};
+use std::marker::PhantomData;
+
+#[derive(Debug)]
+struct CustomMarker<'a>(PhantomData<&'a ()>);
+impl<'a> Reborrow for CustomMarker<'a> {}
+#[derive(Debug, Clone, Copy)]
+struct CustomMarkerRef<'a>(PhantomData<&'a ()>);
+impl<'a> CoerceShared<CustomMarkerRef<'a>> for CustomMarker<'a> {}
+
+
+fn method<'a>(_a: CustomMarkerRef<'a>) -> &'a () {
+    &()
+}
+
+fn main() {
+    let a = CustomMarker(PhantomData);
+    let b = method(a);
+    let c = method(a);
+    let _ = (&a, b, c);
+}

tests/ui/reborrow/custom_marker_coerce_shared_move.rs

@@ -0,0 +1,22 @@
+#![feature(reborrow)]
+use std::ops::{CoerceShared, Reborrow};
+use std::marker::PhantomData;
+
+#[derive(Debug)]
+struct CustomMarker<'a>(PhantomData<&'a ()>);
+impl<'a> Reborrow for CustomMarker<'a> {}
+#[derive(Debug, Clone, Copy)]
+struct CustomMarkerRef<'a>(PhantomData<&'a ()>);
+impl<'a> CoerceShared<CustomMarkerRef<'a>> for CustomMarker<'a> {}
+
+
+fn method<'a>(_a: CustomMarkerRef<'a>) -> &'a () {
+    &()
+}
+
+fn main() {
+    let a = CustomMarker(PhantomData);
+    let b = method(a);
+    let c = method(a);
+    let _ = (a, b, c);
+}

tests/ui/reborrow/custom_marker_mut_a_b.rs

@@ -0,0 +1,18 @@
+#![feature(reborrow)]
+use std::ops::{Reborrow};
+use std::marker::PhantomData;
+
+#[derive(Debug)]
+struct CustomMarker<'a>(PhantomData<&'a ()>);
+impl<'a> Reborrow for CustomMarker<'a> {}
+
+fn method<'a>(_a: CustomMarker<'a>) -> &'a () {
+    &()
+}
+
+fn main() {
+    let a = CustomMarker(PhantomData);
+    let b = method(a);
+    let c = method(a);
+    let _ = (b, c);
+}

tests/ui/reborrow/custom_marker_mut_self.rs

@@ -0,0 +1,17 @@
+#![feature(reborrow)]
+use std::ops::{Reborrow};
+use std::marker::PhantomData;
+
+#[derive(Debug)]
+struct CustomMarker<'a>(PhantomData<&'a ()>);
+impl<'a> Reborrow for CustomMarker<'a> {}
+
+fn method<'a>(_a: CustomMarker<'a>) -> &'a () {
+    &()
+}
+
+fn main() {
+    let a = CustomMarker(PhantomData);
+    let b = method(a);
+    let _ = (a, b); //~ERROR cannot move out of `a` because it is borrowed
+}

tests/ui/reborrow/custom_marker_mut_self_a.rs

@@ -0,0 +1,18 @@
+#![feature(reborrow)]
+use std::ops::{Reborrow};
+use std::marker::PhantomData;
+
+#[derive(Debug)]
+struct CustomMarker<'a>(PhantomData<&'a ()>);
+impl<'a> Reborrow for CustomMarker<'a> {}
+
+fn method<'a>(_a: CustomMarker<'a>) -> &'a () {
+    &()
+}
+
+fn main() {
+    let a = CustomMarker(PhantomData);
+    let b = method(a);
+    let _ = method(a);
+    let _ = (a, b);
+}

tests/ui/reborrow/custom_marker_mut_self_b.rs

@@ -0,0 +1,18 @@
+#![feature(reborrow)]
+use std::ops::{Reborrow};
+use std::marker::PhantomData;
+
+#[derive(Debug)]
+struct CustomMarker<'a>(PhantomData<&'a ()>);
+impl<'a> Reborrow for CustomMarker<'a> {}
+
+fn method<'a>(_a: CustomMarker<'a>) -> &'a () {
+    &()
+}
+
+fn main() {
+    let a = CustomMarker(PhantomData);
+    let _ = method(a);
+    let b = method(a);
+    let _ = (a, b);
+}

tests/ui/reborrow/custom_mut_coerce_shared.rs

@@ -14,13 +14,9 @@ impl<'a, T> Clone for CustomRef<'a, T> {
 }
 impl<'a, T> Copy for CustomRef<'a, T> {}
 
-fn method(a: CustomRef<'_, ()>) {}  //~NOTE function defined here
+fn method(a: CustomRef<'_, ()>) {}
 
 fn main() {
     let a = CustomMut(&mut ());
     method(a);
-    //~^ ERROR mismatched types
-    //~| NOTE expected `CustomRef<'_, ()>`, found `CustomMut<'_, ()>`
-    //~| NOTE arguments to this function are incorrect
-    //~| NOTE expected struct `CustomRef<'_, ()>`
 }