libstd: Remove `~str` from all `libstd` modules except `fmt` and `str`.

15 files changed, 147 insertions, 94 deletions

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());
                     }
                 }
             }