Fix errors

src/libcollections/str.rs

@@ -94,66 +94,26 @@ pub use unicode::{Words, UnicodeStrSlice};
 Section: Creating a string
 */
 
-/// Consumes a vector of bytes to create a new utf-8 string.
-///
-/// Returns `Err` with the original vector if the vector contains invalid
-/// UTF-8.
-///
-/// # Example
-///
-/// ```rust
-/// use std::str;
-/// let hello_vec = vec![104, 101, 108, 108, 111];
-/// let string = str::from_utf8_owned(hello_vec);
-/// assert_eq!(string, Ok("hello".to_string()));
-/// ```
+/// Deprecated. Replaced by `String::from_utf8`
 #[deprecated = "Replaced by `String::from_utf8`"]
 pub fn from_utf8_owned(vv: Vec<u8>) -> Result<String, Vec<u8>> {
     String::from_utf8(vv)
 }
 
-/// Convert a byte to a UTF-8 string
-///
-/// # Failure
-///
-/// Fails if invalid UTF-8
-///
-/// # Example
-///
-/// ```rust
-/// use std::str;
-/// let string = str::from_byte(104);
-/// assert_eq!(string.as_slice(), "h");
-/// ```
+/// Deprecated. Replaced by `String::from_byte`
 #[deprecated = "Replaced by String::from_byte"]
 pub fn from_byte(b: u8) -> String {
     assert!(b < 128u8);
     String::from_char(1, b as char)
 }
 
-/// Convert a char to a string
-///
-/// # Example
-///
-/// ```rust
-/// use std::str;
-/// let string = str::from_char('b');
-/// assert_eq!(string.as_slice(), "b");
-/// ```
+/// Deprecated. Use `String::from_char` or `char::to_string()` instead
 #[deprecated = "use String::from_char or char.to_string()"]
 pub fn from_char(ch: char) -> String {
     String::from_char(1, ch)
 }
 
