std: rename str::from_bytes{,_with_null,_slice} to from_utf8*

Author: erickt

src/compiletest/procsrv.rs

@@ -65,7 +65,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)
     }
 }

src/libextra/base64.rs

@@ -217,7 +217,7 @@ impl<'self> FromBase64 for &'self str {
      *     println(fmt!("%s",hello_str));
      *     let bytes = hello_str.from_base64();
      *     println(fmt!("%?",bytes));
-     *     let result_str = str::from_bytes(bytes);
+     *     let result_str = str::from_utf8(bytes);
      *     println(fmt!("%s",result_str));
      * }
      * ~~~

src/libextra/ebml.rs

@@ -95,7 +95,7 @@ pub mod reader {
         }
 
         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 {

src/libextra/net_tcp.rs

@@ -1800,7 +1800,7 @@ mod test {
         buf_write(sock_buf, expected_req);
 
         let buf_reader = sock_buf as @Reader;
-        let actual_response = str::from_bytes(buf_reader.read_whole_stream());
+        let actual_response = str::from_utf8(buf_reader.read_whole_stream());
         debug!("Actual response: %s", actual_response);
         assert!(expected_resp == actual_response);
     }
@@ -1817,7 +1817,7 @@ mod test {
         let new_bytes = (*r).read_bytes(len);
         debug!("in buf_read.. new_bytes len: %?",
                         new_bytes.len());
-        str::from_bytes(new_bytes)
+        str::from_utf8(new_bytes)
     }
 
     fn run_tcp_test_server(server_ip: &str, server_port: uint, resp: ~str,
@@ -1867,11 +1867,11 @@ mod test {
                         let received_req_bytes = read(&sock, 0u);
                         match received_req_bytes {
                           result::Ok(data) => {
-                            debug!("SERVER: got REQ str::from_bytes..");
+                            debug!("SERVER: got REQ str::from_utf8..");
                             debug!("SERVER: REQ data len: %?",
                                             data.len());
                             server_ch.send(
-                                str::from_bytes(data));
+                                str::from_utf8(data));
                             debug!("SERVER: before write");
                             let s = resp_cell2.take();
                             tcp_write_single(&sock, s.as_bytes().to_owned());
@@ -1954,7 +1954,7 @@ mod test {
                 Ok(~"")
             }
             else {
-                let ret_val = str::from_bytes(read_result.get());
+                let ret_val = str::from_utf8(read_result.get());
                 debug!("CLIENT: after client_ch recv ret: '%s'",
                    ret_val);
                 Ok(ret_val)

src/libextra/terminfo/parser/compiled.rs

@@ -212,7 +212,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 = names_str.split_iter('|').transform(|s| s.to_owned()).collect();
 
     file.read_byte(); // consume NUL

src/libextra/uv_ll.rs

@@ -1287,7 +1287,7 @@ mod test {
                 let buf_base = get_base_from_buf(buf);
                 let bytes = vec::from_buf(buf_base, nread as uint);
                 let read_chan = (*client_data).read_chan.clone();
-                let msg_from_server = str::from_bytes(bytes);
+                let msg_from_server = str::from_utf8(bytes);
                 read_chan.send(msg_from_server);
                 close(stream as *libc::c_void, after_close_cb)
             }
@@ -1473,7 +1473,7 @@ mod test {
                                 buf_len as uint,
                                 nread);
                 let bytes = vec::from_buf(buf_base, nread as uint);
-                let request_str = str::from_bytes(bytes);
+                let request_str = str::from_utf8(bytes);
 
                 let client_data = get_data_for_uv_handle(
                     client_stream_ptr as *libc::c_void) as *tcp_server_data;

src/librustc/back/link.rs

@@ -397,7 +397,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();
         }
     }
@@ -819,7 +819,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();
     }
 

src/librustc/metadata/decoder.rs

@@ -941,7 +941,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)
     }

src/librustc/metadata/tydecode.rs

@@ -99,7 +99,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);
 }
 
@@ -453,7 +453,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);
     }

src/librustc/rustc.rc

