[WIP] str is dead, long live str([u8])!

src/compiletest/runtest.rs

@@ -30,7 +30,7 @@ use std::io::process;
 use std::io::timer;
 use std::io;
 use std::os;
-use std::str;
+use std::str as str_;
 use std::string::String;
 use std::task;
 use std::time::Duration;
@@ -426,7 +426,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
                                    gdbserver :5039 {}/{}",
                                   config.adb_test_dir.clone(),
                                   config.adb_test_dir.clone(),
-                                  str::from_utf8(
+                                  str_::from_utf8(
                                       exe_file.filename()
                                       .unwrap()).unwrap());
 
@@ -1731,7 +1731,7 @@ fn disassemble_extract(config: &Config, _props: &TestProps,
 
 fn count_extracted_lines(p: &Path) -> uint {
     let x = File::open(&p.with_extension("ll")).read_to_end().unwrap();
-    let x = str::from_utf8(x.as_slice()).unwrap();
+    let x = str_::from_utf8(x.as_slice()).unwrap();
     x.lines().count()
 }
 

src/doc/guide-strings.md

@@ -65,10 +65,10 @@ fn main() {
 You can also get a `&str` from a stack-allocated array of bytes:
 
 ```{rust}
-use std::str;
+use std::str as str_;
 
 let x: &[u8] = &[b'a', b'b'];
-let stack_str: &str = str::from_utf8(x).unwrap();
+let stack_str: &str = str_::from_utf8(x).unwrap();
 ```
 
 # Best Practices

src/doc/guide-unsafe.md

@@ -567,7 +567,7 @@ pub extern fn dot_product(a: *const u32, a_len: u32,
 
 #[lang = "panic_fmt"]
 extern fn panic_fmt(args: &core::fmt::Arguments,
-                       file: &str,
+                       file: &core::str::str,
                        line: uint) -> ! {
     loop {}
 }

src/libcollections/bit.rs

@@ -2028,8 +2028,8 @@ mod tests {
     #[test]
     fn test_from_bytes() {
         let bitv = from_bytes(&[0b10110110, 0b00000000, 0b11111111]);
-        let str = format!("{}{}{}", "10110110", "00000000", "11111111");
-        assert_eq!(bitv.to_string().as_slice(), str.as_slice());
+        let s = format!("{}{}{}", "10110110", "00000000", "11111111");
+        assert_eq!(bitv.to_string().as_slice(), s.as_slice());
     }
 
     #[test]

src/libcollections/hash/mod.rs

@@ -69,6 +69,8 @@ use core::borrow::{Cow, ToOwned};
 use core::intrinsics::TypeId;
 use core::mem;
 use core::num::Int;
+#[cfg(not(stage0))] // NOTE(stage0): Remove cfg after a snapshot
+use core::str::str;
 
 use vec::Vec;
 
@@ -326,6 +328,7 @@ mod tests {
     #[test]
     fn test_writer_hasher() {
         use alloc::boxed::Box;
+        use core::str::str;
 
         let hasher = MyWriterHasher;
 

src/libcollections/lib.rs

@@ -115,4 +115,6 @@ mod std {
     pub use core::clone;    // deriving(Clone)
     pub use core::cmp;      // deriving(Eq, Ord, etc.)
     pub use hash;           // deriving(Hash)
+    #[cfg(not(stage0))] // NOTE(stage0): Remove cfg after a snapshot
+    pub use core::str;
 }

src/libcollections/str.rs

@@ -79,7 +79,12 @@ pub use core::str::{eq_slice, is_utf8, is_utf16, Utf16Items};
 pub use core::str::{Utf16Item, ScalarValue, LoneSurrogate, utf16_items};
 pub use core::str::{truncate_utf16_at_nul, utf8_char_width, CharRange};
 pub use core::str::{FromStr, from_str};
-pub use core::str::{Str, StrPrelude};
+pub use core::str::Str;
+// NOTE(stage0): Remove import after a snapshot
+#[cfg(stage0)]
+pub use core::str::StrPrelude;
+#[cfg(not(stage0))]  // NOTE(stage0): Remove cfg after a snapshot
+pub use core::str::str;
 pub use core::str::{from_utf8_unchecked, from_c_str};
 pub use unicode::str::{UnicodeStrPrelude, Words, Graphemes, GraphemeIndices};
 
@@ -2331,6 +2336,7 @@ mod bench {
     use test::black_box;
     use super::*;
     use std::iter::{IteratorExt, DoubleEndedIteratorExt};
+    #[cfg(stage0)]  // NOTE(stage0): Remove import after a snapshot
     use std::str::StrPrelude;
     use std::slice::SlicePrelude;
 

src/libcollections/string.rs

@@ -14,6 +14,9 @@
 
 use core::prelude::*;
 
+#[cfg(stage0)]  // NOTE(stage0): Remove import after a snapshot
+use core::str::StrPrelude;
+
 use core::borrow::{Cow, IntoCow};
 use core::default::Default;
 use core::fmt;
@@ -22,11 +25,13 @@ use core::ptr;
 use core::ops;
 // FIXME: ICE's abound if you import the `Slice` type while importing `Slice` trait
 use core::raw::Slice as RawSlice;
+#[cfg(not(stage0))] // NOTE(stage0): Remove cfg after a snapshot
+use core::str::str;
 
 use hash;
 use slice::CloneSliceAllocPrelude;
-use str;
 use str::{CharRange, CowString, FromStr, StrAllocating, Owned};
+use str as str_;
 use vec::{DerefVec, Vec, as_vec};
 
 /// A growable string stored as a UTF-8 encoded buffer.
@@ -103,7 +108,7 @@ impl String {
     #[inline]
     #[unstable = "error type may change"]
     pub fn from_utf8(vec: Vec<u8>) -> Result<String, Vec<u8>> {
-        if str::is_utf8(vec.as_slice()) {
+        if str_::is_utf8(vec.as_slice()) {
             Ok(String { vec: vec })
         } else {
             Err(vec)
@@ -122,7 +127,7 @@ impl String {
     /// ```
     #[unstable = "return type may change"]
     pub fn from_utf8_lossy<'a>(v: &'a [u8]) -> CowString<'a> {
-        if str::is_utf8(v) {
+        if str_::is_utf8(v) {
             return Cow::Borrowed(unsafe { mem::transmute(v) })
         }
 
@@ -172,7 +177,7 @@ impl String {
             if byte < 128u8 {
                 // subseqidx handles this
             } else {
-                let w = str::utf8_char_width(byte);
+                let w = str_::utf8_char_width(byte);
 
                 match w {
                     2 => {
@@ -255,10 +260,10 @@ impl String {
     #[unstable = "error value in return may change"]
     pub fn from_utf16(v: &[u16]) -> Option<String> {
         let mut s = String::with_capacity(v.len());
-        for c in str::utf16_items(v) {
+        for c in str_::utf16_items(v) {
             match c {
-                str::ScalarValue(c) => s.push(c),
-                str::LoneSurrogate(_) => return None
+                str_::ScalarValue(c) => s.push(c),
+                str_::LoneSurrogate(_) => return None
             }
         }
         Some(s)
@@ -279,7 +284,7 @@ impl String {
     /// ```
     #[stable]
     pub fn from_utf16_lossy(v: &[u16]) -> String {
-        str::utf16_items(v).map(|c| c.to_char_lossy()).collect()
+        str_::utf16_items(v).map(|c| c.to_char_lossy()).collect()
     }
 
     /// Convert a vector of `char`s to a `String`.
@@ -317,7 +322,7 @@ impl String {
     /// slice is not checked to see whether it contains valid UTF-8
     #[unstable = "just renamed from `mod raw`"]
     pub unsafe fn from_raw_buf(buf: *const u8) -> String {
-        String::from_str(str::from_c_str(buf as *const i8))
+        String::from_str(str_::from_c_str(buf as *const i8))
     }
 
     /// Creates a `String` from a `*const u8` buffer of the given length.
@@ -978,8 +983,10 @@ mod tests {
     use test::Bencher;
 
     use slice::CloneSliceAllocPrelude;
-    use str::{Str, StrPrelude};
-    use str;
+    use str::Str;
+    #[cfg(stage0)]  // NOTE(stage0): Remove import after a snapshot
+    use str::StrPrelude;
+    use str as str_;
     use super::{as_string, String, ToString};
     use vec::Vec;
 
@@ -1011,11 +1018,11 @@ mod tests {
     #[test]
     fn test_from_utf8_lossy() {
         let xs = b"hello";
-        let ys: str::CowString = "hello".into_cow();
+        let ys: str_::CowString = "hello".into_cow();
         assert_eq!(String::from_utf8_lossy(xs), ys);
 
         let xs = "ศไทย中华Việt Nam".as_bytes();
-        let ys: str::CowString = "ศไทย中华Việt Nam".into_cow();
+        let ys: str_::CowString = "ศไทย中华Việt Nam".into_cow();
         assert_eq!(String::from_utf8_lossy(xs), ys);
 
         let xs = b"Hello\xC2 There\xFF Goodbye";
@@ -1095,7 +1102,7 @@ mod tests {
             let s_as_utf16 = s.as_slice().utf16_units().collect::<Vec<u16>>();
             let u_as_string = String::from_utf16(u.as_slice()).unwrap();
 
-            assert!(str::is_utf16(u.as_slice()));
+            assert!(str_::is_utf16(u.as_slice()));
             assert_eq!(s_as_utf16, u);
 
             assert_eq!(u_as_string, s);

src/libcore/fmt/float.rs

@@ -22,6 +22,7 @@ use num::{Float, FPNaN, FPInfinite, ToPrimitive};
 use num::cast;
 use result::Ok;
 use slice::{mod, SlicePrelude};
+#[cfg(stage0)]  // NOTE(stage0): Remove import after a snapshot
 use str::StrPrelude;
 
 /// A flag that specifies whether to use exponential (scientific) notation.

src/libcore/fmt/mod.rs

@@ -23,7 +23,10 @@ use result::{Ok, Err};
 use result;
 use slice::SlicePrelude;
 use slice;
+#[cfg(stage0)]  // NOTE(stage0): Remove import after a snapshot
 use str::StrPrelude;
+#[cfg(not(stage0))]  // NOTE(stage0): Remove cfg after a snapshot
+use str::str;
 
 pub use self::num::radix;
 pub use self::num::Radix;

src/libcore/fmt/num.rs

@@ -18,6 +18,8 @@ use fmt;
 use iter::DoubleEndedIteratorExt;
 use num::{Int, cast};
 use slice::SlicePrelude;
+#[cfg(not(stage0))]  // NOTE(stage0): Remove cfg after a snapshot
+use str::str;
 
 /// A type that represents a specific radix
 #[doc(hidden)]

src/libcore/intrinsics.rs

@@ -42,6 +42,9 @@
 #![experimental]
 #![allow(missing_docs)]
 
+#[cfg(not(stage0))]  // NOTE(stage0): Remove cfg after a snapshot
+use str::str;
+
 pub type GlueFn = extern "Rust" fn(*const i8);
 
 #[lang="ty_desc"]

src/libcore/lib.rs

@@ -142,4 +142,5 @@ mod std {
     pub use kinds;
     pub use option;
     pub use fmt;
+    pub use str;
 }

src/libcore/macros.rs

@@ -10,6 +10,8 @@
 
 #![macro_escape]
 
+// NOTE(stage0): Remove macro after a snapshot
+#[cfg(stage0)]
 /// Entry point of task panic, for details, see std::macros
 #[macro_export]
 macro_rules! panic(
@@ -46,6 +48,44 @@ macro_rules! panic(
     });
 )
 
+#[cfg(not(stage0))]  // NOTE(stage0): Remove cfg after a snapshot
+/// Entry point of task panic, for details, see std::macros
+#[macro_export]
+macro_rules! panic(
+    () => (
+        panic!("{}", "explicit panic")
+    );
+    ($msg:expr) => ({
+        static _MSG_FILE_LINE: (&'static ::std::str::str, &'static ::std::str::str, uint) =
+            ($msg, file!(), line!());
+        ::core::panicking::panic(&_MSG_FILE_LINE)
+    });
+    ($fmt:expr, $($arg:tt)*) => ({
+        // a closure can't have return type !, so we need a full
+        // function to pass to format_args!, *and* we need the
+        // file and line numbers right here; so an inner bare fn
+        // is our only choice.
+        //
+        // LLVM doesn't tend to inline this, presumably because begin_unwind_fmt
+        // is #[cold] and #[inline(never)] and because this is flagged as cold
+        // as returning !. We really do want this to be inlined, however,
+        // because it's just a tiny wrapper. Small wins (156K to 149K in size)
+        // were seen when forcing this to be inlined, and that number just goes
+        // up with the number of calls to panic!()
+        //
+        // The leading _'s are to avoid dead code warnings if this is
+        // used inside a dead function. Just `#[allow(dead_code)]` is
+        // insufficient, since the user may have
+        // `#[forbid(dead_code)]` and which cannot be overridden.
+        #[inline(always)]
+        fn _run_fmt(fmt: &::std::fmt::Arguments) -> ! {
+            static _FILE_LINE: (&'static ::std::str::str, uint) = (file!(), line!());
+            ::core::panicking::panic_fmt(fmt, &_FILE_LINE)
+        }
+        format_args!(_run_fmt, $fmt, $($arg)*)
+    });
+)
+
 /// Runtime assertion, for details see std::macros
 #[macro_export]
 macro_rules! assert(

src/libcore/num/f32.rs

@@ -21,6 +21,8 @@ use mem;
 use num::{Float, FPNormal, FPCategory, FPZero, FPSubnormal, FPInfinite, FPNaN};
 use num::from_str_radix;
 use option::Option;
+#[cfg(not(stage0))]  // NOTE(stage0): Remove cfg after a snapshot
+use str::str;
 
 #[stable]
 pub const RADIX: uint = 2u;

src/libcore/num/f64.rs

@@ -21,6 +21,8 @@ use mem;
 use num::{Float, FPNormal, FPCategory, FPZero, FPSubnormal, FPInfinite, FPNaN};
 use num::from_str_radix;
 use option::Option;
+#[cfg(not(stage0))]  // NOTE(stage0): Remove cfg after a snapshot
+use str::str;
 
 // FIXME(#5527): These constants should be deprecated once associated
 // constants are implemented in favour of referencing the respective

src/libcore/num/mod.rs

@@ -31,7 +31,11 @@ use mem::size_of;
 use ops::{Add, Sub, Mul, Div, Rem, Neg};
 use ops::{Not, BitAnd, BitOr, BitXor, Shl, Shr};
 use option::{Option, Some, None};
-use str::{FromStr, from_str, StrPrelude};
+use str::{FromStr, from_str};
+#[cfg(stage0)]  // NOTE(stage0): Remove import after a snapshot
+use str::StrPrelude;
+#[cfg(not(stage0))]  // NOTE(stage0): Remove cfg after a snapshot
+use str::str;
 
 /// Simultaneous division and remainder
 #[inline]
@@ -1437,8 +1441,8 @@ pub trait FromStrRadix {
 
 /// A utility function that just calls FromStrRadix::from_str_radix.
 #[experimental = "might need to return Result"]
-pub fn from_str_radix<T: FromStrRadix>(str: &str, radix: uint) -> Option<T> {
-    FromStrRadix::from_str_radix(str, radix)
+pub fn from_str_radix<T: FromStrRadix>(s: &str, radix: uint) -> Option<T> {
+    FromStrRadix::from_str_radix(s, radix)
 }
 
 macro_rules! from_str_radix_float_impl {

src/libcore/option.rs

@@ -154,6 +154,8 @@ use slice;
 use slice::AsSlice;
 use clone::Clone;
 use ops::Deref;
+#[cfg(not(stage0))]  // NOTE(stage0): Remove cfg after a snapshot
+use str::str;
 
 // Note that this is not a lang item per se, but it has a hidden dependency on
 // `Iterator`, which is one. The compiler assumes that the `next` method of

src/libcore/panicking.rs

@@ -32,6 +32,8 @@
 
 use fmt;
 use intrinsics;
+#[cfg(not(stage0))]  // NOTE(stage0): Remove cfg after a snapshot
+use str::str;
 
 #[cold] #[inline(never)] // this is the slow path, always
 #[lang="panic"]

src/libcore/prelude.rs

@@ -60,7 +60,9 @@ pub use option::Option::{Some, None};
 pub use ptr::RawPtr;
 pub use result::Result;
 pub use result::Result::{Ok, Err};
-pub use str::{Str, StrPrelude};
+pub use str::Str;
+#[cfg(stage0)]  // NOTE(stage0): Remove import after a snapshot
+pub use str::StrPrelude;
 pub use tuple::{Tuple1, Tuple2, Tuple3, Tuple4};
 pub use tuple::{Tuple5, Tuple6, Tuple7, Tuple8};
 pub use tuple::{Tuple9, Tuple10, Tuple11, Tuple12};