---

yaml
---
r: 144747
b: refs/heads/try2
c: de39874
h: refs/heads/master
i:
  144745: 9303422
  144743: 30d7ea6
v: v3

Author: fhahn

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: d1dde99e4b3d43d044cdead7240bbd5f0d7a0ce5
+refs/heads/try2: de39874801761197bf10bf8d04bde1aa2bd82e15
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/compiletest/procsrv.rs

@@ -63,7 +63,7 @@ pub fn run(lib_path: &str,
 
     Result {
         status: output.status,
-        out: str::from_bytes(output.output),
-        err: str::from_bytes(output.error)
+        out: str::from_utf8(output.output),
+        err: str::from_utf8(output.error)
     }
 }

branches/try2/src/libextra/base64.rs

@@ -145,7 +145,7 @@ impl<'self> ToBase64 for &'self [u8] {
         }
 
         unsafe {
-            str::raw::from_bytes_owned(v)
+            str::raw::from_utf8_owned(v)
         }
     }
 }
@@ -162,7 +162,7 @@ impl<'self> FromBase64 for &'self str {
      * Convert any base64 encoded string (literal, `@`, `&`, or `~`)
      * to the byte values it encodes.
      *
-     * You can use the `from_bytes` function in `std::str`
+     * You can use the `from_utf8` function in `std::str`
      * to turn a `[u8]` into a string with characters corresponding to those
      * values.
      *
@@ -180,7 +180,7 @@ impl<'self> FromBase64 for &'self str {
      *     printfln!("%s", hello_str);
      *     let bytes = hello_str.from_base64();
      *     printfln!("%?", bytes);
-     *     let result_str = str::from_bytes(bytes);
+     *     let result_str = str::from_utf8(bytes);
      *     printfln!("%s", result_str);
      * }
      * ~~~

branches/try2/src/libextra/bitv.rs

@@ -523,7 +523,7 @@ impl Bitv {
  * with the most significant bits of each byte coming first. Each
  * bit becomes true if equal to 1 or false if equal to 0.
  */
-pub fn from_bytes(bytes: &[u8]) -> Bitv {
+pub fn from_utf8(bytes: &[u8]) -> Bitv {
     from_fn(bytes.len() * 8, |i| {
         let b = bytes[i / 8] as uint;
         let offset = i % 8;
@@ -1275,8 +1275,8 @@ mod tests {
     }
 
     #[test]
-    fn test_from_bytes() {
-        let bitv = from_bytes([0b10110110, 0b00000000, 0b11111111]);
+    fn test_from_utf8() {
+        let bitv = from_utf8([0b10110110, 0b00000000, 0b11111111]);
         let str = ~"10110110" + "00000000" + "11111111";
         assert_eq!(bitv.to_str(), str);
     }
@@ -1302,7 +1302,7 @@ mod tests {
     #[test]
     fn test_to_bools() {
         let bools = ~[false, false, true, false, false, true, true, false];
-        assert_eq!(from_bytes([0b00100110]).to_bools(), bools);
+        assert_eq!(from_utf8([0b00100110]).to_bools(), bools);
     }
 
     #[test]

branches/try2/src/libextra/ebml.rs

@@ -41,7 +41,7 @@ impl Doc {
     }
 
     pub fn as_str_slice<'a>(&'a self) -> &'a str {
-        str::from_bytes_slice(self.data.slice(self.start, self.end))
+        str::from_utf8_slice(self.data.slice(self.start, self.end))
     }
 
     pub fn as_str(&self) -> ~str {

branches/try2/src/libextra/hex.rs

@@ -45,7 +45,7 @@ impl<'self> ToHex for &'self [u8] {
         }
 
         unsafe {
-            str::raw::from_bytes_owned(v)
+            str::raw::from_utf8_owned(v)
         }
     }
 }
@@ -62,7 +62,7 @@ impl<'self> FromHex for &'self str {
      * Convert any hexadecimal encoded string (literal, `@`, `&`, or `~`)
      * to the byte values it encodes.
      *
-     * You can use the `from_bytes` function in `std::str`
+     * You can use the `from_utf8` function in `std::str`
      * to turn a `[u8]` into a string with characters corresponding to those
      * values.
      *
@@ -80,7 +80,7 @@ impl<'self> FromHex for &'self str {
      *     printfln!("%s", hello_str);
      *     let bytes = hello_str.from_hex().unwrap();
      *     printfln!("%?", bytes);
-     *     let result_str = str::from_bytes(bytes);
+     *     let result_str = str::from_utf8(bytes);
      *     printfln!("%s", result_str);
      * }
      * ~~~

branches/try2/src/libextra/json.rs

@@ -858,7 +858,7 @@ impl<T : iterator::Iterator<char>> Parser<T> {
 
 /// Decodes a json value from an @io::Reader
 pub fn from_reader(rdr: @io::Reader) -> Result<Json, Error> {
-    let s = str::from_bytes(rdr.read_whole_stream());
+    let s = str::from_utf8(rdr.read_whole_stream());
     let mut parser = Parser(~s.iter());
     parser.parse()
 }

branches/try2/src/libextra/terminfo/parser/compiled.rs

@@ -213,7 +213,7 @@ pub fn parse(file: @Reader, longnames: bool) -> Result<~TermInfo, ~str> {
         return Err(~"incompatible file: more string offsets than expected");
     }
 
-    let names_str = str::from_bytes(file.read_bytes(names_bytes as uint - 1)); // don't read NUL
+    let names_str = str::from_utf8(file.read_bytes(names_bytes as uint - 1)); // don't read NUL
     let term_names: ~[~str] = names_str.split_iter('|').map(|s| s.to_owned()).collect();
 
     file.read_byte(); // consume NUL

branches/try2/src/libextra/uuid.rs

@@ -210,7 +210,7 @@ impl Uuid {
     ///
     /// # Arguments
     /// * `b` An array or slice of 16 bytes
-    pub fn from_bytes(b: &[u8]) -> Option<Uuid> {
+    pub fn from_utf8(b: &[u8]) -> Option<Uuid> {
         if b.len() != 16 {
             return None
         }
@@ -307,7 +307,7 @@ impl Uuid {
             s[i*2+0] = digit[0];
             s[i*2+1] = digit[1];
         }
-        str::from_bytes(s)
+        str::from_utf8(s)
     }
 
     /// Returns a string of hexadecimal digits, separated into groups with a hypen
@@ -413,7 +413,7 @@ impl Uuid {
             ub[i] = FromStrRadix::from_str_radix(vs.slice(i*2, (i+1)*2), 16).unwrap();
         }
 
-        Ok(Uuid::from_bytes(ub).unwrap())
+        Ok(Uuid::from_utf8(ub).unwrap())
     }
 }
 
@@ -705,11 +705,11 @@ mod test {
     }
 
     #[test]
-    fn test_from_bytes() {
+    fn test_from_utf8() {
         let b = ~[ 0xa1, 0xa2, 0xa3, 0xa4, 0xb1, 0xb2, 0xc1, 0xc2,
                    0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8 ];
 
-        let u = Uuid::from_bytes(b).unwrap();
+        let u = Uuid::from_utf8(b).unwrap();
         let expected = ~"a1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8";
 
         assert!(u.to_simple_str() == expected);
@@ -729,7 +729,7 @@ mod test {
         let b_in: [u8, ..16] = [ 0xa1, 0xa2, 0xa3, 0xa4, 0xb1, 0xb2, 0xc1, 0xc2,
                                  0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8 ];
 
-        let u = Uuid::from_bytes(b_in.clone()).unwrap();
+        let u = Uuid::from_utf8(b_in.clone()).unwrap();
 
         let b_out = u.to_bytes();
 

branches/try2/src/librustc/back/link.rs

@@ -386,7 +386,7 @@ pub mod write {
                         cc_prog, prog.status));
             sess.note(fmt!("%s arguments: %s",
                         cc_prog, cc_args.connect(" ")));
-            sess.note(str::from_bytes(prog.error + prog.output));
+            sess.note(str::from_utf8(prog.error + prog.output));
             sess.abort_if_errors();
         }
     }
@@ -943,7 +943,7 @@ pub fn link_binary(sess: Session,
                       cc_prog, prog.status));
         sess.note(fmt!("%s arguments: %s",
                        cc_prog, cc_args.connect(" ")));
-        sess.note(str::from_bytes(prog.error + prog.output));
+        sess.note(str::from_utf8(prog.error + prog.output));
         sess.abort_if_errors();
     }
 

branches/try2/src/librustc/metadata/decoder.rs

@@ -1239,7 +1239,7 @@ fn read_path(d: ebml::Doc) -> (~str, uint) {
     do reader::with_doc_data(d) |desc| {
         let pos = io::u64_from_be_bytes(desc, 0u, 4u) as uint;
         let pathbytes = desc.slice(4u, desc.len());
-        let path = str::from_bytes(pathbytes);
+        let path = str::from_utf8(pathbytes);
 
         (path, pos)
     }

branches/try2/src/librustc/metadata/tydecode.rs

@@ -97,7 +97,7 @@ pub fn parse_ident(st: &mut PState, last: char) -> ast::Ident {
 
 fn parse_ident_(st: &mut PState, is_last: @fn(char) -> bool) ->
    ast::Ident {
-    let rslt = scan(st, is_last, str::from_bytes);
+    let rslt = scan(st, is_last, str::from_utf8);
     return st.tcx.sess.ident_of(rslt);
 }
 
@@ -477,7 +477,7 @@ fn parse_abi_set(st: &mut PState) -> AbiSet {
     let mut abis = AbiSet::empty();
     while peek(st) != ']' {
         // FIXME(#5422) str API should not force this copy
-        let abi_str = scan(st, |c| c == ',', str::from_bytes);
+        let abi_str = scan(st, |c| c == ',', str::from_utf8);
         let abi = abi::lookup(abi_str).expect(abi_str);
         abis.add(abi);
     }

branches/try2/src/librustc/middle/borrowck/gather_loans/mod.rs

@@ -95,11 +95,6 @@ impl visit::Visitor<@mut GatherLoanCtxt> for GatherLoanVisitor {
     fn visit_local(&mut self, l:@Local, e:@mut GatherLoanCtxt) {
         gather_loans_in_local(self, l, e);
     }
-
-    // #7740: Do not visit items here, not even fn items nor methods
-    // of impl items; the outer loop in borrowck/mod will visit them
-    // for us in turn.  Thus override visit_item's walk with a no-op.
-    fn visit_item(&mut self, _:@ast::item, _:@mut GatherLoanCtxt) { }
 }
 
 pub fn gather_loans(bccx: @BorrowckCtxt,
@@ -140,8 +135,10 @@ fn gather_loans_in_fn(v: &mut GatherLoanVisitor,
                       id: ast::NodeId,
                       this: @mut GatherLoanCtxt) {
     match fk {
+        // Do not visit items here, the outer loop in borrowck/mod
+        // will visit them for us in turn.
         &visit::fk_item_fn(*) | &visit::fk_method(*) => {
-            fail!("cannot occur, due to visit_item override");
+            return;
         }
 
         // Visit closures as part of the containing item.

branches/try2/src/librustc/rustc.rs

@@ -161,7 +161,7 @@ Available lint options:
         max_key = num::max(name.len(), max_key);
     }
     fn padded(max: uint, s: &str) -> ~str {
-        str::from_bytes(vec::from_elem(max - s.len(), ' ' as u8)) + s
+        str::from_utf8(vec::from_elem(max - s.len(), ' ' as u8)) + s
     }
     println("\nAvailable lint checks:\n");
     printfln!("    %s  %7.7s  %s",
@@ -244,7 +244,7 @@ pub fn run_compiler(args: &[~str], demitter: diagnostic::Emitter) {
       1u => {
         let ifile = matches.free[0].as_slice();
         if "-" == ifile {
-            let src = str::from_bytes(io::stdin().read_whole_stream());
+            let src = str::from_utf8(io::stdin().read_whole_stream());
             str_input(src.to_managed())
         } else {
             file_input(Path(ifile))

branches/try2/src/librustdoc/markdown_writer.rs

@@ -116,8 +116,8 @@ fn pandoc_writer(
 
         debug!("pandoc result: %i", output.status);
         if output.status != 0 {
-            error!("pandoc-out: %s", str::from_bytes(output.output));
-            error!("pandoc-err: %s", str::from_bytes(output.error));
+            error!("pandoc-out: %s", str::from_utf8(output.output));
+            error!("pandoc-err: %s", str::from_utf8(output.error));
             fail!("pandoc failed");
         }
     }

branches/try2/src/librustpkg/rustpkg.rs

@@ -153,7 +153,7 @@ impl<'self> PkgScript<'self> {
                    exe.to_str(), sysroot.to_str(), "configs");
             let output = run::process_output(exe.to_str(), [sysroot.to_str(), ~"configs"]);
             // Run the configs() function to get the configs
-            let cfgs = str::from_bytes_slice(output.output).word_iter()
+            let cfgs = str::from_utf8_slice(output.output).word_iter()
                 .map(|w| w.to_owned()).collect();
             (cfgs, output.status)
         }

branches/try2/src/librustpkg/source_control.rs

@@ -22,8 +22,8 @@ pub fn git_clone(source: &Path, target: &Path, v: &Version) {
         debug!("Running: git clone %s %s", source.to_str(), target.to_str());
         let outp = run::process_output("git", [~"clone", source.to_str(), target.to_str()]);
         if outp.status != 0 {
-            io::println(str::from_bytes_owned(outp.output.clone()));
-            io::println(str::from_bytes_owned(outp.error));
+            io::println(str::from_utf8_owned(outp.output.clone()));
+            io::println(str::from_utf8_owned(outp.error));
             fail!("Couldn't `git clone` %s", source.to_str());
         }
         else {
@@ -36,8 +36,8 @@ pub fn git_clone(source: &Path, target: &Path, v: &Version) {
                                     fmt!("--git-dir=%s", target.push(".git").to_str()),
                                     ~"checkout", fmt!("%s", *s)]);
                     if outp.status != 0 {
-                        io::println(str::from_bytes_owned(outp.output.clone()));
-                        io::println(str::from_bytes_owned(outp.error));
+                        io::println(str::from_utf8_owned(outp.output.clone()));
+                        io::println(str::from_utf8_owned(outp.error));
                         fail!("Couldn't `git checkout %s` in %s",
                               *s, target.to_str());
                     }
@@ -64,8 +64,8 @@ pub fn git_clone(source: &Path, target: &Path, v: &Version) {
 pub fn git_clone_general(source: &str, target: &Path, v: &Version) -> bool {
     let outp = run::process_output("git", [~"clone", source.to_str(), target.to_str()]);
     if outp.status != 0 {
-         debug!(str::from_bytes_owned(outp.output.clone()));
-         debug!(str::from_bytes_owned(outp.error));
+         debug!(str::from_utf8_owned(outp.output.clone()));
+         debug!(str::from_utf8_owned(outp.error));
          false
     }
     else {
@@ -74,8 +74,8 @@ pub fn git_clone_general(source: &str, target: &Path, v: &Version) -> bool {
                     let outp = process_output_in_cwd("git", [~"checkout", fmt!("%s", *s)],
                                                          target);
                     if outp.status != 0 {
-                        debug!(str::from_bytes_owned(outp.output.clone()));
-                        debug!(str::from_bytes_owned(outp.error));
+                        debug!(str::from_utf8_owned(outp.output.clone()));
+                        debug!(str::from_utf8_owned(outp.error));
                         false
                     }
                     else {