auto merge of #6389 : sonwow/rust/issue-3356, r=bstrie

Fix for #3356

Author: bors

src/compiletest/header.rs

@@ -91,7 +91,7 @@ pub fn is_test_ignored(config: config, testfile: &Path) -> bool {
     return false;
 
     fn xfail_target() -> ~str {
-        ~"xfail-" + str::from_slice(os::SYSNAME)
+        ~"xfail-" + str::to_owned(os::SYSNAME)
     }
 }
 

src/compiletest/runtest.rs

@@ -371,7 +371,7 @@ fn check_expected_errors(expected_errors: ~[errors::ExpectedError],
             was_expected = true;
         }
 
-        if !was_expected && is_compiler_error_or_warning(str::from_slice(line)) {
+        if !was_expected && is_compiler_error_or_warning(str::to_owned(line)) {
             fatal_ProcRes(fmt!("unexpected compiler error or warning: '%s'",
                                line),
                           ProcRes);
@@ -596,7 +596,7 @@ fn make_lib_name(config: config, auxfile: &Path, testfile: &Path) -> Path {
 
 fn make_exe_name(config: config, testfile: &Path) -> Path {
     Path(output_base_name(config, testfile).to_str() +
-            str::from_slice(os::EXE_SUFFIX))
+            str::to_owned(os::EXE_SUFFIX))
 }
 
 fn make_run_args(config: config, _props: TestProps, testfile: &Path) ->

src/libcore/io.rs

@@ -758,7 +758,7 @@ impl<T:Reader> ReaderUtil for T {
     fn read_lines(&self) -> ~[~str] {
         do vec::build |push| {
             for self.each_line |line| {
-                push(str::from_slice(line));
+                push(str::to_owned(line));
             }
         }
     }

src/libcore/os.rs

@@ -396,8 +396,8 @@ fn dup2(src: c_int, dst: c_int) -> c_int {
 
 
 pub fn dll_filename(base: &str) -> ~str {
-    return str::from_slice(DLL_PREFIX) + str::from_slice(base) +
-           str::from_slice(DLL_SUFFIX)
+    return str::to_owned(DLL_PREFIX) + str::to_owned(base) +
+           str::to_owned(DLL_SUFFIX)
 }
 
 

src/libcore/path.rs

@@ -506,7 +506,7 @@ impl GenericPath for PosixPath {
     fn with_filestem(&self, s: &str) -> PosixPath {
         match self.filetype() {
           None => self.with_filename(s),
-          Some(ref t) => self.with_filename(str::from_slice(s) + *t)
+          Some(ref t) => self.with_filename(str::to_owned(s) + *t)
         }
     }
 
@@ -517,7 +517,7 @@ impl GenericPath for PosixPath {
               Some(ref s) => self.with_filename(*s)
             }
         } else {
-            let t = ~"." + str::from_slice(t);
+            let t = ~"." + str::to_owned(t);
             match self.filestem() {
               None => self.with_filename(t),
               Some(ref s) => self.with_filename(*s + t)
@@ -650,7 +650,7 @@ impl GenericPath for WindowsPath {
               None => {
                 host = None;
                 device = None;
-                rest = str::from_slice(s);
+                rest = str::to_owned(s);
               }
             }
           }
@@ -723,7 +723,7 @@ impl GenericPath for WindowsPath {
     fn with_filestem(&self, s: &str) -> WindowsPath {
         match self.filetype() {
           None => self.with_filename(s),
-          Some(ref t) => self.with_filename(str::from_slice(s) + *t)
+          Some(ref t) => self.with_filename(str::to_owned(s) + *t)
         }
     }
 
@@ -734,7 +734,7 @@ impl GenericPath for WindowsPath {
               Some(ref s) => self.with_filename(*s)
             }
         } else {
-            let t = ~"." + str::from_slice(t);
+            let t = ~"." + str::to_owned(t);
             match self.filestem() {
               None => self.with_filename(t),
               Some(ref s) =>
@@ -985,7 +985,7 @@ mod tests {
     fn test_posix_paths() {
         fn t(wp: &PosixPath, s: &str) {
             let ss = wp.to_str();
-            let sss = str::from_slice(s);
+            let sss = str::to_owned(s);
             if (ss != sss) {
                 debug!("got %s", ss);
                 debug!("expected %s", sss);
@@ -1043,7 +1043,7 @@ mod tests {
     fn test_normalize() {
         fn t(wp: &PosixPath, s: &str) {
             let ss = wp.to_str();
-            let sss = str::from_slice(s);
+            let sss = str::to_owned(s);
             if (ss != sss) {
                 debug!("got %s", ss);
                 debug!("expected %s", sss);
@@ -1106,7 +1106,7 @@ mod tests {
     fn test_windows_paths() {
         fn t(wp: &WindowsPath, s: &str) {
             let ss = wp.to_str();
-            let sss = str::from_slice(s);
+            let sss = str::to_owned(s);
             if (ss != sss) {
                 debug!("got %s", ss);
                 debug!("expected %s", sss);

src/libcore/rand.rs

@@ -568,7 +568,7 @@ impl<R: Rng> RngUtil for R {
 
     /// Shuffle a vec
     fn shuffle<T:Copy>(&mut self, values: &[T]) -> ~[T] {
-        let mut m = vec::from_slice(values);
+        let mut m = vec::to_owned(values);
         self.shuffle_mut(m);
         m
     }

src/libcore/str.rs

@@ -78,21 +78,21 @@ pub fn from_bytes_slice<'a>(vector: &'a [u8]) -> &'a str {
 
 /// Copy a slice into a new unique str
 #[inline(always)]
-pub fn from_slice(s: &str) -> ~str {
+pub fn to_owned(s: &str) -> ~str {
     unsafe { raw::slice_bytes_owned(s, 0, len(s)) }
 }
 
 impl ToStr for ~str {
     #[inline(always)]
-    fn to_str(&self) -> ~str { from_slice(*self) }
+    fn to_str(&self) -> ~str { to_owned(*self) }
 }
 impl<'self> ToStr for &'self str {
     #[inline(always)]
-    fn to_str(&self) -> ~str { from_slice(*self) }
+    fn to_str(&self) -> ~str { to_owned(*self) }
 }
 impl ToStr for @str {
     #[inline(always)]
-    fn to_str(&self) -> ~str { from_slice(*self) }
+    fn to_str(&self) -> ~str { to_owned(*self) }
 }
 
 /**
@@ -511,7 +511,7 @@ Section: Transforming strings
  */
 pub fn to_bytes(s: &str) -> ~[u8] {
     unsafe {
-        let mut v: ~[u8] = ::cast::transmute(from_slice(s));
+        let mut v: ~[u8] = ::cast::transmute(to_owned(s));
         vec::raw::set_len(&mut v, len(s));
         v
     }
@@ -2438,7 +2438,7 @@ pub fn as_c_str<T>(s: &str, f: &fn(*libc::c_char) -> T) -> T {
         // NB: len includes the trailing null.
         assert!(len > 0);
         if unsafe { *(ptr::offset(buf,len-1)) != 0 } {
-            as_c_str(from_slice(s), f)
+            as_c_str(to_owned(s), f)
         } else {
             f(buf as *libc::c_char)
         }
@@ -3069,7 +3069,7 @@ impl<'self> StrSlice<'self> for &'self str {
 
 
     #[inline]
-    fn to_owned(&self) -> ~str { from_slice(*self) }
+    fn to_owned(&self) -> ~str { to_owned(*self) }
 
     #[inline]
     fn to_managed(&self) -> @str {
@@ -3109,7 +3109,7 @@ impl OwnedStr for ~str {
 impl Clone for ~str {
     #[inline(always)]
     fn clone(&self) -> ~str {
-        from_slice(*self)
+        to_owned(*self)
     }
 }
 

src/libcore/vec.rs

@@ -167,7 +167,7 @@ pub fn from_elem<T:Copy>(n_elts: uint, t: T) -> ~[T] {
 }
 
 /// Creates a new unique vector with the same contents as the slice
-pub fn from_slice<T:Copy>(t: &[T]) -> ~[T] {
+pub fn to_owned<T:Copy>(t: &[T]) -> ~[T] {
     from_fn(t.len(), |i| t[i])
 }
 
@@ -3645,19 +3645,19 @@ mod tests {
         let mut results: ~[~[int]];
 
         results = ~[];
-        for each_permutation(~[]) |v| { results.push(from_slice(v)); }
+        for each_permutation(~[]) |v| { results.push(to_owned(v)); }
         assert!(results == ~[~[]]);
 
         results = ~[];
-        for each_permutation(~[7]) |v| { results.push(from_slice(v)); }
+        for each_permutation(~[7]) |v| { results.push(to_owned(v)); }
         assert!(results == ~[~[7]]);
 
         results = ~[];
-        for each_permutation(~[1,1]) |v| { results.push(from_slice(v)); }
+        for each_permutation(~[1,1]) |v| { results.push(to_owned(v)); }
         assert!(results == ~[~[1,1],~[1,1]]);
 
         results = ~[];
-        for each_permutation(~[5,2,0]) |v| { results.push(from_slice(v)); }
+        for each_permutation(~[5,2,0]) |v| { results.push(to_owned(v)); }
         assert!(results ==
             ~[~[5,2,0],~[5,0,2],~[2,5,0],~[2,0,5],~[0,5,2],~[0,2,5]]);
     }

src/libfuzzer/fuzzer.rc

@@ -316,7 +316,7 @@ pub fn check_variants_T<T:Copy>(crate: @ast::crate,
     if L < 100 {
         do under(uint::min(L, 20)) |i| {
             error!("Replacing... #%?", uint::to_str(i));
-            let fname = str::from_slice(filename.to_str());
+            let fname = str::to_owned(filename.to_str());
             do under(uint::min(L, 30)) |j| {
                 let fname = fname.to_str();
                 error!("With... %?", stringifier(things[j], intr));

src/librust/rust.rc

@@ -192,7 +192,7 @@ fn do_command(command: &Command, args: &[~str]) -> ValidUsage {
             let (prog, prog_args) = (words.head(), words.tail());
             let exitstatus = run::run_program(
                 *prog,
-                vec::append(vec::from_slice(prog_args), args)
+                vec::append(vec::to_owned(prog_args), args)
             );
             os::set_exit_status(exitstatus);
             Valid

src/librustc/back/link.rs

@@ -747,8 +747,8 @@ pub fn output_dll_filename(os: session::os, lm: LinkMeta) -> ~str {
         session::os_android => (android::DLL_PREFIX, android::DLL_SUFFIX),
         session::os_freebsd => (freebsd::DLL_PREFIX, freebsd::DLL_SUFFIX),
     };
-    return str::from_slice(dll_prefix) + libname +
-           str::from_slice(dll_suffix);
+    return str::to_owned(dll_prefix) + libname +
+           str::to_owned(dll_suffix);
 }
 
 // If the user wants an exe generated we need to invoke

src/librustc/driver/driver.rs

@@ -91,9 +91,9 @@ pub fn default_configuration(sess: Session, argv0: @~str, input: &input) ->
     };
 
     return ~[ // Target bindings.
-         attr::mk_word_item(@str::from_slice(os::FAMILY)),
+         attr::mk_word_item(@str::to_owned(os::FAMILY)),
          mk(@~"target_os", @tos),
-         mk(@~"target_family", @str::from_slice(os::FAMILY)),
+         mk(@~"target_family", @str::to_owned(os::FAMILY)),
          mk(@~"target_arch", @arch),
          mk(@~"target_endian", @end),
          mk(@~"target_word_size", @wordsz),
@@ -648,7 +648,7 @@ pub fn build_session_options(binary: @~str,
     let linker_args = getopts::opt_strs(matches, ~"link-args").flat_map( |a| {
         let mut args = ~[];
         for str::each_split_char(*a, ' ') |arg| {
-            args.push(str::from_slice(arg));
+            args.push(str::to_owned(arg));
         }
         args
     });

src/librustc/metadata/decoder.rs

@@ -619,7 +619,7 @@ pub fn maybe_get_item_ast(intr: @ident_interner, cdata: cmd, tcx: ty::ctxt,
     let item_doc = lookup_item(id, cdata.data);
     let path = {
         let item_path = item_path(intr, item_doc);
-        vec::from_slice(item_path.init())
+        vec::to_owned(item_path.init())
     };
     match decode_inlined_item(cdata, tcx, copy path, item_doc) {
       Some(ref ii) => csearch::found((/*bad*/copy *ii)),

src/librustc/metadata/encoder.rs

@@ -1461,7 +1461,7 @@ pub fn encode_metadata(parms: EncodeParams, crate: &crate) -> ~[u8] {
     //
     // Should be:
     //
-    //   vec::from_slice(metadata_encoding_version) +
+    //   vec::to_owned(metadata_encoding_version) +
 
     let writer_bytes: &mut ~[u8] = wr.bytes;
 

src/librustc/metadata/filesearch.rs

@@ -101,7 +101,7 @@ pub fn mk_filesearch(maybe_sysroot: &Option<@Path>,
     @FileSearchImpl {
         sysroot: sysroot,
         addl_lib_search_paths: addl_lib_search_paths,
-        target_triple: str::from_slice(target_triple)
+        target_triple: str::to_owned(target_triple)
     } as @FileSearch
 }
 
@@ -127,7 +127,7 @@ pub fn search<T:Copy>(filesearch: @FileSearch, pick: pick<T>) -> Option<T> {
 
 pub fn relative_target_lib_path(target_triple: &str) -> Path {
     Path(libdir()).push_many([~"rustc",
-                              str::from_slice(target_triple),
+                              str::to_owned(target_triple),
                               libdir()])
 }
 

src/librustc/metadata/loader.rs

@@ -71,7 +71,7 @@ fn libname(cx: &Context) -> (~str, ~str) {
         os_freebsd => (freebsd::DLL_PREFIX, freebsd::DLL_SUFFIX),
     };
 
-    (str::from_slice(dll_prefix), str::from_slice(dll_suffix))
+    (str::to_owned(dll_prefix), str::to_owned(dll_suffix))
 }
 
 fn find_library_crate_aux(