Better group RFC ui tests together

Author: WaffleLapkin

tests/ui/rfc-2005-default-binding-mode/enum.rs

@@ -0,0 +1,45 @@
+// run-pass
+enum Wrapper {
+    Wrap(i32),
+}
+
+use Wrapper::Wrap;
+
+pub fn main() {
+    let Wrap(x) = &Wrap(3);
+    println!("{}", *x);
+
+    let Wrap(x) = &mut Wrap(3);
+    println!("{}", *x);
+
+    if let Some(x) = &Some(3) {
+        println!("{}", *x);
+    } else {
+        panic!();
+    }
+
+    if let Some(x) = &mut Some(3) {
+        println!("{}", *x);
+    } else {
+        panic!();
+    }
+
+    if let Some(x) = &mut Some(3) {
+        *x += 1;
+    } else {
+        panic!();
+    }
+
+    while let Some(x) = &Some(3) {
+        println!("{}", *x);
+        break;
+    }
+    while let Some(x) = &mut Some(3) {
+        println!("{}", *x);
+        break;
+    }
+    while let Some(x) = &mut Some(3) {
+        *x += 1;
+        break;
+    }
+}

tests/ui/rfc-2005-default-binding-mode/for.rs

@@ -1,4 +1,3 @@
-// run-pass
 enum Wrapper {
     Wrap(i32),
 }
@@ -7,39 +6,17 @@ use Wrapper::Wrap;
 
 pub fn main() {
     let Wrap(x) = &Wrap(3);
-    println!("{}", *x);
+    *x += 1; //~ ERROR cannot assign to `*x`, which is behind a `&` reference
 
-    let Wrap(x) = &mut Wrap(3);
-    println!("{}", *x);
 
     if let Some(x) = &Some(3) {
-        println!("{}", *x);
-    } else {
-        panic!();
-    }
-
-    if let Some(x) = &mut Some(3) {
-        println!("{}", *x);
-    } else {
-        panic!();
-    }
-
-    if let Some(x) = &mut Some(3) {
-        *x += 1;
+        *x += 1; //~ ERROR cannot assign to `*x`, which is behind a `&` reference
     } else {
         panic!();
     }
 
     while let Some(x) = &Some(3) {
-        println!("{}", *x);
-        break;
-    }
-    while let Some(x) = &mut Some(3) {
-        println!("{}", *x);
-        break;
-    }
-    while let Some(x) = &mut Some(3) {
-        *x += 1;
+        *x += 1; //~ ERROR cannot assign to `*x`, which is behind a `&` reference
         break;
     }
 }

tests/ui/rfc-2005-default-binding-mode/lit.rs

@@ -0,0 +1,20 @@
+// run-pass
+pub fn main() {
+    let mut tups = vec![(0u8, 1u8)];
+
+    for (n, m) in &tups {
+        let _: &u8 = n;
+        let _: &u8 = m;
+    }
+
+    for (n, m) in &mut tups {
+        *n += 1;
+        *m += 2;
+    }
+
+    assert_eq!(tups, vec![(1u8, 3u8)]);
+
+    for (n, m) in tups {
+        println!("{} {}", m, n);
+    }
+}

tests/ui/rfc-2005-default-binding-mode/slice.rs

