core: Remove some uses of 'move'

Author: brson

src/libcore/at_vec.rs

@@ -61,7 +61,7 @@ pub pure fn build_sized<A>(size: uint,
                            builder: &fn(push: pure fn(v: A))) -> @[A] {
     let mut vec: @[const A] = @[];
     unsafe { raw::reserve(&mut vec, size); }
-    builder(|+x| unsafe { raw::push(&mut vec, move x) });
+    builder(|+x| unsafe { raw::push(&mut vec, x) });
     return unsafe { transmute(vec) };
 }
 
@@ -178,10 +178,10 @@ pub mod raw {
         let repr: **VecRepr = ::cast::reinterpret_cast(&v);
         let fill = (**repr).unboxed.fill;
         if (**repr).unboxed.alloc > fill {
-            push_fast(v, move initval);
+            push_fast(v, initval);
         }
         else {
-            push_slow(v, move initval);
+            push_slow(v, initval);
         }
     }
 

src/libcore/char.rs

@@ -149,7 +149,7 @@ pub pure fn escape_unicode(c: char) -> ~str {
             { str::push_str(&mut out, ~"0"); }
         str::push_str(&mut out, s);
     }
-    move out
+    out
 }
 
 /**

src/libcore/cleanup.rs

@@ -152,7 +152,7 @@ pub unsafe fn annihilate() {
         assert (*box).header.prev == null();
 
         debug!("freeing box: %x", box as uint);
-        rt_free(transmute(move box));
+        rt_free(transmute(box));
     }
 }
 

src/libcore/str.rs

@@ -133,7 +133,7 @@ pub fn push_char(s: &mut ~str, ch: char) {
 pub pure fn from_char(ch: char) -> ~str {
     let mut buf = ~"";
     unsafe { push_char(&mut buf, ch); }
-    move buf
+    buf
 }
 
 /// Convert a vector of chars to a string
@@ -145,7 +145,7 @@ pub pure fn from_chars(chs: &[char]) -> ~str {
             push_char(&mut buf, *ch);
         }
     }
-    move buf
+    buf
 }
 
 /// Appends a string slice to the back of a string, without overallocating
@@ -186,11 +186,11 @@ pub fn push_str(lhs: &mut ~str, rhs: &str) {
 /// Concatenate two strings together
 #[inline(always)]
 pub pure fn append(lhs: ~str, rhs: &str) -> ~str {
-    let mut v = move lhs;
+    let mut v = lhs;
     unsafe {
         push_str_no_overallocate(&mut v, rhs);
     }
-    move v
+    v
 }
 
 
@@ -200,7 +200,7 @@ pub pure fn concat(v: &[~str]) -> ~str {
     for vec::each(v) |ss| {
         unsafe { push_str(&mut s, *ss) };
     }
-    move s
+    s
 }
 
 /// Concatenate a vector of strings, placing a given separator between each
@@ -210,14 +210,14 @@ pub pure fn connect(v: &[~str], sep: &str) -> ~str {
         if first { first = false; } else { unsafe { push_str(&mut s, sep); } }
         unsafe { push_str(&mut s, *ss) };
     }
-    move s
+    s
 }
 
 /// Given a string, make a new string with repeated copies of it
 pub fn repeat(ss: &str, nn: uint) -> ~str {
     let mut acc = ~"";
     for nn.times { acc += ss; }
-    move acc
+    acc
 }
 
 /*
@@ -359,7 +359,7 @@ Section: Transforming strings
 pub pure fn to_bytes(s: &str) -> ~[u8] unsafe {
     let mut v: ~[u8] = ::cast::transmute(from_slice(s));
     vec::raw::set_len(&mut v, len(s));
-    move v
+    v
 }
 
 /// Work with the string as a byte slice, not including trailing null.
@@ -379,7 +379,7 @@ pub pure fn chars(s: &str) -> ~[char] {
         unsafe { buf.push(ch); }
         i = next;
     }
-    move buf
+    buf
 }
 
 /**
@@ -455,7 +455,7 @@ pure fn split_char_inner(s: &str, sep: char, count: uint, allow_empty: bool)
         if allow_empty || start < l {
             unsafe { result.push(raw::slice_bytes(s, start, l) ) };
         }
-        move result
+        result
     } else {
         splitn(s, |cur| cur == sep, count)
     }
@@ -498,7 +498,7 @@ pure fn split_inner(s: &str, sepfn: fn(cc: char) -> bool, count: uint,
     if allow_empty || start < l unsafe {
         result.push(unsafe { raw::slice_bytes(s, start, l) });
     }
-    move result
+    result
 }
 
 // See Issue #1932 for why this is a naive search
@@ -552,7 +552,7 @@ pub pure fn split_str(s: &a/str, sep: &b/str) -> ~[~str] {
     do iter_between_matches(s, sep) |from, to| {
         unsafe { result.push(raw::slice_bytes(s, from, to)); }
     }
-    move result
+    result
 }
 
 pub pure fn split_str_nonempty(s: &a/str, sep: &b/str) -> ~[~str] {
@@ -562,7 +562,7 @@ pub pure fn split_str_nonempty(s: &a/str, sep: &b/str) -> ~[~str] {
             unsafe { result.push(raw::slice_bytes(s, from, to)); }
         }
     }
-    move result
+    result
 }
 
 /**
@@ -581,7 +581,7 @@ pub pure fn lines_any(s: &str) -> ~[~str] {
         if l > 0u && s[l - 1u] == '\r' as u8 {
             unsafe { raw::set_len(&mut cp, l - 1u); }
         }
-        move cp
+        cp
     })
 }
 
@@ -609,17 +609,17 @@ pub fn split_within(ss: &str, lim: uint) -> ~[~str] {
         // then start a new row
         if row.len() + word.len() + 1 > lim {
             rows.push(copy row); // save previous row
-            row = move word;    // start a new one
+            row = word;    // start a new one
         } else {
             if row.len() > 0 { row += ~" " } // separate words
             row += word;  // append to this row
         }
     }
 
     // save the last row
-    if row != ~"" { rows.push(move row); }
+    if row != ~"" { rows.push(row); }
 
-    move rows
+    rows
 }
 
 
@@ -661,7 +661,7 @@ pub pure fn replace(s: &str, from: &str, to: &str) -> ~str {
         }
         unsafe { push_str(&mut result, raw::slice_bytes(s, start, end)); }
     }
-    move result
+    result
 }
 
 /*
@@ -840,7 +840,7 @@ pub pure fn map(ss: &str, ff: fn(char) -> char) -> ~str {
             str::push_char(&mut result, ff(cc));
         }
     }
-    move result
+    result
 }
 
 /// Iterate over the bytes in a string
@@ -1493,7 +1493,7 @@ pub pure fn to_utf16(s: &str) -> ~[u16] {
             u.push_all(~[w1, w2])
         }
     }
-    move u
+    u
 }
 
 pub pure fn utf16_chars(v: &[u16], f: fn(char)) {
@@ -1527,13 +1527,13 @@ pub pure fn from_utf16(v: &[u16]) -> ~str {
         reserve(&mut buf, vec::len(v));
         utf16_chars(v, |ch| push_char(&mut buf, ch));
     }
-    move buf
+    buf
 }
 
 pub pure fn with_capacity(capacity: uint) -> ~str {
     let mut buf = ~"";
     unsafe { reserve(&mut buf, capacity); }
-    move buf
+    buf
 }
 
 /**
@@ -1921,7 +1921,7 @@ pub pure fn escape_default(s: &str) -> ~str {
             push_str(&mut out, char::escape_default(c));
         }
     }
-    move out
+    out
 }
 
 /// Escape each char in `s` with char::escape_unicode.
@@ -1933,7 +1933,7 @@ pub pure fn escape_unicode(s: &str) -> ~str {
             push_str(&mut out, char::escape_unicode(c));
         }
     }
-    move out
+    out
 }
 
 /// Unsafe operations
@@ -1959,7 +1959,7 @@ pub mod raw {
         v.push(0u8);
 
         assert is_utf8(v);
-        return ::cast::transmute(move v);
+        return ::cast::transmute(v);
     }
 
     /// Create a Rust string from a null-terminated C string
@@ -1987,7 +1987,7 @@ pub mod raw {
                               f: fn(v: &str) -> T) -> T {
         let v = (buf, len + 1);
         assert is_utf8(::cast::reinterpret_cast(&v));
-        f(::cast::transmute(move v))
+        f(::cast::transmute(v))
     }
 
     /**
@@ -2014,7 +2014,7 @@ pub mod raw {
                 }
                 vec::raw::set_len(&mut v, end - begin);
                 v.push(0u8);
-                ::cast::transmute(move v)
+                ::cast::transmute(v)
             }
         }
     }
@@ -2667,13 +2667,13 @@ mod tests {
                 let mut i = 0;
                 let mut rs = ~"";
                 while i < 100000 { push_str(&mut rs, ~"aaaaaaaaaa"); i += 1; }
-                move rs
+                rs
             }
             fn half_a_million_letter_a() -> ~str {
                 let mut i = 0;
                 let mut rs = ~"";
                 while i < 100000 { push_str(&mut rs, ~"aaaaa"); i += 1; }
-                move rs
+                rs
             }
             assert half_a_million_letter_a() ==
                 raw::slice_bytes(a_million_letter_a(), 0u, 500000);
@@ -2780,13 +2780,13 @@ mod tests {
                 push_str(&mut rs, ~"华华华华华华华华华华");
                 i += 1;
             }
-            move rs
+            rs
         }
         fn half_a_million_letter_X() -> ~str {
             let mut i = 0;
             let mut rs = ~"";
             while i < 100000 { push_str(&mut rs, ~"华华华华华"); i += 1; }
-            move rs
+            rs
         }
         assert half_a_million_letter_X() ==
             slice(a_million_letter_X(), 0u, 3u * 500000u);