diff options
204 files changed, 2099 insertions, 1493 deletions
diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs index db9cf358a9b..de764d02064 100644 --- a/src/compiletest/compiletest.rs +++ b/src/compiletest/compiletest.rs @@ -96,7 +96,7 @@ pub fn parse_config(args: Vec<StrBuf> ) -> 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<StrBuf> ) -> 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!() } diff --git a/src/compiletest/header.rs b/src/compiletest/header.rs index 5729a11d7ad..55fca1784de 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/runtest.rs b/src/compiletest/runtest.rs index 8c2b34ff35d..d8ca94ab464 100644 --- a/src/compiletest/runtest.rs +++ b/src/compiletest/runtest.rs @@ -538,7 +538,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 @@ -620,18 +621,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/libfmt_macros/lib.rs b/src/libfmt_macros/lib.rs index e12026340d8..0e146505d54 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/libgreen/macros.rs b/src/libgreen/macros.rs index 1921eef9f60..eddf17b34b9 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 dda14fb10af..9f731637a3b 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 5981f87b4f2..a9c0501ee3e 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<directive::LogDirective>) -> bool { +fn enabled(level: u32, + module: &str, + iter: slice::Items<directive::LogDirective>) + -> 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 8ebae70f73c..64b082d9f3f 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/libnum/bigint.rs b/src/libnum/bigint.rs index ecc48d5569c..748eea2ea93 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(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)), } } } diff --git a/src/libnum/complex.rs b/src/libnum/complex.rs index dfbacf6e492..37d9453fabf 100644 --- a/src/libnum/complex.rs +++ b/src/libnum/complex.rs @@ -175,11 +175,15 @@ impl<T: fmt::Show + Num + Ord> fmt::Show for Complex<T> { } impl<T: ToStrRadix + Num + Ord> ToStrRadix for Complex<T> { - 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 cd5c82acf6e..ac1982c3735 100644 --- a/src/libnum/rational.rs +++ b/src/libnum/rational.rs @@ -281,8 +281,10 @@ impl<T: fmt::Show> fmt::Show for Ratio<T> { } impl<T: ToStrRadix> ToStrRadix for Ratio<T> { /// 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)) } } diff --git a/src/libregex/parse/mod.rs b/src/libregex/parse/mod.rs index a695da9fa16..1356cef8768 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()); @@ -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::<u32>(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<Ast, Error> { 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<Ast, Error> { match num::from_str_radix::<u32>(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<uint, Error> { match from_str::<uint>(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<char, Error> { 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_macros/lib.rs b/src/libregex_macros/lib.rs index b85a1592eff..300562e04f2 100644 --- a/src/libregex_macros/lib.rs +++ b/src/libregex_macros/lib.rs @@ -85,7 +85,7 @@ fn native(cx: &mut ExtCtxt, sp: codemap::Span, tts: &[ast::TokenTree]) let re = match Regex::new(regex.to_owned()) { 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<StrBuf> { _ => { 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<StrBuf> { _ => { 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 571959d812a..ba3796211f2 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 429a8f5be5e..cd6e74beb30 100644 --- a/src/librustc/back/link.rs +++ b/src/librustc/back/link.rs @@ -167,7 +167,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 +221,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,8 +363,10 @@ 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()); @@ -369,7 +374,9 @@ pub mod write { } }, 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(); } } @@ -666,7 +673,7 @@ pub fn mangle<PI: Iterator<PathElem>>(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 <len, name> pairs. @@ -774,7 +781,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 +824,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 +834,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 +867,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 +950,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 +971,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 +1020,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 +1033,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,8 +1069,10 @@ 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()); @@ -1058,7 +1080,9 @@ fn link_natively(sess: &Session, trans: &CrateTranslation, dylib: bool, } }, 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 +1094,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 +1433,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 +1443,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 74ac972e5c4..9f12b9d5895 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/driver/config.rs b/src/librustc/driver/config.rs index 4cf33a777ad..e8e970150fd 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}=<value>)", - 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}=<value>)", + 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; @@ -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::<Vec<_>>().append( - matches.opt_strs(level_name).as_slice()); + let flags = matches.opt_strs(level_short.as_slice()) + .move_iter() + .collect::<Vec<_>>() + .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 f51735aface..4e682e8e34b 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<W:io::Writer>(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 06d62c82ce1..eea6b78d3c8 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() { @@ -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=<nodeid>` needs \ - an integer <nodeid>; got {}", - arg.unwrap_or("nothing")).as_slice()) + None => { + sess.fatal(format!("`pretty flowgraph=<nodeid>` needs \ + an integer <nodeid>; got {}", + arg.unwrap_or("nothing")).as_slice()) + } } } _ => { sess.fatal(format!( "argument to `pretty` must be one of `normal`, \ `expanded`, `flowgraph=<nodeid>`, `typed`, `identified`, \ - or `expanded,identified`; got {}", name)); + or `expanded,identified`; got {}", name).as_slice()); } } } @@ -406,9 +409,13 @@ fn monitor(f: proc():Send) { 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 e450fd200a6..19cc3a75e05 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 b6022f56759..ac863d82c9b 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()); } } diff --git a/src/librustc/front/std_inject.rs b/src/librustc/front/std_inject.rs index 92bd81a40f2..efaeeaa5575 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 0ebd392e582..e7a5aeb9ef5 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 5ed8da8a82b..06a043b172f 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<CrateInfo> { 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 2e478419e77..607db8e63c8 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(); } @@ -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(); diff --git a/src/librustc/metadata/loader.rs b/src/librustc/metadata/loader.rs index 456259d1a5d..bcaa3f4c31f 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 { diff --git a/src/librustc/metadata/tydecode.rs b/src/librustc/metadata/tydecode.rs index 0ccb44d2f8c..1a6521c5b5d 100644 --- a/src/librustc/metadata/tydecode.rs +++ b/src/librustc/metadata/tydecode.rs @@ -155,7 +155,10 @@ fn parse_trait_store(st: &mut PState, conv: conv_did) -> 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()) + } } } diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index f46fe9a8b24..8956beb33f4 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 a24e7d66380..65ecec2d2ed 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 b351c99084d..d34ce7f6a5f 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 4662074aa47..925244849bc 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 eaa39ee231d..2060932875d 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()); } } } @@ -710,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, ""); } @@ -739,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()); } } } diff --git a/src/librustc/middle/cfg/construct.rs b/src/librustc/middle/cfg/construct.rs index c9c397d3d61..acf2442f6c1 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 b8baeefd3d0..0d94fdb6e00 100644 --- a/src/librustc/middle/cfg/graphviz.rs +++ b/src/librustc/middle/cfg/graphviz.rs @@ -82,7 +82,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 7da56655378..64b7977c235 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 4f08d818f4a..6e738b14308 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 7b91928ba41..fb797a02795 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<Vec<@Pat> > ; @@ -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 aa0b573eba8..2a1334db2d0 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<T: ty::ExprTyProvider>(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 34a97c15f5c..a1de47f2fa8 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 ae88d64e2f0..b9288fd9fe5 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 2819d7493a6..b3b09ba631e 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 f3977340064..9d735dbaeae 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 81d6fc87a91..64fa1a7270c 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 81e9c3f5ec6..4c381aff1e3 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 d0b7eed6e00..8feacba6e00 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 1954c6d4123..322674a5c9b 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 bd29398e522..3198c0e8398 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 d7aba420864..191ac9aa9a3 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 49e607f1240..3e4ebe845d7 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 ac37af05359..0a7da6e6d08 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 048bbb7d4cd..7065772d74f 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<ast::Lifetime>) { @@ -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 96d26701342..ebce96b0abb 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 e609da6c33d..d86d414da43 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 9cea6d0249c..45baf07c07c 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/base.rs b/src/librustc/middle/trans/base.rs index fc5fcd98ef6..e208097e99b 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<u8> { 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 17667003506..f82a609d695 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 f32aa62d861..fe9581c638e 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 80ee555971d..68e66724d0c 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 80d35d88b21..c804cb77fb2 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 75015bd2d9d..a7bce0019f1 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 b5ab0a391f3..8b43e99b6ac 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 3b3852b3f45..419b4f1e110 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 ff43e4f9abb..48b429c6976 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<NamespaceTree Some(node) => 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 bd25acad21d..024d47ac0ef 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<R>(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<R>(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 fb6aff0e26e..46c987270e3 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. @@ -202,14 +201,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 +369,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 +554,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/intrinsic.rs b/src/librustc/middle/trans/intrinsic.rs index cd28d314772..aeb7a4641c0 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 861caa62515..3076a19228c 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/type_of.rs b/src/librustc/middle/trans/type_of.rs index 9d13fa56e1e..ff485a9cf5d 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 517be1bde2f..6a7ad8f0bd9 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<ty::TraitRef> { 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::<Vec<StrBuf>>())); + .collect::<Vec<StrBuf>>()).as_slice()); } pub fn method_idx(id: ast::Ident, meths: &[Rc<Method>]) -> Option<uint> { @@ -3444,10 +3452,18 @@ pub fn provided_trait_methods(cx: &ctxt, id: ast::DefId) -> Vec<Rc<Method>> { 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<Vec<Rc<VariantInfo>>> { 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<field_ty> { _ => { 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 cb3e900af7d..9cc5d2d73ca 100644 --- a/src/librustc/middle/typeck/astconv.rs +++ b/src/librustc/middle/typeck/astconv.rs @@ -180,7 +180,7 @@ fn ast_path_substs<AC:AstConv,RS:RegionScope>( 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<AC:AstConv,RS:RegionScope>( }; 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<AC:AstConv,RS:RegionScope>( }; 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<ty::t> { 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<AC:AstConv, match ast_ty.node { ast::TyPath(ref path, _, id) => { 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<AC:AstConv, RPtr(r) => { 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<AC:AstConv, RS:RegionScope>( } 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<AC:AstConv, RS:RegionScope>( 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<AC:AstConv, RS:RegionScope>( 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<AC:AstConv, RS:RegionScope>( 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<OwnedSlice<ast::TyPar } tcx.sess.span_fatal( b.path.span, - format!("only the builtin traits can be used \ - as closure or object bounds")); + "only the builtin traits can be used as closure \ + or object bounds"); } ast::StaticRegionTyParamBound => { builtin_bounds.add(ty::BoundStatic); @@ -907,8 +932,8 @@ fn conv_builtin_bounds(tcx: &ty::ctxt, ast_bounds: &Option<OwnedSlice<ast::TyPar if !tcx.sess.features.issue_5723_bootstrap.get() { tcx.sess.span_err( span, - format!("only the 'static lifetime is \ - accepted here.")); + "only the 'static lifetime is accepted \ + here."); } } } diff --git a/src/librustc/middle/typeck/check/_match.rs b/src/librustc/middle/typeck/check/_match.rs index 740539cbddd..6e164d07015 100644 --- a/src/librustc/middle/typeck/check/_match.rs +++ b/src/librustc/middle/typeck/check/_match.rs @@ -263,7 +263,7 @@ pub fn check_pat_variant(pcx: &pat_ctxt, pat: &ast::Pat, path: &ast::Path, npat = subpats_len, kind = kind_name, narg = arg_len); - tcx.sess.span_err(pat.span, s); + tcx.sess.span_err(pat.span, s.as_slice()); error_happened = true; } @@ -280,7 +280,7 @@ pub fn check_pat_variant(pcx: &pat_ctxt, pat: &ast::Pat, path: &ast::Path, {npat, plural, =1{# field} other{# fields}}, \ but the corresponding {kind} has no fields", npat = subpats_len, - kind = kind_name)); + kind = kind_name).as_slice()); error_happened = true; } @@ -324,7 +324,7 @@ pub fn check_struct_pat_fields(pcx: &pat_ctxt, Some(&(_, true)) => { 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 9e8edfccd5b..d512de670bc 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 820c5bd859c..cc9bff89947 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<T>(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 d8da67fff7f..34e8b5e169f 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 04facc1426d..5e67cb54ccc 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 993a678bd26..133fc9b1530 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 d80e9f08888..042bebf573f 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 c70204098e0..447f8dfa278 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<ty::TraitDef> { 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<ty::TraitDef> { 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 d50e36c31a0..819a69cfad1 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 84df7230544..d80e8400a3a 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<C:Combine>(this: &C, a: ty::t, b: ty::t) -> cres<ty::t> { (_, &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 6f99a0a5ffb..6b6b9fab5c6 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 5ca5945a4f4..73684a63ac1 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 ebfb17a8876..41a59dae740 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<T:Combine>(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 7ba2210a2c4..1df16f86801 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 30eb928a979..7fed5e4ee1a 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 24265d342eb..1178e1dfa46 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::<Vec<ty::Region>>() - .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::<Vec<ty::Region>>() - .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 2ee4f8fedd2..f36b9862850 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 165c573d056..253ab22d470 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 42850f88763..a6bf8e109c4 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/util/ppaux.rs b/src/librustc/util/ppaux.rs index 95ae05985d3..982ccceb5ee 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(' '); } }; diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs index 948d47b2eaf..133e8c64042 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(">"); } @@ -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/render.rs b/src/librustdoc/html/render.rs index 752f193fa3f..94bd4d818b4 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(), }; @@ -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 48db910fc39..984ef458c8f 100644 --- a/src/librustdoc/lib.rs +++ b/src/librustdoc/lib.rs @@ -132,7 +132,7 @@ pub fn opts() -> Vec<getopts::OptGroup> { pub fn usage(argv0: &str) { println!("{}", - getopts::usage(format!("{} [options] <input>", argv0), + getopts::usage(format!("{} [options] <input>", argv0).as_slice(), opts().as_slice())); } diff --git a/src/librustdoc/markdown.rs b/src/librustdoc/markdown.rs index e43e7d69a2d..de9c2839e73 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!("<link rel=\"stylesheet\" type=\"text/css\" href=\"{}\">\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/test.rs b/src/librustdoc/test.rs index 5b4a9bd27b7..949cd17fe9a 100644 --- a/src/librustdoc/test.rs +++ b/src/librustdoc/test.rs @@ -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") { diff --git a/src/librustuv/lib.rs b/src/librustuv/lib.rs index 0a6a305a3b7..857e07a2af1 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 104efbeab0a..3a387972ff7 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/libstd/ascii.rs b/src/libstd/ascii.rs index e087b3d1774..8240211a839 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<Ascii> { - let v: ~[u8] = mem::transmute(self); + let v: Vec<u8> = 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<Ascii> = self.as_slice().iter().map(|x| *x).collect(); + vector.into_str() } } impl IntoStr for Vec<Ascii> { #[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 { +unsafe fn str_copy_map_bytes(string: &str, map: &'static [u8]) -> StrBuf { let mut s = string.to_owned(); for b in str::raw::as_owned_vec(&mut s).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())) + 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())) + 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()))); 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/comm/mod.rs b/src/libstd/comm/mod.rs index fd5b92ba469..b2521f2978a 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::<uint>(val).unwrap(), + Some(val) => from_str::<uint>(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::<uint>(val).unwrap(), + Some(val) => from_str::<uint>(val.as_slice()).unwrap(), None => 1, } } diff --git a/src/libstd/fmt.rs b/src/libstd/fmt.rs index 86b77a46a39..db23a5f1720 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<T> 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 a510aa90343..1dad1667ebd 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<S> for &'a str { } } -impl<S: Writer> Hash<S> for ~str { - #[inline] - fn hash(&self, state: &mut S) { - self.as_slice().hash(state); - } -} - macro_rules! impl_hash_tuple( () => ( impl<S: Writer> Hash<S> for () { diff --git a/src/libstd/hash/sip.rs b/src/libstd/hash/sip.rs index 58e0f4c717d..1434e3c7ad7 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 2880365cf34..c7b0d660624 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 a497ffd40a0..6feaf10d5c5 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::<u32>())); + let ret = os::tmpdir().join( + format_strbuf!("rust-{}", rand::random::<u32>())); check!(io::fs::mkdir(&ret, io::UserRWX)); TempDir(ret) } @@ -952,9 +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_str = + (prefix + n.to_str().into_owned()).to_owned(); let msg = msg_str.as_bytes(); check!(w.write(msg)); } @@ -1039,7 +1041,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 +1058,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 92b546d5770..c1e228cd693 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 a043722581b..50bd3e7067c 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<StrBuf> = 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<StrBuf> } 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<uint> { 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<u8>) -> IoResult<uint> { 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<StrBuf> { 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<IoResult<~str>> for Lines<'r, T> { - fn next(&mut self) -> Option<IoResult<~str>> { +impl<'r, T: Buffer> Iterator<IoResult<StrBuf>> for Lines<'r, T> { + fn next(&mut self) -> Option<IoResult<StrBuf>> { 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<StrBuf> { 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 f469c419e8e..4bf71b5480e 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 dec68b9d89e..ac17bc1de13 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 fc760e6fe4c..f1f3e0a468a 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,18 @@ 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.contains(format!("{}={}", + *k, + *v).as_slice()) || + output.contains(format!("{}=\'{}\'", + *k, + *v).as_slice())); } } }) @@ -835,9 +841,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 991f3992dd1..3a103651d63 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 b4fb95c8af7..806df838c91 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 dd874fecc52..de8a6f4beb5 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 a9ec9c1ddc5..b9181793051 100644 --- a/src/libstd/lib.rs +++ b/src/libstd/lib.rs @@ -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 1a971594837..8798c035fca 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<StrBuf> = &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<StrBuf> = &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<StrBuf> = &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<StrBuf> = &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<StrBuf> = &Key; static box_key: Key<@()> = &Key; static int_key: Key<int> = &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<StrBuf> = &Key; static box_key: Key<@()> = &Key; static int_key: Key<int> = &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<StrBuf> = &Key; static box_key: Key<@()> = &Key; static int_key: Key<int> = &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 e9ea0df2a7b..66d93c230a5 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 869a275b1d4..be4e4dc0d66 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 396037d0dba..7d08c181e9e 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 5640e82d077..2504d3f5766 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 40245691e34..7fc6a091dfc 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 7ddddd893e2..a39a6ced077 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 dc4d80601b7..2a23a35be6d 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 ddff42f68db..31a0edfbc38 100644 --- a/src/libstd/num/int_macros.rs +++ b/src/libstd/num/int_macros.rs @@ -77,8 +77,8 @@ pub fn to_str_bytes<U>(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 40167718236..c1d6bbb492d 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 e58872b8395..795534dc283 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<T:NumCast+Zero+One+Eq+Ord+NumStrConv+Float+ Div<T,T>+Neg<T>+Rem<T,T>+Mul<T,T>>( 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 65ac46af5aa..6d68af99890 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 d549e4d0d63..130ca2c4855 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 3773e56f4d1..559fcf6e7d1 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 372e38d6652..f855c8c4951 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 c419276fa24..f651cf72cca 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 7977c647606..ba329065a6e 100644 --- a/src/libstd/num/uint_macros.rs +++ b/src/libstd/num/uint_macros.rs @@ -78,8 +78,8 @@ pub fn to_str_bytes<U>(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 a4705b78caa..349f50b8ac7 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, CloneableVector, 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)] @@ -108,7 +109,7 @@ pub mod win32 { use vec::Vec; pub fn fill_utf16_buf_and_decode(f: |*mut u16, DWORD| -> DWORD) - -> Option<~str> { + -> Option<StrBuf> { unsafe { let mut n = TMPBUF_SZ as DWORD; @@ -174,10 +175,10 @@ fn with_env_lock<T>(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).to_strbuf(); + let v = str::from_utf8_lossy(v).to_strbuf(); (k,v) }).collect() } @@ -273,8 +274,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<StrBuf> { + getenv_as_bytes(n).map(|v| str::from_utf8_lossy(v).to_strbuf()) } #[cfg(unix)] @@ -302,7 +303,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<StrBuf> { unsafe { with_env_lock(|| { use os::win32::{as_utf16_p, fill_utf16_buf_and_decode}; @@ -432,8 +433,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 @@ -688,11 +689,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 +733,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 +790,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) } @@ -851,12 +852,14 @@ 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<StrBuf> { + real_args_as_bytes().move_iter() + .map(|v| str::from_utf8_lossy(v).into_strbuf()) + .collect() } #[cfg(windows)] -fn real_args() -> Vec<~str> { +fn real_args() -> Vec<StrBuf> { use slice; use option::Expect; @@ -910,10 +913,17 @@ 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<StrBuf> { 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]> { @@ -1509,37 +1519,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 +1557,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 +1599,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 +1610,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 +1622,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 +1651,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] diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs index 2960d55f337..1bd099e5d24 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<u8> { - 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 4f7132dc6e4..8a939a92846 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 176788edcc4..1c671b30e80 100644 --- a/src/libstd/path/windows.rs +++ b/src/libstd/path/windows.rs @@ -136,10 +136,17 @@ impl<'a> ToCStr for &'a Path { } impl<S: Writer> ::hash::Hash<S> 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<Path> { } 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 35f32d08728..8da906d8521 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<T>(writer: &mut io::Writer, object: &T) -> io::IoResult<()> { } } -pub fn repr_to_str<T>(t: &T) -> ~str { +pub fn repr_to_str<T>(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/env.rs b/src/libstd/rt/env.rs index 708c42030ab..c9e5cae60e4 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 74675c85b96..aef41de925f 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 8968747d990..749f44d1c9d 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 af87a31b7bd..8f2df831196 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<Any:Send>, { let msg_s = match msg.as_ref::<&'static str>() { Some(s) => *s, - None => match msg.as_ref::<~str>() { + None => match msg.as_ref::<StrBuf>() { Some(s) => s.as_slice(), None => "Box<Any>", } diff --git a/src/libstd/rt/util.rs b/src/libstd/rt/util.rs index c9e82bd16e5..7aebb6e4796 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<uint> = FromStr::from_str(nstr); + let opt_n: Option<uint> = 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) diff --git a/src/libstd/slice.rs b/src/libstd/slice.rs index 0838211b9a5..ae1caa16d28 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 617887e8af3..0b4db05545c 100644 --- a/src/libstd/str.rs +++ b/src/libstd/str.rs @@ -569,7 +569,9 @@ impl<'a> IntoMaybeOwned<'a> for ~str { 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.into_owned()) + } } impl<'a> IntoMaybeOwned<'a> for &'a str { @@ -657,7 +659,7 @@ impl<'a, H: Writer> ::hash::Hash<H> 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), } } } @@ -1085,7 +1087,7 @@ mod tests { #[test] fn test_concat() { fn t(v: &[~str], s: &str) { - assert_eq!(v.concat(), s.to_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"); @@ -1097,7 +1099,7 @@ mod tests { #[test] fn test_connect() { 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".to_owned(), "know".to_owned(), "I'm".to_owned(), "no".to_owned(), "good".to_owned()], @@ -1110,7 +1112,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 +1123,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"); @@ -2176,16 +2178,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 de480ef1b7f..bb5b94d86fa 100644 --- a/src/libstd/strbuf.rs +++ b/src/libstd/strbuf.rs @@ -12,6 +12,7 @@ use c_vec::CVec; use char::Char; +use cmp::Equiv; use container::{Container, Mutable}; use fmt; use io::Writer; @@ -337,6 +338,13 @@ impl<H:Writer> ::hash::Hash<H> for StrBuf { } } +impl<'a, S: Str> Equiv<S> for StrBuf { + #[inline] + fn equiv(&self, other: &S) -> bool { + self.as_slice() == other.as_slice() + } +} + #[cfg(test)] mod tests { extern crate test; diff --git a/src/libstd/task.rs b/src/libstd/task.rs index 5c875b4a2ad..314f659550d 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::<T>()); - assert_eq!(*e.move::<T>().unwrap(), "owned string".to_owned()); + assert_eq!(*e.move::<T>().unwrap(), "owned string".to_strbuf()); } Ok(()) => fail!() } diff --git a/src/libstd/to_str.rs b/src/libstd/to_str.rs index 4132c8a5b5a..fbc4227e726 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<T: fmt::Show> 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 d50c63c5832..f73ebc2255b 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<T: ToCStr>(filename: Option<T>) - -> Result<DynamicLibrary, ~str> { + -> Result<DynamicLibrary, StrBuf> { unsafe { let mut filename = filename; let maybe_library = dl::check_for_errors_in(|| { @@ -128,7 +129,7 @@ impl DynamicLibrary { } /// Access the value at the symbol of the dynamic library - pub unsafe fn symbol<T>(&self, symbol: &str) -> Result<T, ~str> { + pub unsafe fn symbol<T>(&self, symbol: &str) -> Result<T, StrBuf> { // This function should have a lifetime constraint of 'a on // T but that feature is still unimplemented @@ -203,10 +204,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<T: ToCStr>(filename: T) -> *u8 { filename.with_c_str(|raw_name| { @@ -218,7 +221,7 @@ pub mod dl { dlopen(ptr::null(), Lazy as libc::c_int) as *u8 } - pub fn check_for_errors_in<T>(f: || -> T) -> Result<T, ~str> { + pub fn check_for_errors_in<T>(f: || -> T) -> Result<T, StrBuf> { use unstable::mutex::{StaticNativeMutex, NATIVE_MUTEX_INIT}; static mut lock: StaticNativeMutex = NATIVE_MUTEX_INIT; unsafe { @@ -233,7 +236,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 @@ -287,7 +292,7 @@ pub mod dl { handle as *u8 } - pub fn check_for_errors_in<T>(f: || -> T) -> Result<T, ~str> { + pub fn check_for_errors_in<T>(f: || -> T) -> Result<T, StrBuf> { unsafe { SetLastError(0); diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs index 32883707615..1776b6fbe6e 100644 --- a/src/libstd/vec.rs +++ b/src/libstd/vec.rs @@ -671,7 +671,7 @@ impl<T> Vec<T> { /// ```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 5a57c2d6cc6..bc660798240 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 b7700cf396d..c2b5804ecee 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) diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs index 3eb6f40ba53..aa8f397f747 100644 --- a/src/libsyntax/diagnostic.rs +++ b/src/libsyntax/diagnostic.rs @@ -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); @@ -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(()) } @@ -495,7 +498,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 b9c8be290ca..2fa1c13f5d7 100644 --- a/src/libsyntax/ext/asm.rs +++ b/src/libsyntax/ext/asm.rs @@ -208,7 +208,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 { diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index 06b56bbe472..854f1d02219 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<StrBuf> { 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 7c6c9892002..314d63c2d3b 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"); diff --git a/src/libsyntax/ext/deriving/bounds.rs b/src/libsyntax/ext/deriving/bounds.rs index b5b2667f892..d90c7f37213 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 51024158822..89c94891b33 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::<Vec<_>>(); diff --git a/src/libsyntax/ext/deriving/decodable.rs b/src/libsyntax/ext/deriving/decodable.rs index 2447535f1f3..172ae8dca62 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 75b051b2f10..b8a3eea0014 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 6df4da89402..0875daddc0f 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 1187e83308b..aeff36a49e6 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 8dbfbc53cec..d1a4d2f3ee3 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 e3b1037ccc0..989d0a463c3 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 01124fdfa54..ad4b798cfe5 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/source_util.rs b/src/libsyntax/ext/source_util.rs index 6bc08741c07..52f262b052b 100644 --- a/src/libsyntax/ext/source_util.rs +++ b/src/libsyntax/ext/source_util.rs @@ -111,7 +111,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 +130,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 +147,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_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs index 7ff690582d6..f234b0c234d 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 1f264e73d4a..6d799eeae6c 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<NamedMatch> { 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 80ee459a62d..6f17412fa63 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/mod.rs b/src/libsyntax/parse/mod.rs index 8e139b049c5..31a67ff92f5 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<Span>) 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<Span>) 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 b6aa47128e6..394b68d4a72 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 5829f63b2c5..6bddb45201c 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()) } } } @@ -4260,12 +4273,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()); } } } @@ -4348,12 +4368,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 +4440,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 +4609,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 +4667,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 +4693,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 +5100,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 f08cf264f8b..b334aa63270 100644 --- a/src/libsyntax/print/pp.rs +++ b/src/libsyntax/print/pp.rs @@ -135,7 +135,9 @@ pub fn buf_str(toks: Vec<Token>, 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 15b931d5854..785ab6be0dd 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -623,7 +623,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)); @@ -2247,7 +2247,7 @@ 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, @@ -2261,8 +2261,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 +2359,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<comments::Comment> { @@ -2389,7 +2399,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 +2410,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 +2426,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 36e5c1cf763..7562bf2d163 100644 --- a/src/libterm/terminfo/mod.rs +++ b/src/libterm/terminfo/mod.rs @@ -81,9 +81,11 @@ impl<T: Writer> Terminal<T> for TerminfoTerminal<T> { } }; - 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/searcher.rs b/src/libterm/terminfo/searcher.rs index a7365102f96..ac5737c46ed 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<Box<Path>> { 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 06b1126ed05..80517328c26 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<T: Writer> ConsoleTestState<T> { 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<T: Writer> ConsoleTestState<T> { 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,7 +621,7 @@ impl<T: Writer> ConsoleTestState<T> { 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("\n"); @@ -633,7 +635,8 @@ impl<T: Writer> ConsoleTestState<T> { 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 +654,26 @@ impl<T: Writer> ConsoleTestState<T> { 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 +681,7 @@ impl<T: Writer> ConsoleTestState<T> { {} 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 +699,13 @@ impl<T: Writer> ConsoleTestState<T> { 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 +729,7 @@ impl<T: Writer> ConsoleTestState<T> { } 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); } } @@ -813,7 +818,7 @@ pub fn run_tests_console(opts: &TestOpts, tests: Vec<TestDescAndFn> ) -> 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 +941,7 @@ fn get_concurrency() -> uint { use std::rt; match os::getenv("RUST_TEST_TASKS") { Some(s) => { - let opt_n: Option<uint> = FromStr::from_str(s); + let opt_n: Option<uint> = 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/liburl/lib.rs b/src/liburl/lib.rs index 5fc567f06d3..e75afa04cd4 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, Vec<StrBuf>>) -> 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 d2032b9d492..b546935939f 100644 --- a/src/libuuid/lib.rs +++ b/src/libuuid/lib.rs @@ -326,8 +326,8 @@ impl Uuid { let mut s: Vec<u8> = 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() } diff --git a/src/test/run-fail/assert-macro-owned.rs b/src/test/run-fail/assert-macro-owned.rs index 9dec60e488d..bbbe29cc134 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 7b5d263071b..9160b760c92 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/unwind-misc-1.rs b/src/test/run-fail/unwind-misc-1.rs index fae1a8a1773..f160b925525 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-pass/backtrace.rs b/src/test/run-pass/backtrace.rs index 25df896ec15..5e7b9d9560e 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 bb101140ec3..636e879fe32 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 c409852c673..0c372deae2c 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 99f97a41907..c94887f16a9 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 41650b68051..1bcc8bbc2b7 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 18800ac0438..7254ed7d530 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 12ed4830c82..f028d871c20 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::<E>(), 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 5c71d90c159..b4bd4a8201e 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 f97afa2f3e0..efe0e0de40e 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 330ba896062..9c9f0e82d14 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 c43c22d592c..a033fc01df3 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 ee142aa8e6d..ca2420bc573 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 ea10bc038f0..044087ec0ca 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 cdc07c02677..cc63b622398 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/process-spawn-with-unicode-params.rs b/src/test/run-pass/process-spawn-with-unicode-params.rs index 5e1f9bbaf0c..cdbb1fe84dc 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 4c78d9e32c2..0edb0a9670e 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::<Outer>(), 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 8aa67bf2ad6..aeb6adddcac 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::<Outer>(), 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/send_str_hashmap.rs b/src/test/run-pass/send_str_hashmap.rs index 01ee61e1ed5..869dd3f7ff1 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 174a441ace5..1989b638680 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/tag-align-shape.rs b/src/test/run-pass/tag-align-shape.rs index 4f079da2ff3..700cfacb856 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 8c09ba6ba6a..a795881cd6d 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/tcp-connect-timeouts.rs b/src/test/run-pass/tcp-connect-timeouts.rs index 5612c50142c..6116ed29e1a 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 f1a609b2584..799d07891db 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 309325ab7db..c3387a963a7 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 2ec7cac7508..190007a7811 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()); } |