@@ -1,20 +1,9 @@
-// run-pass
-pub fn main() {
-    let mut tups = vec![(0u8, 1u8)];
-
-    for (n, m) in &tups {
-        let _: &u8 = n;
-        let _: &u8 = m;
-    }
+struct Foo {}
 
-    for (n, m) in &mut tups {
-        *n += 1;
-        *m += 2;
-    }
-
-    assert_eq!(tups, vec![(1u8, 3u8)]);
-
-    for (n, m) in tups {
-        println!("{} {}", m, n);
+pub fn main() {
+    let mut tups = vec![(Foo {}, Foo {})];
+    // The below desugars to &(ref n, mut m).
+    for (n, mut m) in &tups {
+        //~^ ERROR cannot move out of a shared reference
     }
 }

tests/ui/rfc-0107-bind-by-move-pattern-guards/bind-by-move-no-guards.rs renamed to tests/ui/rfcs/rfc-0107-bind-by-move-pattern-guards/bind-by-move-no-guards.rs

@@ -0,0 +1,34 @@
+// run-pass
+#![allow(dead_code)]
+fn with_u8() {
+    let s = 5u8;
+    let r = match &s {
+        4 => false,
+        5 => true,
+        _ => false,
+    };
+    assert!(r);
+}
+
+// A string literal isn't mistaken for a non-ref pattern (in which case we'd
+// deref `s` and mess things up).
+fn with_str() {
+    let s: &'static str = "abc";
+    match s {
+            "abc" => true,
+            _ => panic!(),
+    };
+}
+
+// Ditto with byte strings.
+fn with_bytes() {
+    let s: &'static [u8] = b"abc";
+    match s {
+        b"abc" => true,
+        _ => panic!(),
+    };
+}
+
+pub fn main() {
+    with_str();
+}

tests/ui/rfc-0107-bind-by-move-pattern-guards/former-E0008-now-pass.rs renamed to tests/ui/rfcs/rfc-0107-bind-by-move-pattern-guards/former-E0008-now-pass.rs

@@ -1,34 +1,24 @@
-// run-pass
-#![allow(dead_code)]
-fn with_u8() {
-    let s = 5u8;
-    let r = match &s {
-        4 => false,
-        5 => true,
-        _ => false,
-    };
-    assert!(r);
-}
+// FIXME(tschottdorf): we want these to compile, but they don't.
 
-// A string literal isn't mistaken for a non-ref pattern (in which case we'd
-// deref `s` and mess things up).
 fn with_str() {
     let s: &'static str = "abc";
-    match s {
-            "abc" => true,
+
+    match &s {
+            "abc" => true, //~ ERROR mismatched types
             _ => panic!(),
     };
 }
 
-// Ditto with byte strings.
 fn with_bytes() {
     let s: &'static [u8] = b"abc";
-    match s {
-        b"abc" => true,
+
+    match &s {
+        b"abc" => true, //~ ERROR mismatched types
         _ => panic!(),
     };
 }
 
 pub fn main() {
     with_str();
+    with_bytes();
 }

tests/ui/rfc-0107-bind-by-move-pattern-guards/rfc-basic-examples.rs renamed to tests/ui/rfcs/rfc-0107-bind-by-move-pattern-guards/rfc-basic-examples.rs

@@ -0,0 +1,25 @@
+// run-pass
+
+fn slice_pat() {
+    let sl: &[u8] = b"foo";
+
+    match sl {
+        [first, remainder @ ..] => {
+            let _: &u8 = first;
+            assert_eq!(first, &b'f');
+            assert_eq!(remainder, b"oo");
+        }
+        [] => panic!(),
+    }
+}
+
+fn slice_pat_omission() {
+     match &[0, 1, 2] {
+        [..] => {}
+     };
+}
+
+fn main() {
+    slice_pat();
+    slice_pat_omission();
+}

tests/ui/rfc-0107-bind-by-move-pattern-guards/rfc-reject-double-move-across-arms.rs renamed to tests/ui/rfcs/rfc-0107-bind-by-move-pattern-guards/rfc-reject-double-move-across-arms.rs

@@ -1,25 +1,7 @@
-// run-pass
-
-fn slice_pat() {
+pub fn main() {
     let sl: &[u8] = b"foo";
 
-    match sl {
-        [first, remainder @ ..] => {
-            let _: &u8 = first;
-            assert_eq!(first, &b'f');
-            assert_eq!(remainder, b"oo");
-        }
-        [] => panic!(),
-    }
-}
-
-fn slice_pat_omission() {
-     match &[0, 1, 2] {
-        [..] => {}
-     };
-}
-
-fn main() {
-    slice_pat();
-    slice_pat_omission();
+    match sl { //~ ERROR non-exhaustive patterns
+        [first, remainder @ ..] => {},
+    };
 }