-/// Convert a vector of chars to a string
-///
-/// # Example
-///
-/// ```rust
-/// let chars = ['h', 'e', 'l', 'l', 'o'];
-/// let string = String::from_chars(chars);
-/// assert_eq!(string.as_slice(), "hello");
-/// ```
+/// Deprecated. Replaced by `String::from_chars`
 #[deprecated = "use String::from_chars instead"]
 pub fn from_chars(chs: &[char]) -> String {
     chs.iter().map(|c| *c).collect()
@@ -649,7 +609,6 @@ pub mod raw {
     #[test]
     fn test_from_buf_len() {
         use slice::ImmutableVector;
-        use str::StrAllocating;
 
         unsafe {
             let a = vec![65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 0u8];
@@ -854,8 +813,7 @@ mod tests {
     use std::default::Default;
     use std::char::Char;
     use std::clone::Clone;
-    use std::cmp::{Equal, Greater, Less, Ord, Eq, PartialOrd, PartialEq, Equiv};
-    use std::result::{Ok, Err};
+    use std::cmp::{Equal, Greater, Less, Ord, PartialOrd, Equiv};
     use std::option::{Some, None};
     use std::ptr::RawPtr;
     use std::iter::{Iterator, DoubleEndedIterator};
@@ -1546,7 +1504,7 @@ mod tests {
         let mut pos = 0;
         for ch in v.iter() {
             assert!(s.char_at(pos) == *ch);
-            pos += from_char(*ch).len();
+            pos += String::from_char(1, *ch).len();
         }
     }
 
@@ -1557,7 +1515,7 @@ mod tests {
         let mut pos = s.len();
         for ch in v.iter().rev() {
             assert!(s.char_at_reverse(pos) == *ch);
-            pos -= from_char(*ch).len();
+            pos -= String::from_char(1, *ch).len();
         }
     }
 
@@ -1996,10 +1954,8 @@ String::from_str("\u1111\u1171\u11b6"));
 mod bench {
     use test::Bencher;
     use super::*;
-    use vec::Vec;
     use std::iter::{Iterator, DoubleEndedIterator};
     use std::collections::Collection;
-    use std::slice::Vector;
 
     #[bench]
     fn char_iterator(b: &mut Bencher) {

src/libcollections/string.rs

@@ -99,7 +99,7 @@ impl String {
     ///
     /// ```rust
     /// let input = b"Hello \xF0\x90\x80World";
-    /// let output = std::str::from_utf8_lossy(input);
+    /// let output = String::from_utf8_lossy(input);
     /// assert_eq!(output.as_slice(), "Hello \uFFFDWorld");
     /// ```
     pub fn from_utf8_lossy<'a>(v: &'a [u8]) -> MaybeOwned<'a> {
@@ -218,18 +218,18 @@ impl String {
         Owned(res.into_string())
     }
 
-    /// Decode a UTF-16 encoded vector `v` into a string, returning `None`
+    /// Decode a UTF-16 encoded vector `v` into a `String`, returning `None`
     /// if `v` contains any invalid data.
     ///
     /// # Example
     ///
     /// ```rust
-    /// // 𝄞music
+    /// // 𝄞music
     /// let mut v = [0xD834, 0xDD1E, 0x006d, 0x0075,
     ///              0x0073, 0x0069, 0x0063];
-    /// assert_eq!(String::from_utf16(v), Some("𝄞music".to_string()));
+    /// assert_eq!(String::from_utf16(v), Some("𝄞music".to_string()));
     ///
-    /// // 𝄞mu<invalid>ic
+    /// // 𝄞mu<invalid>ic
     /// v[4] = 0xD800;
     /// assert_eq!(String::from_utf16(v), None);
     /// ```
@@ -249,13 +249,13 @@ impl String {
     ///
     /// # Example
     /// ```rust
-    /// // 𝄞mus<invalid>ic<invalid>
+    /// // 𝄞mus<invalid>ic<invalid>
     /// let v = [0xD834, 0xDD1E, 0x006d, 0x0075,
     ///          0x0073, 0xDD1E, 0x0069, 0x0063,
     ///          0xD834];
     ///
     /// assert_eq!(String::from_utf16_lossy(v),
-    ///            "𝄞mus\uFFFDic\uFFFD".to_string());
+    ///            "𝄞mus\uFFFDic\uFFFD".to_string());
     /// ```
     pub fn from_utf16_lossy(v: &[u16]) -> String {
         str::utf16_items(v).map(|c| c.to_char_lossy()).collect()
@@ -575,8 +575,9 @@ mod tests {
 
     use Mutable;
     use str;
-    use str::{Str, StrSlice, MaybeOwned, Owned, Slice};
+    use str::{Str, StrSlice, Owned, Slice};
     use super::String;
+    use vec::Vec;
 
     #[test]
     fn test_from_str() {
@@ -587,10 +588,10 @@ mod tests {
     #[test]
     fn test_from_utf8() {
         let xs = Vec::from_slice(b"hello");
-        assert_eq!(String::from_utf8(xs), Ok("hello".to_string()));
+        assert_eq!(String::from_utf8(xs), Ok(String::from_str("hello")));
 
-        let xs = Vec::from_slice("ศไทย中华Việt Nam".as_bytes());
-        assert_eq!(String::from_utf8(xs), Ok("ศไทย中华Việt Nam".to_string()));
+        let xs = Vec::from_slice("ศไทย中华Việt Nam".as_bytes());
+        assert_eq!(String::from_utf8(xs), Ok(String::from_str("ศไทย中华Việt Nam")));
 
         let xs = Vec::from_slice(b"hello\xFF");
         assert_eq!(String::from_utf8(xs),
@@ -602,21 +603,24 @@ mod tests {
         let xs = b"hello";
         assert_eq!(String::from_utf8_lossy(xs), Slice("hello"));
 
-        let xs = "ศไทย中华Việt Nam".as_bytes();
-        assert_eq!(String::from_utf8_lossy(xs), Slice("ศไทย中华Việt Nam"));
+        let xs = "ศไทย中华Việt Nam".as_bytes();
+        assert_eq!(String::from_utf8_lossy(xs), Slice("ศไทย中华Việt Nam"));
 
         let xs = b"Hello\xC2 There\xFF Goodbye";
-        assert_eq!(String::from_utf8_lossy(xs), Owned(String::from_str("Hello\uFFFD There\uFFFD Goodbye")));
+        assert_eq!(String::from_utf8_lossy(xs),
+                   Owned(String::from_str("Hello\uFFFD There\uFFFD Goodbye")));
 
         let xs = b"Hello\xC0\x80 There\xE6\x83 Goodbye";
         assert_eq!(String::from_utf8_lossy(xs),
                    Owned(String::from_str("Hello\uFFFD\uFFFD There\uFFFD Goodbye")));
 
         let xs = b"\xF5foo\xF5\x80bar";
-        assert_eq!(String::from_utf8_lossy(xs), Owned(String::from_str("\uFFFDfoo\uFFFD\uFFFDbar")));
+        assert_eq!(String::from_utf8_lossy(xs),
+                   Owned(String::from_str("\uFFFDfoo\uFFFD\uFFFDbar")));
 
         let xs = b"\xF1foo\xF1\x80bar\xF1\x80\x80baz";
-        assert_eq!(String::from_utf8_lossy(xs), Owned(String::from_str("\uFFFDfoo\uFFFDbar\uFFFDbaz")));
+        assert_eq!(String::from_utf8_lossy(xs),
+                   Owned(String::from_str("\uFFFDfoo\uFFFDbar\uFFFDbaz")));
 
         let xs = b"\xF4foo\xF4\x80bar\xF4\xBFbaz";
         assert_eq!(String::from_utf8_lossy(xs),
@@ -635,13 +639,13 @@ mod tests {
     #[test]
     fn test_from_utf16() {
         let pairs =
-            [(String::from_str("𐍅𐌿𐌻𐍆𐌹𐌻𐌰\n"),
+            [(String::from_str("𐍅𐌿𐌻𐍆𐌹𐌻𐌰\n"),
               vec![0xd800_u16, 0xdf45_u16, 0xd800_u16, 0xdf3f_u16,
                 0xd800_u16, 0xdf3b_u16, 0xd800_u16, 0xdf46_u16,
                 0xd800_u16, 0xdf39_u16, 0xd800_u16, 0xdf3b_u16,
                 0xd800_u16, 0xdf30_u16, 0x000a_u16]),
 
-             (String::from_str("𐐒𐑉𐐮𐑀𐐲𐑋 𐐏𐐲𐑍\n"),
+             (String::from_str("𐐒𐑉𐐮𐑀𐐲𐑋 𐐏𐐲𐑍\n"),
               vec![0xd801_u16, 0xdc12_u16, 0xd801_u16,
                 0xdc49_u16, 0xd801_u16, 0xdc2e_u16, 0xd801_u16,
                 0xdc40_u16, 0xd801_u16, 0xdc32_u16, 0xd801_u16,
@@ -649,7 +653,7 @@ mod tests {
                 0xd801_u16, 0xdc32_u16, 0xd801_u16, 0xdc4d_u16,
                 0x000a_u16]),
 
-             (String::from_str("𐌀𐌖𐌋𐌄𐌑𐌉·𐌌𐌄𐌕𐌄𐌋𐌉𐌑\n"),
+             (String::from_str("𐌀𐌖𐌋𐌄𐌑𐌉·𐌌𐌄𐌕𐌄𐌋𐌉𐌑\n"),
               vec![0xd800_u16, 0xdf00_u16, 0xd800_u16, 0xdf16_u16,
                 0xd800_u16, 0xdf0b_u16, 0xd800_u16, 0xdf04_u16,
                 0xd800_u16, 0xdf11_u16, 0xd800_u16, 0xdf09_u16,
@@ -658,7 +662,7 @@ mod tests {
                 0xdf04_u16, 0xd800_u16, 0xdf0b_u16, 0xd800_u16,
                 0xdf09_u16, 0xd800_u16, 0xdf11_u16, 0x000a_u16 ]),
 
-             (String::from_str("𐒋𐒘𐒈𐒑𐒛𐒒 𐒕𐒓 𐒈𐒚𐒍 𐒏𐒜𐒒𐒖𐒆 𐒕𐒆\n"),
+             (String::from_str("𐒋𐒘𐒈𐒑𐒛𐒒 𐒕𐒓 𐒈𐒚𐒍 𐒏𐒜𐒒𐒖𐒆 𐒕𐒆\n"),
               vec![0xd801_u16, 0xdc8b_u16, 0xd801_u16, 0xdc98_u16,
                 0xd801_u16, 0xdc88_u16, 0xd801_u16, 0xdc91_u16,
                 0xd801_u16, 0xdc9b_u16, 0xd801_u16, 0xdc92_u16,
@@ -718,7 +722,7 @@ mod tests {
 
         // general
         assert_eq!(String::from_utf16_lossy([0xD800, 0xd801, 0xdc8b, 0xD800]),
-                   String::from_str("\uFFFD𐒋\uFFFD"));
+                   String::from_str("\uFFFD𐒋\uFFFD"));
     }
 
     #[test]
@@ -852,7 +856,8 @@ mod tests {
 
     #[bench]
     fn from_utf8_lossy_100_multibyte(b: &mut Bencher) {
-        let s = "𐌀𐌖𐌋𐌄𐌑𐌉ปรدولة الكويتทศไทย中华𐍅𐌿𐌻𐍆𐌹𐌻𐌰".as_bytes();
+        let s = "𐌀𐌖𐌋𐌄𐌑𐌉ปรدولة\
+            الكويتทศไทย中华𐍅𐌿𐌻𐍆𐌹𐌻𐌰".as_bytes();
         assert_eq!(100, s.len());
         b.iter(|| {
             let _ = String::from_utf8_lossy(s);

src/libregex/parse.rs

@@ -13,7 +13,6 @@ use std::cmp;
 use std::fmt;
 use std::iter;
 use std::num;
-use std::str;
 
 /// Static data containing Unicode ranges for general categories and scripts.
 use unicode::regex::{UNICODE_CLASSES, PERLD, PERLS, PERLW};

src/libregex/test/bench.rs

@@ -10,7 +10,6 @@
 #![allow(non_snake_case_functions)]
 
 use std::rand::{Rng, task_rng};
-use std::str;
 use stdtest::Bencher;
 
 use regex::{Regex, NoExpand};

src/librustc/driver/mod.rs

@@ -20,7 +20,6 @@ use metadata;
 use std::any::AnyRefExt;
 use std::io;
 use std::os;
-use std::str;
 use std::task::TaskBuilder;
 
 use syntax::ast;

src/librustc/metadata/encoder.rs

@@ -35,7 +35,6 @@ use std::hash::Hash;
 use std::hash;
 use std::io::MemWriter;
 use std::mem;
-use std::str;
 use std::collections::HashMap;
 use syntax::abi;
 use syntax::ast::*;
@@ -619,7 +618,7 @@ fn encode_visibility(ebml_w: &mut Encoder, visibility: Visibility) {
         Public => 'y',
         Inherited => 'i',
     };
-    ebml_w.wr_str(ch.to_str().as_slice());
+    ebml_w.wr_str(ch.to_string().as_slice());
     ebml_w.end_tag();
 }
 
@@ -1922,5 +1921,5 @@ pub fn encoded_ty(tcx: &ty::ctxt, t: ty::t) -> String {
         tcx: tcx,
         abbrevs: &RefCell::new(HashMap::new())
     }, t);
-    str::from_utf8(wr.get_ref()).unwrap().to_string()
+    String::from_utf8(wr.unwrap()).unwrap()
 }

src/librustdoc/html/highlight.rs

@@ -13,7 +13,6 @@
 //! This module uses libsyntax's lexer to provide token-based highlighting for
 //! the HTML documentation generated by rustdoc.
 
-use std::str;
 use std::io;
 
 use syntax::parse;

src/librustdoc/html/render.rs

@@ -723,9 +723,9 @@ impl<'a> SourceCollector<'a> {
 
         // Remove the utf-8 BOM if any
         let contents = if contents.starts_with("\ufeff") {
-            contents.as_slice().slice_from(3)
+            contents.slice_from(3)
         } else {
-            contents.as_slice()
+            contents
         };
 
         // Create the intermediate directories

src/librustdoc/lib.rs

@@ -29,7 +29,6 @@ extern crate time;
 
 use std::io;
 use std::io::{File, MemWriter};
-use std::str;
 use std::gc::Gc;
 use serialize::{json, Decodable, Encodable};
 use externalfiles::ExternalHtml;

src/libstd/ascii.rs

@@ -19,7 +19,6 @@ use mem;
 use option::{Option, Some, None};
 use slice::{ImmutableVector, MutableVector, Vector};
 use str::{OwnedStr, Str, StrAllocating, StrSlice};
-use str;
 use string::String;
 use to_str::{IntoStr};
 use vec::Vec;
@@ -676,8 +675,8 @@ mod tests {
         while i <= 500 {
             let upper = if 'a' as u32 <= i && i <= 'z' as u32 { i + 'A' as u32 - 'a' as u32 }
                         else { i };
-            assert_eq!((from_u32(i).unwrap()).to_str().as_slice().to_ascii_upper(),
-                       (from_u32(upper).unwrap()).to_str())
+            assert_eq!((from_u32(i).unwrap()).to_string().as_slice().to_ascii_upper(),
+                       (from_u32(upper).unwrap()).to_string())
             i += 1;
         }
     }
@@ -692,8 +691,8 @@ mod tests {
         while i <= 500 {
             let lower = if 'A' as u32 <= i && i <= 'Z' as u32 { i + 'a' as u32 - 'A' as u32 }
                         else { i };
-            assert_eq!((from_u32(i).unwrap()).to_str().as_slice().to_ascii_lower(),
-                       (from_u32(lower).unwrap()).to_str())
+            assert_eq!((from_u32(i).unwrap()).to_string().as_slice().to_ascii_lower(),
+                       (from_u32(lower).unwrap()).to_string())
             i += 1;
         }
     }
@@ -708,8 +707,8 @@ mod tests {
         while i <= 500 {
             let upper = if 'a' as u32 <= i && i <= 'z' as u32 { i + 'A' as u32 - 'a' as u32 }
                         else { i };
-            assert_eq!((from_u32(i).unwrap()).to_str().into_ascii_upper(),
-                       (from_u32(upper).unwrap()).to_str())
+            assert_eq!((from_u32(i).unwrap()).to_string().into_ascii_upper(),
+                       (from_u32(upper).unwrap()).to_string())
             i += 1;
         }
     }
@@ -725,8 +724,8 @@ mod tests {
         while i <= 500 {
             let lower = if 'A' as u32 <= i && i <= 'Z' as u32 { i + 'a' as u32 - 'A' as u32 }
                         else { i };
-            assert_eq!((from_u32(i).unwrap()).to_str().into_ascii_lower(),
-                       (from_u32(lower).unwrap()).to_str())
+            assert_eq!((from_u32(i).unwrap()).to_string().into_ascii_lower(),
+                       (from_u32(lower).unwrap()).to_string())
             i += 1;
         }
     }
@@ -746,8 +745,8 @@ mod tests {
             let c = i;
             let lower = if 'A' as u32 <= c && c <= 'Z' as u32 { c + 'a' as u32 - 'A' as u32 }
                         else { c };
-            assert!((from_u32(i).unwrap()).to_str().as_slice().eq_ignore_ascii_case(
-                    (from_u32(lower).unwrap()).to_str().as_slice()));
+            assert!((from_u32(i).unwrap()).to_string().as_slice().eq_ignore_ascii_case(
+                    (from_u32(lower).unwrap()).to_string().as_slice()));
             i += 1;
         }
     }

src/libstd/fmt.rs

@@ -417,10 +417,7 @@ the `}` character is escaped with `}}`.
 use io::Writer;
 use io;
 use result::{Ok, Err};
-use str::{Str, StrAllocating};
-use str;
 use string;
-use slice::Vector;
 
 pub use core::fmt::{Formatter, Result, FormatWriter, rt};
 pub use core::fmt::{Show, Bool, Char, Signed, Unsigned, Octal, Binary};
@@ -464,7 +461,7 @@ pub use core::fmt::{secret_pointer};
 pub fn format(args: &Arguments) -> string::String{
     let mut output = io::MemWriter::new();
     let _ = write!(&mut output, "{}", args);
-    String::from_utf8(output.unwrap()).unwrap()
+    string::String::from_utf8(output.unwrap()).unwrap()
 }
 
 impl<'a> Writer for Formatter<'a> {

src/libstd/io/process.rs

@@ -14,7 +14,6 @@
 
 use prelude::*;
 
-use str;
 use fmt;
 use os;
 use io::{IoResult, IoError};

src/libstd/os.rs

@@ -151,7 +151,6 @@ pub mod win32 {
     use slice::{MutableVector, ImmutableVector};
     use string::String;
     use str::StrSlice;
-    use str;
     use vec::Vec;
 
     pub fn fill_utf16_buf_and_decode(f: |*mut u16, DWORD| -> DWORD)

src/libstd/rt/backtrace.rs

@@ -992,7 +992,6 @@ mod imp {
 mod test {
     use prelude::*;
     use io::MemWriter;
-    use str;
 
     macro_rules! t( ($a:expr, $b:expr) => ({
         let mut m = MemWriter::new();

src/libsyntax/ext/source_util.rs

@@ -22,7 +22,6 @@ use print::pprust;
 use std::gc::Gc;
 use std::io::File;
 use std::rc::Rc;
-use std::str;
 
 // These macros all relate to the file system; they either return
 // the column/row/filename of the expression, or they include

src/libsyntax/print/pprust.rs

@@ -30,7 +30,6 @@ use std::gc::Gc;
 use std::io::{IoResult, MemWriter};
 use std::io;
 use std::mem;
-use std::str;
 
 pub enum AnnNode<'a> {
     NodeBlock(&'a ast::Block),

src/libterm/terminfo/parser/compiled.rs

@@ -14,7 +14,6 @@
 
 use std::collections::HashMap;
 use std::io;
-use std::str;
 use super::super::TermInfo;
 
 // These are the orders ncurses uses in its compiled format (as of 5.9). Not sure if portable.

src/libterm/terminfo/searcher.rs

@@ -14,7 +14,7 @@
 
 use std::io::File;
 use std::os::getenv;
-use std::{os, str};
+use std::os;
 
 /// Return path to database entry for `term`
 pub fn get_dbpath_for_term(term: &str) -> Option<Box<Path>> {
@@ -59,7 +59,7 @@ pub fn get_dbpath_for_term(term: &str) -> Option<Box<Path>> {
     // Look for the terminal in all of the search directories
     for p in dirs_to_search.iter() {
         if p.exists() {
-            let f = first_char.to_str();
+            let f = first_char.to_string();
             let newp = p.join_many([f.as_slice(), term]);
             if newp.exists() {
                 return Some(box newp);

src/libtest/stats.rs

@@ -457,7 +457,6 @@ mod tests {
     use stats::write_5_number_summary;
     use stats::write_boxplot;
     use std::io;
-    use std::str;
     use std::f64;
 
     macro_rules! assert_approx_eq(

src/libtime/lib.rs

@@ -31,7 +31,6 @@ extern crate libc;
 use std::io::BufReader;
 use std::num;
 use std::string::String;
-use std::str;
 
 static NSEC_PER_SEC: i32 = 1_000_000_000_i32;
 

src/libuuid/lib.rs

@@ -81,7 +81,6 @@ use std::num::FromStrRadix;
 use std::rand;
 use std::rand::Rng;
 use std::slice;
-use std::str;
 
 use serialize::{Encoder, Encodable, Decoder, Decodable};
 

src/test/run-pass/issue-3563-3.rs

@@ -20,7 +20,6 @@
 // Extern mod controls linkage. Use controls the visibility of names to modules that are
 // already linked in. Using WriterUtil allows us to use the write_line method.
 
-use std::str;
 use std::slice;
 use std::fmt;