Make all remaining moves explicit in libcore

catamorphism · catamorphism · commit f2d9d0ba4148 · 2012-09-10T16:31:39.000-07:00
diff --git a/src/libcore/extfmt.rs b/src/libcore/extfmt.rs
@@ -88,35 +88,35 @@ mod ct {
         let lim = str::len(s);
         let mut buf = ~"";
         fn flush_buf(+buf: ~str, &pieces: ~[piece]) -> ~str {
-            if str::len(buf) > 0u {
-                let piece = piece_string(buf);
-                vec::push(pieces, piece);
+            if str::len(buf) > 0 {
+                let piece = piece_string(move buf);
+                vec::push(pieces, move piece);
             }
             return ~"";
         }
-        let mut i = 0u;
+        let mut i = 0;
         while i < lim {
             let size = str::utf8_char_width(s[i]);
             let curr = str::slice(s, i, i+size);
             if curr == ~"%" {
-                i += 1u;
+                i += 1;
                 if i >= lim {
                     error(~"unterminated conversion at end of string");
                 }
-                let curr2 = str::slice(s, i, i+1u);
+                let curr2 = str::slice(s, i, i+1);
                 if curr2 == ~"%" {
                     buf += curr2;
-                    i += 1u;
+                    i += 1;
                 } else {
-                    buf = flush_buf(buf, pieces);
+                    buf = flush_buf(move buf, pieces);
                     let rs = parse_conversion(s, i, lim, error);
                     vec::push(pieces, copy rs.piece);
                     i = rs.next;
                 }
             } else { buf += curr; i += size; }
         }
-        flush_buf(buf, pieces);
-        return pieces;
+        flush_buf(move buf, pieces);
+        move pieces
     }
     fn peek_num(s: ~str, i: uint, lim: uint) ->
        Option<{num: uint, next: uint}> {
@@ -173,7 +173,7 @@ mod ct {
     fn parse_flags(s: ~str, i: uint, lim: uint) ->
        {flags: ~[flag], next: uint} {
         let noflags: ~[flag] = ~[];
-        if i >= lim { return {flags: noflags, next: i}; }
+        if i >= lim { return {flags: move noflags, next: i}; }
 
         fn more_(f: flag, s: ~str, i: uint, lim: uint) ->
            {flags: ~[flag], next: uint} {
@@ -376,7 +376,7 @@ mod rt {
                     let diff = prec - len;
                     let pad = str::from_chars(vec::from_elem(diff, '0'));
                     pad + s
-                } else { s }
+                } else { move s }
             };
     }
     pure fn get_int_precision(cv: conv) -> uint {
diff --git a/src/libcore/flate.rs b/src/libcore/flate.rs
@@ -31,7 +31,7 @@ fn deflate_buf(buf: &[const u8]) -> ~[u8] {
             let out = vec::unsafe::from_buf(res as *u8,
                                             outsz as uint);
             libc::free(res);
-            out
+            move out
         }
     }
 }
@@ -49,7 +49,7 @@ fn inflate_buf(buf: &[const u8]) -> ~[u8] {
             let out = vec::unsafe::from_buf(res as *u8,
                                             outsz as uint);
             libc::free(res);
-            out
+            move out
         }
     }
 }
diff --git a/src/libcore/io.rs b/src/libcore/io.rs
@@ -58,7 +58,7 @@ impl<T: Reader> T : ReaderUtil {
         let count = self.read(buf, len);
 
         unsafe { vec::unsafe::set_len(buf, count); }
-        vec::from_mut(buf)
+        vec::from_mut(move buf)
     }
     fn read_line() -> ~str {
         let mut buf = ~[];
@@ -128,7 +128,7 @@ impl Reader {
                 buf = vec::slice(buf, offset, vec::len(buf));
             }
         }
