---

yaml
---
r: 50709
b: refs/heads/try
c: 6859a6d
h: refs/heads/master
i:
  50707: 6aa4140
v: v3

Author: bors

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 5f13e9ccc2e3328d4cd8ca49f84e6840dd998346
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: f7a2371c176663d59062ec5158f39faecba45768
-refs/heads/try: ee5842494a9170d6e1079a671695fcfc32ceb920
+refs/heads/try: 6859a6d9a327d7fcd81a38c8e3af6aa0005f7944
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/libcore/clone.rs

@@ -20,11 +20,6 @@ impl Clone for () {
     fn clone(&self) -> () { () }
 }
 
-impl<T:Clone> Clone for ~T {
-    #[inline(always)]
-    fn clone(&self) -> ~T { ~(**self).clone() }
-}
-
 macro_rules! clone_impl(
     ($t:ty) => {
         impl Clone for $t {

branches/try/src/libcore/str.rs

@@ -20,7 +20,6 @@
 use at_vec;
 use cast;
 use char;
-use clone::Clone;
 use cmp::{Equiv, TotalOrd, Ordering, Less, Equal, Greater};
 use libc;
 use option::{None, Option, Some};
@@ -2274,6 +2273,7 @@ pub trait StrSlice {
     pure fn to_owned(&self) -> ~str;
     pure fn to_managed(&self) -> @str;
     pure fn char_at(&self, i: uint) -> char;
+    fn to_bytes(&self) -> ~[u8];
 }
 
 /// Extension methods for strings
@@ -2417,6 +2417,8 @@ impl StrSlice for &self/str {
 
     #[inline]
     pure fn char_at(&self, i: uint) -> char { char_at(*self, i) }
+
+    fn to_bytes(&self) -> ~[u8] { to_bytes(*self) }
 }
 
 pub trait OwnedStr {
@@ -2434,13 +2436,6 @@ impl OwnedStr for ~str {
     }
 }
 
-impl Clone for ~str {
-    #[inline(always)]
-    fn clone(&self) -> ~str {
-        self.to_str()  // hilarious
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use char;

branches/try/src/libcore/unstable/global.rs

@@ -68,11 +68,11 @@ unsafe fn global_data_clone_create_<T:Owned + Clone>(
         match value {
             None => {
                 let value = create();
-                clone_value = Some((*value).clone());
+                clone_value = Some(value.clone());
                 Some(value)
             }
             Some(value) => {
-                clone_value = Some((*value).clone());
+                clone_value = Some(value.clone());
                 Some(value)
             }
         }
@@ -193,7 +193,7 @@ fn get_global_state() -> Exclusive<GlobalState> {
             // Successfully installed the global pointer
 
             // Take a handle to return
-            let clone = (*state).clone();
+            let clone = state.clone();
 
             // Install a runtime exit function to destroy the global object
             do at_exit {

branches/try/src/libcore/vec.rs

@@ -15,7 +15,6 @@
 use container::{Container, Mutable};
 use cast;
 use cmp::{Eq, Equiv, Ord, TotalOrd, Ordering, Less, Equal, Greater};
-use clone::Clone;
 use iter::BaseIter;
 use iter;
 use kinds::Copy;
@@ -2502,18 +2501,6 @@ impl<A:Copy> iter::CopyableNonstrictIter<A> for @[A] {
     }
 }
 
-impl<A:Clone> Clone for ~[A] {
-    #[inline]
-    fn clone(&self) -> ~[A] {
-        let mut dolly = ~[];
-        vec::reserve(&mut dolly, self.len());
-        for self.each |item| {
-            dolly.push(item.clone());
-        }
-        return dolly;
-    }
-}
-
 // ___________________________________________________________________________
 
 #[cfg(test)]

branches/try/src/libstd/arc.rs

@@ -572,7 +572,7 @@ mod tests {
     #[test] #[should_fail] #[ignore(cfg(windows))]
     pub fn test_rw_arc_poison_wr() {
         let arc = ~RWARC(1);
-        let arc2 = (*arc).clone();
+        let arc2 = ~arc.clone();
         do task::try || {
             do arc2.write |one| {
                 fail_unless!(*one == 2);
@@ -585,7 +585,7 @@ mod tests {
     #[test] #[should_fail] #[ignore(cfg(windows))]
     pub fn test_rw_arc_poison_ww() {
         let arc = ~RWARC(1);
-        let arc2 = (*arc).clone();
+        let arc2 = ~arc.clone();
         do task::try || {
             do arc2.write |one| {
                 fail_unless!(*one == 2);
@@ -598,7 +598,7 @@ mod tests {
     #[test] #[should_fail] #[ignore(cfg(windows))]
     pub fn test_rw_arc_poison_dw() {
         let arc = ~RWARC(1);
-        let arc2 = (*arc).clone();
+        let arc2 = ~arc.clone();
         do task::try || {
             do arc2.write_downgrade |write_mode| {
                 do (&write_mode).write |one| {
@@ -613,7 +613,7 @@ mod tests {
     #[test] #[ignore(cfg(windows))]
     pub fn test_rw_arc_no_poison_rr() {
         let arc = ~RWARC(1);
-        let arc2 = (*arc).clone();
+        let arc2 = ~arc.clone();
         do task::try || {
             do arc2.read |one| {
                 fail_unless!(*one == 2);
@@ -626,7 +626,7 @@ mod tests {
     #[test] #[ignore(cfg(windows))]
     pub fn test_rw_arc_no_poison_rw() {
         let arc = ~RWARC(1);
-        let arc2 = (*arc).clone();
+        let arc2 = ~arc.clone();
         do task::try || {
             do arc2.read |one| {
                 fail_unless!(*one == 2);
@@ -639,7 +639,7 @@ mod tests {
     #[test] #[ignore(cfg(windows))]
     pub fn test_rw_arc_no_poison_dr() {
         let arc = ~RWARC(1);
-        let arc2 = (*arc).clone();
+        let arc2 = ~arc.clone();
         do task::try || {
             do arc2.write_downgrade |write_mode| {
                 let read_mode = arc2.downgrade(write_mode);
@@ -655,7 +655,7 @@ mod tests {
     #[test]
     pub fn test_rw_arc() {
         let arc = ~RWARC(0);
-        let arc2 = (*arc).clone();
+        let arc2 = ~arc.clone();
         let (p,c) = comm::stream();
 
         do task::spawn || {
@@ -673,7 +673,7 @@ mod tests {
         // Readers try to catch the writer in the act
         let mut children = ~[];
         for 5.times {
-            let arc3 = (*arc).clone();
+            let arc3 = ~arc.clone();
             do task::task().future_result(|+r| children.push(r)).spawn
                 || {
                 do arc3.read |num| {
@@ -704,7 +704,7 @@ mod tests {
         for 10.times {
             let ((rp1,rc1),(rp2,rc2)) = (comm::stream(),comm::stream());
             reader_convos.push((rc1, rp2));
-            let arcn = (*arc).clone();
+            let arcn = ~arc.clone();
             do task::spawn || {
                 rp1.recv(); // wait for downgrader to give go-ahead
                 do arcn.read |state| {
@@ -715,7 +715,7 @@ mod tests {
         }
 
         // Writer task
-        let arc2 = (*arc).clone();
+        let arc2 = ~arc.clone();
         let ((wp1,wc1),(wp2,wc2)) = (comm::stream(),comm::stream());
         do task::spawn || {
             wp1.recv();

branches/try/src/libstd/sync.rs

@@ -827,7 +827,7 @@ mod tests {
         // "load tmp = move ptr; inc tmp; store ptr <- tmp" dance.
         let (p,c) = comm::stream();
         let m = ~Mutex();
-        let m2 = m.clone();
+        let m2 = ~m.clone();
         let mut sharedstate = ~0;
         let ptr = ptr::addr_of(&(*sharedstate));
         do task::spawn || {
@@ -1105,13 +1105,13 @@ mod tests {
         // Test mutual exclusion between readers and writers. Just like the
         // mutex mutual exclusion test, a ways above.
         let (p,c) = comm::stream();
-        let x2 = (*x).clone();
+        let x2 = ~x.clone();
         let mut sharedstate = ~0;
         let ptr = ptr::addr_of(&(*sharedstate));
         do task::spawn || {
             let sharedstate: &mut int =
                 unsafe { cast::reinterpret_cast(&ptr) };
-            access_shared(sharedstate, &x2, mode1, 10);
+            access_shared(sharedstate, x2, mode1, 10);
             c.send(());
         }
         access_shared(sharedstate, x, mode2, 10);
@@ -1150,14 +1150,14 @@ mod tests {
                                  mode2: RWlockMode,
                                  make_mode2_go_first: bool) {
         // Much like sem_multi_resource.
-        let x2 = (*x).clone();
+        let x2 = ~x.clone();
         let (p1,c1) = comm::stream();
         let (p2,c2) = comm::stream();
         do task::spawn || {
             if !make_mode2_go_first {
                 let _ = p2.recv(); // parent sends to us once it locks, or ...
             }
-            do lock_rwlock_in_mode(&x2, mode2) {
+            do lock_rwlock_in_mode(x2, mode2) {
                 if make_mode2_go_first {
                     c1.send(()); // ... we send to it once we lock
                 }
@@ -1207,7 +1207,7 @@ mod tests {
 
         // Child wakes up parent
         do x.write_cond |cond| {
-            let x2 = (*x).clone();
+            let x2 = ~x.clone();
             do task::spawn || {
                 do x2.write_cond |cond| {
                     let woken = cond.signal();
@@ -1218,7 +1218,7 @@ mod tests {
         }
         // Parent wakes up child
         let (port,chan) = comm::stream();
-        let x3 = (*x).clone();
+        let x3 = ~x.clone();
         do task::spawn || {
             do x3.write_cond |cond| {
                 chan.send(());
@@ -1253,11 +1253,11 @@ mod tests {
         let mut ports = ~[];
 
         for num_waiters.times {
-            let xi = (*x).clone();
+            let xi = ~x.clone();
             let (port, chan) = comm::stream();
             ports.push(port);
             do task::spawn || {
-                do lock_cond(&xi, dg1) |cond| {
+                do lock_cond(xi, dg1) |cond| {
                     chan.send(());
                     cond.wait();
                     chan.send(());
@@ -1289,10 +1289,10 @@ mod tests {
     pub fn rwlock_kill_helper(mode1: RWlockMode, mode2: RWlockMode) {
         // Mutex must get automatically unlocked if failed/killed within.
         let x = ~RWlock();
-        let x2 = (*x).clone();
+        let x2 = ~x.clone();
 
         let result: result::Result<(),()> = do task::try || {
-            do lock_rwlock_in_mode(&x2, mode1) {
+            do lock_rwlock_in_mode(x2, mode1) {
                 fail!();
             }
         };

branches/try/src/libsyntax/codemap.rs

@@ -140,7 +140,7 @@ impl cmp::Eq for span {
 
 impl<S:Encoder> Encodable<S> for span {
     /* Note #1972 -- spans are encoded but not decoded */
-    fn encode(&self, _s: &S) { }
+    fn encode(&self, _s: &S) { _s.emit_nil() }
 }
 
 impl<D:Decoder> Decodable<D> for span {

branches/try/src/libsyntax/ext/pipes/liveness.rs

@@ -63,7 +63,7 @@ pub fn analyze(proto: protocol, _cx: @ext_ctxt) {
         debug!("colive iteration %?", i);
         let mut new_colive = ~[];
         for colive.eachi |i, this_colive| {
-            let mut result = this_colive.clone();
+            let mut result = ~this_colive.clone();
             let this = proto.get_state_by_id(i);
             for this_colive.ones |j| {
                 let next = proto.get_state_by_id(j);

branches/try/src/libsyntax/parse/mod.rs

@@ -297,10 +297,9 @@ mod test {
     use std;
     use core::io;
     use core::option::None;
-    use core::str;
     use util::testing::*;
 
-    #[test] fn to_json_str (val: @Encodable<std::json::Encoder>) -> ~str {
+    #[test] fn to_json_str<E : Encodable<std::json::Encoder>>(val: @E) -> ~str {
         do io::with_str_writer |writer| {
             val.encode(~std::json::Encoder(writer));
         }
@@ -312,18 +311,18 @@ mod test {
             @~"fn foo (x : int) { x; }",
             ~[],
             new_parse_sess(None));
-        check_equal(to_json_str(@tts as @Encodable<std::json::Encoder>),
-                    ~"[[\"tt_tok\",[,[\"IDENT\",[\"fn\",false]]]],\
-                      [\"tt_tok\",[,[\"IDENT\",[\"foo\",false]]]],\
-                      [\"tt_delim\",[[[\"tt_tok\",[,[\"LPAREN\",[]]]],\
-                      [\"tt_tok\",[,[\"IDENT\",[\"x\",false]]]],\
-                      [\"tt_tok\",[,[\"COLON\",[]]]],\
-                      [\"tt_tok\",[,[\"IDENT\",[\"int\",false]]]],\
-                      [\"tt_tok\",[,[\"RPAREN\",[]]]]]]],\
-                      [\"tt_delim\",[[[\"tt_tok\",[,[\"LBRACE\",[]]]],\
-                      [\"tt_tok\",[,[\"IDENT\",[\"x\",false]]]],\
-                      [\"tt_tok\",[,[\"SEMI\",[]]]],\
-                      [\"tt_tok\",[,[\"RBRACE\",[]]]]]]]]"
+        check_equal(to_json_str(@tts),
+                    ~"[[\"tt_tok\",[null,[\"IDENT\",[\"fn\",false]]]],\
+                      [\"tt_tok\",[null,[\"IDENT\",[\"foo\",false]]]],\
+                      [\"tt_delim\",[[[\"tt_tok\",[null,[\"LPAREN\",[]]]],\
+                      [\"tt_tok\",[null,[\"IDENT\",[\"x\",false]]]],\
+                      [\"tt_tok\",[null,[\"COLON\",[]]]],\
+                      [\"tt_tok\",[null,[\"IDENT\",[\"int\",false]]]],\
+                      [\"tt_tok\",[null,[\"RPAREN\",[]]]]]]],\
+                      [\"tt_delim\",[[[\"tt_tok\",[null,[\"LBRACE\",[]]]],\
+                      [\"tt_tok\",[null,[\"IDENT\",[\"x\",false]]]],\
+                      [\"tt_tok\",[null,[\"SEMI\",[]]]],\
+                      [\"tt_tok\",[null,[\"RBRACE\",[]]]]]]]]"
                    );
         let ast1 = new_parser_from_tts(new_parse_sess(None),~[],tts)
             .parse_item(~[]);

branches/try/src/test/run-pass/alt-value-binding-in-guard-3291.rs

@@ -11,7 +11,7 @@
 fn foo(x: Option<~int>, b: bool) -> int {
     match x {
       None => { 1 }
-      Some(ref x) if b => { *x.clone() }
+      Some(copy x) if b => { *x }
       Some(_) => { 0 }
     }
 }

branches/try/src/test/run-pass/assignability-trait.rs

@@ -43,7 +43,7 @@ pub fn main() {
     // Call a method
     for x.iterate() |y| { fail_unless!(x[*y] == *y); }
     // Call a parameterized function
-    fail_unless!(length(x.clone()) == vec::len(x));
+    fail_unless!(length(copy x) == vec::len(x));
     // Call a parameterized function, with type arguments that require
     // a borrow
     fail_unless!(length::<int, &[int]>(x) == vec::len(x));

branches/try/src/test/run-pass/block-iter-2.rs

@@ -15,8 +15,8 @@ fn iter_vec<T>(v: ~[T], f: &fn(&T)) { for v.each |x| { f(x); } }
 pub fn main() {
     let v = ~[1, 2, 3, 4, 5];
     let mut sum = 0;
-    iter_vec(v.clone(), |i| {
-        iter_vec(v.clone(), |j| {
+    iter_vec(copy v, |i| {
+        iter_vec(copy v, |j| {
             sum += *i * *j;
         });
     });

branches/try/src/test/run-pass/block-vec-map2.rs

@@ -15,6 +15,6 @@ pub fn main() {
         vec::map2(~[1, 2, 3, 4, 5],
                   ~[true, false, false, true, true],
                   |i, b| if *b { -(*i) } else { *i } );
-    error!(v.clone());
+    error!(copy v);
     fail_unless!((v == ~[-1, 2, 3, -4, -5]));
 }

branches/try/src/test/run-pass/borrowck-borrow-from-expr-block.rs

@@ -13,7 +13,7 @@ fn borrow(x: &int, f: &fn(x: &int)) {
 }
 
 fn test1(x: @~int) {
-    do borrow(&*x.clone()) |p| {
+    do borrow(copy *x) |p| {
         let x_a = ptr::addr_of(&(**x));
         fail_unless!((x_a as uint) != ptr::to_uint(p));
         fail_unless!(unsafe{*x_a} == *p);