std::str: s/from_utf8_slice/from_utf8/, to make the basic case shorter.

huonw · huonw · commit b0426edc0a83 · 2013-12-04T22:35:53.000+11:00
diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs
@@ -298,7 +298,7 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
 
                 let adb_arg = format!("export LD_LIBRARY_PATH={}; gdbserver :5039 {}/{}",
                          config.adb_test_dir.clone(), config.adb_test_dir.clone(),
-                         str::from_utf8_slice(exe_file.filename().unwrap()));
+                         str::from_utf8(exe_file.filename().unwrap()));
 
                 let mut process = procsrv::run_background("", config.adb_path.clone(),
                         [~"shell",adb_arg.clone()],~[(~"",~"")], Some(~""));
diff --git a/src/libextra/ebml.rs b/src/libextra/ebml.rs
@@ -41,7 +41,7 @@ impl Doc {
     }
 
     pub fn as_str_slice<'a>(&'a self) -> &'a str {
-        str::from_utf8_slice(self.data.slice(self.start, self.end))
+        str::from_utf8(self.data.slice(self.start, self.end))
     }
 
     pub fn as_str(&self) -> ~str {
diff --git a/src/libextra/test.rs b/src/libextra/test.rs
@@ -701,7 +701,7 @@ fn should_sort_failures_before_printing_them() {
 
     st.write_failures();
     let s = match st.out {
-        Right(ref m) => str::from_utf8_slice(*m.inner_ref()),
+        Right(ref m) => str::from_utf8(*m.inner_ref()),
         Left(_) => unreachable!()
     };
 
diff --git a/src/librustc/back/archive.rs b/src/librustc/back/archive.rs
@@ -41,8 +41,8 @@ fn run_ar(sess: Session, args: &str, cwd: Option<&Path>,
     let o = Process::new(ar, args.as_slice(), opts).finish_with_output();
     if !o.status.success() {
         sess.err(format!("{} failed with: {}", ar, o.status));
-        sess.note(format!("stdout ---\n{}", str::from_utf8_slice(o.output)));
-        sess.note(format!("stderr ---\n{}", str::from_utf8_slice(o.error)));
+        sess.note(format!("stdout ---\n{}", str::from_utf8(o.output)));
+        sess.note(format!("stderr ---\n{}", str::from_utf8(o.error)));
         sess.abort_if_errors();
     }
     o
diff --git a/src/librustc/metadata/tydecode.rs b/src/librustc/metadata/tydecode.rs
@@ -98,7 +98,7 @@ pub fn parse_ident(st: &mut PState, last: char) -> ast::Ident {
 
 fn parse_ident_(st: &mut PState, is_last: |char| -> bool) -> ast::Ident {
     scan(st, is_last, |bytes| {
-            st.tcx.sess.ident_of(str::from_utf8_slice(bytes))
+            st.tcx.sess.ident_of(str::from_utf8(bytes))
         })
 }
 
@@ -494,7 +494,7 @@ fn parse_abi_set(st: &mut PState) -> AbiSet {
     let mut abis = AbiSet::empty();
     while peek(st) != ']' {
          scan(st, |c| c == ',', |bytes| {
-                 let abi_str = str::from_utf8_slice(bytes).to_owned();
+                 let abi_str = str::from_utf8(bytes).to_owned();
                  let abi = abi::lookup(abi_str).expect(abi_str);
                  abis.add(abi);
               });
diff --git a/src/librustc/metadata/tyencode.rs b/src/librustc/metadata/tyencode.rs
@@ -72,7 +72,7 @@ pub fn enc_ty(w: @mut MemWriter, cx: @ctxt, t: ty::t) {
             None => {
                 let wr = @mut MemWriter::new();
                 enc_sty(wr, cx, &ty::get(t).sty);
-                let s = str::from_utf8_slice(*wr.inner_ref()).to_managed();
+                let s = str::from_utf8(*wr.inner_ref()).to_managed();
                 cx.tcx.short_names_cache.insert(t, s);
                 s
           }
diff --git a/src/librustpkg/lib.rs b/src/librustpkg/lib.rs
@@ -184,7 +184,7 @@ impl<'self> PkgScript<'self> {
                                              [sysroot.as_str().unwrap().to_owned(), ~"configs"]);
             debug!("run_custom: second pkg command did {:?}", output.status);
             // Run the configs() function to get the configs
-            let cfgs = str::from_utf8_slice(output.output).words()
+            let cfgs = str::from_utf8(output.output).words()
                 .map(|w| w.to_owned()).collect();
             (cfgs, output.status)
         }
diff --git a/src/librustpkg/tests.rs b/src/librustpkg/tests.rs
@@ -154,7 +154,7 @@ fn run_git(args: &[~str], env: Option<~[(~str, ~str)]>, cwd: &Path, err_msg: &st
     let rslt = prog.finish_with_output();
     if !rslt.status.success() {
         fail!("{} [git returned {:?}, output = {}, error = {}]", err_msg,
-           rslt.status, str::from_utf8_slice(rslt.output), str::from_utf8_slice(rslt.error));
+           rslt.status, str::from_utf8(rslt.output), str::from_utf8(rslt.error));
     }
 }
 
@@ -290,13 +290,13 @@ fn command_line_test_with_env(args: &[~str], cwd: &Path, env: Option<~[(~str, ~s
     });
     let output = prog.finish_with_output();
     debug!("Output from command {} with args {:?} was {} \\{{}\\}[{:?}]",
-           cmd, args, str::from_utf8_slice(output.output),
-           str::from_utf8_slice(output.error),
+           cmd, args, str::from_utf8(output.output),
+           str::from_utf8(output.error),
            output.status);
     if !output.status.success() {
-        debug!("Command {} {:?} failed with exit code {:?}; its output was --- {} ---",
+        debug!("Command {} {:?} failed with exit code {:?}; its output was --- {} {} ---",
               cmd, args, output.status,
-              str::from_utf8_slice(output.output) + str::from_utf8_slice(output.error));
+              str::from_utf8(output.output), str::from_utf8(output.error));
         Fail(output)
     }
     else {
@@ -455,7 +455,7 @@ fn built_library_exists(repo: &Path, short_name: &str) -> bool {
 fn command_line_test_output(args: &[~str]) -> ~[~str] {
     let mut result = ~[];
     let p_output = command_line_test(args, &os::getcwd());
-    let test_output = str::from_utf8_slice(p_output.output);
+    let test_output = str::from_utf8(p_output.output);
     for s in test_output.split('\n') {
         result.push(s.to_owned());
     }
@@ -469,7 +469,7 @@ fn command_line_test_output_with_env(args: &[~str], env: ~[(~str, ~str)]) -> ~[~
         Fail(_) => fail!("Command-line test failed"),
         Success(r) => r
     };
-    let test_output = str::from_utf8_slice(p_output.output);
+    let test_output = str::from_utf8(p_output.output);
     for s in test_output.split('\n') {
         result.push(s.to_owned());
     }
@@ -1212,7 +1212,7 @@ fn test_uninstall() {
     let workspace = create_local_package(&PkgId::new("foo"));
     command_line_test([~"uninstall", ~"foo"], workspace.path());
     let output = command_line_test([~"list"], workspace.path());
-    assert!(!str::from_utf8_slice(output.output).contains("foo"));
+    assert!(!str::from_utf8(output.output).contains("foo"));
 }
 
 #[test]
@@ -1282,8 +1282,8 @@ fn test_extern_mod() {
     let outp = prog.finish_with_output();
     if !outp.status.success() {
         fail!("output was {}, error was {}",
-              str::from_utf8_slice(outp.output),
-              str::from_utf8_slice(outp.error));
+              str::from_utf8(outp.output),
+              str::from_utf8(outp.error));
     }
     assert!(exec_file.exists() && is_executable(&exec_file));
 }
@@ -1337,8 +1337,8 @@ fn test_extern_mod_simpler() {
     let outp = prog.finish_with_output();
     if !outp.status.success() {
         fail!("output was {}, error was {}",
-              str::from_utf8_slice(outp.output),
-              str::from_utf8_slice(outp.error));
+              str::from_utf8(outp.output),
+              str::from_utf8(outp.error));
     }
     assert!(exec_file.exists() && is_executable(&exec_file));
 }
@@ -2101,7 +2101,7 @@ fn test_rustpkg_test_creates_exec() {
 fn test_rustpkg_test_output() {
     let workspace = create_local_package_with_test(&PkgId::new("foo"));
     let output = command_line_test([~"test", ~"foo"], workspace.path());
-    let output_str = str::from_utf8_slice(output.output);
+    let output_str = str::from_utf8(output.output);
     // The first two assertions are separate because test output may
     // contain color codes, which could appear between "test f" and "ok".
     assert!(output_str.contains("test f"));
@@ -2132,7 +2132,7 @@ fn test_rustpkg_test_cfg() {
               "#[test] #[cfg(not(foobar))] fn f() { assert!('a' != 'a'); }");
     let output = command_line_test([~"test", ~"--cfg", ~"foobar", ~"foo"],
                                    foo_workspace);
-    let output_str = str::from_utf8_slice(output.output);
+    let output_str = str::from_utf8(output.output);
     assert!(output_str.contains("0 passed; 0 failed; 0 ignored; 0 measured"));
 }
 
@@ -2430,8 +2430,8 @@ fn correct_error_dependency() {
         Fail(ProcessOutput{ error: error, output: output, .. }) => {
             assert!(str::is_utf8(error));
             assert!(str::is_utf8(output));
-            let error_str = str::from_utf8_slice(error);
-            let out_str   = str::from_utf8_slice(output);
+            let error_str = str::from_utf8(error);
+            let out_str   = str::from_utf8(output);
             debug!("ss = {}", error_str);
             debug!("out_str = {}", out_str);
             if out_str.contains("Package badpkg depends on some_package_that_doesnt_exist") &&
diff --git a/src/librustpkg/version.rs b/src/librustpkg/version.rs
@@ -114,7 +114,7 @@ pub fn try_getting_local_version(local_path: &Path) -> Option<Version> {
         }
 
         let mut output = None;
-        let output_text = str::from_utf8_slice(outp.output);
+        let output_text = str::from_utf8(outp.output);
         for l in output_text.lines() {
             if !l.is_whitespace() {
                 output = Some(l);
@@ -145,8 +145,8 @@ pub fn try_getting_version(remote_path: &Path) -> Option<Version> {
                                                 tmp_dir.as_str().unwrap().to_owned()]);
         if outp.status.success() {
             debug!("Cloned it... ( {}, {} )",
-                   str::from_utf8_slice(outp.output),
-                   str::from_utf8_slice(outp.error));
+                   str::from_utf8(outp.output),
+                   str::from_utf8(outp.error));
             let mut output = None;
             let git_dir = tmp_dir.join(".git");
             debug!("(getting version, now getting tags) executing \\{git --git-dir={} tag -l\\}",
@@ -155,7 +155,7 @@ pub fn try_getting_version(remote_path: &Path) -> Option<Version> {
             let outp = run::process_output("git",
                                            ["--git-dir=" + git_dir.as_str().unwrap(),
                                             ~"tag", ~"-l"]);
-            let output_text = str::from_utf8_slice(outp.output);
+            let output_text = str::from_utf8(outp.output);
             debug!("Full output: ( {} ) [{:?}]", output_text, outp.status);
             for l in output_text.lines() {
                 debug!("A line of output: {}", l);
diff --git a/src/librustuv/file.rs b/src/librustuv/file.rs
@@ -487,7 +487,7 @@ mod test {
 
             let nread = result.unwrap();
             assert!(nread > 0);
-            let read_str = str::from_utf8_slice(read_mem.slice_to(nread as uint));
+            let read_str = str::from_utf8(read_mem.slice_to(nread as uint));
             assert_eq!(read_str, "hello");
         }
         // unlink
diff --git a/src/librustuv/net.rs b/src/librustuv/net.rs
@@ -81,7 +81,7 @@ pub fn sockaddr_to_socket_addr(addr: *sockaddr) -> SocketAddr {
             };
             port as u16
         };
-        let ip_str = str::from_utf8_slice(ip_name).trim_right_chars(&'\x00');
+        let ip_str = str::from_utf8(ip_name).trim_right_chars(&'\x00');
         let ip_addr = FromStr::from_str(ip_str).unwrap();
 
         SocketAddr { ip: ip_addr, port: ip_port }
diff --git a/src/libstd/c_str.rs b/src/libstd/c_str.rs
@@ -167,7 +167,7 @@ impl CString {
         if self.buf.is_null() { return None; }
         let buf = self.as_bytes();
         let buf = buf.slice_to(buf.len()-1); // chop off the trailing NUL
-        str::from_utf8_slice_opt(buf)
+        str::from_utf8_opt(buf)
     }
 
     /// Return a CString iterator.
diff --git a/src/libstd/fmt/mod.rs b/src/libstd/fmt/mod.rs
@@ -802,7 +802,7 @@ impl<'self> Formatter<'self> {
 
     fn runplural(&mut self, value: uint, pieces: &[rt::Piece]) {
         ::uint::to_str_bytes(value, 10, |buf| {
-            let valuestr = str::from_utf8_slice(buf);
+            let valuestr = str::from_utf8(buf);
             for piece in pieces.iter() {
                 self.run(piece, Some(valuestr));
             }
diff --git a/src/libstd/io/flate.rs b/src/libstd/io/flate.rs
@@ -117,7 +117,7 @@ mod test {
         let mut out_bytes = [0, .. 100];
         let bytes_read = inflate_reader.read(out_bytes).unwrap();
         assert_eq!(bytes_read, in_bytes.len());
-        let out_msg = str::from_utf8_slice(out_bytes);
+        let out_msg = str::from_utf8(out_bytes);
         assert_eq!(in_msg, out_msg);
     }
 }
diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs
@@ -821,7 +821,7 @@ mod test {
             }
         }
         unlink(filename);
-        let read_str = str::from_utf8_slice(read_mem);
+        let read_str = str::from_utf8(read_mem);
         assert_eq!(read_str, message);
     })
 
@@ -845,7 +845,7 @@ mod test {
             tell_pos_post_read = read_stream.tell();
         }
         unlink(filename);
-        let read_str = str::from_utf8_slice(read_mem);
+        let read_str = str::from_utf8(read_mem);
         assert_eq!(read_str, message.slice(4, 8));
         assert_eq!(tell_pos_pre_read, set_cursor);
         assert_eq!(tell_pos_post_read, message.len() as u64);
@@ -870,7 +870,7 @@ mod test {
             read_stream.read(read_mem);
         }
         unlink(filename);
-        let read_str = str::from_utf8_slice(read_mem);
+        let read_str = str::from_utf8(read_mem);
         assert!(read_str == final_msg.to_owned());
     })
 
@@ -892,15 +892,15 @@ mod test {
 
             read_stream.seek(-4, SeekEnd);
             read_stream.read(read_mem);
-            assert_eq!(str::from_utf8_slice(read_mem), chunk_three);
+            assert_eq!(str::from_utf8(read_mem), chunk_three);
 
             read_stream.seek(-9, SeekCur);
             read_stream.read(read_mem);
-            assert_eq!(str::from_utf8_slice(read_mem), chunk_two);
+            assert_eq!(str::from_utf8(read_mem), chunk_two);
 
             read_stream.seek(0, SeekSet);
             read_stream.read(read_mem);
-            assert_eq!(str::from_utf8_slice(read_mem), chunk_one);
+            assert_eq!(str::from_utf8(read_mem), chunk_one);
         }
         unlink(filename);
     })
@@ -974,7 +974,7 @@ mod test {
             {
                 let n = f.filestem_str();
                 File::open(f).read(mem);
-                let read_str = str::from_utf8_slice(mem);
+                let read_str = str::from_utf8(mem);
                 let expected = match n {
                     None|Some("") => fail!("really shouldn't happen.."),
                     Some(n) => prefix+n
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
@@ -1049,7 +1049,7 @@ pub trait Buffer: Reader {
             Some(n) if n == width => {}
             Some(..) | None => return None // read error
         }
-        match str::from_utf8_slice_opt(buf.slice_to(width)) {
+        match str::from_utf8_opt(buf.slice_to(width)) {
             Some(s) => Some(s.char_at(0)),
             None => None
         }
diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs
@@ -176,7 +176,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
     /// If the path is not representable in utf-8, this returns None.
     #[inline]
     fn as_str<'a>(&'a self) -> Option<&'a str> {
-        str::from_utf8_slice_opt(self.as_vec())
+        str::from_utf8_opt(self.as_vec())
     }
 
     /// Returns the path as a byte vector
@@ -207,7 +207,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
     /// See `dirname` for details.
     #[inline]
     fn dirname_str<'a>(&'a self) -> Option<&'a str> {
-        str::from_utf8_slice_opt(self.dirname())
+        str::from_utf8_opt(self.dirname())
     }
     /// Returns the file component of `self`, as a byte vector.
     /// If `self` represents the root of the file hierarchy, returns None.
@@ -217,7 +217,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
     /// See `filename` for details.
     #[inline]
     fn filename_str<'a>(&'a self) -> Option<&'a str> {
-        self.filename().and_then(str::from_utf8_slice_opt)
+        self.filename().and_then(str::from_utf8_opt)
     }
     /// Returns the stem of the filename of `self`, as a byte vector.
     /// The stem is the portion of the filename just before the last '.'.
@@ -239,7 +239,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
     /// See `filestem` for details.
     #[inline]
     fn filestem_str<'a>(&'a self) -> Option<&'a str> {
-        self.filestem().and_then(str::from_utf8_slice_opt)
+        self.filestem().and_then(str::from_utf8_opt)
     }
     /// Returns the extension of the filename of `self`, as an optional byte vector.
     /// The extension is the portion of the filename just after the last '.'.
@@ -262,7 +262,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
     /// See `extension` for details.
     #[inline]
     fn extension_str<'a>(&'a self) -> Option<&'a str> {
-        self.extension().and_then(str::from_utf8_slice_opt)
+        self.extension().and_then(str::from_utf8_opt)
     }
 
     /// Replaces the filename portion of the path with the given byte vector or string.
@@ -493,12 +493,12 @@ pub trait BytesContainer {
     /// Raises `str::null_byte` if not utf-8
     #[inline]
     fn container_as_str<'a>(&'a self) -> &'a str {
-        str::from_utf8_slice(self.container_as_bytes())
+        str::from_utf8(self.container_as_bytes())
     }
     /// Returns the receiver interpreted as a utf-8 string, if possible
     #[inline]
     fn container_as_str_opt<'a>(&'a self) -> Option<&'a str> {
-        str::from_utf8_slice_opt(self.container_as_bytes())
+        str::from_utf8_opt(self.container_as_bytes())
     }
     /// Returns whether .container_as_str() is guaranteed to not fail
     // FIXME (#8888): Remove unused arg once ::<for T> works
diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs
diff --git a/src/libstd/str.rs b/src/libstd/str.rs
diff --git a/src/test/run-pass/const-str-ptr.rs b/src/test/run-pass/const-str-ptr.rs
diff --git a/src/test/run-pass/rtio-processes.rs b/src/test/run-pass/rtio-processes.rs

Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ impl Doc {`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`pub fn as_str_slice<'a>(&'a self) -> &'a str {`
`44`		`- str::from_utf8_slice(self.data.slice(self.start, self.end))`
	`44`	`+ str::from_utf8(self.data.slice(self.start, self.end))`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`pub fn as_str(&self) -> ~str {`
Original file line number	Diff line number	Diff line change
`@@ -41,8 +41,8 @@ fn run_ar(sess: Session, args: &str, cwd: Option<&Path>,`
`41`	`41`	`let o = Process::new(ar, args.as_slice(), opts).finish_with_output();`
`42`	`42`	`if !o.status.success() {`
`43`	`43`	`sess.err(format!("{} failed with: {}", ar, o.status));`
`44`		`- sess.note(format!("stdout ---\n{}", str::from_utf8_slice(o.output)));`
`45`		`- sess.note(format!("stderr ---\n{}", str::from_utf8_slice(o.error)));`
	`44`	`+ sess.note(format!("stdout ---\n{}", str::from_utf8(o.output)));`
	`45`	`+ sess.note(format!("stderr ---\n{}", str::from_utf8(o.error)));`
