librustc: Remove the broken overloaded assign-ops from the language.

They evaluated the receiver twice. They should be added back with
`AddAssign`, `SubAssign`, etc., traits.

Author: pcwalton

doc/tutorial.md

@@ -1281,9 +1281,9 @@ let your_crayons = ~[BananaMania, Beaver, Bittersweet];
 // Add two vectors to create a new one
 let our_crayons = my_crayons + your_crayons;
 
-// += will append to a vector, provided it lives in a mutable slot
+// .push_all() will append to a vector, provided it lives in a mutable slot
 let mut my_crayons = my_crayons;
-my_crayons += your_crayons;
+my_crayons.push_all(your_crayons);
 ~~~~
 
 > ***Note:*** The above examples of vector addition use owned

src/compiletest/errors.rs

@@ -21,7 +21,7 @@ pub fn load_errors(testfile: &Path) -> ~[ExpectedError] {
     let mut line_num = 1u;
     while !rdr.eof() {
         let ln = rdr.read_line();
-        error_patterns += parse_expected(line_num, ln);
+        error_patterns.push_all_move(parse_expected(line_num, ln));
         line_num += 1u;
     }
     return error_patterns;

src/compiletest/runtest.rs

@@ -226,8 +226,8 @@ actual:\n\
                          ~"-L", config.build_base.to_str(),
                          ~"-L",
                          aux_output_dir_name(config, testfile).to_str()];
-        args += split_maybe_args(&config.rustcflags);
-        args += split_maybe_args(&props.compile_flags);
+        args.push_all_move(split_maybe_args(&config.rustcflags));
+        args.push_all_move(split_maybe_args(&props.compile_flags));
         return ProcArgs {prog: config.rustc_path.to_str(), args: args};
     }
 }
@@ -581,8 +581,8 @@ fn make_compile_args(config: &config, props: &TestProps, extras: ~[~str],
                      ~"-o", xform(config, testfile).to_str(),
                      ~"-L", config.build_base.to_str()]
         + extras;
-    args += split_maybe_args(&config.rustcflags);
-    args += split_maybe_args(&props.compile_flags);
+    args.push_all_move(split_maybe_args(&config.rustcflags));
+    args.push_all_move(split_maybe_args(&props.compile_flags));
     return ProcArgs {prog: config.rustc_path.to_str(), args: args};
 }
 

src/libextra/arena.rs

