diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs index db9cf358a9b99..fa5d85111daf1 100644 --- a/src/compiletest/compiletest.rs +++ b/src/compiletest/compiletest.rs @@ -96,7 +96,7 @@ pub fn parse_config(args: Vec ) -> Config { let args_ = args.tail(); if args.get(1).as_slice() == "-h" || args.get(1).as_slice() == "--help" { let message = format!("Usage: {} [OPTIONS] [TESTNAME...]", argv0); - println!("{}", getopts::usage(message, groups.as_slice())); + println!("{}", getopts::usage(message.as_slice(), groups.as_slice())); println!(""); fail!() } @@ -109,7 +109,7 @@ pub fn parse_config(args: Vec ) -> Config { if matches.opt_present("h") || matches.opt_present("help") { let message = format!("Usage: {} [OPTIONS] [TESTNAME...]", argv0); - println!("{}", getopts::usage(message, groups.as_slice())); + println!("{}", getopts::usage(message.as_slice(), groups.as_slice())); println!(""); fail!() } @@ -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; diff --git a/src/compiletest/errors.rs b/src/compiletest/errors.rs index 408206b16e998..534e04ccb2daa 100644 --- a/src/compiletest/errors.rs +++ b/src/compiletest/errors.rs @@ -24,7 +24,7 @@ pub fn load_errors(re: &Regex, testfile: &Path) -> Vec { 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() } diff --git a/src/compiletest/header.rs b/src/compiletest/header.rs index 5729a11d7ad7e..55fca1784ded5 100644 --- a/src/compiletest/header.rs +++ b/src/compiletest/header.rs @@ -157,9 +157,14 @@ fn iter_header(testfile: &Path, it: |&str| -> bool) -> bool { // module or function. This doesn't seem to be an optimization // with a warm page cache. Maybe with a cold one. let ln = ln.unwrap(); - if ln.starts_with("fn") || ln.starts_with("mod") { + if ln.as_slice().starts_with("fn") || + ln.as_slice().starts_with("mod") { return true; - } else { if !(it(ln.trim())) { return false; } } + } else { + if !(it(ln.as_slice().trim())) { + return false; + } + } } return true; } diff --git a/src/compiletest/procsrv.rs b/src/compiletest/procsrv.rs index 6b273c2d46345..2622cf0e5f1c5 100644 --- a/src/compiletest/procsrv.rs +++ b/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. diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs index 8c2b34ff35d37..c591c477563ee 100644 --- a/src/compiletest/runtest.rs +++ b/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)] @@ -538,7 +544,8 @@ fn run_debuginfo_lldb_test(config: &Config, props: &TestProps, testfile: &Path) // Set breakpoints on every line that contains the string "#break" for line in breakpoint_lines.iter() { - script_str.push_str(format!("breakpoint set --line {}\n", line)); + script_str.push_str(format!("breakpoint set --line {}\n", + line).as_slice()); } // Append the other commands @@ -552,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 @@ -609,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!(); @@ -620,18 +630,18 @@ fn parse_debugger_commands(file_path: &Path, debugger_prefix: &str) for line in reader.lines() { match line { Ok(line) => { - if line.contains("#break") { + if line.as_slice().contains("#break") { breakpoint_lines.push(counter); } header::parse_name_value_directive( - line, + line.as_slice(), command_directive.to_strbuf()).map(|cmd| { commands.push(cmd) }); header::parse_name_value_directive( - line, + line.as_slice(), check_directive.to_strbuf()).map(|cmd| { check_lines.push(cmd) }); diff --git a/src/doc/complement-cheatsheet.md b/src/doc/complement-cheatsheet.md index 4670a2922cf8c..99f7c229d4e36 100644 --- a/src/doc/complement-cheatsheet.md +++ b/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 = - str::from_utf8_owned(~[104u8,105u8]).map(|x| x.to_strbuf()); +let x: Option = + str::from_utf8([ 104u8, 105u8 ]).map(|x| x.to_strbuf()); let y: StrBuf = x.unwrap(); ~~~ diff --git a/src/liballoc/heap.rs b/src/liballoc/heap.rs index 631b72cb8978e..8376fc578dba2 100644 --- a/src/liballoc/heap.rs +++ b/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) } diff --git a/src/liballoc/util.rs b/src/liballoc/util.rs index 7e35af79eab1c..64d620358903e 100644 --- a/src/liballoc/util.rs +++ b/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() {} + diff --git a/src/libcollections/bitv.rs b/src/libcollections/bitv.rs index e2934efa43b65..82cca507c4da7 100644 --- a/src/libcollections/bitv.rs +++ b/src/libcollections/bitv.rs @@ -538,7 +538,7 @@ impl Bitv { * The resulting string has the same length as `self`, and each * character is either '0' or '1'. */ - pub fn to_str(&self) -> ~str { + pub fn to_str(&self) -> StrBuf { let mut rs = StrBuf::new(); for i in self.iter() { if i { @@ -547,7 +547,7 @@ impl Bitv { rs.push_char('0'); } }; - rs.into_owned() + 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); } diff --git a/src/libcore/any.rs b/src/libcore/any.rs index 61c1193e51597..94ac344db3485 100644 --- a/src/libcore/any.rs +++ b/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".to_owned()); - assert_eq!(b.to_str(), "Box".to_owned()); + let a_str = a.to_str(); + let b_str = b.to_str(); + assert_eq!(a_str.as_slice(), "Box"); + assert_eq!(b_str.as_slice(), "Box"); 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"); } } diff --git a/src/libcore/bool.rs b/src/libcore/bool.rs index 2a44d1417198b..ddfdbca196c66 100644 --- a/src/libcore/bool.rs +++ b/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] diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs index 093b3f57047ca..3ad2ebb9f0a28 100644 --- a/src/libcore/cell.rs +++ b/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] diff --git a/src/libcore/char.rs b/src/libcore/char.rs index 6e9d4c9bafbf6..f3942dfd753a4 100644 --- a/src/libcore/char.rs +++ b/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] diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs index a50108607ce71..bf1f3ee310ccd 100644 --- a/src/libcore/cmp.rs +++ b/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 { /// Implement this function to decide equivalent values. fn equiv(&self, other: &T) -> bool; diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs index af492dc295aca..cc965bc6eed39 100644 --- a/src/libcore/fmt/mod.rs +++ b/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) diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs index d9a3271378125..75f67c3df65d7 100644 --- a/src/libcore/fmt/num.rs +++ b/src/libcore/fmt/num.rs @@ -194,7 +194,7 @@ mod tests { use fmt::radix; use super::{Binary, Octal, Decimal, LowerHex, UpperHex}; use super::{GenericRadix, Radix}; - use realstd::str::StrAllocating; + use realstd::str::{Str, StrAllocating}; #[test] fn test_radix_base() { @@ -246,143 +246,143 @@ mod tests { // Formatting integers should select the right implementation based off // the type of the argument. Also, hex/octal/binary should be defined // for integers, but they shouldn't emit the negative sign. - assert_eq!(format!("{}", 1i), "1".to_owned()); - assert_eq!(format!("{}", 1i8), "1".to_owned()); - assert_eq!(format!("{}", 1i16), "1".to_owned()); - assert_eq!(format!("{}", 1i32), "1".to_owned()); - assert_eq!(format!("{}", 1i64), "1".to_owned()); - assert_eq!(format!("{:d}", -1i), "-1".to_owned()); - assert_eq!(format!("{:d}", -1i8), "-1".to_owned()); - assert_eq!(format!("{:d}", -1i16), "-1".to_owned()); - assert_eq!(format!("{:d}", -1i32), "-1".to_owned()); - assert_eq!(format!("{:d}", -1i64), "-1".to_owned()); - assert_eq!(format!("{:t}", 1i), "1".to_owned()); - assert_eq!(format!("{:t}", 1i8), "1".to_owned()); - assert_eq!(format!("{:t}", 1i16), "1".to_owned()); - assert_eq!(format!("{:t}", 1i32), "1".to_owned()); - assert_eq!(format!("{:t}", 1i64), "1".to_owned()); - assert_eq!(format!("{:x}", 1i), "1".to_owned()); - assert_eq!(format!("{:x}", 1i8), "1".to_owned()); - assert_eq!(format!("{:x}", 1i16), "1".to_owned()); - assert_eq!(format!("{:x}", 1i32), "1".to_owned()); - assert_eq!(format!("{:x}", 1i64), "1".to_owned()); - assert_eq!(format!("{:X}", 1i), "1".to_owned()); - assert_eq!(format!("{:X}", 1i8), "1".to_owned()); - assert_eq!(format!("{:X}", 1i16), "1".to_owned()); - assert_eq!(format!("{:X}", 1i32), "1".to_owned()); - assert_eq!(format!("{:X}", 1i64), "1".to_owned()); - assert_eq!(format!("{:o}", 1i), "1".to_owned()); - assert_eq!(format!("{:o}", 1i8), "1".to_owned()); - assert_eq!(format!("{:o}", 1i16), "1".to_owned()); - assert_eq!(format!("{:o}", 1i32), "1".to_owned()); - assert_eq!(format!("{:o}", 1i64), "1".to_owned()); - - assert_eq!(format!("{}", 1u), "1".to_owned()); - assert_eq!(format!("{}", 1u8), "1".to_owned()); - assert_eq!(format!("{}", 1u16), "1".to_owned()); - assert_eq!(format!("{}", 1u32), "1".to_owned()); - assert_eq!(format!("{}", 1u64), "1".to_owned()); - assert_eq!(format!("{:u}", 1u), "1".to_owned()); - assert_eq!(format!("{:u}", 1u8), "1".to_owned()); - assert_eq!(format!("{:u}", 1u16), "1".to_owned()); - assert_eq!(format!("{:u}", 1u32), "1".to_owned()); - assert_eq!(format!("{:u}", 1u64), "1".to_owned()); - assert_eq!(format!("{:t}", 1u), "1".to_owned()); - assert_eq!(format!("{:t}", 1u8), "1".to_owned()); - assert_eq!(format!("{:t}", 1u16), "1".to_owned()); - assert_eq!(format!("{:t}", 1u32), "1".to_owned()); - assert_eq!(format!("{:t}", 1u64), "1".to_owned()); - assert_eq!(format!("{:x}", 1u), "1".to_owned()); - assert_eq!(format!("{:x}", 1u8), "1".to_owned()); - assert_eq!(format!("{:x}", 1u16), "1".to_owned()); - assert_eq!(format!("{:x}", 1u32), "1".to_owned()); - assert_eq!(format!("{:x}", 1u64), "1".to_owned()); - assert_eq!(format!("{:X}", 1u), "1".to_owned()); - assert_eq!(format!("{:X}", 1u8), "1".to_owned()); - assert_eq!(format!("{:X}", 1u16), "1".to_owned()); - assert_eq!(format!("{:X}", 1u32), "1".to_owned()); - assert_eq!(format!("{:X}", 1u64), "1".to_owned()); - assert_eq!(format!("{:o}", 1u), "1".to_owned()); - assert_eq!(format!("{:o}", 1u8), "1".to_owned()); - assert_eq!(format!("{:o}", 1u16), "1".to_owned()); - assert_eq!(format!("{:o}", 1u32), "1".to_owned()); - assert_eq!(format!("{:o}", 1u64), "1".to_owned()); + assert!(format!("{}", 1i).as_slice() == "1"); + assert!(format!("{}", 1i8).as_slice() == "1"); + assert!(format!("{}", 1i16).as_slice() == "1"); + assert!(format!("{}", 1i32).as_slice() == "1"); + assert!(format!("{}", 1i64).as_slice() == "1"); + assert!(format!("{:d}", -1i).as_slice() == "-1"); + assert!(format!("{:d}", -1i8).as_slice() == "-1"); + assert!(format!("{:d}", -1i16).as_slice() == "-1"); + assert!(format!("{:d}", -1i32).as_slice() == "-1"); + assert!(format!("{:d}", -1i64).as_slice() == "-1"); + assert!(format!("{:t}", 1i).as_slice() == "1"); + assert!(format!("{:t}", 1i8).as_slice() == "1"); + assert!(format!("{:t}", 1i16).as_slice() == "1"); + assert!(format!("{:t}", 1i32).as_slice() == "1"); + assert!(format!("{:t}", 1i64).as_slice() == "1"); + assert!(format!("{:x}", 1i).as_slice() == "1"); + assert!(format!("{:x}", 1i8).as_slice() == "1"); + assert!(format!("{:x}", 1i16).as_slice() == "1"); + assert!(format!("{:x}", 1i32).as_slice() == "1"); + assert!(format!("{:x}", 1i64).as_slice() == "1"); + assert!(format!("{:X}", 1i).as_slice() == "1"); + assert!(format!("{:X}", 1i8).as_slice() == "1"); + assert!(format!("{:X}", 1i16).as_slice() == "1"); + assert!(format!("{:X}", 1i32).as_slice() == "1"); + assert!(format!("{:X}", 1i64).as_slice() == "1"); + assert!(format!("{:o}", 1i).as_slice() == "1"); + assert!(format!("{:o}", 1i8).as_slice() == "1"); + assert!(format!("{:o}", 1i16).as_slice() == "1"); + assert!(format!("{:o}", 1i32).as_slice() == "1"); + assert!(format!("{:o}", 1i64).as_slice() == "1"); + + assert!(format!("{}", 1u).as_slice() == "1"); + assert!(format!("{}", 1u8).as_slice() == "1"); + assert!(format!("{}", 1u16).as_slice() == "1"); + assert!(format!("{}", 1u32).as_slice() == "1"); + assert!(format!("{}", 1u64).as_slice() == "1"); + assert!(format!("{:u}", 1u).as_slice() == "1"); + assert!(format!("{:u}", 1u8).as_slice() == "1"); + assert!(format!("{:u}", 1u16).as_slice() == "1"); + assert!(format!("{:u}", 1u32).as_slice() == "1"); + assert!(format!("{:u}", 1u64).as_slice() == "1"); + assert!(format!("{:t}", 1u).as_slice() == "1"); + assert!(format!("{:t}", 1u8).as_slice() == "1"); + assert!(format!("{:t}", 1u16).as_slice() == "1"); + assert!(format!("{:t}", 1u32).as_slice() == "1"); + assert!(format!("{:t}", 1u64).as_slice() == "1"); + assert!(format!("{:x}", 1u).as_slice() == "1"); + assert!(format!("{:x}", 1u8).as_slice() == "1"); + assert!(format!("{:x}", 1u16).as_slice() == "1"); + assert!(format!("{:x}", 1u32).as_slice() == "1"); + assert!(format!("{:x}", 1u64).as_slice() == "1"); + assert!(format!("{:X}", 1u).as_slice() == "1"); + assert!(format!("{:X}", 1u8).as_slice() == "1"); + assert!(format!("{:X}", 1u16).as_slice() == "1"); + assert!(format!("{:X}", 1u32).as_slice() == "1"); + assert!(format!("{:X}", 1u64).as_slice() == "1"); + assert!(format!("{:o}", 1u).as_slice() == "1"); + assert!(format!("{:o}", 1u8).as_slice() == "1"); + assert!(format!("{:o}", 1u16).as_slice() == "1"); + assert!(format!("{:o}", 1u32).as_slice() == "1"); + assert!(format!("{:o}", 1u64).as_slice() == "1"); // Test a larger number - assert_eq!(format!("{:t}", 55), "110111".to_owned()); - assert_eq!(format!("{:o}", 55), "67".to_owned()); - assert_eq!(format!("{:d}", 55), "55".to_owned()); - assert_eq!(format!("{:x}", 55), "37".to_owned()); - assert_eq!(format!("{:X}", 55), "37".to_owned()); + assert!(format!("{:t}", 55).as_slice() == "110111"); + assert!(format!("{:o}", 55).as_slice() == "67"); + assert!(format!("{:d}", 55).as_slice() == "55"); + assert!(format!("{:x}", 55).as_slice() == "37"); + assert!(format!("{:X}", 55).as_slice() == "37"); } #[test] fn test_format_int_zero() { - assert_eq!(format!("{}", 0i), "0".to_owned()); - assert_eq!(format!("{:d}", 0i), "0".to_owned()); - assert_eq!(format!("{:t}", 0i), "0".to_owned()); - assert_eq!(format!("{:o}", 0i), "0".to_owned()); - assert_eq!(format!("{:x}", 0i), "0".to_owned()); - assert_eq!(format!("{:X}", 0i), "0".to_owned()); - - assert_eq!(format!("{}", 0u), "0".to_owned()); - assert_eq!(format!("{:u}", 0u), "0".to_owned()); - assert_eq!(format!("{:t}", 0u), "0".to_owned()); - assert_eq!(format!("{:o}", 0u), "0".to_owned()); - assert_eq!(format!("{:x}", 0u), "0".to_owned()); - assert_eq!(format!("{:X}", 0u), "0".to_owned()); + assert!(format!("{}", 0i).as_slice() == "0"); + assert!(format!("{:d}", 0i).as_slice() == "0"); + assert!(format!("{:t}", 0i).as_slice() == "0"); + assert!(format!("{:o}", 0i).as_slice() == "0"); + assert!(format!("{:x}", 0i).as_slice() == "0"); + assert!(format!("{:X}", 0i).as_slice() == "0"); + + assert!(format!("{}", 0u).as_slice() == "0"); + assert!(format!("{:u}", 0u).as_slice() == "0"); + assert!(format!("{:t}", 0u).as_slice() == "0"); + assert!(format!("{:o}", 0u).as_slice() == "0"); + assert!(format!("{:x}", 0u).as_slice() == "0"); + assert!(format!("{:X}", 0u).as_slice() == "0"); } #[test] fn test_format_int_flags() { - assert_eq!(format!("{:3d}", 1), " 1".to_owned()); - assert_eq!(format!("{:>3d}", 1), " 1".to_owned()); - assert_eq!(format!("{:>+3d}", 1), " +1".to_owned()); - assert_eq!(format!("{:<3d}", 1), "1 ".to_owned()); - assert_eq!(format!("{:#d}", 1), "1".to_owned()); - assert_eq!(format!("{:#x}", 10), "0xa".to_owned()); - assert_eq!(format!("{:#X}", 10), "0xA".to_owned()); - assert_eq!(format!("{:#5x}", 10), " 0xa".to_owned()); - assert_eq!(format!("{:#o}", 10), "0o12".to_owned()); - assert_eq!(format!("{:08x}", 10), "0000000a".to_owned()); - assert_eq!(format!("{:8x}", 10), " a".to_owned()); - assert_eq!(format!("{:<8x}", 10), "a ".to_owned()); - assert_eq!(format!("{:>8x}", 10), " a".to_owned()); - assert_eq!(format!("{:#08x}", 10), "0x00000a".to_owned()); - assert_eq!(format!("{:08d}", -10), "-0000010".to_owned()); - assert_eq!(format!("{:x}", -1u8), "ff".to_owned()); - assert_eq!(format!("{:X}", -1u8), "FF".to_owned()); - assert_eq!(format!("{:t}", -1u8), "11111111".to_owned()); - assert_eq!(format!("{:o}", -1u8), "377".to_owned()); - assert_eq!(format!("{:#x}", -1u8), "0xff".to_owned()); - assert_eq!(format!("{:#X}", -1u8), "0xFF".to_owned()); - assert_eq!(format!("{:#t}", -1u8), "0b11111111".to_owned()); - assert_eq!(format!("{:#o}", -1u8), "0o377".to_owned()); + assert!(format!("{:3d}", 1).as_slice() == " 1"); + assert!(format!("{:>3d}", 1).as_slice() == " 1"); + assert!(format!("{:>+3d}", 1).as_slice() == " +1"); + assert!(format!("{:<3d}", 1).as_slice() == "1 "); + assert!(format!("{:#d}", 1).as_slice() == "1"); + assert!(format!("{:#x}", 10).as_slice() == "0xa"); + assert!(format!("{:#X}", 10).as_slice() == "0xA"); + assert!(format!("{:#5x}", 10).as_slice() == " 0xa"); + assert!(format!("{:#o}", 10).as_slice() == "0o12"); + assert!(format!("{:08x}", 10).as_slice() == "0000000a"); + assert!(format!("{:8x}", 10).as_slice() == " a"); + assert!(format!("{:<8x}", 10).as_slice() == "a "); + assert!(format!("{:>8x}", 10).as_slice() == " a"); + assert!(format!("{:#08x}", 10).as_slice() == "0x00000a"); + assert!(format!("{:08d}", -10).as_slice() == "-0000010"); + assert!(format!("{:x}", -1u8).as_slice() == "ff"); + assert!(format!("{:X}", -1u8).as_slice() == "FF"); + assert!(format!("{:t}", -1u8).as_slice() == "11111111"); + assert!(format!("{:o}", -1u8).as_slice() == "377"); + assert!(format!("{:#x}", -1u8).as_slice() == "0xff"); + assert!(format!("{:#X}", -1u8).as_slice() == "0xFF"); + assert!(format!("{:#t}", -1u8).as_slice() == "0b11111111"); + assert!(format!("{:#o}", -1u8).as_slice() == "0o377"); } #[test] fn test_format_int_sign_padding() { - assert_eq!(format!("{:+5d}", 1), " +1".to_owned()); - assert_eq!(format!("{:+5d}", -1), " -1".to_owned()); - assert_eq!(format!("{:05d}", 1), "00001".to_owned()); - assert_eq!(format!("{:05d}", -1), "-0001".to_owned()); - assert_eq!(format!("{:+05d}", 1), "+0001".to_owned()); - assert_eq!(format!("{:+05d}", -1), "-0001".to_owned()); + assert!(format!("{:+5d}", 1).as_slice() == " +1"); + assert!(format!("{:+5d}", -1).as_slice() == " -1"); + assert!(format!("{:05d}", 1).as_slice() == "00001"); + assert!(format!("{:05d}", -1).as_slice() == "-0001"); + assert!(format!("{:+05d}", 1).as_slice() == "+0001"); + assert!(format!("{:+05d}", -1).as_slice() == "-0001"); } #[test] fn test_format_int_twos_complement() { use {i8, i16, i32, i64}; - assert_eq!(format!("{}", i8::MIN), "-128".to_owned()); - assert_eq!(format!("{}", i16::MIN), "-32768".to_owned()); - assert_eq!(format!("{}", i32::MIN), "-2147483648".to_owned()); - assert_eq!(format!("{}", i64::MIN), "-9223372036854775808".to_owned()); + assert!(format!("{}", i8::MIN).as_slice() == "-128"); + assert!(format!("{}", i16::MIN).as_slice() == "-32768"); + assert!(format!("{}", i32::MIN).as_slice() == "-2147483648"); + assert!(format!("{}", i64::MIN).as_slice() == "-9223372036854775808"); } #[test] fn test_format_radix() { - assert_eq!(format!("{:04}", radix(3, 2)), "0011".to_owned()); - assert_eq!(format!("{}", radix(55, 36)), "1j".to_owned()); + assert!(format!("{:04}", radix(3, 2)).as_slice() == "0011"); + assert!(format!("{}", radix(55, 36)).as_slice() == "1j"); } #[test] diff --git a/src/libcore/mem.rs b/src/libcore/mem.rs index aa7a8f0f8b63a..b72eebe85c587 100644 --- a/src/libcore/mem.rs +++ b/src/libcore/mem.rs @@ -469,6 +469,7 @@ mod tests { use option::{Some,None}; use realstd::str::StrAllocating; use realstd::owned::Box; + use realstd::vec::Vec; use raw; #[test] @@ -568,7 +569,7 @@ mod tests { } unsafe { - assert_eq!(box [76u8], transmute("L".to_owned())); + assert!(Vec::from_slice([76u8]) == transmute("L".to_owned())); } } } diff --git a/src/libcore/option.rs b/src/libcore/option.rs index 00f21ee4c9ced..adea8ac630e27 100644 --- a/src/libcore/option.rs +++ b/src/libcore/option.rs @@ -188,14 +188,14 @@ impl Option { /// /// # Example /// - /// Convert an `Option<~str>` into an `Option`, preserving the original. + /// Convert an `Option` into an `Option`, preserving the original. /// The `map` method takes the `self` argument by value, consuming the original, /// so this technique uses `as_ref` to first take an `Option` to a reference /// to the value inside the original. /// /// ``` - /// let num_as_str: Option<~str> = Some("10".to_owned()); - /// // First, cast `Option<~str>` to `Option<&~str>` with `as_ref`, + /// let num_as_str: Option = Some("10".to_strbuf()); + /// // First, cast `Option` to `Option<&StrBuf>` with `as_ref`, /// // then consume *that* with `map`, leaving `num_as_str` on the stack. /// let num_as_int: Option = num_as_str.as_ref().map(|n| n.len()); /// println!("still can print num_as_str: {}", num_as_str); @@ -278,10 +278,10 @@ impl Option { /// /// # Example /// - /// Convert an `Option<~str>` into an `Option`, consuming the original: + /// Convert an `Option` into an `Option`, consuming the original: /// /// ``` - /// let num_as_str: Option<~str> = Some("10".to_owned()); + /// let num_as_str: Option = Some("10".to_strbuf()); /// // `Option::map` takes self *by value*, consuming `num_as_str` /// let num_as_int: Option = num_as_str.map(|n| n.len()); /// ``` @@ -596,9 +596,10 @@ pub fn collect>, V: FromIterator>(iter: Iter) -> #[cfg(test)] mod tests { use realstd::vec::Vec; - use realstd::str::StrAllocating; + use realstd::strbuf::StrBuf; use option::collect; use prelude::*; + use realstd::str::{Str, StrAllocating}; use iter::range; use str::StrSlice; @@ -619,11 +620,11 @@ mod tests { #[test] fn test_get_str() { - let x = "test".to_owned(); - let addr_x = x.as_ptr(); + let x = "test".to_strbuf(); + let addr_x = x.as_slice().as_ptr(); let opt = Some(x); let y = opt.unwrap(); - let addr_y = y.as_ptr(); + let addr_y = y.as_slice().as_ptr(); assert_eq!(addr_x, addr_y); } @@ -745,7 +746,8 @@ mod tests { #[test] fn test_unwrap() { assert_eq!(Some(1).unwrap(), 1); - assert_eq!(Some("hello".to_owned()).unwrap(), "hello".to_owned()); + let s = Some("hello".to_strbuf()).unwrap(); + assert_eq!(s.as_slice(), "hello"); } #[test] @@ -758,7 +760,7 @@ mod tests { #[test] #[should_fail] fn test_unwrap_fail2() { - let x: Option<~str> = None; + let x: Option = None; x.unwrap(); } diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs index 870fa0ec53f8d..90b5b0d8753e4 100644 --- a/src/libcore/ptr.rs +++ b/src/libcore/ptr.rs @@ -486,6 +486,7 @@ pub mod ptr_tests { use mem; use libc; use realstd::str; + use realstd::str::Str; use slice::{ImmutableVector, MutableVector}; #[test] @@ -660,7 +661,7 @@ pub mod ptr_tests { let expected = expected_arr[ctr].with_ref(|buf| { str::raw::from_c_str(buf) }); - assert_eq!(actual, expected); + assert_eq!(actual.as_slice(), expected.as_slice()); ctr += 1; iteration_count += 1; }); @@ -693,7 +694,7 @@ pub mod ptr_tests { let expected = expected_arr[ctr].with_ref(|buf| { str::raw::from_c_str(buf) }); - assert_eq!(actual, expected); + assert_eq!(actual.as_slice(), expected.as_slice()); ctr += 1; iteration_count += 1; }); diff --git a/src/libcore/raw.rs b/src/libcore/raw.rs index 25f40b358ab25..979eeb657b6a6 100644 --- a/src/libcore/raw.rs +++ b/src/libcore/raw.rs @@ -81,7 +81,6 @@ impl<'a, T> Repr> for &'a [T] {} impl<'a> Repr> for &'a str {} impl Repr<*Box> for @T {} impl Repr<*Vec> for ~[T] {} -impl Repr<*String> for ~str {} #[cfg(test)] mod tests { diff --git a/src/libcore/result.rs b/src/libcore/result.rs index 46f4427e8387e..98d1782f20f53 100644 --- a/src/libcore/result.rs +++ b/src/libcore/result.rs @@ -169,20 +169,24 @@ //! ~~~ //! use std::io::{File, Open, Write, IoError}; //! -//! struct Info { name: ~str, age: int, rating: int } +//! struct Info { +//! name: StrBuf, +//! age: int, +//! rating: int +//! } //! //! fn write_info(info: &Info) -> Result<(), IoError> { //! let mut file = File::open_mode(&Path::new("my_best_friends.txt"), Open, Write); //! // Early return on error -//! match file.write_line(format!("name: {}", info.name)) { +//! match file.write_line(format!("name: {}", info.name).as_slice()) { //! Ok(_) => (), //! Err(e) => return Err(e) //! } -//! match file.write_line(format!("age: {}", info.age)) { +//! match file.write_line(format!("age: {}", info.age).as_slice()) { //! Ok(_) => (), //! Err(e) => return Err(e) //! } -//! return file.write_line(format!("rating: {}", info.rating)); +//! return file.write_line(format!("rating: {}", info.rating).as_slice()); //! } //! ~~~ //! @@ -191,14 +195,18 @@ //! ~~~ //! use std::io::{File, Open, Write, IoError}; //! -//! struct Info { name: ~str, age: int, rating: int } +//! struct Info { +//! name: StrBuf, +//! age: int, +//! rating: int +//! } //! //! fn write_info(info: &Info) -> Result<(), IoError> { //! let mut file = File::open_mode(&Path::new("my_best_friends.txt"), Open, Write); //! // Early return on error -//! try!(file.write_line(format!("name: {}", info.name))); -//! try!(file.write_line(format!("age: {}", info.age))); -//! try!(file.write_line(format!("rating: {}", info.rating))); +//! try!(file.write_line(format!("name: {}", info.name).as_slice())); +//! try!(file.write_line(format!("age: {}", info.age).as_slice())); +//! try!(file.write_line(format!("rating: {}", info.rating).as_slice())); //! return Ok(()); //! } //! ~~~ @@ -421,10 +429,10 @@ impl Result { /// let mut sum = 0; /// /// while !reader.eof() { - /// let line: IoResult<~str> = reader.read_line(); + /// let line: IoResult = reader.read_line(); /// // Convert the string line to a number using `map` and `from_str` /// let val: IoResult = line.map(|line| { - /// from_str::(line).unwrap_or(0) + /// from_str::(line.as_slice()).unwrap_or(0) /// }); /// // Add the value if there were no errors, otherwise add 0 /// sum += val.ok().unwrap_or(0); @@ -629,69 +637,68 @@ pub fn fold_>>(iterator: Iter) -> Result<(),E> { #[cfg(test)] mod tests { use realstd::vec::Vec; - use realstd::str::StrAllocating; + use realstd::strbuf::StrBuf; use result::{collect, fold, fold_}; use prelude::*; + use realstd::str::{Str, StrAllocating}; use iter::range; - pub fn op1() -> Result { Ok(666) } - pub fn op2() -> Result { Err("sadface".to_owned()) } + pub fn op1() -> Result { Ok(666) } + pub fn op2() -> Result { Err("sadface") } #[test] pub fn test_and() { assert_eq!(op1().and(Ok(667)).unwrap(), 667); - assert_eq!(op1().and(Err::<(), ~str>("bad".to_owned())).unwrap_err(), "bad".to_owned()); + assert_eq!(op1().and(Err::<(), &'static str>("bad")).unwrap_err(), + "bad"); - assert_eq!(op2().and(Ok(667)).unwrap_err(), "sadface".to_owned()); - assert_eq!(op2().and(Err::<(), ~str>("bad".to_owned())).unwrap_err(), "sadface".to_owned()); + assert_eq!(op2().and(Ok(667)).unwrap_err(), "sadface"); + assert_eq!(op2().and(Err::<(),&'static str>("bad")).unwrap_err(), + "sadface"); } #[test] pub fn test_and_then() { - assert_eq!(op1().and_then(|i| Ok::(i + 1)).unwrap(), 667); - assert_eq!(op1().and_then(|_| Err::("bad".to_owned())).unwrap_err(), - "bad".to_owned()); - - assert_eq!(op2().and_then(|i| Ok::(i + 1)).unwrap_err(), - "sadface".to_owned()); - assert_eq!(op2().and_then(|_| Err::("bad".to_owned())).unwrap_err(), - "sadface".to_owned()); + assert_eq!(op1().and_then(|i| Ok::(i + 1)).unwrap(), 667); + assert_eq!(op1().and_then(|_| Err::("bad")).unwrap_err(), + "bad"); + + assert_eq!(op2().and_then(|i| Ok::(i + 1)).unwrap_err(), + "sadface"); + assert_eq!(op2().and_then(|_| Err::("bad")).unwrap_err(), + "sadface"); } #[test] pub fn test_or() { assert_eq!(op1().or(Ok(667)).unwrap(), 666); - assert_eq!(op1().or(Err("bad".to_owned())).unwrap(), 666); + assert_eq!(op1().or(Err("bad")).unwrap(), 666); assert_eq!(op2().or(Ok(667)).unwrap(), 667); - assert_eq!(op2().or(Err("bad".to_owned())).unwrap_err(), "bad".to_owned()); + assert_eq!(op2().or(Err("bad")).unwrap_err(), "bad"); } #[test] pub fn test_or_else() { - assert_eq!(op1().or_else(|_| Ok::(667)).unwrap(), 666); - assert_eq!(op1().or_else(|e| Err::(e + "!")).unwrap(), 666); + assert_eq!(op1().or_else(|_| Ok::(667)).unwrap(), 666); + assert_eq!(op1().or_else(|e| Err::(e)).unwrap(), 666); - assert_eq!(op2().or_else(|_| Ok::(667)).unwrap(), 667); - assert_eq!(op2().or_else(|e| Err::(e + "!")).unwrap_err(), - "sadface!".to_owned()); + assert_eq!(op2().or_else(|_| Ok::(667)).unwrap(), 667); + assert_eq!(op2().or_else(|e| Err::(e)).unwrap_err(), + "sadface"); } #[test] pub fn test_impl_map() { - assert_eq!(Ok::<~str, ~str>("a".to_owned()).map(|x| x + "b"), - Ok("ab".to_owned())); - assert_eq!(Err::<~str, ~str>("a".to_owned()).map(|x| x + "b"), - Err("a".to_owned())); + assert!(Ok::(1).map(|x| x + 1) == Ok(2)); + assert!(Err::(1).map(|x| x + 1) == Err(1)); } #[test] pub fn test_impl_map_err() { - assert_eq!(Ok::<~str, ~str>("a".to_owned()).map_err(|x| x + "b"), - Ok("a".to_owned())); - assert_eq!(Err::<~str, ~str>("a".to_owned()).map_err(|x| x + "b"), - Err("ab".to_owned())); + assert!(Ok::(1).map_err(|x| x + 1) == Ok(1)); + assert!(Err::(1).map_err(|x| x + 1) == Err(2)); } #[test] @@ -736,17 +743,19 @@ mod tests { #[test] pub fn test_fmt_default() { - let ok: Result = Ok(100); - let err: Result = Err("Err".to_owned()); + let ok: Result = Ok(100); + let err: Result = Err("Err"); - assert_eq!(format!("{}", ok), "Ok(100)".to_owned()); - assert_eq!(format!("{}", err), "Err(Err)".to_owned()); + let s = format!("{}", ok); + assert_eq!(s.as_slice(), "Ok(100)"); + let s = format!("{}", err); + assert_eq!(s.as_slice(), "Err(Err)"); } #[test] pub fn test_unwrap_or() { - let ok: Result = Ok(100); - let ok_err: Result = Err("Err".to_owned()); + let ok: Result = Ok(100); + let ok_err: Result = Err("Err"); assert_eq!(ok.unwrap_or(50), 100); assert_eq!(ok_err.unwrap_or(50), 50); @@ -754,16 +763,16 @@ mod tests { #[test] pub fn test_unwrap_or_else() { - fn handler(msg: ~str) -> int { - if msg == "I got this.".to_owned() { + fn handler(msg: &'static str) -> int { + if msg == "I got this." { 50 } else { fail!("BadBad") } } - let ok: Result = Ok(100); - let ok_err: Result = Err("I got this.".to_owned()); + let ok: Result = Ok(100); + let ok_err: Result = Err("I got this."); assert_eq!(ok.unwrap_or_else(handler), 100); assert_eq!(ok_err.unwrap_or_else(handler), 50); @@ -772,15 +781,15 @@ mod tests { #[test] #[should_fail] pub fn test_unwrap_or_else_failure() { - fn handler(msg: ~str) -> int { - if msg == "I got this.".to_owned() { + fn handler(msg: &'static str) -> int { + if msg == "I got this." { 50 } else { fail!("BadBad") } } - let bad_err: Result = Err("Unrecoverable mess.".to_owned()); + let bad_err: Result = Err("Unrecoverable mess."); let _ : int = bad_err.unwrap_or_else(handler); } } diff --git a/src/libcore/should_not_exist.rs b/src/libcore/should_not_exist.rs index 2046017869dea..9a0e3ad7ca4ac 100644 --- a/src/libcore/should_not_exist.rs +++ b/src/libcore/should_not_exist.rs @@ -10,9 +10,9 @@ // As noted by this file name, this file should not exist. This file should not // exist because it performs allocations which libcore is not allowed to do. The -// reason for this file's existence is that the `~[T]` and `~str` types are -// language-defined types. Traits are defined in libcore, such as `Clone`, which -// these types need to implement, but the implementation can only be found in +// reason for this file's existence is that the `~[T]` type is a language- +// defined type. Traits are defined in libcore, such as `Clone`, which these +// types need to implement, but the implementation can only be found in // libcore. // // Plan of attack for solving this problem: @@ -24,13 +24,11 @@ // // Currently, no progress has been made on this list. -use char::Char; use clone::Clone; use container::Container; -use default::Default; use finally::try_finally; use intrinsics; -use iter::{range, Iterator, FromIterator}; +use iter::{range, Iterator}; use mem; use num::{CheckedMul, CheckedAdd}; use option::{Some, None}; @@ -38,9 +36,6 @@ use ptr::RawPtr; use ptr; use raw::Vec; use slice::ImmutableVector; -use str::StrSlice; - -#[cfg(not(test))] use ops::Add; #[allow(ctypes)] extern { @@ -60,105 +55,6 @@ unsafe fn alloc(cap: uint) -> *mut Vec<()> { ret } -// Strings - -impl Default for ~str { - fn default() -> ~str { - unsafe { - // Get some memory - let ptr = alloc(0); - - // Initialize the memory - (*ptr).fill = 0; - (*ptr).alloc = 0; - - mem::transmute(ptr) - } - } -} - -impl Clone for ~str { - fn clone(&self) -> ~str { - // Don't use the clone() implementation above because it'll start - // requiring the eh_personality lang item (no fun) - unsafe { - let bytes = self.as_bytes().as_ptr(); - let len = self.len(); - - let ptr = alloc(len) as *mut Vec; - ptr::copy_nonoverlapping_memory(&mut (*ptr).data, bytes, len); - (*ptr).fill = len; - (*ptr).alloc = len; - - mem::transmute(ptr) - } - } -} - -impl FromIterator for ~str { - #[inline] - fn from_iter>(mut iterator: T) -> ~str { - let (lower, _) = iterator.size_hint(); - let mut cap = if lower == 0 {16} else {lower}; - let mut len = 0; - let mut tmp = [0u8, ..4]; - - unsafe { - let mut ptr = alloc(cap) as *mut Vec; - let mut ret = mem::transmute(ptr); - for ch in iterator { - let amt = ch.encode_utf8(tmp); - - if len + amt > cap { - cap = cap.checked_mul(&2).unwrap(); - if cap < len + amt { - cap = len + amt; - } - let ptr2 = alloc(cap) as *mut Vec; - ptr::copy_nonoverlapping_memory(&mut (*ptr2).data, - &(*ptr).data, - len); - // FIXME: #13994: port to the sized deallocation API when available - rust_deallocate(ptr as *u8, 0, 8); - mem::forget(ret); - ret = mem::transmute(ptr2); - ptr = ptr2; - } - - let base = &mut (*ptr).data as *mut u8; - for byte in tmp.slice_to(amt).iter() { - *base.offset(len as int) = *byte; - len += 1; - } - (*ptr).fill = len; - } - ret - } - } -} - -#[cfg(not(test))] -impl<'a> Add<&'a str,~str> for &'a str { - #[inline] - fn add(&self, rhs: & &'a str) -> ~str { - let amt = self.len().checked_add(&rhs.len()).unwrap(); - unsafe { - let ptr = alloc(amt) as *mut Vec; - let base = &mut (*ptr).data as *mut _; - ptr::copy_nonoverlapping_memory(base, - self.as_bytes().as_ptr(), - self.len()); - let base = base.offset(self.len() as int); - ptr::copy_nonoverlapping_memory(base, - rhs.as_bytes().as_ptr(), - rhs.len()); - (*ptr).fill = amt; - (*ptr).alloc = amt; - mem::transmute(ptr) - } - } -} - // Arrays impl Clone for ~[A] { diff --git a/src/libcore/str.rs b/src/libcore/str.rs index 19be2fd3169c8..0b264b1724df0 100644 --- a/src/libcore/str.rs +++ b/src/libcore/str.rs @@ -25,7 +25,7 @@ use iter::range; use num::Saturating; use option::{None, Option, Some}; use raw::Repr; -use slice::{ImmutableVector, Vector}; +use slice::ImmutableVector; use slice; use uint; @@ -596,20 +596,6 @@ pub fn eq_slice(a: &str, b: &str) -> bool { eq_slice_(a, b) } -/// Bytewise string equality -#[cfg(not(test))] -#[lang="uniq_str_eq"] -#[inline] -pub fn eq(a: &~str, b: &~str) -> bool { - eq_slice(*a, *b) -} - -#[cfg(test)] -#[inline] -pub fn eq(a: &~str, b: &~str) -> bool { - eq_slice(*a, *b) -} - /* Section: Misc */ @@ -976,11 +962,6 @@ pub mod traits { } } - impl TotalOrd for ~str { - #[inline] - fn cmp(&self, other: &~str) -> Ordering { self.as_slice().cmp(&other.as_slice()) } - } - impl<'a> Eq for &'a str { #[inline] fn eq(&self, other: & &'a str) -> bool { @@ -990,36 +971,17 @@ pub mod traits { fn ne(&self, other: & &'a str) -> bool { !(*self).eq(other) } } - impl Eq for ~str { - #[inline] - fn eq(&self, other: &~str) -> bool { - eq_slice((*self), (*other)) - } - } - impl<'a> TotalEq for &'a str {} - impl TotalEq for ~str {} - impl<'a> Ord for &'a str { #[inline] fn lt(&self, other: & &'a str) -> bool { self.cmp(other) == Less } } - impl Ord for ~str { - #[inline] - fn lt(&self, other: &~str) -> bool { self.cmp(other) == Less } - } - impl<'a, S: Str> Equiv for &'a str { #[inline] fn equiv(&self, other: &S) -> bool { eq_slice(*self, other.as_slice()) } } - - impl<'a, S: Str> Equiv for ~str { - #[inline] - fn equiv(&self, other: &S) -> bool { eq_slice(*self, other.as_slice()) } - } } #[cfg(test)] @@ -1036,11 +998,6 @@ impl<'a> Str for &'a str { fn as_slice<'a>(&'a self) -> &'a str { *self } } -impl<'a> Str for ~str { - #[inline] - fn as_slice<'a>(&'a self) -> &'a str { let s: &'a str = *self; s } -} - impl<'a> Container for &'a str { #[inline] fn len(&self) -> uint { @@ -1048,11 +1005,6 @@ impl<'a> Container for &'a str { } } -impl Container for ~str { - #[inline] - fn len(&self) -> uint { self.as_slice().len() } -} - /// Methods for string slices pub trait StrSlice<'a> { /// Returns true if one string contains another diff --git a/src/libcore/tuple.rs b/src/libcore/tuple.rs index b73d85489a390..0e21c95807d09 100644 --- a/src/libcore/tuple.rs +++ b/src/libcore/tuple.rs @@ -246,11 +246,11 @@ mod tests { use super::*; use clone::Clone; use cmp::*; - use realstd::str::StrAllocating; + use realstd::str::{Str, StrAllocating}; #[test] fn test_clone() { - let a = (1, "2".to_owned()); + let a = (1, "2"); let b = a.clone(); assert_eq!(a, b); } @@ -323,8 +323,11 @@ mod tests { #[test] fn test_show() { - assert_eq!(format!("{}", (1,)), "(1,)".to_owned()); - assert_eq!(format!("{}", (1, true)), "(1, true)".to_owned()); - assert_eq!(format!("{}", (1, "hi".to_owned(), true)), "(1, hi, true)".to_owned()); + let s = format!("{}", (1,)); + assert_eq!(s.as_slice(), "(1,)"); + let s = format!("{}", (1, true)); + assert_eq!(s.as_slice(), "(1, true)"); + let s = format!("{}", (1, "hi", true)); + assert_eq!(s.as_slice(), "(1, hi, true)"); } } diff --git a/src/libfmt_macros/lib.rs b/src/libfmt_macros/lib.rs index e12026340d828..0e146505d5411 100644 --- a/src/libfmt_macros/lib.rs +++ b/src/libfmt_macros/lib.rs @@ -274,12 +274,13 @@ impl<'a> Parser<'a> { self.cur.next(); } Some((_, other)) => { - self.err( - format!("expected `{}` but found `{}`", c, other)); + self.err(format!("expected `{}` but found `{}`", + c, + other).as_slice()); } None => { - self.err( - format!("expected `{}` but string was terminated", c)); + self.err(format!("expected `{}` but string was terminated", + c).as_slice()); } } } @@ -307,7 +308,8 @@ impl<'a> Parser<'a> { Some((_, c @ '#')) | Some((_, c @ '{')) | Some((_, c @ '\\')) | Some((_, c @ '}')) => { c } Some((_, c)) => { - self.err(format!("invalid escape character `{}`", c)); + self.err(format!("invalid escape character `{}`", + c).as_slice()); c } None => { @@ -459,7 +461,7 @@ impl<'a> Parser<'a> { return None; } method => { - self.err(format!("unknown method: `{}`", method)); + self.err(format!("unknown method: `{}`", method).as_slice()); return None; } } @@ -526,7 +528,7 @@ impl<'a> Parser<'a> { let word = self.word(); if word != "offset" { self.err(format!("expected `offset`, found `{}`", - word)); + word).as_slice()); } else { self.must_consume(':'); match self.integer() { @@ -566,7 +568,7 @@ impl<'a> Parser<'a> { "many" => Keyword(Many), word => { self.err(format!("unexpected plural selector `{}`", - word)); + word).as_slice()); if word == "" { break } else { diff --git a/src/libgetopts/lib.rs b/src/libgetopts/lib.rs index ba30e1a2e986b..60528776294e9 100644 --- a/src/libgetopts/lib.rs +++ b/src/libgetopts/lib.rs @@ -661,7 +661,7 @@ pub fn getopts(args: &[StrBuf], optgrps: &[OptGroup]) -> Result { /// Derive a usage message from a set of long options. pub fn usage(brief: &str, opts: &[OptGroup]) -> StrBuf { - let desc_sep = "\n" + " ".repeat(24); + let desc_sep = format!("\n{}", " ".repeat(24)); let mut rows = opts.iter().map(|optref| { let OptGroup{short_name: short_name, @@ -713,7 +713,7 @@ pub fn usage(brief: &str, opts: &[OptGroup]) -> StrBuf { row.push_char(' '); } } else { - row.push_str(desc_sep) + row.push_str(desc_sep.as_slice()) } // Normalize desc to contain words separated by one space character @@ -734,7 +734,7 @@ pub fn usage(brief: &str, opts: &[OptGroup]) -> StrBuf { // FIXME: #5516 should be graphemes not codepoints // wrapped description - row.push_str(desc_rows.connect(desc_sep)); + row.push_str(desc_rows.connect(desc_sep.as_slice()).as_slice()); row }); @@ -784,7 +784,11 @@ fn format_option(opt: &OptGroup) -> StrBuf { /// Derive a short one-line usage summary from a set of long options. pub fn short_usage(program_name: &str, opts: &[OptGroup]) -> StrBuf { let mut line = format_strbuf!("Usage: {} ", program_name); - line.push_str(opts.iter().map(format_option).collect::>().connect(" ")); + line.push_str(opts.iter() + .map(format_option) + .collect::>() + .connect(" ") + .as_slice()); line } diff --git a/src/libglob/lib.rs b/src/libglob/lib.rs index 7b9260c7eb9dc..e4b1278f3d9db 100644 --- a/src/libglob/lib.rs +++ b/src/libglob/lib.rs @@ -690,13 +690,13 @@ mod test { let pat = Pattern::new("a[0-9]b"); for i in range(0, 10) { - assert!(pat.matches(format!("a{}b", i))); + assert!(pat.matches(format!("a{}b", i).as_slice())); } assert!(!pat.matches("a_b")); let pat = Pattern::new("a[!0-9]b"); for i in range(0, 10) { - assert!(!pat.matches(format!("a{}b", i))); + assert!(!pat.matches(format!("a{}b", i).as_slice())); } assert!(pat.matches("a_b")); @@ -704,11 +704,11 @@ mod test { for &p in pats.iter() { let pat = Pattern::new(p); for c in "abcdefghijklmnopqrstuvwxyz".chars() { - assert!(pat.matches(c.to_str())); + assert!(pat.matches(c.to_str().as_slice())); } for c in "ABCDEFGHIJKLMNOPQRSTUVWXYZ".chars() { let options = MatchOptions {case_sensitive: false, .. MatchOptions::new()}; - assert!(pat.matches_with(c.to_str(), options)); + assert!(pat.matches_with(c.to_str().as_slice(), options)); } assert!(pat.matches("1")); assert!(pat.matches("2")); diff --git a/src/libgreen/macros.rs b/src/libgreen/macros.rs index 1921eef9f60d4..eddf17b34b9ff 100644 --- a/src/libgreen/macros.rs +++ b/src/libgreen/macros.rs @@ -46,7 +46,7 @@ macro_rules! rtassert ( macro_rules! rtabort ( ($($arg:tt)*) => ( { - ::macros::abort(format!($($arg)*)); + ::macros::abort(format!($($arg)*).as_slice()); } ) ) diff --git a/src/libhexfloat/lib.rs b/src/libhexfloat/lib.rs index dda14fb10af02..9f731637a3b51 100644 --- a/src/libhexfloat/lib.rs +++ b/src/libhexfloat/lib.rs @@ -147,7 +147,10 @@ pub fn expand_syntax_ext(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) Some((err_pos, err_str)) => { let pos = expr.span.lo + syntax::codemap::Pos::from_uint(err_pos + 1); let span = syntax::codemap::mk_sp(pos,pos); - cx.span_err(span, format!("invalid hex float literal in hexfloat!: {}", err_str)); + cx.span_err(span, + format!("invalid hex float literal in hexfloat!: \ + {}", + err_str).as_slice()); return base::DummyResult::expr(sp); } _ => () diff --git a/src/liblog/lib.rs b/src/liblog/lib.rs index 5981f87b4f2b6..a9c0501ee3e09 100644 --- a/src/liblog/lib.rs +++ b/src/liblog/lib.rs @@ -302,8 +302,10 @@ pub fn mod_enabled(level: u32, module: &str) -> bool { enabled(level, module, unsafe { (*DIRECTIVES).iter() }) } -fn enabled(level: u32, module: &str, - iter: slice::Items) -> bool { +fn enabled(level: u32, + module: &str, + iter: slice::Items) + -> bool { // Search for the longest match, the vector is assumed to be pre-sorted. for directive in iter.rev() { match directive.name { @@ -322,7 +324,7 @@ fn enabled(level: u32, module: &str, /// `Once` primitive (and this function is called from that primitive). fn init() { let mut directives = match os::getenv("RUST_LOG") { - Some(spec) => directive::parse_logging_spec(spec), + Some(spec) => directive::parse_logging_spec(spec.as_slice()), None => Vec::new(), }; diff --git a/src/libnative/io/addrinfo.rs b/src/libnative/io/addrinfo.rs index 8ebae70f73c04..64b082d9f3f58 100644 --- a/src/libnative/io/addrinfo.rs +++ b/src/libnative/io/addrinfo.rs @@ -104,9 +104,10 @@ fn get_error(_: c_int) -> IoError { #[cfg(not(windows))] fn get_error(s: c_int) -> IoError { use std::io; - use std::str::raw::from_c_str; - let err_str = unsafe { from_c_str(gai_strerror(s)) }; + let err_str = unsafe { + CString::new(gai_strerror(s), false).as_str().unwrap().to_strbuf() + }; IoError { kind: io::OtherIoError, desc: "unable to resolve host", diff --git a/src/libnative/io/file_win32.rs b/src/libnative/io/file_win32.rs index 9693f77217009..f320aca2bfcbf 100644 --- a/src/libnative/io/file_win32.rs +++ b/src/libnative/io/file_win32.rs @@ -450,7 +450,9 @@ pub fn readlink(p: &CString) -> IoResult { libc::VOLUME_NAME_DOS) }); let ret = match ret { - Some(ref s) if s.starts_with(r"\\?\") => Ok(Path::new(s.slice_from(4))), + Some(ref s) if s.as_slice().starts_with(r"\\?\") => { + Ok(Path::new(s.as_slice().slice_from(4))) + } Some(s) => Ok(Path::new(s)), None => Err(super::last_error()), }; diff --git a/src/libnative/io/process.rs b/src/libnative/io/process.rs index 04911bc5f1bd6..80b00dfb3fe57 100644 --- a/src/libnative/io/process.rs +++ b/src/libnative/io/process.rs @@ -323,7 +323,7 @@ fn spawn_process_os(cfg: ProcessConfig, in_fd: c_int, out_fd: c_int, err_fd: c_i with_envp(cfg.env, |envp| { with_dirp(cfg.cwd, |dirp| { - os::win32::as_mut_utf16_p(cmd_str, |cmdp| { + os::win32::as_mut_utf16_p(cmd_str.as_slice(), |cmdp| { let created = CreateProcessW(ptr::null(), cmdp, ptr::mut_null(), @@ -396,7 +396,7 @@ fn zeroed_process_information() -> libc::types::os::arch::extra::PROCESS_INFORMA } #[cfg(windows)] -fn make_command_line(prog: &CString, args: &[CString]) -> ~str { +fn make_command_line(prog: &CString, args: &[CString]) -> StrBuf { let mut cmd = StrBuf::new(); append_arg(&mut cmd, prog.as_str() .expect("expected program name to be utf-8 encoded")); @@ -405,7 +405,7 @@ fn make_command_line(prog: &CString, args: &[CString]) -> ~str { append_arg(&mut cmd, arg.as_str() .expect("expected argument to be utf-8 encoded")); } - return cmd.into_owned(); + return cmd; fn append_arg(cmd: &mut StrBuf, arg: &str) { let quote = arg.chars().any(|c| c == ' ' || c == '\t'); @@ -1093,7 +1093,7 @@ mod tests { use std::c_str::CString; use super::make_command_line; - fn test_wrapper(prog: &str, args: &[&str]) -> ~str { + fn test_wrapper(prog: &str, args: &[&str]) -> StrBuf { make_command_line(&prog.to_c_str(), args.iter() .map(|a| a.to_c_str()) diff --git a/src/libnum/bigint.rs b/src/libnum/bigint.rs index ecc48d5569c0e..9267aea01b4e2 100644 --- a/src/libnum/bigint.rs +++ b/src/libnum/bigint.rs @@ -604,7 +604,7 @@ impl_to_biguint!(u32, FromPrimitive::from_u32) impl_to_biguint!(u64, FromPrimitive::from_u64) impl ToStrRadix for BigUint { - fn to_str_radix(&self, radix: uint) -> ~str { + fn to_str_radix(&self, radix: uint) -> StrBuf { assert!(1 < radix && radix <= 16); let (base, max_len) = get_radix_base(radix); if base == BigDigit::base { @@ -627,15 +627,17 @@ impl ToStrRadix for BigUint { return result; } - fn fill_concat(v: &[BigDigit], radix: uint, l: uint) -> ~str { - if v.is_empty() { return "0".to_owned() } + fn fill_concat(v: &[BigDigit], radix: uint, l: uint) -> StrBuf { + if v.is_empty() { + return "0".to_strbuf() + } let mut s = StrBuf::with_capacity(v.len() * l); for n in v.iter().rev() { let ss = (*n as uint).to_str_radix(radix); - s.push_str("0".repeat(l - ss.len())); - s.push_str(ss); + s.push_str("0".repeat(l - ss.len()).as_slice()); + s.push_str(ss.as_slice()); } - s.as_slice().trim_left_chars('0').to_owned() + s.as_slice().trim_left_chars('0').to_strbuf() } } } @@ -1209,11 +1211,11 @@ impl_to_bigint!(u64, FromPrimitive::from_u64) impl ToStrRadix for BigInt { #[inline] - fn to_str_radix(&self, radix: uint) -> ~str { + fn to_str_radix(&self, radix: uint) -> StrBuf { match self.sign { Plus => self.data.to_str_radix(radix), - Zero => "0".to_owned(), - Minus => "-".to_owned() + self.data.to_str_radix(radix) + Zero => "0".to_strbuf(), + Minus => format_strbuf!("-{}", self.data.to_str_radix(radix)), } } } @@ -1476,29 +1478,112 @@ mod biguint_tests { check("0", 3, "0"); check("1", 3, "8"); - check("1" + "0000" + "0000" + "0000" + "0001" + "0000" + "0000" + "0000" + "0001", 3, - "8" + "0000" + "0000" + "0000" + "0008" + "0000" + "0000" + "0000" + "0008"); - check("1" + "0000" + "0001" + "0000" + "0001", 2, - "4" + "0000" + "0004" + "0000" + "0004"); - check("1" + "0001" + "0001", 1, - "2" + "0002" + "0002"); - - check("" + "4000" + "0000" + "0000" + "0000", 3, - "2" + "0000" + "0000" + "0000" + "0000"); - check("" + "4000" + "0000", 2, - "1" + "0000" + "0000"); - check("" + "4000", 2, - "1" + "0000"); - - check("" + "4000" + "0000" + "0000" + "0000", 67, - "2" + "0000" + "0000" + "0000" + "0000" + "0000" + "0000" + "0000" + "0000"); - check("" + "4000" + "0000", 35, - "2" + "0000" + "0000" + "0000" + "0000"); - check("" + "4000", 19, - "2" + "0000" + "0000"); - - check("" + "fedc" + "ba98" + "7654" + "3210" + "fedc" + "ba98" + "7654" + "3210", 4, - "f" + "edcb" + "a987" + "6543" + "210f" + "edcb" + "a987" + "6543" + "2100"); + check("1\ + 0000\ + 0000\ + 0000\ + 0001\ + 0000\ + 0000\ + 0000\ + 0001", + 3, + "8\ + 0000\ + 0000\ + 0000\ + 0008\ + 0000\ + 0000\ + 0000\ + 0008"); + check("1\ + 0000\ + 0001\ + 0000\ + 0001", + 2, + "4\ + 0000\ + 0004\ + 0000\ + 0004"); + check("1\ + 0001\ + 0001", + 1, + "2\ + 0002\ + 0002"); + + check("\ + 4000\ + 0000\ + 0000\ + 0000", + 3, + "2\ + 0000\ + 0000\ + 0000\ + 0000"); + check("4000\ + 0000", + 2, + "1\ + 0000\ + 0000"); + check("4000", + 2, + "1\ + 0000"); + + check("4000\ + 0000\ + 0000\ + 0000", + 67, + "2\ + 0000\ + 0000\ + 0000\ + 0000\ + 0000\ + 0000\ + 0000\ + 0000"); + check("4000\ + 0000", + 35, + "2\ + 0000\ + 0000\ + 0000\ + 0000"); + check("4000", + 19, + "2\ + 0000\ + 0000"); + + check("fedc\ + ba98\ + 7654\ + 3210\ + fedc\ + ba98\ + 7654\ + 3210", + 4, + "f\ + edcb\ + a987\ + 6543\ + 210f\ + edcb\ + a987\ + 6543\ + 2100"); check("88887777666655554444333322221111", 16, "888877776666555544443333222211110000"); } @@ -1515,28 +1600,107 @@ mod biguint_tests { check("0", 3, "0"); check("f", 3, "1"); - check("1" + "0000" + "0000" + "0000" + "0001" + "0000" + "0000" + "0000" + "0001", 3, - "" + "2000" + "0000" + "0000" + "0000" + "2000" + "0000" + "0000" + "0000"); - check("1" + "0000" + "0001" + "0000" + "0001", 2, - "" + "4000" + "0000" + "4000" + "0000"); - check("1" + "0001" + "0001", 1, - "" + "8000" + "8000"); - - check("2" + "0000" + "0000" + "0000" + "0001" + "0000" + "0000" + "0000" + "0001", 67, - "" + "4000" + "0000" + "0000" + "0000"); - check("2" + "0000" + "0001" + "0000" + "0001", 35, - "" + "4000" + "0000"); - check("2" + "0001" + "0001", 19, - "" + "4000"); - - check("1" + "0000" + "0000" + "0000" + "0000", 1, - "" + "8000" + "0000" + "0000" + "0000"); - check("1" + "0000" + "0000", 1, - "" + "8000" + "0000"); - check("1" + "0000", 1, - "" + "8000"); - check("f" + "edcb" + "a987" + "6543" + "210f" + "edcb" + "a987" + "6543" + "2100", 4, - "" + "fedc" + "ba98" + "7654" + "3210" + "fedc" + "ba98" + "7654" + "3210"); + check("1\ + 0000\ + 0000\ + 0000\ + 0001\ + 0000\ + 0000\ + 0000\ + 0001", + 3, + "2000\ + 0000\ + 0000\ + 0000\ + 2000\ + 0000\ + 0000\ + 0000"); + check("1\ + 0000\ + 0001\ + 0000\ + 0001", + 2, + "4000\ + 0000\ + 4000\ + 0000"); + check("1\ + 0001\ + 0001", + 1, + "8000\ + 8000"); + + check("2\ + 0000\ + 0000\ + 0000\ + 0001\ + 0000\ + 0000\ + 0000\ + 0001", + 67, + "4000\ + 0000\ + 0000\ + 0000"); + check("2\ + 0000\ + 0001\ + 0000\ + 0001", + 35, + "4000\ + 0000"); + check("2\ + 0001\ + 0001", + 19, + "4000"); + + check("1\ + 0000\ + 0000\ + 0000\ + 0000", + 1, + "8000\ + 0000\ + 0000\ + 0000"); + check("1\ + 0000\ + 0000", + 1, + "8000\ + 0000"); + check("1\ + 0000", + 1, + "8000"); + check("f\ + edcb\ + a987\ + 6543\ + 210f\ + edcb\ + a987\ + 6543\ + 2100", + 4, + "fedc\ + ba98\ + 7654\ + 3210\ + fedc\ + ba98\ + 7654\ + 3210"); check("888877776666555544443333222211110000", 16, "88887777666655554444333322221111"); @@ -2543,7 +2707,7 @@ mod bigint_tests { fn test_to_str_radix() { fn check(n: int, ans: &str) { let n: BigInt = FromPrimitive::from_int(n).unwrap(); - assert!(ans == n.to_str_radix(10)); + assert!(ans == n.to_str_radix(10).as_slice()); } check(10, "10"); check(1, "1"); @@ -2572,7 +2736,8 @@ mod bigint_tests { // issue 10522, this hit an edge case that caused it to // attempt to allocate a vector of size (-1u) == huge. - let x: BigInt = from_str("1" + "0".repeat(36)).unwrap(); + let x: BigInt = + from_str(format!("1{}", "0".repeat(36)).as_slice()).unwrap(); let _y = x.to_str(); } diff --git a/src/libnum/complex.rs b/src/libnum/complex.rs index dfbacf6e4922f..37d9453fabfc6 100644 --- a/src/libnum/complex.rs +++ b/src/libnum/complex.rs @@ -175,11 +175,15 @@ impl fmt::Show for Complex { } impl ToStrRadix for Complex { - fn to_str_radix(&self, radix: uint) -> ~str { + fn to_str_radix(&self, radix: uint) -> StrBuf { if self.im < Zero::zero() { - format!("{}-{}i", self.re.to_str_radix(radix), (-self.im).to_str_radix(radix)) + format_strbuf!("{}-{}i", + self.re.to_str_radix(radix), + (-self.im).to_str_radix(radix)) } else { - format!("{}+{}i", self.re.to_str_radix(radix), self.im.to_str_radix(radix)) + format_strbuf!("{}+{}i", + self.re.to_str_radix(radix), + self.im.to_str_radix(radix)) } } } diff --git a/src/libnum/rational.rs b/src/libnum/rational.rs index cd5c82acf6e9a..6191b93ff8f30 100644 --- a/src/libnum/rational.rs +++ b/src/libnum/rational.rs @@ -281,8 +281,10 @@ impl fmt::Show for Ratio { } impl ToStrRadix for Ratio { /// Renders as `numer/denom` where the numbers are in base `radix`. - fn to_str_radix(&self, radix: uint) -> ~str { - format!("{}/{}", self.numer.to_str_radix(radix), self.denom.to_str_radix(radix)) + fn to_str_radix(&self, radix: uint) -> StrBuf { + format_strbuf!("{}/{}", + self.numer.to_str_radix(radix), + self.denom.to_str_radix(radix)) } } @@ -582,7 +584,7 @@ mod test { #[test] fn test_to_from_str_radix() { fn test(r: Rational, s: StrBuf, n: uint) { - assert_eq!(FromStrRadix::from_str_radix(s.to_owned(), n), + assert_eq!(FromStrRadix::from_str_radix(s.as_slice(), n), Some(r)); assert_eq!(r.to_str_radix(n).to_strbuf(), s); } diff --git a/src/libregex/parse/mod.rs b/src/libregex/parse/mod.rs index a695da9fa163e..beefda07f0a0d 100644 --- a/src/libregex/parse/mod.rs +++ b/src/libregex/parse/mod.rs @@ -278,7 +278,10 @@ impl<'a> Parser<'a> { fn noteof(&mut self, expected: &str) -> Result<(), Error> { match self.next_char() { true => Ok(()), - false => self.err(format!("Expected {} but got EOF.", expected)), + false => { + self.err(format!("Expected {} but got EOF.", + expected).as_slice()) + } } } @@ -286,8 +289,11 @@ impl<'a> Parser<'a> { match self.next_char() { true if self.cur() == expected => Ok(()), true => self.err(format!("Expected '{}' but got '{}'.", - expected, self.cur())), - false => self.err(format!("Expected '{}' but got EOF.", expected)), + expected, self.cur()).as_slice()), + false => { + self.err(format!("Expected '{}' but got EOF.", + expected).as_slice()) + } } } @@ -429,8 +435,10 @@ impl<'a> Parser<'a> { try!(self.noteof("not a ']'")) let c2 = self.cur(); if c2 < c { - return self.err(format!( - "Invalid character class range '{}-{}'", c, c2)) + return self.err(format!("Invalid character class \ + range '{}-{}'", + c, + c2).as_slice()) } ranges.push((c, self.cur())) } else { @@ -491,9 +499,12 @@ impl<'a> Parser<'a> { let closer = match self.pos('}') { Some(i) => i, - None => return self.err(format!( - "No closing brace for counted repetition starting at \ - position {}.", start)), + None => { + return self.err(format!("No closing brace for counted \ + repetition starting at position \ + {}.", + start).as_slice()) + } }; self.chari = closer; let greed = try!(self.get_next_greedy()); @@ -502,11 +513,11 @@ impl<'a> Parser<'a> { // Parse the min and max values from the regex. let (mut min, mut max): (uint, Option); - if !inner.contains(",") { - min = try!(self.parse_uint(inner)); + if !inner.as_slice().contains(",") { + min = try!(self.parse_uint(inner.as_slice())); max = Some(min); } else { - let pieces: Vec<&str> = inner.splitn(',', 1).collect(); + let pieces: Vec<&str> = inner.as_slice().splitn(',', 1).collect(); let (smin, smax) = (*pieces.get(0), *pieces.get(1)); if smin.len() == 0 { return self.err("Max repetitions cannot be specified \ @@ -525,19 +536,19 @@ impl<'a> Parser<'a> { if min > MAX_REPEAT { return self.err(format!( "{} exceeds maximum allowed repetitions ({})", - min, MAX_REPEAT)); + min, MAX_REPEAT).as_slice()); } if max.is_some() { let m = max.unwrap(); if m > MAX_REPEAT { return self.err(format!( "{} exceeds maximum allowed repetitions ({})", - m, MAX_REPEAT)); + m, MAX_REPEAT).as_slice()); } if m < min { return self.err(format!( "Max repetitions ({}) cannot be smaller than min \ - repetitions ({}).", m, min)); + repetitions ({}).", m, min).as_slice()); } } @@ -600,7 +611,10 @@ impl<'a> Parser<'a> { if c.is_uppercase() { flags |= FLAG_NEGATED } Ok(Class(ranges, flags)) } - _ => self.err(format!("Invalid escape sequence '\\\\{}'", c)), + _ => { + self.err(format!("Invalid escape sequence '\\\\{}'", + c).as_slice()) + } } } @@ -619,7 +633,7 @@ impl<'a> Parser<'a> { Some(i) => i, None => return self.err(format!( "Missing '\\}' for unclosed '\\{' at position {}", - self.chari)), + self.chari).as_slice()), }; if closer - self.chari + 1 == 0 { return self.err("No Unicode class name found.") @@ -634,8 +648,10 @@ impl<'a> Parser<'a> { self.chari += 1; } match find_class(UNICODE_CLASSES, name.as_slice()) { - None => return self.err(format!( - "Could not find Unicode class '{}'", name)), + None => { + return self.err(format!("Could not find Unicode class '{}'", + name).as_slice()) + } Some(ranges) => { Ok(Class(ranges, negated | (self.flags & FLAG_NOCASE))) } @@ -659,8 +675,10 @@ impl<'a> Parser<'a> { let s = self.slice(start, end); match num::from_str_radix::(s.as_slice(), 8) { Some(n) => Ok(Literal(try!(self.char_from_u32(n)), FLAG_EMPTY)), - None => self.err(format!( - "Could not parse '{}' as octal number.", s)), + None => { + self.err(format!("Could not parse '{}' as octal number.", + s).as_slice()) + } } } @@ -674,8 +692,11 @@ impl<'a> Parser<'a> { let start = self.chari + 2; let closer = match self.pos('}') { - None => return self.err(format!( - "Missing '\\}' for unclosed '\\{' at position {}", start)), + None => { + return self.err(format!("Missing '\\}' for unclosed \ + '\\{' at position {}", + start).as_slice()) + } Some(i) => i, }; self.chari = closer; @@ -689,7 +710,8 @@ impl<'a> Parser<'a> { fn parse_hex_two(&mut self) -> Result { let (start, end) = (self.chari, self.chari + 2); let bad = self.slice(start - 2, self.chars.len()); - try!(self.noteof(format!("Invalid hex escape sequence '{}'", bad))) + try!(self.noteof(format!("Invalid hex escape sequence '{}'", + bad).as_slice())) self.parse_hex_digits(self.slice(start, end).as_slice()) } @@ -697,8 +719,10 @@ impl<'a> Parser<'a> { fn parse_hex_digits(&self, s: &str) -> Result { match num::from_str_radix::(s, 16) { Some(n) => Ok(Literal(try!(self.char_from_u32(n)), FLAG_EMPTY)), - None => self.err(format!( - "Could not parse '{}' as hex number.", s)), + None => { + self.err(format!("Could not parse '{}' as hex number.", + s).as_slice()) + } } } @@ -722,7 +746,8 @@ impl<'a> Parser<'a> { "Capture names can only have underscores, letters and digits.") } if self.names.contains(&name) { - return self.err(format!("Duplicate capture group name '{}'.", name)) + return self.err(format!("Duplicate capture group name '{}'.", + name).as_slice()) } self.names.push(name.clone()); self.chari = closer; @@ -754,7 +779,7 @@ impl<'a> Parser<'a> { if sign < 0 { return self.err(format!( "Cannot negate flags twice in '{}'.", - self.slice(start, self.chari + 1))) + self.slice(start, self.chari + 1)).as_slice()) } sign = -1; saw_flag = false; @@ -765,7 +790,7 @@ impl<'a> Parser<'a> { if !saw_flag { return self.err(format!( "A valid flag does not follow negation in '{}'", - self.slice(start, self.chari + 1))) + self.slice(start, self.chari + 1)).as_slice()) } flags = flags ^ flags; } @@ -777,7 +802,7 @@ impl<'a> Parser<'a> { return Ok(()) } _ => return self.err(format!( - "Unrecognized flag '{}'.", self.cur())), + "Unrecognized flag '{}'.", self.cur()).as_slice()), } } } @@ -871,16 +896,21 @@ impl<'a> Parser<'a> { fn parse_uint(&self, s: &str) -> Result { match from_str::(s) { Some(i) => Ok(i), - None => self.err(format!( - "Expected an unsigned integer but got '{}'.", s)), + None => { + self.err(format!("Expected an unsigned integer but got '{}'.", + s).as_slice()) + } } } fn char_from_u32(&self, n: u32) -> Result { match char::from_u32(n) { Some(c) => Ok(c), - None => self.err(format!( - "Could not decode '{}' to unicode character.", n)), + None => { + self.err(format!("Could not decode '{}' to unicode \ + character.", + n).as_slice()) + } } } diff --git a/src/libregex/test/bench.rs b/src/libregex/test/bench.rs index 4c4ba8dd6bf93..6fcbcbd265aa1 100644 --- a/src/libregex/test/bench.rs +++ b/src/libregex/test/bench.rs @@ -20,38 +20,40 @@ fn bench_assert_match(b: &mut Bencher, re: Regex, text: &str) { #[bench] fn no_exponential(b: &mut Bencher) { let n = 100; - let re = Regex::new("a?".repeat(n) + "a".repeat(n)).unwrap(); + let re = Regex::new(format!("{}{}", + "a?".repeat(n), + "a".repeat(n)).as_slice()).unwrap(); let text = "a".repeat(n); - bench_assert_match(b, re, text); + bench_assert_match(b, re, text.as_slice()); } #[bench] fn literal(b: &mut Bencher) { let re = regex!("y"); - let text = "x".repeat(50) + "y"; - bench_assert_match(b, re, text); + let text = format!("{}y", "x".repeat(50)); + bench_assert_match(b, re, text.as_slice()); } #[bench] fn not_literal(b: &mut Bencher) { let re = regex!(".y"); - let text = "x".repeat(50) + "y"; - bench_assert_match(b, re, text); + let text = format!("{}y", "x".repeat(50)); + bench_assert_match(b, re, text.as_slice()); } #[bench] fn match_class(b: &mut Bencher) { let re = regex!("[abcdw]"); - let text = "xxxx".repeat(20) + "w"; - bench_assert_match(b, re, text); + let text = format!("{}w", "xxxx".repeat(20)); + bench_assert_match(b, re, text.as_slice()); } #[bench] fn match_class_in_range(b: &mut Bencher) { // 'b' is between 'a' and 'c', so the class range checking doesn't help. let re = regex!("[ac]"); - let text = "bbbb".repeat(20) + "c"; - bench_assert_match(b, re, text); + let text = format!("{}c", "bbbb".repeat(20)); + bench_assert_match(b, re, text.as_slice()); } #[bench] @@ -75,7 +77,7 @@ fn anchored_literal_short_non_match(b: &mut Bencher) { fn anchored_literal_long_non_match(b: &mut Bencher) { let re = regex!("^zbc(d|e)"); let text = "abcdefghijklmnopqrstuvwxyz".repeat(15); - b.iter(|| re.is_match(text)); + b.iter(|| re.is_match(text.as_slice())); } #[bench] @@ -89,7 +91,7 @@ fn anchored_literal_short_match(b: &mut Bencher) { fn anchored_literal_long_match(b: &mut Bencher) { let re = regex!("^.bc(d|e)"); let text = "abcdefghijklmnopqrstuvwxyz".repeat(15); - b.iter(|| re.is_match(text)); + b.iter(|| re.is_match(text.as_slice())); } #[bench] diff --git a/src/libregex_macros/lib.rs b/src/libregex_macros/lib.rs index b85a1592eff02..68320e8edd301 100644 --- a/src/libregex_macros/lib.rs +++ b/src/libregex_macros/lib.rs @@ -82,10 +82,10 @@ fn native(cx: &mut ExtCtxt, sp: codemap::Span, tts: &[ast::TokenTree]) // error is logged in 'parse' with cx.span_err None => return DummyResult::any(sp), }; - let re = match Regex::new(regex.to_owned()) { + let re = match Regex::new(regex.as_slice()) { Ok(re) => re, Err(err) => { - cx.span_err(sp, err.to_str()); + cx.span_err(sp, err.to_str().as_slice()); return DummyResult::any(sp) } }; @@ -612,7 +612,7 @@ fn parse(cx: &mut ExtCtxt, tts: &[ast::TokenTree]) -> Option { _ => { cx.span_err(entry.span, format!( "expected string literal but got `{}`", - pprust::lit_to_str(lit))); + pprust::lit_to_str(lit)).as_slice()); return None } } @@ -620,7 +620,7 @@ fn parse(cx: &mut ExtCtxt, tts: &[ast::TokenTree]) -> Option { _ => { cx.span_err(entry.span, format!( "expected string literal but got `{}`", - pprust::expr_to_str(entry))); + pprust::expr_to_str(entry)).as_slice()); return None } }; diff --git a/src/librustc/back/archive.rs b/src/librustc/back/archive.rs index 571959d812a45..ba3796211f259 100644 --- a/src/librustc/back/archive.rs +++ b/src/librustc/back/archive.rs @@ -56,17 +56,24 @@ fn run_ar(sess: &Session, args: &str, cwd: Option<&Path>, Ok(prog) => { let o = prog.wait_with_output().unwrap(); if !o.status.success() { - sess.err(format!("{} failed with: {}", cmd, o.status)); + sess.err(format!("{} failed with: {}", + cmd, + o.status).as_slice()); sess.note(format!("stdout ---\n{}", - str::from_utf8(o.output.as_slice()).unwrap())); + str::from_utf8(o.output + .as_slice()).unwrap()) + .as_slice()); sess.note(format!("stderr ---\n{}", - str::from_utf8(o.error.as_slice()).unwrap())); + str::from_utf8(o.error + .as_slice()).unwrap()) + .as_slice()); sess.abort_if_errors(); } o }, Err(e) => { - sess.err(format!("could not exec `{}`: {}", ar.as_slice(), e)); + sess.err(format!("could not exec `{}`: {}", ar.as_slice(), + e).as_slice()); sess.abort_if_errors(); fail!("rustc::back::archive::run_ar() should not reach this point"); } @@ -158,7 +165,7 @@ impl<'a> Archive<'a> { if skip.iter().any(|s| *s == filename) { continue } if filename.contains(".SYMDEF") { continue } - let filename = format!("r-{}-{}", name, filename); + let filename = format_strbuf!("r-{}-{}", name, filename); let new_filename = file.with_filename(filename); try!(fs::rename(file, &new_filename)); inputs.push(new_filename); @@ -178,8 +185,8 @@ impl<'a> Archive<'a> { }; // On Windows, static libraries sometimes show up as libfoo.a and other // times show up as foo.lib - let oslibname = format!("{}{}.{}", osprefix, name, osext); - let unixlibname = format!("lib{}.a", name); + let oslibname = format_strbuf!("{}{}.{}", osprefix, name, osext); + let unixlibname = format_strbuf!("lib{}.a", name); let mut rustpath = filesearch::rust_path(); rustpath.push(self.sess.target_filesearch().get_lib_path()); @@ -194,7 +201,8 @@ impl<'a> Archive<'a> { } } self.sess.fatal(format!("could not find native static library `{}`, \ - perhaps an -L flag is missing?", name)); + perhaps an -L flag is missing?", + name).as_slice()); } } diff --git a/src/librustc/back/link.rs b/src/librustc/back/link.rs index 429a8f5be5eb5..57f3824ecc560 100644 --- a/src/librustc/back/link.rs +++ b/src/librustc/back/link.rs @@ -62,7 +62,9 @@ pub fn llvm_err(sess: &Session, msg: StrBuf) -> ! { } else { let err = CString::new(cstr, true); let err = str::from_utf8_lossy(err.as_bytes()); - sess.fatal((msg.as_slice() + ": " + err.as_slice())); + sess.fatal(format!("{}: {}", + msg.as_slice(), + err.as_slice()).as_slice()); } } } @@ -167,7 +169,9 @@ pub mod write { "dynamic-no-pic" => lib::llvm::RelocDynamicNoPic, _ => { sess.err(format!("{} is not a valid relocation mode", - sess.opts.cg.relocation_model)); + sess.opts + .cg + .relocation_model).as_slice()); sess.abort_if_errors(); return; } @@ -219,7 +223,8 @@ pub mod write { for pass in sess.opts.cg.passes.iter() { pass.as_slice().with_c_str(|s| { if !llvm::LLVMRustAddPass(mpm, s) { - sess.warn(format!("unknown pass {}, ignoring", *pass)); + sess.warn(format!("unknown pass {}, ignoring", + *pass).as_slice()); } }) } @@ -360,16 +365,21 @@ pub mod write { match cmd.output() { Ok(prog) => { if !prog.status.success() { - sess.err(format!("linking with `{}` failed: {}", pname, prog.status)); - sess.note(format!("{}", &cmd)); + sess.err(format!("linking with `{}` failed: {}", + pname, + prog.status).as_slice()); + sess.note(format!("{}", &cmd).as_slice()); let mut note = prog.error.clone(); note.push_all(prog.output.as_slice()); - sess.note(str::from_utf8(note.as_slice()).unwrap().to_owned()); + sess.note(str::from_utf8(note.as_slice()).unwrap() + .as_slice()); sess.abort_if_errors(); } }, Err(e) => { - sess.err(format!("could not exec the linker `{}`: {}", pname, e)); + sess.err(format!("could not exec the linker `{}`: {}", + pname, + e).as_slice()); sess.abort_if_errors(); } } @@ -531,8 +541,8 @@ pub fn find_crate_id(attrs: &[ast::Attribute], out_filestem: &str) -> CrateId { match attr::find_crateid(attrs) { None => from_str(out_filestem).unwrap_or_else(|| { let mut s = out_filestem.chars().filter(|c| c.is_XID_continue()); - from_str(s.collect::() - .to_owned()).or(from_str("rust-out")).unwrap() + from_str(s.collect::().as_slice()) + .or(from_str("rust-out")).unwrap() }), Some(s) => s, } @@ -639,7 +649,7 @@ pub fn sanitize(s: &str) -> StrBuf { if result.len() > 0u && result.as_slice()[0] != '_' as u8 && ! char::is_XID_start(result.as_slice()[0] as char) { - return ("_" + result.as_slice()).to_strbuf(); + return format!("_{}", result.as_slice()).to_strbuf(); } return result; @@ -666,7 +676,7 @@ pub fn mangle>(mut path: PI, fn push(n: &mut StrBuf, s: &str) { let sani = sanitize(s); - n.push_str(format!("{}{}", sani.len(), sani)); + n.push_str(format!("{}{}", sani.len(), sani).as_slice()); } // First, connect each component with pairs. @@ -691,7 +701,7 @@ pub fn exported_name(path: PathElems, hash: &str, vers: &str) -> StrBuf { // The version will get mangled to have a leading '_', but it makes more // sense to lead with a 'v' b/c this is a version... let vers = if vers.len() > 0 && !char::is_XID_start(vers.char_at(0)) { - "v" + vers + format!("v{}", vers) } else { vers.to_owned() }; @@ -774,7 +784,9 @@ fn remove(sess: &Session, path: &Path) { match fs::unlink(path) { Ok(..) => {} Err(e) => { - sess.err(format!("failed to remove {}: {}", path.display(), e)); + sess.err(format!("failed to remove {}: {}", + path.display(), + e).as_slice()); } } } @@ -815,7 +827,7 @@ pub fn filename_for_input(sess: &Session, crate_type: config::CrateType, let libname = output_lib_filename(id); match crate_type { config::CrateTypeRlib => { - out_filename.with_filename(format!("lib{}.rlib", libname)) + out_filename.with_filename(format_strbuf!("lib{}.rlib", libname)) } config::CrateTypeDylib => { let (prefix, suffix) = match sess.targ_cfg.os { @@ -825,10 +837,13 @@ pub fn filename_for_input(sess: &Session, crate_type: config::CrateType, abi::OsAndroid => (loader::ANDROID_DLL_PREFIX, loader::ANDROID_DLL_SUFFIX), abi::OsFreebsd => (loader::FREEBSD_DLL_PREFIX, loader::FREEBSD_DLL_SUFFIX), }; - out_filename.with_filename(format!("{}{}{}", prefix, libname, suffix)) + out_filename.with_filename(format_strbuf!("{}{}{}", + prefix, + libname, + suffix)) } config::CrateTypeStaticlib => { - out_filename.with_filename(format!("lib{}.a", libname)) + out_filename.with_filename(format_strbuf!("lib{}.a", libname)) } config::CrateTypeExecutable => out_filename.clone(), } @@ -855,12 +870,14 @@ fn link_binary_output(sess: &Session, let obj_is_writeable = is_writeable(&obj_filename); let out_is_writeable = is_writeable(&out_filename); if !out_is_writeable { - sess.fatal(format!("output file {} is not writeable -- check its permissions.", - out_filename.display())); + sess.fatal(format!("output file {} is not writeable -- check its \ + permissions.", + out_filename.display()).as_slice()); } else if !obj_is_writeable { - sess.fatal(format!("object file {} is not writeable -- check its permissions.", - obj_filename.display())); + sess.fatal(format!("object file {} is not writeable -- check its \ + permissions.", + obj_filename.display()).as_slice()); } match crate_type { @@ -936,7 +953,8 @@ fn link_rlib<'a>(sess: &'a Session, Ok(..) => {} Err(e) => { sess.err(format!("failed to write {}: {}", - metadata.display(), e)); + metadata.display(), + e).as_slice()); sess.abort_if_errors(); } } @@ -956,7 +974,9 @@ fn link_rlib<'a>(sess: &'a Session, }) { Ok(()) => {} Err(e) => { - sess.err(format!("failed to write compressed bytecode: {}", e)); + sess.err(format!("failed to write compressed bytecode: \ + {}", + e).as_slice()); sess.abort_if_errors() } } @@ -1003,7 +1023,8 @@ fn link_staticlib(sess: &Session, obj_filename: &Path, out_filename: &Path) { let name = sess.cstore.get_crate_data(cnum).name.clone(); let p = match *path { Some(ref p) => p.clone(), None => { - sess.err(format!("could not find rlib for: `{}`", name)); + sess.err(format!("could not find rlib for: `{}`", + name).as_slice()); continue } }; @@ -1015,7 +1036,9 @@ fn link_staticlib(sess: &Session, obj_filename: &Path, out_filename: &Path) { cstore::NativeUnknown => "library", cstore::NativeFramework => "framework", }; - sess.warn(format!("unlinked native {}: {}", name, *lib)); + sess.warn(format!("unlinked native {}: {}", + name, + *lib).as_slice()); } } } @@ -1049,16 +1072,21 @@ fn link_natively(sess: &Session, trans: &CrateTranslation, dylib: bool, match prog { Ok(prog) => { if !prog.status.success() { - sess.err(format!("linking with `{}` failed: {}", pname, prog.status)); - sess.note(format!("{}", &cmd)); + sess.err(format!("linking with `{}` failed: {}", + pname, + prog.status).as_slice()); + sess.note(format!("{}", &cmd).as_slice()); let mut output = prog.error.clone(); output.push_all(prog.output.as_slice()); - sess.note(str::from_utf8(output.as_slice()).unwrap().to_owned()); + sess.note(str::from_utf8(output.as_slice()).unwrap() + .as_slice()); sess.abort_if_errors(); } }, Err(e) => { - sess.err(format!("could not exec the linker `{}`: {}", pname, e)); + sess.err(format!("could not exec the linker `{}`: {}", + pname, + e).as_slice()); sess.abort_if_errors(); } } @@ -1070,7 +1098,7 @@ fn link_natively(sess: &Session, trans: &CrateTranslation, dylib: bool, match Command::new("dsymutil").arg(out_filename).status() { Ok(..) => {} Err(e) => { - sess.err(format!("failed to run dsymutil: {}", e)); + sess.err(format!("failed to run dsymutil: {}", e).as_slice()); sess.abort_if_errors(); } } @@ -1409,7 +1437,8 @@ fn add_upstream_rust_crates(cmd: &mut Command, sess: &Session, // against the archive. if sess.lto() { let name = sess.cstore.get_crate_data(cnum).name.clone(); - time(sess.time_passes(), format!("altering {}.rlib", name), + time(sess.time_passes(), + format!("altering {}.rlib", name).as_slice(), (), |()| { let dst = tmpdir.join(cratepath.filename().unwrap()); match fs::copy(&cratepath, &dst) { @@ -1418,12 +1447,12 @@ fn add_upstream_rust_crates(cmd: &mut Command, sess: &Session, sess.err(format!("failed to copy {} to {}: {}", cratepath.display(), dst.display(), - e)); + e).as_slice()); sess.abort_if_errors(); } } let mut archive = Archive::open(sess, dst.clone()); - archive.remove_file(format!("{}.o", name)); + archive.remove_file(format!("{}.o", name).as_slice()); let files = archive.files(); if files.iter().any(|s| s.as_slice().ends_with(".o")) { cmd.arg(dst); diff --git a/src/librustc/back/lto.rs b/src/librustc/back/lto.rs index 74ac972e5c4b2..9f12b9d58951c 100644 --- a/src/librustc/back/lto.rs +++ b/src/librustc/back/lto.rs @@ -47,29 +47,46 @@ pub fn run(sess: &session::Session, llmod: ModuleRef, let path = match path { Some(p) => p, None => { - sess.fatal(format!("could not find rlib for: `{}`", name)); + sess.fatal(format!("could not find rlib for: `{}`", + name).as_slice()); } }; let archive = ArchiveRO::open(&path).expect("wanted an rlib"); debug!("reading {}", name); - let bc = time(sess.time_passes(), format!("read {}.bc.deflate", name), (), |_| - archive.read(format!("{}.bc.deflate", name))); + let bc = time(sess.time_passes(), + format!("read {}.bc.deflate", name).as_slice(), + (), + |_| { + archive.read(format!("{}.bc.deflate", + name).as_slice()) + }); let bc = bc.expect("missing compressed bytecode in archive!"); - let bc = time(sess.time_passes(), format!("inflate {}.bc", name), (), |_| - match flate::inflate_bytes(bc) { - Some(bc) => bc, - None => sess.fatal(format!("failed to decompress bc of `{}`", name)) + let bc = time(sess.time_passes(), + format!("inflate {}.bc", name).as_slice(), + (), + |_| { + match flate::inflate_bytes(bc) { + Some(bc) => bc, + None => { + sess.fatal(format!("failed to decompress \ + bc of `{}`", + name).as_slice()) + } + } }); let ptr = bc.as_slice().as_ptr(); debug!("linking {}", name); - time(sess.time_passes(), format!("ll link {}", name), (), |()| unsafe { + time(sess.time_passes(), + format!("ll link {}", name).as_slice(), + (), + |()| unsafe { if !llvm::LLVMRustLinkInExternalBitcode(llmod, ptr as *libc::c_char, bc.len() as libc::size_t) { link::llvm_err(sess, - (format_strbuf!("failed to load bc of `{}`", - name))); + format_strbuf!("failed to load bc of `{}`", + name.as_slice())); } }); } diff --git a/src/librustc/back/rpath.rs b/src/librustc/back/rpath.rs index 8557cfc0bc2bb..8258fb5762be3 100644 --- a/src/librustc/back/rpath.rs +++ b/src/librustc/back/rpath.rs @@ -59,7 +59,7 @@ pub fn get_rpath_flags(sess: &Session, out_filename: &Path) -> Vec { pub fn rpaths_to_flags(rpaths: &[StrBuf]) -> Vec { let mut ret = Vec::new(); for rpath in rpaths.iter() { - ret.push(("-Wl,-rpath," + (*rpath).as_slice()).to_strbuf()); + ret.push(format!("-Wl,-rpath,{}", (*rpath).as_slice())); } return ret; } @@ -132,8 +132,9 @@ pub fn get_rpath_relative_to_output(os: abi::Os, let relative = lib.path_relative_from(&output); let relative = relative.expect("could not create rpath relative to output"); // FIXME (#9639): This needs to handle non-utf8 paths - (prefix + "/" + relative.as_str() - .expect("non-utf8 component in path")).to_strbuf() + format!("{}/{}", + prefix, + relative.as_str().expect("non-utf8 component in path")) } pub fn get_install_prefix_rpath(sysroot: &Path, target_triple: &str) -> StrBuf { diff --git a/src/librustc/driver/config.rs b/src/librustc/driver/config.rs index 4cf33a777ad78..d80cf72bb466d 100644 --- a/src/librustc/driver/config.rs +++ b/src/librustc/driver/config.rs @@ -328,18 +328,23 @@ pub fn build_codegen_options(matches: &getopts::Matches) -> CodegenOptions if option_to_lookup.as_slice() != candidate { continue } if !setter(&mut cg, value) { match value { - Some(..) => early_error(format!("codegen option `{}` takes \ - no value", key)), - None => early_error(format!("codegen option `{0}` requires \ - a value (-C {0}=)", - key)) + Some(..) => { + early_error(format!("codegen option `{}` takes no \ + value", key).as_slice()) + } + None => { + early_error(format!("codegen option `{0}` requires \ + a value (-C {0}=)", + key).as_slice()) + } } } found = true; break; } if !found { - early_error(format!("unknown codegen option: `{}`", key)); + early_error(format!("unknown codegen option: `{}`", + key).as_slice()); } } return cg; @@ -464,8 +469,8 @@ pub fn build_target_config(sopts: &Options) -> Config { let arch = match get_arch(sopts.target_triple.as_slice()) { Some(arch) => arch, None => { - early_error("unknown architecture: " + - sopts.target_triple.as_slice()) + early_error(format!("unknown architecture: {}", + sopts.target_triple.as_slice()).as_slice()) } }; let (int_type, uint_type) = match arch { @@ -570,7 +575,10 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { "staticlib" => CrateTypeStaticlib, "dylib" => CrateTypeDylib, "bin" => CrateTypeExecutable, - _ => early_error(format!("unknown crate type: `{}`", part)) + _ => { + early_error(format!("unknown crate type: `{}`", + part).as_slice()) + } }; crate_types.push(new_part) } @@ -589,14 +597,17 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { let level_short = level_name.slice_chars(0, 1); let level_short = level_short.to_ascii().to_upper().into_str(); - let flags = matches.opt_strs(level_short).move_iter().collect::>().append( - matches.opt_strs(level_name).as_slice()); + let flags = matches.opt_strs(level_short.as_slice()) + .move_iter() + .collect::>() + .append(matches.opt_strs(level_name).as_slice()); for lint_name in flags.iter() { - let lint_name = lint_name.replace("-", "_"); + let lint_name = lint_name.replace("-", "_").into_strbuf(); match lint_dict.find_equiv(&lint_name) { None => { early_error(format!("unknown {} flag: {}", - level_name, lint_name)); + level_name, + lint_name).as_slice()); } Some(lint) => { lint_opts.push((lint.lint, *level)); @@ -618,7 +629,8 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { } } if this_bit == 0 { - early_error(format!("unknown debug flag: {}", *debug_flag)) + early_error(format!("unknown debug flag: {}", + *debug_flag).as_slice()) } debugging_opts |= this_bit; } @@ -638,7 +650,10 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { "bc" => link::OutputTypeBitcode, "obj" => link::OutputTypeObject, "link" => link::OutputTypeExe, - _ => early_error(format!("unknown emission type: `{}`", part)) + _ => { + early_error(format!("unknown emission type: `{}`", + part).as_slice()) + } }; output_types.push(output_type) } @@ -671,8 +686,9 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { Some("2") => Default, Some("3") => Aggressive, Some(arg) => { - early_error(format!("optimization level needs to be between 0-3 \ - (instead was `{}`)", arg)); + early_error(format!("optimization level needs to be \ + between 0-3 (instead was `{}`)", + arg).as_slice()); } } } else { @@ -692,8 +708,9 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { None | Some("2") => FullDebugInfo, Some(arg) => { - early_error(format!("optimization level needs to be between 0-3 \ - (instead was `{}`)", arg)); + early_error(format!("optimization level needs to be between \ + 0-3 (instead was `{}`)", + arg).as_slice()); } } } else { @@ -725,9 +742,11 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { None => Auto, - Some(arg) => early_error(format!( - "argument for --color must be auto, always or never (instead was `{}`)", - arg)) + Some(arg) => { + early_error(format!("argument for --color must be auto, always \ + or never (instead was `{}`)", + arg).as_slice()) + } }; Options { diff --git a/src/librustc/driver/driver.rs b/src/librustc/driver/driver.rs index f51735afaceac..4e682e8e34bb2 100644 --- a/src/librustc/driver/driver.rs +++ b/src/librustc/driver/driver.rs @@ -511,7 +511,7 @@ fn write_out_deps(sess: &Session, Ok(()) => {} Err(e) => { sess.fatal(format!("error writing dependencies to `{}`: {}", - deps_filename.display(), e)); + deps_filename.display(), e).as_slice()); } } } @@ -705,7 +705,8 @@ fn print_flowgraph(analysis: CrateAnalysis, let m = "graphviz::render failed"; io::IoError { detail: Some(match orig_detail { - None => m.into_owned(), Some(d) => format!("{}: {}", m, d) + None => m.into_strbuf(), + Some(d) => format_strbuf!("{}: {}", m, d) }), ..ioerr } diff --git a/src/librustc/driver/mod.rs b/src/librustc/driver/mod.rs index 06d62c82ce1f2..2fb730e4daeec 100644 --- a/src/librustc/driver/mod.rs +++ b/src/librustc/driver/mod.rs @@ -120,7 +120,8 @@ Additional help: -C help Print codegen options -W help Print 'lint' options and default settings -Z help Print internal options for debugging rustc\n", - getopts::usage(message, config::optgroups().as_slice())); + getopts::usage(message.as_slice(), + config::optgroups().as_slice())); } fn describe_warnings() { @@ -142,8 +143,8 @@ Available lint options: for &(_, name) in lint_dict.iter() { max_key = cmp::max(name.len(), max_key); } - fn padded(max: uint, s: &str) -> ~str { - " ".repeat(max - s.len()) + s + fn padded(max: uint, s: &str) -> StrBuf { + format!("{}{}", " ".repeat(max - s.len()), s) } println!("\nAvailable lint checks:\n"); println!(" {} {:7.7s} {}", @@ -153,7 +154,7 @@ Available lint options: for (spec, name) in lint_dict.move_iter() { let name = name.replace("_", "-"); println!(" {} {:7.7s} {}", - padded(max_key, name), + padded(max_key, name.as_slice()), lint::level_to_str(spec.default), spec.desc); } @@ -305,16 +306,18 @@ pub fn parse_pretty(sess: &Session, name: &str) -> PpMode { (arg, "flowgraph") => { match arg.and_then(from_str) { Some(id) => PpmFlowGraph(id), - None => sess.fatal(format_strbuf!("`pretty flowgraph=` needs \ - an integer ; got {}", - arg.unwrap_or("nothing")).as_slice()) + None => { + sess.fatal(format!("`pretty flowgraph=` needs \ + an integer ; got {}", + arg.unwrap_or("nothing")).as_slice()) + } } } _ => { sess.fatal(format!( "argument to `pretty` must be one of `normal`, \ `expanded`, `flowgraph=`, `typed`, `identified`, \ - or `expanded,identified`; got {}", name)); + or `expanded,identified`; got {}", name).as_slice()); } } } @@ -397,18 +400,23 @@ fn monitor(f: proc():Send) { let xs = [ "the compiler hit an unexpected failure path. this is a bug.".to_owned(), - "we would appreciate a bug report: " + BUG_REPORT_URL, + format!("we would appreciate a bug report: {}", + BUG_REPORT_URL), "run with `RUST_BACKTRACE=1` for a backtrace".to_owned(), ]; for note in xs.iter() { - emitter.emit(None, *note, diagnostic::Note) + emitter.emit(None, note.as_slice(), diagnostic::Note) } match r.read_to_str() { Ok(s) => println!("{}", s), - Err(e) => emitter.emit(None, - format!("failed to read internal stderr: {}", e), - diagnostic::Error), + Err(e) => { + emitter.emit(None, + format!("failed to read internal \ + stderr: {}", + e).as_slice(), + diagnostic::Error) + } } } diff --git a/src/librustc/driver/session.rs b/src/librustc/driver/session.rs index e450fd200a6ae..19cc3a75e052b 100644 --- a/src/librustc/driver/session.rs +++ b/src/librustc/driver/session.rs @@ -141,7 +141,8 @@ impl Session { // This exists to help with refactoring to eliminate impossible // cases later on pub fn impossible_case(&self, sp: Span, msg: &str) -> ! { - self.span_bug(sp, format!("impossible case reached: {}", msg)); + self.span_bug(sp, + format!("impossible case reached: {}", msg).as_slice()); } pub fn verbose(&self) -> bool { self.debugging_opt(config::VERBOSE) } pub fn time_passes(&self) -> bool { self.debugging_opt(config::TIME_PASSES) } diff --git a/src/librustc/front/feature_gate.rs b/src/librustc/front/feature_gate.rs index b6022f5675926..21a7fc8d15044 100644 --- a/src/librustc/front/feature_gate.rs +++ b/src/librustc/front/feature_gate.rs @@ -109,7 +109,7 @@ impl<'a> Context<'a> { self.sess.span_err(span, explain); self.sess.span_note(span, format!("add \\#![feature({})] to the \ crate attributes to enable", - feature)); + feature).as_slice()); } } @@ -259,7 +259,9 @@ impl<'a> Visitor<()> for Context<'a> { else { for "e in quotes.iter() { if id == token::str_to_ident(quote) { - self.gate_feature("quote", path.span, quote + msg); + self.gate_feature("quote", + path.span, + format!("{}{}", quote, msg).as_slice()); } } } diff --git a/src/librustc/front/std_inject.rs b/src/librustc/front/std_inject.rs index 92bd81a40f246..efaeeaa557510 100644 --- a/src/librustc/front/std_inject.rs +++ b/src/librustc/front/std_inject.rs @@ -65,7 +65,7 @@ pub fn with_version(krate: &str) -> Option<(InternedString, ast::StrStyle)> { _ => { Some((token::intern_and_get_ident(format!("{}\\#{}", krate, - VERSION)), + VERSION).as_slice()), ast::CookedStr)) } } diff --git a/src/librustc/front/test.rs b/src/librustc/front/test.rs index 0ebd392e582fd..e7a5aeb9ef5aa 100644 --- a/src/librustc/front/test.rs +++ b/src/librustc/front/test.rs @@ -327,7 +327,7 @@ fn mk_test_module(cx: &TestCtxt) -> @ast::Item { pub fn main() { #![main] use std::slice::Vector; - test::test_main_static_x(::std::os::args().as_slice(), TESTS); + test::test_main_static(::std::os::args().as_slice(), TESTS); } )).unwrap(); diff --git a/src/librustc/metadata/creader.rs b/src/librustc/metadata/creader.rs index 5ed8da8a82b04..06a043b172fa7 100644 --- a/src/librustc/metadata/creader.rs +++ b/src/librustc/metadata/creader.rs @@ -91,7 +91,8 @@ fn warn_if_multiple_versions(diag: &SpanHandler, cstore: &CStore) { for ((name, _), dupes) in map.move_iter() { if dupes.len() == 1 { continue } diag.handler().warn( - format!("using multiple versions of crate `{}`", name)); + format!("using multiple versions of crate `{}`", + name).as_slice()); for dupe in dupes.move_iter() { let data = cstore.get_crate_data(dupe); diag.span_note(data.span, "used here"); @@ -161,7 +162,7 @@ fn extract_crate_info(e: &Env, i: &ast::ViewItem) -> Option { Some(id) => id } } - None => from_str(ident.get().to_str()).unwrap() + None => from_str(ident.get().to_str().as_slice()).unwrap() }; Some(CrateInfo { ident: ident.get().to_strbuf(), @@ -224,7 +225,8 @@ fn visit_item(e: &Env, i: &ast::Item) { cstore::NativeUnknown } else { e.sess.span_err(m.span, - format!("unknown kind: `{}`", k)); + format!("unknown kind: `{}`", + k).as_slice()); cstore::NativeUnknown } } @@ -243,7 +245,9 @@ fn visit_item(e: &Env, i: &ast::Item) { } }; if n.get().is_empty() { - e.sess.span_err(m.span, "#[link(name = \"\")] given with empty name"); + e.sess.span_err(m.span, + "#[link(name = \"\")] given with \ + empty name"); } else { e.sess .cstore @@ -425,7 +429,7 @@ impl<'a> CrateLoader for Loader<'a> { let message = format!("crate `{}` contains a macro_registrar fn but \ only a version for triple `{}` could be found (need {})", info.ident, target_triple, driver::host_triple()); - self.env.sess.span_err(krate.span, message); + self.env.sess.span_err(krate.span, message.as_slice()); // need to abort now because the syntax expansion // code will shortly attempt to load and execute // code from the found library. diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index 2e478419e77a9..a0742669cc07e 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -248,7 +248,7 @@ fn encode_symbol(ecx: &EncodeContext, } None => { ecx.diag.handler().bug( - format!("encode_symbol: id not found {}", id)); + format!("encode_symbol: id not found {}", id).as_slice()); } } ebml_w.end_tag(); @@ -375,7 +375,7 @@ fn encode_reexported_static_method(ebml_w: &mut Encoder, ebml_w.start_tag(tag_items_data_item_reexport_name); ebml_w.wr_str(format!("{}::{}", exp.name, - token::get_ident(method_ident))); + token::get_ident(method_ident)).as_slice()); ebml_w.end_tag(); ebml_w.end_tag(); } @@ -602,7 +602,7 @@ fn encode_visibility(ebml_w: &mut Encoder, visibility: Visibility) { Public => 'y', Inherited => 'i', }; - ebml_w.wr_str(str::from_char(ch)); + ebml_w.wr_str(str::from_char(ch).as_slice()); ebml_w.end_tag(); } @@ -848,7 +848,7 @@ fn encode_sized(ebml_w: &mut Encoder, sized: Sized) { DynSize => 'd', StaticSize => 's', }; - ebml_w.wr_str(str::from_char(ch)); + ebml_w.wr_str(str::from_char(ch).as_slice()); ebml_w.end_tag(); } @@ -1439,7 +1439,10 @@ fn synthesize_crate_attrs(ecx: &EncodeContext, attr::mk_attr_inner( attr::mk_name_value_item_str( InternedString::new("crate_id"), - token::intern_and_get_ident(ecx.link_meta.crateid.to_str()))) + token::intern_and_get_ident(ecx.link_meta + .crateid + .to_str() + .as_slice()))) } let mut attrs = Vec::new(); @@ -1882,5 +1885,5 @@ pub fn encoded_ty(tcx: &ty::ctxt, t: ty::t) -> StrBuf { tcx: tcx, abbrevs: &RefCell::new(HashMap::new()) }, t); - str::from_utf8_owned(wr.get_ref().to_owned()).unwrap().to_strbuf() + str::from_utf8_owned(Vec::from_slice(wr.get_ref())).unwrap().to_strbuf() } diff --git a/src/librustc/metadata/loader.rs b/src/librustc/metadata/loader.rs index 456259d1a5d04..9a63aad893f5f 100644 --- a/src/librustc/metadata/loader.rs +++ b/src/librustc/metadata/loader.rs @@ -137,15 +137,17 @@ impl<'a> Context<'a> { &Some(ref r) => format!("{} which `{}` depends on", message, r.ident) }; - self.sess.span_err(self.span, message); + self.sess.span_err(self.span, message.as_slice()); let mismatches = self.rejected_via_triple.iter(); if self.rejected_via_triple.len() > 0 { - self.sess.span_note(self.span, format!("expected triple of {}", self.triple)); + self.sess.span_note(self.span, + format!("expected triple of {}", + self.triple).as_slice()); for (i, &CrateMismatch{ ref path, ref got }) in mismatches.enumerate() { self.sess.fileline_note(self.span, format!("crate `{}` path \\#{}, triple {}: {}", - self.ident, i+1, got, path.display())); + self.ident, i+1, got, path.display()).as_slice()); } } if self.rejected_via_hash.len() > 0 { @@ -155,7 +157,7 @@ impl<'a> Context<'a> { for (i, &CrateMismatch{ ref path, .. }) in mismatches.enumerate() { self.sess.fileline_note(self.span, format!("crate `{}` path \\#{}: {}", - self.ident, i+1, path.display())); + self.ident, i+1, path.display()).as_slice()); } match self.root { &None => {} @@ -163,7 +165,7 @@ impl<'a> Context<'a> { for (i, path) in r.paths().iter().enumerate() { self.sess.fileline_note(self.span, format!("crate `{}` path \\#{}: {}", - r.ident, i+1, path.display())); + r.ident, i+1, path.display()).as_slice()); } } } @@ -198,9 +200,10 @@ impl<'a> Context<'a> { None => return FileDoesntMatch, Some(file) => file, }; - if file.starts_with(rlib_prefix) && file.ends_with(".rlib") { + if file.starts_with(rlib_prefix.as_slice()) && + file.ends_with(".rlib") { info!("rlib candidate: {}", path.display()); - match self.try_match(file, rlib_prefix, ".rlib") { + match self.try_match(file, rlib_prefix.as_slice(), ".rlib") { Some(hash) => { info!("rlib accepted, hash: {}", hash); let slot = candidates.find_or_insert_with(hash, |_| { @@ -215,9 +218,12 @@ impl<'a> Context<'a> { FileDoesntMatch } } - } else if file.starts_with(dylib_prefix) && file.ends_with(dysuffix){ + } else if file.starts_with(dylib_prefix.as_slice()) && + file.ends_with(dysuffix){ info!("dylib candidate: {}", path.display()); - match self.try_match(file, dylib_prefix, dysuffix) { + match self.try_match(file, + dylib_prefix.as_slice(), + dysuffix) { Some(hash) => { info!("dylib accepted, hash: {}", hash); let slot = candidates.find_or_insert_with(hash, |_| { @@ -271,18 +277,20 @@ impl<'a> Context<'a> { _ => { self.sess.span_err(self.span, format!("multiple matching crates for `{}`", - self.crate_id.name)); + self.crate_id.name).as_slice()); self.sess.note("candidates:"); for lib in libraries.iter() { match lib.dylib { Some(ref p) => { - self.sess.note(format!("path: {}", p.display())); + self.sess.note(format!("path: {}", + p.display()).as_slice()); } None => {} } match lib.rlib { Some(ref p) => { - self.sess.note(format!("path: {}", p.display())); + self.sess.note(format!("path: {}", + p.display()).as_slice()); } None => {} } @@ -375,10 +383,13 @@ impl<'a> Context<'a> { if ret.is_some() { self.sess.span_err(self.span, format!("multiple {} candidates for `{}` \ - found", flavor, self.crate_id.name)); + found", + flavor, + self.crate_id.name).as_slice()); self.sess.span_note(self.span, format!(r"candidate \#1: {}", - ret.get_ref().display())); + ret.get_ref() + .display()).as_slice()); error = 1; ret = None; } @@ -386,7 +397,7 @@ impl<'a> Context<'a> { error += 1; self.sess.span_note(self.span, format!(r"candidate \#{}: {}", error, - lib.display())); + lib.display()).as_slice()); continue } *slot = Some(metadata); @@ -450,7 +461,7 @@ impl<'a> Context<'a> { } pub fn note_crateid_attr(diag: &SpanHandler, crateid: &CrateId) { - diag.handler().note(format!("crate_id: {}", crateid.to_str())); + diag.handler().note(format!("crate_id: {}", crateid.to_str()).as_slice()); } impl ArchiveMetadata { @@ -541,7 +552,7 @@ fn get_metadata_section_imp(os: Os, filename: &Path) -> Result ty::TraitStore { match next(st) { '~' => ty::UniqTraitStore, '&' => ty::RegionTraitStore(parse_region(st, conv), parse_mutability(st)), - c => st.tcx.sess.bug(format!("parse_trait_store(): bad input '{}'", c)) + c => { + st.tcx.sess.bug(format!("parse_trait_store(): bad input '{}'", + c).as_slice()) + } } } @@ -449,7 +452,7 @@ fn parse_abi_set(st: &mut PState) -> abi::Abi { assert_eq!(next(st), '['); scan(st, |c| c == ']', |bytes| { let abi_str = str::from_utf8(bytes).unwrap().to_owned(); - abi::lookup(abi_str).expect(abi_str) + abi::lookup(abi_str.as_slice()).expect(abi_str) }) } diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index f46fe9a8b2491..8956beb33f453 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -1312,7 +1312,8 @@ fn decode_side_tables(xcx: &ExtendedDecodeContext, match c::astencode_tag::from_uint(tag) { None => { xcx.dcx.tcx.sess.bug( - format!("unknown tag found in side tables: {:x}", tag)); + format!("unknown tag found in side tables: {:x}", + tag).as_slice()); } Some(value) => { let val_doc = entry_doc.get(c::tag_table_val as uint); @@ -1376,7 +1377,8 @@ fn decode_side_tables(xcx: &ExtendedDecodeContext, } _ => { xcx.dcx.tcx.sess.bug( - format!("unknown tag found in side tables: {:x}", tag)); + format!("unknown tag found in side tables: {:x}", + tag).as_slice()); } } } diff --git a/src/librustc/middle/borrowck/check_loans.rs b/src/librustc/middle/borrowck/check_loans.rs index a24e7d6638066..65ecec2d2ed9f 100644 --- a/src/librustc/middle/borrowck/check_loans.rs +++ b/src/librustc/middle/borrowck/check_loans.rs @@ -243,7 +243,7 @@ impl<'a> CheckLoanCtxt<'a> { if restr.loan_path != loan2.loan_path { continue; } let old_pronoun = if new_loan.loan_path == old_loan.loan_path { - "it".to_owned() + "it".to_strbuf() } else { format!("`{}`", self.bccx.loan_path_to_str(&*old_loan.loan_path)) @@ -255,7 +255,8 @@ impl<'a> CheckLoanCtxt<'a> { new_loan.span, format!("cannot borrow `{}` as mutable \ more than once at a time", - self.bccx.loan_path_to_str(&*new_loan.loan_path))); + self.bccx.loan_path_to_str( + &*new_loan.loan_path)).as_slice()); } (ty::UniqueImmBorrow, _) => { @@ -264,7 +265,7 @@ impl<'a> CheckLoanCtxt<'a> { format!("closure requires unique access to `{}` \ but {} is already borrowed", self.bccx.loan_path_to_str(&*new_loan.loan_path), - old_pronoun)); + old_pronoun).as_slice()); } (_, ty::UniqueImmBorrow) => { @@ -273,7 +274,7 @@ impl<'a> CheckLoanCtxt<'a> { format!("cannot borrow `{}` as {} because \ previous closure requires unique access", self.bccx.loan_path_to_str(&*new_loan.loan_path), - new_loan.kind.to_user_str())); + new_loan.kind.to_user_str()).as_slice()); } (_, _) => { @@ -284,7 +285,7 @@ impl<'a> CheckLoanCtxt<'a> { self.bccx.loan_path_to_str(&*new_loan.loan_path), new_loan.kind.to_user_str(), old_pronoun, - old_loan.kind.to_user_str())); + old_loan.kind.to_user_str()).as_slice()); } } @@ -293,7 +294,8 @@ impl<'a> CheckLoanCtxt<'a> { self.bccx.span_note( span, format!("borrow occurs due to use of `{}` in closure", - self.bccx.loan_path_to_str(&*new_loan.loan_path))); + self.bccx.loan_path_to_str( + &*new_loan.loan_path)).as_slice()); } _ => { } } @@ -303,7 +305,8 @@ impl<'a> CheckLoanCtxt<'a> { format!("the mutable borrow prevents subsequent \ moves, borrows, or modification of `{0}` \ until the borrow ends", - self.bccx.loan_path_to_str(&*old_loan.loan_path)) + self.bccx.loan_path_to_str( + &*old_loan.loan_path)) } ty::ImmBorrow => { @@ -340,7 +343,7 @@ impl<'a> CheckLoanCtxt<'a> { self.bccx.span_note( old_loan.span, - format!("{}; {}", borrow_summary, rule_summary)); + format!("{}; {}", borrow_summary, rule_summary).as_slice()); let old_loan_span = self.tcx().map.span(old_loan.kill_scope); self.bccx.span_end_note(old_loan_span, @@ -428,14 +431,14 @@ impl<'a> CheckLoanCtxt<'a> { format!("cannot assign to {} {} `{}`", cmt.mutbl.to_user_str(), self.bccx.cmt_to_str(&*cmt), - self.bccx.loan_path_to_str(&*lp))); + self.bccx.loan_path_to_str(&*lp)).as_slice()); } None => { self.bccx.span_err( expr.span, format!("cannot assign to {} {}", cmt.mutbl.to_user_str(), - self.bccx.cmt_to_str(&*cmt))); + self.bccx.cmt_to_str(&*cmt)).as_slice()); } } return; @@ -672,11 +675,11 @@ impl<'a> CheckLoanCtxt<'a> { self.bccx.span_err( expr.span, format!("cannot assign to `{}` because it is borrowed", - self.bccx.loan_path_to_str(loan_path))); + self.bccx.loan_path_to_str(loan_path)).as_slice()); self.bccx.span_note( loan.span, format!("borrow of `{}` occurs here", - self.bccx.loan_path_to_str(loan_path))); + self.bccx.loan_path_to_str(loan_path)).as_slice()); } fn check_move_out_from_expr(&self, expr: &ast::Expr) { @@ -702,11 +705,13 @@ impl<'a> CheckLoanCtxt<'a> { span, format!("cannot move out of `{}` \ because it is borrowed", - self.bccx.loan_path_to_str(move_path))); + self.bccx.loan_path_to_str( + move_path)).as_slice()); self.bccx.span_note( loan_span, format!("borrow of `{}` occurs here", - self.bccx.loan_path_to_str(&*loan_path))); + self.bccx.loan_path_to_str( + &*loan_path)).as_slice()); } } true @@ -745,11 +750,13 @@ impl<'a> CheckLoanCtxt<'a> { freevar.span, format!("cannot move `{}` into closure \ because it is borrowed", - this.bccx.loan_path_to_str(move_path))); + this.bccx.loan_path_to_str( + move_path)).as_slice()); this.bccx.span_note( loan_span, format!("borrow of `{}` occurs here", - this.bccx.loan_path_to_str(&*loan_path))); + this.bccx.loan_path_to_str( + &*loan_path)).as_slice()); } } } diff --git a/src/librustc/middle/borrowck/gather_loans/mod.rs b/src/librustc/middle/borrowck/gather_loans/mod.rs index b351c99084de3..d34ce7f6a5f24 100644 --- a/src/librustc/middle/borrowck/gather_loans/mod.rs +++ b/src/librustc/middle/borrowck/gather_loans/mod.rs @@ -174,8 +174,9 @@ fn check_aliasability(bccx: &BorrowckCtxt, // static item resides in immutable memory and mutating it would // cause segfaults. bccx.tcx.sess.span_err(borrow_span, - format!("borrow of immutable static items with \ - unsafe interior is not allowed")); + "borrow of immutable static items \ + with unsafe interior is not \ + allowed"); Err(()) } mc::InteriorSafe => { @@ -290,7 +291,8 @@ impl<'a> GatherLoanCtxt<'a> { ty::ReInfer(..) => { self.tcx().sess.span_bug( cmt.span, - format!("invalid borrow lifetime: {:?}", loan_region)); + format!("invalid borrow lifetime: {:?}", + loan_region).as_slice()); } }; debug!("loan_scope = {:?}", loan_scope); diff --git a/src/librustc/middle/borrowck/gather_loans/move_error.rs b/src/librustc/middle/borrowck/gather_loans/move_error.rs index 4662074aa47fb..925244849bc8a 100644 --- a/src/librustc/middle/borrowck/gather_loans/move_error.rs +++ b/src/librustc/middle/borrowck/gather_loans/move_error.rs @@ -131,7 +131,7 @@ fn report_cannot_move_out_of(bccx: &BorrowckCtxt, move_from: mc::cmt) { bccx.span_err( move_from.span, format!("cannot move out of {}", - bccx.cmt_to_str(&*move_from))); + bccx.cmt_to_str(&*move_from)).as_slice()); } mc::cat_downcast(ref b) | @@ -143,7 +143,7 @@ fn report_cannot_move_out_of(bccx: &BorrowckCtxt, move_from: mc::cmt) { move_from.span, format!("cannot move out of type `{}`, \ which defines the `Drop` trait", - b.ty.user_string(bccx.tcx))); + b.ty.user_string(bccx.tcx)).as_slice()); }, _ => fail!("this path should not cause illegal move") } @@ -163,10 +163,10 @@ fn note_move_destination(bccx: &BorrowckCtxt, format!("attempting to move value to here (to prevent the move, \ use `ref {0}` or `ref mut {0}` to capture value by \ reference)", - pat_name)); + pat_name).as_slice()); } else { bccx.span_note(move_to_span, format!("and here (use `ref {0}` or `ref mut {0}`)", - pat_name)); + pat_name).as_slice()); } } diff --git a/src/librustc/middle/borrowck/mod.rs b/src/librustc/middle/borrowck/mod.rs index 0f67520d8d3bc..2060932875de6 100644 --- a/src/librustc/middle/borrowck/mod.rs +++ b/src/librustc/middle/borrowck/mod.rs @@ -460,17 +460,17 @@ impl<'a> BorrowckCtxt<'a> { self.tcx.sess.span_err( use_span, format!("{} of possibly uninitialized variable: `{}`", - verb, - self.loan_path_to_str(lp))); + verb, + self.loan_path_to_str(lp)).as_slice()); } _ => { let partially = if lp == moved_lp {""} else {"partially "}; self.tcx.sess.span_err( use_span, format!("{} of {}moved value: `{}`", - verb, - partially, - self.loan_path_to_str(lp))); + verb, + partially, + self.loan_path_to_str(lp)).as_slice()); } } @@ -482,25 +482,31 @@ impl<'a> BorrowckCtxt<'a> { Some(ast_map::NodeExpr(expr)) => { (ty::expr_ty_adjusted(self.tcx, expr), expr.span) } - r => self.tcx.sess.bug(format!("MoveExpr({:?}) maps to {:?}, not Expr", - move.id, r)) + r => { + self.tcx.sess.bug(format!("MoveExpr({:?}) maps to \ + {:?}, not Expr", + move.id, + r).as_slice()) + } }; let suggestion = move_suggestion(self.tcx, expr_ty, "moved by default (use `copy` to override)"); self.tcx.sess.span_note( expr_span, format!("`{}` moved here because it has type `{}`, which is {}", - self.loan_path_to_str(moved_lp), - expr_ty.user_string(self.tcx), suggestion)); + self.loan_path_to_str(moved_lp), + expr_ty.user_string(self.tcx), + suggestion).as_slice()); } move_data::MovePat => { let pat_ty = ty::node_id_to_type(self.tcx, move.id); self.tcx.sess.span_note(self.tcx.map.span(move.id), format!("`{}` moved here because it has type `{}`, \ - which is moved by default (use `ref` to override)", - self.loan_path_to_str(moved_lp), - pat_ty.user_string(self.tcx))); + which is moved by default (use `ref` to \ + override)", + self.loan_path_to_str(moved_lp), + pat_ty.user_string(self.tcx)).as_slice()); } move_data::Captured => { @@ -508,8 +514,12 @@ impl<'a> BorrowckCtxt<'a> { Some(ast_map::NodeExpr(expr)) => { (ty::expr_ty_adjusted(self.tcx, expr), expr.span) } - r => self.tcx.sess.bug(format!("Captured({:?}) maps to {:?}, not Expr", - move.id, r)) + r => { + self.tcx.sess.bug(format!("Captured({:?}) maps to \ + {:?}, not Expr", + move.id, + r).as_slice()) + } }; let suggestion = move_suggestion(self.tcx, expr_ty, "moved by default (make a copy and \ @@ -517,9 +527,10 @@ impl<'a> BorrowckCtxt<'a> { self.tcx.sess.span_note( expr_span, format!("`{}` moved into closure environment here because it \ - has type `{}`, which is {}", - self.loan_path_to_str(moved_lp), - expr_ty.user_string(self.tcx), suggestion)); + has type `{}`, which is {}", + self.loan_path_to_str(moved_lp), + expr_ty.user_string(self.tcx), + suggestion).as_slice()); } } @@ -547,10 +558,8 @@ impl<'a> BorrowckCtxt<'a> { self.tcx.sess.span_err( span, format!("re-assignment of immutable variable `{}`", - self.loan_path_to_str(lp))); - self.tcx.sess.span_note( - assign.span, - format!("prior assignment occurs here")); + self.loan_path_to_str(lp)).as_slice()); + self.tcx.sess.span_note(assign.span, "prior assignment occurs here"); } pub fn span_err(&self, s: Span, m: &str) { @@ -657,23 +666,23 @@ impl<'a> BorrowckCtxt<'a> { self.tcx.sess.span_err( span, format!("{} in an aliasable location", - prefix)); + prefix).as_slice()); } mc::AliasableStatic(..) | mc::AliasableStaticMut(..) => { self.tcx.sess.span_err( span, - format!("{} in a static location", prefix)); + format!("{} in a static location", prefix).as_slice()); } mc::AliasableManaged => { self.tcx.sess.span_err( span, - format!("{} in a `@` pointer", prefix)); + format!("{} in a `@` pointer", prefix).as_slice()); } mc::AliasableBorrowed => { self.tcx.sess.span_err( span, - format!("{} in a `&` reference", prefix)); + format!("{} in a `&` reference", prefix).as_slice()); } } } @@ -689,11 +698,16 @@ impl<'a> BorrowckCtxt<'a> { "reference must be valid for ", sub_scope, "..."); + let suggestion = if is_statement_scope(self.tcx, super_scope) { + "; consider using a `let` binding to increase its lifetime" + } else { + "" + }; note_and_explain_region( self.tcx, "...but borrowed value is only valid for ", super_scope, - ""); + suggestion); } err_borrowed_pointer_too_short(loan_scope, ptr_scope, _) => { @@ -705,12 +719,13 @@ impl<'a> BorrowckCtxt<'a> { }; note_and_explain_region( self.tcx, - format!("{} would have to be valid for ", descr), + format!("{} would have to be valid for ", + descr).as_slice(), loan_scope, "..."); note_and_explain_region( self.tcx, - format!("...but {} is only valid for ", descr), + format!("...but {} is only valid for ", descr).as_slice(), ptr_scope, ""); } @@ -734,7 +749,7 @@ impl<'a> BorrowckCtxt<'a> { } mc::PositionalField(idx) => { out.push_char('#'); // invent a notation here - out.push_str(idx.to_str()); + out.push_str(idx.to_str().as_slice()); } } } @@ -779,6 +794,18 @@ impl<'a> BorrowckCtxt<'a> { } } +fn is_statement_scope(tcx: &ty::ctxt, region: ty::Region) -> bool { + match region { + ty::ReScope(node_id) => { + match tcx.map.find(node_id) { + Some(ast_map::NodeStmt(_)) => true, + _ => false + } + } + _ => false + } +} + impl DataFlowOperator for LoanDataFlowOperator { #[inline] fn initial_value(&self) -> bool { diff --git a/src/librustc/middle/cfg/construct.rs b/src/librustc/middle/cfg/construct.rs index c9c397d3d6121..acf2442f6c16b 100644 --- a/src/librustc/middle/cfg/construct.rs +++ b/src/librustc/middle/cfg/construct.rs @@ -508,7 +508,9 @@ impl<'a> CFGBuilder<'a> { fn add_returning_edge(&mut self, _from_expr: @ast::Expr, from_index: CFGIndex) { - let mut data = CFGEdgeData {exiting_scopes: vec!() }; + let mut data = CFGEdgeData { + exiting_scopes: vec!(), + }; for &LoopScope { loop_id: id, .. } in self.loop_scopes.iter().rev() { data.exiting_scopes.push(id); } @@ -533,13 +535,15 @@ impl<'a> CFGBuilder<'a> { } self.tcx.sess.span_bug( expr.span, - format!("no loop scope for id {:?}", loop_id)); + format!("no loop scope for id {:?}", + loop_id).as_slice()); } r => { self.tcx.sess.span_bug( expr.span, - format!("bad entry `{:?}` in def_map for label", r)); + format!("bad entry `{:?}` in def_map for label", + r).as_slice()); } } } diff --git a/src/librustc/middle/cfg/graphviz.rs b/src/librustc/middle/cfg/graphviz.rs index b8baeefd3d02e..3d69e84b63c92 100644 --- a/src/librustc/middle/cfg/graphviz.rs +++ b/src/librustc/middle/cfg/graphviz.rs @@ -37,7 +37,8 @@ fn replace_newline_with_backslash_l(s: StrBuf) -> StrBuf { // \l, not the line that follows; so, add \l at end of string // if not already present, ensuring last line gets left-aligned // as well. - let mut last_two : Vec<_> = s.chars().rev().take(2).collect(); + let mut last_two: Vec<_> = + s.as_slice().chars().rev().take(2).collect(); last_two.reverse(); if last_two.as_slice() != ['\\', 'l'] { s = s.append("\\l"); @@ -82,7 +83,9 @@ impl<'a> dot::Labeller<'a, Node<'a>, Edge<'a>> for LabelledCFG<'a> { let s = self.ast_map.node_to_str(node_id); // left-aligns the lines let s = replace_newline_with_backslash_l(s); - label = label.append(format!("exiting scope_{} {}", i, s.as_slice())); + label = label.append(format!("exiting scope_{} {}", + i, + s.as_slice()).as_slice()); } dot::EscStr(label.into_maybe_owned()) } diff --git a/src/librustc/middle/check_const.rs b/src/librustc/middle/check_const.rs index 7da56655378ed..64b7977c2351e 100644 --- a/src/librustc/middle/check_const.rs +++ b/src/librustc/middle/check_const.rs @@ -107,7 +107,7 @@ fn check_expr(v: &mut CheckCrateVisitor, e: &Expr, is_const: bool) { .span_err(e.span, format!("can not cast to `{}` in a constant \ expression", - ppaux::ty_to_str(v.tcx, ety).as_slice())) + ppaux::ty_to_str(v.tcx, ety)).as_slice()) } } ExprPath(ref pth) => { diff --git a/src/librustc/middle/check_loop.rs b/src/librustc/middle/check_loop.rs index 4f08d818f4a13..6e738b1430833 100644 --- a/src/librustc/middle/check_loop.rs +++ b/src/librustc/middle/check_loop.rs @@ -57,10 +57,14 @@ impl<'a> CheckLoopVisitor<'a> { match cx { Loop => {} Closure => { - self.sess.span_err(span, format!("`{}` inside of a closure", name)); + self.sess.span_err(span, + format!("`{}` inside of a closure", + name).as_slice()); } Normal => { - self.sess.span_err(span, format!("`{}` outside of loop", name)); + self.sess.span_err(span, + format!("`{}` outside of loop", + name).as_slice()); } } } diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index 7b91928ba4145..fb797a027956f 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -74,7 +74,7 @@ fn check_expr(cx: &mut MatchCheckCtxt, ex: &Expr) { // We know the type is inhabited, so this must be wrong cx.tcx.sess.span_err(ex.span, format!("non-exhaustive patterns: \ type {} is non-empty", - ty_to_str(cx.tcx, pat_ty))); + ty_to_str(cx.tcx, pat_ty)).as_slice()); } // If the type *is* empty, it's vacuously exhaustive return; @@ -164,8 +164,8 @@ fn check_exhaustive(cx: &MatchCheckCtxt, sp: Span, pats: Vec<@Pat> ) { match ty::get(ty).sty { ty::ty_bool => { match *ctor { - val(const_bool(true)) => Some("true".to_owned()), - val(const_bool(false)) => Some("false".to_owned()), + val(const_bool(true)) => Some("true".to_strbuf()), + val(const_bool(false)) => Some("false".to_strbuf()), _ => None } } @@ -177,7 +177,11 @@ fn check_exhaustive(cx: &MatchCheckCtxt, sp: Span, pats: Vec<@Pat> ) { let variants = ty::enum_variants(cx.tcx, id); match variants.iter().find(|v| v.id == vid) { - Some(v) => Some(token::get_ident(v.name).get().to_str()), + Some(v) => { + Some(token::get_ident(v.name).get() + .to_str() + .into_strbuf()) + } None => { fail!("check_exhaustive: bad variant in ctor") } @@ -185,7 +189,9 @@ fn check_exhaustive(cx: &MatchCheckCtxt, sp: Span, pats: Vec<@Pat> ) { } ty::ty_vec(..) | ty::ty_rptr(..) => { match *ctor { - vec(n) => Some(format!("vectors of length {}", n)), + vec(n) => { + Some(format_strbuf!("vectors of length {}", n)) + } _ => None } } @@ -193,11 +199,11 @@ fn check_exhaustive(cx: &MatchCheckCtxt, sp: Span, pats: Vec<@Pat> ) { } } }; - let msg = "non-exhaustive patterns".to_owned() + match ext { - Some(ref s) => format!(": {} not covered", *s), - None => "".to_owned() - }; - cx.tcx.sess.span_err(sp, msg); + let msg = format_strbuf!("non-exhaustive patterns{}", match ext { + Some(ref s) => format_strbuf!(": {} not covered", *s), + None => "".to_strbuf() + }); + cx.tcx.sess.span_err(sp, msg.as_slice()); } type matrix = Vec > ; @@ -739,7 +745,8 @@ fn specialize(cx: &MatchCheckCtxt, pat_span, format!("struct pattern resolved to {}, \ not a struct", - ty_to_str(cx.tcx, left_ty))); + ty_to_str(cx.tcx, + left_ty)).as_slice()); } } let args = class_fields.iter().map(|class_field| { @@ -980,9 +987,10 @@ fn check_legality_of_move_bindings(cx: &MatchCheckCtxt, _ => { cx.tcx.sess.span_bug( p.span, - format!("binding pattern {} is \ - not an identifier: {:?}", - p.id, p.node)); + format!("binding pattern {} is not an \ + identifier: {:?}", + p.id, + p.node).as_slice()); } } } diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index aa0b573eba8c8..2a1334db2d085 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -436,10 +436,11 @@ pub fn eval_const_expr_partial(tcx: &T, e: &Expr) // (#5900). Fall back to doing a limited lookup to get past it. let ety = ty::expr_ty_opt(tcx.ty_ctxt(), e) .or_else(|| astconv::ast_ty_to_prim_ty(tcx.ty_ctxt(), target_ty)) - .unwrap_or_else(|| tcx.ty_ctxt().sess.span_fatal( - target_ty.span, - format!("target type not found for const cast") - )); + .unwrap_or_else(|| { + tcx.ty_ctxt().sess.span_fatal(target_ty.span, + "target type not found for \ + const cast") + }); let base = eval_const_expr_partial(tcx, base); match base { diff --git a/src/librustc/middle/dataflow.rs b/src/librustc/middle/dataflow.rs index 34a97c15f5c45..a1de47f2fa8a6 100644 --- a/src/librustc/middle/dataflow.rs +++ b/src/librustc/middle/dataflow.rs @@ -102,14 +102,14 @@ impl<'a, O:DataFlowOperator> pprust::PpAnn for DataFlowContext<'a, O> { let gens_str = if gens.iter().any(|&u| u != 0) { format!(" gen: {}", bits_to_str(gens)) } else { - "".to_owned() + "".to_strbuf() }; let kills = self.kills.slice(start, end); let kills_str = if kills.iter().any(|&u| u != 0) { format!(" kill: {}", bits_to_str(kills)) } else { - "".to_owned() + "".to_strbuf() }; try!(ps.synth_comment(format_strbuf!("id {}: {}{}{}", @@ -652,8 +652,9 @@ impl<'a, 'b, O:DataFlowOperator> PropagationContext<'a, 'b, O> { tcx.sess.span_bug( from_expr.span, format!("pop_scopes(from_expr={}, to_scope={:?}) \ - to_scope does not enclose from_expr", - from_expr.repr(tcx), to_scope.loop_id)); + to_scope does not enclose from_expr", + from_expr.repr(tcx), + to_scope.loop_id).as_slice()); } } } @@ -765,7 +766,8 @@ impl<'a, 'b, O:DataFlowOperator> PropagationContext<'a, 'b, O> { None => { self.tcx().sess.span_bug( expr.span, - format!("no loop scope for id {:?}", loop_id)); + format!("no loop scope for id {:?}", + loop_id).as_slice()); } } } @@ -773,7 +775,8 @@ impl<'a, 'b, O:DataFlowOperator> PropagationContext<'a, 'b, O> { r => { self.tcx().sess.span_bug( expr.span, - format!("bad entry `{:?}` in def_map for label", r)); + format!("bad entry `{:?}` in def_map for label", + r).as_slice()); } } } @@ -789,7 +792,9 @@ impl<'a, 'b, O:DataFlowOperator> PropagationContext<'a, 'b, O> { fn reset(&mut self, bits: &mut [uint]) { let e = if self.dfcx.oper.initial_value() {uint::MAX} else {0}; - for b in bits.mut_iter() { *b = e; } + for b in bits.mut_iter() { + *b = e; + } } fn add_to_entry_set(&mut self, id: ast::NodeId, pred_bits: &[uint]) { @@ -841,7 +846,7 @@ fn bits_to_str(words: &[uint]) -> StrBuf { let mut v = word; for _ in range(0u, uint::BYTES) { result.push_char(sep); - result.push_str(format!("{:02x}", v & 0xFF)); + result.push_str(format!("{:02x}", v & 0xFF).as_slice()); v >>= 8; sep = '-'; } diff --git a/src/librustc/middle/dependency_format.rs b/src/librustc/middle/dependency_format.rs index ae88d64e2f0c9..b9288fd9fe56f 100644 --- a/src/librustc/middle/dependency_format.rs +++ b/src/librustc/middle/dependency_format.rs @@ -118,7 +118,7 @@ fn calculate_type(sess: &session::Session, let src = sess.cstore.get_used_crate_source(cnum).unwrap(); if src.rlib.is_some() { return } sess.err(format!("dependency `{}` not found in rlib format", - data.name)); + data.name).as_slice()); }); return Vec::new(); } @@ -187,7 +187,7 @@ fn calculate_type(sess: &session::Session, match kind { cstore::RequireStatic => "rlib", cstore::RequireDynamic => "dylib", - })); + }).as_slice()); } } } @@ -211,7 +211,8 @@ fn add_library(sess: &session::Session, if link2 != link || link == cstore::RequireStatic { let data = sess.cstore.get_crate_data(cnum); sess.err(format!("cannot satisfy dependencies so `{}` only \ - shows up once", data.name)); + shows up once", + data.name).as_slice()); sess.note("having upstream crates all available in one format \ will likely make this go away"); } diff --git a/src/librustc/middle/effect.rs b/src/librustc/middle/effect.rs index 2819d7493a668..b3b09ba631e26 100644 --- a/src/librustc/middle/effect.rs +++ b/src/librustc/middle/effect.rs @@ -48,8 +48,9 @@ impl<'a> EffectCheckVisitor<'a> { SafeContext => { // Report an error. self.tcx.sess.span_err(span, - format!("{} requires unsafe function or block", - description)) + format!("{} requires unsafe function or \ + block", + description).as_slice()) } UnsafeBlock(block_id) => { // OK, but record this. diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs index f397734006469..9d735dbaeae56 100644 --- a/src/librustc/middle/expr_use_visitor.rs +++ b/src/librustc/middle/expr_use_visitor.rs @@ -422,7 +422,7 @@ impl<'d,'t,TYPER:mc::Typer> ExprUseVisitor<'d,'t,TYPER> { self.tcx().sess.span_bug( callee.span, format!("unxpected callee type {}", - callee_ty.repr(self.tcx()))); + callee_ty.repr(self.tcx())).as_slice()); } } } @@ -448,9 +448,7 @@ impl<'d,'t,TYPER:mc::Typer> ExprUseVisitor<'d,'t,TYPER> { } ast::StmtMac(..) => { - self.tcx().sess.span_bug( - stmt.span, - format!("unexpanded stmt macro")); + self.tcx().sess.span_bug(stmt.span, "unexpanded stmt macro"); } } } @@ -518,7 +516,7 @@ impl<'d,'t,TYPER:mc::Typer> ExprUseVisitor<'d,'t,TYPER> { _ => { self.tcx().sess.span_bug( with_expr.span, - format!("with expression doesn't evaluate to a struct")); + "with expression doesn't evaluate to a struct"); } }; @@ -601,7 +599,7 @@ impl<'d,'t,TYPER:mc::Typer> ExprUseVisitor<'d,'t,TYPER> { ty::ty_rptr(r, ref m) => (m.mutbl, r), _ => self.tcx().sess.span_bug(expr.span, format!("bad overloaded deref type {}", - method_ty.repr(self.tcx()))) + method_ty.repr(self.tcx())).as_slice()) }; let bk = ty::BorrowKind::from_mutbl(m); self.delegate.borrow(expr.id, expr.span, cmt, diff --git a/src/librustc/middle/kind.rs b/src/librustc/middle/kind.rs index 81d6fc87a919c..64fa1a7270c9c 100644 --- a/src/librustc/middle/kind.rs +++ b/src/librustc/middle/kind.rs @@ -127,10 +127,12 @@ fn check_impl_of_trait(cx: &mut Context, it: &Item, trait_ref: &TraitRef, self_t check_builtin_bounds(cx, self_ty, trait_def.bounds, |missing| { cx.tcx.sess.span_err(self_type.span, format!("the type `{}', which does not fulfill `{}`, cannot implement this \ - trait", ty_to_str(cx.tcx, self_ty), missing.user_string(cx.tcx))); + trait", + ty_to_str(cx.tcx, self_ty), + missing.user_string(cx.tcx)).as_slice()); cx.tcx.sess.span_note(self_type.span, format!("types implementing this trait must fulfill `{}`", - trait_def.bounds.user_string(cx.tcx))); + trait_def.bounds.user_string(cx.tcx)).as_slice()); }); // If this is a destructor, check kinds. @@ -210,8 +212,9 @@ fn with_appropriate_checker(cx: &Context, b(check_for_bare) } ref s => { - cx.tcx.sess.bug( - format!("expect fn type in kind checker, not {:?}", s)); + cx.tcx.sess.bug(format!("expect fn type in kind checker, not \ + {:?}", + s).as_slice()); } } } @@ -390,9 +393,9 @@ pub fn check_typaram_bounds(cx: &Context, cx.tcx.sess.span_err( sp, format!("instantiating a type parameter with an incompatible type \ - `{}`, which does not fulfill `{}`", - ty_to_str(cx.tcx, ty), - missing.user_string(cx.tcx))); + `{}`, which does not fulfill `{}`", + ty_to_str(cx.tcx, ty), + missing.user_string(cx.tcx)).as_slice()); }); } @@ -403,19 +406,26 @@ pub fn check_freevar_bounds(cx: &Context, sp: Span, ty: ty::t, // Will be Some if the freevar is implicitly borrowed (stack closure). // Emit a less mysterious error message in this case. match referenced_ty { - Some(rty) => cx.tcx.sess.span_err(sp, - format!("cannot implicitly borrow variable of type `{}` in a bounded \ - stack closure (implicit reference does not fulfill `{}`)", - ty_to_str(cx.tcx, rty), missing.user_string(cx.tcx))), - None => cx.tcx.sess.span_err(sp, + Some(rty) => { + cx.tcx.sess.span_err(sp, + format!("cannot implicitly borrow variable of type `{}` in a \ + bounded stack closure (implicit reference does not \ + fulfill `{}`)", + ty_to_str(cx.tcx, rty), + missing.user_string(cx.tcx)).as_slice()) + } + None => { + cx.tcx.sess.span_err(sp, format!("cannot capture variable of type `{}`, which does \ - not fulfill `{}`, in a bounded closure", - ty_to_str(cx.tcx, ty), missing.user_string(cx.tcx))), + not fulfill `{}`, in a bounded closure", + ty_to_str(cx.tcx, ty), + missing.user_string(cx.tcx)).as_slice()) + } } cx.tcx.sess.span_note( sp, format!("this closure's environment must satisfy `{}`", - bounds.user_string(cx.tcx))); + bounds.user_string(cx.tcx)).as_slice()); }); } @@ -424,9 +434,9 @@ pub fn check_trait_cast_bounds(cx: &Context, sp: Span, ty: ty::t, check_builtin_bounds(cx, ty, bounds, |missing| { cx.tcx.sess.span_err(sp, format!("cannot pack type `{}`, which does not fulfill \ - `{}`, as a trait bounded by {}", - ty_to_str(cx.tcx, ty), missing.user_string(cx.tcx), - bounds.user_string(cx.tcx))); + `{}`, as a trait bounded by {}", + ty_to_str(cx.tcx, ty), missing.user_string(cx.tcx), + bounds.user_string(cx.tcx)).as_slice()); }); } @@ -436,9 +446,10 @@ fn check_copy(cx: &Context, ty: ty::t, sp: Span, reason: &str) { ty::type_contents(cx.tcx, ty).to_str()); if ty::type_moves_by_default(cx.tcx, ty) { cx.tcx.sess.span_err( - sp, format!("copying a value of non-copyable type `{}`", - ty_to_str(cx.tcx, ty))); - cx.tcx.sess.span_note(sp, format!("{}", reason)); + sp, + format!("copying a value of non-copyable type `{}`", + ty_to_str(cx.tcx, ty)).as_slice()); + cx.tcx.sess.span_note(sp, format!("{}", reason).as_slice()); } } @@ -448,7 +459,8 @@ pub fn check_static(tcx: &ty::ctxt, ty: ty::t, sp: Span) -> bool { ty::ty_param(..) => { tcx.sess.span_err(sp, format!("value may contain references; \ - add `'static` bound to `{}`", ty_to_str(tcx, ty))); + add `'static` bound to `{}`", + ty_to_str(tcx, ty)).as_slice()); } _ => { tcx.sess.span_err(sp, "value may contain references"); @@ -564,8 +576,11 @@ pub fn check_cast_for_escaping_regions( // Ensure that `ty` has a statically known size (i.e., it has the `Sized` bound). fn check_sized(tcx: &ty::ctxt, ty: ty::t, name: StrBuf, sp: Span) { if !ty::type_is_sized(tcx, ty) { - tcx.sess.span_err(sp, format!("variable `{}` has dynamically sized type `{}`", - name, ty_to_str(tcx, ty))); + tcx.sess.span_err(sp, + format!("variable `{}` has dynamically sized type \ + `{}`", + name, + ty_to_str(tcx, ty)).as_slice()); } } diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs index 81e9c3f5ec6b2..4c381aff1e3da 100644 --- a/src/librustc/middle/lang_items.rs +++ b/src/librustc/middle/lang_items.rs @@ -152,7 +152,8 @@ impl<'a> LanguageItemCollector<'a> { match self.items.items.get(item_index) { &Some(original_def_id) if original_def_id != item_def_id => { self.session.err(format!("duplicate entry for `{}`", - LanguageItems::item_name(item_index))); + LanguageItems::item_name( + item_index)).as_slice()); } &Some(_) | &None => { // OK. diff --git a/src/librustc/middle/lint.rs b/src/librustc/middle/lint.rs index d0b7eed6e0099..8feacba6e006d 100644 --- a/src/librustc/middle/lint.rs +++ b/src/librustc/middle/lint.rs @@ -506,8 +506,10 @@ impl<'a> Context<'a> { let mut note = None; let msg = match src { Default => { - format!("{}, \\#[{}({})] on by default", msg, - level_to_str(level), self.lint_to_str(lint)) + format_strbuf!("{}, \\#[{}({})] on by default", + msg, + level_to_str(level), + self.lint_to_str(lint)) }, CommandLine => { format!("{} [-{} {}]", msg, @@ -522,8 +524,8 @@ impl<'a> Context<'a> { } }; match level { - Warn => { self.tcx.sess.span_warn(span, msg); } - Deny | Forbid => { self.tcx.sess.span_err(span, msg); } + Warn => self.tcx.sess.span_warn(span, msg.as_slice()), + Deny | Forbid => self.tcx.sess.span_err(span, msg.as_slice()), Allow => fail!(), } @@ -552,7 +554,7 @@ impl<'a> Context<'a> { UnrecognizedLint, meta.span, format!("unknown `{}` attribute: `{}`", - level_to_str(level), lintname)); + level_to_str(level), lintname).as_slice()); } Some(lint) => { let lint = lint.lint; @@ -560,8 +562,9 @@ impl<'a> Context<'a> { if now == Forbid && level != Forbid { self.tcx.sess.span_err(meta.span, format!("{}({}) overruled by outer forbid({})", - level_to_str(level), - lintname, lintname)); + level_to_str(level), + lintname, + lintname).as_slice()); } else if now != level { let src = self.get_source(lint); self.lint_stack.push((lint, now, src)); @@ -965,13 +968,13 @@ fn check_heap_type(cx: &Context, span: Span, ty: ty::t) { if n_uniq > 0 && lint != ManagedHeapMemory { let s = ty_to_str(cx.tcx, ty); let m = format!("type uses owned (Box type) pointers: {}", s); - cx.span_lint(lint, span, m); + cx.span_lint(lint, span, m.as_slice()); } if n_box > 0 && lint != OwnedHeapMemory { let s = ty_to_str(cx.tcx, ty); let m = format!("type uses managed (@ type) pointers: {}", s); - cx.span_lint(lint, span, m); + cx.span_lint(lint, span, m.as_slice()); } } } @@ -1122,7 +1125,8 @@ fn check_attrs_usage(cx: &Context, attrs: &[ast::Attribute]) { for &(obs_attr, obs_alter) in obsolete_attrs.iter() { if name.equiv(&obs_attr) { cx.span_lint(AttributeUsage, attr.span, - format!("obsolete attribute: {:s}", obs_alter)); + format!("obsolete attribute: {:s}", + obs_alter).as_slice()); return; } } @@ -1233,7 +1237,7 @@ fn check_item_non_camel_case_types(cx: &Context, it: &ast::Item) { cx.span_lint( NonCamelCaseTypes, span, format!("{} `{}` should have a camel case identifier", - sort, token::get_ident(ident))); + sort, token::get_ident(ident)).as_slice()); } } @@ -1331,7 +1335,8 @@ fn check_unnecessary_parens_core(cx: &Context, value: &ast::Expr, msg: &str) { match value.node { ast::ExprParen(_) => { cx.span_lint(UnnecessaryParens, value.span, - format!("unnecessary parentheses around {}", msg)) + format!("unnecessary parentheses around {}", + msg).as_slice()) } _ => {} } @@ -1506,8 +1511,10 @@ fn check_missing_doc_attrs(cx: &Context, } }); if !has_doc { - cx.span_lint(MissingDoc, sp, - format!("missing documentation for {}", desc)); + cx.span_lint(MissingDoc, + sp, + format!("missing documentation for {}", + desc).as_slice()); } } @@ -1675,7 +1682,7 @@ fn check_stability(cx: &Context, e: &ast::Expr) { _ => format!("use of {} item", label) }; - cx.span_lint(lint, e.span, msg); + cx.span_lint(lint, e.span, msg.as_slice()); } impl<'a> Visitor<()> for Context<'a> { @@ -1906,8 +1913,11 @@ pub fn check_crate(tcx: &ty::ctxt, // in the iteration code. for (id, v) in tcx.sess.lints.borrow().iter() { for &(lint, span, ref msg) in v.iter() { - tcx.sess.span_bug(span, format!("unprocessed lint {:?} at {}: {}", - lint, tcx.map.node_to_str(*id), *msg)) + tcx.sess.span_bug(span, + format!("unprocessed lint {:?} at {}: {}", + lint, + tcx.map.node_to_str(*id), + *msg).as_slice()) } } diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index 1954c6d4123ee..322674a5c9b7d 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -317,7 +317,7 @@ impl<'a> IrMaps<'a> { self.tcx .sess .span_bug(span, format!("no variable registered for id {}", - node_id)); + node_id).as_slice()); } } } @@ -606,8 +606,9 @@ impl<'a> Liveness<'a> { // code have to agree about which AST nodes are worth // creating liveness nodes for. self.ir.tcx.sess.span_bug( - span, format!("no live node registered for node {}", - node_id)); + span, + format!("no live node registered for node {}", + node_id).as_slice()); } } } diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index bd29398e5225d..3198c0e839877 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -224,7 +224,7 @@ pub fn deref_kind(tcx: &ty::ctxt, t: ty::t) -> deref_kind { None => { tcx.sess.bug( format!("deref_cat() invoked on non-derefable type {}", - ty_to_str(tcx, t))); + ty_to_str(tcx, t)).as_slice()); } } } @@ -578,7 +578,8 @@ impl<'t,TYPER:Typer> MemCategorizationContext<'t,TYPER> { self.tcx().sess.span_bug( span, format!("Upvar of non-closure {} - {}", - fn_node_id, ty.repr(self.tcx()))); + fn_node_id, + ty.repr(self.tcx())).as_slice()); } } } @@ -727,7 +728,7 @@ impl<'t,TYPER:Typer> MemCategorizationContext<'t,TYPER> { self.tcx().sess.span_bug( node.span(), format!("Explicit deref of non-derefable type: {}", - base_cmt.ty.repr(self.tcx()))); + base_cmt.ty.repr(self.tcx())).as_slice()); } } } @@ -800,7 +801,7 @@ impl<'t,TYPER:Typer> MemCategorizationContext<'t,TYPER> { self.tcx().sess.span_bug( elt.span(), format!("Explicit index of non-index type `{}`", - base_cmt.ty.repr(self.tcx()))); + base_cmt.ty.repr(self.tcx())).as_slice()); } }; @@ -884,9 +885,8 @@ impl<'t,TYPER:Typer> MemCategorizationContext<'t,TYPER> { }, _ => { - tcx.sess.span_bug( - pat.span, - format!("Type of slice pattern is not a slice")); + tcx.sess.span_bug(pat.span, + "type of slice pattern is not a slice"); } } } diff --git a/src/librustc/middle/privacy.rs b/src/librustc/middle/privacy.rs index d7aba4208640a..191ac9aa9a377 100644 --- a/src/librustc/middle/privacy.rs +++ b/src/librustc/middle/privacy.rs @@ -632,7 +632,7 @@ impl<'a> PrivacyVisitor<'a> { UnnamedField(idx) => format!("field \\#{} of {} is private", idx + 1, struct_desc), }; - self.tcx.sess.span_err(span, msg); + self.tcx.sess.span_err(span, msg.as_slice()); } // Given the ID of a method, checks to ensure it's in scope. @@ -647,7 +647,8 @@ impl<'a> PrivacyVisitor<'a> { self.report_error(self.ensure_public(span, method_id, None, - format!("method `{}`", string))); + format!("method `{}`", + string).as_slice())); } // Checks that a path is in scope. @@ -661,8 +662,12 @@ impl<'a> PrivacyVisitor<'a> { .unwrap() .identifier); let origdid = def_id_of_def(orig_def); - self.ensure_public(span, def, Some(origdid), - format!("{} `{}`", tyname, name)) + self.ensure_public(span, + def, + Some(origdid), + format!("{} `{}`", + tyname, + name).as_slice()) }; match *self.last_private_map.get(&path_id) { diff --git a/src/librustc/middle/reachable.rs b/src/librustc/middle/reachable.rs index 49e607f12406c..3e4ebe845d7d5 100644 --- a/src/librustc/middle/reachable.rs +++ b/src/librustc/middle/reachable.rs @@ -234,7 +234,7 @@ impl<'a> ReachableContext<'a> { None => { self.tcx.sess.bug(format!("found unmapped ID in worklist: \ {}", - search_item)) + search_item).as_slice()) } } } @@ -324,9 +324,12 @@ impl<'a> ReachableContext<'a> { ast_map::NodeVariant(_) | ast_map::NodeStructCtor(_) => {} _ => { - self.tcx.sess.bug(format!("found unexpected thingy in \ - worklist: {}", - self.tcx.map.node_to_str(search_item))) + self.tcx + .sess + .bug(format!("found unexpected thingy in worklist: {}", + self.tcx + .map + .node_to_str(search_item)).as_slice()) } } } diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs index ac37af05359d5..0a7da6e6d088f 100644 --- a/src/librustc/middle/resolve.rs +++ b/src/librustc/middle/resolve.rs @@ -1085,14 +1085,14 @@ impl<'a> Resolver<'a> { self.resolve_error(sp, format!("duplicate definition of {} `{}`", namespace_error_to_str(duplicate_type), - token::get_ident(name))); + token::get_ident(name)).as_slice()); { let r = child.span_for_namespace(ns); for sp in r.iter() { self.session.span_note(*sp, format!("first definition of {} `{}` here", namespace_error_to_str(duplicate_type), - token::get_ident(name))); + token::get_ident(name)).as_slice()); } } } @@ -2054,7 +2054,7 @@ impl<'a> Resolver<'a> { import_directive.module_path .as_slice(), import_directive.subclass)); - self.resolve_error(import_directive.span, msg); + self.resolve_error(import_directive.span, msg.as_slice()); } Indeterminate => { // Bail out. We'll come around next time. @@ -2427,7 +2427,7 @@ impl<'a> Resolver<'a> { `{}` in `{}`", token::get_ident(source), self.module_to_str(&*containing_module)); - self.resolve_error(directive.span, msg); + self.resolve_error(directive.span, msg.as_slice()); return Failed; } let value_used_public = value_used_reexport || value_used_public; @@ -2651,14 +2651,17 @@ impl<'a> Resolver<'a> { expn_info: span.expn_info, }; self.resolve_error(span, - format!("unresolved import. maybe \ + format!("unresolved import. maybe \ a missing `extern crate \ {}`?", - segment_name)); + segment_name).as_slice()); return Failed; } - self.resolve_error(span, format!("unresolved import: could not find `{}` in \ - `{}`.", segment_name, module_name)); + self.resolve_error(span, + format!("unresolved import: could not \ + find `{}` in `{}`.", + segment_name, + module_name).as_slice()); return Failed; } Indeterminate => { @@ -2675,8 +2678,11 @@ impl<'a> Resolver<'a> { match type_def.module_def { None => { // Not a module. - self.resolve_error(span, format!("not a module `{}`", - token::get_ident(name))); + self.resolve_error( + span, + format!("not a module `{}`", + token::get_ident(name)) + .as_slice()); return Failed; } Some(ref module_def) => { @@ -2717,9 +2723,10 @@ impl<'a> Resolver<'a> { } None => { // There are no type bindings at all. - self.resolve_error(span, - format!("not a module `{}`", - token::get_ident(name))); + self.resolve_error( + span, + format!("not a module `{}`", + token::get_ident(name)).as_slice()); return Failed; } } @@ -2764,16 +2771,15 @@ impl<'a> Resolver<'a> { let mpath = self.idents_to_str(module_path); match mpath.as_slice().rfind(':') { Some(idx) => { - self.resolve_error(span, - format!("unresolved import: could \ - not find `{}` in `{}`", - // idx +- 1 to account for - // the colons on either - // side - mpath.as_slice() - .slice_from(idx + 1), - mpath.as_slice() - .slice_to(idx - 1))); + self.resolve_error( + span, + format!("unresolved import: could not find `{}` \ + in `{}`", + // idx +- 1 to account for the colons on \ + // either side + mpath.as_slice().slice_from(idx + 1), + mpath.as_slice() + .slice_to(idx - 1)).as_slice()); }, None => (), }; @@ -3200,7 +3206,7 @@ impl<'a> Resolver<'a> { } else { let err = format!("unresolved import (maybe you meant `{}::*`?)", sn.as_slice().slice(0, sn.len())); - self.resolve_error(imports.get(index).span, err); + self.resolve_error(imports.get(index).span, err.as_slice()); } } @@ -3870,7 +3876,7 @@ impl<'a> Resolver<'a> { }; let msg = format!("attempt to {} a nonexistent trait `{}`", usage_str, path_str); - self.resolve_error(trait_reference.path.span, msg); + self.resolve_error(trait_reference.path.span, msg.as_slice()); } Some(def) => { debug!("(resolving trait) found trait def: {:?}", def); @@ -4071,7 +4077,7 @@ impl<'a> Resolver<'a> { format!("variable `{}` from pattern \\#1 is \ not bound in pattern \\#{}", token::get_name(key), - i + 1)); + i + 1).as_slice()); } Some(binding_i) => { if binding_0.binding_mode != binding_i.binding_mode { @@ -4080,7 +4086,7 @@ impl<'a> Resolver<'a> { format!("variable `{}` is bound with different \ mode in pattern \\#{} than in pattern \\#1", token::get_name(key), - i + 1)); + i + 1).as_slice()); } } } @@ -4093,7 +4099,7 @@ impl<'a> Resolver<'a> { format!("variable `{}` from pattern \\#{} is \ not bound in pattern \\#1", token::get_name(key), - i + 1)); + i + 1).as_slice()); } } } @@ -4220,7 +4226,7 @@ impl<'a> Resolver<'a> { None => { let msg = format!("use of undeclared type name `{}`", self.path_idents_to_str(path)); - self.resolve_error(ty.span, msg); + self.resolve_error(ty.span, msg.as_slice()); } } @@ -4285,12 +4291,12 @@ impl<'a> Resolver<'a> { self.record_def(pattern.id, (def, lp)); } FoundStructOrEnumVariant(..) => { - self.resolve_error(pattern.span, - format!("declaration of `{}` \ - shadows an enum \ - variant or unit-like \ - struct in scope", - token::get_name(renamed))); + self.resolve_error( + pattern.span, + format!("declaration of `{}` shadows an enum \ + variant or unit-like struct in \ + scope", + token::get_name(renamed)).as_slice()); } FoundConst(def, lp) if mode == RefutableMode => { debug!("(resolving pattern) resolving `{}` to \ @@ -4359,9 +4365,10 @@ impl<'a> Resolver<'a> { // in the same disjunct, which is an // error self.resolve_error(pattern.span, - format!("identifier `{}` is bound more \ - than once in the same pattern", - path_to_str(path))); + format!("identifier `{}` is bound \ + more than once in the same \ + pattern", + path_to_str(path)).as_slice()); } // Not bound in the same pattern: do nothing } @@ -4406,8 +4413,11 @@ impl<'a> Resolver<'a> { self.resolve_error( path.span, format!("`{}` is not an enum variant or constant", - token::get_ident( - path.segments.last().unwrap().identifier))) + token::get_ident( + path.segments + .last() + .unwrap() + .identifier)).as_slice()) } None => { self.resolve_error(path.span, @@ -4435,16 +4445,20 @@ impl<'a> Resolver<'a> { Some(_) => { self.resolve_error(path.span, format!("`{}` is not an enum variant, struct or const", - token::get_ident(path.segments - .last().unwrap() - .identifier))); + token::get_ident( + path.segments + .last() + .unwrap() + .identifier)).as_slice()); } None => { self.resolve_error(path.span, format!("unresolved enum variant, struct or const `{}`", - token::get_ident(path.segments - .last().unwrap() - .identifier))); + token::get_ident( + path.segments + .last() + .unwrap() + .identifier)).as_slice()); } } @@ -4485,7 +4499,7 @@ impl<'a> Resolver<'a> { def: {:?}", result); let msg = format!("`{}` does not name a structure", self.path_idents_to_str(path)); - self.resolve_error(path.span, msg); + self.resolve_error(path.span, msg.as_slice()); } } } @@ -4705,7 +4719,7 @@ impl<'a> Resolver<'a> { Failed => { let msg = format!("use of undeclared module `{}`", self.idents_to_str(module_path_idents.as_slice())); - self.resolve_error(path.span, msg); + self.resolve_error(path.span, msg.as_slice()); return None; } @@ -4776,7 +4790,7 @@ impl<'a> Resolver<'a> { Failed => { let msg = format!("use of undeclared module `::{}`", self.idents_to_str(module_path_idents.as_slice())); - self.resolve_error(path.span, msg); + self.resolve_error(path.span, msg.as_slice()); return None; } @@ -5096,12 +5110,12 @@ impl<'a> Resolver<'a> { format!("`{}` is a structure name, but \ this expression \ uses it like a function name", - wrong_name)); + wrong_name).as_slice()); self.session.span_note(expr.span, format!("Did you mean to write: \ `{} \\{ /* fields */ \\}`?", - wrong_name)); + wrong_name).as_slice()); } _ => { @@ -5119,10 +5133,11 @@ impl<'a> Resolver<'a> { if method_scope && token::get_name(self.self_ident.name).get() == wrong_name.as_slice() { - self.resolve_error(expr.span, - format!("`self` is not available in a \ - static method. Maybe a `self` \ - argument is missing?")); + self.resolve_error( + expr.span, + "`self` is not available \ + in a static method. Maybe a \ + `self` argument is missing?"); } else { let name = path_to_ident(path).name; let mut msg = match self.find_fallback_in_self_type(name) { @@ -5130,7 +5145,7 @@ impl<'a> Resolver<'a> { // limit search to 5 to reduce the number // of stupid suggestions self.find_best_match_for_name(wrong_name.as_slice(), 5) - .map_or("".into_owned(), + .map_or("".to_strbuf(), |x| format!("`{}`", x)) } Field => @@ -5147,8 +5162,11 @@ impl<'a> Resolver<'a> { msg = format!(" Did you mean {}?", msg) } - self.resolve_error(expr.span, format!("unresolved name `{}`.{}", - wrong_name, msg)); + self.resolve_error( + expr.span, + format!("unresolved name `{}`.{}", + wrong_name, + msg).as_slice()); } } } @@ -5182,7 +5200,7 @@ impl<'a> Resolver<'a> { def: {:?}", result); let msg = format!("`{}` does not name a structure", self.path_idents_to_str(path)); - self.resolve_error(path.span, msg); + self.resolve_error(path.span, msg.as_slice()); } } @@ -5211,10 +5229,12 @@ impl<'a> Resolver<'a> { let renamed = mtwt::resolve(label); match self.search_ribs(self.label_ribs.borrow().as_slice(), renamed, expr.span) { - None => - self.resolve_error(expr.span, - format!("use of undeclared label `{}`", - token::get_ident(label))), + None => { + self.resolve_error( + expr.span, + format!("use of undeclared label `{}`", + token::get_ident(label)).as_slice()) + } Some(DlDef(def @ DefLabel(_))) => { // Since this def is a label, it is never read. self.record_def(expr.id, (def, LastMod(AllPublic))) @@ -5343,8 +5363,12 @@ impl<'a> Resolver<'a> { // times, so here is a sanity check it at least comes to // the same conclusion! - nmatsakis if def != *old_value { - self.session.bug(format!("node_id {:?} resolved first to {:?} \ - and then {:?}", node_id, *old_value, def)); + self.session + .bug(format!("node_id {:?} resolved first to {:?} and \ + then {:?}", + node_id, + *old_value, + def).as_slice()); } }); } @@ -5356,10 +5380,10 @@ impl<'a> Resolver<'a> { match pat_binding_mode { BindByValue(_) => {} BindByRef(..) => { - self.resolve_error( - pat.span, - format!("cannot use `ref` binding mode with {}", - descr)); + self.resolve_error(pat.span, + format!("cannot use `ref` binding mode \ + with {}", + descr).as_slice()); } } } diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs index 048bbb7d4cd0d..7065772d74f6c 100644 --- a/src/librustc/middle/resolve_lifetime.rs +++ b/src/librustc/middle/resolve_lifetime.rs @@ -341,7 +341,7 @@ impl<'a> LifetimeContext<'a> { self.sess.span_err( lifetime_ref.span, format!("use of undeclared lifetime name `'{}`", - token::get_name(lifetime_ref.name))); + token::get_name(lifetime_ref.name)).as_slice()); } fn check_lifetime_names(&self, lifetimes: &Vec) { @@ -354,7 +354,7 @@ impl<'a> LifetimeContext<'a> { self.sess.span_err( lifetime.span, format!("illegal lifetime parameter name: `{}`", - token::get_name(lifetime.name))); + token::get_name(lifetime.name)).as_slice()); } } @@ -366,7 +366,7 @@ impl<'a> LifetimeContext<'a> { lifetime_j.span, format!("lifetime name `'{}` declared twice in \ the same scope", - token::get_name(lifetime_j.name))); + token::get_name(lifetime_j.name)).as_slice()); } } } diff --git a/src/librustc/middle/subst.rs b/src/librustc/middle/subst.rs index 96d2670134226..ebce96b0abbbb 100644 --- a/src/librustc/middle/subst.rs +++ b/src/librustc/middle/subst.rs @@ -112,14 +112,17 @@ impl<'a> TypeFolder for SubstFolder<'a> { let root_msg = match self.root_ty { Some(root) => format!(" in the substitution of `{}`", root.repr(self.tcx)), - None => "".to_owned() + None => "".to_strbuf() }; let m = format!("can't use type parameters from outer \ function{}; try using a local type \ - parameter instead", root_msg); + parameter instead", + root_msg); match self.span { - Some(span) => self.tcx.sess.span_err(span, m), - None => self.tcx.sess.err(m) + Some(span) => { + self.tcx.sess.span_err(span, m.as_slice()) + } + None => self.tcx.sess.err(m.as_slice()) } ty::mk_err() } @@ -131,12 +134,15 @@ impl<'a> TypeFolder for SubstFolder<'a> { let root_msg = match self.root_ty { Some(root) => format!(" in the substitution of `{}`", root.repr(self.tcx)), - None => "".to_owned() + None => "".to_strbuf() }; - let m = format!("missing `Self` type param{}", root_msg); + let m = format!("missing `Self` type param{}", + root_msg); match self.span { - Some(span) => self.tcx.sess.span_err(span, m), - None => self.tcx.sess.err(m) + Some(span) => { + self.tcx.sess.span_err(span, m.as_slice()) + } + None => self.tcx.sess.err(m.as_slice()) } ty::mk_err() } diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs index e609da6c33ddc..d86d414da43cb 100644 --- a/src/librustc/middle/trans/_match.rs +++ b/src/librustc/middle/trans/_match.rs @@ -462,7 +462,7 @@ fn assert_is_binding_or_wild(bcx: &Block, p: @ast::Pat) { bcx.sess().span_bug( p.span, format!("expected an identifier pattern but found p: {}", - p.repr(bcx.tcx()))); + p.repr(bcx.tcx())).as_slice()); } } @@ -1229,8 +1229,10 @@ fn compare_values<'a>( rhs: ValueRef, rhs_t: ty::t) -> Result<'a> { - let did = langcall(cx, None, - format!("comparison of `{}`", cx.ty_to_str(rhs_t)), + let did = langcall(cx, + None, + format!("comparison of `{}`", + cx.ty_to_str(rhs_t)).as_slice(), StrEqFnLangItem); let result = callee::trans_lang_call(cx, did, [lhs, rhs], None); Result { @@ -1252,8 +1254,10 @@ fn compare_values<'a>( Store(cx, lhs, scratch_lhs); let scratch_rhs = alloca(cx, val_ty(rhs), "__rhs"); Store(cx, rhs, scratch_rhs); - let did = langcall(cx, None, - format!("comparison of `{}`", cx.ty_to_str(rhs_t)), + let did = langcall(cx, + None, + format!("comparison of `{}`", + cx.ty_to_str(rhs_t)).as_slice(), UniqStrEqFnLangItem); let result = callee::trans_lang_call(cx, did, [scratch_lhs, scratch_rhs], None); Result { @@ -2154,7 +2158,7 @@ fn bind_irrefutable_pat<'a>( if bcx.sess().asm_comments() { add_comment(bcx, format!("bind_irrefutable_pat(pat={})", - pat.repr(bcx.tcx()))); + pat.repr(bcx.tcx())).as_slice()); } let _indenter = indenter(); @@ -2273,7 +2277,7 @@ fn bind_irrefutable_pat<'a>( } ast::PatVec(..) => { bcx.sess().span_bug(pat.span, - format!("vector patterns are never irrefutable!")); + "vector patterns are never irrefutable!"); } ast::PatWild | ast::PatWildMulti | ast::PatLit(_) | ast::PatRange(_, _) => () } diff --git a/src/librustc/middle/trans/adt.rs b/src/librustc/middle/trans/adt.rs index 9cea6d0249cc4..45baf07c07c0e 100644 --- a/src/librustc/middle/trans/adt.rs +++ b/src/librustc/middle/trans/adt.rs @@ -192,7 +192,8 @@ fn represent_type_uncached(cx: &CrateContext, t: ty::t) -> Repr { if !cases.iter().enumerate().all(|(i,c)| c.discr == (i as Disr)) { cx.sess().bug(format!("non-C-like enum {} with specified \ discriminants", - ty::item_path_str(cx.tcx(), def_id))) + ty::item_path_str(cx.tcx(), + def_id)).as_slice()) } if cases.len() == 1 { diff --git a/src/librustc/middle/trans/asm.rs b/src/librustc/middle/trans/asm.rs index e6004b4cb71f7..fa299dc05036c 100644 --- a/src/librustc/middle/trans/asm.rs +++ b/src/librustc/middle/trans/asm.rs @@ -67,7 +67,8 @@ pub fn trans_inline_asm<'a>(bcx: &'a Block<'a>, ia: &ast::InlineAsm) StrBuf::from_str(constraints.iter() .map(|s| s.get().to_strbuf()) .collect::>() - .connect(",")); + .connect(",") + .as_slice()); let mut clobbers = getClobbers(); if !ia.clobbers.get().is_empty() && !clobbers.is_empty() { diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs index fc5fcd98ef6f4..e208097e99b33 100644 --- a/src/librustc/middle/trans/base.rs +++ b/src/librustc/middle/trans/base.rs @@ -341,7 +341,8 @@ fn require_alloc_fn(bcx: &Block, info_ty: ty::t, it: LangItem) -> ast::DefId { Ok(id) => id, Err(s) => { bcx.sess().fatal(format!("allocation of `{}` {}", - bcx.ty_to_str(info_ty), s)); + bcx.ty_to_str(info_ty), + s).as_slice()); } } } @@ -476,7 +477,7 @@ pub fn unset_split_stack(f: ValueRef) { // silently mangles such symbols, breaking our linkage model. pub fn note_unique_llvm_symbol(ccx: &CrateContext, sym: StrBuf) { if ccx.all_llvm_symbols.borrow().contains(&sym) { - ccx.sess().bug(format!("duplicate LLVM symbol: {}", sym)); + ccx.sess().bug(format!("duplicate LLVM symbol: {}", sym).as_slice()); } ccx.all_llvm_symbols.borrow_mut().insert(sym); } @@ -739,8 +740,11 @@ pub fn iter_structural_ty<'r, for variant in (*variants).iter() { let variant_cx = - fcx.new_temp_block("enum-iter-variant-".to_owned() + - variant.disr_val.to_str()); + fcx.new_temp_block( + format_strbuf!("enum-iter-variant-{}", + variant.disr_val + .to_str() + .as_slice()).as_slice()); match adt::trans_case(cx, &*repr, variant.disr_val) { _match::single_result(r) => { AddCase(llswitch, r.val, variant_cx.llbb) @@ -839,7 +843,7 @@ pub fn fail_if_zero<'a>( } _ => { cx.sess().bug(format!("fail-if-zero on unexpected type: {}", - ty_to_str(cx.tcx(), rhs_t))); + ty_to_str(cx.tcx(), rhs_t)).as_slice()); } }; with_cond(cx, is_zero, |bcx| { @@ -1503,8 +1507,8 @@ fn trans_enum_variant_or_tuple_like_struct(ccx: &CrateContext, ty::ty_bare_fn(ref bft) => bft.sig.output, _ => ccx.sess().bug( format!("trans_enum_variant_or_tuple_like_struct: \ - unexpected ctor return type {}", - ty_to_str(ccx.tcx(), ctor_ty))) + unexpected ctor return type {}", + ty_to_str(ccx.tcx(), ctor_ty)).as_slice()) }; let arena = TypedArena::new(); @@ -2052,7 +2056,7 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef { ref variant => { ccx.sess().bug(format!("get_item_val(): unexpected variant: {:?}", - variant)) + variant).as_slice()) } }; @@ -2116,7 +2120,9 @@ pub fn write_metadata(cx: &CrateContext, krate: &ast::Crate) -> Vec { let compressed = Vec::from_slice(encoder::metadata_encoding_version) .append(match flate::deflate_bytes(metadata.as_slice()) { Some(compressed) => compressed, - None => cx.sess().fatal(format!("failed to compress metadata")) + None => { + cx.sess().fatal("failed to compress metadata") + } }.as_slice()); let llmeta = C_bytes(cx, compressed.as_slice()); let llconst = C_struct(cx, [llmeta], false); diff --git a/src/librustc/middle/trans/builder.rs b/src/librustc/middle/trans/builder.rs index 17667003506b1..f82a609d69572 100644 --- a/src/librustc/middle/trans/builder.rs +++ b/src/librustc/middle/trans/builder.rs @@ -750,9 +750,11 @@ impl<'a> Builder<'a> { pub fn add_span_comment(&self, sp: Span, text: &str) { if self.ccx.sess().asm_comments() { - let s = format!("{} ({})", text, self.ccx.sess().codemap().span_to_str(sp)); - debug!("{}", s); - self.add_comment(s); + let s = format!("{} ({})", + text, + self.ccx.sess().codemap().span_to_str(sp)); + debug!("{}", s.as_slice()); + self.add_comment(s.as_slice()); } } @@ -761,7 +763,7 @@ impl<'a> Builder<'a> { let sanitized = text.replace("$", ""); let comment_text = format!("\\# {}", sanitized.replace("\n", "\n\t# ")); self.count_insn("inlineasm"); - let asm = comment_text.with_c_str(|c| { + let asm = comment_text.as_slice().with_c_str(|c| { unsafe { llvm::LLVMConstInlineAsm(Type::func([], &Type::void(self.ccx)).to_ref(), c, noname(), False, False) diff --git a/src/librustc/middle/trans/callee.rs b/src/librustc/middle/trans/callee.rs index f32aa62d861d3..fe9581c638e77 100644 --- a/src/librustc/middle/trans/callee.rs +++ b/src/librustc/middle/trans/callee.rs @@ -102,8 +102,9 @@ fn trans<'a>(bcx: &'a Block<'a>, expr: &ast::Expr) -> Callee<'a> { _ => { bcx.tcx().sess.span_bug( expr.span, - format!("type of callee is neither bare-fn nor closure: {}", - bcx.ty_to_str(datum.ty))); + format!("type of callee is neither bare-fn nor closure: \ + {}", + bcx.ty_to_str(datum.ty)).as_slice()); } } } @@ -151,7 +152,7 @@ fn trans<'a>(bcx: &'a Block<'a>, expr: &ast::Expr) -> Callee<'a> { bcx.tcx().sess.span_bug( ref_expr.span, format!("cannot translate def {:?} \ - to a callable thing!", def)); + to a callable thing!", def).as_slice()); } } } diff --git a/src/librustc/middle/trans/cleanup.rs b/src/librustc/middle/trans/cleanup.rs index 80ee555971d83..68e66724d0c26 100644 --- a/src/librustc/middle/trans/cleanup.rs +++ b/src/librustc/middle/trans/cleanup.rs @@ -329,7 +329,7 @@ impl<'a> CleanupMethods<'a> for FunctionContext<'a> { self.ccx.sess().bug( format!("no cleanup scope {} found", - self.ccx.tcx.map.node_to_str(cleanup_scope))); + self.ccx.tcx.map.node_to_str(cleanup_scope)).as_slice()); } fn schedule_clean_in_custom_scope(&self, @@ -531,7 +531,7 @@ impl<'a> CleanupHelperMethods<'a> for FunctionContext<'a> { LoopExit(id, _) => { self.ccx.sess().bug(format!( "cannot exit from scope {:?}, \ - not in scope", id)); + not in scope", id).as_slice()); } } } @@ -878,7 +878,8 @@ pub fn temporary_scope(tcx: &ty::ctxt, r } None => { - tcx.sess.bug(format!("no temporary scope available for expr {}", id)) + tcx.sess.bug(format!("no temporary scope available for expr {}", + id).as_slice()) } } } diff --git a/src/librustc/middle/trans/closure.rs b/src/librustc/middle/trans/closure.rs index 80d35d88b2137..c804cb77fb29d 100644 --- a/src/librustc/middle/trans/closure.rs +++ b/src/librustc/middle/trans/closure.rs @@ -205,7 +205,7 @@ pub fn store_environment<'a>( if ccx.sess().asm_comments() { add_comment(bcx, format!("Copy {} into closure", - bv.to_str(ccx))); + bv.to_str(ccx)).as_slice()); } let bound_data = GEPi(bcx, llbox, [0u, abi::box_field_body, i]); @@ -386,8 +386,9 @@ pub fn get_wrapper_for_bare_fn(ccx: &CrateContext, ast::DefVariant(_, did, _) | ast::DefStruct(did) => did, _ => { ccx.sess().bug(format!("get_wrapper_for_bare_fn: \ - expected a statically resolved fn, got {:?}", - def)); + expected a statically resolved fn, got \ + {:?}", + def).as_slice()); } }; @@ -405,7 +406,7 @@ pub fn get_wrapper_for_bare_fn(ccx: &CrateContext, _ => { ccx.sess().bug(format!("get_wrapper_for_bare_fn: \ expected a closure ty, got {}", - closure_ty.repr(tcx))); + closure_ty.repr(tcx)).as_slice()); } }; diff --git a/src/librustc/middle/trans/common.rs b/src/librustc/middle/trans/common.rs index 75015bd2d9d2b..a7bce0019f15b 100644 --- a/src/librustc/middle/trans/common.rs +++ b/src/librustc/middle/trans/common.rs @@ -108,7 +108,7 @@ pub fn gensym_name(name: &str) -> PathElem { let num = token::gensym(name); // use one colon which will get translated to a period by the mangler, and // we're guaranteed that `num` is globally unique for this crate. - PathName(token::gensym(format!("{}:{}", name, num))) + PathName(token::gensym(format!("{}:{}", name, num).as_slice())) } pub struct tydesc_info { @@ -459,7 +459,7 @@ impl<'a> Block<'a> { Some(&v) => v, None => { self.tcx().sess.bug(format!( - "no def associated with node id {:?}", nid)); + "no def associated with node id {:?}", nid).as_slice()); } } } @@ -747,9 +747,10 @@ pub fn node_id_substs(bcx: &Block, if !substs.tps.iter().all(|t| !ty::type_needs_infer(*t)) { bcx.sess().bug( - format!("type parameters for node {:?} include inference types: {}", + format!("type parameters for node {:?} include inference types: \ + {}", node, - substs.repr(bcx.tcx()))); + substs.repr(bcx.tcx())).as_slice()); } substs.substp(tcx, bcx.fcx.param_substs) @@ -816,7 +817,7 @@ pub fn resolve_vtable_under_param_substs(tcx: &ty::ctxt, _ => { tcx.sess.bug(format!( "resolve_vtable_under_param_substs: asked to lookup \ - but no vtables in the fn_ctxt!")) + but no vtables in the fn_ctxt!").as_slice()) } } } @@ -870,8 +871,8 @@ pub fn langcall(bcx: &Block, Err(s) => { let msg = format!("{} {}", msg, s); match span { - Some(span) => { bcx.tcx().sess.span_fatal(span, msg); } - None => { bcx.tcx().sess.fatal(msg); } + Some(span) => bcx.tcx().sess.span_fatal(span, msg.as_slice()), + None => bcx.tcx().sess.fatal(msg.as_slice()), } } } diff --git a/src/librustc/middle/trans/consts.rs b/src/librustc/middle/trans/consts.rs index b5ab0a391f3b1..8b43e99b6ac6d 100644 --- a/src/librustc/middle/trans/consts.rs +++ b/src/librustc/middle/trans/consts.rs @@ -55,8 +55,9 @@ pub fn const_lit(cx: &CrateContext, e: &ast::Expr, lit: ast::Lit) C_integral(Type::uint_from_ty(cx, t), i as u64, false) } _ => cx.sess().span_bug(lit.span, - format!("integer literal has type {} (expected int or uint)", - ty_to_str(cx.tcx(), lit_int_ty))) + format!("integer literal has type {} (expected int \ + or uint)", + ty_to_str(cx.tcx(), lit_int_ty)).as_slice()) } } ast::LitFloat(ref fs, t) => { @@ -150,14 +151,14 @@ fn const_deref(cx: &CrateContext, v: ValueRef, t: ty::t, explicit: bool) } _ => { cx.sess().bug(format!("unexpected dereferenceable type {}", - ty_to_str(cx.tcx(), t))) + ty_to_str(cx.tcx(), t)).as_slice()) } }; (dv, mt.ty) } None => { cx.sess().bug(format!("can't dereference const of type {}", - ty_to_str(cx.tcx(), t))) + ty_to_str(cx.tcx(), t)).as_slice()) } } } @@ -206,7 +207,7 @@ pub fn const_expr(cx: &CrateContext, e: &ast::Expr, is_local: bool) -> (ValueRef cx.sess() .span_bug(e.span, format!("unexpected static function: {:?}", - store)) + store).as_slice()) } ty::AutoObject(..) => { cx.sess() @@ -256,11 +257,11 @@ pub fn const_expr(cx: &CrateContext, e: &ast::Expr, is_local: bool) -> (ValueRef } } _ => { - cx.sess().span_bug(e.span, - format!("unimplemented \ - const autoref \ - {:?}", - autoref)) + cx.sess() + .span_bug(e.span, + format!("unimplemented const \ + autoref {:?}", + autoref).as_slice()) } } } @@ -281,7 +282,7 @@ pub fn const_expr(cx: &CrateContext, e: &ast::Expr, is_local: bool) -> (ValueRef } cx.sess().bug(format!("const {} of type {} has size {} instead of {}", e.repr(cx.tcx()), ty_to_str(cx.tcx(), ety), - csize, tsize)); + csize, tsize).as_slice()); } (llconst, inlineable) } diff --git a/src/librustc/middle/trans/controlflow.rs b/src/librustc/middle/trans/controlflow.rs index 3b3852b3f45b1..419b4f1e110a2 100644 --- a/src/librustc/middle/trans/controlflow.rs +++ b/src/librustc/middle/trans/controlflow.rs @@ -165,7 +165,7 @@ pub fn trans_if<'a>(bcx: &'a Block<'a>, } let name = format!("then-block-{}-", thn.id); - let then_bcx_in = bcx.fcx.new_id_block(name, thn.id); + let then_bcx_in = bcx.fcx.new_id_block(name.as_slice(), thn.id); let then_bcx_out = trans_block(then_bcx_in, thn, dest); debuginfo::clear_source_location(bcx.fcx); @@ -287,7 +287,8 @@ pub fn trans_break_cont<'a>(bcx: &'a Block<'a>, match bcx.tcx().def_map.borrow().find(&expr_id) { Some(&ast::DefLabel(loop_id)) => loop_id, ref r => { - bcx.tcx().sess.bug(format!("{:?} in def-map for label", r)) + bcx.tcx().sess.bug(format!("{:?} in def-map for label", + r).as_slice()) } } } diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs index ff43e4f9abb4c..48b429c6976c2 100644 --- a/src/librustc/middle/trans/debuginfo.rs +++ b/src/librustc/middle/trans/debuginfo.rs @@ -317,16 +317,21 @@ pub fn create_global_var_metadata(cx: &CrateContext, ast_map::NodeItem(item) => { match item.node { ast::ItemStatic(..) => (item.ident, item.span), - _ => cx.sess().span_bug(item.span, - format!("debuginfo::create_global_var_metadata() - - Captured var-id refers to unexpected ast_item - variant: {:?}", - var_item)) + _ => { + cx.sess() + .span_bug(item.span, + format!("debuginfo::\ + create_global_var_metadata() - + Captured var-id refers to \ + unexpected ast_item variant: {:?}", + var_item).as_slice()) + } } }, - _ => cx.sess().bug(format!("debuginfo::create_global_var_metadata() - Captured var-id \ - refers to unexpected ast_map variant: {:?}", - var_item)) + _ => cx.sess().bug(format!("debuginfo::create_global_var_metadata() \ + - Captured var-id refers to unexpected \ + ast_map variant: {:?}", + var_item).as_slice()) }; let filename = span_start(cx, span).file.name.clone(); @@ -340,7 +345,8 @@ pub fn create_global_var_metadata(cx: &CrateContext, let namespace_node = namespace_for_item(cx, ast_util::local_def(node_id)); let var_name = token::get_ident(ident).get().to_str(); - let linkage_name = namespace_node.mangled_name_of_contained_item(var_name); + let linkage_name = + namespace_node.mangled_name_of_contained_item(var_name.as_slice()); let var_scope = namespace_node.scope; var_name.as_slice().with_c_str(|var_name| { @@ -380,7 +386,7 @@ pub fn create_local_var_metadata(bcx: &Block, local: &ast::Local) { None => { bcx.sess().span_bug(span, format!("no entry in lllocals table for {:?}", - node_id)); + node_id).as_slice()); } }; @@ -430,13 +436,17 @@ pub fn create_captured_var_metadata(bcx: &Block, "debuginfo::create_captured_var_metadata() - \ Captured var-id refers to unexpected \ ast_map variant: {:?}", - ast_item)); + ast_item).as_slice()); } } } _ => { - cx.sess().span_bug(span, format!("debuginfo::create_captured_var_metadata() - \ - Captured var-id refers to unexpected ast_map variant: {:?}", ast_item)); + cx.sess() + .span_bug(span, + format!("debuginfo::create_captured_var_metadata() - \ + Captured var-id refers to unexpected \ + ast_map variant: {:?}", + ast_item).as_slice()); } }; @@ -519,7 +529,7 @@ pub fn create_argument_metadata(bcx: &Block, arg: &ast::Arg) { None => { bcx.sess().span_bug(span, format!("no entry in llargs table for {:?}", - node_id)); + node_id).as_slice()); } }; @@ -653,7 +663,7 @@ pub fn create_function_debug_context(cx: &CrateContext, ast::ExprFnBlock(fn_decl, top_level_block) | ast::ExprProc(fn_decl, top_level_block) => { let name = format!("fn{}", token::gensym("fn")); - let name = token::str_to_ident(name); + let name = token::str_to_ident(name.as_slice()); (name, fn_decl, // This is not quite right. It should actually inherit the generics of the // enclosing function. @@ -681,7 +691,7 @@ pub fn create_function_debug_context(cx: &CrateContext, cx.sess() .bug(format!("create_function_debug_context: \ unexpected sort of node: {:?}", - fnitem)) + fnitem).as_slice()) } } } @@ -691,7 +701,8 @@ pub fn create_function_debug_context(cx: &CrateContext, return FunctionDebugContext { repr: FunctionWithoutDebugInfo }; } _ => cx.sess().bug(format!("create_function_debug_context: \ - unexpected sort of node: {:?}", fnitem)) + unexpected sort of node: {:?}", + fnitem).as_slice()) }; // This can be the case for functions inlined from another crate @@ -1124,7 +1135,8 @@ fn scope_metadata(fcx: &FunctionContext, let node = fcx.ccx.tcx.map.get(node_id); fcx.ccx.sess().span_bug(span, - format!("debuginfo: Could not find scope info for node {:?}", node)); + format!("debuginfo: Could not find scope info for node {:?}", + node).as_slice()); } } } @@ -1499,14 +1511,17 @@ fn describe_enum_variant(cx: &CrateContext, // Get the argument names from the enum variant info let mut arg_names: Vec<_> = match variant_info.arg_names { Some(ref names) => { - names.iter().map(|ident| token::get_ident(*ident).get().to_str()).collect() + names.iter() + .map(|ident| { + token::get_ident(*ident).get().to_str().into_strbuf() + }).collect() } - None => variant_info.args.iter().map(|_| "".to_owned()).collect() + None => variant_info.args.iter().map(|_| "".to_strbuf()).collect() }; // If this is not a univariant enum, there is also the (unnamed) discriminant field if discriminant_type_metadata.is_some() { - arg_names.insert(0, "".to_owned()); + arg_names.insert(0, "".to_strbuf()); } // Build an array of (field name, field type) pairs to be captured in the factory closure. @@ -1861,7 +1876,7 @@ fn boxed_type_metadata(cx: &CrateContext, -> DICompositeType { let box_type_name = match content_type_name { Some(content_type_name) => format!("Boxed<{}>", content_type_name), - None => "BoxedType".to_owned() + None => "BoxedType".to_strbuf() }; let box_llvm_type = Type::at_box(cx, content_llvm_type); @@ -1913,7 +1928,7 @@ fn boxed_type_metadata(cx: &CrateContext, return composite_type_metadata( cx, box_llvm_type, - box_type_name, + box_type_name.as_slice(), member_descriptions, file_metadata, file_metadata, @@ -1971,7 +1986,9 @@ fn vec_metadata(cx: &CrateContext, let (element_size, element_align) = size_and_align_of(cx, element_llvm_type); let vec_llvm_type = Type::vec(cx, &element_llvm_type); - let vec_type_name: &str = format!("[{}]", ppaux::ty_to_str(cx.tcx(), element_type)); + let vec_type_name = format!("[{}]", + ppaux::ty_to_str(cx.tcx(), element_type)); + let vec_type_name = vec_type_name.as_slice(); let member_llvm_types = vec_llvm_type.field_types(); @@ -2254,7 +2271,11 @@ fn type_metadata(cx: &CrateContext, elements.as_slice(), usage_site_span).finalize(cx) } - _ => cx.sess().bug(format!("debuginfo: unexpected type in type_metadata: {:?}", sty)) + _ => { + cx.sess().bug(format!("debuginfo: unexpected type in \ + type_metadata: {:?}", + sty).as_slice()) + } }; debug_context(cx).created_types.borrow_mut().insert(cache_id, type_metadata); @@ -2852,13 +2873,13 @@ impl NamespaceTreeNode { None => {} } let string = token::get_name(node.name); - output.push_str(format!("{}", string.get().len())); + output.push_str(format!("{}", string.get().len()).as_slice()); output.push_str(string.get()); } let mut name = StrBuf::from_str("_ZN"); fill_nested(self, &mut name); - name.push_str(format!("{}", item_name.len())); + name.push_str(format!("{}", item_name.len()).as_slice()); name.push_str(item_name); name.push_char('E'); name @@ -2941,7 +2962,8 @@ fn namespace_for_item(cx: &CrateContext, def_id: ast::DefId) -> Rc node, None => { cx.sess().bug(format!("debuginfo::namespace_for_item(): \ - path too short for {:?}", def_id)); + path too short for {:?}", + def_id).as_slice()); } } }) diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs index bd25acad21d4d..024d47ac0ef0a 100644 --- a/src/librustc/middle/trans/expr.rs +++ b/src/librustc/middle/trans/expr.rs @@ -421,8 +421,8 @@ fn trans_datum_unadjusted<'a>(bcx: &'a Block<'a>, bcx.tcx().sess.span_bug( expr.span, format!("trans_rvalue_datum_unadjusted reached \ - fall-through case: {:?}", - expr.node)); + fall-through case: {:?}", + expr.node).as_slice()); } } } @@ -635,8 +635,8 @@ fn trans_rvalue_stmt_unadjusted<'a>(bcx: &'a Block<'a>, bcx.tcx().sess.span_bug( expr.span, format!("trans_rvalue_stmt_unadjusted reached \ - fall-through case: {:?}", - expr.node)); + fall-through case: {:?}", + expr.node).as_slice()); } } } @@ -765,8 +765,9 @@ fn trans_rvalue_dps_unadjusted<'a>(bcx: &'a Block<'a>, _ => { bcx.tcx().sess.span_bug( expr.span, - format!("trans_rvalue_dps_unadjusted reached fall-through case: {:?}", - expr.node)); + format!("trans_rvalue_dps_unadjusted reached fall-through \ + case: {:?}", + expr.node).as_slice()); } } } @@ -815,7 +816,7 @@ fn trans_def_dps_unadjusted<'a>( _ => { bcx.tcx().sess.span_bug(ref_expr.span, format!( "Non-DPS def {:?} referened by {}", - def, bcx.node_id_to_str(ref_expr.id))); + def, bcx.node_id_to_str(ref_expr.id)).as_slice()); } } } @@ -839,7 +840,7 @@ fn trans_def_fn_unadjusted<'a>(bcx: &'a Block<'a>, bcx.tcx().sess.span_bug(ref_expr.span, format!( "trans_def_fn_unadjusted invoked on: {:?} for {}", def, - ref_expr.repr(bcx.tcx()))); + ref_expr.repr(bcx.tcx())).as_slice()); } }; @@ -865,7 +866,8 @@ pub fn trans_local_var<'a>(bcx: &'a Block<'a>, Some(&val) => Datum(val, local_ty, Lvalue), None => { bcx.sess().bug(format!( - "trans_local_var: no llval for upvar {:?} found", nid)); + "trans_local_var: no llval for upvar {:?} found", + nid).as_slice()); } } } @@ -877,7 +879,8 @@ pub fn trans_local_var<'a>(bcx: &'a Block<'a>, } _ => { bcx.sess().unimpl(format!( - "unsupported def type in trans_local_var: {:?}", def)); + "unsupported def type in trans_local_var: {:?}", + def).as_slice()); } }; @@ -889,7 +892,8 @@ pub fn trans_local_var<'a>(bcx: &'a Block<'a>, Some(&v) => v, None => { bcx.sess().bug(format!( - "trans_local_var: no datum for local/arg {:?} found", nid)); + "trans_local_var: no datum for local/arg {:?} found", + nid).as_slice()); } }; debug!("take_local(nid={:?}, v={}, ty={})", @@ -922,7 +926,7 @@ pub fn with_field_tys(tcx: &ty::ctxt, tcx.sess.bug(format!( "cannot get field types from the enum type {} \ without a node ID", - ty.repr(tcx))); + ty.repr(tcx)).as_slice()); } Some(node_id) => { let def = tcx.def_map.borrow().get_copy(&node_id); @@ -947,7 +951,7 @@ pub fn with_field_tys(tcx: &ty::ctxt, _ => { tcx.sess.bug(format!( "cannot get field types from the type {}", - ty.repr(tcx))); + ty.repr(tcx)).as_slice()); } } } @@ -1586,16 +1590,22 @@ fn trans_imm_cast<'a>(bcx: &'a Block<'a>, val_ty(lldiscrim_a), lldiscrim_a, true), cast_float => SIToFP(bcx, lldiscrim_a, ll_t_out), - _ => ccx.sess().bug(format!("translating unsupported cast: \ + _ => { + ccx.sess().bug(format!("translating unsupported cast: \ {} ({:?}) -> {} ({:?})", - t_in.repr(bcx.tcx()), k_in, - t_out.repr(bcx.tcx()), k_out)) + t_in.repr(bcx.tcx()), + k_in, + t_out.repr(bcx.tcx()), + k_out).as_slice()) + } } } _ => ccx.sess().bug(format!("translating unsupported cast: \ {} ({:?}) -> {} ({:?})", - t_in.repr(bcx.tcx()), k_in, - t_out.repr(bcx.tcx()), k_out)) + t_in.repr(bcx.tcx()), + k_in, + t_out.repr(bcx.tcx()), + k_out).as_slice()) }; return immediate_rvalue_bcx(bcx, newval, t_out).to_expr_datumblock(); } @@ -1757,7 +1767,7 @@ fn deref_once<'a>(bcx: &'a Block<'a>, bcx.tcx().sess.span_bug( expr.span, format!("deref invoked on expr of illegal type {}", - datum.ty.repr(bcx.tcx()))); + datum.ty.repr(bcx.tcx())).as_slice()); } }; diff --git a/src/librustc/middle/trans/foreign.rs b/src/librustc/middle/trans/foreign.rs index fb6aff0e26ed1..e08ab33808ac9 100644 --- a/src/librustc/middle/trans/foreign.rs +++ b/src/librustc/middle/trans/foreign.rs @@ -81,13 +81,12 @@ pub fn llvm_calling_convention(ccx: &CrateContext, match abi { RustIntrinsic => { // Intrinsics are emitted by monomorphic fn - ccx.sess().bug(format!("asked to register intrinsic fn")); + ccx.sess().bug("asked to register intrinsic fn"); } Rust => { // FIXME(#3678) Implement linking to foreign fns with Rust ABI - ccx.sess().unimpl( - format!("foreign functions with Rust ABI")); + ccx.sess().unimpl("foreign functions with Rust ABI"); } // It's the ABI's job to select this, not us. @@ -164,7 +163,8 @@ pub fn register_static(ccx: &CrateContext, }); lib::llvm::SetLinkage(g1, linkage); - let real_name = "_rust_extern_with_linkage_" + ident.get(); + let mut real_name = "_rust_extern_with_linkage_".to_strbuf(); + real_name.push_str(ident.get()); let g2 = real_name.with_c_str(|buf| { llvm::LLVMAddGlobal(ccx.llmod, llty.to_ref(), buf) }); @@ -202,14 +202,14 @@ pub fn register_foreign_item_fn(ccx: &CrateContext, abi: Abi, fty: ty::t, Some(s) => { ccx.sess().span_fatal(s, format!("ABI `{}` has no suitable calling convention \ - for target architecture", - abi.user_string(ccx.tcx()))) + for target architecture", + abi.user_string(ccx.tcx())).as_slice()) } None => { ccx.sess().fatal( format!("ABI `{}` has no suitable calling convention \ - for target architecture", - abi.user_string(ccx.tcx()))) + for target architecture", + abi.user_string(ccx.tcx())).as_slice()) } } } @@ -370,8 +370,8 @@ pub fn trans_native_call<'a>( // FIXME(#8357) We really ought to report a span here ccx.sess().fatal( format!("ABI string `{}` has no suitable ABI \ - for target architecture", - fn_abi.user_string(ccx.tcx()))); + for target architecture", + fn_abi.user_string(ccx.tcx())).as_slice()); } }; @@ -555,9 +555,9 @@ pub fn trans_rust_fn_with_foreign_abi(ccx: &CrateContext, } _ => { ccx.sess().bug(format!("build_rust_fn: extern fn {} has ty {}, \ - expected a bare fn ty", + expected a bare fn ty", ccx.tcx.map.path_to_str(id), - t.repr(tcx))); + t.repr(tcx)).as_slice()); } }; diff --git a/src/librustc/middle/trans/glue.rs b/src/librustc/middle/trans/glue.rs index b1b684ca3713a..c103a44aa7543 100644 --- a/src/librustc/middle/trans/glue.rs +++ b/src/librustc/middle/trans/glue.rs @@ -454,7 +454,10 @@ pub fn declare_tydesc(ccx: &CrateContext, t: ty::t) -> tydesc_info { fn declare_generic_glue(ccx: &CrateContext, t: ty::t, llfnty: Type, name: &str) -> ValueRef { let _icx = push_ctxt("declare_generic_glue"); - let fn_nm = mangle_internal_name_by_type_and_seq(ccx, t, "glue_".to_owned() + name); + let fn_nm = mangle_internal_name_by_type_and_seq( + ccx, + t, + format!("glue_{}", name).as_slice()); debug!("{} is for type {}", fn_nm, ppaux::ty_to_str(ccx.tcx(), t)); let llfn = decl_cdecl_fn(ccx.llmod, fn_nm.as_slice(), diff --git a/src/librustc/middle/trans/intrinsic.rs b/src/librustc/middle/trans/intrinsic.rs index cd28d31477212..aeb7a4641c08c 100644 --- a/src/librustc/middle/trans/intrinsic.rs +++ b/src/librustc/middle/trans/intrinsic.rs @@ -396,7 +396,7 @@ pub fn trans_intrinsic(ccx: &CrateContext, intype = ty_to_str(ccx.tcx(), in_type), insize = in_type_size as uint, outtype = ty_to_str(ccx.tcx(), out_type), - outsize = out_type_size as uint)); + outsize = out_type_size as uint).as_slice()); } if !return_type_is_void(ccx, out_type) { diff --git a/src/librustc/middle/trans/monomorphize.rs b/src/librustc/middle/trans/monomorphize.rs index 861caa62515b5..3076a19228c39 100644 --- a/src/librustc/middle/trans/monomorphize.rs +++ b/src/librustc/middle/trans/monomorphize.rs @@ -205,7 +205,8 @@ pub fn monomorphic_fn(ccx: &CrateContext, hash_id.hash(&mut state); mono_ty.hash(&mut state); - exported_name(path, format!("h{}", state.result()), + exported_name(path, + format!("h{}", state.result()).as_slice(), ccx.link_meta.crateid.version_or_default()) }); debug!("monomorphize_fn mangled to {}", s); @@ -287,7 +288,7 @@ pub fn monomorphic_fn(ccx: &CrateContext, } _ => { ccx.sess().bug(format!("can't monomorphize a {:?}", - map_node)) + map_node).as_slice()) } } } @@ -311,7 +312,8 @@ pub fn monomorphic_fn(ccx: &CrateContext, ast_map::NodeBlock(..) | ast_map::NodePat(..) | ast_map::NodeLocal(..) => { - ccx.sess().bug(format!("can't monomorphize a {:?}", map_node)) + ccx.sess().bug(format!("can't monomorphize a {:?}", + map_node).as_slice()) } }; diff --git a/src/librustc/middle/trans/reflect.rs b/src/librustc/middle/trans/reflect.rs index 206fc07cd864e..a65802d2c36ff 100644 --- a/src/librustc/middle/trans/reflect.rs +++ b/src/librustc/middle/trans/reflect.rs @@ -87,7 +87,8 @@ impl<'a, 'b> Reflector<'a, 'b> { pub fn visit(&mut self, ty_name: &str, args: &[ValueRef]) { let fcx = self.bcx.fcx; let tcx = self.bcx.tcx(); - let mth_idx = ty::method_idx(token::str_to_ident("visit_".to_owned() + ty_name), + let mth_idx = ty::method_idx(token::str_to_ident(format!( + "visit_{}", ty_name).as_slice()), self.visitor_methods.as_slice()).expect( format!("couldn't find visit method for {}", ty_name)); let mth_ty = @@ -116,9 +117,9 @@ impl<'a, 'b> Reflector<'a, 'b> { bracket_name: &str, extra: &[ValueRef], inner: |&mut Reflector|) { - self.visit("enter_" + bracket_name, extra); + self.visit(format!("enter_{}", bracket_name).as_slice(), extra); inner(self); - self.visit("leave_" + bracket_name, extra); + self.visit(format!("leave_{}", bracket_name).as_slice(), extra); } pub fn leaf(&mut self, name: &str) { @@ -154,7 +155,7 @@ impl<'a, 'b> Reflector<'a, 'b> { ty::ty_vec(ref mt, Some(sz)) => { let extra = (vec!(self.c_uint(sz))).append(self.c_size_and_align(t).as_slice()); let extra = extra.append(self.c_mt(mt).as_slice()); - self.visit("evec_fixed".to_owned(), extra.as_slice()) + self.visit("evec_fixed", extra.as_slice()) } ty::ty_vec(..) | ty::ty_str => fail!("unexpected unsized type"), // Should remove mt from box and uniq. @@ -170,9 +171,9 @@ impl<'a, 'b> Reflector<'a, 'b> { ty::ty_vec(ref mt, None) => { let extra = Vec::new(); let extra = extra.append(self.c_mt(mt).as_slice()); - self.visit("evec_uniq".to_owned(), extra.as_slice()) + self.visit("evec_uniq", extra.as_slice()) } - ty::ty_str => self.visit("estr_uniq".to_owned(), &[]), + ty::ty_str => self.visit("estr_uniq", &[]), _ => { let extra = self.c_mt(&ty::mt { ty: typ, @@ -191,9 +192,10 @@ impl<'a, 'b> Reflector<'a, 'b> { ty::ty_vec(ref mt, None) => { let (name, extra) = ("slice".to_owned(), Vec::new()); let extra = extra.append(self.c_mt(mt).as_slice()); - self.visit("evec_".to_owned() + name, extra.as_slice()) + self.visit(format!("evec_{}", name).as_slice(), + extra.as_slice()) } - ty::ty_str => self.visit("estr_slice".to_owned(), &[]), + ty::ty_str => self.visit("estr_slice", &[]), _ => { let extra = self.c_mt(mt); self.visit("rptr", extra.as_slice()) diff --git a/src/librustc/middle/trans/type_of.rs b/src/librustc/middle/trans/type_of.rs index 9d13fa56e1e73..ff485a9cf5dfb 100644 --- a/src/librustc/middle/trans/type_of.rs +++ b/src/librustc/middle/trans/type_of.rs @@ -155,7 +155,7 @@ pub fn sizing_type_of(cx: &CrateContext, t: ty::t) -> Type { ty::ty_self(_) | ty::ty_infer(..) | ty::ty_param(..) | ty::ty_err(..) | ty::ty_vec(_, None) | ty::ty_str => { cx.sess().bug(format!("fictitious type {:?} in sizing_type_of()", - ty::get(t).sty)) + ty::get(t).sty).as_slice()) } }; diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 517be1bde2f3a..6a7ad8f0bd917 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -2620,7 +2620,7 @@ pub fn node_id_to_trait_ref(cx: &ctxt, id: ast::NodeId) -> Rc { Some(t) => t.clone(), None => cx.sess.bug( format!("node_id_to_trait_ref: no trait ref for node `{}`", - cx.map.node_to_str(id))) + cx.map.node_to_str(id)).as_slice()) } } @@ -2633,7 +2633,7 @@ pub fn node_id_to_type(cx: &ctxt, id: ast::NodeId) -> t { Some(t) => t, None => cx.sess.bug( format!("node_id_to_type: no type for node `{}`", - cx.map.node_to_str(id))) + cx.map.node_to_str(id)).as_slice()) } } @@ -2717,7 +2717,8 @@ pub fn ty_region(tcx: &ctxt, ref s => { tcx.sess.span_bug( span, - format!("ty_region() invoked on in appropriate ty: {:?}", s)); + format!("ty_region() invoked on in appropriate ty: {:?}", + s).as_slice()); } } } @@ -2774,11 +2775,12 @@ pub fn expr_span(cx: &ctxt, id: NodeId) -> Span { } Some(f) => { cx.sess.bug(format!("Node id {} is not an expr: {:?}", - id, f)); + id, + f).as_slice()); } None => { cx.sess.bug(format!("Node id {} is not present \ - in the node map", id)); + in the node map", id).as_slice()); } } } @@ -2793,14 +2795,15 @@ pub fn local_var_name_str(cx: &ctxt, id: NodeId) -> InternedString { _ => { cx.sess.bug( format!("Variable id {} maps to {:?}, not local", - id, pat)); + id, + pat).as_slice()); } } } r => { - cx.sess.bug( - format!("Variable id {} maps to {:?}, not local", - id, r)); + cx.sess.bug(format!("Variable id {} maps to {:?}, not local", + id, + r).as_slice()); } } } @@ -2832,7 +2835,7 @@ pub fn adjust_ty(cx: &ctxt, cx.sess.bug( format!("add_env adjustment on non-bare-fn: \ {:?}", - b)); + b).as_slice()); } } } @@ -2857,7 +2860,8 @@ pub fn adjust_ty(cx: &ctxt, format!("the {}th autoderef failed: \ {}", i, - ty_to_str(cx, adjusted_ty))); + ty_to_str(cx, adjusted_ty)) + .as_slice()); } } } @@ -2923,7 +2927,8 @@ pub fn adjust_ty(cx: &ctxt, _ => { cx.sess.span_bug( span, - format!("borrow-vec associated with bad sty: {:?}", get(ty).sty)); + format!("borrow-vec associated with bad sty: {:?}", + get(ty).sty).as_slice()); } }, ty_vec(mt, Some(_)) => ty::mk_slice(cx, r, ty::mt {ty: mt.ty, mutbl: m}), @@ -2931,7 +2936,8 @@ pub fn adjust_ty(cx: &ctxt, ref s => { cx.sess.span_bug( span, - format!("borrow-vec associated with bad sty: {:?}", s)); + format!("borrow-vec associated with bad sty: {:?}", + s).as_slice()); } } } @@ -2947,7 +2953,7 @@ pub fn adjust_ty(cx: &ctxt, cx.sess.span_bug( span, format!("borrow-trait-obj associated with bad sty: {:?}", - s)); + s).as_slice()); } } } @@ -2996,7 +3002,7 @@ pub fn resolve_expr(tcx: &ctxt, expr: &ast::Expr) -> ast::Def { Some(&def) => def, None => { tcx.sess.span_bug(expr.span, format!( - "no def-map entry for expr {:?}", expr.id)); + "no def-map entry for expr {:?}", expr.id).as_slice()); } } } @@ -3070,9 +3076,11 @@ pub fn expr_kind(tcx: &ctxt, expr: &ast::Expr) -> ExprKind { ast::DefLocal(..) => LvalueExpr, def => { - tcx.sess.span_bug(expr.span, format!( - "uncategorized def for expr {:?}: {:?}", - expr.id, def)); + tcx.sess.span_bug( + expr.span, + format!("uncategorized def for expr {:?}: {:?}", + expr.id, + def).as_slice()); } } } @@ -3193,7 +3201,7 @@ pub fn field_idx_strict(tcx: &ctxt, name: ast::Name, fields: &[field]) token::get_name(name), fields.iter() .map(|f| token::get_ident(f.ident).get().to_strbuf()) - .collect::>())); + .collect::>()).as_slice()); } pub fn method_idx(id: ast::Ident, meths: &[Rc]) -> Option { @@ -3444,10 +3452,18 @@ pub fn provided_trait_methods(cx: &ctxt, id: ast::DefId) -> Vec> { let (_, p) = ast_util::split_trait_methods(ms.as_slice()); p.iter().map(|m| method(cx, ast_util::local_def(m.id))).collect() } - _ => cx.sess.bug(format!("provided_trait_methods: `{}` is not a trait", id)) + _ => { + cx.sess.bug(format!("provided_trait_methods: `{}` is \ + not a trait", + id).as_slice()) + } } } - _ => cx.sess.bug(format!("provided_trait_methods: `{}` is not a trait", id)) + _ => { + cx.sess.bug(format!("provided_trait_methods: `{}` is not a \ + trait", + id).as_slice()) + } } } else { csearch::get_provided_trait_methods(cx, id) @@ -3800,7 +3816,7 @@ pub fn enum_variants(cx: &ctxt, id: ast::DefId) -> Rc>> { cx.sess .span_err(e.span, format!("expected constant: {}", - *err)); + *err).as_slice()); } }, None => {} @@ -3963,7 +3979,7 @@ fn each_super_struct(cx: &ctxt, mut did: ast::DefId, f: |ast::DefId|) { None => { cx.sess.bug( format!("ID not mapped to super-struct: {}", - cx.map.node_to_str(did.node))); + cx.map.node_to_str(did.node)).as_slice()); } } } @@ -3985,7 +4001,7 @@ pub fn lookup_struct_fields(cx: &ctxt, did: ast::DefId) -> Vec { _ => { cx.sess.bug( format!("ID not mapped to struct fields: {}", - cx.map.node_to_str(did.node))); + cx.map.node_to_str(did.node)).as_slice()); } } }); diff --git a/src/librustc/middle/typeck/astconv.rs b/src/librustc/middle/typeck/astconv.rs index cb3e900af7dfe..9cc5d2d73ca1d 100644 --- a/src/librustc/middle/typeck/astconv.rs +++ b/src/librustc/middle/typeck/astconv.rs @@ -180,7 +180,7 @@ fn ast_path_substs( format!("wrong number of lifetime parameters: \ expected {} but found {}", expected_num_region_params, - supplied_num_region_params)); + supplied_num_region_params).as_slice()); } match anon_regions { @@ -204,7 +204,9 @@ fn ast_path_substs( }; this.tcx().sess.span_fatal(path.span, format!("wrong number of type arguments: {} {} but found {}", - expected, required_ty_param_count, supplied_ty_param_count)); + expected, + required_ty_param_count, + supplied_ty_param_count).as_slice()); } else if supplied_ty_param_count > formal_ty_param_count { let expected = if required_ty_param_count < formal_ty_param_count { "expected at most" @@ -213,7 +215,9 @@ fn ast_path_substs( }; this.tcx().sess.span_fatal(path.span, format!("wrong number of type arguments: {} {} but found {}", - expected, formal_ty_param_count, supplied_ty_param_count)); + expected, + formal_ty_param_count, + supplied_ty_param_count).as_slice()); } if supplied_ty_param_count > required_ty_param_count @@ -317,8 +321,11 @@ pub fn ast_ty_to_prim_ty(tcx: &ty::ctxt, ast_ty: &ast::Ty) -> Option { match ast_ty.node { ast::TyPath(ref path, _, id) => { let a_def = match tcx.def_map.borrow().find(&id) { - None => tcx.sess.span_bug( - ast_ty.span, format!("unbound path {}", path_to_str(path))), + None => { + tcx.sess.span_bug(ast_ty.span, + format!("unbound path {}", + path_to_str(path)).as_slice()) + } Some(&d) => d }; match a_def { @@ -382,8 +389,13 @@ pub fn ast_ty_to_builtin_ty { let a_def = match this.tcx().def_map.borrow().find(&id) { - None => this.tcx().sess.span_bug( - ast_ty.span, format!("unbound path {}", path_to_str(path))), + None => { + this.tcx() + .sess + .span_bug(ast_ty.span, + format!("unbound path {}", + path_to_str(path)).as_slice()) + } Some(&d) => d }; @@ -493,8 +505,11 @@ fn mk_pointer { return ty::mk_str_slice(tcx, r, ast::MutImmutable); } - _ => tcx.sess.span_err(path.span, - format!("managed strings are not supported")), + _ => { + tcx.sess + .span_err(path.span, + "managed strings are not supported") + } } } Some(&ast::DefTrait(trait_def_id)) => { @@ -635,8 +650,12 @@ pub fn ast_ty_to_ty( } ast::TyPath(ref path, ref bounds, id) => { let a_def = match tcx.def_map.borrow().find(&id) { - None => tcx.sess.span_bug( - ast_ty.span, format!("unbound path {}", path_to_str(path))), + None => { + tcx.sess + .span_bug(ast_ty.span, + format!("unbound path {}", + path_to_str(path)).as_slice()) + } Some(&d) => d }; // Kind bounds on path types are only supported for traits. @@ -653,8 +672,10 @@ pub fn ast_ty_to_ty( let path_str = path_to_str(path); tcx.sess.span_err( ast_ty.span, - format!("reference to trait `{name}` where a type is expected; \ - try `Box<{name}>` or `&{name}`", name=path_str)); + format!("reference to trait `{name}` where a \ + type is expected; try `Box<{name}>` or \ + `&{name}`", + name=path_str).as_slice()); ty::mk_err() } ast::DefTy(did) | ast::DefStruct(did) => { @@ -675,14 +696,16 @@ pub fn ast_ty_to_ty( ast::DefMod(id) => { tcx.sess.span_fatal(ast_ty.span, format!("found module name used as a type: {}", - tcx.map.node_to_str(id.node))); + tcx.map.node_to_str(id.node)).as_slice()); } ast::DefPrimTy(_) => { fail!("DefPrimTy arm missed in previous ast_ty_to_prim_ty call"); } _ => { tcx.sess.span_fatal(ast_ty.span, - format!("found value name used as a type: {:?}", a_def)); + format!("found value name used \ + as a type: {:?}", + a_def).as_slice()); } } } @@ -705,7 +728,9 @@ pub fn ast_ty_to_ty( Err(ref r) => { tcx.sess.span_fatal( ast_ty.span, - format!("expected constant expr for vector length: {}", *r)); + format!("expected constant expr for vector \ + length: {}", + *r).as_slice()); } } } @@ -897,8 +922,8 @@ fn conv_builtin_bounds(tcx: &ty::ctxt, ast_bounds: &Option { builtin_bounds.add(ty::BoundStatic); @@ -907,8 +932,8 @@ fn conv_builtin_bounds(tcx: &ty::ctxt, ast_bounds: &Option { tcx.sess.span_err(span, format!("field `{}` bound twice in pattern", - token::get_ident(field.ident))); + token::get_ident(field.ident)).as_slice()); } Some(&(index, ref mut used)) => { *used = true; @@ -343,8 +343,8 @@ pub fn check_struct_pat_fields(pcx: &pat_ctxt, check_pat(pcx, field.pat, ty::mk_err()); tcx.sess.span_err(span, format!("struct `{}` does not have a field named `{}`", - name, - token::get_ident(field.ident))); + name, + token::get_ident(field.ident)).as_slice()); } } } @@ -356,9 +356,10 @@ pub fn check_struct_pat_fields(pcx: &pat_ctxt, continue; } - tcx.sess.span_err(span, - format!("pattern does not mention field `{}`", - token::get_name(field.name))); + tcx.sess + .span_err(span, + format!("pattern does not mention field `{}`", + token::get_name(field.name)).as_slice()); } } } @@ -381,10 +382,12 @@ pub fn check_struct_pat(pcx: &pat_ctxt, pat_id: ast::NodeId, span: Span, } Some(&ast::DefStruct(..)) | Some(&ast::DefVariant(..)) => { let name = pprust::path_to_str(path); - tcx.sess.span_err(span, - format!("mismatched types: expected `{}` but found `{}`", - fcx.infcx().ty_to_str(expected), - name)); + tcx.sess + .span_err(span, + format!("mismatched types: expected `{}` but found \ + `{}`", + fcx.infcx().ty_to_str(expected), + name).as_slice()); } _ => { tcx.sess.span_bug(span, "resolve didn't write in struct ID"); @@ -421,9 +424,9 @@ pub fn check_struct_like_enum_variant_pat(pcx: &pat_ctxt, let name = pprust::path_to_str(path); tcx.sess.span_err(span, format!("mismatched types: expected `{}` but \ - found `{}`", - fcx.infcx().ty_to_str(expected), - name)); + found `{}`", + fcx.infcx().ty_to_str(expected), + name).as_slice()); } _ => { tcx.sess.span_bug(span, "resolve didn't write in variant"); diff --git a/src/librustc/middle/typeck/check/method.rs b/src/librustc/middle/typeck/check/method.rs index 9e8edfccd5b5f..d512de670bc80 100644 --- a/src/librustc/middle/typeck/check/method.rs +++ b/src/librustc/middle/typeck/check/method.rs @@ -284,7 +284,7 @@ fn construct_transformed_self_ty_for_object( _ => { tcx.sess.span_bug(span, format!("'impossible' transformed_self_ty: {}", - transformed_self_ty.repr(tcx))); + transformed_self_ty.repr(tcx)).as_slice()); } } } @@ -950,7 +950,7 @@ impl<'a> LookupContext<'a> { ty_infer(TyVar(_)) => { self.bug(format!("unexpected type: {}", - self.ty_to_str(self_ty))); + self.ty_to_str(self_ty)).as_slice()); } } } @@ -1235,9 +1235,10 @@ impl<'a> LookupContext<'a> { rcvr_ty, transformed_self_ty) { Ok(_) => {} Err(_) => { - self.bug(format!("{} was a subtype of {} but now is not?", - self.ty_to_str(rcvr_ty), - self.ty_to_str(transformed_self_ty))); + self.bug(format!( + "{} was a subtype of {} but now is not?", + self.ty_to_str(rcvr_ty), + self.ty_to_str(transformed_self_ty)).as_slice()); } } @@ -1465,25 +1466,25 @@ impl<'a> LookupContext<'a> { self.tcx().sess.span_note( span, format!("candidate \\#{} is `{}`", - idx+1u, - ty::item_path_str(self.tcx(), did))); + idx + 1u, + ty::item_path_str(self.tcx(), did)).as_slice()); } fn report_param_candidate(&self, idx: uint, did: DefId) { self.tcx().sess.span_note( self.span, format!("candidate \\#{} derives from the bound `{}`", - idx+1u, - ty::item_path_str(self.tcx(), did))); + idx + 1u, + ty::item_path_str(self.tcx(), did)).as_slice()); } fn report_trait_candidate(&self, idx: uint, did: DefId) { self.tcx().sess.span_note( self.span, format!("candidate \\#{} derives from the type of the receiver, \ - which is the trait `{}`", - idx+1u, - ty::item_path_str(self.tcx(), did))); + which is the trait `{}`", + idx + 1u, + ty::item_path_str(self.tcx(), did)).as_slice()); } fn infcx(&'a self) -> &'a infer::InferCtxt<'a> { diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs index 820c5bd859ca2..cc9bff899478a 100644 --- a/src/librustc/middle/typeck/check/mod.rs +++ b/src/librustc/middle/typeck/check/mod.rs @@ -546,8 +546,11 @@ fn span_for_field(tcx: &ty::ctxt, field: &ty::field_ty, struct_id: ast::DefId) - _ => false, }) { Some(f) => f.span, - None => tcx.sess.bug(format!("Could not find field {}", - token::get_name(field.name))), + None => { + tcx.sess + .bug(format!("Could not find field {}", + token::get_name(field.name)).as_slice()) + } } }, _ => tcx.sess.bug("Field found outside of a struct?"), @@ -569,8 +572,9 @@ fn check_for_field_shadowing(tcx: &ty::ctxt, match super_fields.iter().find(|sf| f.name == sf.name) { Some(prev_field) => { tcx.sess.span_err(span_for_field(tcx, f, id), - format!("field `{}` hides field declared in super-struct", - token::get_name(f.name))); + format!("field `{}` hides field declared in \ + super-struct", + token::get_name(f.name)).as_slice()); tcx.sess.span_note(span_for_field(tcx, prev_field, parent_id), "previously declared here"); }, @@ -593,11 +597,13 @@ fn check_fields_sized(tcx: &ty::ctxt, if !ty::type_is_sized(tcx, t) { match f.node.kind { ast::NamedField(ident, _) => { - tcx.sess.span_err(f.span, format!("type `{}` is dynamically sized. \ - dynamically sized types may only \ - appear as the type of the final \ - field in a struct", - token::get_ident(ident))); + tcx.sess.span_err( + f.span, + format!("type `{}` is dynamically sized. \ + dynamically sized types may only \ + appear as the type of the final \ + field in a struct", + token::get_ident(ident)).as_slice()); } ast::UnnamedField(_) => { tcx.sess.span_err(f.span, "dynamically sized type in field"); @@ -814,9 +820,10 @@ fn check_impl_methods_against_trait(ccx: &CrateCtxt, None => { tcx.sess.span_err( impl_method.span, - format!("method `{}` is not a member of trait `{}`", - token::get_ident(impl_method_ty.ident), - pprust::path_to_str(&ast_trait_ref.path))); + format!( + "method `{}` is not a member of trait `{}`", + token::get_ident(impl_method_ty.ident), + pprust::path_to_str(&ast_trait_ref.path)).as_slice()); } } } @@ -842,7 +849,7 @@ fn check_impl_methods_against_trait(ccx: &CrateCtxt, tcx.sess.span_err( impl_span, format!("not all trait methods implemented, missing: {}", - missing_methods.connect(", "))); + missing_methods.connect(", ")).as_slice()); } } @@ -886,7 +893,8 @@ fn compare_impl_method(tcx: &ty::ctxt, format!("method `{}` has a `{}` declaration in the impl, \ but not in the trait", token::get_ident(trait_m.ident), - pprust::explicit_self_to_str(impl_m.explicit_self))); + pprust::explicit_self_to_str( + impl_m.explicit_self)).as_slice()); return; } (_, &ast::SelfStatic) => { @@ -895,7 +903,8 @@ fn compare_impl_method(tcx: &ty::ctxt, format!("method `{}` has a `{}` declaration in the trait, \ but not in the impl", token::get_ident(trait_m.ident), - pprust::explicit_self_to_str(trait_m.explicit_self))); + pprust::explicit_self_to_str( + trait_m.explicit_self)).as_slice()); return; } _ => { @@ -914,7 +923,7 @@ fn compare_impl_method(tcx: &ty::ctxt, other{# type parameters}}", method = token::get_ident(trait_m.ident), nimpl = num_impl_m_type_params, - ntrait = num_trait_m_type_params)); + ntrait = num_trait_m_type_params).as_slice()); return; } @@ -927,7 +936,7 @@ fn compare_impl_method(tcx: &ty::ctxt, method = token::get_ident(trait_m.ident), nimpl = impl_m.fty.sig.inputs.len(), trait = ty::item_path_str(tcx, trait_m.def_id), - ntrait = trait_m.fty.sig.inputs.len())); + ntrait = trait_m.fty.sig.inputs.len()).as_slice()); return; } @@ -950,7 +959,7 @@ fn compare_impl_method(tcx: &ty::ctxt, in the trait declaration", token::get_ident(trait_m.ident), i, - extra_bounds.user_string(tcx))); + extra_bounds.user_string(tcx)).as_slice()); return; } @@ -971,7 +980,9 @@ fn compare_impl_method(tcx: &ty::ctxt, method = token::get_ident(trait_m.ident), typaram = i, nimpl = impl_param_def.bounds.trait_bounds.len(), - ntrait = trait_param_def.bounds.trait_bounds.len())); + ntrait = trait_param_def.bounds + .trait_bounds + .len()).as_slice()); return; } } @@ -1040,7 +1051,7 @@ fn compare_impl_method(tcx: &ty::ctxt, impl_m_span, format!("method `{}` has an incompatible type for trait: {}", token::get_ident(trait_m.ident), - ty::type_err_to_str(tcx, terr))); + ty::type_err_to_str(tcx, terr)).as_slice()); ty::note_and_explain_type_err(tcx, terr); } } @@ -1099,7 +1110,8 @@ impl<'a> FnCtxt<'a> { None => { self.tcx().sess.span_bug( span, - format!("no type for local variable {:?}", nid)); + format!("no type for local variable {:?}", + nid).as_slice()); } } } @@ -1173,7 +1185,7 @@ impl<'a> FnCtxt<'a> { Some(&t) => t, None => { self.tcx().sess.bug(format!("no type for expr in fcx {}", - self.tag())); + self.tag()).as_slice()); } } } @@ -1185,7 +1197,7 @@ impl<'a> FnCtxt<'a> { self.tcx().sess.bug( format!("no type for node {}: {} in fcx {}", id, self.tcx().map.node_to_str(id), - self.tag())); + self.tag()).as_slice()); } } } @@ -1197,7 +1209,7 @@ impl<'a> FnCtxt<'a> { self.tcx().sess.bug( format!("no method entry for node {}: {} in fcx {}", id, self.tcx().map.node_to_str(id), - self.tag())); + self.tag()).as_slice()); } } } @@ -1350,7 +1362,7 @@ pub fn autoderef(fcx: &FnCtxt, sp: Span, base_ty: ty::t, // We've reached the recursion limit, error gracefully. fcx.tcx().sess.span_err(sp, format!("reached the recursion limit while auto-dereferencing {}", - base_ty.repr(fcx.tcx()))); + base_ty.repr(fcx.tcx())).as_slice()); (ty::mk_err(), 0, None) } @@ -1607,7 +1619,7 @@ fn check_type_parameter_positions_in_path(function_context: &FnCtxt, found {nsupplied, plural, =1{# lifetime parameter} \ other{# lifetime parameters}}", nexpected = trait_region_parameter_count, - nsupplied = supplied_region_parameter_count)); + nsupplied = supplied_region_parameter_count).as_slice()); } // Make sure the number of type parameters supplied on the trait @@ -1638,7 +1650,8 @@ fn check_type_parameter_positions_in_path(function_context: &FnCtxt, nexpected = required_ty_param_count, nsupplied = supplied_ty_param_count) }; - function_context.tcx().sess.span_err(path.span, msg) + function_context.tcx().sess.span_err(path.span, + msg.as_slice()) } else if supplied_ty_param_count > formal_ty_param_count { let msg = if required_ty_param_count < generics.type_param_defs().len() { format!("the {trait_or_impl} referenced by this path needs at most \ @@ -1659,7 +1672,8 @@ fn check_type_parameter_positions_in_path(function_context: &FnCtxt, nexpected = formal_ty_param_count, nsupplied = supplied_ty_param_count) }; - function_context.tcx().sess.span_err(path.span, msg) + function_context.tcx().sess.span_err(path.span, + msg.as_slice()) } } _ => { @@ -1727,9 +1741,8 @@ fn check_expr_with_unifier(fcx: &FnCtxt, fty.sig.output } _ => { - fcx.tcx().sess.span_bug( - callee_expr.span, - format!("method without bare fn type")); + fcx.tcx().sess.span_bug(callee_expr.span, + "method without bare fn type"); } } } @@ -1768,7 +1781,7 @@ fn check_expr_with_unifier(fcx: &FnCtxt, nexpected = expected_arg_count, nsupplied = supplied_arg_count); - tcx.sess.span_err(sp, msg); + tcx.sess.span_err(sp, msg.as_slice()); err_args(supplied_arg_count) } @@ -1781,7 +1794,7 @@ fn check_expr_with_unifier(fcx: &FnCtxt, nexpected = expected_arg_count, nsupplied = supplied_arg_count); - tcx.sess.span_err(sp, msg); + tcx.sess.span_err(sp, msg.as_slice()); err_args(supplied_arg_count) }; @@ -2484,7 +2497,8 @@ fn check_expr_with_unifier(fcx: &FnCtxt, tcx.sess.span_err( field.ident.span, format!("field `{}` specified more than once", - token::get_ident(field.ident.node))); + token::get_ident(field.ident + .node)).as_slice()); error_happened = true; } Some((field_id, false)) => { @@ -2517,14 +2531,16 @@ fn check_expr_with_unifier(fcx: &FnCtxt, let name = class_field.name; let (_, seen) = *class_field_map.get(&name); if !seen { - missing_fields.push("`".to_owned() + token::get_name(name).get() + "`"); + missing_fields.push( + format!("`{}`", token::get_name(name).get())) } } tcx.sess.span_err(span, - format!("missing {nfields, plural, =1{field} other{fields}}: {fields}", - nfields = missing_fields.len(), - fields = missing_fields.connect(", "))); + format!( + "missing {nfields, plural, =1{field} other{fields}}: {fields}", + nfields = missing_fields.len(), + fields = missing_fields.connect(", ")).as_slice()); } } @@ -3589,7 +3605,7 @@ pub fn check_representable(tcx: &ty::ctxt, tcx.sess.span_err( sp, format!("illegal recursive {} type; \ wrap the inner value in a box to make it representable", - designation)); + designation).as_slice()); return false } ty::Representable | ty::ContainsRecursive => (), @@ -3614,10 +3630,12 @@ pub fn check_instantiable(tcx: &ty::ctxt, -> bool { let item_ty = ty::node_id_to_type(tcx, item_id); if !ty::is_instantiable(tcx, item_ty) { - tcx.sess.span_err(sp, format!("this type cannot be instantiated \ - without an instance of itself; \ - consider using `Option<{}>`", - ppaux::ty_to_str(tcx, item_ty))); + tcx.sess + .span_err(sp, + format!("this type cannot be instantiated without an \ + instance of itself; consider using \ + `Option<{}>`", + ppaux::ty_to_str(tcx, item_ty)).as_slice()); false } else { true @@ -3670,11 +3688,16 @@ pub fn check_enum_variants_sized(ccx: &CrateCtxt, // A struct value with an unsized final field is itself // unsized and we must track this in the type system. if !ty::type_is_sized(ccx.tcx, *t) { - ccx.tcx.sess.span_err(args.get(i).ty.span, - format!("type `{}` is dynamically sized. \ - dynamically sized types may only \ - appear as the final type in a variant", - ppaux::ty_to_str(ccx.tcx, *t))); + ccx.tcx + .sess + .span_err( + args.get(i).ty.span, + format!("type `{}` is dynamically sized. \ + dynamically sized types may only \ + appear as the final type in a \ + variant", + ppaux::ty_to_str(ccx.tcx, + *t)).as_slice()); } } }, @@ -3755,7 +3778,11 @@ pub fn check_enum_variants(ccx: &CrateCtxt, ccx.tcx.sess.span_err(e.span, "expected signed integer constant"); } Err(ref err) => { - ccx.tcx.sess.span_err(e.span, format!("expected constant: {}", *err)); + ccx.tcx + .sess + .span_err(e.span, + format!("expected constant: {}", + *err).as_slice()); } } }, @@ -3906,7 +3933,7 @@ pub fn instantiate_path(fcx: &FnCtxt, found {nsupplied, plural, =1{# lifetime parameter} \ other{# lifetime parameters}}", nexpected = num_expected_regions, - nsupplied = num_supplied_regions)); + nsupplied = num_supplied_regions).as_slice()); } fcx.infcx().region_vars_for_defs(span, tpt.generics.region_param_defs.as_slice()) @@ -3945,7 +3972,7 @@ pub fn instantiate_path(fcx: &FnCtxt, fcx.ccx.tcx.sess.span_err (span, format!("too many type parameters provided: {} {}, found {}", - expected, user_ty_param_count, ty_substs_len)); + expected, user_ty_param_count, ty_substs_len).as_slice()); (fcx.infcx().next_ty_vars(ty_param_count), regions) } else if ty_substs_len < user_ty_param_req { let expected = if user_ty_param_req < user_ty_param_count { @@ -3953,10 +3980,12 @@ pub fn instantiate_path(fcx: &FnCtxt, } else { "expected" }; - fcx.ccx.tcx.sess.span_err - (span, - format!("not enough type parameters provided: {} {}, found {}", - expected, user_ty_param_req, ty_substs_len)); + fcx.ccx.tcx.sess.span_err( + span, + format!("not enough type parameters provided: {} {}, found {}", + expected, + user_ty_param_req, + ty_substs_len).as_slice()); (fcx.infcx().next_ty_vars(ty_param_count), regions) } else { if ty_substs_len > user_ty_param_req @@ -4128,8 +4157,9 @@ pub fn ast_expr_vstore_to_ty(fcx: &FnCtxt, } } _ => { - fcx.ccx.tcx.sess.span_bug( - e.span, format!("vstore with unexpected contents")) + fcx.ccx.tcx.sess.span_bug(e.span, + "vstore with unexpected \ + contents") } } } @@ -4184,8 +4214,9 @@ pub fn check_bounds_are_used(ccx: &CrateCtxt, for (i, b) in tps_used.iter().enumerate() { if !*b { ccx.tcx.sess.span_err( - span, format!("type parameter `{}` is unused", - token::get_ident(tps.get(i).ident))); + span, + format!("type parameter `{}` is unused", + token::get_ident(tps.get(i).ident)).as_slice()); } } } @@ -4222,8 +4253,9 @@ pub fn check_intrinsic_type(ccx: &CrateCtxt, it: &ast::ForeignItem) { } op => { tcx.sess.span_err(it.span, - format!("unrecognized atomic operation function: `{}`", - op)); + format!("unrecognized atomic operation \ + function: `{}`", + op).as_slice()); return; } } @@ -4450,7 +4482,7 @@ pub fn check_intrinsic_type(ccx: &CrateCtxt, it: &ast::ForeignItem) { ref other => { tcx.sess.span_err(it.span, format!("unrecognized intrinsic function: `{}`", - *other)); + *other).as_slice()); return; } } @@ -4468,9 +4500,11 @@ pub fn check_intrinsic_type(ccx: &CrateCtxt, it: &ast::ForeignItem) { let i_ty = ty::lookup_item_type(ccx.tcx, local_def(it.id)); let i_n_tps = i_ty.generics.type_param_defs().len(); if i_n_tps != n_tps { - tcx.sess.span_err(it.span, format!("intrinsic has wrong number \ - of type parameters: found {}, \ - expected {}", i_n_tps, n_tps)); + tcx.sess.span_err(it.span, + format!("intrinsic has wrong number of type \ + parameters: found {}, expected {}", + i_n_tps, + n_tps).as_slice()); } else { require_same_types(tcx, None, diff --git a/src/librustc/middle/typeck/check/regionck.rs b/src/librustc/middle/typeck/check/regionck.rs index d8da67fff7fa3..34e8b5e169ff8 100644 --- a/src/librustc/middle/typeck/check/regionck.rs +++ b/src/librustc/middle/typeck/check/regionck.rs @@ -183,7 +183,7 @@ fn region_of_def(fcx: &FnCtxt, def: ast::Def) -> ty::Region { } _ => { tcx.sess.bug(format!("unexpected def in region_of_def: {:?}", - def)) + def).as_slice()) } } } @@ -880,7 +880,7 @@ fn constrain_autoderefs(rcx: &mut Rcx, ty::ty_rptr(r, ref m) => (m.mutbl, r), _ => rcx.tcx().sess.span_bug(deref_expr.span, format!("bad overloaded deref type {}", - method.ty.repr(rcx.tcx()))) + method.ty.repr(rcx.tcx())).as_slice()) }; { let mc = mc::MemCategorizationContext::new(rcx); @@ -1235,7 +1235,8 @@ fn link_region(rcx: &Rcx, rcx.tcx().sess.span_bug( span, format!("Illegal upvar id: {}", - upvar_id.repr(rcx.tcx()))); + upvar_id.repr( + rcx.tcx())).as_slice()); } } } diff --git a/src/librustc/middle/typeck/check/vtable.rs b/src/librustc/middle/typeck/check/vtable.rs index 04facc1426dba..5e67cb54ccc66 100644 --- a/src/librustc/middle/typeck/check/vtable.rs +++ b/src/librustc/middle/typeck/check/vtable.rs @@ -154,7 +154,7 @@ fn lookup_vtables_for_param(vcx: &VtableContext, format!("failed to find an implementation of \ trait {} for {}", vcx.infcx.trait_ref_to_str(&*trait_ref), - vcx.infcx.ty_to_str(ty))); + vcx.infcx.ty_to_str(ty)).as_slice()); } } true @@ -206,9 +206,9 @@ fn relate_trait_refs(vcx: &VtableContext, let tcx = vcx.tcx(); tcx.sess.span_err(span, format!("expected {}, but found {} ({})", - ppaux::trait_ref_to_str(tcx, &r_exp_trait_ref), - ppaux::trait_ref_to_str(tcx, &r_act_trait_ref), - ty::type_err_to_str(tcx, err))); + ppaux::trait_ref_to_str(tcx, &r_exp_trait_ref), + ppaux::trait_ref_to_str(tcx, &r_act_trait_ref), + ty::type_err_to_str(tcx, err)).as_slice()); } } } @@ -491,9 +491,9 @@ fn fixup_ty(vcx: &VtableContext, Ok(new_type) => Some(new_type), Err(e) if !is_early => { tcx.sess.span_fatal(span, - format!("cannot determine a type \ - for this bounded type parameter: {}", - fixup_err_to_str(e))) + format!("cannot determine a type for this bounded type \ + parameter: {}", + fixup_err_to_str(e)).as_slice()) } Err(_) => { None @@ -550,8 +550,9 @@ pub fn early_resolve_expr(ex: &ast::Expr, fcx: &FnCtxt, is_early: bool) { match (&ty::get(ty).sty, store) { (&ty::ty_rptr(_, mt), ty::RegionTraitStore(_, mutbl)) if !mutability_allowed(mt.mutbl, mutbl) => { - fcx.tcx().sess.span_err(ex.span, - format!("types differ in mutability")); + fcx.tcx() + .sess + .span_err(ex.span, "types differ in mutability"); } (&ty::ty_uniq(..), ty::UniqTraitStore) | @@ -609,15 +610,15 @@ pub fn early_resolve_expr(ex: &ast::Expr, fcx: &FnCtxt, is_early: bool) { ex.span, format!("can only cast an boxed pointer \ to a boxed object, not a {}", - ty::ty_sort_str(fcx.tcx(), ty))); + ty::ty_sort_str(fcx.tcx(), ty)).as_slice()); } (_, ty::RegionTraitStore(..)) => { fcx.ccx.tcx.sess.span_err( ex.span, format!("can only cast an &-pointer \ - to an &-object, not a {}", - ty::ty_sort_str(fcx.tcx(), ty))); + to an &-object, not a {}", + ty::ty_sort_str(fcx.tcx(), ty)).as_slice()); } } } diff --git a/src/librustc/middle/typeck/check/writeback.rs b/src/librustc/middle/typeck/check/writeback.rs index 993a678bd267e..133fc9b1530ab 100644 --- a/src/librustc/middle/typeck/check/writeback.rs +++ b/src/librustc/middle/typeck/check/writeback.rs @@ -402,7 +402,7 @@ impl<'cx> Resolver<'cx> { span, format!("cannot determine a type for \ this expression: {}", - infer::fixup_err_to_str(e))) + infer::fixup_err_to_str(e)).as_slice()) } ResolvingLocal(span) => { @@ -410,7 +410,7 @@ impl<'cx> Resolver<'cx> { span, format!("cannot determine a type for \ this local variable: {}", - infer::fixup_err_to_str(e))) + infer::fixup_err_to_str(e)).as_slice()) } ResolvingPattern(span) => { @@ -418,7 +418,7 @@ impl<'cx> Resolver<'cx> { span, format!("cannot determine a type for \ this pattern binding: {}", - infer::fixup_err_to_str(e))) + infer::fixup_err_to_str(e)).as_slice()) } ResolvingUpvar(upvar_id) => { @@ -430,13 +430,15 @@ impl<'cx> Resolver<'cx> { ty::local_var_name_str( self.tcx, upvar_id.var_id).get().to_str(), - infer::fixup_err_to_str(e))); + infer::fixup_err_to_str(e)).as_slice()); } ResolvingImplRes(span) => { - self.tcx.sess.span_err( - span, - format!("cannot determine a type for impl supertrait")); + self.tcx + .sess + .span_err(span, + "cannot determine a type for impl \ + supertrait"); } } } diff --git a/src/librustc/middle/typeck/coherence.rs b/src/librustc/middle/typeck/coherence.rs index d80e9f0888865..042bebf573f75 100644 --- a/src/librustc/middle/typeck/coherence.rs +++ b/src/librustc/middle/typeck/coherence.rs @@ -431,8 +431,9 @@ impl<'a> CoherenceChecker<'a> { session.span_err( self.span_of_impl(impl_a), format!("conflicting implementations for trait `{}`", - ty::item_path_str(self.crate_context.tcx, - trait_def_id))); + ty::item_path_str( + self.crate_context.tcx, + trait_def_id)).as_slice()); if impl_b.krate == LOCAL_CRATE { session.span_note(self.span_of_impl(impl_b), "note conflicting implementation here"); @@ -442,7 +443,7 @@ impl<'a> CoherenceChecker<'a> { session.note( format!("conflicting implementation in crate \ `{}`", - cdata.name)); + cdata.name).as_slice()); } } } diff --git a/src/librustc/middle/typeck/collect.rs b/src/librustc/middle/typeck/collect.rs index c70204098e0a7..447f8dfa278d6 100644 --- a/src/librustc/middle/typeck/collect.rs +++ b/src/librustc/middle/typeck/collect.rs @@ -123,7 +123,8 @@ impl<'a> AstConv for CrateCtxt<'a> { } x => { self.tcx.sess.bug(format!("unexpected sort of node \ - in get_item_ty(): {:?}", x)); + in get_item_ty(): {:?}", + x).as_slice()); } } } @@ -134,7 +135,8 @@ impl<'a> AstConv for CrateCtxt<'a> { fn ty_infer(&self, span: Span) -> ty::t { self.tcx.sess.span_err(span, "the type placeholder `_` is not \ - allowed within types on item signatures."); + allowed within types on item \ + signatures."); ty::mk_err() } } @@ -573,7 +575,8 @@ pub fn ensure_no_ty_param_bounds(ccx: &CrateCtxt, if ty_param.bounds.len() > 0 { ccx.tcx.sess.span_err( span, - format!("trait bounds are not allowed in {} definitions", thing)); + format!("trait bounds are not allowed in {} definitions", + thing).as_slice()); } } } @@ -711,10 +714,12 @@ pub fn convert_struct(ccx: &CrateCtxt, if result.name != special_idents::unnamed_field.name { let dup = match seen_fields.find(&result.name) { Some(prev_span) => { - tcx.sess.span_err(f.span, - format!("field `{}` is already declared", token::get_name(result.name))); + tcx.sess.span_err( + f.span, + format!("field `{}` is already declared", + token::get_name(result.name)).as_slice()); tcx.sess.span_note(*prev_span, - "previously declared here"); + "previously declared here"); true }, None => false, @@ -840,7 +845,7 @@ pub fn instantiate_trait_ref(ccx: &CrateCtxt, ccx.tcx.sess.span_fatal( ast_trait_ref.path.span, format!("`{}` is not a trait", - path_to_str(&ast_trait_ref.path))); + path_to_str(&ast_trait_ref.path)).as_slice()); } } } @@ -852,8 +857,10 @@ fn get_trait_def(ccx: &CrateCtxt, trait_id: ast::DefId) -> Rc { match ccx.tcx.map.get(trait_id.node) { ast_map::NodeItem(item) => trait_def_of_item(ccx, item), - _ => ccx.tcx.sess.bug(format!("get_trait_def({}): not an item", - trait_id.node)) + _ => { + ccx.tcx.sess.bug(format!("get_trait_def({}): not an item", + trait_id.node).as_slice()) + } } } @@ -889,7 +896,7 @@ pub fn trait_def_of_item(ccx: &CrateCtxt, it: &ast::Item) -> Rc { ref s => { tcx.sess.span_bug( it.span, - format!("trait_def_of_item invoked on {:?}", s)); + format!("trait_def_of_item invoked on {:?}", s).as_slice()); } } } @@ -960,9 +967,7 @@ pub fn ty_of_item(ccx: &CrateCtxt, it: &ast::Item) return tpt; } ast::ItemTrait(..) => { - tcx.sess.span_bug( - it.span, - format!("invoked ty_of_item on trait")); + tcx.sess.span_bug(it.span, "invoked ty_of_item on trait"); } ast::ItemStruct(_, ref generics) => { let ty_generics = ty_generics_for_type(ccx, generics); @@ -1113,8 +1118,7 @@ fn ty_generics(ccx: &CrateCtxt, if !ccx.tcx.sess.features.issue_5723_bootstrap.get() { ccx.tcx.sess.span_err( span, - format!("only the 'static lifetime is \ - accepted here.")); + "only the 'static lifetime is accepted here."); } } } @@ -1151,7 +1155,8 @@ fn ty_generics(ccx: &CrateCtxt, format!("incompatible bounds on type parameter {}, \ bound {} does not allow unsized type", token::get_ident(ident), - ppaux::trait_ref_to_str(tcx, &*trait_ref))); + ppaux::trait_ref_to_str(tcx, + &*trait_ref)).as_slice()); } true }); diff --git a/src/librustc/middle/typeck/infer/coercion.rs b/src/librustc/middle/typeck/infer/coercion.rs index d50e36c31a037..819a69cfad18e 100644 --- a/src/librustc/middle/typeck/infer/coercion.rs +++ b/src/librustc/middle/typeck/infer/coercion.rs @@ -212,7 +212,7 @@ impl<'f> Coerce<'f> { self.get_ref().infcx.tcx.sess.span_bug( self.get_ref().trace.origin.span(), format!("failed to resolve even without \ - any force options: {:?}", e)); + any force options: {:?}", e).as_slice()); } } } diff --git a/src/librustc/middle/typeck/infer/combine.rs b/src/librustc/middle/typeck/infer/combine.rs index 84df7230544e6..d80e8400a3a89 100644 --- a/src/librustc/middle/typeck/infer/combine.rs +++ b/src/librustc/middle/typeck/infer/combine.rs @@ -118,10 +118,9 @@ pub trait Combine { // I think it should never happen that we unify two // substs and one of them has a self_ty and one // doesn't...? I could be wrong about this. - self.infcx().tcx.sess.bug( - format!("substitution a had a self_ty \ - and substitution b didn't, \ - or vice versa")); + self.infcx().tcx.sess.bug("substitution a had a self_ty \ + and substitution b didn't, or \ + vice versa"); } } } @@ -403,9 +402,9 @@ pub fn super_tys(this: &C, a: ty::t, b: ty::t) -> cres { (_, &ty::ty_infer(TyVar(_))) => { tcx.sess.bug( format!("{}: bot and var types should have been handled ({},{})", - this.tag(), - a.inf_str(this.infcx()), - b.inf_str(this.infcx()))); + this.tag(), + a.inf_str(this.infcx()), + b.inf_str(this.infcx())).as_slice()); } // Relate integral variables to other types diff --git a/src/librustc/middle/typeck/infer/error_reporting.rs b/src/librustc/middle/typeck/infer/error_reporting.rs index 6f99a0a5ffb2b..6b6b9fab5c6b7 100644 --- a/src/librustc/middle/typeck/infer/error_reporting.rs +++ b/src/librustc/middle/typeck/infer/error_reporting.rs @@ -355,7 +355,7 @@ impl<'a> ErrorReporting for InferCtxt<'a> { format!("{}: {} ({})", message_root_str, expected_found_str, - ty::type_err_to_str(self.tcx, terr))); + ty::type_err_to_str(self.tcx, terr)).as_slice()); } fn report_and_explain_type_error(&self, @@ -430,7 +430,10 @@ impl<'a> ErrorReporting for InferCtxt<'a> { span, format!("lifetime of borrowed pointer outlives \ lifetime of captured variable `{}`...", - ty::local_var_name_str(self.tcx, upvar_id.var_id).get().to_str())); + ty::local_var_name_str(self.tcx, + upvar_id.var_id) + .get() + .to_str()).as_slice()); note_and_explain_region( self.tcx, "...the borrowed pointer is valid for ", @@ -439,7 +442,10 @@ impl<'a> ErrorReporting for InferCtxt<'a> { note_and_explain_region( self.tcx, format!("...but `{}` is only valid for ", - ty::local_var_name_str(self.tcx, upvar_id.var_id).get().to_str()), + ty::local_var_name_str(self.tcx, + upvar_id.var_id) + .get() + .to_str()).as_slice(), sup, ""); } @@ -483,7 +489,9 @@ impl<'a> ErrorReporting for InferCtxt<'a> { span, format!("captured variable `{}` does not \ outlive the enclosing closure", - ty::local_var_name_str(self.tcx, id).get().to_str())); + ty::local_var_name_str(self.tcx, + id).get() + .to_str()).as_slice()); note_and_explain_region( self.tcx, "captured variable is valid for ", @@ -496,9 +504,8 @@ impl<'a> ErrorReporting for InferCtxt<'a> { ""); } infer::IndexSlice(span) => { - self.tcx.sess.span_err( - span, - format!("index of slice outside its lifetime")); + self.tcx.sess.span_err(span, + "index of slice outside its lifetime"); note_and_explain_region( self.tcx, "the slice is only valid for ", @@ -591,7 +598,7 @@ impl<'a> ErrorReporting for InferCtxt<'a> { span, format!("in type `{}`, pointer has a longer lifetime than \ the data it references", - ty.user_string(self.tcx))); + ty.user_string(self.tcx)).as_slice()); note_and_explain_region( self.tcx, "the pointer is valid for ", @@ -1022,8 +1029,13 @@ impl<'a> Rebuilder<'a> { } ast::TyPath(ref path, _, id) => { let a_def = match self.tcx.def_map.borrow().find(&id) { - None => self.tcx.sess.fatal(format!("unbound path {}", - pprust::path_to_str(path))), + None => { + self.tcx + .sess + .fatal(format!( + "unbound path {}", + pprust::path_to_str(path)).as_slice()) + } Some(&d) => d }; match a_def { @@ -1209,18 +1221,18 @@ impl<'a> ErrorReportingHelpers for InferCtxt<'a> { opt_explicit_self, generics); let msg = format!("consider using an explicit lifetime \ parameter as shown: {}", suggested_fn); - self.tcx.sess.span_note(span, msg); + self.tcx.sess.span_note(span, msg.as_slice()); } fn report_inference_failure(&self, var_origin: RegionVariableOrigin) { let var_description = match var_origin { - infer::MiscVariable(_) => "".to_owned(), - infer::PatternRegion(_) => " for pattern".to_owned(), - infer::AddrOfRegion(_) => " for borrow expression".to_owned(), - infer::AddrOfSlice(_) => " for slice expression".to_owned(), - infer::Autoref(_) => " for autoref".to_owned(), - infer::Coercion(_) => " for automatic coercion".to_owned(), + infer::MiscVariable(_) => "".to_strbuf(), + infer::PatternRegion(_) => " for pattern".to_strbuf(), + infer::AddrOfRegion(_) => " for borrow expression".to_strbuf(), + infer::AddrOfSlice(_) => " for slice expression".to_strbuf(), + infer::Autoref(_) => " for autoref".to_strbuf(), + infer::Coercion(_) => " for automatic coercion".to_strbuf(), infer::LateBoundRegion(_, br) => { format!(" for {}in function call", bound_region_to_str(self.tcx, "lifetime parameter ", true, br)) @@ -1247,7 +1259,7 @@ impl<'a> ErrorReportingHelpers for InferCtxt<'a> { var_origin.span(), format!("cannot infer an appropriate lifetime{} \ due to conflicting requirements", - var_description)); + var_description).as_slice()); } fn note_region_origin(&self, origin: SubregionOrigin) { @@ -1282,7 +1294,7 @@ impl<'a> ErrorReportingHelpers for InferCtxt<'a> { self.tcx.sess.span_note( trace.origin.span(), format!("...so that {} ({})", - desc, values_str)); + desc, values_str).as_slice()); } None => { // Really should avoid printing this error at @@ -1291,7 +1303,7 @@ impl<'a> ErrorReportingHelpers for InferCtxt<'a> { // doing right now. - nmatsakis self.tcx.sess.span_note( trace.origin.span(), - format!("...so that {}", desc)); + format!("...so that {}", desc).as_slice()); } } } @@ -1304,8 +1316,11 @@ impl<'a> ErrorReportingHelpers for InferCtxt<'a> { infer::ReborrowUpvar(span, ref upvar_id) => { self.tcx.sess.span_note( span, - format!("...so that closure can access `{}`", - ty::local_var_name_str(self.tcx, upvar_id.var_id).get().to_str())) + format!( + "...so that closure can access `{}`", + ty::local_var_name_str(self.tcx, upvar_id.var_id) + .get() + .to_str()).as_slice()) } infer::InfStackClosure(span) => { self.tcx.sess.span_note( @@ -1328,7 +1343,9 @@ impl<'a> ErrorReportingHelpers for InferCtxt<'a> { span, format!("...so that captured variable `{}` \ does not outlive the enclosing closure", - ty::local_var_name_str(self.tcx, id).get().to_str())); + ty::local_var_name_str( + self.tcx, + id).get().to_str()).as_slice()); } infer::IndexSlice(span) => { self.tcx.sess.span_note( diff --git a/src/librustc/middle/typeck/infer/glb.rs b/src/librustc/middle/typeck/infer/glb.rs index 5ca5945a4f42f..73684a63ac124 100644 --- a/src/librustc/middle/typeck/infer/glb.rs +++ b/src/librustc/middle/typeck/infer/glb.rs @@ -249,7 +249,8 @@ impl<'f> Combine for Glb<'f> { } this.get_ref().infcx.tcx.sess.span_bug( this.get_ref().trace.origin.span(), - format!("could not find original bound region for {:?}", r)) + format!("could not find original bound region for {:?}", + r).as_slice()) } fn fresh_bound_variable(this: &Glb, binder_id: NodeId) -> ty::Region { diff --git a/src/librustc/middle/typeck/infer/lattice.rs b/src/librustc/middle/typeck/infer/lattice.rs index ebfb17a887633..41a59dae74083 100644 --- a/src/librustc/middle/typeck/infer/lattice.rs +++ b/src/librustc/middle/typeck/infer/lattice.rs @@ -529,7 +529,7 @@ pub fn var_ids(this: &T, r => { this.infcx().tcx.sess.span_bug( this.trace().origin.span(), - format!("found non-region-vid: {:?}", r)); + format!("found non-region-vid: {:?}", r).as_slice()); } }).collect() } diff --git a/src/librustc/middle/typeck/infer/lub.rs b/src/librustc/middle/typeck/infer/lub.rs index 7ba2210a2c4fc..1df16f868013d 100644 --- a/src/librustc/middle/typeck/infer/lub.rs +++ b/src/librustc/middle/typeck/infer/lub.rs @@ -185,8 +185,9 @@ impl<'f> Combine for Lub<'f> { this.get_ref().infcx.tcx.sess.span_bug( this.get_ref().trace.origin.span(), - format!("Region {:?} is not associated with \ - any bound region from A!", r0)) + format!("region {:?} is not associated with \ + any bound region from A!", + r0).as_slice()) } } diff --git a/src/librustc/middle/typeck/infer/mod.rs b/src/librustc/middle/typeck/infer/mod.rs index 30eb928a979b2..7fed5e4ee1ae9 100644 --- a/src/librustc/middle/typeck/infer/mod.rs +++ b/src/librustc/middle/typeck/infer/mod.rs @@ -693,9 +693,9 @@ impl<'a> InferCtxt<'a> { _ => { self.tcx.sess.bug( format!("resolve_type_vars_if_possible() yielded {} \ - when supplied with {}", - self.ty_to_str(dummy0), - self.ty_to_str(dummy1))); + when supplied with {}", + self.ty_to_str(dummy0), + self.ty_to_str(dummy1)).as_slice()); } } } @@ -729,7 +729,7 @@ impl<'a> InferCtxt<'a> { err: Option<&ty::type_err>) { debug!("hi! expected_ty = {:?}, actual_ty = {}", expected_ty, actual_ty); - let error_str = err.map_or("".to_owned(), |t_err| { + let error_str = err.map_or("".to_strbuf(), |t_err| { format!(" ({})", ty::type_err_to_str(self.tcx, t_err)) }); let resolved_expected = expected_ty.map(|e_ty| { @@ -737,11 +737,19 @@ impl<'a> InferCtxt<'a> { }); if !resolved_expected.map_or(false, |e| { ty::type_is_error(e) }) { match resolved_expected { - None => self.tcx.sess.span_err(sp, - format!("{}{}", mk_msg(None, actual_ty), error_str)), + None => { + self.tcx + .sess + .span_err(sp, + format!("{}{}", + mk_msg(None, actual_ty), + error_str).as_slice()) + } Some(e) => { self.tcx.sess.span_err(sp, - format!("{}{}", mk_msg(Some(self.ty_to_str(e)), actual_ty), error_str)); + format!("{}{}", + mk_msg(Some(self.ty_to_str(e)), actual_ty), + error_str).as_slice()); } } for err in err.iter() { diff --git a/src/librustc/middle/typeck/infer/region_inference/mod.rs b/src/librustc/middle/typeck/infer/region_inference/mod.rs index 24265d342eb41..1178e1dfa46e9 100644 --- a/src/librustc/middle/typeck/infer/region_inference/mod.rs +++ b/src/librustc/middle/typeck/infer/region_inference/mod.rs @@ -297,7 +297,7 @@ impl<'a> RegionVarBindings<'a> { origin.span(), format!("cannot relate bound region: {} <= {}", sub.repr(self.tcx), - sup.repr(self.tcx))); + sup.repr(self.tcx)).as_slice()); } (_, ReStatic) => { // all regions are subregions of static, so we can ignore this @@ -369,8 +369,8 @@ impl<'a> RegionVarBindings<'a> { None => { self.tcx.sess.span_bug( self.var_origins.borrow().get(rid.to_uint()).span(), - format!("attempt to resolve region variable before \ - values have been computed!")) + "attempt to resolve region variable before values have \ + been computed!") } Some(ref values) => *values.get(rid.to_uint()) }; @@ -546,7 +546,7 @@ impl<'a> RegionVarBindings<'a> { self.tcx.sess.bug( format!("cannot relate bound region: LUB({}, {})", a.repr(self.tcx), - b.repr(self.tcx))); + b.repr(self.tcx)).as_slice()); } (ReStatic, _) | (_, ReStatic) => { @@ -561,7 +561,9 @@ impl<'a> RegionVarBindings<'a> { self.tcx.sess.span_bug( self.var_origins.borrow().get(v_id.to_uint()).span(), format!("lub_concrete_regions invoked with \ - non-concrete regions: {:?}, {:?}", a, b)); + non-concrete regions: {:?}, {:?}", + a, + b).as_slice()); } (f @ ReFree(ref fr), ReScope(s_id)) | @@ -647,7 +649,7 @@ impl<'a> RegionVarBindings<'a> { self.tcx.sess.bug( format!("cannot relate bound region: GLB({}, {})", a.repr(self.tcx), - b.repr(self.tcx))); + b.repr(self.tcx)).as_slice()); } (ReStatic, r) | (r, ReStatic) => { @@ -665,7 +667,9 @@ impl<'a> RegionVarBindings<'a> { self.tcx.sess.span_bug( self.var_origins.borrow().get(v_id.to_uint()).span(), format!("glb_concrete_regions invoked with \ - non-concrete regions: {:?}, {:?}", a, b)); + non-concrete regions: {:?}, {:?}", + a, + b).as_slice()); } (ReFree(ref fr), s @ ReScope(s_id)) | @@ -1175,7 +1179,7 @@ impl<'a> RegionVarBindings<'a> { upper_bounds.iter() .map(|x| x.region) .collect::>() - .repr(self.tcx))); + .repr(self.tcx)).as_slice()); } fn collect_error_for_contracting_node( @@ -1222,7 +1226,7 @@ impl<'a> RegionVarBindings<'a> { upper_bounds.iter() .map(|x| x.region) .collect::>() - .repr(self.tcx))); + .repr(self.tcx)).as_slice()); } fn collect_concrete_regions(&self, diff --git a/src/librustc/middle/typeck/infer/unify.rs b/src/librustc/middle/typeck/infer/unify.rs index 2ee4f8fedd25b..f36b98628507d 100644 --- a/src/librustc/middle/typeck/infer/unify.rs +++ b/src/librustc/middle/typeck/infer/unify.rs @@ -87,7 +87,7 @@ impl<'a> UnifyInferCtxtMethods for InferCtxt<'a> { Some(&ref var_val) => (*var_val).clone(), None => { tcx.sess.bug(format!( - "failed lookup of vid `{}`", vid_u)); + "failed lookup of vid `{}`", vid_u).as_slice()); } }; match var_val { diff --git a/src/librustc/middle/typeck/mod.rs b/src/librustc/middle/typeck/mod.rs index 165c573d056ed..253ab22d4704c 100644 --- a/src/librustc/middle/typeck/mod.rs +++ b/src/librustc/middle/typeck/mod.rs @@ -311,7 +311,8 @@ pub fn require_same_types(tcx: &ty::ctxt, tcx.sess.span_err(span, format!("{}: {}", msg(), - ty::type_err_to_str(tcx, terr))); + ty::type_err_to_str(tcx, + terr)).as_slice()); ty::note_and_explain_type_err(tcx, terr); false } @@ -359,8 +360,10 @@ fn check_main_fn_ty(ccx: &CrateCtxt, } _ => { tcx.sess.span_bug(main_span, - format!("main has a non-function type: found `{}`", - ppaux::ty_to_str(tcx, main_t))); + format!("main has a non-function type: found \ + `{}`", + ppaux::ty_to_str(tcx, + main_t)).as_slice()); } } } @@ -411,8 +414,10 @@ fn check_start_fn_ty(ccx: &CrateCtxt, } _ => { tcx.sess.span_bug(start_span, - format!("start has a non-function type: found `{}`", - ppaux::ty_to_str(tcx, start_t))); + format!("start has a non-function type: found \ + `{}`", + ppaux::ty_to_str(tcx, + start_t)).as_slice()); } } } diff --git a/src/librustc/middle/typeck/variance.rs b/src/librustc/middle/typeck/variance.rs index 42850f8876338..a6bf8e109c485 100644 --- a/src/librustc/middle/typeck/variance.rs +++ b/src/librustc/middle/typeck/variance.rs @@ -538,8 +538,8 @@ impl<'a> ConstraintContext<'a> { Some(&index) => index, None => { self.tcx().sess.bug(format!( - "No inferred index entry for {}", - self.tcx().map.node_to_str(param_id))); + "no inferred index entry for {}", + self.tcx().map.node_to_str(param_id)).as_slice()); } } } @@ -787,7 +787,7 @@ impl<'a> ConstraintContext<'a> { self.tcx().sess.bug( format!("unexpected type encountered in \ variance inference: {}", - ty.repr(self.tcx()))); + ty.repr(self.tcx())).as_slice()); } } } @@ -858,9 +858,11 @@ impl<'a> ConstraintContext<'a> { ty::ReEmpty => { // We don't expect to see anything but 'static or bound // regions when visiting member types or method types. - self.tcx().sess.bug(format!("unexpected region encountered in \ - variance inference: {}", - region.repr(self.tcx()))); + self.tcx() + .sess + .bug(format!("unexpected region encountered in variance \ + inference: {}", + region.repr(self.tcx())).as_slice()); } } } diff --git a/src/librustc/middle/weak_lang_items.rs b/src/librustc/middle/weak_lang_items.rs index cbe04e4fcda79..19233f0a59fe5 100644 --- a/src/librustc/middle/weak_lang_items.rs +++ b/src/librustc/middle/weak_lang_items.rs @@ -85,7 +85,7 @@ fn verify(sess: &Session, items: &lang_items::LanguageItems) { $( if missing.contains(&lang_items::$item) && items.$name().is_none() { sess.err(format!("language item required, but not found: `{}`", - stringify!($name))); + stringify!($name)).as_slice()); } )* @@ -100,7 +100,7 @@ impl<'a> Context<'a> { } else)* { self.sess.span_err(span, format!("unknown external lang item: `{}`", - name)); + name).as_slice()); } } } diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs index 95ae05985d38e..087a4e58d4978 100644 --- a/src/librustc/util/ppaux.rs +++ b/src/librustc/util/ppaux.rs @@ -50,11 +50,11 @@ pub fn note_and_explain_region(cx: &ctxt, (ref str, Some(span)) => { cx.sess.span_note( span, - format!("{}{}{}", prefix, *str, suffix)); + format!("{}{}{}", prefix, *str, suffix).as_slice()); } (ref str, None) => { cx.sess.note( - format!("{}{}{}", prefix, *str, suffix)); + format!("{}{}{}", prefix, *str, suffix).as_slice()); } } } @@ -255,13 +255,13 @@ pub fn ty_to_str(cx: &ctxt, typ: t) -> StrBuf { match fn_style { ast::NormalFn => {} _ => { - s.push_str(fn_style.to_str()); + s.push_str(fn_style.to_str().as_slice()); s.push_char(' '); } }; if abi != abi::Rust { - s.push_str(format!("extern {} ", abi.to_str())); + s.push_str(format!("extern {} ", abi.to_str()).as_slice()); }; s.push_str("fn"); @@ -292,7 +292,7 @@ pub fn ty_to_str(cx: &ctxt, typ: t) -> StrBuf { match cty.fn_style { ast::NormalFn => {} _ => { - s.push_str(cty.fn_style.to_str()); + s.push_str(cty.fn_style.to_str().as_slice()); s.push_char(' '); } }; @@ -327,7 +327,7 @@ pub fn ty_to_str(cx: &ctxt, typ: t) -> StrBuf { sig: &ty::FnSig) { s.push_char(bra); let strs: Vec = sig.inputs.iter().map(|a| fn_input_to_str(cx, *a)).collect(); - s.push_str(strs.connect(", ")); + s.push_str(strs.connect(", ").as_slice()); if sig.variadic { s.push_str(", ..."); } diff --git a/src/librustdoc/clean.rs b/src/librustdoc/clean.rs index 236c98b72e65a..fb2a80333e82d 100644 --- a/src/librustdoc/clean.rs +++ b/src/librustdoc/clean.rs @@ -1015,7 +1015,10 @@ impl Clean for ty::t { let fqn: Vec = fqn.move_iter().map(|i| { i.to_str().to_strbuf() }).collect(); - let mut path = external_path(fqn.last().unwrap().to_str()); + let mut path = external_path(fqn.last() + .unwrap() + .to_str() + .as_slice()); let kind = match ty::get(*self).sty { ty::ty_struct(..) => TypeStruct, ty::ty_trait(..) => TypeTrait, diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs index 948d47b2eaf7e..65bc9f544f6f7 100644 --- a/src/librustdoc/html/format.rs +++ b/src/librustdoc/html/format.rs @@ -184,12 +184,12 @@ fn path(w: &mut fmt::Formatter, path: &clean::Path, print_all: bool, for lifetime in last.lifetimes.iter() { if counter > 0 { generics.push_str(", "); } counter += 1; - generics.push_str(format!("{}", *lifetime)); + generics.push_str(format!("{}", *lifetime).as_slice()); } for ty in last.types.iter() { if counter > 0 { generics.push_str(", "); } counter += 1; - generics.push_str(format!("{}", *ty)); + generics.push_str(format!("{}", *ty).as_slice()); } generics.push_str(">"); } @@ -206,7 +206,7 @@ fn path(w: &mut fmt::Formatter, path: &clean::Path, print_all: bool, let amt = path.segments.len() - 1; match rel_root { Some(root) => { - let mut root = StrBuf::from_str(root); + let mut root = StrBuf::from_str(root.as_slice()); for seg in path.segments.slice_to(amt).iter() { if "super" == seg.name.as_slice() || "self" == seg.name.as_slice() { @@ -323,18 +323,22 @@ impl fmt::Show for clean::Type { {arrow, select, yes{ -> {ret}} other{}}", style = FnStyleSpace(decl.fn_style), lifetimes = if decl.lifetimes.len() == 0 { - "".to_owned() + "".to_strbuf() } else { format!("<{:#}>", decl.lifetimes) }, args = decl.decl.inputs, - arrow = match decl.decl.output { clean::Unit => "no", _ => "yes" }, + arrow = match decl.decl.output { + clean::Unit => "no", + _ => "yes", + }, ret = decl.decl.output, bounds = { let mut ret = StrBuf::new(); match *region { Some(ref lt) => { - ret.push_str(format!(": {}", *lt)); + ret.push_str(format!(": {}", + *lt).as_slice()); } None => {} } @@ -347,7 +351,8 @@ impl fmt::Show for clean::Type { } else { ret.push_str(" + "); } - ret.push_str(format!("{}", *t)); + ret.push_str(format!("{}", + *t).as_slice()); } } } @@ -416,7 +421,10 @@ impl fmt::Show for clean::Type { }, **t) } clean::BorrowedRef{ lifetime: ref l, mutability, type_: ref ty} => { - let lt = match *l { Some(ref l) => format!("{} ", *l), _ => "".to_owned() }; + let lt = match *l { + Some(ref l) => format!("{} ", *l), + _ => "".to_strbuf(), + }; write!(f, "&{}{}{}", lt, match mutability { @@ -460,10 +468,10 @@ impl<'a> fmt::Show for Method<'a> { clean::SelfValue => args.push_str("self"), clean::SelfOwned => args.push_str("~self"), clean::SelfBorrowed(Some(ref lt), clean::Immutable) => { - args.push_str(format!("&{} self", *lt)); + args.push_str(format!("&{} self", *lt).as_slice()); } clean::SelfBorrowed(Some(ref lt), clean::Mutable) => { - args.push_str(format!("&{} mut self", *lt)); + args.push_str(format!("&{} mut self", *lt).as_slice()); } clean::SelfBorrowed(None, clean::Mutable) => { args.push_str("&mut self"); @@ -475,9 +483,9 @@ impl<'a> fmt::Show for Method<'a> { for (i, input) in d.inputs.values.iter().enumerate() { if i > 0 || args.len() > 0 { args.push_str(", "); } if input.name.len() > 0 { - args.push_str(format!("{}: ", input.name)); + args.push_str(format!("{}: ", input.name).as_slice()); } - args.push_str(format!("{}", input.type_)); + args.push_str(format!("{}", input.type_).as_slice()); } write!(f, "({args}){arrow, select, yes{ -> {ret}} other{}}", diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs index b64e77615e1f5..5f3c19d57549d 100644 --- a/src/librustdoc/html/markdown.rs +++ b/src/librustdoc/html/markdown.rs @@ -177,8 +177,9 @@ pub fn render(w: &mut fmt::Formatter, s: &str, print_toc: bool) -> fmt::Result { }; if !rendered { - let output = highlight::highlight(text, None).as_slice() - .to_c_str(); + let output = highlight::highlight(text.as_slice(), + None).as_slice() + .to_c_str(); output.with_ref(|r| { hoedown_buffer_puts(ob, r) }) @@ -202,7 +203,7 @@ pub fn render(w: &mut fmt::Formatter, s: &str, print_toc: bool) -> fmt::Result { }; // Transform the contents of the header into a hyphenated string - let id = (s.words().map(|s| { + let id = (s.as_slice().words().map(|s| { match s.to_ascii_opt() { Some(s) => s.to_lower().into_str().to_strbuf(), None => s.to_strbuf() diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index 752f193fa3f35..8744553955a63 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -407,8 +407,11 @@ pub fn run(mut krate: clean::Crate, dst: Path) -> io::IoResult<()> { if path.exists() { for line in BufferedReader::new(File::open(path)).lines() { let line = try!(line); - if !line.starts_with(key) { continue } - if line.starts_with(format!("{}['{}']", key, krate)) { + if !line.as_slice().starts_with(key) { + continue + } + if line.as_slice().starts_with( + format!("{}['{}']", key, krate).as_slice()) { continue } ret.push(line.to_strbuf()); @@ -646,7 +649,7 @@ impl<'a> SourceCollector<'a> { let title = format!("{} -- source", cur.filename_display()); let page = layout::Page { - title: title, + title: title.as_slice(), ty: "source", root_path: root_path.as_slice(), }; @@ -968,7 +971,7 @@ impl Context { // does make formatting *a lot* nicer. current_location_key.replace(Some(cx.current.clone())); - let mut title = StrBuf::from_str(cx.current.connect("::")); + let mut title = cx.current.connect("::"); if pushname { if title.len() > 0 { title.push_str("::"); @@ -1138,7 +1141,7 @@ fn item_path(item: &clean::Item) -> StrBuf { } fn full_path(cx: &Context, item: &clean::Item) -> StrBuf { - let mut s = StrBuf::from_str(cx.current.connect("::")); + let mut s = cx.current.connect("::"); s.push_str("::"); s.push_str(item.name.get_ref().as_slice()); return s @@ -1344,7 +1347,7 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item, parents.push_str(": "); for (i, p) in t.parents.iter().enumerate() { if i > 0 { parents.push_str(" + "); } - parents.push_str(format!("{}", *p)); + parents.push_str(format!("{}", *p).as_slice()); } } diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs index 48db910fc3908..984ef458c8f45 100644 --- a/src/librustdoc/lib.rs +++ b/src/librustdoc/lib.rs @@ -132,7 +132,7 @@ pub fn opts() -> Vec { pub fn usage(argv0: &str) { println!("{}", - getopts::usage(format!("{} [options] ", argv0), + getopts::usage(format!("{} [options] ", argv0).as_slice(), opts().as_slice())); } diff --git a/src/librustdoc/markdown.rs b/src/librustdoc/markdown.rs index e43e7d69a2d00..de9c2839e7398 100644 --- a/src/librustdoc/markdown.rs +++ b/src/librustdoc/markdown.rs @@ -80,7 +80,7 @@ pub fn render(input: &str, mut output: Path, matches: &getopts::Matches) -> int let mut css = StrBuf::new(); for name in matches.opt_strs("markdown-css").iter() { let s = format!("\n", name); - css.push_str(s) + css.push_str(s.as_slice()) } let input_str = load_or_return!(input, 1, 2); diff --git a/src/librustdoc/passes.rs b/src/librustdoc/passes.rs index a0d993dfe7d03..da18b7e8e9278 100644 --- a/src/librustdoc/passes.rs +++ b/src/librustdoc/passes.rs @@ -346,14 +346,14 @@ mod unindent_tests { #[test] fn should_unindent() { let s = " line1\n line2".to_owned(); - let r = unindent(s); + let r = unindent(s.as_slice()); assert_eq!(r.as_slice(), "line1\nline2"); } #[test] fn should_unindent_multiple_paragraphs() { let s = " line1\n\n line2".to_owned(); - let r = unindent(s); + let r = unindent(s.as_slice()); assert_eq!(r.as_slice(), "line1\n\nline2"); } @@ -362,7 +362,7 @@ mod unindent_tests { // Line 2 is indented another level beyond the // base indentation and should be preserved let s = " line1\n\n line2".to_owned(); - let r = unindent(s); + let r = unindent(s.as_slice()); assert_eq!(r.as_slice(), "line1\n\n line2"); } @@ -374,14 +374,14 @@ mod unindent_tests { // #[doc = "Start way over here // and continue here"] let s = "line1\n line2".to_owned(); - let r = unindent(s); + let r = unindent(s.as_slice()); assert_eq!(r.as_slice(), "line1\nline2"); } #[test] fn should_not_ignore_first_line_indent_in_a_single_line_para() { let s = "line1\n\n line2".to_owned(); - let r = unindent(s); + let r = unindent(s.as_slice()); assert_eq!(r.as_slice(), "line1\n\n line2"); } } diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs index 5b4a9bd27b76c..63e6b7e36644b 100644 --- a/src/librustdoc/test.rs +++ b/src/librustdoc/test.rs @@ -171,7 +171,7 @@ fn runtest(test: &str, cratename: &str, libs: HashSet, should_fail: bool, // Remove the previous dylib search path var let var = DynamicLibrary::envvar(); - let mut env: Vec<(~str,~str)> = os::env().move_iter().collect(); + let mut env: Vec<(StrBuf,StrBuf)> = os::env().move_iter().collect(); match env.iter().position(|&(ref k, _)| k.as_slice() == var) { Some(i) => { env.remove(i); } None => {} @@ -213,7 +213,8 @@ fn maketest(s: &str, cratename: &str, loose_feature_gating: bool) -> StrBuf { if !s.contains("extern crate") { if s.contains(cratename) { - prog.push_str(format!("extern crate {};\n", cratename)); + prog.push_str(format!("extern crate {};\n", + cratename).as_slice()); } } if s.contains("fn main") { @@ -275,7 +276,7 @@ impl Collector { }, testfn: testing::DynTestFn(proc() { runtest(test.as_slice(), - cratename, + cratename.as_slice(), libs, should_fail, no_run, diff --git a/src/librustuv/lib.rs b/src/librustuv/lib.rs index 0a6a305a3b780..857e07a2af17a 100644 --- a/src/librustuv/lib.rs +++ b/src/librustuv/lib.rs @@ -387,7 +387,7 @@ impl fmt::Show for UvError { #[test] fn error_smoke_test() { let err: UvError = UvError(uvll::EOF); - assert_eq!(err.to_str(), "EOF: end of file".to_owned()); + assert_eq!(err.to_str(), "EOF: end of file".to_strbuf()); } pub fn uv_error_to_io_error(uverr: UvError) -> IoError { diff --git a/src/libserialize/ebml.rs b/src/libserialize/ebml.rs index 104efbeab0a3c..3a387972ff7c1 100644 --- a/src/libserialize/ebml.rs +++ b/src/libserialize/ebml.rs @@ -663,7 +663,7 @@ pub mod writer { _ => Err(io::IoError { kind: io::OtherIoError, desc: "int too big", - detail: Some(format!("{}", n)) + detail: Some(format_strbuf!("{}", n)) }) } } @@ -676,7 +676,7 @@ pub mod writer { Err(io::IoError { kind: io::OtherIoError, desc: "int too big", - detail: Some(format!("{}", n)) + detail: Some(format_strbuf!("{}", n)) }) } diff --git a/src/libserialize/hex.rs b/src/libserialize/hex.rs index 3b8500753cb3f..82ab5fd5b048b 100644 --- a/src/libserialize/hex.rs +++ b/src/libserialize/hex.rs @@ -182,8 +182,16 @@ mod tests { #[test] pub fn test_from_hex_all_bytes() { for i in range(0, 256) { - assert_eq!(format!("{:02x}", i as uint).from_hex().unwrap().as_slice(), &[i as u8]); - assert_eq!(format!("{:02X}", i as uint).from_hex().unwrap().as_slice(), &[i as u8]); + assert_eq!(format!("{:02x}", i as uint).as_slice() + .from_hex() + .unwrap() + .as_slice(), + &[i as u8]); + assert_eq!(format!("{:02X}", i as uint).as_slice() + .from_hex() + .unwrap() + .as_slice(), + &[i as u8]); } } diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs index 422914b140570..92e3d5a26887a 100644 --- a/src/libserialize/json.rs +++ b/src/libserialize/json.rs @@ -425,7 +425,9 @@ impl<'a> ::Encoder for Encoder<'a> { } fn emit_f32(&mut self, v: f32) -> EncodeResult { self.emit_f64(v as f64) } - fn emit_char(&mut self, v: char) -> EncodeResult { self.emit_str(str::from_char(v)) } + fn emit_char(&mut self, v: char) -> EncodeResult { + self.emit_str(str::from_char(v).as_slice()) + } fn emit_str(&mut self, v: &str) -> EncodeResult { write!(self.wr, "{}", escape_str(v)) } @@ -614,9 +616,13 @@ impl<'a> ::Encoder for PrettyEncoder<'a> { fn emit_f64(&mut self, v: f64) -> EncodeResult { write!(self.wr, "{}", f64::to_str_digits(v, 6u)) } - fn emit_f32(&mut self, v: f32) -> EncodeResult { self.emit_f64(v as f64) } + fn emit_f32(&mut self, v: f32) -> EncodeResult { + self.emit_f64(v as f64) + } - fn emit_char(&mut self, v: char) -> EncodeResult { self.emit_str(str::from_char(v)) } + fn emit_char(&mut self, v: char) -> EncodeResult { + self.emit_str(str::from_char(v).as_slice()) + } fn emit_str(&mut self, v: &str) -> EncodeResult { write!(self.wr, "{}", escape_str(v)) } @@ -2477,7 +2483,7 @@ mod tests { // We can't compare the strings directly because the object fields be // printed in a different order. - assert_eq!(a.clone(), from_str(a.to_str()).unwrap()); + assert_eq!(a.clone(), from_str(a.to_str().as_slice()).unwrap()); assert_eq!(a.clone(), from_str(a.to_pretty_str().as_slice()).unwrap()); } diff --git a/src/libstd/ascii.rs b/src/libstd/ascii.rs index e087b3d177499..e5689158601bc 100644 --- a/src/libstd/ascii.rs +++ b/src/libstd/ascii.rs @@ -16,10 +16,9 @@ use iter::Iterator; use mem; use option::{Option, Some, None}; use slice::{ImmutableVector, MutableVector, Vector}; -use str::OwnedStr; -use str::Str; -use str::{StrAllocating, StrSlice}; +use str::{OwnedStr, Str, StrAllocating, StrSlice}; use str; +use strbuf::StrBuf; use to_str::{IntoStr}; use vec::Vec; @@ -249,7 +248,7 @@ impl OwnedAsciiCast for ~[u8] { } } -impl OwnedAsciiCast for ~str { +impl OwnedAsciiCast for StrBuf { #[inline] fn is_ascii(&self) -> bool { self.as_slice().is_ascii() @@ -257,7 +256,7 @@ impl OwnedAsciiCast for ~str { #[inline] unsafe fn into_ascii_nocheck(self) -> Vec { - let v: ~[u8] = mem::transmute(self); + let v: Vec = mem::transmute(self); v.into_ascii_nocheck() } } @@ -314,17 +313,18 @@ impl<'a> AsciiStr for &'a [Ascii] { impl IntoStr for ~[Ascii] { #[inline] - fn into_str(self) -> ~str { - unsafe { mem::transmute(self) } + fn into_str(self) -> StrBuf { + let vector: Vec = self.as_slice().iter().map(|x| *x).collect(); + vector.into_str() } } impl IntoStr for Vec { #[inline] - fn into_str(self) -> ~str { + fn into_str(self) -> StrBuf { unsafe { let s: &str = mem::transmute(self.as_slice()); - s.to_owned() + s.to_strbuf() } } } @@ -346,12 +346,12 @@ pub trait OwnedStrAsciiExt { /// Convert the string to ASCII upper case: /// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z', /// but non-ASCII letters are unchanged. - fn into_ascii_upper(self) -> ~str; + fn into_ascii_upper(self) -> StrBuf; /// Convert the string to ASCII lower case: /// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z', /// but non-ASCII letters are unchanged. - fn into_ascii_lower(self) -> ~str; + fn into_ascii_lower(self) -> StrBuf; } /// Extension methods for ASCII-subset only operations on string slices @@ -359,12 +359,12 @@ pub trait StrAsciiExt { /// Makes a copy of the string in ASCII upper case: /// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z', /// but non-ASCII letters are unchanged. - fn to_ascii_upper(&self) -> ~str; + fn to_ascii_upper(&self) -> StrBuf; /// Makes a copy of the string in ASCII lower case: /// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z', /// but non-ASCII letters are unchanged. - fn to_ascii_lower(&self) -> ~str; + fn to_ascii_lower(&self) -> StrBuf; /// Check that two strings are an ASCII case-insensitive match. /// Same as `to_ascii_lower(a) == to_ascii_lower(b)`, @@ -374,12 +374,12 @@ pub trait StrAsciiExt { impl<'a> StrAsciiExt for &'a str { #[inline] - fn to_ascii_upper(&self) -> ~str { + fn to_ascii_upper(&self) -> StrBuf { unsafe { str_copy_map_bytes(*self, ASCII_UPPER_MAP) } } #[inline] - fn to_ascii_lower(&self) -> ~str { + fn to_ascii_lower(&self) -> StrBuf { unsafe { str_copy_map_bytes(*self, ASCII_LOWER_MAP) } } @@ -394,36 +394,36 @@ impl<'a> StrAsciiExt for &'a str { } } -impl OwnedStrAsciiExt for ~str { +impl OwnedStrAsciiExt for StrBuf { #[inline] - fn into_ascii_upper(self) -> ~str { + fn into_ascii_upper(self) -> StrBuf { unsafe { str_map_bytes(self, ASCII_UPPER_MAP) } } #[inline] - fn into_ascii_lower(self) -> ~str { + fn into_ascii_lower(self) -> StrBuf { unsafe { str_map_bytes(self, ASCII_LOWER_MAP) } } } #[inline] -unsafe fn str_map_bytes(string: ~str, map: &'static [u8]) -> ~str { +unsafe fn str_map_bytes(string: StrBuf, map: &'static [u8]) -> StrBuf { let mut bytes = string.into_bytes(); for b in bytes.mut_iter() { *b = map[*b as uint]; } - str::raw::from_utf8_owned(bytes) + str::from_utf8(bytes.as_slice()).unwrap().to_strbuf() } #[inline] -unsafe fn str_copy_map_bytes(string: &str, map: &'static [u8]) -> ~str { - let mut s = string.to_owned(); - for b in str::raw::as_owned_vec(&mut s).mut_iter() { +unsafe fn str_copy_map_bytes(string: &str, map: &'static [u8]) -> StrBuf { + let mut s = string.to_strbuf(); + for b in s.as_mut_bytes().mut_iter() { *b = map[*b as uint]; } - s + s.into_strbuf() } static ASCII_LOWER_MAP: &'static [u8] = &[ @@ -552,15 +552,17 @@ mod tests { assert_eq!("( ;".to_ascii(), v2ascii!([40, 32, 59])); // FIXME: #5475 borrowchk error, owned vectors do not live long enough // if chained-from directly - let v = box [40u8, 32u8, 59u8]; assert_eq!(v.to_ascii(), v2ascii!([40, 32, 59])); - let v = "( ;".to_owned(); assert_eq!(v.to_ascii(), v2ascii!([40, 32, 59])); + let v = box [40u8, 32u8, 59u8]; + assert_eq!(v.to_ascii(), v2ascii!([40, 32, 59])); + let v = "( ;".to_strbuf(); + assert_eq!(v.as_slice().to_ascii(), v2ascii!([40, 32, 59])); - assert_eq!("abCDef&?#".to_ascii().to_lower().into_str(), "abcdef&?#".to_owned()); - assert_eq!("abCDef&?#".to_ascii().to_upper().into_str(), "ABCDEF&?#".to_owned()); + assert_eq!("abCDef&?#".to_ascii().to_lower().into_str(), "abcdef&?#".to_strbuf()); + assert_eq!("abCDef&?#".to_ascii().to_upper().into_str(), "ABCDEF&?#".to_strbuf()); - assert_eq!("".to_ascii().to_lower().into_str(), "".to_owned()); - assert_eq!("YMCA".to_ascii().to_lower().into_str(), "ymca".to_owned()); - assert_eq!("abcDEFxyz:.;".to_ascii().to_upper().into_str(), "ABCDEFXYZ:.;".to_owned()); + assert_eq!("".to_ascii().to_lower().into_str(), "".to_strbuf()); + assert_eq!("YMCA".to_ascii().to_lower().into_str(), "ymca".to_strbuf()); + assert_eq!("abcDEFxyz:.;".to_ascii().to_upper().into_str(), "ABCDEFXYZ:.;".to_strbuf()); assert!("aBcDeF&?#".to_ascii().eq_ignore_case("AbCdEf&?#".to_ascii())); @@ -572,16 +574,16 @@ mod tests { #[test] fn test_ascii_vec_ng() { - assert_eq!("abCDef&?#".to_ascii().to_lower().into_str(), "abcdef&?#".to_owned()); - assert_eq!("abCDef&?#".to_ascii().to_upper().into_str(), "ABCDEF&?#".to_owned()); - assert_eq!("".to_ascii().to_lower().into_str(), "".to_owned()); - assert_eq!("YMCA".to_ascii().to_lower().into_str(), "ymca".to_owned()); - assert_eq!("abcDEFxyz:.;".to_ascii().to_upper().into_str(), "ABCDEFXYZ:.;".to_owned()); + assert_eq!("abCDef&?#".to_ascii().to_lower().into_str(), "abcdef&?#".to_strbuf()); + assert_eq!("abCDef&?#".to_ascii().to_upper().into_str(), "ABCDEF&?#".to_strbuf()); + assert_eq!("".to_ascii().to_lower().into_str(), "".to_strbuf()); + assert_eq!("YMCA".to_ascii().to_lower().into_str(), "ymca".to_strbuf()); + assert_eq!("abcDEFxyz:.;".to_ascii().to_upper().into_str(), "ABCDEFXYZ:.;".to_strbuf()); } #[test] fn test_owned_ascii_vec() { - assert_eq!(("( ;".to_owned()).into_ascii(), vec2ascii![40, 32, 59]); + assert_eq!(("( ;".to_strbuf()).into_ascii(), vec2ascii![40, 32, 59]); assert_eq!((box [40u8, 32u8, 59u8]).into_ascii(), vec2ascii![40, 32, 59]); } @@ -593,8 +595,8 @@ mod tests { #[test] fn test_ascii_into_str() { - assert_eq!(vec2ascii![40, 32, 59].into_str(), "( ;".to_owned()); - assert_eq!(vec2ascii!(40, 32, 59).into_str(), "( ;".to_owned()); + assert_eq!(vec2ascii![40, 32, 59].into_str(), "( ;".to_strbuf()); + assert_eq!(vec2ascii!(40, 32, 59).into_str(), "( ;".to_strbuf()); } #[test] @@ -641,70 +643,70 @@ mod tests { assert_eq!((vec![40u8, 32u8, 59u8]).into_ascii_opt(), Some(vec2ascii![40, 32, 59])); assert_eq!((vec![127u8, 128u8, 255u8]).into_ascii_opt(), None); - assert_eq!(("( ;".to_owned()).into_ascii_opt(), Some(vec2ascii![40, 32, 59])); - assert_eq!(("zoä华".to_owned()).into_ascii_opt(), None); + assert_eq!(("( ;".to_strbuf()).into_ascii_opt(), Some(vec2ascii![40, 32, 59])); + assert_eq!(("zoä华".to_strbuf()).into_ascii_opt(), None); } #[test] fn test_to_ascii_upper() { - assert_eq!("url()URL()uRl()ürl".to_ascii_upper(), "URL()URL()URL()üRL".to_owned()); - assert_eq!("hıKß".to_ascii_upper(), "HıKß".to_owned()); + assert_eq!("url()URL()uRl()ürl".to_ascii_upper(), "URL()URL()URL()üRL".to_strbuf()); + assert_eq!("hıKß".to_ascii_upper(), "HıKß".to_strbuf()); let mut i = 0; 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_char(from_u32(i).unwrap()).to_ascii_upper(), - from_char(from_u32(upper).unwrap())) + assert_eq!(from_char(from_u32(i).unwrap()).as_slice().to_ascii_upper(), + from_char(from_u32(upper).unwrap()).to_strbuf()) i += 1; } } #[test] fn test_to_ascii_lower() { - assert_eq!("url()URL()uRl()Ürl".to_ascii_lower(), "url()url()url()Ürl".to_owned()); + assert_eq!("url()URL()uRl()Ürl".to_ascii_lower(), "url()url()url()Ürl".to_strbuf()); // Dotted capital I, Kelvin sign, Sharp S. - assert_eq!("HİKß".to_ascii_lower(), "hİKß".to_owned()); + assert_eq!("HİKß".to_ascii_lower(), "hİKß".to_strbuf()); let mut i = 0; 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_char(from_u32(i).unwrap()).to_ascii_lower(), - from_char(from_u32(lower).unwrap())) + assert_eq!(from_char(from_u32(i).unwrap()).as_slice().to_ascii_lower(), + from_char(from_u32(lower).unwrap()).to_strbuf()) i += 1; } } #[test] fn test_into_ascii_upper() { - assert_eq!(("url()URL()uRl()ürl".to_owned()).into_ascii_upper(), - "URL()URL()URL()üRL".to_owned()); - assert_eq!(("hıKß".to_owned()).into_ascii_upper(), "HıKß".to_owned()); + assert_eq!(("url()URL()uRl()ürl".to_strbuf()).into_ascii_upper(), + "URL()URL()URL()üRL".to_strbuf()); + assert_eq!(("hıKß".to_strbuf()).into_ascii_upper(), "HıKß".to_strbuf()); let mut i = 0; 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_char(from_u32(i).unwrap()).into_ascii_upper(), - from_char(from_u32(upper).unwrap())) + assert_eq!(from_char(from_u32(i).unwrap()).to_strbuf().into_ascii_upper(), + from_char(from_u32(upper).unwrap()).to_strbuf()) i += 1; } } #[test] fn test_into_ascii_lower() { - assert_eq!(("url()URL()uRl()Ürl".to_owned()).into_ascii_lower(), - "url()url()url()Ürl".to_owned()); + assert_eq!(("url()URL()uRl()Ürl".to_strbuf()).into_ascii_lower(), + "url()url()url()Ürl".to_strbuf()); // Dotted capital I, Kelvin sign, Sharp S. - assert_eq!(("HİKß".to_owned()).into_ascii_lower(), "hİKß".to_owned()); + assert_eq!(("HİKß".to_strbuf()).into_ascii_lower(), "hİKß".to_strbuf()); let mut i = 0; 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_char(from_u32(i).unwrap()).into_ascii_lower(), - from_char(from_u32(lower).unwrap())) + assert_eq!(from_char(from_u32(i).unwrap()).to_strbuf().into_ascii_lower(), + from_char(from_u32(lower).unwrap()).to_strbuf()) i += 1; } } @@ -724,8 +726,11 @@ 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_char(from_u32(i).unwrap()). - eq_ignore_ascii_case(from_char(from_u32(lower).unwrap()))); + assert!(from_char(from_u32(i).unwrap()).as_slice() + .eq_ignore_ascii_case( + from_char( + from_u32(lower) + .unwrap()).as_slice())); i += 1; } } @@ -733,12 +738,12 @@ mod tests { #[test] fn test_to_str() { let s = Ascii{ chr: 't' as u8 }.to_str(); - assert_eq!(s, "t".to_owned()); + assert_eq!(s, "t".to_strbuf()); } #[test] fn test_show() { let c = Ascii { chr: 't' as u8 }; - assert_eq!(format!("{}", c), "t".to_owned()); + assert_eq!(format_strbuf!("{}", c), "t".to_strbuf()); } } diff --git a/src/libstd/c_str.rs b/src/libstd/c_str.rs index 0c529ee4d963e..4622c0934fe44 100644 --- a/src/libstd/c_str.rs +++ b/src/libstd/c_str.rs @@ -323,29 +323,6 @@ impl<'a> ToCStr for &'a str { } } -impl ToCStr for ~str { - #[inline] - fn to_c_str(&self) -> CString { - self.as_bytes().to_c_str() - } - - #[inline] - unsafe fn to_c_str_unchecked(&self) -> CString { - self.as_bytes().to_c_str_unchecked() - } - - #[inline] - fn with_c_str(&self, f: |*libc::c_char| -> T) -> T { - self.as_bytes().with_c_str(f) - } - - #[inline] - unsafe fn with_c_str_unchecked(&self, f: |*libc::c_char| -> T) -> T { - self.as_bytes().with_c_str_unchecked(f) - } -} - - impl ToCStr for StrBuf { #[inline] fn to_c_str(&self) -> CString { diff --git a/src/libstd/comm/mod.rs b/src/libstd/comm/mod.rs index fd5b92ba46913..b2521f2978a54 100644 --- a/src/libstd/comm/mod.rs +++ b/src/libstd/comm/mod.rs @@ -990,7 +990,7 @@ mod test { pub fn stress_factor() -> uint { match os::getenv("RUST_TEST_STRESS") { - Some(val) => from_str::(val).unwrap(), + Some(val) => from_str::(val.as_slice()).unwrap(), None => 1, } } @@ -1523,7 +1523,7 @@ mod sync_tests { pub fn stress_factor() -> uint { match os::getenv("RUST_TEST_STRESS") { - Some(val) => from_str::(val).unwrap(), + Some(val) => from_str::(val.as_slice()).unwrap(), None => 1, } } diff --git a/src/libstd/fmt.rs b/src/libstd/fmt.rs index 86b77a46a3980..db23a5f172022 100644 --- a/src/libstd/fmt.rs +++ b/src/libstd/fmt.rs @@ -27,9 +27,9 @@ general case. The `format!` macro is intended to be familiar to those coming from C's printf/fprintf functions or Python's `str.format` function. In its current -revision, the `format!` macro returns a `~str` type which is the result of the -formatting. In the future it will also be able to pass in a stream to format -arguments directly while performing minimal allocations. +revision, the `format!` macro returns a `StrBuf` type which is the result of +the formatting. In the future it will also be able to pass in a stream to +format arguments directly while performing minimal allocations. Some examples of the `format!` extension are: @@ -282,7 +282,7 @@ use std::io; # #[allow(unused_must_use)] # fn main() { -format_args!(fmt::format, "this returns {}", "~str"); +format_args!(fmt::format, "this returns {}", "StrBuf"); let some_writer: &mut io::Writer = &mut io::stdout(); format_args!(|args| { write!(some_writer, "{}", args) }, "print with a {}", "closure"); @@ -488,7 +488,7 @@ use io; use option::None; use repr; use result::{Ok, Err}; -use str::{StrAllocating}; +use str::{Str, StrAllocating}; use str; use strbuf::StrBuf; use slice::Vector; @@ -545,10 +545,10 @@ pub trait Poly { /// let s = format_args!(fmt::format, "Hello, {}!", "world"); /// assert_eq!(s, "Hello, world!".to_owned()); /// ``` -pub fn format(args: &Arguments) -> ~str { +pub fn format(args: &Arguments) -> StrBuf{ let mut output = io::MemWriter::new(); let _ = write!(&mut output, "{}", args); - str::from_utf8(output.unwrap().as_slice()).unwrap().to_owned() + str::from_utf8(output.unwrap().as_slice()).unwrap().into_strbuf() } /// Temporary transition utility @@ -572,7 +572,7 @@ impl Poly for T { // this allocation of a new string _ => { let s = repr::repr_to_str(self); - f.pad(s) + f.pad(s.as_slice()) } } } diff --git a/src/libstd/hash/mod.rs b/src/libstd/hash/mod.rs index a510aa90343e5..1dad1667ebd45 100644 --- a/src/libstd/hash/mod.rs +++ b/src/libstd/hash/mod.rs @@ -23,7 +23,7 @@ * #[deriving(Hash)] * struct Person { * id: uint, - * name: ~str, + * name: StrBuf, * phone: u64, * } * @@ -43,7 +43,7 @@ * * struct Person { * id: uint, - * name: ~str, + * name: StrBuf, * phone: u64, * } * @@ -145,13 +145,6 @@ impl<'a, S: Writer> Hash for &'a str { } } -impl Hash for ~str { - #[inline] - fn hash(&self, state: &mut S) { - self.as_slice().hash(state); - } -} - macro_rules! impl_hash_tuple( () => ( impl Hash for () { diff --git a/src/libstd/hash/sip.rs b/src/libstd/hash/sip.rs index 58e0f4c717ded..1434e3c7ad71e 100644 --- a/src/libstd/hash/sip.rs +++ b/src/libstd/hash/sip.rs @@ -458,12 +458,12 @@ mod tests { let mut state_inc = SipState::new_with_keys(k0, k1); let mut state_full = SipState::new_with_keys(k0, k1); - fn to_hex_str(r: &[u8, ..8]) -> ~str { + fn to_hex_str(r: &[u8, ..8]) -> StrBuf { let mut s = StrBuf::new(); for b in r.iter() { - s.push_str((*b as uint).to_str_radix(16u)); + s.push_str((*b as uint).to_str_radix(16u).as_slice()); } - s.into_owned() + s } fn result_bytes(h: u64) -> ~[u8] { @@ -478,13 +478,13 @@ mod tests { ] } - fn result_str(h: u64) -> ~str { + fn result_str(h: u64) -> StrBuf { let r = result_bytes(h); let mut s = StrBuf::new(); for b in r.iter() { - s.push_str((*b as uint).to_str_radix(16u)); + s.push_str((*b as uint).to_str_radix(16u).as_slice()); } - s.into_owned() + s } while t < 64 { @@ -636,7 +636,6 @@ officia deserunt mollit anim id est laborum."; struct Compound { x: u8, y: u64, - z: ~str, } #[bench] @@ -644,7 +643,6 @@ officia deserunt mollit anim id est laborum."; let compound = Compound { x: 1, y: 2, - z: "foobarbaz".to_owned(), }; b.iter(|| { assert_eq!(hash(&compound), 15783192367317361799); diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs index 2880365cf348f..c7b0d66062460 100644 --- a/src/libstd/io/buffered.rs +++ b/src/libstd/io/buffered.rs @@ -537,9 +537,9 @@ mod test { fn test_read_line() { let in_buf = MemReader::new(Vec::from_slice(bytes!("a\nb\nc"))); let mut reader = BufferedReader::with_capacity(2, in_buf); - assert_eq!(reader.read_line(), Ok("a\n".to_owned())); - assert_eq!(reader.read_line(), Ok("b\n".to_owned())); - assert_eq!(reader.read_line(), Ok("c".to_owned())); + assert_eq!(reader.read_line(), Ok("a\n".to_strbuf())); + assert_eq!(reader.read_line(), Ok("b\n".to_strbuf())); + assert_eq!(reader.read_line(), Ok("c".to_strbuf())); assert!(reader.read_line().is_err()); } @@ -548,9 +548,9 @@ mod test { let in_buf = MemReader::new(Vec::from_slice(bytes!("a\nb\nc"))); let mut reader = BufferedReader::with_capacity(2, in_buf); let mut it = reader.lines(); - assert_eq!(it.next(), Some(Ok("a\n".to_owned()))); - assert_eq!(it.next(), Some(Ok("b\n".to_owned()))); - assert_eq!(it.next(), Some(Ok("c".to_owned()))); + assert_eq!(it.next(), Some(Ok("a\n".to_strbuf()))); + assert_eq!(it.next(), Some(Ok("b\n".to_strbuf()))); + assert_eq!(it.next(), Some(Ok("c".to_strbuf()))); assert_eq!(it.next(), None); } diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs index a497ffd40a070..d8edd6517d587 100644 --- a/src/libstd/io/fs.rs +++ b/src/libstd/io/fs.rs @@ -745,7 +745,8 @@ mod test { pub fn tmpdir() -> TempDir { use os; use rand; - let ret = os::tmpdir().join(format!("rust-{}", rand::random::())); + let ret = os::tmpdir().join( + format_strbuf!("rust-{}", rand::random::())); check!(io::fs::mkdir(&ret, io::UserRWX)); TempDir(ret) } @@ -854,7 +855,7 @@ mod test { } check!(unlink(filename)); let read_str = str::from_utf8(read_mem).unwrap(); - assert!(read_str == final_msg.to_owned()); + assert!(read_str.as_slice() == final_msg.as_slice()); }) iotest!(fn file_test_io_seek_shakedown() { @@ -952,10 +953,10 @@ mod test { check!(mkdir(dir, io::UserRWX)); let prefix = "foo"; for n in range(0,3) { - let f = dir.join(format!("{}.txt", n)); + let f = dir.join(format_strbuf!("{}.txt", n)); let mut w = check!(File::create(&f)); - let msg_str = (prefix + n.to_str().to_owned()).to_owned(); - let msg = msg_str.as_bytes(); + let msg_str = format!("{}{}", prefix, n.to_str()); + let msg = msg_str.as_slice().as_bytes(); check!(w.write(msg)); } let files = check!(readdir(dir)); @@ -967,7 +968,7 @@ mod test { let read_str = str::from_utf8(mem).unwrap(); let expected = match n { None|Some("") => fail!("really shouldn't happen.."), - Some(n) => prefix+n + Some(n) => format!("{}{}", prefix, n), }; assert_eq!(expected.as_slice(), read_str); } @@ -1039,7 +1040,7 @@ mod test { let tmpdir = tmpdir(); let mut dirpath = tmpdir.path().clone(); - dirpath.push(format!("test-가一ー你好")); + dirpath.push(format_strbuf!("test-가一ー你好")); check!(mkdir(&dirpath, io::UserRWX)); assert!(dirpath.is_dir()); @@ -1056,7 +1057,7 @@ mod test { let tmpdir = tmpdir(); let unicode = tmpdir.path(); - let unicode = unicode.join(format!("test-각丁ー再见")); + let unicode = unicode.join(format_strbuf!("test-각丁ー再见")); check!(mkdir(&unicode, io::UserRWX)); assert!(unicode.exists()); assert!(!Path::new("test/unicode-bogus-path-각丁ー再见").exists()); diff --git a/src/libstd/io/mem.rs b/src/libstd/io/mem.rs index 92b546d5770e6..c1e228cd693b5 100644 --- a/src/libstd/io/mem.rs +++ b/src/libstd/io/mem.rs @@ -497,7 +497,7 @@ mod test { writer.write_line("testing").unwrap(); writer.write_str("testing").unwrap(); let mut r = BufReader::new(writer.get_ref()); - assert_eq!(r.read_to_str().unwrap(), "testingtesting\ntesting".to_owned()); + assert_eq!(r.read_to_str().unwrap(), "testingtesting\ntesting".to_strbuf()); } #[test] @@ -507,7 +507,7 @@ mod test { writer.write_char('\n').unwrap(); writer.write_char('ệ').unwrap(); let mut r = BufReader::new(writer.get_ref()); - assert_eq!(r.read_to_str().unwrap(), "a\nệ".to_owned()); + assert_eq!(r.read_to_str().unwrap(), "a\nệ".to_strbuf()); } #[test] diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs index a043722581ba2..50bd3e7067c85 100644 --- a/src/libstd/io/mod.rs +++ b/src/libstd/io/mod.rs @@ -76,7 +76,7 @@ Some examples of obvious things you might want to do let path = Path::new("message.txt"); let mut file = BufferedReader::new(File::open(&path)); - let lines: Vec<~str> = file.lines().map(|x| x.unwrap()).collect(); + let lines: Vec = file.lines().map(|x| x.unwrap()).collect(); ``` * Make a simple TCP client connection and request @@ -228,6 +228,7 @@ use result::{Ok, Err, Result}; use slice::{Vector, MutableVector, ImmutableVector}; use str::{StrSlice, StrAllocating}; use str; +use strbuf::StrBuf; use uint; use vec::Vec; @@ -292,7 +293,7 @@ pub struct IoError { /// A human-readable description about the error pub desc: &'static str, /// Detailed information about this error, not always available - pub detail: Option<~str> + pub detail: Option } impl IoError { @@ -364,7 +365,11 @@ impl IoError { IoError { kind: kind, desc: desc, - detail: if detail {Some(os::error_string(errno))} else {None}, + detail: if detail { + Some(os::error_string(errno)) + } else { + None + }, } } @@ -490,8 +495,10 @@ pub trait Reader { /// bytes are read. fn read_at_least(&mut self, min: uint, buf: &mut [u8]) -> IoResult { if min > buf.len() { - return Err(IoError { detail: Some("the buffer is too short".to_owned()), - ..standard_error(InvalidInput) }); + return Err(IoError { + detail: Some("the buffer is too short".to_strbuf()), + ..standard_error(InvalidInput) + }); } let mut read = 0; while read < min { @@ -556,8 +563,10 @@ pub trait Reader { /// bytes are read. fn push_at_least(&mut self, min: uint, len: uint, buf: &mut Vec) -> IoResult { if min > len { - return Err(IoError { detail: Some("the buffer is too short".to_owned()), - ..standard_error(InvalidInput) }); + return Err(IoError { + detail: Some("the buffer is too short".to_strbuf()), + ..standard_error(InvalidInput) + }); } let start_len = buf.len(); @@ -623,10 +632,10 @@ pub trait Reader { /// This function returns all of the same errors as `read_to_end` with an /// additional error if the reader's contents are not a valid sequence of /// UTF-8 bytes. - fn read_to_str(&mut self) -> IoResult<~str> { + fn read_to_str(&mut self) -> IoResult { self.read_to_end().and_then(|s| { match str::from_utf8(s.as_slice()) { - Some(s) => Ok(s.to_owned()), + Some(s) => Ok(s.to_strbuf()), None => Err(standard_error(InvalidInput)), } }) @@ -1235,8 +1244,8 @@ pub struct Lines<'r, T> { buffer: &'r mut T, } -impl<'r, T: Buffer> Iterator> for Lines<'r, T> { - fn next(&mut self) -> Option> { +impl<'r, T: Buffer> Iterator> for Lines<'r, T> { + fn next(&mut self) -> Option> { match self.buffer.read_line() { Ok(x) => Some(Ok(x)), Err(IoError { kind: EndOfFile, ..}) => None, @@ -1321,10 +1330,10 @@ pub trait Buffer: Reader { /// /// Additionally, this function can fail if the line of input read is not a /// valid UTF-8 sequence of bytes. - fn read_line(&mut self) -> IoResult<~str> { + fn read_line(&mut self) -> IoResult { self.read_until('\n' as u8).and_then(|line| match str::from_utf8(line.as_slice()) { - Some(s) => Ok(s.to_owned()), + Some(s) => Ok(s.to_strbuf()), None => Err(standard_error(InvalidInput)), } ) diff --git a/src/libstd/io/net/ip.rs b/src/libstd/io/net/ip.rs index f469c419e8ef7..4bf71b5480e2f 100644 --- a/src/libstd/io/net/ip.rs +++ b/src/libstd/io/net/ip.rs @@ -445,8 +445,8 @@ mod test { #[test] fn ipv6_addr_to_str() { let a1 = Ipv6Addr(0, 0, 0, 0, 0, 0xffff, 0xc000, 0x280); - assert!(a1.to_str() == "::ffff:192.0.2.128".to_owned() || - a1.to_str() == "::FFFF:192.0.2.128".to_owned()); - assert_eq!(Ipv6Addr(8, 9, 10, 11, 12, 13, 14, 15).to_str(), "8:9:a:b:c:d:e:f".to_owned()); + assert!(a1.to_str() == "::ffff:192.0.2.128".to_strbuf() || + a1.to_str() == "::FFFF:192.0.2.128".to_strbuf()); + assert_eq!(Ipv6Addr(8, 9, 10, 11, 12, 13, 14, 15).to_str(), "8:9:a:b:c:d:e:f".to_strbuf()); } } diff --git a/src/libstd/io/net/tcp.rs b/src/libstd/io/net/tcp.rs index dec68b9d89e6d..ac17bc1de1379 100644 --- a/src/libstd/io/net/tcp.rs +++ b/src/libstd/io/net/tcp.rs @@ -434,7 +434,7 @@ mod test { let socket_addr = next_test_ip4(); let ip_str = socket_addr.ip.to_str(); let port = socket_addr.port; - let listener = TcpListener::bind(ip_str, port); + let listener = TcpListener::bind(ip_str.as_slice(), port); let mut acceptor = listener.listen(); spawn(proc() { @@ -452,7 +452,7 @@ mod test { let addr = next_test_ip4(); let ip_str = addr.ip.to_str(); let port = addr.port; - let mut acceptor = TcpListener::bind(ip_str, port).listen(); + let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen(); spawn(proc() { let mut stream = TcpStream::connect("localhost", addr.port); @@ -469,7 +469,7 @@ mod test { let addr = next_test_ip4(); let ip_str = addr.ip.to_str(); let port = addr.port; - let mut acceptor = TcpListener::bind(ip_str, port).listen(); + let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen(); spawn(proc() { let mut stream = TcpStream::connect("127.0.0.1", addr.port); @@ -486,7 +486,7 @@ mod test { let addr = next_test_ip6(); let ip_str = addr.ip.to_str(); let port = addr.port; - let mut acceptor = TcpListener::bind(ip_str, port).listen(); + let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen(); spawn(proc() { let mut stream = TcpStream::connect("::1", addr.port); @@ -503,10 +503,10 @@ mod test { let addr = next_test_ip4(); let ip_str = addr.ip.to_str(); let port = addr.port; - let mut acceptor = TcpListener::bind(ip_str, port).listen(); + let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen(); spawn(proc() { - let mut stream = TcpStream::connect(ip_str, port); + let mut stream = TcpStream::connect(ip_str.as_slice(), port); stream.write([99]).unwrap(); }); @@ -520,10 +520,10 @@ mod test { let addr = next_test_ip6(); let ip_str = addr.ip.to_str(); let port = addr.port; - let mut acceptor = TcpListener::bind(ip_str, port).listen(); + let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen(); spawn(proc() { - let mut stream = TcpStream::connect(ip_str, port); + let mut stream = TcpStream::connect(ip_str.as_slice(), port); stream.write([99]).unwrap(); }); @@ -537,10 +537,10 @@ mod test { let addr = next_test_ip4(); let ip_str = addr.ip.to_str(); let port = addr.port; - let mut acceptor = TcpListener::bind(ip_str, port).listen(); + let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen(); spawn(proc() { - let _stream = TcpStream::connect(ip_str, port); + let _stream = TcpStream::connect(ip_str.as_slice(), port); // Close }); @@ -554,10 +554,10 @@ mod test { let addr = next_test_ip6(); let ip_str = addr.ip.to_str(); let port = addr.port; - let mut acceptor = TcpListener::bind(ip_str, port).listen(); + let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen(); spawn(proc() { - let _stream = TcpStream::connect(ip_str, port); + let _stream = TcpStream::connect(ip_str.as_slice(), port); // Close }); @@ -571,10 +571,10 @@ mod test { let addr = next_test_ip4(); let ip_str = addr.ip.to_str(); let port = addr.port; - let mut acceptor = TcpListener::bind(ip_str, port).listen(); + let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen(); spawn(proc() { - let _stream = TcpStream::connect(ip_str, port); + let _stream = TcpStream::connect(ip_str.as_slice(), port); // Close }); @@ -596,10 +596,10 @@ mod test { let addr = next_test_ip6(); let ip_str = addr.ip.to_str(); let port = addr.port; - let mut acceptor = TcpListener::bind(ip_str, port).listen(); + let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen(); spawn(proc() { - let _stream = TcpStream::connect(ip_str, port); + let _stream = TcpStream::connect(ip_str.as_slice(), port); // Close }); @@ -621,10 +621,10 @@ mod test { let addr = next_test_ip4(); let ip_str = addr.ip.to_str(); let port = addr.port; - let mut acceptor = TcpListener::bind(ip_str, port).listen(); + let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen(); spawn(proc() { - let _stream = TcpStream::connect(ip_str, port); + let _stream = TcpStream::connect(ip_str.as_slice(), port); // Close }); @@ -648,10 +648,10 @@ mod test { let addr = next_test_ip6(); let ip_str = addr.ip.to_str(); let port = addr.port; - let mut acceptor = TcpListener::bind(ip_str, port).listen(); + let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen(); spawn(proc() { - let _stream = TcpStream::connect(ip_str, port); + let _stream = TcpStream::connect(ip_str.as_slice(), port); // Close }); @@ -676,11 +676,11 @@ mod test { let ip_str = addr.ip.to_str(); let port = addr.port; let max = 10u; - let mut acceptor = TcpListener::bind(ip_str, port).listen(); + let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen(); spawn(proc() { for _ in range(0, max) { - let mut stream = TcpStream::connect(ip_str, port); + let mut stream = TcpStream::connect(ip_str.as_slice(), port); stream.write([99]).unwrap(); } }); @@ -697,11 +697,11 @@ mod test { let ip_str = addr.ip.to_str(); let port = addr.port; let max = 10u; - let mut acceptor = TcpListener::bind(ip_str, port).listen(); + let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen(); spawn(proc() { for _ in range(0, max) { - let mut stream = TcpStream::connect(ip_str, port); + let mut stream = TcpStream::connect(ip_str.as_slice(), port); stream.write([99]).unwrap(); } }); @@ -718,7 +718,7 @@ mod test { let ip_str = addr.ip.to_str(); let port = addr.port; static MAX: int = 10; - let acceptor = TcpListener::bind(ip_str, port).listen(); + let acceptor = TcpListener::bind(ip_str.as_slice(), port).listen(); spawn(proc() { let mut acceptor = acceptor; @@ -743,7 +743,7 @@ mod test { spawn(proc() { debug!("connecting"); - let mut stream = TcpStream::connect(ip_str, port); + let mut stream = TcpStream::connect(ip_str.as_slice(), port); // Connect again before writing connect(i + 1, addr); debug!("writing"); @@ -757,7 +757,7 @@ mod test { let ip_str = addr.ip.to_str(); let port = addr.port; static MAX: int = 10; - let acceptor = TcpListener::bind(ip_str, port).listen(); + let acceptor = TcpListener::bind(ip_str.as_slice(), port).listen(); spawn(proc() { let mut acceptor = acceptor; @@ -782,7 +782,7 @@ mod test { spawn(proc() { debug!("connecting"); - let mut stream = TcpStream::connect(ip_str, port); + let mut stream = TcpStream::connect(ip_str.as_slice(), port); // Connect again before writing connect(i + 1, addr); debug!("writing"); @@ -796,7 +796,7 @@ mod test { let addr = next_test_ip4(); let ip_str = addr.ip.to_str(); let port = addr.port; - let acceptor = TcpListener::bind(ip_str, port).listen(); + let acceptor = TcpListener::bind(ip_str.as_slice(), port).listen(); spawn(proc() { let mut acceptor = acceptor; @@ -821,7 +821,7 @@ mod test { spawn(proc() { debug!("connecting"); - let mut stream = TcpStream::connect(ip_str, port); + let mut stream = TcpStream::connect(ip_str.as_slice(), port); // Connect again before writing connect(i + 1, addr); debug!("writing"); @@ -835,7 +835,7 @@ mod test { let addr = next_test_ip6(); let ip_str = addr.ip.to_str(); let port = addr.port; - let acceptor = TcpListener::bind(ip_str, port).listen(); + let acceptor = TcpListener::bind(ip_str.as_slice(), port).listen(); spawn(proc() { let mut acceptor = acceptor; @@ -860,7 +860,7 @@ mod test { spawn(proc() { debug!("connecting"); - let mut stream = TcpStream::connect(ip_str, port); + let mut stream = TcpStream::connect(ip_str.as_slice(), port); // Connect again before writing connect(i + 1, addr); debug!("writing"); @@ -872,7 +872,7 @@ mod test { pub fn socket_name(addr: SocketAddr) { let ip_str = addr.ip.to_str(); let port = addr.port; - let mut listener = TcpListener::bind(ip_str, port).unwrap(); + let mut listener = TcpListener::bind(ip_str.as_slice(), port).unwrap(); // Make sure socket_name gives // us the socket we binded to. @@ -884,13 +884,13 @@ mod test { pub fn peer_name(addr: SocketAddr) { let ip_str = addr.ip.to_str(); let port = addr.port; - let acceptor = TcpListener::bind(ip_str, port).listen(); + let acceptor = TcpListener::bind(ip_str.as_slice(), port).listen(); spawn(proc() { let mut acceptor = acceptor; acceptor.accept().unwrap(); }); - let stream = TcpStream::connect(ip_str, port); + let stream = TcpStream::connect(ip_str.as_slice(), port); assert!(stream.is_ok()); let mut stream = stream.unwrap(); @@ -920,7 +920,7 @@ mod test { let (tx, rx) = channel(); spawn(proc() { let ip_str = addr.ip.to_str(); - let mut srv = TcpListener::bind(ip_str, port).listen().unwrap(); + let mut srv = TcpListener::bind(ip_str.as_slice(), port).listen().unwrap(); tx.send(()); let mut cl = srv.accept().unwrap(); cl.write([10]).unwrap(); @@ -931,7 +931,7 @@ mod test { rx.recv(); let ip_str = addr.ip.to_str(); - let mut c = TcpStream::connect(ip_str, port).unwrap(); + let mut c = TcpStream::connect(ip_str.as_slice(), port).unwrap(); let mut b = [0, ..10]; assert_eq!(c.read(b), Ok(1)); c.write([1]).unwrap(); @@ -942,9 +942,9 @@ mod test { let addr = next_test_ip4(); let ip_str = addr.ip.to_str(); let port = addr.port; - let listener = TcpListener::bind(ip_str, port).unwrap().listen(); + let listener = TcpListener::bind(ip_str.as_slice(), port).unwrap().listen(); assert!(listener.is_ok()); - match TcpListener::bind(ip_str, port).listen() { + match TcpListener::bind(ip_str.as_slice(), port).listen() { Ok(..) => fail!(), Err(e) => { assert!(e.kind == ConnectionRefused || e.kind == OtherIoError); @@ -960,14 +960,14 @@ mod test { spawn(proc() { let ip_str = addr.ip.to_str(); rx.recv(); - let _stream = TcpStream::connect(ip_str, port).unwrap(); + let _stream = TcpStream::connect(ip_str.as_slice(), port).unwrap(); // Close rx.recv(); }); { let ip_str = addr.ip.to_str(); - let mut acceptor = TcpListener::bind(ip_str, port).listen(); + let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen(); tx.send(()); { let _stream = acceptor.accept().unwrap(); @@ -976,17 +976,17 @@ mod test { } // Close listener } - let _listener = TcpListener::bind(addr.ip.to_str(), port); + let _listener = TcpListener::bind(addr.ip.to_str().as_slice(), port); }) iotest!(fn tcp_clone_smoke() { let addr = next_test_ip4(); let ip_str = addr.ip.to_str(); let port = addr.port; - let mut acceptor = TcpListener::bind(ip_str, port).listen(); + let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen(); spawn(proc() { - let mut s = TcpStream::connect(ip_str, port); + let mut s = TcpStream::connect(ip_str.as_slice(), port); let mut buf = [0, 0]; assert_eq!(s.read(buf), Ok(1)); assert_eq!(buf[0], 1); @@ -1014,12 +1014,12 @@ mod test { let addr = next_test_ip6(); let ip_str = addr.ip.to_str(); let port = addr.port; - let mut acceptor = TcpListener::bind(ip_str, port).listen(); + let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen(); let (tx1, rx) = channel(); let tx2 = tx1.clone(); spawn(proc() { - let mut s = TcpStream::connect(ip_str, port); + let mut s = TcpStream::connect(ip_str.as_slice(), port); s.write([1]).unwrap(); rx.recv(); s.write([2]).unwrap(); @@ -1048,10 +1048,10 @@ mod test { let addr = next_test_ip4(); let ip_str = addr.ip.to_str(); let port = addr.port; - let mut acceptor = TcpListener::bind(ip_str, port).listen(); + let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen(); spawn(proc() { - let mut s = TcpStream::connect(ip_str, port); + let mut s = TcpStream::connect(ip_str.as_slice(), port); let mut buf = [0, 1]; s.read(buf).unwrap(); s.read(buf).unwrap(); @@ -1077,7 +1077,7 @@ mod test { let addr = next_test_ip4(); let ip_str = addr.ip.to_str(); let port = addr.port; - let a = TcpListener::bind(ip_str, port).unwrap().listen(); + let a = TcpListener::bind(ip_str.as_slice(), port).unwrap().listen(); spawn(proc() { let mut a = a; let mut c = a.accept().unwrap(); @@ -1085,7 +1085,7 @@ mod test { c.write([1]).unwrap(); }); - let mut s = TcpStream::connect(ip_str, port).unwrap(); + let mut s = TcpStream::connect(ip_str.as_slice(), port).unwrap(); assert!(s.obj.close_write().is_ok()); assert!(s.write([1]).is_err()); assert_eq!(s.read_to_end(), Ok(vec!(1))); @@ -1095,7 +1095,7 @@ mod test { let addr = next_test_ip4(); let ip_str = addr.ip.to_str(); let port = addr.port; - let mut a = TcpListener::bind(ip_str, port).unwrap().listen().unwrap(); + let mut a = TcpListener::bind(ip_str.as_slice(), port).unwrap().listen().unwrap(); a.set_timeout(Some(10)); @@ -1114,7 +1114,8 @@ mod test { if !cfg!(target_os = "freebsd") { let (tx, rx) = channel(); spawn(proc() { - tx.send(TcpStream::connect(addr.ip.to_str(), port).unwrap()); + tx.send(TcpStream::connect(addr.ip.to_str().as_slice(), + port).unwrap()); }); let _l = rx.recv(); for i in range(0, 1001) { @@ -1131,7 +1132,8 @@ mod test { // Unset the timeout and make sure that this always blocks. a.set_timeout(None); spawn(proc() { - drop(TcpStream::connect(addr.ip.to_str(), port).unwrap()); + drop(TcpStream::connect(addr.ip.to_str().as_slice(), + port).unwrap()); }); a.accept().unwrap(); }) @@ -1140,7 +1142,7 @@ mod test { let addr = next_test_ip4(); let ip_str = addr.ip.to_str(); let port = addr.port; - let a = TcpListener::bind(ip_str, port).listen().unwrap(); + let a = TcpListener::bind(ip_str.as_slice(), port).listen().unwrap(); let (_tx, rx) = channel::<()>(); spawn(proc() { let mut a = a; @@ -1149,7 +1151,7 @@ mod test { }); let mut b = [0]; - let mut s = TcpStream::connect(ip_str, port).unwrap(); + let mut s = TcpStream::connect(ip_str.as_slice(), port).unwrap(); let mut s2 = s.clone(); // closing should prevent reads/writes @@ -1178,7 +1180,7 @@ mod test { let addr = next_test_ip4(); let ip_str = addr.ip.to_str(); let port = addr.port; - let a = TcpListener::bind(ip_str, port).listen().unwrap(); + let a = TcpListener::bind(ip_str.as_slice(), port).listen().unwrap(); let (_tx, rx) = channel::<()>(); spawn(proc() { let mut a = a; @@ -1186,7 +1188,7 @@ mod test { let _ = rx.recv_opt(); }); - let mut s = TcpStream::connect(ip_str, port).unwrap(); + let mut s = TcpStream::connect(ip_str.as_slice(), port).unwrap(); let s2 = s.clone(); let (tx, rx) = channel(); spawn(proc() { @@ -1205,10 +1207,10 @@ mod test { let addr = next_test_ip6(); let ip_str = addr.ip.to_str(); let port = addr.port; - let mut a = TcpListener::bind(ip_str, port).listen().unwrap(); + let mut a = TcpListener::bind(ip_str.as_slice(), port).listen().unwrap(); let (tx, rx) = channel::<()>(); spawn(proc() { - let mut s = TcpStream::connect(ip_str, port).unwrap(); + let mut s = TcpStream::connect(ip_str.as_slice(), port).unwrap(); rx.recv(); assert!(s.write([0]).is_ok()); let _ = rx.recv_opt(); @@ -1239,10 +1241,10 @@ mod test { let addr = next_test_ip6(); let ip_str = addr.ip.to_str(); let port = addr.port; - let mut a = TcpListener::bind(ip_str, port).listen().unwrap(); + let mut a = TcpListener::bind(ip_str.as_slice(), port).listen().unwrap(); let (tx, rx) = channel::<()>(); spawn(proc() { - let mut s = TcpStream::connect(ip_str, port).unwrap(); + let mut s = TcpStream::connect(ip_str.as_slice(), port).unwrap(); rx.recv(); let mut amt = 0; while amt < 100 * 128 * 1024 { @@ -1269,10 +1271,10 @@ mod test { let addr = next_test_ip6(); let ip_str = addr.ip.to_str(); let port = addr.port; - let mut a = TcpListener::bind(ip_str, port).listen().unwrap(); + let mut a = TcpListener::bind(ip_str.as_slice(), port).listen().unwrap(); let (tx, rx) = channel::<()>(); spawn(proc() { - let mut s = TcpStream::connect(ip_str, port).unwrap(); + let mut s = TcpStream::connect(ip_str.as_slice(), port).unwrap(); rx.recv(); assert!(s.write([0]).is_ok()); let _ = rx.recv_opt(); @@ -1298,10 +1300,10 @@ mod test { let addr = next_test_ip6(); let ip_str = addr.ip.to_str(); let port = addr.port; - let mut a = TcpListener::bind(ip_str, port).listen().unwrap(); + let mut a = TcpListener::bind(ip_str.as_slice(), port).listen().unwrap(); let (tx, rx) = channel::<()>(); spawn(proc() { - let mut s = TcpStream::connect(ip_str, port).unwrap(); + let mut s = TcpStream::connect(ip_str.as_slice(), port).unwrap(); rx.recv(); assert_eq!(s.write([0]), Ok(())); let _ = rx.recv_opt(); diff --git a/src/libstd/io/process.rs b/src/libstd/io/process.rs index fc760e6fe4ca3..7d84530282ff3 100644 --- a/src/libstd/io/process.rs +++ b/src/libstd/io/process.rs @@ -583,11 +583,11 @@ mod tests { } }) - pub fn read_all(input: &mut Reader) -> ~str { + pub fn read_all(input: &mut Reader) -> StrBuf { input.read_to_str().unwrap() } - pub fn run_output(cmd: Command) -> ~str { + pub fn run_output(cmd: Command) -> StrBuf { let p = cmd.spawn(); assert!(p.is_ok()); let mut p = p.unwrap(); @@ -601,7 +601,7 @@ mod tests { iotest!(fn stdout_works() { let mut cmd = Command::new("echo"); cmd.arg("foobar").stdout(CreatePipe(false, true)); - assert_eq!(run_output(cmd), "foobar\n".to_owned()); + assert_eq!(run_output(cmd), "foobar\n".to_strbuf()); }) #[cfg(unix, not(target_os="android"))] @@ -610,7 +610,7 @@ mod tests { cmd.arg("-c").arg("pwd") .cwd(&Path::new("/")) .stdout(CreatePipe(false, true)); - assert_eq!(run_output(cmd), "/\n".to_owned()); + assert_eq!(run_output(cmd), "/\n".to_strbuf()); }) #[cfg(unix, not(target_os="android"))] @@ -624,7 +624,7 @@ mod tests { drop(p.stdin.take()); let out = read_all(p.stdout.get_mut_ref() as &mut Reader); assert!(p.wait().unwrap().success()); - assert_eq!(out, "foobar\n".to_owned()); + assert_eq!(out, "foobar\n".to_strbuf()); }) #[cfg(not(target_os="android"))] @@ -682,7 +682,7 @@ mod tests { let output_str = str::from_utf8(output.as_slice()).unwrap(); assert!(status.success()); - assert_eq!(output_str.trim().to_owned(), "hello".to_owned()); + assert_eq!(output_str.trim().to_strbuf(), "hello".to_strbuf()); // FIXME #7224 if !running_on_valgrind() { assert_eq!(error, Vec::new()); @@ -719,7 +719,7 @@ mod tests { let output_str = str::from_utf8(output.as_slice()).unwrap(); assert!(status.success()); - assert_eq!(output_str.trim().to_owned(), "hello".to_owned()); + assert_eq!(output_str.trim().to_strbuf(), "hello".to_strbuf()); // FIXME #7224 if !running_on_valgrind() { assert_eq!(error, Vec::new()); @@ -749,9 +749,9 @@ mod tests { let prog = pwd_cmd().spawn().unwrap(); let output = str::from_utf8(prog.wait_with_output().unwrap() - .output.as_slice()).unwrap().to_owned(); + .output.as_slice()).unwrap().to_strbuf(); let parent_dir = os::getcwd(); - let child_dir = Path::new(output.trim()); + let child_dir = Path::new(output.as_slice().trim()); let parent_stat = parent_dir.stat().unwrap(); let child_stat = child_dir.stat().unwrap(); @@ -768,8 +768,8 @@ mod tests { let prog = pwd_cmd().cwd(&parent_dir).spawn().unwrap(); let output = str::from_utf8(prog.wait_with_output().unwrap() - .output.as_slice()).unwrap().to_owned(); - let child_dir = Path::new(output.trim()); + .output.as_slice()).unwrap().to_strbuf(); + let child_dir = Path::new(output.as_slice().trim().into_strbuf()); let parent_stat = parent_dir.stat().unwrap(); let child_stat = child_dir.stat().unwrap(); @@ -803,12 +803,14 @@ mod tests { let prog = env_cmd().spawn().unwrap(); let output = str::from_utf8(prog.wait_with_output().unwrap() - .output.as_slice()).unwrap().to_owned(); + .output.as_slice()).unwrap().to_strbuf(); let r = os::env(); for &(ref k, ref v) in r.iter() { // don't check windows magical empty-named variables - assert!(k.is_empty() || output.contains(format!("{}={}", *k, *v))); + assert!(k.is_empty() || + output.as_slice() + .contains(format!("{}={}", *k, *v).as_slice())); } }) #[cfg(target_os="android")] @@ -819,14 +821,20 @@ mod tests { let mut prog = env_cmd().spawn().unwrap(); let output = str::from_utf8(prog.wait_with_output() .unwrap().output.as_slice()) - .unwrap().to_owned(); + .unwrap().to_strbuf(); let r = os::env(); for &(ref k, ref v) in r.iter() { // don't check android RANDOM variables - if *k != "RANDOM".to_owned() { - assert!(output.contains(format!("{}={}", *k, *v)) || - output.contains(format!("{}=\'{}\'", *k, *v))); + if *k != "RANDOM".to_strbuf() { + assert!(output.as_slice() + .contains(format!("{}={}", + *k, + *v).as_slice()) || + output.as_slice() + .contains(format!("{}=\'{}\'", + *k, + *v).as_slice())); } } }) @@ -835,9 +843,9 @@ mod tests { let new_env = box [("RUN_TEST_NEW_ENV", "123")]; let prog = env_cmd().env(new_env).spawn().unwrap(); let result = prog.wait_with_output().unwrap(); - let output = str::from_utf8_lossy(result.output.as_slice()).into_owned(); + let output = str::from_utf8_lossy(result.output.as_slice()).into_strbuf(); - assert!(output.contains("RUN_TEST_NEW_ENV=123"), + assert!(output.as_slice().contains("RUN_TEST_NEW_ENV=123"), "didn't find RUN_TEST_NEW_ENV inside of:\n\n{}", output); }) diff --git a/src/libstd/io/stdio.rs b/src/libstd/io/stdio.rs index 991f3992dd1bd..3a103651d635f 100644 --- a/src/libstd/io/stdio.rs +++ b/src/libstd/io/stdio.rs @@ -409,7 +409,7 @@ mod tests { set_stdout(box w); println!("hello!"); }); - assert_eq!(r.read_to_str().unwrap(), "hello!\n".to_owned()); + assert_eq!(r.read_to_str().unwrap(), "hello!\n".to_strbuf()); }) iotest!(fn capture_stderr() { @@ -422,6 +422,6 @@ mod tests { fail!("my special message"); }); let s = r.read_to_str().unwrap(); - assert!(s.contains("my special message")); + assert!(s.as_slice().contains("my special message")); }) } diff --git a/src/libstd/io/tempfile.rs b/src/libstd/io/tempfile.rs index b4fb95c8af770..806df838c919e 100644 --- a/src/libstd/io/tempfile.rs +++ b/src/libstd/io/tempfile.rs @@ -42,10 +42,11 @@ impl TempDir { static mut CNT: atomics::AtomicUint = atomics::INIT_ATOMIC_UINT; for _ in range(0u, 1000) { - let filename = format!("rs-{}-{}-{}", - unsafe { libc::getpid() }, - unsafe { CNT.fetch_add(1, atomics::SeqCst) }, - suffix); + let filename = + format_strbuf!("rs-{}-{}-{}", + unsafe { libc::getpid() }, + unsafe { CNT.fetch_add(1, atomics::SeqCst) }, + suffix); let p = tmpdir.join(filename); match fs::mkdir(&p, io::UserRWX) { Err(..) => {} diff --git a/src/libstd/io/test.rs b/src/libstd/io/test.rs index dd874fecc52a5..de8a6f4beb5ea 100644 --- a/src/libstd/io/test.rs +++ b/src/libstd/io/test.rs @@ -67,14 +67,14 @@ pub fn next_test_unix() -> Path { // base port and pid are an attempt to be unique between multiple // test-runners of different configurations running on one // buildbot, the count is to be unique within this executable. - let string = format!("rust-test-unix-path-{}-{}-{}", - base_port(), - unsafe {libc::getpid()}, - unsafe {COUNT.fetch_add(1, Relaxed)}); + let string = format_strbuf!("rust-test-unix-path-{}-{}-{}", + base_port(), + unsafe {libc::getpid()}, + unsafe {COUNT.fetch_add(1, Relaxed)}); if cfg!(unix) { os::tmpdir().join(string) } else { - Path::new(r"\\.\pipe\" + string) + Path::new(format_strbuf!("{}{}", r"\\.\pipe\", string)) } } diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs index a9ec9c1ddc5ac..22ac397c702c3 100644 --- a/src/libstd/lib.rs +++ b/src/libstd/lib.rs @@ -47,9 +47,9 @@ //! for which the [`slice`](slice/index.html) module defines many //! methods. //! -//! UTF-8 strings, `~str` and `&str`, are built-in types, and the -//! standard library defines methods for them on a variety of traits -//! in the [`str`](str/index.html) module. Rust strings are immutable; +//! `&str`, a UTF-8 string, is a built-in type, and the standard library +//! defines methods for it on a variety of traits in the +//! [`str`](str/index.html) module. Rust strings are immutable; //! use the `StrBuf` type defined in [`strbuf`](strbuf/index.html) //! for a mutable string builder. //! @@ -284,4 +284,5 @@ mod std { // The test runner requires std::slice::Vector, so re-export std::slice just for it. #[cfg(test)] pub use slice; + #[cfg(test)] pub use strbuf; } diff --git a/src/libstd/local_data.rs b/src/libstd/local_data.rs index 1a971594837df..8798c035fcaf1 100644 --- a/src/libstd/local_data.rs +++ b/src/libstd/local_data.rs @@ -274,12 +274,12 @@ mod tests { #[test] fn test_tls_multitask() { - static my_key: Key<~str> = &Key; - my_key.replace(Some("parent data".to_owned())); + static my_key: Key = &Key; + my_key.replace(Some("parent data".to_strbuf())); task::spawn(proc() { // TLS shouldn't carry over. assert!(my_key.get().is_none()); - my_key.replace(Some("child data".to_owned())); + my_key.replace(Some("child data".to_strbuf())); assert!(my_key.get().get_ref().as_slice() == "child data"); // should be cleaned up for us }); @@ -292,17 +292,17 @@ mod tests { #[test] fn test_tls_overwrite() { - static my_key: Key<~str> = &Key; - my_key.replace(Some("first data".to_owned())); - my_key.replace(Some("next data".to_owned())); // Shouldn't leak. + static my_key: Key = &Key; + my_key.replace(Some("first data".to_strbuf())); + my_key.replace(Some("next data".to_strbuf())); // Shouldn't leak. assert!(my_key.get().unwrap().as_slice() == "next data"); } #[test] fn test_tls_pop() { - static my_key: Key<~str> = &Key; - my_key.replace(Some("weasel".to_owned())); - assert!(my_key.replace(None).unwrap() == "weasel".to_owned()); + static my_key: Key = &Key; + my_key.replace(Some("weasel".to_strbuf())); + assert!(my_key.replace(None).unwrap() == "weasel".to_strbuf()); // Pop must remove the data from the map. assert!(my_key.replace(None).is_none()); } @@ -315,19 +315,19 @@ mod tests { // to get recorded as something within a rust stack segment. Then a // subsequent upcall (esp. for logging, think vsnprintf) would run on // a stack smaller than 1 MB. - static my_key: Key<~str> = &Key; + static my_key: Key = &Key; task::spawn(proc() { - my_key.replace(Some("hax".to_owned())); + my_key.replace(Some("hax".to_strbuf())); }); } #[test] fn test_tls_multiple_types() { - static str_key: Key<~str> = &Key; + static str_key: Key = &Key; static box_key: Key<@()> = &Key; static int_key: Key = &Key; task::spawn(proc() { - str_key.replace(Some("string data".to_owned())); + str_key.replace(Some("string data".to_strbuf())); box_key.replace(Some(@())); int_key.replace(Some(42)); }); @@ -335,12 +335,12 @@ mod tests { #[test] fn test_tls_overwrite_multiple_types() { - static str_key: Key<~str> = &Key; + static str_key: Key = &Key; static box_key: Key<@()> = &Key; static int_key: Key = &Key; task::spawn(proc() { - str_key.replace(Some("string data".to_owned())); - str_key.replace(Some("string data 2".to_owned())); + str_key.replace(Some("string data".to_strbuf())); + str_key.replace(Some("string data 2".to_strbuf())); box_key.replace(Some(@())); box_key.replace(Some(@())); int_key.replace(Some(42)); @@ -354,13 +354,13 @@ mod tests { #[test] #[should_fail] fn test_tls_cleanup_on_failure() { - static str_key: Key<~str> = &Key; + static str_key: Key = &Key; static box_key: Key<@()> = &Key; static int_key: Key = &Key; - str_key.replace(Some("parent data".to_owned())); + str_key.replace(Some("parent data".to_strbuf())); box_key.replace(Some(@())); task::spawn(proc() { - str_key.replace(Some("string data".to_owned())); + str_key.replace(Some("string data".to_strbuf())); box_key.replace(Some(@())); int_key.replace(Some(42)); fail!(); diff --git a/src/libstd/num/f32.rs b/src/libstd/num/f32.rs index e9ea0df2a7b9e..66d93c230a57c 100644 --- a/src/libstd/num/f32.rs +++ b/src/libstd/num/f32.rs @@ -20,6 +20,7 @@ use intrinsics; use libc::c_int; use num::strconv; use num; +use strbuf::StrBuf; pub use core::f32::{RADIX, MANTISSA_DIGITS, DIGITS, EPSILON, MIN_VALUE}; pub use core::f32::{MIN_POS_VALUE, MAX_VALUE, MIN_EXP, MAX_EXP, MIN_10_EXP}; @@ -242,7 +243,7 @@ impl FloatMath for f32 { /// /// * num - The float value #[inline] -pub fn to_str(num: f32) -> ~str { +pub fn to_str(num: f32) -> StrBuf { let (r, _) = strconv::float_to_str_common( num, 10u, true, strconv::SignNeg, strconv::DigAll, strconv::ExpNone, false); r @@ -254,7 +255,7 @@ pub fn to_str(num: f32) -> ~str { /// /// * num - The float value #[inline] -pub fn to_str_hex(num: f32) -> ~str { +pub fn to_str_hex(num: f32) -> StrBuf { let (r, _) = strconv::float_to_str_common( num, 16u, true, strconv::SignNeg, strconv::DigAll, strconv::ExpNone, false); r @@ -268,7 +269,7 @@ pub fn to_str_hex(num: f32) -> ~str { /// * num - The float value /// * radix - The base to use #[inline] -pub fn to_str_radix_special(num: f32, rdx: uint) -> (~str, bool) { +pub fn to_str_radix_special(num: f32, rdx: uint) -> (StrBuf, bool) { strconv::float_to_str_common(num, rdx, true, strconv::SignNeg, strconv::DigAll, strconv::ExpNone, false) } @@ -281,7 +282,7 @@ pub fn to_str_radix_special(num: f32, rdx: uint) -> (~str, bool) { /// * num - The float value /// * digits - The number of significant digits #[inline] -pub fn to_str_exact(num: f32, dig: uint) -> ~str { +pub fn to_str_exact(num: f32, dig: uint) -> StrBuf { let (r, _) = strconv::float_to_str_common( num, 10u, true, strconv::SignNeg, strconv::DigExact(dig), strconv::ExpNone, false); r @@ -295,7 +296,7 @@ pub fn to_str_exact(num: f32, dig: uint) -> ~str { /// * num - The float value /// * digits - The number of significant digits #[inline] -pub fn to_str_digits(num: f32, dig: uint) -> ~str { +pub fn to_str_digits(num: f32, dig: uint) -> StrBuf { let (r, _) = strconv::float_to_str_common( num, 10u, true, strconv::SignNeg, strconv::DigMax(dig), strconv::ExpNone, false); r @@ -310,7 +311,7 @@ pub fn to_str_digits(num: f32, dig: uint) -> ~str { /// * digits - The number of digits after the decimal point /// * upper - Use `E` instead of `e` for the exponent sign #[inline] -pub fn to_str_exp_exact(num: f32, dig: uint, upper: bool) -> ~str { +pub fn to_str_exp_exact(num: f32, dig: uint, upper: bool) -> StrBuf { let (r, _) = strconv::float_to_str_common( num, 10u, true, strconv::SignNeg, strconv::DigExact(dig), strconv::ExpDec, upper); r @@ -325,7 +326,7 @@ pub fn to_str_exp_exact(num: f32, dig: uint, upper: bool) -> ~str { /// * digits - The number of digits after the decimal point /// * upper - Use `E` instead of `e` for the exponent sign #[inline] -pub fn to_str_exp_digits(num: f32, dig: uint, upper: bool) -> ~str { +pub fn to_str_exp_digits(num: f32, dig: uint, upper: bool) -> StrBuf { let (r, _) = strconv::float_to_str_common( num, 10u, true, strconv::SignNeg, strconv::DigMax(dig), strconv::ExpDec, upper); r @@ -345,7 +346,7 @@ impl num::ToStrRadix for f32 { /// possible misinterpretation of the result at higher bases. If those values /// are expected, use `to_str_radix_special()` instead. #[inline] - fn to_str_radix(&self, rdx: uint) -> ~str { + fn to_str_radix(&self, rdx: uint) -> StrBuf { let (r, special) = strconv::float_to_str_common( *self, rdx, true, strconv::SignNeg, strconv::DigAll, strconv::ExpNone, false); if special { fail!("number has a special value, \ diff --git a/src/libstd/num/f64.rs b/src/libstd/num/f64.rs index 869a275b1d408..be4e4dc0d66f6 100644 --- a/src/libstd/num/f64.rs +++ b/src/libstd/num/f64.rs @@ -19,6 +19,7 @@ use intrinsics; use libc::c_int; use num::strconv; use num; +use strbuf::StrBuf; pub use core::f64::{RADIX, MANTISSA_DIGITS, DIGITS, EPSILON, MIN_VALUE}; pub use core::f64::{MIN_POS_VALUE, MAX_VALUE, MIN_EXP, MAX_EXP, MIN_10_EXP}; @@ -250,7 +251,7 @@ impl FloatMath for f64 { /// /// * num - The float value #[inline] -pub fn to_str(num: f64) -> ~str { +pub fn to_str(num: f64) -> StrBuf { let (r, _) = strconv::float_to_str_common( num, 10u, true, strconv::SignNeg, strconv::DigAll, strconv::ExpNone, false); r @@ -262,7 +263,7 @@ pub fn to_str(num: f64) -> ~str { /// /// * num - The float value #[inline] -pub fn to_str_hex(num: f64) -> ~str { +pub fn to_str_hex(num: f64) -> StrBuf { let (r, _) = strconv::float_to_str_common( num, 16u, true, strconv::SignNeg, strconv::DigAll, strconv::ExpNone, false); r @@ -276,7 +277,7 @@ pub fn to_str_hex(num: f64) -> ~str { /// * num - The float value /// * radix - The base to use #[inline] -pub fn to_str_radix_special(num: f64, rdx: uint) -> (~str, bool) { +pub fn to_str_radix_special(num: f64, rdx: uint) -> (StrBuf, bool) { strconv::float_to_str_common(num, rdx, true, strconv::SignNeg, strconv::DigAll, strconv::ExpNone, false) } @@ -289,7 +290,7 @@ pub fn to_str_radix_special(num: f64, rdx: uint) -> (~str, bool) { /// * num - The float value /// * digits - The number of significant digits #[inline] -pub fn to_str_exact(num: f64, dig: uint) -> ~str { +pub fn to_str_exact(num: f64, dig: uint) -> StrBuf { let (r, _) = strconv::float_to_str_common( num, 10u, true, strconv::SignNeg, strconv::DigExact(dig), strconv::ExpNone, false); r @@ -303,7 +304,7 @@ pub fn to_str_exact(num: f64, dig: uint) -> ~str { /// * num - The float value /// * digits - The number of significant digits #[inline] -pub fn to_str_digits(num: f64, dig: uint) -> ~str { +pub fn to_str_digits(num: f64, dig: uint) -> StrBuf { let (r, _) = strconv::float_to_str_common( num, 10u, true, strconv::SignNeg, strconv::DigMax(dig), strconv::ExpNone, false); r @@ -318,7 +319,7 @@ pub fn to_str_digits(num: f64, dig: uint) -> ~str { /// * digits - The number of digits after the decimal point /// * upper - Use `E` instead of `e` for the exponent sign #[inline] -pub fn to_str_exp_exact(num: f64, dig: uint, upper: bool) -> ~str { +pub fn to_str_exp_exact(num: f64, dig: uint, upper: bool) -> StrBuf { let (r, _) = strconv::float_to_str_common( num, 10u, true, strconv::SignNeg, strconv::DigExact(dig), strconv::ExpDec, upper); r @@ -333,7 +334,7 @@ pub fn to_str_exp_exact(num: f64, dig: uint, upper: bool) -> ~str { /// * digits - The number of digits after the decimal point /// * upper - Use `E` instead of `e` for the exponent sign #[inline] -pub fn to_str_exp_digits(num: f64, dig: uint, upper: bool) -> ~str { +pub fn to_str_exp_digits(num: f64, dig: uint, upper: bool) -> StrBuf { let (r, _) = strconv::float_to_str_common( num, 10u, true, strconv::SignNeg, strconv::DigMax(dig), strconv::ExpDec, upper); r @@ -353,7 +354,7 @@ impl num::ToStrRadix for f64 { /// possible misinterpretation of the result at higher bases. If those values /// are expected, use `to_str_radix_special()` instead. #[inline] - fn to_str_radix(&self, rdx: uint) -> ~str { + fn to_str_radix(&self, rdx: uint) -> StrBuf { let (r, special) = strconv::float_to_str_common( *self, rdx, true, strconv::SignNeg, strconv::DigAll, strconv::ExpNone, false); if special { fail!("number has a special value, \ diff --git a/src/libstd/num/i16.rs b/src/libstd/num/i16.rs index 396037d0dbace..7d08c181e9e39 100644 --- a/src/libstd/num/i16.rs +++ b/src/libstd/num/i16.rs @@ -15,6 +15,7 @@ use num::{ToStrRadix, FromStrRadix}; use num::strconv; use option::Option; use slice::ImmutableVector; +use strbuf::StrBuf; pub use core::i16::{BITS, BYTES, MIN, MAX}; diff --git a/src/libstd/num/i32.rs b/src/libstd/num/i32.rs index 5640e82d077dc..2504d3f576627 100644 --- a/src/libstd/num/i32.rs +++ b/src/libstd/num/i32.rs @@ -15,6 +15,7 @@ use num::{ToStrRadix, FromStrRadix}; use num::strconv; use option::Option; use slice::ImmutableVector; +use strbuf::StrBuf; pub use core::i32::{BITS, BYTES, MIN, MAX}; diff --git a/src/libstd/num/i64.rs b/src/libstd/num/i64.rs index 40245691e3456..7fc6a091dfcf1 100644 --- a/src/libstd/num/i64.rs +++ b/src/libstd/num/i64.rs @@ -15,6 +15,7 @@ use num::{ToStrRadix, FromStrRadix}; use num::strconv; use option::Option; use slice::ImmutableVector; +use strbuf::StrBuf; pub use core::i64::{BITS, BYTES, MIN, MAX}; diff --git a/src/libstd/num/i8.rs b/src/libstd/num/i8.rs index 7ddddd893e211..a39a6ced07742 100644 --- a/src/libstd/num/i8.rs +++ b/src/libstd/num/i8.rs @@ -15,6 +15,7 @@ use num::{ToStrRadix, FromStrRadix}; use num::strconv; use option::Option; use slice::ImmutableVector; +use strbuf::StrBuf; pub use core::i8::{BITS, BYTES, MIN, MAX}; diff --git a/src/libstd/num/int.rs b/src/libstd/num/int.rs index dc4d80601b7db..2a23a35be6d6a 100644 --- a/src/libstd/num/int.rs +++ b/src/libstd/num/int.rs @@ -15,6 +15,7 @@ use num::{ToStrRadix, FromStrRadix}; use num::strconv; use option::Option; use slice::ImmutableVector; +use strbuf::StrBuf; pub use core::int::{BITS, BYTES, MIN, MAX}; diff --git a/src/libstd/num/int_macros.rs b/src/libstd/num/int_macros.rs index ddff42f68dba9..31a0edfbc389c 100644 --- a/src/libstd/num/int_macros.rs +++ b/src/libstd/num/int_macros.rs @@ -77,8 +77,8 @@ pub fn to_str_bytes(n: $T, radix: uint, f: |v: &[u8]| -> U) -> U { impl ToStrRadix for $T { /// Convert to a string in a given base. #[inline] - fn to_str_radix(&self, radix: uint) -> ~str { - format!("{}", ::fmt::radix(*self, radix as u8)) + fn to_str_radix(&self, radix: uint) -> StrBuf { + format_strbuf!("{}", ::fmt::radix(*self, radix as u8)) } } @@ -136,39 +136,39 @@ mod tests { #[test] fn test_to_str() { - assert_eq!((0 as $T).to_str_radix(10u), "0".to_owned()); - assert_eq!((1 as $T).to_str_radix(10u), "1".to_owned()); - assert_eq!((-1 as $T).to_str_radix(10u), "-1".to_owned()); - assert_eq!((127 as $T).to_str_radix(16u), "7f".to_owned()); - assert_eq!((100 as $T).to_str_radix(10u), "100".to_owned()); + assert_eq!((0 as $T).to_str_radix(10u), "0".to_strbuf()); + assert_eq!((1 as $T).to_str_radix(10u), "1".to_strbuf()); + assert_eq!((-1 as $T).to_str_radix(10u), "-1".to_strbuf()); + assert_eq!((127 as $T).to_str_radix(16u), "7f".to_strbuf()); + assert_eq!((100 as $T).to_str_radix(10u), "100".to_strbuf()); } #[test] fn test_int_to_str_overflow() { let mut i8_val: i8 = 127_i8; - assert_eq!(i8_val.to_str(), "127".to_owned()); + assert_eq!(i8_val.to_str(), "127".to_strbuf()); i8_val += 1 as i8; - assert_eq!(i8_val.to_str(), "-128".to_owned()); + assert_eq!(i8_val.to_str(), "-128".to_strbuf()); let mut i16_val: i16 = 32_767_i16; - assert_eq!(i16_val.to_str(), "32767".to_owned()); + assert_eq!(i16_val.to_str(), "32767".to_strbuf()); i16_val += 1 as i16; - assert_eq!(i16_val.to_str(), "-32768".to_owned()); + assert_eq!(i16_val.to_str(), "-32768".to_strbuf()); let mut i32_val: i32 = 2_147_483_647_i32; - assert_eq!(i32_val.to_str(), "2147483647".to_owned()); + assert_eq!(i32_val.to_str(), "2147483647".to_strbuf()); i32_val += 1 as i32; - assert_eq!(i32_val.to_str(), "-2147483648".to_owned()); + assert_eq!(i32_val.to_str(), "-2147483648".to_strbuf()); let mut i64_val: i64 = 9_223_372_036_854_775_807_i64; - assert_eq!(i64_val.to_str(), "9223372036854775807".to_owned()); + assert_eq!(i64_val.to_str(), "9223372036854775807".to_strbuf()); i64_val += 1 as i64; - assert_eq!(i64_val.to_str(), "-9223372036854775808".to_owned()); + assert_eq!(i64_val.to_str(), "-9223372036854775808".to_strbuf()); } #[test] diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs index 40167718236ef..c1d6bbb492db8 100644 --- a/src/libstd/num/mod.rs +++ b/src/libstd/num/mod.rs @@ -15,7 +15,8 @@ #![allow(missing_doc)] -use option::{Option}; +use option::Option; +use strbuf::StrBuf; #[cfg(test)] use fmt::Show; @@ -111,7 +112,7 @@ pub trait FloatMath: Float { /// A generic trait for converting a value to a string with a radix (base) pub trait ToStrRadix { - fn to_str_radix(&self, radix: uint) -> ~str; + fn to_str_radix(&self, radix: uint) -> StrBuf; } /// A generic trait for converting a string with a radix (base) to a value diff --git a/src/libstd/num/strconv.rs b/src/libstd/num/strconv.rs index e58872b8395a6..795534dc28372 100644 --- a/src/libstd/num/strconv.rs +++ b/src/libstd/num/strconv.rs @@ -19,9 +19,9 @@ use num::{Float, FPNaN, FPInfinite, ToPrimitive}; use num; use ops::{Add, Sub, Mul, Div, Rem, Neg}; use option::{None, Option, Some}; -use slice::{CloneableVector, ImmutableVector, MutableVector}; +use slice::{ImmutableVector, MutableVector}; use std::cmp::{Ord, Eq}; -use str::{StrAllocating, StrSlice}; +use str::StrSlice; use strbuf::StrBuf; use vec::Vec; @@ -496,10 +496,10 @@ pub fn float_to_str_common+Neg+Rem+Mul>( num: T, radix: uint, negative_zero: bool, sign: SignFormat, digits: SignificantDigits, exp_format: ExponentFormat, exp_capital: bool - ) -> (~str, bool) { + ) -> (StrBuf, bool) { let (bytes, special) = float_to_str_bytes_common(num, radix, negative_zero, sign, digits, exp_format, exp_capital); - (StrBuf::from_utf8(bytes).unwrap().into_owned(), special) + (StrBuf::from_utf8(bytes).unwrap(), special) } // Some constants for from_str_bytes_common's input validation, diff --git a/src/libstd/num/u16.rs b/src/libstd/num/u16.rs index 65ac46af5aa0c..6d68af9989094 100644 --- a/src/libstd/num/u16.rs +++ b/src/libstd/num/u16.rs @@ -15,6 +15,7 @@ use num::{ToStrRadix, FromStrRadix}; use num::strconv; use option::Option; use slice::ImmutableVector; +use strbuf::StrBuf; pub use core::u16::{BITS, BYTES, MIN, MAX}; diff --git a/src/libstd/num/u32.rs b/src/libstd/num/u32.rs index d549e4d0d6362..130ca2c48557e 100644 --- a/src/libstd/num/u32.rs +++ b/src/libstd/num/u32.rs @@ -15,6 +15,7 @@ use num::{ToStrRadix, FromStrRadix}; use num::strconv; use option::Option; use slice::ImmutableVector; +use strbuf::StrBuf; pub use core::u32::{BITS, BYTES, MIN, MAX}; diff --git a/src/libstd/num/u64.rs b/src/libstd/num/u64.rs index 3773e56f4d16d..559fcf6e7d163 100644 --- a/src/libstd/num/u64.rs +++ b/src/libstd/num/u64.rs @@ -15,6 +15,7 @@ use num::{ToStrRadix, FromStrRadix}; use num::strconv; use option::Option; use slice::ImmutableVector; +use strbuf::StrBuf; pub use core::u64::{BITS, BYTES, MIN, MAX}; diff --git a/src/libstd/num/u8.rs b/src/libstd/num/u8.rs index 372e38d66521f..f855c8c495111 100644 --- a/src/libstd/num/u8.rs +++ b/src/libstd/num/u8.rs @@ -15,6 +15,7 @@ use num::{ToStrRadix, FromStrRadix}; use num::strconv; use option::Option; use slice::ImmutableVector; +use strbuf::StrBuf; pub use core::u8::{BITS, BYTES, MIN, MAX}; diff --git a/src/libstd/num/uint.rs b/src/libstd/num/uint.rs index c419276fa2451..f651cf72ccaf1 100644 --- a/src/libstd/num/uint.rs +++ b/src/libstd/num/uint.rs @@ -15,6 +15,7 @@ use num::{ToStrRadix, FromStrRadix}; use num::strconv; use option::Option; use slice::ImmutableVector; +use strbuf::StrBuf; pub use core::uint::{BITS, BYTES, MIN, MAX}; diff --git a/src/libstd/num/uint_macros.rs b/src/libstd/num/uint_macros.rs index 7977c64760677..ba329065a6eaa 100644 --- a/src/libstd/num/uint_macros.rs +++ b/src/libstd/num/uint_macros.rs @@ -78,8 +78,8 @@ pub fn to_str_bytes(n: $T, radix: uint, f: |v: &[u8]| -> U) -> U { impl ToStrRadix for $T { /// Convert to a string in a given base. #[inline] - fn to_str_radix(&self, radix: uint) -> ~str { - format!("{}", ::fmt::radix(*self, radix as u8)) + fn to_str_radix(&self, radix: uint) -> StrBuf { + format_strbuf!("{}", ::fmt::radix(*self, radix as u8)) } } @@ -94,13 +94,13 @@ mod tests { #[test] pub fn test_to_str() { - assert_eq!((0 as $T).to_str_radix(10u), "0".to_owned()); - assert_eq!((1 as $T).to_str_radix(10u), "1".to_owned()); - assert_eq!((2 as $T).to_str_radix(10u), "2".to_owned()); - assert_eq!((11 as $T).to_str_radix(10u), "11".to_owned()); - assert_eq!((11 as $T).to_str_radix(16u), "b".to_owned()); - assert_eq!((255 as $T).to_str_radix(16u), "ff".to_owned()); - assert_eq!((0xff as $T).to_str_radix(10u), "255".to_owned()); + assert_eq!((0 as $T).to_str_radix(10u), "0".to_strbuf()); + assert_eq!((1 as $T).to_str_radix(10u), "1".to_strbuf()); + assert_eq!((2 as $T).to_str_radix(10u), "2".to_strbuf()); + assert_eq!((11 as $T).to_str_radix(10u), "11".to_strbuf()); + assert_eq!((11 as $T).to_str_radix(16u), "b".to_strbuf()); + assert_eq!((255 as $T).to_str_radix(16u), "ff".to_strbuf()); + assert_eq!((0xff as $T).to_str_radix(10u), "255".to_strbuf()); } #[test] @@ -133,28 +133,28 @@ mod tests { #[test] fn test_uint_to_str_overflow() { let mut u8_val: u8 = 255_u8; - assert_eq!(u8_val.to_str(), "255".to_owned()); + assert_eq!(u8_val.to_str(), "255".to_strbuf()); u8_val += 1 as u8; - assert_eq!(u8_val.to_str(), "0".to_owned()); + assert_eq!(u8_val.to_str(), "0".to_strbuf()); let mut u16_val: u16 = 65_535_u16; - assert_eq!(u16_val.to_str(), "65535".to_owned()); + assert_eq!(u16_val.to_str(), "65535".to_strbuf()); u16_val += 1 as u16; - assert_eq!(u16_val.to_str(), "0".to_owned()); + assert_eq!(u16_val.to_str(), "0".to_strbuf()); let mut u32_val: u32 = 4_294_967_295_u32; - assert_eq!(u32_val.to_str(), "4294967295".to_owned()); + assert_eq!(u32_val.to_str(), "4294967295".to_strbuf()); u32_val += 1 as u32; - assert_eq!(u32_val.to_str(), "0".to_owned()); + assert_eq!(u32_val.to_str(), "0".to_strbuf()); let mut u64_val: u64 = 18_446_744_073_709_551_615_u64; - assert_eq!(u64_val.to_str(), "18446744073709551615".to_owned()); + assert_eq!(u64_val.to_str(), "18446744073709551615".to_strbuf()); u64_val += 1 as u64; - assert_eq!(u64_val.to_str(), "0".to_owned()); + assert_eq!(u64_val.to_str(), "0".to_strbuf()); } #[test] diff --git a/src/libstd/os.rs b/src/libstd/os.rs index a4705b78caab7..493dd86b2763a 100644 --- a/src/libstd/os.rs +++ b/src/libstd/os.rs @@ -30,21 +30,22 @@ use clone::Clone; use container::Container; -use libc; +use fmt; +use iter::Iterator; use libc::{c_void, c_int}; +use libc; +use ops::Drop; use option::{Some, None, Option}; use os; -use ops::Drop; -use result::{Err, Ok, Result}; +use path::{Path, GenericPath}; +use ptr::RawPtr; use ptr; -use str; +use result::{Err, Ok, Result}; +use slice::{Vector, ImmutableVector, MutableVector, OwnedVector}; use str::{Str, StrSlice, StrAllocating}; -use fmt; +use str; +use strbuf::StrBuf; use sync::atomics::{AtomicInt, INIT_ATOMIC_INT, SeqCst}; -use path::{Path, GenericPath}; -use iter::Iterator; -use slice::{Vector, CloneableVector, ImmutableVector, MutableVector, OwnedVector}; -use ptr::RawPtr; use vec::Vec; #[cfg(unix)] @@ -103,12 +104,13 @@ pub mod win32 { use option; use os::TMPBUF_SZ; use slice::{MutableVector, ImmutableVector}; + use strbuf::StrBuf; use str::{StrSlice, StrAllocating}; use str; use vec::Vec; pub fn fill_utf16_buf_and_decode(f: |*mut u16, DWORD| -> DWORD) - -> Option<~str> { + -> Option { unsafe { let mut n = TMPBUF_SZ as DWORD; @@ -174,20 +176,20 @@ fn with_env_lock(f: || -> T) -> T { /// /// Invalid UTF-8 bytes are replaced with \uFFFD. See `str::from_utf8_lossy()` /// for details. -pub fn env() -> Vec<(~str,~str)> { +pub fn env() -> Vec<(StrBuf,StrBuf)> { env_as_bytes().move_iter().map(|(k,v)| { - let k = str::from_utf8_lossy(k).into_owned(); - let v = str::from_utf8_lossy(v).into_owned(); + let k = str::from_utf8_lossy(k.as_slice()).to_strbuf(); + let v = str::from_utf8_lossy(v.as_slice()).to_strbuf(); (k,v) }).collect() } /// Returns a vector of (variable, value) byte-vector pairs for all the /// environment variables of the current process. -pub fn env_as_bytes() -> Vec<(~[u8],~[u8])> { +pub fn env_as_bytes() -> Vec<(Vec,Vec)> { unsafe { #[cfg(windows)] - unsafe fn get_env_pairs() -> Vec<~[u8]> { + unsafe fn get_env_pairs() -> Vec> { use slice::raw; use libc::funcs::extra::kernel32::{ @@ -227,7 +229,7 @@ pub fn env_as_bytes() -> Vec<(~[u8],~[u8])> { result } #[cfg(unix)] - unsafe fn get_env_pairs() -> Vec<~[u8]> { + unsafe fn get_env_pairs() -> Vec> { use c_str::CString; extern { @@ -240,18 +242,19 @@ pub fn env_as_bytes() -> Vec<(~[u8],~[u8])> { } let mut result = Vec::new(); ptr::array_each(environ, |e| { - let env_pair = CString::new(e, false).as_bytes_no_nul().to_owned(); + let env_pair = + Vec::from_slice(CString::new(e, false).as_bytes_no_nul()); result.push(env_pair); }); result } - fn env_convert(input: Vec<~[u8]>) -> Vec<(~[u8], ~[u8])> { + fn env_convert(input: Vec>) -> Vec<(Vec, Vec)> { let mut pairs = Vec::new(); for p in input.iter() { - let mut it = p.splitn(1, |b| *b == '=' as u8); - let key = it.next().unwrap().to_owned(); - let val = it.next().unwrap_or(&[]).to_owned(); + let mut it = p.as_slice().splitn(1, |b| *b == '=' as u8); + let key = Vec::from_slice(it.next().unwrap()); + let val = Vec::from_slice(it.next().unwrap_or(&[])); pairs.push((key, val)); } pairs @@ -273,8 +276,8 @@ pub fn env_as_bytes() -> Vec<(~[u8],~[u8])> { /// # Failure /// /// Fails if `n` has any interior NULs. -pub fn getenv(n: &str) -> Option<~str> { - getenv_as_bytes(n).map(|v| str::from_utf8_lossy(v).into_owned()) +pub fn getenv(n: &str) -> Option { + getenv_as_bytes(n).map(|v| str::from_utf8_lossy(v.as_slice()).to_strbuf()) } #[cfg(unix)] @@ -284,7 +287,7 @@ pub fn getenv(n: &str) -> Option<~str> { /// # Failure /// /// Fails if `n` has any interior NULs. -pub fn getenv_as_bytes(n: &str) -> Option<~[u8]> { +pub fn getenv_as_bytes(n: &str) -> Option> { use c_str::CString; unsafe { @@ -293,7 +296,8 @@ pub fn getenv_as_bytes(n: &str) -> Option<~[u8]> { if s.is_null() { None } else { - Some(CString::new(s, false).as_bytes_no_nul().to_owned()) + Some(Vec::from_slice(CString::new(s, + false).as_bytes_no_nul())) } }) } @@ -302,7 +306,7 @@ pub fn getenv_as_bytes(n: &str) -> Option<~[u8]> { #[cfg(windows)] /// Fetches the environment variable `n` from the current process, returning /// None if the variable isn't set. -pub fn getenv(n: &str) -> Option<~str> { +pub fn getenv(n: &str) -> Option { unsafe { with_env_lock(|| { use os::win32::{as_utf16_p, fill_utf16_buf_and_decode}; @@ -318,7 +322,7 @@ pub fn getenv(n: &str) -> Option<~str> { #[cfg(windows)] /// Fetches the environment variable `n` byte vector from the current process, /// returning None if the variable isn't set. -pub fn getenv_as_bytes(n: &str) -> Option<~[u8]> { +pub fn getenv_as_bytes(n: &str) -> Option> { getenv(n).map(|s| s.into_bytes()) } @@ -432,8 +436,8 @@ pub fn pipe() -> Pipe { } /// Returns the proper dll filename for the given basename of a file. -pub fn dll_filename(base: &str) -> ~str { - format!("{}{}{}", consts::DLL_PREFIX, base, consts::DLL_SUFFIX) +pub fn dll_filename(base: &str) -> StrBuf { + format_strbuf!("{}{}{}", consts::DLL_PREFIX, base, consts::DLL_SUFFIX) } /// Optionally returns the filesystem path of the current executable which is @@ -527,7 +531,7 @@ pub fn self_exe_path() -> Option { * Otherwise, homedir returns option::none. */ pub fn homedir() -> Option { - // FIXME (#7188): getenv needs a ~[u8] variant + // FIXME (#7188): getenv needs a Vec variant return match getenv("HOME") { Some(ref p) if !p.is_empty() => Path::new_opt(p.as_slice()), _ => secondary() @@ -688,11 +692,11 @@ pub fn errno() -> uint { } /// Return the string corresponding to an `errno()` value of `errnum`. -pub fn error_string(errnum: uint) -> ~str { +pub fn error_string(errnum: uint) -> StrBuf { return strerror(errnum); #[cfg(unix)] - fn strerror(errnum: uint) -> ~str { + fn strerror(errnum: uint) -> StrBuf { #[cfg(target_os = "macos")] #[cfg(target_os = "android")] #[cfg(target_os = "freebsd")] @@ -732,12 +736,12 @@ pub fn error_string(errnum: uint) -> ~str { fail!("strerror_r failure"); } - str::raw::from_c_str(p as *c_char) + str::raw::from_c_str(p as *c_char).into_strbuf() } } #[cfg(windows)] - fn strerror(errnum: uint) -> ~str { + fn strerror(errnum: uint) -> StrBuf { use libc::types::os::arch::extra::DWORD; use libc::types::os::arch::extra::LPWSTR; use libc::types::os::arch::extra::LPVOID; @@ -789,7 +793,7 @@ pub fn error_string(errnum: uint) -> ~str { } /// Get a string representing the platform-dependent last error -pub fn last_os_error() -> ~str { +pub fn last_os_error() -> StrBuf { error_string(errno() as uint) } @@ -816,11 +820,12 @@ pub fn get_exit_status() -> int { } #[cfg(target_os = "macos")] -unsafe fn load_argc_and_argv(argc: int, argv: **c_char) -> Vec<~[u8]> { +unsafe fn load_argc_and_argv(argc: int, argv: **c_char) -> Vec> { use c_str::CString; Vec::from_fn(argc as uint, |i| { - CString::new(*argv.offset(i as int), false).as_bytes_no_nul().to_owned() + Vec::from_slice(CString::new(*argv.offset(i as int), + false).as_bytes_no_nul()) }) } @@ -830,7 +835,7 @@ unsafe fn load_argc_and_argv(argc: int, argv: **c_char) -> Vec<~[u8]> { * Returns a list of the command line arguments. */ #[cfg(target_os = "macos")] -fn real_args_as_bytes() -> Vec<~[u8]> { +fn real_args_as_bytes() -> Vec> { unsafe { let (argc, argv) = (*_NSGetArgc() as int, *_NSGetArgv() as **c_char); @@ -841,7 +846,7 @@ fn real_args_as_bytes() -> Vec<~[u8]> { #[cfg(target_os = "linux")] #[cfg(target_os = "android")] #[cfg(target_os = "freebsd")] -fn real_args_as_bytes() -> Vec<~[u8]> { +fn real_args_as_bytes() -> Vec> { use rt; match rt::args::clone() { @@ -851,12 +856,15 @@ fn real_args_as_bytes() -> Vec<~[u8]> { } #[cfg(not(windows))] -fn real_args() -> Vec<~str> { - real_args_as_bytes().move_iter().map(|v| str::from_utf8_lossy(v).into_owned()).collect() +fn real_args() -> Vec { + real_args_as_bytes().move_iter() + .map(|v| { + str::from_utf8_lossy(v.as_slice()).into_strbuf() + }).collect() } #[cfg(windows)] -fn real_args() -> Vec<~str> { +fn real_args() -> Vec { use slice; use option::Expect; @@ -886,7 +894,7 @@ fn real_args() -> Vec<~str> { } #[cfg(windows)] -fn real_args_as_bytes() -> Vec<~[u8]> { +fn real_args_as_bytes() -> Vec> { real_args().move_iter().map(|s| s.into_bytes()).collect() } @@ -910,13 +918,20 @@ extern "system" { /// /// The arguments are interpreted as utf-8, with invalid bytes replaced with \uFFFD. /// See `str::from_utf8_lossy` for details. -pub fn args() -> Vec<~str> { +#[cfg(not(test))] +pub fn args() -> Vec { real_args() } +#[cfg(test)] +#[allow(missing_doc)] +pub fn args() -> ::realstd::vec::Vec<::realstd::strbuf::StrBuf> { + ::realstd::os::args() +} + /// Returns the arguments which this program was started with (normally passed /// via the command line) as byte vectors. -pub fn args_as_bytes() -> Vec<~[u8]> { +pub fn args_as_bytes() -> Vec> { real_args_as_bytes() } @@ -1509,37 +1524,37 @@ mod tests { assert!(a.len() >= 1); } - fn make_rand_name() -> ~str { + fn make_rand_name() -> StrBuf { let mut rng = rand::task_rng(); let n = format_strbuf!("TEST{}", rng.gen_ascii_str(10u).as_slice()); assert!(getenv(n.as_slice()).is_none()); - n.into_owned() + n } #[test] fn test_setenv() { let n = make_rand_name(); - setenv(n, "VALUE"); - assert_eq!(getenv(n), option::Some("VALUE".to_owned())); + setenv(n.as_slice(), "VALUE"); + assert_eq!(getenv(n.as_slice()), option::Some("VALUE".to_strbuf())); } #[test] fn test_unsetenv() { let n = make_rand_name(); - setenv(n, "VALUE"); - unsetenv(n); - assert_eq!(getenv(n), option::None); + setenv(n.as_slice(), "VALUE"); + unsetenv(n.as_slice()); + assert_eq!(getenv(n.as_slice()), option::None); } #[test] #[ignore] fn test_setenv_overwrite() { let n = make_rand_name(); - setenv(n, "1"); - setenv(n, "2"); - assert_eq!(getenv(n), option::Some("2".to_owned())); - setenv(n, ""); - assert_eq!(getenv(n), option::Some("".to_owned())); + setenv(n.as_slice(), "1"); + setenv(n.as_slice(), "2"); + assert_eq!(getenv(n.as_slice()), option::Some("2".to_strbuf())); + setenv(n.as_slice(), ""); + assert_eq!(getenv(n.as_slice()), option::Some("".to_strbuf())); } // Windows GetEnvironmentVariable requires some extra work to make sure @@ -1547,16 +1562,16 @@ mod tests { #[test] #[ignore] fn test_getenv_big() { - let mut s = "".to_owned(); + let mut s = "".to_strbuf(); let mut i = 0; while i < 100 { - s = s + "aaaaaaaaaa"; + s.push_str("aaaaaaaaaa"); i += 1; } let n = make_rand_name(); - setenv(n, s); + setenv(n.as_slice(), s.as_slice()); debug!("{}", s.clone()); - assert_eq!(getenv(n), option::Some(s)); + assert_eq!(getenv(n.as_slice()), option::Some(s)); } #[test] @@ -1589,7 +1604,7 @@ mod tests { for p in e.iter() { let (n, v) = (*p).clone(); debug!("{:?}", n.clone()); - let v2 = getenv(n); + let v2 = getenv(n.as_slice()); // MingW seems to set some funky environment variables like // "=C:=C:\MinGW\msys\1.0\bin" and "!::=::\" that are returned // from env() but not visible from getenv(). @@ -1600,11 +1615,11 @@ mod tests { #[test] fn test_env_set_get_huge() { let n = make_rand_name(); - let s = "x".repeat(10000); - setenv(n, s); - assert_eq!(getenv(n), Some(s)); - unsetenv(n); - assert_eq!(getenv(n), None); + let s = "x".repeat(10000).to_strbuf(); + setenv(n.as_slice(), s.as_slice()); + assert_eq!(getenv(n.as_slice()), Some(s)); + unsetenv(n.as_slice()); + assert_eq!(getenv(n.as_slice()), None); } #[test] @@ -1612,11 +1627,11 @@ mod tests { let n = make_rand_name(); let mut e = env(); - setenv(n, "VALUE"); - assert!(!e.contains(&(n.clone(), "VALUE".to_owned()))); + setenv(n.as_slice(), "VALUE"); + assert!(!e.contains(&(n.clone(), "VALUE".to_strbuf()))); e = env(); - assert!(e.contains(&(n, "VALUE".to_owned()))); + assert!(e.contains(&(n, "VALUE".to_strbuf()))); } #[test] @@ -1641,7 +1656,9 @@ mod tests { setenv("HOME", ""); assert!(os::homedir().is_none()); - for s in oldhome.iter() { setenv("HOME", *s) } + for s in oldhome.iter() { + setenv("HOME", s.as_slice()) + } } #[test] @@ -1668,8 +1685,12 @@ mod tests { setenv("USERPROFILE", "/home/PaloAlto"); assert!(os::homedir() == Some(Path::new("/home/MountainView"))); - for s in oldhome.iter() { setenv("HOME", *s) } - for s in olduserprofile.iter() { setenv("USERPROFILE", *s) } + for s in oldhome.iter() { + setenv("HOME", s.as_slice()) + } + for s in olduserprofile.iter() { + setenv("USERPROFILE", s.as_slice()) + } } #[test] diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs index 2960d55f337c7..1bd099e5d244d 100644 --- a/src/libstd/path/mod.rs +++ b/src/libstd/path/mod.rs @@ -519,28 +519,12 @@ impl<'a> BytesContainer for &'a str { fn is_str(_: Option<&'a str>) -> bool { true } } -impl BytesContainer for ~str { - #[inline] - fn container_as_bytes<'a>(&'a self) -> &'a [u8] { - self.as_bytes() - } - #[inline] - fn container_as_str<'a>(&'a self) -> Option<&'a str> { - Some(self.as_slice()) - } - #[inline] - fn is_str(_: Option<~str>) -> bool { true } -} impl BytesContainer for StrBuf { #[inline] fn container_as_bytes<'a>(&'a self) -> &'a [u8] { self.as_bytes() } #[inline] - fn container_into_owned_bytes(self) -> Vec { - self.into_bytes() - } - #[inline] fn container_as_str<'a>(&'a self) -> Option<&'a str> { Some(self.as_slice()) } diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs index 4f7132dc6e442..8a939a9284659 100644 --- a/src/libstd/path/posix.rs +++ b/src/libstd/path/posix.rs @@ -781,7 +781,7 @@ mod tests { t!(s: "a/b/c", ["d", "e"], "a/b/c/d/e"); t!(s: "a/b/c", ["d", "/e"], "/e"); t!(s: "a/b/c", ["d", "/e", "f"], "/e/f"); - t!(s: "a/b/c", ["d".to_owned(), "e".to_owned()], "a/b/c/d/e"); + t!(s: "a/b/c", ["d".to_strbuf(), "e".to_strbuf()], "a/b/c/d/e"); t!(v: b!("a/b/c"), [b!("d"), b!("e")], b!("a/b/c/d/e")); t!(v: b!("a/b/c"), [b!("d"), b!("/e"), b!("f")], b!("/e/f")); t!(v: b!("a/b/c"), [Vec::from_slice(b!("d")), Vec::from_slice(b!("e"))], b!("a/b/c/d/e")); @@ -886,7 +886,7 @@ mod tests { t!(s: "a/b/c", ["d", "e"], "a/b/c/d/e"); t!(s: "a/b/c", ["..", "d"], "a/b/d"); t!(s: "a/b/c", ["d", "/e", "f"], "/e/f"); - t!(s: "a/b/c", ["d".to_owned(), "e".to_owned()], "a/b/c/d/e"); + t!(s: "a/b/c", ["d".to_strbuf(), "e".to_strbuf()], "a/b/c/d/e"); t!(v: b!("a/b/c"), [b!("d"), b!("e")], b!("a/b/c/d/e")); t!(v: b!("a/b/c"), [Vec::from_slice(b!("d")), Vec::from_slice(b!("e"))], b!("a/b/c/d/e")); } diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs index 176788edcc466..1c671b30e80d9 100644 --- a/src/libstd/path/windows.rs +++ b/src/libstd/path/windows.rs @@ -136,10 +136,17 @@ impl<'a> ToCStr for &'a Path { } impl ::hash::Hash for Path { + #[cfg(not(test))] #[inline] fn hash(&self, state: &mut S) { self.repr.hash(state) } + + #[cfg(test)] + #[inline] + fn hash(&self, _: &mut S) { + // No-op because the `hash` implementation will be wrong. + } } impl BytesContainer for Path { @@ -589,7 +596,7 @@ impl GenericPath for Path { } } } - Some(Path::new(comps.connect("\\"))) + Some(Path::new(comps.connect("\\").into_strbuf())) } } @@ -754,7 +761,10 @@ impl Path { let mut s = StrBuf::from_str(s.slice_to(len)); unsafe { let v = s.as_mut_vec(); - *v.get_mut(0) = v.get(0).to_ascii().to_upper().to_byte(); + *v.get_mut(0) = v.get(0) + .to_ascii() + .to_upper() + .to_byte(); } if is_abs { // normalize C:/ to C:\ @@ -913,7 +923,7 @@ pub fn make_non_verbatim(path: &Path) -> Option { } Some(VerbatimUNCPrefix(_,_)) => { // \\?\UNC\server\share - Path::new(format!(r"\\{}", repr.slice_from(7))) + Path::new(format_strbuf!(r"\\{}", repr.slice_from(7))) } }; if new_path.prefix.is_none() { @@ -1331,9 +1341,9 @@ mod tests { #[test] fn test_display_str() { let path = Path::new("foo"); - assert_eq!(path.display().to_str(), "foo".to_owned()); + assert_eq!(path.display().to_str(), "foo".to_strbuf()); let path = Path::new(b!("\\")); - assert_eq!(path.filename_display().to_str(), "".to_owned()); + assert_eq!(path.filename_display().to_str(), "".to_strbuf()); let path = Path::new("foo"); let mo = path.display().as_maybe_owned(); @@ -1594,7 +1604,7 @@ mod tests { t!(s: "a\\b\\c", ["d", "e"], "a\\b\\c\\d\\e"); t!(s: "a\\b\\c", ["d", "\\e"], "\\e"); t!(s: "a\\b\\c", ["d", "\\e", "f"], "\\e\\f"); - t!(s: "a\\b\\c", ["d".to_owned(), "e".to_owned()], "a\\b\\c\\d\\e"); + t!(s: "a\\b\\c", ["d".to_strbuf(), "e".to_strbuf()], "a\\b\\c\\d\\e"); t!(v: b!("a\\b\\c"), [b!("d"), b!("e")], b!("a\\b\\c\\d\\e")); t!(v: b!("a\\b\\c"), [b!("d"), b!("\\e"), b!("f")], b!("\\e\\f")); t!(v: b!("a\\b\\c"), [Vec::from_slice(b!("d")), Vec::from_slice(b!("e"))], @@ -1735,7 +1745,7 @@ mod tests { t!(s: "a\\b\\c", ["d", "e"], "a\\b\\c\\d\\e"); t!(s: "a\\b\\c", ["..", "d"], "a\\b\\d"); t!(s: "a\\b\\c", ["d", "\\e", "f"], "\\e\\f"); - t!(s: "a\\b\\c", ["d".to_owned(), "e".to_owned()], "a\\b\\c\\d\\e"); + t!(s: "a\\b\\c", ["d".to_strbuf(), "e".to_strbuf()], "a\\b\\c\\d\\e"); t!(v: b!("a\\b\\c"), [b!("d"), b!("e")], b!("a\\b\\c\\d\\e")); t!(v: b!("a\\b\\c"), [Vec::from_slice(b!("d")), Vec::from_slice(b!("e"))], b!("a\\b\\c\\d\\e")); diff --git a/src/libstd/repr.rs b/src/libstd/repr.rs index 35f32d0872802..8da906d85219a 100644 --- a/src/libstd/repr.rs +++ b/src/libstd/repr.rs @@ -16,21 +16,22 @@ More runtime type reflection #![allow(missing_doc)] -use mem::transmute; use char; use container::Container; +use intrinsics::{Disr, Opaque, TyDesc, TyVisitor, get_tydesc, visit_tydesc}; use io; use iter::Iterator; +use mem::transmute; use option::{Some, None, Option}; use ptr::RawPtr; -use reflect; +use raw; use reflect::{MovePtr, align}; +use reflect; use result::{Ok, Err}; -use str::StrSlice; -use to_str::ToStr; use slice::Vector; -use intrinsics::{Disr, Opaque, TyDesc, TyVisitor, get_tydesc, visit_tydesc}; -use raw; +use str::{Str, StrSlice}; +use strbuf::StrBuf; +use to_str::ToStr; use vec::Vec; macro_rules! try( ($me:expr, $e:expr) => ( @@ -296,10 +297,7 @@ impl<'a> TyVisitor for ReprVisitor<'a> { } fn visit_estr_uniq(&mut self) -> bool { - self.get::<~str>(|this, s| { - try!(this, this.writer.write(['~' as u8])); - this.write_escaped_slice(*s) - }) + true } fn visit_estr_slice(&mut self) -> bool { @@ -604,14 +602,14 @@ pub fn write_repr(writer: &mut io::Writer, object: &T) -> io::IoResult<()> { } } -pub fn repr_to_str(t: &T) -> ~str { +pub fn repr_to_str(t: &T) -> StrBuf { use str; use str::StrAllocating; use io; let mut result = io::MemWriter::new(); write_repr(&mut result as &mut io::Writer, t).unwrap(); - str::from_utf8(result.unwrap().as_slice()).unwrap().to_owned() + str::from_utf8(result.unwrap().as_slice()).unwrap().to_strbuf() } #[cfg(test)] @@ -638,8 +636,6 @@ fn test_repr() { exact_test(&false, "false"); exact_test(&1.234, "1.234f64"); exact_test(&("hello"), "\"hello\""); - // FIXME What do I do about this one? - exact_test(&("he\u10f3llo".to_owned()), "~\"he\\u10f3llo\""); exact_test(&(@10), "@10"); exact_test(&(box 10), "box 10"); @@ -659,14 +655,6 @@ fn test_repr() { "@repr::P{a: 10, b: 1.234f64}"); exact_test(&(box P{a:10, b:1.234}), "box repr::P{a: 10, b: 1.234f64}"); - exact_test(&(10u8, "hello".to_owned()), - "(10u8, ~\"hello\")"); - exact_test(&(10u16, "hello".to_owned()), - "(10u16, ~\"hello\")"); - exact_test(&(10u32, "hello".to_owned()), - "(10u32, ~\"hello\")"); - exact_test(&(10u64, "hello".to_owned()), - "(10u64, ~\"hello\")"); exact_test(&(&[1, 2]), "&[1, 2]"); exact_test(&(&mut [1, 2]), "&mut [1, 2]"); diff --git a/src/libstd/rt/args.rs b/src/libstd/rt/args.rs index 95d0eabd336d8..cde20521c2f66 100644 --- a/src/libstd/rt/args.rs +++ b/src/libstd/rt/args.rs @@ -37,8 +37,8 @@ pub unsafe fn init(argc: int, argv: **u8) { realargs::init(argc, argv) } #[cfg(test)] pub unsafe fn cleanup() { realargs::cleanup() } /// Take the global arguments from global storage. -#[cfg(not(test))] pub fn take() -> Option> { imp::take() } -#[cfg(test)] pub fn take() -> Option> { +#[cfg(not(test))] pub fn take() -> Option>> { imp::take() } +#[cfg(test)] pub fn take() -> Option>> { match realargs::take() { realstd::option::Some(v) => Some(unsafe{ ::mem::transmute(v) }), realstd::option::None => None, @@ -48,12 +48,16 @@ pub unsafe fn init(argc: int, argv: **u8) { realargs::init(argc, argv) } /// Give the global arguments to global storage. /// /// It is an error if the arguments already exist. -#[cfg(not(test))] pub fn put(args: Vec<~[u8]>) { imp::put(args) } -#[cfg(test)] pub fn put(args: Vec<~[u8]>) { realargs::put(unsafe { ::mem::transmute(args) }) } +#[cfg(not(test))] pub fn put(args: Vec>) { imp::put(args) } +#[cfg(test)] pub fn put(args: Vec>) { + realargs::put(unsafe { + ::mem::transmute(args) + }) +} /// Make a clone of the global arguments. -#[cfg(not(test))] pub fn clone() -> Option> { imp::clone() } -#[cfg(test)] pub fn clone() -> Option> { +#[cfg(not(test))] pub fn clone() -> Option>> { imp::clone() } +#[cfg(test)] pub fn clone() -> Option>> { match realargs::clone() { realstd::option::Some(v) => Some(unsafe { ::mem::transmute(v) }), realstd::option::None => None, @@ -88,15 +92,15 @@ mod imp { lock.destroy(); } - pub fn take() -> Option> { + pub fn take() -> Option>> { with_lock(|| unsafe { let ptr = get_global_ptr(); let val = mem::replace(&mut *ptr, None); - val.as_ref().map(|s: &Box>| (**s).clone()) + val.as_ref().map(|s: &Box>>| (**s).clone()) }) } - pub fn put(args: Vec<~[u8]>) { + pub fn put(args: Vec>) { with_lock(|| unsafe { let ptr = get_global_ptr(); rtassert!((*ptr).is_none()); @@ -104,10 +108,10 @@ mod imp { }) } - pub fn clone() -> Option> { + pub fn clone() -> Option>> { with_lock(|| unsafe { let ptr = get_global_ptr(); - (*ptr).as_ref().map(|s: &Box>| (**s).clone()) + (*ptr).as_ref().map(|s: &Box>>| (**s).clone()) }) } @@ -118,22 +122,21 @@ mod imp { } } - fn get_global_ptr() -> *mut Option>> { + fn get_global_ptr() -> *mut Option>>> { unsafe { mem::transmute(&global_args_ptr) } } // Copied from `os`. #[cfg(not(test))] - unsafe fn load_argc_and_argv(argc: int, argv: **u8) -> Vec<~[u8]> { + unsafe fn load_argc_and_argv(argc: int, argv: **u8) -> Vec> { use c_str::CString; use ptr::RawPtr; use libc; - use slice::CloneableVector; use vec::Vec; Vec::from_fn(argc as uint, |i| { let cs = CString::new(*(argv as **libc::c_char).offset(i as int), false); - cs.as_bytes_no_nul().to_owned() + Vec::from_slice(cs.as_bytes_no_nul()) }) } @@ -148,7 +151,10 @@ mod imp { // Preserve the actual global state. let saved_value = take(); - let expected = vec![bytes!("happy").to_owned(), bytes!("today?").to_owned()]; + let expected = vec![ + Vec::from_slice(bytes!("happy")), + Vec::from_slice(bytes!("today?")), + ]; put(expected.clone()); assert!(clone() == Some(expected.clone())); @@ -179,15 +185,15 @@ mod imp { pub fn cleanup() { } - pub fn take() -> Option> { + pub fn take() -> Option>> { fail!() } - pub fn put(_args: Vec<~[u8]>) { + pub fn put(_args: Vec>) { fail!() } - pub fn clone() -> Option> { + pub fn clone() -> Option>> { fail!() } } diff --git a/src/libstd/rt/env.rs b/src/libstd/rt/env.rs index 708c42030ab7e..c9e5cae60e46c 100644 --- a/src/libstd/rt/env.rs +++ b/src/libstd/rt/env.rs @@ -13,6 +13,7 @@ use from_str::from_str; use option::{Some, None, Expect}; use os; +use str::Str; // Note that these are all accessed without any synchronization. // They are expected to be initialized once then left alone. @@ -25,15 +26,19 @@ static mut DEBUG_BORROW: bool = false; pub fn init() { unsafe { match os::getenv("RUST_MIN_STACK") { - Some(s) => match from_str(s) { + Some(s) => match from_str(s.as_slice()) { Some(i) => MIN_STACK = i, None => () }, None => () } match os::getenv("RUST_MAX_CACHED_STACKS") { - Some(max) => MAX_CACHED_STACKS = from_str(max).expect("expected positive integer in \ - RUST_MAX_CACHED_STACKS"), + Some(max) => { + MAX_CACHED_STACKS = + from_str(max.as_slice()).expect("expected positive \ + integer in \ + RUST_MAX_CACHED_STACKS") + } None => () } match os::getenv("RUST_DEBUG_BORROW") { diff --git a/src/libstd/rt/macros.rs b/src/libstd/rt/macros.rs index 74675c85b96b3..aef41de925ffa 100644 --- a/src/libstd/rt/macros.rs +++ b/src/libstd/rt/macros.rs @@ -43,6 +43,7 @@ macro_rules! rtassert ( macro_rules! rtabort ( ($($arg:tt)*) => ( { - ::rt::util::abort(format!($($arg)*)); + use str::Str; + ::rt::util::abort(format!($($arg)*).as_slice()); } ) ) diff --git a/src/libstd/rt/task.rs b/src/libstd/rt/task.rs index 8968747d9908e..749f44d1c9d2c 100644 --- a/src/libstd/rt/task.rs +++ b/src/libstd/rt/task.rs @@ -420,11 +420,11 @@ mod test { #[test] fn tls() { - local_data_key!(key: @~str) - key.replace(Some(@"data".to_owned())); + local_data_key!(key: @StrBuf) + key.replace(Some(@"data".to_strbuf())); assert_eq!(key.get().unwrap().as_slice(), "data"); - local_data_key!(key2: @~str) - key2.replace(Some(@"data".to_owned())); + local_data_key!(key2: @StrBuf) + key2.replace(Some(@"data".to_strbuf())); assert_eq!(key2.get().unwrap().as_slice(), "data"); } diff --git a/src/libstd/rt/unwind.rs b/src/libstd/rt/unwind.rs index af87a31b7bd81..8f2df8311969b 100644 --- a/src/libstd/rt/unwind.rs +++ b/src/libstd/rt/unwind.rs @@ -71,6 +71,7 @@ use rt::backtrace; use rt::local::Local; use rt::task::Task; use str::Str; +use strbuf::StrBuf; use task::TaskResult; use uw = rt::libunwind; @@ -353,7 +354,7 @@ pub fn begin_unwind_fmt(msg: &fmt::Arguments, file: &'static str, // required with the current scheme, and (b) we don't handle // failure + OOM properly anyway (see comment in begin_unwind // below). - begin_unwind_inner(box fmt::format(msg), file, line) + begin_unwind_inner(box fmt::format_strbuf(msg), file, line) } /// This is the entry point of unwinding for fail!() and assert!(). @@ -388,7 +389,7 @@ fn begin_unwind_inner(msg: Box, { let msg_s = match msg.as_ref::<&'static str>() { Some(s) => *s, - None => match msg.as_ref::<~str>() { + None => match msg.as_ref::() { Some(s) => s.as_slice(), None => "Box", } diff --git a/src/libstd/rt/util.rs b/src/libstd/rt/util.rs index c9e82bd16e541..1ab9ac1b11edc 100644 --- a/src/libstd/rt/util.rs +++ b/src/libstd/rt/util.rs @@ -18,7 +18,7 @@ use libc; use option::{Some, None, Option}; use os; use result::Ok; -use str::StrSlice; +use str::{Str, StrSlice}; use unstable::running_on_valgrind; use slice::ImmutableVector; @@ -55,7 +55,7 @@ pub fn limit_thread_creation_due_to_osx_and_valgrind() -> bool { pub fn default_sched_threads() -> uint { match os::getenv("RUST_THREADS") { Some(nstr) => { - let opt_n: Option = FromStr::from_str(nstr); + let opt_n: Option = FromStr::from_str(nstr.as_slice()); match opt_n { Some(n) if n > 0 => n, _ => rtabort!("`RUST_THREADS` is `{}`, should be a positive integer", nstr) @@ -145,6 +145,7 @@ which at the time convulsed us with joy, yet which are now partly lost to my memory and partly incapable of presentation to others.", _ => "You've met with a terrible fate, haven't you?" }; + ::alloc::util::make_stdlib_link_work(); // see comments in liballoc rterrln!("{}", ""); rterrln!("{}", quote); rterrln!("{}", ""); diff --git a/src/libstd/slice.rs b/src/libstd/slice.rs index 0838211b9a59f..ae1caa16d28ad 100644 --- a/src/libstd/slice.rs +++ b/src/libstd/slice.rs @@ -1853,16 +1853,18 @@ mod tests { }) ) let empty: ~[int] = box []; - test_show_vec!(empty, "[]".to_owned()); - test_show_vec!(box [1], "[1]".to_owned()); - test_show_vec!(box [1, 2, 3], "[1, 2, 3]".to_owned()); - test_show_vec!(box [box [], box [1u], box [1u, 1u]], "[[], [1], [1, 1]]".to_owned()); + test_show_vec!(empty, "[]".to_strbuf()); + test_show_vec!(box [1], "[1]".to_strbuf()); + test_show_vec!(box [1, 2, 3], "[1, 2, 3]".to_strbuf()); + test_show_vec!(box [box [], box [1u], box [1u, 1u]], + "[[], [1], [1, 1]]".to_strbuf()); let empty_mut: &mut [int] = &mut[]; - test_show_vec!(empty_mut, "[]".to_owned()); - test_show_vec!(&mut[1], "[1]".to_owned()); - test_show_vec!(&mut[1, 2, 3], "[1, 2, 3]".to_owned()); - test_show_vec!(&mut[&mut[], &mut[1u], &mut[1u, 1u]], "[[], [1], [1, 1]]".to_owned()); + test_show_vec!(empty_mut, "[]".to_strbuf()); + test_show_vec!(&mut[1], "[1]".to_strbuf()); + test_show_vec!(&mut[1, 2, 3], "[1, 2, 3]".to_strbuf()); + test_show_vec!(&mut[&mut[], &mut[1u], &mut[1u, 1u]], + "[[], [1], [1, 1]]".to_strbuf()); } #[test] diff --git a/src/libstd/str.rs b/src/libstd/str.rs index 617887e8af3ea..4ba711c46112f 100644 --- a/src/libstd/str.rs +++ b/src/libstd/str.rs @@ -17,37 +17,29 @@ Unicode string manipulation (`str` type) Rust's string type is one of the core primitive types of the language. While represented by the name `str`, the name `str` is not actually a valid type in Rust. Each string must also be decorated with its ownership. This means that -there are two common kinds of strings in Rust: - -* `~str` - This is an owned string. This type obeys all of the normal semantics - of the `Box` types, meaning that it has one, and only one, - owner. This type cannot be implicitly copied, and is moved out of - when passed to other functions. +there is one common kind of string in Rust: * `&str` - This is the borrowed string type. This type of string can only be created from the other kind of string. As the name "borrowed" implies, this type of string is owned elsewhere, and this string cannot be moved out of. -As an example, here's a few different kinds of strings. +As an example, here's the one kind of string. ```rust fn main() { - let owned_string = "I am an owned string".to_owned(); - let borrowed_string1 = "This string is borrowed with the 'static lifetime"; - let borrowed_string2: &str = owned_string; // owned strings can be borrowed + let borrowed_string = "This string is borrowed with the 'static lifetime"; } ``` -From the example above, you can see that Rust has 2 different kinds of string -literals. The owned literals correspond to the owned string types, but the -"borrowed literal" is actually more akin to C's concept of a static string. +From the example above, you can see that Rust has 1 different kind of string +literal. The "borrowed literal" is akin to C's concept of a static string. -When a string is declared without a `~` sigil, then the string is allocated -statically in the rodata of the executable/library. The string then has the -type `&'static str` meaning that the string is valid for the `'static` -lifetime, otherwise known as the lifetime of the entire program. As can be -inferred from the type, these static strings are not mutable. +String literals are allocated statically in the rodata of the +executable/library. The string then has the type `&'static str` meaning that +the string is valid for the `'static` lifetime, otherwise known as the +lifetime of the entire program. As can be inferred from the type, these static +strings are not mutable. # Mutability @@ -67,10 +59,8 @@ stream of UTF-8 bytes. All safely-created strings are guaranteed to be validly encoded UTF-8 sequences. Additionally, strings are not null-terminated and can contain null codepoints. -The actual representation of strings have direct mappings to vectors: - -* `~str` is the same as `~[u8]` -* `&str` is the same as `&[u8]` +The actual representation of strings have direct mappings to vectors: `&str` +is the same as `&[u8]`. */ @@ -81,13 +71,12 @@ use cmp::{Eq, TotalEq, Ord, TotalOrd, Equiv, Ordering}; use container::Container; use default::Default; use fmt; -use from_str::FromStr; use io::Writer; use iter::{Iterator, range, AdditiveIterator}; use mem::transmute; use mem; use option::{None, Option, Some}; -use result::{Result, Ok, Err}; +use result::Result; use slice::Vector; use slice::{ImmutableVector, MutableVector, CloneableVector}; use strbuf::StrBuf; @@ -96,7 +85,7 @@ use vec::Vec; pub use core::str::{from_utf8, CharEq, Chars, CharOffsets, RevChars}; pub use core::str::{RevCharOffsets, Bytes, RevBytes, CharSplits, RevCharSplits}; pub use core::str::{CharSplitsN, Words, AnyLines, MatchIndices, StrSplits}; -pub use core::str::{eq_slice, eq, is_utf8, is_utf16, UTF16Items}; +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::{Str, StrSlice}; @@ -109,17 +98,8 @@ Section: Creating a string /// /// Returns `Err` with the original vector if the vector contains invalid /// UTF-8. -pub fn from_utf8_owned(vv: ~[u8]) -> Result<~str, ~[u8]> { - if is_utf8(vv) { - Ok(unsafe { raw::from_utf8_owned(vv) }) - } else { - Err(vv) - } -} - -impl FromStr for ~str { - #[inline] - fn from_str(s: &str) -> Option<~str> { Some(s.to_owned()) } +pub fn from_utf8_owned(vv: Vec) -> Result> { + StrBuf::from_utf8(vv) } /// Convert a byte to a UTF-8 string @@ -127,35 +107,37 @@ impl FromStr for ~str { /// # Failure /// /// Fails if invalid UTF-8 -pub fn from_byte(b: u8) -> ~str { +pub fn from_byte(b: u8) -> StrBuf { assert!(b < 128u8); - unsafe { ::mem::transmute(box [b]) } + StrBuf::from_char(1, b as char) } /// Convert a char to a string -pub fn from_char(ch: char) -> ~str { +pub fn from_char(ch: char) -> StrBuf { let mut buf = StrBuf::new(); buf.push_char(ch); - buf.into_owned() + buf } /// Convert a vector of chars to a string -pub fn from_chars(chs: &[char]) -> ~str { +pub fn from_chars(chs: &[char]) -> StrBuf { chs.iter().map(|c| *c).collect() } /// Methods for vectors of strings pub trait StrVector { /// Concatenate a vector of strings. - fn concat(&self) -> ~str; + fn concat(&self) -> StrBuf; /// Concatenate a vector of strings, placing a given separator between each. - fn connect(&self, sep: &str) -> ~str; + fn connect(&self, sep: &str) -> StrBuf; } impl<'a, S: Str> StrVector for &'a [S] { - fn concat(&self) -> ~str { - if self.is_empty() { return "".to_owned(); } + fn concat(&self) -> StrBuf { + if self.is_empty() { + return StrBuf::new(); + } // `len` calculation may overflow but push_str but will check boundaries let len = self.iter().map(|s| s.as_slice().len()).sum(); @@ -166,14 +148,18 @@ impl<'a, S: Str> StrVector for &'a [S] { result.push_str(s.as_slice()) } - result.into_owned() + result } - fn connect(&self, sep: &str) -> ~str { - if self.is_empty() { return "".to_owned(); } + fn connect(&self, sep: &str) -> StrBuf { + if self.is_empty() { + return StrBuf::new(); + } // concat is faster - if sep.is_empty() { return self.concat(); } + if sep.is_empty() { + return self.concat(); + } // this is wrong without the guarantee that `self` is non-empty // `len` calculation may overflow but push_str but will check boundaries @@ -190,18 +176,18 @@ impl<'a, S: Str> StrVector for &'a [S] { } result.push_str(s.as_slice()); } - result.into_owned() + result } } impl<'a, S: Str> StrVector for Vec { #[inline] - fn concat(&self) -> ~str { + fn concat(&self) -> StrBuf { self.as_slice().concat() } #[inline] - fn connect(&self, sep: &str) -> ~str { + fn connect(&self, sep: &str) -> StrBuf { self.as_slice().connect(sep) } } @@ -317,7 +303,7 @@ impl<'a> Iterator for Decompositions<'a> { /// # Return value /// /// The original string with all occurrences of `from` replaced with `to` -pub fn replace(s: &str, from: &str, to: &str) -> ~str { +pub fn replace(s: &str, from: &str, to: &str) -> StrBuf { let mut result = StrBuf::new(); let mut last_end = 0; for (start, end) in s.match_indices(from) { @@ -326,7 +312,7 @@ pub fn replace(s: &str, from: &str, to: &str) -> ~str { last_end = end; } result.push_str(unsafe{raw::slice_bytes(s, last_end, s.len())}); - result.into_owned() + result } /* @@ -350,7 +336,7 @@ Section: Misc /// v[4] = 0xD800; /// assert_eq!(str::from_utf16(v), None); /// ``` -pub fn from_utf16(v: &[u16]) -> Option<~str> { +pub fn from_utf16(v: &[u16]) -> Option { let mut s = StrBuf::with_capacity(v.len() / 2); for c in utf16_items(v) { match c { @@ -358,7 +344,7 @@ pub fn from_utf16(v: &[u16]) -> Option<~str> { LoneSurrogate(_) => return None } } - Some(s.into_owned()) + Some(s) } /// Decode a UTF-16 encoded vector `v` into a string, replacing @@ -376,7 +362,7 @@ pub fn from_utf16(v: &[u16]) -> Option<~str> { /// assert_eq!(str::from_utf16_lossy(v), /// "𝄞mus\uFFFDic\uFFFD".to_owned()); /// ``` -pub fn from_utf16_lossy(v: &[u16]) -> ~str { +pub fn from_utf16_lossy(v: &[u16]) -> StrBuf { utf16_items(v).map(|c| c.to_char_lossy()).collect() } @@ -523,14 +509,14 @@ pub fn from_utf8_lossy<'a>(v: &'a [u8]) -> MaybeOwned<'a> { Section: MaybeOwned */ -/// A MaybeOwned is a string that can hold either a ~str or a &str. +/// A MaybeOwned is a string that can hold either a StrBuf or a &str. /// This can be useful as an optimization when an allocation is sometimes /// needed but not always. pub enum MaybeOwned<'a> { /// A borrowed string Slice(&'a str), /// An owned string - Owned(~str) + Owned(StrBuf) } /// SendStr is a specialization of `MaybeOwned` to be sendable @@ -562,14 +548,11 @@ pub trait IntoMaybeOwned<'a> { fn into_maybe_owned(self) -> MaybeOwned<'a>; } -impl<'a> IntoMaybeOwned<'a> for ~str { - #[inline] - fn into_maybe_owned(self) -> MaybeOwned<'a> { Owned(self) } -} - impl<'a> IntoMaybeOwned<'a> for StrBuf { #[inline] - fn into_maybe_owned(self) -> MaybeOwned<'a> { Owned(self.into_owned()) } + fn into_maybe_owned(self) -> MaybeOwned<'a> { + Owned(self) + } } impl<'a> IntoMaybeOwned<'a> for &'a str { @@ -624,7 +607,7 @@ impl<'a> Str for MaybeOwned<'a> { impl<'a> StrAllocating for MaybeOwned<'a> { #[inline] - fn into_owned(self) -> ~str { + fn into_owned(self) -> StrBuf { match self { Slice(s) => s.to_owned(), Owned(s) => s @@ -657,7 +640,7 @@ impl<'a, H: Writer> ::hash::Hash for MaybeOwned<'a> { fn hash(&self, hasher: &mut H) { match *self { Slice(s) => s.hash(hasher), - Owned(ref s) => s.hash(hasher), + Owned(ref s) => s.as_slice().hash(hasher), } } } @@ -674,58 +657,43 @@ impl<'a> fmt::Show for MaybeOwned<'a> { /// Unsafe operations pub mod raw { + use c_str::CString; use libc; use mem; - use ptr::RawPtr; use raw::Slice; - use slice::CloneableVector; - use str::{is_utf8, StrAllocating}; + use strbuf::StrBuf; + use vec::Vec; pub use core::str::raw::{from_utf8, c_str_to_static_slice, slice_bytes}; pub use core::str::raw::{slice_unchecked}; /// Create a Rust string from a *u8 buffer of the given length - pub unsafe fn from_buf_len(buf: *u8, len: uint) -> ~str { - let v = Slice { data: buf, len: len }; - let bytes: &[u8] = ::mem::transmute(v); - assert!(is_utf8(bytes)); - let s: &str = ::mem::transmute(bytes); - s.to_owned() - } - - #[lang="strdup_uniq"] - #[cfg(not(test))] - #[inline] - unsafe fn strdup_uniq(ptr: *u8, len: uint) -> ~str { - from_buf_len(ptr, len) + pub unsafe fn from_buf_len(buf: *u8, len: uint) -> StrBuf { + let mut result = StrBuf::new(); + result.push_bytes(mem::transmute(Slice { + data: buf, + len: len, + })); + result } /// Create a Rust string from a null-terminated C string - pub unsafe fn from_c_str(buf: *libc::c_char) -> ~str { - let mut curr = buf; - let mut i = 0; - while *curr != 0 { - i += 1; - curr = buf.offset(i); - } - from_buf_len(buf as *u8, i as uint) + pub unsafe fn from_c_str(c_string: *libc::c_char) -> StrBuf { + let mut buf = StrBuf::new(); + buf.push_bytes(CString::new(c_string, false).as_bytes_no_nul()); + buf } /// Converts an owned vector of bytes to a new owned string. This assumes /// that the utf-8-ness of the vector has already been validated #[inline] - pub unsafe fn from_utf8_owned(v: ~[u8]) -> ~str { + pub unsafe fn from_utf8_owned(v: Vec) -> StrBuf { mem::transmute(v) } /// Converts a byte to a string. - pub unsafe fn from_byte(u: u8) -> ~str { from_utf8_owned(box [u]) } - - /// Access the str in its vector representation. - /// The caller must preserve the valid UTF-8 property when modifying. - #[inline] - pub unsafe fn as_owned_vec<'a>(s: &'a mut ~str) -> &'a mut ~[u8] { - mem::transmute(s) + pub unsafe fn from_byte(u: u8) -> StrBuf { + from_utf8_owned(vec![u]) } /// Sets the length of a string @@ -753,8 +721,8 @@ Section: Trait implementations /// Any string that can be represented as a slice pub trait StrAllocating: Str { - /// Convert `self` into a ~str, not making a copy if possible. - fn into_owned(self) -> ~str; + /// Convert `self` into a `StrBuf`, not making a copy if possible. + fn into_owned(self) -> StrBuf; /// Convert `self` into a `StrBuf`. #[inline] @@ -765,27 +733,27 @@ pub trait StrAllocating: Str { /// Convert `self` into a `StrBuf`, not making a copy if possible. #[inline] fn into_strbuf(self) -> StrBuf { - StrBuf::from_owned_str(self.into_owned()) + self.into_owned() } /// Escape each char in `s` with `char::escape_default`. - fn escape_default(&self) -> ~str { + fn escape_default(&self) -> StrBuf { let me = self.as_slice(); let mut out = StrBuf::with_capacity(me.len()); for c in me.chars() { c.escape_default(|c| out.push_char(c)); } - out.into_owned() + out } /// Escape each char in `s` with `char::escape_unicode`. - fn escape_unicode(&self) -> ~str { + fn escape_unicode(&self) -> StrBuf { let me = self.as_slice(); let mut out = StrBuf::with_capacity(me.len()); for c in me.chars() { c.escape_unicode(|c| out.push_char(c)); } - out.into_owned() + out } /// Replace all occurrences of one string with another. @@ -812,7 +780,7 @@ pub trait StrAllocating: Str { /// // not found, so no change. /// assert_eq!(s.replace("cookie monster", "little lamb"), s); /// ``` - fn replace(&self, from: &str, to: &str) -> ~str { + fn replace(&self, from: &str, to: &str) -> StrBuf { let me = self.as_slice(); let mut result = StrBuf::new(); let mut last_end = 0; @@ -822,16 +790,16 @@ pub trait StrAllocating: Str { last_end = end; } result.push_str(unsafe{raw::slice_bytes(me, last_end, me.len())}); - result.into_owned() + result } - /// Copy a slice into a new owned str. + /// Copy a slice into a new `StrBuf`. #[inline] - fn to_owned(&self) -> ~str { + fn to_owned(&self) -> StrBuf { use slice::Vector; unsafe { - ::mem::transmute(self.as_slice().as_bytes().to_owned()) + ::mem::transmute(Vec::from_slice(self.as_slice().as_bytes())) } } @@ -848,13 +816,13 @@ pub trait StrAllocating: Str { } /// Given a string, make a new string with repeated copies of it. - fn repeat(&self, nn: uint) -> ~str { + fn repeat(&self, nn: uint) -> StrBuf { let me = self.as_slice(); let mut ret = StrBuf::with_capacity(nn * me.len()); for _ in range(0, nn) { ret.push_str(me); } - ret.into_owned() + ret } /// Levenshtein Distance between two strings. @@ -919,12 +887,9 @@ pub trait StrAllocating: Str { impl<'a> StrAllocating for &'a str { #[inline] - fn into_owned(self) -> ~str { self.to_owned() } -} - -impl<'a> StrAllocating for ~str { - #[inline] - fn into_owned(self) -> ~str { self } + fn into_owned(self) -> StrBuf { + self.to_owned() + } } /// Methods for owned strings @@ -932,23 +897,23 @@ pub trait OwnedStr { /// Consumes the string, returning the underlying byte buffer. /// /// The buffer does not have a null terminator. - fn into_bytes(self) -> ~[u8]; + fn into_bytes(self) -> Vec; /// Pushes the given string onto this string, returning the concatenation of the two strings. - fn append(self, rhs: &str) -> ~str; + fn append(self, rhs: &str) -> StrBuf; } -impl OwnedStr for ~str { +impl OwnedStr for StrBuf { #[inline] - fn into_bytes(self) -> ~[u8] { + fn into_bytes(self) -> Vec { unsafe { mem::transmute(self) } } #[inline] - fn append(self, rhs: &str) -> ~str { + fn append(self, rhs: &str) -> StrBuf { let mut new_str = StrBuf::from_owned_str(self); new_str.push_str(rhs); - new_str.into_owned() + new_str } } @@ -960,13 +925,6 @@ mod tests { use str::*; use strbuf::StrBuf; - #[test] - fn test_eq() { - assert!((eq(&"".to_owned(), &"".to_owned()))); - assert!((eq(&"foo".to_owned(), &"foo".to_owned()))); - assert!((!eq(&"foo".to_owned(), &"bar".to_owned()))); - } - #[test] fn test_eq_slice() { assert!((eq_slice("foobar".slice(0, 3), "foo"))); @@ -1025,10 +983,10 @@ mod tests { #[test] fn test_collect() { let empty = "".to_owned(); - let s: ~str = empty.chars().collect(); + let s: StrBuf = empty.as_slice().chars().collect(); assert_eq!(empty, s); let data = "ประเทศไทย中".to_owned(); - let s: ~str = data.chars().collect(); + let s: StrBuf = data.as_slice().chars().collect(); assert_eq!(data, s); } @@ -1050,23 +1008,24 @@ mod tests { assert_eq!(data.slice(2u, 6u).find_str("ab"), Some(3u - 2u)); assert!(data.slice(2u, 4u).find_str("ab").is_none()); - let mut data = "ประเทศไทย中华Việt Nam".to_owned(); - data = data + data; - assert!(data.find_str("ไท华").is_none()); - assert_eq!(data.slice(0u, 43u).find_str(""), Some(0u)); - assert_eq!(data.slice(6u, 43u).find_str(""), Some(6u - 6u)); + let string = "ประเทศไทย中华Việt Nam"; + let mut data = string.to_strbuf(); + data.push_str(string); + assert!(data.as_slice().find_str("ไท华").is_none()); + assert_eq!(data.as_slice().slice(0u, 43u).find_str(""), Some(0u)); + assert_eq!(data.as_slice().slice(6u, 43u).find_str(""), Some(6u - 6u)); - assert_eq!(data.slice(0u, 43u).find_str("ประ"), Some( 0u)); - assert_eq!(data.slice(0u, 43u).find_str("ทศไ"), Some(12u)); - assert_eq!(data.slice(0u, 43u).find_str("ย中"), Some(24u)); - assert_eq!(data.slice(0u, 43u).find_str("iệt"), Some(34u)); - assert_eq!(data.slice(0u, 43u).find_str("Nam"), Some(40u)); + assert_eq!(data.as_slice().slice(0u, 43u).find_str("ประ"), Some( 0u)); + assert_eq!(data.as_slice().slice(0u, 43u).find_str("ทศไ"), Some(12u)); + assert_eq!(data.as_slice().slice(0u, 43u).find_str("ย中"), Some(24u)); + assert_eq!(data.as_slice().slice(0u, 43u).find_str("iệt"), Some(34u)); + assert_eq!(data.as_slice().slice(0u, 43u).find_str("Nam"), Some(40u)); - assert_eq!(data.slice(43u, 86u).find_str("ประ"), Some(43u - 43u)); - assert_eq!(data.slice(43u, 86u).find_str("ทศไ"), Some(55u - 43u)); - assert_eq!(data.slice(43u, 86u).find_str("ย中"), Some(67u - 43u)); - assert_eq!(data.slice(43u, 86u).find_str("iệt"), Some(77u - 43u)); - assert_eq!(data.slice(43u, 86u).find_str("Nam"), Some(83u - 43u)); + assert_eq!(data.as_slice().slice(43u, 86u).find_str("ประ"), Some(43u - 43u)); + assert_eq!(data.as_slice().slice(43u, 86u).find_str("ทศไ"), Some(55u - 43u)); + assert_eq!(data.as_slice().slice(43u, 86u).find_str("ย中"), Some(67u - 43u)); + assert_eq!(data.as_slice().slice(43u, 86u).find_str("iệt"), Some(77u - 43u)); + assert_eq!(data.as_slice().slice(43u, 86u).find_str("Nam"), Some(83u - 43u)); } #[test] @@ -1084,25 +1043,25 @@ mod tests { #[test] fn test_concat() { - fn t(v: &[~str], s: &str) { - assert_eq!(v.concat(), s.to_str()); + fn t(v: &[StrBuf], s: &str) { + assert_eq!(v.concat(), s.to_str().into_owned()); } t(["you".to_owned(), "know".to_owned(), "I'm".to_owned(), "no".to_owned(), "good".to_owned()], "youknowI'mnogood"); - let v: &[~str] = []; + let v: &[StrBuf] = []; t(v, ""); t(["hi".to_owned()], "hi"); } #[test] fn test_connect() { - fn t(v: &[~str], sep: &str, s: &str) { - assert_eq!(v.connect(sep), s.to_str()); + fn t(v: &[StrBuf], sep: &str, s: &str) { + assert_eq!(v.connect(sep), s.to_str().into_owned()); } t(["you".to_owned(), "know".to_owned(), "I'm".to_owned(), "no".to_owned(), "good".to_owned()], " ", "you know I'm no good"); - let v: &[~str] = []; + let v: &[StrBuf] = []; t(v, " ", ""); t(["hi".to_owned()], " ", "hi"); } @@ -1110,7 +1069,7 @@ mod tests { #[test] fn test_concat_slices() { fn t(v: &[&str], s: &str) { - assert_eq!(v.concat(), s.to_str()); + assert_eq!(v.concat(), s.to_str().into_owned()); } t(["you", "know", "I'm", "no", "good"], "youknowI'mnogood"); let v: &[&str] = []; @@ -1121,7 +1080,7 @@ mod tests { #[test] fn test_connect_slices() { fn t(v: &[&str], sep: &str, s: &str) { - assert_eq!(v.connect(sep), s.to_str()); + assert_eq!(v.connect(sep), s.to_str().into_owned()); } t(["you", "know", "I'm", "no", "good"], " ", "you know I'm no good"); @@ -1143,27 +1102,29 @@ mod tests { assert_eq!("ab", unsafe {raw::slice_bytes("abc", 0, 2)}); assert_eq!("bc", unsafe {raw::slice_bytes("abc", 1, 3)}); assert_eq!("", unsafe {raw::slice_bytes("abc", 1, 1)}); - fn a_million_letter_a() -> ~str { + fn a_million_letter_a() -> StrBuf { let mut i = 0; let mut rs = StrBuf::new(); while i < 100000 { rs.push_str("aaaaaaaaaa"); i += 1; } - rs.into_owned() + rs } - fn half_a_million_letter_a() -> ~str { + fn half_a_million_letter_a() -> StrBuf { let mut i = 0; let mut rs = StrBuf::new(); while i < 100000 { rs.push_str("aaaaa"); i += 1; } - rs.into_owned() + rs } let letters = a_million_letter_a(); assert!(half_a_million_letter_a() == - unsafe {raw::slice_bytes(letters, 0u, 500000)}.to_owned()); + unsafe {raw::slice_bytes(letters.as_slice(), + 0u, + 500000)}.to_owned()); } #[test] @@ -1208,41 +1169,41 @@ mod tests { #[test] fn test_replace_2a() { - let data = "ประเทศไทย中华".to_owned(); - let repl = "دولة الكويت".to_owned(); + let data = "ประเทศไทย中华"; + let repl = "دولة الكويت"; - let a = "ประเ".to_owned(); - let a2 = "دولة الكويتทศไทย中华".to_owned(); - assert_eq!(data.replace(a, repl), a2); + let a = "ประเ"; + let a2 = "دولة الكويتทศไทย中华"; + assert_eq!(data.replace(a, repl).as_slice(), a2); } #[test] fn test_replace_2b() { - let data = "ประเทศไทย中华".to_owned(); - let repl = "دولة الكويت".to_owned(); + let data = "ประเทศไทย中华"; + let repl = "دولة الكويت"; - let b = "ะเ".to_owned(); - let b2 = "ปรدولة الكويتทศไทย中华".to_owned(); - assert_eq!(data.replace(b, repl), b2); + let b = "ะเ"; + let b2 = "ปรدولة الكويتทศไทย中华"; + assert_eq!(data.replace(b, repl).as_slice(), b2); } #[test] fn test_replace_2c() { - let data = "ประเทศไทย中华".to_owned(); - let repl = "دولة الكويت".to_owned(); + let data = "ประเทศไทย中华"; + let repl = "دولة الكويت"; - let c = "中华".to_owned(); - let c2 = "ประเทศไทยدولة الكويت".to_owned(); - assert_eq!(data.replace(c, repl), c2); + let c = "中华"; + let c2 = "ประเทศไทยدولة الكويت"; + assert_eq!(data.replace(c, repl).as_slice(), c2); } #[test] fn test_replace_2d() { - let data = "ประเทศไทย中华".to_owned(); - let repl = "دولة الكويت".to_owned(); + let data = "ประเทศไทย中华"; + let repl = "دولة الكويت"; - let d = "ไท华".to_owned(); - assert_eq!(data.replace(d, repl), data); + let d = "ไท华"; + assert_eq!(data.replace(d, repl).as_slice(), data); } #[test] @@ -1258,27 +1219,27 @@ mod tests { assert_eq!("", data.slice(3, 3)); assert_eq!("华", data.slice(30, 33)); - fn a_million_letter_X() -> ~str { + fn a_million_letter_X() -> StrBuf { let mut i = 0; let mut rs = StrBuf::new(); while i < 100000 { rs.push_str("华华华华华华华华华华"); i += 1; } - rs.into_owned() + rs } - fn half_a_million_letter_X() -> ~str { + fn half_a_million_letter_X() -> StrBuf { let mut i = 0; let mut rs = StrBuf::new(); while i < 100000 { rs.push_str("华华华华华"); i += 1; } - rs.into_owned() + rs } let letters = a_million_letter_X(); assert!(half_a_million_letter_X() == - letters.slice(0u, 3u * 500000u).to_owned()); + letters.as_slice().slice(0u, 3u * 500000u).to_owned()); } #[test] @@ -1571,17 +1532,17 @@ mod tests { #[test] fn vec_str_conversions() { - let s1: ~str = "All mimsy were the borogoves".to_owned(); + let s1: StrBuf = "All mimsy were the borogoves".to_strbuf(); - let v: ~[u8] = s1.as_bytes().to_owned(); - let s2: ~str = from_utf8(v).unwrap().to_owned(); + let v: Vec = Vec::from_slice(s1.as_bytes()); + let s2: StrBuf = from_utf8(v.as_slice()).unwrap().to_strbuf(); let mut i: uint = 0u; let n1: uint = s1.len(); let n2: uint = v.len(); assert_eq!(n1, n2); while i < n1 { - let a: u8 = s1[i]; - let b: u8 = s2[i]; + let a: u8 = s1.as_slice()[i]; + let b: u8 = s2.as_slice()[i]; debug!("{}", a); debug!("{}", b); assert_eq!(a, b); @@ -1599,7 +1560,7 @@ mod tests { assert!(!"abcde".contains("def")); assert!(!"".contains("a")); - let data = "ประเทศไทย中华Việt Nam".to_owned(); + let data = "ประเทศไทย中华Việt Nam"; assert!(data.contains("ประเ")); assert!(data.contains("ะเ")); assert!(data.contains("中华")); @@ -1719,7 +1680,7 @@ mod tests { #[test] fn test_char_at() { - let s = "ศไทย中华Việt Nam".to_owned(); + let s = "ศไทย中华Việt Nam"; let v = box ['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m']; let mut pos = 0; for ch in v.iter() { @@ -1730,7 +1691,7 @@ mod tests { #[test] fn test_char_at_reverse() { - let s = "ศไทย中华Việt Nam".to_owned(); + let s = "ศไทย中华Việt Nam"; let v = box ['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m']; let mut pos = s.len(); for ch in v.iter().rev() { @@ -1775,7 +1736,7 @@ mod tests { #[test] fn test_char_range_at() { - let data = "b¢€𤭢𤭢€¢b".to_owned(); + let data = "b¢€𤭢𤭢€¢b"; assert_eq!('b', data.char_range_at(0).ch); assert_eq!('¢', data.char_range_at(1).ch); assert_eq!('€', data.char_range_at(3).ch); @@ -1791,29 +1752,10 @@ mod tests { assert_eq!("abc".char_range_at_reverse(0).next, 0); } - #[test] - fn test_add() { - #![allow(unnecessary_allocation)] - macro_rules! t ( - ($s1:expr, $s2:expr, $e:expr) => { { - let s1 = $s1; - let s2 = $s2; - let e = $e; - assert_eq!(s1 + s2, e.to_owned()); - assert_eq!(s1.to_owned() + s2, e.to_owned()); - } } - ); - - t!("foo", "bar", "foobar"); - t!("foo", "bar".to_owned(), "foobar"); - t!("ศไทย中", "华Việt Nam", "ศไทย中华Việt Nam"); - t!("ศไทย中", "华Việt Nam".to_owned(), "ศไทย中华Việt Nam"); - } - #[test] fn test_iterator() { use iter::*; - let s = "ศไทย中华Việt Nam".to_owned(); + let s = "ศไทย中华Việt Nam"; let v = box ['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m']; let mut pos = 0; @@ -1829,7 +1771,7 @@ mod tests { #[test] fn test_rev_iterator() { use iter::*; - let s = "ศไทย中华Việt Nam".to_owned(); + let s = "ศไทย中华Việt Nam"; let v = box ['m', 'a', 'N', ' ', 't', 'ệ','i','V','华','中','ย','ท','ไ','ศ']; let mut pos = 0; @@ -1852,7 +1794,7 @@ mod tests { #[test] fn test_bytesator() { - let s = "ศไทย中华Việt Nam".to_owned(); + let s = "ศไทย中华Việt Nam"; let v = [ 224, 184, 168, 224, 185, 132, 224, 184, 151, 224, 184, 162, 228, 184, 173, 229, 141, 142, 86, 105, 225, 187, 135, 116, 32, 78, 97, @@ -1868,7 +1810,7 @@ mod tests { #[test] fn test_bytes_revator() { - let s = "ศไทย中华Việt Nam".to_owned(); + let s = "ศไทย中华Việt Nam"; let v = [ 224, 184, 168, 224, 185, 132, 224, 184, 151, 224, 184, 162, 228, 184, 173, 229, 141, 142, 86, 105, 225, 187, 135, 116, 32, 78, 97, @@ -2025,30 +1967,30 @@ mod tests { #[test] fn test_nfd_chars() { - assert_eq!("abc".nfd_chars().collect::<~str>(), "abc".to_owned()); - assert_eq!("\u1e0b\u01c4".nfd_chars().collect::<~str>(), "d\u0307\u01c4".to_owned()); - assert_eq!("\u2026".nfd_chars().collect::<~str>(), "\u2026".to_owned()); - assert_eq!("\u2126".nfd_chars().collect::<~str>(), "\u03a9".to_owned()); - assert_eq!("\u1e0b\u0323".nfd_chars().collect::<~str>(), "d\u0323\u0307".to_owned()); - assert_eq!("\u1e0d\u0307".nfd_chars().collect::<~str>(), "d\u0323\u0307".to_owned()); - assert_eq!("a\u0301".nfd_chars().collect::<~str>(), "a\u0301".to_owned()); - assert_eq!("\u0301a".nfd_chars().collect::<~str>(), "\u0301a".to_owned()); - assert_eq!("\ud4db".nfd_chars().collect::<~str>(), "\u1111\u1171\u11b6".to_owned()); - assert_eq!("\uac1c".nfd_chars().collect::<~str>(), "\u1100\u1162".to_owned()); + assert_eq!("abc".nfd_chars().collect::(), "abc".to_strbuf()); + assert_eq!("\u1e0b\u01c4".nfd_chars().collect::(), "d\u0307\u01c4".to_strbuf()); + assert_eq!("\u2026".nfd_chars().collect::(), "\u2026".to_strbuf()); + assert_eq!("\u2126".nfd_chars().collect::(), "\u03a9".to_strbuf()); + assert_eq!("\u1e0b\u0323".nfd_chars().collect::(), "d\u0323\u0307".to_strbuf()); + assert_eq!("\u1e0d\u0307".nfd_chars().collect::(), "d\u0323\u0307".to_strbuf()); + assert_eq!("a\u0301".nfd_chars().collect::(), "a\u0301".to_strbuf()); + assert_eq!("\u0301a".nfd_chars().collect::(), "\u0301a".to_strbuf()); + assert_eq!("\ud4db".nfd_chars().collect::(), "\u1111\u1171\u11b6".to_strbuf()); + assert_eq!("\uac1c".nfd_chars().collect::(), "\u1100\u1162".to_strbuf()); } #[test] fn test_nfkd_chars() { - assert_eq!("abc".nfkd_chars().collect::<~str>(), "abc".to_owned()); - assert_eq!("\u1e0b\u01c4".nfkd_chars().collect::<~str>(), "d\u0307DZ\u030c".to_owned()); - assert_eq!("\u2026".nfkd_chars().collect::<~str>(), "...".to_owned()); - assert_eq!("\u2126".nfkd_chars().collect::<~str>(), "\u03a9".to_owned()); - assert_eq!("\u1e0b\u0323".nfkd_chars().collect::<~str>(), "d\u0323\u0307".to_owned()); - assert_eq!("\u1e0d\u0307".nfkd_chars().collect::<~str>(), "d\u0323\u0307".to_owned()); - assert_eq!("a\u0301".nfkd_chars().collect::<~str>(), "a\u0301".to_owned()); - assert_eq!("\u0301a".nfkd_chars().collect::<~str>(), "\u0301a".to_owned()); - assert_eq!("\ud4db".nfkd_chars().collect::<~str>(), "\u1111\u1171\u11b6".to_owned()); - assert_eq!("\uac1c".nfkd_chars().collect::<~str>(), "\u1100\u1162".to_owned()); + assert_eq!("abc".nfkd_chars().collect::(), "abc".to_strbuf()); + assert_eq!("\u1e0b\u01c4".nfkd_chars().collect::(), "d\u0307DZ\u030c".to_strbuf()); + assert_eq!("\u2026".nfkd_chars().collect::(), "...".to_strbuf()); + assert_eq!("\u2126".nfkd_chars().collect::(), "\u03a9".to_strbuf()); + assert_eq!("\u1e0b\u0323".nfkd_chars().collect::(), "d\u0323\u0307".to_strbuf()); + assert_eq!("\u1e0d\u0307".nfkd_chars().collect::(), "d\u0323\u0307".to_strbuf()); + assert_eq!("a\u0301".nfkd_chars().collect::(), "a\u0301".to_strbuf()); + assert_eq!("\u0301a".nfkd_chars().collect::(), "\u0301a".to_strbuf()); + assert_eq!("\ud4db".nfkd_chars().collect::(), "\u1111\u1171\u11b6".to_strbuf()); + assert_eq!("\uac1c".nfkd_chars().collect::(), "\u1100\u1162".to_strbuf()); } #[test] @@ -2093,7 +2035,7 @@ mod tests { } t::<&str>(); - t::<~str>(); + t::(); } #[test] @@ -2122,14 +2064,15 @@ mod tests { #[test] fn test_str_from_utf8_owned() { - let xs = bytes!("hello").to_owned(); + let xs = Vec::from_slice(bytes!("hello")); assert_eq!(from_utf8_owned(xs), Ok("hello".to_owned())); - let xs = bytes!("ศไทย中华Việt Nam").to_owned(); + let xs = Vec::from_slice(bytes!("ศไทย中华Việt Nam")); assert_eq!(from_utf8_owned(xs), Ok("ศไทย中华Việt Nam".to_owned())); - let xs = bytes!("hello", 0xff).to_owned(); - assert_eq!(from_utf8_owned(xs), Err(bytes!("hello", 0xff).to_owned())); + let xs = Vec::from_slice(bytes!("hello", 0xff)); + assert_eq!(from_utf8_owned(xs), + Err(Vec::from_slice(bytes!("hello", 0xff)))); } #[test] @@ -2167,8 +2110,8 @@ mod tests { #[test] fn test_from_str() { - let owned: Option<~str> = from_str("string"); - assert_eq!(owned, Some("string".to_owned())); + let owned: Option = from_str("string"); + assert_eq!(owned, Some("string".to_strbuf())); } #[test] @@ -2176,16 +2119,16 @@ mod tests { let s = Slice("abcde"); assert_eq!(s.len(), 5); assert_eq!(s.as_slice(), "abcde"); - assert_eq!(s.to_str(), "abcde".to_owned()); - assert_eq!(format!("{}", s), "abcde".to_owned()); + assert_eq!(s.to_str(), "abcde".to_strbuf()); + assert_eq!(format_strbuf!("{}", s), "abcde".to_strbuf()); assert!(s.lt(&Owned("bcdef".to_owned()))); assert_eq!(Slice(""), Default::default()); let o = Owned("abcde".to_owned()); assert_eq!(o.len(), 5); assert_eq!(o.as_slice(), "abcde"); - assert_eq!(o.to_str(), "abcde".to_owned()); - assert_eq!(format!("{}", o), "abcde".to_owned()); + assert_eq!(o.to_str(), "abcde".to_strbuf()); + assert_eq!(format_strbuf!("{}", o), "abcde".to_strbuf()); assert!(o.lt(&Slice("bcdef"))); assert_eq!(Owned("".to_owned()), Default::default()); diff --git a/src/libstd/strbuf.rs b/src/libstd/strbuf.rs index de480ef1b7fb7..dd462ff5ab584 100644 --- a/src/libstd/strbuf.rs +++ b/src/libstd/strbuf.rs @@ -12,8 +12,11 @@ use c_vec::CVec; use char::Char; +use cmp::Equiv; use container::{Container, Mutable}; +use default::Default; use fmt; +use from_str::FromStr; use io::Writer; use iter::{Extendable, FromIterator, Iterator, range}; use mem; @@ -21,8 +24,8 @@ use option::{None, Option, Some}; use ptr::RawPtr; use ptr; use result::{Result, Ok, Err}; -use slice::{OwnedVector, Vector, CloneableVector}; -use str::{CharRange, OwnedStr, Str, StrSlice, StrAllocating}; +use slice::Vector; +use str::{CharRange, Str, StrSlice, StrAllocating}; use str; use vec::Vec; @@ -67,10 +70,8 @@ impl StrBuf { /// Creates a new string buffer from the given owned string, taking care not to copy it. #[inline] - pub fn from_owned_str(string: ~str) -> StrBuf { - StrBuf { - vec: string.into_bytes().move_iter().collect(), - } + pub fn from_owned_str(string: StrBuf) -> StrBuf { + string } /// Returns the vector as a string buffer, if possible, taking care not to @@ -191,6 +192,13 @@ impl StrBuf { self.vec.as_slice() } + /// Works with the underlying buffer as a mutable byte slice. Unsafe + /// because this can be used to violate the UTF-8 property. + #[inline] + pub unsafe fn as_mut_bytes<'a>(&'a mut self) -> &'a mut [u8] { + self.vec.as_mut_slice() + } + /// Shorten a string to the specified length (which must be <= the current length) #[inline] pub fn truncate(&mut self, len: uint) { @@ -314,14 +322,20 @@ impl Str for StrBuf { impl StrAllocating for StrBuf { #[inline] - fn into_owned(self) -> ~str { - unsafe { - mem::transmute(self.vec.as_slice().to_owned()) - } + fn into_owned(self) -> StrBuf { + self } #[inline] - fn into_strbuf(self) -> StrBuf { self } + fn into_strbuf(self) -> StrBuf { + self + } +} + +impl Default for StrBuf { + fn default() -> StrBuf { + StrBuf::new() + } } impl fmt::Show for StrBuf { @@ -337,6 +351,20 @@ impl ::hash::Hash for StrBuf { } } +impl<'a, S: Str> Equiv for StrBuf { + #[inline] + fn equiv(&self, other: &S) -> bool { + self.as_slice() == other.as_slice() + } +} + +impl FromStr for StrBuf { + #[inline] + fn from_str(s: &str) -> Option { + Some(s.to_strbuf()) + } +} + #[cfg(test)] mod tests { extern crate test; diff --git a/src/libstd/task.rs b/src/libstd/task.rs index 5c875b4a2ad08..314f659550d41 100644 --- a/src/libstd/task.rs +++ b/src/libstd/task.rs @@ -51,6 +51,7 @@ use str::{Str, SendStr, IntoMaybeOwned}; #[cfg(test)] use owned::AnyOwnExt; #[cfg(test)] use result; #[cfg(test)] use str::StrAllocating; +#[cfg(test)] use strbuf::StrBuf; /// Indicates the manner in which a task exited. /// @@ -496,12 +497,12 @@ fn test_try_fail_message_static_str() { #[test] fn test_try_fail_message_owned_str() { match try(proc() { - fail!("owned string".to_owned()); + fail!("owned string".to_strbuf()); }) { Err(e) => { - type T = ~str; + type T = StrBuf; assert!(e.is::()); - assert_eq!(*e.move::().unwrap(), "owned string".to_owned()); + assert_eq!(*e.move::().unwrap(), "owned string".to_strbuf()); } Ok(()) => fail!() } diff --git a/src/libstd/to_str.rs b/src/libstd/to_str.rs index 4132c8a5b5a33..fbc4227e72646 100644 --- a/src/libstd/to_str.rs +++ b/src/libstd/to_str.rs @@ -15,21 +15,24 @@ The `ToStr` trait for converting to strings */ use fmt; +use strbuf::StrBuf; /// A generic trait for converting a value to a string pub trait ToStr { /// Converts the value of `self` to an owned string - fn to_str(&self) -> ~str; + fn to_str(&self) -> StrBuf; } /// Trait for converting a type to a string, consuming it in the process. pub trait IntoStr { /// Consume and convert to a string. - fn into_str(self) -> ~str; + fn into_str(self) -> StrBuf; } impl ToStr for T { - fn to_str(&self) -> ~str { format!("{}", *self) } + fn to_str(&self) -> StrBuf { + format_strbuf!("{}", *self) + } } #[cfg(test)] @@ -39,23 +42,23 @@ mod tests { #[test] fn test_simple_types() { - assert_eq!(1i.to_str(), "1".to_owned()); - assert_eq!((-1i).to_str(), "-1".to_owned()); - assert_eq!(200u.to_str(), "200".to_owned()); - assert_eq!(2u8.to_str(), "2".to_owned()); - assert_eq!(true.to_str(), "true".to_owned()); - assert_eq!(false.to_str(), "false".to_owned()); - assert_eq!(().to_str(), "()".to_owned()); - assert_eq!(("hi".to_owned()).to_str(), "hi".to_owned()); + assert_eq!(1i.to_str(), "1".to_strbuf()); + assert_eq!((-1i).to_str(), "-1".to_strbuf()); + assert_eq!(200u.to_str(), "200".to_strbuf()); + assert_eq!(2u8.to_str(), "2".to_strbuf()); + assert_eq!(true.to_str(), "true".to_strbuf()); + assert_eq!(false.to_str(), "false".to_strbuf()); + assert_eq!(().to_str(), "()".to_strbuf()); + assert_eq!(("hi".to_strbuf()).to_str(), "hi".to_strbuf()); } #[test] fn test_vectors() { let x: ~[int] = box []; - assert_eq!(x.to_str(), "[]".to_owned()); - assert_eq!((box [1]).to_str(), "[1]".to_owned()); - assert_eq!((box [1, 2, 3]).to_str(), "[1, 2, 3]".to_owned()); + assert_eq!(x.to_str(), "[]".to_strbuf()); + assert_eq!((box [1]).to_str(), "[1]".to_strbuf()); + assert_eq!((box [1, 2, 3]).to_str(), "[1, 2, 3]".to_strbuf()); assert!((box [box [], box [1], box [1, 1]]).to_str() == - "[[], [1], [1, 1]]".to_owned()); + "[[], [1], [1, 1]]".to_strbuf()); } } diff --git a/src/libstd/unstable/dynamic_lib.rs b/src/libstd/unstable/dynamic_lib.rs index d50c63c583247..8e85283ee55d3 100644 --- a/src/libstd/unstable/dynamic_lib.rs +++ b/src/libstd/unstable/dynamic_lib.rs @@ -27,6 +27,7 @@ use path::{Path,GenericPath}; use result::*; use slice::{Vector,ImmutableVector}; use str; +use strbuf::StrBuf; use vec::Vec; pub struct DynamicLibrary { handle: *u8} @@ -56,7 +57,7 @@ impl DynamicLibrary { /// Lazily open a dynamic library. When passed None it gives a /// handle to the calling process pub fn open(filename: Option) - -> Result { + -> Result { unsafe { let mut filename = filename; let maybe_library = dl::check_for_errors_in(|| { @@ -118,7 +119,9 @@ impl DynamicLibrary { let mut ret = Vec::new(); match os::getenv_as_bytes(DynamicLibrary::envvar()) { Some(env) => { - for portion in env.split(|a| *a == DynamicLibrary::separator()) { + for portion in + env.as_slice() + .split(|a| *a == DynamicLibrary::separator()) { ret.push(Path::new(portion)); } } @@ -128,7 +131,7 @@ impl DynamicLibrary { } /// Access the value at the symbol of the dynamic library - pub unsafe fn symbol(&self, symbol: &str) -> Result { + pub unsafe fn symbol(&self, symbol: &str) -> Result { // This function should have a lifetime constraint of 'a on // T but that feature is still unimplemented @@ -203,10 +206,12 @@ mod test { pub mod dl { use prelude::*; - use c_str::ToCStr; + use c_str::{CString, ToCStr}; use libc; use ptr; - use str; + use result::*; + use str::StrAllocating; + use strbuf::StrBuf; pub unsafe fn open_external(filename: T) -> *u8 { filename.with_c_str(|raw_name| { @@ -218,7 +223,7 @@ pub mod dl { dlopen(ptr::null(), Lazy as libc::c_int) as *u8 } - pub fn check_for_errors_in(f: || -> T) -> Result { + pub fn check_for_errors_in(f: || -> T) -> Result { use unstable::mutex::{StaticNativeMutex, NATIVE_MUTEX_INIT}; static mut lock: StaticNativeMutex = NATIVE_MUTEX_INIT; unsafe { @@ -233,7 +238,9 @@ pub mod dl { let ret = if ptr::null() == last_error { Ok(result) } else { - Err(str::raw::from_c_str(last_error)) + Err(CString::new(last_error, false).as_str() + .unwrap() + .to_strbuf()) }; ret @@ -269,6 +276,7 @@ pub mod dl { use os; use ptr; use result::{Ok, Err, Result}; + use strbuf::StrBuf; use str; use c_str::ToCStr; @@ -287,7 +295,7 @@ pub mod dl { handle as *u8 } - pub fn check_for_errors_in(f: || -> T) -> Result { + pub fn check_for_errors_in(f: || -> T) -> Result { unsafe { SetLastError(0); diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs index 32883707615d5..1776b6fbe6ec6 100644 --- a/src/libstd/vec.rs +++ b/src/libstd/vec.rs @@ -671,7 +671,7 @@ impl Vec { /// ```rust /// let v = vec!("a".to_owned(), "b".to_owned()); /// for s in v.move_iter() { - /// // s has type ~str, not &~str + /// // s has type StrBuf, not &StrBuf /// println!("{}", s); /// } /// ``` @@ -1849,9 +1849,9 @@ mod tests { let b: ~[u8] = FromVec::from_vec(a); assert_eq!(b.as_slice(), &[]); - let a = vec!["one".to_owned(), "two".to_owned()]; - let b: ~[~str] = FromVec::from_vec(a); - assert_eq!(b.as_slice(), &["one".to_owned(), "two".to_owned()]); + let a = vec!["one".to_strbuf(), "two".to_strbuf()]; + let b: ~[StrBuf] = FromVec::from_vec(a); + assert_eq!(b.as_slice(), &["one".to_strbuf(), "two".to_strbuf()]); struct Foo { x: uint, diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs index 5a57c2d6cc62d..bc660798240e9 100644 --- a/src/libsyntax/attr.rs +++ b/src/libsyntax/attr.rs @@ -396,7 +396,8 @@ pub fn require_unique_names(diagnostic: &SpanHandler, metas: &[@MetaItem]) { if !set.insert(name.clone()) { diagnostic.span_fatal(meta.span, - format!("duplicate meta item `{}`", name)); + format!("duplicate meta item `{}`", + name).as_slice()); } } } diff --git a/src/libsyntax/crateid.rs b/src/libsyntax/crateid.rs index b7700cf396d48..dc699bb985068 100644 --- a/src/libsyntax/crateid.rs +++ b/src/libsyntax/crateid.rs @@ -39,7 +39,9 @@ impl fmt::Show for CrateId { Some(ref version) => version.as_slice(), }; if self.path == self.name || - self.path.as_slice().ends_with(format!("/{}", self.name)) { + self.path + .as_slice() + .ends_with(format!("/{}", self.name).as_slice()) { write!(f, "\\#{}", version) } else { write!(f, "\\#{}:{}", self.name, version) @@ -52,12 +54,14 @@ impl FromStr for CrateId { let pieces: Vec<&str> = s.splitn('#', 1).collect(); let path = pieces.get(0).to_owned(); - if path.starts_with("/") || path.ends_with("/") || - path.starts_with(".") || path.is_empty() { + if path.as_slice().starts_with("/") || path.as_slice().ends_with("/") || + path.as_slice().starts_with(".") || path.is_empty() { return None; } - let path_pieces: Vec<&str> = path.rsplitn('/', 1).collect(); + let path_pieces: Vec<&str> = path.as_slice() + .rsplitn('/', 1) + .collect(); let inferred_name = *path_pieces.get(0); let (name, version) = if pieces.len() == 1 { diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs index 3eb6f40ba53c3..446a8f93753c3 100644 --- a/src/libsyntax/diagnostic.rs +++ b/src/libsyntax/diagnostic.rs @@ -106,7 +106,7 @@ impl SpanHandler { fail!(ExplicitBug); } pub fn span_unimpl(&self, sp: Span, msg: &str) -> ! { - self.span_bug(sp, "unimplemented ".to_owned() + msg); + self.span_bug(sp, format!("unimplemented {}", msg).as_slice()); } pub fn handler<'a>(&'a self) -> &'a Handler { &self.handler @@ -143,13 +143,13 @@ impl Handler { let s; match self.err_count.get() { 0u => return, - 1u => s = "aborting due to previous error".to_owned(), + 1u => s = "aborting due to previous error".to_strbuf(), _ => { s = format!("aborting due to {} previous errors", - self.err_count.get()); + self.err_count.get()); } } - self.fatal(s); + self.fatal(s.as_slice()); } pub fn warn(&self, msg: &str) { self.emit.borrow_mut().emit(None, msg, Warning); @@ -162,7 +162,7 @@ impl Handler { fail!(ExplicitBug); } pub fn unimpl(&self, msg: &str) -> ! { - self.bug("unimplemented ".to_owned() + msg); + self.bug(format!("unimplemented {}", msg).as_slice()); } pub fn emit(&self, cmsp: Option<(&codemap::CodeMap, Span)>, @@ -267,9 +267,12 @@ fn print_diagnostic(dst: &mut EmitterWriter, try!(write!(&mut dst.dst, "{} ", topic)); } - try!(print_maybe_styled(dst, format!("{}: ", lvl.to_str()), + try!(print_maybe_styled(dst, + format!("{}: ", lvl.to_str()).as_slice(), term::attr::ForegroundColor(lvl.color()))); - try!(print_maybe_styled(dst, format!("{}\n", msg), term::attr::Bold)); + try!(print_maybe_styled(dst, + format!("{}\n", msg).as_slice(), + term::attr::Bold)); Ok(()) } @@ -431,7 +434,8 @@ fn highlight_lines(err: &mut EmitterWriter, s.push_char('~'); } } - try!(print_maybe_styled(err, s.into_owned() + "\n", + try!(print_maybe_styled(err, + format!("{}\n", s).as_slice(), term::attr::ForegroundColor(lvl.color()))); } Ok(()) @@ -476,7 +480,7 @@ fn custom_highlight_lines(w: &mut EmitterWriter, s.push_char('^'); s.push_char('\n'); print_maybe_styled(w, - s.into_owned(), + s.as_slice(), term::attr::ForegroundColor(lvl.color())) } @@ -495,7 +499,8 @@ fn print_macro_backtrace(w: &mut EmitterWriter, }; try!(print_diagnostic(w, ss.as_slice(), Note, format!("in expansion of {}{}{}", pre, - ei.callee.name, post))); + ei.callee.name, + post).as_slice())); let ss = cm.span_to_str(ei.call_site); try!(print_diagnostic(w, ss.as_slice(), Note, "expansion site")); try!(print_macro_backtrace(w, cm, ei.call_site)); diff --git a/src/libsyntax/ext/asm.rs b/src/libsyntax/ext/asm.rs index b9c8be290caac..822084df2f607 100644 --- a/src/libsyntax/ext/asm.rs +++ b/src/libsyntax/ext/asm.rs @@ -107,7 +107,9 @@ pub fn expand_asm(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) (Some('+'), operand) => { // Save a reference to the output read_write_operands.push((outputs.len(), out)); - Some(token::intern_and_get_ident("=" + operand)) + Some(token::intern_and_get_ident(format!( + "={}", + operand).as_slice())) } _ => { cx.span_err(span, "output operand constraint lacks '=' or '+'"); @@ -208,7 +210,8 @@ pub fn expand_asm(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) // Append an input operand, with the form of ("0", expr) // that links to an output operand. for &(i, out) in read_write_operands.iter() { - inputs.push((token::intern_and_get_ident(i.to_str()), out)); + inputs.push((token::intern_and_get_ident(i.to_str().as_slice()), + out)); } MacExpr::new(@ast::Expr { @@ -216,7 +219,7 @@ pub fn expand_asm(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) node: ast::ExprInlineAsm(ast::InlineAsm { asm: token::intern_and_get_ident(asm.get()), asm_str_style: asm_str_style.unwrap(), - clobbers: token::intern_and_get_ident(cons), + clobbers: token::intern_and_get_ident(cons.as_slice()), inputs: inputs, outputs: outputs, volatile: volatile, diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index 06b56bbe472a2..854f1d022198c 100644 --- a/src/libsyntax/ext/base.rs +++ b/src/libsyntax/ext/base.rs @@ -533,7 +533,7 @@ pub fn check_zero_tts(cx: &ExtCtxt, tts: &[ast::TokenTree], name: &str) { if tts.len() != 0 { - cx.span_err(sp, format!("{} takes no arguments", name)); + cx.span_err(sp, format!("{} takes no arguments", name).as_slice()); } } @@ -545,14 +545,17 @@ pub fn get_single_str_from_tts(cx: &ExtCtxt, name: &str) -> Option { if tts.len() != 1 { - cx.span_err(sp, format!("{} takes 1 argument.", name)); + cx.span_err(sp, format!("{} takes 1 argument.", name).as_slice()); } else { match tts[0] { ast::TTTok(_, token::LIT_STR(ident)) | ast::TTTok(_, token::LIT_STR_RAW(ident, _)) => { return Some(token::get_ident(ident).get().to_strbuf()) } - _ => cx.span_err(sp, format!("{} requires a string.", name)), + _ => { + cx.span_err(sp, + format!("{} requires a string.", name).as_slice()) + } } } None diff --git a/src/libsyntax/ext/concat.rs b/src/libsyntax/ext/concat.rs index 7c6c9892002c9..b2baff8d286ec 100644 --- a/src/libsyntax/ext/concat.rs +++ b/src/libsyntax/ext/concat.rs @@ -38,14 +38,14 @@ pub fn expand_syntax_ext(cx: &mut base::ExtCtxt, accumulator.push_char(c); } ast::LitInt(i, _) | ast::LitIntUnsuffixed(i) => { - accumulator.push_str(format!("{}", i)); + accumulator.push_str(format!("{}", i).as_slice()); } ast::LitUint(u, _) => { - accumulator.push_str(format!("{}", u)); + accumulator.push_str(format!("{}", u).as_slice()); } ast::LitNil => {} ast::LitBool(b) => { - accumulator.push_str(format!("{}", b)); + accumulator.push_str(format!("{}", b).as_slice()); } ast::LitBinary(..) => { cx.span_err(e.span, "cannot concatenate a binary literal"); @@ -59,5 +59,5 @@ pub fn expand_syntax_ext(cx: &mut base::ExtCtxt, } base::MacExpr::new(cx.expr_str( sp, - token::intern_and_get_ident(accumulator.into_owned()))) + token::intern_and_get_ident(accumulator.as_slice()))) } diff --git a/src/libsyntax/ext/concat_idents.rs b/src/libsyntax/ext/concat_idents.rs index 0e168e7b33b70..24478358d7951 100644 --- a/src/libsyntax/ext/concat_idents.rs +++ b/src/libsyntax/ext/concat_idents.rs @@ -42,7 +42,7 @@ pub fn expand_syntax_ext(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) } } } - let res = str_to_ident(res_str.into_owned()); + let res = str_to_ident(res_str.as_slice()); let e = @ast::Expr { id: ast::DUMMY_NODE_ID, diff --git a/src/libsyntax/ext/deriving/bounds.rs b/src/libsyntax/ext/deriving/bounds.rs index b5b2667f892de..d90c7f37213b7 100644 --- a/src/libsyntax/ext/deriving/bounds.rs +++ b/src/libsyntax/ext/deriving/bounds.rs @@ -25,12 +25,18 @@ pub fn expand_deriving_bound(cx: &mut ExtCtxt, "Copy" => "Copy", "Send" => "Send", "Share" => "Share", - ref tname => cx.span_bug(span, - format!("expected built-in trait name but found {}", - *tname)) + ref tname => { + cx.span_bug(span, + format!("expected built-in trait name but \ + found {}", + *tname).as_slice()) + } } }, - _ => return cx.span_err(span, "unexpected value in deriving, expected a trait") + _ => { + return cx.span_err(span, "unexpected value in deriving, expected \ + a trait") + } }; let trait_def = TraitDef { diff --git a/src/libsyntax/ext/deriving/clone.rs b/src/libsyntax/ext/deriving/clone.rs index 510241588228c..89c94891b3380 100644 --- a/src/libsyntax/ext/deriving/clone.rs +++ b/src/libsyntax/ext/deriving/clone.rs @@ -66,12 +66,17 @@ fn cs_clone( ctor_ident = variant.node.name; all_fields = af; }, - EnumNonMatching(..) => cx.span_bug(trait_span, - format!("non-matching enum variants in `deriving({})`", - name)), - StaticEnum(..) | StaticStruct(..) => cx.span_bug(trait_span, - format!("static method in `deriving({})`", - name)) + EnumNonMatching(..) => { + cx.span_bug(trait_span, + format!("non-matching enum variants in \ + `deriving({})`", + name).as_slice()) + } + StaticEnum(..) | StaticStruct(..) => { + cx.span_bug(trait_span, + format!("static method in `deriving({})`", + name).as_slice()) + } } if all_fields.len() >= 1 && all_fields.get(0).name.is_none() { @@ -83,9 +88,12 @@ fn cs_clone( let fields = all_fields.iter().map(|field| { let ident = match field.name { Some(i) => i, - None => cx.span_bug(trait_span, - format!("unnamed field in normal struct in `deriving({})`", - name)) + None => { + cx.span_bug(trait_span, + format!("unnamed field in normal struct in \ + `deriving({})`", + name).as_slice()) + } }; cx.field_imm(field.span, ident, subcall(field)) }).collect::>(); diff --git a/src/libsyntax/ext/deriving/decodable.rs b/src/libsyntax/ext/deriving/decodable.rs index 2447535f1f3d8..172ae8dca6279 100644 --- a/src/libsyntax/ext/deriving/decodable.rs +++ b/src/libsyntax/ext/deriving/decodable.rs @@ -168,7 +168,7 @@ fn decode_static_fields(cx: &mut ExtCtxt, let fields = fields.iter().enumerate().map(|(i, &span)| { getarg(cx, span, token::intern_and_get_ident(format!("_field{}", - i)), + i).as_slice()), i) }).collect(); diff --git a/src/libsyntax/ext/deriving/encodable.rs b/src/libsyntax/ext/deriving/encodable.rs index 75b051b2f1086..b8a3eea0014a0 100644 --- a/src/libsyntax/ext/deriving/encodable.rs +++ b/src/libsyntax/ext/deriving/encodable.rs @@ -154,7 +154,8 @@ fn encodable_substructure(cx: &mut ExtCtxt, trait_span: Span, let name = match name { Some(id) => token::get_ident(id), None => { - token::intern_and_get_ident(format!("_field{}", i)) + token::intern_and_get_ident(format!("_field{}", + i).as_slice()) } }; let enc = cx.expr_method_call(span, self_, encode, vec!(blkencoder)); diff --git a/src/libsyntax/ext/deriving/generic/mod.rs b/src/libsyntax/ext/deriving/generic/mod.rs index 6df4da8940219..0875daddc0f9f 100644 --- a/src/libsyntax/ext/deriving/generic/mod.rs +++ b/src/libsyntax/ext/deriving/generic/mod.rs @@ -574,7 +574,7 @@ impl<'a> MethodDef<'a> { for (i, ty) in self.args.iter().enumerate() { let ast_ty = ty.to_ty(cx, trait_.span, type_ident, generics); - let ident = cx.ident_of(format!("__arg_{}", i)); + let ident = cx.ident_of(format!("__arg_{}", i).as_slice()); arg_tys.push((ident, ast_ty)); let arg_expr = cx.expr_ident(trait_.span, ident); @@ -674,9 +674,13 @@ impl<'a> MethodDef<'a> { // [fields of next Self arg], [etc]] let mut patterns = Vec::new(); for i in range(0u, self_args.len()) { - let (pat, ident_expr) = trait_.create_struct_pattern(cx, type_ident, struct_def, - format!("__self_{}", i), - ast::MutImmutable); + let (pat, ident_expr) = + trait_.create_struct_pattern(cx, + type_ident, + struct_def, + format!("__self_{}", + i).as_slice(), + ast::MutImmutable); patterns.push(pat); raw_fields.push(ident_expr); } @@ -875,7 +879,7 @@ impl<'a> MethodDef<'a> { } else { // there are still matches to create let current_match_str = if match_count == 0 { - "__self".to_owned() + "__self".to_strbuf() } else { format!("__arg_{}", match_count) }; @@ -895,10 +899,11 @@ impl<'a> MethodDef<'a> { // matching-variant match let variant = *enum_def.variants.get(index); - let (pattern, idents) = trait_.create_enum_variant_pattern(cx, - variant, - current_match_str, - ast::MutImmutable); + let (pattern, idents) = trait_.create_enum_variant_pattern( + cx, + variant, + current_match_str.as_slice(), + ast::MutImmutable); matches_so_far.push((index, variant, idents)); let arm_expr = self.build_enum_match(cx, @@ -926,10 +931,12 @@ impl<'a> MethodDef<'a> { } else { // create an arm matching on each variant for (index, &variant) in enum_def.variants.iter().enumerate() { - let (pattern, idents) = trait_.create_enum_variant_pattern(cx, - variant, - current_match_str, - ast::MutImmutable); + let (pattern, idents) = + trait_.create_enum_variant_pattern( + cx, + variant, + current_match_str.as_slice(), + ast::MutImmutable); matches_so_far.push((index, variant, idents)); let new_matching = @@ -1081,7 +1088,11 @@ impl<'a> TraitDef<'a> { cx.span_bug(sp, "a struct with named and unnamed fields in `deriving`"); } }; - let path = cx.path_ident(sp, cx.ident_of(format!("{}_{}", prefix, i))); + let path = + cx.path_ident(sp, + cx.ident_of(format!("{}_{}", + prefix, + i).as_slice())); paths.push(path.clone()); let val = cx.expr( sp, ast::ExprParen( @@ -1127,7 +1138,11 @@ impl<'a> TraitDef<'a> { let mut ident_expr = Vec::new(); for (i, va) in variant_args.iter().enumerate() { let sp = self.set_expn_info(cx, va.ty.span); - let path = cx.path_ident(sp, cx.ident_of(format!("{}_{}", prefix, i))); + let path = + cx.path_ident(sp, + cx.ident_of(format!("{}_{}", + prefix, + i).as_slice())); paths.push(path.clone()); let val = cx.expr( diff --git a/src/libsyntax/ext/deriving/mod.rs b/src/libsyntax/ext/deriving/mod.rs index 1187e83308b84..aeff36a49e60e 100644 --- a/src/libsyntax/ext/deriving/mod.rs +++ b/src/libsyntax/ext/deriving/mod.rs @@ -96,8 +96,10 @@ pub fn expand_meta_deriving(cx: &mut ExtCtxt, "Copy" => expand!(bounds::expand_deriving_bound), ref tname => { - cx.span_err(titem.span, format!("unknown \ - `deriving` trait: `{}`", *tname)); + cx.span_err(titem.span, + format!("unknown `deriving` \ + trait: `{}`", + *tname).as_slice()); } }; } diff --git a/src/libsyntax/ext/env.rs b/src/libsyntax/ext/env.rs index 8dbfbc53cecf7..d1a4d2f3ee3b6 100644 --- a/src/libsyntax/ext/env.rs +++ b/src/libsyntax/ext/env.rs @@ -53,7 +53,7 @@ pub fn expand_option_env(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) cx.ident_of("Some")), vec!(cx.expr_str(sp, token::intern_and_get_ident( - s)))) + s.as_slice())))) } }; MacExpr::new(e) @@ -80,7 +80,7 @@ pub fn expand_env(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) 1 => { token::intern_and_get_ident(format!("environment variable `{}` \ not defined", - var)) + var).as_slice()) } 2 => { match expr_to_str(cx, *exprs.get(1), "expected string literal") { @@ -99,7 +99,7 @@ pub fn expand_env(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) cx.span_err(sp, msg.get()); cx.expr_uint(sp, 0) } - Some(s) => cx.expr_str(sp, token::intern_and_get_ident(s)) + Some(s) => cx.expr_str(sp, token::intern_and_get_ident(s.as_slice())) }; MacExpr::new(e) } diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index e3b1037ccc06e..989d0a463c387 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -47,10 +47,9 @@ pub fn expand_expr(e: @ast::Expr, fld: &mut MacroExpander) -> @ast::Expr { // Token-tree macros: MacInvocTT(ref pth, ref tts, _) => { if pth.segments.len() > 1u { - fld.cx.span_err( - pth.span, - format!("expected macro name without module \ - separators")); + fld.cx.span_err(pth.span, + "expected macro name without module \ + separators"); // let compilation continue return DummyResult::raw_expr(e.span); } @@ -62,7 +61,7 @@ pub fn expand_expr(e: @ast::Expr, fld: &mut MacroExpander) -> @ast::Expr { fld.cx.span_err( pth.span, format!("macro undefined: '{}'", - extnamestr.get())); + extnamestr.get()).as_slice()); // let compilation continue return DummyResult::raw_expr(e.span); @@ -93,11 +92,10 @@ pub fn expand_expr(e: @ast::Expr, fld: &mut MacroExpander) -> @ast::Expr { None => { fld.cx.span_err( pth.span, - format!( - "non-expr macro in expr pos: {}", - extnamestr.get() - ) - ); + format!("non-expr macro in expr pos: \ + {}", + extnamestr.get().as_slice() + ).as_slice()); return DummyResult::raw_expr(e.span); } }; @@ -109,8 +107,7 @@ pub fn expand_expr(e: @ast::Expr, fld: &mut MacroExpander) -> @ast::Expr { fld.cx.span_err( pth.span, format!("'{}' is not a tt-style macro", - extnamestr.get()) - ); + extnamestr.get()).as_slice()); return DummyResult::raw_expr(e.span); } }; @@ -384,18 +381,19 @@ pub fn expand_item_mac(it: @ast::Item, fld: &mut MacroExpander) None => { fld.cx.span_err(pth.span, format!("macro undefined: '{}!'", - extnamestr)); + extnamestr).as_slice()); // let compilation continue return SmallVector::zero(); } Some(&NormalTT(ref expander, span)) => { if it.ident.name != parse::token::special_idents::invalid.name { - fld.cx.span_err(pth.span, - format!("macro {}! expects no ident argument, \ - given '{}'", - extnamestr, - token::get_ident(it.ident))); + fld.cx + .span_err(pth.span, + format!("macro {}! expects no ident argument, \ + given '{}'", + extnamestr, + token::get_ident(it.ident)).as_slice()); return SmallVector::zero(); } fld.cx.bt_push(ExpnInfo { @@ -414,7 +412,7 @@ pub fn expand_item_mac(it: @ast::Item, fld: &mut MacroExpander) if it.ident.name == parse::token::special_idents::invalid.name { fld.cx.span_err(pth.span, format!("macro {}! expects an ident argument", - extnamestr.get())); + extnamestr.get()).as_slice()); return SmallVector::zero(); } fld.cx.bt_push(ExpnInfo { @@ -432,7 +430,7 @@ pub fn expand_item_mac(it: @ast::Item, fld: &mut MacroExpander) _ => { fld.cx.span_err(it.span, format!("{}! is not legal in item position", - extnamestr.get())); + extnamestr.get()).as_slice()); return SmallVector::zero(); } }; @@ -459,7 +457,7 @@ pub fn expand_item_mac(it: @ast::Item, fld: &mut MacroExpander) None => { fld.cx.span_err(pth.span, format!("expr macro in item position: {}", - extnamestr.get())); + extnamestr.get()).as_slice()); return SmallVector::zero(); } } @@ -532,7 +530,7 @@ fn load_extern_macros(krate: &ast::ViewItem, fld: &mut MacroExpander) { // this is fatal: there are almost certainly macros we need // inside this crate, so continue would spew "macro undefined" // errors - Err(err) => fld.cx.span_fatal(krate.span, err) + Err(err) => fld.cx.span_fatal(krate.span, err.as_slice()) }; unsafe { @@ -540,7 +538,7 @@ fn load_extern_macros(krate: &ast::ViewItem, fld: &mut MacroExpander) { match lib.symbol(registrar.as_slice()) { Ok(registrar) => registrar, // again fatal if we can't register macros - Err(err) => fld.cx.span_fatal(krate.span, err) + Err(err) => fld.cx.span_fatal(krate.span, err.as_slice()) }; registrar(|name, extension| { let extension = match extension { @@ -581,7 +579,9 @@ pub fn expand_stmt(s: &Stmt, fld: &mut MacroExpander) -> SmallVector<@Stmt> { let extnamestr = token::get_ident(extname); let marked_after = match fld.extsbox.find(&extname.name) { None => { - fld.cx.span_err(pth.span, format!("macro undefined: '{}'", extnamestr)); + fld.cx.span_err(pth.span, + format!("macro undefined: '{}'", + extnamestr).as_slice()); return SmallVector::zero(); } @@ -609,7 +609,7 @@ pub fn expand_stmt(s: &Stmt, fld: &mut MacroExpander) -> SmallVector<@Stmt> { None => { fld.cx.span_err(pth.span, format!("non-stmt macro in stmt pos: {}", - extnamestr)); + extnamestr).as_slice()); return SmallVector::zero(); } }; @@ -619,7 +619,7 @@ pub fn expand_stmt(s: &Stmt, fld: &mut MacroExpander) -> SmallVector<@Stmt> { _ => { fld.cx.span_err(pth.span, format!("'{}' is not a tt-style macro", - extnamestr)); + extnamestr).as_slice()); return SmallVector::zero(); } }; diff --git a/src/libsyntax/ext/format.rs b/src/libsyntax/ext/format.rs index 01124fdfa54df..ad4b798cfe5b8 100644 --- a/src/libsyntax/ext/format.rs +++ b/src/libsyntax/ext/format.rs @@ -130,7 +130,7 @@ fn parse_args(ecx: &mut ExtCtxt, sp: Span, allow_method: bool, _ => { ecx.span_err(p.span, format!("expected ident for named argument, but found `{}`", - p.this_token_to_str())); + p.this_token_to_str()).as_slice()); return (invocation, None); } }; @@ -141,7 +141,9 @@ fn parse_args(ecx: &mut ExtCtxt, sp: Span, allow_method: bool, match names.find_equiv(&name) { None => {} Some(prev) => { - ecx.span_err(e.span, format!("duplicate argument named `{}`", name)); + ecx.span_err(e.span, + format!("duplicate argument named `{}`", + name).as_slice()); ecx.parse_sess.span_diagnostic.span_note(prev.span, "previously here"); continue } @@ -246,13 +248,15 @@ impl<'a, 'b> Context<'a, 'b> { match arm.selector { parse::Keyword(name) => { self.ecx.span_err(self.fmtsp, - format!("duplicate selector \ - `{}`", name)); + format!("duplicate \ + selector `{}`", + name).as_slice()); } parse::Literal(idx) => { self.ecx.span_err(self.fmtsp, - format!("duplicate selector \ - `={}`", idx)); + format!("duplicate \ + selector `={}`", + idx).as_slice()); } } } @@ -267,7 +271,7 @@ impl<'a, 'b> Context<'a, 'b> { if !seen_cases.insert(arm.selector) { self.ecx.span_err(self.fmtsp, format!("duplicate selector `{}`", - arm.selector)); + arm.selector).as_slice()); } else if arm.selector == "" { self.ecx.span_err(self.fmtsp, "empty selector in `select`"); @@ -286,7 +290,7 @@ impl<'a, 'b> Context<'a, 'b> { if self.args.len() <= arg { let msg = format!("invalid reference to argument `{}` (there \ are {} arguments)", arg, self.args.len()); - self.ecx.span_err(self.fmtsp, msg); + self.ecx.span_err(self.fmtsp, msg.as_slice()); return; } { @@ -306,7 +310,7 @@ impl<'a, 'b> Context<'a, 'b> { Some(e) => e.span, None => { let msg = format!("there is no argument named `{}`", name); - self.ecx.span_err(self.fmtsp, msg); + self.ecx.span_err(self.fmtsp, msg.as_slice()); return; } }; @@ -349,19 +353,19 @@ impl<'a, 'b> Context<'a, 'b> { format!("argument redeclared with type `{}` when \ it was previously `{}`", *ty, - *cur)); + *cur).as_slice()); } (&Known(ref cur), _) => { self.ecx.span_err(sp, format!("argument used to format with `{}` was \ attempted to not be used for formatting", - *cur)); + *cur).as_slice()); } (_, &Known(ref ty)) => { self.ecx.span_err(sp, format!("argument previously used as a format \ argument attempted to be used as `{}`", - *ty)); + *ty).as_slice()); } (_, _) => { self.ecx.span_err(sp, "argument declared with multiple formats"); @@ -480,7 +484,7 @@ impl<'a, 'b> Context<'a, 'b> { }).collect(); let (lr, selarg) = match arm.selector { parse::Keyword(t) => { - let p = self.rtpath(t.to_str()); + let p = self.rtpath(t.to_str().as_slice()); let p = self.ecx.path_global(sp, p); (self.rtpath("Keyword"), self.ecx.expr_path(p)) } @@ -516,7 +520,8 @@ impl<'a, 'b> Context<'a, 'b> { ), None); let st = ast::ItemStatic(ty, ast::MutImmutable, method); let static_name = self.ecx.ident_of(format!("__STATIC_METHOD_{}", - self.method_statics.len())); + self.method_statics + .len()).as_slice()); let item = self.ecx.item(sp, static_name, self.static_attrs(), st); self.method_statics.push(item); self.ecx.expr_ident(sp, static_name) @@ -662,7 +667,7 @@ impl<'a, 'b> Context<'a, 'b> { continue // error already generated } - let name = self.ecx.ident_of(format!("__arg{}", i)); + let name = self.ecx.ident_of(format!("__arg{}", i).as_slice()); pats.push(self.ecx.pat_ident(e.span, name)); heads.push(self.ecx.expr_addr_of(e.span, e)); locals.push(self.format_arg(e.span, Exact(i), @@ -674,7 +679,8 @@ impl<'a, 'b> Context<'a, 'b> { Some(..) | None => continue }; - let lname = self.ecx.ident_of(format!("__arg{}", *name)); + let lname = self.ecx.ident_of(format!("__arg{}", + *name).as_slice()); pats.push(self.ecx.pat_ident(e.span, lname)); heads.push(self.ecx.expr_addr_of(e.span, e)); *names.get_mut(*self.name_positions.get(name)) = @@ -786,8 +792,10 @@ impl<'a, 'b> Context<'a, 'b> { "x" => "secret_lower_hex", "X" => "secret_upper_hex", _ => { - self.ecx.span_err(sp, format!("unknown format trait `{}`", - *tyname)); + self.ecx + .span_err(sp, + format!("unknown format trait `{}`", + *tyname).as_slice()); "dummy" } } diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs index b3eec136c7d69..bb3a88f44e4bb 100644 --- a/src/libsyntax/ext/quote.rs +++ b/src/libsyntax/ext/quote.rs @@ -436,7 +436,7 @@ fn mk_token(cx: &ExtCtxt, sp: Span, tok: &token::Token) -> @ast::Expr { ast::TyI32 => "TyI32".to_owned(), ast::TyI64 => "TyI64".to_owned() }; - let e_ity = cx.expr_ident(sp, id_ext(s_ity)); + let e_ity = cx.expr_ident(sp, id_ext(s_ity.as_slice())); let e_i64 = cx.expr_lit(sp, ast::LitInt(i, ast::TyI64)); @@ -453,7 +453,7 @@ fn mk_token(cx: &ExtCtxt, sp: Span, tok: &token::Token) -> @ast::Expr { ast::TyU32 => "TyU32".to_owned(), ast::TyU64 => "TyU64".to_owned() }; - let e_uty = cx.expr_ident(sp, id_ext(s_uty)); + let e_uty = cx.expr_ident(sp, id_ext(s_uty.as_slice())); let e_u64 = cx.expr_lit(sp, ast::LitUint(u, ast::TyU64)); @@ -476,7 +476,7 @@ fn mk_token(cx: &ExtCtxt, sp: Span, tok: &token::Token) -> @ast::Expr { ast::TyF64 => "TyF64".to_owned(), ast::TyF128 => "TyF128".to_owned() }; - let e_fty = cx.expr_ident(sp, id_ext(s_fty)); + let e_fty = cx.expr_ident(sp, id_ext(s_fty.as_slice())); let e_fident = mk_ident(cx, sp, fident); diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs index 6bc08741c079a..452719d2dd881 100644 --- a/src/libsyntax/ext/source_util.rs +++ b/src/libsyntax/ext/source_util.rs @@ -76,7 +76,9 @@ pub fn expand_mod(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) .map(|x| token::get_ident(*x).get().to_strbuf()) .collect::>() .connect("::"); - base::MacExpr::new(cx.expr_str(sp, token::intern_and_get_ident(string))) + base::MacExpr::new(cx.expr_str( + sp, + token::intern_and_get_ident(string.as_slice()))) } // include! : parse the given file as an expr @@ -111,7 +113,10 @@ pub fn expand_include_str(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) let file = res_rel_file(cx, sp, &Path::new(file)); let bytes = match File::open(&file).read_to_end() { Err(e) => { - cx.span_err(sp, format!("couldn't read {}: {}", file.display(), e)); + cx.span_err(sp, + format!("couldn't read {}: {}", + file.display(), + e).as_slice()); return DummyResult::expr(sp); } Ok(bytes) => bytes, @@ -127,7 +132,9 @@ pub fn expand_include_str(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) base::MacExpr::new(cx.expr_str(sp, interned)) } None => { - cx.span_err(sp, format!("{} wasn't a utf-8 file", file.display())); + cx.span_err(sp, + format!("{} wasn't a utf-8 file", + file.display()).as_slice()); return DummyResult::expr(sp); } } @@ -142,7 +149,10 @@ pub fn expand_include_bin(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) let file = res_rel_file(cx, sp, &Path::new(file)); match File::open(&file).read_to_end() { Err(e) => { - cx.span_err(sp, format!("couldn't read {}: {}", file.display(), e)); + cx.span_err(sp, + format!("couldn't read {}: {}", + file.display(), + e).as_slice()); return DummyResult::expr(sp); } Ok(bytes) => { diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs index 89e8d48425f6c..ce1c7da585f6e 100644 --- a/src/libsyntax/ext/tt/macro_parser.rs +++ b/src/libsyntax/ext/tt/macro_parser.rs @@ -188,7 +188,9 @@ pub fn nameize(p_s: &ParseSess, ms: &[Matcher], res: &[Rc]) if ret_val.contains_key(&bind_name) { let string = token::get_ident(bind_name); p_s.span_diagnostic - .span_fatal(span, "duplicated bind name: " + string.get()) + .span_fatal(span, + format!("duplicated bind name: {}", + string.get()).as_slice()) } ret_val.insert(bind_name, res[idx].clone()); } @@ -455,6 +457,9 @@ pub fn parse_nt(p: &mut Parser, name: &str) -> Nonterminal { res } "matchers" => token::NtMatchers(p.parse_matchers()), - _ => p.fatal("unsupported builtin nonterminal parser: ".to_owned() + name) + _ => { + p.fatal(format!("unsupported builtin nonterminal parser: {}", + name).as_slice()) + } } } diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs index 7ff690582d680..f234b0c234d16 100644 --- a/src/libsyntax/ext/tt/macro_rules.rs +++ b/src/libsyntax/ext/tt/macro_rules.rs @@ -52,7 +52,7 @@ impl<'a> ParserAnyMacro<'a> { following", token_str); let span = parser.span; - parser.span_err(span, msg); + parser.span_err(span, msg.as_slice()); } } } diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs index 1f264e73d4aa3..6d799eeae6c75 100644 --- a/src/libsyntax/ext/tt/transcribe.rs +++ b/src/libsyntax/ext/tt/transcribe.rs @@ -89,9 +89,10 @@ fn lookup_cur_matched(r: &TtReader, name: Ident) -> Rc { match matched_opt { Some(s) => lookup_cur_matched_by_matched(r, s), None => { - r.sp_diag.span_fatal(r.cur_span, - format!("unknown macro variable `{}`", - token::get_ident(name))); + r.sp_diag + .span_fatal(r.cur_span, + format!("unknown macro variable `{}`", + token::get_ident(name)).as_slice()); } } } @@ -269,7 +270,7 @@ pub fn tt_next_token(r: &mut TtReader) -> TokenAndSpan { r.sp_diag.span_fatal( r.cur_span, /* blame the macro writer */ format!("variable '{}' is still repeating at this depth", - token::get_ident(ident))); + token::get_ident(ident)).as_slice()); } } } diff --git a/src/libsyntax/parse/attr.rs b/src/libsyntax/parse/attr.rs index 80ee459a62d6f..6f17412fa6385 100644 --- a/src/libsyntax/parse/attr.rs +++ b/src/libsyntax/parse/attr.rs @@ -88,7 +88,7 @@ impl<'a> ParserAttr for Parser<'a> { _ => { let token_str = self.this_token_to_str(); self.fatal(format!("expected `\\#` but found `{}`", - token_str)); + token_str).as_slice()); } }; diff --git a/src/libsyntax/parse/lexer.rs b/src/libsyntax/parse/lexer.rs index c78d2aaf3a7e8..5a7a816dbb3e0 100644 --- a/src/libsyntax/parse/lexer.rs +++ b/src/libsyntax/parse/lexer.rs @@ -589,13 +589,13 @@ fn scan_number(c: char, rdr: &mut StringReader) -> token::Token { bump(rdr); bump(rdr); check_float_base(rdr, start_bpos, rdr.last_pos, base); - return token::LIT_FLOAT(str_to_ident(num_str.into_owned()), + return token::LIT_FLOAT(str_to_ident(num_str.as_slice()), ast::TyF32); } else if c == '6' && n == '4' { bump(rdr); bump(rdr); check_float_base(rdr, start_bpos, rdr.last_pos, base); - return token::LIT_FLOAT(str_to_ident(num_str.into_owned()), + return token::LIT_FLOAT(str_to_ident(num_str.as_slice()), ast::TyF64); /* FIXME (#2252): if this is out of range for either a 32-bit or 64-bit float, it won't be noticed till the @@ -612,8 +612,7 @@ fn scan_number(c: char, rdr: &mut StringReader) -> token::Token { } if is_float { check_float_base(rdr, start_bpos, rdr.last_pos, base); - return token::LIT_FLOAT_UNSUFFIXED(str_to_ident( - num_str.into_owned())); + return token::LIT_FLOAT_UNSUFFIXED(str_to_ident(num_str.as_slice())); } else { if num_str.len() == 0u { fatal_span(rdr, start_bpos, rdr.last_pos, diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index 8e139b049c590..31a67ff92f5c0 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -224,7 +224,9 @@ pub fn file_to_filemap(sess: &ParseSess, path: &Path, spanopt: Option) let bytes = match File::open(path).read_to_end() { Ok(bytes) => bytes, Err(e) => { - err(format!("couldn't read {}: {}", path.display(), e)); + err(format!("couldn't read {}: {}", + path.display(), + e).as_slice()); unreachable!() } }; @@ -233,7 +235,9 @@ pub fn file_to_filemap(sess: &ParseSess, path: &Path, spanopt: Option) return string_to_filemap(sess, s.to_strbuf(), path.as_str().unwrap().to_strbuf()) } - None => err(format!("{} is not UTF-8 encoded", path.display())), + None => { + err(format!("{} is not UTF-8 encoded", path.display()).as_slice()) + } } unreachable!() } diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs index b6aa47128e630..394b68d4a72e7 100644 --- a/src/libsyntax/parse/obsolete.rs +++ b/src/libsyntax/parse/obsolete.rs @@ -158,10 +158,14 @@ impl<'a> ParserObsoleteMethods for Parser<'a> { kind: ObsoleteSyntax, kind_str: &str, desc: &str) { - self.span_err(sp, format!("obsolete syntax: {}", kind_str)); + self.span_err(sp, + format!("obsolete syntax: {}", kind_str).as_slice()); if !self.obsolete_set.contains(&kind) { - self.sess.span_diagnostic.handler().note(format!("{}", desc)); + self.sess + .span_diagnostic + .handler() + .note(format!("{}", desc).as_slice()); self.obsolete_set.insert(kind); } } diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 5829f63b2c531..4897fed692812 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -371,12 +371,12 @@ impl<'a> Parser<'a> { pub fn unexpected_last(&mut self, t: &token::Token) -> ! { let token_str = Parser::token_to_str(t); self.span_fatal(self.last_span, format!("unexpected token: `{}`", - token_str)); + token_str).as_slice()); } pub fn unexpected(&mut self) -> ! { let this_token = self.this_token_to_str(); - self.fatal(format!("unexpected token: `{}`", this_token)); + self.fatal(format!("unexpected token: `{}`", this_token).as_slice()); } // expect and consume the token t. Signal an error if @@ -389,7 +389,7 @@ impl<'a> Parser<'a> { let this_token_str = self.this_token_to_str(); self.fatal(format!("expected `{}` but found `{}`", token_str, - this_token_str)) + this_token_str).as_slice()) } } @@ -420,11 +420,15 @@ impl<'a> Parser<'a> { let expect = tokens_to_str(expected.as_slice()); let actual = self.this_token_to_str(); self.fatal( - if expected.len() != 1 { - format!("expected one of `{}` but found `{}`", expect, actual) + (if expected.len() != 1 { + (format!("expected one of `{}` but found `{}`", + expect, + actual)) } else { - format!("expected `{}` but found `{}`", expect, actual) - } + (format!("expected `{}` but found `{}`", + expect, + actual)) + }).as_slice() ) } } @@ -501,7 +505,8 @@ impl<'a> Parser<'a> { } _ => { let token_str = self.this_token_to_str(); - self.fatal(format!( "expected ident, found `{}`", token_str)) + self.fatal((format!("expected ident, found `{}`", + token_str)).as_slice()) } } } @@ -545,7 +550,7 @@ impl<'a> Parser<'a> { let id_interned_str = token::get_ident(kw.to_ident()); let token_str = self.this_token_to_str(); self.fatal(format!("expected `{}`, found `{}`", - id_interned_str, token_str)) + id_interned_str, token_str).as_slice()) } } @@ -554,7 +559,8 @@ impl<'a> Parser<'a> { if token::is_strict_keyword(&self.token) { let token_str = self.this_token_to_str(); self.span_err(self.span, - format!("found `{}` in ident position", token_str)); + format!("found `{}` in ident position", + token_str).as_slice()); } } @@ -562,7 +568,8 @@ impl<'a> Parser<'a> { pub fn check_reserved_keywords(&mut self) { if token::is_reserved_keyword(&self.token) { let token_str = self.this_token_to_str(); - self.fatal(format!("`{}` is a reserved keyword", token_str)) + self.fatal(format!("`{}` is a reserved keyword", + token_str).as_slice()) } } @@ -581,7 +588,7 @@ impl<'a> Parser<'a> { Parser::token_to_str(&token::BINOP(token::AND)); self.fatal(format!("expected `{}`, found `{}`", found_token, - token_str)) + token_str).as_slice()) } } } @@ -600,7 +607,8 @@ impl<'a> Parser<'a> { let token_str = Parser::token_to_str(&token::BINOP(token::OR)); self.fatal(format!("expected `{}`, found `{}`", - token_str, found_token)) + token_str, + found_token).as_slice()) } } } @@ -650,7 +658,8 @@ impl<'a> Parser<'a> { let found_token = self.this_token_to_str(); let token_str = Parser::token_to_str(&token::LT); self.fatal(format!("expected `{}`, found `{}`", - token_str, found_token)) + token_str, + found_token).as_slice()) } } @@ -690,7 +699,7 @@ impl<'a> Parser<'a> { let this_token_str = self.this_token_to_str(); self.fatal(format!("expected `{}`, found `{}`", gt_str, - this_token_str)) + this_token_str).as_slice()) } } } @@ -1186,8 +1195,8 @@ impl<'a> Parser<'a> { _ => { let token_str = p.this_token_to_str(); - p.fatal(format!("expected `;` or `\\{` but found `{}`", - token_str)) + p.fatal((format!("expected `;` or `\\{` but found `{}`", + token_str)).as_slice()) } } }) @@ -1359,7 +1368,7 @@ impl<'a> Parser<'a> { TyInfer } else { let msg = format!("expected type, found token {:?}", self.token); - self.fatal(msg); + self.fatal(msg.as_slice()); }; let sp = mk_sp(lo, self.last_span.hi); @@ -1631,7 +1640,7 @@ impl<'a> Parser<'a> { }; } _ => { - self.fatal(format!("expected a lifetime name")); + self.fatal(format!("expected a lifetime name").as_slice()); } } } @@ -1667,7 +1676,7 @@ impl<'a> Parser<'a> { let msg = format!("expected `,` or `>` after lifetime \ name, got: {:?}", self.token); - self.fatal(msg); + self.fatal(msg.as_slice()); } } } @@ -2122,7 +2131,7 @@ impl<'a> Parser<'a> { }; let token_str = p.this_token_to_str(); p.fatal(format!("incorrect close delimiter: `{}`", - token_str)) + token_str).as_slice()) }, /* we ought to allow different depths of unquotation */ token::DOLLAR if p.quote_depth > 0u => { @@ -2773,7 +2782,7 @@ impl<'a> Parser<'a> { if self.token != token::RBRACE { let token_str = self.this_token_to_str(); self.fatal(format!("expected `\\}`, found `{}`", - token_str)) + token_str).as_slice()) } etc = true; break; @@ -2793,7 +2802,8 @@ impl<'a> Parser<'a> { match bind_type { BindByRef(..) | BindByValue(MutMutable) => { let token_str = self.this_token_to_str(); - self.fatal(format!("unexpected `{}`", token_str)) + self.fatal(format!("unexpected `{}`", + token_str).as_slice()) } _ => {} } @@ -3202,7 +3212,8 @@ impl<'a> Parser<'a> { }; let tok_str = self.this_token_to_str(); self.fatal(format!("expected {}`(` or `\\{`, but found `{}`", - ident_str, tok_str)) + ident_str, + tok_str).as_slice()) } }; @@ -3606,7 +3617,8 @@ impl<'a> Parser<'a> { fn expect_self_ident(&mut self) { if !self.is_self_ident() { let token_str = self.this_token_to_str(); - self.fatal(format!("expected `self` but found `{}`", token_str)) + self.fatal(format!("expected `self` but found `{}`", + token_str).as_slice()) } self.bump(); } @@ -3738,7 +3750,7 @@ impl<'a> Parser<'a> { _ => { let token_str = self.this_token_to_str(); self.fatal(format!("expected `,` or `)`, found `{}`", - token_str)) + token_str).as_slice()) } } } else { @@ -4005,8 +4017,9 @@ impl<'a> Parser<'a> { fields.push(self.parse_struct_decl_field()); } if fields.len() == 0 { - self.fatal(format!("unit-like struct definition should be written as `struct {};`", - token::get_ident(class_name))); + self.fatal(format!("unit-like struct definition should be \ + written as `struct {};`", + token::get_ident(class_name)).as_slice()); } self.bump(); } else if self.token == token::LPAREN { @@ -4036,7 +4049,7 @@ impl<'a> Parser<'a> { let token_str = self.this_token_to_str(); self.fatal(format!("expected `\\{`, `(`, or `;` after struct \ name but found `{}`", - token_str)) + token_str).as_slice()) } let _ = ast::DUMMY_NODE_ID; // FIXME: Workaround for crazy bug. @@ -4066,7 +4079,7 @@ impl<'a> Parser<'a> { let token_str = self.this_token_to_str(); self.span_fatal(self.span, format!("expected `,`, or `\\}` but found `{}`", - token_str)) + token_str).as_slice()) } } a_var @@ -4147,7 +4160,7 @@ impl<'a> Parser<'a> { _ => { let token_str = self.this_token_to_str(); self.fatal(format!("expected item but found `{}`", - token_str)) + token_str).as_slice()) } } } @@ -4229,8 +4242,8 @@ impl<'a> Parser<'a> { Some(d) => (dir_path.join(d), true), None => { let mod_name = mod_string.get().to_owned(); - let default_path_str = mod_name + ".rs"; - let secondary_path_str = mod_name + "/mod.rs"; + let default_path_str = format!("{}.rs", mod_name); + let secondary_path_str = format!("{}/mod.rs", mod_name); let default_path = dir_path.join(default_path_str.as_slice()); let secondary_path = dir_path.join(secondary_path_str.as_slice()); let default_exists = default_path.exists(); @@ -4246,12 +4259,14 @@ impl<'a> Parser<'a> { self.span_note(id_sp, format!("maybe move this module `{0}` \ to its own directory via \ - `{0}/mod.rs`", this_module)); + `{0}/mod.rs`", + this_module).as_slice()); if default_exists || secondary_exists { self.span_note(id_sp, format!("... or maybe `use` the module \ `{}` instead of possibly \ - redeclaring it", mod_name)); + redeclaring it", + mod_name).as_slice()); } self.abort_if_errors(); } @@ -4260,12 +4275,19 @@ impl<'a> Parser<'a> { (true, false) => (default_path, false), (false, true) => (secondary_path, true), (false, false) => { - self.span_fatal(id_sp, format!("file not found for module `{}`", mod_name)); + self.span_fatal(id_sp, + format!("file not found for module \ + `{}`", + mod_name).as_slice()); } (true, true) => { - self.span_fatal(id_sp, - format!("file for module `{}` found at both {} and {}", - mod_name, default_path_str, secondary_path_str)); + self.span_fatal( + id_sp, + format!("file for module `{}` found at both {} \ + and {}", + mod_name, + default_path_str, + secondary_path_str).as_slice()); } } } @@ -4290,7 +4312,7 @@ impl<'a> Parser<'a> { err.push_str(" -> "); } err.push_str(path.display().as_maybe_owned().as_slice()); - self.span_fatal(id_sp, err.into_owned()); + self.span_fatal(id_sp, err.as_slice()); } None => () } @@ -4348,12 +4370,14 @@ impl<'a> Parser<'a> { let ty = self.parse_ty(false); let hi = self.span.hi; self.expect(&token::SEMI); - @ast::ForeignItem { ident: ident, - attrs: attrs, - node: ForeignItemStatic(ty, mutbl), - id: ast::DUMMY_NODE_ID, - span: mk_sp(lo, hi), - vis: vis } + @ast::ForeignItem { + ident: ident, + attrs: attrs, + node: ForeignItemStatic(ty, mutbl), + id: ast::DUMMY_NODE_ID, + span: mk_sp(lo, hi), + vis: vis, + } } // parse safe/unsafe and fn @@ -4418,8 +4442,9 @@ impl<'a> Parser<'a> { _ => { let token_str = self.this_token_to_str(); self.span_fatal(self.span, - format!("expected extern crate name but found `{}`", - token_str)); + format!("expected extern crate name but \ + found `{}`", + token_str).as_slice()); } }; @@ -4586,11 +4611,10 @@ impl<'a> Parser<'a> { None => { self.span_err( self.span, - format!("illegal ABI: \ - expected one of [{}], \ - found `{}`", - abi::all_names().connect(", "), - the_string)); + format!("illegal ABI: expected one of [{}], \ + found `{}`", + abi::all_names().connect(", "), + the_string).as_slice()); None } } @@ -4645,7 +4669,8 @@ impl<'a> Parser<'a> { self.span_err(mk_sp(lo, self.last_span.hi), format!("`extern mod` is obsolete, use \ `extern crate` instead \ - to refer to external crates.")) + to refer to external \ + crates.").as_slice()) } return self.parse_item_extern_crate(lo, visibility, attrs); } @@ -4670,7 +4695,8 @@ impl<'a> Parser<'a> { let token_str = self.this_token_to_str(); self.span_fatal(self.span, - format!("expected `\\{` or `fn` but found `{}`", token_str)); + format!("expected `\\{` or `fn` but found `{}`", + token_str).as_slice()); } let is_virtual = self.eat_keyword(keywords::Virtual); @@ -5076,7 +5102,8 @@ impl<'a> Parser<'a> { } ViewItemExternCrate(..) if !extern_mod_allowed => { self.span_err(view_item.span, - "\"extern crate\" declarations are not allowed here"); + "\"extern crate\" declarations are \ + not allowed here"); } ViewItemExternCrate(..) => {} } diff --git a/src/libsyntax/print/pp.rs b/src/libsyntax/print/pp.rs index f08cf264f8bfb..b334aa632706e 100644 --- a/src/libsyntax/print/pp.rs +++ b/src/libsyntax/print/pp.rs @@ -135,7 +135,9 @@ pub fn buf_str(toks: Vec, if i != left { s.push_str(", "); } - s.push_str(format!("{}={}", szs.get(i), tok_str(toks.get(i).clone()))); + s.push_str(format!("{}={}", + szs.get(i), + tok_str(toks.get(i).clone())).as_slice()); i += 1u; i %= n; } diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 15b931d58545e..5500ca4575306 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -141,7 +141,8 @@ pub fn to_str(f: |&mut State| -> IoResult<()>) -> StrBuf { // that we "know" to be a `MemWriter` that works around the lack of checked // downcasts. let (_, wr): (uint, Box) = mem::transmute_copy(&s.s.out); - let result = str::from_utf8_owned(wr.get_ref().to_owned()).unwrap(); + let result = + str::from_utf8_owned(Vec::from_slice(wr.get_ref())).unwrap(); mem::forget(wr); result.to_strbuf() } @@ -623,7 +624,7 @@ impl<'a> State<'a> { } ast::ItemForeignMod(ref nmod) => { try!(self.head("extern")); - try!(self.word_nbsp(nmod.abi.to_str())); + try!(self.word_nbsp(nmod.abi.to_str().as_slice())); try!(self.bopen()); try!(self.print_foreign_mod(nmod, item.attrs.as_slice())); try!(self.bclose(item.span)); @@ -2234,7 +2235,7 @@ impl<'a> State<'a> { let mut res = StrBuf::from_str("'"); ch.escape_default(|c| res.push_char(c)); res.push_char('\''); - word(&mut self.s, res.into_owned()) + word(&mut self.s, res.as_slice()) } ast::LitInt(i, t) => { word(&mut self.s, @@ -2247,11 +2248,14 @@ impl<'a> State<'a> { ast_util::ForceSuffix).as_slice()) } ast::LitIntUnsuffixed(i) => { - word(&mut self.s, format!("{}", i)) + word(&mut self.s, format!("{}", i).as_slice()) } ast::LitFloat(ref f, t) => { word(&mut self.s, - f.get() + ast_util::float_ty_to_str(t).as_slice()) + format!( + "{}{}", + f.get(), + ast_util::float_ty_to_str(t).as_slice()).as_slice()) } ast::LitFloatUnsuffixed(ref f) => word(&mut self.s, f.get()), ast::LitNil => word(&mut self.s, "()"), @@ -2261,8 +2265,13 @@ impl<'a> State<'a> { ast::LitBinary(ref arr) => { try!(self.ibox(indent_unit)); try!(word(&mut self.s, "[")); - try!(self.commasep_cmnt(Inconsistent, arr.as_slice(), - |s, u| word(&mut s.s, format!("{}", *u)), + try!(self.commasep_cmnt(Inconsistent, + arr.as_slice(), + |s, u| { + word(&mut s.s, + format!("{}", + *u).as_slice()) + }, |_| lit.span)); try!(word(&mut self.s, "]")); self.end() @@ -2354,11 +2363,16 @@ impl<'a> State<'a> { pub fn print_string(&mut self, st: &str, style: ast::StrStyle) -> IoResult<()> { let st = match style { - ast::CookedStr => format!("\"{}\"", st.escape_default()), - ast::RawStr(n) => format!("r{delim}\"{string}\"{delim}", - delim="#".repeat(n), string=st) + ast::CookedStr => { + (format!("\"{}\"", st.escape_default())) + } + ast::RawStr(n) => { + (format!("r{delim}\"{string}\"{delim}", + delim="#".repeat(n), + string=st)) + } }; - word(&mut self.s, st) + word(&mut self.s, st.as_slice()) } pub fn next_comment(&mut self) -> Option { @@ -2389,7 +2403,7 @@ impl<'a> State<'a> { Some(abi::Rust) => Ok(()), Some(abi) => { try!(self.word_nbsp("extern")); - self.word_nbsp(abi.to_str()) + self.word_nbsp(abi.to_str().as_slice()) } None => Ok(()) } @@ -2400,7 +2414,7 @@ impl<'a> State<'a> { match opt_abi { Some(abi) => { try!(self.word_nbsp("extern")); - self.word_nbsp(abi.to_str()) + self.word_nbsp(abi.to_str().as_slice()) } None => Ok(()) } @@ -2416,7 +2430,7 @@ impl<'a> State<'a> { if abi != abi::Rust { try!(self.word_nbsp("extern")); - try!(self.word_nbsp(abi.to_str())); + try!(self.word_nbsp(abi.to_str().as_slice())); } word(&mut self.s, "fn") diff --git a/src/libterm/terminfo/mod.rs b/src/libterm/terminfo/mod.rs index 36e5c1cf763a6..7562bf2d163dc 100644 --- a/src/libterm/terminfo/mod.rs +++ b/src/libterm/terminfo/mod.rs @@ -81,9 +81,11 @@ impl Terminal for TerminfoTerminal { } }; - let entry = open(term); + let entry = open(term.as_slice()); if entry.is_err() { - if os::getenv("MSYSCON").map_or(false, |s| "mintty.exe" == s) { + if os::getenv("MSYSCON").map_or(false, |s| { + "mintty.exe" == s.as_slice() + }) { // msys terminal return Some(TerminfoTerminal {out: out, ti: msys_terminfo(), num_colors: 8}); } diff --git a/src/libterm/terminfo/parser/compiled.rs b/src/libterm/terminfo/parser/compiled.rs index 5a1c8ea02e221..687e27f4282a9 100644 --- a/src/libterm/terminfo/parser/compiled.rs +++ b/src/libterm/terminfo/parser/compiled.rs @@ -221,7 +221,8 @@ pub fn parse(file: &mut io::Reader, longnames: bool) None => return Err("input not utf-8".to_strbuf()), }; - let term_names: Vec = names_str.split('|') + let term_names: Vec = names_str.as_slice() + .split('|') .map(|s| s.to_strbuf()) .collect(); diff --git a/src/libterm/terminfo/searcher.rs b/src/libterm/terminfo/searcher.rs index a7365102f96ca..ac5737c46ed41 100644 --- a/src/libterm/terminfo/searcher.rs +++ b/src/libterm/terminfo/searcher.rs @@ -36,11 +36,11 @@ pub fn get_dbpath_for_term(term: &str) -> Option> { dirs_to_search.push(homedir.unwrap().join(".terminfo")) } match getenv("TERMINFO_DIRS") { - Some(dirs) => for i in dirs.split(':') { + Some(dirs) => for i in dirs.as_slice().split(':') { if i == "" { dirs_to_search.push(Path::new("/usr/share/terminfo")); } else { - dirs_to_search.push(Path::new(i.to_owned())); + dirs_to_search.push(Path::new(i.to_strbuf())); } }, // Found nothing in TERMINFO_DIRS, use the default paths: diff --git a/src/libtest/lib.rs b/src/libtest/lib.rs index 06b1126ed05b5..1f10956b38015 100644 --- a/src/libtest/lib.rs +++ b/src/libtest/lib.rs @@ -355,7 +355,8 @@ Test Attributes: normal test runs. Running with --ignored will run these tests. This may also be written as \#[ignore(cfg(...))] to ignore the test on certain configurations.", - usage = getopts::usage(message, optgroups().as_slice())); + usage = getopts::usage(message.as_slice(), + optgroups().as_slice())); } // Parses command line arguments into test options @@ -568,13 +569,13 @@ impl ConsoleTestState { pub fn write_run_start(&mut self, len: uint) -> io::IoResult<()> { self.total = len; let noun = if len != 1 { "tests" } else { "test" }; - self.write_plain(format!("\nrunning {} {}\n", len, noun)) + self.write_plain(format!("\nrunning {} {}\n", len, noun).as_slice()) } pub fn write_test_start(&mut self, test: &TestDesc, align: NamePadding) -> io::IoResult<()> { let name = test.padded_name(self.max_name_len, align); - self.write_plain(format!("test {} ... ", name)) + self.write_plain(format!("test {} ... ", name).as_slice()) } pub fn write_result(&mut self, result: &TestResult) -> io::IoResult<()> { @@ -584,11 +585,12 @@ impl ConsoleTestState { TrIgnored => self.write_ignored(), TrMetrics(ref mm) => { try!(self.write_metric()); - self.write_plain(format!(": {}", fmt_metrics(mm))) + self.write_plain(format!(": {}", fmt_metrics(mm)).as_slice()) } TrBench(ref bs) => { try!(self.write_bench()); - self.write_plain(format!(": {}", fmt_bench_samples(bs))) + self.write_plain(format!(": {}", + fmt_bench_samples(bs)).as_slice()) } }); self.write_plain("\n") @@ -619,9 +621,11 @@ impl ConsoleTestState { failures.push(f.name.to_str()); if stdout.len() > 0 { fail_out.push_str(format!("---- {} stdout ----\n\t", - f.name.as_slice())); + f.name.as_slice()).as_slice()); let output = str::from_utf8_lossy(stdout.as_slice()); - fail_out.push_str(output.as_slice().replace("\n", "\n\t")); + fail_out.push_str(output.as_slice() + .replace("\n", "\n\t") + .as_slice()); fail_out.push_str("\n"); } } @@ -633,7 +637,8 @@ impl ConsoleTestState { try!(self.write_plain("\nfailures:\n")); failures.as_mut_slice().sort(); for name in failures.iter() { - try!(self.write_plain(format!(" {}\n", name.as_slice()))); + try!(self.write_plain(format!(" {}\n", + name.as_slice()).as_slice())); } Ok(()) } @@ -651,24 +656,26 @@ impl ConsoleTestState { MetricAdded => { added += 1; try!(self.write_added()); - try!(self.write_plain(format!(": {}\n", *k))); + try!(self.write_plain(format!(": {}\n", *k).as_slice())); } MetricRemoved => { removed += 1; try!(self.write_removed()); - try!(self.write_plain(format!(": {}\n", *k))); + try!(self.write_plain(format!(": {}\n", *k).as_slice())); } Improvement(pct) => { improved += 1; - try!(self.write_plain(format!(": {}", *k))); + try!(self.write_plain(format!(": {}", *k).as_slice())); try!(self.write_improved()); - try!(self.write_plain(format!(" by {:.2f}%\n", pct as f64))); + try!(self.write_plain(format!(" by {:.2f}%\n", + pct as f64).as_slice())); } Regression(pct) => { regressed += 1; - try!(self.write_plain(format!(": {}", *k))); + try!(self.write_plain(format!(": {}", *k).as_slice())); try!(self.write_regressed()); - try!(self.write_plain(format!(" by {:.2f}%\n", pct as f64))); + try!(self.write_plain(format!(" by {:.2f}%\n", + pct as f64).as_slice())); } } } @@ -676,7 +683,7 @@ impl ConsoleTestState { {} removed, {} improved, {} regressed, \ {} noise\n", added, removed, improved, regressed, - noise))); + noise).as_slice())); if regressed == 0 { try!(self.write_plain("updated ratchet file\n")); } else { @@ -694,13 +701,13 @@ impl ConsoleTestState { None => true, Some(ref pth) => { try!(self.write_plain(format!("\nusing metrics ratchet: {}\n", - pth.display()))); + pth.display()).as_slice())); match ratchet_pct { None => (), Some(pct) => try!(self.write_plain(format!("with noise-tolerance \ forced to: {}%\n", - pct))) + pct).as_slice())) } let (diff, ok) = self.metrics.ratchet(pth, ratchet_pct); try!(self.write_metric_diff(&diff)); @@ -724,7 +731,7 @@ impl ConsoleTestState { } let s = format!(". {} passed; {} failed; {} ignored; {} measured\n\n", self.passed, self.failed, self.ignored, self.measured); - try!(self.write_plain(s)); + try!(self.write_plain(s.as_slice())); return Ok(success); } } @@ -771,7 +778,9 @@ pub fn run_tests_console(opts: &TestOpts, tests: Vec ) -> io::IoR let MetricMap(mm) = mm; for (k,v) in mm.iter() { st.metrics - .insert_metric(tname + "." + k.as_slice(), + .insert_metric(format!("{}.{}", + tname, + k).as_slice(), v.value, v.noise); } @@ -813,7 +822,7 @@ pub fn run_tests_console(opts: &TestOpts, tests: Vec ) -> io::IoR Some(ref pth) => { try!(st.metrics.save(pth)); try!(st.write_plain(format!("\nmetrics saved to: {}", - pth.display()))); + pth.display()).as_slice())); } } return st.write_run_finish(&opts.ratchet_metrics, opts.ratchet_noise_percent); @@ -936,7 +945,7 @@ fn get_concurrency() -> uint { use std::rt; match os::getenv("RUST_TEST_TASKS") { Some(s) => { - let opt_n: Option = FromStr::from_str(s); + let opt_n: Option = FromStr::from_str(s.as_slice()); match opt_n { Some(n) if n > 0 => n, _ => fail!("RUST_TEST_TASKS is `{}`, should be a positive integer.", s) diff --git a/src/libtime/lib.rs b/src/libtime/lib.rs index 0e67076dc08e3..8f47a7ce2cb2a 100644 --- a/src/libtime/lib.rs +++ b/src/libtime/lib.rs @@ -237,21 +237,11 @@ pub struct Tm { /// for U.S. Pacific Daylight Time, the value is -7*60*60 = -25200. pub tm_gmtoff: i32, - /// Abbreviated name for the time zone that was used to compute this broken-down time value. - /// For example, U.S. Pacific Daylight Time is "PDT". - pub tm_zone: ~str, - /// Nanoseconds after the second – [0, 109 - 1] pub tm_nsec: i32, } pub fn empty_tm() -> Tm { - // 64 is the max size of the timezone buffer allocated on windows - // in rust_localtime. In glibc the max timezone size is supposedly 3. - let mut zone = StrBuf::new(); - for _ in range(0, 64) { - zone.push_char(' ') - } Tm { tm_sec: 0_i32, tm_min: 0_i32, @@ -263,7 +253,6 @@ pub fn empty_tm() -> Tm { tm_yday: 0_i32, tm_isdst: 0_i32, tm_gmtoff: 0_i32, - tm_zone: zone.into_owned(), tm_nsec: 0_i32, } } @@ -745,7 +734,6 @@ pub fn strptime(s: &str, format: &str) -> Result { 'Z' => { if match_str(s, pos, "UTC") || match_str(s, pos, "GMT") { tm.tm_gmtoff = 0_i32; - tm.tm_zone = "UTC".to_owned(); Ok(pos + 3u) } else { // It's odd, but to maintain compatibility with c's @@ -770,7 +758,6 @@ pub fn strptime(s: &str, format: &str) -> Result { let (v, pos) = item; if v == 0_i32 { tm.tm_gmtoff = 0_i32; - tm.tm_zone = "UTC".to_owned(); } Ok(pos) @@ -801,7 +788,6 @@ pub fn strptime(s: &str, format: &str) -> Result { tm_yday: 0_i32, tm_isdst: 0_i32, tm_gmtoff: 0_i32, - tm_zone: "".to_owned(), tm_nsec: 0_i32, }; let mut pos = 0u; @@ -848,7 +834,6 @@ pub fn strptime(s: &str, format: &str) -> Result { tm_yday: tm.tm_yday, tm_isdst: tm.tm_isdst, tm_gmtoff: tm.tm_gmtoff, - tm_zone: tm.tm_zone.clone(), tm_nsec: tm.tm_nsec, }) } else { result } @@ -1050,7 +1035,7 @@ pub fn strftime(format: &str, tm: &Tm) -> StrBuf { 'w' => (tm.tm_wday as int).to_str().to_strbuf(), 'Y' => (tm.tm_year as int + 1900).to_str().to_strbuf(), 'y' => format_strbuf!("{:02d}", (tm.tm_year as int + 1900) % 100), - 'Z' => tm.tm_zone.to_strbuf(), + 'Z' => "".to_strbuf(), // FIXME(pcwalton): Implement this. 'z' => { let sign = if tm.tm_gmtoff > 0_i32 { '+' } else { '-' }; let mut m = num::abs(tm.tm_gmtoff) / 60_i32; @@ -1176,7 +1161,6 @@ mod tests { assert_eq!(utc.tm_yday, 43_i32); assert_eq!(utc.tm_isdst, 0_i32); assert_eq!(utc.tm_gmtoff, 0_i32); - assert_eq!(utc.tm_zone, "UTC".to_owned()); assert_eq!(utc.tm_nsec, 54321_i32); } @@ -1198,12 +1182,6 @@ mod tests { assert_eq!(local.tm_yday, 43_i32); assert_eq!(local.tm_isdst, 0_i32); assert_eq!(local.tm_gmtoff, -28800_i32); - - // FIXME (#2350): We should probably standardize on the timezone - // abbreviation. - let zone = &local.tm_zone; - assert!(*zone == "PST".to_owned() || *zone == "Pacific Standard Time".to_owned()); - assert_eq!(local.tm_nsec, 54321_i32); } @@ -1246,7 +1224,6 @@ mod tests { assert!(tm.tm_wday == 0_i32); assert!(tm.tm_isdst == 0_i32); assert!(tm.tm_gmtoff == 0_i32); - assert!(tm.tm_zone == "".to_owned()); assert!(tm.tm_nsec == 0_i32); } Err(_) => () @@ -1270,7 +1247,6 @@ mod tests { assert!(tm.tm_yday == 0_i32); assert!(tm.tm_isdst == 0_i32); assert!(tm.tm_gmtoff == 0_i32); - assert!(tm.tm_zone == "".to_owned()); assert!(tm.tm_nsec == 12340000_i32); } } @@ -1382,10 +1358,6 @@ mod tests { assert!(test("6", "%w")); assert!(test("2009", "%Y")); assert!(test("09", "%y")); - assert!(strptime("UTC", "%Z").unwrap().tm_zone == - "UTC".to_owned()); - assert!(strptime("PST", "%Z").unwrap().tm_zone == - "".to_owned()); assert!(strptime("-0000", "%z").unwrap().tm_gmtoff == 0); assert!(strptime("-0800", "%z").unwrap().tm_gmtoff == @@ -1457,22 +1429,9 @@ mod tests { assert_eq!(local.strftime("%Y"), "2009".to_strbuf()); assert_eq!(local.strftime("%y"), "09".to_strbuf()); assert_eq!(local.strftime("%+"), "2009-02-13T15:31:30-08:00".to_strbuf()); - - // FIXME (#2350): We should probably standardize on the timezone - // abbreviation. - let zone = local.strftime("%Z"); - assert!(zone == "PST".to_strbuf() || zone == "Pacific Standard Time".to_strbuf()); - assert_eq!(local.strftime("%z"), "-0800".to_strbuf()); assert_eq!(local.strftime("%%"), "%".to_strbuf()); - // FIXME (#2350): We should probably standardize on the timezone - // abbreviation. - let rfc822 = local.rfc822(); - let prefix = "Fri, 13 Feb 2009 15:31:30 ".to_strbuf(); - assert!(rfc822 == format_strbuf!("{}PST", prefix) || - rfc822 == format_strbuf!("{}Pacific Standard Time", prefix)); - assert_eq!(local.ctime(), "Fri Feb 13 15:31:30 2009".to_strbuf()); assert_eq!(local.rfc822z(), "Fri, 13 Feb 2009 15:31:30 -0800".to_strbuf()); assert_eq!(local.rfc3339(), "2009-02-13T15:31:30-08:00".to_strbuf()); diff --git a/src/liburl/lib.rs b/src/liburl/lib.rs index 5fc567f06d38d..e75afa04cd40d 100644 --- a/src/liburl/lib.rs +++ b/src/liburl/lib.rs @@ -164,10 +164,10 @@ fn encode_inner(s: &str, full_url: bool) -> StrBuf { out.push_char(ch); } - _ => out.push_str(format!("%{:X}", ch as uint)) + _ => out.push_str(format!("%{:X}", ch as uint).as_slice()) } } else { - out.push_str(format!("%{:X}", ch as uint)); + out.push_str(format!("%{:X}", ch as uint).as_slice()); } } } @@ -292,7 +292,7 @@ fn encode_plus(s: &str) -> StrBuf { out.push_char(ch); } ' ' => out.push_char('+'), - _ => out.push_str(format!("%{:X}", ch as uint)) + _ => out.push_str(format!("%{:X}", ch as uint).as_slice()) } } @@ -319,7 +319,7 @@ pub fn encode_form_urlencoded(m: &HashMap>) -> StrBuf { out.push_str(format!("{}={}", key, - encode_plus(value.as_slice()))); + encode_plus(value.as_slice())).as_slice()); } } diff --git a/src/libuuid/lib.rs b/src/libuuid/lib.rs index d2032b9d49281..de9d6ef7c89aa 100644 --- a/src/libuuid/lib.rs +++ b/src/libuuid/lib.rs @@ -326,8 +326,8 @@ impl Uuid { let mut s: Vec = Vec::from_elem(32, 0u8); for i in range(0u, 16u) { let digit = format!("{:02x}", self.bytes[i] as uint); - *s.get_mut(i*2+0) = digit[0]; - *s.get_mut(i*2+1) = digit[1]; + *s.get_mut(i*2+0) = digit.as_slice()[0]; + *s.get_mut(i*2+1) = digit.as_slice()[1]; } str::from_utf8(s.as_slice()).unwrap().to_strbuf() } @@ -426,14 +426,16 @@ impl Uuid { // At this point, we know we have a valid hex string, without hyphens assert!(vs.len() == 32); - assert!(vs.chars().all(|c| c.is_digit_radix(16))); + assert!(vs.as_slice().chars().all(|c| c.is_digit_radix(16))); // Allocate output UUID buffer let mut ub = [0u8, ..16]; // Extract each hex digit from the string for i in range(0u, 16u) { - ub[i] = FromStrRadix::from_str_radix(vs.slice(i*2, (i+1)*2), 16).unwrap(); + ub[i] = FromStrRadix::from_str_radix(vs.as_slice() + .slice(i*2, (i+1)*2), + 16).unwrap(); } Ok(Uuid::from_bytes(ub).unwrap()) @@ -624,7 +626,7 @@ mod test { // Round-trip let uuid_orig = Uuid::new_v4(); let orig_str = uuid_orig.to_str(); - let uuid_out = Uuid::parse_string(orig_str).unwrap(); + let uuid_out = Uuid::parse_string(orig_str.as_slice()).unwrap(); assert!(uuid_orig == uuid_out); // Test error reporting @@ -706,7 +708,7 @@ mod test { assert!(uuid_hs == uuid); let ss = uuid.to_str(); - let uuid_ss = Uuid::parse_string(ss).unwrap(); + let uuid_ss = Uuid::parse_string(ss.as_slice()).unwrap(); assert!(uuid_ss == uuid); } diff --git a/src/rt/rust_builtin.c b/src/rt/rust_builtin.c index 6ab36f1db7a82..ed077e69978a9 100644 --- a/src/rt/rust_builtin.c +++ b/src/rt/rust_builtin.c @@ -127,15 +127,6 @@ rust_list_dir_wfd_fp_buf(void* wfd) { } #endif -typedef struct -{ - size_t fill; // in bytes; if zero, heapified - size_t alloc; // in bytes - uint8_t data[0]; -} rust_vec; - -typedef rust_vec rust_str; - typedef struct { int32_t tm_sec; int32_t tm_min; @@ -147,7 +138,6 @@ typedef struct { int32_t tm_yday; int32_t tm_isdst; int32_t tm_gmtoff; - rust_str *tm_zone; int32_t tm_nsec; } rust_tm; @@ -164,8 +154,10 @@ void rust_tm_to_tm(rust_tm* in_tm, struct tm* out_tm) { out_tm->tm_isdst = in_tm->tm_isdst; } -void tm_to_rust_tm(struct tm* in_tm, rust_tm* out_tm, int32_t gmtoff, - const char *zone, int32_t nsec) { +void tm_to_rust_tm(struct tm* in_tm, + rust_tm* out_tm, + int32_t gmtoff, + int32_t nsec) { out_tm->tm_sec = in_tm->tm_sec; out_tm->tm_min = in_tm->tm_min; out_tm->tm_hour = in_tm->tm_hour; @@ -177,13 +169,6 @@ void tm_to_rust_tm(struct tm* in_tm, rust_tm* out_tm, int32_t gmtoff, out_tm->tm_isdst = in_tm->tm_isdst; out_tm->tm_gmtoff = gmtoff; out_tm->tm_nsec = nsec; - - if (zone != NULL) { - size_t size = strlen(zone); - assert(out_tm->tm_zone->alloc >= size); - memcpy(out_tm->tm_zone->data, zone, size); - out_tm->tm_zone->fill = size; - } } #if defined(__WIN32__) @@ -225,7 +210,7 @@ rust_gmtime(int64_t sec, int32_t nsec, rust_tm *timeptr) { time_t s = sec; GMTIME(&s, &tm); - tm_to_rust_tm(&tm, timeptr, 0, "UTC", nsec); + tm_to_rust_tm(&tm, timeptr, 0, nsec); } void @@ -234,28 +219,13 @@ rust_localtime(int64_t sec, int32_t nsec, rust_tm *timeptr) { time_t s = sec; LOCALTIME(&s, &tm); - const char* zone = NULL; #if defined(__WIN32__) int32_t gmtoff = -timezone; - wchar_t wbuffer[64] = {0}; - char buffer[256] = {0}; - // strftime("%Z") can contain non-UTF-8 characters on non-English locale (issue #9418), - // so time zone should be converted from UTF-16 string. - // Since wcsftime depends on setlocale() result, - // instead we convert it using MultiByteToWideChar. - if (strftime(buffer, sizeof(buffer) / sizeof(char), "%Z", &tm) > 0) { - // ANSI -> UTF-16 - MultiByteToWideChar(CP_ACP, 0, buffer, -1, wbuffer, sizeof(wbuffer) / sizeof(wchar_t)); - // UTF-16 -> UTF-8 - WideCharToMultiByte(CP_UTF8, 0, wbuffer, -1, buffer, sizeof(buffer), NULL, NULL); - zone = buffer; - } #else int32_t gmtoff = tm.tm_gmtoff; - zone = tm.tm_zone; #endif - tm_to_rust_tm(&tm, timeptr, gmtoff, zone, nsec); + tm_to_rust_tm(&tm, timeptr, gmtoff, nsec); } int64_t diff --git a/src/test/bench/core-map.rs b/src/test/bench/core-map.rs index 6a8a56b4f1f8a..d7acd82092fac 100644 --- a/src/test/bench/core-map.rs +++ b/src/test/bench/core-map.rs @@ -93,7 +93,7 @@ fn main() { let args = args.as_slice(); let n_keys = { if args.len() == 2 { - from_str::(args[1]).unwrap() + from_str::(args[1].as_slice()).unwrap() } else { 1000000 } diff --git a/src/test/bench/core-set.rs b/src/test/bench/core-set.rs index 757d61f285746..ffc2fdffba447 100644 --- a/src/test/bench/core-set.rs +++ b/src/test/bench/core-set.rs @@ -158,7 +158,7 @@ fn main() { let args = args.as_slice(); let num_keys = { if args.len() == 2 { - from_str::(args[1]).unwrap() + from_str::(args[1].as_slice()).unwrap() } else { 100 // woefully inadequate for any real measurement } diff --git a/src/test/bench/core-uint-to-str.rs b/src/test/bench/core-uint-to-str.rs index d954b0c12e3c8..381527763c962 100644 --- a/src/test/bench/core-uint-to-str.rs +++ b/src/test/bench/core-uint-to-str.rs @@ -21,7 +21,7 @@ fn main() { args.move_iter().collect() }; - let n = from_str::(*args.get(1)).unwrap(); + let n = from_str::(args.get(1).as_slice()).unwrap(); for i in range(0u, n) { let x = i.to_str(); diff --git a/src/test/bench/msgsend-ring-mutex-arcs.rs b/src/test/bench/msgsend-ring-mutex-arcs.rs index 2779ec06e9ff0..633ac6ebcdff8 100644 --- a/src/test/bench/msgsend-ring-mutex-arcs.rs +++ b/src/test/bench/msgsend-ring-mutex-arcs.rs @@ -70,8 +70,8 @@ fn main() { args.clone().move_iter().collect() }; - let num_tasks = from_str::(*args.get(1)).unwrap(); - let msg_per_task = from_str::(*args.get(2)).unwrap(); + let num_tasks = from_str::(args.get(1).as_slice()).unwrap(); + let msg_per_task = from_str::(args.get(2).as_slice()).unwrap(); let (mut num_chan, num_port) = init(); diff --git a/src/test/bench/msgsend-ring-rw-arcs.rs b/src/test/bench/msgsend-ring-rw-arcs.rs index 70b31017223e6..a324f10fb33af 100644 --- a/src/test/bench/msgsend-ring-rw-arcs.rs +++ b/src/test/bench/msgsend-ring-rw-arcs.rs @@ -71,8 +71,8 @@ fn main() { args.clone().move_iter().collect() }; - let num_tasks = from_str::(*args.get(1)).unwrap(); - let msg_per_task = from_str::(*args.get(2)).unwrap(); + let num_tasks = from_str::(args.get(1).as_slice()).unwrap(); + let msg_per_task = from_str::(args.get(2).as_slice()).unwrap(); let (mut num_chan, num_port) = init(); diff --git a/src/test/bench/rt-messaging-ping-pong.rs b/src/test/bench/rt-messaging-ping-pong.rs index bbe6b6c23f0f9..34e0742b6324a 100644 --- a/src/test/bench/rt-messaging-ping-pong.rs +++ b/src/test/bench/rt-messaging-ping-pong.rs @@ -63,13 +63,13 @@ fn main() { let args = os::args(); let args = args.as_slice(); let n = if args.len() == 3 { - from_str::(args[1]).unwrap() + from_str::(args[1].as_slice()).unwrap() } else { 10000 }; let m = if args.len() == 3 { - from_str::(args[2]).unwrap() + from_str::(args[2].as_slice()).unwrap() } else { 4 }; diff --git a/src/test/bench/rt-parfib.rs b/src/test/bench/rt-parfib.rs index 29cee668389f8..4072dc0064afb 100644 --- a/src/test/bench/rt-parfib.rs +++ b/src/test/bench/rt-parfib.rs @@ -33,7 +33,7 @@ fn main() { let args = os::args(); let args = args.as_slice(); let n = if args.len() == 2 { - from_str::(args[1]).unwrap() + from_str::(args[1].as_slice()).unwrap() } else { 10 }; diff --git a/src/test/bench/rt-spawn-rate.rs b/src/test/bench/rt-spawn-rate.rs index 48d4a41c1a39a..a091c6be9f8c6 100644 --- a/src/test/bench/rt-spawn-rate.rs +++ b/src/test/bench/rt-spawn-rate.rs @@ -30,7 +30,7 @@ fn main() { let args = os::args(); let args = args.as_slice(); let n = if args.len() == 2 { - from_str::(args[1]).unwrap() + from_str::(args[1].as_slice()).unwrap() } else { 100000 }; diff --git a/src/test/bench/shootout-ackermann.rs b/src/test/bench/shootout-ackermann.rs index 46ea188a271a4..e0116931538e9 100644 --- a/src/test/bench/shootout-ackermann.rs +++ b/src/test/bench/shootout-ackermann.rs @@ -31,6 +31,6 @@ fn main() { } else { args.move_iter().collect() }; - let n = from_str::(*args.get(1)).unwrap(); + let n = from_str::(args.get(1).as_slice()).unwrap(); println!("Ack(3,{}): {}\n", n, ack(3, n)); } diff --git a/src/test/bench/shootout-binarytrees.rs b/src/test/bench/shootout-binarytrees.rs index 181d19ade3ab4..eab8b66b90d1e 100644 --- a/src/test/bench/shootout-binarytrees.rs +++ b/src/test/bench/shootout-binarytrees.rs @@ -46,7 +46,7 @@ fn main() { } else if args.len() <= 1u { 8 } else { - from_str(args[1]).unwrap() + from_str(args[1].as_slice()).unwrap() }; let min_depth = 4; let max_depth = if min_depth + 2 > n {min_depth + 2} else {n}; diff --git a/src/test/bench/shootout-chameneos-redux.rs b/src/test/bench/shootout-chameneos-redux.rs index f0bc0204fd26d..181fe29c89185 100644 --- a/src/test/bench/shootout-chameneos-redux.rs +++ b/src/test/bench/shootout-chameneos-redux.rs @@ -48,7 +48,7 @@ fn show_color_list(set: Vec) -> StrBuf { let mut out = StrBuf::new(); for col in set.iter() { out.push_char(' '); - out.push_str(col.to_str()); + out.push_str(col.to_str().as_slice()); } out } @@ -198,7 +198,10 @@ fn main() { let nn = if std::os::getenv("RUST_BENCH").is_some() { 200000 } else { - std::os::args().as_slice().get(1).and_then(|arg| from_str(*arg)).unwrap_or(600) + std::os::args().as_slice() + .get(1) + .and_then(|arg| from_str(arg.as_slice())) + .unwrap_or(600) }; print_complements(); diff --git a/src/test/bench/shootout-fannkuch-redux.rs b/src/test/bench/shootout-fannkuch-redux.rs index 3525b90d3f681..9cc8f2f23ff26 100644 --- a/src/test/bench/shootout-fannkuch-redux.rs +++ b/src/test/bench/shootout-fannkuch-redux.rs @@ -53,7 +53,10 @@ fn fannkuch(n: uint, i: uint) -> (int, int) { } fn main() { - let n = std::os::args().as_slice().get(1).and_then(|arg| from_str(*arg)).unwrap_or(2u); + let n = std::os::args().as_slice() + .get(1) + .and_then(|arg| from_str(arg.as_slice())) + .unwrap_or(2u); let (tx, rx) = channel(); for i in range(0, n) { diff --git a/src/test/bench/shootout-fasta-redux.rs b/src/test/bench/shootout-fasta-redux.rs index 3f8d3275b64f9..adec9d31afecb 100644 --- a/src/test/bench/shootout-fasta-redux.rs +++ b/src/test/bench/shootout-fasta-redux.rs @@ -179,7 +179,7 @@ fn main() { let args = os::args(); let args = args.as_slice(); let n = if args.len() > 1 { - from_str::(args[1]).unwrap() + from_str::(args[1].as_slice()).unwrap() } else { 5 }; diff --git a/src/test/bench/shootout-fasta.rs b/src/test/bench/shootout-fasta.rs index c526ef54caff2..4126fda00bcce 100644 --- a/src/test/bench/shootout-fasta.rs +++ b/src/test/bench/shootout-fasta.rs @@ -80,7 +80,7 @@ fn run(writer: &mut W) { } else if args.len() <= 1u { 1000 } else { - from_str(args[1]).unwrap() + from_str(args[1].as_slice()).unwrap() }; let rng = &mut MyRandom::new(); diff --git a/src/test/bench/shootout-fibo.rs b/src/test/bench/shootout-fibo.rs index a453ddccde510..76f96f8d43b99 100644 --- a/src/test/bench/shootout-fibo.rs +++ b/src/test/bench/shootout-fibo.rs @@ -27,6 +27,6 @@ fn main() { } else { args.move_iter().collect() }; - let n = from_str::(*args.get(1)).unwrap(); + let n = from_str::(args.get(1).as_slice()).unwrap(); println!("{}\n", fib(n)); } diff --git a/src/test/bench/shootout-k-nucleotide-pipes.rs b/src/test/bench/shootout-k-nucleotide-pipes.rs index 250562a095ea0..6f8c44f4bdfb8 100644 --- a/src/test/bench/shootout-k-nucleotide-pipes.rs +++ b/src/test/bench/shootout-k-nucleotide-pipes.rs @@ -64,7 +64,7 @@ fn sort_and_fmt(mm: &HashMap , uint>, total: uint) -> StrBuf { k.as_slice() .to_ascii() .to_upper() - .into_str(), v)); + .into_str(), v).as_slice()); } return buffer @@ -179,15 +179,15 @@ fn main() { let mut proc_mode = false; for line in rdr.lines() { - let line = line.unwrap().trim().to_owned(); + let line = line.unwrap().as_slice().trim().to_owned(); if line.len() == 0u { continue; } - match (line[0] as char, proc_mode) { + match (line.as_slice()[0] as char, proc_mode) { // start processing if this is the one ('>', false) => { - match line.slice_from(1).find_str("THREE") { + match line.as_slice().slice_from(1).find_str("THREE") { option::Some(_) => { proc_mode = true; } option::None => { } } diff --git a/src/test/bench/shootout-k-nucleotide.rs b/src/test/bench/shootout-k-nucleotide.rs index 1434838e59bce..e46f27a9f4158 100644 --- a/src/test/bench/shootout-k-nucleotide.rs +++ b/src/test/bench/shootout-k-nucleotide.rs @@ -252,9 +252,9 @@ fn print_occurrences(frequencies: &mut Table, occurrence: &'static str) { fn get_sequence(r: &mut R, key: &str) -> Vec { let mut res = Vec::new(); for l in r.lines().map(|l| l.ok().unwrap()) - .skip_while(|l| key != l.slice_to(key.len())).skip(1) + .skip_while(|l| key != l.as_slice().slice_to(key.len())).skip(1) { - res.push_all(l.trim().as_bytes()); + res.push_all(l.as_slice().trim().as_bytes()); } for b in res.mut_iter() { *b = b.to_ascii().to_upper().to_byte(); diff --git a/src/test/bench/shootout-mandelbrot.rs b/src/test/bench/shootout-mandelbrot.rs index debd12874da1e..6b3079b8fc8d1 100644 --- a/src/test/bench/shootout-mandelbrot.rs +++ b/src/test/bench/shootout-mandelbrot.rs @@ -169,7 +169,7 @@ fn main() { which interferes with the test runner."); mandelbrot(1000, io::util::NullWriter) } else { - mandelbrot(from_str(args[1]).unwrap(), io::stdout()) + mandelbrot(from_str(args[1].as_slice()).unwrap(), io::stdout()) }; res.unwrap(); } diff --git a/src/test/bench/shootout-nbody.rs b/src/test/bench/shootout-nbody.rs index f9a84f276bf6e..5a077b377475c 100644 --- a/src/test/bench/shootout-nbody.rs +++ b/src/test/bench/shootout-nbody.rs @@ -141,7 +141,7 @@ fn main() { 5000000 } else { std::os::args().as_slice().get(1) - .and_then(|arg| from_str(*arg)) + .and_then(|arg| from_str(arg.as_slice())) .unwrap_or(1000) }; let mut bodies = BODIES; diff --git a/src/test/bench/shootout-pidigits.rs b/src/test/bench/shootout-pidigits.rs index 49356e6e6458e..8b522f362b330 100644 --- a/src/test/bench/shootout-pidigits.rs +++ b/src/test/bench/shootout-pidigits.rs @@ -92,7 +92,7 @@ fn main() { let n = if args.len() < 2 { 512 } else { - FromStr::from_str(args[1]).unwrap() + FromStr::from_str(args[1].as_slice()).unwrap() }; pidigits(n); } diff --git a/src/test/bench/shootout-regex-dna.rs b/src/test/bench/shootout-regex-dna.rs index f5409688bc6c4..002eaf2bbf921 100644 --- a/src/test/bench/shootout-regex-dna.rs +++ b/src/test/bench/shootout-regex-dna.rs @@ -38,7 +38,7 @@ fn main() { } else { box io::stdin() as Box }; - let mut seq = StrBuf::from_str(rdr.read_to_str().unwrap()); + let mut seq = rdr.read_to_str().unwrap(); let ilen = seq.len(); seq = regex!(">[^\n]*\n|\n").replace_all(seq.as_slice(), NoExpand("")); diff --git a/src/test/bench/shootout-spectralnorm.rs b/src/test/bench/shootout-spectralnorm.rs index 70a0e7a957c6b..c6a678828c15b 100644 --- a/src/test/bench/shootout-spectralnorm.rs +++ b/src/test/bench/shootout-spectralnorm.rs @@ -100,7 +100,7 @@ fn main() { } else if args.len() < 2 { 2000 } else { - FromStr::from_str(args[1]).unwrap() + FromStr::from_str(args[1].as_slice()).unwrap() }; let u = Arc::new(RWLock::new(Vec::from_elem(n, 1.))); let v = Arc::new(RWLock::new(Vec::from_elem(n, 1.))); diff --git a/src/test/bench/shootout-threadring.rs b/src/test/bench/shootout-threadring.rs index 60485f40ba4e0..1a6582927caf2 100644 --- a/src/test/bench/shootout-threadring.rs +++ b/src/test/bench/shootout-threadring.rs @@ -39,9 +39,11 @@ fn main() { let token = if std::os::getenv("RUST_BENCH").is_some() { 2000000 } else { - args.get(1).and_then(|arg| from_str(*arg)).unwrap_or(1000) + args.get(1).and_then(|arg| from_str(arg.as_slice())).unwrap_or(1000) }; - let n_tasks = args.get(2).and_then(|arg| from_str(*arg)).unwrap_or(503); + let n_tasks = args.get(2) + .and_then(|arg| from_str(arg.as_slice())) + .unwrap_or(503); start(n_tasks, token); } diff --git a/src/test/bench/std-smallintmap.rs b/src/test/bench/std-smallintmap.rs index ae1d9db8982bb..3b26de9cf47be 100644 --- a/src/test/bench/std-smallintmap.rs +++ b/src/test/bench/std-smallintmap.rs @@ -38,8 +38,8 @@ fn main() { } else { args.move_iter().collect() }; - let max = from_str::(*args.get(1)).unwrap(); - let rep = from_str::(*args.get(2)).unwrap(); + let max = from_str::(args.get(1).as_slice()).unwrap(); + let rep = from_str::(args.get(2).as_slice()).unwrap(); let mut checkf = 0.0; let mut appendf = 0.0; diff --git a/src/test/bench/sudoku.rs b/src/test/bench/sudoku.rs index 58568282e1584..0485e10a38bfa 100644 --- a/src/test/bench/sudoku.rs +++ b/src/test/bench/sudoku.rs @@ -72,7 +72,10 @@ impl Sudoku { let mut g = Vec::from_fn(10u, { |_i| vec!(0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8) }); for line in reader.lines() { let line = line.unwrap(); - let comps: Vec<&str> = line.trim().split(',').collect(); + let comps: Vec<&str> = line.as_slice() + .trim() + .split(',') + .collect(); if comps.len() == 3u { let row = from_str::(*comps.get(0)).unwrap() as u8; diff --git a/src/test/bench/task-perf-jargon-metal-smoke.rs b/src/test/bench/task-perf-jargon-metal-smoke.rs index 442386e30586e..1669f41374d1f 100644 --- a/src/test/bench/task-perf-jargon-metal-smoke.rs +++ b/src/test/bench/task-perf-jargon-metal-smoke.rs @@ -49,7 +49,7 @@ fn main() { }; let (tx, rx) = channel(); - child_generation(from_str::(*args.get(1)).unwrap(), tx); + child_generation(from_str::(args.get(1).as_slice()).unwrap(), tx); if rx.recv_opt().is_err() { fail!("it happened when we slumbered"); } diff --git a/src/test/bench/task-perf-spawnalot.rs b/src/test/bench/task-perf-spawnalot.rs index e64b807ca3acc..cb5eb77df6c23 100644 --- a/src/test/bench/task-perf-spawnalot.rs +++ b/src/test/bench/task-perf-spawnalot.rs @@ -31,7 +31,7 @@ fn main() { } else { args.move_iter().collect() }; - let n = from_str::(*args.get(1)).unwrap(); + let n = from_str::(args.get(1).as_slice()).unwrap(); let mut i = 0u; while i < n { task::spawn(proc() f(n) ); i += 1u; } } diff --git a/src/test/compile-fail/unsafe-modifying-str.rs b/src/test/compile-fail/borrowck-let-suggestion.rs similarity index 56% rename from src/test/compile-fail/unsafe-modifying-str.rs rename to src/test/compile-fail/borrowck-let-suggestion.rs index 1adf88c80be90..a03087f9b2dad 100644 --- a/src/test/compile-fail/unsafe-modifying-str.rs +++ b/src/test/compile-fail/borrowck-let-suggestion.rs @@ -1,4 +1,4 @@ -// Copyright 2013 The Rust Project Developers. See the COPYRIGHT +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // @@ -8,11 +8,13 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +fn f() { + let x = [1].iter(); //~ ERROR borrowed value does not live long enough + //~^^ NOTE reference must be valid for the block + //~^^ NOTE consider using a `let` binding to increase its lifetime +} + fn main() { - let mut s = "test".to_owned(); - s[0] = 3; //~ ERROR: not allowed - s[0] += 3; //~ ERROR: not allowed - { - let _a = &mut s[0]; //~ ERROR: not allowed - } + f(); } + diff --git a/src/test/compile-fail/closure-reform-bad.rs b/src/test/compile-fail/closure-reform-bad.rs index a5168c4604580..1e1889c7339d2 100644 --- a/src/test/compile-fail/closure-reform-bad.rs +++ b/src/test/compile-fail/closure-reform-bad.rs @@ -17,7 +17,7 @@ fn call_bare(f: fn(&str)) { fn main() { let string = "world!"; - let f: |&str| = |s| println!("{}", s + string); + let f: |&str| = |s| println!("{}{}", s, string); call_bare(f) //~ ERROR mismatched types } diff --git a/src/test/compile-fail/lint-heap-memory.rs b/src/test/compile-fail/lint-heap-memory.rs index eaa1819bd53e5..ae18e9bebad59 100644 --- a/src/test/compile-fail/lint-heap-memory.rs +++ b/src/test/compile-fail/lint-heap-memory.rs @@ -27,6 +27,5 @@ fn main() { box 2; //~ ERROR type uses owned fn g(_: Box) {} //~ ERROR type uses owned - "".to_owned(); //~ ERROR type uses owned proc() {}; //~ ERROR type uses owned } diff --git a/src/test/compile-fail/regions-glb-free-free.rs b/src/test/compile-fail/regions-glb-free-free.rs index d8a6391826b48..1d8c4cec65544 100644 --- a/src/test/compile-fail/regions-glb-free-free.rs +++ b/src/test/compile-fail/regions-glb-free-free.rs @@ -33,7 +33,7 @@ mod argparse { } fn main () { - let f : argparse::Flag = argparse::flag("flag".to_owned(), "My flag".to_owned()); - let updated_flag = f.set_desc("My new flag".to_owned()); - assert_eq!(updated_flag.desc, "My new flag"); + let f : argparse::Flag = argparse::flag("flag", "My flag"); + let updated_flag = f.set_desc("My new flag"); + assert_eq!(updated_flag.desc.as_slice(), "My new flag"); } diff --git a/src/test/compile-fail/trait-coercion-generic-regions.rs b/src/test/compile-fail/trait-coercion-generic-regions.rs index 04239de2a83cc..cf7a5c4ad14fe 100644 --- a/src/test/compile-fail/trait-coercion-generic-regions.rs +++ b/src/test/compile-fail/trait-coercion-generic-regions.rs @@ -25,7 +25,7 @@ impl Trait<&'static str> for Struct { fn main() { let person = "Fred".to_owned(); - let person: &str = person; //~ ERROR `person[..]` does not live long enough + let person: &str = person.as_slice(); //~ ERROR `person` does not live long enough let s: Box> = box Struct { person: person }; } diff --git a/src/test/pretty/match-naked-expr-long.rs b/src/test/pretty/match-naked-expr-long.rs deleted file mode 100644 index 994a81dc48662..0000000000000 --- a/src/test/pretty/match-naked-expr-long.rs +++ /dev/null @@ -1,25 +0,0 @@ -// Copyright 2012 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -// pp-exact - -// actually this doesn't quite look how I want it to, but I can't -// get the prettyprinter to indent the long expr - -fn main() { - let x = Some(3); - let _y = - match x { - Some(_) => - "some".to_owned() + "very" + "very" + "very" + "very" + "very" + - "very" + "very" + "very" + "long" + "string", - None => "none".to_owned() - }; -} diff --git a/src/test/run-fail/assert-macro-owned.rs b/src/test/run-fail/assert-macro-owned.rs index 9dec60e488dbf..bbbe29cc13411 100644 --- a/src/test/run-fail/assert-macro-owned.rs +++ b/src/test/run-fail/assert-macro-owned.rs @@ -11,5 +11,5 @@ // error-pattern:failed at 'test-assert-owned' fn main() { - assert!(false, "test-assert-owned".to_owned()); + assert!(false, "test-assert-owned".to_strbuf()); } diff --git a/src/test/run-fail/explicit-fail-msg.rs b/src/test/run-fail/explicit-fail-msg.rs index 7b5d263071b76..9160b760c92d6 100644 --- a/src/test/run-fail/explicit-fail-msg.rs +++ b/src/test/run-fail/explicit-fail-msg.rs @@ -15,5 +15,5 @@ fn main() { let mut a = 1; if 1 == 1 { a = 2; } - fail!("woooo".to_owned() + "o"); + fail!(format_strbuf!("woooo{}", "o")); } diff --git a/src/test/run-fail/issue-3029.rs b/src/test/run-fail/issue-3029.rs index b3b1fd2082b8c..a57f4683df315 100644 --- a/src/test/run-fail/issue-3029.rs +++ b/src/test/run-fail/issue-3029.rs @@ -19,5 +19,4 @@ fn main() { let y = vec!(3); fail!("so long"); x.push_all_move(y); - "good".to_owned() + "bye".to_owned(); } diff --git a/src/test/run-fail/unwind-misc-1.rs b/src/test/run-fail/unwind-misc-1.rs index fae1a8a17738c..f160b92552504 100644 --- a/src/test/run-fail/unwind-misc-1.rs +++ b/src/test/run-fail/unwind-misc-1.rs @@ -22,9 +22,9 @@ fn main() { let mut map = collections::HashMap::new(); let mut arr = Vec::new(); for _i in range(0u, 10u) { - arr.push(@"key stuff".to_owned()); + arr.push(@"key stuff".to_strbuf()); map.insert(arr.clone(), - arr.clone().append([@"value stuff".to_owned()])); + arr.clone().append([@"value stuff".to_strbuf()])); if arr.len() == 5 { fail!(); } diff --git a/src/test/run-make/unicode-input/multiple_files.rs b/src/test/run-make/unicode-input/multiple_files.rs index 219eb1a3ebd45..e41c5d1b6266e 100644 --- a/src/test/run-make/unicode-input/multiple_files.rs +++ b/src/test/run-make/unicode-input/multiple_files.rs @@ -57,7 +57,11 @@ fn main() { // rustc is passed to us with --out-dir and -L etc., so we // can't exec it directly let result = Command::new("sh") - .arg("-c").arg(rustc + " " + main_file.as_str().unwrap()) + .arg("-c") + .arg(format!("{} {}", + rustc, + main_file.as_str() + .unwrap()).as_slice()) .output().unwrap(); let err = str::from_utf8_lossy(result.error.as_slice()); diff --git a/src/test/run-make/unicode-input/span_length.rs b/src/test/run-make/unicode-input/span_length.rs index 2bb89d7621320..854ed94e20afa 100644 --- a/src/test/run-make/unicode-input/span_length.rs +++ b/src/test/run-make/unicode-input/span_length.rs @@ -52,13 +52,17 @@ fn main() { // rustc is passed to us with --out-dir and -L etc., so we // can't exec it directly let result = Command::new("sh") - .arg("-c").arg(rustc + " " + main_file.as_str().unwrap()) + .arg("-c") + .arg(format!("{} {}", + rustc, + main_file.as_str() + .unwrap()).as_slice()) .output().unwrap(); let err = str::from_utf8_lossy(result.error.as_slice()); // the span should end the line (e.g no extra ~'s) - let expected_span = "^" + "~".repeat(n - 1) + "\n"; - assert!(err.as_slice().contains(expected_span)); + let expected_span = format!("^{}\n", "~".repeat(n - 1)); + assert!(err.as_slice().contains(expected_span.as_slice())); } } diff --git a/src/test/run-pass/auto-ref-slice-plus-ref.rs b/src/test/run-pass/auto-ref-slice-plus-ref.rs index 626f19b51085d..f7b9732f12e87 100644 --- a/src/test/run-pass/auto-ref-slice-plus-ref.rs +++ b/src/test/run-pass/auto-ref-slice-plus-ref.rs @@ -30,7 +30,6 @@ pub fn main() { (vec!(1)).as_slice().test_imm(); (&[1]).test_imm(); ("test").test_imm(); - ("test".to_owned()).test_imm(); ("test").test_imm(); // FIXME: Other types of mutable vecs don't currently exist diff --git a/src/test/run-pass/backtrace.rs b/src/test/run-pass/backtrace.rs index 25df896ec15a1..5e7b9d9560e38 100644 --- a/src/test/run-pass/backtrace.rs +++ b/src/test/run-pass/backtrace.rs @@ -92,6 +92,6 @@ fn main() { } else if args.len() >= 2 && args[1].as_slice() == "double-fail" { double(); } else { - runtest(args[0]); + runtest(args[0].as_slice()); } } diff --git a/src/test/run-pass/capturing-logging.rs b/src/test/run-pass/capturing-logging.rs index bb101140ec393..636e879fe32a8 100644 --- a/src/test/run-pass/capturing-logging.rs +++ b/src/test/run-pass/capturing-logging.rs @@ -46,6 +46,6 @@ fn main() { info!("info"); }); let s = r.read_to_str().unwrap(); - assert!(s.contains("info")); - assert!(!s.contains("debug")); + assert!(s.as_slice().contains("info")); + assert!(!s.as_slice().contains("debug")); } diff --git a/src/test/run-pass/cleanup-shortcircuit.rs b/src/test/run-pass/cleanup-shortcircuit.rs index c409852c6736c..0c372deae2c12 100644 --- a/src/test/run-pass/cleanup-shortcircuit.rs +++ b/src/test/run-pass/cleanup-shortcircuit.rs @@ -32,7 +32,7 @@ pub fn main() { // expression was never evaluated, we wound up trying to clean // uninitialized memory. - if args.len() >= 2 && args[1] == "signal".to_owned() { + if args.len() >= 2 && args[1].as_slice() == "signal" { // Raise a segfault. unsafe { *(0 as *mut int) = 0; } } diff --git a/src/test/run-pass/concat.rs b/src/test/run-pass/concat.rs index 99f97a41907df..c94887f16a981 100644 --- a/src/test/run-pass/concat.rs +++ b/src/test/run-pass/concat.rs @@ -9,8 +9,8 @@ // except according to those terms. pub fn main() { - assert_eq!(format!(concat!("foo", "bar", "{}"), "baz"), "foobarbaz".to_owned()); - assert_eq!(format!(concat!()), "".to_owned()); + assert_eq!(format!(concat!("foo", "bar", "{}"), "baz"), "foobarbaz".to_strbuf()); + assert_eq!(format!(concat!()), "".to_strbuf()); assert_eq!( concat!(1, 2i, 3u, 4f32, 4.0, 'a', true, ()), diff --git a/src/test/run-pass/deriving-show-2.rs b/src/test/run-pass/deriving-show-2.rs index 41650b6805129..1bcc8bbc2b7c0 100644 --- a/src/test/run-pass/deriving-show-2.rs +++ b/src/test/run-pass/deriving-show-2.rs @@ -41,15 +41,15 @@ impl fmt::Show for Custom { } pub fn main() { - assert_eq!(B1.to_str(), "B1".to_owned()); - assert_eq!(B2.to_str(), "B2".to_owned()); - assert_eq!(C1(3).to_str(), "C1(3)".to_owned()); - assert_eq!(C2(B2).to_str(), "C2(B2)".to_owned()); - assert_eq!(D1{ a: 2 }.to_str(), "D1 { a: 2 }".to_owned()); - assert_eq!(E.to_str(), "E".to_owned()); - assert_eq!(F(3).to_str(), "F(3)".to_owned()); - assert_eq!(G(3, 4).to_str(), "G(3, 4)".to_owned()); - assert_eq!(G(3, 4).to_str(), "G(3, 4)".to_owned()); - assert_eq!(I{ a: 2, b: 4 }.to_str(), "I { a: 2, b: 4 }".to_owned()); - assert_eq!(J(Custom).to_str(), "J(yay)".to_owned()); + assert_eq!(B1.to_str(), "B1".to_strbuf()); + assert_eq!(B2.to_str(), "B2".to_strbuf()); + assert_eq!(C1(3).to_str(), "C1(3)".to_strbuf()); + assert_eq!(C2(B2).to_str(), "C2(B2)".to_strbuf()); + assert_eq!(D1{ a: 2 }.to_str(), "D1 { a: 2 }".to_strbuf()); + assert_eq!(E.to_str(), "E".to_strbuf()); + assert_eq!(F(3).to_str(), "F(3)".to_strbuf()); + assert_eq!(G(3, 4).to_str(), "G(3, 4)".to_strbuf()); + assert_eq!(G(3, 4).to_str(), "G(3, 4)".to_strbuf()); + assert_eq!(I{ a: 2, b: 4 }.to_str(), "I { a: 2, b: 4 }".to_strbuf()); + assert_eq!(J(Custom).to_str(), "J(yay)".to_strbuf()); } diff --git a/src/test/run-pass/deriving-show.rs b/src/test/run-pass/deriving-show.rs index 18800ac0438fa..7254ed7d5301a 100644 --- a/src/test/run-pass/deriving-show.rs +++ b/src/test/run-pass/deriving-show.rs @@ -28,7 +28,7 @@ enum Enum { macro_rules! t { ($x:expr, $expected:expr) => { - assert_eq!(format!("{}", $x), $expected.to_owned()) + assert_eq!(format!("{}", $x), $expected.to_strbuf()) } } diff --git a/src/test/run-pass/enum-discrim-width-stuff.rs b/src/test/run-pass/enum-discrim-width-stuff.rs index 12ed4830c82d0..f028d871c20de 100644 --- a/src/test/run-pass/enum-discrim-width-stuff.rs +++ b/src/test/run-pass/enum-discrim-width-stuff.rs @@ -23,8 +23,8 @@ macro_rules! check { assert_eq!(size_of::(), size_of::<$t>()); assert_eq!(V as $t, $v); assert_eq!(C as $t, $v); - assert_eq!(format!("{:?}", V), "V".to_owned()); - assert_eq!(format!("{:?}", C), "V".to_owned()); + assert_eq!(format!("{:?}", V), "V".to_strbuf()); + assert_eq!(format!("{:?}", C), "V".to_strbuf()); } } $m::check(); diff --git a/src/test/run-pass/exec-env.rs b/src/test/run-pass/exec-env.rs index 5c71d90c159be..b4bd4a8201ed5 100644 --- a/src/test/run-pass/exec-env.rs +++ b/src/test/run-pass/exec-env.rs @@ -13,5 +13,5 @@ use std::os; pub fn main() { - assert_eq!(os::getenv("TEST_EXEC_ENV"), Some("22".to_owned())); + assert_eq!(os::getenv("TEST_EXEC_ENV"), Some("22".to_strbuf())); } diff --git a/src/test/run-pass/exponential-notation.rs b/src/test/run-pass/exponential-notation.rs index f97afa2f3e0ea..efe0e0de40ebc 100644 --- a/src/test/run-pass/exponential-notation.rs +++ b/src/test/run-pass/exponential-notation.rs @@ -13,7 +13,7 @@ use s = std::num::strconv; use to_str = std::num::strconv::float_to_str_common; -macro_rules! t(($a:expr, $b:expr) => { { let (r, _) = $a; assert_eq!(r, $b.to_owned()) } }) +macro_rules! t(($a:expr, $b:expr) => { { let (r, _) = $a; assert_eq!(r, $b.to_strbuf()) } }) pub fn main() { // Basic usage diff --git a/src/test/run-pass/fixed_length_vec_glue.rs b/src/test/run-pass/fixed_length_vec_glue.rs index 330ba896062e2..9c9f0e82d14ac 100644 --- a/src/test/run-pass/fixed_length_vec_glue.rs +++ b/src/test/run-pass/fixed_length_vec_glue.rs @@ -17,5 +17,5 @@ pub fn main() { let arr = [1,2,3]; let struc = Struc {a: 13u8, b: arr, c: 42}; let s = repr::repr_to_str(&struc); - assert_eq!(s, "Struc{a: 13u8, b: [1, 2, 3], c: 42}".to_owned()); + assert_eq!(s, "Struc{a: 13u8, b: [1, 2, 3], c: 42}".to_strbuf()); } diff --git a/src/test/run-pass/format-ref-cell.rs b/src/test/run-pass/format-ref-cell.rs index c43c22d592cdc..a033fc01df389 100644 --- a/src/test/run-pass/format-ref-cell.rs +++ b/src/test/run-pass/format-ref-cell.rs @@ -14,5 +14,5 @@ pub fn main() { let name = RefCell::new("rust"); let what = RefCell::new("rocks"); let msg = format!("{name:?} {:?}", &*what.borrow(), name=&*name.borrow()); - assert_eq!(msg, "&\"rust\" &\"rocks\"".to_owned()); + assert_eq!(msg, "&\"rust\" &\"rocks\"".to_strbuf()); } diff --git a/src/test/run-pass/ifmt.rs b/src/test/run-pass/ifmt.rs index ee142aa8e6dbc..ca2420bc57320 100644 --- a/src/test/run-pass/ifmt.rs +++ b/src/test/run-pass/ifmt.rs @@ -222,5 +222,5 @@ fn test_order() { } assert_eq!(format!("{} {} {a} {b} {} {c}", foo(), foo(), foo(), a=foo(), b=foo(), c=foo()), - "1 2 4 5 3 6".to_owned()); + "1 2 4 5 3 6".to_strbuf()); } diff --git a/src/test/run-pass/issue-3559.rs b/src/test/run-pass/issue-3559.rs index ea10bc038f072..044087ec0ca0e 100644 --- a/src/test/run-pass/issue-3559.rs +++ b/src/test/run-pass/issue-3559.rs @@ -22,8 +22,8 @@ fn check_strs(actual: &str, expected: &str) -> bool { pub fn main() { let mut table = HashMap::new(); - table.insert("one".to_owned(), 1); - table.insert("two".to_owned(), 2); - assert!(check_strs(table.to_str(), "{one: 1, two: 2}") || - check_strs(table.to_str(), "{two: 2, one: 1}")); + table.insert("one".to_strbuf(), 1); + table.insert("two".to_strbuf(), 2); + assert!(check_strs(table.to_str().as_slice(), "{one: 1, two: 2}") || + check_strs(table.to_str().as_slice(), "{two: 2, one: 1}")); } diff --git a/src/test/run-pass/issue-3563-3.rs b/src/test/run-pass/issue-3563-3.rs index cdc07c026772e..cc63b62239812 100644 --- a/src/test/run-pass/issue-3563-3.rs +++ b/src/test/run-pass/issue-3563-3.rs @@ -159,7 +159,7 @@ pub fn check_strs(actual: &str, expected: &str) -> bool { fn test_ascii_art_ctor() { let art = AsciiArt(3, 3, '*'); - assert!(check_strs(art.to_str(), "...\n...\n...")); + assert!(check_strs(art.to_str().as_slice(), "...\n...\n...")); } @@ -168,7 +168,7 @@ fn test_add_pt() { art.add_pt(0, 0); art.add_pt(0, -10); art.add_pt(1, 2); - assert!(check_strs(art.to_str(), "*..\n...\n.*.")); + assert!(check_strs(art.to_str().as_slice(), "*..\n...\n.*.")); } @@ -176,7 +176,7 @@ fn test_shapes() { let mut art = AsciiArt(4, 4, '*'); art.add_rect(Rect {top_left: Point {x: 0, y: 0}, size: Size {width: 4, height: 4}}); art.add_point(Point {x: 2, y: 2}); - assert!(check_strs(art.to_str(), "****\n*..*\n*.**\n****")); + assert!(check_strs(art.to_str().as_slice(), "****\n*..*\n*.**\n****")); } pub fn main() { diff --git a/src/test/run-pass/issue-3574.rs b/src/test/run-pass/issue-3574.rs index 85c5673377733..e31f2ade125eb 100644 --- a/src/test/run-pass/issue-3574.rs +++ b/src/test/run-pass/issue-3574.rs @@ -8,21 +8,15 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![allow(unnecessary_allocation)] - // rustc --test match_borrowed_str.rs.rs && ./match_borrowed_str.rs -fn compare(x: &str, y: &str) -> bool -{ - match x - { +fn compare(x: &str, y: &str) -> bool { + match x { "foo" => y == "foo", _ => y == "bar", } } -pub fn main() -{ +pub fn main() { assert!(compare("foo", "foo")); - assert!(compare("foo".to_owned(), "foo".to_owned())); } diff --git a/src/test/run-pass/let-assignability.rs b/src/test/run-pass/let-assignability.rs index e89151fcd9dd8..477f3b2acafda 100644 --- a/src/test/run-pass/let-assignability.rs +++ b/src/test/run-pass/let-assignability.rs @@ -9,8 +9,8 @@ // except according to those terms. fn f() { - let a = "hello".to_owned(); - let b: &str = a; + let a = box 1; + let b: &int = a; println!("{}", b); } diff --git a/src/test/run-pass/let-destruct-ref.rs b/src/test/run-pass/let-destruct-ref.rs index 70ce2b93fc90b..343780b246382 100644 --- a/src/test/run-pass/let-destruct-ref.rs +++ b/src/test/run-pass/let-destruct-ref.rs @@ -9,7 +9,7 @@ // except according to those terms. pub fn main() { - let x = "hello".to_owned(); + let x = 3u; let ref y = x; - assert_eq!(x.slice(0, x.len()), y.slice(0, y.len())); + assert_eq!(x, *y); } diff --git a/src/test/run-pass/linear-for-loop.rs b/src/test/run-pass/linear-for-loop.rs index 9ae8cc893b141..2f8f16fb1aea9 100644 --- a/src/test/run-pass/linear-for-loop.rs +++ b/src/test/run-pass/linear-for-loop.rs @@ -16,7 +16,7 @@ pub fn main() { assert_eq!(y, 6); let s = "hello there".to_owned(); let mut i: int = 0; - for c in s.bytes() { + for c in s.as_slice().bytes() { if i == 0 { assert!((c == 'h' as u8)); } if i == 1 { assert!((c == 'e' as u8)); } if i == 2 { assert!((c == 'l' as u8)); } diff --git a/src/test/run-pass/log-err-phi.rs b/src/test/run-pass/log-err-phi.rs index cf3131514db6c..2f2328faaca7f 100644 --- a/src/test/run-pass/log-err-phi.rs +++ b/src/test/run-pass/log-err-phi.rs @@ -10,4 +10,8 @@ -pub fn main() { if false { println!("{}", "foo".to_owned() + "bar"); } } +pub fn main() { + if false { + println!("{}", "foobar"); + } +} diff --git a/src/test/run-pass/option-ext.rs b/src/test/run-pass/option-ext.rs index 967ca621948a2..7a816f9133501 100644 --- a/src/test/run-pass/option-ext.rs +++ b/src/test/run-pass/option-ext.rs @@ -9,7 +9,7 @@ // except according to those terms. pub fn main() { - let thing = "{{ f }}".to_owned(); + let thing = "{{ f }}"; let f = thing.find_str("{{"); if f.is_none() { diff --git a/src/test/run-pass/process-spawn-with-unicode-params.rs b/src/test/run-pass/process-spawn-with-unicode-params.rs index 5e1f9bbaf0cfd..cdbb1fe84dc5a 100644 --- a/src/test/run-pass/process-spawn-with-unicode-params.rs +++ b/src/test/run-pass/process-spawn-with-unicode-params.rs @@ -36,12 +36,13 @@ fn main() { let blah = "\u03c0\u042f\u97f3\u00e6\u221e"; let child_name = "child"; - let child_dir = "process-spawn-with-unicode-params-" + blah; + let child_dir = format_strbuf!("process-spawn-with-unicode-params-{}", + blah); // parameters sent to child / expected to be received from parent let arg = blah; let cwd = my_dir.join(Path::new(child_dir.clone())); - let env = ("RUST_TEST_PROC_SPAWN_UNICODE".to_owned(), blah.to_owned()); + let env = ("RUST_TEST_PROC_SPAWN_UNICODE".to_strbuf(), blah.to_strbuf()); // am I the parent or the child? if my_args.len() == 1 { // parent diff --git a/src/test/run-pass/rec-align-u32.rs b/src/test/run-pass/rec-align-u32.rs index 4c78d9e32c218..0edb0a9670ee1 100644 --- a/src/test/run-pass/rec-align-u32.rs +++ b/src/test/run-pass/rec-align-u32.rs @@ -64,6 +64,6 @@ pub fn main() { // because `inner`s alignment was 4. assert_eq!(mem::size_of::(), m::size()); - assert_eq!(y, "Outer{c8: 22u8, t: Inner{c64: 44u32}}".to_owned()); + assert_eq!(y, "Outer{c8: 22u8, t: Inner{c64: 44u32}}".to_strbuf()); } } diff --git a/src/test/run-pass/rec-align-u64.rs b/src/test/run-pass/rec-align-u64.rs index 8aa67bf2ad650..aeb6adddcac53 100644 --- a/src/test/run-pass/rec-align-u64.rs +++ b/src/test/run-pass/rec-align-u64.rs @@ -86,6 +86,6 @@ pub fn main() { // because `Inner`s alignment was 4. assert_eq!(mem::size_of::(), m::m::size()); - assert_eq!(y, "Outer{c8: 22u8, t: Inner{c64: 44u64}}".to_owned()); + assert_eq!(y, "Outer{c8: 22u8, t: Inner{c64: 44u64}}".to_strbuf()); } } diff --git a/src/test/run-pass/regions-borrow-estr-uniq.rs b/src/test/run-pass/regions-borrow-estr-uniq.rs deleted file mode 100644 index 161e392520ef2..0000000000000 --- a/src/test/run-pass/regions-borrow-estr-uniq.rs +++ /dev/null @@ -1,23 +0,0 @@ -// Copyright 2012 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -fn foo(x: &str) -> u8 { - x[0] -} - -pub fn main() { - let p = "hello".to_owned(); - let r = foo(p); - assert_eq!(r, 'h' as u8); - - let p = "hello".to_owned(); - let r = foo(p); - assert_eq!(r, 'h' as u8); -} diff --git a/src/test/run-pass/send_str_hashmap.rs b/src/test/run-pass/send_str_hashmap.rs index 01ee61e1ed548..869dd3f7ff15f 100644 --- a/src/test/run-pass/send_str_hashmap.rs +++ b/src/test/run-pass/send_str_hashmap.rs @@ -54,18 +54,8 @@ pub fn main() { assert_eq!(map.find_equiv(&("cde")), Some(&c)); assert_eq!(map.find_equiv(&("def")), Some(&d)); - assert_eq!(map.find_equiv(&("abc".to_owned())), Some(&a)); - assert_eq!(map.find_equiv(&("bcd".to_owned())), Some(&b)); - assert_eq!(map.find_equiv(&("cde".to_owned())), Some(&c)); - assert_eq!(map.find_equiv(&("def".to_owned())), Some(&d)); - assert_eq!(map.find_equiv(&Slice("abc")), Some(&a)); assert_eq!(map.find_equiv(&Slice("bcd")), Some(&b)); assert_eq!(map.find_equiv(&Slice("cde")), Some(&c)); assert_eq!(map.find_equiv(&Slice("def")), Some(&d)); - - assert_eq!(map.find_equiv(&Owned("abc".to_owned())), Some(&a)); - assert_eq!(map.find_equiv(&Owned("bcd".to_owned())), Some(&b)); - assert_eq!(map.find_equiv(&Owned("cde".to_owned())), Some(&c)); - assert_eq!(map.find_equiv(&Owned("def".to_owned())), Some(&d)); } diff --git a/src/test/run-pass/signal-exit-status.rs b/src/test/run-pass/signal-exit-status.rs index 174a441ace575..1989b638680c6 100644 --- a/src/test/run-pass/signal-exit-status.rs +++ b/src/test/run-pass/signal-exit-status.rs @@ -26,7 +26,7 @@ use std::io::process::{Command, ExitSignal, ExitStatus}; pub fn main() { let args = os::args(); let args = args.as_slice(); - if args.len() >= 2 && args[1] == "signal".to_owned() { + if args.len() >= 2 && args[1].as_slice() == "signal" { // Raise a segfault. unsafe { *(0 as *mut int) = 0; } } else { diff --git a/src/test/run-pass/str-idx.rs b/src/test/run-pass/str-idx.rs index 7597b02e31b2e..d65eb6415bfc0 100644 --- a/src/test/run-pass/str-idx.rs +++ b/src/test/run-pass/str-idx.rs @@ -12,7 +12,7 @@ pub fn main() { let s = "hello".to_owned(); - let c: u8 = s[4]; + let c: u8 = s.as_slice()[4]; println!("{:?}", c); assert_eq!(c, 0x6f as u8); } diff --git a/src/test/run-pass/super-fast-paren-parsing.rs b/src/test/run-pass/super-fast-paren-parsing.rs index 1204efc29ebd3..26cc43bcfa0ba 100644 --- a/src/test/run-pass/super-fast-paren-parsing.rs +++ b/src/test/run-pass/super-fast-paren-parsing.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// exec-env:RUST_MIN_STACK=8000000 +// exec-env:RUST_MIN_STACK=16000000 // // Big stack is needed for pretty printing, a little sad... diff --git a/src/test/run-pass/syntax-extension-source-utils.rs b/src/test/run-pass/syntax-extension-source-utils.rs index 017b17d0e9c2f..9f58cbbff203a 100644 --- a/src/test/run-pass/syntax-extension-source-utils.rs +++ b/src/test/run-pass/syntax-extension-source-utils.rs @@ -15,17 +15,19 @@ pub mod m1 { pub mod m2 { - pub fn where_am_i() -> StrBuf { (module_path!()).to_strbuf() } + pub fn where_am_i() -> StrBuf { + (module_path!()).to_strbuf() + } } } macro_rules! indirect_line( () => ( line!() ) ) pub fn main() { - assert_eq!(line!(), 25); + assert_eq!(line!(), 27); //assert!((col!() == 11)); - assert_eq!(indirect_line!(), 27); - assert!((file!().to_owned().ends_with("syntax-extension-source-utils.rs"))); + assert_eq!(indirect_line!(), 29); + assert!((file!().ends_with("syntax-extension-source-utils.rs"))); assert_eq!(stringify!((2*3) + 5).to_strbuf(), "( 2 * 3 ) + 5".to_strbuf()); assert!(include!("syntax-extension-source-utils-files/includeme.\ fragment").to_strbuf() diff --git a/src/test/run-pass/tag-align-shape.rs b/src/test/run-pass/tag-align-shape.rs index 4f079da2ff3f3..700cfacb85604 100644 --- a/src/test/run-pass/tag-align-shape.rs +++ b/src/test/run-pass/tag-align-shape.rs @@ -22,5 +22,5 @@ pub fn main() { let x = t_rec {c8: 22u8, t: a_tag(44u64)}; let y = format!("{:?}", x); println!("y = {}", y); - assert_eq!(y, "t_rec{c8: 22u8, t: a_tag(44u64)}".to_owned()); + assert_eq!(y, "t_rec{c8: 22u8, t: a_tag(44u64)}".to_strbuf()); } diff --git a/src/test/run-pass/tag-disr-val-shape.rs b/src/test/run-pass/tag-disr-val-shape.rs index 8c09ba6ba6a65..a795881cd6de2 100644 --- a/src/test/run-pass/tag-disr-val-shape.rs +++ b/src/test/run-pass/tag-disr-val-shape.rs @@ -19,7 +19,7 @@ enum color { pub fn main() { let act = format!("{:?}", red); println!("{}", act); - assert_eq!("red".to_owned(), act); - assert_eq!("green".to_owned(), format!("{:?}", green)); - assert_eq!("white".to_owned(), format!("{:?}", white)); + assert_eq!("red".to_strbuf(), act); + assert_eq!("green".to_strbuf(), format!("{:?}", green)); + assert_eq!("white".to_strbuf(), format!("{:?}", white)); } diff --git a/src/test/run-pass/task-comm-16.rs b/src/test/run-pass/task-comm-16.rs index 47f21a0c60c8f..963121fff8228 100644 --- a/src/test/run-pass/task-comm-16.rs +++ b/src/test/run-pass/task-comm-16.rs @@ -39,10 +39,10 @@ fn test_str() { let s0 = "test".to_owned(); tx.send(s0); let s1 = rx.recv(); - assert_eq!(s1[0], 't' as u8); - assert_eq!(s1[1], 'e' as u8); - assert_eq!(s1[2], 's' as u8); - assert_eq!(s1[3], 't' as u8); + assert_eq!(s1.as_slice()[0], 't' as u8); + assert_eq!(s1.as_slice()[1], 'e' as u8); + assert_eq!(s1.as_slice()[2], 's' as u8); + assert_eq!(s1.as_slice()[3], 't' as u8); } #[deriving(Show)] diff --git a/src/test/run-pass/tcp-connect-timeouts.rs b/src/test/run-pass/tcp-connect-timeouts.rs index 5612c50142caf..6116ed29e1aa8 100644 --- a/src/test/run-pass/tcp-connect-timeouts.rs +++ b/src/test/run-pass/tcp-connect-timeouts.rs @@ -63,7 +63,7 @@ iotest!(fn eventual_timeout() { let (tx1, rx1) = channel(); let (_tx2, rx2) = channel::<()>(); native::task::spawn(proc() { - let _l = TcpListener::bind(host, port).unwrap().listen(); + let _l = TcpListener::bind(host.as_slice(), port).unwrap().listen(); tx1.send(()); let _ = rx2.recv_opt(); }); @@ -84,7 +84,7 @@ iotest!(fn timeout_success() { let addr = next_test_ip4(); let host = addr.ip.to_str(); let port = addr.port; - let _l = TcpListener::bind(host, port).unwrap().listen(); + let _l = TcpListener::bind(host.as_slice(), port).unwrap().listen(); assert!(TcpStream::connect_timeout(addr, 1000).is_ok()); }) diff --git a/src/test/run-pass/tcp-stress.rs b/src/test/run-pass/tcp-stress.rs index f1a609b258498..799d07891db0c 100644 --- a/src/test/run-pass/tcp-stress.rs +++ b/src/test/run-pass/tcp-stress.rs @@ -64,7 +64,7 @@ fn main() { builder.spawn(proc() { let host = addr.ip.to_str(); let port = addr.port; - match TcpStream::connect(host, port) { + match TcpStream::connect(host.as_slice(), port) { Ok(stream) => { let mut stream = stream; stream.write([1]); diff --git a/src/test/run-pass/test-ignore-cfg.rs b/src/test/run-pass/test-ignore-cfg.rs index 309325ab7db4a..c3387a963a701 100644 --- a/src/test/run-pass/test-ignore-cfg.rs +++ b/src/test/run-pass/test-ignore-cfg.rs @@ -27,10 +27,10 @@ fn checktests() { let tests = __test::TESTS; assert!( - tests.iter().any(|t| t.desc.name.to_str() == "shouldignore".to_owned() && + tests.iter().any(|t| t.desc.name.to_str().as_slice() == "shouldignore" && t.desc.ignore)); assert!( - tests.iter().any(|t| t.desc.name.to_str() == "shouldnotignore".to_owned() && + tests.iter().any(|t| t.desc.name.to_str().as_slice() == "shouldnotignore" && !t.desc.ignore)); } diff --git a/src/test/run-pass/vec-to_str.rs b/src/test/run-pass/vec-to_str.rs index 2ec7cac750893..190007a781164 100644 --- a/src/test/run-pass/vec-to_str.rs +++ b/src/test/run-pass/vec-to_str.rs @@ -9,12 +9,12 @@ // except according to those terms. pub fn main() { - assert_eq!((vec!(0, 1)).to_str(), "[0, 1]".to_owned()); - assert_eq!((&[1, 2]).to_str(), "[1, 2]".to_owned()); + assert_eq!((vec!(0, 1)).to_str(), "[0, 1]".to_strbuf()); + assert_eq!((&[1, 2]).to_str(), "[1, 2]".to_strbuf()); let foo = vec!(3, 4); let bar = &[4, 5]; - assert_eq!(foo.to_str(), "[3, 4]".to_owned()); - assert_eq!(bar.to_str(), "[4, 5]".to_owned()); + assert_eq!(foo.to_str(), "[3, 4]".to_strbuf()); + assert_eq!(bar.to_str(), "[4, 5]".to_strbuf()); }