---

yaml
---
r: 63231
b: refs/heads/snap-stage3
c: 8761b1f
h: refs/heads/master
i:
  63229: 7366337
  63227: cae47dd
  63223: 5122bee
  63215: 9eb6b9d
  63199: 583695a
  63167: d53b7b8
  63103: cd6fe44
  62975: fa69e26
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: eecbe5556b96aa5546ede9454483a53b25d3380a
+refs/heads/snap-stage3: 8761b1fb16c8d1e7e57a95efdb2cdcf36565477a
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/doc/tutorial.md

@@ -1410,7 +1410,7 @@ let new_favorite_crayon_name = favorite_crayon_name.trim();
 
 if favorite_crayon_name.len() > 5 {
    // Create a substring
-   println(favorite_crayon_name.slice_chars(0, 5));
+   println(favorite_crayon_name.substr(0, 5));
 }
 ~~~
 

branches/snap-stage3/src/compiletest/runtest.rs

@@ -171,8 +171,8 @@ fn run_pretty_test(config: &config, props: &TestProps, testfile: &Path) {
     if props.pp_exact.is_some() {
         // Now we have to care about line endings
         let cr = ~"\r";
-        actual = actual.replace(cr, "");
-        expected = expected.replace(cr, "");
+        actual = str::replace(actual, cr, "");
+        expected = str::replace(expected, cr, "");
     }
 
     compare_source(expected, actual);
@@ -238,7 +238,7 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
     // do not optimize debuginfo tests
     let mut config = match config.rustcflags {
         Some(ref flags) => config {
-            rustcflags: Some(flags.replace("-O", "")),
+            rustcflags: Some(str::replace(*flags, "-O", "")),
             .. copy *config
         },
         None => copy *config
@@ -254,7 +254,7 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
     }
 
     // write debugger script
-    let script_str = cmds.append("\nquit\n");
+    let script_str = str::append(cmds, "\nquit\n");
     debug!("script_str = %s", script_str);
     dump_output_file(config, testfile, script_str, "debugger.script");
 

branches/snap-stage3/src/libextra/base64.rs

@@ -12,6 +12,7 @@
 
 use core::prelude::*;
 
+use core::str;
 use core::vec;
 
 /// A trait for converting a value to base64 encoding.
@@ -110,7 +111,7 @@ impl<'self> ToBase64 for &'self str {
      *
      */
     fn to_base64(&self) -> ~str {
-        self.as_bytes().to_base64()
+        str::to_bytes(*self).to_base64()
     }
 }
 
@@ -223,7 +224,7 @@ impl<'self> FromBase64 for &'self str {
      * ~~~
      */
     fn from_base64(&self) -> ~[u8] {
-        self.as_bytes().from_base64()
+        str::to_bytes(*self).from_base64()
     }
 }
 
@@ -244,12 +245,12 @@ mod tests {
 
     #[test]
     fn test_from_base64() {
-        assert_eq!("".from_base64(), "".as_bytes().to_owned());
-        assert_eq!("Zg==".from_base64(), "f".as_bytes().to_owned());
-        assert_eq!("Zm8=".from_base64(), "fo".as_bytes().to_owned());
-        assert_eq!("Zm9v".from_base64(), "foo".as_bytes().to_owned());
-        assert_eq!("Zm9vYg==".from_base64(), "foob".as_bytes().to_owned());
-        assert_eq!("Zm9vYmE=".from_base64(), "fooba".as_bytes().to_owned());
-        assert_eq!("Zm9vYmFy".from_base64(), "foobar".as_bytes().to_owned());
+        assert_eq!("".from_base64(), str::to_bytes(""));
+        assert_eq!("Zg==".from_base64(), str::to_bytes("f"));
+        assert_eq!("Zm8=".from_base64(), str::to_bytes("fo"));
+        assert_eq!("Zm9v".from_base64(), str::to_bytes("foo"));
+        assert_eq!("Zm9vYg==".from_base64(), str::to_bytes("foob"));
+        assert_eq!("Zm9vYmE=".from_base64(), str::to_bytes("fooba"))
+        assert_eq!("Zm9vYmFy".from_base64(), str::to_bytes("foobar"));
     }
 }

branches/snap-stage3/src/libextra/ebml.rs

@@ -607,6 +607,7 @@ pub mod writer {
 
     use core::cast;
     use core::io;
+    use core::str;
 
     // ebml writing
     pub struct Encoder {
@@ -724,7 +725,7 @@ pub mod writer {
         }
 
         pub fn wr_tagged_str(&mut self, tag_id: uint, v: &str) {
-            self.wr_tagged_bytes(tag_id, v.as_bytes());
+            str::byte_slice(v, |b| self.wr_tagged_bytes(tag_id, b));
         }
 
         pub fn wr_bytes(&mut self, b: &[u8]) {
@@ -734,7 +735,7 @@ pub mod writer {
 
         pub fn wr_str(&mut self, s: &str) {
             debug!("Write str: %?", s);
-            self.writer.write(s.as_bytes());
+            self.writer.write(str::to_bytes(s));
         }
     }
 

branches/snap-stage3/src/libextra/fileinput.rs

@@ -487,7 +487,7 @@ mod test {
         let mut buf : ~[u8] = vec::from_elem(6, 0u8);
         let count = fi.read(buf, 10);
         assert_eq!(count, 6);
-        assert_eq!(buf, "0\n1\n2\n".as_bytes().to_owned());
+        assert_eq!(buf, "0\n1\n2\n".to_bytes());
         assert!(fi.eof())
         assert_eq!(fi.state().line_num, 3);
     }

branches/snap-stage3/src/libextra/flatpipes.rs

@@ -450,7 +450,7 @@ pub mod flatteners {
                               T: Decodable<D>>(
                               buf: &[u8])
                               -> T {
-        let buf = buf.to_owned();
+        let buf = vec::to_owned(buf);
         let buf_reader = @BufReader::new(buf);
         let reader = buf_reader as @Reader;
         let mut deser: D = FromReader::from_reader(reader);

branches/snap-stage3/src/libextra/getopts.rs

@@ -345,7 +345,7 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result {
         }
         i += 1;
     }
-    return Ok(Matches {opts: opts.to_owned(),
+    return Ok(Matches {opts: vec::to_owned(opts),
                vals: vals,
                free: free});
 }
@@ -447,7 +447,7 @@ pub fn opt_default(mm: &Matches, nm: &str, def: &str) -> Option<~str> {
     let vals = opt_vals(mm, nm);
     if vals.is_empty() { return None::<~str>; }
     return match vals[0] { Val(ref s) => Some::<~str>(copy *s),
-                           _      => Some::<~str>(def.to_owned()) }
+                           _      => Some::<~str>(str::to_owned(def)) }
 }
 
 #[deriving(Eq)]
@@ -487,10 +487,10 @@ pub mod groups {
                   desc: &str, hint: &str) -> OptGroup {
         let len = short_name.len();
         assert!(len == 1 || len == 0);
-        return OptGroup { short_name: short_name.to_owned(),
-                long_name: long_name.to_owned(),
-                hint: hint.to_owned(),
-                desc: desc.to_owned(),
+        return OptGroup { short_name: str::to_owned(short_name),
+                long_name: str::to_owned(long_name),
+                hint: str::to_owned(hint),
+                desc: str::to_owned(desc),
                 hasarg: Yes,
                 occur: Req};
     }
@@ -500,10 +500,10 @@ pub mod groups {
                   desc: &str, hint: &str) -> OptGroup {
         let len = short_name.len();
         assert!(len == 1 || len == 0);
-        return OptGroup {short_name: short_name.to_owned(),
-                long_name: long_name.to_owned(),
-                hint: hint.to_owned(),
-                desc: desc.to_owned(),
+        return OptGroup {short_name: str::to_owned(short_name),
+                long_name: str::to_owned(long_name),
+                hint: str::to_owned(hint),
+                desc: str::to_owned(desc),
                 hasarg: Yes,
                 occur: Optional};
     }
@@ -513,10 +513,10 @@ pub mod groups {
                    desc: &str) -> OptGroup {
         let len = short_name.len();
         assert!(len == 1 || len == 0);
-        return OptGroup {short_name: short_name.to_owned(),
-                long_name: long_name.to_owned(),
+        return OptGroup {short_name: str::to_owned(short_name),
+                long_name: str::to_owned(long_name),
                 hint: ~"",
-                desc: desc.to_owned(),
+                desc: str::to_owned(desc),
                 hasarg: No,
                 occur: Optional};
     }
@@ -526,10 +526,10 @@ pub mod groups {
                       desc: &str, hint: &str) -> OptGroup {
         let len = short_name.len();
         assert!(len == 1 || len == 0);
-        return OptGroup {short_name: short_name.to_owned(),
-                long_name: long_name.to_owned(),
-                hint: hint.to_owned(),
-                desc: desc.to_owned(),
+        return OptGroup {short_name: str::to_owned(short_name),
+                long_name: str::to_owned(long_name),
+                hint: str::to_owned(hint),
+                desc: str::to_owned(desc),
                 hasarg: Maybe,
                 occur: Optional};
     }
@@ -542,10 +542,10 @@ pub mod groups {
                     desc: &str, hint: &str) -> OptGroup {
         let len = short_name.len();
         assert!(len == 1 || len == 0);
-        return OptGroup {short_name: short_name.to_owned(),
-                long_name: long_name.to_owned(),
-                hint: hint.to_owned(),
-                desc: desc.to_owned(),
+        return OptGroup {short_name: str::to_owned(short_name),
+                long_name: str::to_owned(long_name),
+                hint: str::to_owned(hint),
+                desc: str::to_owned(desc),
                 hasarg: Yes,
                 occur: Multi};
     }
@@ -593,7 +593,7 @@ pub mod groups {
      */
     pub fn usage(brief: &str, opts: &[OptGroup]) -> ~str {
 
-        let desc_sep = ~"\n" + " ".repeat(24);
+        let desc_sep = ~"\n" + str::repeat(" ", 24);
 
         let rows = vec::map(opts, |optref| {
             let OptGroup{short_name: short_name,
@@ -603,7 +603,7 @@ pub mod groups {
                          hasarg: hasarg,
                          _} = copy *optref;
 
-            let mut row = " ".repeat(4);
+            let mut row = str::repeat(" ", 4);
 
             // short option
             row += match short_name.len() {
@@ -629,7 +629,7 @@ pub mod groups {
             // here we just need to indent the start of the description
             let rowlen = row.len();
             row += if rowlen < 24 {
-                " ".repeat(24 - rowlen)
+                str::repeat(" ", 24 - rowlen)
             } else {
                 copy desc_sep
             };
@@ -654,7 +654,7 @@ pub mod groups {
             row
         });
 
-        return brief.to_owned() +
+        return str::to_owned(brief) +
                "\n\nOptions:\n" +
                rows.connect("\n") +
                "\n\n";

branches/snap-stage3/src/libextra/md4.rs

@@ -10,6 +10,7 @@
 
 use core::prelude::*;
 
+use core::str;
 use core::uint;
 use core::vec;
 
@@ -29,7 +30,7 @@ pub fn md4(msg: &[u8]) -> Quad {
     let orig_len: u64 = (msg.len() * 8u) as u64;
 
     // pad message
-    let mut msg = vec::append(msg.to_owned(), [0x80u8]);
+    let mut msg = vec::append(vec::to_owned(msg), [0x80u8]);
     let mut bitlen = orig_len + 8u64;
     while (bitlen + 64u64) % 512u64 > 0u64 {
         msg.push(0u8);
@@ -128,7 +129,7 @@ pub fn md4_str(msg: &[u8]) -> ~str {
 
 /// Calculates the md4 hash of a string, returning the hex-encoded version of
 /// the hash
-pub fn md4_text(msg: &str) -> ~str { md4_str(msg.as_bytes()) }
+pub fn md4_text(msg: &str) -> ~str { md4_str(str::to_bytes(msg)) }
 
 #[test]
 fn test_md4() {

branches/snap-stage3/src/libextra/net_tcp.rs

@@ -1636,7 +1636,7 @@ mod test {
         assert_eq!(net::ip::get_port(&sock.get_peer_addr()), 8887);
 
         // Fulfill the protocol the test server expects
-        let resp_bytes = "ping".as_bytes().to_owned();
+        let resp_bytes = str::to_bytes("ping");
         tcp_write_single(&sock, resp_bytes);
         debug!("message sent");
         sock.read(0u);
@@ -1756,7 +1756,9 @@ mod test {
         buf_write(sock_buf, expected_req);
 
         // so contrived!
-        let actual_resp = buf_read(sock_buf, expected_resp.as_bytes().len());
+        let actual_resp = do str::as_bytes(&expected_resp.to_str()) |resp_buf| {
+            buf_read(sock_buf, resp_buf.len())
+        };
 
         let actual_req = server_result_po.recv();
         debug!("REQ: expected: '%s' actual: '%s'",
@@ -1808,10 +1810,11 @@ mod test {
 
     fn buf_write<W:io::Writer>(w: &W, val: &str) {
         debug!("BUF_WRITE: val len %?", val.len());
-        let b_slice = val.as_bytes();
-        debug!("BUF_WRITE: b_slice len %?",
-               b_slice.len());
-        w.write(b_slice)
+        do str::byte_slice(val) |b_slice| {
+            debug!("BUF_WRITE: b_slice len %?",
+                            b_slice.len());
+            w.write(b_slice)
+        }
     }
 
     fn buf_read<R:io::Reader>(r: &R, len: uint) -> ~str {
@@ -1874,8 +1877,7 @@ mod test {
                             server_ch.send(
                                 str::from_bytes(data));
                             debug!("SERVER: before write");
-                            let s = resp_cell2.take();
-                            tcp_write_single(&sock, s.as_bytes().to_owned());
+                            tcp_write_single(&sock, str::to_bytes(resp_cell2.take()));
                             debug!("SERVER: after write.. die");
                             kill_ch.send(None);
                           }
@@ -1947,7 +1949,7 @@ mod test {
         }
         else {
             let sock = result::unwrap(connect_result);
-            let resp_bytes = resp.as_bytes().to_owned();
+            let resp_bytes = str::to_bytes(resp);
             tcp_write_single(&sock, resp_bytes);
             let read_result = sock.read(0u);
             if read_result.is_err() {

branches/snap-stage3/src/libextra/net_url.rs

@@ -1060,7 +1060,7 @@ mod tests {
         /*
         assert_eq!(decode_form_urlencoded([]).len(), 0);
 
-        let s = "a=1&foo+bar=abc&foo+bar=12+%3D+34".as_bytes();
+        let s = str::to_bytes("a=1&foo+bar=abc&foo+bar=12+%3D+34");
         let form = decode_form_urlencoded(s);
         assert_eq!(form.len(), 2);
         assert_eq!(form.get_ref(&~"a"), &~[~"1"]);

branches/snap-stage3/src/libextra/num/bigint.rs

@@ -524,7 +524,7 @@ impl ToStrRadix for BigUint {
                 let s = uint::to_str_radix(*n as uint, radix);
                 str::from_chars(vec::from_elem(l - s.len(), '0')) + s
             }).concat();
-            s.trim_left_chars(&'0').to_owned()
+            s.trim_left_chars(['0']).to_owned()
         }
     }
 }
@@ -534,7 +534,7 @@ impl FromStrRadix for BigUint {
 
     pub fn from_str_radix(s: &str, radix: uint)
         -> Option<BigUint> {
-        BigUint::parse_bytes(s.as_bytes(), radix)
+        BigUint::parse_bytes(str::to_bytes(s), radix)
     }
 }
 
@@ -564,7 +564,7 @@ impl BigUint {
     /// Creates and initializes an BigUint.
 
     pub fn from_slice(slice: &[BigDigit]) -> BigUint {
-        return BigUint::new(slice.to_owned());
+        return BigUint::new(vec::to_owned(slice));
     }
 
     /// Creates and initializes an BigUint.
@@ -1090,7 +1090,7 @@ impl FromStrRadix for BigInt {
 
     fn from_str_radix(s: &str, radix: uint)
         -> Option<BigInt> {
-        BigInt::parse_bytes(s.as_bytes(), radix)
+        BigInt::parse_bytes(str::to_bytes(s), radix)
     }
 }