`46`	`46`	`sess.abort_if_errors();`
`47`	`47`	`}`
`48`	`48`	`o`
Original file line number	Diff line number	Diff line change
`@@ -72,7 +72,7 @@ pub fn enc_ty(w: @mut MemWriter, cx: @ctxt, t: ty::t) {`
`72`	`72`	`None => {`
`73`	`73`	`let wr = @mut MemWriter::new();`
`74`	`74`	`enc_sty(wr, cx, &ty::get(t).sty);`
`75`		`- let s = str::from_utf8_slice(*wr.inner_ref()).to_managed();`
	`75`	`+ let s = str::from_utf8(*wr.inner_ref()).to_managed();`
`76`	`76`	`cx.tcx.short_names_cache.insert(t, s);`
`77`	`77`	`s`
`78`	`78`	`}`
Original file line number	Diff line number	Diff line change
`@@ -184,7 +184,7 @@ impl<'self> PkgScript<'self> {`
`184`	`184`	`[sysroot.as_str().unwrap().to_owned(), ~"configs"]);`
`185`	`185`	`debug!("run_custom: second pkg command did {:?}", output.status);`
`186`	`186`	`// Run the configs() function to get the configs`
`187`		`- let cfgs = str::from_utf8_slice(output.output).words()`
	`187`	`+ let cfgs = str::from_utf8(output.output).words()`
`188`	`188`	`.map(\|w\| w.to_owned()).collect();`
`189`	`189`	`(cfgs, output.status)`
`190`	`190`	`}`
Original file line number	Diff line number	Diff line change
`@@ -487,7 +487,7 @@ mod test {`
`487`	`487`
`488`	`488`	`let nread = result.unwrap();`
`489`	`489`	`assert!(nread > 0);`
`490`		`- let read_str = str::from_utf8_slice(read_mem.slice_to(nread as uint));`
	`490`	`+ let read_str = str::from_utf8(read_mem.slice_to(nread as uint));`
`491`	`491`	`assert_eq!(read_str, "hello");`
`492`	`492`	`}`
`493`	`493`	`// unlink`