@@ -186,20 +186,18 @@ impl Arena {
     #[inline]
     fn alloc_pod_inner(&mut self, n_bytes: uint, align: uint) -> *u8 {
         unsafe {
-            // XXX: Borrow check
-            let head = transmute_mut_region(&mut self.pod_head);
-
-            let start = round_up_to(head.fill, align);
+            let this = transmute_mut_region(self);
+            let start = round_up_to(this.pod_head.fill, align);
             let end = start + n_bytes;
-            if end > at_vec::capacity(head.data) {
-                return self.alloc_pod_grow(n_bytes, align);
+            if end > at_vec::capacity(this.pod_head.data) {
+                return this.alloc_pod_grow(n_bytes, align);
             }
-            head.fill = end;
+            this.pod_head.fill = end;
 
             //debug!("idx = %u, size = %u, align = %u, fill = %u",
             //       start, n_bytes, align, head.fill);
 
-            ptr::offset(vec::raw::to_ptr(head.data), start)
+            ptr::offset(vec::raw::to_ptr(this.pod_head.data), start)
         }
     }
 
@@ -237,15 +235,15 @@ impl Arena {
             let after_tydesc = head.fill + sys::size_of::<*TyDesc>();
             let start = round_up_to(after_tydesc, align);
             let end = start + n_bytes;
-            if end > at_vec::capacity(head.data) {
+            if end > at_vec::capacity(self.head.data) {
                 return self.alloc_nonpod_grow(n_bytes, align);
             }
             head.fill = round_up_to(end, sys::pref_align_of::<*TyDesc>());
 
             //debug!("idx = %u, size = %u, align = %u, fill = %u",
             //       start, n_bytes, align, head.fill);
 
-            let buf = vec::raw::to_ptr(head.data);
+            let buf = vec::raw::to_ptr(self.head.data);
             return (ptr::offset(buf, tydesc_start), ptr::offset(buf, start));
         }
     }

src/libextra/bitv.rs

@@ -476,9 +476,15 @@ impl Bitv {
      * character is either '0' or '1'.
      */
      pub fn to_str(&self) -> ~str {
-       let mut rs = ~"";
-       for self.each() |i| { if i { rs += "1"; } else { rs += "0"; } };
-       rs
+        let mut rs = ~"";
+        for self.each() |i| {
+            if i {
+                rs.push_char('1');
+            } else {
+                rs.push_char('0');
+            }
+        };
+        rs
      }
 
 

src/libextra/getopts.rs

@@ -606,33 +606,47 @@ pub mod groups {
             let mut row = " ".repeat(4);
 
             // short option
-            row += match short_name.len() {
-                0 => ~"",
-                1 => ~"-" + short_name + " ",
+            match short_name.len() {
+                0 => {}
+                1 => {
+                    row.push_char('-');
+                    row.push_str(short_name);
+                    row.push_char(' ');
+                }
                 _ => fail!("the short name should only be 1 ascii char long"),
-            };
+            }
 
             // long option
-            row += match long_name.len() {
-                0 => ~"",
-                _ => ~"--" + long_name + " ",
-            };
+            match long_name.len() {
+                0 => {}
+                _ => {
+                    row.push_str("--");
+                    row.push_str(long_name);
+                    row.push_char(' ');
+                }
+            }
 
             // arg
-            row += match hasarg {
-                No    => ~"",
-                Yes   => hint,
-                Maybe => ~"[" + hint + "]",
-            };
+            match hasarg {
+                No => {}
+                Yes => row.push_str(hint),
+                Maybe => {
+                    row.push_char('[');
+                    row.push_str(hint);
+                    row.push_char(']');
+                }
+            }
 
             // FIXME: #5516
             // here we just need to indent the start of the description
             let rowlen = row.len();
-            row += if rowlen < 24 {
-                " ".repeat(24 - rowlen)
+            if rowlen < 24 {
+                for (24 - rowlen).times {
+                    row.push_char(' ')
+                }
             } else {
-                copy desc_sep
-            };
+                row.push_str(desc_sep)
+            }
 
             // Normalize desc to contain words separated by one space character
             let mut desc_normalized_whitespace = ~"";
@@ -649,7 +663,7 @@ pub mod groups {
 
             // FIXME: #5516
             // wrapped description
-            row += desc_rows.connect(desc_sep);
+            row.push_str(desc_rows.connect(desc_sep));
 
             row
         });

src/libextra/json.rs

@@ -60,25 +60,27 @@ fn escape_str(s: &str) -> ~str {
     let mut escaped = ~"\"";
     for s.iter().advance |c| {
         match c {
-          '"' => escaped += "\\\"",
-          '\\' => escaped += "\\\\",
-          '\x08' => escaped += "\\b",
-          '\x0c' => escaped += "\\f",
-          '\n' => escaped += "\\n",
-          '\r' => escaped += "\\r",
-          '\t' => escaped += "\\t",
-          _ => escaped += str::from_char(c)
+          '"' => escaped.push_str("\\\""),
+          '\\' => escaped.push_str("\\\\"),
+          '\x08' => escaped.push_str("\\b"),
+          '\x0c' => escaped.push_str("\\f"),
+          '\n' => escaped.push_str("\\n"),
+          '\r' => escaped.push_str("\\r"),
+          '\t' => escaped.push_str("\\t"),
+          _ => escaped.push_char(c),
         }
     };
 
-    escaped += "\"";
+    escaped.push_char('"');
 
     escaped
 }
 
 fn spaces(n: uint) -> ~str {
     let mut ss = ~"";
-    for n.times { ss.push_str(" "); }
+    for n.times {
+        ss.push_str(" ");
+    }
     return ss;
 }
 

src/libextra/md4.rs

@@ -119,8 +119,10 @@ pub fn md4_str(msg: &[u8]) -> ~str {
         let mut i = 0u32;
         while i < 4u32 {
             let byte = (u >> (i * 8u32)) as u8;
-            if byte <= 16u8 { result += "0"; }
-            result += uint::to_str_radix(byte as uint, 16u);
+            if byte <= 16u8 {
+                result.push_char('0')
+            }
+            result.push_str(uint::to_str_radix(byte as uint, 16u));
             i += 1u32;
         }
     }

src/libextra/net_url.rs

@@ -93,10 +93,10 @@ fn encode_inner(s: &str, full_url: bool) -> ~str {
                         out.push_char(ch);
                       }
 
-                      _ => out += fmt!("%%%X", ch as uint)
+                      _ => out.push_str(fmt!("%%%X", ch as uint))
                     }
                 } else {
-                    out += fmt!("%%%X", ch as uint);
+                    out.push_str(fmt!("%%%X", ch as uint));
                 }
               }
             }
@@ -192,7 +192,7 @@ fn encode_plus(s: &str) -> ~str {
                 out.push_char(ch);
               }
               ' ' => out.push_char('+'),
-              _ => out += fmt!("%%%X", ch as uint)
+              _ => out.push_str(fmt!("%%%X", ch as uint))
             }
         }
 
@@ -218,7 +218,7 @@ pub fn encode_form_urlencoded(m: &HashMap<~str, ~[~str]>) -> ~str {
                 first = false;
             }
 
-            out += fmt!("%s=%s", key, encode_plus(*value));
+            out.push_str(fmt!("%s=%s", key, encode_plus(*value)));
         }
     }
 

src/libextra/num/bigint.rs

@@ -510,11 +510,11 @@ impl ToStrRadix for BigUint {
             let mut m      = n;
             while m > divider {
                 let (d, m0) = m.div_mod_floor(&divider);
-                result += [m0.to_uint() as BigDigit];
+                result.push(m0.to_uint() as BigDigit);
                 m = d;
             }
             if !m.is_zero() {
-                result += [m.to_uint() as BigDigit];
+                result.push(m.to_uint() as BigDigit);
             }
             return result;
         }