---

yaml
---
r: 59015
b: refs/heads/incoming
c: 07cd5a8
h: refs/heads/master
i:
  59013: 8e5f815
  59011: 5c06288
  59007: e37c663
v: v3

Author: catamorphism

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c50a9d5b664478e533ba1d1d353213d70c8ad589
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/incoming: ce9c0225c451c00c3eebe4e496185143a18814b9
+refs/heads/incoming: 07cd5a850c0a7990ae78f160e27dc5561580e18f
 refs/heads/dist-snap: 00dbbd01c2aee72982b3e0f9511ae1d4428c3ba9
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/src/libcore/core.rc

@@ -60,6 +60,7 @@ they contained the following prologue:
 // Don't link to core. We are core.
 #[no_core];
 
+#[warn(vecs_implicitly_copyable)];
 #[deny(non_camel_case_types)];
 #[allow(deprecated_mutable_fields)];
 

branches/incoming/src/libstd/arc.rs

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

branches/incoming/src/libstd/future.rs

@@ -238,8 +238,8 @@ mod test {
 
     #[test]
     fn test_sendable_future() {
-        let expected = "schlorf";
-        let f = Cell(do spawn { expected });
+        let expected = ~"schlorf";
+        let f = Cell(do spawn { copy expected });
         do task::spawn {
             let mut f = f.take();
             let actual = f.get();

branches/incoming/src/libstd/getopts.rs

@@ -229,13 +229,13 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result {
     let l = args.len();
     let mut i = 0;
     while i < l {
-        let cur = copy args[i];
+        let cur = args[i];
         let curlen = cur.len();
         if !is_arg(cur) {
             free.push(cur);
         } else if cur == ~"--" {
             let mut j = i + 1;
-            while j < l { free.push(copy args[j]); j += 1; }
+            while j < l { free.push(args[j]); j += 1; }
             break;
         } else {
             let mut names;
@@ -248,8 +248,8 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result {
                     names = ~[Long(tail)];
                 } else {
                     names =
-                        ~[Long(copy tail_eq[0])];
-                    i_arg = Some(copy tail_eq[1]);
+                        ~[Long(tail_eq[0])];
+                    i_arg = Some(tail_eq[1]);
                 }
             } else {
                 let mut j = 1;
@@ -266,7 +266,7 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result {
                        interpreted correctly
                     */
 
-                    match find_opt(opts, copy opt) {
+                    match find_opt(opts, opt) {
                       Some(id) => last_valid_opt_id = Some(id),
                       None => {
                         let arg_follows =
@@ -292,7 +292,7 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result {
             let mut name_pos = 0;
             for names.each() |nm| {
                 name_pos += 1;
-                let optid = match find_opt(opts, copy *nm) {
+                let optid = match find_opt(opts, *nm) {
                   Some(id) => id,
                   None => return Err(UnrecognizedOption(name_str(nm)))
                 };
@@ -305,18 +305,18 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result {
                   }
                   Maybe => {
                     if !i_arg.is_none() {
-                        vals[optid].push(Val((copy i_arg).get()));
+                        vals[optid].push(Val(i_arg.get()));
                     } else if name_pos < names.len() ||
                                   i + 1 == l || is_arg(args[i + 1]) {
                         vals[optid].push(Given);
-                    } else { i += 1; vals[optid].push(Val(copy args[i])); }
+                    } else { i += 1; vals[optid].push(Val(args[i])); }
                   }
                   Yes => {
                     if !i_arg.is_none() {
-                        vals[optid].push(Val((copy i_arg).get()));
+                        vals[optid].push(Val(i_arg.get()));
                     } else if i + 1 == l {
                         return Err(ArgumentMissing(name_str(nm)));
-                    } else { i += 1; vals[optid].push(Val(copy args[i])); }
+                    } else { i += 1; vals[optid].push(Val(args[i])); }
                   }
                 }
             }
@@ -346,15 +346,15 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result {
 
 fn opt_vals(mm: &Matches, nm: &str) -> ~[Optval] {
     return match find_opt(mm.opts, mkname(nm)) {
-      Some(id) => copy mm.vals[id],
+      Some(id) => mm.vals[id],
       None => {
         error!("No option '%s' defined", nm);
         fail!()
       }
     };
 }
 
-fn opt_val(mm: &Matches, nm: &str) -> Optval { copy opt_vals(mm, nm)[0] }
+fn opt_val(mm: &Matches, nm: &str) -> Optval { return opt_vals(mm, nm)[0]; }
 
 /// Returns true if an option was matched
 pub fn opt_present(mm: &Matches, nm: &str) -> bool {
@@ -547,29 +547,25 @@ pub mod groups {
     // translate OptGroup into Opt
     // (both short and long names correspond to different Opts)
     pub fn long_to_short(lopt: &OptGroup) -> ~[Opt] {
-        let OptGroup{short_name: short_name,
-                     long_name: long_name,
-                     hasarg: hasarg,
-                     occur: occur,
-                     _} = copy *lopt;
+        match ((*lopt).short_name.len(),
+               (*lopt).long_name.len()) {
 
-        match (short_name.len(), long_name.len()) {
            (0,0) => fail!(~"this long-format option was given no name"),
 
-           (0,_) => ~[Opt {name: Long((long_name)),
-                           hasarg: hasarg,
-                           occur: occur}],
+           (0,_) => ~[Opt {name:   Long(((*lopt).long_name)),
+                           hasarg: (*lopt).hasarg,
+                           occur:  (*lopt).occur}],
 
-           (1,0) => ~[Opt {name: Short(str::char_at(short_name, 0)),
-                           hasarg: hasarg,
-                           occur: occur}],
+           (1,0) => ~[Opt {name: Short(str::char_at((*lopt).short_name, 0)),
+                           hasarg: (*lopt).hasarg,
+                           occur:  (*lopt).occur}],
 
-           (1,_) => ~[Opt {name: Short(str::char_at(short_name, 0)),
-                           hasarg: hasarg,
-                           occur:  occur},
-                      Opt {name:   Long((long_name)),
-                           hasarg: hasarg,
-                           occur:  occur}],
+           (1,_) => ~[Opt {name: Short(str::char_at((*lopt).short_name, 0)),
+                           hasarg: (*lopt).hasarg,
+                           occur:  (*lopt).occur},
+                      Opt {name:   Long(((*lopt).long_name)),
+                           hasarg: (*lopt).hasarg,
+                           occur:  (*lopt).occur}],
 
            (_,_) => fail!(~"something is wrong with the long-form opt")
         }
@@ -590,12 +586,11 @@ pub mod groups {
         let desc_sep = ~"\n" + str::repeat(~" ", 24);
 
         let rows = vec::map(opts, |optref| {
-            let OptGroup{short_name: short_name,
-                         long_name: long_name,
-                         hint: hint,
-                         desc: desc,
-                         hasarg: hasarg,
-                         _} = copy *optref;
+            let short_name = (*optref).short_name;
+            let long_name = (*optref).long_name;
+            let hint = (*optref).hint;
+            let desc = (*optref).desc;
+            let hasarg = (*optref).hasarg;
 
             let mut row = str::repeat(~" ", 4);
 
@@ -625,7 +620,7 @@ pub mod groups {
             row += if rowlen < 24 {
                 str::repeat(~" ", 24 - rowlen)
             } else {
-                copy desc_sep
+                desc_sep
             };
 
             // Normalize desc to contain words separated by one space character
@@ -897,7 +892,7 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Err(copy f) => {
-            error!(fail_str(copy f));
+            error!(fail_str(f));
             check_fail_type(f, UnexpectedArgument_);
           }
           _ => fail!()

branches/incoming/src/libstd/net_ip.rs

@@ -175,7 +175,7 @@ pub mod v4 {
     pub fn parse_addr(ip: &str) -> IpAddr {
         match try_parse_addr(ip) {
           result::Ok(addr) => addr,
-          result::Err(ref err_data) => fail!(copy err_data.err_msg)
+          result::Err(ref err_data) => fail!(err_data.err_msg)
         }
     }
     // the simple, old style numberic representation of
@@ -272,7 +272,7 @@ pub mod v6 {
     pub fn parse_addr(ip: &str) -> IpAddr {
         match try_parse_addr(ip) {
           result::Ok(addr) => addr,
-          result::Err(copy err_data) => fail!(copy err_data.err_msg)
+          result::Err(copy err_data) => fail!(err_data.err_msg)
         }
     }
     pub fn try_parse_addr(ip: &str) -> result::Result<IpAddr,ParseAddrErr> {