libcore: Remove all uses of ~str from libcore.

[breaking-change]

Author: pcwalton

src/compiletest/compiletest.rs

@@ -323,11 +323,15 @@ pub fn is_test(config: &Config, testfile: &Path) -> bool {
     let mut valid = false;
 
     for ext in valid_extensions.iter() {
-        if name.ends_with(*ext) { valid = true; }
+        if name.ends_with(ext.as_slice()) {
+            valid = true;
+        }
     }
 
     for pre in invalid_prefixes.iter() {
-        if name.starts_with(*pre) { valid = false; }
+        if name.starts_with(pre.as_slice()) {
+            valid = false;
+        }
     }
 
     return valid;

src/compiletest/errors.rs

@@ -24,7 +24,7 @@ pub fn load_errors(re: &Regex, testfile: &Path) -> Vec<ExpectedError> {
     let mut rdr = BufferedReader::new(File::open(testfile).unwrap());
 
     rdr.lines().enumerate().filter_map(|(line_no, ln)| {
-        parse_expected(line_no + 1, ln.unwrap(), re)
+        parse_expected(line_no + 1, ln.unwrap().as_slice(), re)
     }).collect()
 }
 

src/compiletest/procsrv.rs

@@ -15,7 +15,8 @@ use std::unstable::dynamic_lib::DynamicLibrary;
 
 fn target_env(lib_path: &str, prog: &str) -> Vec<(StrBuf, StrBuf)> {
     let prog = if cfg!(windows) {prog.slice_to(prog.len() - 4)} else {prog};
-    let aux_path = prog + ".libaux";
+    let mut aux_path = prog.to_strbuf();
+    aux_path.push_str(".libaux");
 
     // Need to be sure to put both the lib_path and the aux path in the dylib
     // search path for the child.

src/compiletest/runtest.rs

@@ -351,7 +351,10 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
                               cmds,
                               "quit".to_strbuf()].connect("\n");
             debug!("script_str = {}", script_str);
-            dump_output_file(config, testfile, script_str, "debugger.script");
+            dump_output_file(config,
+                             testfile,
+                             script_str.as_slice(),
+                             "debugger.script");
 
 
             procsrv::run("",
@@ -459,7 +462,10 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
                 "quit\n".to_strbuf()
             ].connect("\n");
             debug!("script_str = {}", script_str);
-            dump_output_file(config, testfile, script_str, "debugger.script");
+            dump_output_file(config,
+                             testfile,
+                             script_str.as_slice(),
+                             "debugger.script");
 
             // run debugger script with gdb
             #[cfg(windows)]
@@ -553,7 +559,10 @@ fn run_debuginfo_lldb_test(config: &Config, props: &TestProps, testfile: &Path)
 
     // Write the script into a file
     debug!("script_str = {}", script_str);
-    dump_output_file(config, testfile, script_str.into_owned(), "debugger.script");
+    dump_output_file(config,
+                     testfile,
+                     script_str.as_slice(),
+                     "debugger.script");
     let debugger_script = make_out_name(config, testfile, "debugger.script");
 
     // Let LLDB execute the script via lldb_batchmode.py
@@ -610,8 +619,8 @@ fn parse_debugger_commands(file_path: &Path, debugger_prefix: &str)
                            -> DebuggerCommands {
     use std::io::{BufferedReader, File};
 
-    let command_directive = debugger_prefix + "-command";
-    let check_directive = debugger_prefix + "-check";
+    let command_directive = format!("{}-command", debugger_prefix);
+    let check_directive = format!("{}-check", debugger_prefix);
 
     let mut breakpoint_lines = vec!();
     let mut commands = vec!();

src/doc/complement-cheatsheet.md

@@ -60,8 +60,8 @@ To return an Owned String (StrBuf) use the str helper function [`from_utf8_owned
 ~~~
 use std::str;
 
-let x: Result<StrBuf,~[u8]> =
-    str::from_utf8_owned(~[104u8,105u8]).map(|x| x.to_strbuf());
+let x: Option<StrBuf> =
+    str::from_utf8([ 104u8, 105u8 ]).map(|x| x.to_strbuf());
 let y: StrBuf = x.unwrap();
 ~~~
 

src/liballoc/heap.rs

@@ -116,18 +116,18 @@ pub fn stats_print() {
     }
 }
 
+// The compiler never calls `exchange_free` on ~ZeroSizeType, so zero-size
+// allocations can point to this `static`. It would be incorrect to use a null
+// pointer, due to enums assuming types like unique pointers are never null.
+pub static mut EMPTY: uint = 12345;
+
 /// The allocator for unique pointers.
 #[cfg(not(test))]
 #[lang="exchange_malloc"]
 #[inline]
 unsafe fn exchange_malloc(size: uint, align: uint) -> *mut u8 {
-    // The compiler never calls `exchange_free` on ~ZeroSizeType, so zero-size
-    // allocations can point to this `static`. It would be incorrect to use a null
-    // pointer, due to enums assuming types like unique pointers are never null.
-    static EMPTY: () = ();
-
     if size == 0 {
-        &EMPTY as *() as *mut u8
+        &EMPTY as *uint as *mut u8
     } else {
         allocate(size, align)
     }

src/liballoc/util.rs

@@ -28,3 +28,20 @@ fn align_to(size: uint, align: uint) -> uint {
     assert!(align != 0);
     (size + align - 1) & !(align - 1)
 }
+
+// FIXME(#14344): When linking liballoc with libstd, this library will be linked
+//                as an rlib (it only exists as an rlib). It turns out that an
+//                optimized standard library doesn't actually use *any* symbols
+//                from this library. Everything is inlined and optimized away.
+//                This means that linkers will actually omit the object for this
+//                file, even though it may be needed in the future.
+//
+//                To get around this for now, we define a dummy symbol which
+//                will never get inlined so the stdlib can call it. The stdlib's
+//                reference to this symbol will cause this library's object file
+//                to get linked in to libstd successfully (the linker won't
+//                optimize it out).
+#[deprecated]
+#[doc(hidden)]
+pub fn make_stdlib_link_work() {}
+

src/libcollections/bitv.rs

@@ -1330,7 +1330,7 @@ mod tests {
     #[test]
     fn test_from_bytes() {
         let bitv = from_bytes([0b10110110, 0b00000000, 0b11111111]);
-        let str = "10110110".to_owned() + "00000000" + "11111111";
+        let str = format!("{}{}{}", "10110110", "00000000", "11111111");
         assert_eq!(bitv.to_str(), str);
     }
 

src/libcore/any.rs

@@ -119,7 +119,7 @@ mod tests {
     use prelude::*;
     use super::*;
     use realstd::owned::{Box, AnyOwnExt};
-    use realstd::str::StrAllocating;
+    use realstd::str::{Str, StrAllocating};
 
     #[deriving(Eq, Show)]
     struct Test;
@@ -249,13 +249,17 @@ mod tests {
         use realstd::to_str::ToStr;
         let a = box 8u as Box<::realstd::any::Any>;
         let b = box Test as Box<::realstd::any::Any>;
-        assert_eq!(a.to_str(), "Box<Any>".to_owned());
-        assert_eq!(b.to_str(), "Box<Any>".to_owned());
+        let a_str = a.to_str();
+        let b_str = b.to_str();
+        assert_eq!(a_str.as_slice(), "Box<Any>");
+        assert_eq!(b_str.as_slice(), "Box<Any>");
 
         let a = &8u as &Any;
         let b = &Test as &Any;
-        assert_eq!(format!("{}", a), "&Any".to_owned());
-        assert_eq!(format!("{}", b), "&Any".to_owned());
+        let s = format!("{}", a);
+        assert_eq!(s.as_slice(), "&Any");
+        let s = format!("{}", b);
+        assert_eq!(s.as_slice(), "&Any");
     }
 }
 

src/libcore/bool.rs

@@ -242,8 +242,10 @@ mod tests {
 
     #[test]
     fn test_to_str() {
-        assert_eq!(false.to_str(), "false".to_owned());
-        assert_eq!(true.to_str(), "true".to_owned());
+        let s = false.to_str();
+        assert_eq!(s.as_slice(), "false");
+        let s = true.to_str();
+        assert_eq!(s.as_slice(), "true");
     }
 
     #[test]

src/libcore/cell.rs

@@ -404,12 +404,13 @@ mod test {
     #[test]
     fn cell_has_sensible_show() {
         use str::StrSlice;
+        use realstd::str::Str;
 
         let x = Cell::new("foo bar");
-        assert!(format!("{}", x).contains(x.get()));
+        assert!(format!("{}", x).as_slice().contains(x.get()));
 
         x.set("baz qux");
-        assert!(format!("{}", x).contains(x.get()));
+        assert!(format!("{}", x).as_slice().contains(x.get()));
     }
 
     #[test]

src/libcore/char.rs

@@ -637,7 +637,7 @@ mod test {
     use slice::ImmutableVector;
     use option::{Some, None};
     use realstd::strbuf::StrBuf;
-    use realstd::str::StrAllocating;
+    use realstd::str::{Str, StrAllocating};
 
     #[test]
     fn test_is_lowercase() {
@@ -742,46 +742,65 @@ mod test {
 
     #[test]
     fn test_escape_default() {
-        fn string(c: char) -> ~str {
+        fn string(c: char) -> StrBuf {
             let mut result = StrBuf::new();
             escape_default(c, |c| { result.push_char(c); });
-            return result.into_owned();
+            return result;
         }
-        assert_eq!(string('\n'), "\\n".to_owned());
-        assert_eq!(string('\r'), "\\r".to_owned());
-        assert_eq!(string('\''), "\\'".to_owned());
-        assert_eq!(string('"'), "\\\"".to_owned());
-        assert_eq!(string(' '), " ".to_owned());
-        assert_eq!(string('a'), "a".to_owned());
-        assert_eq!(string('~'), "~".to_owned());
-        assert_eq!(string('\x00'), "\\x00".to_owned());
-        assert_eq!(string('\x1f'), "\\x1f".to_owned());
-        assert_eq!(string('\x7f'), "\\x7f".to_owned());
-        assert_eq!(string('\xff'), "\\xff".to_owned());
-        assert_eq!(string('\u011b'), "\\u011b".to_owned());
-        assert_eq!(string('\U0001d4b6'), "\\U0001d4b6".to_owned());
+        let s = string('\n');
+        assert_eq!(s.as_slice(), "\\n");
+        let s = string('\r');
+        assert_eq!(s.as_slice(), "\\r");
+        let s = string('\'');
+        assert_eq!(s.as_slice(), "\\'");
+        let s = string('"');
+        assert_eq!(s.as_slice(), "\\\"");
+        let s = string(' ');
+        assert_eq!(s.as_slice(), " ");
+        let s = string('a');
+        assert_eq!(s.as_slice(), "a");
+        let s = string('~');
+        assert_eq!(s.as_slice(), "~");
+        let s = string('\x00');
+        assert_eq!(s.as_slice(), "\\x00");
+        let s = string('\x1f');
+        assert_eq!(s.as_slice(), "\\x1f");
+        let s = string('\x7f');
+        assert_eq!(s.as_slice(), "\\x7f");
+        let s = string('\xff');
+        assert_eq!(s.as_slice(), "\\xff");
+        let s = string('\u011b');
+        assert_eq!(s.as_slice(), "\\u011b");
+        let s = string('\U0001d4b6');
+        assert_eq!(s.as_slice(), "\\U0001d4b6");
     }
 
     #[test]
     fn test_escape_unicode() {
-        fn string(c: char) -> ~str {
+        fn string(c: char) -> StrBuf {
             let mut result = StrBuf::new();
             escape_unicode(c, |c| { result.push_char(c); });
-            return result.into_owned();
+            return result;
         }
-        assert_eq!(string('\x00'), "\\x00".to_owned());
-        assert_eq!(string('\n'), "\\x0a".to_owned());
-        assert_eq!(string(' '), "\\x20".to_owned());
-        assert_eq!(string('a'), "\\x61".to_owned());
-        assert_eq!(string('\u011b'), "\\u011b".to_owned());
-        assert_eq!(string('\U0001d4b6'), "\\U0001d4b6".to_owned());
+        let s = string('\x00');
+        assert_eq!(s.as_slice(), "\\x00");
+        let s = string('\n');
+        assert_eq!(s.as_slice(), "\\x0a");
+        let s = string(' ');
+        assert_eq!(s.as_slice(), "\\x20");
+        let s = string('a');
+        assert_eq!(s.as_slice(), "\\x61");
+        let s = string('\u011b');
+        assert_eq!(s.as_slice(), "\\u011b");
+        let s = string('\U0001d4b6');
+        assert_eq!(s.as_slice(), "\\U0001d4b6");
     }
 
     #[test]
     fn test_to_str() {
         use realstd::to_str::ToStr;
         let s = 't'.to_str();
-        assert_eq!(s, "t".to_owned());
+        assert_eq!(s.as_slice(), "t");
     }
 
     #[test]

src/libcore/cmp.rs

@@ -171,7 +171,7 @@ pub trait Ord: Eq {
 /// The equivalence relation. Two values may be equivalent even if they are
 /// of different types. The most common use case for this relation is
 /// container types; e.g. it is often desirable to be able to use `&str`
-/// values to look up entries in a container with `~str` keys.
+/// values to look up entries in a container with `StrBuf` keys.
 pub trait Equiv<T> {
     /// Implement this function to decide equivalent values.
     fn equiv(&self, other: &T) -> bool;

src/libcore/fmt/mod.rs

@@ -594,7 +594,7 @@ pub fn argument<'a, T>(f: extern "Rust" fn(&T, &mut Formatter) -> Result,
 }
 
 #[cfg(test)]
-pub fn format(args: &Arguments) -> ~str {
+pub fn format(args: &Arguments) -> ::realstd::strbuf::StrBuf {
     use str;
     use realstd::str::StrAllocating;
     use realstd::io::MemWriter;
@@ -613,7 +613,10 @@ pub fn format(args: &Arguments) -> ~str {
 
     let mut i = MemWriter::new();
     let _ = write(&mut i, args);
-    str::from_utf8(i.get_ref()).unwrap().to_owned()
+
+    let mut result = ::realstd::strbuf::StrBuf::new();
+    result.push_str(str::from_utf8(i.get_ref()).unwrap());
+    result
 }
 
 /// When the compiler determines that the type of an argument *must* be a string
@@ -761,7 +764,6 @@ macro_rules! delegate(($ty:ty to $other:ident) => {
         }
     }
 })
-delegate!(~str to string)
 delegate!(&'a str to string)
 delegate!(bool to bool)
 delegate!(char to char)