@@ -168,7 +168,7 @@ Available lint options:
     let mut max_key = 0;
     for lint_dict.each_key |k| { max_key = uint::max(k.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
     }
     io::println(fmt!("\nAvailable lint checks:\n"));
     io::println(fmt!("    %s  %7.7s  %s",
@@ -251,7 +251,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))

src/librustc/util/ppaux.rs

@@ -433,11 +433,11 @@ pub fn ty_to_str(cx: ctxt, typ: t) -> ~str {
       ty_param(param_ty {idx: id, def_id: did}) => {
           if cx.sess.verbose() {
               fmt!("'%s:%?",
-                   str::from_bytes([('a' as u8) + (id as u8)]),
+                   str::from_utf8([('a' as u8) + (id as u8)]),
                    did)
           } else {
               fmt!("'%s",
-                   str::from_bytes([('a' as u8) + (id as u8)]))
+                   str::from_utf8([('a' as u8) + (id as u8)]))
           }
       }
       ty_self(*) => ~"Self",

src/librustpkg/tests.rs

@@ -660,7 +660,7 @@ fn test_info() {
     let expected_info = ~"package foo"; // fill in
     let workspace = create_local_package(&PkgId::new("foo"));
     let output = command_line_test([~"info", ~"foo"], &workspace);
-    assert_eq!(str::from_bytes(output.output), expected_info);
+    assert_eq!(str::from_utf8(output.output), expected_info);
 }
 
 #[test]
@@ -669,7 +669,7 @@ fn test_rustpkg_test() {
     let expected_results = ~"1 out of 1 tests passed"; // fill in
     let workspace = create_local_package_with_test(&PkgId::new("foo"));
     let output = command_line_test([~"test", ~"foo"], &workspace);
-    assert_eq!(str::from_bytes(output.output), expected_results);
+    assert_eq!(str::from_utf8(output.output), expected_results);
 }
 
 #[test]
@@ -679,5 +679,5 @@ fn test_uninstall() {
     let _output = command_line_test([~"info", ~"foo"], &workspace);
     command_line_test([~"uninstall", ~"foo"], &workspace);
     let output = command_line_test([~"list"], &workspace);
-    assert!(!str::from_bytes(output.output).contains("foo"));
+    assert!(!str::from_utf8(output.output).contains("foo"));
 }

src/libstd/io.rs

@@ -636,7 +636,7 @@ impl<T:Reader> ReaderUtil for T {
             }
             bytes.push(ch as u8);
         }