-        chars
+        move chars
     }
 
     fn read_char() -> char {
@@ -180,7 +180,7 @@ impl Reader {
     fn read_whole_stream() -> ~[u8] {
         let mut buf: ~[u8] = ~[];
         while !self.eof() { vec::push_all(buf, self.read_bytes(2048u)); }
-        buf
+        move buf
     }
 
     fn each_byte(it: fn(int) -> bool) {
@@ -688,7 +688,7 @@ impl MemBuffer: Writer {
 
             self.pos += v_len;
 
-            buf
+            move buf
         }
     }
     fn seek(offset: int, whence: SeekStyle) {
diff --git a/src/libcore/os.rs b/src/libcore/os.rs
@@ -215,7 +215,7 @@ mod global_env {
                 assert vec::len(vs) == 2u;
                 vec::push(pairs, (copy vs[0], copy vs[1]));
             }
-            return pairs;
+            move pairs
         }
 
         #[cfg(unix)]
diff --git a/src/libcore/path.rs b/src/libcore/path.rs
@@ -99,7 +99,7 @@ impl PosixPath : GenericPath {
             if s.len() == 0 {
                 ~"."
             } else {
-                s
+                move s
             }
         }
     }
@@ -139,7 +139,7 @@ impl PosixPath : GenericPath {
         let dpath = from_str::<PosixPath>(d);
         match self.filename() {
           Some(ref f) => dpath.push(*f),
-          None => dpath
+          None => move dpath
         }
     }
 
@@ -197,8 +197,7 @@ impl PosixPath : GenericPath {
     }
 
     pure fn push_many(cs: &[~str]) -> PosixPath {
-        return PosixPath { components: self.components + cs,
-                           ..self }
+       PosixPath { components: (copy self.components) + copy cs, ..self }
     }
 
     pure fn push(s: &str) -> PosixPath {
@@ -288,7 +287,7 @@ impl WindowsPath : GenericPath {
             if s.len() == 0 {
                 ~"."
             } else {
-                s
+                move s
             }
         }
     }
@@ -328,7 +327,7 @@ impl WindowsPath : GenericPath {
         let dpath = from_str::<WindowsPath>(d);
         match self.filename() {
           Some(ref f) => dpath.push(*f),
-          None => dpath
+          None => move dpath
         }
     }
 
@@ -386,7 +385,7 @@ impl WindowsPath : GenericPath {
     }
 
     pure fn push_many(cs: &[~str]) -> WindowsPath {
-        return WindowsPath { components: self.components + cs,
+        return WindowsPath { components: (copy self.components) + (copy cs),
                             ..self }
     }
 
@@ -428,7 +427,7 @@ pure fn normalize(components: &[~str]) -> ~[~str] {
             }
         }
     }
-    cs
+    move cs
 }
 
 mod posix {
@@ -525,7 +524,7 @@ mod windows {
                 if s[i] == '\\' as u8 {
                     let pre = s.slice(2, i);
                     let rest = s.slice(i, s.len());
-                    return Some((pre, rest));
+                    return Some((move pre, move rest));
                 }
                 i += 1;
             }
@@ -543,7 +542,7 @@ mod windows {
                 } else {
                     s.slice(2, s.len())
                 };
-                return Some((s.slice(0,1), rest));
+                return Some((s.slice(0,1), move rest));
             }
             None
         }
diff --git a/src/libcore/priv.rs b/src/libcore/priv.rs
@@ -46,15 +46,15 @@ unsafe fn chan_from_global_ptr<T: Send>(
         // There's no global channel. We must make it
 
         let (setup_po, setup_ch) = do task_fn().spawn_conversation
-            |setup_po, setup_ch| {
+            |move f, setup_po, setup_ch| {
             let po = comm::Port::<T>();
             let ch = comm::Chan(po);
             comm::send(setup_ch, ch);
 
             // Wait to hear if we are the official instance of
             // this global task
             match comm::recv::<Msg>(setup_po) {
-              Proceed => f(po),
+              Proceed => f(move po),
               Abort => ()
             }
         };
diff --git a/src/libcore/rand.rs b/src/libcore/rand.rs
@@ -154,7 +154,7 @@ impl Rng {
             s = s + str::from_char(self.gen_char_from(charset));
             i += 1u;
         }
-        s
+        move s
     }
 
     /// Return a random byte string of the specified length
@@ -220,14 +220,14 @@ impl Rng {
                 vec::push(r, item.item);
             }
         }
-        r
+        move r
     }
 
     /// Shuffle a vec
     fn shuffle<T:Copy>(values: &[T]) -> ~[T] {
         let mut m = vec::from_slice(values);
         self.shuffle_mut(m);
-        return m;
+        move m
     }
 
     /// Shuffle a mutable vec in place
diff --git a/src/libcore/run.rs b/src/libcore/run.rs
@@ -260,7 +260,7 @@ fn read_all(rd: io::Reader) -> ~str {
         let bytes = rd.read_bytes(4096u);
         buf += str::from_bytes(bytes);
     }
