some extra test cases to cover in the borrow checker.

Author: pnkfelix

src/test/run-pass/loop-no-reinit-needed-post-bot.rs

@@ -0,0 +1,41 @@
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+struct S;
+// Ensure S is moved, not copied, on assignment.
+impl Drop for S { fn drop(&mut self) { } }
+
+// user-defined function "returning" bottom (i.e. no return at all).
+fn my_fail() -> ! { loop {} }
+
+pub fn step(f: bool) {
+    let mut g = S;
+    let mut i = 0;
+    loop
+    {
+        if i > 10 { break; } else { i += 1; }
+
+        let _g = g;
+
+        if f {
+            // re-initialize g, but only before restarting loop.
+            g = S;
+            continue;
+        }
+
+        my_fail();
+
+        // we never get here, so we do not need to re-initialize g.
+    }
+}
+
+pub fn main() {
+    step(true);
+}

src/test/run-pass/struct-partial-move-1.rs

@@ -0,0 +1,30 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[deriving(PartialEq, Show)]
+struct Partial<T> { x: T, y: T }
+
+#[deriving(PartialEq, Show)]
+struct S { val: int }
+impl S { fn new(v: int) -> S { S { val: v } } }
+impl Drop for S { fn drop(&mut self) { } }
+
+pub fn f<T>((b1, b2): (T, T), f: |T| -> T) -> Partial<T> {
+    let p = Partial { x: b1, y: b2 };
+
+    // Move of `p` is legal even though we are also moving `p.y`; the
+    // `..p` moves all fields *except* `p.y` in this context.
+    Partial { y: f(p.y), ..p }
+}
+
+pub fn main() {
+    let p = f((S::new(3), S::new(4)), |S { val: z }| S::new(z+1));
+    assert_eq!(p, Partial { x: S::new(3), y: S::new(5) });
+}

src/test/run-pass/struct-partial-move-2.rs

@@ -0,0 +1,37 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[deriving(PartialEq, Show)]
+struct Partial<T> { x: T, y: T }
+
+#[deriving(PartialEq, Show)]
+struct S { val: int }
+impl S { fn new(v: int) -> S { S { val: v } } }
+impl Drop for S { fn drop(&mut self) { } }
+
+type Two<T> = (Partial<T>, Partial<T>);
+
+pub fn f<T>((b1, b2): (T, T), (b3, b4): (T, T), f: |T| -> T) -> Two<T> {
+    let p = Partial { x: b1, y: b2 };
+    let q = Partial { x: b3, y: b4 };
+
+     // Move of `q` is legal even though we have already moved `q.y`;
+     // the `..q` moves all fields *except* `q.y` in this context.
+     // Likewise, the move of `p.x` is legal for similar reasons.
+    (Partial { x: f(q.y), ..p }, Partial { y: f(p.x), ..q })
+}
+
+pub fn main() {
+    let two = f((S::new(1), S::new(3)),
+                (S::new(5), S::new(7)),
+                |S { val: z }| S::new(z+1));
+    assert_eq!(two, (Partial { x: S::new(8), y: S::new(3) },
+                     Partial { x: S::new(5), y: S::new(2) }));
+}