---

yaml
---
r: 152638
b: refs/heads/try2
c: 373b0fc
h: refs/heads/master
v: v3

Author: pnkfelix

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 95fdbeee48163691cf66de4a53fdc108157babcf
+refs/heads/try2: 373b0fc56905c17d14438446e16712bf714c6f08
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/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);
+}

branches/try2/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) });
+}

branches/try2/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) }));
+}