-        str::from_bytes(bytes)
+        str::from_utf8(bytes)
     }
 
     fn read_line(&self) -> ~str {
@@ -645,7 +645,7 @@ impl<T:Reader> ReaderUtil for T {
 
     fn read_chars(&self, n: uint) -> ~[char] {
         // returns the (consumed offset, n_req), appends characters to &chars
-        fn chars_from_bytes<T:Reader>(bytes: &~[u8], chars: &mut ~[char])
+        fn chars_from_utf8<T:Reader>(bytes: &~[u8], chars: &mut ~[char])
             -> (uint, uint) {
             let mut i = 0;
             let bytes_len = bytes.len();
@@ -691,7 +691,7 @@ impl<T:Reader> ReaderUtil for T {
                 break;
             }
             bytes.push_all(data);
-            let (offset, nbreq) = chars_from_bytes::<T>(&bytes, &mut chars);
+            let (offset, nbreq) = chars_from_utf8::<T>(&bytes, &mut chars);
             let ncreq = n - chars.len();
             // again we either know we need a certain number of bytes
             // to complete a character, or we make sure we don't
@@ -1721,7 +1721,7 @@ pub fn seek_in_buf(offset: int, pos: uint, len: uint, whence: SeekStyle) ->
 pub fn read_whole_file_str(file: &Path) -> Result<~str, ~str> {
     result::chain(read_whole_file(file), |bytes| {
         if str::is_utf8(bytes) {
-            result::Ok(str::from_bytes(bytes))
+            result::Ok(str::from_utf8(bytes))
         } else {
             result::Err(file.to_str() + " is not UTF-8")
         }

src/libstd/logging.rs

@@ -60,7 +60,7 @@ pub fn log_type<T>(level: u32, object: &T) {
         }
         _ => {
             // XXX: Bad allocation
-            let msg = str::from_bytes(bytes);
+            let msg = str::from_utf8(bytes);
             newsched_log_str(msg);
         }
     }

src/libstd/num/strconv.rs

@@ -388,7 +388,7 @@ pub fn to_str_common<T:NumCast+Zero+One+Eq+Ord+NumStrConv+Copy+
         sign: SignFormat, digits: SignificantDigits) -> (~str, bool) {
     let (bytes, special) = to_str_bytes_common(num, radix,
                                negative_zero, sign, digits);
-    (str::from_bytes(bytes), special)
+    (str::from_utf8(bytes), special)
 }
 
 // Some constants for from_str_bytes_common's input validation,

src/libstd/rt/io/flate.rs

@@ -117,7 +117,7 @@ mod test {
         let mut out_bytes = [0, .. 100];
         let bytes_read = inflate_reader.read(out_bytes).get();
         assert_eq!(bytes_read, in_bytes.len());
-        let out_msg = str::from_bytes(out_bytes);
+        let out_msg = str::from_utf8(out_bytes);
         assert!(in_msg == out_msg);
     }
 }

src/libstd/run.rs

@@ -954,7 +954,7 @@ mod tests {
 
         let run::ProcessOutput {status, output, error}
              = run::process_output("echo", [~"hello"]);
-        let output_str = str::from_bytes(output);
+        let output_str = str::from_utf8(output);
 
         assert_eq!(status, 0);
         assert_eq!(output_str.trim().to_owned(), ~"hello");
@@ -1016,7 +1016,7 @@ mod tests {
             let reader = io::FILE_reader(file, false);
             let buf = reader.read_whole_stream();
             os::fclose(file);
-            str::from_bytes(buf)
+            str::from_utf8(buf)
         }
     }
 
@@ -1039,7 +1039,7 @@ mod tests {
         let mut prog = run::Process::new("echo", [~"hello"], run::ProcessOptions::new());
         let run::ProcessOutput {status, output, error}
             = prog.finish_with_output();
-        let output_str = str::from_bytes(output);
+        let output_str = str::from_utf8(output);
 
         assert_eq!(status, 0);
         assert_eq!(output_str.trim().to_owned(), ~"hello");
@@ -1053,7 +1053,7 @@ mod tests {
         let run::ProcessOutput {status, output, error}
             = prog.finish_with_output();
 
-        let output_str = str::from_bytes(output);
+        let output_str = str::from_utf8(output);
 
         assert_eq!(status, 0);
         assert_eq!(output_str.trim().to_owned(), ~"hello");
@@ -1102,7 +1102,7 @@ mod tests {
     fn test_keep_current_working_dir() {
         let mut prog = run_pwd(None);
 
-        let output = str::from_bytes(prog.finish_with_output().output);
+        let output = str::from_utf8(prog.finish_with_output().output);
         let parent_dir = os::getcwd().normalize();
         let child_dir = Path(output.trim()).normalize();
 
@@ -1120,7 +1120,7 @@ mod tests {
         let parent_dir = os::getcwd().dir_path().normalize();
         let mut prog = run_pwd(Some(&parent_dir));
 
-        let output = str::from_bytes(prog.finish_with_output().output);
+        let output = str::from_utf8(prog.finish_with_output().output);
         let child_dir = Path(output.trim()).normalize();
 
         let parent_stat = parent_dir.stat().unwrap();
@@ -1150,7 +1150,7 @@ mod tests {
     fn test_inherit_env() {
 
         let mut prog = run_env(None);
-        let output = str::from_bytes(prog.finish_with_output().output);
+        let output = str::from_utf8(prog.finish_with_output().output);
 
         for os::env().each |&(k, v)| {
             // don't check windows magical empty-named variables
@@ -1165,7 +1165,7 @@ mod tests {
         new_env.push((~"RUN_TEST_NEW_ENV", ~"123"));
 
         let mut prog = run_env(Some(new_env.slice(0, new_env.len())));
-        let output = str::from_bytes(prog.finish_with_output().output);
+        let output = str::from_utf8(prog.finish_with_output().output);
 
         assert!(output.contains("RUN_TEST_NEW_ENV=123"));
     }