librustc: Remove all uses of "copy".

Author: pcwalton

src/compiletest/compiletest.rs

@@ -117,9 +117,11 @@ pub fn parse_config(args: ~[~str]) -> config {
         mode: str_mode(getopts::opt_str(matches, "mode")),
         run_ignored: getopts::opt_present(matches, "ignored"),
         filter:
-             if !matches.free.is_empty() {
-                 Some(copy matches.free[0])
-             } else { None },
+            if !matches.free.is_empty() {
+                 Some(matches.free[0].clone())
+            } else {
+                None
+            },
         logfile: getopts::opt_maybe_str(matches, "logfile").map(|s| Path(*s)),
         save_metrics: getopts::opt_maybe_str(matches, "save-metrics").map(|s| Path(*s)),
         ratchet_metrics:
@@ -223,9 +225,9 @@ pub fn run_tests(config: &config) {
 
 pub fn test_opts(config: &config) -> test::TestOpts {
     test::TestOpts {
-        filter: copy config.filter,
+        filter: config.filter.clone(),
         run_ignored: config.run_ignored,
-        logfile: copy config.logfile,
+        logfile: config.logfile.clone(),
         run_tests: true,
         run_benchmarks: true,
         ratchet_metrics: copy config.ratchet_metrics,
@@ -240,7 +242,7 @@ pub fn make_tests(config: &config) -> ~[test::TestDescAndFn] {
     let mut tests = ~[];
     let dirs = os::list_dir_path(&config.src_base);
     for dirs.iter().advance |file| {
-        let file = copy *file;
+        let file = (*file).clone();
         debug!("inspecting file %s", file.to_str());
         if is_test(config, file) {
             let t = do make_test(config, file) {
@@ -306,7 +308,7 @@ pub fn make_test_name(config: &config, testfile: &Path) -> test::TestName {
 
 pub fn make_test_closure(config: &config, testfile: &Path) -> test::TestFn {
     use std::cell::Cell;
-    let config = Cell::new(copy *config);
+    let config = Cell::new((*config).clone());
     let testfile = Cell::new(testfile.to_str());
     test::DynTestFn(|| { runtest::run(config.take(), testfile.take()) })
 }

src/compiletest/procsrv.rs

@@ -22,7 +22,7 @@ fn target_env(lib_path: &str, prog: &str) -> ~[(~str,~str)] {
     let aux_path = prog.slice(0u, prog.len() - 4u).to_owned() + ".libaux";
 
     env = do env.map() |pair| {
-        let (k,v) = copy *pair;
+        let (k,v) = (*pair).clone();
         if k == ~"PATH" { (~"PATH", v + ";" + lib_path + ";" + aux_path) }
         else { (k,v) }
     };

src/compiletest/runtest.rs

@@ -150,7 +150,7 @@ fn run_pretty_test(config: &config, props: &TestProps, testfile: &Path) {
     let mut round = 0;
     while round < rounds {
         logv(config, fmt!("pretty-printing round %d", round));
-        let ProcRes = print_source(config, testfile, copy srcs[round]);
+        let ProcRes = print_source(config, testfile, srcs[round].clone());
 
         if ProcRes.status != 0 {
             fatal_ProcRes(fmt!("pretty-printing failed in round %d", round),
@@ -168,9 +168,9 @@ fn run_pretty_test(config: &config, props: &TestProps, testfile: &Path) {
             let filepath = testfile.dir_path().push_rel(file);
             io::read_whole_file_str(&filepath).get()
           }
-          None => { copy srcs[srcs.len() - 2u] }
+          None => { srcs[srcs.len() - 2u].clone() }
         };
-    let mut actual = copy srcs[srcs.len() - 1u];
+    let mut actual = srcs[srcs.len() - 1u].clone();
 
     if props.pp_exact.is_some() {
         // Now we have to care about line endings
@@ -243,13 +243,13 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
     let mut config = match config.rustcflags {
         Some(ref flags) => config {
             rustcflags: Some(flags.replace("-O", "")),
-            .. copy *config
+            .. (*config).clone()
         },
-        None => copy *config
+        None => (*config).clone()
     };
     let config = &mut config;
     let cmds = props.debugger_cmds.connect("\n");
-    let check_lines = copy props.check_lines;
+    let check_lines = props.check_lines.clone();
 
     // compile test file (it shoud have 'compile-flags:-g' in the header)
     let mut ProcRes = compile_test(config, props, testfile);
@@ -498,7 +498,7 @@ fn exec_compiled_test(config: &config, props: &TestProps,
                       testfile: &Path) -> ProcRes {
 
     // If testing the new runtime then set the RUST_NEWRT env var
-    let env = copy props.exec_env;
+    let env = props.exec_env.clone();
     let env = if config.newrt { env + &[(~"RUST_NEWRT", ~"1")] } else { env };
 
     match config.target {
@@ -742,7 +742,7 @@ fn _arm_exec_compiled_test(config: &config, props: &TestProps,
 
     // copy to target
     let copy_result = procsrv::run("", config.adb_path,
-        [~"push", copy args.prog, copy config.adb_test_dir],
+        [~"push", args.prog.clone(), config.adb_test_dir.clone()],
         ~[(~"",~"")], Some(~""));
 
     if config.verbose {
@@ -832,7 +832,7 @@ fn _arm_push_aux_shared_library(config: &config, testfile: &Path) {
         if (file.filetype() == Some(~".so")) {
 
             let copy_result = procsrv::run("", config.adb_path,
-                [~"push", file.to_str(), copy config.adb_test_dir],
+                [~"push", file.to_str(), config.adb_test_dir.clone()],
                 ~[(~"",~"")], Some(~""));
 
             if config.verbose {

src/libextra/arc.rs

@@ -534,7 +534,7 @@ mod tests {
 
             let arc_v : ARC<~[int]> = p.recv();
 
-            let v = copy (*arc_v.get());
+            let v = (*arc_v.get()).clone();
             assert_eq!(v[3], 4);
         };
 

src/libextra/base64.rs

@@ -211,14 +211,14 @@ impl<'self> FromBase64 for &'self [u8] {
             let val = byte as u32;
 
             match ch {
-                'A'..'Z'  => buf |= val - 0x41,
-                'a'..'z'  => buf |= val - 0x47,
-                '0'..'9'  => buf |= val + 0x04,
-                '+'|'-'   => buf |= 0x3E,
-                '/'|'_'   => buf |= 0x3F,
+                'A'..'Z' => buf |= val - 0x41,
+                'a'..'z' => buf |= val - 0x47,
+                '0'..'9' => buf |= val + 0x04,
+                '+'|'-' => buf |= 0x3E,
+                '/'|'_' => buf |= 0x3F,
                 '\r'|'\n' => loop,
-                '='       => break,
-                _         => return Err(~"Invalid Base64 character")
+                '=' => break,
+                _ => return Err(~"Invalid Base64 character")
             }
 
             buf <<= 6;

src/libextra/bitv.rs

@@ -266,7 +266,7 @@ impl Bitv {
         else {
             let nelems = nbits/uint::bits +
                          if nbits % uint::bits == 0 {0} else {1};
-            let elem = if init {!0} else {0};
+            let elem = if init {!0u} else {0u};
             let s = vec::from_elem(nelems, elem);
             Big(~BigBitv::new(s))
         };
@@ -518,7 +518,7 @@ impl Clone for Bitv {
             Bitv{nbits: self.nbits, rep: Small(~SmallBitv{bits: b.bits})}
           }
           Big(ref b) => {
-            let mut st = vec::from_elem(self.nbits / uint::bits + 1, 0);
+            let mut st = vec::from_elem(self.nbits / uint::bits + 1, 0u);
             let len = st.len();
             for uint::range(0, len) |i| { st[i] = b.storage[i]; };
             Bitv{nbits: self.nbits, rep: Big(~BigBitv{storage: st})}

src/libextra/c_vec.rs

@@ -119,17 +119,19 @@ pub unsafe fn c_vec_with_dtor<T>(base: *mut T, len: uint, dtor: @fn())
  *
  * Fails if `ofs` is greater or equal to the length of the vector
  */
-pub fn get<T:Copy>(t: CVec<T>, ofs: uint) -> T {
+pub fn get<T:Clone>(t: CVec<T>, ofs: uint) -> T {
     assert!(ofs < len(t));
-    return unsafe { copy *ptr::mut_offset(t.base, ofs) };
+    return unsafe {
+        (*ptr::mut_offset(t.base, ofs)).clone()
+    };
 }
 
 /**
  * Sets the value of an element at a given index
  *
  * Fails if `ofs` is greater or equal to the length of the vector
  */
-pub fn set<T:Copy>(t: CVec<T>, ofs: uint, v: T) {
+pub fn set<T>(t: CVec<T>, ofs: uint, v: T) {
     assert!(ofs < len(t));
     unsafe { *ptr::mut_offset(t.base, ofs) = v };
 }

src/libextra/dlist.rs

@@ -609,8 +609,8 @@ mod tests {
     }
 
     #[cfg(test)]
-    fn list_from<T: Copy>(v: &[T]) -> DList<T> {
-        v.iter().transform(|x| copy *x).collect()
+    fn list_from<T: Clone>(v: &[T]) -> DList<T> {
+        v.iter().transform(|x| (*x).clone()).collect()
     }
 
     #[test]

src/libextra/ebml.rs

@@ -29,6 +29,7 @@ struct EbmlState {
     data_pos: uint,
 }
 
+#[deriving(Clone)]
 pub struct Doc {
     data: @~[u8],
     start: uint,
@@ -615,6 +616,7 @@ pub mod writer {
     use super::*;
 
     use std::cast;
+    use std::clone::Clone;
     use std::io;
 
     // ebml writing
@@ -623,6 +625,15 @@ pub mod writer {
         priv size_positions: ~[uint],
     }
 
+    impl Clone for Encoder {
+        fn clone(&self) -> Encoder {
+            Encoder {
+                writer: self.writer,
+                size_positions: self.size_positions.clone(),
+            }
+        }
+    }
+
     fn write_sized_vuint(w: @io::Writer, n: uint, size: uint) {
         match size {
             1u => w.write(&[0x80u8 | (n as u8)]),

src/libextra/fileinput.rs

@@ -107,6 +107,7 @@ and `line_num_file` represent the number of lines read in total and in
 the current file respectively. `current_path` is `None` if the current
 file is `stdin`.
 */
+#[deriving(Clone)]
 pub struct FileInputState {
     current_path: Option<Path>,
     line_num: uint,
@@ -223,7 +224,7 @@ impl FileInput {
         let path_option = self.fi.files.shift();
         let file = match path_option {
             None => io::stdin(),
-            Some(ref path) => io::file_reader(path).get()
+            Some(ref path) => io::file_reader(path).unwrap()
         };
 
         self.fi.current_reader = Some(file);
@@ -259,15 +260,15 @@ impl FileInput {
     */
     pub fn each_line_state(&self,
                             f: &fn(&str, FileInputState) -> bool) -> bool {
-         self.each_line(|line| f(line, copy self.fi.state))
+         self.each_line(|line| f(line, self.fi.state.clone()))
     }
 
 
     /**
     Retrieve the current `FileInputState` information.
     */
     pub fn state(&self) -> FileInputState {
-        copy self.fi.state
+        self.fi.state.clone()
     }
 }
 
@@ -431,7 +432,7 @@ mod test {
         let paths = ~[Some(Path("some/path")),
                       Some(Path("some/other/path"))];
 
-        assert_eq!(pathify(strs, true), copy paths);
+        assert_eq!(pathify(strs, true), paths.clone());
         assert_eq!(pathify(strs, false), paths);
 
         assert_eq!(pathify([~"-"], true), ~[None]);
@@ -449,7 +450,7 @@ mod test {
             make_file(filename.get_ref(), [fmt!("%u", i)]);
         }
 
-        let fi = FileInput::from_vec(copy filenames);
+        let fi = FileInput::from_vec(filenames.clone());
 
         for "012".iter().enumerate().advance |(line, c)| {
             assert_eq!(fi.read_byte(), c as int);
@@ -459,7 +460,7 @@ mod test {
             assert_eq!(fi.state().line_num, line + 1);
             assert_eq!(fi.state().line_num_file, 1);
 
-            assert_eq!(copy fi.state().current_path, copy filenames[line]);
+            assert_eq!(fi.state().current_path.clone(), filenames[line].clone());
         }
 
         assert_eq!(fi.read_byte(), -1);
@@ -542,13 +543,13 @@ mod test {
         make_file(filenames[2].get_ref(), [~"3", ~"4"]);
 
         let mut count = 0;
-        for input_vec_state(copy filenames) |line, state| {
+        for input_vec_state(filenames.clone()) |line, state| {
             let expected_path = match line {
-                "1" | "2" => copy filenames[0],
-                "3" | "4" => copy filenames[2],
+                "1" | "2" => filenames[0].clone(),
+                "3" | "4" => filenames[2].clone(),
                 _ => fail!("unexpected line")
             };
-            assert_eq!(copy state.current_path, expected_path);
+            assert_eq!(state.current_path.clone(), expected_path);
             count += 1;
         }
         assert_eq!(count, 4);