-    return buf;
+    move buf
 }
 
 /**
@@ -306,11 +306,11 @@ fn program_output(prog: &str, args: &[~str]) ->
     let ch = comm::Chan(p);
     do task::spawn_sched(task::SingleThreaded) {
         let errput = readclose(pipe_err.in);
-        comm::send(ch, (2, errput));
+        comm::send(ch, (2, move errput));
     };
     do task::spawn_sched(task::SingleThreaded) {
         let output = readclose(pipe_out.in);
-        comm::send(ch, (1, output));
+        comm::send(ch, (1, move output));
     };
     let status = run::waitpid(pid);
     let mut errs = ~"";
@@ -332,7 +332,7 @@ fn program_output(prog: &str, args: &[~str]) ->
         };
         count -= 1;
     };
-    return {status: status, out: outs, err: errs};
+    return {status: status, out: move outs, err: move errs};
 }
 
 fn writeclose(fd: c_int, s: &str) {
@@ -354,7 +354,7 @@ fn readclose(fd: c_int) -> ~str {
         buf += str::from_bytes(bytes);
     }
     os::fclose(file);
-    return buf;
+    move buf
 }
 
 /// Waits for a process to exit and returns the exit code
diff --git a/src/libcore/unsafe.rs b/src/libcore/unsafe.rs
@@ -53,7 +53,7 @@ unsafe fn bump_box_refcount<T>(+t: @T) { forget(t); }
 unsafe fn transmute<L, G>(-thing: L) -> G {
     let newthing = reinterpret_cast(&thing);
     forget(thing);
-    return newthing;
+    move newthing
 }
 
 /// Coerce an immutable reference to be mutable.
@@ -113,9 +113,9 @@ struct ArcDestruct<T> {
                         unsafe::reinterpret_cast(&data.unwrapper);
                     let (message, response) = option::swap_unwrap(p);
                     // Send 'ready' and wait for a response.
-                    pipes::send_one(message, ());
+                    pipes::send_one(move message, ());
                     // Unkillable wait. Message guaranteed to come.
-                    if pipes::recv_one(response) {
+                    if pipes::recv_one(move response) {
                         // Other task got the data.
                         unsafe::forget(data);
                     } else {
@@ -147,13 +147,13 @@ unsafe fn unwrap_shared_mutable_state<T: Send>(+rc: SharedMutableState<T>)
             // In case we get killed early, we need to tell the person who
             // tried to wake us whether they should hand-off the data to us.
             if task::failing() {
-                pipes::send_one(response, false);
+                pipes::send_one(move response, false);
                 // Either this swap_unwrap or the one below (at "Got here")
                 // ought to run.
                 unsafe::forget(option::swap_unwrap(&mut self.ptr));
             } else {
                 assert self.ptr.is_none();
-                pipes::send_one(response, true);
+                pipes::send_one(move response, true);
             }
         }
     }
@@ -162,7 +162,7 @@ unsafe fn unwrap_shared_mutable_state<T: Send>(+rc: SharedMutableState<T>)
         let ptr: ~ArcData<T> = unsafe::reinterpret_cast(&rc.data);
         let (c1,p1) = pipes::oneshot(); // ()
         let (c2,p2) = pipes::oneshot(); // bool
-        let server: UnwrapProto = ~mut Some((c1,p2));
+        let server: UnwrapProto = ~mut Some((move c1,move p2));
         let serverp: libc::uintptr_t = unsafe::transmute(server);
         // Try to put our server end in the unwrapper slot.
         if rustrt::rust_compare_and_swap_ptr(&mut ptr.unwrapper, 0, serverp) {
@@ -180,8 +180,9 @@ unsafe fn unwrap_shared_mutable_state<T: Send>(+rc: SharedMutableState<T>)
             } else {
                 // The *next* person who sees the refcount hit 0 will wake us.
                 let end_result =
-                    DeathThroes { ptr: Some(ptr), response: Some(c2) };
-                let mut p1 = Some(p1); // argh
+                    DeathThroes { ptr: Some(move ptr),
+                                  response: Some(move c2) };
+                let mut p1 = Some(move p1); // argh
                 do task::rekillable {
                     pipes::recv_one(option::swap_unwrap(&mut p1));
                 }
@@ -210,7 +211,7 @@ unsafe fn unwrap_shared_mutable_state<T: Send>(+rc: SharedMutableState<T>)
 type SharedMutableState<T: Send> = ArcDestruct<T>;
 
 unsafe fn shared_mutable_state<T: Send>(+data: T) -> SharedMutableState<T> {
-    let data = ~ArcData { count: 1, unwrapper: 0, data: Some(data) };
+    let data = ~ArcData { count: 1, unwrapper: 0, data: Some(move data) };
     unsafe {
         let ptr = unsafe::transmute(data);
         ArcDestruct(ptr)
@@ -322,7 +323,7 @@ fn exclusive<T:Send >(+user_data: T) -> Exclusive<T> {
     let data = ExData {
         lock: LittleLock(), mut failed: false, mut data: user_data
     };
-    Exclusive { x: unsafe { shared_mutable_state(data) } }
+    Exclusive { x: unsafe { shared_mutable_state(move data) } }
 }
 
 impl<T: Send> Exclusive<T> {
@@ -347,17 +348,17 @@ impl<T: Send> Exclusive<T> {
             rec.failed = true;
             let result = f(&mut rec.data);
             rec.failed = false;
-            result
+            move result
         }
     }
 }
 
 // FIXME(#2585) make this a by-move method on the exclusive
 fn unwrap_exclusive<T: Send>(+arc: Exclusive<T>) -> T {
-    let Exclusive { x: x } = arc;
-    let inner = unsafe { unwrap_shared_mutable_state(x) };
-    let ExData { data: data, _ } = inner;
-    data
+    let Exclusive { x: x } <- arc;
+    let inner = unsafe { unwrap_shared_mutable_state(move x) };
+    let ExData { data: data, _ } <- inner;
+    move data
 }
 
 /****************************************************************************

Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ fn deflate_buf(buf: &[const u8]) -> ~[u8] {`
`31`	`31`	`let out = vec::unsafe::from_buf(res as *u8,`
`32`	`32`	`outsz as uint);`
`33`	`33`	`libc::free(res);`
`34`		`- out`
	`34`	`+ move out`
`35`	`35`	`}`
`36`	`36`	`}`
`37`	`37`	`}`
`@@ -49,7 +49,7 @@ fn inflate_buf(buf: &[const u8]) -> ~[u8] {`
`49`	`49`	`let out = vec::unsafe::from_buf(res as *u8,`
`50`	`50`	`outsz as uint);`
`51`	`51`	`libc::free(res);`
`52`		`- out`
	`52`	`+ move out`
`53`	`53`	`}`
`54`	`54`	`}`
`55`	`55`	`}`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ impl<T: Reader> T : ReaderUtil {`
`58`	`58`	`let count = self.read(buf, len);`
`59`	`59`
`60`	`60`	`unsafe { vec::unsafe::set_len(buf, count); }`
`61`		`- vec::from_mut(buf)`
	`61`	`+ vec::from_mut(move buf)`
`62`	`62`	`}`
`63`	`63`	`fn read_line() -> ~str {`
`64`	`64`	`let mut buf = ~[];`
`@@ -128,7 +128,7 @@ impl Reader {`
`128`	`128`	`buf = vec::slice(buf, offset, vec::len(buf));`
`129`	`129`	`}`
`130`	`130`	`}`
`131`		`- chars`
	`131`	`+ move chars`
`132`	`132`	`}`
`133`	`133`
`134`	`134`	`fn read_char() -> char {`
`@@ -180,7 +180,7 @@ impl Reader {`
`180`	`180`	`fn read_whole_stream() -> ~[u8] {`
`181`	`181`	`let mut buf: ~[u8] = ~[];`
`182`	`182`	`while !self.eof() { vec::push_all(buf, self.read_bytes(2048u)); }`
`183`		`- buf`
	`183`	`+ move buf`
`184`	`184`	`}`
`185`	`185`
`186`	`186`	`fn each_byte(it: fn(int) -> bool) {`
`@@ -688,7 +688,7 @@ impl MemBuffer: Writer {`
`688`	`688`
`689`	`689`	`self.pos += v_len;`
`690`	`690`
`691`		`- buf`
	`691`	`+ move buf`
`692`	`692`	`}`
`693`	`693`	`}`
`694`	`694`	`fn seek(offset: int, whence: SeekStyle) {`
Original file line number	Diff line number	Diff line change
`@@ -215,7 +215,7 @@ mod global_env {`
`215`	`215`	`assert vec::len(vs) == 2u;`
`216`	`216`	`vec::push(pairs, (copy vs[0], copy vs[1]));`
`217`	`217`	`}`
`218`		`- return pairs;`
	`218`	`+ move pairs`
`219`	`219`	`}`
`220`	`220`
`221`	`221`	`#[cfg(unix)]`
Original file line number	Diff line number	Diff line change
`@@ -99,7 +99,7 @@ impl PosixPath : GenericPath {`
`99`	`99`	`if s.len() == 0 {`
`100`	`100`	`~"."`
`101`	`101`	`} else {`
`102`		`- s`
	`102`	`+ move s`
`103`	`103`	`}`
`104`	`104`	`}`
`105`	`105`	`}`
`@@ -139,7 +139,7 @@ impl PosixPath : GenericPath {`
`139`	`139`	`let dpath = from_str::<PosixPath>(d);`
`140`	`140`	`match self.filename() {`
`141`	`141`	`Some(ref f) => dpath.push(*f),`
`142`		`- None => dpath`
	`142`	`+ None => move dpath`
`143`	`143`	`}`
`144`	`144`	`}`
`145`	`145`
`@@ -197,8 +197,7 @@ impl PosixPath : GenericPath {`
`197`	`197`	`}`
`198`	`198`
`199`	`199`	`pure fn push_many(cs: &[~str]) -> PosixPath {`
`200`		`- return PosixPath { components: self.components + cs,`
`201`		`- ..self }`
	`200`	`+ PosixPath { components: (copy self.components) + copy cs, ..self }`
`202`	`201`	`}`
`203`	`202`
`204`	`203`	`pure fn push(s: &str) -> PosixPath {`
`@@ -288,7 +287,7 @@ impl WindowsPath : GenericPath {`
`288`	`287`	`if s.len() == 0 {`
`289`	`288`	`~"."`
`290`	`289`	`} else {`
`291`		`- s`
	`290`	`+ move s`
`292`	`291`	`}`
`293`	`292`	`}`
`294`	`293`	`}`
`@@ -328,7 +327,7 @@ impl WindowsPath : GenericPath {`
`328`	`327`	`let dpath = from_str::<WindowsPath>(d);`
`329`	`328`	`match self.filename() {`
`330`	`329`	`Some(ref f) => dpath.push(*f),`
`331`		`- None => dpath`
	`330`	`+ None => move dpath`
`332`	`331`	`}`
`333`	`332`	`}`
`334`	`333`
`@@ -386,7 +385,7 @@ impl WindowsPath : GenericPath {`
`386`	`385`	`}`
`387`	`386`
`388`	`387`	`pure fn push_many(cs: &[~str]) -> WindowsPath {`
`389`		`- return WindowsPath { components: self.components + cs,`
	`388`	`+ return WindowsPath { components: (copy self.components) + (copy cs),`
`390`	`389`	`..self }`
`391`	`390`	`}`
`392`	`391`
`@@ -428,7 +427,7 @@ pure fn normalize(components: &[~str]) -> ~[~str] {`
`428`	`427`	`}`
`429`	`428`	`}`
`430`	`429`	`}`
`431`		`- cs`
	`430`	`+ move cs`
`432`	`431`	`}`
`433`	`432`
`434`	`433`	`mod posix {`
`@@ -525,7 +524,7 @@ mod windows {`
`525`	`524`	`if s[i] == '\\' as u8 {`
`526`	`525`	`let pre = s.slice(2, i);`
`527`	`526`	`let rest = s.slice(i, s.len());`
`528`		`- return Some((pre, rest));`
	`527`	`+ return Some((move pre, move rest));`
`529`	`528`	`}`
`530`	`529`	`i += 1;`
`531`	`530`	`}`
`@@ -543,7 +542,7 @@ mod windows {`
`543`	`542`	`} else {`
`544`	`543`	`s.slice(2, s.len())`
`545`	`544`	`};`
`546`		`- return Some((s.slice(0,1), rest));`
	`545`	`+ return Some((s.slice(0,1), move rest));`
`547`	`546`	`}`
`548`	`547`	`None`
`549`	`548`	`}`
Original file line number	Diff line number	Diff line change
`@@ -154,7 +154,7 @@ impl Rng {`
`154`	`154`	`s = s + str::from_char(self.gen_char_from(charset));`
`155`	`155`	`i += 1u;`
`156`	`156`	`}`
`157`		`- s`
	`157`	`+ move s`
`158`	`158`	`}`
`159`	`159`
`160`	`160`	`/// Return a random byte string of the specified length`
`@@ -220,14 +220,14 @@ impl Rng {`
`220`	`220`	`vec::push(r, item.item);`
`221`	`221`	`}`
`222`	`222`	`}`
`223`		`- r`
	`223`	`+ move r`
`224`	`224`	`}`
`225`	`225`
`226`	`226`	`/// Shuffle a vec`
`227`	`227`	`fn shuffle<T:Copy>(values: &[T]) -> ~[T] {`
`228`	`228`	`let mut m = vec::from_slice(values);`
`229`	`229`	`self.shuffle_mut(m);`
`230`		`- return m;`
	`230`	`+ move m`
`231`	`231`	`}`
`232`	`232`
`233`	`233`	`/// Shuffle a mutable vec in place`